drivers/hwmon/w83791d.c

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