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