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 static const unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
57 0x2e, 0x2f, I2C_CLIENT_END };
58 static unsigned short isa_address = 0x290;
60 /* Insmod parameters */
61 I2C_CLIENT_INSMOD_4(w83781d, w83782d, w83783s, as99127f);
62 I2C_CLIENT_MODULE_PARM(force_subclients, "List of subclient addresses: "
63 "{bus, clientaddr, subclientaddr1, subclientaddr2}");
66 module_param(reset, bool, 0);
67 MODULE_PARM_DESC(reset, "Set to one to reset chip on load");
70 module_param(init, bool, 0);
71 MODULE_PARM_DESC(init, "Set to zero to bypass chip initialization");
73 /* Constants specified below */
75 /* Length of ISA address segment */
76 #define W83781D_EXTENT 8
78 /* Where are the ISA address/data registers relative to the base address */
79 #define W83781D_ADDR_REG_OFFSET 5
80 #define W83781D_DATA_REG_OFFSET 6
82 /* The device registers */
83 /* in nr from 0 to 8 */
84 #define W83781D_REG_IN_MAX(nr) ((nr < 7) ? (0x2b + (nr) * 2) : \
85 (0x554 + (((nr) - 7) * 2)))
86 #define W83781D_REG_IN_MIN(nr) ((nr < 7) ? (0x2c + (nr) * 2) : \
87 (0x555 + (((nr) - 7) * 2)))
88 #define W83781D_REG_IN(nr) ((nr < 7) ? (0x20 + (nr)) : \
91 /* fan nr from 0 to 2 */
92 #define W83781D_REG_FAN_MIN(nr) (0x3b + (nr))
93 #define W83781D_REG_FAN(nr) (0x28 + (nr))
95 #define W83781D_REG_BANK 0x4E
96 #define W83781D_REG_TEMP2_CONFIG 0x152
97 #define W83781D_REG_TEMP3_CONFIG 0x252
98 /* temp nr from 1 to 3 */
99 #define W83781D_REG_TEMP(nr) ((nr == 3) ? (0x0250) : \
100 ((nr == 2) ? (0x0150) : \
102 #define W83781D_REG_TEMP_HYST(nr) ((nr == 3) ? (0x253) : \
103 ((nr == 2) ? (0x153) : \
105 #define W83781D_REG_TEMP_OVER(nr) ((nr == 3) ? (0x255) : \
106 ((nr == 2) ? (0x155) : \
109 #define W83781D_REG_CONFIG 0x40
111 /* Interrupt status (W83781D, AS99127F) */
112 #define W83781D_REG_ALARM1 0x41
113 #define W83781D_REG_ALARM2 0x42
115 /* Real-time status (W83782D, W83783S) */
116 #define W83782D_REG_ALARM1 0x459
117 #define W83782D_REG_ALARM2 0x45A
118 #define W83782D_REG_ALARM3 0x45B
120 #define W83781D_REG_BEEP_CONFIG 0x4D
121 #define W83781D_REG_BEEP_INTS1 0x56
122 #define W83781D_REG_BEEP_INTS2 0x57
123 #define W83781D_REG_BEEP_INTS3 0x453 /* not on W83781D */
125 #define W83781D_REG_VID_FANDIV 0x47
127 #define W83781D_REG_CHIPID 0x49
128 #define W83781D_REG_WCHIPID 0x58
129 #define W83781D_REG_CHIPMAN 0x4F
130 #define W83781D_REG_PIN 0x4B
133 #define W83781D_REG_VBAT 0x5D
135 /* PWM 782D (1-4) and 783S (1-2) only */
136 static const u8 W83781D_REG_PWM[] = { 0x5B, 0x5A, 0x5E, 0x5F };
137 #define W83781D_REG_PWMCLK12 0x5C
138 #define W83781D_REG_PWMCLK34 0x45C
140 #define W83781D_REG_I2C_ADDR 0x48
141 #define W83781D_REG_I2C_SUBADDR 0x4A
143 /* The following are undocumented in the data sheets however we
144 received the information in an email from Winbond tech support */
145 /* Sensor selection - not on 781d */
146 #define W83781D_REG_SCFG1 0x5D
147 static const u8 BIT_SCFG1[] = { 0x02, 0x04, 0x08 };
149 #define W83781D_REG_SCFG2 0x59
150 static const u8 BIT_SCFG2[] = { 0x10, 0x20, 0x40 };
152 #define W83781D_DEFAULT_BETA 3435
155 #define IN_TO_REG(val) SENSORS_LIMIT(((val) + 8) / 16, 0, 255)
156 #define IN_FROM_REG(val) ((val) * 16)
159 FAN_TO_REG(long rpm, int div)
163 rpm = SENSORS_LIMIT(rpm, 1, 1000000);
164 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
168 FAN_FROM_REG(u8 val, int div)
174 return 1350000 / (val * div);
177 #define TEMP_TO_REG(val) SENSORS_LIMIT((val) / 1000, -127, 128)
178 #define TEMP_FROM_REG(val) ((val) * 1000)
180 #define BEEP_MASK_FROM_REG(val,type) ((type) == as99127f ? \
181 (~(val)) & 0x7fff : (val) & 0xff7fff)
182 #define BEEP_MASK_TO_REG(val,type) ((type) == as99127f ? \
183 (~(val)) & 0x7fff : (val) & 0xff7fff)
185 #define DIV_FROM_REG(val) (1 << (val))
188 DIV_TO_REG(long val, enum chips type)
191 val = SENSORS_LIMIT(val, 1,
193 || type == as99127f) ? 8 : 128)) >> 1;
194 for (i = 0; i < 7; i++) {
202 /* There are some complications in a module like this. First off, W83781D chips
203 may be both present on the SMBus and the ISA bus, and we have to handle
204 those cases separately at some places. Second, there might be several
205 W83781D chips available (well, actually, that is probably never done; but
206 it is a clean illustration of how to handle a case like that). Finally,
207 a specific chip may be attached to *both* ISA and SMBus, and we would
208 not like to detect it double. */
210 /* For ISA chips, we abuse the i2c_client addr and name fields. We also use
211 the driver field to differentiate between I2C and ISA chips. */
212 struct w83781d_data {
213 struct i2c_client client;
214 struct device *hwmon_dev;
218 struct mutex update_lock;
219 char valid; /* !=0 if following fields are valid */
220 unsigned long last_updated; /* In jiffies */
222 struct i2c_client *lm75[2]; /* for secondary I2C addresses */
223 /* array of 2 pointers to subclients */
225 u8 in[9]; /* Register value - 8 & 9 for 782D only */
226 u8 in_max[9]; /* Register value - 8 & 9 for 782D only */
227 u8 in_min[9]; /* Register value - 8 & 9 for 782D only */
228 u8 fan[3]; /* Register value */
229 u8 fan_min[3]; /* Register value */
230 s8 temp; /* Register value */
231 s8 temp_max; /* Register value */
232 s8 temp_max_hyst; /* Register value */
233 u16 temp_add[2]; /* Register value */
234 u16 temp_max_add[2]; /* Register value */
235 u16 temp_max_hyst_add[2]; /* Register value */
236 u8 fan_div[3]; /* Register encoding, shifted right */
237 u8 vid; /* Register encoding, combined */
238 u32 alarms; /* Register encoding, combined */
239 u32 beep_mask; /* Register encoding, combined */
240 u8 pwm[4]; /* Register value */
241 u8 pwm2_enable; /* Boolean */
242 u16 sens[3]; /* 782D/783S only.
243 1 = pentium diode; 2 = 3904 diode;
248 static int w83781d_attach_adapter(struct i2c_adapter *adapter);
249 static int w83781d_detect(struct i2c_adapter *adapter, int address, int kind);
250 static int w83781d_detach_client(struct i2c_client *client);
252 static int __devinit w83781d_isa_probe(struct platform_device *pdev);
253 static int __devexit w83781d_isa_remove(struct platform_device *pdev);
255 static int w83781d_read_value(struct w83781d_data *data, u16 reg);
256 static int w83781d_write_value(struct w83781d_data *data, u16 reg, u16 value);
257 static struct w83781d_data *w83781d_update_device(struct device *dev);
258 static void w83781d_init_device(struct device *dev);
260 static struct i2c_driver w83781d_driver = {
264 .attach_adapter = w83781d_attach_adapter,
265 .detach_client = w83781d_detach_client,
268 static struct platform_driver w83781d_isa_driver = {
270 .owner = THIS_MODULE,
273 .probe = w83781d_isa_probe,
274 .remove = w83781d_isa_remove,
278 /* following are the sysfs callback functions */
279 #define show_in_reg(reg) \
280 static ssize_t show_##reg (struct device *dev, struct device_attribute *da, \
283 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
284 struct w83781d_data *data = w83781d_update_device(dev); \
285 return sprintf(buf, "%ld\n", \
286 (long)IN_FROM_REG(data->reg[attr->index])); \
292 #define store_in_reg(REG, reg) \
293 static ssize_t store_in_##reg (struct device *dev, struct device_attribute \
294 *da, const char *buf, size_t count) \
296 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
297 struct w83781d_data *data = dev_get_drvdata(dev); \
298 int nr = attr->index; \
301 val = simple_strtoul(buf, NULL, 10); \
303 mutex_lock(&data->update_lock); \
304 data->in_##reg[nr] = IN_TO_REG(val); \
305 w83781d_write_value(data, W83781D_REG_IN_##REG(nr), data->in_##reg[nr]); \
307 mutex_unlock(&data->update_lock); \
310 store_in_reg(MIN, min);
311 store_in_reg(MAX, max);
313 #define sysfs_in_offsets(offset) \
314 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
315 show_in, NULL, offset); \
316 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
317 show_in_min, store_in_min, offset); \
318 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
319 show_in_max, store_in_max, offset)
331 #define show_fan_reg(reg) \
332 static ssize_t show_##reg (struct device *dev, struct device_attribute *da, \
335 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
336 struct w83781d_data *data = w83781d_update_device(dev); \
337 return sprintf(buf,"%ld\n", \
338 FAN_FROM_REG(data->reg[attr->index], \
339 DIV_FROM_REG(data->fan_div[attr->index]))); \
342 show_fan_reg(fan_min);
345 store_fan_min(struct device *dev, struct device_attribute *da,
346 const char *buf, size_t count)
348 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
349 struct w83781d_data *data = dev_get_drvdata(dev);
350 int nr = attr->index;
353 val = simple_strtoul(buf, NULL, 10);
355 mutex_lock(&data->update_lock);
357 FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
358 w83781d_write_value(data, W83781D_REG_FAN_MIN(nr),
361 mutex_unlock(&data->update_lock);
365 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
366 static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO | S_IWUSR,
367 show_fan_min, store_fan_min, 0);
368 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1);
369 static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO | S_IWUSR,
370 show_fan_min, store_fan_min, 1);
371 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2);
372 static SENSOR_DEVICE_ATTR(fan3_min, S_IRUGO | S_IWUSR,
373 show_fan_min, store_fan_min, 2);
375 #define show_temp_reg(reg) \
376 static ssize_t show_##reg (struct device *dev, struct device_attribute *da, \
379 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
380 struct w83781d_data *data = w83781d_update_device(dev); \
381 int nr = attr->index; \
382 if (nr >= 2) { /* TEMP2 and TEMP3 */ \
383 return sprintf(buf,"%d\n", \
384 LM75_TEMP_FROM_REG(data->reg##_add[nr-2])); \
385 } else { /* TEMP1 */ \
386 return sprintf(buf,"%ld\n", (long)TEMP_FROM_REG(data->reg)); \
390 show_temp_reg(temp_max);
391 show_temp_reg(temp_max_hyst);
393 #define store_temp_reg(REG, reg) \
394 static ssize_t store_temp_##reg (struct device *dev, \
395 struct device_attribute *da, const char *buf, size_t count) \
397 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
398 struct w83781d_data *data = dev_get_drvdata(dev); \
399 int nr = attr->index; \
402 val = simple_strtol(buf, NULL, 10); \
404 mutex_lock(&data->update_lock); \
406 if (nr >= 2) { /* TEMP2 and TEMP3 */ \
407 data->temp_##reg##_add[nr-2] = LM75_TEMP_TO_REG(val); \
408 w83781d_write_value(data, W83781D_REG_TEMP_##REG(nr), \
409 data->temp_##reg##_add[nr-2]); \
410 } else { /* TEMP1 */ \
411 data->temp_##reg = TEMP_TO_REG(val); \
412 w83781d_write_value(data, W83781D_REG_TEMP_##REG(nr), \
416 mutex_unlock(&data->update_lock); \
419 store_temp_reg(OVER, max);
420 store_temp_reg(HYST, max_hyst);
422 #define sysfs_temp_offsets(offset) \
423 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
424 show_temp, NULL, offset); \
425 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
426 show_temp_max, store_temp_max, offset); \
427 static SENSOR_DEVICE_ATTR(temp##offset##_max_hyst, S_IRUGO | S_IWUSR, \
428 show_temp_max_hyst, store_temp_max_hyst, offset);
430 sysfs_temp_offsets(1);
431 sysfs_temp_offsets(2);
432 sysfs_temp_offsets(3);
435 show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
437 struct w83781d_data *data = w83781d_update_device(dev);
438 return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm));
441 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
444 show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
446 struct w83781d_data *data = dev_get_drvdata(dev);
447 return sprintf(buf, "%ld\n", (long) data->vrm);
451 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
453 struct w83781d_data *data = dev_get_drvdata(dev);
456 val = simple_strtoul(buf, NULL, 10);
462 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
465 show_alarms_reg(struct device *dev, struct device_attribute *attr, char *buf)
467 struct w83781d_data *data = w83781d_update_device(dev);
468 return sprintf(buf, "%u\n", data->alarms);
471 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
473 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
476 struct w83781d_data *data = w83781d_update_device(dev);
477 int bitnr = to_sensor_dev_attr(attr)->index;
478 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
481 /* The W83781D has a single alarm bit for temp2 and temp3 */
482 static ssize_t show_temp3_alarm(struct device *dev,
483 struct device_attribute *attr, char *buf)
485 struct w83781d_data *data = w83781d_update_device(dev);
486 int bitnr = (data->type == w83781d) ? 5 : 13;
487 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
490 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
491 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
492 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
493 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
494 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
495 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9);
496 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 10);
497 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 16);
498 static SENSOR_DEVICE_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 17);
499 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
500 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
501 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11);
502 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4);
503 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5);
504 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_temp3_alarm, NULL, 0);
506 static ssize_t show_beep_mask (struct device *dev, struct device_attribute *attr, char *buf)
508 struct w83781d_data *data = w83781d_update_device(dev);
509 return sprintf(buf, "%ld\n",
510 (long)BEEP_MASK_FROM_REG(data->beep_mask, data->type));
514 store_beep_mask(struct device *dev, struct device_attribute *attr,
515 const char *buf, size_t count)
517 struct w83781d_data *data = dev_get_drvdata(dev);
520 val = simple_strtoul(buf, NULL, 10);
522 mutex_lock(&data->update_lock);
523 data->beep_mask &= 0x8000; /* preserve beep enable */
524 data->beep_mask |= BEEP_MASK_TO_REG(val, data->type);
525 w83781d_write_value(data, W83781D_REG_BEEP_INTS1,
526 data->beep_mask & 0xff);
527 w83781d_write_value(data, W83781D_REG_BEEP_INTS2,
528 (data->beep_mask >> 8) & 0xff);
529 if (data->type != w83781d && data->type != as99127f) {
530 w83781d_write_value(data, W83781D_REG_BEEP_INTS3,
531 ((data->beep_mask) >> 16) & 0xff);
533 mutex_unlock(&data->update_lock);
538 static DEVICE_ATTR(beep_mask, S_IRUGO | S_IWUSR,
539 show_beep_mask, store_beep_mask);
541 static ssize_t show_beep(struct device *dev, struct device_attribute *attr,
544 struct w83781d_data *data = w83781d_update_device(dev);
545 int bitnr = to_sensor_dev_attr(attr)->index;
546 return sprintf(buf, "%u\n", (data->beep_mask >> bitnr) & 1);
550 store_beep(struct device *dev, struct device_attribute *attr,
551 const char *buf, size_t count)
553 struct w83781d_data *data = dev_get_drvdata(dev);
554 int bitnr = to_sensor_dev_attr(attr)->index;
558 bit = simple_strtoul(buf, NULL, 10);
562 mutex_lock(&data->update_lock);
564 data->beep_mask |= (1 << bitnr);
566 data->beep_mask &= ~(1 << bitnr);
569 reg = w83781d_read_value(data, W83781D_REG_BEEP_INTS1);
573 reg &= ~(1 << bitnr);
574 w83781d_write_value(data, W83781D_REG_BEEP_INTS1, reg);
575 } else if (bitnr < 16) {
576 reg = w83781d_read_value(data, W83781D_REG_BEEP_INTS2);
578 reg |= (1 << (bitnr - 8));
580 reg &= ~(1 << (bitnr - 8));
581 w83781d_write_value(data, W83781D_REG_BEEP_INTS2, reg);
583 reg = w83781d_read_value(data, W83781D_REG_BEEP_INTS3);
585 reg |= (1 << (bitnr - 16));
587 reg &= ~(1 << (bitnr - 16));
588 w83781d_write_value(data, W83781D_REG_BEEP_INTS3, reg);
590 mutex_unlock(&data->update_lock);
595 /* The W83781D has a single beep bit for temp2 and temp3 */
596 static ssize_t show_temp3_beep(struct device *dev,
597 struct device_attribute *attr, char *buf)
599 struct w83781d_data *data = w83781d_update_device(dev);
600 int bitnr = (data->type == w83781d) ? 5 : 13;
601 return sprintf(buf, "%u\n", (data->beep_mask >> bitnr) & 1);
604 static SENSOR_DEVICE_ATTR(in0_beep, S_IRUGO | S_IWUSR,
605 show_beep, store_beep, 0);
606 static SENSOR_DEVICE_ATTR(in1_beep, S_IRUGO | S_IWUSR,
607 show_beep, store_beep, 1);
608 static SENSOR_DEVICE_ATTR(in2_beep, S_IRUGO | S_IWUSR,
609 show_beep, store_beep, 2);
610 static SENSOR_DEVICE_ATTR(in3_beep, S_IRUGO | S_IWUSR,
611 show_beep, store_beep, 3);
612 static SENSOR_DEVICE_ATTR(in4_beep, S_IRUGO | S_IWUSR,
613 show_beep, store_beep, 8);
614 static SENSOR_DEVICE_ATTR(in5_beep, S_IRUGO | S_IWUSR,
615 show_beep, store_beep, 9);
616 static SENSOR_DEVICE_ATTR(in6_beep, S_IRUGO | S_IWUSR,
617 show_beep, store_beep, 10);
618 static SENSOR_DEVICE_ATTR(in7_beep, S_IRUGO | S_IWUSR,
619 show_beep, store_beep, 16);
620 static SENSOR_DEVICE_ATTR(in8_beep, S_IRUGO | S_IWUSR,
621 show_beep, store_beep, 17);
622 static SENSOR_DEVICE_ATTR(fan1_beep, S_IRUGO | S_IWUSR,
623 show_beep, store_beep, 6);
624 static SENSOR_DEVICE_ATTR(fan2_beep, S_IRUGO | S_IWUSR,
625 show_beep, store_beep, 7);
626 static SENSOR_DEVICE_ATTR(fan3_beep, S_IRUGO | S_IWUSR,
627 show_beep, store_beep, 11);
628 static SENSOR_DEVICE_ATTR(temp1_beep, S_IRUGO | S_IWUSR,
629 show_beep, store_beep, 4);
630 static SENSOR_DEVICE_ATTR(temp2_beep, S_IRUGO | S_IWUSR,
631 show_beep, store_beep, 5);
632 static SENSOR_DEVICE_ATTR(temp3_beep, S_IRUGO,
633 show_temp3_beep, store_beep, 13);
634 static SENSOR_DEVICE_ATTR(beep_enable, S_IRUGO | S_IWUSR,
635 show_beep, store_beep, 15);
638 show_fan_div(struct device *dev, struct device_attribute *da, char *buf)
640 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
641 struct w83781d_data *data = w83781d_update_device(dev);
642 return sprintf(buf, "%ld\n",
643 (long) DIV_FROM_REG(data->fan_div[attr->index]));
646 /* Note: we save and restore the fan minimum here, because its value is
647 determined in part by the fan divisor. This follows the principle of
648 least surprise; the user doesn't expect the fan minimum to change just
649 because the divisor changed. */
651 store_fan_div(struct device *dev, struct device_attribute *da,
652 const char *buf, size_t count)
654 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
655 struct w83781d_data *data = dev_get_drvdata(dev);
657 int nr = attr->index;
659 unsigned long val = simple_strtoul(buf, NULL, 10);
661 mutex_lock(&data->update_lock);
664 min = FAN_FROM_REG(data->fan_min[nr],
665 DIV_FROM_REG(data->fan_div[nr]));
667 data->fan_div[nr] = DIV_TO_REG(val, data->type);
669 reg = (w83781d_read_value(data, nr==2 ? W83781D_REG_PIN : W83781D_REG_VID_FANDIV)
670 & (nr==0 ? 0xcf : 0x3f))
671 | ((data->fan_div[nr] & 0x03) << (nr==0 ? 4 : 6));
672 w83781d_write_value(data, nr==2 ? W83781D_REG_PIN : W83781D_REG_VID_FANDIV, reg);
674 /* w83781d and as99127f don't have extended divisor bits */
675 if (data->type != w83781d && data->type != as99127f) {
676 reg = (w83781d_read_value(data, W83781D_REG_VBAT)
678 | ((data->fan_div[nr] & 0x04) << (3 + nr));
679 w83781d_write_value(data, W83781D_REG_VBAT, reg);
682 /* Restore fan_min */
683 data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
684 w83781d_write_value(data, W83781D_REG_FAN_MIN(nr), data->fan_min[nr]);
686 mutex_unlock(&data->update_lock);
690 static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
691 show_fan_div, store_fan_div, 0);
692 static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
693 show_fan_div, store_fan_div, 1);
694 static SENSOR_DEVICE_ATTR(fan3_div, S_IRUGO | S_IWUSR,
695 show_fan_div, store_fan_div, 2);
698 show_pwm(struct device *dev, struct device_attribute *da, char *buf)
700 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
701 struct w83781d_data *data = w83781d_update_device(dev);
702 return sprintf(buf, "%d\n", (int)data->pwm[attr->index]);
706 show_pwm2_enable(struct device *dev, struct device_attribute *da, char *buf)
708 struct w83781d_data *data = w83781d_update_device(dev);
709 return sprintf(buf, "%d\n", (int)data->pwm2_enable);
713 store_pwm(struct device *dev, struct device_attribute *da, const char *buf,
716 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
717 struct w83781d_data *data = dev_get_drvdata(dev);
718 int nr = attr->index;
721 val = simple_strtoul(buf, NULL, 10);
723 mutex_lock(&data->update_lock);
724 data->pwm[nr] = SENSORS_LIMIT(val, 0, 255);
725 w83781d_write_value(data, W83781D_REG_PWM[nr], data->pwm[nr]);
726 mutex_unlock(&data->update_lock);
731 store_pwm2_enable(struct device *dev, struct device_attribute *da,
732 const char *buf, size_t count)
734 struct w83781d_data *data = dev_get_drvdata(dev);
737 val = simple_strtoul(buf, NULL, 10);
739 mutex_lock(&data->update_lock);
744 reg = w83781d_read_value(data, W83781D_REG_PWMCLK12);
745 w83781d_write_value(data, W83781D_REG_PWMCLK12,
746 (reg & 0xf7) | (val << 3));
748 reg = w83781d_read_value(data, W83781D_REG_BEEP_CONFIG);
749 w83781d_write_value(data, W83781D_REG_BEEP_CONFIG,
750 (reg & 0xef) | (!val << 4));
752 data->pwm2_enable = val;
756 mutex_unlock(&data->update_lock);
760 mutex_unlock(&data->update_lock);
764 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, store_pwm, 0);
765 static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, show_pwm, store_pwm, 1);
766 static SENSOR_DEVICE_ATTR(pwm3, S_IRUGO | S_IWUSR, show_pwm, store_pwm, 2);
767 static SENSOR_DEVICE_ATTR(pwm4, S_IRUGO | S_IWUSR, show_pwm, store_pwm, 3);
768 /* only PWM2 can be enabled/disabled */
769 static DEVICE_ATTR(pwm2_enable, S_IRUGO | S_IWUSR,
770 show_pwm2_enable, store_pwm2_enable);
773 show_sensor(struct device *dev, struct device_attribute *da, char *buf)
775 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
776 struct w83781d_data *data = w83781d_update_device(dev);
777 return sprintf(buf, "%d\n", (int)data->sens[attr->index]);
781 store_sensor(struct device *dev, struct device_attribute *da,
782 const char *buf, size_t count)
784 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
785 struct w83781d_data *data = dev_get_drvdata(dev);
786 int nr = attr->index;
789 val = simple_strtoul(buf, NULL, 10);
791 mutex_lock(&data->update_lock);
794 case 1: /* PII/Celeron diode */
795 tmp = w83781d_read_value(data, W83781D_REG_SCFG1);
796 w83781d_write_value(data, W83781D_REG_SCFG1,
797 tmp | BIT_SCFG1[nr]);
798 tmp = w83781d_read_value(data, W83781D_REG_SCFG2);
799 w83781d_write_value(data, W83781D_REG_SCFG2,
800 tmp | BIT_SCFG2[nr]);
801 data->sens[nr] = val;
804 tmp = w83781d_read_value(data, W83781D_REG_SCFG1);
805 w83781d_write_value(data, W83781D_REG_SCFG1,
806 tmp | BIT_SCFG1[nr]);
807 tmp = w83781d_read_value(data, W83781D_REG_SCFG2);
808 w83781d_write_value(data, W83781D_REG_SCFG2,
809 tmp & ~BIT_SCFG2[nr]);
810 data->sens[nr] = val;
812 case W83781D_DEFAULT_BETA:
813 dev_warn(dev, "Sensor type %d is deprecated, please use 4 "
814 "instead\n", W83781D_DEFAULT_BETA);
816 case 4: /* thermistor */
817 tmp = w83781d_read_value(data, W83781D_REG_SCFG1);
818 w83781d_write_value(data, W83781D_REG_SCFG1,
819 tmp & ~BIT_SCFG1[nr]);
820 data->sens[nr] = val;
823 dev_err(dev, "Invalid sensor type %ld; must be 1, 2, or 4\n",
828 mutex_unlock(&data->update_lock);
832 static SENSOR_DEVICE_ATTR(temp1_type, S_IRUGO | S_IWUSR,
833 show_sensor, store_sensor, 0);
834 static SENSOR_DEVICE_ATTR(temp2_type, S_IRUGO | S_IWUSR,
835 show_sensor, store_sensor, 1);
836 static SENSOR_DEVICE_ATTR(temp3_type, S_IRUGO | S_IWUSR,
837 show_sensor, store_sensor, 2);
839 /* I2C devices get this name attribute automatically, but for ISA devices
840 we must create it by ourselves. */
842 show_name(struct device *dev, struct device_attribute *devattr, char *buf)
844 struct w83781d_data *data = dev_get_drvdata(dev);
845 return sprintf(buf, "%s\n", data->client.name);
847 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
849 /* This function is called when:
850 * w83781d_driver is inserted (when this module is loaded), for each
852 * when a new adapter is inserted (and w83781d_driver is still present)
853 We block updates of the ISA device to minimize the risk of concurrent
854 access to the same W83781D chip through different interfaces. */
856 w83781d_attach_adapter(struct i2c_adapter *adapter)
858 struct w83781d_data *data;
861 if (!(adapter->class & I2C_CLASS_HWMON))
864 data = pdev ? platform_get_drvdata(pdev) : NULL;
866 mutex_lock(&data->update_lock);
867 err = i2c_probe(adapter, &addr_data, w83781d_detect);
869 mutex_unlock(&data->update_lock);
873 /* Assumes that adapter is of I2C, not ISA variety.
874 * OTHERWISE DON'T CALL THIS
877 w83781d_detect_subclients(struct i2c_adapter *adapter, int address, int kind,
878 struct i2c_client *new_client)
882 const char *client_name = "";
883 struct w83781d_data *data = i2c_get_clientdata(new_client);
885 data->lm75[0] = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
886 if (!(data->lm75[0])) {
891 id = i2c_adapter_id(adapter);
893 if (force_subclients[0] == id && force_subclients[1] == address) {
894 for (i = 2; i <= 3; i++) {
895 if (force_subclients[i] < 0x48 ||
896 force_subclients[i] > 0x4f) {
897 dev_err(&new_client->dev, "Invalid subclient "
898 "address %d; must be 0x48-0x4f\n",
899 force_subclients[i]);
904 w83781d_write_value(data, W83781D_REG_I2C_SUBADDR,
905 (force_subclients[2] & 0x07) |
906 ((force_subclients[3] & 0x07) << 4));
907 data->lm75[0]->addr = force_subclients[2];
909 val1 = w83781d_read_value(data, W83781D_REG_I2C_SUBADDR);
910 data->lm75[0]->addr = 0x48 + (val1 & 0x07);
913 if (kind != w83783s) {
914 data->lm75[1] = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
915 if (!(data->lm75[1])) {
920 if (force_subclients[0] == id &&
921 force_subclients[1] == address) {
922 data->lm75[1]->addr = force_subclients[3];
924 data->lm75[1]->addr = 0x48 + ((val1 >> 4) & 0x07);
926 if (data->lm75[0]->addr == data->lm75[1]->addr) {
927 dev_err(&new_client->dev,
928 "Duplicate addresses 0x%x for subclients.\n",
929 data->lm75[0]->addr);
936 client_name = "w83781d subclient";
937 else if (kind == w83782d)
938 client_name = "w83782d subclient";
939 else if (kind == w83783s)
940 client_name = "w83783s subclient";
941 else if (kind == as99127f)
942 client_name = "as99127f subclient";
944 for (i = 0; i <= 1; i++) {
945 /* store all data in w83781d */
946 i2c_set_clientdata(data->lm75[i], NULL);
947 data->lm75[i]->adapter = adapter;
948 data->lm75[i]->driver = &w83781d_driver;
949 data->lm75[i]->flags = 0;
950 strlcpy(data->lm75[i]->name, client_name,
952 if ((err = i2c_attach_client(data->lm75[i]))) {
953 dev_err(&new_client->dev, "Subclient %d "
954 "registration at address 0x%x "
955 "failed.\n", i, data->lm75[i]->addr);
966 /* Undo inits in case of errors */
968 i2c_detach_client(data->lm75[0]);
970 kfree(data->lm75[1]);
972 kfree(data->lm75[0]);
977 #define IN_UNIT_ATTRS(X) \
978 &sensor_dev_attr_in##X##_input.dev_attr.attr, \
979 &sensor_dev_attr_in##X##_min.dev_attr.attr, \
980 &sensor_dev_attr_in##X##_max.dev_attr.attr, \
981 &sensor_dev_attr_in##X##_alarm.dev_attr.attr, \
982 &sensor_dev_attr_in##X##_beep.dev_attr.attr
984 #define FAN_UNIT_ATTRS(X) \
985 &sensor_dev_attr_fan##X##_input.dev_attr.attr, \
986 &sensor_dev_attr_fan##X##_min.dev_attr.attr, \
987 &sensor_dev_attr_fan##X##_div.dev_attr.attr, \
988 &sensor_dev_attr_fan##X##_alarm.dev_attr.attr, \
989 &sensor_dev_attr_fan##X##_beep.dev_attr.attr
991 #define TEMP_UNIT_ATTRS(X) \
992 &sensor_dev_attr_temp##X##_input.dev_attr.attr, \
993 &sensor_dev_attr_temp##X##_max.dev_attr.attr, \
994 &sensor_dev_attr_temp##X##_max_hyst.dev_attr.attr, \
995 &sensor_dev_attr_temp##X##_alarm.dev_attr.attr, \
996 &sensor_dev_attr_temp##X##_beep.dev_attr.attr
998 static struct attribute* w83781d_attributes[] = {
1010 &dev_attr_cpu0_vid.attr,
1012 &dev_attr_alarms.attr,
1013 &dev_attr_beep_mask.attr,
1014 &sensor_dev_attr_beep_enable.dev_attr.attr,
1017 static const struct attribute_group w83781d_group = {
1018 .attrs = w83781d_attributes,
1021 static struct attribute *w83781d_attributes_opt[] = {
1026 &sensor_dev_attr_pwm1.dev_attr.attr,
1027 &sensor_dev_attr_pwm2.dev_attr.attr,
1028 &sensor_dev_attr_pwm3.dev_attr.attr,
1029 &sensor_dev_attr_pwm4.dev_attr.attr,
1030 &dev_attr_pwm2_enable.attr,
1031 &sensor_dev_attr_temp1_type.dev_attr.attr,
1032 &sensor_dev_attr_temp2_type.dev_attr.attr,
1033 &sensor_dev_attr_temp3_type.dev_attr.attr,
1036 static const struct attribute_group w83781d_group_opt = {
1037 .attrs = w83781d_attributes_opt,
1040 /* Returns 1 if the I2C chip appears to be an alias of the ISA chip */
1041 static int w83781d_alias_detect(struct i2c_client *client, u8 chipid)
1043 struct w83781d_data *i2c, *isa;
1046 if (!pdev) /* No ISA chip */
1049 i2c = i2c_get_clientdata(client);
1050 isa = platform_get_drvdata(pdev);
1052 if (w83781d_read_value(isa, W83781D_REG_I2C_ADDR) != client->addr)
1053 return 0; /* Address doesn't match */
1054 if (w83781d_read_value(isa, W83781D_REG_WCHIPID) != chipid)
1055 return 0; /* Chip type doesn't match */
1057 /* We compare all the limit registers, the config register and the
1058 * interrupt mask registers */
1059 for (i = 0x2b; i <= 0x3d; i++) {
1060 if (w83781d_read_value(isa, i) != w83781d_read_value(i2c, i))
1063 if (w83781d_read_value(isa, W83781D_REG_CONFIG) !=
1064 w83781d_read_value(i2c, W83781D_REG_CONFIG))
1066 for (i = 0x43; i <= 0x46; i++) {
1067 if (w83781d_read_value(isa, i) != w83781d_read_value(i2c, i))
1074 /* No clean up is done on error, it's up to the caller */
1076 w83781d_create_files(struct device *dev, int kind, int is_isa)
1080 if ((err = sysfs_create_group(&dev->kobj, &w83781d_group)))
1083 if (kind != w83783s) {
1084 if ((err = device_create_file(dev,
1085 &sensor_dev_attr_in1_input.dev_attr))
1086 || (err = device_create_file(dev,
1087 &sensor_dev_attr_in1_min.dev_attr))
1088 || (err = device_create_file(dev,
1089 &sensor_dev_attr_in1_max.dev_attr))
1090 || (err = device_create_file(dev,
1091 &sensor_dev_attr_in1_alarm.dev_attr))
1092 || (err = device_create_file(dev,
1093 &sensor_dev_attr_in1_beep.dev_attr)))
1096 if (kind != as99127f && kind != w83781d && kind != w83783s) {
1097 if ((err = device_create_file(dev,
1098 &sensor_dev_attr_in7_input.dev_attr))
1099 || (err = device_create_file(dev,
1100 &sensor_dev_attr_in7_min.dev_attr))
1101 || (err = device_create_file(dev,
1102 &sensor_dev_attr_in7_max.dev_attr))
1103 || (err = device_create_file(dev,
1104 &sensor_dev_attr_in7_alarm.dev_attr))
1105 || (err = device_create_file(dev,
1106 &sensor_dev_attr_in7_beep.dev_attr))
1107 || (err = device_create_file(dev,
1108 &sensor_dev_attr_in8_input.dev_attr))
1109 || (err = device_create_file(dev,
1110 &sensor_dev_attr_in8_min.dev_attr))
1111 || (err = device_create_file(dev,
1112 &sensor_dev_attr_in8_max.dev_attr))
1113 || (err = device_create_file(dev,
1114 &sensor_dev_attr_in8_alarm.dev_attr))
1115 || (err = device_create_file(dev,
1116 &sensor_dev_attr_in8_beep.dev_attr)))
1119 if (kind != w83783s) {
1120 if ((err = device_create_file(dev,
1121 &sensor_dev_attr_temp3_input.dev_attr))
1122 || (err = device_create_file(dev,
1123 &sensor_dev_attr_temp3_max.dev_attr))
1124 || (err = device_create_file(dev,
1125 &sensor_dev_attr_temp3_max_hyst.dev_attr))
1126 || (err = device_create_file(dev,
1127 &sensor_dev_attr_temp3_alarm.dev_attr))
1128 || (err = device_create_file(dev,
1129 &sensor_dev_attr_temp3_beep.dev_attr)))
1132 if (kind != w83781d) {
1133 err = sysfs_chmod_file(&dev->kobj,
1134 &sensor_dev_attr_temp3_alarm.dev_attr.attr,
1141 if (kind != w83781d && kind != as99127f) {
1142 if ((err = device_create_file(dev,
1143 &sensor_dev_attr_pwm1.dev_attr))
1144 || (err = device_create_file(dev,
1145 &sensor_dev_attr_pwm2.dev_attr))
1146 || (err = device_create_file(dev, &dev_attr_pwm2_enable)))
1149 if (kind == w83782d && !is_isa) {
1150 if ((err = device_create_file(dev,
1151 &sensor_dev_attr_pwm3.dev_attr))
1152 || (err = device_create_file(dev,
1153 &sensor_dev_attr_pwm4.dev_attr)))
1157 if (kind != as99127f && kind != w83781d) {
1158 if ((err = device_create_file(dev,
1159 &sensor_dev_attr_temp1_type.dev_attr))
1160 || (err = device_create_file(dev,
1161 &sensor_dev_attr_temp2_type.dev_attr)))
1163 if (kind != w83783s) {
1164 if ((err = device_create_file(dev,
1165 &sensor_dev_attr_temp3_type.dev_attr)))
1171 err = device_create_file(&pdev->dev, &dev_attr_name);
1180 w83781d_detect(struct i2c_adapter *adapter, int address, int kind)
1183 struct i2c_client *client;
1185 struct w83781d_data *data;
1187 const char *client_name = "";
1188 enum vendor { winbond, asus } vendid;
1190 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1195 /* OK. For now, we presume we have a valid client. We now create the
1196 client structure, even though we cannot fill it completely yet.
1197 But it allows us to access w83781d_{read,write}_value. */
1199 if (!(data = kzalloc(sizeof(struct w83781d_data), GFP_KERNEL))) {
1204 client = &data->client;
1205 i2c_set_clientdata(client, data);
1206 client->addr = address;
1207 mutex_init(&data->lock);
1208 client->adapter = adapter;
1209 client->driver = &w83781d_driver;
1212 /* Now, we do the remaining detection. */
1214 /* The w8378?d may be stuck in some other bank than bank 0. This may
1215 make reading other information impossible. Specify a force=... or
1216 force_*=... parameter, and the Winbond will be reset to the right
1219 if (w83781d_read_value(data, W83781D_REG_CONFIG) & 0x80) {
1220 dev_dbg(&adapter->dev, "Detection of w83781d chip "
1221 "failed at step 3\n");
1225 val1 = w83781d_read_value(data, W83781D_REG_BANK);
1226 val2 = w83781d_read_value(data, W83781D_REG_CHIPMAN);
1227 /* Check for Winbond or Asus ID if in bank 0 */
1228 if ((!(val1 & 0x07)) &&
1229 (((!(val1 & 0x80)) && (val2 != 0xa3) && (val2 != 0xc3))
1230 || ((val1 & 0x80) && (val2 != 0x5c) && (val2 != 0x12)))) {
1231 dev_dbg(&adapter->dev, "Detection of w83781d chip "
1232 "failed at step 4\n");
1236 /* If Winbond SMBus, check address at 0x48.
1237 Asus doesn't support, except for as99127f rev.2 */
1238 if ((!(val1 & 0x80) && (val2 == 0xa3)) ||
1239 ((val1 & 0x80) && (val2 == 0x5c))) {
1240 if (w83781d_read_value
1241 (data, W83781D_REG_I2C_ADDR) != address) {
1242 dev_dbg(&adapter->dev, "Detection of w83781d "
1243 "chip failed at step 5\n");
1250 /* We have either had a force parameter, or we have already detected the
1251 Winbond. Put it now into bank 0 and Vendor ID High Byte */
1252 w83781d_write_value(data, W83781D_REG_BANK,
1253 (w83781d_read_value(data, W83781D_REG_BANK)
1256 /* Determine the chip type. */
1259 val2 = w83781d_read_value(data, W83781D_REG_CHIPMAN);
1262 else if (val2 == 0x12)
1265 dev_dbg(&adapter->dev, "w83781d chip vendor is "
1266 "neither Winbond nor Asus\n");
1271 val1 = w83781d_read_value(data, W83781D_REG_WCHIPID);
1272 if ((val1 == 0x10 || val1 == 0x11) && vendid == winbond)
1274 else if (val1 == 0x30 && vendid == winbond)
1276 else if (val1 == 0x40 && vendid == winbond && address == 0x2d)
1278 else if (val1 == 0x31)
1282 dev_warn(&adapter->dev, "Ignoring 'force' "
1283 "parameter for unknown chip at "
1284 "address 0x%02x\n", address);
1289 if ((kind == w83781d || kind == w83782d)
1290 && w83781d_alias_detect(client, val1)) {
1291 dev_dbg(&adapter->dev, "Device at 0x%02x appears to "
1292 "be the same as ISA device\n", address);
1298 if (kind == w83781d) {
1299 client_name = "w83781d";
1300 } else if (kind == w83782d) {
1301 client_name = "w83782d";
1302 } else if (kind == w83783s) {
1303 client_name = "w83783s";
1304 } else if (kind == as99127f) {
1305 client_name = "as99127f";
1308 /* Fill in the remaining client fields and put into the global list */
1309 strlcpy(client->name, client_name, I2C_NAME_SIZE);
1312 /* Tell the I2C layer a new client has arrived */
1313 if ((err = i2c_attach_client(client)))
1316 /* attach secondary i2c lm75-like clients */
1317 if ((err = w83781d_detect_subclients(adapter, address,
1321 /* Initialize the chip */
1322 w83781d_init_device(dev);
1324 /* Register sysfs hooks */
1325 err = w83781d_create_files(dev, kind, 0);
1329 data->hwmon_dev = hwmon_device_register(dev);
1330 if (IS_ERR(data->hwmon_dev)) {
1331 err = PTR_ERR(data->hwmon_dev);
1338 sysfs_remove_group(&dev->kobj, &w83781d_group);
1339 sysfs_remove_group(&dev->kobj, &w83781d_group_opt);
1341 if (data->lm75[1]) {
1342 i2c_detach_client(data->lm75[1]);
1343 kfree(data->lm75[1]);
1345 if (data->lm75[0]) {
1346 i2c_detach_client(data->lm75[0]);
1347 kfree(data->lm75[0]);
1350 i2c_detach_client(client);
1358 w83781d_detach_client(struct i2c_client *client)
1360 struct w83781d_data *data = i2c_get_clientdata(client);
1365 hwmon_device_unregister(data->hwmon_dev);
1366 sysfs_remove_group(&client->dev.kobj, &w83781d_group);
1367 sysfs_remove_group(&client->dev.kobj, &w83781d_group_opt);
1370 if ((err = i2c_detach_client(client)))
1384 static int __devinit
1385 w83781d_isa_probe(struct platform_device *pdev)
1388 struct w83781d_data *data;
1389 struct resource *res;
1392 /* Reserve the ISA region */
1393 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1394 if (!request_region(res->start + W83781D_ADDR_REG_OFFSET, 2,
1400 if (!(data = kzalloc(sizeof(struct w83781d_data), GFP_KERNEL))) {
1402 goto exit_release_region;
1404 mutex_init(&data->lock);
1405 data->client.addr = res->start;
1406 i2c_set_clientdata(&data->client, data);
1407 platform_set_drvdata(pdev, data);
1409 reg = w83781d_read_value(data, W83781D_REG_WCHIPID);
1412 data->type = w83782d;
1416 data->type = w83781d;
1419 strlcpy(data->client.name, name, I2C_NAME_SIZE);
1421 /* Initialize the W83781D chip */
1422 w83781d_init_device(&pdev->dev);
1424 /* Register sysfs hooks */
1425 err = w83781d_create_files(&pdev->dev, data->type, 1);
1427 goto exit_remove_files;
1429 data->hwmon_dev = hwmon_device_register(&pdev->dev);
1430 if (IS_ERR(data->hwmon_dev)) {
1431 err = PTR_ERR(data->hwmon_dev);
1432 goto exit_remove_files;
1438 sysfs_remove_group(&pdev->dev.kobj, &w83781d_group);
1439 sysfs_remove_group(&pdev->dev.kobj, &w83781d_group_opt);
1440 device_remove_file(&pdev->dev, &dev_attr_name);
1442 exit_release_region:
1443 release_region(res->start + W83781D_ADDR_REG_OFFSET, 2);
1448 static int __devexit
1449 w83781d_isa_remove(struct platform_device *pdev)
1451 struct w83781d_data *data = platform_get_drvdata(pdev);
1453 hwmon_device_unregister(data->hwmon_dev);
1454 sysfs_remove_group(&pdev->dev.kobj, &w83781d_group);
1455 sysfs_remove_group(&pdev->dev.kobj, &w83781d_group_opt);
1456 device_remove_file(&pdev->dev, &dev_attr_name);
1457 release_region(data->client.addr + W83781D_ADDR_REG_OFFSET, 2);
1463 /* The SMBus locks itself, usually, but nothing may access the Winbond between
1464 bank switches. ISA access must always be locked explicitly!
1465 We ignore the W83781D BUSY flag at this moment - it could lead to deadlocks,
1466 would slow down the W83781D access and should not be necessary.
1467 There are some ugly typecasts here, but the good news is - they should
1468 nowhere else be necessary! */
1470 w83781d_read_value(struct w83781d_data *data, u16 reg)
1472 struct i2c_client *client = &data->client;
1473 int res, word_sized, bank;
1474 struct i2c_client *cl;
1476 mutex_lock(&data->lock);
1477 if (!client->driver) { /* ISA device */
1478 word_sized = (((reg & 0xff00) == 0x100)
1479 || ((reg & 0xff00) == 0x200))
1480 && (((reg & 0x00ff) == 0x50)
1481 || ((reg & 0x00ff) == 0x53)
1482 || ((reg & 0x00ff) == 0x55));
1484 outb_p(W83781D_REG_BANK,
1485 client->addr + W83781D_ADDR_REG_OFFSET);
1487 client->addr + W83781D_DATA_REG_OFFSET);
1489 outb_p(reg & 0xff, client->addr + W83781D_ADDR_REG_OFFSET);
1490 res = inb_p(client->addr + W83781D_DATA_REG_OFFSET);
1492 outb_p((reg & 0xff) + 1,
1493 client->addr + W83781D_ADDR_REG_OFFSET);
1495 (res << 8) + inb_p(client->addr +
1496 W83781D_DATA_REG_OFFSET);
1499 outb_p(W83781D_REG_BANK,
1500 client->addr + W83781D_ADDR_REG_OFFSET);
1501 outb_p(0, client->addr + W83781D_DATA_REG_OFFSET);
1504 bank = (reg >> 8) & 0x0f;
1507 i2c_smbus_write_byte_data(client, W83781D_REG_BANK,
1509 if (bank == 0 || bank > 2) {
1510 res = i2c_smbus_read_byte_data(client, reg & 0xff);
1512 /* switch to subclient */
1513 cl = data->lm75[bank - 1];
1514 /* convert from ISA to LM75 I2C addresses */
1515 switch (reg & 0xff) {
1516 case 0x50: /* TEMP */
1517 res = swab16(i2c_smbus_read_word_data(cl, 0));
1519 case 0x52: /* CONFIG */
1520 res = i2c_smbus_read_byte_data(cl, 1);
1522 case 0x53: /* HYST */
1523 res = swab16(i2c_smbus_read_word_data(cl, 2));
1525 case 0x55: /* OVER */
1527 res = swab16(i2c_smbus_read_word_data(cl, 3));
1532 i2c_smbus_write_byte_data(client, W83781D_REG_BANK, 0);
1534 mutex_unlock(&data->lock);
1539 w83781d_write_value(struct w83781d_data *data, u16 reg, u16 value)
1541 struct i2c_client *client = &data->client;
1542 int word_sized, bank;
1543 struct i2c_client *cl;
1545 mutex_lock(&data->lock);
1546 if (!client->driver) { /* ISA device */
1547 word_sized = (((reg & 0xff00) == 0x100)
1548 || ((reg & 0xff00) == 0x200))
1549 && (((reg & 0x00ff) == 0x53)
1550 || ((reg & 0x00ff) == 0x55));
1552 outb_p(W83781D_REG_BANK,
1553 client->addr + W83781D_ADDR_REG_OFFSET);
1555 client->addr + W83781D_DATA_REG_OFFSET);
1557 outb_p(reg & 0xff, client->addr + W83781D_ADDR_REG_OFFSET);
1560 client->addr + W83781D_DATA_REG_OFFSET);
1561 outb_p((reg & 0xff) + 1,
1562 client->addr + W83781D_ADDR_REG_OFFSET);
1564 outb_p(value & 0xff, client->addr + W83781D_DATA_REG_OFFSET);
1566 outb_p(W83781D_REG_BANK,
1567 client->addr + W83781D_ADDR_REG_OFFSET);
1568 outb_p(0, client->addr + W83781D_DATA_REG_OFFSET);
1571 bank = (reg >> 8) & 0x0f;
1574 i2c_smbus_write_byte_data(client, W83781D_REG_BANK,
1576 if (bank == 0 || bank > 2) {
1577 i2c_smbus_write_byte_data(client, reg & 0xff,
1580 /* switch to subclient */
1581 cl = data->lm75[bank - 1];
1582 /* convert from ISA to LM75 I2C addresses */
1583 switch (reg & 0xff) {
1584 case 0x52: /* CONFIG */
1585 i2c_smbus_write_byte_data(cl, 1, value & 0xff);
1587 case 0x53: /* HYST */
1588 i2c_smbus_write_word_data(cl, 2, swab16(value));
1590 case 0x55: /* OVER */
1591 i2c_smbus_write_word_data(cl, 3, swab16(value));
1596 i2c_smbus_write_byte_data(client, W83781D_REG_BANK, 0);
1598 mutex_unlock(&data->lock);
1603 w83781d_init_device(struct device *dev)
1605 struct w83781d_data *data = dev_get_drvdata(dev);
1607 int type = data->type;
1610 if (reset && type != as99127f) { /* this resets registers we don't have
1611 documentation for on the as99127f */
1612 /* Resetting the chip has been the default for a long time,
1613 but it causes the BIOS initializations (fan clock dividers,
1614 thermal sensor types...) to be lost, so it is now optional.
1615 It might even go away if nobody reports it as being useful,
1616 as I see very little reason why this would be needed at
1618 dev_info(dev, "If reset=1 solved a problem you were "
1619 "having, please report!\n");
1621 /* save these registers */
1622 i = w83781d_read_value(data, W83781D_REG_BEEP_CONFIG);
1623 p = w83781d_read_value(data, W83781D_REG_PWMCLK12);
1624 /* Reset all except Watchdog values and last conversion values
1625 This sets fan-divs to 2, among others */
1626 w83781d_write_value(data, W83781D_REG_CONFIG, 0x80);
1627 /* Restore the registers and disable power-on abnormal beep.
1628 This saves FAN 1/2/3 input/output values set by BIOS. */
1629 w83781d_write_value(data, W83781D_REG_BEEP_CONFIG, i | 0x80);
1630 w83781d_write_value(data, W83781D_REG_PWMCLK12, p);
1631 /* Disable master beep-enable (reset turns it on).
1632 Individual beep_mask should be reset to off but for some reason
1633 disabling this bit helps some people not get beeped */
1634 w83781d_write_value(data, W83781D_REG_BEEP_INTS2, 0);
1637 /* Disable power-on abnormal beep, as advised by the datasheet.
1638 Already done if reset=1. */
1639 if (init && !reset && type != as99127f) {
1640 i = w83781d_read_value(data, W83781D_REG_BEEP_CONFIG);
1641 w83781d_write_value(data, W83781D_REG_BEEP_CONFIG, i | 0x80);
1644 data->vrm = vid_which_vrm();
1646 if ((type != w83781d) && (type != as99127f)) {
1647 tmp = w83781d_read_value(data, W83781D_REG_SCFG1);
1648 for (i = 1; i <= 3; i++) {
1649 if (!(tmp & BIT_SCFG1[i - 1])) {
1650 data->sens[i - 1] = 4;
1652 if (w83781d_read_value
1654 W83781D_REG_SCFG2) & BIT_SCFG2[i - 1])
1655 data->sens[i - 1] = 1;
1657 data->sens[i - 1] = 2;
1659 if (type == w83783s && i == 2)
1664 if (init && type != as99127f) {
1666 tmp = w83781d_read_value(data, W83781D_REG_TEMP2_CONFIG);
1668 dev_warn(dev, "Enabling temp2, readings "
1669 "might not make sense\n");
1670 w83781d_write_value(data, W83781D_REG_TEMP2_CONFIG,
1675 if (type != w83783s) {
1676 tmp = w83781d_read_value(data,
1677 W83781D_REG_TEMP3_CONFIG);
1679 dev_warn(dev, "Enabling temp3, "
1680 "readings might not make sense\n");
1681 w83781d_write_value(data,
1682 W83781D_REG_TEMP3_CONFIG, tmp & 0xfe);
1687 /* Start monitoring */
1688 w83781d_write_value(data, W83781D_REG_CONFIG,
1689 (w83781d_read_value(data,
1690 W83781D_REG_CONFIG) & 0xf7)
1693 /* A few vars need to be filled upon startup */
1694 for (i = 0; i < 3; i++) {
1695 data->fan_min[i] = w83781d_read_value(data,
1696 W83781D_REG_FAN_MIN(i));
1699 mutex_init(&data->update_lock);
1702 static struct w83781d_data *w83781d_update_device(struct device *dev)
1704 struct w83781d_data *data = dev_get_drvdata(dev);
1705 struct i2c_client *client = &data->client;
1708 mutex_lock(&data->update_lock);
1710 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1712 dev_dbg(dev, "Starting device update\n");
1714 for (i = 0; i <= 8; i++) {
1715 if (data->type == w83783s && i == 1)
1716 continue; /* 783S has no in1 */
1718 w83781d_read_value(data, W83781D_REG_IN(i));
1720 w83781d_read_value(data, W83781D_REG_IN_MIN(i));
1722 w83781d_read_value(data, W83781D_REG_IN_MAX(i));
1723 if ((data->type != w83782d) && (i == 6))
1726 for (i = 0; i < 3; i++) {
1728 w83781d_read_value(data, W83781D_REG_FAN(i));
1730 w83781d_read_value(data, W83781D_REG_FAN_MIN(i));
1732 if (data->type != w83781d && data->type != as99127f) {
1733 for (i = 0; i < 4; i++) {
1735 w83781d_read_value(data,
1736 W83781D_REG_PWM[i]);
1737 if ((data->type != w83782d || !client->driver)
1741 /* Only PWM2 can be disabled */
1742 data->pwm2_enable = (w83781d_read_value(data,
1743 W83781D_REG_PWMCLK12) & 0x08) >> 3;
1746 data->temp = w83781d_read_value(data, W83781D_REG_TEMP(1));
1748 w83781d_read_value(data, W83781D_REG_TEMP_OVER(1));
1749 data->temp_max_hyst =
1750 w83781d_read_value(data, W83781D_REG_TEMP_HYST(1));
1752 w83781d_read_value(data, W83781D_REG_TEMP(2));
1753 data->temp_max_add[0] =
1754 w83781d_read_value(data, W83781D_REG_TEMP_OVER(2));
1755 data->temp_max_hyst_add[0] =
1756 w83781d_read_value(data, W83781D_REG_TEMP_HYST(2));
1757 if (data->type != w83783s) {
1759 w83781d_read_value(data, W83781D_REG_TEMP(3));
1760 data->temp_max_add[1] =
1761 w83781d_read_value(data,
1762 W83781D_REG_TEMP_OVER(3));
1763 data->temp_max_hyst_add[1] =
1764 w83781d_read_value(data,
1765 W83781D_REG_TEMP_HYST(3));
1767 i = w83781d_read_value(data, W83781D_REG_VID_FANDIV);
1768 data->vid = i & 0x0f;
1769 data->vid |= (w83781d_read_value(data,
1770 W83781D_REG_CHIPID) & 0x01) << 4;
1771 data->fan_div[0] = (i >> 4) & 0x03;
1772 data->fan_div[1] = (i >> 6) & 0x03;
1773 data->fan_div[2] = (w83781d_read_value(data,
1774 W83781D_REG_PIN) >> 6) & 0x03;
1775 if ((data->type != w83781d) && (data->type != as99127f)) {
1776 i = w83781d_read_value(data, W83781D_REG_VBAT);
1777 data->fan_div[0] |= (i >> 3) & 0x04;
1778 data->fan_div[1] |= (i >> 4) & 0x04;
1779 data->fan_div[2] |= (i >> 5) & 0x04;
1781 if (data->type == w83782d) {
1782 data->alarms = w83781d_read_value(data,
1784 | (w83781d_read_value(data,
1785 W83782D_REG_ALARM2) << 8)
1786 | (w83781d_read_value(data,
1787 W83782D_REG_ALARM3) << 16);
1788 } else if (data->type == w83783s) {
1789 data->alarms = w83781d_read_value(data,
1791 | (w83781d_read_value(data,
1792 W83782D_REG_ALARM2) << 8);
1794 /* No real-time status registers, fall back to
1795 interrupt status registers */
1796 data->alarms = w83781d_read_value(data,
1798 | (w83781d_read_value(data,
1799 W83781D_REG_ALARM2) << 8);
1801 i = w83781d_read_value(data, W83781D_REG_BEEP_INTS2);
1802 data->beep_mask = (i << 8) +
1803 w83781d_read_value(data, W83781D_REG_BEEP_INTS1);
1804 if ((data->type != w83781d) && (data->type != as99127f)) {
1806 w83781d_read_value(data,
1807 W83781D_REG_BEEP_INTS3) << 16;
1809 data->last_updated = jiffies;
1813 mutex_unlock(&data->update_lock);
1818 /* return 1 if a supported chip is found, 0 otherwise */
1820 w83781d_isa_found(unsigned short address)
1822 int val, save, found = 0;
1824 /* We have to request the region in two parts because some
1825 boards declare base+4 to base+7 as a PNP device */
1826 if (!request_region(address, 4, "w83781d")) {
1827 pr_debug("w83781d: Failed to request low part of region\n");
1830 if (!request_region(address + 4, 4, "w83781d")) {
1831 pr_debug("w83781d: Failed to request high part of region\n");
1832 release_region(address, 4);
1836 #define REALLY_SLOW_IO
1837 /* We need the timeouts for at least some W83781D-like
1838 chips. But only if we read 'undefined' registers. */
1839 val = inb_p(address + 1);
1840 if (inb_p(address + 2) != val
1841 || inb_p(address + 3) != val
1842 || inb_p(address + 7) != val) {
1843 pr_debug("w83781d: Detection failed at step 1\n");
1846 #undef REALLY_SLOW_IO
1848 /* We should be able to change the 7 LSB of the address port. The
1849 MSB (busy flag) should be clear initially, set after the write. */
1850 save = inb_p(address + W83781D_ADDR_REG_OFFSET);
1852 pr_debug("w83781d: Detection failed at step 2\n");
1856 outb_p(val, address + W83781D_ADDR_REG_OFFSET);
1857 if (inb_p(address + W83781D_ADDR_REG_OFFSET) != (val | 0x80)) {
1858 outb_p(save, address + W83781D_ADDR_REG_OFFSET);
1859 pr_debug("w83781d: Detection failed at step 3\n");
1863 /* We found a device, now see if it could be a W83781D */
1864 outb_p(W83781D_REG_CONFIG, address + W83781D_ADDR_REG_OFFSET);
1865 val = inb_p(address + W83781D_DATA_REG_OFFSET);
1867 pr_debug("w83781d: Detection failed at step 4\n");
1870 outb_p(W83781D_REG_BANK, address + W83781D_ADDR_REG_OFFSET);
1871 save = inb_p(address + W83781D_DATA_REG_OFFSET);
1872 outb_p(W83781D_REG_CHIPMAN, address + W83781D_ADDR_REG_OFFSET);
1873 val = inb_p(address + W83781D_DATA_REG_OFFSET);
1874 if ((!(save & 0x80) && (val != 0xa3))
1875 || ((save & 0x80) && (val != 0x5c))) {
1876 pr_debug("w83781d: Detection failed at step 5\n");
1879 outb_p(W83781D_REG_I2C_ADDR, address + W83781D_ADDR_REG_OFFSET);
1880 val = inb_p(address + W83781D_DATA_REG_OFFSET);
1881 if (val < 0x03 || val > 0x77) { /* Not a valid I2C address */
1882 pr_debug("w83781d: Detection failed at step 6\n");
1886 /* The busy flag should be clear again */
1887 if (inb_p(address + W83781D_ADDR_REG_OFFSET) & 0x80) {
1888 pr_debug("w83781d: Detection failed at step 7\n");
1892 /* Determine the chip type */
1893 outb_p(W83781D_REG_BANK, address + W83781D_ADDR_REG_OFFSET);
1894 save = inb_p(address + W83781D_DATA_REG_OFFSET);
1895 outb_p(save & 0xf8, address + W83781D_DATA_REG_OFFSET);
1896 outb_p(W83781D_REG_WCHIPID, address + W83781D_ADDR_REG_OFFSET);
1897 val = inb_p(address + W83781D_DATA_REG_OFFSET);
1898 if ((val & 0xfe) == 0x10 /* W83781D */
1899 || val == 0x30) /* W83782D */
1903 pr_info("w83781d: Found a %s chip at %#x\n",
1904 val == 0x30 ? "W83782D" : "W83781D", (int)address);
1907 release_region(address + 4, 4);
1908 release_region(address, 4);
1913 w83781d_isa_device_add(unsigned short address)
1915 struct resource res = {
1917 .end = address + W83781D_EXTENT - 1,
1919 .flags = IORESOURCE_IO,
1923 pdev = platform_device_alloc("w83781d", address);
1926 printk(KERN_ERR "w83781d: Device allocation failed\n");
1930 err = platform_device_add_resources(pdev, &res, 1);
1932 printk(KERN_ERR "w83781d: Device resource addition failed "
1934 goto exit_device_put;
1937 err = platform_device_add(pdev);
1939 printk(KERN_ERR "w83781d: Device addition failed (%d)\n",
1941 goto exit_device_put;
1947 platform_device_put(pdev);
1954 sensors_w83781d_init(void)
1958 /* We register the ISA device first, so that we can skip the
1959 * registration of an I2C interface to the same device. */
1960 if (w83781d_isa_found(isa_address)) {
1961 res = platform_driver_register(&w83781d_isa_driver);
1965 /* Sets global pdev as a side effect */
1966 res = w83781d_isa_device_add(isa_address);
1968 goto exit_unreg_isa_driver;
1971 res = i2c_add_driver(&w83781d_driver);
1973 goto exit_unreg_isa_device;
1977 exit_unreg_isa_device:
1978 platform_device_unregister(pdev);
1979 exit_unreg_isa_driver:
1980 platform_driver_unregister(&w83781d_isa_driver);
1986 sensors_w83781d_exit(void)
1989 platform_device_unregister(pdev);
1990 platform_driver_unregister(&w83781d_isa_driver);
1992 i2c_del_driver(&w83781d_driver);
1995 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
1996 "Philip Edelbrock <phil@netroedge.com>, "
1997 "and Mark Studebaker <mdsxyz123@yahoo.com>");
1998 MODULE_DESCRIPTION("W83781D driver");
1999 MODULE_LICENSE("GPL");
2001 module_init(sensors_w83781d_init);
2002 module_exit(sensors_w83781d_exit);