drivers/hwmon/w83791d.c

   1 /*
   2     w83791d.c - Part of lm_sensors, Linux kernel modules for hardware
   3                 monitoring
   4
   5     Copyright (C) 2006 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       3       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, but its output is more along the lines of the
  31     83781d (which means there are no changes to the user-mode sensors
  32     program which treats the 83791d as an 83781d).
  33 */
  34
  35 #include <linux/config.h>
  36 #include <linux/module.h>
  37 #include <linux/init.h>
  38 #include <linux/slab.h>
  39 #include <linux/i2c.h>
  40 #include <linux/hwmon.h>
  41 #include <linux/hwmon-vid.h>
  42 #include <linux/hwmon-sysfs.h>
  43 #include <linux/err.h>
  44 #include <linux/mutex.h>
  45
  46 #define NUMBER_OF_VIN           10
  47 #define NUMBER_OF_FANIN         5
  48 #define NUMBER_OF_TEMPIN        3
  49
  50 /* Addresses to scan */
  51 static unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END };
  52
  53 /* Insmod parameters */
  54 I2C_CLIENT_INSMOD_1(w83791d);
  55 I2C_CLIENT_MODULE_PARM(force_subclients, "List of subclient addresses: "
  56                         "{bus, clientaddr, subclientaddr1, subclientaddr2}");
  57
  58 static int reset;
  59 module_param(reset, bool, 0);
  60 MODULE_PARM_DESC(reset, "Set to one to force a hardware chip reset");
  61
  62 static int init;
  63 module_param(init, bool, 0);
  64 MODULE_PARM_DESC(init, "Set to one to force extra software initialization");
  65
  66 /* The W83791D registers */
  67 static const u8 W83791D_REG_IN[NUMBER_OF_VIN] = {
  68         0x20,                   /* VCOREA in DataSheet */
  69         0x21,                   /* VINR0 in DataSheet */
  70         0x22,                   /* +3.3VIN in DataSheet */
  71         0x23,                   /* VDD5V in DataSheet */
  72         0x24,                   /* +12VIN in DataSheet */
  73         0x25,                   /* -12VIN in DataSheet */
  74         0x26,                   /* -5VIN in DataSheet */
  75         0xB0,                   /* 5VSB in DataSheet */
  76         0xB1,                   /* VBAT in DataSheet */
  77         0xB2                    /* VINR1 in DataSheet */
  78 };
  79
  80 static const u8 W83791D_REG_IN_MAX[NUMBER_OF_VIN] = {
  81         0x2B,                   /* VCOREA High Limit in DataSheet */
  82         0x2D,                   /* VINR0 High Limit in DataSheet */
  83         0x2F,                   /* +3.3VIN High Limit in DataSheet */
  84         0x31,                   /* VDD5V High Limit in DataSheet */
  85         0x33,                   /* +12VIN High Limit in DataSheet */
  86         0x35,                   /* -12VIN High Limit in DataSheet */
  87         0x37,                   /* -5VIN High Limit in DataSheet */
  88         0xB4,                   /* 5VSB High Limit in DataSheet */
  89         0xB6,                   /* VBAT High Limit in DataSheet */
  90         0xB8                    /* VINR1 High Limit in DataSheet */
  91 };
  92 static const u8 W83791D_REG_IN_MIN[NUMBER_OF_VIN] = {
  93         0x2C,                   /* VCOREA Low Limit in DataSheet */
  94         0x2E,                   /* VINR0 Low Limit in DataSheet */
  95         0x30,                   /* +3.3VIN Low Limit in DataSheet */
  96         0x32,                   /* VDD5V Low Limit in DataSheet */
  97         0x34,                   /* +12VIN Low Limit in DataSheet */
  98         0x36,                   /* -12VIN Low Limit in DataSheet */
  99         0x38,                   /* -5VIN Low Limit in DataSheet */
 100         0xB5,                   /* 5VSB Low Limit in DataSheet */
 101         0xB7,                   /* VBAT Low Limit in DataSheet */
 102         0xB9                    /* VINR1 Low Limit in DataSheet */
 103 };
 104 static const u8 W83791D_REG_FAN[NUMBER_OF_FANIN] = {
 105         0x28,                   /* FAN 1 Count in DataSheet */
 106         0x29,                   /* FAN 2 Count in DataSheet */
 107         0x2A,                   /* FAN 3 Count in DataSheet */
 108         0xBA,                   /* FAN 4 Count in DataSheet */
 109         0xBB,                   /* FAN 5 Count in DataSheet */
 110 };
 111 static const u8 W83791D_REG_FAN_MIN[NUMBER_OF_FANIN] = {
 112         0x3B,                   /* FAN 1 Count Low Limit in DataSheet */
 113         0x3C,                   /* FAN 2 Count Low Limit in DataSheet */
 114         0x3D,                   /* FAN 3 Count Low Limit in DataSheet */
 115         0xBC,                   /* FAN 4 Count Low Limit in DataSheet */
 116         0xBD,                   /* FAN 5 Count Low Limit in DataSheet */
 117 };
 118
 119 static const u8 W83791D_REG_FAN_CFG[2] = {
 120         0x84,                   /* FAN 1/2 configuration */
 121         0x95,                   /* FAN 3 configuration */
 122 };
 123
 124 static const u8 W83791D_REG_FAN_DIV[3] = {
 125         0x47,                   /* contains FAN1 and FAN2 Divisor */
 126         0x4b,                   /* contains FAN3 Divisor */
 127         0x5C,                   /* contains FAN4 and FAN5 Divisor */
 128 };
 129
 130 #define W83791D_REG_BANK                0x4E
 131 #define W83791D_REG_TEMP2_CONFIG        0xC2
 132 #define W83791D_REG_TEMP3_CONFIG        0xCA
 133
 134 static const u8 W83791D_REG_TEMP1[3] = {
 135         0x27,                   /* TEMP 1 in DataSheet */
 136         0x39,                   /* TEMP 1 Over in DataSheet */
 137         0x3A,                   /* TEMP 1 Hyst in DataSheet */
 138 };
 139
 140 static const u8 W83791D_REG_TEMP_ADD[2][6] = {
 141         {0xC0,                  /* TEMP 2 in DataSheet */
 142          0xC1,                  /* TEMP 2(0.5 deg) in DataSheet */
 143          0xC5,                  /* TEMP 2 Over High part in DataSheet */
 144          0xC6,                  /* TEMP 2 Over Low part in DataSheet */
 145          0xC3,                  /* TEMP 2 Thyst High part in DataSheet */
 146          0xC4},                 /* TEMP 2 Thyst Low part in DataSheet */
 147         {0xC8,                  /* TEMP 3 in DataSheet */
 148          0xC9,                  /* TEMP 3(0.5 deg) in DataSheet */
 149          0xCD,                  /* TEMP 3 Over High part in DataSheet */
 150          0xCE,                  /* TEMP 3 Over Low part in DataSheet */
 151          0xCB,                  /* TEMP 3 Thyst High part in DataSheet */
 152          0xCC}                  /* TEMP 3 Thyst Low part in DataSheet */
 153 };
 154
 155 #define W83791D_REG_BEEP_CONFIG         0x4D
 156
 157 static const u8 W83791D_REG_BEEP_CTRL[3] = {
 158         0x56,                   /* BEEP Control Register 1 */
 159         0x57,                   /* BEEP Control Register 2 */
 160         0xA3,                   /* BEEP Control Register 3 */
 161 };
 162
 163 #define W83791D_REG_CONFIG              0x40
 164 #define W83791D_REG_VID_FANDIV          0x47
 165 #define W83791D_REG_DID_VID4            0x49
 166 #define W83791D_REG_WCHIPID             0x58
 167 #define W83791D_REG_CHIPMAN             0x4F
 168 #define W83791D_REG_PIN                 0x4B
 169 #define W83791D_REG_I2C_SUBADDR         0x4A
 170
 171 #define W83791D_REG_ALARM1 0xA9 /* realtime status register1 */
 172 #define W83791D_REG_ALARM2 0xAA /* realtime status register2 */
 173 #define W83791D_REG_ALARM3 0xAB /* realtime status register3 */
 174
 175 #define W83791D_REG_VBAT                0x5D
 176 #define W83791D_REG_I2C_ADDR            0x48
 177
 178 /* The SMBus locks itself. The Winbond W83791D has a bank select register
 179    (index 0x4e), but the driver only accesses registers in bank 0. Since
 180    we don't switch banks, we don't need any special code to handle
 181    locking access between bank switches */
 182 static inline int w83791d_read(struct i2c_client *client, u8 reg)
 183 {
 184         return i2c_smbus_read_byte_data(client, reg);
 185 }
 186
 187 static inline int w83791d_write(struct i2c_client *client, u8 reg, u8 value)
 188 {
 189         return i2c_smbus_write_byte_data(client, reg, value);
 190 }
 191
 192 /* The analog voltage inputs have 16mV LSB. Since the sysfs output is
 193    in mV as would be measured on the chip input pin, need to just
 194    multiply/divide by 16 to translate from/to register values. */
 195 #define IN_TO_REG(val)          (SENSORS_LIMIT((((val) + 8) / 16), 0, 255))
 196 #define IN_FROM_REG(val)        ((val) * 16)
 197
 198 static u8 fan_to_reg(long rpm, int div)
 199 {
 200         if (rpm == 0)
 201                 return 255;
 202         rpm = SENSORS_LIMIT(rpm, 1, 1000000);
 203         return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
 204 }
 205
 206 #define FAN_FROM_REG(val,div)   ((val) == 0   ? -1 : \
 207                                 ((val) == 255 ? 0 : \
 208                                         1350000 / ((val) * (div))))
 209
 210 /* for temp1 which is 8-bit resolution, LSB = 1 degree Celsius */
 211 #define TEMP1_FROM_REG(val)     ((val) * 1000)
 212 #define TEMP1_TO_REG(val)       ((val) <= -128000 ? -128 : \
 213                                  (val) >= 127000 ? 127 : \
 214                                  (val) < 0 ? ((val) - 500) / 1000 : \
 215                                  ((val) + 500) / 1000)
 216
 217 /* for temp2 and temp3 which are 9-bit resolution, LSB = 0.5 degree Celsius
 218    Assumes the top 8 bits are the integral amount and the bottom 8 bits
 219    are the fractional amount. Since we only have 0.5 degree resolution,
 220    the bottom 7 bits will always be zero */
 221 #define TEMP23_FROM_REG(val)    ((val) / 128 * 500)
 222 #define TEMP23_TO_REG(val)      ((val) <= -128000 ? 0x8000 : \
 223                                  (val) >= 127500 ? 0x7F80 : \
 224                                  (val) < 0 ? ((val) - 250) / 500 * 128 : \
 225                                  ((val) + 250) / 500 * 128)
 226
 227
 228 #define BEEP_MASK_TO_REG(val)           ((val) & 0xffffff)
 229 #define BEEP_MASK_FROM_REG(val)         ((val) & 0xffffff)
 230
 231 #define DIV_FROM_REG(val)               (1 << (val))
 232
 233 static u8 div_to_reg(int nr, long val)
 234 {
 235         int i;
 236         int max;
 237
 238         /* first three fan's divisor max out at 8, rest max out at 128 */
 239         max = (nr < 3) ? 8 : 128;
 240         val = SENSORS_LIMIT(val, 1, max) >> 1;
 241         for (i = 0; i < 7; i++) {
 242                 if (val == 0)
 243                         break;
 244                 val >>= 1;
 245         }
 246         return (u8) i;
 247 }
 248
 249 struct w83791d_data {
 250         struct i2c_client client;
 251         struct class_device *class_dev;
 252         struct mutex update_lock;
 253
 254         char valid;                     /* !=0 if following fields are valid */
 255         unsigned long last_updated;     /* In jiffies */
 256
 257         /* array of 2 pointers to subclients */
 258         struct i2c_client *lm75[2];
 259
 260         /* volts */
 261         u8 in[NUMBER_OF_VIN];           /* Register value */
 262         u8 in_max[NUMBER_OF_VIN];       /* Register value */
 263         u8 in_min[NUMBER_OF_VIN];       /* Register value */
 264
 265         /* fans */
 266         u8 fan[NUMBER_OF_FANIN];        /* Register value */
 267         u8 fan_min[NUMBER_OF_FANIN];    /* Register value */
 268         u8 fan_div[NUMBER_OF_FANIN];    /* Register encoding, shifted right */
 269
 270         /* Temperature sensors */
 271
 272         s8 temp1[3];            /* current, over, thyst */
 273         s16 temp_add[2][3];     /* fixed point value. Top 8 bits are the
 274                                    integral part, bottom 8 bits are the
 275                                    fractional part. We only use the top
 276                                    9 bits as the resolution is only
 277                                    to the 0.5 degree C...
 278                                    two sensors with three values
 279                                    (cur, over, hyst)  */
 280
 281         /* Misc */
 282         u32 alarms;             /* realtime status register encoding,combined */
 283         u8 beep_enable;         /* Global beep enable */
 284         u32 beep_mask;          /* Mask off specific beeps */
 285         u8 vid;                 /* Register encoding, combined */
 286         u8 vrm;                 /* hwmon-vid */
 287 };
 288
 289 static int w83791d_attach_adapter(struct i2c_adapter *adapter);
 290 static int w83791d_detect(struct i2c_adapter *adapter, int address, int kind);
 291 static int w83791d_detach_client(struct i2c_client *client);
 292
 293 static int w83791d_read(struct i2c_client *client, u8 register);
 294 static int w83791d_write(struct i2c_client *client, u8 register, u8 value);
 295 static struct w83791d_data *w83791d_update_device(struct device *dev);
 296
 297 #ifdef DEBUG
 298 static void w83791d_print_debug(struct w83791d_data *data, struct device *dev);
 299 #endif
 300
 301 static void w83791d_init_client(struct i2c_client *client);
 302
 303 static struct i2c_driver w83791d_driver = {
 304         .driver = {
 305                 .name = "w83791d",
 306         },
 307         .attach_adapter = w83791d_attach_adapter,
 308         .detach_client = w83791d_detach_client,
 309 };
 310
 311 /* following are the sysfs callback functions */
 312 #define show_in_reg(reg) \
 313 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
 314                         char *buf) \
 315 { \
 316         struct sensor_device_attribute *sensor_attr = \
 317                                                 to_sensor_dev_attr(attr); \
 318         struct w83791d_data *data = w83791d_update_device(dev); \
 319         int nr = sensor_attr->index; \
 320         return sprintf(buf,"%d\n", IN_FROM_REG(data->reg[nr])); \
 321 }
 322
 323 show_in_reg(in);
 324 show_in_reg(in_min);
 325 show_in_reg(in_max);
 326
 327 #define store_in_reg(REG, reg) \
 328 static ssize_t store_in_##reg(struct device *dev, \
 329                                 struct device_attribute *attr, \
 330                                 const char *buf, size_t count) \
 331 { \
 332         struct sensor_device_attribute *sensor_attr = \
 333                                                 to_sensor_dev_attr(attr); \
 334         struct i2c_client *client = to_i2c_client(dev); \
 335         struct w83791d_data *data = i2c_get_clientdata(client); \
 336         unsigned long val = simple_strtoul(buf, NULL, 10); \
 337         int nr = sensor_attr->index; \
 338          \
 339         mutex_lock(&data->update_lock); \
 340         data->in_##reg[nr] = IN_TO_REG(val); \
 341         w83791d_write(client, W83791D_REG_IN_##REG[nr], data->in_##reg[nr]); \
 342         mutex_unlock(&data->update_lock); \
 343          \
 344         return count; \
 345 }
 346 store_in_reg(MIN, min);
 347 store_in_reg(MAX, max);
 348
 349 static struct sensor_device_attribute sda_in_input[] = {
 350         SENSOR_ATTR(in0_input, S_IRUGO, show_in, NULL, 0),
 351         SENSOR_ATTR(in1_input, S_IRUGO, show_in, NULL, 1),
 352         SENSOR_ATTR(in2_input, S_IRUGO, show_in, NULL, 2),
 353         SENSOR_ATTR(in3_input, S_IRUGO, show_in, NULL, 3),
 354         SENSOR_ATTR(in4_input, S_IRUGO, show_in, NULL, 4),
 355         SENSOR_ATTR(in5_input, S_IRUGO, show_in, NULL, 5),
 356         SENSOR_ATTR(in6_input, S_IRUGO, show_in, NULL, 6),
 357         SENSOR_ATTR(in7_input, S_IRUGO, show_in, NULL, 7),
 358         SENSOR_ATTR(in8_input, S_IRUGO, show_in, NULL, 8),
 359         SENSOR_ATTR(in9_input, S_IRUGO, show_in, NULL, 9),
 360 };
 361
 362 static struct sensor_device_attribute sda_in_min[] = {
 363         SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 0),
 364         SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 1),
 365         SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 2),
 366         SENSOR_ATTR(in3_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 3),
 367         SENSOR_ATTR(in4_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 4),
 368         SENSOR_ATTR(in5_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 5),
 369         SENSOR_ATTR(in6_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 6),
 370         SENSOR_ATTR(in7_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 7),
 371         SENSOR_ATTR(in8_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 8),
 372         SENSOR_ATTR(in9_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 9),
 373 };
 374
 375 static struct sensor_device_attribute sda_in_max[] = {
 376         SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 0),
 377         SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 1),
 378         SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 2),
 379         SENSOR_ATTR(in3_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 3),
 380         SENSOR_ATTR(in4_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 4),
 381         SENSOR_ATTR(in5_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 5),
 382         SENSOR_ATTR(in6_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 6),
 383         SENSOR_ATTR(in7_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 7),
 384         SENSOR_ATTR(in8_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 8),
 385         SENSOR_ATTR(in9_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 9),
 386 };
 387
 388 #define show_fan_reg(reg) \
 389 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
 390                                 char *buf) \
 391 { \
 392         struct sensor_device_attribute *sensor_attr = \
 393                                                 to_sensor_dev_attr(attr); \
 394         struct w83791d_data *data = w83791d_update_device(dev); \
 395         int nr = sensor_attr->index; \
 396         return sprintf(buf,"%d\n", \
 397                 FAN_FROM_REG(data->reg[nr], DIV_FROM_REG(data->fan_div[nr]))); \
 398 }
 399
 400 show_fan_reg(fan);
 401 show_fan_reg(fan_min);
 402
 403 static ssize_t store_fan_min(struct device *dev, struct device_attribute *attr,
 404                                 const char *buf, size_t count)
 405 {
 406         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 407         struct i2c_client *client = to_i2c_client(dev);
 408         struct w83791d_data *data = i2c_get_clientdata(client);
 409         unsigned long val = simple_strtoul(buf, NULL, 10);
 410         int nr = sensor_attr->index;
 411
 412         mutex_lock(&data->update_lock);
 413         data->fan_min[nr] = fan_to_reg(val, DIV_FROM_REG(data->fan_div[nr]));
 414         w83791d_write(client, W83791D_REG_FAN_MIN[nr], data->fan_min[nr]);
 415         mutex_unlock(&data->update_lock);
 416
 417         return count;
 418 }
 419
 420 static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr,
 421                                 char *buf)
 422 {
 423         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 424         int nr = sensor_attr->index;
 425         struct w83791d_data *data = w83791d_update_device(dev);
 426         return sprintf(buf, "%u\n", DIV_FROM_REG(data->fan_div[nr]));
 427 }
 428
 429 /* Note: we save and restore the fan minimum here, because its value is
 430    determined in part by the fan divisor.  This follows the principle of
 431    least suprise; the user doesn't expect the fan minimum to change just
 432    because the divisor changed. */
 433 static ssize_t store_fan_div(struct device *dev, struct device_attribute *attr,
 434                                 const char *buf, size_t count)
 435 {
 436         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 437         struct i2c_client *client = to_i2c_client(dev);
 438         struct w83791d_data *data = i2c_get_clientdata(client);
 439         int nr = sensor_attr->index;
 440         unsigned long min;
 441         u8 tmp_fan_div;
 442         u8 fan_div_reg;
 443         int indx = 0;
 444         u8 keep_mask = 0;
 445         u8 new_shift = 0;
 446
 447         /* Save fan_min */
 448         min = FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr]));
 449
 450         mutex_lock(&data->update_lock);
 451         data->fan_div[nr] = div_to_reg(nr, simple_strtoul(buf, NULL, 10));
 452
 453         switch (nr) {
 454         case 0:
 455                 indx = 0;
 456                 keep_mask = 0xcf;
 457                 new_shift = 4;
 458                 break;
 459         case 1:
 460                 indx = 0;
 461                 keep_mask = 0x3f;
 462                 new_shift = 6;
 463                 break;
 464         case 2:
 465                 indx = 1;
 466                 keep_mask = 0x3f;
 467                 new_shift = 6;
 468                 break;
 469         case 3:
 470                 indx = 2;
 471                 keep_mask = 0xf8;
 472                 new_shift = 0;
 473                 break;
 474         case 4:
 475                 indx = 2;
 476                 keep_mask = 0x8f;
 477                 new_shift = 4;
 478                 break;
 479 #ifdef DEBUG
 480         default:
 481                 dev_warn(dev, "store_fan_div: Unexpected nr seen: %d\n", nr);
 482                 count = -EINVAL;
 483                 goto err_exit;
 484 #endif
 485         }
 486
 487         fan_div_reg = w83791d_read(client, W83791D_REG_FAN_DIV[indx])
 488                         & keep_mask;
 489         tmp_fan_div = (data->fan_div[nr] << new_shift) & ~keep_mask;
 490
 491         w83791d_write(client, W83791D_REG_FAN_DIV[indx],
 492                                 fan_div_reg | tmp_fan_div);
 493
 494         /* Restore fan_min */
 495         data->fan_min[nr] = fan_to_reg(min, DIV_FROM_REG(data->fan_div[nr]));
 496         w83791d_write(client, W83791D_REG_FAN_MIN[nr], data->fan_min[nr]);
 497
 498 #ifdef DEBUG
 499 err_exit:
 500 #endif
 501         mutex_unlock(&data->update_lock);
 502
 503         return count;
 504 }
 505
 506 static struct sensor_device_attribute sda_fan_input[] = {
 507         SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0),
 508         SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1),
 509         SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2),
 510         SENSOR_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3),
 511         SENSOR_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4),
 512 };
 513
 514 static struct sensor_device_attribute sda_fan_min[] = {
 515         SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO,
 516                         show_fan_min, store_fan_min, 0),
 517         SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO,
 518                         show_fan_min, store_fan_min, 1),
 519         SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO,
 520                         show_fan_min, store_fan_min, 2),
 521         SENSOR_ATTR(fan4_min, S_IWUSR | S_IRUGO,
 522                         show_fan_min, store_fan_min, 3),
 523         SENSOR_ATTR(fan5_min, S_IWUSR | S_IRUGO,
 524                         show_fan_min, store_fan_min, 4),
 525 };
 526
 527 static struct sensor_device_attribute sda_fan_div[] = {
 528         SENSOR_ATTR(fan1_div, S_IWUSR | S_IRUGO,
 529                         show_fan_div, store_fan_div, 0),
 530         SENSOR_ATTR(fan2_div, S_IWUSR | S_IRUGO,
 531                         show_fan_div, store_fan_div, 1),
 532         SENSOR_ATTR(fan3_div, S_IWUSR | S_IRUGO,
 533                         show_fan_div, store_fan_div, 2),
 534         SENSOR_ATTR(fan4_div, S_IWUSR | S_IRUGO,
 535                         show_fan_div, store_fan_div, 3),
 536         SENSOR_ATTR(fan5_div, S_IWUSR | S_IRUGO,
 537                         show_fan_div, store_fan_div, 4),
 538 };
 539
 540 /* read/write the temperature1, includes measured value and limits */
 541 static ssize_t show_temp1(struct device *dev, struct device_attribute *devattr,
 542                                 char *buf)
 543 {
 544         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 545         struct w83791d_data *data = w83791d_update_device(dev);
 546         return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp1[attr->index]));
 547 }
 548
 549 static ssize_t store_temp1(struct device *dev, struct device_attribute *devattr,
 550                                 const char *buf, size_t count)
 551 {
 552         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 553         struct i2c_client *client = to_i2c_client(dev);
 554         struct w83791d_data *data = i2c_get_clientdata(client);
 555         long val = simple_strtol(buf, NULL, 10);
 556         int nr = attr->index;
 557
 558         mutex_lock(&data->update_lock);
 559         data->temp1[nr] = TEMP1_TO_REG(val);
 560         w83791d_write(client, W83791D_REG_TEMP1[nr], data->temp1[nr]);
 561         mutex_unlock(&data->update_lock);
 562         return count;
 563 }
 564
 565 /* read/write temperature2-3, includes measured value and limits */
 566 static ssize_t show_temp23(struct device *dev, struct device_attribute *devattr,
 567                                 char *buf)
 568 {
 569         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 570         struct w83791d_data *data = w83791d_update_device(dev);
 571         int nr = attr->nr;
 572         int index = attr->index;
 573         return sprintf(buf, "%d\n", TEMP23_FROM_REG(data->temp_add[nr][index]));
 574 }
 575
 576 static ssize_t store_temp23(struct device *dev,
 577                                 struct device_attribute *devattr,
 578                                 const char *buf, size_t count)
 579 {
 580         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 581         struct i2c_client *client = to_i2c_client(dev);
 582         struct w83791d_data *data = i2c_get_clientdata(client);
 583         long val = simple_strtol(buf, NULL, 10);
 584         int nr = attr->nr;
 585         int index = attr->index;
 586
 587         mutex_lock(&data->update_lock);
 588         data->temp_add[nr][index] = TEMP23_TO_REG(val);
 589         w83791d_write(client, W83791D_REG_TEMP_ADD[nr][index * 2],
 590                                 data->temp_add[nr][index] >> 8);
 591         w83791d_write(client, W83791D_REG_TEMP_ADD[nr][index * 2 + 1],
 592                                 data->temp_add[nr][index] & 0x80);
 593         mutex_unlock(&data->update_lock);
 594
 595         return count;
 596 }
 597
 598 static struct sensor_device_attribute_2 sda_temp_input[] = {
 599         SENSOR_ATTR_2(temp1_input, S_IRUGO, show_temp1, NULL, 0, 0),
 600         SENSOR_ATTR_2(temp2_input, S_IRUGO, show_temp23, NULL, 0, 0),
 601         SENSOR_ATTR_2(temp3_input, S_IRUGO, show_temp23, NULL, 1, 0),
 602 };
 603
 604 static struct sensor_device_attribute_2 sda_temp_max[] = {
 605         SENSOR_ATTR_2(temp1_max, S_IRUGO | S_IWUSR,
 606                         show_temp1, store_temp1, 0, 1),
 607         SENSOR_ATTR_2(temp2_max, S_IRUGO | S_IWUSR,
 608                         show_temp23, store_temp23, 0, 1),
 609         SENSOR_ATTR_2(temp3_max, S_IRUGO | S_IWUSR,
 610                         show_temp23, store_temp23, 1, 1),
 611 };
 612
 613 static struct sensor_device_attribute_2 sda_temp_max_hyst[] = {
 614         SENSOR_ATTR_2(temp1_max_hyst, S_IRUGO | S_IWUSR,
 615                         show_temp1, store_temp1, 0, 2),
 616         SENSOR_ATTR_2(temp2_max_hyst, S_IRUGO | S_IWUSR,
 617                         show_temp23, store_temp23, 0, 2),
 618         SENSOR_ATTR_2(temp3_max_hyst, S_IRUGO | S_IWUSR,
 619                         show_temp23, store_temp23, 1, 2),
 620 };
 621
 622
 623 /* get reatime status of all sensors items: voltage, temp, fan */
 624 static ssize_t show_alarms_reg(struct device *dev,
 625                                 struct device_attribute *attr, char *buf)
 626 {
 627         struct w83791d_data *data = w83791d_update_device(dev);
 628         return sprintf(buf, "%u\n", data->alarms);
 629 }
 630
 631 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
 632
 633 /* Beep control */
 634
 635 #define GLOBAL_BEEP_ENABLE_SHIFT        15
 636 #define GLOBAL_BEEP_ENABLE_MASK         (1 << GLOBAL_BEEP_ENABLE_SHIFT)
 637
 638 static ssize_t show_beep_enable(struct device *dev,
 639                                 struct device_attribute *attr, char *buf)
 640 {
 641         struct w83791d_data *data = w83791d_update_device(dev);
 642         return sprintf(buf, "%d\n", data->beep_enable);
 643 }
 644
 645 static ssize_t show_beep_mask(struct device *dev,
 646                                 struct device_attribute *attr, char *buf)
 647 {
 648         struct w83791d_data *data = w83791d_update_device(dev);
 649         return sprintf(buf, "%d\n", BEEP_MASK_FROM_REG(data->beep_mask));
 650 }
 651
 652
 653 static ssize_t store_beep_mask(struct device *dev,
 654                                 struct device_attribute *attr,
 655                                 const char *buf, size_t count)
 656 {
 657         struct i2c_client *client = to_i2c_client(dev);
 658         struct w83791d_data *data = i2c_get_clientdata(client);
 659         long val = simple_strtol(buf, NULL, 10);
 660         int i;
 661
 662         mutex_lock(&data->update_lock);
 663
 664         /* The beep_enable state overrides any enabling request from
 665            the masks */
 666         data->beep_mask = BEEP_MASK_TO_REG(val) & ~GLOBAL_BEEP_ENABLE_MASK;
 667         data->beep_mask |= (data->beep_enable << GLOBAL_BEEP_ENABLE_SHIFT);
 668
 669         val = data->beep_mask;
 670
 671         for (i = 0; i < 3; i++) {
 672                 w83791d_write(client, W83791D_REG_BEEP_CTRL[i], (val & 0xff));
 673                 val >>= 8;
 674         }
 675
 676         mutex_unlock(&data->update_lock);
 677
 678         return count;
 679 }
 680
 681 static ssize_t store_beep_enable(struct device *dev,
 682                                 struct device_attribute *attr,
 683                                 const char *buf, size_t count)
 684 {
 685         struct i2c_client *client = to_i2c_client(dev);
 686         struct w83791d_data *data = i2c_get_clientdata(client);
 687         long val = simple_strtol(buf, NULL, 10);
 688
 689         mutex_lock(&data->update_lock);
 690
 691         data->beep_enable = val ? 1 : 0;
 692
 693         /* Keep the full mask value in sync with the current enable */
 694         data->beep_mask &= ~GLOBAL_BEEP_ENABLE_MASK;
 695         data->beep_mask |= (data->beep_enable << GLOBAL_BEEP_ENABLE_SHIFT);
 696
 697         /* The global control is in the second beep control register
 698            so only need to update that register */
 699         val = (data->beep_mask >> 8) & 0xff;
 700
 701         w83791d_write(client, W83791D_REG_BEEP_CTRL[1], val);
 702
 703         mutex_unlock(&data->update_lock);
 704
 705         return count;
 706 }
 707
 708 static struct sensor_device_attribute sda_beep_ctrl[] = {
 709         SENSOR_ATTR(beep_enable, S_IRUGO | S_IWUSR,
 710                         show_beep_enable, store_beep_enable, 0),
 711         SENSOR_ATTR(beep_mask, S_IRUGO | S_IWUSR,
 712                         show_beep_mask, store_beep_mask, 1)
 713 };
 714
 715 /* cpu voltage regulation information */
 716 static ssize_t show_vid_reg(struct device *dev,
 717                                 struct device_attribute *attr, char *buf)
 718 {
 719         struct w83791d_data *data = w83791d_update_device(dev);
 720         return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
 721 }
 722
 723 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
 724
 725 static ssize_t show_vrm_reg(struct device *dev,
 726                                 struct device_attribute *attr, char *buf)
 727 {
 728         struct w83791d_data *data = w83791d_update_device(dev);
 729         return sprintf(buf, "%d\n", data->vrm);
 730 }
 731
 732 static ssize_t store_vrm_reg(struct device *dev,
 733                                 struct device_attribute *attr,
 734                                 const char *buf, size_t count)
 735 {
 736         struct i2c_client *client = to_i2c_client(dev);
 737         struct w83791d_data *data = i2c_get_clientdata(client);
 738         unsigned long val = simple_strtoul(buf, NULL, 10);
 739
 740         /* No lock needed as vrm is internal to the driver
 741            (not read from a chip register) and so is not
 742            updated in w83791d_update_device() */
 743         data->vrm = val;
 744
 745         return count;
 746 }
 747
 748 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
 749
 750 /* This function is called when:
 751      * w83791d_driver is inserted (when this module is loaded), for each
 752        available adapter
 753      * when a new adapter is inserted (and w83791d_driver is still present) */
 754 static int w83791d_attach_adapter(struct i2c_adapter *adapter)
 755 {
 756         if (!(adapter->class & I2C_CLASS_HWMON))
 757                 return 0;
 758         return i2c_probe(adapter, &addr_data, w83791d_detect);
 759 }
 760
 761
 762 static int w83791d_create_subclient(struct i2c_adapter *adapter,
 763                                 struct i2c_client *client, int addr,
 764                                 struct i2c_client **sub_cli)
 765 {
 766         int err;
 767         struct i2c_client *sub_client;
 768
 769         (*sub_cli) = sub_client =
 770                         kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
 771         if (!(sub_client)) {
 772                 return -ENOMEM;
 773         }
 774         sub_client->addr = 0x48 + addr;
 775         i2c_set_clientdata(sub_client, NULL);
 776         sub_client->adapter = adapter;
 777         sub_client->driver = &w83791d_driver;
 778         strlcpy(sub_client->name, "w83791d subclient", I2C_NAME_SIZE);
 779         if ((err = i2c_attach_client(sub_client))) {
 780                 dev_err(&client->dev, "subclient registration "
 781                         "at address 0x%x failed\n", sub_client->addr);
 782                 kfree(sub_client);
 783                 return err;
 784         }
 785         return 0;
 786 }
 787
 788
 789 static int w83791d_detect_subclients(struct i2c_adapter *adapter, int address,
 790                                 int kind, struct i2c_client *client)
 791 {
 792         struct w83791d_data *data = i2c_get_clientdata(client);
 793         int i, id, err;
 794         u8 val;
 795
 796         id = i2c_adapter_id(adapter);
 797         if (force_subclients[0] == id && force_subclients[1] == address) {
 798                 for (i = 2; i <= 3; i++) {
 799                         if (force_subclients[i] < 0x48 ||
 800                             force_subclients[i] > 0x4f) {
 801                                 dev_err(&client->dev,
 802                                         "invalid subclient "
 803                                         "address %d; must be 0x48-0x4f\n",
 804                                         force_subclients[i]);
 805                                 err = -ENODEV;
 806                                 goto error_sc_0;
 807                         }
 808                 }
 809                 w83791d_write(client, W83791D_REG_I2C_SUBADDR,
 810                                         (force_subclients[2] & 0x07) |
 811                                         ((force_subclients[3] & 0x07) << 4));
 812         }
 813
 814         val = w83791d_read(client, W83791D_REG_I2C_SUBADDR);
 815         if (!(val & 0x08)) {
 816                 err = w83791d_create_subclient(adapter, client,
 817                                                 val & 0x7, &data->lm75[0]);
 818                 if (err < 0)
 819                         goto error_sc_0;
 820         }
 821         if (!(val & 0x80)) {
 822                 if ((data->lm75[0] != NULL) &&
 823                                 ((val & 0x7) == ((val >> 4) & 0x7))) {
 824                         dev_err(&client->dev,
 825                                 "duplicate addresses 0x%x, "
 826                                 "use force_subclient\n",
 827                                 data->lm75[0]->addr);
 828                         err = -ENODEV;
 829                         goto error_sc_1;
 830                 }
 831                 err = w83791d_create_subclient(adapter, client,
 832                                         (val >> 4) & 0x7, &data->lm75[1]);
 833                 if (err < 0)
 834                         goto error_sc_1;
 835         }
 836
 837         return 0;
 838
 839 /* Undo inits in case of errors */
 840
 841 error_sc_1:
 842         if (data->lm75[0] != NULL) {
 843                 i2c_detach_client(data->lm75[0]);
 844                 kfree(data->lm75[0]);
 845         }
 846 error_sc_0:
 847         return err;
 848 }
 849
 850
 851 static int w83791d_detect(struct i2c_adapter *adapter, int address, int kind)
 852 {
 853         struct i2c_client *client;
 854         struct device *dev;
 855         struct w83791d_data *data;
 856         int i, val1, val2;
 857         int err = 0;
 858         const char *client_name = "";
 859
 860         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
 861                 goto error0;
 862         }
 863
 864         /* OK. For now, we presume we have a valid client. We now create the
 865            client structure, even though we cannot fill it completely yet.
 866            But it allows us to access w83791d_{read,write}_value. */
 867         if (!(data = kzalloc(sizeof(struct w83791d_data), GFP_KERNEL))) {
 868                 err = -ENOMEM;
 869                 goto error0;
 870         }
 871
 872         client = &data->client;
 873         dev = &client->dev;
 874         i2c_set_clientdata(client, data);
 875         client->addr = address;
 876         client->adapter = adapter;
 877         client->driver = &w83791d_driver;
 878         mutex_init(&data->update_lock);
 879
 880         /* Now, we do the remaining detection. */
 881
 882         /* The w83791d may be stuck in some other bank than bank 0. This may
 883            make reading other information impossible. Specify a force=...
 884            parameter, and the Winbond will be reset to the right bank. */
 885         if (kind < 0) {
 886                 if (w83791d_read(client, W83791D_REG_CONFIG) & 0x80) {
 887                         dev_dbg(dev, "Detection failed at step 1\n");
 888                         goto error1;
 889                 }
 890                 val1 = w83791d_read(client, W83791D_REG_BANK);
 891                 val2 = w83791d_read(client, W83791D_REG_CHIPMAN);
 892                 /* Check for Winbond ID if in bank 0 */
 893                 if (!(val1 & 0x07)) {
 894                         /* yes it is Bank0 */
 895                         if (((!(val1 & 0x80)) && (val2 != 0xa3)) ||
 896                             ((val1 & 0x80) && (val2 != 0x5c))) {
 897                                 dev_dbg(dev, "Detection failed at step 2\n");
 898                                 goto error1;
 899                         }
 900                 }
 901                 /* If Winbond chip, address of chip and W83791D_REG_I2C_ADDR
 902                    should match */
 903                 if (w83791d_read(client, W83791D_REG_I2C_ADDR) != address) {
 904                         dev_dbg(dev, "Detection failed at step 3\n");
 905                         goto error1;
 906                 }
 907         }
 908
 909         /* We either have a force parameter or we have reason to
 910            believe it is a Winbond chip. Either way, we want bank 0 and
 911            Vendor ID high byte */
 912         val1 = w83791d_read(client, W83791D_REG_BANK) & 0x78;
 913         w83791d_write(client, W83791D_REG_BANK, val1 | 0x80);
 914
 915         /* Verify it is a Winbond w83791d */
 916         if (kind <= 0) {
 917                 /* get vendor ID */
 918                 val2 = w83791d_read(client, W83791D_REG_CHIPMAN);
 919                 if (val2 != 0x5c) {     /* the vendor is NOT Winbond */
 920                         dev_dbg(dev, "Detection failed at step 4\n");
 921                         goto error1;
 922                 }
 923                 val1 = w83791d_read(client, W83791D_REG_WCHIPID);
 924                 if (val1 == 0x71) {
 925                         kind = w83791d;
 926                 } else {
 927                         if (kind == 0)
 928                                 dev_warn(dev,
 929                                         "w83791d: Ignoring 'force' parameter "
 930                                         "for unknown chip at adapter %d, "
 931                                         "address 0x%02x\n",
 932                                         i2c_adapter_id(adapter), address);
 933                         goto error1;
 934                 }
 935         }
 936
 937         if (kind == w83791d) {
 938                 client_name = "w83791d";
 939         } else {
 940                 dev_err(dev, "w83791d: Internal error: unknown kind (%d)?!?",
 941                         kind);
 942                 goto error1;
 943         }
 944
 945 #ifdef DEBUG
 946         val1 = w83791d_read(client, W83791D_REG_DID_VID4);
 947         dev_dbg(dev, "Device ID version: %d.%d (0x%02x)\n",
 948                         (val1 >> 5) & 0x07, (val1 >> 1) & 0x0f, val1);
 949 #endif
 950
 951         /* Fill in the remaining client fields and put into the global list */
 952         strlcpy(client->name, client_name, I2C_NAME_SIZE);
 953
 954         /* Tell the I2C layer a new client has arrived */
 955         if ((err = i2c_attach_client(client)))
 956                 goto error1;
 957
 958         if ((err = w83791d_detect_subclients(adapter, address, kind, client)))
 959                 goto error2;
 960
 961         /* Initialize the chip */
 962         w83791d_init_client(client);
 963
 964         /* If the fan_div is changed, make sure there is a rational
 965            fan_min in place */
 966         for (i = 0; i < NUMBER_OF_FANIN; i++) {
 967                 data->fan_min[i] = w83791d_read(client, W83791D_REG_FAN_MIN[i]);
 968         }
 969
 970         /* Register sysfs hooks */
 971         data->class_dev = hwmon_device_register(dev);
 972         if (IS_ERR(data->class_dev)) {
 973                 err = PTR_ERR(data->class_dev);
 974                 goto error3;
 975         }
 976
 977         for (i = 0; i < NUMBER_OF_VIN; i++) {
 978                 device_create_file(dev, &sda_in_input[i].dev_attr);
 979                 device_create_file(dev, &sda_in_min[i].dev_attr);
 980                 device_create_file(dev, &sda_in_max[i].dev_attr);
 981         }
 982
 983         for (i = 0; i < NUMBER_OF_FANIN; i++) {
 984                 device_create_file(dev, &sda_fan_input[i].dev_attr);
 985                 device_create_file(dev, &sda_fan_div[i].dev_attr);
 986                 device_create_file(dev, &sda_fan_min[i].dev_attr);
 987         }
 988
 989         for (i = 0; i < NUMBER_OF_TEMPIN; i++) {
 990                 device_create_file(dev, &sda_temp_input[i].dev_attr);
 991                 device_create_file(dev, &sda_temp_max[i].dev_attr);
 992                 device_create_file(dev, &sda_temp_max_hyst[i].dev_attr);
 993         }
 994
 995         device_create_file(dev, &dev_attr_alarms);
 996
 997         for (i = 0; i < ARRAY_SIZE(sda_beep_ctrl); i++) {
 998                 device_create_file(dev, &sda_beep_ctrl[i].dev_attr);
 999         }
