xref: /openbmc/linux/drivers/hwmon/w83792d.c (revision d5cb9783536a41df9f9cba5b0a1d78047ed787f7)
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/hwmon.h>
44 #include <linux/hwmon-sysfs.h>
45 #include <linux/err.h>
46 
47 /* Addresses to scan */
48 static unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END };
49 
50 /* Insmod parameters */
51 I2C_CLIENT_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 class_device *class_dev;
271 	struct semaphore lock;
272 	enum chips type;
273 
274 	struct semaphore update_lock;
275 	char valid;		/* !=0 if following fields are valid */
276 	unsigned long last_updated;	/* In jiffies */
277 
278 	/* array of 2 pointers to subclients */
279 	struct i2c_client *lm75[2];
280 
281 	u8 in[9];		/* Register value */
282 	u8 in_max[9];		/* Register value */
283 	u8 in_min[9];		/* Register value */
284 	u8 low_bits[2];		/* Additional resolution to voltage in0-6 */
285 	u8 fan[7];		/* Register value */
286 	u8 fan_min[7];		/* Register value */
287 	u8 temp1[3];		/* current, over, thyst */
288 	u8 temp_add[2][6];	/* Register value */
289 	u8 fan_div[7];		/* Register encoding, shifted right */
290 	u8 pwm[7];		/* We only consider the first 3 set of pwm,
291 				   although 792 chip has 7 set of pwm. */
292 	u8 pwmenable[3];
293 	u8 pwm_mode[7];		/* indicates PWM or DC mode: 1->PWM; 0->DC */
294 	u32 alarms;		/* realtime status register encoding,combined */
295 	u8 chassis;		/* Chassis status */
296 	u8 chassis_clear;	/* CLR_CHS, clear chassis intrusion detection */
297 	u8 thermal_cruise[3];	/* Smart FanI: Fan1,2,3 target value */
298 	u8 tolerance[3];	/* Fan1,2,3 tolerance(Smart Fan I/II) */
299 	u8 sf2_points[3][4];	/* Smart FanII: Fan1,2,3 temperature points */
300 	u8 sf2_levels[3][4];	/* Smart FanII: Fan1,2,3 duty cycle levels */
301 };
302 
303 static int w83792d_attach_adapter(struct i2c_adapter *adapter);
304 static int w83792d_detect(struct i2c_adapter *adapter, int address, int kind);
305 static int w83792d_detach_client(struct i2c_client *client);
306 
307 static int w83792d_read_value(struct i2c_client *client, u8 register);
308 static int w83792d_write_value(struct i2c_client *client, u8 register,
309 				u8 value);
310 static struct w83792d_data *w83792d_update_device(struct device *dev);
311 
312 #ifdef DEBUG
313 static void w83792d_print_debug(struct w83792d_data *data, struct device *dev);
314 #endif
315 
316 static void w83792d_init_client(struct i2c_client *client);
317 
318 static struct i2c_driver w83792d_driver = {
319 	.owner = THIS_MODULE,
320 	.name = "w83792d",
321 	.flags = I2C_DF_NOTIFY,
322 	.attach_adapter = w83792d_attach_adapter,
323 	.detach_client = w83792d_detach_client,
324 };
325 
326 static long in_count_from_reg(int nr, struct w83792d_data *data)
327 {
328 	u16 vol_count = data->in[nr];
329 	u16 low_bits = 0;
330 	vol_count = (vol_count << 2);
331 	switch (nr)
332 	{
333 	case 0:  /* vin0 */
334 		low_bits = (data->low_bits[0]) & 0x03;
335 		break;
336 	case 1:  /* vin1 */
337 		low_bits = ((data->low_bits[0]) & 0x0c) >> 2;
338 		break;
339 	case 2:  /* vin2 */
340 		low_bits = ((data->low_bits[0]) & 0x30) >> 4;
341 		break;
342 	case 3:  /* vin3 */
343 		low_bits = ((data->low_bits[0]) & 0xc0) >> 6;
344 		break;
345 	case 4:  /* vin4 */
346 		low_bits = (data->low_bits[1]) & 0x03;
347 		break;
348 	case 5:  /* vin5 */
349 		low_bits = ((data->low_bits[1]) & 0x0c) >> 2;
350 		break;
351 	case 6:  /* vin6 */
352 		low_bits = ((data->low_bits[1]) & 0x30) >> 4;
353 	default:
354 		break;
355 	}
356 	vol_count = vol_count | low_bits;
357 	return vol_count;
358 }
359 
360 /* following are the sysfs callback functions */
361 static ssize_t show_in(struct device *dev, struct device_attribute *attr,
362 			char *buf)
363 {
364 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
365 	int nr = sensor_attr->index;
366 	struct w83792d_data *data = w83792d_update_device(dev);
367 	return sprintf(buf,"%ld\n", IN_FROM_REG(nr,(in_count_from_reg(nr, data))));
368 }
369 
370 #define show_in_reg(reg) \
371 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
372 			char *buf) \
373 { \
374 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
375 	int nr = sensor_attr->index; \
376 	struct w83792d_data *data = w83792d_update_device(dev); \
377 	return sprintf(buf,"%ld\n", (long)(IN_FROM_REG(nr, (data->reg[nr])*4))); \
378 }
379 
380 show_in_reg(in_min);
381 show_in_reg(in_max);
382 
383 #define store_in_reg(REG, reg) \
384 static ssize_t store_in_##reg (struct device *dev, \
385 				struct device_attribute *attr, \
386 				const char *buf, size_t count) \
387 { \
388 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
389 	int nr = sensor_attr->index; \
390 	struct i2c_client *client = to_i2c_client(dev); \
391 	struct w83792d_data *data = i2c_get_clientdata(client); \
392 	u32 val; \
393 	 \
394 	val = simple_strtoul(buf, NULL, 10); \
395 	data->in_##reg[nr] = SENSORS_LIMIT(IN_TO_REG(nr, val)/4, 0, 255); \
396 	w83792d_write_value(client, W83792D_REG_IN_##REG[nr], data->in_##reg[nr]); \
397 	 \
398 	return count; \
399 }
400 store_in_reg(MIN, min);
401 store_in_reg(MAX, max);
402 
403 #define sysfs_in_reg(offset) \
404 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, show_in, \
405 				NULL, offset); \
406 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
407 				show_in_min, store_in_min, offset); \
408 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
409 				show_in_max, store_in_max, offset);
410 
411 sysfs_in_reg(0);
412 sysfs_in_reg(1);
413 sysfs_in_reg(2);
414 sysfs_in_reg(3);
415 sysfs_in_reg(4);
416 sysfs_in_reg(5);
417 sysfs_in_reg(6);
418 sysfs_in_reg(7);
419 sysfs_in_reg(8);
420 
421 #define device_create_file_in(client, offset) \
422 do { \
423 device_create_file(&client->dev, &sensor_dev_attr_in##offset##_input.dev_attr); \
424 device_create_file(&client->dev, &sensor_dev_attr_in##offset##_max.dev_attr); \
425 device_create_file(&client->dev, &sensor_dev_attr_in##offset##_min.dev_attr); \
426 } while (0)
427 
428 #define show_fan_reg(reg) \
429 static ssize_t show_##reg (struct device *dev, struct device_attribute *attr, \
430 			char *buf) \
431 { \
432 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
433 	int nr = sensor_attr->index - 1; \
434 	struct w83792d_data *data = w83792d_update_device(dev); \
435 	return sprintf(buf,"%d\n", \
436 		FAN_FROM_REG(data->reg[nr], DIV_FROM_REG(data->fan_div[nr]))); \
437 }
438 
439 show_fan_reg(fan);
440 show_fan_reg(fan_min);
441 
442 static ssize_t
443 store_fan_min(struct device *dev, struct device_attribute *attr,
444 		const char *buf, size_t count)
445 {
446 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
447 	int nr = sensor_attr->index - 1;
448 	struct i2c_client *client = to_i2c_client(dev);
449 	struct w83792d_data *data = i2c_get_clientdata(client);
450 	u32 val;
451 
452 	val = simple_strtoul(buf, NULL, 10);
453 	data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
454 	w83792d_write_value(client, W83792D_REG_FAN_MIN[nr],
455 				data->fan_min[nr]);
456 
457 	return count;
458 }
459 
460 static ssize_t
461 show_fan_div(struct device *dev, struct device_attribute *attr,
462 		char *buf)
463 {
464 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
465 	int nr = sensor_attr->index;
466 	struct w83792d_data *data = w83792d_update_device(dev);
467 	return sprintf(buf, "%u\n", DIV_FROM_REG(data->fan_div[nr - 1]));
468 }
469 
470 /* Note: we save and restore the fan minimum here, because its value is
471    determined in part by the fan divisor.  This follows the principle of
472    least suprise; the user doesn't expect the fan minimum to change just
473    because the divisor changed. */
474 static ssize_t
475 store_fan_div(struct device *dev, struct device_attribute *attr,
476 		const char *buf, size_t count)
477 {
478 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
479 	int nr = sensor_attr->index - 1;
480 	struct i2c_client *client = to_i2c_client(dev);
481 	struct w83792d_data *data = i2c_get_clientdata(client);
482 	unsigned long min;
483 	/*u8 reg;*/
484 	u8 fan_div_reg = 0;
485 	u8 tmp_fan_div;
486 
487 	/* Save fan_min */
488 	min = FAN_FROM_REG(data->fan_min[nr],
489 			   DIV_FROM_REG(data->fan_div[nr]));
490 
491 	data->fan_div[nr] = DIV_TO_REG(simple_strtoul(buf, NULL, 10));
492 
493 	fan_div_reg = w83792d_read_value(client, W83792D_REG_FAN_DIV[nr >> 1]);
494 	fan_div_reg &= (nr & 0x01) ? 0x8f : 0xf8;
495 	tmp_fan_div = (nr & 0x01) ? (((data->fan_div[nr]) << 4) & 0x70)
496 					: ((data->fan_div[nr]) & 0x07);
497 	w83792d_write_value(client, W83792D_REG_FAN_DIV[nr >> 1],
498 					fan_div_reg | tmp_fan_div);
499 
500 	/* Restore fan_min */
501 	data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
502 	w83792d_write_value(client, W83792D_REG_FAN_MIN[nr], data->fan_min[nr]);
503 
504 	return count;
505 }
506 
507 #define sysfs_fan(offset) \
508 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan, NULL, \
509 				offset); \
510 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
511 				show_fan_div, store_fan_div, offset); \
512 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
513 				show_fan_min, store_fan_min, offset);
514 
515 sysfs_fan(1);
516 sysfs_fan(2);
517 sysfs_fan(3);
518 sysfs_fan(4);
519 sysfs_fan(5);
520 sysfs_fan(6);
521 sysfs_fan(7);
522 
523 #define device_create_file_fan(client, offset) \
524 do { \
525 device_create_file(&client->dev, &sensor_dev_attr_fan##offset##_input.dev_attr); \
526 device_create_file(&client->dev, &sensor_dev_attr_fan##offset##_div.dev_attr); \
527 device_create_file(&client->dev, &sensor_dev_attr_fan##offset##_min.dev_attr); \
528 } while (0)
529 
530 
531 /* read/write the temperature1, includes measured value and limits */
532 
533 static ssize_t show_temp1(struct device *dev, struct device_attribute *attr,
534 				char *buf)
535 {
536 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
537 	int nr = sensor_attr->index;
538 	struct w83792d_data *data = w83792d_update_device(dev);
539 	return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp1[nr]));
540 }
541 
542 static ssize_t store_temp1(struct device *dev, struct device_attribute *attr,
543 				const char *buf, size_t count)
544 {
545 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
546 	int nr = sensor_attr->index;
547 	struct i2c_client *client = to_i2c_client(dev);
548 	struct w83792d_data *data = i2c_get_clientdata(client);
549 	s32 val;
550 
551 	val = simple_strtol(buf, NULL, 10);
552 
553 	data->temp1[nr] = TEMP1_TO_REG(val);
554 	w83792d_write_value(client, W83792D_REG_TEMP1[nr],
555 		data->temp1[nr]);
556 
557 	return count;
558 }
559 
560 
561 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp1, NULL, 0);
562 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, show_temp1,
563 				store_temp1, 1);
564 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, show_temp1,
565 				store_temp1, 2);
566 
567 #define device_create_file_temp1(client) \
568 do { \
569 device_create_file(&client->dev, &sensor_dev_attr_temp1_input.dev_attr); \
570 device_create_file(&client->dev, &sensor_dev_attr_temp1_max.dev_attr); \
571 device_create_file(&client->dev, &sensor_dev_attr_temp1_max_hyst.dev_attr); \
572 } while (0)
573 
574 
575 /* read/write the temperature2-3, includes measured value and limits */
576 
577 static ssize_t show_temp23(struct device *dev, struct device_attribute *attr,
578 				char *buf)
579 {
580 	struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr);
581 	int nr = sensor_attr->nr;
582 	int index = sensor_attr->index;
583 	struct w83792d_data *data = w83792d_update_device(dev);
584 	return sprintf(buf,"%ld\n",
585 		(long)TEMP_ADD_FROM_REG(data->temp_add[nr][index],
586 			data->temp_add[nr][index+1]));
587 }
588 
589 static ssize_t store_temp23(struct device *dev, struct device_attribute *attr,
590 				const char *buf, size_t count)
591 {
592 	struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr);
593 	int nr = sensor_attr->nr;
594 	int index = sensor_attr->index;
595 	struct i2c_client *client = to_i2c_client(dev);
596 	struct w83792d_data *data = i2c_get_clientdata(client);
597 	s32 val;
598 
599 	val = simple_strtol(buf, NULL, 10);
600 
601 	data->temp_add[nr][index] = TEMP_ADD_TO_REG_HIGH(val);
602 	data->temp_add[nr][index+1] = TEMP_ADD_TO_REG_LOW(val);
603 	w83792d_write_value(client, W83792D_REG_TEMP_ADD[nr][index],
604 		data->temp_add[nr][index]);
605 	w83792d_write_value(client, W83792D_REG_TEMP_ADD[nr][index+1],
606 		data->temp_add[nr][index+1]);
607 
608 	return count;
609 }
610 
611 #define sysfs_temp23(name,idx) \
612 static SENSOR_DEVICE_ATTR_2(name##_input, S_IRUGO, show_temp23, NULL, \
613 				idx, 0); \
614 static SENSOR_DEVICE_ATTR_2(name##_max, S_IRUGO | S_IWUSR, \
615 				show_temp23, store_temp23, idx, 2); \
616 static SENSOR_DEVICE_ATTR_2(name##_max_hyst, S_IRUGO | S_IWUSR, \
617 				show_temp23, store_temp23, idx, 4);
618 
619 sysfs_temp23(temp2,0)
620 sysfs_temp23(temp3,1)
621 
622 #define device_create_file_temp_add(client, offset) \
623 do { \
624 device_create_file(&client->dev, &sensor_dev_attr_temp##offset##_input.dev_attr); \
625 device_create_file(&client->dev, &sensor_dev_attr_temp##offset##_max.dev_attr); \
626 device_create_file(&client->dev, \
627 &sensor_dev_attr_temp##offset##_max_hyst.dev_attr); \
628 } while (0)
629 
630 
631 /* get reatime status of all sensors items: voltage, temp, fan */
632 static ssize_t
633 show_alarms_reg(struct device *dev, struct device_attribute *attr, char *buf)
634 {
635 	struct w83792d_data *data = w83792d_update_device(dev);
636 	return sprintf(buf, "%d\n", data->alarms);
637 }
638 
639 static
640 DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
641 #define device_create_file_alarms(client) \
642 device_create_file(&client->dev, &dev_attr_alarms);
643 
644 
645 
646 static ssize_t
647 show_pwm(struct device *dev, struct device_attribute *attr,
648 		char *buf)
649 {
650 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
651 	int nr = sensor_attr->index;
652 	struct w83792d_data *data = w83792d_update_device(dev);
653 	return sprintf(buf, "%ld\n", (long) PWM_FROM_REG(data->pwm[nr-1]));
654 }
655 
656 static ssize_t
657 show_pwmenable(struct device *dev, struct device_attribute *attr,
658 			char *buf)
659 {
660 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
661 	int nr = sensor_attr->index - 1;
662 	struct w83792d_data *data = w83792d_update_device(dev);
663 	long pwm_enable_tmp = 1;
664 
665 	switch (data->pwmenable[nr]) {
666 	case 0:
667 		pwm_enable_tmp = 1; /* manual mode */
668 		break;
669 	case 1:
670 		pwm_enable_tmp = 3; /*thermal cruise/Smart Fan I */
671 		break;
672 	case 2:
673 		pwm_enable_tmp = 2; /* Smart Fan II */
674 		break;
675 	}
676 
677 	return sprintf(buf, "%ld\n", pwm_enable_tmp);
678 }
679 
680 static ssize_t
681 store_pwm(struct device *dev, struct device_attribute *attr,
682 		const char *buf, size_t count)
683 {
684 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
685 	int nr = sensor_attr->index - 1;
686 	struct i2c_client *client = to_i2c_client(dev);
687 	struct w83792d_data *data = i2c_get_clientdata(client);
688 	u32 val;
689 
690 	val = simple_strtoul(buf, NULL, 10);
691 	data->pwm[nr] = PWM_TO_REG(val);
692 	w83792d_write_value(client, W83792D_REG_PWM[nr], data->pwm[nr]);
693 
694 	return count;
695 }
696 
697 static ssize_t
698 store_pwmenable(struct device *dev, struct device_attribute *attr,
699 			const char *buf, size_t count)
700 {
701 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
702 	int nr = sensor_attr->index - 1;
703 	struct i2c_client *client = to_i2c_client(dev);
704 	struct w83792d_data *data = i2c_get_clientdata(client);
705 	u32 val;
706 	u8 fan_cfg_tmp, cfg1_tmp, cfg2_tmp, cfg3_tmp, cfg4_tmp;
707 
708 	val = simple_strtoul(buf, NULL, 10);
709 	switch (val) {
710 	case 1:
711 		data->pwmenable[nr] = 0; /* manual mode */
712 		break;
713 	case 2:
714 		data->pwmenable[nr] = 2; /* Smart Fan II */
715 		break;
716 	case 3:
717 		data->pwmenable[nr] = 1; /* thermal cruise/Smart Fan I */
718 		break;
719 	default:
720 		return -EINVAL;
721 	}
722 	cfg1_tmp = data->pwmenable[0];
723 	cfg2_tmp = (data->pwmenable[1]) << 2;
724 	cfg3_tmp = (data->pwmenable[2]) << 4;
725 	cfg4_tmp = w83792d_read_value(client,W83792D_REG_FAN_CFG) & 0xc0;
726 	fan_cfg_tmp = ((cfg4_tmp | cfg3_tmp) | cfg2_tmp) | cfg1_tmp;
727 	w83792d_write_value(client, W83792D_REG_FAN_CFG, fan_cfg_tmp);
728 
729 	return count;
730 }
731 
732 #define sysfs_pwm(offset) \
733 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
734 				show_pwm, store_pwm, offset); \
735 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \
736 				show_pwmenable, store_pwmenable, offset); \
737 
738 sysfs_pwm(1);
739 sysfs_pwm(2);
740 sysfs_pwm(3);
741 
742 
743 #define device_create_file_pwm(client, offset) \
744 do { \
745 device_create_file(&client->dev, &sensor_dev_attr_pwm##offset.dev_attr); \
746 } while (0)
747 
748 #define device_create_file_pwmenable(client, offset) \
749 do { \
750 device_create_file(&client->dev, &sensor_dev_attr_pwm##offset##_enable.dev_attr); \
751 } while (0)
752 
753 
754 static ssize_t
755 show_pwm_mode(struct device *dev, struct device_attribute *attr,
756 			char *buf)
757 {
758 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
759 	int nr = sensor_attr->index;
760 	struct w83792d_data *data = w83792d_update_device(dev);
761 	return sprintf(buf, "%d\n", data->pwm_mode[nr-1]);
762 }
763 
764 static ssize_t
765 store_pwm_mode(struct device *dev, struct device_attribute *attr,
766 			const char *buf, size_t count)
767 {
768 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
769 	int nr = sensor_attr->index - 1;
770 	struct i2c_client *client = to_i2c_client(dev);
771 	struct w83792d_data *data = i2c_get_clientdata(client);
772 	u32 val;
773 	u8 pwm_mode_mask = 0;
774 
775 	val = simple_strtoul(buf, NULL, 10);
776 	data->pwm_mode[nr] = SENSORS_LIMIT(val, 0, 1);
777 	pwm_mode_mask = w83792d_read_value(client,
778 		W83792D_REG_PWM[nr]) & 0x7f;
779 	w83792d_write_value(client, W83792D_REG_PWM[nr],
780 		((data->pwm_mode[nr]) << 7) | pwm_mode_mask);
781 
782 	return count;
783 }
784 
785 #define sysfs_pwm_mode(offset) \
786 static SENSOR_DEVICE_ATTR(pwm##offset##_mode, S_IRUGO | S_IWUSR, \
787 				show_pwm_mode, store_pwm_mode, offset);
788 
789 sysfs_pwm_mode(1);
790 sysfs_pwm_mode(2);
791 sysfs_pwm_mode(3);
792 
793 #define device_create_file_pwm_mode(client, offset) \
794 do { \
795 device_create_file(&client->dev, &sensor_dev_attr_pwm##offset##_mode.dev_attr); \
796 } while (0)
797 
798 
799 static ssize_t
800 show_regs_chassis(struct device *dev, struct device_attribute *attr,
801 			char *buf)
802 {
803 	struct w83792d_data *data = w83792d_update_device(dev);
804 	return sprintf(buf, "%d\n", data->chassis);
805 }
806 
807 static DEVICE_ATTR(chassis, S_IRUGO, show_regs_chassis, NULL);
808 
809 #define device_create_file_chassis(client) \
810 do { \
811 device_create_file(&client->dev, &dev_attr_chassis); \
812 } while (0)
813 
814 
815 static ssize_t
816 show_chassis_clear(struct device *dev, struct device_attribute *attr, char *buf)
817 {
818 	struct w83792d_data *data = w83792d_update_device(dev);
819 	return sprintf(buf, "%d\n", data->chassis_clear);
820 }
821 
822 static ssize_t
823 store_chassis_clear(struct device *dev, struct device_attribute *attr,
824 			const char *buf, size_t count)
825 {
826 	struct i2c_client *client = to_i2c_client(dev);
827 	struct w83792d_data *data = i2c_get_clientdata(client);
828 	u32 val;
829 	u8 temp1 = 0, temp2 = 0;
830 
831 	val = simple_strtoul(buf, NULL, 10);
832 
833 	data->chassis_clear = SENSORS_LIMIT(val, 0 ,1);
834 	temp1 = ((data->chassis_clear) << 7) & 0x80;
835 	temp2 = w83792d_read_value(client,
836 		W83792D_REG_CHASSIS_CLR) & 0x7f;
837 	w83792d_write_value(client, W83792D_REG_CHASSIS_CLR, temp1 | temp2);
838 
839 	return count;
840 }
841 
842 static DEVICE_ATTR(chassis_clear, S_IRUGO | S_IWUSR,
843 		show_chassis_clear, store_chassis_clear);
844 
845 #define device_create_file_chassis_clear(client) \
846 do { \
847 device_create_file(&client->dev, &dev_attr_chassis_clear); \
848 } while (0)
849 
850 
851 
852 /* For Smart Fan I / Thermal Cruise */
853 static ssize_t
854 show_thermal_cruise(struct device *dev, struct device_attribute *attr,
855 			char *buf)
856 {
857 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
858 	int nr = sensor_attr->index;
859 	struct w83792d_data *data = w83792d_update_device(dev);
860 	return sprintf(buf, "%ld\n", (long)data->thermal_cruise[nr-1]);
861 }
862 
863 static ssize_t
864 store_thermal_cruise(struct device *dev, struct device_attribute *attr,
865 			const char *buf, size_t count)
866 {
867 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
868 	int nr = sensor_attr->index - 1;
869 	struct i2c_client *client = to_i2c_client(dev);
870 	struct w83792d_data *data = i2c_get_clientdata(client);
871 	u32 val;
872 	u8 target_tmp=0, target_mask=0;
873 
874 	val = simple_strtoul(buf, NULL, 10);
875 	target_tmp = val;
876 	target_tmp = target_tmp & 0x7f;
877 	target_mask = w83792d_read_value(client, W83792D_REG_THERMAL[nr]) & 0x80;
878 	data->thermal_cruise[nr] = SENSORS_LIMIT(target_tmp, 0, 255);
879 	w83792d_write_value(client, W83792D_REG_THERMAL[nr],
880 		(data->thermal_cruise[nr]) | target_mask);
881 
882 	return count;
883 }
884 
885 #define sysfs_thermal_cruise(offset) \
886 static SENSOR_DEVICE_ATTR(thermal_cruise##offset, S_IRUGO | S_IWUSR, \
887 			show_thermal_cruise, store_thermal_cruise, offset);
888 
889 sysfs_thermal_cruise(1);
890 sysfs_thermal_cruise(2);
891 sysfs_thermal_cruise(3);
892 
893 #define device_create_file_thermal_cruise(client, offset) \
894 do { \
895 device_create_file(&client->dev, \
896 &sensor_dev_attr_thermal_cruise##offset.dev_attr); \
897 } while (0)
898 
899 
900 /* For Smart Fan I/Thermal Cruise and Smart Fan II */
901 static ssize_t
902 show_tolerance(struct device *dev, struct device_attribute *attr,
903 		char *buf)
904 {
905 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
906 	int nr = sensor_attr->index;
907 	struct w83792d_data *data = w83792d_update_device(dev);
908 	return sprintf(buf, "%ld\n", (long)data->tolerance[nr-1]);
909 }
910 
911 static ssize_t
912 store_tolerance(struct device *dev, struct device_attribute *attr,
913 		const char *buf, size_t count)
914 {
915 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
916 	int nr = sensor_attr->index - 1;
917 	struct i2c_client *client = to_i2c_client(dev);
918 	struct w83792d_data *data = i2c_get_clientdata(client);
919 	u32 val;
920 	u8 tol_tmp, tol_mask;
921 
922 	val = simple_strtoul(buf, NULL, 10);
923 	tol_mask = w83792d_read_value(client,
924 		W83792D_REG_TOLERANCE[nr]) & ((nr == 1) ? 0x0f : 0xf0);
925 	tol_tmp = SENSORS_LIMIT(val, 0, 15);
926 	tol_tmp &= 0x0f;
927 	data->tolerance[nr] = tol_tmp;
928 	if (nr == 1) {
929 		tol_tmp <<= 4;
930 	}
931 	w83792d_write_value(client, W83792D_REG_TOLERANCE[nr],
932 		tol_mask | tol_tmp);
933 
934 	return count;
935 }
936 
937 #define sysfs_tolerance(offset) \
938 static SENSOR_DEVICE_ATTR(tolerance##offset, S_IRUGO | S_IWUSR, \
939 				show_tolerance, store_tolerance, offset);
940 
941 sysfs_tolerance(1);
942 sysfs_tolerance(2);
943 sysfs_tolerance(3);
944 
945 #define device_create_file_tolerance(client, offset) \
946 do { \
947 device_create_file(&client->dev, &sensor_dev_attr_tolerance##offset.dev_attr); \
948 } while (0)
949 
950 
951 /* For Smart Fan II */
952 static ssize_t
953 show_sf2_point(struct device *dev, struct device_attribute *attr,
954 		char *buf)
955 {
956 	struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr);
957 	int nr = sensor_attr->nr;
958 	int index = sensor_attr->index;
959 	struct w83792d_data *data = w83792d_update_device(dev);
960 	return sprintf(buf, "%ld\n", (long)data->sf2_points[index-1][nr-1]);
961 }
962 
963 static ssize_t
964 store_sf2_point(struct device *dev, struct device_attribute *attr,
965 		const char *buf, size_t count)
966 {
967 	struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr);
968 	int nr = sensor_attr->nr - 1;
969 	int index = sensor_attr->index - 1;
970 	struct i2c_client *client = to_i2c_client(dev);
971 	struct w83792d_data *data = i2c_get_clientdata(client);
972 	u32 val;
973 	u8 mask_tmp = 0;
974 
975 	val = simple_strtoul(buf, NULL, 10);
976 	data->sf2_points[index][nr] = SENSORS_LIMIT(val, 0, 127);
977 	mask_tmp = w83792d_read_value(client,
978 					W83792D_REG_POINTS[index][nr]) & 0x80;
979 	w83792d_write_value(client, W83792D_REG_POINTS[index][nr],
980 		mask_tmp|data->sf2_points[index][nr]);
981 
982 	return count;
983 }
984 
985 #define sysfs_sf2_point(offset, index) \
986 static SENSOR_DEVICE_ATTR_2(sf2_point##offset##_fan##index, S_IRUGO | S_IWUSR, \
987 				show_sf2_point, store_sf2_point, offset, index);
988 
989 sysfs_sf2_point(1, 1);	/* Fan1 */
990 sysfs_sf2_point(2, 1);	/* Fan1 */
991 sysfs_sf2_point(3, 1);	/* Fan1 */
992 sysfs_sf2_point(4, 1);	/* Fan1 */
993 sysfs_sf2_point(1, 2);	/* Fan2 */
994 sysfs_sf2_point(2, 2);	/* Fan2 */
995 sysfs_sf2_point(3, 2);	/* Fan2 */
996 sysfs_sf2_point(4, 2);	/* Fan2 */
997 sysfs_sf2_point(1, 3);	/* Fan3 */
998 sysfs_sf2_point(2, 3);	/* Fan3 */
999 sysfs_sf2_point(3, 3);	/* Fan3 */
1000 sysfs_sf2_point(4, 3);	/* Fan3 */
1001 
1002 #define device_create_file_sf2_point(client, offset, index) \
1003 do { \
1004 device_create_file(&client->dev, \
1005 &sensor_dev_attr_sf2_point##offset##_fan##index.dev_attr); \
1006 } while (0)
1007 
1008 
1009 static ssize_t
1010 show_sf2_level(struct device *dev, struct device_attribute *attr,
1011 		char *buf)
1012 {
1013 	struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr);
1014 	int nr = sensor_attr->nr;
1015 	int index = sensor_attr->index;
1016 	struct w83792d_data *data = w83792d_update_device(dev);
1017 	return sprintf(buf, "%d\n",
1018 			(((data->sf2_levels[index-1][nr]) * 100) / 15));
1019 }
1020 
1021 static ssize_t
1022 store_sf2_level(struct device *dev, struct device_attribute *attr,
1023 		const char *buf, size_t count)
1024 {
1025 	struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr);
1026 	int nr = sensor_attr->nr;
1027 	int index = sensor_attr->index - 1;
1028 	struct i2c_client *client = to_i2c_client(dev);
1029 	struct w83792d_data *data = i2c_get_clientdata(client);
1030 	u32 val;
1031 	u8 mask_tmp=0, level_tmp=0;
1032 
1033 	val = simple_strtoul(buf, NULL, 10);
1034 	data->sf2_levels[index][nr] = SENSORS_LIMIT((val * 15) / 100, 0, 15);
1035 	mask_tmp = w83792d_read_value(client, W83792D_REG_LEVELS[index][nr])
1036 		& ((nr==3) ? 0xf0 : 0x0f);
1037 	if (nr==3) {
1038 		level_tmp = data->sf2_levels[index][nr];
1039 	} else {
1040 		level_tmp = data->sf2_levels[index][nr] << 4;
1041 	}
1042 	w83792d_write_value(client, W83792D_REG_LEVELS[index][nr], level_tmp | mask_tmp);
1043 
1044 	return count;
1045 }
1046 
1047 #define sysfs_sf2_level(offset, index) \
1048 static SENSOR_DEVICE_ATTR_2(sf2_level##offset##_fan##index, S_IRUGO | S_IWUSR, \
1049 				show_sf2_level, store_sf2_level, offset, index);
1050 
1051 sysfs_sf2_level(1, 1);	/* Fan1 */
1052 sysfs_sf2_level(2, 1);	/* Fan1 */
1053 sysfs_sf2_level(3, 1);	/* Fan1 */
1054 sysfs_sf2_level(1, 2);	/* Fan2 */
1055 sysfs_sf2_level(2, 2);	/* Fan2 */
1056 sysfs_sf2_level(3, 2);	/* Fan2 */
1057 sysfs_sf2_level(1, 3);	/* Fan3 */
1058 sysfs_sf2_level(2, 3);	/* Fan3 */
1059 sysfs_sf2_level(3, 3);	/* Fan3 */
1060 
1061 #define device_create_file_sf2_level(client, offset, index) \
1062 do { \
1063 device_create_file(&client->dev, \
1064 &sensor_dev_attr_sf2_level##offset##_fan##index.dev_attr); \
1065 } while (0)
1066 
1067 
1068 /* This function is called when:
1069      * w83792d_driver is inserted (when this module is loaded), for each
1070        available adapter
1071      * when a new adapter is inserted (and w83792d_driver is still present) */
1072 static int
1073 w83792d_attach_adapter(struct i2c_adapter *adapter)
1074 {
1075 	if (!(adapter->class & I2C_CLASS_HWMON))
1076 		return 0;
1077 	return i2c_probe(adapter, &addr_data, w83792d_detect);
1078 }
1079 
1080 
1081 static int
1082 w83792d_create_subclient(struct i2c_adapter *adapter,
1083 				struct i2c_client *new_client, int addr,
1084 				struct i2c_client **sub_cli)
1085 {
1086 	int err;
1087 	struct i2c_client *sub_client;
1088 
1089 	(*sub_cli) = sub_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1090 	if (!(sub_client)) {
1091 		return -ENOMEM;
1092 	}
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 = kzalloc(sizeof(struct w83792d_data), GFP_KERNEL))) {
1187 		err = -ENOMEM;
1188 		goto ERROR0;
1189 	}
1190 
1191 	new_client = &data->client;
1192 	i2c_set_clientdata(new_client, data);
1193 	new_client->addr = address;
1194 	init_MUTEX(&data->lock);
1195 	new_client->adapter = adapter;
1196 	new_client->driver = &w83792d_driver;
1197 	new_client->flags = 0;
1198 
1199 	/* Now, we do the remaining detection. */
1200 
1201 	/* The w83792d may be stuck in some other bank than bank 0. This may
1202 	   make reading other information impossible. Specify a force=... or
1203 	   force_*=... parameter, and the Winbond will be reset to the right
1204 	   bank. */
1205 	if (kind < 0) {
1206 		if (w83792d_read_value(new_client, W83792D_REG_CONFIG) & 0x80) {
1207 			dev_warn(&new_client->dev, "Detection failed at step "
1208 				"3\n");
1209 			goto ERROR1;
1210 		}
1211 		val1 = w83792d_read_value(new_client, W83792D_REG_BANK);
1212 		val2 = w83792d_read_value(new_client, W83792D_REG_CHIPMAN);
1213 		/* Check for Winbond ID if in bank 0 */
1214 		if (!(val1 & 0x07)) {  /* is Bank0 */
1215 			if (((!(val1 & 0x80)) && (val2 != 0xa3)) ||
1216 			     ((val1 & 0x80) && (val2 != 0x5c))) {
1217 				goto ERROR1;
1218 			}
1219 		}
1220 		/* If Winbond chip, address of chip and W83792D_REG_I2C_ADDR
1221 		   should match */
1222 		if (w83792d_read_value(new_client,
1223 					W83792D_REG_I2C_ADDR) != address) {
1224 			dev_warn(&new_client->dev, "Detection failed "
1225 				"at step 5\n");
1226 			goto ERROR1;
1227 		}
1228 	}
1229 
1230 	/* We have either had a force parameter, or we have already detected the
1231 	   Winbond. Put it now into bank 0 and Vendor ID High Byte */
1232 	w83792d_write_value(new_client,
1233 			    W83792D_REG_BANK,
1234 			    (w83792d_read_value(new_client,
1235 				W83792D_REG_BANK) & 0x78) | 0x80);
1236 
1237 	/* Determine the chip type. */
1238 	if (kind <= 0) {
1239 		/* get vendor ID */
1240 		val2 = w83792d_read_value(new_client, W83792D_REG_CHIPMAN);
1241 		if (val2 != 0x5c) {  /* the vendor is NOT Winbond */
1242 			goto ERROR1;
1243 		}
1244 		val1 = w83792d_read_value(new_client, W83792D_REG_WCHIPID);
1245 		if (val1 == 0x7a && address >= 0x2c) {
1246 			kind = w83792d;
1247 		} else {
1248 			if (kind == 0)
1249 					dev_warn(&new_client->dev,
1250 					"w83792d: Ignoring 'force' parameter for"
1251 					" unknown chip at adapter %d, address"
1252 					" 0x%02x\n", i2c_adapter_id(adapter),
1253 					address);
1254 			goto ERROR1;
1255 		}
1256 	}
1257 
1258 	if (kind == w83792d) {
1259 		client_name = "w83792d";
1260 	} else {
1261 		dev_err(&new_client->dev, "w83792d: Internal error: unknown"
1262 					  " kind (%d)?!?", kind);
1263 		goto ERROR1;
1264 	}
1265 
1266 	/* Fill in the remaining client fields and put into the global list */
1267 	strlcpy(new_client->name, client_name, I2C_NAME_SIZE);
1268 	data->type = kind;
1269 
1270 	data->valid = 0;
1271 	init_MUTEX(&data->update_lock);
1272 
1273 	/* Tell the I2C layer a new client has arrived */
1274 	if ((err = i2c_attach_client(new_client)))
1275 		goto ERROR1;
1276 
1277 	if ((err = w83792d_detect_subclients(adapter, address,
1278 			kind, new_client)))
1279 		goto ERROR2;
1280 
1281 	/* Initialize the chip */
1282 	w83792d_init_client(new_client);
1283 
1284 	/* A few vars need to be filled upon startup */
1285 	for (i = 1; i <= 7; i++) {
1286 		data->fan_min[i - 1] = w83792d_read_value(new_client,
1287 					W83792D_REG_FAN_MIN[i]);
1288 	}
1289 
1290 	/* Register sysfs hooks */
1291 	data->class_dev = hwmon_device_register(&new_client->dev);
1292 	if (IS_ERR(data->class_dev)) {
1293 		err = PTR_ERR(data->class_dev);
1294 		goto ERROR3;
1295 	}
1296 	device_create_file_in(new_client, 0);
1297 	device_create_file_in(new_client, 1);
1298 	device_create_file_in(new_client, 2);
1299 	device_create_file_in(new_client, 3);
1300 	device_create_file_in(new_client, 4);
1301 	device_create_file_in(new_client, 5);
1302 	device_create_file_in(new_client, 6);
1303 	device_create_file_in(new_client, 7);
1304 	device_create_file_in(new_client, 8);
1305 
1306 	device_create_file_fan(new_client, 1);
1307 	device_create_file_fan(new_client, 2);
1308 	device_create_file_fan(new_client, 3);
1309 	device_create_file_fan(new_client, 4);
1310 	device_create_file_fan(new_client, 5);
1311 	device_create_file_fan(new_client, 6);
1312 	device_create_file_fan(new_client, 7);
1313 
1314 	device_create_file_temp1(new_client);		/* Temp1 */
1315 	device_create_file_temp_add(new_client, 2);	/* Temp2 */
1316 	device_create_file_temp_add(new_client, 3);	/* Temp3 */
1317 
1318 	device_create_file_alarms(new_client);
1319 
1320 	device_create_file_pwm(new_client, 1);
1321 	device_create_file_pwm(new_client, 2);
1322 	device_create_file_pwm(new_client, 3);
1323 
1324 	device_create_file_pwmenable(new_client, 1);
1325 	device_create_file_pwmenable(new_client, 2);
1326 	device_create_file_pwmenable(new_client, 3);
1327 
1328 	device_create_file_pwm_mode(new_client, 1);
1329 	device_create_file_pwm_mode(new_client, 2);
1330 	device_create_file_pwm_mode(new_client, 3);
1331 
1332 	device_create_file_chassis(new_client);
1333 	device_create_file_chassis_clear(new_client);
1334 
1335 	device_create_file_thermal_cruise(new_client, 1);
1336 	device_create_file_thermal_cruise(new_client, 2);
1337 	device_create_file_thermal_cruise(new_client, 3);
1338 
1339 	device_create_file_tolerance(new_client, 1);
1340 	device_create_file_tolerance(new_client, 2);
1341 	device_create_file_tolerance(new_client, 3);
1342 
1343 	device_create_file_sf2_point(new_client, 1, 1);	/* Fan1 */
1344 	device_create_file_sf2_point(new_client, 2, 1);	/* Fan1 */
1345 	device_create_file_sf2_point(new_client, 3, 1);	/* Fan1 */
1346 	device_create_file_sf2_point(new_client, 4, 1);	/* Fan1 */
1347 	device_create_file_sf2_point(new_client, 1, 2);	/* Fan2 */
1348 	device_create_file_sf2_point(new_client, 2, 2);	/* Fan2 */
1349 	device_create_file_sf2_point(new_client, 3, 2);	/* Fan2 */
1350 	device_create_file_sf2_point(new_client, 4, 2);	/* Fan2 */
1351 	device_create_file_sf2_point(new_client, 1, 3);	/* Fan3 */
1352 	device_create_file_sf2_point(new_client, 2, 3);	/* Fan3 */
1353 	device_create_file_sf2_point(new_client, 3, 3);	/* Fan3 */
1354 	device_create_file_sf2_point(new_client, 4, 3);	/* Fan3 */
1355 
1356 	device_create_file_sf2_level(new_client, 1, 1);	/* Fan1 */
1357 	device_create_file_sf2_level(new_client, 2, 1);	/* Fan1 */
1358 	device_create_file_sf2_level(new_client, 3, 1);	/* Fan1 */
1359 	device_create_file_sf2_level(new_client, 1, 2);	/* Fan2 */
1360 	device_create_file_sf2_level(new_client, 2, 2);	/* Fan2 */
1361 	device_create_file_sf2_level(new_client, 3, 2);	/* Fan2 */
1362 	device_create_file_sf2_level(new_client, 1, 3);	/* Fan3 */
1363 	device_create_file_sf2_level(new_client, 2, 3);	/* Fan3 */
1364 	device_create_file_sf2_level(new_client, 3, 3);	/* Fan3 */
1365 
1366 	return 0;
1367 
1368 ERROR3:
1369 	if (data->lm75[0] != NULL) {
1370 		i2c_detach_client(data->lm75[0]);
1371 		kfree(data->lm75[0]);
1372 	}
1373 	if (data->lm75[1] != NULL) {
1374 		i2c_detach_client(data->lm75[1]);
1375 		kfree(data->lm75[1]);
1376 	}
1377 ERROR2:
1378 	i2c_detach_client(new_client);
1379 ERROR1:
1380 	kfree(data);
1381 ERROR0:
1382 	return err;
1383 }
1384 
1385 static int
1386 w83792d_detach_client(struct i2c_client *client)
1387 {
1388 	struct w83792d_data *data = i2c_get_clientdata(client);
1389 	int err;
1390 
1391 	/* main client */
1392 	if (data)
1393 		hwmon_device_unregister(data->class_dev);
1394 
1395 	if ((err = i2c_detach_client(client)))
1396 		return err;
1397 
1398 	/* main client */
1399 	if (data)
1400 		kfree(data);
1401 	/* subclient */
1402 	else
1403 		kfree(client);
1404 
1405 	return 0;
1406 }
1407 
1408 /* The SMBus locks itself, usually, but nothing may access the Winbond between
1409    bank switches. ISA access must always be locked explicitly!
1410    We ignore the W83792D BUSY flag at this moment - it could lead to deadlocks,
1411    would slow down the W83792D access and should not be necessary.
1412    There are some ugly typecasts here, but the good news is - they should
1413    nowhere else be necessary! */
1414 static int
1415 w83792d_read_value(struct i2c_client *client, u8 reg)
1416 {
1417 	int res=0;
1418 	res = i2c_smbus_read_byte_data(client, reg);
1419 
1420 	return res;
1421 }
1422 
1423 static int
1424 w83792d_write_value(struct i2c_client *client, u8 reg, u8 value)
1425 {
1426 	i2c_smbus_write_byte_data(client, reg,  value);
1427 	return 0;
1428 }
1429 
1430 static void
1431 w83792d_init_client(struct i2c_client *client)
1432 {
1433 	u8 temp2_cfg, temp3_cfg, vid_in_b;
1434 
1435 	if (init) {
1436 		w83792d_write_value(client, W83792D_REG_CONFIG, 0x80);
1437 	}
1438 	/* Clear the bit6 of W83792D_REG_VID_IN_B(set it into 0):
1439 	   W83792D_REG_VID_IN_B bit6 = 0: the high/low limit of
1440 	     vin0/vin1 can be modified by user;
1441 	   W83792D_REG_VID_IN_B bit6 = 1: the high/low limit of
1442 	     vin0/vin1 auto-updated, can NOT be modified by user. */
1443 	vid_in_b = w83792d_read_value(client, W83792D_REG_VID_IN_B);
1444 	w83792d_write_value(client, W83792D_REG_VID_IN_B,
1445 			    vid_in_b & 0xbf);
1446 
1447 	temp2_cfg = w83792d_read_value(client, W83792D_REG_TEMP2_CONFIG);
1448 	temp3_cfg = w83792d_read_value(client, W83792D_REG_TEMP3_CONFIG);
1449 	w83792d_write_value(client, W83792D_REG_TEMP2_CONFIG,
1450 				temp2_cfg & 0xe6);
1451 	w83792d_write_value(client, W83792D_REG_TEMP3_CONFIG,
1452 				temp3_cfg & 0xe6);
1453 
1454 	/* Start monitoring */
1455 	w83792d_write_value(client, W83792D_REG_CONFIG,
1456 			    (w83792d_read_value(client,
1457 						W83792D_REG_CONFIG) & 0xf7)
1458 			    | 0x01);
1459 }
1460 
1461 static struct w83792d_data *w83792d_update_device(struct device *dev)
1462 {
1463 	struct i2c_client *client = to_i2c_client(dev);
1464 	struct w83792d_data *data = i2c_get_clientdata(client);
1465 	int i, j;
1466 	u8 reg_array_tmp[4], pwm_array_tmp[7], reg_tmp;
1467 
1468 	down(&data->update_lock);
1469 
1470 	if (time_after
1471 	    (jiffies - data->last_updated, (unsigned long) (HZ * 3))
1472 	    || time_before(jiffies, data->last_updated) || !data->valid) {
1473 		dev_dbg(dev, "Starting device update\n");
1474 
1475 		/* Update the voltages measured value and limits */
1476 		for (i = 0; i < 9; i++) {
1477 			data->in[i] = w83792d_read_value(client,
1478 						W83792D_REG_IN[i]);
1479 			data->in_max[i] = w83792d_read_value(client,
1480 						W83792D_REG_IN_MAX[i]);
1481 			data->in_min[i] = w83792d_read_value(client,
1482 						W83792D_REG_IN_MIN[i]);
1483 		}
1484 		data->low_bits[0] = w83792d_read_value(client,
1485 						W83792D_REG_LOW_BITS1);
1486 		data->low_bits[1] = w83792d_read_value(client,
1487 						W83792D_REG_LOW_BITS2);
1488 		for (i = 0; i < 7; i++) {
1489 			/* Update the Fan measured value and limits */
1490 			data->fan[i] = w83792d_read_value(client,
1491 						W83792D_REG_FAN[i]);
1492 			data->fan_min[i] = w83792d_read_value(client,
1493 						W83792D_REG_FAN_MIN[i]);
1494 			/* Update the PWM/DC Value and PWM/DC flag */
1495 			pwm_array_tmp[i] = w83792d_read_value(client,
1496 						W83792D_REG_PWM[i]);
1497 			data->pwm[i] = pwm_array_tmp[i] & 0x0f;
1498 			data->pwm_mode[i] = (pwm_array_tmp[i] >> 7) & 0x01;
1499 		}
1500 
1501 		reg_tmp = w83792d_read_value(client, W83792D_REG_FAN_CFG);
1502 		data->pwmenable[0] = reg_tmp & 0x03;
1503 		data->pwmenable[1] = (reg_tmp>>2) & 0x03;
1504 		data->pwmenable[2] = (reg_tmp>>4) & 0x03;
1505 
1506 		for (i = 0; i < 3; i++) {
1507 			data->temp1[i] = w83792d_read_value(client,
1508 							W83792D_REG_TEMP1[i]);
1509 		}
1510 		for (i = 0; i < 2; i++) {
1511 			for (j = 0; j < 6; j++) {
1512 				data->temp_add[i][j] = w83792d_read_value(
1513 					client,W83792D_REG_TEMP_ADD[i][j]);
1514 			}
1515 		}
1516 
1517 		/* Update the Fan Divisor */
1518 		for (i = 0; i < 4; i++) {
1519 			reg_array_tmp[i] = w83792d_read_value(client,
1520 							W83792D_REG_FAN_DIV[i]);
1521 		}
1522 		data->fan_div[0] = reg_array_tmp[0] & 0x07;
1523 		data->fan_div[1] = (reg_array_tmp[0] >> 4) & 0x07;
1524 		data->fan_div[2] = reg_array_tmp[1] & 0x07;
1525 		data->fan_div[3] = (reg_array_tmp[1] >> 4) & 0x07;
1526 		data->fan_div[4] = reg_array_tmp[2] & 0x07;
1527 		data->fan_div[5] = (reg_array_tmp[2] >> 4) & 0x07;
1528 		data->fan_div[6] = reg_array_tmp[3] & 0x07;
1529 
1530 		/* Update the realtime status */
1531 		data->alarms = w83792d_read_value(client, W83792D_REG_ALARM1) +
1532 			(w83792d_read_value(client, W83792D_REG_ALARM2) << 8) +
1533 			(w83792d_read_value(client, W83792D_REG_ALARM3) << 16);
1534 
1535 		/* Update CaseOpen status and it's CLR_CHS. */
1536 		data->chassis = (w83792d_read_value(client,
1537 			W83792D_REG_CHASSIS) >> 5) & 0x01;
1538 		data->chassis_clear = (w83792d_read_value(client,
1539 			W83792D_REG_CHASSIS_CLR) >> 7) & 0x01;
1540 
1541 		/* Update Thermal Cruise/Smart Fan I target value */
1542 		for (i = 0; i < 3; i++) {
1543 			data->thermal_cruise[i] =
1544 				w83792d_read_value(client,
1545 				W83792D_REG_THERMAL[i]) & 0x7f;
1546 		}
1547 
1548 		/* Update Smart Fan I/II tolerance */
1549 		reg_tmp = w83792d_read_value(client, W83792D_REG_TOLERANCE[0]);
1550 		data->tolerance[0] = reg_tmp & 0x0f;
1551 		data->tolerance[1] = (reg_tmp >> 4) & 0x0f;
1552 		data->tolerance[2] = w83792d_read_value(client,
1553 					W83792D_REG_TOLERANCE[2]) & 0x0f;
1554 
1555 		/* Update Smart Fan II temperature points */
1556 		for (i = 0; i < 3; i++) {
1557 			for (j = 0; j < 4; j++) {
1558 				data->sf2_points[i][j] = w83792d_read_value(
1559 					client,W83792D_REG_POINTS[i][j]) & 0x7f;
1560 			}
1561 		}
1562 
1563 		/* Update Smart Fan II duty cycle levels */
1564 		for (i = 0; i < 3; i++) {
1565 			reg_tmp = w83792d_read_value(client,
1566 						W83792D_REG_LEVELS[i][0]);
1567 			data->sf2_levels[i][0] = reg_tmp & 0x0f;
1568 			data->sf2_levels[i][1] = (reg_tmp >> 4) & 0x0f;
1569 			reg_tmp = w83792d_read_value(client,
1570 						W83792D_REG_LEVELS[i][2]);
1571 			data->sf2_levels[i][2] = (reg_tmp >> 4) & 0x0f;
1572 			data->sf2_levels[i][3] = reg_tmp & 0x0f;
1573 		}
1574 
1575 		data->last_updated = jiffies;
1576 		data->valid = 1;
1577 	}
1578 
1579 	up(&data->update_lock);
1580 
1581 #ifdef DEBUG
1582 	w83792d_print_debug(data, dev);
1583 #endif
1584 
1585 	return data;
1586 }
1587 
1588 #ifdef DEBUG
1589 static void w83792d_print_debug(struct w83792d_data *data, struct device *dev)
1590 {
1591 	int i=0, j=0;
1592 	dev_dbg(dev, "==========The following is the debug message...========\n");
1593 	dev_dbg(dev, "9 set of Voltages: =====>\n");
1594 	for (i=0; i<9; i++) {
1595 		dev_dbg(dev, "vin[%d] is: 0x%x\n", i, data->in[i]);
1596 		dev_dbg(dev, "vin[%d] max is: 0x%x\n", i, data->in_max[i]);
1597 		dev_dbg(dev, "vin[%d] min is: 0x%x\n", i, data->in_min[i]);
1598 	}
1599 	dev_dbg(dev, "Low Bit1 is: 0x%x\n", data->low_bits[0]);
1600 	dev_dbg(dev, "Low Bit2 is: 0x%x\n", data->low_bits[1]);
1601 	dev_dbg(dev, "7 set of Fan Counts and Duty Cycles: =====>\n");
1602 	for (i=0; i<7; i++) {
1603 		dev_dbg(dev, "fan[%d] is: 0x%x\n", i, data->fan[i]);
1604 		dev_dbg(dev, "fan[%d] min is: 0x%x\n", i, data->fan_min[i]);
1605 		dev_dbg(dev, "pwm[%d]     is: 0x%x\n", i, data->pwm[i]);
1606 		dev_dbg(dev, "pwm_mode[%d] is: 0x%x\n", i, data->pwm_mode[i]);
1607 	}
1608 	dev_dbg(dev, "3 set of Temperatures: =====>\n");
1609 	for (i=0; i<3; i++) {
1610 		dev_dbg(dev, "temp1[%d] is: 0x%x\n", i, data->temp1[i]);
1611 	}
1612 
1613 	for (i=0; i<2; i++) {
1614 		for (j=0; j<6; j++) {
1615 			dev_dbg(dev, "temp_add[%d][%d] is: 0x%x\n", i, j,
1616 							data->temp_add[i][j]);
1617 		}
1618 	}
1619 
1620 	for (i=0; i<7; i++) {
1621 		dev_dbg(dev, "fan_div[%d] is: 0x%x\n", i, data->fan_div[i]);
1622 	}
1623 	dev_dbg(dev, "==========End of the debug message...==================\n");
1624 	dev_dbg(dev, "\n");
1625 }
1626 #endif
1627 
1628 static int __init
1629 sensors_w83792d_init(void)
1630 {
1631 	return i2c_add_driver(&w83792d_driver);
1632 }
1633 
1634 static void __exit
1635 sensors_w83792d_exit(void)
1636 {
1637 	i2c_del_driver(&w83792d_driver);
1638 }
1639 
1640 MODULE_AUTHOR("Chunhao Huang @ Winbond <DZShen@Winbond.com.tw>");
1641 MODULE_DESCRIPTION("W83792AD/D driver for linux-2.6");
1642 MODULE_LICENSE("GPL");
1643 
1644 module_init(sensors_w83792d_init);
1645 module_exit(sensors_w83792d_exit);
1646 
1647