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