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

   1 /*
   2     w83791d.c - Part of lm_sensors, Linux kernel modules for hardware
   3                 monitoring
   4
   5     Copyright (C) 2006-2007 Charles Spirakis <bezaur@gmail.com>
   6
   7     This program is free software; you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License as published by
   9     the Free Software Foundation; either version 2 of the License, or
  10     (at your option) any later version.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with this program; if not, write to the Free Software
  19     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 /*
  23     Supports following chips:
  24
  25     Chip        #vin    #fanin  #pwm    #temp   wchipid vendid  i2c     ISA
  26     w83791d     10      5       5       3       0x71    0x5ca3  yes     no
  27
  28     The w83791d chip appears to be part way between the 83781d and the
  29     83792d. Thus, this file is derived from both the w83792d.c and
  30     w83781d.c files.
  31
  32     The w83791g chip is the same as the w83791d but lead-free.
  33 */
  34
  35 #include <linux/module.h>
  36 #include <linux/init.h>
  37 #include <linux/slab.h>
  38 #include <linux/i2c.h>
  39 #include <linux/hwmon.h>
  40 #include <linux/hwmon-vid.h>
  41 #include <linux/hwmon-sysfs.h>
  42 #include <linux/err.h>
  43 #include <linux/mutex.h>
  44
  45 #define NUMBER_OF_VIN           10
  46 #define NUMBER_OF_FANIN         5
  47 #define NUMBER_OF_TEMPIN        3
  48 #define NUMBER_OF_PWM           5
  49
  50 /* Addresses to scan */
  51 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f,
  52                                                 I2C_CLIENT_END };
  53
  54 /* Insmod parameters */
  55 I2C_CLIENT_INSMOD_1(w83791d);
  56
  57 static unsigned short force_subclients[4];
  58 module_param_array(force_subclients, short, NULL, 0);
  59 MODULE_PARM_DESC(force_subclients, "List of subclient addresses: "
  60                         "{bus, clientaddr, subclientaddr1, subclientaddr2}");
  61
  62 static int reset;
  63 module_param(reset, bool, 0);
  64 MODULE_PARM_DESC(reset, "Set to one to force a hardware chip reset");
  65
  66 static int init;
  67 module_param(init, bool, 0);
  68 MODULE_PARM_DESC(init, "Set to one to force extra software initialization");
  69
  70 /* The W83791D registers */
  71 static const u8 W83791D_REG_IN[NUMBER_OF_VIN] = {
  72         0x20,                   /* VCOREA in DataSheet */
  73         0x21,                   /* VINR0 in DataSheet */
  74         0x22,                   /* +3.3VIN in DataSheet */
  75         0x23,                   /* VDD5V in DataSheet */
  76         0x24,                   /* +12VIN in DataSheet */
  77         0x25,                   /* -12VIN in DataSheet */
  78         0x26,                   /* -5VIN in DataSheet */
  79         0xB0,                   /* 5VSB in DataSheet */
  80         0xB1,                   /* VBAT in DataSheet */
  81         0xB2                    /* VINR1 in DataSheet */
  82 };
  83
  84 static const u8 W83791D_REG_IN_MAX[NUMBER_OF_VIN] = {
  85         0x2B,                   /* VCOREA High Limit in DataSheet */
  86         0x2D,                   /* VINR0 High Limit in DataSheet */
  87         0x2F,                   /* +3.3VIN High Limit in DataSheet */
  88         0x31,                   /* VDD5V High Limit in DataSheet */
  89         0x33,                   /* +12VIN High Limit in DataSheet */
  90         0x35,                   /* -12VIN High Limit in DataSheet */
  91         0x37,                   /* -5VIN High Limit in DataSheet */
  92         0xB4,                   /* 5VSB High Limit in DataSheet */
  93         0xB6,                   /* VBAT High Limit in DataSheet */
  94         0xB8                    /* VINR1 High Limit in DataSheet */
  95 };
  96 static const u8 W83791D_REG_IN_MIN[NUMBER_OF_VIN] = {
  97         0x2C,                   /* VCOREA Low Limit in DataSheet */
  98         0x2E,                   /* VINR0 Low Limit in DataSheet */
  99         0x30,                   /* +3.3VIN Low Limit in DataSheet */
 100         0x32,                   /* VDD5V Low Limit in DataSheet */
 101         0x34,                   /* +12VIN Low Limit in DataSheet */
 102         0x36,                   /* -12VIN Low Limit in DataSheet */
 103         0x38,                   /* -5VIN Low Limit in DataSheet */
 104         0xB5,                   /* 5VSB Low Limit in DataSheet */
 105         0xB7,                   /* VBAT Low Limit in DataSheet */
 106         0xB9                    /* VINR1 Low Limit in DataSheet */
 107 };
 108 static const u8 W83791D_REG_FAN[NUMBER_OF_FANIN] = {
 109         0x28,                   /* FAN 1 Count in DataSheet */
 110         0x29,                   /* FAN 2 Count in DataSheet */
 111         0x2A,                   /* FAN 3 Count in DataSheet */
 112         0xBA,                   /* FAN 4 Count in DataSheet */
 113         0xBB,                   /* FAN 5 Count in DataSheet */
 114 };
 115 static const u8 W83791D_REG_FAN_MIN[NUMBER_OF_FANIN] = {
 116         0x3B,                   /* FAN 1 Count Low Limit in DataSheet */
 117         0x3C,                   /* FAN 2 Count Low Limit in DataSheet */
 118         0x3D,                   /* FAN 3 Count Low Limit in DataSheet */
 119         0xBC,                   /* FAN 4 Count Low Limit in DataSheet */
 120         0xBD,                   /* FAN 5 Count Low Limit in DataSheet */
 121 };
 122
 123 static const u8 W83791D_REG_PWM[NUMBER_OF_PWM] = {
 124         0x81,                   /* PWM 1 duty cycle register in DataSheet */
 125         0x83,                   /* PWM 2 duty cycle register in DataSheet */
 126         0x94,                   /* PWM 3 duty cycle register in DataSheet */
 127         0xA0,                   /* PWM 4 duty cycle register in DataSheet */
 128         0xA1,                   /* PWM 5 duty cycle register in DataSheet */
 129 };
 130
 131 static const u8 W83791D_REG_TEMP_TARGET[3] = {
 132         0x85,                   /* PWM 1 target temperature for temp 1 */
 133         0x86,                   /* PWM 2 target temperature for temp 2 */
 134         0x96,                   /* PWM 3 target temperature for temp 3 */
 135 };
 136
 137 static const u8 W83791D_REG_TEMP_TOL[2] = {
 138         0x87,                   /* PWM 1/2 temperature tolerance */
 139         0x97,                   /* PWM 3 temperature tolerance */
 140 };
 141
 142 static const u8 W83791D_REG_FAN_CFG[2] = {
 143         0x84,                   /* FAN 1/2 configuration */
 144         0x95,                   /* FAN 3 configuration */
 145 };
 146
 147 static const u8 W83791D_REG_FAN_DIV[3] = {
 148         0x47,                   /* contains FAN1 and FAN2 Divisor */
 149         0x4b,                   /* contains FAN3 Divisor */
 150         0x5C,                   /* contains FAN4 and FAN5 Divisor */
 151 };
 152
 153 #define W83791D_REG_BANK                0x4E
 154 #define W83791D_REG_TEMP2_CONFIG        0xC2
 155 #define W83791D_REG_TEMP3_CONFIG        0xCA
 156
 157 static const u8 W83791D_REG_TEMP1[3] = {
 158         0x27,                   /* TEMP 1 in DataSheet */
 159         0x39,                   /* TEMP 1 Over in DataSheet */
 160         0x3A,                   /* TEMP 1 Hyst in DataSheet */
 161 };
 162
 163 static const u8 W83791D_REG_TEMP_ADD[2][6] = {
 164         {0xC0,                  /* TEMP 2 in DataSheet */
 165          0xC1,                  /* TEMP 2(0.5 deg) in DataSheet */
 166          0xC5,                  /* TEMP 2 Over High part in DataSheet */
 167          0xC6,                  /* TEMP 2 Over Low part in DataSheet */
 168          0xC3,                  /* TEMP 2 Thyst High part in DataSheet */
 169          0xC4},                 /* TEMP 2 Thyst Low part in DataSheet */
 170         {0xC8,                  /* TEMP 3 in DataSheet */
 171          0xC9,                  /* TEMP 3(0.5 deg) in DataSheet */
 172          0xCD,                  /* TEMP 3 Over High part in DataSheet */
 173          0xCE,                  /* TEMP 3 Over Low part in DataSheet */
 174          0xCB,                  /* TEMP 3 Thyst High part in DataSheet */
 175          0xCC}                  /* TEMP 3 Thyst Low part in DataSheet */
 176 };
 177
 178 #define W83791D_REG_BEEP_CONFIG         0x4D
 179
 180 static const u8 W83791D_REG_BEEP_CTRL[3] = {
 181         0x56,                   /* BEEP Control Register 1 */
 182         0x57,                   /* BEEP Control Register 2 */
 183         0xA3,                   /* BEEP Control Register 3 */
 184 };
 185
 186 #define W83791D_REG_GPIO                0x15
 187 #define W83791D_REG_CONFIG              0x40
 188 #define W83791D_REG_VID_FANDIV          0x47
 189 #define W83791D_REG_DID_VID4            0x49
 190 #define W83791D_REG_WCHIPID             0x58
 191 #define W83791D_REG_CHIPMAN             0x4F
 192 #define W83791D_REG_PIN                 0x4B
 193 #define W83791D_REG_I2C_SUBADDR         0x4A
 194
 195 #define W83791D_REG_ALARM1 0xA9 /* realtime status register1 */
 196 #define W83791D_REG_ALARM2 0xAA /* realtime status register2 */
 197 #define W83791D_REG_ALARM3 0xAB /* realtime status register3 */
 198
 199 #define W83791D_REG_VBAT                0x5D
 200 #define W83791D_REG_I2C_ADDR            0x48
 201
 202 /* The SMBus locks itself. The Winbond W83791D has a bank select register
 203    (index 0x4e), but the driver only accesses registers in bank 0. Since
 204    we don't switch banks, we don't need any special code to handle
 205    locking access between bank switches */
 206 static inline int w83791d_read(struct i2c_client *client, u8 reg)
 207 {
 208         return i2c_smbus_read_byte_data(client, reg);
 209 }
 210
 211 static inline int w83791d_write(struct i2c_client *client, u8 reg, u8 value)
 212 {
 213         return i2c_smbus_write_byte_data(client, reg, value);
 214 }
 215
 216 /* The analog voltage inputs have 16mV LSB. Since the sysfs output is
 217    in mV as would be measured on the chip input pin, need to just
 218    multiply/divide by 16 to translate from/to register values. */
 219 #define IN_TO_REG(val)          (SENSORS_LIMIT((((val) + 8) / 16), 0, 255))
 220 #define IN_FROM_REG(val)        ((val) * 16)
 221
 222 static u8 fan_to_reg(long rpm, int div)
 223 {
 224         if (rpm == 0)
 225                 return 255;
 226         rpm = SENSORS_LIMIT(rpm, 1, 1000000);
 227         return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
 228 }
 229
 230 #define FAN_FROM_REG(val,div)   ((val) == 0   ? -1 : \
 231                                 ((val) == 255 ? 0 : \
 232                                         1350000 / ((val) * (div))))
 233
 234 /* for temp1 which is 8-bit resolution, LSB = 1 degree Celsius */
 235 #define TEMP1_FROM_REG(val)     ((val) * 1000)
 236 #define TEMP1_TO_REG(val)       ((val) <= -128000 ? -128 : \
 237                                  (val) >= 127000 ? 127 : \
 238                                  (val) < 0 ? ((val) - 500) / 1000 : \
 239                                  ((val) + 500) / 1000)
 240
 241 /* for temp2 and temp3 which are 9-bit resolution, LSB = 0.5 degree Celsius
 242    Assumes the top 8 bits are the integral amount and the bottom 8 bits
 243    are the fractional amount. Since we only have 0.5 degree resolution,
 244    the bottom 7 bits will always be zero */
 245 #define TEMP23_FROM_REG(val)    ((val) / 128 * 500)
 246 #define TEMP23_TO_REG(val)      ((val) <= -128000 ? 0x8000 : \
 247                                  (val) >= 127500 ? 0x7F80 : \
 248                                  (val) < 0 ? ((val) - 250) / 500 * 128 : \
 249                                  ((val) + 250) / 500 * 128)
 250
 251 /* for thermal cruise target temp, 7-bits, LSB = 1 degree Celsius */
 252 #define TARGET_TEMP_TO_REG(val)         ((val) < 0 ? 0 : \
 253                                         (val) >= 127000 ? 127 : \
 254                                         ((val) + 500) / 1000)
 255
 256 /* for thermal cruise temp tolerance, 4-bits, LSB = 1 degree Celsius */
 257 #define TOL_TEMP_TO_REG(val)            ((val) < 0 ? 0 : \
 258                                         (val) >= 15000 ? 15 : \
 259                                         ((val) + 500) / 1000)
 260
 261 #define BEEP_MASK_TO_REG(val)           ((val) & 0xffffff)
 262 #define BEEP_MASK_FROM_REG(val)         ((val) & 0xffffff)
 263
 264 #define DIV_FROM_REG(val)               (1 << (val))
 265
 266 static u8 div_to_reg(int nr, long val)
 267 {
 268         int i;
 269
 270         /* fan divisors max out at 128 */
 271         val = SENSORS_LIMIT(val, 1, 128) >> 1;
 272         for (i = 0; i < 7; i++) {
 273                 if (val == 0)
 274                         break;
 275                 val >>= 1;
 276         }
 277         return (u8) i;
 278 }
 279
 280 struct w83791d_data {
 281         struct device *hwmon_dev;
 282         struct mutex update_lock;
 283
 284         char valid;                     /* !=0 if following fields are valid */
 285         unsigned long last_updated;     /* In jiffies */
 286
 287         /* array of 2 pointers to subclients */
 288         struct i2c_client *lm75[2];
 289
 290         /* volts */
 291         u8 in[NUMBER_OF_VIN];           /* Register value */
 292         u8 in_max[NUMBER_OF_VIN];       /* Register value */
 293         u8 in_min[NUMBER_OF_VIN];       /* Register value */
 294
 295         /* fans */
 296         u8 fan[NUMBER_OF_FANIN];        /* Register value */
 297         u8 fan_min[NUMBER_OF_FANIN];    /* Register value */
 298         u8 fan_div[NUMBER_OF_FANIN];    /* Register encoding, shifted right */
 299
 300         /* Temperature sensors */
 301
 302         s8 temp1[3];            /* current, over, thyst */
 303         s16 temp_add[2][3];     /* fixed point value. Top 8 bits are the
 304                                    integral part, bottom 8 bits are the
 305                                    fractional part. We only use the top
 306                                    9 bits as the resolution is only
 307                                    to the 0.5 degree C...
 308                                    two sensors with three values
 309                                    (cur, over, hyst)  */
 310
 311         /* PWMs */
 312         u8 pwm[5];              /* pwm duty cycle */
 313         u8 pwm_enable[3];       /* pwm enable status for fan 1-3
 314                                         (fan 4-5 only support manual mode) */
 315
 316         u8 temp_target[3];      /* pwm 1-3 target temperature */
 317         u8 temp_tolerance[3];   /* pwm 1-3 temperature tolerance */
 318
 319         /* Misc */
 320         u32 alarms;             /* realtime status register encoding,combined */
 321         u8 beep_enable;         /* Global beep enable */
 322         u32 beep_mask;          /* Mask off specific beeps */
 323         u8 vid;                 /* Register encoding, combined */
 324         u8 vrm;                 /* hwmon-vid */
 325 };
 326
 327 static int w83791d_probe(struct i2c_client *client,
 328                          const struct i2c_device_id *id);
 329 static int w83791d_detect(struct i2c_client *client, int kind,
 330                           struct i2c_board_info *info);
 331 static int w83791d_remove(struct i2c_client *client);
 332
 333 static int w83791d_read(struct i2c_client *client, u8 register);
 334 static int w83791d_write(struct i2c_client *client, u8 register, u8 value);
 335 static struct w83791d_data *w83791d_update_device(struct device *dev);
 336
 337 #ifdef DEBUG
 338 static void w83791d_print_debug(struct w83791d_data *data, struct device *dev);
 339 #endif
 340
 341 static void w83791d_init_client(struct i2c_client *client);
 342
 343 static const struct i2c_device_id w83791d_id[] = {
 344         { "w83791d", w83791d },
 345         { }
 346 };
 347 MODULE_DEVICE_TABLE(i2c, w83791d_id);
 348
 349 static struct i2c_driver w83791d_driver = {
 350         .class          = I2C_CLASS_HWMON,
 351         .driver = {
 352                 .name = "w83791d",
 353         },
 354         .probe          = w83791d_probe,
 355         .remove         = w83791d_remove,
 356         .id_table       = w83791d_id,
 357         .detect         = w83791d_detect,
 358         .address_data   = &addr_data,
 359 };
 360
 361 /* following are the sysfs callback functions */
 362 #define show_in_reg(reg) \
 363 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
 364                         char *buf) \
 365 { \
 366         struct sensor_device_attribute *sensor_attr = \
 367                                                 to_sensor_dev_attr(attr); \
 368         struct w83791d_data *data = w83791d_update_device(dev); \
 369         int nr = sensor_attr->index; \
 370         return sprintf(buf,"%d\n", IN_FROM_REG(data->reg[nr])); \
 371 }
 372
 373 show_in_reg(in);
 374 show_in_reg(in_min);
 375 show_in_reg(in_max);
 376
 377 #define store_in_reg(REG, reg) \
 378 static ssize_t store_in_##reg(struct device *dev, \
 379                                 struct device_attribute *attr, \
 380                                 const char *buf, size_t count) \
 381 { \
 382         struct sensor_device_attribute *sensor_attr = \
 383                                                 to_sensor_dev_attr(attr); \
 384         struct i2c_client *client = to_i2c_client(dev); \
 385         struct w83791d_data *data = i2c_get_clientdata(client); \
 386         unsigned long val = simple_strtoul(buf, NULL, 10); \
 387         int nr = sensor_attr->index; \
 388          \
 389         mutex_lock(&data->update_lock); \
 390         data->in_##reg[nr] = IN_TO_REG(val); \
 391         w83791d_write(client, W83791D_REG_IN_##REG[nr], data->in_##reg[nr]); \
 392         mutex_unlock(&data->update_lock); \
 393          \
 394         return count; \
 395 }
 396 store_in_reg(MIN, min);
 397 store_in_reg(MAX, max);
 398
 399 static struct sensor_device_attribute sda_in_input[] = {
 400         SENSOR_ATTR(in0_input, S_IRUGO, show_in, NULL, 0),
 401         SENSOR_ATTR(in1_input, S_IRUGO, show_in, NULL, 1),
 402         SENSOR_ATTR(in2_input, S_IRUGO, show_in, NULL, 2),
 403         SENSOR_ATTR(in3_input, S_IRUGO, show_in, NULL, 3),
 404         SENSOR_ATTR(in4_input, S_IRUGO, show_in, NULL, 4),
 405         SENSOR_ATTR(in5_input, S_IRUGO, show_in, NULL, 5),
 406         SENSOR_ATTR(in6_input, S_IRUGO, show_in, NULL, 6),
 407         SENSOR_ATTR(in7_input, S_IRUGO, show_in, NULL, 7),
 408         SENSOR_ATTR(in8_input, S_IRUGO, show_in, NULL, 8),
 409         SENSOR_ATTR(in9_input, S_IRUGO, show_in, NULL, 9),
 410 };
 411
 412 static struct sensor_device_attribute sda_in_min[] = {
 413         SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 0),
 414         SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 1),
 415         SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 2),
 416         SENSOR_ATTR(in3_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 3),
 417         SENSOR_ATTR(in4_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 4),
 418         SENSOR_ATTR(in5_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 5),
 419         SENSOR_ATTR(in6_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 6),
 420         SENSOR_ATTR(in7_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 7),
 421         SENSOR_ATTR(in8_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 8),
 422         SENSOR_ATTR(in9_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 9),
 423 };
 424
 425 static struct sensor_device_attribute sda_in_max[] = {
 426         SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 0),
 427         SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 1),
 428         SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 2),
 429         SENSOR_ATTR(in3_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 3),
 430         SENSOR_ATTR(in4_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 4),
 431         SENSOR_ATTR(in5_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 5),
 432         SENSOR_ATTR(in6_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 6),
 433         SENSOR_ATTR(in7_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 7),
 434         SENSOR_ATTR(in8_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 8),
 435         SENSOR_ATTR(in9_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 9),
 436 };
 437
 438
 439 static ssize_t show_beep(struct device *dev, struct device_attribute *attr,
 440                         char *buf)
 441 {
 442         struct sensor_device_attribute *sensor_attr =
 443                                                 to_sensor_dev_attr(attr);
 444         struct w83791d_data *data = w83791d_update_device(dev);
 445         int bitnr = sensor_attr->index;
 446
 447         return sprintf(buf, "%d\n", (data->beep_mask >> bitnr) & 1);
 448 }
 449
 450 static ssize_t store_beep(struct device *dev, struct device_attribute *attr,
 451                         const char *buf, size_t count)
 452 {
 453         struct sensor_device_attribute *sensor_attr =
 454                                                 to_sensor_dev_attr(attr);
 455         struct i2c_client *client = to_i2c_client(dev);
 456         struct w83791d_data *data = i2c_get_clientdata(client);
 457         int bitnr = sensor_attr->index;
 458         int bytenr = bitnr / 8;
 459         long val = simple_strtol(buf, NULL, 10) ? 1 : 0;
 460
 461         mutex_lock(&data->update_lock);
 462
 463         data->beep_mask &= ~(0xff << (bytenr * 8));
 464         data->beep_mask |= w83791d_read(client, W83791D_REG_BEEP_CTRL[bytenr])
 465                 << (bytenr * 8);
 466
 467         data->beep_mask &= ~(1 << bitnr);
 468         data->beep_mask |= val << bitnr;
 469
 470         w83791d_write(client, W83791D_REG_BEEP_CTRL[bytenr],
 471                 (data->beep_mask >> (bytenr * 8)) & 0xff);
 472
 473         mutex_unlock(&data->update_lock);
 474
 475         return count;
 476 }
 477
 478 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
 479                         char *buf)
 480 {
 481         struct sensor_device_attribute *sensor_attr =
 482                                                 to_sensor_dev_attr(attr);
 483         struct w83791d_data *data = w83791d_update_device(dev);
 484         int bitnr = sensor_attr->index;
 485
 486         return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1);
 487 }
 488
 489 /* Note: The bitmask for the beep enable/disable is different than
 490    the bitmask for the alarm. */
 491 static struct sensor_device_attribute sda_in_beep[] = {
 492         SENSOR_ATTR(in0_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 0),
 493         SENSOR_ATTR(in1_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 13),
 494         SENSOR_ATTR(in2_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 2),
 495         SENSOR_ATTR(in3_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 3),
 496         SENSOR_ATTR(in4_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 8),
 497         SENSOR_ATTR(in5_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 9),
 498         SENSOR_ATTR(in6_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 10),
 499         SENSOR_ATTR(in7_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 16),
 500         SENSOR_ATTR(in8_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 17),
 501         SENSOR_ATTR(in9_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 14),
 502 };
 503
 504 static struct sensor_device_attribute sda_in_alarm[] = {
 505         SENSOR_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0),
 506         SENSOR_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1),
 507         SENSOR_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2),
 508         SENSOR_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3),
 509         SENSOR_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8),
 510         SENSOR_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9),
 511         SENSOR_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 10),
 512         SENSOR_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 19),
 513         SENSOR_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 20),
 514         SENSOR_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL, 14),
 515 };
 516
 517 #define show_fan_reg(reg) \
 518 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
 519                                 char *buf) \
 520 { \
 521         struct sensor_device_attribute *sensor_attr = \
 522                                                 to_sensor_dev_attr(attr); \
 523         struct w83791d_data *data = w83791d_update_device(dev); \
 524         int nr = sensor_attr->index; \
 525         return sprintf(buf,"%d\n", \
 526                 FAN_FROM_REG(data->reg[nr], DIV_FROM_REG(data->fan_div[nr]))); \
 527 }
 528
 529 show_fan_reg(fan);
 530 show_fan_reg(fan_min);
 531
 532 static ssize_t store_fan_min(struct device *dev, struct device_attribute *attr,
 533                                 const char *buf, size_t count)
 534 {
 535         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 536         struct i2c_client *client = to_i2c_client(dev);
 537         struct w83791d_data *data = i2c_get_clientdata(client);
 538         unsigned long val = simple_strtoul(buf, NULL, 10);
 539         int nr = sensor_attr->index;
 540
 541         mutex_lock(&data->update_lock);
 542         data->fan_min[nr] = fan_to_reg(val, DIV_FROM_REG(data->fan_div[nr]));
 543         w83791d_write(client, W83791D_REG_FAN_MIN[nr], data->fan_min[nr]);
 544         mutex_unlock(&data->update_lock);
 545
 546         return count;
 547 }
 548
 549 static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr,
 550                                 char *buf)
 551 {
 552         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 553         int nr = sensor_attr->index;
 554         struct w83791d_data *data = w83791d_update_device(dev);
 555         return sprintf(buf, "%u\n", DIV_FROM_REG(data->fan_div[nr]));
 556 }
 557
 558 /* Note: we save and restore the fan minimum here, because its value is
 559    determined in part by the fan divisor.  This follows the principle of
 560    least suprise; the user doesn't expect the fan minimum to change just
 561    because the divisor changed. */
 562 static ssize_t store_fan_div(struct device *dev, struct device_attribute *attr,
 563                                 const char *buf, size_t count)
 564 {
 565         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 566         struct i2c_client *client = to_i2c_client(dev);
 567         struct w83791d_data *data = i2c_get_clientdata(client);
 568         int nr = sensor_attr->index;
 569         unsigned long min;
 570         u8 tmp_fan_div;
 571         u8 fan_div_reg;
 572         u8 vbat_reg;
 573         int indx = 0;
 574         u8 keep_mask = 0;
 575         u8 new_shift = 0;
 576
 577         /* Save fan_min */
 578         min = FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr]));
 579
 580         mutex_lock(&data->update_lock);
 581         data->fan_div[nr] = div_to_reg(nr, simple_strtoul(buf, NULL, 10));
 582
 583         switch (nr) {
 584         case 0:
 585                 indx = 0;
 586                 keep_mask = 0xcf;
 587                 new_shift = 4;
 588                 break;
 589         case 1:
 590                 indx = 0;
 591                 keep_mask = 0x3f;
 592                 new_shift = 6;
 593                 break;
 594         case 2:
 595                 indx = 1;
 596                 keep_mask = 0x3f;
 597                 new_shift = 6;
 598                 break;
 599         case 3:
 600                 indx = 2;
 601                 keep_mask = 0xf8;
 602                 new_shift = 0;
 603                 break;
 604         case 4:
 605                 indx = 2;
 606                 keep_mask = 0x8f;
 607                 new_shift = 4;
 608                 break;
 609 #ifdef DEBUG
 610         default:
 611                 dev_warn(dev, "store_fan_div: Unexpected nr seen: %d\n", nr);
 612                 count = -EINVAL;
 613                 goto err_exit;
 614 #endif
 615         }
 616
 617         fan_div_reg = w83791d_read(client, W83791D_REG_FAN_DIV[indx])
 618                         & keep_mask;
 619         tmp_fan_div = (data->fan_div[nr] << new_shift) & ~keep_mask;
 620
 621         w83791d_write(client, W83791D_REG_FAN_DIV[indx],
 622                                 fan_div_reg | tmp_fan_div);
 623
 624         /* Bit 2 of fans 0-2 is stored in the vbat register (bits 5-7) */
 625         if (nr < 3) {
 626                 keep_mask = ~(1 << (nr + 5));
 627                 vbat_reg = w83791d_read(client, W83791D_REG_VBAT)
 628                                 & keep_mask;
 629                 tmp_fan_div = (data->fan_div[nr] << (3 + nr)) & ~keep_mask;
 630                 w83791d_write(client, W83791D_REG_VBAT,
 631                                 vbat_reg | tmp_fan_div);
 632         }
 633
 634         /* Restore fan_min */
 635         data->fan_min[nr] = fan_to_reg(min, DIV_FROM_REG(data->fan_div[nr]));
 636         w83791d_write(client, W83791D_REG_FAN_MIN[nr], data->fan_min[nr]);
 637
 638 #ifdef DEBUG
 639 err_exit:
 640 #endif
 641         mutex_unlock(&data->update_lock);
 642
 643         return count;
 644 }
 645
 646 static struct sensor_device_attribute sda_fan_input[] = {
 647         SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0),
 648         SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1),
 649         SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2),
 650         SENSOR_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3),
 651         SENSOR_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4),
 652 };
 653
 654 static struct sensor_device_attribute sda_fan_min[] = {
 655         SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO,
 656                         show_fan_min, store_fan_min, 0),
 657         SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO,
 658                         show_fan_min, store_fan_min, 1),
 659         SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO,
 660                         show_fan_min, store_fan_min, 2),
 661         SENSOR_ATTR(fan4_min, S_IWUSR | S_IRUGO,
 662                         show_fan_min, store_fan_min, 3),
 663         SENSOR_ATTR(fan5_min, S_IWUSR | S_IRUGO,
 664                         show_fan_min, store_fan_min, 4),
 665 };
 666
 667 static struct sensor_device_attribute sda_fan_div[] = {
 668         SENSOR_ATTR(fan1_div, S_IWUSR | S_IRUGO,
 669                         show_fan_div, store_fan_div, 0),
 670         SENSOR_ATTR(fan2_div, S_IWUSR | S_IRUGO,
 671                         show_fan_div, store_fan_div, 1),
 672         SENSOR_ATTR(fan3_div, S_IWUSR | S_IRUGO,
 673                         show_fan_div, store_fan_div, 2),
 674         SENSOR_ATTR(fan4_div, S_IWUSR | S_IRUGO,
 675                         show_fan_div, store_fan_div, 3),
 676         SENSOR_ATTR(fan5_div, S_IWUSR | S_IRUGO,
 677                         show_fan_div, store_fan_div, 4),
 678 };
 679
 680 static struct sensor_device_attribute sda_fan_beep[] = {
 681         SENSOR_ATTR(fan1_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 6),
 682         SENSOR_ATTR(fan2_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 7),
 683         SENSOR_ATTR(fan3_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 11),
 684         SENSOR_ATTR(fan4_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 21),
 685         SENSOR_ATTR(fan5_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 22),
 686 };
 687
 688 static struct sensor_device_attribute sda_fan_alarm[] = {
 689         SENSOR_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6),
 690         SENSOR_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7),
 691         SENSOR_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11),
 692         SENSOR_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 21),
 693         SENSOR_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 22),
 694 };
 695
 696 /* read/write PWMs */
 697 static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
 698                                 char *buf)
 699 {
 700         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 701         int nr = sensor_attr->index;
 702         struct w83791d_data *data = w83791d_update_device(dev);
 703         return sprintf(buf, "%u\n", data->pwm[nr]);
 704 }
 705
 706 static ssize_t store_pwm(struct device *dev, struct device_attribute *attr,
 707                 const char *buf, size_t count)
 708 {
 709         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 710         struct i2c_client *client = to_i2c_client(dev);
 711         struct w83791d_data *data = i2c_get_clientdata(client);
 712         int nr = sensor_attr->index;
 713         unsigned long val;
 714
 715         if (strict_strtoul(buf, 10, &val))
 716                 return -EINVAL;
 717
 718         mutex_lock(&data->update_lock);
 719         data->pwm[nr] = SENSORS_LIMIT(val, 0, 255);
 720         w83791d_write(client, W83791D_REG_PWM[nr], data->pwm[nr]);
 721         mutex_unlock(&data->update_lock);
 722         return count;
 723 }
 724
 725 static struct sensor_device_attribute sda_pwm[] = {
 726         SENSOR_ATTR(pwm1, S_IWUSR | S_IRUGO,
 727                         show_pwm, store_pwm, 0),
 728         SENSOR_ATTR(pwm2, S_IWUSR | S_IRUGO,
 729                         show_pwm, store_pwm, 1),
 730         SENSOR_ATTR(pwm3, S_IWUSR | S_IRUGO,
 731                         show_pwm, store_pwm, 2),
 732         SENSOR_ATTR(pwm4, S_IWUSR | S_IRUGO,
 733                         show_pwm, store_pwm, 3),
 734         SENSOR_ATTR(pwm5, S_IWUSR | S_IRUGO,
 735                         show_pwm, store_pwm, 4),
 736 };
 737
 738 static ssize_t show_pwmenable(struct device *dev, struct device_attribute *attr,
 739                                 char *buf)
 740 {
 741         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 742         int nr = sensor_attr->index;
 743         struct w83791d_data *data = w83791d_update_device(dev);
 744         return sprintf(buf, "%u\n", data->pwm_enable[nr] + 1);
 745 }
 746
 747 static ssize_t store_pwmenable(struct device *dev,
 748                 struct device_attribute *attr, const char *buf, size_t count)
 749 {
 750         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 751         struct i2c_client *client = to_i2c_client(dev);
 752         struct w83791d_data *data = i2c_get_clientdata(client);
 753         int nr = sensor_attr->index;
 754         unsigned long val;
 755         u8 reg_cfg_tmp;
 756         u8 reg_idx = 0;
 757         u8 val_shift = 0;
 758         u8 keep_mask = 0;
 759
 760         int ret = strict_strtoul(buf, 10, &val);
 761
 762         if (ret || val < 1 || val > 3)
 763                 return -EINVAL;
 764
 765         mutex_lock(&data->update_lock);
 766         data->pwm_enable[nr] = val - 1;
 767         switch (nr) {
 768         case 0:
 769                 reg_idx = 0;
 770                 val_shift = 2;
 771                 keep_mask = 0xf3;
 772                 break;
 773         case 1:
 774                 reg_idx = 0;
 775                 val_shift = 4;
 776                 keep_mask = 0xcf;
 777                 break;
 778         case 2:
 779                 reg_idx = 1;
 780                 val_shift = 2;
 781                 keep_mask = 0xf3;
 782                 break;
 783         }
 784
 785         reg_cfg_tmp = w83791d_read(client, W83791D_REG_FAN_CFG[reg_idx]);
 786         reg_cfg_tmp = (reg_cfg_tmp & keep_mask) |
 787                                         data->pwm_enable[nr] << val_shift;
 788
 789         w83791d_write(client, W83791D_REG_FAN_CFG[reg_idx], reg_cfg_tmp);
 790         mutex_unlock(&data->update_lock);
 791
 792         return count;
 793 }
 794 static struct sensor_device_attribute sda_pwmenable[] = {
 795         SENSOR_ATTR(pwm1_enable, S_IWUSR | S_IRUGO,
 796                         show_pwmenable, store_pwmenable, 0),
 797         SENSOR_ATTR(pwm2_enable, S_IWUSR | S_IRUGO,
 798                         show_pwmenable, store_pwmenable, 1),
 799         SENSOR_ATTR(pwm3_enable, S_IWUSR | S_IRUGO,
 800                         show_pwmenable, store_pwmenable, 2),
 801 };
 802
 803 /* For Smart Fan I / Thermal Cruise */
 804 static ssize_t show_temp_target(struct device *dev,
 805                         struct device_attribute *attr, char *buf)
 806 {
 807         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 808         struct w83791d_data *data = w83791d_update_device(dev);
 809         int nr = sensor_attr->index;
 810         return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp_target[nr]));
 811 }
 812
 813 static ssize_t store_temp_target(struct device *dev,
 814                 struct device_attribute *attr, const char *buf, size_t count)
 815 {
 816         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 817         struct i2c_client *client = to_i2c_client(dev);
 818         struct w83791d_data *data = i2c_get_clientdata(client);
 819         int nr = sensor_attr->index;
 820         unsigned long val;
 821         u8 target_mask;
 822
 823         if (strict_strtoul(buf, 10, &val))
 824                 return -EINVAL;
 825
 826         mutex_lock(&data->update_lock);
 827         data->temp_target[nr] = TARGET_TEMP_TO_REG(val);
 828         target_mask = w83791d_read(client,
 829                                 W83791D_REG_TEMP_TARGET[nr]) & 0x80;
 830         w83791d_write(client, W83791D_REG_TEMP_TARGET[nr],
 831                                 data->temp_target[nr] | target_mask);
 832         mutex_unlock(&data->update_lock);
 833         return count;
 834 }
 835
 836 static struct sensor_device_attribute sda_temp_target[] = {
 837         SENSOR_ATTR(temp1_target, S_IWUSR | S_IRUGO,
 838                         show_temp_target, store_temp_target, 0),
 839         SENSOR_ATTR(temp2_target, S_IWUSR | S_IRUGO,
 840                         show_temp_target, store_temp_target, 1),
 841         SENSOR_ATTR(temp3_target, S_IWUSR | S_IRUGO,
 842                         show_temp_target, store_temp_target, 2),
 843 };
 844
 845 static ssize_t show_temp_tolerance(struct device *dev,
 846                         struct device_attribute *attr, char *buf)
 847 {
 848         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 849         struct w83791d_data *data = w83791d_update_device(dev);
 850         int nr = sensor_attr->index;
 851         return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp_tolerance[nr]));
 852 }
 853
 854 static ssize_t store_temp_tolerance(struct device *dev,
 855                 struct device_attribute *attr, const char *buf, size_t count)
 856 {
 857         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 858         struct i2c_client *client = to_i2c_client(dev);
 859         struct w83791d_data *data = i2c_get_clientdata(client);
 860         int nr = sensor_attr->index;
 861         unsigned long val;
 862         u8 target_mask;
 863         u8 reg_idx = 0;
 864         u8 val_shift = 0;
 865         u8 keep_mask = 0;
 866
 867         if (strict_strtoul(buf, 10, &val))
 868                 return -EINVAL;
 869
 870         switch (nr) {
 871         case 0:
 872                 reg_idx = 0;
 873                 val_shift = 0;
 874                 keep_mask = 0xf0;
 875                 break;
 876         case 1:
 877                 reg_idx = 0;
 878                 val_shift = 4;
 879                 keep_mask = 0x0f;
 880                 break;
 881         case 2:
 882                 reg_idx = 1;
 883                 val_shift = 0;
 884                 keep_mask = 0xf0;
 885                 break;
 886         }
 887
 888         mutex_lock(&data->update_lock);
 889         data->temp_tolerance[nr] = TOL_TEMP_TO_REG(val);
 890         target_mask = w83791d_read(client,
 891                         W83791D_REG_TEMP_TOL[reg_idx]) & keep_mask;
 892         w83791d_write(client, W83791D_REG_TEMP_TOL[reg_idx],
 893                         (data->temp_tolerance[nr] << val_shift) | target_mask);
 894         mutex_unlock(&data->update_lock);
 895         return count;
 896 }
 897
 898 static struct sensor_device_attribute sda_temp_tolerance[] = {
 899         SENSOR_ATTR(temp1_tolerance, S_IWUSR | S_IRUGO,
 900                         show_temp_tolerance, store_temp_tolerance, 0),
 901         SENSOR_ATTR(temp2_tolerance, S_IWUSR | S_IRUGO,
 902                         show_temp_tolerance, store_temp_tolerance, 1),
 903         SENSOR_ATTR(temp3_tolerance, S_IWUSR | S_IRUGO,
 904                         show_temp_tolerance, store_temp_tolerance, 2),
 905 };
 906
 907 /* read/write the temperature1, includes measured value and limits */
 908 static ssize_t show_temp1(struct device *dev, struct device_attribute *devattr,
 909                                 char *buf)
 910 {
 911         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 912         struct w83791d_data *data = w83791d_update_device(dev);
 913         return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp1[attr->index]));
 914 }
 915
 916 static ssize_t store_temp1(struct device *dev, struct device_attribute *devattr,
 917                                 const char *buf, size_t count)
 918 {
 919         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 920         struct i2c_client *client = to_i2c_client(dev);
 921         struct w83791d_data *data = i2c_get_clientdata(client);
 922         long val = simple_strtol(buf, NULL, 10);
 923         int nr = attr->index;
 924
 925         mutex_lock(&data->update_lock);
 926         data->temp1[nr] = TEMP1_TO_REG(val);
 927         w83791d_write(client, W83791D_REG_TEMP1[nr], data->temp1[nr]);
 928         mutex_unlock(&data->update_lock);
 929         return count;
 930 }
 931
 932 /* read/write temperature2-3, includes measured value and limits */
 933 static ssize_t show_temp23(struct device *dev, struct device_attribute *devattr,
 934                                 char *buf)
 935 {
 936         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 937         struct w83791d_data *data = w83791d_update_device(dev);
 938         int nr = attr->nr;
 939         int index = attr->index;
 940         return sprintf(buf, "%d\n", TEMP23_FROM_REG(data->temp_add[nr][index]));
 941 }
 942
 943 static ssize_t store_temp23(struct device *dev,
 944                                 struct device_attribute *devattr,
 945                                 const char *buf, size_t count)
 946 {
 947         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 948         struct i2c_client *client = to_i2c_client(dev);
 949         struct w83791d_data *data = i2c_get_clientdata(client);
 950         long val = simple_strtol(buf, NULL, 10);
 951         int nr = attr->nr;
 952         int index = attr->index;
 953
 954         mutex_lock(&data->update_lock);
 955         data->temp_add[nr][index] = TEMP23_TO_REG(val);
 956         w83791d_write(client, W83791D_REG_TEMP_ADD[nr][index * 2],
 957                                 data->temp_add[nr][index] >> 8);
 958         w83791d_write(client, W83791D_REG_TEMP_ADD[nr][index * 2 + 1],
 959                                 data->temp_add[nr][index] & 0x80);
 960         mutex_unlock(&data->update_lock);
 961
 962         return count;
 963 }
 964
 965 static struct sensor_device_attribute_2 sda_temp_input[] = {
 966         SENSOR_ATTR_2(temp1_input, S_IRUGO, show_temp1, NULL, 0, 0),
 967         SENSOR_ATTR_2(temp2_input, S_IRUGO, show_temp23, NULL, 0, 0),
 968         SENSOR_ATTR_2(temp3_input, S_IRUGO, show_temp23, NULL, 1, 0),
 969 };
 970
 971 static struct sensor_device_attribute_2 sda_temp_max[] = {
 972         SENSOR_ATTR_2(temp1_max, S_IRUGO | S_IWUSR,
 973                         show_temp1, store_temp1, 0, 1),
 974         SENSOR_ATTR_2(temp2_max, S_IRUGO | S_IWUSR,
 975                         show_temp23, store_temp23, 0, 1),
 976         SENSOR_ATTR_2(temp3_max, S_IRUGO | S_IWUSR,
 977                         show_temp23, store_temp23, 1, 1),
 978 };
 979
 980 static struct sensor_device_attribute_2 sda_temp_max_hyst[] = {
 981         SENSOR_ATTR_2(temp1_max_hyst, S_IRUGO | S_IWUSR,
 982                         show_temp1, store_temp1, 0, 2),
 983         SENSOR_ATTR_2(temp2_max_hyst, S_IRUGO | S_IWUSR,
 984                         show_temp23, store_temp23, 0, 2),
 985         SENSOR_ATTR_2(temp3_max_hyst, S_IRUGO | S_IWUSR,
 986                         show_temp23, store_temp23, 1, 2),
 987 };
 988
 989 /* Note: The bitmask for the beep enable/disable is different than
 990    the bitmask for the alarm. */
 991 static struct sensor_device_attribute sda_temp_beep[] = {
 992         SENSOR_ATTR(temp1_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 4),
 993         SENSOR_ATTR(temp2_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 5),
 994         SENSOR_ATTR(temp3_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 1),
 995 };
 996
 997 static struct sensor_device_attribute sda_temp_alarm[] = {
 998         SENSOR_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4),
 999         SENSOR_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5),
