SAFE public projects git trees. - safe/jmp/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,
 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,
1165                          struct i2c_board_info *info)
1166 {
1167         u8 tmp, bank, chip_id;
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         tmp = bank & 0x80 ? 0x5c : 0xa3;
1178         /* Check Winbond vendor ID */
1179         if (tmp != i2c_smbus_read_byte_data(client, W83793_REG_VENDORID)) {
1180                 pr_debug("w83793: Detection failed at check vendor id\n");
1181                 return -ENODEV;
1182         }
1183
1184         /* If Winbond chip, address of chip and W83793_REG_I2C_ADDR
1185            should match */
1186         if ((bank & 0x07) == 0
1187          && i2c_smbus_read_byte_data(client, W83793_REG_I2C_ADDR) !=
1188             (address << 1)) {
1189                 pr_debug("w83793: Detection failed at check i2c addr\n");
1190                 return -ENODEV;
1191         }
1192
1193         /* Determine the chip type now */
1194         chip_id = i2c_smbus_read_byte_data(client, W83793_REG_CHIPID);
1195         if (chip_id != 0x7b)
1196                 return -ENODEV;
1197
1198         strlcpy(info->type, "w83793", I2C_NAME_SIZE);
1199
1200         return 0;
1201 }
1202
1203 static int w83793_probe(struct i2c_client *client,
1204                         const struct i2c_device_id *id)
1205 {
1206         struct device *dev = &client->dev;
1207         struct w83793_data *data;
1208         int i, tmp, val, err;
1209         int files_fan = ARRAY_SIZE(w83793_left_fan) / 7;
1210         int files_pwm = ARRAY_SIZE(w83793_left_pwm) / 5;
1211         int files_temp = ARRAY_SIZE(w83793_temp) / 6;
1212
1213         data = kzalloc(sizeof(struct w83793_data), GFP_KERNEL);
1214         if (!data) {
1215                 err = -ENOMEM;
1216                 goto exit;
1217         }
1218
1219         i2c_set_clientdata(client, data);
1220         data->bank = i2c_smbus_read_byte_data(client, W83793_REG_BANKSEL);
1221         mutex_init(&data->update_lock);
1222
1223         err = w83793_detect_subclients(client);
1224         if (err)
1225                 goto free_mem;
1226
1227         /* Initialize the chip */
1228         w83793_init_client(client);
1229
1230         /*
1231            Only fan 1-5 has their own input pins,
1232            Pwm 1-3 has their own pins
1233          */
1234         data->has_fan = 0x1f;
1235         data->has_pwm = 0x07;
1236         tmp = w83793_read_value(client, W83793_REG_MFC);
1237         val = w83793_read_value(client, W83793_REG_FANIN_CTRL);
1238
1239         /* check the function of pins 49-56 */
1240         if (tmp & 0x80) {
1241                 data->has_vid |= 0x2;   /* has VIDB */
1242         } else {
1243                 data->has_pwm |= 0x18;  /* pwm 4,5 */
1244                 if (val & 0x01) {       /* fan 6 */
1245                         data->has_fan |= 0x20;
1246                         data->has_pwm |= 0x20;
1247                 }
1248                 if (val & 0x02) {       /* fan 7 */
1249                         data->has_fan |= 0x40;
1250                         data->has_pwm |= 0x40;
1251                 }
1252                 if (!(tmp & 0x40) && (val & 0x04)) {    /* fan 8 */
1253                         data->has_fan |= 0x80;
1254                         data->has_pwm |= 0x80;
1255                 }
1256         }
1257
1258         /* check the function of pins 37-40 */
1259         if (!(tmp & 0x29))
1260                 data->has_vid |= 0x1;   /* has VIDA */
1261         if (0x08 == (tmp & 0x0c)) {
1262                 if (val & 0x08) /* fan 9 */
1263                         data->has_fan |= 0x100;
1264                 if (val & 0x10) /* fan 10 */
1265                         data->has_fan |= 0x200;
1266         }
1267         if (0x20 == (tmp & 0x30)) {
1268                 if (val & 0x20) /* fan 11 */
1269                         data->has_fan |= 0x400;
1270                 if (val & 0x40) /* fan 12 */
1271                         data->has_fan |= 0x800;
1272         }
1273
1274         if ((tmp & 0x01) && (val & 0x04)) {     /* fan 8, second location */
1275                 data->has_fan |= 0x80;
1276                 data->has_pwm |= 0x80;
1277         }
1278
1279         tmp = w83793_read_value(client, W83793_REG_FANIN_SEL);
1280         if ((tmp & 0x01) && (val & 0x08)) {     /* fan 9, second location */
1281                 data->has_fan |= 0x100;
1282         }
1283         if ((tmp & 0x02) && (val & 0x10)) {     /* fan 10, second location */
1284                 data->has_fan |= 0x200;
1285         }
1286         if ((tmp & 0x04) && (val & 0x20)) {     /* fan 11, second location */
1287                 data->has_fan |= 0x400;
1288         }
1289         if ((tmp & 0x08) && (val & 0x40)) {     /* fan 12, second location */
1290                 data->has_fan |= 0x800;
1291         }
1292
1293         /* check the temp1-6 mode, ignore former AMDSI selected inputs */
1294         tmp = w83793_read_value(client,W83793_REG_TEMP_MODE[0]);
1295         if (tmp & 0x01)
1296                 data->has_temp |= 0x01;
1297         if (tmp & 0x04)
1298                 data->has_temp |= 0x02;
1299         if (tmp & 0x10)
1300                 data->has_temp |= 0x04;
1301         if (tmp & 0x40)
1302                 data->has_temp |= 0x08;
1303
1304         tmp = w83793_read_value(client,W83793_REG_TEMP_MODE[1]);
1305         if (tmp & 0x01)
1306                 data->has_temp |= 0x10;
1307         if (tmp & 0x02)
1308                 data->has_temp |= 0x20;
1309
1310         /* Register sysfs hooks */
1311         for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++) {
1312                 err = device_create_file(dev,
1313                                          &w83793_sensor_attr_2[i].dev_attr);
1314                 if (err)
1315                         goto exit_remove;
1316         }
1317
1318         for (i = 0; i < ARRAY_SIZE(w83793_vid); i++) {
1319                 if (!(data->has_vid & (1 << i)))
1320                         continue;
1321                 err = device_create_file(dev, &w83793_vid[i].dev_attr);
1322                 if (err)
1323                         goto exit_remove;
1324         }
1325         if (data->has_vid) {
1326                 data->vrm = vid_which_vrm();
1327                 err = device_create_file(dev, &dev_attr_vrm);
1328                 if (err)
1329                         goto exit_remove;
1330         }
1331
1332         for (i = 0; i < ARRAY_SIZE(sda_single_files); i++) {
1333                 err = device_create_file(dev, &sda_single_files[i].dev_attr);
1334                 if (err)
1335                         goto exit_remove;
1336
1337         }
1338
1339         for (i = 0; i < 6; i++) {
1340                 int j;
1341                 if (!(data->has_temp & (1 << i)))
1342                         continue;
1343                 for (j = 0; j < files_temp; j++) {
1344                         err = device_create_file(dev,
1345                                                 &w83793_temp[(i) * files_temp
1346                                                                 + j].dev_attr);
1347                         if (err)
1348                                 goto exit_remove;
1349                 }
1350         }
1351
1352         for (i = 5; i < 12; i++) {
1353                 int j;
1354                 if (!(data->has_fan & (1 << i)))
1355                         continue;
1356                 for (j = 0; j < files_fan; j++) {
1357                         err = device_create_file(dev,
1358                                            &w83793_left_fan[(i - 5) * files_fan
1359                                                                 + j].dev_attr);
1360                         if (err)
1361                                 goto exit_remove;
1362                 }
1363         }
1364
1365         for (i = 3; i < 8; i++) {
1366                 int j;
1367                 if (!(data->has_pwm & (1 << i)))
1368                         continue;
1369                 for (j = 0; j < files_pwm; j++) {
1370                         err = device_create_file(dev,
1371                                            &w83793_left_pwm[(i - 3) * files_pwm
1372                                                                 + j].dev_attr);
1373                         if (err)
1374                                 goto exit_remove;
1375                 }
1376         }
1377
1378         data->hwmon_dev = hwmon_device_register(dev);
1379         if (IS_ERR(data->hwmon_dev)) {
1380                 err = PTR_ERR(data->hwmon_dev);
1381                 goto exit_remove;
1382         }
1383
1384         return 0;
1385
1386         /* Unregister sysfs hooks */
1387
1388 exit_remove:
1389         for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++)
1390                 device_remove_file(dev, &w83793_sensor_attr_2[i].dev_attr);
1391
1392         for (i = 0; i < ARRAY_SIZE(sda_single_files); i++)
1393                 device_remove_file(dev, &sda_single_files[i].dev_attr);
1394
1395         for (i = 0; i < ARRAY_SIZE(w83793_vid); i++)
1396                 device_remove_file(dev, &w83793_vid[i].dev_attr);
1397
1398         for (i = 0; i < ARRAY_SIZE(w83793_left_fan); i++)
1399                 device_remove_file(dev, &w83793_left_fan[i].dev_attr);
1400
1401         for (i = 0; i < ARRAY_SIZE(w83793_left_pwm); i++)
1402                 device_remove_file(dev, &w83793_left_pwm[i].dev_attr);
1403
1404         for (i = 0; i < ARRAY_SIZE(w83793_temp); i++)
1405                 device_remove_file(dev, &w83793_temp[i].dev_attr);
1406
1407         if (data->lm75[0] != NULL)
1408                 i2c_unregister_device(data->lm75[0]);
1409         if (data->lm75[1] != NULL)
1410                 i2c_unregister_device(data->lm75[1]);
1411 free_mem:
1412         kfree(data);
1413 exit:
1414         return err;
1415 }
1416
1417 static void w83793_update_nonvolatile(struct device *dev)
1418 {
1419         struct i2c_client *client = to_i2c_client(dev);
1420         struct w83793_data *data = i2c_get_clientdata(client);
1421         int i, j;
1422         /*
1423            They are somewhat "stable" registers, and to update them everytime
1424            takes so much time, it's just not worthy. Update them in a long
1425            interval to avoid exception.
1426          */
1427         if (!(time_after(jiffies, data->last_nonvolatile + HZ * 300)
1428               || !data->valid))
1429                 return;
1430         /* update voltage limits */
1431         for (i = 1; i < 3; i++) {
1432                 for (j = 0; j < ARRAY_SIZE(data->in); j++) {
1433                         data->in[j][i] =
1434                             w83793_read_value(client, W83793_REG_IN[j][i]);
1435                 }
1436                 data->in_low_bits[i] =
1437                     w83793_read_value(client, W83793_REG_IN_LOW_BITS[i]);
1438         }
1439
1440         for (i = 0; i < ARRAY_SIZE(data->fan_min); i++) {
1441                 /* Update the Fan measured value and limits */
1442                 if (!(data->has_fan & (1 << i))) {
1443                         continue;
1444                 }
1445                 data->fan_min[i] =
1446                     w83793_read_value(client, W83793_REG_FAN_MIN(i)) << 8;
1447                 data->fan_min[i] |=
1448                     w83793_read_value(client, W83793_REG_FAN_MIN(i) + 1);
1449         }
1450
1451         for (i = 0; i < ARRAY_SIZE(data->temp_fan_map); i++) {
1452                 if (!(data->has_temp & (1 << i)))
1453                         continue;
1454                 data->temp_fan_map[i] =
1455                     w83793_read_value(client, W83793_REG_TEMP_FAN_MAP(i));
1456                 for (j = 1; j < 5; j++) {
1457                         data->temp[i][j] =
1458                             w83793_read_value(client, W83793_REG_TEMP[i][j]);
1459                 }
1460                 data->temp_cruise[i] =
1461                     w83793_read_value(client, W83793_REG_TEMP_CRUISE(i));
1462                 for (j = 0; j < 7; j++) {
1463                         data->sf2_pwm[i][j] =
1464                             w83793_read_value(client, W83793_REG_SF2_PWM(i, j));
1465                         data->sf2_temp[i][j] =
1466                             w83793_read_value(client,
1467                                               W83793_REG_SF2_TEMP(i, j));
1468                 }
1469         }
1470
1471         for (i = 0; i < ARRAY_SIZE(data->temp_mode); i++)
1472                 data->temp_mode[i] =
1473                     w83793_read_value(client, W83793_REG_TEMP_MODE[i]);
1474
1475         for (i = 0; i < ARRAY_SIZE(data->tolerance); i++) {
1476                 data->tolerance[i] =
1477                     w83793_read_value(client, W83793_REG_TEMP_TOL(i));
1478         }
1479
1480         for (i = 0; i < ARRAY_SIZE(data->pwm); i++) {
1481                 if (!(data->has_pwm & (1 << i)))
1482                         continue;
1483                 data->pwm[i][PWM_NONSTOP] =
1484                     w83793_read_value(client, W83793_REG_PWM(i, PWM_NONSTOP));
1485                 data->pwm[i][PWM_START] =
1486                     w83793_read_value(client, W83793_REG_PWM(i, PWM_START));
1487                 data->pwm_stop_time[i] =
1488                     w83793_read_value(client, W83793_REG_PWM_STOP_TIME(i));
1489         }
1490
1491         data->pwm_default = w83793_read_value(client, W83793_REG_PWM_DEFAULT);
1492         data->pwm_enable = w83793_read_value(client, W83793_REG_PWM_ENABLE);
1493         data->pwm_uptime = w83793_read_value(client, W83793_REG_PWM_UPTIME);
1494         data->pwm_downtime = w83793_read_value(client, W83793_REG_PWM_DOWNTIME);
1495         data->temp_critical =
1496             w83793_read_value(client, W83793_REG_TEMP_CRITICAL);
1497         data->beep_enable = w83793_read_value(client, W83793_REG_OVT_BEEP);
1498
1499         for (i = 0; i < ARRAY_SIZE(data->beeps); i++) {
1500                 data->beeps[i] = w83793_read_value(client, W83793_REG_BEEP(i));
1501         }
1502
1503         data->last_nonvolatile = jiffies;
1504 }
1505
1506 static struct w83793_data *w83793_update_device(struct device *dev)
1507 {
1508         struct i2c_client *client = to_i2c_client(dev);
1509         struct w83793_data *data = i2c_get_clientdata(client);
1510         int i;
1511
1512         mutex_lock(&data->update_lock);
1513
1514         if (!(time_after(jiffies, data->last_updated + HZ * 2)
1515               || !data->valid))
1516                 goto END;
1517
1518         /* Update the voltages measured value and limits */
1519         for (i = 0; i < ARRAY_SIZE(data->in); i++)
1520                 data->in[i][IN_READ] =
1521                     w83793_read_value(client, W83793_REG_IN[i][IN_READ]);
1522
1523         data->in_low_bits[IN_READ] =
1524             w83793_read_value(client, W83793_REG_IN_LOW_BITS[IN_READ]);
1525
1526         for (i = 0; i < ARRAY_SIZE(data->fan); i++) {
1527                 if (!(data->has_fan & (1 << i))) {
1528                         continue;
1529                 }
1530                 data->fan[i] =
1531                     w83793_read_value(client, W83793_REG_FAN(i)) << 8;
1532                 data->fan[i] |=
1533                     w83793_read_value(client, W83793_REG_FAN(i) + 1);
1534         }
1535
1536         for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
1537                 if (!(data->has_temp & (1 << i)))
1538                         continue;
1539                 data->temp[i][TEMP_READ] =
1540                     w83793_read_value(client, W83793_REG_TEMP[i][TEMP_READ]);
1541         }
1542
1543         data->temp_low_bits =
1544             w83793_read_value(client, W83793_REG_TEMP_LOW_BITS);
1545
1546         for (i = 0; i < ARRAY_SIZE(data->pwm); i++) {
1547                 if (data->has_pwm & (1 << i))
1548                         data->pwm[i][PWM_DUTY] =
1549                             w83793_read_value(client,
1550                                               W83793_REG_PWM(i, PWM_DUTY));
1551         }
1552
1553         for (i = 0; i < ARRAY_SIZE(data->alarms); i++)
1554                 data->alarms[i] =
1555                     w83793_read_value(client, W83793_REG_ALARM(i));
1556         if (data->has_vid & 0x01)
1557                 data->vid[0] = w83793_read_value(client, W83793_REG_VID_INA);
1558         if (data->has_vid & 0x02)
1559                 data->vid[1] = w83793_read_value(client, W83793_REG_VID_INB);
1560         w83793_update_nonvolatile(dev);
1561         data->last_updated = jiffies;
1562         data->valid = 1;
1563
1564 END:
1565         mutex_unlock(&data->update_lock);
1566         return data;
1567 }
1568
1569 /* Ignore the possibility that somebody change bank outside the driver
1570    Must be called with data->update_lock held, except during initialization */
1571 static u8 w83793_read_value(struct i2c_client *client, u16 reg)
1572 {
1573         struct w83793_data *data = i2c_get_clientdata(client);
1574         u8 res = 0xff;
1575         u8 new_bank = reg >> 8;
1576
1577         new_bank |= data->bank & 0xfc;
1578         if (data->bank != new_bank) {
1579                 if (i2c_smbus_write_byte_data
1580                     (client, W83793_REG_BANKSEL, new_bank) >= 0)
1581                         data->bank = new_bank;
1582                 else {
1583                         dev_err(&client->dev,
1584                                 "set bank to %d failed, fall back "
1585                                 "to bank %d, read reg 0x%x error\n",
1586                                 new_bank, data->bank, reg);
1587                         res = 0x0;      /* read 0x0 from the chip */
1588                         goto END;
1589                 }
1590         }
1591         res = i2c_smbus_read_byte_data(client, reg & 0xff);
1592 END:
1593         return res;
1594 }
1595
1596 /* Must be called with data->update_lock held, except during initialization */
1597 static int w83793_write_value(struct i2c_client *client, u16 reg, u8 value)
1598 {
1599         struct w83793_data *data = i2c_get_clientdata(client);
1600         int res;
1601         u8 new_bank = reg >> 8;
1602
1603         new_bank |= data->bank & 0xfc;
1604         if (data->bank != new_bank) {
1605                 if ((res = i2c_smbus_write_byte_data
1606                     (client, W83793_REG_BANKSEL, new_bank)) >= 0)
1607                         data->bank = new_bank;
1608                 else {
1609                         dev_err(&client->dev,
1610                                 "set bank to %d failed, fall back "
1611                                 "to bank %d, write reg 0x%x error\n",
1612                                 new_bank, data->bank, reg);
1613                         goto END;
1614                 }
1615         }
1616
1617         res = i2c_smbus_write_byte_data(client, reg & 0xff, value);
1618 END:
1619         return res;
1620 }
1621
1622 static int __init sensors_w83793_init(void)
1623 {
1624         return i2c_add_driver(&w83793_driver);
1625 }
1626
1627 static void __exit sensors_w83793_exit(void)
1628 {
1629         i2c_del_driver(&w83793_driver);
1630 }
1631
1632 MODULE_AUTHOR("Yuan Mu");
1633 MODULE_DESCRIPTION("w83793 driver");
1634 MODULE_LICENSE("GPL");
1635
1636 module_init(sensors_w83793_init);
1637 module_exit(sensors_w83793_exit);