2 w83792d.c - Part of lm_sensors, Linux kernel modules for hardware
4 Copyright (C) 2004, 2005 Winbond Electronics Corp.
5 Chunhao Huang <DZShen@Winbond.com.tw>,
6 Rudolf Marek <r.marek@sh.cvut.cz>
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.
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.
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.
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
32 Supports following chips:
34 Chip #vin #fanin #pwm #temp wchipid vendid i2c ISA
35 w83792d 9 7 7 3 0x7a 0x5ca3 yes no
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.h>
46 #include <linux/hwmon-sysfs.h>
47 #include <linux/err.h>
49 /* Addresses to scan */
50 static unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END };
52 /* Insmod parameters */
53 SENSORS_INSMOD_1(w83792d);
54 I2C_CLIENT_MODULE_PARM(force_subclients, "List of subclient addresses: "
55 "{bus, clientaddr, subclientaddr1, subclientaddr2}");
58 module_param(init, bool, 0);
59 MODULE_PARM_DESC(init, "Set to one to force chip initialization");
61 /* The W83792D registers */
62 static const u8 W83792D_REG_IN[9] = {
63 0x20, /* Vcore A in DataSheet */
64 0x21, /* Vcore B in DataSheet */
65 0x22, /* VIN0 in DataSheet */
66 0x23, /* VIN1 in DataSheet */
67 0x24, /* VIN2 in DataSheet */
68 0x25, /* VIN3 in DataSheet */
69 0x26, /* 5VCC in DataSheet */
70 0xB0, /* 5VSB in DataSheet */
71 0xB1 /* VBAT in DataSheet */
73 #define W83792D_REG_LOW_BITS1 0x3E /* Low Bits I in DataSheet */
74 #define W83792D_REG_LOW_BITS2 0x3F /* Low Bits II in DataSheet */
75 static const u8 W83792D_REG_IN_MAX[9] = {
76 0x2B, /* Vcore A High Limit in DataSheet */
77 0x2D, /* Vcore B High Limit in DataSheet */
78 0x2F, /* VIN0 High Limit in DataSheet */
79 0x31, /* VIN1 High Limit in DataSheet */
80 0x33, /* VIN2 High Limit in DataSheet */
81 0x35, /* VIN3 High Limit in DataSheet */
82 0x37, /* 5VCC High Limit in DataSheet */
83 0xB4, /* 5VSB High Limit in DataSheet */
84 0xB6 /* VBAT High Limit in DataSheet */
86 static const u8 W83792D_REG_IN_MIN[9] = {
87 0x2C, /* Vcore A Low Limit in DataSheet */
88 0x2E, /* Vcore B Low Limit in DataSheet */
89 0x30, /* VIN0 Low Limit in DataSheet */
90 0x32, /* VIN1 Low Limit in DataSheet */
91 0x34, /* VIN2 Low Limit in DataSheet */
92 0x36, /* VIN3 Low Limit in DataSheet */
93 0x38, /* 5VCC Low Limit in DataSheet */
94 0xB5, /* 5VSB Low Limit in DataSheet */
95 0xB7 /* VBAT Low Limit in DataSheet */
97 static const u8 W83792D_REG_FAN[7] = {
98 0x28, /* FAN 1 Count in DataSheet */
99 0x29, /* FAN 2 Count in DataSheet */
100 0x2A, /* FAN 3 Count in DataSheet */
101 0xB8, /* FAN 4 Count in DataSheet */
102 0xB9, /* FAN 5 Count in DataSheet */
103 0xBA, /* FAN 6 Count in DataSheet */
104 0xBE /* FAN 7 Count in DataSheet */
106 static const u8 W83792D_REG_FAN_MIN[7] = {
107 0x3B, /* FAN 1 Count Low Limit in DataSheet */
108 0x3C, /* FAN 2 Count Low Limit in DataSheet */
109 0x3D, /* FAN 3 Count Low Limit in DataSheet */
110 0xBB, /* FAN 4 Count Low Limit in DataSheet */
111 0xBC, /* FAN 5 Count Low Limit in DataSheet */
112 0xBD, /* FAN 6 Count Low Limit in DataSheet */
113 0xBF /* FAN 7 Count Low Limit in DataSheet */
115 #define W83792D_REG_FAN_CFG 0x84 /* FAN Configuration in DataSheet */
116 static const u8 W83792D_REG_FAN_DIV[4] = {
117 0x47, /* contains FAN2 and FAN1 Divisor */
118 0x5B, /* contains FAN4 and FAN3 Divisor */
119 0x5C, /* contains FAN6 and FAN5 Divisor */
120 0x9E /* contains FAN7 Divisor. */
122 static const u8 W83792D_REG_PWM[7] = {
123 0x81, /* FAN 1 Duty Cycle, be used to control */
124 0x83, /* FAN 2 Duty Cycle, be used to control */
125 0x94, /* FAN 3 Duty Cycle, be used to control */
126 0xA3, /* FAN 4 Duty Cycle, be used to control */
127 0xA4, /* FAN 5 Duty Cycle, be used to control */
128 0xA5, /* FAN 6 Duty Cycle, be used to control */
129 0xA6 /* FAN 7 Duty Cycle, be used to control */
131 #define W83792D_REG_BANK 0x4E
132 #define W83792D_REG_TEMP2_CONFIG 0xC2
133 #define W83792D_REG_TEMP3_CONFIG 0xCA
135 static const u8 W83792D_REG_TEMP1[3] = {
136 0x27, /* TEMP 1 in DataSheet */
137 0x39, /* TEMP 1 Over in DataSheet */
138 0x3A, /* TEMP 1 Hyst in DataSheet */
141 static const u8 W83792D_REG_TEMP_ADD[2][6] = {
142 { 0xC0, /* TEMP 2 in DataSheet */
143 0xC1, /* TEMP 2(0.5 deg) in DataSheet */
144 0xC5, /* TEMP 2 Over High part in DataSheet */
145 0xC6, /* TEMP 2 Over Low part in DataSheet */
146 0xC3, /* TEMP 2 Thyst High part in DataSheet */
147 0xC4 }, /* TEMP 2 Thyst Low part in DataSheet */
148 { 0xC8, /* TEMP 3 in DataSheet */
149 0xC9, /* TEMP 3(0.5 deg) in DataSheet */
150 0xCD, /* TEMP 3 Over High part in DataSheet */
151 0xCE, /* TEMP 3 Over Low part in DataSheet */
152 0xCB, /* TEMP 3 Thyst High part in DataSheet */
153 0xCC } /* TEMP 3 Thyst Low part in DataSheet */
156 static const u8 W83792D_REG_THERMAL[3] = {
157 0x85, /* SmartFanI: Fan1 target value */
158 0x86, /* SmartFanI: Fan2 target value */
159 0x96 /* SmartFanI: Fan3 target value */
162 static const u8 W83792D_REG_TOLERANCE[3] = {
163 0x87, /* (bit3-0)SmartFan Fan1 tolerance */
164 0x87, /* (bit7-4)SmartFan Fan2 tolerance */
165 0x97 /* (bit3-0)SmartFan Fan3 tolerance */
168 static const u8 W83792D_REG_POINTS[3][4] = {
169 { 0x85, /* SmartFanII: Fan1 temp point 1 */
170 0xE3, /* SmartFanII: Fan1 temp point 2 */
171 0xE4, /* SmartFanII: Fan1 temp point 3 */
172 0xE5 }, /* SmartFanII: Fan1 temp point 4 */
173 { 0x86, /* SmartFanII: Fan2 temp point 1 */
174 0xE6, /* SmartFanII: Fan2 temp point 2 */
175 0xE7, /* SmartFanII: Fan2 temp point 3 */
176 0xE8 }, /* SmartFanII: Fan2 temp point 4 */
177 { 0x96, /* SmartFanII: Fan3 temp point 1 */
178 0xE9, /* SmartFanII: Fan3 temp point 2 */
179 0xEA, /* SmartFanII: Fan3 temp point 3 */
180 0xEB } /* SmartFanII: Fan3 temp point 4 */
183 static const u8 W83792D_REG_LEVELS[3][4] = {
184 { 0x88, /* (bit3-0) SmartFanII: Fan1 Non-Stop */
185 0x88, /* (bit7-4) SmartFanII: Fan1 Level 1 */
186 0xE0, /* (bit7-4) SmartFanII: Fan1 Level 2 */
187 0xE0 }, /* (bit3-0) SmartFanII: Fan1 Level 3 */
188 { 0x89, /* (bit3-0) SmartFanII: Fan2 Non-Stop */
189 0x89, /* (bit7-4) SmartFanII: Fan2 Level 1 */
190 0xE1, /* (bit7-4) SmartFanII: Fan2 Level 2 */
191 0xE1 }, /* (bit3-0) SmartFanII: Fan2 Level 3 */
192 { 0x98, /* (bit3-0) SmartFanII: Fan3 Non-Stop */
193 0x98, /* (bit7-4) SmartFanII: Fan3 Level 1 */
194 0xE2, /* (bit7-4) SmartFanII: Fan3 Level 2 */
195 0xE2 } /* (bit3-0) SmartFanII: Fan3 Level 3 */
198 #define W83792D_REG_CONFIG 0x40
199 #define W83792D_REG_VID_FANDIV 0x47
200 #define W83792D_REG_CHIPID 0x49
201 #define W83792D_REG_WCHIPID 0x58
202 #define W83792D_REG_CHIPMAN 0x4F
203 #define W83792D_REG_PIN 0x4B
204 #define W83792D_REG_I2C_SUBADDR 0x4A
206 #define W83792D_REG_ALARM1 0xA9 /* realtime status register1 */
207 #define W83792D_REG_ALARM2 0xAA /* realtime status register2 */
208 #define W83792D_REG_ALARM3 0xAB /* realtime status register3 */
209 #define W83792D_REG_CHASSIS 0x42 /* Bit 5: Case Open status bit */
210 #define W83792D_REG_CHASSIS_CLR 0x44 /* Bit 7: Case Open CLR_CHS/Reset bit */
212 /* control in0/in1 's limit modifiability */
213 #define W83792D_REG_VID_IN_B 0x17
215 #define W83792D_REG_VBAT 0x5D
216 #define W83792D_REG_I2C_ADDR 0x48
218 /* Conversions. Rounding and limit checking is only done on the TO_REG
219 variants. Note that you should be a bit careful with which arguments
220 these macros are called: arguments may be evaluated more than once.
221 Fixing this is just not worth it. */
222 #define IN_FROM_REG(nr,val) (((nr)<=1)?(val*2): \
223 ((((nr)==6)||((nr)==7))?(val*6):(val*4)))
224 #define IN_TO_REG(nr,val) (((nr)<=1)?(val/2): \
225 ((((nr)==6)||((nr)==7))?(val/6):(val/4)))
228 FAN_TO_REG(long rpm, int div)
232 rpm = SENSORS_LIMIT(rpm, 1, 1000000);
233 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
236 #define FAN_FROM_REG(val,div) ((val) == 0 ? -1 : \
237 ((val) == 255 ? 0 : \
238 1350000 / ((val) * (div))))
241 #define TEMP1_TO_REG(val) (SENSORS_LIMIT(((val) < 0 ? (val)+0x100*1000 \
242 : (val)) / 1000, 0, 0xff))
243 #define TEMP1_FROM_REG(val) (((val) & 0x80 ? (val)-0x100 : (val)) * 1000)
244 /* for temp2 and temp3, because they need addtional resolution */
245 #define TEMP_ADD_FROM_REG(val1, val2) \
246 ((((val1) & 0x80 ? (val1)-0x100 \
247 : (val1)) * 1000) + ((val2 & 0x80) ? 500 : 0))
248 #define TEMP_ADD_TO_REG_HIGH(val) \
249 (SENSORS_LIMIT(((val) < 0 ? (val)+0x100*1000 \
250 : (val)) / 1000, 0, 0xff))
251 #define TEMP_ADD_TO_REG_LOW(val) ((val%1000) ? 0x80 : 0x00)
253 #define PWM_FROM_REG(val) (val)
254 #define PWM_TO_REG(val) (SENSORS_LIMIT((val),0,255))
255 #define DIV_FROM_REG(val) (1 << (val))
261 val = SENSORS_LIMIT(val, 1, 128) >> 1;
262 for (i = 0; i < 6; i++) {
270 struct w83792d_data {
271 struct i2c_client client;
272 struct class_device *class_dev;
273 struct semaphore lock;
276 struct semaphore update_lock;
277 char valid; /* !=0 if following fields are valid */
278 unsigned long last_updated; /* In jiffies */
280 /* array of 2 pointers to subclients */
281 struct i2c_client *lm75[2];
283 u8 in[9]; /* Register value */
284 u8 in_max[9]; /* Register value */
285 u8 in_min[9]; /* Register value */
286 u8 low_bits[2]; /* Additional resolution to voltage in0-6 */
287 u8 fan[7]; /* Register value */
288 u8 fan_min[7]; /* Register value */
289 u8 temp1[3]; /* current, over, thyst */
290 u8 temp_add[2][6]; /* Register value */
291 u8 fan_div[7]; /* Register encoding, shifted right */
292 u8 pwm[7]; /* We only consider the first 3 set of pwm,
293 although 792 chip has 7 set of pwm. */
295 u8 pwm_mode[7]; /* indicates PWM or DC mode: 1->PWM; 0->DC */
296 u32 alarms; /* realtime status register encoding,combined */
297 u8 chassis; /* Chassis status */
298 u8 chassis_clear; /* CLR_CHS, clear chassis intrusion detection */
299 u8 thermal_cruise[3]; /* Smart FanI: Fan1,2,3 target value */
300 u8 tolerance[3]; /* Fan1,2,3 tolerance(Smart Fan I/II) */
301 u8 sf2_points[3][4]; /* Smart FanII: Fan1,2,3 temperature points */
302 u8 sf2_levels[3][4]; /* Smart FanII: Fan1,2,3 duty cycle levels */
305 static int w83792d_attach_adapter(struct i2c_adapter *adapter);
306 static int w83792d_detect(struct i2c_adapter *adapter, int address, int kind);
307 static int w83792d_detach_client(struct i2c_client *client);
309 static int w83792d_read_value(struct i2c_client *client, u8 register);
310 static int w83792d_write_value(struct i2c_client *client, u8 register,
312 static struct w83792d_data *w83792d_update_device(struct device *dev);
315 static void w83792d_print_debug(struct w83792d_data *data, struct device *dev);
318 static void w83792d_init_client(struct i2c_client *client);
320 static struct i2c_driver w83792d_driver = {
321 .owner = THIS_MODULE,
323 .flags = I2C_DF_NOTIFY,
324 .attach_adapter = w83792d_attach_adapter,
325 .detach_client = w83792d_detach_client,
328 static long in_count_from_reg(int nr, struct w83792d_data *data)
330 u16 vol_count = data->in[nr];
332 vol_count = (vol_count << 2);
336 low_bits = (data->low_bits[0]) & 0x03;
339 low_bits = ((data->low_bits[0]) & 0x0c) >> 2;
342 low_bits = ((data->low_bits[0]) & 0x30) >> 4;
345 low_bits = ((data->low_bits[0]) & 0xc0) >> 6;
348 low_bits = (data->low_bits[1]) & 0x03;
351 low_bits = ((data->low_bits[1]) & 0x0c) >> 2;
354 low_bits = ((data->low_bits[1]) & 0x30) >> 4;
358 vol_count = vol_count | low_bits;
362 /* following are the sysfs callback functions */
363 static ssize_t show_in(struct device *dev, struct device_attribute *attr,
366 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
367 int nr = sensor_attr->index;
368 struct w83792d_data *data = w83792d_update_device(dev);
369 return sprintf(buf,"%ld\n", IN_FROM_REG(nr,(in_count_from_reg(nr, data))));
372 #define show_in_reg(reg) \
373 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
376 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
377 int nr = sensor_attr->index; \
378 struct w83792d_data *data = w83792d_update_device(dev); \
379 return sprintf(buf,"%ld\n", (long)(IN_FROM_REG(nr, (data->reg[nr])*4))); \
385 #define store_in_reg(REG, reg) \
386 static ssize_t store_in_##reg (struct device *dev, \
387 struct device_attribute *attr, \
388 const char *buf, size_t count) \
390 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
391 int nr = sensor_attr->index; \
392 struct i2c_client *client = to_i2c_client(dev); \
393 struct w83792d_data *data = i2c_get_clientdata(client); \
396 val = simple_strtoul(buf, NULL, 10); \
397 data->in_##reg[nr] = SENSORS_LIMIT(IN_TO_REG(nr, val)/4, 0, 255); \
398 w83792d_write_value(client, W83792D_REG_IN_##REG[nr], data->in_##reg[nr]); \
402 store_in_reg(MIN, min);
403 store_in_reg(MAX, max);
405 #define sysfs_in_reg(offset) \
406 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, show_in, \
408 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
409 show_in_min, store_in_min, offset); \
410 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
411 show_in_max, store_in_max, offset);
423 #define device_create_file_in(client, offset) \
425 device_create_file(&client->dev, &sensor_dev_attr_in##offset##_input.dev_attr); \
426 device_create_file(&client->dev, &sensor_dev_attr_in##offset##_max.dev_attr); \
427 device_create_file(&client->dev, &sensor_dev_attr_in##offset##_min.dev_attr); \
430 #define show_fan_reg(reg) \
431 static ssize_t show_##reg (struct device *dev, struct device_attribute *attr, \
434 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
435 int nr = sensor_attr->index - 1; \
436 struct w83792d_data *data = w83792d_update_device(dev); \
437 return sprintf(buf,"%d\n", \
438 FAN_FROM_REG(data->reg[nr], DIV_FROM_REG(data->fan_div[nr]))); \
442 show_fan_reg(fan_min);
445 store_fan_min(struct device *dev, struct device_attribute *attr,
446 const char *buf, size_t count)
448 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
449 int nr = sensor_attr->index - 1;
450 struct i2c_client *client = to_i2c_client(dev);
451 struct w83792d_data *data = i2c_get_clientdata(client);
454 val = simple_strtoul(buf, NULL, 10);
455 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
456 w83792d_write_value(client, W83792D_REG_FAN_MIN[nr],
463 show_fan_div(struct device *dev, struct device_attribute *attr,
466 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
467 int nr = sensor_attr->index;
468 struct w83792d_data *data = w83792d_update_device(dev);
469 return sprintf(buf, "%u\n", DIV_FROM_REG(data->fan_div[nr - 1]));
472 /* Note: we save and restore the fan minimum here, because its value is
473 determined in part by the fan divisor. This follows the principle of
474 least suprise; the user doesn't expect the fan minimum to change just
475 because the divisor changed. */
477 store_fan_div(struct device *dev, struct device_attribute *attr,
478 const char *buf, size_t count)
480 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
481 int nr = sensor_attr->index - 1;
482 struct i2c_client *client = to_i2c_client(dev);
483 struct w83792d_data *data = i2c_get_clientdata(client);
490 min = FAN_FROM_REG(data->fan_min[nr],
491 DIV_FROM_REG(data->fan_div[nr]));
493 data->fan_div[nr] = DIV_TO_REG(simple_strtoul(buf, NULL, 10));
495 fan_div_reg = w83792d_read_value(client, W83792D_REG_FAN_DIV[nr >> 1]);
496 fan_div_reg &= (nr & 0x01) ? 0x8f : 0xf8;
497 tmp_fan_div = (nr & 0x01) ? (((data->fan_div[nr]) << 4) & 0x70)
498 : ((data->fan_div[nr]) & 0x07);
499 w83792d_write_value(client, W83792D_REG_FAN_DIV[nr >> 1],
500 fan_div_reg | tmp_fan_div);
502 /* Restore fan_min */
503 data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
504 w83792d_write_value(client, W83792D_REG_FAN_MIN[nr], data->fan_min[nr]);
509 #define sysfs_fan(offset) \
510 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan, NULL, \
512 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
513 show_fan_div, store_fan_div, offset); \
514 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
515 show_fan_min, store_fan_min, offset);
525 #define device_create_file_fan(client, offset) \
527 device_create_file(&client->dev, &sensor_dev_attr_fan##offset##_input.dev_attr); \
528 device_create_file(&client->dev, &sensor_dev_attr_fan##offset##_div.dev_attr); \
529 device_create_file(&client->dev, &sensor_dev_attr_fan##offset##_min.dev_attr); \
533 /* read/write the temperature1, includes measured value and limits */
535 static ssize_t show_temp1(struct device *dev, struct device_attribute *attr,
538 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
539 int nr = sensor_attr->index;
540 struct w83792d_data *data = w83792d_update_device(dev);
541 return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp1[nr]));
544 static ssize_t store_temp1(struct device *dev, struct device_attribute *attr,
545 const char *buf, size_t count)
547 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
548 int nr = sensor_attr->index;
549 struct i2c_client *client = to_i2c_client(dev);
550 struct w83792d_data *data = i2c_get_clientdata(client);
553 val = simple_strtol(buf, NULL, 10);
555 data->temp1[nr] = TEMP1_TO_REG(val);
556 w83792d_write_value(client, W83792D_REG_TEMP1[nr],
563 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp1, NULL, 0);
564 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, show_temp1,
566 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, show_temp1,
569 #define device_create_file_temp1(client) \
571 device_create_file(&client->dev, &sensor_dev_attr_temp1_input.dev_attr); \
572 device_create_file(&client->dev, &sensor_dev_attr_temp1_max.dev_attr); \
573 device_create_file(&client->dev, &sensor_dev_attr_temp1_max_hyst.dev_attr); \
577 /* read/write the temperature2-3, includes measured value and limits */
579 static ssize_t show_temp23(struct device *dev, struct device_attribute *attr,
582 struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr);
583 int nr = sensor_attr->nr;
584 int index = sensor_attr->index;
585 struct w83792d_data *data = w83792d_update_device(dev);
586 return sprintf(buf,"%ld\n",
587 (long)TEMP_ADD_FROM_REG(data->temp_add[nr][index],
588 data->temp_add[nr][index+1]));
591 static ssize_t store_temp23(struct device *dev, struct device_attribute *attr,
592 const char *buf, size_t count)
594 struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr);
595 int nr = sensor_attr->nr;
596 int index = sensor_attr->index;
597 struct i2c_client *client = to_i2c_client(dev);
598 struct w83792d_data *data = i2c_get_clientdata(client);
601 val = simple_strtol(buf, NULL, 10);
603 data->temp_add[nr][index] = TEMP_ADD_TO_REG_HIGH(val);
604 data->temp_add[nr][index+1] = TEMP_ADD_TO_REG_LOW(val);
605 w83792d_write_value(client, W83792D_REG_TEMP_ADD[nr][index],
606 data->temp_add[nr][index]);
607 w83792d_write_value(client, W83792D_REG_TEMP_ADD[nr][index+1],
608 data->temp_add[nr][index+1]);
613 #define sysfs_temp23(name,idx) \
614 static SENSOR_DEVICE_ATTR_2(name##_input, S_IRUGO, show_temp23, NULL, \
616 static SENSOR_DEVICE_ATTR_2(name##_max, S_IRUGO | S_IWUSR, \
617 show_temp23, store_temp23, idx, 2); \
618 static SENSOR_DEVICE_ATTR_2(name##_max_hyst, S_IRUGO | S_IWUSR, \
619 show_temp23, store_temp23, idx, 4);
621 sysfs_temp23(temp2,0)
622 sysfs_temp23(temp3,1)
624 #define device_create_file_temp_add(client, offset) \
626 device_create_file(&client->dev, &sensor_dev_attr_temp##offset##_input.dev_attr); \
627 device_create_file(&client->dev, &sensor_dev_attr_temp##offset##_max.dev_attr); \
628 device_create_file(&client->dev, \
629 &sensor_dev_attr_temp##offset##_max_hyst.dev_attr); \
633 /* get reatime status of all sensors items: voltage, temp, fan */
635 show_alarms_reg(struct device *dev, struct device_attribute *attr, char *buf)
637 struct w83792d_data *data = w83792d_update_device(dev);
638 return sprintf(buf, "%d\n", data->alarms);
642 DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
643 #define device_create_file_alarms(client) \
644 device_create_file(&client->dev, &dev_attr_alarms);
649 show_pwm(struct device *dev, struct device_attribute *attr,
652 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
653 int nr = sensor_attr->index;
654 struct w83792d_data *data = w83792d_update_device(dev);
655 return sprintf(buf, "%ld\n", (long) PWM_FROM_REG(data->pwm[nr-1]));
659 show_pwmenable(struct device *dev, struct device_attribute *attr,
662 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
663 int nr = sensor_attr->index - 1;
664 struct w83792d_data *data = w83792d_update_device(dev);
665 long pwm_enable_tmp = 1;
667 switch (data->pwmenable[nr]) {
669 pwm_enable_tmp = 1; /* manual mode */
672 pwm_enable_tmp = 3; /*thermal cruise/Smart Fan I */
675 pwm_enable_tmp = 2; /* Smart Fan II */
679 return sprintf(buf, "%ld\n", pwm_enable_tmp);
683 store_pwm(struct device *dev, struct device_attribute *attr,
684 const char *buf, size_t count)
686 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
687 int nr = sensor_attr->index - 1;
688 struct i2c_client *client = to_i2c_client(dev);
689 struct w83792d_data *data = i2c_get_clientdata(client);
692 val = simple_strtoul(buf, NULL, 10);
693 data->pwm[nr] = PWM_TO_REG(val);
694 w83792d_write_value(client, W83792D_REG_PWM[nr], data->pwm[nr]);
700 store_pwmenable(struct device *dev, struct device_attribute *attr,
701 const char *buf, size_t count)
703 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
704 int nr = sensor_attr->index - 1;
705 struct i2c_client *client = to_i2c_client(dev);
706 struct w83792d_data *data = i2c_get_clientdata(client);
708 u8 fan_cfg_tmp, cfg1_tmp, cfg2_tmp, cfg3_tmp, cfg4_tmp;
710 val = simple_strtoul(buf, NULL, 10);
713 data->pwmenable[nr] = 0; /* manual mode */
716 data->pwmenable[nr] = 2; /* Smart Fan II */
719 data->pwmenable[nr] = 1; /* thermal cruise/Smart Fan I */
724 cfg1_tmp = data->pwmenable[0];
725 cfg2_tmp = (data->pwmenable[1]) << 2;
726 cfg3_tmp = (data->pwmenable[2]) << 4;
727 cfg4_tmp = w83792d_read_value(client,W83792D_REG_FAN_CFG) & 0xc0;
728 fan_cfg_tmp = ((cfg4_tmp | cfg3_tmp) | cfg2_tmp) | cfg1_tmp;
729 w83792d_write_value(client, W83792D_REG_FAN_CFG, fan_cfg_tmp);
734 #define sysfs_pwm(offset) \
735 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
736 show_pwm, store_pwm, offset); \
737 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \
738 show_pwmenable, store_pwmenable, offset); \
745 #define device_create_file_pwm(client, offset) \
747 device_create_file(&client->dev, &sensor_dev_attr_pwm##offset.dev_attr); \
750 #define device_create_file_pwmenable(client, offset) \
752 device_create_file(&client->dev, &sensor_dev_attr_pwm##offset##_enable.dev_attr); \
757 show_pwm_mode(struct device *dev, struct device_attribute *attr,
760 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
761 int nr = sensor_attr->index;
762 struct w83792d_data *data = w83792d_update_device(dev);
763 return sprintf(buf, "%d\n", data->pwm_mode[nr-1]);
767 store_pwm_mode(struct device *dev, struct device_attribute *attr,
768 const char *buf, size_t count)
770 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
771 int nr = sensor_attr->index - 1;
772 struct i2c_client *client = to_i2c_client(dev);
773 struct w83792d_data *data = i2c_get_clientdata(client);
775 u8 pwm_mode_mask = 0;
777 val = simple_strtoul(buf, NULL, 10);
778 data->pwm_mode[nr] = SENSORS_LIMIT(val, 0, 1);
779 pwm_mode_mask = w83792d_read_value(client,
780 W83792D_REG_PWM[nr]) & 0x7f;
781 w83792d_write_value(client, W83792D_REG_PWM[nr],
782 ((data->pwm_mode[nr]) << 7) | pwm_mode_mask);
787 #define sysfs_pwm_mode(offset) \
788 static SENSOR_DEVICE_ATTR(pwm##offset##_mode, S_IRUGO | S_IWUSR, \
789 show_pwm_mode, store_pwm_mode, offset);
795 #define device_create_file_pwm_mode(client, offset) \
797 device_create_file(&client->dev, &sensor_dev_attr_pwm##offset##_mode.dev_attr); \
802 show_regs_chassis(struct device *dev, struct device_attribute *attr,
805 struct w83792d_data *data = w83792d_update_device(dev);
806 return sprintf(buf, "%d\n", data->chassis);
809 static DEVICE_ATTR(chassis, S_IRUGO, show_regs_chassis, NULL);
811 #define device_create_file_chassis(client) \
813 device_create_file(&client->dev, &dev_attr_chassis); \
818 show_chassis_clear(struct device *dev, struct device_attribute *attr, char *buf)
820 struct w83792d_data *data = w83792d_update_device(dev);
821 return sprintf(buf, "%d\n", data->chassis_clear);
825 store_chassis_clear(struct device *dev, struct device_attribute *attr,
826 const char *buf, size_t count)
828 struct i2c_client *client = to_i2c_client(dev);
829 struct w83792d_data *data = i2c_get_clientdata(client);
831 u8 temp1 = 0, temp2 = 0;
833 val = simple_strtoul(buf, NULL, 10);
835 data->chassis_clear = SENSORS_LIMIT(val, 0 ,1);
836 temp1 = ((data->chassis_clear) << 7) & 0x80;
837 temp2 = w83792d_read_value(client,
838 W83792D_REG_CHASSIS_CLR) & 0x7f;
839 w83792d_write_value(client, W83792D_REG_CHASSIS_CLR, temp1 | temp2);
844 static DEVICE_ATTR(chassis_clear, S_IRUGO | S_IWUSR,
845 show_chassis_clear, store_chassis_clear);
847 #define device_create_file_chassis_clear(client) \
849 device_create_file(&client->dev, &dev_attr_chassis_clear); \
854 /* For Smart Fan I / Thermal Cruise */
856 show_thermal_cruise(struct device *dev, struct device_attribute *attr,
859 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
860 int nr = sensor_attr->index;
861 struct w83792d_data *data = w83792d_update_device(dev);
862 return sprintf(buf, "%ld\n", (long)data->thermal_cruise[nr-1]);
866 store_thermal_cruise(struct device *dev, struct device_attribute *attr,
867 const char *buf, size_t count)
869 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
870 int nr = sensor_attr->index - 1;
871 struct i2c_client *client = to_i2c_client(dev);
872 struct w83792d_data *data = i2c_get_clientdata(client);
874 u8 target_tmp=0, target_mask=0;
876 val = simple_strtoul(buf, NULL, 10);
878 target_tmp = target_tmp & 0x7f;
879 target_mask = w83792d_read_value(client, W83792D_REG_THERMAL[nr]) & 0x80;
880 data->thermal_cruise[nr] = SENSORS_LIMIT(target_tmp, 0, 255);
881 w83792d_write_value(client, W83792D_REG_THERMAL[nr],
882 (data->thermal_cruise[nr]) | target_mask);
887 #define sysfs_thermal_cruise(offset) \
888 static SENSOR_DEVICE_ATTR(thermal_cruise##offset, S_IRUGO | S_IWUSR, \
889 show_thermal_cruise, store_thermal_cruise, offset);
891 sysfs_thermal_cruise(1);
892 sysfs_thermal_cruise(2);
893 sysfs_thermal_cruise(3);
895 #define device_create_file_thermal_cruise(client, offset) \
897 device_create_file(&client->dev, \
898 &sensor_dev_attr_thermal_cruise##offset.dev_attr); \
902 /* For Smart Fan I/Thermal Cruise and Smart Fan II */
904 show_tolerance(struct device *dev, struct device_attribute *attr,
907 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
908 int nr = sensor_attr->index;
909 struct w83792d_data *data = w83792d_update_device(dev);
910 return sprintf(buf, "%ld\n", (long)data->tolerance[nr-1]);
914 store_tolerance(struct device *dev, struct device_attribute *attr,
915 const char *buf, size_t count)
917 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
918 int nr = sensor_attr->index - 1;
919 struct i2c_client *client = to_i2c_client(dev);
920 struct w83792d_data *data = i2c_get_clientdata(client);
922 u8 tol_tmp, tol_mask;
924 val = simple_strtoul(buf, NULL, 10);
925 tol_mask = w83792d_read_value(client,
926 W83792D_REG_TOLERANCE[nr]) & ((nr == 1) ? 0x0f : 0xf0);
927 tol_tmp = SENSORS_LIMIT(val, 0, 15);
929 data->tolerance[nr] = tol_tmp;
933 w83792d_write_value(client, W83792D_REG_TOLERANCE[nr],
939 #define sysfs_tolerance(offset) \
940 static SENSOR_DEVICE_ATTR(tolerance##offset, S_IRUGO | S_IWUSR, \
941 show_tolerance, store_tolerance, offset);
947 #define device_create_file_tolerance(client, offset) \
949 device_create_file(&client->dev, &sensor_dev_attr_tolerance##offset.dev_attr); \
953 /* For Smart Fan II */
955 show_sf2_point(struct device *dev, struct device_attribute *attr,
958 struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr);
959 int nr = sensor_attr->nr;
960 int index = sensor_attr->index;
961 struct w83792d_data *data = w83792d_update_device(dev);
962 return sprintf(buf, "%ld\n", (long)data->sf2_points[index-1][nr-1]);
966 store_sf2_point(struct device *dev, struct device_attribute *attr,
967 const char *buf, size_t count)
969 struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr);
970 int nr = sensor_attr->nr - 1;
971 int index = sensor_attr->index - 1;
972 struct i2c_client *client = to_i2c_client(dev);
973 struct w83792d_data *data = i2c_get_clientdata(client);
977 val = simple_strtoul(buf, NULL, 10);
978 data->sf2_points[index][nr] = SENSORS_LIMIT(val, 0, 127);
979 mask_tmp = w83792d_read_value(client,
980 W83792D_REG_POINTS[index][nr]) & 0x80;
981 w83792d_write_value(client, W83792D_REG_POINTS[index][nr],
982 mask_tmp|data->sf2_points[index][nr]);
987 #define sysfs_sf2_point(offset, index) \
988 static SENSOR_DEVICE_ATTR_2(sf2_point##offset##_fan##index, S_IRUGO | S_IWUSR, \
989 show_sf2_point, store_sf2_point, offset, index);
991 sysfs_sf2_point(1, 1); /* Fan1 */
992 sysfs_sf2_point(2, 1); /* Fan1 */
993 sysfs_sf2_point(3, 1); /* Fan1 */
994 sysfs_sf2_point(4, 1); /* Fan1 */
995 sysfs_sf2_point(1, 2); /* Fan2 */
996 sysfs_sf2_point(2, 2); /* Fan2 */
997 sysfs_sf2_point(3, 2); /* Fan2 */
998 sysfs_sf2_point(4, 2); /* Fan2 */
999 sysfs_sf2_point(1, 3); /* Fan3 */
1000 sysfs_sf2_point(2, 3); /* Fan3 */
1001 sysfs_sf2_point(3, 3); /* Fan3 */
1002 sysfs_sf2_point(4, 3); /* Fan3 */
1004 #define device_create_file_sf2_point(client, offset, index) \
1006 device_create_file(&client->dev, \
1007 &sensor_dev_attr_sf2_point##offset##_fan##index.dev_attr); \
1012 show_sf2_level(struct device *dev, struct device_attribute *attr,
1015 struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr);
1016 int nr = sensor_attr->nr;
1017 int index = sensor_attr->index;
1018 struct w83792d_data *data = w83792d_update_device(dev);
1019 return sprintf(buf, "%d\n",
1020 (((data->sf2_levels[index-1][nr]) * 100) / 15));
1024 store_sf2_level(struct device *dev, struct device_attribute *attr,
1025 const char *buf, size_t count)
1027 struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr);
1028 int nr = sensor_attr->nr;
1029 int index = sensor_attr->index - 1;
1030 struct i2c_client *client = to_i2c_client(dev);
1031 struct w83792d_data *data = i2c_get_clientdata(client);
1033 u8 mask_tmp=0, level_tmp=0;
1035 val = simple_strtoul(buf, NULL, 10);
1036 data->sf2_levels[index][nr] = SENSORS_LIMIT((val * 15) / 100, 0, 15);
1037 mask_tmp = w83792d_read_value(client, W83792D_REG_LEVELS[index][nr])
1038 & ((nr==3) ? 0xf0 : 0x0f);
1040 level_tmp = data->sf2_levels[index][nr];
1042 level_tmp = data->sf2_levels[index][nr] << 4;
1044 w83792d_write_value(client, W83792D_REG_LEVELS[index][nr], level_tmp | mask_tmp);
1049 #define sysfs_sf2_level(offset, index) \
1050 static SENSOR_DEVICE_ATTR_2(sf2_level##offset##_fan##index, S_IRUGO | S_IWUSR, \
1051 show_sf2_level, store_sf2_level, offset, index);
1053 sysfs_sf2_level(1, 1); /* Fan1 */
1054 sysfs_sf2_level(2, 1); /* Fan1 */
1055 sysfs_sf2_level(3, 1); /* Fan1 */
1056 sysfs_sf2_level(1, 2); /* Fan2 */
1057 sysfs_sf2_level(2, 2); /* Fan2 */
1058 sysfs_sf2_level(3, 2); /* Fan2 */
1059 sysfs_sf2_level(1, 3); /* Fan3 */
1060 sysfs_sf2_level(2, 3); /* Fan3 */
1061 sysfs_sf2_level(3, 3); /* Fan3 */
1063 #define device_create_file_sf2_level(client, offset, index) \
1065 device_create_file(&client->dev, \
1066 &sensor_dev_attr_sf2_level##offset##_fan##index.dev_attr); \
1070 /* This function is called when:
1071 * w83792d_driver is inserted (when this module is loaded), for each
1073 * when a new adapter is inserted (and w83792d_driver is still present) */
1075 w83792d_attach_adapter(struct i2c_adapter *adapter)
1077 if (!(adapter->class & I2C_CLASS_HWMON))
1079 return i2c_probe(adapter, &addr_data, w83792d_detect);
1084 w83792d_create_subclient(struct i2c_adapter *adapter,
1085 struct i2c_client *new_client, int addr,
1086 struct i2c_client **sub_cli)
1089 struct i2c_client *sub_client;
1091 (*sub_cli) = sub_client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
1092 if (!(sub_client)) {
1095 memset(sub_client, 0x00, sizeof(struct i2c_client));
1096 sub_client->addr = 0x48 + addr;
1097 i2c_set_clientdata(sub_client, NULL);
1098 sub_client->adapter = adapter;
1099 sub_client->driver = &w83792d_driver;
1100 sub_client->flags = 0;
1101 strlcpy(sub_client->name, "w83792d subclient", I2C_NAME_SIZE);
1102 if ((err = i2c_attach_client(sub_client))) {
1103 dev_err(&new_client->dev, "subclient registration "
1104 "at address 0x%x failed\n", sub_client->addr);
1113 w83792d_detect_subclients(struct i2c_adapter *adapter, int address, int kind,
1114 struct i2c_client *new_client)
1118 struct w83792d_data *data = i2c_get_clientdata(new_client);
1120 id = i2c_adapter_id(adapter);
1121 if (force_subclients[0] == id && force_subclients[1] == address) {
1122 for (i = 2; i <= 3; i++) {
1123 if (force_subclients[i] < 0x48 ||
1124 force_subclients[i] > 0x4f) {
1125 dev_err(&new_client->dev, "invalid subclient "
1126 "address %d; must be 0x48-0x4f\n",
1127 force_subclients[i]);
1132 w83792d_write_value(new_client, W83792D_REG_I2C_SUBADDR,
1133 (force_subclients[2] & 0x07) |
1134 ((force_subclients[3] & 0x07) << 4));
1137 val = w83792d_read_value(new_client, W83792D_REG_I2C_SUBADDR);
1138 if (!(val & 0x08)) {
1139 err = w83792d_create_subclient(adapter, new_client, val & 0x7,
1144 if (!(val & 0x80)) {
1145 if ((data->lm75[0] != NULL) &&
1146 ((val & 0x7) == ((val >> 4) & 0x7))) {
1147 dev_err(&new_client->dev, "duplicate addresses 0x%x, "
1148 "use force_subclient\n", data->lm75[0]->addr);
1152 err = w83792d_create_subclient(adapter, new_client,
1153 (val >> 4) & 0x7, &data->lm75[1]);
1160 /* Undo inits in case of errors */
1163 if (data->lm75[0] != NULL) {
1164 i2c_detach_client(data->lm75[0]);
1165 kfree(data->lm75[0]);
1173 w83792d_detect(struct i2c_adapter *adapter, int address, int kind)
1175 int i = 0, val1 = 0, val2;
1176 struct i2c_client *new_client;
1177 struct w83792d_data *data;
1179 const char *client_name = "";
1181 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1185 /* OK. For now, we presume we have a valid client. We now create the
1186 client structure, even though we cannot fill it completely yet.
1187 But it allows us to access w83792d_{read,write}_value. */
1189 if (!(data = kmalloc(sizeof(struct w83792d_data), GFP_KERNEL))) {
1193 memset(data, 0, sizeof(struct w83792d_data));
1195 new_client = &data->client;
1196 i2c_set_clientdata(new_client, data);
1197 new_client->addr = address;
1198 init_MUTEX(&data->lock);
1199 new_client->adapter = adapter;
1200 new_client->driver = &w83792d_driver;
1201 new_client->flags = 0;
1203 /* Now, we do the remaining detection. */
1205 /* The w83792d may be stuck in some other bank than bank 0. This may
1206 make reading other information impossible. Specify a force=... or
1207 force_*=... parameter, and the Winbond will be reset to the right
1210 if (w83792d_read_value(new_client, W83792D_REG_CONFIG) & 0x80) {
1211 dev_warn(&new_client->dev, "Detection failed at step "
1215 val1 = w83792d_read_value(new_client, W83792D_REG_BANK);
1216 val2 = w83792d_read_value(new_client, W83792D_REG_CHIPMAN);
1217 /* Check for Winbond ID if in bank 0 */
1218 if (!(val1 & 0x07)) { /* is Bank0 */
1219 if (((!(val1 & 0x80)) && (val2 != 0xa3)) ||
1220 ((val1 & 0x80) && (val2 != 0x5c))) {
1224 /* If Winbond chip, address of chip and W83792D_REG_I2C_ADDR
1226 if (w83792d_read_value(new_client,
1227 W83792D_REG_I2C_ADDR) != address) {
1228 dev_warn(&new_client->dev, "Detection failed "
1234 /* We have either had a force parameter, or we have already detected the
1235 Winbond. Put it now into bank 0 and Vendor ID High Byte */
1236 w83792d_write_value(new_client,
1238 (w83792d_read_value(new_client,
1239 W83792D_REG_BANK) & 0x78) | 0x80);
1241 /* Determine the chip type. */
1244 val2 = w83792d_read_value(new_client, W83792D_REG_CHIPMAN);
1245 if (val2 != 0x5c) { /* the vendor is NOT Winbond */
1248 val1 = w83792d_read_value(new_client, W83792D_REG_WCHIPID);
1249 if (val1 == 0x7a && address >= 0x2c) {
1253 dev_warn(&new_client->dev,
1254 "w83792d: Ignoring 'force' parameter for"
1255 " unknown chip at adapter %d, address"
1256 " 0x%02x\n", i2c_adapter_id(adapter),
1262 if (kind == w83792d) {
1263 client_name = "w83792d";
1265 dev_err(&new_client->dev, "w83792d: Internal error: unknown"
1266 " kind (%d)?!?", kind);
1270 /* Fill in the remaining client fields and put into the global list */
1271 strlcpy(new_client->name, client_name, I2C_NAME_SIZE);
1275 init_MUTEX(&data->update_lock);
1277 /* Tell the I2C layer a new client has arrived */
1278 if ((err = i2c_attach_client(new_client)))
1281 if ((err = w83792d_detect_subclients(adapter, address,
1285 /* Initialize the chip */
1286 w83792d_init_client(new_client);
1288 /* A few vars need to be filled upon startup */
1289 for (i = 1; i <= 7; i++) {
1290 data->fan_min[i - 1] = w83792d_read_value(new_client,
1291 W83792D_REG_FAN_MIN[i]);
1294 /* Register sysfs hooks */
1295 data->class_dev = hwmon_device_register(&new_client->dev);
1296 if (IS_ERR(data->class_dev)) {
1297 err = PTR_ERR(data->class_dev);
1300 device_create_file_in(new_client, 0);
1301 device_create_file_in(new_client, 1);
1302 device_create_file_in(new_client, 2);
1303 device_create_file_in(new_client, 3);
1304 device_create_file_in(new_client, 4);
1305 device_create_file_in(new_client, 5);
1306 device_create_file_in(new_client, 6);
1307 device_create_file_in(new_client, 7);
1308 device_create_file_in(new_client, 8);
1310 device_create_file_fan(new_client, 1);
1311 device_create_file_fan(new_client, 2);
1312 device_create_file_fan(new_client, 3);
1313 device_create_file_fan(new_client, 4);
1314 device_create_file_fan(new_client, 5);
1315 device_create_file_fan(new_client, 6);
1316 device_create_file_fan(new_client, 7);
1318 device_create_file_temp1(new_client); /* Temp1 */
1319 device_create_file_temp_add(new_client, 2); /* Temp2 */
1320 device_create_file_temp_add(new_client, 3); /* Temp3 */
1322 device_create_file_alarms(new_client);
1324 device_create_file_pwm(new_client, 1);
1325 device_create_file_pwm(new_client, 2);
1326 device_create_file_pwm(new_client, 3);
1328 device_create_file_pwmenable(new_client, 1);
1329 device_create_file_pwmenable(new_client, 2);
1330 device_create_file_pwmenable(new_client, 3);
1332 device_create_file_pwm_mode(new_client, 1);
1333 device_create_file_pwm_mode(new_client, 2);
1334 device_create_file_pwm_mode(new_client, 3);
1336 device_create_file_chassis(new_client);
1337 device_create_file_chassis_clear(new_client);
1339 device_create_file_thermal_cruise(new_client, 1);
1340 device_create_file_thermal_cruise(new_client, 2);
1341 device_create_file_thermal_cruise(new_client, 3);
1343 device_create_file_tolerance(new_client, 1);
1344 device_create_file_tolerance(new_client, 2);
1345 device_create_file_tolerance(new_client, 3);
1347 device_create_file_sf2_point(new_client, 1, 1); /* Fan1 */
1348 device_create_file_sf2_point(new_client, 2, 1); /* Fan1 */
1349 device_create_file_sf2_point(new_client, 3, 1); /* Fan1 */
1350 device_create_file_sf2_point(new_client, 4, 1); /* Fan1 */
1351 device_create_file_sf2_point(new_client, 1, 2); /* Fan2 */
1352 device_create_file_sf2_point(new_client, 2, 2); /* Fan2 */
1353 device_create_file_sf2_point(new_client, 3, 2); /* Fan2 */
1354 device_create_file_sf2_point(new_client, 4, 2); /* Fan2 */
1355 device_create_file_sf2_point(new_client, 1, 3); /* Fan3 */
1356 device_create_file_sf2_point(new_client, 2, 3); /* Fan3 */
1357 device_create_file_sf2_point(new_client, 3, 3); /* Fan3 */
1358 device_create_file_sf2_point(new_client, 4, 3); /* Fan3 */
1360 device_create_file_sf2_level(new_client, 1, 1); /* Fan1 */
1361 device_create_file_sf2_level(new_client, 2, 1); /* Fan1 */
1362 device_create_file_sf2_level(new_client, 3, 1); /* Fan1 */
1363 device_create_file_sf2_level(new_client, 1, 2); /* Fan2 */
1364 device_create_file_sf2_level(new_client, 2, 2); /* Fan2 */
1365 device_create_file_sf2_level(new_client, 3, 2); /* Fan2 */
1366 device_create_file_sf2_level(new_client, 1, 3); /* Fan3 */
1367 device_create_file_sf2_level(new_client, 2, 3); /* Fan3 */
1368 device_create_file_sf2_level(new_client, 3, 3); /* Fan3 */
1373 if (data->lm75[0] != NULL) {
1374 i2c_detach_client(data->lm75[0]);
1375 kfree(data->lm75[0]);
1377 if (data->lm75[1] != NULL) {
1378 i2c_detach_client(data->lm75[1]);
1379 kfree(data->lm75[1]);
1382 i2c_detach_client(new_client);
1390 w83792d_detach_client(struct i2c_client *client)
1392 struct w83792d_data *data = i2c_get_clientdata(client);
1397 hwmon_device_unregister(data->class_dev);
1399 if ((err = i2c_detach_client(client)))
1412 /* The SMBus locks itself, usually, but nothing may access the Winbond between
1413 bank switches. ISA access must always be locked explicitly!
1414 We ignore the W83792D BUSY flag at this moment - it could lead to deadlocks,
1415 would slow down the W83792D access and should not be necessary.
1416 There are some ugly typecasts here, but the good news is - they should
1417 nowhere else be necessary! */
1419 w83792d_read_value(struct i2c_client *client, u8 reg)
1422 res = i2c_smbus_read_byte_data(client, reg);
1428 w83792d_write_value(struct i2c_client *client, u8 reg, u8 value)
1430 i2c_smbus_write_byte_data(client, reg, value);
1434 /* Called when we have found a new W83792D. It should set limits, etc. */
1436 w83792d_init_client(struct i2c_client *client)
1438 u8 temp2_cfg, temp3_cfg, vid_in_b;
1441 w83792d_write_value(client, W83792D_REG_CONFIG, 0x80);
1443 /* Clear the bit6 of W83792D_REG_VID_IN_B(set it into 0):
1444 W83792D_REG_VID_IN_B bit6 = 0: the high/low limit of
1445 vin0/vin1 can be modified by user;
1446 W83792D_REG_VID_IN_B bit6 = 1: the high/low limit of
1447 vin0/vin1 auto-updated, can NOT be modified by user. */
1448 vid_in_b = w83792d_read_value(client, W83792D_REG_VID_IN_B);
1449 w83792d_write_value(client, W83792D_REG_VID_IN_B,
1452 temp2_cfg = w83792d_read_value(client, W83792D_REG_TEMP2_CONFIG);
1453 temp3_cfg = w83792d_read_value(client, W83792D_REG_TEMP3_CONFIG);
1454 w83792d_write_value(client, W83792D_REG_TEMP2_CONFIG,
1456 w83792d_write_value(client, W83792D_REG_TEMP3_CONFIG,
1459 /* Start monitoring */
1460 w83792d_write_value(client, W83792D_REG_CONFIG,
1461 (w83792d_read_value(client,
1462 W83792D_REG_CONFIG) & 0xf7)
1466 static struct w83792d_data *w83792d_update_device(struct device *dev)
1468 struct i2c_client *client = to_i2c_client(dev);
1469 struct w83792d_data *data = i2c_get_clientdata(client);
1471 u8 reg_array_tmp[4], pwm_array_tmp[7], reg_tmp;
1473 down(&data->update_lock);
1476 (jiffies - data->last_updated, (unsigned long) (HZ * 3))
1477 || time_before(jiffies, data->last_updated) || !data->valid) {
1478 dev_dbg(dev, "Starting device update\n");
1480 /* Update the voltages measured value and limits */
1481 for (i = 0; i < 9; i++) {
1482 data->in[i] = w83792d_read_value(client,
1484 data->in_max[i] = w83792d_read_value(client,
1485 W83792D_REG_IN_MAX[i]);
1486 data->in_min[i] = w83792d_read_value(client,
1487 W83792D_REG_IN_MIN[i]);
1489 data->low_bits[0] = w83792d_read_value(client,
1490 W83792D_REG_LOW_BITS1);
1491 data->low_bits[1] = w83792d_read_value(client,
1492 W83792D_REG_LOW_BITS2);
1493 for (i = 0; i < 7; i++) {
1494 /* Update the Fan measured value and limits */
1495 data->fan[i] = w83792d_read_value(client,
1496 W83792D_REG_FAN[i]);
1497 data->fan_min[i] = w83792d_read_value(client,
1498 W83792D_REG_FAN_MIN[i]);
1499 /* Update the PWM/DC Value and PWM/DC flag */
1500 pwm_array_tmp[i] = w83792d_read_value(client,
1501 W83792D_REG_PWM[i]);
1502 data->pwm[i] = pwm_array_tmp[i] & 0x0f;
1503 data->pwm_mode[i] = (pwm_array_tmp[i] >> 7) & 0x01;
1506 reg_tmp = w83792d_read_value(client, W83792D_REG_FAN_CFG);
1507 data->pwmenable[0] = reg_tmp & 0x03;
1508 data->pwmenable[1] = (reg_tmp>>2) & 0x03;
1509 data->pwmenable[2] = (reg_tmp>>4) & 0x03;
1511 for (i = 0; i < 3; i++) {
1512 data->temp1[i] = w83792d_read_value(client,
1513 W83792D_REG_TEMP1[i]);
1515 for (i = 0; i < 2; i++) {
1516 for (j = 0; j < 6; j++) {
1517 data->temp_add[i][j] = w83792d_read_value(
1518 client,W83792D_REG_TEMP_ADD[i][j]);
1522 /* Update the Fan Divisor */
1523 for (i = 0; i < 4; i++) {
1524 reg_array_tmp[i] = w83792d_read_value(client,
1525 W83792D_REG_FAN_DIV[i]);
1527 data->fan_div[0] = reg_array_tmp[0] & 0x07;
1528 data->fan_div[1] = (reg_array_tmp[0] >> 4) & 0x07;
1529 data->fan_div[2] = reg_array_tmp[1] & 0x07;
1530 data->fan_div[3] = (reg_array_tmp[1] >> 4) & 0x07;
1531 data->fan_div[4] = reg_array_tmp[2] & 0x07;
1532 data->fan_div[5] = (reg_array_tmp[2] >> 4) & 0x07;
1533 data->fan_div[6] = reg_array_tmp[3] & 0x07;
1535 /* Update the realtime status */
1536 data->alarms = w83792d_read_value(client, W83792D_REG_ALARM1) +
1537 (w83792d_read_value(client, W83792D_REG_ALARM2) << 8) +
1538 (w83792d_read_value(client, W83792D_REG_ALARM3) << 16);
1540 /* Update CaseOpen status and it's CLR_CHS. */
1541 data->chassis = (w83792d_read_value(client,
1542 W83792D_REG_CHASSIS) >> 5) & 0x01;
1543 data->chassis_clear = (w83792d_read_value(client,
1544 W83792D_REG_CHASSIS_CLR) >> 7) & 0x01;
1546 /* Update Thermal Cruise/Smart Fan I target value */
1547 for (i = 0; i < 3; i++) {
1548 data->thermal_cruise[i] =
1549 w83792d_read_value(client,
1550 W83792D_REG_THERMAL[i]) & 0x7f;
1553 /* Update Smart Fan I/II tolerance */
1554 reg_tmp = w83792d_read_value(client, W83792D_REG_TOLERANCE[0]);
1555 data->tolerance[0] = reg_tmp & 0x0f;
1556 data->tolerance[1] = (reg_tmp >> 4) & 0x0f;
1557 data->tolerance[2] = w83792d_read_value(client,
1558 W83792D_REG_TOLERANCE[2]) & 0x0f;
1560 /* Update Smart Fan II temperature points */
1561 for (i = 0; i < 3; i++) {
1562 for (j = 0; j < 4; j++) {
1563 data->sf2_points[i][j] = w83792d_read_value(
1564 client,W83792D_REG_POINTS[i][j]) & 0x7f;
1568 /* Update Smart Fan II duty cycle levels */
1569 for (i = 0; i < 3; i++) {
1570 reg_tmp = w83792d_read_value(client,
1571 W83792D_REG_LEVELS[i][0]);
1572 data->sf2_levels[i][0] = reg_tmp & 0x0f;
1573 data->sf2_levels[i][1] = (reg_tmp >> 4) & 0x0f;
1574 reg_tmp = w83792d_read_value(client,
1575 W83792D_REG_LEVELS[i][2]);
1576 data->sf2_levels[i][2] = (reg_tmp >> 4) & 0x0f;
1577 data->sf2_levels[i][3] = reg_tmp & 0x0f;
1580 data->last_updated = jiffies;
1584 up(&data->update_lock);
1587 w83792d_print_debug(data, dev);
1594 static void w83792d_print_debug(struct w83792d_data *data, struct device *dev)
1597 dev_dbg(dev, "==========The following is the debug message...========\n");
1598 dev_dbg(dev, "9 set of Voltages: =====>\n");
1599 for (i=0; i<9; i++) {
1600 dev_dbg(dev, "vin[%d] is: 0x%x\n", i, data->in[i]);
1601 dev_dbg(dev, "vin[%d] max is: 0x%x\n", i, data->in_max[i]);
1602 dev_dbg(dev, "vin[%d] min is: 0x%x\n", i, data->in_min[i]);
1604 dev_dbg(dev, "Low Bit1 is: 0x%x\n", data->low_bits[0]);
1605 dev_dbg(dev, "Low Bit2 is: 0x%x\n", data->low_bits[1]);
1606 dev_dbg(dev, "7 set of Fan Counts and Duty Cycles: =====>\n");
1607 for (i=0; i<7; i++) {
1608 dev_dbg(dev, "fan[%d] is: 0x%x\n", i, data->fan[i]);
1609 dev_dbg(dev, "fan[%d] min is: 0x%x\n", i, data->fan_min[i]);
1610 dev_dbg(dev, "pwm[%d] is: 0x%x\n", i, data->pwm[i]);
1611 dev_dbg(dev, "pwm_mode[%d] is: 0x%x\n", i, data->pwm_mode[i]);
1613 dev_dbg(dev, "3 set of Temperatures: =====>\n");
1614 for (i=0; i<3; i++) {
1615 dev_dbg(dev, "temp1[%d] is: 0x%x\n", i, data->temp1[i]);
1618 for (i=0; i<2; i++) {
1619 for (j=0; j<6; j++) {
1620 dev_dbg(dev, "temp_add[%d][%d] is: 0x%x\n", i, j,
1621 data->temp_add[i][j]);
1625 for (i=0; i<7; i++) {
1626 dev_dbg(dev, "fan_div[%d] is: 0x%x\n", i, data->fan_div[i]);
1628 dev_dbg(dev, "==========End of the debug message...==================\n");
1634 sensors_w83792d_init(void)
1636 return i2c_add_driver(&w83792d_driver);
1640 sensors_w83792d_exit(void)
1642 i2c_del_driver(&w83792d_driver);
1645 MODULE_AUTHOR("Chunhao Huang @ Winbond <DZShen@Winbond.com.tw>");
1646 MODULE_DESCRIPTION("W83792AD/D driver for linux-2.6");
1647 MODULE_LICENSE("GPL");
1649 module_init(sensors_w83792d_init);
1650 module_exit(sensors_w83792d_exit);