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