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