2 w83793.c - Linux kernel driver for hardware monitoring
3 Copyright (C) 2006 Winbond Electronics Corp.
5 Rudolf Marek <r.marek@assembler.cz>
6 Copyright (C) 2009-2010 Sven Anders <anders@anduras.de>, ANDURAS AG.
8 (Based partially on fschmd driver,
9 Copyright 2007-2008 by Hans de Goede)
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation - version 2.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
27 Supports following chips:
29 Chip #vin #fanin #pwm #temp wchipid vendid i2c ISA
30 w83793 10 12 8 6 0x7b 0x5ca3 yes no
33 #include <linux/module.h>
34 #include <linux/init.h>
35 #include <linux/slab.h>
36 #include <linux/i2c.h>
37 #include <linux/hwmon.h>
38 #include <linux/hwmon-vid.h>
39 #include <linux/hwmon-sysfs.h>
40 #include <linux/err.h>
41 #include <linux/mutex.h>
43 #include <linux/watchdog.h>
44 #include <linux/miscdevice.h>
45 #include <linux/uaccess.h>
46 #include <linux/kref.h>
47 #include <linux/notifier.h>
48 #include <linux/reboot.h>
51 #define WATCHDOG_TIMEOUT 2 /* 2 minute default timeout */
53 /* Addresses to scan */
54 static const unsigned short normal_i2c
[] = { 0x2c, 0x2d, 0x2e, 0x2f,
57 /* Insmod parameters */
59 static unsigned short force_subclients
[4];
60 module_param_array(force_subclients
, short, NULL
, 0);
61 MODULE_PARM_DESC(force_subclients
, "List of subclient addresses: "
62 "{bus, clientaddr, subclientaddr1, subclientaddr2}");
65 module_param(reset
, bool, 0);
66 MODULE_PARM_DESC(reset
, "Set to 1 to reset chip, not recommended");
68 static int timeout
= WATCHDOG_TIMEOUT
; /* default timeout in minutes */
69 module_param(timeout
, int, 0);
70 MODULE_PARM_DESC(timeout
,
71 "Watchdog timeout in minutes. 2<= timeout <=255 (default="
72 __MODULE_STRING(WATCHDOG_TIMEOUT
) ")");
74 static int nowayout
= WATCHDOG_NOWAYOUT
;
75 module_param(nowayout
, int, 0);
76 MODULE_PARM_DESC(nowayout
,
77 "Watchdog cannot be stopped once started (default="
78 __MODULE_STRING(WATCHDOG_NOWAYOUT
) ")");
81 Address 0x00, 0x0d, 0x0e, 0x0f in all three banks are reserved
82 as ID, Bank Select registers
84 #define W83793_REG_BANKSEL 0x00
85 #define W83793_REG_VENDORID 0x0d
86 #define W83793_REG_CHIPID 0x0e
87 #define W83793_REG_DEVICEID 0x0f
89 #define W83793_REG_CONFIG 0x40
90 #define W83793_REG_MFC 0x58
91 #define W83793_REG_FANIN_CTRL 0x5c
92 #define W83793_REG_FANIN_SEL 0x5d
93 #define W83793_REG_I2C_ADDR 0x0b
94 #define W83793_REG_I2C_SUBADDR 0x0c
95 #define W83793_REG_VID_INA 0x05
96 #define W83793_REG_VID_INB 0x06
97 #define W83793_REG_VID_LATCHA 0x07
98 #define W83793_REG_VID_LATCHB 0x08
99 #define W83793_REG_VID_CTRL 0x59
101 #define W83793_REG_WDT_LOCK 0x01
102 #define W83793_REG_WDT_ENABLE 0x02
103 #define W83793_REG_WDT_STATUS 0x03
104 #define W83793_REG_WDT_TIMEOUT 0x04
106 static u16 W83793_REG_TEMP_MODE
[2] = { 0x5e, 0x5f };
110 #define TEMP_CRIT_HYST 2
112 #define TEMP_WARN_HYST 4
113 /* only crit and crit_hyst affect real-time alarm status
114 current crit crit_hyst warn warn_hyst */
115 static u16 W83793_REG_TEMP
[][5] = {
116 {0x1c, 0x78, 0x79, 0x7a, 0x7b},
117 {0x1d, 0x7c, 0x7d, 0x7e, 0x7f},
118 {0x1e, 0x80, 0x81, 0x82, 0x83},
119 {0x1f, 0x84, 0x85, 0x86, 0x87},
120 {0x20, 0x88, 0x89, 0x8a, 0x8b},
121 {0x21, 0x8c, 0x8d, 0x8e, 0x8f},
124 #define W83793_REG_TEMP_LOW_BITS 0x22
126 #define W83793_REG_BEEP(index) (0x53 + (index))
127 #define W83793_REG_ALARM(index) (0x4b + (index))
129 #define W83793_REG_CLR_CHASSIS 0x4a /* SMI MASK4 */
130 #define W83793_REG_IRQ_CTRL 0x50
131 #define W83793_REG_OVT_CTRL 0x51
132 #define W83793_REG_OVT_BEEP 0x52
137 static const u16 W83793_REG_IN
[][3] = {
138 /* Current, High, Low */
139 {0x10, 0x60, 0x61}, /* Vcore A */
140 {0x11, 0x62, 0x63}, /* Vcore B */
141 {0x12, 0x64, 0x65}, /* Vtt */
142 {0x14, 0x6a, 0x6b}, /* VSEN1 */
143 {0x15, 0x6c, 0x6d}, /* VSEN2 */
144 {0x16, 0x6e, 0x6f}, /* +3VSEN */
145 {0x17, 0x70, 0x71}, /* +12VSEN */
146 {0x18, 0x72, 0x73}, /* 5VDD */
147 {0x19, 0x74, 0x75}, /* 5VSB */
148 {0x1a, 0x76, 0x77}, /* VBAT */
151 /* Low Bits of Vcore A/B Vtt Read/High/Low */
152 static const u16 W83793_REG_IN_LOW_BITS
[] = { 0x1b, 0x68, 0x69 };
153 static u8 scale_in
[] = { 2, 2, 2, 16, 16, 16, 8, 24, 24, 16 };
154 static u8 scale_in_add
[] = { 0, 0, 0, 0, 0, 0, 0, 150, 150, 0 };
156 #define W83793_REG_FAN(index) (0x23 + 2 * (index)) /* High byte */
157 #define W83793_REG_FAN_MIN(index) (0x90 + 2 * (index)) /* High byte */
159 #define W83793_REG_PWM_DEFAULT 0xb2
160 #define W83793_REG_PWM_ENABLE 0x207
161 #define W83793_REG_PWM_UPTIME 0xc3 /* Unit in 0.1 second */
162 #define W83793_REG_PWM_DOWNTIME 0xc4 /* Unit in 0.1 second */
163 #define W83793_REG_TEMP_CRITICAL 0xc5
167 #define PWM_NONSTOP 2
168 #define PWM_STOP_TIME 3
169 #define W83793_REG_PWM(index, nr) (((nr) == 0 ? 0xb3 : \
170 (nr) == 1 ? 0x220 : 0x218) + (index))
172 /* bit field, fan1 is bit0, fan2 is bit1 ... */
173 #define W83793_REG_TEMP_FAN_MAP(index) (0x201 + (index))
174 #define W83793_REG_TEMP_TOL(index) (0x208 + (index))
175 #define W83793_REG_TEMP_CRUISE(index) (0x210 + (index))
176 #define W83793_REG_PWM_STOP_TIME(index) (0x228 + (index))
177 #define W83793_REG_SF2_TEMP(index, nr) (0x230 + ((index) << 4) + (nr))
178 #define W83793_REG_SF2_PWM(index, nr) (0x238 + ((index) << 4) + (nr))
180 static inline unsigned long FAN_FROM_REG(u16 val
)
182 if ((val
>= 0xfff) || (val
== 0))
184 return (1350000UL / val
);
187 static inline u16
FAN_TO_REG(long rpm
)
191 return SENSORS_LIMIT((1350000 + (rpm
>> 1)) / rpm
, 1, 0xffe);
194 static inline unsigned long TIME_FROM_REG(u8 reg
)
199 static inline u8
TIME_TO_REG(unsigned long val
)
201 return SENSORS_LIMIT((val
+ 50) / 100, 0, 0xff);
204 static inline long TEMP_FROM_REG(s8 reg
)
209 static inline s8
TEMP_TO_REG(long val
, s8 min
, s8 max
)
211 return SENSORS_LIMIT((val
+ (val
< 0 ? -500 : 500)) / 1000, min
, max
);
215 struct i2c_client
*lm75
[2];
216 struct device
*hwmon_dev
;
217 struct mutex update_lock
;
218 char valid
; /* !=0 if following fields are valid */
219 unsigned long last_updated
; /* In jiffies */
220 unsigned long last_nonvolatile
; /* In jiffies, last time we update the
221 nonvolatile registers */
226 u8 in
[10][3]; /* Register value, read/high/low */
227 u8 in_low_bits
[3]; /* Additional resolution for VCore A/B Vtt */
229 u16 has_fan
; /* Only fan1- fan5 has own pins */
230 u16 fan
[12]; /* Register value combine */
231 u16 fan_min
[12]; /* Register value combine */
233 s8 temp
[6][5]; /* current, crit, crit_hyst,warn, warn_hyst */
234 u8 temp_low_bits
; /* Additional resolution TD1-TD4 */
235 u8 temp_mode
[2]; /* byte 0: Temp D1-D4 mode each has 2 bits
236 byte 1: Temp R1,R2 mode, each has 1 bit */
237 u8 temp_critical
; /* If reached all fan will be at full speed */
238 u8 temp_fan_map
[6]; /* Temp controls which pwm fan, bit field */
243 u8 pwm_enable
; /* Register value, each Temp has 1 bit */
244 u8 pwm_uptime
; /* Register value */
245 u8 pwm_downtime
; /* Register value */
246 u8 pwm_default
; /* All fan default pwm, next poweron valid */
247 u8 pwm
[8][3]; /* Register value */
251 u8 alarms
[5]; /* realtime status registers */
254 u8 tolerance
[3]; /* Temp tolerance(Smart Fan I/II) */
255 u8 sf2_pwm
[6][7]; /* Smart FanII: Fan duty cycle */
256 u8 sf2_temp
[6][7]; /* Smart FanII: Temp level point */
259 struct i2c_client
*client
;
260 struct mutex watchdog_lock
;
261 struct list_head list
; /* member of the watchdog_data_list */
263 struct miscdevice watchdog_miscdev
;
264 unsigned long watchdog_is_open
;
265 char watchdog_expect_close
;
266 char watchdog_name
[10]; /* must be unique to avoid sysfs conflict */
267 unsigned int watchdog_caused_reboot
;
268 int watchdog_timeout
; /* watchdog timeout in minutes */
271 /* Somewhat ugly :( global data pointer list with all devices, so that
272 we can find our device data as when using misc_register. There is no
273 other method to get to one's device data from the open file-op and
274 for usage in the reboot notifier callback. */
275 static LIST_HEAD(watchdog_data_list
);
277 /* Note this lock not only protect list access, but also data.kref access */
278 static DEFINE_MUTEX(watchdog_data_mutex
);
280 /* Release our data struct when we're detached from the i2c client *and* all
281 references to our watchdog device are released */
282 static void w83793_release_resources(struct kref
*ref
)
284 struct w83793_data
*data
= container_of(ref
, struct w83793_data
, kref
);
288 static u8
w83793_read_value(struct i2c_client
*client
, u16 reg
);
289 static int w83793_write_value(struct i2c_client
*client
, u16 reg
, u8 value
);
290 static int w83793_probe(struct i2c_client
*client
,
291 const struct i2c_device_id
*id
);
292 static int w83793_detect(struct i2c_client
*client
,
293 struct i2c_board_info
*info
);
294 static int w83793_remove(struct i2c_client
*client
);
295 static void w83793_init_client(struct i2c_client
*client
);
296 static void w83793_update_nonvolatile(struct device
*dev
);
297 static struct w83793_data
*w83793_update_device(struct device
*dev
);
299 static const struct i2c_device_id w83793_id
[] = {
303 MODULE_DEVICE_TABLE(i2c
, w83793_id
);
305 static struct i2c_driver w83793_driver
= {
306 .class = I2C_CLASS_HWMON
,
310 .probe
= w83793_probe
,
311 .remove
= w83793_remove
,
312 .id_table
= w83793_id
,
313 .detect
= w83793_detect
,
314 .address_list
= normal_i2c
,
318 show_vrm(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
320 struct w83793_data
*data
= dev_get_drvdata(dev
);
321 return sprintf(buf
, "%d\n", data
->vrm
);
325 show_vid(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
327 struct w83793_data
*data
= w83793_update_device(dev
);
328 struct sensor_device_attribute_2
*sensor_attr
=
329 to_sensor_dev_attr_2(attr
);
330 int index
= sensor_attr
->index
;
332 return sprintf(buf
, "%d\n", vid_from_reg(data
->vid
[index
], data
->vrm
));
336 store_vrm(struct device
*dev
, struct device_attribute
*attr
,
337 const char *buf
, size_t count
)
339 struct w83793_data
*data
= dev_get_drvdata(dev
);
340 data
->vrm
= simple_strtoul(buf
, NULL
, 10);
344 #define ALARM_STATUS 0
345 #define BEEP_ENABLE 1
347 show_alarm_beep(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
349 struct w83793_data
*data
= w83793_update_device(dev
);
350 struct sensor_device_attribute_2
*sensor_attr
=
351 to_sensor_dev_attr_2(attr
);
352 int nr
= sensor_attr
->nr
;
353 int index
= sensor_attr
->index
>> 3;
354 int bit
= sensor_attr
->index
& 0x07;
357 if (ALARM_STATUS
== nr
) {
358 val
= (data
->alarms
[index
] >> (bit
)) & 1;
359 } else { /* BEEP_ENABLE */
360 val
= (data
->beeps
[index
] >> (bit
)) & 1;
363 return sprintf(buf
, "%u\n", val
);
367 store_beep(struct device
*dev
, struct device_attribute
*attr
,
368 const char *buf
, size_t count
)
370 struct i2c_client
*client
= to_i2c_client(dev
);
371 struct w83793_data
*data
= i2c_get_clientdata(client
);
372 struct sensor_device_attribute_2
*sensor_attr
=
373 to_sensor_dev_attr_2(attr
);
374 int index
= sensor_attr
->index
>> 3;
375 int shift
= sensor_attr
->index
& 0x07;
376 u8 beep_bit
= 1 << shift
;
379 val
= simple_strtoul(buf
, NULL
, 10);
380 if (val
!= 0 && val
!= 1)
383 mutex_lock(&data
->update_lock
);
384 data
->beeps
[index
] = w83793_read_value(client
, W83793_REG_BEEP(index
));
385 data
->beeps
[index
] &= ~beep_bit
;
386 data
->beeps
[index
] |= val
<< shift
;
387 w83793_write_value(client
, W83793_REG_BEEP(index
), data
->beeps
[index
]);
388 mutex_unlock(&data
->update_lock
);
394 show_beep_enable(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
396 struct w83793_data
*data
= w83793_update_device(dev
);
397 return sprintf(buf
, "%u\n", (data
->beep_enable
>> 1) & 0x01);
401 store_beep_enable(struct device
*dev
, struct device_attribute
*attr
,
402 const char *buf
, size_t count
)
404 struct i2c_client
*client
= to_i2c_client(dev
);
405 struct w83793_data
*data
= i2c_get_clientdata(client
);
406 u8 val
= simple_strtoul(buf
, NULL
, 10);
408 if (val
!= 0 && val
!= 1)
411 mutex_lock(&data
->update_lock
);
412 data
->beep_enable
= w83793_read_value(client
, W83793_REG_OVT_BEEP
)
414 data
->beep_enable
|= val
<< 1;
415 w83793_write_value(client
, W83793_REG_OVT_BEEP
, data
->beep_enable
);
416 mutex_unlock(&data
->update_lock
);
421 /* Write any value to clear chassis alarm */
423 store_chassis_clear_legacy(struct device
*dev
,
424 struct device_attribute
*attr
, const char *buf
,
427 struct i2c_client
*client
= to_i2c_client(dev
);
428 struct w83793_data
*data
= i2c_get_clientdata(client
);
431 dev_warn(dev
, "Attribute chassis is deprecated, "
432 "use intrusion0_alarm instead\n");
434 mutex_lock(&data
->update_lock
);
435 val
= w83793_read_value(client
, W83793_REG_CLR_CHASSIS
);
437 w83793_write_value(client
, W83793_REG_CLR_CHASSIS
, val
);
438 mutex_unlock(&data
->update_lock
);
442 /* Write 0 to clear chassis alarm */
444 store_chassis_clear(struct device
*dev
,
445 struct device_attribute
*attr
, const char *buf
,
448 struct i2c_client
*client
= to_i2c_client(dev
);
449 struct w83793_data
*data
= i2c_get_clientdata(client
);
453 if (strict_strtoul(buf
, 10, &val
) || val
!= 0)
456 mutex_lock(&data
->update_lock
);
457 reg
= w83793_read_value(client
, W83793_REG_CLR_CHASSIS
);
458 w83793_write_value(client
, W83793_REG_CLR_CHASSIS
, reg
| 0x80);
459 data
->valid
= 0; /* Force cache refresh */
460 mutex_unlock(&data
->update_lock
);
467 show_fan(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
469 struct sensor_device_attribute_2
*sensor_attr
=
470 to_sensor_dev_attr_2(attr
);
471 int nr
= sensor_attr
->nr
;
472 int index
= sensor_attr
->index
;
473 struct w83793_data
*data
= w83793_update_device(dev
);
476 if (FAN_INPUT
== nr
) {
477 val
= data
->fan
[index
] & 0x0fff;
479 val
= data
->fan_min
[index
] & 0x0fff;
482 return sprintf(buf
, "%lu\n", FAN_FROM_REG(val
));
486 store_fan_min(struct device
*dev
, struct device_attribute
*attr
,
487 const char *buf
, size_t count
)
489 struct sensor_device_attribute_2
*sensor_attr
=
490 to_sensor_dev_attr_2(attr
);
491 int index
= sensor_attr
->index
;
492 struct i2c_client
*client
= to_i2c_client(dev
);
493 struct w83793_data
*data
= i2c_get_clientdata(client
);
494 u16 val
= FAN_TO_REG(simple_strtoul(buf
, NULL
, 10));
496 mutex_lock(&data
->update_lock
);
497 data
->fan_min
[index
] = val
;
498 w83793_write_value(client
, W83793_REG_FAN_MIN(index
),
500 w83793_write_value(client
, W83793_REG_FAN_MIN(index
) + 1, val
& 0xff);
501 mutex_unlock(&data
->update_lock
);
507 show_pwm(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
509 struct sensor_device_attribute_2
*sensor_attr
=
510 to_sensor_dev_attr_2(attr
);
511 struct w83793_data
*data
= w83793_update_device(dev
);
513 int nr
= sensor_attr
->nr
;
514 int index
= sensor_attr
->index
;
516 if (PWM_STOP_TIME
== nr
)
517 val
= TIME_FROM_REG(data
->pwm_stop_time
[index
]);
519 val
= (data
->pwm
[index
][nr
] & 0x3f) << 2;
521 return sprintf(buf
, "%d\n", val
);
525 store_pwm(struct device
*dev
, struct device_attribute
*attr
,
526 const char *buf
, size_t count
)
528 struct i2c_client
*client
= to_i2c_client(dev
);
529 struct w83793_data
*data
= i2c_get_clientdata(client
);
530 struct sensor_device_attribute_2
*sensor_attr
=
531 to_sensor_dev_attr_2(attr
);
532 int nr
= sensor_attr
->nr
;
533 int index
= sensor_attr
->index
;
536 mutex_lock(&data
->update_lock
);
537 if (PWM_STOP_TIME
== nr
) {
538 val
= TIME_TO_REG(simple_strtoul(buf
, NULL
, 10));
539 data
->pwm_stop_time
[index
] = val
;
540 w83793_write_value(client
, W83793_REG_PWM_STOP_TIME(index
),
543 val
= SENSORS_LIMIT(simple_strtoul(buf
, NULL
, 10), 0, 0xff)
545 data
->pwm
[index
][nr
] =
546 w83793_read_value(client
, W83793_REG_PWM(index
, nr
)) & 0xc0;
547 data
->pwm
[index
][nr
] |= val
;
548 w83793_write_value(client
, W83793_REG_PWM(index
, nr
),
549 data
->pwm
[index
][nr
]);
552 mutex_unlock(&data
->update_lock
);
557 show_temp(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
559 struct sensor_device_attribute_2
*sensor_attr
=
560 to_sensor_dev_attr_2(attr
);
561 int nr
= sensor_attr
->nr
;
562 int index
= sensor_attr
->index
;
563 struct w83793_data
*data
= w83793_update_device(dev
);
564 long temp
= TEMP_FROM_REG(data
->temp
[index
][nr
]);
566 if (TEMP_READ
== nr
&& index
< 4) { /* Only TD1-TD4 have low bits */
567 int low
= ((data
->temp_low_bits
>> (index
* 2)) & 0x03) * 250;
568 temp
+= temp
> 0 ? low
: -low
;
570 return sprintf(buf
, "%ld\n", temp
);
574 store_temp(struct device
*dev
, struct device_attribute
*attr
,
575 const char *buf
, size_t count
)
577 struct sensor_device_attribute_2
*sensor_attr
=
578 to_sensor_dev_attr_2(attr
);
579 int nr
= sensor_attr
->nr
;
580 int index
= sensor_attr
->index
;
581 struct i2c_client
*client
= to_i2c_client(dev
);
582 struct w83793_data
*data
= i2c_get_clientdata(client
);
583 long tmp
= simple_strtol(buf
, NULL
, 10);
585 mutex_lock(&data
->update_lock
);
586 data
->temp
[index
][nr
] = TEMP_TO_REG(tmp
, -128, 127);
587 w83793_write_value(client
, W83793_REG_TEMP
[index
][nr
],
588 data
->temp
[index
][nr
]);
589 mutex_unlock(&data
->update_lock
);
595 each has 4 mode:(2 bits)
597 1: Use internal temp sensor(default)
599 3: Use sensor in Intel CPU and get result by PECI
602 each has 2 mode:(1 bit)
603 0: Disable temp sensor monitor
604 1: To enable temp sensors monitor
607 /* 0 disable, 6 PECI */
608 static u8 TO_TEMP_MODE
[] = { 0, 0, 0, 6 };
611 show_temp_mode(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
613 struct w83793_data
*data
= w83793_update_device(dev
);
614 struct sensor_device_attribute_2
*sensor_attr
=
615 to_sensor_dev_attr_2(attr
);
616 int index
= sensor_attr
->index
;
617 u8 mask
= (index
< 4) ? 0x03 : 0x01;
618 u8 shift
= (index
< 4) ? (2 * index
) : (index
- 4);
620 index
= (index
< 4) ? 0 : 1;
622 tmp
= (data
->temp_mode
[index
] >> shift
) & mask
;
624 /* for the internal sensor, found out if diode or thermistor */
626 tmp
= index
== 0 ? 3 : 4;
628 tmp
= TO_TEMP_MODE
[tmp
];
631 return sprintf(buf
, "%d\n", tmp
);
635 store_temp_mode(struct device
*dev
, struct device_attribute
*attr
,
636 const char *buf
, size_t count
)
638 struct i2c_client
*client
= to_i2c_client(dev
);
639 struct w83793_data
*data
= i2c_get_clientdata(client
);
640 struct sensor_device_attribute_2
*sensor_attr
=
641 to_sensor_dev_attr_2(attr
);
642 int index
= sensor_attr
->index
;
643 u8 mask
= (index
< 4) ? 0x03 : 0x01;
644 u8 shift
= (index
< 4) ? (2 * index
) : (index
- 4);
645 u8 val
= simple_strtoul(buf
, NULL
, 10);
647 /* transform the sysfs interface values into table above */
648 if ((val
== 6) && (index
< 4)) {
650 } else if ((val
== 3 && index
< 4)
651 || (val
== 4 && index
>= 4)) {
652 /* transform diode or thermistor into internal enable */
658 index
= (index
< 4) ? 0 : 1;
659 mutex_lock(&data
->update_lock
);
660 data
->temp_mode
[index
] =
661 w83793_read_value(client
, W83793_REG_TEMP_MODE
[index
]);
662 data
->temp_mode
[index
] &= ~(mask
<< shift
);
663 data
->temp_mode
[index
] |= val
<< shift
;
664 w83793_write_value(client
, W83793_REG_TEMP_MODE
[index
],
665 data
->temp_mode
[index
]);
666 mutex_unlock(&data
->update_lock
);
671 #define SETUP_PWM_DEFAULT 0
672 #define SETUP_PWM_UPTIME 1 /* Unit in 0.1s */
673 #define SETUP_PWM_DOWNTIME 2 /* Unit in 0.1s */
674 #define SETUP_TEMP_CRITICAL 3
676 show_sf_setup(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
678 struct sensor_device_attribute_2
*sensor_attr
=
679 to_sensor_dev_attr_2(attr
);
680 int nr
= sensor_attr
->nr
;
681 struct w83793_data
*data
= w83793_update_device(dev
);
684 if (SETUP_PWM_DEFAULT
== nr
) {
685 val
= (data
->pwm_default
& 0x3f) << 2;
686 } else if (SETUP_PWM_UPTIME
== nr
) {
687 val
= TIME_FROM_REG(data
->pwm_uptime
);
688 } else if (SETUP_PWM_DOWNTIME
== nr
) {
689 val
= TIME_FROM_REG(data
->pwm_downtime
);
690 } else if (SETUP_TEMP_CRITICAL
== nr
) {
691 val
= TEMP_FROM_REG(data
->temp_critical
& 0x7f);
694 return sprintf(buf
, "%d\n", val
);
698 store_sf_setup(struct device
*dev
, struct device_attribute
*attr
,
699 const char *buf
, size_t count
)
701 struct sensor_device_attribute_2
*sensor_attr
=
702 to_sensor_dev_attr_2(attr
);
703 int nr
= sensor_attr
->nr
;
704 struct i2c_client
*client
= to_i2c_client(dev
);
705 struct w83793_data
*data
= i2c_get_clientdata(client
);
707 mutex_lock(&data
->update_lock
);
708 if (SETUP_PWM_DEFAULT
== nr
) {
710 w83793_read_value(client
, W83793_REG_PWM_DEFAULT
) & 0xc0;
711 data
->pwm_default
|= SENSORS_LIMIT(simple_strtoul(buf
, NULL
,
714 w83793_write_value(client
, W83793_REG_PWM_DEFAULT
,
716 } else if (SETUP_PWM_UPTIME
== nr
) {
717 data
->pwm_uptime
= TIME_TO_REG(simple_strtoul(buf
, NULL
, 10));
718 data
->pwm_uptime
+= data
->pwm_uptime
== 0 ? 1 : 0;
719 w83793_write_value(client
, W83793_REG_PWM_UPTIME
,
721 } else if (SETUP_PWM_DOWNTIME
== nr
) {
722 data
->pwm_downtime
= TIME_TO_REG(simple_strtoul(buf
, NULL
, 10));
723 data
->pwm_downtime
+= data
->pwm_downtime
== 0 ? 1 : 0;
724 w83793_write_value(client
, W83793_REG_PWM_DOWNTIME
,
726 } else { /* SETUP_TEMP_CRITICAL */
727 data
->temp_critical
=
728 w83793_read_value(client
, W83793_REG_TEMP_CRITICAL
) & 0x80;
729 data
->temp_critical
|= TEMP_TO_REG(simple_strtol(buf
, NULL
, 10),
731 w83793_write_value(client
, W83793_REG_TEMP_CRITICAL
,
732 data
->temp_critical
);
735 mutex_unlock(&data
->update_lock
);
740 Temp SmartFan control
742 Temp channel control which pwm fan, bitfield, bit 0 indicate pwm1...
743 It's possible two or more temp channels control the same fan, w83793
744 always prefers to pick the most critical request and applies it to
746 It's possible one fan is not in any mapping of 6 temp channels, this
747 means the fan is manual mode
750 Each temp channel has its own SmartFan mode, and temp channel
751 control fans that are set by TEMP_FAN_MAP
753 1: Thermal Cruise Mode
756 Target temperature in thermal cruise mode, w83793 will try to turn
757 fan speed to keep the temperature of target device around this
761 If Temp higher or lower than target with this tolerance, w83793
762 will take actions to speed up or slow down the fan to keep the
763 temperature within the tolerance range.
766 #define TEMP_FAN_MAP 0
767 #define TEMP_PWM_ENABLE 1
768 #define TEMP_CRUISE 2
769 #define TEMP_TOLERANCE 3
771 show_sf_ctrl(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
773 struct sensor_device_attribute_2
*sensor_attr
=
774 to_sensor_dev_attr_2(attr
);
775 int nr
= sensor_attr
->nr
;
776 int index
= sensor_attr
->index
;
777 struct w83793_data
*data
= w83793_update_device(dev
);
780 if (TEMP_FAN_MAP
== nr
) {
781 val
= data
->temp_fan_map
[index
];
782 } else if (TEMP_PWM_ENABLE
== nr
) {
783 /* +2 to transfrom into 2 and 3 to conform with sysfs intf */
784 val
= ((data
->pwm_enable
>> index
) & 0x01) + 2;
785 } else if (TEMP_CRUISE
== nr
) {
786 val
= TEMP_FROM_REG(data
->temp_cruise
[index
] & 0x7f);
787 } else { /* TEMP_TOLERANCE */
788 val
= data
->tolerance
[index
>> 1] >> ((index
& 0x01) ? 4 : 0);
789 val
= TEMP_FROM_REG(val
& 0x0f);
791 return sprintf(buf
, "%d\n", val
);
795 store_sf_ctrl(struct device
*dev
, struct device_attribute
*attr
,
796 const char *buf
, size_t count
)
798 struct sensor_device_attribute_2
*sensor_attr
=
799 to_sensor_dev_attr_2(attr
);
800 int nr
= sensor_attr
->nr
;
801 int index
= sensor_attr
->index
;
802 struct i2c_client
*client
= to_i2c_client(dev
);
803 struct w83793_data
*data
= i2c_get_clientdata(client
);
806 mutex_lock(&data
->update_lock
);
807 if (TEMP_FAN_MAP
== nr
) {
808 val
= simple_strtoul(buf
, NULL
, 10) & 0xff;
809 w83793_write_value(client
, W83793_REG_TEMP_FAN_MAP(index
), val
);
810 data
->temp_fan_map
[index
] = val
;
811 } else if (TEMP_PWM_ENABLE
== nr
) {
812 val
= simple_strtoul(buf
, NULL
, 10);
813 if (2 == val
|| 3 == val
) {
815 w83793_read_value(client
, W83793_REG_PWM_ENABLE
);
817 data
->pwm_enable
|= 1 << index
;
819 data
->pwm_enable
&= ~(1 << index
);
820 w83793_write_value(client
, W83793_REG_PWM_ENABLE
,
823 mutex_unlock(&data
->update_lock
);
826 } else if (TEMP_CRUISE
== nr
) {
827 data
->temp_cruise
[index
] =
828 w83793_read_value(client
, W83793_REG_TEMP_CRUISE(index
));
829 val
= TEMP_TO_REG(simple_strtol(buf
, NULL
, 10), 0, 0x7f);
830 data
->temp_cruise
[index
] &= 0x80;
831 data
->temp_cruise
[index
] |= val
;
833 w83793_write_value(client
, W83793_REG_TEMP_CRUISE(index
),
834 data
->temp_cruise
[index
]);
835 } else { /* TEMP_TOLERANCE */
837 u8 shift
= (index
& 0x01) ? 4 : 0;
839 w83793_read_value(client
, W83793_REG_TEMP_TOL(i
));
841 val
= TEMP_TO_REG(simple_strtol(buf
, NULL
, 10), 0, 0x0f);
842 data
->tolerance
[i
] &= ~(0x0f << shift
);
843 data
->tolerance
[i
] |= val
<< shift
;
844 w83793_write_value(client
, W83793_REG_TEMP_TOL(i
),
848 mutex_unlock(&data
->update_lock
);
853 show_sf2_pwm(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
855 struct sensor_device_attribute_2
*sensor_attr
=
856 to_sensor_dev_attr_2(attr
);
857 int nr
= sensor_attr
->nr
;
858 int index
= sensor_attr
->index
;
859 struct w83793_data
*data
= w83793_update_device(dev
);
861 return sprintf(buf
, "%d\n", (data
->sf2_pwm
[index
][nr
] & 0x3f) << 2);
865 store_sf2_pwm(struct device
*dev
, struct device_attribute
*attr
,
866 const char *buf
, size_t count
)
868 struct i2c_client
*client
= to_i2c_client(dev
);
869 struct w83793_data
*data
= i2c_get_clientdata(client
);
870 struct sensor_device_attribute_2
*sensor_attr
=
871 to_sensor_dev_attr_2(attr
);
872 int nr
= sensor_attr
->nr
;
873 int index
= sensor_attr
->index
;
874 u8 val
= SENSORS_LIMIT(simple_strtoul(buf
, NULL
, 10), 0, 0xff) >> 2;
876 mutex_lock(&data
->update_lock
);
877 data
->sf2_pwm
[index
][nr
] =
878 w83793_read_value(client
, W83793_REG_SF2_PWM(index
, nr
)) & 0xc0;
879 data
->sf2_pwm
[index
][nr
] |= val
;
880 w83793_write_value(client
, W83793_REG_SF2_PWM(index
, nr
),
881 data
->sf2_pwm
[index
][nr
]);
882 mutex_unlock(&data
->update_lock
);
887 show_sf2_temp(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
889 struct sensor_device_attribute_2
*sensor_attr
=
890 to_sensor_dev_attr_2(attr
);
891 int nr
= sensor_attr
->nr
;
892 int index
= sensor_attr
->index
;
893 struct w83793_data
*data
= w83793_update_device(dev
);
895 return sprintf(buf
, "%ld\n",
896 TEMP_FROM_REG(data
->sf2_temp
[index
][nr
] & 0x7f));
900 store_sf2_temp(struct device
*dev
, struct device_attribute
*attr
,
901 const char *buf
, size_t count
)
903 struct i2c_client
*client
= to_i2c_client(dev
);
904 struct w83793_data
*data
= i2c_get_clientdata(client
);
905 struct sensor_device_attribute_2
*sensor_attr
=
906 to_sensor_dev_attr_2(attr
);
907 int nr
= sensor_attr
->nr
;
908 int index
= sensor_attr
->index
;
909 u8 val
= TEMP_TO_REG(simple_strtol(buf
, NULL
, 10), 0, 0x7f);
911 mutex_lock(&data
->update_lock
);
912 data
->sf2_temp
[index
][nr
] =
913 w83793_read_value(client
, W83793_REG_SF2_TEMP(index
, nr
)) & 0x80;
914 data
->sf2_temp
[index
][nr
] |= val
;
915 w83793_write_value(client
, W83793_REG_SF2_TEMP(index
, nr
),
916 data
->sf2_temp
[index
][nr
]);
917 mutex_unlock(&data
->update_lock
);
921 /* only Vcore A/B and Vtt have additional 2 bits precision */
923 show_in(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
925 struct sensor_device_attribute_2
*sensor_attr
=
926 to_sensor_dev_attr_2(attr
);
927 int nr
= sensor_attr
->nr
;
928 int index
= sensor_attr
->index
;
929 struct w83793_data
*data
= w83793_update_device(dev
);
930 u16 val
= data
->in
[index
][nr
];
934 val
+= (data
->in_low_bits
[nr
] >> (index
* 2)) & 0x3;
936 /* voltage inputs 5VDD and 5VSB needs 150mV offset */
937 val
= val
* scale_in
[index
] + scale_in_add
[index
];
938 return sprintf(buf
, "%d\n", val
);
942 store_in(struct device
*dev
, struct device_attribute
*attr
,
943 const char *buf
, size_t count
)
945 struct sensor_device_attribute_2
*sensor_attr
=
946 to_sensor_dev_attr_2(attr
);
947 int nr
= sensor_attr
->nr
;
948 int index
= sensor_attr
->index
;
949 struct i2c_client
*client
= to_i2c_client(dev
);
950 struct w83793_data
*data
= i2c_get_clientdata(client
);
954 (simple_strtoul(buf
, NULL
, 10) +
955 scale_in
[index
] / 2) / scale_in
[index
];
956 mutex_lock(&data
->update_lock
);
958 /* fix the limit values of 5VDD and 5VSB to ALARM mechanism */
959 if (1 == nr
|| 2 == nr
) {
960 val
-= scale_in_add
[index
] / scale_in
[index
];
962 val
= SENSORS_LIMIT(val
, 0, 255);
964 val
= SENSORS_LIMIT(val
, 0, 0x3FF);
965 data
->in_low_bits
[nr
] =
966 w83793_read_value(client
, W83793_REG_IN_LOW_BITS
[nr
]);
967 data
->in_low_bits
[nr
] &= ~(0x03 << (2 * index
));
968 data
->in_low_bits
[nr
] |= (val
& 0x03) << (2 * index
);
969 w83793_write_value(client
, W83793_REG_IN_LOW_BITS
[nr
],
970 data
->in_low_bits
[nr
]);
973 data
->in
[index
][nr
] = val
;
974 w83793_write_value(client
, W83793_REG_IN
[index
][nr
],
975 data
->in
[index
][nr
]);
976 mutex_unlock(&data
->update_lock
);
982 #define SENSOR_ATTR_IN(index) \
983 SENSOR_ATTR_2(in##index##_input, S_IRUGO, show_in, NULL, \
985 SENSOR_ATTR_2(in##index##_max, S_IRUGO | S_IWUSR, show_in, \
986 store_in, IN_MAX, index), \
987 SENSOR_ATTR_2(in##index##_min, S_IRUGO | S_IWUSR, show_in, \
988 store_in, IN_LOW, index), \
989 SENSOR_ATTR_2(in##index##_alarm, S_IRUGO, show_alarm_beep, \
990 NULL, ALARM_STATUS, index + ((index > 2) ? 1 : 0)), \
991 SENSOR_ATTR_2(in##index##_beep, S_IWUSR | S_IRUGO, \
992 show_alarm_beep, store_beep, BEEP_ENABLE, \
993 index + ((index > 2) ? 1 : 0))
995 #define SENSOR_ATTR_FAN(index) \
996 SENSOR_ATTR_2(fan##index##_alarm, S_IRUGO, show_alarm_beep, \
997 NULL, ALARM_STATUS, index + 17), \
998 SENSOR_ATTR_2(fan##index##_beep, S_IWUSR | S_IRUGO, \
999 show_alarm_beep, store_beep, BEEP_ENABLE, index + 17), \
1000 SENSOR_ATTR_2(fan##index##_input, S_IRUGO, show_fan, \
1001 NULL, FAN_INPUT, index - 1), \
1002 SENSOR_ATTR_2(fan##index##_min, S_IWUSR | S_IRUGO, \
1003 show_fan, store_fan_min, FAN_MIN, index - 1)
1005 #define SENSOR_ATTR_PWM(index) \
1006 SENSOR_ATTR_2(pwm##index, S_IWUSR | S_IRUGO, show_pwm, \
1007 store_pwm, PWM_DUTY, index - 1), \
1008 SENSOR_ATTR_2(pwm##index##_nonstop, S_IWUSR | S_IRUGO, \
1009 show_pwm, store_pwm, PWM_NONSTOP, index - 1), \
1010 SENSOR_ATTR_2(pwm##index##_start, S_IWUSR | S_IRUGO, \
1011 show_pwm, store_pwm, PWM_START, index - 1), \
1012 SENSOR_ATTR_2(pwm##index##_stop_time, S_IWUSR | S_IRUGO, \
1013 show_pwm, store_pwm, PWM_STOP_TIME, index - 1)
1015 #define SENSOR_ATTR_TEMP(index) \
1016 SENSOR_ATTR_2(temp##index##_type, S_IRUGO | S_IWUSR, \
1017 show_temp_mode, store_temp_mode, NOT_USED, index - 1), \
1018 SENSOR_ATTR_2(temp##index##_input, S_IRUGO, show_temp, \
1019 NULL, TEMP_READ, index - 1), \
1020 SENSOR_ATTR_2(temp##index##_max, S_IRUGO | S_IWUSR, show_temp, \
1021 store_temp, TEMP_CRIT, index - 1), \
1022 SENSOR_ATTR_2(temp##index##_max_hyst, S_IRUGO | S_IWUSR, \
1023 show_temp, store_temp, TEMP_CRIT_HYST, index - 1), \
1024 SENSOR_ATTR_2(temp##index##_warn, S_IRUGO | S_IWUSR, show_temp, \
1025 store_temp, TEMP_WARN, index - 1), \
1026 SENSOR_ATTR_2(temp##index##_warn_hyst, S_IRUGO | S_IWUSR, \
1027 show_temp, store_temp, TEMP_WARN_HYST, index - 1), \
1028 SENSOR_ATTR_2(temp##index##_alarm, S_IRUGO, \
1029 show_alarm_beep, NULL, ALARM_STATUS, index + 11), \
1030 SENSOR_ATTR_2(temp##index##_beep, S_IWUSR | S_IRUGO, \
1031 show_alarm_beep, store_beep, BEEP_ENABLE, index + 11), \
1032 SENSOR_ATTR_2(temp##index##_auto_channels_pwm, \
1033 S_IRUGO | S_IWUSR, show_sf_ctrl, store_sf_ctrl, \
1034 TEMP_FAN_MAP, index - 1), \
1035 SENSOR_ATTR_2(temp##index##_pwm_enable, S_IWUSR | S_IRUGO, \
1036 show_sf_ctrl, store_sf_ctrl, TEMP_PWM_ENABLE, \
1038 SENSOR_ATTR_2(thermal_cruise##index, S_IRUGO | S_IWUSR, \
1039 show_sf_ctrl, store_sf_ctrl, TEMP_CRUISE, index - 1), \
1040 SENSOR_ATTR_2(tolerance##index, S_IRUGO | S_IWUSR, show_sf_ctrl,\
1041 store_sf_ctrl, TEMP_TOLERANCE, index - 1), \
1042 SENSOR_ATTR_2(temp##index##_auto_point1_pwm, S_IRUGO | S_IWUSR, \
1043 show_sf2_pwm, store_sf2_pwm, 0, index - 1), \
1044 SENSOR_ATTR_2(temp##index##_auto_point2_pwm, S_IRUGO | S_IWUSR, \
1045 show_sf2_pwm, store_sf2_pwm, 1, index - 1), \
1046 SENSOR_ATTR_2(temp##index##_auto_point3_pwm, S_IRUGO | S_IWUSR, \
1047 show_sf2_pwm, store_sf2_pwm, 2, index - 1), \
1048 SENSOR_ATTR_2(temp##index##_auto_point4_pwm, S_IRUGO | S_IWUSR, \
1049 show_sf2_pwm, store_sf2_pwm, 3, index - 1), \
1050 SENSOR_ATTR_2(temp##index##_auto_point5_pwm, S_IRUGO | S_IWUSR, \
1051 show_sf2_pwm, store_sf2_pwm, 4, index - 1), \
1052 SENSOR_ATTR_2(temp##index##_auto_point6_pwm, S_IRUGO | S_IWUSR, \
1053 show_sf2_pwm, store_sf2_pwm, 5, index - 1), \
1054 SENSOR_ATTR_2(temp##index##_auto_point7_pwm, S_IRUGO | S_IWUSR, \
1055 show_sf2_pwm, store_sf2_pwm, 6, index - 1), \
1056 SENSOR_ATTR_2(temp##index##_auto_point1_temp, S_IRUGO | S_IWUSR,\
1057 show_sf2_temp, store_sf2_temp, 0, index - 1), \
1058 SENSOR_ATTR_2(temp##index##_auto_point2_temp, S_IRUGO | S_IWUSR,\
1059 show_sf2_temp, store_sf2_temp, 1, index - 1), \
1060 SENSOR_ATTR_2(temp##index##_auto_point3_temp, S_IRUGO | S_IWUSR,\
1061 show_sf2_temp, store_sf2_temp, 2, index - 1), \
1062 SENSOR_ATTR_2(temp##index##_auto_point4_temp, S_IRUGO | S_IWUSR,\
1063 show_sf2_temp, store_sf2_temp, 3, index - 1), \
1064 SENSOR_ATTR_2(temp##index##_auto_point5_temp, S_IRUGO | S_IWUSR,\
1065 show_sf2_temp, store_sf2_temp, 4, index - 1), \
1066 SENSOR_ATTR_2(temp##index##_auto_point6_temp, S_IRUGO | S_IWUSR,\
1067 show_sf2_temp, store_sf2_temp, 5, index - 1), \
1068 SENSOR_ATTR_2(temp##index##_auto_point7_temp, S_IRUGO | S_IWUSR,\
1069 show_sf2_temp, store_sf2_temp, 6, index - 1)
1071 static struct sensor_device_attribute_2 w83793_sensor_attr_2
[] = {
1092 static struct sensor_device_attribute_2 w83793_temp
[] = {
1093 SENSOR_ATTR_TEMP(1),
1094 SENSOR_ATTR_TEMP(2),
1095 SENSOR_ATTR_TEMP(3),
1096 SENSOR_ATTR_TEMP(4),
1097 SENSOR_ATTR_TEMP(5),
1098 SENSOR_ATTR_TEMP(6),
1102 static struct sensor_device_attribute_2 w83793_left_fan
[] = {
1107 SENSOR_ATTR_FAN(10),
1108 SENSOR_ATTR_FAN(11),
1109 SENSOR_ATTR_FAN(12),
1113 static struct sensor_device_attribute_2 w83793_left_pwm
[] = {
1121 static struct sensor_device_attribute_2 w83793_vid
[] = {
1122 SENSOR_ATTR_2(cpu0_vid
, S_IRUGO
, show_vid
, NULL
, NOT_USED
, 0),
1123 SENSOR_ATTR_2(cpu1_vid
, S_IRUGO
, show_vid
, NULL
, NOT_USED
, 1),
1125 static DEVICE_ATTR(vrm
, S_IWUSR
| S_IRUGO
, show_vrm
, store_vrm
);
1127 static struct sensor_device_attribute_2 sda_single_files
[] = {
1128 SENSOR_ATTR_2(chassis
, S_IWUSR
| S_IRUGO
, show_alarm_beep
,
1129 store_chassis_clear_legacy
, ALARM_STATUS
, 30),
1130 SENSOR_ATTR_2(intrusion0_alarm
, S_IWUSR
| S_IRUGO
, show_alarm_beep
,
1131 store_chassis_clear
, ALARM_STATUS
, 30),
1132 SENSOR_ATTR_2(beep_enable
, S_IWUSR
| S_IRUGO
, show_beep_enable
,
1133 store_beep_enable
, NOT_USED
, NOT_USED
),
1134 SENSOR_ATTR_2(pwm_default
, S_IWUSR
| S_IRUGO
, show_sf_setup
,
1135 store_sf_setup
, SETUP_PWM_DEFAULT
, NOT_USED
),
1136 SENSOR_ATTR_2(pwm_uptime
, S_IWUSR
| S_IRUGO
, show_sf_setup
,
1137 store_sf_setup
, SETUP_PWM_UPTIME
, NOT_USED
),
1138 SENSOR_ATTR_2(pwm_downtime
, S_IWUSR
| S_IRUGO
, show_sf_setup
,
1139 store_sf_setup
, SETUP_PWM_DOWNTIME
, NOT_USED
),
1140 SENSOR_ATTR_2(temp_critical
, S_IWUSR
| S_IRUGO
, show_sf_setup
,
1141 store_sf_setup
, SETUP_TEMP_CRITICAL
, NOT_USED
),
1144 static void w83793_init_client(struct i2c_client
*client
)
1147 w83793_write_value(client
, W83793_REG_CONFIG
, 0x80);
1150 /* Start monitoring */
1151 w83793_write_value(client
, W83793_REG_CONFIG
,
1152 w83793_read_value(client
, W83793_REG_CONFIG
) | 0x01);
1159 static int watchdog_set_timeout(struct w83793_data
*data
, int timeout
)
1163 mtimeout
= DIV_ROUND_UP(timeout
, 60);
1168 mutex_lock(&data
->watchdog_lock
);
1169 if (!data
->client
) {
1174 data
->watchdog_timeout
= mtimeout
;
1176 /* Set Timeout value (in Minutes) */
1177 w83793_write_value(data
->client
, W83793_REG_WDT_TIMEOUT
,
1178 data
->watchdog_timeout
);
1180 ret
= mtimeout
* 60;
1183 mutex_unlock(&data
->watchdog_lock
);
1187 static int watchdog_get_timeout(struct w83793_data
*data
)
1191 mutex_lock(&data
->watchdog_lock
);
1192 timeout
= data
->watchdog_timeout
* 60;
1193 mutex_unlock(&data
->watchdog_lock
);
1198 static int watchdog_trigger(struct w83793_data
*data
)
1202 mutex_lock(&data
->watchdog_lock
);
1203 if (!data
->client
) {
1208 /* Set Timeout value (in Minutes) */
1209 w83793_write_value(data
->client
, W83793_REG_WDT_TIMEOUT
,
1210 data
->watchdog_timeout
);
1213 mutex_unlock(&data
->watchdog_lock
);
1217 static int watchdog_enable(struct w83793_data
*data
)
1221 mutex_lock(&data
->watchdog_lock
);
1222 if (!data
->client
) {
1227 /* Set initial timeout */
1228 w83793_write_value(data
->client
, W83793_REG_WDT_TIMEOUT
,
1229 data
->watchdog_timeout
);
1231 /* Enable Soft Watchdog */
1232 w83793_write_value(data
->client
, W83793_REG_WDT_LOCK
, 0x55);
1235 mutex_unlock(&data
->watchdog_lock
);
1239 static int watchdog_disable(struct w83793_data
*data
)
1243 mutex_lock(&data
->watchdog_lock
);
1244 if (!data
->client
) {
1249 /* Disable Soft Watchdog */
1250 w83793_write_value(data
->client
, W83793_REG_WDT_LOCK
, 0xAA);
1253 mutex_unlock(&data
->watchdog_lock
);
1257 static int watchdog_open(struct inode
*inode
, struct file
*filp
)
1259 struct w83793_data
*pos
, *data
= NULL
;
1260 int watchdog_is_open
;
1262 /* We get called from drivers/char/misc.c with misc_mtx hold, and we
1263 call misc_register() from w83793_probe() with watchdog_data_mutex
1264 hold, as misc_register() takes the misc_mtx lock, this is a possible
1265 deadlock, so we use mutex_trylock here. */
1266 if (!mutex_trylock(&watchdog_data_mutex
))
1267 return -ERESTARTSYS
;
1268 list_for_each_entry(pos
, &watchdog_data_list
, list
) {
1269 if (pos
->watchdog_miscdev
.minor
== iminor(inode
)) {
1275 /* Check, if device is already open */
1276 watchdog_is_open
= test_and_set_bit(0, &data
->watchdog_is_open
);
1278 /* Increase data reference counter (if not already done).
1279 Note we can never not have found data, so we don't check for this */
1280 if (!watchdog_is_open
)
1281 kref_get(&data
->kref
);
1283 mutex_unlock(&watchdog_data_mutex
);
1285 /* Check, if device is already open and possibly issue error */
1286 if (watchdog_is_open
)
1289 /* Enable Soft Watchdog */
1290 watchdog_enable(data
);
1292 /* Store pointer to data into filp's private data */
1293 filp
->private_data
= data
;
1295 return nonseekable_open(inode
, filp
);
1298 static int watchdog_close(struct inode
*inode
, struct file
*filp
)
1300 struct w83793_data
*data
= filp
->private_data
;
1302 if (data
->watchdog_expect_close
) {
1303 watchdog_disable(data
);
1304 data
->watchdog_expect_close
= 0;
1306 watchdog_trigger(data
);
1307 dev_crit(&data
->client
->dev
,
1308 "unexpected close, not stopping watchdog!\n");
1311 clear_bit(0, &data
->watchdog_is_open
);
1313 /* Decrease data reference counter */
1314 mutex_lock(&watchdog_data_mutex
);
1315 kref_put(&data
->kref
, w83793_release_resources
);
1316 mutex_unlock(&watchdog_data_mutex
);
1321 static ssize_t
watchdog_write(struct file
*filp
, const char __user
*buf
,
1322 size_t count
, loff_t
*offset
)
1325 struct w83793_data
*data
= filp
->private_data
;
1331 /* Clear it in case it was set with a previous write */
1332 data
->watchdog_expect_close
= 0;
1334 for (i
= 0; i
!= count
; i
++) {
1336 if (get_user(c
, buf
+ i
))
1339 data
->watchdog_expect_close
= 1;
1342 ret
= watchdog_trigger(data
);
1349 static long watchdog_ioctl(struct file
*filp
, unsigned int cmd
,
1352 struct watchdog_info ident
= {
1353 .options
= WDIOF_KEEPALIVEPING
|
1356 .identity
= "w83793 watchdog"
1360 struct w83793_data
*data
= filp
->private_data
;
1363 case WDIOC_GETSUPPORT
:
1365 ident
.options
|= WDIOF_MAGICCLOSE
;
1366 if (copy_to_user((void __user
*)arg
, &ident
, sizeof(ident
)))
1370 case WDIOC_GETSTATUS
:
1371 val
= data
->watchdog_caused_reboot
? WDIOF_CARDRESET
: 0;
1372 ret
= put_user(val
, (int __user
*)arg
);
1375 case WDIOC_GETBOOTSTATUS
:
1376 ret
= put_user(0, (int __user
*)arg
);
1379 case WDIOC_KEEPALIVE
:
1380 ret
= watchdog_trigger(data
);
1383 case WDIOC_GETTIMEOUT
:
1384 val
= watchdog_get_timeout(data
);
1385 ret
= put_user(val
, (int __user
*)arg
);
1388 case WDIOC_SETTIMEOUT
:
1389 if (get_user(val
, (int __user
*)arg
)) {
1393 ret
= watchdog_set_timeout(data
, val
);
1395 ret
= put_user(ret
, (int __user
*)arg
);
1398 case WDIOC_SETOPTIONS
:
1399 if (get_user(val
, (int __user
*)arg
)) {
1404 if (val
& WDIOS_DISABLECARD
)
1405 ret
= watchdog_disable(data
);
1406 else if (val
& WDIOS_ENABLECARD
)
1407 ret
= watchdog_enable(data
);
1418 static const struct file_operations watchdog_fops
= {
1419 .owner
= THIS_MODULE
,
1420 .llseek
= no_llseek
,
1421 .open
= watchdog_open
,
1422 .release
= watchdog_close
,
1423 .write
= watchdog_write
,
1424 .unlocked_ioctl
= watchdog_ioctl
,
1428 * Notifier for system down
1431 static int watchdog_notify_sys(struct notifier_block
*this, unsigned long code
,
1434 struct w83793_data
*data
= NULL
;
1436 if (code
== SYS_DOWN
|| code
== SYS_HALT
) {
1438 /* Disable each registered watchdog */
1439 mutex_lock(&watchdog_data_mutex
);
1440 list_for_each_entry(data
, &watchdog_data_list
, list
) {
1441 if (data
->watchdog_miscdev
.minor
)
1442 watchdog_disable(data
);
1444 mutex_unlock(&watchdog_data_mutex
);
1451 * The WDT needs to learn about soft shutdowns in order to
1452 * turn the timebomb registers off.
1455 static struct notifier_block watchdog_notifier
= {
1456 .notifier_call
= watchdog_notify_sys
,
1460 * Init / remove routines
1463 static int w83793_remove(struct i2c_client
*client
)
1465 struct w83793_data
*data
= i2c_get_clientdata(client
);
1466 struct device
*dev
= &client
->dev
;
1469 /* Unregister the watchdog (if registered) */
1470 if (data
->watchdog_miscdev
.minor
) {
1471 misc_deregister(&data
->watchdog_miscdev
);
1473 if (data
->watchdog_is_open
) {
1474 dev_warn(&client
->dev
,
1475 "i2c client detached with watchdog open! "
1476 "Stopping watchdog.\n");
1477 watchdog_disable(data
);
1480 mutex_lock(&watchdog_data_mutex
);
1481 list_del(&data
->list
);
1482 mutex_unlock(&watchdog_data_mutex
);
1484 /* Tell the watchdog code the client is gone */
1485 mutex_lock(&data
->watchdog_lock
);
1486 data
->client
= NULL
;
1487 mutex_unlock(&data
->watchdog_lock
);
1490 /* Reset Configuration Register to Disable Watch Dog Registers */
1491 tmp
= w83793_read_value(client
, W83793_REG_CONFIG
);
1492 w83793_write_value(client
, W83793_REG_CONFIG
, tmp
& ~0x04);
1494 unregister_reboot_notifier(&watchdog_notifier
);
1496 hwmon_device_unregister(data
->hwmon_dev
);
1498 for (i
= 0; i
< ARRAY_SIZE(w83793_sensor_attr_2
); i
++)
1499 device_remove_file(dev
,
1500 &w83793_sensor_attr_2
[i
].dev_attr
);
1502 for (i
= 0; i
< ARRAY_SIZE(sda_single_files
); i
++)
1503 device_remove_file(dev
, &sda_single_files
[i
].dev_attr
);
1505 for (i
= 0; i
< ARRAY_SIZE(w83793_vid
); i
++)
1506 device_remove_file(dev
, &w83793_vid
[i
].dev_attr
);
1507 device_remove_file(dev
, &dev_attr_vrm
);
1509 for (i
= 0; i
< ARRAY_SIZE(w83793_left_fan
); i
++)
1510 device_remove_file(dev
, &w83793_left_fan
[i
].dev_attr
);
1512 for (i
= 0; i
< ARRAY_SIZE(w83793_left_pwm
); i
++)
1513 device_remove_file(dev
, &w83793_left_pwm
[i
].dev_attr
);
1515 for (i
= 0; i
< ARRAY_SIZE(w83793_temp
); i
++)
1516 device_remove_file(dev
, &w83793_temp
[i
].dev_attr
);
1518 if (data
->lm75
[0] != NULL
)
1519 i2c_unregister_device(data
->lm75
[0]);
1520 if (data
->lm75
[1] != NULL
)
1521 i2c_unregister_device(data
->lm75
[1]);
1523 /* Decrease data reference counter */
1524 mutex_lock(&watchdog_data_mutex
);
1525 kref_put(&data
->kref
, w83793_release_resources
);
1526 mutex_unlock(&watchdog_data_mutex
);
1532 w83793_detect_subclients(struct i2c_client
*client
)
1535 int address
= client
->addr
;
1537 struct i2c_adapter
*adapter
= client
->adapter
;
1538 struct w83793_data
*data
= i2c_get_clientdata(client
);
1540 id
= i2c_adapter_id(adapter
);
1541 if (force_subclients
[0] == id
&& force_subclients
[1] == address
) {
1542 for (i
= 2; i
<= 3; i
++) {
1543 if (force_subclients
[i
] < 0x48
1544 || force_subclients
[i
] > 0x4f) {
1545 dev_err(&client
->dev
,
1546 "invalid subclient "
1547 "address %d; must be 0x48-0x4f\n",
1548 force_subclients
[i
]);
1553 w83793_write_value(client
, W83793_REG_I2C_SUBADDR
,
1554 (force_subclients
[2] & 0x07) |
1555 ((force_subclients
[3] & 0x07) << 4));
1558 tmp
= w83793_read_value(client
, W83793_REG_I2C_SUBADDR
);
1559 if (!(tmp
& 0x08)) {
1560 data
->lm75
[0] = i2c_new_dummy(adapter
, 0x48 + (tmp
& 0x7));
1562 if (!(tmp
& 0x80)) {
1563 if ((data
->lm75
[0] != NULL
)
1564 && ((tmp
& 0x7) == ((tmp
>> 4) & 0x7))) {
1565 dev_err(&client
->dev
,
1566 "duplicate addresses 0x%x, "
1567 "use force_subclients\n", data
->lm75
[0]->addr
);
1571 data
->lm75
[1] = i2c_new_dummy(adapter
,
1572 0x48 + ((tmp
>> 4) & 0x7));
1577 /* Undo inits in case of errors */
1580 if (data
->lm75
[0] != NULL
)
1581 i2c_unregister_device(data
->lm75
[0]);
1586 /* Return 0 if detection is successful, -ENODEV otherwise */
1587 static int w83793_detect(struct i2c_client
*client
,
1588 struct i2c_board_info
*info
)
1590 u8 tmp
, bank
, chip_id
;
1591 struct i2c_adapter
*adapter
= client
->adapter
;
1592 unsigned short address
= client
->addr
;
1594 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
)) {
1598 bank
= i2c_smbus_read_byte_data(client
, W83793_REG_BANKSEL
);
1600 tmp
= bank
& 0x80 ? 0x5c : 0xa3;
1601 /* Check Winbond vendor ID */
1602 if (tmp
!= i2c_smbus_read_byte_data(client
, W83793_REG_VENDORID
)) {
1603 pr_debug("w83793: Detection failed at check vendor id\n");
1607 /* If Winbond chip, address of chip and W83793_REG_I2C_ADDR
1609 if ((bank
& 0x07) == 0
1610 && i2c_smbus_read_byte_data(client
, W83793_REG_I2C_ADDR
) !=
1612 pr_debug("w83793: Detection failed at check i2c addr\n");
1616 /* Determine the chip type now */
1617 chip_id
= i2c_smbus_read_byte_data(client
, W83793_REG_CHIPID
);
1618 if (chip_id
!= 0x7b)
1621 strlcpy(info
->type
, "w83793", I2C_NAME_SIZE
);
1626 static int w83793_probe(struct i2c_client
*client
,
1627 const struct i2c_device_id
*id
)
1629 struct device
*dev
= &client
->dev
;
1630 const int watchdog_minors
[] = { WATCHDOG_MINOR
, 212, 213, 214, 215 };
1631 struct w83793_data
*data
;
1632 int i
, tmp
, val
, err
;
1633 int files_fan
= ARRAY_SIZE(w83793_left_fan
) / 7;
1634 int files_pwm
= ARRAY_SIZE(w83793_left_pwm
) / 5;
1635 int files_temp
= ARRAY_SIZE(w83793_temp
) / 6;
1637 data
= kzalloc(sizeof(struct w83793_data
), GFP_KERNEL
);
1643 i2c_set_clientdata(client
, data
);
1644 data
->bank
= i2c_smbus_read_byte_data(client
, W83793_REG_BANKSEL
);
1645 mutex_init(&data
->update_lock
);
1646 mutex_init(&data
->watchdog_lock
);
1647 INIT_LIST_HEAD(&data
->list
);
1648 kref_init(&data
->kref
);
1650 /* Store client pointer in our data struct for watchdog usage
1651 (where the client is found through a data ptr instead of the
1653 data
->client
= client
;
1655 err
= w83793_detect_subclients(client
);
1659 /* Initialize the chip */
1660 w83793_init_client(client
);
1663 Only fan 1-5 has their own input pins,
1664 Pwm 1-3 has their own pins
1666 data
->has_fan
= 0x1f;
1667 data
->has_pwm
= 0x07;
1668 tmp
= w83793_read_value(client
, W83793_REG_MFC
);
1669 val
= w83793_read_value(client
, W83793_REG_FANIN_CTRL
);
1671 /* check the function of pins 49-56 */
1673 data
->has_vid
|= 0x2; /* has VIDB */
1675 data
->has_pwm
|= 0x18; /* pwm 4,5 */
1676 if (val
& 0x01) { /* fan 6 */
1677 data
->has_fan
|= 0x20;
1678 data
->has_pwm
|= 0x20;
1680 if (val
& 0x02) { /* fan 7 */
1681 data
->has_fan
|= 0x40;
1682 data
->has_pwm
|= 0x40;
1684 if (!(tmp
& 0x40) && (val
& 0x04)) { /* fan 8 */
1685 data
->has_fan
|= 0x80;
1686 data
->has_pwm
|= 0x80;
1690 /* check the function of pins 37-40 */
1692 data
->has_vid
|= 0x1; /* has VIDA */
1693 if (0x08 == (tmp
& 0x0c)) {
1694 if (val
& 0x08) /* fan 9 */
1695 data
->has_fan
|= 0x100;
1696 if (val
& 0x10) /* fan 10 */
1697 data
->has_fan
|= 0x200;
1699 if (0x20 == (tmp
& 0x30)) {
1700 if (val
& 0x20) /* fan 11 */
1701 data
->has_fan
|= 0x400;
1702 if (val
& 0x40) /* fan 12 */
1703 data
->has_fan
|= 0x800;
1706 if ((tmp
& 0x01) && (val
& 0x04)) { /* fan 8, second location */
1707 data
->has_fan
|= 0x80;
1708 data
->has_pwm
|= 0x80;
1711 tmp
= w83793_read_value(client
, W83793_REG_FANIN_SEL
);
1712 if ((tmp
& 0x01) && (val
& 0x08)) { /* fan 9, second location */
1713 data
->has_fan
|= 0x100;
1715 if ((tmp
& 0x02) && (val
& 0x10)) { /* fan 10, second location */
1716 data
->has_fan
|= 0x200;
1718 if ((tmp
& 0x04) && (val
& 0x20)) { /* fan 11, second location */
1719 data
->has_fan
|= 0x400;
1721 if ((tmp
& 0x08) && (val
& 0x40)) { /* fan 12, second location */
1722 data
->has_fan
|= 0x800;
1725 /* check the temp1-6 mode, ignore former AMDSI selected inputs */
1726 tmp
= w83793_read_value(client
,W83793_REG_TEMP_MODE
[0]);
1728 data
->has_temp
|= 0x01;
1730 data
->has_temp
|= 0x02;
1732 data
->has_temp
|= 0x04;
1734 data
->has_temp
|= 0x08;
1736 tmp
= w83793_read_value(client
,W83793_REG_TEMP_MODE
[1]);
1738 data
->has_temp
|= 0x10;
1740 data
->has_temp
|= 0x20;
1742 /* Register sysfs hooks */
1743 for (i
= 0; i
< ARRAY_SIZE(w83793_sensor_attr_2
); i
++) {
1744 err
= device_create_file(dev
,
1745 &w83793_sensor_attr_2
[i
].dev_attr
);
1750 for (i
= 0; i
< ARRAY_SIZE(w83793_vid
); i
++) {
1751 if (!(data
->has_vid
& (1 << i
)))
1753 err
= device_create_file(dev
, &w83793_vid
[i
].dev_attr
);
1757 if (data
->has_vid
) {
1758 data
->vrm
= vid_which_vrm();
1759 err
= device_create_file(dev
, &dev_attr_vrm
);
1764 for (i
= 0; i
< ARRAY_SIZE(sda_single_files
); i
++) {
1765 err
= device_create_file(dev
, &sda_single_files
[i
].dev_attr
);
1771 for (i
= 0; i
< 6; i
++) {
1773 if (!(data
->has_temp
& (1 << i
)))
1775 for (j
= 0; j
< files_temp
; j
++) {
1776 err
= device_create_file(dev
,
1777 &w83793_temp
[(i
) * files_temp
1784 for (i
= 5; i
< 12; i
++) {
1786 if (!(data
->has_fan
& (1 << i
)))
1788 for (j
= 0; j
< files_fan
; j
++) {
1789 err
= device_create_file(dev
,
1790 &w83793_left_fan
[(i
- 5) * files_fan
1797 for (i
= 3; i
< 8; i
++) {
1799 if (!(data
->has_pwm
& (1 << i
)))
1801 for (j
= 0; j
< files_pwm
; j
++) {
1802 err
= device_create_file(dev
,
1803 &w83793_left_pwm
[(i
- 3) * files_pwm
1810 data
->hwmon_dev
= hwmon_device_register(dev
);
1811 if (IS_ERR(data
->hwmon_dev
)) {
1812 err
= PTR_ERR(data
->hwmon_dev
);
1816 /* Watchdog initialization */
1818 /* Register boot notifier */
1819 err
= register_reboot_notifier(&watchdog_notifier
);
1821 dev_err(&client
->dev
,
1822 "cannot register reboot notifier (err=%d)\n", err
);
1826 /* Enable Watchdog registers.
1827 Set Configuration Register to Enable Watch Dog Registers
1828 (Bit 2) = XXXX, X1XX. */
1829 tmp
= w83793_read_value(client
, W83793_REG_CONFIG
);
1830 w83793_write_value(client
, W83793_REG_CONFIG
, tmp
| 0x04);
1832 /* Set the default watchdog timeout */
1833 data
->watchdog_timeout
= timeout
;
1835 /* Check, if last reboot was caused by watchdog */
1836 data
->watchdog_caused_reboot
=
1837 w83793_read_value(data
->client
, W83793_REG_WDT_STATUS
) & 0x01;
1839 /* Disable Soft Watchdog during initialiation */
1840 watchdog_disable(data
);
1842 /* We take the data_mutex lock early so that watchdog_open() cannot
1843 run when misc_register() has completed, but we've not yet added
1844 our data to the watchdog_data_list (and set the default timeout) */
1845 mutex_lock(&watchdog_data_mutex
);
1846 for (i
= 0; i
< ARRAY_SIZE(watchdog_minors
); i
++) {
1847 /* Register our watchdog part */
1848 snprintf(data
->watchdog_name
, sizeof(data
->watchdog_name
),
1849 "watchdog%c", (i
== 0) ? '\0' : ('0' + i
));
1850 data
->watchdog_miscdev
.name
= data
->watchdog_name
;
1851 data
->watchdog_miscdev
.fops
= &watchdog_fops
;
1852 data
->watchdog_miscdev
.minor
= watchdog_minors
[i
];
1854 err
= misc_register(&data
->watchdog_miscdev
);
1858 data
->watchdog_miscdev
.minor
= 0;
1859 dev_err(&client
->dev
,
1860 "Registering watchdog chardev: %d\n", err
);
1864 list_add(&data
->list
, &watchdog_data_list
);
1866 dev_info(&client
->dev
,
1867 "Registered watchdog chardev major 10, minor: %d\n",
1868 watchdog_minors
[i
]);
1871 if (i
== ARRAY_SIZE(watchdog_minors
)) {
1872 data
->watchdog_miscdev
.minor
= 0;
1873 dev_warn(&client
->dev
, "Couldn't register watchdog chardev "
1874 "(due to no free minor)\n");
1877 mutex_unlock(&watchdog_data_mutex
);
1881 /* Unregister hwmon device */
1885 hwmon_device_unregister(data
->hwmon_dev
);
1887 /* Unregister sysfs hooks */
1890 for (i
= 0; i
< ARRAY_SIZE(w83793_sensor_attr_2
); i
++)
1891 device_remove_file(dev
, &w83793_sensor_attr_2
[i
].dev_attr
);
1893 for (i
= 0; i
< ARRAY_SIZE(sda_single_files
); i
++)
1894 device_remove_file(dev
, &sda_single_files
[i
].dev_attr
);
1896 for (i
= 0; i
< ARRAY_SIZE(w83793_vid
); i
++)
1897 device_remove_file(dev
, &w83793_vid
[i
].dev_attr
);
1899 for (i
= 0; i
< ARRAY_SIZE(w83793_left_fan
); i
++)
1900 device_remove_file(dev
, &w83793_left_fan
[i
].dev_attr
);
1902 for (i
= 0; i
< ARRAY_SIZE(w83793_left_pwm
); i
++)
1903 device_remove_file(dev
, &w83793_left_pwm
[i
].dev_attr
);
1905 for (i
= 0; i
< ARRAY_SIZE(w83793_temp
); i
++)
1906 device_remove_file(dev
, &w83793_temp
[i
].dev_attr
);
1908 if (data
->lm75
[0] != NULL
)
1909 i2c_unregister_device(data
->lm75
[0]);
1910 if (data
->lm75
[1] != NULL
)
1911 i2c_unregister_device(data
->lm75
[1]);
1918 static void w83793_update_nonvolatile(struct device
*dev
)
1920 struct i2c_client
*client
= to_i2c_client(dev
);
1921 struct w83793_data
*data
= i2c_get_clientdata(client
);
1924 They are somewhat "stable" registers, and to update them every time
1925 takes so much time, it's just not worthy. Update them in a long
1926 interval to avoid exception.
1928 if (!(time_after(jiffies
, data
->last_nonvolatile
+ HZ
* 300)
1931 /* update voltage limits */
1932 for (i
= 1; i
< 3; i
++) {
1933 for (j
= 0; j
< ARRAY_SIZE(data
->in
); j
++) {
1935 w83793_read_value(client
, W83793_REG_IN
[j
][i
]);
1937 data
->in_low_bits
[i
] =
1938 w83793_read_value(client
, W83793_REG_IN_LOW_BITS
[i
]);
1941 for (i
= 0; i
< ARRAY_SIZE(data
->fan_min
); i
++) {
1942 /* Update the Fan measured value and limits */
1943 if (!(data
->has_fan
& (1 << i
))) {
1947 w83793_read_value(client
, W83793_REG_FAN_MIN(i
)) << 8;
1949 w83793_read_value(client
, W83793_REG_FAN_MIN(i
) + 1);
1952 for (i
= 0; i
< ARRAY_SIZE(data
->temp_fan_map
); i
++) {
1953 if (!(data
->has_temp
& (1 << i
)))
1955 data
->temp_fan_map
[i
] =
1956 w83793_read_value(client
, W83793_REG_TEMP_FAN_MAP(i
));
1957 for (j
= 1; j
< 5; j
++) {
1959 w83793_read_value(client
, W83793_REG_TEMP
[i
][j
]);
1961 data
->temp_cruise
[i
] =
1962 w83793_read_value(client
, W83793_REG_TEMP_CRUISE(i
));
1963 for (j
= 0; j
< 7; j
++) {
1964 data
->sf2_pwm
[i
][j
] =
1965 w83793_read_value(client
, W83793_REG_SF2_PWM(i
, j
));
1966 data
->sf2_temp
[i
][j
] =
1967 w83793_read_value(client
,
1968 W83793_REG_SF2_TEMP(i
, j
));
1972 for (i
= 0; i
< ARRAY_SIZE(data
->temp_mode
); i
++)
1973 data
->temp_mode
[i
] =
1974 w83793_read_value(client
, W83793_REG_TEMP_MODE
[i
]);
1976 for (i
= 0; i
< ARRAY_SIZE(data
->tolerance
); i
++) {
1977 data
->tolerance
[i
] =
1978 w83793_read_value(client
, W83793_REG_TEMP_TOL(i
));
1981 for (i
= 0; i
< ARRAY_SIZE(data
->pwm
); i
++) {
1982 if (!(data
->has_pwm
& (1 << i
)))
1984 data
->pwm
[i
][PWM_NONSTOP
] =
1985 w83793_read_value(client
, W83793_REG_PWM(i
, PWM_NONSTOP
));
1986 data
->pwm
[i
][PWM_START
] =
1987 w83793_read_value(client
, W83793_REG_PWM(i
, PWM_START
));
1988 data
->pwm_stop_time
[i
] =
1989 w83793_read_value(client
, W83793_REG_PWM_STOP_TIME(i
));
1992 data
->pwm_default
= w83793_read_value(client
, W83793_REG_PWM_DEFAULT
);
1993 data
->pwm_enable
= w83793_read_value(client
, W83793_REG_PWM_ENABLE
);
1994 data
->pwm_uptime
= w83793_read_value(client
, W83793_REG_PWM_UPTIME
);
1995 data
->pwm_downtime
= w83793_read_value(client
, W83793_REG_PWM_DOWNTIME
);
1996 data
->temp_critical
=
1997 w83793_read_value(client
, W83793_REG_TEMP_CRITICAL
);
1998 data
->beep_enable
= w83793_read_value(client
, W83793_REG_OVT_BEEP
);
2000 for (i
= 0; i
< ARRAY_SIZE(data
->beeps
); i
++) {
2001 data
->beeps
[i
] = w83793_read_value(client
, W83793_REG_BEEP(i
));
2004 data
->last_nonvolatile
= jiffies
;
2007 static struct w83793_data
*w83793_update_device(struct device
*dev
)
2009 struct i2c_client
*client
= to_i2c_client(dev
);
2010 struct w83793_data
*data
= i2c_get_clientdata(client
);
2013 mutex_lock(&data
->update_lock
);
2015 if (!(time_after(jiffies
, data
->last_updated
+ HZ
* 2)
2019 /* Update the voltages measured value and limits */
2020 for (i
= 0; i
< ARRAY_SIZE(data
->in
); i
++)
2021 data
->in
[i
][IN_READ
] =
2022 w83793_read_value(client
, W83793_REG_IN
[i
][IN_READ
]);
2024 data
->in_low_bits
[IN_READ
] =
2025 w83793_read_value(client
, W83793_REG_IN_LOW_BITS
[IN_READ
]);
2027 for (i
= 0; i
< ARRAY_SIZE(data
->fan
); i
++) {
2028 if (!(data
->has_fan
& (1 << i
))) {
2032 w83793_read_value(client
, W83793_REG_FAN(i
)) << 8;
2034 w83793_read_value(client
, W83793_REG_FAN(i
) + 1);
2037 for (i
= 0; i
< ARRAY_SIZE(data
->temp
); i
++) {
2038 if (!(data
->has_temp
& (1 << i
)))
2040 data
->temp
[i
][TEMP_READ
] =
2041 w83793_read_value(client
, W83793_REG_TEMP
[i
][TEMP_READ
]);
2044 data
->temp_low_bits
=
2045 w83793_read_value(client
, W83793_REG_TEMP_LOW_BITS
);
2047 for (i
= 0; i
< ARRAY_SIZE(data
->pwm
); i
++) {
2048 if (data
->has_pwm
& (1 << i
))
2049 data
->pwm
[i
][PWM_DUTY
] =
2050 w83793_read_value(client
,
2051 W83793_REG_PWM(i
, PWM_DUTY
));
2054 for (i
= 0; i
< ARRAY_SIZE(data
->alarms
); i
++)
2056 w83793_read_value(client
, W83793_REG_ALARM(i
));
2057 if (data
->has_vid
& 0x01)
2058 data
->vid
[0] = w83793_read_value(client
, W83793_REG_VID_INA
);
2059 if (data
->has_vid
& 0x02)
2060 data
->vid
[1] = w83793_read_value(client
, W83793_REG_VID_INB
);
2061 w83793_update_nonvolatile(dev
);
2062 data
->last_updated
= jiffies
;
2066 mutex_unlock(&data
->update_lock
);
2070 /* Ignore the possibility that somebody change bank outside the driver
2071 Must be called with data->update_lock held, except during initialization */
2072 static u8
w83793_read_value(struct i2c_client
*client
, u16 reg
)
2074 struct w83793_data
*data
= i2c_get_clientdata(client
);
2076 u8 new_bank
= reg
>> 8;
2078 new_bank
|= data
->bank
& 0xfc;
2079 if (data
->bank
!= new_bank
) {
2080 if (i2c_smbus_write_byte_data
2081 (client
, W83793_REG_BANKSEL
, new_bank
) >= 0)
2082 data
->bank
= new_bank
;
2084 dev_err(&client
->dev
,
2085 "set bank to %d failed, fall back "
2086 "to bank %d, read reg 0x%x error\n",
2087 new_bank
, data
->bank
, reg
);
2088 res
= 0x0; /* read 0x0 from the chip */
2092 res
= i2c_smbus_read_byte_data(client
, reg
& 0xff);
2097 /* Must be called with data->update_lock held, except during initialization */
2098 static int w83793_write_value(struct i2c_client
*client
, u16 reg
, u8 value
)
2100 struct w83793_data
*data
= i2c_get_clientdata(client
);
2102 u8 new_bank
= reg
>> 8;
2104 new_bank
|= data
->bank
& 0xfc;
2105 if (data
->bank
!= new_bank
) {
2106 if ((res
= i2c_smbus_write_byte_data
2107 (client
, W83793_REG_BANKSEL
, new_bank
)) >= 0)
2108 data
->bank
= new_bank
;
2110 dev_err(&client
->dev
,
2111 "set bank to %d failed, fall back "
2112 "to bank %d, write reg 0x%x error\n",
2113 new_bank
, data
->bank
, reg
);
2118 res
= i2c_smbus_write_byte_data(client
, reg
& 0xff, value
);
2123 static int __init
sensors_w83793_init(void)
2125 return i2c_add_driver(&w83793_driver
);
2128 static void __exit
sensors_w83793_exit(void)
2130 i2c_del_driver(&w83793_driver
);
2133 MODULE_AUTHOR("Yuan Mu, Sven Anders");
2134 MODULE_DESCRIPTION("w83793 driver");
2135 MODULE_LICENSE("GPL");
2137 module_init(sensors_w83793_init
);
2138 module_exit(sensors_w83793_exit
);