1000
1001         device_create_file(dev, &dev_attr_cpu0_vid);
1002         device_create_file(dev, &dev_attr_vrm);
1003
1004         return 0;
1005
1006 error3:
1007         if (data->lm75[0] != NULL) {
1008                 i2c_detach_client(data->lm75[0]);
1009                 kfree(data->lm75[0]);
1010         }
1011         if (data->lm75[1] != NULL) {
1012                 i2c_detach_client(data->lm75[1]);
1013                 kfree(data->lm75[1]);
1014         }
1015 error2:
1016         i2c_detach_client(client);
1017 error1:
1018         kfree(data);
1019 error0:
1020         return err;
1021 }
1022
1023 static int w83791d_detach_client(struct i2c_client *client)
1024 {
1025         struct w83791d_data *data = i2c_get_clientdata(client);
1026         int err;
1027
1028         /* main client */
1029         if (data)
1030                 hwmon_device_unregister(data->class_dev);
1031
1032         if ((err = i2c_detach_client(client)))
1033                 return err;
1034
1035         /* main client */
1036         if (data)
1037                 kfree(data);
1038         /* subclient */
1039         else
1040                 kfree(client);
1041
1042         return 0;
1043 }
1044
1045 static void w83791d_init_client(struct i2c_client *client)
1046 {
1047         struct w83791d_data *data = i2c_get_clientdata(client);
1048         u8 tmp;
1049         u8 old_beep;
1050
1051         /* The difference between reset and init is that reset
1052            does a hard reset of the chip via index 0x40, bit 7,
1053            but init simply forces certain registers to have "sane"
1054            values. The hope is that the BIOS has done the right
1055            thing (which is why the default is reset=0, init=0),
1056            but if not, reset is the hard hammer and init
1057            is the soft mallet both of which are trying to whack
1058            things into place...
1059            NOTE: The data sheet makes a distinction between
1060            "power on defaults" and "reset by MR". As far as I can tell,
1061            the hard reset puts everything into a power-on state so I'm
1062            not sure what "reset by MR" means or how it can happen.
1063            */
1064         if (reset || init) {
1065                 /* keep some BIOS settings when we... */
1066                 old_beep = w83791d_read(client, W83791D_REG_BEEP_CONFIG);
1067
1068                 if (reset) {
1069                         /* ... reset the chip and ... */
1070                         w83791d_write(client, W83791D_REG_CONFIG, 0x80);
1071                 }
1072
1073                 /* ... disable power-on abnormal beep */
1074                 w83791d_write(client, W83791D_REG_BEEP_CONFIG, old_beep | 0x80);
1075
1076                 /* disable the global beep (not done by hard reset) */
1077                 tmp = w83791d_read(client, W83791D_REG_BEEP_CTRL[1]);
1078                 w83791d_write(client, W83791D_REG_BEEP_CTRL[1], tmp & 0xef);
1079
1080                 if (init) {
1081                         /* Make sure monitoring is turned on for add-ons */
1082                         tmp = w83791d_read(client, W83791D_REG_TEMP2_CONFIG);
1083                         if (tmp & 1) {
1084                                 w83791d_write(client, W83791D_REG_TEMP2_CONFIG,
1085                                         tmp & 0xfe);
1086                         }
1087
1088                         tmp = w83791d_read(client, W83791D_REG_TEMP3_CONFIG);
1089                         if (tmp & 1) {
1090                                 w83791d_write(client, W83791D_REG_TEMP3_CONFIG,
1091                                         tmp & 0xfe);
1092                         }
1093
1094                         /* Start monitoring */
1095                         tmp = w83791d_read(client, W83791D_REG_CONFIG) & 0xf7;
1096                         w83791d_write(client, W83791D_REG_CONFIG, tmp | 0x01);
1097                 }
1098         }
1099
1100         data->vrm = vid_which_vrm();
1101 }
1102
1103 static struct w83791d_data *w83791d_update_device(struct device *dev)
1104 {
1105         struct i2c_client *client = to_i2c_client(dev);
1106         struct w83791d_data *data = i2c_get_clientdata(client);
1107         int i, j;
1108         u8 reg_array_tmp[3];
1109
1110         mutex_lock(&data->update_lock);
1111
1112         if (time_after(jiffies, data->last_updated + (HZ * 3))
1113                         || !data->valid) {
1114                 dev_dbg(dev, "Starting w83791d device update\n");
1115
1116                 /* Update the voltages measured value and limits */
1117                 for (i = 0; i < NUMBER_OF_VIN; i++) {
1118                         data->in[i] = w83791d_read(client,
1119                                                 W83791D_REG_IN[i]);
1120                         data->in_max[i] = w83791d_read(client,
1121                                                 W83791D_REG_IN_MAX[i]);
1122                         data->in_min[i] = w83791d_read(client,
1123                                                 W83791D_REG_IN_MIN[i]);
1124                 }
1125
1126                 /* Update the fan counts and limits */
1127                 for (i = 0; i < NUMBER_OF_FANIN; i++) {
1128                         /* Update the Fan measured value and limits */
1129                         data->fan[i] = w83791d_read(client,
1130                                                 W83791D_REG_FAN[i]);
1131                         data->fan_min[i] = w83791d_read(client,
1132                                                 W83791D_REG_FAN_MIN[i]);
1133                 }
1134
1135                 /* Update the fan divisor */
1136                 for (i = 0; i < 3; i++) {
1137                         reg_array_tmp[i] = w83791d_read(client,
1138                                                 W83791D_REG_FAN_DIV[i]);
1139                 }
1140                 data->fan_div[0] = (reg_array_tmp[0] >> 4) & 0x03;
1141                 data->fan_div[1] = (reg_array_tmp[0] >> 6) & 0x03;
1142                 data->fan_div[2] = (reg_array_tmp[1] >> 6) & 0x03;
1143                 data->fan_div[3] = reg_array_tmp[2] & 0x07;
1144                 data->fan_div[4] = (reg_array_tmp[2] >> 4) & 0x07;
1145
1146                 /* Update the first temperature sensor */
1147                 for (i = 0; i < 3; i++) {
1148                         data->temp1[i] = w83791d_read(client,
1149                                                 W83791D_REG_TEMP1[i]);
1150                 }
1151
1152                 /* Update the rest of the temperature sensors */
1153                 for (i = 0; i < 2; i++) {
1154                         for (j = 0; j < 3; j++) {
1155                                 data->temp_add[i][j] =
1156                                         (w83791d_read(client,
1157                                         W83791D_REG_TEMP_ADD[i][j * 2]) << 8) |
1158                                         w83791d_read(client,
1159                                         W83791D_REG_TEMP_ADD[i][j * 2 + 1]);
1160                         }
1161                 }
1162
1163                 /* Update the realtime status */
1164                 data->alarms =
1165                         w83791d_read(client, W83791D_REG_ALARM1) +
1166                         (w83791d_read(client, W83791D_REG_ALARM2) << 8) +
1167                         (w83791d_read(client, W83791D_REG_ALARM3) << 16);
1168
1169                 /* Update the beep configuration information */
1170                 data->beep_mask =
1171                         w83791d_read(client, W83791D_REG_BEEP_CTRL[0]) +
1172                         (w83791d_read(client, W83791D_REG_BEEP_CTRL[1]) << 8) +
1173                         (w83791d_read(client, W83791D_REG_BEEP_CTRL[2]) << 16);
1174
1175                 data->beep_enable =
1176                         (data->beep_mask >> GLOBAL_BEEP_ENABLE_SHIFT) & 0x01;
1177
1178                 /* Update the cpu voltage information */
1179                 i = w83791d_read(client, W83791D_REG_VID_FANDIV);
1180                 data->vid = i & 0x0f;
1181                 data->vid |= (w83791d_read(client, W83791D_REG_DID_VID4) & 0x01)
1182                                 << 4;
1183
1184                 data->last_updated = jiffies;
1185                 data->valid = 1;
1186         }
1187
1188         mutex_unlock(&data->update_lock);
1189
1190 #ifdef DEBUG
1191         w83791d_print_debug(data, dev);
1192 #endif
1193
1194         return data;
1195 }
1196
1197 #ifdef DEBUG
1198 static void w83791d_print_debug(struct w83791d_data *data, struct device *dev)
1199 {
1200         int i = 0, j = 0;
1201
1202         dev_dbg(dev, "======Start of w83791d debug values======\n");
1203         dev_dbg(dev, "%d set of Voltages: ===>\n", NUMBER_OF_VIN);
1204         for (i = 0; i < NUMBER_OF_VIN; i++) {
1205                 dev_dbg(dev, "vin[%d] is:     0x%02x\n", i, data->in[i]);
1206                 dev_dbg(dev, "vin[%d] min is: 0x%02x\n", i, data->in_min[i]);
1207                 dev_dbg(dev, "vin[%d] max is: 0x%02x\n", i, data->in_max[i]);
1208         }
1209         dev_dbg(dev, "%d set of Fan Counts/Divisors: ===>\n", NUMBER_OF_FANIN);
1210         for (i = 0; i < NUMBER_OF_FANIN; i++) {
1211                 dev_dbg(dev, "fan[%d] is:     0x%02x\n", i, data->fan[i]);
1212                 dev_dbg(dev, "fan[%d] min is: 0x%02x\n", i, data->fan_min[i]);
1213                 dev_dbg(dev, "fan_div[%d] is: 0x%02x\n", i, data->fan_div[i]);
1214         }
1215
1216         /* temperature math is signed, but only print out the
1217            bits that matter */
1218         dev_dbg(dev, "%d set of Temperatures: ===>\n", NUMBER_OF_TEMPIN);
1219         for (i = 0; i < 3; i++) {
1220                 dev_dbg(dev, "temp1[%d] is: 0x%02x\n", i, (u8) data->temp1[i]);
1221         }
1222         for (i = 0; i < 2; i++) {
1223                 for (j = 0; j < 3; j++) {
1224                         dev_dbg(dev, "temp_add[%d][%d] is: 0x%04x\n", i, j,
1225                                 (u16) data->temp_add[i][j]);
1226                 }
1227         }
1228
1229         dev_dbg(dev, "Misc Information: ===>\n");
1230         dev_dbg(dev, "alarm is:     0x%08x\n", data->alarms);
1231         dev_dbg(dev, "beep_mask is: 0x%08x\n", data->beep_mask);
1232         dev_dbg(dev, "beep_enable is: %d\n", data->beep_enable);
1233         dev_dbg(dev, "vid is: 0x%02x\n", data->vid);
1234         dev_dbg(dev, "vrm is: 0x%02x\n", data->vrm);
1235         dev_dbg(dev, "=======End of w83791d debug values========\n");
1236         dev_dbg(dev, "\n");
1237 }
1238 #endif
1239
1240 static int __init sensors_w83791d_init(void)
1241 {
1242         return i2c_add_driver(&w83791d_driver);
1243 }
1244
1245 static void __exit sensors_w83791d_exit(void)
1246 {
1247         i2c_del_driver(&w83791d_driver);
1248 }
1249
1250 MODULE_AUTHOR("Charles Spirakis <bezaur@gmail.com>");
1251 MODULE_DESCRIPTION("W83791D driver");
1252 MODULE_LICENSE("GPL");
1253
1254 module_init(sensors_w83791d_init);
1255 module_exit(sensors_w83791d_exit);