?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
TTY: restore tty_ldisc_wait_idle
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / hwmon / w83627ehf.c
blob072c58008a633b713e1f68fd3a522572a41842d1
1 /*
2 w83627ehf - Driver for the hardware monitoring functionality of
3 the Winbond W83627EHF Super-I/O chip
4 Copyright (C) 2005 Jean Delvare <khali@linux-fr.org>
5 Copyright (C) 2006 Yuan Mu (Winbond),
6 Rudolf Marek <r.marek@assembler.cz>
7 David Hubbard <david.c.hubbard@gmail.com>
8 Daniel J Blueman <daniel.blueman@gmail.com>
9
10 Shamelessly ripped from the w83627hf driver
11 Copyright (C) 2003 Mark Studebaker
12
13 Thanks to Leon Moonen, Steve Cliffe and Grant Coady for their help
14 in testing and debugging this driver.
15
16 This driver also supports the W83627EHG, which is the lead-free
17 version of the W83627EHF.
18
19 This program is free software; you can redistribute it and/or modify
20 it under the terms of the GNU General Public License as published by
21 the Free Software Foundation; either version 2 of the License, or
22 (at your option) any later version.
23
24 This program is distributed in the hope that it will be useful,
25 but WITHOUT ANY WARRANTY; without even the implied warranty of
26 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27 GNU General Public License for more details.
28
29 You should have received a copy of the GNU General Public License
30 along with this program; if not, write to the Free Software
31 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
32
33
34 Supports the following chips:
35
36 Chip #vin #fan #pwm #temp chip IDs man ID
37 w83627ehf 10 5 4 3 0x8850 0x88 0x5ca3
38 0x8860 0xa1
39 w83627dhg 9 5 4 3 0xa020 0xc1 0x5ca3
40 w83627dhg-p 9 5 4 3 0xb070 0xc1 0x5ca3
41 w83667hg 9 5 3 3 0xa510 0xc1 0x5ca3
42 w83667hg-b 9 5 3 3 0xb350 0xc1 0x5ca3
43 */
44
45 #include <linux/module.h>
46 #include <linux/init.h>
47 #include <linux/slab.h>
48 #include <linux/jiffies.h>
49 #include <linux/platform_device.h>
50 #include <linux/hwmon.h>
51 #include <linux/hwmon-sysfs.h>
52 #include <linux/hwmon-vid.h>
53 #include <linux/err.h>
54 #include <linux/mutex.h>
55 #include <linux/acpi.h>
56 #include <linux/io.h>
57 #include "lm75.h"
58
59 enum kinds { w83627ehf, w83627dhg, w83627dhg_p, w83667hg, w83667hg_b };
60
61 /* used to set data->name = w83627ehf_device_names[data->sio_kind] */
62 static const char * w83627ehf_device_names[] = {
63 "w83627ehf",
64 "w83627dhg",
65 "w83627dhg",
66 "w83667hg",
67 "w83667hg",
68 };
69
70 static unsigned short force_id;
71 module_param(force_id, ushort, 0);
72 MODULE_PARM_DESC(force_id, "Override the detected device ID");
73
74 #define DRVNAME "w83627ehf"
75
76 /*
77 * Super-I/O constants and functions
78 */
79
80 #define W83627EHF_LD_HWM 0x0b
81 #define W83667HG_LD_VID 0x0d
82
83 #define SIO_REG_LDSEL 0x07 /* Logical device select */
84 #define SIO_REG_DEVID 0x20 /* Device ID (2 bytes) */
85 #define SIO_REG_EN_VRM10 0x2C /* GPIO3, GPIO4 selection */
86 #define SIO_REG_ENABLE 0x30 /* Logical device enable */
87 #define SIO_REG_ADDR 0x60 /* Logical device address (2 bytes) */
88 #define SIO_REG_VID_CTRL 0xF0 /* VID control */
89 #define SIO_REG_VID_DATA 0xF1 /* VID data */
90
91 #define SIO_W83627EHF_ID 0x8850
92 #define SIO_W83627EHG_ID 0x8860
93 #define SIO_W83627DHG_ID 0xa020
94 #define SIO_W83627DHG_P_ID 0xb070
95 #define SIO_W83667HG_ID 0xa510
96 #define SIO_W83667HG_B_ID 0xb350
97 #define SIO_ID_MASK 0xFFF0
98
99 static inline void
100 superio_outb(int ioreg, int reg, int val)
101 {
102 outb(reg, ioreg);
103 outb(val, ioreg + 1);
104 }
105
106 static inline int
107 superio_inb(int ioreg, int reg)
108 {
109 outb(reg, ioreg);
110 return inb(ioreg + 1);
111 }
112
113 static inline void
114 superio_select(int ioreg, int ld)
115 {
116 outb(SIO_REG_LDSEL, ioreg);
117 outb(ld, ioreg + 1);
118 }
119
120 static inline void
121 superio_enter(int ioreg)
122 {
123 outb(0x87, ioreg);
124 outb(0x87, ioreg);
125 }
126
127 static inline void
128 superio_exit(int ioreg)
129 {
130 outb(0xaa, ioreg);
131 outb(0x02, ioreg);
132 outb(0x02, ioreg + 1);
133 }
134
135 /*
136 * ISA constants
137 */
138
139 #define IOREGION_ALIGNMENT ~7
140 #define IOREGION_OFFSET 5
141 #define IOREGION_LENGTH 2
142 #define ADDR_REG_OFFSET 0
143 #define DATA_REG_OFFSET 1
144
145 #define W83627EHF_REG_BANK 0x4E
146 #define W83627EHF_REG_CONFIG 0x40
147
148 /* Not currently used:
149 * REG_MAN_ID has the value 0x5ca3 for all supported chips.
150 * REG_CHIP_ID == 0x88/0xa1/0xc1 depending on chip model.
151 * REG_MAN_ID is at port 0x4f
152 * REG_CHIP_ID is at port 0x58 */
153
154 static const u16 W83627EHF_REG_FAN[] = { 0x28, 0x29, 0x2a, 0x3f, 0x553 };
155 static const u16 W83627EHF_REG_FAN_MIN[] = { 0x3b, 0x3c, 0x3d, 0x3e, 0x55c };
156
157 /* The W83627EHF registers for nr=7,8,9 are in bank 5 */
158 #define W83627EHF_REG_IN_MAX(nr) ((nr < 7) ? (0x2b + (nr) * 2) : \
159 (0x554 + (((nr) - 7) * 2)))
160 #define W83627EHF_REG_IN_MIN(nr) ((nr < 7) ? (0x2c + (nr) * 2) : \
161 (0x555 + (((nr) - 7) * 2)))
162 #define W83627EHF_REG_IN(nr) ((nr < 7) ? (0x20 + (nr)) : \
163 (0x550 + (nr) - 7))
164
165 #define W83627EHF_REG_TEMP1 0x27
166 #define W83627EHF_REG_TEMP1_HYST 0x3a
167 #define W83627EHF_REG_TEMP1_OVER 0x39
168 static const u16 W83627EHF_REG_TEMP[] = { 0x150, 0x250 };
169 static const u16 W83627EHF_REG_TEMP_HYST[] = { 0x153, 0x253 };
170 static const u16 W83627EHF_REG_TEMP_OVER[] = { 0x155, 0x255 };
171 static const u16 W83627EHF_REG_TEMP_CONFIG[] = { 0x152, 0x252 };
172
173 /* Fan clock dividers are spread over the following five registers */
174 #define W83627EHF_REG_FANDIV1 0x47
175 #define W83627EHF_REG_FANDIV2 0x4B
176 #define W83627EHF_REG_VBAT 0x5D
177 #define W83627EHF_REG_DIODE 0x59
178 #define W83627EHF_REG_SMI_OVT 0x4C
179
180 #define W83627EHF_REG_ALARM1 0x459
181 #define W83627EHF_REG_ALARM2 0x45A
182 #define W83627EHF_REG_ALARM3 0x45B
183
184 /* SmartFan registers */
185 #define W83627EHF_REG_FAN_STEPUP_TIME 0x0f
186 #define W83627EHF_REG_FAN_STEPDOWN_TIME 0x0e
187
188 /* DC or PWM output fan configuration */
189 static const u8 W83627EHF_REG_PWM_ENABLE[] = {
190 0x04, /* SYS FAN0 output mode and PWM mode */
191 0x04, /* CPU FAN0 output mode and PWM mode */
192 0x12, /* AUX FAN mode */
193 0x62, /* CPU FAN1 mode */
194 };
195
196 static const u8 W83627EHF_PWM_MODE_SHIFT[] = { 0, 1, 0, 6 };
197 static const u8 W83627EHF_PWM_ENABLE_SHIFT[] = { 2, 4, 1, 4 };
198
199 /* FAN Duty Cycle, be used to control */
200 static const u8 W83627EHF_REG_PWM[] = { 0x01, 0x03, 0x11, 0x61 };
201 static const u8 W83627EHF_REG_TARGET[] = { 0x05, 0x06, 0x13, 0x63 };
202 static const u8 W83627EHF_REG_TOLERANCE[] = { 0x07, 0x07, 0x14, 0x62 };
203
204 /* Advanced Fan control, some values are common for all fans */
205 static const u8 W83627EHF_REG_FAN_START_OUTPUT[] = { 0x0a, 0x0b, 0x16, 0x65 };
206 static const u8 W83627EHF_REG_FAN_STOP_OUTPUT[] = { 0x08, 0x09, 0x15, 0x64 };
207 static const u8 W83627EHF_REG_FAN_STOP_TIME[] = { 0x0c, 0x0d, 0x17, 0x66 };
208
209 static const u8 W83627EHF_REG_FAN_MAX_OUTPUT_COMMON[]
210 = { 0xff, 0x67, 0xff, 0x69 };
211 static const u8 W83627EHF_REG_FAN_STEP_OUTPUT_COMMON[]
212 = { 0xff, 0x68, 0xff, 0x6a };
213
214 static const u8 W83627EHF_REG_FAN_MAX_OUTPUT_W83667_B[] = { 0x67, 0x69, 0x6b };
215 static const u8 W83627EHF_REG_FAN_STEP_OUTPUT_W83667_B[] = { 0x68, 0x6a, 0x6c };
216
217 /*
218 * Conversions
219 */
220
221 /* 1 is PWM mode, output in ms */
222 static inline unsigned int step_time_from_reg(u8 reg, u8 mode)
223 {
224 return mode ? 100 * reg : 400 * reg;
225 }
226
227 static inline u8 step_time_to_reg(unsigned int msec, u8 mode)
228 {
229 return SENSORS_LIMIT((mode ? (msec + 50) / 100 :
230 (msec + 200) / 400), 1, 255);
231 }
232
233 static inline unsigned int
234 fan_from_reg(u8 reg, unsigned int div)
235 {
236 if (reg == 0 || reg == 255)
237 return 0;
238 return 1350000U / (reg * div);
239 }
240
241 static inline unsigned int
242 div_from_reg(u8 reg)
243 {
244 return 1 << reg;
245 }
246
247 static inline int
248 temp1_from_reg(s8 reg)
249 {
250 return reg * 1000;
251 }
252
253 static inline s8
254 temp1_to_reg(long temp, int min, int max)
255 {
256 if (temp <= min)
257 return min / 1000;
258 if (temp >= max)
259 return max / 1000;
260 if (temp < 0)
261 return (temp - 500) / 1000;
262 return (temp + 500) / 1000;
263 }
264
265 /* Some of analog inputs have internal scaling (2x), 8mV is ADC LSB */
266
267 static u8 scale_in[10] = { 8, 8, 16, 16, 8, 8, 8, 16, 16, 8 };
268
269 static inline long in_from_reg(u8 reg, u8 nr)
270 {
271 return reg * scale_in[nr];
272 }
273
274 static inline u8 in_to_reg(u32 val, u8 nr)
275 {
276 return SENSORS_LIMIT(((val + (scale_in[nr] / 2)) / scale_in[nr]), 0, 255);
277 }
278
279 /*
280 * Data structures and manipulation thereof
281 */
282
283 struct w83627ehf_data {
284 int addr; /* IO base of hw monitor block */
285 const char *name;
286
287 struct device *hwmon_dev;
288 struct mutex lock;
289
290 const u8 *REG_FAN_START_OUTPUT;
291 const u8 *REG_FAN_STOP_OUTPUT;
292 const u8 *REG_FAN_MAX_OUTPUT;
293 const u8 *REG_FAN_STEP_OUTPUT;
294
295 struct mutex update_lock;
296 char valid; /* !=0 if following fields are valid */
297 unsigned long last_updated; /* In jiffies */
298
299 /* Register values */
300 u8 in_num; /* number of in inputs we have */
301 u8 in[10]; /* Register value */
302 u8 in_max[10]; /* Register value */
303 u8 in_min[10]; /* Register value */
304 u8 fan[5];
305 u8 fan_min[5];
306 u8 fan_div[5];
307 u8 has_fan; /* some fan inputs can be disabled */
308 u8 temp_type[3];
309 s8 temp1;
310 s8 temp1_max;
311 s8 temp1_max_hyst;
312 s16 temp[2];
313 s16 temp_max[2];
314 s16 temp_max_hyst[2];
315 u32 alarms;
316
317 u8 pwm_mode[4]; /* 0->DC variable voltage, 1->PWM variable duty cycle */
318 u8 pwm_enable[4]; /* 1->manual
319 2->thermal cruise mode (also called SmartFan I)
320 3->fan speed cruise mode
321 4->variable thermal cruise (also called SmartFan III) */
322 u8 pwm_num; /* number of pwm */
323 u8 pwm[4];
324 u8 target_temp[4];
325 u8 tolerance[4];
326
327 u8 fan_start_output[4]; /* minimum fan speed when spinning up */
328 u8 fan_stop_output[4]; /* minimum fan speed when spinning down */
329 u8 fan_stop_time[4]; /* time at minimum before disabling fan */
330 u8 fan_max_output[4]; /* maximum fan speed */
331 u8 fan_step_output[4]; /* rate of change output value */
332
333 u8 vid;
334 u8 vrm;
335
336 u8 temp3_disable;
337 u8 in6_skip;
338 };
339
340 struct w83627ehf_sio_data {
341 int sioreg;
342 enum kinds kind;
343 };
344
345 static inline int is_word_sized(u16 reg)
346 {
347 return (((reg & 0xff00) == 0x100
348 || (reg & 0xff00) == 0x200)
349 && ((reg & 0x00ff) == 0x50
350 || (reg & 0x00ff) == 0x53
351 || (reg & 0x00ff) == 0x55));
352 }
353
354 /* Registers 0x50-0x5f are banked */
355 static inline void w83627ehf_set_bank(struct w83627ehf_data *data, u16 reg)
356 {
357 if ((reg & 0x00f0) == 0x50) {
358 outb_p(W83627EHF_REG_BANK, data->addr + ADDR_REG_OFFSET);
359 outb_p(reg >> 8, data->addr + DATA_REG_OFFSET);
360 }
361 }
362
363 /* Not strictly necessary, but play it safe for now */
364 static inline void w83627ehf_reset_bank(struct w83627ehf_data *data, u16 reg)
365 {
366 if (reg & 0xff00) {
367 outb_p(W83627EHF_REG_BANK, data->addr + ADDR_REG_OFFSET);
368 outb_p(0, data->addr + DATA_REG_OFFSET);
369 }
370 }
371
372 static u16 w83627ehf_read_value(struct w83627ehf_data *data, u16 reg)
373 {
374 int res, word_sized = is_word_sized(reg);
375
376 mutex_lock(&data->lock);
377
378 w83627ehf_set_bank(data, reg);
379 outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET);
380 res = inb_p(data->addr + DATA_REG_OFFSET);
381 if (word_sized) {
382 outb_p((reg & 0xff) + 1,
383 data->addr + ADDR_REG_OFFSET);
384 res = (res << 8) + inb_p(data->addr + DATA_REG_OFFSET);
385 }
386 w83627ehf_reset_bank(data, reg);
387
388 mutex_unlock(&data->lock);
389
390 return res;
391 }
392
393 static int w83627ehf_write_value(struct w83627ehf_data *data, u16 reg, u16 value)
394 {
395 int word_sized = is_word_sized(reg);
396
397 mutex_lock(&data->lock);
398
399 w83627ehf_set_bank(data, reg);
400 outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET);
401 if (word_sized) {
402 outb_p(value >> 8, data->addr + DATA_REG_OFFSET);
403 outb_p((reg & 0xff) + 1,
404 data->addr + ADDR_REG_OFFSET);
405 }
406 outb_p(value & 0xff, data->addr + DATA_REG_OFFSET);
407 w83627ehf_reset_bank(data, reg);
408
409 mutex_unlock(&data->lock);
410 return 0;
411 }
412
413 /* This function assumes that the caller holds data->update_lock */
414 static void w83627ehf_write_fan_div(struct w83627ehf_data *data, int nr)
415 {
416 u8 reg;
417
418 switch (nr) {
419 case 0:
420 reg = (w83627ehf_read_value(data, W83627EHF_REG_FANDIV1) & 0xcf)
421 | ((data->fan_div[0] & 0x03) << 4);
422 /* fan5 input control bit is write only, compute the value */
423 reg |= (data->has_fan & (1 << 4)) ? 1 : 0;
424 w83627ehf_write_value(data, W83627EHF_REG_FANDIV1, reg);
425 reg = (w83627ehf_read_value(data, W83627EHF_REG_VBAT) & 0xdf)
426 | ((data->fan_div[0] & 0x04) << 3);
427 w83627ehf_write_value(data, W83627EHF_REG_VBAT, reg);
428 break;
429 case 1:
430 reg = (w83627ehf_read_value(data, W83627EHF_REG_FANDIV1) & 0x3f)
431 | ((data->fan_div[1] & 0x03) << 6);
432 /* fan5 input control bit is write only, compute the value */
433 reg |= (data->has_fan & (1 << 4)) ? 1 : 0;
434 w83627ehf_write_value(data, W83627EHF_REG_FANDIV1, reg);
435 reg = (w83627ehf_read_value(data, W83627EHF_REG_VBAT) & 0xbf)
436 | ((data->fan_div[1] & 0x04) << 4);
437 w83627ehf_write_value(data, W83627EHF_REG_VBAT, reg);
438 break;
439 case 2:
440 reg = (w83627ehf_read_value(data, W83627EHF_REG_FANDIV2) & 0x3f)
441 | ((data->fan_div[2] & 0x03) << 6);
442 w83627ehf_write_value(data, W83627EHF_REG_FANDIV2, reg);
443 reg = (w83627ehf_read_value(data, W83627EHF_REG_VBAT) & 0x7f)
444 | ((data->fan_div[2] & 0x04) << 5);
445 w83627ehf_write_value(data, W83627EHF_REG_VBAT, reg);
446 break;
447 case 3:
448 reg = (w83627ehf_read_value(data, W83627EHF_REG_DIODE) & 0xfc)
449 | (data->fan_div[3] & 0x03);
450 w83627ehf_write_value(data, W83627EHF_REG_DIODE, reg);
451 reg = (w83627ehf_read_value(data, W83627EHF_REG_SMI_OVT) & 0x7f)
452 | ((data->fan_div[3] & 0x04) << 5);
453 w83627ehf_write_value(data, W83627EHF_REG_SMI_OVT, reg);
454 break;
455 case 4:
456 reg = (w83627ehf_read_value(data, W83627EHF_REG_DIODE) & 0x73)
457 | ((data->fan_div[4] & 0x03) << 2)
458 | ((data->fan_div[4] & 0x04) << 5);
459 w83627ehf_write_value(data, W83627EHF_REG_DIODE, reg);
460 break;
461 }
462 }
463
464 static void w83627ehf_update_fan_div(struct w83627ehf_data *data)
465 {
466 int i;
467
468 i = w83627ehf_read_value(data, W83627EHF_REG_FANDIV1);
469 data->fan_div[0] = (i >> 4) & 0x03;
470 data->fan_div[1] = (i >> 6) & 0x03;
471 i = w83627ehf_read_value(data, W83627EHF_REG_FANDIV2);
472 data->fan_div[2] = (i >> 6) & 0x03;
473 i = w83627ehf_read_value(data, W83627EHF_REG_VBAT);
474 data->fan_div[0] |= (i >> 3) & 0x04;
475 data->fan_div[1] |= (i >> 4) & 0x04;
476 data->fan_div[2] |= (i >> 5) & 0x04;
477 if (data->has_fan & ((1 << 3) | (1 << 4))) {
478 i = w83627ehf_read_value(data, W83627EHF_REG_DIODE);
479 data->fan_div[3] = i & 0x03;
480 data->fan_div[4] = ((i >> 2) & 0x03)
481 | ((i >> 5) & 0x04);
482 }
483 if (data->has_fan & (1 << 3)) {
484 i = w83627ehf_read_value(data, W83627EHF_REG_SMI_OVT);
485 data->fan_div[3] |= (i >> 5) & 0x04;
486 }
487 }
488
489 static struct w83627ehf_data *w83627ehf_update_device(struct device *dev)
490 {
491 struct w83627ehf_data *data = dev_get_drvdata(dev);
492 int pwmcfg = 0, tolerance = 0; /* shut up the compiler */
493 int i;
494
495 mutex_lock(&data->update_lock);
496
497 if (time_after(jiffies, data->last_updated + HZ + HZ/2)
498 || !data->valid) {
499 /* Fan clock dividers */
500 w83627ehf_update_fan_div(data);
501
502 /* Measured voltages and limits */
503 for (i = 0; i < data->in_num; i++) {
504 data->in[i] = w83627ehf_read_value(data,
505 W83627EHF_REG_IN(i));
506 data->in_min[i] = w83627ehf_read_value(data,
507 W83627EHF_REG_IN_MIN(i));
508 data->in_max[i] = w83627ehf_read_value(data,
509 W83627EHF_REG_IN_MAX(i));
510 }
511
512 /* Measured fan speeds and limits */
513 for (i = 0; i < 5; i++) {
514 if (!(data->has_fan & (1 << i)))
515 continue;
516
517 data->fan[i] = w83627ehf_read_value(data,
518 W83627EHF_REG_FAN[i]);
519 data->fan_min[i] = w83627ehf_read_value(data,
520 W83627EHF_REG_FAN_MIN[i]);
521
522 /* If we failed to measure the fan speed and clock
523 divider can be increased, let's try that for next
524 time */
525 if (data->fan[i] == 0xff
526 && data->fan_div[i] < 0x07) {
527 dev_dbg(dev, "Increasing fan%d "
528 "clock divider from %u to %u\n",
529 i + 1, div_from_reg(data->fan_div[i]),
530 div_from_reg(data->fan_div[i] + 1));
531 data->fan_div[i]++;
532 w83627ehf_write_fan_div(data, i);
533 /* Preserve min limit if possible */
534 if (data->fan_min[i] >= 2
535 && data->fan_min[i] != 255)
536 w83627ehf_write_value(data,
537 W83627EHF_REG_FAN_MIN[i],
538 (data->fan_min[i] /= 2));
539 }
540 }
541
542 for (i = 0; i < data->pwm_num; i++) {
543 if (!(data->has_fan & (1 << i)))
544 continue;
545
546 /* pwmcfg, tolerance mapped for i=0, i=1 to same reg */
547 if (i != 1) {
548 pwmcfg = w83627ehf_read_value(data,
549 W83627EHF_REG_PWM_ENABLE[i]);
550 tolerance = w83627ehf_read_value(data,
551 W83627EHF_REG_TOLERANCE[i]);
552 }
553 data->pwm_mode[i] =
554 ((pwmcfg >> W83627EHF_PWM_MODE_SHIFT[i]) & 1)
555 ? 0 : 1;
556 data->pwm_enable[i] =
557 ((pwmcfg >> W83627EHF_PWM_ENABLE_SHIFT[i])
558 & 3) + 1;
559 data->pwm[i] = w83627ehf_read_value(data,
560 W83627EHF_REG_PWM[i]);
561 data->fan_start_output[i] = w83627ehf_read_value(data,
562 W83627EHF_REG_FAN_START_OUTPUT[i]);
563 data->fan_stop_output[i] = w83627ehf_read_value(data,
564 W83627EHF_REG_FAN_STOP_OUTPUT[i]);
565 data->fan_stop_time[i] = w83627ehf_read_value(data,
566 W83627EHF_REG_FAN_STOP_TIME[i]);
567
568 if (data->REG_FAN_MAX_OUTPUT[i] != 0xff)
569 data->fan_max_output[i] =
570 w83627ehf_read_value(data,
571 data->REG_FAN_MAX_OUTPUT[i]);
572
573 if (data->REG_FAN_STEP_OUTPUT[i] != 0xff)
574 data->fan_step_output[i] =
575 w83627ehf_read_value(data,
576 data->REG_FAN_STEP_OUTPUT[i]);
577
578 data->target_temp[i] =
579 w83627ehf_read_value(data,
580 W83627EHF_REG_TARGET[i]) &
581 (data->pwm_mode[i] == 1 ? 0x7f : 0xff);
582 data->tolerance[i] = (tolerance >> (i == 1 ? 4 : 0))
583 & 0x0f;
584 }
585
586 /* Measured temperatures and limits */
587 data->temp1 = w83627ehf_read_value(data,
588 W83627EHF_REG_TEMP1);
589 data->temp1_max = w83627ehf_read_value(data,
590 W83627EHF_REG_TEMP1_OVER);
591 data->temp1_max_hyst = w83627ehf_read_value(data,
592 W83627EHF_REG_TEMP1_HYST);
593 for (i = 0; i < 2; i++) {
594 data->temp[i] = w83627ehf_read_value(data,
595 W83627EHF_REG_TEMP[i]);
596 data->temp_max[i] = w83627ehf_read_value(data,
597 W83627EHF_REG_TEMP_OVER[i]);
598 data->temp_max_hyst[i] = w83627ehf_read_value(data,
599 W83627EHF_REG_TEMP_HYST[i]);
600 }
601
602 data->alarms = w83627ehf_read_value(data,
603 W83627EHF_REG_ALARM1) |
604 (w83627ehf_read_value(data,
605 W83627EHF_REG_ALARM2) << 8) |
606 (w83627ehf_read_value(data,
607 W83627EHF_REG_ALARM3) << 16);
608
609 data->last_updated = jiffies;
610 data->valid = 1;
611 }
612
613 mutex_unlock(&data->update_lock);
614 return data;
615 }
616
617 /*
618 * Sysfs callback functions
619 */
620 #define show_in_reg(reg) \
621 static ssize_t \
622 show_##reg(struct device *dev, struct device_attribute *attr, \
623 char *buf) \
624 { \
625 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
626 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
627 int nr = sensor_attr->index; \
628 return sprintf(buf, "%ld\n", in_from_reg(data->reg[nr], nr)); \
629 }
630 show_in_reg(in)
631 show_in_reg(in_min)
632 show_in_reg(in_max)
633
634 #define store_in_reg(REG, reg) \
635 static ssize_t \
636 store_in_##reg (struct device *dev, struct device_attribute *attr, \
637 const char *buf, size_t count) \
638 { \
639 struct w83627ehf_data *data = dev_get_drvdata(dev); \
640 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
641 int nr = sensor_attr->index; \
642 u32 val = simple_strtoul(buf, NULL, 10); \
643 \
644 mutex_lock(&data->update_lock); \
645 data->in_##reg[nr] = in_to_reg(val, nr); \
646 w83627ehf_write_value(data, W83627EHF_REG_IN_##REG(nr), \
647 data->in_##reg[nr]); \
648 mutex_unlock(&data->update_lock); \
649 return count; \
650 }
651
652 store_in_reg(MIN, min)
653 store_in_reg(MAX, max)
654
655 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, char *buf)
656 {
657 struct w83627ehf_data *data = w83627ehf_update_device(dev);
658 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
659 int nr = sensor_attr->index;
660 return sprintf(buf, "%u\n", (data->alarms >> nr) & 0x01);
661 }
662
663 static struct sensor_device_attribute sda_in_input[] = {
664 SENSOR_ATTR(in0_input, S_IRUGO, show_in, NULL, 0),
665 SENSOR_ATTR(in1_input, S_IRUGO, show_in, NULL, 1),
666 SENSOR_ATTR(in2_input, S_IRUGO, show_in, NULL, 2),
667 SENSOR_ATTR(in3_input, S_IRUGO, show_in, NULL, 3),
668 SENSOR_ATTR(in4_input, S_IRUGO, show_in, NULL, 4),
669 SENSOR_ATTR(in5_input, S_IRUGO, show_in, NULL, 5),
670 SENSOR_ATTR(in6_input, S_IRUGO, show_in, NULL, 6),
671 SENSOR_ATTR(in7_input, S_IRUGO, show_in, NULL, 7),
672 SENSOR_ATTR(in8_input, S_IRUGO, show_in, NULL, 8),
673 SENSOR_ATTR(in9_input, S_IRUGO, show_in, NULL, 9),
674 };
675
676 static struct sensor_device_attribute sda_in_alarm[] = {
677 SENSOR_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0),
678 SENSOR_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1),
679 SENSOR_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2),
680 SENSOR_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3),
681 SENSOR_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8),
682 SENSOR_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 21),
683 SENSOR_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 20),
684 SENSOR_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 16),
685 SENSOR_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 17),
686 SENSOR_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL, 19),
687 };
688
689 static struct sensor_device_attribute sda_in_min[] = {
690 SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 0),
691 SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 1),
692 SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 2),
693 SENSOR_ATTR(in3_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 3),
694 SENSOR_ATTR(in4_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 4),
695 SENSOR_ATTR(in5_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 5),
696 SENSOR_ATTR(in6_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 6),
697 SENSOR_ATTR(in7_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 7),
698 SENSOR_ATTR(in8_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 8),
699 SENSOR_ATTR(in9_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 9),
700 };
701
702 static struct sensor_device_attribute sda_in_max[] = {
703 SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 0),
704 SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 1),
705 SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 2),
706 SENSOR_ATTR(in3_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 3),
707 SENSOR_ATTR(in4_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 4),
708 SENSOR_ATTR(in5_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 5),
709 SENSOR_ATTR(in6_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 6),
710 SENSOR_ATTR(in7_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 7),
711 SENSOR_ATTR(in8_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 8),
712 SENSOR_ATTR(in9_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 9),
713 };
714
715 #define show_fan_reg(reg) \
716 static ssize_t \
717 show_##reg(struct device *dev, struct device_attribute *attr, \
718 char *buf) \
719 { \
720 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
721 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
722 int nr = sensor_attr->index; \
723 return sprintf(buf, "%d\n", \
724 fan_from_reg(data->reg[nr], \
725 div_from_reg(data->fan_div[nr]))); \
726 }
727 show_fan_reg(fan);
728 show_fan_reg(fan_min);
729
730 static ssize_t
731 show_fan_div(struct device *dev, struct device_attribute *attr,
732 char *buf)
733 {
734 struct w83627ehf_data *data = w83627ehf_update_device(dev);
735 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
736 int nr = sensor_attr->index;
737 return sprintf(buf, "%u\n", div_from_reg(data->fan_div[nr]));
738 }
739
740 static ssize_t
741 store_fan_min(struct device *dev, struct device_attribute *attr,
742 const char *buf, size_t count)
743 {
744 struct w83627ehf_data *data = dev_get_drvdata(dev);
745 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
746 int nr = sensor_attr->index;
747 unsigned int val = simple_strtoul(buf, NULL, 10);
748 unsigned int reg;
749 u8 new_div;
750
751 mutex_lock(&data->update_lock);
752 if (!val) {
753 /* No min limit, alarm disabled */
754 data->fan_min[nr] = 255;
755 new_div = data->fan_div[nr]; /* No change */
756 dev_info(dev, "fan%u low limit and alarm disabled\n", nr + 1);
757 } else if ((reg = 1350000U / val) >= 128 * 255) {
758 /* Speed below this value cannot possibly be represented,
759 even with the highest divider (128) */
760 data->fan_min[nr] = 254;
761 new_div = 7; /* 128 == (1 << 7) */
762 dev_warn(dev, "fan%u low limit %u below minimum %u, set to "
763 "minimum\n", nr + 1, val, fan_from_reg(254, 128));
764 } else if (!reg) {
765 /* Speed above this value cannot possibly be represented,
766 even with the lowest divider (1) */
767 data->fan_min[nr] = 1;
768 new_div = 0; /* 1 == (1 << 0) */
769 dev_warn(dev, "fan%u low limit %u above maximum %u, set to "
770 "maximum\n", nr + 1, val, fan_from_reg(1, 1));
771 } else {
772 /* Automatically pick the best divider, i.e. the one such
773 that the min limit will correspond to a register value
774 in the 96..192 range */
775 new_div = 0;
776 while (reg > 192 && new_div < 7) {
777 reg >>= 1;
778 new_div++;
779 }
780 data->fan_min[nr] = reg;
781 }
782
783 /* Write both the fan clock divider (if it changed) and the new
784 fan min (unconditionally) */
785 if (new_div != data->fan_div[nr]) {
786 /* Preserve the fan speed reading */
787 if (data->fan[nr] != 0xff) {
788 if (new_div > data->fan_div[nr])
789 data->fan[nr] >>= new_div - data->fan_div[nr];
790 else if (data->fan[nr] & 0x80)
791 data->fan[nr] = 0xff;
792 else
793 data->fan[nr] <<= data->fan_div[nr] - new_div;
794 }
795
796 dev_dbg(dev, "fan%u clock divider changed from %u to %u\n",
797 nr + 1, div_from_reg(data->fan_div[nr]),
798 div_from_reg(new_div));
799 data->fan_div[nr] = new_div;
800 w83627ehf_write_fan_div(data, nr);
801 /* Give the chip time to sample a new speed value */
802 data->last_updated = jiffies;
803 }
804 w83627ehf_write_value(data, W83627EHF_REG_FAN_MIN[nr],
805 data->fan_min[nr]);
806 mutex_unlock(&data->update_lock);
807
808 return count;
809 }
810
811 static struct sensor_device_attribute sda_fan_input[] = {
812 SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0),
813 SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1),
814 SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2),
815 SENSOR_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3),
816 SENSOR_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4),
817 };
818
819 static struct sensor_device_attribute sda_fan_alarm[] = {
820 SENSOR_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6),
821 SENSOR_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7),
822 SENSOR_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11),
823 SENSOR_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 10),
824 SENSOR_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 23),
825 };
826
827 static struct sensor_device_attribute sda_fan_min[] = {
828 SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min,
829 store_fan_min, 0),
830 SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min,
831 store_fan_min, 1),
832 SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min,
833 store_fan_min, 2),
834 SENSOR_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min,
835 store_fan_min, 3),
836 SENSOR_ATTR(fan5_min, S_IWUSR | S_IRUGO, show_fan_min,
837 store_fan_min, 4),
838 };
839
840 static struct sensor_device_attribute sda_fan_div[] = {
841 SENSOR_ATTR(fan1_div, S_IRUGO, show_fan_div, NULL, 0),
842 SENSOR_ATTR(fan2_div, S_IRUGO, show_fan_div, NULL, 1),
843 SENSOR_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2),
844 SENSOR_ATTR(fan4_div, S_IRUGO, show_fan_div, NULL, 3),
845 SENSOR_ATTR(fan5_div, S_IRUGO, show_fan_div, NULL, 4),
846 };
847
848 #define show_temp1_reg(reg) \
849 static ssize_t \
850 show_##reg(struct device *dev, struct device_attribute *attr, \
851 char *buf) \
852 { \
853 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
854 return sprintf(buf, "%d\n", temp1_from_reg(data->reg)); \
855 }
856 show_temp1_reg(temp1);
857 show_temp1_reg(temp1_max);
858 show_temp1_reg(temp1_max_hyst);
859
860 #define store_temp1_reg(REG, reg) \
861 static ssize_t \
862 store_temp1_##reg(struct device *dev, struct device_attribute *attr, \
863 const char *buf, size_t count) \
864 { \
865 struct w83627ehf_data *data = dev_get_drvdata(dev); \
866 long val = simple_strtol(buf, NULL, 10); \
867 \
868 mutex_lock(&data->update_lock); \
869 data->temp1_##reg = temp1_to_reg(val, -128000, 127000); \
870 w83627ehf_write_value(data, W83627EHF_REG_TEMP1_##REG, \
871 data->temp1_##reg); \
872 mutex_unlock(&data->update_lock); \
873 return count; \
874 }
875 store_temp1_reg(OVER, max);
876 store_temp1_reg(HYST, max_hyst);
877
878 #define show_temp_reg(reg) \
879 static ssize_t \
880 show_##reg(struct device *dev, struct device_attribute *attr, \
881 char *buf) \
882 { \
883 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
884 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
885 int nr = sensor_attr->index; \
886 return sprintf(buf, "%d\n", \
887 LM75_TEMP_FROM_REG(data->reg[nr])); \
888 }
889 show_temp_reg(temp);
890 show_temp_reg(temp_max);
891 show_temp_reg(temp_max_hyst);
892
893 #define store_temp_reg(REG, reg) \
894 static ssize_t \
895 store_##reg(struct device *dev, struct device_attribute *attr, \
896 const char *buf, size_t count) \
897 { \
898 struct w83627ehf_data *data = dev_get_drvdata(dev); \
899 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
900 int nr = sensor_attr->index; \
901 long val = simple_strtol(buf, NULL, 10); \
902 \
903 mutex_lock(&data->update_lock); \
904 data->reg[nr] = LM75_TEMP_TO_REG(val); \
905 w83627ehf_write_value(data, W83627EHF_REG_TEMP_##REG[nr], \
906 data->reg[nr]); \
907 mutex_unlock(&data->update_lock); \
908 return count; \
909 }
910 store_temp_reg(OVER, temp_max);
911 store_temp_reg(HYST, temp_max_hyst);
912
913 static ssize_t
914 show_temp_type(struct device *dev, struct device_attribute *attr, char *buf)
915 {
916 struct w83627ehf_data *data = w83627ehf_update_device(dev);
917 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
918 int nr = sensor_attr->index;
919 return sprintf(buf, "%d\n", (int)data->temp_type[nr]);
920 }
921
922 static struct sensor_device_attribute sda_temp_input[] = {
923 SENSOR_ATTR(temp1_input, S_IRUGO, show_temp1, NULL, 0),
924 SENSOR_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 0),
925 SENSOR_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 1),
926 };
927
928 static struct sensor_device_attribute sda_temp_max[] = {
929 SENSOR_ATTR(temp1_max, S_IRUGO | S_IWUSR, show_temp1_max,
930 store_temp1_max, 0),
931 SENSOR_ATTR(temp2_max, S_IRUGO | S_IWUSR, show_temp_max,
932 store_temp_max, 0),
933 SENSOR_ATTR(temp3_max, S_IRUGO | S_IWUSR, show_temp_max,
934 store_temp_max, 1),
935 };
936
937 static struct sensor_device_attribute sda_temp_max_hyst[] = {
938 SENSOR_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, show_temp1_max_hyst,
939 store_temp1_max_hyst, 0),
940 SENSOR_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
941 store_temp_max_hyst, 0),
942 SENSOR_ATTR(temp3_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
943 store_temp_max_hyst, 1),
944 };
945
946 static struct sensor_device_attribute sda_temp_alarm[] = {
947 SENSOR_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4),
948 SENSOR_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5),
949 SENSOR_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13),
950 };
951
952 static struct sensor_device_attribute sda_temp_type[] = {
953 SENSOR_ATTR(temp1_type, S_IRUGO, show_temp_type, NULL, 0),
954 SENSOR_ATTR(temp2_type, S_IRUGO, show_temp_type, NULL, 1),
955 SENSOR_ATTR(temp3_type, S_IRUGO, show_temp_type, NULL, 2),
956 };
957
958 #define show_pwm_reg(reg) \
959 static ssize_t show_##reg (struct device *dev, struct device_attribute *attr, \
960 char *buf) \
961 { \
962 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
963 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
964 int nr = sensor_attr->index; \
965 return sprintf(buf, "%d\n", data->reg[nr]); \
966 }
967
968 show_pwm_reg(pwm_mode)
969 show_pwm_reg(pwm_enable)
970 show_pwm_reg(pwm)
971
972 static ssize_t
973 store_pwm_mode(struct device *dev, struct device_attribute *attr,
974 const char *buf, size_t count)
975 {
976 struct w83627ehf_data *data = dev_get_drvdata(dev);
977 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
978 int nr = sensor_attr->index;
979 u32 val = simple_strtoul(buf, NULL, 10);
980 u16 reg;
981
982 if (val > 1)
983 return -EINVAL;
984 mutex_lock(&data->update_lock);
985 reg = w83627ehf_read_value(data, W83627EHF_REG_PWM_ENABLE[nr]);
986 data->pwm_mode[nr] = val;
987 reg &= ~(1 << W83627EHF_PWM_MODE_SHIFT[nr]);
988 if (!val)
989 reg |= 1 << W83627EHF_PWM_MODE_SHIFT[nr];
990 w83627ehf_write_value(data, W83627EHF_REG_PWM_ENABLE[nr], reg);
991 mutex_unlock(&data->update_lock);
992 return count;
993 }
994
995 static ssize_t
996 store_pwm(struct device *dev, struct device_attribute *attr,
997 const char *buf, size_t count)
998 {
999 struct w83627ehf_data *data = dev_get_drvdata(dev);
1000 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1001 int nr = sensor_attr->index;
1002 u32 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 0, 255);
1003
1004 mutex_lock(&data->update_lock);
1005 data->pwm[nr] = val;
1006 w83627ehf_write_value(data, W83627EHF_REG_PWM[nr], val);
1007 mutex_unlock(&data->update_lock);
1008 return count;
1009 }
1010
1011 static ssize_t
1012 store_pwm_enable(struct device *dev, struct device_attribute *attr,
1013 const char *buf, size_t count)
1014 {
1015 struct w83627ehf_data *data = dev_get_drvdata(dev);
1016 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1017 int nr = sensor_attr->index;
1018 u32 val = simple_strtoul(buf, NULL, 10);
1019 u16 reg;
1020
1021 if (!val || (val > 4))
1022 return -EINVAL;
1023 mutex_lock(&data->update_lock);
1024 reg = w83627ehf_read_value(data, W83627EHF_REG_PWM_ENABLE[nr]);
1025 data->pwm_enable[nr] = val;
1026 reg &= ~(0x03 << W83627EHF_PWM_ENABLE_SHIFT[nr]);
1027 reg |= (val - 1) << W83627EHF_PWM_ENABLE_SHIFT[nr];
1028 w83627ehf_write_value(data, W83627EHF_REG_PWM_ENABLE[nr], reg);
1029 mutex_unlock(&data->update_lock);
1030 return count;
1031 }
1032
1033
1034 #define show_tol_temp(reg) \
1035 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
1036 char *buf) \
1037 { \
1038 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1039 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
1040 int nr = sensor_attr->index; \
1041 return sprintf(buf, "%d\n", temp1_from_reg(data->reg[nr])); \
1042 }
1043
1044 show_tol_temp(tolerance)
1045 show_tol_temp(target_temp)
1046
1047 static ssize_t
1048 store_target_temp(struct device *dev, struct device_attribute *attr,
1049 const char *buf, size_t count)
1050 {
1051 struct w83627ehf_data *data = dev_get_drvdata(dev);
1052 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1053 int nr = sensor_attr->index;
1054 u8 val = temp1_to_reg(simple_strtoul(buf, NULL, 10), 0, 127000);
1055
1056 mutex_lock(&data->update_lock);
1057 data->target_temp[nr] = val;
1058 w83627ehf_write_value(data, W83627EHF_REG_TARGET[nr], val);
1059 mutex_unlock(&data->update_lock);
1060 return count;
1061 }
1062
1063 static ssize_t
1064 store_tolerance(struct device *dev, struct device_attribute *attr,
1065 const char *buf, size_t count)
1066 {
1067 struct w83627ehf_data *data = dev_get_drvdata(dev);
1068 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1069 int nr = sensor_attr->index;
1070 u16 reg;
1071 /* Limit the temp to 0C - 15C */
1072 u8 val = temp1_to_reg(simple_strtoul(buf, NULL, 10), 0, 15000);
1073
1074 mutex_lock(&data->update_lock);
1075 reg = w83627ehf_read_value(data, W83627EHF_REG_TOLERANCE[nr]);
1076 data->tolerance[nr] = val;
1077 if (nr == 1)
1078 reg = (reg & 0x0f) | (val << 4);
1079 else
1080 reg = (reg & 0xf0) | val;
1081 w83627ehf_write_value(data, W83627EHF_REG_TOLERANCE[nr], reg);
1082 mutex_unlock(&data->update_lock);
1083 return count;
1084 }
1085
1086 static struct sensor_device_attribute sda_pwm[] = {
1087 SENSOR_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 0),
1088 SENSOR_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 1),
1089 SENSOR_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 2),
1090 SENSOR_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 3),
1091 };
1092
1093 static struct sensor_device_attribute sda_pwm_mode[] = {
1094 SENSOR_ATTR(pwm1_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1095 store_pwm_mode, 0),
1096 SENSOR_ATTR(pwm2_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1097 store_pwm_mode, 1),
1098 SENSOR_ATTR(pwm3_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1099 store_pwm_mode, 2),
1100 SENSOR_ATTR(pwm4_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1101 store_pwm_mode, 3),
1102 };
1103
1104 static struct sensor_device_attribute sda_pwm_enable[] = {
1105 SENSOR_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1106 store_pwm_enable, 0),
1107 SENSOR_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1108 store_pwm_enable, 1),
1109 SENSOR_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1110 store_pwm_enable, 2),
1111 SENSOR_ATTR(pwm4_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1112 store_pwm_enable, 3),
1113 };
1114
1115 static struct sensor_device_attribute sda_target_temp[] = {
1116 SENSOR_ATTR(pwm1_target, S_IWUSR | S_IRUGO, show_target_temp,
1117 store_target_temp, 0),
1118 SENSOR_ATTR(pwm2_target, S_IWUSR | S_IRUGO, show_target_temp,
1119 store_target_temp, 1),
1120 SENSOR_ATTR(pwm3_target, S_IWUSR | S_IRUGO, show_target_temp,
1121 store_target_temp, 2),
1122 SENSOR_ATTR(pwm4_target, S_IWUSR | S_IRUGO, show_target_temp,
1123 store_target_temp, 3),
1124 };
1125
1126 static struct sensor_device_attribute sda_tolerance[] = {
1127 SENSOR_ATTR(pwm1_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1128 store_tolerance, 0),
1129 SENSOR_ATTR(pwm2_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1130 store_tolerance, 1),
1131 SENSOR_ATTR(pwm3_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1132 store_tolerance, 2),
1133 SENSOR_ATTR(pwm4_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1134 store_tolerance, 3),
1135 };
1136
1137 /* Smart Fan registers */
1138
1139 #define fan_functions(reg, REG) \
1140 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
1141 char *buf) \
1142 { \
1143 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1144 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
1145 int nr = sensor_attr->index; \
1146 return sprintf(buf, "%d\n", data->reg[nr]); \
1147 }\
1148 static ssize_t \
1149 store_##reg(struct device *dev, struct device_attribute *attr, \
1150 const char *buf, size_t count) \
1151 {\
1152 struct w83627ehf_data *data = dev_get_drvdata(dev); \
1153 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
1154 int nr = sensor_attr->index; \
1155 u32 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 1, 255); \
1156 mutex_lock(&data->update_lock); \
1157 data->reg[nr] = val; \
1158 w83627ehf_write_value(data, data->REG_##REG[nr], val); \
1159 mutex_unlock(&data->update_lock); \
1160 return count; \
1161 }
1162
1163 fan_functions(fan_start_output, FAN_START_OUTPUT)
1164 fan_functions(fan_stop_output, FAN_STOP_OUTPUT)
1165 fan_functions(fan_max_output, FAN_MAX_OUTPUT)
1166 fan_functions(fan_step_output, FAN_STEP_OUTPUT)
1167
1168 #define fan_time_functions(reg, REG) \
1169 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
1170 char *buf) \
1171 { \
1172 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1173 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
1174 int nr = sensor_attr->index; \
1175 return sprintf(buf, "%d\n", \
1176 step_time_from_reg(data->reg[nr], data->pwm_mode[nr])); \
1177 } \
1178 \
1179 static ssize_t \
1180 store_##reg(struct device *dev, struct device_attribute *attr, \
1181 const char *buf, size_t count) \
1182 { \
1183 struct w83627ehf_data *data = dev_get_drvdata(dev); \
1184 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
1185 int nr = sensor_attr->index; \
1186 u8 val = step_time_to_reg(simple_strtoul(buf, NULL, 10), \
1187 data->pwm_mode[nr]); \
1188 mutex_lock(&data->update_lock); \
1189 data->reg[nr] = val; \
1190 w83627ehf_write_value(data, W83627EHF_REG_##REG[nr], val); \
1191 mutex_unlock(&data->update_lock); \
1192 return count; \
1193 } \
1194
1195 fan_time_functions(fan_stop_time, FAN_STOP_TIME)
1196
1197 static ssize_t show_name(struct device *dev, struct device_attribute *attr,
1198 char *buf)
1199 {
1200 struct w83627ehf_data *data = dev_get_drvdata(dev);
1201
1202 return sprintf(buf, "%s\n", data->name);
1203 }
1204 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
1205
1206 static struct sensor_device_attribute sda_sf3_arrays_fan4[] = {
1207 SENSOR_ATTR(pwm4_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1208 store_fan_stop_time, 3),
1209 SENSOR_ATTR(pwm4_start_output, S_IWUSR | S_IRUGO, show_fan_start_output,
1210 store_fan_start_output, 3),
1211 SENSOR_ATTR(pwm4_stop_output, S_IWUSR | S_IRUGO, show_fan_stop_output,
1212 store_fan_stop_output, 3),
1213 SENSOR_ATTR(pwm4_max_output, S_IWUSR | S_IRUGO, show_fan_max_output,
1214 store_fan_max_output, 3),
1215 SENSOR_ATTR(pwm4_step_output, S_IWUSR | S_IRUGO, show_fan_step_output,
1216 store_fan_step_output, 3),
1217 };
1218
1219 static struct sensor_device_attribute sda_sf3_arrays[] = {
1220 SENSOR_ATTR(pwm1_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1221 store_fan_stop_time, 0),
1222 SENSOR_ATTR(pwm2_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1223 store_fan_stop_time, 1),
1224 SENSOR_ATTR(pwm3_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1225 store_fan_stop_time, 2),
1226 SENSOR_ATTR(pwm1_start_output, S_IWUSR | S_IRUGO, show_fan_start_output,
1227 store_fan_start_output, 0),
1228 SENSOR_ATTR(pwm2_start_output, S_IWUSR | S_IRUGO, show_fan_start_output,
1229 store_fan_start_output, 1),
1230 SENSOR_ATTR(pwm3_start_output, S_IWUSR | S_IRUGO, show_fan_start_output,
1231 store_fan_start_output, 2),
1232 SENSOR_ATTR(pwm1_stop_output, S_IWUSR | S_IRUGO, show_fan_stop_output,
1233 store_fan_stop_output, 0),
1234 SENSOR_ATTR(pwm2_stop_output, S_IWUSR | S_IRUGO, show_fan_stop_output,
1235 store_fan_stop_output, 1),
1236 SENSOR_ATTR(pwm3_stop_output, S_IWUSR | S_IRUGO, show_fan_stop_output,
1237 store_fan_stop_output, 2),
1238 };
1239
1240
1241 /*
1242 * pwm1 and pwm3 don't support max and step settings on all chips.
1243 * Need to check support while generating/removing attribute files.
1244 */
1245 static struct sensor_device_attribute sda_sf3_max_step_arrays[] = {
1246 SENSOR_ATTR(pwm1_max_output, S_IWUSR | S_IRUGO, show_fan_max_output,
1247 store_fan_max_output, 0),
1248 SENSOR_ATTR(pwm1_step_output, S_IWUSR | S_IRUGO, show_fan_step_output,
1249 store_fan_step_output, 0),
1250 SENSOR_ATTR(pwm2_max_output, S_IWUSR | S_IRUGO, show_fan_max_output,
1251 store_fan_max_output, 1),
1252 SENSOR_ATTR(pwm2_step_output, S_IWUSR | S_IRUGO, show_fan_step_output,
1253 store_fan_step_output, 1),
1254 SENSOR_ATTR(pwm3_max_output, S_IWUSR | S_IRUGO, show_fan_max_output,
1255 store_fan_max_output, 2),
1256 SENSOR_ATTR(pwm3_step_output, S_IWUSR | S_IRUGO, show_fan_step_output,
1257 store_fan_step_output, 2),
1258 };
1259
1260 static ssize_t
1261 show_vid(struct device *dev, struct device_attribute *attr, char *buf)
1262 {
1263 struct w83627ehf_data *data = dev_get_drvdata(dev);
1264 return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
1265 }
1266 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
1267
1268 /*
1269 * Driver and device management
1270 */
1271
1272 static void w83627ehf_device_remove_files(struct device *dev)
1273 {
1274 /* some entries in the following arrays may not have been used in
1275 * device_create_file(), but device_remove_file() will ignore them */
1276 int i;
1277 struct w83627ehf_data *data = dev_get_drvdata(dev);
1278
1279 for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++)
1280 device_remove_file(dev, &sda_sf3_arrays[i].dev_attr);
1281 for (i = 0; i < ARRAY_SIZE(sda_sf3_max_step_arrays); i++) {
1282 struct sensor_device_attribute *attr =
1283 &sda_sf3_max_step_arrays[i];
1284 if (data->REG_FAN_STEP_OUTPUT[attr->index] != 0xff)
1285 device_remove_file(dev, &attr->dev_attr);
1286 }
1287 for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++)
1288 device_remove_file(dev, &sda_sf3_arrays_fan4[i].dev_attr);
1289 for (i = 0; i < data->in_num; i++) {
1290 if ((i == 6) && data->in6_skip)
1291 continue;
1292 device_remove_file(dev, &sda_in_input[i].dev_attr);
1293 device_remove_file(dev, &sda_in_alarm[i].dev_attr);
1294 device_remove_file(dev, &sda_in_min[i].dev_attr);
1295 device_remove_file(dev, &sda_in_max[i].dev_attr);
1296 }
1297 for (i = 0; i < 5; i++) {
1298 device_remove_file(dev, &sda_fan_input[i].dev_attr);
1299 device_remove_file(dev, &sda_fan_alarm[i].dev_attr);
1300 device_remove_file(dev, &sda_fan_div[i].dev_attr);
1301 device_remove_file(dev, &sda_fan_min[i].dev_attr);
1302 }
1303 for (i = 0; i < data->pwm_num; i++) {
1304 device_remove_file(dev, &sda_pwm[i].dev_attr);
1305 device_remove_file(dev, &sda_pwm_mode[i].dev_attr);
1306 device_remove_file(dev, &sda_pwm_enable[i].dev_attr);
1307 device_remove_file(dev, &sda_target_temp[i].dev_attr);
1308 device_remove_file(dev, &sda_tolerance[i].dev_attr);
1309 }
1310 for (i = 0; i < 3; i++) {
1311 if ((i == 2) && data->temp3_disable)
1312 continue;
1313 device_remove_file(dev, &sda_temp_input[i].dev_attr);
1314 device_remove_file(dev, &sda_temp_max[i].dev_attr);
1315 device_remove_file(dev, &sda_temp_max_hyst[i].dev_attr);
1316 device_remove_file(dev, &sda_temp_alarm[i].dev_attr);
1317 device_remove_file(dev, &sda_temp_type[i].dev_attr);
1318 }
1319
1320 device_remove_file(dev, &dev_attr_name);
1321 device_remove_file(dev, &dev_attr_cpu0_vid);
1322 }
1323
1324 /* Get the monitoring functions started */
1325 static inline void __devinit w83627ehf_init_device(struct w83627ehf_data *data)
1326 {
1327 int i;
1328 u8 tmp, diode;
1329
1330 /* Start monitoring is needed */
1331 tmp = w83627ehf_read_value(data, W83627EHF_REG_CONFIG);
1332 if (!(tmp & 0x01))
1333 w83627ehf_write_value(data, W83627EHF_REG_CONFIG,
1334 tmp | 0x01);
1335
1336 /* Enable temp2 and temp3 if needed */
1337 for (i = 0; i < 2; i++) {
1338 tmp = w83627ehf_read_value(data,
1339 W83627EHF_REG_TEMP_CONFIG[i]);
1340 if ((i == 1) && data->temp3_disable)
1341 continue;
1342 if (tmp & 0x01)
1343 w83627ehf_write_value(data,
1344 W83627EHF_REG_TEMP_CONFIG[i],
1345 tmp & 0xfe);
1346 }
1347
1348 /* Enable VBAT monitoring if needed */
1349 tmp = w83627ehf_read_value(data, W83627EHF_REG_VBAT);
1350 if (!(tmp & 0x01))
1351 w83627ehf_write_value(data, W83627EHF_REG_VBAT, tmp | 0x01);
1352
1353 /* Get thermal sensor types */
1354 diode = w83627ehf_read_value(data, W83627EHF_REG_DIODE);
1355 for (i = 0; i < 3; i++) {
1356 if ((tmp & (0x02 << i)))
1357 data->temp_type[i] = (diode & (0x10 << i)) ? 1 : 2;
1358 else
1359 data->temp_type[i] = 4; /* thermistor */
1360 }
1361 }
1362
1363 static int __devinit w83627ehf_probe(struct platform_device *pdev)
1364 {
1365 struct device *dev = &pdev->dev;
1366 struct w83627ehf_sio_data *sio_data = dev->platform_data;
1367 struct w83627ehf_data *data;
1368 struct resource *res;
1369 u8 fan4pin, fan5pin, en_vrm10;
1370 int i, err = 0;
1371
1372 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1373 if (!request_region(res->start, IOREGION_LENGTH, DRVNAME)) {
1374 err = -EBUSY;
1375 dev_err(dev, "Failed to request region 0x%lx-0x%lx\n",
1376 (unsigned long)res->start,
1377 (unsigned long)res->start + IOREGION_LENGTH - 1);
1378 goto exit;
1379 }
1380
1381 if (!(data = kzalloc(sizeof(struct w83627ehf_data), GFP_KERNEL))) {
1382 err = -ENOMEM;
1383 goto exit_release;
1384 }
1385
1386 data->addr = res->start;
1387 mutex_init(&data->lock);
1388 mutex_init(&data->update_lock);
1389 data->name = w83627ehf_device_names[sio_data->kind];
1390 platform_set_drvdata(pdev, data);
1391
1392 /* 627EHG and 627EHF have 10 voltage inputs; 627DHG and 667HG have 9 */
1393 data->in_num = (sio_data->kind == w83627ehf) ? 10 : 9;
1394 /* 667HG has 3 pwms */
1395 data->pwm_num = (sio_data->kind == w83667hg
1396 || sio_data->kind == w83667hg_b) ? 3 : 4;
1397
1398 /* Check temp3 configuration bit for 667HG */
1399 if (sio_data->kind == w83667hg || sio_data->kind == w83667hg_b) {
1400 data->temp3_disable = w83627ehf_read_value(data,
1401 W83627EHF_REG_TEMP_CONFIG[1]) & 0x01;
1402 data->in6_skip = !data->temp3_disable;
1403 }
1404
1405 data->REG_FAN_START_OUTPUT = W83627EHF_REG_FAN_START_OUTPUT;
1406 data->REG_FAN_STOP_OUTPUT = W83627EHF_REG_FAN_STOP_OUTPUT;
1407 if (sio_data->kind == w83667hg_b) {
1408 data->REG_FAN_MAX_OUTPUT =
1409 W83627EHF_REG_FAN_MAX_OUTPUT_W83667_B;
1410 data->REG_FAN_STEP_OUTPUT =
1411 W83627EHF_REG_FAN_STEP_OUTPUT_W83667_B;
1412 } else {
1413 data->REG_FAN_MAX_OUTPUT =
1414 W83627EHF_REG_FAN_MAX_OUTPUT_COMMON;
1415 data->REG_FAN_STEP_OUTPUT =
1416 W83627EHF_REG_FAN_STEP_OUTPUT_COMMON;
1417 }
1418
1419 /* Initialize the chip */
1420 w83627ehf_init_device(data);
1421
1422 data->vrm = vid_which_vrm();
1423 superio_enter(sio_data->sioreg);
1424 /* Read VID value */
1425 if (sio_data->kind == w83667hg || sio_data->kind == w83667hg_b) {
1426 /* W83667HG has different pins for VID input and output, so
1427 we can get the VID input values directly at logical device D
1428 0xe3. */
1429 superio_select(sio_data->sioreg, W83667HG_LD_VID);
1430 data->vid = superio_inb(sio_data->sioreg, 0xe3);
1431 err = device_create_file(dev, &dev_attr_cpu0_vid);
1432 if (err)
1433 goto exit_release;
1434 } else {
1435 superio_select(sio_data->sioreg, W83627EHF_LD_HWM);
1436 if (superio_inb(sio_data->sioreg, SIO_REG_VID_CTRL) & 0x80) {
1437 /* Set VID input sensibility if needed. In theory the
1438 BIOS should have set it, but in practice it's not
1439 always the case. We only do it for the W83627EHF/EHG
1440 because the W83627DHG is more complex in this
1441 respect. */
1442 if (sio_data->kind == w83627ehf) {
1443 en_vrm10 = superio_inb(sio_data->sioreg,
1444 SIO_REG_EN_VRM10);
1445 if ((en_vrm10 & 0x08) && data->vrm == 90) {
1446 dev_warn(dev, "Setting VID input "
1447 "voltage to TTL\n");
1448 superio_outb(sio_data->sioreg,
1449 SIO_REG_EN_VRM10,
1450 en_vrm10 & ~0x08);
1451 } else if (!(en_vrm10 & 0x08)
1452 && data->vrm == 100) {
1453 dev_warn(dev, "Setting VID input "
1454 "voltage to VRM10\n");
1455 superio_outb(sio_data->sioreg,
1456 SIO_REG_EN_VRM10,
1457 en_vrm10 | 0x08);
1458 }
1459 }
1460
1461 data->vid = superio_inb(sio_data->sioreg,
1462 SIO_REG_VID_DATA);
1463 if (sio_data->kind == w83627ehf) /* 6 VID pins only */
1464 data->vid &= 0x3f;
1465
1466 err = device_create_file(dev, &dev_attr_cpu0_vid);
1467 if (err)
1468 goto exit_release;
1469 } else {
1470 dev_info(dev, "VID pins in output mode, CPU VID not "
1471 "available\n");
1472 }
1473 }
1474
1475 /* fan4 and fan5 share some pins with the GPIO and serial flash */
1476 if (sio_data->kind == w83667hg || sio_data->kind == w83667hg_b) {
1477 fan5pin = superio_inb(sio_data->sioreg, 0x27) & 0x20;
1478 fan4pin = superio_inb(sio_data->sioreg, 0x27) & 0x40;
1479 } else {
1480 fan5pin = !(superio_inb(sio_data->sioreg, 0x24) & 0x02);
1481 fan4pin = !(superio_inb(sio_data->sioreg, 0x29) & 0x06);
1482 }
1483 superio_exit(sio_data->sioreg);
1484
1485 /* It looks like fan4 and fan5 pins can be alternatively used
1486 as fan on/off switches, but fan5 control is write only :/
1487 We assume that if the serial interface is disabled, designers
1488 connected fan5 as input unless they are emitting log 1, which
1489 is not the default. */
1490
1491 data->has_fan = 0x07; /* fan1, fan2 and fan3 */
1492 i = w83627ehf_read_value(data, W83627EHF_REG_FANDIV1);
1493 if ((i & (1 << 2)) && fan4pin)
1494 data->has_fan |= (1 << 3);
1495 if (!(i & (1 << 1)) && fan5pin)
1496 data->has_fan |= (1 << 4);
1497
1498 /* Read fan clock dividers immediately */
1499 w83627ehf_update_fan_div(data);
1500
1501 /* Register sysfs hooks */
1502 for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++)
1503 if ((err = device_create_file(dev,
1504 &sda_sf3_arrays[i].dev_attr)))
1505 goto exit_remove;
1506
1507 for (i = 0; i < ARRAY_SIZE(sda_sf3_max_step_arrays); i++) {
1508 struct sensor_device_attribute *attr =
1509 &sda_sf3_max_step_arrays[i];
1510 if (data->REG_FAN_STEP_OUTPUT[attr->index] != 0xff) {
1511 err = device_create_file(dev, &attr->dev_attr);
1512 if (err)
1513 goto exit_remove;
1514 }
1515 }
1516 /* if fan4 is enabled create the sf3 files for it */
1517 if ((data->has_fan & (1 << 3)) && data->pwm_num >= 4)
1518 for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++) {
1519 if ((err = device_create_file(dev,
1520 &sda_sf3_arrays_fan4[i].dev_attr)))
1521 goto exit_remove;
1522 }
1523
1524 for (i = 0; i < data->in_num; i++) {
1525 if ((i == 6) && data->in6_skip)
1526 continue;
1527 if ((err = device_create_file(dev, &sda_in_input[i].dev_attr))
1528 || (err = device_create_file(dev,
1529 &sda_in_alarm[i].dev_attr))
1530 || (err = device_create_file(dev,
1531 &sda_in_min[i].dev_attr))
1532 || (err = device_create_file(dev,
1533 &sda_in_max[i].dev_attr)))
1534 goto exit_remove;
1535 }
1536
1537 for (i = 0; i < 5; i++) {
1538 if (data->has_fan & (1 << i)) {
1539 if ((err = device_create_file(dev,
1540 &sda_fan_input[i].dev_attr))
1541 || (err = device_create_file(dev,
1542 &sda_fan_alarm[i].dev_attr))
1543 || (err = device_create_file(dev,
1544 &sda_fan_div[i].dev_attr))
1545 || (err = device_create_file(dev,
1546 &sda_fan_min[i].dev_attr)))
1547 goto exit_remove;
1548 if (i < data->pwm_num &&
1549 ((err = device_create_file(dev,
1550 &sda_pwm[i].dev_attr))
1551 || (err = device_create_file(dev,
1552 &sda_pwm_mode[i].dev_attr))
1553 || (err = device_create_file(dev,
1554 &sda_pwm_enable[i].dev_attr))
1555 || (err = device_create_file(dev,
1556 &sda_target_temp[i].dev_attr))
1557 || (err = device_create_file(dev,
1558 &sda_tolerance[i].dev_attr))))
1559 goto exit_remove;
1560 }
1561 }
1562
1563 for (i = 0; i < 3; i++) {
1564 if ((i == 2) && data->temp3_disable)
1565 continue;
1566 if ((err = device_create_file(dev,
1567 &sda_temp_input[i].dev_attr))
1568 || (err = device_create_file(dev,
1569 &sda_temp_max[i].dev_attr))
1570 || (err = device_create_file(dev,
1571 &sda_temp_max_hyst[i].dev_attr))
1572 || (err = device_create_file(dev,
1573 &sda_temp_alarm[i].dev_attr))
1574 || (err = device_create_file(dev,
1575 &sda_temp_type[i].dev_attr)))
1576 goto exit_remove;
1577 }
1578
1579 err = device_create_file(dev, &dev_attr_name);
1580 if (err)
1581 goto exit_remove;
1582
1583 data->hwmon_dev = hwmon_device_register(dev);
1584 if (IS_ERR(data->hwmon_dev)) {
1585 err = PTR_ERR(data->hwmon_dev);
1586 goto exit_remove;
1587 }
1588
1589 return 0;
1590
1591 exit_remove:
1592 w83627ehf_device_remove_files(dev);
1593 kfree(data);
1594 platform_set_drvdata(pdev, NULL);
1595 exit_release:
1596 release_region(res->start, IOREGION_LENGTH);
1597 exit:
1598 return err;
1599 }
1600
1601 static int __devexit w83627ehf_remove(struct platform_device *pdev)
1602 {
1603 struct w83627ehf_data *data = platform_get_drvdata(pdev);
1604
1605 hwmon_device_unregister(data->hwmon_dev);
1606 w83627ehf_device_remove_files(&pdev->dev);
1607 release_region(data->addr, IOREGION_LENGTH);
1608 platform_set_drvdata(pdev, NULL);
1609 kfree(data);
1610
1611 return 0;
1612 }
1613
1614 static struct platform_driver w83627ehf_driver = {
1615 .driver = {
1616 .owner = THIS_MODULE,
1617 .name = DRVNAME,
1618 },
1619 .probe = w83627ehf_probe,
1620 .remove = __devexit_p(w83627ehf_remove),
1621 };
1622
1623 /* w83627ehf_find() looks for a '627 in the Super-I/O config space */
1624 static int __init w83627ehf_find(int sioaddr, unsigned short *addr,
1625 struct w83627ehf_sio_data *sio_data)
1626 {
1627 static const char __initdata sio_name_W83627EHF[] = "W83627EHF";
1628 static const char __initdata sio_name_W83627EHG[] = "W83627EHG";
1629 static const char __initdata sio_name_W83627DHG[] = "W83627DHG";
1630 static const char __initdata sio_name_W83627DHG_P[] = "W83627DHG-P";
1631 static const char __initdata sio_name_W83667HG[] = "W83667HG";
1632 static const char __initdata sio_name_W83667HG_B[] = "W83667HG-B";
1633
1634 u16 val;
1635 const char *sio_name;
1636
1637 superio_enter(sioaddr);
1638
1639 if (force_id)
1640 val = force_id;
1641 else
1642 val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8)
1643 | superio_inb(sioaddr, SIO_REG_DEVID + 1);
1644 switch (val & SIO_ID_MASK) {
1645 case SIO_W83627EHF_ID:
1646 sio_data->kind = w83627ehf;
1647 sio_name = sio_name_W83627EHF;
1648 break;
1649 case SIO_W83627EHG_ID:
1650 sio_data->kind = w83627ehf;
1651 sio_name = sio_name_W83627EHG;
1652 break;
1653 case SIO_W83627DHG_ID:
1654 sio_data->kind = w83627dhg;
1655 sio_name = sio_name_W83627DHG;
1656 break;
1657 case SIO_W83627DHG_P_ID:
1658 sio_data->kind = w83627dhg_p;
1659 sio_name = sio_name_W83627DHG_P;
1660 break;
1661 case SIO_W83667HG_ID:
1662 sio_data->kind = w83667hg;
1663 sio_name = sio_name_W83667HG;
1664 break;
1665 case SIO_W83667HG_B_ID:
1666 sio_data->kind = w83667hg_b;
1667 sio_name = sio_name_W83667HG_B;
1668 break;
1669 default:
1670 if (val != 0xffff)
1671 pr_debug(DRVNAME ": unsupported chip ID: 0x%04x\n",
1672 val);
1673 superio_exit(sioaddr);
1674 return -ENODEV;
1675 }
1676
1677 /* We have a known chip, find the HWM I/O address */
1678 superio_select(sioaddr, W83627EHF_LD_HWM);
1679 val = (superio_inb(sioaddr, SIO_REG_ADDR) << 8)
1680 | superio_inb(sioaddr, SIO_REG_ADDR + 1);
1681 *addr = val & IOREGION_ALIGNMENT;
1682 if (*addr == 0) {
1683 printk(KERN_ERR DRVNAME ": Refusing to enable a Super-I/O "
1684 "device with a base I/O port 0.\n");
1685 superio_exit(sioaddr);
1686 return -ENODEV;
1687 }
1688
1689 /* Activate logical device if needed */
1690 val = superio_inb(sioaddr, SIO_REG_ENABLE);
1691 if (!(val & 0x01)) {
1692 printk(KERN_WARNING DRVNAME ": Forcibly enabling Super-I/O. "
1693 "Sensor is probably unusable.\n");
1694 superio_outb(sioaddr, SIO_REG_ENABLE, val | 0x01);
1695 }
1696
1697 superio_exit(sioaddr);
1698 pr_info(DRVNAME ": Found %s chip at %#x\n", sio_name, *addr);
1699 sio_data->sioreg = sioaddr;
1700
1701 return 0;
1702 }
1703
1704 /* when Super-I/O functions move to a separate file, the Super-I/O
1705 * bus will manage the lifetime of the device and this module will only keep
1706 * track of the w83627ehf driver. But since we platform_device_alloc(), we
1707 * must keep track of the device */
1708 static struct platform_device *pdev;
1709
1710 static int __init sensors_w83627ehf_init(void)
1711 {
1712 int err;
1713 unsigned short address;
1714 struct resource res;
1715 struct w83627ehf_sio_data sio_data;
1716
1717 /* initialize sio_data->kind and sio_data->sioreg.
1718 *
1719 * when Super-I/O functions move to a separate file, the Super-I/O
1720 * driver will probe 0x2e and 0x4e and auto-detect the presence of a
1721 * w83627ehf hardware monitor, and call probe() */
1722 if (w83627ehf_find(0x2e, &address, &sio_data) &&
1723 w83627ehf_find(0x4e, &address, &sio_data))
1724 return -ENODEV;
1725
1726 err = platform_driver_register(&w83627ehf_driver);
1727 if (err)
1728 goto exit;
1729
1730 if (!(pdev = platform_device_alloc(DRVNAME, address))) {
1731 err = -ENOMEM;
1732 printk(KERN_ERR DRVNAME ": Device allocation failed\n");
1733 goto exit_unregister;
1734 }
1735
1736 err = platform_device_add_data(pdev, &sio_data,
1737 sizeof(struct w83627ehf_sio_data));
1738 if (err) {
1739 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
1740 goto exit_device_put;
1741 }
1742
1743 memset(&res, 0, sizeof(res));
1744 res.name = DRVNAME;
1745 res.start = address + IOREGION_OFFSET;
1746 res.end = address + IOREGION_OFFSET + IOREGION_LENGTH - 1;
1747 res.flags = IORESOURCE_IO;
1748
1749 err = acpi_check_resource_conflict(&res);
1750 if (err)
1751 goto exit_device_put;
1752
1753 err = platform_device_add_resources(pdev, &res, 1);
1754 if (err) {
1755 printk(KERN_ERR DRVNAME ": Device resource addition failed "
1756 "(%d)\n", err);
1757 goto exit_device_put;
1758 }
1759
1760 /* platform_device_add calls probe() */
1761 err = platform_device_add(pdev);
1762 if (err) {
1763 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
1764 err);
1765 goto exit_device_put;
1766 }
1767
1768 return 0;
1769
1770 exit_device_put:
1771 platform_device_put(pdev);
1772 exit_unregister:
1773 platform_driver_unregister(&w83627ehf_driver);
1774 exit:
1775 return err;
1776 }
1777
1778 static void __exit sensors_w83627ehf_exit(void)
1779 {
1780 platform_device_unregister(pdev);
1781 platform_driver_unregister(&w83627ehf_driver);
1782 }
1783
1784 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
1785 MODULE_DESCRIPTION("W83627EHF driver");
1786 MODULE_LICENSE("GPL");
1787
1788 module_init(sensors_w83627ehf_init);
1789 module_exit(sensors_w83627ehf_exit);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree