Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * w83792d.c - Part of lm_sensors, Linux kernel modules for hardware
0004  *         monitoring
0005  * Copyright (C) 2004, 2005 Winbond Electronics Corp.
0006  *              Shane Huang,
0007  *              Rudolf Marek <r.marek@assembler.cz>
0008  *
0009  * Note:
0010  * 1. This driver is only for 2.6 kernel, 2.4 kernel need a different driver.
0011  * 2. This driver is only for Winbond W83792D C version device, there
0012  *     are also some motherboards with B version W83792D device. The
0013  *     calculation method to in6-in7(measured value, limits) is a little
0014  *     different between C and B version. C or B version can be identified
0015  *     by CR[0x49h].
0016  */
0017 
0018 /*
0019  * Supports following chips:
0020  *
0021  * Chip     #vin    #fanin  #pwm    #temp   wchipid vendid  i2c ISA
0022  * w83792d  9   7   7   3   0x7a    0x5ca3  yes no
0023  */
0024 
0025 #include <linux/module.h>
0026 #include <linux/init.h>
0027 #include <linux/slab.h>
0028 #include <linux/i2c.h>
0029 #include <linux/hwmon.h>
0030 #include <linux/hwmon-sysfs.h>
0031 #include <linux/err.h>
0032 #include <linux/mutex.h>
0033 #include <linux/sysfs.h>
0034 #include <linux/jiffies.h>
0035 
0036 /* Addresses to scan */
0037 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f,
0038                         I2C_CLIENT_END };
0039 
0040 /* Insmod parameters */
0041 
0042 static unsigned short force_subclients[4];
0043 module_param_array(force_subclients, short, NULL, 0);
0044 MODULE_PARM_DESC(force_subclients,
0045          "List of subclient addresses: {bus, clientaddr, subclientaddr1, subclientaddr2}");
0046 
0047 static bool init;
0048 module_param(init, bool, 0);
0049 MODULE_PARM_DESC(init, "Set to one to force chip initialization");
0050 
0051 /* The W83792D registers */
0052 static const u8 W83792D_REG_IN[9] = {
0053     0x20,   /* Vcore A in DataSheet */
0054     0x21,   /* Vcore B in DataSheet */
0055     0x22,   /* VIN0 in DataSheet */
0056     0x23,   /* VIN1 in DataSheet */
0057     0x24,   /* VIN2 in DataSheet */
0058     0x25,   /* VIN3 in DataSheet */
0059     0x26,   /* 5VCC in DataSheet */
0060     0xB0,   /* 5VSB in DataSheet */
0061     0xB1    /* VBAT in DataSheet */
0062 };
0063 #define W83792D_REG_LOW_BITS1 0x3E  /* Low Bits I in DataSheet */
0064 #define W83792D_REG_LOW_BITS2 0x3F  /* Low Bits II in DataSheet */
0065 static const u8 W83792D_REG_IN_MAX[9] = {
0066     0x2B,   /* Vcore A High Limit in DataSheet */
0067     0x2D,   /* Vcore B High Limit in DataSheet */
0068     0x2F,   /* VIN0 High Limit in DataSheet */
0069     0x31,   /* VIN1 High Limit in DataSheet */
0070     0x33,   /* VIN2 High Limit in DataSheet */
0071     0x35,   /* VIN3 High Limit in DataSheet */
0072     0x37,   /* 5VCC High Limit in DataSheet */
0073     0xB4,   /* 5VSB High Limit in DataSheet */
0074     0xB6    /* VBAT High Limit in DataSheet */
0075 };
0076 static const u8 W83792D_REG_IN_MIN[9] = {
0077     0x2C,   /* Vcore A Low Limit in DataSheet */
0078     0x2E,   /* Vcore B Low Limit in DataSheet */
0079     0x30,   /* VIN0 Low Limit in DataSheet */
0080     0x32,   /* VIN1 Low Limit in DataSheet */
0081     0x34,   /* VIN2 Low Limit in DataSheet */
0082     0x36,   /* VIN3 Low Limit in DataSheet */
0083     0x38,   /* 5VCC Low Limit in DataSheet */
0084     0xB5,   /* 5VSB Low Limit in DataSheet */
0085     0xB7    /* VBAT Low Limit in DataSheet */
0086 };
0087 static const u8 W83792D_REG_FAN[7] = {
0088     0x28,   /* FAN 1 Count in DataSheet */
0089     0x29,   /* FAN 2 Count in DataSheet */
0090     0x2A,   /* FAN 3 Count in DataSheet */
0091     0xB8,   /* FAN 4 Count in DataSheet */
0092     0xB9,   /* FAN 5 Count in DataSheet */
0093     0xBA,   /* FAN 6 Count in DataSheet */
0094     0xBE    /* FAN 7 Count in DataSheet */
0095 };
0096 static const u8 W83792D_REG_FAN_MIN[7] = {
0097     0x3B,   /* FAN 1 Count Low Limit in DataSheet */
0098     0x3C,   /* FAN 2 Count Low Limit in DataSheet */
0099     0x3D,   /* FAN 3 Count Low Limit in DataSheet */
0100     0xBB,   /* FAN 4 Count Low Limit in DataSheet */
0101     0xBC,   /* FAN 5 Count Low Limit in DataSheet */
0102     0xBD,   /* FAN 6 Count Low Limit in DataSheet */
0103     0xBF    /* FAN 7 Count Low Limit in DataSheet */
0104 };
0105 #define W83792D_REG_FAN_CFG 0x84    /* FAN Configuration in DataSheet */
0106 static const u8 W83792D_REG_FAN_DIV[4] = {
0107     0x47,   /* contains FAN2 and FAN1 Divisor */
0108     0x5B,   /* contains FAN4 and FAN3 Divisor */
0109     0x5C,   /* contains FAN6 and FAN5 Divisor */
0110     0x9E    /* contains FAN7 Divisor. */
0111 };
0112 static const u8 W83792D_REG_PWM[7] = {
0113     0x81,   /* FAN 1 Duty Cycle, be used to control */
0114     0x83,   /* FAN 2 Duty Cycle, be used to control */
0115     0x94,   /* FAN 3 Duty Cycle, be used to control */
0116     0xA3,   /* FAN 4 Duty Cycle, be used to control */
0117     0xA4,   /* FAN 5 Duty Cycle, be used to control */
0118     0xA5,   /* FAN 6 Duty Cycle, be used to control */
0119     0xA6    /* FAN 7 Duty Cycle, be used to control */
0120 };
0121 #define W83792D_REG_BANK        0x4E
0122 #define W83792D_REG_TEMP2_CONFIG    0xC2
0123 #define W83792D_REG_TEMP3_CONFIG    0xCA
0124 
0125 static const u8 W83792D_REG_TEMP1[3] = {
0126     0x27,   /* TEMP 1 in DataSheet */
0127     0x39,   /* TEMP 1 Over in DataSheet */
0128     0x3A,   /* TEMP 1 Hyst in DataSheet */
0129 };
0130 
0131 static const u8 W83792D_REG_TEMP_ADD[2][6] = {
0132     { 0xC0,     /* TEMP 2 in DataSheet */
0133       0xC1,     /* TEMP 2(0.5 deg) in DataSheet */
0134       0xC5,     /* TEMP 2 Over High part in DataSheet */
0135       0xC6,     /* TEMP 2 Over Low part in DataSheet */
0136       0xC3,     /* TEMP 2 Thyst High part in DataSheet */
0137       0xC4 },   /* TEMP 2 Thyst Low part in DataSheet */
0138     { 0xC8,     /* TEMP 3 in DataSheet */
0139       0xC9,     /* TEMP 3(0.5 deg) in DataSheet */
0140       0xCD,     /* TEMP 3 Over High part in DataSheet */
0141       0xCE,     /* TEMP 3 Over Low part in DataSheet */
0142       0xCB,     /* TEMP 3 Thyst High part in DataSheet */
0143       0xCC }    /* TEMP 3 Thyst Low part in DataSheet */
0144 };
0145 
0146 static const u8 W83792D_REG_THERMAL[3] = {
0147     0x85,   /* SmartFanI: Fan1 target value */
0148     0x86,   /* SmartFanI: Fan2 target value */
0149     0x96    /* SmartFanI: Fan3 target value */
0150 };
0151 
0152 static const u8 W83792D_REG_TOLERANCE[3] = {
0153     0x87,   /* (bit3-0)SmartFan Fan1 tolerance */
0154     0x87,   /* (bit7-4)SmartFan Fan2 tolerance */
0155     0x97    /* (bit3-0)SmartFan Fan3 tolerance */
0156 };
0157 
0158 static const u8 W83792D_REG_POINTS[3][4] = {
0159     { 0x85,     /* SmartFanII: Fan1 temp point 1 */
0160       0xE3,     /* SmartFanII: Fan1 temp point 2 */
0161       0xE4,     /* SmartFanII: Fan1 temp point 3 */
0162       0xE5 },   /* SmartFanII: Fan1 temp point 4 */
0163     { 0x86,     /* SmartFanII: Fan2 temp point 1 */
0164       0xE6,     /* SmartFanII: Fan2 temp point 2 */
0165       0xE7,     /* SmartFanII: Fan2 temp point 3 */
0166       0xE8 },   /* SmartFanII: Fan2 temp point 4 */
0167     { 0x96,     /* SmartFanII: Fan3 temp point 1 */
0168       0xE9,     /* SmartFanII: Fan3 temp point 2 */
0169       0xEA,     /* SmartFanII: Fan3 temp point 3 */
0170       0xEB }    /* SmartFanII: Fan3 temp point 4 */
0171 };
0172 
0173 static const u8 W83792D_REG_LEVELS[3][4] = {
0174     { 0x88,     /* (bit3-0) SmartFanII: Fan1 Non-Stop */
0175       0x88,     /* (bit7-4) SmartFanII: Fan1 Level 1 */
0176       0xE0,     /* (bit7-4) SmartFanII: Fan1 Level 2 */
0177       0xE0 },   /* (bit3-0) SmartFanII: Fan1 Level 3 */
0178     { 0x89,     /* (bit3-0) SmartFanII: Fan2 Non-Stop */
0179       0x89,     /* (bit7-4) SmartFanII: Fan2 Level 1 */
0180       0xE1,     /* (bit7-4) SmartFanII: Fan2 Level 2 */
0181       0xE1 },   /* (bit3-0) SmartFanII: Fan2 Level 3 */
0182     { 0x98,     /* (bit3-0) SmartFanII: Fan3 Non-Stop */
0183       0x98,     /* (bit7-4) SmartFanII: Fan3 Level 1 */
0184       0xE2,     /* (bit7-4) SmartFanII: Fan3 Level 2 */
0185       0xE2 }    /* (bit3-0) SmartFanII: Fan3 Level 3 */
0186 };
0187 
0188 #define W83792D_REG_GPIO_EN     0x1A
0189 #define W83792D_REG_CONFIG      0x40
0190 #define W83792D_REG_VID_FANDIV      0x47
0191 #define W83792D_REG_CHIPID      0x49
0192 #define W83792D_REG_WCHIPID     0x58
0193 #define W83792D_REG_CHIPMAN     0x4F
0194 #define W83792D_REG_PIN         0x4B
0195 #define W83792D_REG_I2C_SUBADDR     0x4A
0196 
0197 #define W83792D_REG_ALARM1 0xA9     /* realtime status register1 */
0198 #define W83792D_REG_ALARM2 0xAA     /* realtime status register2 */
0199 #define W83792D_REG_ALARM3 0xAB     /* realtime status register3 */
0200 #define W83792D_REG_CHASSIS 0x42    /* Bit 5: Case Open status bit */
0201 #define W83792D_REG_CHASSIS_CLR 0x44    /* Bit 7: Case Open CLR_CHS/Reset bit */
0202 
0203 /* control in0/in1 's limit modifiability */
0204 #define W83792D_REG_VID_IN_B        0x17
0205 
0206 #define W83792D_REG_VBAT        0x5D
0207 #define W83792D_REG_I2C_ADDR        0x48
0208 
0209 /*
0210  * Conversions. Rounding and limit checking is only done on the TO_REG
0211  * variants. Note that you should be a bit careful with which arguments
0212  * these macros are called: arguments may be evaluated more than once.
0213  * Fixing this is just not worth it.
0214  */
0215 #define IN_FROM_REG(nr, val) (((nr) <= 1) ? ((val) * 2) : \
0216         ((((nr) == 6) || ((nr) == 7)) ? ((val) * 6) : ((val) * 4)))
0217 #define IN_TO_REG(nr, val) (((nr) <= 1) ? ((val) / 2) : \
0218         ((((nr) == 6) || ((nr) == 7)) ? ((val) / 6) : ((val) / 4)))
0219 
0220 static inline u8
0221 FAN_TO_REG(long rpm, int div)
0222 {
0223     if (rpm == 0)
0224         return 255;
0225     rpm = clamp_val(rpm, 1, 1000000);
0226     return clamp_val((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
0227 }
0228 
0229 #define FAN_FROM_REG(val, div)  ((val) == 0   ? -1 : \
0230                 ((val) == 255 ? 0 : \
0231                         1350000 / ((val) * (div))))
0232 
0233 /* for temp1 */
0234 #define TEMP1_TO_REG(val)   (clamp_val(((val) < 0 ? (val) + 0x100 * 1000 \
0235                               : (val)) / 1000, 0, 0xff))
0236 #define TEMP1_FROM_REG(val) (((val) & 0x80 ? (val)-0x100 : (val)) * 1000)
0237 /* for temp2 and temp3, because they need additional resolution */
0238 #define TEMP_ADD_FROM_REG(val1, val2) \
0239     ((((val1) & 0x80 ? (val1)-0x100 \
0240         : (val1)) * 1000) + ((val2 & 0x80) ? 500 : 0))
0241 #define TEMP_ADD_TO_REG_HIGH(val) \
0242     (clamp_val(((val) < 0 ? (val) + 0x100 * 1000 : (val)) / 1000, 0, 0xff))
0243 #define TEMP_ADD_TO_REG_LOW(val)    ((val%1000) ? 0x80 : 0x00)
0244 
0245 #define DIV_FROM_REG(val)       (1 << (val))
0246 
0247 static inline u8
0248 DIV_TO_REG(long val)
0249 {
0250     int i;
0251     val = clamp_val(val, 1, 128) >> 1;
0252     for (i = 0; i < 7; i++) {
0253         if (val == 0)
0254             break;
0255         val >>= 1;
0256     }
0257     return (u8)i;
0258 }
0259 
0260 struct w83792d_data {
0261     struct device *hwmon_dev;
0262 
0263     struct mutex update_lock;
0264     bool valid;     /* true if following fields are valid */
0265     unsigned long last_updated; /* In jiffies */
0266 
0267     u8 in[9];       /* Register value */
0268     u8 in_max[9];       /* Register value */
0269     u8 in_min[9];       /* Register value */
0270     u16 low_bits;       /* Additional resolution to voltage in6-0 */
0271     u8 fan[7];      /* Register value */
0272     u8 fan_min[7];      /* Register value */
0273     u8 temp1[3];        /* current, over, thyst */
0274     u8 temp_add[2][6];  /* Register value */
0275     u8 fan_div[7];      /* Register encoding, shifted right */
0276     u8 pwm[7];      /* The 7 PWM outputs */
0277     u8 pwmenable[3];
0278     u32 alarms;     /* realtime status register encoding,combined */
0279     u8 chassis;     /* Chassis status */
0280     u8 thermal_cruise[3];   /* Smart FanI: Fan1,2,3 target value */
0281     u8 tolerance[3];    /* Fan1,2,3 tolerance(Smart Fan I/II) */
0282     u8 sf2_points[3][4];    /* Smart FanII: Fan1,2,3 temperature points */
0283     u8 sf2_levels[3][4];    /* Smart FanII: Fan1,2,3 duty cycle levels */
0284 };
0285 
0286 static int w83792d_probe(struct i2c_client *client);
0287 static int w83792d_detect(struct i2c_client *client,
0288               struct i2c_board_info *info);
0289 static int w83792d_remove(struct i2c_client *client);
0290 static struct w83792d_data *w83792d_update_device(struct device *dev);
0291 
0292 #ifdef DEBUG
0293 static void w83792d_print_debug(struct w83792d_data *data, struct device *dev);
0294 #endif
0295 
0296 static void w83792d_init_client(struct i2c_client *client);
0297 
0298 static const struct i2c_device_id w83792d_id[] = {
0299     { "w83792d", 0 },
0300     { }
0301 };
0302 MODULE_DEVICE_TABLE(i2c, w83792d_id);
0303 
0304 static struct i2c_driver w83792d_driver = {
0305     .class      = I2C_CLASS_HWMON,
0306     .driver = {
0307         .name = "w83792d",
0308     },
0309     .probe_new  = w83792d_probe,
0310     .remove     = w83792d_remove,
0311     .id_table   = w83792d_id,
0312     .detect     = w83792d_detect,
0313     .address_list   = normal_i2c,
0314 };
0315 
0316 static inline long in_count_from_reg(int nr, struct w83792d_data *data)
0317 {
0318     /* in7 and in8 do not have low bits, but the formula still works */
0319     return (data->in[nr] << 2) | ((data->low_bits >> (2 * nr)) & 0x03);
0320 }
0321 
0322 /*
0323  * The SMBus locks itself. The Winbond W83792D chip has a bank register,
0324  * but the driver only accesses registers in bank 0, so we don't have
0325  * to switch banks and lock access between switches.
0326  */
0327 static inline int w83792d_read_value(struct i2c_client *client, u8 reg)
0328 {
0329     return i2c_smbus_read_byte_data(client, reg);
0330 }
0331 
0332 static inline int
0333 w83792d_write_value(struct i2c_client *client, u8 reg, u8 value)
0334 {
0335     return i2c_smbus_write_byte_data(client, reg, value);
0336 }
0337 
0338 /* following are the sysfs callback functions */
0339 static ssize_t show_in(struct device *dev, struct device_attribute *attr,
0340             char *buf)
0341 {
0342     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0343     int nr = sensor_attr->index;
0344     struct w83792d_data *data = w83792d_update_device(dev);
0345     return sprintf(buf, "%ld\n",
0346                IN_FROM_REG(nr, in_count_from_reg(nr, data)));
0347 }
0348 
0349 #define show_in_reg(reg) \
0350 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
0351             char *buf) \
0352 { \
0353     struct sensor_device_attribute *sensor_attr \
0354         = to_sensor_dev_attr(attr); \
0355     int nr = sensor_attr->index; \
0356     struct w83792d_data *data = w83792d_update_device(dev); \
0357     return sprintf(buf, "%ld\n", \
0358                (long)(IN_FROM_REG(nr, data->reg[nr]) * 4)); \
0359 }
0360 
0361 show_in_reg(in_min);
0362 show_in_reg(in_max);
0363 
0364 #define store_in_reg(REG, reg) \
0365 static ssize_t store_in_##reg(struct device *dev, \
0366                 struct device_attribute *attr, \
0367                 const char *buf, size_t count) \
0368 { \
0369     struct sensor_device_attribute *sensor_attr \
0370             = to_sensor_dev_attr(attr); \
0371     int nr = sensor_attr->index; \
0372     struct i2c_client *client = to_i2c_client(dev); \
0373     struct w83792d_data *data = i2c_get_clientdata(client); \
0374     unsigned long val; \
0375     int err = kstrtoul(buf, 10, &val); \
0376     if (err) \
0377         return err; \
0378     mutex_lock(&data->update_lock); \
0379     data->in_##reg[nr] = clamp_val(IN_TO_REG(nr, val) / 4, 0, 255); \
0380     w83792d_write_value(client, W83792D_REG_IN_##REG[nr], \
0381                 data->in_##reg[nr]); \
0382     mutex_unlock(&data->update_lock); \
0383      \
0384     return count; \
0385 }
0386 store_in_reg(MIN, min);
0387 store_in_reg(MAX, max);
0388 
0389 #define show_fan_reg(reg) \
0390 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
0391             char *buf) \
0392 { \
0393     struct sensor_device_attribute *sensor_attr \
0394             = to_sensor_dev_attr(attr); \
0395     int nr = sensor_attr->index - 1; \
0396     struct w83792d_data *data = w83792d_update_device(dev); \
0397     return sprintf(buf, "%d\n", \
0398         FAN_FROM_REG(data->reg[nr], DIV_FROM_REG(data->fan_div[nr]))); \
0399 }
0400 
0401 show_fan_reg(fan);
0402 show_fan_reg(fan_min);
0403 
0404 static ssize_t
0405 store_fan_min(struct device *dev, struct device_attribute *attr,
0406         const char *buf, size_t count)
0407 {
0408     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0409     int nr = sensor_attr->index - 1;
0410     struct i2c_client *client = to_i2c_client(dev);
0411     struct w83792d_data *data = i2c_get_clientdata(client);
0412     unsigned long val;
0413     int err;
0414 
0415     err = kstrtoul(buf, 10, &val);
0416     if (err)
0417         return err;
0418 
0419     mutex_lock(&data->update_lock);
0420     data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
0421     w83792d_write_value(client, W83792D_REG_FAN_MIN[nr],
0422                 data->fan_min[nr]);
0423     mutex_unlock(&data->update_lock);
0424 
0425     return count;
0426 }
0427 
0428 static ssize_t
0429 show_fan_div(struct device *dev, struct device_attribute *attr,
0430         char *buf)
0431 {
0432     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0433     int nr = sensor_attr->index;
0434     struct w83792d_data *data = w83792d_update_device(dev);
0435     return sprintf(buf, "%u\n", DIV_FROM_REG(data->fan_div[nr - 1]));
0436 }
0437 
0438 /*
0439  * Note: we save and restore the fan minimum here, because its value is
0440  * determined in part by the fan divisor.  This follows the principle of
0441  * least surprise; the user doesn't expect the fan minimum to change just
0442  * because the divisor changed.
0443  */
0444 static ssize_t
0445 store_fan_div(struct device *dev, struct device_attribute *attr,
0446         const char *buf, size_t count)
0447 {
0448     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0449     int nr = sensor_attr->index - 1;
0450     struct i2c_client *client = to_i2c_client(dev);
0451     struct w83792d_data *data = i2c_get_clientdata(client);
0452     unsigned long min;
0453     /*u8 reg;*/
0454     u8 fan_div_reg = 0;
0455     u8 tmp_fan_div;
0456     unsigned long val;
0457     int err;
0458 
0459     err = kstrtoul(buf, 10, &val);
0460     if (err)
0461         return err;
0462 
0463     /* Save fan_min */
0464     mutex_lock(&data->update_lock);
0465     min = FAN_FROM_REG(data->fan_min[nr],
0466                DIV_FROM_REG(data->fan_div[nr]));
0467 
0468     data->fan_div[nr] = DIV_TO_REG(val);
0469 
0470     fan_div_reg = w83792d_read_value(client, W83792D_REG_FAN_DIV[nr >> 1]);
0471     fan_div_reg &= (nr & 0x01) ? 0x8f : 0xf8;
0472     tmp_fan_div = (nr & 0x01) ? (((data->fan_div[nr]) << 4) & 0x70)
0473                     : ((data->fan_div[nr]) & 0x07);
0474     w83792d_write_value(client, W83792D_REG_FAN_DIV[nr >> 1],
0475                     fan_div_reg | tmp_fan_div);
0476 
0477     /* Restore fan_min */
0478     data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
0479     w83792d_write_value(client, W83792D_REG_FAN_MIN[nr], data->fan_min[nr]);
0480     mutex_unlock(&data->update_lock);
0481 
0482     return count;
0483 }
0484 
0485 /* read/write the temperature1, includes measured value and limits */
0486 
0487 static ssize_t show_temp1(struct device *dev, struct device_attribute *attr,
0488                 char *buf)
0489 {
0490     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0491     int nr = sensor_attr->index;
0492     struct w83792d_data *data = w83792d_update_device(dev);
0493     return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp1[nr]));
0494 }
0495 
0496 static ssize_t store_temp1(struct device *dev, struct device_attribute *attr,
0497                 const char *buf, size_t count)
0498 {
0499     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0500     int nr = sensor_attr->index;
0501     struct i2c_client *client = to_i2c_client(dev);
0502     struct w83792d_data *data = i2c_get_clientdata(client);
0503     long val;
0504     int err;
0505 
0506     err = kstrtol(buf, 10, &val);
0507     if (err)
0508         return err;
0509 
0510     mutex_lock(&data->update_lock);
0511     data->temp1[nr] = TEMP1_TO_REG(val);
0512     w83792d_write_value(client, W83792D_REG_TEMP1[nr],
0513         data->temp1[nr]);
0514     mutex_unlock(&data->update_lock);
0515 
0516     return count;
0517 }
0518 
0519 /* read/write the temperature2-3, includes measured value and limits */
0520 
0521 static ssize_t show_temp23(struct device *dev, struct device_attribute *attr,
0522                 char *buf)
0523 {
0524     struct sensor_device_attribute_2 *sensor_attr
0525       = to_sensor_dev_attr_2(attr);
0526     int nr = sensor_attr->nr;
0527     int index = sensor_attr->index;
0528     struct w83792d_data *data = w83792d_update_device(dev);
0529     return sprintf(buf, "%ld\n",
0530         (long)TEMP_ADD_FROM_REG(data->temp_add[nr][index],
0531             data->temp_add[nr][index+1]));
0532 }
0533 
0534 static ssize_t store_temp23(struct device *dev, struct device_attribute *attr,
0535                 const char *buf, size_t count)
0536 {
0537     struct sensor_device_attribute_2 *sensor_attr
0538       = to_sensor_dev_attr_2(attr);
0539     int nr = sensor_attr->nr;
0540     int index = sensor_attr->index;
0541     struct i2c_client *client = to_i2c_client(dev);
0542     struct w83792d_data *data = i2c_get_clientdata(client);
0543     long val;
0544     int err;
0545 
0546     err = kstrtol(buf, 10, &val);
0547     if (err)
0548         return err;
0549 
0550     mutex_lock(&data->update_lock);
0551     data->temp_add[nr][index] = TEMP_ADD_TO_REG_HIGH(val);
0552     data->temp_add[nr][index+1] = TEMP_ADD_TO_REG_LOW(val);
0553     w83792d_write_value(client, W83792D_REG_TEMP_ADD[nr][index],
0554         data->temp_add[nr][index]);
0555     w83792d_write_value(client, W83792D_REG_TEMP_ADD[nr][index+1],
0556         data->temp_add[nr][index+1]);
0557     mutex_unlock(&data->update_lock);
0558 
0559     return count;
0560 }
0561 
0562 /* get realtime status of all sensors items: voltage, temp, fan */
0563 static ssize_t
0564 alarms_show(struct device *dev, struct device_attribute *attr, char *buf)
0565 {
0566     struct w83792d_data *data = w83792d_update_device(dev);
0567     return sprintf(buf, "%d\n", data->alarms);
0568 }
0569 
0570 static ssize_t show_alarm(struct device *dev,
0571               struct device_attribute *attr, char *buf)
0572 {
0573     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0574     int nr = sensor_attr->index;
0575     struct w83792d_data *data = w83792d_update_device(dev);
0576     return sprintf(buf, "%d\n", (data->alarms >> nr) & 1);
0577 }
0578 
0579 static ssize_t
0580 show_pwm(struct device *dev, struct device_attribute *attr,
0581         char *buf)
0582 {
0583     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0584     int nr = sensor_attr->index;
0585     struct w83792d_data *data = w83792d_update_device(dev);
0586     return sprintf(buf, "%d\n", (data->pwm[nr] & 0x0f) << 4);
0587 }
0588 
0589 static ssize_t
0590 show_pwmenable(struct device *dev, struct device_attribute *attr,
0591             char *buf)
0592 {
0593     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0594     int nr = sensor_attr->index - 1;
0595     struct w83792d_data *data = w83792d_update_device(dev);
0596     long pwm_enable_tmp = 1;
0597 
0598     switch (data->pwmenable[nr]) {
0599     case 0:
0600         pwm_enable_tmp = 1; /* manual mode */
0601         break;
0602     case 1:
0603         pwm_enable_tmp = 3; /*thermal cruise/Smart Fan I */
0604         break;
0605     case 2:
0606         pwm_enable_tmp = 2; /* Smart Fan II */
0607         break;
0608     }
0609 
0610     return sprintf(buf, "%ld\n", pwm_enable_tmp);
0611 }
0612 
0613 static ssize_t
0614 store_pwm(struct device *dev, struct device_attribute *attr,
0615         const char *buf, size_t count)
0616 {
0617     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0618     int nr = sensor_attr->index;
0619     struct i2c_client *client = to_i2c_client(dev);
0620     struct w83792d_data *data = i2c_get_clientdata(client);
0621     unsigned long val;
0622     int err;
0623 
0624     err = kstrtoul(buf, 10, &val);
0625     if (err)
0626         return err;
0627     val = clamp_val(val, 0, 255) >> 4;
0628 
0629     mutex_lock(&data->update_lock);
0630     val |= w83792d_read_value(client, W83792D_REG_PWM[nr]) & 0xf0;
0631     data->pwm[nr] = val;
0632     w83792d_write_value(client, W83792D_REG_PWM[nr], data->pwm[nr]);
0633     mutex_unlock(&data->update_lock);
0634 
0635     return count;
0636 }
0637 
0638 static ssize_t
0639 store_pwmenable(struct device *dev, struct device_attribute *attr,
0640             const char *buf, size_t count)
0641 {
0642     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0643     int nr = sensor_attr->index - 1;
0644     struct i2c_client *client = to_i2c_client(dev);
0645     struct w83792d_data *data = i2c_get_clientdata(client);
0646     u8 fan_cfg_tmp, cfg1_tmp, cfg2_tmp, cfg3_tmp, cfg4_tmp;
0647     unsigned long val;
0648     int err;
0649 
0650     err = kstrtoul(buf, 10, &val);
0651     if (err)
0652         return err;
0653 
0654     if (val < 1 || val > 3)
0655         return -EINVAL;
0656 
0657     mutex_lock(&data->update_lock);
0658     switch (val) {
0659     case 1:
0660         data->pwmenable[nr] = 0; /* manual mode */
0661         break;
0662     case 2:
0663         data->pwmenable[nr] = 2; /* Smart Fan II */
0664         break;
0665     case 3:
0666         data->pwmenable[nr] = 1; /* thermal cruise/Smart Fan I */
0667         break;
0668     }
0669     cfg1_tmp = data->pwmenable[0];
0670     cfg2_tmp = (data->pwmenable[1]) << 2;
0671     cfg3_tmp = (data->pwmenable[2]) << 4;
0672     cfg4_tmp = w83792d_read_value(client, W83792D_REG_FAN_CFG) & 0xc0;
0673     fan_cfg_tmp = ((cfg4_tmp | cfg3_tmp) | cfg2_tmp) | cfg1_tmp;
0674     w83792d_write_value(client, W83792D_REG_FAN_CFG, fan_cfg_tmp);
0675     mutex_unlock(&data->update_lock);
0676 
0677     return count;
0678 }
0679 
0680 static ssize_t
0681 show_pwm_mode(struct device *dev, struct device_attribute *attr,
0682             char *buf)
0683 {
0684     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0685     int nr = sensor_attr->index;
0686     struct w83792d_data *data = w83792d_update_device(dev);
0687     return sprintf(buf, "%d\n", data->pwm[nr] >> 7);
0688 }
0689 
0690 static ssize_t
0691 store_pwm_mode(struct device *dev, struct device_attribute *attr,
0692             const char *buf, size_t count)
0693 {
0694     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0695     int nr = sensor_attr->index;
0696     struct i2c_client *client = to_i2c_client(dev);
0697     struct w83792d_data *data = i2c_get_clientdata(client);
0698     unsigned long val;
0699     int err;
0700 
0701     err = kstrtoul(buf, 10, &val);
0702     if (err)
0703         return err;
0704     if (val > 1)
0705         return -EINVAL;
0706 
0707     mutex_lock(&data->update_lock);
0708     data->pwm[nr] = w83792d_read_value(client, W83792D_REG_PWM[nr]);
0709     if (val) {          /* PWM mode */
0710         data->pwm[nr] |= 0x80;
0711     } else {            /* DC mode */
0712         data->pwm[nr] &= 0x7f;
0713     }
0714     w83792d_write_value(client, W83792D_REG_PWM[nr], data->pwm[nr]);
0715     mutex_unlock(&data->update_lock);
0716 
0717     return count;
0718 }
0719 
0720 static ssize_t
0721 intrusion0_alarm_show(struct device *dev, struct device_attribute *attr,
0722               char *buf)
0723 {
0724     struct w83792d_data *data = w83792d_update_device(dev);
0725     return sprintf(buf, "%d\n", data->chassis);
0726 }
0727 
0728 static ssize_t
0729 intrusion0_alarm_store(struct device *dev, struct device_attribute *attr,
0730                const char *buf, size_t count)
0731 {
0732     struct i2c_client *client = to_i2c_client(dev);
0733     struct w83792d_data *data = i2c_get_clientdata(client);
0734     unsigned long val;
0735     u8 reg;
0736 
0737     if (kstrtoul(buf, 10, &val) || val != 0)
0738         return -EINVAL;
0739 
0740     mutex_lock(&data->update_lock);
0741     reg = w83792d_read_value(client, W83792D_REG_CHASSIS_CLR);
0742     w83792d_write_value(client, W83792D_REG_CHASSIS_CLR, reg | 0x80);
0743     data->valid = false;        /* Force cache refresh */
0744     mutex_unlock(&data->update_lock);
0745 
0746     return count;
0747 }
0748 
0749 /* For Smart Fan I / Thermal Cruise */
0750 static ssize_t
0751 show_thermal_cruise(struct device *dev, struct device_attribute *attr,
0752             char *buf)
0753 {
0754     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0755     int nr = sensor_attr->index;
0756     struct w83792d_data *data = w83792d_update_device(dev);
0757     return sprintf(buf, "%ld\n", (long)data->thermal_cruise[nr-1]);
0758 }
0759 
0760 static ssize_t
0761 store_thermal_cruise(struct device *dev, struct device_attribute *attr,
0762             const char *buf, size_t count)
0763 {
0764     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0765     int nr = sensor_attr->index - 1;
0766     struct i2c_client *client = to_i2c_client(dev);
0767     struct w83792d_data *data = i2c_get_clientdata(client);
0768     u8 target_tmp = 0, target_mask = 0;
0769     unsigned long val;
0770     int err;
0771 
0772     err = kstrtoul(buf, 10, &val);
0773     if (err)
0774         return err;
0775 
0776     target_tmp = val;
0777     target_tmp = target_tmp & 0x7f;
0778     mutex_lock(&data->update_lock);
0779     target_mask = w83792d_read_value(client,
0780                      W83792D_REG_THERMAL[nr]) & 0x80;
0781     data->thermal_cruise[nr] = clamp_val(target_tmp, 0, 255);
0782     w83792d_write_value(client, W83792D_REG_THERMAL[nr],
0783         (data->thermal_cruise[nr]) | target_mask);
0784     mutex_unlock(&data->update_lock);
0785 
0786     return count;
0787 }
0788 
0789 /* For Smart Fan I/Thermal Cruise and Smart Fan II */
0790 static ssize_t
0791 show_tolerance(struct device *dev, struct device_attribute *attr,
0792         char *buf)
0793 {
0794     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0795     int nr = sensor_attr->index;
0796     struct w83792d_data *data = w83792d_update_device(dev);
0797     return sprintf(buf, "%ld\n", (long)data->tolerance[nr-1]);
0798 }
0799 
0800 static ssize_t
0801 store_tolerance(struct device *dev, struct device_attribute *attr,
0802         const char *buf, size_t count)
0803 {
0804     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0805     int nr = sensor_attr->index - 1;
0806     struct i2c_client *client = to_i2c_client(dev);
0807     struct w83792d_data *data = i2c_get_clientdata(client);
0808     u8 tol_tmp, tol_mask;
0809     unsigned long val;
0810     int err;
0811 
0812     err = kstrtoul(buf, 10, &val);
0813     if (err)
0814         return err;
0815 
0816     mutex_lock(&data->update_lock);
0817     tol_mask = w83792d_read_value(client,
0818         W83792D_REG_TOLERANCE[nr]) & ((nr == 1) ? 0x0f : 0xf0);
0819     tol_tmp = clamp_val(val, 0, 15);
0820     tol_tmp &= 0x0f;
0821     data->tolerance[nr] = tol_tmp;
0822     if (nr == 1)
0823         tol_tmp <<= 4;
0824     w83792d_write_value(client, W83792D_REG_TOLERANCE[nr],
0825         tol_mask | tol_tmp);
0826     mutex_unlock(&data->update_lock);
0827 
0828     return count;
0829 }
0830 
0831 /* For Smart Fan II */
0832 static ssize_t
0833 show_sf2_point(struct device *dev, struct device_attribute *attr,
0834         char *buf)
0835 {
0836     struct sensor_device_attribute_2 *sensor_attr
0837       = to_sensor_dev_attr_2(attr);
0838     int nr = sensor_attr->nr;
0839     int index = sensor_attr->index;
0840     struct w83792d_data *data = w83792d_update_device(dev);
0841     return sprintf(buf, "%ld\n", (long)data->sf2_points[index-1][nr-1]);
0842 }
0843 
0844 static ssize_t
0845 store_sf2_point(struct device *dev, struct device_attribute *attr,
0846         const char *buf, size_t count)
0847 {
0848     struct sensor_device_attribute_2 *sensor_attr
0849       = to_sensor_dev_attr_2(attr);
0850     int nr = sensor_attr->nr - 1;
0851     int index = sensor_attr->index - 1;
0852     struct i2c_client *client = to_i2c_client(dev);
0853     struct w83792d_data *data = i2c_get_clientdata(client);
0854     u8 mask_tmp = 0;
0855     unsigned long val;
0856     int err;
0857 
0858     err = kstrtoul(buf, 10, &val);
0859     if (err)
0860         return err;
0861 
0862     mutex_lock(&data->update_lock);
0863     data->sf2_points[index][nr] = clamp_val(val, 0, 127);
0864     mask_tmp = w83792d_read_value(client,
0865                     W83792D_REG_POINTS[index][nr]) & 0x80;
0866     w83792d_write_value(client, W83792D_REG_POINTS[index][nr],
0867         mask_tmp|data->sf2_points[index][nr]);
0868     mutex_unlock(&data->update_lock);
0869 
0870     return count;
0871 }
0872 
0873 static ssize_t
0874 show_sf2_level(struct device *dev, struct device_attribute *attr,
0875         char *buf)
0876 {
0877     struct sensor_device_attribute_2 *sensor_attr
0878       = to_sensor_dev_attr_2(attr);
0879     int nr = sensor_attr->nr;
0880     int index = sensor_attr->index;
0881     struct w83792d_data *data = w83792d_update_device(dev);
0882     return sprintf(buf, "%d\n",
0883             (((data->sf2_levels[index-1][nr]) * 100) / 15));
0884 }
0885 
0886 static ssize_t
0887 store_sf2_level(struct device *dev, struct device_attribute *attr,
0888         const char *buf, size_t count)
0889 {
0890     struct sensor_device_attribute_2 *sensor_attr
0891       = to_sensor_dev_attr_2(attr);
0892     int nr = sensor_attr->nr;
0893     int index = sensor_attr->index - 1;
0894     struct i2c_client *client = to_i2c_client(dev);
0895     struct w83792d_data *data = i2c_get_clientdata(client);
0896     u8 mask_tmp = 0, level_tmp = 0;
0897     unsigned long val;
0898     int err;
0899 
0900     err = kstrtoul(buf, 10, &val);
0901     if (err)
0902         return err;
0903 
0904     mutex_lock(&data->update_lock);
0905     data->sf2_levels[index][nr] = clamp_val((val * 15) / 100, 0, 15);
0906     mask_tmp = w83792d_read_value(client, W83792D_REG_LEVELS[index][nr])
0907         & ((nr == 3) ? 0xf0 : 0x0f);
0908     if (nr == 3)
0909         level_tmp = data->sf2_levels[index][nr];
0910     else
0911         level_tmp = data->sf2_levels[index][nr] << 4;
0912     w83792d_write_value(client, W83792D_REG_LEVELS[index][nr],
0913                 level_tmp | mask_tmp);
0914     mutex_unlock(&data->update_lock);
0915 
0916     return count;
0917 }
0918 
0919 
0920 static int
0921 w83792d_detect_subclients(struct i2c_client *new_client)
0922 {
0923     int i, id;
0924     int address = new_client->addr;
0925     u8 val;
0926     struct i2c_adapter *adapter = new_client->adapter;
0927 
0928     id = i2c_adapter_id(adapter);
0929     if (force_subclients[0] == id && force_subclients[1] == address) {
0930         for (i = 2; i <= 3; i++) {
0931             if (force_subclients[i] < 0x48 ||
0932                 force_subclients[i] > 0x4f) {
0933                 dev_err(&new_client->dev,
0934                     "invalid subclient address %d; must be 0x48-0x4f\n",
0935                     force_subclients[i]);
0936                 return -ENODEV;
0937             }
0938         }
0939         w83792d_write_value(new_client, W83792D_REG_I2C_SUBADDR,
0940                     (force_subclients[2] & 0x07) |
0941                     ((force_subclients[3] & 0x07) << 4));
0942     }
0943 
0944     val = w83792d_read_value(new_client, W83792D_REG_I2C_SUBADDR);
0945 
0946     if (!(val & 0x88) && (val & 0x7) == ((val >> 4) & 0x7)) {
0947         dev_err(&new_client->dev,
0948             "duplicate addresses 0x%x, use force_subclient\n", 0x48 + (val & 0x7));
0949         return -ENODEV;
0950     }
0951 
0952     if (!(val & 0x08))
0953         devm_i2c_new_dummy_device(&new_client->dev, adapter, 0x48 + (val & 0x7));
0954 
0955     if (!(val & 0x80))
0956         devm_i2c_new_dummy_device(&new_client->dev, adapter, 0x48 + ((val >> 4) & 0x7));
0957 
0958     return 0;
0959 }
0960 
0961 static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, show_in, NULL, 0);
0962 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in, NULL, 1);
0963 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in, NULL, 2);
0964 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in, NULL, 3);
0965 static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_in, NULL, 4);
0966 static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, show_in, NULL, 5);
0967 static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, show_in, NULL, 6);
0968 static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, show_in, NULL, 7);
0969 static SENSOR_DEVICE_ATTR(in8_input, S_IRUGO, show_in, NULL, 8);
0970 static SENSOR_DEVICE_ATTR(in0_min, S_IWUSR | S_IRUGO,
0971             show_in_min, store_in_min, 0);
0972 static SENSOR_DEVICE_ATTR(in1_min, S_IWUSR | S_IRUGO,
0973             show_in_min, store_in_min, 1);
0974 static SENSOR_DEVICE_ATTR(in2_min, S_IWUSR | S_IRUGO,
0975             show_in_min, store_in_min, 2);
0976 static SENSOR_DEVICE_ATTR(in3_min, S_IWUSR | S_IRUGO,
0977             show_in_min, store_in_min, 3);
0978 static SENSOR_DEVICE_ATTR(in4_min, S_IWUSR | S_IRUGO,
0979             show_in_min, store_in_min, 4);
0980 static SENSOR_DEVICE_ATTR(in5_min, S_IWUSR | S_IRUGO,
0981             show_in_min, store_in_min, 5);
0982 static SENSOR_DEVICE_ATTR(in6_min, S_IWUSR | S_IRUGO,
0983             show_in_min, store_in_min, 6);
0984 static SENSOR_DEVICE_ATTR(in7_min, S_IWUSR | S_IRUGO,
0985             show_in_min, store_in_min, 7);
0986 static SENSOR_DEVICE_ATTR(in8_min, S_IWUSR | S_IRUGO,
0987             show_in_min, store_in_min, 8);
0988 static SENSOR_DEVICE_ATTR(in0_max, S_IWUSR | S_IRUGO,
0989             show_in_max, store_in_max, 0);
0990 static SENSOR_DEVICE_ATTR(in1_max, S_IWUSR | S_IRUGO,
0991             show_in_max, store_in_max, 1);
0992 static SENSOR_DEVICE_ATTR(in2_max, S_IWUSR | S_IRUGO,
0993             show_in_max, store_in_max, 2);
0994 static SENSOR_DEVICE_ATTR(in3_max, S_IWUSR | S_IRUGO,
0995             show_in_max, store_in_max, 3);
0996 static SENSOR_DEVICE_ATTR(in4_max, S_IWUSR | S_IRUGO,
0997             show_in_max, store_in_max, 4);
0998 static SENSOR_DEVICE_ATTR(in5_max, S_IWUSR | S_IRUGO,
0999             show_in_max, store_in_max, 5);
1000 static SENSOR_DEVICE_ATTR(in6_max, S_IWUSR | S_IRUGO,
1001             show_in_max, store_in_max, 6);
1002 static SENSOR_DEVICE_ATTR(in7_max, S_IWUSR | S_IRUGO,
1003             show_in_max, store_in_max, 7);
1004 static SENSOR_DEVICE_ATTR(in8_max, S_IWUSR | S_IRUGO,
1005             show_in_max, store_in_max, 8);
1006 static SENSOR_DEVICE_ATTR_2(temp1_input, S_IRUGO, show_temp1, NULL, 0, 0);
1007 static SENSOR_DEVICE_ATTR_2(temp2_input, S_IRUGO, show_temp23, NULL, 0, 0);
1008 static SENSOR_DEVICE_ATTR_2(temp3_input, S_IRUGO, show_temp23, NULL, 1, 0);
1009 static SENSOR_DEVICE_ATTR_2(temp1_max, S_IRUGO | S_IWUSR,
1010             show_temp1, store_temp1, 0, 1);
1011 static SENSOR_DEVICE_ATTR_2(temp2_max, S_IRUGO | S_IWUSR, show_temp23,
1012             store_temp23, 0, 2);
1013 static SENSOR_DEVICE_ATTR_2(temp3_max, S_IRUGO | S_IWUSR, show_temp23,
1014             store_temp23, 1, 2);
1015 static SENSOR_DEVICE_ATTR_2(temp1_max_hyst, S_IRUGO | S_IWUSR,
1016             show_temp1, store_temp1, 0, 2);
1017 static SENSOR_DEVICE_ATTR_2(temp2_max_hyst, S_IRUGO | S_IWUSR,
1018             show_temp23, store_temp23, 0, 4);
1019 static SENSOR_DEVICE_ATTR_2(temp3_max_hyst, S_IRUGO | S_IWUSR,
1020             show_temp23, store_temp23, 1, 4);
1021 static DEVICE_ATTR_RO(alarms);
1022 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
1023 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
1024 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 2);
1025 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 3);
1026 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 4);
1027 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 5);
1028 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 6);
1029 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 7);
1030 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 8);
1031 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 9);
1032 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 10);
1033 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 11);
1034 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 12);
1035 static SENSOR_DEVICE_ATTR(fan7_alarm, S_IRUGO, show_alarm, NULL, 15);
1036 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 19);
1037 static SENSOR_DEVICE_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 20);
1038 static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 21);
1039 static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 22);
1040 static SENSOR_DEVICE_ATTR(fan6_alarm, S_IRUGO, show_alarm, NULL, 23);
1041 static DEVICE_ATTR_RW(intrusion0_alarm);
1042 static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 0);
1043 static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 1);
1044 static SENSOR_DEVICE_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 2);
1045 static SENSOR_DEVICE_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 3);
1046 static SENSOR_DEVICE_ATTR(pwm5, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 4);
1047 static SENSOR_DEVICE_ATTR(pwm6, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 5);
1048 static SENSOR_DEVICE_ATTR(pwm7, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 6);
1049 static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO,
1050             show_pwmenable, store_pwmenable, 1);
1051 static SENSOR_DEVICE_ATTR(pwm2_enable, S_IWUSR | S_IRUGO,
1052             show_pwmenable, store_pwmenable, 2);
1053 static SENSOR_DEVICE_ATTR(pwm3_enable, S_IWUSR | S_IRUGO,
1054             show_pwmenable, store_pwmenable, 3);
1055 static SENSOR_DEVICE_ATTR(pwm1_mode, S_IWUSR | S_IRUGO,
1056             show_pwm_mode, store_pwm_mode, 0);
1057 static SENSOR_DEVICE_ATTR(pwm2_mode, S_IWUSR | S_IRUGO,
1058             show_pwm_mode, store_pwm_mode, 1);
1059 static SENSOR_DEVICE_ATTR(pwm3_mode, S_IWUSR | S_IRUGO,
1060             show_pwm_mode, store_pwm_mode, 2);
1061 static SENSOR_DEVICE_ATTR(pwm4_mode, S_IWUSR | S_IRUGO,
1062             show_pwm_mode, store_pwm_mode, 3);
1063 static SENSOR_DEVICE_ATTR(pwm5_mode, S_IWUSR | S_IRUGO,
1064             show_pwm_mode, store_pwm_mode, 4);
1065 static SENSOR_DEVICE_ATTR(pwm6_mode, S_IWUSR | S_IRUGO,
1066             show_pwm_mode, store_pwm_mode, 5);
1067 static SENSOR_DEVICE_ATTR(pwm7_mode, S_IWUSR | S_IRUGO,
1068             show_pwm_mode, store_pwm_mode, 6);
1069 static SENSOR_DEVICE_ATTR(tolerance1, S_IWUSR | S_IRUGO,
1070             show_tolerance, store_tolerance, 1);
1071 static SENSOR_DEVICE_ATTR(tolerance2, S_IWUSR | S_IRUGO,
1072             show_tolerance, store_tolerance, 2);
1073 static SENSOR_DEVICE_ATTR(tolerance3, S_IWUSR | S_IRUGO,
1074             show_tolerance, store_tolerance, 3);
1075 static SENSOR_DEVICE_ATTR(thermal_cruise1, S_IWUSR | S_IRUGO,
1076             show_thermal_cruise, store_thermal_cruise, 1);
1077 static SENSOR_DEVICE_ATTR(thermal_cruise2, S_IWUSR | S_IRUGO,
1078             show_thermal_cruise, store_thermal_cruise, 2);
1079 static SENSOR_DEVICE_ATTR(thermal_cruise3, S_IWUSR | S_IRUGO,
1080             show_thermal_cruise, store_thermal_cruise, 3);
1081 static SENSOR_DEVICE_ATTR_2(sf2_point1_fan1, S_IRUGO | S_IWUSR,
1082             show_sf2_point, store_sf2_point, 1, 1);
1083 static SENSOR_DEVICE_ATTR_2(sf2_point2_fan1, S_IRUGO | S_IWUSR,
1084             show_sf2_point, store_sf2_point, 2, 1);
1085 static SENSOR_DEVICE_ATTR_2(sf2_point3_fan1, S_IRUGO | S_IWUSR,
1086             show_sf2_point, store_sf2_point, 3, 1);
1087 static SENSOR_DEVICE_ATTR_2(sf2_point4_fan1, S_IRUGO | S_IWUSR,
1088             show_sf2_point, store_sf2_point, 4, 1);
1089 static SENSOR_DEVICE_ATTR_2(sf2_point1_fan2, S_IRUGO | S_IWUSR,
1090             show_sf2_point, store_sf2_point, 1, 2);
1091 static SENSOR_DEVICE_ATTR_2(sf2_point2_fan2, S_IRUGO | S_IWUSR,
1092             show_sf2_point, store_sf2_point, 2, 2);
1093 static SENSOR_DEVICE_ATTR_2(sf2_point3_fan2, S_IRUGO | S_IWUSR,
1094             show_sf2_point, store_sf2_point, 3, 2);
1095 static SENSOR_DEVICE_ATTR_2(sf2_point4_fan2, S_IRUGO | S_IWUSR,
1096             show_sf2_point, store_sf2_point, 4, 2);
1097 static SENSOR_DEVICE_ATTR_2(sf2_point1_fan3, S_IRUGO | S_IWUSR,
1098             show_sf2_point, store_sf2_point, 1, 3);
1099 static SENSOR_DEVICE_ATTR_2(sf2_point2_fan3, S_IRUGO | S_IWUSR,
1100             show_sf2_point, store_sf2_point, 2, 3);
1101 static SENSOR_DEVICE_ATTR_2(sf2_point3_fan3, S_IRUGO | S_IWUSR,
1102             show_sf2_point, store_sf2_point, 3, 3);
1103 static SENSOR_DEVICE_ATTR_2(sf2_point4_fan3, S_IRUGO | S_IWUSR,
1104             show_sf2_point, store_sf2_point, 4, 3);
1105 static SENSOR_DEVICE_ATTR_2(sf2_level1_fan1, S_IRUGO | S_IWUSR,
1106             show_sf2_level, store_sf2_level, 1, 1);
1107 static SENSOR_DEVICE_ATTR_2(sf2_level2_fan1, S_IRUGO | S_IWUSR,
1108             show_sf2_level, store_sf2_level, 2, 1);
1109 static SENSOR_DEVICE_ATTR_2(sf2_level3_fan1, S_IRUGO | S_IWUSR,
1110             show_sf2_level, store_sf2_level, 3, 1);
1111 static SENSOR_DEVICE_ATTR_2(sf2_level1_fan2, S_IRUGO | S_IWUSR,
1112             show_sf2_level, store_sf2_level, 1, 2);
1113 static SENSOR_DEVICE_ATTR_2(sf2_level2_fan2, S_IRUGO | S_IWUSR,
1114             show_sf2_level, store_sf2_level, 2, 2);
1115 static SENSOR_DEVICE_ATTR_2(sf2_level3_fan2, S_IRUGO | S_IWUSR,
1116             show_sf2_level, store_sf2_level, 3, 2);
1117 static SENSOR_DEVICE_ATTR_2(sf2_level1_fan3, S_IRUGO | S_IWUSR,
1118             show_sf2_level, store_sf2_level, 1, 3);
1119 static SENSOR_DEVICE_ATTR_2(sf2_level2_fan3, S_IRUGO | S_IWUSR,
1120             show_sf2_level, store_sf2_level, 2, 3);
1121 static SENSOR_DEVICE_ATTR_2(sf2_level3_fan3, S_IRUGO | S_IWUSR,
1122             show_sf2_level, store_sf2_level, 3, 3);
1123 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 1);
1124 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 2);
1125 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 3);
1126 static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 4);
1127 static SENSOR_DEVICE_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 5);
1128 static SENSOR_DEVICE_ATTR(fan6_input, S_IRUGO, show_fan, NULL, 6);
1129 static SENSOR_DEVICE_ATTR(fan7_input, S_IRUGO, show_fan, NULL, 7);
1130 static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO,
1131             show_fan_min, store_fan_min, 1);
1132 static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO,
1133             show_fan_min, store_fan_min, 2);
1134 static SENSOR_DEVICE_ATTR(fan3_min, S_IWUSR | S_IRUGO,
1135             show_fan_min, store_fan_min, 3);
1136 static SENSOR_DEVICE_ATTR(fan4_min, S_IWUSR | S_IRUGO,
1137             show_fan_min, store_fan_min, 4);
1138 static SENSOR_DEVICE_ATTR(fan5_min, S_IWUSR | S_IRUGO,
1139             show_fan_min, store_fan_min, 5);
1140 static SENSOR_DEVICE_ATTR(fan6_min, S_IWUSR | S_IRUGO,
1141             show_fan_min, store_fan_min, 6);
1142 static SENSOR_DEVICE_ATTR(fan7_min, S_IWUSR | S_IRUGO,
1143             show_fan_min, store_fan_min, 7);
1144 static SENSOR_DEVICE_ATTR(fan1_div, S_IWUSR | S_IRUGO,
1145             show_fan_div, store_fan_div, 1);
1146 static SENSOR_DEVICE_ATTR(fan2_div, S_IWUSR | S_IRUGO,
1147             show_fan_div, store_fan_div, 2);
1148 static SENSOR_DEVICE_ATTR(fan3_div, S_IWUSR | S_IRUGO,
1149             show_fan_div, store_fan_div, 3);
1150 static SENSOR_DEVICE_ATTR(fan4_div, S_IWUSR | S_IRUGO,
1151             show_fan_div, store_fan_div, 4);
1152 static SENSOR_DEVICE_ATTR(fan5_div, S_IWUSR | S_IRUGO,
1153             show_fan_div, store_fan_div, 5);
1154 static SENSOR_DEVICE_ATTR(fan6_div, S_IWUSR | S_IRUGO,
1155             show_fan_div, store_fan_div, 6);
1156 static SENSOR_DEVICE_ATTR(fan7_div, S_IWUSR | S_IRUGO,
1157             show_fan_div, store_fan_div, 7);
1158 
1159 static struct attribute *w83792d_attributes_fan[4][7] = {
1160     {
1161         &sensor_dev_attr_fan4_input.dev_attr.attr,
1162         &sensor_dev_attr_fan4_min.dev_attr.attr,
1163         &sensor_dev_attr_fan4_div.dev_attr.attr,
1164         &sensor_dev_attr_fan4_alarm.dev_attr.attr,
1165         &sensor_dev_attr_pwm4.dev_attr.attr,
1166         &sensor_dev_attr_pwm4_mode.dev_attr.attr,
1167         NULL
1168     }, {
1169         &sensor_dev_attr_fan5_input.dev_attr.attr,
1170         &sensor_dev_attr_fan5_min.dev_attr.attr,
1171         &sensor_dev_attr_fan5_div.dev_attr.attr,
1172         &sensor_dev_attr_fan5_alarm.dev_attr.attr,
1173         &sensor_dev_attr_pwm5.dev_attr.attr,
1174         &sensor_dev_attr_pwm5_mode.dev_attr.attr,
1175         NULL
1176     }, {
1177         &sensor_dev_attr_fan6_input.dev_attr.attr,
1178         &sensor_dev_attr_fan6_min.dev_attr.attr,
1179         &sensor_dev_attr_fan6_div.dev_attr.attr,
1180         &sensor_dev_attr_fan6_alarm.dev_attr.attr,
1181         &sensor_dev_attr_pwm6.dev_attr.attr,
1182         &sensor_dev_attr_pwm6_mode.dev_attr.attr,
1183         NULL
1184     }, {
1185         &sensor_dev_attr_fan7_input.dev_attr.attr,
1186         &sensor_dev_attr_fan7_min.dev_attr.attr,
1187         &sensor_dev_attr_fan7_div.dev_attr.attr,
1188         &sensor_dev_attr_fan7_alarm.dev_attr.attr,
1189         &sensor_dev_attr_pwm7.dev_attr.attr,
1190         &sensor_dev_attr_pwm7_mode.dev_attr.attr,
1191         NULL
1192     }
1193 };
1194 
1195 static const struct attribute_group w83792d_group_fan[4] = {
1196     { .attrs = w83792d_attributes_fan[0] },
1197     { .attrs = w83792d_attributes_fan[1] },
1198     { .attrs = w83792d_attributes_fan[2] },
1199     { .attrs = w83792d_attributes_fan[3] },
1200 };
1201 
1202 static struct attribute *w83792d_attributes[] = {
1203     &sensor_dev_attr_in0_input.dev_attr.attr,
1204     &sensor_dev_attr_in0_max.dev_attr.attr,
1205     &sensor_dev_attr_in0_min.dev_attr.attr,
1206     &sensor_dev_attr_in1_input.dev_attr.attr,
1207     &sensor_dev_attr_in1_max.dev_attr.attr,
1208     &sensor_dev_attr_in1_min.dev_attr.attr,
1209     &sensor_dev_attr_in2_input.dev_attr.attr,
1210     &sensor_dev_attr_in2_max.dev_attr.attr,
1211     &sensor_dev_attr_in2_min.dev_attr.attr,
1212     &sensor_dev_attr_in3_input.dev_attr.attr,
1213     &sensor_dev_attr_in3_max.dev_attr.attr,
1214     &sensor_dev_attr_in3_min.dev_attr.attr,
1215     &sensor_dev_attr_in4_input.dev_attr.attr,
1216     &sensor_dev_attr_in4_max.dev_attr.attr,
1217     &sensor_dev_attr_in4_min.dev_attr.attr,
1218     &sensor_dev_attr_in5_input.dev_attr.attr,
1219     &sensor_dev_attr_in5_max.dev_attr.attr,
1220     &sensor_dev_attr_in5_min.dev_attr.attr,
1221     &sensor_dev_attr_in6_input.dev_attr.attr,
1222     &sensor_dev_attr_in6_max.dev_attr.attr,
1223     &sensor_dev_attr_in6_min.dev_attr.attr,
1224     &sensor_dev_attr_in7_input.dev_attr.attr,
1225     &sensor_dev_attr_in7_max.dev_attr.attr,
1226     &sensor_dev_attr_in7_min.dev_attr.attr,
1227     &sensor_dev_attr_in8_input.dev_attr.attr,
1228     &sensor_dev_attr_in8_max.dev_attr.attr,
1229     &sensor_dev_attr_in8_min.dev_attr.attr,
1230     &sensor_dev_attr_in0_alarm.dev_attr.attr,
1231     &sensor_dev_attr_in1_alarm.dev_attr.attr,
1232     &sensor_dev_attr_in2_alarm.dev_attr.attr,
1233     &sensor_dev_attr_in3_alarm.dev_attr.attr,
1234     &sensor_dev_attr_in4_alarm.dev_attr.attr,
1235     &sensor_dev_attr_in5_alarm.dev_attr.attr,
1236     &sensor_dev_attr_in6_alarm.dev_attr.attr,
1237     &sensor_dev_attr_in7_alarm.dev_attr.attr,
1238     &sensor_dev_attr_in8_alarm.dev_attr.attr,
1239     &sensor_dev_attr_temp1_input.dev_attr.attr,
1240     &sensor_dev_attr_temp1_max.dev_attr.attr,
1241     &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
1242     &sensor_dev_attr_temp2_input.dev_attr.attr,
1243     &sensor_dev_attr_temp2_max.dev_attr.attr,
1244     &sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
1245     &sensor_dev_attr_temp3_input.dev_attr.attr,
1246     &sensor_dev_attr_temp3_max.dev_attr.attr,
1247     &sensor_dev_attr_temp3_max_hyst.dev_attr.attr,
1248     &sensor_dev_attr_temp1_alarm.dev_attr.attr,
1249     &sensor_dev_attr_temp2_alarm.dev_attr.attr,
1250     &sensor_dev_attr_temp3_alarm.dev_attr.attr,
1251     &sensor_dev_attr_pwm1.dev_attr.attr,
1252     &sensor_dev_attr_pwm1_mode.dev_attr.attr,
1253     &sensor_dev_attr_pwm1_enable.dev_attr.attr,
1254     &sensor_dev_attr_pwm2.dev_attr.attr,
1255     &sensor_dev_attr_pwm2_mode.dev_attr.attr,
1256     &sensor_dev_attr_pwm2_enable.dev_attr.attr,
1257     &sensor_dev_attr_pwm3.dev_attr.attr,
1258     &sensor_dev_attr_pwm3_mode.dev_attr.attr,
1259     &sensor_dev_attr_pwm3_enable.dev_attr.attr,
1260     &dev_attr_alarms.attr,
1261     &dev_attr_intrusion0_alarm.attr,
1262     &sensor_dev_attr_tolerance1.dev_attr.attr,
1263     &sensor_dev_attr_thermal_cruise1.dev_attr.attr,
1264     &sensor_dev_attr_tolerance2.dev_attr.attr,
1265     &sensor_dev_attr_thermal_cruise2.dev_attr.attr,
1266     &sensor_dev_attr_tolerance3.dev_attr.attr,
1267     &sensor_dev_attr_thermal_cruise3.dev_attr.attr,
1268     &sensor_dev_attr_sf2_point1_fan1.dev_attr.attr,
1269     &sensor_dev_attr_sf2_point2_fan1.dev_attr.attr,
1270     &sensor_dev_attr_sf2_point3_fan1.dev_attr.attr,
1271     &sensor_dev_attr_sf2_point4_fan1.dev_attr.attr,
1272     &sensor_dev_attr_sf2_point1_fan2.dev_attr.attr,
1273     &sensor_dev_attr_sf2_point2_fan2.dev_attr.attr,
1274     &sensor_dev_attr_sf2_point3_fan2.dev_attr.attr,
1275     &sensor_dev_attr_sf2_point4_fan2.dev_attr.attr,
1276     &sensor_dev_attr_sf2_point1_fan3.dev_attr.attr,
1277     &sensor_dev_attr_sf2_point2_fan3.dev_attr.attr,
1278     &sensor_dev_attr_sf2_point3_fan3.dev_attr.attr,
1279     &sensor_dev_attr_sf2_point4_fan3.dev_attr.attr,
1280     &sensor_dev_attr_sf2_level1_fan1.dev_attr.attr,
1281     &sensor_dev_attr_sf2_level2_fan1.dev_attr.attr,
1282     &sensor_dev_attr_sf2_level3_fan1.dev_attr.attr,
1283     &sensor_dev_attr_sf2_level1_fan2.dev_attr.attr,
1284     &sensor_dev_attr_sf2_level2_fan2.dev_attr.attr,
1285     &sensor_dev_attr_sf2_level3_fan2.dev_attr.attr,
1286     &sensor_dev_attr_sf2_level1_fan3.dev_attr.attr,
1287     &sensor_dev_attr_sf2_level2_fan3.dev_attr.attr,
1288     &sensor_dev_attr_sf2_level3_fan3.dev_attr.attr,
1289     &sensor_dev_attr_fan1_input.dev_attr.attr,
1290     &sensor_dev_attr_fan1_min.dev_attr.attr,
1291     &sensor_dev_attr_fan1_div.dev_attr.attr,
1292     &sensor_dev_attr_fan1_alarm.dev_attr.attr,
1293     &sensor_dev_attr_fan2_input.dev_attr.attr,
1294     &sensor_dev_attr_fan2_min.dev_attr.attr,
1295     &sensor_dev_attr_fan2_div.dev_attr.attr,
1296     &sensor_dev_attr_fan2_alarm.dev_attr.attr,
1297     &sensor_dev_attr_fan3_input.dev_attr.attr,
1298     &sensor_dev_attr_fan3_min.dev_attr.attr,
1299     &sensor_dev_attr_fan3_div.dev_attr.attr,
1300     &sensor_dev_attr_fan3_alarm.dev_attr.attr,
1301     NULL
1302 };
1303 
1304 static const struct attribute_group w83792d_group = {
1305     .attrs = w83792d_attributes,
1306 };
1307 
1308 /* Return 0 if detection is successful, -ENODEV otherwise */
1309 static int
1310 w83792d_detect(struct i2c_client *client, struct i2c_board_info *info)
1311 {
1312     struct i2c_adapter *adapter = client->adapter;
1313     int val1, val2;
1314     unsigned short address = client->addr;
1315 
1316     if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1317         return -ENODEV;
1318 
1319     if (w83792d_read_value(client, W83792D_REG_CONFIG) & 0x80)
1320         return -ENODEV;
1321 
1322     val1 = w83792d_read_value(client, W83792D_REG_BANK);
1323     val2 = w83792d_read_value(client, W83792D_REG_CHIPMAN);
1324     /* Check for Winbond ID if in bank 0 */
1325     if (!(val1 & 0x07)) {  /* is Bank0 */
1326         if ((!(val1 & 0x80) && val2 != 0xa3) ||
1327             ((val1 & 0x80) && val2 != 0x5c))
1328             return -ENODEV;
1329     }
1330     /*
1331      * If Winbond chip, address of chip and W83792D_REG_I2C_ADDR
1332      * should match
1333      */
1334     if (w83792d_read_value(client, W83792D_REG_I2C_ADDR) != address)
1335         return -ENODEV;
1336 
1337     /*  Put it now into bank 0 and Vendor ID High Byte */
1338     w83792d_write_value(client,
1339                 W83792D_REG_BANK,
1340                 (w83792d_read_value(client,
1341                 W83792D_REG_BANK) & 0x78) | 0x80);
1342 
1343     /* Determine the chip type. */
1344     val1 = w83792d_read_value(client, W83792D_REG_WCHIPID);
1345     val2 = w83792d_read_value(client, W83792D_REG_CHIPMAN);
1346     if (val1 != 0x7a || val2 != 0x5c)
1347         return -ENODEV;
1348 
1349     strlcpy(info->type, "w83792d", I2C_NAME_SIZE);
1350 
1351     return 0;
1352 }
1353 
1354 static int
1355 w83792d_probe(struct i2c_client *client)
1356 {
1357     struct w83792d_data *data;
1358     struct device *dev = &client->dev;
1359     int i, val1, err;
1360 
1361     data = devm_kzalloc(dev, sizeof(struct w83792d_data), GFP_KERNEL);
1362     if (!data)
1363         return -ENOMEM;
1364 
1365     i2c_set_clientdata(client, data);
1366     mutex_init(&data->update_lock);
1367 
1368     err = w83792d_detect_subclients(client);
1369     if (err)
1370         return err;
1371 
1372     /* Initialize the chip */
1373     w83792d_init_client(client);
1374 
1375     /* A few vars need to be filled upon startup */
1376     for (i = 0; i < 7; i++) {
1377         data->fan_min[i] = w83792d_read_value(client,
1378                     W83792D_REG_FAN_MIN[i]);
1379     }
1380 
1381     /* Register sysfs hooks */
1382     err = sysfs_create_group(&dev->kobj, &w83792d_group);
1383     if (err)
1384         return err;
1385 
1386     /*
1387      * Read GPIO enable register to check if pins for fan 4,5 are used as
1388      * GPIO
1389      */
1390     val1 = w83792d_read_value(client, W83792D_REG_GPIO_EN);
1391 
1392     if (!(val1 & 0x40)) {
1393         err = sysfs_create_group(&dev->kobj, &w83792d_group_fan[0]);
1394         if (err)
1395             goto exit_remove_files;
1396     }
1397 
1398     if (!(val1 & 0x20)) {
1399         err = sysfs_create_group(&dev->kobj, &w83792d_group_fan[1]);
1400         if (err)
1401             goto exit_remove_files;
1402     }
1403 
1404     val1 = w83792d_read_value(client, W83792D_REG_PIN);
1405     if (val1 & 0x40) {
1406         err = sysfs_create_group(&dev->kobj, &w83792d_group_fan[2]);
1407         if (err)
1408             goto exit_remove_files;
1409     }
1410 
1411     if (val1 & 0x04) {
1412         err = sysfs_create_group(&dev->kobj, &w83792d_group_fan[3]);
1413         if (err)
1414             goto exit_remove_files;
1415     }
1416 
1417     data->hwmon_dev = hwmon_device_register(dev);
1418     if (IS_ERR(data->hwmon_dev)) {
1419         err = PTR_ERR(data->hwmon_dev);
1420         goto exit_remove_files;
1421     }
1422 
1423     return 0;
1424 
1425 exit_remove_files:
1426     sysfs_remove_group(&dev->kobj, &w83792d_group);
1427     for (i = 0; i < ARRAY_SIZE(w83792d_group_fan); i++)
1428         sysfs_remove_group(&dev->kobj, &w83792d_group_fan[i]);
1429     return err;
1430 }
1431 
1432 static int
1433 w83792d_remove(struct i2c_client *client)
1434 {
1435     struct w83792d_data *data = i2c_get_clientdata(client);
1436     int i;
1437 
1438     hwmon_device_unregister(data->hwmon_dev);
1439     sysfs_remove_group(&client->dev.kobj, &w83792d_group);
1440     for (i = 0; i < ARRAY_SIZE(w83792d_group_fan); i++)
1441         sysfs_remove_group(&client->dev.kobj,
1442                    &w83792d_group_fan[i]);
1443 
1444     return 0;
1445 }
1446 
1447 static void
1448 w83792d_init_client(struct i2c_client *client)
1449 {
1450     u8 temp2_cfg, temp3_cfg, vid_in_b;
1451 
1452     if (init)
1453         w83792d_write_value(client, W83792D_REG_CONFIG, 0x80);
1454 
1455     /*
1456      * Clear the bit6 of W83792D_REG_VID_IN_B(set it into 0):
1457      * W83792D_REG_VID_IN_B bit6 = 0: the high/low limit of
1458      * vin0/vin1 can be modified by user;
1459      * W83792D_REG_VID_IN_B bit6 = 1: the high/low limit of
1460      * vin0/vin1 auto-updated, can NOT be modified by user.
1461      */
1462     vid_in_b = w83792d_read_value(client, W83792D_REG_VID_IN_B);
1463     w83792d_write_value(client, W83792D_REG_VID_IN_B,
1464                 vid_in_b & 0xbf);
1465 
1466     temp2_cfg = w83792d_read_value(client, W83792D_REG_TEMP2_CONFIG);
1467     temp3_cfg = w83792d_read_value(client, W83792D_REG_TEMP3_CONFIG);
1468     w83792d_write_value(client, W83792D_REG_TEMP2_CONFIG,
1469                 temp2_cfg & 0xe6);
1470     w83792d_write_value(client, W83792D_REG_TEMP3_CONFIG,
1471                 temp3_cfg & 0xe6);
1472 
1473     /* Start monitoring */
1474     w83792d_write_value(client, W83792D_REG_CONFIG,
1475                 (w83792d_read_value(client,
1476                         W83792D_REG_CONFIG) & 0xf7)
1477                 | 0x01);
1478 }
1479 
1480 static struct w83792d_data *w83792d_update_device(struct device *dev)
1481 {
1482     struct i2c_client *client = to_i2c_client(dev);
1483     struct w83792d_data *data = i2c_get_clientdata(client);
1484     int i, j;
1485     u8 reg_array_tmp[4], reg_tmp;
1486 
1487     mutex_lock(&data->update_lock);
1488 
1489     if (time_after
1490         (jiffies - data->last_updated, (unsigned long) (HZ * 3))
1491         || time_before(jiffies, data->last_updated) || !data->valid) {
1492         dev_dbg(dev, "Starting device update\n");
1493 
1494         /* Update the voltages measured value and limits */
1495         for (i = 0; i < 9; i++) {
1496             data->in[i] = w83792d_read_value(client,
1497                         W83792D_REG_IN[i]);
1498             data->in_max[i] = w83792d_read_value(client,
1499                         W83792D_REG_IN_MAX[i]);
1500             data->in_min[i] = w83792d_read_value(client,
1501                         W83792D_REG_IN_MIN[i]);
1502         }
1503         data->low_bits = w83792d_read_value(client,
1504                         W83792D_REG_LOW_BITS1) +
1505                  (w83792d_read_value(client,
1506                         W83792D_REG_LOW_BITS2) << 8);
1507         for (i = 0; i < 7; i++) {
1508             /* Update the Fan measured value and limits */
1509             data->fan[i] = w83792d_read_value(client,
1510                         W83792D_REG_FAN[i]);
1511             data->fan_min[i] = w83792d_read_value(client,
1512                         W83792D_REG_FAN_MIN[i]);
1513             /* Update the PWM/DC Value and PWM/DC flag */
1514             data->pwm[i] = w83792d_read_value(client,
1515                         W83792D_REG_PWM[i]);
1516         }
1517 
1518         reg_tmp = w83792d_read_value(client, W83792D_REG_FAN_CFG);
1519         data->pwmenable[0] = reg_tmp & 0x03;
1520         data->pwmenable[1] = (reg_tmp>>2) & 0x03;
1521         data->pwmenable[2] = (reg_tmp>>4) & 0x03;
1522 
1523         for (i = 0; i < 3; i++) {
1524             data->temp1[i] = w83792d_read_value(client,
1525                             W83792D_REG_TEMP1[i]);
1526         }
1527         for (i = 0; i < 2; i++) {
1528             for (j = 0; j < 6; j++) {
1529                 data->temp_add[i][j] = w83792d_read_value(
1530                     client, W83792D_REG_TEMP_ADD[i][j]);
1531             }
1532         }
1533 
1534         /* Update the Fan Divisor */
1535         for (i = 0; i < 4; i++) {
1536             reg_array_tmp[i] = w83792d_read_value(client,
1537                             W83792D_REG_FAN_DIV[i]);
1538         }
1539         data->fan_div[0] = reg_array_tmp[0] & 0x07;
1540         data->fan_div[1] = (reg_array_tmp[0] >> 4) & 0x07;
1541         data->fan_div[2] = reg_array_tmp[1] & 0x07;
1542         data->fan_div[3] = (reg_array_tmp[1] >> 4) & 0x07;
1543         data->fan_div[4] = reg_array_tmp[2] & 0x07;
1544         data->fan_div[5] = (reg_array_tmp[2] >> 4) & 0x07;
1545         data->fan_div[6] = reg_array_tmp[3] & 0x07;
1546 
1547         /* Update the realtime status */
1548         data->alarms = w83792d_read_value(client, W83792D_REG_ALARM1) +
1549             (w83792d_read_value(client, W83792D_REG_ALARM2) << 8) +
1550             (w83792d_read_value(client, W83792D_REG_ALARM3) << 16);
1551 
1552         /* Update CaseOpen status and it's CLR_CHS. */
1553         data->chassis = (w83792d_read_value(client,
1554             W83792D_REG_CHASSIS) >> 5) & 0x01;
1555 
1556         /* Update Thermal Cruise/Smart Fan I target value */
1557         for (i = 0; i < 3; i++) {
1558             data->thermal_cruise[i] =
1559                 w83792d_read_value(client,
1560                 W83792D_REG_THERMAL[i]) & 0x7f;
1561         }
1562 
1563         /* Update Smart Fan I/II tolerance */
1564         reg_tmp = w83792d_read_value(client, W83792D_REG_TOLERANCE[0]);
1565         data->tolerance[0] = reg_tmp & 0x0f;
1566         data->tolerance[1] = (reg_tmp >> 4) & 0x0f;
1567         data->tolerance[2] = w83792d_read_value(client,
1568                     W83792D_REG_TOLERANCE[2]) & 0x0f;
1569 
1570         /* Update Smart Fan II temperature points */
1571         for (i = 0; i < 3; i++) {
1572             for (j = 0; j < 4; j++) {
1573                 data->sf2_points[i][j]
1574                   = w83792d_read_value(client,
1575                     W83792D_REG_POINTS[i][j]) & 0x7f;
1576             }
1577         }
1578 
1579         /* Update Smart Fan II duty cycle levels */
1580         for (i = 0; i < 3; i++) {
1581             reg_tmp = w83792d_read_value(client,
1582                         W83792D_REG_LEVELS[i][0]);
1583             data->sf2_levels[i][0] = reg_tmp & 0x0f;
1584             data->sf2_levels[i][1] = (reg_tmp >> 4) & 0x0f;
1585             reg_tmp = w83792d_read_value(client,
1586                         W83792D_REG_LEVELS[i][2]);
1587             data->sf2_levels[i][2] = (reg_tmp >> 4) & 0x0f;
1588             data->sf2_levels[i][3] = reg_tmp & 0x0f;
1589         }
1590 
1591         data->last_updated = jiffies;
1592         data->valid = true;
1593     }
1594 
1595     mutex_unlock(&data->update_lock);
1596 
1597 #ifdef DEBUG
1598     w83792d_print_debug(data, dev);
1599 #endif
1600 
1601     return data;
1602 }
1603 
1604 #ifdef DEBUG
1605 static void w83792d_print_debug(struct w83792d_data *data, struct device *dev)
1606 {
1607     int i = 0, j = 0;
1608     dev_dbg(dev, "==========The following is the debug message...========\n");
1609     dev_dbg(dev, "9 set of Voltages: =====>\n");
1610     for (i = 0; i < 9; i++) {
1611         dev_dbg(dev, "vin[%d] is: 0x%x\n", i, data->in[i]);
1612         dev_dbg(dev, "vin[%d] max is: 0x%x\n", i, data->in_max[i]);
1613         dev_dbg(dev, "vin[%d] min is: 0x%x\n", i, data->in_min[i]);
1614     }
1615     dev_dbg(dev, "Low Bit1 is: 0x%x\n", data->low_bits & 0xff);
1616     dev_dbg(dev, "Low Bit2 is: 0x%x\n", data->low_bits >> 8);
1617     dev_dbg(dev, "7 set of Fan Counts and Duty Cycles: =====>\n");
1618     for (i = 0; i < 7; i++) {
1619         dev_dbg(dev, "fan[%d] is: 0x%x\n", i, data->fan[i]);
1620         dev_dbg(dev, "fan[%d] min is: 0x%x\n", i, data->fan_min[i]);
1621         dev_dbg(dev, "pwm[%d]     is: 0x%x\n", i, data->pwm[i]);
1622     }
1623     dev_dbg(dev, "3 set of Temperatures: =====>\n");
1624     for (i = 0; i < 3; i++)
1625         dev_dbg(dev, "temp1[%d] is: 0x%x\n", i, data->temp1[i]);
1626 
1627     for (i = 0; i < 2; i++) {
1628         for (j = 0; j < 6; j++) {
1629             dev_dbg(dev, "temp_add[%d][%d] is: 0x%x\n", i, j,
1630                             data->temp_add[i][j]);
1631         }
1632     }
1633 
1634     for (i = 0; i < 7; i++)
1635         dev_dbg(dev, "fan_div[%d] is: 0x%x\n", i, data->fan_div[i]);
1636 
1637     dev_dbg(dev, "==========End of the debug message...================\n");
1638     dev_dbg(dev, "\n");
1639 }
1640 #endif
1641 
1642 module_i2c_driver(w83792d_driver);
1643 
1644 MODULE_AUTHOR("Shane Huang (Winbond)");
1645 MODULE_DESCRIPTION("W83792AD/D driver for linux-2.6");
1646 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!