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>
56 static struct platform_device *pdev;
58 #define DRVNAME "w83627hf"
59 enum chips { w83627hf, w83627thf, w83697hf, w83637hf, w83687thf };
61 static u16 force_addr;
62 module_param(force_addr, ushort, 0);
63 MODULE_PARM_DESC(force_addr,
64 "Initialize the base address of the sensors");
65 static u8 force_i2c = 0x1f;
66 module_param(force_i2c, byte, 0);
67 MODULE_PARM_DESC(force_i2c,
68 "Initialize the i2c address of the sensors");
71 module_param(reset, bool, 0);
72 MODULE_PARM_DESC(reset, "Set to one to reset chip on load");
75 module_param(init, bool, 0);
76 MODULE_PARM_DESC(init, "Set to zero to bypass chip initialization");
78 /* modified from kernel/include/traps.c */
79 static int REG; /* The register to read/write */
80 #define DEV 0x07 /* Register: Logical device select */
81 static int VAL; /* The value to read/write */
83 /* logical device numbers for superio_select (below) */
84 #define W83627HF_LD_FDC 0x00
85 #define W83627HF_LD_PRT 0x01
86 #define W83627HF_LD_UART1 0x02
87 #define W83627HF_LD_UART2 0x03
88 #define W83627HF_LD_KBC 0x05
89 #define W83627HF_LD_CIR 0x06 /* w83627hf only */
90 #define W83627HF_LD_GAME 0x07
91 #define W83627HF_LD_MIDI 0x07
92 #define W83627HF_LD_GPIO1 0x07
93 #define W83627HF_LD_GPIO5 0x07 /* w83627thf only */
94 #define W83627HF_LD_GPIO2 0x08
95 #define W83627HF_LD_GPIO3 0x09
96 #define W83627HF_LD_GPIO4 0x09 /* w83627thf only */
97 #define W83627HF_LD_ACPI 0x0a
98 #define W83627HF_LD_HWM 0x0b
100 #define DEVID 0x20 /* Register: Device ID */
102 #define W83627THF_GPIO5_EN 0x30 /* w83627thf only */
103 #define W83627THF_GPIO5_IOSR 0xf3 /* w83627thf only */
104 #define W83627THF_GPIO5_DR 0xf4 /* w83627thf only */
106 #define W83687THF_VID_EN 0x29 /* w83687thf only */
107 #define W83687THF_VID_CFG 0xF0 /* w83687thf only */
108 #define W83687THF_VID_DATA 0xF1 /* w83687thf only */
111 superio_outb(int reg, int val)
125 superio_select(int ld)
144 #define W627_DEVID 0x52
145 #define W627THF_DEVID 0x82
146 #define W697_DEVID 0x60
147 #define W637_DEVID 0x70
148 #define W687THF_DEVID 0x85
149 #define WINB_ACT_REG 0x30
150 #define WINB_BASE_REG 0x60
151 /* Constants specified below */
153 /* Alignment of the base address */
154 #define WINB_ALIGNMENT ~7
156 /* Offset & size of I/O region we are interested in */
157 #define WINB_REGION_OFFSET 5
158 #define WINB_REGION_SIZE 2
160 /* Where are the sensors address/data registers relative to the region offset */
161 #define W83781D_ADDR_REG_OFFSET 0
162 #define W83781D_DATA_REG_OFFSET 1
164 /* The W83781D registers */
165 /* The W83782D registers for nr=7,8 are in bank 5 */
166 #define W83781D_REG_IN_MAX(nr) ((nr < 7) ? (0x2b + (nr) * 2) : \
167 (0x554 + (((nr) - 7) * 2)))
168 #define W83781D_REG_IN_MIN(nr) ((nr < 7) ? (0x2c + (nr) * 2) : \
169 (0x555 + (((nr) - 7) * 2)))
170 #define W83781D_REG_IN(nr) ((nr < 7) ? (0x20 + (nr)) : \
173 #define W83781D_REG_FAN_MIN(nr) (0x3a + (nr))
174 #define W83781D_REG_FAN(nr) (0x27 + (nr))
176 #define W83627HF_REG_TEMP2_CONFIG 0x152
177 #define W83627HF_REG_TEMP3_CONFIG 0x252
178 /* these are zero-based, unlike config constants above */
179 static const u16 w83627hf_reg_temp[] = { 0x27, 0x150, 0x250 };
180 static const u16 w83627hf_reg_temp_hyst[] = { 0x3A, 0x153, 0x253 };
181 static const u16 w83627hf_reg_temp_over[] = { 0x39, 0x155, 0x255 };
183 #define W83781D_REG_BANK 0x4E
185 #define W83781D_REG_CONFIG 0x40
186 #define W83781D_REG_ALARM1 0x459
187 #define W83781D_REG_ALARM2 0x45A
188 #define W83781D_REG_ALARM3 0x45B
190 #define W83781D_REG_BEEP_CONFIG 0x4D
191 #define W83781D_REG_BEEP_INTS1 0x56
192 #define W83781D_REG_BEEP_INTS2 0x57
193 #define W83781D_REG_BEEP_INTS3 0x453
195 #define W83781D_REG_VID_FANDIV 0x47
197 #define W83781D_REG_CHIPID 0x49
198 #define W83781D_REG_WCHIPID 0x58
199 #define W83781D_REG_CHIPMAN 0x4F
200 #define W83781D_REG_PIN 0x4B
202 #define W83781D_REG_VBAT 0x5D
204 #define W83627HF_REG_PWM1 0x5A
205 #define W83627HF_REG_PWM2 0x5B
207 #define W83627THF_REG_PWM1 0x01 /* 697HF/637HF/687THF too */
208 #define W83627THF_REG_PWM2 0x03 /* 697HF/637HF/687THF too */
209 #define W83627THF_REG_PWM3 0x11 /* 637HF/687THF too */
211 #define W83627THF_REG_VRM_OVT_CFG 0x18 /* 637HF/687THF too */
213 static const u8 regpwm_627hf[] = { W83627HF_REG_PWM1, W83627HF_REG_PWM2 };
214 static const u8 regpwm[] = { W83627THF_REG_PWM1, W83627THF_REG_PWM2,
215 W83627THF_REG_PWM3 };
216 #define W836X7HF_REG_PWM(type, nr) (((type) == w83627hf) ? \
217 regpwm_627hf[nr] : regpwm[nr])
219 #define W83627HF_REG_PWM_FREQ 0x5C /* Only for the 627HF */
221 #define W83637HF_REG_PWM_FREQ1 0x00 /* 697HF/687THF too */
222 #define W83637HF_REG_PWM_FREQ2 0x02 /* 697HF/687THF too */
223 #define W83637HF_REG_PWM_FREQ3 0x10 /* 687THF too */
225 static const u8 W83637HF_REG_PWM_FREQ[] = { W83637HF_REG_PWM_FREQ1,
226 W83637HF_REG_PWM_FREQ2,
227 W83637HF_REG_PWM_FREQ3 };
229 #define W83627HF_BASE_PWM_FREQ 46870
231 #define W83781D_REG_I2C_ADDR 0x48
232 #define W83781D_REG_I2C_SUBADDR 0x4A
234 /* Sensor selection */
235 #define W83781D_REG_SCFG1 0x5D
236 static const u8 BIT_SCFG1[] = { 0x02, 0x04, 0x08 };
237 #define W83781D_REG_SCFG2 0x59
238 static const u8 BIT_SCFG2[] = { 0x10, 0x20, 0x40 };
239 #define W83781D_DEFAULT_BETA 3435
241 /* Conversions. Limit checking is only done on the TO_REG
242 variants. Note that you should be a bit careful with which arguments
243 these macros are called: arguments may be evaluated more than once.
244 Fixing this is just not worth it. */
245 #define IN_TO_REG(val) (SENSORS_LIMIT((((val) + 8)/16),0,255))
246 #define IN_FROM_REG(val) ((val) * 16)
248 static inline u8 FAN_TO_REG(long rpm, int div)
252 rpm = SENSORS_LIMIT(rpm, 1, 1000000);
253 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
257 #define TEMP_MIN (-128000)
258 #define TEMP_MAX ( 127000)
260 /* TEMP: 0.001C/bit (-128C to +127C)
261 REG: 1C/bit, two's complement */
262 static u8 TEMP_TO_REG(long temp)
264 int ntemp = SENSORS_LIMIT(temp, TEMP_MIN, TEMP_MAX);
265 ntemp += (ntemp<0 ? -500 : 500);
266 return (u8)(ntemp / 1000);
269 static int TEMP_FROM_REG(u8 reg)
271 return (s8)reg * 1000;
274 #define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
276 #define PWM_TO_REG(val) (SENSORS_LIMIT((val),0,255))
278 static inline unsigned long pwm_freq_from_reg_627hf(u8 reg)
281 freq = W83627HF_BASE_PWM_FREQ >> reg;
284 static inline u8 pwm_freq_to_reg_627hf(unsigned long val)
287 /* Only 5 dividers (1 2 4 8 16)
288 Search for the nearest available frequency */
289 for (i = 0; i < 4; i++) {
290 if (val > (((W83627HF_BASE_PWM_FREQ >> i) +
291 (W83627HF_BASE_PWM_FREQ >> (i+1))) / 2))
297 static inline unsigned long pwm_freq_from_reg(u8 reg)
299 /* Clock bit 8 -> 180 kHz or 24 MHz */
300 unsigned long clock = (reg & 0x80) ? 180000UL : 24000000UL;
303 /* This should not happen but anyway... */
306 return (clock / (reg << 8));
308 static inline u8 pwm_freq_to_reg(unsigned long val)
310 /* Minimum divider value is 0x01 and maximum is 0x7F */
311 if (val >= 93750) /* The highest we can do */
313 if (val >= 720) /* Use 24 MHz clock */
314 return (24000000UL / (val << 8));
315 if (val < 6) /* The lowest we can do */
317 else /* Use 180 kHz clock */
318 return (0x80 | (180000UL / (val << 8)));
321 #define BEEP_MASK_FROM_REG(val) (val)
322 #define BEEP_MASK_TO_REG(val) ((val) & 0xffffff)
323 #define BEEP_ENABLE_TO_REG(val) ((val)?1:0)
324 #define BEEP_ENABLE_FROM_REG(val) ((val)?1:0)
326 #define DIV_FROM_REG(val) (1 << (val))
328 static inline u8 DIV_TO_REG(long val)
331 val = SENSORS_LIMIT(val, 1, 128) >> 1;
332 for (i = 0; i < 7; i++) {
340 /* For each registered chip, we need to keep some data in memory.
341 The structure is dynamically allocated. */
342 struct w83627hf_data {
345 struct device *hwmon_dev;
349 struct mutex update_lock;
350 char valid; /* !=0 if following fields are valid */
351 unsigned long last_updated; /* In jiffies */
353 u8 in[9]; /* Register value */
354 u8 in_max[9]; /* Register value */
355 u8 in_min[9]; /* Register value */
356 u8 fan[3]; /* Register value */
357 u8 fan_min[3]; /* Register value */
358 u16 temp[3]; /* Register value */
359 u16 temp_max[3]; /* Register value */
360 u16 temp_max_hyst[3]; /* Register value */
361 u8 fan_div[3]; /* Register encoding, shifted right */
362 u8 vid; /* Register encoding, combined */
363 u32 alarms; /* Register encoding, combined */
364 u32 beep_mask; /* Register encoding, combined */
365 u8 beep_enable; /* Boolean */
366 u8 pwm[3]; /* Register value */
367 u8 pwm_freq[3]; /* Register value */
368 u16 sens[3]; /* 1 = pentium diode; 2 = 3904 diode;
371 u8 vrm_ovt; /* Register value, 627THF/637HF/687THF only */
374 struct w83627hf_sio_data {
379 static int w83627hf_probe(struct platform_device *pdev);
380 static int __devexit w83627hf_remove(struct platform_device *pdev);
382 static int w83627hf_read_value(struct w83627hf_data *data, u16 reg);
383 static int w83627hf_write_value(struct w83627hf_data *data, u16 reg, u16 value);
384 static void w83627hf_update_fan_div(struct w83627hf_data *data);
385 static struct w83627hf_data *w83627hf_update_device(struct device *dev);
386 static void w83627hf_init_device(struct platform_device *pdev);
388 static struct platform_driver w83627hf_driver = {
390 .owner = THIS_MODULE,
393 .probe = w83627hf_probe,
394 .remove = __devexit_p(w83627hf_remove),
398 show_in_input(struct device *dev, struct device_attribute *devattr, char *buf)
400 int nr = to_sensor_dev_attr(devattr)->index;
401 struct w83627hf_data *data = w83627hf_update_device(dev);
402 return sprintf(buf, "%ld\n", (long)IN_FROM_REG(data->in[nr]));
405 show_in_min(struct device *dev, struct device_attribute *devattr, char *buf)
407 int nr = to_sensor_dev_attr(devattr)->index;
408 struct w83627hf_data *data = w83627hf_update_device(dev);
409 return sprintf(buf, "%ld\n", (long)IN_FROM_REG(data->in_min[nr]));
412 show_in_max(struct device *dev, struct device_attribute *devattr, char *buf)
414 int nr = to_sensor_dev_attr(devattr)->index;
415 struct w83627hf_data *data = w83627hf_update_device(dev);
416 return sprintf(buf, "%ld\n", (long)IN_FROM_REG(data->in_max[nr]));
419 store_in_min(struct device *dev, struct device_attribute *devattr,
420 const char *buf, size_t count)
422 int nr = to_sensor_dev_attr(devattr)->index;
423 struct w83627hf_data *data = dev_get_drvdata(dev);
424 long val = simple_strtol(buf, NULL, 10);
426 mutex_lock(&data->update_lock);
427 data->in_min[nr] = IN_TO_REG(val);
428 w83627hf_write_value(data, W83781D_REG_IN_MIN(nr), data->in_min[nr]);
429 mutex_unlock(&data->update_lock);
433 store_in_max(struct device *dev, struct device_attribute *devattr,
434 const char *buf, size_t count)
436 int nr = to_sensor_dev_attr(devattr)->index;
437 struct w83627hf_data *data = dev_get_drvdata(dev);
438 long val = simple_strtol(buf, NULL, 10);
440 mutex_lock(&data->update_lock);
441 data->in_max[nr] = IN_TO_REG(val);
442 w83627hf_write_value(data, W83781D_REG_IN_MAX(nr), data->in_max[nr]);
443 mutex_unlock(&data->update_lock);
446 #define sysfs_vin_decl(offset) \
447 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
448 show_in_input, NULL, offset); \
449 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO|S_IWUSR, \
450 show_in_min, store_in_min, offset); \
451 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO|S_IWUSR, \
452 show_in_max, store_in_max, offset);
463 /* use a different set of functions for in0 */
464 static ssize_t show_in_0(struct w83627hf_data *data, char *buf, u8 reg)
468 if ((data->vrm_ovt & 0x01) &&
469 (w83627thf == data->type || w83637hf == data->type
470 || w83687thf == data->type))
472 /* use VRM9 calculation */
473 in0 = (long)((reg * 488 + 70000 + 50) / 100);
475 /* use VRM8 (standard) calculation */
476 in0 = (long)IN_FROM_REG(reg);
478 return sprintf(buf,"%ld\n", in0);
481 static ssize_t show_regs_in_0(struct device *dev, struct device_attribute *attr, char *buf)
483 struct w83627hf_data *data = w83627hf_update_device(dev);
484 return show_in_0(data, buf, data->in[0]);
487 static ssize_t show_regs_in_min0(struct device *dev, struct device_attribute *attr, char *buf)
489 struct w83627hf_data *data = w83627hf_update_device(dev);
490 return show_in_0(data, buf, data->in_min[0]);
493 static ssize_t show_regs_in_max0(struct device *dev, struct device_attribute *attr, char *buf)
495 struct w83627hf_data *data = w83627hf_update_device(dev);
496 return show_in_0(data, buf, data->in_max[0]);
499 static ssize_t store_regs_in_min0(struct device *dev, struct device_attribute *attr,
500 const char *buf, size_t count)
502 struct w83627hf_data *data = dev_get_drvdata(dev);
505 val = simple_strtoul(buf, NULL, 10);
507 mutex_lock(&data->update_lock);
509 if ((data->vrm_ovt & 0x01) &&
510 (w83627thf == data->type || w83637hf == data->type
511 || w83687thf == data->type))
513 /* use VRM9 calculation */
515 SENSORS_LIMIT(((val * 100) - 70000 + 244) / 488, 0,
518 /* use VRM8 (standard) calculation */
519 data->in_min[0] = IN_TO_REG(val);
521 w83627hf_write_value(data, W83781D_REG_IN_MIN(0), data->in_min[0]);
522 mutex_unlock(&data->update_lock);
526 static ssize_t store_regs_in_max0(struct device *dev, struct device_attribute *attr,
527 const char *buf, size_t count)
529 struct w83627hf_data *data = dev_get_drvdata(dev);
532 val = simple_strtoul(buf, NULL, 10);
534 mutex_lock(&data->update_lock);
536 if ((data->vrm_ovt & 0x01) &&
537 (w83627thf == data->type || w83637hf == data->type
538 || w83687thf == data->type))
540 /* use VRM9 calculation */
542 SENSORS_LIMIT(((val * 100) - 70000 + 244) / 488, 0,
545 /* use VRM8 (standard) calculation */
546 data->in_max[0] = IN_TO_REG(val);
548 w83627hf_write_value(data, W83781D_REG_IN_MAX(0), data->in_max[0]);
549 mutex_unlock(&data->update_lock);
553 static DEVICE_ATTR(in0_input, S_IRUGO, show_regs_in_0, NULL);
554 static DEVICE_ATTR(in0_min, S_IRUGO | S_IWUSR,
555 show_regs_in_min0, store_regs_in_min0);
556 static DEVICE_ATTR(in0_max, S_IRUGO | S_IWUSR,
557 show_regs_in_max0, store_regs_in_max0);
560 show_fan_input(struct device *dev, struct device_attribute *devattr, char *buf)
562 int nr = to_sensor_dev_attr(devattr)->index;
563 struct w83627hf_data *data = w83627hf_update_device(dev);
564 return sprintf(buf, "%ld\n", FAN_FROM_REG(data->fan[nr],
565 (long)DIV_FROM_REG(data->fan_div[nr])));
568 show_fan_min(struct device *dev, struct device_attribute *devattr, char *buf)
570 int nr = to_sensor_dev_attr(devattr)->index;
571 struct w83627hf_data *data = w83627hf_update_device(dev);
572 return sprintf(buf, "%ld\n", FAN_FROM_REG(data->fan_min[nr],
573 (long)DIV_FROM_REG(data->fan_div[nr])));
576 store_fan_min(struct device *dev, struct device_attribute *devattr,
577 const char *buf, size_t count)
579 int nr = to_sensor_dev_attr(devattr)->index;
580 struct w83627hf_data *data = dev_get_drvdata(dev);
581 u32 val = simple_strtoul(buf, NULL, 10);
583 mutex_lock(&data->update_lock);
584 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
585 w83627hf_write_value(data, W83781D_REG_FAN_MIN(nr+1),
588 mutex_unlock(&data->update_lock);
591 #define sysfs_fan_decl(offset) \
592 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
593 show_fan_input, NULL, offset - 1); \
594 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
595 show_fan_min, store_fan_min, offset - 1);
602 show_temp(struct device *dev, struct device_attribute *devattr, char *buf)
604 int nr = to_sensor_dev_attr(devattr)->index;
605 struct w83627hf_data *data = w83627hf_update_device(dev);
607 u16 tmp = data->temp[nr];
608 return sprintf(buf, "%ld\n", (nr) ? (long) LM75_TEMP_FROM_REG(tmp)
609 : (long) TEMP_FROM_REG(tmp));
613 show_temp_max(struct device *dev, struct device_attribute *devattr,
616 int nr = to_sensor_dev_attr(devattr)->index;
617 struct w83627hf_data *data = w83627hf_update_device(dev);
619 u16 tmp = data->temp_max[nr];
620 return sprintf(buf, "%ld\n", (nr) ? (long) LM75_TEMP_FROM_REG(tmp)
621 : (long) TEMP_FROM_REG(tmp));
625 show_temp_max_hyst(struct device *dev, struct device_attribute *devattr,
628 int nr = to_sensor_dev_attr(devattr)->index;
629 struct w83627hf_data *data = w83627hf_update_device(dev);
631 u16 tmp = data->temp_max_hyst[nr];
632 return sprintf(buf, "%ld\n", (nr) ? (long) LM75_TEMP_FROM_REG(tmp)
633 : (long) TEMP_FROM_REG(tmp));
637 store_temp_max(struct device *dev, struct device_attribute *devattr,
638 const char *buf, size_t count)
640 int nr = to_sensor_dev_attr(devattr)->index;
641 struct w83627hf_data *data = dev_get_drvdata(dev);
642 long val = simple_strtol(buf, NULL, 10);
643 u16 tmp = (nr) ? LM75_TEMP_TO_REG(val) : TEMP_TO_REG(val);
645 mutex_lock(&data->update_lock);
646 data->temp_max[nr] = tmp;
647 w83627hf_write_value(data, w83627hf_reg_temp_over[nr], tmp);
648 mutex_unlock(&data->update_lock);
653 store_temp_max_hyst(struct device *dev, struct device_attribute *devattr,
654 const char *buf, size_t count)
656 int nr = to_sensor_dev_attr(devattr)->index;
657 struct w83627hf_data *data = dev_get_drvdata(dev);
658 long val = simple_strtol(buf, NULL, 10);
659 u16 tmp = (nr) ? LM75_TEMP_TO_REG(val) : TEMP_TO_REG(val);
661 mutex_lock(&data->update_lock);
662 data->temp_max_hyst[nr] = tmp;
663 w83627hf_write_value(data, w83627hf_reg_temp_hyst[nr], tmp);
664 mutex_unlock(&data->update_lock);
668 #define sysfs_temp_decl(offset) \
669 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
670 show_temp, NULL, offset - 1); \
671 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO|S_IWUSR, \
672 show_temp_max, store_temp_max, offset - 1); \
673 static SENSOR_DEVICE_ATTR(temp##offset##_max_hyst, S_IRUGO|S_IWUSR, \
674 show_temp_max_hyst, store_temp_max_hyst, offset - 1);
681 show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
683 struct w83627hf_data *data = w83627hf_update_device(dev);
684 return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm));
686 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
689 show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
691 struct w83627hf_data *data = dev_get_drvdata(dev);
692 return sprintf(buf, "%ld\n", (long) data->vrm);
695 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
697 struct w83627hf_data *data = dev_get_drvdata(dev);
700 val = simple_strtoul(buf, NULL, 10);
705 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
708 show_alarms_reg(struct device *dev, struct device_attribute *attr, char *buf)
710 struct w83627hf_data *data = w83627hf_update_device(dev);
711 return sprintf(buf, "%ld\n", (long) data->alarms);
713 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
715 #define show_beep_reg(REG, reg) \
716 static ssize_t show_beep_##reg (struct device *dev, struct device_attribute *attr, char *buf) \
718 struct w83627hf_data *data = w83627hf_update_device(dev); \
719 return sprintf(buf,"%ld\n", \
720 (long)BEEP_##REG##_FROM_REG(data->beep_##reg)); \
722 show_beep_reg(ENABLE, enable)
723 show_beep_reg(MASK, mask)
725 #define BEEP_ENABLE 0 /* Store beep_enable */
726 #define BEEP_MASK 1 /* Store beep_mask */
729 store_beep_reg(struct device *dev, const char *buf, size_t count,
732 struct w83627hf_data *data = dev_get_drvdata(dev);
735 val = simple_strtoul(buf, NULL, 10);
737 mutex_lock(&data->update_lock);
739 if (update_mask == BEEP_MASK) { /* We are storing beep_mask */
740 data->beep_mask = BEEP_MASK_TO_REG(val);
741 w83627hf_write_value(data, W83781D_REG_BEEP_INTS1,
742 data->beep_mask & 0xff);
743 w83627hf_write_value(data, W83781D_REG_BEEP_INTS3,
744 ((data->beep_mask) >> 16) & 0xff);
745 val2 = (data->beep_mask >> 8) & 0x7f;
746 } else { /* We are storing beep_enable */
748 w83627hf_read_value(data, W83781D_REG_BEEP_INTS2) & 0x7f;
749 data->beep_enable = BEEP_ENABLE_TO_REG(val);
752 w83627hf_write_value(data, W83781D_REG_BEEP_INTS2,
753 val2 | data->beep_enable << 7);
755 mutex_unlock(&data->update_lock);
759 #define sysfs_beep(REG, reg) \
760 static ssize_t show_regs_beep_##reg (struct device *dev, struct device_attribute *attr, char *buf) \
762 return show_beep_##reg(dev, attr, buf); \
765 store_regs_beep_##reg (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
767 return store_beep_reg(dev, buf, count, BEEP_##REG); \
769 static DEVICE_ATTR(beep_##reg, S_IRUGO | S_IWUSR, \
770 show_regs_beep_##reg, store_regs_beep_##reg);
772 sysfs_beep(ENABLE, enable);
773 sysfs_beep(MASK, mask);
776 show_fan_div(struct device *dev, struct device_attribute *devattr, char *buf)
778 int nr = to_sensor_dev_attr(devattr)->index;
779 struct w83627hf_data *data = w83627hf_update_device(dev);
780 return sprintf(buf, "%ld\n",
781 (long) DIV_FROM_REG(data->fan_div[nr]));
783 /* Note: we save and restore the fan minimum here, because its value is
784 determined in part by the fan divisor. This follows the principle of
785 least surprise; the user doesn't expect the fan minimum to change just
786 because the divisor changed. */
788 store_fan_div(struct device *dev, struct device_attribute *devattr,
789 const char *buf, size_t count)
791 int nr = to_sensor_dev_attr(devattr)->index;
792 struct w83627hf_data *data = dev_get_drvdata(dev);
795 unsigned long val = simple_strtoul(buf, NULL, 10);
797 mutex_lock(&data->update_lock);
800 min = FAN_FROM_REG(data->fan_min[nr],
801 DIV_FROM_REG(data->fan_div[nr]));
803 data->fan_div[nr] = DIV_TO_REG(val);
805 reg = (w83627hf_read_value(data, nr==2 ? W83781D_REG_PIN : W83781D_REG_VID_FANDIV)
806 & (nr==0 ? 0xcf : 0x3f))
807 | ((data->fan_div[nr] & 0x03) << (nr==0 ? 4 : 6));
808 w83627hf_write_value(data, nr==2 ? W83781D_REG_PIN : W83781D_REG_VID_FANDIV, reg);
810 reg = (w83627hf_read_value(data, W83781D_REG_VBAT)
812 | ((data->fan_div[nr] & 0x04) << (3 + nr));
813 w83627hf_write_value(data, W83781D_REG_VBAT, reg);
815 /* Restore fan_min */
816 data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
817 w83627hf_write_value(data, W83781D_REG_FAN_MIN(nr+1), data->fan_min[nr]);
819 mutex_unlock(&data->update_lock);
823 static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO|S_IWUSR,
824 show_fan_div, store_fan_div, 0);
825 static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO|S_IWUSR,
826 show_fan_div, store_fan_div, 1);
827 static SENSOR_DEVICE_ATTR(fan3_div, S_IRUGO|S_IWUSR,
828 show_fan_div, store_fan_div, 2);
831 show_pwm(struct device *dev, struct device_attribute *devattr, char *buf)
833 int nr = to_sensor_dev_attr(devattr)->index;
834 struct w83627hf_data *data = w83627hf_update_device(dev);
835 return sprintf(buf, "%ld\n", (long) data->pwm[nr]);
839 store_pwm(struct device *dev, struct device_attribute *devattr,
840 const char *buf, size_t count)
842 int nr = to_sensor_dev_attr(devattr)->index;
843 struct w83627hf_data *data = dev_get_drvdata(dev);
844 u32 val = simple_strtoul(buf, NULL, 10);
846 mutex_lock(&data->update_lock);
848 if (data->type == w83627thf) {
849 /* bits 0-3 are reserved in 627THF */
850 data->pwm[nr] = PWM_TO_REG(val) & 0xf0;
851 w83627hf_write_value(data,
852 W836X7HF_REG_PWM(data->type, nr),
854 (w83627hf_read_value(data,
855 W836X7HF_REG_PWM(data->type, nr)) & 0x0f));
857 data->pwm[nr] = PWM_TO_REG(val);
858 w83627hf_write_value(data,
859 W836X7HF_REG_PWM(data->type, nr),
863 mutex_unlock(&data->update_lock);
867 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO|S_IWUSR, show_pwm, store_pwm, 0);
868 static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO|S_IWUSR, show_pwm, store_pwm, 1);
869 static SENSOR_DEVICE_ATTR(pwm3, S_IRUGO|S_IWUSR, show_pwm, store_pwm, 2);
872 show_pwm_freq(struct device *dev, struct device_attribute *devattr, char *buf)
874 int nr = to_sensor_dev_attr(devattr)->index;
875 struct w83627hf_data *data = w83627hf_update_device(dev);
876 if (data->type == w83627hf)
877 return sprintf(buf, "%ld\n",
878 pwm_freq_from_reg_627hf(data->pwm_freq[nr]));
880 return sprintf(buf, "%ld\n",
881 pwm_freq_from_reg(data->pwm_freq[nr]));
885 store_pwm_freq(struct device *dev, struct device_attribute *devattr,
886 const char *buf, size_t count)
888 int nr = to_sensor_dev_attr(devattr)->index;
889 struct w83627hf_data *data = dev_get_drvdata(dev);
890 static const u8 mask[]={0xF8, 0x8F};
893 val = simple_strtoul(buf, NULL, 10);
895 mutex_lock(&data->update_lock);
897 if (data->type == w83627hf) {
898 data->pwm_freq[nr] = pwm_freq_to_reg_627hf(val);
899 w83627hf_write_value(data, W83627HF_REG_PWM_FREQ,
900 (data->pwm_freq[nr] << (nr*4)) |
901 (w83627hf_read_value(data,
902 W83627HF_REG_PWM_FREQ) & mask[nr]));
904 data->pwm_freq[nr] = pwm_freq_to_reg(val);
905 w83627hf_write_value(data, W83637HF_REG_PWM_FREQ[nr],
909 mutex_unlock(&data->update_lock);
913 static SENSOR_DEVICE_ATTR(pwm1_freq, S_IRUGO|S_IWUSR,
914 show_pwm_freq, store_pwm_freq, 0);
915 static SENSOR_DEVICE_ATTR(pwm2_freq, S_IRUGO|S_IWUSR,
916 show_pwm_freq, store_pwm_freq, 1);
917 static SENSOR_DEVICE_ATTR(pwm3_freq, S_IRUGO|S_IWUSR,
918 show_pwm_freq, store_pwm_freq, 2);
921 show_temp_type(struct device *dev, struct device_attribute *devattr,
924 int nr = to_sensor_dev_attr(devattr)->index;
925 struct w83627hf_data *data = w83627hf_update_device(dev);
926 return sprintf(buf, "%ld\n", (long) data->sens[nr]);
930 store_temp_type(struct device *dev, struct device_attribute *devattr,
931 const char *buf, size_t count)
933 int nr = to_sensor_dev_attr(devattr)->index;
934 struct w83627hf_data *data = dev_get_drvdata(dev);
937 val = simple_strtoul(buf, NULL, 10);
939 mutex_lock(&data->update_lock);
942 case 1: /* PII/Celeron diode */
943 tmp = w83627hf_read_value(data, W83781D_REG_SCFG1);
944 w83627hf_write_value(data, W83781D_REG_SCFG1,
945 tmp | BIT_SCFG1[nr]);
946 tmp = w83627hf_read_value(data, W83781D_REG_SCFG2);
947 w83627hf_write_value(data, W83781D_REG_SCFG2,
948 tmp | BIT_SCFG2[nr]);
949 data->sens[nr] = val;
952 tmp = w83627hf_read_value(data, W83781D_REG_SCFG1);
953 w83627hf_write_value(data, W83781D_REG_SCFG1,
954 tmp | BIT_SCFG1[nr]);
955 tmp = w83627hf_read_value(data, W83781D_REG_SCFG2);
956 w83627hf_write_value(data, W83781D_REG_SCFG2,
957 tmp & ~BIT_SCFG2[nr]);
958 data->sens[nr] = val;
960 case W83781D_DEFAULT_BETA:
961 dev_warn(dev, "Sensor type %d is deprecated, please use 4 "
962 "instead\n", W83781D_DEFAULT_BETA);
964 case 4: /* thermistor */
965 tmp = w83627hf_read_value(data, W83781D_REG_SCFG1);
966 w83627hf_write_value(data, W83781D_REG_SCFG1,
967 tmp & ~BIT_SCFG1[nr]);
968 data->sens[nr] = val;
972 "Invalid sensor type %ld; must be 1, 2, or 4\n",
977 mutex_unlock(&data->update_lock);
981 #define sysfs_temp_type(offset) \
982 static SENSOR_DEVICE_ATTR(temp##offset##_type, S_IRUGO | S_IWUSR, \
983 show_temp_type, store_temp_type, offset - 1);
990 show_name(struct device *dev, struct device_attribute *devattr, char *buf)
992 struct w83627hf_data *data = dev_get_drvdata(dev);
994 return sprintf(buf, "%s\n", data->name);
996 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
998 static int __init w83627hf_find(int sioaddr, unsigned short *addr,
999 struct w83627hf_sio_data *sio_data)
1004 static const __initdata char *names[] = {
1016 val= superio_inb(DEVID);
1019 sio_data->type = w83627hf;
1022 sio_data->type = w83627thf;
1025 sio_data->type = w83697hf;
1028 sio_data->type = w83637hf;
1031 sio_data->type = w83687thf;
1033 case 0xff: /* No device at all */
1036 pr_debug(DRVNAME ": Unsupported chip (DEVID=0x%02x)\n", val);
1040 superio_select(W83627HF_LD_HWM);
1041 force_addr &= WINB_ALIGNMENT;
1043 printk(KERN_WARNING DRVNAME ": Forcing address 0x%x\n",
1045 superio_outb(WINB_BASE_REG, force_addr >> 8);
1046 superio_outb(WINB_BASE_REG + 1, force_addr & 0xff);
1048 val = (superio_inb(WINB_BASE_REG) << 8) |
1049 superio_inb(WINB_BASE_REG + 1);
1050 *addr = val & WINB_ALIGNMENT;
1052 printk(KERN_WARNING DRVNAME ": Base address not set, "
1057 val = superio_inb(WINB_ACT_REG);
1058 if (!(val & 0x01)) {
1059 printk(KERN_WARNING DRVNAME ": Enabling HWM logical device\n");
1060 superio_outb(WINB_ACT_REG, val | 0x01);
1064 pr_info(DRVNAME ": Found %s chip at %#x\n",
1065 names[sio_data->type], *addr);
1072 #define VIN_UNIT_ATTRS(_X_) \
1073 &sensor_dev_attr_in##_X_##_input.dev_attr.attr, \
1074 &sensor_dev_attr_in##_X_##_min.dev_attr.attr, \
1075 &sensor_dev_attr_in##_X_##_max.dev_attr.attr
1077 #define FAN_UNIT_ATTRS(_X_) \
1078 &sensor_dev_attr_fan##_X_##_input.dev_attr.attr, \
1079 &sensor_dev_attr_fan##_X_##_min.dev_attr.attr, \
1080 &sensor_dev_attr_fan##_X_##_div.dev_attr.attr
1082 #define TEMP_UNIT_ATTRS(_X_) \
1083 &sensor_dev_attr_temp##_X_##_input.dev_attr.attr, \
1084 &sensor_dev_attr_temp##_X_##_max.dev_attr.attr, \
1085 &sensor_dev_attr_temp##_X_##_max_hyst.dev_attr.attr, \
1086 &sensor_dev_attr_temp##_X_##_type.dev_attr.attr
1088 static struct attribute *w83627hf_attributes[] = {
1089 &dev_attr_in0_input.attr,
1090 &dev_attr_in0_min.attr,
1091 &dev_attr_in0_max.attr,
1104 &dev_attr_alarms.attr,
1105 &dev_attr_beep_enable.attr,
1106 &dev_attr_beep_mask.attr,
1108 &sensor_dev_attr_pwm1.dev_attr.attr,
1109 &sensor_dev_attr_pwm2.dev_attr.attr,
1110 &dev_attr_name.attr,
1114 static const struct attribute_group w83627hf_group = {
1115 .attrs = w83627hf_attributes,
1118 static struct attribute *w83627hf_attributes_opt[] = {
1125 &sensor_dev_attr_pwm3.dev_attr.attr,
1127 &sensor_dev_attr_pwm1_freq.dev_attr.attr,
1128 &sensor_dev_attr_pwm2_freq.dev_attr.attr,
1129 &sensor_dev_attr_pwm3_freq.dev_attr.attr,
1133 static const struct attribute_group w83627hf_group_opt = {
1134 .attrs = w83627hf_attributes_opt,
1137 static int __devinit w83627hf_probe(struct platform_device *pdev)
1139 struct device *dev = &pdev->dev;
1140 struct w83627hf_sio_data *sio_data = dev->platform_data;
1141 struct w83627hf_data *data;
1142 struct resource *res;
1145 static const char *names[] = {
1153 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1154 if (!request_region(res->start, WINB_REGION_SIZE, DRVNAME)) {
1155 dev_err(dev, "Failed to request region 0x%lx-0x%lx\n",
1156 (unsigned long)res->start,
1157 (unsigned long)(res->start + WINB_REGION_SIZE - 1));
1162 if (!(data = kzalloc(sizeof(struct w83627hf_data), GFP_KERNEL))) {
1166 data->addr = res->start;
1167 data->type = sio_data->type;
1168 data->name = names[sio_data->type];
1169 mutex_init(&data->lock);
1170 mutex_init(&data->update_lock);
1171 platform_set_drvdata(pdev, data);
1173 /* Initialize the chip */
1174 w83627hf_init_device(pdev);
1176 /* A few vars need to be filled upon startup */
1177 data->fan_min[0] = w83627hf_read_value(data, W83781D_REG_FAN_MIN(1));
1178 data->fan_min[1] = w83627hf_read_value(data, W83781D_REG_FAN_MIN(2));
1179 data->fan_min[2] = w83627hf_read_value(data, W83781D_REG_FAN_MIN(3));
1180 w83627hf_update_fan_div(data);
1182 /* Register common device attributes */
1183 if ((err = sysfs_create_group(&dev->kobj, &w83627hf_group)))
1186 /* Register chip-specific device attributes */
1187 if (data->type == w83627hf || data->type == w83697hf)
1188 if ((err = device_create_file(dev,
1189 &sensor_dev_attr_in5_input.dev_attr))
1190 || (err = device_create_file(dev,
1191 &sensor_dev_attr_in5_min.dev_attr))
1192 || (err = device_create_file(dev,
1193 &sensor_dev_attr_in5_max.dev_attr))
1194 || (err = device_create_file(dev,
1195 &sensor_dev_attr_in6_input.dev_attr))
1196 || (err = device_create_file(dev,
1197 &sensor_dev_attr_in6_min.dev_attr))
1198 || (err = device_create_file(dev,
1199 &sensor_dev_attr_in6_max.dev_attr))
1200 || (err = device_create_file(dev,
1201 &sensor_dev_attr_pwm1_freq.dev_attr))
1202 || (err = device_create_file(dev,
1203 &sensor_dev_attr_pwm2_freq.dev_attr)))
1206 if (data->type != w83697hf)
1207 if ((err = device_create_file(dev,
1208 &sensor_dev_attr_in1_input.dev_attr))
1209 || (err = device_create_file(dev,
1210 &sensor_dev_attr_in1_min.dev_attr))
1211 || (err = device_create_file(dev,
1212 &sensor_dev_attr_in1_max.dev_attr))
1213 || (err = device_create_file(dev,
1214 &sensor_dev_attr_fan3_input.dev_attr))
1215 || (err = device_create_file(dev,
1216 &sensor_dev_attr_fan3_min.dev_attr))
1217 || (err = device_create_file(dev,
1218 &sensor_dev_attr_fan3_div.dev_attr))
1219 || (err = device_create_file(dev,
1220 &sensor_dev_attr_temp3_input.dev_attr))
1221 || (err = device_create_file(dev,
1222 &sensor_dev_attr_temp3_max.dev_attr))
1223 || (err = device_create_file(dev,
1224 &sensor_dev_attr_temp3_max_hyst.dev_attr))
1225 || (err = device_create_file(dev,
1226 &sensor_dev_attr_temp3_type.dev_attr)))
1229 if (data->type != w83697hf && data->vid != 0xff) {
1230 /* Convert VID to voltage based on VRM */
1231 data->vrm = vid_which_vrm();
1233 if ((err = device_create_file(dev, &dev_attr_cpu0_vid))
1234 || (err = device_create_file(dev, &dev_attr_vrm)))
1238 if (data->type == w83627thf || data->type == w83637hf
1239 || data->type == w83687thf)
1240 if ((err = device_create_file(dev,
1241 &sensor_dev_attr_pwm3.dev_attr)))
1244 if (data->type == w83637hf || data->type == w83687thf)
1245 if ((err = device_create_file(dev,
1246 &sensor_dev_attr_pwm1_freq.dev_attr))
1247 || (err = device_create_file(dev,
1248 &sensor_dev_attr_pwm2_freq.dev_attr))
1249 || (err = device_create_file(dev,
1250 &sensor_dev_attr_pwm3_freq.dev_attr)))
1253 data->hwmon_dev = hwmon_device_register(dev);
1254 if (IS_ERR(data->hwmon_dev)) {
1255 err = PTR_ERR(data->hwmon_dev);
1262 sysfs_remove_group(&dev->kobj, &w83627hf_group);
1263 sysfs_remove_group(&dev->kobj, &w83627hf_group_opt);
1265 platform_set_drvdata(pdev, NULL);
1268 release_region(res->start, WINB_REGION_SIZE);
1273 static int __devexit w83627hf_remove(struct platform_device *pdev)
1275 struct w83627hf_data *data = platform_get_drvdata(pdev);
1276 struct resource *res;
1278 hwmon_device_unregister(data->hwmon_dev);
1280 sysfs_remove_group(&pdev->dev.kobj, &w83627hf_group);
1281 sysfs_remove_group(&pdev->dev.kobj, &w83627hf_group_opt);
1282 platform_set_drvdata(pdev, NULL);
1285 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1286 release_region(res->start, WINB_REGION_SIZE);
1292 /* Registers 0x50-0x5f are banked */
1293 static inline void w83627hf_set_bank(struct w83627hf_data *data, u16 reg)
1295 if ((reg & 0x00f0) == 0x50) {
1296 outb_p(W83781D_REG_BANK, data->addr + W83781D_ADDR_REG_OFFSET);
1297 outb_p(reg >> 8, data->addr + W83781D_DATA_REG_OFFSET);
1301 /* Not strictly necessary, but play it safe for now */
1302 static inline void w83627hf_reset_bank(struct w83627hf_data *data, u16 reg)
1305 outb_p(W83781D_REG_BANK, data->addr + W83781D_ADDR_REG_OFFSET);
1306 outb_p(0, data->addr + W83781D_DATA_REG_OFFSET);
1310 static int w83627hf_read_value(struct w83627hf_data *data, u16 reg)
1312 int res, word_sized;
1314 mutex_lock(&data->lock);
1315 word_sized = (((reg & 0xff00) == 0x100)
1316 || ((reg & 0xff00) == 0x200))
1317 && (((reg & 0x00ff) == 0x50)
1318 || ((reg & 0x00ff) == 0x53)
1319 || ((reg & 0x00ff) == 0x55));
1320 w83627hf_set_bank(data, reg);
1321 outb_p(reg & 0xff, data->addr + W83781D_ADDR_REG_OFFSET);
1322 res = inb_p(data->addr + W83781D_DATA_REG_OFFSET);
1324 outb_p((reg & 0xff) + 1,
1325 data->addr + W83781D_ADDR_REG_OFFSET);
1327 (res << 8) + inb_p(data->addr +
1328 W83781D_DATA_REG_OFFSET);
1330 w83627hf_reset_bank(data, reg);
1331 mutex_unlock(&data->lock);
1335 static int __devinit w83627thf_read_gpio5(struct platform_device *pdev)
1337 int res = 0xff, sel;
1340 superio_select(W83627HF_LD_GPIO5);
1342 /* Make sure these GPIO pins are enabled */
1343 if (!(superio_inb(W83627THF_GPIO5_EN) & (1<<3))) {
1344 dev_dbg(&pdev->dev, "GPIO5 disabled, no VID function\n");
1348 /* Make sure the pins are configured for input
1349 There must be at least five (VRM 9), and possibly 6 (VRM 10) */
1350 sel = superio_inb(W83627THF_GPIO5_IOSR) & 0x3f;
1351 if ((sel & 0x1f) != 0x1f) {
1352 dev_dbg(&pdev->dev, "GPIO5 not configured for VID "
1357 dev_info(&pdev->dev, "Reading VID from GPIO5\n");
1358 res = superio_inb(W83627THF_GPIO5_DR) & sel;
1365 static int __devinit w83687thf_read_vid(struct platform_device *pdev)
1370 superio_select(W83627HF_LD_HWM);
1372 /* Make sure these GPIO pins are enabled */
1373 if (!(superio_inb(W83687THF_VID_EN) & (1 << 2))) {
1374 dev_dbg(&pdev->dev, "VID disabled, no VID function\n");
1378 /* Make sure the pins are configured for input */
1379 if (!(superio_inb(W83687THF_VID_CFG) & (1 << 4))) {
1380 dev_dbg(&pdev->dev, "VID configured as output, "
1381 "no VID function\n");
1385 res = superio_inb(W83687THF_VID_DATA) & 0x3f;
1392 static int w83627hf_write_value(struct w83627hf_data *data, u16 reg, u16 value)
1396 mutex_lock(&data->lock);
1397 word_sized = (((reg & 0xff00) == 0x100)
1398 || ((reg & 0xff00) == 0x200))
1399 && (((reg & 0x00ff) == 0x53)
1400 || ((reg & 0x00ff) == 0x55));
1401 w83627hf_set_bank(data, reg);
1402 outb_p(reg & 0xff, data->addr + W83781D_ADDR_REG_OFFSET);
1405 data->addr + W83781D_DATA_REG_OFFSET);
1406 outb_p((reg & 0xff) + 1,
1407 data->addr + W83781D_ADDR_REG_OFFSET);
1409 outb_p(value & 0xff,
1410 data->addr + W83781D_DATA_REG_OFFSET);
1411 w83627hf_reset_bank(data, reg);
1412 mutex_unlock(&data->lock);
1416 static void __devinit w83627hf_init_device(struct platform_device *pdev)
1418 struct w83627hf_data *data = platform_get_drvdata(pdev);
1420 enum chips type = data->type;
1424 /* Resetting the chip has been the default for a long time,
1425 but repeatedly caused problems (fans going to full
1426 speed...) so it is now optional. It might even go away if
1427 nobody reports it as being useful, as I see very little
1428 reason why this would be needed at all. */
1429 dev_info(&pdev->dev, "If reset=1 solved a problem you were "
1430 "having, please report!\n");
1432 /* save this register */
1433 i = w83627hf_read_value(data, W83781D_REG_BEEP_CONFIG);
1434 /* Reset all except Watchdog values and last conversion values
1435 This sets fan-divs to 2, among others */
1436 w83627hf_write_value(data, W83781D_REG_CONFIG, 0x80);
1437 /* Restore the register and disable power-on abnormal beep.
1438 This saves FAN 1/2/3 input/output values set by BIOS. */
1439 w83627hf_write_value(data, W83781D_REG_BEEP_CONFIG, i | 0x80);
1440 /* Disable master beep-enable (reset turns it on).
1441 Individual beeps should be reset to off but for some reason
1442 disabling this bit helps some people not get beeped */
1443 w83627hf_write_value(data, W83781D_REG_BEEP_INTS2, 0);
1446 /* Minimize conflicts with other winbond i2c-only clients... */
1447 /* disable i2c subclients... how to disable main i2c client?? */
1448 /* force i2c address to relatively uncommon address */
1449 w83627hf_write_value(data, W83781D_REG_I2C_SUBADDR, 0x89);
1450 w83627hf_write_value(data, W83781D_REG_I2C_ADDR, force_i2c);
1452 /* Read VID only once */
1453 if (type == w83627hf || type == w83637hf) {
1454 int lo = w83627hf_read_value(data, W83781D_REG_VID_FANDIV);
1455 int hi = w83627hf_read_value(data, W83781D_REG_CHIPID);
1456 data->vid = (lo & 0x0f) | ((hi & 0x01) << 4);
1457 } else if (type == w83627thf) {
1458 data->vid = w83627thf_read_gpio5(pdev);
1459 } else if (type == w83687thf) {
1460 data->vid = w83687thf_read_vid(pdev);
1463 /* Read VRM & OVT Config only once */
1464 if (type == w83627thf || type == w83637hf || type == w83687thf) {
1466 w83627hf_read_value(data, W83627THF_REG_VRM_OVT_CFG);
1469 tmp = w83627hf_read_value(data, W83781D_REG_SCFG1);
1470 for (i = 1; i <= 3; i++) {
1471 if (!(tmp & BIT_SCFG1[i - 1])) {
1472 data->sens[i - 1] = 4;
1474 if (w83627hf_read_value
1476 W83781D_REG_SCFG2) & BIT_SCFG2[i - 1])
1477 data->sens[i - 1] = 1;
1479 data->sens[i - 1] = 2;
1481 if ((type == w83697hf) && (i == 2))
1487 tmp = w83627hf_read_value(data, W83627HF_REG_TEMP2_CONFIG);
1489 dev_warn(&pdev->dev, "Enabling temp2, readings "
1490 "might not make sense\n");
1491 w83627hf_write_value(data, W83627HF_REG_TEMP2_CONFIG,
1496 if (type != w83697hf) {
1497 tmp = w83627hf_read_value(data,
1498 W83627HF_REG_TEMP3_CONFIG);
1500 dev_warn(&pdev->dev, "Enabling temp3, "
1501 "readings might not make sense\n");
1502 w83627hf_write_value(data,
1503 W83627HF_REG_TEMP3_CONFIG, tmp & 0xfe);
1508 /* Start monitoring */
1509 w83627hf_write_value(data, W83781D_REG_CONFIG,
1510 (w83627hf_read_value(data,
1511 W83781D_REG_CONFIG) & 0xf7)
1515 static void w83627hf_update_fan_div(struct w83627hf_data *data)
1519 reg = w83627hf_read_value(data, W83781D_REG_VID_FANDIV);
1520 data->fan_div[0] = (reg >> 4) & 0x03;
1521 data->fan_div[1] = (reg >> 6) & 0x03;
1522 if (data->type != w83697hf) {
1523 data->fan_div[2] = (w83627hf_read_value(data,
1524 W83781D_REG_PIN) >> 6) & 0x03;
1526 reg = w83627hf_read_value(data, W83781D_REG_VBAT);
1527 data->fan_div[0] |= (reg >> 3) & 0x04;
1528 data->fan_div[1] |= (reg >> 4) & 0x04;
1529 if (data->type != w83697hf)
1530 data->fan_div[2] |= (reg >> 5) & 0x04;
1533 static struct w83627hf_data *w83627hf_update_device(struct device *dev)
1535 struct w83627hf_data *data = dev_get_drvdata(dev);
1536 int i, num_temps = (data->type == w83697hf) ? 2 : 3;
1538 mutex_lock(&data->update_lock);
1540 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1542 for (i = 0; i <= 8; i++) {
1543 /* skip missing sensors */
1544 if (((data->type == w83697hf) && (i == 1)) ||
1545 ((data->type != w83627hf && data->type != w83697hf)
1546 && (i == 5 || i == 6)))
1549 w83627hf_read_value(data, W83781D_REG_IN(i));
1551 w83627hf_read_value(data,
1552 W83781D_REG_IN_MIN(i));
1554 w83627hf_read_value(data,
1555 W83781D_REG_IN_MAX(i));
1557 for (i = 1; i <= 3; i++) {
1559 w83627hf_read_value(data, W83781D_REG_FAN(i));
1560 data->fan_min[i - 1] =
1561 w83627hf_read_value(data,
1562 W83781D_REG_FAN_MIN(i));
1564 for (i = 0; i <= 2; i++) {
1565 u8 tmp = w83627hf_read_value(data,
1566 W836X7HF_REG_PWM(data->type, i));
1567 /* bits 0-3 are reserved in 627THF */
1568 if (data->type == w83627thf)
1572 (data->type == w83627hf || data->type == w83697hf))
1575 if (data->type == w83627hf) {
1576 u8 tmp = w83627hf_read_value(data,
1577 W83627HF_REG_PWM_FREQ);
1578 data->pwm_freq[0] = tmp & 0x07;
1579 data->pwm_freq[1] = (tmp >> 4) & 0x07;
1580 } else if (data->type != w83627thf) {
1581 for (i = 1; i <= 3; i++) {
1582 data->pwm_freq[i - 1] =
1583 w83627hf_read_value(data,
1584 W83637HF_REG_PWM_FREQ[i - 1]);
1585 if (i == 2 && (data->type == w83697hf))
1589 for (i = 0; i < num_temps; i++) {
1590 data->temp[i] = w83627hf_read_value(
1591 data, w83627hf_reg_temp[i]);
1592 data->temp_max[i] = w83627hf_read_value(
1593 data, w83627hf_reg_temp_over[i]);
1594 data->temp_max_hyst[i] = w83627hf_read_value(
1595 data, w83627hf_reg_temp_hyst[i]);
1598 w83627hf_update_fan_div(data);
1601 w83627hf_read_value(data, W83781D_REG_ALARM1) |
1602 (w83627hf_read_value(data, W83781D_REG_ALARM2) << 8) |
1603 (w83627hf_read_value(data, W83781D_REG_ALARM3) << 16);
1604 i = w83627hf_read_value(data, W83781D_REG_BEEP_INTS2);
1605 data->beep_enable = i >> 7;
1606 data->beep_mask = ((i & 0x7f) << 8) |
1607 w83627hf_read_value(data, W83781D_REG_BEEP_INTS1) |
1608 w83627hf_read_value(data, W83781D_REG_BEEP_INTS3) << 16;
1609 data->last_updated = jiffies;
1613 mutex_unlock(&data->update_lock);
1618 static int __init w83627hf_device_add(unsigned short address,
1619 const struct w83627hf_sio_data *sio_data)
1621 struct resource res = {
1622 .start = address + WINB_REGION_OFFSET,
1623 .end = address + WINB_REGION_OFFSET + WINB_REGION_SIZE - 1,
1625 .flags = IORESOURCE_IO,
1629 pdev = platform_device_alloc(DRVNAME, address);
1632 printk(KERN_ERR DRVNAME ": Device allocation failed\n");
1636 err = platform_device_add_resources(pdev, &res, 1);
1638 printk(KERN_ERR DRVNAME ": Device resource addition failed "
1640 goto exit_device_put;
1643 err = platform_device_add_data(pdev, sio_data,
1644 sizeof(struct w83627hf_sio_data));
1646 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
1647 goto exit_device_put;
1650 err = platform_device_add(pdev);
1652 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
1654 goto exit_device_put;
1660 platform_device_put(pdev);
1665 static int __init sensors_w83627hf_init(void)
1668 unsigned short address;
1669 struct w83627hf_sio_data sio_data;
1671 if (w83627hf_find(0x2e, &address, &sio_data)
1672 && w83627hf_find(0x4e, &address, &sio_data))
1675 err = platform_driver_register(&w83627hf_driver);
1679 /* Sets global pdev as a side effect */
1680 err = w83627hf_device_add(address, &sio_data);
1687 platform_driver_unregister(&w83627hf_driver);
1692 static void __exit sensors_w83627hf_exit(void)
1694 platform_device_unregister(pdev);
1695 platform_driver_unregister(&w83627hf_driver);
1698 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
1699 "Philip Edelbrock <phil@netroedge.com>, "
1700 "and Mark Studebaker <mdsxyz123@yahoo.com>");
1701 MODULE_DESCRIPTION("W83627HF driver");
1702 MODULE_LICENSE("GPL");
1704 module_init(sensors_w83627hf_init);
1705 module_exit(sensors_w83627hf_exit);