1000         SENSOR_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13),
1001 };
1002
1003 /* get reatime status of all sensors items: voltage, temp, fan */
1004 static ssize_t show_alarms_reg(struct device *dev,
1005                                 struct device_attribute *attr, char *buf)
1006 {
1007         struct w83791d_data *data = w83791d_update_device(dev);
1008         return sprintf(buf, "%u\n", data->alarms);
1009 }
1010
1011 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
1012
1013 /* Beep control */
1014
1015 #define GLOBAL_BEEP_ENABLE_SHIFT        15
1016 #define GLOBAL_BEEP_ENABLE_MASK         (1 << GLOBAL_BEEP_ENABLE_SHIFT)
1017
1018 static ssize_t show_beep_enable(struct device *dev,
1019                                 struct device_attribute *attr, char *buf)
1020 {
1021         struct w83791d_data *data = w83791d_update_device(dev);
1022         return sprintf(buf, "%d\n", data->beep_enable);
1023 }
1024
1025 static ssize_t show_beep_mask(struct device *dev,
1026                                 struct device_attribute *attr, char *buf)
1027 {
1028         struct w83791d_data *data = w83791d_update_device(dev);
1029         return sprintf(buf, "%d\n", BEEP_MASK_FROM_REG(data->beep_mask));
1030 }
1031
1032
1033 static ssize_t store_beep_mask(struct device *dev,
1034                                 struct device_attribute *attr,
1035                                 const char *buf, size_t count)
1036 {
1037         struct i2c_client *client = to_i2c_client(dev);
1038         struct w83791d_data *data = i2c_get_clientdata(client);
1039         long val = simple_strtol(buf, NULL, 10);
1040         int i;
1041
1042         mutex_lock(&data->update_lock);
1043
1044         /* The beep_enable state overrides any enabling request from
1045            the masks */
1046         data->beep_mask = BEEP_MASK_TO_REG(val) & ~GLOBAL_BEEP_ENABLE_MASK;
1047         data->beep_mask |= (data->beep_enable << GLOBAL_BEEP_ENABLE_SHIFT);
1048
1049         val = data->beep_mask;
1050
1051         for (i = 0; i < 3; i++) {
1052                 w83791d_write(client, W83791D_REG_BEEP_CTRL[i], (val & 0xff));
1053                 val >>= 8;
1054         }
1055
1056         mutex_unlock(&data->update_lock);
1057
1058         return count;
1059 }
1060
1061 static ssize_t store_beep_enable(struct device *dev,
1062                                 struct device_attribute *attr,
1063                                 const char *buf, size_t count)
1064 {
1065         struct i2c_client *client = to_i2c_client(dev);
1066         struct w83791d_data *data = i2c_get_clientdata(client);
1067         long val = simple_strtol(buf, NULL, 10);
1068
1069         mutex_lock(&data->update_lock);
1070
1071         data->beep_enable = val ? 1 : 0;
1072
1073         /* Keep the full mask value in sync with the current enable */
1074         data->beep_mask &= ~GLOBAL_BEEP_ENABLE_MASK;
1075         data->beep_mask |= (data->beep_enable << GLOBAL_BEEP_ENABLE_SHIFT);
1076
1077         /* The global control is in the second beep control register
1078            so only need to update that register */
1079         val = (data->beep_mask >> 8) & 0xff;
1080
1081         w83791d_write(client, W83791D_REG_BEEP_CTRL[1], val);
1082
1083         mutex_unlock(&data->update_lock);
1084
1085         return count;
1086 }
1087
1088 static struct sensor_device_attribute sda_beep_ctrl[] = {
1089         SENSOR_ATTR(beep_enable, S_IRUGO | S_IWUSR,
1090                         show_beep_enable, store_beep_enable, 0),
1091         SENSOR_ATTR(beep_mask, S_IRUGO | S_IWUSR,
1092                         show_beep_mask, store_beep_mask, 1)
1093 };
1094
1095 /* cpu voltage regulation information */
1096 static ssize_t show_vid_reg(struct device *dev,
1097                                 struct device_attribute *attr, char *buf)
1098 {
1099         struct w83791d_data *data = w83791d_update_device(dev);
1100         return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
1101 }
1102
1103 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
1104
1105 static ssize_t show_vrm_reg(struct device *dev,
1106                                 struct device_attribute *attr, char *buf)
1107 {
1108         struct w83791d_data *data = dev_get_drvdata(dev);
1109         return sprintf(buf, "%d\n", data->vrm);
1110 }
1111
1112 static ssize_t store_vrm_reg(struct device *dev,
1113                                 struct device_attribute *attr,
1114                                 const char *buf, size_t count)
1115 {
1116         struct w83791d_data *data = dev_get_drvdata(dev);
1117
1118         /* No lock needed as vrm is internal to the driver
1119            (not read from a chip register) and so is not
1120            updated in w83791d_update_device() */
1121         data->vrm = simple_strtoul(buf, NULL, 10);
1122
1123         return count;
1124 }
1125
1126 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
1127
1128 #define IN_UNIT_ATTRS(X) \
1129         &sda_in_input[X].dev_attr.attr, \
1130         &sda_in_min[X].dev_attr.attr,   \
1131         &sda_in_max[X].dev_attr.attr,   \
1132         &sda_in_beep[X].dev_attr.attr,  \
1133         &sda_in_alarm[X].dev_attr.attr
1134
1135 #define FAN_UNIT_ATTRS(X) \
1136         &sda_fan_input[X].dev_attr.attr,        \
1137         &sda_fan_min[X].dev_attr.attr,          \
1138         &sda_fan_div[X].dev_attr.attr,          \
1139         &sda_fan_beep[X].dev_attr.attr,         \
1140         &sda_fan_alarm[X].dev_attr.attr
1141
1142 #define TEMP_UNIT_ATTRS(X) \
1143         &sda_temp_input[X].dev_attr.attr,       \
1144         &sda_temp_max[X].dev_attr.attr,         \
1145         &sda_temp_max_hyst[X].dev_attr.attr,    \
1146         &sda_temp_beep[X].dev_attr.attr,        \
1147         &sda_temp_alarm[X].dev_attr.attr
1148
1149 static struct attribute *w83791d_attributes[] = {
1150         IN_UNIT_ATTRS(0),
1151         IN_UNIT_ATTRS(1),
1152         IN_UNIT_ATTRS(2),
1153         IN_UNIT_ATTRS(3),
1154         IN_UNIT_ATTRS(4),
1155         IN_UNIT_ATTRS(5),
1156         IN_UNIT_ATTRS(6),
1157         IN_UNIT_ATTRS(7),
1158         IN_UNIT_ATTRS(8),
1159         IN_UNIT_ATTRS(9),
1160         FAN_UNIT_ATTRS(0),
1161         FAN_UNIT_ATTRS(1),
1162         FAN_UNIT_ATTRS(2),
1163         TEMP_UNIT_ATTRS(0),
1164         TEMP_UNIT_ATTRS(1),
1165         TEMP_UNIT_ATTRS(2),
1166         &dev_attr_alarms.attr,
1167         &sda_beep_ctrl[0].dev_attr.attr,
1168         &sda_beep_ctrl[1].dev_attr.attr,
1169         &dev_attr_cpu0_vid.attr,
1170         &dev_attr_vrm.attr,
1171         &sda_pwm[0].dev_attr.attr,
1172         &sda_pwm[1].dev_attr.attr,
1173         &sda_pwm[2].dev_attr.attr,
1174         &sda_pwmenable[0].dev_attr.attr,
1175         &sda_pwmenable[1].dev_attr.attr,
1176         &sda_pwmenable[2].dev_attr.attr,
1177         &sda_temp_target[0].dev_attr.attr,
1178         &sda_temp_target[1].dev_attr.attr,
1179         &sda_temp_target[2].dev_attr.attr,
1180         &sda_temp_tolerance[0].dev_attr.attr,
1181         &sda_temp_tolerance[1].dev_attr.attr,
1182         &sda_temp_tolerance[2].dev_attr.attr,
1183         NULL
1184 };
1185
1186 static const struct attribute_group w83791d_group = {
1187         .attrs = w83791d_attributes,
1188 };
1189
1190 /* Separate group of attributes for fan/pwm 4-5. Their pins can also be
1191    in use for GPIO in which case their sysfs-interface should not be made
1192    available */
1193 static struct attribute *w83791d_attributes_fanpwm45[] = {
1194         FAN_UNIT_ATTRS(3),
1195         FAN_UNIT_ATTRS(4),
1196         &sda_pwm[3].dev_attr.attr,
1197         &sda_pwm[4].dev_attr.attr,
1198         NULL
1199 };
1200
1201 static const struct attribute_group w83791d_group_fanpwm45 = {
1202         .attrs = w83791d_attributes_fanpwm45,
1203 };
1204
1205 static int w83791d_detect_subclients(struct i2c_client *client)
1206 {
1207         struct i2c_adapter *adapter = client->adapter;
1208         struct w83791d_data *data = i2c_get_clientdata(client);
1209         int address = client->addr;
1210         int i, id, err;
1211         u8 val;
1212
1213         id = i2c_adapter_id(adapter);
1214         if (force_subclients[0] == id && force_subclients[1] == address) {
1215                 for (i = 2; i <= 3; i++) {
1216                         if (force_subclients[i] < 0x48 ||
1217                             force_subclients[i] > 0x4f) {
1218                                 dev_err(&client->dev,
1219                                         "invalid subclient "
1220                                         "address %d; must be 0x48-0x4f\n",
1221                                         force_subclients[i]);
1222                                 err = -ENODEV;
1223                                 goto error_sc_0;
1224                         }
1225                 }
1226                 w83791d_write(client, W83791D_REG_I2C_SUBADDR,
1227                                         (force_subclients[2] & 0x07) |
1228                                         ((force_subclients[3] & 0x07) << 4));
1229         }
1230
1231         val = w83791d_read(client, W83791D_REG_I2C_SUBADDR);
1232         if (!(val & 0x08)) {
1233                 data->lm75[0] = i2c_new_dummy(adapter, 0x48 + (val & 0x7));
1234         }
1235         if (!(val & 0x80)) {
1236                 if ((data->lm75[0] != NULL) &&
1237                                 ((val & 0x7) == ((val >> 4) & 0x7))) {
1238                         dev_err(&client->dev,
1239                                 "duplicate addresses 0x%x, "
1240                                 "use force_subclient\n",
1241                                 data->lm75[0]->addr);
1242                         err = -ENODEV;
1243                         goto error_sc_1;
1244                 }
1245                 data->lm75[1] = i2c_new_dummy(adapter,
1246                                               0x48 + ((val >> 4) & 0x7));
1247         }
1248
1249         return 0;
1250
1251 /* Undo inits in case of errors */
1252
1253 error_sc_1:
1254         if (data->lm75[0] != NULL)
1255                 i2c_unregister_device(data->lm75[0]);
1256 error_sc_0:
1257         return err;
1258 }
1259
1260
1261 /* Return 0 if detection is successful, -ENODEV otherwise */
1262 static int w83791d_detect(struct i2c_client *client, int kind,
1263                           struct i2c_board_info *info)
1264 {
1265         struct i2c_adapter *adapter = client->adapter;
1266         int val1, val2;
1267         unsigned short address = client->addr;
1268
1269         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1270                 return -ENODEV;
1271         }
1272
1273         if (w83791d_read(client, W83791D_REG_CONFIG) & 0x80)
1274                 return -ENODEV;
1275
1276         val1 = w83791d_read(client, W83791D_REG_BANK);
1277         val2 = w83791d_read(client, W83791D_REG_CHIPMAN);
1278         /* Check for Winbond ID if in bank 0 */
1279         if (!(val1 & 0x07)) {
1280                 if ((!(val1 & 0x80) && val2 != 0xa3) ||
1281                     ( (val1 & 0x80) && val2 != 0x5c)) {
1282                         return -ENODEV;
1283                 }
1284         }
1285         /* If Winbond chip, address of chip and W83791D_REG_I2C_ADDR
1286            should match */
1287         if (w83791d_read(client, W83791D_REG_I2C_ADDR) != address)
1288                 return -ENODEV;
1289
1290         /* We want bank 0 and Vendor ID high byte */
1291         val1 = w83791d_read(client, W83791D_REG_BANK) & 0x78;
1292         w83791d_write(client, W83791D_REG_BANK, val1 | 0x80);
1293
1294         /* Verify it is a Winbond w83791d */
1295         val1 = w83791d_read(client, W83791D_REG_WCHIPID);
1296         val2 = w83791d_read(client, W83791D_REG_CHIPMAN);
1297         if (val1 != 0x71 || val2 != 0x5c)
1298                 return -ENODEV;
1299
1300         strlcpy(info->type, "w83791d", I2C_NAME_SIZE);
1301
1302         return 0;
1303 }
1304
1305 static int w83791d_probe(struct i2c_client *client,
1306                          const struct i2c_device_id *id)
1307 {
1308         struct w83791d_data *data;
1309         struct device *dev = &client->dev;
1310         int i, err;
1311         u8 has_fanpwm45;
1312
1313 #ifdef DEBUG
1314         int val1;
1315         val1 = w83791d_read(client, W83791D_REG_DID_VID4);
1316         dev_dbg(dev, "Device ID version: %d.%d (0x%02x)\n",
1317                         (val1 >> 5) & 0x07, (val1 >> 1) & 0x0f, val1);
1318 #endif
1319
1320         data = kzalloc(sizeof(struct w83791d_data), GFP_KERNEL);
1321         if (!data) {
1322                 err = -ENOMEM;
1323                 goto error0;
1324         }
1325
1326         i2c_set_clientdata(client, data);
1327         mutex_init(&data->update_lock);
1328
1329         err = w83791d_detect_subclients(client);
1330         if (err)
1331                 goto error1;
1332
1333         /* Initialize the chip */
1334         w83791d_init_client(client);
1335
1336         /* If the fan_div is changed, make sure there is a rational
1337            fan_min in place */
1338         for (i = 0; i < NUMBER_OF_FANIN; i++) {
1339                 data->fan_min[i] = w83791d_read(client, W83791D_REG_FAN_MIN[i]);
1340         }
1341
1342         /* Register sysfs hooks */
1343         if ((err = sysfs_create_group(&client->dev.kobj, &w83791d_group)))
1344                 goto error3;
1345
1346         /* Check if pins of fan/pwm 4-5 are in use as GPIO */
1347         has_fanpwm45 = w83791d_read(client, W83791D_REG_GPIO) & 0x10;
1348         if (has_fanpwm45) {
1349                 err = sysfs_create_group(&client->dev.kobj,
1350                                          &w83791d_group_fanpwm45);
1351                 if (err)
1352                         goto error4;
1353         }
1354
1355         /* Everything is ready, now register the working device */
1356         data->hwmon_dev = hwmon_device_register(dev);
1357         if (IS_ERR(data->hwmon_dev)) {
1358                 err = PTR_ERR(data->hwmon_dev);
1359                 goto error5;
1360         }
1361
1362         return 0;
1363
1364 error5:
1365         if (has_fanpwm45)
1366                 sysfs_remove_group(&client->dev.kobj, &w83791d_group_fanpwm45);
1367 error4:
1368         sysfs_remove_group(&client->dev.kobj, &w83791d_group);
1369 error3:
1370         if (data->lm75[0] != NULL)
1371                 i2c_unregister_device(data->lm75[0]);
1372         if (data->lm75[1] != NULL)
1373                 i2c_unregister_device(data->lm75[1]);
1374 error1:
1375         kfree(data);
1376 error0:
1377         return err;
1378 }
1379
1380 static int w83791d_remove(struct i2c_client *client)
1381 {
1382         struct w83791d_data *data = i2c_get_clientdata(client);
1383
1384         hwmon_device_unregister(data->hwmon_dev);
1385         sysfs_remove_group(&client->dev.kobj, &w83791d_group);
1386
1387         if (data->lm75[0] != NULL)
1388                 i2c_unregister_device(data->lm75[0]);
1389         if (data->lm75[1] != NULL)
1390                 i2c_unregister_device(data->lm75[1]);
1391
1392         kfree(data);
1393         return 0;
1394 }
1395
1396 static void w83791d_init_client(struct i2c_client *client)
1397 {
1398         struct w83791d_data *data = i2c_get_clientdata(client);
1399         u8 tmp;
1400         u8 old_beep;
1401
1402         /* The difference between reset and init is that reset
1403            does a hard reset of the chip via index 0x40, bit 7,
1404            but init simply forces certain registers to have "sane"
1405            values. The hope is that the BIOS has done the right
1406            thing (which is why the default is reset=0, init=0),
1407            but if not, reset is the hard hammer and init
1408            is the soft mallet both of which are trying to whack
1409            things into place...
1410            NOTE: The data sheet makes a distinction between
1411            "power on defaults" and "reset by MR". As far as I can tell,
1412            the hard reset puts everything into a power-on state so I'm
1413            not sure what "reset by MR" means or how it can happen.
1414            */
1415         if (reset || init) {
1416                 /* keep some BIOS settings when we... */
1417                 old_beep = w83791d_read(client, W83791D_REG_BEEP_CONFIG);
1418
1419                 if (reset) {
1420                         /* ... reset the chip and ... */
1421                         w83791d_write(client, W83791D_REG_CONFIG, 0x80);
1422                 }
1423
1424                 /* ... disable power-on abnormal beep */
1425                 w83791d_write(client, W83791D_REG_BEEP_CONFIG, old_beep | 0x80);
1426
1427                 /* disable the global beep (not done by hard reset) */
1428                 tmp = w83791d_read(client, W83791D_REG_BEEP_CTRL[1]);
1429                 w83791d_write(client, W83791D_REG_BEEP_CTRL[1], tmp & 0xef);
1430
1431                 if (init) {
1432                         /* Make sure monitoring is turned on for add-ons */
1433                         tmp = w83791d_read(client, W83791D_REG_TEMP2_CONFIG);
1434                         if (tmp & 1) {
1435                                 w83791d_write(client, W83791D_REG_TEMP2_CONFIG,
1436                                         tmp & 0xfe);
1437                         }
1438
1439                         tmp = w83791d_read(client, W83791D_REG_TEMP3_CONFIG);
1440                         if (tmp & 1) {
1441                                 w83791d_write(client, W83791D_REG_TEMP3_CONFIG,
1442                                         tmp & 0xfe);
1443                         }
1444
1445                         /* Start monitoring */
1446                         tmp = w83791d_read(client, W83791D_REG_CONFIG) & 0xf7;
1447                         w83791d_write(client, W83791D_REG_CONFIG, tmp | 0x01);
1448                 }
1449         }
1450
1451         data->vrm = vid_which_vrm();
1452 }
1453
1454 static struct w83791d_data *w83791d_update_device(struct device *dev)
1455 {
1456         struct i2c_client *client = to_i2c_client(dev);
1457         struct w83791d_data *data = i2c_get_clientdata(client);
1458         int i, j;
1459         u8 reg_array_tmp[3];
1460         u8 vbat_reg;
1461
1462         mutex_lock(&data->update_lock);
1463
1464         if (time_after(jiffies, data->last_updated + (HZ * 3))
1465                         || !data->valid) {
1466                 dev_dbg(dev, "Starting w83791d device update\n");
1467
1468                 /* Update the voltages measured value and limits */
1469                 for (i = 0; i < NUMBER_OF_VIN; i++) {
1470                         data->in[i] = w83791d_read(client,
1471                                                 W83791D_REG_IN[i]);
1472                         data->in_max[i] = w83791d_read(client,
1473                                                 W83791D_REG_IN_MAX[i]);
1474                         data->in_min[i] = w83791d_read(client,
1475                                                 W83791D_REG_IN_MIN[i]);
1476                 }
1477
1478                 /* Update the fan counts and limits */
1479                 for (i = 0; i < NUMBER_OF_FANIN; i++) {
1480                         /* Update the Fan measured value and limits */
1481                         data->fan[i] = w83791d_read(client,
1482                                                 W83791D_REG_FAN[i]);
1483                         data->fan_min[i] = w83791d_read(client,
1484                                                 W83791D_REG_FAN_MIN[i]);
1485                 }
1486
1487                 /* Update the fan divisor */
1488                 for (i = 0; i < 3; i++) {
1489                         reg_array_tmp[i] = w83791d_read(client,
1490                                                 W83791D_REG_FAN_DIV[i]);
1491                 }
1492                 data->fan_div[0] = (reg_array_tmp[0] >> 4) & 0x03;
1493                 data->fan_div[1] = (reg_array_tmp[0] >> 6) & 0x03;
1494                 data->fan_div[2] = (reg_array_tmp[1] >> 6) & 0x03;
1495                 data->fan_div[3] = reg_array_tmp[2] & 0x07;
1496                 data->fan_div[4] = (reg_array_tmp[2] >> 4) & 0x07;
1497
1498                 /* The fan divisor for fans 0-2 get bit 2 from
1499                    bits 5-7 respectively of vbat register */
1500                 vbat_reg = w83791d_read(client, W83791D_REG_VBAT);
1501                 for (i = 0; i < 3; i++)
1502                         data->fan_div[i] |= (vbat_reg >> (3 + i)) & 0x04;
1503
1504                 /* Update PWM duty cycle */
1505                 for (i = 0; i < NUMBER_OF_PWM; i++) {
1506                         data->pwm[i] =  w83791d_read(client,
1507                                                 W83791D_REG_PWM[i]);
1508                 }
1509
1510                 /* Update PWM enable status */
1511                 for (i = 0; i < 2; i++) {
1512                         reg_array_tmp[i] = w83791d_read(client,
1513                                                 W83791D_REG_FAN_CFG[i]);
1514                 }
1515                 data->pwm_enable[0] = (reg_array_tmp[0] >> 2) & 0x03;
1516                 data->pwm_enable[1] = (reg_array_tmp[0] >> 4) & 0x03;
1517                 data->pwm_enable[2] = (reg_array_tmp[1] >> 2) & 0x03;
1518
1519                 /* Update PWM target temperature */
1520                 for (i = 0; i < 3; i++) {
1521                         data->temp_target[i] = w83791d_read(client,
1522                                 W83791D_REG_TEMP_TARGET[i]) & 0x7f;
1523                 }
1524
1525                 /* Update PWM temperature tolerance */
1526                 for (i = 0; i < 2; i++) {
1527                         reg_array_tmp[i] = w83791d_read(client,
1528                                         W83791D_REG_TEMP_TOL[i]);
1529                 }
1530                 data->temp_tolerance[0] = reg_array_tmp[0] & 0x0f;
1531                 data->temp_tolerance[1] = (reg_array_tmp[0] >> 4) & 0x0f;
1532                 data->temp_tolerance[2] = reg_array_tmp[1] & 0x0f;
1533
1534                 /* Update the first temperature sensor */
1535                 for (i = 0; i < 3; i++) {
1536                         data->temp1[i] = w83791d_read(client,
1537                                                 W83791D_REG_TEMP1[i]);
1538                 }
1539
1540                 /* Update the rest of the temperature sensors */
1541                 for (i = 0; i < 2; i++) {
1542                         for (j = 0; j < 3; j++) {
1543                                 data->temp_add[i][j] =
1544                                         (w83791d_read(client,
1545                                         W83791D_REG_TEMP_ADD[i][j * 2]) << 8) |
1546                                         w83791d_read(client,
1547                                         W83791D_REG_TEMP_ADD[i][j * 2 + 1]);
1548                         }
1549                 }
1550
1551                 /* Update the realtime status */
1552                 data->alarms =
1553                         w83791d_read(client, W83791D_REG_ALARM1) +
1554                         (w83791d_read(client, W83791D_REG_ALARM2) << 8) +
1555                         (w83791d_read(client, W83791D_REG_ALARM3) << 16);
1556
1557                 /* Update the beep configuration information */
1558                 data->beep_mask =
1559                         w83791d_read(client, W83791D_REG_BEEP_CTRL[0]) +
1560                         (w83791d_read(client, W83791D_REG_BEEP_CTRL[1]) << 8) +
1561                         (w83791d_read(client, W83791D_REG_BEEP_CTRL[2]) << 16);
1562
1563                 /* Extract global beep enable flag */
1564                 data->beep_enable =
1565                         (data->beep_mask >> GLOBAL_BEEP_ENABLE_SHIFT) & 0x01;
1566
1567                 /* Update the cpu voltage information */
1568                 i = w83791d_read(client, W83791D_REG_VID_FANDIV);
1569                 data->vid = i & 0x0f;
1570                 data->vid |= (w83791d_read(client, W83791D_REG_DID_VID4) & 0x01)
1571                                 << 4;
1572
1573                 data->last_updated = jiffies;
1574                 data->valid = 1;
1575         }
1576
1577         mutex_unlock(&data->update_lock);
1578
1579 #ifdef DEBUG
1580         w83791d_print_debug(data, dev);
1581 #endif
1582
1583         return data;
1584 }
1585
1586 #ifdef DEBUG
1587 static void w83791d_print_debug(struct w83791d_data *data, struct device *dev)
1588 {
1589         int i = 0, j = 0;
1590
1591         dev_dbg(dev, "======Start of w83791d debug values======\n");
1592         dev_dbg(dev, "%d set of Voltages: ===>\n", NUMBER_OF_VIN);
1593         for (i = 0; i < NUMBER_OF_VIN; i++) {
1594                 dev_dbg(dev, "vin[%d] is:     0x%02x\n", i, data->in[i]);
1595                 dev_dbg(dev, "vin[%d] min is: 0x%02x\n", i, data->in_min[i]);
1596                 dev_dbg(dev, "vin[%d] max is: 0x%02x\n", i, data->in_max[i]);
1597         }
1598         dev_dbg(dev, "%d set of Fan Counts/Divisors: ===>\n", NUMBER_OF_FANIN);
1599         for (i = 0; i < NUMBER_OF_FANIN; i++) {
1600                 dev_dbg(dev, "fan[%d] is:     0x%02x\n", i, data->fan[i]);
1601                 dev_dbg(dev, "fan[%d] min is: 0x%02x\n", i, data->fan_min[i]);
1602                 dev_dbg(dev, "fan_div[%d] is: 0x%02x\n", i, data->fan_div[i]);
1603         }
1604
1605         /* temperature math is signed, but only print out the
1606            bits that matter */
1607         dev_dbg(dev, "%d set of Temperatures: ===>\n", NUMBER_OF_TEMPIN);
1608         for (i = 0; i < 3; i++) {
1609                 dev_dbg(dev, "temp1[%d] is: 0x%02x\n", i, (u8) data->temp1[i]);
1610         }
1611         for (i = 0; i < 2; i++) {
1612                 for (j = 0; j < 3; j++) {
1613                         dev_dbg(dev, "temp_add[%d][%d] is: 0x%04x\n", i, j,
1614                                 (u16) data->temp_add[i][j]);
1615                 }
1616         }
1617
1618         dev_dbg(dev, "Misc Information: ===>\n");
1619         dev_dbg(dev, "alarm is:     0x%08x\n", data->alarms);
1620         dev_dbg(dev, "beep_mask is: 0x%08x\n", data->beep_mask);
1621         dev_dbg(dev, "beep_enable is: %d\n", data->beep_enable);
1622         dev_dbg(dev, "vid is: 0x%02x\n", data->vid);
1623         dev_dbg(dev, "vrm is: 0x%02x\n", data->vrm);
1624         dev_dbg(dev, "=======End of w83791d debug values========\n");
1625         dev_dbg(dev, "\n");
1626 }
1627 #endif
1628
1629 static int __init sensors_w83791d_init(void)
1630 {
1631         return i2c_add_driver(&w83791d_driver);
1632 }
1633
1634 static void __exit sensors_w83791d_exit(void)
1635 {
1636         i2c_del_driver(&w83791d_driver);
1637 }
1638
1639 MODULE_AUTHOR("Charles Spirakis <bezaur@gmail.com>");
1640 MODULE_DESCRIPTION("W83791D driver");
1641 MODULE_LICENSE("GPL");
1642
1643 module_init(sensors_w83791d_init);
1644 module_exit(sensors_w83791d_exit);