drivers/hwmon/w83791d.c

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