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