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