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