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