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 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 w83627hf 9 3 2 3 0x21 0x5ca3 yes yes(LPC)
32 w83782d 9 3 2-4 3 0x30 0x5ca3 yes yes
33 w83783s 5-6 3 2 1-2 0x40 0x5ca3 yes no
37 #include <linux/module.h>
38 #include <linux/init.h>
39 #include <linux/slab.h>
40 #include <linux/jiffies.h>
41 #include <linux/i2c.h>
42 #include <linux/platform_device.h>
43 #include <linux/ioport.h>
44 #include <linux/hwmon.h>
45 #include <linux/hwmon-vid.h>
46 #include <linux/hwmon-sysfs.h>
47 #include <linux/sysfs.h>
48 #include <linux/err.h>
49 #include <linux/mutex.h>
53 /* ISA device, if found */
54 static struct platform_device
*pdev
;
56 /* Addresses to scan */
57 static unsigned short normal_i2c
[] = { 0x20, 0x21, 0x22, 0x23, 0x24, 0x25,
58 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b,
59 0x2c, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END
};
60 static unsigned short isa_address
= 0x290;
62 /* Insmod parameters */
63 I2C_CLIENT_INSMOD_5(w83781d
, w83782d
, w83783s
, w83627hf
, as99127f
);
64 I2C_CLIENT_MODULE_PARM(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, W83627HF) */
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
156 /* RT Table registers */
157 #define W83781D_REG_RT_IDX 0x50
158 #define W83781D_REG_RT_VAL 0x51
161 #define IN_TO_REG(val) SENSORS_LIMIT(((val) + 8) / 16, 0, 255)
162 #define IN_FROM_REG(val) ((val) * 16)
165 FAN_TO_REG(long rpm
, int div
)
169 rpm
= SENSORS_LIMIT(rpm
, 1, 1000000);
170 return SENSORS_LIMIT((1350000 + rpm
* div
/ 2) / (rpm
* div
), 1, 254);
174 FAN_FROM_REG(u8 val
, int div
)
180 return 1350000 / (val
* div
);
183 #define TEMP_TO_REG(val) SENSORS_LIMIT((val) / 1000, -127, 128)
184 #define TEMP_FROM_REG(val) ((val) * 1000)
186 #define BEEP_MASK_FROM_REG(val,type) ((type) == as99127f ? \
187 (val) ^ 0x7fff : (val))
188 #define BEEP_MASK_TO_REG(val,type) ((type) == as99127f ? \
189 (~(val)) & 0x7fff : (val) & 0xffffff)
191 #define DIV_FROM_REG(val) (1 << (val))
194 DIV_TO_REG(long val
, enum chips type
)
197 val
= SENSORS_LIMIT(val
, 1,
199 || type
== as99127f
) ? 8 : 128)) >> 1;
200 for (i
= 0; i
< 7; i
++) {
208 /* There are some complications in a module like this. First off, W83781D chips
209 may be both present on the SMBus and the ISA bus, and we have to handle
210 those cases separately at some places. Second, there might be several
211 W83781D chips available (well, actually, that is probably never done; but
212 it is a clean illustration of how to handle a case like that). Finally,
213 a specific chip may be attached to *both* ISA and SMBus, and we would
214 not like to detect it double. Fortunately, in the case of the W83781D at
215 least, a register tells us what SMBus address we are on, so that helps
216 a bit - except if there could be more than one SMBus. Groan. No solution
219 /* For ISA chips, we abuse the i2c_client addr and name fields. We also use
220 the driver field to differentiate between I2C and ISA chips. */
221 struct w83781d_data
{
222 struct i2c_client client
;
223 struct device
*hwmon_dev
;
227 struct mutex update_lock
;
228 char valid
; /* !=0 if following fields are valid */
229 unsigned long last_updated
; /* In jiffies */
231 struct i2c_client
*lm75
[2]; /* for secondary I2C addresses */
232 /* array of 2 pointers to subclients */
234 u8 in
[9]; /* Register value - 8 & 9 for 782D only */
235 u8 in_max
[9]; /* Register value - 8 & 9 for 782D only */
236 u8 in_min
[9]; /* Register value - 8 & 9 for 782D only */
237 u8 fan
[3]; /* Register value */
238 u8 fan_min
[3]; /* Register value */
239 s8 temp
; /* Register value */
240 s8 temp_max
; /* Register value */
241 s8 temp_max_hyst
; /* Register value */
242 u16 temp_add
[2]; /* Register value */
243 u16 temp_max_add
[2]; /* Register value */
244 u16 temp_max_hyst_add
[2]; /* Register value */
245 u8 fan_div
[3]; /* Register encoding, shifted right */
246 u8 vid
; /* Register encoding, combined */
247 u32 alarms
; /* Register encoding, combined */
248 u32 beep_mask
; /* Register encoding, combined */
249 u8 beep_enable
; /* Boolean */
250 u8 pwm
[4]; /* Register value */
251 u8 pwm2_enable
; /* Boolean */
252 u16 sens
[3]; /* 782D/783S only.
253 1 = pentium diode; 2 = 3904 diode;
258 static int w83781d_attach_adapter(struct i2c_adapter
*adapter
);
259 static int w83781d_detect(struct i2c_adapter
*adapter
, int address
, int kind
);
260 static int w83781d_detach_client(struct i2c_client
*client
);
262 static int __devinit
w83781d_isa_probe(struct platform_device
*pdev
);
263 static int __devexit
w83781d_isa_remove(struct platform_device
*pdev
);
265 static int w83781d_read_value(struct w83781d_data
*data
, u16 reg
);
266 static int w83781d_write_value(struct w83781d_data
*data
, u16 reg
, u16 value
);
267 static struct w83781d_data
*w83781d_update_device(struct device
*dev
);
268 static void w83781d_init_device(struct device
*dev
);
270 static struct i2c_driver w83781d_driver
= {
274 .id
= I2C_DRIVERID_W83781D
,
275 .attach_adapter
= w83781d_attach_adapter
,
276 .detach_client
= w83781d_detach_client
,
279 static struct platform_driver w83781d_isa_driver
= {
281 .owner
= THIS_MODULE
,
284 .probe
= w83781d_isa_probe
,
285 .remove
= w83781d_isa_remove
,
289 /* following are the sysfs callback functions */
290 #define show_in_reg(reg) \
291 static ssize_t show_##reg (struct device *dev, struct device_attribute *da, \
294 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
295 struct w83781d_data *data = w83781d_update_device(dev); \
296 return sprintf(buf, "%ld\n", \
297 (long)IN_FROM_REG(data->reg[attr->index])); \
303 #define store_in_reg(REG, reg) \
304 static ssize_t store_in_##reg (struct device *dev, struct device_attribute \
305 *da, const char *buf, size_t count) \
307 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
308 struct w83781d_data *data = dev_get_drvdata(dev); \
309 int nr = attr->index; \
312 val = simple_strtoul(buf, NULL, 10); \
314 mutex_lock(&data->update_lock); \
315 data->in_##reg[nr] = IN_TO_REG(val); \
316 w83781d_write_value(data, W83781D_REG_IN_##REG(nr), data->in_##reg[nr]); \
318 mutex_unlock(&data->update_lock); \
321 store_in_reg(MIN
, min
);
322 store_in_reg(MAX
, max
);
324 #define sysfs_in_offsets(offset) \
325 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
326 show_in, NULL, offset); \
327 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
328 show_in_min, store_in_min, offset); \
329 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
330 show_in_max, store_in_max, offset)
342 #define show_fan_reg(reg) \
343 static ssize_t show_##reg (struct device *dev, struct device_attribute *da, \
346 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
347 struct w83781d_data *data = w83781d_update_device(dev); \
348 return sprintf(buf,"%ld\n", \
349 FAN_FROM_REG(data->reg[attr->index], \
350 DIV_FROM_REG(data->fan_div[attr->index]))); \
353 show_fan_reg(fan_min
);
356 store_fan_min(struct device
*dev
, struct device_attribute
*da
,
357 const char *buf
, size_t count
)
359 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
360 struct w83781d_data
*data
= dev_get_drvdata(dev
);
361 int nr
= attr
->index
;
364 val
= simple_strtoul(buf
, NULL
, 10);
366 mutex_lock(&data
->update_lock
);
368 FAN_TO_REG(val
, DIV_FROM_REG(data
->fan_div
[nr
]));
369 w83781d_write_value(data
, W83781D_REG_FAN_MIN(nr
),
372 mutex_unlock(&data
->update_lock
);
376 static SENSOR_DEVICE_ATTR(fan1_input
, S_IRUGO
, show_fan
, NULL
, 0);
377 static SENSOR_DEVICE_ATTR(fan1_min
, S_IRUGO
| S_IWUSR
,
378 show_fan_min
, store_fan_min
, 0);
379 static SENSOR_DEVICE_ATTR(fan2_input
, S_IRUGO
, show_fan
, NULL
, 1);
380 static SENSOR_DEVICE_ATTR(fan2_min
, S_IRUGO
| S_IWUSR
,
381 show_fan_min
, store_fan_min
, 1);
382 static SENSOR_DEVICE_ATTR(fan3_input
, S_IRUGO
, show_fan
, NULL
, 2);
383 static SENSOR_DEVICE_ATTR(fan3_min
, S_IRUGO
| S_IWUSR
,
384 show_fan_min
, store_fan_min
, 2);
386 #define show_temp_reg(reg) \
387 static ssize_t show_##reg (struct device *dev, struct device_attribute *da, \
390 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
391 struct w83781d_data *data = w83781d_update_device(dev); \
392 int nr = attr->index; \
393 if (nr >= 2) { /* TEMP2 and TEMP3 */ \
394 return sprintf(buf,"%d\n", \
395 LM75_TEMP_FROM_REG(data->reg##_add[nr-2])); \
396 } else { /* TEMP1 */ \
397 return sprintf(buf,"%ld\n", (long)TEMP_FROM_REG(data->reg)); \
401 show_temp_reg(temp_max
);
402 show_temp_reg(temp_max_hyst
);
404 #define store_temp_reg(REG, reg) \
405 static ssize_t store_temp_##reg (struct device *dev, \
406 struct device_attribute *da, const char *buf, size_t count) \
408 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
409 struct w83781d_data *data = dev_get_drvdata(dev); \
410 int nr = attr->index; \
413 val = simple_strtol(buf, NULL, 10); \
415 mutex_lock(&data->update_lock); \
417 if (nr >= 2) { /* TEMP2 and TEMP3 */ \
418 data->temp_##reg##_add[nr-2] = LM75_TEMP_TO_REG(val); \
419 w83781d_write_value(data, W83781D_REG_TEMP_##REG(nr), \
420 data->temp_##reg##_add[nr-2]); \
421 } else { /* TEMP1 */ \
422 data->temp_##reg = TEMP_TO_REG(val); \
423 w83781d_write_value(data, W83781D_REG_TEMP_##REG(nr), \
427 mutex_unlock(&data->update_lock); \
430 store_temp_reg(OVER
, max
);
431 store_temp_reg(HYST
, max_hyst
);
433 #define sysfs_temp_offsets(offset) \
434 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
435 show_temp, NULL, offset); \
436 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
437 show_temp_max, store_temp_max, offset); \
438 static SENSOR_DEVICE_ATTR(temp##offset##_max_hyst, S_IRUGO | S_IWUSR, \
439 show_temp_max_hyst, store_temp_max_hyst, offset);
441 sysfs_temp_offsets(1);
442 sysfs_temp_offsets(2);
443 sysfs_temp_offsets(3);
446 show_vid_reg(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
448 struct w83781d_data
*data
= w83781d_update_device(dev
);
449 return sprintf(buf
, "%ld\n", (long) vid_from_reg(data
->vid
, data
->vrm
));
452 static DEVICE_ATTR(cpu0_vid
, S_IRUGO
, show_vid_reg
, NULL
);
455 show_vrm_reg(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
457 struct w83781d_data
*data
= w83781d_update_device(dev
);
458 return sprintf(buf
, "%ld\n", (long) data
->vrm
);
462 store_vrm_reg(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
464 struct w83781d_data
*data
= dev_get_drvdata(dev
);
467 val
= simple_strtoul(buf
, NULL
, 10);
473 static DEVICE_ATTR(vrm
, S_IRUGO
| S_IWUSR
, show_vrm_reg
, store_vrm_reg
);
476 show_alarms_reg(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
478 struct w83781d_data
*data
= w83781d_update_device(dev
);
479 return sprintf(buf
, "%u\n", data
->alarms
);
482 static DEVICE_ATTR(alarms
, S_IRUGO
, show_alarms_reg
, NULL
);
484 static ssize_t
show_beep_mask (struct device
*dev
, struct device_attribute
*attr
, char *buf
)
486 struct w83781d_data
*data
= w83781d_update_device(dev
);
487 return sprintf(buf
, "%ld\n",
488 (long)BEEP_MASK_FROM_REG(data
->beep_mask
, data
->type
));
490 static ssize_t
show_beep_enable (struct device
*dev
, struct device_attribute
*attr
, char *buf
)
492 struct w83781d_data
*data
= w83781d_update_device(dev
);
493 return sprintf(buf
, "%ld\n", (long)data
->beep_enable
);
497 store_beep_mask(struct device
*dev
, struct device_attribute
*attr
,
498 const char *buf
, size_t count
)
500 struct w83781d_data
*data
= dev_get_drvdata(dev
);
503 val
= simple_strtoul(buf
, NULL
, 10);
505 mutex_lock(&data
->update_lock
);
506 data
->beep_mask
= BEEP_MASK_TO_REG(val
, data
->type
);
507 w83781d_write_value(data
, W83781D_REG_BEEP_INTS1
,
508 data
->beep_mask
& 0xff);
509 w83781d_write_value(data
, W83781D_REG_BEEP_INTS2
,
510 ((data
->beep_mask
>> 8) & 0x7f)
511 | data
->beep_enable
<< 7);
512 if (data
->type
!= w83781d
&& data
->type
!= as99127f
) {
513 w83781d_write_value(data
, W83781D_REG_BEEP_INTS3
,
514 ((data
->beep_mask
) >> 16) & 0xff);
516 mutex_unlock(&data
->update_lock
);
522 store_beep_enable(struct device
*dev
, struct device_attribute
*attr
,
523 const char *buf
, size_t count
)
525 struct w83781d_data
*data
= dev_get_drvdata(dev
);
528 val
= simple_strtoul(buf
, NULL
, 10);
529 if (val
!= 0 && val
!= 1)
532 mutex_lock(&data
->update_lock
);
533 data
->beep_enable
= val
;
534 val
= w83781d_read_value(data
, W83781D_REG_BEEP_INTS2
) & 0x7f;
535 val
|= data
->beep_enable
<< 7;
536 w83781d_write_value(data
, W83781D_REG_BEEP_INTS2
, val
);
537 mutex_unlock(&data
->update_lock
);
542 static DEVICE_ATTR(beep_mask
, S_IRUGO
| S_IWUSR
,
543 show_beep_mask
, store_beep_mask
);
544 static DEVICE_ATTR(beep_enable
, S_IRUGO
| S_IWUSR
,
545 show_beep_enable
, store_beep_enable
);
548 show_fan_div(struct device
*dev
, struct device_attribute
*da
, char *buf
)
550 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
551 struct w83781d_data
*data
= w83781d_update_device(dev
);
552 return sprintf(buf
, "%ld\n",
553 (long) DIV_FROM_REG(data
->fan_div
[attr
->index
]));
556 /* Note: we save and restore the fan minimum here, because its value is
557 determined in part by the fan divisor. This follows the principle of
558 least surprise; the user doesn't expect the fan minimum to change just
559 because the divisor changed. */
561 store_fan_div(struct device
*dev
, struct device_attribute
*da
,
562 const char *buf
, size_t count
)
564 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
565 struct w83781d_data
*data
= dev_get_drvdata(dev
);
567 int nr
= attr
->index
;
569 unsigned long val
= simple_strtoul(buf
, NULL
, 10);
571 mutex_lock(&data
->update_lock
);
574 min
= FAN_FROM_REG(data
->fan_min
[nr
],
575 DIV_FROM_REG(data
->fan_div
[nr
]));
577 data
->fan_div
[nr
] = DIV_TO_REG(val
, data
->type
);
579 reg
= (w83781d_read_value(data
, nr
==2 ? W83781D_REG_PIN
: W83781D_REG_VID_FANDIV
)
580 & (nr
==0 ? 0xcf : 0x3f))
581 | ((data
->fan_div
[nr
] & 0x03) << (nr
==0 ? 4 : 6));
582 w83781d_write_value(data
, nr
==2 ? W83781D_REG_PIN
: W83781D_REG_VID_FANDIV
, reg
);
584 /* w83781d and as99127f don't have extended divisor bits */
585 if (data
->type
!= w83781d
&& data
->type
!= as99127f
) {
586 reg
= (w83781d_read_value(data
, W83781D_REG_VBAT
)
588 | ((data
->fan_div
[nr
] & 0x04) << (3 + nr
));
589 w83781d_write_value(data
, W83781D_REG_VBAT
, reg
);
592 /* Restore fan_min */
593 data
->fan_min
[nr
] = FAN_TO_REG(min
, DIV_FROM_REG(data
->fan_div
[nr
]));
594 w83781d_write_value(data
, W83781D_REG_FAN_MIN(nr
), data
->fan_min
[nr
]);
596 mutex_unlock(&data
->update_lock
);
600 static SENSOR_DEVICE_ATTR(fan1_div
, S_IRUGO
| S_IWUSR
,
601 show_fan_div
, store_fan_div
, 0);
602 static SENSOR_DEVICE_ATTR(fan2_div
, S_IRUGO
| S_IWUSR
,
603 show_fan_div
, store_fan_div
, 1);
604 static SENSOR_DEVICE_ATTR(fan3_div
, S_IRUGO
| S_IWUSR
,
605 show_fan_div
, store_fan_div
, 2);
608 show_pwm(struct device
*dev
, struct device_attribute
*da
, char *buf
)
610 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
611 struct w83781d_data
*data
= w83781d_update_device(dev
);
612 return sprintf(buf
, "%d\n", (int)data
->pwm
[attr
->index
]);
616 show_pwm2_enable(struct device
*dev
, struct device_attribute
*da
, char *buf
)
618 struct w83781d_data
*data
= w83781d_update_device(dev
);
619 return sprintf(buf
, "%d\n", (int)data
->pwm2_enable
);
623 store_pwm(struct device
*dev
, struct device_attribute
*da
, const char *buf
,
626 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
627 struct w83781d_data
*data
= dev_get_drvdata(dev
);
628 int nr
= attr
->index
;
631 val
= simple_strtoul(buf
, NULL
, 10);
633 mutex_lock(&data
->update_lock
);
634 data
->pwm
[nr
] = SENSORS_LIMIT(val
, 0, 255);
635 w83781d_write_value(data
, W83781D_REG_PWM
[nr
], data
->pwm
[nr
]);
636 mutex_unlock(&data
->update_lock
);
641 store_pwm2_enable(struct device
*dev
, struct device_attribute
*da
,
642 const char *buf
, size_t count
)
644 struct w83781d_data
*data
= dev_get_drvdata(dev
);
647 val
= simple_strtoul(buf
, NULL
, 10);
649 mutex_lock(&data
->update_lock
);
654 reg
= w83781d_read_value(data
, W83781D_REG_PWMCLK12
);
655 w83781d_write_value(data
, W83781D_REG_PWMCLK12
,
656 (reg
& 0xf7) | (val
<< 3));
658 reg
= w83781d_read_value(data
, W83781D_REG_BEEP_CONFIG
);
659 w83781d_write_value(data
, W83781D_REG_BEEP_CONFIG
,
660 (reg
& 0xef) | (!val
<< 4));
662 data
->pwm2_enable
= val
;
666 mutex_unlock(&data
->update_lock
);
670 mutex_unlock(&data
->update_lock
);
674 static SENSOR_DEVICE_ATTR(pwm1
, S_IRUGO
| S_IWUSR
, show_pwm
, store_pwm
, 0);
675 static SENSOR_DEVICE_ATTR(pwm2
, S_IRUGO
| S_IWUSR
, show_pwm
, store_pwm
, 1);
676 static SENSOR_DEVICE_ATTR(pwm3
, S_IRUGO
| S_IWUSR
, show_pwm
, store_pwm
, 2);
677 static SENSOR_DEVICE_ATTR(pwm4
, S_IRUGO
| S_IWUSR
, show_pwm
, store_pwm
, 3);
678 /* only PWM2 can be enabled/disabled */
679 static DEVICE_ATTR(pwm2_enable
, S_IRUGO
| S_IWUSR
,
680 show_pwm2_enable
, store_pwm2_enable
);
683 show_sensor(struct device
*dev
, struct device_attribute
*da
, char *buf
)
685 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
686 struct w83781d_data
*data
= w83781d_update_device(dev
);
687 return sprintf(buf
, "%d\n", (int)data
->sens
[attr
->index
]);
691 store_sensor(struct device
*dev
, struct device_attribute
*da
,
692 const char *buf
, size_t count
)
694 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
695 struct w83781d_data
*data
= dev_get_drvdata(dev
);
696 int nr
= attr
->index
;
699 val
= simple_strtoul(buf
, NULL
, 10);
701 mutex_lock(&data
->update_lock
);
704 case 1: /* PII/Celeron diode */
705 tmp
= w83781d_read_value(data
, W83781D_REG_SCFG1
);
706 w83781d_write_value(data
, W83781D_REG_SCFG1
,
707 tmp
| BIT_SCFG1
[nr
]);
708 tmp
= w83781d_read_value(data
, W83781D_REG_SCFG2
);
709 w83781d_write_value(data
, W83781D_REG_SCFG2
,
710 tmp
| BIT_SCFG2
[nr
]);
711 data
->sens
[nr
] = val
;
714 tmp
= w83781d_read_value(data
, W83781D_REG_SCFG1
);
715 w83781d_write_value(data
, W83781D_REG_SCFG1
,
716 tmp
| BIT_SCFG1
[nr
]);
717 tmp
= w83781d_read_value(data
, W83781D_REG_SCFG2
);
718 w83781d_write_value(data
, W83781D_REG_SCFG2
,
719 tmp
& ~BIT_SCFG2
[nr
]);
720 data
->sens
[nr
] = val
;
722 case W83781D_DEFAULT_BETA
:
723 dev_warn(dev
, "Sensor type %d is deprecated, please use 4 "
724 "instead\n", W83781D_DEFAULT_BETA
);
726 case 4: /* thermistor */
727 tmp
= w83781d_read_value(data
, W83781D_REG_SCFG1
);
728 w83781d_write_value(data
, W83781D_REG_SCFG1
,
729 tmp
& ~BIT_SCFG1
[nr
]);
730 data
->sens
[nr
] = val
;
733 dev_err(dev
, "Invalid sensor type %ld; must be 1, 2, or 4\n",
738 mutex_unlock(&data
->update_lock
);
742 static SENSOR_DEVICE_ATTR(temp1_type
, S_IRUGO
| S_IWUSR
,
743 show_sensor
, store_sensor
, 0);
744 static SENSOR_DEVICE_ATTR(temp2_type
, S_IRUGO
| S_IWUSR
,
745 show_sensor
, store_sensor
, 1);
746 static SENSOR_DEVICE_ATTR(temp3_type
, S_IRUGO
| S_IWUSR
,
747 show_sensor
, store_sensor
, 2);
749 /* I2C devices get this name attribute automatically, but for ISA devices
750 we must create it by ourselves. */
752 show_name(struct device
*dev
, struct device_attribute
*devattr
, char *buf
)
754 struct w83781d_data
*data
= dev_get_drvdata(dev
);
755 return sprintf(buf
, "%s\n", data
->client
.name
);
757 static DEVICE_ATTR(name
, S_IRUGO
, show_name
, NULL
);
759 /* This function is called when:
760 * w83781d_driver is inserted (when this module is loaded), for each
762 * when a new adapter is inserted (and w83781d_driver is still present) */
764 w83781d_attach_adapter(struct i2c_adapter
*adapter
)
766 if (!(adapter
->class & I2C_CLASS_HWMON
))
768 return i2c_probe(adapter
, &addr_data
, w83781d_detect
);
771 /* Assumes that adapter is of I2C, not ISA variety.
772 * OTHERWISE DON'T CALL THIS
775 w83781d_detect_subclients(struct i2c_adapter
*adapter
, int address
, int kind
,
776 struct i2c_client
*new_client
)
780 const char *client_name
= "";
781 struct w83781d_data
*data
= i2c_get_clientdata(new_client
);
783 data
->lm75
[0] = kzalloc(sizeof(struct i2c_client
), GFP_KERNEL
);
784 if (!(data
->lm75
[0])) {
789 id
= i2c_adapter_id(adapter
);
791 if (force_subclients
[0] == id
&& force_subclients
[1] == address
) {
792 for (i
= 2; i
<= 3; i
++) {
793 if (force_subclients
[i
] < 0x48 ||
794 force_subclients
[i
] > 0x4f) {
795 dev_err(&new_client
->dev
, "Invalid subclient "
796 "address %d; must be 0x48-0x4f\n",
797 force_subclients
[i
]);
802 w83781d_write_value(data
, W83781D_REG_I2C_SUBADDR
,
803 (force_subclients
[2] & 0x07) |
804 ((force_subclients
[3] & 0x07) << 4));
805 data
->lm75
[0]->addr
= force_subclients
[2];
807 val1
= w83781d_read_value(data
, W83781D_REG_I2C_SUBADDR
);
808 data
->lm75
[0]->addr
= 0x48 + (val1
& 0x07);
811 if (kind
!= w83783s
) {
812 data
->lm75
[1] = kzalloc(sizeof(struct i2c_client
), GFP_KERNEL
);
813 if (!(data
->lm75
[1])) {
818 if (force_subclients
[0] == id
&&
819 force_subclients
[1] == address
) {
820 data
->lm75
[1]->addr
= force_subclients
[3];
822 data
->lm75
[1]->addr
= 0x48 + ((val1
>> 4) & 0x07);
824 if (data
->lm75
[0]->addr
== data
->lm75
[1]->addr
) {
825 dev_err(&new_client
->dev
,
826 "Duplicate addresses 0x%x for subclients.\n",
827 data
->lm75
[0]->addr
);
834 client_name
= "w83781d subclient";
835 else if (kind
== w83782d
)
836 client_name
= "w83782d subclient";
837 else if (kind
== w83783s
)
838 client_name
= "w83783s subclient";
839 else if (kind
== w83627hf
)
840 client_name
= "w83627hf subclient";
841 else if (kind
== as99127f
)
842 client_name
= "as99127f subclient";
844 for (i
= 0; i
<= 1; i
++) {
845 /* store all data in w83781d */
846 i2c_set_clientdata(data
->lm75
[i
], NULL
);
847 data
->lm75
[i
]->adapter
= adapter
;
848 data
->lm75
[i
]->driver
= &w83781d_driver
;
849 data
->lm75
[i
]->flags
= 0;
850 strlcpy(data
->lm75
[i
]->name
, client_name
,
852 if ((err
= i2c_attach_client(data
->lm75
[i
]))) {
853 dev_err(&new_client
->dev
, "Subclient %d "
854 "registration at address 0x%x "
855 "failed.\n", i
, data
->lm75
[i
]->addr
);
866 /* Undo inits in case of errors */
868 i2c_detach_client(data
->lm75
[0]);
870 kfree(data
->lm75
[1]);
872 kfree(data
->lm75
[0]);
877 #define IN_UNIT_ATTRS(X) \
878 &sensor_dev_attr_in##X##_input.dev_attr.attr, \
879 &sensor_dev_attr_in##X##_min.dev_attr.attr, \
880 &sensor_dev_attr_in##X##_max.dev_attr.attr
882 #define FAN_UNIT_ATTRS(X) \
883 &sensor_dev_attr_fan##X##_input.dev_attr.attr, \
884 &sensor_dev_attr_fan##X##_min.dev_attr.attr, \
885 &sensor_dev_attr_fan##X##_div.dev_attr.attr
887 #define TEMP_UNIT_ATTRS(X) \
888 &sensor_dev_attr_temp##X##_input.dev_attr.attr, \
889 &sensor_dev_attr_temp##X##_max.dev_attr.attr, \
890 &sensor_dev_attr_temp##X##_max_hyst.dev_attr.attr
892 static struct attribute
* w83781d_attributes
[] = {
904 &dev_attr_cpu0_vid
.attr
,
906 &dev_attr_alarms
.attr
,
907 &dev_attr_beep_mask
.attr
,
908 &dev_attr_beep_enable
.attr
,
911 static const struct attribute_group w83781d_group
= {
912 .attrs
= w83781d_attributes
,
915 static struct attribute
*w83781d_attributes_opt
[] = {
920 &sensor_dev_attr_pwm1
.dev_attr
.attr
,
921 &sensor_dev_attr_pwm2
.dev_attr
.attr
,
922 &sensor_dev_attr_pwm3
.dev_attr
.attr
,
923 &sensor_dev_attr_pwm4
.dev_attr
.attr
,
924 &dev_attr_pwm2_enable
.attr
,
925 &sensor_dev_attr_temp1_type
.dev_attr
.attr
,
926 &sensor_dev_attr_temp2_type
.dev_attr
.attr
,
927 &sensor_dev_attr_temp3_type
.dev_attr
.attr
,
930 static const struct attribute_group w83781d_group_opt
= {
931 .attrs
= w83781d_attributes_opt
,
934 /* No clean up is done on error, it's up to the caller */
936 w83781d_create_files(struct device
*dev
, int kind
, int is_isa
)
940 if ((err
= sysfs_create_group(&dev
->kobj
, &w83781d_group
)))
943 if (kind
!= w83783s
) {
944 if ((err
= device_create_file(dev
,
945 &sensor_dev_attr_in1_input
.dev_attr
))
946 || (err
= device_create_file(dev
,
947 &sensor_dev_attr_in1_min
.dev_attr
))
948 || (err
= device_create_file(dev
,
949 &sensor_dev_attr_in1_max
.dev_attr
)))
952 if (kind
!= as99127f
&& kind
!= w83781d
&& kind
!= w83783s
) {
953 if ((err
= device_create_file(dev
,
954 &sensor_dev_attr_in7_input
.dev_attr
))
955 || (err
= device_create_file(dev
,
956 &sensor_dev_attr_in7_min
.dev_attr
))
957 || (err
= device_create_file(dev
,
958 &sensor_dev_attr_in7_max
.dev_attr
))
959 || (err
= device_create_file(dev
,
960 &sensor_dev_attr_in8_input
.dev_attr
))
961 || (err
= device_create_file(dev
,
962 &sensor_dev_attr_in8_min
.dev_attr
))
963 || (err
= device_create_file(dev
,
964 &sensor_dev_attr_in8_max
.dev_attr
)))
967 if (kind
!= w83783s
) {
968 if ((err
= device_create_file(dev
,
969 &sensor_dev_attr_temp3_input
.dev_attr
))
970 || (err
= device_create_file(dev
,
971 &sensor_dev_attr_temp3_max
.dev_attr
))
972 || (err
= device_create_file(dev
,
973 &sensor_dev_attr_temp3_max_hyst
.dev_attr
)))
977 if (kind
!= w83781d
&& kind
!= as99127f
) {
978 if ((err
= device_create_file(dev
,
979 &sensor_dev_attr_pwm1
.dev_attr
))
980 || (err
= device_create_file(dev
,
981 &sensor_dev_attr_pwm2
.dev_attr
))
982 || (err
= device_create_file(dev
, &dev_attr_pwm2_enable
)))
985 if (kind
== w83782d
&& !is_isa
) {
986 if ((err
= device_create_file(dev
,
987 &sensor_dev_attr_pwm3
.dev_attr
))
988 || (err
= device_create_file(dev
,
989 &sensor_dev_attr_pwm4
.dev_attr
)))
993 if (kind
!= as99127f
&& kind
!= w83781d
) {
994 if ((err
= device_create_file(dev
,
995 &sensor_dev_attr_temp1_type
.dev_attr
))
996 || (err
= device_create_file(dev
,
997 &sensor_dev_attr_temp2_type
.dev_attr
)))
999 if (kind
!= w83783s
) {
1000 if ((err
= device_create_file(dev
,
1001 &sensor_dev_attr_temp3_type
.dev_attr
)))
1007 err
= device_create_file(&pdev
->dev
, &dev_attr_name
);
1016 w83781d_detect(struct i2c_adapter
*adapter
, int address
, int kind
)
1019 struct i2c_client
*client
;
1021 struct w83781d_data
*data
;
1023 const char *client_name
= "";
1024 enum vendor
{ winbond
, asus
} vendid
;
1026 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
)) {
1031 /* OK. For now, we presume we have a valid client. We now create the
1032 client structure, even though we cannot fill it completely yet.
1033 But it allows us to access w83781d_{read,write}_value. */
1035 if (!(data
= kzalloc(sizeof(struct w83781d_data
), GFP_KERNEL
))) {
1040 client
= &data
->client
;
1041 i2c_set_clientdata(client
, data
);
1042 client
->addr
= address
;
1043 mutex_init(&data
->lock
);
1044 client
->adapter
= adapter
;
1045 client
->driver
= &w83781d_driver
;
1048 /* Now, we do the remaining detection. */
1050 /* The w8378?d may be stuck in some other bank than bank 0. This may
1051 make reading other information impossible. Specify a force=... or
1052 force_*=... parameter, and the Winbond will be reset to the right
1055 if (w83781d_read_value(data
, W83781D_REG_CONFIG
) & 0x80) {
1056 dev_dbg(&adapter
->dev
, "Detection of w83781d chip "
1057 "failed at step 3\n");
1061 val1
= w83781d_read_value(data
, W83781D_REG_BANK
);
1062 val2
= w83781d_read_value(data
, W83781D_REG_CHIPMAN
);
1063 /* Check for Winbond or Asus ID if in bank 0 */
1064 if ((!(val1
& 0x07)) &&
1065 (((!(val1
& 0x80)) && (val2
!= 0xa3) && (val2
!= 0xc3))
1066 || ((val1
& 0x80) && (val2
!= 0x5c) && (val2
!= 0x12)))) {
1067 dev_dbg(&adapter
->dev
, "Detection of w83781d chip "
1068 "failed at step 4\n");
1072 /* If Winbond SMBus, check address at 0x48.
1073 Asus doesn't support, except for as99127f rev.2 */
1074 if ((!(val1
& 0x80) && (val2
== 0xa3)) ||
1075 ((val1
& 0x80) && (val2
== 0x5c))) {
1076 if (w83781d_read_value
1077 (data
, W83781D_REG_I2C_ADDR
) != address
) {
1078 dev_dbg(&adapter
->dev
, "Detection of w83781d "
1079 "chip failed at step 5\n");
1086 /* We have either had a force parameter, or we have already detected the
1087 Winbond. Put it now into bank 0 and Vendor ID High Byte */
1088 w83781d_write_value(data
, W83781D_REG_BANK
,
1089 (w83781d_read_value(data
, W83781D_REG_BANK
)
1092 /* Determine the chip type. */
1095 val2
= w83781d_read_value(data
, W83781D_REG_CHIPMAN
);
1098 else if (val2
== 0x12)
1101 dev_dbg(&adapter
->dev
, "w83781d chip vendor is "
1102 "neither Winbond nor Asus\n");
1107 val1
= w83781d_read_value(data
, W83781D_REG_WCHIPID
);
1108 if ((val1
== 0x10 || val1
== 0x11) && vendid
== winbond
)
1110 else if (val1
== 0x30 && vendid
== winbond
)
1112 else if (val1
== 0x40 && vendid
== winbond
&& address
== 0x2d)
1114 else if (val1
== 0x21 && vendid
== winbond
)
1116 else if (val1
== 0x31 && address
>= 0x28)
1120 dev_warn(&adapter
->dev
, "Ignoring 'force' "
1121 "parameter for unknown chip at "
1122 "address 0x%02x\n", address
);
1128 if (kind
== w83781d
) {
1129 client_name
= "w83781d";
1130 } else if (kind
== w83782d
) {
1131 client_name
= "w83782d";
1132 } else if (kind
== w83783s
) {
1133 client_name
= "w83783s";
1134 } else if (kind
== w83627hf
) {
1135 client_name
= "w83627hf";
1136 } else if (kind
== as99127f
) {
1137 client_name
= "as99127f";
1140 /* Fill in the remaining client fields and put into the global list */
1141 strlcpy(client
->name
, client_name
, I2C_NAME_SIZE
);
1144 /* Tell the I2C layer a new client has arrived */
1145 if ((err
= i2c_attach_client(client
)))
1148 /* attach secondary i2c lm75-like clients */
1149 if ((err
= w83781d_detect_subclients(adapter
, address
,
1153 /* Initialize the chip */
1154 w83781d_init_device(dev
);
1156 /* Register sysfs hooks */
1157 err
= w83781d_create_files(dev
, kind
, 0);
1161 data
->hwmon_dev
= hwmon_device_register(dev
);
1162 if (IS_ERR(data
->hwmon_dev
)) {
1163 err
= PTR_ERR(data
->hwmon_dev
);
1170 sysfs_remove_group(&dev
->kobj
, &w83781d_group
);
1171 sysfs_remove_group(&dev
->kobj
, &w83781d_group_opt
);
1173 if (data
->lm75
[1]) {
1174 i2c_detach_client(data
->lm75
[1]);
1175 kfree(data
->lm75
[1]);
1177 if (data
->lm75
[0]) {
1178 i2c_detach_client(data
->lm75
[0]);
1179 kfree(data
->lm75
[0]);
1182 i2c_detach_client(client
);
1190 w83781d_detach_client(struct i2c_client
*client
)
1192 struct w83781d_data
*data
= i2c_get_clientdata(client
);
1197 hwmon_device_unregister(data
->hwmon_dev
);
1198 sysfs_remove_group(&client
->dev
.kobj
, &w83781d_group
);
1199 sysfs_remove_group(&client
->dev
.kobj
, &w83781d_group_opt
);
1202 if ((err
= i2c_detach_client(client
)))
1216 static int __devinit
1217 w83781d_isa_probe(struct platform_device
*pdev
)
1220 struct w83781d_data
*data
;
1221 struct resource
*res
;
1224 /* Reserve the ISA region */
1225 res
= platform_get_resource(pdev
, IORESOURCE_IO
, 0);
1226 if (!request_region(res
->start
, W83781D_EXTENT
, "w83781d")) {
1231 if (!(data
= kzalloc(sizeof(struct w83781d_data
), GFP_KERNEL
))) {
1233 goto exit_release_region
;
1235 mutex_init(&data
->lock
);
1236 data
->client
.addr
= res
->start
;
1237 i2c_set_clientdata(&data
->client
, data
);
1238 platform_set_drvdata(pdev
, data
);
1240 reg
= w83781d_read_value(data
, W83781D_REG_WCHIPID
);
1243 data
->type
= w83627hf
;
1247 data
->type
= w83782d
;
1251 data
->type
= w83781d
;
1254 strlcpy(data
->client
.name
, name
, I2C_NAME_SIZE
);
1256 /* Initialize the W83781D chip */
1257 w83781d_init_device(&pdev
->dev
);
1259 /* Register sysfs hooks */
1260 err
= w83781d_create_files(&pdev
->dev
, data
->type
, 1);
1262 goto exit_remove_files
;
1264 data
->hwmon_dev
= hwmon_device_register(&pdev
->dev
);
1265 if (IS_ERR(data
->hwmon_dev
)) {
1266 err
= PTR_ERR(data
->hwmon_dev
);
1267 goto exit_remove_files
;
1273 sysfs_remove_group(&pdev
->dev
.kobj
, &w83781d_group
);
1274 sysfs_remove_group(&pdev
->dev
.kobj
, &w83781d_group_opt
);
1275 device_remove_file(&pdev
->dev
, &dev_attr_name
);
1277 exit_release_region
:
1278 release_region(res
->start
, W83781D_EXTENT
);
1283 static int __devexit
1284 w83781d_isa_remove(struct platform_device
*pdev
)
1286 struct w83781d_data
*data
= platform_get_drvdata(pdev
);
1288 hwmon_device_unregister(data
->hwmon_dev
);
1289 sysfs_remove_group(&pdev
->dev
.kobj
, &w83781d_group
);
1290 sysfs_remove_group(&pdev
->dev
.kobj
, &w83781d_group_opt
);
1291 device_remove_file(&pdev
->dev
, &dev_attr_name
);
1292 release_region(data
->client
.addr
, W83781D_EXTENT
);
1298 /* The SMBus locks itself, usually, but nothing may access the Winbond between
1299 bank switches. ISA access must always be locked explicitly!
1300 We ignore the W83781D BUSY flag at this moment - it could lead to deadlocks,
1301 would slow down the W83781D access and should not be necessary.
1302 There are some ugly typecasts here, but the good news is - they should
1303 nowhere else be necessary! */
1305 w83781d_read_value(struct w83781d_data
*data
, u16 reg
)
1307 struct i2c_client
*client
= &data
->client
;
1308 int res
, word_sized
, bank
;
1309 struct i2c_client
*cl
;
1311 mutex_lock(&data
->lock
);
1312 if (!client
->driver
) { /* ISA device */
1313 word_sized
= (((reg
& 0xff00) == 0x100)
1314 || ((reg
& 0xff00) == 0x200))
1315 && (((reg
& 0x00ff) == 0x50)
1316 || ((reg
& 0x00ff) == 0x53)
1317 || ((reg
& 0x00ff) == 0x55));
1319 outb_p(W83781D_REG_BANK
,
1320 client
->addr
+ W83781D_ADDR_REG_OFFSET
);
1322 client
->addr
+ W83781D_DATA_REG_OFFSET
);
1324 outb_p(reg
& 0xff, client
->addr
+ W83781D_ADDR_REG_OFFSET
);
1325 res
= inb_p(client
->addr
+ W83781D_DATA_REG_OFFSET
);
1327 outb_p((reg
& 0xff) + 1,
1328 client
->addr
+ W83781D_ADDR_REG_OFFSET
);
1330 (res
<< 8) + inb_p(client
->addr
+
1331 W83781D_DATA_REG_OFFSET
);
1334 outb_p(W83781D_REG_BANK
,
1335 client
->addr
+ W83781D_ADDR_REG_OFFSET
);
1336 outb_p(0, client
->addr
+ W83781D_DATA_REG_OFFSET
);
1339 bank
= (reg
>> 8) & 0x0f;
1342 i2c_smbus_write_byte_data(client
, W83781D_REG_BANK
,
1344 if (bank
== 0 || bank
> 2) {
1345 res
= i2c_smbus_read_byte_data(client
, reg
& 0xff);
1347 /* switch to subclient */
1348 cl
= data
->lm75
[bank
- 1];
1349 /* convert from ISA to LM75 I2C addresses */
1350 switch (reg
& 0xff) {
1351 case 0x50: /* TEMP */
1352 res
= swab16(i2c_smbus_read_word_data(cl
, 0));
1354 case 0x52: /* CONFIG */
1355 res
= i2c_smbus_read_byte_data(cl
, 1);
1357 case 0x53: /* HYST */
1358 res
= swab16(i2c_smbus_read_word_data(cl
, 2));
1360 case 0x55: /* OVER */
1362 res
= swab16(i2c_smbus_read_word_data(cl
, 3));
1367 i2c_smbus_write_byte_data(client
, W83781D_REG_BANK
, 0);
1369 mutex_unlock(&data
->lock
);
1374 w83781d_write_value(struct w83781d_data
*data
, u16 reg
, u16 value
)
1376 struct i2c_client
*client
= &data
->client
;
1377 int word_sized
, bank
;
1378 struct i2c_client
*cl
;
1380 mutex_lock(&data
->lock
);
1381 if (!client
->driver
) { /* ISA device */
1382 word_sized
= (((reg
& 0xff00) == 0x100)
1383 || ((reg
& 0xff00) == 0x200))
1384 && (((reg
& 0x00ff) == 0x53)
1385 || ((reg
& 0x00ff) == 0x55));
1387 outb_p(W83781D_REG_BANK
,
1388 client
->addr
+ W83781D_ADDR_REG_OFFSET
);
1390 client
->addr
+ W83781D_DATA_REG_OFFSET
);
1392 outb_p(reg
& 0xff, client
->addr
+ W83781D_ADDR_REG_OFFSET
);
1395 client
->addr
+ W83781D_DATA_REG_OFFSET
);
1396 outb_p((reg
& 0xff) + 1,
1397 client
->addr
+ W83781D_ADDR_REG_OFFSET
);
1399 outb_p(value
& 0xff, client
->addr
+ W83781D_DATA_REG_OFFSET
);
1401 outb_p(W83781D_REG_BANK
,
1402 client
->addr
+ W83781D_ADDR_REG_OFFSET
);
1403 outb_p(0, client
->addr
+ W83781D_DATA_REG_OFFSET
);
1406 bank
= (reg
>> 8) & 0x0f;
1409 i2c_smbus_write_byte_data(client
, W83781D_REG_BANK
,
1411 if (bank
== 0 || bank
> 2) {
1412 i2c_smbus_write_byte_data(client
, reg
& 0xff,
1415 /* switch to subclient */
1416 cl
= data
->lm75
[bank
- 1];
1417 /* convert from ISA to LM75 I2C addresses */
1418 switch (reg
& 0xff) {
1419 case 0x52: /* CONFIG */
1420 i2c_smbus_write_byte_data(cl
, 1, value
& 0xff);
1422 case 0x53: /* HYST */
1423 i2c_smbus_write_word_data(cl
, 2, swab16(value
));
1425 case 0x55: /* OVER */
1426 i2c_smbus_write_word_data(cl
, 3, swab16(value
));
1431 i2c_smbus_write_byte_data(client
, W83781D_REG_BANK
, 0);
1433 mutex_unlock(&data
->lock
);
1438 w83781d_init_device(struct device
*dev
)
1440 struct w83781d_data
*data
= dev_get_drvdata(dev
);
1442 int type
= data
->type
;
1445 if (type
== w83627hf
)
1446 dev_info(dev
, "The W83627HF chip is better supported by the "
1447 "w83627hf driver, support will be dropped from the "
1448 "w83781d driver soon\n");
1450 if (reset
&& type
!= as99127f
) { /* this resets registers we don't have
1451 documentation for on the as99127f */
1452 /* Resetting the chip has been the default for a long time,
1453 but it causes the BIOS initializations (fan clock dividers,
1454 thermal sensor types...) to be lost, so it is now optional.
1455 It might even go away if nobody reports it as being useful,
1456 as I see very little reason why this would be needed at
1458 dev_info(dev
, "If reset=1 solved a problem you were "
1459 "having, please report!\n");
1461 /* save these registers */
1462 i
= w83781d_read_value(data
, W83781D_REG_BEEP_CONFIG
);
1463 p
= w83781d_read_value(data
, W83781D_REG_PWMCLK12
);
1464 /* Reset all except Watchdog values and last conversion values
1465 This sets fan-divs to 2, among others */
1466 w83781d_write_value(data
, W83781D_REG_CONFIG
, 0x80);
1467 /* Restore the registers and disable power-on abnormal beep.
1468 This saves FAN 1/2/3 input/output values set by BIOS. */
1469 w83781d_write_value(data
, W83781D_REG_BEEP_CONFIG
, i
| 0x80);
1470 w83781d_write_value(data
, W83781D_REG_PWMCLK12
, p
);
1471 /* Disable master beep-enable (reset turns it on).
1472 Individual beep_mask should be reset to off but for some reason
1473 disabling this bit helps some people not get beeped */
1474 w83781d_write_value(data
, W83781D_REG_BEEP_INTS2
, 0);
1477 /* Disable power-on abnormal beep, as advised by the datasheet.
1478 Already done if reset=1. */
1479 if (init
&& !reset
&& type
!= as99127f
) {
1480 i
= w83781d_read_value(data
, W83781D_REG_BEEP_CONFIG
);
1481 w83781d_write_value(data
, W83781D_REG_BEEP_CONFIG
, i
| 0x80);
1484 data
->vrm
= vid_which_vrm();
1486 if ((type
!= w83781d
) && (type
!= as99127f
)) {
1487 tmp
= w83781d_read_value(data
, W83781D_REG_SCFG1
);
1488 for (i
= 1; i
<= 3; i
++) {
1489 if (!(tmp
& BIT_SCFG1
[i
- 1])) {
1490 data
->sens
[i
- 1] = 4;
1492 if (w83781d_read_value
1494 W83781D_REG_SCFG2
) & BIT_SCFG2
[i
- 1])
1495 data
->sens
[i
- 1] = 1;
1497 data
->sens
[i
- 1] = 2;
1499 if (type
== w83783s
&& i
== 2)
1504 if (init
&& type
!= as99127f
) {
1506 tmp
= w83781d_read_value(data
, W83781D_REG_TEMP2_CONFIG
);
1508 dev_warn(dev
, "Enabling temp2, readings "
1509 "might not make sense\n");
1510 w83781d_write_value(data
, W83781D_REG_TEMP2_CONFIG
,
1515 if (type
!= w83783s
) {
1516 tmp
= w83781d_read_value(data
,
1517 W83781D_REG_TEMP3_CONFIG
);
1519 dev_warn(dev
, "Enabling temp3, "
1520 "readings might not make sense\n");
1521 w83781d_write_value(data
,
1522 W83781D_REG_TEMP3_CONFIG
, tmp
& 0xfe);
1527 /* Start monitoring */
1528 w83781d_write_value(data
, W83781D_REG_CONFIG
,
1529 (w83781d_read_value(data
,
1530 W83781D_REG_CONFIG
) & 0xf7)
1533 /* A few vars need to be filled upon startup */
1534 for (i
= 0; i
< 3; i
++) {
1535 data
->fan_min
[i
] = w83781d_read_value(data
,
1536 W83781D_REG_FAN_MIN(i
));
1539 mutex_init(&data
->update_lock
);
1542 static struct w83781d_data
*w83781d_update_device(struct device
*dev
)
1544 struct w83781d_data
*data
= dev_get_drvdata(dev
);
1545 struct i2c_client
*client
= &data
->client
;
1548 mutex_lock(&data
->update_lock
);
1550 if (time_after(jiffies
, data
->last_updated
+ HZ
+ HZ
/ 2)
1552 dev_dbg(dev
, "Starting device update\n");
1554 for (i
= 0; i
<= 8; i
++) {
1555 if (data
->type
== w83783s
&& i
== 1)
1556 continue; /* 783S has no in1 */
1558 w83781d_read_value(data
, W83781D_REG_IN(i
));
1560 w83781d_read_value(data
, W83781D_REG_IN_MIN(i
));
1562 w83781d_read_value(data
, W83781D_REG_IN_MAX(i
));
1563 if ((data
->type
!= w83782d
)
1564 && (data
->type
!= w83627hf
) && (i
== 6))
1567 for (i
= 0; i
< 3; i
++) {
1569 w83781d_read_value(data
, W83781D_REG_FAN(i
));
1571 w83781d_read_value(data
, W83781D_REG_FAN_MIN(i
));
1573 if (data
->type
!= w83781d
&& data
->type
!= as99127f
) {
1574 for (i
= 0; i
< 4; i
++) {
1576 w83781d_read_value(data
,
1577 W83781D_REG_PWM
[i
]);
1578 if ((data
->type
!= w83782d
|| !client
->driver
)
1582 /* Only PWM2 can be disabled */
1583 data
->pwm2_enable
= (w83781d_read_value(data
,
1584 W83781D_REG_PWMCLK12
) & 0x08) >> 3;
1587 data
->temp
= w83781d_read_value(data
, W83781D_REG_TEMP(1));
1589 w83781d_read_value(data
, W83781D_REG_TEMP_OVER(1));
1590 data
->temp_max_hyst
=
1591 w83781d_read_value(data
, W83781D_REG_TEMP_HYST(1));
1593 w83781d_read_value(data
, W83781D_REG_TEMP(2));
1594 data
->temp_max_add
[0] =
1595 w83781d_read_value(data
, W83781D_REG_TEMP_OVER(2));
1596 data
->temp_max_hyst_add
[0] =
1597 w83781d_read_value(data
, W83781D_REG_TEMP_HYST(2));
1598 if (data
->type
!= w83783s
) {
1600 w83781d_read_value(data
, W83781D_REG_TEMP(3));
1601 data
->temp_max_add
[1] =
1602 w83781d_read_value(data
,
1603 W83781D_REG_TEMP_OVER(3));
1604 data
->temp_max_hyst_add
[1] =
1605 w83781d_read_value(data
,
1606 W83781D_REG_TEMP_HYST(3));
1608 i
= w83781d_read_value(data
, W83781D_REG_VID_FANDIV
);
1609 data
->vid
= i
& 0x0f;
1610 data
->vid
|= (w83781d_read_value(data
,
1611 W83781D_REG_CHIPID
) & 0x01) << 4;
1612 data
->fan_div
[0] = (i
>> 4) & 0x03;
1613 data
->fan_div
[1] = (i
>> 6) & 0x03;
1614 data
->fan_div
[2] = (w83781d_read_value(data
,
1615 W83781D_REG_PIN
) >> 6) & 0x03;
1616 if ((data
->type
!= w83781d
) && (data
->type
!= as99127f
)) {
1617 i
= w83781d_read_value(data
, W83781D_REG_VBAT
);
1618 data
->fan_div
[0] |= (i
>> 3) & 0x04;
1619 data
->fan_div
[1] |= (i
>> 4) & 0x04;
1620 data
->fan_div
[2] |= (i
>> 5) & 0x04;
1622 if ((data
->type
== w83782d
) || (data
->type
== w83627hf
)) {
1623 data
->alarms
= w83781d_read_value(data
,
1625 | (w83781d_read_value(data
,
1626 W83782D_REG_ALARM2
) << 8)
1627 | (w83781d_read_value(data
,
1628 W83782D_REG_ALARM3
) << 16);
1629 } else if (data
->type
== w83783s
) {
1630 data
->alarms
= w83781d_read_value(data
,
1632 | (w83781d_read_value(data
,
1633 W83782D_REG_ALARM2
) << 8);
1635 /* No real-time status registers, fall back to
1636 interrupt status registers */
1637 data
->alarms
= w83781d_read_value(data
,
1639 | (w83781d_read_value(data
,
1640 W83781D_REG_ALARM2
) << 8);
1642 i
= w83781d_read_value(data
, W83781D_REG_BEEP_INTS2
);
1643 data
->beep_enable
= i
>> 7;
1644 data
->beep_mask
= ((i
& 0x7f) << 8) +
1645 w83781d_read_value(data
, W83781D_REG_BEEP_INTS1
);
1646 if ((data
->type
!= w83781d
) && (data
->type
!= as99127f
)) {
1648 w83781d_read_value(data
,
1649 W83781D_REG_BEEP_INTS3
) << 16;
1651 data
->last_updated
= jiffies
;
1655 mutex_unlock(&data
->update_lock
);
1660 /* return 1 if a supported chip is found, 0 otherwise */
1662 w83781d_isa_found(unsigned short address
)
1664 int val
, save
, found
= 0;
1666 if (!request_region(address
, W83781D_EXTENT
, "w83781d"))
1669 #define REALLY_SLOW_IO
1670 /* We need the timeouts for at least some W83781D-like
1671 chips. But only if we read 'undefined' registers. */
1672 val
= inb_p(address
+ 1);
1673 if (inb_p(address
+ 2) != val
1674 || inb_p(address
+ 3) != val
1675 || inb_p(address
+ 7) != val
) {
1676 pr_debug("w83781d: Detection failed at step 1\n");
1679 #undef REALLY_SLOW_IO
1681 /* We should be able to change the 7 LSB of the address port. The
1682 MSB (busy flag) should be clear initially, set after the write. */
1683 save
= inb_p(address
+ W83781D_ADDR_REG_OFFSET
);
1685 pr_debug("w83781d: Detection failed at step 2\n");
1689 outb_p(val
, address
+ W83781D_ADDR_REG_OFFSET
);
1690 if (inb_p(address
+ W83781D_ADDR_REG_OFFSET
) != (val
| 0x80)) {
1691 outb_p(save
, address
+ W83781D_ADDR_REG_OFFSET
);
1692 pr_debug("w83781d: Detection failed at step 3\n");
1696 /* We found a device, now see if it could be a W83781D */
1697 outb_p(W83781D_REG_CONFIG
, address
+ W83781D_ADDR_REG_OFFSET
);
1698 val
= inb_p(address
+ W83781D_DATA_REG_OFFSET
);
1700 pr_debug("w83781d: Detection failed at step 4\n");
1703 outb_p(W83781D_REG_BANK
, address
+ W83781D_ADDR_REG_OFFSET
);
1704 save
= inb_p(address
+ W83781D_DATA_REG_OFFSET
);
1705 outb_p(W83781D_REG_CHIPMAN
, address
+ W83781D_ADDR_REG_OFFSET
);
1706 val
= inb_p(address
+ W83781D_DATA_REG_OFFSET
);
1707 if ((!(save
& 0x80) && (val
!= 0xa3))
1708 || ((save
& 0x80) && (val
!= 0x5c))) {
1709 pr_debug("w83781d: Detection failed at step 5\n");
1712 outb_p(W83781D_REG_I2C_ADDR
, address
+ W83781D_ADDR_REG_OFFSET
);
1713 val
= inb_p(address
+ W83781D_DATA_REG_OFFSET
);
1714 if (val
< 0x03 || val
> 0x77) { /* Not a valid I2C address */
1715 pr_debug("w83781d: Detection failed at step 6\n");
1719 /* The busy flag should be clear again */
1720 if (inb_p(address
+ W83781D_ADDR_REG_OFFSET
) & 0x80) {
1721 pr_debug("w83781d: Detection failed at step 7\n");
1725 /* Determine the chip type */
1726 outb_p(W83781D_REG_BANK
, address
+ W83781D_ADDR_REG_OFFSET
);
1727 save
= inb_p(address
+ W83781D_DATA_REG_OFFSET
);
1728 outb_p(save
& 0xf8, address
+ W83781D_DATA_REG_OFFSET
);
1729 outb_p(W83781D_REG_WCHIPID
, address
+ W83781D_ADDR_REG_OFFSET
);
1730 val
= inb_p(address
+ W83781D_DATA_REG_OFFSET
);
1731 if ((val
& 0xfe) == 0x10 /* W83781D */
1732 || val
== 0x30 /* W83782D */
1733 || val
== 0x21) /* W83627HF */
1737 pr_info("w83781d: Found a %s chip at %#x\n",
1738 val
== 0x21 ? "W83627HF" :
1739 val
== 0x30 ? "W83782D" : "W83781D", (int)address
);
1742 release_region(address
, W83781D_EXTENT
);
1747 w83781d_isa_device_add(unsigned short address
)
1749 struct resource res
= {
1751 .end
= address
+ W83781D_EXTENT
- 1,
1753 .flags
= IORESOURCE_IO
,
1757 pdev
= platform_device_alloc("w83781d", address
);
1760 printk(KERN_ERR
"w83781d: Device allocation failed\n");
1764 err
= platform_device_add_resources(pdev
, &res
, 1);
1766 printk(KERN_ERR
"w83781d: Device resource addition failed "
1768 goto exit_device_put
;
1771 err
= platform_device_add(pdev
);
1773 printk(KERN_ERR
"w83781d: Device addition failed (%d)\n",
1775 goto exit_device_put
;
1781 platform_device_put(pdev
);
1788 sensors_w83781d_init(void)
1792 res
= i2c_add_driver(&w83781d_driver
);
1796 if (w83781d_isa_found(isa_address
)) {
1797 res
= platform_driver_register(&w83781d_isa_driver
);
1799 goto exit_unreg_i2c_driver
;
1801 /* Sets global pdev as a side effect */
1802 res
= w83781d_isa_device_add(isa_address
);
1804 goto exit_unreg_isa_driver
;
1809 exit_unreg_isa_driver
:
1810 platform_driver_unregister(&w83781d_isa_driver
);
1811 exit_unreg_i2c_driver
:
1812 i2c_del_driver(&w83781d_driver
);
1818 sensors_w83781d_exit(void)
1821 platform_device_unregister(pdev
);
1822 platform_driver_unregister(&w83781d_isa_driver
);
1824 i2c_del_driver(&w83781d_driver
);
1827 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
1828 "Philip Edelbrock <phil@netroedge.com>, "
1829 "and Mark Studebaker <mdsxyz123@yahoo.com>");
1830 MODULE_DESCRIPTION("W83781D driver");
1831 MODULE_LICENSE("GPL");
1833 module_init(sensors_w83781d_init
);
1834 module_exit(sensors_w83781d_exit
);