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