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 /* 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 ((i2c_smbus_read_byte_data(client, LM78_REG_CONFIG) & 0x80)
 580          || i2c_smbus_read_byte_data(client, LM78_REG_I2C_ADDR) != address)
 581                 goto err_nodev;
 582
 583         /* Explicitly prevent the misdetection of Winbond chips */
 584         i = i2c_smbus_read_byte_data(client, 0x4f);
 585         if (i == 0xa3 || i == 0x5c)
 586                 goto err_nodev;
 587
 588         /* Determine the chip type. */
 589         i = i2c_smbus_read_byte_data(client, LM78_REG_CHIPID);
 590         if (i == 0x00 || i == 0x20      /* LM78 */
 591          || i == 0x40)                  /* LM78-J */
 592                 client_name = "lm78";
 593         else if ((i & 0xfe) == 0xc0)
 594                 client_name = "lm79";
 595         else
 596                 goto err_nodev;
 597
 598         if (lm78_alias_detect(client, i)) {
 599                 dev_dbg(&adapter->dev, "Device at 0x%02x appears to "
 600                         "be the same as ISA device\n", address);
 601                 goto err_nodev;
 602         }
 603
 604         if (isa)
 605                 mutex_unlock(&isa->update_lock);
 606
 607         strlcpy(info->type, client_name, I2C_NAME_SIZE);
 608
 609         return 0;
 610
 611  err_nodev:
 612         if (isa)
 613                 mutex_unlock(&isa->update_lock);
 614         return -ENODEV;
 615 }
 616
 617 static int lm78_i2c_probe(struct i2c_client *client,
 618                           const struct i2c_device_id *id)
 619 {
 620         struct lm78_data *data;
 621         int err;
 622
 623         data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL);
 624         if (!data)
 625                 return -ENOMEM;
 626
 627         i2c_set_clientdata(client, data);
 628         data->client = client;
 629         data->type = id->driver_data;
 630
 631         /* Initialize the LM78 chip */
 632         lm78_init_device(data);
 633
 634         /* Register sysfs hooks */
 635         err = sysfs_create_group(&client->dev.kobj, &lm78_group);
 636         if (err)
 637                 goto ERROR3;
 638
 639         data->hwmon_dev = hwmon_device_register(&client->dev);
 640         if (IS_ERR(data->hwmon_dev)) {
 641                 err = PTR_ERR(data->hwmon_dev);
 642                 goto ERROR4;
 643         }
 644
 645         return 0;
 646
 647 ERROR4:
 648         sysfs_remove_group(&client->dev.kobj, &lm78_group);
 649 ERROR3:
 650         kfree(data);
 651         return err;
 652 }
 653
 654 static int lm78_i2c_remove(struct i2c_client *client)
 655 {
 656         struct lm78_data *data = i2c_get_clientdata(client);
 657
 658         hwmon_device_unregister(data->hwmon_dev);
 659         sysfs_remove_group(&client->dev.kobj, &lm78_group);
 660         kfree(data);
 661
 662         return 0;
 663 }
 664
 665 static int __devinit lm78_isa_probe(struct platform_device *pdev)
 666 {
 667         int err;
 668         struct lm78_data *data;
 669         struct resource *res;
 670
 671         /* Reserve the ISA region */
 672         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
 673         if (!request_region(res->start + LM78_ADDR_REG_OFFSET, 2, "lm78")) {
 674                 err = -EBUSY;
 675                 goto exit;
 676         }
 677
 678         if (!(data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL))) {
 679                 err = -ENOMEM;
 680                 goto exit_release_region;
 681         }
 682         mutex_init(&data->lock);
 683         data->isa_addr = res->start;
 684         platform_set_drvdata(pdev, data);
 685
 686         if (lm78_read_value(data, LM78_REG_CHIPID) & 0x80) {
 687                 data->type = lm79;
 688                 data->name = "lm79";
 689         } else {
 690                 data->type = lm78;
 691                 data->name = "lm78";
 692         }
 693
 694         /* Initialize the LM78 chip */
 695         lm78_init_device(data);
 696
 697         /* Register sysfs hooks */
 698         if ((err = sysfs_create_group(&pdev->dev.kobj, &lm78_group))
 699          || (err = device_create_file(&pdev->dev, &dev_attr_name)))
 700                 goto exit_remove_files;
 701
 702         data->hwmon_dev = hwmon_device_register(&pdev->dev);
 703         if (IS_ERR(data->hwmon_dev)) {
 704                 err = PTR_ERR(data->hwmon_dev);
 705                 goto exit_remove_files;
 706         }
 707
 708         return 0;
 709
 710  exit_remove_files:
 711         sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
 712         device_remove_file(&pdev->dev, &dev_attr_name);
 713         kfree(data);
 714  exit_release_region:
 715         release_region(res->start + LM78_ADDR_REG_OFFSET, 2);
 716  exit:
 717         return err;
 718 }
 719
 720 static int __devexit lm78_isa_remove(struct platform_device *pdev)
 721 {
 722         struct lm78_data *data = platform_get_drvdata(pdev);
 723         struct resource *res;
 724
 725         hwmon_device_unregister(data->hwmon_dev);
 726         sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
 727         device_remove_file(&pdev->dev, &dev_attr_name);
 728         kfree(data);
 729
 730         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
 731         release_region(res->start + LM78_ADDR_REG_OFFSET, 2);
 732
 733         return 0;
 734 }
 735
 736 /* The SMBus locks itself, but ISA access must be locked explicitly!
 737    We don't want to lock the whole ISA bus, so we lock each client
 738    separately.
 739    We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
 740    would slow down the LM78 access and should not be necessary.  */
 741 static int lm78_read_value(struct lm78_data *data, u8 reg)
 742 {
 743         struct i2c_client *client = data->client;
 744
 745         if (!client) { /* ISA device */
 746                 int res;
 747                 mutex_lock(&data->lock);
 748                 outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
 749                 res = inb_p(data->isa_addr + LM78_DATA_REG_OFFSET);
 750                 mutex_unlock(&data->lock);
 751                 return res;
 752         } else
 753                 return i2c_smbus_read_byte_data(client, reg);
 754 }
 755
 756 /* The SMBus locks itself, but ISA access muse be locked explicitly!
 757    We don't want to lock the whole ISA bus, so we lock each client
 758    separately.
 759    We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
 760    would slow down the LM78 access and should not be necessary.
 761    There are some ugly typecasts here, but the good new is - they should
 762    nowhere else be necessary! */
 763 static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value)
 764 {
 765         struct i2c_client *client = data->client;
 766
 767         if (!client) { /* ISA device */
 768                 mutex_lock(&data->lock);
 769                 outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
 770                 outb_p(value, data->isa_addr + LM78_DATA_REG_OFFSET);
 771                 mutex_unlock(&data->lock);
 772                 return 0;
 773         } else
 774                 return i2c_smbus_write_byte_data(client, reg, value);
 775 }
 776
 777 static void lm78_init_device(struct lm78_data *data)
 778 {
 779         u8 config;
 780         int i;
 781
 782         /* Start monitoring */
 783         config = lm78_read_value(data, LM78_REG_CONFIG);
 784         if ((config & 0x09) != 0x01)
 785                 lm78_write_value(data, LM78_REG_CONFIG,
 786                                  (config & 0xf7) | 0x01);
 787
 788         /* A few vars need to be filled upon startup */
 789         for (i = 0; i < 3; i++) {
 790                 data->fan_min[i] = lm78_read_value(data,
 791                                         LM78_REG_FAN_MIN(i));
 792         }
 793
 794         mutex_init(&data->update_lock);
 795 }
 796
 797 static struct lm78_data *lm78_update_device(struct device *dev)
 798 {
 799         struct lm78_data *data = dev_get_drvdata(dev);
 800         int i;
 801
 802         mutex_lock(&data->update_lock);
 803
 804         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
 805             || !data->valid) {
 806
 807                 dev_dbg(dev, "Starting lm78 update\n");
 808
 809                 for (i = 0; i <= 6; i++) {
 810                         data->in[i] =
 811                             lm78_read_value(data, LM78_REG_IN(i));
 812                         data->in_min[i] =
 813                             lm78_read_value(data, LM78_REG_IN_MIN(i));
 814                         data->in_max[i] =
 815                             lm78_read_value(data, LM78_REG_IN_MAX(i));
 816                 }
 817                 for (i = 0; i < 3; i++) {
 818                         data->fan[i] =
 819                             lm78_read_value(data, LM78_REG_FAN(i));
 820                         data->fan_min[i] =
 821                             lm78_read_value(data, LM78_REG_FAN_MIN(i));
 822                 }
 823                 data->temp = lm78_read_value(data, LM78_REG_TEMP);
 824                 data->temp_over =
 825                     lm78_read_value(data, LM78_REG_TEMP_OVER);
 826                 data->temp_hyst =
 827                     lm78_read_value(data, LM78_REG_TEMP_HYST);
 828                 i = lm78_read_value(data, LM78_REG_VID_FANDIV);
 829                 data->vid = i & 0x0f;
 830                 if (data->type == lm79)
 831                         data->vid |=
 832                             (lm78_read_value(data, LM78_REG_CHIPID) &
 833                              0x01) << 4;
 834                 else
 835                         data->vid |= 0x10;
 836                 data->fan_div[0] = (i >> 4) & 0x03;
 837                 data->fan_div[1] = i >> 6;
 838                 data->alarms = lm78_read_value(data, LM78_REG_ALARM1) +
 839                     (lm78_read_value(data, LM78_REG_ALARM2) << 8);
 840                 data->last_updated = jiffies;
 841                 data->valid = 1;
 842
 843                 data->fan_div[2] = 1;
 844         }
 845
 846         mutex_unlock(&data->update_lock);
 847
 848         return data;
 849 }
 850
 851 /* return 1 if a supported chip is found, 0 otherwise */
 852 static int __init lm78_isa_found(unsigned short address)
 853 {
 854         int val, save, found = 0;
 855
 856         /* We have to request the region in two parts because some
 857            boards declare base+4 to base+7 as a PNP device */
 858         if (!request_region(address, 4, "lm78")) {
 859                 pr_debug("lm78: Failed to request low part of region\n");
 860                 return 0;
 861         }
 862         if (!request_region(address + 4, 4, "lm78")) {
 863                 pr_debug("lm78: Failed to request high part of region\n");
 864                 release_region(address, 4);
 865                 return 0;
 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("lm78: Found an %s chip at %#x\n",
 926                         val & 0x80 ? "LM79" : "LM78", (int)address);
 927
 928  release:
 929         release_region(address + 4, 4);
 930         release_region(address, 4);
 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                 printk(KERN_ERR "lm78: Device allocation failed\n");
 948                 goto exit;
 949         }
 950
 951         err = platform_device_add_resources(pdev, &res, 1);
 952         if (err) {
 953                 printk(KERN_ERR "lm78: Device resource addition failed "
 954                        "(%d)\n", err);
 955                 goto exit_device_put;
 956         }
 957
 958         err = platform_device_add(pdev);
 959         if (err) {
 960                 printk(KERN_ERR "lm78: Device addition failed (%d)\n",
 961                        err);
 962                 goto exit_device_put;
 963         }
 964
 965         return 0;
 966
 967  exit_device_put:
 968         platform_device_put(pdev);
 969  exit:
 970         pdev = NULL;
 971         return err;
 972 }
 973
 974 static int __init sm_lm78_init(void)
 975 {
 976         int res;
 977
 978         /* We register the ISA device first, so that we can skip the
 979          * registration of an I2C interface to the same device. */
 980         if (lm78_isa_found(isa_address)) {
 981                 res = platform_driver_register(&lm78_isa_driver);
 982                 if (res)
 983                         goto exit;
 984
 985                 /* Sets global pdev as a side effect */
 986                 res = lm78_isa_device_add(isa_address);
 987                 if (res)
 988                         goto exit_unreg_isa_driver;
 989         }
 990
 991         res = i2c_add_driver(&lm78_driver);
 992         if (res)
 993                 goto exit_unreg_isa_device;
 994
 995         return 0;
 996
 997  exit_unreg_isa_device:
 998         platform_device_unregister(pdev);
 999  exit_unreg_isa_driver:
1000         platform_driver_unregister(&lm78_isa_driver);
1001  exit:
1002         return res;
1003 }
1004
1005 static void __exit sm_lm78_exit(void)
1006 {
1007         if (pdev) {
1008                 platform_device_unregister(pdev);
1009                 platform_driver_unregister(&lm78_isa_driver);
1010         }
1011         i2c_del_driver(&lm78_driver);
1012 }
1013
1014
1015
1016 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
1017 MODULE_DESCRIPTION("LM78/LM79 driver");
1018 MODULE_LICENSE("GPL");
1019
1020 module_init(sm_lm78_init);
1021 module_exit(sm_lm78_exit);