2 w83781d.c - Part of lm_sensors, Linux kernel modules for hardware
4 Copyright (c) 1998 - 2001 Frodo Looijaard <frodol@dds.nl>,
5 Philip Edelbrock <phil@netroedge.com>,
6 and Mark Studebaker <mdsxyz123@yahoo.com>
7 Copyright (c) 2007 - 2008 Jean Delvare <khali@linux-fr.org>
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 Supports following chips:
27 Chip #vin #fanin #pwm #temp wchipid vendid i2c ISA
28 as99127f 7 3 0 3 0x31 0x12c3 yes no
29 as99127f rev.2 (type_name = as99127f) 0x31 0x5ca3 yes no
30 w83781d 7 3 0 3 0x10-1 0x5ca3 yes yes
31 w83782d 9 3 2-4 3 0x30 0x5ca3 yes yes
32 w83783s 5-6 3 2 1-2 0x40 0x5ca3 yes no
36 #include <linux/module.h>
37 #include <linux/init.h>
38 #include <linux/slab.h>
39 #include <linux/jiffies.h>
40 #include <linux/i2c.h>
41 #include <linux/hwmon.h>
42 #include <linux/hwmon-vid.h>
43 #include <linux/hwmon-sysfs.h>
44 #include <linux/sysfs.h>
45 #include <linux/err.h>
46 #include <linux/mutex.h>
49 #include <linux/platform_device.h>
50 #include <linux/ioport.h>
56 /* Addresses to scan */
57 static const unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
58 0x2e, 0x2f, I2C_CLIENT_END };
59 /* Insmod parameters */
60 I2C_CLIENT_INSMOD_4(w83781d, w83782d, w83783s, as99127f);
62 static unsigned short force_subclients[4];
63 module_param_array(force_subclients, short, NULL, 0);
64 MODULE_PARM_DESC(force_subclients, "List of subclient addresses: "
65 "{bus, clientaddr, subclientaddr1, subclientaddr2}");
68 module_param(reset, bool, 0);
69 MODULE_PARM_DESC(reset, "Set to one to reset chip on load");
72 module_param(init, bool, 0);
73 MODULE_PARM_DESC(init, "Set to zero to bypass chip initialization");
75 /* Constants specified below */
77 /* Length of ISA address segment */
78 #define W83781D_EXTENT 8
80 /* Where are the ISA address/data registers relative to the base address */
81 #define W83781D_ADDR_REG_OFFSET 5
82 #define W83781D_DATA_REG_OFFSET 6
84 /* The device registers */
85 /* in nr from 0 to 8 */
86 #define W83781D_REG_IN_MAX(nr) ((nr < 7) ? (0x2b + (nr) * 2) : \
87 (0x554 + (((nr) - 7) * 2)))
88 #define W83781D_REG_IN_MIN(nr) ((nr < 7) ? (0x2c + (nr) * 2) : \
89 (0x555 + (((nr) - 7) * 2)))
90 #define W83781D_REG_IN(nr) ((nr < 7) ? (0x20 + (nr)) : \
93 /* fan nr from 0 to 2 */
94 #define W83781D_REG_FAN_MIN(nr) (0x3b + (nr))
95 #define W83781D_REG_FAN(nr) (0x28 + (nr))
97 #define W83781D_REG_BANK 0x4E
98 #define W83781D_REG_TEMP2_CONFIG 0x152
99 #define W83781D_REG_TEMP3_CONFIG 0x252
100 /* temp nr from 1 to 3 */
101 #define W83781D_REG_TEMP(nr) ((nr == 3) ? (0x0250) : \
102 ((nr == 2) ? (0x0150) : \
104 #define W83781D_REG_TEMP_HYST(nr) ((nr == 3) ? (0x253) : \
105 ((nr == 2) ? (0x153) : \
107 #define W83781D_REG_TEMP_OVER(nr) ((nr == 3) ? (0x255) : \
108 ((nr == 2) ? (0x155) : \
111 #define W83781D_REG_CONFIG 0x40
113 /* Interrupt status (W83781D, AS99127F) */
114 #define W83781D_REG_ALARM1 0x41
115 #define W83781D_REG_ALARM2 0x42
117 /* Real-time status (W83782D, W83783S) */
118 #define W83782D_REG_ALARM1 0x459
119 #define W83782D_REG_ALARM2 0x45A
120 #define W83782D_REG_ALARM3 0x45B
122 #define W83781D_REG_BEEP_CONFIG 0x4D
123 #define W83781D_REG_BEEP_INTS1 0x56
124 #define W83781D_REG_BEEP_INTS2 0x57
125 #define W83781D_REG_BEEP_INTS3 0x453 /* not on W83781D */
127 #define W83781D_REG_VID_FANDIV 0x47
129 #define W83781D_REG_CHIPID 0x49
130 #define W83781D_REG_WCHIPID 0x58
131 #define W83781D_REG_CHIPMAN 0x4F
132 #define W83781D_REG_PIN 0x4B
135 #define W83781D_REG_VBAT 0x5D
137 /* PWM 782D (1-4) and 783S (1-2) only */
138 static const u8 W83781D_REG_PWM[] = { 0x5B, 0x5A, 0x5E, 0x5F };
139 #define W83781D_REG_PWMCLK12 0x5C
140 #define W83781D_REG_PWMCLK34 0x45C
142 #define W83781D_REG_I2C_ADDR 0x48
143 #define W83781D_REG_I2C_SUBADDR 0x4A
145 /* The following are undocumented in the data sheets however we
146 received the information in an email from Winbond tech support */
147 /* Sensor selection - not on 781d */
148 #define W83781D_REG_SCFG1 0x5D
149 static const u8 BIT_SCFG1[] = { 0x02, 0x04, 0x08 };
151 #define W83781D_REG_SCFG2 0x59
152 static const u8 BIT_SCFG2[] = { 0x10, 0x20, 0x40 };
154 #define W83781D_DEFAULT_BETA 3435
157 #define IN_TO_REG(val) SENSORS_LIMIT(((val) + 8) / 16, 0, 255)
158 #define IN_FROM_REG(val) ((val) * 16)
161 FAN_TO_REG(long rpm, int div)
165 rpm = SENSORS_LIMIT(rpm, 1, 1000000);
166 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
170 FAN_FROM_REG(u8 val, int div)
176 return 1350000 / (val * div);
179 #define TEMP_TO_REG(val) SENSORS_LIMIT((val) / 1000, -127, 128)
180 #define TEMP_FROM_REG(val) ((val) * 1000)
182 #define BEEP_MASK_FROM_REG(val,type) ((type) == as99127f ? \
183 (~(val)) & 0x7fff : (val) & 0xff7fff)
184 #define BEEP_MASK_TO_REG(val,type) ((type) == as99127f ? \
185 (~(val)) & 0x7fff : (val) & 0xff7fff)
187 #define DIV_FROM_REG(val) (1 << (val))
190 DIV_TO_REG(long val, enum chips type)
193 val = SENSORS_LIMIT(val, 1,
195 || type == as99127f) ? 8 : 128)) >> 1;
196 for (i = 0; i < 7; i++) {
204 struct w83781d_data {
205 struct i2c_client *client;
206 struct device *hwmon_dev;
210 /* For ISA device only */
214 struct mutex update_lock;
215 char valid; /* !=0 if following fields are valid */
216 unsigned long last_updated; /* In jiffies */
218 struct i2c_client *lm75[2]; /* for secondary I2C addresses */
219 /* array of 2 pointers to subclients */
221 u8 in[9]; /* Register value - 8 & 9 for 782D only */
222 u8 in_max[9]; /* Register value - 8 & 9 for 782D only */
223 u8 in_min[9]; /* Register value - 8 & 9 for 782D only */
224 u8 fan[3]; /* Register value */
225 u8 fan_min[3]; /* Register value */
226 s8 temp; /* Register value */
227 s8 temp_max; /* Register value */
228 s8 temp_max_hyst; /* Register value */
229 u16 temp_add[2]; /* Register value */
230 u16 temp_max_add[2]; /* Register value */
231 u16 temp_max_hyst_add[2]; /* Register value */
232 u8 fan_div[3]; /* Register encoding, shifted right */
233 u8 vid; /* Register encoding, combined */
234 u32 alarms; /* Register encoding, combined */
235 u32 beep_mask; /* Register encoding, combined */
236 u8 pwm[4]; /* Register value */
237 u8 pwm2_enable; /* Boolean */
238 u16 sens[3]; /* 782D/783S only.
239 1 = pentium diode; 2 = 3904 diode;
244 static struct w83781d_data *w83781d_data_if_isa(void);
245 static int w83781d_alias_detect(struct i2c_client *client, u8 chipid);
247 static int w83781d_read_value(struct w83781d_data *data, u16 reg);
248 static int w83781d_write_value(struct w83781d_data *data, u16 reg, u16 value);
249 static struct w83781d_data *w83781d_update_device(struct device *dev);
250 static void w83781d_init_device(struct device *dev);
252 /* following are the sysfs callback functions */
253 #define show_in_reg(reg) \
254 static ssize_t show_##reg (struct device *dev, struct device_attribute *da, \
257 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
258 struct w83781d_data *data = w83781d_update_device(dev); \
259 return sprintf(buf, "%ld\n", \
260 (long)IN_FROM_REG(data->reg[attr->index])); \
266 #define store_in_reg(REG, reg) \
267 static ssize_t store_in_##reg (struct device *dev, struct device_attribute \
268 *da, const char *buf, size_t count) \
270 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
271 struct w83781d_data *data = dev_get_drvdata(dev); \
272 int nr = attr->index; \
275 val = simple_strtoul(buf, NULL, 10); \
277 mutex_lock(&data->update_lock); \
278 data->in_##reg[nr] = IN_TO_REG(val); \
279 w83781d_write_value(data, W83781D_REG_IN_##REG(nr), data->in_##reg[nr]); \
281 mutex_unlock(&data->update_lock); \
284 store_in_reg(MIN, min);
285 store_in_reg(MAX, max);
287 #define sysfs_in_offsets(offset) \
288 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
289 show_in, NULL, offset); \
290 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
291 show_in_min, store_in_min, offset); \
292 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
293 show_in_max, store_in_max, offset)
305 #define show_fan_reg(reg) \
306 static ssize_t show_##reg (struct device *dev, struct device_attribute *da, \
309 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
310 struct w83781d_data *data = w83781d_update_device(dev); \
311 return sprintf(buf,"%ld\n", \
312 FAN_FROM_REG(data->reg[attr->index], \
313 DIV_FROM_REG(data->fan_div[attr->index]))); \
316 show_fan_reg(fan_min);
319 store_fan_min(struct device *dev, struct device_attribute *da,
320 const char *buf, size_t count)
322 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
323 struct w83781d_data *data = dev_get_drvdata(dev);
324 int nr = attr->index;
327 val = simple_strtoul(buf, NULL, 10);
329 mutex_lock(&data->update_lock);
331 FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
332 w83781d_write_value(data, W83781D_REG_FAN_MIN(nr),
335 mutex_unlock(&data->update_lock);
339 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
340 static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO | S_IWUSR,
341 show_fan_min, store_fan_min, 0);
342 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1);
343 static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO | S_IWUSR,
344 show_fan_min, store_fan_min, 1);
345 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2);
346 static SENSOR_DEVICE_ATTR(fan3_min, S_IRUGO | S_IWUSR,
347 show_fan_min, store_fan_min, 2);
349 #define show_temp_reg(reg) \
350 static ssize_t show_##reg (struct device *dev, struct device_attribute *da, \
353 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
354 struct w83781d_data *data = w83781d_update_device(dev); \
355 int nr = attr->index; \
356 if (nr >= 2) { /* TEMP2 and TEMP3 */ \
357 return sprintf(buf,"%d\n", \
358 LM75_TEMP_FROM_REG(data->reg##_add[nr-2])); \
359 } else { /* TEMP1 */ \
360 return sprintf(buf,"%ld\n", (long)TEMP_FROM_REG(data->reg)); \
364 show_temp_reg(temp_max);
365 show_temp_reg(temp_max_hyst);
367 #define store_temp_reg(REG, reg) \
368 static ssize_t store_temp_##reg (struct device *dev, \
369 struct device_attribute *da, const char *buf, size_t count) \
371 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
372 struct w83781d_data *data = dev_get_drvdata(dev); \
373 int nr = attr->index; \
376 val = simple_strtol(buf, NULL, 10); \
378 mutex_lock(&data->update_lock); \
380 if (nr >= 2) { /* TEMP2 and TEMP3 */ \
381 data->temp_##reg##_add[nr-2] = LM75_TEMP_TO_REG(val); \
382 w83781d_write_value(data, W83781D_REG_TEMP_##REG(nr), \
383 data->temp_##reg##_add[nr-2]); \
384 } else { /* TEMP1 */ \
385 data->temp_##reg = TEMP_TO_REG(val); \
386 w83781d_write_value(data, W83781D_REG_TEMP_##REG(nr), \
390 mutex_unlock(&data->update_lock); \
393 store_temp_reg(OVER, max);
394 store_temp_reg(HYST, max_hyst);
396 #define sysfs_temp_offsets(offset) \
397 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
398 show_temp, NULL, offset); \
399 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
400 show_temp_max, store_temp_max, offset); \
401 static SENSOR_DEVICE_ATTR(temp##offset##_max_hyst, S_IRUGO | S_IWUSR, \
402 show_temp_max_hyst, store_temp_max_hyst, offset);
404 sysfs_temp_offsets(1);
405 sysfs_temp_offsets(2);
406 sysfs_temp_offsets(3);
409 show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
411 struct w83781d_data *data = w83781d_update_device(dev);
412 return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm));
415 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
418 show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
420 struct w83781d_data *data = dev_get_drvdata(dev);
421 return sprintf(buf, "%ld\n", (long) data->vrm);
425 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
427 struct w83781d_data *data = dev_get_drvdata(dev);
430 val = simple_strtoul(buf, NULL, 10);
436 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
439 show_alarms_reg(struct device *dev, struct device_attribute *attr, char *buf)
441 struct w83781d_data *data = w83781d_update_device(dev);
442 return sprintf(buf, "%u\n", data->alarms);
445 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
447 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
450 struct w83781d_data *data = w83781d_update_device(dev);
451 int bitnr = to_sensor_dev_attr(attr)->index;
452 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
455 /* The W83781D has a single alarm bit for temp2 and temp3 */
456 static ssize_t show_temp3_alarm(struct device *dev,
457 struct device_attribute *attr, char *buf)
459 struct w83781d_data *data = w83781d_update_device(dev);
460 int bitnr = (data->type == w83781d) ? 5 : 13;
461 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
464 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
465 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
466 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
467 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
468 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
469 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9);
470 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 10);
471 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 16);
472 static SENSOR_DEVICE_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 17);
473 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
474 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
475 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11);
476 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4);
477 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5);
478 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_temp3_alarm, NULL, 0);
480 static ssize_t show_beep_mask (struct device *dev, struct device_attribute *attr, char *buf)
482 struct w83781d_data *data = w83781d_update_device(dev);
483 return sprintf(buf, "%ld\n",
484 (long)BEEP_MASK_FROM_REG(data->beep_mask, data->type));
488 store_beep_mask(struct device *dev, struct device_attribute *attr,
489 const char *buf, size_t count)
491 struct w83781d_data *data = dev_get_drvdata(dev);
494 val = simple_strtoul(buf, NULL, 10);
496 mutex_lock(&data->update_lock);
497 data->beep_mask &= 0x8000; /* preserve beep enable */
498 data->beep_mask |= BEEP_MASK_TO_REG(val, data->type);
499 w83781d_write_value(data, W83781D_REG_BEEP_INTS1,
500 data->beep_mask & 0xff);
501 w83781d_write_value(data, W83781D_REG_BEEP_INTS2,
502 (data->beep_mask >> 8) & 0xff);
503 if (data->type != w83781d && data->type != as99127f) {
504 w83781d_write_value(data, W83781D_REG_BEEP_INTS3,
505 ((data->beep_mask) >> 16) & 0xff);
507 mutex_unlock(&data->update_lock);
512 static DEVICE_ATTR(beep_mask, S_IRUGO | S_IWUSR,
513 show_beep_mask, store_beep_mask);
515 static ssize_t show_beep(struct device *dev, struct device_attribute *attr,
518 struct w83781d_data *data = w83781d_update_device(dev);
519 int bitnr = to_sensor_dev_attr(attr)->index;
520 return sprintf(buf, "%u\n", (data->beep_mask >> bitnr) & 1);
524 store_beep(struct device *dev, struct device_attribute *attr,
525 const char *buf, size_t count)
527 struct w83781d_data *data = dev_get_drvdata(dev);
528 int bitnr = to_sensor_dev_attr(attr)->index;
532 bit = simple_strtoul(buf, NULL, 10);
536 mutex_lock(&data->update_lock);
538 data->beep_mask |= (1 << bitnr);
540 data->beep_mask &= ~(1 << bitnr);
543 reg = w83781d_read_value(data, W83781D_REG_BEEP_INTS1);
547 reg &= ~(1 << bitnr);
548 w83781d_write_value(data, W83781D_REG_BEEP_INTS1, reg);
549 } else if (bitnr < 16) {
550 reg = w83781d_read_value(data, W83781D_REG_BEEP_INTS2);
552 reg |= (1 << (bitnr - 8));
554 reg &= ~(1 << (bitnr - 8));
555 w83781d_write_value(data, W83781D_REG_BEEP_INTS2, reg);
557 reg = w83781d_read_value(data, W83781D_REG_BEEP_INTS3);
559 reg |= (1 << (bitnr - 16));
561 reg &= ~(1 << (bitnr - 16));
562 w83781d_write_value(data, W83781D_REG_BEEP_INTS3, reg);
564 mutex_unlock(&data->update_lock);
569 /* The W83781D has a single beep bit for temp2 and temp3 */
570 static ssize_t show_temp3_beep(struct device *dev,
571 struct device_attribute *attr, char *buf)
573 struct w83781d_data *data = w83781d_update_device(dev);
574 int bitnr = (data->type == w83781d) ? 5 : 13;
575 return sprintf(buf, "%u\n", (data->beep_mask >> bitnr) & 1);
578 static SENSOR_DEVICE_ATTR(in0_beep, S_IRUGO | S_IWUSR,
579 show_beep, store_beep, 0);
580 static SENSOR_DEVICE_ATTR(in1_beep, S_IRUGO | S_IWUSR,
581 show_beep, store_beep, 1);
582 static SENSOR_DEVICE_ATTR(in2_beep, S_IRUGO | S_IWUSR,
583 show_beep, store_beep, 2);
584 static SENSOR_DEVICE_ATTR(in3_beep, S_IRUGO | S_IWUSR,
585 show_beep, store_beep, 3);
586 static SENSOR_DEVICE_ATTR(in4_beep, S_IRUGO | S_IWUSR,
587 show_beep, store_beep, 8);
588 static SENSOR_DEVICE_ATTR(in5_beep, S_IRUGO | S_IWUSR,
589 show_beep, store_beep, 9);
590 static SENSOR_DEVICE_ATTR(in6_beep, S_IRUGO | S_IWUSR,
591 show_beep, store_beep, 10);
592 static SENSOR_DEVICE_ATTR(in7_beep, S_IRUGO | S_IWUSR,
593 show_beep, store_beep, 16);
594 static SENSOR_DEVICE_ATTR(in8_beep, S_IRUGO | S_IWUSR,
595 show_beep, store_beep, 17);
596 static SENSOR_DEVICE_ATTR(fan1_beep, S_IRUGO | S_IWUSR,
597 show_beep, store_beep, 6);
598 static SENSOR_DEVICE_ATTR(fan2_beep, S_IRUGO | S_IWUSR,
599 show_beep, store_beep, 7);
600 static SENSOR_DEVICE_ATTR(fan3_beep, S_IRUGO | S_IWUSR,
601 show_beep, store_beep, 11);
602 static SENSOR_DEVICE_ATTR(temp1_beep, S_IRUGO | S_IWUSR,
603 show_beep, store_beep, 4);
604 static SENSOR_DEVICE_ATTR(temp2_beep, S_IRUGO | S_IWUSR,
605 show_beep, store_beep, 5);
606 static SENSOR_DEVICE_ATTR(temp3_beep, S_IRUGO,
607 show_temp3_beep, store_beep, 13);
608 static SENSOR_DEVICE_ATTR(beep_enable, S_IRUGO | S_IWUSR,
609 show_beep, store_beep, 15);
612 show_fan_div(struct device *dev, struct device_attribute *da, char *buf)
614 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
615 struct w83781d_data *data = w83781d_update_device(dev);
616 return sprintf(buf, "%ld\n",
617 (long) DIV_FROM_REG(data->fan_div[attr->index]));
620 /* Note: we save and restore the fan minimum here, because its value is
621 determined in part by the fan divisor. This follows the principle of
622 least surprise; the user doesn't expect the fan minimum to change just
623 because the divisor changed. */
625 store_fan_div(struct device *dev, struct device_attribute *da,
626 const char *buf, size_t count)
628 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
629 struct w83781d_data *data = dev_get_drvdata(dev);
631 int nr = attr->index;
633 unsigned long val = simple_strtoul(buf, NULL, 10);
635 mutex_lock(&data->update_lock);
638 min = FAN_FROM_REG(data->fan_min[nr],
639 DIV_FROM_REG(data->fan_div[nr]));
641 data->fan_div[nr] = DIV_TO_REG(val, data->type);
643 reg = (w83781d_read_value(data, nr==2 ? W83781D_REG_PIN : W83781D_REG_VID_FANDIV)
644 & (nr==0 ? 0xcf : 0x3f))
645 | ((data->fan_div[nr] & 0x03) << (nr==0 ? 4 : 6));
646 w83781d_write_value(data, nr==2 ? W83781D_REG_PIN : W83781D_REG_VID_FANDIV, reg);
648 /* w83781d and as99127f don't have extended divisor bits */
649 if (data->type != w83781d && data->type != as99127f) {
650 reg = (w83781d_read_value(data, W83781D_REG_VBAT)
652 | ((data->fan_div[nr] & 0x04) << (3 + nr));
653 w83781d_write_value(data, W83781D_REG_VBAT, reg);
656 /* Restore fan_min */
657 data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
658 w83781d_write_value(data, W83781D_REG_FAN_MIN(nr), data->fan_min[nr]);
660 mutex_unlock(&data->update_lock);
664 static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
665 show_fan_div, store_fan_div, 0);
666 static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
667 show_fan_div, store_fan_div, 1);
668 static SENSOR_DEVICE_ATTR(fan3_div, S_IRUGO | S_IWUSR,
669 show_fan_div, store_fan_div, 2);
672 show_pwm(struct device *dev, struct device_attribute *da, char *buf)
674 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
675 struct w83781d_data *data = w83781d_update_device(dev);
676 return sprintf(buf, "%d\n", (int)data->pwm[attr->index]);
680 show_pwm2_enable(struct device *dev, struct device_attribute *da, char *buf)
682 struct w83781d_data *data = w83781d_update_device(dev);
683 return sprintf(buf, "%d\n", (int)data->pwm2_enable);
687 store_pwm(struct device *dev, struct device_attribute *da, const char *buf,
690 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
691 struct w83781d_data *data = dev_get_drvdata(dev);
692 int nr = attr->index;
695 val = simple_strtoul(buf, NULL, 10);
697 mutex_lock(&data->update_lock);
698 data->pwm[nr] = SENSORS_LIMIT(val, 0, 255);
699 w83781d_write_value(data, W83781D_REG_PWM[nr], data->pwm[nr]);
700 mutex_unlock(&data->update_lock);
705 store_pwm2_enable(struct device *dev, struct device_attribute *da,
706 const char *buf, size_t count)
708 struct w83781d_data *data = dev_get_drvdata(dev);
711 val = simple_strtoul(buf, NULL, 10);
713 mutex_lock(&data->update_lock);
718 reg = w83781d_read_value(data, W83781D_REG_PWMCLK12);
719 w83781d_write_value(data, W83781D_REG_PWMCLK12,
720 (reg & 0xf7) | (val << 3));
722 reg = w83781d_read_value(data, W83781D_REG_BEEP_CONFIG);
723 w83781d_write_value(data, W83781D_REG_BEEP_CONFIG,
724 (reg & 0xef) | (!val << 4));
726 data->pwm2_enable = val;
730 mutex_unlock(&data->update_lock);
734 mutex_unlock(&data->update_lock);
738 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, store_pwm, 0);
739 static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, show_pwm, store_pwm, 1);
740 static SENSOR_DEVICE_ATTR(pwm3, S_IRUGO | S_IWUSR, show_pwm, store_pwm, 2);
741 static SENSOR_DEVICE_ATTR(pwm4, S_IRUGO | S_IWUSR, show_pwm, store_pwm, 3);
742 /* only PWM2 can be enabled/disabled */
743 static DEVICE_ATTR(pwm2_enable, S_IRUGO | S_IWUSR,
744 show_pwm2_enable, store_pwm2_enable);
747 show_sensor(struct device *dev, struct device_attribute *da, char *buf)
749 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
750 struct w83781d_data *data = w83781d_update_device(dev);
751 return sprintf(buf, "%d\n", (int)data->sens[attr->index]);
755 store_sensor(struct device *dev, struct device_attribute *da,
756 const char *buf, size_t count)
758 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
759 struct w83781d_data *data = dev_get_drvdata(dev);
760 int nr = attr->index;
763 val = simple_strtoul(buf, NULL, 10);
765 mutex_lock(&data->update_lock);
768 case 1: /* PII/Celeron diode */
769 tmp = w83781d_read_value(data, W83781D_REG_SCFG1);
770 w83781d_write_value(data, W83781D_REG_SCFG1,
771 tmp | BIT_SCFG1[nr]);
772 tmp = w83781d_read_value(data, W83781D_REG_SCFG2);
773 w83781d_write_value(data, W83781D_REG_SCFG2,
774 tmp | BIT_SCFG2[nr]);
775 data->sens[nr] = val;
778 tmp = w83781d_read_value(data, W83781D_REG_SCFG1);
779 w83781d_write_value(data, W83781D_REG_SCFG1,
780 tmp | BIT_SCFG1[nr]);
781 tmp = w83781d_read_value(data, W83781D_REG_SCFG2);
782 w83781d_write_value(data, W83781D_REG_SCFG2,
783 tmp & ~BIT_SCFG2[nr]);
784 data->sens[nr] = val;
786 case W83781D_DEFAULT_BETA:
787 dev_warn(dev, "Sensor type %d is deprecated, please use 4 "
788 "instead\n", W83781D_DEFAULT_BETA);
790 case 4: /* thermistor */
791 tmp = w83781d_read_value(data, W83781D_REG_SCFG1);
792 w83781d_write_value(data, W83781D_REG_SCFG1,
793 tmp & ~BIT_SCFG1[nr]);
794 data->sens[nr] = val;
797 dev_err(dev, "Invalid sensor type %ld; must be 1, 2, or 4\n",
802 mutex_unlock(&data->update_lock);
806 static SENSOR_DEVICE_ATTR(temp1_type, S_IRUGO | S_IWUSR,
807 show_sensor, store_sensor, 0);
808 static SENSOR_DEVICE_ATTR(temp2_type, S_IRUGO | S_IWUSR,
809 show_sensor, store_sensor, 1);
810 static SENSOR_DEVICE_ATTR(temp3_type, S_IRUGO | S_IWUSR,
811 show_sensor, store_sensor, 2);
813 /* Assumes that adapter is of I2C, not ISA variety.
814 * OTHERWISE DON'T CALL THIS
817 w83781d_detect_subclients(struct i2c_client *new_client)
821 int address = new_client->addr;
822 unsigned short sc_addr[2];
823 struct i2c_adapter *adapter = new_client->adapter;
824 struct w83781d_data *data = i2c_get_clientdata(new_client);
825 enum chips kind = data->type;
827 id = i2c_adapter_id(adapter);
829 if (force_subclients[0] == id && force_subclients[1] == address) {
830 for (i = 2; i <= 3; i++) {
831 if (force_subclients[i] < 0x48 ||
832 force_subclients[i] > 0x4f) {
833 dev_err(&new_client->dev, "Invalid subclient "
834 "address %d; must be 0x48-0x4f\n",
835 force_subclients[i]);
840 w83781d_write_value(data, W83781D_REG_I2C_SUBADDR,
841 (force_subclients[2] & 0x07) |
842 ((force_subclients[3] & 0x07) << 4));
843 sc_addr[0] = force_subclients[2];
845 val1 = w83781d_read_value(data, W83781D_REG_I2C_SUBADDR);
846 sc_addr[0] = 0x48 + (val1 & 0x07);
849 if (kind != w83783s) {
850 if (force_subclients[0] == id &&
851 force_subclients[1] == address) {
852 sc_addr[1] = force_subclients[3];
854 sc_addr[1] = 0x48 + ((val1 >> 4) & 0x07);
856 if (sc_addr[0] == sc_addr[1]) {
857 dev_err(&new_client->dev,
858 "Duplicate addresses 0x%x for subclients.\n",
865 for (i = 0; i <= 1; i++) {
866 data->lm75[i] = i2c_new_dummy(adapter, sc_addr[i]);
867 if (!data->lm75[i]) {
868 dev_err(&new_client->dev, "Subclient %d "
869 "registration at address 0x%x "
870 "failed.\n", i, sc_addr[i]);
882 /* Undo inits in case of errors */
884 i2c_unregister_device(data->lm75[0]);
890 #define IN_UNIT_ATTRS(X) \
891 &sensor_dev_attr_in##X##_input.dev_attr.attr, \
892 &sensor_dev_attr_in##X##_min.dev_attr.attr, \
893 &sensor_dev_attr_in##X##_max.dev_attr.attr, \
894 &sensor_dev_attr_in##X##_alarm.dev_attr.attr, \
895 &sensor_dev_attr_in##X##_beep.dev_attr.attr
897 #define FAN_UNIT_ATTRS(X) \
898 &sensor_dev_attr_fan##X##_input.dev_attr.attr, \
899 &sensor_dev_attr_fan##X##_min.dev_attr.attr, \
900 &sensor_dev_attr_fan##X##_div.dev_attr.attr, \
901 &sensor_dev_attr_fan##X##_alarm.dev_attr.attr, \
902 &sensor_dev_attr_fan##X##_beep.dev_attr.attr
904 #define TEMP_UNIT_ATTRS(X) \
905 &sensor_dev_attr_temp##X##_input.dev_attr.attr, \
906 &sensor_dev_attr_temp##X##_max.dev_attr.attr, \
907 &sensor_dev_attr_temp##X##_max_hyst.dev_attr.attr, \
908 &sensor_dev_attr_temp##X##_alarm.dev_attr.attr, \
909 &sensor_dev_attr_temp##X##_beep.dev_attr.attr
911 static struct attribute* w83781d_attributes[] = {
923 &dev_attr_cpu0_vid.attr,
925 &dev_attr_alarms.attr,
926 &dev_attr_beep_mask.attr,
927 &sensor_dev_attr_beep_enable.dev_attr.attr,
930 static const struct attribute_group w83781d_group = {
931 .attrs = w83781d_attributes,
934 static struct attribute *w83781d_attributes_opt[] = {
939 &sensor_dev_attr_pwm1.dev_attr.attr,
940 &sensor_dev_attr_pwm2.dev_attr.attr,
941 &sensor_dev_attr_pwm3.dev_attr.attr,
942 &sensor_dev_attr_pwm4.dev_attr.attr,
943 &dev_attr_pwm2_enable.attr,
944 &sensor_dev_attr_temp1_type.dev_attr.attr,
945 &sensor_dev_attr_temp2_type.dev_attr.attr,
946 &sensor_dev_attr_temp3_type.dev_attr.attr,
949 static const struct attribute_group w83781d_group_opt = {
950 .attrs = w83781d_attributes_opt,
953 /* No clean up is done on error, it's up to the caller */
955 w83781d_create_files(struct device *dev, int kind, int is_isa)
959 if ((err = sysfs_create_group(&dev->kobj, &w83781d_group)))
962 if (kind != w83783s) {
963 if ((err = device_create_file(dev,
964 &sensor_dev_attr_in1_input.dev_attr))
965 || (err = device_create_file(dev,
966 &sensor_dev_attr_in1_min.dev_attr))
967 || (err = device_create_file(dev,
968 &sensor_dev_attr_in1_max.dev_attr))
969 || (err = device_create_file(dev,
970 &sensor_dev_attr_in1_alarm.dev_attr))
971 || (err = device_create_file(dev,
972 &sensor_dev_attr_in1_beep.dev_attr)))
975 if (kind != as99127f && kind != w83781d && kind != w83783s) {
976 if ((err = device_create_file(dev,
977 &sensor_dev_attr_in7_input.dev_attr))
978 || (err = device_create_file(dev,
979 &sensor_dev_attr_in7_min.dev_attr))
980 || (err = device_create_file(dev,
981 &sensor_dev_attr_in7_max.dev_attr))
982 || (err = device_create_file(dev,
983 &sensor_dev_attr_in7_alarm.dev_attr))
984 || (err = device_create_file(dev,
985 &sensor_dev_attr_in7_beep.dev_attr))
986 || (err = device_create_file(dev,
987 &sensor_dev_attr_in8_input.dev_attr))
988 || (err = device_create_file(dev,
989 &sensor_dev_attr_in8_min.dev_attr))
990 || (err = device_create_file(dev,
991 &sensor_dev_attr_in8_max.dev_attr))
992 || (err = device_create_file(dev,
993 &sensor_dev_attr_in8_alarm.dev_attr))
994 || (err = device_create_file(dev,
995 &sensor_dev_attr_in8_beep.dev_attr)))
998 if (kind != w83783s) {
999 if ((err = device_create_file(dev,
1000 &sensor_dev_attr_temp3_input.dev_attr))
1001 || (err = device_create_file(dev,
1002 &sensor_dev_attr_temp3_max.dev_attr))
1003 || (err = device_create_file(dev,
1004 &sensor_dev_attr_temp3_max_hyst.dev_attr))
1005 || (err = device_create_file(dev,
1006 &sensor_dev_attr_temp3_alarm.dev_attr))
1007 || (err = device_create_file(dev,
1008 &sensor_dev_attr_temp3_beep.dev_attr)))
1011 if (kind != w83781d) {
1012 err = sysfs_chmod_file(&dev->kobj,
1013 &sensor_dev_attr_temp3_alarm.dev_attr.attr,
1020 if (kind != w83781d && kind != as99127f) {
1021 if ((err = device_create_file(dev,
1022 &sensor_dev_attr_pwm1.dev_attr))
1023 || (err = device_create_file(dev,
1024 &sensor_dev_attr_pwm2.dev_attr))
1025 || (err = device_create_file(dev, &dev_attr_pwm2_enable)))
1028 if (kind == w83782d && !is_isa) {
1029 if ((err = device_create_file(dev,
1030 &sensor_dev_attr_pwm3.dev_attr))
1031 || (err = device_create_file(dev,
1032 &sensor_dev_attr_pwm4.dev_attr)))
1036 if (kind != as99127f && kind != w83781d) {
1037 if ((err = device_create_file(dev,
1038 &sensor_dev_attr_temp1_type.dev_attr))
1039 || (err = device_create_file(dev,
1040 &sensor_dev_attr_temp2_type.dev_attr)))
1042 if (kind != w83783s) {
1043 if ((err = device_create_file(dev,
1044 &sensor_dev_attr_temp3_type.dev_attr)))
1052 /* Return 0 if detection is successful, -ENODEV otherwise */
1054 w83781d_detect(struct i2c_client *client, struct i2c_board_info *info)
1057 struct w83781d_data *isa = w83781d_data_if_isa();
1058 struct i2c_adapter *adapter = client->adapter;
1059 int address = client->addr;
1060 const char *client_name;
1061 enum vendor { winbond, asus } vendid;
1063 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1066 /* We block updates of the ISA device to minimize the risk of
1067 concurrent access to the same W83781D chip through different
1070 mutex_lock(&isa->update_lock);
1072 if (i2c_smbus_read_byte_data(client, W83781D_REG_CONFIG) & 0x80) {
1073 dev_dbg(&adapter->dev,
1074 "Detection of w83781d chip failed at step 3\n");
1078 val1 = i2c_smbus_read_byte_data(client, W83781D_REG_BANK);
1079 val2 = i2c_smbus_read_byte_data(client, W83781D_REG_CHIPMAN);
1080 /* Check for Winbond or Asus ID if in bank 0 */
1081 if (!(val1 & 0x07) &&
1082 ((!(val1 & 0x80) && val2 != 0xa3 && val2 != 0xc3) ||
1083 ( (val1 & 0x80) && val2 != 0x5c && val2 != 0x12))) {
1084 dev_dbg(&adapter->dev,
1085 "Detection of w83781d chip failed at step 4\n");
1088 /* If Winbond SMBus, check address at 0x48.
1089 Asus doesn't support, except for as99127f rev.2 */
1090 if ((!(val1 & 0x80) && val2 == 0xa3) ||
1091 ( (val1 & 0x80) && val2 == 0x5c)) {
1092 if (i2c_smbus_read_byte_data(client, W83781D_REG_I2C_ADDR)
1094 dev_dbg(&adapter->dev,
1095 "Detection of w83781d chip failed at step 5\n");
1100 /* Put it now into bank 0 and Vendor ID High Byte */
1101 i2c_smbus_write_byte_data(client, W83781D_REG_BANK,
1102 (i2c_smbus_read_byte_data(client, W83781D_REG_BANK)
1105 /* Get the vendor ID */
1106 val2 = i2c_smbus_read_byte_data(client, W83781D_REG_CHIPMAN);
1109 else if (val2 == 0x12)
1112 dev_dbg(&adapter->dev,
1113 "w83781d chip vendor is neither Winbond nor Asus\n");
1117 /* Determine the chip type. */
1118 val1 = i2c_smbus_read_byte_data(client, W83781D_REG_WCHIPID);
1119 if ((val1 == 0x10 || val1 == 0x11) && vendid == winbond)
1120 client_name = "w83781d";
1121 else if (val1 == 0x30 && vendid == winbond)
1122 client_name = "w83782d";
1123 else if (val1 == 0x40 && vendid == winbond && address == 0x2d)
1124 client_name = "w83783s";
1125 else if (val1 == 0x31)
1126 client_name = "as99127f";
1130 if (val1 <= 0x30 && w83781d_alias_detect(client, val1)) {
1131 dev_dbg(&adapter->dev, "Device at 0x%02x appears to "
1132 "be the same as ISA device\n", address);
1137 mutex_unlock(&isa->update_lock);
1139 strlcpy(info->type, client_name, I2C_NAME_SIZE);
1145 mutex_unlock(&isa->update_lock);
1150 w83781d_probe(struct i2c_client *client, const struct i2c_device_id *id)
1152 struct device *dev = &client->dev;
1153 struct w83781d_data *data;
1156 data = kzalloc(sizeof(struct w83781d_data), GFP_KERNEL);
1162 i2c_set_clientdata(client, data);
1163 mutex_init(&data->lock);
1164 mutex_init(&data->update_lock);
1166 data->type = id->driver_data;
1167 data->client = client;
1169 /* attach secondary i2c lm75-like clients */
1170 err = w83781d_detect_subclients(client);
1174 /* Initialize the chip */
1175 w83781d_init_device(dev);
1177 /* Register sysfs hooks */
1178 err = w83781d_create_files(dev, data->type, 0);
1182 data->hwmon_dev = hwmon_device_register(dev);
1183 if (IS_ERR(data->hwmon_dev)) {
1184 err = PTR_ERR(data->hwmon_dev);
1191 sysfs_remove_group(&dev->kobj, &w83781d_group);
1192 sysfs_remove_group(&dev->kobj, &w83781d_group_opt);
1195 i2c_unregister_device(data->lm75[0]);
1197 i2c_unregister_device(data->lm75[1]);
1199 i2c_set_clientdata(client, NULL);
1206 w83781d_remove(struct i2c_client *client)
1208 struct w83781d_data *data = i2c_get_clientdata(client);
1209 struct device *dev = &client->dev;
1211 hwmon_device_unregister(data->hwmon_dev);
1213 sysfs_remove_group(&dev->kobj, &w83781d_group);
1214 sysfs_remove_group(&dev->kobj, &w83781d_group_opt);
1217 i2c_unregister_device(data->lm75[0]);
1219 i2c_unregister_device(data->lm75[1]);
1221 i2c_set_clientdata(client, NULL);
1228 w83781d_read_value_i2c(struct w83781d_data *data, u16 reg)
1230 struct i2c_client *client = data->client;
1232 struct i2c_client *cl;
1234 bank = (reg >> 8) & 0x0f;
1237 i2c_smbus_write_byte_data(client, W83781D_REG_BANK,
1239 if (bank == 0 || bank > 2) {
1240 res = i2c_smbus_read_byte_data(client, reg & 0xff);
1242 /* switch to subclient */
1243 cl = data->lm75[bank - 1];
1244 /* convert from ISA to LM75 I2C addresses */
1245 switch (reg & 0xff) {
1246 case 0x50: /* TEMP */
1247 res = swab16(i2c_smbus_read_word_data(cl, 0));
1249 case 0x52: /* CONFIG */
1250 res = i2c_smbus_read_byte_data(cl, 1);
1252 case 0x53: /* HYST */
1253 res = swab16(i2c_smbus_read_word_data(cl, 2));
1255 case 0x55: /* OVER */
1257 res = swab16(i2c_smbus_read_word_data(cl, 3));
1262 i2c_smbus_write_byte_data(client, W83781D_REG_BANK, 0);
1268 w83781d_write_value_i2c(struct w83781d_data *data, u16 reg, u16 value)
1270 struct i2c_client *client = data->client;
1272 struct i2c_client *cl;
1274 bank = (reg >> 8) & 0x0f;
1277 i2c_smbus_write_byte_data(client, W83781D_REG_BANK,
1279 if (bank == 0 || bank > 2) {
1280 i2c_smbus_write_byte_data(client, reg & 0xff,
1283 /* switch to subclient */
1284 cl = data->lm75[bank - 1];
1285 /* convert from ISA to LM75 I2C addresses */
1286 switch (reg & 0xff) {
1287 case 0x52: /* CONFIG */
1288 i2c_smbus_write_byte_data(cl, 1, value & 0xff);
1290 case 0x53: /* HYST */
1291 i2c_smbus_write_word_data(cl, 2, swab16(value));
1293 case 0x55: /* OVER */
1294 i2c_smbus_write_word_data(cl, 3, swab16(value));
1299 i2c_smbus_write_byte_data(client, W83781D_REG_BANK, 0);
1305 w83781d_init_device(struct device *dev)
1307 struct w83781d_data *data = dev_get_drvdata(dev);
1309 int type = data->type;
1312 if (reset && type != as99127f) { /* this resets registers we don't have
1313 documentation for on the as99127f */
1314 /* Resetting the chip has been the default for a long time,
1315 but it causes the BIOS initializations (fan clock dividers,
1316 thermal sensor types...) to be lost, so it is now optional.
1317 It might even go away if nobody reports it as being useful,
1318 as I see very little reason why this would be needed at
1320 dev_info(dev, "If reset=1 solved a problem you were "
1321 "having, please report!\n");
1323 /* save these registers */
1324 i = w83781d_read_value(data, W83781D_REG_BEEP_CONFIG);
1325 p = w83781d_read_value(data, W83781D_REG_PWMCLK12);
1326 /* Reset all except Watchdog values and last conversion values
1327 This sets fan-divs to 2, among others */
1328 w83781d_write_value(data, W83781D_REG_CONFIG, 0x80);
1329 /* Restore the registers and disable power-on abnormal beep.
1330 This saves FAN 1/2/3 input/output values set by BIOS. */
1331 w83781d_write_value(data, W83781D_REG_BEEP_CONFIG, i | 0x80);
1332 w83781d_write_value(data, W83781D_REG_PWMCLK12, p);
1333 /* Disable master beep-enable (reset turns it on).
1334 Individual beep_mask should be reset to off but for some reason
1335 disabling this bit helps some people not get beeped */
1336 w83781d_write_value(data, W83781D_REG_BEEP_INTS2, 0);
1339 /* Disable power-on abnormal beep, as advised by the datasheet.
1340 Already done if reset=1. */
1341 if (init && !reset && type != as99127f) {
1342 i = w83781d_read_value(data, W83781D_REG_BEEP_CONFIG);
1343 w83781d_write_value(data, W83781D_REG_BEEP_CONFIG, i | 0x80);
1346 data->vrm = vid_which_vrm();
1348 if ((type != w83781d) && (type != as99127f)) {
1349 tmp = w83781d_read_value(data, W83781D_REG_SCFG1);
1350 for (i = 1; i <= 3; i++) {
1351 if (!(tmp & BIT_SCFG1[i - 1])) {
1352 data->sens[i - 1] = 4;
1354 if (w83781d_read_value
1356 W83781D_REG_SCFG2) & BIT_SCFG2[i - 1])
1357 data->sens[i - 1] = 1;
1359 data->sens[i - 1] = 2;
1361 if (type == w83783s && i == 2)
1366 if (init && type != as99127f) {
1368 tmp = w83781d_read_value(data, W83781D_REG_TEMP2_CONFIG);
1370 dev_warn(dev, "Enabling temp2, readings "
1371 "might not make sense\n");
1372 w83781d_write_value(data, W83781D_REG_TEMP2_CONFIG,
1377 if (type != w83783s) {
1378 tmp = w83781d_read_value(data,
1379 W83781D_REG_TEMP3_CONFIG);
1381 dev_warn(dev, "Enabling temp3, "
1382 "readings might not make sense\n");
1383 w83781d_write_value(data,
1384 W83781D_REG_TEMP3_CONFIG, tmp & 0xfe);
1389 /* Start monitoring */
1390 w83781d_write_value(data, W83781D_REG_CONFIG,
1391 (w83781d_read_value(data,
1392 W83781D_REG_CONFIG) & 0xf7)
1395 /* A few vars need to be filled upon startup */
1396 for (i = 0; i < 3; i++) {
1397 data->fan_min[i] = w83781d_read_value(data,
1398 W83781D_REG_FAN_MIN(i));
1401 mutex_init(&data->update_lock);
1404 static struct w83781d_data *w83781d_update_device(struct device *dev)
1406 struct w83781d_data *data = dev_get_drvdata(dev);
1407 struct i2c_client *client = data->client;
1410 mutex_lock(&data->update_lock);
1412 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1414 dev_dbg(dev, "Starting device update\n");
1416 for (i = 0; i <= 8; i++) {
1417 if (data->type == w83783s && i == 1)
1418 continue; /* 783S has no in1 */
1420 w83781d_read_value(data, W83781D_REG_IN(i));
1422 w83781d_read_value(data, W83781D_REG_IN_MIN(i));
1424 w83781d_read_value(data, W83781D_REG_IN_MAX(i));
1425 if ((data->type != w83782d) && (i == 6))
1428 for (i = 0; i < 3; i++) {
1430 w83781d_read_value(data, W83781D_REG_FAN(i));
1432 w83781d_read_value(data, W83781D_REG_FAN_MIN(i));
1434 if (data->type != w83781d && data->type != as99127f) {
1435 for (i = 0; i < 4; i++) {
1437 w83781d_read_value(data,
1438 W83781D_REG_PWM[i]);
1439 /* Only W83782D on SMBus has PWM3 and PWM4 */
1440 if ((data->type != w83782d || !client)
1444 /* Only PWM2 can be disabled */
1445 data->pwm2_enable = (w83781d_read_value(data,
1446 W83781D_REG_PWMCLK12) & 0x08) >> 3;
1449 data->temp = w83781d_read_value(data, W83781D_REG_TEMP(1));
1451 w83781d_read_value(data, W83781D_REG_TEMP_OVER(1));
1452 data->temp_max_hyst =
1453 w83781d_read_value(data, W83781D_REG_TEMP_HYST(1));
1455 w83781d_read_value(data, W83781D_REG_TEMP(2));
1456 data->temp_max_add[0] =
1457 w83781d_read_value(data, W83781D_REG_TEMP_OVER(2));
1458 data->temp_max_hyst_add[0] =
1459 w83781d_read_value(data, W83781D_REG_TEMP_HYST(2));
1460 if (data->type != w83783s) {
1462 w83781d_read_value(data, W83781D_REG_TEMP(3));
1463 data->temp_max_add[1] =
1464 w83781d_read_value(data,
1465 W83781D_REG_TEMP_OVER(3));
1466 data->temp_max_hyst_add[1] =
1467 w83781d_read_value(data,
1468 W83781D_REG_TEMP_HYST(3));
1470 i = w83781d_read_value(data, W83781D_REG_VID_FANDIV);
1471 data->vid = i & 0x0f;
1472 data->vid |= (w83781d_read_value(data,
1473 W83781D_REG_CHIPID) & 0x01) << 4;
1474 data->fan_div[0] = (i >> 4) & 0x03;
1475 data->fan_div[1] = (i >> 6) & 0x03;
1476 data->fan_div[2] = (w83781d_read_value(data,
1477 W83781D_REG_PIN) >> 6) & 0x03;
1478 if ((data->type != w83781d) && (data->type != as99127f)) {
1479 i = w83781d_read_value(data, W83781D_REG_VBAT);
1480 data->fan_div[0] |= (i >> 3) & 0x04;
1481 data->fan_div[1] |= (i >> 4) & 0x04;
1482 data->fan_div[2] |= (i >> 5) & 0x04;
1484 if (data->type == w83782d) {
1485 data->alarms = w83781d_read_value(data,
1487 | (w83781d_read_value(data,
1488 W83782D_REG_ALARM2) << 8)
1489 | (w83781d_read_value(data,
1490 W83782D_REG_ALARM3) << 16);
1491 } else if (data->type == w83783s) {
1492 data->alarms = w83781d_read_value(data,
1494 | (w83781d_read_value(data,
1495 W83782D_REG_ALARM2) << 8);
1497 /* No real-time status registers, fall back to
1498 interrupt status registers */
1499 data->alarms = w83781d_read_value(data,
1501 | (w83781d_read_value(data,
1502 W83781D_REG_ALARM2) << 8);
1504 i = w83781d_read_value(data, W83781D_REG_BEEP_INTS2);
1505 data->beep_mask = (i << 8) +
1506 w83781d_read_value(data, W83781D_REG_BEEP_INTS1);
1507 if ((data->type != w83781d) && (data->type != as99127f)) {
1509 w83781d_read_value(data,
1510 W83781D_REG_BEEP_INTS3) << 16;
1512 data->last_updated = jiffies;
1516 mutex_unlock(&data->update_lock);
1521 static const struct i2c_device_id w83781d_ids[] = {
1522 { "w83781d", w83781d, },
1523 { "w83782d", w83782d, },
1524 { "w83783s", w83783s, },
1525 { "as99127f", as99127f },
1528 MODULE_DEVICE_TABLE(i2c, w83781d_ids);
1530 static struct i2c_driver w83781d_driver = {
1531 .class = I2C_CLASS_HWMON,
1535 .probe = w83781d_probe,
1536 .remove = w83781d_remove,
1537 .id_table = w83781d_ids,
1538 .detect = w83781d_detect,
1539 .address_list = normal_i2c,
1547 /* ISA device, if found */
1548 static struct platform_device *pdev;
1550 static unsigned short isa_address = 0x290;
1552 /* I2C devices get this name attribute automatically, but for ISA devices
1553 we must create it by ourselves. */
1555 show_name(struct device *dev, struct device_attribute *devattr, char *buf)
1557 struct w83781d_data *data = dev_get_drvdata(dev);
1558 return sprintf(buf, "%s\n", data->name);
1560 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
1562 static struct w83781d_data *w83781d_data_if_isa(void)
1564 return pdev ? platform_get_drvdata(pdev) : NULL;
1567 /* Returns 1 if the I2C chip appears to be an alias of the ISA chip */
1568 static int w83781d_alias_detect(struct i2c_client *client, u8 chipid)
1570 struct w83781d_data *isa;
1573 if (!pdev) /* No ISA chip */
1576 isa = platform_get_drvdata(pdev);
1578 if (w83781d_read_value(isa, W83781D_REG_I2C_ADDR) != client->addr)
1579 return 0; /* Address doesn't match */
1580 if (w83781d_read_value(isa, W83781D_REG_WCHIPID) != chipid)
1581 return 0; /* Chip type doesn't match */
1583 /* We compare all the limit registers, the config register and the
1584 * interrupt mask registers */
1585 for (i = 0x2b; i <= 0x3d; i++) {
1586 if (w83781d_read_value(isa, i) !=
1587 i2c_smbus_read_byte_data(client, i))
1590 if (w83781d_read_value(isa, W83781D_REG_CONFIG) !=
1591 i2c_smbus_read_byte_data(client, W83781D_REG_CONFIG))
1593 for (i = 0x43; i <= 0x46; i++) {
1594 if (w83781d_read_value(isa, i) !=
1595 i2c_smbus_read_byte_data(client, i))
1603 w83781d_read_value_isa(struct w83781d_data *data, u16 reg)
1605 int word_sized, res;
1607 word_sized = (((reg & 0xff00) == 0x100)
1608 || ((reg & 0xff00) == 0x200))
1609 && (((reg & 0x00ff) == 0x50)
1610 || ((reg & 0x00ff) == 0x53)
1611 || ((reg & 0x00ff) == 0x55));
1613 outb_p(W83781D_REG_BANK,
1614 data->isa_addr + W83781D_ADDR_REG_OFFSET);
1616 data->isa_addr + W83781D_DATA_REG_OFFSET);
1618 outb_p(reg & 0xff, data->isa_addr + W83781D_ADDR_REG_OFFSET);
1619 res = inb_p(data->isa_addr + W83781D_DATA_REG_OFFSET);
1621 outb_p((reg & 0xff) + 1,
1622 data->isa_addr + W83781D_ADDR_REG_OFFSET);
1624 (res << 8) + inb_p(data->isa_addr +
1625 W83781D_DATA_REG_OFFSET);
1628 outb_p(W83781D_REG_BANK,
1629 data->isa_addr + W83781D_ADDR_REG_OFFSET);
1630 outb_p(0, data->isa_addr + W83781D_DATA_REG_OFFSET);
1636 w83781d_write_value_isa(struct w83781d_data *data, u16 reg, u16 value)
1640 word_sized = (((reg & 0xff00) == 0x100)
1641 || ((reg & 0xff00) == 0x200))
1642 && (((reg & 0x00ff) == 0x53)
1643 || ((reg & 0x00ff) == 0x55));
1645 outb_p(W83781D_REG_BANK,
1646 data->isa_addr + W83781D_ADDR_REG_OFFSET);
1648 data->isa_addr + W83781D_DATA_REG_OFFSET);
1650 outb_p(reg & 0xff, data->isa_addr + W83781D_ADDR_REG_OFFSET);
1653 data->isa_addr + W83781D_DATA_REG_OFFSET);
1654 outb_p((reg & 0xff) + 1,
1655 data->isa_addr + W83781D_ADDR_REG_OFFSET);
1657 outb_p(value & 0xff, data->isa_addr + W83781D_DATA_REG_OFFSET);
1659 outb_p(W83781D_REG_BANK,
1660 data->isa_addr + W83781D_ADDR_REG_OFFSET);
1661 outb_p(0, data->isa_addr + W83781D_DATA_REG_OFFSET);
1665 /* The SMBus locks itself, usually, but nothing may access the Winbond between
1666 bank switches. ISA access must always be locked explicitly!
1667 We ignore the W83781D BUSY flag at this moment - it could lead to deadlocks,
1668 would slow down the W83781D access and should not be necessary.
1669 There are some ugly typecasts here, but the good news is - they should
1670 nowhere else be necessary! */
1672 w83781d_read_value(struct w83781d_data *data, u16 reg)
1674 struct i2c_client *client = data->client;
1677 mutex_lock(&data->lock);
1679 res = w83781d_read_value_i2c(data, reg);
1681 res = w83781d_read_value_isa(data, reg);
1682 mutex_unlock(&data->lock);
1687 w83781d_write_value(struct w83781d_data *data, u16 reg, u16 value)
1689 struct i2c_client *client = data->client;
1691 mutex_lock(&data->lock);
1693 w83781d_write_value_i2c(data, reg, value);
1695 w83781d_write_value_isa(data, reg, value);
1696 mutex_unlock(&data->lock);
1700 static int __devinit
1701 w83781d_isa_probe(struct platform_device *pdev)
1704 struct w83781d_data *data;
1705 struct resource *res;
1707 /* Reserve the ISA region */
1708 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1709 if (!request_region(res->start + W83781D_ADDR_REG_OFFSET, 2,
1715 data = kzalloc(sizeof(struct w83781d_data), GFP_KERNEL);
1718 goto exit_release_region;
1720 mutex_init(&data->lock);
1721 data->isa_addr = res->start;
1722 platform_set_drvdata(pdev, data);
1724 reg = w83781d_read_value(data, W83781D_REG_WCHIPID);
1727 data->type = w83782d;
1728 data->name = "w83782d";
1731 data->type = w83781d;
1732 data->name = "w83781d";
1735 /* Initialize the W83781D chip */
1736 w83781d_init_device(&pdev->dev);
1738 /* Register sysfs hooks */
1739 err = w83781d_create_files(&pdev->dev, data->type, 1);
1741 goto exit_remove_files;
1743 err = device_create_file(&pdev->dev, &dev_attr_name);
1745 goto exit_remove_files;
1747 data->hwmon_dev = hwmon_device_register(&pdev->dev);
1748 if (IS_ERR(data->hwmon_dev)) {
1749 err = PTR_ERR(data->hwmon_dev);
1750 goto exit_remove_files;
1756 sysfs_remove_group(&pdev->dev.kobj, &w83781d_group);
1757 sysfs_remove_group(&pdev->dev.kobj, &w83781d_group_opt);
1758 device_remove_file(&pdev->dev, &dev_attr_name);
1760 exit_release_region:
1761 release_region(res->start + W83781D_ADDR_REG_OFFSET, 2);
1766 static int __devexit
1767 w83781d_isa_remove(struct platform_device *pdev)
1769 struct w83781d_data *data = platform_get_drvdata(pdev);
1771 hwmon_device_unregister(data->hwmon_dev);
1772 sysfs_remove_group(&pdev->dev.kobj, &w83781d_group);
1773 sysfs_remove_group(&pdev->dev.kobj, &w83781d_group_opt);
1774 device_remove_file(&pdev->dev, &dev_attr_name);
1775 release_region(data->isa_addr + W83781D_ADDR_REG_OFFSET, 2);
1781 static struct platform_driver w83781d_isa_driver = {
1783 .owner = THIS_MODULE,
1786 .probe = w83781d_isa_probe,
1787 .remove = __devexit_p(w83781d_isa_remove),
1790 /* return 1 if a supported chip is found, 0 otherwise */
1792 w83781d_isa_found(unsigned short address)
1794 int val, save, found = 0;
1796 /* We have to request the region in two parts because some
1797 boards declare base+4 to base+7 as a PNP device */
1798 if (!request_region(address, 4, "w83781d")) {
1799 pr_debug("w83781d: Failed to request low part of region\n");
1802 if (!request_region(address + 4, 4, "w83781d")) {
1803 pr_debug("w83781d: Failed to request high part of region\n");
1804 release_region(address, 4);
1808 #define REALLY_SLOW_IO
1809 /* We need the timeouts for at least some W83781D-like
1810 chips. But only if we read 'undefined' registers. */
1811 val = inb_p(address + 1);
1812 if (inb_p(address + 2) != val
1813 || inb_p(address + 3) != val
1814 || inb_p(address + 7) != val) {
1815 pr_debug("w83781d: Detection failed at step 1\n");
1818 #undef REALLY_SLOW_IO
1820 /* We should be able to change the 7 LSB of the address port. The
1821 MSB (busy flag) should be clear initially, set after the write. */
1822 save = inb_p(address + W83781D_ADDR_REG_OFFSET);
1824 pr_debug("w83781d: Detection failed at step 2\n");
1828 outb_p(val, address + W83781D_ADDR_REG_OFFSET);
1829 if (inb_p(address + W83781D_ADDR_REG_OFFSET) != (val | 0x80)) {
1830 outb_p(save, address + W83781D_ADDR_REG_OFFSET);
1831 pr_debug("w83781d: Detection failed at step 3\n");
1835 /* We found a device, now see if it could be a W83781D */
1836 outb_p(W83781D_REG_CONFIG, address + W83781D_ADDR_REG_OFFSET);
1837 val = inb_p(address + W83781D_DATA_REG_OFFSET);
1839 pr_debug("w83781d: Detection failed at step 4\n");
1842 outb_p(W83781D_REG_BANK, address + W83781D_ADDR_REG_OFFSET);
1843 save = inb_p(address + W83781D_DATA_REG_OFFSET);
1844 outb_p(W83781D_REG_CHIPMAN, address + W83781D_ADDR_REG_OFFSET);
1845 val = inb_p(address + W83781D_DATA_REG_OFFSET);
1846 if ((!(save & 0x80) && (val != 0xa3))
1847 || ((save & 0x80) && (val != 0x5c))) {
1848 pr_debug("w83781d: Detection failed at step 5\n");
1851 outb_p(W83781D_REG_I2C_ADDR, address + W83781D_ADDR_REG_OFFSET);
1852 val = inb_p(address + W83781D_DATA_REG_OFFSET);
1853 if (val < 0x03 || val > 0x77) { /* Not a valid I2C address */
1854 pr_debug("w83781d: Detection failed at step 6\n");
1858 /* The busy flag should be clear again */
1859 if (inb_p(address + W83781D_ADDR_REG_OFFSET) & 0x80) {
1860 pr_debug("w83781d: Detection failed at step 7\n");
1864 /* Determine the chip type */
1865 outb_p(W83781D_REG_BANK, address + W83781D_ADDR_REG_OFFSET);
1866 save = inb_p(address + W83781D_DATA_REG_OFFSET);
1867 outb_p(save & 0xf8, address + W83781D_DATA_REG_OFFSET);
1868 outb_p(W83781D_REG_WCHIPID, address + W83781D_ADDR_REG_OFFSET);
1869 val = inb_p(address + W83781D_DATA_REG_OFFSET);
1870 if ((val & 0xfe) == 0x10 /* W83781D */
1871 || val == 0x30) /* W83782D */
1875 pr_info("w83781d: Found a %s chip at %#x\n",
1876 val == 0x30 ? "W83782D" : "W83781D", (int)address);
1879 release_region(address + 4, 4);
1880 release_region(address, 4);
1885 w83781d_isa_device_add(unsigned short address)
1887 struct resource res = {
1889 .end = address + W83781D_EXTENT - 1,
1891 .flags = IORESOURCE_IO,
1895 pdev = platform_device_alloc("w83781d", address);
1898 printk(KERN_ERR "w83781d: Device allocation failed\n");
1902 err = platform_device_add_resources(pdev, &res, 1);
1904 printk(KERN_ERR "w83781d: Device resource addition failed "
1906 goto exit_device_put;
1909 err = platform_device_add(pdev);
1911 printk(KERN_ERR "w83781d: Device addition failed (%d)\n",
1913 goto exit_device_put;
1919 platform_device_put(pdev);
1926 w83781d_isa_register(void)
1930 if (w83781d_isa_found(isa_address)) {
1931 res = platform_driver_register(&w83781d_isa_driver);
1935 /* Sets global pdev as a side effect */
1936 res = w83781d_isa_device_add(isa_address);
1938 goto exit_unreg_isa_driver;
1943 exit_unreg_isa_driver:
1944 platform_driver_unregister(&w83781d_isa_driver);
1950 w83781d_isa_unregister(void)
1953 platform_device_unregister(pdev);
1954 platform_driver_unregister(&w83781d_isa_driver);
1957 #else /* !CONFIG_ISA */
1959 static struct w83781d_data *w83781d_data_if_isa(void)
1965 w83781d_alias_detect(struct i2c_client *client, u8 chipid)
1971 w83781d_read_value(struct w83781d_data *data, u16 reg)
1975 mutex_lock(&data->lock);
1976 res = w83781d_read_value_i2c(data, reg);
1977 mutex_unlock(&data->lock);
1983 w83781d_write_value(struct w83781d_data *data, u16 reg, u16 value)
1985 mutex_lock(&data->lock);
1986 w83781d_write_value_i2c(data, reg, value);
1987 mutex_unlock(&data->lock);
1993 w83781d_isa_register(void)
1999 w83781d_isa_unregister(void)
2002 #endif /* CONFIG_ISA */
2005 sensors_w83781d_init(void)
2009 /* We register the ISA device first, so that we can skip the
2010 * registration of an I2C interface to the same device. */
2011 res = w83781d_isa_register();
2015 res = i2c_add_driver(&w83781d_driver);
2017 goto exit_unreg_isa;
2022 w83781d_isa_unregister();
2028 sensors_w83781d_exit(void)
2030 w83781d_isa_unregister();
2031 i2c_del_driver(&w83781d_driver);
2034 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
2035 "Philip Edelbrock <phil@netroedge.com>, "
2036 "and Mark Studebaker <mdsxyz123@yahoo.com>");
2037 MODULE_DESCRIPTION("W83781D driver");
2038 MODULE_LICENSE("GPL");
2040 module_init(sensors_w83781d_init);
2041 module_exit(sensors_w83781d_exit);