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     Copyright (C) 2009-2010 Sven Anders <anders@anduras.de>, ANDURAS AG.
   7                   Watchdog driver part
   8                   (Based partially on fschmd driver,
   9                    Copyright 2007-2008 by Hans de Goede)
  10
  11     This program is free software; you can redistribute it and/or modify
  12     it under the terms of the GNU General Public License as published by
  13     the Free Software Foundation - version 2.
  14
  15     This program is distributed in the hope that it will be useful,
  16     but WITHOUT ANY WARRANTY; without even the implied warranty of
  17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18     GNU General Public License for more details.
  19
  20     You should have received a copy of the GNU General Public License
  21     along with this program; if not, write to the Free Software
  22     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  23     02110-1301 USA.
  24 */
  25
  26 /*
  27     Supports following chips:
  28
  29     Chip        #vin    #fanin  #pwm    #temp   wchipid vendid  i2c     ISA
  30     w83793      10      12      8       6       0x7b    0x5ca3  yes     no
  31 */
  32
  33 #include <linux/module.h>
  34 #include <linux/init.h>
  35 #include <linux/slab.h>
  36 #include <linux/i2c.h>
  37 #include <linux/hwmon.h>
  38 #include <linux/smp_lock.h>
  39 #include <linux/hwmon-vid.h>
  40 #include <linux/hwmon-sysfs.h>
  41 #include <linux/err.h>
  42 #include <linux/mutex.h>
  43 #include <linux/fs.h>
  44 #include <linux/watchdog.h>
  45 #include <linux/miscdevice.h>
  46 #include <linux/uaccess.h>
  47 #include <linux/kref.h>
  48 #include <linux/notifier.h>
  49 #include <linux/reboot.h>
  50
  51 /* Default values */
  52 #define WATCHDOG_TIMEOUT 2      /* 2 minute default timeout */
  53
  54 /* Addresses to scan */
  55 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f,
  56                                                 I2C_CLIENT_END };
  57
  58 /* Insmod parameters */
  59
  60 static unsigned short force_subclients[4];
  61 module_param_array(force_subclients, short, NULL, 0);
  62 MODULE_PARM_DESC(force_subclients, "List of subclient addresses: "
  63                        "{bus, clientaddr, subclientaddr1, subclientaddr2}");
  64
  65 static int reset;
  66 module_param(reset, bool, 0);
  67 MODULE_PARM_DESC(reset, "Set to 1 to reset chip, not recommended");
  68
  69 static int timeout = WATCHDOG_TIMEOUT;  /* default timeout in minutes */
  70 module_param(timeout, int, 0);
  71 MODULE_PARM_DESC(timeout,
  72         "Watchdog timeout in minutes. 2<= timeout <=255 (default="
  73                                 __MODULE_STRING(WATCHDOG_TIMEOUT) ")");
  74
  75 static int nowayout = WATCHDOG_NOWAYOUT;
  76 module_param(nowayout, int, 0);
  77 MODULE_PARM_DESC(nowayout,
  78         "Watchdog cannot be stopped once started (default="
  79                                 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
  80
  81 /*
  82    Address 0x00, 0x0d, 0x0e, 0x0f in all three banks are reserved
  83    as ID, Bank Select registers
  84 */
  85 #define W83793_REG_BANKSEL              0x00
  86 #define W83793_REG_VENDORID             0x0d
  87 #define W83793_REG_CHIPID               0x0e
  88 #define W83793_REG_DEVICEID             0x0f
  89
  90 #define W83793_REG_CONFIG               0x40
  91 #define W83793_REG_MFC                  0x58
  92 #define W83793_REG_FANIN_CTRL           0x5c
  93 #define W83793_REG_FANIN_SEL            0x5d
  94 #define W83793_REG_I2C_ADDR             0x0b
  95 #define W83793_REG_I2C_SUBADDR          0x0c
  96 #define W83793_REG_VID_INA              0x05
  97 #define W83793_REG_VID_INB              0x06
  98 #define W83793_REG_VID_LATCHA           0x07
  99 #define W83793_REG_VID_LATCHB           0x08
 100 #define W83793_REG_VID_CTRL             0x59
 101
 102 #define W83793_REG_WDT_LOCK             0x01
 103 #define W83793_REG_WDT_ENABLE           0x02
 104 #define W83793_REG_WDT_STATUS           0x03
 105 #define W83793_REG_WDT_TIMEOUT          0x04
 106
 107 static u16 W83793_REG_TEMP_MODE[2] = { 0x5e, 0x5f };
 108
 109 #define TEMP_READ       0
 110 #define TEMP_CRIT       1
 111 #define TEMP_CRIT_HYST  2
 112 #define TEMP_WARN       3
 113 #define TEMP_WARN_HYST  4
 114 /* only crit and crit_hyst affect real-time alarm status
 115    current crit crit_hyst warn warn_hyst */
 116 static u16 W83793_REG_TEMP[][5] = {
 117         {0x1c, 0x78, 0x79, 0x7a, 0x7b},
 118         {0x1d, 0x7c, 0x7d, 0x7e, 0x7f},
 119         {0x1e, 0x80, 0x81, 0x82, 0x83},
 120         {0x1f, 0x84, 0x85, 0x86, 0x87},
 121         {0x20, 0x88, 0x89, 0x8a, 0x8b},
 122         {0x21, 0x8c, 0x8d, 0x8e, 0x8f},
 123 };
 124
 125 #define W83793_REG_TEMP_LOW_BITS        0x22
 126
 127 #define W83793_REG_BEEP(index)          (0x53 + (index))
 128 #define W83793_REG_ALARM(index)         (0x4b + (index))
 129
 130 #define W83793_REG_CLR_CHASSIS          0x4a    /* SMI MASK4 */
 131 #define W83793_REG_IRQ_CTRL             0x50
 132 #define W83793_REG_OVT_CTRL             0x51
 133 #define W83793_REG_OVT_BEEP             0x52
 134
 135 #define IN_READ                         0
 136 #define IN_MAX                          1
 137 #define IN_LOW                          2
 138 static const u16 W83793_REG_IN[][3] = {
 139         /* Current, High, Low */
 140         {0x10, 0x60, 0x61},     /* Vcore A      */
 141         {0x11, 0x62, 0x63},     /* Vcore B      */
 142         {0x12, 0x64, 0x65},     /* Vtt          */
 143         {0x14, 0x6a, 0x6b},     /* VSEN1        */
 144         {0x15, 0x6c, 0x6d},     /* VSEN2        */
 145         {0x16, 0x6e, 0x6f},     /* +3VSEN       */
 146         {0x17, 0x70, 0x71},     /* +12VSEN      */
 147         {0x18, 0x72, 0x73},     /* 5VDD         */
 148         {0x19, 0x74, 0x75},     /* 5VSB         */
 149         {0x1a, 0x76, 0x77},     /* VBAT         */
 150 };
 151
 152 /* Low Bits of Vcore A/B Vtt Read/High/Low */
 153 static const u16 W83793_REG_IN_LOW_BITS[] = { 0x1b, 0x68, 0x69 };
 154 static u8 scale_in[] = { 2, 2, 2, 16, 16, 16, 8, 24, 24, 16 };
 155 static u8 scale_in_add[] = { 0, 0, 0, 0, 0, 0, 0, 150, 150, 0 };
 156
 157 #define W83793_REG_FAN(index)           (0x23 + 2 * (index))    /* High byte */
 158 #define W83793_REG_FAN_MIN(index)       (0x90 + 2 * (index))    /* High byte */
 159
 160 #define W83793_REG_PWM_DEFAULT          0xb2
 161 #define W83793_REG_PWM_ENABLE           0x207
 162 #define W83793_REG_PWM_UPTIME           0xc3    /* Unit in 0.1 second */
 163 #define W83793_REG_PWM_DOWNTIME         0xc4    /* Unit in 0.1 second */
 164 #define W83793_REG_TEMP_CRITICAL        0xc5
 165
 166 #define PWM_DUTY                        0
 167 #define PWM_START                       1
 168 #define PWM_NONSTOP                     2
 169 #define PWM_STOP_TIME                   3
 170 #define W83793_REG_PWM(index, nr)       (((nr) == 0 ? 0xb3 : \
 171                                          (nr) == 1 ? 0x220 : 0x218) + (index))
 172
 173 /* bit field, fan1 is bit0, fan2 is bit1 ... */
 174 #define W83793_REG_TEMP_FAN_MAP(index)  (0x201 + (index))
 175 #define W83793_REG_TEMP_TOL(index)      (0x208 + (index))
 176 #define W83793_REG_TEMP_CRUISE(index)   (0x210 + (index))
 177 #define W83793_REG_PWM_STOP_TIME(index) (0x228 + (index))
 178 #define W83793_REG_SF2_TEMP(index, nr)  (0x230 + ((index) << 4) + (nr))
 179 #define W83793_REG_SF2_PWM(index, nr)   (0x238 + ((index) << 4) + (nr))
 180
 181 static inline unsigned long FAN_FROM_REG(u16 val)
 182 {
 183         if ((val >= 0xfff) || (val == 0))
 184                 return  0;
 185         return (1350000UL / val);
 186 }
 187
 188 static inline u16 FAN_TO_REG(long rpm)
 189 {
 190         if (rpm <= 0)
 191                 return 0x0fff;
 192         return SENSORS_LIMIT((1350000 + (rpm >> 1)) / rpm, 1, 0xffe);
 193 }
 194
 195 static inline unsigned long TIME_FROM_REG(u8 reg)
 196 {
 197         return (reg * 100);
 198 }
 199
 200 static inline u8 TIME_TO_REG(unsigned long val)
 201 {
 202         return SENSORS_LIMIT((val + 50) / 100, 0, 0xff);
 203 }
 204
 205 static inline long TEMP_FROM_REG(s8 reg)
 206 {
 207         return (reg * 1000);
 208 }
 209
 210 static inline s8 TEMP_TO_REG(long val, s8 min, s8 max)
 211 {
 212         return SENSORS_LIMIT((val + (val < 0 ? -500 : 500)) / 1000, min, max);
 213 }
 214
 215 struct w83793_data {
 216         struct i2c_client *lm75[2];
 217         struct device *hwmon_dev;
 218         struct mutex update_lock;
 219         char valid;                     /* !=0 if following fields are valid */
 220         unsigned long last_updated;     /* In jiffies */
 221         unsigned long last_nonvolatile; /* In jiffies, last time we update the
 222                                            nonvolatile registers */
 223
 224         u8 bank;
 225         u8 vrm;
 226         u8 vid[2];
 227         u8 in[10][3];           /* Register value, read/high/low */
 228         u8 in_low_bits[3];      /* Additional resolution for VCore A/B Vtt */
 229
 230         u16 has_fan;            /* Only fan1- fan5 has own pins */
 231         u16 fan[12];            /* Register value combine */
 232         u16 fan_min[12];        /* Register value combine */
 233
 234         s8 temp[6][5];          /* current, crit, crit_hyst,warn, warn_hyst */
 235         u8 temp_low_bits;       /* Additional resolution TD1-TD4 */
 236         u8 temp_mode[2];        /* byte 0: Temp D1-D4 mode each has 2 bits
 237                                    byte 1: Temp R1,R2 mode, each has 1 bit */
 238         u8 temp_critical;       /* If reached all fan will be at full speed */
 239         u8 temp_fan_map[6];     /* Temp controls which pwm fan, bit field */
 240
 241         u8 has_pwm;
 242         u8 has_temp;
 243         u8 has_vid;
 244         u8 pwm_enable;          /* Register value, each Temp has 1 bit */
 245         u8 pwm_uptime;          /* Register value */
 246         u8 pwm_downtime;        /* Register value */
 247         u8 pwm_default;         /* All fan default pwm, next poweron valid */
 248         u8 pwm[8][3];           /* Register value */
 249         u8 pwm_stop_time[8];
 250         u8 temp_cruise[6];
 251
 252         u8 alarms[5];           /* realtime status registers */
 253         u8 beeps[5];
 254         u8 beep_enable;
 255         u8 tolerance[3];        /* Temp tolerance(Smart Fan I/II) */
 256         u8 sf2_pwm[6][7];       /* Smart FanII: Fan duty cycle */
 257         u8 sf2_temp[6][7];      /* Smart FanII: Temp level point */
 258
 259         /* watchdog */
 260         struct i2c_client *client;
 261         struct mutex watchdog_lock;
 262         struct list_head list; /* member of the watchdog_data_list */
 263         struct kref kref;
 264         struct miscdevice watchdog_miscdev;
 265         unsigned long watchdog_is_open;
 266         char watchdog_expect_close;
 267         char watchdog_name[10]; /* must be unique to avoid sysfs conflict */
 268         unsigned int watchdog_caused_reboot;
 269         int watchdog_timeout; /* watchdog timeout in minutes */
 270 };
 271
 272 /* Somewhat ugly :( global data pointer list with all devices, so that
 273    we can find our device data as when using misc_register. There is no
 274    other method to get to one's device data from the open file-op and
 275    for usage in the reboot notifier callback. */
 276 static LIST_HEAD(watchdog_data_list);
 277
 278 /* Note this lock not only protect list access, but also data.kref access */
 279 static DEFINE_MUTEX(watchdog_data_mutex);
 280
 281 /* Release our data struct when we're detached from the i2c client *and* all
 282    references to our watchdog device are released */
 283 static void w83793_release_resources(struct kref *ref)
 284 {
 285         struct w83793_data *data = container_of(ref, struct w83793_data, kref);
 286         kfree(data);
 287 }
 288
 289 static u8 w83793_read_value(struct i2c_client *client, u16 reg);
 290 static int w83793_write_value(struct i2c_client *client, u16 reg, u8 value);
 291 static int w83793_probe(struct i2c_client *client,
 292                         const struct i2c_device_id *id);
 293 static int w83793_detect(struct i2c_client *client,
 294                          struct i2c_board_info *info);
 295 static int w83793_remove(struct i2c_client *client);
 296 static void w83793_init_client(struct i2c_client *client);
 297 static void w83793_update_nonvolatile(struct device *dev);
 298 static struct w83793_data *w83793_update_device(struct device *dev);
 299
 300 static const struct i2c_device_id w83793_id[] = {
 301         { "w83793", 0 },
 302         { }
 303 };
 304 MODULE_DEVICE_TABLE(i2c, w83793_id);
 305
 306 static struct i2c_driver w83793_driver = {
 307         .class          = I2C_CLASS_HWMON,
 308         .driver = {
 309                    .name = "w83793",
 310         },
 311         .probe          = w83793_probe,
 312         .remove         = w83793_remove,
 313         .id_table       = w83793_id,
 314         .detect         = w83793_detect,
 315         .address_list   = normal_i2c,
 316 };
 317
 318 static ssize_t
 319 show_vrm(struct device *dev, struct device_attribute *attr, char *buf)
 320 {
 321         struct w83793_data *data = dev_get_drvdata(dev);
 322         return sprintf(buf, "%d\n", data->vrm);
 323 }
 324
 325 static ssize_t
 326 show_vid(struct device *dev, struct device_attribute *attr, char *buf)
 327 {
 328         struct w83793_data *data = w83793_update_device(dev);
 329         struct sensor_device_attribute_2 *sensor_attr =
 330             to_sensor_dev_attr_2(attr);
 331         int index = sensor_attr->index;
 332
 333         return sprintf(buf, "%d\n", vid_from_reg(data->vid[index], data->vrm));
 334 }
 335
 336 static ssize_t
 337 store_vrm(struct device *dev, struct device_attribute *attr,
 338           const char *buf, size_t count)
 339 {
 340         struct w83793_data *data = dev_get_drvdata(dev);
 341         data->vrm = simple_strtoul(buf, NULL, 10);
 342         return count;
 343 }
 344
 345 #define ALARM_STATUS                    0
 346 #define BEEP_ENABLE                     1
 347 static ssize_t
 348 show_alarm_beep(struct device *dev, struct device_attribute *attr, char *buf)
 349 {
 350         struct w83793_data *data = w83793_update_device(dev);
 351         struct sensor_device_attribute_2 *sensor_attr =
 352             to_sensor_dev_attr_2(attr);
 353         int nr = sensor_attr->nr;
 354         int index = sensor_attr->index >> 3;
 355         int bit = sensor_attr->index & 0x07;
 356         u8 val;
 357
 358         if (ALARM_STATUS == nr) {
 359                 val = (data->alarms[index] >> (bit)) & 1;
 360         } else {                /* BEEP_ENABLE */
 361                 val = (data->beeps[index] >> (bit)) & 1;
 362         }
 363
 364         return sprintf(buf, "%u\n", val);
 365 }
 366
 367 static ssize_t
 368 store_beep(struct device *dev, struct device_attribute *attr,
 369            const char *buf, size_t count)
 370 {
 371         struct i2c_client *client = to_i2c_client(dev);
 372         struct w83793_data *data = i2c_get_clientdata(client);
 373         struct sensor_device_attribute_2 *sensor_attr =
 374             to_sensor_dev_attr_2(attr);
 375         int index = sensor_attr->index >> 3;
 376         int shift = sensor_attr->index & 0x07;
 377         u8 beep_bit = 1 << shift;
 378         u8 val;
 379
 380         val = simple_strtoul(buf, NULL, 10);
 381         if (val != 0 && val != 1)
 382                 return -EINVAL;
 383
 384         mutex_lock(&data->update_lock);
 385         data->beeps[index] = w83793_read_value(client, W83793_REG_BEEP(index));
 386         data->beeps[index] &= ~beep_bit;
 387         data->beeps[index] |= val << shift;
 388         w83793_write_value(client, W83793_REG_BEEP(index), data->beeps[index]);
 389         mutex_unlock(&data->update_lock);
 390
 391         return count;
 392 }
 393
 394 static ssize_t
 395 show_beep_enable(struct device *dev, struct device_attribute *attr, char *buf)
 396 {
 397         struct w83793_data *data = w83793_update_device(dev);
 398         return sprintf(buf, "%u\n", (data->beep_enable >> 1) & 0x01);
 399 }
 400
 401 static ssize_t
 402 store_beep_enable(struct device *dev, struct device_attribute *attr,
 403                   const char *buf, size_t count)
 404 {
 405         struct i2c_client *client = to_i2c_client(dev);
 406         struct w83793_data *data = i2c_get_clientdata(client);
 407         u8 val = simple_strtoul(buf, NULL, 10);
 408
 409         if (val != 0 && val != 1)
 410                 return -EINVAL;
 411
 412         mutex_lock(&data->update_lock);
 413         data->beep_enable = w83793_read_value(client, W83793_REG_OVT_BEEP)
 414                             & 0xfd;
 415         data->beep_enable |= val << 1;
 416         w83793_write_value(client, W83793_REG_OVT_BEEP, data->beep_enable);
 417         mutex_unlock(&data->update_lock);
 418
 419         return count;
 420 }
 421
 422 /* Write any value to clear chassis alarm */
 423 static ssize_t
 424 store_chassis_clear(struct device *dev,
 425                     struct device_attribute *attr, const char *buf,
 426                     size_t count)
 427 {
 428         struct i2c_client *client = to_i2c_client(dev);
 429         struct w83793_data *data = i2c_get_clientdata(client);
 430         u8 val;
 431
 432         mutex_lock(&data->update_lock);
 433         val = w83793_read_value(client, W83793_REG_CLR_CHASSIS);
 434         val |= 0x80;
 435         w83793_write_value(client, W83793_REG_CLR_CHASSIS, val);
 436         mutex_unlock(&data->update_lock);
 437         return count;
 438 }
 439
 440 #define FAN_INPUT                       0
 441 #define FAN_MIN                         1
 442 static ssize_t
 443 show_fan(struct device *dev, struct device_attribute *attr, char *buf)
 444 {
 445         struct sensor_device_attribute_2 *sensor_attr =
 446             to_sensor_dev_attr_2(attr);
 447         int nr = sensor_attr->nr;
 448         int index = sensor_attr->index;
 449         struct w83793_data *data = w83793_update_device(dev);
 450         u16 val;
 451
 452         if (FAN_INPUT == nr) {
 453                 val = data->fan[index] & 0x0fff;
 454         } else {
 455                 val = data->fan_min[index] & 0x0fff;
 456         }
 457
 458         return sprintf(buf, "%lu\n", FAN_FROM_REG(val));
 459 }
 460
 461 static ssize_t
 462 store_fan_min(struct device *dev, struct device_attribute *attr,
 463               const char *buf, size_t count)
 464 {
 465         struct sensor_device_attribute_2 *sensor_attr =
 466             to_sensor_dev_attr_2(attr);
 467         int index = sensor_attr->index;
 468         struct i2c_client *client = to_i2c_client(dev);
 469         struct w83793_data *data = i2c_get_clientdata(client);
 470         u16 val = FAN_TO_REG(simple_strtoul(buf, NULL, 10));
 471
 472         mutex_lock(&data->update_lock);
 473         data->fan_min[index] = val;
 474         w83793_write_value(client, W83793_REG_FAN_MIN(index),
 475                            (val >> 8) & 0xff);
 476         w83793_write_value(client, W83793_REG_FAN_MIN(index) + 1, val & 0xff);
 477         mutex_unlock(&data->update_lock);
 478
 479         return count;
 480 }
 481
 482 static ssize_t
 483 show_pwm(struct device *dev, struct device_attribute *attr, char *buf)
 484 {
 485         struct sensor_device_attribute_2 *sensor_attr =
 486             to_sensor_dev_attr_2(attr);
 487         struct w83793_data *data = w83793_update_device(dev);
 488         u16 val;
 489         int nr = sensor_attr->nr;
 490         int index = sensor_attr->index;
 491
 492         if (PWM_STOP_TIME == nr)
 493                 val = TIME_FROM_REG(data->pwm_stop_time[index]);
 494         else
 495                 val = (data->pwm[index][nr] & 0x3f) << 2;
 496
 497         return sprintf(buf, "%d\n", val);
 498 }
 499
 500 static ssize_t
 501 store_pwm(struct device *dev, struct device_attribute *attr,
 502           const char *buf, size_t count)
 503 {
 504         struct i2c_client *client = to_i2c_client(dev);
 505         struct w83793_data *data = i2c_get_clientdata(client);
 506         struct sensor_device_attribute_2 *sensor_attr =
 507             to_sensor_dev_attr_2(attr);
 508         int nr = sensor_attr->nr;
 509         int index = sensor_attr->index;
 510         u8 val;
 511
 512         mutex_lock(&data->update_lock);
 513         if (PWM_STOP_TIME == nr) {
 514                 val = TIME_TO_REG(simple_strtoul(buf, NULL, 10));
 515                 data->pwm_stop_time[index] = val;
 516                 w83793_write_value(client, W83793_REG_PWM_STOP_TIME(index),
 517                                    val);
 518         } else {
 519                 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 0, 0xff)
 520                       >> 2;
 521                 data->pwm[index][nr] =
 522                     w83793_read_value(client, W83793_REG_PWM(index, nr)) & 0xc0;
 523                 data->pwm[index][nr] |= val;
 524                 w83793_write_value(client, W83793_REG_PWM(index, nr),
 525                                                         data->pwm[index][nr]);
 526         }
 527
 528         mutex_unlock(&data->update_lock);
 529         return count;
 530 }
 531
 532 static ssize_t
 533 show_temp(struct device *dev, struct device_attribute *attr, char *buf)
 534 {
 535         struct sensor_device_attribute_2 *sensor_attr =
 536             to_sensor_dev_attr_2(attr);
 537         int nr = sensor_attr->nr;
 538         int index = sensor_attr->index;
 539         struct w83793_data *data = w83793_update_device(dev);
 540         long temp = TEMP_FROM_REG(data->temp[index][nr]);
 541
 542         if (TEMP_READ == nr && index < 4) {     /* Only TD1-TD4 have low bits */
 543                 int low = ((data->temp_low_bits >> (index * 2)) & 0x03) * 250;
 544                 temp += temp > 0 ? low : -low;
 545         }
 546         return sprintf(buf, "%ld\n", temp);
 547 }
 548
 549 static ssize_t
 550 store_temp(struct device *dev, struct device_attribute *attr,
 551            const char *buf, size_t count)
 552 {
 553         struct sensor_device_attribute_2 *sensor_attr =
 554             to_sensor_dev_attr_2(attr);
 555         int nr = sensor_attr->nr;
 556         int index = sensor_attr->index;
 557         struct i2c_client *client = to_i2c_client(dev);
 558         struct w83793_data *data = i2c_get_clientdata(client);
 559         long tmp = simple_strtol(buf, NULL, 10);
 560
 561         mutex_lock(&data->update_lock);
 562         data->temp[index][nr] = TEMP_TO_REG(tmp, -128, 127);
 563         w83793_write_value(client, W83793_REG_TEMP[index][nr],
 564                            data->temp[index][nr]);
 565         mutex_unlock(&data->update_lock);
 566         return count;
 567 }
 568
 569 /*
 570         TD1-TD4
 571         each has 4 mode:(2 bits)
 572         0:      Stop monitor
 573         1:      Use internal temp sensor(default)
 574         2:      Reserved
 575         3:      Use sensor in Intel CPU and get result by PECI
 576
 577         TR1-TR2
 578         each has 2 mode:(1 bit)
 579         0:      Disable temp sensor monitor
 580         1:      To enable temp sensors monitor
 581 */
 582
 583 /* 0 disable, 6 PECI */
 584 static u8 TO_TEMP_MODE[] = { 0, 0, 0, 6 };
 585
 586 static ssize_t
 587 show_temp_mode(struct device *dev, struct device_attribute *attr, char *buf)
 588 {
 589         struct w83793_data *data = w83793_update_device(dev);
 590         struct sensor_device_attribute_2 *sensor_attr =
 591             to_sensor_dev_attr_2(attr);
 592         int index = sensor_attr->index;
 593         u8 mask = (index < 4) ? 0x03 : 0x01;
 594         u8 shift = (index < 4) ? (2 * index) : (index - 4);
 595         u8 tmp;
 596         index = (index < 4) ? 0 : 1;
 597
 598         tmp = (data->temp_mode[index] >> shift) & mask;
 599
 600         /* for the internal sensor, found out if diode or thermistor */
 601         if (tmp == 1) {
 602                 tmp = index == 0 ? 3 : 4;
 603         } else {
 604                 tmp = TO_TEMP_MODE[tmp];
 605         }
 606
 607         return sprintf(buf, "%d\n", tmp);
 608 }
 609
 610 static ssize_t
 611 store_temp_mode(struct device *dev, struct device_attribute *attr,
 612                 const char *buf, size_t count)
 613 {
 614         struct i2c_client *client = to_i2c_client(dev);
 615         struct w83793_data *data = i2c_get_clientdata(client);
 616         struct sensor_device_attribute_2 *sensor_attr =
 617             to_sensor_dev_attr_2(attr);
 618         int index = sensor_attr->index;
 619         u8 mask = (index < 4) ? 0x03 : 0x01;
 620         u8 shift = (index < 4) ? (2 * index) : (index - 4);
 621         u8 val = simple_strtoul(buf, NULL, 10);
 622
 623         /* transform the sysfs interface values into table above */
 624         if ((val == 6) && (index < 4)) {
 625                 val -= 3;
 626         } else if ((val == 3 && index < 4)
 627                 || (val == 4 && index >= 4)) {
 628                 /* transform diode or thermistor into internal enable */
 629                 val = !!val;
 630         } else {
 631                 return -EINVAL;
 632         }
 633
 634         index = (index < 4) ? 0 : 1;
 635         mutex_lock(&data->update_lock);
 636         data->temp_mode[index] =
 637             w83793_read_value(client, W83793_REG_TEMP_MODE[index]);
 638         data->temp_mode[index] &= ~(mask << shift);
 639         data->temp_mode[index] |= val << shift;
 640         w83793_write_value(client, W83793_REG_TEMP_MODE[index],
 641                                                         data->temp_mode[index]);
 642         mutex_unlock(&data->update_lock);
 643
 644         return count;
 645 }
 646
 647 #define SETUP_PWM_DEFAULT               0
 648 #define SETUP_PWM_UPTIME                1       /* Unit in 0.1s */
 649 #define SETUP_PWM_DOWNTIME              2       /* Unit in 0.1s */
 650 #define SETUP_TEMP_CRITICAL             3
 651 static ssize_t
 652 show_sf_setup(struct device *dev, struct device_attribute *attr, char *buf)
 653 {
 654         struct sensor_device_attribute_2 *sensor_attr =
 655             to_sensor_dev_attr_2(attr);
 656         int nr = sensor_attr->nr;
 657         struct w83793_data *data = w83793_update_device(dev);
 658         u32 val = 0;
 659
 660         if (SETUP_PWM_DEFAULT == nr) {
 661                 val = (data->pwm_default & 0x3f) << 2;
 662         } else if (SETUP_PWM_UPTIME == nr) {
 663                 val = TIME_FROM_REG(data->pwm_uptime);
 664         } else if (SETUP_PWM_DOWNTIME == nr) {
 665                 val = TIME_FROM_REG(data->pwm_downtime);
 666         } else if (SETUP_TEMP_CRITICAL == nr) {
 667                 val = TEMP_FROM_REG(data->temp_critical & 0x7f);
 668         }
 669
 670         return sprintf(buf, "%d\n", val);
 671 }
 672
 673 static ssize_t
 674 store_sf_setup(struct device *dev, struct device_attribute *attr,
 675                const char *buf, size_t count)
 676 {
 677         struct sensor_device_attribute_2 *sensor_attr =
 678             to_sensor_dev_attr_2(attr);
 679         int nr = sensor_attr->nr;
 680         struct i2c_client *client = to_i2c_client(dev);
 681         struct w83793_data *data = i2c_get_clientdata(client);
 682
 683         mutex_lock(&data->update_lock);
 684         if (SETUP_PWM_DEFAULT == nr) {
 685                 data->pwm_default =
 686                     w83793_read_value(client, W83793_REG_PWM_DEFAULT) & 0xc0;
 687                 data->pwm_default |= SENSORS_LIMIT(simple_strtoul(buf, NULL,
 688                                                                   10),
 689                                                    0, 0xff) >> 2;
 690                 w83793_write_value(client, W83793_REG_PWM_DEFAULT,
 691                                                         data->pwm_default);
 692         } else if (SETUP_PWM_UPTIME == nr) {
 693                 data->pwm_uptime = TIME_TO_REG(simple_strtoul(buf, NULL, 10));
 694                 data->pwm_uptime += data->pwm_uptime == 0 ? 1 : 0;
 695                 w83793_write_value(client, W83793_REG_PWM_UPTIME,
 696                                                         data->pwm_uptime);
 697         } else if (SETUP_PWM_DOWNTIME == nr) {
 698                 data->pwm_downtime = TIME_TO_REG(simple_strtoul(buf, NULL, 10));
 699                 data->pwm_downtime += data->pwm_downtime == 0 ? 1 : 0;
 700                 w83793_write_value(client, W83793_REG_PWM_DOWNTIME,
 701                                                         data->pwm_downtime);
 702         } else {                /* SETUP_TEMP_CRITICAL */
 703                 data->temp_critical =
 704                     w83793_read_value(client, W83793_REG_TEMP_CRITICAL) & 0x80;
 705                 data->temp_critical |= TEMP_TO_REG(simple_strtol(buf, NULL, 10),
 706                                                    0, 0x7f);
 707                 w83793_write_value(client, W83793_REG_TEMP_CRITICAL,
 708                                                         data->temp_critical);
 709         }
 710
 711         mutex_unlock(&data->update_lock);
 712         return count;
 713 }
 714
 715 /*
 716         Temp SmartFan control
 717         TEMP_FAN_MAP
 718         Temp channel control which pwm fan, bitfield, bit 0 indicate pwm1...
 719         It's possible two or more temp channels control the same fan, w83793
 720         always prefers to pick the most critical request and applies it to
 721         the related Fan.
 722         It's possible one fan is not in any mapping of 6 temp channels, this
 723         means the fan is manual mode
 724
 725         TEMP_PWM_ENABLE
 726         Each temp channel has its own SmartFan mode, and temp channel
 727         control fans that are set by TEMP_FAN_MAP
 728         0:      SmartFanII mode
 729         1:      Thermal Cruise Mode
 730
 731         TEMP_CRUISE
 732         Target temperature in thermal cruise mode, w83793 will try to turn
 733         fan speed to keep the temperature of target device around this
 734         temperature.
 735
 736         TEMP_TOLERANCE
 737         If Temp higher or lower than target with this tolerance, w83793
 738         will take actions to speed up or slow down the fan to keep the
 739         temperature within the tolerance range.
 740 */
 741
 742 #define TEMP_FAN_MAP                    0
 743 #define TEMP_PWM_ENABLE                 1
 744 #define TEMP_CRUISE                     2
 745 #define TEMP_TOLERANCE                  3
 746 static ssize_t
 747 show_sf_ctrl(struct device *dev, struct device_attribute *attr, char *buf)
 748 {
 749         struct sensor_device_attribute_2 *sensor_attr =
 750             to_sensor_dev_attr_2(attr);
 751         int nr = sensor_attr->nr;
 752         int index = sensor_attr->index;
 753         struct w83793_data *data = w83793_update_device(dev);
 754         u32 val;
 755
 756         if (TEMP_FAN_MAP == nr) {
 757                 val = data->temp_fan_map[index];
 758         } else if (TEMP_PWM_ENABLE == nr) {
 759                 /* +2 to transfrom into 2 and 3 to conform with sysfs intf */
 760                 val = ((data->pwm_enable >> index) & 0x01) + 2;
 761         } else if (TEMP_CRUISE == nr) {
 762                 val = TEMP_FROM_REG(data->temp_cruise[index] & 0x7f);
 763         } else {                /* TEMP_TOLERANCE */
 764                 val = data->tolerance[index >> 1] >> ((index & 0x01) ? 4 : 0);
 765                 val = TEMP_FROM_REG(val & 0x0f);
 766         }
 767         return sprintf(buf, "%d\n", val);
 768 }
 769
 770 static ssize_t
 771 store_sf_ctrl(struct device *dev, struct device_attribute *attr,
 772               const char *buf, size_t count)
 773 {
 774         struct sensor_device_attribute_2 *sensor_attr =
 775             to_sensor_dev_attr_2(attr);
 776         int nr = sensor_attr->nr;
 777         int index = sensor_attr->index;
 778         struct i2c_client *client = to_i2c_client(dev);
 779         struct w83793_data *data = i2c_get_clientdata(client);
 780         u32 val;
 781
 782         mutex_lock(&data->update_lock);
 783         if (TEMP_FAN_MAP == nr) {
 784                 val = simple_strtoul(buf, NULL, 10) & 0xff;
 785                 w83793_write_value(client, W83793_REG_TEMP_FAN_MAP(index), val);
 786                 data->temp_fan_map[index] = val;
 787         } else if (TEMP_PWM_ENABLE == nr) {
 788                 val = simple_strtoul(buf, NULL, 10);
 789                 if (2 == val || 3 == val) {
 790                         data->pwm_enable =
 791                             w83793_read_value(client, W83793_REG_PWM_ENABLE);
 792                         if (val - 2)
 793                                 data->pwm_enable |= 1 << index;
 794                         else
 795                                 data->pwm_enable &= ~(1 << index);
 796                         w83793_write_value(client, W83793_REG_PWM_ENABLE,
 797                                                         data->pwm_enable);
 798                 } else {
 799                         mutex_unlock(&data->update_lock);
 800                         return -EINVAL;
 801                 }
 802         } else if (TEMP_CRUISE == nr) {
 803                 data->temp_cruise[index] =
 804                     w83793_read_value(client, W83793_REG_TEMP_CRUISE(index));
 805                 val = TEMP_TO_REG(simple_strtol(buf, NULL, 10), 0, 0x7f);
 806                 data->temp_cruise[index] &= 0x80;
 807                 data->temp_cruise[index] |= val;
 808
 809                 w83793_write_value(client, W83793_REG_TEMP_CRUISE(index),
 810                                                 data->temp_cruise[index]);
 811         } else {                /* TEMP_TOLERANCE */
 812                 int i = index >> 1;
 813                 u8 shift = (index & 0x01) ? 4 : 0;
 814                 data->tolerance[i] =
 815                     w83793_read_value(client, W83793_REG_TEMP_TOL(i));
 816
 817                 val = TEMP_TO_REG(simple_strtol(buf, NULL, 10), 0, 0x0f);
 818                 data->tolerance[i] &= ~(0x0f << shift);
 819                 data->tolerance[i] |= val << shift;
 820                 w83793_write_value(client, W83793_REG_TEMP_TOL(i),
 821                                                         data->tolerance[i]);
 822         }
 823
 824         mutex_unlock(&data->update_lock);
 825         return count;
 826 }
 827
 828 static ssize_t
 829 show_sf2_pwm(struct device *dev, struct device_attribute *attr, char *buf)
 830 {
 831         struct sensor_device_attribute_2 *sensor_attr =
 832             to_sensor_dev_attr_2(attr);
 833         int nr = sensor_attr->nr;
 834         int index = sensor_attr->index;
 835         struct w83793_data *data = w83793_update_device(dev);
 836
 837         return sprintf(buf, "%d\n", (data->sf2_pwm[index][nr] & 0x3f) << 2);
 838 }
 839
 840 static ssize_t
 841 store_sf2_pwm(struct device *dev, struct device_attribute *attr,
 842               const char *buf, size_t count)
 843 {
 844         struct i2c_client *client = to_i2c_client(dev);
 845         struct w83793_data *data = i2c_get_clientdata(client);
 846         struct sensor_device_attribute_2 *sensor_attr =
 847             to_sensor_dev_attr_2(attr);
 848         int nr = sensor_attr->nr;
 849         int index = sensor_attr->index;
 850         u8 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 0, 0xff) >> 2;
 851
 852         mutex_lock(&data->update_lock);
 853         data->sf2_pwm[index][nr] =
 854             w83793_read_value(client, W83793_REG_SF2_PWM(index, nr)) & 0xc0;
 855         data->sf2_pwm[index][nr] |= val;
 856         w83793_write_value(client, W83793_REG_SF2_PWM(index, nr),
 857                                                 data->sf2_pwm[index][nr]);
 858         mutex_unlock(&data->update_lock);
 859         return count;
 860 }
 861
 862 static ssize_t
 863 show_sf2_temp(struct device *dev, struct device_attribute *attr, char *buf)
 864 {
 865         struct sensor_device_attribute_2 *sensor_attr =
 866             to_sensor_dev_attr_2(attr);
 867         int nr = sensor_attr->nr;
 868         int index = sensor_attr->index;
 869         struct w83793_data *data = w83793_update_device(dev);
 870
 871         return sprintf(buf, "%ld\n",
 872                        TEMP_FROM_REG(data->sf2_temp[index][nr] & 0x7f));
 873 }
 874
 875 static ssize_t
 876 store_sf2_temp(struct device *dev, struct device_attribute *attr,
 877                const char *buf, size_t count)
 878 {
 879         struct i2c_client *client = to_i2c_client(dev);
 880         struct w83793_data *data = i2c_get_clientdata(client);
 881         struct sensor_device_attribute_2 *sensor_attr =
 882             to_sensor_dev_attr_2(attr);
 883         int nr = sensor_attr->nr;
 884         int index = sensor_attr->index;
 885         u8 val = TEMP_TO_REG(simple_strtol(buf, NULL, 10), 0, 0x7f);
 886
 887         mutex_lock(&data->update_lock);
 888         data->sf2_temp[index][nr] =
 889             w83793_read_value(client, W83793_REG_SF2_TEMP(index, nr)) & 0x80;
 890         data->sf2_temp[index][nr] |= val;
 891         w83793_write_value(client, W83793_REG_SF2_TEMP(index, nr),
 892                                              data->sf2_temp[index][nr]);
 893         mutex_unlock(&data->update_lock);
 894         return count;
 895 }
 896
 897 /* only Vcore A/B and Vtt have additional 2 bits precision */
 898 static ssize_t
 899 show_in(struct device *dev, struct device_attribute *attr, char *buf)
 900 {
 901         struct sensor_device_attribute_2 *sensor_attr =
 902             to_sensor_dev_attr_2(attr);
 903         int nr = sensor_attr->nr;
 904         int index = sensor_attr->index;
 905         struct w83793_data *data = w83793_update_device(dev);
 906         u16 val = data->in[index][nr];
 907
 908         if (index < 3) {
 909                 val <<= 2;
 910                 val += (data->in_low_bits[nr] >> (index * 2)) & 0x3;
 911         }
 912         /* voltage inputs 5VDD and 5VSB needs 150mV offset */
 913         val = val * scale_in[index] + scale_in_add[index];
 914         return sprintf(buf, "%d\n", val);
 915 }
 916
 917 static ssize_t
 918 store_in(struct device *dev, struct device_attribute *attr,
 919          const char *buf, size_t count)
 920 {
 921         struct sensor_device_attribute_2 *sensor_attr =
 922             to_sensor_dev_attr_2(attr);
 923         int nr = sensor_attr->nr;
 924         int index = sensor_attr->index;
 925         struct i2c_client *client = to_i2c_client(dev);
 926         struct w83793_data *data = i2c_get_clientdata(client);
 927         u32 val;
 928
 929         val =
 930             (simple_strtoul(buf, NULL, 10) +
 931              scale_in[index] / 2) / scale_in[index];
 932         mutex_lock(&data->update_lock);
 933         if (index > 2) {
 934                 /* fix the limit values of 5VDD and 5VSB to ALARM mechanism */
 935                 if (1 == nr || 2 == nr) {
 936                         val -= scale_in_add[index] / scale_in[index];
 937                 }
 938                 val = SENSORS_LIMIT(val, 0, 255);
 939         } else {
 940                 val = SENSORS_LIMIT(val, 0, 0x3FF);
 941                 data->in_low_bits[nr] =
 942                     w83793_read_value(client, W83793_REG_IN_LOW_BITS[nr]);
 943                 data->in_low_bits[nr] &= ~(0x03 << (2 * index));
 944                 data->in_low_bits[nr] |= (val & 0x03) << (2 * index);
 945                 w83793_write_value(client, W83793_REG_IN_LOW_BITS[nr],
 946                                                      data->in_low_bits[nr]);
 947                 val >>= 2;
 948         }
 949         data->in[index][nr] = val;
 950         w83793_write_value(client, W83793_REG_IN[index][nr],
 951                                                         data->in[index][nr]);
 952         mutex_unlock(&data->update_lock);
 953         return count;
 954 }
 955
 956 #define NOT_USED                        -1
 957
 958 #define SENSOR_ATTR_IN(index)                                           \
 959         SENSOR_ATTR_2(in##index##_input, S_IRUGO, show_in, NULL,        \
 960                 IN_READ, index),                                        \
 961         SENSOR_ATTR_2(in##index##_max, S_IRUGO | S_IWUSR, show_in,      \
 962                 store_in, IN_MAX, index),                               \
 963         SENSOR_ATTR_2(in##index##_min, S_IRUGO | S_IWUSR, show_in,      \
 964                 store_in, IN_LOW, index),                               \
 965         SENSOR_ATTR_2(in##index##_alarm, S_IRUGO, show_alarm_beep,      \
 966                 NULL, ALARM_STATUS, index + ((index > 2) ? 1 : 0)),     \
 967         SENSOR_ATTR_2(in##index##_beep, S_IWUSR | S_IRUGO,              \
 968                 show_alarm_beep, store_beep, BEEP_ENABLE,               \
 969                 index + ((index > 2) ? 1 : 0))
 970
 971 #define SENSOR_ATTR_FAN(index)                                          \
 972         SENSOR_ATTR_2(fan##index##_alarm, S_IRUGO, show_alarm_beep,     \
 973                 NULL, ALARM_STATUS, index + 17),                        \
 974         SENSOR_ATTR_2(fan##index##_beep, S_IWUSR | S_IRUGO,             \
 975                 show_alarm_beep, store_beep, BEEP_ENABLE, index + 17),  \
 976         SENSOR_ATTR_2(fan##index##_input, S_IRUGO, show_fan,            \
 977                 NULL, FAN_INPUT, index - 1),                            \
 978         SENSOR_ATTR_2(fan##index##_min, S_IWUSR | S_IRUGO,              \
 979                 show_fan, store_fan_min, FAN_MIN, index - 1)
 980
 981 #define SENSOR_ATTR_PWM(index)                                          \
 982         SENSOR_ATTR_2(pwm##index, S_IWUSR | S_IRUGO, show_pwm,          \
 983                 store_pwm, PWM_DUTY, index - 1),                        \
 984         SENSOR_ATTR_2(pwm##index##_nonstop, S_IWUSR | S_IRUGO,          \
 985                 show_pwm, store_pwm, PWM_NONSTOP, index - 1),           \
 986         SENSOR_ATTR_2(pwm##index##_start, S_IWUSR | S_IRUGO,            \
 987                 show_pwm, store_pwm, PWM_START, index - 1),             \
 988         SENSOR_ATTR_2(pwm##index##_stop_time, S_IWUSR | S_IRUGO,        \
 989                 show_pwm, store_pwm, PWM_STOP_TIME, index - 1)
 990
 991 #define SENSOR_ATTR_TEMP(index)                                         \
 992         SENSOR_ATTR_2(temp##index##_type, S_IRUGO | S_IWUSR,            \
 993                 show_temp_mode, store_temp_mode, NOT_USED, index - 1),  \
 994         SENSOR_ATTR_2(temp##index##_input, S_IRUGO, show_temp,          \
 995                 NULL, TEMP_READ, index - 1),                            \
 996         SENSOR_ATTR_2(temp##index##_max, S_IRUGO | S_IWUSR, show_temp,  \
 997                 store_temp, TEMP_CRIT, index - 1),                      \
 998         SENSOR_ATTR_2(temp##index##_max_hyst, S_IRUGO | S_IWUSR,        \
 999                 show_temp, store_temp, TEMP_CRIT_HYST, index - 1),      \
