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