?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
hwmon: (w83627ehf) Better fix for negative temperature values
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / hwmon / w83627ehf.c
blob98aab4bea34280925f84465ecf7d3222cbc6d3ea
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 Copyright (C) 2010 Sheng-Yuan Huang (Nuvoton) (PS00)
10
11 Shamelessly ripped from the w83627hf driver
12 Copyright (C) 2003 Mark Studebaker
13
14 Thanks to Leon Moonen, Steve Cliffe and Grant Coady for their help
15 in testing and debugging this driver.
16
17 This driver also supports the W83627EHG, which is the lead-free
18 version of the W83627EHF.
19
20 This program is free software; you can redistribute it and/or modify
21 it under the terms of the GNU General Public License as published by
22 the Free Software Foundation; either version 2 of the License, or
23 (at your option) any later version.
24
25 This program is distributed in the hope that it will be useful,
26 but WITHOUT ANY WARRANTY; without even the implied warranty of
27 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
28 GNU General Public License for more details.
29
30 You should have received a copy of the GNU General Public License
31 along with this program; if not, write to the Free Software
32 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
33
34
35 Supports the following chips:
36
37 Chip #vin #fan #pwm #temp chip IDs man ID
38 w83627ehf 10 5 4 3 0x8850 0x88 0x5ca3
39 0x8860 0xa1
40 w83627dhg 9 5 4 3 0xa020 0xc1 0x5ca3
41 w83627dhg-p 9 5 4 3 0xb070 0xc1 0x5ca3
42 w83667hg 9 5 3 3 0xa510 0xc1 0x5ca3
43 w83667hg-b 9 5 3 4 0xb350 0xc1 0x5ca3
44 nct6775f 9 4 3 9 0xb470 0xc1 0x5ca3
45 nct6776f 9 5 3 9 0xC330 0xc1 0x5ca3
46 */
47
48 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
49
50 #include <linux/module.h>
51 #include <linux/init.h>
52 #include <linux/slab.h>
53 #include <linux/jiffies.h>
54 #include <linux/platform_device.h>
55 #include <linux/hwmon.h>
56 #include <linux/hwmon-sysfs.h>
57 #include <linux/hwmon-vid.h>
58 #include <linux/err.h>
59 #include <linux/mutex.h>
60 #include <linux/acpi.h>
61 #include <linux/io.h>
62 #include "lm75.h"
63
64 enum kinds { w83627ehf, w83627dhg, w83627dhg_p, w83667hg, w83667hg_b, nct6775,
65 nct6776 };
66
67 /* used to set data->name = w83627ehf_device_names[data->sio_kind] */
68 static const char * const w83627ehf_device_names[] = {
69 "w83627ehf",
70 "w83627dhg",
71 "w83627dhg",
72 "w83667hg",
73 "w83667hg",
74 "nct6775",
75 "nct6776",
76 };
77
78 static unsigned short force_id;
79 module_param(force_id, ushort, 0);
80 MODULE_PARM_DESC(force_id, "Override the detected device ID");
81
82 static unsigned short fan_debounce;
83 module_param(fan_debounce, ushort, 0);
84 MODULE_PARM_DESC(fan_debounce, "Enable debouncing for fan RPM signal");
85
86 #define DRVNAME "w83627ehf"
87
88 /*
89 * Super-I/O constants and functions
90 */
91
92 #define W83627EHF_LD_HWM 0x0b
93 #define W83667HG_LD_VID 0x0d
94
95 #define SIO_REG_LDSEL 0x07 /* Logical device select */
96 #define SIO_REG_DEVID 0x20 /* Device ID (2 bytes) */
97 #define SIO_REG_EN_VRM10 0x2C /* GPIO3, GPIO4 selection */
98 #define SIO_REG_ENABLE 0x30 /* Logical device enable */
99 #define SIO_REG_ADDR 0x60 /* Logical device address (2 bytes) */
100 #define SIO_REG_VID_CTRL 0xF0 /* VID control */
101 #define SIO_REG_VID_DATA 0xF1 /* VID data */
102
103 #define SIO_W83627EHF_ID 0x8850
104 #define SIO_W83627EHG_ID 0x8860
105 #define SIO_W83627DHG_ID 0xa020
106 #define SIO_W83627DHG_P_ID 0xb070
107 #define SIO_W83667HG_ID 0xa510
108 #define SIO_W83667HG_B_ID 0xb350
109 #define SIO_NCT6775_ID 0xb470
110 #define SIO_NCT6776_ID 0xc330
111 #define SIO_ID_MASK 0xFFF0
112
113 static inline void
114 superio_outb(int ioreg, int reg, int val)
115 {
116 outb(reg, ioreg);
117 outb(val, ioreg + 1);
118 }
119
120 static inline int
121 superio_inb(int ioreg, int reg)
122 {
123 outb(reg, ioreg);
124 return inb(ioreg + 1);
125 }
126
127 static inline void
128 superio_select(int ioreg, int ld)
129 {
130 outb(SIO_REG_LDSEL, ioreg);
131 outb(ld, ioreg + 1);
132 }
133
134 static inline void
135 superio_enter(int ioreg)
136 {
137 outb(0x87, ioreg);
138 outb(0x87, ioreg);
139 }
140
141 static inline void
142 superio_exit(int ioreg)
143 {
144 outb(0xaa, ioreg);
145 outb(0x02, ioreg);
146 outb(0x02, ioreg + 1);
147 }
148
149 /*
150 * ISA constants
151 */
152
153 #define IOREGION_ALIGNMENT (~7)
154 #define IOREGION_OFFSET 5
155 #define IOREGION_LENGTH 2
156 #define ADDR_REG_OFFSET 0
157 #define DATA_REG_OFFSET 1
158
159 #define W83627EHF_REG_BANK 0x4E
160 #define W83627EHF_REG_CONFIG 0x40
161
162 /* Not currently used:
163 * REG_MAN_ID has the value 0x5ca3 for all supported chips.
164 * REG_CHIP_ID == 0x88/0xa1/0xc1 depending on chip model.
165 * REG_MAN_ID is at port 0x4f
166 * REG_CHIP_ID is at port 0x58 */
167
168 static const u16 W83627EHF_REG_FAN[] = { 0x28, 0x29, 0x2a, 0x3f, 0x553 };
169 static const u16 W83627EHF_REG_FAN_MIN[] = { 0x3b, 0x3c, 0x3d, 0x3e, 0x55c };
170
171 /* The W83627EHF registers for nr=7,8,9 are in bank 5 */
172 #define W83627EHF_REG_IN_MAX(nr) ((nr < 7) ? (0x2b + (nr) * 2) : \
173 (0x554 + (((nr) - 7) * 2)))
174 #define W83627EHF_REG_IN_MIN(nr) ((nr < 7) ? (0x2c + (nr) * 2) : \
175 (0x555 + (((nr) - 7) * 2)))
176 #define W83627EHF_REG_IN(nr) ((nr < 7) ? (0x20 + (nr)) : \
177 (0x550 + (nr) - 7))
178
179 static const u16 W83627EHF_REG_TEMP[] = { 0x27, 0x150, 0x250, 0x7e };
180 static const u16 W83627EHF_REG_TEMP_HYST[] = { 0x3a, 0x153, 0x253, 0 };
181 static const u16 W83627EHF_REG_TEMP_OVER[] = { 0x39, 0x155, 0x255, 0 };
182 static const u16 W83627EHF_REG_TEMP_CONFIG[] = { 0, 0x152, 0x252, 0 };
183
184 /* Fan clock dividers are spread over the following five registers */
185 #define W83627EHF_REG_FANDIV1 0x47
186 #define W83627EHF_REG_FANDIV2 0x4B
187 #define W83627EHF_REG_VBAT 0x5D
188 #define W83627EHF_REG_DIODE 0x59
189 #define W83627EHF_REG_SMI_OVT 0x4C
190
191 /* NCT6775F has its own fan divider registers */
192 #define NCT6775_REG_FANDIV1 0x506
193 #define NCT6775_REG_FANDIV2 0x507
194 #define NCT6775_REG_FAN_DEBOUNCE 0xf0
195
196 #define W83627EHF_REG_ALARM1 0x459
197 #define W83627EHF_REG_ALARM2 0x45A
198 #define W83627EHF_REG_ALARM3 0x45B
199
200 #define W83627EHF_REG_CASEOPEN_DET 0x42 /* SMI STATUS #2 */
201 #define W83627EHF_REG_CASEOPEN_CLR 0x46 /* SMI MASK #3 */
202
203 /* SmartFan registers */
204 #define W83627EHF_REG_FAN_STEPUP_TIME 0x0f
205 #define W83627EHF_REG_FAN_STEPDOWN_TIME 0x0e
206
207 /* DC or PWM output fan configuration */
208 static const u8 W83627EHF_REG_PWM_ENABLE[] = {
209 0x04, /* SYS FAN0 output mode and PWM mode */
210 0x04, /* CPU FAN0 output mode and PWM mode */
211 0x12, /* AUX FAN mode */
212 0x62, /* CPU FAN1 mode */
213 };
214
215 static const u8 W83627EHF_PWM_MODE_SHIFT[] = { 0, 1, 0, 6 };
216 static const u8 W83627EHF_PWM_ENABLE_SHIFT[] = { 2, 4, 1, 4 };
217
218 /* FAN Duty Cycle, be used to control */
219 static const u16 W83627EHF_REG_PWM[] = { 0x01, 0x03, 0x11, 0x61 };
220 static const u16 W83627EHF_REG_TARGET[] = { 0x05, 0x06, 0x13, 0x63 };
221 static const u8 W83627EHF_REG_TOLERANCE[] = { 0x07, 0x07, 0x14, 0x62 };
222
223 /* Advanced Fan control, some values are common for all fans */
224 static const u16 W83627EHF_REG_FAN_START_OUTPUT[] = { 0x0a, 0x0b, 0x16, 0x65 };
225 static const u16 W83627EHF_REG_FAN_STOP_OUTPUT[] = { 0x08, 0x09, 0x15, 0x64 };
226 static const u16 W83627EHF_REG_FAN_STOP_TIME[] = { 0x0c, 0x0d, 0x17, 0x66 };
227
228 static const u16 W83627EHF_REG_FAN_MAX_OUTPUT_COMMON[]
229 = { 0xff, 0x67, 0xff, 0x69 };
230 static const u16 W83627EHF_REG_FAN_STEP_OUTPUT_COMMON[]
231 = { 0xff, 0x68, 0xff, 0x6a };
232
233 static const u16 W83627EHF_REG_FAN_MAX_OUTPUT_W83667_B[] = { 0x67, 0x69, 0x6b };
234 static const u16 W83627EHF_REG_FAN_STEP_OUTPUT_W83667_B[]
235 = { 0x68, 0x6a, 0x6c };
236
237 static const u16 NCT6775_REG_TARGET[] = { 0x101, 0x201, 0x301 };
238 static const u16 NCT6775_REG_FAN_MODE[] = { 0x102, 0x202, 0x302 };
239 static const u16 NCT6775_REG_FAN_STOP_OUTPUT[] = { 0x105, 0x205, 0x305 };
240 static const u16 NCT6775_REG_FAN_START_OUTPUT[] = { 0x106, 0x206, 0x306 };
241 static const u16 NCT6775_REG_FAN_STOP_TIME[] = { 0x107, 0x207, 0x307 };
242 static const u16 NCT6775_REG_PWM[] = { 0x109, 0x209, 0x309 };
243 static const u16 NCT6775_REG_FAN_MAX_OUTPUT[] = { 0x10a, 0x20a, 0x30a };
244 static const u16 NCT6775_REG_FAN_STEP_OUTPUT[] = { 0x10b, 0x20b, 0x30b };
245 static const u16 NCT6775_REG_FAN[] = { 0x630, 0x632, 0x634, 0x636, 0x638 };
246 static const u16 NCT6776_REG_FAN_MIN[] = { 0x63a, 0x63c, 0x63e, 0x640, 0x642};
247
248 static const u16 NCT6775_REG_TEMP[]
249 = { 0x27, 0x150, 0x250, 0x73, 0x75, 0x77, 0x62b, 0x62c, 0x62d };
250 static const u16 NCT6775_REG_TEMP_CONFIG[]
251 = { 0, 0x152, 0x252, 0, 0, 0, 0x628, 0x629, 0x62A };
252 static const u16 NCT6775_REG_TEMP_HYST[]
253 = { 0x3a, 0x153, 0x253, 0, 0, 0, 0x673, 0x678, 0x67D };
254 static const u16 NCT6775_REG_TEMP_OVER[]
255 = { 0x39, 0x155, 0x255, 0, 0, 0, 0x672, 0x677, 0x67C };
256 static const u16 NCT6775_REG_TEMP_SOURCE[]
257 = { 0x621, 0x622, 0x623, 0x100, 0x200, 0x300, 0x624, 0x625, 0x626 };
258
259 static const char *const w83667hg_b_temp_label[] = {
260 "SYSTIN",
261 "CPUTIN",
262 "AUXTIN",
263 "AMDTSI",
264 "PECI Agent 1",
265 "PECI Agent 2",
266 "PECI Agent 3",
267 "PECI Agent 4"
268 };
269
270 static const char *const nct6775_temp_label[] = {
271 "",
272 "SYSTIN",
273 "CPUTIN",
274 "AUXTIN",
275 "AMD SB-TSI",
276 "PECI Agent 0",
277 "PECI Agent 1",
278 "PECI Agent 2",
279 "PECI Agent 3",
280 "PECI Agent 4",
281 "PECI Agent 5",
282 "PECI Agent 6",
283 "PECI Agent 7",
284 "PCH_CHIP_CPU_MAX_TEMP",
285 "PCH_CHIP_TEMP",
286 "PCH_CPU_TEMP",
287 "PCH_MCH_TEMP",
288 "PCH_DIM0_TEMP",
289 "PCH_DIM1_TEMP",
290 "PCH_DIM2_TEMP",
291 "PCH_DIM3_TEMP"
292 };
293
294 static const char *const nct6776_temp_label[] = {
295 "",
296 "SYSTIN",
297 "CPUTIN",
298 "AUXTIN",
299 "SMBUSMASTER 0",
300 "SMBUSMASTER 1",
301 "SMBUSMASTER 2",
302 "SMBUSMASTER 3",
303 "SMBUSMASTER 4",
304 "SMBUSMASTER 5",
305 "SMBUSMASTER 6",
306 "SMBUSMASTER 7",
307 "PECI Agent 0",
308 "PECI Agent 1",
309 "PCH_CHIP_CPU_MAX_TEMP",
310 "PCH_CHIP_TEMP",
311 "PCH_CPU_TEMP",
312 "PCH_MCH_TEMP",
313 "PCH_DIM0_TEMP",
314 "PCH_DIM1_TEMP",
315 "PCH_DIM2_TEMP",
316 "PCH_DIM3_TEMP",
317 "BYTE_TEMP"
318 };
319
320 #define NUM_REG_TEMP ARRAY_SIZE(NCT6775_REG_TEMP)
321
322 static int is_word_sized(u16 reg)
323 {
324 return ((((reg & 0xff00) == 0x100
325 || (reg & 0xff00) == 0x200)
326 && ((reg & 0x00ff) == 0x50
327 || (reg & 0x00ff) == 0x53
328 || (reg & 0x00ff) == 0x55))
329 || (reg & 0xfff0) == 0x630
330 || reg == 0x640 || reg == 0x642
331 || ((reg & 0xfff0) == 0x650
332 && (reg & 0x000f) >= 0x06)
333 || reg == 0x73 || reg == 0x75 || reg == 0x77
334 );
335 }
336
337 /*
338 * Conversions
339 */
340
341 /* 1 is PWM mode, output in ms */
342 static inline unsigned int step_time_from_reg(u8 reg, u8 mode)
343 {
344 return mode ? 100 * reg : 400 * reg;
345 }
346
347 static inline u8 step_time_to_reg(unsigned int msec, u8 mode)
348 {
349 return SENSORS_LIMIT((mode ? (msec + 50) / 100 :
350 (msec + 200) / 400), 1, 255);
351 }
352
353 static unsigned int fan_from_reg8(u16 reg, unsigned int divreg)
354 {
355 if (reg == 0 || reg == 255)
356 return 0;
357 return 1350000U / (reg << divreg);
358 }
359
360 static unsigned int fan_from_reg13(u16 reg, unsigned int divreg)
361 {
362 if ((reg & 0xff1f) == 0xff1f)
363 return 0;
364
365 reg = (reg & 0x1f) | ((reg & 0xff00) >> 3);
366
367 if (reg == 0)
368 return 0;
369
370 return 1350000U / reg;
371 }
372
373 static unsigned int fan_from_reg16(u16 reg, unsigned int divreg)
374 {
375 if (reg == 0 || reg == 0xffff)
376 return 0;
377
378 /*
379 * Even though the registers are 16 bit wide, the fan divisor
380 * still applies.
381 */
382 return 1350000U / (reg << divreg);
383 }
384
385 static inline unsigned int
386 div_from_reg(u8 reg)
387 {
388 return 1 << reg;
389 }
390
391 /* Some of analog inputs have internal scaling (2x), 8mV is ADC LSB */
392
393 static u8 scale_in[10] = { 8, 8, 16, 16, 8, 8, 8, 16, 16, 8 };
394
395 static inline long in_from_reg(u8 reg, u8 nr)
396 {
397 return reg * scale_in[nr];
398 }
399
400 static inline u8 in_to_reg(u32 val, u8 nr)
401 {
402 return SENSORS_LIMIT(((val + (scale_in[nr] / 2)) / scale_in[nr]), 0,
403 255);
404 }
405
406 /*
407 * Data structures and manipulation thereof
408 */
409
410 struct w83627ehf_data {
411 int addr; /* IO base of hw monitor block */
412 const char *name;
413
414 struct device *hwmon_dev;
415 struct mutex lock;
416
417 u16 reg_temp[NUM_REG_TEMP];
418 u16 reg_temp_over[NUM_REG_TEMP];
419 u16 reg_temp_hyst[NUM_REG_TEMP];
420 u16 reg_temp_config[NUM_REG_TEMP];
421 u8 temp_src[NUM_REG_TEMP];
422 const char * const *temp_label;
423
424 const u16 *REG_PWM;
425 const u16 *REG_TARGET;
426 const u16 *REG_FAN;
427 const u16 *REG_FAN_MIN;
428 const u16 *REG_FAN_START_OUTPUT;
429 const u16 *REG_FAN_STOP_OUTPUT;
430 const u16 *REG_FAN_STOP_TIME;
431 const u16 *REG_FAN_MAX_OUTPUT;
432 const u16 *REG_FAN_STEP_OUTPUT;
433
434 unsigned int (*fan_from_reg)(u16 reg, unsigned int divreg);
435 unsigned int (*fan_from_reg_min)(u16 reg, unsigned int divreg);
436
437 struct mutex update_lock;
438 char valid; /* !=0 if following fields are valid */
439 unsigned long last_updated; /* In jiffies */
440
441 /* Register values */
442 u8 bank; /* current register bank */
443 u8 in_num; /* number of in inputs we have */
444 u8 in[10]; /* Register value */
445 u8 in_max[10]; /* Register value */
446 u8 in_min[10]; /* Register value */
447 unsigned int rpm[5];
448 u16 fan_min[5];
449 u8 fan_div[5];
450 u8 has_fan; /* some fan inputs can be disabled */
451 u8 has_fan_min; /* some fans don't have min register */
452 bool has_fan_div;
453 u8 temp_type[3];
454 s16 temp[9];
455 s16 temp_max[9];
456 s16 temp_max_hyst[9];
457 u32 alarms;
458 u8 caseopen;
459
460 u8 pwm_mode[4]; /* 0->DC variable voltage, 1->PWM variable duty cycle */
461 u8 pwm_enable[4]; /* 1->manual
462 2->thermal cruise mode (also called SmartFan I)
463 3->fan speed cruise mode
464 4->variable thermal cruise (also called
465 SmartFan III)
466 5->enhanced variable thermal cruise (also called
467 SmartFan IV) */
468 u8 pwm_enable_orig[4]; /* original value of pwm_enable */
469 u8 pwm_num; /* number of pwm */
470 u8 pwm[4];
471 u8 target_temp[4];
472 u8 tolerance[4];
473
474 u8 fan_start_output[4]; /* minimum fan speed when spinning up */
475 u8 fan_stop_output[4]; /* minimum fan speed when spinning down */
476 u8 fan_stop_time[4]; /* time at minimum before disabling fan */
477 u8 fan_max_output[4]; /* maximum fan speed */
478 u8 fan_step_output[4]; /* rate of change output value */
479
480 u8 vid;
481 u8 vrm;
482
483 u16 have_temp;
484 u8 in6_skip;
485 };
486
487 struct w83627ehf_sio_data {
488 int sioreg;
489 enum kinds kind;
490 };
491
492 /*
493 * On older chips, only registers 0x50-0x5f are banked.
494 * On more recent chips, all registers are banked.
495 * Assume that is the case and set the bank number for each access.
496 * Cache the bank number so it only needs to be set if it changes.
497 */
498 static inline void w83627ehf_set_bank(struct w83627ehf_data *data, u16 reg)
499 {
500 u8 bank = reg >> 8;
501 if (data->bank != bank) {
502 outb_p(W83627EHF_REG_BANK, data->addr + ADDR_REG_OFFSET);
503 outb_p(bank, data->addr + DATA_REG_OFFSET);
504 data->bank = bank;
505 }
506 }
507
508 static u16 w83627ehf_read_value(struct w83627ehf_data *data, u16 reg)
509 {
510 int res, word_sized = is_word_sized(reg);
511
512 mutex_lock(&data->lock);
513
514 w83627ehf_set_bank(data, reg);
515 outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET);
516 res = inb_p(data->addr + DATA_REG_OFFSET);
517 if (word_sized) {
518 outb_p((reg & 0xff) + 1,
519 data->addr + ADDR_REG_OFFSET);
520 res = (res << 8) + inb_p(data->addr + DATA_REG_OFFSET);
521 }
522
523 mutex_unlock(&data->lock);
524 return res;
525 }
526
527 static int w83627ehf_write_value(struct w83627ehf_data *data, u16 reg,
528 u16 value)
529 {
530 int word_sized = is_word_sized(reg);
531
532 mutex_lock(&data->lock);
533
534 w83627ehf_set_bank(data, reg);
535 outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET);
536 if (word_sized) {
537 outb_p(value >> 8, data->addr + DATA_REG_OFFSET);
538 outb_p((reg & 0xff) + 1,
539 data->addr + ADDR_REG_OFFSET);
540 }
541 outb_p(value & 0xff, data->addr + DATA_REG_OFFSET);
542
543 mutex_unlock(&data->lock);
544 return 0;
545 }
546
547 /* We left-align 8-bit temperature values to make the code simpler */
548 static u16 w83627ehf_read_temp(struct w83627ehf_data *data, u16 reg)
549 {
550 u16 res;
551
552 res = w83627ehf_read_value(data, reg);
553 if (!is_word_sized(reg))
554 res <<= 8;
555
556 return res;
557 }
558
559 static int w83627ehf_write_temp(struct w83627ehf_data *data, u16 reg,
560 u16 value)
561 {
562 if (!is_word_sized(reg))
563 value >>= 8;
564 return w83627ehf_write_value(data, reg, value);
565 }
566
567 /* This function assumes that the caller holds data->update_lock */
568 static void nct6775_write_fan_div(struct w83627ehf_data *data, int nr)
569 {
570 u8 reg;
571
572 switch (nr) {
573 case 0:
574 reg = (w83627ehf_read_value(data, NCT6775_REG_FANDIV1) & 0x70)
575 | (data->fan_div[0] & 0x7);
576 w83627ehf_write_value(data, NCT6775_REG_FANDIV1, reg);
577 break;
578 case 1:
579 reg = (w83627ehf_read_value(data, NCT6775_REG_FANDIV1) & 0x7)
580 | ((data->fan_div[1] << 4) & 0x70);
581 w83627ehf_write_value(data, NCT6775_REG_FANDIV1, reg);
582 case 2:
583 reg = (w83627ehf_read_value(data, NCT6775_REG_FANDIV2) & 0x70)
584 | (data->fan_div[2] & 0x7);
585 w83627ehf_write_value(data, NCT6775_REG_FANDIV2, reg);
586 break;
587 case 3:
588 reg = (w83627ehf_read_value(data, NCT6775_REG_FANDIV2) & 0x7)
589 | ((data->fan_div[3] << 4) & 0x70);
590 w83627ehf_write_value(data, NCT6775_REG_FANDIV2, reg);
591 break;
592 }
593 }
594
595 /* This function assumes that the caller holds data->update_lock */
596 static void w83627ehf_write_fan_div(struct w83627ehf_data *data, int nr)
597 {
598 u8 reg;
599
600 switch (nr) {
601 case 0:
602 reg = (w83627ehf_read_value(data, W83627EHF_REG_FANDIV1) & 0xcf)
603 | ((data->fan_div[0] & 0x03) << 4);
604 /* fan5 input control bit is write only, compute the value */
605 reg |= (data->has_fan & (1 << 4)) ? 1 : 0;
606 w83627ehf_write_value(data, W83627EHF_REG_FANDIV1, reg);
607 reg = (w83627ehf_read_value(data, W83627EHF_REG_VBAT) & 0xdf)
608 | ((data->fan_div[0] & 0x04) << 3);
609 w83627ehf_write_value(data, W83627EHF_REG_VBAT, reg);
610 break;
611 case 1:
612 reg = (w83627ehf_read_value(data, W83627EHF_REG_FANDIV1) & 0x3f)
613 | ((data->fan_div[1] & 0x03) << 6);
614 /* fan5 input control bit is write only, compute the value */
615 reg |= (data->has_fan & (1 << 4)) ? 1 : 0;
616 w83627ehf_write_value(data, W83627EHF_REG_FANDIV1, reg);
617 reg = (w83627ehf_read_value(data, W83627EHF_REG_VBAT) & 0xbf)
618 | ((data->fan_div[1] & 0x04) << 4);
619 w83627ehf_write_value(data, W83627EHF_REG_VBAT, reg);
620 break;
621 case 2:
622 reg = (w83627ehf_read_value(data, W83627EHF_REG_FANDIV2) & 0x3f)
623 | ((data->fan_div[2] & 0x03) << 6);
624 w83627ehf_write_value(data, W83627EHF_REG_FANDIV2, reg);
625 reg = (w83627ehf_read_value(data, W83627EHF_REG_VBAT) & 0x7f)
626 | ((data->fan_div[2] & 0x04) << 5);
627 w83627ehf_write_value(data, W83627EHF_REG_VBAT, reg);
628 break;
629 case 3:
630 reg = (w83627ehf_read_value(data, W83627EHF_REG_DIODE) & 0xfc)
631 | (data->fan_div[3] & 0x03);
632 w83627ehf_write_value(data, W83627EHF_REG_DIODE, reg);
633 reg = (w83627ehf_read_value(data, W83627EHF_REG_SMI_OVT) & 0x7f)
634 | ((data->fan_div[3] & 0x04) << 5);
635 w83627ehf_write_value(data, W83627EHF_REG_SMI_OVT, reg);
636 break;
637 case 4:
638 reg = (w83627ehf_read_value(data, W83627EHF_REG_DIODE) & 0x73)
639 | ((data->fan_div[4] & 0x03) << 2)
640 | ((data->fan_div[4] & 0x04) << 5);
641 w83627ehf_write_value(data, W83627EHF_REG_DIODE, reg);
642 break;
643 }
644 }
645
646 static void w83627ehf_write_fan_div_common(struct device *dev,
647 struct w83627ehf_data *data, int nr)
648 {
649 struct w83627ehf_sio_data *sio_data = dev->platform_data;
650
651 if (sio_data->kind == nct6776)
652 ; /* no dividers, do nothing */
653 else if (sio_data->kind == nct6775)
654 nct6775_write_fan_div(data, nr);
655 else
656 w83627ehf_write_fan_div(data, nr);
657 }
658
659 static void nct6775_update_fan_div(struct w83627ehf_data *data)
660 {
661 u8 i;
662
663 i = w83627ehf_read_value(data, NCT6775_REG_FANDIV1);
664 data->fan_div[0] = i & 0x7;
665 data->fan_div[1] = (i & 0x70) >> 4;
666 i = w83627ehf_read_value(data, NCT6775_REG_FANDIV2);
667 data->fan_div[2] = i & 0x7;
668 if (data->has_fan & (1<<3))
669 data->fan_div[3] = (i & 0x70) >> 4;
670 }
671
672 static void w83627ehf_update_fan_div(struct w83627ehf_data *data)
673 {
674 int i;
675
676 i = w83627ehf_read_value(data, W83627EHF_REG_FANDIV1);
677 data->fan_div[0] = (i >> 4) & 0x03;
678 data->fan_div[1] = (i >> 6) & 0x03;
679 i = w83627ehf_read_value(data, W83627EHF_REG_FANDIV2);
680 data->fan_div[2] = (i >> 6) & 0x03;
681 i = w83627ehf_read_value(data, W83627EHF_REG_VBAT);
682 data->fan_div[0] |= (i >> 3) & 0x04;
683 data->fan_div[1] |= (i >> 4) & 0x04;
684 data->fan_div[2] |= (i >> 5) & 0x04;
685 if (data->has_fan & ((1 << 3) | (1 << 4))) {
686 i = w83627ehf_read_value(data, W83627EHF_REG_DIODE);
687 data->fan_div[3] = i & 0x03;
688 data->fan_div[4] = ((i >> 2) & 0x03)
689 | ((i >> 5) & 0x04);
690 }
691 if (data->has_fan & (1 << 3)) {
692 i = w83627ehf_read_value(data, W83627EHF_REG_SMI_OVT);
693 data->fan_div[3] |= (i >> 5) & 0x04;
694 }
695 }
696
697 static void w83627ehf_update_fan_div_common(struct device *dev,
698 struct w83627ehf_data *data)
699 {
700 struct w83627ehf_sio_data *sio_data = dev->platform_data;
701
702 if (sio_data->kind == nct6776)
703 ; /* no dividers, do nothing */
704 else if (sio_data->kind == nct6775)
705 nct6775_update_fan_div(data);
706 else
707 w83627ehf_update_fan_div(data);
708 }
709
710 static void nct6775_update_pwm(struct w83627ehf_data *data)
711 {
712 int i;
713 int pwmcfg, fanmodecfg;
714
715 for (i = 0; i < data->pwm_num; i++) {
716 pwmcfg = w83627ehf_read_value(data,
717 W83627EHF_REG_PWM_ENABLE[i]);
718 fanmodecfg = w83627ehf_read_value(data,
719 NCT6775_REG_FAN_MODE[i]);
720 data->pwm_mode[i] =
721 ((pwmcfg >> W83627EHF_PWM_MODE_SHIFT[i]) & 1) ? 0 : 1;
722 data->pwm_enable[i] = ((fanmodecfg >> 4) & 7) + 1;
723 data->tolerance[i] = fanmodecfg & 0x0f;
724 data->pwm[i] = w83627ehf_read_value(data, data->REG_PWM[i]);
725 }
726 }
727
728 static void w83627ehf_update_pwm(struct w83627ehf_data *data)
729 {
730 int i;
731 int pwmcfg = 0, tolerance = 0; /* shut up the compiler */
732
733 for (i = 0; i < data->pwm_num; i++) {
734 if (!(data->has_fan & (1 << i)))
735 continue;
736
737 /* pwmcfg, tolerance mapped for i=0, i=1 to same reg */
738 if (i != 1) {
739 pwmcfg = w83627ehf_read_value(data,
740 W83627EHF_REG_PWM_ENABLE[i]);
741 tolerance = w83627ehf_read_value(data,
742 W83627EHF_REG_TOLERANCE[i]);
743 }
744 data->pwm_mode[i] =
745 ((pwmcfg >> W83627EHF_PWM_MODE_SHIFT[i]) & 1) ? 0 : 1;
746 data->pwm_enable[i] = ((pwmcfg >> W83627EHF_PWM_ENABLE_SHIFT[i])
747 & 3) + 1;
748 data->pwm[i] = w83627ehf_read_value(data, data->REG_PWM[i]);
749
750 data->tolerance[i] = (tolerance >> (i == 1 ? 4 : 0)) & 0x0f;
751 }
752 }
753
754 static void w83627ehf_update_pwm_common(struct device *dev,
755 struct w83627ehf_data *data)
756 {
757 struct w83627ehf_sio_data *sio_data = dev->platform_data;
758
759 if (sio_data->kind == nct6775 || sio_data->kind == nct6776)
760 nct6775_update_pwm(data);
761 else
762 w83627ehf_update_pwm(data);
763 }
764
765 static struct w83627ehf_data *w83627ehf_update_device(struct device *dev)
766 {
767 struct w83627ehf_data *data = dev_get_drvdata(dev);
768 struct w83627ehf_sio_data *sio_data = dev->platform_data;
769
770 int i;
771
772 mutex_lock(&data->update_lock);
773
774 if (time_after(jiffies, data->last_updated + HZ + HZ/2)
775 || !data->valid) {
776 /* Fan clock dividers */
777 w83627ehf_update_fan_div_common(dev, data);
778
779 /* Measured voltages and limits */
780 for (i = 0; i < data->in_num; i++) {
781 if ((i == 6) && data->in6_skip)
782 continue;
783
784 data->in[i] = w83627ehf_read_value(data,
785 W83627EHF_REG_IN(i));
786 data->in_min[i] = w83627ehf_read_value(data,
787 W83627EHF_REG_IN_MIN(i));
788 data->in_max[i] = w83627ehf_read_value(data,
789 W83627EHF_REG_IN_MAX(i));
790 }
791
792 /* Measured fan speeds and limits */
793 for (i = 0; i < 5; i++) {
794 u16 reg;
795
796 if (!(data->has_fan & (1 << i)))
797 continue;
798
799 reg = w83627ehf_read_value(data, data->REG_FAN[i]);
800 data->rpm[i] = data->fan_from_reg(reg,
801 data->fan_div[i]);
802
803 if (data->has_fan_min & (1 << i))
804 data->fan_min[i] = w83627ehf_read_value(data,
805 data->REG_FAN_MIN[i]);
806
807 /* If we failed to measure the fan speed and clock
808 divider can be increased, let's try that for next
809 time */
810 if (data->has_fan_div
811 && (reg >= 0xff || (sio_data->kind == nct6775
812 && reg == 0x00))
813 && data->fan_div[i] < 0x07) {
814 dev_dbg(dev, "Increasing fan%d "
815 "clock divider from %u to %u\n",
816 i + 1, div_from_reg(data->fan_div[i]),
817 div_from_reg(data->fan_div[i] + 1));
818 data->fan_div[i]++;
819 w83627ehf_write_fan_div_common(dev, data, i);
820 /* Preserve min limit if possible */
821 if ((data->has_fan_min & (1 << i))
822 && data->fan_min[i] >= 2
823 && data->fan_min[i] != 255)
824 w83627ehf_write_value(data,
825 data->REG_FAN_MIN[i],
826 (data->fan_min[i] /= 2));
827 }
828 }
829
830 w83627ehf_update_pwm_common(dev, data);
831
832 for (i = 0; i < data->pwm_num; i++) {
833 if (!(data->has_fan & (1 << i)))
834 continue;
835
836 data->fan_start_output[i] =
837 w83627ehf_read_value(data,
838 data->REG_FAN_START_OUTPUT[i]);
839 data->fan_stop_output[i] =
840 w83627ehf_read_value(data,
841 data->REG_FAN_STOP_OUTPUT[i]);
842 data->fan_stop_time[i] =
843 w83627ehf_read_value(data,
844 data->REG_FAN_STOP_TIME[i]);
845
846 if (data->REG_FAN_MAX_OUTPUT &&
847 data->REG_FAN_MAX_OUTPUT[i] != 0xff)
848 data->fan_max_output[i] =
849 w83627ehf_read_value(data,
850 data->REG_FAN_MAX_OUTPUT[i]);
851
852 if (data->REG_FAN_STEP_OUTPUT &&
853 data->REG_FAN_STEP_OUTPUT[i] != 0xff)
854 data->fan_step_output[i] =
855 w83627ehf_read_value(data,
856 data->REG_FAN_STEP_OUTPUT[i]);
857
858 data->target_temp[i] =
859 w83627ehf_read_value(data,
860 data->REG_TARGET[i]) &
861 (data->pwm_mode[i] == 1 ? 0x7f : 0xff);
862 }
863
864 /* Measured temperatures and limits */
865 for (i = 0; i < NUM_REG_TEMP; i++) {
866 if (!(data->have_temp & (1 << i)))
867 continue;
868 data->temp[i] = w83627ehf_read_temp(data,
869 data->reg_temp[i]);
870 if (data->reg_temp_over[i])
871 data->temp_max[i]
872 = w83627ehf_read_temp(data,
873 data->reg_temp_over[i]);
874 if (data->reg_temp_hyst[i])
875 data->temp_max_hyst[i]
876 = w83627ehf_read_temp(data,
877 data->reg_temp_hyst[i]);
878 }
879
880 data->alarms = w83627ehf_read_value(data,
881 W83627EHF_REG_ALARM1) |
882 (w83627ehf_read_value(data,
883 W83627EHF_REG_ALARM2) << 8) |
884 (w83627ehf_read_value(data,
885 W83627EHF_REG_ALARM3) << 16);
886
887 data->caseopen = w83627ehf_read_value(data,
888 W83627EHF_REG_CASEOPEN_DET);
889
890 data->last_updated = jiffies;
891 data->valid = 1;
892 }
893
894 mutex_unlock(&data->update_lock);
895 return data;
896 }
897
898 /*
899 * Sysfs callback functions
900 */
901 #define show_in_reg(reg) \
902 static ssize_t \
903 show_##reg(struct device *dev, struct device_attribute *attr, \
904 char *buf) \
905 { \
906 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
907 struct sensor_device_attribute *sensor_attr = \
908 to_sensor_dev_attr(attr); \
909 int nr = sensor_attr->index; \
910 return sprintf(buf, "%ld\n", in_from_reg(data->reg[nr], nr)); \
911 }
912 show_in_reg(in)
913 show_in_reg(in_min)
914 show_in_reg(in_max)
915
916 #define store_in_reg(REG, reg) \
917 static ssize_t \
918 store_in_##reg(struct device *dev, struct device_attribute *attr, \
919 const char *buf, size_t count) \
920 { \
921 struct w83627ehf_data *data = dev_get_drvdata(dev); \
922 struct sensor_device_attribute *sensor_attr = \
923 to_sensor_dev_attr(attr); \
924 int nr = sensor_attr->index; \
925 unsigned long val; \
926 int err; \
927 err = strict_strtoul(buf, 10, &val); \
928 if (err < 0) \
929 return err; \
930 mutex_lock(&data->update_lock); \
931 data->in_##reg[nr] = in_to_reg(val, nr); \
932 w83627ehf_write_value(data, W83627EHF_REG_IN_##REG(nr), \
933 data->in_##reg[nr]); \
934 mutex_unlock(&data->update_lock); \
935 return count; \
936 }
937
938 store_in_reg(MIN, min)
939 store_in_reg(MAX, max)
940
941 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
942 char *buf)
943 {
944 struct w83627ehf_data *data = w83627ehf_update_device(dev);
945 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
946 int nr = sensor_attr->index;
947 return sprintf(buf, "%u\n", (data->alarms >> nr) & 0x01);
948 }
949
950 static struct sensor_device_attribute sda_in_input[] = {
951 SENSOR_ATTR(in0_input, S_IRUGO, show_in, NULL, 0),
952 SENSOR_ATTR(in1_input, S_IRUGO, show_in, NULL, 1),
953 SENSOR_ATTR(in2_input, S_IRUGO, show_in, NULL, 2),
954 SENSOR_ATTR(in3_input, S_IRUGO, show_in, NULL, 3),
955 SENSOR_ATTR(in4_input, S_IRUGO, show_in, NULL, 4),
956 SENSOR_ATTR(in5_input, S_IRUGO, show_in, NULL, 5),
957 SENSOR_ATTR(in6_input, S_IRUGO, show_in, NULL, 6),
958 SENSOR_ATTR(in7_input, S_IRUGO, show_in, NULL, 7),
959 SENSOR_ATTR(in8_input, S_IRUGO, show_in, NULL, 8),
960 SENSOR_ATTR(in9_input, S_IRUGO, show_in, NULL, 9),
961 };
962
963 static struct sensor_device_attribute sda_in_alarm[] = {
964 SENSOR_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0),
965 SENSOR_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1),
966 SENSOR_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2),
967 SENSOR_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3),
968 SENSOR_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8),
969 SENSOR_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 21),
970 SENSOR_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 20),
971 SENSOR_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 16),
972 SENSOR_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 17),
973 SENSOR_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL, 19),
974 };
975
976 static struct sensor_device_attribute sda_in_min[] = {
977 SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 0),
978 SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 1),
979 SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 2),
980 SENSOR_ATTR(in3_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 3),
981 SENSOR_ATTR(in4_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 4),
982 SENSOR_ATTR(in5_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 5),
983 SENSOR_ATTR(in6_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 6),
984 SENSOR_ATTR(in7_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 7),
985 SENSOR_ATTR(in8_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 8),
986 SENSOR_ATTR(in9_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 9),
987 };
988
989 static struct sensor_device_attribute sda_in_max[] = {
990 SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 0),
991 SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 1),
992 SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 2),
993 SENSOR_ATTR(in3_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 3),
994 SENSOR_ATTR(in4_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 4),
995 SENSOR_ATTR(in5_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 5),
996 SENSOR_ATTR(in6_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 6),
997 SENSOR_ATTR(in7_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 7),
998 SENSOR_ATTR(in8_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 8),
999 SENSOR_ATTR(in9_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 9),
1000 };
1001
1002 static ssize_t
1003 show_fan(struct device *dev, struct device_attribute *attr, char *buf)
1004 {
1005 struct w83627ehf_data *data = w83627ehf_update_device(dev);
1006 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1007 int nr = sensor_attr->index;
1008 return sprintf(buf, "%d\n", data->rpm[nr]);
1009 }
1010
1011 static ssize_t
1012 show_fan_min(struct device *dev, struct device_attribute *attr, char *buf)
1013 {
1014 struct w83627ehf_data *data = w83627ehf_update_device(dev);
1015 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1016 int nr = sensor_attr->index;
1017 return sprintf(buf, "%d\n",
1018 data->fan_from_reg_min(data->fan_min[nr],
1019 data->fan_div[nr]));
1020 }
1021
1022 static ssize_t
1023 show_fan_div(struct device *dev, struct device_attribute *attr,
1024 char *buf)
1025 {
1026 struct w83627ehf_data *data = w83627ehf_update_device(dev);
1027 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1028 int nr = sensor_attr->index;
1029 return sprintf(buf, "%u\n", div_from_reg(data->fan_div[nr]));
1030 }
1031
1032 static ssize_t
1033 store_fan_min(struct device *dev, struct device_attribute *attr,
1034 const char *buf, size_t count)
1035 {
1036 struct w83627ehf_data *data = dev_get_drvdata(dev);
1037 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1038 int nr = sensor_attr->index;
1039 unsigned long val;
1040 int err;
1041 unsigned int reg;
1042 u8 new_div;
1043
1044 err = strict_strtoul(buf, 10, &val);
1045 if (err < 0)
1046 return err;
1047
1048 mutex_lock(&data->update_lock);
1049 if (!data->has_fan_div) {
1050 /*
1051 * Only NCT6776F for now, so we know that this is a 13 bit
1052 * register
1053 */
1054 if (!val) {
1055 val = 0xff1f;
1056 } else {
1057 if (val > 1350000U)
1058 val = 135000U;
1059 val = 1350000U / val;
1060 val = (val & 0x1f) | ((val << 3) & 0xff00);
1061 }
1062 data->fan_min[nr] = val;
1063 goto done; /* Leave fan divider alone */
1064 }
1065 if (!val) {
1066 /* No min limit, alarm disabled */
1067 data->fan_min[nr] = 255;
1068 new_div = data->fan_div[nr]; /* No change */
1069 dev_info(dev, "fan%u low limit and alarm disabled\n", nr + 1);
1070 } else if ((reg = 1350000U / val) >= 128 * 255) {
1071 /* Speed below this value cannot possibly be represented,
1072 even with the highest divider (128) */
1073 data->fan_min[nr] = 254;
1074 new_div = 7; /* 128 == (1 << 7) */
1075 dev_warn(dev, "fan%u low limit %lu below minimum %u, set to "
1076 "minimum\n", nr + 1, val,
1077 data->fan_from_reg_min(254, 7));
1078 } else if (!reg) {
1079 /* Speed above this value cannot possibly be represented,
1080 even with the lowest divider (1) */
1081 data->fan_min[nr] = 1;
1082 new_div = 0; /* 1 == (1 << 0) */
1083 dev_warn(dev, "fan%u low limit %lu above maximum %u, set to "
1084 "maximum\n", nr + 1, val,
1085 data->fan_from_reg_min(1, 0));
1086 } else {
1087 /* Automatically pick the best divider, i.e. the one such
1088 that the min limit will correspond to a register value
1089 in the 96..192 range */
1090 new_div = 0;
1091 while (reg > 192 && new_div < 7) {
1092 reg >>= 1;
1093 new_div++;
1094 }
1095 data->fan_min[nr] = reg;
1096 }
1097
1098 /* Write both the fan clock divider (if it changed) and the new
1099 fan min (unconditionally) */
1100 if (new_div != data->fan_div[nr]) {
1101 dev_dbg(dev, "fan%u clock divider changed from %u to %u\n",
1102 nr + 1, div_from_reg(data->fan_div[nr]),
1103 div_from_reg(new_div));
1104 data->fan_div[nr] = new_div;
1105 w83627ehf_write_fan_div_common(dev, data, nr);
1106 /* Give the chip time to sample a new speed value */
1107 data->last_updated = jiffies;
1108 }
1109 done:
1110 w83627ehf_write_value(data, data->REG_FAN_MIN[nr],
1111 data->fan_min[nr]);
1112 mutex_unlock(&data->update_lock);
1113
1114 return count;
1115 }
1116
1117 static struct sensor_device_attribute sda_fan_input[] = {
1118 SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0),
1119 SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1),
1120 SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2),
1121 SENSOR_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3),
1122 SENSOR_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4),
1123 };
1124
1125 static struct sensor_device_attribute sda_fan_alarm[] = {
1126 SENSOR_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6),
1127 SENSOR_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7),
1128 SENSOR_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11),
1129 SENSOR_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 10),
1130 SENSOR_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 23),
1131 };
1132
1133 static struct sensor_device_attribute sda_fan_min[] = {
1134 SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min,
1135 store_fan_min, 0),
1136 SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min,
1137 store_fan_min, 1),
1138 SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min,
1139 store_fan_min, 2),
1140 SENSOR_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min,
1141 store_fan_min, 3),
1142 SENSOR_ATTR(fan5_min, S_IWUSR | S_IRUGO, show_fan_min,
1143 store_fan_min, 4),
1144 };
1145
1146 static struct sensor_device_attribute sda_fan_div[] = {
1147 SENSOR_ATTR(fan1_div, S_IRUGO, show_fan_div, NULL, 0),
1148 SENSOR_ATTR(fan2_div, S_IRUGO, show_fan_div, NULL, 1),
1149 SENSOR_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2),
1150 SENSOR_ATTR(fan4_div, S_IRUGO, show_fan_div, NULL, 3),
1151 SENSOR_ATTR(fan5_div, S_IRUGO, show_fan_div, NULL, 4),
1152 };
1153
1154 static ssize_t
1155 show_temp_label(struct device *dev, struct device_attribute *attr, char *buf)
1156 {
1157 struct w83627ehf_data *data = w83627ehf_update_device(dev);
1158 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1159 int nr = sensor_attr->index;
1160 return sprintf(buf, "%s\n", data->temp_label[data->temp_src[nr]]);
1161 }
1162
1163 #define show_temp_reg(addr, reg) \
1164 static ssize_t \
1165 show_##reg(struct device *dev, struct device_attribute *attr, \
1166 char *buf) \
1167 { \
1168 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1169 struct sensor_device_attribute *sensor_attr = \
1170 to_sensor_dev_attr(attr); \
1171 int nr = sensor_attr->index; \
1172 return sprintf(buf, "%d\n", LM75_TEMP_FROM_REG(data->reg[nr])); \
1173 }
1174 show_temp_reg(reg_temp, temp);
1175 show_temp_reg(reg_temp_over, temp_max);
1176 show_temp_reg(reg_temp_hyst, temp_max_hyst);
1177
1178 #define store_temp_reg(addr, reg) \
1179 static ssize_t \
1180 store_##reg(struct device *dev, struct device_attribute *attr, \
1181 const char *buf, size_t count) \
1182 { \
1183 struct w83627ehf_data *data = dev_get_drvdata(dev); \
1184 struct sensor_device_attribute *sensor_attr = \
1185 to_sensor_dev_attr(attr); \
1186 int nr = sensor_attr->index; \
1187 int err; \
1188 long val; \
1189 err = strict_strtol(buf, 10, &val); \
1190 if (err < 0) \
1191 return err; \
1192 mutex_lock(&data->update_lock); \
1193 data->reg[nr] = LM75_TEMP_TO_REG(val); \
1194 w83627ehf_write_temp(data, data->addr[nr], data->reg[nr]); \
1195 mutex_unlock(&data->update_lock); \
1196 return count; \
1197 }
1198 store_temp_reg(reg_temp_over, temp_max);
1199 store_temp_reg(reg_temp_hyst, temp_max_hyst);
1200
1201 static ssize_t
1202 show_temp_type(struct device *dev, struct device_attribute *attr, char *buf)
1203 {
1204 struct w83627ehf_data *data = w83627ehf_update_device(dev);
1205 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1206 int nr = sensor_attr->index;
1207 return sprintf(buf, "%d\n", (int)data->temp_type[nr]);
1208 }
1209
1210 static struct sensor_device_attribute sda_temp_input[] = {
1211 SENSOR_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0),
1212 SENSOR_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1),
1213 SENSOR_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2),
1214 SENSOR_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3),
1215 SENSOR_ATTR(temp5_input, S_IRUGO, show_temp, NULL, 4),
1216 SENSOR_ATTR(temp6_input, S_IRUGO, show_temp, NULL, 5),
1217 SENSOR_ATTR(temp7_input, S_IRUGO, show_temp, NULL, 6),
1218 SENSOR_ATTR(temp8_input, S_IRUGO, show_temp, NULL, 7),
1219 SENSOR_ATTR(temp9_input, S_IRUGO, show_temp, NULL, 8),
1220 };
1221
1222 static struct sensor_device_attribute sda_temp_label[] = {
1223 SENSOR_ATTR(temp1_label, S_IRUGO, show_temp_label, NULL, 0),
1224 SENSOR_ATTR(temp2_label, S_IRUGO, show_temp_label, NULL, 1),
1225 SENSOR_ATTR(temp3_label, S_IRUGO, show_temp_label, NULL, 2),
1226 SENSOR_ATTR(temp4_label, S_IRUGO, show_temp_label, NULL, 3),
1227 SENSOR_ATTR(temp5_label, S_IRUGO, show_temp_label, NULL, 4),
1228 SENSOR_ATTR(temp6_label, S_IRUGO, show_temp_label, NULL, 5),
1229 SENSOR_ATTR(temp7_label, S_IRUGO, show_temp_label, NULL, 6),
1230 SENSOR_ATTR(temp8_label, S_IRUGO, show_temp_label, NULL, 7),
1231 SENSOR_ATTR(temp9_label, S_IRUGO, show_temp_label, NULL, 8),
1232 };
1233
1234 static struct sensor_device_attribute sda_temp_max[] = {
1235 SENSOR_ATTR(temp1_max, S_IRUGO | S_IWUSR, show_temp_max,
1236 store_temp_max, 0),
1237 SENSOR_ATTR(temp2_max, S_IRUGO | S_IWUSR, show_temp_max,
1238 store_temp_max, 1),
1239 SENSOR_ATTR(temp3_max, S_IRUGO | S_IWUSR, show_temp_max,
1240 store_temp_max, 2),
1241 SENSOR_ATTR(temp4_max, S_IRUGO | S_IWUSR, show_temp_max,
1242 store_temp_max, 3),
1243 SENSOR_ATTR(temp5_max, S_IRUGO | S_IWUSR, show_temp_max,
1244 store_temp_max, 4),
1245 SENSOR_ATTR(temp6_max, S_IRUGO | S_IWUSR, show_temp_max,
1246 store_temp_max, 5),
1247 SENSOR_ATTR(temp7_max, S_IRUGO | S_IWUSR, show_temp_max,
1248 store_temp_max, 6),
1249 SENSOR_ATTR(temp8_max, S_IRUGO | S_IWUSR, show_temp_max,
1250 store_temp_max, 7),
1251 SENSOR_ATTR(temp9_max, S_IRUGO | S_IWUSR, show_temp_max,
1252 store_temp_max, 8),
1253 };
1254
1255 static struct sensor_device_attribute sda_temp_max_hyst[] = {
1256 SENSOR_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
1257 store_temp_max_hyst, 0),
1258 SENSOR_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
1259 store_temp_max_hyst, 1),
1260 SENSOR_ATTR(temp3_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
1261 store_temp_max_hyst, 2),
1262 SENSOR_ATTR(temp4_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
1263 store_temp_max_hyst, 3),
1264 SENSOR_ATTR(temp5_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
1265 store_temp_max_hyst, 4),
1266 SENSOR_ATTR(temp6_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
1267 store_temp_max_hyst, 5),
1268 SENSOR_ATTR(temp7_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
1269 store_temp_max_hyst, 6),
1270 SENSOR_ATTR(temp8_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
1271 store_temp_max_hyst, 7),
1272 SENSOR_ATTR(temp9_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
1273 store_temp_max_hyst, 8),
1274 };
1275
1276 static struct sensor_device_attribute sda_temp_alarm[] = {
1277 SENSOR_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4),
1278 SENSOR_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5),
1279 SENSOR_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13),
1280 };
1281
1282 static struct sensor_device_attribute sda_temp_type[] = {
1283 SENSOR_ATTR(temp1_type, S_IRUGO, show_temp_type, NULL, 0),
1284 SENSOR_ATTR(temp2_type, S_IRUGO, show_temp_type, NULL, 1),
1285 SENSOR_ATTR(temp3_type, S_IRUGO, show_temp_type, NULL, 2),
1286 };
1287
1288 #define show_pwm_reg(reg) \
1289 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
1290 char *buf) \
1291 { \
1292 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1293 struct sensor_device_attribute *sensor_attr = \
1294 to_sensor_dev_attr(attr); \
1295 int nr = sensor_attr->index; \
1296 return sprintf(buf, "%d\n", data->reg[nr]); \
1297 }
1298
1299 show_pwm_reg(pwm_mode)
1300 show_pwm_reg(pwm_enable)
1301 show_pwm_reg(pwm)
1302
1303 static ssize_t
1304 store_pwm_mode(struct device *dev, struct device_attribute *attr,
1305 const char *buf, size_t count)
1306 {
1307 struct w83627ehf_data *data = dev_get_drvdata(dev);
1308 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1309 int nr = sensor_attr->index;
1310 unsigned long val;
1311 int err;
1312 u16 reg;
1313
1314 err = strict_strtoul(buf, 10, &val);
1315 if (err < 0)
1316 return err;
1317
1318 if (val > 1)
1319 return -EINVAL;
1320 mutex_lock(&data->update_lock);
1321 reg = w83627ehf_read_value(data, W83627EHF_REG_PWM_ENABLE[nr]);
1322 data->pwm_mode[nr] = val;
1323 reg &= ~(1 << W83627EHF_PWM_MODE_SHIFT[nr]);
1324 if (!val)
1325 reg |= 1 << W83627EHF_PWM_MODE_SHIFT[nr];
1326 w83627ehf_write_value(data, W83627EHF_REG_PWM_ENABLE[nr], reg);
1327 mutex_unlock(&data->update_lock);
1328 return count;
1329 }
1330
1331 static ssize_t
1332 store_pwm(struct device *dev, struct device_attribute *attr,
1333 const char *buf, size_t count)
1334 {
1335 struct w83627ehf_data *data = dev_get_drvdata(dev);
1336 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1337 int nr = sensor_attr->index;
1338 unsigned long val;
1339 int err;
1340
1341 err = strict_strtoul(buf, 10, &val);
1342 if (err < 0)
1343 return err;
1344
1345 val = SENSORS_LIMIT(val, 0, 255);
1346
1347 mutex_lock(&data->update_lock);
1348 data->pwm[nr] = val;
1349 w83627ehf_write_value(data, data->REG_PWM[nr], val);
1350 mutex_unlock(&data->update_lock);
1351 return count;
1352 }
1353
1354 static ssize_t
1355 store_pwm_enable(struct device *dev, struct device_attribute *attr,
1356 const char *buf, size_t count)
1357 {
1358 struct w83627ehf_data *data = dev_get_drvdata(dev);
1359 struct w83627ehf_sio_data *sio_data = dev->platform_data;
1360 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1361 int nr = sensor_attr->index;
1362 unsigned long val;
1363 int err;
1364 u16 reg;
1365
1366 err = strict_strtoul(buf, 10, &val);
1367 if (err < 0)
1368 return err;
1369
1370 if (!val || (val > 4 && val != data->pwm_enable_orig[nr]))
1371 return -EINVAL;
1372 /* SmartFan III mode is not supported on NCT6776F */
1373 if (sio_data->kind == nct6776 && val == 4)
1374 return -EINVAL;
1375
1376 mutex_lock(&data->update_lock);
1377 data->pwm_enable[nr] = val;
1378 if (sio_data->kind == nct6775 || sio_data->kind == nct6776) {
1379 reg = w83627ehf_read_value(data,
1380 NCT6775_REG_FAN_MODE[nr]);
1381 reg &= 0x0f;
1382 reg |= (val - 1) << 4;
1383 w83627ehf_write_value(data,
1384 NCT6775_REG_FAN_MODE[nr], reg);
1385 } else {
1386 reg = w83627ehf_read_value(data, W83627EHF_REG_PWM_ENABLE[nr]);
1387 reg &= ~(0x03 << W83627EHF_PWM_ENABLE_SHIFT[nr]);
1388 reg |= (val - 1) << W83627EHF_PWM_ENABLE_SHIFT[nr];
1389 w83627ehf_write_value(data, W83627EHF_REG_PWM_ENABLE[nr], reg);
1390 }
1391 mutex_unlock(&data->update_lock);
1392 return count;
1393 }
1394
1395
1396 #define show_tol_temp(reg) \
1397 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
1398 char *buf) \
1399 { \
1400 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1401 struct sensor_device_attribute *sensor_attr = \
1402 to_sensor_dev_attr(attr); \
1403 int nr = sensor_attr->index; \
1404 return sprintf(buf, "%d\n", data->reg[nr] * 1000); \
1405 }
1406
1407 show_tol_temp(tolerance)
1408 show_tol_temp(target_temp)
1409
1410 static ssize_t
1411 store_target_temp(struct device *dev, struct device_attribute *attr,
1412 const char *buf, size_t count)
1413 {
1414 struct w83627ehf_data *data = dev_get_drvdata(dev);
1415 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1416 int nr = sensor_attr->index;
1417 long val;
1418 int err;
1419
1420 err = strict_strtol(buf, 10, &val);
1421 if (err < 0)
1422 return err;
1423
1424 val = SENSORS_LIMIT(DIV_ROUND_CLOSEST(val, 1000), 0, 127);
1425
1426 mutex_lock(&data->update_lock);
1427 data->target_temp[nr] = val;
1428 w83627ehf_write_value(data, data->REG_TARGET[nr], val);
1429 mutex_unlock(&data->update_lock);
1430 return count;
1431 }
1432
1433 static ssize_t
1434 store_tolerance(struct device *dev, struct device_attribute *attr,
1435 const char *buf, size_t count)
1436 {
1437 struct w83627ehf_data *data = dev_get_drvdata(dev);
1438 struct w83627ehf_sio_data *sio_data = dev->platform_data;
1439 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1440 int nr = sensor_attr->index;
1441 u16 reg;
1442 long val;
1443 int err;
1444
1445 err = strict_strtol(buf, 10, &val);
1446 if (err < 0)
1447 return err;
1448
1449 /* Limit the temp to 0C - 15C */
1450 val = SENSORS_LIMIT(DIV_ROUND_CLOSEST(val, 1000), 0, 15);
1451
1452 mutex_lock(&data->update_lock);
1453 if (sio_data->kind == nct6775 || sio_data->kind == nct6776) {
1454 /* Limit tolerance further for NCT6776F */
1455 if (sio_data->kind == nct6776 && val > 7)
1456 val = 7;
1457 reg = w83627ehf_read_value(data, NCT6775_REG_FAN_MODE[nr]);
1458 reg = (reg & 0xf0) | val;
1459 w83627ehf_write_value(data, NCT6775_REG_FAN_MODE[nr], reg);
1460 } else {
1461 reg = w83627ehf_read_value(data, W83627EHF_REG_TOLERANCE[nr]);
1462 if (nr == 1)
1463 reg = (reg & 0x0f) | (val << 4);
1464 else
1465 reg = (reg & 0xf0) | val;
1466 w83627ehf_write_value(data, W83627EHF_REG_TOLERANCE[nr], reg);
1467 }
1468 data->tolerance[nr] = val;
1469 mutex_unlock(&data->update_lock);
1470 return count;
1471 }
1472
1473 static struct sensor_device_attribute sda_pwm[] = {
1474 SENSOR_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 0),
1475 SENSOR_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 1),
1476 SENSOR_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 2),
1477 SENSOR_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 3),
1478 };
1479
1480 static struct sensor_device_attribute sda_pwm_mode[] = {
1481 SENSOR_ATTR(pwm1_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1482 store_pwm_mode, 0),
1483 SENSOR_ATTR(pwm2_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1484 store_pwm_mode, 1),
1485 SENSOR_ATTR(pwm3_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1486 store_pwm_mode, 2),
1487 SENSOR_ATTR(pwm4_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1488 store_pwm_mode, 3),
1489 };
1490
1491 static struct sensor_device_attribute sda_pwm_enable[] = {
1492 SENSOR_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1493 store_pwm_enable, 0),
1494 SENSOR_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1495 store_pwm_enable, 1),
1496 SENSOR_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1497 store_pwm_enable, 2),
1498 SENSOR_ATTR(pwm4_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1499 store_pwm_enable, 3),
1500 };
1501
1502 static struct sensor_device_attribute sda_target_temp[] = {
1503 SENSOR_ATTR(pwm1_target, S_IWUSR | S_IRUGO, show_target_temp,
1504 store_target_temp, 0),
1505 SENSOR_ATTR(pwm2_target, S_IWUSR | S_IRUGO, show_target_temp,
1506 store_target_temp, 1),
1507 SENSOR_ATTR(pwm3_target, S_IWUSR | S_IRUGO, show_target_temp,
1508 store_target_temp, 2),
1509 SENSOR_ATTR(pwm4_target, S_IWUSR | S_IRUGO, show_target_temp,
1510 store_target_temp, 3),
1511 };
1512
1513 static struct sensor_device_attribute sda_tolerance[] = {
1514 SENSOR_ATTR(pwm1_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1515 store_tolerance, 0),
1516 SENSOR_ATTR(pwm2_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1517 store_tolerance, 1),
1518 SENSOR_ATTR(pwm3_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1519 store_tolerance, 2),
1520 SENSOR_ATTR(pwm4_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1521 store_tolerance, 3),
1522 };
1523
1524 /* Smart Fan registers */
1525
1526 #define fan_functions(reg, REG) \
1527 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
1528 char *buf) \
1529 { \
1530 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1531 struct sensor_device_attribute *sensor_attr = \
1532 to_sensor_dev_attr(attr); \
1533 int nr = sensor_attr->index; \
1534 return sprintf(buf, "%d\n", data->reg[nr]); \
1535 } \
1536 static ssize_t \
1537 store_##reg(struct device *dev, struct device_attribute *attr, \
1538 const char *buf, size_t count) \
1539 { \
1540 struct w83627ehf_data *data = dev_get_drvdata(dev); \
1541 struct sensor_device_attribute *sensor_attr = \
1542 to_sensor_dev_attr(attr); \
1543 int nr = sensor_attr->index; \
1544 unsigned long val; \
1545 int err; \
1546 err = strict_strtoul(buf, 10, &val); \
1547 if (err < 0) \
1548 return err; \
1549 val = SENSORS_LIMIT(val, 1, 255); \
1550 mutex_lock(&data->update_lock); \
1551 data->reg[nr] = val; \
1552 w83627ehf_write_value(data, data->REG_##REG[nr], val); \
1553 mutex_unlock(&data->update_lock); \
1554 return count; \
1555 }
1556
1557 fan_functions(fan_start_output, FAN_START_OUTPUT)
1558 fan_functions(fan_stop_output, FAN_STOP_OUTPUT)
1559 fan_functions(fan_max_output, FAN_MAX_OUTPUT)
1560 fan_functions(fan_step_output, FAN_STEP_OUTPUT)
1561
1562 #define fan_time_functions(reg, REG) \
1563 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
1564 char *buf) \
1565 { \
1566 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1567 struct sensor_device_attribute *sensor_attr = \
1568 to_sensor_dev_attr(attr); \
1569 int nr = sensor_attr->index; \
1570 return sprintf(buf, "%d\n", \
1571 step_time_from_reg(data->reg[nr], \
1572 data->pwm_mode[nr])); \
1573 } \
1574 \
1575 static ssize_t \
1576 store_##reg(struct device *dev, struct device_attribute *attr, \
1577 const char *buf, size_t count) \
1578 { \
1579 struct w83627ehf_data *data = dev_get_drvdata(dev); \
1580 struct sensor_device_attribute *sensor_attr = \
1581 to_sensor_dev_attr(attr); \
1582 int nr = sensor_attr->index; \
1583 unsigned long val; \
1584 int err; \
1585 err = strict_strtoul(buf, 10, &val); \
1586 if (err < 0) \
1587 return err; \
1588 val = step_time_to_reg(val, data->pwm_mode[nr]); \
1589 mutex_lock(&data->update_lock); \
1590 data->reg[nr] = val; \
1591 w83627ehf_write_value(data, W83627EHF_REG_##REG[nr], val); \
1592 mutex_unlock(&data->update_lock); \
1593 return count; \
1594 } \
1595
1596 fan_time_functions(fan_stop_time, FAN_STOP_TIME)
1597
1598 static ssize_t show_name(struct device *dev, struct device_attribute *attr,
1599 char *buf)
1600 {
1601 struct w83627ehf_data *data = dev_get_drvdata(dev);
1602
1603 return sprintf(buf, "%s\n", data->name);
1604 }
1605 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
1606
1607 static struct sensor_device_attribute sda_sf3_arrays_fan4[] = {
1608 SENSOR_ATTR(pwm4_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1609 store_fan_stop_time, 3),
1610 SENSOR_ATTR(pwm4_start_output, S_IWUSR | S_IRUGO, show_fan_start_output,
1611 store_fan_start_output, 3),
1612 SENSOR_ATTR(pwm4_stop_output, S_IWUSR | S_IRUGO, show_fan_stop_output,
1613 store_fan_stop_output, 3),
1614 SENSOR_ATTR(pwm4_max_output, S_IWUSR | S_IRUGO, show_fan_max_output,
1615 store_fan_max_output, 3),
1616 SENSOR_ATTR(pwm4_step_output, S_IWUSR | S_IRUGO, show_fan_step_output,
1617 store_fan_step_output, 3),
1618 };
1619
1620 static struct sensor_device_attribute sda_sf3_arrays[] = {
1621 SENSOR_ATTR(pwm1_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1622 store_fan_stop_time, 0),
1623 SENSOR_ATTR(pwm2_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1624 store_fan_stop_time, 1),
1625 SENSOR_ATTR(pwm3_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1626 store_fan_stop_time, 2),
1627 SENSOR_ATTR(pwm1_start_output, S_IWUSR | S_IRUGO, show_fan_start_output,
1628 store_fan_start_output, 0),
1629 SENSOR_ATTR(pwm2_start_output, S_IWUSR | S_IRUGO, show_fan_start_output,
1630 store_fan_start_output, 1),
1631 SENSOR_ATTR(pwm3_start_output, S_IWUSR | S_IRUGO, show_fan_start_output,
1632 store_fan_start_output, 2),
1633 SENSOR_ATTR(pwm1_stop_output, S_IWUSR | S_IRUGO, show_fan_stop_output,
1634 store_fan_stop_output, 0),
1635 SENSOR_ATTR(pwm2_stop_output, S_IWUSR | S_IRUGO, show_fan_stop_output,
1636 store_fan_stop_output, 1),
1637 SENSOR_ATTR(pwm3_stop_output, S_IWUSR | S_IRUGO, show_fan_stop_output,
1638 store_fan_stop_output, 2),
1639 };
1640
1641
1642 /*
1643 * pwm1 and pwm3 don't support max and step settings on all chips.
1644 * Need to check support while generating/removing attribute files.
1645 */
1646 static struct sensor_device_attribute sda_sf3_max_step_arrays[] = {
1647 SENSOR_ATTR(pwm1_max_output, S_IWUSR | S_IRUGO, show_fan_max_output,
1648 store_fan_max_output, 0),
1649 SENSOR_ATTR(pwm1_step_output, S_IWUSR | S_IRUGO, show_fan_step_output,
1650 store_fan_step_output, 0),
1651 SENSOR_ATTR(pwm2_max_output, S_IWUSR | S_IRUGO, show_fan_max_output,
1652 store_fan_max_output, 1),
1653 SENSOR_ATTR(pwm2_step_output, S_IWUSR | S_IRUGO, show_fan_step_output,
1654 store_fan_step_output, 1),
1655 SENSOR_ATTR(pwm3_max_output, S_IWUSR | S_IRUGO, show_fan_max_output,
1656 store_fan_max_output, 2),
1657 SENSOR_ATTR(pwm3_step_output, S_IWUSR | S_IRUGO, show_fan_step_output,
1658 store_fan_step_output, 2),
1659 };
1660
1661 static ssize_t
1662 show_vid(struct device *dev, struct device_attribute *attr, char *buf)
1663 {
1664 struct w83627ehf_data *data = dev_get_drvdata(dev);
1665 return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
1666 }
1667 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
1668
1669
1670 /* Case open detection */
1671
1672 static ssize_t
1673 show_caseopen(struct device *dev, struct device_attribute *attr, char *buf)
1674 {
1675 struct w83627ehf_data *data = w83627ehf_update_device(dev);
1676
1677 return sprintf(buf, "%d\n",
1678 !!(data->caseopen & to_sensor_dev_attr_2(attr)->index));
1679 }
1680
1681 static ssize_t
1682 clear_caseopen(struct device *dev, struct device_attribute *attr,
1683 const char *buf, size_t count)
1684 {
1685 struct w83627ehf_data *data = dev_get_drvdata(dev);
1686 unsigned long val;
1687 u16 reg, mask;
1688
1689 if (strict_strtoul(buf, 10, &val) || val != 0)
1690 return -EINVAL;
1691
1692 mask = to_sensor_dev_attr_2(attr)->nr;
1693
1694 mutex_lock(&data->update_lock);
1695 reg = w83627ehf_read_value(data, W83627EHF_REG_CASEOPEN_CLR);
1696 w83627ehf_write_value(data, W83627EHF_REG_CASEOPEN_CLR, reg | mask);
1697 w83627ehf_write_value(data, W83627EHF_REG_CASEOPEN_CLR, reg & ~mask);
1698 data->valid = 0; /* Force cache refresh */
1699 mutex_unlock(&data->update_lock);
1700
1701 return count;
1702 }
1703
1704 static struct sensor_device_attribute_2 sda_caseopen[] = {
1705 SENSOR_ATTR_2(intrusion0_alarm, S_IWUSR | S_IRUGO, show_caseopen,
1706 clear_caseopen, 0x80, 0x10),
1707 SENSOR_ATTR_2(intrusion1_alarm, S_IWUSR | S_IRUGO, show_caseopen,
1708 clear_caseopen, 0x40, 0x40),
1709 };
1710
1711 /*
1712 * Driver and device management
1713 */
1714
1715 static void w83627ehf_device_remove_files(struct device *dev)
1716 {
1717 /* some entries in the following arrays may not have been used in
1718 * device_create_file(), but device_remove_file() will ignore them */
1719 int i;
1720 struct w83627ehf_data *data = dev_get_drvdata(dev);
1721
1722 for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++)
1723 device_remove_file(dev, &sda_sf3_arrays[i].dev_attr);
1724 for (i = 0; i < ARRAY_SIZE(sda_sf3_max_step_arrays); i++) {
1725 struct sensor_device_attribute *attr =
1726 &sda_sf3_max_step_arrays[i];
1727 if (data->REG_FAN_STEP_OUTPUT &&
1728 data->REG_FAN_STEP_OUTPUT[attr->index] != 0xff)
1729 device_remove_file(dev, &attr->dev_attr);
1730 }
1731 for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++)
1732 device_remove_file(dev, &sda_sf3_arrays_fan4[i].dev_attr);
1733 for (i = 0; i < data->in_num; i++) {
1734 if ((i == 6) && data->in6_skip)
1735 continue;
1736 device_remove_file(dev, &sda_in_input[i].dev_attr);
1737 device_remove_file(dev, &sda_in_alarm[i].dev_attr);
1738 device_remove_file(dev, &sda_in_min[i].dev_attr);
1739 device_remove_file(dev, &sda_in_max[i].dev_attr);
1740 }
1741 for (i = 0; i < 5; i++) {
1742 device_remove_file(dev, &sda_fan_input[i].dev_attr);
1743 device_remove_file(dev, &sda_fan_alarm[i].dev_attr);
1744 device_remove_file(dev, &sda_fan_div[i].dev_attr);
1745 device_remove_file(dev, &sda_fan_min[i].dev_attr);
1746 }
1747 for (i = 0; i < data->pwm_num; i++) {
1748 device_remove_file(dev, &sda_pwm[i].dev_attr);
1749 device_remove_file(dev, &sda_pwm_mode[i].dev_attr);
1750 device_remove_file(dev, &sda_pwm_enable[i].dev_attr);
1751 device_remove_file(dev, &sda_target_temp[i].dev_attr);
1752 device_remove_file(dev, &sda_tolerance[i].dev_attr);
1753 }
1754 for (i = 0; i < NUM_REG_TEMP; i++) {
1755 if (!(data->have_temp & (1 << i)))
1756 continue;
1757 device_remove_file(dev, &sda_temp_input[i].dev_attr);
1758 device_remove_file(dev, &sda_temp_label[i].dev_attr);
1759 device_remove_file(dev, &sda_temp_max[i].dev_attr);
1760 device_remove_file(dev, &sda_temp_max_hyst[i].dev_attr);
1761 if (i > 2)
1762 continue;
1763 device_remove_file(dev, &sda_temp_alarm[i].dev_attr);
1764 device_remove_file(dev, &sda_temp_type[i].dev_attr);
1765 }
1766
1767 device_remove_file(dev, &sda_caseopen[0].dev_attr);
1768 device_remove_file(dev, &sda_caseopen[1].dev_attr);
1769
1770 device_remove_file(dev, &dev_attr_name);
1771 device_remove_file(dev, &dev_attr_cpu0_vid);
1772 }
1773
1774 /* Get the monitoring functions started */
1775 static inline void __devinit w83627ehf_init_device(struct w83627ehf_data *data,
1776 enum kinds kind)
1777 {
1778 int i;
1779 u8 tmp, diode;
1780
1781 /* Start monitoring is needed */
1782 tmp = w83627ehf_read_value(data, W83627EHF_REG_CONFIG);
1783 if (!(tmp & 0x01))
1784 w83627ehf_write_value(data, W83627EHF_REG_CONFIG,
1785 tmp | 0x01);
1786
1787 /* Enable temperature sensors if needed */
1788 for (i = 0; i < NUM_REG_TEMP; i++) {
1789 if (!(data->have_temp & (1 << i)))
1790 continue;
1791 if (!data->reg_temp_config[i])
1792 continue;
1793 tmp = w83627ehf_read_value(data,
1794 data->reg_temp_config[i]);
1795 if (tmp & 0x01)
1796 w83627ehf_write_value(data,
1797 data->reg_temp_config[i],
1798 tmp & 0xfe);
1799 }
1800
1801 /* Enable VBAT monitoring if needed */
1802 tmp = w83627ehf_read_value(data, W83627EHF_REG_VBAT);
1803 if (!(tmp & 0x01))
1804 w83627ehf_write_value(data, W83627EHF_REG_VBAT, tmp | 0x01);
1805
1806 /* Get thermal sensor types */
1807 switch (kind) {
1808 case w83627ehf:
1809 diode = w83627ehf_read_value(data, W83627EHF_REG_DIODE);
1810 break;
1811 default:
1812 diode = 0x70;
1813 }
1814 for (i = 0; i < 3; i++) {
1815 if ((tmp & (0x02 << i)))
1816 data->temp_type[i] = (diode & (0x10 << i)) ? 1 : 3;
1817 else
1818 data->temp_type[i] = 4; /* thermistor */
1819 }
1820 }
1821
1822 static void w82627ehf_swap_tempreg(struct w83627ehf_data *data,
1823 int r1, int r2)
1824 {
1825 u16 tmp;
1826
1827 tmp = data->temp_src[r1];
1828 data->temp_src[r1] = data->temp_src[r2];
1829 data->temp_src[r2] = tmp;
1830
1831 tmp = data->reg_temp[r1];
1832 data->reg_temp[r1] = data->reg_temp[r2];
1833 data->reg_temp[r2] = tmp;
1834
1835 tmp = data->reg_temp_over[r1];
1836 data->reg_temp_over[r1] = data->reg_temp_over[r2];
1837 data->reg_temp_over[r2] = tmp;
1838
1839 tmp = data->reg_temp_hyst[r1];
1840 data->reg_temp_hyst[r1] = data->reg_temp_hyst[r2];
1841 data->reg_temp_hyst[r2] = tmp;
1842
1843 tmp = data->reg_temp_config[r1];
1844 data->reg_temp_config[r1] = data->reg_temp_config[r2];
1845 data->reg_temp_config[r2] = tmp;
1846 }
1847
1848 static void __devinit
1849 w83627ehf_check_fan_inputs(const struct w83627ehf_sio_data *sio_data,
1850 struct w83627ehf_data *data)
1851 {
1852 int fan3pin, fan4pin, fan4min, fan5pin, regval;
1853
1854 superio_enter(sio_data->sioreg);
1855
1856 /* fan4 and fan5 share some pins with the GPIO and serial flash */
1857 if (sio_data->kind == nct6775) {
1858 /* On NCT6775, fan4 shares pins with the fdc interface */
1859 fan3pin = 1;
1860 fan4pin = !(superio_inb(sio_data->sioreg, 0x2A) & 0x80);
1861 fan4min = 0;
1862 fan5pin = 0;
1863 } else if (sio_data->kind == nct6776) {
1864 fan3pin = !(superio_inb(sio_data->sioreg, 0x24) & 0x40);
1865 fan4pin = !!(superio_inb(sio_data->sioreg, 0x1C) & 0x01);
1866 fan5pin = !!(superio_inb(sio_data->sioreg, 0x1C) & 0x02);
1867 fan4min = fan4pin;
1868 } else if (sio_data->kind == w83667hg || sio_data->kind == w83667hg_b) {
1869 fan3pin = 1;
1870 fan4pin = superio_inb(sio_data->sioreg, 0x27) & 0x40;
1871 fan5pin = superio_inb(sio_data->sioreg, 0x27) & 0x20;
1872 fan4min = fan4pin;
1873 } else {
1874 fan3pin = 1;
1875 fan4pin = !(superio_inb(sio_data->sioreg, 0x29) & 0x06);
1876 fan5pin = !(superio_inb(sio_data->sioreg, 0x24) & 0x02);
1877 fan4min = fan4pin;
1878 }
1879
1880 superio_exit(sio_data->sioreg);
1881
1882 data->has_fan = data->has_fan_min = 0x03; /* fan1 and fan2 */
1883 data->has_fan |= (fan3pin << 2);
1884 data->has_fan_min |= (fan3pin << 2);
1885
1886 if (sio_data->kind == nct6775 || sio_data->kind == nct6776) {
1887 /*
1888 * NCT6775F and NCT6776F don't have the W83627EHF_REG_FANDIV1
1889 * register
1890 */
1891 data->has_fan |= (fan4pin << 3) | (fan5pin << 4);
1892 data->has_fan_min |= (fan4min << 3) | (fan5pin << 4);
1893 } else {
1894 /*
1895 * It looks like fan4 and fan5 pins can be alternatively used
1896 * as fan on/off switches, but fan5 control is write only :/
1897 * We assume that if the serial interface is disabled, designers
1898 * connected fan5 as input unless they are emitting log 1, which
1899 * is not the default.
1900 */
1901 regval = w83627ehf_read_value(data, W83627EHF_REG_FANDIV1);
1902 if ((regval & (1 << 2)) && fan4pin) {
1903 data->has_fan |= (1 << 3);
1904 data->has_fan_min |= (1 << 3);
1905 }
1906 if (!(regval & (1 << 1)) && fan5pin) {
1907 data->has_fan |= (1 << 4);
1908 data->has_fan_min |= (1 << 4);
1909 }
1910 }
1911 }
1912
1913 static int __devinit w83627ehf_probe(struct platform_device *pdev)
1914 {
1915 struct device *dev = &pdev->dev;
1916 struct w83627ehf_sio_data *sio_data = dev->platform_data;
1917 struct w83627ehf_data *data;
1918 struct resource *res;
1919 u8 en_vrm10;
1920 int i, err = 0;
1921
1922 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1923 if (!request_region(res->start, IOREGION_LENGTH, DRVNAME)) {
1924 err = -EBUSY;
1925 dev_err(dev, "Failed to request region 0x%lx-0x%lx\n",
1926 (unsigned long)res->start,
1927 (unsigned long)res->start + IOREGION_LENGTH - 1);
1928 goto exit;
1929 }
1930
1931 data = kzalloc(sizeof(struct w83627ehf_data), GFP_KERNEL);
1932 if (!data) {
1933 err = -ENOMEM;
1934 goto exit_release;
1935 }
1936
1937 data->addr = res->start;
1938 mutex_init(&data->lock);
1939 mutex_init(&data->update_lock);
1940 data->name = w83627ehf_device_names[sio_data->kind];
1941 platform_set_drvdata(pdev, data);
1942
1943 /* 627EHG and 627EHF have 10 voltage inputs; 627DHG and 667HG have 9 */
1944 data->in_num = (sio_data->kind == w83627ehf) ? 10 : 9;
1945 /* 667HG, NCT6775F, and NCT6776F have 3 pwms */
1946 data->pwm_num = (sio_data->kind == w83667hg
1947 || sio_data->kind == w83667hg_b
1948 || sio_data->kind == nct6775
1949 || sio_data->kind == nct6776) ? 3 : 4;
1950
1951 data->have_temp = 0x07;
1952 /* Check temp3 configuration bit for 667HG */
1953 if (sio_data->kind == w83667hg) {
1954 u8 reg;
1955
1956 reg = w83627ehf_read_value(data, W83627EHF_REG_TEMP_CONFIG[2]);
1957 if (reg & 0x01)
1958 data->have_temp &= ~(1 << 2);
1959 else
1960 data->in6_skip = 1; /* either temp3 or in6 */
1961 }
1962
1963 /* Deal with temperature register setup first. */
1964 if (sio_data->kind == nct6775 || sio_data->kind == nct6776) {
1965 int mask = 0;
1966
1967 /*
1968 * Display temperature sensor output only if it monitors
1969 * a source other than one already reported. Always display
1970 * first three temperature registers, though.
1971 */
1972 for (i = 0; i < NUM_REG_TEMP; i++) {
1973 u8 src;
1974
1975 data->reg_temp[i] = NCT6775_REG_TEMP[i];
1976 data->reg_temp_over[i] = NCT6775_REG_TEMP_OVER[i];
1977 data->reg_temp_hyst[i] = NCT6775_REG_TEMP_HYST[i];
1978 data->reg_temp_config[i] = NCT6775_REG_TEMP_CONFIG[i];
1979
1980 src = w83627ehf_read_value(data,
1981 NCT6775_REG_TEMP_SOURCE[i]);
1982 src &= 0x1f;
1983 if (src && !(mask & (1 << src))) {
1984 data->have_temp |= 1 << i;
1985 mask |= 1 << src;
1986 }
1987
1988 data->temp_src[i] = src;
1989
1990 /*
1991 * Now do some register swapping if index 0..2 don't
1992 * point to SYSTIN(1), CPUIN(2), and AUXIN(3).
1993 * Idea is to have the first three attributes
1994 * report SYSTIN, CPUIN, and AUXIN if possible
1995 * without overriding the basic system configuration.
1996 */
1997 if (i > 0 && data->temp_src[0] != 1
1998 && data->temp_src[i] == 1)
1999 w82627ehf_swap_tempreg(data, 0, i);
2000 if (i > 1 && data->temp_src[1] != 2
2001 && data->temp_src[i] == 2)
2002 w82627ehf_swap_tempreg(data, 1, i);
2003 if (i > 2 && data->temp_src[2] != 3
2004 && data->temp_src[i] == 3)
2005 w82627ehf_swap_tempreg(data, 2, i);
2006 }
2007 if (sio_data->kind == nct6776) {
2008 /*
2009 * On NCT6776, AUXTIN and VIN3 pins are shared.
2010 * Only way to detect it is to check if AUXTIN is used
2011 * as a temperature source, and if that source is
2012 * enabled.
2013 *
2014 * If that is the case, disable in6, which reports VIN3.
2015 * Otherwise disable temp3.
2016 */
2017 if (data->temp_src[2] == 3) {
2018 u8 reg;
2019
2020 if (data->reg_temp_config[2])
2021 reg = w83627ehf_read_value(data,
2022 data->reg_temp_config[2]);
2023 else
2024 reg = 0; /* Assume AUXTIN is used */
2025
2026 if (reg & 0x01)
2027 data->have_temp &= ~(1 << 2);
2028 else
2029 data->in6_skip = 1;
2030 }
2031 data->temp_label = nct6776_temp_label;
2032 } else {
2033 data->temp_label = nct6775_temp_label;
2034 }
2035 } else if (sio_data->kind == w83667hg_b) {
2036 u8 reg;
2037
2038 /*
2039 * Temperature sources are selected with bank 0, registers 0x49
2040 * and 0x4a.
2041 */
2042 for (i = 0; i < ARRAY_SIZE(W83627EHF_REG_TEMP); i++) {
2043 data->reg_temp[i] = W83627EHF_REG_TEMP[i];
2044 data->reg_temp_over[i] = W83627EHF_REG_TEMP_OVER[i];
2045 data->reg_temp_hyst[i] = W83627EHF_REG_TEMP_HYST[i];
2046 data->reg_temp_config[i] = W83627EHF_REG_TEMP_CONFIG[i];
2047 }
2048 reg = w83627ehf_read_value(data, 0x4a);
2049 data->temp_src[0] = reg >> 5;
2050 reg = w83627ehf_read_value(data, 0x49);
2051 data->temp_src[1] = reg & 0x07;
2052 data->temp_src[2] = (reg >> 4) & 0x07;
2053
2054 /*
2055 * W83667HG-B has another temperature register at 0x7e.
2056 * The temperature source is selected with register 0x7d.
2057 * Support it if the source differs from already reported
2058 * sources.
2059 */
2060 reg = w83627ehf_read_value(data, 0x7d);
2061 reg &= 0x07;
2062 if (reg != data->temp_src[0] && reg != data->temp_src[1]
2063 && reg != data->temp_src[2]) {
2064 data->temp_src[3] = reg;
2065 data->have_temp |= 1 << 3;
2066 }
2067
2068 /*
2069 * Chip supports either AUXTIN or VIN3. Try to find out which
2070 * one.
2071 */
2072 reg = w83627ehf_read_value(data, W83627EHF_REG_TEMP_CONFIG[2]);
2073 if (data->temp_src[2] == 2 && (reg & 0x01))
2074 data->have_temp &= ~(1 << 2);
2075
2076 if ((data->temp_src[2] == 2 && (data->have_temp & (1 << 2)))
2077 || (data->temp_src[3] == 2 && (data->have_temp & (1 << 3))))
2078 data->in6_skip = 1;
2079
2080 data->temp_label = w83667hg_b_temp_label;
2081 } else {
2082 /* Temperature sources are fixed */
2083 for (i = 0; i < 3; i++) {
2084 data->reg_temp[i] = W83627EHF_REG_TEMP[i];
2085 data->reg_temp_over[i] = W83627EHF_REG_TEMP_OVER[i];
2086 data->reg_temp_hyst[i] = W83627EHF_REG_TEMP_HYST[i];
2087 data->reg_temp_config[i] = W83627EHF_REG_TEMP_CONFIG[i];
2088 }
2089 }
2090
2091 if (sio_data->kind == nct6775) {
2092 data->has_fan_div = true;
2093 data->fan_from_reg = fan_from_reg16;
2094 data->fan_from_reg_min = fan_from_reg8;
2095 data->REG_PWM = NCT6775_REG_PWM;
2096 data->REG_TARGET = NCT6775_REG_TARGET;
2097 data->REG_FAN = NCT6775_REG_FAN;
2098 data->REG_FAN_MIN = W83627EHF_REG_FAN_MIN;
2099 data->REG_FAN_START_OUTPUT = NCT6775_REG_FAN_START_OUTPUT;
2100 data->REG_FAN_STOP_OUTPUT = NCT6775_REG_FAN_STOP_OUTPUT;
2101 data->REG_FAN_STOP_TIME = NCT6775_REG_FAN_STOP_TIME;
2102 data->REG_FAN_MAX_OUTPUT = NCT6775_REG_FAN_MAX_OUTPUT;
2103 data->REG_FAN_STEP_OUTPUT = NCT6775_REG_FAN_STEP_OUTPUT;
2104 } else if (sio_data->kind == nct6776) {
2105 data->has_fan_div = false;
2106 data->fan_from_reg = fan_from_reg13;
2107 data->fan_from_reg_min = fan_from_reg13;
2108 data->REG_PWM = NCT6775_REG_PWM;
2109 data->REG_TARGET = NCT6775_REG_TARGET;
2110 data->REG_FAN = NCT6775_REG_FAN;
2111 data->REG_FAN_MIN = NCT6776_REG_FAN_MIN;
2112 data->REG_FAN_START_OUTPUT = NCT6775_REG_FAN_START_OUTPUT;
2113 data->REG_FAN_STOP_OUTPUT = NCT6775_REG_FAN_STOP_OUTPUT;
2114 data->REG_FAN_STOP_TIME = NCT6775_REG_FAN_STOP_TIME;
2115 } else if (sio_data->kind == w83667hg_b) {
2116 data->has_fan_div = true;
2117 data->fan_from_reg = fan_from_reg8;
2118 data->fan_from_reg_min = fan_from_reg8;
2119 data->REG_PWM = W83627EHF_REG_PWM;
2120 data->REG_TARGET = W83627EHF_REG_TARGET;
2121 data->REG_FAN = W83627EHF_REG_FAN;
2122 data->REG_FAN_MIN = W83627EHF_REG_FAN_MIN;
2123 data->REG_FAN_START_OUTPUT = W83627EHF_REG_FAN_START_OUTPUT;
2124 data->REG_FAN_STOP_OUTPUT = W83627EHF_REG_FAN_STOP_OUTPUT;
2125 data->REG_FAN_STOP_TIME = W83627EHF_REG_FAN_STOP_TIME;
2126 data->REG_FAN_MAX_OUTPUT =
2127 W83627EHF_REG_FAN_MAX_OUTPUT_W83667_B;
2128 data->REG_FAN_STEP_OUTPUT =
2129 W83627EHF_REG_FAN_STEP_OUTPUT_W83667_B;
2130 } else {
2131 data->has_fan_div = true;
2132 data->fan_from_reg = fan_from_reg8;
2133 data->fan_from_reg_min = fan_from_reg8;
2134 data->REG_PWM = W83627EHF_REG_PWM;
2135 data->REG_TARGET = W83627EHF_REG_TARGET;
2136 data->REG_FAN = W83627EHF_REG_FAN;
2137 data->REG_FAN_MIN = W83627EHF_REG_FAN_MIN;
2138 data->REG_FAN_START_OUTPUT = W83627EHF_REG_FAN_START_OUTPUT;
2139 data->REG_FAN_STOP_OUTPUT = W83627EHF_REG_FAN_STOP_OUTPUT;
2140 data->REG_FAN_STOP_TIME = W83627EHF_REG_FAN_STOP_TIME;
2141 data->REG_FAN_MAX_OUTPUT =
2142 W83627EHF_REG_FAN_MAX_OUTPUT_COMMON;
2143 data->REG_FAN_STEP_OUTPUT =
2144 W83627EHF_REG_FAN_STEP_OUTPUT_COMMON;
2145 }
2146
2147 /* Initialize the chip */
2148 w83627ehf_init_device(data, sio_data->kind);
2149
2150 data->vrm = vid_which_vrm();
2151 superio_enter(sio_data->sioreg);
2152 /* Read VID value */
2153 if (sio_data->kind == w83667hg || sio_data->kind == w83667hg_b ||
2154 sio_data->kind == nct6775 || sio_data->kind == nct6776) {
2155 /* W83667HG has different pins for VID input and output, so
2156 we can get the VID input values directly at logical device D
2157 0xe3. */
2158 superio_select(sio_data->sioreg, W83667HG_LD_VID);
2159 data->vid = superio_inb(sio_data->sioreg, 0xe3);
2160 err = device_create_file(dev, &dev_attr_cpu0_vid);
2161 if (err)
2162 goto exit_release;
2163 } else {
2164 superio_select(sio_data->sioreg, W83627EHF_LD_HWM);
2165 if (superio_inb(sio_data->sioreg, SIO_REG_VID_CTRL) & 0x80) {
2166 /* Set VID input sensibility if needed. In theory the
2167 BIOS should have set it, but in practice it's not
2168 always the case. We only do it for the W83627EHF/EHG
2169 because the W83627DHG is more complex in this
2170 respect. */
2171 if (sio_data->kind == w83627ehf) {
2172 en_vrm10 = superio_inb(sio_data->sioreg,
2173 SIO_REG_EN_VRM10);
2174 if ((en_vrm10 & 0x08) && data->vrm == 90) {
2175 dev_warn(dev, "Setting VID input "
2176 "voltage to TTL\n");
2177 superio_outb(sio_data->sioreg,
2178 SIO_REG_EN_VRM10,
2179 en_vrm10 & ~0x08);
2180 } else if (!(en_vrm10 & 0x08)
2181 && data->vrm == 100) {
2182 dev_warn(dev, "Setting VID input "
2183 "voltage to VRM10\n");
2184 superio_outb(sio_data->sioreg,
2185 SIO_REG_EN_VRM10,
2186 en_vrm10 | 0x08);
2187 }
2188 }
2189
2190 data->vid = superio_inb(sio_data->sioreg,
2191 SIO_REG_VID_DATA);
2192 if (sio_data->kind == w83627ehf) /* 6 VID pins only */
2193 data->vid &= 0x3f;
2194
2195 err = device_create_file(dev, &dev_attr_cpu0_vid);
2196 if (err)
2197 goto exit_release;
2198 } else {
2199 dev_info(dev, "VID pins in output mode, CPU VID not "
2200 "available\n");
2201 }
2202 }
2203
2204 if (fan_debounce &&
2205 (sio_data->kind == nct6775 || sio_data->kind == nct6776)) {
2206 u8 tmp;
2207
2208 superio_select(sio_data->sioreg, W83627EHF_LD_HWM);
2209 tmp = superio_inb(sio_data->sioreg, NCT6775_REG_FAN_DEBOUNCE);
2210 if (sio_data->kind == nct6776)
2211 superio_outb(sio_data->sioreg, NCT6775_REG_FAN_DEBOUNCE,
2212 0x3e | tmp);
2213 else
2214 superio_outb(sio_data->sioreg, NCT6775_REG_FAN_DEBOUNCE,
2215 0x1e | tmp);
2216 pr_info("Enabled fan debounce for chip %s\n", data->name);
2217 }
2218
2219 superio_exit(sio_data->sioreg);
2220
2221 w83627ehf_check_fan_inputs(sio_data, data);
2222
2223 /* Read fan clock dividers immediately */
2224 w83627ehf_update_fan_div_common(dev, data);
2225
2226 /* Read pwm data to save original values */
2227 w83627ehf_update_pwm_common(dev, data);
2228 for (i = 0; i < data->pwm_num; i++)
2229 data->pwm_enable_orig[i] = data->pwm_enable[i];
2230
2231 /* Read pwm data to save original values */
2232 w83627ehf_update_pwm_common(dev, data);
2233 for (i = 0; i < data->pwm_num; i++)
2234 data->pwm_enable_orig[i] = data->pwm_enable[i];
2235
2236 /* Register sysfs hooks */
2237 for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++) {
2238 err = device_create_file(dev, &sda_sf3_arrays[i].dev_attr);
2239 if (err)
2240 goto exit_remove;
2241 }
2242
2243 for (i = 0; i < ARRAY_SIZE(sda_sf3_max_step_arrays); i++) {
2244 struct sensor_device_attribute *attr =
2245 &sda_sf3_max_step_arrays[i];
2246 if (data->REG_FAN_STEP_OUTPUT &&
2247 data->REG_FAN_STEP_OUTPUT[attr->index] != 0xff) {
2248 err = device_create_file(dev, &attr->dev_attr);
2249 if (err)
2250 goto exit_remove;
2251 }
2252 }
2253 /* if fan4 is enabled create the sf3 files for it */
2254 if ((data->has_fan & (1 << 3)) && data->pwm_num >= 4)
2255 for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++) {
2256 err = device_create_file(dev,
2257 &sda_sf3_arrays_fan4[i].dev_attr);
2258 if (err)
2259 goto exit_remove;
2260 }
2261
2262 for (i = 0; i < data->in_num; i++) {
2263 if ((i == 6) && data->in6_skip)
2264 continue;
2265 if ((err = device_create_file(dev, &sda_in_input[i].dev_attr))
2266 || (err = device_create_file(dev,
2267 &sda_in_alarm[i].dev_attr))
2268 || (err = device_create_file(dev,
2269 &sda_in_min[i].dev_attr))
2270 || (err = device_create_file(dev,
2271 &sda_in_max[i].dev_attr)))
2272 goto exit_remove;
2273 }
2274
2275 for (i = 0; i < 5; i++) {
2276 if (data->has_fan & (1 << i)) {
2277 if ((err = device_create_file(dev,
2278 &sda_fan_input[i].dev_attr))
2279 || (err = device_create_file(dev,
2280 &sda_fan_alarm[i].dev_attr)))
2281 goto exit_remove;
2282 if (sio_data->kind != nct6776) {
2283 err = device_create_file(dev,
2284 &sda_fan_div[i].dev_attr);
2285 if (err)
2286 goto exit_remove;
2287 }
2288 if (data->has_fan_min & (1 << i)) {
2289 err = device_create_file(dev,
2290 &sda_fan_min[i].dev_attr);
2291 if (err)
2292 goto exit_remove;
2293 }
2294 if (i < data->pwm_num &&
2295 ((err = device_create_file(dev,
2296 &sda_pwm[i].dev_attr))
2297 || (err = device_create_file(dev,
2298 &sda_pwm_mode[i].dev_attr))
2299 || (err = device_create_file(dev,
2300 &sda_pwm_enable[i].dev_attr))
2301 || (err = device_create_file(dev,
2302 &sda_target_temp[i].dev_attr))
2303 || (err = device_create_file(dev,
2304 &sda_tolerance[i].dev_attr))))
2305 goto exit_remove;
2306 }
2307 }
2308
2309 for (i = 0; i < NUM_REG_TEMP; i++) {
2310 if (!(data->have_temp & (1 << i)))
2311 continue;
2312 err = device_create_file(dev, &sda_temp_input[i].dev_attr);
2313 if (err)
2314 goto exit_remove;
2315 if (data->temp_label) {
2316 err = device_create_file(dev,
2317 &sda_temp_label[i].dev_attr);
2318 if (err)
2319 goto exit_remove;
2320 }
2321 if (data->reg_temp_over[i]) {
2322 err = device_create_file(dev,
2323 &sda_temp_max[i].dev_attr);
2324 if (err)
2325 goto exit_remove;
2326 }
2327 if (data->reg_temp_hyst[i]) {
2328 err = device_create_file(dev,
2329 &sda_temp_max_hyst[i].dev_attr);
2330 if (err)
2331 goto exit_remove;
2332 }
2333 if (i > 2)
2334 continue;
2335 if ((err = device_create_file(dev,
2336 &sda_temp_alarm[i].dev_attr))
2337 || (err = device_create_file(dev,
2338 &sda_temp_type[i].dev_attr)))
2339 goto exit_remove;
2340 }
2341
2342 err = device_create_file(dev, &sda_caseopen[0].dev_attr);
2343 if (err)
2344 goto exit_remove;
2345
2346 if (sio_data->kind == nct6776) {
2347 err = device_create_file(dev, &sda_caseopen[1].dev_attr);
2348 if (err)
2349 goto exit_remove;
2350 }
2351
2352 err = device_create_file(dev, &dev_attr_name);
2353 if (err)
2354 goto exit_remove;
2355
2356 data->hwmon_dev = hwmon_device_register(dev);
2357 if (IS_ERR(data->hwmon_dev)) {
2358 err = PTR_ERR(data->hwmon_dev);
2359 goto exit_remove;
2360 }
2361
2362 return 0;
2363
2364 exit_remove:
2365 w83627ehf_device_remove_files(dev);
2366 kfree(data);
2367 platform_set_drvdata(pdev, NULL);
2368 exit_release:
2369 release_region(res->start, IOREGION_LENGTH);
2370 exit:
2371 return err;
2372 }
2373
2374 static int __devexit w83627ehf_remove(struct platform_device *pdev)
2375 {
2376 struct w83627ehf_data *data = platform_get_drvdata(pdev);
2377
2378 hwmon_device_unregister(data->hwmon_dev);
2379 w83627ehf_device_remove_files(&pdev->dev);
2380 release_region(data->addr, IOREGION_LENGTH);
2381 platform_set_drvdata(pdev, NULL);
2382 kfree(data);
2383
2384 return 0;
2385 }
2386
2387 static struct platform_driver w83627ehf_driver = {
2388 .driver = {
2389 .owner = THIS_MODULE,
2390 .name = DRVNAME,
2391 },
2392 .probe = w83627ehf_probe,
2393 .remove = __devexit_p(w83627ehf_remove),
2394 };
2395
2396 /* w83627ehf_find() looks for a '627 in the Super-I/O config space */
2397 static int __init w83627ehf_find(int sioaddr, unsigned short *addr,
2398 struct w83627ehf_sio_data *sio_data)
2399 {
2400 static const char __initdata sio_name_W83627EHF[] = "W83627EHF";
2401 static const char __initdata sio_name_W83627EHG[] = "W83627EHG";
2402 static const char __initdata sio_name_W83627DHG[] = "W83627DHG";
2403 static const char __initdata sio_name_W83627DHG_P[] = "W83627DHG-P";
2404 static const char __initdata sio_name_W83667HG[] = "W83667HG";
2405 static const char __initdata sio_name_W83667HG_B[] = "W83667HG-B";
2406 static const char __initdata sio_name_NCT6775[] = "NCT6775F";
2407 static const char __initdata sio_name_NCT6776[] = "NCT6776F";
2408
2409 u16 val;
2410 const char *sio_name;
2411
2412 superio_enter(sioaddr);
2413
2414 if (force_id)
2415 val = force_id;
2416 else
2417 val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8)
2418 | superio_inb(sioaddr, SIO_REG_DEVID + 1);
2419 switch (val & SIO_ID_MASK) {
2420 case SIO_W83627EHF_ID:
2421 sio_data->kind = w83627ehf;
2422 sio_name = sio_name_W83627EHF;
2423 break;
2424 case SIO_W83627EHG_ID:
2425 sio_data->kind = w83627ehf;
2426 sio_name = sio_name_W83627EHG;
2427 break;
2428 case SIO_W83627DHG_ID:
2429 sio_data->kind = w83627dhg;
2430 sio_name = sio_name_W83627DHG;
2431 break;
2432 case SIO_W83627DHG_P_ID:
2433 sio_data->kind = w83627dhg_p;
2434 sio_name = sio_name_W83627DHG_P;
2435 break;
2436 case SIO_W83667HG_ID:
2437 sio_data->kind = w83667hg;
2438 sio_name = sio_name_W83667HG;
2439 break;
2440 case SIO_W83667HG_B_ID:
2441 sio_data->kind = w83667hg_b;
2442 sio_name = sio_name_W83667HG_B;
2443 break;
2444 case SIO_NCT6775_ID:
2445 sio_data->kind = nct6775;
2446 sio_name = sio_name_NCT6775;
2447 break;
2448 case SIO_NCT6776_ID:
2449 sio_data->kind = nct6776;
2450 sio_name = sio_name_NCT6776;
2451 break;
2452 default:
2453 if (val != 0xffff)
2454 pr_debug("unsupported chip ID: 0x%04x\n", val);
2455 superio_exit(sioaddr);
2456 return -ENODEV;
2457 }
2458
2459 /* We have a known chip, find the HWM I/O address */
2460 superio_select(sioaddr, W83627EHF_LD_HWM);
2461 val = (superio_inb(sioaddr, SIO_REG_ADDR) << 8)
2462 | superio_inb(sioaddr, SIO_REG_ADDR + 1);
2463 *addr = val & IOREGION_ALIGNMENT;
2464 if (*addr == 0) {
2465 pr_err("Refusing to enable a Super-I/O device with a base I/O port 0\n");
2466 superio_exit(sioaddr);
2467 return -ENODEV;
2468 }
2469
2470 /* Activate logical device if needed */
2471 val = superio_inb(sioaddr, SIO_REG_ENABLE);
2472 if (!(val & 0x01)) {
2473 pr_warn("Forcibly enabling Super-I/O. "
2474 "Sensor is probably unusable.\n");
2475 superio_outb(sioaddr, SIO_REG_ENABLE, val | 0x01);
2476 }
2477
2478 superio_exit(sioaddr);
2479 pr_info("Found %s chip at %#x\n", sio_name, *addr);
2480 sio_data->sioreg = sioaddr;
2481
2482 return 0;
2483 }
2484
2485 /* when Super-I/O functions move to a separate file, the Super-I/O
2486 * bus will manage the lifetime of the device and this module will only keep
2487 * track of the w83627ehf driver. But since we platform_device_alloc(), we
2488 * must keep track of the device */
2489 static struct platform_device *pdev;
2490
2491 static int __init sensors_w83627ehf_init(void)
2492 {
2493 int err;
2494 unsigned short address;
2495 struct resource res;
2496 struct w83627ehf_sio_data sio_data;
2497
2498 /* initialize sio_data->kind and sio_data->sioreg.
2499 *
2500 * when Super-I/O functions move to a separate file, the Super-I/O
2501 * driver will probe 0x2e and 0x4e and auto-detect the presence of a
2502 * w83627ehf hardware monitor, and call probe() */
2503 if (w83627ehf_find(0x2e, &address, &sio_data) &&
2504 w83627ehf_find(0x4e, &address, &sio_data))
2505 return -ENODEV;
2506
2507 err = platform_driver_register(&w83627ehf_driver);
2508 if (err)
2509 goto exit;
2510
2511 pdev = platform_device_alloc(DRVNAME, address);
2512 if (!pdev) {
2513 err = -ENOMEM;
2514 pr_err("Device allocation failed\n");
2515 goto exit_unregister;
2516 }
2517
2518 err = platform_device_add_data(pdev, &sio_data,
2519 sizeof(struct w83627ehf_sio_data));
2520 if (err) {
2521 pr_err("Platform data allocation failed\n");
2522 goto exit_device_put;
2523 }
2524
2525 memset(&res, 0, sizeof(res));
2526 res.name = DRVNAME;
2527 res.start = address + IOREGION_OFFSET;
2528 res.end = address + IOREGION_OFFSET + IOREGION_LENGTH - 1;
2529 res.flags = IORESOURCE_IO;
2530
2531 err = acpi_check_resource_conflict(&res);
2532 if (err)
2533 goto exit_device_put;
2534
2535 err = platform_device_add_resources(pdev, &res, 1);
2536 if (err) {
2537 pr_err("Device resource addition failed (%d)\n", err);
2538 goto exit_device_put;
2539 }
2540
2541 /* platform_device_add calls probe() */
2542 err = platform_device_add(pdev);
2543 if (err) {
2544 pr_err("Device addition failed (%d)\n", err);
2545 goto exit_device_put;
2546 }
2547
2548 return 0;
2549
2550 exit_device_put:
2551 platform_device_put(pdev);
2552 exit_unregister:
2553 platform_driver_unregister(&w83627ehf_driver);
2554 exit:
2555 return err;
2556 }
2557
2558 static void __exit sensors_w83627ehf_exit(void)
2559 {
2560 platform_device_unregister(pdev);
2561 platform_driver_unregister(&w83627ehf_driver);
2562 }
2563
2564 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
2565 MODULE_DESCRIPTION("W83627EHF driver");
2566 MODULE_LICENSE("GPL");
2567
2568 module_init(sensors_w83627ehf_init);
2569 module_exit(sensors_w83627ehf_exit);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree