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