git.oblomov.eu Git - linux-2.6/blob - drivers/hwmon/w83793.c

   1 /*
   2     w83793.c - Linux kernel driver for hardware monitoring
   3     Copyright (C) 2006 Winbond Electronics Corp.
   4                   Yuan Mu
   5                   Rudolf Marek <r.marek@assembler.cz>
   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 - version 2.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19     02110-1301 USA.
  20 */
  21
  22 /*
  23     Supports following chips:
  24
  25     Chip        #vin    #fanin  #pwm    #temp   wchipid vendid  i2c     ISA
  26     w83793      10      12      8       6       0x7b    0x5ca3  yes     no
  27 */
  28
  29 #include <linux/module.h>
  30 #include <linux/init.h>
  31 #include <linux/slab.h>
  32 #include <linux/i2c.h>
  33 #include <linux/hwmon.h>
  34 #include <linux/hwmon-vid.h>
  35 #include <linux/hwmon-sysfs.h>
  36 #include <linux/err.h>
  37 #include <linux/mutex.h>
  38
  39 /* Addresses to scan */
  40 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f,
  41                                                 I2C_CLIENT_END };
  42
  43 /* Insmod parameters */
  44 I2C_CLIENT_INSMOD_1(w83793);
  45
  46 static unsigned short force_subclients[4];
  47 module_param_array(force_subclients, short, NULL, 0);
  48 MODULE_PARM_DESC(force_subclients, "List of subclient addresses: "
  49                        "{bus, clientaddr, subclientaddr1, subclientaddr2}");
  50
  51 static int reset;
  52 module_param(reset, bool, 0);
  53 MODULE_PARM_DESC(reset, "Set to 1 to reset chip, not recommended");
  54
  55 /*
  56    Address 0x00, 0x0d, 0x0e, 0x0f in all three banks are reserved
  57    as ID, Bank Select registers
  58 */
  59 #define W83793_REG_BANKSEL              0x00
  60 #define W83793_REG_VENDORID             0x0d
  61 #define W83793_REG_CHIPID               0x0e
  62 #define W83793_REG_DEVICEID             0x0f
  63
  64 #define W83793_REG_CONFIG               0x40
  65 #define W83793_REG_MFC                  0x58
  66 #define W83793_REG_FANIN_CTRL           0x5c
  67 #define W83793_REG_FANIN_SEL            0x5d
  68 #define W83793_REG_I2C_ADDR             0x0b
  69 #define W83793_REG_I2C_SUBADDR          0x0c
  70 #define W83793_REG_VID_INA              0x05
  71 #define W83793_REG_VID_INB              0x06
  72 #define W83793_REG_VID_LATCHA           0x07
  73 #define W83793_REG_VID_LATCHB           0x08
  74 #define W83793_REG_VID_CTRL             0x59
  75
  76 static u16 W83793_REG_TEMP_MODE[2] = { 0x5e, 0x5f };
  77
  78 #define TEMP_READ       0
  79 #define TEMP_CRIT       1
  80 #define TEMP_CRIT_HYST  2
  81 #define TEMP_WARN       3
  82 #define TEMP_WARN_HYST  4
  83 /* only crit and crit_hyst affect real-time alarm status
  84    current crit crit_hyst warn warn_hyst */
  85 static u16 W83793_REG_TEMP[][5] = {
  86         {0x1c, 0x78, 0x79, 0x7a, 0x7b},
  87         {0x1d, 0x7c, 0x7d, 0x7e, 0x7f},
  88         {0x1e, 0x80, 0x81, 0x82, 0x83},
  89         {0x1f, 0x84, 0x85, 0x86, 0x87},
  90         {0x20, 0x88, 0x89, 0x8a, 0x8b},
  91         {0x21, 0x8c, 0x8d, 0x8e, 0x8f},
  92 };
  93
  94 #define W83793_REG_TEMP_LOW_BITS        0x22
  95
  96 #define W83793_REG_BEEP(index)          (0x53 + (index))
  97 #define W83793_REG_ALARM(index)         (0x4b + (index))
  98
  99 #define W83793_REG_CLR_CHASSIS          0x4a    /* SMI MASK4 */
 100 #define W83793_REG_IRQ_CTRL             0x50
 101 #define W83793_REG_OVT_CTRL             0x51
 102 #define W83793_REG_OVT_BEEP             0x52
 103
 104 #define IN_READ                         0
 105 #define IN_MAX                          1
 106 #define IN_LOW                          2
 107 static const u16 W83793_REG_IN[][3] = {
 108         /* Current, High, Low */
 109         {0x10, 0x60, 0x61},     /* Vcore A      */
 110         {0x11, 0x62, 0x63},     /* Vcore B      */
 111         {0x12, 0x64, 0x65},     /* Vtt          */
 112         {0x14, 0x6a, 0x6b},     /* VSEN1        */
 113         {0x15, 0x6c, 0x6d},     /* VSEN2        */
 114         {0x16, 0x6e, 0x6f},     /* +3VSEN       */
 115         {0x17, 0x70, 0x71},     /* +12VSEN      */
 116         {0x18, 0x72, 0x73},     /* 5VDD         */
 117         {0x19, 0x74, 0x75},     /* 5VSB         */
 118         {0x1a, 0x76, 0x77},     /* VBAT         */
 119 };
 120
 121 /* Low Bits of Vcore A/B Vtt Read/High/Low */
 122 static const u16 W83793_REG_IN_LOW_BITS[] = { 0x1b, 0x68, 0x69 };
 123 static u8 scale_in[] = { 2, 2, 2, 16, 16, 16, 8, 24, 24, 16 };
 124 static u8 scale_in_add[] = { 0, 0, 0, 0, 0, 0, 0, 150, 150, 0 };
 125
 126 #define W83793_REG_FAN(index)           (0x23 + 2 * (index))    /* High byte */
 127 #define W83793_REG_FAN_MIN(index)       (0x90 + 2 * (index))    /* High byte */
 128
 129 #define W83793_REG_PWM_DEFAULT          0xb2
 130 #define W83793_REG_PWM_ENABLE           0x207
 131 #define W83793_REG_PWM_UPTIME           0xc3    /* Unit in 0.1 second */
 132 #define W83793_REG_PWM_DOWNTIME         0xc4    /* Unit in 0.1 second */
 133 #define W83793_REG_TEMP_CRITICAL        0xc5
 134
 135 #define PWM_DUTY                        0
 136 #define PWM_START                       1
 137 #define PWM_NONSTOP                     2
 138 #define PWM_STOP_TIME                   3
 139 #define W83793_REG_PWM(index, nr)       (((nr) == 0 ? 0xb3 : \
 140                                          (nr) == 1 ? 0x220 : 0x218) + (index))
 141
 142 /* bit field, fan1 is bit0, fan2 is bit1 ... */
 143 #define W83793_REG_TEMP_FAN_MAP(index)  (0x201 + (index))
 144 #define W83793_REG_TEMP_TOL(index)      (0x208 + (index))
 145 #define W83793_REG_TEMP_CRUISE(index)   (0x210 + (index))
 146 #define W83793_REG_PWM_STOP_TIME(index) (0x228 + (index))
 147 #define W83793_REG_SF2_TEMP(index, nr)  (0x230 + ((index) << 4) + (nr))
 148 #define W83793_REG_SF2_PWM(index, nr)   (0x238 + ((index) << 4) + (nr))
 149
 150 static inline unsigned long FAN_FROM_REG(u16 val)
 151 {
 152         if ((val >= 0xfff) || (val == 0))
 153                 return  0;
 154         return (1350000UL / val);
 155 }
 156
 157 static inline u16 FAN_TO_REG(long rpm)
 158 {
 159         if (rpm <= 0)
 160                 return 0x0fff;
 161         return SENSORS_LIMIT((1350000 + (rpm >> 1)) / rpm, 1, 0xffe);
 162 }
 163
 164 static inline unsigned long TIME_FROM_REG(u8 reg)
 165 {
 166         return (reg * 100);
 167 }
 168
 169 static inline u8 TIME_TO_REG(unsigned long val)
 170 {
 171         return SENSORS_LIMIT((val + 50) / 100, 0, 0xff);
 172 }
 173
 174 static inline long TEMP_FROM_REG(s8 reg)
 175 {
 176         return (reg * 1000);
 177 }
 178
 179 static inline s8 TEMP_TO_REG(long val, s8 min, s8 max)
 180 {
 181         return SENSORS_LIMIT((val + (val < 0 ? -500 : 500)) / 1000, min, max);
 182 }
 183
 184 struct w83793_data {
 185         struct i2c_client *lm75[2];
 186         struct device *hwmon_dev;
 187         struct mutex update_lock;
 188         char valid;                     /* !=0 if following fields are valid */
 189         unsigned long last_updated;     /* In jiffies */
 190         unsigned long last_nonvolatile; /* In jiffies, last time we update the
 191                                            nonvolatile registers */
 192
 193         u8 bank;
 194         u8 vrm;
 195         u8 vid[2];
 196         u8 in[10][3];           /* Register value, read/high/low */
 197         u8 in_low_bits[3];      /* Additional resolution for VCore A/B Vtt */
 198
 199         u16 has_fan;            /* Only fan1- fan5 has own pins */
 200         u16 fan[12];            /* Register value combine */
 201         u16 fan_min[12];        /* Register value combine */
 202
 203         s8 temp[6][5];          /* current, crit, crit_hyst,warn, warn_hyst */
 204         u8 temp_low_bits;       /* Additional resolution TD1-TD4 */
 205         u8 temp_mode[2];        /* byte 0: Temp D1-D4 mode each has 2 bits
 206                                    byte 1: Temp R1,R2 mode, each has 1 bit */
 207         u8 temp_critical;       /* If reached all fan will be at full speed */
 208         u8 temp_fan_map[6];     /* Temp controls which pwm fan, bit field */
 209
 210         u8 has_pwm;
 211         u8 has_temp;
 212         u8 has_vid;
 213         u8 pwm_enable;          /* Register value, each Temp has 1 bit */
 214         u8 pwm_uptime;          /* Register value */
 215         u8 pwm_downtime;        /* Register value */
 216         u8 pwm_default;         /* All fan default pwm, next poweron valid */
 217         u8 pwm[8][3];           /* Register value */
 218         u8 pwm_stop_time[8];
 219         u8 temp_cruise[6];
 220
 221         u8 alarms[5];           /* realtime status registers */
 222         u8 beeps[5];
 223         u8 beep_enable;
 224         u8 tolerance[3];        /* Temp tolerance(Smart Fan I/II) */
 225         u8 sf2_pwm[6][7];       /* Smart FanII: Fan duty cycle */
 226         u8 sf2_temp[6][7];      /* Smart FanII: Temp level point */
 227 };
 228
 229 static u8 w83793_read_value(struct i2c_client *client, u16 reg);
 230 static int w83793_write_value(struct i2c_client *client, u16 reg, u8 value);
 231 static int w83793_probe(struct i2c_client *client,
 232                         const struct i2c_device_id *id);
 233 static int w83793_detect(struct i2c_client *client, int kind,
 234                          struct i2c_board_info *info);
 235 static int w83793_remove(struct i2c_client *client);
 236 static void w83793_init_client(struct i2c_client *client);
 237 static void w83793_update_nonvolatile(struct device *dev);
 238 static struct w83793_data *w83793_update_device(struct device *dev);
 239
 240 static const struct i2c_device_id w83793_id[] = {
 241         { "w83793", w83793 },
 242         { }
 243 };
 244 MODULE_DEVICE_TABLE(i2c, w83793_id);
 245
 246 static struct i2c_driver w83793_driver = {
 247         .class          = I2C_CLASS_HWMON,
 248         .driver = {
 249                    .name = "w83793",
 250         },
 251         .probe          = w83793_probe,
 252         .remove         = w83793_remove,
 253         .id_table       = w83793_id,
 254         .detect         = w83793_detect,
 255         .address_data   = &addr_data,
 256 };
 257
 258 static ssize_t
 259 show_vrm(struct device *dev, struct device_attribute *attr, char *buf)
 260 {
 261         struct w83793_data *data = dev_get_drvdata(dev);
 262         return sprintf(buf, "%d\n", data->vrm);
 263 }
 264
 265 static ssize_t
 266 show_vid(struct device *dev, struct device_attribute *attr, char *buf)
 267 {
 268         struct w83793_data *data = w83793_update_device(dev);
 269         struct sensor_device_attribute_2 *sensor_attr =
 270             to_sensor_dev_attr_2(attr);
 271         int index = sensor_attr->index;
 272
 273         return sprintf(buf, "%d\n", vid_from_reg(data->vid[index], data->vrm));
 274 }
 275
 276 static ssize_t
 277 store_vrm(struct device *dev, struct device_attribute *attr,
 278           const char *buf, size_t count)
 279 {
 280         struct w83793_data *data = dev_get_drvdata(dev);
 281         data->vrm = simple_strtoul(buf, NULL, 10);
 282         return count;
 283 }
 284
 285 #define ALARM_STATUS                    0
 286 #define BEEP_ENABLE                     1
 287 static ssize_t
 288 show_alarm_beep(struct device *dev, struct device_attribute *attr, char *buf)
 289 {
 290         struct w83793_data *data = w83793_update_device(dev);
 291         struct sensor_device_attribute_2 *sensor_attr =
 292             to_sensor_dev_attr_2(attr);
 293         int nr = sensor_attr->nr;
 294         int index = sensor_attr->index >> 3;
 295         int bit = sensor_attr->index & 0x07;
 296         u8 val;
 297
 298         if (ALARM_STATUS == nr) {
 299                 val = (data->alarms[index] >> (bit)) & 1;
 300         } else {                /* BEEP_ENABLE */
 301                 val = (data->beeps[index] >> (bit)) & 1;
 302         }
 303
 304         return sprintf(buf, "%u\n", val);
 305 }
 306
 307 static ssize_t
 308 store_beep(struct device *dev, struct device_attribute *attr,
 309            const char *buf, size_t count)
 310 {
 311         struct i2c_client *client = to_i2c_client(dev);
 312         struct w83793_data *data = i2c_get_clientdata(client);
 313         struct sensor_device_attribute_2 *sensor_attr =
 314             to_sensor_dev_attr_2(attr);
 315         int index = sensor_attr->index >> 3;
 316         int shift = sensor_attr->index & 0x07;
 317         u8 beep_bit = 1 << shift;
 318         u8 val;
 319
 320         val = simple_strtoul(buf, NULL, 10);
 321         if (val != 0 && val != 1)
 322                 return -EINVAL;
 323
 324         mutex_lock(&data->update_lock);
 325         data->beeps[index] = w83793_read_value(client, W83793_REG_BEEP(index));
 326         data->beeps[index] &= ~beep_bit;
 327         data->beeps[index] |= val << shift;
 328         w83793_write_value(client, W83793_REG_BEEP(index), data->beeps[index]);
 329         mutex_unlock(&data->update_lock);
 330
 331         return count;
 332 }
 333
 334 static ssize_t
 335 show_beep_enable(struct device *dev, struct device_attribute *attr, char *buf)
 336 {
 337         struct w83793_data *data = w83793_update_device(dev);
 338         return sprintf(buf, "%u\n", (data->beep_enable >> 1) & 0x01);
 339 }
 340
 341 static ssize_t
 342 store_beep_enable(struct device *dev, struct device_attribute *attr,
 343                   const char *buf, size_t count)
 344 {
 345         struct i2c_client *client = to_i2c_client(dev);
 346         struct w83793_data *data = i2c_get_clientdata(client);
 347         u8 val = simple_strtoul(buf, NULL, 10);
 348
 349         if (val != 0 && val != 1)
 350                 return -EINVAL;
 351
 352         mutex_lock(&data->update_lock);
 353         data->beep_enable = w83793_read_value(client, W83793_REG_OVT_BEEP)
 354                             & 0xfd;
 355         data->beep_enable |= val << 1;
 356         w83793_write_value(client, W83793_REG_OVT_BEEP, data->beep_enable);
 357         mutex_unlock(&data->update_lock);
 358
 359         return count;
 360 }
 361
 362 /* Write any value to clear chassis alarm */
 363 static ssize_t
 364 store_chassis_clear(struct device *dev,
 365                     struct device_attribute *attr, const char *buf,
 366                     size_t count)
 367 {
 368         struct i2c_client *client = to_i2c_client(dev);
 369         struct w83793_data *data = i2c_get_clientdata(client);
 370         u8 val;
 371
 372         mutex_lock(&data->update_lock);
 373         val = w83793_read_value(client, W83793_REG_CLR_CHASSIS);
 374         val |= 0x80;
 375         w83793_write_value(client, W83793_REG_CLR_CHASSIS, val);
 376         mutex_unlock(&data->update_lock);
 377         return count;
 378 }
 379
 380 #define FAN_INPUT                       0
 381 #define FAN_MIN                         1
 382 static ssize_t
 383 show_fan(struct device *dev, struct device_attribute *attr, char *buf)
 384 {
 385         struct sensor_device_attribute_2 *sensor_attr =
 386             to_sensor_dev_attr_2(attr);
 387         int nr = sensor_attr->nr;
 388         int index = sensor_attr->index;
 389         struct w83793_data *data = w83793_update_device(dev);
 390         u16 val;
 391
 392         if (FAN_INPUT == nr) {
 393                 val = data->fan[index] & 0x0fff;
 394         } else {
 395                 val = data->fan_min[index] & 0x0fff;
 396         }
 397
 398         return sprintf(buf, "%lu\n", FAN_FROM_REG(val));
 399 }
 400
 401 static ssize_t
 402 store_fan_min(struct device *dev, struct device_attribute *attr,
 403               const char *buf, size_t count)
 404 {
 405         struct sensor_device_attribute_2 *sensor_attr =
 406             to_sensor_dev_attr_2(attr);
 407         int index = sensor_attr->index;
 408         struct i2c_client *client = to_i2c_client(dev);
 409         struct w83793_data *data = i2c_get_clientdata(client);
 410         u16 val = FAN_TO_REG(simple_strtoul(buf, NULL, 10));
 411
 412         mutex_lock(&data->update_lock);
 413         data->fan_min[index] = val;
 414         w83793_write_value(client, W83793_REG_FAN_MIN(index),
 415                            (val >> 8) & 0xff);
 416         w83793_write_value(client, W83793_REG_FAN_MIN(index) + 1, val & 0xff);
 417         mutex_unlock(&data->update_lock);
 418
 419         return count;
 420 }
 421
 422 static ssize_t
 423 show_pwm(struct device *dev, struct device_attribute *attr, char *buf)
 424 {
 425         struct sensor_device_attribute_2 *sensor_attr =
 426             to_sensor_dev_attr_2(attr);
 427         struct w83793_data *data = w83793_update_device(dev);
 428         u16 val;
 429         int nr = sensor_attr->nr;
 430         int index = sensor_attr->index;
 431
 432         if (PWM_STOP_TIME == nr)
 433                 val = TIME_FROM_REG(data->pwm_stop_time[index]);
 434         else
 435                 val = (data->pwm[index][nr] & 0x3f) << 2;
 436
 437         return sprintf(buf, "%d\n", val);
 438 }
 439
 440 static ssize_t
 441 store_pwm(struct device *dev, struct device_attribute *attr,
 442           const char *buf, size_t count)
 443 {
 444         struct i2c_client *client = to_i2c_client(dev);
 445         struct w83793_data *data = i2c_get_clientdata(client);
 446         struct sensor_device_attribute_2 *sensor_attr =
 447             to_sensor_dev_attr_2(attr);
 448         int nr = sensor_attr->nr;
 449         int index = sensor_attr->index;
 450         u8 val;
 451
 452         mutex_lock(&data->update_lock);
 453         if (PWM_STOP_TIME == nr) {
 454                 val = TIME_TO_REG(simple_strtoul(buf, NULL, 10));
 455                 data->pwm_stop_time[index] = val;
 456                 w83793_write_value(client, W83793_REG_PWM_STOP_TIME(index),
 457                                    val);
 458         } else {
 459                 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 0, 0xff)
 460                       >> 2;
 461                 data->pwm[index][nr] =
 462                     w83793_read_value(client, W83793_REG_PWM(index, nr)) & 0xc0;
 463                 data->pwm[index][nr] |= val;
 464                 w83793_write_value(client, W83793_REG_PWM(index, nr),
 465                                                         data->pwm[index][nr]);
 466         }
 467
 468         mutex_unlock(&data->update_lock);
 469         return count;
 470 }
 471
 472 static ssize_t
 473 show_temp(struct device *dev, struct device_attribute *attr, char *buf)
 474 {
 475         struct sensor_device_attribute_2 *sensor_attr =
 476             to_sensor_dev_attr_2(attr);
 477         int nr = sensor_attr->nr;
 478         int index = sensor_attr->index;
 479         struct w83793_data *data = w83793_update_device(dev);
 480         long temp = TEMP_FROM_REG(data->temp[index][nr]);
 481
 482         if (TEMP_READ == nr && index < 4) {     /* Only TD1-TD4 have low bits */
 483                 int low = ((data->temp_low_bits >> (index * 2)) & 0x03) * 250;
 484                 temp += temp > 0 ? low : -low;
 485         }
 486         return sprintf(buf, "%ld\n", temp);
 487 }
 488
 489 static ssize_t
 490 store_temp(struct device *dev, struct device_attribute *attr,
 491            const char *buf, size_t count)
 492 {
 493         struct sensor_device_attribute_2 *sensor_attr =
 494             to_sensor_dev_attr_2(attr);
 495         int nr = sensor_attr->nr;
 496         int index = sensor_attr->index;
 497         struct i2c_client *client = to_i2c_client(dev);
 498         struct w83793_data *data = i2c_get_clientdata(client);
 499         long tmp = simple_strtol(buf, NULL, 10);
 500
 501         mutex_lock(&data->update_lock);
 502         data->temp[index][nr] = TEMP_TO_REG(tmp, -128, 127);
 503         w83793_write_value(client, W83793_REG_TEMP[index][nr],
 504                            data->temp[index][nr]);
 505         mutex_unlock(&data->update_lock);
 506         return count;
 507 }
 508
 509 /*
 510         TD1-TD4
 511         each has 4 mode:(2 bits)
 512         0:      Stop monitor
 513         1:      Use internal temp sensor(default)
 514         2:      Reserved
 515         3:      Use sensor in Intel CPU and get result by PECI
 516
 517         TR1-TR2
 518         each has 2 mode:(1 bit)
 519         0:      Disable temp sensor monitor
 520         1:      To enable temp sensors monitor
 521 */
 522
 523 /* 0 disable, 6 PECI */
 524 static u8 TO_TEMP_MODE[] = { 0, 0, 0, 6 };
 525
 526 static ssize_t
 527 show_temp_mode(struct device *dev, struct device_attribute *attr, char *buf)
 528 {
 529         struct w83793_data *data = w83793_update_device(dev);
 530         struct sensor_device_attribute_2 *sensor_attr =
 531             to_sensor_dev_attr_2(attr);
 532         int index = sensor_attr->index;
 533         u8 mask = (index < 4) ? 0x03 : 0x01;
 534         u8 shift = (index < 4) ? (2 * index) : (index - 4);
 535         u8 tmp;
 536         index = (index < 4) ? 0 : 1;
 537
 538         tmp = (data->temp_mode[index] >> shift) & mask;
 539
 540         /* for the internal sensor, found out if diode or thermistor */
 541         if (tmp == 1) {
 542                 tmp = index == 0 ? 3 : 4;
 543         } else {
 544                 tmp = TO_TEMP_MODE[tmp];
 545         }
 546
 547         return sprintf(buf, "%d\n", tmp);
 548 }
 549
 550 static ssize_t
 551 store_temp_mode(struct device *dev, struct device_attribute *attr,
 552                 const char *buf, size_t count)
 553 {
 554         struct i2c_client *client = to_i2c_client(dev);
 555         struct w83793_data *data = i2c_get_clientdata(client);
 556         struct sensor_device_attribute_2 *sensor_attr =
 557             to_sensor_dev_attr_2(attr);
 558         int index = sensor_attr->index;
 559         u8 mask = (index < 4) ? 0x03 : 0x01;
 560         u8 shift = (index < 4) ? (2 * index) : (index - 4);
 561         u8 val = simple_strtoul(buf, NULL, 10);
 562
 563         /* transform the sysfs interface values into table above */
 564         if ((val == 6) && (index < 4)) {
 565                 val -= 3;
 566         } else if ((val == 3 && index < 4)
 567                 || (val == 4 && index >= 4)) {
 568                 /* transform diode or thermistor into internal enable */
 569                 val = !!val;
 570         } else {
 571                 return -EINVAL;
 572         }
 573
 574         index = (index < 4) ? 0 : 1;
 575         mutex_lock(&data->update_lock);
 576         data->temp_mode[index] =
 577             w83793_read_value(client, W83793_REG_TEMP_MODE[index]);
 578         data->temp_mode[index] &= ~(mask << shift);
 579         data->temp_mode[index] |= val << shift;
 580         w83793_write_value(client, W83793_REG_TEMP_MODE[index],
 581                                                         data->temp_mode[index]);
 582         mutex_unlock(&data->update_lock);
 583
 584         return count;
 585 }
 586
 587 #define SETUP_PWM_DEFAULT               0
 588 #define SETUP_PWM_UPTIME                1       /* Unit in 0.1s */
 589 #define SETUP_PWM_DOWNTIME              2       /* Unit in 0.1s */
 590 #define SETUP_TEMP_CRITICAL             3
 591 static ssize_t
 592 show_sf_setup(struct device *dev, struct device_attribute *attr, char *buf)
 593 {
 594         struct sensor_device_attribute_2 *sensor_attr =
 595             to_sensor_dev_attr_2(attr);
 596         int nr = sensor_attr->nr;
 597         struct w83793_data *data = w83793_update_device(dev);
 598         u32 val = 0;
 599
 600         if (SETUP_PWM_DEFAULT == nr) {
 601                 val = (data->pwm_default & 0x3f) << 2;
 602         } else if (SETUP_PWM_UPTIME == nr) {
 603                 val = TIME_FROM_REG(data->pwm_uptime);
 604         } else if (SETUP_PWM_DOWNTIME == nr) {
 605                 val = TIME_FROM_REG(data->pwm_downtime);
 606         } else if (SETUP_TEMP_CRITICAL == nr) {
 607                 val = TEMP_FROM_REG(data->temp_critical & 0x7f);
 608         }
 609
 610         return sprintf(buf, "%d\n", val);
 611 }
 612
 613 static ssize_t
 614 store_sf_setup(struct device *dev, struct device_attribute *attr,
 615                const char *buf, size_t count)
 616 {
 617         struct sensor_device_attribute_2 *sensor_attr =
 618             to_sensor_dev_attr_2(attr);
 619         int nr = sensor_attr->nr;
 620         struct i2c_client *client = to_i2c_client(dev);
 621         struct w83793_data *data = i2c_get_clientdata(client);
 622
 623         mutex_lock(&data->update_lock);
 624         if (SETUP_PWM_DEFAULT == nr) {
 625                 data->pwm_default =
 626                     w83793_read_value(client, W83793_REG_PWM_DEFAULT) & 0xc0;
 627                 data->pwm_default |= SENSORS_LIMIT(simple_strtoul(buf, NULL,
 628                                                                   10),
 629                                                    0, 0xff) >> 2;
 630                 w83793_write_value(client, W83793_REG_PWM_DEFAULT,
 631                                                         data->pwm_default);
 632         } else if (SETUP_PWM_UPTIME == nr) {
 633                 data->pwm_uptime = TIME_TO_REG(simple_strtoul(buf, NULL, 10));
 634                 data->pwm_uptime += data->pwm_uptime == 0 ? 1 : 0;
 635                 w83793_write_value(client, W83793_REG_PWM_UPTIME,
 636                                                         data->pwm_uptime);
 637         } else if (SETUP_PWM_DOWNTIME == nr) {
 638                 data->pwm_downtime = TIME_TO_REG(simple_strtoul(buf, NULL, 10));
 639                 data->pwm_downtime += data->pwm_downtime == 0 ? 1 : 0;
 640                 w83793_write_value(client, W83793_REG_PWM_DOWNTIME,
 641                                                         data->pwm_downtime);
 642         } else {                /* SETUP_TEMP_CRITICAL */
 643                 data->temp_critical =
 644                     w83793_read_value(client, W83793_REG_TEMP_CRITICAL) & 0x80;
 645                 data->temp_critical |= TEMP_TO_REG(simple_strtol(buf, NULL, 10),
 646                                                    0, 0x7f);
 647                 w83793_write_value(client, W83793_REG_TEMP_CRITICAL,
 648                                                         data->temp_critical);
 649         }
 650
 651         mutex_unlock(&data->update_lock);
 652         return count;
 653 }
 654
 655 /*
 656         Temp SmartFan control
 657         TEMP_FAN_MAP
 658         Temp channel control which pwm fan, bitfield, bit 0 indicate pwm1...
 659         It's possible two or more temp channels control the same fan, w83793
 660         always prefers to pick the most critical request and applies it to
 661         the related Fan.
 662         It's possible one fan is not in any mapping of 6 temp channels, this
 663         means the fan is manual mode
 664
 665         TEMP_PWM_ENABLE
 666         Each temp channel has its own SmartFan mode, and temp channel
 667         control fans that are set by TEMP_FAN_MAP
 668         0:      SmartFanII mode
 669         1:      Thermal Cruise Mode
 670
 671         TEMP_CRUISE
 672         Target temperature in thermal cruise mode, w83793 will try to turn
 673         fan speed to keep the temperature of target device around this
 674         temperature.
 675
 676         TEMP_TOLERANCE
 677         If Temp higher or lower than target with this tolerance, w83793
 678         will take actions to speed up or slow down the fan to keep the
 679         temperature within the tolerance range.
 680 */
 681
 682 #define TEMP_FAN_MAP                    0
 683 #define TEMP_PWM_ENABLE                 1
 684 #define TEMP_CRUISE                     2
 685 #define TEMP_TOLERANCE                  3
 686 static ssize_t
 687 show_sf_ctrl(struct device *dev, struct device_attribute *attr, char *buf)
 688 {
 689         struct sensor_device_attribute_2 *sensor_attr =
 690             to_sensor_dev_attr_2(attr);
 691         int nr = sensor_attr->nr;
 692         int index = sensor_attr->index;
 693         struct w83793_data *data = w83793_update_device(dev);
 694         u32 val;
 695
 696         if (TEMP_FAN_MAP == nr) {
 697                 val = data->temp_fan_map[index];
 698         } else if (TEMP_PWM_ENABLE == nr) {
 699                 /* +2 to transfrom into 2 and 3 to conform with sysfs intf */
 700                 val = ((data->pwm_enable >> index) & 0x01) + 2;
 701         } else if (TEMP_CRUISE == nr) {
 702                 val = TEMP_FROM_REG(data->temp_cruise[index] & 0x7f);
 703         } else {                /* TEMP_TOLERANCE */
 704                 val = data->tolerance[index >> 1] >> ((index & 0x01) ? 4 : 0);
 705                 val = TEMP_FROM_REG(val & 0x0f);
 706         }
 707         return sprintf(buf, "%d\n", val);
 708 }
 709
 710 static ssize_t
 711 store_sf_ctrl(struct device *dev, struct device_attribute *attr,
 712               const char *buf, size_t count)
 713 {
 714         struct sensor_device_attribute_2 *sensor_attr =
 715             to_sensor_dev_attr_2(attr);
 716         int nr = sensor_attr->nr;
 717         int index = sensor_attr->index;
 718         struct i2c_client *client = to_i2c_client(dev);
 719         struct w83793_data *data = i2c_get_clientdata(client);
 720         u32 val;
 721
 722         mutex_lock(&data->update_lock);
 723         if (TEMP_FAN_MAP == nr) {
 724                 val = simple_strtoul(buf, NULL, 10) & 0xff;
 725                 w83793_write_value(client, W83793_REG_TEMP_FAN_MAP(index), val);
 726                 data->temp_fan_map[index] = val;
 727         } else if (TEMP_PWM_ENABLE == nr) {
 728                 val = simple_strtoul(buf, NULL, 10);
 729                 if (2 == val || 3 == val) {
 730                         data->pwm_enable =
 731                             w83793_read_value(client, W83793_REG_PWM_ENABLE);
 732                         if (val - 2)
 733                                 data->pwm_enable |= 1 << index;
 734                         else
 735                                 data->pwm_enable &= ~(1 << index);
 736                         w83793_write_value(client, W83793_REG_PWM_ENABLE,
 737                                                         data->pwm_enable);
 738                 } else {
 739                         mutex_unlock(&data->update_lock);
 740                         return -EINVAL;
 741                 }
 742         } else if (TEMP_CRUISE == nr) {
 743                 data->temp_cruise[index] =
 744                     w83793_read_value(client, W83793_REG_TEMP_CRUISE(index));
 745                 val = TEMP_TO_REG(simple_strtol(buf, NULL, 10), 0, 0x7f);
 746                 data->temp_cruise[index] &= 0x80;
 747                 data->temp_cruise[index] |= val;
 748
 749                 w83793_write_value(client, W83793_REG_TEMP_CRUISE(index),
 750                                                 data->temp_cruise[index]);
 751         } else {                /* TEMP_TOLERANCE */
 752                 int i = index >> 1;
 753                 u8 shift = (index & 0x01) ? 4 : 0;
 754                 data->tolerance[i] =
 755                     w83793_read_value(client, W83793_REG_TEMP_TOL(i));
 756
 757                 val = TEMP_TO_REG(simple_strtol(buf, NULL, 10), 0, 0x0f);
 758                 data->tolerance[i] &= ~(0x0f << shift);
 759                 data->tolerance[i] |= val << shift;
 760                 w83793_write_value(client, W83793_REG_TEMP_TOL(i),
 761                                                         data->tolerance[i]);
 762         }
 763
 764         mutex_unlock(&data->update_lock);
 765         return count;
 766 }
 767
 768 static ssize_t
 769 show_sf2_pwm(struct device *dev, struct device_attribute *attr, char *buf)
 770 {
 771         struct sensor_device_attribute_2 *sensor_attr =
 772             to_sensor_dev_attr_2(attr);
 773         int nr = sensor_attr->nr;
 774         int index = sensor_attr->index;
 775         struct w83793_data *data = w83793_update_device(dev);
 776
 777         return sprintf(buf, "%d\n", (data->sf2_pwm[index][nr] & 0x3f) << 2);
 778 }
 779
 780 static ssize_t
 781 store_sf2_pwm(struct device *dev, struct device_attribute *attr,
 782               const char *buf, size_t count)
 783 {
 784         struct i2c_client *client = to_i2c_client(dev);
 785         struct w83793_data *data = i2c_get_clientdata(client);
 786         struct sensor_device_attribute_2 *sensor_attr =
 787             to_sensor_dev_attr_2(attr);
 788         int nr = sensor_attr->nr;
 789         int index = sensor_attr->index;
 790         u8 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 0, 0xff) >> 2;
 791
 792         mutex_lock(&data->update_lock);
 793         data->sf2_pwm[index][nr] =
 794             w83793_read_value(client, W83793_REG_SF2_PWM(index, nr)) & 0xc0;
 795         data->sf2_pwm[index][nr] |= val;
 796         w83793_write_value(client, W83793_REG_SF2_PWM(index, nr),
 797                                                 data->sf2_pwm[index][nr]);
 798         mutex_unlock(&data->update_lock);
 799         return count;
 800 }
 801
 802 static ssize_t
 803 show_sf2_temp(struct device *dev, struct device_attribute *attr, char *buf)
 804 {
 805         struct sensor_device_attribute_2 *sensor_attr =
 806             to_sensor_dev_attr_2(attr);
 807         int nr = sensor_attr->nr;
 808         int index = sensor_attr->index;
 809         struct w83793_data *data = w83793_update_device(dev);
 810
 811         return sprintf(buf, "%ld\n",
 812                        TEMP_FROM_REG(data->sf2_temp[index][nr] & 0x7f));
 813 }
 814
 815 static ssize_t
 816 store_sf2_temp(struct device *dev, struct device_attribute *attr,
 817                const char *buf, size_t count)
 818 {
 819         struct i2c_client *client = to_i2c_client(dev);
 820         struct w83793_data *data = i2c_get_clientdata(client);
 821         struct sensor_device_attribute_2 *sensor_attr =
 822             to_sensor_dev_attr_2(attr);
 823         int nr = sensor_attr->nr;
 824         int index = sensor_attr->index;
 825         u8 val = TEMP_TO_REG(simple_strtol(buf, NULL, 10), 0, 0x7f);
 826
 827         mutex_lock(&data->update_lock);
 828         data->sf2_temp[index][nr] =
 829             w83793_read_value(client, W83793_REG_SF2_TEMP(index, nr)) & 0x80;
 830         data->sf2_temp[index][nr] |= val;
 831         w83793_write_value(client, W83793_REG_SF2_TEMP(index, nr),
 832                                              data->sf2_temp[index][nr]);
 833         mutex_unlock(&data->update_lock);
 834         return count;
 835 }
 836
 837 /* only Vcore A/B and Vtt have additional 2 bits precision */
 838 static ssize_t
 839 show_in(struct device *dev, struct device_attribute *attr, char *buf)
 840 {
 841         struct sensor_device_attribute_2 *sensor_attr =
 842             to_sensor_dev_attr_2(attr);
 843         int nr = sensor_attr->nr;
 844         int index = sensor_attr->index;
 845         struct w83793_data *data = w83793_update_device(dev);
 846         u16 val = data->in[index][nr];
 847
 848         if (index < 3) {
 849                 val <<= 2;
 850                 val += (data->in_low_bits[nr] >> (index * 2)) & 0x3;
 851         }
 852         /* voltage inputs 5VDD and 5VSB needs 150mV offset */
 853         val = val * scale_in[index] + scale_in_add[index];
 854         return sprintf(buf, "%d\n", val);
 855 }
 856
 857 static ssize_t
 858 store_in(struct device *dev, struct device_attribute *attr,
 859          const char *buf, size_t count)
 860 {
 861         struct sensor_device_attribute_2 *sensor_attr =
 862             to_sensor_dev_attr_2(attr);
 863         int nr = sensor_attr->nr;
 864         int index = sensor_attr->index;
 865         struct i2c_client *client = to_i2c_client(dev);
 866         struct w83793_data *data = i2c_get_clientdata(client);
 867         u32 val;
 868
 869         val =
 870             (simple_strtoul(buf, NULL, 10) +
 871              scale_in[index] / 2) / scale_in[index];
 872         mutex_lock(&data->update_lock);
 873         if (index > 2) {
 874                 /* fix the limit values of 5VDD and 5VSB to ALARM mechanism */
 875                 if (1 == nr || 2 == nr) {
 876                         val -= scale_in_add[index] / scale_in[index];
 877                 }
 878                 val = SENSORS_LIMIT(val, 0, 255);
 879         } else {
 880                 val = SENSORS_LIMIT(val, 0, 0x3FF);
 881                 data->in_low_bits[nr] =
 882                     w83793_read_value(client, W83793_REG_IN_LOW_BITS[nr]);
 883                 data->in_low_bits[nr] &= ~(0x03 << (2 * index));
 884                 data->in_low_bits[nr] |= (val & 0x03) << (2 * index);
 885                 w83793_write_value(client, W83793_REG_IN_LOW_BITS[nr],
 886                                                      data->in_low_bits[nr]);
 887                 val >>= 2;
 888         }
 889         data->in[index][nr] = val;
 890         w83793_write_value(client, W83793_REG_IN[index][nr],
 891                                                         data->in[index][nr]);
 892         mutex_unlock(&data->update_lock);
 893         return count;
 894 }
 895
 896 #define NOT_USED                        -1
 897
 898 #define SENSOR_ATTR_IN(index)                                           \
 899         SENSOR_ATTR_2(in##index##_input, S_IRUGO, show_in, NULL,        \
 900                 IN_READ, index),                                        \
 901         SENSOR_ATTR_2(in##index##_max, S_IRUGO | S_IWUSR, show_in,      \
 902                 store_in, IN_MAX, index),                               \
 903         SENSOR_ATTR_2(in##index##_min, S_IRUGO | S_IWUSR, show_in,      \
 904                 store_in, IN_LOW, index),                               \
 905         SENSOR_ATTR_2(in##index##_alarm, S_IRUGO, show_alarm_beep,      \
 906                 NULL, ALARM_STATUS, index + ((index > 2) ? 1 : 0)),     \
 907         SENSOR_ATTR_2(in##index##_beep, S_IWUSR | S_IRUGO,              \
 908                 show_alarm_beep, store_beep, BEEP_ENABLE,               \
 909                 index + ((index > 2) ? 1 : 0))
 910
 911 #define SENSOR_ATTR_FAN(index)                                          \
 912         SENSOR_ATTR_2(fan##index##_alarm, S_IRUGO, show_alarm_beep,     \
 913                 NULL, ALARM_STATUS, index + 17),                        \
 914         SENSOR_ATTR_2(fan##index##_beep, S_IWUSR | S_IRUGO,             \
 915                 show_alarm_beep, store_beep, BEEP_ENABLE, index + 17),  \
 916         SENSOR_ATTR_2(fan##index##_input, S_IRUGO, show_fan,            \
 917                 NULL, FAN_INPUT, index - 1),                            \
 918         SENSOR_ATTR_2(fan##index##_min, S_IWUSR | S_IRUGO,              \
 919                 show_fan, store_fan_min, FAN_MIN, index - 1)
 920
 921 #define SENSOR_ATTR_PWM(index)                                          \
 922         SENSOR_ATTR_2(pwm##index, S_IWUSR | S_IRUGO, show_pwm,          \
 923                 store_pwm, PWM_DUTY, index - 1),                        \
 924         SENSOR_ATTR_2(pwm##index##_nonstop, S_IWUSR | S_IRUGO,          \
 925                 show_pwm, store_pwm, PWM_NONSTOP, index - 1),           \
 926         SENSOR_ATTR_2(pwm##index##_start, S_IWUSR | S_IRUGO,            \
 927                 show_pwm, store_pwm, PWM_START, index - 1),             \
 928         SENSOR_ATTR_2(pwm##index##_stop_time, S_IWUSR | S_IRUGO,        \
 929                 show_pwm, store_pwm, PWM_STOP_TIME, index - 1)
 930
 931 #define SENSOR_ATTR_TEMP(index)                                         \
 932         SENSOR_ATTR_2(temp##index##_type, S_IRUGO | S_IWUSR,            \
 933                 show_temp_mode, store_temp_mode, NOT_USED, index - 1),  \
 934         SENSOR_ATTR_2(temp##index##_input, S_IRUGO, show_temp,          \
 935                 NULL, TEMP_READ, index - 1),                            \
 936         SENSOR_ATTR_2(temp##index##_max, S_IRUGO | S_IWUSR, show_temp,  \
 937                 store_temp, TEMP_CRIT, index - 1),                      \
 938         SENSOR_ATTR_2(temp##index##_max_hyst, S_IRUGO | S_IWUSR,        \
 939                 show_temp, store_temp, TEMP_CRIT_HYST, index - 1),      \
 940         SENSOR_ATTR_2(temp##index##_warn, S_IRUGO | S_IWUSR, show_temp, \
 941                 store_temp, TEMP_WARN, index - 1),                      \
 942         SENSOR_ATTR_2(temp##index##_warn_hyst, S_IRUGO | S_IWUSR,       \
 943                 show_temp, store_temp, TEMP_WARN_HYST, index - 1),      \
 944         SENSOR_ATTR_2(temp##index##_alarm, S_IRUGO,                     \
 945                 show_alarm_beep, NULL, ALARM_STATUS, index + 11),       \
 946         SENSOR_ATTR_2(temp##index##_beep, S_IWUSR | S_IRUGO,            \
 947                 show_alarm_beep, store_beep, BEEP_ENABLE, index + 11),  \
 948         SENSOR_ATTR_2(temp##index##_auto_channels_pwm,                  \
 949                 S_IRUGO | S_IWUSR, show_sf_ctrl, store_sf_ctrl,         \
 950                 TEMP_FAN_MAP, index - 1),                               \
 951         SENSOR_ATTR_2(temp##index##_pwm_enable, S_IWUSR | S_IRUGO,      \
 952                 show_sf_ctrl, store_sf_ctrl, TEMP_PWM_ENABLE,           \
 953                 index - 1),                                             \
 954         SENSOR_ATTR_2(thermal_cruise##index, S_IRUGO | S_IWUSR,         \
 955                 show_sf_ctrl, store_sf_ctrl, TEMP_CRUISE, index - 1),   \
 956         SENSOR_ATTR_2(tolerance##index, S_IRUGO | S_IWUSR, show_sf_ctrl,\
 957                 store_sf_ctrl, TEMP_TOLERANCE, index - 1),              \
 958         SENSOR_ATTR_2(temp##index##_auto_point1_pwm, S_IRUGO | S_IWUSR, \
 959                 show_sf2_pwm, store_sf2_pwm, 0, index - 1),             \
 960         SENSOR_ATTR_2(temp##index##_auto_point2_pwm, S_IRUGO | S_IWUSR, \
 961                 show_sf2_pwm, store_sf2_pwm, 1, index - 1),             \
 962         SENSOR_ATTR_2(temp##index##_auto_point3_pwm, S_IRUGO | S_IWUSR, \
 963                 show_sf2_pwm, store_sf2_pwm, 2, index - 1),             \
 964         SENSOR_ATTR_2(temp##index##_auto_point4_pwm, S_IRUGO | S_IWUSR, \
 965                 show_sf2_pwm, store_sf2_pwm, 3, index - 1),             \
 966         SENSOR_ATTR_2(temp##index##_auto_point5_pwm, S_IRUGO | S_IWUSR, \
 967                 show_sf2_pwm, store_sf2_pwm, 4, index - 1),             \
 968         SENSOR_ATTR_2(temp##index##_auto_point6_pwm, S_IRUGO | S_IWUSR, \
 969                 show_sf2_pwm, store_sf2_pwm, 5, index - 1),             \
 970         SENSOR_ATTR_2(temp##index##_auto_point7_pwm, S_IRUGO | S_IWUSR, \
 971                 show_sf2_pwm, store_sf2_pwm, 6, index - 1),             \
 972         SENSOR_ATTR_2(temp##index##_auto_point1_temp, S_IRUGO | S_IWUSR,\
 973                 show_sf2_temp, store_sf2_temp, 0, index - 1),           \
 974         SENSOR_ATTR_2(temp##index##_auto_point2_temp, S_IRUGO | S_IWUSR,\
 975                 show_sf2_temp, store_sf2_temp, 1, index - 1),           \
 976         SENSOR_ATTR_2(temp##index##_auto_point3_temp, S_IRUGO | S_IWUSR,\
 977                 show_sf2_temp, store_sf2_temp, 2, index - 1),           \
 978         SENSOR_ATTR_2(temp##index##_auto_point4_temp, S_IRUGO | S_IWUSR,\
 979                 show_sf2_temp, store_sf2_temp, 3, index - 1),           \
 980         SENSOR_ATTR_2(temp##index##_auto_point5_temp, S_IRUGO | S_IWUSR,\
 981                 show_sf2_temp, store_sf2_temp, 4, index - 1),           \
 982         SENSOR_ATTR_2(temp##index##_auto_point6_temp, S_IRUGO | S_IWUSR,\
 983                 show_sf2_temp, store_sf2_temp, 5, index - 1),           \
 984         SENSOR_ATTR_2(temp##index##_auto_point7_temp, S_IRUGO | S_IWUSR,\
 985                 show_sf2_temp, store_sf2_temp, 6, index - 1)
 986
 987 static struct sensor_device_attribute_2 w83793_sensor_attr_2[] = {
 988         SENSOR_ATTR_IN(0),
 989         SENSOR_ATTR_IN(1),
 990         SENSOR_ATTR_IN(2),
 991         SENSOR_ATTR_IN(3),
 992         SENSOR_ATTR_IN(4),
 993         SENSOR_ATTR_IN(5),
 994         SENSOR_ATTR_IN(6),
 995         SENSOR_ATTR_IN(7),
 996         SENSOR_ATTR_IN(8),
 997         SENSOR_ATTR_IN(9),
 998         SENSOR_ATTR_FAN(1),
 999         SENSOR_ATTR_FAN(2),
1000         SENSOR_ATTR_FAN(3),
1001         SENSOR_ATTR_FAN(4),
1002         SENSOR_ATTR_FAN(5),
1003         SENSOR_ATTR_PWM(1),
1004         SENSOR_ATTR_PWM(2),
1005         SENSOR_ATTR_PWM(3),
1006 };
1007
1008 static struct sensor_device_attribute_2 w83793_temp[] = {
1009         SENSOR_ATTR_TEMP(1),
1010         SENSOR_ATTR_TEMP(2),
1011         SENSOR_ATTR_TEMP(3),
1012         SENSOR_ATTR_TEMP(4),
1013         SENSOR_ATTR_TEMP(5),
1014         SENSOR_ATTR_TEMP(6),
1015 };
1016
1017 /* Fan6-Fan12 */
1018 static struct sensor_device_attribute_2 w83793_left_fan[] = {
1019         SENSOR_ATTR_FAN(6),
1020         SENSOR_ATTR_FAN(7),
1021         SENSOR_ATTR_FAN(8),
1022         SENSOR_ATTR_FAN(9),
1023         SENSOR_ATTR_FAN(10),
1024         SENSOR_ATTR_FAN(11),
1025         SENSOR_ATTR_FAN(12),
1026 };
1027
1028 /* Pwm4-Pwm8 */
1029 static struct sensor_device_attribute_2 w83793_left_pwm[] = {
1030         SENSOR_ATTR_PWM(4),
1031         SENSOR_ATTR_PWM(5),
1032         SENSOR_ATTR_PWM(6),
1033         SENSOR_ATTR_PWM(7),
1034         SENSOR_ATTR_PWM(8),
1035 };
1036
1037 static struct sensor_device_attribute_2 w83793_vid[] = {
1038         SENSOR_ATTR_2(cpu0_vid, S_IRUGO, show_vid, NULL, NOT_USED, 0),
1039         SENSOR_ATTR_2(cpu1_vid, S_IRUGO, show_vid, NULL, NOT_USED, 1),
1040 };
1041 static DEVICE_ATTR(vrm, S_IWUSR | S_IRUGO, show_vrm, store_vrm);
1042
1043 static struct sensor_device_attribute_2 sda_single_files[] = {
1044         SENSOR_ATTR_2(chassis, S_IWUSR | S_IRUGO, show_alarm_beep,
1045                       store_chassis_clear, ALARM_STATUS, 30),
1046         SENSOR_ATTR_2(beep_enable, S_IWUSR | S_IRUGO, show_beep_enable,
1047                       store_beep_enable, NOT_USED, NOT_USED),
1048         SENSOR_ATTR_2(pwm_default, S_IWUSR | S_IRUGO, show_sf_setup,
1049                       store_sf_setup, SETUP_PWM_DEFAULT, NOT_USED),
1050         SENSOR_ATTR_2(pwm_uptime, S_IWUSR | S_IRUGO, show_sf_setup,
1051                       store_sf_setup, SETUP_PWM_UPTIME, NOT_USED),
1052         SENSOR_ATTR_2(pwm_downtime, S_IWUSR | S_IRUGO, show_sf_setup,
1053                       store_sf_setup, SETUP_PWM_DOWNTIME, NOT_USED),
1054         SENSOR_ATTR_2(temp_critical, S_IWUSR | S_IRUGO, show_sf_setup,
1055                       store_sf_setup, SETUP_TEMP_CRITICAL, NOT_USED),
1056 };
1057
1058 static void w83793_init_client(struct i2c_client *client)
1059 {
1060         if (reset) {
1061                 w83793_write_value(client, W83793_REG_CONFIG, 0x80);
1062         }
1063
1064         /* Start monitoring */
1065         w83793_write_value(client, W83793_REG_CONFIG,
1066                            w83793_read_value(client, W83793_REG_CONFIG) | 0x01);
1067
1068 }
1069
1070 static int w83793_remove(struct i2c_client *client)
1071 {
1072         struct w83793_data *data = i2c_get_clientdata(client);
1073         struct device *dev = &client->dev;
1074         int i;
1075
1076         hwmon_device_unregister(data->hwmon_dev);
1077
1078         for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++)
1079                 device_remove_file(dev,
1080                                    &w83793_sensor_attr_2[i].dev_attr);
1081
1082         for (i = 0; i < ARRAY_SIZE(sda_single_files); i++)
1083                 device_remove_file(dev, &sda_single_files[i].dev_attr);
1084
1085         for (i = 0; i < ARRAY_SIZE(w83793_vid); i++)
1086                 device_remove_file(dev, &w83793_vid[i].dev_attr);
1087         device_remove_file(dev, &dev_attr_vrm);
1088
1089         for (i = 0; i < ARRAY_SIZE(w83793_left_fan); i++)
1090                 device_remove_file(dev, &w83793_left_fan[i].dev_attr);
1091
1092         for (i = 0; i < ARRAY_SIZE(w83793_left_pwm); i++)
1093                 device_remove_file(dev, &w83793_left_pwm[i].dev_attr);
1094
1095         for (i = 0; i < ARRAY_SIZE(w83793_temp); i++)
1096                 device_remove_file(dev, &w83793_temp[i].dev_attr);
1097
1098         if (data->lm75[0] != NULL)
1099                 i2c_unregister_device(data->lm75[0]);
1100         if (data->lm75[1] != NULL)
1101                 i2c_unregister_device(data->lm75[1]);
1102
1103         kfree(data);
1104
1105         return 0;
1106 }
1107
1108 static int
1109 w83793_detect_subclients(struct i2c_client *client)
1110 {
1111         int i, id, err;
1112         int address = client->addr;
1113         u8 tmp;
1114         struct i2c_adapter *adapter = client->adapter;
1115         struct w83793_data *data = i2c_get_clientdata(client);
1116
1117         id = i2c_adapter_id(adapter);
1118         if (force_subclients[0] == id && force_subclients[1] == address) {
1119                 for (i = 2; i <= 3; i++) {
1120                         if (force_subclients[i] < 0x48
1121                             || force_subclients[i] > 0x4f) {
1122                                 dev_err(&client->dev,
1123                                         "invalid subclient "
1124                                         "address %d; must be 0x48-0x4f\n",
1125                                         force_subclients[i]);
1126                                 err = -EINVAL;
1127                                 goto ERROR_SC_0;
1128                         }
1129                 }
1130                 w83793_write_value(client, W83793_REG_I2C_SUBADDR,
1131                                    (force_subclients[2] & 0x07) |
1132                                    ((force_subclients[3] & 0x07) << 4));
1133         }
1134
1135         tmp = w83793_read_value(client, W83793_REG_I2C_SUBADDR);
1136         if (!(tmp & 0x08)) {
1137                 data->lm75[0] = i2c_new_dummy(adapter, 0x48 + (tmp & 0x7));
1138         }
1139         if (!(tmp & 0x80)) {
1140                 if ((data->lm75[0] != NULL)
1141                     && ((tmp & 0x7) == ((tmp >> 4) & 0x7))) {
1142                         dev_err(&client->dev,
1143                                 "duplicate addresses 0x%x, "
1144                                 "use force_subclients\n", data->lm75[0]->addr);
1145                         err = -ENODEV;
1146                         goto ERROR_SC_1;
1147                 }
1148                 data->lm75[1] = i2c_new_dummy(adapter,
1149                                               0x48 + ((tmp >> 4) & 0x7));
1150         }
1151
1152         return 0;
1153
1154         /* Undo inits in case of errors */
1155
1156 ERROR_SC_1:
1157         if (data->lm75[0] != NULL)
1158                 i2c_unregister_device(data->lm75[0]);
1159 ERROR_SC_0:
1160         return err;
1161 }
1162
1163 /* Return 0 if detection is successful, -ENODEV otherwise */
1164 static int w83793_detect(struct i2c_client *client, int kind,
1165                          struct i2c_board_info *info)
1166 {
1167         u8 tmp, bank;
1168         struct i2c_adapter *adapter = client->adapter;
1169         unsigned short address = client->addr;
1170
1171         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1172                 return -ENODEV;
1173         }
1174
1175         bank = i2c_smbus_read_byte_data(client, W83793_REG_BANKSEL);
1176
1177         if (kind < 0) {
1178                 tmp = bank & 0x80 ? 0x5c : 0xa3;
1179                 /* Check Winbond vendor ID */
1180                 if (tmp != i2c_smbus_read_byte_data(client,
1181                                                         W83793_REG_VENDORID)) {
1182                         pr_debug("w83793: Detection failed at check "
1183                                  "vendor id\n");
1184                         return -ENODEV;
1185                 }
1186
1187                 /* If Winbond chip, address of chip and W83793_REG_I2C_ADDR
1188                    should match */
1189                 if ((bank & 0x07) == 0
1190                  && i2c_smbus_read_byte_data(client, W83793_REG_I2C_ADDR) !=
1191                     (address << 1)) {
1192                         pr_debug("w83793: Detection failed at check "
1193                                  "i2c addr\n");
1194                         return -ENODEV;
1195                 }
1196
1197         }
1198
1199         /* We have either had a force parameter, or we have already detected the
1200            Winbond. Determine the chip type now */
1201
1202         if (kind <= 0) {
1203                 if (0x7b == i2c_smbus_read_byte_data(client,
1204                                                      W83793_REG_CHIPID)) {
1205                         kind = w83793;
1206                 } else {
1207                         if (kind == 0)
1208                                 dev_warn(&adapter->dev, "w83793: Ignoring "
1209                                          "'force' parameter for unknown chip "
1210                                          "at address 0x%02x\n", address);
1211                         return -ENODEV;
1212                 }
1213         }
1214
1215         strlcpy(info->type, "w83793", I2C_NAME_SIZE);
1216
1217         return 0;
1218 }
1219
1220 static int w83793_probe(struct i2c_client *client,
1221                         const struct i2c_device_id *id)
1222 {
1223         struct device *dev = &client->dev;
1224         struct w83793_data *data;
1225         int i, tmp, val, err;
1226         int files_fan = ARRAY_SIZE(w83793_left_fan) / 7;
1227         int files_pwm = ARRAY_SIZE(w83793_left_pwm) / 5;
1228         int files_temp = ARRAY_SIZE(w83793_temp) / 6;
1229
1230         data = kzalloc(sizeof(struct w83793_data), GFP_KERNEL);
1231         if (!data) {
1232                 err = -ENOMEM;
1233                 goto exit;
1234         }
1235
1236         i2c_set_clientdata(client, data);
1237         data->bank = i2c_smbus_read_byte_data(client, W83793_REG_BANKSEL);
1238         mutex_init(&data->update_lock);
1239
1240         err = w83793_detect_subclients(client);
1241         if (err)
1242                 goto free_mem;
1243
1244         /* Initialize the chip */
1245         w83793_init_client(client);
1246
1247         /*
1248            Only fan 1-5 has their own input pins,
1249            Pwm 1-3 has their own pins
1250          */
1251         data->has_fan = 0x1f;
1252         data->has_pwm = 0x07;
1253         tmp = w83793_read_value(client, W83793_REG_MFC);
1254         val = w83793_read_value(client, W83793_REG_FANIN_CTRL);
1255
1256         /* check the function of pins 49-56 */
1257         if (tmp & 0x80) {
1258                 data->has_vid |= 0x2;   /* has VIDB */
1259         } else {
1260                 data->has_pwm |= 0x18;  /* pwm 4,5 */
1261                 if (val & 0x01) {       /* fan 6 */
1262                         data->has_fan |= 0x20;
1263                         data->has_pwm |= 0x20;
1264                 }
1265                 if (val & 0x02) {       /* fan 7 */
1266                         data->has_fan |= 0x40;
1267                         data->has_pwm |= 0x40;
1268                 }
1269                 if (!(tmp & 0x40) && (val & 0x04)) {    /* fan 8 */
1270                         data->has_fan |= 0x80;
1271                         data->has_pwm |= 0x80;
1272                 }
1273         }
1274
1275         /* check the function of pins 37-40 */
1276         if (!(tmp & 0x29))
1277                 data->has_vid |= 0x1;   /* has VIDA */
1278         if (0x08 == (tmp & 0x0c)) {
1279                 if (val & 0x08) /* fan 9 */
1280                         data->has_fan |= 0x100;
1281                 if (val & 0x10) /* fan 10 */
1282                         data->has_fan |= 0x200;
1283         }
1284         if (0x20 == (tmp & 0x30)) {
1285                 if (val & 0x20) /* fan 11 */
1286                         data->has_fan |= 0x400;
1287                 if (val & 0x40) /* fan 12 */
1288                         data->has_fan |= 0x800;
1289         }
1290
1291         if ((tmp & 0x01) && (val & 0x04)) {     /* fan 8, second location */
1292                 data->has_fan |= 0x80;
1293                 data->has_pwm |= 0x80;
1294         }
1295
1296         tmp = w83793_read_value(client, W83793_REG_FANIN_SEL);
1297         if ((tmp & 0x01) && (val & 0x08)) {     /* fan 9, second location */
1298                 data->has_fan |= 0x100;
1299         }
1300         if ((tmp & 0x02) && (val & 0x10)) {     /* fan 10, second location */
1301                 data->has_fan |= 0x200;
1302         }
1303         if ((tmp & 0x04) && (val & 0x20)) {     /* fan 11, second location */
1304                 data->has_fan |= 0x400;
1305         }
1306         if ((tmp & 0x08) && (val & 0x40)) {     /* fan 12, second location */
1307                 data->has_fan |= 0x800;
1308         }
1309
1310         /* check the temp1-6 mode, ignore former AMDSI selected inputs */
1311         tmp = w83793_read_value(client,W83793_REG_TEMP_MODE[0]);
1312         if (tmp & 0x01)
1313                 data->has_temp |= 0x01;
1314         if (tmp & 0x04)
1315                 data->has_temp |= 0x02;
1316         if (tmp & 0x10)
1317                 data->has_temp |= 0x04;
1318         if (tmp & 0x40)
1319                 data->has_temp |= 0x08;
1320
1321         tmp = w83793_read_value(client,W83793_REG_TEMP_MODE[1]);
1322         if (tmp & 0x01)
1323                 data->has_temp |= 0x10;
1324         if (tmp & 0x02)
1325                 data->has_temp |= 0x20;
1326
1327         /* Register sysfs hooks */
1328         for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++) {
1329                 err = device_create_file(dev,
1330                                          &w83793_sensor_attr_2[i].dev_attr);
1331                 if (err)
1332                         goto exit_remove;
1333         }
1334
1335         for (i = 0; i < ARRAY_SIZE(w83793_vid); i++) {
1336                 if (!(data->has_vid & (1 << i)))
1337                         continue;
1338                 err = device_create_file(dev, &w83793_vid[i].dev_attr);
1339                 if (err)
1340                         goto exit_remove;
1341         }
1342         if (data->has_vid) {
1343                 data->vrm = vid_which_vrm();
1344                 err = device_create_file(dev, &dev_attr_vrm);
1345                 if (err)
1346                         goto exit_remove;
1347         }
1348
1349         for (i = 0; i < ARRAY_SIZE(sda_single_files); i++) {
1350                 err = device_create_file(dev, &sda_single_files[i].dev_attr);
1351                 if (err)
1352                         goto exit_remove;
1353
1354         }
1355
1356         for (i = 0; i < 6; i++) {
1357                 int j;
1358                 if (!(data->has_temp & (1 << i)))
1359                         continue;
1360                 for (j = 0; j < files_temp; j++) {
1361                         err = device_create_file(dev,
1362                                                 &w83793_temp[(i) * files_temp
1363                                                                 + j].dev_attr);
1364                         if (err)
1365                                 goto exit_remove;
1366                 }
1367         }
1368
1369         for (i = 5; i < 12; i++) {
1370                 int j;
1371                 if (!(data->has_fan & (1 << i)))
1372                         continue;
1373                 for (j = 0; j < files_fan; j++) {
1374                         err = device_create_file(dev,
1375                                            &w83793_left_fan[(i - 5) * files_fan
1376                                                                 + j].dev_attr);
1377                         if (err)
1378                                 goto exit_remove;
1379                 }
1380         }
1381
1382         for (i = 3; i < 8; i++) {
1383                 int j;
1384                 if (!(data->has_pwm & (1 << i)))
1385                         continue;
1386                 for (j = 0; j < files_pwm; j++) {
1387                         err = device_create_file(dev,
1388                                            &w83793_left_pwm[(i - 3) * files_pwm
1389                                                                 + j].dev_attr);
1390                         if (err)
1391                                 goto exit_remove;
1392                 }
1393         }
1394
1395         data->hwmon_dev = hwmon_device_register(dev);
1396         if (IS_ERR(data->hwmon_dev)) {
1397                 err = PTR_ERR(data->hwmon_dev);
1398                 goto exit_remove;
1399         }
1400
1401         return 0;
1402
1403         /* Unregister sysfs hooks */
1404
1405 exit_remove:
1406         for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++)
1407                 device_remove_file(dev, &w83793_sensor_attr_2[i].dev_attr);
1408
1409         for (i = 0; i < ARRAY_SIZE(sda_single_files); i++)
1410                 device_remove_file(dev, &sda_single_files[i].dev_attr);
1411
1412         for (i = 0; i < ARRAY_SIZE(w83793_vid); i++)
1413                 device_remove_file(dev, &w83793_vid[i].dev_attr);
1414
1415         for (i = 0; i < ARRAY_SIZE(w83793_left_fan); i++)
1416                 device_remove_file(dev, &w83793_left_fan[i].dev_attr);
1417
1418         for (i = 0; i < ARRAY_SIZE(w83793_left_pwm); i++)
1419                 device_remove_file(dev, &w83793_left_pwm[i].dev_attr);
1420
1421         for (i = 0; i < ARRAY_SIZE(w83793_temp); i++)
1422                 device_remove_file(dev, &w83793_temp[i].dev_attr);
1423
1424         if (data->lm75[0] != NULL)
1425                 i2c_unregister_device(data->lm75[0]);
1426         if (data->lm75[1] != NULL)
1427                 i2c_unregister_device(data->lm75[1]);
1428 free_mem:
1429         kfree(data);
1430 exit:
1431         return err;
1432 }
1433
1434 static void w83793_update_nonvolatile(struct device *dev)
1435 {
1436         struct i2c_client *client = to_i2c_client(dev);
1437         struct w83793_data *data = i2c_get_clientdata(client);
1438         int i, j;
1439         /*
1440            They are somewhat "stable" registers, and to update them everytime
1441            takes so much time, it's just not worthy. Update them in a long
1442            interval to avoid exception.
1443          */
1444         if (!(time_after(jiffies, data->last_nonvolatile + HZ * 300)
1445               || !data->valid))
1446                 return;
1447         /* update voltage limits */
1448         for (i = 1; i < 3; i++) {
1449                 for (j = 0; j < ARRAY_SIZE(data->in); j++) {
1450                         data->in[j][i] =
1451                             w83793_read_value(client, W83793_REG_IN[j][i]);
1452                 }
1453                 data->in_low_bits[i] =
1454                     w83793_read_value(client, W83793_REG_IN_LOW_BITS[i]);
1455         }
1456
1457         for (i = 0; i < ARRAY_SIZE(data->fan_min); i++) {
1458                 /* Update the Fan measured value and limits */
1459                 if (!(data->has_fan & (1 << i))) {
1460                         continue;
1461                 }
1462                 data->fan_min[i] =
1463                     w83793_read_value(client, W83793_REG_FAN_MIN(i)) << 8;
1464                 data->fan_min[i] |=
1465                     w83793_read_value(client, W83793_REG_FAN_MIN(i) + 1);
1466         }
1467
1468         for (i = 0; i < ARRAY_SIZE(data->temp_fan_map); i++) {
1469                 if (!(data->has_temp & (1 << i)))
1470                         continue;
1471                 data->temp_fan_map[i] =
1472                     w83793_read_value(client, W83793_REG_TEMP_FAN_MAP(i));
1473                 for (j = 1; j < 5; j++) {
1474                         data->temp[i][j] =
1475                             w83793_read_value(client, W83793_REG_TEMP[i][j]);
1476                 }
1477                 data->temp_cruise[i] =
1478                     w83793_read_value(client, W83793_REG_TEMP_CRUISE(i));
1479                 for (j = 0; j < 7; j++) {
1480                         data->sf2_pwm[i][j] =
1481                             w83793_read_value(client, W83793_REG_SF2_PWM(i, j));
1482                         data->sf2_temp[i][j] =
1483                             w83793_read_value(client,
1484                                               W83793_REG_SF2_TEMP(i, j));
1485                 }
1486         }
1487
1488         for (i = 0; i < ARRAY_SIZE(data->temp_mode); i++)
1489                 data->temp_mode[i] =
1490                     w83793_read_value(client, W83793_REG_TEMP_MODE[i]);
1491
1492         for (i = 0; i < ARRAY_SIZE(data->tolerance); i++) {
1493                 data->tolerance[i] =
1494                     w83793_read_value(client, W83793_REG_TEMP_TOL(i));
1495         }
1496
1497         for (i = 0; i < ARRAY_SIZE(data->pwm); i++) {
1498                 if (!(data->has_pwm & (1 << i)))
1499                         continue;
1500                 data->pwm[i][PWM_NONSTOP] =
1501                     w83793_read_value(client, W83793_REG_PWM(i, PWM_NONSTOP));
1502                 data->pwm[i][PWM_START] =
1503                     w83793_read_value(client, W83793_REG_PWM(i, PWM_START));
1504                 data->pwm_stop_time[i] =
1505                     w83793_read_value(client, W83793_REG_PWM_STOP_TIME(i));
1506         }
1507
1508         data->pwm_default = w83793_read_value(client, W83793_REG_PWM_DEFAULT);
1509         data->pwm_enable = w83793_read_value(client, W83793_REG_PWM_ENABLE);
1510         data->pwm_uptime = w83793_read_value(client, W83793_REG_PWM_UPTIME);
1511         data->pwm_downtime = w83793_read_value(client, W83793_REG_PWM_DOWNTIME);
1512         data->temp_critical =
1513             w83793_read_value(client, W83793_REG_TEMP_CRITICAL);
1514         data->beep_enable = w83793_read_value(client, W83793_REG_OVT_BEEP);
1515
1516         for (i = 0; i < ARRAY_SIZE(data->beeps); i++) {
1517                 data->beeps[i] = w83793_read_value(client, W83793_REG_BEEP(i));
1518         }
1519
1520         data->last_nonvolatile = jiffies;
1521 }
1522
1523 static struct w83793_data *w83793_update_device(struct device *dev)
1524 {
1525         struct i2c_client *client = to_i2c_client(dev);
1526         struct w83793_data *data = i2c_get_clientdata(client);
1527         int i;
1528
1529         mutex_lock(&data->update_lock);
1530
1531         if (!(time_after(jiffies, data->last_updated + HZ * 2)
1532               || !data->valid))
1533                 goto END;
1534
1535         /* Update the voltages measured value and limits */
1536         for (i = 0; i < ARRAY_SIZE(data->in); i++)
1537                 data->in[i][IN_READ] =
1538                     w83793_read_value(client, W83793_REG_IN[i][IN_READ]);
1539
1540         data->in_low_bits[IN_READ] =
1541             w83793_read_value(client, W83793_REG_IN_LOW_BITS[IN_READ]);
1542
1543         for (i = 0; i < ARRAY_SIZE(data->fan); i++) {
1544                 if (!(data->has_fan & (1 << i))) {
1545                         continue;
1546                 }
1547                 data->fan[i] =
1548                     w83793_read_value(client, W83793_REG_FAN(i)) << 8;
1549                 data->fan[i] |=
1550                     w83793_read_value(client, W83793_REG_FAN(i) + 1);
1551         }
1552
1553         for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
1554                 if (!(data->has_temp & (1 << i)))
1555                         continue;
1556                 data->temp[i][TEMP_READ] =
1557                     w83793_read_value(client, W83793_REG_TEMP[i][TEMP_READ]);
1558         }
1559
1560         data->temp_low_bits =
1561             w83793_read_value(client, W83793_REG_TEMP_LOW_BITS);
1562
1563         for (i = 0; i < ARRAY_SIZE(data->pwm); i++) {
1564                 if (data->has_pwm & (1 << i))
1565                         data->pwm[i][PWM_DUTY] =
1566                             w83793_read_value(client,
1567                                               W83793_REG_PWM(i, PWM_DUTY));
1568         }
1569
1570         for (i = 0; i < ARRAY_SIZE(data->alarms); i++)
1571                 data->alarms[i] =
1572                     w83793_read_value(client, W83793_REG_ALARM(i));
1573         if (data->has_vid & 0x01)
1574                 data->vid[0] = w83793_read_value(client, W83793_REG_VID_INA);
1575         if (data->has_vid & 0x02)
1576                 data->vid[1] = w83793_read_value(client, W83793_REG_VID_INB);
1577         w83793_update_nonvolatile(dev);
1578         data->last_updated = jiffies;
1579         data->valid = 1;
1580
1581 END:
1582         mutex_unlock(&data->update_lock);
1583         return data;
1584 }
1585
1586 /* Ignore the possibility that somebody change bank outside the driver
1587    Must be called with data->update_lock held, except during initialization */
1588 static u8 w83793_read_value(struct i2c_client *client, u16 reg)
1589 {
1590         struct w83793_data *data = i2c_get_clientdata(client);
1591         u8 res = 0xff;
1592         u8 new_bank = reg >> 8;
1593
1594         new_bank |= data->bank & 0xfc;
1595         if (data->bank != new_bank) {
1596                 if (i2c_smbus_write_byte_data
1597                     (client, W83793_REG_BANKSEL, new_bank) >= 0)
1598                         data->bank = new_bank;
1599                 else {
1600                         dev_err(&client->dev,
1601                                 "set bank to %d failed, fall back "
1602                                 "to bank %d, read reg 0x%x error\n",
1603                                 new_bank, data->bank, reg);
1604                         res = 0x0;      /* read 0x0 from the chip */
1605                         goto END;
1606                 }
1607         }
1608         res = i2c_smbus_read_byte_data(client, reg & 0xff);
1609 END:
1610         return res;
1611 }
1612
1613 /* Must be called with data->update_lock held, except during initialization */
1614 static int w83793_write_value(struct i2c_client *client, u16 reg, u8 value)
1615 {
1616         struct w83793_data *data = i2c_get_clientdata(client);
1617         int res;
1618         u8 new_bank = reg >> 8;
1619
1620         new_bank |= data->bank & 0xfc;
1621         if (data->bank != new_bank) {
1622                 if ((res = i2c_smbus_write_byte_data
1623                     (client, W83793_REG_BANKSEL, new_bank)) >= 0)
1624                         data->bank = new_bank;
1625                 else {
1626                         dev_err(&client->dev,
1627                                 "set bank to %d failed, fall back "
1628                                 "to bank %d, write reg 0x%x error\n",
1629                                 new_bank, data->bank, reg);
1630                         goto END;
1631                 }
1632         }
1633
1634         res = i2c_smbus_write_byte_data(client, reg & 0xff, value);
1635 END:
1636         return res;
1637 }
1638
1639 static int __init sensors_w83793_init(void)
1640 {
1641         return i2c_add_driver(&w83793_driver);
1642 }
1643
1644 static void __exit sensors_w83793_exit(void)
1645 {
1646         i2c_del_driver(&w83793_driver);
1647 }
1648
1649 MODULE_AUTHOR("Yuan Mu");
1650 MODULE_DESCRIPTION("w83793 driver");
1651 MODULE_LICENSE("GPL");
1652
1653 module_init(sensors_w83793_init);
1654 module_exit(sensors_w83793_exit);