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