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