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