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
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 #include <linux/module.h>
  22 #include <linux/init.h>
  23 #include <linux/slab.h>
  24 #include <linux/jiffies.h>
  25 #include <linux/i2c.h>
  26 #include <linux/i2c-isa.h>
  27 #include <linux/hwmon.h>
  28 #include <linux/hwmon-vid.h>
  29 #include <linux/err.h>
  30 #include <asm/io.h>
  31
  32 /* Addresses to scan */
  33 static unsigned short normal_i2c[] = { 0x20, 0x21, 0x22, 0x23, 0x24,
  34                                         0x25, 0x26, 0x27, 0x28, 0x29,
  35                                         0x2a, 0x2b, 0x2c, 0x2d, 0x2e,
  36                                         0x2f, I2C_CLIENT_END };
  37 static unsigned short isa_address = 0x290;
  38
  39 /* Insmod parameters */
  40 I2C_CLIENT_INSMOD_2(lm78, lm79);
  41
  42 /* Many LM78 constants specified below */
  43
  44 /* Length of ISA address segment */
  45 #define LM78_EXTENT 8
  46
  47 /* Where are the ISA address/data registers relative to the base address */
  48 #define LM78_ADDR_REG_OFFSET 5
  49 #define LM78_DATA_REG_OFFSET 6
  50
  51 /* The LM78 registers */
  52 #define LM78_REG_IN_MAX(nr) (0x2b + (nr) * 2)
  53 #define LM78_REG_IN_MIN(nr) (0x2c + (nr) * 2)
  54 #define LM78_REG_IN(nr) (0x20 + (nr))
  55
  56 #define LM78_REG_FAN_MIN(nr) (0x3b + (nr))
  57 #define LM78_REG_FAN(nr) (0x28 + (nr))
  58
  59 #define LM78_REG_TEMP 0x27
  60 #define LM78_REG_TEMP_OVER 0x39
  61 #define LM78_REG_TEMP_HYST 0x3a
  62
  63 #define LM78_REG_ALARM1 0x41
  64 #define LM78_REG_ALARM2 0x42
  65
  66 #define LM78_REG_VID_FANDIV 0x47
  67
  68 #define LM78_REG_CONFIG 0x40
  69 #define LM78_REG_CHIPID 0x49
  70 #define LM78_REG_I2C_ADDR 0x48
  71
  72
  73 /* Conversions. Rounding and limit checking is only done on the TO_REG
  74    variants. */
  75
  76 /* IN: mV, (0V to 4.08V)
  77    REG: 16mV/bit */
  78 static inline u8 IN_TO_REG(unsigned long val)
  79 {
  80         unsigned long nval = SENSORS_LIMIT(val, 0, 4080);
  81         return (nval + 8) / 16;
  82 }
  83 #define IN_FROM_REG(val) ((val) *  16)
  84
  85 static inline u8 FAN_TO_REG(long rpm, int div)
  86 {
  87         if (rpm <= 0)
  88                 return 255;
  89         return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
  90 }
  91
  92 static inline int FAN_FROM_REG(u8 val, int div)
  93 {
  94         return val==0 ? -1 : val==255 ? 0 : 1350000/(val*div);
  95 }
  96
  97 /* TEMP: mC (-128C to +127C)
  98    REG: 1C/bit, two's complement */
  99 static inline s8 TEMP_TO_REG(int val)
 100 {
 101         int nval = SENSORS_LIMIT(val, -128000, 127000) ;
 102         return nval<0 ? (nval-500)/1000 : (nval+500)/1000;
 103 }
 104
 105 static inline int TEMP_FROM_REG(s8 val)
 106 {
 107         return val * 1000;
 108 }
 109
 110 #define DIV_FROM_REG(val) (1 << (val))
 111
 112 /* There are some complications in a module like this. First off, LM78 chips
 113    may be both present on the SMBus and the ISA bus, and we have to handle
 114    those cases separately at some places. Second, there might be several
 115    LM78 chips available (well, actually, that is probably never done; but
 116    it is a clean illustration of how to handle a case like that). Finally,
 117    a specific chip may be attached to *both* ISA and SMBus, and we would
 118    not like to detect it double. Fortunately, in the case of the LM78 at
 119    least, a register tells us what SMBus address we are on, so that helps
 120    a bit - except if there could be more than one SMBus. Groan. No solution
 121    for this yet. */
 122
 123 /* This module may seem overly long and complicated. In fact, it is not so
 124    bad. Quite a lot of bookkeeping is done. A real driver can often cut
 125    some corners. */
 126
 127 /* For each registered LM78, we need to keep some data in memory. That
 128    data is pointed to by lm78_list[NR]->data. The structure itself is
 129    dynamically allocated, at the same time when a new lm78 client is
 130    allocated. */
 131 struct lm78_data {
 132         struct i2c_client client;
 133         struct class_device *class_dev;
 134         struct semaphore lock;
 135         enum chips type;
 136
 137         struct semaphore update_lock;
 138         char valid;             /* !=0 if following fields are valid */
 139         unsigned long last_updated;     /* In jiffies */
 140
 141         u8 in[7];               /* Register value */
 142         u8 in_max[7];           /* Register value */
 143         u8 in_min[7];           /* Register value */
 144         u8 fan[3];              /* Register value */
 145         u8 fan_min[3];          /* Register value */
 146         s8 temp;                /* Register value */
 147         s8 temp_over;           /* Register value */
 148         s8 temp_hyst;           /* Register value */
 149         u8 fan_div[3];          /* Register encoding, shifted right */
 150         u8 vid;                 /* Register encoding, combined */
 151         u16 alarms;             /* Register encoding, combined */
 152 };
 153
 154
 155 static int lm78_attach_adapter(struct i2c_adapter *adapter);
 156 static int lm78_isa_attach_adapter(struct i2c_adapter *adapter);
 157 static int lm78_detect(struct i2c_adapter *adapter, int address, int kind);
 158 static int lm78_detach_client(struct i2c_client *client);
 159
 160 static int lm78_read_value(struct i2c_client *client, u8 register);
 161 static int lm78_write_value(struct i2c_client *client, u8 register, u8 value);
 162 static struct lm78_data *lm78_update_device(struct device *dev);
 163 static void lm78_init_client(struct i2c_client *client);
 164
 165
 166 static struct i2c_driver lm78_driver = {
 167         .owner          = THIS_MODULE,
 168         .name           = "lm78",
 169         .id             = I2C_DRIVERID_LM78,
 170         .flags          = I2C_DF_NOTIFY,
 171         .attach_adapter = lm78_attach_adapter,
 172         .detach_client  = lm78_detach_client,
 173 };
 174
 175 static struct i2c_driver lm78_isa_driver = {
 176         .owner          = THIS_MODULE,
 177         .name           = "lm78-isa",
 178         .attach_adapter = lm78_isa_attach_adapter,
 179         .detach_client  = lm78_detach_client,
 180 };
 181
 182
 183 /* 7 Voltages */
 184 static ssize_t show_in(struct device *dev, char *buf, int nr)
 185 {
 186         struct lm78_data *data = lm78_update_device(dev);
 187         return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr]));
 188 }
 189
 190 static ssize_t show_in_min(struct device *dev, char *buf, int nr)
 191 {
 192         struct lm78_data *data = lm78_update_device(dev);
 193         return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr]));
 194 }
 195
 196 static ssize_t show_in_max(struct device *dev, char *buf, int nr)
 197 {
 198         struct lm78_data *data = lm78_update_device(dev);
 199         return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr]));
 200 }
 201
 202 static ssize_t set_in_min(struct device *dev, const char *buf,
 203                 size_t count, int nr)
 204 {
 205         struct i2c_client *client = to_i2c_client(dev);
 206         struct lm78_data *data = i2c_get_clientdata(client);
 207         unsigned long val = simple_strtoul(buf, NULL, 10);
 208
 209         down(&data->update_lock);
 210         data->in_min[nr] = IN_TO_REG(val);
 211         lm78_write_value(client, LM78_REG_IN_MIN(nr), data->in_min[nr]);
 212         up(&data->update_lock);
 213         return count;
 214 }
 215
 216 static ssize_t set_in_max(struct device *dev, const char *buf,
 217                 size_t count, int nr)
 218 {
 219         struct i2c_client *client = to_i2c_client(dev);
 220         struct lm78_data *data = i2c_get_clientdata(client);
 221         unsigned long val = simple_strtoul(buf, NULL, 10);
 222
 223         down(&data->update_lock);
 224         data->in_max[nr] = IN_TO_REG(val);
 225         lm78_write_value(client, LM78_REG_IN_MAX(nr), data->in_max[nr]);
 226         up(&data->update_lock);
 227         return count;
 228 }
 229
 230 #define show_in_offset(offset)                                  \
 231 static ssize_t                                                  \
 232         show_in##offset (struct device *dev, struct device_attribute *attr, char *buf)          \
 233 {                                                               \
 234         return show_in(dev, buf, offset);                       \
 235 }                                                               \
 236 static DEVICE_ATTR(in##offset##_input, S_IRUGO,                 \
 237                 show_in##offset, NULL);                         \
 238 static ssize_t                                                  \
 239         show_in##offset##_min (struct device *dev, struct device_attribute *attr, char *buf)   \
 240 {                                                               \
 241         return show_in_min(dev, buf, offset);                   \
 242 }                                                               \
 243 static ssize_t                                                  \
 244         show_in##offset##_max (struct device *dev, struct device_attribute *attr, char *buf)   \
 245 {                                                               \
 246         return show_in_max(dev, buf, offset);                   \
 247 }                                                               \
 248 static ssize_t set_in##offset##_min (struct device *dev, struct device_attribute *attr, \
 249                 const char *buf, size_t count)                  \
 250 {                                                               \
 251         return set_in_min(dev, buf, count, offset);             \
 252 }                                                               \
 253 static ssize_t set_in##offset##_max (struct device *dev, struct device_attribute *attr, \
 254                 const char *buf, size_t count)                  \
 255 {                                                               \
 256         return set_in_max(dev, buf, count, offset);             \
 257 }                                                               \
 258 static DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,         \
 259                 show_in##offset##_min, set_in##offset##_min);   \
 260 static DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,         \
 261                 show_in##offset##_max, set_in##offset##_max);
 262
 263 show_in_offset(0);
 264 show_in_offset(1);
 265 show_in_offset(2);
 266 show_in_offset(3);
 267 show_in_offset(4);
 268 show_in_offset(5);
 269 show_in_offset(6);
 270
 271 /* Temperature */
 272 static ssize_t show_temp(struct device *dev, struct device_attribute *attr, char *buf)
 273 {
 274         struct lm78_data *data = lm78_update_device(dev);
 275         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));
 276 }
 277
 278 static ssize_t show_temp_over(struct device *dev, struct device_attribute *attr, char *buf)
 279 {
 280         struct lm78_data *data = lm78_update_device(dev);
 281         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
 282 }
 283
 284 static ssize_t set_temp_over(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 285 {
 286         struct i2c_client *client = to_i2c_client(dev);
 287         struct lm78_data *data = i2c_get_clientdata(client);
 288         long val = simple_strtol(buf, NULL, 10);
 289
 290         down(&data->update_lock);
 291         data->temp_over = TEMP_TO_REG(val);
 292         lm78_write_value(client, LM78_REG_TEMP_OVER, data->temp_over);
 293         up(&data->update_lock);
 294         return count;
 295 }
 296
 297 static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *attr, char *buf)
 298 {
 299         struct lm78_data *data = lm78_update_device(dev);
 300         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
 301 }
 302
 303 static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 304 {
 305         struct i2c_client *client = to_i2c_client(dev);
 306         struct lm78_data *data = i2c_get_clientdata(client);
 307         long val = simple_strtol(buf, NULL, 10);
 308
 309         down(&data->update_lock);
 310         data->temp_hyst = TEMP_TO_REG(val);
 311         lm78_write_value(client, LM78_REG_TEMP_HYST, data->temp_hyst);
 312         up(&data->update_lock);
 313         return count;
 314 }
 315
 316 static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL);
 317 static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
 318                 show_temp_over, set_temp_over);
 319 static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
 320                 show_temp_hyst, set_temp_hyst);
 321
 322 /* 3 Fans */
 323 static ssize_t show_fan(struct device *dev, char *buf, int nr)
 324 {
 325         struct lm78_data *data = lm78_update_device(dev);
 326         return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
 327                 DIV_FROM_REG(data->fan_div[nr])) );
 328 }
 329
 330 static ssize_t show_fan_min(struct device *dev, char *buf, int nr)
 331 {
 332         struct lm78_data *data = lm78_update_device(dev);
 333         return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan_min[nr],
 334                 DIV_FROM_REG(data->fan_div[nr])) );
 335 }
 336
 337 static ssize_t set_fan_min(struct device *dev, const char *buf,
 338                 size_t count, int nr)
 339 {
 340         struct i2c_client *client = to_i2c_client(dev);
 341         struct lm78_data *data = i2c_get_clientdata(client);
 342         unsigned long val = simple_strtoul(buf, NULL, 10);
 343
 344         down(&data->update_lock);
 345         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
 346         lm78_write_value(client, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
 347         up(&data->update_lock);
 348         return count;
 349 }
 350
 351 static ssize_t show_fan_div(struct device *dev, char *buf, int nr)
 352 {
 353         struct lm78_data *data = lm78_update_device(dev);
 354         return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]) );
 355 }
 356
 357 /* Note: we save and restore the fan minimum here, because its value is
 358    determined in part by the fan divisor.  This follows the principle of
 359    least suprise; the user doesn't expect the fan minimum to change just
 360    because the divisor changed. */
 361 static ssize_t set_fan_div(struct device *dev, const char *buf,
 362         size_t count, int nr)
 363 {
 364         struct i2c_client *client = to_i2c_client(dev);
 365         struct lm78_data *data = i2c_get_clientdata(client);
 366         unsigned long val = simple_strtoul(buf, NULL, 10);
 367         unsigned long min;
 368         u8 reg;
 369
 370         down(&data->update_lock);
 371         min = FAN_FROM_REG(data->fan_min[nr],
 372                            DIV_FROM_REG(data->fan_div[nr]));
 373
 374         switch (val) {
 375         case 1: data->fan_div[nr] = 0; break;
 376         case 2: data->fan_div[nr] = 1; break;
 377         case 4: data->fan_div[nr] = 2; break;
 378         case 8: data->fan_div[nr] = 3; break;
 379         default:
 380                 dev_err(&client->dev, "fan_div value %ld not "
 381                         "supported. Choose one of 1, 2, 4 or 8!\n", val);
 382                 up(&data->update_lock);
 383                 return -EINVAL;
 384         }
 385
 386         reg = lm78_read_value(client, LM78_REG_VID_FANDIV);
 387         switch (nr) {
 388         case 0:
 389                 reg = (reg & 0xcf) | (data->fan_div[nr] << 4);
 390                 break;
 391         case 1:
 392                 reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
 393                 break;
 394         }
 395         lm78_write_value(client, LM78_REG_VID_FANDIV, reg);
 396
 397         data->fan_min[nr] =
 398                 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
 399         lm78_write_value(client, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
 400         up(&data->update_lock);
 401
 402         return count;
 403 }
 404
 405 #define show_fan_offset(offset)                                         \
 406 static ssize_t show_fan_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
 407 {                                                                       \
 408         return show_fan(dev, buf, offset - 1);                          \
 409 }                                                                       \
 410 static ssize_t show_fan_##offset##_min (struct device *dev, struct device_attribute *attr, char *buf)  \
 411 {                                                                       \
 412         return show_fan_min(dev, buf, offset - 1);                      \
 413 }                                                                       \
 414 static ssize_t show_fan_##offset##_div (struct device *dev, struct device_attribute *attr, char *buf)  \
 415 {                                                                       \
 416         return show_fan_div(dev, buf, offset - 1);                      \
 417 }                                                                       \
 418 static ssize_t set_fan_##offset##_min (struct device *dev, struct device_attribute *attr,               \
 419                 const char *buf, size_t count)                          \
 420 {                                                                       \
 421         return set_fan_min(dev, buf, count, offset - 1);                \
 422 }                                                                       \
 423 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan_##offset, NULL);\
 424 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,                \
 425                 show_fan_##offset##_min, set_fan_##offset##_min);
 426
 427 static ssize_t set_fan_1_div(struct device *dev, struct device_attribute *attr, const char *buf,
 428                 size_t count)
 429 {
 430         return set_fan_div(dev, buf, count, 0) ;
 431 }
 432
 433 static ssize_t set_fan_2_div(struct device *dev, struct device_attribute *attr, const char *buf,
 434                 size_t count)
 435 {
 436         return set_fan_div(dev, buf, count, 1) ;
 437 }
 438
 439 show_fan_offset(1);
 440 show_fan_offset(2);
 441 show_fan_offset(3);
 442
 443 /* Fan 3 divisor is locked in H/W */
 444 static DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
 445                 show_fan_1_div, set_fan_1_div);
 446 static DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
 447                 show_fan_2_div, set_fan_2_div);
 448 static DEVICE_ATTR(fan3_div, S_IRUGO, show_fan_3_div, NULL);
 449
 450 /* VID */
 451 static ssize_t show_vid(struct device *dev, struct device_attribute *attr, char *buf)
 452 {
 453         struct lm78_data *data = lm78_update_device(dev);
 454         return sprintf(buf, "%d\n", vid_from_reg(82, data->vid));
 455 }
 456 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
 457
 458 /* Alarms */
 459 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
 460 {
 461         struct lm78_data *data = lm78_update_device(dev);
 462         return sprintf(buf, "%u\n", data->alarms);
 463 }
 464 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 465
 466 /* This function is called when:
 467      * lm78_driver is inserted (when this module is loaded), for each
 468        available adapter
 469      * when a new adapter is inserted (and lm78_driver is still present) */
 470 static int lm78_attach_adapter(struct i2c_adapter *adapter)
 471 {
 472         if (!(adapter->class & I2C_CLASS_HWMON))
 473                 return 0;
 474         return i2c_probe(adapter, &addr_data, lm78_detect);
 475 }
 476
 477 static int lm78_isa_attach_adapter(struct i2c_adapter *adapter)
 478 {
 479         return lm78_detect(adapter, isa_address, -1);
 480 }
 481
 482 /* This function is called by i2c_probe */
 483 int lm78_detect(struct i2c_adapter *adapter, int address, int kind)
 484 {
 485         int i, err;
 486         struct i2c_client *new_client;
 487         struct lm78_data *data;
 488         const char *client_name = "";
 489         int is_isa = i2c_is_isa_adapter(adapter);
 490
 491         if (!is_isa &&
 492             !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
 493                 err = -ENODEV;
 494                 goto ERROR0;
 495         }
 496
 497         /* Reserve the ISA region */
 498         if (is_isa)
 499                 if (!request_region(address, LM78_EXTENT,
 500                                     lm78_isa_driver.name)) {
 501                         err = -EBUSY;
 502                         goto ERROR0;
 503                 }
 504
 505         /* Probe whether there is anything available on this address. Already
 506            done for SMBus clients */
 507         if (kind < 0) {
 508                 if (is_isa) {
 509
 510 #define REALLY_SLOW_IO
 511                         /* We need the timeouts for at least some LM78-like
 512                            chips. But only if we read 'undefined' registers. */
 513                         i = inb_p(address + 1);
 514                         if (inb_p(address + 2) != i) {
 515                                 err = -ENODEV;
 516                                 goto ERROR1;
 517                         }
 518                         if (inb_p(address + 3) != i) {
 519                                 err = -ENODEV;
 520                                 goto ERROR1;
 521                         }
 522                         if (inb_p(address + 7) != i) {
 523                                 err = -ENODEV;
 524                                 goto ERROR1;
 525                         }
 526 #undef REALLY_SLOW_IO
 527
 528                         /* Let's just hope nothing breaks here */
 529                         i = inb_p(address + 5) & 0x7f;
 530                         outb_p(~i & 0x7f, address + 5);
 531                         if ((inb_p(address + 5) & 0x7f) != (~i & 0x7f)) {
 532                                 outb_p(i, address + 5);
 533                                 err = -ENODEV;
 534                                 goto ERROR1;
 535                         }
 536                 }
 537         }
 538
 539         /* OK. For now, we presume we have a valid client. We now create the
 540            client structure, even though we cannot fill it completely yet.
 541            But it allows us to access lm78_{read,write}_value. */
 542
 543         if (!(data = kmalloc(sizeof(struct lm78_data), GFP_KERNEL))) {
 544                 err = -ENOMEM;
 545                 goto ERROR1;
 546         }
 547         memset(data, 0, sizeof(struct lm78_data));
 548
 549         new_client = &data->client;
 550         if (is_isa)
 551                 init_MUTEX(&data->lock);
 552         i2c_set_clientdata(new_client, data);
 553         new_client->addr = address;
 554         new_client->adapter = adapter;
 555         new_client->driver = is_isa ? &lm78_isa_driver : &lm78_driver;
 556         new_client->flags = 0;
 557
 558         /* Now, we do the remaining detection. */
 559         if (kind < 0) {
 560                 if (lm78_read_value(new_client, LM78_REG_CONFIG) & 0x80) {
 561                         err = -ENODEV;
 562                         goto ERROR2;
 563                 }
 564                 if (!is_isa && (lm78_read_value(
 565                                 new_client, LM78_REG_I2C_ADDR) != address)) {
 566                         err = -ENODEV;
 567                         goto ERROR2;
 568                 }
 569         }
 570
 571         /* Determine the chip type. */
 572         if (kind <= 0) {
 573                 i = lm78_read_value(new_client, LM78_REG_CHIPID);
 574                 if (i == 0x00 || i == 0x20      /* LM78 */
 575                  || i == 0x40)                  /* LM78-J */
 576                         kind = lm78;
 577                 else if ((i & 0xfe) == 0xc0)
 578                         kind = lm79;
 579                 else {
 580                         if (kind == 0)
 581                                 dev_warn(&adapter->dev, "Ignoring 'force' "
 582                                         "parameter for unknown chip at "
 583                                         "adapter %d, address 0x%02x\n",
 584                                         i2c_adapter_id(adapter), address);
 585                         err = -ENODEV;
 586                         goto ERROR2;
 587                 }
 588         }
 589
 590         if (kind == lm78) {
 591                 client_name = "lm78";
 592         } else if (kind == lm79) {
 593                 client_name = "lm79";
 594         }
 595
 596         /* Fill in the remaining client fields and put into the global list */
 597         strlcpy(new_client->name, client_name, I2C_NAME_SIZE);
 598         data->type = kind;
 599
 600         data->valid = 0;
 601         init_MUTEX(&data->update_lock);
 602
 603         /* Tell the I2C layer a new client has arrived */
 604         if ((err = i2c_attach_client(new_client)))
 605                 goto ERROR2;
 606
 607         /* Initialize the LM78 chip */
 608         lm78_init_client(new_client);
 609
 610         /* A few vars need to be filled upon startup */
 611         for (i = 0; i < 3; i++) {
 612                 data->fan_min[i] = lm78_read_value(new_client,
 613                                         LM78_REG_FAN_MIN(i));
 614         }
 615
 616         /* Register sysfs hooks */
 617         data->class_dev = hwmon_device_register(&new_client->dev);
 618         if (IS_ERR(data->class_dev)) {
 619                 err = PTR_ERR(data->class_dev);
 620                 goto ERROR3;
 621         }
 622
 623         device_create_file(&new_client->dev, &dev_attr_in0_input);
 624         device_create_file(&new_client->dev, &dev_attr_in0_min);
 625         device_create_file(&new_client->dev, &dev_attr_in0_max);
 626         device_create_file(&new_client->dev, &dev_attr_in1_input);
 627         device_create_file(&new_client->dev, &dev_attr_in1_min);
 628         device_create_file(&new_client->dev, &dev_attr_in1_max);
 629         device_create_file(&new_client->dev, &dev_attr_in2_input);
 630         device_create_file(&new_client->dev, &dev_attr_in2_min);
 631         device_create_file(&new_client->dev, &dev_attr_in2_max);
 632         device_create_file(&new_client->dev, &dev_attr_in3_input);
 633         device_create_file(&new_client->dev, &dev_attr_in3_min);
 634         device_create_file(&new_client->dev, &dev_attr_in3_max);
 635         device_create_file(&new_client->dev, &dev_attr_in4_input);
 636         device_create_file(&new_client->dev, &dev_attr_in4_min);
 637         device_create_file(&new_client->dev, &dev_attr_in4_max);
 638         device_create_file(&new_client->dev, &dev_attr_in5_input);
 639         device_create_file(&new_client->dev, &dev_attr_in5_min);
 640         device_create_file(&new_client->dev, &dev_attr_in5_max);
 641         device_create_file(&new_client->dev, &dev_attr_in6_input);
 642         device_create_file(&new_client->dev, &dev_attr_in6_min);
 643         device_create_file(&new_client->dev, &dev_attr_in6_max);
 644         device_create_file(&new_client->dev, &dev_attr_temp1_input);
 645         device_create_file(&new_client->dev, &dev_attr_temp1_max);
 646         device_create_file(&new_client->dev, &dev_attr_temp1_max_hyst);
 647         device_create_file(&new_client->dev, &dev_attr_fan1_input);
 648         device_create_file(&new_client->dev, &dev_attr_fan1_min);
 649         device_create_file(&new_client->dev, &dev_attr_fan1_div);
 650         device_create_file(&new_client->dev, &dev_attr_fan2_input);
 651         device_create_file(&new_client->dev, &dev_attr_fan2_min);
 652         device_create_file(&new_client->dev, &dev_attr_fan2_div);
 653         device_create_file(&new_client->dev, &dev_attr_fan3_input);
 654         device_create_file(&new_client->dev, &dev_attr_fan3_min);
 655         device_create_file(&new_client->dev, &dev_attr_fan3_div);
 656         device_create_file(&new_client->dev, &dev_attr_alarms);
 657         device_create_file(&new_client->dev, &dev_attr_cpu0_vid);
 658
 659         return 0;
 660
 661 ERROR3:
 662         i2c_detach_client(new_client);
 663 ERROR2:
 664         kfree(data);
 665 ERROR1:
 666         if (is_isa)
 667                 release_region(address, LM78_EXTENT);
 668 ERROR0:
 669         return err;
 670 }
 671
 672 static int lm78_detach_client(struct i2c_client *client)
 673 {
 674         struct lm78_data *data = i2c_get_clientdata(client);
 675         int err;
 676
 677         hwmon_device_unregister(data->class_dev);
 678
 679         if ((err = i2c_detach_client(client)))
 680                 return err;
 681
 682         if(i2c_is_isa_client(client))
 683                 release_region(client->addr, LM78_EXTENT);
 684
 685         kfree(data);
 686
 687         return 0;
 688 }
 689
 690 /* The SMBus locks itself, but ISA access must be locked explicitly!
 691    We don't want to lock the whole ISA bus, so we lock each client
 692    separately.
 693    We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
 694    would slow down the LM78 access and should not be necessary.  */
 695 static int lm78_read_value(struct i2c_client *client, u8 reg)
 696 {
 697         int res;
 698         if (i2c_is_isa_client(client)) {
 699                 struct lm78_data *data = i2c_get_clientdata(client);
 700                 down(&data->lock);
 701                 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
 702                 res = inb_p(client->addr + LM78_DATA_REG_OFFSET);
 703                 up(&data->lock);
 704                 return res;
 705         } else
 706                 return i2c_smbus_read_byte_data(client, reg);
 707 }
 708
 709 /* The SMBus locks itself, but ISA access muse be locked explicitly!
 710    We don't want to lock the whole ISA bus, so we lock each client
 711    separately.
 712    We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
 713    would slow down the LM78 access and should not be necessary.
 714    There are some ugly typecasts here, but the good new is - they should
 715    nowhere else be necessary! */
 716 static int lm78_write_value(struct i2c_client *client, u8 reg, u8 value)
 717 {
 718         if (i2c_is_isa_client(client)) {
 719                 struct lm78_data *data = i2c_get_clientdata(client);
 720                 down(&data->lock);
 721                 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
 722                 outb_p(value, client->addr + LM78_DATA_REG_OFFSET);
 723                 up(&data->lock);
 724                 return 0;
 725         } else
 726                 return i2c_smbus_write_byte_data(client, reg, value);
 727 }
 728
 729 /* Called when we have found a new LM78. It should set limits, etc. */
 730 static void lm78_init_client(struct i2c_client *client)
 731 {
 732         u8 config = lm78_read_value(client, LM78_REG_CONFIG);
 733
 734         /* Start monitoring */
 735         if (!(config & 0x01))
 736                 lm78_write_value(client, LM78_REG_CONFIG,
 737                                  (config & 0xf7) | 0x01);
 738 }
 739
 740 static struct lm78_data *lm78_update_device(struct device *dev)
 741 {
 742         struct i2c_client *client = to_i2c_client(dev);
 743         struct lm78_data *data = i2c_get_clientdata(client);
 744         int i;
 745
 746         down(&data->update_lock);
 747
 748         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
 749             || !data->valid) {
 750
 751                 dev_dbg(&client->dev, "Starting lm78 update\n");
 752
 753                 for (i = 0; i <= 6; i++) {
 754                         data->in[i] =
 755                             lm78_read_value(client, LM78_REG_IN(i));
 756                         data->in_min[i] =
 757                             lm78_read_value(client, LM78_REG_IN_MIN(i));
 758                         data->in_max[i] =
 759                             lm78_read_value(client, LM78_REG_IN_MAX(i));
 760                 }
 761                 for (i = 0; i < 3; i++) {
 762                         data->fan[i] =
 763                             lm78_read_value(client, LM78_REG_FAN(i));
 764                         data->fan_min[i] =
 765                             lm78_read_value(client, LM78_REG_FAN_MIN(i));
 766                 }
 767                 data->temp = lm78_read_value(client, LM78_REG_TEMP);
 768                 data->temp_over =
 769                     lm78_read_value(client, LM78_REG_TEMP_OVER);
 770                 data->temp_hyst =
 771                     lm78_read_value(client, LM78_REG_TEMP_HYST);
 772                 i = lm78_read_value(client, LM78_REG_VID_FANDIV);
 773                 data->vid = i & 0x0f;
 774                 if (data->type == lm79)
 775                         data->vid |=
 776                             (lm78_read_value(client, LM78_REG_CHIPID) &
 777                              0x01) << 4;
 778                 else
 779                         data->vid |= 0x10;
 780                 data->fan_div[0] = (i >> 4) & 0x03;
 781                 data->fan_div[1] = i >> 6;
 782                 data->alarms = lm78_read_value(client, LM78_REG_ALARM1) +
 783                     (lm78_read_value(client, LM78_REG_ALARM2) << 8);
 784                 data->last_updated = jiffies;
 785                 data->valid = 1;
 786
 787                 data->fan_div[2] = 1;
 788         }
 789
 790         up(&data->update_lock);
 791
 792         return data;
 793 }
 794
 795 static int __init sm_lm78_init(void)
 796 {
 797         int res;
 798
 799         res = i2c_add_driver(&lm78_driver);
 800         if (res)
 801                 return res;
 802
 803         res = i2c_isa_add_driver(&lm78_isa_driver);
 804         if (res) {
 805                 i2c_del_driver(&lm78_driver);
 806                 return res;
 807         }
 808
 809         return 0;
 810 }
 811
 812 static void __exit sm_lm78_exit(void)
 813 {
 814         i2c_isa_del_driver(&lm78_isa_driver);
 815         i2c_del_driver(&lm78_driver);
 816 }
 817
 818
 819
 820 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
 821 MODULE_DESCRIPTION("LM78/LM79 driver");
 822 MODULE_LICENSE("GPL");
 823
 824 module_init(sm_lm78_init);
 825 module_exit(sm_lm78_exit);