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