Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * w83793.c - Linux kernel driver for hardware monitoring
0004  * Copyright (C) 2006 Winbond Electronics Corp.
0005  *        Yuan Mu
0006  *        Rudolf Marek <r.marek@assembler.cz>
0007  * Copyright (C) 2009-2010 Sven Anders <anders@anduras.de>, ANDURAS AG.
0008  *      Watchdog driver part
0009  *      (Based partially on fschmd driver,
0010  *       Copyright 2007-2008 by Hans de Goede)
0011  */
0012 
0013 /*
0014  * Supports following chips:
0015  *
0016  * Chip #vin    #fanin  #pwm    #temp   wchipid vendid  i2c ISA
0017  * w83793   10  12  8   6   0x7b    0x5ca3  yes no
0018  */
0019 
0020 #include <linux/module.h>
0021 #include <linux/init.h>
0022 #include <linux/slab.h>
0023 #include <linux/i2c.h>
0024 #include <linux/hwmon.h>
0025 #include <linux/hwmon-vid.h>
0026 #include <linux/hwmon-sysfs.h>
0027 #include <linux/err.h>
0028 #include <linux/mutex.h>
0029 #include <linux/fs.h>
0030 #include <linux/watchdog.h>
0031 #include <linux/miscdevice.h>
0032 #include <linux/uaccess.h>
0033 #include <linux/kref.h>
0034 #include <linux/notifier.h>
0035 #include <linux/reboot.h>
0036 #include <linux/jiffies.h>
0037 
0038 /* Default values */
0039 #define WATCHDOG_TIMEOUT 2  /* 2 minute default timeout */
0040 
0041 /* Addresses to scan */
0042 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f,
0043                         I2C_CLIENT_END };
0044 
0045 /* Insmod parameters */
0046 
0047 static unsigned short force_subclients[4];
0048 module_param_array(force_subclients, short, NULL, 0);
0049 MODULE_PARM_DESC(force_subclients,
0050          "List of subclient addresses: {bus, clientaddr, subclientaddr1, subclientaddr2}");
0051 
0052 static bool reset;
0053 module_param(reset, bool, 0);
0054 MODULE_PARM_DESC(reset, "Set to 1 to reset chip, not recommended");
0055 
0056 static int timeout = WATCHDOG_TIMEOUT;  /* default timeout in minutes */
0057 module_param(timeout, int, 0);
0058 MODULE_PARM_DESC(timeout,
0059     "Watchdog timeout in minutes. 2<= timeout <=255 (default="
0060                 __MODULE_STRING(WATCHDOG_TIMEOUT) ")");
0061 
0062 static bool nowayout = WATCHDOG_NOWAYOUT;
0063 module_param(nowayout, bool, 0);
0064 MODULE_PARM_DESC(nowayout,
0065     "Watchdog cannot be stopped once started (default="
0066                 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
0067 
0068 /*
0069  * Address 0x00, 0x0d, 0x0e, 0x0f in all three banks are reserved
0070  * as ID, Bank Select registers
0071  */
0072 #define W83793_REG_BANKSEL      0x00
0073 #define W83793_REG_VENDORID     0x0d
0074 #define W83793_REG_CHIPID       0x0e
0075 #define W83793_REG_DEVICEID     0x0f
0076 
0077 #define W83793_REG_CONFIG       0x40
0078 #define W83793_REG_MFC          0x58
0079 #define W83793_REG_FANIN_CTRL       0x5c
0080 #define W83793_REG_FANIN_SEL        0x5d
0081 #define W83793_REG_I2C_ADDR     0x0b
0082 #define W83793_REG_I2C_SUBADDR      0x0c
0083 #define W83793_REG_VID_INA      0x05
0084 #define W83793_REG_VID_INB      0x06
0085 #define W83793_REG_VID_LATCHA       0x07
0086 #define W83793_REG_VID_LATCHB       0x08
0087 #define W83793_REG_VID_CTRL     0x59
0088 
0089 #define W83793_REG_WDT_LOCK     0x01
0090 #define W83793_REG_WDT_ENABLE       0x02
0091 #define W83793_REG_WDT_STATUS       0x03
0092 #define W83793_REG_WDT_TIMEOUT      0x04
0093 
0094 static u16 W83793_REG_TEMP_MODE[2] = { 0x5e, 0x5f };
0095 
0096 #define TEMP_READ   0
0097 #define TEMP_CRIT   1
0098 #define TEMP_CRIT_HYST  2
0099 #define TEMP_WARN   3
0100 #define TEMP_WARN_HYST  4
0101 /*
0102  * only crit and crit_hyst affect real-time alarm status
0103  * current crit crit_hyst warn warn_hyst
0104  */
0105 static u16 W83793_REG_TEMP[][5] = {
0106     {0x1c, 0x78, 0x79, 0x7a, 0x7b},
0107     {0x1d, 0x7c, 0x7d, 0x7e, 0x7f},
0108     {0x1e, 0x80, 0x81, 0x82, 0x83},
0109     {0x1f, 0x84, 0x85, 0x86, 0x87},
0110     {0x20, 0x88, 0x89, 0x8a, 0x8b},
0111     {0x21, 0x8c, 0x8d, 0x8e, 0x8f},
0112 };
0113 
0114 #define W83793_REG_TEMP_LOW_BITS    0x22
0115 
0116 #define W83793_REG_BEEP(index)      (0x53 + (index))
0117 #define W83793_REG_ALARM(index)     (0x4b + (index))
0118 
0119 #define W83793_REG_CLR_CHASSIS      0x4a    /* SMI MASK4 */
0120 #define W83793_REG_IRQ_CTRL     0x50
0121 #define W83793_REG_OVT_CTRL     0x51
0122 #define W83793_REG_OVT_BEEP     0x52
0123 
0124 #define IN_READ             0
0125 #define IN_MAX              1
0126 #define IN_LOW              2
0127 static const u16 W83793_REG_IN[][3] = {
0128     /* Current, High, Low */
0129     {0x10, 0x60, 0x61}, /* Vcore A  */
0130     {0x11, 0x62, 0x63}, /* Vcore B  */
0131     {0x12, 0x64, 0x65}, /* Vtt      */
0132     {0x14, 0x6a, 0x6b}, /* VSEN1    */
0133     {0x15, 0x6c, 0x6d}, /* VSEN2    */
0134     {0x16, 0x6e, 0x6f}, /* +3VSEN   */
0135     {0x17, 0x70, 0x71}, /* +12VSEN  */
0136     {0x18, 0x72, 0x73}, /* 5VDD     */
0137     {0x19, 0x74, 0x75}, /* 5VSB     */
0138     {0x1a, 0x76, 0x77}, /* VBAT     */
0139 };
0140 
0141 /* Low Bits of Vcore A/B Vtt Read/High/Low */
0142 static const u16 W83793_REG_IN_LOW_BITS[] = { 0x1b, 0x68, 0x69 };
0143 static u8 scale_in[] = { 2, 2, 2, 16, 16, 16, 8, 24, 24, 16 };
0144 static u8 scale_in_add[] = { 0, 0, 0, 0, 0, 0, 0, 150, 150, 0 };
0145 
0146 #define W83793_REG_FAN(index)       (0x23 + 2 * (index))    /* High byte */
0147 #define W83793_REG_FAN_MIN(index)   (0x90 + 2 * (index))    /* High byte */
0148 
0149 #define W83793_REG_PWM_DEFAULT      0xb2
0150 #define W83793_REG_PWM_ENABLE       0x207
0151 #define W83793_REG_PWM_UPTIME       0xc3    /* Unit in 0.1 second */
0152 #define W83793_REG_PWM_DOWNTIME     0xc4    /* Unit in 0.1 second */
0153 #define W83793_REG_TEMP_CRITICAL    0xc5
0154 
0155 #define PWM_DUTY            0
0156 #define PWM_START           1
0157 #define PWM_NONSTOP         2
0158 #define PWM_STOP_TIME           3
0159 #define W83793_REG_PWM(index, nr)   (((nr) == 0 ? 0xb3 : \
0160                      (nr) == 1 ? 0x220 : 0x218) + (index))
0161 
0162 /* bit field, fan1 is bit0, fan2 is bit1 ... */
0163 #define W83793_REG_TEMP_FAN_MAP(index)  (0x201 + (index))
0164 #define W83793_REG_TEMP_TOL(index)  (0x208 + (index))
0165 #define W83793_REG_TEMP_CRUISE(index)   (0x210 + (index))
0166 #define W83793_REG_PWM_STOP_TIME(index) (0x228 + (index))
0167 #define W83793_REG_SF2_TEMP(index, nr)  (0x230 + ((index) << 4) + (nr))
0168 #define W83793_REG_SF2_PWM(index, nr)   (0x238 + ((index) << 4) + (nr))
0169 
0170 static inline unsigned long FAN_FROM_REG(u16 val)
0171 {
0172     if ((val >= 0xfff) || (val == 0))
0173         return  0;
0174     return 1350000UL / val;
0175 }
0176 
0177 static inline u16 FAN_TO_REG(long rpm)
0178 {
0179     if (rpm <= 0)
0180         return 0x0fff;
0181     return clamp_val((1350000 + (rpm >> 1)) / rpm, 1, 0xffe);
0182 }
0183 
0184 static inline unsigned long TIME_FROM_REG(u8 reg)
0185 {
0186     return reg * 100;
0187 }
0188 
0189 static inline u8 TIME_TO_REG(unsigned long val)
0190 {
0191     return clamp_val((val + 50) / 100, 0, 0xff);
0192 }
0193 
0194 static inline long TEMP_FROM_REG(s8 reg)
0195 {
0196     return reg * 1000;
0197 }
0198 
0199 static inline s8 TEMP_TO_REG(long val, s8 min, s8 max)
0200 {
0201     return clamp_val((val + (val < 0 ? -500 : 500)) / 1000, min, max);
0202 }
0203 
0204 struct w83793_data {
0205     struct device *hwmon_dev;
0206     struct mutex update_lock;
0207     bool valid;         /* true if following fields are valid */
0208     unsigned long last_updated; /* In jiffies */
0209     unsigned long last_nonvolatile; /* In jiffies, last time we update the
0210                      * nonvolatile registers
0211                      */
0212 
0213     u8 bank;
0214     u8 vrm;
0215     u8 vid[2];
0216     u8 in[10][3];       /* Register value, read/high/low */
0217     u8 in_low_bits[3];  /* Additional resolution for VCore A/B Vtt */
0218 
0219     u16 has_fan;        /* Only fan1- fan5 has own pins */
0220     u16 fan[12];        /* Register value combine */
0221     u16 fan_min[12];    /* Register value combine */
0222 
0223     s8 temp[6][5];      /* current, crit, crit_hyst,warn, warn_hyst */
0224     u8 temp_low_bits;   /* Additional resolution TD1-TD4 */
0225     u8 temp_mode[2];    /* byte 0: Temp D1-D4 mode each has 2 bits
0226                  * byte 1: Temp R1,R2 mode, each has 1 bit
0227                  */
0228     u8 temp_critical;   /* If reached all fan will be at full speed */
0229     u8 temp_fan_map[6]; /* Temp controls which pwm fan, bit field */
0230 
0231     u8 has_pwm;
0232     u8 has_temp;
0233     u8 has_vid;
0234     u8 pwm_enable;      /* Register value, each Temp has 1 bit */
0235     u8 pwm_uptime;      /* Register value */
0236     u8 pwm_downtime;    /* Register value */
0237     u8 pwm_default;     /* All fan default pwm, next poweron valid */
0238     u8 pwm[8][3];       /* Register value */
0239     u8 pwm_stop_time[8];
0240     u8 temp_cruise[6];
0241 
0242     u8 alarms[5];       /* realtime status registers */
0243     u8 beeps[5];
0244     u8 beep_enable;
0245     u8 tolerance[3];    /* Temp tolerance(Smart Fan I/II) */
0246     u8 sf2_pwm[6][7];   /* Smart FanII: Fan duty cycle */
0247     u8 sf2_temp[6][7];  /* Smart FanII: Temp level point */
0248 
0249     /* watchdog */
0250     struct i2c_client *client;
0251     struct mutex watchdog_lock;
0252     struct list_head list; /* member of the watchdog_data_list */
0253     struct kref kref;
0254     struct miscdevice watchdog_miscdev;
0255     unsigned long watchdog_is_open;
0256     char watchdog_expect_close;
0257     char watchdog_name[10]; /* must be unique to avoid sysfs conflict */
0258     unsigned int watchdog_caused_reboot;
0259     int watchdog_timeout; /* watchdog timeout in minutes */
0260 };
0261 
0262 /*
0263  * Somewhat ugly :( global data pointer list with all devices, so that
0264  * we can find our device data as when using misc_register. There is no
0265  * other method to get to one's device data from the open file-op and
0266  * for usage in the reboot notifier callback.
0267  */
0268 static LIST_HEAD(watchdog_data_list);
0269 
0270 /* Note this lock not only protect list access, but also data.kref access */
0271 static DEFINE_MUTEX(watchdog_data_mutex);
0272 
0273 /*
0274  * Release our data struct when we're detached from the i2c client *and* all
0275  * references to our watchdog device are released
0276  */
0277 static void w83793_release_resources(struct kref *ref)
0278 {
0279     struct w83793_data *data = container_of(ref, struct w83793_data, kref);
0280     kfree(data);
0281 }
0282 
0283 static u8 w83793_read_value(struct i2c_client *client, u16 reg);
0284 static int w83793_write_value(struct i2c_client *client, u16 reg, u8 value);
0285 static int w83793_probe(struct i2c_client *client);
0286 static int w83793_detect(struct i2c_client *client,
0287              struct i2c_board_info *info);
0288 static int w83793_remove(struct i2c_client *client);
0289 static void w83793_init_client(struct i2c_client *client);
0290 static void w83793_update_nonvolatile(struct device *dev);
0291 static struct w83793_data *w83793_update_device(struct device *dev);
0292 
0293 static const struct i2c_device_id w83793_id[] = {
0294     { "w83793", 0 },
0295     { }
0296 };
0297 MODULE_DEVICE_TABLE(i2c, w83793_id);
0298 
0299 static struct i2c_driver w83793_driver = {
0300     .class      = I2C_CLASS_HWMON,
0301     .driver = {
0302            .name = "w83793",
0303     },
0304     .probe_new  = w83793_probe,
0305     .remove     = w83793_remove,
0306     .id_table   = w83793_id,
0307     .detect     = w83793_detect,
0308     .address_list   = normal_i2c,
0309 };
0310 
0311 static ssize_t
0312 vrm_show(struct device *dev, struct device_attribute *attr, char *buf)
0313 {
0314     struct w83793_data *data = dev_get_drvdata(dev);
0315     return sprintf(buf, "%d\n", data->vrm);
0316 }
0317 
0318 static ssize_t
0319 show_vid(struct device *dev, struct device_attribute *attr, char *buf)
0320 {
0321     struct w83793_data *data = w83793_update_device(dev);
0322     struct sensor_device_attribute_2 *sensor_attr =
0323         to_sensor_dev_attr_2(attr);
0324     int index = sensor_attr->index;
0325 
0326     return sprintf(buf, "%d\n", vid_from_reg(data->vid[index], data->vrm));
0327 }
0328 
0329 static ssize_t
0330 vrm_store(struct device *dev, struct device_attribute *attr,
0331       const char *buf, size_t count)
0332 {
0333     struct w83793_data *data = dev_get_drvdata(dev);
0334     unsigned long val;
0335     int err;
0336 
0337     err = kstrtoul(buf, 10, &val);
0338     if (err)
0339         return err;
0340 
0341     if (val > 255)
0342         return -EINVAL;
0343 
0344     data->vrm = val;
0345     return count;
0346 }
0347 
0348 #define ALARM_STATUS            0
0349 #define BEEP_ENABLE         1
0350 static ssize_t
0351 show_alarm_beep(struct device *dev, struct device_attribute *attr, char *buf)
0352 {
0353     struct w83793_data *data = w83793_update_device(dev);
0354     struct sensor_device_attribute_2 *sensor_attr =
0355         to_sensor_dev_attr_2(attr);
0356     int nr = sensor_attr->nr;
0357     int index = sensor_attr->index >> 3;
0358     int bit = sensor_attr->index & 0x07;
0359     u8 val;
0360 
0361     if (nr == ALARM_STATUS) {
0362         val = (data->alarms[index] >> (bit)) & 1;
0363     } else {        /* BEEP_ENABLE */
0364         val = (data->beeps[index] >> (bit)) & 1;
0365     }
0366 
0367     return sprintf(buf, "%u\n", val);
0368 }
0369 
0370 static ssize_t
0371 store_beep(struct device *dev, struct device_attribute *attr,
0372        const char *buf, size_t count)
0373 {
0374     struct i2c_client *client = to_i2c_client(dev);
0375     struct w83793_data *data = i2c_get_clientdata(client);
0376     struct sensor_device_attribute_2 *sensor_attr =
0377         to_sensor_dev_attr_2(attr);
0378     int index = sensor_attr->index >> 3;
0379     int shift = sensor_attr->index & 0x07;
0380     u8 beep_bit = 1 << shift;
0381     unsigned long val;
0382     int err;
0383 
0384     err = kstrtoul(buf, 10, &val);
0385     if (err)
0386         return err;
0387 
0388     if (val > 1)
0389         return -EINVAL;
0390 
0391     mutex_lock(&data->update_lock);
0392     data->beeps[index] = w83793_read_value(client, W83793_REG_BEEP(index));
0393     data->beeps[index] &= ~beep_bit;
0394     data->beeps[index] |= val << shift;
0395     w83793_write_value(client, W83793_REG_BEEP(index), data->beeps[index]);
0396     mutex_unlock(&data->update_lock);
0397 
0398     return count;
0399 }
0400 
0401 static ssize_t
0402 show_beep_enable(struct device *dev, struct device_attribute *attr, char *buf)
0403 {
0404     struct w83793_data *data = w83793_update_device(dev);
0405     return sprintf(buf, "%u\n", (data->beep_enable >> 1) & 0x01);
0406 }
0407 
0408 static ssize_t
0409 store_beep_enable(struct device *dev, struct device_attribute *attr,
0410           const char *buf, size_t count)
0411 {
0412     struct i2c_client *client = to_i2c_client(dev);
0413     struct w83793_data *data = i2c_get_clientdata(client);
0414     unsigned long val;
0415     int err;
0416 
0417     err = kstrtoul(buf, 10, &val);
0418     if (err)
0419         return err;
0420 
0421     if (val > 1)
0422         return -EINVAL;
0423 
0424     mutex_lock(&data->update_lock);
0425     data->beep_enable = w83793_read_value(client, W83793_REG_OVT_BEEP)
0426                 & 0xfd;
0427     data->beep_enable |= val << 1;
0428     w83793_write_value(client, W83793_REG_OVT_BEEP, data->beep_enable);
0429     mutex_unlock(&data->update_lock);
0430 
0431     return count;
0432 }
0433 
0434 /* Write 0 to clear chassis alarm */
0435 static ssize_t
0436 store_chassis_clear(struct device *dev,
0437             struct device_attribute *attr, const char *buf,
0438             size_t count)
0439 {
0440     struct i2c_client *client = to_i2c_client(dev);
0441     struct w83793_data *data = i2c_get_clientdata(client);
0442     unsigned long val;
0443     u8 reg;
0444     int err;
0445 
0446     err = kstrtoul(buf, 10, &val);
0447     if (err)
0448         return err;
0449     if (val)
0450         return -EINVAL;
0451 
0452     mutex_lock(&data->update_lock);
0453     reg = w83793_read_value(client, W83793_REG_CLR_CHASSIS);
0454     w83793_write_value(client, W83793_REG_CLR_CHASSIS, reg | 0x80);
0455     data->valid = false;        /* Force cache refresh */
0456     mutex_unlock(&data->update_lock);
0457     return count;
0458 }
0459 
0460 #define FAN_INPUT           0
0461 #define FAN_MIN             1
0462 static ssize_t
0463 show_fan(struct device *dev, struct device_attribute *attr, char *buf)
0464 {
0465     struct sensor_device_attribute_2 *sensor_attr =
0466         to_sensor_dev_attr_2(attr);
0467     int nr = sensor_attr->nr;
0468     int index = sensor_attr->index;
0469     struct w83793_data *data = w83793_update_device(dev);
0470     u16 val;
0471 
0472     if (nr == FAN_INPUT)
0473         val = data->fan[index] & 0x0fff;
0474     else
0475         val = data->fan_min[index] & 0x0fff;
0476 
0477     return sprintf(buf, "%lu\n", FAN_FROM_REG(val));
0478 }
0479 
0480 static ssize_t
0481 store_fan_min(struct device *dev, struct device_attribute *attr,
0482           const char *buf, size_t count)
0483 {
0484     struct sensor_device_attribute_2 *sensor_attr =
0485         to_sensor_dev_attr_2(attr);
0486     int index = sensor_attr->index;
0487     struct i2c_client *client = to_i2c_client(dev);
0488     struct w83793_data *data = i2c_get_clientdata(client);
0489     unsigned long val;
0490     int err;
0491 
0492     err = kstrtoul(buf, 10, &val);
0493     if (err)
0494         return err;
0495     val = FAN_TO_REG(val);
0496 
0497     mutex_lock(&data->update_lock);
0498     data->fan_min[index] = val;
0499     w83793_write_value(client, W83793_REG_FAN_MIN(index),
0500                (val >> 8) & 0xff);
0501     w83793_write_value(client, W83793_REG_FAN_MIN(index) + 1, val & 0xff);
0502     mutex_unlock(&data->update_lock);
0503 
0504     return count;
0505 }
0506 
0507 static ssize_t
0508 show_pwm(struct device *dev, struct device_attribute *attr, char *buf)
0509 {
0510     struct sensor_device_attribute_2 *sensor_attr =
0511         to_sensor_dev_attr_2(attr);
0512     struct w83793_data *data = w83793_update_device(dev);
0513     u16 val;
0514     int nr = sensor_attr->nr;
0515     int index = sensor_attr->index;
0516 
0517     if (nr == PWM_STOP_TIME)
0518         val = TIME_FROM_REG(data->pwm_stop_time[index]);
0519     else
0520         val = (data->pwm[index][nr] & 0x3f) << 2;
0521 
0522     return sprintf(buf, "%d\n", val);
0523 }
0524 
0525 static ssize_t
0526 store_pwm(struct device *dev, struct device_attribute *attr,
0527       const char *buf, size_t count)
0528 {
0529     struct i2c_client *client = to_i2c_client(dev);
0530     struct w83793_data *data = i2c_get_clientdata(client);
0531     struct sensor_device_attribute_2 *sensor_attr =
0532         to_sensor_dev_attr_2(attr);
0533     int nr = sensor_attr->nr;
0534     int index = sensor_attr->index;
0535     unsigned long val;
0536     int err;
0537 
0538     err = kstrtoul(buf, 10, &val);
0539     if (err)
0540         return err;
0541 
0542     mutex_lock(&data->update_lock);
0543     if (nr == PWM_STOP_TIME) {
0544         val = TIME_TO_REG(val);
0545         data->pwm_stop_time[index] = val;
0546         w83793_write_value(client, W83793_REG_PWM_STOP_TIME(index),
0547                    val);
0548     } else {
0549         val = clamp_val(val, 0, 0xff) >> 2;
0550         data->pwm[index][nr] =
0551             w83793_read_value(client, W83793_REG_PWM(index, nr)) & 0xc0;
0552         data->pwm[index][nr] |= val;
0553         w83793_write_value(client, W83793_REG_PWM(index, nr),
0554                             data->pwm[index][nr]);
0555     }
0556 
0557     mutex_unlock(&data->update_lock);
0558     return count;
0559 }
0560 
0561 static ssize_t
0562 show_temp(struct device *dev, struct device_attribute *attr, char *buf)
0563 {
0564     struct sensor_device_attribute_2 *sensor_attr =
0565         to_sensor_dev_attr_2(attr);
0566     int nr = sensor_attr->nr;
0567     int index = sensor_attr->index;
0568     struct w83793_data *data = w83793_update_device(dev);
0569     long temp = TEMP_FROM_REG(data->temp[index][nr]);
0570 
0571     if (nr == TEMP_READ && index < 4) { /* Only TD1-TD4 have low bits */
0572         int low = ((data->temp_low_bits >> (index * 2)) & 0x03) * 250;
0573         temp += temp > 0 ? low : -low;
0574     }
0575     return sprintf(buf, "%ld\n", temp);
0576 }
0577 
0578 static ssize_t
0579 store_temp(struct device *dev, struct device_attribute *attr,
0580        const char *buf, size_t count)
0581 {
0582     struct sensor_device_attribute_2 *sensor_attr =
0583         to_sensor_dev_attr_2(attr);
0584     int nr = sensor_attr->nr;
0585     int index = sensor_attr->index;
0586     struct i2c_client *client = to_i2c_client(dev);
0587     struct w83793_data *data = i2c_get_clientdata(client);
0588     long tmp;
0589     int err;
0590 
0591     err = kstrtol(buf, 10, &tmp);
0592     if (err)
0593         return err;
0594 
0595     mutex_lock(&data->update_lock);
0596     data->temp[index][nr] = TEMP_TO_REG(tmp, -128, 127);
0597     w83793_write_value(client, W83793_REG_TEMP[index][nr],
0598                data->temp[index][nr]);
0599     mutex_unlock(&data->update_lock);
0600     return count;
0601 }
0602 
0603 /*
0604  * TD1-TD4
0605  * each has 4 mode:(2 bits)
0606  * 0:   Stop monitor
0607  * 1:   Use internal temp sensor(default)
0608  * 2:   Reserved
0609  * 3:   Use sensor in Intel CPU and get result by PECI
0610  *
0611  * TR1-TR2
0612  * each has 2 mode:(1 bit)
0613  * 0:   Disable temp sensor monitor
0614  * 1:   To enable temp sensors monitor
0615  */
0616 
0617 /* 0 disable, 6 PECI */
0618 static u8 TO_TEMP_MODE[] = { 0, 0, 0, 6 };
0619 
0620 static ssize_t
0621 show_temp_mode(struct device *dev, struct device_attribute *attr, char *buf)
0622 {
0623     struct w83793_data *data = w83793_update_device(dev);
0624     struct sensor_device_attribute_2 *sensor_attr =
0625         to_sensor_dev_attr_2(attr);
0626     int index = sensor_attr->index;
0627     u8 mask = (index < 4) ? 0x03 : 0x01;
0628     u8 shift = (index < 4) ? (2 * index) : (index - 4);
0629     u8 tmp;
0630     index = (index < 4) ? 0 : 1;
0631 
0632     tmp = (data->temp_mode[index] >> shift) & mask;
0633 
0634     /* for the internal sensor, found out if diode or thermistor */
0635     if (tmp == 1)
0636         tmp = index == 0 ? 3 : 4;
0637     else
0638         tmp = TO_TEMP_MODE[tmp];
0639 
0640     return sprintf(buf, "%d\n", tmp);
0641 }
0642 
0643 static ssize_t
0644 store_temp_mode(struct device *dev, struct device_attribute *attr,
0645         const char *buf, size_t count)
0646 {
0647     struct i2c_client *client = to_i2c_client(dev);
0648     struct w83793_data *data = i2c_get_clientdata(client);
0649     struct sensor_device_attribute_2 *sensor_attr =
0650         to_sensor_dev_attr_2(attr);
0651     int index = sensor_attr->index;
0652     u8 mask = (index < 4) ? 0x03 : 0x01;
0653     u8 shift = (index < 4) ? (2 * index) : (index - 4);
0654     unsigned long val;
0655     int err;
0656 
0657     err = kstrtoul(buf, 10, &val);
0658     if (err)
0659         return err;
0660 
0661     /* transform the sysfs interface values into table above */
0662     if ((val == 6) && (index < 4)) {
0663         val -= 3;
0664     } else if ((val == 3 && index < 4)
0665         || (val == 4 && index >= 4)) {
0666         /* transform diode or thermistor into internal enable */
0667         val = !!val;
0668     } else {
0669         return -EINVAL;
0670     }
0671 
0672     index = (index < 4) ? 0 : 1;
0673     mutex_lock(&data->update_lock);
0674     data->temp_mode[index] =
0675         w83793_read_value(client, W83793_REG_TEMP_MODE[index]);
0676     data->temp_mode[index] &= ~(mask << shift);
0677     data->temp_mode[index] |= val << shift;
0678     w83793_write_value(client, W83793_REG_TEMP_MODE[index],
0679                             data->temp_mode[index]);
0680     mutex_unlock(&data->update_lock);
0681 
0682     return count;
0683 }
0684 
0685 #define SETUP_PWM_DEFAULT       0
0686 #define SETUP_PWM_UPTIME        1   /* Unit in 0.1s */
0687 #define SETUP_PWM_DOWNTIME      2   /* Unit in 0.1s */
0688 #define SETUP_TEMP_CRITICAL     3
0689 static ssize_t
0690 show_sf_setup(struct device *dev, struct device_attribute *attr, char *buf)
0691 {
0692     struct sensor_device_attribute_2 *sensor_attr =
0693         to_sensor_dev_attr_2(attr);
0694     int nr = sensor_attr->nr;
0695     struct w83793_data *data = w83793_update_device(dev);
0696     u32 val = 0;
0697 
0698     if (nr == SETUP_PWM_DEFAULT)
0699         val = (data->pwm_default & 0x3f) << 2;
0700     else if (nr == SETUP_PWM_UPTIME)
0701         val = TIME_FROM_REG(data->pwm_uptime);
0702     else if (nr == SETUP_PWM_DOWNTIME)
0703         val = TIME_FROM_REG(data->pwm_downtime);
0704     else if (nr == SETUP_TEMP_CRITICAL)
0705         val = TEMP_FROM_REG(data->temp_critical & 0x7f);
0706 
0707     return sprintf(buf, "%d\n", val);
0708 }
0709 
0710 static ssize_t
0711 store_sf_setup(struct device *dev, struct device_attribute *attr,
0712            const char *buf, size_t count)
0713 {
0714     struct sensor_device_attribute_2 *sensor_attr =
0715         to_sensor_dev_attr_2(attr);
0716     int nr = sensor_attr->nr;
0717     struct i2c_client *client = to_i2c_client(dev);
0718     struct w83793_data *data = i2c_get_clientdata(client);
0719     long val;
0720     int err;
0721 
0722     err = kstrtol(buf, 10, &val);
0723     if (err)
0724         return err;
0725 
0726     mutex_lock(&data->update_lock);
0727     if (nr == SETUP_PWM_DEFAULT) {
0728         data->pwm_default =
0729             w83793_read_value(client, W83793_REG_PWM_DEFAULT) & 0xc0;
0730         data->pwm_default |= clamp_val(val, 0, 0xff) >> 2;
0731         w83793_write_value(client, W83793_REG_PWM_DEFAULT,
0732                             data->pwm_default);
0733     } else if (nr == SETUP_PWM_UPTIME) {
0734         data->pwm_uptime = TIME_TO_REG(val);
0735         data->pwm_uptime += data->pwm_uptime == 0 ? 1 : 0;
0736         w83793_write_value(client, W83793_REG_PWM_UPTIME,
0737                             data->pwm_uptime);
0738     } else if (nr == SETUP_PWM_DOWNTIME) {
0739         data->pwm_downtime = TIME_TO_REG(val);
0740         data->pwm_downtime += data->pwm_downtime == 0 ? 1 : 0;
0741         w83793_write_value(client, W83793_REG_PWM_DOWNTIME,
0742                             data->pwm_downtime);
0743     } else {        /* SETUP_TEMP_CRITICAL */
0744         data->temp_critical =
0745             w83793_read_value(client, W83793_REG_TEMP_CRITICAL) & 0x80;
0746         data->temp_critical |= TEMP_TO_REG(val, 0, 0x7f);
0747         w83793_write_value(client, W83793_REG_TEMP_CRITICAL,
0748                             data->temp_critical);
0749     }
0750 
0751     mutex_unlock(&data->update_lock);
0752     return count;
0753 }
0754 
0755 /*
0756  * Temp SmartFan control
0757  * TEMP_FAN_MAP
0758  * Temp channel control which pwm fan, bitfield, bit 0 indicate pwm1...
0759  * It's possible two or more temp channels control the same fan, w83793
0760  * always prefers to pick the most critical request and applies it to
0761  * the related Fan.
0762  * It's possible one fan is not in any mapping of 6 temp channels, this
0763  * means the fan is manual mode
0764  *
0765  * TEMP_PWM_ENABLE
0766  * Each temp channel has its own SmartFan mode, and temp channel
0767  * control fans that are set by TEMP_FAN_MAP
0768  * 0:   SmartFanII mode
0769  * 1:   Thermal Cruise Mode
0770  *
0771  * TEMP_CRUISE
0772  * Target temperature in thermal cruise mode, w83793 will try to turn
0773  * fan speed to keep the temperature of target device around this
0774  * temperature.
0775  *
0776  * TEMP_TOLERANCE
0777  * If Temp higher or lower than target with this tolerance, w83793
0778  * will take actions to speed up or slow down the fan to keep the
0779  * temperature within the tolerance range.
0780  */
0781 
0782 #define TEMP_FAN_MAP            0
0783 #define TEMP_PWM_ENABLE         1
0784 #define TEMP_CRUISE         2
0785 #define TEMP_TOLERANCE          3
0786 static ssize_t
0787 show_sf_ctrl(struct device *dev, struct device_attribute *attr, char *buf)
0788 {
0789     struct sensor_device_attribute_2 *sensor_attr =
0790         to_sensor_dev_attr_2(attr);
0791     int nr = sensor_attr->nr;
0792     int index = sensor_attr->index;
0793     struct w83793_data *data = w83793_update_device(dev);
0794     u32 val;
0795 
0796     if (nr == TEMP_FAN_MAP) {
0797         val = data->temp_fan_map[index];
0798     } else if (nr == TEMP_PWM_ENABLE) {
0799         /* +2 to transform into 2 and 3 to conform with sysfs intf */
0800         val = ((data->pwm_enable >> index) & 0x01) + 2;
0801     } else if (nr == TEMP_CRUISE) {
0802         val = TEMP_FROM_REG(data->temp_cruise[index] & 0x7f);
0803     } else {        /* TEMP_TOLERANCE */
0804         val = data->tolerance[index >> 1] >> ((index & 0x01) ? 4 : 0);
0805         val = TEMP_FROM_REG(val & 0x0f);
0806     }
0807     return sprintf(buf, "%d\n", val);
0808 }
0809 
0810 static ssize_t
0811 store_sf_ctrl(struct device *dev, struct device_attribute *attr,
0812           const char *buf, size_t count)
0813 {
0814     struct sensor_device_attribute_2 *sensor_attr =
0815         to_sensor_dev_attr_2(attr);
0816     int nr = sensor_attr->nr;
0817     int index = sensor_attr->index;
0818     struct i2c_client *client = to_i2c_client(dev);
0819     struct w83793_data *data = i2c_get_clientdata(client);
0820     long val;
0821     int err;
0822 
0823     err = kstrtol(buf, 10, &val);
0824     if (err)
0825         return err;
0826 
0827     mutex_lock(&data->update_lock);
0828     if (nr == TEMP_FAN_MAP) {
0829         val = clamp_val(val, 0, 255);
0830         w83793_write_value(client, W83793_REG_TEMP_FAN_MAP(index), val);
0831         data->temp_fan_map[index] = val;
0832     } else if (nr == TEMP_PWM_ENABLE) {
0833         if (val == 2 || val == 3) {
0834             data->pwm_enable =
0835                 w83793_read_value(client, W83793_REG_PWM_ENABLE);
0836             if (val - 2)
0837                 data->pwm_enable |= 1 << index;
0838             else
0839                 data->pwm_enable &= ~(1 << index);
0840             w83793_write_value(client, W83793_REG_PWM_ENABLE,
0841                             data->pwm_enable);
0842         } else {
0843             mutex_unlock(&data->update_lock);
0844             return -EINVAL;
0845         }
0846     } else if (nr == TEMP_CRUISE) {
0847         data->temp_cruise[index] =
0848             w83793_read_value(client, W83793_REG_TEMP_CRUISE(index));
0849         data->temp_cruise[index] &= 0x80;
0850         data->temp_cruise[index] |= TEMP_TO_REG(val, 0, 0x7f);
0851 
0852         w83793_write_value(client, W83793_REG_TEMP_CRUISE(index),
0853                         data->temp_cruise[index]);
0854     } else {        /* TEMP_TOLERANCE */
0855         int i = index >> 1;
0856         u8 shift = (index & 0x01) ? 4 : 0;
0857         data->tolerance[i] =
0858             w83793_read_value(client, W83793_REG_TEMP_TOL(i));
0859 
0860         data->tolerance[i] &= ~(0x0f << shift);
0861         data->tolerance[i] |= TEMP_TO_REG(val, 0, 0x0f) << shift;
0862         w83793_write_value(client, W83793_REG_TEMP_TOL(i),
0863                             data->tolerance[i]);
0864     }
0865 
0866     mutex_unlock(&data->update_lock);
0867     return count;
0868 }
0869 
0870 static ssize_t
0871 show_sf2_pwm(struct device *dev, struct device_attribute *attr, char *buf)
0872 {
0873     struct sensor_device_attribute_2 *sensor_attr =
0874         to_sensor_dev_attr_2(attr);
0875     int nr = sensor_attr->nr;
0876     int index = sensor_attr->index;
0877     struct w83793_data *data = w83793_update_device(dev);
0878 
0879     return sprintf(buf, "%d\n", (data->sf2_pwm[index][nr] & 0x3f) << 2);
0880 }
0881 
0882 static ssize_t
0883 store_sf2_pwm(struct device *dev, struct device_attribute *attr,
0884           const char *buf, size_t count)
0885 {
0886     struct i2c_client *client = to_i2c_client(dev);
0887     struct w83793_data *data = i2c_get_clientdata(client);
0888     struct sensor_device_attribute_2 *sensor_attr =
0889         to_sensor_dev_attr_2(attr);
0890     int nr = sensor_attr->nr;
0891     int index = sensor_attr->index;
0892     unsigned long val;
0893     int err;
0894 
0895     err = kstrtoul(buf, 10, &val);
0896     if (err)
0897         return err;
0898     val = clamp_val(val, 0, 0xff) >> 2;
0899 
0900     mutex_lock(&data->update_lock);
0901     data->sf2_pwm[index][nr] =
0902         w83793_read_value(client, W83793_REG_SF2_PWM(index, nr)) & 0xc0;
0903     data->sf2_pwm[index][nr] |= val;
0904     w83793_write_value(client, W83793_REG_SF2_PWM(index, nr),
0905                         data->sf2_pwm[index][nr]);
0906     mutex_unlock(&data->update_lock);
0907     return count;
0908 }
0909 
0910 static ssize_t
0911 show_sf2_temp(struct device *dev, struct device_attribute *attr, char *buf)
0912 {
0913     struct sensor_device_attribute_2 *sensor_attr =
0914         to_sensor_dev_attr_2(attr);
0915     int nr = sensor_attr->nr;
0916     int index = sensor_attr->index;
0917     struct w83793_data *data = w83793_update_device(dev);
0918 
0919     return sprintf(buf, "%ld\n",
0920                TEMP_FROM_REG(data->sf2_temp[index][nr] & 0x7f));
0921 }
0922 
0923 static ssize_t
0924 store_sf2_temp(struct device *dev, struct device_attribute *attr,
0925            const char *buf, size_t count)
0926 {
0927     struct i2c_client *client = to_i2c_client(dev);
0928     struct w83793_data *data = i2c_get_clientdata(client);
0929     struct sensor_device_attribute_2 *sensor_attr =
0930         to_sensor_dev_attr_2(attr);
0931     int nr = sensor_attr->nr;
0932     int index = sensor_attr->index;
0933     long val;
0934     int err;
0935 
0936     err = kstrtol(buf, 10, &val);
0937     if (err)
0938         return err;
0939     val = TEMP_TO_REG(val, 0, 0x7f);
0940 
0941     mutex_lock(&data->update_lock);
0942     data->sf2_temp[index][nr] =
0943         w83793_read_value(client, W83793_REG_SF2_TEMP(index, nr)) & 0x80;
0944     data->sf2_temp[index][nr] |= val;
0945     w83793_write_value(client, W83793_REG_SF2_TEMP(index, nr),
0946                          data->sf2_temp[index][nr]);
0947     mutex_unlock(&data->update_lock);
0948     return count;
0949 }
0950 
0951 /* only Vcore A/B and Vtt have additional 2 bits precision */
0952 static ssize_t
0953 show_in(struct device *dev, struct device_attribute *attr, char *buf)
0954 {
0955     struct sensor_device_attribute_2 *sensor_attr =
0956         to_sensor_dev_attr_2(attr);
0957     int nr = sensor_attr->nr;
0958     int index = sensor_attr->index;
0959     struct w83793_data *data = w83793_update_device(dev);
0960     u16 val = data->in[index][nr];
0961 
0962     if (index < 3) {
0963         val <<= 2;
0964         val += (data->in_low_bits[nr] >> (index * 2)) & 0x3;
0965     }
0966     /* voltage inputs 5VDD and 5VSB needs 150mV offset */
0967     val = val * scale_in[index] + scale_in_add[index];
0968     return sprintf(buf, "%d\n", val);
0969 }
0970 
0971 static ssize_t
0972 store_in(struct device *dev, struct device_attribute *attr,
0973      const char *buf, size_t count)
0974 {
0975     struct sensor_device_attribute_2 *sensor_attr =
0976         to_sensor_dev_attr_2(attr);
0977     int nr = sensor_attr->nr;
0978     int index = sensor_attr->index;
0979     struct i2c_client *client = to_i2c_client(dev);
0980     struct w83793_data *data = i2c_get_clientdata(client);
0981     unsigned long val;
0982     int err;
0983 
0984     err = kstrtoul(buf, 10, &val);
0985     if (err)
0986         return err;
0987     val = (val + scale_in[index] / 2) / scale_in[index];
0988 
0989     mutex_lock(&data->update_lock);
0990     if (index > 2) {
0991         /* fix the limit values of 5VDD and 5VSB to ALARM mechanism */
0992         if (nr == 1 || nr == 2)
0993             val -= scale_in_add[index] / scale_in[index];
0994         val = clamp_val(val, 0, 255);
0995     } else {
0996         val = clamp_val(val, 0, 0x3FF);
0997         data->in_low_bits[nr] =
0998             w83793_read_value(client, W83793_REG_IN_LOW_BITS[nr]);
0999         data->in_low_bits[nr] &= ~(0x03 << (2 * index));
1000         data->in_low_bits[nr] |= (val & 0x03) << (2 * index);
1001         w83793_write_value(client, W83793_REG_IN_LOW_BITS[nr],
1002                              data->in_low_bits[nr]);
1003         val >>= 2;
1004     }
1005     data->in[index][nr] = val;
1006     w83793_write_value(client, W83793_REG_IN[index][nr],
1007                             data->in[index][nr]);
1008     mutex_unlock(&data->update_lock);
1009     return count;
1010 }
1011 
1012 #define NOT_USED            -1
1013 
1014 #define SENSOR_ATTR_IN(index)                       \
1015     SENSOR_ATTR_2(in##index##_input, S_IRUGO, show_in, NULL,    \
1016         IN_READ, index),                    \
1017     SENSOR_ATTR_2(in##index##_max, S_IRUGO | S_IWUSR, show_in,  \
1018         store_in, IN_MAX, index),               \
1019     SENSOR_ATTR_2(in##index##_min, S_IRUGO | S_IWUSR, show_in,  \
1020         store_in, IN_LOW, index),               \
1021     SENSOR_ATTR_2(in##index##_alarm, S_IRUGO, show_alarm_beep,  \
1022         NULL, ALARM_STATUS, index + ((index > 2) ? 1 : 0)), \
1023     SENSOR_ATTR_2(in##index##_beep, S_IWUSR | S_IRUGO,      \
1024         show_alarm_beep, store_beep, BEEP_ENABLE,       \
1025         index + ((index > 2) ? 1 : 0))
1026 
1027 #define SENSOR_ATTR_FAN(index)                      \
1028     SENSOR_ATTR_2(fan##index##_alarm, S_IRUGO, show_alarm_beep, \
1029         NULL, ALARM_STATUS, index + 17),            \
1030     SENSOR_ATTR_2(fan##index##_beep, S_IWUSR | S_IRUGO,     \
1031         show_alarm_beep, store_beep, BEEP_ENABLE, index + 17),  \
1032     SENSOR_ATTR_2(fan##index##_input, S_IRUGO, show_fan,        \
1033         NULL, FAN_INPUT, index - 1),                \
1034     SENSOR_ATTR_2(fan##index##_min, S_IWUSR | S_IRUGO,      \
1035         show_fan, store_fan_min, FAN_MIN, index - 1)
1036 
1037 #define SENSOR_ATTR_PWM(index)                      \
1038     SENSOR_ATTR_2(pwm##index, S_IWUSR | S_IRUGO, show_pwm,      \
1039         store_pwm, PWM_DUTY, index - 1),            \
1040     SENSOR_ATTR_2(pwm##index##_nonstop, S_IWUSR | S_IRUGO,      \
1041         show_pwm, store_pwm, PWM_NONSTOP, index - 1),       \
1042     SENSOR_ATTR_2(pwm##index##_start, S_IWUSR | S_IRUGO,        \
1043         show_pwm, store_pwm, PWM_START, index - 1),     \
1044     SENSOR_ATTR_2(pwm##index##_stop_time, S_IWUSR | S_IRUGO,    \
1045         show_pwm, store_pwm, PWM_STOP_TIME, index - 1)
1046 
1047 #define SENSOR_ATTR_TEMP(index)                     \
1048     SENSOR_ATTR_2(temp##index##_type, S_IRUGO | S_IWUSR,        \
1049         show_temp_mode, store_temp_mode, NOT_USED, index - 1),  \
1050     SENSOR_ATTR_2(temp##index##_input, S_IRUGO, show_temp,      \
1051         NULL, TEMP_READ, index - 1),                \
1052     SENSOR_ATTR_2(temp##index##_max, S_IRUGO | S_IWUSR, show_temp,  \
1053         store_temp, TEMP_CRIT, index - 1),          \
1054     SENSOR_ATTR_2(temp##index##_max_hyst, S_IRUGO | S_IWUSR,    \
1055         show_temp, store_temp, TEMP_CRIT_HYST, index - 1),  \
1056     SENSOR_ATTR_2(temp##index##_warn, S_IRUGO | S_IWUSR, show_temp, \
1057         store_temp, TEMP_WARN, index - 1),          \
1058     SENSOR_ATTR_2(temp##index##_warn_hyst, S_IRUGO | S_IWUSR,   \
1059         show_temp, store_temp, TEMP_WARN_HYST, index - 1),  \
1060     SENSOR_ATTR_2(temp##index##_alarm, S_IRUGO,         \
1061         show_alarm_beep, NULL, ALARM_STATUS, index + 11),   \
1062     SENSOR_ATTR_2(temp##index##_beep, S_IWUSR | S_IRUGO,        \
1063         show_alarm_beep, store_beep, BEEP_ENABLE, index + 11),  \
1064     SENSOR_ATTR_2(temp##index##_auto_channels_pwm,          \
1065         S_IRUGO | S_IWUSR, show_sf_ctrl, store_sf_ctrl,     \
1066         TEMP_FAN_MAP, index - 1),               \
1067     SENSOR_ATTR_2(temp##index##_pwm_enable, S_IWUSR | S_IRUGO,  \
1068         show_sf_ctrl, store_sf_ctrl, TEMP_PWM_ENABLE,       \
1069         index - 1),                     \
1070     SENSOR_ATTR_2(thermal_cruise##index, S_IRUGO | S_IWUSR,     \
1071         show_sf_ctrl, store_sf_ctrl, TEMP_CRUISE, index - 1),   \
1072     SENSOR_ATTR_2(tolerance##index, S_IRUGO | S_IWUSR, show_sf_ctrl,\
1073         store_sf_ctrl, TEMP_TOLERANCE, index - 1),      \
1074     SENSOR_ATTR_2(temp##index##_auto_point1_pwm, S_IRUGO | S_IWUSR, \
1075         show_sf2_pwm, store_sf2_pwm, 0, index - 1),     \
1076     SENSOR_ATTR_2(temp##index##_auto_point2_pwm, S_IRUGO | S_IWUSR, \
1077         show_sf2_pwm, store_sf2_pwm, 1, index - 1),     \
1078     SENSOR_ATTR_2(temp##index##_auto_point3_pwm, S_IRUGO | S_IWUSR, \
1079         show_sf2_pwm, store_sf2_pwm, 2, index - 1),     \
1080     SENSOR_ATTR_2(temp##index##_auto_point4_pwm, S_IRUGO | S_IWUSR, \
1081         show_sf2_pwm, store_sf2_pwm, 3, index - 1),     \
1082     SENSOR_ATTR_2(temp##index##_auto_point5_pwm, S_IRUGO | S_IWUSR, \
1083         show_sf2_pwm, store_sf2_pwm, 4, index - 1),     \
1084     SENSOR_ATTR_2(temp##index##_auto_point6_pwm, S_IRUGO | S_IWUSR, \
1085         show_sf2_pwm, store_sf2_pwm, 5, index - 1),     \
1086     SENSOR_ATTR_2(temp##index##_auto_point7_pwm, S_IRUGO | S_IWUSR, \
1087         show_sf2_pwm, store_sf2_pwm, 6, index - 1),     \
1088     SENSOR_ATTR_2(temp##index##_auto_point1_temp, S_IRUGO | S_IWUSR,\
1089         show_sf2_temp, store_sf2_temp, 0, index - 1),       \
1090     SENSOR_ATTR_2(temp##index##_auto_point2_temp, S_IRUGO | S_IWUSR,\
1091         show_sf2_temp, store_sf2_temp, 1, index - 1),       \
1092     SENSOR_ATTR_2(temp##index##_auto_point3_temp, S_IRUGO | S_IWUSR,\
1093         show_sf2_temp, store_sf2_temp, 2, index - 1),       \
1094     SENSOR_ATTR_2(temp##index##_auto_point4_temp, S_IRUGO | S_IWUSR,\
1095         show_sf2_temp, store_sf2_temp, 3, index - 1),       \
1096     SENSOR_ATTR_2(temp##index##_auto_point5_temp, S_IRUGO | S_IWUSR,\
1097         show_sf2_temp, store_sf2_temp, 4, index - 1),       \
1098     SENSOR_ATTR_2(temp##index##_auto_point6_temp, S_IRUGO | S_IWUSR,\
1099         show_sf2_temp, store_sf2_temp, 5, index - 1),       \
1100     SENSOR_ATTR_2(temp##index##_auto_point7_temp, S_IRUGO | S_IWUSR,\
1101         show_sf2_temp, store_sf2_temp, 6, index - 1)
1102 
1103 static struct sensor_device_attribute_2 w83793_sensor_attr_2[] = {
1104     SENSOR_ATTR_IN(0),
1105     SENSOR_ATTR_IN(1),
1106     SENSOR_ATTR_IN(2),
1107     SENSOR_ATTR_IN(3),
1108     SENSOR_ATTR_IN(4),
1109     SENSOR_ATTR_IN(5),
1110     SENSOR_ATTR_IN(6),
1111     SENSOR_ATTR_IN(7),
1112     SENSOR_ATTR_IN(8),
1113     SENSOR_ATTR_IN(9),
1114     SENSOR_ATTR_FAN(1),
1115     SENSOR_ATTR_FAN(2),
1116     SENSOR_ATTR_FAN(3),
1117     SENSOR_ATTR_FAN(4),
1118     SENSOR_ATTR_FAN(5),
1119     SENSOR_ATTR_PWM(1),
1120     SENSOR_ATTR_PWM(2),
1121     SENSOR_ATTR_PWM(3),
1122 };
1123 
1124 static struct sensor_device_attribute_2 w83793_temp[] = {
1125     SENSOR_ATTR_TEMP(1),
1126     SENSOR_ATTR_TEMP(2),
1127     SENSOR_ATTR_TEMP(3),
1128     SENSOR_ATTR_TEMP(4),
1129     SENSOR_ATTR_TEMP(5),
1130     SENSOR_ATTR_TEMP(6),
1131 };
1132 
1133 /* Fan6-Fan12 */
1134 static struct sensor_device_attribute_2 w83793_left_fan[] = {
1135     SENSOR_ATTR_FAN(6),
1136     SENSOR_ATTR_FAN(7),
1137     SENSOR_ATTR_FAN(8),
1138     SENSOR_ATTR_FAN(9),
1139     SENSOR_ATTR_FAN(10),
1140     SENSOR_ATTR_FAN(11),
1141     SENSOR_ATTR_FAN(12),
1142 };
1143 
1144 /* Pwm4-Pwm8 */
1145 static struct sensor_device_attribute_2 w83793_left_pwm[] = {
1146     SENSOR_ATTR_PWM(4),
1147     SENSOR_ATTR_PWM(5),
1148     SENSOR_ATTR_PWM(6),
1149     SENSOR_ATTR_PWM(7),
1150     SENSOR_ATTR_PWM(8),
1151 };
1152 
1153 static struct sensor_device_attribute_2 w83793_vid[] = {
1154     SENSOR_ATTR_2(cpu0_vid, S_IRUGO, show_vid, NULL, NOT_USED, 0),
1155     SENSOR_ATTR_2(cpu1_vid, S_IRUGO, show_vid, NULL, NOT_USED, 1),
1156 };
1157 static DEVICE_ATTR_RW(vrm);
1158 
1159 static struct sensor_device_attribute_2 sda_single_files[] = {
1160     SENSOR_ATTR_2(intrusion0_alarm, S_IWUSR | S_IRUGO, show_alarm_beep,
1161               store_chassis_clear, ALARM_STATUS, 30),
1162     SENSOR_ATTR_2(beep_enable, S_IWUSR | S_IRUGO, show_beep_enable,
1163               store_beep_enable, NOT_USED, NOT_USED),
1164     SENSOR_ATTR_2(pwm_default, S_IWUSR | S_IRUGO, show_sf_setup,
1165               store_sf_setup, SETUP_PWM_DEFAULT, NOT_USED),
1166     SENSOR_ATTR_2(pwm_uptime, S_IWUSR | S_IRUGO, show_sf_setup,
1167               store_sf_setup, SETUP_PWM_UPTIME, NOT_USED),
1168     SENSOR_ATTR_2(pwm_downtime, S_IWUSR | S_IRUGO, show_sf_setup,
1169               store_sf_setup, SETUP_PWM_DOWNTIME, NOT_USED),
1170     SENSOR_ATTR_2(temp_critical, S_IWUSR | S_IRUGO, show_sf_setup,
1171               store_sf_setup, SETUP_TEMP_CRITICAL, NOT_USED),
1172 };
1173 
1174 static void w83793_init_client(struct i2c_client *client)
1175 {
1176     if (reset)
1177         w83793_write_value(client, W83793_REG_CONFIG, 0x80);
1178 
1179     /* Start monitoring */
1180     w83793_write_value(client, W83793_REG_CONFIG,
1181                w83793_read_value(client, W83793_REG_CONFIG) | 0x01);
1182 }
1183 
1184 /*
1185  * Watchdog routines
1186  */
1187 
1188 static int watchdog_set_timeout(struct w83793_data *data, int timeout)
1189 {
1190     unsigned int mtimeout;
1191     int ret;
1192 
1193     mtimeout = DIV_ROUND_UP(timeout, 60);
1194 
1195     if (mtimeout > 255)
1196         return -EINVAL;
1197 
1198     mutex_lock(&data->watchdog_lock);
1199     if (!data->client) {
1200         ret = -ENODEV;
1201         goto leave;
1202     }
1203 
1204     data->watchdog_timeout = mtimeout;
1205 
1206     /* Set Timeout value (in Minutes) */
1207     w83793_write_value(data->client, W83793_REG_WDT_TIMEOUT,
1208                data->watchdog_timeout);
1209 
1210     ret = mtimeout * 60;
1211 
1212 leave:
1213     mutex_unlock(&data->watchdog_lock);
1214     return ret;
1215 }
1216 
1217 static int watchdog_get_timeout(struct w83793_data *data)
1218 {
1219     int timeout;
1220 
1221     mutex_lock(&data->watchdog_lock);
1222     timeout = data->watchdog_timeout * 60;
1223     mutex_unlock(&data->watchdog_lock);
1224 
1225     return timeout;
1226 }
1227 
1228 static int watchdog_trigger(struct w83793_data *data)
1229 {
1230     int ret = 0;
1231 
1232     mutex_lock(&data->watchdog_lock);
1233     if (!data->client) {
1234         ret = -ENODEV;
1235         goto leave;
1236     }
1237 
1238     /* Set Timeout value (in Minutes) */
1239     w83793_write_value(data->client, W83793_REG_WDT_TIMEOUT,
1240                data->watchdog_timeout);
1241 
1242 leave:
1243     mutex_unlock(&data->watchdog_lock);
1244     return ret;
1245 }
1246 
1247 static int watchdog_enable(struct w83793_data *data)
1248 {
1249     int ret = 0;
1250 
1251     mutex_lock(&data->watchdog_lock);
1252     if (!data->client) {
1253         ret = -ENODEV;
1254         goto leave;
1255     }
1256 
1257     /* Set initial timeout */
1258     w83793_write_value(data->client, W83793_REG_WDT_TIMEOUT,
1259                data->watchdog_timeout);
1260 
1261     /* Enable Soft Watchdog */
1262     w83793_write_value(data->client, W83793_REG_WDT_LOCK, 0x55);
1263 
1264 leave:
1265     mutex_unlock(&data->watchdog_lock);
1266     return ret;
1267 }
1268 
1269 static int watchdog_disable(struct w83793_data *data)
1270 {
1271     int ret = 0;
1272 
1273     mutex_lock(&data->watchdog_lock);
1274     if (!data->client) {
1275         ret = -ENODEV;
1276         goto leave;
1277     }
1278 
1279     /* Disable Soft Watchdog */
1280     w83793_write_value(data->client, W83793_REG_WDT_LOCK, 0xAA);
1281 
1282 leave:
1283     mutex_unlock(&data->watchdog_lock);
1284     return ret;
1285 }
1286 
1287 static int watchdog_open(struct inode *inode, struct file *filp)
1288 {
1289     struct w83793_data *pos, *data = NULL;
1290     int watchdog_is_open;
1291 
1292     /*
1293      * We get called from drivers/char/misc.c with misc_mtx hold, and we
1294      * call misc_register() from  w83793_probe() with watchdog_data_mutex
1295      * hold, as misc_register() takes the misc_mtx lock, this is a possible
1296      * deadlock, so we use mutex_trylock here.
1297      */
1298     if (!mutex_trylock(&watchdog_data_mutex))
1299         return -ERESTARTSYS;
1300     list_for_each_entry(pos, &watchdog_data_list, list) {
1301         if (pos->watchdog_miscdev.minor == iminor(inode)) {
1302             data = pos;
1303             break;
1304         }
1305     }
1306 
1307     /* Check, if device is already open */
1308     watchdog_is_open = test_and_set_bit(0, &data->watchdog_is_open);
1309 
1310     /*
1311      * Increase data reference counter (if not already done).
1312      * Note we can never not have found data, so we don't check for this
1313      */
1314     if (!watchdog_is_open)
1315         kref_get(&data->kref);
1316 
1317     mutex_unlock(&watchdog_data_mutex);
1318 
1319     /* Check, if device is already open and possibly issue error */
1320     if (watchdog_is_open)
1321         return -EBUSY;
1322 
1323     /* Enable Soft Watchdog */
1324     watchdog_enable(data);
1325 
1326     /* Store pointer to data into filp's private data */
1327     filp->private_data = data;
1328 
1329     return stream_open(inode, filp);
1330 }
1331 
1332 static int watchdog_close(struct inode *inode, struct file *filp)
1333 {
1334     struct w83793_data *data = filp->private_data;
1335 
1336     if (data->watchdog_expect_close) {
1337         watchdog_disable(data);
1338         data->watchdog_expect_close = 0;
1339     } else {
1340         watchdog_trigger(data);
1341         dev_crit(&data->client->dev,
1342             "unexpected close, not stopping watchdog!\n");
1343     }
1344 
1345     clear_bit(0, &data->watchdog_is_open);
1346 
1347     /* Decrease data reference counter */
1348     mutex_lock(&watchdog_data_mutex);
1349     kref_put(&data->kref, w83793_release_resources);
1350     mutex_unlock(&watchdog_data_mutex);
1351 
1352     return 0;
1353 }
1354 
1355 static ssize_t watchdog_write(struct file *filp, const char __user *buf,
1356     size_t count, loff_t *offset)
1357 {
1358     ssize_t ret;
1359     struct w83793_data *data = filp->private_data;
1360 
1361     if (count) {
1362         if (!nowayout) {
1363             size_t i;
1364 
1365             /* Clear it in case it was set with a previous write */
1366             data->watchdog_expect_close = 0;
1367 
1368             for (i = 0; i != count; i++) {
1369                 char c;
1370                 if (get_user(c, buf + i))
1371                     return -EFAULT;
1372                 if (c == 'V')
1373                     data->watchdog_expect_close = 1;
1374             }
1375         }
1376         ret = watchdog_trigger(data);
1377         if (ret < 0)
1378             return ret;
1379     }
1380     return count;
1381 }
1382 
1383 static long watchdog_ioctl(struct file *filp, unsigned int cmd,
1384                unsigned long arg)
1385 {
1386     struct watchdog_info ident = {
1387         .options = WDIOF_KEEPALIVEPING |
1388                WDIOF_SETTIMEOUT |
1389                WDIOF_CARDRESET,
1390         .identity = "w83793 watchdog"
1391     };
1392 
1393     int val, ret = 0;
1394     struct w83793_data *data = filp->private_data;
1395 
1396     switch (cmd) {
1397     case WDIOC_GETSUPPORT:
1398         if (!nowayout)
1399             ident.options |= WDIOF_MAGICCLOSE;
1400         if (copy_to_user((void __user *)arg, &ident, sizeof(ident)))
1401             ret = -EFAULT;
1402         break;
1403 
1404     case WDIOC_GETSTATUS:
1405         val = data->watchdog_caused_reboot ? WDIOF_CARDRESET : 0;
1406         ret = put_user(val, (int __user *)arg);
1407         break;
1408 
1409     case WDIOC_GETBOOTSTATUS:
1410         ret = put_user(0, (int __user *)arg);
1411         break;
1412 
1413     case WDIOC_KEEPALIVE:
1414         ret = watchdog_trigger(data);
1415         break;
1416 
1417     case WDIOC_GETTIMEOUT:
1418         val = watchdog_get_timeout(data);
1419         ret = put_user(val, (int __user *)arg);
1420         break;
1421 
1422     case WDIOC_SETTIMEOUT:
1423         if (get_user(val, (int __user *)arg)) {
1424             ret = -EFAULT;
1425             break;
1426         }
1427         ret = watchdog_set_timeout(data, val);
1428         if (ret > 0)
1429             ret = put_user(ret, (int __user *)arg);
1430         break;
1431 
1432     case WDIOC_SETOPTIONS:
1433         if (get_user(val, (int __user *)arg)) {
1434             ret = -EFAULT;
1435             break;
1436         }
1437 
1438         if (val & WDIOS_DISABLECARD)
1439             ret = watchdog_disable(data);
1440         else if (val & WDIOS_ENABLECARD)
1441             ret = watchdog_enable(data);
1442         else
1443             ret = -EINVAL;
1444 
1445         break;
1446     default:
1447         ret = -ENOTTY;
1448     }
1449     return ret;
1450 }
1451 
1452 static const struct file_operations watchdog_fops = {
1453     .owner = THIS_MODULE,
1454     .llseek = no_llseek,
1455     .open = watchdog_open,
1456     .release = watchdog_close,
1457     .write = watchdog_write,
1458     .unlocked_ioctl = watchdog_ioctl,
1459     .compat_ioctl = compat_ptr_ioctl,
1460 };
1461 
1462 /*
1463  *  Notifier for system down
1464  */
1465 
1466 static int watchdog_notify_sys(struct notifier_block *this, unsigned long code,
1467                    void *unused)
1468 {
1469     struct w83793_data *data = NULL;
1470 
1471     if (code == SYS_DOWN || code == SYS_HALT) {
1472 
1473         /* Disable each registered watchdog */
1474         mutex_lock(&watchdog_data_mutex);
1475         list_for_each_entry(data, &watchdog_data_list, list) {
1476             if (data->watchdog_miscdev.minor)
1477                 watchdog_disable(data);
1478         }
1479         mutex_unlock(&watchdog_data_mutex);
1480     }
1481 
1482     return NOTIFY_DONE;
1483 }
1484 
1485 /*
1486  *  The WDT needs to learn about soft shutdowns in order to
1487  *  turn the timebomb registers off.
1488  */
1489 
1490 static struct notifier_block watchdog_notifier = {
1491     .notifier_call = watchdog_notify_sys,
1492 };
1493 
1494 /*
1495  * Init / remove routines
1496  */
1497 
1498 static int w83793_remove(struct i2c_client *client)
1499 {
1500     struct w83793_data *data = i2c_get_clientdata(client);
1501     struct device *dev = &client->dev;
1502     int i, tmp;
1503 
1504     /* Unregister the watchdog (if registered) */
1505     if (data->watchdog_miscdev.minor) {
1506         misc_deregister(&data->watchdog_miscdev);
1507 
1508         if (data->watchdog_is_open) {
1509             dev_warn(&client->dev,
1510                 "i2c client detached with watchdog open! "
1511                 "Stopping watchdog.\n");
1512             watchdog_disable(data);
1513         }
1514 
1515         mutex_lock(&watchdog_data_mutex);
1516         list_del(&data->list);
1517         mutex_unlock(&watchdog_data_mutex);
1518 
1519         /* Tell the watchdog code the client is gone */
1520         mutex_lock(&data->watchdog_lock);
1521         data->client = NULL;
1522         mutex_unlock(&data->watchdog_lock);
1523     }
1524 
1525     /* Reset Configuration Register to Disable Watch Dog Registers */
1526     tmp = w83793_read_value(client, W83793_REG_CONFIG);
1527     w83793_write_value(client, W83793_REG_CONFIG, tmp & ~0x04);
1528 
1529     unregister_reboot_notifier(&watchdog_notifier);
1530 
1531     hwmon_device_unregister(data->hwmon_dev);
1532 
1533     for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++)
1534         device_remove_file(dev,
1535                    &w83793_sensor_attr_2[i].dev_attr);
1536 
1537     for (i = 0; i < ARRAY_SIZE(sda_single_files); i++)
1538         device_remove_file(dev, &sda_single_files[i].dev_attr);
1539 
1540     for (i = 0; i < ARRAY_SIZE(w83793_vid); i++)
1541         device_remove_file(dev, &w83793_vid[i].dev_attr);
1542     device_remove_file(dev, &dev_attr_vrm);
1543 
1544     for (i = 0; i < ARRAY_SIZE(w83793_left_fan); i++)
1545         device_remove_file(dev, &w83793_left_fan[i].dev_attr);
1546 
1547     for (i = 0; i < ARRAY_SIZE(w83793_left_pwm); i++)
1548         device_remove_file(dev, &w83793_left_pwm[i].dev_attr);
1549 
1550     for (i = 0; i < ARRAY_SIZE(w83793_temp); i++)
1551         device_remove_file(dev, &w83793_temp[i].dev_attr);
1552 
1553     /* Decrease data reference counter */
1554     mutex_lock(&watchdog_data_mutex);
1555     kref_put(&data->kref, w83793_release_resources);
1556     mutex_unlock(&watchdog_data_mutex);
1557 
1558     return 0;
1559 }
1560 
1561 static int
1562 w83793_detect_subclients(struct i2c_client *client)
1563 {
1564     int i, id;
1565     int address = client->addr;
1566     u8 tmp;
1567     struct i2c_adapter *adapter = client->adapter;
1568 
1569     id = i2c_adapter_id(adapter);
1570     if (force_subclients[0] == id && force_subclients[1] == address) {
1571         for (i = 2; i <= 3; i++) {
1572             if (force_subclients[i] < 0x48
1573                 || force_subclients[i] > 0x4f) {
1574                 dev_err(&client->dev,
1575                     "invalid subclient "
1576                     "address %d; must be 0x48-0x4f\n",
1577                     force_subclients[i]);
1578                 return -EINVAL;
1579             }
1580         }
1581         w83793_write_value(client, W83793_REG_I2C_SUBADDR,
1582                    (force_subclients[2] & 0x07) |
1583                    ((force_subclients[3] & 0x07) << 4));
1584     }
1585 
1586     tmp = w83793_read_value(client, W83793_REG_I2C_SUBADDR);
1587 
1588     if (!(tmp & 0x88) && (tmp & 0x7) == ((tmp >> 4) & 0x7)) {
1589         dev_err(&client->dev,
1590             "duplicate addresses 0x%x, use force_subclient\n", 0x48 + (tmp & 0x7));
1591         return -ENODEV;
1592     }
1593 
1594     if (!(tmp & 0x08))
1595         devm_i2c_new_dummy_device(&client->dev, adapter, 0x48 + (tmp & 0x7));
1596 
1597     if (!(tmp & 0x80))
1598         devm_i2c_new_dummy_device(&client->dev, adapter, 0x48 + ((tmp >> 4) & 0x7));
1599 
1600     return 0;
1601 }
1602 
1603 /* Return 0 if detection is successful, -ENODEV otherwise */
1604 static int w83793_detect(struct i2c_client *client,
1605              struct i2c_board_info *info)
1606 {
1607     u8 tmp, bank, chip_id;
1608     struct i2c_adapter *adapter = client->adapter;
1609     unsigned short address = client->addr;
1610 
1611     if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1612         return -ENODEV;
1613 
1614     bank = i2c_smbus_read_byte_data(client, W83793_REG_BANKSEL);
1615 
1616     tmp = bank & 0x80 ? 0x5c : 0xa3;
1617     /* Check Winbond vendor ID */
1618     if (tmp != i2c_smbus_read_byte_data(client, W83793_REG_VENDORID)) {
1619         pr_debug("w83793: Detection failed at check vendor id\n");
1620         return -ENODEV;
1621     }
1622 
1623     /*
1624      * If Winbond chip, address of chip and W83793_REG_I2C_ADDR
1625      * should match
1626      */
1627     if ((bank & 0x07) == 0
1628      && i2c_smbus_read_byte_data(client, W83793_REG_I2C_ADDR) !=
1629         (address << 1)) {
1630         pr_debug("w83793: Detection failed at check i2c addr\n");
1631         return -ENODEV;
1632     }
1633 
1634     /* Determine the chip type now */
1635     chip_id = i2c_smbus_read_byte_data(client, W83793_REG_CHIPID);
1636     if (chip_id != 0x7b)
1637         return -ENODEV;
1638 
1639     strlcpy(info->type, "w83793", I2C_NAME_SIZE);
1640 
1641     return 0;
1642 }
1643 
1644 static int w83793_probe(struct i2c_client *client)
1645 {
1646     struct device *dev = &client->dev;
1647     static const int watchdog_minors[] = {
1648         WATCHDOG_MINOR, 212, 213, 214, 215
1649     };
1650     struct w83793_data *data;
1651     int i, tmp, val, err;
1652     int files_fan = ARRAY_SIZE(w83793_left_fan) / 7;
1653     int files_pwm = ARRAY_SIZE(w83793_left_pwm) / 5;
1654     int files_temp = ARRAY_SIZE(w83793_temp) / 6;
1655 
1656     data = kzalloc(sizeof(struct w83793_data), GFP_KERNEL);
1657     if (!data) {
1658         err = -ENOMEM;
1659         goto exit;
1660     }
1661 
1662     i2c_set_clientdata(client, data);
1663     data->bank = i2c_smbus_read_byte_data(client, W83793_REG_BANKSEL);
1664     mutex_init(&data->update_lock);
1665     mutex_init(&data->watchdog_lock);
1666     INIT_LIST_HEAD(&data->list);
1667     kref_init(&data->kref);
1668 
1669     /*
1670      * Store client pointer in our data struct for watchdog usage
1671      * (where the client is found through a data ptr instead of the
1672      * otherway around)
1673      */
1674     data->client = client;
1675 
1676     err = w83793_detect_subclients(client);
1677     if (err)
1678         goto free_mem;
1679 
1680     /* Initialize the chip */
1681     w83793_init_client(client);
1682 
1683     /*
1684      * Only fan 1-5 has their own input pins,
1685      * Pwm 1-3 has their own pins
1686      */
1687     data->has_fan = 0x1f;
1688     data->has_pwm = 0x07;
1689     tmp = w83793_read_value(client, W83793_REG_MFC);
1690     val = w83793_read_value(client, W83793_REG_FANIN_CTRL);
1691 
1692     /* check the function of pins 49-56 */
1693     if (tmp & 0x80) {
1694         data->has_vid |= 0x2;   /* has VIDB */
1695     } else {
1696         data->has_pwm |= 0x18;  /* pwm 4,5 */
1697         if (val & 0x01) {   /* fan 6 */
1698             data->has_fan |= 0x20;
1699             data->has_pwm |= 0x20;
1700         }
1701         if (val & 0x02) {   /* fan 7 */
1702             data->has_fan |= 0x40;
1703             data->has_pwm |= 0x40;
1704         }
1705         if (!(tmp & 0x40) && (val & 0x04)) {    /* fan 8 */
1706             data->has_fan |= 0x80;
1707             data->has_pwm |= 0x80;
1708         }
1709     }
1710 
1711     /* check the function of pins 37-40 */
1712     if (!(tmp & 0x29))
1713         data->has_vid |= 0x1;   /* has VIDA */
1714     if (0x08 == (tmp & 0x0c)) {
1715         if (val & 0x08) /* fan 9 */
1716             data->has_fan |= 0x100;
1717         if (val & 0x10) /* fan 10 */
1718             data->has_fan |= 0x200;
1719     }
1720     if (0x20 == (tmp & 0x30)) {
1721         if (val & 0x20) /* fan 11 */
1722             data->has_fan |= 0x400;
1723         if (val & 0x40) /* fan 12 */
1724             data->has_fan |= 0x800;
1725     }
1726 
1727     if ((tmp & 0x01) && (val & 0x04)) { /* fan 8, second location */
1728         data->has_fan |= 0x80;
1729         data->has_pwm |= 0x80;
1730     }
1731 
1732     tmp = w83793_read_value(client, W83793_REG_FANIN_SEL);
1733     if ((tmp & 0x01) && (val & 0x08)) { /* fan 9, second location */
1734         data->has_fan |= 0x100;
1735     }
1736     if ((tmp & 0x02) && (val & 0x10)) { /* fan 10, second location */
1737         data->has_fan |= 0x200;
1738     }
1739     if ((tmp & 0x04) && (val & 0x20)) { /* fan 11, second location */
1740         data->has_fan |= 0x400;
1741     }
1742     if ((tmp & 0x08) && (val & 0x40)) { /* fan 12, second location */
1743         data->has_fan |= 0x800;
1744     }
1745 
1746     /* check the temp1-6 mode, ignore former AMDSI selected inputs */
1747     tmp = w83793_read_value(client, W83793_REG_TEMP_MODE[0]);
1748     if (tmp & 0x01)
1749         data->has_temp |= 0x01;
1750     if (tmp & 0x04)
1751         data->has_temp |= 0x02;
1752     if (tmp & 0x10)
1753         data->has_temp |= 0x04;
1754     if (tmp & 0x40)
1755         data->has_temp |= 0x08;
1756 
1757     tmp = w83793_read_value(client, W83793_REG_TEMP_MODE[1]);
1758     if (tmp & 0x01)
1759         data->has_temp |= 0x10;
1760     if (tmp & 0x02)
1761         data->has_temp |= 0x20;
1762 
1763     /* Register sysfs hooks */
1764     for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++) {
1765         err = device_create_file(dev,
1766                      &w83793_sensor_attr_2[i].dev_attr);
1767         if (err)
1768             goto exit_remove;
1769     }
1770 
1771     for (i = 0; i < ARRAY_SIZE(w83793_vid); i++) {
1772         if (!(data->has_vid & (1 << i)))
1773             continue;
1774         err = device_create_file(dev, &w83793_vid[i].dev_attr);
1775         if (err)
1776             goto exit_remove;
1777     }
1778     if (data->has_vid) {
1779         data->vrm = vid_which_vrm();
1780         err = device_create_file(dev, &dev_attr_vrm);
1781         if (err)
1782             goto exit_remove;
1783     }
1784 
1785     for (i = 0; i < ARRAY_SIZE(sda_single_files); i++) {
1786         err = device_create_file(dev, &sda_single_files[i].dev_attr);
1787         if (err)
1788             goto exit_remove;
1789 
1790     }
1791 
1792     for (i = 0; i < 6; i++) {
1793         int j;
1794         if (!(data->has_temp & (1 << i)))
1795             continue;
1796         for (j = 0; j < files_temp; j++) {
1797             err = device_create_file(dev,
1798                         &w83793_temp[(i) * files_temp
1799                                 + j].dev_attr);
1800             if (err)
1801                 goto exit_remove;
1802         }
1803     }
1804 
1805     for (i = 5; i < 12; i++) {
1806         int j;
1807         if (!(data->has_fan & (1 << i)))
1808             continue;
1809         for (j = 0; j < files_fan; j++) {
1810             err = device_create_file(dev,
1811                        &w83793_left_fan[(i - 5) * files_fan
1812                                 + j].dev_attr);
1813             if (err)
1814                 goto exit_remove;
1815         }
1816     }
1817 
1818     for (i = 3; i < 8; i++) {
1819         int j;
1820         if (!(data->has_pwm & (1 << i)))
1821             continue;
1822         for (j = 0; j < files_pwm; j++) {
1823             err = device_create_file(dev,
1824                        &w83793_left_pwm[(i - 3) * files_pwm
1825                                 + j].dev_attr);
1826             if (err)
1827                 goto exit_remove;
1828         }
1829     }
1830 
1831     data->hwmon_dev = hwmon_device_register(dev);
1832     if (IS_ERR(data->hwmon_dev)) {
1833         err = PTR_ERR(data->hwmon_dev);
1834         goto exit_remove;
1835     }
1836 
1837     /* Watchdog initialization */
1838 
1839     /* Register boot notifier */
1840     err = register_reboot_notifier(&watchdog_notifier);
1841     if (err != 0) {
1842         dev_err(&client->dev,
1843             "cannot register reboot notifier (err=%d)\n", err);
1844         goto exit_devunreg;
1845     }
1846 
1847     /*
1848      * Enable Watchdog registers.
1849      * Set Configuration Register to Enable Watch Dog Registers
1850      * (Bit 2) = XXXX, X1XX.
1851      */
1852     tmp = w83793_read_value(client, W83793_REG_CONFIG);
1853     w83793_write_value(client, W83793_REG_CONFIG, tmp | 0x04);
1854 
1855     /* Set the default watchdog timeout */
1856     data->watchdog_timeout = timeout;
1857 
1858     /* Check, if last reboot was caused by watchdog */
1859     data->watchdog_caused_reboot =
1860       w83793_read_value(data->client, W83793_REG_WDT_STATUS) & 0x01;
1861 
1862     /* Disable Soft Watchdog during initialiation */
1863     watchdog_disable(data);
1864 
1865     /*
1866      * We take the data_mutex lock early so that watchdog_open() cannot
1867      * run when misc_register() has completed, but we've not yet added
1868      * our data to the watchdog_data_list (and set the default timeout)
1869      */
1870     mutex_lock(&watchdog_data_mutex);
1871     for (i = 0; i < ARRAY_SIZE(watchdog_minors); i++) {
1872         /* Register our watchdog part */
1873         snprintf(data->watchdog_name, sizeof(data->watchdog_name),
1874             "watchdog%c", (i == 0) ? '\0' : ('0' + i));
1875         data->watchdog_miscdev.name = data->watchdog_name;
1876         data->watchdog_miscdev.fops = &watchdog_fops;
1877         data->watchdog_miscdev.minor = watchdog_minors[i];
1878 
1879         err = misc_register(&data->watchdog_miscdev);
1880         if (err == -EBUSY)
1881             continue;
1882         if (err) {
1883             data->watchdog_miscdev.minor = 0;
1884             dev_err(&client->dev,
1885                 "Registering watchdog chardev: %d\n", err);
1886             break;
1887         }
1888 
1889         list_add(&data->list, &watchdog_data_list);
1890 
1891         dev_info(&client->dev,
1892             "Registered watchdog chardev major 10, minor: %d\n",
1893             watchdog_minors[i]);
1894         break;
1895     }
1896     if (i == ARRAY_SIZE(watchdog_minors)) {
1897         data->watchdog_miscdev.minor = 0;
1898         dev_warn(&client->dev,
1899              "Couldn't register watchdog chardev (due to no free minor)\n");
1900     }
1901 
1902     mutex_unlock(&watchdog_data_mutex);
1903 
1904     return 0;
1905 
1906     /* Unregister hwmon device */
1907 
1908 exit_devunreg:
1909 
1910     hwmon_device_unregister(data->hwmon_dev);
1911 
1912     /* Unregister sysfs hooks */
1913 
1914 exit_remove:
1915     for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++)
1916         device_remove_file(dev, &w83793_sensor_attr_2[i].dev_attr);
1917 
1918     for (i = 0; i < ARRAY_SIZE(sda_single_files); i++)
1919         device_remove_file(dev, &sda_single_files[i].dev_attr);
1920 
1921     for (i = 0; i < ARRAY_SIZE(w83793_vid); i++)
1922         device_remove_file(dev, &w83793_vid[i].dev_attr);
1923 
1924     for (i = 0; i < ARRAY_SIZE(w83793_left_fan); i++)
1925         device_remove_file(dev, &w83793_left_fan[i].dev_attr);
1926 
1927     for (i = 0; i < ARRAY_SIZE(w83793_left_pwm); i++)
1928         device_remove_file(dev, &w83793_left_pwm[i].dev_attr);
1929 
1930     for (i = 0; i < ARRAY_SIZE(w83793_temp); i++)
1931         device_remove_file(dev, &w83793_temp[i].dev_attr);
1932 free_mem:
1933     kfree(data);
1934 exit:
1935     return err;
1936 }
1937 
1938 static void w83793_update_nonvolatile(struct device *dev)
1939 {
1940     struct i2c_client *client = to_i2c_client(dev);
1941     struct w83793_data *data = i2c_get_clientdata(client);
1942     int i, j;
1943     /*
1944      * They are somewhat "stable" registers, and to update them every time
1945      * takes so much time, it's just not worthy. Update them in a long
1946      * interval to avoid exception.
1947      */
1948     if (!(time_after(jiffies, data->last_nonvolatile + HZ * 300)
1949           || !data->valid))
1950         return;
1951     /* update voltage limits */
1952     for (i = 1; i < 3; i++) {
1953         for (j = 0; j < ARRAY_SIZE(data->in); j++) {
1954             data->in[j][i] =
1955                 w83793_read_value(client, W83793_REG_IN[j][i]);
1956         }
1957         data->in_low_bits[i] =
1958             w83793_read_value(client, W83793_REG_IN_LOW_BITS[i]);
1959     }
1960 
1961     for (i = 0; i < ARRAY_SIZE(data->fan_min); i++) {
1962         /* Update the Fan measured value and limits */
1963         if (!(data->has_fan & (1 << i)))
1964             continue;
1965         data->fan_min[i] =
1966             w83793_read_value(client, W83793_REG_FAN_MIN(i)) << 8;
1967         data->fan_min[i] |=
1968             w83793_read_value(client, W83793_REG_FAN_MIN(i) + 1);
1969     }
1970 
1971     for (i = 0; i < ARRAY_SIZE(data->temp_fan_map); i++) {
1972         if (!(data->has_temp & (1 << i)))
1973             continue;
1974         data->temp_fan_map[i] =
1975             w83793_read_value(client, W83793_REG_TEMP_FAN_MAP(i));
1976         for (j = 1; j < 5; j++) {
1977             data->temp[i][j] =
1978                 w83793_read_value(client, W83793_REG_TEMP[i][j]);
1979         }
1980         data->temp_cruise[i] =
1981             w83793_read_value(client, W83793_REG_TEMP_CRUISE(i));
1982         for (j = 0; j < 7; j++) {
1983             data->sf2_pwm[i][j] =
1984                 w83793_read_value(client, W83793_REG_SF2_PWM(i, j));
1985             data->sf2_temp[i][j] =
1986                 w83793_read_value(client,
1987                           W83793_REG_SF2_TEMP(i, j));
1988         }
1989     }
1990 
1991     for (i = 0; i < ARRAY_SIZE(data->temp_mode); i++)
1992         data->temp_mode[i] =
1993             w83793_read_value(client, W83793_REG_TEMP_MODE[i]);
1994 
1995     for (i = 0; i < ARRAY_SIZE(data->tolerance); i++) {
1996         data->tolerance[i] =
1997             w83793_read_value(client, W83793_REG_TEMP_TOL(i));
1998     }
1999 
2000     for (i = 0; i < ARRAY_SIZE(data->pwm); i++) {
2001         if (!(data->has_pwm & (1 << i)))
2002             continue;
2003         data->pwm[i][PWM_NONSTOP] =
2004             w83793_read_value(client, W83793_REG_PWM(i, PWM_NONSTOP));
2005         data->pwm[i][PWM_START] =
2006             w83793_read_value(client, W83793_REG_PWM(i, PWM_START));
2007         data->pwm_stop_time[i] =
2008             w83793_read_value(client, W83793_REG_PWM_STOP_TIME(i));
2009     }
2010 
2011     data->pwm_default = w83793_read_value(client, W83793_REG_PWM_DEFAULT);
2012     data->pwm_enable = w83793_read_value(client, W83793_REG_PWM_ENABLE);
2013     data->pwm_uptime = w83793_read_value(client, W83793_REG_PWM_UPTIME);
2014     data->pwm_downtime = w83793_read_value(client, W83793_REG_PWM_DOWNTIME);
2015     data->temp_critical =
2016         w83793_read_value(client, W83793_REG_TEMP_CRITICAL);
2017     data->beep_enable = w83793_read_value(client, W83793_REG_OVT_BEEP);
2018 
2019     for (i = 0; i < ARRAY_SIZE(data->beeps); i++)
2020         data->beeps[i] = w83793_read_value(client, W83793_REG_BEEP(i));
2021 
2022     data->last_nonvolatile = jiffies;
2023 }
2024 
2025 static struct w83793_data *w83793_update_device(struct device *dev)
2026 {
2027     struct i2c_client *client = to_i2c_client(dev);
2028     struct w83793_data *data = i2c_get_clientdata(client);
2029     int i;
2030 
2031     mutex_lock(&data->update_lock);
2032 
2033     if (!(time_after(jiffies, data->last_updated + HZ * 2)
2034           || !data->valid))
2035         goto END;
2036 
2037     /* Update the voltages measured value and limits */
2038     for (i = 0; i < ARRAY_SIZE(data->in); i++)
2039         data->in[i][IN_READ] =
2040             w83793_read_value(client, W83793_REG_IN[i][IN_READ]);
2041 
2042     data->in_low_bits[IN_READ] =
2043         w83793_read_value(client, W83793_REG_IN_LOW_BITS[IN_READ]);
2044 
2045     for (i = 0; i < ARRAY_SIZE(data->fan); i++) {
2046         if (!(data->has_fan & (1 << i)))
2047             continue;
2048         data->fan[i] =
2049             w83793_read_value(client, W83793_REG_FAN(i)) << 8;
2050         data->fan[i] |=
2051             w83793_read_value(client, W83793_REG_FAN(i) + 1);
2052     }
2053 
2054     for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
2055         if (!(data->has_temp & (1 << i)))
2056             continue;
2057         data->temp[i][TEMP_READ] =
2058             w83793_read_value(client, W83793_REG_TEMP[i][TEMP_READ]);
2059     }
2060 
2061     data->temp_low_bits =
2062         w83793_read_value(client, W83793_REG_TEMP_LOW_BITS);
2063 
2064     for (i = 0; i < ARRAY_SIZE(data->pwm); i++) {
2065         if (data->has_pwm & (1 << i))
2066             data->pwm[i][PWM_DUTY] =
2067                 w83793_read_value(client,
2068                           W83793_REG_PWM(i, PWM_DUTY));
2069     }
2070 
2071     for (i = 0; i < ARRAY_SIZE(data->alarms); i++)
2072         data->alarms[i] =
2073             w83793_read_value(client, W83793_REG_ALARM(i));
2074     if (data->has_vid & 0x01)
2075         data->vid[0] = w83793_read_value(client, W83793_REG_VID_INA);
2076     if (data->has_vid & 0x02)
2077         data->vid[1] = w83793_read_value(client, W83793_REG_VID_INB);
2078     w83793_update_nonvolatile(dev);
2079     data->last_updated = jiffies;
2080     data->valid = true;
2081 
2082 END:
2083     mutex_unlock(&data->update_lock);
2084     return data;
2085 }
2086 
2087 /*
2088  * Ignore the possibility that somebody change bank outside the driver
2089  * Must be called with data->update_lock held, except during initialization
2090  */
2091 static u8 w83793_read_value(struct i2c_client *client, u16 reg)
2092 {
2093     struct w83793_data *data = i2c_get_clientdata(client);
2094     u8 res;
2095     u8 new_bank = reg >> 8;
2096 
2097     new_bank |= data->bank & 0xfc;
2098     if (data->bank != new_bank) {
2099         if (i2c_smbus_write_byte_data
2100             (client, W83793_REG_BANKSEL, new_bank) >= 0)
2101             data->bank = new_bank;
2102         else {
2103             dev_err(&client->dev,
2104                 "set bank to %d failed, fall back "
2105                 "to bank %d, read reg 0x%x error\n",
2106                 new_bank, data->bank, reg);
2107             res = 0x0;  /* read 0x0 from the chip */
2108             goto END;
2109         }
2110     }
2111     res = i2c_smbus_read_byte_data(client, reg & 0xff);
2112 END:
2113     return res;
2114 }
2115 
2116 /* Must be called with data->update_lock held, except during initialization */
2117 static int w83793_write_value(struct i2c_client *client, u16 reg, u8 value)
2118 {
2119     struct w83793_data *data = i2c_get_clientdata(client);
2120     int res;
2121     u8 new_bank = reg >> 8;
2122 
2123     new_bank |= data->bank & 0xfc;
2124     if (data->bank != new_bank) {
2125         res = i2c_smbus_write_byte_data(client, W83793_REG_BANKSEL,
2126                         new_bank);
2127         if (res < 0) {
2128             dev_err(&client->dev,
2129                 "set bank to %d failed, fall back "
2130                 "to bank %d, write reg 0x%x error\n",
2131                 new_bank, data->bank, reg);
2132             goto END;
2133         }
2134         data->bank = new_bank;
2135     }
2136 
2137     res = i2c_smbus_write_byte_data(client, reg & 0xff, value);
2138 END:
2139     return res;
2140 }
2141 
2142 module_i2c_driver(w83793_driver);
2143 
2144 MODULE_AUTHOR("Yuan Mu, Sven Anders");
2145 MODULE_DESCRIPTION("w83793 driver");
2146 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!