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