2 w83627hf.c - Part of lm_sensors, Linux kernel modules for hardware
4 Copyright (c) 1998 - 2003 Frodo Looijaard <frodol@dds.nl>,
5 Philip Edelbrock <phil@netroedge.com>,
6 and Mark Studebaker <mdsxyz123@yahoo.com>
7 Ported to 2.6 by Bernhard C. Schrenk <clemy@clemy.org>
8 Copyright (c) 2007 Jean Delvare <khali@linux-fr.org>
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 Supports following chips:
28 Chip #vin #fanin #pwm #temp wchipid vendid i2c ISA
29 w83627hf 9 3 2 3 0x20 0x5ca3 no yes(LPC)
30 w83627thf 7 3 3 3 0x90 0x5ca3 no yes(LPC)
31 w83637hf 7 3 3 3 0x80 0x5ca3 no yes(LPC)
32 w83687thf 7 3 3 3 0x90 0x5ca3 no yes(LPC)
33 w83697hf 8 2 2 2 0x60 0x5ca3 no yes(LPC)
35 For other winbond chips, and for i2c support in the above chips,
38 Note: automatic ("cruise") fan control for 697, 637 & 627thf not
42 #include <linux/module.h>
43 #include <linux/init.h>
44 #include <linux/slab.h>
45 #include <linux/jiffies.h>
46 #include <linux/platform_device.h>
47 #include <linux/hwmon.h>
48 #include <linux/hwmon-sysfs.h>
49 #include <linux/hwmon-vid.h>
50 #include <linux/err.h>
51 #include <linux/mutex.h>
52 #include <linux/ioport.h>
53 #include <linux/acpi.h>
57 static struct platform_device *pdev;
59 #define DRVNAME "w83627hf"
60 enum chips { w83627hf, w83627thf, w83697hf, w83637hf, w83687thf };
62 static u16 force_addr;
63 module_param(force_addr, ushort, 0);
64 MODULE_PARM_DESC(force_addr,
65 "Initialize the base address of the sensors");
66 static u8 force_i2c = 0x1f;
67 module_param(force_i2c, byte, 0);
68 MODULE_PARM_DESC(force_i2c,
69 "Initialize the i2c address of the sensors");
72 module_param(reset, bool, 0);
73 MODULE_PARM_DESC(reset, "Set to one to reset chip on load");
76 module_param(init, bool, 0);
77 MODULE_PARM_DESC(init, "Set to zero to bypass chip initialization");
79 static unsigned short force_id;
80 module_param(force_id, ushort, 0);
81 MODULE_PARM_DESC(force_id, "Override the detected device ID");
83 /* modified from kernel/include/traps.c */
84 static int REG; /* The register to read/write */
85 #define DEV 0x07 /* Register: Logical device select */
86 static int VAL; /* The value to read/write */
88 /* logical device numbers for superio_select (below) */
89 #define W83627HF_LD_FDC 0x00
90 #define W83627HF_LD_PRT 0x01
91 #define W83627HF_LD_UART1 0x02
92 #define W83627HF_LD_UART2 0x03
93 #define W83627HF_LD_KBC 0x05
94 #define W83627HF_LD_CIR 0x06 /* w83627hf only */
95 #define W83627HF_LD_GAME 0x07
96 #define W83627HF_LD_MIDI 0x07
97 #define W83627HF_LD_GPIO1 0x07
98 #define W83627HF_LD_GPIO5 0x07 /* w83627thf only */
99 #define W83627HF_LD_GPIO2 0x08
100 #define W83627HF_LD_GPIO3 0x09
101 #define W83627HF_LD_GPIO4 0x09 /* w83627thf only */
102 #define W83627HF_LD_ACPI 0x0a
103 #define W83627HF_LD_HWM 0x0b
105 #define DEVID 0x20 /* Register: Device ID */
107 #define W83627THF_GPIO5_EN 0x30 /* w83627thf only */
108 #define W83627THF_GPIO5_IOSR 0xf3 /* w83627thf only */
109 #define W83627THF_GPIO5_DR 0xf4 /* w83627thf only */
111 #define W83687THF_VID_EN 0x29 /* w83687thf only */
112 #define W83687THF_VID_CFG 0xF0 /* w83687thf only */
113 #define W83687THF_VID_DATA 0xF1 /* w83687thf only */
116 superio_outb(int reg, int val)
130 superio_select(int ld)
149 #define W627_DEVID 0x52
150 #define W627THF_DEVID 0x82
151 #define W697_DEVID 0x60
152 #define W637_DEVID 0x70
153 #define W687THF_DEVID 0x85
154 #define WINB_ACT_REG 0x30
155 #define WINB_BASE_REG 0x60
156 /* Constants specified below */
158 /* Alignment of the base address */
159 #define WINB_ALIGNMENT ~7
161 /* Offset & size of I/O region we are interested in */
162 #define WINB_REGION_OFFSET 5
163 #define WINB_REGION_SIZE 2
165 /* Where are the sensors address/data registers relative to the region offset */
166 #define W83781D_ADDR_REG_OFFSET 0
167 #define W83781D_DATA_REG_OFFSET 1
169 /* The W83781D registers */
170 /* The W83782D registers for nr=7,8 are in bank 5 */
171 #define W83781D_REG_IN_MAX(nr) ((nr < 7) ? (0x2b + (nr) * 2) : \
172 (0x554 + (((nr) - 7) * 2)))
173 #define W83781D_REG_IN_MIN(nr) ((nr < 7) ? (0x2c + (nr) * 2) : \
174 (0x555 + (((nr) - 7) * 2)))
175 #define W83781D_REG_IN(nr) ((nr < 7) ? (0x20 + (nr)) : \
178 /* nr:0-2 for fans:1-3 */
179 #define W83627HF_REG_FAN_MIN(nr) (0x3b + (nr))
180 #define W83627HF_REG_FAN(nr) (0x28 + (nr))
182 #define W83627HF_REG_TEMP2_CONFIG 0x152
183 #define W83627HF_REG_TEMP3_CONFIG 0x252
184 /* these are zero-based, unlike config constants above */
185 static const u16 w83627hf_reg_temp[] = { 0x27, 0x150, 0x250 };
186 static const u16 w83627hf_reg_temp_hyst[] = { 0x3A, 0x153, 0x253 };
187 static const u16 w83627hf_reg_temp_over[] = { 0x39, 0x155, 0x255 };
189 #define W83781D_REG_BANK 0x4E
191 #define W83781D_REG_CONFIG 0x40
192 #define W83781D_REG_ALARM1 0x459
193 #define W83781D_REG_ALARM2 0x45A
194 #define W83781D_REG_ALARM3 0x45B
196 #define W83781D_REG_BEEP_CONFIG 0x4D
197 #define W83781D_REG_BEEP_INTS1 0x56
198 #define W83781D_REG_BEEP_INTS2 0x57
199 #define W83781D_REG_BEEP_INTS3 0x453
201 #define W83781D_REG_VID_FANDIV 0x47
203 #define W83781D_REG_CHIPID 0x49
204 #define W83781D_REG_WCHIPID 0x58
205 #define W83781D_REG_CHIPMAN 0x4F
206 #define W83781D_REG_PIN 0x4B
208 #define W83781D_REG_VBAT 0x5D
210 #define W83627HF_REG_PWM1 0x5A
211 #define W83627HF_REG_PWM2 0x5B
213 #define W83627THF_REG_PWM1 0x01 /* 697HF/637HF/687THF too */
214 #define W83627THF_REG_PWM2 0x03 /* 697HF/637HF/687THF too */
215 #define W83627THF_REG_PWM3 0x11 /* 637HF/687THF too */
217 #define W83627THF_REG_VRM_OVT_CFG 0x18 /* 637HF/687THF too */
219 static const u8 regpwm_627hf[] = { W83627HF_REG_PWM1, W83627HF_REG_PWM2 };
220 static const u8 regpwm[] = { W83627THF_REG_PWM1, W83627THF_REG_PWM2,
221 W83627THF_REG_PWM3 };
222 #define W836X7HF_REG_PWM(type, nr) (((type) == w83627hf) ? \
223 regpwm_627hf[nr] : regpwm[nr])
225 #define W83627HF_REG_PWM_FREQ 0x5C /* Only for the 627HF */
227 #define W83637HF_REG_PWM_FREQ1 0x00 /* 697HF/687THF too */
228 #define W83637HF_REG_PWM_FREQ2 0x02 /* 697HF/687THF too */
229 #define W83637HF_REG_PWM_FREQ3 0x10 /* 687THF too */
231 static const u8 W83637HF_REG_PWM_FREQ[] = { W83637HF_REG_PWM_FREQ1,
232 W83637HF_REG_PWM_FREQ2,
233 W83637HF_REG_PWM_FREQ3 };
235 #define W83627HF_BASE_PWM_FREQ 46870
237 #define W83781D_REG_I2C_ADDR 0x48
238 #define W83781D_REG_I2C_SUBADDR 0x4A
240 /* Sensor selection */
241 #define W83781D_REG_SCFG1 0x5D
242 static const u8 BIT_SCFG1[] = { 0x02, 0x04, 0x08 };
243 #define W83781D_REG_SCFG2 0x59
244 static const u8 BIT_SCFG2[] = { 0x10, 0x20, 0x40 };
245 #define W83781D_DEFAULT_BETA 3435
247 /* Conversions. Limit checking is only done on the TO_REG
248 variants. Note that you should be a bit careful with which arguments
249 these macros are called: arguments may be evaluated more than once.
250 Fixing this is just not worth it. */
251 #define IN_TO_REG(val) (SENSORS_LIMIT((((val) + 8)/16),0,255))
252 #define IN_FROM_REG(val) ((val) * 16)
254 static inline u8 FAN_TO_REG(long rpm, int div)
258 rpm = SENSORS_LIMIT(rpm, 1, 1000000);
259 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
263 #define TEMP_MIN (-128000)
264 #define TEMP_MAX ( 127000)
266 /* TEMP: 0.001C/bit (-128C to +127C)
267 REG: 1C/bit, two's complement */
268 static u8 TEMP_TO_REG(long temp)
270 int ntemp = SENSORS_LIMIT(temp, TEMP_MIN, TEMP_MAX);
271 ntemp += (ntemp<0 ? -500 : 500);
272 return (u8)(ntemp / 1000);
275 static int TEMP_FROM_REG(u8 reg)
277 return (s8)reg * 1000;
280 #define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
282 #define PWM_TO_REG(val) (SENSORS_LIMIT((val),0,255))
284 static inline unsigned long pwm_freq_from_reg_627hf(u8 reg)
287 freq = W83627HF_BASE_PWM_FREQ >> reg;
290 static inline u8 pwm_freq_to_reg_627hf(unsigned long val)
293 /* Only 5 dividers (1 2 4 8 16)
294 Search for the nearest available frequency */
295 for (i = 0; i < 4; i++) {
296 if (val > (((W83627HF_BASE_PWM_FREQ >> i) +
297 (W83627HF_BASE_PWM_FREQ >> (i+1))) / 2))
303 static inline unsigned long pwm_freq_from_reg(u8 reg)
305 /* Clock bit 8 -> 180 kHz or 24 MHz */
306 unsigned long clock = (reg & 0x80) ? 180000UL : 24000000UL;
309 /* This should not happen but anyway... */
312 return (clock / (reg << 8));
314 static inline u8 pwm_freq_to_reg(unsigned long val)
316 /* Minimum divider value is 0x01 and maximum is 0x7F */
317 if (val >= 93750) /* The highest we can do */
319 if (val >= 720) /* Use 24 MHz clock */
320 return (24000000UL / (val << 8));
321 if (val < 6) /* The lowest we can do */
323 else /* Use 180 kHz clock */
324 return (0x80 | (180000UL / (val << 8)));
327 #define BEEP_MASK_FROM_REG(val) ((val) & 0xff7fff)
328 #define BEEP_MASK_TO_REG(val) ((val) & 0xff7fff)
330 #define DIV_FROM_REG(val) (1 << (val))
332 static inline u8 DIV_TO_REG(long val)
335 val = SENSORS_LIMIT(val, 1, 128) >> 1;
336 for (i = 0; i < 7; i++) {
344 /* For each registered chip, we need to keep some data in memory.
345 The structure is dynamically allocated. */
346 struct w83627hf_data {
349 struct device *hwmon_dev;
353 struct mutex update_lock;
354 char valid; /* !=0 if following fields are valid */
355 unsigned long last_updated; /* In jiffies */
357 u8 in[9]; /* Register value */
358 u8 in_max[9]; /* Register value */
359 u8 in_min[9]; /* Register value */
360 u8 fan[3]; /* Register value */
361 u8 fan_min[3]; /* Register value */
362 u16 temp[3]; /* Register value */
363 u16 temp_max[3]; /* Register value */
364 u16 temp_max_hyst[3]; /* Register value */
365 u8 fan_div[3]; /* Register encoding, shifted right */
366 u8 vid; /* Register encoding, combined */
367 u32 alarms; /* Register encoding, combined */
368 u32 beep_mask; /* Register encoding, combined */
369 u8 pwm[3]; /* Register value */
370 u8 pwm_freq[3]; /* Register value */
371 u16 sens[3]; /* 1 = pentium diode; 2 = 3904 diode;
374 u8 vrm_ovt; /* Register value, 627THF/637HF/687THF only */
377 struct w83627hf_sio_data {
382 static int w83627hf_probe(struct platform_device *pdev);
383 static int __devexit w83627hf_remove(struct platform_device *pdev);
385 static int w83627hf_read_value(struct w83627hf_data *data, u16 reg);
386 static int w83627hf_write_value(struct w83627hf_data *data, u16 reg, u16 value);
387 static void w83627hf_update_fan_div(struct w83627hf_data *data);
388 static struct w83627hf_data *w83627hf_update_device(struct device *dev);
389 static void w83627hf_init_device(struct platform_device *pdev);
391 static struct platform_driver w83627hf_driver = {
393 .owner = THIS_MODULE,
396 .probe = w83627hf_probe,
397 .remove = __devexit_p(w83627hf_remove),
401 show_in_input(struct device *dev, struct device_attribute *devattr, char *buf)
403 int nr = to_sensor_dev_attr(devattr)->index;
404 struct w83627hf_data *data = w83627hf_update_device(dev);
405 return sprintf(buf, "%ld\n", (long)IN_FROM_REG(data->in[nr]));
408 show_in_min(struct device *dev, struct device_attribute *devattr, char *buf)
410 int nr = to_sensor_dev_attr(devattr)->index;
411 struct w83627hf_data *data = w83627hf_update_device(dev);
412 return sprintf(buf, "%ld\n", (long)IN_FROM_REG(data->in_min[nr]));
415 show_in_max(struct device *dev, struct device_attribute *devattr, char *buf)
417 int nr = to_sensor_dev_attr(devattr)->index;
418 struct w83627hf_data *data = w83627hf_update_device(dev);
419 return sprintf(buf, "%ld\n", (long)IN_FROM_REG(data->in_max[nr]));
422 store_in_min(struct device *dev, struct device_attribute *devattr,
423 const char *buf, size_t count)
425 int nr = to_sensor_dev_attr(devattr)->index;
426 struct w83627hf_data *data = dev_get_drvdata(dev);
427 long val = simple_strtol(buf, NULL, 10);
429 mutex_lock(&data->update_lock);
430 data->in_min[nr] = IN_TO_REG(val);
431 w83627hf_write_value(data, W83781D_REG_IN_MIN(nr), data->in_min[nr]);
432 mutex_unlock(&data->update_lock);
436 store_in_max(struct device *dev, struct device_attribute *devattr,
437 const char *buf, size_t count)
439 int nr = to_sensor_dev_attr(devattr)->index;
440 struct w83627hf_data *data = dev_get_drvdata(dev);
441 long val = simple_strtol(buf, NULL, 10);
443 mutex_lock(&data->update_lock);
444 data->in_max[nr] = IN_TO_REG(val);
445 w83627hf_write_value(data, W83781D_REG_IN_MAX(nr), data->in_max[nr]);
446 mutex_unlock(&data->update_lock);
449 #define sysfs_vin_decl(offset) \
450 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
451 show_in_input, NULL, offset); \
452 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO|S_IWUSR, \
453 show_in_min, store_in_min, offset); \
454 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO|S_IWUSR, \
455 show_in_max, store_in_max, offset);
466 /* use a different set of functions for in0 */
467 static ssize_t show_in_0(struct w83627hf_data *data, char *buf, u8 reg)
471 if ((data->vrm_ovt & 0x01) &&
472 (w83627thf == data->type || w83637hf == data->type
473 || w83687thf == data->type))
475 /* use VRM9 calculation */
476 in0 = (long)((reg * 488 + 70000 + 50) / 100);
478 /* use VRM8 (standard) calculation */
479 in0 = (long)IN_FROM_REG(reg);
481 return sprintf(buf,"%ld\n", in0);
484 static ssize_t show_regs_in_0(struct device *dev, struct device_attribute *attr, char *buf)
486 struct w83627hf_data *data = w83627hf_update_device(dev);
487 return show_in_0(data, buf, data->in[0]);
490 static ssize_t show_regs_in_min0(struct device *dev, struct device_attribute *attr, char *buf)
492 struct w83627hf_data *data = w83627hf_update_device(dev);
493 return show_in_0(data, buf, data->in_min[0]);
496 static ssize_t show_regs_in_max0(struct device *dev, struct device_attribute *attr, char *buf)
498 struct w83627hf_data *data = w83627hf_update_device(dev);
499 return show_in_0(data, buf, data->in_max[0]);
502 static ssize_t store_regs_in_min0(struct device *dev, struct device_attribute *attr,
503 const char *buf, size_t count)
505 struct w83627hf_data *data = dev_get_drvdata(dev);
508 val = simple_strtoul(buf, NULL, 10);
510 mutex_lock(&data->update_lock);
512 if ((data->vrm_ovt & 0x01) &&
513 (w83627thf == data->type || w83637hf == data->type
514 || w83687thf == data->type))
516 /* use VRM9 calculation */
518 SENSORS_LIMIT(((val * 100) - 70000 + 244) / 488, 0,
521 /* use VRM8 (standard) calculation */
522 data->in_min[0] = IN_TO_REG(val);
524 w83627hf_write_value(data, W83781D_REG_IN_MIN(0), data->in_min[0]);
525 mutex_unlock(&data->update_lock);
529 static ssize_t store_regs_in_max0(struct device *dev, struct device_attribute *attr,
530 const char *buf, size_t count)
532 struct w83627hf_data *data = dev_get_drvdata(dev);
535 val = simple_strtoul(buf, NULL, 10);
537 mutex_lock(&data->update_lock);
539 if ((data->vrm_ovt & 0x01) &&
540 (w83627thf == data->type || w83637hf == data->type
541 || w83687thf == data->type))
543 /* use VRM9 calculation */
545 SENSORS_LIMIT(((val * 100) - 70000 + 244) / 488, 0,
548 /* use VRM8 (standard) calculation */
549 data->in_max[0] = IN_TO_REG(val);
551 w83627hf_write_value(data, W83781D_REG_IN_MAX(0), data->in_max[0]);
552 mutex_unlock(&data->update_lock);
556 static DEVICE_ATTR(in0_input, S_IRUGO, show_regs_in_0, NULL);
557 static DEVICE_ATTR(in0_min, S_IRUGO | S_IWUSR,
558 show_regs_in_min0, store_regs_in_min0);
559 static DEVICE_ATTR(in0_max, S_IRUGO | S_IWUSR,
560 show_regs_in_max0, store_regs_in_max0);
563 show_fan_input(struct device *dev, struct device_attribute *devattr, char *buf)
565 int nr = to_sensor_dev_attr(devattr)->index;
566 struct w83627hf_data *data = w83627hf_update_device(dev);
567 return sprintf(buf, "%ld\n", FAN_FROM_REG(data->fan[nr],
568 (long)DIV_FROM_REG(data->fan_div[nr])));
571 show_fan_min(struct device *dev, struct device_attribute *devattr, char *buf)
573 int nr = to_sensor_dev_attr(devattr)->index;
574 struct w83627hf_data *data = w83627hf_update_device(dev);
575 return sprintf(buf, "%ld\n", FAN_FROM_REG(data->fan_min[nr],
576 (long)DIV_FROM_REG(data->fan_div[nr])));
579 store_fan_min(struct device *dev, struct device_attribute *devattr,
580 const char *buf, size_t count)
582 int nr = to_sensor_dev_attr(devattr)->index;
583 struct w83627hf_data *data = dev_get_drvdata(dev);
584 u32 val = simple_strtoul(buf, NULL, 10);
586 mutex_lock(&data->update_lock);
587 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
588 w83627hf_write_value(data, W83627HF_REG_FAN_MIN(nr),
591 mutex_unlock(&data->update_lock);
594 #define sysfs_fan_decl(offset) \
595 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
596 show_fan_input, NULL, offset - 1); \
597 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
598 show_fan_min, store_fan_min, offset - 1);
605 show_temp(struct device *dev, struct device_attribute *devattr, char *buf)
607 int nr = to_sensor_dev_attr(devattr)->index;
608 struct w83627hf_data *data = w83627hf_update_device(dev);
610 u16 tmp = data->temp[nr];
611 return sprintf(buf, "%ld\n", (nr) ? (long) LM75_TEMP_FROM_REG(tmp)
612 : (long) TEMP_FROM_REG(tmp));
616 show_temp_max(struct device *dev, struct device_attribute *devattr,
619 int nr = to_sensor_dev_attr(devattr)->index;
620 struct w83627hf_data *data = w83627hf_update_device(dev);
622 u16 tmp = data->temp_max[nr];
623 return sprintf(buf, "%ld\n", (nr) ? (long) LM75_TEMP_FROM_REG(tmp)
624 : (long) TEMP_FROM_REG(tmp));
628 show_temp_max_hyst(struct device *dev, struct device_attribute *devattr,
631 int nr = to_sensor_dev_attr(devattr)->index;
632 struct w83627hf_data *data = w83627hf_update_device(dev);
634 u16 tmp = data->temp_max_hyst[nr];
635 return sprintf(buf, "%ld\n", (nr) ? (long) LM75_TEMP_FROM_REG(tmp)
636 : (long) TEMP_FROM_REG(tmp));
640 store_temp_max(struct device *dev, struct device_attribute *devattr,
641 const char *buf, size_t count)
643 int nr = to_sensor_dev_attr(devattr)->index;
644 struct w83627hf_data *data = dev_get_drvdata(dev);
645 long val = simple_strtol(buf, NULL, 10);
646 u16 tmp = (nr) ? LM75_TEMP_TO_REG(val) : TEMP_TO_REG(val);
648 mutex_lock(&data->update_lock);
649 data->temp_max[nr] = tmp;
650 w83627hf_write_value(data, w83627hf_reg_temp_over[nr], tmp);
651 mutex_unlock(&data->update_lock);
656 store_temp_max_hyst(struct device *dev, struct device_attribute *devattr,
657 const char *buf, size_t count)
659 int nr = to_sensor_dev_attr(devattr)->index;
660 struct w83627hf_data *data = dev_get_drvdata(dev);
661 long val = simple_strtol(buf, NULL, 10);
662 u16 tmp = (nr) ? LM75_TEMP_TO_REG(val) : TEMP_TO_REG(val);
664 mutex_lock(&data->update_lock);
665 data->temp_max_hyst[nr] = tmp;
666 w83627hf_write_value(data, w83627hf_reg_temp_hyst[nr], tmp);
667 mutex_unlock(&data->update_lock);
671 #define sysfs_temp_decl(offset) \
672 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
673 show_temp, NULL, offset - 1); \
674 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO|S_IWUSR, \
675 show_temp_max, store_temp_max, offset - 1); \
676 static SENSOR_DEVICE_ATTR(temp##offset##_max_hyst, S_IRUGO|S_IWUSR, \
677 show_temp_max_hyst, store_temp_max_hyst, offset - 1);
684 show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
686 struct w83627hf_data *data = w83627hf_update_device(dev);
687 return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm));
689 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
692 show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
694 struct w83627hf_data *data = dev_get_drvdata(dev);
695 return sprintf(buf, "%ld\n", (long) data->vrm);
698 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
700 struct w83627hf_data *data = dev_get_drvdata(dev);
703 val = simple_strtoul(buf, NULL, 10);
708 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
711 show_alarms_reg(struct device *dev, struct device_attribute *attr, char *buf)
713 struct w83627hf_data *data = w83627hf_update_device(dev);
714 return sprintf(buf, "%ld\n", (long) data->alarms);
716 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
719 show_alarm(struct device *dev, struct device_attribute *attr, char *buf)
721 struct w83627hf_data *data = w83627hf_update_device(dev);
722 int bitnr = to_sensor_dev_attr(attr)->index;
723 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
725 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
726 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
727 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
728 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
729 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
730 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9);
731 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 10);
732 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 16);
733 static SENSOR_DEVICE_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 17);
734 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
735 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
736 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11);
737 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4);
738 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5);
739 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13);
742 show_beep_mask(struct device *dev, struct device_attribute *attr, char *buf)
744 struct w83627hf_data *data = w83627hf_update_device(dev);
745 return sprintf(buf, "%ld\n",
746 (long)BEEP_MASK_FROM_REG(data->beep_mask));
750 store_beep_mask(struct device *dev, struct device_attribute *attr,
751 const char *buf, size_t count)
753 struct w83627hf_data *data = dev_get_drvdata(dev);
756 val = simple_strtoul(buf, NULL, 10);
758 mutex_lock(&data->update_lock);
760 /* preserve beep enable */
761 data->beep_mask = (data->beep_mask & 0x8000)
762 | BEEP_MASK_TO_REG(val);
763 w83627hf_write_value(data, W83781D_REG_BEEP_INTS1,
764 data->beep_mask & 0xff);
765 w83627hf_write_value(data, W83781D_REG_BEEP_INTS3,
766 ((data->beep_mask) >> 16) & 0xff);
767 w83627hf_write_value(data, W83781D_REG_BEEP_INTS2,
768 (data->beep_mask >> 8) & 0xff);
770 mutex_unlock(&data->update_lock);
774 static DEVICE_ATTR(beep_mask, S_IRUGO | S_IWUSR,
775 show_beep_mask, store_beep_mask);
778 show_beep(struct device *dev, struct device_attribute *attr, char *buf)
780 struct w83627hf_data *data = w83627hf_update_device(dev);
781 int bitnr = to_sensor_dev_attr(attr)->index;
782 return sprintf(buf, "%u\n", (data->beep_mask >> bitnr) & 1);
786 store_beep(struct device *dev, struct device_attribute *attr,
787 const char *buf, size_t count)
789 struct w83627hf_data *data = dev_get_drvdata(dev);
790 int bitnr = to_sensor_dev_attr(attr)->index;
794 bit = simple_strtoul(buf, NULL, 10);
798 mutex_lock(&data->update_lock);
800 data->beep_mask |= (1 << bitnr);
802 data->beep_mask &= ~(1 << bitnr);
805 reg = w83627hf_read_value(data, W83781D_REG_BEEP_INTS1);
809 reg &= ~(1 << bitnr);
810 w83627hf_write_value(data, W83781D_REG_BEEP_INTS1, reg);
811 } else if (bitnr < 16) {
812 reg = w83627hf_read_value(data, W83781D_REG_BEEP_INTS2);
814 reg |= (1 << (bitnr - 8));
816 reg &= ~(1 << (bitnr - 8));
817 w83627hf_write_value(data, W83781D_REG_BEEP_INTS2, reg);
819 reg = w83627hf_read_value(data, W83781D_REG_BEEP_INTS3);
821 reg |= (1 << (bitnr - 16));
823 reg &= ~(1 << (bitnr - 16));
824 w83627hf_write_value(data, W83781D_REG_BEEP_INTS3, reg);
826 mutex_unlock(&data->update_lock);
831 static SENSOR_DEVICE_ATTR(in0_beep, S_IRUGO | S_IWUSR,
832 show_beep, store_beep, 0);
833 static SENSOR_DEVICE_ATTR(in1_beep, S_IRUGO | S_IWUSR,
834 show_beep, store_beep, 1);
835 static SENSOR_DEVICE_ATTR(in2_beep, S_IRUGO | S_IWUSR,
836 show_beep, store_beep, 2);
837 static SENSOR_DEVICE_ATTR(in3_beep, S_IRUGO | S_IWUSR,
838 show_beep, store_beep, 3);
839 static SENSOR_DEVICE_ATTR(in4_beep, S_IRUGO | S_IWUSR,
840 show_beep, store_beep, 8);
841 static SENSOR_DEVICE_ATTR(in5_beep, S_IRUGO | S_IWUSR,
842 show_beep, store_beep, 9);
843 static SENSOR_DEVICE_ATTR(in6_beep, S_IRUGO | S_IWUSR,
844 show_beep, store_beep, 10);
845 static SENSOR_DEVICE_ATTR(in7_beep, S_IRUGO | S_IWUSR,
846 show_beep, store_beep, 16);
847 static SENSOR_DEVICE_ATTR(in8_beep, S_IRUGO | S_IWUSR,
848 show_beep, store_beep, 17);
849 static SENSOR_DEVICE_ATTR(fan1_beep, S_IRUGO | S_IWUSR,
850 show_beep, store_beep, 6);
851 static SENSOR_DEVICE_ATTR(fan2_beep, S_IRUGO | S_IWUSR,
852 show_beep, store_beep, 7);
853 static SENSOR_DEVICE_ATTR(fan3_beep, S_IRUGO | S_IWUSR,
854 show_beep, store_beep, 11);
855 static SENSOR_DEVICE_ATTR(temp1_beep, S_IRUGO | S_IWUSR,
856 show_beep, store_beep, 4);
857 static SENSOR_DEVICE_ATTR(temp2_beep, S_IRUGO | S_IWUSR,
858 show_beep, store_beep, 5);
859 static SENSOR_DEVICE_ATTR(temp3_beep, S_IRUGO | S_IWUSR,
860 show_beep, store_beep, 13);
861 static SENSOR_DEVICE_ATTR(beep_enable, S_IRUGO | S_IWUSR,
862 show_beep, store_beep, 15);
865 show_fan_div(struct device *dev, struct device_attribute *devattr, char *buf)
867 int nr = to_sensor_dev_attr(devattr)->index;
868 struct w83627hf_data *data = w83627hf_update_device(dev);
869 return sprintf(buf, "%ld\n",
870 (long) DIV_FROM_REG(data->fan_div[nr]));
872 /* Note: we save and restore the fan minimum here, because its value is
873 determined in part by the fan divisor. This follows the principle of
874 least surprise; the user doesn't expect the fan minimum to change just
875 because the divisor changed. */
877 store_fan_div(struct device *dev, struct device_attribute *devattr,
878 const char *buf, size_t count)
880 int nr = to_sensor_dev_attr(devattr)->index;
881 struct w83627hf_data *data = dev_get_drvdata(dev);
884 unsigned long val = simple_strtoul(buf, NULL, 10);
886 mutex_lock(&data->update_lock);
889 min = FAN_FROM_REG(data->fan_min[nr],
890 DIV_FROM_REG(data->fan_div[nr]));
892 data->fan_div[nr] = DIV_TO_REG(val);
894 reg = (w83627hf_read_value(data, nr==2 ? W83781D_REG_PIN : W83781D_REG_VID_FANDIV)
895 & (nr==0 ? 0xcf : 0x3f))
896 | ((data->fan_div[nr] & 0x03) << (nr==0 ? 4 : 6));
897 w83627hf_write_value(data, nr==2 ? W83781D_REG_PIN : W83781D_REG_VID_FANDIV, reg);
899 reg = (w83627hf_read_value(data, W83781D_REG_VBAT)
901 | ((data->fan_div[nr] & 0x04) << (3 + nr));
902 w83627hf_write_value(data, W83781D_REG_VBAT, reg);
904 /* Restore fan_min */
905 data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
906 w83627hf_write_value(data, W83627HF_REG_FAN_MIN(nr), data->fan_min[nr]);
908 mutex_unlock(&data->update_lock);
912 static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO|S_IWUSR,
913 show_fan_div, store_fan_div, 0);
914 static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO|S_IWUSR,
915 show_fan_div, store_fan_div, 1);
916 static SENSOR_DEVICE_ATTR(fan3_div, S_IRUGO|S_IWUSR,
917 show_fan_div, store_fan_div, 2);
920 show_pwm(struct device *dev, struct device_attribute *devattr, char *buf)
922 int nr = to_sensor_dev_attr(devattr)->index;
923 struct w83627hf_data *data = w83627hf_update_device(dev);
924 return sprintf(buf, "%ld\n", (long) data->pwm[nr]);
928 store_pwm(struct device *dev, struct device_attribute *devattr,
929 const char *buf, size_t count)
931 int nr = to_sensor_dev_attr(devattr)->index;
932 struct w83627hf_data *data = dev_get_drvdata(dev);
933 u32 val = simple_strtoul(buf, NULL, 10);
935 mutex_lock(&data->update_lock);
937 if (data->type == w83627thf) {
938 /* bits 0-3 are reserved in 627THF */
939 data->pwm[nr] = PWM_TO_REG(val) & 0xf0;
940 w83627hf_write_value(data,
941 W836X7HF_REG_PWM(data->type, nr),
943 (w83627hf_read_value(data,
944 W836X7HF_REG_PWM(data->type, nr)) & 0x0f));
946 data->pwm[nr] = PWM_TO_REG(val);
947 w83627hf_write_value(data,
948 W836X7HF_REG_PWM(data->type, nr),
952 mutex_unlock(&data->update_lock);
956 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO|S_IWUSR, show_pwm, store_pwm, 0);
957 static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO|S_IWUSR, show_pwm, store_pwm, 1);
958 static SENSOR_DEVICE_ATTR(pwm3, S_IRUGO|S_IWUSR, show_pwm, store_pwm, 2);
961 show_pwm_freq(struct device *dev, struct device_attribute *devattr, char *buf)
963 int nr = to_sensor_dev_attr(devattr)->index;
964 struct w83627hf_data *data = w83627hf_update_device(dev);
965 if (data->type == w83627hf)
966 return sprintf(buf, "%ld\n",
967 pwm_freq_from_reg_627hf(data->pwm_freq[nr]));
969 return sprintf(buf, "%ld\n",
970 pwm_freq_from_reg(data->pwm_freq[nr]));
974 store_pwm_freq(struct device *dev, struct device_attribute *devattr,
975 const char *buf, size_t count)
977 int nr = to_sensor_dev_attr(devattr)->index;
978 struct w83627hf_data *data = dev_get_drvdata(dev);
979 static const u8 mask[]={0xF8, 0x8F};
982 val = simple_strtoul(buf, NULL, 10);
984 mutex_lock(&data->update_lock);
986 if (data->type == w83627hf) {
987 data->pwm_freq[nr] = pwm_freq_to_reg_627hf(val);
988 w83627hf_write_value(data, W83627HF_REG_PWM_FREQ,
989 (data->pwm_freq[nr] << (nr*4)) |
990 (w83627hf_read_value(data,
991 W83627HF_REG_PWM_FREQ) & mask[nr]));
993 data->pwm_freq[nr] = pwm_freq_to_reg(val);
994 w83627hf_write_value(data, W83637HF_REG_PWM_FREQ[nr],
998 mutex_unlock(&data->update_lock);
1002 static SENSOR_DEVICE_ATTR(pwm1_freq, S_IRUGO|S_IWUSR,
1003 show_pwm_freq, store_pwm_freq, 0);
1004 static SENSOR_DEVICE_ATTR(pwm2_freq, S_IRUGO|S_IWUSR,
1005 show_pwm_freq, store_pwm_freq, 1);
1006 static SENSOR_DEVICE_ATTR(pwm3_freq, S_IRUGO|S_IWUSR,
1007 show_pwm_freq, store_pwm_freq, 2);
1010 show_temp_type(struct device *dev, struct device_attribute *devattr,
1013 int nr = to_sensor_dev_attr(devattr)->index;
1014 struct w83627hf_data *data = w83627hf_update_device(dev);
1015 return sprintf(buf, "%ld\n", (long) data->sens[nr]);
1019 store_temp_type(struct device *dev, struct device_attribute *devattr,
1020 const char *buf, size_t count)
1022 int nr = to_sensor_dev_attr(devattr)->index;
1023 struct w83627hf_data *data = dev_get_drvdata(dev);
1026 val = simple_strtoul(buf, NULL, 10);
1028 mutex_lock(&data->update_lock);
1031 case 1: /* PII/Celeron diode */
1032 tmp = w83627hf_read_value(data, W83781D_REG_SCFG1);
1033 w83627hf_write_value(data, W83781D_REG_SCFG1,
1034 tmp | BIT_SCFG1[nr]);
1035 tmp = w83627hf_read_value(data, W83781D_REG_SCFG2);
1036 w83627hf_write_value(data, W83781D_REG_SCFG2,
1037 tmp | BIT_SCFG2[nr]);
1038 data->sens[nr] = val;
1041 tmp = w83627hf_read_value(data, W83781D_REG_SCFG1);
1042 w83627hf_write_value(data, W83781D_REG_SCFG1,
1043 tmp | BIT_SCFG1[nr]);
1044 tmp = w83627hf_read_value(data, W83781D_REG_SCFG2);
1045 w83627hf_write_value(data, W83781D_REG_SCFG2,
1046 tmp & ~BIT_SCFG2[nr]);
1047 data->sens[nr] = val;
1049 case W83781D_DEFAULT_BETA:
1050 dev_warn(dev, "Sensor type %d is deprecated, please use 4 "
1051 "instead\n", W83781D_DEFAULT_BETA);
1053 case 4: /* thermistor */
1054 tmp = w83627hf_read_value(data, W83781D_REG_SCFG1);
1055 w83627hf_write_value(data, W83781D_REG_SCFG1,
1056 tmp & ~BIT_SCFG1[nr]);
1057 data->sens[nr] = val;
1061 "Invalid sensor type %ld; must be 1, 2, or 4\n",
1066 mutex_unlock(&data->update_lock);
1070 #define sysfs_temp_type(offset) \
1071 static SENSOR_DEVICE_ATTR(temp##offset##_type, S_IRUGO | S_IWUSR, \
1072 show_temp_type, store_temp_type, offset - 1);
1079 show_name(struct device *dev, struct device_attribute *devattr, char *buf)
1081 struct w83627hf_data *data = dev_get_drvdata(dev);
1083 return sprintf(buf, "%s\n", data->name);
1085 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
1087 static int __init w83627hf_find(int sioaddr, unsigned short *addr,
1088 struct w83627hf_sio_data *sio_data)
1093 static const __initdata char *names[] = {
1105 val = force_id ? force_id : superio_inb(DEVID);
1108 sio_data->type = w83627hf;
1111 sio_data->type = w83627thf;
1114 sio_data->type = w83697hf;
1117 sio_data->type = w83637hf;
1120 sio_data->type = w83687thf;
1122 case 0xff: /* No device at all */
1125 pr_debug(DRVNAME ": Unsupported chip (DEVID=0x%02x)\n", val);
1129 superio_select(W83627HF_LD_HWM);
1130 force_addr &= WINB_ALIGNMENT;
1132 printk(KERN_WARNING DRVNAME ": Forcing address 0x%x\n",
1134 superio_outb(WINB_BASE_REG, force_addr >> 8);
1135 superio_outb(WINB_BASE_REG + 1, force_addr & 0xff);
1137 val = (superio_inb(WINB_BASE_REG) << 8) |
1138 superio_inb(WINB_BASE_REG + 1);
1139 *addr = val & WINB_ALIGNMENT;
1141 printk(KERN_WARNING DRVNAME ": Base address not set, "
1146 val = superio_inb(WINB_ACT_REG);
1147 if (!(val & 0x01)) {
1148 printk(KERN_WARNING DRVNAME ": Enabling HWM logical device\n");
1149 superio_outb(WINB_ACT_REG, val | 0x01);
1153 pr_info(DRVNAME ": Found %s chip at %#x\n",
1154 names[sio_data->type], *addr);
1161 #define VIN_UNIT_ATTRS(_X_) \
1162 &sensor_dev_attr_in##_X_##_input.dev_attr.attr, \
1163 &sensor_dev_attr_in##_X_##_min.dev_attr.attr, \
1164 &sensor_dev_attr_in##_X_##_max.dev_attr.attr, \
1165 &sensor_dev_attr_in##_X_##_alarm.dev_attr.attr, \
1166 &sensor_dev_attr_in##_X_##_beep.dev_attr.attr
1168 #define FAN_UNIT_ATTRS(_X_) \
1169 &sensor_dev_attr_fan##_X_##_input.dev_attr.attr, \
1170 &sensor_dev_attr_fan##_X_##_min.dev_attr.attr, \
1171 &sensor_dev_attr_fan##_X_##_div.dev_attr.attr, \
1172 &sensor_dev_attr_fan##_X_##_alarm.dev_attr.attr, \
1173 &sensor_dev_attr_fan##_X_##_beep.dev_attr.attr
1175 #define TEMP_UNIT_ATTRS(_X_) \
1176 &sensor_dev_attr_temp##_X_##_input.dev_attr.attr, \
1177 &sensor_dev_attr_temp##_X_##_max.dev_attr.attr, \
1178 &sensor_dev_attr_temp##_X_##_max_hyst.dev_attr.attr, \
1179 &sensor_dev_attr_temp##_X_##_type.dev_attr.attr, \
1180 &sensor_dev_attr_temp##_X_##_alarm.dev_attr.attr, \
1181 &sensor_dev_attr_temp##_X_##_beep.dev_attr.attr
1183 static struct attribute *w83627hf_attributes[] = {
1184 &dev_attr_in0_input.attr,
1185 &dev_attr_in0_min.attr,
1186 &dev_attr_in0_max.attr,
1187 &sensor_dev_attr_in0_alarm.dev_attr.attr,
1188 &sensor_dev_attr_in0_beep.dev_attr.attr,
1201 &dev_attr_alarms.attr,
1202 &sensor_dev_attr_beep_enable.dev_attr.attr,
1203 &dev_attr_beep_mask.attr,
1205 &sensor_dev_attr_pwm1.dev_attr.attr,
1206 &sensor_dev_attr_pwm2.dev_attr.attr,
1207 &dev_attr_name.attr,
1211 static const struct attribute_group w83627hf_group = {
1212 .attrs = w83627hf_attributes,
1215 static struct attribute *w83627hf_attributes_opt[] = {
1222 &sensor_dev_attr_pwm3.dev_attr.attr,
1224 &sensor_dev_attr_pwm1_freq.dev_attr.attr,
1225 &sensor_dev_attr_pwm2_freq.dev_attr.attr,
1226 &sensor_dev_attr_pwm3_freq.dev_attr.attr,
1230 static const struct attribute_group w83627hf_group_opt = {
1231 .attrs = w83627hf_attributes_opt,
1234 static int __devinit w83627hf_probe(struct platform_device *pdev)
1236 struct device *dev = &pdev->dev;
1237 struct w83627hf_sio_data *sio_data = dev->platform_data;
1238 struct w83627hf_data *data;
1239 struct resource *res;
1242 static const char *names[] = {
1250 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1251 if (!request_region(res->start, WINB_REGION_SIZE, DRVNAME)) {
1252 dev_err(dev, "Failed to request region 0x%lx-0x%lx\n",
1253 (unsigned long)res->start,
1254 (unsigned long)(res->start + WINB_REGION_SIZE - 1));
1259 if (!(data = kzalloc(sizeof(struct w83627hf_data), GFP_KERNEL))) {
1263 data->addr = res->start;
1264 data->type = sio_data->type;
1265 data->name = names[sio_data->type];
1266 mutex_init(&data->lock);
1267 mutex_init(&data->update_lock);
1268 platform_set_drvdata(pdev, data);
1270 /* Initialize the chip */
1271 w83627hf_init_device(pdev);
1273 /* A few vars need to be filled upon startup */
1274 for (i = 0; i <= 2; i++)
1275 data->fan_min[i] = w83627hf_read_value(
1276 data, W83627HF_REG_FAN_MIN(i));
1277 w83627hf_update_fan_div(data);
1279 /* Register common device attributes */
1280 if ((err = sysfs_create_group(&dev->kobj, &w83627hf_group)))
1283 /* Register chip-specific device attributes */
1284 if (data->type == w83627hf || data->type == w83697hf)
1285 if ((err = device_create_file(dev,
1286 &sensor_dev_attr_in5_input.dev_attr))
1287 || (err = device_create_file(dev,
1288 &sensor_dev_attr_in5_min.dev_attr))
1289 || (err = device_create_file(dev,
1290 &sensor_dev_attr_in5_max.dev_attr))
1291 || (err = device_create_file(dev,
1292 &sensor_dev_attr_in5_alarm.dev_attr))
1293 || (err = device_create_file(dev,
1294 &sensor_dev_attr_in5_beep.dev_attr))
1295 || (err = device_create_file(dev,
1296 &sensor_dev_attr_in6_input.dev_attr))
1297 || (err = device_create_file(dev,
1298 &sensor_dev_attr_in6_min.dev_attr))
1299 || (err = device_create_file(dev,
1300 &sensor_dev_attr_in6_max.dev_attr))
1301 || (err = device_create_file(dev,
1302 &sensor_dev_attr_in6_alarm.dev_attr))
1303 || (err = device_create_file(dev,
1304 &sensor_dev_attr_in6_beep.dev_attr))
1305 || (err = device_create_file(dev,
1306 &sensor_dev_attr_pwm1_freq.dev_attr))
1307 || (err = device_create_file(dev,
1308 &sensor_dev_attr_pwm2_freq.dev_attr)))
1311 if (data->type != w83697hf)
1312 if ((err = device_create_file(dev,
1313 &sensor_dev_attr_in1_input.dev_attr))
1314 || (err = device_create_file(dev,
1315 &sensor_dev_attr_in1_min.dev_attr))
1316 || (err = device_create_file(dev,
1317 &sensor_dev_attr_in1_max.dev_attr))
1318 || (err = device_create_file(dev,
1319 &sensor_dev_attr_in1_alarm.dev_attr))
1320 || (err = device_create_file(dev,
1321 &sensor_dev_attr_in1_beep.dev_attr))
1322 || (err = device_create_file(dev,
1323 &sensor_dev_attr_fan3_input.dev_attr))
1324 || (err = device_create_file(dev,
1325 &sensor_dev_attr_fan3_min.dev_attr))
1326 || (err = device_create_file(dev,
1327 &sensor_dev_attr_fan3_div.dev_attr))
1328 || (err = device_create_file(dev,
1329 &sensor_dev_attr_fan3_alarm.dev_attr))
1330 || (err = device_create_file(dev,
1331 &sensor_dev_attr_fan3_beep.dev_attr))
1332 || (err = device_create_file(dev,
1333 &sensor_dev_attr_temp3_input.dev_attr))
1334 || (err = device_create_file(dev,
1335 &sensor_dev_attr_temp3_max.dev_attr))
1336 || (err = device_create_file(dev,
1337 &sensor_dev_attr_temp3_max_hyst.dev_attr))
1338 || (err = device_create_file(dev,
1339 &sensor_dev_attr_temp3_alarm.dev_attr))
1340 || (err = device_create_file(dev,
1341 &sensor_dev_attr_temp3_beep.dev_attr))
1342 || (err = device_create_file(dev,
1343 &sensor_dev_attr_temp3_type.dev_attr)))
1346 if (data->type != w83697hf && data->vid != 0xff) {
1347 /* Convert VID to voltage based on VRM */
1348 data->vrm = vid_which_vrm();
1350 if ((err = device_create_file(dev, &dev_attr_cpu0_vid))
1351 || (err = device_create_file(dev, &dev_attr_vrm)))
1355 if (data->type == w83627thf || data->type == w83637hf
1356 || data->type == w83687thf)
1357 if ((err = device_create_file(dev,
1358 &sensor_dev_attr_pwm3.dev_attr)))
1361 if (data->type == w83637hf || data->type == w83687thf)
1362 if ((err = device_create_file(dev,
1363 &sensor_dev_attr_pwm1_freq.dev_attr))
1364 || (err = device_create_file(dev,
1365 &sensor_dev_attr_pwm2_freq.dev_attr))
1366 || (err = device_create_file(dev,
1367 &sensor_dev_attr_pwm3_freq.dev_attr)))
1370 data->hwmon_dev = hwmon_device_register(dev);
1371 if (IS_ERR(data->hwmon_dev)) {
1372 err = PTR_ERR(data->hwmon_dev);
1379 sysfs_remove_group(&dev->kobj, &w83627hf_group);
1380 sysfs_remove_group(&dev->kobj, &w83627hf_group_opt);
1382 platform_set_drvdata(pdev, NULL);
1385 release_region(res->start, WINB_REGION_SIZE);
1390 static int __devexit w83627hf_remove(struct platform_device *pdev)
1392 struct w83627hf_data *data = platform_get_drvdata(pdev);
1393 struct resource *res;
1395 hwmon_device_unregister(data->hwmon_dev);
1397 sysfs_remove_group(&pdev->dev.kobj, &w83627hf_group);
1398 sysfs_remove_group(&pdev->dev.kobj, &w83627hf_group_opt);
1399 platform_set_drvdata(pdev, NULL);
1402 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1403 release_region(res->start, WINB_REGION_SIZE);
1409 /* Registers 0x50-0x5f are banked */
1410 static inline void w83627hf_set_bank(struct w83627hf_data *data, u16 reg)
1412 if ((reg & 0x00f0) == 0x50) {
1413 outb_p(W83781D_REG_BANK, data->addr + W83781D_ADDR_REG_OFFSET);
1414 outb_p(reg >> 8, data->addr + W83781D_DATA_REG_OFFSET);
1418 /* Not strictly necessary, but play it safe for now */
1419 static inline void w83627hf_reset_bank(struct w83627hf_data *data, u16 reg)
1422 outb_p(W83781D_REG_BANK, data->addr + W83781D_ADDR_REG_OFFSET);
1423 outb_p(0, data->addr + W83781D_DATA_REG_OFFSET);
1427 static int w83627hf_read_value(struct w83627hf_data *data, u16 reg)
1429 int res, word_sized;
1431 mutex_lock(&data->lock);
1432 word_sized = (((reg & 0xff00) == 0x100)
1433 || ((reg & 0xff00) == 0x200))
1434 && (((reg & 0x00ff) == 0x50)
1435 || ((reg & 0x00ff) == 0x53)
1436 || ((reg & 0x00ff) == 0x55));
1437 w83627hf_set_bank(data, reg);
1438 outb_p(reg & 0xff, data->addr + W83781D_ADDR_REG_OFFSET);
1439 res = inb_p(data->addr + W83781D_DATA_REG_OFFSET);
1441 outb_p((reg & 0xff) + 1,
1442 data->addr + W83781D_ADDR_REG_OFFSET);
1444 (res << 8) + inb_p(data->addr +
1445 W83781D_DATA_REG_OFFSET);
1447 w83627hf_reset_bank(data, reg);
1448 mutex_unlock(&data->lock);
1452 static int __devinit w83627thf_read_gpio5(struct platform_device *pdev)
1454 int res = 0xff, sel;
1457 superio_select(W83627HF_LD_GPIO5);
1459 /* Make sure these GPIO pins are enabled */
1460 if (!(superio_inb(W83627THF_GPIO5_EN) & (1<<3))) {
1461 dev_dbg(&pdev->dev, "GPIO5 disabled, no VID function\n");
1465 /* Make sure the pins are configured for input
1466 There must be at least five (VRM 9), and possibly 6 (VRM 10) */
1467 sel = superio_inb(W83627THF_GPIO5_IOSR) & 0x3f;
1468 if ((sel & 0x1f) != 0x1f) {
1469 dev_dbg(&pdev->dev, "GPIO5 not configured for VID "
1474 dev_info(&pdev->dev, "Reading VID from GPIO5\n");
1475 res = superio_inb(W83627THF_GPIO5_DR) & sel;
1482 static int __devinit w83687thf_read_vid(struct platform_device *pdev)
1487 superio_select(W83627HF_LD_HWM);
1489 /* Make sure these GPIO pins are enabled */
1490 if (!(superio_inb(W83687THF_VID_EN) & (1 << 2))) {
1491 dev_dbg(&pdev->dev, "VID disabled, no VID function\n");
1495 /* Make sure the pins are configured for input */
1496 if (!(superio_inb(W83687THF_VID_CFG) & (1 << 4))) {
1497 dev_dbg(&pdev->dev, "VID configured as output, "
1498 "no VID function\n");
1502 res = superio_inb(W83687THF_VID_DATA) & 0x3f;
1509 static int w83627hf_write_value(struct w83627hf_data *data, u16 reg, u16 value)
1513 mutex_lock(&data->lock);
1514 word_sized = (((reg & 0xff00) == 0x100)
1515 || ((reg & 0xff00) == 0x200))
1516 && (((reg & 0x00ff) == 0x53)
1517 || ((reg & 0x00ff) == 0x55));
1518 w83627hf_set_bank(data, reg);
1519 outb_p(reg & 0xff, data->addr + W83781D_ADDR_REG_OFFSET);
1522 data->addr + W83781D_DATA_REG_OFFSET);
1523 outb_p((reg & 0xff) + 1,
1524 data->addr + W83781D_ADDR_REG_OFFSET);
1526 outb_p(value & 0xff,
1527 data->addr + W83781D_DATA_REG_OFFSET);
1528 w83627hf_reset_bank(data, reg);
1529 mutex_unlock(&data->lock);
1533 static void __devinit w83627hf_init_device(struct platform_device *pdev)
1535 struct w83627hf_data *data = platform_get_drvdata(pdev);
1537 enum chips type = data->type;
1541 /* Resetting the chip has been the default for a long time,
1542 but repeatedly caused problems (fans going to full
1543 speed...) so it is now optional. It might even go away if
1544 nobody reports it as being useful, as I see very little
1545 reason why this would be needed at all. */
1546 dev_info(&pdev->dev, "If reset=1 solved a problem you were "
1547 "having, please report!\n");
1549 /* save this register */
1550 i = w83627hf_read_value(data, W83781D_REG_BEEP_CONFIG);
1551 /* Reset all except Watchdog values and last conversion values
1552 This sets fan-divs to 2, among others */
1553 w83627hf_write_value(data, W83781D_REG_CONFIG, 0x80);
1554 /* Restore the register and disable power-on abnormal beep.
1555 This saves FAN 1/2/3 input/output values set by BIOS. */
1556 w83627hf_write_value(data, W83781D_REG_BEEP_CONFIG, i | 0x80);
1557 /* Disable master beep-enable (reset turns it on).
1558 Individual beeps should be reset to off but for some reason
1559 disabling this bit helps some people not get beeped */
1560 w83627hf_write_value(data, W83781D_REG_BEEP_INTS2, 0);
1563 /* Minimize conflicts with other winbond i2c-only clients... */
1564 /* disable i2c subclients... how to disable main i2c client?? */
1565 /* force i2c address to relatively uncommon address */
1566 w83627hf_write_value(data, W83781D_REG_I2C_SUBADDR, 0x89);
1567 w83627hf_write_value(data, W83781D_REG_I2C_ADDR, force_i2c);
1569 /* Read VID only once */
1570 if (type == w83627hf || type == w83637hf) {
1571 int lo = w83627hf_read_value(data, W83781D_REG_VID_FANDIV);
1572 int hi = w83627hf_read_value(data, W83781D_REG_CHIPID);
1573 data->vid = (lo & 0x0f) | ((hi & 0x01) << 4);
1574 } else if (type == w83627thf) {
1575 data->vid = w83627thf_read_gpio5(pdev);
1576 } else if (type == w83687thf) {
1577 data->vid = w83687thf_read_vid(pdev);
1580 /* Read VRM & OVT Config only once */
1581 if (type == w83627thf || type == w83637hf || type == w83687thf) {
1583 w83627hf_read_value(data, W83627THF_REG_VRM_OVT_CFG);
1586 tmp = w83627hf_read_value(data, W83781D_REG_SCFG1);
1587 for (i = 1; i <= 3; i++) {
1588 if (!(tmp & BIT_SCFG1[i - 1])) {
1589 data->sens[i - 1] = 4;
1591 if (w83627hf_read_value
1593 W83781D_REG_SCFG2) & BIT_SCFG2[i - 1])
1594 data->sens[i - 1] = 1;
1596 data->sens[i - 1] = 2;
1598 if ((type == w83697hf) && (i == 2))
1604 tmp = w83627hf_read_value(data, W83627HF_REG_TEMP2_CONFIG);
1606 dev_warn(&pdev->dev, "Enabling temp2, readings "
1607 "might not make sense\n");
1608 w83627hf_write_value(data, W83627HF_REG_TEMP2_CONFIG,
1613 if (type != w83697hf) {
1614 tmp = w83627hf_read_value(data,
1615 W83627HF_REG_TEMP3_CONFIG);
1617 dev_warn(&pdev->dev, "Enabling temp3, "
1618 "readings might not make sense\n");
1619 w83627hf_write_value(data,
1620 W83627HF_REG_TEMP3_CONFIG, tmp & 0xfe);
1625 /* Start monitoring */
1626 w83627hf_write_value(data, W83781D_REG_CONFIG,
1627 (w83627hf_read_value(data,
1628 W83781D_REG_CONFIG) & 0xf7)
1631 /* Enable VBAT monitoring if needed */
1632 tmp = w83627hf_read_value(data, W83781D_REG_VBAT);
1634 w83627hf_write_value(data, W83781D_REG_VBAT, tmp | 0x01);
1637 static void w83627hf_update_fan_div(struct w83627hf_data *data)
1641 reg = w83627hf_read_value(data, W83781D_REG_VID_FANDIV);
1642 data->fan_div[0] = (reg >> 4) & 0x03;
1643 data->fan_div[1] = (reg >> 6) & 0x03;
1644 if (data->type != w83697hf) {
1645 data->fan_div[2] = (w83627hf_read_value(data,
1646 W83781D_REG_PIN) >> 6) & 0x03;
1648 reg = w83627hf_read_value(data, W83781D_REG_VBAT);
1649 data->fan_div[0] |= (reg >> 3) & 0x04;
1650 data->fan_div[1] |= (reg >> 4) & 0x04;
1651 if (data->type != w83697hf)
1652 data->fan_div[2] |= (reg >> 5) & 0x04;
1655 static struct w83627hf_data *w83627hf_update_device(struct device *dev)
1657 struct w83627hf_data *data = dev_get_drvdata(dev);
1658 int i, num_temps = (data->type == w83697hf) ? 2 : 3;
1660 mutex_lock(&data->update_lock);
1662 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1664 for (i = 0; i <= 8; i++) {
1665 /* skip missing sensors */
1666 if (((data->type == w83697hf) && (i == 1)) ||
1667 ((data->type != w83627hf && data->type != w83697hf)
1668 && (i == 5 || i == 6)))
1671 w83627hf_read_value(data, W83781D_REG_IN(i));
1673 w83627hf_read_value(data,
1674 W83781D_REG_IN_MIN(i));
1676 w83627hf_read_value(data,
1677 W83781D_REG_IN_MAX(i));
1679 for (i = 0; i <= 2; i++) {
1681 w83627hf_read_value(data, W83627HF_REG_FAN(i));
1683 w83627hf_read_value(data,
1684 W83627HF_REG_FAN_MIN(i));
1686 for (i = 0; i <= 2; i++) {
1687 u8 tmp = w83627hf_read_value(data,
1688 W836X7HF_REG_PWM(data->type, i));
1689 /* bits 0-3 are reserved in 627THF */
1690 if (data->type == w83627thf)
1694 (data->type == w83627hf || data->type == w83697hf))
1697 if (data->type == w83627hf) {
1698 u8 tmp = w83627hf_read_value(data,
1699 W83627HF_REG_PWM_FREQ);
1700 data->pwm_freq[0] = tmp & 0x07;
1701 data->pwm_freq[1] = (tmp >> 4) & 0x07;
1702 } else if (data->type != w83627thf) {
1703 for (i = 1; i <= 3; i++) {
1704 data->pwm_freq[i - 1] =
1705 w83627hf_read_value(data,
1706 W83637HF_REG_PWM_FREQ[i - 1]);
1707 if (i == 2 && (data->type == w83697hf))
1711 for (i = 0; i < num_temps; i++) {
1712 data->temp[i] = w83627hf_read_value(
1713 data, w83627hf_reg_temp[i]);
1714 data->temp_max[i] = w83627hf_read_value(
1715 data, w83627hf_reg_temp_over[i]);
1716 data->temp_max_hyst[i] = w83627hf_read_value(
1717 data, w83627hf_reg_temp_hyst[i]);
1720 w83627hf_update_fan_div(data);
1723 w83627hf_read_value(data, W83781D_REG_ALARM1) |
1724 (w83627hf_read_value(data, W83781D_REG_ALARM2) << 8) |
1725 (w83627hf_read_value(data, W83781D_REG_ALARM3) << 16);
1726 i = w83627hf_read_value(data, W83781D_REG_BEEP_INTS2);
1727 data->beep_mask = (i << 8) |
1728 w83627hf_read_value(data, W83781D_REG_BEEP_INTS1) |
1729 w83627hf_read_value(data, W83781D_REG_BEEP_INTS3) << 16;
1730 data->last_updated = jiffies;
1734 mutex_unlock(&data->update_lock);
1739 static int __init w83627hf_device_add(unsigned short address,
1740 const struct w83627hf_sio_data *sio_data)
1742 struct resource res = {
1743 .start = address + WINB_REGION_OFFSET,
1744 .end = address + WINB_REGION_OFFSET + WINB_REGION_SIZE - 1,
1746 .flags = IORESOURCE_IO,
1750 err = acpi_check_resource_conflict(&res);
1754 pdev = platform_device_alloc(DRVNAME, address);
1757 printk(KERN_ERR DRVNAME ": Device allocation failed\n");
1761 err = platform_device_add_resources(pdev, &res, 1);
1763 printk(KERN_ERR DRVNAME ": Device resource addition failed "
1765 goto exit_device_put;
1768 err = platform_device_add_data(pdev, sio_data,
1769 sizeof(struct w83627hf_sio_data));
1771 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
1772 goto exit_device_put;
1775 err = platform_device_add(pdev);
1777 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
1779 goto exit_device_put;
1785 platform_device_put(pdev);
1790 static int __init sensors_w83627hf_init(void)
1793 unsigned short address;
1794 struct w83627hf_sio_data sio_data;
1796 if (w83627hf_find(0x2e, &address, &sio_data)
1797 && w83627hf_find(0x4e, &address, &sio_data))
1800 err = platform_driver_register(&w83627hf_driver);
1804 /* Sets global pdev as a side effect */
1805 err = w83627hf_device_add(address, &sio_data);
1812 platform_driver_unregister(&w83627hf_driver);
1817 static void __exit sensors_w83627hf_exit(void)
1819 platform_device_unregister(pdev);
1820 platform_driver_unregister(&w83627hf_driver);
1823 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
1824 "Philip Edelbrock <phil@netroedge.com>, "
1825 "and Mark Studebaker <mdsxyz123@yahoo.com>");
1826 MODULE_DESCRIPTION("W83627HF driver");
1827 MODULE_LICENSE("GPL");
1829 module_init(sensors_w83627hf_init);
1830 module_exit(sensors_w83627hf_exit);