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>
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 Supports following chips:
27 Chip #vin #fanin #pwm #temp wchipid vendid i2c ISA
28 w83627hf 9 3 2 3 0x20 0x5ca3 no yes(LPC)
29 w83627thf 7 3 3 3 0x90 0x5ca3 no yes(LPC)
30 w83637hf 7 3 3 3 0x80 0x5ca3 no yes(LPC)
31 w83697hf 8 2 2 2 0x60 0x5ca3 no yes(LPC)
33 For other winbond chips, and for i2c support in the above chips,
36 Note: automatic ("cruise") fan control for 697, 637 & 627thf not
40 #include <linux/module.h>
41 #include <linux/init.h>
42 #include <linux/slab.h>
43 #include <linux/jiffies.h>
44 #include <linux/i2c.h>
45 #include <linux/i2c-sensor.h>
46 #include <linux/i2c-vid.h>
47 #include <linux/hwmon.h>
48 #include <linux/err.h>
52 static u16 force_addr
;
53 module_param(force_addr
, ushort
, 0);
54 MODULE_PARM_DESC(force_addr
,
55 "Initialize the base address of the sensors");
56 static u8 force_i2c
= 0x1f;
57 module_param(force_i2c
, byte
, 0);
58 MODULE_PARM_DESC(force_i2c
,
59 "Initialize the i2c address of the sensors");
61 /* Addresses to scan */
62 static unsigned short normal_i2c
[] = { I2C_CLIENT_END
};
63 static unsigned int normal_isa
[] = { 0, I2C_CLIENT_ISA_END
};
65 /* Insmod parameters */
66 SENSORS_INSMOD_4(w83627hf
, w83627thf
, w83697hf
, w83637hf
);
69 module_param(init
, bool, 0);
70 MODULE_PARM_DESC(init
, "Set to zero to bypass chip initialization");
72 /* modified from kernel/include/traps.c */
73 static int REG
; /* The register to read/write */
74 #define DEV 0x07 /* Register: Logical device select */
75 static int VAL
; /* The value to read/write */
77 /* logical device numbers for superio_select (below) */
78 #define W83627HF_LD_FDC 0x00
79 #define W83627HF_LD_PRT 0x01
80 #define W83627HF_LD_UART1 0x02
81 #define W83627HF_LD_UART2 0x03
82 #define W83627HF_LD_KBC 0x05
83 #define W83627HF_LD_CIR 0x06 /* w83627hf only */
84 #define W83627HF_LD_GAME 0x07
85 #define W83627HF_LD_MIDI 0x07
86 #define W83627HF_LD_GPIO1 0x07
87 #define W83627HF_LD_GPIO5 0x07 /* w83627thf only */
88 #define W83627HF_LD_GPIO2 0x08
89 #define W83627HF_LD_GPIO3 0x09
90 #define W83627HF_LD_GPIO4 0x09 /* w83627thf only */
91 #define W83627HF_LD_ACPI 0x0a
92 #define W83627HF_LD_HWM 0x0b
94 #define DEVID 0x20 /* Register: Device ID */
96 #define W83627THF_GPIO5_EN 0x30 /* w83627thf only */
97 #define W83627THF_GPIO5_IOSR 0xf3 /* w83627thf only */
98 #define W83627THF_GPIO5_DR 0xf4 /* w83627thf only */
101 superio_outb(int reg
, int val
)
115 superio_select(int ld
)
134 #define W627_DEVID 0x52
135 #define W627THF_DEVID 0x82
136 #define W697_DEVID 0x60
137 #define W637_DEVID 0x70
138 #define WINB_ACT_REG 0x30
139 #define WINB_BASE_REG 0x60
140 /* Constants specified below */
142 /* Length of ISA address segment */
143 #define WINB_EXTENT 8
145 /* Where are the ISA address/data registers relative to the base address */
146 #define W83781D_ADDR_REG_OFFSET 5
147 #define W83781D_DATA_REG_OFFSET 6
149 /* The W83781D registers */
150 /* The W83782D registers for nr=7,8 are in bank 5 */
151 #define W83781D_REG_IN_MAX(nr) ((nr < 7) ? (0x2b + (nr) * 2) : \
152 (0x554 + (((nr) - 7) * 2)))
153 #define W83781D_REG_IN_MIN(nr) ((nr < 7) ? (0x2c + (nr) * 2) : \
154 (0x555 + (((nr) - 7) * 2)))
155 #define W83781D_REG_IN(nr) ((nr < 7) ? (0x20 + (nr)) : \
158 #define W83781D_REG_FAN_MIN(nr) (0x3a + (nr))
159 #define W83781D_REG_FAN(nr) (0x27 + (nr))
161 #define W83781D_REG_TEMP2_CONFIG 0x152
162 #define W83781D_REG_TEMP3_CONFIG 0x252
163 #define W83781D_REG_TEMP(nr) ((nr == 3) ? (0x0250) : \
164 ((nr == 2) ? (0x0150) : \
166 #define W83781D_REG_TEMP_HYST(nr) ((nr == 3) ? (0x253) : \
167 ((nr == 2) ? (0x153) : \
169 #define W83781D_REG_TEMP_OVER(nr) ((nr == 3) ? (0x255) : \
170 ((nr == 2) ? (0x155) : \
173 #define W83781D_REG_BANK 0x4E
175 #define W83781D_REG_CONFIG 0x40
176 #define W83781D_REG_ALARM1 0x41
177 #define W83781D_REG_ALARM2 0x42
178 #define W83781D_REG_ALARM3 0x450
180 #define W83781D_REG_IRQ 0x4C
181 #define W83781D_REG_BEEP_CONFIG 0x4D
182 #define W83781D_REG_BEEP_INTS1 0x56
183 #define W83781D_REG_BEEP_INTS2 0x57
184 #define W83781D_REG_BEEP_INTS3 0x453
186 #define W83781D_REG_VID_FANDIV 0x47
188 #define W83781D_REG_CHIPID 0x49
189 #define W83781D_REG_WCHIPID 0x58
190 #define W83781D_REG_CHIPMAN 0x4F
191 #define W83781D_REG_PIN 0x4B
193 #define W83781D_REG_VBAT 0x5D
195 #define W83627HF_REG_PWM1 0x5A
196 #define W83627HF_REG_PWM2 0x5B
197 #define W83627HF_REG_PWMCLK12 0x5C
199 #define W83627THF_REG_PWM1 0x01 /* 697HF and 637HF too */
200 #define W83627THF_REG_PWM2 0x03 /* 697HF and 637HF too */
201 #define W83627THF_REG_PWM3 0x11 /* 637HF too */
203 #define W83627THF_REG_VRM_OVT_CFG 0x18 /* 637HF too */
205 static const u8 regpwm_627hf
[] = { W83627HF_REG_PWM1
, W83627HF_REG_PWM2
};
206 static const u8 regpwm
[] = { W83627THF_REG_PWM1
, W83627THF_REG_PWM2
,
207 W83627THF_REG_PWM3
};
208 #define W836X7HF_REG_PWM(type, nr) (((type) == w83627hf) ? \
209 regpwm_627hf[(nr) - 1] : regpwm[(nr) - 1])
211 #define W83781D_REG_I2C_ADDR 0x48
212 #define W83781D_REG_I2C_SUBADDR 0x4A
214 /* Sensor selection */
215 #define W83781D_REG_SCFG1 0x5D
216 static const u8 BIT_SCFG1
[] = { 0x02, 0x04, 0x08 };
217 #define W83781D_REG_SCFG2 0x59
218 static const u8 BIT_SCFG2
[] = { 0x10, 0x20, 0x40 };
219 #define W83781D_DEFAULT_BETA 3435
221 /* Conversions. Limit checking is only done on the TO_REG
222 variants. Note that you should be a bit careful with which arguments
223 these macros are called: arguments may be evaluated more than once.
224 Fixing this is just not worth it. */
225 #define IN_TO_REG(val) (SENSORS_LIMIT((((val) + 8)/16),0,255))
226 #define IN_FROM_REG(val) ((val) * 16)
228 static inline u8
FAN_TO_REG(long rpm
, int div
)
232 rpm
= SENSORS_LIMIT(rpm
, 1, 1000000);
233 return SENSORS_LIMIT((1350000 + rpm
* div
/ 2) / (rpm
* div
), 1,
237 #define TEMP_MIN (-128000)
238 #define TEMP_MAX ( 127000)
240 /* TEMP: 0.001C/bit (-128C to +127C)
241 REG: 1C/bit, two's complement */
242 static u8
TEMP_TO_REG(int temp
)
244 int ntemp
= SENSORS_LIMIT(temp
, TEMP_MIN
, TEMP_MAX
);
245 ntemp
+= (ntemp
<0 ? -500 : 500);
246 return (u8
)(ntemp
/ 1000);
249 static int TEMP_FROM_REG(u8 reg
)
251 return (s8
)reg
* 1000;
254 #define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
256 #define PWM_TO_REG(val) (SENSORS_LIMIT((val),0,255))
258 #define BEEP_MASK_FROM_REG(val) (val)
259 #define BEEP_MASK_TO_REG(val) ((val) & 0xffffff)
260 #define BEEP_ENABLE_TO_REG(val) ((val)?1:0)
261 #define BEEP_ENABLE_FROM_REG(val) ((val)?1:0)
263 #define DIV_FROM_REG(val) (1 << (val))
265 static inline u8
DIV_TO_REG(long val
)
268 val
= SENSORS_LIMIT(val
, 1, 128) >> 1;
269 for (i
= 0; i
< 7; i
++) {
277 /* For each registered chip, we need to keep some data in memory. That
278 data is pointed to by w83627hf_list[NR]->data. The structure itself is
279 dynamically allocated, at the same time when a new client is allocated. */
280 struct w83627hf_data
{
281 struct i2c_client client
;
282 struct class_device
*class_dev
;
283 struct semaphore lock
;
286 struct semaphore update_lock
;
287 char valid
; /* !=0 if following fields are valid */
288 unsigned long last_updated
; /* In jiffies */
290 struct i2c_client
*lm75
; /* for secondary I2C addresses */
291 /* pointer to array of 2 subclients */
293 u8 in
[9]; /* Register value */
294 u8 in_max
[9]; /* Register value */
295 u8 in_min
[9]; /* Register value */
296 u8 fan
[3]; /* Register value */
297 u8 fan_min
[3]; /* Register value */
299 u8 temp_max
; /* Register value */
300 u8 temp_max_hyst
; /* Register value */
301 u16 temp_add
[2]; /* Register value */
302 u16 temp_max_add
[2]; /* Register value */
303 u16 temp_max_hyst_add
[2]; /* Register value */
304 u8 fan_div
[3]; /* Register encoding, shifted right */
305 u8 vid
; /* Register encoding, combined */
306 u32 alarms
; /* Register encoding, combined */
307 u32 beep_mask
; /* Register encoding, combined */
308 u8 beep_enable
; /* Boolean */
309 u8 pwm
[3]; /* Register value */
310 u16 sens
[3]; /* 782D/783S only.
311 1 = pentium diode; 2 = 3904 diode;
312 3000-5000 = thermistor beta.
314 Other Betas unimplemented */
316 u8 vrm_ovt
; /* Register value, 627thf & 637hf only */
320 static int w83627hf_attach_adapter(struct i2c_adapter
*adapter
);
321 static int w83627hf_detect(struct i2c_adapter
*adapter
, int address
,
323 static int w83627hf_detach_client(struct i2c_client
*client
);
325 static int w83627hf_read_value(struct i2c_client
*client
, u16
register);
326 static int w83627hf_write_value(struct i2c_client
*client
, u16
register,
328 static struct w83627hf_data
*w83627hf_update_device(struct device
*dev
);
329 static void w83627hf_init_client(struct i2c_client
*client
);
331 static struct i2c_driver w83627hf_driver
= {
332 .owner
= THIS_MODULE
,
334 .id
= I2C_DRIVERID_W83627HF
,
335 .flags
= I2C_DF_NOTIFY
,
336 .attach_adapter
= w83627hf_attach_adapter
,
337 .detach_client
= w83627hf_detach_client
,
340 /* following are the sysfs callback functions */
341 #define show_in_reg(reg) \
342 static ssize_t show_##reg (struct device *dev, char *buf, int nr) \
344 struct w83627hf_data *data = w83627hf_update_device(dev); \
345 return sprintf(buf,"%ld\n", (long)IN_FROM_REG(data->reg[nr])); \
351 #define store_in_reg(REG, reg) \
353 store_in_##reg (struct device *dev, const char *buf, size_t count, int nr) \
355 struct i2c_client *client = to_i2c_client(dev); \
356 struct w83627hf_data *data = i2c_get_clientdata(client); \
359 val = simple_strtoul(buf, NULL, 10); \
361 down(&data->update_lock); \
362 data->in_##reg[nr] = IN_TO_REG(val); \
363 w83627hf_write_value(client, W83781D_REG_IN_##REG(nr), \
364 data->in_##reg[nr]); \
366 up(&data->update_lock); \
369 store_in_reg(MIN
, min
)
370 store_in_reg(MAX
, max
)
372 #define sysfs_in_offset(offset) \
374 show_regs_in_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
376 return show_in(dev, buf, offset); \
378 static DEVICE_ATTR(in##offset##_input, S_IRUGO, show_regs_in_##offset, NULL);
380 #define sysfs_in_reg_offset(reg, offset) \
381 static ssize_t show_regs_in_##reg##offset (struct device *dev, struct device_attribute *attr, char *buf) \
383 return show_in_##reg (dev, buf, offset); \
386 store_regs_in_##reg##offset (struct device *dev, struct device_attribute *attr, \
387 const char *buf, size_t count) \
389 return store_in_##reg (dev, buf, count, offset); \
391 static DEVICE_ATTR(in##offset##_##reg, S_IRUGO| S_IWUSR, \
392 show_regs_in_##reg##offset, store_regs_in_##reg##offset);
394 #define sysfs_in_offsets(offset) \
395 sysfs_in_offset(offset) \
396 sysfs_in_reg_offset(min, offset) \
397 sysfs_in_reg_offset(max, offset)
408 /* use a different set of functions for in0 */
409 static ssize_t
show_in_0(struct w83627hf_data
*data
, char *buf
, u8 reg
)
413 if ((data
->vrm_ovt
& 0x01) &&
414 (w83627thf
== data
->type
|| w83637hf
== data
->type
))
416 /* use VRM9 calculation */
417 in0
= (long)((reg
* 488 + 70000 + 50) / 100);
419 /* use VRM8 (standard) calculation */
420 in0
= (long)IN_FROM_REG(reg
);
422 return sprintf(buf
,"%ld\n", in0
);
425 static ssize_t
show_regs_in_0(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
427 struct w83627hf_data
*data
= w83627hf_update_device(dev
);
428 return show_in_0(data
, buf
, data
->in
[0]);
431 static ssize_t
show_regs_in_min0(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
433 struct w83627hf_data
*data
= w83627hf_update_device(dev
);
434 return show_in_0(data
, buf
, data
->in_min
[0]);
437 static ssize_t
show_regs_in_max0(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
439 struct w83627hf_data
*data
= w83627hf_update_device(dev
);
440 return show_in_0(data
, buf
, data
->in_max
[0]);
443 static ssize_t
store_regs_in_min0(struct device
*dev
, struct device_attribute
*attr
,
444 const char *buf
, size_t count
)
446 struct i2c_client
*client
= to_i2c_client(dev
);
447 struct w83627hf_data
*data
= i2c_get_clientdata(client
);
450 val
= simple_strtoul(buf
, NULL
, 10);
452 down(&data
->update_lock
);
454 if ((data
->vrm_ovt
& 0x01) &&
455 (w83627thf
== data
->type
|| w83637hf
== data
->type
))
457 /* use VRM9 calculation */
458 data
->in_min
[0] = (u8
)(((val
* 100) - 70000 + 244) / 488);
460 /* use VRM8 (standard) calculation */
461 data
->in_min
[0] = IN_TO_REG(val
);
463 w83627hf_write_value(client
, W83781D_REG_IN_MIN(0), data
->in_min
[0]);
464 up(&data
->update_lock
);
468 static ssize_t
store_regs_in_max0(struct device
*dev
, struct device_attribute
*attr
,
469 const char *buf
, size_t count
)
471 struct i2c_client
*client
= to_i2c_client(dev
);
472 struct w83627hf_data
*data
= i2c_get_clientdata(client
);
475 val
= simple_strtoul(buf
, NULL
, 10);
477 down(&data
->update_lock
);
479 if ((data
->vrm_ovt
& 0x01) &&
480 (w83627thf
== data
->type
|| w83637hf
== data
->type
))
482 /* use VRM9 calculation */
483 data
->in_max
[0] = (u8
)(((val
* 100) - 70000 + 244) / 488);
485 /* use VRM8 (standard) calculation */
486 data
->in_max
[0] = IN_TO_REG(val
);
488 w83627hf_write_value(client
, W83781D_REG_IN_MAX(0), data
->in_max
[0]);
489 up(&data
->update_lock
);
493 static DEVICE_ATTR(in0_input
, S_IRUGO
, show_regs_in_0
, NULL
);
494 static DEVICE_ATTR(in0_min
, S_IRUGO
| S_IWUSR
,
495 show_regs_in_min0
, store_regs_in_min0
);
496 static DEVICE_ATTR(in0_max
, S_IRUGO
| S_IWUSR
,
497 show_regs_in_max0
, store_regs_in_max0
);
499 #define device_create_file_in(client, offset) \
501 device_create_file(&client->dev, &dev_attr_in##offset##_input); \
502 device_create_file(&client->dev, &dev_attr_in##offset##_min); \
503 device_create_file(&client->dev, &dev_attr_in##offset##_max); \
506 #define show_fan_reg(reg) \
507 static ssize_t show_##reg (struct device *dev, char *buf, int nr) \
509 struct w83627hf_data *data = w83627hf_update_device(dev); \
510 return sprintf(buf,"%ld\n", \
511 FAN_FROM_REG(data->reg[nr-1], \
512 (long)DIV_FROM_REG(data->fan_div[nr-1]))); \
515 show_fan_reg(fan_min
);
518 store_fan_min(struct device
*dev
, const char *buf
, size_t count
, int nr
)
520 struct i2c_client
*client
= to_i2c_client(dev
);
521 struct w83627hf_data
*data
= i2c_get_clientdata(client
);
524 val
= simple_strtoul(buf
, NULL
, 10);
526 down(&data
->update_lock
);
527 data
->fan_min
[nr
- 1] =
528 FAN_TO_REG(val
, DIV_FROM_REG(data
->fan_div
[nr
- 1]));
529 w83627hf_write_value(client
, W83781D_REG_FAN_MIN(nr
),
530 data
->fan_min
[nr
- 1]);
532 up(&data
->update_lock
);
536 #define sysfs_fan_offset(offset) \
537 static ssize_t show_regs_fan_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
539 return show_fan(dev, buf, offset); \
541 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_regs_fan_##offset, NULL);
543 #define sysfs_fan_min_offset(offset) \
544 static ssize_t show_regs_fan_min##offset (struct device *dev, struct device_attribute *attr, char *buf) \
546 return show_fan_min(dev, buf, offset); \
549 store_regs_fan_min##offset (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
551 return store_fan_min(dev, buf, count, offset); \
553 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
554 show_regs_fan_min##offset, store_regs_fan_min##offset);
557 sysfs_fan_min_offset(1);
559 sysfs_fan_min_offset(2);
561 sysfs_fan_min_offset(3);
563 #define device_create_file_fan(client, offset) \
565 device_create_file(&client->dev, &dev_attr_fan##offset##_input); \
566 device_create_file(&client->dev, &dev_attr_fan##offset##_min); \
569 #define show_temp_reg(reg) \
570 static ssize_t show_##reg (struct device *dev, char *buf, int nr) \
572 struct w83627hf_data *data = w83627hf_update_device(dev); \
573 if (nr >= 2) { /* TEMP2 and TEMP3 */ \
574 return sprintf(buf,"%ld\n", \
575 (long)LM75_TEMP_FROM_REG(data->reg##_add[nr-2])); \
576 } else { /* TEMP1 */ \
577 return sprintf(buf,"%ld\n", (long)TEMP_FROM_REG(data->reg)); \
581 show_temp_reg(temp_max
);
582 show_temp_reg(temp_max_hyst
);
584 #define store_temp_reg(REG, reg) \
586 store_temp_##reg (struct device *dev, const char *buf, size_t count, int nr) \
588 struct i2c_client *client = to_i2c_client(dev); \
589 struct w83627hf_data *data = i2c_get_clientdata(client); \
592 val = simple_strtoul(buf, NULL, 10); \
594 down(&data->update_lock); \
596 if (nr >= 2) { /* TEMP2 and TEMP3 */ \
597 data->temp_##reg##_add[nr-2] = LM75_TEMP_TO_REG(val); \
598 w83627hf_write_value(client, W83781D_REG_TEMP_##REG(nr), \
599 data->temp_##reg##_add[nr-2]); \
600 } else { /* TEMP1 */ \
601 data->temp_##reg = TEMP_TO_REG(val); \
602 w83627hf_write_value(client, W83781D_REG_TEMP_##REG(nr), \
606 up(&data->update_lock); \
609 store_temp_reg(OVER
, max
);
610 store_temp_reg(HYST
, max_hyst
);
612 #define sysfs_temp_offset(offset) \
614 show_regs_temp_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
616 return show_temp(dev, buf, offset); \
618 static DEVICE_ATTR(temp##offset##_input, S_IRUGO, show_regs_temp_##offset, NULL);
620 #define sysfs_temp_reg_offset(reg, offset) \
621 static ssize_t show_regs_temp_##reg##offset (struct device *dev, struct device_attribute *attr, char *buf) \
623 return show_temp_##reg (dev, buf, offset); \
626 store_regs_temp_##reg##offset (struct device *dev, struct device_attribute *attr, \
627 const char *buf, size_t count) \
629 return store_temp_##reg (dev, buf, count, offset); \
631 static DEVICE_ATTR(temp##offset##_##reg, S_IRUGO| S_IWUSR, \
632 show_regs_temp_##reg##offset, store_regs_temp_##reg##offset);
634 #define sysfs_temp_offsets(offset) \
635 sysfs_temp_offset(offset) \
636 sysfs_temp_reg_offset(max, offset) \
637 sysfs_temp_reg_offset(max_hyst, offset)
639 sysfs_temp_offsets(1);
640 sysfs_temp_offsets(2);
641 sysfs_temp_offsets(3);
643 #define device_create_file_temp(client, offset) \
645 device_create_file(&client->dev, &dev_attr_temp##offset##_input); \
646 device_create_file(&client->dev, &dev_attr_temp##offset##_max); \
647 device_create_file(&client->dev, &dev_attr_temp##offset##_max_hyst); \
651 show_vid_reg(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
653 struct w83627hf_data
*data
= w83627hf_update_device(dev
);
654 return sprintf(buf
, "%ld\n", (long) vid_from_reg(data
->vid
, data
->vrm
));
656 static DEVICE_ATTR(cpu0_vid
, S_IRUGO
, show_vid_reg
, NULL
);
657 #define device_create_file_vid(client) \
658 device_create_file(&client->dev, &dev_attr_cpu0_vid)
661 show_vrm_reg(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
663 struct w83627hf_data
*data
= w83627hf_update_device(dev
);
664 return sprintf(buf
, "%ld\n", (long) data
->vrm
);
667 store_vrm_reg(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
669 struct i2c_client
*client
= to_i2c_client(dev
);
670 struct w83627hf_data
*data
= i2c_get_clientdata(client
);
673 val
= simple_strtoul(buf
, NULL
, 10);
678 static DEVICE_ATTR(vrm
, S_IRUGO
| S_IWUSR
, show_vrm_reg
, store_vrm_reg
);
679 #define device_create_file_vrm(client) \
680 device_create_file(&client->dev, &dev_attr_vrm)
683 show_alarms_reg(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
685 struct w83627hf_data
*data
= w83627hf_update_device(dev
);
686 return sprintf(buf
, "%ld\n", (long) data
->alarms
);
688 static DEVICE_ATTR(alarms
, S_IRUGO
, show_alarms_reg
, NULL
);
689 #define device_create_file_alarms(client) \
690 device_create_file(&client->dev, &dev_attr_alarms)
692 #define show_beep_reg(REG, reg) \
693 static ssize_t show_beep_##reg (struct device *dev, struct device_attribute *attr, char *buf) \
695 struct w83627hf_data *data = w83627hf_update_device(dev); \
696 return sprintf(buf,"%ld\n", \
697 (long)BEEP_##REG##_FROM_REG(data->beep_##reg)); \
699 show_beep_reg(ENABLE
, enable
)
700 show_beep_reg(MASK
, mask
)
702 #define BEEP_ENABLE 0 /* Store beep_enable */
703 #define BEEP_MASK 1 /* Store beep_mask */
706 store_beep_reg(struct device
*dev
, const char *buf
, size_t count
,
709 struct i2c_client
*client
= to_i2c_client(dev
);
710 struct w83627hf_data
*data
= i2c_get_clientdata(client
);
713 val
= simple_strtoul(buf
, NULL
, 10);
715 down(&data
->update_lock
);
717 if (update_mask
== BEEP_MASK
) { /* We are storing beep_mask */
718 data
->beep_mask
= BEEP_MASK_TO_REG(val
);
719 w83627hf_write_value(client
, W83781D_REG_BEEP_INTS1
,
720 data
->beep_mask
& 0xff);
721 w83627hf_write_value(client
, W83781D_REG_BEEP_INTS3
,
722 ((data
->beep_mask
) >> 16) & 0xff);
723 val2
= (data
->beep_mask
>> 8) & 0x7f;
724 } else { /* We are storing beep_enable */
726 w83627hf_read_value(client
, W83781D_REG_BEEP_INTS2
) & 0x7f;
727 data
->beep_enable
= BEEP_ENABLE_TO_REG(val
);
730 w83627hf_write_value(client
, W83781D_REG_BEEP_INTS2
,
731 val2
| data
->beep_enable
<< 7);
733 up(&data
->update_lock
);
737 #define sysfs_beep(REG, reg) \
738 static ssize_t show_regs_beep_##reg (struct device *dev, struct device_attribute *attr, char *buf) \
740 return show_beep_##reg(dev, attr, buf); \
743 store_regs_beep_##reg (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
745 return store_beep_reg(dev, buf, count, BEEP_##REG); \
747 static DEVICE_ATTR(beep_##reg, S_IRUGO | S_IWUSR, \
748 show_regs_beep_##reg, store_regs_beep_##reg);
750 sysfs_beep(ENABLE
, enable
);
751 sysfs_beep(MASK
, mask
);
753 #define device_create_file_beep(client) \
755 device_create_file(&client->dev, &dev_attr_beep_enable); \
756 device_create_file(&client->dev, &dev_attr_beep_mask); \
760 show_fan_div_reg(struct device
*dev
, char *buf
, int nr
)
762 struct w83627hf_data
*data
= w83627hf_update_device(dev
);
763 return sprintf(buf
, "%ld\n",
764 (long) DIV_FROM_REG(data
->fan_div
[nr
- 1]));
767 /* Note: we save and restore the fan minimum here, because its value is
768 determined in part by the fan divisor. This follows the principle of
769 least suprise; the user doesn't expect the fan minimum to change just
770 because the divisor changed. */
772 store_fan_div_reg(struct device
*dev
, const char *buf
, size_t count
, int nr
)
774 struct i2c_client
*client
= to_i2c_client(dev
);
775 struct w83627hf_data
*data
= i2c_get_clientdata(client
);
778 unsigned long val
= simple_strtoul(buf
, NULL
, 10);
780 down(&data
->update_lock
);
783 min
= FAN_FROM_REG(data
->fan_min
[nr
],
784 DIV_FROM_REG(data
->fan_div
[nr
]));
786 data
->fan_div
[nr
] = DIV_TO_REG(val
);
788 reg
= (w83627hf_read_value(client
, nr
==2 ? W83781D_REG_PIN
: W83781D_REG_VID_FANDIV
)
789 & (nr
==0 ? 0xcf : 0x3f))
790 | ((data
->fan_div
[nr
] & 0x03) << (nr
==0 ? 4 : 6));
791 w83627hf_write_value(client
, nr
==2 ? W83781D_REG_PIN
: W83781D_REG_VID_FANDIV
, reg
);
793 reg
= (w83627hf_read_value(client
, W83781D_REG_VBAT
)
795 | ((data
->fan_div
[nr
] & 0x04) << (3 + nr
));
796 w83627hf_write_value(client
, W83781D_REG_VBAT
, reg
);
798 /* Restore fan_min */
799 data
->fan_min
[nr
] = FAN_TO_REG(min
, DIV_FROM_REG(data
->fan_div
[nr
]));
800 w83627hf_write_value(client
, W83781D_REG_FAN_MIN(nr
+1), data
->fan_min
[nr
]);
802 up(&data
->update_lock
);
806 #define sysfs_fan_div(offset) \
807 static ssize_t show_regs_fan_div_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
809 return show_fan_div_reg(dev, buf, offset); \
812 store_regs_fan_div_##offset (struct device *dev, struct device_attribute *attr, \
813 const char *buf, size_t count) \
815 return store_fan_div_reg(dev, buf, count, offset - 1); \
817 static DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
818 show_regs_fan_div_##offset, store_regs_fan_div_##offset);
824 #define device_create_file_fan_div(client, offset) \
826 device_create_file(&client->dev, &dev_attr_fan##offset##_div); \
830 show_pwm_reg(struct device
*dev
, char *buf
, int nr
)
832 struct w83627hf_data
*data
= w83627hf_update_device(dev
);
833 return sprintf(buf
, "%ld\n", (long) data
->pwm
[nr
- 1]);
837 store_pwm_reg(struct device
*dev
, const char *buf
, size_t count
, int nr
)
839 struct i2c_client
*client
= to_i2c_client(dev
);
840 struct w83627hf_data
*data
= i2c_get_clientdata(client
);
843 val
= simple_strtoul(buf
, NULL
, 10);
845 down(&data
->update_lock
);
847 if (data
->type
== w83627thf
) {
848 /* bits 0-3 are reserved in 627THF */
849 data
->pwm
[nr
- 1] = PWM_TO_REG(val
) & 0xf0;
850 w83627hf_write_value(client
,
851 W836X7HF_REG_PWM(data
->type
, nr
),
853 (w83627hf_read_value(client
,
854 W836X7HF_REG_PWM(data
->type
, nr
)) & 0x0f));
856 data
->pwm
[nr
- 1] = PWM_TO_REG(val
);
857 w83627hf_write_value(client
,
858 W836X7HF_REG_PWM(data
->type
, nr
),
862 up(&data
->update_lock
);
866 #define sysfs_pwm(offset) \
867 static ssize_t show_regs_pwm_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
869 return show_pwm_reg(dev, buf, offset); \
872 store_regs_pwm_##offset (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
874 return store_pwm_reg(dev, buf, count, offset); \
876 static DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
877 show_regs_pwm_##offset, store_regs_pwm_##offset);
883 #define device_create_file_pwm(client, offset) \
885 device_create_file(&client->dev, &dev_attr_pwm##offset); \
889 show_sensor_reg(struct device
*dev
, char *buf
, int nr
)
891 struct w83627hf_data
*data
= w83627hf_update_device(dev
);
892 return sprintf(buf
, "%ld\n", (long) data
->sens
[nr
- 1]);
896 store_sensor_reg(struct device
*dev
, const char *buf
, size_t count
, int nr
)
898 struct i2c_client
*client
= to_i2c_client(dev
);
899 struct w83627hf_data
*data
= i2c_get_clientdata(client
);
902 val
= simple_strtoul(buf
, NULL
, 10);
904 down(&data
->update_lock
);
907 case 1: /* PII/Celeron diode */
908 tmp
= w83627hf_read_value(client
, W83781D_REG_SCFG1
);
909 w83627hf_write_value(client
, W83781D_REG_SCFG1
,
910 tmp
| BIT_SCFG1
[nr
- 1]);
911 tmp
= w83627hf_read_value(client
, W83781D_REG_SCFG2
);
912 w83627hf_write_value(client
, W83781D_REG_SCFG2
,
913 tmp
| BIT_SCFG2
[nr
- 1]);
914 data
->sens
[nr
- 1] = val
;
917 tmp
= w83627hf_read_value(client
, W83781D_REG_SCFG1
);
918 w83627hf_write_value(client
, W83781D_REG_SCFG1
,
919 tmp
| BIT_SCFG1
[nr
- 1]);
920 tmp
= w83627hf_read_value(client
, W83781D_REG_SCFG2
);
921 w83627hf_write_value(client
, W83781D_REG_SCFG2
,
922 tmp
& ~BIT_SCFG2
[nr
- 1]);
923 data
->sens
[nr
- 1] = val
;
925 case W83781D_DEFAULT_BETA
: /* thermistor */
926 tmp
= w83627hf_read_value(client
, W83781D_REG_SCFG1
);
927 w83627hf_write_value(client
, W83781D_REG_SCFG1
,
928 tmp
& ~BIT_SCFG1
[nr
- 1]);
929 data
->sens
[nr
- 1] = val
;
932 dev_err(&client
->dev
,
933 "Invalid sensor type %ld; must be 1, 2, or %d\n",
934 (long) val
, W83781D_DEFAULT_BETA
);
938 up(&data
->update_lock
);
942 #define sysfs_sensor(offset) \
943 static ssize_t show_regs_sensor_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
945 return show_sensor_reg(dev, buf, offset); \
948 store_regs_sensor_##offset (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
950 return store_sensor_reg(dev, buf, count, offset); \
952 static DEVICE_ATTR(temp##offset##_type, S_IRUGO | S_IWUSR, \
953 show_regs_sensor_##offset, store_regs_sensor_##offset);
959 #define device_create_file_sensor(client, offset) \
961 device_create_file(&client->dev, &dev_attr_temp##offset##_type); \
965 /* This function is called when:
966 * w83627hf_driver is inserted (when this module is loaded), for each
968 * when a new adapter is inserted (and w83627hf_driver is still present) */
969 static int w83627hf_attach_adapter(struct i2c_adapter
*adapter
)
971 return i2c_detect(adapter
, &addr_data
, w83627hf_detect
);
974 static int w83627hf_find(int sioaddr
, int *address
)
982 val
= superio_inb(DEVID
);
983 if(val
!= W627_DEVID
&&
984 val
!= W627THF_DEVID
&&
991 superio_select(W83627HF_LD_HWM
);
992 val
= (superio_inb(WINB_BASE_REG
) << 8) |
993 superio_inb(WINB_BASE_REG
+ 1);
994 *address
= val
& ~(WINB_EXTENT
- 1);
995 if (*address
== 0 && force_addr
== 0) {
1000 *address
= force_addr
; /* so detect will get called */
1006 int w83627hf_detect(struct i2c_adapter
*adapter
, int address
,
1010 struct i2c_client
*new_client
;
1011 struct w83627hf_data
*data
;
1013 const char *client_name
= "";
1015 if (!i2c_is_isa_adapter(adapter
)) {
1021 address
= force_addr
& ~(WINB_EXTENT
- 1);
1023 if (!request_region(address
, WINB_EXTENT
, w83627hf_driver
.name
)) {
1029 printk("w83627hf.o: forcing ISA address 0x%04X\n", address
);
1031 superio_select(W83627HF_LD_HWM
);
1032 superio_outb(WINB_BASE_REG
, address
>> 8);
1033 superio_outb(WINB_BASE_REG
+1, address
& 0xff);
1038 val
= superio_inb(DEVID
);
1039 if(val
== W627_DEVID
)
1041 else if(val
== W697_DEVID
)
1043 else if(val
== W627THF_DEVID
)
1045 else if(val
== W637_DEVID
)
1048 dev_info(&adapter
->dev
,
1049 "Unsupported chip (dev_id=0x%02X).\n", val
);
1053 superio_select(W83627HF_LD_HWM
);
1054 if((val
= 0x01 & superio_inb(WINB_ACT_REG
)) == 0)
1055 superio_outb(WINB_ACT_REG
, 1);
1058 /* OK. For now, we presume we have a valid client. We now create the
1059 client structure, even though we cannot fill it completely yet.
1060 But it allows us to access w83627hf_{read,write}_value. */
1062 if (!(data
= kmalloc(sizeof(struct w83627hf_data
), GFP_KERNEL
))) {
1066 memset(data
, 0, sizeof(struct w83627hf_data
));
1068 new_client
= &data
->client
;
1069 i2c_set_clientdata(new_client
, data
);
1070 new_client
->addr
= address
;
1071 init_MUTEX(&data
->lock
);
1072 new_client
->adapter
= adapter
;
1073 new_client
->driver
= &w83627hf_driver
;
1074 new_client
->flags
= 0;
1077 if (kind
== w83627hf
) {
1078 client_name
= "w83627hf";
1079 } else if (kind
== w83627thf
) {
1080 client_name
= "w83627thf";
1081 } else if (kind
== w83697hf
) {
1082 client_name
= "w83697hf";
1083 } else if (kind
== w83637hf
) {
1084 client_name
= "w83637hf";
1087 /* Fill in the remaining client fields and put into the global list */
1088 strlcpy(new_client
->name
, client_name
, I2C_NAME_SIZE
);
1091 init_MUTEX(&data
->update_lock
);
1093 /* Tell the I2C layer a new client has arrived */
1094 if ((err
= i2c_attach_client(new_client
)))
1099 /* Initialize the chip */
1100 w83627hf_init_client(new_client
);
1102 /* A few vars need to be filled upon startup */
1103 data
->fan_min
[0] = w83627hf_read_value(new_client
, W83781D_REG_FAN_MIN(1));
1104 data
->fan_min
[1] = w83627hf_read_value(new_client
, W83781D_REG_FAN_MIN(2));
1105 data
->fan_min
[2] = w83627hf_read_value(new_client
, W83781D_REG_FAN_MIN(3));
1107 /* Register sysfs hooks */
1108 data
->class_dev
= hwmon_device_register(&new_client
->dev
);
1109 if (IS_ERR(data
->class_dev
)) {
1110 err
= PTR_ERR(data
->class_dev
);
1114 device_create_file_in(new_client
, 0);
1115 if (kind
!= w83697hf
)
1116 device_create_file_in(new_client
, 1);
1117 device_create_file_in(new_client
, 2);
1118 device_create_file_in(new_client
, 3);
1119 device_create_file_in(new_client
, 4);
1120 if (kind
!= w83627thf
&& kind
!= w83637hf
) {
1121 device_create_file_in(new_client
, 5);
1122 device_create_file_in(new_client
, 6);
1124 device_create_file_in(new_client
, 7);
1125 device_create_file_in(new_client
, 8);
1127 device_create_file_fan(new_client
, 1);
1128 device_create_file_fan(new_client
, 2);
1129 if (kind
!= w83697hf
)
1130 device_create_file_fan(new_client
, 3);
1132 device_create_file_temp(new_client
, 1);
1133 device_create_file_temp(new_client
, 2);
1134 if (kind
!= w83697hf
)
1135 device_create_file_temp(new_client
, 3);
1137 if (kind
!= w83697hf
)
1138 device_create_file_vid(new_client
);
1140 if (kind
!= w83697hf
)
1141 device_create_file_vrm(new_client
);
1143 device_create_file_fan_div(new_client
, 1);
1144 device_create_file_fan_div(new_client
, 2);
1145 if (kind
!= w83697hf
)
1146 device_create_file_fan_div(new_client
, 3);
1148 device_create_file_alarms(new_client
);
1150 device_create_file_beep(new_client
);
1152 device_create_file_pwm(new_client
, 1);
1153 device_create_file_pwm(new_client
, 2);
1154 if (kind
== w83627thf
|| kind
== w83637hf
)
1155 device_create_file_pwm(new_client
, 3);
1157 device_create_file_sensor(new_client
, 1);
1158 device_create_file_sensor(new_client
, 2);
1159 if (kind
!= w83697hf
)
1160 device_create_file_sensor(new_client
, 3);
1165 i2c_detach_client(new_client
);
1169 release_region(address
, WINB_EXTENT
);
1174 static int w83627hf_detach_client(struct i2c_client
*client
)
1176 struct w83627hf_data
*data
= i2c_get_clientdata(client
);
1179 hwmon_device_unregister(data
->class_dev
);
1181 if ((err
= i2c_detach_client(client
))) {
1182 dev_err(&client
->dev
,
1183 "Client deregistration failed, client not detached.\n");
1187 release_region(client
->addr
, WINB_EXTENT
);
1195 ISA access must always be locked explicitly!
1196 We ignore the W83781D BUSY flag at this moment - it could lead to deadlocks,
1197 would slow down the W83781D access and should not be necessary.
1198 There are some ugly typecasts here, but the good news is - they should
1199 nowhere else be necessary! */
1200 static int w83627hf_read_value(struct i2c_client
*client
, u16 reg
)
1202 struct w83627hf_data
*data
= i2c_get_clientdata(client
);
1203 int res
, word_sized
;
1206 word_sized
= (((reg
& 0xff00) == 0x100)
1207 || ((reg
& 0xff00) == 0x200))
1208 && (((reg
& 0x00ff) == 0x50)
1209 || ((reg
& 0x00ff) == 0x53)
1210 || ((reg
& 0x00ff) == 0x55));
1212 outb_p(W83781D_REG_BANK
,
1213 client
->addr
+ W83781D_ADDR_REG_OFFSET
);
1215 client
->addr
+ W83781D_DATA_REG_OFFSET
);
1217 outb_p(reg
& 0xff, client
->addr
+ W83781D_ADDR_REG_OFFSET
);
1218 res
= inb_p(client
->addr
+ W83781D_DATA_REG_OFFSET
);
1220 outb_p((reg
& 0xff) + 1,
1221 client
->addr
+ W83781D_ADDR_REG_OFFSET
);
1223 (res
<< 8) + inb_p(client
->addr
+
1224 W83781D_DATA_REG_OFFSET
);
1227 outb_p(W83781D_REG_BANK
,
1228 client
->addr
+ W83781D_ADDR_REG_OFFSET
);
1229 outb_p(0, client
->addr
+ W83781D_DATA_REG_OFFSET
);
1235 static int w83627thf_read_gpio5(struct i2c_client
*client
)
1237 int res
= 0xff, sel
;
1240 superio_select(W83627HF_LD_GPIO5
);
1242 /* Make sure these GPIO pins are enabled */
1243 if (!(superio_inb(W83627THF_GPIO5_EN
) & (1<<3))) {
1244 dev_dbg(&client
->dev
, "GPIO5 disabled, no VID function\n");
1248 /* Make sure the pins are configured for input
1249 There must be at least five (VRM 9), and possibly 6 (VRM 10) */
1250 sel
= superio_inb(W83627THF_GPIO5_IOSR
);
1251 if ((sel
& 0x1f) != 0x1f) {
1252 dev_dbg(&client
->dev
, "GPIO5 not configured for VID "
1257 dev_info(&client
->dev
, "Reading VID from GPIO5\n");
1258 res
= superio_inb(W83627THF_GPIO5_DR
) & sel
;
1265 static int w83627hf_write_value(struct i2c_client
*client
, u16 reg
, u16 value
)
1267 struct w83627hf_data
*data
= i2c_get_clientdata(client
);
1271 word_sized
= (((reg
& 0xff00) == 0x100)
1272 || ((reg
& 0xff00) == 0x200))
1273 && (((reg
& 0x00ff) == 0x53)
1274 || ((reg
& 0x00ff) == 0x55));
1276 outb_p(W83781D_REG_BANK
,
1277 client
->addr
+ W83781D_ADDR_REG_OFFSET
);
1279 client
->addr
+ W83781D_DATA_REG_OFFSET
);
1281 outb_p(reg
& 0xff, client
->addr
+ W83781D_ADDR_REG_OFFSET
);
1284 client
->addr
+ W83781D_DATA_REG_OFFSET
);
1285 outb_p((reg
& 0xff) + 1,
1286 client
->addr
+ W83781D_ADDR_REG_OFFSET
);
1288 outb_p(value
& 0xff,
1289 client
->addr
+ W83781D_DATA_REG_OFFSET
);
1291 outb_p(W83781D_REG_BANK
,
1292 client
->addr
+ W83781D_ADDR_REG_OFFSET
);
1293 outb_p(0, client
->addr
+ W83781D_DATA_REG_OFFSET
);
1299 /* Called when we have found a new W83781D. It should set limits, etc. */
1300 static void w83627hf_init_client(struct i2c_client
*client
)
1302 struct w83627hf_data
*data
= i2c_get_clientdata(client
);
1304 int type
= data
->type
;
1308 /* save this register */
1309 i
= w83627hf_read_value(client
, W83781D_REG_BEEP_CONFIG
);
1310 /* Reset all except Watchdog values and last conversion values
1311 This sets fan-divs to 2, among others */
1312 w83627hf_write_value(client
, W83781D_REG_CONFIG
, 0x80);
1313 /* Restore the register and disable power-on abnormal beep.
1314 This saves FAN 1/2/3 input/output values set by BIOS. */
1315 w83627hf_write_value(client
, W83781D_REG_BEEP_CONFIG
, i
| 0x80);
1316 /* Disable master beep-enable (reset turns it on).
1317 Individual beeps should be reset to off but for some reason
1318 disabling this bit helps some people not get beeped */
1319 w83627hf_write_value(client
, W83781D_REG_BEEP_INTS2
, 0);
1322 /* Minimize conflicts with other winbond i2c-only clients... */
1323 /* disable i2c subclients... how to disable main i2c client?? */
1324 /* force i2c address to relatively uncommon address */
1325 w83627hf_write_value(client
, W83781D_REG_I2C_SUBADDR
, 0x89);
1326 w83627hf_write_value(client
, W83781D_REG_I2C_ADDR
, force_i2c
);
1328 /* Read VID only once */
1329 if (w83627hf
== data
->type
|| w83637hf
== data
->type
) {
1330 int lo
= w83627hf_read_value(client
, W83781D_REG_VID_FANDIV
);
1331 int hi
= w83627hf_read_value(client
, W83781D_REG_CHIPID
);
1332 data
->vid
= (lo
& 0x0f) | ((hi
& 0x01) << 4);
1333 } else if (w83627thf
== data
->type
) {
1334 data
->vid
= w83627thf_read_gpio5(client
) & 0x3f;
1337 /* Read VRM & OVT Config only once */
1338 if (w83627thf
== data
->type
|| w83637hf
== data
->type
) {
1340 w83627hf_read_value(client
, W83627THF_REG_VRM_OVT_CFG
);
1341 data
->vrm
= (data
->vrm_ovt
& 0x01) ? 90 : 82;
1343 /* Convert VID to voltage based on default VRM */
1344 data
->vrm
= i2c_which_vrm();
1347 tmp
= w83627hf_read_value(client
, W83781D_REG_SCFG1
);
1348 for (i
= 1; i
<= 3; i
++) {
1349 if (!(tmp
& BIT_SCFG1
[i
- 1])) {
1350 data
->sens
[i
- 1] = W83781D_DEFAULT_BETA
;
1352 if (w83627hf_read_value
1354 W83781D_REG_SCFG2
) & BIT_SCFG2
[i
- 1])
1355 data
->sens
[i
- 1] = 1;
1357 data
->sens
[i
- 1] = 2;
1359 if ((type
== w83697hf
) && (i
== 2))
1365 tmp
= w83627hf_read_value(client
, W83781D_REG_TEMP2_CONFIG
);
1367 dev_warn(&client
->dev
, "Enabling temp2, readings "
1368 "might not make sense\n");
1369 w83627hf_write_value(client
, W83781D_REG_TEMP2_CONFIG
,
1374 if (type
!= w83697hf
) {
1375 tmp
= w83627hf_read_value(client
,
1376 W83781D_REG_TEMP3_CONFIG
);
1378 dev_warn(&client
->dev
, "Enabling temp3, "
1379 "readings might not make sense\n");
1380 w83627hf_write_value(client
,
1381 W83781D_REG_TEMP3_CONFIG
, tmp
& 0xfe);
1385 if (type
== w83627hf
) {
1386 /* enable PWM2 control (can't hurt since PWM reg
1387 should have been reset to 0xff) */
1388 w83627hf_write_value(client
, W83627HF_REG_PWMCLK12
,
1391 /* enable comparator mode for temp2 and temp3 so
1392 alarm indication will work correctly */
1393 i
= w83627hf_read_value(client
, W83781D_REG_IRQ
);
1395 w83627hf_write_value(client
, W83781D_REG_IRQ
,
1399 /* Start monitoring */
1400 w83627hf_write_value(client
, W83781D_REG_CONFIG
,
1401 (w83627hf_read_value(client
,
1402 W83781D_REG_CONFIG
) & 0xf7)
1406 static struct w83627hf_data
*w83627hf_update_device(struct device
*dev
)
1408 struct i2c_client
*client
= to_i2c_client(dev
);
1409 struct w83627hf_data
*data
= i2c_get_clientdata(client
);
1412 down(&data
->update_lock
);
1414 if (time_after(jiffies
, data
->last_updated
+ HZ
+ HZ
/ 2)
1416 for (i
= 0; i
<= 8; i
++) {
1417 /* skip missing sensors */
1418 if (((data
->type
== w83697hf
) && (i
== 1)) ||
1419 ((data
->type
== w83627thf
|| data
->type
== w83637hf
)
1420 && (i
== 4 || i
== 5)))
1423 w83627hf_read_value(client
, W83781D_REG_IN(i
));
1425 w83627hf_read_value(client
,
1426 W83781D_REG_IN_MIN(i
));
1428 w83627hf_read_value(client
,
1429 W83781D_REG_IN_MAX(i
));
1431 for (i
= 1; i
<= 3; i
++) {
1433 w83627hf_read_value(client
, W83781D_REG_FAN(i
));
1434 data
->fan_min
[i
- 1] =
1435 w83627hf_read_value(client
,
1436 W83781D_REG_FAN_MIN(i
));
1438 for (i
= 1; i
<= 3; i
++) {
1439 u8 tmp
= w83627hf_read_value(client
,
1440 W836X7HF_REG_PWM(data
->type
, i
));
1441 /* bits 0-3 are reserved in 627THF */
1442 if (data
->type
== w83627thf
)
1444 data
->pwm
[i
- 1] = tmp
;
1446 (data
->type
== w83627hf
|| data
->type
== w83697hf
))
1450 data
->temp
= w83627hf_read_value(client
, W83781D_REG_TEMP(1));
1452 w83627hf_read_value(client
, W83781D_REG_TEMP_OVER(1));
1453 data
->temp_max_hyst
=
1454 w83627hf_read_value(client
, W83781D_REG_TEMP_HYST(1));
1456 w83627hf_read_value(client
, W83781D_REG_TEMP(2));
1457 data
->temp_max_add
[0] =
1458 w83627hf_read_value(client
, W83781D_REG_TEMP_OVER(2));
1459 data
->temp_max_hyst_add
[0] =
1460 w83627hf_read_value(client
, W83781D_REG_TEMP_HYST(2));
1461 if (data
->type
!= w83697hf
) {
1463 w83627hf_read_value(client
, W83781D_REG_TEMP(3));
1464 data
->temp_max_add
[1] =
1465 w83627hf_read_value(client
, W83781D_REG_TEMP_OVER(3));
1466 data
->temp_max_hyst_add
[1] =
1467 w83627hf_read_value(client
, W83781D_REG_TEMP_HYST(3));
1470 i
= w83627hf_read_value(client
, W83781D_REG_VID_FANDIV
);
1471 data
->fan_div
[0] = (i
>> 4) & 0x03;
1472 data
->fan_div
[1] = (i
>> 6) & 0x03;
1473 if (data
->type
!= w83697hf
) {
1474 data
->fan_div
[2] = (w83627hf_read_value(client
,
1475 W83781D_REG_PIN
) >> 6) & 0x03;
1477 i
= w83627hf_read_value(client
, W83781D_REG_VBAT
);
1478 data
->fan_div
[0] |= (i
>> 3) & 0x04;
1479 data
->fan_div
[1] |= (i
>> 4) & 0x04;
1480 if (data
->type
!= w83697hf
)
1481 data
->fan_div
[2] |= (i
>> 5) & 0x04;
1483 w83627hf_read_value(client
, W83781D_REG_ALARM1
) |
1484 (w83627hf_read_value(client
, W83781D_REG_ALARM2
) << 8) |
1485 (w83627hf_read_value(client
, W83781D_REG_ALARM3
) << 16);
1486 i
= w83627hf_read_value(client
, W83781D_REG_BEEP_INTS2
);
1487 data
->beep_enable
= i
>> 7;
1488 data
->beep_mask
= ((i
& 0x7f) << 8) |
1489 w83627hf_read_value(client
, W83781D_REG_BEEP_INTS1
) |
1490 w83627hf_read_value(client
, W83781D_REG_BEEP_INTS3
) << 16;
1491 data
->last_updated
= jiffies
;
1495 up(&data
->update_lock
);
1500 static int __init
sensors_w83627hf_init(void)
1504 if (w83627hf_find(0x2e, &addr
)
1505 && w83627hf_find(0x4e, &addr
)) {
1508 normal_isa
[0] = addr
;
1510 return i2c_add_driver(&w83627hf_driver
);
1513 static void __exit
sensors_w83627hf_exit(void)
1515 i2c_del_driver(&w83627hf_driver
);
1518 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
1519 "Philip Edelbrock <phil@netroedge.com>, "
1520 "and Mark Studebaker <mdsxyz123@yahoo.com>");
1521 MODULE_DESCRIPTION("W83627HF driver");
1522 MODULE_LICENSE("GPL");
1524 module_init(sensors_w83627hf_init
);
1525 module_exit(sensors_w83627hf_exit
);