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

   1 /*
   2     w83791d.c - Part of lm_sensors, Linux kernel modules for hardware
   3                 monitoring
   4
   5     Copyright (C) 2006-2007 Charles Spirakis <bezaur@gmail.com>
   6
   7     This program is free software; you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License as published by
   9     the Free Software Foundation; either version 2 of the License, or
  10     (at your option) any later version.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with this program; if not, write to the Free Software
  19     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 /*
  23     Supports following chips:
  24
  25     Chip        #vin    #fanin  #pwm    #temp   wchipid vendid  i2c     ISA
  26     w83791d     10      5       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 const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f,
  51                                                 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
 237         /* fan divisors max out at 128 */
 238         val = SENSORS_LIMIT(val, 1, 128) >> 1;
 239         for (i = 0; i < 7; i++) {
 240                 if (val == 0)
 241                         break;
 242                 val >>= 1;
 243         }
 244         return (u8) i;
 245 }
 246
 247 struct w83791d_data {
 248         struct device *hwmon_dev;
 249         struct mutex update_lock;
 250
 251         char valid;                     /* !=0 if following fields are valid */
 252         unsigned long last_updated;     /* In jiffies */
 253
 254         /* array of 2 pointers to subclients */
 255         struct i2c_client *lm75[2];
 256
 257         /* volts */
 258         u8 in[NUMBER_OF_VIN];           /* Register value */
 259         u8 in_max[NUMBER_OF_VIN];       /* Register value */
 260         u8 in_min[NUMBER_OF_VIN];       /* Register value */
 261
 262         /* fans */
 263         u8 fan[NUMBER_OF_FANIN];        /* Register value */
 264         u8 fan_min[NUMBER_OF_FANIN];    /* Register value */
 265         u8 fan_div[NUMBER_OF_FANIN];    /* Register encoding, shifted right */
 266
 267         /* Temperature sensors */
 268
 269         s8 temp1[3];            /* current, over, thyst */
 270         s16 temp_add[2][3];     /* fixed point value. Top 8 bits are the
 271                                    integral part, bottom 8 bits are the
 272                                    fractional part. We only use the top
 273                                    9 bits as the resolution is only
 274                                    to the 0.5 degree C...
 275                                    two sensors with three values
 276                                    (cur, over, hyst)  */
 277
 278         /* Misc */
 279         u32 alarms;             /* realtime status register encoding,combined */
 280         u8 beep_enable;         /* Global beep enable */
 281         u32 beep_mask;          /* Mask off specific beeps */
 282         u8 vid;                 /* Register encoding, combined */
 283         u8 vrm;                 /* hwmon-vid */
 284 };
 285
 286 static int w83791d_probe(struct i2c_client *client,
 287                          const struct i2c_device_id *id);
 288 static int w83791d_detect(struct i2c_client *client, int kind,
 289                           struct i2c_board_info *info);
 290 static int w83791d_remove(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 const struct i2c_device_id w83791d_id[] = {
 303         { "w83791d", w83791d },
 304         { }
 305 };
 306 MODULE_DEVICE_TABLE(i2c, w83791d_id);
 307
 308 static struct i2c_driver w83791d_driver = {
 309         .class          = I2C_CLASS_HWMON,
 310         .driver = {
 311                 .name = "w83791d",
 312         },
 313         .probe          = w83791d_probe,
 314         .remove         = w83791d_remove,
 315         .id_table       = w83791d_id,
 316         .detect         = w83791d_detect,
 317         .address_data   = &addr_data,
 318 };
 319
 320 /* following are the sysfs callback functions */
 321 #define show_in_reg(reg) \
 322 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
 323                         char *buf) \
 324 { \
 325         struct sensor_device_attribute *sensor_attr = \
 326                                                 to_sensor_dev_attr(attr); \
 327         struct w83791d_data *data = w83791d_update_device(dev); \
 328         int nr = sensor_attr->index; \
 329         return sprintf(buf,"%d\n", IN_FROM_REG(data->reg[nr])); \
 330 }
 331
 332 show_in_reg(in);
 333 show_in_reg(in_min);
 334 show_in_reg(in_max);
 335
 336 #define store_in_reg(REG, reg) \
 337 static ssize_t store_in_##reg(struct device *dev, \
 338                                 struct device_attribute *attr, \
 339                                 const char *buf, size_t count) \
 340 { \
 341         struct sensor_device_attribute *sensor_attr = \
 342                                                 to_sensor_dev_attr(attr); \
 343         struct i2c_client *client = to_i2c_client(dev); \
 344         struct w83791d_data *data = i2c_get_clientdata(client); \
 345         unsigned long val = simple_strtoul(buf, NULL, 10); \
 346         int nr = sensor_attr->index; \
 347          \
 348         mutex_lock(&data->update_lock); \
 349         data->in_##reg[nr] = IN_TO_REG(val); \
 350         w83791d_write(client, W83791D_REG_IN_##REG[nr], data->in_##reg[nr]); \
 351         mutex_unlock(&data->update_lock); \
 352          \
 353         return count; \
 354 }
 355 store_in_reg(MIN, min);
 356 store_in_reg(MAX, max);
 357
 358 static struct sensor_device_attribute sda_in_input[] = {
 359         SENSOR_ATTR(in0_input, S_IRUGO, show_in, NULL, 0),
 360         SENSOR_ATTR(in1_input, S_IRUGO, show_in, NULL, 1),
 361         SENSOR_ATTR(in2_input, S_IRUGO, show_in, NULL, 2),
 362         SENSOR_ATTR(in3_input, S_IRUGO, show_in, NULL, 3),
 363         SENSOR_ATTR(in4_input, S_IRUGO, show_in, NULL, 4),
 364         SENSOR_ATTR(in5_input, S_IRUGO, show_in, NULL, 5),
 365         SENSOR_ATTR(in6_input, S_IRUGO, show_in, NULL, 6),
 366         SENSOR_ATTR(in7_input, S_IRUGO, show_in, NULL, 7),
 367         SENSOR_ATTR(in8_input, S_IRUGO, show_in, NULL, 8),
 368         SENSOR_ATTR(in9_input, S_IRUGO, show_in, NULL, 9),
 369 };
 370
 371 static struct sensor_device_attribute sda_in_min[] = {
 372         SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 0),
 373         SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 1),
 374         SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 2),
 375         SENSOR_ATTR(in3_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 3),
 376         SENSOR_ATTR(in4_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 4),
 377         SENSOR_ATTR(in5_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 5),
 378         SENSOR_ATTR(in6_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 6),
 379         SENSOR_ATTR(in7_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 7),
 380         SENSOR_ATTR(in8_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 8),
 381         SENSOR_ATTR(in9_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 9),
 382 };
 383
 384 static struct sensor_device_attribute sda_in_max[] = {
 385         SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 0),
 386         SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 1),
 387         SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 2),
 388         SENSOR_ATTR(in3_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 3),
 389         SENSOR_ATTR(in4_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 4),
 390         SENSOR_ATTR(in5_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 5),
 391         SENSOR_ATTR(in6_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 6),
 392         SENSOR_ATTR(in7_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 7),
 393         SENSOR_ATTR(in8_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 8),
 394         SENSOR_ATTR(in9_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 9),
 395 };
 396
 397
 398 static ssize_t show_beep(struct device *dev, struct device_attribute *attr,
 399                         char *buf)
 400 {
 401         struct sensor_device_attribute *sensor_attr =
 402                                                 to_sensor_dev_attr(attr);
 403         struct w83791d_data *data = w83791d_update_device(dev);
 404         int bitnr = sensor_attr->index;
 405
 406         return sprintf(buf, "%d\n", (data->beep_mask >> bitnr) & 1);
 407 }
 408
 409 static ssize_t store_beep(struct device *dev, struct device_attribute *attr,
 410                         const char *buf, size_t count)
 411 {
 412         struct sensor_device_attribute *sensor_attr =
 413                                                 to_sensor_dev_attr(attr);
 414         struct i2c_client *client = to_i2c_client(dev);
 415         struct w83791d_data *data = i2c_get_clientdata(client);
 416         int bitnr = sensor_attr->index;
 417         int bytenr = bitnr / 8;
 418         long val = simple_strtol(buf, NULL, 10) ? 1 : 0;
 419
 420         mutex_lock(&data->update_lock);
 421
 422         data->beep_mask &= ~(0xff << (bytenr * 8));
 423         data->beep_mask |= w83791d_read(client, W83791D_REG_BEEP_CTRL[bytenr])
 424                 << (bytenr * 8);
 425
 426         data->beep_mask &= ~(1 << bitnr);
 427         data->beep_mask |= val << bitnr;
 428
 429         w83791d_write(client, W83791D_REG_BEEP_CTRL[bytenr],
 430                 (data->beep_mask >> (bytenr * 8)) & 0xff);
 431
 432         mutex_unlock(&data->update_lock);
 433
 434         return count;
 435 }
 436
 437 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
 438                         char *buf)
 439 {
 440         struct sensor_device_attribute *sensor_attr =
 441                                                 to_sensor_dev_attr(attr);
 442         struct w83791d_data *data = w83791d_update_device(dev);
 443         int bitnr = sensor_attr->index;
 444
 445         return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1);
 446 }
 447
 448 /* Note: The bitmask for the beep enable/disable is different than
 449    the bitmask for the alarm. */
 450 static struct sensor_device_attribute sda_in_beep[] = {
 451         SENSOR_ATTR(in0_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 0),
 452         SENSOR_ATTR(in1_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 13),
 453         SENSOR_ATTR(in2_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 2),
 454         SENSOR_ATTR(in3_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 3),
 455         SENSOR_ATTR(in4_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 8),
 456         SENSOR_ATTR(in5_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 9),
 457         SENSOR_ATTR(in6_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 10),
 458         SENSOR_ATTR(in7_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 16),
 459         SENSOR_ATTR(in8_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 17),
 460         SENSOR_ATTR(in9_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 14),
 461 };
 462
 463 static struct sensor_device_attribute sda_in_alarm[] = {
 464         SENSOR_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0),
 465         SENSOR_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1),
 466         SENSOR_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2),
 467         SENSOR_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3),
 468         SENSOR_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8),
 469         SENSOR_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9),
 470         SENSOR_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 10),
 471         SENSOR_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 19),
 472         SENSOR_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 20),
 473         SENSOR_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL, 14),
 474 };
 475
 476 #define show_fan_reg(reg) \
 477 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
 478                                 char *buf) \
 479 { \
 480         struct sensor_device_attribute *sensor_attr = \
 481                                                 to_sensor_dev_attr(attr); \
 482         struct w83791d_data *data = w83791d_update_device(dev); \
 483         int nr = sensor_attr->index; \
 484         return sprintf(buf,"%d\n", \
 485                 FAN_FROM_REG(data->reg[nr], DIV_FROM_REG(data->fan_div[nr]))); \
 486 }
 487
 488 show_fan_reg(fan);
 489 show_fan_reg(fan_min);
 490
 491 static ssize_t store_fan_min(struct device *dev, struct device_attribute *attr,
 492                                 const char *buf, size_t count)
 493 {
 494         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 495         struct i2c_client *client = to_i2c_client(dev);
 496         struct w83791d_data *data = i2c_get_clientdata(client);
 497         unsigned long val = simple_strtoul(buf, NULL, 10);
 498         int nr = sensor_attr->index;
 499
 500         mutex_lock(&data->update_lock);
 501         data->fan_min[nr] = fan_to_reg(val, DIV_FROM_REG(data->fan_div[nr]));
 502         w83791d_write(client, W83791D_REG_FAN_MIN[nr], data->fan_min[nr]);
 503         mutex_unlock(&data->update_lock);
 504
 505         return count;
 506 }
 507
 508 static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr,
 509                                 char *buf)
 510 {
 511         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 512         int nr = sensor_attr->index;
 513         struct w83791d_data *data = w83791d_update_device(dev);
 514         return sprintf(buf, "%u\n", DIV_FROM_REG(data->fan_div[nr]));
 515 }
 516
 517 /* Note: we save and restore the fan minimum here, because its value is
 518    determined in part by the fan divisor.  This follows the principle of
 519    least suprise; the user doesn't expect the fan minimum to change just
 520    because the divisor changed. */
 521 static ssize_t store_fan_div(struct device *dev, struct device_attribute *attr,
 522                                 const char *buf, size_t count)
 523 {
 524         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 525         struct i2c_client *client = to_i2c_client(dev);
 526         struct w83791d_data *data = i2c_get_clientdata(client);
 527         int nr = sensor_attr->index;
 528         unsigned long min;
 529         u8 tmp_fan_div;
 530         u8 fan_div_reg;
 531         u8 vbat_reg;
 532         int indx = 0;
 533         u8 keep_mask = 0;
 534         u8 new_shift = 0;
 535
 536         /* Save fan_min */
 537         min = FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr]));
 538
 539         mutex_lock(&data->update_lock);
 540         data->fan_div[nr] = div_to_reg(nr, simple_strtoul(buf, NULL, 10));
 541
 542         switch (nr) {
 543         case 0:
 544                 indx = 0;
 545                 keep_mask = 0xcf;
 546                 new_shift = 4;
 547                 break;
 548         case 1:
 549                 indx = 0;
 550                 keep_mask = 0x3f;
 551                 new_shift = 6;
 552                 break;
 553         case 2:
 554                 indx = 1;
 555                 keep_mask = 0x3f;
 556                 new_shift = 6;
 557                 break;
 558         case 3:
 559                 indx = 2;
 560                 keep_mask = 0xf8;
 561                 new_shift = 0;
 562                 break;
 563         case 4:
 564                 indx = 2;
 565                 keep_mask = 0x8f;
 566                 new_shift = 4;
 567                 break;
 568 #ifdef DEBUG
 569         default:
 570                 dev_warn(dev, "store_fan_div: Unexpected nr seen: %d\n", nr);
 571                 count = -EINVAL;
 572                 goto err_exit;
 573 #endif
 574         }
 575
 576         fan_div_reg = w83791d_read(client, W83791D_REG_FAN_DIV[indx])
 577                         & keep_mask;
 578         tmp_fan_div = (data->fan_div[nr] << new_shift) & ~keep_mask;
 579
 580         w83791d_write(client, W83791D_REG_FAN_DIV[indx],
 581                                 fan_div_reg | tmp_fan_div);
 582
 583         /* Bit 2 of fans 0-2 is stored in the vbat register (bits 5-7) */
 584         if (nr < 3) {
 585                 keep_mask = ~(1 << (nr + 5));
 586                 vbat_reg = w83791d_read(client, W83791D_REG_VBAT)
 587                                 & keep_mask;
 588                 tmp_fan_div = (data->fan_div[nr] << (3 + nr)) & ~keep_mask;
 589                 w83791d_write(client, W83791D_REG_VBAT,
 590                                 vbat_reg | tmp_fan_div);
 591         }
 592
 593         /* Restore fan_min */
 594         data->fan_min[nr] = fan_to_reg(min, DIV_FROM_REG(data->fan_div[nr]));
 595         w83791d_write(client, W83791D_REG_FAN_MIN[nr], data->fan_min[nr]);
 596
 597 #ifdef DEBUG
 598 err_exit:
 599 #endif
 600         mutex_unlock(&data->update_lock);
 601
 602         return count;
 603 }
 604
 605 static struct sensor_device_attribute sda_fan_input[] = {
 606         SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0),
 607         SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1),
 608         SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2),
 609         SENSOR_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3),
 610         SENSOR_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4),
 611 };
 612
 613 static struct sensor_device_attribute sda_fan_min[] = {
 614         SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO,
 615                         show_fan_min, store_fan_min, 0),
 616         SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO,
 617                         show_fan_min, store_fan_min, 1),
 618         SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO,
 619                         show_fan_min, store_fan_min, 2),
 620         SENSOR_ATTR(fan4_min, S_IWUSR | S_IRUGO,
 621                         show_fan_min, store_fan_min, 3),
 622         SENSOR_ATTR(fan5_min, S_IWUSR | S_IRUGO,
 623                         show_fan_min, store_fan_min, 4),
 624 };
 625
 626 static struct sensor_device_attribute sda_fan_div[] = {
 627         SENSOR_ATTR(fan1_div, S_IWUSR | S_IRUGO,
 628                         show_fan_div, store_fan_div, 0),
 629         SENSOR_ATTR(fan2_div, S_IWUSR | S_IRUGO,
 630                         show_fan_div, store_fan_div, 1),
 631         SENSOR_ATTR(fan3_div, S_IWUSR | S_IRUGO,
 632                         show_fan_div, store_fan_div, 2),
 633         SENSOR_ATTR(fan4_div, S_IWUSR | S_IRUGO,
 634                         show_fan_div, store_fan_div, 3),
 635         SENSOR_ATTR(fan5_div, S_IWUSR | S_IRUGO,
 636                         show_fan_div, store_fan_div, 4),
 637 };
 638
 639 static struct sensor_device_attribute sda_fan_beep[] = {
 640         SENSOR_ATTR(fan1_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 6),
 641         SENSOR_ATTR(fan2_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 7),
 642         SENSOR_ATTR(fan3_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 11),
 643         SENSOR_ATTR(fan4_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 21),
 644         SENSOR_ATTR(fan5_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 22),
 645 };
 646
 647 static struct sensor_device_attribute sda_fan_alarm[] = {
 648         SENSOR_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6),
 649         SENSOR_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7),
 650         SENSOR_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11),
 651         SENSOR_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 21),
 652         SENSOR_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 22),
 653 };
 654
 655 /* read/write the temperature1, includes measured value and limits */
 656 static ssize_t show_temp1(struct device *dev, struct device_attribute *devattr,
 657                                 char *buf)
 658 {
 659         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 660         struct w83791d_data *data = w83791d_update_device(dev);
 661         return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp1[attr->index]));
 662 }
 663
 664 static ssize_t store_temp1(struct device *dev, struct device_attribute *devattr,
 665                                 const char *buf, size_t count)
 666 {
 667         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 668         struct i2c_client *client = to_i2c_client(dev);
 669         struct w83791d_data *data = i2c_get_clientdata(client);
 670         long val = simple_strtol(buf, NULL, 10);
 671         int nr = attr->index;
 672
 673         mutex_lock(&data->update_lock);
 674         data->temp1[nr] = TEMP1_TO_REG(val);
 675         w83791d_write(client, W83791D_REG_TEMP1[nr], data->temp1[nr]);
 676         mutex_unlock(&data->update_lock);
 677         return count;
 678 }
 679
 680 /* read/write temperature2-3, includes measured value and limits */
 681 static ssize_t show_temp23(struct device *dev, struct device_attribute *devattr,
 682                                 char *buf)
 683 {
 684         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 685         struct w83791d_data *data = w83791d_update_device(dev);
 686         int nr = attr->nr;
 687         int index = attr->index;
 688         return sprintf(buf, "%d\n", TEMP23_FROM_REG(data->temp_add[nr][index]));
 689 }
 690
 691 static ssize_t store_temp23(struct device *dev,
 692                                 struct device_attribute *devattr,
 693                                 const char *buf, size_t count)
 694 {
 695         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 696         struct i2c_client *client = to_i2c_client(dev);
 697         struct w83791d_data *data = i2c_get_clientdata(client);
 698         long val = simple_strtol(buf, NULL, 10);
 699         int nr = attr->nr;
 700         int index = attr->index;
 701
 702         mutex_lock(&data->update_lock);
 703         data->temp_add[nr][index] = TEMP23_TO_REG(val);
 704         w83791d_write(client, W83791D_REG_TEMP_ADD[nr][index * 2],
 705                                 data->temp_add[nr][index] >> 8);
 706         w83791d_write(client, W83791D_REG_TEMP_ADD[nr][index * 2 + 1],
 707                                 data->temp_add[nr][index] & 0x80);
 708         mutex_unlock(&data->update_lock);
 709
 710         return count;
 711 }
 712
 713 static struct sensor_device_attribute_2 sda_temp_input[] = {
 714         SENSOR_ATTR_2(temp1_input, S_IRUGO, show_temp1, NULL, 0, 0),
 715         SENSOR_ATTR_2(temp2_input, S_IRUGO, show_temp23, NULL, 0, 0),
 716         SENSOR_ATTR_2(temp3_input, S_IRUGO, show_temp23, NULL, 1, 0),
 717 };
 718
 719 static struct sensor_device_attribute_2 sda_temp_max[] = {
 720         SENSOR_ATTR_2(temp1_max, S_IRUGO | S_IWUSR,
 721                         show_temp1, store_temp1, 0, 1),
 722         SENSOR_ATTR_2(temp2_max, S_IRUGO | S_IWUSR,
 723                         show_temp23, store_temp23, 0, 1),
 724         SENSOR_ATTR_2(temp3_max, S_IRUGO | S_IWUSR,
 725                         show_temp23, store_temp23, 1, 1),
 726 };
 727
 728 static struct sensor_device_attribute_2 sda_temp_max_hyst[] = {
 729         SENSOR_ATTR_2(temp1_max_hyst, S_IRUGO | S_IWUSR,
 730                         show_temp1, store_temp1, 0, 2),
 731         SENSOR_ATTR_2(temp2_max_hyst, S_IRUGO | S_IWUSR,
 732                         show_temp23, store_temp23, 0, 2),
 733         SENSOR_ATTR_2(temp3_max_hyst, S_IRUGO | S_IWUSR,
 734                         show_temp23, store_temp23, 1, 2),
 735 };
 736
 737 /* Note: The bitmask for the beep enable/disable is different than
 738    the bitmask for the alarm. */
 739 static struct sensor_device_attribute sda_temp_beep[] = {
 740         SENSOR_ATTR(temp1_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 4),
 741         SENSOR_ATTR(temp2_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 5),
 742         SENSOR_ATTR(temp3_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 1),
 743 };
 744
 745 static struct sensor_device_attribute sda_temp_alarm[] = {
 746         SENSOR_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4),
 747         SENSOR_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5),
 748         SENSOR_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13),
 749 };
 750
 751 /* get reatime status of all sensors items: voltage, temp, fan */
 752 static ssize_t show_alarms_reg(struct device *dev,
 753                                 struct device_attribute *attr, char *buf)
 754 {
 755         struct w83791d_data *data = w83791d_update_device(dev);
 756         return sprintf(buf, "%u\n", data->alarms);
 757 }
 758
 759 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
 760
 761 /* Beep control */
 762
 763 #define GLOBAL_BEEP_ENABLE_SHIFT        15
 764 #define GLOBAL_BEEP_ENABLE_MASK         (1 << GLOBAL_BEEP_ENABLE_SHIFT)
 765
 766 static ssize_t show_beep_enable(struct device *dev,
 767                                 struct device_attribute *attr, char *buf)
 768 {
 769         struct w83791d_data *data = w83791d_update_device(dev);
 770         return sprintf(buf, "%d\n", data->beep_enable);
 771 }
 772
 773 static ssize_t show_beep_mask(struct device *dev,
 774                                 struct device_attribute *attr, char *buf)
 775 {
 776         struct w83791d_data *data = w83791d_update_device(dev);
 777         return sprintf(buf, "%d\n", BEEP_MASK_FROM_REG(data->beep_mask));
 778 }
 779
 780
 781 static ssize_t store_beep_mask(struct device *dev,
 782                                 struct device_attribute *attr,
 783                                 const char *buf, size_t count)
 784 {
 785         struct i2c_client *client = to_i2c_client(dev);
 786         struct w83791d_data *data = i2c_get_clientdata(client);
 787         long val = simple_strtol(buf, NULL, 10);
 788         int i;
 789
 790         mutex_lock(&data->update_lock);
 791
 792         /* The beep_enable state overrides any enabling request from
 793            the masks */
 794         data->beep_mask = BEEP_MASK_TO_REG(val) & ~GLOBAL_BEEP_ENABLE_MASK;
 795         data->beep_mask |= (data->beep_enable << GLOBAL_BEEP_ENABLE_SHIFT);
 796
 797         val = data->beep_mask;
 798
 799         for (i = 0; i < 3; i++) {
 800                 w83791d_write(client, W83791D_REG_BEEP_CTRL[i], (val & 0xff));
 801                 val >>= 8;
 802         }
 803
 804         mutex_unlock(&data->update_lock);
 805
 806         return count;
 807 }
 808
 809 static ssize_t store_beep_enable(struct device *dev,
 810                                 struct device_attribute *attr,
 811                                 const char *buf, size_t count)
 812 {
 813         struct i2c_client *client = to_i2c_client(dev);
 814         struct w83791d_data *data = i2c_get_clientdata(client);
 815         long val = simple_strtol(buf, NULL, 10);
 816
 817         mutex_lock(&data->update_lock);
 818
 819         data->beep_enable = val ? 1 : 0;
 820
 821         /* Keep the full mask value in sync with the current enable */
 822         data->beep_mask &= ~GLOBAL_BEEP_ENABLE_MASK;
 823         data->beep_mask |= (data->beep_enable << GLOBAL_BEEP_ENABLE_SHIFT);
 824
 825         /* The global control is in the second beep control register
 826            so only need to update that register */
 827         val = (data->beep_mask >> 8) & 0xff;
 828
 829         w83791d_write(client, W83791D_REG_BEEP_CTRL[1], val);
 830
 831         mutex_unlock(&data->update_lock);
 832
 833         return count;
 834 }
 835
 836 static struct sensor_device_attribute sda_beep_ctrl[] = {
 837         SENSOR_ATTR(beep_enable, S_IRUGO | S_IWUSR,
 838                         show_beep_enable, store_beep_enable, 0),
 839         SENSOR_ATTR(beep_mask, S_IRUGO | S_IWUSR,
 840                         show_beep_mask, store_beep_mask, 1)
 841 };
 842
 843 /* cpu voltage regulation information */
 844 static ssize_t show_vid_reg(struct device *dev,
 845                                 struct device_attribute *attr, char *buf)
 846 {
 847         struct w83791d_data *data = w83791d_update_device(dev);
 848         return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
 849 }
 850
 851 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
 852
 853 static ssize_t show_vrm_reg(struct device *dev,
 854                                 struct device_attribute *attr, char *buf)
 855 {
 856         struct w83791d_data *data = dev_get_drvdata(dev);
 857         return sprintf(buf, "%d\n", data->vrm);
 858 }
 859
 860 static ssize_t store_vrm_reg(struct device *dev,
 861                                 struct device_attribute *attr,
 862                                 const char *buf, size_t count)
 863 {
 864         struct w83791d_data *data = dev_get_drvdata(dev);
 865
 866         /* No lock needed as vrm is internal to the driver
 867            (not read from a chip register) and so is not
 868            updated in w83791d_update_device() */
 869         data->vrm = simple_strtoul(buf, NULL, 10);
 870
 871         return count;
 872 }
 873
 874 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
 875
 876 #define IN_UNIT_ATTRS(X) \
 877         &sda_in_input[X].dev_attr.attr, \
 878         &sda_in_min[X].dev_attr.attr,   \
 879         &sda_in_max[X].dev_attr.attr,   \
 880         &sda_in_beep[X].dev_attr.attr,  \
 881         &sda_in_alarm[X].dev_attr.attr
 882
 883 #define FAN_UNIT_ATTRS(X) \
 884         &sda_fan_input[X].dev_attr.attr,        \
 885         &sda_fan_min[X].dev_attr.attr,          \
 886         &sda_fan_div[X].dev_attr.attr,          \
 887         &sda_fan_beep[X].dev_attr.attr,         \
 888         &sda_fan_alarm[X].dev_attr.attr
 889
 890 #define TEMP_UNIT_ATTRS(X) \
 891         &sda_temp_input[X].dev_attr.attr,       \
 892         &sda_temp_max[X].dev_attr.attr,         \
 893         &sda_temp_max_hyst[X].dev_attr.attr,    \
 894         &sda_temp_beep[X].dev_attr.attr,        \
 895         &sda_temp_alarm[X].dev_attr.attr
 896
 897 static struct attribute *w83791d_attributes[] = {
 898         IN_UNIT_ATTRS(0),
 899         IN_UNIT_ATTRS(1),
 900         IN_UNIT_ATTRS(2),
 901         IN_UNIT_ATTRS(3),
 902         IN_UNIT_ATTRS(4),
 903         IN_UNIT_ATTRS(5),
 904         IN_UNIT_ATTRS(6),
 905         IN_UNIT_ATTRS(7),
 906         IN_UNIT_ATTRS(8),
 907         IN_UNIT_ATTRS(9),
 908         FAN_UNIT_ATTRS(0),
 909         FAN_UNIT_ATTRS(1),
 910         FAN_UNIT_ATTRS(2),
 911         FAN_UNIT_ATTRS(3),
 912         FAN_UNIT_ATTRS(4),
 913         TEMP_UNIT_ATTRS(0),
 914         TEMP_UNIT_ATTRS(1),
 915         TEMP_UNIT_ATTRS(2),
 916         &dev_attr_alarms.attr,
 917         &sda_beep_ctrl[0].dev_attr.attr,
 918         &sda_beep_ctrl[1].dev_attr.attr,
 919         &dev_attr_cpu0_vid.attr,
 920         &dev_attr_vrm.attr,
 921         NULL
 922 };
 923
 924 static const struct attribute_group w83791d_group = {
 925         .attrs = w83791d_attributes,
 926 };
 927
 928
 929 static int w83791d_detect_subclients(struct i2c_client *client)
 930 {
 931         struct i2c_adapter *adapter = client->adapter;
 932         struct w83791d_data *data = i2c_get_clientdata(client);
 933         int address = client->addr;
 934         int i, id, err;
 935         u8 val;
 936
 937         id = i2c_adapter_id(adapter);
 938         if (force_subclients[0] == id && force_subclients[1] == address) {
 939                 for (i = 2; i <= 3; i++) {
 940                         if (force_subclients[i] < 0x48 ||
 941                             force_subclients[i] > 0x4f) {
 942                                 dev_err(&client->dev,
 943                                         "invalid subclient "
 944                                         "address %d; must be 0x48-0x4f\n",
 945                                         force_subclients[i]);
 946                                 err = -ENODEV;
 947                                 goto error_sc_0;
 948                         }
 949                 }
 950                 w83791d_write(client, W83791D_REG_I2C_SUBADDR,
 951                                         (force_subclients[2] & 0x07) |
 952                                         ((force_subclients[3] & 0x07) << 4));
 953         }
 954
 955         val = w83791d_read(client, W83791D_REG_I2C_SUBADDR);
 956         if (!(val & 0x08)) {
 957                 data->lm75[0] = i2c_new_dummy(adapter, 0x48 + (val & 0x7));
 958         }
 959         if (!(val & 0x80)) {
 960                 if ((data->lm75[0] != NULL) &&
 961                                 ((val & 0x7) == ((val >> 4) & 0x7))) {
 962                         dev_err(&client->dev,
 963                                 "duplicate addresses 0x%x, "
 964                                 "use force_subclient\n",
 965                                 data->lm75[0]->addr);
 966                         err = -ENODEV;
 967                         goto error_sc_1;
 968                 }
 969                 data->lm75[1] = i2c_new_dummy(adapter,
 970                                               0x48 + ((val >> 4) & 0x7));
 971         }
 972
 973         return 0;
 974
 975 /* Undo inits in case of errors */
 976
 977 error_sc_1:
 978         if (data->lm75[0] != NULL)
 979                 i2c_unregister_device(data->lm75[0]);
 980 error_sc_0:
 981         return err;
 982 }
 983
 984
 985 /* Return 0 if detection is successful, -ENODEV otherwise */
 986 static int w83791d_detect(struct i2c_client *client, int kind,
 987                           struct i2c_board_info *info)
 988 {
 989         struct i2c_adapter *adapter = client->adapter;
 990         int val1, val2;
 991         unsigned short address = client->addr;
 992
 993         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
 994                 return -ENODEV;
 995         }
 996
 997         /* The w83791d may be stuck in some other bank than bank 0. This may
 998            make reading other information impossible. Specify a force=...
 999            parameter, and the Winbond will be reset to the right bank. */
