drivers/hwmon/w83791d.c

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