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     Copyright (c) 2007        Jean Delvare <khali@linux-fr.org>
   6
   7     This program is free software; you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License as published by
   9     the Free Software Foundation; either version 2 of the License, or
  10     (at your option) any later version.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with this program; if not, write to the Free Software
  19     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include <linux/module.h>
  23 #include <linux/init.h>
  24 #include <linux/slab.h>
  25 #include <linux/jiffies.h>
  26 #include <linux/i2c.h>
  27 #include <linux/platform_device.h>
  28 #include <linux/ioport.h>
  29 #include <linux/hwmon.h>
  30 #include <linux/hwmon-vid.h>
  31 #include <linux/hwmon-sysfs.h>
  32 #include <linux/err.h>
  33 #include <linux/mutex.h>
  34 #include <asm/io.h>
  35
  36 /* ISA device, if found */
  37 static struct platform_device *pdev;
  38
  39 /* Addresses to scan */
  40 static unsigned short normal_i2c[] = { 0x20, 0x21, 0x22, 0x23, 0x24,
  41                                         0x25, 0x26, 0x27, 0x28, 0x29,
  42                                         0x2a, 0x2b, 0x2c, 0x2d, 0x2e,
  43                                         0x2f, I2C_CLIENT_END };
  44 static unsigned short isa_address = 0x290;
  45
  46 /* Insmod parameters */
  47 I2C_CLIENT_INSMOD_2(lm78, lm79);
  48
  49 /* Many LM78 constants specified below */
  50
  51 /* Length of ISA address segment */
  52 #define LM78_EXTENT 8
  53
  54 /* Where are the ISA address/data registers relative to the base address */
  55 #define LM78_ADDR_REG_OFFSET 5
  56 #define LM78_DATA_REG_OFFSET 6
  57
  58 /* The LM78 registers */
  59 #define LM78_REG_IN_MAX(nr) (0x2b + (nr) * 2)
  60 #define LM78_REG_IN_MIN(nr) (0x2c + (nr) * 2)
  61 #define LM78_REG_IN(nr) (0x20 + (nr))
  62
  63 #define LM78_REG_FAN_MIN(nr) (0x3b + (nr))
  64 #define LM78_REG_FAN(nr) (0x28 + (nr))
  65
  66 #define LM78_REG_TEMP 0x27
  67 #define LM78_REG_TEMP_OVER 0x39
  68 #define LM78_REG_TEMP_HYST 0x3a
  69
  70 #define LM78_REG_ALARM1 0x41
  71 #define LM78_REG_ALARM2 0x42
  72
  73 #define LM78_REG_VID_FANDIV 0x47
  74
  75 #define LM78_REG_CONFIG 0x40
  76 #define LM78_REG_CHIPID 0x49
  77 #define LM78_REG_I2C_ADDR 0x48
  78
  79
  80 /* Conversions. Rounding and limit checking is only done on the TO_REG
  81    variants. */
  82
  83 /* IN: mV, (0V to 4.08V)
  84    REG: 16mV/bit */
  85 static inline u8 IN_TO_REG(unsigned long val)
  86 {
  87         unsigned long nval = SENSORS_LIMIT(val, 0, 4080);
  88         return (nval + 8) / 16;
  89 }
  90 #define IN_FROM_REG(val) ((val) *  16)
  91
  92 static inline u8 FAN_TO_REG(long rpm, int div)
  93 {
  94         if (rpm <= 0)
  95                 return 255;
  96         return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
  97 }
  98
  99 static inline int FAN_FROM_REG(u8 val, int div)
 100 {
 101         return val==0 ? -1 : val==255 ? 0 : 1350000/(val*div);
 102 }
 103
 104 /* TEMP: mC (-128C to +127C)
 105    REG: 1C/bit, two's complement */
 106 static inline s8 TEMP_TO_REG(int val)
 107 {
 108         int nval = SENSORS_LIMIT(val, -128000, 127000) ;
 109         return nval<0 ? (nval-500)/1000 : (nval+500)/1000;
 110 }
 111
 112 static inline int TEMP_FROM_REG(s8 val)
 113 {
 114         return val * 1000;
 115 }
 116
 117 #define DIV_FROM_REG(val) (1 << (val))
 118
 119 /* There are some complications in a module like this. First off, LM78 chips
 120    may be both present on the SMBus and the ISA bus, and we have to handle
 121    those cases separately at some places. Second, there might be several
 122    LM78 chips available (well, actually, that is probably never done; but
 123    it is a clean illustration of how to handle a case like that). Finally,
 124    a specific chip may be attached to *both* ISA and SMBus, and we would
 125    not like to detect it double. Fortunately, in the case of the LM78 at
 126    least, a register tells us what SMBus address we are on, so that helps
 127    a bit - except if there could be more than one SMBus. Groan. No solution
 128    for this yet. */
 129
 130 /* For ISA chips, we abuse the i2c_client addr and name fields. We also use
 131    the driver field to differentiate between I2C and ISA chips. */
 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_detect(struct i2c_adapter *adapter, int address, int kind);
 158 static int lm78_detach_client(struct i2c_client *client);
 159
 160 static int __devinit lm78_isa_probe(struct platform_device *pdev);
 161 static int __devexit lm78_isa_remove(struct platform_device *pdev);
 162
 163 static int lm78_read_value(struct lm78_data *data, u8 reg);
 164 static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value);
 165 static struct lm78_data *lm78_update_device(struct device *dev);
 166 static void lm78_init_device(struct lm78_data *data);
 167
 168
 169 static struct i2c_driver lm78_driver = {
 170         .driver = {
 171                 .name   = "lm78",
 172         },
 173         .id             = I2C_DRIVERID_LM78,
 174         .attach_adapter = lm78_attach_adapter,
 175         .detach_client  = lm78_detach_client,
 176 };
 177
 178 static struct platform_driver lm78_isa_driver = {
 179         .driver = {
 180                 .owner  = THIS_MODULE,
 181                 .name   = "lm78",
 182         },
 183         .probe          = lm78_isa_probe,
 184         .remove         = lm78_isa_remove,
 185 };
 186
 187
 188 /* 7 Voltages */
 189 static ssize_t show_in(struct device *dev, struct device_attribute *da,
 190                        char *buf)
 191 {
 192         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 193         struct lm78_data *data = lm78_update_device(dev);
 194         return sprintf(buf, "%d\n", IN_FROM_REG(data->in[attr->index]));
 195 }
 196
 197 static ssize_t show_in_min(struct device *dev, struct device_attribute *da,
 198                            char *buf)
 199 {
 200         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 201         struct lm78_data *data = lm78_update_device(dev);
 202         return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[attr->index]));
 203 }
 204
 205 static ssize_t show_in_max(struct device *dev, struct device_attribute *da,
 206                            char *buf)
 207 {
 208         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 209         struct lm78_data *data = lm78_update_device(dev);
 210         return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[attr->index]));
 211 }
 212
 213 static ssize_t set_in_min(struct device *dev, struct device_attribute *da,
 214                           const char *buf, size_t count)
 215 {
 216         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 217         struct lm78_data *data = dev_get_drvdata(dev);
 218         unsigned long val = simple_strtoul(buf, NULL, 10);
 219         int nr = attr->index;
 220
 221         mutex_lock(&data->update_lock);
 222         data->in_min[nr] = IN_TO_REG(val);
 223         lm78_write_value(data, LM78_REG_IN_MIN(nr), data->in_min[nr]);
 224         mutex_unlock(&data->update_lock);
 225         return count;
 226 }
 227
 228 static ssize_t set_in_max(struct device *dev, struct device_attribute *da,
 229                           const char *buf, size_t count)
 230 {
 231         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 232         struct lm78_data *data = dev_get_drvdata(dev);
 233         unsigned long val = simple_strtoul(buf, NULL, 10);
 234         int nr = attr->index;
 235
 236         mutex_lock(&data->update_lock);
 237         data->in_max[nr] = IN_TO_REG(val);
 238         lm78_write_value(data, LM78_REG_IN_MAX(nr), data->in_max[nr]);
 239         mutex_unlock(&data->update_lock);
 240         return count;
 241 }
 242
 243 #define show_in_offset(offset)                                  \
 244 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO,          \
 245                 show_in, NULL, offset);                         \
 246 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,  \
 247                 show_in_min, set_in_min, offset);               \
 248 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,  \
 249                 show_in_max, set_in_max, offset);
 250
 251 show_in_offset(0);
 252 show_in_offset(1);
 253 show_in_offset(2);
 254 show_in_offset(3);
 255 show_in_offset(4);
 256 show_in_offset(5);
 257 show_in_offset(6);
 258
 259 /* Temperature */
 260 static ssize_t show_temp(struct device *dev, struct device_attribute *da,
 261                          char *buf)
 262 {
 263         struct lm78_data *data = lm78_update_device(dev);
 264         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));
 265 }
 266
 267 static ssize_t show_temp_over(struct device *dev, struct device_attribute *da,
 268                               char *buf)
 269 {
 270         struct lm78_data *data = lm78_update_device(dev);
 271         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
 272 }
 273
 274 static ssize_t set_temp_over(struct device *dev, struct device_attribute *da,
 275                              const char *buf, size_t count)
 276 {
 277         struct lm78_data *data = dev_get_drvdata(dev);
 278         long val = simple_strtol(buf, NULL, 10);
 279
 280         mutex_lock(&data->update_lock);
 281         data->temp_over = TEMP_TO_REG(val);
 282         lm78_write_value(data, LM78_REG_TEMP_OVER, data->temp_over);
 283         mutex_unlock(&data->update_lock);
 284         return count;
 285 }
 286
 287 static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *da,
 288                               char *buf)
 289 {
 290         struct lm78_data *data = lm78_update_device(dev);
 291         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
 292 }
 293
 294 static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *da,
 295                              const char *buf, size_t count)
 296 {
 297         struct lm78_data *data = dev_get_drvdata(dev);
 298         long val = simple_strtol(buf, NULL, 10);
 299
 300         mutex_lock(&data->update_lock);
 301         data->temp_hyst = TEMP_TO_REG(val);
 302         lm78_write_value(data, LM78_REG_TEMP_HYST, data->temp_hyst);
 303         mutex_unlock(&data->update_lock);
 304         return count;
 305 }
 306
 307 static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL);
 308 static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
 309                 show_temp_over, set_temp_over);
 310 static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
 311                 show_temp_hyst, set_temp_hyst);
 312
 313 /* 3 Fans */
 314 static ssize_t show_fan(struct device *dev, struct device_attribute *da,
 315                         char *buf)
 316 {
 317         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 318         struct lm78_data *data = lm78_update_device(dev);
 319         int nr = attr->index;
 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, struct device_attribute *da,
 325                             char *buf)
 326 {
 327         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 328         struct lm78_data *data = lm78_update_device(dev);
 329         int nr = attr->index;
 330         return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan_min[nr],
 331                 DIV_FROM_REG(data->fan_div[nr])) );
 332 }
 333
 334 static ssize_t set_fan_min(struct device *dev, struct device_attribute *da,
 335                            const char *buf, size_t count)
 336 {
 337         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 338         struct lm78_data *data = dev_get_drvdata(dev);
 339         int nr = attr->index;
 340         unsigned long val = simple_strtoul(buf, NULL, 10);
 341
 342         mutex_lock(&data->update_lock);
 343         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
 344         lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
 345         mutex_unlock(&data->update_lock);
 346         return count;
 347 }
 348
 349 static ssize_t show_fan_div(struct device *dev, struct device_attribute *da,
 350                             char *buf)
 351 {
 352         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 353         struct lm78_data *data = lm78_update_device(dev);
 354         return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[attr->index]));
 355 }
 356
 357 /* Note: we save and restore the fan minimum here, because its value is
 358    determined in part by the fan divisor.  This follows the principle of
 359    least surprise; the user doesn't expect the fan minimum to change just
 360    because the divisor changed. */
 361 static ssize_t set_fan_div(struct device *dev, struct device_attribute *da,
 362                            const char *buf, size_t count)
 363 {
 364         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 365         struct lm78_data *data = dev_get_drvdata(dev);
 366         int nr = attr->index;
 367         unsigned long val = simple_strtoul(buf, NULL, 10);
 368         unsigned long min;
 369         u8 reg;
 370
 371         mutex_lock(&data->update_lock);
 372         min = FAN_FROM_REG(data->fan_min[nr],
 373                            DIV_FROM_REG(data->fan_div[nr]));
 374
 375         switch (val) {
 376         case 1: data->fan_div[nr] = 0; break;
 377         case 2: data->fan_div[nr] = 1; break;
 378         case 4: data->fan_div[nr] = 2; break;
 379         case 8: data->fan_div[nr] = 3; break;
 380         default:
 381                 dev_err(dev, "fan_div value %ld not "
 382                         "supported. Choose one of 1, 2, 4 or 8!\n", val);
 383                 mutex_unlock(&data->update_lock);
 384                 return -EINVAL;
 385         }
 386
 387         reg = lm78_read_value(data, LM78_REG_VID_FANDIV);
 388         switch (nr) {
 389         case 0:
 390                 reg = (reg & 0xcf) | (data->fan_div[nr] << 4);
 391                 break;
 392         case 1:
 393                 reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
 394                 break;
 395         }
 396         lm78_write_value(data, LM78_REG_VID_FANDIV, reg);
 397
 398         data->fan_min[nr] =
 399                 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
 400         lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
 401         mutex_unlock(&data->update_lock);
 402
 403         return count;
 404 }
 405
 406 #define show_fan_offset(offset)                         \
 407 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO,         \
 408                 show_fan, NULL, offset - 1);                    \
 409 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
 410                 show_fan_min, set_fan_min, offset - 1);
 411
 412 show_fan_offset(1);
 413 show_fan_offset(2);
 414 show_fan_offset(3);
 415
 416 /* Fan 3 divisor is locked in H/W */
 417 static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
 418                 show_fan_div, set_fan_div, 0);
 419 static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
 420                 show_fan_div, set_fan_div, 1);
 421 static SENSOR_DEVICE_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2);
 422
 423 /* VID */
 424 static ssize_t show_vid(struct device *dev, struct device_attribute *da,
 425                         char *buf)
 426 {
 427         struct lm78_data *data = lm78_update_device(dev);
 428         return sprintf(buf, "%d\n", vid_from_reg(data->vid, 82));
 429 }
 430 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
 431
 432 /* Alarms */
 433 static ssize_t show_alarms(struct device *dev, struct device_attribute *da,
 434                            char *buf)
 435 {
 436         struct lm78_data *data = lm78_update_device(dev);
 437         return sprintf(buf, "%u\n", data->alarms);
 438 }
 439 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 440
 441 /* This function is called when:
 442      * lm78_driver is inserted (when this module is loaded), for each
 443        available adapter
 444      * when a new adapter is inserted (and lm78_driver is still present) */
 445 static int lm78_attach_adapter(struct i2c_adapter *adapter)
 446 {
 447         if (!(adapter->class & I2C_CLASS_HWMON))
 448                 return 0;
 449         return i2c_probe(adapter, &addr_data, lm78_detect);
 450 }
 451
 452 static struct attribute *lm78_attributes[] = {
 453         &sensor_dev_attr_in0_input.dev_attr.attr,
 454         &sensor_dev_attr_in0_min.dev_attr.attr,
 455         &sensor_dev_attr_in0_max.dev_attr.attr,
 456         &sensor_dev_attr_in1_input.dev_attr.attr,
 457         &sensor_dev_attr_in1_min.dev_attr.attr,
 458         &sensor_dev_attr_in1_max.dev_attr.attr,
 459         &sensor_dev_attr_in2_input.dev_attr.attr,
 460         &sensor_dev_attr_in2_min.dev_attr.attr,
 461         &sensor_dev_attr_in2_max.dev_attr.attr,
 462         &sensor_dev_attr_in3_input.dev_attr.attr,
 463         &sensor_dev_attr_in3_min.dev_attr.attr,
 464         &sensor_dev_attr_in3_max.dev_attr.attr,
 465         &sensor_dev_attr_in4_input.dev_attr.attr,
 466         &sensor_dev_attr_in4_min.dev_attr.attr,
 467         &sensor_dev_attr_in4_max.dev_attr.attr,
 468         &sensor_dev_attr_in5_input.dev_attr.attr,
 469         &sensor_dev_attr_in5_min.dev_attr.attr,
 470         &sensor_dev_attr_in5_max.dev_attr.attr,
 471         &sensor_dev_attr_in6_input.dev_attr.attr,
 472         &sensor_dev_attr_in6_min.dev_attr.attr,
 473         &sensor_dev_attr_in6_max.dev_attr.attr,
 474         &dev_attr_temp1_input.attr,
 475         &dev_attr_temp1_max.attr,
 476         &dev_attr_temp1_max_hyst.attr,
 477         &sensor_dev_attr_fan1_input.dev_attr.attr,
 478         &sensor_dev_attr_fan1_min.dev_attr.attr,
 479         &sensor_dev_attr_fan1_div.dev_attr.attr,
 480         &sensor_dev_attr_fan2_input.dev_attr.attr,
 481         &sensor_dev_attr_fan2_min.dev_attr.attr,
 482         &sensor_dev_attr_fan2_div.dev_attr.attr,
 483         &sensor_dev_attr_fan3_input.dev_attr.attr,
 484         &sensor_dev_attr_fan3_min.dev_attr.attr,
 485         &sensor_dev_attr_fan3_div.dev_attr.attr,
 486         &dev_attr_alarms.attr,
 487         &dev_attr_cpu0_vid.attr,
 488
 489         NULL
 490 };
 491
 492 static const struct attribute_group lm78_group = {
 493         .attrs = lm78_attributes,
 494 };
 495
 496 /* I2C devices get this name attribute automatically, but for ISA devices
 497    we must create it by ourselves. */
 498 static ssize_t show_name(struct device *dev, struct device_attribute
 499                          *devattr, char *buf)
 500 {
 501         struct lm78_data *data = dev_get_drvdata(dev);
 502
 503         return sprintf(buf, "%s\n", data->client.name);
 504 }
 505 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
 506
 507 /* This function is called by i2c_probe */
 508 static int lm78_detect(struct i2c_adapter *adapter, int address, int kind)
 509 {
 510         int i, err;
 511         struct i2c_client *new_client;
 512         struct lm78_data *data;
 513         const char *client_name = "";
 514
 515         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
 516                 err = -ENODEV;
 517                 goto ERROR1;
 518         }
 519
 520         /* OK. For now, we presume we have a valid client. We now create the
 521            client structure, even though we cannot fill it completely yet.
 522            But it allows us to access lm78_{read,write}_value. */
 523
 524         if (!(data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL))) {
 525                 err = -ENOMEM;
 526                 goto ERROR1;
 527         }
 528
 529         new_client = &data->client;
 530         i2c_set_clientdata(new_client, data);
 531         new_client->addr = address;
 532         new_client->adapter = adapter;
 533         new_client->driver = &lm78_driver;
 534
 535         /* Now, we do the remaining detection. */
 536         if (kind < 0) {
 537                 if (lm78_read_value(data, LM78_REG_CONFIG) & 0x80) {
 538                         err = -ENODEV;
 539                         goto ERROR2;
 540                 }
 541                 if (lm78_read_value(data, LM78_REG_I2C_ADDR) !=
 542                     address) {
 543                         err = -ENODEV;
 544                         goto ERROR2;
 545                 }
 546         }
 547
 548         /* Determine the chip type. */
 549         if (kind <= 0) {
 550                 i = lm78_read_value(data, LM78_REG_CHIPID);
 551                 if (i == 0x00 || i == 0x20      /* LM78 */
 552                  || i == 0x40)                  /* LM78-J */
 553                         kind = lm78;
 554                 else if ((i & 0xfe) == 0xc0)
 555                         kind = lm79;
 556                 else {
 557                         if (kind == 0)
 558                                 dev_warn(&adapter->dev, "Ignoring 'force' "
 559                                         "parameter for unknown chip at "
 560                                         "adapter %d, address 0x%02x\n",
 561                                         i2c_adapter_id(adapter), address);
 562                         err = -ENODEV;
 563                         goto ERROR2;
 564                 }
 565         }
 566
 567         if (kind == lm78) {
 568                 client_name = "lm78";
 569         } else if (kind == lm79) {
 570                 client_name = "lm79";
 571         }
 572
 573         /* Fill in the remaining client fields and put into the global list */
 574         strlcpy(new_client->name, client_name, I2C_NAME_SIZE);
 575         data->type = kind;
 576
 577         /* Tell the I2C layer a new client has arrived */
 578         if ((err = i2c_attach_client(new_client)))
 579                 goto ERROR2;
 580
 581         /* Initialize the LM78 chip */
 582         lm78_init_device(data);
 583
 584         /* Register sysfs hooks */
 585         if ((err = sysfs_create_group(&new_client->dev.kobj, &lm78_group)))
 586                 goto ERROR3;
 587
 588         data->class_dev = hwmon_device_register(&new_client->dev);
 589         if (IS_ERR(data->class_dev)) {
 590                 err = PTR_ERR(data->class_dev);
 591                 goto ERROR4;
 592         }
 593
 594         return 0;
 595
 596 ERROR4:
 597         sysfs_remove_group(&new_client->dev.kobj, &lm78_group);
 598 ERROR3:
 599         i2c_detach_client(new_client);
 600 ERROR2:
 601         kfree(data);
 602 ERROR1:
 603         return err;
 604 }
 605
 606 static int lm78_detach_client(struct i2c_client *client)
 607 {
 608         struct lm78_data *data = i2c_get_clientdata(client);
 609         int err;
 610
 611         hwmon_device_unregister(data->class_dev);
 612         sysfs_remove_group(&client->dev.kobj, &lm78_group);
 613
 614         if ((err = i2c_detach_client(client)))
 615                 return err;
 616
 617         kfree(data);
 618
 619         return 0;
 620 }
 621
 622 static int __devinit lm78_isa_probe(struct platform_device *pdev)
 623 {
 624         int err;
 625         struct lm78_data *data;
 626         struct resource *res;
 627         const char *name;
 628
 629         /* Reserve the ISA region */
 630         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
 631         if (!request_region(res->start, LM78_EXTENT, "lm78")) {
 632                 err = -EBUSY;
 633                 goto exit;
 634         }
 635
 636         if (!(data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL))) {
 637                 err = -ENOMEM;
 638                 goto exit_release_region;
 639         }
 640         mutex_init(&data->lock);
 641         data->client.addr = res->start;
 642         i2c_set_clientdata(&data->client, data);
 643         platform_set_drvdata(pdev, data);
 644
 645         if (lm78_read_value(data, LM78_REG_CHIPID) & 0x80) {
 646                 data->type = lm79;
 647                 name = "lm79";
 648         } else {
 649                 data->type = lm78;
 650                 name = "lm78";
 651         }
 652         strlcpy(data->client.name, name, I2C_NAME_SIZE);
 653
 654         /* Initialize the LM78 chip */
 655         lm78_init_device(data);
 656
 657         /* Register sysfs hooks */
 658         if ((err = sysfs_create_group(&pdev->dev.kobj, &lm78_group))
 659          || (err = device_create_file(&pdev->dev, &dev_attr_name)))
 660                 goto exit_remove_files;
 661
 662         data->class_dev = hwmon_device_register(&pdev->dev);
 663         if (IS_ERR(data->class_dev)) {
 664                 err = PTR_ERR(data->class_dev);
 665                 goto exit_remove_files;
 666         }
 667
 668         return 0;
 669
 670  exit_remove_files:
 671         sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
 672         device_remove_file(&pdev->dev, &dev_attr_name);
 673         kfree(data);
 674  exit_release_region:
 675         release_region(res->start, LM78_EXTENT);
 676  exit:
 677         return err;
 678 }
 679
 680 static int __devexit lm78_isa_remove(struct platform_device *pdev)
 681 {
 682         struct lm78_data *data = platform_get_drvdata(pdev);
 683
 684         hwmon_device_unregister(data->class_dev);
 685         sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
 686         device_remove_file(&pdev->dev, &dev_attr_name);
 687         release_region(data->client.addr, LM78_EXTENT);
 688         kfree(data);
 689
 690         return 0;
 691 }
 692
 693 /* The SMBus locks itself, but ISA access must be locked explicitly!
 694    We don't want to lock the whole ISA bus, so we lock each client
 695    separately.
 696    We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
 697    would slow down the LM78 access and should not be necessary.  */
 698 static int lm78_read_value(struct lm78_data *data, u8 reg)
 699 {
 700         struct i2c_client *client = &data->client;
 701
 702         if (!client->driver) { /* ISA device */
 703                 int res;
 704                 mutex_lock(&data->lock);
 705                 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
 706                 res = inb_p(client->addr + LM78_DATA_REG_OFFSET);
 707                 mutex_unlock(&data->lock);
 708                 return res;
 709         } else
 710                 return i2c_smbus_read_byte_data(client, reg);
 711 }
 712
 713 /* The SMBus locks itself, but ISA access muse be locked explicitly!
 714    We don't want to lock the whole ISA bus, so we lock each client
 715    separately.
 716    We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
 717    would slow down the LM78 access and should not be necessary.
 718    There are some ugly typecasts here, but the good new is - they should
 719    nowhere else be necessary! */
 720 static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value)
 721 {
 722         struct i2c_client *client = &data->client;
 723
 724         if (!client->driver) { /* ISA device */
 725                 mutex_lock(&data->lock);
 726                 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
 727                 outb_p(value, client->addr + LM78_DATA_REG_OFFSET);
 728                 mutex_unlock(&data->lock);
 729                 return 0;
 730         } else
 731                 return i2c_smbus_write_byte_data(client, reg, value);
 732 }
 733
 734 static void lm78_init_device(struct lm78_data *data)
 735 {
 736         u8 config;
 737         int i;
 738
 739         /* Start monitoring */
 740         config = lm78_read_value(data, LM78_REG_CONFIG);
 741         if ((config & 0x09) != 0x01)
 742                 lm78_write_value(data, LM78_REG_CONFIG,
 743                                  (config & 0xf7) | 0x01);
 744
 745         /* A few vars need to be filled upon startup */
 746         for (i = 0; i < 3; i++) {
 747                 data->fan_min[i] = lm78_read_value(data,
 748                                         LM78_REG_FAN_MIN(i));
 749         }
 750
 751         mutex_init(&data->update_lock);
 752 }
 753
 754 static struct lm78_data *lm78_update_device(struct device *dev)
 755 {
 756         struct lm78_data *data = dev_get_drvdata(dev);
 757         int i;
 758
 759         mutex_lock(&data->update_lock);
 760
 761         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
 762             || !data->valid) {
 763
 764                 dev_dbg(dev, "Starting lm78 update\n");
 765
 766                 for (i = 0; i <= 6; i++) {
 767                         data->in[i] =
 768                             lm78_read_value(data, LM78_REG_IN(i));
 769                         data->in_min[i] =
 770                             lm78_read_value(data, LM78_REG_IN_MIN(i));
 771                         data->in_max[i] =
 772                             lm78_read_value(data, LM78_REG_IN_MAX(i));
 773                 }
 774                 for (i = 0; i < 3; i++) {
 775                         data->fan[i] =
 776                             lm78_read_value(data, LM78_REG_FAN(i));
 777                         data->fan_min[i] =
 778                             lm78_read_value(data, LM78_REG_FAN_MIN(i));
 779                 }
 780                 data->temp = lm78_read_value(data, LM78_REG_TEMP);
 781                 data->temp_over =
 782                     lm78_read_value(data, LM78_REG_TEMP_OVER);
 783                 data->temp_hyst =
 784                     lm78_read_value(data, LM78_REG_TEMP_HYST);
 785                 i = lm78_read_value(data, LM78_REG_VID_FANDIV);
 786                 data->vid = i & 0x0f;
 787                 if (data->type == lm79)
 788                         data->vid |=
 789                             (lm78_read_value(data, LM78_REG_CHIPID) &
 790                              0x01) << 4;
 791                 else
 792                         data->vid |= 0x10;
 793                 data->fan_div[0] = (i >> 4) & 0x03;
 794                 data->fan_div[1] = i >> 6;
 795                 data->alarms = lm78_read_value(data, LM78_REG_ALARM1) +
 796                     (lm78_read_value(data, LM78_REG_ALARM2) << 8);
 797                 data->last_updated = jiffies;
 798                 data->valid = 1;
 799
 800                 data->fan_div[2] = 1;
 801         }
 802
 803         mutex_unlock(&data->update_lock);
 804
 805         return data;
 806 }
 807
 808 /* return 1 if a supported chip is found, 0 otherwise */
 809 static int __init lm78_isa_found(unsigned short address)
 810 {
 811         int val, save, found = 0;
 812
 813         if (!request_region(address, LM78_EXTENT, "lm78"))
 814                 return 0;
 815
 816 #define REALLY_SLOW_IO
 817         /* We need the timeouts for at least some LM78-like
 818            chips. But only if we read 'undefined' registers. */
 819         val = inb_p(address + 1);
 820         if (inb_p(address + 2) != val
 821          || inb_p(address + 3) != val
 822          || inb_p(address + 7) != val)
 823                 goto release;
 824 #undef REALLY_SLOW_IO
 825
 826         /* We should be able to change the 7 LSB of the address port. The
 827            MSB (busy flag) should be clear initially, set after the write. */
 828         save = inb_p(address + LM78_ADDR_REG_OFFSET);
 829         if (save & 0x80)
 830                 goto release;
 831         val = ~save & 0x7f;
 832         outb_p(val, address + LM78_ADDR_REG_OFFSET);
 833         if (inb_p(address + LM78_ADDR_REG_OFFSET) != (val | 0x80)) {
 834                 outb_p(save, address + LM78_ADDR_REG_OFFSET);
 835                 goto release;
 836         }
 837
 838         /* We found a device, now see if it could be an LM78 */
 839         outb_p(LM78_REG_CONFIG, address + LM78_ADDR_REG_OFFSET);
 840         val = inb_p(address + LM78_DATA_REG_OFFSET);
 841         if (val & 0x80)
 842                 goto release;
 843         outb_p(LM78_REG_I2C_ADDR, address + LM78_ADDR_REG_OFFSET);
 844         val = inb_p(address + LM78_DATA_REG_OFFSET);
 845         if (val < 0x03 || val > 0x77)   /* Not a valid I2C address */
 846                 goto release;
 847
 848         /* The busy flag should be clear again */
 849         if (inb_p(address + LM78_ADDR_REG_OFFSET) & 0x80)
 850                 goto release;
 851
 852         /* Explicitly prevent the misdetection of Winbond chips */
 853         outb_p(0x4f, address + LM78_ADDR_REG_OFFSET);
 854         val = inb_p(address + LM78_DATA_REG_OFFSET);
 855         if (val == 0xa3 || val == 0x5c)
 856                 goto release;
 857
 858         /* Explicitly prevent the misdetection of ITE chips */
 859         outb_p(0x58, address + LM78_ADDR_REG_OFFSET);
 860         val = inb_p(address + LM78_DATA_REG_OFFSET);
 861         if (val == 0x90)
 862                 goto release;
 863
 864         /* Determine the chip type */
 865         outb_p(LM78_REG_CHIPID, address + LM78_ADDR_REG_OFFSET);
 866         val = inb_p(address + LM78_DATA_REG_OFFSET);
 867         if (val == 0x00                 /* LM78 */
 868          || val == 0x40                 /* LM78-J */
 869          || (val & 0xfe) == 0xc0)       /* LM79 */
 870                 found = 1;
 871
 872         if (found)
 873                 pr_info("lm78: Found an %s chip at %#x\n",
 874                         val & 0x80 ? "LM79" : "LM78", (int)address);
 875
 876  release:
 877         release_region(address, LM78_EXTENT);
 878         return found;
 879 }
 880
 881 static int __init lm78_isa_device_add(unsigned short address)
 882 {
 883         struct resource res = {
 884                 .start  = address,
 885                 .end    = address + LM78_EXTENT,
 886                 .name   = "lm78",
 887                 .flags  = IORESOURCE_IO,
 888         };
 889         int err;
 890
 891         pdev = platform_device_alloc("lm78", address);
 892         if (!pdev) {
 893                 err = -ENOMEM;
 894                 printk(KERN_ERR "lm78: Device allocation failed\n");
 895                 goto exit;
 896         }
 897
 898         err = platform_device_add_resources(pdev, &res, 1);
 899         if (err) {
 900                 printk(KERN_ERR "lm78: Device resource addition failed "
 901                        "(%d)\n", err);
 902                 goto exit_device_put;
 903         }
 904
 905         err = platform_device_add(pdev);
 906         if (err) {
 907                 printk(KERN_ERR "lm78: Device addition failed (%d)\n",
 908                        err);
 909                 goto exit_device_put;
 910         }
 911
 912         return 0;
 913
 914  exit_device_put:
 915         platform_device_put(pdev);
 916  exit:
 917         pdev = NULL;
 918         return err;
 919 }
 920
 921 static int __init sm_lm78_init(void)
 922 {
 923         int res;
 924
 925         res = i2c_add_driver(&lm78_driver);
 926         if (res)
 927                 goto exit;
 928
 929         if (lm78_isa_found(isa_address)) {
 930                 res = platform_driver_register(&lm78_isa_driver);
 931                 if (res)
 932                         goto exit_unreg_i2c_driver;
 933
 934                 /* Sets global pdev as a side effect */
 935                 res = lm78_isa_device_add(isa_address);
 936                 if (res)
 937                         goto exit_unreg_isa_driver;
 938         }
 939
 940         return 0;
 941
 942  exit_unreg_isa_driver:
 943         platform_driver_unregister(&lm78_isa_driver);
 944  exit_unreg_i2c_driver:
 945         i2c_del_driver(&lm78_driver);
 946  exit:
 947         return res;
 948 }
 949
 950 static void __exit sm_lm78_exit(void)
 951 {
 952         if (pdev) {
 953                 platform_device_unregister(pdev);
 954                 platform_driver_unregister(&lm78_isa_driver);
 955         }
 956         i2c_del_driver(&lm78_driver);
 957 }
 958
 959
 960
 961 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
 962 MODULE_DESCRIPTION("LM78/LM79 driver");
 963 MODULE_LICENSE("GPL");
 964
 965 module_init(sm_lm78_init);
 966 module_exit(sm_lm78_exit);