2 w83791d.c - Part of lm_sensors, Linux kernel modules for hardware
5 Copyright (C) 2006-2007 Charles Spirakis <bezaur@gmail.com>
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.
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.
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.
23 Supports following chips:
25 Chip #vin #fanin #pwm #temp wchipid vendid i2c ISA
26 w83791d 10 5 5 3 0x71 0x5ca3 yes no
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
32 The w83791g chip is the same as the w83791d but lead-free.
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>
45 #define NUMBER_OF_VIN 10
46 #define NUMBER_OF_FANIN 5
47 #define NUMBER_OF_TEMPIN 3
48 #define NUMBER_OF_PWM 5
50 /* Addresses to scan */
51 static const unsigned short normal_i2c
[] = { 0x2c, 0x2d, 0x2e, 0x2f,
54 /* Insmod parameters */
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}");
62 module_param(reset
, bool, 0);
63 MODULE_PARM_DESC(reset
, "Set to one to force a hardware chip reset");
66 module_param(init
, bool, 0);
67 MODULE_PARM_DESC(init
, "Set to one to force extra software initialization");
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 */
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 */
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 */
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 */
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 */
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 */
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 */
136 static const u8 W83791D_REG_TEMP_TOL
[2] = {
137 0x87, /* PWM 1/2 temperature tolerance */
138 0x97, /* PWM 3 temperature tolerance */
141 static const u8 W83791D_REG_FAN_CFG
[2] = {
142 0x84, /* FAN 1/2 configuration */
143 0x95, /* FAN 3 configuration */
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 */
152 #define W83791D_REG_BANK 0x4E
153 #define W83791D_REG_TEMP2_CONFIG 0xC2
154 #define W83791D_REG_TEMP3_CONFIG 0xCA
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 */
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 */
177 #define W83791D_REG_BEEP_CONFIG 0x4D
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 */
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
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 */
198 #define W83791D_REG_VBAT 0x5D
199 #define W83791D_REG_I2C_ADDR 0x48
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
)
207 return i2c_smbus_read_byte_data(client
, reg
);
210 static inline int w83791d_write(struct i2c_client
*client
, u8 reg
, u8 value
)
212 return i2c_smbus_write_byte_data(client
, reg
, value
);
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)
221 static u8
fan_to_reg(long rpm
, int div
)
225 rpm
= SENSORS_LIMIT(rpm
, 1, 1000000);
226 return SENSORS_LIMIT((1350000 + rpm
* div
/ 2) / (rpm
* div
), 1, 254);
229 #define FAN_FROM_REG(val,div) ((val) == 0 ? -1 : \
230 ((val) == 255 ? 0 : \
231 1350000 / ((val) * (div))))
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)
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)
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)
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)
260 #define BEEP_MASK_TO_REG(val) ((val) & 0xffffff)
261 #define BEEP_MASK_FROM_REG(val) ((val) & 0xffffff)
263 #define DIV_FROM_REG(val) (1 << (val))
265 static u8
div_to_reg(int nr
, long val
)
269 /* fan divisors max out at 128 */
270 val
= SENSORS_LIMIT(val
, 1, 128) >> 1;
271 for (i
= 0; i
< 7; i
++) {
279 struct w83791d_data
{
280 struct device
*hwmon_dev
;
281 struct mutex update_lock
;
283 char valid
; /* !=0 if following fields are valid */
284 unsigned long last_updated
; /* In jiffies */
286 /* array of 2 pointers to subclients */
287 struct i2c_client
*lm75
[2];
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 */
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 */
299 /* Temperature sensors */
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
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) */
315 u8 temp_target
[3]; /* pwm 1-3 target temperature */
316 u8 temp_tolerance
[3]; /* pwm 1-3 temperature tolerance */
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 */
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
);
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
);
337 static void w83791d_print_debug(struct w83791d_data
*data
, struct device
*dev
);
340 static void w83791d_init_client(struct i2c_client
*client
);
342 static const struct i2c_device_id w83791d_id
[] = {
346 MODULE_DEVICE_TABLE(i2c
, w83791d_id
);
348 static struct i2c_driver w83791d_driver
= {
349 .class = I2C_CLASS_HWMON
,
353 .probe
= w83791d_probe
,
354 .remove
= w83791d_remove
,
355 .id_table
= w83791d_id
,
356 .detect
= w83791d_detect
,
357 .address_list
= normal_i2c
,
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, \
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])); \
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) \
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; \
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); \
395 store_in_reg(MIN
, min
);
396 store_in_reg(MAX
, max
);
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),
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),
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),
438 static ssize_t
show_beep(struct device
*dev
, struct device_attribute
*attr
,
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
;
446 return sprintf(buf
, "%d\n", (data
->beep_mask
>> bitnr
) & 1);
449 static ssize_t
store_beep(struct device
*dev
, struct device_attribute
*attr
,
450 const char *buf
, size_t count
)
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;
460 mutex_lock(&data
->update_lock
);
462 data
->beep_mask
&= ~(0xff << (bytenr
* 8));
463 data
->beep_mask
|= w83791d_read(client
, W83791D_REG_BEEP_CTRL
[bytenr
])
466 data
->beep_mask
&= ~(1 << bitnr
);
467 data
->beep_mask
|= val
<< bitnr
;
469 w83791d_write(client
, W83791D_REG_BEEP_CTRL
[bytenr
],
470 (data
->beep_mask
>> (bytenr
* 8)) & 0xff);
472 mutex_unlock(&data
->update_lock
);
477 static ssize_t
show_alarm(struct device
*dev
, struct device_attribute
*attr
,
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
;
485 return sprintf(buf
, "%d\n", (data
->alarms
>> bitnr
) & 1);
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),
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),
516 #define show_fan_reg(reg) \
517 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
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]))); \
529 show_fan_reg(fan_min
);
531 static ssize_t
store_fan_min(struct device
*dev
, struct device_attribute
*attr
,
532 const char *buf
, size_t count
)
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
;
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
);
548 static ssize_t
show_fan_div(struct device
*dev
, struct device_attribute
*attr
,
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
]));
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
)
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
;
577 min
= FAN_FROM_REG(data
->fan_min
[nr
], DIV_FROM_REG(data
->fan_div
[nr
]));
579 mutex_lock(&data
->update_lock
);
580 data
->fan_div
[nr
] = div_to_reg(nr
, simple_strtoul(buf
, NULL
, 10));
610 dev_warn(dev
, "store_fan_div: Unexpected nr seen: %d\n", nr
);
616 fan_div_reg
= w83791d_read(client
, W83791D_REG_FAN_DIV
[indx
])
618 tmp_fan_div
= (data
->fan_div
[nr
] << new_shift
) & ~keep_mask
;
620 w83791d_write(client
, W83791D_REG_FAN_DIV
[indx
],
621 fan_div_reg
| tmp_fan_div
);
623 /* Bit 2 of fans 0-2 is stored in the vbat register (bits 5-7) */
625 keep_mask
= ~(1 << (nr
+ 5));
626 vbat_reg
= w83791d_read(client
, W83791D_REG_VBAT
)
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
);
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
]);
640 mutex_unlock(&data
->update_lock
);
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),
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),
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),
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),
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),
695 /* read/write PWMs */
696 static ssize_t
show_pwm(struct device
*dev
, struct device_attribute
*attr
,
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
]);
705 static ssize_t
store_pwm(struct device
*dev
, struct device_attribute
*attr
,
706 const char *buf
, size_t count
)
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
;
714 if (strict_strtoul(buf
, 10, &val
))
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
);
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),
737 static ssize_t
show_pwmenable(struct device
*dev
, struct device_attribute
*attr
,
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);
746 static ssize_t
store_pwmenable(struct device
*dev
,
747 struct device_attribute
*attr
, const char *buf
, size_t count
)
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
;
759 int ret
= strict_strtoul(buf
, 10, &val
);
761 if (ret
|| val
< 1 || val
> 3)
764 mutex_lock(&data
->update_lock
);
765 data
->pwm_enable
[nr
] = val
- 1;
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
;
788 w83791d_write(client
, W83791D_REG_FAN_CFG
[reg_idx
], reg_cfg_tmp
);
789 mutex_unlock(&data
->update_lock
);
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),
802 /* For Smart Fan I / Thermal Cruise */
803 static ssize_t
show_temp_target(struct device
*dev
,
804 struct device_attribute
*attr
, char *buf
)
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
]));
812 static ssize_t
store_temp_target(struct device
*dev
,
813 struct device_attribute
*attr
, const char *buf
, size_t count
)
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
;
822 if (strict_strtoul(buf
, 10, &val
))
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
);
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),
844 static ssize_t
show_temp_tolerance(struct device
*dev
,
845 struct device_attribute
*attr
, char *buf
)
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
]));
853 static ssize_t
store_temp_tolerance(struct device
*dev
,
854 struct device_attribute
*attr
, const char *buf
, size_t count
)
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
;
866 if (strict_strtoul(buf
, 10, &val
))
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
);
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),
906 /* read/write the temperature1, includes measured value and limits */
907 static ssize_t
show_temp1(struct device
*dev
, struct device_attribute
*devattr
,
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
]));
915 static ssize_t
store_temp1(struct device
*dev
, struct device_attribute
*devattr
,
916 const char *buf
, size_t count
)
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
;
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
);
931 /* read/write temperature2-3, includes measured value and limits */
932 static ssize_t
show_temp23(struct device
*dev
, struct device_attribute
*devattr
,
935 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
936 struct w83791d_data
*data
= w83791d_update_device(dev
);
938 int index
= attr
->index
;
939 return sprintf(buf
, "%d\n", TEMP23_FROM_REG(data
->temp_add
[nr
][index
]));
942 static ssize_t
store_temp23(struct device
*dev
,
943 struct device_attribute
*devattr
,
944 const char *buf
, size_t count
)
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);
951 int index
= attr
->index
;
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
);
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),
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),
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),
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),
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),
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
)
1006 struct w83791d_data
*data
= w83791d_update_device(dev
);
1007 return sprintf(buf
, "%u\n", data
->alarms
);
1010 static DEVICE_ATTR(alarms
, S_IRUGO
, show_alarms_reg
, NULL
);
1014 #define GLOBAL_BEEP_ENABLE_SHIFT 15
1015 #define GLOBAL_BEEP_ENABLE_MASK (1 << GLOBAL_BEEP_ENABLE_SHIFT)
1017 static ssize_t
show_beep_enable(struct device
*dev
,
1018 struct device_attribute
*attr
, char *buf
)
1020 struct w83791d_data
*data
= w83791d_update_device(dev
);
1021 return sprintf(buf
, "%d\n", data
->beep_enable
);
1024 static ssize_t
show_beep_mask(struct device
*dev
,
1025 struct device_attribute
*attr
, char *buf
)
1027 struct w83791d_data
*data
= w83791d_update_device(dev
);
1028 return sprintf(buf
, "%d\n", BEEP_MASK_FROM_REG(data
->beep_mask
));
1032 static ssize_t
store_beep_mask(struct device
*dev
,
1033 struct device_attribute
*attr
,
1034 const char *buf
, size_t count
)
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);
1041 mutex_lock(&data
->update_lock
);
1043 /* The beep_enable state overrides any enabling request from
1045 data
->beep_mask
= BEEP_MASK_TO_REG(val
) & ~GLOBAL_BEEP_ENABLE_MASK
;
1046 data
->beep_mask
|= (data
->beep_enable
<< GLOBAL_BEEP_ENABLE_SHIFT
);
1048 val
= data
->beep_mask
;
1050 for (i
= 0; i
< 3; i
++) {
1051 w83791d_write(client
, W83791D_REG_BEEP_CTRL
[i
], (val
& 0xff));
1055 mutex_unlock(&data
->update_lock
);
1060 static ssize_t
store_beep_enable(struct device
*dev
,
1061 struct device_attribute
*attr
,
1062 const char *buf
, size_t count
)
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);
1068 mutex_lock(&data
->update_lock
);
1070 data
->beep_enable
= val
? 1 : 0;
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
);
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;
1080 w83791d_write(client
, W83791D_REG_BEEP_CTRL
[1], val
);
1082 mutex_unlock(&data
->update_lock
);
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)
1094 /* cpu voltage regulation information */
1095 static ssize_t
show_vid_reg(struct device
*dev
,
1096 struct device_attribute
*attr
, char *buf
)
1098 struct w83791d_data
*data
= w83791d_update_device(dev
);
1099 return sprintf(buf
, "%d\n", vid_from_reg(data
->vid
, data
->vrm
));
1102 static DEVICE_ATTR(cpu0_vid
, S_IRUGO
, show_vid_reg
, NULL
);
1104 static ssize_t
show_vrm_reg(struct device
*dev
,
1105 struct device_attribute
*attr
, char *buf
)
1107 struct w83791d_data
*data
= dev_get_drvdata(dev
);
1108 return sprintf(buf
, "%d\n", data
->vrm
);
1111 static ssize_t
store_vrm_reg(struct device
*dev
,
1112 struct device_attribute
*attr
,
1113 const char *buf
, size_t count
)
1115 struct w83791d_data
*data
= dev_get_drvdata(dev
);
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);
1125 static DEVICE_ATTR(vrm
, S_IRUGO
| S_IWUSR
, show_vrm_reg
, store_vrm_reg
);
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
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
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
1148 static struct attribute
*w83791d_attributes
[] = {
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
,
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
,
1185 static const struct attribute_group w83791d_group
= {
1186 .attrs
= w83791d_attributes
,
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
1192 static struct attribute
*w83791d_attributes_fanpwm45
[] = {
1195 &sda_pwm
[3].dev_attr
.attr
,
1196 &sda_pwm
[4].dev_attr
.attr
,
1200 static const struct attribute_group w83791d_group_fanpwm45
= {
1201 .attrs
= w83791d_attributes_fanpwm45
,
1204 static int w83791d_detect_subclients(struct i2c_client
*client
)
1206 struct i2c_adapter
*adapter
= client
->adapter
;
1207 struct w83791d_data
*data
= i2c_get_clientdata(client
);
1208 int address
= client
->addr
;
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
]);
1225 w83791d_write(client
, W83791D_REG_I2C_SUBADDR
,
1226 (force_subclients
[2] & 0x07) |
1227 ((force_subclients
[3] & 0x07) << 4));
1230 val
= w83791d_read(client
, W83791D_REG_I2C_SUBADDR
);
1231 if (!(val
& 0x08)) {
1232 data
->lm75
[0] = i2c_new_dummy(adapter
, 0x48 + (val
& 0x7));
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
);
1244 data
->lm75
[1] = i2c_new_dummy(adapter
,
1245 0x48 + ((val
>> 4) & 0x7));
1250 /* Undo inits in case of errors */
1253 if (data
->lm75
[0] != NULL
)
1254 i2c_unregister_device(data
->lm75
[0]);
1260 /* Return 0 if detection is successful, -ENODEV otherwise */
1261 static int w83791d_detect(struct i2c_client
*client
,
1262 struct i2c_board_info
*info
)
1264 struct i2c_adapter
*adapter
= client
->adapter
;
1266 unsigned short address
= client
->addr
;
1268 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
)) {
1272 if (w83791d_read(client
, W83791D_REG_CONFIG
) & 0x80)
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)) {
1284 /* If Winbond chip, address of chip and W83791D_REG_I2C_ADDR
1286 if (w83791d_read(client
, W83791D_REG_I2C_ADDR
) != address
)
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);
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)
1299 strlcpy(info
->type
, "w83791d", I2C_NAME_SIZE
);
1304 static int w83791d_probe(struct i2c_client
*client
,
1305 const struct i2c_device_id
*id
)
1307 struct w83791d_data
*data
;
1308 struct device
*dev
= &client
->dev
;
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
);
1319 data
= kzalloc(sizeof(struct w83791d_data
), GFP_KERNEL
);
1325 i2c_set_clientdata(client
, data
);
1326 mutex_init(&data
->update_lock
);
1328 err
= w83791d_detect_subclients(client
);
1332 /* Initialize the chip */
1333 w83791d_init_client(client
);
1335 /* If the fan_div is changed, make sure there is a rational
1337 for (i
= 0; i
< NUMBER_OF_FANIN
; i
++) {
1338 data
->fan_min
[i
] = w83791d_read(client
, W83791D_REG_FAN_MIN
[i
]);
1341 /* Register sysfs hooks */
1342 if ((err
= sysfs_create_group(&client
->dev
.kobj
, &w83791d_group
)))
1345 /* Check if pins of fan/pwm 4-5 are in use as GPIO */
1346 has_fanpwm45
= w83791d_read(client
, W83791D_REG_GPIO
) & 0x10;
1348 err
= sysfs_create_group(&client
->dev
.kobj
,
1349 &w83791d_group_fanpwm45
);
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
);
1365 sysfs_remove_group(&client
->dev
.kobj
, &w83791d_group_fanpwm45
);
1367 sysfs_remove_group(&client
->dev
.kobj
, &w83791d_group
);
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]);
1379 static int w83791d_remove(struct i2c_client
*client
)
1381 struct w83791d_data
*data
= i2c_get_clientdata(client
);
1383 hwmon_device_unregister(data
->hwmon_dev
);
1384 sysfs_remove_group(&client
->dev
.kobj
, &w83791d_group
);
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]);
1395 static void w83791d_init_client(struct i2c_client
*client
)
1397 struct w83791d_data
*data
= i2c_get_clientdata(client
);
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.
1414 if (reset
|| init
) {
1415 /* keep some BIOS settings when we... */
1416 old_beep
= w83791d_read(client
, W83791D_REG_BEEP_CONFIG
);
1419 /* ... reset the chip and ... */
1420 w83791d_write(client
, W83791D_REG_CONFIG
, 0x80);
1423 /* ... disable power-on abnormal beep */
1424 w83791d_write(client
, W83791D_REG_BEEP_CONFIG
, old_beep
| 0x80);
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);
1431 /* Make sure monitoring is turned on for add-ons */
1432 tmp
= w83791d_read(client
, W83791D_REG_TEMP2_CONFIG
);
1434 w83791d_write(client
, W83791D_REG_TEMP2_CONFIG
,
1438 tmp
= w83791d_read(client
, W83791D_REG_TEMP3_CONFIG
);
1440 w83791d_write(client
, W83791D_REG_TEMP3_CONFIG
,
1444 /* Start monitoring */
1445 tmp
= w83791d_read(client
, W83791D_REG_CONFIG
) & 0xf7;
1446 w83791d_write(client
, W83791D_REG_CONFIG
, tmp
| 0x01);
1450 data
->vrm
= vid_which_vrm();
1453 static struct w83791d_data
*w83791d_update_device(struct device
*dev
)
1455 struct i2c_client
*client
= to_i2c_client(dev
);
1456 struct w83791d_data
*data
= i2c_get_clientdata(client
);
1458 u8 reg_array_tmp
[3];
1461 mutex_lock(&data
->update_lock
);
1463 if (time_after(jiffies
, data
->last_updated
+ (HZ
* 3))
1465 dev_dbg(dev
, "Starting w83791d device update\n");
1467 /* Update the voltages measured value and limits */
1468 for (i
= 0; i
< NUMBER_OF_VIN
; i
++) {
1469 data
->in
[i
] = w83791d_read(client
,
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
]);
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
]);
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
]);
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;
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;
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
]);
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
]);
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;
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;
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
]);
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;
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
]);
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]);
1550 /* Update the realtime status */
1552 w83791d_read(client
, W83791D_REG_ALARM1
) +
1553 (w83791d_read(client
, W83791D_REG_ALARM2
) << 8) +
1554 (w83791d_read(client
, W83791D_REG_ALARM3
) << 16);
1556 /* Update the beep configuration information */
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);
1562 /* Extract global beep enable flag */
1564 (data
->beep_mask
>> GLOBAL_BEEP_ENABLE_SHIFT
) & 0x01;
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)
1572 data
->last_updated
= jiffies
;
1576 mutex_unlock(&data
->update_lock
);
1579 w83791d_print_debug(data
, dev
);
1586 static void w83791d_print_debug(struct w83791d_data
*data
, struct device
*dev
)
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
]);
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
]);
1604 /* temperature math is signed, but only print out the
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
]);
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
]);
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");
1628 static int __init
sensors_w83791d_init(void)
1630 return i2c_add_driver(&w83791d_driver
);
1633 static void __exit
sensors_w83791d_exit(void)
1635 i2c_del_driver(&w83791d_driver
);
1638 MODULE_AUTHOR("Charles Spirakis <bezaur@gmail.com>");
1639 MODULE_DESCRIPTION("W83791D driver");
1640 MODULE_LICENSE("GPL");
1642 module_init(sensors_w83791d_init
);
1643 module_exit(sensors_w83791d_exit
);