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