1000         if (kind < 0) {
1001                 if (w83791d_read(client, W83791D_REG_CONFIG) & 0x80) {
1002                         return -ENODEV;
1003                 }
1004                 val1 = w83791d_read(client, W83791D_REG_BANK);
1005                 val2 = w83791d_read(client, W83791D_REG_CHIPMAN);
1006                 /* Check for Winbond ID if in bank 0 */
1007                 if (!(val1 & 0x07)) {
1008                         /* yes it is Bank0 */
1009                         if (((!(val1 & 0x80)) && (val2 != 0xa3)) ||
1010                             ((val1 & 0x80) && (val2 != 0x5c))) {
1011                                 return -ENODEV;
1012                         }
1013                 }
1014                 /* If Winbond chip, address of chip and W83791D_REG_I2C_ADDR
1015                    should match */
1016                 if (w83791d_read(client, W83791D_REG_I2C_ADDR) != address) {
1017                         return -ENODEV;
1018                 }
1019         }
1020
1021         /* We either have a force parameter or we have reason to
1022            believe it is a Winbond chip. Either way, we want bank 0 and
1023            Vendor ID high byte */
1024         val1 = w83791d_read(client, W83791D_REG_BANK) & 0x78;
1025         w83791d_write(client, W83791D_REG_BANK, val1 | 0x80);
1026
1027         /* Verify it is a Winbond w83791d */
1028         if (kind <= 0) {
1029                 /* get vendor ID */
1030                 val2 = w83791d_read(client, W83791D_REG_CHIPMAN);
1031                 if (val2 != 0x5c) {     /* the vendor is NOT Winbond */
1032                         return -ENODEV;
1033                 }
1034                 val1 = w83791d_read(client, W83791D_REG_WCHIPID);
1035                 if (val1 == 0x71) {
1036                         kind = w83791d;
1037                 } else {
1038                         if (kind == 0)
1039                                 dev_warn(&adapter->dev,
1040                                         "w83791d: Ignoring 'force' parameter "
1041                                         "for unknown chip at adapter %d, "
1042                                         "address 0x%02x\n",
1043                                         i2c_adapter_id(adapter), address);
1044                         return -ENODEV;
1045                 }
1046         }
1047
1048         strlcpy(info->type, "w83791d", I2C_NAME_SIZE);
1049
1050         return 0;
1051 }
1052
1053 static int w83791d_probe(struct i2c_client *client,
1054                          const struct i2c_device_id *id)
1055 {
1056         struct w83791d_data *data;
1057         struct device *dev = &client->dev;
1058         int i, err;
1059
1060 #ifdef DEBUG
1061         int val1;
1062         val1 = w83791d_read(client, W83791D_REG_DID_VID4);
1063         dev_dbg(dev, "Device ID version: %d.%d (0x%02x)\n",
1064                         (val1 >> 5) & 0x07, (val1 >> 1) & 0x0f, val1);
1065 #endif
1066
1067         data = kzalloc(sizeof(struct w83791d_data), GFP_KERNEL);
1068         if (!data) {
1069                 err = -ENOMEM;
1070                 goto error0;
1071         }
1072
1073         i2c_set_clientdata(client, data);
1074         mutex_init(&data->update_lock);
1075
1076         err = w83791d_detect_subclients(client);
1077         if (err)
1078                 goto error1;
1079
1080         /* Initialize the chip */
1081         w83791d_init_client(client);
1082
1083         /* If the fan_div is changed, make sure there is a rational
1084            fan_min in place */
1085         for (i = 0; i < NUMBER_OF_FANIN; i++) {
1086                 data->fan_min[i] = w83791d_read(client, W83791D_REG_FAN_MIN[i]);
1087         }
1088
1089         /* Register sysfs hooks */
1090         if ((err = sysfs_create_group(&client->dev.kobj, &w83791d_group)))
1091                 goto error3;
1092
1093         /* Everything is ready, now register the working device */
1094         data->hwmon_dev = hwmon_device_register(dev);
1095         if (IS_ERR(data->hwmon_dev)) {
1096                 err = PTR_ERR(data->hwmon_dev);
1097                 goto error4;
1098         }
1099
1100         return 0;
1101
1102 error4:
1103         sysfs_remove_group(&client->dev.kobj, &w83791d_group);
1104 error3:
1105         if (data->lm75[0] != NULL)
1106                 i2c_unregister_device(data->lm75[0]);
1107         if (data->lm75[1] != NULL)
1108                 i2c_unregister_device(data->lm75[1]);
1109 error1:
1110         kfree(data);
1111 error0:
1112         return err;
1113 }
1114
1115 static int w83791d_remove(struct i2c_client *client)
1116 {
1117         struct w83791d_data *data = i2c_get_clientdata(client);
1118
1119         hwmon_device_unregister(data->hwmon_dev);
1120         sysfs_remove_group(&client->dev.kobj, &w83791d_group);
1121
1122         if (data->lm75[0] != NULL)
1123                 i2c_unregister_device(data->lm75[0]);
1124         if (data->lm75[1] != NULL)
1125                 i2c_unregister_device(data->lm75[1]);
1126
1127         kfree(data);
1128         return 0;
1129 }
1130
1131 static void w83791d_init_client(struct i2c_client *client)
1132 {
1133         struct w83791d_data *data = i2c_get_clientdata(client);
1134         u8 tmp;
1135         u8 old_beep;
1136
1137         /* The difference between reset and init is that reset
1138            does a hard reset of the chip via index 0x40, bit 7,
1139            but init simply forces certain registers to have "sane"
1140            values. The hope is that the BIOS has done the right
1141            thing (which is why the default is reset=0, init=0),
1142            but if not, reset is the hard hammer and init
1143            is the soft mallet both of which are trying to whack
1144            things into place...
1145            NOTE: The data sheet makes a distinction between
1146            "power on defaults" and "reset by MR". As far as I can tell,
1147            the hard reset puts everything into a power-on state so I'm
1148            not sure what "reset by MR" means or how it can happen.
1149            */
1150         if (reset || init) {
1151                 /* keep some BIOS settings when we... */
1152                 old_beep = w83791d_read(client, W83791D_REG_BEEP_CONFIG);
1153
1154                 if (reset) {
1155                         /* ... reset the chip and ... */
1156                         w83791d_write(client, W83791D_REG_CONFIG, 0x80);
1157                 }
1158
1159                 /* ... disable power-on abnormal beep */
1160                 w83791d_write(client, W83791D_REG_BEEP_CONFIG, old_beep | 0x80);
1161
1162                 /* disable the global beep (not done by hard reset) */
1163                 tmp = w83791d_read(client, W83791D_REG_BEEP_CTRL[1]);
1164                 w83791d_write(client, W83791D_REG_BEEP_CTRL[1], tmp & 0xef);
1165
1166                 if (init) {
1167                         /* Make sure monitoring is turned on for add-ons */
1168                         tmp = w83791d_read(client, W83791D_REG_TEMP2_CONFIG);
1169                         if (tmp & 1) {
1170                                 w83791d_write(client, W83791D_REG_TEMP2_CONFIG,
1171                                         tmp & 0xfe);
1172                         }
1173
1174                         tmp = w83791d_read(client, W83791D_REG_TEMP3_CONFIG);
1175                         if (tmp & 1) {
1176                                 w83791d_write(client, W83791D_REG_TEMP3_CONFIG,
1177                                         tmp & 0xfe);
1178                         }
1179
1180                         /* Start monitoring */
1181                         tmp = w83791d_read(client, W83791D_REG_CONFIG) & 0xf7;
1182                         w83791d_write(client, W83791D_REG_CONFIG, tmp | 0x01);
1183                 }
1184         }
1185
1186         data->vrm = vid_which_vrm();
1187 }
1188
1189 static struct w83791d_data *w83791d_update_device(struct device *dev)
1190 {
1191         struct i2c_client *client = to_i2c_client(dev);
1192         struct w83791d_data *data = i2c_get_clientdata(client);
1193         int i, j;
1194         u8 reg_array_tmp[3];
1195         u8 vbat_reg;
1196
1197         mutex_lock(&data->update_lock);
1198
1199         if (time_after(jiffies, data->last_updated + (HZ * 3))
1200                         || !data->valid) {
1201                 dev_dbg(dev, "Starting w83791d device update\n");
1202
1203                 /* Update the voltages measured value and limits */
1204                 for (i = 0; i < NUMBER_OF_VIN; i++) {
1205                         data->in[i] = w83791d_read(client,
1206                                                 W83791D_REG_IN[i]);
1207                         data->in_max[i] = w83791d_read(client,
1208                                                 W83791D_REG_IN_MAX[i]);
1209                         data->in_min[i] = w83791d_read(client,
1210                                                 W83791D_REG_IN_MIN[i]);
1211                 }
1212
1213                 /* Update the fan counts and limits */
1214                 for (i = 0; i < NUMBER_OF_FANIN; i++) {
1215                         /* Update the Fan measured value and limits */
1216                         data->fan[i] = w83791d_read(client,
1217                                                 W83791D_REG_FAN[i]);
1218                         data->fan_min[i] = w83791d_read(client,
1219                                                 W83791D_REG_FAN_MIN[i]);
1220                 }
1221
1222                 /* Update the fan divisor */
1223                 for (i = 0; i < 3; i++) {
1224                         reg_array_tmp[i] = w83791d_read(client,
1225                                                 W83791D_REG_FAN_DIV[i]);
1226                 }
1227                 data->fan_div[0] = (reg_array_tmp[0] >> 4) & 0x03;
1228                 data->fan_div[1] = (reg_array_tmp[0] >> 6) & 0x03;
1229                 data->fan_div[2] = (reg_array_tmp[1] >> 6) & 0x03;
1230                 data->fan_div[3] = reg_array_tmp[2] & 0x07;
1231                 data->fan_div[4] = (reg_array_tmp[2] >> 4) & 0x07;
1232
1233                 /* The fan divisor for fans 0-2 get bit 2 from
1234                    bits 5-7 respectively of vbat register */
1235                 vbat_reg = w83791d_read(client, W83791D_REG_VBAT);
1236                 for (i = 0; i < 3; i++)
1237                         data->fan_div[i] |= (vbat_reg >> (3 + i)) & 0x04;
1238
1239                 /* Update the first temperature sensor */
1240                 for (i = 0; i < 3; i++) {
1241                         data->temp1[i] = w83791d_read(client,
1242                                                 W83791D_REG_TEMP1[i]);
1243                 }
1244
1245                 /* Update the rest of the temperature sensors */
1246                 for (i = 0; i < 2; i++) {
1247                         for (j = 0; j < 3; j++) {
1248                                 data->temp_add[i][j] =
1249                                         (w83791d_read(client,
1250                                         W83791D_REG_TEMP_ADD[i][j * 2]) << 8) |
1251                                         w83791d_read(client,
1252                                         W83791D_REG_TEMP_ADD[i][j * 2 + 1]);
1253                         }
1254                 }
1255
1256                 /* Update the realtime status */
1257                 data->alarms =
1258                         w83791d_read(client, W83791D_REG_ALARM1) +
1259                         (w83791d_read(client, W83791D_REG_ALARM2) << 8) +
1260                         (w83791d_read(client, W83791D_REG_ALARM3) << 16);
1261
1262                 /* Update the beep configuration information */
1263                 data->beep_mask =
1264                         w83791d_read(client, W83791D_REG_BEEP_CTRL[0]) +
1265                         (w83791d_read(client, W83791D_REG_BEEP_CTRL[1]) << 8) +
1266                         (w83791d_read(client, W83791D_REG_BEEP_CTRL[2]) << 16);
1267
1268                 /* Extract global beep enable flag */
1269                 data->beep_enable =
1270                         (data->beep_mask >> GLOBAL_BEEP_ENABLE_SHIFT) & 0x01;
1271
1272                 /* Update the cpu voltage information */
1273                 i = w83791d_read(client, W83791D_REG_VID_FANDIV);
1274                 data->vid = i & 0x0f;
1275                 data->vid |= (w83791d_read(client, W83791D_REG_DID_VID4) & 0x01)
1276                                 << 4;
1277
1278                 data->last_updated = jiffies;
1279                 data->valid = 1;
1280         }
1281
1282         mutex_unlock(&data->update_lock);
1283
1284 #ifdef DEBUG
1285         w83791d_print_debug(data, dev);
1286 #endif
1287
1288         return data;
1289 }
1290
1291 #ifdef DEBUG
1292 static void w83791d_print_debug(struct w83791d_data *data, struct device *dev)
1293 {
1294         int i = 0, j = 0;
1295
1296         dev_dbg(dev, "======Start of w83791d debug values======\n");
1297         dev_dbg(dev, "%d set of Voltages: ===>\n", NUMBER_OF_VIN);
1298         for (i = 0; i < NUMBER_OF_VIN; i++) {
1299                 dev_dbg(dev, "vin[%d] is:     0x%02x\n", i, data->in[i]);
1300                 dev_dbg(dev, "vin[%d] min is: 0x%02x\n", i, data->in_min[i]);
1301                 dev_dbg(dev, "vin[%d] max is: 0x%02x\n", i, data->in_max[i]);
1302         }
1303         dev_dbg(dev, "%d set of Fan Counts/Divisors: ===>\n", NUMBER_OF_FANIN);
1304         for (i = 0; i < NUMBER_OF_FANIN; i++) {
1305                 dev_dbg(dev, "fan[%d] is:     0x%02x\n", i, data->fan[i]);
1306                 dev_dbg(dev, "fan[%d] min is: 0x%02x\n", i, data->fan_min[i]);
1307                 dev_dbg(dev, "fan_div[%d] is: 0x%02x\n", i, data->fan_div[i]);
1308         }
1309
1310         /* temperature math is signed, but only print out the
1311            bits that matter */
1312         dev_dbg(dev, "%d set of Temperatures: ===>\n", NUMBER_OF_TEMPIN);
1313         for (i = 0; i < 3; i++) {
1314                 dev_dbg(dev, "temp1[%d] is: 0x%02x\n", i, (u8) data->temp1[i]);
1315         }
1316         for (i = 0; i < 2; i++) {
1317                 for (j = 0; j < 3; j++) {
1318                         dev_dbg(dev, "temp_add[%d][%d] is: 0x%04x\n", i, j,
1319                                 (u16) data->temp_add[i][j]);
1320                 }
1321         }
1322
1323         dev_dbg(dev, "Misc Information: ===>\n");
1324         dev_dbg(dev, "alarm is:     0x%08x\n", data->alarms);
1325         dev_dbg(dev, "beep_mask is: 0x%08x\n", data->beep_mask);
1326         dev_dbg(dev, "beep_enable is: %d\n", data->beep_enable);
1327         dev_dbg(dev, "vid is: 0x%02x\n", data->vid);
1328         dev_dbg(dev, "vrm is: 0x%02x\n", data->vrm);
1329         dev_dbg(dev, "=======End of w83791d debug values========\n");
1330         dev_dbg(dev, "\n");
1331 }
1332 #endif
1333
1334 static int __init sensors_w83791d_init(void)
1335 {
1336         return i2c_add_driver(&w83791d_driver);
1337 }
1338
1339 static void __exit sensors_w83791d_exit(void)
1340 {
1341         i2c_del_driver(&w83791d_driver);
1342 }
1343
1344 MODULE_AUTHOR("Charles Spirakis <bezaur@gmail.com>");
1345 MODULE_DESCRIPTION("W83791D driver");
1346 MODULE_LICENSE("GPL");
1347
1348 module_init(sensors_w83791d_init);
1349 module_exit(sensors_w83791d_exit);