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