drivers/hwmon/lm78.c

   1 /*
   2  * lm78.c - Part of lm_sensors, Linux kernel modules for hardware
   3  *          monitoring
   4  * Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
   5  * Copyright (c) 2007, 2011  Jean Delvare <khali@linux-fr.org>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  23
  24 #include <linux/module.h>
  25 #include <linux/init.h>
  26 #include <linux/slab.h>
  27 #include <linux/jiffies.h>
  28 #include <linux/i2c.h>
  29 #include <linux/hwmon.h>
  30 #include <linux/hwmon-vid.h>
  31 #include <linux/hwmon-sysfs.h>
  32 #include <linux/err.h>
  33 #include <linux/mutex.h>
  34
  35 #ifdef CONFIG_ISA
  36 #include <linux/platform_device.h>
  37 #include <linux/ioport.h>
  38 #include <linux/io.h>
  39 #endif
  40
  41 /* Addresses to scan */
  42 static const unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
  43                                                 0x2e, 0x2f, I2C_CLIENT_END };
  44 enum chips { lm78, lm79 };
  45
  46 /* Many LM78 constants specified below */
  47
  48 /* Length of ISA address segment */
  49 #define LM78_EXTENT 8
  50
  51 /* Where are the ISA address/data registers relative to the base address */
  52 #define LM78_ADDR_REG_OFFSET 5
  53 #define LM78_DATA_REG_OFFSET 6
  54
  55 /* The LM78 registers */
  56 #define LM78_REG_IN_MAX(nr) (0x2b + (nr) * 2)
  57 #define LM78_REG_IN_MIN(nr) (0x2c + (nr) * 2)
  58 #define LM78_REG_IN(nr) (0x20 + (nr))
  59
  60 #define LM78_REG_FAN_MIN(nr) (0x3b + (nr))
  61 #define LM78_REG_FAN(nr) (0x28 + (nr))
  62
  63 #define LM78_REG_TEMP 0x27
  64 #define LM78_REG_TEMP_OVER 0x39
  65 #define LM78_REG_TEMP_HYST 0x3a
  66
  67 #define LM78_REG_ALARM1 0x41
  68 #define LM78_REG_ALARM2 0x42
  69
  70 #define LM78_REG_VID_FANDIV 0x47
  71
  72 #define LM78_REG_CONFIG 0x40
  73 #define LM78_REG_CHIPID 0x49
  74 #define LM78_REG_I2C_ADDR 0x48
  75
  76
  77 /*
  78  * Conversions. Rounding and limit checking is only done on the TO_REG
  79  * variants.
  80  */
  81
  82 /*
  83  * IN: mV (0V to 4.08V)
  84  * REG: 16mV/bit
  85  */
  86 static inline u8 IN_TO_REG(unsigned long val)
  87 {
  88         unsigned long nval = SENSORS_LIMIT(val, 0, 4080);
  89         return (nval + 8) / 16;
  90 }
  91 #define IN_FROM_REG(val) ((val) *  16)
  92
  93 static inline u8 FAN_TO_REG(long rpm, int div)
  94 {
  95         if (rpm <= 0)
  96                 return 255;
  97         return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
  98 }
  99
 100 static inline int FAN_FROM_REG(u8 val, int div)
 101 {
 102         return val == 0 ? -1 : val == 255 ? 0 : 1350000 / (val * div);
 103 }
 104
 105 /*
 106  * TEMP: mC (-128C to +127C)
 107  * REG: 1C/bit, two's complement
 108  */
 109 static inline s8 TEMP_TO_REG(int val)
 110 {
 111         int nval = SENSORS_LIMIT(val, -128000, 127000) ;
 112         return nval < 0 ? (nval - 500) / 1000 : (nval + 500) / 1000;
 113 }
 114
 115 static inline int TEMP_FROM_REG(s8 val)
 116 {
 117         return val * 1000;
 118 }
 119
 120 #define DIV_FROM_REG(val) (1 << (val))
 121
 122 struct lm78_data {
 123         struct i2c_client *client;
 124         struct device *hwmon_dev;
 125         struct mutex lock;
 126         enum chips type;
 127
 128         /* For ISA device only */
 129         const char *name;
 130         int isa_addr;
 131
 132         struct mutex update_lock;
 133         char valid;             /* !=0 if following fields are valid */
 134         unsigned long last_updated;     /* In jiffies */
 135
 136         u8 in[7];               /* Register value */
 137         u8 in_max[7];           /* Register value */
 138         u8 in_min[7];           /* Register value */
 139         u8 fan[3];              /* Register value */
 140         u8 fan_min[3];          /* Register value */
 141         s8 temp;                /* Register value */
 142         s8 temp_over;           /* Register value */
 143         s8 temp_hyst;           /* Register value */
 144         u8 fan_div[3];          /* Register encoding, shifted right */
 145         u8 vid;                 /* Register encoding, combined */
 146         u16 alarms;             /* Register encoding, combined */
 147 };
 148
 149
 150 static int lm78_read_value(struct lm78_data *data, u8 reg);
 151 static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value);
 152 static struct lm78_data *lm78_update_device(struct device *dev);
 153 static void lm78_init_device(struct lm78_data *data);
 154
 155
 156 /* 7 Voltages */
 157 static ssize_t show_in(struct device *dev, struct device_attribute *da,
 158                        char *buf)
 159 {
 160         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 161         struct lm78_data *data = lm78_update_device(dev);
 162         return sprintf(buf, "%d\n", IN_FROM_REG(data->in[attr->index]));
 163 }
 164
 165 static ssize_t show_in_min(struct device *dev, struct device_attribute *da,
 166                            char *buf)
 167 {
 168         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 169         struct lm78_data *data = lm78_update_device(dev);
 170         return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[attr->index]));
 171 }
 172
 173 static ssize_t show_in_max(struct device *dev, struct device_attribute *da,
 174                            char *buf)
 175 {
 176         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 177         struct lm78_data *data = lm78_update_device(dev);
 178         return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[attr->index]));
 179 }
 180
 181 static ssize_t set_in_min(struct device *dev, struct device_attribute *da,
 182                           const char *buf, size_t count)
 183 {
 184         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 185         struct lm78_data *data = dev_get_drvdata(dev);
 186         int nr = attr->index;
 187         unsigned long val;
 188         int err;
 189
 190         err = kstrtoul(buf, 10, &val);
 191         if (err)
 192                 return err;
 193
 194         mutex_lock(&data->update_lock);
 195         data->in_min[nr] = IN_TO_REG(val);
 196         lm78_write_value(data, LM78_REG_IN_MIN(nr), data->in_min[nr]);
 197         mutex_unlock(&data->update_lock);
 198         return count;
 199 }
 200
 201 static ssize_t set_in_max(struct device *dev, struct device_attribute *da,
 202                           const char *buf, size_t count)
 203 {
 204         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 205         struct lm78_data *data = dev_get_drvdata(dev);
 206         int nr = attr->index;
 207         unsigned long val;
 208         int err;
 209
 210         err = kstrtoul(buf, 10, &val);
 211         if (err)
 212                 return err;
 213
 214         mutex_lock(&data->update_lock);
 215         data->in_max[nr] = IN_TO_REG(val);
 216         lm78_write_value(data, LM78_REG_IN_MAX(nr), data->in_max[nr]);
 217         mutex_unlock(&data->update_lock);
 218         return count;
 219 }
 220
 221 #define show_in_offset(offset)                                  \
 222 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO,          \
 223                 show_in, NULL, offset);                         \
 224 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,  \
 225                 show_in_min, set_in_min, offset);               \
 226 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,  \
 227                 show_in_max, set_in_max, offset);
 228
 229 show_in_offset(0);
 230 show_in_offset(1);
 231 show_in_offset(2);
 232 show_in_offset(3);
 233 show_in_offset(4);
 234 show_in_offset(5);
 235 show_in_offset(6);
 236
 237 /* Temperature */
 238 static ssize_t show_temp(struct device *dev, struct device_attribute *da,
 239                          char *buf)
 240 {
 241         struct lm78_data *data = lm78_update_device(dev);
 242         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));
 243 }
 244
 245 static ssize_t show_temp_over(struct device *dev, struct device_attribute *da,
 246                               char *buf)
 247 {
 248         struct lm78_data *data = lm78_update_device(dev);
 249         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
 250 }
 251
 252 static ssize_t set_temp_over(struct device *dev, struct device_attribute *da,
 253                              const char *buf, size_t count)
 254 {
 255         struct lm78_data *data = dev_get_drvdata(dev);
 256         long val;
 257         int err;
 258
 259         err = kstrtol(buf, 10, &val);
 260         if (err)
 261                 return err;
 262
 263         mutex_lock(&data->update_lock);
 264         data->temp_over = TEMP_TO_REG(val);
 265         lm78_write_value(data, LM78_REG_TEMP_OVER, data->temp_over);
 266         mutex_unlock(&data->update_lock);
 267         return count;
 268 }
 269
 270 static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *da,
 271                               char *buf)
 272 {
 273         struct lm78_data *data = lm78_update_device(dev);
 274         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
 275 }
 276
 277 static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *da,
 278                              const char *buf, size_t count)
 279 {
 280         struct lm78_data *data = dev_get_drvdata(dev);
 281         long val;
 282         int err;
 283
 284         err = kstrtol(buf, 10, &val);
 285         if (err)
 286                 return err;
 287
 288         mutex_lock(&data->update_lock);
 289         data->temp_hyst = TEMP_TO_REG(val);
 290         lm78_write_value(data, LM78_REG_TEMP_HYST, data->temp_hyst);
 291         mutex_unlock(&data->update_lock);
 292         return count;
 293 }
 294
 295 static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL);
 296 static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
 297                 show_temp_over, set_temp_over);
 298 static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
 299                 show_temp_hyst, set_temp_hyst);
 300
 301 /* 3 Fans */
 302 static ssize_t show_fan(struct device *dev, struct device_attribute *da,
 303                         char *buf)
 304 {
 305         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 306         struct lm78_data *data = lm78_update_device(dev);
 307         int nr = attr->index;
 308         return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
 309                 DIV_FROM_REG(data->fan_div[nr])));
 310 }
 311
 312 static ssize_t show_fan_min(struct device *dev, struct device_attribute *da,
 313                             char *buf)
 314 {
 315         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 316         struct lm78_data *data = lm78_update_device(dev);
 317         int nr = attr->index;
 318         return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr],
 319                 DIV_FROM_REG(data->fan_div[nr])));
 320 }
 321
 322 static ssize_t set_fan_min(struct device *dev, struct device_attribute *da,
 323                            const char *buf, size_t count)
 324 {
 325         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 326         struct lm78_data *data = dev_get_drvdata(dev);
 327         int nr = attr->index;
 328         unsigned long val;
 329         int err;
 330
 331         err = kstrtoul(buf, 10, &val);
 332         if (err)
 333                 return err;
 334
 335         mutex_lock(&data->update_lock);
 336         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
 337         lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
 338         mutex_unlock(&data->update_lock);
 339         return count;
 340 }
 341
 342 static ssize_t show_fan_div(struct device *dev, struct device_attribute *da,
 343                             char *buf)
 344 {
 345         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 346         struct lm78_data *data = lm78_update_device(dev);
 347         return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[attr->index]));
 348 }
 349
 350 /*
 351  * Note: we save and restore the fan minimum here, because its value is
 352  * determined in part by the fan divisor.  This follows the principle of
 353  * least surprise; the user doesn't expect the fan minimum to change just
 354  * because the divisor changed.
 355  */
 356 static ssize_t set_fan_div(struct device *dev, struct device_attribute *da,
 357                            const char *buf, size_t count)
 358 {
 359         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 360         struct lm78_data *data = dev_get_drvdata(dev);
 361         int nr = attr->index;
 362         unsigned long min;
 363         u8 reg;
 364         unsigned long val;
 365         int err;
 366
 367         err = kstrtoul(buf, 10, &val);
 368         if (err)
 369                 return err;
 370
 371         mutex_lock(&data->update_lock);
 372         min = FAN_FROM_REG(data->fan_min[nr],
 373                            DIV_FROM_REG(data->fan_div[nr]));
 374
 375         switch (val) {
 376         case 1:
 377                 data->fan_div[nr] = 0;
 378                 break;
 379         case 2:
 380                 data->fan_div[nr] = 1;
 381                 break;
 382         case 4:
 383                 data->fan_div[nr] = 2;
 384                 break;
 385         case 8:
 386                 data->fan_div[nr] = 3;
 387                 break;
 388         default:
 389                 dev_err(dev, "fan_div value %ld not "
 390                         "supported. Choose one of 1, 2, 4 or 8!\n", val);
 391                 mutex_unlock(&data->update_lock);
 392                 return -EINVAL;
 393         }
 394
 395         reg = lm78_read_value(data, LM78_REG_VID_FANDIV);
 396         switch (nr) {
 397         case 0:
 398                 reg = (reg & 0xcf) | (data->fan_div[nr] << 4);
 399                 break;
 400         case 1:
 401                 reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
 402                 break;
 403         }
 404         lm78_write_value(data, LM78_REG_VID_FANDIV, reg);
 405
 406         data->fan_min[nr] =
 407                 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
 408         lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
 409         mutex_unlock(&data->update_lock);
 410
 411         return count;
 412 }
 413
 414 #define show_fan_offset(offset)                         \
 415 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO,         \
 416                 show_fan, NULL, offset - 1);                    \
 417 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
 418                 show_fan_min, set_fan_min, offset - 1);
 419
 420 show_fan_offset(1);
 421 show_fan_offset(2);
 422 show_fan_offset(3);
 423
 424 /* Fan 3 divisor is locked in H/W */
 425 static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
 426                 show_fan_div, set_fan_div, 0);
 427 static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
 428                 show_fan_div, set_fan_div, 1);
 429 static SENSOR_DEVICE_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2);
 430
 431 /* VID */
 432 static ssize_t show_vid(struct device *dev, struct device_attribute *da,
 433                         char *buf)
 434 {
 435         struct lm78_data *data = lm78_update_device(dev);
 436         return sprintf(buf, "%d\n", vid_from_reg(data->vid, 82));
 437 }
 438 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
 439
 440 /* Alarms */
 441 static ssize_t show_alarms(struct device *dev, struct device_attribute *da,
 442                            char *buf)
 443 {
 444         struct lm78_data *data = lm78_update_device(dev);
 445         return sprintf(buf, "%u\n", data->alarms);
 446 }
 447 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 448
 449 static ssize_t show_alarm(struct device *dev, struct device_attribute *da,
 450                           char *buf)
 451 {
 452         struct lm78_data *data = lm78_update_device(dev);
 453         int nr = to_sensor_dev_attr(da)->index;
 454         return sprintf(buf, "%u\n", (data->alarms >> nr) & 1);
 455 }
 456 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
 457 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
 458 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
 459 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
 460 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
 461 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9);
 462 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 10);
 463 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
 464 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
 465 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11);
 466 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4);
 467
 468 static struct attribute *lm78_attributes[] = {
 469         &sensor_dev_attr_in0_input.dev_attr.attr,
 470         &sensor_dev_attr_in0_min.dev_attr.attr,
 471         &sensor_dev_attr_in0_max.dev_attr.attr,
 472         &sensor_dev_attr_in0_alarm.dev_attr.attr,
 473         &sensor_dev_attr_in1_input.dev_attr.attr,
 474         &sensor_dev_attr_in1_min.dev_attr.attr,
 475         &sensor_dev_attr_in1_max.dev_attr.attr,
 476         &sensor_dev_attr_in1_alarm.dev_attr.attr,
 477         &sensor_dev_attr_in2_input.dev_attr.attr,
 478         &sensor_dev_attr_in2_min.dev_attr.attr,
 479         &sensor_dev_attr_in2_max.dev_attr.attr,
 480         &sensor_dev_attr_in2_alarm.dev_attr.attr,
 481         &sensor_dev_attr_in3_input.dev_attr.attr,
 482         &sensor_dev_attr_in3_min.dev_attr.attr,
 483         &sensor_dev_attr_in3_max.dev_attr.attr,
 484         &sensor_dev_attr_in3_alarm.dev_attr.attr,
 485         &sensor_dev_attr_in4_input.dev_attr.attr,
 486         &sensor_dev_attr_in4_min.dev_attr.attr,
 487         &sensor_dev_attr_in4_max.dev_attr.attr,
 488         &sensor_dev_attr_in4_alarm.dev_attr.attr,
 489         &sensor_dev_attr_in5_input.dev_attr.attr,
 490         &sensor_dev_attr_in5_min.dev_attr.attr,
 491         &sensor_dev_attr_in5_max.dev_attr.attr,
 492         &sensor_dev_attr_in5_alarm.dev_attr.attr,
 493         &sensor_dev_attr_in6_input.dev_attr.attr,
 494         &sensor_dev_attr_in6_min.dev_attr.attr,
 495         &sensor_dev_attr_in6_max.dev_attr.attr,
 496         &sensor_dev_attr_in6_alarm.dev_attr.attr,
 497         &dev_attr_temp1_input.attr,
 498         &dev_attr_temp1_max.attr,
 499         &dev_attr_temp1_max_hyst.attr,
 500         &sensor_dev_attr_temp1_alarm.dev_attr.attr,
 501         &sensor_dev_attr_fan1_input.dev_attr.attr,
 502         &sensor_dev_attr_fan1_min.dev_attr.attr,
 503         &sensor_dev_attr_fan1_div.dev_attr.attr,
 504         &sensor_dev_attr_fan1_alarm.dev_attr.attr,
 505         &sensor_dev_attr_fan2_input.dev_attr.attr,
 506         &sensor_dev_attr_fan2_min.dev_attr.attr,
 507         &sensor_dev_attr_fan2_div.dev_attr.attr,
 508         &sensor_dev_attr_fan2_alarm.dev_attr.attr,
 509         &sensor_dev_attr_fan3_input.dev_attr.attr,
 510         &sensor_dev_attr_fan3_min.dev_attr.attr,
 511         &sensor_dev_attr_fan3_div.dev_attr.attr,
 512         &sensor_dev_attr_fan3_alarm.dev_attr.attr,
 513         &dev_attr_alarms.attr,
 514         &dev_attr_cpu0_vid.attr,
 515
 516         NULL
 517 };
 518
 519 static const struct attribute_group lm78_group = {
 520         .attrs = lm78_attributes,
 521 };
 522
 523 /*
 524  * ISA related code
 525  */
 526 #ifdef CONFIG_ISA
 527
 528 /* ISA device, if found */
 529 static struct platform_device *pdev;
 530
 531 static unsigned short isa_address = 0x290;
 532
 533 /*
 534  * I2C devices get this name attribute automatically, but for ISA devices
 535  * we must create it by ourselves.
 536  */
 537 static ssize_t show_name(struct device *dev, struct device_attribute
 538                          *devattr, char *buf)
 539 {
 540         struct lm78_data *data = dev_get_drvdata(dev);
 541
 542         return sprintf(buf, "%s\n", data->name);
 543 }
 544 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
 545
 546 static struct lm78_data *lm78_data_if_isa(void)
 547 {
 548         return pdev ? platform_get_drvdata(pdev) : NULL;
 549 }
 550
 551 /* Returns 1 if the I2C chip appears to be an alias of the ISA chip */
 552 static int lm78_alias_detect(struct i2c_client *client, u8 chipid)
 553 {
 554         struct lm78_data *isa;
 555         int i;
 556
 557         if (!pdev)      /* No ISA chip */
 558                 return 0;
 559         isa = platform_get_drvdata(pdev);
 560
 561         if (lm78_read_value(isa, LM78_REG_I2C_ADDR) != client->addr)
 562                 return 0;       /* Address doesn't match */
 563         if ((lm78_read_value(isa, LM78_REG_CHIPID) & 0xfe) != (chipid & 0xfe))
 564                 return 0;       /* Chip type doesn't match */
 565
 566         /*
 567          * We compare all the limit registers, the config register and the
 568          * interrupt mask registers
 569          */
 570         for (i = 0x2b; i <= 0x3d; i++) {
 571                 if (lm78_read_value(isa, i) !=
 572                     i2c_smbus_read_byte_data(client, i))
 573                         return 0;
 574         }
 575         if (lm78_read_value(isa, LM78_REG_CONFIG) !=
 576             i2c_smbus_read_byte_data(client, LM78_REG_CONFIG))
 577                 return 0;
 578         for (i = 0x43; i <= 0x46; i++) {
 579                 if (lm78_read_value(isa, i) !=
 580                     i2c_smbus_read_byte_data(client, i))
 581                         return 0;
 582         }
 583
 584         return 1;
 585 }
 586 #else /* !CONFIG_ISA */
 587
 588 static int lm78_alias_detect(struct i2c_client *client, u8 chipid)
 589 {
 590         return 0;
 591 }
 592
 593 static struct lm78_data *lm78_data_if_isa(void)
 594 {
 595         return NULL;
 596 }
 597 #endif /* CONFIG_ISA */
 598
 599 static int lm78_i2c_detect(struct i2c_client *client,
 600                            struct i2c_board_info *info)
 601 {
 602         int i;
 603         struct lm78_data *isa = lm78_data_if_isa();
 604         const char *client_name;
 605         struct i2c_adapter *adapter = client->adapter;
 606         int address = client->addr;
 607
 608         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 609                 return -ENODEV;
 610
 611         /*
 612          * We block updates of the ISA device to minimize the risk of
 613          * concurrent access to the same LM78 chip through different
 614          * interfaces.
 615          */
 616         if (isa)
 617                 mutex_lock(&isa->update_lock);
 618
 619         if ((i2c_smbus_read_byte_data(client, LM78_REG_CONFIG) & 0x80)
 620          || i2c_smbus_read_byte_data(client, LM78_REG_I2C_ADDR) != address)
 621                 goto err_nodev;
 622
 623         /* Explicitly prevent the misdetection of Winbond chips */
 624         i = i2c_smbus_read_byte_data(client, 0x4f);
 625         if (i == 0xa3 || i == 0x5c)
 626                 goto err_nodev;
 627
 628         /* Determine the chip type. */
 629         i = i2c_smbus_read_byte_data(client, LM78_REG_CHIPID);
 630         if (i == 0x00 || i == 0x20      /* LM78 */
 631          || i == 0x40)                  /* LM78-J */
 632                 client_name = "lm78";
 633         else if ((i & 0xfe) == 0xc0)
 634                 client_name = "lm79";
 635         else
 636                 goto err_nodev;
 637
 638         if (lm78_alias_detect(client, i)) {
 639                 dev_dbg(&adapter->dev, "Device at 0x%02x appears to "
 640                         "be the same as ISA device\n", address);
 641                 goto err_nodev;
 642         }
 643
 644         if (isa)
 645                 mutex_unlock(&isa->update_lock);
 646
 647         strlcpy(info->type, client_name, I2C_NAME_SIZE);
 648
 649         return 0;
 650
 651  err_nodev:
 652         if (isa)
 653                 mutex_unlock(&isa->update_lock);
 654         return -ENODEV;
 655 }
 656
 657 static int lm78_i2c_probe(struct i2c_client *client,
 658                           const struct i2c_device_id *id)
 659 {
 660         struct lm78_data *data;
 661         int err;
 662
 663         data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL);
 664         if (!data)
 665                 return -ENOMEM;
 666
 667         i2c_set_clientdata(client, data);
 668         data->client = client;
 669         data->type = id->driver_data;
 670
 671         /* Initialize the LM78 chip */
 672         lm78_init_device(data);
 673
 674         /* Register sysfs hooks */
 675         err = sysfs_create_group(&client->dev.kobj, &lm78_group);
 676         if (err)
 677                 goto ERROR3;
 678
 679         data->hwmon_dev = hwmon_device_register(&client->dev);
 680         if (IS_ERR(data->hwmon_dev)) {
 681                 err = PTR_ERR(data->hwmon_dev);
 682                 goto ERROR4;
 683         }
 684
 685         return 0;
 686
 687 ERROR4:
 688         sysfs_remove_group(&client->dev.kobj, &lm78_group);
 689 ERROR3:
 690         kfree(data);
 691         return err;
 692 }
 693
 694 static int lm78_i2c_remove(struct i2c_client *client)
 695 {
 696         struct lm78_data *data = i2c_get_clientdata(client);
 697
 698         hwmon_device_unregister(data->hwmon_dev);
 699         sysfs_remove_group(&client->dev.kobj, &lm78_group);
 700         kfree(data);
 701
 702         return 0;
 703 }
 704
 705 static const struct i2c_device_id lm78_i2c_id[] = {
 706         { "lm78", lm78 },
 707         { "lm79", lm79 },
 708         { }
 709 };
 710 MODULE_DEVICE_TABLE(i2c, lm78_i2c_id);
 711
 712 static struct i2c_driver lm78_driver = {
 713         .class          = I2C_CLASS_HWMON,
 714         .driver = {
 715                 .name   = "lm78",
 716         },
 717         .probe          = lm78_i2c_probe,
 718         .remove         = lm78_i2c_remove,
 719         .id_table       = lm78_i2c_id,
 720         .detect         = lm78_i2c_detect,
 721         .address_list   = normal_i2c,
 722 };
 723
 724 /*
 725  * The SMBus locks itself, but ISA access must be locked explicitly!
 726  * We don't want to lock the whole ISA bus, so we lock each client
 727  * separately.
 728  * We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
 729  * would slow down the LM78 access and should not be necessary.
 730  */
 731 static int lm78_read_value(struct lm78_data *data, u8 reg)
 732 {
 733         struct i2c_client *client = data->client;
 734
 735 #ifdef CONFIG_ISA
 736         if (!client) { /* ISA device */
 737                 int res;
 738                 mutex_lock(&data->lock);
 739                 outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
 740                 res = inb_p(data->isa_addr + LM78_DATA_REG_OFFSET);
 741                 mutex_unlock(&data->lock);
 742                 return res;
 743         } else
 744 #endif
 745                 return i2c_smbus_read_byte_data(client, reg);
 746 }
 747
 748 static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value)
 749 {
 750         struct i2c_client *client = data->client;
 751
 752 #ifdef CONFIG_ISA
 753         if (!client) { /* ISA device */
 754                 mutex_lock(&data->lock);
 755                 outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
 756                 outb_p(value, data->isa_addr + LM78_DATA_REG_OFFSET);
 757                 mutex_unlock(&data->lock);
 758                 return 0;
 759         } else
 760 #endif
 761                 return i2c_smbus_write_byte_data(client, reg, value);
 762 }
 763
 764 static void lm78_init_device(struct lm78_data *data)
 765 {
 766         u8 config;
 767         int i;
 768
 769         /* Start monitoring */
 770         config = lm78_read_value(data, LM78_REG_CONFIG);
 771         if ((config & 0x09) != 0x01)
 772                 lm78_write_value(data, LM78_REG_CONFIG,
 773                                  (config & 0xf7) | 0x01);
 774
 775         /* A few vars need to be filled upon startup */
 776         for (i = 0; i < 3; i++) {
 777                 data->fan_min[i] = lm78_read_value(data,
 778                                         LM78_REG_FAN_MIN(i));
 779         }
 780
 781         mutex_init(&data->update_lock);
 782 }
 783
 784 static struct lm78_data *lm78_update_device(struct device *dev)
 785 {
 786         struct lm78_data *data = dev_get_drvdata(dev);
 787         int i;
 788
 789         mutex_lock(&data->update_lock);
 790
 791         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
 792             || !data->valid) {
 793
 794                 dev_dbg(dev, "Starting lm78 update\n");
 795
 796                 for (i = 0; i <= 6; i++) {
 797                         data->in[i] =
 798                             lm78_read_value(data, LM78_REG_IN(i));
 799                         data->in_min[i] =
 800                             lm78_read_value(data, LM78_REG_IN_MIN(i));
 801                         data->in_max[i] =
 802                             lm78_read_value(data, LM78_REG_IN_MAX(i));
 803                 }
 804                 for (i = 0; i < 3; i++) {
 805                         data->fan[i] =
 806                             lm78_read_value(data, LM78_REG_FAN(i));
 807                         data->fan_min[i] =
 808                             lm78_read_value(data, LM78_REG_FAN_MIN(i));
 809                 }
 810                 data->temp = lm78_read_value(data, LM78_REG_TEMP);
 811                 data->temp_over =
 812                     lm78_read_value(data, LM78_REG_TEMP_OVER);
 813                 data->temp_hyst =
 814                     lm78_read_value(data, LM78_REG_TEMP_HYST);
 815                 i = lm78_read_value(data, LM78_REG_VID_FANDIV);
 816                 data->vid = i & 0x0f;
 817                 if (data->type == lm79)
 818                         data->vid |=
 819                             (lm78_read_value(data, LM78_REG_CHIPID) &
 820                              0x01) << 4;
 821                 else
 822                         data->vid |= 0x10;
 823                 data->fan_div[0] = (i >> 4) & 0x03;
 824                 data->fan_div[1] = i >> 6;
 825                 data->alarms = lm78_read_value(data, LM78_REG_ALARM1) +
 826                     (lm78_read_value(data, LM78_REG_ALARM2) << 8);
 827                 data->last_updated = jiffies;
 828                 data->valid = 1;
 829
 830                 data->fan_div[2] = 1;
 831         }
 832
 833         mutex_unlock(&data->update_lock);
 834
 835         return data;
 836 }
 837
 838 #ifdef CONFIG_ISA
 839 static int __devinit lm78_isa_probe(struct platform_device *pdev)
 840 {
 841         int err;
 842         struct lm78_data *data;
 843         struct resource *res;
 844
 845         /* Reserve the ISA region */
 846         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
 847         if (!request_region(res->start + LM78_ADDR_REG_OFFSET, 2, "lm78")) {
 848                 err = -EBUSY;
 849                 goto exit;
 850         }
 851
 852         data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL);
 853         if (!data) {
 854                 err = -ENOMEM;
 855                 goto exit_release_region;
 856         }
 857         mutex_init(&data->lock);
 858         data->isa_addr = res->start;
 859         platform_set_drvdata(pdev, data);
 860
 861         if (lm78_read_value(data, LM78_REG_CHIPID) & 0x80) {
 862                 data->type = lm79;
 863                 data->name = "lm79";
 864         } else {
 865                 data->type = lm78;
 866                 data->name = "lm78";
 867         }
 868
 869         /* Initialize the LM78 chip */
 870         lm78_init_device(data);
 871
 872         /* Register sysfs hooks */
 873         err = sysfs_create_group(&pdev->dev.kobj, &lm78_group);
 874         if (err)
 875                 goto exit_remove_files;
 876         err = device_create_file(&pdev->dev, &dev_attr_name);
 877         if (err)
 878                 goto exit_remove_files;
 879
 880         data->hwmon_dev = hwmon_device_register(&pdev->dev);
 881         if (IS_ERR(data->hwmon_dev)) {
 882                 err = PTR_ERR(data->hwmon_dev);
 883                 goto exit_remove_files;
 884         }
 885
 886         return 0;
 887
 888  exit_remove_files:
 889         sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
 890         device_remove_file(&pdev->dev, &dev_attr_name);
 891         kfree(data);
 892  exit_release_region:
 893         release_region(res->start + LM78_ADDR_REG_OFFSET, 2);
 894  exit:
 895         return err;
 896 }
 897
 898 static int __devexit lm78_isa_remove(struct platform_device *pdev)
 899 {
 900         struct lm78_data *data = platform_get_drvdata(pdev);
 901         struct resource *res;
 902
 903         hwmon_device_unregister(data->hwmon_dev);
 904         sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
 905         device_remove_file(&pdev->dev, &dev_attr_name);
 906         kfree(data);
 907
 908         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
 909         release_region(res->start + LM78_ADDR_REG_OFFSET, 2);
 910
 911         return 0;
 912 }
 913
 914 static struct platform_driver lm78_isa_driver = {
 915         .driver = {
 916                 .owner  = THIS_MODULE,
 917                 .name   = "lm78",
 918         },
 919         .probe          = lm78_isa_probe,
 920         .remove         = __devexit_p(lm78_isa_remove),
 921 };
 922
 923 /* return 1 if a supported chip is found, 0 otherwise */
 924 static int __init lm78_isa_found(unsigned short address)
 925 {
 926         int val, save, found = 0;
 927         int port;
 928
 929         /*
 930          * Some boards declare base+0 to base+7 as a PNP device, some base+4
 931          * to base+7 and some base+5 to base+6. So we better request each port
 932          * individually for the probing phase.
 933          */
 934         for (port = address; port < address + LM78_EXTENT; port++) {
 935                 if (!request_region(port, 1, "lm78")) {
 936                         pr_debug("Failed to request port 0x%x\n", port);
 937                         goto release;
 938                 }
 939         }
 940
 941 #define REALLY_SLOW_IO
 942         /*
 943          * We need the timeouts for at least some LM78-like
 944          * chips. But only if we read 'undefined' registers.
 945          */
 946         val = inb_p(address + 1);
 947         if (inb_p(address + 2) != val
 948          || inb_p(address + 3) != val
 949          || inb_p(address + 7) != val)
 950                 goto release;
 951 #undef REALLY_SLOW_IO
 952
 953         /*
 954          * We should be able to change the 7 LSB of the address port. The
 955          * MSB (busy flag) should be clear initially, set after the write.
 956          */
 957         save = inb_p(address + LM78_ADDR_REG_OFFSET);
 958         if (save & 0x80)
 959                 goto release;
 960         val = ~save & 0x7f;
 961         outb_p(val, address + LM78_ADDR_REG_OFFSET);
 962         if (inb_p(address + LM78_ADDR_REG_OFFSET) != (val | 0x80)) {
 963                 outb_p(save, address + LM78_ADDR_REG_OFFSET);
 964                 goto release;
 965         }
 966
 967         /* We found a device, now see if it could be an LM78 */
 968         outb_p(LM78_REG_CONFIG, address + LM78_ADDR_REG_OFFSET);
 969         val = inb_p(address + LM78_DATA_REG_OFFSET);
 970         if (val & 0x80)
 971                 goto release;
 972         outb_p(LM78_REG_I2C_ADDR, address + LM78_ADDR_REG_OFFSET);
 973         val = inb_p(address + LM78_DATA_REG_OFFSET);
 974         if (val < 0x03 || val > 0x77)   /* Not a valid I2C address */
 975                 goto release;
 976
 977         /* The busy flag should be clear again */
 978         if (inb_p(address + LM78_ADDR_REG_OFFSET) & 0x80)
 979                 goto release;
 980
 981         /* Explicitly prevent the misdetection of Winbond chips */
 982         outb_p(0x4f, address + LM78_ADDR_REG_OFFSET);
 983         val = inb_p(address + LM78_DATA_REG_OFFSET);
 984         if (val == 0xa3 || val == 0x5c)
 985                 goto release;
 986
 987         /* Explicitly prevent the misdetection of ITE chips */
 988         outb_p(0x58, address + LM78_ADDR_REG_OFFSET);
 989         val = inb_p(address + LM78_DATA_REG_OFFSET);
 990         if (val == 0x90)
 991                 goto release;
 992
 993         /* Determine the chip type */
 994         outb_p(LM78_REG_CHIPID, address + LM78_ADDR_REG_OFFSET);
 995         val = inb_p(address + LM78_DATA_REG_OFFSET);
 996         if (val == 0x00 || val == 0x20  /* LM78 */
 997          || val == 0x40                 /* LM78-J */
 998          || (val & 0xfe) == 0xc0)       /* LM79 */
 999                 found = 1;
1000
1001         if (found)
1002                 pr_info("Found an %s chip at %#x\n",
1003                         val & 0x80 ? "LM79" : "LM78", (int)address);
1004
1005  release:
1006         for (port--; port >= address; port--)
1007                 release_region(port, 1);
1008         return found;
1009 }
1010
1011 static int __init lm78_isa_device_add(unsigned short address)
1012 {
1013         struct resource res = {
1014                 .start  = address,
1015                 .end    = address + LM78_EXTENT - 1,
1016                 .name   = "lm78",
1017                 .flags  = IORESOURCE_IO,
1018         };
1019         int err;
1020
1021         pdev = platform_device_alloc("lm78", address);
1022         if (!pdev) {
1023                 err = -ENOMEM;
1024                 pr_err("Device allocation failed\n");
1025                 goto exit;
1026         }
1027
1028         err = platform_device_add_resources(pdev, &res, 1);
1029         if (err) {
1030                 pr_err("Device resource addition failed (%d)\n", err);
1031                 goto exit_device_put;
1032         }
1033
1034         err = platform_device_add(pdev);
1035         if (err) {
1036                 pr_err("Device addition failed (%d)\n", err);
1037                 goto exit_device_put;
1038         }
1039
1040         return 0;
1041
1042  exit_device_put:
1043         platform_device_put(pdev);
1044  exit:
1045         pdev = NULL;
1046         return err;
1047 }
1048
1049 static int __init lm78_isa_register(void)
1050 {
1051         int res;
1052
1053         if (lm78_isa_found(isa_address)) {
1054                 res = platform_driver_register(&lm78_isa_driver);
1055                 if (res)
1056                         goto exit;
1057
1058                 /* Sets global pdev as a side effect */
1059                 res = lm78_isa_device_add(isa_address);
1060                 if (res)
1061                         goto exit_unreg_isa_driver;
1062         }
1063
1064         return 0;
1065
1066  exit_unreg_isa_driver:
1067         platform_driver_unregister(&lm78_isa_driver);
1068  exit:
1069         return res;
1070 }
1071
1072 static void lm78_isa_unregister(void)
1073 {
1074         if (pdev) {
1075                 platform_device_unregister(pdev);
1076                 platform_driver_unregister(&lm78_isa_driver);
1077         }
1078 }
1079 #else /* !CONFIG_ISA */
1080
1081 static int __init lm78_isa_register(void)
1082 {
1083         return 0;
1084 }
1085
1086 static void lm78_isa_unregister(void)
1087 {
1088 }
1089 #endif /* CONFIG_ISA */
1090
1091 static int __init sm_lm78_init(void)
1092 {
1093         int res;
1094
1095         /*
1096          * We register the ISA device first, so that we can skip the
1097          * registration of an I2C interface to the same device.
1098          */
1099         res = lm78_isa_register();
1100         if (res)
1101                 goto exit;
1102
1103         res = i2c_add_driver(&lm78_driver);
1104         if (res)
1105                 goto exit_unreg_isa_device;
1106
1107         return 0;
1108
1109  exit_unreg_isa_device:
1110         lm78_isa_unregister();
1111  exit:
1112         return res;
1113 }
1114
1115 static void __exit sm_lm78_exit(void)
1116 {
1117         lm78_isa_unregister();
1118         i2c_del_driver(&lm78_driver);
1119 }
1120
1121 MODULE_AUTHOR("Frodo Looijaard, Jean Delvare <khali@linux-fr.org>");
1122 MODULE_DESCRIPTION("LM78/LM79 driver");
1123 MODULE_LICENSE("GPL");
1124
1125 module_init(sm_lm78_init);
1126 module_exit(sm_lm78_exit);