?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[SUNLANCE]: Mark sparc_lance_probe_one as __devinit.
[linux-2.6/verdex.git] / drivers / hwmon / w83791d.c
blobeec43abd57fb1e59801d311c95357efac86b2265
1 /*
2 w83791d.c - Part of lm_sensors, Linux kernel modules for hardware
3 monitoring
4
5 Copyright (C) 2006 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 3 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, but its output is more along the lines of the
31 83781d (which means there are no changes to the user-mode sensors
32 program which treats the 83791d as an 83781d).
33 */
34
35 #include <linux/config.h>
36 #include <linux/module.h>
37 #include <linux/init.h>
38 #include <linux/slab.h>
39 #include <linux/i2c.h>
40 #include <linux/hwmon.h>
41 #include <linux/hwmon-vid.h>
42 #include <linux/hwmon-sysfs.h>
43 #include <linux/err.h>
44 #include <linux/mutex.h>
45
46 #define NUMBER_OF_VIN 10
47 #define NUMBER_OF_FANIN 5
48 #define NUMBER_OF_TEMPIN 3
49
50 /* Addresses to scan */
51 static unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END };
52
53 /* Insmod parameters */
54 I2C_CLIENT_INSMOD_1(w83791d);
55 I2C_CLIENT_MODULE_PARM(force_subclients, "List of subclient addresses: "
56 "{bus, clientaddr, subclientaddr1, subclientaddr2}");
57
58 static int reset;
59 module_param(reset, bool, 0);
60 MODULE_PARM_DESC(reset, "Set to one to force a hardware chip reset");
61
62 static int init;
63 module_param(init, bool, 0);
64 MODULE_PARM_DESC(init, "Set to one to force extra software initialization");
65
66 /* The W83791D registers */
67 static const u8 W83791D_REG_IN[NUMBER_OF_VIN] = {
68 0x20, /* VCOREA in DataSheet */
69 0x21, /* VINR0 in DataSheet */
70 0x22, /* +3.3VIN in DataSheet */
71 0x23, /* VDD5V in DataSheet */
72 0x24, /* +12VIN in DataSheet */
73 0x25, /* -12VIN in DataSheet */
74 0x26, /* -5VIN in DataSheet */
75 0xB0, /* 5VSB in DataSheet */
76 0xB1, /* VBAT in DataSheet */
77 0xB2 /* VINR1 in DataSheet */
78 };
79
80 static const u8 W83791D_REG_IN_MAX[NUMBER_OF_VIN] = {
81 0x2B, /* VCOREA High Limit in DataSheet */
82 0x2D, /* VINR0 High Limit in DataSheet */
83 0x2F, /* +3.3VIN High Limit in DataSheet */
84 0x31, /* VDD5V High Limit in DataSheet */
85 0x33, /* +12VIN High Limit in DataSheet */
86 0x35, /* -12VIN High Limit in DataSheet */
87 0x37, /* -5VIN High Limit in DataSheet */
88 0xB4, /* 5VSB High Limit in DataSheet */
89 0xB6, /* VBAT High Limit in DataSheet */
90 0xB8 /* VINR1 High Limit in DataSheet */
91 };
92 static const u8 W83791D_REG_IN_MIN[NUMBER_OF_VIN] = {
93 0x2C, /* VCOREA Low Limit in DataSheet */
94 0x2E, /* VINR0 Low Limit in DataSheet */
95 0x30, /* +3.3VIN Low Limit in DataSheet */
96 0x32, /* VDD5V Low Limit in DataSheet */
97 0x34, /* +12VIN Low Limit in DataSheet */
98 0x36, /* -12VIN Low Limit in DataSheet */
99 0x38, /* -5VIN Low Limit in DataSheet */
100 0xB5, /* 5VSB Low Limit in DataSheet */
101 0xB7, /* VBAT Low Limit in DataSheet */
102 0xB9 /* VINR1 Low Limit in DataSheet */
103 };
104 static const u8 W83791D_REG_FAN[NUMBER_OF_FANIN] = {
105 0x28, /* FAN 1 Count in DataSheet */
106 0x29, /* FAN 2 Count in DataSheet */
107 0x2A, /* FAN 3 Count in DataSheet */
108 0xBA, /* FAN 4 Count in DataSheet */
109 0xBB, /* FAN 5 Count in DataSheet */
110 };
111 static const u8 W83791D_REG_FAN_MIN[NUMBER_OF_FANIN] = {
112 0x3B, /* FAN 1 Count Low Limit in DataSheet */
113 0x3C, /* FAN 2 Count Low Limit in DataSheet */
114 0x3D, /* FAN 3 Count Low Limit in DataSheet */
115 0xBC, /* FAN 4 Count Low Limit in DataSheet */
116 0xBD, /* FAN 5 Count Low Limit in DataSheet */
117 };
118
119 static const u8 W83791D_REG_FAN_CFG[2] = {
120 0x84, /* FAN 1/2 configuration */
121 0x95, /* FAN 3 configuration */
122 };
123
124 static const u8 W83791D_REG_FAN_DIV[3] = {
125 0x47, /* contains FAN1 and FAN2 Divisor */
126 0x4b, /* contains FAN3 Divisor */
127 0x5C, /* contains FAN4 and FAN5 Divisor */
128 };
129
130 #define W83791D_REG_BANK 0x4E
131 #define W83791D_REG_TEMP2_CONFIG 0xC2
132 #define W83791D_REG_TEMP3_CONFIG 0xCA
133
134 static const u8 W83791D_REG_TEMP1[3] = {
135 0x27, /* TEMP 1 in DataSheet */
136 0x39, /* TEMP 1 Over in DataSheet */
137 0x3A, /* TEMP 1 Hyst in DataSheet */
138 };
139
140 static const u8 W83791D_REG_TEMP_ADD[2][6] = {
141 {0xC0, /* TEMP 2 in DataSheet */
142 0xC1, /* TEMP 2(0.5 deg) in DataSheet */
143 0xC5, /* TEMP 2 Over High part in DataSheet */
144 0xC6, /* TEMP 2 Over Low part in DataSheet */
145 0xC3, /* TEMP 2 Thyst High part in DataSheet */
146 0xC4}, /* TEMP 2 Thyst Low part in DataSheet */
147 {0xC8, /* TEMP 3 in DataSheet */
148 0xC9, /* TEMP 3(0.5 deg) in DataSheet */
149 0xCD, /* TEMP 3 Over High part in DataSheet */
150 0xCE, /* TEMP 3 Over Low part in DataSheet */
151 0xCB, /* TEMP 3 Thyst High part in DataSheet */
152 0xCC} /* TEMP 3 Thyst Low part in DataSheet */
153 };
154
155 #define W83791D_REG_BEEP_CONFIG 0x4D
156
157 static const u8 W83791D_REG_BEEP_CTRL[3] = {
158 0x56, /* BEEP Control Register 1 */
159 0x57, /* BEEP Control Register 2 */
160 0xA3, /* BEEP Control Register 3 */
161 };
162
163 #define W83791D_REG_CONFIG 0x40
164 #define W83791D_REG_VID_FANDIV 0x47
165 #define W83791D_REG_DID_VID4 0x49
166 #define W83791D_REG_WCHIPID 0x58
167 #define W83791D_REG_CHIPMAN 0x4F
168 #define W83791D_REG_PIN 0x4B
169 #define W83791D_REG_I2C_SUBADDR 0x4A
170
171 #define W83791D_REG_ALARM1 0xA9 /* realtime status register1 */
172 #define W83791D_REG_ALARM2 0xAA /* realtime status register2 */
173 #define W83791D_REG_ALARM3 0xAB /* realtime status register3 */
174
175 #define W83791D_REG_VBAT 0x5D
176 #define W83791D_REG_I2C_ADDR 0x48
177
178 /* The SMBus locks itself. The Winbond W83791D has a bank select register
179 (index 0x4e), but the driver only accesses registers in bank 0. Since
180 we don't switch banks, we don't need any special code to handle
181 locking access between bank switches */
182 static inline int w83791d_read(struct i2c_client *client, u8 reg)
183 {
184 return i2c_smbus_read_byte_data(client, reg);
185 }
186
187 static inline int w83791d_write(struct i2c_client *client, u8 reg, u8 value)
188 {
189 return i2c_smbus_write_byte_data(client, reg, value);
190 }
191
192 /* The analog voltage inputs have 16mV LSB. Since the sysfs output is
193 in mV as would be measured on the chip input pin, need to just
194 multiply/divide by 16 to translate from/to register values. */
195 #define IN_TO_REG(val) (SENSORS_LIMIT((((val) + 8) / 16), 0, 255))
196 #define IN_FROM_REG(val) ((val) * 16)
197
198 static u8 fan_to_reg(long rpm, int div)
199 {
200 if (rpm == 0)
201 return 255;
202 rpm = SENSORS_LIMIT(rpm, 1, 1000000);
203 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
204 }
205
206 #define FAN_FROM_REG(val,div) ((val) == 0 ? -1 : \
207 ((val) == 255 ? 0 : \
208 1350000 / ((val) * (div))))
209
210 /* for temp1 which is 8-bit resolution, LSB = 1 degree Celsius */
211 #define TEMP1_FROM_REG(val) ((val) * 1000)
212 #define TEMP1_TO_REG(val) ((val) <= -128000 ? -128 : \
213 (val) >= 127000 ? 127 : \
214 (val) < 0 ? ((val) - 500) / 1000 : \
215 ((val) + 500) / 1000)
216
217 /* for temp2 and temp3 which are 9-bit resolution, LSB = 0.5 degree Celsius
218 Assumes the top 8 bits are the integral amount and the bottom 8 bits
219 are the fractional amount. Since we only have 0.5 degree resolution,
220 the bottom 7 bits will always be zero */
221 #define TEMP23_FROM_REG(val) ((val) / 128 * 500)
222 #define TEMP23_TO_REG(val) ((val) <= -128000 ? 0x8000 : \
223 (val) >= 127500 ? 0x7F80 : \
224 (val) < 0 ? ((val) - 250) / 500 * 128 : \
225 ((val) + 250) / 500 * 128)
226
227
228 #define BEEP_MASK_TO_REG(val) ((val) & 0xffffff)
229 #define BEEP_MASK_FROM_REG(val) ((val) & 0xffffff)
230
231 #define DIV_FROM_REG(val) (1 << (val))
232
233 static u8 div_to_reg(int nr, long val)
234 {
235 int i;
236 int max;
237
238 /* first three fan's divisor max out at 8, rest max out at 128 */
239 max = (nr < 3) ? 8 : 128;
240 val = SENSORS_LIMIT(val, 1, max) >> 1;
241 for (i = 0; i < 7; i++) {
242 if (val == 0)
243 break;
244 val >>= 1;
245 }
246 return (u8) i;
247 }
248
249 struct w83791d_data {
250 struct i2c_client client;
251 struct class_device *class_dev;
252 struct mutex update_lock;
253
254 char valid; /* !=0 if following fields are valid */
255 unsigned long last_updated; /* In jiffies */
256
257 /* array of 2 pointers to subclients */
258 struct i2c_client *lm75[2];
259
260 /* volts */
261 u8 in[NUMBER_OF_VIN]; /* Register value */
262 u8 in_max[NUMBER_OF_VIN]; /* Register value */
263 u8 in_min[NUMBER_OF_VIN]; /* Register value */
264
265 /* fans */
266 u8 fan[NUMBER_OF_FANIN]; /* Register value */
267 u8 fan_min[NUMBER_OF_FANIN]; /* Register value */
268 u8 fan_div[NUMBER_OF_FANIN]; /* Register encoding, shifted right */
269
270 /* Temperature sensors */
271
272 s8 temp1[3]; /* current, over, thyst */
273 s16 temp_add[2][3]; /* fixed point value. Top 8 bits are the
274 integral part, bottom 8 bits are the
275 fractional part. We only use the top
276 9 bits as the resolution is only
277 to the 0.5 degree C...
278 two sensors with three values
279 (cur, over, hyst) */
280
281 /* Misc */
282 u32 alarms; /* realtime status register encoding,combined */
283 u8 beep_enable; /* Global beep enable */
284 u32 beep_mask; /* Mask off specific beeps */
285 u8 vid; /* Register encoding, combined */
286 u8 vrm; /* hwmon-vid */
287 };
288
289 static int w83791d_attach_adapter(struct i2c_adapter *adapter);
290 static int w83791d_detect(struct i2c_adapter *adapter, int address, int kind);
291 static int w83791d_detach_client(struct i2c_client *client);
292
293 static int w83791d_read(struct i2c_client *client, u8 register);
294 static int w83791d_write(struct i2c_client *client, u8 register, u8 value);
295 static struct w83791d_data *w83791d_update_device(struct device *dev);
296
297 #ifdef DEBUG
298 static void w83791d_print_debug(struct w83791d_data *data, struct device *dev);
299 #endif
300
301 static void w83791d_init_client(struct i2c_client *client);
302
303 static struct i2c_driver w83791d_driver = {
304 .driver = {
305 .name = "w83791d",
306 },
307 .attach_adapter = w83791d_attach_adapter,
308 .detach_client = w83791d_detach_client,
309 };
310
311 /* following are the sysfs callback functions */
312 #define show_in_reg(reg) \
313 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
314 char *buf) \
315 { \
316 struct sensor_device_attribute *sensor_attr = \
317 to_sensor_dev_attr(attr); \
318 struct w83791d_data *data = w83791d_update_device(dev); \
319 int nr = sensor_attr->index; \
320 return sprintf(buf,"%d\n", IN_FROM_REG(data->reg[nr])); \
321 }
322
323 show_in_reg(in);
324 show_in_reg(in_min);
325 show_in_reg(in_max);
326
327 #define store_in_reg(REG, reg) \
328 static ssize_t store_in_##reg(struct device *dev, \
329 struct device_attribute *attr, \
330 const char *buf, size_t count) \
331 { \
332 struct sensor_device_attribute *sensor_attr = \
333 to_sensor_dev_attr(attr); \
334 struct i2c_client *client = to_i2c_client(dev); \
335 struct w83791d_data *data = i2c_get_clientdata(client); \
336 unsigned long val = simple_strtoul(buf, NULL, 10); \
337 int nr = sensor_attr->index; \
338 \
339 mutex_lock(&data->update_lock); \
340 data->in_##reg[nr] = IN_TO_REG(val); \
341 w83791d_write(client, W83791D_REG_IN_##REG[nr], data->in_##reg[nr]); \
342 mutex_unlock(&data->update_lock); \
343 \
344 return count; \
345 }
346 store_in_reg(MIN, min);
347 store_in_reg(MAX, max);
348
349 static struct sensor_device_attribute sda_in_input[] = {
350 SENSOR_ATTR(in0_input, S_IRUGO, show_in, NULL, 0),
351 SENSOR_ATTR(in1_input, S_IRUGO, show_in, NULL, 1),
352 SENSOR_ATTR(in2_input, S_IRUGO, show_in, NULL, 2),
353 SENSOR_ATTR(in3_input, S_IRUGO, show_in, NULL, 3),
354 SENSOR_ATTR(in4_input, S_IRUGO, show_in, NULL, 4),
355 SENSOR_ATTR(in5_input, S_IRUGO, show_in, NULL, 5),
356 SENSOR_ATTR(in6_input, S_IRUGO, show_in, NULL, 6),
357 SENSOR_ATTR(in7_input, S_IRUGO, show_in, NULL, 7),
358 SENSOR_ATTR(in8_input, S_IRUGO, show_in, NULL, 8),
359 SENSOR_ATTR(in9_input, S_IRUGO, show_in, NULL, 9),
360 };
361
362 static struct sensor_device_attribute sda_in_min[] = {
363 SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 0),
364 SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 1),
365 SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 2),
366 SENSOR_ATTR(in3_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 3),
367 SENSOR_ATTR(in4_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 4),
368 SENSOR_ATTR(in5_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 5),
369 SENSOR_ATTR(in6_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 6),
370 SENSOR_ATTR(in7_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 7),
371 SENSOR_ATTR(in8_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 8),
372 SENSOR_ATTR(in9_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 9),
373 };
374
375 static struct sensor_device_attribute sda_in_max[] = {
376 SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 0),
377 SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 1),
378 SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 2),
379 SENSOR_ATTR(in3_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 3),
380 SENSOR_ATTR(in4_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 4),
381 SENSOR_ATTR(in5_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 5),
382 SENSOR_ATTR(in6_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 6),
383 SENSOR_ATTR(in7_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 7),
384 SENSOR_ATTR(in8_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 8),
385 SENSOR_ATTR(in9_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 9),
386 };
387
388 #define show_fan_reg(reg) \
389 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
390 char *buf) \
391 { \
392 struct sensor_device_attribute *sensor_attr = \
393 to_sensor_dev_attr(attr); \
394 struct w83791d_data *data = w83791d_update_device(dev); \
395 int nr = sensor_attr->index; \
396 return sprintf(buf,"%d\n", \
397 FAN_FROM_REG(data->reg[nr], DIV_FROM_REG(data->fan_div[nr]))); \
398 }
399
400 show_fan_reg(fan);
401 show_fan_reg(fan_min);
402
403 static ssize_t store_fan_min(struct device *dev, struct device_attribute *attr,
404 const char *buf, size_t count)
405 {
406 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
407 struct i2c_client *client = to_i2c_client(dev);
408 struct w83791d_data *data = i2c_get_clientdata(client);
409 unsigned long val = simple_strtoul(buf, NULL, 10);
410 int nr = sensor_attr->index;
411
412 mutex_lock(&data->update_lock);
413 data->fan_min[nr] = fan_to_reg(val, DIV_FROM_REG(data->fan_div[nr]));
414 w83791d_write(client, W83791D_REG_FAN_MIN[nr], data->fan_min[nr]);
415 mutex_unlock(&data->update_lock);
416
417 return count;
418 }
419
420 static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr,
421 char *buf)
422 {
423 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
424 int nr = sensor_attr->index;
425 struct w83791d_data *data = w83791d_update_device(dev);
426 return sprintf(buf, "%u\n", DIV_FROM_REG(data->fan_div[nr]));
427 }
428
429 /* Note: we save and restore the fan minimum here, because its value is
430 determined in part by the fan divisor. This follows the principle of
431 least suprise; the user doesn't expect the fan minimum to change just
432 because the divisor changed. */
433 static ssize_t store_fan_div(struct device *dev, struct device_attribute *attr,
434 const char *buf, size_t count)
435 {
436 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
437 struct i2c_client *client = to_i2c_client(dev);
438 struct w83791d_data *data = i2c_get_clientdata(client);
439 int nr = sensor_attr->index;
440 unsigned long min;
441 u8 tmp_fan_div;
442 u8 fan_div_reg;
443 int indx = 0;
444 u8 keep_mask = 0;
445 u8 new_shift = 0;
446
447 /* Save fan_min */
448 min = FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr]));
449
450 mutex_lock(&data->update_lock);
451 data->fan_div[nr] = div_to_reg(nr, simple_strtoul(buf, NULL, 10));
452
453 switch (nr) {
454 case 0:
455 indx = 0;
456 keep_mask = 0xcf;
457 new_shift = 4;
458 break;
459 case 1:
460 indx = 0;
461 keep_mask = 0x3f;
462 new_shift = 6;
463 break;
464 case 2:
465 indx = 1;
466 keep_mask = 0x3f;
467 new_shift = 6;
468 break;
469 case 3:
470 indx = 2;
471 keep_mask = 0xf8;
472 new_shift = 0;
473 break;
474 case 4:
475 indx = 2;
476 keep_mask = 0x8f;
477 new_shift = 4;
478 break;
479 #ifdef DEBUG
480 default:
481 dev_warn(dev, "store_fan_div: Unexpected nr seen: %d\n", nr);
482 count = -EINVAL;
483 goto err_exit;
484 #endif
485 }
486
487 fan_div_reg = w83791d_read(client, W83791D_REG_FAN_DIV[indx])
488 & keep_mask;
489 tmp_fan_div = (data->fan_div[nr] << new_shift) & ~keep_mask;
490
491 w83791d_write(client, W83791D_REG_FAN_DIV[indx],
492 fan_div_reg | tmp_fan_div);
493
494 /* Restore fan_min */
495 data->fan_min[nr] = fan_to_reg(min, DIV_FROM_REG(data->fan_div[nr]));
496 w83791d_write(client, W83791D_REG_FAN_MIN[nr], data->fan_min[nr]);
497
498 #ifdef DEBUG
499 err_exit:
500 #endif
501 mutex_unlock(&data->update_lock);
502
503 return count;
504 }
505
506 static struct sensor_device_attribute sda_fan_input[] = {
507 SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0),
508 SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1),
509 SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2),
510 SENSOR_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3),
511 SENSOR_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4),
512 };
513
514 static struct sensor_device_attribute sda_fan_min[] = {
515 SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO,
516 show_fan_min, store_fan_min, 0),
517 SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO,
518 show_fan_min, store_fan_min, 1),
519 SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO,
520 show_fan_min, store_fan_min, 2),
521 SENSOR_ATTR(fan4_min, S_IWUSR | S_IRUGO,
522 show_fan_min, store_fan_min, 3),
523 SENSOR_ATTR(fan5_min, S_IWUSR | S_IRUGO,
524 show_fan_min, store_fan_min, 4),
525 };
526
527 static struct sensor_device_attribute sda_fan_div[] = {
528 SENSOR_ATTR(fan1_div, S_IWUSR | S_IRUGO,
529 show_fan_div, store_fan_div, 0),
530 SENSOR_ATTR(fan2_div, S_IWUSR | S_IRUGO,
531 show_fan_div, store_fan_div, 1),
532 SENSOR_ATTR(fan3_div, S_IWUSR | S_IRUGO,
533 show_fan_div, store_fan_div, 2),
534 SENSOR_ATTR(fan4_div, S_IWUSR | S_IRUGO,
535 show_fan_div, store_fan_div, 3),
536 SENSOR_ATTR(fan5_div, S_IWUSR | S_IRUGO,
537 show_fan_div, store_fan_div, 4),
538 };
539
540 /* read/write the temperature1, includes measured value and limits */
541 static ssize_t show_temp1(struct device *dev, struct device_attribute *devattr,
542 char *buf)
543 {
544 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
545 struct w83791d_data *data = w83791d_update_device(dev);
546 return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp1[attr->index]));
547 }
548
549 static ssize_t store_temp1(struct device *dev, struct device_attribute *devattr,
550 const char *buf, size_t count)
551 {
552 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
553 struct i2c_client *client = to_i2c_client(dev);
554 struct w83791d_data *data = i2c_get_clientdata(client);
555 long val = simple_strtol(buf, NULL, 10);
556 int nr = attr->index;
557
558 mutex_lock(&data->update_lock);
559 data->temp1[nr] = TEMP1_TO_REG(val);
560 w83791d_write(client, W83791D_REG_TEMP1[nr], data->temp1[nr]);
561 mutex_unlock(&data->update_lock);
562 return count;
563 }
564
565 /* read/write temperature2-3, includes measured value and limits */
566 static ssize_t show_temp23(struct device *dev, struct device_attribute *devattr,
567 char *buf)
568 {
569 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
570 struct w83791d_data *data = w83791d_update_device(dev);
571 int nr = attr->nr;
572 int index = attr->index;
573 return sprintf(buf, "%d\n", TEMP23_FROM_REG(data->temp_add[nr][index]));
574 }
575
576 static ssize_t store_temp23(struct device *dev,
577 struct device_attribute *devattr,
578 const char *buf, size_t count)
579 {
580 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
581 struct i2c_client *client = to_i2c_client(dev);
582 struct w83791d_data *data = i2c_get_clientdata(client);
583 long val = simple_strtol(buf, NULL, 10);
584 int nr = attr->nr;
585 int index = attr->index;
586
587 mutex_lock(&data->update_lock);
588 data->temp_add[nr][index] = TEMP23_TO_REG(val);
589 w83791d_write(client, W83791D_REG_TEMP_ADD[nr][index * 2],
590 data->temp_add[nr][index] >> 8);
591 w83791d_write(client, W83791D_REG_TEMP_ADD[nr][index * 2 + 1],
592 data->temp_add[nr][index] & 0x80);
593 mutex_unlock(&data->update_lock);
594
595 return count;
596 }
597
598 static struct sensor_device_attribute_2 sda_temp_input[] = {
599 SENSOR_ATTR_2(temp1_input, S_IRUGO, show_temp1, NULL, 0, 0),
600 SENSOR_ATTR_2(temp2_input, S_IRUGO, show_temp23, NULL, 0, 0),
601 SENSOR_ATTR_2(temp3_input, S_IRUGO, show_temp23, NULL, 1, 0),
602 };
603
604 static struct sensor_device_attribute_2 sda_temp_max[] = {
605 SENSOR_ATTR_2(temp1_max, S_IRUGO | S_IWUSR,
606 show_temp1, store_temp1, 0, 1),
607 SENSOR_ATTR_2(temp2_max, S_IRUGO | S_IWUSR,
608 show_temp23, store_temp23, 0, 1),
609 SENSOR_ATTR_2(temp3_max, S_IRUGO | S_IWUSR,
610 show_temp23, store_temp23, 1, 1),
611 };
612
613 static struct sensor_device_attribute_2 sda_temp_max_hyst[] = {
614 SENSOR_ATTR_2(temp1_max_hyst, S_IRUGO | S_IWUSR,
615 show_temp1, store_temp1, 0, 2),
616 SENSOR_ATTR_2(temp2_max_hyst, S_IRUGO | S_IWUSR,
617 show_temp23, store_temp23, 0, 2),
618 SENSOR_ATTR_2(temp3_max_hyst, S_IRUGO | S_IWUSR,
619 show_temp23, store_temp23, 1, 2),
620 };
621
622
623 /* get reatime status of all sensors items: voltage, temp, fan */
624 static ssize_t show_alarms_reg(struct device *dev,
625 struct device_attribute *attr, char *buf)
626 {
627 struct w83791d_data *data = w83791d_update_device(dev);
628 return sprintf(buf, "%u\n", data->alarms);
629 }
630
631 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
632
633 /* Beep control */
634
635 #define GLOBAL_BEEP_ENABLE_SHIFT 15
636 #define GLOBAL_BEEP_ENABLE_MASK (1 << GLOBAL_BEEP_ENABLE_SHIFT)
637
638 static ssize_t show_beep_enable(struct device *dev,
639 struct device_attribute *attr, char *buf)
640 {
641 struct w83791d_data *data = w83791d_update_device(dev);
642 return sprintf(buf, "%d\n", data->beep_enable);
643 }
644
645 static ssize_t show_beep_mask(struct device *dev,
646 struct device_attribute *attr, char *buf)
647 {
648 struct w83791d_data *data = w83791d_update_device(dev);
649 return sprintf(buf, "%d\n", BEEP_MASK_FROM_REG(data->beep_mask));
650 }
651
652
653 static ssize_t store_beep_mask(struct device *dev,
654 struct device_attribute *attr,
655 const char *buf, size_t count)
656 {
657 struct i2c_client *client = to_i2c_client(dev);
658 struct w83791d_data *data = i2c_get_clientdata(client);
659 long val = simple_strtol(buf, NULL, 10);
660 int i;
661
662 mutex_lock(&data->update_lock);
663
664 /* The beep_enable state overrides any enabling request from
665 the masks */
666 data->beep_mask = BEEP_MASK_TO_REG(val) & ~GLOBAL_BEEP_ENABLE_MASK;
667 data->beep_mask |= (data->beep_enable << GLOBAL_BEEP_ENABLE_SHIFT);
668
669 val = data->beep_mask;
670
671 for (i = 0; i < 3; i++) {
672 w83791d_write(client, W83791D_REG_BEEP_CTRL[i], (val & 0xff));
673 val >>= 8;
674 }
675
676 mutex_unlock(&data->update_lock);
677
678 return count;
679 }
680
681 static ssize_t store_beep_enable(struct device *dev,
682 struct device_attribute *attr,
683 const char *buf, size_t count)
684 {
685 struct i2c_client *client = to_i2c_client(dev);
686 struct w83791d_data *data = i2c_get_clientdata(client);
687 long val = simple_strtol(buf, NULL, 10);
688
689 mutex_lock(&data->update_lock);
690
691 data->beep_enable = val ? 1 : 0;
692
693 /* Keep the full mask value in sync with the current enable */
694 data->beep_mask &= ~GLOBAL_BEEP_ENABLE_MASK;
695 data->beep_mask |= (data->beep_enable << GLOBAL_BEEP_ENABLE_SHIFT);
696
697 /* The global control is in the second beep control register
698 so only need to update that register */
699 val = (data->beep_mask >> 8) & 0xff;
700
701 w83791d_write(client, W83791D_REG_BEEP_CTRL[1], val);
702
703 mutex_unlock(&data->update_lock);
704
705 return count;
706 }
707
708 static struct sensor_device_attribute sda_beep_ctrl[] = {
709 SENSOR_ATTR(beep_enable, S_IRUGO | S_IWUSR,
710 show_beep_enable, store_beep_enable, 0),
711 SENSOR_ATTR(beep_mask, S_IRUGO | S_IWUSR,
712 show_beep_mask, store_beep_mask, 1)
713 };
714
715 /* cpu voltage regulation information */
716 static ssize_t show_vid_reg(struct device *dev,
717 struct device_attribute *attr, char *buf)
718 {
719 struct w83791d_data *data = w83791d_update_device(dev);
720 return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
721 }
722
723 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
724
725 static ssize_t show_vrm_reg(struct device *dev,
726 struct device_attribute *attr, char *buf)
727 {
728 struct w83791d_data *data = w83791d_update_device(dev);
729 return sprintf(buf, "%d\n", data->vrm);
730 }
731
732 static ssize_t store_vrm_reg(struct device *dev,
733 struct device_attribute *attr,
734 const char *buf, size_t count)
735 {
736 struct i2c_client *client = to_i2c_client(dev);
737 struct w83791d_data *data = i2c_get_clientdata(client);
738 unsigned long val = simple_strtoul(buf, NULL, 10);
739
740 /* No lock needed as vrm is internal to the driver
741 (not read from a chip register) and so is not
742 updated in w83791d_update_device() */
743 data->vrm = val;
744
745 return count;
746 }
747
748 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
749
750 /* This function is called when:
751 * w83791d_driver is inserted (when this module is loaded), for each
752 available adapter
753 * when a new adapter is inserted (and w83791d_driver is still present) */
754 static int w83791d_attach_adapter(struct i2c_adapter *adapter)
755 {
756 if (!(adapter->class & I2C_CLASS_HWMON))
757 return 0;
758 return i2c_probe(adapter, &addr_data, w83791d_detect);
759 }
760
761
762 static int w83791d_create_subclient(struct i2c_adapter *adapter,
763 struct i2c_client *client, int addr,
764 struct i2c_client **sub_cli)
765 {
766 int err;
767 struct i2c_client *sub_client;
768
769 (*sub_cli) = sub_client =
770 kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
771 if (!(sub_client)) {
772 return -ENOMEM;
773 }
774 sub_client->addr = 0x48 + addr;
775 i2c_set_clientdata(sub_client, NULL);
776 sub_client->adapter = adapter;
777 sub_client->driver = &w83791d_driver;
778 strlcpy(sub_client->name, "w83791d subclient", I2C_NAME_SIZE);
779 if ((err = i2c_attach_client(sub_client))) {
780 dev_err(&client->dev, "subclient registration "
781 "at address 0x%x failed\n", sub_client->addr);
782 kfree(sub_client);
783 return err;
784 }
785 return 0;
786 }
787
788
789 static int w83791d_detect_subclients(struct i2c_adapter *adapter, int address,
790 int kind, struct i2c_client *client)
791 {
792 struct w83791d_data *data = i2c_get_clientdata(client);
793 int i, id, err;
794 u8 val;
795
796 id = i2c_adapter_id(adapter);
797 if (force_subclients[0] == id && force_subclients[1] == address) {
798 for (i = 2; i <= 3; i++) {
799 if (force_subclients[i] < 0x48 ||
800 force_subclients[i] > 0x4f) {
801 dev_err(&client->dev,
802 "invalid subclient "
803 "address %d; must be 0x48-0x4f\n",
804 force_subclients[i]);
805 err = -ENODEV;
806 goto error_sc_0;
807 }
808 }
809 w83791d_write(client, W83791D_REG_I2C_SUBADDR,
810 (force_subclients[2] & 0x07) |
811 ((force_subclients[3] & 0x07) << 4));
812 }
813
814 val = w83791d_read(client, W83791D_REG_I2C_SUBADDR);
815 if (!(val & 0x08)) {
816 err = w83791d_create_subclient(adapter, client,
817 val & 0x7, &data->lm75[0]);
818 if (err < 0)
819 goto error_sc_0;
820 }
821 if (!(val & 0x80)) {
822 if ((data->lm75[0] != NULL) &&
823 ((val & 0x7) == ((val >> 4) & 0x7))) {
824 dev_err(&client->dev,
825 "duplicate addresses 0x%x, "
826 "use force_subclient\n",
827 data->lm75[0]->addr);
828 err = -ENODEV;
829 goto error_sc_1;
830 }
831 err = w83791d_create_subclient(adapter, client,
832 (val >> 4) & 0x7, &data->lm75[1]);
833 if (err < 0)
834 goto error_sc_1;
835 }
836
837 return 0;
838
839 /* Undo inits in case of errors */
840
841 error_sc_1:
842 if (data->lm75[0] != NULL) {
843 i2c_detach_client(data->lm75[0]);
844 kfree(data->lm75[0]);
845 }
846 error_sc_0:
847 return err;
848 }
849
850
851 static int w83791d_detect(struct i2c_adapter *adapter, int address, int kind)
852 {
853 struct i2c_client *client;
854 struct device *dev;
855 struct w83791d_data *data;
856 int i, val1, val2;
857 int err = 0;
858 const char *client_name = "";
859
860 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
861 goto error0;
862 }
863
864 /* OK. For now, we presume we have a valid client. We now create the
865 client structure, even though we cannot fill it completely yet.
866 But it allows us to access w83791d_{read,write}_value. */
867 if (!(data = kzalloc(sizeof(struct w83791d_data), GFP_KERNEL))) {
868 err = -ENOMEM;
869 goto error0;
870 }
871
872 client = &data->client;
873 dev = &client->dev;
874 i2c_set_clientdata(client, data);
875 client->addr = address;
876 client->adapter = adapter;
877 client->driver = &w83791d_driver;
878 mutex_init(&data->update_lock);
879
880 /* Now, we do the remaining detection. */
881
882 /* The w83791d may be stuck in some other bank than bank 0. This may
883 make reading other information impossible. Specify a force=...
884 parameter, and the Winbond will be reset to the right bank. */
885 if (kind < 0) {
886 if (w83791d_read(client, W83791D_REG_CONFIG) & 0x80) {
887 dev_dbg(dev, "Detection failed at step 1\n");
888 goto error1;
889 }
890 val1 = w83791d_read(client, W83791D_REG_BANK);
891 val2 = w83791d_read(client, W83791D_REG_CHIPMAN);
892 /* Check for Winbond ID if in bank 0 */
893 if (!(val1 & 0x07)) {
894 /* yes it is Bank0 */
895 if (((!(val1 & 0x80)) && (val2 != 0xa3)) ||
896 ((val1 & 0x80) && (val2 != 0x5c))) {
897 dev_dbg(dev, "Detection failed at step 2\n");
898 goto error1;
899 }
900 }
901 /* If Winbond chip, address of chip and W83791D_REG_I2C_ADDR
902 should match */
903 if (w83791d_read(client, W83791D_REG_I2C_ADDR) != address) {
904 dev_dbg(dev, "Detection failed at step 3\n");
905 goto error1;
906 }
907 }
908
909 /* We either have a force parameter or we have reason to
910 believe it is a Winbond chip. Either way, we want bank 0 and
911 Vendor ID high byte */
912 val1 = w83791d_read(client, W83791D_REG_BANK) & 0x78;
913 w83791d_write(client, W83791D_REG_BANK, val1 | 0x80);
914
915 /* Verify it is a Winbond w83791d */
916 if (kind <= 0) {
917 /* get vendor ID */
918 val2 = w83791d_read(client, W83791D_REG_CHIPMAN);
919 if (val2 != 0x5c) { /* the vendor is NOT Winbond */
920 dev_dbg(dev, "Detection failed at step 4\n");
921 goto error1;
922 }
923 val1 = w83791d_read(client, W83791D_REG_WCHIPID);
924 if (val1 == 0x71) {
925 kind = w83791d;
926 } else {
927 if (kind == 0)
928 dev_warn(dev,
929 "w83791d: Ignoring 'force' parameter "
930 "for unknown chip at adapter %d, "
931 "address 0x%02x\n",
932 i2c_adapter_id(adapter), address);
933 goto error1;
934 }
935 }
936
937 if (kind == w83791d) {
938 client_name = "w83791d";
939 } else {
940 dev_err(dev, "w83791d: Internal error: unknown kind (%d)?!?",
941 kind);
942 goto error1;
943 }
944
945 #ifdef DEBUG
946 val1 = w83791d_read(client, W83791D_REG_DID_VID4);
947 dev_dbg(dev, "Device ID version: %d.%d (0x%02x)\n",
948 (val1 >> 5) & 0x07, (val1 >> 1) & 0x0f, val1);
949 #endif
950
951 /* Fill in the remaining client fields and put into the global list */
952 strlcpy(client->name, client_name, I2C_NAME_SIZE);
953
954 /* Tell the I2C layer a new client has arrived */
955 if ((err = i2c_attach_client(client)))
956 goto error1;
957
958 if ((err = w83791d_detect_subclients(adapter, address, kind, client)))
959 goto error2;
960
961 /* Initialize the chip */
962 w83791d_init_client(client);
963
964 /* If the fan_div is changed, make sure there is a rational
965 fan_min in place */
966 for (i = 0; i < NUMBER_OF_FANIN; i++) {
967 data->fan_min[i] = w83791d_read(client, W83791D_REG_FAN_MIN[i]);
968 }
969
970 /* Register sysfs hooks */
971 data->class_dev = hwmon_device_register(dev);
972 if (IS_ERR(data->class_dev)) {
973 err = PTR_ERR(data->class_dev);
974 goto error3;
975 }
976
977 for (i = 0; i < NUMBER_OF_VIN; i++) {
978 device_create_file(dev, &sda_in_input[i].dev_attr);
979 device_create_file(dev, &sda_in_min[i].dev_attr);
980 device_create_file(dev, &sda_in_max[i].dev_attr);
981 }
982
983 for (i = 0; i < NUMBER_OF_FANIN; i++) {
984 device_create_file(dev, &sda_fan_input[i].dev_attr);
985 device_create_file(dev, &sda_fan_div[i].dev_attr);
986 device_create_file(dev, &sda_fan_min[i].dev_attr);
987 }
988
989 for (i = 0; i < NUMBER_OF_TEMPIN; i++) {
990 device_create_file(dev, &sda_temp_input[i].dev_attr);
991 device_create_file(dev, &sda_temp_max[i].dev_attr);
992 device_create_file(dev, &sda_temp_max_hyst[i].dev_attr);
993 }
994
995 device_create_file(dev, &dev_attr_alarms);
996
997 for (i = 0; i < ARRAY_SIZE(sda_beep_ctrl); i++) {
998 device_create_file(dev, &sda_beep_ctrl[i].dev_attr);
999 }
1000
1001 device_create_file(dev, &dev_attr_cpu0_vid);
1002 device_create_file(dev, &dev_attr_vrm);
1003
1004 return 0;
1005
1006 error3:
1007 if (data->lm75[0] != NULL) {
1008 i2c_detach_client(data->lm75[0]);
1009 kfree(data->lm75[0]);
1010 }
1011 if (data->lm75[1] != NULL) {
1012 i2c_detach_client(data->lm75[1]);
1013 kfree(data->lm75[1]);
1014 }
1015 error2:
1016 i2c_detach_client(client);
1017 error1:
1018 kfree(data);
1019 error0:
1020 return err;
1021 }
1022
1023 static int w83791d_detach_client(struct i2c_client *client)
1024 {
1025 struct w83791d_data *data = i2c_get_clientdata(client);
1026 int err;
1027
1028 /* main client */
1029 if (data)
1030 hwmon_device_unregister(data->class_dev);
1031
1032 if ((err = i2c_detach_client(client)))
1033 return err;
1034
1035 /* main client */
1036 if (data)
1037 kfree(data);
1038 /* subclient */
1039 else
1040 kfree(client);
1041
1042 return 0;
1043 }
1044
1045 static void w83791d_init_client(struct i2c_client *client)
1046 {
1047 struct w83791d_data *data = i2c_get_clientdata(client);
1048 u8 tmp;
1049 u8 old_beep;
1050
1051 /* The difference between reset and init is that reset
1052 does a hard reset of the chip via index 0x40, bit 7,
1053 but init simply forces certain registers to have "sane"
1054 values. The hope is that the BIOS has done the right
1055 thing (which is why the default is reset=0, init=0),
1056 but if not, reset is the hard hammer and init
1057 is the soft mallet both of which are trying to whack
1058 things into place...
1059 NOTE: The data sheet makes a distinction between
1060 "power on defaults" and "reset by MR". As far as I can tell,
1061 the hard reset puts everything into a power-on state so I'm
1062 not sure what "reset by MR" means or how it can happen.
1063 */
1064 if (reset || init) {
1065 /* keep some BIOS settings when we... */
1066 old_beep = w83791d_read(client, W83791D_REG_BEEP_CONFIG);
1067
1068 if (reset) {
1069 /* ... reset the chip and ... */
1070 w83791d_write(client, W83791D_REG_CONFIG, 0x80);
1071 }
1072
1073 /* ... disable power-on abnormal beep */
1074 w83791d_write(client, W83791D_REG_BEEP_CONFIG, old_beep | 0x80);
1075
1076 /* disable the global beep (not done by hard reset) */
1077 tmp = w83791d_read(client, W83791D_REG_BEEP_CTRL[1]);
1078 w83791d_write(client, W83791D_REG_BEEP_CTRL[1], tmp & 0xef);
1079
1080 if (init) {
1081 /* Make sure monitoring is turned on for add-ons */
1082 tmp = w83791d_read(client, W83791D_REG_TEMP2_CONFIG);
1083 if (tmp & 1) {
1084 w83791d_write(client, W83791D_REG_TEMP2_CONFIG,
1085 tmp & 0xfe);
1086 }
1087
1088 tmp = w83791d_read(client, W83791D_REG_TEMP3_CONFIG);
1089 if (tmp & 1) {
1090 w83791d_write(client, W83791D_REG_TEMP3_CONFIG,
1091 tmp & 0xfe);
1092 }
1093
1094 /* Start monitoring */
1095 tmp = w83791d_read(client, W83791D_REG_CONFIG) & 0xf7;
1096 w83791d_write(client, W83791D_REG_CONFIG, tmp | 0x01);
1097 }
1098 }
1099
1100 data->vrm = vid_which_vrm();
1101 }
1102
1103 static struct w83791d_data *w83791d_update_device(struct device *dev)
1104 {
1105 struct i2c_client *client = to_i2c_client(dev);
1106 struct w83791d_data *data = i2c_get_clientdata(client);
1107 int i, j;
1108 u8 reg_array_tmp[3];
1109
1110 mutex_lock(&data->update_lock);
1111
1112 if (time_after(jiffies, data->last_updated + (HZ * 3))
1113 || !data->valid) {
1114 dev_dbg(dev, "Starting w83791d device update\n");
1115
1116 /* Update the voltages measured value and limits */
1117 for (i = 0; i < NUMBER_OF_VIN; i++) {
1118 data->in[i] = w83791d_read(client,
1119 W83791D_REG_IN[i]);
1120 data->in_max[i] = w83791d_read(client,
1121 W83791D_REG_IN_MAX[i]);
1122 data->in_min[i] = w83791d_read(client,
1123 W83791D_REG_IN_MIN[i]);
1124 }
1125
1126 /* Update the fan counts and limits */
1127 for (i = 0; i < NUMBER_OF_FANIN; i++) {
1128 /* Update the Fan measured value and limits */
1129 data->fan[i] = w83791d_read(client,
1130 W83791D_REG_FAN[i]);
1131 data->fan_min[i] = w83791d_read(client,
1132 W83791D_REG_FAN_MIN[i]);
1133 }
1134
1135 /* Update the fan divisor */
1136 for (i = 0; i < 3; i++) {
1137 reg_array_tmp[i] = w83791d_read(client,
1138 W83791D_REG_FAN_DIV[i]);
1139 }
1140 data->fan_div[0] = (reg_array_tmp[0] >> 4) & 0x03;
1141 data->fan_div[1] = (reg_array_tmp[0] >> 6) & 0x03;
1142 data->fan_div[2] = (reg_array_tmp[1] >> 6) & 0x03;
1143 data->fan_div[3] = reg_array_tmp[2] & 0x07;
1144 data->fan_div[4] = (reg_array_tmp[2] >> 4) & 0x07;
1145
1146 /* Update the first temperature sensor */
1147 for (i = 0; i < 3; i++) {
1148 data->temp1[i] = w83791d_read(client,
1149 W83791D_REG_TEMP1[i]);
1150 }
1151
1152 /* Update the rest of the temperature sensors */
1153 for (i = 0; i < 2; i++) {
1154 for (j = 0; j < 3; j++) {
1155 data->temp_add[i][j] =
1156 (w83791d_read(client,
1157 W83791D_REG_TEMP_ADD[i][j * 2]) << 8) |
1158 w83791d_read(client,
1159 W83791D_REG_TEMP_ADD[i][j * 2 + 1]);
1160 }
1161 }
1162
1163 /* Update the realtime status */
1164 data->alarms =
1165 w83791d_read(client, W83791D_REG_ALARM1) +
1166 (w83791d_read(client, W83791D_REG_ALARM2) << 8) +
1167 (w83791d_read(client, W83791D_REG_ALARM3) << 16);
1168
1169 /* Update the beep configuration information */
1170 data->beep_mask =
1171 w83791d_read(client, W83791D_REG_BEEP_CTRL[0]) +
1172 (w83791d_read(client, W83791D_REG_BEEP_CTRL[1]) << 8) +
1173 (w83791d_read(client, W83791D_REG_BEEP_CTRL[2]) << 16);
1174
1175 data->beep_enable =
1176 (data->beep_mask >> GLOBAL_BEEP_ENABLE_SHIFT) & 0x01;
1177
1178 /* Update the cpu voltage information */
1179 i = w83791d_read(client, W83791D_REG_VID_FANDIV);
1180 data->vid = i & 0x0f;
1181 data->vid |= (w83791d_read(client, W83791D_REG_DID_VID4) & 0x01)
1182 << 4;
1183
1184 data->last_updated = jiffies;
1185 data->valid = 1;
1186 }
1187
1188 mutex_unlock(&data->update_lock);
1189
1190 #ifdef DEBUG
1191 w83791d_print_debug(data, dev);
1192 #endif
1193
1194 return data;
1195 }
1196
1197 #ifdef DEBUG
1198 static void w83791d_print_debug(struct w83791d_data *data, struct device *dev)
1199 {
1200 int i = 0, j = 0;
1201
1202 dev_dbg(dev, "======Start of w83791d debug values======\n");
1203 dev_dbg(dev, "%d set of Voltages: ===>\n", NUMBER_OF_VIN);
1204 for (i = 0; i < NUMBER_OF_VIN; i++) {
1205 dev_dbg(dev, "vin[%d] is: 0x%02x\n", i, data->in[i]);
1206 dev_dbg(dev, "vin[%d] min is: 0x%02x\n", i, data->in_min[i]);
1207 dev_dbg(dev, "vin[%d] max is: 0x%02x\n", i, data->in_max[i]);
1208 }
1209 dev_dbg(dev, "%d set of Fan Counts/Divisors: ===>\n", NUMBER_OF_FANIN);
1210 for (i = 0; i < NUMBER_OF_FANIN; i++) {
1211 dev_dbg(dev, "fan[%d] is: 0x%02x\n", i, data->fan[i]);
1212 dev_dbg(dev, "fan[%d] min is: 0x%02x\n", i, data->fan_min[i]);
1213 dev_dbg(dev, "fan_div[%d] is: 0x%02x\n", i, data->fan_div[i]);
1214 }
1215
1216 /* temperature math is signed, but only print out the
1217 bits that matter */
1218 dev_dbg(dev, "%d set of Temperatures: ===>\n", NUMBER_OF_TEMPIN);
1219 for (i = 0; i < 3; i++) {
1220 dev_dbg(dev, "temp1[%d] is: 0x%02x\n", i, (u8) data->temp1[i]);
1221 }
1222 for (i = 0; i < 2; i++) {
1223 for (j = 0; j < 3; j++) {
1224 dev_dbg(dev, "temp_add[%d][%d] is: 0x%04x\n", i, j,
1225 (u16) data->temp_add[i][j]);
1226 }
1227 }
1228
1229 dev_dbg(dev, "Misc Information: ===>\n");
1230 dev_dbg(dev, "alarm is: 0x%08x\n", data->alarms);
1231 dev_dbg(dev, "beep_mask is: 0x%08x\n", data->beep_mask);
1232 dev_dbg(dev, "beep_enable is: %d\n", data->beep_enable);
1233 dev_dbg(dev, "vid is: 0x%02x\n", data->vid);
1234 dev_dbg(dev, "vrm is: 0x%02x\n", data->vrm);
1235 dev_dbg(dev, "=======End of w83791d debug values========\n");
1236 dev_dbg(dev, "\n");
1237 }
1238 #endif
1239
1240 static int __init sensors_w83791d_init(void)
1241 {
1242 return i2c_add_driver(&w83791d_driver);
1243 }
1244
1245 static void __exit sensors_w83791d_exit(void)
1246 {
1247 i2c_del_driver(&w83791d_driver);
1248 }
1249
1250 MODULE_AUTHOR("Charles Spirakis <bezaur@gmail.com>");
1251 MODULE_DESCRIPTION("W83791D driver");
1252 MODULE_LICENSE("GPL");
1253
1254 module_init(sensors_w83791d_init);
1255 module_exit(sensors_w83791d_exit);
Verdex Pro support