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