SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/hwmon/w83781d.c

   1 /*
   2     w83781d.c - Part of lm_sensors, Linux kernel modules for hardware
   3                 monitoring
   4     Copyright (c) 1998 - 2001  Frodo Looijaard <frodol@dds.nl>,
   5                                Philip Edelbrock <phil@netroedge.com>,
   6                                and Mark Studebaker <mdsxyz123@yahoo.com>
   7     Copyright (c) 2007         Jean Delvare <khali@linux-fr.org>
   8
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17     GNU General Public License for more details.
  18
  19     You should have received a copy of the GNU General Public License
  20     along with this program; if not, write to the Free Software
  21     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 */
  23
  24 /*
  25     Supports following chips:
  26
  27     Chip        #vin    #fanin  #pwm    #temp   wchipid vendid  i2c     ISA
  28     as99127f    7       3       0       3       0x31    0x12c3  yes     no
  29     as99127f rev.2 (type_name = as99127f)       0x31    0x5ca3  yes     no
  30     w83781d     7       3       0       3       0x10-1  0x5ca3  yes     yes
  31     w83627hf    9       3       2       3       0x21    0x5ca3  yes     yes(LPC)
  32     w83782d     9       3       2-4     3       0x30    0x5ca3  yes     yes
  33     w83783s     5-6     3       2       1-2     0x40    0x5ca3  yes     no
  34
  35 */
  36
  37 #include <linux/module.h>
  38 #include <linux/init.h>
  39 #include <linux/slab.h>
  40 #include <linux/jiffies.h>
  41 #include <linux/i2c.h>
  42 #include <linux/platform_device.h>
  43 #include <linux/ioport.h>
  44 #include <linux/hwmon.h>
  45 #include <linux/hwmon-vid.h>
  46 #include <linux/hwmon-sysfs.h>
  47 #include <linux/sysfs.h>
  48 #include <linux/err.h>
  49 #include <linux/mutex.h>
  50 #include <asm/io.h>
  51 #include "lm75.h"
  52
  53 /* ISA device, if found */
  54 static struct platform_device *pdev;
  55
  56 /* Addresses to scan */
  57 static unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
  58                                        0x2e, 0x2f, I2C_CLIENT_END };
  59 static unsigned short isa_address = 0x290;
  60
  61 /* Insmod parameters */
  62 I2C_CLIENT_INSMOD_5(w83781d, w83782d, w83783s, w83627hf, as99127f);
  63 I2C_CLIENT_MODULE_PARM(force_subclients, "List of subclient addresses: "
  64                     "{bus, clientaddr, subclientaddr1, subclientaddr2}");
  65
  66 static int reset;
  67 module_param(reset, bool, 0);
  68 MODULE_PARM_DESC(reset, "Set to one to reset chip on load");
  69
  70 static int init = 1;
  71 module_param(init, bool, 0);
  72 MODULE_PARM_DESC(init, "Set to zero to bypass chip initialization");
  73
  74 /* Constants specified below */
  75
  76 /* Length of ISA address segment */
  77 #define W83781D_EXTENT                  8
  78
  79 /* Where are the ISA address/data registers relative to the base address */
  80 #define W83781D_ADDR_REG_OFFSET         5
  81 #define W83781D_DATA_REG_OFFSET         6
  82
  83 /* The device registers */
  84 /* in nr from 0 to 8 */
  85 #define W83781D_REG_IN_MAX(nr)          ((nr < 7) ? (0x2b + (nr) * 2) : \
  86                                                     (0x554 + (((nr) - 7) * 2)))
  87 #define W83781D_REG_IN_MIN(nr)          ((nr < 7) ? (0x2c + (nr) * 2) : \
  88                                                     (0x555 + (((nr) - 7) * 2)))
  89 #define W83781D_REG_IN(nr)              ((nr < 7) ? (0x20 + (nr)) : \
  90                                                     (0x550 + (nr) - 7))
  91
  92 /* fan nr from 0 to 2 */
  93 #define W83781D_REG_FAN_MIN(nr)         (0x3b + (nr))
  94 #define W83781D_REG_FAN(nr)             (0x28 + (nr))
  95
  96 #define W83781D_REG_BANK                0x4E
  97 #define W83781D_REG_TEMP2_CONFIG        0x152
  98 #define W83781D_REG_TEMP3_CONFIG        0x252
  99 /* temp nr from 1 to 3 */
 100 #define W83781D_REG_TEMP(nr)            ((nr == 3) ? (0x0250) : \
 101                                         ((nr == 2) ? (0x0150) : \
 102                                                      (0x27)))
 103 #define W83781D_REG_TEMP_HYST(nr)       ((nr == 3) ? (0x253) : \
 104                                         ((nr == 2) ? (0x153) : \
 105                                                      (0x3A)))
 106 #define W83781D_REG_TEMP_OVER(nr)       ((nr == 3) ? (0x255) : \
 107                                         ((nr == 2) ? (0x155) : \
 108                                                      (0x39)))
 109
 110 #define W83781D_REG_CONFIG              0x40
 111
 112 /* Interrupt status (W83781D, AS99127F) */
 113 #define W83781D_REG_ALARM1              0x41
 114 #define W83781D_REG_ALARM2              0x42
 115
 116 /* Real-time status (W83782D, W83783S, W83627HF) */
 117 #define W83782D_REG_ALARM1              0x459
 118 #define W83782D_REG_ALARM2              0x45A
 119 #define W83782D_REG_ALARM3              0x45B
 120
 121 #define W83781D_REG_BEEP_CONFIG         0x4D
 122 #define W83781D_REG_BEEP_INTS1          0x56
 123 #define W83781D_REG_BEEP_INTS2          0x57
 124 #define W83781D_REG_BEEP_INTS3          0x453   /* not on W83781D */
 125
 126 #define W83781D_REG_VID_FANDIV          0x47
 127
 128 #define W83781D_REG_CHIPID              0x49
 129 #define W83781D_REG_WCHIPID             0x58
 130 #define W83781D_REG_CHIPMAN             0x4F
 131 #define W83781D_REG_PIN                 0x4B
 132
 133 /* 782D/783S only */
 134 #define W83781D_REG_VBAT                0x5D
 135
 136 /* PWM 782D (1-4) and 783S (1-2) only */
 137 static const u8 W83781D_REG_PWM[] = { 0x5B, 0x5A, 0x5E, 0x5F };
 138 #define W83781D_REG_PWMCLK12            0x5C
 139 #define W83781D_REG_PWMCLK34            0x45C
 140
 141 #define W83781D_REG_I2C_ADDR            0x48
 142 #define W83781D_REG_I2C_SUBADDR         0x4A
 143
 144 /* The following are undocumented in the data sheets however we
 145    received the information in an email from Winbond tech support */
 146 /* Sensor selection - not on 781d */
 147 #define W83781D_REG_SCFG1               0x5D
 148 static const u8 BIT_SCFG1[] = { 0x02, 0x04, 0x08 };
 149
 150 #define W83781D_REG_SCFG2               0x59
 151 static const u8 BIT_SCFG2[] = { 0x10, 0x20, 0x40 };
 152
 153 #define W83781D_DEFAULT_BETA            3435
 154
 155 /* RT Table registers */
 156 #define W83781D_REG_RT_IDX              0x50
 157 #define W83781D_REG_RT_VAL              0x51
 158
 159 /* Conversions */
 160 #define IN_TO_REG(val)                  SENSORS_LIMIT(((val) + 8) / 16, 0, 255)
 161 #define IN_FROM_REG(val)                ((val) * 16)
 162
 163 static inline u8
 164 FAN_TO_REG(long rpm, int div)
 165 {
 166         if (rpm == 0)
 167                 return 255;
 168         rpm = SENSORS_LIMIT(rpm, 1, 1000000);
 169         return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
 170 }
 171
 172 static inline long
 173 FAN_FROM_REG(u8 val, int div)
 174 {
 175         if (val == 0)
 176                 return -1;
 177         if (val == 255)
 178                 return 0;
 179         return 1350000 / (val * div);
 180 }
 181
 182 #define TEMP_TO_REG(val)                SENSORS_LIMIT((val) / 1000, -127, 128)
 183 #define TEMP_FROM_REG(val)              ((val) * 1000)
 184
 185 #define BEEP_MASK_FROM_REG(val,type)    ((type) == as99127f ? \
 186                                          (val) ^ 0x7fff : (val))
 187 #define BEEP_MASK_TO_REG(val,type)      ((type) == as99127f ? \
 188                                          (~(val)) & 0x7fff : (val) & 0xffffff)
 189
 190 #define DIV_FROM_REG(val)               (1 << (val))
 191
 192 static inline u8
 193 DIV_TO_REG(long val, enum chips type)
 194 {
 195         int i;
 196         val = SENSORS_LIMIT(val, 1,
 197                             ((type == w83781d
 198                               || type == as99127f) ? 8 : 128)) >> 1;
 199         for (i = 0; i < 7; i++) {
 200                 if (val == 0)
 201                         break;
 202                 val >>= 1;
 203         }
 204         return i;
 205 }
 206
 207 /* There are some complications in a module like this. First off, W83781D chips
 208    may be both present on the SMBus and the ISA bus, and we have to handle
 209    those cases separately at some places. Second, there might be several
 210    W83781D chips available (well, actually, that is probably never done; but
 211    it is a clean illustration of how to handle a case like that). Finally,
 212    a specific chip may be attached to *both* ISA and SMBus, and we would
 213    not like to detect it double. Fortunately, in the case of the W83781D at
 214    least, a register tells us what SMBus address we are on, so that helps
 215    a bit - except if there could be more than one SMBus. Groan. No solution
 216    for this yet. */
 217
 218 /* For ISA chips, we abuse the i2c_client addr and name fields. We also use
 219    the driver field to differentiate between I2C and ISA chips. */
 220 struct w83781d_data {
 221         struct i2c_client client;
 222         struct device *hwmon_dev;
 223         struct mutex lock;
 224         enum chips type;
 225
 226         struct mutex update_lock;
 227         char valid;             /* !=0 if following fields are valid */
 228         unsigned long last_updated;     /* In jiffies */
 229
 230         struct i2c_client *lm75[2];     /* for secondary I2C addresses */
 231         /* array of 2 pointers to subclients */
 232
 233         u8 in[9];               /* Register value - 8 & 9 for 782D only */
 234         u8 in_max[9];           /* Register value - 8 & 9 for 782D only */
 235         u8 in_min[9];           /* Register value - 8 & 9 for 782D only */
 236         u8 fan[3];              /* Register value */
 237         u8 fan_min[3];          /* Register value */
 238         s8 temp;                /* Register value */
 239         s8 temp_max;            /* Register value */
 240         s8 temp_max_hyst;       /* Register value */
 241         u16 temp_add[2];        /* Register value */
 242         u16 temp_max_add[2];    /* Register value */
 243         u16 temp_max_hyst_add[2];       /* Register value */
 244         u8 fan_div[3];          /* Register encoding, shifted right */
 245         u8 vid;                 /* Register encoding, combined */
 246         u32 alarms;             /* Register encoding, combined */
 247         u32 beep_mask;          /* Register encoding, combined */
 248         u8 beep_enable;         /* Boolean */
 249         u8 pwm[4];              /* Register value */
 250         u8 pwm2_enable;         /* Boolean */
 251         u16 sens[3];            /* 782D/783S only.
 252                                    1 = pentium diode; 2 = 3904 diode;
 253                                    4 = thermistor */
 254         u8 vrm;
 255 };
 256
 257 static int w83781d_attach_adapter(struct i2c_adapter *adapter);
 258 static int w83781d_detect(struct i2c_adapter *adapter, int address, int kind);
 259 static int w83781d_detach_client(struct i2c_client *client);
 260
 261 static int __devinit w83781d_isa_probe(struct platform_device *pdev);
 262 static int __devexit w83781d_isa_remove(struct platform_device *pdev);
 263
 264 static int w83781d_read_value(struct w83781d_data *data, u16 reg);
 265 static int w83781d_write_value(struct w83781d_data *data, u16 reg, u16 value);
 266 static struct w83781d_data *w83781d_update_device(struct device *dev);
 267 static void w83781d_init_device(struct device *dev);
 268
 269 static struct i2c_driver w83781d_driver = {
 270         .driver = {
 271                 .name = "w83781d",
 272         },
 273         .id = I2C_DRIVERID_W83781D,
 274         .attach_adapter = w83781d_attach_adapter,
 275         .detach_client = w83781d_detach_client,
 276 };
 277
 278 static struct platform_driver w83781d_isa_driver = {
 279         .driver = {
 280                 .owner = THIS_MODULE,
 281                 .name = "w83781d",
 282         },
 283         .probe = w83781d_isa_probe,
 284         .remove = w83781d_isa_remove,
 285 };
 286
 287
 288 /* following are the sysfs callback functions */
 289 #define show_in_reg(reg) \
 290 static ssize_t show_##reg (struct device *dev, struct device_attribute *da, \
 291                 char *buf) \
 292 { \
 293         struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
 294         struct w83781d_data *data = w83781d_update_device(dev); \
 295         return sprintf(buf, "%ld\n", \
 296                        (long)IN_FROM_REG(data->reg[attr->index])); \
 297 }
 298 show_in_reg(in);
 299 show_in_reg(in_min);
 300 show_in_reg(in_max);
 301
 302 #define store_in_reg(REG, reg) \
 303 static ssize_t store_in_##reg (struct device *dev, struct device_attribute \
 304                 *da, const char *buf, size_t count) \
 305 { \
 306         struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
 307         struct w83781d_data *data = dev_get_drvdata(dev); \
 308         int nr = attr->index; \
 309         u32 val; \
 310          \
 311         val = simple_strtoul(buf, NULL, 10); \
 312          \
 313         mutex_lock(&data->update_lock); \
 314         data->in_##reg[nr] = IN_TO_REG(val); \
 315         w83781d_write_value(data, W83781D_REG_IN_##REG(nr), data->in_##reg[nr]); \
 316          \
 317         mutex_unlock(&data->update_lock); \
 318         return count; \
 319 }
 320 store_in_reg(MIN, min);
 321 store_in_reg(MAX, max);
 322
 323 #define sysfs_in_offsets(offset) \
 324 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
 325                 show_in, NULL, offset); \
 326 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
 327                 show_in_min, store_in_min, offset); \
 328 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
 329                 show_in_max, store_in_max, offset)
 330
 331 sysfs_in_offsets(0);
 332 sysfs_in_offsets(1);
 333 sysfs_in_offsets(2);
 334 sysfs_in_offsets(3);
 335 sysfs_in_offsets(4);
 336 sysfs_in_offsets(5);
 337 sysfs_in_offsets(6);
 338 sysfs_in_offsets(7);
 339 sysfs_in_offsets(8);
 340
 341 #define show_fan_reg(reg) \
 342 static ssize_t show_##reg (struct device *dev, struct device_attribute *da, \
 343                 char *buf) \
 344 { \
 345         struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
 346         struct w83781d_data *data = w83781d_update_device(dev); \
 347         return sprintf(buf,"%ld\n", \
 348                 FAN_FROM_REG(data->reg[attr->index], \
 349                         DIV_FROM_REG(data->fan_div[attr->index]))); \
 350 }
 351 show_fan_reg(fan);
 352 show_fan_reg(fan_min);
 353
 354 static ssize_t
 355 store_fan_min(struct device *dev, struct device_attribute *da,
 356                 const char *buf, size_t count)
 357 {
 358         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 359         struct w83781d_data *data = dev_get_drvdata(dev);
 360         int nr = attr->index;
 361         u32 val;
 362
 363         val = simple_strtoul(buf, NULL, 10);
 364
 365         mutex_lock(&data->update_lock);
 366         data->fan_min[nr] =
 367             FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
 368         w83781d_write_value(data, W83781D_REG_FAN_MIN(nr),
 369                             data->fan_min[nr]);
 370
 371         mutex_unlock(&data->update_lock);
 372         return count;
 373 }
 374
 375 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
 376 static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO | S_IWUSR,
 377                 show_fan_min, store_fan_min, 0);
 378 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1);
 379 static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO | S_IWUSR,
 380                 show_fan_min, store_fan_min, 1);
 381 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2);
 382 static SENSOR_DEVICE_ATTR(fan3_min, S_IRUGO | S_IWUSR,
 383                 show_fan_min, store_fan_min, 2);
 384
 385 #define show_temp_reg(reg) \
 386 static ssize_t show_##reg (struct device *dev, struct device_attribute *da, \
 387                 char *buf) \
 388 { \
 389         struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
 390         struct w83781d_data *data = w83781d_update_device(dev); \
 391         int nr = attr->index; \
 392         if (nr >= 2) {  /* TEMP2 and TEMP3 */ \
 393                 return sprintf(buf,"%d\n", \
 394                         LM75_TEMP_FROM_REG(data->reg##_add[nr-2])); \
 395         } else {        /* TEMP1 */ \
 396                 return sprintf(buf,"%ld\n", (long)TEMP_FROM_REG(data->reg)); \
 397         } \
 398 }
 399 show_temp_reg(temp);
 400 show_temp_reg(temp_max);
 401 show_temp_reg(temp_max_hyst);
 402
 403 #define store_temp_reg(REG, reg) \
 404 static ssize_t store_temp_##reg (struct device *dev, \
 405                 struct device_attribute *da, const char *buf, size_t count) \
 406 { \
 407         struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
 408         struct w83781d_data *data = dev_get_drvdata(dev); \
 409         int nr = attr->index; \
 410         long val; \
 411          \
 412         val = simple_strtol(buf, NULL, 10); \
 413          \
 414         mutex_lock(&data->update_lock); \
 415          \
 416         if (nr >= 2) {  /* TEMP2 and TEMP3 */ \
 417                 data->temp_##reg##_add[nr-2] = LM75_TEMP_TO_REG(val); \
 418                 w83781d_write_value(data, W83781D_REG_TEMP_##REG(nr), \
 419                                 data->temp_##reg##_add[nr-2]); \
 420         } else {        /* TEMP1 */ \
 421                 data->temp_##reg = TEMP_TO_REG(val); \
 422                 w83781d_write_value(data, W83781D_REG_TEMP_##REG(nr), \
 423                         data->temp_##reg); \
 424         } \
 425          \
 426         mutex_unlock(&data->update_lock); \
 427         return count; \
 428 }
 429 store_temp_reg(OVER, max);
 430 store_temp_reg(HYST, max_hyst);
 431
 432 #define sysfs_temp_offsets(offset) \
 433 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
 434                 show_temp, NULL, offset); \
 435 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
 436                 show_temp_max, store_temp_max, offset); \
 437 static SENSOR_DEVICE_ATTR(temp##offset##_max_hyst, S_IRUGO | S_IWUSR, \
 438                 show_temp_max_hyst, store_temp_max_hyst, offset);
 439
 440 sysfs_temp_offsets(1);
 441 sysfs_temp_offsets(2);
 442 sysfs_temp_offsets(3);
 443
 444 static ssize_t
 445 show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
 446 {
 447         struct w83781d_data *data = w83781d_update_device(dev);
 448         return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm));
 449 }
 450
 451 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
 452
 453 static ssize_t
 454 show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
 455 {
 456         struct w83781d_data *data = dev_get_drvdata(dev);
 457         return sprintf(buf, "%ld\n", (long) data->vrm);
 458 }
 459
 460 static ssize_t
 461 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 462 {
 463         struct w83781d_data *data = dev_get_drvdata(dev);
 464         u32 val;
 465
 466         val = simple_strtoul(buf, NULL, 10);
 467         data->vrm = val;
 468
 469         return count;
 470 }
 471
 472 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
 473
 474 static ssize_t
 475 show_alarms_reg(struct device *dev, struct device_attribute *attr, char *buf)
 476 {
 477         struct w83781d_data *data = w83781d_update_device(dev);
 478         return sprintf(buf, "%u\n", data->alarms);
 479 }
 480
 481 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
 482
 483 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
 484                 char *buf)
 485 {
 486         struct w83781d_data *data = w83781d_update_device(dev);
 487         int bitnr = to_sensor_dev_attr(attr)->index;
 488         return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
 489 }
 490
 491 /* The W83781D has a single alarm bit for temp2 and temp3 */
 492 static ssize_t show_temp3_alarm(struct device *dev,
 493                 struct device_attribute *attr, char *buf)
 494 {
 495         struct w83781d_data *data = w83781d_update_device(dev);
 496         int bitnr = (data->type == w83781d) ? 5 : 13;
 497         return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
 498 }
 499
 500 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
 501 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
 502 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
 503 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
 504 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
 505 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9);
 506 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 10);
 507 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 16);
 508 static SENSOR_DEVICE_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 17);
 509 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
 510 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
 511 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11);
 512 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4);
 513 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5);
 514 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_temp3_alarm, NULL, 0);
 515
 516 static ssize_t show_beep_mask (struct device *dev, struct device_attribute *attr, char *buf)
 517 {
 518         struct w83781d_data *data = w83781d_update_device(dev);
 519         return sprintf(buf, "%ld\n",
 520                        (long)BEEP_MASK_FROM_REG(data->beep_mask, data->type));
 521 }
 522 static ssize_t show_beep_enable (struct device *dev, struct device_attribute *attr, char *buf)
 523 {
 524         struct w83781d_data *data = w83781d_update_device(dev);
 525         return sprintf(buf, "%ld\n", (long)data->beep_enable);
 526 }
 527
 528 static ssize_t
 529 store_beep_mask(struct device *dev, struct device_attribute *attr,
 530                 const char *buf, size_t count)
 531 {
 532         struct w83781d_data *data = dev_get_drvdata(dev);
 533         u32 val;
 534
 535         val = simple_strtoul(buf, NULL, 10);
 536
 537         mutex_lock(&data->update_lock);
 538         data->beep_mask = BEEP_MASK_TO_REG(val, data->type);
 539         w83781d_write_value(data, W83781D_REG_BEEP_INTS1,
 540                             data->beep_mask & 0xff);
 541         w83781d_write_value(data, W83781D_REG_BEEP_INTS2,
 542                             ((data->beep_mask >> 8) & 0x7f)
 543                             | data->beep_enable << 7);
 544         if (data->type != w83781d && data->type != as99127f) {
 545                 w83781d_write_value(data, W83781D_REG_BEEP_INTS3,
 546                                     ((data->beep_mask) >> 16) & 0xff);
 547         }
 548         mutex_unlock(&data->update_lock);
 549
 550         return count;
 551 }
 552
 553 static ssize_t
 554 store_beep_enable(struct device *dev, struct device_attribute *attr,
 555                 const char *buf, size_t count)
 556 {
 557         struct w83781d_data *data = dev_get_drvdata(dev);
 558         u32 val;
 559
 560         val = simple_strtoul(buf, NULL, 10);
 561         if (val != 0 && val != 1)
 562                 return -EINVAL;
 563
 564         mutex_lock(&data->update_lock);
 565         data->beep_enable = val;
 566         val = w83781d_read_value(data, W83781D_REG_BEEP_INTS2) & 0x7f;
 567         val |= data->beep_enable << 7;
 568         w83781d_write_value(data, W83781D_REG_BEEP_INTS2, val);
 569         mutex_unlock(&data->update_lock);
 570
 571         return count;
 572 }
 573
 574 static DEVICE_ATTR(beep_mask, S_IRUGO | S_IWUSR,
 575                 show_beep_mask, store_beep_mask);
 576 static DEVICE_ATTR(beep_enable, S_IRUGO | S_IWUSR,
 577                 show_beep_enable, store_beep_enable);
 578
 579 static ssize_t show_beep(struct device *dev, struct device_attribute *attr,
 580                 char *buf)
 581 {
 582         struct w83781d_data *data = w83781d_update_device(dev);
 583         int bitnr = to_sensor_dev_attr(attr)->index;
 584         return sprintf(buf, "%u\n", (data->beep_mask >> bitnr) & 1);
 585 }
 586
 587 static ssize_t
 588 store_beep(struct device *dev, struct device_attribute *attr,
 589                 const char *buf, size_t count)
 590 {
 591         struct w83781d_data *data = dev_get_drvdata(dev);
 592         int bitnr = to_sensor_dev_attr(attr)->index;
 593         unsigned long bit;
 594         u8 reg;
 595
 596         bit = simple_strtoul(buf, NULL, 10);
 597         if (bit & ~1)
 598                 return -EINVAL;
 599
 600         mutex_lock(&data->update_lock);
 601         if (bit)
 602                 data->beep_mask |= (1 << bitnr);
 603         else
 604                 data->beep_mask &= ~(1 << bitnr);
 605
 606         if (bitnr < 8) {
 607                 reg = w83781d_read_value(data, W83781D_REG_BEEP_INTS1);
 608                 if (bit)
 609                         reg |= (1 << bitnr);
 610                 else
 611                         reg &= ~(1 << bitnr);
 612                 w83781d_write_value(data, W83781D_REG_BEEP_INTS1, reg);
 613         } else if (bitnr < 16) {
 614                 reg = w83781d_read_value(data, W83781D_REG_BEEP_INTS2);
 615                 if (bit)
 616                         reg |= (1 << (bitnr - 8));
 617                 else
 618                         reg &= ~(1 << (bitnr - 8));
 619                 w83781d_write_value(data, W83781D_REG_BEEP_INTS2, reg);
 620         } else {
 621                 reg = w83781d_read_value(data, W83781D_REG_BEEP_INTS3);
 622                 if (bit)
 623                         reg |= (1 << (bitnr - 16));
 624                 else
 625                         reg &= ~(1 << (bitnr - 16));
 626                 w83781d_write_value(data, W83781D_REG_BEEP_INTS3, reg);
 627         }
 628         mutex_unlock(&data->update_lock);
 629
 630         return count;
 631 }
 632
 633 /* The W83781D has a single beep bit for temp2 and temp3 */
 634 static ssize_t show_temp3_beep(struct device *dev,
 635                 struct device_attribute *attr, char *buf)
 636 {
 637         struct w83781d_data *data = w83781d_update_device(dev);
 638         int bitnr = (data->type == w83781d) ? 5 : 13;
 639         return sprintf(buf, "%u\n", (data->beep_mask >> bitnr) & 1);
 640 }
 641
 642 static SENSOR_DEVICE_ATTR(in0_beep, S_IRUGO | S_IWUSR,
 643                         show_beep, store_beep, 0);
 644 static SENSOR_DEVICE_ATTR(in1_beep, S_IRUGO | S_IWUSR,
 645                         show_beep, store_beep, 1);
 646 static SENSOR_DEVICE_ATTR(in2_beep, S_IRUGO | S_IWUSR,
 647                         show_beep, store_beep, 2);
 648 static SENSOR_DEVICE_ATTR(in3_beep, S_IRUGO | S_IWUSR,
 649                         show_beep, store_beep, 3);
 650 static SENSOR_DEVICE_ATTR(in4_beep, S_IRUGO | S_IWUSR,
 651                         show_beep, store_beep, 8);
 652 static SENSOR_DEVICE_ATTR(in5_beep, S_IRUGO | S_IWUSR,
 653                         show_beep, store_beep, 9);
 654 static SENSOR_DEVICE_ATTR(in6_beep, S_IRUGO | S_IWUSR,
 655                         show_beep, store_beep, 10);
 656 static SENSOR_DEVICE_ATTR(in7_beep, S_IRUGO | S_IWUSR,
 657                         show_beep, store_beep, 16);
 658 static SENSOR_DEVICE_ATTR(in8_beep, S_IRUGO | S_IWUSR,
 659                         show_beep, store_beep, 17);
 660 static SENSOR_DEVICE_ATTR(fan1_beep, S_IRUGO | S_IWUSR,
 661                         show_beep, store_beep, 6);
 662 static SENSOR_DEVICE_ATTR(fan2_beep, S_IRUGO | S_IWUSR,
 663                         show_beep, store_beep, 7);
 664 static SENSOR_DEVICE_ATTR(fan3_beep, S_IRUGO | S_IWUSR,
 665                         show_beep, store_beep, 11);
 666 static SENSOR_DEVICE_ATTR(temp1_beep, S_IRUGO | S_IWUSR,
 667                         show_beep, store_beep, 4);
 668 static SENSOR_DEVICE_ATTR(temp2_beep, S_IRUGO | S_IWUSR,
 669                         show_beep, store_beep, 5);
 670 static SENSOR_DEVICE_ATTR(temp3_beep, S_IRUGO,
 671                         show_temp3_beep, store_beep, 13);
 672
 673 static ssize_t
 674 show_fan_div(struct device *dev, struct device_attribute *da, char *buf)
 675 {
 676         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 677         struct w83781d_data *data = w83781d_update_device(dev);
 678         return sprintf(buf, "%ld\n",
 679                        (long) DIV_FROM_REG(data->fan_div[attr->index]));
 680 }
 681
 682 /* Note: we save and restore the fan minimum here, because its value is
 683    determined in part by the fan divisor.  This follows the principle of
 684    least surprise; the user doesn't expect the fan minimum to change just
 685    because the divisor changed. */
 686 static ssize_t
 687 store_fan_div(struct device *dev, struct device_attribute *da,
 688                 const char *buf, size_t count)
 689 {
 690         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 691         struct w83781d_data *data = dev_get_drvdata(dev);
 692         unsigned long min;
 693         int nr = attr->index;
 694         u8 reg;
 695         unsigned long val = simple_strtoul(buf, NULL, 10);
 696
 697         mutex_lock(&data->update_lock);
 698
 699         /* Save fan_min */
 700         min = FAN_FROM_REG(data->fan_min[nr],
 701                            DIV_FROM_REG(data->fan_div[nr]));
 702
 703         data->fan_div[nr] = DIV_TO_REG(val, data->type);
 704
 705         reg = (w83781d_read_value(data, nr==2 ? W83781D_REG_PIN : W83781D_REG_VID_FANDIV)
 706                & (nr==0 ? 0xcf : 0x3f))
 707             | ((data->fan_div[nr] & 0x03) << (nr==0 ? 4 : 6));
 708         w83781d_write_value(data, nr==2 ? W83781D_REG_PIN : W83781D_REG_VID_FANDIV, reg);
 709
 710         /* w83781d and as99127f don't have extended divisor bits */
 711         if (data->type != w83781d && data->type != as99127f) {
 712                 reg = (w83781d_read_value(data, W83781D_REG_VBAT)
 713                        & ~(1 << (5 + nr)))
 714                     | ((data->fan_div[nr] & 0x04) << (3 + nr));
 715                 w83781d_write_value(data, W83781D_REG_VBAT, reg);
 716         }
 717
 718         /* Restore fan_min */
 719         data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
 720         w83781d_write_value(data, W83781D_REG_FAN_MIN(nr), data->fan_min[nr]);
 721
 722         mutex_unlock(&data->update_lock);
 723         return count;
 724 }
 725
 726 static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
 727                 show_fan_div, store_fan_div, 0);
 728 static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
 729                 show_fan_div, store_fan_div, 1);
 730 static SENSOR_DEVICE_ATTR(fan3_div, S_IRUGO | S_IWUSR,
 731                 show_fan_div, store_fan_div, 2);
 732
 733 static ssize_t
 734 show_pwm(struct device *dev, struct device_attribute *da, char *buf)
 735 {
 736         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 737         struct w83781d_data *data = w83781d_update_device(dev);
 738         return sprintf(buf, "%d\n", (int)data->pwm[attr->index]);
 739 }
 740
 741 static ssize_t
 742 show_pwm2_enable(struct device *dev, struct device_attribute *da, char *buf)
 743 {
 744         struct w83781d_data *data = w83781d_update_device(dev);
 745         return sprintf(buf, "%d\n", (int)data->pwm2_enable);
 746 }
 747
 748 static ssize_t
 749 store_pwm(struct device *dev, struct device_attribute *da, const char *buf,
 750                 size_t count)
 751 {
 752         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 753         struct w83781d_data *data = dev_get_drvdata(dev);
 754         int nr = attr->index;
 755         u32 val;
 756
 757         val = simple_strtoul(buf, NULL, 10);
 758
 759         mutex_lock(&data->update_lock);
 760         data->pwm[nr] = SENSORS_LIMIT(val, 0, 255);
 761         w83781d_write_value(data, W83781D_REG_PWM[nr], data->pwm[nr]);
 762         mutex_unlock(&data->update_lock);
 763         return count;
 764 }
 765
 766 static ssize_t
 767 store_pwm2_enable(struct device *dev, struct device_attribute *da,
 768                 const char *buf, size_t count)
 769 {
 770         struct w83781d_data *data = dev_get_drvdata(dev);
 771         u32 val, reg;
 772
 773         val = simple_strtoul(buf, NULL, 10);
 774
 775         mutex_lock(&data->update_lock);
 776
 777         switch (val) {
 778         case 0:
 779         case 1:
 780                 reg = w83781d_read_value(data, W83781D_REG_PWMCLK12);
 781                 w83781d_write_value(data, W83781D_REG_PWMCLK12,
 782                                     (reg & 0xf7) | (val << 3));
 783
 784                 reg = w83781d_read_value(data, W83781D_REG_BEEP_CONFIG);
 785                 w83781d_write_value(data, W83781D_REG_BEEP_CONFIG,
 786                                     (reg & 0xef) | (!val << 4));
 787
 788                 data->pwm2_enable = val;
 789                 break;
 790
 791         default:
 792                 mutex_unlock(&data->update_lock);
 793                 return -EINVAL;
 794         }
 795
 796         mutex_unlock(&data->update_lock);
 797         return count;
 798 }
 799
 800 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, store_pwm, 0);
 801 static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, show_pwm, store_pwm, 1);
 802 static SENSOR_DEVICE_ATTR(pwm3, S_IRUGO | S_IWUSR, show_pwm, store_pwm, 2);
 803 static SENSOR_DEVICE_ATTR(pwm4, S_IRUGO | S_IWUSR, show_pwm, store_pwm, 3);
 804 /* only PWM2 can be enabled/disabled */
 805 static DEVICE_ATTR(pwm2_enable, S_IRUGO | S_IWUSR,
 806                 show_pwm2_enable, store_pwm2_enable);
 807
 808 static ssize_t
 809 show_sensor(struct device *dev, struct device_attribute *da, char *buf)
 810 {
 811         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 812         struct w83781d_data *data = w83781d_update_device(dev);
 813         return sprintf(buf, "%d\n", (int)data->sens[attr->index]);
 814 }
 815
 816 static ssize_t
 817 store_sensor(struct device *dev, struct device_attribute *da,
 818                 const char *buf, size_t count)
 819 {
 820         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 821         struct w83781d_data *data = dev_get_drvdata(dev);
 822         int nr = attr->index;
 823         u32 val, tmp;
 824
 825         val = simple_strtoul(buf, NULL, 10);
 826
 827         mutex_lock(&data->update_lock);
 828
 829         switch (val) {
 830         case 1:         /* PII/Celeron diode */
 831                 tmp = w83781d_read_value(data, W83781D_REG_SCFG1);
 832                 w83781d_write_value(data, W83781D_REG_SCFG1,
 833                                     tmp | BIT_SCFG1[nr]);
 834                 tmp = w83781d_read_value(data, W83781D_REG_SCFG2);
 835                 w83781d_write_value(data, W83781D_REG_SCFG2,
 836                                     tmp | BIT_SCFG2[nr]);
 837                 data->sens[nr] = val;
 838                 break;
 839         case 2:         /* 3904 */
 840                 tmp = w83781d_read_value(data, W83781D_REG_SCFG1);
 841                 w83781d_write_value(data, W83781D_REG_SCFG1,
 842                                     tmp | BIT_SCFG1[nr]);
 843                 tmp = w83781d_read_value(data, W83781D_REG_SCFG2);
 844                 w83781d_write_value(data, W83781D_REG_SCFG2,
 845                                     tmp & ~BIT_SCFG2[nr]);
 846                 data->sens[nr] = val;
 847                 break;
 848         case W83781D_DEFAULT_BETA:
 849                 dev_warn(dev, "Sensor type %d is deprecated, please use 4 "
 850                          "instead\n", W83781D_DEFAULT_BETA);
 851                 /* fall through */
 852         case 4:         /* thermistor */
 853                 tmp = w83781d_read_value(data, W83781D_REG_SCFG1);
 854                 w83781d_write_value(data, W83781D_REG_SCFG1,
 855                                     tmp & ~BIT_SCFG1[nr]);
 856                 data->sens[nr] = val;
 857                 break;
 858         default:
 859                 dev_err(dev, "Invalid sensor type %ld; must be 1, 2, or 4\n",
 860                        (long) val);
 861                 break;
 862         }
 863
 864         mutex_unlock(&data->update_lock);
 865         return count;
 866 }
 867
 868 static SENSOR_DEVICE_ATTR(temp1_type, S_IRUGO | S_IWUSR,
 869         show_sensor, store_sensor, 0);
 870 static SENSOR_DEVICE_ATTR(temp2_type, S_IRUGO | S_IWUSR,
 871         show_sensor, store_sensor, 1);
 872 static SENSOR_DEVICE_ATTR(temp3_type, S_IRUGO | S_IWUSR,
 873         show_sensor, store_sensor, 2);
 874
 875 /* I2C devices get this name attribute automatically, but for ISA devices
 876    we must create it by ourselves. */
 877 static ssize_t
 878 show_name(struct device *dev, struct device_attribute *devattr, char *buf)
 879 {
 880         struct w83781d_data *data = dev_get_drvdata(dev);
 881         return sprintf(buf, "%s\n", data->client.name);
 882 }
 883 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
 884
 885 /* This function is called when:
 886      * w83781d_driver is inserted (when this module is loaded), for each
 887        available adapter
 888      * when a new adapter is inserted (and w83781d_driver is still present) */
 889 static int
 890 w83781d_attach_adapter(struct i2c_adapter *adapter)
 891 {
 892         if (!(adapter->class & I2C_CLASS_HWMON))
 893                 return 0;
 894         return i2c_probe(adapter, &addr_data, w83781d_detect);
 895 }
 896
 897 /* Assumes that adapter is of I2C, not ISA variety.
 898  * OTHERWISE DON'T CALL THIS
 899  */
 900 static int
 901 w83781d_detect_subclients(struct i2c_adapter *adapter, int address, int kind,
 902                 struct i2c_client *new_client)
 903 {
 904         int i, val1 = 0, id;
 905         int err;
 906         const char *client_name = "";
 907         struct w83781d_data *data = i2c_get_clientdata(new_client);
 908
 909         data->lm75[0] = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
 910         if (!(data->lm75[0])) {
 911                 err = -ENOMEM;
 912                 goto ERROR_SC_0;
 913         }
 914
 915         id = i2c_adapter_id(adapter);
 916
 917         if (force_subclients[0] == id && force_subclients[1] == address) {
 918                 for (i = 2; i <= 3; i++) {
 919                         if (force_subclients[i] < 0x48 ||
 920                             force_subclients[i] > 0x4f) {
 921                                 dev_err(&new_client->dev, "Invalid subclient "
 922                                         "address %d; must be 0x48-0x4f\n",
 923                                         force_subclients[i]);
 924                                 err = -EINVAL;
 925                                 goto ERROR_SC_1;
 926                         }
 927                 }
 928                 w83781d_write_value(data, W83781D_REG_I2C_SUBADDR,
 929                                 (force_subclients[2] & 0x07) |
 930                                 ((force_subclients[3] & 0x07) << 4));
 931                 data->lm75[0]->addr = force_subclients[2];
 932         } else {
 933                 val1 = w83781d_read_value(data, W83781D_REG_I2C_SUBADDR);
 934                 data->lm75[0]->addr = 0x48 + (val1 & 0x07);
 935         }
 936
 937         if (kind != w83783s) {
 938                 data->lm75[1] = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
 939                 if (!(data->lm75[1])) {
 940                         err = -ENOMEM;
 941                         goto ERROR_SC_1;
 942                 }
 943
 944                 if (force_subclients[0] == id &&
 945                     force_subclients[1] == address) {
 946                         data->lm75[1]->addr = force_subclients[3];
 947                 } else {
 948                         data->lm75[1]->addr = 0x48 + ((val1 >> 4) & 0x07);
 949                 }
 950                 if (data->lm75[0]->addr == data->lm75[1]->addr) {
 951                         dev_err(&new_client->dev,
 952                                "Duplicate addresses 0x%x for subclients.\n",
 953                                data->lm75[0]->addr);
 954                         err = -EBUSY;
 955                         goto ERROR_SC_2;
 956                 }
 957         }
 958
 959         if (kind == w83781d)
 960                 client_name = "w83781d subclient";
 961         else if (kind == w83782d)
 962                 client_name = "w83782d subclient";
 963         else if (kind == w83783s)
 964                 client_name = "w83783s subclient";
 965         else if (kind == w83627hf)
 966                 client_name = "w83627hf subclient";
 967         else if (kind == as99127f)
 968                 client_name = "as99127f subclient";
 969
 970         for (i = 0; i <= 1; i++) {
 971                 /* store all data in w83781d */
 972                 i2c_set_clientdata(data->lm75[i], NULL);
 973                 data->lm75[i]->adapter = adapter;
 974                 data->lm75[i]->driver = &w83781d_driver;
 975                 data->lm75[i]->flags = 0;
 976                 strlcpy(data->lm75[i]->name, client_name,
 977                         I2C_NAME_SIZE);
 978                 if ((err = i2c_attach_client(data->lm75[i]))) {
 979                         dev_err(&new_client->dev, "Subclient %d "
 980                                 "registration at address 0x%x "
 981                                 "failed.\n", i, data->lm75[i]->addr);
 982                         if (i == 1)
 983                                 goto ERROR_SC_3;
 984                         goto ERROR_SC_2;
 985                 }
 986                 if (kind == w83783s)
 987                         break;
 988         }
 989
 990         return 0;
 991
 992 /* Undo inits in case of errors */
 993 ERROR_SC_3:
 994         i2c_detach_client(data->lm75[0]);
 995 ERROR_SC_2:
 996         kfree(data->lm75[1]);
 997 ERROR_SC_1:
 998         kfree(data->lm75[0]);
 999 ERROR_SC_0:
1000         return err;
1001 }
1002
1003 #define IN_UNIT_ATTRS(X)                                        \
1004         &sensor_dev_attr_in##X##_input.dev_attr.attr,           \
1005         &sensor_dev_attr_in##X##_min.dev_attr.attr,             \
1006         &sensor_dev_attr_in##X##_max.dev_attr.attr,             \
1007         &sensor_dev_attr_in##X##_alarm.dev_attr.attr,           \
1008         &sensor_dev_attr_in##X##_beep.dev_attr.attr
1009
1010 #define FAN_UNIT_ATTRS(X)                                       \
1011         &sensor_dev_attr_fan##X##_input.dev_attr.attr,          \
1012         &sensor_dev_attr_fan##X##_min.dev_attr.attr,            \
1013         &sensor_dev_attr_fan##X##_div.dev_attr.attr,            \
1014         &sensor_dev_attr_fan##X##_alarm.dev_attr.attr,          \
1015         &sensor_dev_attr_fan##X##_beep.dev_attr.attr
1016
1017 #define TEMP_UNIT_ATTRS(X)                                      \
1018         &sensor_dev_attr_temp##X##_input.dev_attr.attr,         \
1019         &sensor_dev_attr_temp##X##_max.dev_attr.attr,           \
1020         &sensor_dev_attr_temp##X##_max_hyst.dev_attr.attr,      \
1021         &sensor_dev_attr_temp##X##_alarm.dev_attr.attr,         \
1022         &sensor_dev_attr_temp##X##_beep.dev_attr.attr
1023
1024 static struct attribute* w83781d_attributes[] = {
1025         IN_UNIT_ATTRS(0),
1026         IN_UNIT_ATTRS(2),
1027         IN_UNIT_ATTRS(3),
1028         IN_UNIT_ATTRS(4),
1029         IN_UNIT_ATTRS(5),
1030         IN_UNIT_ATTRS(6),
1031         FAN_UNIT_ATTRS(1),
1032         FAN_UNIT_ATTRS(2),
1033         FAN_UNIT_ATTRS(3),
1034         TEMP_UNIT_ATTRS(1),
1035         TEMP_UNIT_ATTRS(2),
1036         &dev_attr_cpu0_vid.attr,
1037         &dev_attr_vrm.attr,
1038         &dev_attr_alarms.attr,
1039         &dev_attr_beep_mask.attr,
1040         &dev_attr_beep_enable.attr,
1041         NULL
1042 };
1043 static const struct attribute_group w83781d_group = {
1044         .attrs = w83781d_attributes,
1045 };
1046
1047 static struct attribute *w83781d_attributes_opt[] = {
1048         IN_UNIT_ATTRS(1),
1049         IN_UNIT_ATTRS(7),
1050         IN_UNIT_ATTRS(8),
1051         TEMP_UNIT_ATTRS(3),
1052         &sensor_dev_attr_pwm1.dev_attr.attr,
1053         &sensor_dev_attr_pwm2.dev_attr.attr,
1054         &sensor_dev_attr_pwm3.dev_attr.attr,
1055         &sensor_dev_attr_pwm4.dev_attr.attr,
1056         &dev_attr_pwm2_enable.attr,
1057         &sensor_dev_attr_temp1_type.dev_attr.attr,
1058         &sensor_dev_attr_temp2_type.dev_attr.attr,
1059         &sensor_dev_attr_temp3_type.dev_attr.attr,
1060         NULL
1061 };
1062 static const struct attribute_group w83781d_group_opt = {
1063         .attrs = w83781d_attributes_opt,
1064 };
1065
1066 /* No clean up is done on error, it's up to the caller */
1067 static int
1068 w83781d_create_files(struct device *dev, int kind, int is_isa)
1069 {
1070         int err;
1071
1072         if ((err = sysfs_create_group(&dev->kobj, &w83781d_group)))
1073                 return err;
1074
1075         if (kind != w83783s) {
1076                 if ((err = device_create_file(dev,
1077                                 &sensor_dev_attr_in1_input.dev_attr))
1078                     || (err = device_create_file(dev,
1079                                 &sensor_dev_attr_in1_min.dev_attr))
1080                     || (err = device_create_file(dev,
1081                                 &sensor_dev_attr_in1_max.dev_attr))
1082                     || (err = device_create_file(dev,
1083                                 &sensor_dev_attr_in1_alarm.dev_attr))
1084                     || (err = device_create_file(dev,
1085                                 &sensor_dev_attr_in1_beep.dev_attr)))
1086                         return err;
1087         }
1088         if (kind != as99127f && kind != w83781d && kind != w83783s) {
1089                 if ((err = device_create_file(dev,
1090                                 &sensor_dev_attr_in7_input.dev_attr))
1091                     || (err = device_create_file(dev,
1092                                 &sensor_dev_attr_in7_min.dev_attr))
1093                     || (err = device_create_file(dev,
1094                                 &sensor_dev_attr_in7_max.dev_attr))
1095                     || (err = device_create_file(dev,
1096                                 &sensor_dev_attr_in7_alarm.dev_attr))
1097                     || (err = device_create_file(dev,
1098                                 &sensor_dev_attr_in7_beep.dev_attr))
1099                     || (err = device_create_file(dev,
1100                                 &sensor_dev_attr_in8_input.dev_attr))
1101                     || (err = device_create_file(dev,
1102                                 &sensor_dev_attr_in8_min.dev_attr))
1103                     || (err = device_create_file(dev,
1104                                 &sensor_dev_attr_in8_max.dev_attr))
1105                     || (err = device_create_file(dev,
1106                                 &sensor_dev_attr_in8_alarm.dev_attr))
1107                     || (err = device_create_file(dev,
1108                                 &sensor_dev_attr_in8_beep.dev_attr)))
1109                         return err;
1110         }
1111         if (kind != w83783s) {
1112                 if ((err = device_create_file(dev,
1113                                 &sensor_dev_attr_temp3_input.dev_attr))
1114                     || (err = device_create_file(dev,
1115                                 &sensor_dev_attr_temp3_max.dev_attr))
1116                     || (err = device_create_file(dev,
1117                                 &sensor_dev_attr_temp3_max_hyst.dev_attr))
1118                     || (err = device_create_file(dev,
1119                                 &sensor_dev_attr_temp3_alarm.dev_attr))
1120                     || (err = device_create_file(dev,
1121                                 &sensor_dev_attr_temp3_beep.dev_attr)))
1122                         return err;
1123
1124                 if (kind != w83781d) {
1125                         err = sysfs_chmod_file(&dev->kobj,
1126                                 &sensor_dev_attr_temp3_alarm.dev_attr.attr,
1127                                 S_IRUGO | S_IWUSR);
1128                         if (err)
1129                                 return err;
1130                 }
1131         }
1132
1133         if (kind != w83781d && kind != as99127f) {
1134                 if ((err = device_create_file(dev,
1135                                 &sensor_dev_attr_pwm1.dev_attr))
1136                     || (err = device_create_file(dev,
1137                                 &sensor_dev_attr_pwm2.dev_attr))
1138                     || (err = device_create_file(dev, &dev_attr_pwm2_enable)))
1139                         return err;
1140         }
1141         if (kind == w83782d && !is_isa) {
1142                 if ((err = device_create_file(dev,
1143                                 &sensor_dev_attr_pwm3.dev_attr))
1144                     || (err = device_create_file(dev,
1145                                 &sensor_dev_attr_pwm4.dev_attr)))
1146                         return err;
1147         }
1148
1149         if (kind != as99127f && kind != w83781d) {
1150                 if ((err = device_create_file(dev,
1151                                 &sensor_dev_attr_temp1_type.dev_attr))
1152                     || (err = device_create_file(dev,
1153                                 &sensor_dev_attr_temp2_type.dev_attr)))
1154                         return err;
1155                 if (kind != w83783s) {
1156                         if ((err = device_create_file(dev,
1157                                         &sensor_dev_attr_temp3_type.dev_attr)))
1158                                 return err;
1159                 }
1160         }
1161
1162         if (is_isa) {
1163                 err = device_create_file(&pdev->dev, &dev_attr_name);
1164                 if (err)
1165                         return err;
1166         }
1167
1168         return 0;
1169 }
1170
1171 static int
1172 w83781d_detect(struct i2c_adapter *adapter, int address, int kind)
1173 {
1174         int val1 = 0, val2;
1175         struct i2c_client *client;
1176         struct device *dev;
1177         struct w83781d_data *data;
1178         int err;
1179         const char *client_name = "";
1180         enum vendor { winbond, asus } vendid;
1181
1182         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1183                 err = -EINVAL;
1184                 goto ERROR1;
1185         }
1186
1187         /* OK. For now, we presume we have a valid client. We now create the
1188            client structure, even though we cannot fill it completely yet.
1189            But it allows us to access w83781d_{read,write}_value. */
1190
1191         if (!(data = kzalloc(sizeof(struct w83781d_data), GFP_KERNEL))) {
1192                 err = -ENOMEM;
1193                 goto ERROR1;
1194         }
1195
1196         client = &data->client;
1197         i2c_set_clientdata(client, data);
1198         client->addr = address;
1199         mutex_init(&data->lock);
1200         client->adapter = adapter;
1201         client->driver = &w83781d_driver;
1202         dev = &client->dev;
1203
1204         /* Now, we do the remaining detection. */
1205
1206         /* The w8378?d may be stuck in some other bank than bank 0. This may
1207            make reading other information impossible. Specify a force=... or
1208            force_*=... parameter, and the Winbond will be reset to the right
1209            bank. */
1210         if (kind < 0) {
1211                 if (w83781d_read_value(data, W83781D_REG_CONFIG) & 0x80) {
1212                         dev_dbg(&adapter->dev, "Detection of w83781d chip "
1213                                 "failed at step 3\n");
1214                         err = -ENODEV;
1215                         goto ERROR2;
1216                 }
1217                 val1 = w83781d_read_value(data, W83781D_REG_BANK);
1218                 val2 = w83781d_read_value(data, W83781D_REG_CHIPMAN);
1219                 /* Check for Winbond or Asus ID if in bank 0 */
1220                 if ((!(val1 & 0x07)) &&
1221                     (((!(val1 & 0x80)) && (val2 != 0xa3) && (val2 != 0xc3))
1222                      || ((val1 & 0x80) && (val2 != 0x5c) && (val2 != 0x12)))) {
1223                         dev_dbg(&adapter->dev, "Detection of w83781d chip "
1224                                 "failed at step 4\n");
1225                         err = -ENODEV;
1226                         goto ERROR2;
1227                 }
1228                 /* If Winbond SMBus, check address at 0x48.
1229                    Asus doesn't support, except for as99127f rev.2 */
1230                 if ((!(val1 & 0x80) && (val2 == 0xa3)) ||
1231                     ((val1 & 0x80) && (val2 == 0x5c))) {
1232                         if (w83781d_read_value
1233                             (data, W83781D_REG_I2C_ADDR) != address) {
1234                                 dev_dbg(&adapter->dev, "Detection of w83781d "
1235                                         "chip failed at step 5\n");
1236                                 err = -ENODEV;
1237                                 goto ERROR2;
1238                         }
1239                 }
1240         }
1241
1242         /* We have either had a force parameter, or we have already detected the
1243            Winbond. Put it now into bank 0 and Vendor ID High Byte */
1244         w83781d_write_value(data, W83781D_REG_BANK,
1245                             (w83781d_read_value(data, W83781D_REG_BANK)
1246                              & 0x78) | 0x80);
1247
1248         /* Determine the chip type. */
1249         if (kind <= 0) {
1250                 /* get vendor ID */
1251                 val2 = w83781d_read_value(data, W83781D_REG_CHIPMAN);
1252                 if (val2 == 0x5c)
1253                         vendid = winbond;
1254                 else if (val2 == 0x12)
1255                         vendid = asus;
1256                 else {
1257                         dev_dbg(&adapter->dev, "w83781d chip vendor is "
1258                                 "neither Winbond nor Asus\n");
1259                         err = -ENODEV;
1260                         goto ERROR2;
1261                 }
1262
1263                 val1 = w83781d_read_value(data, W83781D_REG_WCHIPID);
1264                 if ((val1 == 0x10 || val1 == 0x11) && vendid == winbond)
1265                         kind = w83781d;
1266                 else if (val1 == 0x30 && vendid == winbond)
1267                         kind = w83782d;
1268                 else if (val1 == 0x40 && vendid == winbond && address == 0x2d)
1269                         kind = w83783s;
1270                 else if (val1 == 0x21 && vendid == winbond)
1271                         kind = w83627hf;
1272                 else if (val1 == 0x31)
1273                         kind = as99127f;
1274                 else {
1275                         if (kind == 0)
1276                                 dev_warn(&adapter->dev, "Ignoring 'force' "
1277                                          "parameter for unknown chip at "
1278                                          "address 0x%02x\n", address);
1279                         err = -EINVAL;
1280                         goto ERROR2;
1281                 }
1282         }
1283
1284         if (kind == w83781d) {
1285                 client_name = "w83781d";
1286         } else if (kind == w83782d) {
1287                 client_name = "w83782d";
1288         } else if (kind == w83783s) {
1289                 client_name = "w83783s";
1290         } else if (kind == w83627hf) {
1291                 client_name = "w83627hf";
1292         } else if (kind == as99127f) {
1293                 client_name = "as99127f";
1294         }
1295
1296         /* Fill in the remaining client fields and put into the global list */
1297         strlcpy(client->name, client_name, I2C_NAME_SIZE);
1298         data->type = kind;
1299
1300         /* Tell the I2C layer a new client has arrived */
1301         if ((err = i2c_attach_client(client)))
1302                 goto ERROR2;
1303
1304         /* attach secondary i2c lm75-like clients */
1305         if ((err = w83781d_detect_subclients(adapter, address,
1306                         kind, client)))
1307                 goto ERROR3;
1308
1309         /* Initialize the chip */
1310         w83781d_init_device(dev);
1311
1312         /* Register sysfs hooks */
1313         err = w83781d_create_files(dev, kind, 0);
1314         if (err)
1315                 goto ERROR4;
1316
1317         data->hwmon_dev = hwmon_device_register(dev);
1318         if (IS_ERR(data->hwmon_dev)) {
1319                 err = PTR_ERR(data->hwmon_dev);
1320                 goto ERROR4;
1321         }
1322
1323         return 0;
1324
1325 ERROR4:
1326         sysfs_remove_group(&dev->kobj, &w83781d_group);
1327         sysfs_remove_group(&dev->kobj, &w83781d_group_opt);
1328
1329         if (data->lm75[1]) {
1330                 i2c_detach_client(data->lm75[1]);
1331                 kfree(data->lm75[1]);
1332         }
1333         if (data->lm75[0]) {
1334                 i2c_detach_client(data->lm75[0]);
1335                 kfree(data->lm75[0]);
1336         }
1337 ERROR3:
1338         i2c_detach_client(client);
1339 ERROR2:
1340         kfree(data);
1341 ERROR1:
1342         return err;
1343 }
1344
1345 static int
1346 w83781d_detach_client(struct i2c_client *client)
1347 {
1348         struct w83781d_data *data = i2c_get_clientdata(client);
1349         int err;
1350
1351         /* main client */
1352         if (data) {
1353                 hwmon_device_unregister(data->hwmon_dev);
1354                 sysfs_remove_group(&client->dev.kobj, &w83781d_group);
1355                 sysfs_remove_group(&client->dev.kobj, &w83781d_group_opt);
1356         }
1357
1358         if ((err = i2c_detach_client(client)))
1359                 return err;
1360
1361         /* main client */
1362         if (data)
1363                 kfree(data);
1364
1365         /* subclient */
1366         else
1367                 kfree(client);
1368
1369         return 0;
1370 }
1371
1372 static int __devinit
1373 w83781d_isa_probe(struct platform_device *pdev)
1374 {
1375         int err, reg;
1376         struct w83781d_data *data;
1377         struct resource *res;
1378         const char *name;
1379
1380         /* Reserve the ISA region */
1381         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1382         if (!request_region(res->start, W83781D_EXTENT, "w83781d")) {
1383                 err = -EBUSY;
1384                 goto exit;
1385         }
1386
1387         if (!(data = kzalloc(sizeof(struct w83781d_data), GFP_KERNEL))) {
1388                 err = -ENOMEM;
1389                 goto exit_release_region;
1390         }
1391         mutex_init(&data->lock);
1392         data->client.addr = res->start;
1393         i2c_set_clientdata(&data->client, data);
1394         platform_set_drvdata(pdev, data);
1395
1396         reg = w83781d_read_value(data, W83781D_REG_WCHIPID);
1397         switch (reg) {
1398         case 0x21:
1399                 data->type = w83627hf;
1400                 name = "w83627hf";
1401                 break;
1402         case 0x30:
1403                 data->type = w83782d;
1404                 name = "w83782d";
1405                 break;
1406         default:
1407                 data->type = w83781d;
1408                 name = "w83781d";
1409         }
1410         strlcpy(data->client.name, name, I2C_NAME_SIZE);
1411
1412         /* Initialize the W83781D chip */
1413         w83781d_init_device(&pdev->dev);
1414
1415         /* Register sysfs hooks */
1416         err = w83781d_create_files(&pdev->dev, data->type, 1);
1417         if (err)
1418                 goto exit_remove_files;
1419
1420         data->hwmon_dev = hwmon_device_register(&pdev->dev);
1421         if (IS_ERR(data->hwmon_dev)) {
1422                 err = PTR_ERR(data->hwmon_dev);
1423                 goto exit_remove_files;
1424         }
1425
1426         return 0;
1427
1428  exit_remove_files:
1429         sysfs_remove_group(&pdev->dev.kobj, &w83781d_group);
1430         sysfs_remove_group(&pdev->dev.kobj, &w83781d_group_opt);
1431         device_remove_file(&pdev->dev, &dev_attr_name);
1432         kfree(data);
1433  exit_release_region:
1434         release_region(res->start, W83781D_EXTENT);
1435  exit:
1436         return err;
1437 }
1438
1439 static int __devexit
1440 w83781d_isa_remove(struct platform_device *pdev)
1441 {
1442         struct w83781d_data *data = platform_get_drvdata(pdev);
1443
1444         hwmon_device_unregister(data->hwmon_dev);
1445         sysfs_remove_group(&pdev->dev.kobj, &w83781d_group);
1446         sysfs_remove_group(&pdev->dev.kobj, &w83781d_group_opt);
1447         device_remove_file(&pdev->dev, &dev_attr_name);
1448         release_region(data->client.addr, W83781D_EXTENT);
1449         kfree(data);
1450
1451         return 0;
1452 }
1453
1454 /* The SMBus locks itself, usually, but nothing may access the Winbond between
1455    bank switches. ISA access must always be locked explicitly!
1456    We ignore the W83781D BUSY flag at this moment - it could lead to deadlocks,
1457    would slow down the W83781D access and should not be necessary.
1458    There are some ugly typecasts here, but the good news is - they should
1459    nowhere else be necessary! */
1460 static int
1461 w83781d_read_value(struct w83781d_data *data, u16 reg)
1462 {
1463         struct i2c_client *client = &data->client;
1464         int res, word_sized, bank;
1465         struct i2c_client *cl;
1466
1467         mutex_lock(&data->lock);
1468         if (!client->driver) { /* ISA device */
1469                 word_sized = (((reg & 0xff00) == 0x100)
1470                               || ((reg & 0xff00) == 0x200))
1471                     && (((reg & 0x00ff) == 0x50)
1472                         || ((reg & 0x00ff) == 0x53)
1473                         || ((reg & 0x00ff) == 0x55));
1474                 if (reg & 0xff00) {
1475                         outb_p(W83781D_REG_BANK,
1476                                client->addr + W83781D_ADDR_REG_OFFSET);
1477                         outb_p(reg >> 8,
1478                                client->addr + W83781D_DATA_REG_OFFSET);
1479                 }
1480                 outb_p(reg & 0xff, client->addr + W83781D_ADDR_REG_OFFSET);
1481                 res = inb_p(client->addr + W83781D_DATA_REG_OFFSET);
1482                 if (word_sized) {
1483                         outb_p((reg & 0xff) + 1,
1484                                client->addr + W83781D_ADDR_REG_OFFSET);
1485                         res =
1486                             (res << 8) + inb_p(client->addr +
1487                                                W83781D_DATA_REG_OFFSET);
1488                 }
1489                 if (reg & 0xff00) {
1490                         outb_p(W83781D_REG_BANK,
1491                                client->addr + W83781D_ADDR_REG_OFFSET);
1492                         outb_p(0, client->addr + W83781D_DATA_REG_OFFSET);
1493                 }
1494         } else {
1495                 bank = (reg >> 8) & 0x0f;
1496                 if (bank > 2)
1497                         /* switch banks */
1498                         i2c_smbus_write_byte_data(client, W83781D_REG_BANK,
1499                                                   bank);
1500                 if (bank == 0 || bank > 2) {
1501                         res = i2c_smbus_read_byte_data(client, reg & 0xff);
1502                 } else {
1503                         /* switch to subclient */
1504                         cl = data->lm75[bank - 1];
1505                         /* convert from ISA to LM75 I2C addresses */
1506                         switch (reg & 0xff) {
1507                         case 0x50:      /* TEMP */
1508                                 res = swab16(i2c_smbus_read_word_data(cl, 0));
1509                                 break;
1510                         case 0x52:      /* CONFIG */
1511                                 res = i2c_smbus_read_byte_data(cl, 1);
1512                                 break;
1513                         case 0x53:      /* HYST */
1514                                 res = swab16(i2c_smbus_read_word_data(cl, 2));
1515                                 break;
1516                         case 0x55:      /* OVER */
1517                         default:
1518                                 res = swab16(i2c_smbus_read_word_data(cl, 3));
1519                                 break;
1520                         }
1521                 }
1522                 if (bank > 2)
1523                         i2c_smbus_write_byte_data(client, W83781D_REG_BANK, 0);
1524         }
1525         mutex_unlock(&data->lock);
1526         return res;
1527 }
1528
1529 static int
1530 w83781d_write_value(struct w83781d_data *data, u16 reg, u16 value)
1531 {
1532         struct i2c_client *client = &data->client;
1533         int word_sized, bank;
1534         struct i2c_client *cl;
1535
1536         mutex_lock(&data->lock);
1537         if (!client->driver) { /* ISA device */
1538                 word_sized = (((reg & 0xff00) == 0x100)
1539                               || ((reg & 0xff00) == 0x200))
1540                     && (((reg & 0x00ff) == 0x53)
1541                         || ((reg & 0x00ff) == 0x55));
1542                 if (reg & 0xff00) {
1543                         outb_p(W83781D_REG_BANK,
1544                                client->addr + W83781D_ADDR_REG_OFFSET);
1545                         outb_p(reg >> 8,
1546                                client->addr + W83781D_DATA_REG_OFFSET);
1547                 }
1548                 outb_p(reg & 0xff, client->addr + W83781D_ADDR_REG_OFFSET);
1549                 if (word_sized) {
1550                         outb_p(value >> 8,
1551                                client->addr + W83781D_DATA_REG_OFFSET);
1552                         outb_p((reg & 0xff) + 1,
1553                                client->addr + W83781D_ADDR_REG_OFFSET);
1554                 }
1555                 outb_p(value & 0xff, client->addr + W83781D_DATA_REG_OFFSET);
1556                 if (reg & 0xff00) {
1557                         outb_p(W83781D_REG_BANK,
1558                                client->addr + W83781D_ADDR_REG_OFFSET);
1559                         outb_p(0, client->addr + W83781D_DATA_REG_OFFSET);
1560                 }
1561         } else {
1562                 bank = (reg >> 8) & 0x0f;
1563                 if (bank > 2)
1564                         /* switch banks */
1565                         i2c_smbus_write_byte_data(client, W83781D_REG_BANK,
1566                                                   bank);
1567                 if (bank == 0 || bank > 2) {
1568                         i2c_smbus_write_byte_data(client, reg & 0xff,
1569                                                   value & 0xff);
1570                 } else {
1571                         /* switch to subclient */
1572                         cl = data->lm75[bank - 1];
1573                         /* convert from ISA to LM75 I2C addresses */
1574                         switch (reg & 0xff) {
1575                         case 0x52:      /* CONFIG */
1576                                 i2c_smbus_write_byte_data(cl, 1, value & 0xff);
1577                                 break;
1578                         case 0x53:      /* HYST */
1579                                 i2c_smbus_write_word_data(cl, 2, swab16(value));
1580                                 break;
1581                         case 0x55:      /* OVER */
1582                                 i2c_smbus_write_word_data(cl, 3, swab16(value));
1583                                 break;
1584                         }
1585                 }
1586                 if (bank > 2)
1587                         i2c_smbus_write_byte_data(client, W83781D_REG_BANK, 0);
1588         }
1589         mutex_unlock(&data->lock);
1590         return 0;
1591 }
1592
1593 static void
1594 w83781d_init_device(struct device *dev)
1595 {
1596         struct w83781d_data *data = dev_get_drvdata(dev);
1597         int i, p;
1598         int type = data->type;
1599         u8 tmp;
1600
1601         if (type == w83627hf)
1602                 dev_info(dev, "The W83627HF chip is better supported by the "
1603                          "w83627hf driver, support will be dropped from the "
1604                          "w83781d driver soon\n");
1605
1606         if (reset && type != as99127f) { /* this resets registers we don't have
1607                                            documentation for on the as99127f */
1608                 /* Resetting the chip has been the default for a long time,
1609                    but it causes the BIOS initializations (fan clock dividers,
1610                    thermal sensor types...) to be lost, so it is now optional.
1611                    It might even go away if nobody reports it as being useful,
1612                    as I see very little reason why this would be needed at
1613                    all. */
1614                 dev_info(dev, "If reset=1 solved a problem you were "
1615                          "having, please report!\n");
1616
1617                 /* save these registers */
1618                 i = w83781d_read_value(data, W83781D_REG_BEEP_CONFIG);
1619                 p = w83781d_read_value(data, W83781D_REG_PWMCLK12);
1620                 /* Reset all except Watchdog values and last conversion values
1621                    This sets fan-divs to 2, among others */
1622                 w83781d_write_value(data, W83781D_REG_CONFIG, 0x80);
1623                 /* Restore the registers and disable power-on abnormal beep.
1624                    This saves FAN 1/2/3 input/output values set by BIOS. */
1625                 w83781d_write_value(data, W83781D_REG_BEEP_CONFIG, i | 0x80);
1626                 w83781d_write_value(data, W83781D_REG_PWMCLK12, p);
1627                 /* Disable master beep-enable (reset turns it on).
1628                    Individual beep_mask should be reset to off but for some reason
1629                    disabling this bit helps some people not get beeped */
1630                 w83781d_write_value(data, W83781D_REG_BEEP_INTS2, 0);
1631         }
1632
1633         /* Disable power-on abnormal beep, as advised by the datasheet.
1634            Already done if reset=1. */
1635         if (init && !reset && type != as99127f) {
1636                 i = w83781d_read_value(data, W83781D_REG_BEEP_CONFIG);
1637                 w83781d_write_value(data, W83781D_REG_BEEP_CONFIG, i | 0x80);
1638         }
1639
1640         data->vrm = vid_which_vrm();
1641
1642         if ((type != w83781d) && (type != as99127f)) {
1643                 tmp = w83781d_read_value(data, W83781D_REG_SCFG1);
1644                 for (i = 1; i <= 3; i++) {
1645                         if (!(tmp & BIT_SCFG1[i - 1])) {
1646                                 data->sens[i - 1] = 4;
1647                         } else {
1648                                 if (w83781d_read_value
1649                                     (data,
1650                                      W83781D_REG_SCFG2) & BIT_SCFG2[i - 1])
1651                                         data->sens[i - 1] = 1;
1652                                 else
1653                                         data->sens[i - 1] = 2;
1654                         }
1655                         if (type == w83783s && i == 2)
1656                                 break;
1657                 }
1658         }
1659
1660         if (init && type != as99127f) {
1661                 /* Enable temp2 */
1662                 tmp = w83781d_read_value(data, W83781D_REG_TEMP2_CONFIG);
1663                 if (tmp & 0x01) {
1664                         dev_warn(dev, "Enabling temp2, readings "
1665                                  "might not make sense\n");
1666                         w83781d_write_value(data, W83781D_REG_TEMP2_CONFIG,
1667                                 tmp & 0xfe);
1668                 }
1669
1670                 /* Enable temp3 */
1671                 if (type != w83783s) {
1672                         tmp = w83781d_read_value(data,
1673                                 W83781D_REG_TEMP3_CONFIG);
1674                         if (tmp & 0x01) {
1675                                 dev_warn(dev, "Enabling temp3, "
1676                                          "readings might not make sense\n");
1677                                 w83781d_write_value(data,
1678                                         W83781D_REG_TEMP3_CONFIG, tmp & 0xfe);
1679                         }
1680                 }
1681         }
1682
1683         /* Start monitoring */
1684         w83781d_write_value(data, W83781D_REG_CONFIG,
1685                             (w83781d_read_value(data,
1686                                                 W83781D_REG_CONFIG) & 0xf7)
1687                             | 0x01);
1688
1689         /* A few vars need to be filled upon startup */
1690         for (i = 0; i < 3; i++) {
1691                 data->fan_min[i] = w83781d_read_value(data,
1692                                         W83781D_REG_FAN_MIN(i));
1693         }
1694
1695         mutex_init(&data->update_lock);
1696 }
1697
1698 static struct w83781d_data *w83781d_update_device(struct device *dev)
1699 {
1700         struct w83781d_data *data = dev_get_drvdata(dev);
1701         struct i2c_client *client = &data->client;
1702         int i;
1703
1704         mutex_lock(&data->update_lock);
1705
1706         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1707             || !data->valid) {
1708                 dev_dbg(dev, "Starting device update\n");
1709
1710                 for (i = 0; i <= 8; i++) {
1711                         if (data->type == w83783s && i == 1)
1712                                 continue;       /* 783S has no in1 */
1713                         data->in[i] =
1714                             w83781d_read_value(data, W83781D_REG_IN(i));
1715                         data->in_min[i] =
1716                             w83781d_read_value(data, W83781D_REG_IN_MIN(i));
1717                         data->in_max[i] =
1718                             w83781d_read_value(data, W83781D_REG_IN_MAX(i));
1719                         if ((data->type != w83782d)
1720                             && (data->type != w83627hf) && (i == 6))
1721                                 break;
1722                 }
1723                 for (i = 0; i < 3; i++) {
1724                         data->fan[i] =
1725                             w83781d_read_value(data, W83781D_REG_FAN(i));
1726                         data->fan_min[i] =
1727                             w83781d_read_value(data, W83781D_REG_FAN_MIN(i));
1728                 }
1729                 if (data->type != w83781d && data->type != as99127f) {
1730                         for (i = 0; i < 4; i++) {
1731                                 data->pwm[i] =
1732                                     w83781d_read_value(data,
1733                                                        W83781D_REG_PWM[i]);
1734                                 if ((data->type != w83782d || !client->driver)
1735                                     && i == 1)
1736                                         break;
1737                         }
1738                         /* Only PWM2 can be disabled */
1739                         data->pwm2_enable = (w83781d_read_value(data,
1740                                               W83781D_REG_PWMCLK12) & 0x08) >> 3;
1741                 }
1742
1743                 data->temp = w83781d_read_value(data, W83781D_REG_TEMP(1));
1744                 data->temp_max =
1745                     w83781d_read_value(data, W83781D_REG_TEMP_OVER(1));
1746                 data->temp_max_hyst =
1747                     w83781d_read_value(data, W83781D_REG_TEMP_HYST(1));
1748                 data->temp_add[0] =
1749                     w83781d_read_value(data, W83781D_REG_TEMP(2));
1750                 data->temp_max_add[0] =
1751                     w83781d_read_value(data, W83781D_REG_TEMP_OVER(2));
1752                 data->temp_max_hyst_add[0] =
1753                     w83781d_read_value(data, W83781D_REG_TEMP_HYST(2));
1754                 if (data->type != w83783s) {
1755                         data->temp_add[1] =
1756                             w83781d_read_value(data, W83781D_REG_TEMP(3));
1757                         data->temp_max_add[1] =
1758                             w83781d_read_value(data,
1759                                                W83781D_REG_TEMP_OVER(3));
1760                         data->temp_max_hyst_add[1] =
1761                             w83781d_read_value(data,
1762                                                W83781D_REG_TEMP_HYST(3));
1763                 }
1764                 i = w83781d_read_value(data, W83781D_REG_VID_FANDIV);
1765                 data->vid = i & 0x0f;
1766                 data->vid |= (w83781d_read_value(data,
1767                                         W83781D_REG_CHIPID) & 0x01) << 4;
1768                 data->fan_div[0] = (i >> 4) & 0x03;
1769                 data->fan_div[1] = (i >> 6) & 0x03;
1770                 data->fan_div[2] = (w83781d_read_value(data,
1771                                         W83781D_REG_PIN) >> 6) & 0x03;
1772                 if ((data->type != w83781d) && (data->type != as99127f)) {
1773                         i = w83781d_read_value(data, W83781D_REG_VBAT);
1774                         data->fan_div[0] |= (i >> 3) & 0x04;
1775                         data->fan_div[1] |= (i >> 4) & 0x04;
1776                         data->fan_div[2] |= (i >> 5) & 0x04;
1777                 }
1778                 if ((data->type == w83782d) || (data->type == w83627hf)) {
1779                         data->alarms = w83781d_read_value(data,
1780                                                 W83782D_REG_ALARM1)
1781                                      | (w83781d_read_value(data,
1782                                                 W83782D_REG_ALARM2) << 8)
1783                                      | (w83781d_read_value(data,
1784                                                 W83782D_REG_ALARM3) << 16);
1785                 } else if (data->type == w83783s) {
1786                         data->alarms = w83781d_read_value(data,
1787                                                 W83782D_REG_ALARM1)
1788                                      | (w83781d_read_value(data,
1789                                                 W83782D_REG_ALARM2) << 8);
1790                 } else {
1791                         /* No real-time status registers, fall back to
1792                            interrupt status registers */
1793                         data->alarms = w83781d_read_value(data,
1794                                                 W83781D_REG_ALARM1)
1795                                      | (w83781d_read_value(data,
1796                                                 W83781D_REG_ALARM2) << 8);
1797                 }
1798                 i = w83781d_read_value(data, W83781D_REG_BEEP_INTS2);
1799                 data->beep_enable = i >> 7;
1800                 data->beep_mask = ((i & 0x7f) << 8) +
1801                     w83781d_read_value(data, W83781D_REG_BEEP_INTS1);
1802                 if ((data->type != w83781d) && (data->type != as99127f)) {
1803                         data->beep_mask |=
1804                             w83781d_read_value(data,
1805                                                W83781D_REG_BEEP_INTS3) << 16;
1806                 }
1807                 data->last_updated = jiffies;
1808                 data->valid = 1;
1809         }
1810
1811         mutex_unlock(&data->update_lock);
1812
1813         return data;
1814 }
1815
1816 /* return 1 if a supported chip is found, 0 otherwise */
1817 static int __init
1818 w83781d_isa_found(unsigned short address)
1819 {
1820         int val, save, found = 0;
1821
1822         if (!request_region(address, W83781D_EXTENT, "w83781d"))
1823                 return 0;
1824
1825 #define REALLY_SLOW_IO
1826         /* We need the timeouts for at least some W83781D-like
1827            chips. But only if we read 'undefined' registers. */
1828         val = inb_p(address + 1);
1829         if (inb_p(address + 2) != val
1830          || inb_p(address + 3) != val
1831          || inb_p(address + 7) != val) {
1832                 pr_debug("w83781d: Detection failed at step 1\n");
1833                 goto release;
1834         }
1835 #undef REALLY_SLOW_IO
1836
1837         /* We should be able to change the 7 LSB of the address port. The
1838            MSB (busy flag) should be clear initially, set after the write. */
1839         save = inb_p(address + W83781D_ADDR_REG_OFFSET);
1840         if (save & 0x80) {
1841                 pr_debug("w83781d: Detection failed at step 2\n");
1842                 goto release;
1843         }
1844         val = ~save & 0x7f;
1845         outb_p(val, address + W83781D_ADDR_REG_OFFSET);
1846         if (inb_p(address + W83781D_ADDR_REG_OFFSET) != (val | 0x80)) {
1847                 outb_p(save, address + W83781D_ADDR_REG_OFFSET);
1848                 pr_debug("w83781d: Detection failed at step 3\n");
1849                 goto release;
1850         }
1851
1852         /* We found a device, now see if it could be a W83781D */
1853         outb_p(W83781D_REG_CONFIG, address + W83781D_ADDR_REG_OFFSET);
1854         val = inb_p(address + W83781D_DATA_REG_OFFSET);
1855         if (val & 0x80) {
1856                 pr_debug("w83781d: Detection failed at step 4\n");
1857                 goto release;
1858         }
1859         outb_p(W83781D_REG_BANK, address + W83781D_ADDR_REG_OFFSET);
1860         save = inb_p(address + W83781D_DATA_REG_OFFSET);
1861         outb_p(W83781D_REG_CHIPMAN, address + W83781D_ADDR_REG_OFFSET);
1862         val = inb_p(address + W83781D_DATA_REG_OFFSET);
1863         if ((!(save & 0x80) && (val != 0xa3))
1864          || ((save & 0x80) && (val != 0x5c))) {
1865                 pr_debug("w83781d: Detection failed at step 5\n");
1866                 goto release;
1867         }
1868         outb_p(W83781D_REG_I2C_ADDR, address + W83781D_ADDR_REG_OFFSET);
1869         val = inb_p(address + W83781D_DATA_REG_OFFSET);
1870         if (val < 0x03 || val > 0x77) { /* Not a valid I2C address */
1871                 pr_debug("w83781d: Detection failed at step 6\n");
1872                 goto release;
1873         }
1874
1875         /* The busy flag should be clear again */
1876         if (inb_p(address + W83781D_ADDR_REG_OFFSET) & 0x80) {
1877                 pr_debug("w83781d: Detection failed at step 7\n");
1878                 goto release;
1879         }
1880
1881         /* Determine the chip type */
1882         outb_p(W83781D_REG_BANK, address + W83781D_ADDR_REG_OFFSET);
1883         save = inb_p(address + W83781D_DATA_REG_OFFSET);
1884         outb_p(save & 0xf8, address + W83781D_DATA_REG_OFFSET);
1885         outb_p(W83781D_REG_WCHIPID, address + W83781D_ADDR_REG_OFFSET);
1886         val = inb_p(address + W83781D_DATA_REG_OFFSET);
1887         if ((val & 0xfe) == 0x10        /* W83781D */
1888          || val == 0x30                 /* W83782D */
1889          || val == 0x21)                /* W83627HF */
1890                 found = 1;
1891
1892         if (found)
1893                 pr_info("w83781d: Found a %s chip at %#x\n",
1894                         val == 0x21 ? "W83627HF" :
1895                         val == 0x30 ? "W83782D" : "W83781D", (int)address);
1896
1897  release:
1898         release_region(address, W83781D_EXTENT);
1899         return found;
1900 }
1901
1902 static int __init
1903 w83781d_isa_device_add(unsigned short address)
1904 {
1905         struct resource res = {
1906                 .start  = address,
1907                 .end    = address + W83781D_EXTENT - 1,
1908                 .name   = "w83781d",
1909                 .flags  = IORESOURCE_IO,
1910         };
1911         int err;
1912
1913         pdev = platform_device_alloc("w83781d", address);
1914         if (!pdev) {
1915                 err = -ENOMEM;
1916                 printk(KERN_ERR "w83781d: Device allocation failed\n");
1917                 goto exit;
1918         }
1919
1920         err = platform_device_add_resources(pdev, &res, 1);
1921         if (err) {
1922                 printk(KERN_ERR "w83781d: Device resource addition failed "
1923                        "(%d)\n", err);
1924                 goto exit_device_put;
1925         }
1926
1927         err = platform_device_add(pdev);
1928         if (err) {
1929                 printk(KERN_ERR "w83781d: Device addition failed (%d)\n",
1930                        err);
1931                 goto exit_device_put;
1932         }
1933
1934         return 0;
1935
1936  exit_device_put:
1937         platform_device_put(pdev);
1938  exit:
1939         pdev = NULL;
1940         return err;
1941 }
1942
1943 static int __init
1944 sensors_w83781d_init(void)
1945 {
1946         int res;
1947
1948         res = i2c_add_driver(&w83781d_driver);
1949         if (res)
1950                 goto exit;
1951
1952         if (w83781d_isa_found(isa_address)) {
1953                 res = platform_driver_register(&w83781d_isa_driver);
1954                 if (res)
1955                         goto exit_unreg_i2c_driver;
1956
1957                 /* Sets global pdev as a side effect */
1958                 res = w83781d_isa_device_add(isa_address);
1959                 if (res)
1960                         goto exit_unreg_isa_driver;
1961         }
1962
1963         return 0;
1964
1965  exit_unreg_isa_driver:
1966         platform_driver_unregister(&w83781d_isa_driver);
1967  exit_unreg_i2c_driver:
1968         i2c_del_driver(&w83781d_driver);
1969  exit:
1970         return res;
1971 }
1972
1973 static void __exit
1974 sensors_w83781d_exit(void)
1975 {
1976         if (pdev) {
1977                 platform_device_unregister(pdev);
1978                 platform_driver_unregister(&w83781d_isa_driver);
1979         }
1980         i2c_del_driver(&w83781d_driver);
1981 }
1982
1983 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
1984               "Philip Edelbrock <phil@netroedge.com>, "
1985               "and Mark Studebaker <mdsxyz123@yahoo.com>");
1986 MODULE_DESCRIPTION("W83781D driver");
1987 MODULE_LICENSE("GPL");
1988
1989 module_init(sensors_w83781d_init);
1990 module_exit(sensors_w83781d_exit);