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 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/platform_device.h>
42 #include <linux/ioport.h>
43 #include <linux/hwmon.h>
44 #include <linux/hwmon-vid.h>
45 #include <linux/hwmon-sysfs.h>
46 #include <linux/sysfs.h>
47 #include <linux/err.h>
48 #include <linux/mutex.h>
52 /* ISA device, if found */
53 static struct platform_device
*pdev
;
55 /* Addresses to scan */
56 <<<<<<< HEAD
:drivers
/hwmon
/w83781d
.c
57 static unsigned short normal_i2c
[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
58 0x2e, 0x2f, I2C_CLIENT_END
};
60 static const unsigned short normal_i2c
[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
61 0x2e, 0x2f, I2C_CLIENT_END
};
62 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a
:drivers
/hwmon
/w83781d
.c
63 static unsigned short isa_address
= 0x290;
65 /* Insmod parameters */
66 I2C_CLIENT_INSMOD_4(w83781d
, w83782d
, w83783s
, as99127f
);
67 I2C_CLIENT_MODULE_PARM(force_subclients
, "List of subclient addresses: "
68 "{bus, clientaddr, subclientaddr1, subclientaddr2}");
71 module_param(reset
, bool, 0);
72 MODULE_PARM_DESC(reset
, "Set to one to reset chip on load");
75 module_param(init
, bool, 0);
76 MODULE_PARM_DESC(init
, "Set to zero to bypass chip initialization");
78 /* Constants specified below */
80 /* Length of ISA address segment */
81 #define W83781D_EXTENT 8
83 /* Where are the ISA address/data registers relative to the base address */
84 #define W83781D_ADDR_REG_OFFSET 5
85 #define W83781D_DATA_REG_OFFSET 6
87 /* The device registers */
88 /* in nr from 0 to 8 */
89 #define W83781D_REG_IN_MAX(nr) ((nr < 7) ? (0x2b + (nr) * 2) : \
90 (0x554 + (((nr) - 7) * 2)))
91 #define W83781D_REG_IN_MIN(nr) ((nr < 7) ? (0x2c + (nr) * 2) : \
92 (0x555 + (((nr) - 7) * 2)))
93 #define W83781D_REG_IN(nr) ((nr < 7) ? (0x20 + (nr)) : \
96 /* fan nr from 0 to 2 */
97 #define W83781D_REG_FAN_MIN(nr) (0x3b + (nr))
98 #define W83781D_REG_FAN(nr) (0x28 + (nr))
100 #define W83781D_REG_BANK 0x4E
101 #define W83781D_REG_TEMP2_CONFIG 0x152
102 #define W83781D_REG_TEMP3_CONFIG 0x252
103 /* temp nr from 1 to 3 */
104 #define W83781D_REG_TEMP(nr) ((nr == 3) ? (0x0250) : \
105 ((nr == 2) ? (0x0150) : \
107 #define W83781D_REG_TEMP_HYST(nr) ((nr == 3) ? (0x253) : \
108 ((nr == 2) ? (0x153) : \
110 #define W83781D_REG_TEMP_OVER(nr) ((nr == 3) ? (0x255) : \
111 ((nr == 2) ? (0x155) : \
114 #define W83781D_REG_CONFIG 0x40
116 /* Interrupt status (W83781D, AS99127F) */
117 #define W83781D_REG_ALARM1 0x41
118 #define W83781D_REG_ALARM2 0x42
120 /* Real-time status (W83782D, W83783S) */
121 #define W83782D_REG_ALARM1 0x459
122 #define W83782D_REG_ALARM2 0x45A
123 #define W83782D_REG_ALARM3 0x45B
125 #define W83781D_REG_BEEP_CONFIG 0x4D
126 #define W83781D_REG_BEEP_INTS1 0x56
127 #define W83781D_REG_BEEP_INTS2 0x57
128 #define W83781D_REG_BEEP_INTS3 0x453 /* not on W83781D */
130 #define W83781D_REG_VID_FANDIV 0x47
132 #define W83781D_REG_CHIPID 0x49
133 #define W83781D_REG_WCHIPID 0x58
134 #define W83781D_REG_CHIPMAN 0x4F
135 #define W83781D_REG_PIN 0x4B
138 #define W83781D_REG_VBAT 0x5D
140 /* PWM 782D (1-4) and 783S (1-2) only */
141 static const u8 W83781D_REG_PWM
[] = { 0x5B, 0x5A, 0x5E, 0x5F };
142 #define W83781D_REG_PWMCLK12 0x5C
143 #define W83781D_REG_PWMCLK34 0x45C
145 #define W83781D_REG_I2C_ADDR 0x48
146 #define W83781D_REG_I2C_SUBADDR 0x4A
148 /* The following are undocumented in the data sheets however we
149 received the information in an email from Winbond tech support */
150 /* Sensor selection - not on 781d */
151 #define W83781D_REG_SCFG1 0x5D
152 static const u8 BIT_SCFG1
[] = { 0x02, 0x04, 0x08 };
154 #define W83781D_REG_SCFG2 0x59
155 static const u8 BIT_SCFG2
[] = { 0x10, 0x20, 0x40 };
157 #define W83781D_DEFAULT_BETA 3435
160 #define IN_TO_REG(val) SENSORS_LIMIT(((val) + 8) / 16, 0, 255)
161 #define IN_FROM_REG(val) ((val) * 16)
164 FAN_TO_REG(long rpm
, int div
)
168 rpm
= SENSORS_LIMIT(rpm
, 1, 1000000);
169 return SENSORS_LIMIT((1350000 + rpm
* div
/ 2) / (rpm
* div
), 1, 254);
173 FAN_FROM_REG(u8 val
, int div
)
179 return 1350000 / (val
* div
);
182 #define TEMP_TO_REG(val) SENSORS_LIMIT((val) / 1000, -127, 128)
183 #define TEMP_FROM_REG(val) ((val) * 1000)
185 #define BEEP_MASK_FROM_REG(val,type) ((type) == as99127f ? \
186 (val) ^ 0x7fff : (val))
187 #define BEEP_MASK_TO_REG(val,type) ((type) == as99127f ? \
188 (~(val)) & 0x7fff : (val) & 0xffffff)
190 #define DIV_FROM_REG(val) (1 << (val))
193 DIV_TO_REG(long val
, enum chips type
)
196 val
= SENSORS_LIMIT(val
, 1,
198 || type
== as99127f
) ? 8 : 128)) >> 1;
199 for (i
= 0; i
< 7; i
++) {
207 /* There are some complications in a module like this. First off, W83781D chips
208 may be both present on the SMBus and the ISA bus, and we have to handle
209 those cases separately at some places. Second, there might be several
210 W83781D chips available (well, actually, that is probably never done; but
211 it is a clean illustration of how to handle a case like that). Finally,
212 a specific chip may be attached to *both* ISA and SMBus, and we would
213 not like to detect it double. Fortunately, in the case of the W83781D at
214 least, a register tells us what SMBus address we are on, so that helps
215 a bit - except if there could be more than one SMBus. Groan. No solution
218 /* For ISA chips, we abuse the i2c_client addr and name fields. We also use
219 the driver field to differentiate between I2C and ISA chips. */
220 struct w83781d_data
{
221 struct i2c_client client
;
222 struct device
*hwmon_dev
;
226 struct mutex update_lock
;
227 char valid
; /* !=0 if following fields are valid */
228 unsigned long last_updated
; /* In jiffies */
230 struct i2c_client
*lm75
[2]; /* for secondary I2C addresses */
231 /* array of 2 pointers to subclients */
233 u8 in
[9]; /* Register value - 8 & 9 for 782D only */
234 u8 in_max
[9]; /* Register value - 8 & 9 for 782D only */
235 u8 in_min
[9]; /* Register value - 8 & 9 for 782D only */
236 u8 fan
[3]; /* Register value */
237 u8 fan_min
[3]; /* Register value */
238 s8 temp
; /* Register value */
239 s8 temp_max
; /* Register value */
240 s8 temp_max_hyst
; /* Register value */
241 u16 temp_add
[2]; /* Register value */
242 u16 temp_max_add
[2]; /* Register value */
243 u16 temp_max_hyst_add
[2]; /* Register value */
244 u8 fan_div
[3]; /* Register encoding, shifted right */
245 u8 vid
; /* Register encoding, combined */
246 u32 alarms
; /* Register encoding, combined */
247 u32 beep_mask
; /* Register encoding, combined */
248 u8 beep_enable
; /* Boolean */
249 u8 pwm
[4]; /* Register value */
250 u8 pwm2_enable
; /* Boolean */
251 u16 sens
[3]; /* 782D/783S only.
252 1 = pentium diode; 2 = 3904 diode;
257 static int w83781d_attach_adapter(struct i2c_adapter
*adapter
);
258 static int w83781d_detect(struct i2c_adapter
*adapter
, int address
, int kind
);
259 static int w83781d_detach_client(struct i2c_client
*client
);
261 static int __devinit
w83781d_isa_probe(struct platform_device
*pdev
);
262 static int __devexit
w83781d_isa_remove(struct platform_device
*pdev
);
264 static int w83781d_read_value(struct w83781d_data
*data
, u16 reg
);
265 static int w83781d_write_value(struct w83781d_data
*data
, u16 reg
, u16 value
);
266 static struct w83781d_data
*w83781d_update_device(struct device
*dev
);
267 static void w83781d_init_device(struct device
*dev
);
269 static struct i2c_driver w83781d_driver
= {
273 .attach_adapter
= w83781d_attach_adapter
,
274 .detach_client
= w83781d_detach_client
,
277 static struct platform_driver w83781d_isa_driver
= {
279 .owner
= THIS_MODULE
,
282 .probe
= w83781d_isa_probe
,
283 .remove
= w83781d_isa_remove
,
287 /* following are the sysfs callback functions */
288 #define show_in_reg(reg) \
289 static ssize_t show_##reg (struct device *dev, struct device_attribute *da, \
292 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
293 struct w83781d_data *data = w83781d_update_device(dev); \
294 return sprintf(buf, "%ld\n", \
295 (long)IN_FROM_REG(data->reg[attr->index])); \
301 #define store_in_reg(REG, reg) \
302 static ssize_t store_in_##reg (struct device *dev, struct device_attribute \
303 *da, const char *buf, size_t count) \
305 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
306 struct w83781d_data *data = dev_get_drvdata(dev); \
307 int nr = attr->index; \
310 val = simple_strtoul(buf, NULL, 10); \
312 mutex_lock(&data->update_lock); \
313 data->in_##reg[nr] = IN_TO_REG(val); \
314 w83781d_write_value(data, W83781D_REG_IN_##REG(nr), data->in_##reg[nr]); \
316 mutex_unlock(&data->update_lock); \
319 store_in_reg(MIN
, min
);
320 store_in_reg(MAX
, max
);
322 #define sysfs_in_offsets(offset) \
323 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
324 show_in, NULL, offset); \
325 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
326 show_in_min, store_in_min, offset); \
327 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
328 show_in_max, store_in_max, offset)
340 #define show_fan_reg(reg) \
341 static ssize_t show_##reg (struct device *dev, struct device_attribute *da, \
344 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
345 struct w83781d_data *data = w83781d_update_device(dev); \
346 return sprintf(buf,"%ld\n", \
347 FAN_FROM_REG(data->reg[attr->index], \
348 DIV_FROM_REG(data->fan_div[attr->index]))); \
351 show_fan_reg(fan_min
);
354 store_fan_min(struct device
*dev
, struct device_attribute
*da
,
355 const char *buf
, size_t count
)
357 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
358 struct w83781d_data
*data
= dev_get_drvdata(dev
);
359 int nr
= attr
->index
;
362 val
= simple_strtoul(buf
, NULL
, 10);
364 mutex_lock(&data
->update_lock
);
366 FAN_TO_REG(val
, DIV_FROM_REG(data
->fan_div
[nr
]));
367 w83781d_write_value(data
, W83781D_REG_FAN_MIN(nr
),
370 mutex_unlock(&data
->update_lock
);
374 static SENSOR_DEVICE_ATTR(fan1_input
, S_IRUGO
, show_fan
, NULL
, 0);
375 static SENSOR_DEVICE_ATTR(fan1_min
, S_IRUGO
| S_IWUSR
,
376 show_fan_min
, store_fan_min
, 0);
377 static SENSOR_DEVICE_ATTR(fan2_input
, S_IRUGO
, show_fan
, NULL
, 1);
378 static SENSOR_DEVICE_ATTR(fan2_min
, S_IRUGO
| S_IWUSR
,
379 show_fan_min
, store_fan_min
, 1);
380 static SENSOR_DEVICE_ATTR(fan3_input
, S_IRUGO
, show_fan
, NULL
, 2);
381 static SENSOR_DEVICE_ATTR(fan3_min
, S_IRUGO
| S_IWUSR
,
382 show_fan_min
, store_fan_min
, 2);
384 #define show_temp_reg(reg) \
385 static ssize_t show_##reg (struct device *dev, struct device_attribute *da, \
388 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
389 struct w83781d_data *data = w83781d_update_device(dev); \
390 int nr = attr->index; \
391 if (nr >= 2) { /* TEMP2 and TEMP3 */ \
392 return sprintf(buf,"%d\n", \
393 LM75_TEMP_FROM_REG(data->reg##_add[nr-2])); \
394 } else { /* TEMP1 */ \
395 return sprintf(buf,"%ld\n", (long)TEMP_FROM_REG(data->reg)); \
399 show_temp_reg(temp_max
);
400 show_temp_reg(temp_max_hyst
);
402 #define store_temp_reg(REG, reg) \
403 static ssize_t store_temp_##reg (struct device *dev, \
404 struct device_attribute *da, const char *buf, size_t count) \
406 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
407 struct w83781d_data *data = dev_get_drvdata(dev); \
408 int nr = attr->index; \
411 val = simple_strtol(buf, NULL, 10); \
413 mutex_lock(&data->update_lock); \
415 if (nr >= 2) { /* TEMP2 and TEMP3 */ \
416 data->temp_##reg##_add[nr-2] = LM75_TEMP_TO_REG(val); \
417 w83781d_write_value(data, W83781D_REG_TEMP_##REG(nr), \
418 data->temp_##reg##_add[nr-2]); \
419 } else { /* TEMP1 */ \
420 data->temp_##reg = TEMP_TO_REG(val); \
421 w83781d_write_value(data, W83781D_REG_TEMP_##REG(nr), \
425 mutex_unlock(&data->update_lock); \
428 store_temp_reg(OVER
, max
);
429 store_temp_reg(HYST
, max_hyst
);
431 #define sysfs_temp_offsets(offset) \
432 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
433 show_temp, NULL, offset); \
434 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
435 show_temp_max, store_temp_max, offset); \
436 static SENSOR_DEVICE_ATTR(temp##offset##_max_hyst, S_IRUGO | S_IWUSR, \
437 show_temp_max_hyst, store_temp_max_hyst, offset);
439 sysfs_temp_offsets(1);
440 sysfs_temp_offsets(2);
441 sysfs_temp_offsets(3);
444 show_vid_reg(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
446 struct w83781d_data
*data
= w83781d_update_device(dev
);
447 return sprintf(buf
, "%ld\n", (long) vid_from_reg(data
->vid
, data
->vrm
));
450 static DEVICE_ATTR(cpu0_vid
, S_IRUGO
, show_vid_reg
, NULL
);
453 show_vrm_reg(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
455 struct w83781d_data
*data
= dev_get_drvdata(dev
);
456 return sprintf(buf
, "%ld\n", (long) data
->vrm
);
460 store_vrm_reg(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
462 struct w83781d_data
*data
= dev_get_drvdata(dev
);
465 val
= simple_strtoul(buf
, NULL
, 10);
471 static DEVICE_ATTR(vrm
, S_IRUGO
| S_IWUSR
, show_vrm_reg
, store_vrm_reg
);
474 show_alarms_reg(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
476 struct w83781d_data
*data
= w83781d_update_device(dev
);
477 return sprintf(buf
, "%u\n", data
->alarms
);
480 static DEVICE_ATTR(alarms
, S_IRUGO
, show_alarms_reg
, NULL
);
482 static ssize_t
show_alarm(struct device
*dev
, struct device_attribute
*attr
,
485 struct w83781d_data
*data
= w83781d_update_device(dev
);
486 int bitnr
= to_sensor_dev_attr(attr
)->index
;
487 return sprintf(buf
, "%u\n", (data
->alarms
>> bitnr
) & 1);
490 /* The W83781D has a single alarm bit for temp2 and temp3 */
491 static ssize_t
show_temp3_alarm(struct device
*dev
,
492 struct device_attribute
*attr
, char *buf
)
494 struct w83781d_data
*data
= w83781d_update_device(dev
);
495 int bitnr
= (data
->type
== w83781d
) ? 5 : 13;
496 return sprintf(buf
, "%u\n", (data
->alarms
>> bitnr
) & 1);
499 static SENSOR_DEVICE_ATTR(in0_alarm
, S_IRUGO
, show_alarm
, NULL
, 0);
500 static SENSOR_DEVICE_ATTR(in1_alarm
, S_IRUGO
, show_alarm
, NULL
, 1);
501 static SENSOR_DEVICE_ATTR(in2_alarm
, S_IRUGO
, show_alarm
, NULL
, 2);
502 static SENSOR_DEVICE_ATTR(in3_alarm
, S_IRUGO
, show_alarm
, NULL
, 3);
503 static SENSOR_DEVICE_ATTR(in4_alarm
, S_IRUGO
, show_alarm
, NULL
, 8);
504 static SENSOR_DEVICE_ATTR(in5_alarm
, S_IRUGO
, show_alarm
, NULL
, 9);
505 static SENSOR_DEVICE_ATTR(in6_alarm
, S_IRUGO
, show_alarm
, NULL
, 10);
506 static SENSOR_DEVICE_ATTR(in7_alarm
, S_IRUGO
, show_alarm
, NULL
, 16);
507 static SENSOR_DEVICE_ATTR(in8_alarm
, S_IRUGO
, show_alarm
, NULL
, 17);
508 static SENSOR_DEVICE_ATTR(fan1_alarm
, S_IRUGO
, show_alarm
, NULL
, 6);
509 static SENSOR_DEVICE_ATTR(fan2_alarm
, S_IRUGO
, show_alarm
, NULL
, 7);
510 static SENSOR_DEVICE_ATTR(fan3_alarm
, S_IRUGO
, show_alarm
, NULL
, 11);
511 static SENSOR_DEVICE_ATTR(temp1_alarm
, S_IRUGO
, show_alarm
, NULL
, 4);
512 static SENSOR_DEVICE_ATTR(temp2_alarm
, S_IRUGO
, show_alarm
, NULL
, 5);
513 static SENSOR_DEVICE_ATTR(temp3_alarm
, S_IRUGO
, show_temp3_alarm
, NULL
, 0);
515 static ssize_t
show_beep_mask (struct device
*dev
, struct device_attribute
*attr
, char *buf
)
517 struct w83781d_data
*data
= w83781d_update_device(dev
);
518 return sprintf(buf
, "%ld\n",
519 (long)BEEP_MASK_FROM_REG(data
->beep_mask
, data
->type
));
521 static ssize_t
show_beep_enable (struct device
*dev
, struct device_attribute
*attr
, char *buf
)
523 struct w83781d_data
*data
= w83781d_update_device(dev
);
524 return sprintf(buf
, "%ld\n", (long)data
->beep_enable
);
528 store_beep_mask(struct device
*dev
, struct device_attribute
*attr
,
529 const char *buf
, size_t count
)
531 struct w83781d_data
*data
= dev_get_drvdata(dev
);
534 val
= simple_strtoul(buf
, NULL
, 10);
536 mutex_lock(&data
->update_lock
);
537 data
->beep_mask
= BEEP_MASK_TO_REG(val
, data
->type
);
538 w83781d_write_value(data
, W83781D_REG_BEEP_INTS1
,
539 data
->beep_mask
& 0xff);
540 w83781d_write_value(data
, W83781D_REG_BEEP_INTS2
,
541 ((data
->beep_mask
>> 8) & 0x7f)
542 | data
->beep_enable
<< 7);
543 if (data
->type
!= w83781d
&& data
->type
!= as99127f
) {
544 w83781d_write_value(data
, W83781D_REG_BEEP_INTS3
,
545 ((data
->beep_mask
) >> 16) & 0xff);
547 mutex_unlock(&data
->update_lock
);
553 store_beep_enable(struct device
*dev
, struct device_attribute
*attr
,
554 const char *buf
, size_t count
)
556 struct w83781d_data
*data
= dev_get_drvdata(dev
);
559 val
= simple_strtoul(buf
, NULL
, 10);
560 if (val
!= 0 && val
!= 1)
563 mutex_lock(&data
->update_lock
);
564 data
->beep_enable
= val
;
565 val
= w83781d_read_value(data
, W83781D_REG_BEEP_INTS2
) & 0x7f;
566 val
|= data
->beep_enable
<< 7;
567 w83781d_write_value(data
, W83781D_REG_BEEP_INTS2
, val
);
568 mutex_unlock(&data
->update_lock
);
573 static DEVICE_ATTR(beep_mask
, S_IRUGO
| S_IWUSR
,
574 show_beep_mask
, store_beep_mask
);
575 static DEVICE_ATTR(beep_enable
, S_IRUGO
| S_IWUSR
,
576 show_beep_enable
, store_beep_enable
);
578 static ssize_t
show_beep(struct device
*dev
, struct device_attribute
*attr
,
581 struct w83781d_data
*data
= w83781d_update_device(dev
);
582 int bitnr
= to_sensor_dev_attr(attr
)->index
;
583 return sprintf(buf
, "%u\n", (data
->beep_mask
>> bitnr
) & 1);
587 store_beep(struct device
*dev
, struct device_attribute
*attr
,
588 const char *buf
, size_t count
)
590 struct w83781d_data
*data
= dev_get_drvdata(dev
);
591 int bitnr
= to_sensor_dev_attr(attr
)->index
;
595 bit
= simple_strtoul(buf
, NULL
, 10);
599 mutex_lock(&data
->update_lock
);
601 data
->beep_mask
|= (1 << bitnr
);
603 data
->beep_mask
&= ~(1 << bitnr
);
606 reg
= w83781d_read_value(data
, W83781D_REG_BEEP_INTS1
);
610 reg
&= ~(1 << bitnr
);
611 w83781d_write_value(data
, W83781D_REG_BEEP_INTS1
, reg
);
612 } else if (bitnr
< 16) {
613 reg
= w83781d_read_value(data
, W83781D_REG_BEEP_INTS2
);
615 reg
|= (1 << (bitnr
- 8));
617 reg
&= ~(1 << (bitnr
- 8));
618 w83781d_write_value(data
, W83781D_REG_BEEP_INTS2
, reg
);
620 reg
= w83781d_read_value(data
, W83781D_REG_BEEP_INTS3
);
622 reg
|= (1 << (bitnr
- 16));
624 reg
&= ~(1 << (bitnr
- 16));
625 w83781d_write_value(data
, W83781D_REG_BEEP_INTS3
, reg
);
627 mutex_unlock(&data
->update_lock
);
632 /* The W83781D has a single beep bit for temp2 and temp3 */
633 static ssize_t
show_temp3_beep(struct device
*dev
,
634 struct device_attribute
*attr
, char *buf
)
636 struct w83781d_data
*data
= w83781d_update_device(dev
);
637 int bitnr
= (data
->type
== w83781d
) ? 5 : 13;
638 return sprintf(buf
, "%u\n", (data
->beep_mask
>> bitnr
) & 1);
641 static SENSOR_DEVICE_ATTR(in0_beep
, S_IRUGO
| S_IWUSR
,
642 show_beep
, store_beep
, 0);
643 static SENSOR_DEVICE_ATTR(in1_beep
, S_IRUGO
| S_IWUSR
,
644 show_beep
, store_beep
, 1);
645 static SENSOR_DEVICE_ATTR(in2_beep
, S_IRUGO
| S_IWUSR
,
646 show_beep
, store_beep
, 2);
647 static SENSOR_DEVICE_ATTR(in3_beep
, S_IRUGO
| S_IWUSR
,
648 show_beep
, store_beep
, 3);
649 static SENSOR_DEVICE_ATTR(in4_beep
, S_IRUGO
| S_IWUSR
,
650 show_beep
, store_beep
, 8);
651 static SENSOR_DEVICE_ATTR(in5_beep
, S_IRUGO
| S_IWUSR
,
652 show_beep
, store_beep
, 9);
653 static SENSOR_DEVICE_ATTR(in6_beep
, S_IRUGO
| S_IWUSR
,
654 show_beep
, store_beep
, 10);
655 static SENSOR_DEVICE_ATTR(in7_beep
, S_IRUGO
| S_IWUSR
,
656 show_beep
, store_beep
, 16);
657 static SENSOR_DEVICE_ATTR(in8_beep
, S_IRUGO
| S_IWUSR
,
658 show_beep
, store_beep
, 17);
659 static SENSOR_DEVICE_ATTR(fan1_beep
, S_IRUGO
| S_IWUSR
,
660 show_beep
, store_beep
, 6);
661 static SENSOR_DEVICE_ATTR(fan2_beep
, S_IRUGO
| S_IWUSR
,
662 show_beep
, store_beep
, 7);
663 static SENSOR_DEVICE_ATTR(fan3_beep
, S_IRUGO
| S_IWUSR
,
664 show_beep
, store_beep
, 11);
665 static SENSOR_DEVICE_ATTR(temp1_beep
, S_IRUGO
| S_IWUSR
,
666 show_beep
, store_beep
, 4);
667 static SENSOR_DEVICE_ATTR(temp2_beep
, S_IRUGO
| S_IWUSR
,
668 show_beep
, store_beep
, 5);
669 static SENSOR_DEVICE_ATTR(temp3_beep
, S_IRUGO
,
670 show_temp3_beep
, store_beep
, 13);
673 show_fan_div(struct device
*dev
, struct device_attribute
*da
, char *buf
)
675 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
676 struct w83781d_data
*data
= w83781d_update_device(dev
);
677 return sprintf(buf
, "%ld\n",
678 (long) DIV_FROM_REG(data
->fan_div
[attr
->index
]));
681 /* Note: we save and restore the fan minimum here, because its value is
682 determined in part by the fan divisor. This follows the principle of
683 least surprise; the user doesn't expect the fan minimum to change just
684 because the divisor changed. */
686 store_fan_div(struct device
*dev
, struct device_attribute
*da
,
687 const char *buf
, size_t count
)
689 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
690 struct w83781d_data
*data
= dev_get_drvdata(dev
);
692 int nr
= attr
->index
;
694 unsigned long val
= simple_strtoul(buf
, NULL
, 10);
696 mutex_lock(&data
->update_lock
);
699 min
= FAN_FROM_REG(data
->fan_min
[nr
],
700 DIV_FROM_REG(data
->fan_div
[nr
]));
702 data
->fan_div
[nr
] = DIV_TO_REG(val
, data
->type
);
704 reg
= (w83781d_read_value(data
, nr
==2 ? W83781D_REG_PIN
: W83781D_REG_VID_FANDIV
)
705 & (nr
==0 ? 0xcf : 0x3f))
706 | ((data
->fan_div
[nr
] & 0x03) << (nr
==0 ? 4 : 6));
707 w83781d_write_value(data
, nr
==2 ? W83781D_REG_PIN
: W83781D_REG_VID_FANDIV
, reg
);
709 /* w83781d and as99127f don't have extended divisor bits */
710 if (data
->type
!= w83781d
&& data
->type
!= as99127f
) {
711 reg
= (w83781d_read_value(data
, W83781D_REG_VBAT
)
713 | ((data
->fan_div
[nr
] & 0x04) << (3 + nr
));
714 w83781d_write_value(data
, W83781D_REG_VBAT
, reg
);
717 /* Restore fan_min */
718 data
->fan_min
[nr
] = FAN_TO_REG(min
, DIV_FROM_REG(data
->fan_div
[nr
]));
719 w83781d_write_value(data
, W83781D_REG_FAN_MIN(nr
), data
->fan_min
[nr
]);
721 mutex_unlock(&data
->update_lock
);
725 static SENSOR_DEVICE_ATTR(fan1_div
, S_IRUGO
| S_IWUSR
,
726 show_fan_div
, store_fan_div
, 0);
727 static SENSOR_DEVICE_ATTR(fan2_div
, S_IRUGO
| S_IWUSR
,
728 show_fan_div
, store_fan_div
, 1);
729 static SENSOR_DEVICE_ATTR(fan3_div
, S_IRUGO
| S_IWUSR
,
730 show_fan_div
, store_fan_div
, 2);
733 show_pwm(struct device
*dev
, struct device_attribute
*da
, char *buf
)
735 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
736 struct w83781d_data
*data
= w83781d_update_device(dev
);
737 return sprintf(buf
, "%d\n", (int)data
->pwm
[attr
->index
]);
741 show_pwm2_enable(struct device
*dev
, struct device_attribute
*da
, char *buf
)
743 struct w83781d_data
*data
= w83781d_update_device(dev
);
744 return sprintf(buf
, "%d\n", (int)data
->pwm2_enable
);
748 store_pwm(struct device
*dev
, struct device_attribute
*da
, const char *buf
,
751 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
752 struct w83781d_data
*data
= dev_get_drvdata(dev
);
753 int nr
= attr
->index
;
756 val
= simple_strtoul(buf
, NULL
, 10);
758 mutex_lock(&data
->update_lock
);
759 data
->pwm
[nr
] = SENSORS_LIMIT(val
, 0, 255);
760 w83781d_write_value(data
, W83781D_REG_PWM
[nr
], data
->pwm
[nr
]);
761 mutex_unlock(&data
->update_lock
);
766 store_pwm2_enable(struct device
*dev
, struct device_attribute
*da
,
767 const char *buf
, size_t count
)
769 struct w83781d_data
*data
= dev_get_drvdata(dev
);
772 val
= simple_strtoul(buf
, NULL
, 10);
774 mutex_lock(&data
->update_lock
);
779 reg
= w83781d_read_value(data
, W83781D_REG_PWMCLK12
);
780 w83781d_write_value(data
, W83781D_REG_PWMCLK12
,
781 (reg
& 0xf7) | (val
<< 3));
783 reg
= w83781d_read_value(data
, W83781D_REG_BEEP_CONFIG
);
784 w83781d_write_value(data
, W83781D_REG_BEEP_CONFIG
,
785 (reg
& 0xef) | (!val
<< 4));
787 data
->pwm2_enable
= val
;
791 mutex_unlock(&data
->update_lock
);
795 mutex_unlock(&data
->update_lock
);
799 static SENSOR_DEVICE_ATTR(pwm1
, S_IRUGO
| S_IWUSR
, show_pwm
, store_pwm
, 0);
800 static SENSOR_DEVICE_ATTR(pwm2
, S_IRUGO
| S_IWUSR
, show_pwm
, store_pwm
, 1);
801 static SENSOR_DEVICE_ATTR(pwm3
, S_IRUGO
| S_IWUSR
, show_pwm
, store_pwm
, 2);
802 static SENSOR_DEVICE_ATTR(pwm4
, S_IRUGO
| S_IWUSR
, show_pwm
, store_pwm
, 3);
803 /* only PWM2 can be enabled/disabled */
804 static DEVICE_ATTR(pwm2_enable
, S_IRUGO
| S_IWUSR
,
805 show_pwm2_enable
, store_pwm2_enable
);
808 show_sensor(struct device
*dev
, struct device_attribute
*da
, char *buf
)
810 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
811 struct w83781d_data
*data
= w83781d_update_device(dev
);
812 return sprintf(buf
, "%d\n", (int)data
->sens
[attr
->index
]);
816 store_sensor(struct device
*dev
, struct device_attribute
*da
,
817 const char *buf
, size_t count
)
819 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
820 struct w83781d_data
*data
= dev_get_drvdata(dev
);
821 int nr
= attr
->index
;
824 val
= simple_strtoul(buf
, NULL
, 10);
826 mutex_lock(&data
->update_lock
);
829 case 1: /* PII/Celeron diode */
830 tmp
= w83781d_read_value(data
, W83781D_REG_SCFG1
);
831 w83781d_write_value(data
, W83781D_REG_SCFG1
,
832 tmp
| BIT_SCFG1
[nr
]);
833 tmp
= w83781d_read_value(data
, W83781D_REG_SCFG2
);
834 w83781d_write_value(data
, W83781D_REG_SCFG2
,
835 tmp
| BIT_SCFG2
[nr
]);
836 data
->sens
[nr
] = val
;
839 tmp
= w83781d_read_value(data
, W83781D_REG_SCFG1
);
840 w83781d_write_value(data
, W83781D_REG_SCFG1
,
841 tmp
| BIT_SCFG1
[nr
]);
842 tmp
= w83781d_read_value(data
, W83781D_REG_SCFG2
);
843 w83781d_write_value(data
, W83781D_REG_SCFG2
,
844 tmp
& ~BIT_SCFG2
[nr
]);
845 data
->sens
[nr
] = val
;
847 case W83781D_DEFAULT_BETA
:
848 dev_warn(dev
, "Sensor type %d is deprecated, please use 4 "
849 "instead\n", W83781D_DEFAULT_BETA
);
851 case 4: /* thermistor */
852 tmp
= w83781d_read_value(data
, W83781D_REG_SCFG1
);
853 w83781d_write_value(data
, W83781D_REG_SCFG1
,
854 tmp
& ~BIT_SCFG1
[nr
]);
855 data
->sens
[nr
] = val
;
858 dev_err(dev
, "Invalid sensor type %ld; must be 1, 2, or 4\n",
863 mutex_unlock(&data
->update_lock
);
867 static SENSOR_DEVICE_ATTR(temp1_type
, S_IRUGO
| S_IWUSR
,
868 show_sensor
, store_sensor
, 0);
869 static SENSOR_DEVICE_ATTR(temp2_type
, S_IRUGO
| S_IWUSR
,
870 show_sensor
, store_sensor
, 1);
871 static SENSOR_DEVICE_ATTR(temp3_type
, S_IRUGO
| S_IWUSR
,
872 show_sensor
, store_sensor
, 2);
874 /* I2C devices get this name attribute automatically, but for ISA devices
875 we must create it by ourselves. */
877 show_name(struct device
*dev
, struct device_attribute
*devattr
, char *buf
)
879 struct w83781d_data
*data
= dev_get_drvdata(dev
);
880 return sprintf(buf
, "%s\n", data
->client
.name
);
882 static DEVICE_ATTR(name
, S_IRUGO
, show_name
, NULL
);
884 /* This function is called when:
885 * w83781d_driver is inserted (when this module is loaded), for each
887 * when a new adapter is inserted (and w83781d_driver is still present) */
889 w83781d_attach_adapter(struct i2c_adapter
*adapter
)
891 if (!(adapter
->class & I2C_CLASS_HWMON
))
893 return i2c_probe(adapter
, &addr_data
, w83781d_detect
);
896 /* Assumes that adapter is of I2C, not ISA variety.
897 * OTHERWISE DON'T CALL THIS
900 w83781d_detect_subclients(struct i2c_adapter
*adapter
, int address
, int kind
,
901 struct i2c_client
*new_client
)
905 const char *client_name
= "";
906 struct w83781d_data
*data
= i2c_get_clientdata(new_client
);
908 data
->lm75
[0] = kzalloc(sizeof(struct i2c_client
), GFP_KERNEL
);
909 if (!(data
->lm75
[0])) {
914 id
= i2c_adapter_id(adapter
);
916 if (force_subclients
[0] == id
&& force_subclients
[1] == address
) {
917 for (i
= 2; i
<= 3; i
++) {
918 if (force_subclients
[i
] < 0x48 ||
919 force_subclients
[i
] > 0x4f) {
920 dev_err(&new_client
->dev
, "Invalid subclient "
921 "address %d; must be 0x48-0x4f\n",
922 force_subclients
[i
]);
927 w83781d_write_value(data
, W83781D_REG_I2C_SUBADDR
,
928 (force_subclients
[2] & 0x07) |
929 ((force_subclients
[3] & 0x07) << 4));
930 data
->lm75
[0]->addr
= force_subclients
[2];
932 val1
= w83781d_read_value(data
, W83781D_REG_I2C_SUBADDR
);
933 data
->lm75
[0]->addr
= 0x48 + (val1
& 0x07);
936 if (kind
!= w83783s
) {
937 data
->lm75
[1] = kzalloc(sizeof(struct i2c_client
), GFP_KERNEL
);
938 if (!(data
->lm75
[1])) {
943 if (force_subclients
[0] == id
&&
944 force_subclients
[1] == address
) {
945 data
->lm75
[1]->addr
= force_subclients
[3];
947 data
->lm75
[1]->addr
= 0x48 + ((val1
>> 4) & 0x07);
949 if (data
->lm75
[0]->addr
== data
->lm75
[1]->addr
) {
950 dev_err(&new_client
->dev
,
951 "Duplicate addresses 0x%x for subclients.\n",
952 data
->lm75
[0]->addr
);
959 client_name
= "w83781d subclient";
960 else if (kind
== w83782d
)
961 client_name
= "w83782d subclient";
962 else if (kind
== w83783s
)
963 client_name
= "w83783s subclient";
964 else if (kind
== as99127f
)
965 client_name
= "as99127f subclient";
967 for (i
= 0; i
<= 1; i
++) {
968 /* store all data in w83781d */
969 i2c_set_clientdata(data
->lm75
[i
], NULL
);
970 data
->lm75
[i
]->adapter
= adapter
;
971 data
->lm75
[i
]->driver
= &w83781d_driver
;
972 data
->lm75
[i
]->flags
= 0;
973 strlcpy(data
->lm75
[i
]->name
, client_name
,
975 if ((err
= i2c_attach_client(data
->lm75
[i
]))) {
976 dev_err(&new_client
->dev
, "Subclient %d "
977 "registration at address 0x%x "
978 "failed.\n", i
, data
->lm75
[i
]->addr
);
989 /* Undo inits in case of errors */
991 i2c_detach_client(data
->lm75
[0]);
993 kfree(data
->lm75
[1]);
995 kfree(data
->lm75
[0]);
1000 #define IN_UNIT_ATTRS(X) \
1001 &sensor_dev_attr_in##X##_input.dev_attr.attr, \
1002 &sensor_dev_attr_in##X##_min.dev_attr.attr, \
1003 &sensor_dev_attr_in##X##_max.dev_attr.attr, \
1004 &sensor_dev_attr_in##X##_alarm.dev_attr.attr, \
1005 &sensor_dev_attr_in##X##_beep.dev_attr.attr
1007 #define FAN_UNIT_ATTRS(X) \
1008 &sensor_dev_attr_fan##X##_input.dev_attr.attr, \
1009 &sensor_dev_attr_fan##X##_min.dev_attr.attr, \
1010 &sensor_dev_attr_fan##X##_div.dev_attr.attr, \
1011 &sensor_dev_attr_fan##X##_alarm.dev_attr.attr, \
1012 &sensor_dev_attr_fan##X##_beep.dev_attr.attr
1014 #define TEMP_UNIT_ATTRS(X) \
1015 &sensor_dev_attr_temp##X##_input.dev_attr.attr, \
1016 &sensor_dev_attr_temp##X##_max.dev_attr.attr, \
1017 &sensor_dev_attr_temp##X##_max_hyst.dev_attr.attr, \
1018 &sensor_dev_attr_temp##X##_alarm.dev_attr.attr, \
1019 &sensor_dev_attr_temp##X##_beep.dev_attr.attr
1021 static struct attribute
* w83781d_attributes
[] = {
1033 &dev_attr_cpu0_vid
.attr
,
1035 &dev_attr_alarms
.attr
,
1036 &dev_attr_beep_mask
.attr
,
1037 &dev_attr_beep_enable
.attr
,
1040 static const struct attribute_group w83781d_group
= {
1041 .attrs
= w83781d_attributes
,
1044 static struct attribute
*w83781d_attributes_opt
[] = {
1049 &sensor_dev_attr_pwm1
.dev_attr
.attr
,
1050 &sensor_dev_attr_pwm2
.dev_attr
.attr
,
1051 &sensor_dev_attr_pwm3
.dev_attr
.attr
,
1052 &sensor_dev_attr_pwm4
.dev_attr
.attr
,
1053 &dev_attr_pwm2_enable
.attr
,
1054 &sensor_dev_attr_temp1_type
.dev_attr
.attr
,
1055 &sensor_dev_attr_temp2_type
.dev_attr
.attr
,
1056 &sensor_dev_attr_temp3_type
.dev_attr
.attr
,
1059 static const struct attribute_group w83781d_group_opt
= {
1060 .attrs
= w83781d_attributes_opt
,
1063 /* No clean up is done on error, it's up to the caller */
1065 w83781d_create_files(struct device
*dev
, int kind
, int is_isa
)
1069 if ((err
= sysfs_create_group(&dev
->kobj
, &w83781d_group
)))
1072 if (kind
!= w83783s
) {
1073 if ((err
= device_create_file(dev
,
1074 &sensor_dev_attr_in1_input
.dev_attr
))
1075 || (err
= device_create_file(dev
,
1076 &sensor_dev_attr_in1_min
.dev_attr
))
1077 || (err
= device_create_file(dev
,
1078 &sensor_dev_attr_in1_max
.dev_attr
))
1079 || (err
= device_create_file(dev
,
1080 &sensor_dev_attr_in1_alarm
.dev_attr
))
1081 || (err
= device_create_file(dev
,
1082 &sensor_dev_attr_in1_beep
.dev_attr
)))
1085 if (kind
!= as99127f
&& kind
!= w83781d
&& kind
!= w83783s
) {
1086 if ((err
= device_create_file(dev
,
1087 &sensor_dev_attr_in7_input
.dev_attr
))
1088 || (err
= device_create_file(dev
,
1089 &sensor_dev_attr_in7_min
.dev_attr
))
1090 || (err
= device_create_file(dev
,
1091 &sensor_dev_attr_in7_max
.dev_attr
))
1092 || (err
= device_create_file(dev
,
1093 &sensor_dev_attr_in7_alarm
.dev_attr
))
1094 || (err
= device_create_file(dev
,
1095 &sensor_dev_attr_in7_beep
.dev_attr
))
1096 || (err
= device_create_file(dev
,
1097 &sensor_dev_attr_in8_input
.dev_attr
))
1098 || (err
= device_create_file(dev
,
1099 &sensor_dev_attr_in8_min
.dev_attr
))
1100 || (err
= device_create_file(dev
,
1101 &sensor_dev_attr_in8_max
.dev_attr
))
1102 || (err
= device_create_file(dev
,
1103 &sensor_dev_attr_in8_alarm
.dev_attr
))
1104 || (err
= device_create_file(dev
,
1105 &sensor_dev_attr_in8_beep
.dev_attr
)))
1108 if (kind
!= w83783s
) {
1109 if ((err
= device_create_file(dev
,
1110 &sensor_dev_attr_temp3_input
.dev_attr
))
1111 || (err
= device_create_file(dev
,
1112 &sensor_dev_attr_temp3_max
.dev_attr
))
1113 || (err
= device_create_file(dev
,
1114 &sensor_dev_attr_temp3_max_hyst
.dev_attr
))
1115 || (err
= device_create_file(dev
,
1116 &sensor_dev_attr_temp3_alarm
.dev_attr
))
1117 || (err
= device_create_file(dev
,
1118 &sensor_dev_attr_temp3_beep
.dev_attr
)))
1121 if (kind
!= w83781d
) {
1122 err
= sysfs_chmod_file(&dev
->kobj
,
1123 &sensor_dev_attr_temp3_alarm
.dev_attr
.attr
,
1130 if (kind
!= w83781d
&& kind
!= as99127f
) {
1131 if ((err
= device_create_file(dev
,
1132 &sensor_dev_attr_pwm1
.dev_attr
))
1133 || (err
= device_create_file(dev
,
1134 &sensor_dev_attr_pwm2
.dev_attr
))
1135 || (err
= device_create_file(dev
, &dev_attr_pwm2_enable
)))
1138 if (kind
== w83782d
&& !is_isa
) {
1139 if ((err
= device_create_file(dev
,
1140 &sensor_dev_attr_pwm3
.dev_attr
))
1141 || (err
= device_create_file(dev
,
1142 &sensor_dev_attr_pwm4
.dev_attr
)))
1146 if (kind
!= as99127f
&& kind
!= w83781d
) {
1147 if ((err
= device_create_file(dev
,
1148 &sensor_dev_attr_temp1_type
.dev_attr
))
1149 || (err
= device_create_file(dev
,
1150 &sensor_dev_attr_temp2_type
.dev_attr
)))
1152 if (kind
!= w83783s
) {
1153 if ((err
= device_create_file(dev
,
1154 &sensor_dev_attr_temp3_type
.dev_attr
)))
1160 err
= device_create_file(&pdev
->dev
, &dev_attr_name
);
1169 w83781d_detect(struct i2c_adapter
*adapter
, int address
, int kind
)
1172 struct i2c_client
*client
;
1174 struct w83781d_data
*data
;
1176 const char *client_name
= "";
1177 enum vendor
{ winbond
, asus
} vendid
;
1179 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
)) {
1184 /* OK. For now, we presume we have a valid client. We now create the
1185 client structure, even though we cannot fill it completely yet.
1186 But it allows us to access w83781d_{read,write}_value. */
1188 if (!(data
= kzalloc(sizeof(struct w83781d_data
), GFP_KERNEL
))) {
1193 client
= &data
->client
;
1194 i2c_set_clientdata(client
, data
);
1195 client
->addr
= address
;
1196 mutex_init(&data
->lock
);
1197 client
->adapter
= adapter
;
1198 client
->driver
= &w83781d_driver
;
1201 /* Now, we do the remaining detection. */
1203 /* The w8378?d may be stuck in some other bank than bank 0. This may
1204 make reading other information impossible. Specify a force=... or
1205 force_*=... parameter, and the Winbond will be reset to the right
1208 if (w83781d_read_value(data
, W83781D_REG_CONFIG
) & 0x80) {
1209 dev_dbg(&adapter
->dev
, "Detection of w83781d chip "
1210 "failed at step 3\n");
1214 val1
= w83781d_read_value(data
, W83781D_REG_BANK
);
1215 val2
= w83781d_read_value(data
, W83781D_REG_CHIPMAN
);
1216 /* Check for Winbond or Asus ID if in bank 0 */
1217 if ((!(val1
& 0x07)) &&
1218 (((!(val1
& 0x80)) && (val2
!= 0xa3) && (val2
!= 0xc3))
1219 || ((val1
& 0x80) && (val2
!= 0x5c) && (val2
!= 0x12)))) {
1220 dev_dbg(&adapter
->dev
, "Detection of w83781d chip "
1221 "failed at step 4\n");
1225 /* If Winbond SMBus, check address at 0x48.
1226 Asus doesn't support, except for as99127f rev.2 */
1227 if ((!(val1
& 0x80) && (val2
== 0xa3)) ||
1228 ((val1
& 0x80) && (val2
== 0x5c))) {
1229 if (w83781d_read_value
1230 (data
, W83781D_REG_I2C_ADDR
) != address
) {
1231 dev_dbg(&adapter
->dev
, "Detection of w83781d "
1232 "chip failed at step 5\n");
1239 /* We have either had a force parameter, or we have already detected the
1240 Winbond. Put it now into bank 0 and Vendor ID High Byte */
1241 w83781d_write_value(data
, W83781D_REG_BANK
,
1242 (w83781d_read_value(data
, W83781D_REG_BANK
)
1245 /* Determine the chip type. */
1248 val2
= w83781d_read_value(data
, W83781D_REG_CHIPMAN
);
1251 else if (val2
== 0x12)
1254 dev_dbg(&adapter
->dev
, "w83781d chip vendor is "
1255 "neither Winbond nor Asus\n");
1260 val1
= w83781d_read_value(data
, W83781D_REG_WCHIPID
);
1261 if ((val1
== 0x10 || val1
== 0x11) && vendid
== winbond
)
1263 else if (val1
== 0x30 && vendid
== winbond
)
1265 else if (val1
== 0x40 && vendid
== winbond
&& address
== 0x2d)
1267 else if (val1
== 0x31)
1271 dev_warn(&adapter
->dev
, "Ignoring 'force' "
1272 "parameter for unknown chip at "
1273 "address 0x%02x\n", address
);
1279 if (kind
== w83781d
) {
1280 client_name
= "w83781d";
1281 } else if (kind
== w83782d
) {
1282 client_name
= "w83782d";
1283 } else if (kind
== w83783s
) {
1284 client_name
= "w83783s";
1285 } else if (kind
== as99127f
) {
1286 client_name
= "as99127f";
1289 /* Fill in the remaining client fields and put into the global list */
1290 strlcpy(client
->name
, client_name
, I2C_NAME_SIZE
);
1293 /* Tell the I2C layer a new client has arrived */
1294 if ((err
= i2c_attach_client(client
)))
1297 /* attach secondary i2c lm75-like clients */
1298 if ((err
= w83781d_detect_subclients(adapter
, address
,
1302 /* Initialize the chip */
1303 w83781d_init_device(dev
);
1305 /* Register sysfs hooks */
1306 err
= w83781d_create_files(dev
, kind
, 0);
1310 data
->hwmon_dev
= hwmon_device_register(dev
);
1311 if (IS_ERR(data
->hwmon_dev
)) {
1312 err
= PTR_ERR(data
->hwmon_dev
);
1319 sysfs_remove_group(&dev
->kobj
, &w83781d_group
);
1320 sysfs_remove_group(&dev
->kobj
, &w83781d_group_opt
);
1322 if (data
->lm75
[1]) {
1323 i2c_detach_client(data
->lm75
[1]);
1324 kfree(data
->lm75
[1]);
1326 if (data
->lm75
[0]) {
1327 i2c_detach_client(data
->lm75
[0]);
1328 kfree(data
->lm75
[0]);
1331 i2c_detach_client(client
);
1339 w83781d_detach_client(struct i2c_client
*client
)
1341 struct w83781d_data
*data
= i2c_get_clientdata(client
);
1346 hwmon_device_unregister(data
->hwmon_dev
);
1347 sysfs_remove_group(&client
->dev
.kobj
, &w83781d_group
);
1348 sysfs_remove_group(&client
->dev
.kobj
, &w83781d_group_opt
);
1351 if ((err
= i2c_detach_client(client
)))
1365 static int __devinit
1366 w83781d_isa_probe(struct platform_device
*pdev
)
1369 struct w83781d_data
*data
;
1370 struct resource
*res
;
1373 /* Reserve the ISA region */
1374 res
= platform_get_resource(pdev
, IORESOURCE_IO
, 0);
1375 if (!request_region(res
->start
, W83781D_EXTENT
, "w83781d")) {
1380 if (!(data
= kzalloc(sizeof(struct w83781d_data
), GFP_KERNEL
))) {
1382 goto exit_release_region
;
1384 mutex_init(&data
->lock
);
1385 data
->client
.addr
= res
->start
;
1386 i2c_set_clientdata(&data
->client
, data
);
1387 platform_set_drvdata(pdev
, data
);
1389 reg
= w83781d_read_value(data
, W83781D_REG_WCHIPID
);
1392 data
->type
= w83782d
;
1396 data
->type
= w83781d
;
1399 strlcpy(data
->client
.name
, name
, I2C_NAME_SIZE
);
1401 /* Initialize the W83781D chip */
1402 w83781d_init_device(&pdev
->dev
);
1404 /* Register sysfs hooks */
1405 err
= w83781d_create_files(&pdev
->dev
, data
->type
, 1);
1407 goto exit_remove_files
;
1409 data
->hwmon_dev
= hwmon_device_register(&pdev
->dev
);
1410 if (IS_ERR(data
->hwmon_dev
)) {
1411 err
= PTR_ERR(data
->hwmon_dev
);
1412 goto exit_remove_files
;
1418 sysfs_remove_group(&pdev
->dev
.kobj
, &w83781d_group
);
1419 sysfs_remove_group(&pdev
->dev
.kobj
, &w83781d_group_opt
);
1420 device_remove_file(&pdev
->dev
, &dev_attr_name
);
1422 exit_release_region
:
1423 release_region(res
->start
, W83781D_EXTENT
);
1428 static int __devexit
1429 w83781d_isa_remove(struct platform_device
*pdev
)
1431 struct w83781d_data
*data
= platform_get_drvdata(pdev
);
1433 hwmon_device_unregister(data
->hwmon_dev
);
1434 sysfs_remove_group(&pdev
->dev
.kobj
, &w83781d_group
);
1435 sysfs_remove_group(&pdev
->dev
.kobj
, &w83781d_group_opt
);
1436 device_remove_file(&pdev
->dev
, &dev_attr_name
);
1437 release_region(data
->client
.addr
, W83781D_EXTENT
);
1443 /* The SMBus locks itself, usually, but nothing may access the Winbond between
1444 bank switches. ISA access must always be locked explicitly!
1445 We ignore the W83781D BUSY flag at this moment - it could lead to deadlocks,
1446 would slow down the W83781D access and should not be necessary.
1447 There are some ugly typecasts here, but the good news is - they should
1448 nowhere else be necessary! */
1450 w83781d_read_value(struct w83781d_data
*data
, u16 reg
)
1452 struct i2c_client
*client
= &data
->client
;
1453 int res
, word_sized
, bank
;
1454 struct i2c_client
*cl
;
1456 mutex_lock(&data
->lock
);
1457 if (!client
->driver
) { /* ISA device */
1458 word_sized
= (((reg
& 0xff00) == 0x100)
1459 || ((reg
& 0xff00) == 0x200))
1460 && (((reg
& 0x00ff) == 0x50)
1461 || ((reg
& 0x00ff) == 0x53)
1462 || ((reg
& 0x00ff) == 0x55));
1464 outb_p(W83781D_REG_BANK
,
1465 client
->addr
+ W83781D_ADDR_REG_OFFSET
);
1467 client
->addr
+ W83781D_DATA_REG_OFFSET
);
1469 outb_p(reg
& 0xff, client
->addr
+ W83781D_ADDR_REG_OFFSET
);
1470 res
= inb_p(client
->addr
+ W83781D_DATA_REG_OFFSET
);
1472 outb_p((reg
& 0xff) + 1,
1473 client
->addr
+ W83781D_ADDR_REG_OFFSET
);
1475 (res
<< 8) + inb_p(client
->addr
+
1476 W83781D_DATA_REG_OFFSET
);
1479 outb_p(W83781D_REG_BANK
,
1480 client
->addr
+ W83781D_ADDR_REG_OFFSET
);
1481 outb_p(0, client
->addr
+ W83781D_DATA_REG_OFFSET
);
1484 bank
= (reg
>> 8) & 0x0f;
1487 i2c_smbus_write_byte_data(client
, W83781D_REG_BANK
,
1489 if (bank
== 0 || bank
> 2) {
1490 res
= i2c_smbus_read_byte_data(client
, reg
& 0xff);
1492 /* switch to subclient */
1493 cl
= data
->lm75
[bank
- 1];
1494 /* convert from ISA to LM75 I2C addresses */
1495 switch (reg
& 0xff) {
1496 case 0x50: /* TEMP */
1497 res
= swab16(i2c_smbus_read_word_data(cl
, 0));
1499 case 0x52: /* CONFIG */
1500 res
= i2c_smbus_read_byte_data(cl
, 1);
1502 case 0x53: /* HYST */
1503 res
= swab16(i2c_smbus_read_word_data(cl
, 2));
1505 case 0x55: /* OVER */
1507 res
= swab16(i2c_smbus_read_word_data(cl
, 3));
1512 i2c_smbus_write_byte_data(client
, W83781D_REG_BANK
, 0);
1514 mutex_unlock(&data
->lock
);
1519 w83781d_write_value(struct w83781d_data
*data
, u16 reg
, u16 value
)
1521 struct i2c_client
*client
= &data
->client
;
1522 int word_sized
, bank
;
1523 struct i2c_client
*cl
;
1525 mutex_lock(&data
->lock
);
1526 if (!client
->driver
) { /* ISA device */
1527 word_sized
= (((reg
& 0xff00) == 0x100)
1528 || ((reg
& 0xff00) == 0x200))
1529 && (((reg
& 0x00ff) == 0x53)
1530 || ((reg
& 0x00ff) == 0x55));
1532 outb_p(W83781D_REG_BANK
,
1533 client
->addr
+ W83781D_ADDR_REG_OFFSET
);
1535 client
->addr
+ W83781D_DATA_REG_OFFSET
);
1537 outb_p(reg
& 0xff, client
->addr
+ W83781D_ADDR_REG_OFFSET
);
1540 client
->addr
+ W83781D_DATA_REG_OFFSET
);
1541 outb_p((reg
& 0xff) + 1,
1542 client
->addr
+ W83781D_ADDR_REG_OFFSET
);
1544 outb_p(value
& 0xff, client
->addr
+ W83781D_DATA_REG_OFFSET
);
1546 outb_p(W83781D_REG_BANK
,
1547 client
->addr
+ W83781D_ADDR_REG_OFFSET
);
1548 outb_p(0, client
->addr
+ W83781D_DATA_REG_OFFSET
);
1551 bank
= (reg
>> 8) & 0x0f;
1554 i2c_smbus_write_byte_data(client
, W83781D_REG_BANK
,
1556 if (bank
== 0 || bank
> 2) {
1557 i2c_smbus_write_byte_data(client
, reg
& 0xff,
1560 /* switch to subclient */
1561 cl
= data
->lm75
[bank
- 1];
1562 /* convert from ISA to LM75 I2C addresses */
1563 switch (reg
& 0xff) {
1564 case 0x52: /* CONFIG */
1565 i2c_smbus_write_byte_data(cl
, 1, value
& 0xff);
1567 case 0x53: /* HYST */
1568 i2c_smbus_write_word_data(cl
, 2, swab16(value
));
1570 case 0x55: /* OVER */
1571 i2c_smbus_write_word_data(cl
, 3, swab16(value
));
1576 i2c_smbus_write_byte_data(client
, W83781D_REG_BANK
, 0);
1578 mutex_unlock(&data
->lock
);
1583 w83781d_init_device(struct device
*dev
)
1585 struct w83781d_data
*data
= dev_get_drvdata(dev
);
1587 int type
= data
->type
;
1590 if (reset
&& type
!= as99127f
) { /* this resets registers we don't have
1591 documentation for on the as99127f */
1592 /* Resetting the chip has been the default for a long time,
1593 but it causes the BIOS initializations (fan clock dividers,
1594 thermal sensor types...) to be lost, so it is now optional.
1595 It might even go away if nobody reports it as being useful,
1596 as I see very little reason why this would be needed at
1598 dev_info(dev
, "If reset=1 solved a problem you were "
1599 "having, please report!\n");
1601 /* save these registers */
1602 i
= w83781d_read_value(data
, W83781D_REG_BEEP_CONFIG
);
1603 p
= w83781d_read_value(data
, W83781D_REG_PWMCLK12
);
1604 /* Reset all except Watchdog values and last conversion values
1605 This sets fan-divs to 2, among others */
1606 w83781d_write_value(data
, W83781D_REG_CONFIG
, 0x80);
1607 /* Restore the registers and disable power-on abnormal beep.
1608 This saves FAN 1/2/3 input/output values set by BIOS. */
1609 w83781d_write_value(data
, W83781D_REG_BEEP_CONFIG
, i
| 0x80);
1610 w83781d_write_value(data
, W83781D_REG_PWMCLK12
, p
);
1611 /* Disable master beep-enable (reset turns it on).
1612 Individual beep_mask should be reset to off but for some reason
1613 disabling this bit helps some people not get beeped */
1614 w83781d_write_value(data
, W83781D_REG_BEEP_INTS2
, 0);
1617 /* Disable power-on abnormal beep, as advised by the datasheet.
1618 Already done if reset=1. */
1619 if (init
&& !reset
&& type
!= as99127f
) {
1620 i
= w83781d_read_value(data
, W83781D_REG_BEEP_CONFIG
);
1621 w83781d_write_value(data
, W83781D_REG_BEEP_CONFIG
, i
| 0x80);
1624 data
->vrm
= vid_which_vrm();
1626 if ((type
!= w83781d
) && (type
!= as99127f
)) {
1627 tmp
= w83781d_read_value(data
, W83781D_REG_SCFG1
);
1628 for (i
= 1; i
<= 3; i
++) {
1629 if (!(tmp
& BIT_SCFG1
[i
- 1])) {
1630 data
->sens
[i
- 1] = 4;
1632 if (w83781d_read_value
1634 W83781D_REG_SCFG2
) & BIT_SCFG2
[i
- 1])
1635 data
->sens
[i
- 1] = 1;
1637 data
->sens
[i
- 1] = 2;
1639 if (type
== w83783s
&& i
== 2)
1644 if (init
&& type
!= as99127f
) {
1646 tmp
= w83781d_read_value(data
, W83781D_REG_TEMP2_CONFIG
);
1648 dev_warn(dev
, "Enabling temp2, readings "
1649 "might not make sense\n");
1650 w83781d_write_value(data
, W83781D_REG_TEMP2_CONFIG
,
1655 if (type
!= w83783s
) {
1656 tmp
= w83781d_read_value(data
,
1657 W83781D_REG_TEMP3_CONFIG
);
1659 dev_warn(dev
, "Enabling temp3, "
1660 "readings might not make sense\n");
1661 w83781d_write_value(data
,
1662 W83781D_REG_TEMP3_CONFIG
, tmp
& 0xfe);
1667 /* Start monitoring */
1668 w83781d_write_value(data
, W83781D_REG_CONFIG
,
1669 (w83781d_read_value(data
,
1670 W83781D_REG_CONFIG
) & 0xf7)
1673 /* A few vars need to be filled upon startup */
1674 for (i
= 0; i
< 3; i
++) {
1675 data
->fan_min
[i
] = w83781d_read_value(data
,
1676 W83781D_REG_FAN_MIN(i
));
1679 mutex_init(&data
->update_lock
);
1682 static struct w83781d_data
*w83781d_update_device(struct device
*dev
)
1684 struct w83781d_data
*data
= dev_get_drvdata(dev
);
1685 struct i2c_client
*client
= &data
->client
;
1688 mutex_lock(&data
->update_lock
);
1690 if (time_after(jiffies
, data
->last_updated
+ HZ
+ HZ
/ 2)
1692 dev_dbg(dev
, "Starting device update\n");
1694 for (i
= 0; i
<= 8; i
++) {
1695 if (data
->type
== w83783s
&& i
== 1)
1696 continue; /* 783S has no in1 */
1698 w83781d_read_value(data
, W83781D_REG_IN(i
));
1700 w83781d_read_value(data
, W83781D_REG_IN_MIN(i
));
1702 w83781d_read_value(data
, W83781D_REG_IN_MAX(i
));
1703 if ((data
->type
!= w83782d
) && (i
== 6))
1706 for (i
= 0; i
< 3; i
++) {
1708 w83781d_read_value(data
, W83781D_REG_FAN(i
));
1710 w83781d_read_value(data
, W83781D_REG_FAN_MIN(i
));
1712 if (data
->type
!= w83781d
&& data
->type
!= as99127f
) {
1713 for (i
= 0; i
< 4; i
++) {
1715 w83781d_read_value(data
,
1716 W83781D_REG_PWM
[i
]);
1717 if ((data
->type
!= w83782d
|| !client
->driver
)
1721 /* Only PWM2 can be disabled */
1722 data
->pwm2_enable
= (w83781d_read_value(data
,
1723 W83781D_REG_PWMCLK12
) & 0x08) >> 3;
1726 data
->temp
= w83781d_read_value(data
, W83781D_REG_TEMP(1));
1728 w83781d_read_value(data
, W83781D_REG_TEMP_OVER(1));
1729 data
->temp_max_hyst
=
1730 w83781d_read_value(data
, W83781D_REG_TEMP_HYST(1));
1732 w83781d_read_value(data
, W83781D_REG_TEMP(2));
1733 data
->temp_max_add
[0] =
1734 w83781d_read_value(data
, W83781D_REG_TEMP_OVER(2));
1735 data
->temp_max_hyst_add
[0] =
1736 w83781d_read_value(data
, W83781D_REG_TEMP_HYST(2));
1737 if (data
->type
!= w83783s
) {
1739 w83781d_read_value(data
, W83781D_REG_TEMP(3));
1740 data
->temp_max_add
[1] =
1741 w83781d_read_value(data
,
1742 W83781D_REG_TEMP_OVER(3));
1743 data
->temp_max_hyst_add
[1] =
1744 w83781d_read_value(data
,
1745 W83781D_REG_TEMP_HYST(3));
1747 i
= w83781d_read_value(data
, W83781D_REG_VID_FANDIV
);
1748 data
->vid
= i
& 0x0f;
1749 data
->vid
|= (w83781d_read_value(data
,
1750 W83781D_REG_CHIPID
) & 0x01) << 4;
1751 data
->fan_div
[0] = (i
>> 4) & 0x03;
1752 data
->fan_div
[1] = (i
>> 6) & 0x03;
1753 data
->fan_div
[2] = (w83781d_read_value(data
,
1754 W83781D_REG_PIN
) >> 6) & 0x03;
1755 if ((data
->type
!= w83781d
) && (data
->type
!= as99127f
)) {
1756 i
= w83781d_read_value(data
, W83781D_REG_VBAT
);
1757 data
->fan_div
[0] |= (i
>> 3) & 0x04;
1758 data
->fan_div
[1] |= (i
>> 4) & 0x04;
1759 data
->fan_div
[2] |= (i
>> 5) & 0x04;
1761 if (data
->type
== w83782d
) {
1762 data
->alarms
= w83781d_read_value(data
,
1764 | (w83781d_read_value(data
,
1765 W83782D_REG_ALARM2
) << 8)
1766 | (w83781d_read_value(data
,
1767 W83782D_REG_ALARM3
) << 16);
1768 } else if (data
->type
== w83783s
) {
1769 data
->alarms
= w83781d_read_value(data
,
1771 | (w83781d_read_value(data
,
1772 W83782D_REG_ALARM2
) << 8);
1774 /* No real-time status registers, fall back to
1775 interrupt status registers */
1776 data
->alarms
= w83781d_read_value(data
,
1778 | (w83781d_read_value(data
,
1779 W83781D_REG_ALARM2
) << 8);
1781 i
= w83781d_read_value(data
, W83781D_REG_BEEP_INTS2
);
1782 data
->beep_enable
= i
>> 7;
1783 data
->beep_mask
= ((i
& 0x7f) << 8) +
1784 w83781d_read_value(data
, W83781D_REG_BEEP_INTS1
);
1785 if ((data
->type
!= w83781d
) && (data
->type
!= as99127f
)) {
1787 w83781d_read_value(data
,
1788 W83781D_REG_BEEP_INTS3
) << 16;
1790 data
->last_updated
= jiffies
;
1794 mutex_unlock(&data
->update_lock
);
1799 /* return 1 if a supported chip is found, 0 otherwise */
1801 w83781d_isa_found(unsigned short address
)
1803 int val
, save
, found
= 0;
1805 if (!request_region(address
, W83781D_EXTENT
, "w83781d"))
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
, W83781D_EXTENT
);
1884 w83781d_isa_device_add(unsigned short address
)
1886 struct resource res
= {
1888 .end
= address
+ W83781D_EXTENT
- 1,
1890 .flags
= IORESOURCE_IO
,
1894 pdev
= platform_device_alloc("w83781d", address
);
1897 printk(KERN_ERR
"w83781d: Device allocation failed\n");
1901 err
= platform_device_add_resources(pdev
, &res
, 1);
1903 printk(KERN_ERR
"w83781d: Device resource addition failed "
1905 goto exit_device_put
;
1908 err
= platform_device_add(pdev
);
1910 printk(KERN_ERR
"w83781d: Device addition failed (%d)\n",
1912 goto exit_device_put
;
1918 platform_device_put(pdev
);
1925 sensors_w83781d_init(void)
1929 res
= i2c_add_driver(&w83781d_driver
);
1933 if (w83781d_isa_found(isa_address
)) {
1934 res
= platform_driver_register(&w83781d_isa_driver
);
1936 goto exit_unreg_i2c_driver
;
1938 /* Sets global pdev as a side effect */
1939 res
= w83781d_isa_device_add(isa_address
);
1941 goto exit_unreg_isa_driver
;
1946 exit_unreg_isa_driver
:
1947 platform_driver_unregister(&w83781d_isa_driver
);
1948 exit_unreg_i2c_driver
:
1949 i2c_del_driver(&w83781d_driver
);
1955 sensors_w83781d_exit(void)
1958 platform_device_unregister(pdev
);
1959 platform_driver_unregister(&w83781d_isa_driver
);
1961 i2c_del_driver(&w83781d_driver
);
1964 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
1965 "Philip Edelbrock <phil@netroedge.com>, "
1966 "and Mark Studebaker <mdsxyz123@yahoo.com>");
1967 MODULE_DESCRIPTION("W83781D driver");
1968 MODULE_LICENSE("GPL");
1970 module_init(sensors_w83781d_init
);
1971 module_exit(sensors_w83781d_exit
);