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