?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'master' of /pub/scm/linux/kernel/git/torvalds/linux-2.6
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / hwmon / w83791d.c
blob97851c5ba3a3872caa715e130c3ff12a29c55297
1 /*
2 w83791d.c - Part of lm_sensors, Linux kernel modules for hardware
3 monitoring
4
5 Copyright (C) 2006-2007 Charles Spirakis <bezaur@gmail.com>
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22 /*
23 Supports following chips:
24
25 Chip #vin #fanin #pwm #temp wchipid vendid i2c ISA
26 w83791d 10 5 5 3 0x71 0x5ca3 yes no
27
28 The w83791d chip appears to be part way between the 83781d and the
29 83792d. Thus, this file is derived from both the w83792d.c and
30 w83781d.c files.
31
32 The w83791g chip is the same as the w83791d but lead-free.
33 */
34
35 #include <linux/module.h>
36 #include <linux/init.h>
37 #include <linux/slab.h>
38 #include <linux/i2c.h>
39 #include <linux/hwmon.h>
40 #include <linux/hwmon-vid.h>
41 #include <linux/hwmon-sysfs.h>
42 #include <linux/err.h>
43 #include <linux/mutex.h>
44
45 #define NUMBER_OF_VIN 10
46 #define NUMBER_OF_FANIN 5
47 #define NUMBER_OF_TEMPIN 3
48 #define NUMBER_OF_PWM 5
49
50 /* Addresses to scan */
51 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f,
52 I2C_CLIENT_END };
53
54 /* Insmod parameters */
55 I2C_CLIENT_INSMOD_1(w83791d);
56
57 static unsigned short force_subclients[4];
58 module_param_array(force_subclients, short, NULL, 0);
59 MODULE_PARM_DESC(force_subclients, "List of subclient addresses: "
60 "{bus, clientaddr, subclientaddr1, subclientaddr2}");
61
62 static int reset;
63 module_param(reset, bool, 0);
64 MODULE_PARM_DESC(reset, "Set to one to force a hardware chip reset");
65
66 static int init;
67 module_param(init, bool, 0);
68 MODULE_PARM_DESC(init, "Set to one to force extra software initialization");
69
70 /* The W83791D registers */
71 static const u8 W83791D_REG_IN[NUMBER_OF_VIN] = {
72 0x20, /* VCOREA in DataSheet */
73 0x21, /* VINR0 in DataSheet */
74 0x22, /* +3.3VIN in DataSheet */
75 0x23, /* VDD5V in DataSheet */
76 0x24, /* +12VIN in DataSheet */
77 0x25, /* -12VIN in DataSheet */
78 0x26, /* -5VIN in DataSheet */
79 0xB0, /* 5VSB in DataSheet */
80 0xB1, /* VBAT in DataSheet */
81 0xB2 /* VINR1 in DataSheet */
82 };
83
84 static const u8 W83791D_REG_IN_MAX[NUMBER_OF_VIN] = {
85 0x2B, /* VCOREA High Limit in DataSheet */
86 0x2D, /* VINR0 High Limit in DataSheet */
87 0x2F, /* +3.3VIN High Limit in DataSheet */
88 0x31, /* VDD5V High Limit in DataSheet */
89 0x33, /* +12VIN High Limit in DataSheet */
90 0x35, /* -12VIN High Limit in DataSheet */
91 0x37, /* -5VIN High Limit in DataSheet */
92 0xB4, /* 5VSB High Limit in DataSheet */
93 0xB6, /* VBAT High Limit in DataSheet */
94 0xB8 /* VINR1 High Limit in DataSheet */
95 };
96 static const u8 W83791D_REG_IN_MIN[NUMBER_OF_VIN] = {
97 0x2C, /* VCOREA Low Limit in DataSheet */
98 0x2E, /* VINR0 Low Limit in DataSheet */
99 0x30, /* +3.3VIN Low Limit in DataSheet */
100 0x32, /* VDD5V Low Limit in DataSheet */
101 0x34, /* +12VIN Low Limit in DataSheet */
102 0x36, /* -12VIN Low Limit in DataSheet */
103 0x38, /* -5VIN Low Limit in DataSheet */
104 0xB5, /* 5VSB Low Limit in DataSheet */
105 0xB7, /* VBAT Low Limit in DataSheet */
106 0xB9 /* VINR1 Low Limit in DataSheet */
107 };
108 static const u8 W83791D_REG_FAN[NUMBER_OF_FANIN] = {
109 0x28, /* FAN 1 Count in DataSheet */
110 0x29, /* FAN 2 Count in DataSheet */
111 0x2A, /* FAN 3 Count in DataSheet */
112 0xBA, /* FAN 4 Count in DataSheet */
113 0xBB, /* FAN 5 Count in DataSheet */
114 };
115 static const u8 W83791D_REG_FAN_MIN[NUMBER_OF_FANIN] = {
116 0x3B, /* FAN 1 Count Low Limit in DataSheet */
117 0x3C, /* FAN 2 Count Low Limit in DataSheet */
118 0x3D, /* FAN 3 Count Low Limit in DataSheet */
119 0xBC, /* FAN 4 Count Low Limit in DataSheet */
120 0xBD, /* FAN 5 Count Low Limit in DataSheet */
121 };
122
123 static const u8 W83791D_REG_PWM[NUMBER_OF_PWM] = {
124 0x81, /* PWM 1 duty cycle register in DataSheet */
125 0x83, /* PWM 2 duty cycle register in DataSheet */
126 0x94, /* PWM 3 duty cycle register in DataSheet */
127 0xA0, /* PWM 4 duty cycle register in DataSheet */
128 0xA1, /* PWM 5 duty cycle register in DataSheet */
129 };
130
131 static const u8 W83791D_REG_TEMP_TARGET[3] = {
132 0x85, /* PWM 1 target temperature for temp 1 */
133 0x86, /* PWM 2 target temperature for temp 2 */
134 0x96, /* PWM 3 target temperature for temp 3 */
135 };
136
137 static const u8 W83791D_REG_TEMP_TOL[2] = {
138 0x87, /* PWM 1/2 temperature tolerance */
139 0x97, /* PWM 3 temperature tolerance */
140 };
141
142 static const u8 W83791D_REG_FAN_CFG[2] = {
143 0x84, /* FAN 1/2 configuration */
144 0x95, /* FAN 3 configuration */
145 };
146
147 static const u8 W83791D_REG_FAN_DIV[3] = {
148 0x47, /* contains FAN1 and FAN2 Divisor */
149 0x4b, /* contains FAN3 Divisor */
150 0x5C, /* contains FAN4 and FAN5 Divisor */
151 };
152
153 #define W83791D_REG_BANK 0x4E
154 #define W83791D_REG_TEMP2_CONFIG 0xC2
155 #define W83791D_REG_TEMP3_CONFIG 0xCA
156
157 static const u8 W83791D_REG_TEMP1[3] = {
158 0x27, /* TEMP 1 in DataSheet */
159 0x39, /* TEMP 1 Over in DataSheet */
160 0x3A, /* TEMP 1 Hyst in DataSheet */
161 };
162
163 static const u8 W83791D_REG_TEMP_ADD[2][6] = {
164 {0xC0, /* TEMP 2 in DataSheet */
165 0xC1, /* TEMP 2(0.5 deg) in DataSheet */
166 0xC5, /* TEMP 2 Over High part in DataSheet */
167 0xC6, /* TEMP 2 Over Low part in DataSheet */
168 0xC3, /* TEMP 2 Thyst High part in DataSheet */
169 0xC4}, /* TEMP 2 Thyst Low part in DataSheet */
170 {0xC8, /* TEMP 3 in DataSheet */
171 0xC9, /* TEMP 3(0.5 deg) in DataSheet */
172 0xCD, /* TEMP 3 Over High part in DataSheet */
173 0xCE, /* TEMP 3 Over Low part in DataSheet */
174 0xCB, /* TEMP 3 Thyst High part in DataSheet */
175 0xCC} /* TEMP 3 Thyst Low part in DataSheet */
176 };
177
178 #define W83791D_REG_BEEP_CONFIG 0x4D
179
180 static const u8 W83791D_REG_BEEP_CTRL[3] = {
181 0x56, /* BEEP Control Register 1 */
182 0x57, /* BEEP Control Register 2 */
183 0xA3, /* BEEP Control Register 3 */
184 };
185
186 #define W83791D_REG_GPIO 0x15
187 #define W83791D_REG_CONFIG 0x40
188 #define W83791D_REG_VID_FANDIV 0x47
189 #define W83791D_REG_DID_VID4 0x49
190 #define W83791D_REG_WCHIPID 0x58
191 #define W83791D_REG_CHIPMAN 0x4F
192 #define W83791D_REG_PIN 0x4B
193 #define W83791D_REG_I2C_SUBADDR 0x4A
194
195 #define W83791D_REG_ALARM1 0xA9 /* realtime status register1 */
196 #define W83791D_REG_ALARM2 0xAA /* realtime status register2 */
197 #define W83791D_REG_ALARM3 0xAB /* realtime status register3 */
198
199 #define W83791D_REG_VBAT 0x5D
200 #define W83791D_REG_I2C_ADDR 0x48
201
202 /* The SMBus locks itself. The Winbond W83791D has a bank select register
203 (index 0x4e), but the driver only accesses registers in bank 0. Since
204 we don't switch banks, we don't need any special code to handle
205 locking access between bank switches */
206 static inline int w83791d_read(struct i2c_client *client, u8 reg)
207 {
208 return i2c_smbus_read_byte_data(client, reg);
209 }
210
211 static inline int w83791d_write(struct i2c_client *client, u8 reg, u8 value)
212 {
213 return i2c_smbus_write_byte_data(client, reg, value);
214 }
215
216 /* The analog voltage inputs have 16mV LSB. Since the sysfs output is
217 in mV as would be measured on the chip input pin, need to just
218 multiply/divide by 16 to translate from/to register values. */
219 #define IN_TO_REG(val) (SENSORS_LIMIT((((val) + 8) / 16), 0, 255))
220 #define IN_FROM_REG(val) ((val) * 16)
221
222 static u8 fan_to_reg(long rpm, int div)
223 {
224 if (rpm == 0)
225 return 255;
226 rpm = SENSORS_LIMIT(rpm, 1, 1000000);
227 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
228 }
229
230 #define FAN_FROM_REG(val,div) ((val) == 0 ? -1 : \
231 ((val) == 255 ? 0 : \
232 1350000 / ((val) * (div))))
233
234 /* for temp1 which is 8-bit resolution, LSB = 1 degree Celsius */
235 #define TEMP1_FROM_REG(val) ((val) * 1000)
236 #define TEMP1_TO_REG(val) ((val) <= -128000 ? -128 : \
237 (val) >= 127000 ? 127 : \
238 (val) < 0 ? ((val) - 500) / 1000 : \
239 ((val) + 500) / 1000)
240
241 /* for temp2 and temp3 which are 9-bit resolution, LSB = 0.5 degree Celsius
242 Assumes the top 8 bits are the integral amount and the bottom 8 bits
243 are the fractional amount. Since we only have 0.5 degree resolution,
244 the bottom 7 bits will always be zero */
245 #define TEMP23_FROM_REG(val) ((val) / 128 * 500)
246 #define TEMP23_TO_REG(val) ((val) <= -128000 ? 0x8000 : \
247 (val) >= 127500 ? 0x7F80 : \
248 (val) < 0 ? ((val) - 250) / 500 * 128 : \
249 ((val) + 250) / 500 * 128)
250
251 /* for thermal cruise target temp, 7-bits, LSB = 1 degree Celsius */
252 #define TARGET_TEMP_TO_REG(val) ((val) < 0 ? 0 : \
253 (val) >= 127000 ? 127 : \
254 ((val) + 500) / 1000)
255
256 /* for thermal cruise temp tolerance, 4-bits, LSB = 1 degree Celsius */
257 #define TOL_TEMP_TO_REG(val) ((val) < 0 ? 0 : \
258 (val) >= 15000 ? 15 : \
259 ((val) + 500) / 1000)
260
261 #define BEEP_MASK_TO_REG(val) ((val) & 0xffffff)
262 #define BEEP_MASK_FROM_REG(val) ((val) & 0xffffff)
263
264 #define DIV_FROM_REG(val) (1 << (val))
265
266 static u8 div_to_reg(int nr, long val)
267 {
268 int i;
269
270 /* fan divisors max out at 128 */
271 val = SENSORS_LIMIT(val, 1, 128) >> 1;
272 for (i = 0; i < 7; i++) {
273 if (val == 0)
274 break;
275 val >>= 1;
276 }
277 return (u8) i;
278 }
279
280 struct w83791d_data {
281 struct device *hwmon_dev;
282 struct mutex update_lock;
283
284 char valid; /* !=0 if following fields are valid */
285 unsigned long last_updated; /* In jiffies */
286
287 /* array of 2 pointers to subclients */
288 struct i2c_client *lm75[2];
289
290 /* volts */
291 u8 in[NUMBER_OF_VIN]; /* Register value */
292 u8 in_max[NUMBER_OF_VIN]; /* Register value */
293 u8 in_min[NUMBER_OF_VIN]; /* Register value */
294
295 /* fans */
296 u8 fan[NUMBER_OF_FANIN]; /* Register value */
297 u8 fan_min[NUMBER_OF_FANIN]; /* Register value */
298 u8 fan_div[NUMBER_OF_FANIN]; /* Register encoding, shifted right */
299
300 /* Temperature sensors */
301
302 s8 temp1[3]; /* current, over, thyst */
303 s16 temp_add[2][3]; /* fixed point value. Top 8 bits are the
304 integral part, bottom 8 bits are the
305 fractional part. We only use the top
306 9 bits as the resolution is only
307 to the 0.5 degree C...
308 two sensors with three values
309 (cur, over, hyst) */
310
311 /* PWMs */
312 u8 pwm[5]; /* pwm duty cycle */
313 u8 pwm_enable[3]; /* pwm enable status for fan 1-3
314 (fan 4-5 only support manual mode) */
315
316 u8 temp_target[3]; /* pwm 1-3 target temperature */
317 u8 temp_tolerance[3]; /* pwm 1-3 temperature tolerance */
318
319 /* Misc */
320 u32 alarms; /* realtime status register encoding,combined */
321 u8 beep_enable; /* Global beep enable */
322 u32 beep_mask; /* Mask off specific beeps */
323 u8 vid; /* Register encoding, combined */
324 u8 vrm; /* hwmon-vid */
325 };
326
327 static int w83791d_probe(struct i2c_client *client,
328 const struct i2c_device_id *id);
329 static int w83791d_detect(struct i2c_client *client, int kind,
330 struct i2c_board_info *info);
331 static int w83791d_remove(struct i2c_client *client);
332
333 static int w83791d_read(struct i2c_client *client, u8 register);
334 static int w83791d_write(struct i2c_client *client, u8 register, u8 value);
335 static struct w83791d_data *w83791d_update_device(struct device *dev);
336
337 #ifdef DEBUG
338 static void w83791d_print_debug(struct w83791d_data *data, struct device *dev);
339 #endif
340
341 static void w83791d_init_client(struct i2c_client *client);
342
343 static const struct i2c_device_id w83791d_id[] = {
344 { "w83791d", w83791d },
345 { }
346 };
347 MODULE_DEVICE_TABLE(i2c, w83791d_id);
348
349 static struct i2c_driver w83791d_driver = {
350 .class = I2C_CLASS_HWMON,
351 .driver = {
352 .name = "w83791d",
353 },
354 .probe = w83791d_probe,
355 .remove = w83791d_remove,
356 .id_table = w83791d_id,
357 .detect = w83791d_detect,
358 .address_data = &addr_data,
359 };
360
361 /* following are the sysfs callback functions */
362 #define show_in_reg(reg) \
363 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
364 char *buf) \
365 { \
366 struct sensor_device_attribute *sensor_attr = \
367 to_sensor_dev_attr(attr); \
368 struct w83791d_data *data = w83791d_update_device(dev); \
369 int nr = sensor_attr->index; \
370 return sprintf(buf,"%d\n", IN_FROM_REG(data->reg[nr])); \
371 }
372
373 show_in_reg(in);
374 show_in_reg(in_min);
375 show_in_reg(in_max);
376
377 #define store_in_reg(REG, reg) \
378 static ssize_t store_in_##reg(struct device *dev, \
379 struct device_attribute *attr, \
380 const char *buf, size_t count) \
381 { \
382 struct sensor_device_attribute *sensor_attr = \
383 to_sensor_dev_attr(attr); \
384 struct i2c_client *client = to_i2c_client(dev); \
385 struct w83791d_data *data = i2c_get_clientdata(client); \
386 unsigned long val = simple_strtoul(buf, NULL, 10); \
387 int nr = sensor_attr->index; \
388 \
389 mutex_lock(&data->update_lock); \
390 data->in_##reg[nr] = IN_TO_REG(val); \
391 w83791d_write(client, W83791D_REG_IN_##REG[nr], data->in_##reg[nr]); \
392 mutex_unlock(&data->update_lock); \
393 \
394 return count; \
395 }
396 store_in_reg(MIN, min);
397 store_in_reg(MAX, max);
398
399 static struct sensor_device_attribute sda_in_input[] = {
400 SENSOR_ATTR(in0_input, S_IRUGO, show_in, NULL, 0),
401 SENSOR_ATTR(in1_input, S_IRUGO, show_in, NULL, 1),
402 SENSOR_ATTR(in2_input, S_IRUGO, show_in, NULL, 2),
403 SENSOR_ATTR(in3_input, S_IRUGO, show_in, NULL, 3),
404 SENSOR_ATTR(in4_input, S_IRUGO, show_in, NULL, 4),
405 SENSOR_ATTR(in5_input, S_IRUGO, show_in, NULL, 5),
406 SENSOR_ATTR(in6_input, S_IRUGO, show_in, NULL, 6),
407 SENSOR_ATTR(in7_input, S_IRUGO, show_in, NULL, 7),
408 SENSOR_ATTR(in8_input, S_IRUGO, show_in, NULL, 8),
409 SENSOR_ATTR(in9_input, S_IRUGO, show_in, NULL, 9),
410 };
411
412 static struct sensor_device_attribute sda_in_min[] = {
413 SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 0),
414 SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 1),
415 SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 2),
416 SENSOR_ATTR(in3_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 3),
417 SENSOR_ATTR(in4_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 4),
418 SENSOR_ATTR(in5_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 5),
419 SENSOR_ATTR(in6_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 6),
420 SENSOR_ATTR(in7_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 7),
421 SENSOR_ATTR(in8_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 8),
422 SENSOR_ATTR(in9_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 9),
423 };
424
425 static struct sensor_device_attribute sda_in_max[] = {
426 SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 0),
427 SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 1),
428 SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 2),
429 SENSOR_ATTR(in3_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 3),
430 SENSOR_ATTR(in4_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 4),
431 SENSOR_ATTR(in5_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 5),
432 SENSOR_ATTR(in6_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 6),
433 SENSOR_ATTR(in7_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 7),
434 SENSOR_ATTR(in8_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 8),
435 SENSOR_ATTR(in9_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 9),
436 };
437
438
439 static ssize_t show_beep(struct device *dev, struct device_attribute *attr,
440 char *buf)
441 {
442 struct sensor_device_attribute *sensor_attr =
443 to_sensor_dev_attr(attr);
444 struct w83791d_data *data = w83791d_update_device(dev);
445 int bitnr = sensor_attr->index;
446
447 return sprintf(buf, "%d\n", (data->beep_mask >> bitnr) & 1);
448 }
449
450 static ssize_t store_beep(struct device *dev, struct device_attribute *attr,
451 const char *buf, size_t count)
452 {
453 struct sensor_device_attribute *sensor_attr =
454 to_sensor_dev_attr(attr);
455 struct i2c_client *client = to_i2c_client(dev);
456 struct w83791d_data *data = i2c_get_clientdata(client);
457 int bitnr = sensor_attr->index;
458 int bytenr = bitnr / 8;
459 long val = simple_strtol(buf, NULL, 10) ? 1 : 0;
460
461 mutex_lock(&data->update_lock);
462
463 data->beep_mask &= ~(0xff << (bytenr * 8));
464 data->beep_mask |= w83791d_read(client, W83791D_REG_BEEP_CTRL[bytenr])
465 << (bytenr * 8);
466
467 data->beep_mask &= ~(1 << bitnr);
468 data->beep_mask |= val << bitnr;
469
470 w83791d_write(client, W83791D_REG_BEEP_CTRL[bytenr],
471 (data->beep_mask >> (bytenr * 8)) & 0xff);
472
473 mutex_unlock(&data->update_lock);
474
475 return count;
476 }
477
478 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
479 char *buf)
480 {
481 struct sensor_device_attribute *sensor_attr =
482 to_sensor_dev_attr(attr);
483 struct w83791d_data *data = w83791d_update_device(dev);
484 int bitnr = sensor_attr->index;
485
486 return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1);
487 }
488
489 /* Note: The bitmask for the beep enable/disable is different than
490 the bitmask for the alarm. */
491 static struct sensor_device_attribute sda_in_beep[] = {
492 SENSOR_ATTR(in0_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 0),
493 SENSOR_ATTR(in1_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 13),
494 SENSOR_ATTR(in2_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 2),
495 SENSOR_ATTR(in3_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 3),
496 SENSOR_ATTR(in4_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 8),
497 SENSOR_ATTR(in5_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 9),
498 SENSOR_ATTR(in6_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 10),
499 SENSOR_ATTR(in7_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 16),
500 SENSOR_ATTR(in8_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 17),
501 SENSOR_ATTR(in9_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 14),
502 };
503
504 static struct sensor_device_attribute sda_in_alarm[] = {
505 SENSOR_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0),
506 SENSOR_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1),
507 SENSOR_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2),
508 SENSOR_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3),
509 SENSOR_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8),
510 SENSOR_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9),
511 SENSOR_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 10),
512 SENSOR_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 19),
513 SENSOR_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 20),
514 SENSOR_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL, 14),
515 };
516
517 #define show_fan_reg(reg) \
518 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
519 char *buf) \
520 { \
521 struct sensor_device_attribute *sensor_attr = \
522 to_sensor_dev_attr(attr); \
523 struct w83791d_data *data = w83791d_update_device(dev); \
524 int nr = sensor_attr->index; \
525 return sprintf(buf,"%d\n", \
526 FAN_FROM_REG(data->reg[nr], DIV_FROM_REG(data->fan_div[nr]))); \
527 }
528
529 show_fan_reg(fan);
530 show_fan_reg(fan_min);
531
532 static ssize_t store_fan_min(struct device *dev, struct device_attribute *attr,
533 const char *buf, size_t count)
534 {
535 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
536 struct i2c_client *client = to_i2c_client(dev);
537 struct w83791d_data *data = i2c_get_clientdata(client);
538 unsigned long val = simple_strtoul(buf, NULL, 10);
539 int nr = sensor_attr->index;
540
541 mutex_lock(&data->update_lock);
542 data->fan_min[nr] = fan_to_reg(val, DIV_FROM_REG(data->fan_div[nr]));
543 w83791d_write(client, W83791D_REG_FAN_MIN[nr], data->fan_min[nr]);
544 mutex_unlock(&data->update_lock);
545
546 return count;
547 }
548
549 static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr,
550 char *buf)
551 {
552 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
553 int nr = sensor_attr->index;
554 struct w83791d_data *data = w83791d_update_device(dev);
555 return sprintf(buf, "%u\n", DIV_FROM_REG(data->fan_div[nr]));
556 }
557
558 /* Note: we save and restore the fan minimum here, because its value is
559 determined in part by the fan divisor. This follows the principle of
560 least suprise; the user doesn't expect the fan minimum to change just
561 because the divisor changed. */
562 static ssize_t store_fan_div(struct device *dev, struct device_attribute *attr,
563 const char *buf, size_t count)
564 {
565 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
566 struct i2c_client *client = to_i2c_client(dev);
567 struct w83791d_data *data = i2c_get_clientdata(client);
568 int nr = sensor_attr->index;
569 unsigned long min;
570 u8 tmp_fan_div;
571 u8 fan_div_reg;
572 u8 vbat_reg;
573 int indx = 0;
574 u8 keep_mask = 0;
575 u8 new_shift = 0;
576
577 /* Save fan_min */
578 min = FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr]));
579
580 mutex_lock(&data->update_lock);
581 data->fan_div[nr] = div_to_reg(nr, simple_strtoul(buf, NULL, 10));
582
583 switch (nr) {
584 case 0:
585 indx = 0;
586 keep_mask = 0xcf;
587 new_shift = 4;
588 break;
589 case 1:
590 indx = 0;
591 keep_mask = 0x3f;
592 new_shift = 6;
593 break;
594 case 2:
595 indx = 1;
596 keep_mask = 0x3f;
597 new_shift = 6;
598 break;
599 case 3:
600 indx = 2;
601 keep_mask = 0xf8;
602 new_shift = 0;
603 break;
604 case 4:
605 indx = 2;
606 keep_mask = 0x8f;
607 new_shift = 4;
608 break;
609 #ifdef DEBUG
610 default:
611 dev_warn(dev, "store_fan_div: Unexpected nr seen: %d\n", nr);
612 count = -EINVAL;
613 goto err_exit;
614 #endif
615 }
616
617 fan_div_reg = w83791d_read(client, W83791D_REG_FAN_DIV[indx])
618 & keep_mask;
619 tmp_fan_div = (data->fan_div[nr] << new_shift) & ~keep_mask;
620
621 w83791d_write(client, W83791D_REG_FAN_DIV[indx],
622 fan_div_reg | tmp_fan_div);
623
624 /* Bit 2 of fans 0-2 is stored in the vbat register (bits 5-7) */
625 if (nr < 3) {
626 keep_mask = ~(1 << (nr + 5));
627 vbat_reg = w83791d_read(client, W83791D_REG_VBAT)
628 & keep_mask;
629 tmp_fan_div = (data->fan_div[nr] << (3 + nr)) & ~keep_mask;
630 w83791d_write(client, W83791D_REG_VBAT,
631 vbat_reg | tmp_fan_div);
632 }
633
634 /* Restore fan_min */
635 data->fan_min[nr] = fan_to_reg(min, DIV_FROM_REG(data->fan_div[nr]));
636 w83791d_write(client, W83791D_REG_FAN_MIN[nr], data->fan_min[nr]);
637
638 #ifdef DEBUG
639 err_exit:
640 #endif
641 mutex_unlock(&data->update_lock);
642
643 return count;
644 }
645
646 static struct sensor_device_attribute sda_fan_input[] = {
647 SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0),
648 SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1),
649 SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2),
650 SENSOR_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3),
651 SENSOR_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4),
652 };
653
654 static struct sensor_device_attribute sda_fan_min[] = {
655 SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO,
656 show_fan_min, store_fan_min, 0),
657 SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO,
658 show_fan_min, store_fan_min, 1),
659 SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO,
660 show_fan_min, store_fan_min, 2),
661 SENSOR_ATTR(fan4_min, S_IWUSR | S_IRUGO,
662 show_fan_min, store_fan_min, 3),
663 SENSOR_ATTR(fan5_min, S_IWUSR | S_IRUGO,
664 show_fan_min, store_fan_min, 4),
665 };
666
667 static struct sensor_device_attribute sda_fan_div[] = {
668 SENSOR_ATTR(fan1_div, S_IWUSR | S_IRUGO,
669 show_fan_div, store_fan_div, 0),
670 SENSOR_ATTR(fan2_div, S_IWUSR | S_IRUGO,
671 show_fan_div, store_fan_div, 1),
672 SENSOR_ATTR(fan3_div, S_IWUSR | S_IRUGO,
673 show_fan_div, store_fan_div, 2),
674 SENSOR_ATTR(fan4_div, S_IWUSR | S_IRUGO,
675 show_fan_div, store_fan_div, 3),
676 SENSOR_ATTR(fan5_div, S_IWUSR | S_IRUGO,
677 show_fan_div, store_fan_div, 4),
678 };
679
680 static struct sensor_device_attribute sda_fan_beep[] = {
681 SENSOR_ATTR(fan1_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 6),
682 SENSOR_ATTR(fan2_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 7),
683 SENSOR_ATTR(fan3_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 11),
684 SENSOR_ATTR(fan4_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 21),
685 SENSOR_ATTR(fan5_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 22),
686 };
687
688 static struct sensor_device_attribute sda_fan_alarm[] = {
689 SENSOR_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6),
690 SENSOR_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7),
691 SENSOR_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11),
692 SENSOR_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 21),
693 SENSOR_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 22),
694 };
695
696 /* read/write PWMs */
697 static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
698 char *buf)
699 {
700 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
701 int nr = sensor_attr->index;
702 struct w83791d_data *data = w83791d_update_device(dev);
703 return sprintf(buf, "%u\n", data->pwm[nr]);
704 }
705
706 static ssize_t store_pwm(struct device *dev, struct device_attribute *attr,
707 const char *buf, size_t count)
708 {
709 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
710 struct i2c_client *client = to_i2c_client(dev);
711 struct w83791d_data *data = i2c_get_clientdata(client);
712 int nr = sensor_attr->index;
713 unsigned long val;
714
715 if (strict_strtoul(buf, 10, &val))
716 return -EINVAL;
717
718 mutex_lock(&data->update_lock);
719 data->pwm[nr] = SENSORS_LIMIT(val, 0, 255);
720 w83791d_write(client, W83791D_REG_PWM[nr], data->pwm[nr]);
721 mutex_unlock(&data->update_lock);
722 return count;
723 }
724
725 static struct sensor_device_attribute sda_pwm[] = {
726 SENSOR_ATTR(pwm1, S_IWUSR | S_IRUGO,
727 show_pwm, store_pwm, 0),
728 SENSOR_ATTR(pwm2, S_IWUSR | S_IRUGO,
729 show_pwm, store_pwm, 1),
730 SENSOR_ATTR(pwm3, S_IWUSR | S_IRUGO,
731 show_pwm, store_pwm, 2),
732 SENSOR_ATTR(pwm4, S_IWUSR | S_IRUGO,
733 show_pwm, store_pwm, 3),
734 SENSOR_ATTR(pwm5, S_IWUSR | S_IRUGO,
735 show_pwm, store_pwm, 4),
736 };
737
738 static ssize_t show_pwmenable(struct device *dev, struct device_attribute *attr,
739 char *buf)
740 {
741 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
742 int nr = sensor_attr->index;
743 struct w83791d_data *data = w83791d_update_device(dev);
744 return sprintf(buf, "%u\n", data->pwm_enable[nr] + 1);
745 }
746
747 static ssize_t store_pwmenable(struct device *dev,
748 struct device_attribute *attr, const char *buf, size_t count)
749 {
750 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
751 struct i2c_client *client = to_i2c_client(dev);
752 struct w83791d_data *data = i2c_get_clientdata(client);
753 int nr = sensor_attr->index;
754 unsigned long val;
755 u8 reg_cfg_tmp;
756 u8 reg_idx = 0;
757 u8 val_shift = 0;
758 u8 keep_mask = 0;
759
760 int ret = strict_strtoul(buf, 10, &val);
761
762 if (ret || val < 1 || val > 3)
763 return -EINVAL;
764
765 mutex_lock(&data->update_lock);
766 data->pwm_enable[nr] = val - 1;
767 switch (nr) {
768 case 0:
769 reg_idx = 0;
770 val_shift = 2;
771 keep_mask = 0xf3;
772 break;
773 case 1:
774 reg_idx = 0;
775 val_shift = 4;
776 keep_mask = 0xcf;
777 break;
778 case 2:
779 reg_idx = 1;
780 val_shift = 2;
781 keep_mask = 0xf3;
782 break;
783 }
784
785 reg_cfg_tmp = w83791d_read(client, W83791D_REG_FAN_CFG[reg_idx]);
786 reg_cfg_tmp = (reg_cfg_tmp & keep_mask) |
787 data->pwm_enable[nr] << val_shift;
788
789 w83791d_write(client, W83791D_REG_FAN_CFG[reg_idx], reg_cfg_tmp);
790 mutex_unlock(&data->update_lock);
791
792 return count;
793 }
794 static struct sensor_device_attribute sda_pwmenable[] = {
795 SENSOR_ATTR(pwm1_enable, S_IWUSR | S_IRUGO,
796 show_pwmenable, store_pwmenable, 0),
797 SENSOR_ATTR(pwm2_enable, S_IWUSR | S_IRUGO,
798 show_pwmenable, store_pwmenable, 1),
799 SENSOR_ATTR(pwm3_enable, S_IWUSR | S_IRUGO,
800 show_pwmenable, store_pwmenable, 2),
801 };
802
803 /* For Smart Fan I / Thermal Cruise */
804 static ssize_t show_temp_target(struct device *dev,
805 struct device_attribute *attr, char *buf)
806 {
807 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
808 struct w83791d_data *data = w83791d_update_device(dev);
809 int nr = sensor_attr->index;
810 return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp_target[nr]));
811 }
812
813 static ssize_t store_temp_target(struct device *dev,
814 struct device_attribute *attr, const char *buf, size_t count)
815 {
816 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
817 struct i2c_client *client = to_i2c_client(dev);
818 struct w83791d_data *data = i2c_get_clientdata(client);
819 int nr = sensor_attr->index;
820 unsigned long val;
821 u8 target_mask;
822
823 if (strict_strtoul(buf, 10, &val))
824 return -EINVAL;
825
826 mutex_lock(&data->update_lock);
827 data->temp_target[nr] = TARGET_TEMP_TO_REG(val);
828 target_mask = w83791d_read(client,
829 W83791D_REG_TEMP_TARGET[nr]) & 0x80;
830 w83791d_write(client, W83791D_REG_TEMP_TARGET[nr],
831 data->temp_target[nr] | target_mask);
832 mutex_unlock(&data->update_lock);
833 return count;
834 }
835
836 static struct sensor_device_attribute sda_temp_target[] = {
837 SENSOR_ATTR(temp1_target, S_IWUSR | S_IRUGO,
838 show_temp_target, store_temp_target, 0),
839 SENSOR_ATTR(temp2_target, S_IWUSR | S_IRUGO,
840 show_temp_target, store_temp_target, 1),
841 SENSOR_ATTR(temp3_target, S_IWUSR | S_IRUGO,
842 show_temp_target, store_temp_target, 2),
843 };
844
845 static ssize_t show_temp_tolerance(struct device *dev,
846 struct device_attribute *attr, char *buf)
847 {
848 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
849 struct w83791d_data *data = w83791d_update_device(dev);
850 int nr = sensor_attr->index;
851 return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp_tolerance[nr]));
852 }
853
854 static ssize_t store_temp_tolerance(struct device *dev,
855 struct device_attribute *attr, const char *buf, size_t count)
856 {
857 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
858 struct i2c_client *client = to_i2c_client(dev);
859 struct w83791d_data *data = i2c_get_clientdata(client);
860 int nr = sensor_attr->index;
861 unsigned long val;
862 u8 target_mask;
863 u8 reg_idx = 0;
864 u8 val_shift = 0;
865 u8 keep_mask = 0;
866
867 if (strict_strtoul(buf, 10, &val))
868 return -EINVAL;
869
870 switch (nr) {
871 case 0:
872 reg_idx = 0;
873 val_shift = 0;
874 keep_mask = 0xf0;
875 break;
876 case 1:
877 reg_idx = 0;
878 val_shift = 4;
879 keep_mask = 0x0f;
880 break;
881 case 2:
882 reg_idx = 1;
883 val_shift = 0;
884 keep_mask = 0xf0;
885 break;
886 }
887
888 mutex_lock(&data->update_lock);
889 data->temp_tolerance[nr] = TOL_TEMP_TO_REG(val);
890 target_mask = w83791d_read(client,
891 W83791D_REG_TEMP_TOL[reg_idx]) & keep_mask;
892 w83791d_write(client, W83791D_REG_TEMP_TOL[reg_idx],
893 (data->temp_tolerance[nr] << val_shift) | target_mask);
894 mutex_unlock(&data->update_lock);
895 return count;
896 }
897
898 static struct sensor_device_attribute sda_temp_tolerance[] = {
899 SENSOR_ATTR(temp1_tolerance, S_IWUSR | S_IRUGO,
900 show_temp_tolerance, store_temp_tolerance, 0),
901 SENSOR_ATTR(temp2_tolerance, S_IWUSR | S_IRUGO,
902 show_temp_tolerance, store_temp_tolerance, 1),
903 SENSOR_ATTR(temp3_tolerance, S_IWUSR | S_IRUGO,
904 show_temp_tolerance, store_temp_tolerance, 2),
905 };
906
907 /* read/write the temperature1, includes measured value and limits */
908 static ssize_t show_temp1(struct device *dev, struct device_attribute *devattr,
909 char *buf)
910 {
911 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
912 struct w83791d_data *data = w83791d_update_device(dev);
913 return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp1[attr->index]));
914 }
915
916 static ssize_t store_temp1(struct device *dev, struct device_attribute *devattr,
917 const char *buf, size_t count)
918 {
919 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
920 struct i2c_client *client = to_i2c_client(dev);
921 struct w83791d_data *data = i2c_get_clientdata(client);
922 long val = simple_strtol(buf, NULL, 10);
923 int nr = attr->index;
924
925 mutex_lock(&data->update_lock);
926 data->temp1[nr] = TEMP1_TO_REG(val);
927 w83791d_write(client, W83791D_REG_TEMP1[nr], data->temp1[nr]);
928 mutex_unlock(&data->update_lock);
929 return count;
930 }
931
932 /* read/write temperature2-3, includes measured value and limits */
933 static ssize_t show_temp23(struct device *dev, struct device_attribute *devattr,
934 char *buf)
935 {
936 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
937 struct w83791d_data *data = w83791d_update_device(dev);
938 int nr = attr->nr;
939 int index = attr->index;
940 return sprintf(buf, "%d\n", TEMP23_FROM_REG(data->temp_add[nr][index]));
941 }
942
943 static ssize_t store_temp23(struct device *dev,
944 struct device_attribute *devattr,
945 const char *buf, size_t count)
946 {
947 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
948 struct i2c_client *client = to_i2c_client(dev);
949 struct w83791d_data *data = i2c_get_clientdata(client);
950 long val = simple_strtol(buf, NULL, 10);
951 int nr = attr->nr;
952 int index = attr->index;
953
954 mutex_lock(&data->update_lock);
955 data->temp_add[nr][index] = TEMP23_TO_REG(val);
956 w83791d_write(client, W83791D_REG_TEMP_ADD[nr][index * 2],
957 data->temp_add[nr][index] >> 8);
958 w83791d_write(client, W83791D_REG_TEMP_ADD[nr][index * 2 + 1],
959 data->temp_add[nr][index] & 0x80);
960 mutex_unlock(&data->update_lock);
961
962 return count;
963 }
964
965 static struct sensor_device_attribute_2 sda_temp_input[] = {
966 SENSOR_ATTR_2(temp1_input, S_IRUGO, show_temp1, NULL, 0, 0),
967 SENSOR_ATTR_2(temp2_input, S_IRUGO, show_temp23, NULL, 0, 0),
968 SENSOR_ATTR_2(temp3_input, S_IRUGO, show_temp23, NULL, 1, 0),
969 };
970
971 static struct sensor_device_attribute_2 sda_temp_max[] = {
972 SENSOR_ATTR_2(temp1_max, S_IRUGO | S_IWUSR,
973 show_temp1, store_temp1, 0, 1),
974 SENSOR_ATTR_2(temp2_max, S_IRUGO | S_IWUSR,
975 show_temp23, store_temp23, 0, 1),
976 SENSOR_ATTR_2(temp3_max, S_IRUGO | S_IWUSR,
977 show_temp23, store_temp23, 1, 1),
978 };
979
980 static struct sensor_device_attribute_2 sda_temp_max_hyst[] = {
981 SENSOR_ATTR_2(temp1_max_hyst, S_IRUGO | S_IWUSR,
982 show_temp1, store_temp1, 0, 2),
983 SENSOR_ATTR_2(temp2_max_hyst, S_IRUGO | S_IWUSR,
984 show_temp23, store_temp23, 0, 2),
985 SENSOR_ATTR_2(temp3_max_hyst, S_IRUGO | S_IWUSR,
986 show_temp23, store_temp23, 1, 2),
987 };
988
989 /* Note: The bitmask for the beep enable/disable is different than
990 the bitmask for the alarm. */
991 static struct sensor_device_attribute sda_temp_beep[] = {
992 SENSOR_ATTR(temp1_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 4),
993 SENSOR_ATTR(temp2_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 5),
994 SENSOR_ATTR(temp3_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 1),
995 };
996
997 static struct sensor_device_attribute sda_temp_alarm[] = {
998 SENSOR_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4),
999 SENSOR_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5),
1000 SENSOR_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13),
1001 };
1002
1003 /* get reatime status of all sensors items: voltage, temp, fan */
1004 static ssize_t show_alarms_reg(struct device *dev,
1005 struct device_attribute *attr, char *buf)
1006 {
1007 struct w83791d_data *data = w83791d_update_device(dev);
1008 return sprintf(buf, "%u\n", data->alarms);
1009 }
1010
1011 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
1012
1013 /* Beep control */
1014
1015 #define GLOBAL_BEEP_ENABLE_SHIFT 15
1016 #define GLOBAL_BEEP_ENABLE_MASK (1 << GLOBAL_BEEP_ENABLE_SHIFT)
1017
1018 static ssize_t show_beep_enable(struct device *dev,
1019 struct device_attribute *attr, char *buf)
1020 {
1021 struct w83791d_data *data = w83791d_update_device(dev);
1022 return sprintf(buf, "%d\n", data->beep_enable);
1023 }
1024
1025 static ssize_t show_beep_mask(struct device *dev,
1026 struct device_attribute *attr, char *buf)
1027 {
1028 struct w83791d_data *data = w83791d_update_device(dev);
1029 return sprintf(buf, "%d\n", BEEP_MASK_FROM_REG(data->beep_mask));
1030 }
1031
1032
1033 static ssize_t store_beep_mask(struct device *dev,
1034 struct device_attribute *attr,
1035 const char *buf, size_t count)
1036 {
1037 struct i2c_client *client = to_i2c_client(dev);
1038 struct w83791d_data *data = i2c_get_clientdata(client);
1039 long val = simple_strtol(buf, NULL, 10);
1040 int i;
1041
1042 mutex_lock(&data->update_lock);
1043
1044 /* The beep_enable state overrides any enabling request from
1045 the masks */
1046 data->beep_mask = BEEP_MASK_TO_REG(val) & ~GLOBAL_BEEP_ENABLE_MASK;
1047 data->beep_mask |= (data->beep_enable << GLOBAL_BEEP_ENABLE_SHIFT);
1048
1049 val = data->beep_mask;
1050
1051 for (i = 0; i < 3; i++) {
1052 w83791d_write(client, W83791D_REG_BEEP_CTRL[i], (val & 0xff));
1053 val >>= 8;
1054 }
1055
1056 mutex_unlock(&data->update_lock);
1057
1058 return count;
1059 }
1060
1061 static ssize_t store_beep_enable(struct device *dev,
1062 struct device_attribute *attr,
1063 const char *buf, size_t count)
1064 {
1065 struct i2c_client *client = to_i2c_client(dev);
1066 struct w83791d_data *data = i2c_get_clientdata(client);
1067 long val = simple_strtol(buf, NULL, 10);
1068
1069 mutex_lock(&data->update_lock);
1070
1071 data->beep_enable = val ? 1 : 0;
1072
1073 /* Keep the full mask value in sync with the current enable */
1074 data->beep_mask &= ~GLOBAL_BEEP_ENABLE_MASK;
1075 data->beep_mask |= (data->beep_enable << GLOBAL_BEEP_ENABLE_SHIFT);
1076
1077 /* The global control is in the second beep control register
1078 so only need to update that register */
1079 val = (data->beep_mask >> 8) & 0xff;
1080
1081 w83791d_write(client, W83791D_REG_BEEP_CTRL[1], val);
1082
1083 mutex_unlock(&data->update_lock);
1084
1085 return count;
1086 }
1087
1088 static struct sensor_device_attribute sda_beep_ctrl[] = {
1089 SENSOR_ATTR(beep_enable, S_IRUGO | S_IWUSR,
1090 show_beep_enable, store_beep_enable, 0),
1091 SENSOR_ATTR(beep_mask, S_IRUGO | S_IWUSR,
1092 show_beep_mask, store_beep_mask, 1)
1093 };
1094
1095 /* cpu voltage regulation information */
1096 static ssize_t show_vid_reg(struct device *dev,
1097 struct device_attribute *attr, char *buf)
1098 {
1099 struct w83791d_data *data = w83791d_update_device(dev);
1100 return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
1101 }
1102
1103 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
1104
1105 static ssize_t show_vrm_reg(struct device *dev,
1106 struct device_attribute *attr, char *buf)
1107 {
1108 struct w83791d_data *data = dev_get_drvdata(dev);
1109 return sprintf(buf, "%d\n", data->vrm);
1110 }
1111
1112 static ssize_t store_vrm_reg(struct device *dev,
1113 struct device_attribute *attr,
1114 const char *buf, size_t count)
1115 {
1116 struct w83791d_data *data = dev_get_drvdata(dev);
1117
1118 /* No lock needed as vrm is internal to the driver
1119 (not read from a chip register) and so is not
1120 updated in w83791d_update_device() */
1121 data->vrm = simple_strtoul(buf, NULL, 10);
1122
1123 return count;
1124 }
1125
1126 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
1127
1128 #define IN_UNIT_ATTRS(X) \
1129 &sda_in_input[X].dev_attr.attr, \
1130 &sda_in_min[X].dev_attr.attr, \
1131 &sda_in_max[X].dev_attr.attr, \
1132 &sda_in_beep[X].dev_attr.attr, \
1133 &sda_in_alarm[X].dev_attr.attr
1134
1135 #define FAN_UNIT_ATTRS(X) \
1136 &sda_fan_input[X].dev_attr.attr, \
1137 &sda_fan_min[X].dev_attr.attr, \
1138 &sda_fan_div[X].dev_attr.attr, \
1139 &sda_fan_beep[X].dev_attr.attr, \
1140 &sda_fan_alarm[X].dev_attr.attr
1141
1142 #define TEMP_UNIT_ATTRS(X) \
1143 &sda_temp_input[X].dev_attr.attr, \
1144 &sda_temp_max[X].dev_attr.attr, \
1145 &sda_temp_max_hyst[X].dev_attr.attr, \
1146 &sda_temp_beep[X].dev_attr.attr, \
1147 &sda_temp_alarm[X].dev_attr.attr
1148
1149 static struct attribute *w83791d_attributes[] = {
1150 IN_UNIT_ATTRS(0),
1151 IN_UNIT_ATTRS(1),
1152 IN_UNIT_ATTRS(2),
1153 IN_UNIT_ATTRS(3),
1154 IN_UNIT_ATTRS(4),
1155 IN_UNIT_ATTRS(5),
1156 IN_UNIT_ATTRS(6),
1157 IN_UNIT_ATTRS(7),
1158 IN_UNIT_ATTRS(8),
1159 IN_UNIT_ATTRS(9),
1160 FAN_UNIT_ATTRS(0),
1161 FAN_UNIT_ATTRS(1),
1162 FAN_UNIT_ATTRS(2),
1163 TEMP_UNIT_ATTRS(0),
1164 TEMP_UNIT_ATTRS(1),
1165 TEMP_UNIT_ATTRS(2),
1166 &dev_attr_alarms.attr,
1167 &sda_beep_ctrl[0].dev_attr.attr,
1168 &sda_beep_ctrl[1].dev_attr.attr,
1169 &dev_attr_cpu0_vid.attr,
1170 &dev_attr_vrm.attr,
1171 &sda_pwm[0].dev_attr.attr,
1172 &sda_pwm[1].dev_attr.attr,
1173 &sda_pwm[2].dev_attr.attr,
1174 &sda_pwmenable[0].dev_attr.attr,
1175 &sda_pwmenable[1].dev_attr.attr,
1176 &sda_pwmenable[2].dev_attr.attr,
1177 &sda_temp_target[0].dev_attr.attr,
1178 &sda_temp_target[1].dev_attr.attr,
1179 &sda_temp_target[2].dev_attr.attr,
1180 &sda_temp_tolerance[0].dev_attr.attr,
1181 &sda_temp_tolerance[1].dev_attr.attr,
1182 &sda_temp_tolerance[2].dev_attr.attr,
1183 NULL
1184 };
1185
1186 static const struct attribute_group w83791d_group = {
1187 .attrs = w83791d_attributes,
1188 };
1189
1190 /* Separate group of attributes for fan/pwm 4-5. Their pins can also be
1191 in use for GPIO in which case their sysfs-interface should not be made
1192 available */
1193 static struct attribute *w83791d_attributes_fanpwm45[] = {
1194 FAN_UNIT_ATTRS(3),
1195 FAN_UNIT_ATTRS(4),
1196 &sda_pwm[3].dev_attr.attr,
1197 &sda_pwm[4].dev_attr.attr,
1198 NULL
1199 };
1200
1201 static const struct attribute_group w83791d_group_fanpwm45 = {
1202 .attrs = w83791d_attributes_fanpwm45,
1203 };
1204
1205 static int w83791d_detect_subclients(struct i2c_client *client)
1206 {
1207 struct i2c_adapter *adapter = client->adapter;
1208 struct w83791d_data *data = i2c_get_clientdata(client);
1209 int address = client->addr;
1210 int i, id, err;
1211 u8 val;
1212
1213 id = i2c_adapter_id(adapter);
1214 if (force_subclients[0] == id && force_subclients[1] == address) {
1215 for (i = 2; i <= 3; i++) {
1216 if (force_subclients[i] < 0x48 ||
1217 force_subclients[i] > 0x4f) {
1218 dev_err(&client->dev,
1219 "invalid subclient "
1220 "address %d; must be 0x48-0x4f\n",
1221 force_subclients[i]);
1222 err = -ENODEV;
1223 goto error_sc_0;
1224 }
1225 }
1226 w83791d_write(client, W83791D_REG_I2C_SUBADDR,
1227 (force_subclients[2] & 0x07) |
1228 ((force_subclients[3] & 0x07) << 4));
1229 }
1230
1231 val = w83791d_read(client, W83791D_REG_I2C_SUBADDR);
1232 if (!(val & 0x08)) {
1233 data->lm75[0] = i2c_new_dummy(adapter, 0x48 + (val & 0x7));
1234 }
1235 if (!(val & 0x80)) {
1236 if ((data->lm75[0] != NULL) &&
1237 ((val & 0x7) == ((val >> 4) & 0x7))) {
1238 dev_err(&client->dev,
1239 "duplicate addresses 0x%x, "
1240 "use force_subclient\n",
1241 data->lm75[0]->addr);
1242 err = -ENODEV;
1243 goto error_sc_1;
1244 }
1245 data->lm75[1] = i2c_new_dummy(adapter,
1246 0x48 + ((val >> 4) & 0x7));
1247 }
1248
1249 return 0;
1250
1251 /* Undo inits in case of errors */
1252
1253 error_sc_1:
1254 if (data->lm75[0] != NULL)
1255 i2c_unregister_device(data->lm75[0]);
1256 error_sc_0:
1257 return err;
1258 }
1259
1260
1261 /* Return 0 if detection is successful, -ENODEV otherwise */
1262 static int w83791d_detect(struct i2c_client *client, int kind,
1263 struct i2c_board_info *info)
1264 {
1265 struct i2c_adapter *adapter = client->adapter;
1266 int val1, val2;
1267 unsigned short address = client->addr;
1268
1269 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1270 return -ENODEV;
1271 }
1272
1273 /* The w83791d may be stuck in some other bank than bank 0. This may
1274 make reading other information impossible. Specify a force=...
1275 parameter, and the Winbond will be reset to the right bank. */
1276 if (kind < 0) {
1277 if (w83791d_read(client, W83791D_REG_CONFIG) & 0x80) {
1278 return -ENODEV;
1279 }
1280 val1 = w83791d_read(client, W83791D_REG_BANK);
1281 val2 = w83791d_read(client, W83791D_REG_CHIPMAN);
1282 /* Check for Winbond ID if in bank 0 */
1283 if (!(val1 & 0x07)) {
1284 /* yes it is Bank0 */
1285 if (((!(val1 & 0x80)) && (val2 != 0xa3)) ||
1286 ((val1 & 0x80) && (val2 != 0x5c))) {
1287 return -ENODEV;
1288 }
1289 }
1290 /* If Winbond chip, address of chip and W83791D_REG_I2C_ADDR
1291 should match */
1292 if (w83791d_read(client, W83791D_REG_I2C_ADDR) != address) {
1293 return -ENODEV;
1294 }
1295 }
1296
1297 /* We either have a force parameter or we have reason to
1298 believe it is a Winbond chip. Either way, we want bank 0 and
1299 Vendor ID high byte */
1300 val1 = w83791d_read(client, W83791D_REG_BANK) & 0x78;
1301 w83791d_write(client, W83791D_REG_BANK, val1 | 0x80);
1302
1303 /* Verify it is a Winbond w83791d */
1304 if (kind <= 0) {
1305 /* get vendor ID */
1306 val2 = w83791d_read(client, W83791D_REG_CHIPMAN);
1307 if (val2 != 0x5c) { /* the vendor is NOT Winbond */
1308 return -ENODEV;
1309 }
1310 val1 = w83791d_read(client, W83791D_REG_WCHIPID);
1311 if (val1 == 0x71) {
1312 kind = w83791d;
1313 } else {
1314 if (kind == 0)
1315 dev_warn(&adapter->dev,
1316 "w83791d: Ignoring 'force' parameter "
1317 "for unknown chip at adapter %d, "
1318 "address 0x%02x\n",
1319 i2c_adapter_id(adapter), address);
1320 return -ENODEV;
1321 }
1322 }
1323
1324 strlcpy(info->type, "w83791d", I2C_NAME_SIZE);
1325
1326 return 0;
1327 }
1328
1329 static int w83791d_probe(struct i2c_client *client,
1330 const struct i2c_device_id *id)
1331 {
1332 struct w83791d_data *data;
1333 struct device *dev = &client->dev;
1334 int i, err;
1335 u8 has_fanpwm45;
1336
1337 #ifdef DEBUG
1338 int val1;
1339 val1 = w83791d_read(client, W83791D_REG_DID_VID4);
1340 dev_dbg(dev, "Device ID version: %d.%d (0x%02x)\n",
1341 (val1 >> 5) & 0x07, (val1 >> 1) & 0x0f, val1);
1342 #endif
1343
1344 data = kzalloc(sizeof(struct w83791d_data), GFP_KERNEL);
1345 if (!data) {
1346 err = -ENOMEM;
1347 goto error0;
1348 }
1349
1350 i2c_set_clientdata(client, data);
1351 mutex_init(&data->update_lock);
1352
1353 err = w83791d_detect_subclients(client);
1354 if (err)
1355 goto error1;
1356
1357 /* Initialize the chip */
1358 w83791d_init_client(client);
1359
1360 /* If the fan_div is changed, make sure there is a rational
1361 fan_min in place */
1362 for (i = 0; i < NUMBER_OF_FANIN; i++) {
1363 data->fan_min[i] = w83791d_read(client, W83791D_REG_FAN_MIN[i]);
1364 }
1365
1366 /* Register sysfs hooks */
1367 if ((err = sysfs_create_group(&client->dev.kobj, &w83791d_group)))
1368 goto error3;
1369
1370 /* Check if pins of fan/pwm 4-5 are in use as GPIO */
1371 has_fanpwm45 = w83791d_read(client, W83791D_REG_GPIO) & 0x10;
1372 if (has_fanpwm45) {
1373 err = sysfs_create_group(&client->dev.kobj,
1374 &w83791d_group_fanpwm45);
1375 if (err)
1376 goto error4;
1377 }
1378
1379 /* Everything is ready, now register the working device */
1380 data->hwmon_dev = hwmon_device_register(dev);
1381 if (IS_ERR(data->hwmon_dev)) {
1382 err = PTR_ERR(data->hwmon_dev);
1383 goto error5;
1384 }
1385
1386 return 0;
1387
1388 error5:
1389 if (has_fanpwm45)
1390 sysfs_remove_group(&client->dev.kobj, &w83791d_group_fanpwm45);
1391 error4:
1392 sysfs_remove_group(&client->dev.kobj, &w83791d_group);
1393 error3:
1394 if (data->lm75[0] != NULL)
1395 i2c_unregister_device(data->lm75[0]);
1396 if (data->lm75[1] != NULL)
1397 i2c_unregister_device(data->lm75[1]);
1398 error1:
1399 kfree(data);
1400 error0:
1401 return err;
1402 }
1403
1404 static int w83791d_remove(struct i2c_client *client)
1405 {
1406 struct w83791d_data *data = i2c_get_clientdata(client);
1407
1408 hwmon_device_unregister(data->hwmon_dev);
1409 sysfs_remove_group(&client->dev.kobj, &w83791d_group);
1410
1411 if (data->lm75[0] != NULL)
1412 i2c_unregister_device(data->lm75[0]);
1413 if (data->lm75[1] != NULL)
1414 i2c_unregister_device(data->lm75[1]);
1415
1416 kfree(data);
1417 return 0;
1418 }
1419
1420 static void w83791d_init_client(struct i2c_client *client)
1421 {
1422 struct w83791d_data *data = i2c_get_clientdata(client);
1423 u8 tmp;
1424 u8 old_beep;
1425
1426 /* The difference between reset and init is that reset
1427 does a hard reset of the chip via index 0x40, bit 7,
1428 but init simply forces certain registers to have "sane"
1429 values. The hope is that the BIOS has done the right
1430 thing (which is why the default is reset=0, init=0),
1431 but if not, reset is the hard hammer and init
1432 is the soft mallet both of which are trying to whack
1433 things into place...
1434 NOTE: The data sheet makes a distinction between
1435 "power on defaults" and "reset by MR". As far as I can tell,
1436 the hard reset puts everything into a power-on state so I'm
1437 not sure what "reset by MR" means or how it can happen.
1438 */
1439 if (reset || init) {
1440 /* keep some BIOS settings when we... */
1441 old_beep = w83791d_read(client, W83791D_REG_BEEP_CONFIG);
1442
1443 if (reset) {
1444 /* ... reset the chip and ... */
1445 w83791d_write(client, W83791D_REG_CONFIG, 0x80);
1446 }
1447
1448 /* ... disable power-on abnormal beep */
1449 w83791d_write(client, W83791D_REG_BEEP_CONFIG, old_beep | 0x80);
1450
1451 /* disable the global beep (not done by hard reset) */
1452 tmp = w83791d_read(client, W83791D_REG_BEEP_CTRL[1]);
1453 w83791d_write(client, W83791D_REG_BEEP_CTRL[1], tmp & 0xef);
1454
1455 if (init) {
1456 /* Make sure monitoring is turned on for add-ons */
1457 tmp = w83791d_read(client, W83791D_REG_TEMP2_CONFIG);
1458 if (tmp & 1) {
1459 w83791d_write(client, W83791D_REG_TEMP2_CONFIG,
1460 tmp & 0xfe);
1461 }
1462
1463 tmp = w83791d_read(client, W83791D_REG_TEMP3_CONFIG);
1464 if (tmp & 1) {
1465 w83791d_write(client, W83791D_REG_TEMP3_CONFIG,
1466 tmp & 0xfe);
1467 }
1468
1469 /* Start monitoring */
1470 tmp = w83791d_read(client, W83791D_REG_CONFIG) & 0xf7;
1471 w83791d_write(client, W83791D_REG_CONFIG, tmp | 0x01);
1472 }
1473 }
1474
1475 data->vrm = vid_which_vrm();
1476 }
1477
1478 static struct w83791d_data *w83791d_update_device(struct device *dev)
1479 {
1480 struct i2c_client *client = to_i2c_client(dev);
1481 struct w83791d_data *data = i2c_get_clientdata(client);
1482 int i, j;
1483 u8 reg_array_tmp[3];
1484 u8 vbat_reg;
1485
1486 mutex_lock(&data->update_lock);
1487
1488 if (time_after(jiffies, data->last_updated + (HZ * 3))
1489 || !data->valid) {
1490 dev_dbg(dev, "Starting w83791d device update\n");
1491
1492 /* Update the voltages measured value and limits */
1493 for (i = 0; i < NUMBER_OF_VIN; i++) {
1494 data->in[i] = w83791d_read(client,
1495 W83791D_REG_IN[i]);
1496 data->in_max[i] = w83791d_read(client,
1497 W83791D_REG_IN_MAX[i]);
1498 data->in_min[i] = w83791d_read(client,
1499 W83791D_REG_IN_MIN[i]);
1500 }
1501
1502 /* Update the fan counts and limits */
1503 for (i = 0; i < NUMBER_OF_FANIN; i++) {
1504 /* Update the Fan measured value and limits */
1505 data->fan[i] = w83791d_read(client,
1506 W83791D_REG_FAN[i]);
1507 data->fan_min[i] = w83791d_read(client,
1508 W83791D_REG_FAN_MIN[i]);
1509 }
1510
1511 /* Update the fan divisor */
1512 for (i = 0; i < 3; i++) {
1513 reg_array_tmp[i] = w83791d_read(client,
1514 W83791D_REG_FAN_DIV[i]);
1515 }
1516 data->fan_div[0] = (reg_array_tmp[0] >> 4) & 0x03;
1517 data->fan_div[1] = (reg_array_tmp[0] >> 6) & 0x03;
1518 data->fan_div[2] = (reg_array_tmp[1] >> 6) & 0x03;
1519 data->fan_div[3] = reg_array_tmp[2] & 0x07;
1520 data->fan_div[4] = (reg_array_tmp[2] >> 4) & 0x07;
1521
1522 /* The fan divisor for fans 0-2 get bit 2 from
1523 bits 5-7 respectively of vbat register */
1524 vbat_reg = w83791d_read(client, W83791D_REG_VBAT);
1525 for (i = 0; i < 3; i++)
1526 data->fan_div[i] |= (vbat_reg >> (3 + i)) & 0x04;
1527
1528 /* Update PWM duty cycle */
1529 for (i = 0; i < NUMBER_OF_PWM; i++) {
1530 data->pwm[i] = w83791d_read(client,
1531 W83791D_REG_PWM[i]);
1532 }
1533
1534 /* Update PWM enable status */
1535 for (i = 0; i < 2; i++) {
1536 reg_array_tmp[i] = w83791d_read(client,
1537 W83791D_REG_FAN_CFG[i]);
1538 }
1539 data->pwm_enable[0] = (reg_array_tmp[0] >> 2) & 0x03;
1540 data->pwm_enable[1] = (reg_array_tmp[0] >> 4) & 0x03;
1541 data->pwm_enable[2] = (reg_array_tmp[1] >> 2) & 0x03;
1542
1543 /* Update PWM target temperature */
1544 for (i = 0; i < 3; i++) {
1545 data->temp_target[i] = w83791d_read(client,
1546 W83791D_REG_TEMP_TARGET[i]) & 0x7f;
1547 }
1548
1549 /* Update PWM temperature tolerance */
1550 for (i = 0; i < 2; i++) {
1551 reg_array_tmp[i] = w83791d_read(client,
1552 W83791D_REG_TEMP_TOL[i]);
1553 }
1554 data->temp_tolerance[0] = reg_array_tmp[0] & 0x0f;
1555 data->temp_tolerance[1] = (reg_array_tmp[0] >> 4) & 0x0f;
1556 data->temp_tolerance[2] = reg_array_tmp[1] & 0x0f;
1557
1558 /* Update the first temperature sensor */
1559 for (i = 0; i < 3; i++) {
1560 data->temp1[i] = w83791d_read(client,
1561 W83791D_REG_TEMP1[i]);
1562 }
1563
1564 /* Update the rest of the temperature sensors */
1565 for (i = 0; i < 2; i++) {
1566 for (j = 0; j < 3; j++) {
1567 data->temp_add[i][j] =
1568 (w83791d_read(client,
1569 W83791D_REG_TEMP_ADD[i][j * 2]) << 8) |
1570 w83791d_read(client,
1571 W83791D_REG_TEMP_ADD[i][j * 2 + 1]);
1572 }
1573 }
1574
1575 /* Update the realtime status */
1576 data->alarms =
1577 w83791d_read(client, W83791D_REG_ALARM1) +
1578 (w83791d_read(client, W83791D_REG_ALARM2) << 8) +
1579 (w83791d_read(client, W83791D_REG_ALARM3) << 16);
1580
1581 /* Update the beep configuration information */
1582 data->beep_mask =
1583 w83791d_read(client, W83791D_REG_BEEP_CTRL[0]) +
1584 (w83791d_read(client, W83791D_REG_BEEP_CTRL[1]) << 8) +
1585 (w83791d_read(client, W83791D_REG_BEEP_CTRL[2]) << 16);
1586
1587 /* Extract global beep enable flag */
1588 data->beep_enable =
1589 (data->beep_mask >> GLOBAL_BEEP_ENABLE_SHIFT) & 0x01;
1590
1591 /* Update the cpu voltage information */
1592 i = w83791d_read(client, W83791D_REG_VID_FANDIV);
1593 data->vid = i & 0x0f;
1594 data->vid |= (w83791d_read(client, W83791D_REG_DID_VID4) & 0x01)
1595 << 4;
1596
1597 data->last_updated = jiffies;
1598 data->valid = 1;
1599 }
1600
1601 mutex_unlock(&data->update_lock);
1602
1603 #ifdef DEBUG
1604 w83791d_print_debug(data, dev);
1605 #endif
1606
1607 return data;
1608 }
1609
1610 #ifdef DEBUG
1611 static void w83791d_print_debug(struct w83791d_data *data, struct device *dev)
1612 {
1613 int i = 0, j = 0;
1614
1615 dev_dbg(dev, "======Start of w83791d debug values======\n");
1616 dev_dbg(dev, "%d set of Voltages: ===>\n", NUMBER_OF_VIN);
1617 for (i = 0; i < NUMBER_OF_VIN; i++) {
1618 dev_dbg(dev, "vin[%d] is: 0x%02x\n", i, data->in[i]);
1619 dev_dbg(dev, "vin[%d] min is: 0x%02x\n", i, data->in_min[i]);
1620 dev_dbg(dev, "vin[%d] max is: 0x%02x\n", i, data->in_max[i]);
1621 }
1622 dev_dbg(dev, "%d set of Fan Counts/Divisors: ===>\n", NUMBER_OF_FANIN);
1623 for (i = 0; i < NUMBER_OF_FANIN; i++) {
1624 dev_dbg(dev, "fan[%d] is: 0x%02x\n", i, data->fan[i]);
1625 dev_dbg(dev, "fan[%d] min is: 0x%02x\n", i, data->fan_min[i]);
1626 dev_dbg(dev, "fan_div[%d] is: 0x%02x\n", i, data->fan_div[i]);
1627 }
1628
1629 /* temperature math is signed, but only print out the
1630 bits that matter */
1631 dev_dbg(dev, "%d set of Temperatures: ===>\n", NUMBER_OF_TEMPIN);
1632 for (i = 0; i < 3; i++) {
1633 dev_dbg(dev, "temp1[%d] is: 0x%02x\n", i, (u8) data->temp1[i]);
1634 }
1635 for (i = 0; i < 2; i++) {
1636 for (j = 0; j < 3; j++) {
1637 dev_dbg(dev, "temp_add[%d][%d] is: 0x%04x\n", i, j,
1638 (u16) data->temp_add[i][j]);
1639 }
1640 }
1641
1642 dev_dbg(dev, "Misc Information: ===>\n");
1643 dev_dbg(dev, "alarm is: 0x%08x\n", data->alarms);
1644 dev_dbg(dev, "beep_mask is: 0x%08x\n", data->beep_mask);
1645 dev_dbg(dev, "beep_enable is: %d\n", data->beep_enable);
1646 dev_dbg(dev, "vid is: 0x%02x\n", data->vid);
1647 dev_dbg(dev, "vrm is: 0x%02x\n", data->vrm);
1648 dev_dbg(dev, "=======End of w83791d debug values========\n");
1649 dev_dbg(dev, "\n");
1650 }
1651 #endif
1652
1653 static int __init sensors_w83791d_init(void)
1654 {
1655 return i2c_add_driver(&w83791d_driver);
1656 }
1657
1658 static void __exit sensors_w83791d_exit(void)
1659 {
1660 i2c_del_driver(&w83791d_driver);
1661 }
1662
1663 MODULE_AUTHOR("Charles Spirakis <bezaur@gmail.com>");
1664 MODULE_DESCRIPTION("W83791D driver");
1665 MODULE_LICENSE("GPL");
1666
1667 module_init(sensors_w83791d_init);
1668 module_exit(sensors_w83791d_exit);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree