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         }
 617
 618         /* Determine the chip type. */
 619         if (kind <= 0) {
 620                 i = lm78_read_value(data, LM78_REG_CHIPID);
 621                 if (i == 0x00 || i == 0x20      /* LM78 */
 622                  || i == 0x40)                  /* LM78-J */
 623                         kind = lm78;
 624                 else if ((i & 0xfe) == 0xc0)
 625                         kind = lm79;
 626                 else {
 627                         if (kind == 0)
 628                                 dev_warn(&adapter->dev, "Ignoring 'force' "
 629                                         "parameter for unknown chip at "
 630                                         "adapter %d, address 0x%02x\n",
 631                                         i2c_adapter_id(adapter), address);
 632                         err = -ENODEV;
 633                         goto ERROR2;
 634                 }
 635
 636                 if (lm78_alias_detect(new_client, i)) {
 637                         dev_dbg(&adapter->dev, "Device at 0x%02x appears to "
 638                                 "be the same as ISA device\n", address);
 639                         err = -ENODEV;
 640                         goto ERROR2;
 641                 }
 642         }
 643
 644         if (kind == lm78) {
 645                 client_name = "lm78";
 646         } else if (kind == lm79) {
 647                 client_name = "lm79";
 648         }
 649
 650         /* Fill in the remaining client fields and put into the global list */
 651         strlcpy(new_client->name, client_name, I2C_NAME_SIZE);
 652         data->type = kind;
 653
 654         /* Tell the I2C layer a new client has arrived */
 655         if ((err = i2c_attach_client(new_client)))
 656                 goto ERROR2;
 657
 658         /* Initialize the LM78 chip */
 659         lm78_init_device(data);
 660
 661         /* Register sysfs hooks */
 662         if ((err = sysfs_create_group(&new_client->dev.kobj, &lm78_group)))
 663                 goto ERROR3;
 664
 665         data->hwmon_dev = hwmon_device_register(&new_client->dev);
 666         if (IS_ERR(data->hwmon_dev)) {
 667                 err = PTR_ERR(data->hwmon_dev);
 668                 goto ERROR4;
 669         }
 670
 671         return 0;
 672
 673 ERROR4:
 674         sysfs_remove_group(&new_client->dev.kobj, &lm78_group);
 675 ERROR3:
 676         i2c_detach_client(new_client);
 677 ERROR2:
 678         kfree(data);
 679 ERROR1:
 680         return err;
 681 }
 682
 683 static int lm78_detach_client(struct i2c_client *client)
 684 {
 685         struct lm78_data *data = i2c_get_clientdata(client);
 686         int err;
 687
 688         hwmon_device_unregister(data->hwmon_dev);
 689         sysfs_remove_group(&client->dev.kobj, &lm78_group);
 690
 691         if ((err = i2c_detach_client(client)))
 692                 return err;
 693
 694         kfree(data);
 695
 696         return 0;
 697 }
 698
 699 static int __devinit lm78_isa_probe(struct platform_device *pdev)
 700 {
 701         int err;
 702         struct lm78_data *data;
 703         struct resource *res;
 704         const char *name;
 705
 706         /* Reserve the ISA region */
 707         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
 708         if (!request_region(res->start + LM78_ADDR_REG_OFFSET, 2, "lm78")) {
 709                 err = -EBUSY;
 710                 goto exit;
 711         }
 712
 713         if (!(data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL))) {
 714                 err = -ENOMEM;
 715                 goto exit_release_region;
 716         }
 717         mutex_init(&data->lock);
 718         data->client.addr = res->start;
 719         i2c_set_clientdata(&data->client, data);
 720         platform_set_drvdata(pdev, data);
 721
 722         if (lm78_read_value(data, LM78_REG_CHIPID) & 0x80) {
 723                 data->type = lm79;
 724                 name = "lm79";
 725         } else {
 726                 data->type = lm78;
 727                 name = "lm78";
 728         }
 729         strlcpy(data->client.name, name, I2C_NAME_SIZE);
 730
 731         /* Initialize the LM78 chip */
 732         lm78_init_device(data);
 733
 734         /* Register sysfs hooks */
 735         if ((err = sysfs_create_group(&pdev->dev.kobj, &lm78_group))
 736          || (err = device_create_file(&pdev->dev, &dev_attr_name)))
 737                 goto exit_remove_files;
 738
 739         data->hwmon_dev = hwmon_device_register(&pdev->dev);
 740         if (IS_ERR(data->hwmon_dev)) {
 741                 err = PTR_ERR(data->hwmon_dev);
 742                 goto exit_remove_files;
 743         }
 744
 745         return 0;
 746
 747  exit_remove_files:
 748         sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
 749         device_remove_file(&pdev->dev, &dev_attr_name);
 750         kfree(data);
 751  exit_release_region:
 752         release_region(res->start + LM78_ADDR_REG_OFFSET, 2);
 753  exit:
 754         return err;
 755 }
 756
 757 static int __devexit lm78_isa_remove(struct platform_device *pdev)
 758 {
 759         struct lm78_data *data = platform_get_drvdata(pdev);
 760
 761         hwmon_device_unregister(data->hwmon_dev);
 762         sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
 763         device_remove_file(&pdev->dev, &dev_attr_name);
 764         release_region(data->client.addr + LM78_ADDR_REG_OFFSET, 2);
 765         kfree(data);
 766
 767         return 0;
 768 }
 769
 770 /* The SMBus locks itself, but ISA access must be locked explicitly!
 771    We don't want to lock the whole ISA bus, so we lock each client
 772    separately.
 773    We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
 774    would slow down the LM78 access and should not be necessary.  */
 775 static int lm78_read_value(struct lm78_data *data, u8 reg)
 776 {
 777         struct i2c_client *client = &data->client;
 778
 779         if (!client->driver) { /* ISA device */
 780                 int res;
 781                 mutex_lock(&data->lock);
 782                 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
 783                 res = inb_p(client->addr + LM78_DATA_REG_OFFSET);
 784                 mutex_unlock(&data->lock);
 785                 return res;
 786         } else
 787                 return i2c_smbus_read_byte_data(client, reg);
 788 }
 789
 790 /* The SMBus locks itself, but ISA access muse be locked explicitly!
 791    We don't want to lock the whole ISA bus, so we lock each client
 792    separately.
 793    We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
 794    would slow down the LM78 access and should not be necessary.
 795    There are some ugly typecasts here, but the good new is - they should
 796    nowhere else be necessary! */
 797 static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value)
 798 {
 799         struct i2c_client *client = &data->client;
 800
 801         if (!client->driver) { /* ISA device */
 802                 mutex_lock(&data->lock);
 803                 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
 804                 outb_p(value, client->addr + LM78_DATA_REG_OFFSET);
 805                 mutex_unlock(&data->lock);
 806                 return 0;
 807         } else
 808                 return i2c_smbus_write_byte_data(client, reg, value);
 809 }
 810
 811 static void lm78_init_device(struct lm78_data *data)
 812 {
 813         u8 config;
 814         int i;
 815
 816         /* Start monitoring */
 817         config = lm78_read_value(data, LM78_REG_CONFIG);
 818         if ((config & 0x09) != 0x01)
 819                 lm78_write_value(data, LM78_REG_CONFIG,
 820                                  (config & 0xf7) | 0x01);
 821
 822         /* A few vars need to be filled upon startup */
 823         for (i = 0; i < 3; i++) {
 824                 data->fan_min[i] = lm78_read_value(data,
 825                                         LM78_REG_FAN_MIN(i));
 826         }
 827
 828         mutex_init(&data->update_lock);
 829 }
 830
 831 static struct lm78_data *lm78_update_device(struct device *dev)
 832 {
 833         struct lm78_data *data = dev_get_drvdata(dev);
 834         int i;
 835
 836         mutex_lock(&data->update_lock);
 837
 838         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
 839             || !data->valid) {
 840
 841                 dev_dbg(dev, "Starting lm78 update\n");
 842
 843                 for (i = 0; i <= 6; i++) {
 844                         data->in[i] =
 845                             lm78_read_value(data, LM78_REG_IN(i));
 846                         data->in_min[i] =
 847                             lm78_read_value(data, LM78_REG_IN_MIN(i));
 848                         data->in_max[i] =
 849                             lm78_read_value(data, LM78_REG_IN_MAX(i));
 850                 }
 851                 for (i = 0; i < 3; i++) {
 852                         data->fan[i] =
 853                             lm78_read_value(data, LM78_REG_FAN(i));
 854                         data->fan_min[i] =
 855                             lm78_read_value(data, LM78_REG_FAN_MIN(i));
 856                 }
 857                 data->temp = lm78_read_value(data, LM78_REG_TEMP);
 858                 data->temp_over =
 859                     lm78_read_value(data, LM78_REG_TEMP_OVER);
 860                 data->temp_hyst =
 861                     lm78_read_value(data, LM78_REG_TEMP_HYST);
 862                 i = lm78_read_value(data, LM78_REG_VID_FANDIV);
 863                 data->vid = i & 0x0f;
 864                 if (data->type == lm79)
 865                         data->vid |=
 866                             (lm78_read_value(data, LM78_REG_CHIPID) &
 867                              0x01) << 4;
 868                 else
 869                         data->vid |= 0x10;
 870                 data->fan_div[0] = (i >> 4) & 0x03;
 871                 data->fan_div[1] = i >> 6;
 872                 data->alarms = lm78_read_value(data, LM78_REG_ALARM1) +
 873                     (lm78_read_value(data, LM78_REG_ALARM2) << 8);
 874                 data->last_updated = jiffies;
 875                 data->valid = 1;
 876
 877                 data->fan_div[2] = 1;
 878         }
 879
 880         mutex_unlock(&data->update_lock);
 881
 882         return data;
 883 }
 884
 885 /* return 1 if a supported chip is found, 0 otherwise */
 886 static int __init lm78_isa_found(unsigned short address)
 887 {
 888         int val, save, found = 0;
 889
 890         /* We have to request the region in two parts because some
 891            boards declare base+4 to base+7 as a PNP device */
 892         if (!request_region(address, 4, "lm78")) {
 893                 pr_debug("lm78: Failed to request low part of region\n");
 894                 return 0;
 895         }
 896         if (!request_region(address + 4, 4, "lm78")) {
 897                 pr_debug("lm78: Failed to request high part of region\n");
 898                 release_region(address, 4);
 899                 return 0;
 900         }
 901
 902 #define REALLY_SLOW_IO
 903         /* We need the timeouts for at least some LM78-like
 904            chips. But only if we read 'undefined' registers. */
 905         val = inb_p(address + 1);
 906         if (inb_p(address + 2) != val
 907          || inb_p(address + 3) != val
 908          || inb_p(address + 7) != val)
 909                 goto release;
 910 #undef REALLY_SLOW_IO
 911
 912         /* We should be able to change the 7 LSB of the address port. The
 913            MSB (busy flag) should be clear initially, set after the write. */
 914         save = inb_p(address + LM78_ADDR_REG_OFFSET);
 915         if (save & 0x80)
 916                 goto release;
 917         val = ~save & 0x7f;
 918         outb_p(val, address + LM78_ADDR_REG_OFFSET);
 919         if (inb_p(address + LM78_ADDR_REG_OFFSET) != (val | 0x80)) {
 920                 outb_p(save, address + LM78_ADDR_REG_OFFSET);
 921                 goto release;
 922         }
 923
 924         /* We found a device, now see if it could be an LM78 */
 925         outb_p(LM78_REG_CONFIG, address + LM78_ADDR_REG_OFFSET);
 926         val = inb_p(address + LM78_DATA_REG_OFFSET);
 927         if (val & 0x80)
 928                 goto release;
 929         outb_p(LM78_REG_I2C_ADDR, address + LM78_ADDR_REG_OFFSET);
 930         val = inb_p(address + LM78_DATA_REG_OFFSET);
 931         if (val < 0x03 || val > 0x77)   /* Not a valid I2C address */
 932                 goto release;
 933
 934         /* The busy flag should be clear again */
 935         if (inb_p(address + LM78_ADDR_REG_OFFSET) & 0x80)
 936                 goto release;
 937
 938         /* Explicitly prevent the misdetection of Winbond chips */
 939         outb_p(0x4f, address + LM78_ADDR_REG_OFFSET);
 940         val = inb_p(address + LM78_DATA_REG_OFFSET);
 941         if (val == 0xa3 || val == 0x5c)
 942                 goto release;
 943
 944         /* Explicitly prevent the misdetection of ITE chips */
 945         outb_p(0x58, address + LM78_ADDR_REG_OFFSET);
 946         val = inb_p(address + LM78_DATA_REG_OFFSET);
 947         if (val == 0x90)
 948                 goto release;
 949
 950         /* Determine the chip type */
 951         outb_p(LM78_REG_CHIPID, address + LM78_ADDR_REG_OFFSET);
 952         val = inb_p(address + LM78_DATA_REG_OFFSET);
 953         if (val == 0x00 || val == 0x20  /* LM78 */
 954          || val == 0x40                 /* LM78-J */
 955          || (val & 0xfe) == 0xc0)       /* LM79 */
 956                 found = 1;
 957
 958         if (found)
 959                 pr_info("lm78: Found an %s chip at %#x\n",
 960                         val & 0x80 ? "LM79" : "LM78", (int)address);
 961
 962  release:
 963         release_region(address + 4, 4);
 964         release_region(address, 4);
 965         return found;
 966 }
 967
 968 static int __init lm78_isa_device_add(unsigned short address)
 969 {
 970         struct resource res = {
 971                 .start  = address,
 972                 .end    = address + LM78_EXTENT - 1,
 973                 .name   = "lm78",
 974                 .flags  = IORESOURCE_IO,
 975         };
 976         int err;
 977
 978         pdev = platform_device_alloc("lm78", address);
 979         if (!pdev) {
 980                 err = -ENOMEM;
 981                 printk(KERN_ERR "lm78: Device allocation failed\n");
 982                 goto exit;
 983         }
 984
 985         err = platform_device_add_resources(pdev, &res, 1);
 986         if (err) {
 987                 printk(KERN_ERR "lm78: Device resource addition failed "
 988                        "(%d)\n", err);
 989                 goto exit_device_put;
 990         }
 991
 992         err = platform_device_add(pdev);
 993         if (err) {
 994                 printk(KERN_ERR "lm78: Device addition failed (%d)\n",
 995                        err);
 996                 goto exit_device_put;
 997         }
 998
 999         return 0;
1000
1001  exit_device_put:
1002         platform_device_put(pdev);
1003  exit:
1004         pdev = NULL;
1005         return err;
1006 }
1007
1008 static int __init sm_lm78_init(void)
1009 {
1010         int res;
1011
1012         /* We register the ISA device first, so that we can skip the
1013          * registration of an I2C interface to the same device. */
1014         if (lm78_isa_found(isa_address)) {
1015                 res = platform_driver_register(&lm78_isa_driver);
1016                 if (res)
1017                         goto exit;
1018
1019                 /* Sets global pdev as a side effect */
1020                 res = lm78_isa_device_add(isa_address);
1021                 if (res)
1022                         goto exit_unreg_isa_driver;
1023         }
1024
1025         res = i2c_add_driver(&lm78_driver);
1026         if (res)
1027                 goto exit_unreg_isa_device;
1028
1029         return 0;
1030
1031  exit_unreg_isa_device:
1032         platform_device_unregister(pdev);
1033  exit_unreg_isa_driver:
1034         platform_driver_unregister(&lm78_isa_driver);
1035  exit:
1036         return res;
1037 }
1038
1039 static void __exit sm_lm78_exit(void)
1040 {
1041         if (pdev) {
1042                 platform_device_unregister(pdev);
1043                 platform_driver_unregister(&lm78_isa_driver);
1044         }
1045         i2c_del_driver(&lm78_driver);
1046 }
1047
1048
1049
1050 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
1051 MODULE_DESCRIPTION("LM78/LM79 driver");
1052 MODULE_LICENSE("GPL");
1053
1054 module_init(sm_lm78_init);
1055 module_exit(sm_lm78_exit);