1000         SENSOR_ATTR_2(temp##index##_warn, S_IRUGO | S_IWUSR, show_temp, \
1001                 store_temp, TEMP_WARN, index - 1),                      \
1002         SENSOR_ATTR_2(temp##index##_warn_hyst, S_IRUGO | S_IWUSR,       \
1003                 show_temp, store_temp, TEMP_WARN_HYST, index - 1),      \
1004         SENSOR_ATTR_2(temp##index##_alarm, S_IRUGO,                     \
1005                 show_alarm_beep, NULL, ALARM_STATUS, index + 11),       \
1006         SENSOR_ATTR_2(temp##index##_beep, S_IWUSR | S_IRUGO,            \
1007                 show_alarm_beep, store_beep, BEEP_ENABLE, index + 11),  \
1008         SENSOR_ATTR_2(temp##index##_auto_channels_pwm,                  \
1009                 S_IRUGO | S_IWUSR, show_sf_ctrl, store_sf_ctrl,         \
1010                 TEMP_FAN_MAP, index - 1),                               \
1011         SENSOR_ATTR_2(temp##index##_pwm_enable, S_IWUSR | S_IRUGO,      \
1012                 show_sf_ctrl, store_sf_ctrl, TEMP_PWM_ENABLE,           \
1013                 index - 1),                                             \
1014         SENSOR_ATTR_2(thermal_cruise##index, S_IRUGO | S_IWUSR,         \
1015                 show_sf_ctrl, store_sf_ctrl, TEMP_CRUISE, index - 1),   \
1016         SENSOR_ATTR_2(tolerance##index, S_IRUGO | S_IWUSR, show_sf_ctrl,\
1017                 store_sf_ctrl, TEMP_TOLERANCE, index - 1),              \
1018         SENSOR_ATTR_2(temp##index##_auto_point1_pwm, S_IRUGO | S_IWUSR, \
1019                 show_sf2_pwm, store_sf2_pwm, 0, index - 1),             \
1020         SENSOR_ATTR_2(temp##index##_auto_point2_pwm, S_IRUGO | S_IWUSR, \
1021                 show_sf2_pwm, store_sf2_pwm, 1, index - 1),             \
1022         SENSOR_ATTR_2(temp##index##_auto_point3_pwm, S_IRUGO | S_IWUSR, \
1023                 show_sf2_pwm, store_sf2_pwm, 2, index - 1),             \
1024         SENSOR_ATTR_2(temp##index##_auto_point4_pwm, S_IRUGO | S_IWUSR, \
1025                 show_sf2_pwm, store_sf2_pwm, 3, index - 1),             \
1026         SENSOR_ATTR_2(temp##index##_auto_point5_pwm, S_IRUGO | S_IWUSR, \
1027                 show_sf2_pwm, store_sf2_pwm, 4, index - 1),             \
1028         SENSOR_ATTR_2(temp##index##_auto_point6_pwm, S_IRUGO | S_IWUSR, \
1029                 show_sf2_pwm, store_sf2_pwm, 5, index - 1),             \
1030         SENSOR_ATTR_2(temp##index##_auto_point7_pwm, S_IRUGO | S_IWUSR, \
1031                 show_sf2_pwm, store_sf2_pwm, 6, index - 1),             \
1032         SENSOR_ATTR_2(temp##index##_auto_point1_temp, S_IRUGO | S_IWUSR,\
1033                 show_sf2_temp, store_sf2_temp, 0, index - 1),           \
1034         SENSOR_ATTR_2(temp##index##_auto_point2_temp, S_IRUGO | S_IWUSR,\
1035                 show_sf2_temp, store_sf2_temp, 1, index - 1),           \
1036         SENSOR_ATTR_2(temp##index##_auto_point3_temp, S_IRUGO | S_IWUSR,\
1037                 show_sf2_temp, store_sf2_temp, 2, index - 1),           \
1038         SENSOR_ATTR_2(temp##index##_auto_point4_temp, S_IRUGO | S_IWUSR,\
1039                 show_sf2_temp, store_sf2_temp, 3, index - 1),           \
1040         SENSOR_ATTR_2(temp##index##_auto_point5_temp, S_IRUGO | S_IWUSR,\
1041                 show_sf2_temp, store_sf2_temp, 4, index - 1),           \
1042         SENSOR_ATTR_2(temp##index##_auto_point6_temp, S_IRUGO | S_IWUSR,\
1043                 show_sf2_temp, store_sf2_temp, 5, index - 1),           \
1044         SENSOR_ATTR_2(temp##index##_auto_point7_temp, S_IRUGO | S_IWUSR,\
1045                 show_sf2_temp, store_sf2_temp, 6, index - 1)
1046
1047 static struct sensor_device_attribute_2 w83793_sensor_attr_2[] = {
1048         SENSOR_ATTR_IN(0),
1049         SENSOR_ATTR_IN(1),
1050         SENSOR_ATTR_IN(2),
1051         SENSOR_ATTR_IN(3),
1052         SENSOR_ATTR_IN(4),
1053         SENSOR_ATTR_IN(5),
1054         SENSOR_ATTR_IN(6),
1055         SENSOR_ATTR_IN(7),
1056         SENSOR_ATTR_IN(8),
1057         SENSOR_ATTR_IN(9),
1058         SENSOR_ATTR_FAN(1),
1059         SENSOR_ATTR_FAN(2),
1060         SENSOR_ATTR_FAN(3),
1061         SENSOR_ATTR_FAN(4),
1062         SENSOR_ATTR_FAN(5),
1063         SENSOR_ATTR_PWM(1),
1064         SENSOR_ATTR_PWM(2),
1065         SENSOR_ATTR_PWM(3),
1066 };
1067
1068 static struct sensor_device_attribute_2 w83793_temp[] = {
1069         SENSOR_ATTR_TEMP(1),
1070         SENSOR_ATTR_TEMP(2),
1071         SENSOR_ATTR_TEMP(3),
1072         SENSOR_ATTR_TEMP(4),
1073         SENSOR_ATTR_TEMP(5),
1074         SENSOR_ATTR_TEMP(6),
1075 };
1076
1077 /* Fan6-Fan12 */
1078 static struct sensor_device_attribute_2 w83793_left_fan[] = {
1079         SENSOR_ATTR_FAN(6),
1080         SENSOR_ATTR_FAN(7),
1081         SENSOR_ATTR_FAN(8),
1082         SENSOR_ATTR_FAN(9),
1083         SENSOR_ATTR_FAN(10),
1084         SENSOR_ATTR_FAN(11),
1085         SENSOR_ATTR_FAN(12),
1086 };
1087
1088 /* Pwm4-Pwm8 */
1089 static struct sensor_device_attribute_2 w83793_left_pwm[] = {
1090         SENSOR_ATTR_PWM(4),
1091         SENSOR_ATTR_PWM(5),
1092         SENSOR_ATTR_PWM(6),
1093         SENSOR_ATTR_PWM(7),
1094         SENSOR_ATTR_PWM(8),
1095 };
1096
1097 static struct sensor_device_attribute_2 w83793_vid[] = {
1098         SENSOR_ATTR_2(cpu0_vid, S_IRUGO, show_vid, NULL, NOT_USED, 0),
1099         SENSOR_ATTR_2(cpu1_vid, S_IRUGO, show_vid, NULL, NOT_USED, 1),
1100 };
1101 static DEVICE_ATTR(vrm, S_IWUSR | S_IRUGO, show_vrm, store_vrm);
1102
1103 static struct sensor_device_attribute_2 sda_single_files[] = {
1104         SENSOR_ATTR_2(chassis, S_IWUSR | S_IRUGO, show_alarm_beep,
1105                       store_chassis_clear, ALARM_STATUS, 30),
1106         SENSOR_ATTR_2(beep_enable, S_IWUSR | S_IRUGO, show_beep_enable,
1107                       store_beep_enable, NOT_USED, NOT_USED),
1108         SENSOR_ATTR_2(pwm_default, S_IWUSR | S_IRUGO, show_sf_setup,
1109                       store_sf_setup, SETUP_PWM_DEFAULT, NOT_USED),
1110         SENSOR_ATTR_2(pwm_uptime, S_IWUSR | S_IRUGO, show_sf_setup,
1111                       store_sf_setup, SETUP_PWM_UPTIME, NOT_USED),
1112         SENSOR_ATTR_2(pwm_downtime, S_IWUSR | S_IRUGO, show_sf_setup,
1113                       store_sf_setup, SETUP_PWM_DOWNTIME, NOT_USED),
1114         SENSOR_ATTR_2(temp_critical, S_IWUSR | S_IRUGO, show_sf_setup,
1115                       store_sf_setup, SETUP_TEMP_CRITICAL, NOT_USED),
1116 };
1117
1118 static void w83793_init_client(struct i2c_client *client)
1119 {
1120         if (reset) {
1121                 w83793_write_value(client, W83793_REG_CONFIG, 0x80);
1122         }
1123
1124         /* Start monitoring */
1125         w83793_write_value(client, W83793_REG_CONFIG,
1126                            w83793_read_value(client, W83793_REG_CONFIG) | 0x01);
1127 }
1128
1129 /*
1130  * Watchdog routines
1131  */
1132
1133 static int watchdog_set_timeout(struct w83793_data *data, int timeout)
1134 {
1135         int ret, mtimeout;
1136
1137         mtimeout = DIV_ROUND_UP(timeout, 60);
1138
1139         if (mtimeout > 255)
1140                 return -EINVAL;
1141
1142         mutex_lock(&data->watchdog_lock);
1143         if (!data->client) {
1144                 ret = -ENODEV;
1145                 goto leave;
1146         }
1147
1148         data->watchdog_timeout = mtimeout;
1149
1150         /* Set Timeout value (in Minutes) */
1151         w83793_write_value(data->client, W83793_REG_WDT_TIMEOUT,
1152                            data->watchdog_timeout);
1153
1154         ret = mtimeout * 60;
1155
1156 leave:
1157         mutex_unlock(&data->watchdog_lock);
1158         return ret;
1159 }
1160
1161 static int watchdog_get_timeout(struct w83793_data *data)
1162 {
1163         int timeout;
1164
1165         mutex_lock(&data->watchdog_lock);
1166         timeout = data->watchdog_timeout * 60;
1167         mutex_unlock(&data->watchdog_lock);
1168
1169         return timeout;
1170 }
1171
1172 static int watchdog_trigger(struct w83793_data *data)
1173 {
1174         int ret = 0;
1175
1176         mutex_lock(&data->watchdog_lock);
1177         if (!data->client) {
1178                 ret = -ENODEV;
1179                 goto leave;
1180         }
1181
1182         /* Set Timeout value (in Minutes) */
1183         w83793_write_value(data->client, W83793_REG_WDT_TIMEOUT,
1184                            data->watchdog_timeout);
1185
1186 leave:
1187         mutex_unlock(&data->watchdog_lock);
1188         return ret;
1189 }
1190
1191 static int watchdog_enable(struct w83793_data *data)
1192 {
1193         int ret = 0;
1194
1195         mutex_lock(&data->watchdog_lock);
1196         if (!data->client) {
1197                 ret = -ENODEV;
1198                 goto leave;
1199         }
1200
1201         /* Set initial timeout */
1202         w83793_write_value(data->client, W83793_REG_WDT_TIMEOUT,
1203                            data->watchdog_timeout);
1204
1205         /* Enable Soft Watchdog */
1206         w83793_write_value(data->client, W83793_REG_WDT_LOCK, 0x55);
1207
1208 leave:
1209         mutex_unlock(&data->watchdog_lock);
1210         return ret;
1211 }
1212
1213 static int watchdog_disable(struct w83793_data *data)
1214 {
1215         int ret = 0;
1216
1217         mutex_lock(&data->watchdog_lock);
1218         if (!data->client) {
1219                 ret = -ENODEV;
1220                 goto leave;
1221         }
1222
1223         /* Disable Soft Watchdog */
1224         w83793_write_value(data->client, W83793_REG_WDT_LOCK, 0xAA);
1225
1226 leave:
1227         mutex_unlock(&data->watchdog_lock);
1228         return ret;
1229 }
1230
1231 static int watchdog_open(struct inode *inode, struct file *filp)
1232 {
1233         struct w83793_data *pos, *data = NULL;
1234         int watchdog_is_open;
1235
1236         /* We get called from drivers/char/misc.c with misc_mtx hold, and we
1237            call misc_register() from  w83793_probe() with watchdog_data_mutex
1238            hold, as misc_register() takes the misc_mtx lock, this is a possible
1239            deadlock, so we use mutex_trylock here. */
1240         if (!mutex_trylock(&watchdog_data_mutex))
1241                 return -ERESTARTSYS;
1242         list_for_each_entry(pos, &watchdog_data_list, list) {
1243                 if (pos->watchdog_miscdev.minor == iminor(inode)) {
1244                         data = pos;
1245                         break;
1246                 }
1247         }
1248
1249         /* Check, if device is already open */
1250         watchdog_is_open = test_and_set_bit(0, &data->watchdog_is_open);
1251
1252         /* Increase data reference counter (if not already done).
1253            Note we can never not have found data, so we don't check for this */
1254         if (!watchdog_is_open)
1255                 kref_get(&data->kref);
1256
1257         mutex_unlock(&watchdog_data_mutex);
1258
1259         /* Check, if device is already open and possibly issue error */
1260         if (watchdog_is_open)
1261                 return -EBUSY;
1262
1263         /* Enable Soft Watchdog */
1264         watchdog_enable(data);
1265
1266         /* Store pointer to data into filp's private data */
1267         filp->private_data = data;
1268
1269         return nonseekable_open(inode, filp);
1270 }
1271
1272 static int watchdog_close(struct inode *inode, struct file *filp)
1273 {
1274         struct w83793_data *data = filp->private_data;
1275
1276         if (data->watchdog_expect_close) {
1277                 watchdog_disable(data);
1278                 data->watchdog_expect_close = 0;
1279         } else {
1280                 watchdog_trigger(data);
1281                 dev_crit(&data->client->dev,
1282                         "unexpected close, not stopping watchdog!\n");
1283         }
1284
1285         clear_bit(0, &data->watchdog_is_open);
1286
1287         /* Decrease data reference counter */
1288         mutex_lock(&watchdog_data_mutex);
1289         kref_put(&data->kref, w83793_release_resources);
1290         mutex_unlock(&watchdog_data_mutex);
1291
1292         return 0;
1293 }
1294
1295 static ssize_t watchdog_write(struct file *filp, const char __user *buf,
1296         size_t count, loff_t *offset)
1297 {
1298         ssize_t ret;
1299         struct w83793_data *data = filp->private_data;
1300
1301         if (count) {
1302                 if (!nowayout) {
1303                         size_t i;
1304
1305                         /* Clear it in case it was set with a previous write */
1306                         data->watchdog_expect_close = 0;
1307
1308                         for (i = 0; i != count; i++) {
1309                                 char c;
1310                                 if (get_user(c, buf + i))
1311                                         return -EFAULT;
1312                                 if (c == 'V')
1313                                         data->watchdog_expect_close = 1;
1314                         }
1315                 }
1316                 ret = watchdog_trigger(data);
1317                 if (ret < 0)
1318                         return ret;
1319         }
1320         return count;
1321 }
1322
1323 static long watchdog_ioctl(struct file *filp, unsigned int cmd,
1324                            unsigned long arg)
1325 {
1326         static struct watchdog_info ident = {
1327                 .options = WDIOF_KEEPALIVEPING |
1328                            WDIOF_SETTIMEOUT |
1329                            WDIOF_CARDRESET,
1330                 .identity = "w83793 watchdog"
1331         };
1332
1333         int val, ret = 0;
1334         struct w83793_data *data = filp->private_data;
1335
1336         lock_kernel();
1337         switch (cmd) {
1338         case WDIOC_GETSUPPORT:
1339                 if (!nowayout)
1340                         ident.options |= WDIOF_MAGICCLOSE;
1341                 if (copy_to_user((void __user *)arg, &ident, sizeof(ident)))
1342                         ret = -EFAULT;
1343                 break;
1344
1345         case WDIOC_GETSTATUS:
1346                 val = data->watchdog_caused_reboot ? WDIOF_CARDRESET : 0;
1347                 ret = put_user(val, (int __user *)arg);
1348                 break;
1349
1350         case WDIOC_GETBOOTSTATUS:
1351                 ret = put_user(0, (int __user *)arg);
1352                 break;
1353
1354         case WDIOC_KEEPALIVE:
1355                 ret = watchdog_trigger(data);
1356                 break;
1357
1358         case WDIOC_GETTIMEOUT:
1359                 val = watchdog_get_timeout(data);
1360                 ret = put_user(val, (int __user *)arg);
1361                 break;
1362
1363         case WDIOC_SETTIMEOUT:
1364                 if (get_user(val, (int __user *)arg)) {
1365                         ret = -EFAULT;
1366                         break;
1367                 }
1368                 ret = watchdog_set_timeout(data, val);
1369                 if (ret > 0)
1370                         ret = put_user(ret, (int __user *)arg);
1371                 break;
1372
1373         case WDIOC_SETOPTIONS:
1374                 if (get_user(val, (int __user *)arg)) {
1375                         ret = -EFAULT;
1376                         break;
1377                 }
1378
1379                 if (val & WDIOS_DISABLECARD)
1380                         ret = watchdog_disable(data);
1381                 else if (val & WDIOS_ENABLECARD)
1382                         ret = watchdog_enable(data);
1383                 else
1384                         ret = -EINVAL;
1385
1386                 break;
1387         default:
1388                 ret = -ENOTTY;
1389         }
1390         unlock_kernel();
1391         return ret;
1392 }
1393
1394 static const struct file_operations watchdog_fops = {
1395         .owner = THIS_MODULE,
1396         .llseek = no_llseek,
1397         .open = watchdog_open,
1398         .release = watchdog_close,
1399         .write = watchdog_write,
1400         .unlocked_ioctl = watchdog_ioctl,
1401 };
1402
1403 /*
1404  *      Notifier for system down
1405  */
1406
1407 static int watchdog_notify_sys(struct notifier_block *this, unsigned long code,
1408                                void *unused)
1409 {
1410         struct w83793_data *data = NULL;
1411
1412         if (code == SYS_DOWN || code == SYS_HALT) {
1413
1414                 /* Disable each registered watchdog */
1415                 mutex_lock(&watchdog_data_mutex);
1416                 list_for_each_entry(data, &watchdog_data_list, list) {
1417                         if (data->watchdog_miscdev.minor)
1418                                 watchdog_disable(data);
1419                 }
1420                 mutex_unlock(&watchdog_data_mutex);
1421         }
1422
1423         return NOTIFY_DONE;
1424 }
1425
1426 /*
1427  *      The WDT needs to learn about soft shutdowns in order to
1428  *      turn the timebomb registers off.
1429  */
1430
1431 static struct notifier_block watchdog_notifier = {
1432         .notifier_call = watchdog_notify_sys,
1433 };
1434
1435 /*
1436  * Init / remove routines
1437  */
1438
1439 static int w83793_remove(struct i2c_client *client)
1440 {
1441         struct w83793_data *data = i2c_get_clientdata(client);
1442         struct device *dev = &client->dev;
1443         int i, tmp;
1444
1445         /* Unregister the watchdog (if registered) */
1446         if (data->watchdog_miscdev.minor) {
1447                 misc_deregister(&data->watchdog_miscdev);
1448
1449                 if (data->watchdog_is_open) {
1450                         dev_warn(&client->dev,
1451                                 "i2c client detached with watchdog open! "
1452                                 "Stopping watchdog.\n");
1453                         watchdog_disable(data);
1454                 }
1455
1456                 mutex_lock(&watchdog_data_mutex);
1457                 list_del(&data->list);
1458                 mutex_unlock(&watchdog_data_mutex);
1459
1460                 /* Tell the watchdog code the client is gone */
1461                 mutex_lock(&data->watchdog_lock);
1462                 data->client = NULL;
1463                 mutex_unlock(&data->watchdog_lock);
1464         }
1465
1466         /* Reset Configuration Register to Disable Watch Dog Registers */
1467         tmp = w83793_read_value(client, W83793_REG_CONFIG);
1468         w83793_write_value(client, W83793_REG_CONFIG, tmp & ~0x04);
1469
1470         unregister_reboot_notifier(&watchdog_notifier);
1471
1472         hwmon_device_unregister(data->hwmon_dev);
1473
1474         for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++)
1475                 device_remove_file(dev,
1476                                    &w83793_sensor_attr_2[i].dev_attr);
1477
1478         for (i = 0; i < ARRAY_SIZE(sda_single_files); i++)
1479                 device_remove_file(dev, &sda_single_files[i].dev_attr);
1480
1481         for (i = 0; i < ARRAY_SIZE(w83793_vid); i++)
1482                 device_remove_file(dev, &w83793_vid[i].dev_attr);
1483         device_remove_file(dev, &dev_attr_vrm);
1484
1485         for (i = 0; i < ARRAY_SIZE(w83793_left_fan); i++)
1486                 device_remove_file(dev, &w83793_left_fan[i].dev_attr);
1487
1488         for (i = 0; i < ARRAY_SIZE(w83793_left_pwm); i++)
1489                 device_remove_file(dev, &w83793_left_pwm[i].dev_attr);
1490
1491         for (i = 0; i < ARRAY_SIZE(w83793_temp); i++)
1492                 device_remove_file(dev, &w83793_temp[i].dev_attr);
1493
1494         if (data->lm75[0] != NULL)
1495                 i2c_unregister_device(data->lm75[0]);
1496         if (data->lm75[1] != NULL)
1497                 i2c_unregister_device(data->lm75[1]);
1498
1499         /* Decrease data reference counter */
1500         mutex_lock(&watchdog_data_mutex);
1501         kref_put(&data->kref, w83793_release_resources);
1502         mutex_unlock(&watchdog_data_mutex);
1503
1504         return 0;
1505 }
1506
1507 static int
1508 w83793_detect_subclients(struct i2c_client *client)
1509 {
1510         int i, id, err;
1511         int address = client->addr;
1512         u8 tmp;
1513         struct i2c_adapter *adapter = client->adapter;
1514         struct w83793_data *data = i2c_get_clientdata(client);
1515
1516         id = i2c_adapter_id(adapter);
1517         if (force_subclients[0] == id && force_subclients[1] == address) {
1518                 for (i = 2; i <= 3; i++) {
1519                         if (force_subclients[i] < 0x48
1520                             || force_subclients[i] > 0x4f) {
1521                                 dev_err(&client->dev,
1522                                         "invalid subclient "
1523                                         "address %d; must be 0x48-0x4f\n",
1524                                         force_subclients[i]);
1525                                 err = -EINVAL;
1526                                 goto ERROR_SC_0;
1527                         }
1528                 }
1529                 w83793_write_value(client, W83793_REG_I2C_SUBADDR,
1530                                    (force_subclients[2] & 0x07) |
1531                                    ((force_subclients[3] & 0x07) << 4));
1532         }
1533
1534         tmp = w83793_read_value(client, W83793_REG_I2C_SUBADDR);
1535         if (!(tmp & 0x08)) {
1536                 data->lm75[0] = i2c_new_dummy(adapter, 0x48 + (tmp & 0x7));
1537         }
1538         if (!(tmp & 0x80)) {
1539                 if ((data->lm75[0] != NULL)
1540                     && ((tmp & 0x7) == ((tmp >> 4) & 0x7))) {
1541                         dev_err(&client->dev,
1542                                 "duplicate addresses 0x%x, "
1543                                 "use force_subclients\n", data->lm75[0]->addr);
1544                         err = -ENODEV;
1545                         goto ERROR_SC_1;
1546                 }
1547                 data->lm75[1] = i2c_new_dummy(adapter,
1548                                               0x48 + ((tmp >> 4) & 0x7));
1549         }
1550
1551         return 0;
1552
1553         /* Undo inits in case of errors */
1554
1555 ERROR_SC_1:
1556         if (data->lm75[0] != NULL)
1557                 i2c_unregister_device(data->lm75[0]);
1558 ERROR_SC_0:
1559         return err;
1560 }
1561
1562 /* Return 0 if detection is successful, -ENODEV otherwise */
1563 static int w83793_detect(struct i2c_client *client,
1564                          struct i2c_board_info *info)
1565 {
1566         u8 tmp, bank, chip_id;
1567         struct i2c_adapter *adapter = client->adapter;
1568         unsigned short address = client->addr;
1569
1570         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1571                 return -ENODEV;
1572         }
1573
1574         bank = i2c_smbus_read_byte_data(client, W83793_REG_BANKSEL);
1575
1576         tmp = bank & 0x80 ? 0x5c : 0xa3;
1577         /* Check Winbond vendor ID */
1578         if (tmp != i2c_smbus_read_byte_data(client, W83793_REG_VENDORID)) {
1579                 pr_debug("w83793: Detection failed at check vendor id\n");
1580                 return -ENODEV;
1581         }
1582
1583         /* If Winbond chip, address of chip and W83793_REG_I2C_ADDR
1584            should match */
1585         if ((bank & 0x07) == 0
1586          && i2c_smbus_read_byte_data(client, W83793_REG_I2C_ADDR) !=
1587             (address << 1)) {
1588                 pr_debug("w83793: Detection failed at check i2c addr\n");
1589                 return -ENODEV;
1590         }
1591
1592         /* Determine the chip type now */
1593         chip_id = i2c_smbus_read_byte_data(client, W83793_REG_CHIPID);
1594         if (chip_id != 0x7b)
1595                 return -ENODEV;
1596
1597         strlcpy(info->type, "w83793", I2C_NAME_SIZE);
1598
1599         return 0;
1600 }
1601
1602 static int w83793_probe(struct i2c_client *client,
1603                         const struct i2c_device_id *id)
1604 {
1605         struct device *dev = &client->dev;
1606         const int watchdog_minors[] = { WATCHDOG_MINOR, 212, 213, 214, 215 };
1607         struct w83793_data *data;
1608         int i, tmp, val, err;
1609         int files_fan = ARRAY_SIZE(w83793_left_fan) / 7;
1610         int files_pwm = ARRAY_SIZE(w83793_left_pwm) / 5;
1611         int files_temp = ARRAY_SIZE(w83793_temp) / 6;
1612
1613         data = kzalloc(sizeof(struct w83793_data), GFP_KERNEL);
1614         if (!data) {
1615                 err = -ENOMEM;
1616                 goto exit;
1617         }
1618
1619         i2c_set_clientdata(client, data);
1620         data->bank = i2c_smbus_read_byte_data(client, W83793_REG_BANKSEL);
1621         mutex_init(&data->update_lock);
1622         mutex_init(&data->watchdog_lock);
1623         INIT_LIST_HEAD(&data->list);
1624         kref_init(&data->kref);
1625
1626         /* Store client pointer in our data struct for watchdog usage
1627            (where the client is found through a data ptr instead of the
1628            otherway around) */
1629         data->client = client;
1630
1631         err = w83793_detect_subclients(client);
1632         if (err)
1633                 goto free_mem;
1634
1635         /* Initialize the chip */
1636         w83793_init_client(client);
1637
1638         /*
1639            Only fan 1-5 has their own input pins,
1640            Pwm 1-3 has their own pins
1641          */
1642         data->has_fan = 0x1f;
1643         data->has_pwm = 0x07;
1644         tmp = w83793_read_value(client, W83793_REG_MFC);
1645         val = w83793_read_value(client, W83793_REG_FANIN_CTRL);
1646
1647         /* check the function of pins 49-56 */
1648         if (tmp & 0x80) {
1649                 data->has_vid |= 0x2;   /* has VIDB */
1650         } else {
1651                 data->has_pwm |= 0x18;  /* pwm 4,5 */
1652                 if (val & 0x01) {       /* fan 6 */
1653                         data->has_fan |= 0x20;
1654                         data->has_pwm |= 0x20;
1655                 }
1656                 if (val & 0x02) {       /* fan 7 */
1657                         data->has_fan |= 0x40;
1658                         data->has_pwm |= 0x40;
1659                 }
1660                 if (!(tmp & 0x40) && (val & 0x04)) {    /* fan 8 */
1661                         data->has_fan |= 0x80;
1662                         data->has_pwm |= 0x80;
1663                 }
1664         }
1665
1666         /* check the function of pins 37-40 */
1667         if (!(tmp & 0x29))
1668                 data->has_vid |= 0x1;   /* has VIDA */
1669         if (0x08 == (tmp & 0x0c)) {
1670                 if (val & 0x08) /* fan 9 */
1671                         data->has_fan |= 0x100;
1672                 if (val & 0x10) /* fan 10 */
1673                         data->has_fan |= 0x200;
1674         }
1675         if (0x20 == (tmp & 0x30)) {
1676                 if (val & 0x20) /* fan 11 */
1677                         data->has_fan |= 0x400;
1678                 if (val & 0x40) /* fan 12 */
1679                         data->has_fan |= 0x800;
1680         }
1681
1682         if ((tmp & 0x01) && (val & 0x04)) {     /* fan 8, second location */
1683                 data->has_fan |= 0x80;
1684                 data->has_pwm |= 0x80;
1685         }
1686
1687         tmp = w83793_read_value(client, W83793_REG_FANIN_SEL);
1688         if ((tmp & 0x01) && (val & 0x08)) {     /* fan 9, second location */
1689                 data->has_fan |= 0x100;
1690         }
1691         if ((tmp & 0x02) && (val & 0x10)) {     /* fan 10, second location */
1692                 data->has_fan |= 0x200;
1693         }
1694         if ((tmp & 0x04) && (val & 0x20)) {     /* fan 11, second location */
1695                 data->has_fan |= 0x400;
1696         }
1697         if ((tmp & 0x08) && (val & 0x40)) {     /* fan 12, second location */
1698                 data->has_fan |= 0x800;
1699         }
1700
1701         /* check the temp1-6 mode, ignore former AMDSI selected inputs */
1702         tmp = w83793_read_value(client,W83793_REG_TEMP_MODE[0]);
1703         if (tmp & 0x01)
1704                 data->has_temp |= 0x01;
1705         if (tmp & 0x04)
1706                 data->has_temp |= 0x02;
1707         if (tmp & 0x10)
1708                 data->has_temp |= 0x04;
1709         if (tmp & 0x40)
1710                 data->has_temp |= 0x08;
1711
1712         tmp = w83793_read_value(client,W83793_REG_TEMP_MODE[1]);
1713         if (tmp & 0x01)
1714                 data->has_temp |= 0x10;
1715         if (tmp & 0x02)
1716                 data->has_temp |= 0x20;
1717
1718         /* Register sysfs hooks */
1719         for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++) {
1720                 err = device_create_file(dev,
1721                                          &w83793_sensor_attr_2[i].dev_attr);
1722                 if (err)
1723                         goto exit_remove;
1724         }
1725
1726         for (i = 0; i < ARRAY_SIZE(w83793_vid); i++) {
1727                 if (!(data->has_vid & (1 << i)))
1728                         continue;
1729                 err = device_create_file(dev, &w83793_vid[i].dev_attr);
1730                 if (err)
1731                         goto exit_remove;
1732         }
1733         if (data->has_vid) {
1734                 data->vrm = vid_which_vrm();
1735                 err = device_create_file(dev, &dev_attr_vrm);
1736                 if (err)
1737                         goto exit_remove;
1738         }
1739
1740         for (i = 0; i < ARRAY_SIZE(sda_single_files); i++) {
1741                 err = device_create_file(dev, &sda_single_files[i].dev_attr);
1742                 if (err)
1743                         goto exit_remove;
1744
1745         }
1746
1747         for (i = 0; i < 6; i++) {
1748                 int j;
1749                 if (!(data->has_temp & (1 << i)))
1750                         continue;
1751                 for (j = 0; j < files_temp; j++) {
1752                         err = device_create_file(dev,
1753                                                 &w83793_temp[(i) * files_temp
1754                                                                 + j].dev_attr);
1755                         if (err)
1756                                 goto exit_remove;
1757                 }
1758         }
1759
1760         for (i = 5; i < 12; i++) {
1761                 int j;
1762                 if (!(data->has_fan & (1 << i)))
1763                         continue;
1764                 for (j = 0; j < files_fan; j++) {
1765                         err = device_create_file(dev,
1766                                            &w83793_left_fan[(i - 5) * files_fan
1767                                                                 + j].dev_attr);
1768                         if (err)
1769                                 goto exit_remove;
1770                 }
1771         }
1772
1773         for (i = 3; i < 8; i++) {
1774                 int j;
1775                 if (!(data->has_pwm & (1 << i)))
1776                         continue;
1777                 for (j = 0; j < files_pwm; j++) {
1778                         err = device_create_file(dev,
1779                                            &w83793_left_pwm[(i - 3) * files_pwm
1780                                                                 + j].dev_attr);
1781                         if (err)
1782                                 goto exit_remove;
1783                 }
1784         }
1785
1786         data->hwmon_dev = hwmon_device_register(dev);
1787         if (IS_ERR(data->hwmon_dev)) {
1788                 err = PTR_ERR(data->hwmon_dev);
1789                 goto exit_remove;
1790         }
1791
1792         /* Watchdog initialization */
1793
1794         /* Register boot notifier */
1795         err = register_reboot_notifier(&watchdog_notifier);
1796         if (err != 0) {
1797                 dev_err(&client->dev,
1798                         "cannot register reboot notifier (err=%d)\n", err);
1799                 goto exit_devunreg;
1800         }
1801
1802         /* Enable Watchdog registers.
1803            Set Configuration Register to Enable Watch Dog Registers
1804            (Bit 2) = XXXX, X1XX. */
1805         tmp = w83793_read_value(client, W83793_REG_CONFIG);
1806         w83793_write_value(client, W83793_REG_CONFIG, tmp | 0x04);
1807
1808         /* Set the default watchdog timeout */
1809         data->watchdog_timeout = timeout;
1810
1811         /* Check, if last reboot was caused by watchdog */
1812         data->watchdog_caused_reboot =
1813           w83793_read_value(data->client, W83793_REG_WDT_STATUS) & 0x01;
1814
1815         /* Disable Soft Watchdog during initialiation */
1816         watchdog_disable(data);
1817
1818         /* We take the data_mutex lock early so that watchdog_open() cannot
1819            run when misc_register() has completed, but we've not yet added
1820            our data to the watchdog_data_list (and set the default timeout) */
1821         mutex_lock(&watchdog_data_mutex);
1822         for (i = 0; i < ARRAY_SIZE(watchdog_minors); i++) {
1823                 /* Register our watchdog part */
1824                 snprintf(data->watchdog_name, sizeof(data->watchdog_name),
1825                         "watchdog%c", (i == 0) ? '\0' : ('0' + i));
1826                 data->watchdog_miscdev.name = data->watchdog_name;
1827                 data->watchdog_miscdev.fops = &watchdog_fops;
1828                 data->watchdog_miscdev.minor = watchdog_minors[i];
1829
1830                 err = misc_register(&data->watchdog_miscdev);
1831                 if (err == -EBUSY)
1832                         continue;
1833                 if (err) {
1834                         data->watchdog_miscdev.minor = 0;
1835                         dev_err(&client->dev,
1836                                 "Registering watchdog chardev: %d\n", err);
1837                         break;
1838                 }
1839
1840                 list_add(&data->list, &watchdog_data_list);
1841
1842                 dev_info(&client->dev,
1843                         "Registered watchdog chardev major 10, minor: %d\n",
1844                         watchdog_minors[i]);
1845                 break;
1846         }
1847         if (i == ARRAY_SIZE(watchdog_minors)) {
1848                 data->watchdog_miscdev.minor = 0;
1849                 dev_warn(&client->dev, "Couldn't register watchdog chardev "
1850                         "(due to no free minor)\n");
1851         }
1852
1853         mutex_unlock(&watchdog_data_mutex);
1854
1855         return 0;
1856
1857         /* Unregister hwmon device */
1858
1859 exit_devunreg:
1860
1861         hwmon_device_unregister(data->hwmon_dev);
1862
1863         /* Unregister sysfs hooks */
1864
1865 exit_remove:
1866         for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++)
1867                 device_remove_file(dev, &w83793_sensor_attr_2[i].dev_attr);
1868
1869         for (i = 0; i < ARRAY_SIZE(sda_single_files); i++)
1870                 device_remove_file(dev, &sda_single_files[i].dev_attr);
1871
1872         for (i = 0; i < ARRAY_SIZE(w83793_vid); i++)
1873                 device_remove_file(dev, &w83793_vid[i].dev_attr);
1874
1875         for (i = 0; i < ARRAY_SIZE(w83793_left_fan); i++)
1876                 device_remove_file(dev, &w83793_left_fan[i].dev_attr);
1877
1878         for (i = 0; i < ARRAY_SIZE(w83793_left_pwm); i++)
1879                 device_remove_file(dev, &w83793_left_pwm[i].dev_attr);
1880
1881         for (i = 0; i < ARRAY_SIZE(w83793_temp); i++)
1882                 device_remove_file(dev, &w83793_temp[i].dev_attr);
1883
1884         if (data->lm75[0] != NULL)
1885                 i2c_unregister_device(data->lm75[0]);
1886         if (data->lm75[1] != NULL)
1887                 i2c_unregister_device(data->lm75[1]);
1888 free_mem:
1889         kfree(data);
1890 exit:
1891         return err;
1892 }
1893
1894 static void w83793_update_nonvolatile(struct device *dev)
1895 {
1896         struct i2c_client *client = to_i2c_client(dev);
1897         struct w83793_data *data = i2c_get_clientdata(client);
1898         int i, j;
1899         /*
1900            They are somewhat "stable" registers, and to update them everytime
1901            takes so much time, it's just not worthy. Update them in a long
1902            interval to avoid exception.
1903          */
1904         if (!(time_after(jiffies, data->last_nonvolatile + HZ * 300)
1905               || !data->valid))
1906                 return;
1907         /* update voltage limits */
1908         for (i = 1; i < 3; i++) {
1909                 for (j = 0; j < ARRAY_SIZE(data->in); j++) {
1910                         data->in[j][i] =
1911                             w83793_read_value(client, W83793_REG_IN[j][i]);
1912                 }
1913                 data->in_low_bits[i] =
1914                     w83793_read_value(client, W83793_REG_IN_LOW_BITS[i]);
1915         }
1916
1917         for (i = 0; i < ARRAY_SIZE(data->fan_min); i++) {
1918                 /* Update the Fan measured value and limits */
1919                 if (!(data->has_fan & (1 << i))) {
1920                         continue;
1921                 }
1922                 data->fan_min[i] =
1923                     w83793_read_value(client, W83793_REG_FAN_MIN(i)) << 8;
1924                 data->fan_min[i] |=
1925                     w83793_read_value(client, W83793_REG_FAN_MIN(i) + 1);
1926         }
1927
1928         for (i = 0; i < ARRAY_SIZE(data->temp_fan_map); i++) {
1929                 if (!(data->has_temp & (1 << i)))
1930                         continue;
1931                 data->temp_fan_map[i] =
1932                     w83793_read_value(client, W83793_REG_TEMP_FAN_MAP(i));
1933                 for (j = 1; j < 5; j++) {
1934                         data->temp[i][j] =
1935                             w83793_read_value(client, W83793_REG_TEMP[i][j]);
1936                 }
1937                 data->temp_cruise[i] =
1938                     w83793_read_value(client, W83793_REG_TEMP_CRUISE(i));
1939                 for (j = 0; j < 7; j++) {
1940                         data->sf2_pwm[i][j] =
1941                             w83793_read_value(client, W83793_REG_SF2_PWM(i, j));
1942                         data->sf2_temp[i][j] =
1943                             w83793_read_value(client,
1944                                               W83793_REG_SF2_TEMP(i, j));
1945                 }
1946         }
1947
1948         for (i = 0; i < ARRAY_SIZE(data->temp_mode); i++)
1949                 data->temp_mode[i] =
1950                     w83793_read_value(client, W83793_REG_TEMP_MODE[i]);
1951
1952         for (i = 0; i < ARRAY_SIZE(data->tolerance); i++) {
1953                 data->tolerance[i] =
1954                     w83793_read_value(client, W83793_REG_TEMP_TOL(i));
1955         }
1956
1957         for (i = 0; i < ARRAY_SIZE(data->pwm); i++) {
1958                 if (!(data->has_pwm & (1 << i)))
1959                         continue;
1960                 data->pwm[i][PWM_NONSTOP] =
1961                     w83793_read_value(client, W83793_REG_PWM(i, PWM_NONSTOP));
1962                 data->pwm[i][PWM_START] =
1963                     w83793_read_value(client, W83793_REG_PWM(i, PWM_START));
1964                 data->pwm_stop_time[i] =
1965                     w83793_read_value(client, W83793_REG_PWM_STOP_TIME(i));
1966         }
1967
1968         data->pwm_default = w83793_read_value(client, W83793_REG_PWM_DEFAULT);
1969         data->pwm_enable = w83793_read_value(client, W83793_REG_PWM_ENABLE);
1970         data->pwm_uptime = w83793_read_value(client, W83793_REG_PWM_UPTIME);
1971         data->pwm_downtime = w83793_read_value(client, W83793_REG_PWM_DOWNTIME);
1972         data->temp_critical =
1973             w83793_read_value(client, W83793_REG_TEMP_CRITICAL);
1974         data->beep_enable = w83793_read_value(client, W83793_REG_OVT_BEEP);
1975
1976         for (i = 0; i < ARRAY_SIZE(data->beeps); i++) {
1977                 data->beeps[i] = w83793_read_value(client, W83793_REG_BEEP(i));
1978         }
1979
1980         data->last_nonvolatile = jiffies;
1981 }
1982
1983 static struct w83793_data *w83793_update_device(struct device *dev)
1984 {
1985         struct i2c_client *client = to_i2c_client(dev);
1986         struct w83793_data *data = i2c_get_clientdata(client);
1987         int i;
1988
1989         mutex_lock(&data->update_lock);
1990
1991         if (!(time_after(jiffies, data->last_updated + HZ * 2)
1992               || !data->valid))
1993                 goto END;
1994
1995         /* Update the voltages measured value and limits */
1996         for (i = 0; i < ARRAY_SIZE(data->in); i++)
1997                 data->in[i][IN_READ] =
1998                     w83793_read_value(client, W83793_REG_IN[i][IN_READ]);
1999
2000         data->in_low_bits[IN_READ] =
2001             w83793_read_value(client, W83793_REG_IN_LOW_BITS[IN_READ]);
2002
2003         for (i = 0; i < ARRAY_SIZE(data->fan); i++) {
2004                 if (!(data->has_fan & (1 << i))) {
2005                         continue;
2006                 }
2007                 data->fan[i] =
2008                     w83793_read_value(client, W83793_REG_FAN(i)) << 8;
2009                 data->fan[i] |=
2010                     w83793_read_value(client, W83793_REG_FAN(i) + 1);
2011         }
2012
2013         for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
2014                 if (!(data->has_temp & (1 << i)))
2015                         continue;
2016                 data->temp[i][TEMP_READ] =
2017                     w83793_read_value(client, W83793_REG_TEMP[i][TEMP_READ]);
2018         }
2019
2020         data->temp_low_bits =
2021             w83793_read_value(client, W83793_REG_TEMP_LOW_BITS);
2022
2023         for (i = 0; i < ARRAY_SIZE(data->pwm); i++) {
2024                 if (data->has_pwm & (1 << i))
2025                         data->pwm[i][PWM_DUTY] =
2026                             w83793_read_value(client,
2027                                               W83793_REG_PWM(i, PWM_DUTY));
2028         }
2029
2030         for (i = 0; i < ARRAY_SIZE(data->alarms); i++)
2031                 data->alarms[i] =
2032                     w83793_read_value(client, W83793_REG_ALARM(i));
2033         if (data->has_vid & 0x01)
2034                 data->vid[0] = w83793_read_value(client, W83793_REG_VID_INA);
2035         if (data->has_vid & 0x02)
2036                 data->vid[1] = w83793_read_value(client, W83793_REG_VID_INB);
2037         w83793_update_nonvolatile(dev);
2038         data->last_updated = jiffies;
2039         data->valid = 1;
2040
2041 END:
2042         mutex_unlock(&data->update_lock);
2043         return data;
2044 }
2045
2046 /* Ignore the possibility that somebody change bank outside the driver
2047    Must be called with data->update_lock held, except during initialization */
2048 static u8 w83793_read_value(struct i2c_client *client, u16 reg)
2049 {
2050         struct w83793_data *data = i2c_get_clientdata(client);
2051         u8 res = 0xff;
2052         u8 new_bank = reg >> 8;
2053
2054         new_bank |= data->bank & 0xfc;
2055         if (data->bank != new_bank) {
2056                 if (i2c_smbus_write_byte_data
2057                     (client, W83793_REG_BANKSEL, new_bank) >= 0)
2058                         data->bank = new_bank;
2059                 else {
2060                         dev_err(&client->dev,
2061                                 "set bank to %d failed, fall back "
2062                                 "to bank %d, read reg 0x%x error\n",
2063                                 new_bank, data->bank, reg);
2064                         res = 0x0;      /* read 0x0 from the chip */
2065                         goto END;
2066                 }
2067         }
2068         res = i2c_smbus_read_byte_data(client, reg & 0xff);
2069 END:
2070         return res;
2071 }
2072
2073 /* Must be called with data->update_lock held, except during initialization */
2074 static int w83793_write_value(struct i2c_client *client, u16 reg, u8 value)
2075 {
2076         struct w83793_data *data = i2c_get_clientdata(client);
2077         int res;
2078         u8 new_bank = reg >> 8;
2079
2080         new_bank |= data->bank & 0xfc;
2081         if (data->bank != new_bank) {
2082                 if ((res = i2c_smbus_write_byte_data
2083                     (client, W83793_REG_BANKSEL, new_bank)) >= 0)
2084                         data->bank = new_bank;
2085                 else {
2086                         dev_err(&client->dev,
2087                                 "set bank to %d failed, fall back "
2088                                 "to bank %d, write reg 0x%x error\n",
2089                                 new_bank, data->bank, reg);
2090                         goto END;
2091                 }
2092         }
2093
2094         res = i2c_smbus_write_byte_data(client, reg & 0xff, value);
2095 END:
2096         return res;
2097 }
2098
2099 static int __init sensors_w83793_init(void)
2100 {
2101         return i2c_add_driver(&w83793_driver);
2102 }
2103
2104 static void __exit sensors_w83793_exit(void)
2105 {
2106         i2c_del_driver(&w83793_driver);
2107 }
2108
2109 MODULE_AUTHOR("Yuan Mu, Sven Anders");
2110 MODULE_DESCRIPTION("w83793 driver");
2111 MODULE_LICENSE("GPL");
2112
2113 module_init(sensors_w83793_init);
2114 module_exit(sensors_w83793_exit);