projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[deliverable/linux.git] / drivers / hwmon / w83627hf.c
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 Copyright (c) 2007 Jean Delvare <khali@linux-fr.org>
9
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.
14
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.
19
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.
23 */
24
25 /*
26 Supports following chips:
27
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)
34
35 For other winbond chips, and for i2c support in the above chips,
36 use w83781d.c.
37
38 Note: automatic ("cruise") fan control for 697, 637 & 627thf not
39 supported yet.
40 */
41
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-vid.h>
49 #include <linux/err.h>
50 #include <linux/mutex.h>
51 #include <linux/ioport.h>
52 #include <asm/io.h>
53 #include "lm75.h"
54
55 static struct platform_device *pdev;
56
57 #define DRVNAME "w83627hf"
58 enum chips { w83627hf, w83627thf, w83697hf, w83637hf, w83687thf };
59
60 static u16 force_addr;
61 module_param(force_addr, ushort, 0);
62 MODULE_PARM_DESC(force_addr,
63 "Initialize the base address of the sensors");
64 static u8 force_i2c = 0x1f;
65 module_param(force_i2c, byte, 0);
66 MODULE_PARM_DESC(force_i2c,
67 "Initialize the i2c address of the sensors");
68
69 static int reset;
70 module_param(reset, bool, 0);
71 MODULE_PARM_DESC(reset, "Set to one to reset chip on load");
72
73 static int init = 1;
74 module_param(init, bool, 0);
75 MODULE_PARM_DESC(init, "Set to zero to bypass chip initialization");
76
77 /* modified from kernel/include/traps.c */
78 static int REG; /* The register to read/write */
79 #define DEV 0x07 /* Register: Logical device select */
80 static int VAL; /* The value to read/write */
81
82 /* logical device numbers for superio_select (below) */
83 #define W83627HF_LD_FDC 0x00
84 #define W83627HF_LD_PRT 0x01
85 #define W83627HF_LD_UART1 0x02
86 #define W83627HF_LD_UART2 0x03
87 #define W83627HF_LD_KBC 0x05
88 #define W83627HF_LD_CIR 0x06 /* w83627hf only */
89 #define W83627HF_LD_GAME 0x07
90 #define W83627HF_LD_MIDI 0x07
91 #define W83627HF_LD_GPIO1 0x07
92 #define W83627HF_LD_GPIO5 0x07 /* w83627thf only */
93 #define W83627HF_LD_GPIO2 0x08
94 #define W83627HF_LD_GPIO3 0x09
95 #define W83627HF_LD_GPIO4 0x09 /* w83627thf only */
96 #define W83627HF_LD_ACPI 0x0a
97 #define W83627HF_LD_HWM 0x0b
98
99 #define DEVID 0x20 /* Register: Device ID */
100
101 #define W83627THF_GPIO5_EN 0x30 /* w83627thf only */
102 #define W83627THF_GPIO5_IOSR 0xf3 /* w83627thf only */
103 #define W83627THF_GPIO5_DR 0xf4 /* w83627thf only */
104
105 #define W83687THF_VID_EN 0x29 /* w83687thf only */
106 #define W83687THF_VID_CFG 0xF0 /* w83687thf only */
107 #define W83687THF_VID_DATA 0xF1 /* w83687thf only */
108
109 static inline void
110 superio_outb(int reg, int val)
111 {
112 outb(reg, REG);
113 outb(val, VAL);
114 }
115
116 static inline int
117 superio_inb(int reg)
118 {
119 outb(reg, REG);
120 return inb(VAL);
121 }
122
123 static inline void
124 superio_select(int ld)
125 {
126 outb(DEV, REG);
127 outb(ld, VAL);
128 }
129
130 static inline void
131 superio_enter(void)
132 {
133 outb(0x87, REG);
134 outb(0x87, REG);
135 }
136
137 static inline void
138 superio_exit(void)
139 {
140 outb(0xAA, REG);
141 }
142
143 #define W627_DEVID 0x52
144 #define W627THF_DEVID 0x82
145 #define W697_DEVID 0x60
146 #define W637_DEVID 0x70
147 #define W687THF_DEVID 0x85
148 #define WINB_ACT_REG 0x30
149 #define WINB_BASE_REG 0x60
150 /* Constants specified below */
151
152 /* Alignment of the base address */
153 #define WINB_ALIGNMENT ~7
154
155 /* Offset & size of I/O region we are interested in */
156 #define WINB_REGION_OFFSET 5
157 #define WINB_REGION_SIZE 2
158
159 /* Where are the sensors address/data registers relative to the region offset */
160 #define W83781D_ADDR_REG_OFFSET 0
161 #define W83781D_DATA_REG_OFFSET 1
162
163 /* The W83781D registers */
164 /* The W83782D registers for nr=7,8 are in bank 5 */
165 #define W83781D_REG_IN_MAX(nr) ((nr < 7) ? (0x2b + (nr) * 2) : \
166 (0x554 + (((nr) - 7) * 2)))
167 #define W83781D_REG_IN_MIN(nr) ((nr < 7) ? (0x2c + (nr) * 2) : \
168 (0x555 + (((nr) - 7) * 2)))
169 #define W83781D_REG_IN(nr) ((nr < 7) ? (0x20 + (nr)) : \
170 (0x550 + (nr) - 7))
171
172 #define W83781D_REG_FAN_MIN(nr) (0x3a + (nr))
173 #define W83781D_REG_FAN(nr) (0x27 + (nr))
174
175 #define W83781D_REG_TEMP2_CONFIG 0x152
176 #define W83781D_REG_TEMP3_CONFIG 0x252
177 #define W83781D_REG_TEMP(nr) ((nr == 3) ? (0x0250) : \
178 ((nr == 2) ? (0x0150) : \
179 (0x27)))
180 #define W83781D_REG_TEMP_HYST(nr) ((nr == 3) ? (0x253) : \
181 ((nr == 2) ? (0x153) : \
182 (0x3A)))
183 #define W83781D_REG_TEMP_OVER(nr) ((nr == 3) ? (0x255) : \
184 ((nr == 2) ? (0x155) : \
185 (0x39)))
186
187 #define W83781D_REG_BANK 0x4E
188
189 #define W83781D_REG_CONFIG 0x40
190 #define W83781D_REG_ALARM1 0x459
191 #define W83781D_REG_ALARM2 0x45A
192 #define W83781D_REG_ALARM3 0x45B
193
194 #define W83781D_REG_BEEP_CONFIG 0x4D
195 #define W83781D_REG_BEEP_INTS1 0x56
196 #define W83781D_REG_BEEP_INTS2 0x57
197 #define W83781D_REG_BEEP_INTS3 0x453
198
199 #define W83781D_REG_VID_FANDIV 0x47
200
201 #define W83781D_REG_CHIPID 0x49
202 #define W83781D_REG_WCHIPID 0x58
203 #define W83781D_REG_CHIPMAN 0x4F
204 #define W83781D_REG_PIN 0x4B
205
206 #define W83781D_REG_VBAT 0x5D
207
208 #define W83627HF_REG_PWM1 0x5A
209 #define W83627HF_REG_PWM2 0x5B
210
211 #define W83627THF_REG_PWM1 0x01 /* 697HF/637HF/687THF too */
212 #define W83627THF_REG_PWM2 0x03 /* 697HF/637HF/687THF too */
213 #define W83627THF_REG_PWM3 0x11 /* 637HF/687THF too */
214
215 #define W83627THF_REG_VRM_OVT_CFG 0x18 /* 637HF/687THF too */
216
217 static const u8 regpwm_627hf[] = { W83627HF_REG_PWM1, W83627HF_REG_PWM2 };
218 static const u8 regpwm[] = { W83627THF_REG_PWM1, W83627THF_REG_PWM2,
219 W83627THF_REG_PWM3 };
220 #define W836X7HF_REG_PWM(type, nr) (((type) == w83627hf) ? \
221 regpwm_627hf[(nr) - 1] : regpwm[(nr) - 1])
222
223 #define W83627HF_REG_PWM_FREQ 0x5C /* Only for the 627HF */
224
225 #define W83637HF_REG_PWM_FREQ1 0x00 /* 697HF/687THF too */
226 #define W83637HF_REG_PWM_FREQ2 0x02 /* 697HF/687THF too */
227 #define W83637HF_REG_PWM_FREQ3 0x10 /* 687THF too */
228
229 static const u8 W83637HF_REG_PWM_FREQ[] = { W83637HF_REG_PWM_FREQ1,
230 W83637HF_REG_PWM_FREQ2,
231 W83637HF_REG_PWM_FREQ3 };
232
233 #define W83627HF_BASE_PWM_FREQ 46870
234
235 #define W83781D_REG_I2C_ADDR 0x48
236 #define W83781D_REG_I2C_SUBADDR 0x4A
237
238 /* Sensor selection */
239 #define W83781D_REG_SCFG1 0x5D
240 static const u8 BIT_SCFG1[] = { 0x02, 0x04, 0x08 };
241 #define W83781D_REG_SCFG2 0x59
242 static const u8 BIT_SCFG2[] = { 0x10, 0x20, 0x40 };
243 #define W83781D_DEFAULT_BETA 3435
244
245 /* Conversions. Limit checking is only done on the TO_REG
246 variants. Note that you should be a bit careful with which arguments
247 these macros are called: arguments may be evaluated more than once.
248 Fixing this is just not worth it. */
249 #define IN_TO_REG(val) (SENSORS_LIMIT((((val) + 8)/16),0,255))
250 #define IN_FROM_REG(val) ((val) * 16)
251
252 static inline u8 FAN_TO_REG(long rpm, int div)
253 {
254 if (rpm == 0)
255 return 255;
256 rpm = SENSORS_LIMIT(rpm, 1, 1000000);
257 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
258 254);
259 }
260
261 #define TEMP_MIN (-128000)
262 #define TEMP_MAX ( 127000)
263
264 /* TEMP: 0.001C/bit (-128C to +127C)
265 REG: 1C/bit, two's complement */
266 static u8 TEMP_TO_REG(int temp)
267 {
268 int ntemp = SENSORS_LIMIT(temp, TEMP_MIN, TEMP_MAX);
269 ntemp += (ntemp<0 ? -500 : 500);
270 return (u8)(ntemp / 1000);
271 }
272
273 static int TEMP_FROM_REG(u8 reg)
274 {
275 return (s8)reg * 1000;
276 }
277
278 #define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
279
280 #define PWM_TO_REG(val) (SENSORS_LIMIT((val),0,255))
281
282 static inline unsigned long pwm_freq_from_reg_627hf(u8 reg)
283 {
284 unsigned long freq;
285 freq = W83627HF_BASE_PWM_FREQ >> reg;
286 return freq;
287 }
288 static inline u8 pwm_freq_to_reg_627hf(unsigned long val)
289 {
290 u8 i;
291 /* Only 5 dividers (1 2 4 8 16)
292 Search for the nearest available frequency */
293 for (i = 0; i < 4; i++) {
294 if (val > (((W83627HF_BASE_PWM_FREQ >> i) +
295 (W83627HF_BASE_PWM_FREQ >> (i+1))) / 2))
296 break;
297 }
298 return i;
299 }
300
301 static inline unsigned long pwm_freq_from_reg(u8 reg)
302 {
303 /* Clock bit 8 -> 180 kHz or 24 MHz */
304 unsigned long clock = (reg & 0x80) ? 180000UL : 24000000UL;
305
306 reg &= 0x7f;
307 /* This should not happen but anyway... */
308 if (reg == 0)
309 reg++;
310 return (clock / (reg << 8));
311 }
312 static inline u8 pwm_freq_to_reg(unsigned long val)
313 {
314 /* Minimum divider value is 0x01 and maximum is 0x7F */
315 if (val >= 93750) /* The highest we can do */
316 return 0x01;
317 if (val >= 720) /* Use 24 MHz clock */
318 return (24000000UL / (val << 8));
319 if (val < 6) /* The lowest we can do */
320 return 0xFF;
321 else /* Use 180 kHz clock */
322 return (0x80 | (180000UL / (val << 8)));
323 }
324
325 #define BEEP_MASK_FROM_REG(val) (val)
326 #define BEEP_MASK_TO_REG(val) ((val) & 0xffffff)
327 #define BEEP_ENABLE_TO_REG(val) ((val)?1:0)
328 #define BEEP_ENABLE_FROM_REG(val) ((val)?1:0)
329
330 #define DIV_FROM_REG(val) (1 << (val))
331
332 static inline u8 DIV_TO_REG(long val)
333 {
334 int i;
335 val = SENSORS_LIMIT(val, 1, 128) >> 1;
336 for (i = 0; i < 7; i++) {
337 if (val == 0)
338 break;
339 val >>= 1;
340 }
341 return ((u8) i);
342 }
343
344 /* For each registered chip, we need to keep some data in memory.
345 The structure is dynamically allocated. */
346 struct w83627hf_data {
347 unsigned short addr;
348 const char *name;
349 struct class_device *class_dev;
350 struct mutex lock;
351 enum chips type;
352
353 struct mutex update_lock;
354 char valid; /* !=0 if following fields are valid */
355 unsigned long last_updated; /* In jiffies */
356
357 u8 in[9]; /* Register value */
358 u8 in_max[9]; /* Register value */
359 u8 in_min[9]; /* Register value */
360 u8 fan[3]; /* Register value */
361 u8 fan_min[3]; /* Register value */
362 u8 temp;
363 u8 temp_max; /* Register value */
364 u8 temp_max_hyst; /* Register value */
365 u16 temp_add[2]; /* Register value */
366 u16 temp_max_add[2]; /* Register value */
367 u16 temp_max_hyst_add[2]; /* Register value */
368 u8 fan_div[3]; /* Register encoding, shifted right */
369 u8 vid; /* Register encoding, combined */
370 u32 alarms; /* Register encoding, combined */
371 u32 beep_mask; /* Register encoding, combined */
372 u8 beep_enable; /* Boolean */
373 u8 pwm[3]; /* Register value */
374 u8 pwm_freq[3]; /* Register value */
375 u16 sens[3]; /* 782D/783S only.
376 1 = pentium diode; 2 = 3904 diode;
377 3000-5000 = thermistor beta.
378 Default = 3435.
379 Other Betas unimplemented */
380 u8 vrm;
381 u8 vrm_ovt; /* Register value, 627THF/637HF/687THF only */
382 };
383
384 struct w83627hf_sio_data {
385 enum chips type;
386 };
387
388
389 static int w83627hf_probe(struct platform_device *pdev);
390 static int w83627hf_remove(struct platform_device *pdev);
391
392 static int w83627hf_read_value(struct w83627hf_data *data, u16 reg);
393 static int w83627hf_write_value(struct w83627hf_data *data, u16 reg, u16 value);
394 static struct w83627hf_data *w83627hf_update_device(struct device *dev);
395 static void w83627hf_init_device(struct platform_device *pdev);
396
397 static struct platform_driver w83627hf_driver = {
398 .driver = {
399 .owner = THIS_MODULE,
400 .name = DRVNAME,
401 },
402 .probe = w83627hf_probe,
403 .remove = __devexit_p(w83627hf_remove),
404 };
405
406 /* following are the sysfs callback functions */
407 #define show_in_reg(reg) \
408 static ssize_t show_##reg (struct device *dev, char *buf, int nr) \
409 { \
410 struct w83627hf_data *data = w83627hf_update_device(dev); \
411 return sprintf(buf,"%ld\n", (long)IN_FROM_REG(data->reg[nr])); \
412 }
413 show_in_reg(in)
414 show_in_reg(in_min)
415 show_in_reg(in_max)
416
417 #define store_in_reg(REG, reg) \
418 static ssize_t \
419 store_in_##reg (struct device *dev, const char *buf, size_t count, int nr) \
420 { \
421 struct w83627hf_data *data = dev_get_drvdata(dev); \
422 u32 val; \
423 \
424 val = simple_strtoul(buf, NULL, 10); \
425 \
426 mutex_lock(&data->update_lock); \
427 data->in_##reg[nr] = IN_TO_REG(val); \
428 w83627hf_write_value(data, W83781D_REG_IN_##REG(nr), \
429 data->in_##reg[nr]); \
430 \
431 mutex_unlock(&data->update_lock); \
432 return count; \
433 }
434 store_in_reg(MIN, min)
435 store_in_reg(MAX, max)
436
437 #define sysfs_in_offset(offset) \
438 static ssize_t \
439 show_regs_in_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
440 { \
441 return show_in(dev, buf, offset); \
442 } \
443 static DEVICE_ATTR(in##offset##_input, S_IRUGO, show_regs_in_##offset, NULL);
444
445 #define sysfs_in_reg_offset(reg, offset) \
446 static ssize_t show_regs_in_##reg##offset (struct device *dev, struct device_attribute *attr, char *buf) \
447 { \
448 return show_in_##reg (dev, buf, offset); \
449 } \
450 static ssize_t \
451 store_regs_in_##reg##offset (struct device *dev, struct device_attribute *attr, \
452 const char *buf, size_t count) \
453 { \
454 return store_in_##reg (dev, buf, count, offset); \
455 } \
456 static DEVICE_ATTR(in##offset##_##reg, S_IRUGO| S_IWUSR, \
457 show_regs_in_##reg##offset, store_regs_in_##reg##offset);
458
459 #define sysfs_in_offsets(offset) \
460 sysfs_in_offset(offset) \
461 sysfs_in_reg_offset(min, offset) \
462 sysfs_in_reg_offset(max, offset)
463
464 sysfs_in_offsets(1);
465 sysfs_in_offsets(2);
466 sysfs_in_offsets(3);
467 sysfs_in_offsets(4);
468 sysfs_in_offsets(5);
469 sysfs_in_offsets(6);
470 sysfs_in_offsets(7);
471 sysfs_in_offsets(8);
472
473 /* use a different set of functions for in0 */
474 static ssize_t show_in_0(struct w83627hf_data *data, char *buf, u8 reg)
475 {
476 long in0;
477
478 if ((data->vrm_ovt & 0x01) &&
479 (w83627thf == data->type || w83637hf == data->type
480 || w83687thf == data->type))
481
482 /* use VRM9 calculation */
483 in0 = (long)((reg * 488 + 70000 + 50) / 100);
484 else
485 /* use VRM8 (standard) calculation */
486 in0 = (long)IN_FROM_REG(reg);
487
488 return sprintf(buf,"%ld\n", in0);
489 }
490
491 static ssize_t show_regs_in_0(struct device *dev, struct device_attribute *attr, char *buf)
492 {
493 struct w83627hf_data *data = w83627hf_update_device(dev);
494 return show_in_0(data, buf, data->in[0]);
495 }
496
497 static ssize_t show_regs_in_min0(struct device *dev, struct device_attribute *attr, char *buf)
498 {
499 struct w83627hf_data *data = w83627hf_update_device(dev);
500 return show_in_0(data, buf, data->in_min[0]);
501 }
502
503 static ssize_t show_regs_in_max0(struct device *dev, struct device_attribute *attr, char *buf)
504 {
505 struct w83627hf_data *data = w83627hf_update_device(dev);
506 return show_in_0(data, buf, data->in_max[0]);
507 }
508
509 static ssize_t store_regs_in_min0(struct device *dev, struct device_attribute *attr,
510 const char *buf, size_t count)
511 {
512 struct w83627hf_data *data = dev_get_drvdata(dev);
513 u32 val;
514
515 val = simple_strtoul(buf, NULL, 10);
516
517 mutex_lock(&data->update_lock);
518
519 if ((data->vrm_ovt & 0x01) &&
520 (w83627thf == data->type || w83637hf == data->type
521 || w83687thf == data->type))
522
523 /* use VRM9 calculation */
524 data->in_min[0] =
525 SENSORS_LIMIT(((val * 100) - 70000 + 244) / 488, 0,
526 255);
527 else
528 /* use VRM8 (standard) calculation */
529 data->in_min[0] = IN_TO_REG(val);
530
531 w83627hf_write_value(data, W83781D_REG_IN_MIN(0), data->in_min[0]);
532 mutex_unlock(&data->update_lock);
533 return count;
534 }
535
536 static ssize_t store_regs_in_max0(struct device *dev, struct device_attribute *attr,
537 const char *buf, size_t count)
538 {
539 struct w83627hf_data *data = dev_get_drvdata(dev);
540 u32 val;
541
542 val = simple_strtoul(buf, NULL, 10);
543
544 mutex_lock(&data->update_lock);
545
546 if ((data->vrm_ovt & 0x01) &&
547 (w83627thf == data->type || w83637hf == data->type
548 || w83687thf == data->type))
549
550 /* use VRM9 calculation */
551 data->in_max[0] =
552 SENSORS_LIMIT(((val * 100) - 70000 + 244) / 488, 0,
553 255);
554 else
555 /* use VRM8 (standard) calculation */
556 data->in_max[0] = IN_TO_REG(val);
557
558 w83627hf_write_value(data, W83781D_REG_IN_MAX(0), data->in_max[0]);
559 mutex_unlock(&data->update_lock);
560 return count;
561 }
562
563 static DEVICE_ATTR(in0_input, S_IRUGO, show_regs_in_0, NULL);
564 static DEVICE_ATTR(in0_min, S_IRUGO | S_IWUSR,
565 show_regs_in_min0, store_regs_in_min0);
566 static DEVICE_ATTR(in0_max, S_IRUGO | S_IWUSR,
567 show_regs_in_max0, store_regs_in_max0);
568
569 #define show_fan_reg(reg) \
570 static ssize_t show_##reg (struct device *dev, char *buf, int nr) \
571 { \
572 struct w83627hf_data *data = w83627hf_update_device(dev); \
573 return sprintf(buf,"%ld\n", \
574 FAN_FROM_REG(data->reg[nr-1], \
575 (long)DIV_FROM_REG(data->fan_div[nr-1]))); \
576 }
577 show_fan_reg(fan);
578 show_fan_reg(fan_min);
579
580 static ssize_t
581 store_fan_min(struct device *dev, const char *buf, size_t count, int nr)
582 {
583 struct w83627hf_data *data = dev_get_drvdata(dev);
584 u32 val;
585
586 val = simple_strtoul(buf, NULL, 10);
587
588 mutex_lock(&data->update_lock);
589 data->fan_min[nr - 1] =
590 FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr - 1]));
591 w83627hf_write_value(data, W83781D_REG_FAN_MIN(nr),
592 data->fan_min[nr - 1]);
593
594 mutex_unlock(&data->update_lock);
595 return count;
596 }
597
598 #define sysfs_fan_offset(offset) \
599 static ssize_t show_regs_fan_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
600 { \
601 return show_fan(dev, buf, offset); \
602 } \
603 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_regs_fan_##offset, NULL);
604
605 #define sysfs_fan_min_offset(offset) \
606 static ssize_t show_regs_fan_min##offset (struct device *dev, struct device_attribute *attr, char *buf) \
607 { \
608 return show_fan_min(dev, buf, offset); \
609 } \
610 static ssize_t \
611 store_regs_fan_min##offset (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
612 { \
613 return store_fan_min(dev, buf, count, offset); \
614 } \
615 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
616 show_regs_fan_min##offset, store_regs_fan_min##offset);
617
618 sysfs_fan_offset(1);
619 sysfs_fan_min_offset(1);
620 sysfs_fan_offset(2);
621 sysfs_fan_min_offset(2);
622 sysfs_fan_offset(3);
623 sysfs_fan_min_offset(3);
624
625 #define show_temp_reg(reg) \
626 static ssize_t show_##reg (struct device *dev, char *buf, int nr) \
627 { \
628 struct w83627hf_data *data = w83627hf_update_device(dev); \
629 if (nr >= 2) { /* TEMP2 and TEMP3 */ \
630 return sprintf(buf,"%ld\n", \
631 (long)LM75_TEMP_FROM_REG(data->reg##_add[nr-2])); \
632 } else { /* TEMP1 */ \
633 return sprintf(buf,"%ld\n", (long)TEMP_FROM_REG(data->reg)); \
634 } \
635 }
636 show_temp_reg(temp);
637 show_temp_reg(temp_max);
638 show_temp_reg(temp_max_hyst);
639
640 #define store_temp_reg(REG, reg) \
641 static ssize_t \
642 store_temp_##reg (struct device *dev, const char *buf, size_t count, int nr) \
643 { \
644 struct w83627hf_data *data = dev_get_drvdata(dev); \
645 u32 val; \
646 \
647 val = simple_strtoul(buf, NULL, 10); \
648 \
649 mutex_lock(&data->update_lock); \
650 \
651 if (nr >= 2) { /* TEMP2 and TEMP3 */ \
652 data->temp_##reg##_add[nr-2] = LM75_TEMP_TO_REG(val); \
653 w83627hf_write_value(data, W83781D_REG_TEMP_##REG(nr), \
654 data->temp_##reg##_add[nr-2]); \
655 } else { /* TEMP1 */ \
656 data->temp_##reg = TEMP_TO_REG(val); \
657 w83627hf_write_value(data, W83781D_REG_TEMP_##REG(nr), \
658 data->temp_##reg); \
659 } \
660 \
661 mutex_unlock(&data->update_lock); \
662 return count; \
663 }
664 store_temp_reg(OVER, max);
665 store_temp_reg(HYST, max_hyst);
666
667 #define sysfs_temp_offset(offset) \
668 static ssize_t \
669 show_regs_temp_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
670 { \
671 return show_temp(dev, buf, offset); \
672 } \
673 static DEVICE_ATTR(temp##offset##_input, S_IRUGO, show_regs_temp_##offset, NULL);
674
675 #define sysfs_temp_reg_offset(reg, offset) \
676 static ssize_t show_regs_temp_##reg##offset (struct device *dev, struct device_attribute *attr, char *buf) \
677 { \
678 return show_temp_##reg (dev, buf, offset); \
679 } \
680 static ssize_t \
681 store_regs_temp_##reg##offset (struct device *dev, struct device_attribute *attr, \
682 const char *buf, size_t count) \
683 { \
684 return store_temp_##reg (dev, buf, count, offset); \
685 } \
686 static DEVICE_ATTR(temp##offset##_##reg, S_IRUGO| S_IWUSR, \
687 show_regs_temp_##reg##offset, store_regs_temp_##reg##offset);
688
689 #define sysfs_temp_offsets(offset) \
690 sysfs_temp_offset(offset) \
691 sysfs_temp_reg_offset(max, offset) \
692 sysfs_temp_reg_offset(max_hyst, offset)
693
694 sysfs_temp_offsets(1);
695 sysfs_temp_offsets(2);
696 sysfs_temp_offsets(3);
697
698 static ssize_t
699 show_vid_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", (long) vid_from_reg(data->vid, data->vrm));
703 }
704 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
705
706 static ssize_t
707 show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
708 {
709 struct w83627hf_data *data = w83627hf_update_device(dev);
710 return sprintf(buf, "%ld\n", (long) data->vrm);
711 }
712 static ssize_t
713 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
714 {
715 struct w83627hf_data *data = dev_get_drvdata(dev);
716 u32 val;
717
718 val = simple_strtoul(buf, NULL, 10);
719 data->vrm = val;
720
721 return count;
722 }
723 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
724
725 static ssize_t
726 show_alarms_reg(struct device *dev, struct device_attribute *attr, char *buf)
727 {
728 struct w83627hf_data *data = w83627hf_update_device(dev);
729 return sprintf(buf, "%ld\n", (long) data->alarms);
730 }
731 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
732
733 #define show_beep_reg(REG, reg) \
734 static ssize_t show_beep_##reg (struct device *dev, struct device_attribute *attr, char *buf) \
735 { \
736 struct w83627hf_data *data = w83627hf_update_device(dev); \
737 return sprintf(buf,"%ld\n", \
738 (long)BEEP_##REG##_FROM_REG(data->beep_##reg)); \
739 }
740 show_beep_reg(ENABLE, enable)
741 show_beep_reg(MASK, mask)
742
743 #define BEEP_ENABLE 0 /* Store beep_enable */
744 #define BEEP_MASK 1 /* Store beep_mask */
745
746 static ssize_t
747 store_beep_reg(struct device *dev, const char *buf, size_t count,
748 int update_mask)
749 {
750 struct w83627hf_data *data = dev_get_drvdata(dev);
751 u32 val, val2;
752
753 val = simple_strtoul(buf, NULL, 10);
754
755 mutex_lock(&data->update_lock);
756
757 if (update_mask == BEEP_MASK) { /* We are storing beep_mask */
758 data->beep_mask = BEEP_MASK_TO_REG(val);
759 w83627hf_write_value(data, W83781D_REG_BEEP_INTS1,
760 data->beep_mask & 0xff);
761 w83627hf_write_value(data, W83781D_REG_BEEP_INTS3,
762 ((data->beep_mask) >> 16) & 0xff);
763 val2 = (data->beep_mask >> 8) & 0x7f;
764 } else { /* We are storing beep_enable */
765 val2 =
766 w83627hf_read_value(data, W83781D_REG_BEEP_INTS2) & 0x7f;
767 data->beep_enable = BEEP_ENABLE_TO_REG(val);
768 }
769
770 w83627hf_write_value(data, W83781D_REG_BEEP_INTS2,
771 val2 | data->beep_enable << 7);
772
773 mutex_unlock(&data->update_lock);
774 return count;
775 }
776
777 #define sysfs_beep(REG, reg) \
778 static ssize_t show_regs_beep_##reg (struct device *dev, struct device_attribute *attr, char *buf) \
779 { \
780 return show_beep_##reg(dev, attr, buf); \
781 } \
782 static ssize_t \
783 store_regs_beep_##reg (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
784 { \
785 return store_beep_reg(dev, buf, count, BEEP_##REG); \
786 } \
787 static DEVICE_ATTR(beep_##reg, S_IRUGO | S_IWUSR, \
788 show_regs_beep_##reg, store_regs_beep_##reg);
789
790 sysfs_beep(ENABLE, enable);
791 sysfs_beep(MASK, mask);
792
793 static ssize_t
794 show_fan_div_reg(struct device *dev, char *buf, int nr)
795 {
796 struct w83627hf_data *data = w83627hf_update_device(dev);
797 return sprintf(buf, "%ld\n",
798 (long) DIV_FROM_REG(data->fan_div[nr - 1]));
799 }
800
801 /* Note: we save and restore the fan minimum here, because its value is
802 determined in part by the fan divisor. This follows the principle of
803 least surprise; the user doesn't expect the fan minimum to change just
804 because the divisor changed. */
805 static ssize_t
806 store_fan_div_reg(struct device *dev, const char *buf, size_t count, int nr)
807 {
808 struct w83627hf_data *data = dev_get_drvdata(dev);
809 unsigned long min;
810 u8 reg;
811 unsigned long val = simple_strtoul(buf, NULL, 10);
812
813 mutex_lock(&data->update_lock);
814
815 /* Save fan_min */
816 min = FAN_FROM_REG(data->fan_min[nr],
817 DIV_FROM_REG(data->fan_div[nr]));
818
819 data->fan_div[nr] = DIV_TO_REG(val);
820
821 reg = (w83627hf_read_value(data, nr==2 ? W83781D_REG_PIN : W83781D_REG_VID_FANDIV)
822 & (nr==0 ? 0xcf : 0x3f))
823 | ((data->fan_div[nr] & 0x03) << (nr==0 ? 4 : 6));
824 w83627hf_write_value(data, nr==2 ? W83781D_REG_PIN : W83781D_REG_VID_FANDIV, reg);
825
826 reg = (w83627hf_read_value(data, W83781D_REG_VBAT)
827 & ~(1 << (5 + nr)))
828 | ((data->fan_div[nr] & 0x04) << (3 + nr));
829 w83627hf_write_value(data, W83781D_REG_VBAT, reg);
830
831 /* Restore fan_min */
832 data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
833 w83627hf_write_value(data, W83781D_REG_FAN_MIN(nr+1), data->fan_min[nr]);
834
835 mutex_unlock(&data->update_lock);
836 return count;
837 }
838
839 #define sysfs_fan_div(offset) \
840 static ssize_t show_regs_fan_div_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
841 { \
842 return show_fan_div_reg(dev, buf, offset); \
843 } \
844 static ssize_t \
845 store_regs_fan_div_##offset (struct device *dev, struct device_attribute *attr, \
846 const char *buf, size_t count) \
847 { \
848 return store_fan_div_reg(dev, buf, count, offset - 1); \
849 } \
850 static DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
851 show_regs_fan_div_##offset, store_regs_fan_div_##offset);
852
853 sysfs_fan_div(1);
854 sysfs_fan_div(2);
855 sysfs_fan_div(3);
856
857 static ssize_t
858 show_pwm_reg(struct device *dev, char *buf, int nr)
859 {
860 struct w83627hf_data *data = w83627hf_update_device(dev);
861 return sprintf(buf, "%ld\n", (long) data->pwm[nr - 1]);
862 }
863
864 static ssize_t
865 store_pwm_reg(struct device *dev, const char *buf, size_t count, int nr)
866 {
867 struct w83627hf_data *data = dev_get_drvdata(dev);
868 u32 val;
869
870 val = simple_strtoul(buf, NULL, 10);
871
872 mutex_lock(&data->update_lock);
873
874 if (data->type == w83627thf) {
875 /* bits 0-3 are reserved in 627THF */
876 data->pwm[nr - 1] = PWM_TO_REG(val) & 0xf0;
877 w83627hf_write_value(data,
878 W836X7HF_REG_PWM(data->type, nr),
879 data->pwm[nr - 1] |
880 (w83627hf_read_value(data,
881 W836X7HF_REG_PWM(data->type, nr)) & 0x0f));
882 } else {
883 data->pwm[nr - 1] = PWM_TO_REG(val);
884 w83627hf_write_value(data,
885 W836X7HF_REG_PWM(data->type, nr),
886 data->pwm[nr - 1]);
887 }
888
889 mutex_unlock(&data->update_lock);
890 return count;
891 }
892
893 #define sysfs_pwm(offset) \
894 static ssize_t show_regs_pwm_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
895 { \
896 return show_pwm_reg(dev, buf, offset); \
897 } \
898 static ssize_t \
899 store_regs_pwm_##offset (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
900 { \
901 return store_pwm_reg(dev, buf, count, offset); \
902 } \
903 static DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
904 show_regs_pwm_##offset, store_regs_pwm_##offset);
905
906 sysfs_pwm(1);
907 sysfs_pwm(2);
908 sysfs_pwm(3);
909
910 static ssize_t
911 show_pwm_freq_reg(struct device *dev, char *buf, int nr)
912 {
913 struct w83627hf_data *data = w83627hf_update_device(dev);
914 if (data->type == w83627hf)
915 return sprintf(buf, "%ld\n",
916 pwm_freq_from_reg_627hf(data->pwm_freq[nr - 1]));
917 else
918 return sprintf(buf, "%ld\n",
919 pwm_freq_from_reg(data->pwm_freq[nr - 1]));
920 }
921
922 static ssize_t
923 store_pwm_freq_reg(struct device *dev, const char *buf, size_t count, int nr)
924 {
925 struct w83627hf_data *data = dev_get_drvdata(dev);
926 static const u8 mask[]={0xF8, 0x8F};
927 u32 val;
928
929 val = simple_strtoul(buf, NULL, 10);
930
931 mutex_lock(&data->update_lock);
932
933 if (data->type == w83627hf) {
934 data->pwm_freq[nr - 1] = pwm_freq_to_reg_627hf(val);
935 w83627hf_write_value(data, W83627HF_REG_PWM_FREQ,
936 (data->pwm_freq[nr - 1] << ((nr - 1)*4)) |
937 (w83627hf_read_value(data,
938 W83627HF_REG_PWM_FREQ) & mask[nr - 1]));
939 } else {
940 data->pwm_freq[nr - 1] = pwm_freq_to_reg(val);
941 w83627hf_write_value(data, W83637HF_REG_PWM_FREQ[nr - 1],
942 data->pwm_freq[nr - 1]);
943 }
944
945 mutex_unlock(&data->update_lock);
946 return count;
947 }
948
949 #define sysfs_pwm_freq(offset) \
950 static ssize_t show_regs_pwm_freq_##offset(struct device *dev, \
951 struct device_attribute *attr, char *buf) \
952 { \
953 return show_pwm_freq_reg(dev, buf, offset); \
954 } \
955 static ssize_t \
956 store_regs_pwm_freq_##offset(struct device *dev, \
957 struct device_attribute *attr, const char *buf, size_t count) \
958 { \
959 return store_pwm_freq_reg(dev, buf, count, offset); \
960 } \
961 static DEVICE_ATTR(pwm##offset##_freq, S_IRUGO | S_IWUSR, \
962 show_regs_pwm_freq_##offset, store_regs_pwm_freq_##offset);
963
964 sysfs_pwm_freq(1);
965 sysfs_pwm_freq(2);
966 sysfs_pwm_freq(3);
967
968 static ssize_t
969 show_sensor_reg(struct device *dev, char *buf, int nr)
970 {
971 struct w83627hf_data *data = w83627hf_update_device(dev);
972 return sprintf(buf, "%ld\n", (long) data->sens[nr - 1]);
973 }
974
975 static ssize_t
976 store_sensor_reg(struct device *dev, const char *buf, size_t count, int nr)
977 {
978 struct w83627hf_data *data = dev_get_drvdata(dev);
979 u32 val, tmp;
980
981 val = simple_strtoul(buf, NULL, 10);
982
983 mutex_lock(&data->update_lock);
984
985 switch (val) {
986 case 1: /* PII/Celeron diode */
987 tmp = w83627hf_read_value(data, W83781D_REG_SCFG1);
988 w83627hf_write_value(data, W83781D_REG_SCFG1,
989 tmp | BIT_SCFG1[nr - 1]);
990 tmp = w83627hf_read_value(data, W83781D_REG_SCFG2);
991 w83627hf_write_value(data, W83781D_REG_SCFG2,
992 tmp | BIT_SCFG2[nr - 1]);
993 data->sens[nr - 1] = val;
994 break;
995 case 2: /* 3904 */
996 tmp = w83627hf_read_value(data, W83781D_REG_SCFG1);
997 w83627hf_write_value(data, W83781D_REG_SCFG1,
998 tmp | BIT_SCFG1[nr - 1]);
999 tmp = w83627hf_read_value(data, W83781D_REG_SCFG2);
1000 w83627hf_write_value(data, W83781D_REG_SCFG2,
1001 tmp & ~BIT_SCFG2[nr - 1]);
1002 data->sens[nr - 1] = val;
1003 break;
1004 case W83781D_DEFAULT_BETA: /* thermistor */
1005 tmp = w83627hf_read_value(data, W83781D_REG_SCFG1);
1006 w83627hf_write_value(data, W83781D_REG_SCFG1,
1007 tmp & ~BIT_SCFG1[nr - 1]);
1008 data->sens[nr - 1] = val;
1009 break;
1010 default:
1011 dev_err(dev,
1012 "Invalid sensor type %ld; must be 1, 2, or %d\n",
1013 (long) val, W83781D_DEFAULT_BETA);
1014 break;
1015 }
1016
1017 mutex_unlock(&data->update_lock);
1018 return count;
1019 }
1020
1021 #define sysfs_sensor(offset) \
1022 static ssize_t show_regs_sensor_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
1023 { \
1024 return show_sensor_reg(dev, buf, offset); \
1025 } \
1026 static ssize_t \
1027 store_regs_sensor_##offset (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
1028 { \
1029 return store_sensor_reg(dev, buf, count, offset); \
1030 } \
1031 static DEVICE_ATTR(temp##offset##_type, S_IRUGO | S_IWUSR, \
1032 show_regs_sensor_##offset, store_regs_sensor_##offset);
1033
1034 sysfs_sensor(1);
1035 sysfs_sensor(2);
1036 sysfs_sensor(3);
1037
1038 static ssize_t show_name(struct device *dev, struct device_attribute
1039 *devattr, char *buf)
1040 {
1041 struct w83627hf_data *data = dev_get_drvdata(dev);
1042
1043 return sprintf(buf, "%s\n", data->name);
1044 }
1045 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
1046
1047 static int __init w83627hf_find(int sioaddr, unsigned short *addr,
1048 struct w83627hf_sio_data *sio_data)
1049 {
1050 int err = -ENODEV;
1051 u16 val;
1052
1053 static const __initdata char *names[] = {
1054 "W83627HF",
1055 "W83627THF",
1056 "W83697HF",
1057 "W83637HF",
1058 "W83687THF",
1059 };
1060
1061 REG = sioaddr;
1062 VAL = sioaddr + 1;
1063
1064 superio_enter();
1065 val= superio_inb(DEVID);
1066 switch (val) {
1067 case W627_DEVID:
1068 sio_data->type = w83627hf;
1069 break;
1070 case W627THF_DEVID:
1071 sio_data->type = w83627thf;
1072 break;
1073 case W697_DEVID:
1074 sio_data->type = w83697hf;
1075 break;
1076 case W637_DEVID:
1077 sio_data->type = w83637hf;
1078 break;
1079 case W687THF_DEVID:
1080 sio_data->type = w83687thf;
1081 break;
1082 case 0xff: /* No device at all */
1083 goto exit;
1084 default:
1085 pr_debug(DRVNAME ": Unsupported chip (DEVID=0x%02x)\n", val);
1086 goto exit;
1087 }
1088
1089 superio_select(W83627HF_LD_HWM);
1090 force_addr &= WINB_ALIGNMENT;
1091 if (force_addr) {
1092 printk(KERN_WARNING DRVNAME ": Forcing address 0x%x\n",
1093 force_addr);
1094 superio_outb(WINB_BASE_REG, force_addr >> 8);
1095 superio_outb(WINB_BASE_REG + 1, force_addr & 0xff);
1096 }
1097 val = (superio_inb(WINB_BASE_REG) << 8) |
1098 superio_inb(WINB_BASE_REG + 1);
1099 *addr = val & WINB_ALIGNMENT;
1100 if (*addr == 0) {
1101 printk(KERN_WARNING DRVNAME ": Base address not set, "
1102 "skipping\n");
1103 goto exit;
1104 }
1105
1106 val = superio_inb(WINB_ACT_REG);
1107 if (!(val & 0x01)) {
1108 printk(KERN_WARNING DRVNAME ": Enabling HWM logical device\n");
1109 superio_outb(WINB_ACT_REG, val | 0x01);
1110 }
1111
1112 err = 0;
1113 pr_info(DRVNAME ": Found %s chip at %#x\n",
1114 names[sio_data->type], *addr);
1115
1116 exit:
1117 superio_exit();
1118 return err;
1119 }
1120
1121 static struct attribute *w83627hf_attributes[] = {
1122 &dev_attr_in0_input.attr,
1123 &dev_attr_in0_min.attr,
1124 &dev_attr_in0_max.attr,
1125 &dev_attr_in2_input.attr,
1126 &dev_attr_in2_min.attr,
1127 &dev_attr_in2_max.attr,
1128 &dev_attr_in3_input.attr,
1129 &dev_attr_in3_min.attr,
1130 &dev_attr_in3_max.attr,
1131 &dev_attr_in4_input.attr,
1132 &dev_attr_in4_min.attr,
1133 &dev_attr_in4_max.attr,
1134 &dev_attr_in7_input.attr,
1135 &dev_attr_in7_min.attr,
1136 &dev_attr_in7_max.attr,
1137 &dev_attr_in8_input.attr,
1138 &dev_attr_in8_min.attr,
1139 &dev_attr_in8_max.attr,
1140
1141 &dev_attr_fan1_input.attr,
1142 &dev_attr_fan1_min.attr,
1143 &dev_attr_fan1_div.attr,
1144 &dev_attr_fan2_input.attr,
1145 &dev_attr_fan2_min.attr,
1146 &dev_attr_fan2_div.attr,
1147
1148 &dev_attr_temp1_input.attr,
1149 &dev_attr_temp1_max.attr,
1150 &dev_attr_temp1_max_hyst.attr,
1151 &dev_attr_temp1_type.attr,
1152 &dev_attr_temp2_input.attr,
1153 &dev_attr_temp2_max.attr,
1154 &dev_attr_temp2_max_hyst.attr,
1155 &dev_attr_temp2_type.attr,
1156
1157 &dev_attr_alarms.attr,
1158 &dev_attr_beep_enable.attr,
1159 &dev_attr_beep_mask.attr,
1160
1161 &dev_attr_pwm1.attr,
1162 &dev_attr_pwm2.attr,
1163
1164 &dev_attr_name.attr,
1165 NULL
1166 };
1167
1168 static const struct attribute_group w83627hf_group = {
1169 .attrs = w83627hf_attributes,
1170 };
1171
1172 static struct attribute *w83627hf_attributes_opt[] = {
1173 &dev_attr_in1_input.attr,
1174 &dev_attr_in1_min.attr,
1175 &dev_attr_in1_max.attr,
1176 &dev_attr_in5_input.attr,
1177 &dev_attr_in5_min.attr,
1178 &dev_attr_in5_max.attr,
1179 &dev_attr_in6_input.attr,
1180 &dev_attr_in6_min.attr,
1181 &dev_attr_in6_max.attr,
1182
1183 &dev_attr_fan3_input.attr,
1184 &dev_attr_fan3_min.attr,
1185 &dev_attr_fan3_div.attr,
1186
1187 &dev_attr_temp3_input.attr,
1188 &dev_attr_temp3_max.attr,
1189 &dev_attr_temp3_max_hyst.attr,
1190 &dev_attr_temp3_type.attr,
1191
1192 &dev_attr_pwm3.attr,
1193
1194 &dev_attr_pwm1_freq.attr,
1195 &dev_attr_pwm2_freq.attr,
1196 &dev_attr_pwm3_freq.attr,
1197 NULL
1198 };
1199
1200 static const struct attribute_group w83627hf_group_opt = {
1201 .attrs = w83627hf_attributes_opt,
1202 };
1203
1204 static int __devinit w83627hf_probe(struct platform_device *pdev)
1205 {
1206 struct device *dev = &pdev->dev;
1207 struct w83627hf_sio_data *sio_data = dev->platform_data;
1208 struct w83627hf_data *data;
1209 struct resource *res;
1210 int err;
1211
1212 static const char *names[] = {
1213 "w83627hf",
1214 "w83627thf",
1215 "w83697hf",
1216 "w83637hf",
1217 "w83687thf",
1218 };
1219
1220 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1221 if (!request_region(res->start, WINB_REGION_SIZE, DRVNAME)) {
1222 dev_err(dev, "Failed to request region 0x%lx-0x%lx\n",
1223 (unsigned long)res->start,
1224 (unsigned long)(res->start + WINB_REGION_SIZE - 1));
1225 err = -EBUSY;
1226 goto ERROR0;
1227 }
1228
1229 if (!(data = kzalloc(sizeof(struct w83627hf_data), GFP_KERNEL))) {
1230 err = -ENOMEM;
1231 goto ERROR1;
1232 }
1233 data->addr = res->start;
1234 data->type = sio_data->type;
1235 data->name = names[sio_data->type];
1236 mutex_init(&data->lock);
1237 mutex_init(&data->update_lock);
1238 platform_set_drvdata(pdev, data);
1239
1240 /* Initialize the chip */
1241 w83627hf_init_device(pdev);
1242
1243 /* A few vars need to be filled upon startup */
1244 data->fan_min[0] = w83627hf_read_value(data, W83781D_REG_FAN_MIN(1));
1245 data->fan_min[1] = w83627hf_read_value(data, W83781D_REG_FAN_MIN(2));
1246 data->fan_min[2] = w83627hf_read_value(data, W83781D_REG_FAN_MIN(3));
1247
1248 /* Register common device attributes */
1249 if ((err = sysfs_create_group(&dev->kobj, &w83627hf_group)))
1250 goto ERROR3;
1251
1252 /* Register chip-specific device attributes */
1253 if (data->type == w83627hf || data->type == w83697hf)
1254 if ((err = device_create_file(dev, &dev_attr_in5_input))
1255 || (err = device_create_file(dev, &dev_attr_in5_min))
1256 || (err = device_create_file(dev, &dev_attr_in5_max))
1257 || (err = device_create_file(dev, &dev_attr_in6_input))
1258 || (err = device_create_file(dev, &dev_attr_in6_min))
1259 || (err = device_create_file(dev, &dev_attr_in6_max))
1260 || (err = device_create_file(dev, &dev_attr_pwm1_freq))
1261 || (err = device_create_file(dev, &dev_attr_pwm2_freq)))
1262 goto ERROR4;
1263
1264 if (data->type != w83697hf)
1265 if ((err = device_create_file(dev, &dev_attr_in1_input))
1266 || (err = device_create_file(dev, &dev_attr_in1_min))
1267 || (err = device_create_file(dev, &dev_attr_in1_max))
1268 || (err = device_create_file(dev, &dev_attr_fan3_input))
1269 || (err = device_create_file(dev, &dev_attr_fan3_min))
1270 || (err = device_create_file(dev, &dev_attr_fan3_div))
1271 || (err = device_create_file(dev, &dev_attr_temp3_input))
1272 || (err = device_create_file(dev, &dev_attr_temp3_max))
1273 || (err = device_create_file(dev, &dev_attr_temp3_max_hyst))
1274 || (err = device_create_file(dev, &dev_attr_temp3_type)))
1275 goto ERROR4;
1276
1277 if (data->type != w83697hf && data->vid != 0xff) {
1278 /* Convert VID to voltage based on VRM */
1279 data->vrm = vid_which_vrm();
1280
1281 if ((err = device_create_file(dev, &dev_attr_cpu0_vid))
1282 || (err = device_create_file(dev, &dev_attr_vrm)))
1283 goto ERROR4;
1284 }
1285
1286 if (data->type == w83627thf || data->type == w83637hf
1287 || data->type == w83687thf)
1288 if ((err = device_create_file(dev, &dev_attr_pwm3)))
1289 goto ERROR4;
1290
1291 if (data->type == w83637hf || data->type == w83687thf)
1292 if ((err = device_create_file(dev, &dev_attr_pwm1_freq))
1293 || (err = device_create_file(dev, &dev_attr_pwm2_freq))
1294 || (err = device_create_file(dev, &dev_attr_pwm3_freq)))
1295 goto ERROR4;
1296
1297 data->class_dev = hwmon_device_register(dev);
1298 if (IS_ERR(data->class_dev)) {
1299 err = PTR_ERR(data->class_dev);
1300 goto ERROR4;
1301 }
1302
1303 return 0;
1304
1305 ERROR4:
1306 sysfs_remove_group(&dev->kobj, &w83627hf_group);
1307 sysfs_remove_group(&dev->kobj, &w83627hf_group_opt);
1308 ERROR3:
1309 platform_set_drvdata(pdev, NULL);
1310 kfree(data);
1311 ERROR1:
1312 release_region(res->start, WINB_REGION_SIZE);
1313 ERROR0:
1314 return err;
1315 }
1316
1317 static int __devexit w83627hf_remove(struct platform_device *pdev)
1318 {
1319 struct w83627hf_data *data = platform_get_drvdata(pdev);
1320 struct resource *res;
1321
1322 hwmon_device_unregister(data->class_dev);
1323
1324 sysfs_remove_group(&pdev->dev.kobj, &w83627hf_group);
1325 sysfs_remove_group(&pdev->dev.kobj, &w83627hf_group_opt);
1326 platform_set_drvdata(pdev, NULL);
1327 kfree(data);
1328
1329 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1330 release_region(res->start, WINB_REGION_SIZE);
1331
1332 return 0;
1333 }
1334
1335
1336 static int w83627hf_read_value(struct w83627hf_data *data, u16 reg)
1337 {
1338 int res, word_sized;
1339
1340 mutex_lock(&data->lock);
1341 word_sized = (((reg & 0xff00) == 0x100)
1342 || ((reg & 0xff00) == 0x200))
1343 && (((reg & 0x00ff) == 0x50)
1344 || ((reg & 0x00ff) == 0x53)
1345 || ((reg & 0x00ff) == 0x55));
1346 if (reg & 0xff00) {
1347 outb_p(W83781D_REG_BANK,
1348 data->addr + W83781D_ADDR_REG_OFFSET);
1349 outb_p(reg >> 8,
1350 data->addr + W83781D_DATA_REG_OFFSET);
1351 }
1352 outb_p(reg & 0xff, data->addr + W83781D_ADDR_REG_OFFSET);
1353 res = inb_p(data->addr + W83781D_DATA_REG_OFFSET);
1354 if (word_sized) {
1355 outb_p((reg & 0xff) + 1,
1356 data->addr + W83781D_ADDR_REG_OFFSET);
1357 res =
1358 (res << 8) + inb_p(data->addr +
1359 W83781D_DATA_REG_OFFSET);
1360 }
1361 if (reg & 0xff00) {
1362 outb_p(W83781D_REG_BANK,
1363 data->addr + W83781D_ADDR_REG_OFFSET);
1364 outb_p(0, data->addr + W83781D_DATA_REG_OFFSET);
1365 }
1366 mutex_unlock(&data->lock);
1367 return res;
1368 }
1369
1370 static int __devinit w83627thf_read_gpio5(struct platform_device *pdev)
1371 {
1372 int res = 0xff, sel;
1373
1374 superio_enter();
1375 superio_select(W83627HF_LD_GPIO5);
1376
1377 /* Make sure these GPIO pins are enabled */
1378 if (!(superio_inb(W83627THF_GPIO5_EN) & (1<<3))) {
1379 dev_dbg(&pdev->dev, "GPIO5 disabled, no VID function\n");
1380 goto exit;
1381 }
1382
1383 /* Make sure the pins are configured for input
1384 There must be at least five (VRM 9), and possibly 6 (VRM 10) */
1385 sel = superio_inb(W83627THF_GPIO5_IOSR) & 0x3f;
1386 if ((sel & 0x1f) != 0x1f) {
1387 dev_dbg(&pdev->dev, "GPIO5 not configured for VID "
1388 "function\n");
1389 goto exit;
1390 }
1391
1392 dev_info(&pdev->dev, "Reading VID from GPIO5\n");
1393 res = superio_inb(W83627THF_GPIO5_DR) & sel;
1394
1395 exit:
1396 superio_exit();
1397 return res;
1398 }
1399
1400 static int __devinit w83687thf_read_vid(struct platform_device *pdev)
1401 {
1402 int res = 0xff;
1403
1404 superio_enter();
1405 superio_select(W83627HF_LD_HWM);
1406
1407 /* Make sure these GPIO pins are enabled */
1408 if (!(superio_inb(W83687THF_VID_EN) & (1 << 2))) {
1409 dev_dbg(&pdev->dev, "VID disabled, no VID function\n");
1410 goto exit;
1411 }
1412
1413 /* Make sure the pins are configured for input */
1414 if (!(superio_inb(W83687THF_VID_CFG) & (1 << 4))) {
1415 dev_dbg(&pdev->dev, "VID configured as output, "
1416 "no VID function\n");
1417 goto exit;
1418 }
1419
1420 res = superio_inb(W83687THF_VID_DATA) & 0x3f;
1421
1422 exit:
1423 superio_exit();
1424 return res;
1425 }
1426
1427 static int w83627hf_write_value(struct w83627hf_data *data, u16 reg, u16 value)
1428 {
1429 int word_sized;
1430
1431 mutex_lock(&data->lock);
1432 word_sized = (((reg & 0xff00) == 0x100)
1433 || ((reg & 0xff00) == 0x200))
1434 && (((reg & 0x00ff) == 0x53)
1435 || ((reg & 0x00ff) == 0x55));
1436 if (reg & 0xff00) {
1437 outb_p(W83781D_REG_BANK,
1438 data->addr + W83781D_ADDR_REG_OFFSET);
1439 outb_p(reg >> 8,
1440 data->addr + W83781D_DATA_REG_OFFSET);
1441 }
1442 outb_p(reg & 0xff, data->addr + W83781D_ADDR_REG_OFFSET);
1443 if (word_sized) {
1444 outb_p(value >> 8,
1445 data->addr + W83781D_DATA_REG_OFFSET);
1446 outb_p((reg & 0xff) + 1,
1447 data->addr + W83781D_ADDR_REG_OFFSET);
1448 }
1449 outb_p(value & 0xff,
1450 data->addr + W83781D_DATA_REG_OFFSET);
1451 if (reg & 0xff00) {
1452 outb_p(W83781D_REG_BANK,
1453 data->addr + W83781D_ADDR_REG_OFFSET);
1454 outb_p(0, data->addr + W83781D_DATA_REG_OFFSET);
1455 }
1456 mutex_unlock(&data->lock);
1457 return 0;
1458 }
1459
1460 static void __devinit w83627hf_init_device(struct platform_device *pdev)
1461 {
1462 struct w83627hf_data *data = platform_get_drvdata(pdev);
1463 int i;
1464 enum chips type = data->type;
1465 u8 tmp;
1466
1467 if (reset) {
1468 /* Resetting the chip has been the default for a long time,
1469 but repeatedly caused problems (fans going to full
1470 speed...) so it is now optional. It might even go away if
1471 nobody reports it as being useful, as I see very little
1472 reason why this would be needed at all. */
1473 dev_info(&pdev->dev, "If reset=1 solved a problem you were "
1474 "having, please report!\n");
1475
1476 /* save this register */
1477 i = w83627hf_read_value(data, W83781D_REG_BEEP_CONFIG);
1478 /* Reset all except Watchdog values and last conversion values
1479 This sets fan-divs to 2, among others */
1480 w83627hf_write_value(data, W83781D_REG_CONFIG, 0x80);
1481 /* Restore the register and disable power-on abnormal beep.
1482 This saves FAN 1/2/3 input/output values set by BIOS. */
1483 w83627hf_write_value(data, W83781D_REG_BEEP_CONFIG, i | 0x80);
1484 /* Disable master beep-enable (reset turns it on).
1485 Individual beeps should be reset to off but for some reason
1486 disabling this bit helps some people not get beeped */
1487 w83627hf_write_value(data, W83781D_REG_BEEP_INTS2, 0);
1488 }
1489
1490 /* Minimize conflicts with other winbond i2c-only clients... */
1491 /* disable i2c subclients... how to disable main i2c client?? */
1492 /* force i2c address to relatively uncommon address */
1493 w83627hf_write_value(data, W83781D_REG_I2C_SUBADDR, 0x89);
1494 w83627hf_write_value(data, W83781D_REG_I2C_ADDR, force_i2c);
1495
1496 /* Read VID only once */
1497 if (type == w83627hf || type == w83637hf) {
1498 int lo = w83627hf_read_value(data, W83781D_REG_VID_FANDIV);
1499 int hi = w83627hf_read_value(data, W83781D_REG_CHIPID);
1500 data->vid = (lo & 0x0f) | ((hi & 0x01) << 4);
1501 } else if (type == w83627thf) {
1502 data->vid = w83627thf_read_gpio5(pdev);
1503 } else if (type == w83687thf) {
1504 data->vid = w83687thf_read_vid(pdev);
1505 }
1506
1507 /* Read VRM & OVT Config only once */
1508 if (type == w83627thf || type == w83637hf || type == w83687thf) {
1509 data->vrm_ovt =
1510 w83627hf_read_value(data, W83627THF_REG_VRM_OVT_CFG);
1511 }
1512
1513 tmp = w83627hf_read_value(data, W83781D_REG_SCFG1);
1514 for (i = 1; i <= 3; i++) {
1515 if (!(tmp & BIT_SCFG1[i - 1])) {
1516 data->sens[i - 1] = W83781D_DEFAULT_BETA;
1517 } else {
1518 if (w83627hf_read_value
1519 (data,
1520 W83781D_REG_SCFG2) & BIT_SCFG2[i - 1])
1521 data->sens[i - 1] = 1;
1522 else
1523 data->sens[i - 1] = 2;
1524 }
1525 if ((type == w83697hf) && (i == 2))
1526 break;
1527 }
1528
1529 if(init) {
1530 /* Enable temp2 */
1531 tmp = w83627hf_read_value(data, W83781D_REG_TEMP2_CONFIG);
1532 if (tmp & 0x01) {
1533 dev_warn(&pdev->dev, "Enabling temp2, readings "
1534 "might not make sense\n");
1535 w83627hf_write_value(data, W83781D_REG_TEMP2_CONFIG,
1536 tmp & 0xfe);
1537 }
1538
1539 /* Enable temp3 */
1540 if (type != w83697hf) {
1541 tmp = w83627hf_read_value(data,
1542 W83781D_REG_TEMP3_CONFIG);
1543 if (tmp & 0x01) {
1544 dev_warn(&pdev->dev, "Enabling temp3, "
1545 "readings might not make sense\n");
1546 w83627hf_write_value(data,
1547 W83781D_REG_TEMP3_CONFIG, tmp & 0xfe);
1548 }
1549 }
1550 }
1551
1552 /* Start monitoring */
1553 w83627hf_write_value(data, W83781D_REG_CONFIG,
1554 (w83627hf_read_value(data,
1555 W83781D_REG_CONFIG) & 0xf7)
1556 | 0x01);
1557 }
1558
1559 static struct w83627hf_data *w83627hf_update_device(struct device *dev)
1560 {
1561 struct w83627hf_data *data = dev_get_drvdata(dev);
1562 int i;
1563
1564 mutex_lock(&data->update_lock);
1565
1566 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1567 || !data->valid) {
1568 for (i = 0; i <= 8; i++) {
1569 /* skip missing sensors */
1570 if (((data->type == w83697hf) && (i == 1)) ||
1571 ((data->type != w83627hf && data->type != w83697hf)
1572 && (i == 5 || i == 6)))
1573 continue;
1574 data->in[i] =
1575 w83627hf_read_value(data, W83781D_REG_IN(i));
1576 data->in_min[i] =
1577 w83627hf_read_value(data,
1578 W83781D_REG_IN_MIN(i));
1579 data->in_max[i] =
1580 w83627hf_read_value(data,
1581 W83781D_REG_IN_MAX(i));
1582 }
1583 for (i = 1; i <= 3; i++) {
1584 data->fan[i - 1] =
1585 w83627hf_read_value(data, W83781D_REG_FAN(i));
1586 data->fan_min[i - 1] =
1587 w83627hf_read_value(data,
1588 W83781D_REG_FAN_MIN(i));
1589 }
1590 for (i = 1; i <= 3; i++) {
1591 u8 tmp = w83627hf_read_value(data,
1592 W836X7HF_REG_PWM(data->type, i));
1593 /* bits 0-3 are reserved in 627THF */
1594 if (data->type == w83627thf)
1595 tmp &= 0xf0;
1596 data->pwm[i - 1] = tmp;
1597 if(i == 2 &&
1598 (data->type == w83627hf || data->type == w83697hf))
1599 break;
1600 }
1601 if (data->type == w83627hf) {
1602 u8 tmp = w83627hf_read_value(data,
1603 W83627HF_REG_PWM_FREQ);
1604 data->pwm_freq[0] = tmp & 0x07;
1605 data->pwm_freq[1] = (tmp >> 4) & 0x07;
1606 } else if (data->type != w83627thf) {
1607 for (i = 1; i <= 3; i++) {
1608 data->pwm_freq[i - 1] =
1609 w83627hf_read_value(data,
1610 W83637HF_REG_PWM_FREQ[i - 1]);
1611 if (i == 2 && (data->type == w83697hf))
1612 break;
1613 }
1614 }
1615
1616 data->temp = w83627hf_read_value(data, W83781D_REG_TEMP(1));
1617 data->temp_max =
1618 w83627hf_read_value(data, W83781D_REG_TEMP_OVER(1));
1619 data->temp_max_hyst =
1620 w83627hf_read_value(data, W83781D_REG_TEMP_HYST(1));
1621 data->temp_add[0] =
1622 w83627hf_read_value(data, W83781D_REG_TEMP(2));
1623 data->temp_max_add[0] =
1624 w83627hf_read_value(data, W83781D_REG_TEMP_OVER(2));
1625 data->temp_max_hyst_add[0] =
1626 w83627hf_read_value(data, W83781D_REG_TEMP_HYST(2));
1627 if (data->type != w83697hf) {
1628 data->temp_add[1] =
1629 w83627hf_read_value(data, W83781D_REG_TEMP(3));
1630 data->temp_max_add[1] =
1631 w83627hf_read_value(data, W83781D_REG_TEMP_OVER(3));
1632 data->temp_max_hyst_add[1] =
1633 w83627hf_read_value(data, W83781D_REG_TEMP_HYST(3));
1634 }
1635
1636 i = w83627hf_read_value(data, W83781D_REG_VID_FANDIV);
1637 data->fan_div[0] = (i >> 4) & 0x03;
1638 data->fan_div[1] = (i >> 6) & 0x03;
1639 if (data->type != w83697hf) {
1640 data->fan_div[2] = (w83627hf_read_value(data,
1641 W83781D_REG_PIN) >> 6) & 0x03;
1642 }
1643 i = w83627hf_read_value(data, W83781D_REG_VBAT);
1644 data->fan_div[0] |= (i >> 3) & 0x04;
1645 data->fan_div[1] |= (i >> 4) & 0x04;
1646 if (data->type != w83697hf)
1647 data->fan_div[2] |= (i >> 5) & 0x04;
1648 data->alarms =
1649 w83627hf_read_value(data, W83781D_REG_ALARM1) |
1650 (w83627hf_read_value(data, W83781D_REG_ALARM2) << 8) |
1651 (w83627hf_read_value(data, W83781D_REG_ALARM3) << 16);
1652 i = w83627hf_read_value(data, W83781D_REG_BEEP_INTS2);
1653 data->beep_enable = i >> 7;
1654 data->beep_mask = ((i & 0x7f) << 8) |
1655 w83627hf_read_value(data, W83781D_REG_BEEP_INTS1) |
1656 w83627hf_read_value(data, W83781D_REG_BEEP_INTS3) << 16;
1657 data->last_updated = jiffies;
1658 data->valid = 1;
1659 }
1660
1661 mutex_unlock(&data->update_lock);
1662
1663 return data;
1664 }
1665
1666 static int __init w83627hf_device_add(unsigned short address,
1667 const struct w83627hf_sio_data *sio_data)
1668 {
1669 struct resource res = {
1670 .start = address + WINB_REGION_OFFSET,
1671 .end = address + WINB_REGION_OFFSET + WINB_REGION_SIZE - 1,
1672 .name = DRVNAME,
1673 .flags = IORESOURCE_IO,
1674 };
1675 int err;
1676
1677 pdev = platform_device_alloc(DRVNAME, address);
1678 if (!pdev) {
1679 err = -ENOMEM;
1680 printk(KERN_ERR DRVNAME ": Device allocation failed\n");
1681 goto exit;
1682 }
1683
1684 err = platform_device_add_resources(pdev, &res, 1);
1685 if (err) {
1686 printk(KERN_ERR DRVNAME ": Device resource addition failed "
1687 "(%d)\n", err);
1688 goto exit_device_put;
1689 }
1690
1691 err = platform_device_add_data(pdev, sio_data,
1692 sizeof(struct w83627hf_sio_data));
1693 if (err) {
1694 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
1695 goto exit_device_put;
1696 }
1697
1698 err = platform_device_add(pdev);
1699 if (err) {
1700 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
1701 err);
1702 goto exit_device_put;
1703 }
1704
1705 return 0;
1706
1707 exit_device_put:
1708 platform_device_put(pdev);
1709 exit:
1710 return err;
1711 }
1712
1713 static int __init sensors_w83627hf_init(void)
1714 {
1715 int err;
1716 unsigned short address;
1717 struct w83627hf_sio_data sio_data;
1718
1719 if (w83627hf_find(0x2e, &address, &sio_data)
1720 && w83627hf_find(0x4e, &address, &sio_data))
1721 return -ENODEV;
1722
1723 err = platform_driver_register(&w83627hf_driver);
1724 if (err)
1725 goto exit;
1726
1727 /* Sets global pdev as a side effect */
1728 err = w83627hf_device_add(address, &sio_data);
1729 if (err)
1730 goto exit_driver;
1731
1732 return 0;
1733
1734 exit_driver:
1735 platform_driver_unregister(&w83627hf_driver);
1736 exit:
1737 return err;
1738 }
1739
1740 static void __exit sensors_w83627hf_exit(void)
1741 {
1742 platform_device_unregister(pdev);
1743 platform_driver_unregister(&w83627hf_driver);
1744 }
1745
1746 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
1747 "Philip Edelbrock <phil@netroedge.com>, "
1748 "and Mark Studebaker <mdsxyz123@yahoo.com>");
1749 MODULE_DESCRIPTION("W83627HF driver");
1750 MODULE_LICENSE("GPL");
1751
1752 module_init(sensors_w83627hf_init);
1753 module_exit(sensors_w83627hf_exit);
Linux kernel - Deliverables
This page took 0.077442 seconds and 6 git commands to generate.