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