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