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