drivers/hwmon/w83792d.c

   1 /*
   2     w83792d.c - Part of lm_sensors, Linux kernel modules for hardware
   3                 monitoring
   4     Copyright (C) 2004, 2005 Winbond Electronics Corp.
   5                         Chunhao Huang <DZShen@Winbond.com.tw>,
   6                         Rudolf Marek <r.marek@sh.cvut.cz>
   7
   8     This program is free software; you can redistribute it and/or modify
   9     it under the terms of the GNU General Public License as published by
  10     the Free Software Foundation; either version 2 of the License, or
  11     (at your option) any later version.
  12
  13     This program is distributed in the hope that it will be useful,
  14     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16     GNU General Public License for more details.
  17
  18     You should have received a copy of the GNU General Public License
  19     along with this program; if not, write to the Free Software
  20     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21
  22     Note:
  23     1. This driver is only for 2.6 kernel, 2.4 kernel need a different driver.
  24     2. This driver is only for Winbond W83792D C version device, there
  25        are also some motherboards with B version W83792D device. The
  26        calculation method to in6-in7(measured value, limits) is a little
  27        different between C and B version. C or B version can be identified
  28        by CR[0x49h].
  29 */
  30
  31 /*
  32     Supports following chips:
  33
  34     Chip        #vin    #fanin  #pwm    #temp   wchipid vendid  i2c     ISA
  35     w83792d     9       7       7       3       0x7a    0x5ca3  yes     no
  36 */
  37
  38 #include <linux/config.h>
  39 #include <linux/module.h>
  40 #include <linux/init.h>
  41 #include <linux/slab.h>
  42 #include <linux/i2c.h>
  43 #include <linux/i2c-sensor.h>
  44 #include <linux/i2c-vid.h>
  45 #include <linux/hwmon-sysfs.h>
  46
  47 /* Addresses to scan */
  48 static unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END };
  49
  50 /* Insmod parameters */
  51 SENSORS_INSMOD_1(w83792d);
  52 I2C_CLIENT_MODULE_PARM(force_subclients, "List of subclient addresses: "
  53                         "{bus, clientaddr, subclientaddr1, subclientaddr2}");
  54
  55 static int init;
  56 module_param(init, bool, 0);
  57 MODULE_PARM_DESC(init, "Set to one to force chip initialization");
  58
  59 /* The W83792D registers */
  60 static const u8 W83792D_REG_IN[9] = {
  61         0x20,   /* Vcore A in DataSheet */
  62         0x21,   /* Vcore B in DataSheet */
  63         0x22,   /* VIN0 in DataSheet */
  64         0x23,   /* VIN1 in DataSheet */
  65         0x24,   /* VIN2 in DataSheet */
  66         0x25,   /* VIN3 in DataSheet */
  67         0x26,   /* 5VCC in DataSheet */
  68         0xB0,   /* 5VSB in DataSheet */
  69         0xB1    /* VBAT in DataSheet */
  70 };
  71 #define W83792D_REG_LOW_BITS1 0x3E  /* Low Bits I in DataSheet */
  72 #define W83792D_REG_LOW_BITS2 0x3F  /* Low Bits II in DataSheet */
  73 static const u8 W83792D_REG_IN_MAX[9] = {
  74         0x2B,   /* Vcore A High Limit in DataSheet */
  75         0x2D,   /* Vcore B High Limit in DataSheet */
  76         0x2F,   /* VIN0 High Limit in DataSheet */
  77         0x31,   /* VIN1 High Limit in DataSheet */
  78         0x33,   /* VIN2 High Limit in DataSheet */
  79         0x35,   /* VIN3 High Limit in DataSheet */
  80         0x37,   /* 5VCC High Limit in DataSheet */
  81         0xB4,   /* 5VSB High Limit in DataSheet */
  82         0xB6    /* VBAT High Limit in DataSheet */
  83 };
  84 static const u8 W83792D_REG_IN_MIN[9] = {
  85         0x2C,   /* Vcore A Low Limit in DataSheet */
  86         0x2E,   /* Vcore B Low Limit in DataSheet */
  87         0x30,   /* VIN0 Low Limit in DataSheet */
  88         0x32,   /* VIN1 Low Limit in DataSheet */
  89         0x34,   /* VIN2 Low Limit in DataSheet */
  90         0x36,   /* VIN3 Low Limit in DataSheet */
  91         0x38,   /* 5VCC Low Limit in DataSheet */
  92         0xB5,   /* 5VSB Low Limit in DataSheet */
  93         0xB7    /* VBAT Low Limit in DataSheet */
  94 };
  95 static const u8 W83792D_REG_FAN[7] = {
  96         0x28,   /* FAN 1 Count in DataSheet */
  97         0x29,   /* FAN 2 Count in DataSheet */
  98         0x2A,   /* FAN 3 Count in DataSheet */
  99         0xB8,   /* FAN 4 Count in DataSheet */
 100         0xB9,   /* FAN 5 Count in DataSheet */
 101         0xBA,   /* FAN 6 Count in DataSheet */
 102         0xBE    /* FAN 7 Count in DataSheet */
 103 };
 104 static const u8 W83792D_REG_FAN_MIN[7] = {
 105         0x3B,   /* FAN 1 Count Low Limit in DataSheet */
 106         0x3C,   /* FAN 2 Count Low Limit in DataSheet */
 107         0x3D,   /* FAN 3 Count Low Limit in DataSheet */
 108         0xBB,   /* FAN 4 Count Low Limit in DataSheet */
 109         0xBC,   /* FAN 5 Count Low Limit in DataSheet */
 110         0xBD,   /* FAN 6 Count Low Limit in DataSheet */
 111         0xBF    /* FAN 7 Count Low Limit in DataSheet */
 112 };
 113 #define W83792D_REG_FAN_CFG 0x84        /* FAN Configuration in DataSheet */
 114 static const u8 W83792D_REG_FAN_DIV[4] = {
 115         0x47,   /* contains FAN2 and FAN1 Divisor */
 116         0x5B,   /* contains FAN4 and FAN3 Divisor */
 117         0x5C,   /* contains FAN6 and FAN5 Divisor */
 118         0x9E    /* contains FAN7 Divisor. */
 119 };
 120 static const u8 W83792D_REG_PWM[7] = {
 121         0x81,   /* FAN 1 Duty Cycle, be used to control */
 122         0x83,   /* FAN 2 Duty Cycle, be used to control */
 123         0x94,   /* FAN 3 Duty Cycle, be used to control */
 124         0xA3,   /* FAN 4 Duty Cycle, be used to control */
 125         0xA4,   /* FAN 5 Duty Cycle, be used to control */
 126         0xA5,   /* FAN 6 Duty Cycle, be used to control */
 127         0xA6    /* FAN 7 Duty Cycle, be used to control */
 128 };
 129 #define W83792D_REG_BANK                0x4E
 130 #define W83792D_REG_TEMP2_CONFIG        0xC2
 131 #define W83792D_REG_TEMP3_CONFIG        0xCA
 132
 133 static const u8 W83792D_REG_TEMP1[3] = {
 134         0x27,   /* TEMP 1 in DataSheet */
 135         0x39,   /* TEMP 1 Over in DataSheet */
 136         0x3A,   /* TEMP 1 Hyst in DataSheet */
 137 };
 138
 139 static const u8 W83792D_REG_TEMP_ADD[2][6] = {
 140         { 0xC0,         /* TEMP 2 in DataSheet */
 141           0xC1,         /* TEMP 2(0.5 deg) in DataSheet */
 142           0xC5,         /* TEMP 2 Over High part in DataSheet */
 143           0xC6,         /* TEMP 2 Over Low part in DataSheet */
 144           0xC3,         /* TEMP 2 Thyst High part in DataSheet */
 145           0xC4 },       /* TEMP 2 Thyst Low part in DataSheet */
 146         { 0xC8,         /* TEMP 3 in DataSheet */
 147           0xC9,         /* TEMP 3(0.5 deg) in DataSheet */
 148           0xCD,         /* TEMP 3 Over High part in DataSheet */
 149           0xCE,         /* TEMP 3 Over Low part in DataSheet */
 150           0xCB,         /* TEMP 3 Thyst High part in DataSheet */
 151           0xCC }        /* TEMP 3 Thyst Low part in DataSheet */
 152 };
 153
 154 static const u8 W83792D_REG_THERMAL[3] = {
 155         0x85,   /* SmartFanI: Fan1 target value */
 156         0x86,   /* SmartFanI: Fan2 target value */
 157         0x96    /* SmartFanI: Fan3 target value */
 158 };
 159
 160 static const u8 W83792D_REG_TOLERANCE[3] = {
 161         0x87,   /* (bit3-0)SmartFan Fan1 tolerance */
 162         0x87,   /* (bit7-4)SmartFan Fan2 tolerance */
 163         0x97    /* (bit3-0)SmartFan Fan3 tolerance */
 164 };
 165
 166 static const u8 W83792D_REG_POINTS[3][4] = {
 167         { 0x85,         /* SmartFanII: Fan1 temp point 1 */
 168           0xE3,         /* SmartFanII: Fan1 temp point 2 */
 169           0xE4,         /* SmartFanII: Fan1 temp point 3 */
 170           0xE5 },       /* SmartFanII: Fan1 temp point 4 */
 171         { 0x86,         /* SmartFanII: Fan2 temp point 1 */
 172           0xE6,         /* SmartFanII: Fan2 temp point 2 */
 173           0xE7,         /* SmartFanII: Fan2 temp point 3 */
 174           0xE8 },       /* SmartFanII: Fan2 temp point 4 */
 175         { 0x96,         /* SmartFanII: Fan3 temp point 1 */
 176           0xE9,         /* SmartFanII: Fan3 temp point 2 */
 177           0xEA,         /* SmartFanII: Fan3 temp point 3 */
 178           0xEB }        /* SmartFanII: Fan3 temp point 4 */
 179 };
 180
 181 static const u8 W83792D_REG_LEVELS[3][4] = {
 182         { 0x88,         /* (bit3-0) SmartFanII: Fan1 Non-Stop */
 183           0x88,         /* (bit7-4) SmartFanII: Fan1 Level 1 */
 184           0xE0,         /* (bit7-4) SmartFanII: Fan1 Level 2 */
 185           0xE0 },       /* (bit3-0) SmartFanII: Fan1 Level 3 */
 186         { 0x89,         /* (bit3-0) SmartFanII: Fan2 Non-Stop */
 187           0x89,         /* (bit7-4) SmartFanII: Fan2 Level 1 */
 188           0xE1,         /* (bit7-4) SmartFanII: Fan2 Level 2 */
 189           0xE1 },       /* (bit3-0) SmartFanII: Fan2 Level 3 */
 190         { 0x98,         /* (bit3-0) SmartFanII: Fan3 Non-Stop */
 191           0x98,         /* (bit7-4) SmartFanII: Fan3 Level 1 */
 192           0xE2,         /* (bit7-4) SmartFanII: Fan3 Level 2 */
 193           0xE2 }        /* (bit3-0) SmartFanII: Fan3 Level 3 */
 194 };
 195
 196 #define W83792D_REG_CONFIG              0x40
 197 #define W83792D_REG_VID_FANDIV          0x47
 198 #define W83792D_REG_CHIPID              0x49
 199 #define W83792D_REG_WCHIPID             0x58
 200 #define W83792D_REG_CHIPMAN             0x4F
 201 #define W83792D_REG_PIN                 0x4B
 202 #define W83792D_REG_I2C_SUBADDR         0x4A
 203
 204 #define W83792D_REG_ALARM1 0xA9         /* realtime status register1 */
 205 #define W83792D_REG_ALARM2 0xAA         /* realtime status register2 */
 206 #define W83792D_REG_ALARM3 0xAB         /* realtime status register3 */
 207 #define W83792D_REG_CHASSIS 0x42        /* Bit 5: Case Open status bit */
 208 #define W83792D_REG_CHASSIS_CLR 0x44    /* Bit 7: Case Open CLR_CHS/Reset bit */
 209
 210 /* control in0/in1 's limit modifiability */
 211 #define W83792D_REG_VID_IN_B            0x17
 212
 213 #define W83792D_REG_VBAT                0x5D
 214 #define W83792D_REG_I2C_ADDR            0x48
 215
 216 /* Conversions. Rounding and limit checking is only done on the TO_REG
 217    variants. Note that you should be a bit careful with which arguments
 218    these macros are called: arguments may be evaluated more than once.
 219    Fixing this is just not worth it. */
 220 #define IN_FROM_REG(nr,val) (((nr)<=1)?(val*2): \
 221                                 ((((nr)==6)||((nr)==7))?(val*6):(val*4)))
 222 #define IN_TO_REG(nr,val) (((nr)<=1)?(val/2): \
 223                                 ((((nr)==6)||((nr)==7))?(val/6):(val/4)))
 224
 225 static inline u8
 226 FAN_TO_REG(long rpm, int div)
 227 {
 228         if (rpm == 0)
 229                 return 255;
 230         rpm = SENSORS_LIMIT(rpm, 1, 1000000);
 231         return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
 232 }
 233
 234 #define FAN_FROM_REG(val,div)   ((val) == 0   ? -1 : \
 235                                 ((val) == 255 ? 0 : \
 236                                                 1350000 / ((val) * (div))))
 237
 238 /* for temp1 */
 239 #define TEMP1_TO_REG(val)       (SENSORS_LIMIT(((val) < 0 ? (val)+0x100*1000 \
 240                                         : (val)) / 1000, 0, 0xff))
 241 #define TEMP1_FROM_REG(val)     (((val) & 0x80 ? (val)-0x100 : (val)) * 1000)
 242 /* for temp2 and temp3, because they need addtional resolution */
 243 #define TEMP_ADD_FROM_REG(val1, val2) \
 244         ((((val1) & 0x80 ? (val1)-0x100 \
 245                 : (val1)) * 1000) + ((val2 & 0x80) ? 500 : 0))
 246 #define TEMP_ADD_TO_REG_HIGH(val) \
 247         (SENSORS_LIMIT(((val) < 0 ? (val)+0x100*1000 \
 248                         : (val)) / 1000, 0, 0xff))
 249 #define TEMP_ADD_TO_REG_LOW(val)        ((val%1000) ? 0x80 : 0x00)
 250
 251 #define PWM_FROM_REG(val)               (val)
 252 #define PWM_TO_REG(val)                 (SENSORS_LIMIT((val),0,255))
 253 #define DIV_FROM_REG(val)               (1 << (val))
 254
 255 static inline u8
 256 DIV_TO_REG(long val)
 257 {
 258         int i;
 259         val = SENSORS_LIMIT(val, 1, 128) >> 1;
 260         for (i = 0; i < 6; i++) {
 261                 if (val == 0)
 262                         break;
 263                 val >>= 1;
 264         }
 265         return ((u8) i);
 266 }
 267
 268 struct w83792d_data {
 269         struct i2c_client client;
 270         struct semaphore lock;
 271         enum chips type;
 272
 273         struct semaphore update_lock;
 274         char valid;             /* !=0 if following fields are valid */
 275         unsigned long last_updated;     /* In jiffies */
 276
 277         /* array of 2 pointers to subclients */
 278         struct i2c_client *lm75[2];
 279
 280         u8 in[9];               /* Register value */
 281         u8 in_max[9];           /* Register value */
 282         u8 in_min[9];           /* Register value */
 283         u8 low_bits[2];         /* Additional resolution to voltage in0-6 */
 284         u8 fan[7];              /* Register value */
 285         u8 fan_min[7];          /* Register value */
 286         u8 temp1[3];            /* current, over, thyst */
 287         u8 temp_add[2][6];      /* Register value */
 288         u8 fan_div[7];          /* Register encoding, shifted right */
 289         u8 pwm[7];              /* We only consider the first 3 set of pwm,
 290                                    although 792 chip has 7 set of pwm. */
 291         u8 pwmenable[3];
 292         u8 pwm_mode[7];         /* indicates PWM or DC mode: 1->PWM; 0->DC */
 293         u32 alarms;             /* realtime status register encoding,combined */
 294         u8 chassis;             /* Chassis status */
 295         u8 chassis_clear;       /* CLR_CHS, clear chassis intrusion detection */
 296         u8 thermal_cruise[3];   /* Smart FanI: Fan1,2,3 target value */
 297         u8 tolerance[3];        /* Fan1,2,3 tolerance(Smart Fan I/II) */
 298         u8 sf2_points[3][4];    /* Smart FanII: Fan1,2,3 temperature points */
 299         u8 sf2_levels[3][4];    /* Smart FanII: Fan1,2,3 duty cycle levels */
 300 };
 301
 302 static int w83792d_attach_adapter(struct i2c_adapter *adapter);
 303 static int w83792d_detect(struct i2c_adapter *adapter, int address, int kind);
 304 static int w83792d_detach_client(struct i2c_client *client);
 305
 306 static int w83792d_read_value(struct i2c_client *client, u8 register);
 307 static int w83792d_write_value(struct i2c_client *client, u8 register,
 308                                 u8 value);
 309 static struct w83792d_data *w83792d_update_device(struct device *dev);
 310
 311 #ifdef DEBUG
 312 static void w83792d_print_debug(struct w83792d_data *data, struct device *dev);
 313 #endif
 314
 315 static void w83792d_init_client(struct i2c_client *client);
 316
 317 static struct i2c_driver w83792d_driver = {
 318         .owner = THIS_MODULE,
 319         .name = "w83792d",
 320         .flags = I2C_DF_NOTIFY,
 321         .attach_adapter = w83792d_attach_adapter,
 322         .detach_client = w83792d_detach_client,
 323 };
 324
 325 static long in_count_from_reg(int nr, struct w83792d_data *data)
 326 {
 327         u16 vol_count = data->in[nr];
 328         u16 low_bits = 0;
 329         vol_count = (vol_count << 2);
 330         switch (nr)
 331         {
 332         case 0:  /* vin0 */
 333                 low_bits = (data->low_bits[0]) & 0x03;
 334                 break;
 335         case 1:  /* vin1 */
 336                 low_bits = ((data->low_bits[0]) & 0x0c) >> 2;
 337                 break;
 338         case 2:  /* vin2 */
 339                 low_bits = ((data->low_bits[0]) & 0x30) >> 4;
 340                 break;
 341         case 3:  /* vin3 */
 342                 low_bits = ((data->low_bits[0]) & 0xc0) >> 6;
 343                 break;
 344         case 4:  /* vin4 */
 345                 low_bits = (data->low_bits[1]) & 0x03;
 346                 break;
 347         case 5:  /* vin5 */
 348                 low_bits = ((data->low_bits[1]) & 0x0c) >> 2;
 349                 break;
 350         case 6:  /* vin6 */
 351                 low_bits = ((data->low_bits[1]) & 0x30) >> 4;
 352         default:
 353                 break;
 354         }
 355         vol_count = vol_count | low_bits;
 356         return vol_count;
 357 }
 358
 359 /* following are the sysfs callback functions */
 360 static ssize_t show_in(struct device *dev, struct device_attribute *attr,
 361                         char *buf)
 362 {
 363         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 364         int nr = sensor_attr->index;
 365         struct w83792d_data *data = w83792d_update_device(dev);
 366         return sprintf(buf,"%ld\n", IN_FROM_REG(nr,(in_count_from_reg(nr, data))));
 367 }
 368
 369 #define show_in_reg(reg) \
 370 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
 371                         char *buf) \
 372 { \
 373         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
 374         int nr = sensor_attr->index; \
 375         struct w83792d_data *data = w83792d_update_device(dev); \
 376         return sprintf(buf,"%ld\n", (long)(IN_FROM_REG(nr, (data->reg[nr])*4))); \
 377 }
 378
 379 show_in_reg(in_min);
 380 show_in_reg(in_max);
 381
 382 #define store_in_reg(REG, reg) \
 383 static ssize_t store_in_##reg (struct device *dev, \
 384                                 struct device_attribute *attr, \
 385                                 const char *buf, size_t count) \
 386 { \
 387         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
 388         int nr = sensor_attr->index; \
 389         struct i2c_client *client = to_i2c_client(dev); \
 390         struct w83792d_data *data = i2c_get_clientdata(client); \
 391         u32 val; \
 392          \
 393         val = simple_strtoul(buf, NULL, 10); \
 394         data->in_##reg[nr] = SENSORS_LIMIT(IN_TO_REG(nr, val)/4, 0, 255); \
 395         w83792d_write_value(client, W83792D_REG_IN_##REG[nr], data->in_##reg[nr]); \
 396          \
 397         return count; \
 398 }
 399 store_in_reg(MIN, min);
 400 store_in_reg(MAX, max);
 401
 402 #define sysfs_in_reg(offset) \
 403 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, show_in, \
 404                                 NULL, offset); \
 405 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
 406                                 show_in_min, store_in_min, offset); \
 407 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
 408                                 show_in_max, store_in_max, offset);
 409
 410 sysfs_in_reg(0);
 411 sysfs_in_reg(1);
 412 sysfs_in_reg(2);
 413 sysfs_in_reg(3);
 414 sysfs_in_reg(4);
 415 sysfs_in_reg(5);
 416 sysfs_in_reg(6);
 417 sysfs_in_reg(7);
 418 sysfs_in_reg(8);
 419
 420 #define device_create_file_in(client, offset) \
 421 do { \
 422 device_create_file(&client->dev, &sensor_dev_attr_in##offset##_input.dev_attr); \
 423 device_create_file(&client->dev, &sensor_dev_attr_in##offset##_max.dev_attr); \
 424 device_create_file(&client->dev, &sensor_dev_attr_in##offset##_min.dev_attr); \
 425 } while (0)
 426
 427 #define show_fan_reg(reg) \
 428 static ssize_t show_##reg (struct device *dev, struct device_attribute *attr, \
 429                         char *buf) \
 430 { \
 431         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
 432         int nr = sensor_attr->index - 1; \
 433         struct w83792d_data *data = w83792d_update_device(dev); \
 434         return sprintf(buf,"%d\n", \
 435                 FAN_FROM_REG(data->reg[nr], DIV_FROM_REG(data->fan_div[nr]))); \
 436 }
 437
 438 show_fan_reg(fan);
 439 show_fan_reg(fan_min);
 440
 441 static ssize_t
 442 store_fan_min(struct device *dev, struct device_attribute *attr,
 443                 const char *buf, size_t count)
 444 {
 445         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 446         int nr = sensor_attr->index - 1;
 447         struct i2c_client *client = to_i2c_client(dev);
 448         struct w83792d_data *data = i2c_get_clientdata(client);
 449         u32 val;
 450
 451         val = simple_strtoul(buf, NULL, 10);
 452         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
 453         w83792d_write_value(client, W83792D_REG_FAN_MIN[nr],
 454                                 data->fan_min[nr]);
 455
 456         return count;
 457 }
 458
 459 static ssize_t
 460 show_fan_div(struct device *dev, struct device_attribute *attr,
 461                 char *buf)
 462 {
 463         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 464         int nr = sensor_attr->index;
 465         struct w83792d_data *data = w83792d_update_device(dev);
 466         return sprintf(buf, "%u\n", DIV_FROM_REG(data->fan_div[nr - 1]));
 467 }
 468
 469 /* Note: we save and restore the fan minimum here, because its value is
 470    determined in part by the fan divisor.  This follows the principle of
 471    least suprise; the user doesn't expect the fan minimum to change just
 472    because the divisor changed. */
 473 static ssize_t
 474 store_fan_div(struct device *dev, struct device_attribute *attr,
 475                 const char *buf, size_t count)
 476 {
 477         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 478         int nr = sensor_attr->index - 1;
 479         struct i2c_client *client = to_i2c_client(dev);
 480         struct w83792d_data *data = i2c_get_clientdata(client);
 481         unsigned long min;
 482         /*u8 reg;*/
 483         u8 fan_div_reg = 0;
 484         u8 tmp_fan_div;
 485
 486         /* Save fan_min */
 487         min = FAN_FROM_REG(data->fan_min[nr],
 488                            DIV_FROM_REG(data->fan_div[nr]));
 489
 490         data->fan_div[nr] = DIV_TO_REG(simple_strtoul(buf, NULL, 10));
 491
 492         fan_div_reg = w83792d_read_value(client, W83792D_REG_FAN_DIV[nr >> 1]);
 493         fan_div_reg &= (nr & 0x01) ? 0x8f : 0xf8;
 494         tmp_fan_div = (nr & 0x01) ? (((data->fan_div[nr]) << 4) & 0x70)
 495                                         : ((data->fan_div[nr]) & 0x07);
 496         w83792d_write_value(client, W83792D_REG_FAN_DIV[nr >> 1],
 497                                         fan_div_reg | tmp_fan_div);
 498
 499         /* Restore fan_min */
 500         data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
 501         w83792d_write_value(client, W83792D_REG_FAN_MIN[nr], data->fan_min[nr]);
 502
 503         return count;
 504 }
 505
 506 #define sysfs_fan(offset) \
 507 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan, NULL, \
 508                                 offset); \
 509 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
 510                                 show_fan_div, store_fan_div, offset); \
 511 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
 512                                 show_fan_min, store_fan_min, offset);
 513
 514 sysfs_fan(1);
 515 sysfs_fan(2);
 516 sysfs_fan(3);
 517 sysfs_fan(4);
 518 sysfs_fan(5);
 519 sysfs_fan(6);
 520 sysfs_fan(7);
 521
 522 #define device_create_file_fan(client, offset) \
 523 do { \
 524 device_create_file(&client->dev, &sensor_dev_attr_fan##offset##_input.dev_attr); \
 525 device_create_file(&client->dev, &sensor_dev_attr_fan##offset##_div.dev_attr); \
 526 device_create_file(&client->dev, &sensor_dev_attr_fan##offset##_min.dev_attr); \
 527 } while (0)
 528
 529
 530 /* read/write the temperature1, includes measured value and limits */
 531
 532 static ssize_t show_temp1(struct device *dev, struct device_attribute *attr,
 533                                 char *buf)
 534 {
 535         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 536         int nr = sensor_attr->index;
 537         struct w83792d_data *data = w83792d_update_device(dev);
 538         return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp1[nr]));
 539 }
 540
 541 static ssize_t store_temp1(struct device *dev, struct device_attribute *attr,
 542                                 const char *buf, size_t count)
 543 {
 544         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 545         int nr = sensor_attr->index;
 546         struct i2c_client *client = to_i2c_client(dev);
 547         struct w83792d_data *data = i2c_get_clientdata(client);
 548         s32 val;
 549
 550         val = simple_strtol(buf, NULL, 10);
 551
 552         data->temp1[nr] = TEMP1_TO_REG(val);
 553         w83792d_write_value(client, W83792D_REG_TEMP1[nr],
 554                 data->temp1[nr]);
 555
 556         return count;
 557 }
 558
 559
 560 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp1, NULL, 0);
 561 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, show_temp1,
 562                                 store_temp1, 1);
 563 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, show_temp1,
 564                                 store_temp1, 2);
 565
 566 #define device_create_file_temp1(client) \
 567 do { \
 568 device_create_file(&client->dev, &sensor_dev_attr_temp1_input.dev_attr); \
 569 device_create_file(&client->dev, &sensor_dev_attr_temp1_max.dev_attr); \
 570 device_create_file(&client->dev, &sensor_dev_attr_temp1_max_hyst.dev_attr); \
 571 } while (0)
 572
 573
 574 /* read/write the temperature2-3, includes measured value and limits */
 575
 576 static ssize_t show_temp23(struct device *dev, struct device_attribute *attr,
 577                                 char *buf)
 578 {
 579         struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr);
 580         int nr = sensor_attr->nr;
 581         int index = sensor_attr->index;
 582         struct w83792d_data *data = w83792d_update_device(dev);
 583         return sprintf(buf,"%ld\n",
 584                 (long)TEMP_ADD_FROM_REG(data->temp_add[nr][index],
 585                         data->temp_add[nr][index+1]));
 586 }
 587
 588 static ssize_t store_temp23(struct device *dev, struct device_attribute *attr,
 589                                 const char *buf, size_t count)
 590 {
 591         struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr);
 592         int nr = sensor_attr->nr;
 593         int index = sensor_attr->index;
 594         struct i2c_client *client = to_i2c_client(dev);
 595         struct w83792d_data *data = i2c_get_clientdata(client);
 596         s32 val;
 597
 598         val = simple_strtol(buf, NULL, 10);
 599
 600         data->temp_add[nr][index] = TEMP_ADD_TO_REG_HIGH(val);
 601         data->temp_add[nr][index+1] = TEMP_ADD_TO_REG_LOW(val);
 602         w83792d_write_value(client, W83792D_REG_TEMP_ADD[nr][index],
 603                 data->temp_add[nr][index]);
 604         w83792d_write_value(client, W83792D_REG_TEMP_ADD[nr][index+1],
 605                 data->temp_add[nr][index+1]);
 606
 607         return count;
 608 }
 609
 610 #define sysfs_temp23(name,idx) \
 611 static SENSOR_DEVICE_ATTR_2(name##_input, S_IRUGO, show_temp23, NULL, \
 612                                 idx, 0); \
 613 static SENSOR_DEVICE_ATTR_2(name##_max, S_IRUGO | S_IWUSR, \
 614                                 show_temp23, store_temp23, idx, 2); \
 615 static SENSOR_DEVICE_ATTR_2(name##_max_hyst, S_IRUGO | S_IWUSR, \
 616                                 show_temp23, store_temp23, idx, 4);
 617
 618 sysfs_temp23(temp2,0)
 619 sysfs_temp23(temp3,1)
 620
 621 #define device_create_file_temp_add(client, offset) \
 622 do { \
 623 device_create_file(&client->dev, &sensor_dev_attr_temp##offset##_input.dev_attr); \
 624 device_create_file(&client->dev, &sensor_dev_attr_temp##offset##_max.dev_attr); \
 625 device_create_file(&client->dev, \
 626 &sensor_dev_attr_temp##offset##_max_hyst.dev_attr); \
 627 } while (0)
 628
 629
 630 /* get reatime status of all sensors items: voltage, temp, fan */
 631 static ssize_t
 632 show_alarms_reg(struct device *dev, struct device_attribute *attr, char *buf)
 633 {
 634         struct w83792d_data *data = w83792d_update_device(dev);
 635         return sprintf(buf, "%d\n", data->alarms);
 636 }
 637
 638 static
 639 DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
 640 #define device_create_file_alarms(client) \
 641 device_create_file(&client->dev, &dev_attr_alarms);
 642
 643
 644
 645 static ssize_t
 646 show_pwm(struct device *dev, struct device_attribute *attr,
 647                 char *buf)
 648 {
 649         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 650         int nr = sensor_attr->index;
 651         struct w83792d_data *data = w83792d_update_device(dev);
 652         return sprintf(buf, "%ld\n", (long) PWM_FROM_REG(data->pwm[nr-1]));
 653 }
 654
 655 static ssize_t
 656 show_pwmenable(struct device *dev, struct device_attribute *attr,
 657                         char *buf)
 658 {
 659         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 660         int nr = sensor_attr->index - 1;
 661         struct w83792d_data *data = w83792d_update_device(dev);
 662         long pwm_enable_tmp = 1;
 663
 664         switch (data->pwmenable[nr]) {
 665         case 0:
 666                 pwm_enable_tmp = 1; /* manual mode */
 667                 break;
 668         case 1:
 669                 pwm_enable_tmp = 3; /*thermal cruise/Smart Fan I */
 670                 break;
 671         case 2:
 672                 pwm_enable_tmp = 2; /* Smart Fan II */
 673                 break;
 674         }
 675
 676         return sprintf(buf, "%ld\n", pwm_enable_tmp);
 677 }
 678
 679 static ssize_t
 680 store_pwm(struct device *dev, struct device_attribute *attr,
 681                 const char *buf, size_t count)
 682 {
 683         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 684         int nr = sensor_attr->index - 1;
 685         struct i2c_client *client = to_i2c_client(dev);
 686         struct w83792d_data *data = i2c_get_clientdata(client);
 687         u32 val;
 688
 689         val = simple_strtoul(buf, NULL, 10);
 690         data->pwm[nr] = PWM_TO_REG(val);
 691         w83792d_write_value(client, W83792D_REG_PWM[nr], data->pwm[nr]);
 692
 693         return count;
 694 }
 695
 696 static ssize_t
 697 store_pwmenable(struct device *dev, struct device_attribute *attr,
 698                         const char *buf, size_t count)
 699 {
 700         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 701         int nr = sensor_attr->index - 1;
 702         struct i2c_client *client = to_i2c_client(dev);
 703         struct w83792d_data *data = i2c_get_clientdata(client);
 704         u32 val;
 705         u8 fan_cfg_tmp, cfg1_tmp, cfg2_tmp, cfg3_tmp, cfg4_tmp;
 706
 707         val = simple_strtoul(buf, NULL, 10);
 708         switch (val) {
 709         case 1:
 710                 data->pwmenable[nr] = 0; /* manual mode */
 711                 break;
 712         case 2:
 713                 data->pwmenable[nr] = 2; /* Smart Fan II */
 714                 break;
 715         case 3:
 716                 data->pwmenable[nr] = 1; /* thermal cruise/Smart Fan I */
 717                 break;
 718         default:
 719                 return -EINVAL;
 720         }
 721         cfg1_tmp = data->pwmenable[0];
 722         cfg2_tmp = (data->pwmenable[1]) << 2;
 723         cfg3_tmp = (data->pwmenable[2]) << 4;
 724         cfg4_tmp = w83792d_read_value(client,W83792D_REG_FAN_CFG) & 0xc0;
 725         fan_cfg_tmp = ((cfg4_tmp | cfg3_tmp) | cfg2_tmp) | cfg1_tmp;
 726         w83792d_write_value(client, W83792D_REG_FAN_CFG, fan_cfg_tmp);
 727
 728         return count;
 729 }
 730
 731 #define sysfs_pwm(offset) \
 732 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
 733                                 show_pwm, store_pwm, offset); \
 734 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \
 735                                 show_pwmenable, store_pwmenable, offset); \
 736
 737 sysfs_pwm(1);
 738 sysfs_pwm(2);
 739 sysfs_pwm(3);
 740
 741
 742 #define device_create_file_pwm(client, offset) \
 743 do { \
 744 device_create_file(&client->dev, &sensor_dev_attr_pwm##offset.dev_attr); \
 745 } while (0)
 746
 747 #define device_create_file_pwmenable(client, offset) \
 748 do { \
 749 device_create_file(&client->dev, &sensor_dev_attr_pwm##offset##_enable.dev_attr); \
 750 } while (0)
 751
 752
 753 static ssize_t
 754 show_pwm_mode(struct device *dev, struct device_attribute *attr,
 755                         char *buf)
 756 {
 757         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 758         int nr = sensor_attr->index;
 759         struct w83792d_data *data = w83792d_update_device(dev);
 760         return sprintf(buf, "%d\n", data->pwm_mode[nr-1]);
 761 }
 762
 763 static ssize_t
 764 store_pwm_mode(struct device *dev, struct device_attribute *attr,
 765                         const char *buf, size_t count)
 766 {
 767         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 768         int nr = sensor_attr->index - 1;
 769         struct i2c_client *client = to_i2c_client(dev);
 770         struct w83792d_data *data = i2c_get_clientdata(client);
 771         u32 val;
 772         u8 pwm_mode_mask = 0;
 773
 774         val = simple_strtoul(buf, NULL, 10);
 775         data->pwm_mode[nr] = SENSORS_LIMIT(val, 0, 1);
 776         pwm_mode_mask = w83792d_read_value(client,
 777                 W83792D_REG_PWM[nr]) & 0x7f;
 778         w83792d_write_value(client, W83792D_REG_PWM[nr],
 779                 ((data->pwm_mode[nr]) << 7) | pwm_mode_mask);
 780
 781         return count;
 782 }
 783
 784 #define sysfs_pwm_mode(offset) \
 785 static SENSOR_DEVICE_ATTR(pwm##offset##_mode, S_IRUGO | S_IWUSR, \
 786                                 show_pwm_mode, store_pwm_mode, offset);
 787
 788 sysfs_pwm_mode(1);
 789 sysfs_pwm_mode(2);
 790 sysfs_pwm_mode(3);
 791
 792 #define device_create_file_pwm_mode(client, offset) \
 793 do { \
 794 device_create_file(&client->dev, &sensor_dev_attr_pwm##offset##_mode.dev_attr); \
 795 } while (0)
 796
 797
 798 static ssize_t
 799 show_regs_chassis(struct device *dev, struct device_attribute *attr,
 800                         char *buf)
 801 {
 802         struct w83792d_data *data = w83792d_update_device(dev);
 803         return sprintf(buf, "%d\n", data->chassis);
 804 }
 805
 806 static DEVICE_ATTR(chassis, S_IRUGO, show_regs_chassis, NULL);
 807
 808 #define device_create_file_chassis(client) \
 809 do { \
 810 device_create_file(&client->dev, &dev_attr_chassis); \
 811 } while (0)
 812
 813
 814 static ssize_t
 815 show_chassis_clear(struct device *dev, struct device_attribute *attr, char *buf)
 816 {
 817         struct w83792d_data *data = w83792d_update_device(dev);
 818         return sprintf(buf, "%d\n", data->chassis_clear);
 819 }
 820
 821 static ssize_t
 822 store_chassis_clear(struct device *dev, struct device_attribute *attr,
 823                         const char *buf, size_t count)
 824 {
 825         struct i2c_client *client = to_i2c_client(dev);
 826         struct w83792d_data *data = i2c_get_clientdata(client);
 827         u32 val;
 828         u8 temp1 = 0, temp2 = 0;
 829
 830         val = simple_strtoul(buf, NULL, 10);
 831
 832         data->chassis_clear = SENSORS_LIMIT(val, 0 ,1);
 833         temp1 = ((data->chassis_clear) << 7) & 0x80;
 834         temp2 = w83792d_read_value(client,
 835                 W83792D_REG_CHASSIS_CLR) & 0x7f;
 836         w83792d_write_value(client, W83792D_REG_CHASSIS_CLR, temp1 | temp2);
 837
 838         return count;
 839 }
 840
 841 static DEVICE_ATTR(chassis_clear, S_IRUGO | S_IWUSR,
 842                 show_chassis_clear, store_chassis_clear);
 843
 844 #define device_create_file_chassis_clear(client) \
 845 do { \
 846 device_create_file(&client->dev, &dev_attr_chassis_clear); \
 847 } while (0)
 848
 849
 850
 851 /* For Smart Fan I / Thermal Cruise */
 852 static ssize_t
 853 show_thermal_cruise(struct device *dev, struct device_attribute *attr,
 854                         char *buf)
 855 {
 856         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 857         int nr = sensor_attr->index;
 858         struct w83792d_data *data = w83792d_update_device(dev);
 859         return sprintf(buf, "%ld\n", (long)data->thermal_cruise[nr-1]);
 860 }
 861
 862 static ssize_t
 863 store_thermal_cruise(struct device *dev, struct device_attribute *attr,
 864                         const char *buf, size_t count)
 865 {
 866         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 867         int nr = sensor_attr->index - 1;
 868         struct i2c_client *client = to_i2c_client(dev);
 869         struct w83792d_data *data = i2c_get_clientdata(client);
 870         u32 val;
 871         u8 target_tmp=0, target_mask=0;
 872
 873         val = simple_strtoul(buf, NULL, 10);
 874         target_tmp = val;
 875         target_tmp = target_tmp & 0x7f;
 876         target_mask = w83792d_read_value(client, W83792D_REG_THERMAL[nr]) & 0x80;
 877         data->thermal_cruise[nr] = SENSORS_LIMIT(target_tmp, 0, 255);
 878         w83792d_write_value(client, W83792D_REG_THERMAL[nr],
 879                 (data->thermal_cruise[nr]) | target_mask);
 880
 881         return count;
 882 }
 883
 884 #define sysfs_thermal_cruise(offset) \
 885 static SENSOR_DEVICE_ATTR(thermal_cruise##offset, S_IRUGO | S_IWUSR, \
 886                         show_thermal_cruise, store_thermal_cruise, offset);
 887
 888 sysfs_thermal_cruise(1);
 889 sysfs_thermal_cruise(2);
 890 sysfs_thermal_cruise(3);
 891
 892 #define device_create_file_thermal_cruise(client, offset) \
 893 do { \
 894 device_create_file(&client->dev, \
 895 &sensor_dev_attr_thermal_cruise##offset.dev_attr); \
 896 } while (0)
 897
 898
 899 /* For Smart Fan I/Thermal Cruise and Smart Fan II */
 900 static ssize_t
 901 show_tolerance(struct device *dev, struct device_attribute *attr,
 902                 char *buf)
 903 {
 904         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 905         int nr = sensor_attr->index;
 906         struct w83792d_data *data = w83792d_update_device(dev);
 907         return sprintf(buf, "%ld\n", (long)data->tolerance[nr-1]);
 908 }
 909
 910 static ssize_t
 911 store_tolerance(struct device *dev, struct device_attribute *attr,
 912                 const char *buf, size_t count)
 913 {
 914         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 915         int nr = sensor_attr->index - 1;
 916         struct i2c_client *client = to_i2c_client(dev);
 917         struct w83792d_data *data = i2c_get_clientdata(client);
 918         u32 val;
 919         u8 tol_tmp, tol_mask;
 920
 921         val = simple_strtoul(buf, NULL, 10);
 922         tol_mask = w83792d_read_value(client,
 923                 W83792D_REG_TOLERANCE[nr]) & ((nr == 1) ? 0x0f : 0xf0);
 924         tol_tmp = SENSORS_LIMIT(val, 0, 15);
 925         tol_tmp &= 0x0f;
 926         data->tolerance[nr] = tol_tmp;
 927         if (nr == 1) {
 928                 tol_tmp <<= 4;
 929         }
 930         w83792d_write_value(client, W83792D_REG_TOLERANCE[nr],
 931                 tol_mask | tol_tmp);
 932
 933         return count;
 934 }
 935
 936 #define sysfs_tolerance(offset) \
 937 static SENSOR_DEVICE_ATTR(tolerance##offset, S_IRUGO | S_IWUSR, \
 938                                 show_tolerance, store_tolerance, offset);
 939
 940 sysfs_tolerance(1);
 941 sysfs_tolerance(2);
 942 sysfs_tolerance(3);
 943
 944 #define device_create_file_tolerance(client, offset) \
 945 do { \
 946 device_create_file(&client->dev, &sensor_dev_attr_tolerance##offset.dev_attr); \
 947 } while (0)
 948
 949
 950 /* For Smart Fan II */
 951 static ssize_t
 952 show_sf2_point(struct device *dev, struct device_attribute *attr,
 953                 char *buf)
 954 {
 955         struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr);
 956         int nr = sensor_attr->nr;
 957         int index = sensor_attr->index;
 958         struct w83792d_data *data = w83792d_update_device(dev);
 959         return sprintf(buf, "%ld\n", (long)data->sf2_points[index-1][nr-1]);
 960 }
 961
 962 static ssize_t
 963 store_sf2_point(struct device *dev, struct device_attribute *attr,
 964                 const char *buf, size_t count)
 965 {
 966         struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr);
 967         int nr = sensor_attr->nr - 1;
 968         int index = sensor_attr->index - 1;
 969         struct i2c_client *client = to_i2c_client(dev);
 970         struct w83792d_data *data = i2c_get_clientdata(client);
 971         u32 val;
 972         u8 mask_tmp = 0;
 973
 974         val = simple_strtoul(buf, NULL, 10);
 975         data->sf2_points[index][nr] = SENSORS_LIMIT(val, 0, 127);
 976         mask_tmp = w83792d_read_value(client,
 977                                         W83792D_REG_POINTS[index][nr]) & 0x80;
 978         w83792d_write_value(client, W83792D_REG_POINTS[index][nr],
 979                 mask_tmp|data->sf2_points[index][nr]);
 980
 981         return count;
 982 }
 983
 984 #define sysfs_sf2_point(offset, index) \
 985 static SENSOR_DEVICE_ATTR_2(sf2_point##offset##_fan##index, S_IRUGO | S_IWUSR, \
 986                                 show_sf2_point, store_sf2_point, offset, index);
 987
 988 sysfs_sf2_point(1, 1);  /* Fan1 */
 989 sysfs_sf2_point(2, 1);  /* Fan1 */
 990 sysfs_sf2_point(3, 1);  /* Fan1 */
 991 sysfs_sf2_point(4, 1);  /* Fan1 */
 992 sysfs_sf2_point(1, 2);  /* Fan2 */
 993 sysfs_sf2_point(2, 2);  /* Fan2 */
 994 sysfs_sf2_point(3, 2);  /* Fan2 */
 995 sysfs_sf2_point(4, 2);  /* Fan2 */
 996 sysfs_sf2_point(1, 3);  /* Fan3 */
 997 sysfs_sf2_point(2, 3);  /* Fan3 */
 998 sysfs_sf2_point(3, 3);  /* Fan3 */
 999 sysfs_sf2_point(4, 3);  /* Fan3 */
1000
1001 #define device_create_file_sf2_point(client, offset, index) \
1002 do { \
1003 device_create_file(&client->dev, \
1004 &sensor_dev_attr_sf2_point##offset##_fan##index.dev_attr); \
1005 } while (0)
1006
1007
1008 static ssize_t
1009 show_sf2_level(struct device *dev, struct device_attribute *attr,
1010                 char *buf)
1011 {
1012         struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr);
1013         int nr = sensor_attr->nr;
1014         int index = sensor_attr->index;
1015         struct w83792d_data *data = w83792d_update_device(dev);
1016         return sprintf(buf, "%d\n",
1017                         (((data->sf2_levels[index-1][nr]) * 100) / 15));
1018 }
1019
1020 static ssize_t
1021 store_sf2_level(struct device *dev, struct device_attribute *attr,
1022                 const char *buf, size_t count)
1023 {
1024         struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr);
1025         int nr = sensor_attr->nr;
1026         int index = sensor_attr->index - 1;
1027         struct i2c_client *client = to_i2c_client(dev);
1028         struct w83792d_data *data = i2c_get_clientdata(client);
1029         u32 val;
1030         u8 mask_tmp=0, level_tmp=0;
1031
1032         val = simple_strtoul(buf, NULL, 10);
1033         data->sf2_levels[index][nr] = SENSORS_LIMIT((val * 15) / 100, 0, 15);
1034         mask_tmp = w83792d_read_value(client, W83792D_REG_LEVELS[index][nr])
1035                 & ((nr==3) ? 0xf0 : 0x0f);
1036         if (nr==3) {
1037                 level_tmp = data->sf2_levels[index][nr];
1038         } else {
1039                 level_tmp = data->sf2_levels[index][nr] << 4;
1040         }
1041         w83792d_write_value(client, W83792D_REG_LEVELS[index][nr], level_tmp | mask_tmp);
1042
1043         return count;
1044 }
1045
1046 #define sysfs_sf2_level(offset, index) \
1047 static SENSOR_DEVICE_ATTR_2(sf2_level##offset##_fan##index, S_IRUGO | S_IWUSR, \
1048                                 show_sf2_level, store_sf2_level, offset, index);
1049
1050 sysfs_sf2_level(1, 1);  /* Fan1 */
1051 sysfs_sf2_level(2, 1);  /* Fan1 */
1052 sysfs_sf2_level(3, 1);  /* Fan1 */
1053 sysfs_sf2_level(1, 2);  /* Fan2 */
1054 sysfs_sf2_level(2, 2);  /* Fan2 */
1055 sysfs_sf2_level(3, 2);  /* Fan2 */
1056 sysfs_sf2_level(1, 3);  /* Fan3 */
1057 sysfs_sf2_level(2, 3);  /* Fan3 */
1058 sysfs_sf2_level(3, 3);  /* Fan3 */
1059
1060 #define device_create_file_sf2_level(client, offset, index) \
1061 do { \
1062 device_create_file(&client->dev, \
1063 &sensor_dev_attr_sf2_level##offset##_fan##index.dev_attr); \
1064 } while (0)
1065
1066
1067 /* This function is called when:
1068      * w83792d_driver is inserted (when this module is loaded), for each
1069        available adapter
1070      * when a new adapter is inserted (and w83792d_driver is still present) */
1071 static int
1072 w83792d_attach_adapter(struct i2c_adapter *adapter)
1073 {
1074         if (!(adapter->class & I2C_CLASS_HWMON))
1075                 return 0;
1076         return i2c_detect(adapter, &addr_data, w83792d_detect);
1077 }
1078
1079
1080 static int
1081 w83792d_create_subclient(struct i2c_adapter *adapter,
1082                                 struct i2c_client *new_client, int addr,
1083                                 struct i2c_client **sub_cli)
1084 {
1085         int err;
1086         struct i2c_client *sub_client;
1087
1088         (*sub_cli) = sub_client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
1089         if (!(sub_client)) {
1090                 return -ENOMEM;
1091         }
1092         memset(sub_client, 0x00, sizeof(struct i2c_client));
1093         sub_client->addr = 0x48 + addr;
1094         i2c_set_clientdata(sub_client, NULL);
1095         sub_client->adapter = adapter;
1096         sub_client->driver = &w83792d_driver;
1097         sub_client->flags = 0;
1098         strlcpy(sub_client->name, "w83792d subclient", I2C_NAME_SIZE);
1099         if ((err = i2c_attach_client(sub_client))) {
1100                 dev_err(&new_client->dev, "subclient registration "
1101                         "at address 0x%x failed\n", sub_client->addr);
1102                 kfree(sub_client);
1103                 return err;
1104         }
1105         return 0;
1106 }
1107
1108
1109 static int
1110 w83792d_detect_subclients(struct i2c_adapter *adapter, int address, int kind,
1111                 struct i2c_client *new_client)
1112 {
1113         int i, id, err;
1114         u8 val;
1115         struct w83792d_data *data = i2c_get_clientdata(new_client);
1116
1117         id = i2c_adapter_id(adapter);
1118         if (force_subclients[0] == id && force_subclients[1] == address) {
1119                 for (i = 2; i <= 3; i++) {
1120                         if (force_subclients[i] < 0x48 ||
1121                             force_subclients[i] > 0x4f) {
1122                                 dev_err(&new_client->dev, "invalid subclient "
1123                                         "address %d; must be 0x48-0x4f\n",
1124                                         force_subclients[i]);
1125                                 err = -ENODEV;
1126                                 goto ERROR_SC_0;
1127                         }
1128                 }
1129                 w83792d_write_value(new_client, W83792D_REG_I2C_SUBADDR,
1130                                         (force_subclients[2] & 0x07) |
1131                                         ((force_subclients[3] & 0x07) << 4));
1132         }
1133
1134         val = w83792d_read_value(new_client, W83792D_REG_I2C_SUBADDR);
1135         if (!(val & 0x08)) {
1136                 err = w83792d_create_subclient(adapter, new_client, val & 0x7,
1137                                                 &data->lm75[0]);
1138                 if (err < 0)
1139                         goto ERROR_SC_0;
1140         }
1141         if (!(val & 0x80)) {
1142                 if ((data->lm75[0] != NULL) &&
1143                         ((val & 0x7) == ((val >> 4) & 0x7))) {
1144                         dev_err(&new_client->dev, "duplicate addresses 0x%x, "
1145                                 "use force_subclient\n", data->lm75[0]->addr);
1146                         err = -ENODEV;
1147                         goto ERROR_SC_1;
1148                 }
1149                 err = w83792d_create_subclient(adapter, new_client,
1150                                                 (val >> 4) & 0x7, &data->lm75[1]);
1151                 if (err < 0)
1152                         goto ERROR_SC_1;
1153         }
1154
1155         return 0;
1156
1157 /* Undo inits in case of errors */
1158
1159 ERROR_SC_1:
1160         if (data->lm75[0] != NULL) {
1161                 i2c_detach_client(data->lm75[0]);
1162                 kfree(data->lm75[0]);
1163         }
1164 ERROR_SC_0:
1165         return err;
1166 }
1167
1168
1169 static int
1170 w83792d_detect(struct i2c_adapter *adapter, int address, int kind)
1171 {
1172         int i = 0, val1 = 0, val2;
1173         struct i2c_client *new_client;
1174         struct w83792d_data *data;
1175         int err = 0;
1176         const char *client_name = "";
1177
1178         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1179                 goto ERROR0;
1180         }
1181
1182         /* OK. For now, we presume we have a valid client. We now create the
1183            client structure, even though we cannot fill it completely yet.
1184            But it allows us to access w83792d_{read,write}_value. */
1185
1186         if (!(data = kmalloc(sizeof(struct w83792d_data), GFP_KERNEL))) {
1187                 err = -ENOMEM;
1188                 goto ERROR0;
1189         }
1190         memset(data, 0, sizeof(struct w83792d_data));
1191
1192         new_client = &data->client;
1193         i2c_set_clientdata(new_client, data);
1194         new_client->addr = address;
1195         init_MUTEX(&data->lock);
1196         new_client->adapter = adapter;
1197         new_client->driver = &w83792d_driver;
1198         new_client->flags = 0;
1199
1200         /* Now, we do the remaining detection. */
1201
1202         /* The w83792d may be stuck in some other bank than bank 0. This may
1203            make reading other information impossible. Specify a force=... or
1204            force_*=... parameter, and the Winbond will be reset to the right
1205            bank. */
1206         if (kind < 0) {
1207                 if (w83792d_read_value(new_client, W83792D_REG_CONFIG) & 0x80) {
1208                         dev_warn(&new_client->dev, "Detection failed at step "
1209                                 "3\n");
1210                         goto ERROR1;
1211                 }
1212                 val1 = w83792d_read_value(new_client, W83792D_REG_BANK);
1213                 val2 = w83792d_read_value(new_client, W83792D_REG_CHIPMAN);
1214                 /* Check for Winbond ID if in bank 0 */
1215                 if (!(val1 & 0x07)) {  /* is Bank0 */
1216                         if (((!(val1 & 0x80)) && (val2 != 0xa3)) ||
1217                              ((val1 & 0x80) && (val2 != 0x5c))) {
1218                                 goto ERROR1;
1219                         }
1220                 }
1221                 /* If Winbond chip, address of chip and W83792D_REG_I2C_ADDR
1222                    should match */
1223                 if (w83792d_read_value(new_client,
1224                                         W83792D_REG_I2C_ADDR) != address) {
1225                         dev_warn(&new_client->dev, "Detection failed "
1226                                 "at step 5\n");
1227                         goto ERROR1;
1228                 }
1229         }
1230
1231         /* We have either had a force parameter, or we have already detected the
1232            Winbond. Put it now into bank 0 and Vendor ID High Byte */
1233         w83792d_write_value(new_client,
1234                             W83792D_REG_BANK,
1235                             (w83792d_read_value(new_client,
1236                                 W83792D_REG_BANK) & 0x78) | 0x80);
1237
1238         /* Determine the chip type. */
1239         if (kind <= 0) {
1240                 /* get vendor ID */
1241                 val2 = w83792d_read_value(new_client, W83792D_REG_CHIPMAN);
1242                 if (val2 != 0x5c) {  /* the vendor is NOT Winbond */
1243                         goto ERROR1;
1244                 }
1245                 val1 = w83792d_read_value(new_client, W83792D_REG_WCHIPID);
1246                 if (val1 == 0x7a && address >= 0x2c) {
1247                         kind = w83792d;
1248                 } else {
1249                         if (kind == 0)
1250                                         dev_warn(&new_client->dev,
1251                                         "w83792d: Ignoring 'force' parameter for"
1252                                         " unknown chip at adapter %d, address"
1253                                         " 0x%02x\n", i2c_adapter_id(adapter),
1254                                         address);
1255                         goto ERROR1;
1256                 }
1257         }
1258
1259         if (kind == w83792d) {
1260                 client_name = "w83792d";
1261         } else {
1262                 dev_err(&new_client->dev, "w83792d: Internal error: unknown"
1263                                           " kind (%d)?!?", kind);
1264                 goto ERROR1;
1265         }
1266
1267         /* Fill in the remaining client fields and put into the global list */
1268         strlcpy(new_client->name, client_name, I2C_NAME_SIZE);
1269         data->type = kind;
1270
1271         data->valid = 0;
1272         init_MUTEX(&data->update_lock);
1273
1274         /* Tell the I2C layer a new client has arrived */
1275         if ((err = i2c_attach_client(new_client)))
1276                 goto ERROR1;
1277
1278         if ((err = w83792d_detect_subclients(adapter, address,
1279                         kind, new_client)))
1280                 goto ERROR2;
1281
1282         /* Initialize the chip */
1283         w83792d_init_client(new_client);
1284
1285         /* A few vars need to be filled upon startup */
1286         for (i = 1; i <= 7; i++) {
1287                 data->fan_min[i - 1] = w83792d_read_value(new_client,
1288                                         W83792D_REG_FAN_MIN[i]);
1289         }
1290
1291         /* Register sysfs hooks */
1292         device_create_file_in(new_client, 0);
1293         device_create_file_in(new_client, 1);
1294         device_create_file_in(new_client, 2);
1295         device_create_file_in(new_client, 3);
1296         device_create_file_in(new_client, 4);
1297         device_create_file_in(new_client, 5);
1298         device_create_file_in(new_client, 6);
1299         device_create_file_in(new_client, 7);
1300         device_create_file_in(new_client, 8);
1301
1302         device_create_file_fan(new_client, 1);
1303         device_create_file_fan(new_client, 2);
1304         device_create_file_fan(new_client, 3);
1305         device_create_file_fan(new_client, 4);
1306         device_create_file_fan(new_client, 5);
1307         device_create_file_fan(new_client, 6);
1308         device_create_file_fan(new_client, 7);
1309
1310         device_create_file_temp1(new_client);           /* Temp1 */
1311         device_create_file_temp_add(new_client, 2);     /* Temp2 */
1312         device_create_file_temp_add(new_client, 3);     /* Temp3 */
1313
1314         device_create_file_alarms(new_client);
1315
1316         device_create_file_pwm(new_client, 1);
1317         device_create_file_pwm(new_client, 2);
1318         device_create_file_pwm(new_client, 3);
1319
1320         device_create_file_pwmenable(new_client, 1);
1321         device_create_file_pwmenable(new_client, 2);
1322         device_create_file_pwmenable(new_client, 3);
1323
1324         device_create_file_pwm_mode(new_client, 1);
1325         device_create_file_pwm_mode(new_client, 2);
1326         device_create_file_pwm_mode(new_client, 3);
1327
1328         device_create_file_chassis(new_client);
1329         device_create_file_chassis_clear(new_client);
1330
1331         device_create_file_thermal_cruise(new_client, 1);
1332         device_create_file_thermal_cruise(new_client, 2);
1333         device_create_file_thermal_cruise(new_client, 3);
1334
1335         device_create_file_tolerance(new_client, 1);
1336         device_create_file_tolerance(new_client, 2);
1337         device_create_file_tolerance(new_client, 3);
1338
1339         device_create_file_sf2_point(new_client, 1, 1); /* Fan1 */
1340         device_create_file_sf2_point(new_client, 2, 1); /* Fan1 */
1341         device_create_file_sf2_point(new_client, 3, 1); /* Fan1 */
1342         device_create_file_sf2_point(new_client, 4, 1); /* Fan1 */
1343         device_create_file_sf2_point(new_client, 1, 2); /* Fan2 */
1344         device_create_file_sf2_point(new_client, 2, 2); /* Fan2 */
1345         device_create_file_sf2_point(new_client, 3, 2); /* Fan2 */
1346         device_create_file_sf2_point(new_client, 4, 2); /* Fan2 */
1347         device_create_file_sf2_point(new_client, 1, 3); /* Fan3 */
1348         device_create_file_sf2_point(new_client, 2, 3); /* Fan3 */
1349         device_create_file_sf2_point(new_client, 3, 3); /* Fan3 */
1350         device_create_file_sf2_point(new_client, 4, 3); /* Fan3 */
1351
1352         device_create_file_sf2_level(new_client, 1, 1); /* Fan1 */
1353         device_create_file_sf2_level(new_client, 2, 1); /* Fan1 */
1354         device_create_file_sf2_level(new_client, 3, 1); /* Fan1 */
1355         device_create_file_sf2_level(new_client, 1, 2); /* Fan2 */
1356         device_create_file_sf2_level(new_client, 2, 2); /* Fan2 */
1357         device_create_file_sf2_level(new_client, 3, 2); /* Fan2 */
1358         device_create_file_sf2_level(new_client, 1, 3); /* Fan3 */
1359         device_create_file_sf2_level(new_client, 2, 3); /* Fan3 */
1360         device_create_file_sf2_level(new_client, 3, 3); /* Fan3 */
1361
1362         return 0;
1363
1364 ERROR2:
1365         i2c_detach_client(new_client);
1366 ERROR1:
1367         kfree(data);
1368 ERROR0:
1369         return err;
1370 }
1371
1372 static int
1373 w83792d_detach_client(struct i2c_client *client)
1374 {
1375         int err;
1376
1377         if ((err = i2c_detach_client(client))) {
1378                 dev_err(&client->dev,
1379                         "Client deregistration failed, client not detached.\n");
1380                 return err;
1381         }
1382
1383         if (i2c_get_clientdata(client)==NULL) {
1384                 /* subclients */
1385                 kfree(client);
1386         } else {
1387                 /* main client */
1388                 kfree(i2c_get_clientdata(client));
1389         }
1390
1391         return 0;
1392 }
1393
1394 /* The SMBus locks itself, usually, but nothing may access the Winbond between
1395    bank switches. ISA access must always be locked explicitly!
1396    We ignore the W83792D BUSY flag at this moment - it could lead to deadlocks,
1397    would slow down the W83792D access and should not be necessary.
1398    There are some ugly typecasts here, but the good news is - they should
1399    nowhere else be necessary! */
1400 static int
1401 w83792d_read_value(struct i2c_client *client, u8 reg)
1402 {
1403         int res=0;
1404         res = i2c_smbus_read_byte_data(client, reg);
1405
1406         return res;
1407 }
1408
1409 static int
1410 w83792d_write_value(struct i2c_client *client, u8 reg, u8 value)
1411 {
1412         i2c_smbus_write_byte_data(client, reg,  value);
1413         return 0;
1414 }
1415
1416 /* Called when we have found a new W83792D. It should set limits, etc. */
1417 static void
1418 w83792d_init_client(struct i2c_client *client)
1419 {
1420         u8 temp2_cfg, temp3_cfg, vid_in_b;
1421
1422         if (init) {
1423                 w83792d_write_value(client, W83792D_REG_CONFIG, 0x80);
1424         }
1425         /* Clear the bit6 of W83792D_REG_VID_IN_B(set it into 0):
1426            W83792D_REG_VID_IN_B bit6 = 0: the high/low limit of
1427              vin0/vin1 can be modified by user;
1428            W83792D_REG_VID_IN_B bit6 = 1: the high/low limit of
1429              vin0/vin1 auto-updated, can NOT be modified by user. */
1430         vid_in_b = w83792d_read_value(client, W83792D_REG_VID_IN_B);
1431         w83792d_write_value(client, W83792D_REG_VID_IN_B,
1432                             vid_in_b & 0xbf);
1433
1434         temp2_cfg = w83792d_read_value(client, W83792D_REG_TEMP2_CONFIG);
1435         temp3_cfg = w83792d_read_value(client, W83792D_REG_TEMP3_CONFIG);
1436         w83792d_write_value(client, W83792D_REG_TEMP2_CONFIG,
1437                                 temp2_cfg & 0xe6);
1438         w83792d_write_value(client, W83792D_REG_TEMP3_CONFIG,
1439                                 temp3_cfg & 0xe6);
1440
1441         /* Start monitoring */
1442         w83792d_write_value(client, W83792D_REG_CONFIG,
1443                             (w83792d_read_value(client,
1444                                                 W83792D_REG_CONFIG) & 0xf7)
1445                             | 0x01);
1446 }
1447
1448 static struct w83792d_data *w83792d_update_device(struct device *dev)
1449 {
1450         struct i2c_client *client = to_i2c_client(dev);
1451         struct w83792d_data *data = i2c_get_clientdata(client);
1452         int i, j;
1453         u8 reg_array_tmp[4], pwm_array_tmp[7], reg_tmp;
1454
1455         down(&data->update_lock);
1456
1457         if (time_after
1458             (jiffies - data->last_updated, (unsigned long) (HZ * 3))
1459             || time_before(jiffies, data->last_updated) || !data->valid) {
1460                 dev_dbg(dev, "Starting device update\n");
1461
1462                 /* Update the voltages measured value and limits */
1463                 for (i = 0; i < 9; i++) {
1464                         data->in[i] = w83792d_read_value(client,
1465                                                 W83792D_REG_IN[i]);
1466                         data->in_max[i] = w83792d_read_value(client,
1467                                                 W83792D_REG_IN_MAX[i]);
1468                         data->in_min[i] = w83792d_read_value(client,
1469                                                 W83792D_REG_IN_MIN[i]);
1470                 }
1471                 data->low_bits[0] = w83792d_read_value(client,
1472                                                 W83792D_REG_LOW_BITS1);
1473                 data->low_bits[1] = w83792d_read_value(client,
1474                                                 W83792D_REG_LOW_BITS2);
1475                 for (i = 0; i < 7; i++) {
1476                         /* Update the Fan measured value and limits */
1477                         data->fan[i] = w83792d_read_value(client,
1478                                                 W83792D_REG_FAN[i]);
1479                         data->fan_min[i] = w83792d_read_value(client,
1480                                                 W83792D_REG_FAN_MIN[i]);
1481                         /* Update the PWM/DC Value and PWM/DC flag */
1482                         pwm_array_tmp[i] = w83792d_read_value(client,
1483                                                 W83792D_REG_PWM[i]);
1484                         data->pwm[i] = pwm_array_tmp[i] & 0x0f;
1485                         data->pwm_mode[i] = (pwm_array_tmp[i] >> 7) & 0x01;
1486                 }
1487
1488                 reg_tmp = w83792d_read_value(client, W83792D_REG_FAN_CFG);
1489                 data->pwmenable[0] = reg_tmp & 0x03;
1490                 data->pwmenable[1] = (reg_tmp>>2) & 0x03;
1491                 data->pwmenable[2] = (reg_tmp>>4) & 0x03;
1492
1493                 for (i = 0; i < 3; i++) {
1494                         data->temp1[i] = w83792d_read_value(client,
1495                                                         W83792D_REG_TEMP1[i]);
1496                 }
1497                 for (i = 0; i < 2; i++) {
1498                         for (j = 0; j < 6; j++) {
1499                                 data->temp_add[i][j] = w83792d_read_value(
1500                                         client,W83792D_REG_TEMP_ADD[i][j]);
1501                         }
1502                 }
1503
1504                 /* Update the Fan Divisor */
1505                 for (i = 0; i < 4; i++) {
1506                         reg_array_tmp[i] = w83792d_read_value(client,
1507                                                         W83792D_REG_FAN_DIV[i]);
1508                 }
1509                 data->fan_div[0] = reg_array_tmp[0] & 0x07;
1510                 data->fan_div[1] = (reg_array_tmp[0] >> 4) & 0x07;
1511                 data->fan_div[2] = reg_array_tmp[1] & 0x07;
1512                 data->fan_div[3] = (reg_array_tmp[1] >> 4) & 0x07;
1513                 data->fan_div[4] = reg_array_tmp[2] & 0x07;
1514                 data->fan_div[5] = (reg_array_tmp[2] >> 4) & 0x07;
1515                 data->fan_div[6] = reg_array_tmp[3] & 0x07;
1516
1517                 /* Update the realtime status */
1518                 data->alarms = w83792d_read_value(client, W83792D_REG_ALARM1) +
1519                         (w83792d_read_value(client, W83792D_REG_ALARM2) << 8) +
1520                         (w83792d_read_value(client, W83792D_REG_ALARM3) << 16);
1521
1522                 /* Update CaseOpen status and it's CLR_CHS. */
1523                 data->chassis = (w83792d_read_value(client,
1524                         W83792D_REG_CHASSIS) >> 5) & 0x01;
1525                 data->chassis_clear = (w83792d_read_value(client,
1526                         W83792D_REG_CHASSIS_CLR) >> 7) & 0x01;
1527
1528                 /* Update Thermal Cruise/Smart Fan I target value */
1529                 for (i = 0; i < 3; i++) {
1530                         data->thermal_cruise[i] =
1531                                 w83792d_read_value(client,
1532                                 W83792D_REG_THERMAL[i]) & 0x7f;
1533                 }
1534
1535                 /* Update Smart Fan I/II tolerance */
1536                 reg_tmp = w83792d_read_value(client, W83792D_REG_TOLERANCE[0]);
1537                 data->tolerance[0] = reg_tmp & 0x0f;
1538                 data->tolerance[1] = (reg_tmp >> 4) & 0x0f;
1539                 data->tolerance[2] = w83792d_read_value(client,
1540                                         W83792D_REG_TOLERANCE[2]) & 0x0f;
1541
1542                 /* Update Smart Fan II temperature points */
1543                 for (i = 0; i < 3; i++) {
1544                         for (j = 0; j < 4; j++) {
1545                                 data->sf2_points[i][j] = w83792d_read_value(
1546                                         client,W83792D_REG_POINTS[i][j]) & 0x7f;
1547                         }
1548                 }
1549
1550                 /* Update Smart Fan II duty cycle levels */
1551                 for (i = 0; i < 3; i++) {
1552                         reg_tmp = w83792d_read_value(client,
1553                                                 W83792D_REG_LEVELS[i][0]);
1554                         data->sf2_levels[i][0] = reg_tmp & 0x0f;
1555                         data->sf2_levels[i][1] = (reg_tmp >> 4) & 0x0f;
1556                         reg_tmp = w83792d_read_value(client,
1557                                                 W83792D_REG_LEVELS[i][2]);
1558                         data->sf2_levels[i][2] = (reg_tmp >> 4) & 0x0f;
1559                         data->sf2_levels[i][3] = reg_tmp & 0x0f;
1560                 }
1561
1562                 data->last_updated = jiffies;
1563                 data->valid = 1;
1564         }
1565
1566         up(&data->update_lock);
1567
1568 #ifdef DEBUG
1569         w83792d_print_debug(data, dev);
1570 #endif
1571
1572         return data;
1573 }
1574
1575 #ifdef DEBUG
1576 static void w83792d_print_debug(struct w83792d_data *data, struct device *dev)
1577 {
1578         int i=0, j=0;
1579         dev_dbg(dev, "==========The following is the debug message...========\n");
1580         dev_dbg(dev, "9 set of Voltages: =====>\n");
1581         for (i=0; i<9; i++) {
1582                 dev_dbg(dev, "vin[%d] is: 0x%x\n", i, data->in[i]);
1583                 dev_dbg(dev, "vin[%d] max is: 0x%x\n", i, data->in_max[i]);
1584                 dev_dbg(dev, "vin[%d] min is: 0x%x\n", i, data->in_min[i]);
1585         }
1586         dev_dbg(dev, "Low Bit1 is: 0x%x\n", data->low_bits[0]);
1587         dev_dbg(dev, "Low Bit2 is: 0x%x\n", data->low_bits[1]);
1588         dev_dbg(dev, "7 set of Fan Counts and Duty Cycles: =====>\n");
1589         for (i=0; i<7; i++) {
1590                 dev_dbg(dev, "fan[%d] is: 0x%x\n", i, data->fan[i]);
1591                 dev_dbg(dev, "fan[%d] min is: 0x%x\n", i, data->fan_min[i]);
1592                 dev_dbg(dev, "pwm[%d]     is: 0x%x\n", i, data->pwm[i]);
1593                 dev_dbg(dev, "pwm_mode[%d] is: 0x%x\n", i, data->pwm_mode[i]);
1594         }
1595         dev_dbg(dev, "3 set of Temperatures: =====>\n");
1596         for (i=0; i<3; i++) {
1597                 dev_dbg(dev, "temp1[%d] is: 0x%x\n", i, data->temp1[i]);
1598         }
1599
1600         for (i=0; i<2; i++) {
1601                 for (j=0; j<6; j++) {
1602                         dev_dbg(dev, "temp_add[%d][%d] is: 0x%x\n", i, j,
1603                                                         data->temp_add[i][j]);
1604                 }
1605         }
1606
1607         for (i=0; i<7; i++) {
1608                 dev_dbg(dev, "fan_div[%d] is: 0x%x\n", i, data->fan_div[i]);
1609         }
1610         dev_dbg(dev, "==========End of the debug message...==================\n");
1611         dev_dbg(dev, "\n");
1612 }
1613 #endif
1614
1615 static int __init
1616 sensors_w83792d_init(void)
1617 {
1618         return i2c_add_driver(&w83792d_driver);
1619 }
1620
1621 static void __exit
1622 sensors_w83792d_exit(void)
1623 {
1624         i2c_del_driver(&w83792d_driver);
1625 }
1626
1627 MODULE_AUTHOR("Chunhao Huang @ Winbond <DZShen@Winbond.com.tw>");
1628 MODULE_DESCRIPTION("W83792AD/D driver for linux-2.6");
1629 MODULE_LICENSE("GPL");
1630
1631 module_init(sensors_w83792d_init);
1632 module_exit(sensors_w83792d_exit);
1633