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 static struct attribute *lm78_attributes[] = {
 486         &dev_attr_in0_input.attr,
 487         &dev_attr_in0_min.attr,
 488         &dev_attr_in0_max.attr,
 489         &dev_attr_in1_input.attr,
 490         &dev_attr_in1_min.attr,
 491         &dev_attr_in1_max.attr,
 492         &dev_attr_in2_input.attr,
 493         &dev_attr_in2_min.attr,
 494         &dev_attr_in2_max.attr,
 495         &dev_attr_in3_input.attr,
 496         &dev_attr_in3_min.attr,
 497         &dev_attr_in3_max.attr,
 498         &dev_attr_in4_input.attr,
 499         &dev_attr_in4_min.attr,
 500         &dev_attr_in4_max.attr,
 501         &dev_attr_in5_input.attr,
 502         &dev_attr_in5_min.attr,
 503         &dev_attr_in5_max.attr,
 504         &dev_attr_in6_input.attr,
 505         &dev_attr_in6_min.attr,
 506         &dev_attr_in6_max.attr,
 507         &dev_attr_temp1_input.attr,
 508         &dev_attr_temp1_max.attr,
 509         &dev_attr_temp1_max_hyst.attr,
 510         &dev_attr_fan1_input.attr,
 511         &dev_attr_fan1_min.attr,
 512         &dev_attr_fan1_div.attr,
 513         &dev_attr_fan2_input.attr,
 514         &dev_attr_fan2_min.attr,
 515         &dev_attr_fan2_div.attr,
 516         &dev_attr_fan3_input.attr,
 517         &dev_attr_fan3_min.attr,
 518         &dev_attr_fan3_div.attr,
 519         &dev_attr_alarms.attr,
 520         &dev_attr_cpu0_vid.attr,
 521
 522         NULL
 523 };
 524
 525 static const struct attribute_group lm78_group = {
 526         .attrs = lm78_attributes,
 527 };
 528
 529 /* This function is called by i2c_probe */
 530 static int lm78_detect(struct i2c_adapter *adapter, int address, int kind)
 531 {
 532         int i, err;
 533         struct i2c_client *new_client;
 534         struct lm78_data *data;
 535         const char *client_name = "";
 536         int is_isa = i2c_is_isa_adapter(adapter);
 537
 538         if (!is_isa &&
 539             !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
 540                 err = -ENODEV;
 541                 goto ERROR0;
 542         }
 543
 544         /* Reserve the ISA region */
 545         if (is_isa)
 546                 if (!request_region(address, LM78_EXTENT,
 547                                     lm78_isa_driver.driver.name)) {
 548                         err = -EBUSY;
 549                         goto ERROR0;
 550                 }
 551
 552         /* Probe whether there is anything available on this address. Already
 553            done for SMBus clients */
 554         if (kind < 0) {
 555                 if (is_isa) {
 556
 557 #define REALLY_SLOW_IO
 558                         /* We need the timeouts for at least some LM78-like
 559                            chips. But only if we read 'undefined' registers. */
 560                         i = inb_p(address + 1);
 561                         if (inb_p(address + 2) != i) {
 562                                 err = -ENODEV;
 563                                 goto ERROR1;
 564                         }
 565                         if (inb_p(address + 3) != i) {
 566                                 err = -ENODEV;
 567                                 goto ERROR1;
 568                         }
 569                         if (inb_p(address + 7) != i) {
 570                                 err = -ENODEV;
 571                                 goto ERROR1;
 572                         }
 573 #undef REALLY_SLOW_IO
 574
 575                         /* Let's just hope nothing breaks here */
 576                         i = inb_p(address + 5) & 0x7f;
 577                         outb_p(~i & 0x7f, address + 5);
 578                         if ((inb_p(address + 5) & 0x7f) != (~i & 0x7f)) {
 579                                 outb_p(i, address + 5);
 580                                 err = -ENODEV;
 581                                 goto ERROR1;
 582                         }
 583                 }
 584         }
 585
 586         /* OK. For now, we presume we have a valid client. We now create the
 587            client structure, even though we cannot fill it completely yet.
 588            But it allows us to access lm78_{read,write}_value. */
 589
 590         if (!(data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL))) {
 591                 err = -ENOMEM;
 592                 goto ERROR1;
 593         }
 594
 595         new_client = &data->client;
 596         if (is_isa)
 597                 mutex_init(&data->lock);
 598         i2c_set_clientdata(new_client, data);
 599         new_client->addr = address;
 600         new_client->adapter = adapter;
 601         new_client->driver = is_isa ? &lm78_isa_driver : &lm78_driver;
 602         new_client->flags = 0;
 603
 604         /* Now, we do the remaining detection. */
 605         if (kind < 0) {
 606                 if (lm78_read_value(new_client, LM78_REG_CONFIG) & 0x80) {
 607                         err = -ENODEV;
 608                         goto ERROR2;
 609                 }
 610                 if (!is_isa && (lm78_read_value(
 611                                 new_client, LM78_REG_I2C_ADDR) != address)) {
 612                         err = -ENODEV;
 613                         goto ERROR2;
 614                 }
 615         }
 616
 617         /* Determine the chip type. */
 618         if (kind <= 0) {
 619                 i = lm78_read_value(new_client, LM78_REG_CHIPID);
 620                 if (i == 0x00 || i == 0x20      /* LM78 */
 621                  || i == 0x40)                  /* LM78-J */
 622                         kind = lm78;
 623                 else if ((i & 0xfe) == 0xc0)
 624                         kind = lm79;
 625                 else {
 626                         if (kind == 0)
 627                                 dev_warn(&adapter->dev, "Ignoring 'force' "
 628                                         "parameter for unknown chip at "
 629                                         "adapter %d, address 0x%02x\n",
 630                                         i2c_adapter_id(adapter), address);
 631                         err = -ENODEV;
 632                         goto ERROR2;
 633                 }
 634         }
 635
 636         if (kind == lm78) {
 637                 client_name = "lm78";
 638         } else if (kind == lm79) {
 639                 client_name = "lm79";
 640         }
 641
 642         /* Fill in the remaining client fields and put into the global list */
 643         strlcpy(new_client->name, client_name, I2C_NAME_SIZE);
 644         data->type = kind;
 645
 646         data->valid = 0;
 647         mutex_init(&data->update_lock);
 648
 649         /* Tell the I2C layer a new client has arrived */
 650         if ((err = i2c_attach_client(new_client)))
 651                 goto ERROR2;
 652
 653         /* Initialize the LM78 chip */
 654         lm78_init_client(new_client);
 655
 656         /* A few vars need to be filled upon startup */
 657         for (i = 0; i < 3; i++) {
 658                 data->fan_min[i] = lm78_read_value(new_client,
 659                                         LM78_REG_FAN_MIN(i));
 660         }
 661
 662         /* Register sysfs hooks */
 663         if ((err = sysfs_create_group(&new_client->dev.kobj, &lm78_group)))
 664                 goto ERROR3;
 665
 666         data->class_dev = hwmon_device_register(&new_client->dev);
 667         if (IS_ERR(data->class_dev)) {
 668                 err = PTR_ERR(data->class_dev);
 669                 goto ERROR4;
 670         }
 671
 672         return 0;
 673
 674 ERROR4:
 675         sysfs_remove_group(&new_client->dev.kobj, &lm78_group);
 676 ERROR3:
 677         i2c_detach_client(new_client);
 678 ERROR2:
 679         kfree(data);
 680 ERROR1:
 681         if (is_isa)
 682                 release_region(address, LM78_EXTENT);
 683 ERROR0:
 684         return err;
 685 }
 686
 687 static int lm78_detach_client(struct i2c_client *client)
 688 {
 689         struct lm78_data *data = i2c_get_clientdata(client);
 690         int err;
 691
 692         hwmon_device_unregister(data->class_dev);
 693         sysfs_remove_group(&client->dev.kobj, &lm78_group);
 694
 695         if ((err = i2c_detach_client(client)))
 696                 return err;
 697
 698         if(i2c_is_isa_client(client))
 699                 release_region(client->addr, LM78_EXTENT);
 700
 701         kfree(data);
 702
 703         return 0;
 704 }
 705
 706 /* The SMBus locks itself, but ISA access must be locked explicitly!
 707    We don't want to lock the whole ISA bus, so we lock each client
 708    separately.
 709    We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
 710    would slow down the LM78 access and should not be necessary.  */
 711 static int lm78_read_value(struct i2c_client *client, u8 reg)
 712 {
 713         int res;
 714         if (i2c_is_isa_client(client)) {
 715                 struct lm78_data *data = i2c_get_clientdata(client);
 716                 mutex_lock(&data->lock);
 717                 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
 718                 res = inb_p(client->addr + LM78_DATA_REG_OFFSET);
 719                 mutex_unlock(&data->lock);
 720                 return res;
 721         } else
 722                 return i2c_smbus_read_byte_data(client, reg);
 723 }
 724
 725 /* The SMBus locks itself, but ISA access muse be locked explicitly!
 726    We don't want to lock the whole ISA bus, so we lock each client
 727    separately.
 728    We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
 729    would slow down the LM78 access and should not be necessary.
 730    There are some ugly typecasts here, but the good new is - they should
 731    nowhere else be necessary! */
 732 static int lm78_write_value(struct i2c_client *client, u8 reg, u8 value)
 733 {
 734         if (i2c_is_isa_client(client)) {
 735                 struct lm78_data *data = i2c_get_clientdata(client);
 736                 mutex_lock(&data->lock);
 737                 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
 738                 outb_p(value, client->addr + LM78_DATA_REG_OFFSET);
 739                 mutex_unlock(&data->lock);
 740                 return 0;
 741         } else
 742                 return i2c_smbus_write_byte_data(client, reg, value);
 743 }
 744
 745 static void lm78_init_client(struct i2c_client *client)
 746 {
 747         u8 config = lm78_read_value(client, LM78_REG_CONFIG);
 748
 749         /* Start monitoring */
 750         if (!(config & 0x01))
 751                 lm78_write_value(client, LM78_REG_CONFIG,
 752                                  (config & 0xf7) | 0x01);
 753 }
 754
 755 static struct lm78_data *lm78_update_device(struct device *dev)
 756 {
 757         struct i2c_client *client = to_i2c_client(dev);
 758         struct lm78_data *data = i2c_get_clientdata(client);
 759         int i;
 760
 761         mutex_lock(&data->update_lock);
 762
 763         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
 764             || !data->valid) {
 765
 766                 dev_dbg(&client->dev, "Starting lm78 update\n");
 767
 768                 for (i = 0; i <= 6; i++) {
 769                         data->in[i] =
 770                             lm78_read_value(client, LM78_REG_IN(i));
 771                         data->in_min[i] =
 772                             lm78_read_value(client, LM78_REG_IN_MIN(i));
 773                         data->in_max[i] =
 774                             lm78_read_value(client, LM78_REG_IN_MAX(i));
 775                 }
 776                 for (i = 0; i < 3; i++) {
 777                         data->fan[i] =
 778                             lm78_read_value(client, LM78_REG_FAN(i));
 779                         data->fan_min[i] =
 780                             lm78_read_value(client, LM78_REG_FAN_MIN(i));
 781                 }
 782                 data->temp = lm78_read_value(client, LM78_REG_TEMP);
 783                 data->temp_over =
 784                     lm78_read_value(client, LM78_REG_TEMP_OVER);
 785                 data->temp_hyst =
 786                     lm78_read_value(client, LM78_REG_TEMP_HYST);
 787                 i = lm78_read_value(client, LM78_REG_VID_FANDIV);
 788                 data->vid = i & 0x0f;
 789                 if (data->type == lm79)
 790                         data->vid |=
 791                             (lm78_read_value(client, LM78_REG_CHIPID) &
 792                              0x01) << 4;
 793                 else
 794                         data->vid |= 0x10;
 795                 data->fan_div[0] = (i >> 4) & 0x03;
 796                 data->fan_div[1] = i >> 6;
 797                 data->alarms = lm78_read_value(client, LM78_REG_ALARM1) +
 798                     (lm78_read_value(client, LM78_REG_ALARM2) << 8);
 799                 data->last_updated = jiffies;
 800                 data->valid = 1;
 801
 802                 data->fan_div[2] = 1;
 803         }
 804
 805         mutex_unlock(&data->update_lock);
 806
 807         return data;
 808 }
 809
 810 static int __init sm_lm78_init(void)
 811 {
 812         int res;
 813
 814         res = i2c_add_driver(&lm78_driver);
 815         if (res)
 816                 return res;
 817
 818         res = i2c_isa_add_driver(&lm78_isa_driver);
 819         if (res) {
 820                 i2c_del_driver(&lm78_driver);
 821                 return res;
 822         }
 823
 824         return 0;
 825 }
 826
 827 static void __exit sm_lm78_exit(void)
 828 {
 829         i2c_isa_del_driver(&lm78_isa_driver);
 830         i2c_del_driver(&lm78_driver);
 831 }
 832
 833
 834
 835 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
 836 MODULE_DESCRIPTION("LM78/LM79 driver");
 837 MODULE_LICENSE("GPL");
 838
 839 module_init(sm_lm78_init);
 840 module_exit(sm_lm78_exit);