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