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