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