?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[SCSI] advansys pci tweaks.
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / hwmon / w83627hf.c
blob7ea441d4da63ecb9ba65b8b2be1387aa6f9179e5
1 /*
2 w83627hf.c - Part of lm_sensors, Linux kernel modules for hardware
3 monitoring
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
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.
13
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.
18
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.
22 */
23
24 /*
25 Supports following chips:
26
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)
32
33 For other winbond chips, and for i2c support in the above chips,
34 use w83781d.c.
35
36 Note: automatic ("cruise") fan control for 697, 637 & 627thf not
37 supported yet.
38 */
39
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-isa.h>
46 #include <linux/hwmon.h>
47 #include <linux/hwmon-vid.h>
48 #include <linux/err.h>
49 #include <asm/io.h>
50 #include "lm75.h"
51
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");
60
61 /* The actual ISA address is read from Super-I/O configuration space */
62 static unsigned short address;
63
64 /* Insmod parameters */
65 enum chips { any_chip, w83627hf, w83627thf, w83697hf, w83637hf };
66
67 static int reset;
68 module_param(reset, bool, 0);
69 MODULE_PARM_DESC(reset, "Set to one to reset chip on load");
70
71 static int init = 1;
72 module_param(init, bool, 0);
73 MODULE_PARM_DESC(init, "Set to zero to bypass chip initialization");
74
75 /* modified from kernel/include/traps.c */
76 static int REG; /* The register to read/write */
77 #define DEV 0x07 /* Register: Logical device select */
78 static int VAL; /* The value to read/write */
79
80 /* logical device numbers for superio_select (below) */
81 #define W83627HF_LD_FDC 0x00
82 #define W83627HF_LD_PRT 0x01
83 #define W83627HF_LD_UART1 0x02
84 #define W83627HF_LD_UART2 0x03
85 #define W83627HF_LD_KBC 0x05
86 #define W83627HF_LD_CIR 0x06 /* w83627hf only */
87 #define W83627HF_LD_GAME 0x07
88 #define W83627HF_LD_MIDI 0x07
89 #define W83627HF_LD_GPIO1 0x07
90 #define W83627HF_LD_GPIO5 0x07 /* w83627thf only */
91 #define W83627HF_LD_GPIO2 0x08
92 #define W83627HF_LD_GPIO3 0x09
93 #define W83627HF_LD_GPIO4 0x09 /* w83627thf only */
94 #define W83627HF_LD_ACPI 0x0a
95 #define W83627HF_LD_HWM 0x0b
96
97 #define DEVID 0x20 /* Register: Device ID */
98
99 #define W83627THF_GPIO5_EN 0x30 /* w83627thf only */
100 #define W83627THF_GPIO5_IOSR 0xf3 /* w83627thf only */
101 #define W83627THF_GPIO5_DR 0xf4 /* w83627thf only */
102
103 static inline void
104 superio_outb(int reg, int val)
105 {
106 outb(reg, REG);
107 outb(val, VAL);
108 }
109
110 static inline int
111 superio_inb(int reg)
112 {
113 outb(reg, REG);
114 return inb(VAL);
115 }
116
117 static inline void
118 superio_select(int ld)
119 {
120 outb(DEV, REG);
121 outb(ld, VAL);
122 }
123
124 static inline void
125 superio_enter(void)
126 {
127 outb(0x87, REG);
128 outb(0x87, REG);
129 }
130
131 static inline void
132 superio_exit(void)
133 {
134 outb(0xAA, REG);
135 }
136
137 #define W627_DEVID 0x52
138 #define W627THF_DEVID 0x82
139 #define W697_DEVID 0x60
140 #define W637_DEVID 0x70
141 #define WINB_ACT_REG 0x30
142 #define WINB_BASE_REG 0x60
143 /* Constants specified below */
144
145 /* Alignment of the base address */
146 #define WINB_ALIGNMENT ~7
147
148 /* Offset & size of I/O region we are interested in */
149 #define WINB_REGION_OFFSET 5
150 #define WINB_REGION_SIZE 2
151
152 /* Where are the sensors address/data registers relative to the base address */
153 #define W83781D_ADDR_REG_OFFSET 5
154 #define W83781D_DATA_REG_OFFSET 6
155
156 /* The W83781D registers */
157 /* The W83782D registers for nr=7,8 are in bank 5 */
158 #define W83781D_REG_IN_MAX(nr) ((nr < 7) ? (0x2b + (nr) * 2) : \
159 (0x554 + (((nr) - 7) * 2)))
160 #define W83781D_REG_IN_MIN(nr) ((nr < 7) ? (0x2c + (nr) * 2) : \
161 (0x555 + (((nr) - 7) * 2)))
162 #define W83781D_REG_IN(nr) ((nr < 7) ? (0x20 + (nr)) : \
163 (0x550 + (nr) - 7))
164
165 #define W83781D_REG_FAN_MIN(nr) (0x3a + (nr))
166 #define W83781D_REG_FAN(nr) (0x27 + (nr))
167
168 #define W83781D_REG_TEMP2_CONFIG 0x152
169 #define W83781D_REG_TEMP3_CONFIG 0x252
170 #define W83781D_REG_TEMP(nr) ((nr == 3) ? (0x0250) : \
171 ((nr == 2) ? (0x0150) : \
172 (0x27)))
173 #define W83781D_REG_TEMP_HYST(nr) ((nr == 3) ? (0x253) : \
174 ((nr == 2) ? (0x153) : \
175 (0x3A)))
176 #define W83781D_REG_TEMP_OVER(nr) ((nr == 3) ? (0x255) : \
177 ((nr == 2) ? (0x155) : \
178 (0x39)))
179
180 #define W83781D_REG_BANK 0x4E
181
182 #define W83781D_REG_CONFIG 0x40
183 #define W83781D_REG_ALARM1 0x459
184 #define W83781D_REG_ALARM2 0x45A
185 #define W83781D_REG_ALARM3 0x45B
186
187 #define W83781D_REG_BEEP_CONFIG 0x4D
188 #define W83781D_REG_BEEP_INTS1 0x56
189 #define W83781D_REG_BEEP_INTS2 0x57
190 #define W83781D_REG_BEEP_INTS3 0x453
191
192 #define W83781D_REG_VID_FANDIV 0x47
193
194 #define W83781D_REG_CHIPID 0x49
195 #define W83781D_REG_WCHIPID 0x58
196 #define W83781D_REG_CHIPMAN 0x4F
197 #define W83781D_REG_PIN 0x4B
198
199 #define W83781D_REG_VBAT 0x5D
200
201 #define W83627HF_REG_PWM1 0x5A
202 #define W83627HF_REG_PWM2 0x5B
203
204 #define W83627THF_REG_PWM1 0x01 /* 697HF and 637HF too */
205 #define W83627THF_REG_PWM2 0x03 /* 697HF and 637HF too */
206 #define W83627THF_REG_PWM3 0x11 /* 637HF too */
207
208 #define W83627THF_REG_VRM_OVT_CFG 0x18 /* 637HF too */
209
210 static const u8 regpwm_627hf[] = { W83627HF_REG_PWM1, W83627HF_REG_PWM2 };
211 static const u8 regpwm[] = { W83627THF_REG_PWM1, W83627THF_REG_PWM2,
212 W83627THF_REG_PWM3 };
213 #define W836X7HF_REG_PWM(type, nr) (((type) == w83627hf) ? \
214 regpwm_627hf[(nr) - 1] : regpwm[(nr) - 1])
215
216 #define W83781D_REG_I2C_ADDR 0x48
217 #define W83781D_REG_I2C_SUBADDR 0x4A
218
219 /* Sensor selection */
220 #define W83781D_REG_SCFG1 0x5D
221 static const u8 BIT_SCFG1[] = { 0x02, 0x04, 0x08 };
222 #define W83781D_REG_SCFG2 0x59
223 static const u8 BIT_SCFG2[] = { 0x10, 0x20, 0x40 };
224 #define W83781D_DEFAULT_BETA 3435
225
226 /* Conversions. Limit checking is only done on the TO_REG
227 variants. Note that you should be a bit careful with which arguments
228 these macros are called: arguments may be evaluated more than once.
229 Fixing this is just not worth it. */
230 #define IN_TO_REG(val) (SENSORS_LIMIT((((val) + 8)/16),0,255))
231 #define IN_FROM_REG(val) ((val) * 16)
232
233 static inline u8 FAN_TO_REG(long rpm, int div)
234 {
235 if (rpm == 0)
236 return 255;
237 rpm = SENSORS_LIMIT(rpm, 1, 1000000);
238 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
239 254);
240 }
241
242 #define TEMP_MIN (-128000)
243 #define TEMP_MAX ( 127000)
244
245 /* TEMP: 0.001C/bit (-128C to +127C)
246 REG: 1C/bit, two's complement */
247 static u8 TEMP_TO_REG(int temp)
248 {
249 int ntemp = SENSORS_LIMIT(temp, TEMP_MIN, TEMP_MAX);
250 ntemp += (ntemp<0 ? -500 : 500);
251 return (u8)(ntemp / 1000);
252 }
253
254 static int TEMP_FROM_REG(u8 reg)
255 {
256 return (s8)reg * 1000;
257 }
258
259 #define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
260
261 #define PWM_TO_REG(val) (SENSORS_LIMIT((val),0,255))
262
263 #define BEEP_MASK_FROM_REG(val) (val)
264 #define BEEP_MASK_TO_REG(val) ((val) & 0xffffff)
265 #define BEEP_ENABLE_TO_REG(val) ((val)?1:0)
266 #define BEEP_ENABLE_FROM_REG(val) ((val)?1:0)
267
268 #define DIV_FROM_REG(val) (1 << (val))
269
270 static inline u8 DIV_TO_REG(long val)
271 {
272 int i;
273 val = SENSORS_LIMIT(val, 1, 128) >> 1;
274 for (i = 0; i < 7; i++) {
275 if (val == 0)
276 break;
277 val >>= 1;
278 }
279 return ((u8) i);
280 }
281
282 /* For each registered chip, we need to keep some data in memory. That
283 data is pointed to by w83627hf_list[NR]->data. The structure itself is
284 dynamically allocated, at the same time when a new client is allocated. */
285 struct w83627hf_data {
286 struct i2c_client client;
287 struct class_device *class_dev;
288 struct semaphore lock;
289 enum chips type;
290
291 struct semaphore update_lock;
292 char valid; /* !=0 if following fields are valid */
293 unsigned long last_updated; /* In jiffies */
294
295 struct i2c_client *lm75; /* for secondary I2C addresses */
296 /* pointer to array of 2 subclients */
297
298 u8 in[9]; /* Register value */
299 u8 in_max[9]; /* Register value */
300 u8 in_min[9]; /* Register value */
301 u8 fan[3]; /* Register value */
302 u8 fan_min[3]; /* Register value */
303 u8 temp;
304 u8 temp_max; /* Register value */
305 u8 temp_max_hyst; /* Register value */
306 u16 temp_add[2]; /* Register value */
307 u16 temp_max_add[2]; /* Register value */
308 u16 temp_max_hyst_add[2]; /* Register value */
309 u8 fan_div[3]; /* Register encoding, shifted right */
310 u8 vid; /* Register encoding, combined */
311 u32 alarms; /* Register encoding, combined */
312 u32 beep_mask; /* Register encoding, combined */
313 u8 beep_enable; /* Boolean */
314 u8 pwm[3]; /* Register value */
315 u16 sens[3]; /* 782D/783S only.
316 1 = pentium diode; 2 = 3904 diode;
317 3000-5000 = thermistor beta.
318 Default = 3435.
319 Other Betas unimplemented */
320 u8 vrm;
321 u8 vrm_ovt; /* Register value, 627thf & 637hf only */
322 };
323
324
325 static int w83627hf_detect(struct i2c_adapter *adapter);
326 static int w83627hf_detach_client(struct i2c_client *client);
327
328 static int w83627hf_read_value(struct i2c_client *client, u16 register);
329 static int w83627hf_write_value(struct i2c_client *client, u16 register,
330 u16 value);
331 static struct w83627hf_data *w83627hf_update_device(struct device *dev);
332 static void w83627hf_init_client(struct i2c_client *client);
333
334 static struct i2c_driver w83627hf_driver = {
335 .driver = {
336 .name = "w83627hf",
337 },
338 .attach_adapter = w83627hf_detect,
339 .detach_client = w83627hf_detach_client,
340 };
341
342 /* following are the sysfs callback functions */
343 #define show_in_reg(reg) \
344 static ssize_t show_##reg (struct device *dev, char *buf, int nr) \
345 { \
346 struct w83627hf_data *data = w83627hf_update_device(dev); \
347 return sprintf(buf,"%ld\n", (long)IN_FROM_REG(data->reg[nr])); \
348 }
349 show_in_reg(in)
350 show_in_reg(in_min)
351 show_in_reg(in_max)
352
353 #define store_in_reg(REG, reg) \
354 static ssize_t \
355 store_in_##reg (struct device *dev, const char *buf, size_t count, int nr) \
356 { \
357 struct i2c_client *client = to_i2c_client(dev); \
358 struct w83627hf_data *data = i2c_get_clientdata(client); \
359 u32 val; \
360 \
361 val = simple_strtoul(buf, NULL, 10); \
362 \
363 down(&data->update_lock); \
364 data->in_##reg[nr] = IN_TO_REG(val); \
365 w83627hf_write_value(client, W83781D_REG_IN_##REG(nr), \
366 data->in_##reg[nr]); \
367 \
368 up(&data->update_lock); \
369 return count; \
370 }
371 store_in_reg(MIN, min)
372 store_in_reg(MAX, max)
373
374 #define sysfs_in_offset(offset) \
375 static ssize_t \
376 show_regs_in_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
377 { \
378 return show_in(dev, buf, offset); \
379 } \
380 static DEVICE_ATTR(in##offset##_input, S_IRUGO, show_regs_in_##offset, NULL);
381
382 #define sysfs_in_reg_offset(reg, offset) \
383 static ssize_t show_regs_in_##reg##offset (struct device *dev, struct device_attribute *attr, char *buf) \
384 { \
385 return show_in_##reg (dev, buf, offset); \
386 } \
387 static ssize_t \
388 store_regs_in_##reg##offset (struct device *dev, struct device_attribute *attr, \
389 const char *buf, size_t count) \
390 { \
391 return store_in_##reg (dev, buf, count, offset); \
392 } \
393 static DEVICE_ATTR(in##offset##_##reg, S_IRUGO| S_IWUSR, \
394 show_regs_in_##reg##offset, store_regs_in_##reg##offset);
395
396 #define sysfs_in_offsets(offset) \
397 sysfs_in_offset(offset) \
398 sysfs_in_reg_offset(min, offset) \
399 sysfs_in_reg_offset(max, offset)
400
401 sysfs_in_offsets(1);
402 sysfs_in_offsets(2);
403 sysfs_in_offsets(3);
404 sysfs_in_offsets(4);
405 sysfs_in_offsets(5);
406 sysfs_in_offsets(6);
407 sysfs_in_offsets(7);
408 sysfs_in_offsets(8);
409
410 /* use a different set of functions for in0 */
411 static ssize_t show_in_0(struct w83627hf_data *data, char *buf, u8 reg)
412 {
413 long in0;
414
415 if ((data->vrm_ovt & 0x01) &&
416 (w83627thf == data->type || w83637hf == data->type))
417
418 /* use VRM9 calculation */
419 in0 = (long)((reg * 488 + 70000 + 50) / 100);
420 else
421 /* use VRM8 (standard) calculation */
422 in0 = (long)IN_FROM_REG(reg);
423
424 return sprintf(buf,"%ld\n", in0);
425 }
426
427 static ssize_t show_regs_in_0(struct device *dev, struct device_attribute *attr, char *buf)
428 {
429 struct w83627hf_data *data = w83627hf_update_device(dev);
430 return show_in_0(data, buf, data->in[0]);
431 }
432
433 static ssize_t show_regs_in_min0(struct device *dev, struct device_attribute *attr, char *buf)
434 {
435 struct w83627hf_data *data = w83627hf_update_device(dev);
436 return show_in_0(data, buf, data->in_min[0]);
437 }
438
439 static ssize_t show_regs_in_max0(struct device *dev, struct device_attribute *attr, char *buf)
440 {
441 struct w83627hf_data *data = w83627hf_update_device(dev);
442 return show_in_0(data, buf, data->in_max[0]);
443 }
444
445 static ssize_t store_regs_in_min0(struct device *dev, struct device_attribute *attr,
446 const char *buf, size_t count)
447 {
448 struct i2c_client *client = to_i2c_client(dev);
449 struct w83627hf_data *data = i2c_get_clientdata(client);
450 u32 val;
451
452 val = simple_strtoul(buf, NULL, 10);
453
454 down(&data->update_lock);
455
456 if ((data->vrm_ovt & 0x01) &&
457 (w83627thf == data->type || w83637hf == data->type))
458
459 /* use VRM9 calculation */
460 data->in_min[0] =
461 SENSORS_LIMIT(((val * 100) - 70000 + 244) / 488, 0,
462 255);
463 else
464 /* use VRM8 (standard) calculation */
465 data->in_min[0] = IN_TO_REG(val);
466
467 w83627hf_write_value(client, W83781D_REG_IN_MIN(0), data->in_min[0]);
468 up(&data->update_lock);
469 return count;
470 }
471
472 static ssize_t store_regs_in_max0(struct device *dev, struct device_attribute *attr,
473 const char *buf, size_t count)
474 {
475 struct i2c_client *client = to_i2c_client(dev);
476 struct w83627hf_data *data = i2c_get_clientdata(client);
477 u32 val;
478
479 val = simple_strtoul(buf, NULL, 10);
480
481 down(&data->update_lock);
482
483 if ((data->vrm_ovt & 0x01) &&
484 (w83627thf == data->type || w83637hf == data->type))
485
486 /* use VRM9 calculation */
487 data->in_max[0] =
488 SENSORS_LIMIT(((val * 100) - 70000 + 244) / 488, 0,
489 255);
490 else
491 /* use VRM8 (standard) calculation */
492 data->in_max[0] = IN_TO_REG(val);
493
494 w83627hf_write_value(client, W83781D_REG_IN_MAX(0), data->in_max[0]);
495 up(&data->update_lock);
496 return count;
497 }
498
499 static DEVICE_ATTR(in0_input, S_IRUGO, show_regs_in_0, NULL);
500 static DEVICE_ATTR(in0_min, S_IRUGO | S_IWUSR,
501 show_regs_in_min0, store_regs_in_min0);
502 static DEVICE_ATTR(in0_max, S_IRUGO | S_IWUSR,
503 show_regs_in_max0, store_regs_in_max0);
504
505 #define device_create_file_in(client, offset) \
506 do { \
507 device_create_file(&client->dev, &dev_attr_in##offset##_input); \
508 device_create_file(&client->dev, &dev_attr_in##offset##_min); \
509 device_create_file(&client->dev, &dev_attr_in##offset##_max); \
510 } while (0)
511
512 #define show_fan_reg(reg) \
513 static ssize_t show_##reg (struct device *dev, char *buf, int nr) \
514 { \
515 struct w83627hf_data *data = w83627hf_update_device(dev); \
516 return sprintf(buf,"%ld\n", \
517 FAN_FROM_REG(data->reg[nr-1], \
518 (long)DIV_FROM_REG(data->fan_div[nr-1]))); \
519 }
520 show_fan_reg(fan);
521 show_fan_reg(fan_min);
522
523 static ssize_t
524 store_fan_min(struct device *dev, const char *buf, size_t count, int nr)
525 {
526 struct i2c_client *client = to_i2c_client(dev);
527 struct w83627hf_data *data = i2c_get_clientdata(client);
528 u32 val;
529
530 val = simple_strtoul(buf, NULL, 10);
531
532 down(&data->update_lock);
533 data->fan_min[nr - 1] =
534 FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr - 1]));
535 w83627hf_write_value(client, W83781D_REG_FAN_MIN(nr),
536 data->fan_min[nr - 1]);
537
538 up(&data->update_lock);
539 return count;
540 }
541
542 #define sysfs_fan_offset(offset) \
543 static ssize_t show_regs_fan_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
544 { \
545 return show_fan(dev, buf, offset); \
546 } \
547 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_regs_fan_##offset, NULL);
548
549 #define sysfs_fan_min_offset(offset) \
550 static ssize_t show_regs_fan_min##offset (struct device *dev, struct device_attribute *attr, char *buf) \
551 { \
552 return show_fan_min(dev, buf, offset); \
553 } \
554 static ssize_t \
555 store_regs_fan_min##offset (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
556 { \
557 return store_fan_min(dev, buf, count, offset); \
558 } \
559 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
560 show_regs_fan_min##offset, store_regs_fan_min##offset);
561
562 sysfs_fan_offset(1);
563 sysfs_fan_min_offset(1);
564 sysfs_fan_offset(2);
565 sysfs_fan_min_offset(2);
566 sysfs_fan_offset(3);
567 sysfs_fan_min_offset(3);
568
569 #define device_create_file_fan(client, offset) \
570 do { \
571 device_create_file(&client->dev, &dev_attr_fan##offset##_input); \
572 device_create_file(&client->dev, &dev_attr_fan##offset##_min); \
573 } while (0)
574
575 #define show_temp_reg(reg) \
576 static ssize_t show_##reg (struct device *dev, char *buf, int nr) \
577 { \
578 struct w83627hf_data *data = w83627hf_update_device(dev); \
579 if (nr >= 2) { /* TEMP2 and TEMP3 */ \
580 return sprintf(buf,"%ld\n", \
581 (long)LM75_TEMP_FROM_REG(data->reg##_add[nr-2])); \
582 } else { /* TEMP1 */ \
583 return sprintf(buf,"%ld\n", (long)TEMP_FROM_REG(data->reg)); \
584 } \
585 }
586 show_temp_reg(temp);
587 show_temp_reg(temp_max);
588 show_temp_reg(temp_max_hyst);
589
590 #define store_temp_reg(REG, reg) \
591 static ssize_t \
592 store_temp_##reg (struct device *dev, const char *buf, size_t count, int nr) \
593 { \
594 struct i2c_client *client = to_i2c_client(dev); \
595 struct w83627hf_data *data = i2c_get_clientdata(client); \
596 u32 val; \
597 \
598 val = simple_strtoul(buf, NULL, 10); \
599 \
600 down(&data->update_lock); \
601 \
602 if (nr >= 2) { /* TEMP2 and TEMP3 */ \
603 data->temp_##reg##_add[nr-2] = LM75_TEMP_TO_REG(val); \
604 w83627hf_write_value(client, W83781D_REG_TEMP_##REG(nr), \
605 data->temp_##reg##_add[nr-2]); \
606 } else { /* TEMP1 */ \
607 data->temp_##reg = TEMP_TO_REG(val); \
608 w83627hf_write_value(client, W83781D_REG_TEMP_##REG(nr), \
609 data->temp_##reg); \
610 } \
611 \
612 up(&data->update_lock); \
613 return count; \
614 }
615 store_temp_reg(OVER, max);
616 store_temp_reg(HYST, max_hyst);
617
618 #define sysfs_temp_offset(offset) \
619 static ssize_t \
620 show_regs_temp_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
621 { \
622 return show_temp(dev, buf, offset); \
623 } \
624 static DEVICE_ATTR(temp##offset##_input, S_IRUGO, show_regs_temp_##offset, NULL);
625
626 #define sysfs_temp_reg_offset(reg, offset) \
627 static ssize_t show_regs_temp_##reg##offset (struct device *dev, struct device_attribute *attr, char *buf) \
628 { \
629 return show_temp_##reg (dev, buf, offset); \
630 } \
631 static ssize_t \
632 store_regs_temp_##reg##offset (struct device *dev, struct device_attribute *attr, \
633 const char *buf, size_t count) \
634 { \
635 return store_temp_##reg (dev, buf, count, offset); \
636 } \
637 static DEVICE_ATTR(temp##offset##_##reg, S_IRUGO| S_IWUSR, \
638 show_regs_temp_##reg##offset, store_regs_temp_##reg##offset);
639
640 #define sysfs_temp_offsets(offset) \
641 sysfs_temp_offset(offset) \
642 sysfs_temp_reg_offset(max, offset) \
643 sysfs_temp_reg_offset(max_hyst, offset)
644
645 sysfs_temp_offsets(1);
646 sysfs_temp_offsets(2);
647 sysfs_temp_offsets(3);
648
649 #define device_create_file_temp(client, offset) \
650 do { \
651 device_create_file(&client->dev, &dev_attr_temp##offset##_input); \
652 device_create_file(&client->dev, &dev_attr_temp##offset##_max); \
653 device_create_file(&client->dev, &dev_attr_temp##offset##_max_hyst); \
654 } while (0)
655
656 static ssize_t
657 show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
658 {
659 struct w83627hf_data *data = w83627hf_update_device(dev);
660 return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm));
661 }
662 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
663 #define device_create_file_vid(client) \
664 device_create_file(&client->dev, &dev_attr_cpu0_vid)
665
666 static ssize_t
667 show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
668 {
669 struct w83627hf_data *data = w83627hf_update_device(dev);
670 return sprintf(buf, "%ld\n", (long) data->vrm);
671 }
672 static ssize_t
673 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
674 {
675 struct i2c_client *client = to_i2c_client(dev);
676 struct w83627hf_data *data = i2c_get_clientdata(client);
677 u32 val;
678
679 val = simple_strtoul(buf, NULL, 10);
680 data->vrm = val;
681
682 return count;
683 }
684 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
685 #define device_create_file_vrm(client) \
686 device_create_file(&client->dev, &dev_attr_vrm)
687
688 static ssize_t
689 show_alarms_reg(struct device *dev, struct device_attribute *attr, char *buf)
690 {
691 struct w83627hf_data *data = w83627hf_update_device(dev);
692 return sprintf(buf, "%ld\n", (long) data->alarms);
693 }
694 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
695 #define device_create_file_alarms(client) \
696 device_create_file(&client->dev, &dev_attr_alarms)
697
698 #define show_beep_reg(REG, reg) \
699 static ssize_t show_beep_##reg (struct device *dev, struct device_attribute *attr, char *buf) \
700 { \
701 struct w83627hf_data *data = w83627hf_update_device(dev); \
702 return sprintf(buf,"%ld\n", \
703 (long)BEEP_##REG##_FROM_REG(data->beep_##reg)); \
704 }
705 show_beep_reg(ENABLE, enable)
706 show_beep_reg(MASK, mask)
707
708 #define BEEP_ENABLE 0 /* Store beep_enable */
709 #define BEEP_MASK 1 /* Store beep_mask */
710
711 static ssize_t
712 store_beep_reg(struct device *dev, const char *buf, size_t count,
713 int update_mask)
714 {
715 struct i2c_client *client = to_i2c_client(dev);
716 struct w83627hf_data *data = i2c_get_clientdata(client);
717 u32 val, val2;
718
719 val = simple_strtoul(buf, NULL, 10);
720
721 down(&data->update_lock);
722
723 if (update_mask == BEEP_MASK) { /* We are storing beep_mask */
724 data->beep_mask = BEEP_MASK_TO_REG(val);
725 w83627hf_write_value(client, W83781D_REG_BEEP_INTS1,
726 data->beep_mask & 0xff);
727 w83627hf_write_value(client, W83781D_REG_BEEP_INTS3,
728 ((data->beep_mask) >> 16) & 0xff);
729 val2 = (data->beep_mask >> 8) & 0x7f;
730 } else { /* We are storing beep_enable */
731 val2 =
732 w83627hf_read_value(client, W83781D_REG_BEEP_INTS2) & 0x7f;
733 data->beep_enable = BEEP_ENABLE_TO_REG(val);
734 }
735
736 w83627hf_write_value(client, W83781D_REG_BEEP_INTS2,
737 val2 | data->beep_enable << 7);
738
739 up(&data->update_lock);
740 return count;
741 }
742
743 #define sysfs_beep(REG, reg) \
744 static ssize_t show_regs_beep_##reg (struct device *dev, struct device_attribute *attr, char *buf) \
745 { \
746 return show_beep_##reg(dev, attr, buf); \
747 } \
748 static ssize_t \
749 store_regs_beep_##reg (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
750 { \
751 return store_beep_reg(dev, buf, count, BEEP_##REG); \
752 } \
753 static DEVICE_ATTR(beep_##reg, S_IRUGO | S_IWUSR, \
754 show_regs_beep_##reg, store_regs_beep_##reg);
755
756 sysfs_beep(ENABLE, enable);
757 sysfs_beep(MASK, mask);
758
759 #define device_create_file_beep(client) \
760 do { \
761 device_create_file(&client->dev, &dev_attr_beep_enable); \
762 device_create_file(&client->dev, &dev_attr_beep_mask); \
763 } while (0)
764
765 static ssize_t
766 show_fan_div_reg(struct device *dev, char *buf, int nr)
767 {
768 struct w83627hf_data *data = w83627hf_update_device(dev);
769 return sprintf(buf, "%ld\n",
770 (long) DIV_FROM_REG(data->fan_div[nr - 1]));
771 }
772
773 /* Note: we save and restore the fan minimum here, because its value is
774 determined in part by the fan divisor. This follows the principle of
775 least suprise; the user doesn't expect the fan minimum to change just
776 because the divisor changed. */
777 static ssize_t
778 store_fan_div_reg(struct device *dev, const char *buf, size_t count, int nr)
779 {
780 struct i2c_client *client = to_i2c_client(dev);
781 struct w83627hf_data *data = i2c_get_clientdata(client);
782 unsigned long min;
783 u8 reg;
784 unsigned long val = simple_strtoul(buf, NULL, 10);
785
786 down(&data->update_lock);
787
788 /* Save fan_min */
789 min = FAN_FROM_REG(data->fan_min[nr],
790 DIV_FROM_REG(data->fan_div[nr]));
791
792 data->fan_div[nr] = DIV_TO_REG(val);
793
794 reg = (w83627hf_read_value(client, nr==2 ? W83781D_REG_PIN : W83781D_REG_VID_FANDIV)
795 & (nr==0 ? 0xcf : 0x3f))
796 | ((data->fan_div[nr] & 0x03) << (nr==0 ? 4 : 6));
797 w83627hf_write_value(client, nr==2 ? W83781D_REG_PIN : W83781D_REG_VID_FANDIV, reg);
798
799 reg = (w83627hf_read_value(client, W83781D_REG_VBAT)
800 & ~(1 << (5 + nr)))
801 | ((data->fan_div[nr] & 0x04) << (3 + nr));
802 w83627hf_write_value(client, W83781D_REG_VBAT, reg);
803
804 /* Restore fan_min */
805 data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
806 w83627hf_write_value(client, W83781D_REG_FAN_MIN(nr+1), data->fan_min[nr]);
807
808 up(&data->update_lock);
809 return count;
810 }
811
812 #define sysfs_fan_div(offset) \
813 static ssize_t show_regs_fan_div_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
814 { \
815 return show_fan_div_reg(dev, buf, offset); \
816 } \
817 static ssize_t \
818 store_regs_fan_div_##offset (struct device *dev, struct device_attribute *attr, \
819 const char *buf, size_t count) \
820 { \
821 return store_fan_div_reg(dev, buf, count, offset - 1); \
822 } \
823 static DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
824 show_regs_fan_div_##offset, store_regs_fan_div_##offset);
825
826 sysfs_fan_div(1);
827 sysfs_fan_div(2);
828 sysfs_fan_div(3);
829
830 #define device_create_file_fan_div(client, offset) \
831 do { \
832 device_create_file(&client->dev, &dev_attr_fan##offset##_div); \
833 } while (0)
834
835 static ssize_t
836 show_pwm_reg(struct device *dev, char *buf, int nr)
837 {
838 struct w83627hf_data *data = w83627hf_update_device(dev);
839 return sprintf(buf, "%ld\n", (long) data->pwm[nr - 1]);
840 }
841
842 static ssize_t
843 store_pwm_reg(struct device *dev, const char *buf, size_t count, int nr)
844 {
845 struct i2c_client *client = to_i2c_client(dev);
846 struct w83627hf_data *data = i2c_get_clientdata(client);
847 u32 val;
848
849 val = simple_strtoul(buf, NULL, 10);
850
851 down(&data->update_lock);
852
853 if (data->type == w83627thf) {
854 /* bits 0-3 are reserved in 627THF */
855 data->pwm[nr - 1] = PWM_TO_REG(val) & 0xf0;
856 w83627hf_write_value(client,
857 W836X7HF_REG_PWM(data->type, nr),
858 data->pwm[nr - 1] |
859 (w83627hf_read_value(client,
860 W836X7HF_REG_PWM(data->type, nr)) & 0x0f));
861 } else {
862 data->pwm[nr - 1] = PWM_TO_REG(val);
863 w83627hf_write_value(client,
864 W836X7HF_REG_PWM(data->type, nr),
865 data->pwm[nr - 1]);
866 }
867
868 up(&data->update_lock);
869 return count;
870 }
871
872 #define sysfs_pwm(offset) \
873 static ssize_t show_regs_pwm_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
874 { \
875 return show_pwm_reg(dev, buf, offset); \
876 } \
877 static ssize_t \
878 store_regs_pwm_##offset (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
879 { \
880 return store_pwm_reg(dev, buf, count, offset); \
881 } \
882 static DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
883 show_regs_pwm_##offset, store_regs_pwm_##offset);
884
885 sysfs_pwm(1);
886 sysfs_pwm(2);
887 sysfs_pwm(3);
888
889 #define device_create_file_pwm(client, offset) \
890 do { \
891 device_create_file(&client->dev, &dev_attr_pwm##offset); \
892 } while (0)
893
894 static ssize_t
895 show_sensor_reg(struct device *dev, char *buf, int nr)
896 {
897 struct w83627hf_data *data = w83627hf_update_device(dev);
898 return sprintf(buf, "%ld\n", (long) data->sens[nr - 1]);
899 }
900
901 static ssize_t
902 store_sensor_reg(struct device *dev, const char *buf, size_t count, int nr)
903 {
904 struct i2c_client *client = to_i2c_client(dev);
905 struct w83627hf_data *data = i2c_get_clientdata(client);
906 u32 val, tmp;
907
908 val = simple_strtoul(buf, NULL, 10);
909
910 down(&data->update_lock);
911
912 switch (val) {
913 case 1: /* PII/Celeron diode */
914 tmp = w83627hf_read_value(client, W83781D_REG_SCFG1);
915 w83627hf_write_value(client, W83781D_REG_SCFG1,
916 tmp | BIT_SCFG1[nr - 1]);
917 tmp = w83627hf_read_value(client, W83781D_REG_SCFG2);
918 w83627hf_write_value(client, W83781D_REG_SCFG2,
919 tmp | BIT_SCFG2[nr - 1]);
920 data->sens[nr - 1] = val;
921 break;
922 case 2: /* 3904 */
923 tmp = w83627hf_read_value(client, W83781D_REG_SCFG1);
924 w83627hf_write_value(client, W83781D_REG_SCFG1,
925 tmp | BIT_SCFG1[nr - 1]);
926 tmp = w83627hf_read_value(client, W83781D_REG_SCFG2);
927 w83627hf_write_value(client, W83781D_REG_SCFG2,
928 tmp & ~BIT_SCFG2[nr - 1]);
929 data->sens[nr - 1] = val;
930 break;
931 case W83781D_DEFAULT_BETA: /* thermistor */
932 tmp = w83627hf_read_value(client, W83781D_REG_SCFG1);
933 w83627hf_write_value(client, W83781D_REG_SCFG1,
934 tmp & ~BIT_SCFG1[nr - 1]);
935 data->sens[nr - 1] = val;
936 break;
937 default:
938 dev_err(&client->dev,
939 "Invalid sensor type %ld; must be 1, 2, or %d\n",
940 (long) val, W83781D_DEFAULT_BETA);
941 break;
942 }
943
944 up(&data->update_lock);
945 return count;
946 }
947
948 #define sysfs_sensor(offset) \
949 static ssize_t show_regs_sensor_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
950 { \
951 return show_sensor_reg(dev, buf, offset); \
952 } \
953 static ssize_t \
954 store_regs_sensor_##offset (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
955 { \
956 return store_sensor_reg(dev, buf, count, offset); \
957 } \
958 static DEVICE_ATTR(temp##offset##_type, S_IRUGO | S_IWUSR, \
959 show_regs_sensor_##offset, store_regs_sensor_##offset);
960
961 sysfs_sensor(1);
962 sysfs_sensor(2);
963 sysfs_sensor(3);
964
965 #define device_create_file_sensor(client, offset) \
966 do { \
967 device_create_file(&client->dev, &dev_attr_temp##offset##_type); \
968 } while (0)
969
970
971 static int __init w83627hf_find(int sioaddr, unsigned short *addr)
972 {
973 u16 val;
974
975 REG = sioaddr;
976 VAL = sioaddr + 1;
977
978 superio_enter();
979 val= superio_inb(DEVID);
980 if(val != W627_DEVID &&
981 val != W627THF_DEVID &&
982 val != W697_DEVID &&
983 val != W637_DEVID) {
984 superio_exit();
985 return -ENODEV;
986 }
987
988 superio_select(W83627HF_LD_HWM);
989 val = (superio_inb(WINB_BASE_REG) << 8) |
990 superio_inb(WINB_BASE_REG + 1);
991 *addr = val & WINB_ALIGNMENT;
992 if (*addr == 0 && force_addr == 0) {
993 superio_exit();
994 return -ENODEV;
995 }
996
997 superio_exit();
998 return 0;
999 }
1000
1001 static int w83627hf_detect(struct i2c_adapter *adapter)
1002 {
1003 int val, kind;
1004 struct i2c_client *new_client;
1005 struct w83627hf_data *data;
1006 int err = 0;
1007 const char *client_name = "";
1008
1009 if(force_addr)
1010 address = force_addr & WINB_ALIGNMENT;
1011
1012 if (!request_region(address + WINB_REGION_OFFSET, WINB_REGION_SIZE,
1013 w83627hf_driver.driver.name)) {
1014 err = -EBUSY;
1015 goto ERROR0;
1016 }
1017
1018 if(force_addr) {
1019 printk("w83627hf.o: forcing ISA address 0x%04X\n", address);
1020 superio_enter();
1021 superio_select(W83627HF_LD_HWM);
1022 superio_outb(WINB_BASE_REG, address >> 8);
1023 superio_outb(WINB_BASE_REG+1, address & 0xff);
1024 superio_exit();
1025 }
1026
1027 superio_enter();
1028 val= superio_inb(DEVID);
1029 if(val == W627_DEVID)
1030 kind = w83627hf;
1031 else if(val == W697_DEVID)
1032 kind = w83697hf;
1033 else if(val == W627THF_DEVID)
1034 kind = w83627thf;
1035 else if(val == W637_DEVID)
1036 kind = w83637hf;
1037 else {
1038 dev_info(&adapter->dev,
1039 "Unsupported chip (dev_id=0x%02X).\n", val);
1040 goto ERROR1;
1041 }
1042
1043 superio_select(W83627HF_LD_HWM);
1044 if((val = 0x01 & superio_inb(WINB_ACT_REG)) == 0)
1045 superio_outb(WINB_ACT_REG, 1);
1046 superio_exit();
1047
1048 /* OK. For now, we presume we have a valid client. We now create the
1049 client structure, even though we cannot fill it completely yet.
1050 But it allows us to access w83627hf_{read,write}_value. */
1051
1052 if (!(data = kzalloc(sizeof(struct w83627hf_data), GFP_KERNEL))) {
1053 err = -ENOMEM;
1054 goto ERROR1;
1055 }
1056
1057 new_client = &data->client;
1058 i2c_set_clientdata(new_client, data);
1059 new_client->addr = address;
1060 init_MUTEX(&data->lock);
1061 new_client->adapter = adapter;
1062 new_client->driver = &w83627hf_driver;
1063 new_client->flags = 0;
1064
1065
1066 if (kind == w83627hf) {
1067 client_name = "w83627hf";
1068 } else if (kind == w83627thf) {
1069 client_name = "w83627thf";
1070 } else if (kind == w83697hf) {
1071 client_name = "w83697hf";
1072 } else if (kind == w83637hf) {
1073 client_name = "w83637hf";
1074 }
1075
1076 /* Fill in the remaining client fields and put into the global list */
1077 strlcpy(new_client->name, client_name, I2C_NAME_SIZE);
1078 data->type = kind;
1079 data->valid = 0;
1080 init_MUTEX(&data->update_lock);
1081
1082 /* Tell the I2C layer a new client has arrived */
1083 if ((err = i2c_attach_client(new_client)))
1084 goto ERROR2;
1085
1086 data->lm75 = NULL;
1087
1088 /* Initialize the chip */
1089 w83627hf_init_client(new_client);
1090
1091 /* A few vars need to be filled upon startup */
1092 data->fan_min[0] = w83627hf_read_value(new_client, W83781D_REG_FAN_MIN(1));
1093 data->fan_min[1] = w83627hf_read_value(new_client, W83781D_REG_FAN_MIN(2));
1094 data->fan_min[2] = w83627hf_read_value(new_client, W83781D_REG_FAN_MIN(3));
1095
1096 /* Register sysfs hooks */
1097 data->class_dev = hwmon_device_register(&new_client->dev);
1098 if (IS_ERR(data->class_dev)) {
1099 err = PTR_ERR(data->class_dev);
1100 goto ERROR3;
1101 }
1102
1103 device_create_file_in(new_client, 0);
1104 if (kind != w83697hf)
1105 device_create_file_in(new_client, 1);
1106 device_create_file_in(new_client, 2);
1107 device_create_file_in(new_client, 3);
1108 device_create_file_in(new_client, 4);
1109 if (kind != w83627thf && kind != w83637hf) {
1110 device_create_file_in(new_client, 5);
1111 device_create_file_in(new_client, 6);
1112 }
1113 device_create_file_in(new_client, 7);
1114 device_create_file_in(new_client, 8);
1115
1116 device_create_file_fan(new_client, 1);
1117 device_create_file_fan(new_client, 2);
1118 if (kind != w83697hf)
1119 device_create_file_fan(new_client, 3);
1120
1121 device_create_file_temp(new_client, 1);
1122 device_create_file_temp(new_client, 2);
1123 if (kind != w83697hf)
1124 device_create_file_temp(new_client, 3);
1125
1126 if (kind != w83697hf && data->vid != 0xff) {
1127 device_create_file_vid(new_client);
1128 device_create_file_vrm(new_client);
1129 }
1130
1131 device_create_file_fan_div(new_client, 1);
1132 device_create_file_fan_div(new_client, 2);
1133 if (kind != w83697hf)
1134 device_create_file_fan_div(new_client, 3);
1135
1136 device_create_file_alarms(new_client);
1137
1138 device_create_file_beep(new_client);
1139
1140 device_create_file_pwm(new_client, 1);
1141 device_create_file_pwm(new_client, 2);
1142 if (kind == w83627thf || kind == w83637hf)
1143 device_create_file_pwm(new_client, 3);
1144
1145 device_create_file_sensor(new_client, 1);
1146 device_create_file_sensor(new_client, 2);
1147 if (kind != w83697hf)
1148 device_create_file_sensor(new_client, 3);
1149
1150 return 0;
1151
1152 ERROR3:
1153 i2c_detach_client(new_client);
1154 ERROR2:
1155 kfree(data);
1156 ERROR1:
1157 release_region(address + WINB_REGION_OFFSET, WINB_REGION_SIZE);
1158 ERROR0:
1159 return err;
1160 }
1161
1162 static int w83627hf_detach_client(struct i2c_client *client)
1163 {
1164 struct w83627hf_data *data = i2c_get_clientdata(client);
1165 int err;
1166
1167 hwmon_device_unregister(data->class_dev);
1168
1169 if ((err = i2c_detach_client(client)))
1170 return err;
1171
1172 release_region(client->addr + WINB_REGION_OFFSET, WINB_REGION_SIZE);
1173 kfree(data);
1174
1175 return 0;
1176 }
1177
1178
1179 /*
1180 ISA access must always be locked explicitly!
1181 We ignore the W83781D BUSY flag at this moment - it could lead to deadlocks,
1182 would slow down the W83781D access and should not be necessary.
1183 There are some ugly typecasts here, but the good news is - they should
1184 nowhere else be necessary! */
1185 static int w83627hf_read_value(struct i2c_client *client, u16 reg)
1186 {
1187 struct w83627hf_data *data = i2c_get_clientdata(client);
1188 int res, word_sized;
1189
1190 down(&data->lock);
1191 word_sized = (((reg & 0xff00) == 0x100)
1192 || ((reg & 0xff00) == 0x200))
1193 && (((reg & 0x00ff) == 0x50)
1194 || ((reg & 0x00ff) == 0x53)
1195 || ((reg & 0x00ff) == 0x55));
1196 if (reg & 0xff00) {
1197 outb_p(W83781D_REG_BANK,
1198 client->addr + W83781D_ADDR_REG_OFFSET);
1199 outb_p(reg >> 8,
1200 client->addr + W83781D_DATA_REG_OFFSET);
1201 }
1202 outb_p(reg & 0xff, client->addr + W83781D_ADDR_REG_OFFSET);
1203 res = inb_p(client->addr + W83781D_DATA_REG_OFFSET);
1204 if (word_sized) {
1205 outb_p((reg & 0xff) + 1,
1206 client->addr + W83781D_ADDR_REG_OFFSET);
1207 res =
1208 (res << 8) + inb_p(client->addr +
1209 W83781D_DATA_REG_OFFSET);
1210 }
1211 if (reg & 0xff00) {
1212 outb_p(W83781D_REG_BANK,
1213 client->addr + W83781D_ADDR_REG_OFFSET);
1214 outb_p(0, client->addr + W83781D_DATA_REG_OFFSET);
1215 }
1216 up(&data->lock);
1217 return res;
1218 }
1219
1220 static int w83627thf_read_gpio5(struct i2c_client *client)
1221 {
1222 int res = 0xff, sel;
1223
1224 superio_enter();
1225 superio_select(W83627HF_LD_GPIO5);
1226
1227 /* Make sure these GPIO pins are enabled */
1228 if (!(superio_inb(W83627THF_GPIO5_EN) & (1<<3))) {
1229 dev_dbg(&client->dev, "GPIO5 disabled, no VID function\n");
1230 goto exit;
1231 }
1232
1233 /* Make sure the pins are configured for input
1234 There must be at least five (VRM 9), and possibly 6 (VRM 10) */
1235 sel = superio_inb(W83627THF_GPIO5_IOSR) & 0x3f;
1236 if ((sel & 0x1f) != 0x1f) {
1237 dev_dbg(&client->dev, "GPIO5 not configured for VID "
1238 "function\n");
1239 goto exit;
1240 }
1241
1242 dev_info(&client->dev, "Reading VID from GPIO5\n");
1243 res = superio_inb(W83627THF_GPIO5_DR) & sel;
1244
1245 exit:
1246 superio_exit();
1247 return res;
1248 }
1249
1250 static int w83627hf_write_value(struct i2c_client *client, u16 reg, u16 value)
1251 {
1252 struct w83627hf_data *data = i2c_get_clientdata(client);
1253 int word_sized;
1254
1255 down(&data->lock);
1256 word_sized = (((reg & 0xff00) == 0x100)
1257 || ((reg & 0xff00) == 0x200))
1258 && (((reg & 0x00ff) == 0x53)
1259 || ((reg & 0x00ff) == 0x55));
1260 if (reg & 0xff00) {
1261 outb_p(W83781D_REG_BANK,
1262 client->addr + W83781D_ADDR_REG_OFFSET);
1263 outb_p(reg >> 8,
1264 client->addr + W83781D_DATA_REG_OFFSET);
1265 }
1266 outb_p(reg & 0xff, client->addr + W83781D_ADDR_REG_OFFSET);
1267 if (word_sized) {
1268 outb_p(value >> 8,
1269 client->addr + W83781D_DATA_REG_OFFSET);
1270 outb_p((reg & 0xff) + 1,
1271 client->addr + W83781D_ADDR_REG_OFFSET);
1272 }
1273 outb_p(value & 0xff,
1274 client->addr + W83781D_DATA_REG_OFFSET);
1275 if (reg & 0xff00) {
1276 outb_p(W83781D_REG_BANK,
1277 client->addr + W83781D_ADDR_REG_OFFSET);
1278 outb_p(0, client->addr + W83781D_DATA_REG_OFFSET);
1279 }
1280 up(&data->lock);
1281 return 0;
1282 }
1283
1284 static void w83627hf_init_client(struct i2c_client *client)
1285 {
1286 struct w83627hf_data *data = i2c_get_clientdata(client);
1287 int i;
1288 int type = data->type;
1289 u8 tmp;
1290
1291 if (reset) {
1292 /* Resetting the chip has been the default for a long time,
1293 but repeatedly caused problems (fans going to full
1294 speed...) so it is now optional. It might even go away if
1295 nobody reports it as being useful, as I see very little
1296 reason why this would be needed at all. */
1297 dev_info(&client->dev, "If reset=1 solved a problem you were "
1298 "having, please report!\n");
1299
1300 /* save this register */
1301 i = w83627hf_read_value(client, W83781D_REG_BEEP_CONFIG);
1302 /* Reset all except Watchdog values and last conversion values
1303 This sets fan-divs to 2, among others */
1304 w83627hf_write_value(client, W83781D_REG_CONFIG, 0x80);
1305 /* Restore the register and disable power-on abnormal beep.
1306 This saves FAN 1/2/3 input/output values set by BIOS. */
1307 w83627hf_write_value(client, W83781D_REG_BEEP_CONFIG, i | 0x80);
1308 /* Disable master beep-enable (reset turns it on).
1309 Individual beeps should be reset to off but for some reason
1310 disabling this bit helps some people not get beeped */
1311 w83627hf_write_value(client, W83781D_REG_BEEP_INTS2, 0);
1312 }
1313
1314 /* Minimize conflicts with other winbond i2c-only clients... */
1315 /* disable i2c subclients... how to disable main i2c client?? */
1316 /* force i2c address to relatively uncommon address */
1317 w83627hf_write_value(client, W83781D_REG_I2C_SUBADDR, 0x89);
1318 w83627hf_write_value(client, W83781D_REG_I2C_ADDR, force_i2c);
1319
1320 /* Read VID only once */
1321 if (w83627hf == data->type || w83637hf == data->type) {
1322 int lo = w83627hf_read_value(client, W83781D_REG_VID_FANDIV);
1323 int hi = w83627hf_read_value(client, W83781D_REG_CHIPID);
1324 data->vid = (lo & 0x0f) | ((hi & 0x01) << 4);
1325 } else if (w83627thf == data->type) {
1326 data->vid = w83627thf_read_gpio5(client);
1327 }
1328
1329 /* Read VRM & OVT Config only once */
1330 if (w83627thf == data->type || w83637hf == data->type) {
1331 data->vrm_ovt =
1332 w83627hf_read_value(client, W83627THF_REG_VRM_OVT_CFG);
1333 }
1334
1335 /* Convert VID to voltage based on VRM */
1336 data->vrm = vid_which_vrm();
1337
1338 tmp = w83627hf_read_value(client, W83781D_REG_SCFG1);
1339 for (i = 1; i <= 3; i++) {
1340 if (!(tmp & BIT_SCFG1[i - 1])) {
1341 data->sens[i - 1] = W83781D_DEFAULT_BETA;
1342 } else {
1343 if (w83627hf_read_value
1344 (client,
1345 W83781D_REG_SCFG2) & BIT_SCFG2[i - 1])
1346 data->sens[i - 1] = 1;
1347 else
1348 data->sens[i - 1] = 2;
1349 }
1350 if ((type == w83697hf) && (i == 2))
1351 break;
1352 }
1353
1354 if(init) {
1355 /* Enable temp2 */
1356 tmp = w83627hf_read_value(client, W83781D_REG_TEMP2_CONFIG);
1357 if (tmp & 0x01) {
1358 dev_warn(&client->dev, "Enabling temp2, readings "
1359 "might not make sense\n");
1360 w83627hf_write_value(client, W83781D_REG_TEMP2_CONFIG,
1361 tmp & 0xfe);
1362 }
1363
1364 /* Enable temp3 */
1365 if (type != w83697hf) {
1366 tmp = w83627hf_read_value(client,
1367 W83781D_REG_TEMP3_CONFIG);
1368 if (tmp & 0x01) {
1369 dev_warn(&client->dev, "Enabling temp3, "
1370 "readings might not make sense\n");
1371 w83627hf_write_value(client,
1372 W83781D_REG_TEMP3_CONFIG, tmp & 0xfe);
1373 }
1374 }
1375 }
1376
1377 /* Start monitoring */
1378 w83627hf_write_value(client, W83781D_REG_CONFIG,
1379 (w83627hf_read_value(client,
1380 W83781D_REG_CONFIG) & 0xf7)
1381 | 0x01);
1382 }
1383
1384 static struct w83627hf_data *w83627hf_update_device(struct device *dev)
1385 {
1386 struct i2c_client *client = to_i2c_client(dev);
1387 struct w83627hf_data *data = i2c_get_clientdata(client);
1388 int i;
1389
1390 down(&data->update_lock);
1391
1392 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1393 || !data->valid) {
1394 for (i = 0; i <= 8; i++) {
1395 /* skip missing sensors */
1396 if (((data->type == w83697hf) && (i == 1)) ||
1397 ((data->type == w83627thf || data->type == w83637hf)
1398 && (i == 5 || i == 6)))
1399 continue;
1400 data->in[i] =
1401 w83627hf_read_value(client, W83781D_REG_IN(i));
1402 data->in_min[i] =
1403 w83627hf_read_value(client,
1404 W83781D_REG_IN_MIN(i));
1405 data->in_max[i] =
1406 w83627hf_read_value(client,
1407 W83781D_REG_IN_MAX(i));
1408 }
1409 for (i = 1; i <= 3; i++) {
1410 data->fan[i - 1] =
1411 w83627hf_read_value(client, W83781D_REG_FAN(i));
1412 data->fan_min[i - 1] =
1413 w83627hf_read_value(client,
1414 W83781D_REG_FAN_MIN(i));
1415 }
1416 for (i = 1; i <= 3; i++) {
1417 u8 tmp = w83627hf_read_value(client,
1418 W836X7HF_REG_PWM(data->type, i));
1419 /* bits 0-3 are reserved in 627THF */
1420 if (data->type == w83627thf)
1421 tmp &= 0xf0;
1422 data->pwm[i - 1] = tmp;
1423 if(i == 2 &&
1424 (data->type == w83627hf || data->type == w83697hf))
1425 break;
1426 }
1427
1428 data->temp = w83627hf_read_value(client, W83781D_REG_TEMP(1));
1429 data->temp_max =
1430 w83627hf_read_value(client, W83781D_REG_TEMP_OVER(1));
1431 data->temp_max_hyst =
1432 w83627hf_read_value(client, W83781D_REG_TEMP_HYST(1));
1433 data->temp_add[0] =
1434 w83627hf_read_value(client, W83781D_REG_TEMP(2));
1435 data->temp_max_add[0] =
1436 w83627hf_read_value(client, W83781D_REG_TEMP_OVER(2));
1437 data->temp_max_hyst_add[0] =
1438 w83627hf_read_value(client, W83781D_REG_TEMP_HYST(2));
1439 if (data->type != w83697hf) {
1440 data->temp_add[1] =
1441 w83627hf_read_value(client, W83781D_REG_TEMP(3));
1442 data->temp_max_add[1] =
1443 w83627hf_read_value(client, W83781D_REG_TEMP_OVER(3));
1444 data->temp_max_hyst_add[1] =
1445 w83627hf_read_value(client, W83781D_REG_TEMP_HYST(3));
1446 }
1447
1448 i = w83627hf_read_value(client, W83781D_REG_VID_FANDIV);
1449 data->fan_div[0] = (i >> 4) & 0x03;
1450 data->fan_div[1] = (i >> 6) & 0x03;
1451 if (data->type != w83697hf) {
1452 data->fan_div[2] = (w83627hf_read_value(client,
1453 W83781D_REG_PIN) >> 6) & 0x03;
1454 }
1455 i = w83627hf_read_value(client, W83781D_REG_VBAT);
1456 data->fan_div[0] |= (i >> 3) & 0x04;
1457 data->fan_div[1] |= (i >> 4) & 0x04;
1458 if (data->type != w83697hf)
1459 data->fan_div[2] |= (i >> 5) & 0x04;
1460 data->alarms =
1461 w83627hf_read_value(client, W83781D_REG_ALARM1) |
1462 (w83627hf_read_value(client, W83781D_REG_ALARM2) << 8) |
1463 (w83627hf_read_value(client, W83781D_REG_ALARM3) << 16);
1464 i = w83627hf_read_value(client, W83781D_REG_BEEP_INTS2);
1465 data->beep_enable = i >> 7;
1466 data->beep_mask = ((i & 0x7f) << 8) |
1467 w83627hf_read_value(client, W83781D_REG_BEEP_INTS1) |
1468 w83627hf_read_value(client, W83781D_REG_BEEP_INTS3) << 16;
1469 data->last_updated = jiffies;
1470 data->valid = 1;
1471 }
1472
1473 up(&data->update_lock);
1474
1475 return data;
1476 }
1477
1478 static int __init sensors_w83627hf_init(void)
1479 {
1480 if (w83627hf_find(0x2e, &address)
1481 && w83627hf_find(0x4e, &address)) {
1482 return -ENODEV;
1483 }
1484
1485 return i2c_isa_add_driver(&w83627hf_driver);
1486 }
1487
1488 static void __exit sensors_w83627hf_exit(void)
1489 {
1490 i2c_isa_del_driver(&w83627hf_driver);
1491 }
1492
1493 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
1494 "Philip Edelbrock <phil@netroedge.com>, "
1495 "and Mark Studebaker <mdsxyz123@yahoo.com>");
1496 MODULE_DESCRIPTION("W83627HF driver");
1497 MODULE_LICENSE("GPL");
1498
1499 module_init(sensors_w83627hf_init);
1500 module_exit(sensors_w83627hf_exit);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree