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        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/platform_device.h>
  30 #include <linux/ioport.h>
  31 #include <linux/hwmon.h>
  32 #include <linux/hwmon-vid.h>
  33 #include <linux/hwmon-sysfs.h>
  34 #include <linux/err.h>
  35 #include <linux/mutex.h>
  36 #include <linux/io.h>
  37
  38 /* ISA device, if found */
  39 static struct platform_device *pdev;
  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 static unsigned short isa_address = 0x290;
  45
  46 enum chips { lm78, lm79 };
  47
  48 /* Many LM78 constants specified below */
  49
  50 /* Length of ISA address segment */
  51 #define LM78_EXTENT 8
  52
  53 /* Where are the ISA address/data registers relative to the base address */
  54 #define LM78_ADDR_REG_OFFSET 5
  55 #define LM78_DATA_REG_OFFSET 6
  56
  57 /* The LM78 registers */
  58 #define LM78_REG_IN_MAX(nr) (0x2b + (nr) * 2)
  59 #define LM78_REG_IN_MIN(nr) (0x2c + (nr) * 2)
  60 #define LM78_REG_IN(nr) (0x20 + (nr))
  61
  62 #define LM78_REG_FAN_MIN(nr) (0x3b + (nr))
  63 #define LM78_REG_FAN(nr) (0x28 + (nr))
  64
  65 #define LM78_REG_TEMP 0x27
  66 #define LM78_REG_TEMP_OVER 0x39
  67 #define LM78_REG_TEMP_HYST 0x3a
  68
  69 #define LM78_REG_ALARM1 0x41
  70 #define LM78_REG_ALARM2 0x42
  71
  72 #define LM78_REG_VID_FANDIV 0x47
  73
  74 #define LM78_REG_CONFIG 0x40
  75 #define LM78_REG_CHIPID 0x49
  76 #define LM78_REG_I2C_ADDR 0x48
  77
  78
  79 /* Conversions. Rounding and limit checking is only done on the TO_REG
  80    variants. */
  81
  82 /* IN: mV, (0V to 4.08V)
  83    REG: 16mV/bit */
  84 static inline u8 IN_TO_REG(unsigned long val)
  85 {
  86         unsigned long nval = SENSORS_LIMIT(val, 0, 4080);
  87         return (nval + 8) / 16;
  88 }
  89 #define IN_FROM_REG(val) ((val) *  16)
  90
  91 static inline u8 FAN_TO_REG(long rpm, int div)
  92 {
  93         if (rpm <= 0)
  94                 return 255;
  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(int 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 /* I2C devices get this name attribute automatically, but for ISA devices
 480    we must create it by ourselves. */
 481 static ssize_t show_name(struct device *dev, struct device_attribute
 482                          *devattr, char *buf)
 483 {
 484         struct lm78_data *data = dev_get_drvdata(dev);
 485
 486         return sprintf(buf, "%s\n", data->name);
 487 }
 488 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
 489
 490 /* Returns 1 if the I2C chip appears to be an alias of the ISA chip */
 491 static int lm78_alias_detect(struct i2c_client *client, u8 chipid)
 492 {
 493         struct lm78_data *isa;
 494         int i;
 495
 496         if (!pdev)      /* No ISA chip */
 497                 return 0;
 498         isa = platform_get_drvdata(pdev);
 499
 500         if (lm78_read_value(isa, LM78_REG_I2C_ADDR) != client->addr)
 501                 return 0;       /* Address doesn't match */
 502         if ((lm78_read_value(isa, LM78_REG_CHIPID) & 0xfe) != (chipid & 0xfe))
 503                 return 0;       /* Chip type doesn't match */
 504
 505         /* We compare all the limit registers, the config register and the
 506          * interrupt mask registers */
 507         for (i = 0x2b; i <= 0x3d; i++) {
 508                 if (lm78_read_value(isa, i) !=
 509                     i2c_smbus_read_byte_data(client, i))
 510                         return 0;
 511         }
 512         if (lm78_read_value(isa, LM78_REG_CONFIG) !=
 513             i2c_smbus_read_byte_data(client, LM78_REG_CONFIG))
 514                 return 0;
 515         for (i = 0x43; i <= 0x46; i++) {
 516                 if (lm78_read_value(isa, i) !=
 517                     i2c_smbus_read_byte_data(client, i))
 518                         return 0;
 519         }
 520
 521         return 1;
 522 }
 523
 524 static int lm78_i2c_detect(struct i2c_client *client,
 525                            struct i2c_board_info *info)
 526 {
 527         int i;
 528         struct lm78_data *isa = pdev ? platform_get_drvdata(pdev) : NULL;
 529         const char *client_name;
 530         struct i2c_adapter *adapter = client->adapter;
 531         int address = client->addr;
 532
 533         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 534                 return -ENODEV;
 535
 536         /* We block updates of the ISA device to minimize the risk of
 537            concurrent access to the same LM78 chip through different
 538            interfaces. */
 539         if (isa)
 540                 mutex_lock(&isa->update_lock);
 541
 542         if ((i2c_smbus_read_byte_data(client, LM78_REG_CONFIG) & 0x80)
 543          || i2c_smbus_read_byte_data(client, LM78_REG_I2C_ADDR) != address)
 544                 goto err_nodev;
 545
 546         /* Explicitly prevent the misdetection of Winbond chips */
 547         i = i2c_smbus_read_byte_data(client, 0x4f);
 548         if (i == 0xa3 || i == 0x5c)
 549                 goto err_nodev;
 550
 551         /* Determine the chip type. */
 552         i = i2c_smbus_read_byte_data(client, LM78_REG_CHIPID);
 553         if (i == 0x00 || i == 0x20      /* LM78 */
 554          || i == 0x40)                  /* LM78-J */
 555                 client_name = "lm78";
 556         else if ((i & 0xfe) == 0xc0)
 557                 client_name = "lm79";
 558         else
 559                 goto err_nodev;
 560
 561         if (lm78_alias_detect(client, i)) {
 562                 dev_dbg(&adapter->dev, "Device at 0x%02x appears to "
 563                         "be the same as ISA device\n", address);
 564                 goto err_nodev;
 565         }
 566
 567         if (isa)
 568                 mutex_unlock(&isa->update_lock);
 569
 570         strlcpy(info->type, client_name, I2C_NAME_SIZE);
 571
 572         return 0;
 573
 574  err_nodev:
 575         if (isa)
 576                 mutex_unlock(&isa->update_lock);
 577         return -ENODEV;
 578 }
 579
 580 static int lm78_i2c_probe(struct i2c_client *client,
 581                           const struct i2c_device_id *id)
 582 {
 583         struct lm78_data *data;
 584         int err;
 585
 586         data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL);
 587         if (!data)
 588                 return -ENOMEM;
 589
 590         i2c_set_clientdata(client, data);
 591         data->client = client;
 592         data->type = id->driver_data;
 593
 594         /* Initialize the LM78 chip */
 595         lm78_init_device(data);
 596
 597         /* Register sysfs hooks */
 598         err = sysfs_create_group(&client->dev.kobj, &lm78_group);
 599         if (err)
 600                 goto ERROR3;
 601
 602         data->hwmon_dev = hwmon_device_register(&client->dev);
 603         if (IS_ERR(data->hwmon_dev)) {
 604                 err = PTR_ERR(data->hwmon_dev);
 605                 goto ERROR4;
 606         }
 607
 608         return 0;
 609
 610 ERROR4:
 611         sysfs_remove_group(&client->dev.kobj, &lm78_group);
 612 ERROR3:
 613         kfree(data);
 614         return err;
 615 }
 616
 617 static int lm78_i2c_remove(struct i2c_client *client)
 618 {
 619         struct lm78_data *data = i2c_get_clientdata(client);
 620
 621         hwmon_device_unregister(data->hwmon_dev);
 622         sysfs_remove_group(&client->dev.kobj, &lm78_group);
 623         kfree(data);
 624
 625         return 0;
 626 }
 627
 628 static const struct i2c_device_id lm78_i2c_id[] = {
 629         { "lm78", lm78 },
 630         { "lm79", lm79 },
 631         { }
 632 };
 633 MODULE_DEVICE_TABLE(i2c, lm78_i2c_id);
 634
 635 static struct i2c_driver lm78_driver = {
 636         .class          = I2C_CLASS_HWMON,
 637         .driver = {
 638                 .name   = "lm78",
 639         },
 640         .probe          = lm78_i2c_probe,
 641         .remove         = lm78_i2c_remove,
 642         .id_table       = lm78_i2c_id,
 643         .detect         = lm78_i2c_detect,
 644         .address_list   = normal_i2c,
 645 };
 646
 647 /* The SMBus locks itself, but ISA access must be locked explicitly!
 648    We don't want to lock the whole ISA bus, so we lock each client
 649    separately.
 650    We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
 651    would slow down the LM78 access and should not be necessary.  */
 652 static int lm78_read_value(struct lm78_data *data, u8 reg)
 653 {
 654         struct i2c_client *client = data->client;
 655
 656         if (!client) { /* ISA device */
 657                 int res;
 658                 mutex_lock(&data->lock);
 659                 outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
 660                 res = inb_p(data->isa_addr + LM78_DATA_REG_OFFSET);
 661                 mutex_unlock(&data->lock);
 662                 return res;
 663         } else
 664                 return i2c_smbus_read_byte_data(client, reg);
 665 }
 666
 667 /* The SMBus locks itself, but ISA access muse be locked explicitly!
 668    We don't want to lock the whole ISA bus, so we lock each client
 669    separately.
 670    We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
 671    would slow down the LM78 access and should not be necessary.
 672    There are some ugly typecasts here, but the good new is - they should
 673    nowhere else be necessary! */
 674 static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value)
 675 {
 676         struct i2c_client *client = data->client;
 677
 678         if (!client) { /* ISA device */
 679                 mutex_lock(&data->lock);
 680                 outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
 681                 outb_p(value, data->isa_addr + LM78_DATA_REG_OFFSET);
 682                 mutex_unlock(&data->lock);
 683                 return 0;
 684         } else
 685                 return i2c_smbus_write_byte_data(client, reg, value);
 686 }
 687
 688 static void lm78_init_device(struct lm78_data *data)
 689 {
 690         u8 config;
 691         int i;
 692
 693         /* Start monitoring */
 694         config = lm78_read_value(data, LM78_REG_CONFIG);
 695         if ((config & 0x09) != 0x01)
 696                 lm78_write_value(data, LM78_REG_CONFIG,
 697                                  (config & 0xf7) | 0x01);
 698
 699         /* A few vars need to be filled upon startup */
 700         for (i = 0; i < 3; i++) {
 701                 data->fan_min[i] = lm78_read_value(data,
 702                                         LM78_REG_FAN_MIN(i));
 703         }
 704
 705         mutex_init(&data->update_lock);
 706 }
 707
 708 static struct lm78_data *lm78_update_device(struct device *dev)
 709 {
 710         struct lm78_data *data = dev_get_drvdata(dev);
 711         int i;
 712
 713         mutex_lock(&data->update_lock);
 714
 715         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
 716             || !data->valid) {
 717
 718                 dev_dbg(dev, "Starting lm78 update\n");
 719
 720                 for (i = 0; i <= 6; i++) {
 721                         data->in[i] =
 722                             lm78_read_value(data, LM78_REG_IN(i));
 723                         data->in_min[i] =
 724                             lm78_read_value(data, LM78_REG_IN_MIN(i));
 725                         data->in_max[i] =
 726                             lm78_read_value(data, LM78_REG_IN_MAX(i));
 727                 }
 728                 for (i = 0; i < 3; i++) {
 729                         data->fan[i] =
 730                             lm78_read_value(data, LM78_REG_FAN(i));
 731                         data->fan_min[i] =
 732                             lm78_read_value(data, LM78_REG_FAN_MIN(i));
 733                 }
 734                 data->temp = lm78_read_value(data, LM78_REG_TEMP);
 735                 data->temp_over =
 736                     lm78_read_value(data, LM78_REG_TEMP_OVER);
 737                 data->temp_hyst =
 738                     lm78_read_value(data, LM78_REG_TEMP_HYST);
 739                 i = lm78_read_value(data, LM78_REG_VID_FANDIV);
 740                 data->vid = i & 0x0f;
 741                 if (data->type == lm79)
 742                         data->vid |=
 743                             (lm78_read_value(data, LM78_REG_CHIPID) &
 744                              0x01) << 4;
 745                 else
 746                         data->vid |= 0x10;
 747                 data->fan_div[0] = (i >> 4) & 0x03;
 748                 data->fan_div[1] = i >> 6;
 749                 data->alarms = lm78_read_value(data, LM78_REG_ALARM1) +
 750                     (lm78_read_value(data, LM78_REG_ALARM2) << 8);
 751                 data->last_updated = jiffies;
 752                 data->valid = 1;
 753
 754                 data->fan_div[2] = 1;
 755         }
 756
 757         mutex_unlock(&data->update_lock);
 758
 759         return data;
 760 }
 761
 762 static int __devinit lm78_isa_probe(struct platform_device *pdev)
 763 {
 764         int err;
 765         struct lm78_data *data;
 766         struct resource *res;
 767
 768         /* Reserve the ISA region */
 769         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
 770         if (!request_region(res->start + LM78_ADDR_REG_OFFSET, 2, "lm78")) {
 771                 err = -EBUSY;
 772                 goto exit;
 773         }
 774
 775         data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL);
 776         if (!data) {
 777                 err = -ENOMEM;
 778                 goto exit_release_region;
 779         }
 780         mutex_init(&data->lock);
 781         data->isa_addr = res->start;
 782         platform_set_drvdata(pdev, data);
 783
 784         if (lm78_read_value(data, LM78_REG_CHIPID) & 0x80) {
 785                 data->type = lm79;
 786                 data->name = "lm79";
 787         } else {
 788                 data->type = lm78;
 789                 data->name = "lm78";
 790         }
 791
 792         /* Initialize the LM78 chip */
 793         lm78_init_device(data);
 794
 795         /* Register sysfs hooks */
 796         if ((err = sysfs_create_group(&pdev->dev.kobj, &lm78_group))
 797          || (err = device_create_file(&pdev->dev, &dev_attr_name)))
 798                 goto exit_remove_files;
 799
 800         data->hwmon_dev = hwmon_device_register(&pdev->dev);
 801         if (IS_ERR(data->hwmon_dev)) {
 802                 err = PTR_ERR(data->hwmon_dev);
 803                 goto exit_remove_files;
 804         }
 805
 806         return 0;
 807
 808  exit_remove_files:
 809         sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
 810         device_remove_file(&pdev->dev, &dev_attr_name);
 811         kfree(data);
 812  exit_release_region:
 813         release_region(res->start + LM78_ADDR_REG_OFFSET, 2);
 814  exit:
 815         return err;
 816 }
 817
 818 static int __devexit lm78_isa_remove(struct platform_device *pdev)
 819 {
 820         struct lm78_data *data = platform_get_drvdata(pdev);
 821         struct resource *res;
 822
 823         hwmon_device_unregister(data->hwmon_dev);
 824         sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
 825         device_remove_file(&pdev->dev, &dev_attr_name);
 826         kfree(data);
 827
 828         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
 829         release_region(res->start + LM78_ADDR_REG_OFFSET, 2);
 830
 831         return 0;
 832 }
 833
 834 static struct platform_driver lm78_isa_driver = {
 835         .driver = {
 836                 .owner  = THIS_MODULE,
 837                 .name   = "lm78",
 838         },
 839         .probe          = lm78_isa_probe,
 840         .remove         = __devexit_p(lm78_isa_remove),
 841 };
 842
 843 /* return 1 if a supported chip is found, 0 otherwise */
 844 static int __init lm78_isa_found(unsigned short address)
 845 {
 846         int val, save, found = 0;
 847         int port;
 848
 849         /* Some boards declare base+0 to base+7 as a PNP device, some base+4
 850          * to base+7 and some base+5 to base+6. So we better request each port
 851          * individually for the probing phase. */
 852         for (port = address; port < address + LM78_EXTENT; port++) {
 853                 if (!request_region(port, 1, "lm78")) {
 854                         pr_debug("Failed to request port 0x%x\n", port);
 855                         goto release;
 856                 }
 857         }
 858
 859 #define REALLY_SLOW_IO
 860         /* We need the timeouts for at least some LM78-like
 861            chips. But only if we read 'undefined' registers. */
 862         val = inb_p(address + 1);
 863         if (inb_p(address + 2) != val
 864          || inb_p(address + 3) != val
 865          || inb_p(address + 7) != val)
 866                 goto release;
 867 #undef REALLY_SLOW_IO
 868
 869         /* We should be able to change the 7 LSB of the address port. The
 870            MSB (busy flag) should be clear initially, set after the write. */
 871         save = inb_p(address + LM78_ADDR_REG_OFFSET);
 872         if (save & 0x80)
 873                 goto release;
 874         val = ~save & 0x7f;
 875         outb_p(val, address + LM78_ADDR_REG_OFFSET);
 876         if (inb_p(address + LM78_ADDR_REG_OFFSET) != (val | 0x80)) {
 877                 outb_p(save, address + LM78_ADDR_REG_OFFSET);
 878                 goto release;
 879         }
 880
 881         /* We found a device, now see if it could be an LM78 */
 882         outb_p(LM78_REG_CONFIG, address + LM78_ADDR_REG_OFFSET);
 883         val = inb_p(address + LM78_DATA_REG_OFFSET);
 884         if (val & 0x80)
 885                 goto release;
 886         outb_p(LM78_REG_I2C_ADDR, address + LM78_ADDR_REG_OFFSET);
 887         val = inb_p(address + LM78_DATA_REG_OFFSET);
 888         if (val < 0x03 || val > 0x77)   /* Not a valid I2C address */
 889                 goto release;
 890
 891         /* The busy flag should be clear again */
 892         if (inb_p(address + LM78_ADDR_REG_OFFSET) & 0x80)
 893                 goto release;
 894
 895         /* Explicitly prevent the misdetection of Winbond chips */
 896         outb_p(0x4f, address + LM78_ADDR_REG_OFFSET);
 897         val = inb_p(address + LM78_DATA_REG_OFFSET);
 898         if (val == 0xa3 || val == 0x5c)
 899                 goto release;
 900
 901         /* Explicitly prevent the misdetection of ITE chips */
 902         outb_p(0x58, address + LM78_ADDR_REG_OFFSET);
 903         val = inb_p(address + LM78_DATA_REG_OFFSET);
 904         if (val == 0x90)
 905                 goto release;
 906
 907         /* Determine the chip type */
 908         outb_p(LM78_REG_CHIPID, address + LM78_ADDR_REG_OFFSET);
 909         val = inb_p(address + LM78_DATA_REG_OFFSET);
 910         if (val == 0x00 || val == 0x20  /* LM78 */
 911          || val == 0x40                 /* LM78-J */
 912          || (val & 0xfe) == 0xc0)       /* LM79 */
 913                 found = 1;
 914
 915         if (found)
 916                 pr_info("Found an %s chip at %#x\n",
 917                         val & 0x80 ? "LM79" : "LM78", (int)address);
 918
 919  release:
 920         for (port--; port >= address; port--)
 921                 release_region(port, 1);
 922         return found;
 923 }
 924
 925 static int __init lm78_isa_device_add(unsigned short address)
 926 {
 927         struct resource res = {
 928                 .start  = address,
 929                 .end    = address + LM78_EXTENT - 1,
 930                 .name   = "lm78",
 931                 .flags  = IORESOURCE_IO,
 932         };
 933         int err;
 934
 935         pdev = platform_device_alloc("lm78", address);
 936         if (!pdev) {
 937                 err = -ENOMEM;
 938                 pr_err("Device allocation failed\n");
 939                 goto exit;
 940         }
 941
 942         err = platform_device_add_resources(pdev, &res, 1);
 943         if (err) {
 944                 pr_err("Device resource addition failed (%d)\n", err);
 945                 goto exit_device_put;
 946         }
 947
 948         err = platform_device_add(pdev);
 949         if (err) {
 950                 pr_err("Device addition failed (%d)\n", err);
 951                 goto exit_device_put;
 952         }
 953
 954         return 0;
 955
 956  exit_device_put:
 957         platform_device_put(pdev);
 958  exit:
 959         pdev = NULL;
 960         return err;
 961 }
 962
 963 static int __init sm_lm78_init(void)
 964 {
 965         int res;
 966
 967         /* We register the ISA device first, so that we can skip the
 968          * registration of an I2C interface to the same device. */
 969         if (lm78_isa_found(isa_address)) {
 970                 res = platform_driver_register(&lm78_isa_driver);
 971                 if (res)
 972                         goto exit;
 973
 974                 /* Sets global pdev as a side effect */
 975                 res = lm78_isa_device_add(isa_address);
 976                 if (res)
 977                         goto exit_unreg_isa_driver;
 978         }
 979
 980         res = i2c_add_driver(&lm78_driver);
 981         if (res)
 982                 goto exit_unreg_isa_device;
 983
 984         return 0;
 985
 986  exit_unreg_isa_device:
 987         platform_device_unregister(pdev);
 988  exit_unreg_isa_driver:
 989         platform_driver_unregister(&lm78_isa_driver);
 990  exit:
 991         return res;
 992 }
 993
 994 static void __exit sm_lm78_exit(void)
 995 {
 996         if (pdev) {
 997                 platform_device_unregister(pdev);
 998                 platform_driver_unregister(&lm78_isa_driver);
 999         }
1000         i2c_del_driver(&lm78_driver);
1001 }
1002
1003
1004
1005 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
1006 MODULE_DESCRIPTION("LM78/LM79 driver");
1007 MODULE_LICENSE("GPL");
1008
1009 module_init(sm_lm78_init);
1010 module_exit(sm_lm78_exit);