drivers/i2c/chips/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
   8     This program is free software; you can redistribute it and/or modify
   9     it under the terms of the GNU General Public License as published by
  10     the Free Software Foundation; either version 2 of the License, or
  11     (at your option) any later version.
  12
  13     This program is distributed in the hope that it will be useful,
  14     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16     GNU General Public License for more details.
  17
  18     You should have received a copy of the GNU General Public License
  19     along with this program; if not, write to the Free Software
  20     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 /*
  24     Supports following chips:
  25
  26     Chip        #vin    #fanin  #pwm    #temp   wchipid vendid  i2c     ISA
  27     as99127f    7       3       0       3       0x31    0x12c3  yes     no
  28     as99127f rev.2 (type_name = as99127f)       0x31    0x5ca3  yes     no
  29     w83781d     7       3       0       3       0x10-1  0x5ca3  yes     yes
  30     w83627hf    9       3       2       3       0x21    0x5ca3  yes     yes(LPC)
  31     w83627thf   9       3       2       3       0x90    0x5ca3  no      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     w83697hf    8       2       2       2       0x60    0x5ca3  no      yes(LPC)
  35
  36 */
  37
  38 #include <linux/config.h>
  39 #include <linux/module.h>
  40 #include <linux/init.h>
  41 #include <linux/slab.h>
  42 #include <linux/i2c.h>
  43 #include <linux/i2c-sensor.h>
  44 #include <linux/i2c-vid.h>
  45 #include <asm/io.h>
  46 #include "lm75.h"
  47
  48 /* RT Table support #defined so we can take it out if it gets bothersome */
  49 #define W83781D_RT                      1
  50
  51 /* Addresses to scan */
  52 static unsigned short normal_i2c[] = { 0x20, 0x21, 0x22, 0x23, 0x24, 0x25,
  53                                         0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b,
  54                                         0x2c, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END };
  55 static unsigned int normal_isa[] = { 0x0290, I2C_CLIENT_ISA_END };
  56
  57 /* Insmod parameters */
  58 SENSORS_INSMOD_6(w83781d, w83782d, w83783s, w83627hf, as99127f, w83697hf);
  59 I2C_CLIENT_MODULE_PARM(force_subclients, "List of subclient addresses: "
  60                     "{bus, clientaddr, subclientaddr1, subclientaddr2}");
  61
  62 static int init = 1;
  63 module_param(init, bool, 0);
  64 MODULE_PARM_DESC(init, "Set to zero to bypass chip initialization");
  65
  66 /* Constants specified below */
  67
  68 /* Length of ISA address segment */
  69 #define W83781D_EXTENT                  8
  70
  71 /* Where are the ISA address/data registers relative to the base address */
  72 #define W83781D_ADDR_REG_OFFSET         5
  73 #define W83781D_DATA_REG_OFFSET         6
  74
  75 /* The W83781D registers */
  76 /* The W83782D registers for nr=7,8 are in bank 5 */
  77 #define W83781D_REG_IN_MAX(nr)          ((nr < 7) ? (0x2b + (nr) * 2) : \
  78                                                     (0x554 + (((nr) - 7) * 2)))
  79 #define W83781D_REG_IN_MIN(nr)          ((nr < 7) ? (0x2c + (nr) * 2) : \
  80                                                     (0x555 + (((nr) - 7) * 2)))
  81 #define W83781D_REG_IN(nr)              ((nr < 7) ? (0x20 + (nr)) : \
  82                                                     (0x550 + (nr) - 7))
  83
  84 #define W83781D_REG_FAN_MIN(nr)         (0x3a + (nr))
  85 #define W83781D_REG_FAN(nr)             (0x27 + (nr))
  86
  87 #define W83781D_REG_BANK                0x4E
  88 #define W83781D_REG_TEMP2_CONFIG        0x152
  89 #define W83781D_REG_TEMP3_CONFIG        0x252
  90 #define W83781D_REG_TEMP(nr)            ((nr == 3) ? (0x0250) : \
  91                                         ((nr == 2) ? (0x0150) : \
  92                                                      (0x27)))
  93 #define W83781D_REG_TEMP_HYST(nr)       ((nr == 3) ? (0x253) : \
  94                                         ((nr == 2) ? (0x153) : \
  95                                                      (0x3A)))
  96 #define W83781D_REG_TEMP_OVER(nr)       ((nr == 3) ? (0x255) : \
  97                                         ((nr == 2) ? (0x155) : \
  98                                                      (0x39)))
  99
 100 #define W83781D_REG_CONFIG              0x40
 101 #define W83781D_REG_ALARM1              0x41
 102 #define W83781D_REG_ALARM2              0x42
 103 #define W83781D_REG_ALARM3              0x450   /* not on W83781D */
 104
 105 #define W83781D_REG_IRQ                 0x4C
 106 #define W83781D_REG_BEEP_CONFIG         0x4D
 107 #define W83781D_REG_BEEP_INTS1          0x56
 108 #define W83781D_REG_BEEP_INTS2          0x57
 109 #define W83781D_REG_BEEP_INTS3          0x453   /* not on W83781D */
 110
 111 #define W83781D_REG_VID_FANDIV          0x47
 112
 113 #define W83781D_REG_CHIPID              0x49
 114 #define W83781D_REG_WCHIPID             0x58
 115 #define W83781D_REG_CHIPMAN             0x4F
 116 #define W83781D_REG_PIN                 0x4B
 117
 118 /* 782D/783S only */
 119 #define W83781D_REG_VBAT                0x5D
 120
 121 /* PWM 782D (1-4) and 783S (1-2) only */
 122 #define W83781D_REG_PWM1                0x5B    /* 782d and 783s/627hf datasheets disagree */
 123                                                 /* on which is which; */
 124 #define W83781D_REG_PWM2                0x5A    /* We follow the 782d convention here, */
 125                                                 /* However 782d is probably wrong. */
 126 #define W83781D_REG_PWM3                0x5E
 127 #define W83781D_REG_PWM4                0x5F
 128 #define W83781D_REG_PWMCLK12            0x5C
 129 #define W83781D_REG_PWMCLK34            0x45C
 130 static const u8 regpwm[] = { W83781D_REG_PWM1, W83781D_REG_PWM2,
 131         W83781D_REG_PWM3, W83781D_REG_PWM4
 132 };
 133
 134 #define W83781D_REG_PWM(nr)             (regpwm[(nr) - 1])
 135
 136 #define W83781D_REG_I2C_ADDR            0x48
 137 #define W83781D_REG_I2C_SUBADDR         0x4A
 138
 139 /* The following are undocumented in the data sheets however we
 140    received the information in an email from Winbond tech support */
 141 /* Sensor selection - not on 781d */
 142 #define W83781D_REG_SCFG1               0x5D
 143 static const u8 BIT_SCFG1[] = { 0x02, 0x04, 0x08 };
 144
 145 #define W83781D_REG_SCFG2               0x59
 146 static const u8 BIT_SCFG2[] = { 0x10, 0x20, 0x40 };
 147
 148 #define W83781D_DEFAULT_BETA            3435
 149
 150 /* RT Table registers */
 151 #define W83781D_REG_RT_IDX              0x50
 152 #define W83781D_REG_RT_VAL              0x51
 153
 154 /* Conversions. Rounding and limit checking is only done on the TO_REG
 155    variants. Note that you should be a bit careful with which arguments
 156    these macros are called: arguments may be evaluated more than once.
 157    Fixing this is just not worth it. */
 158 #define IN_TO_REG(val)                  (SENSORS_LIMIT((((val) * 10 + 8)/16),0,255))
 159 #define IN_FROM_REG(val)                (((val) * 16) / 10)
 160
 161 static inline u8
 162 FAN_TO_REG(long rpm, int div)
 163 {
 164         if (rpm == 0)
 165                 return 255;
 166         rpm = SENSORS_LIMIT(rpm, 1, 1000000);
 167         return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
 168 }
 169
 170 #define FAN_FROM_REG(val,div)           ((val) == 0   ? -1 : \
 171                                         ((val) == 255 ? 0 : \
 172                                                         1350000 / ((val) * (div))))
 173
 174 #define TEMP_TO_REG(val)                (SENSORS_LIMIT(((val) < 0 ? (val)+0x100*1000 \
 175                                                 : (val)) / 1000, 0, 0xff))
 176 #define TEMP_FROM_REG(val)              (((val) & 0x80 ? (val)-0x100 : (val)) * 1000)
 177
 178 #define AS99127_TEMP_ADD_TO_REG(val)    (SENSORS_LIMIT((((val) < 0 ? (val)+0x10000*250 \
 179                                                 : (val)) / 250) << 7, 0, 0xffff))
 180 #define AS99127_TEMP_ADD_FROM_REG(val)  ((((val) & 0x8000 ? (val)-0x10000 : (val)) \
 181                                                 >> 7) * 250)
 182
 183 #define ALARMS_FROM_REG(val)            (val)
 184 #define PWM_FROM_REG(val)               (val)
 185 #define PWM_TO_REG(val)                 (SENSORS_LIMIT((val),0,255))
 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 BEEP_ENABLE_TO_REG(val)         ((val) ? 1 : 0)
 192 #define BEEP_ENABLE_FROM_REG(val)       ((val) ? 1 : 0)
 193
 194 #define DIV_FROM_REG(val)               (1 << (val))
 195
 196 static inline u8
 197 DIV_TO_REG(long val, enum chips type)
 198 {
 199         int i;
 200         val = SENSORS_LIMIT(val, 1,
 201                             ((type == w83781d
 202                               || type == as99127f) ? 8 : 128)) >> 1;
 203         for (i = 0; i < 6; i++) {
 204                 if (val == 0)
 205                         break;
 206                 val >>= 1;
 207         }
 208         return ((u8) i);
 209 }
 210
 211 /* There are some complications in a module like this. First off, W83781D chips
 212    may be both present on the SMBus and the ISA bus, and we have to handle
 213    those cases separately at some places. Second, there might be several
 214    W83781D chips available (well, actually, that is probably never done; but
 215    it is a clean illustration of how to handle a case like that). Finally,
 216    a specific chip may be attached to *both* ISA and SMBus, and we would
 217    not like to detect it double. Fortunately, in the case of the W83781D at
 218    least, a register tells us what SMBus address we are on, so that helps
 219    a bit - except if there could be more than one SMBus. Groan. No solution
 220    for this yet. */
 221
 222 /* This module may seem overly long and complicated. In fact, it is not so
 223    bad. Quite a lot of bookkeeping is done. A real driver can often cut
 224    some corners. */
 225
 226 /* For each registered W83781D, we need to keep some data in memory. That
 227    data is pointed to by w83781d_list[NR]->data. The structure itself is
 228    dynamically allocated, at the same time when a new w83781d client is
 229    allocated. */
 230 struct w83781d_data {
 231         struct i2c_client client;
 232         struct semaphore lock;
 233         enum chips type;
 234
 235         struct semaphore update_lock;
 236         char valid;             /* !=0 if following fields are valid */
 237         unsigned long last_updated;     /* In jiffies */
 238
 239         struct i2c_client *lm75[2];     /* for secondary I2C addresses */
 240         /* array of 2 pointers to subclients */
 241
 242         u8 in[9];               /* Register value - 8 & 9 for 782D only */
 243         u8 in_max[9];           /* Register value - 8 & 9 for 782D only */
 244         u8 in_min[9];           /* Register value - 8 & 9 for 782D only */
 245         u8 fan[3];              /* Register value */
 246         u8 fan_min[3];          /* Register value */
 247         u8 temp;
 248         u8 temp_max;            /* Register value */
 249         u8 temp_max_hyst;       /* Register value */
 250         u16 temp_add[2];        /* Register value */
 251         u16 temp_max_add[2];    /* Register value */
 252         u16 temp_max_hyst_add[2];       /* Register value */
 253         u8 fan_div[3];          /* Register encoding, shifted right */
 254         u8 vid;                 /* Register encoding, combined */
 255         u32 alarms;             /* Register encoding, combined */
 256         u32 beep_mask;          /* Register encoding, combined */
 257         u8 beep_enable;         /* Boolean */
 258         u8 pwm[4];              /* Register value */
 259         u8 pwmenable[4];        /* Boolean */
 260         u16 sens[3];            /* 782D/783S only.
 261                                    1 = pentium diode; 2 = 3904 diode;
 262                                    3000-5000 = thermistor beta.
 263                                    Default = 3435.
 264                                    Other Betas unimplemented */
 265 #ifdef W83781D_RT
 266         u8 rt[3][32];           /* Register value */
 267 #endif
 268         u8 vrm;
 269 };
 270
 271 static int w83781d_attach_adapter(struct i2c_adapter *adapter);
 272 static int w83781d_detect(struct i2c_adapter *adapter, int address, int kind);
 273 static int w83781d_detach_client(struct i2c_client *client);
 274
 275 static int w83781d_read_value(struct i2c_client *client, u16 register);
 276 static int w83781d_write_value(struct i2c_client *client, u16 register,
 277                                u16 value);
 278 static struct w83781d_data *w83781d_update_device(struct device *dev);
 279 static void w83781d_init_client(struct i2c_client *client);
 280
 281 static struct i2c_driver w83781d_driver = {
 282         .owner = THIS_MODULE,
 283         .name = "w83781d",
 284         .id = I2C_DRIVERID_W83781D,
 285         .flags = I2C_DF_NOTIFY,
 286         .attach_adapter = w83781d_attach_adapter,
 287         .detach_client = w83781d_detach_client,
 288 };
 289
 290 /* following are the sysfs callback functions */
 291 #define show_in_reg(reg) \
 292 static ssize_t show_##reg (struct device *dev, char *buf, int nr) \
 293 { \
 294         struct w83781d_data *data = w83781d_update_device(dev); \
 295         return sprintf(buf,"%ld\n", (long)IN_FROM_REG(data->reg[nr] * 10)); \
 296 }
 297 show_in_reg(in);
 298 show_in_reg(in_min);
 299 show_in_reg(in_max);
 300
 301 #define store_in_reg(REG, reg) \
 302 static ssize_t store_in_##reg (struct device *dev, const char *buf, size_t count, int nr) \
 303 { \
 304         struct i2c_client *client = to_i2c_client(dev); \
 305         struct w83781d_data *data = i2c_get_clientdata(client); \
 306         u32 val; \
 307          \
 308         val = simple_strtoul(buf, NULL, 10) / 10; \
 309         data->in_##reg[nr] = IN_TO_REG(val); \
 310         w83781d_write_value(client, W83781D_REG_IN_##REG(nr), data->in_##reg[nr]); \
 311          \
 312         return count; \
 313 }
 314 store_in_reg(MIN, min);
 315 store_in_reg(MAX, max);
 316
 317 #define sysfs_in_offset(offset) \
 318 static ssize_t \
 319 show_regs_in_##offset (struct device *dev, char *buf) \
 320 { \
 321         return show_in(dev, buf, offset); \
 322 } \
 323 static DEVICE_ATTR(in##offset##_input, S_IRUGO, show_regs_in_##offset, NULL);
 324
 325 #define sysfs_in_reg_offset(reg, offset) \
 326 static ssize_t show_regs_in_##reg##offset (struct device *dev, char *buf) \
 327 { \
 328         return show_in_##reg (dev, buf, offset); \
 329 } \
 330 static ssize_t store_regs_in_##reg##offset (struct device *dev, const char *buf, size_t count) \
 331 { \
 332         return store_in_##reg (dev, buf, count, offset); \
 333 } \
 334 static DEVICE_ATTR(in##offset##_##reg, S_IRUGO| S_IWUSR, show_regs_in_##reg##offset, store_regs_in_##reg##offset);
 335
 336 #define sysfs_in_offsets(offset) \
 337 sysfs_in_offset(offset); \
 338 sysfs_in_reg_offset(min, offset); \
 339 sysfs_in_reg_offset(max, offset);
 340
 341 sysfs_in_offsets(0);
 342 sysfs_in_offsets(1);
 343 sysfs_in_offsets(2);
 344 sysfs_in_offsets(3);
 345 sysfs_in_offsets(4);
 346 sysfs_in_offsets(5);
 347 sysfs_in_offsets(6);
 348 sysfs_in_offsets(7);
 349 sysfs_in_offsets(8);
 350
 351 #define device_create_file_in(client, offset) \
 352 do { \
 353 device_create_file(&client->dev, &dev_attr_in##offset##_input); \
 354 device_create_file(&client->dev, &dev_attr_in##offset##_min); \
 355 device_create_file(&client->dev, &dev_attr_in##offset##_max); \
 356 } while (0)
 357
 358 #define show_fan_reg(reg) \
 359 static ssize_t show_##reg (struct device *dev, char *buf, int nr) \
 360 { \
 361         struct w83781d_data *data = w83781d_update_device(dev); \
 362         return sprintf(buf,"%ld\n", \
 363                 FAN_FROM_REG(data->reg[nr-1], (long)DIV_FROM_REG(data->fan_div[nr-1]))); \
 364 }
 365 show_fan_reg(fan);
 366 show_fan_reg(fan_min);
 367
 368 static ssize_t
 369 store_fan_min(struct device *dev, const char *buf, size_t count, int nr)
 370 {
 371         struct i2c_client *client = to_i2c_client(dev);
 372         struct w83781d_data *data = i2c_get_clientdata(client);
 373         u32 val;
 374
 375         val = simple_strtoul(buf, NULL, 10);
 376         data->fan_min[nr - 1] =
 377             FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr - 1]));
 378         w83781d_write_value(client, W83781D_REG_FAN_MIN(nr),
 379                             data->fan_min[nr - 1]);
 380
 381         return count;
 382 }
 383
 384 #define sysfs_fan_offset(offset) \
 385 static ssize_t show_regs_fan_##offset (struct device *dev, char *buf) \
 386 { \
 387         return show_fan(dev, buf, offset); \
 388 } \
 389 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_regs_fan_##offset, NULL);
 390
 391 #define sysfs_fan_min_offset(offset) \
 392 static ssize_t show_regs_fan_min##offset (struct device *dev, char *buf) \
 393 { \
 394         return show_fan_min(dev, buf, offset); \
 395 } \
 396 static ssize_t store_regs_fan_min##offset (struct device *dev, const char *buf, size_t count) \
 397 { \
 398         return store_fan_min(dev, buf, count, offset); \
 399 } \
 400 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, show_regs_fan_min##offset, store_regs_fan_min##offset);
 401
 402 sysfs_fan_offset(1);
 403 sysfs_fan_min_offset(1);
 404 sysfs_fan_offset(2);
 405 sysfs_fan_min_offset(2);
 406 sysfs_fan_offset(3);
 407 sysfs_fan_min_offset(3);
 408
 409 #define device_create_file_fan(client, offset) \
 410 do { \
 411 device_create_file(&client->dev, &dev_attr_fan##offset##_input); \
 412 device_create_file(&client->dev, &dev_attr_fan##offset##_min); \
 413 } while (0)
 414
 415 #define show_temp_reg(reg) \
 416 static ssize_t show_##reg (struct device *dev, char *buf, int nr) \
 417 { \
 418         struct w83781d_data *data = w83781d_update_device(dev); \
 419         if (nr >= 2) {  /* TEMP2 and TEMP3 */ \
 420                 if (data->type == as99127f) { \
 421                         return sprintf(buf,"%ld\n", \
 422                                 (long)AS99127_TEMP_ADD_FROM_REG(data->reg##_add[nr-2])); \
 423                 } else { \
 424                         return sprintf(buf,"%d\n", \
 425                                 LM75_TEMP_FROM_REG(data->reg##_add[nr-2])); \
 426                 } \
 427         } else {        /* TEMP1 */ \
 428                 return sprintf(buf,"%ld\n", (long)TEMP_FROM_REG(data->reg)); \
 429         } \
 430 }
 431 show_temp_reg(temp);
 432 show_temp_reg(temp_max);
 433 show_temp_reg(temp_max_hyst);
 434
 435 #define store_temp_reg(REG, reg) \
 436 static ssize_t store_temp_##reg (struct device *dev, const char *buf, size_t count, int nr) \
 437 { \
 438         struct i2c_client *client = to_i2c_client(dev); \
 439         struct w83781d_data *data = i2c_get_clientdata(client); \
 440         s32 val; \
 441          \
 442         val = simple_strtol(buf, NULL, 10); \
 443          \
 444         if (nr >= 2) {  /* TEMP2 and TEMP3 */ \
 445                 if (data->type == as99127f) \
 446                         data->temp_##reg##_add[nr-2] = AS99127_TEMP_ADD_TO_REG(val); \
 447                 else \
 448                         data->temp_##reg##_add[nr-2] = LM75_TEMP_TO_REG(val); \
 449                  \
 450                 w83781d_write_value(client, W83781D_REG_TEMP_##REG(nr), \
 451                                 data->temp_##reg##_add[nr-2]); \
 452         } else {        /* TEMP1 */ \
 453                 data->temp_##reg = TEMP_TO_REG(val); \
 454                 w83781d_write_value(client, W83781D_REG_TEMP_##REG(nr), \
 455                         data->temp_##reg); \
 456         } \
 457          \
 458         return count; \
 459 }
 460 store_temp_reg(OVER, max);
 461 store_temp_reg(HYST, max_hyst);
 462
 463 #define sysfs_temp_offset(offset) \
 464 static ssize_t \
 465 show_regs_temp_##offset (struct device *dev, char *buf) \
 466 { \
 467         return show_temp(dev, buf, offset); \
 468 } \
 469 static DEVICE_ATTR(temp##offset##_input, S_IRUGO, show_regs_temp_##offset, NULL);
 470
 471 #define sysfs_temp_reg_offset(reg, offset) \
 472 static ssize_t show_regs_temp_##reg##offset (struct device *dev, char *buf) \
 473 { \
 474         return show_temp_##reg (dev, buf, offset); \
 475 } \
 476 static ssize_t store_regs_temp_##reg##offset (struct device *dev, const char *buf, size_t count) \
 477 { \
 478         return store_temp_##reg (dev, buf, count, offset); \
 479 } \
 480 static DEVICE_ATTR(temp##offset##_##reg, S_IRUGO| S_IWUSR, show_regs_temp_##reg##offset, store_regs_temp_##reg##offset);
 481
 482 #define sysfs_temp_offsets(offset) \
 483 sysfs_temp_offset(offset); \
 484 sysfs_temp_reg_offset(max, offset); \
 485 sysfs_temp_reg_offset(max_hyst, offset);
 486
 487 sysfs_temp_offsets(1);
 488 sysfs_temp_offsets(2);
 489 sysfs_temp_offsets(3);
 490
 491 #define device_create_file_temp(client, offset) \
 492 do { \
 493 device_create_file(&client->dev, &dev_attr_temp##offset##_input); \
 494 device_create_file(&client->dev, &dev_attr_temp##offset##_max); \
 495 device_create_file(&client->dev, &dev_attr_temp##offset##_max_hyst); \
 496 } while (0)
 497
 498 static ssize_t
 499 show_vid_reg(struct device *dev, char *buf)
 500 {
 501         struct w83781d_data *data = w83781d_update_device(dev);
 502         return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm));
 503 }
 504
 505 static
 506 DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
 507 #define device_create_file_vid(client) \
 508 device_create_file(&client->dev, &dev_attr_cpu0_vid);
 509 static ssize_t
 510 show_vrm_reg(struct device *dev, char *buf)
 511 {
 512         struct w83781d_data *data = w83781d_update_device(dev);
 513         return sprintf(buf, "%ld\n", (long) data->vrm);
 514 }
 515
 516 static ssize_t
 517 store_vrm_reg(struct device *dev, const char *buf, size_t count)
 518 {
 519         struct i2c_client *client = to_i2c_client(dev);
 520         struct w83781d_data *data = i2c_get_clientdata(client);
 521         u32 val;
 522
 523         val = simple_strtoul(buf, NULL, 10);
 524         data->vrm = val;
 525
 526         return count;
 527 }
 528
 529 static
 530 DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
 531 #define device_create_file_vrm(client) \
 532 device_create_file(&client->dev, &dev_attr_vrm);
 533 static ssize_t
 534 show_alarms_reg(struct device *dev, char *buf)
 535 {
 536         struct w83781d_data *data = w83781d_update_device(dev);
 537         return sprintf(buf, "%ld\n", (long) ALARMS_FROM_REG(data->alarms));
 538 }
 539
 540 static
 541 DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
 542 #define device_create_file_alarms(client) \
 543 device_create_file(&client->dev, &dev_attr_alarms);
 544 static ssize_t show_beep_mask (struct device *dev, char *buf)
 545 {
 546         struct w83781d_data *data = w83781d_update_device(dev);
 547         return sprintf(buf, "%ld\n",
 548                        (long)BEEP_MASK_FROM_REG(data->beep_mask, data->type));
 549 }
 550 static ssize_t show_beep_enable (struct device *dev, char *buf)
 551 {
 552         struct w83781d_data *data = w83781d_update_device(dev);
 553         return sprintf(buf, "%ld\n",
 554                        (long)BEEP_ENABLE_FROM_REG(data->beep_enable));
 555 }
 556
 557 #define BEEP_ENABLE                     0       /* Store beep_enable */
 558 #define BEEP_MASK                       1       /* Store beep_mask */
 559
 560 static ssize_t
 561 store_beep_reg(struct device *dev, const char *buf, size_t count,
 562                int update_mask)
 563 {
 564         struct i2c_client *client = to_i2c_client(dev);
 565         struct w83781d_data *data = i2c_get_clientdata(client);
 566         u32 val, val2;
 567
 568         val = simple_strtoul(buf, NULL, 10);
 569
 570         if (update_mask == BEEP_MASK) { /* We are storing beep_mask */
 571                 data->beep_mask = BEEP_MASK_TO_REG(val, data->type);
 572                 w83781d_write_value(client, W83781D_REG_BEEP_INTS1,
 573                                     data->beep_mask & 0xff);
 574
 575                 if ((data->type != w83781d) && (data->type != as99127f)) {
 576                         w83781d_write_value(client, W83781D_REG_BEEP_INTS3,
 577                                             ((data->beep_mask) >> 16) & 0xff);
 578                 }
 579
 580                 val2 = (data->beep_mask >> 8) & 0x7f;
 581         } else {                /* We are storing beep_enable */
 582                 val2 = w83781d_read_value(client, W83781D_REG_BEEP_INTS2) & 0x7f;
 583                 data->beep_enable = BEEP_ENABLE_TO_REG(val);
 584         }
 585
 586         w83781d_write_value(client, W83781D_REG_BEEP_INTS2,
 587                             val2 | data->beep_enable << 7);
 588
 589         return count;
 590 }
 591
 592 #define sysfs_beep(REG, reg) \
 593 static ssize_t show_regs_beep_##reg (struct device *dev, char *buf) \
 594 { \
 595         return show_beep_##reg(dev, buf); \
 596 } \
 597 static ssize_t store_regs_beep_##reg (struct device *dev, const char *buf, size_t count) \
 598 { \
 599         return store_beep_reg(dev, buf, count, BEEP_##REG); \
 600 } \
 601 static DEVICE_ATTR(beep_##reg, S_IRUGO | S_IWUSR, show_regs_beep_##reg, store_regs_beep_##reg);
 602
 603 sysfs_beep(ENABLE, enable);
 604 sysfs_beep(MASK, mask);
 605
 606 #define device_create_file_beep(client) \
 607 do { \
 608 device_create_file(&client->dev, &dev_attr_beep_enable); \
 609 device_create_file(&client->dev, &dev_attr_beep_mask); \
 610 } while (0)
 611
 612 static ssize_t
 613 show_fan_div_reg(struct device *dev, char *buf, int nr)
 614 {
 615         struct w83781d_data *data = w83781d_update_device(dev);
 616         return sprintf(buf, "%ld\n",
 617                        (long) DIV_FROM_REG(data->fan_div[nr - 1]));
 618 }
 619
 620 /* Note: we save and restore the fan minimum here, because its value is
 621    determined in part by the fan divisor.  This follows the principle of
 622    least suprise; the user doesn't expect the fan minimum to change just
 623    because the divisor changed. */
 624 static ssize_t
 625 store_fan_div_reg(struct device *dev, const char *buf, size_t count, int nr)
 626 {
 627         struct i2c_client *client = to_i2c_client(dev);
 628         struct w83781d_data *data = i2c_get_clientdata(client);
 629         unsigned long min;
 630         u8 reg;
 631
 632         /* Save fan_min */
 633         min = FAN_FROM_REG(data->fan_min[nr],
 634                            DIV_FROM_REG(data->fan_div[nr]));
 635
 636         data->fan_div[nr] = DIV_TO_REG(simple_strtoul(buf, NULL, 10),
 637                                       data->type);
 638
 639         reg = (w83781d_read_value(client, nr==2 ? W83781D_REG_PIN : W83781D_REG_VID_FANDIV)
 640                & (nr==0 ? 0xcf : 0x3f))
 641             | ((data->fan_div[nr] & 0x03) << (nr==0 ? 4 : 6));
 642         w83781d_write_value(client, nr==2 ? W83781D_REG_PIN : W83781D_REG_VID_FANDIV, reg);
 643
 644         /* w83781d and as99127f don't have extended divisor bits */
 645         if (data->type != w83781d && data->type != as99127f) {
 646                 reg = (w83781d_read_value(client, W83781D_REG_VBAT)
 647                        & ~(1 << (5 + nr)))
 648                     | ((data->fan_div[nr] & 0x04) << (3 + nr));
 649                 w83781d_write_value(client, W83781D_REG_VBAT, reg);
 650         }
 651
 652         /* Restore fan_min */
 653         data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
 654         w83781d_write_value(client, W83781D_REG_FAN_MIN(nr+1), data->fan_min[nr]);
 655
 656         return count;
 657 }
 658
 659 #define sysfs_fan_div(offset) \
 660 static ssize_t show_regs_fan_div_##offset (struct device *dev, char *buf) \
 661 { \
 662         return show_fan_div_reg(dev, buf, offset); \
 663 } \
 664 static ssize_t store_regs_fan_div_##offset (struct device *dev, const char *buf, size_t count) \
 665 { \
 666         return store_fan_div_reg(dev, buf, count, offset - 1); \
 667 } \
 668 static DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, show_regs_fan_div_##offset, store_regs_fan_div_##offset);
 669
 670 sysfs_fan_div(1);
 671 sysfs_fan_div(2);
 672 sysfs_fan_div(3);
 673
 674 #define device_create_file_fan_div(client, offset) \
 675 do { \
 676 device_create_file(&client->dev, &dev_attr_fan##offset##_div); \
 677 } while (0)
 678
 679 static ssize_t
 680 show_pwm_reg(struct device *dev, char *buf, int nr)
 681 {
 682         struct w83781d_data *data = w83781d_update_device(dev);
 683         return sprintf(buf, "%ld\n", (long) PWM_FROM_REG(data->pwm[nr - 1]));
 684 }
 685
 686 static ssize_t
 687 show_pwmenable_reg(struct device *dev, char *buf, int nr)
 688 {
 689         struct w83781d_data *data = w83781d_update_device(dev);
 690         return sprintf(buf, "%ld\n", (long) data->pwmenable[nr - 1]);
 691 }
 692
 693 static ssize_t
 694 store_pwm_reg(struct device *dev, const char *buf, size_t count, int nr)
 695 {
 696         struct i2c_client *client = to_i2c_client(dev);
 697         struct w83781d_data *data = i2c_get_clientdata(client);
 698         u32 val;
 699
 700         val = simple_strtoul(buf, NULL, 10);
 701
 702         data->pwm[nr - 1] = PWM_TO_REG(val);
 703         w83781d_write_value(client, W83781D_REG_PWM(nr), data->pwm[nr - 1]);
 704
 705         return count;
 706 }
 707
 708 static ssize_t
 709 store_pwmenable_reg(struct device *dev, const char *buf, size_t count, int nr)
 710 {
 711         struct i2c_client *client = to_i2c_client(dev);
 712         struct w83781d_data *data = i2c_get_clientdata(client);
 713         u32 val, reg;
 714
 715         val = simple_strtoul(buf, NULL, 10);
 716
 717         switch (val) {
 718         case 0:
 719         case 1:
 720                 reg = w83781d_read_value(client, W83781D_REG_PWMCLK12);
 721                 w83781d_write_value(client, W83781D_REG_PWMCLK12,
 722                                     (reg & 0xf7) | (val << 3));
 723
 724                 reg = w83781d_read_value(client, W83781D_REG_BEEP_CONFIG);
 725                 w83781d_write_value(client, W83781D_REG_BEEP_CONFIG,
 726                                     (reg & 0xef) | (!val << 4));
 727
 728                 data->pwmenable[nr - 1] = val;
 729                 break;
 730
 731         default:
 732                 return -EINVAL;
 733         }
 734
 735         return count;
 736 }
 737
 738 #define sysfs_pwm(offset) \
 739 static ssize_t show_regs_pwm_##offset (struct device *dev, char *buf) \
 740 { \
 741         return show_pwm_reg(dev, buf, offset); \
 742 } \
 743 static ssize_t store_regs_pwm_##offset (struct device *dev, \
 744                 const char *buf, size_t count) \
 745 { \
 746         return store_pwm_reg(dev, buf, count, offset); \
 747 } \
 748 static DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
 749                 show_regs_pwm_##offset, store_regs_pwm_##offset);
 750
 751 #define sysfs_pwmenable(offset) \
 752 static ssize_t show_regs_pwmenable_##offset (struct device *dev, char *buf) \
 753 { \
 754         return show_pwmenable_reg(dev, buf, offset); \
 755 } \
 756 static ssize_t store_regs_pwmenable_##offset (struct device *dev, \
 757                 const char *buf, size_t count) \
 758 { \
 759         return store_pwmenable_reg(dev, buf, count, offset); \
 760 } \
 761 static DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \
 762                 show_regs_pwmenable_##offset, store_regs_pwmenable_##offset);
 763
 764 sysfs_pwm(1);
 765 sysfs_pwm(2);
 766 sysfs_pwmenable(2);             /* only PWM2 can be enabled/disabled */
 767 sysfs_pwm(3);
 768 sysfs_pwm(4);
 769
 770 #define device_create_file_pwm(client, offset) \
 771 do { \
 772 device_create_file(&client->dev, &dev_attr_pwm##offset); \
 773 } while (0)
 774
 775 #define device_create_file_pwmenable(client, offset) \
 776 do { \
 777 device_create_file(&client->dev, &dev_attr_pwm##offset##_enable); \
 778 } while (0)
 779
 780 static ssize_t
 781 show_sensor_reg(struct device *dev, char *buf, int nr)
 782 {
 783         struct w83781d_data *data = w83781d_update_device(dev);
 784         return sprintf(buf, "%ld\n", (long) data->sens[nr - 1]);
 785 }
 786
 787 static ssize_t
 788 store_sensor_reg(struct device *dev, const char *buf, size_t count, int nr)
 789 {
 790         struct i2c_client *client = to_i2c_client(dev);
 791         struct w83781d_data *data = i2c_get_clientdata(client);
 792         u32 val, tmp;
 793
 794         val = simple_strtoul(buf, NULL, 10);
 795
 796         switch (val) {
 797         case 1:         /* PII/Celeron diode */
 798                 tmp = w83781d_read_value(client, W83781D_REG_SCFG1);
 799                 w83781d_write_value(client, W83781D_REG_SCFG1,
 800                                     tmp | BIT_SCFG1[nr - 1]);
 801                 tmp = w83781d_read_value(client, W83781D_REG_SCFG2);
 802                 w83781d_write_value(client, W83781D_REG_SCFG2,
 803                                     tmp | BIT_SCFG2[nr - 1]);
 804                 data->sens[nr - 1] = val;
 805                 break;
 806         case 2:         /* 3904 */
 807                 tmp = w83781d_read_value(client, W83781D_REG_SCFG1);
 808                 w83781d_write_value(client, W83781D_REG_SCFG1,
 809                                     tmp | BIT_SCFG1[nr - 1]);
 810                 tmp = w83781d_read_value(client, W83781D_REG_SCFG2);
 811                 w83781d_write_value(client, W83781D_REG_SCFG2,
 812                                     tmp & ~BIT_SCFG2[nr - 1]);
 813                 data->sens[nr - 1] = val;
 814                 break;
 815         case W83781D_DEFAULT_BETA:      /* thermistor */
 816                 tmp = w83781d_read_value(client, W83781D_REG_SCFG1);
 817                 w83781d_write_value(client, W83781D_REG_SCFG1,
 818                                     tmp & ~BIT_SCFG1[nr - 1]);
 819                 data->sens[nr - 1] = val;
 820                 break;
 821         default:
 822                 dev_err(dev, "Invalid sensor type %ld; must be 1, 2, or %d\n",
 823                        (long) val, W83781D_DEFAULT_BETA);
 824                 break;
 825         }
 826
 827         return count;
 828 }
 829
 830 #define sysfs_sensor(offset) \
 831 static ssize_t show_regs_sensor_##offset (struct device *dev, char *buf) \
 832 { \
 833     return show_sensor_reg(dev, buf, offset); \
 834 } \
 835 static ssize_t store_regs_sensor_##offset (struct device *dev, const char *buf, size_t count) \
 836 { \
 837     return store_sensor_reg(dev, buf, count, offset); \
 838 } \
 839 static DEVICE_ATTR(temp##offset##_type, S_IRUGO | S_IWUSR, show_regs_sensor_##offset, store_regs_sensor_##offset);
 840
 841 sysfs_sensor(1);
 842 sysfs_sensor(2);
 843 sysfs_sensor(3);
 844
 845 #define device_create_file_sensor(client, offset) \
 846 do { \
 847 device_create_file(&client->dev, &dev_attr_temp##offset##_type); \
 848 } while (0)
 849
 850 #ifdef W83781D_RT
 851 static ssize_t
 852 show_rt_reg(struct device *dev, char *buf, int nr)
 853 {
 854         struct w83781d_data *data = w83781d_update_device(dev);
 855         int i, j = 0;
 856
 857         for (i = 0; i < 32; i++) {
 858                 if (i > 0)
 859                         j += sprintf(buf, " %ld", (long) data->rt[nr - 1][i]);
 860                 else
 861                         j += sprintf(buf, "%ld", (long) data->rt[nr - 1][i]);
 862         }
 863         j += sprintf(buf, "\n");
 864
 865         return j;
 866 }
 867
 868 static ssize_t
 869 store_rt_reg(struct device *dev, const char *buf, size_t count, int nr)
 870 {
 871         struct i2c_client *client = to_i2c_client(dev);
 872         struct w83781d_data *data = i2c_get_clientdata(client);
 873         u32 val, i;
 874
 875         for (i = 0; i < count; i++) {
 876                 val = simple_strtoul(buf + count, NULL, 10);
 877
 878                 /* fixme: no bounds checking 0-255 */
 879                 data->rt[nr - 1][i] = val & 0xff;
 880                 w83781d_write_value(client, W83781D_REG_RT_IDX, i);
 881                 w83781d_write_value(client, W83781D_REG_RT_VAL,
 882                                     data->rt[nr - 1][i]);
 883         }
 884
 885         return count;
 886 }
 887
 888 #define sysfs_rt(offset) \
 889 static ssize_t show_regs_rt_##offset (struct device *dev, char *buf) \
 890 { \
 891         return show_rt_reg(dev, buf, offset); \
 892 } \
 893 static ssize_t store_regs_rt_##offset (struct device *dev, const char *buf, size_t count) \
 894 { \
 895     return store_rt_reg(dev, buf, count, offset); \
 896 } \
 897 static DEVICE_ATTR(rt##offset, S_IRUGO | S_IWUSR, show_regs_rt_##offset, store_regs_rt_##offset);
 898
 899 sysfs_rt(1);
 900 sysfs_rt(2);
 901 sysfs_rt(3);
 902
 903 #define device_create_file_rt(client, offset) \
 904 do { \
 905 device_create_file(&client->dev, &dev_attr_rt##offset); \
 906 } while (0)
 907
 908 #endif                          /* ifdef W83781D_RT */
 909
 910 /* This function is called when:
 911      * w83781d_driver is inserted (when this module is loaded), for each
 912        available adapter
 913      * when a new adapter is inserted (and w83781d_driver is still present) */
 914 static int
 915 w83781d_attach_adapter(struct i2c_adapter *adapter)
 916 {
 917         if (!(adapter->class & I2C_CLASS_HWMON))
 918                 return 0;
 919         return i2c_detect(adapter, &addr_data, w83781d_detect);
 920 }
 921
 922 /* Assumes that adapter is of I2C, not ISA variety.
 923  * OTHERWISE DON'T CALL THIS
 924  */
 925 static int
 926 w83781d_detect_subclients(struct i2c_adapter *adapter, int address, int kind,
 927                 struct i2c_client *new_client)
 928 {
 929         int i, val1 = 0, id;
 930         int err;
 931         const char *client_name = "";
 932         struct w83781d_data *data = i2c_get_clientdata(new_client);
 933
 934         data->lm75[0] = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
 935         if (!(data->lm75[0])) {
 936                 err = -ENOMEM;
 937                 goto ERROR_SC_0;
 938         }
 939         memset(data->lm75[0], 0x00, sizeof (struct i2c_client));
 940
 941         id = i2c_adapter_id(adapter);
 942
 943         if (force_subclients[0] == id && force_subclients[1] == address) {
 944                 for (i = 2; i <= 3; i++) {
 945                         if (force_subclients[i] < 0x48 ||
 946                             force_subclients[i] > 0x4f) {
 947                                 dev_err(&new_client->dev, "Invalid subclient "
 948                                         "address %d; must be 0x48-0x4f\n",
 949                                         force_subclients[i]);
 950                                 err = -EINVAL;
 951                                 goto ERROR_SC_1;
 952                         }
 953                 }
 954                 w83781d_write_value(new_client, W83781D_REG_I2C_SUBADDR,
 955                                 (force_subclients[2] & 0x07) |
 956                                 ((force_subclients[3] & 0x07) << 4));
 957                 data->lm75[0]->addr = force_subclients[2];
 958         } else {
 959                 val1 = w83781d_read_value(new_client, W83781D_REG_I2C_SUBADDR);
 960                 data->lm75[0]->addr = 0x48 + (val1 & 0x07);
 961         }
 962
 963         if (kind != w83783s) {
 964
 965                 data->lm75[1] = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
 966                 if (!(data->lm75[1])) {
 967                         err = -ENOMEM;
 968                         goto ERROR_SC_1;
 969                 }
 970                 memset(data->lm75[1], 0x0, sizeof(struct i2c_client));
 971
 972                 if (force_subclients[0] == id &&
 973                     force_subclients[1] == address) {
 974                         data->lm75[1]->addr = force_subclients[3];
 975                 } else {
 976                         data->lm75[1]->addr = 0x48 + ((val1 >> 4) & 0x07);
 977                 }
 978                 if (data->lm75[0]->addr == data->lm75[1]->addr) {
 979                         dev_err(&new_client->dev,
 980                                "Duplicate addresses 0x%x for subclients.\n",
 981                                data->lm75[0]->addr);
 982                         err = -EBUSY;
 983                         goto ERROR_SC_2;
 984                 }
 985         }
 986
 987         if (kind == w83781d)
 988                 client_name = "w83781d subclient";
 989         else if (kind == w83782d)
 990                 client_name = "w83782d subclient";
 991         else if (kind == w83783s)
 992                 client_name = "w83783s subclient";
 993         else if (kind == w83627hf)
 994                 client_name = "w83627hf subclient";
 995         else if (kind == as99127f)
 996                 client_name = "as99127f subclient";
 997
 998         for (i = 0; i <= 1; i++) {
 999                 /* store all data in w83781d */
1000                 i2c_set_clientdata(data->lm75[i], NULL);
1001                 data->lm75[i]->adapter = adapter;
1002                 data->lm75[i]->driver = &w83781d_driver;
1003                 data->lm75[i]->flags = 0;
1004                 strlcpy(data->lm75[i]->name, client_name,
1005                         I2C_NAME_SIZE);
1006                 if ((err = i2c_attach_client(data->lm75[i]))) {
1007                         dev_err(&new_client->dev, "Subclient %d "
1008                                 "registration at address 0x%x "
1009                                 "failed.\n", i, data->lm75[i]->addr);
1010                         if (i == 1)
1011                                 goto ERROR_SC_3;
1012                         goto ERROR_SC_2;
1013                 }
1014                 if (kind == w83783s)
1015                         break;
1016         }
1017
1018         return 0;
1019
1020 /* Undo inits in case of errors */
1021 ERROR_SC_3:
1022         i2c_detach_client(data->lm75[0]);
1023 ERROR_SC_2:
1024         if (NULL != data->lm75[1])
1025                 kfree(data->lm75[1]);
1026 ERROR_SC_1:
1027         if (NULL != data->lm75[0])
1028                 kfree(data->lm75[0]);
1029 ERROR_SC_0:
1030         return err;
1031 }
1032
1033 static int
1034 w83781d_detect(struct i2c_adapter *adapter, int address, int kind)
1035 {
1036         int i = 0, val1 = 0, val2;
1037         struct i2c_client *new_client;
1038         struct w83781d_data *data;
1039         int err;
1040         const char *client_name = "";
1041         int is_isa = i2c_is_isa_adapter(adapter);
1042         enum vendor { winbond, asus } vendid;
1043
1044         if (!is_isa
1045             && !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1046                 err = -EINVAL;
1047                 goto ERROR0;
1048         }
1049
1050         /* Prevent users from forcing a kind for a bus it isn't supposed
1051            to possibly be on */
1052         if (is_isa && (kind == as99127f || kind == w83783s)) {
1053                 dev_err(&adapter->dev,
1054                         "Cannot force I2C-only chip for ISA address 0x%02x.\n",
1055                         address);
1056                 err = -EINVAL;
1057                 goto ERROR0;
1058         }
1059         if (!is_isa && kind == w83697hf) {
1060                 dev_err(&adapter->dev,
1061                         "Cannot force ISA-only chip for I2C address 0x%02x.\n",
1062                         address);
1063                 err = -EINVAL;
1064                 goto ERROR0;
1065         }
1066
1067         if (is_isa)
1068                 if (!request_region(address, W83781D_EXTENT,
1069                                     w83781d_driver.name)) {
1070                         dev_dbg(&adapter->dev, "Request of region "
1071                                 "0x%x-0x%x for w83781d failed\n", address,
1072                                 address + W83781D_EXTENT - 1);
1073                         err = -EBUSY;
1074                         goto ERROR0;
1075                 }
1076
1077         /* Probe whether there is anything available on this address. Already
1078            done for SMBus clients */
1079         if (kind < 0) {
1080                 if (is_isa) {
1081
1082 #define REALLY_SLOW_IO
1083                         /* We need the timeouts for at least some LM78-like
1084                            chips. But only if we read 'undefined' registers. */
1085                         i = inb_p(address + 1);
1086                         if (inb_p(address + 2) != i
1087                          || inb_p(address + 3) != i
1088                          || inb_p(address + 7) != i) {
1089                                 dev_dbg(&adapter->dev, "Detection of w83781d "
1090                                         "chip failed at step 1\n");
1091                                 err = -ENODEV;
1092                                 goto ERROR1;
1093                         }
1094 #undef REALLY_SLOW_IO
1095
1096                         /* Let's just hope nothing breaks here */
1097                         i = inb_p(address + 5) & 0x7f;
1098                         outb_p(~i & 0x7f, address + 5);
1099                         val2 = inb_p(address + 5) & 0x7f;
1100                         if (val2 != (~i & 0x7f)) {
1101                                 outb_p(i, address + 5);
1102                                 dev_dbg(&adapter->dev, "Detection of w83781d "
1103                                         "chip failed at step 2 (0x%x != "
1104                                         "0x%x at 0x%x)\n", val2, ~i & 0x7f,
1105                                         address + 5);
1106                                 err = -ENODEV;
1107                                 goto ERROR1;
1108                         }
1109                 }
1110         }
1111
1112         /* OK. For now, we presume we have a valid client. We now create the
1113            client structure, even though we cannot fill it completely yet.
1114            But it allows us to access w83781d_{read,write}_value. */
1115
1116         if (!(data = kmalloc(sizeof(struct w83781d_data), GFP_KERNEL))) {
1117                 err = -ENOMEM;
1118                 goto ERROR1;
1119         }
1120         memset(data, 0, sizeof(struct w83781d_data));
1121
1122         new_client = &data->client;
1123         i2c_set_clientdata(new_client, data);
1124         new_client->addr = address;
1125         init_MUTEX(&data->lock);
1126         new_client->adapter = adapter;
1127         new_client->driver = &w83781d_driver;
1128         new_client->flags = 0;
1129
1130         /* Now, we do the remaining detection. */
1131
1132         /* The w8378?d may be stuck in some other bank than bank 0. This may
1133            make reading other information impossible. Specify a force=... or
1134            force_*=... parameter, and the Winbond will be reset to the right
1135            bank. */
1136         if (kind < 0) {
1137                 if (w83781d_read_value(new_client, W83781D_REG_CONFIG) & 0x80) {
1138                         dev_dbg(&new_client->dev, "Detection failed at step "
1139                                 "3\n");
1140                         err = -ENODEV;
1141                         goto ERROR2;
1142                 }
1143                 val1 = w83781d_read_value(new_client, W83781D_REG_BANK);
1144                 val2 = w83781d_read_value(new_client, W83781D_REG_CHIPMAN);
1145                 /* Check for Winbond or Asus ID if in bank 0 */
1146                 if ((!(val1 & 0x07)) &&
1147                     (((!(val1 & 0x80)) && (val2 != 0xa3) && (val2 != 0xc3))
1148                      || ((val1 & 0x80) && (val2 != 0x5c) && (val2 != 0x12)))) {
1149                         dev_dbg(&new_client->dev, "Detection failed at step "
1150                                 "4\n");
1151                         err = -ENODEV;
1152                         goto ERROR2;
1153                 }
1154                 /* If Winbond SMBus, check address at 0x48.
1155                    Asus doesn't support, except for as99127f rev.2 */
1156                 if ((!is_isa) && (((!(val1 & 0x80)) && (val2 == 0xa3)) ||
1157                                   ((val1 & 0x80) && (val2 == 0x5c)))) {
1158                         if (w83781d_read_value
1159                             (new_client, W83781D_REG_I2C_ADDR) != address) {
1160                                 dev_dbg(&new_client->dev, "Detection failed "
1161                                         "at step 5\n");
1162                                 err = -ENODEV;
1163                                 goto ERROR2;
1164                         }
1165                 }
1166         }
1167
1168         /* We have either had a force parameter, or we have already detected the
1169            Winbond. Put it now into bank 0 and Vendor ID High Byte */
1170         w83781d_write_value(new_client, W83781D_REG_BANK,
1171                             (w83781d_read_value(new_client,
1172                                                 W83781D_REG_BANK) & 0x78) |
1173                             0x80);
1174
1175         /* Determine the chip type. */
1176         if (kind <= 0) {
1177                 /* get vendor ID */
1178                 val2 = w83781d_read_value(new_client, W83781D_REG_CHIPMAN);
1179                 if (val2 == 0x5c)
1180                         vendid = winbond;
1181                 else if (val2 == 0x12)
1182                         vendid = asus;
1183                 else {
1184                         dev_dbg(&new_client->dev, "Chip was made by neither "
1185                                 "Winbond nor Asus?\n");
1186                         err = -ENODEV;
1187                         goto ERROR2;
1188                 }
1189
1190                 val1 = w83781d_read_value(new_client, W83781D_REG_WCHIPID);
1191                 if ((val1 == 0x10 || val1 == 0x11) && vendid == winbond)
1192                         kind = w83781d;
1193                 else if (val1 == 0x30 && vendid == winbond)
1194                         kind = w83782d;
1195                 else if (val1 == 0x40 && vendid == winbond && !is_isa
1196                                 && address == 0x2d)
1197                         kind = w83783s;
1198                 else if ((val1 == 0x21 || val1 == 0x90) && vendid == winbond)
1199                         kind = w83627hf;
1200                 else if (val1 == 0x31 && !is_isa && address >= 0x28)
1201                         kind = as99127f;
1202                 else if (val1 == 0x60 && vendid == winbond && is_isa)
1203                         kind = w83697hf;
1204                 else {
1205                         if (kind == 0)
1206                                 dev_warn(&new_client->dev, "Ignoring 'force' "
1207                                          "parameter for unknown chip at "
1208                                          "adapter %d, address 0x%02x\n",
1209                                          i2c_adapter_id(adapter), address);
1210                         err = -EINVAL;
1211                         goto ERROR2;
1212                 }
1213         }
1214
1215         if (kind == w83781d) {
1216                 client_name = "w83781d";
1217         } else if (kind == w83782d) {
1218                 client_name = "w83782d";
1219         } else if (kind == w83783s) {
1220                 client_name = "w83783s";
1221         } else if (kind == w83627hf) {
1222                 if (val1 == 0x90)
1223                         client_name = "w83627thf";
1224                 else
1225                         client_name = "w83627hf";
1226         } else if (kind == as99127f) {
1227                 client_name = "as99127f";
1228         } else if (kind == w83697hf) {
1229                 client_name = "w83697hf";
1230         }
1231
1232         /* Fill in the remaining client fields and put into the global list */
1233         strlcpy(new_client->name, client_name, I2C_NAME_SIZE);
1234         data->type = kind;
1235
1236         data->valid = 0;
1237         init_MUTEX(&data->update_lock);
1238
1239         /* Tell the I2C layer a new client has arrived */
1240         if ((err = i2c_attach_client(new_client)))
1241                 goto ERROR2;
1242
1243         /* attach secondary i2c lm75-like clients */
1244         if (!is_isa) {
1245                 if ((err = w83781d_detect_subclients(adapter, address,
1246                                 kind, new_client)))
1247                         goto ERROR3;
1248         } else {
1249                 data->lm75[0] = NULL;
1250                 data->lm75[1] = NULL;
1251         }
1252
1253         /* Initialize the chip */
1254         w83781d_init_client(new_client);
1255
1256         /* A few vars need to be filled upon startup */
1257         for (i = 1; i <= 3; i++) {
1258                 data->fan_min[i - 1] = w83781d_read_value(new_client,
1259                                         W83781D_REG_FAN_MIN(i));
1260         }
1261         if (kind != w83781d && kind != as99127f)
1262                 for (i = 0; i < 4; i++)
1263                         data->pwmenable[i] = 1;
1264
1265         /* Register sysfs hooks */
1266         device_create_file_in(new_client, 0);
1267         if (kind != w83783s && kind != w83697hf)
1268                 device_create_file_in(new_client, 1);
1269         device_create_file_in(new_client, 2);
1270         device_create_file_in(new_client, 3);
1271         device_create_file_in(new_client, 4);
1272         device_create_file_in(new_client, 5);
1273         device_create_file_in(new_client, 6);
1274         if (kind != as99127f && kind != w83781d && kind != w83783s) {
1275                 device_create_file_in(new_client, 7);
1276                 device_create_file_in(new_client, 8);
1277         }
1278
1279         device_create_file_fan(new_client, 1);
1280         device_create_file_fan(new_client, 2);
1281         if (kind != w83697hf)
1282                 device_create_file_fan(new_client, 3);
1283
1284         device_create_file_temp(new_client, 1);
1285         device_create_file_temp(new_client, 2);
1286         if (kind != w83783s && kind != w83697hf)
1287                 device_create_file_temp(new_client, 3);
1288
1289         if (kind != w83697hf)
1290                 device_create_file_vid(new_client);
1291
1292         if (kind != w83697hf)
1293                 device_create_file_vrm(new_client);
1294
1295         device_create_file_fan_div(new_client, 1);
1296         device_create_file_fan_div(new_client, 2);
1297         if (kind != w83697hf)
1298                 device_create_file_fan_div(new_client, 3);
1299
1300         device_create_file_alarms(new_client);
1301
1302         device_create_file_beep(new_client);
1303
1304         if (kind != w83781d && kind != as99127f) {
1305                 device_create_file_pwm(new_client, 1);
1306                 device_create_file_pwm(new_client, 2);
1307                 device_create_file_pwmenable(new_client, 2);
1308         }
1309         if (kind == w83782d && !is_isa) {
1310                 device_create_file_pwm(new_client, 3);
1311                 device_create_file_pwm(new_client, 4);
1312         }
1313
1314         if (kind != as99127f && kind != w83781d) {
1315                 device_create_file_sensor(new_client, 1);
1316                 device_create_file_sensor(new_client, 2);
1317                 if (kind != w83783s && kind != w83697hf)
1318                         device_create_file_sensor(new_client, 3);
1319         }
1320 #ifdef W83781D_RT
1321         if (kind == w83781d) {
1322                 device_create_file_rt(new_client, 1);
1323                 device_create_file_rt(new_client, 2);
1324                 device_create_file_rt(new_client, 3);
1325         }
1326 #endif
1327
1328         return 0;
1329
1330 ERROR3:
1331         i2c_detach_client(new_client);
1332 ERROR2:
1333         kfree(data);
1334 ERROR1:
1335         if (is_isa)
1336                 release_region(address, W83781D_EXTENT);
1337 ERROR0:
1338         return err;
1339 }
1340
1341 static int
1342 w83781d_detach_client(struct i2c_client *client)
1343 {
1344         int err;
1345
1346         if (i2c_is_isa_client(client))
1347                 release_region(client->addr, W83781D_EXTENT);
1348
1349         if ((err = i2c_detach_client(client))) {
1350                 dev_err(&client->dev,
1351                        "Client deregistration failed, client not detached.\n");
1352                 return err;
1353         }
1354
1355         if (i2c_get_clientdata(client)==NULL) {
1356                 /* subclients */
1357                 kfree(client);
1358         } else {
1359                 /* main client */
1360                 kfree(i2c_get_clientdata(client));
1361         }
1362
1363         return 0;
1364 }
1365
1366 /* The SMBus locks itself, usually, but nothing may access the Winbond between
1367    bank switches. ISA access must always be locked explicitly!
1368    We ignore the W83781D BUSY flag at this moment - it could lead to deadlocks,
1369    would slow down the W83781D access and should not be necessary.
1370    There are some ugly typecasts here, but the good news is - they should
1371    nowhere else be necessary! */
1372 static int
1373 w83781d_read_value(struct i2c_client *client, u16 reg)
1374 {
1375         struct w83781d_data *data = i2c_get_clientdata(client);
1376         int res, word_sized, bank;
1377         struct i2c_client *cl;
1378
1379         down(&data->lock);
1380         if (i2c_is_isa_client(client)) {
1381                 word_sized = (((reg & 0xff00) == 0x100)
1382                               || ((reg & 0xff00) == 0x200))
1383                     && (((reg & 0x00ff) == 0x50)
1384                         || ((reg & 0x00ff) == 0x53)
1385                         || ((reg & 0x00ff) == 0x55));
1386                 if (reg & 0xff00) {
1387                         outb_p(W83781D_REG_BANK,
1388                                client->addr + W83781D_ADDR_REG_OFFSET);
1389                         outb_p(reg >> 8,
1390                                client->addr + W83781D_DATA_REG_OFFSET);
1391                 }
1392                 outb_p(reg & 0xff, client->addr + W83781D_ADDR_REG_OFFSET);
1393                 res = inb_p(client->addr + W83781D_DATA_REG_OFFSET);
1394                 if (word_sized) {
1395                         outb_p((reg & 0xff) + 1,
1396                                client->addr + W83781D_ADDR_REG_OFFSET);
1397                         res =
1398                             (res << 8) + inb_p(client->addr +
1399                                                W83781D_DATA_REG_OFFSET);
1400                 }
1401                 if (reg & 0xff00) {
1402                         outb_p(W83781D_REG_BANK,
1403                                client->addr + W83781D_ADDR_REG_OFFSET);
1404                         outb_p(0, client->addr + W83781D_DATA_REG_OFFSET);
1405                 }
1406         } else {
1407                 bank = (reg >> 8) & 0x0f;
1408                 if (bank > 2)
1409                         /* switch banks */
1410                         i2c_smbus_write_byte_data(client, W83781D_REG_BANK,
1411                                                   bank);
1412                 if (bank == 0 || bank > 2) {
1413                         res = i2c_smbus_read_byte_data(client, reg & 0xff);
1414                 } else {
1415                         /* switch to subclient */
1416                         cl = data->lm75[bank - 1];
1417                         /* convert from ISA to LM75 I2C addresses */
1418                         switch (reg & 0xff) {
1419                         case 0x50:      /* TEMP */
1420                                 res = swab16(i2c_smbus_read_word_data(cl, 0));
1421                                 break;
1422                         case 0x52:      /* CONFIG */
1423                                 res = i2c_smbus_read_byte_data(cl, 1);
1424                                 break;
1425                         case 0x53:      /* HYST */
1426                                 res = swab16(i2c_smbus_read_word_data(cl, 2));
1427                                 break;
1428                         case 0x55:      /* OVER */
1429                         default:
1430                                 res = swab16(i2c_smbus_read_word_data(cl, 3));
1431                                 break;
1432                         }
1433                 }
1434                 if (bank > 2)
1435                         i2c_smbus_write_byte_data(client, W83781D_REG_BANK, 0);
1436         }
1437         up(&data->lock);
1438         return res;
1439 }
1440
1441 static int
1442 w83781d_write_value(struct i2c_client *client, u16 reg, u16 value)
1443 {
1444         struct w83781d_data *data = i2c_get_clientdata(client);
1445         int word_sized, bank;
1446         struct i2c_client *cl;
1447
1448         down(&data->lock);
1449         if (i2c_is_isa_client(client)) {
1450                 word_sized = (((reg & 0xff00) == 0x100)
1451                               || ((reg & 0xff00) == 0x200))
1452                     && (((reg & 0x00ff) == 0x53)
1453                         || ((reg & 0x00ff) == 0x55));
1454                 if (reg & 0xff00) {
1455                         outb_p(W83781D_REG_BANK,
1456                                client->addr + W83781D_ADDR_REG_OFFSET);
1457                         outb_p(reg >> 8,
1458                                client->addr + W83781D_DATA_REG_OFFSET);
1459                 }
1460                 outb_p(reg & 0xff, client->addr + W83781D_ADDR_REG_OFFSET);
1461                 if (word_sized) {
1462                         outb_p(value >> 8,
1463                                client->addr + W83781D_DATA_REG_OFFSET);
1464                         outb_p((reg & 0xff) + 1,
1465                                client->addr + W83781D_ADDR_REG_OFFSET);
1466                 }
1467                 outb_p(value & 0xff, client->addr + W83781D_DATA_REG_OFFSET);
1468                 if (reg & 0xff00) {
1469                         outb_p(W83781D_REG_BANK,
1470                                client->addr + W83781D_ADDR_REG_OFFSET);
1471                         outb_p(0, client->addr + W83781D_DATA_REG_OFFSET);
1472                 }
1473         } else {
1474                 bank = (reg >> 8) & 0x0f;
1475                 if (bank > 2)
1476                         /* switch banks */
1477                         i2c_smbus_write_byte_data(client, W83781D_REG_BANK,
1478                                                   bank);
1479                 if (bank == 0 || bank > 2) {
1480                         i2c_smbus_write_byte_data(client, reg & 0xff,
1481                                                   value & 0xff);
1482                 } else {
1483                         /* switch to subclient */
1484                         cl = data->lm75[bank - 1];
1485                         /* convert from ISA to LM75 I2C addresses */
1486                         switch (reg & 0xff) {
1487                         case 0x52:      /* CONFIG */
1488                                 i2c_smbus_write_byte_data(cl, 1, value & 0xff);
1489                                 break;
1490                         case 0x53:      /* HYST */
1491                                 i2c_smbus_write_word_data(cl, 2, swab16(value));
1492                                 break;
1493                         case 0x55:      /* OVER */
1494                                 i2c_smbus_write_word_data(cl, 3, swab16(value));
1495                                 break;
1496                         }
1497                 }
1498                 if (bank > 2)
1499                         i2c_smbus_write_byte_data(client, W83781D_REG_BANK, 0);
1500         }
1501         up(&data->lock);
1502         return 0;
1503 }
1504
1505 /* Called when we have found a new W83781D. It should set limits, etc. */
1506 static void
1507 w83781d_init_client(struct i2c_client *client)
1508 {
1509         struct w83781d_data *data = i2c_get_clientdata(client);
1510         int i, p;
1511         int type = data->type;
1512         u8 tmp;
1513
1514         if (init && type != as99127f) { /* this resets registers we don't have
1515                                            documentation for on the as99127f */
1516                 /* save these registers */
1517                 i = w83781d_read_value(client, W83781D_REG_BEEP_CONFIG);
1518                 p = w83781d_read_value(client, W83781D_REG_PWMCLK12);
1519                 /* Reset all except Watchdog values and last conversion values
1520                    This sets fan-divs to 2, among others */
1521                 w83781d_write_value(client, W83781D_REG_CONFIG, 0x80);
1522                 /* Restore the registers and disable power-on abnormal beep.
1523                    This saves FAN 1/2/3 input/output values set by BIOS. */
1524                 w83781d_write_value(client, W83781D_REG_BEEP_CONFIG, i | 0x80);
1525                 w83781d_write_value(client, W83781D_REG_PWMCLK12, p);
1526                 /* Disable master beep-enable (reset turns it on).
1527                    Individual beep_mask should be reset to off but for some reason
1528                    disabling this bit helps some people not get beeped */
1529                 w83781d_write_value(client, W83781D_REG_BEEP_INTS2, 0);
1530         }
1531
1532         data->vrm = i2c_which_vrm();
1533
1534         if ((type != w83781d) && (type != as99127f)) {
1535                 tmp = w83781d_read_value(client, W83781D_REG_SCFG1);
1536                 for (i = 1; i <= 3; i++) {
1537                         if (!(tmp & BIT_SCFG1[i - 1])) {
1538                                 data->sens[i - 1] = W83781D_DEFAULT_BETA;
1539                         } else {
1540                                 if (w83781d_read_value
1541                                     (client,
1542                                      W83781D_REG_SCFG2) & BIT_SCFG2[i - 1])
1543                                         data->sens[i - 1] = 1;
1544                                 else
1545                                         data->sens[i - 1] = 2;
1546                         }
1547                         if ((type == w83783s || type == w83697hf) && (i == 2))
1548                                 break;
1549                 }
1550         }
1551 #ifdef W83781D_RT
1552 /*
1553    Fill up the RT Tables.
1554    We assume that they are 32 bytes long, in order for temp 1-3.
1555    Data sheet documentation is sparse.
1556    We also assume that it is only for the 781D although I suspect
1557    that the others support it as well....
1558 */
1559
1560         if (init && type == w83781d) {
1561                 u16 k = 0;
1562 /*
1563     Auto-indexing doesn't seem to work...
1564     w83781d_write_value(client,W83781D_REG_RT_IDX,0);
1565 */
1566                 for (i = 0; i < 3; i++) {
1567                         int j;
1568                         for (j = 0; j < 32; j++) {
1569                                 w83781d_write_value(client,
1570                                                     W83781D_REG_RT_IDX, k++);
1571                                 data->rt[i][j] =
1572                                     w83781d_read_value(client,
1573                                                        W83781D_REG_RT_VAL);
1574                         }
1575                 }
1576         }
1577 #endif                          /* W83781D_RT */
1578
1579         if (init) {
1580                 if (type != w83783s && type != w83697hf) {
1581                         w83781d_write_value(client, W83781D_REG_TEMP3_CONFIG,
1582                                             0x00);
1583                 }
1584                 if (type != w83781d) {
1585                         /* enable comparator mode for temp2 and temp3 so
1586                            alarm indication will work correctly */
1587                         i = w83781d_read_value(client, W83781D_REG_IRQ);
1588                         if (!(i & 0x40))
1589                                 w83781d_write_value(client, W83781D_REG_IRQ,
1590                                                     i | 0x40);
1591                 }
1592         }
1593
1594         /* Start monitoring */
1595         w83781d_write_value(client, W83781D_REG_CONFIG,
1596                             (w83781d_read_value(client,
1597                                                 W83781D_REG_CONFIG) & 0xf7)
1598                             | 0x01);
1599 }
1600
1601 static struct w83781d_data *w83781d_update_device(struct device *dev)
1602 {
1603         struct i2c_client *client = to_i2c_client(dev);
1604         struct w83781d_data *data = i2c_get_clientdata(client);
1605         int i;
1606
1607         down(&data->update_lock);
1608
1609         if (time_after
1610             (jiffies - data->last_updated, (unsigned long) (HZ + HZ / 2))
1611             || time_before(jiffies, data->last_updated) || !data->valid) {
1612                 dev_dbg(dev, "Starting device update\n");
1613
1614                 for (i = 0; i <= 8; i++) {
1615                         if ((data->type == w83783s || data->type == w83697hf)
1616                             && (i == 1))
1617                                 continue;       /* 783S has no in1 */
1618                         data->in[i] =
1619                             w83781d_read_value(client, W83781D_REG_IN(i));
1620                         data->in_min[i] =
1621                             w83781d_read_value(client, W83781D_REG_IN_MIN(i));
1622                         data->in_max[i] =
1623                             w83781d_read_value(client, W83781D_REG_IN_MAX(i));
1624                         if ((data->type != w83782d) && (data->type != w83697hf)
1625                             && (data->type != w83627hf) && (i == 6))
1626                                 break;
1627                 }
1628                 for (i = 1; i <= 3; i++) {
1629                         data->fan[i - 1] =
1630                             w83781d_read_value(client, W83781D_REG_FAN(i));
1631                         data->fan_min[i - 1] =
1632                             w83781d_read_value(client, W83781D_REG_FAN_MIN(i));
1633                 }
1634                 if (data->type != w83781d && data->type != as99127f) {
1635                         for (i = 1; i <= 4; i++) {
1636                                 data->pwm[i - 1] =
1637                                     w83781d_read_value(client,
1638                                                        W83781D_REG_PWM(i));
1639                                 if ((data->type != w83782d
1640                                      || i2c_is_isa_client(client))
1641                                     && i == 2)
1642                                         break;
1643                         }
1644                         /* Only PWM2 can be disabled */
1645                         data->pwmenable[1] = (w83781d_read_value(client,
1646                                               W83781D_REG_PWMCLK12) & 0x08) >> 3;
1647                 }
1648
1649                 data->temp = w83781d_read_value(client, W83781D_REG_TEMP(1));
1650                 data->temp_max =
1651                     w83781d_read_value(client, W83781D_REG_TEMP_OVER(1));
1652                 data->temp_max_hyst =
1653                     w83781d_read_value(client, W83781D_REG_TEMP_HYST(1));
1654                 data->temp_add[0] =
1655                     w83781d_read_value(client, W83781D_REG_TEMP(2));
1656                 data->temp_max_add[0] =
1657                     w83781d_read_value(client, W83781D_REG_TEMP_OVER(2));
1658                 data->temp_max_hyst_add[0] =
1659                     w83781d_read_value(client, W83781D_REG_TEMP_HYST(2));
1660                 if (data->type != w83783s && data->type != w83697hf) {
1661                         data->temp_add[1] =
1662                             w83781d_read_value(client, W83781D_REG_TEMP(3));
1663                         data->temp_max_add[1] =
1664                             w83781d_read_value(client,
1665                                                W83781D_REG_TEMP_OVER(3));
1666                         data->temp_max_hyst_add[1] =
1667                             w83781d_read_value(client,
1668                                                W83781D_REG_TEMP_HYST(3));
1669                 }
1670                 i = w83781d_read_value(client, W83781D_REG_VID_FANDIV);
1671                 if (data->type != w83697hf) {
1672                         data->vid = i & 0x0f;
1673                         data->vid |=
1674                             (w83781d_read_value(client, W83781D_REG_CHIPID) &
1675                              0x01)
1676                             << 4;
1677                 }
1678                 data->fan_div[0] = (i >> 4) & 0x03;
1679                 data->fan_div[1] = (i >> 6) & 0x03;
1680                 if (data->type != w83697hf) {
1681                         data->fan_div[2] = (w83781d_read_value(client,
1682                                                                W83781D_REG_PIN)
1683                                             >> 6) & 0x03;
1684                 }
1685                 if ((data->type != w83781d) && (data->type != as99127f)) {
1686                         i = w83781d_read_value(client, W83781D_REG_VBAT);
1687                         data->fan_div[0] |= (i >> 3) & 0x04;
1688                         data->fan_div[1] |= (i >> 4) & 0x04;
1689                         if (data->type != w83697hf)
1690                                 data->fan_div[2] |= (i >> 5) & 0x04;
1691                 }
1692                 data->alarms =
1693                     w83781d_read_value(client,
1694                                        W83781D_REG_ALARM1) +
1695                     (w83781d_read_value(client, W83781D_REG_ALARM2) << 8);
1696                 if ((data->type == w83782d) || (data->type == w83627hf)) {
1697                         data->alarms |=
1698                             w83781d_read_value(client,
1699                                                W83781D_REG_ALARM3) << 16;
1700                 }
1701                 i = w83781d_read_value(client, W83781D_REG_BEEP_INTS2);
1702                 data->beep_enable = i >> 7;
1703                 data->beep_mask = ((i & 0x7f) << 8) +
1704                     w83781d_read_value(client, W83781D_REG_BEEP_INTS1);
1705                 if ((data->type != w83781d) && (data->type != as99127f)) {
1706                         data->beep_mask |=
1707                             w83781d_read_value(client,
1708                                                W83781D_REG_BEEP_INTS3) << 16;
1709                 }
1710                 data->last_updated = jiffies;
1711                 data->valid = 1;
1712         }
1713
1714         up(&data->update_lock);
1715
1716         return data;
1717 }
1718
1719 static int __init
1720 sensors_w83781d_init(void)
1721 {
1722         return i2c_add_driver(&w83781d_driver);
1723 }
1724
1725 static void __exit
1726 sensors_w83781d_exit(void)
1727 {
1728         i2c_del_driver(&w83781d_driver);
1729 }
1730
1731 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
1732               "Philip Edelbrock <phil@netroedge.com>, "
1733               "and Mark Studebaker <mdsxyz123@yahoo.com>");
1734 MODULE_DESCRIPTION("W83781D driver");
1735 MODULE_LICENSE("GPL");
1736
1737 module_init(sensors_w83781d_init);
1738 module_exit(sensors_w83781d_exit);