projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-linus' of master.kernel.org:/home/rmk/linux-2.6-arm
[deliverable/linux.git] / drivers / hwmon / w83627ehf.c
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
9 Shamelessly ripped from the w83627hf driver
10 Copyright (C) 2003 Mark Studebaker
11
12 Thanks to Leon Moonen, Steve Cliffe and Grant Coady for their help
13 in testing and debugging this driver.
14
15 This driver also supports the W83627EHG, which is the lead-free
16 version of the W83627EHF.
17
18 This program is free software; you can redistribute it and/or modify
19 it under the terms of the GNU General Public License as published by
20 the Free Software Foundation; either version 2 of the License, or
21 (at your option) any later version.
22
23 This program is distributed in the hope that it will be useful,
24 but WITHOUT ANY WARRANTY; without even the implied warranty of
25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 GNU General Public License for more details.
27
28 You should have received a copy of the GNU General Public License
29 along with this program; if not, write to the Free Software
30 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
31
32
33 Supports the following chips:
34
35 Chip #vin #fan #pwm #temp chip_id man_id
36 w83627ehf 10 5 4 3 0x88,0xa1 0x5ca3
37 */
38
39 #include <linux/module.h>
40 #include <linux/init.h>
41 #include <linux/slab.h>
42 #include <linux/i2c.h>
43 #include <linux/i2c-isa.h>
44 #include <linux/hwmon.h>
45 #include <linux/hwmon-sysfs.h>
46 #include <linux/err.h>
47 #include <linux/mutex.h>
48 #include <asm/io.h>
49 #include "lm75.h"
50
51 /* The actual ISA address is read from Super-I/O configuration space */
52 static unsigned short address;
53
54 /*
55 * Super-I/O constants and functions
56 */
57
58 static int REG; /* The register to read/write */
59 static int VAL; /* The value to read/write */
60
61 #define W83627EHF_LD_HWM 0x0b
62
63 #define SIO_REG_LDSEL 0x07 /* Logical device select */
64 #define SIO_REG_DEVID 0x20 /* Device ID (2 bytes) */
65 #define SIO_REG_ENABLE 0x30 /* Logical device enable */
66 #define SIO_REG_ADDR 0x60 /* Logical device address (2 bytes) */
67
68 #define SIO_W83627EHF_ID 0x8840
69 #define SIO_ID_MASK 0xFFC0
70
71 static inline void
72 superio_outb(int reg, int val)
73 {
74 outb(reg, REG);
75 outb(val, VAL);
76 }
77
78 static inline int
79 superio_inb(int reg)
80 {
81 outb(reg, REG);
82 return inb(VAL);
83 }
84
85 static inline void
86 superio_select(int ld)
87 {
88 outb(SIO_REG_LDSEL, REG);
89 outb(ld, VAL);
90 }
91
92 static inline void
93 superio_enter(void)
94 {
95 outb(0x87, REG);
96 outb(0x87, REG);
97 }
98
99 static inline void
100 superio_exit(void)
101 {
102 outb(0x02, REG);
103 outb(0x02, VAL);
104 }
105
106 /*
107 * ISA constants
108 */
109
110 #define REGION_ALIGNMENT ~7
111 #define REGION_OFFSET 5
112 #define REGION_LENGTH 2
113 #define ADDR_REG_OFFSET 5
114 #define DATA_REG_OFFSET 6
115
116 #define W83627EHF_REG_BANK 0x4E
117 #define W83627EHF_REG_CONFIG 0x40
118 #define W83627EHF_REG_CHIP_ID 0x49
119 #define W83627EHF_REG_MAN_ID 0x4F
120
121 static const u16 W83627EHF_REG_FAN[] = { 0x28, 0x29, 0x2a, 0x3f, 0x553 };
122 static const u16 W83627EHF_REG_FAN_MIN[] = { 0x3b, 0x3c, 0x3d, 0x3e, 0x55c };
123
124 /* The W83627EHF registers for nr=7,8,9 are in bank 5 */
125 #define W83627EHF_REG_IN_MAX(nr) ((nr < 7) ? (0x2b + (nr) * 2) : \
126 (0x554 + (((nr) - 7) * 2)))
127 #define W83627EHF_REG_IN_MIN(nr) ((nr < 7) ? (0x2c + (nr) * 2) : \
128 (0x555 + (((nr) - 7) * 2)))
129 #define W83627EHF_REG_IN(nr) ((nr < 7) ? (0x20 + (nr)) : \
130 (0x550 + (nr) - 7))
131
132 #define W83627EHF_REG_TEMP1 0x27
133 #define W83627EHF_REG_TEMP1_HYST 0x3a
134 #define W83627EHF_REG_TEMP1_OVER 0x39
135 static const u16 W83627EHF_REG_TEMP[] = { 0x150, 0x250 };
136 static const u16 W83627EHF_REG_TEMP_HYST[] = { 0x153, 0x253 };
137 static const u16 W83627EHF_REG_TEMP_OVER[] = { 0x155, 0x255 };
138 static const u16 W83627EHF_REG_TEMP_CONFIG[] = { 0x152, 0x252 };
139
140 /* Fan clock dividers are spread over the following five registers */
141 #define W83627EHF_REG_FANDIV1 0x47
142 #define W83627EHF_REG_FANDIV2 0x4B
143 #define W83627EHF_REG_VBAT 0x5D
144 #define W83627EHF_REG_DIODE 0x59
145 #define W83627EHF_REG_SMI_OVT 0x4C
146
147 #define W83627EHF_REG_ALARM1 0x459
148 #define W83627EHF_REG_ALARM2 0x45A
149 #define W83627EHF_REG_ALARM3 0x45B
150
151 /* SmartFan registers */
152 /* DC or PWM output fan configuration */
153 static const u8 W83627EHF_REG_PWM_ENABLE[] = {
154 0x04, /* SYS FAN0 output mode and PWM mode */
155 0x04, /* CPU FAN0 output mode and PWM mode */
156 0x12, /* AUX FAN mode */
157 0x62, /* CPU fan1 mode */
158 };
159
160 static const u8 W83627EHF_PWM_MODE_SHIFT[] = { 0, 1, 0, 6 };
161 static const u8 W83627EHF_PWM_ENABLE_SHIFT[] = { 2, 4, 1, 4 };
162
163 /* FAN Duty Cycle, be used to control */
164 static const u8 W83627EHF_REG_PWM[] = { 0x01, 0x03, 0x11, 0x61 };
165 static const u8 W83627EHF_REG_TARGET[] = { 0x05, 0x06, 0x13, 0x63 };
166 static const u8 W83627EHF_REG_TOLERANCE[] = { 0x07, 0x07, 0x14, 0x62 };
167
168
169 /* Advanced Fan control, some values are common for all fans */
170 static const u8 W83627EHF_REG_FAN_MIN_OUTPUT[] = { 0x08, 0x09, 0x15, 0x64 };
171 static const u8 W83627EHF_REG_FAN_STOP_TIME[] = { 0x0C, 0x0D, 0x17, 0x66 };
172
173 /*
174 * Conversions
175 */
176
177 /* 1 is PWM mode, output in ms */
178 static inline unsigned int step_time_from_reg(u8 reg, u8 mode)
179 {
180 return mode ? 100 * reg : 400 * reg;
181 }
182
183 static inline u8 step_time_to_reg(unsigned int msec, u8 mode)
184 {
185 return SENSORS_LIMIT((mode ? (msec + 50) / 100 :
186 (msec + 200) / 400), 1, 255);
187 }
188
189 static inline unsigned int
190 fan_from_reg(u8 reg, unsigned int div)
191 {
192 if (reg == 0 || reg == 255)
193 return 0;
194 return 1350000U / (reg * div);
195 }
196
197 static inline unsigned int
198 div_from_reg(u8 reg)
199 {
200 return 1 << reg;
201 }
202
203 static inline int
204 temp1_from_reg(s8 reg)
205 {
206 return reg * 1000;
207 }
208
209 static inline s8
210 temp1_to_reg(int temp, int min, int max)
211 {
212 if (temp <= min)
213 return min / 1000;
214 if (temp >= max)
215 return max / 1000;
216 if (temp < 0)
217 return (temp - 500) / 1000;
218 return (temp + 500) / 1000;
219 }
220
221 /* Some of analog inputs have internal scaling (2x), 8mV is ADC LSB */
222
223 static u8 scale_in[10] = { 8, 8, 16, 16, 8, 8, 8, 16, 16, 8 };
224
225 static inline long in_from_reg(u8 reg, u8 nr)
226 {
227 return reg * scale_in[nr];
228 }
229
230 static inline u8 in_to_reg(u32 val, u8 nr)
231 {
232 return SENSORS_LIMIT(((val + (scale_in[nr] / 2)) / scale_in[nr]), 0, 255);
233 }
234
235 /*
236 * Data structures and manipulation thereof
237 */
238
239 struct w83627ehf_data {
240 struct i2c_client client;
241 struct class_device *class_dev;
242 struct mutex lock;
243
244 struct mutex update_lock;
245 char valid; /* !=0 if following fields are valid */
246 unsigned long last_updated; /* In jiffies */
247
248 /* Register values */
249 u8 in[10]; /* Register value */
250 u8 in_max[10]; /* Register value */
251 u8 in_min[10]; /* Register value */
252 u8 fan[5];
253 u8 fan_min[5];
254 u8 fan_div[5];
255 u8 has_fan; /* some fan inputs can be disabled */
256 s8 temp1;
257 s8 temp1_max;
258 s8 temp1_max_hyst;
259 s16 temp[2];
260 s16 temp_max[2];
261 s16 temp_max_hyst[2];
262 u32 alarms;
263
264 u8 pwm_mode[4]; /* 0->DC variable voltage, 1->PWM variable duty cycle */
265 u8 pwm_enable[4]; /* 1->manual
266 2->thermal cruise (also called SmartFan I) */
267 u8 pwm[4];
268 u8 target_temp[4];
269 u8 tolerance[4];
270
271 u8 fan_min_output[4]; /* minimum fan speed */
272 u8 fan_stop_time[4];
273 };
274
275 static inline int is_word_sized(u16 reg)
276 {
277 return (((reg & 0xff00) == 0x100
278 || (reg & 0xff00) == 0x200)
279 && ((reg & 0x00ff) == 0x50
280 || (reg & 0x00ff) == 0x53
281 || (reg & 0x00ff) == 0x55));
282 }
283
284 /* We assume that the default bank is 0, thus the following two functions do
285 nothing for registers which live in bank 0. For others, they respectively
286 set the bank register to the correct value (before the register is
287 accessed), and back to 0 (afterwards). */
288 static inline void w83627ehf_set_bank(struct i2c_client *client, u16 reg)
289 {
290 if (reg & 0xff00) {
291 outb_p(W83627EHF_REG_BANK, client->addr + ADDR_REG_OFFSET);
292 outb_p(reg >> 8, client->addr + DATA_REG_OFFSET);
293 }
294 }
295
296 static inline void w83627ehf_reset_bank(struct i2c_client *client, u16 reg)
297 {
298 if (reg & 0xff00) {
299 outb_p(W83627EHF_REG_BANK, client->addr + ADDR_REG_OFFSET);
300 outb_p(0, client->addr + DATA_REG_OFFSET);
301 }
302 }
303
304 static u16 w83627ehf_read_value(struct i2c_client *client, u16 reg)
305 {
306 struct w83627ehf_data *data = i2c_get_clientdata(client);
307 int res, word_sized = is_word_sized(reg);
308
309 mutex_lock(&data->lock);
310
311 w83627ehf_set_bank(client, reg);
312 outb_p(reg & 0xff, client->addr + ADDR_REG_OFFSET);
313 res = inb_p(client->addr + DATA_REG_OFFSET);
314 if (word_sized) {
315 outb_p((reg & 0xff) + 1,
316 client->addr + ADDR_REG_OFFSET);
317 res = (res << 8) + inb_p(client->addr + DATA_REG_OFFSET);
318 }
319 w83627ehf_reset_bank(client, reg);
320
321 mutex_unlock(&data->lock);
322
323 return res;
324 }
325
326 static int w83627ehf_write_value(struct i2c_client *client, u16 reg, u16 value)
327 {
328 struct w83627ehf_data *data = i2c_get_clientdata(client);
329 int word_sized = is_word_sized(reg);
330
331 mutex_lock(&data->lock);
332
333 w83627ehf_set_bank(client, reg);
334 outb_p(reg & 0xff, client->addr + ADDR_REG_OFFSET);
335 if (word_sized) {
336 outb_p(value >> 8, client->addr + DATA_REG_OFFSET);
337 outb_p((reg & 0xff) + 1,
338 client->addr + ADDR_REG_OFFSET);
339 }
340 outb_p(value & 0xff, client->addr + DATA_REG_OFFSET);
341 w83627ehf_reset_bank(client, reg);
342
343 mutex_unlock(&data->lock);
344 return 0;
345 }
346
347 /* This function assumes that the caller holds data->update_lock */
348 static void w83627ehf_write_fan_div(struct i2c_client *client, int nr)
349 {
350 struct w83627ehf_data *data = i2c_get_clientdata(client);
351 u8 reg;
352
353 switch (nr) {
354 case 0:
355 reg = (w83627ehf_read_value(client, W83627EHF_REG_FANDIV1) & 0xcf)
356 | ((data->fan_div[0] & 0x03) << 4);
357 /* fan5 input control bit is write only, compute the value */
358 reg |= (data->has_fan & (1 << 4)) ? 1 : 0;
359 w83627ehf_write_value(client, W83627EHF_REG_FANDIV1, reg);
360 reg = (w83627ehf_read_value(client, W83627EHF_REG_VBAT) & 0xdf)
361 | ((data->fan_div[0] & 0x04) << 3);
362 w83627ehf_write_value(client, W83627EHF_REG_VBAT, reg);
363 break;
364 case 1:
365 reg = (w83627ehf_read_value(client, W83627EHF_REG_FANDIV1) & 0x3f)
366 | ((data->fan_div[1] & 0x03) << 6);
367 /* fan5 input control bit is write only, compute the value */
368 reg |= (data->has_fan & (1 << 4)) ? 1 : 0;
369 w83627ehf_write_value(client, W83627EHF_REG_FANDIV1, reg);
370 reg = (w83627ehf_read_value(client, W83627EHF_REG_VBAT) & 0xbf)
371 | ((data->fan_div[1] & 0x04) << 4);
372 w83627ehf_write_value(client, W83627EHF_REG_VBAT, reg);
373 break;
374 case 2:
375 reg = (w83627ehf_read_value(client, W83627EHF_REG_FANDIV2) & 0x3f)
376 | ((data->fan_div[2] & 0x03) << 6);
377 w83627ehf_write_value(client, W83627EHF_REG_FANDIV2, reg);
378 reg = (w83627ehf_read_value(client, W83627EHF_REG_VBAT) & 0x7f)
379 | ((data->fan_div[2] & 0x04) << 5);
380 w83627ehf_write_value(client, W83627EHF_REG_VBAT, reg);
381 break;
382 case 3:
383 reg = (w83627ehf_read_value(client, W83627EHF_REG_DIODE) & 0xfc)
384 | (data->fan_div[3] & 0x03);
385 w83627ehf_write_value(client, W83627EHF_REG_DIODE, reg);
386 reg = (w83627ehf_read_value(client, W83627EHF_REG_SMI_OVT) & 0x7f)
387 | ((data->fan_div[3] & 0x04) << 5);
388 w83627ehf_write_value(client, W83627EHF_REG_SMI_OVT, reg);
389 break;
390 case 4:
391 reg = (w83627ehf_read_value(client, W83627EHF_REG_DIODE) & 0x73)
392 | ((data->fan_div[4] & 0x03) << 3)
393 | ((data->fan_div[4] & 0x04) << 5);
394 w83627ehf_write_value(client, W83627EHF_REG_DIODE, reg);
395 break;
396 }
397 }
398
399 static struct w83627ehf_data *w83627ehf_update_device(struct device *dev)
400 {
401 struct i2c_client *client = to_i2c_client(dev);
402 struct w83627ehf_data *data = i2c_get_clientdata(client);
403 int pwmcfg = 0, tolerance = 0; /* shut up the compiler */
404 int i;
405
406 mutex_lock(&data->update_lock);
407
408 if (time_after(jiffies, data->last_updated + HZ)
409 || !data->valid) {
410 /* Fan clock dividers */
411 i = w83627ehf_read_value(client, W83627EHF_REG_FANDIV1);
412 data->fan_div[0] = (i >> 4) & 0x03;
413 data->fan_div[1] = (i >> 6) & 0x03;
414 i = w83627ehf_read_value(client, W83627EHF_REG_FANDIV2);
415 data->fan_div[2] = (i >> 6) & 0x03;
416 i = w83627ehf_read_value(client, W83627EHF_REG_VBAT);
417 data->fan_div[0] |= (i >> 3) & 0x04;
418 data->fan_div[1] |= (i >> 4) & 0x04;
419 data->fan_div[2] |= (i >> 5) & 0x04;
420 if (data->has_fan & ((1 << 3) | (1 << 4))) {
421 i = w83627ehf_read_value(client, W83627EHF_REG_DIODE);
422 data->fan_div[3] = i & 0x03;
423 data->fan_div[4] = ((i >> 2) & 0x03)
424 | ((i >> 5) & 0x04);
425 }
426 if (data->has_fan & (1 << 3)) {
427 i = w83627ehf_read_value(client, W83627EHF_REG_SMI_OVT);
428 data->fan_div[3] |= (i >> 5) & 0x04;
429 }
430
431 /* Measured voltages and limits */
432 for (i = 0; i < 10; i++) {
433 data->in[i] = w83627ehf_read_value(client,
434 W83627EHF_REG_IN(i));
435 data->in_min[i] = w83627ehf_read_value(client,
436 W83627EHF_REG_IN_MIN(i));
437 data->in_max[i] = w83627ehf_read_value(client,
438 W83627EHF_REG_IN_MAX(i));
439 }
440
441 /* Measured fan speeds and limits */
442 for (i = 0; i < 5; i++) {
443 if (!(data->has_fan & (1 << i)))
444 continue;
445
446 data->fan[i] = w83627ehf_read_value(client,
447 W83627EHF_REG_FAN[i]);
448 data->fan_min[i] = w83627ehf_read_value(client,
449 W83627EHF_REG_FAN_MIN[i]);
450
451 /* If we failed to measure the fan speed and clock
452 divider can be increased, let's try that for next
453 time */
454 if (data->fan[i] == 0xff
455 && data->fan_div[i] < 0x07) {
456 dev_dbg(&client->dev, "Increasing fan %d "
457 "clock divider from %u to %u\n",
458 i, div_from_reg(data->fan_div[i]),
459 div_from_reg(data->fan_div[i] + 1));
460 data->fan_div[i]++;
461 w83627ehf_write_fan_div(client, i);
462 /* Preserve min limit if possible */
463 if (data->fan_min[i] >= 2
464 && data->fan_min[i] != 255)
465 w83627ehf_write_value(client,
466 W83627EHF_REG_FAN_MIN[i],
467 (data->fan_min[i] /= 2));
468 }
469 }
470
471 for (i = 0; i < 4; i++) {
472 /* pwmcfg, tolarance mapped for i=0, i=1 to same reg */
473 if (i != 1) {
474 pwmcfg = w83627ehf_read_value(client,
475 W83627EHF_REG_PWM_ENABLE[i]);
476 tolerance = w83627ehf_read_value(client,
477 W83627EHF_REG_TOLERANCE[i]);
478 }
479 data->pwm_mode[i] =
480 ((pwmcfg >> W83627EHF_PWM_MODE_SHIFT[i]) & 1)
481 ? 0 : 1;
482 data->pwm_enable[i] =
483 ((pwmcfg >> W83627EHF_PWM_ENABLE_SHIFT[i])
484 & 3) + 1;
485 data->pwm[i] = w83627ehf_read_value(client,
486 W83627EHF_REG_PWM[i]);
487 data->fan_min_output[i] = w83627ehf_read_value(client,
488 W83627EHF_REG_FAN_MIN_OUTPUT[i]);
489 data->fan_stop_time[i] = w83627ehf_read_value(client,
490 W83627EHF_REG_FAN_STOP_TIME[i]);
491 data->target_temp[i] =
492 w83627ehf_read_value(client,
493 W83627EHF_REG_TARGET[i]) &
494 (data->pwm_mode[i] == 1 ? 0x7f : 0xff);
495 data->tolerance[i] = (tolerance >> (i == 1 ? 4 : 0))
496 & 0x0f;
497 }
498
499 /* Measured temperatures and limits */
500 data->temp1 = w83627ehf_read_value(client,
501 W83627EHF_REG_TEMP1);
502 data->temp1_max = w83627ehf_read_value(client,
503 W83627EHF_REG_TEMP1_OVER);
504 data->temp1_max_hyst = w83627ehf_read_value(client,
505 W83627EHF_REG_TEMP1_HYST);
506 for (i = 0; i < 2; i++) {
507 data->temp[i] = w83627ehf_read_value(client,
508 W83627EHF_REG_TEMP[i]);
509 data->temp_max[i] = w83627ehf_read_value(client,
510 W83627EHF_REG_TEMP_OVER[i]);
511 data->temp_max_hyst[i] = w83627ehf_read_value(client,
512 W83627EHF_REG_TEMP_HYST[i]);
513 }
514
515 data->alarms = w83627ehf_read_value(client,
516 W83627EHF_REG_ALARM1) |
517 (w83627ehf_read_value(client,
518 W83627EHF_REG_ALARM2) << 8) |
519 (w83627ehf_read_value(client,
520 W83627EHF_REG_ALARM3) << 16);
521
522 data->last_updated = jiffies;
523 data->valid = 1;
524 }
525
526 mutex_unlock(&data->update_lock);
527 return data;
528 }
529
530 /*
531 * Sysfs callback functions
532 */
533 #define show_in_reg(reg) \
534 static ssize_t \
535 show_##reg(struct device *dev, struct device_attribute *attr, \
536 char *buf) \
537 { \
538 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
539 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
540 int nr = sensor_attr->index; \
541 return sprintf(buf, "%ld\n", in_from_reg(data->reg[nr], nr)); \
542 }
543 show_in_reg(in)
544 show_in_reg(in_min)
545 show_in_reg(in_max)
546
547 #define store_in_reg(REG, reg) \
548 static ssize_t \
549 store_in_##reg (struct device *dev, struct device_attribute *attr, \
550 const char *buf, size_t count) \
551 { \
552 struct i2c_client *client = to_i2c_client(dev); \
553 struct w83627ehf_data *data = i2c_get_clientdata(client); \
554 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
555 int nr = sensor_attr->index; \
556 u32 val = simple_strtoul(buf, NULL, 10); \
557 \
558 mutex_lock(&data->update_lock); \
559 data->in_##reg[nr] = in_to_reg(val, nr); \
560 w83627ehf_write_value(client, W83627EHF_REG_IN_##REG(nr), \
561 data->in_##reg[nr]); \
562 mutex_unlock(&data->update_lock); \
563 return count; \
564 }
565
566 store_in_reg(MIN, min)
567 store_in_reg(MAX, max)
568
569 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, char *buf)
570 {
571 struct w83627ehf_data *data = w83627ehf_update_device(dev);
572 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
573 int nr = sensor_attr->index;
574 return sprintf(buf, "%u\n", (data->alarms >> nr) & 0x01);
575 }
576
577 static struct sensor_device_attribute sda_in_input[] = {
578 SENSOR_ATTR(in0_input, S_IRUGO, show_in, NULL, 0),
579 SENSOR_ATTR(in1_input, S_IRUGO, show_in, NULL, 1),
580 SENSOR_ATTR(in2_input, S_IRUGO, show_in, NULL, 2),
581 SENSOR_ATTR(in3_input, S_IRUGO, show_in, NULL, 3),
582 SENSOR_ATTR(in4_input, S_IRUGO, show_in, NULL, 4),
583 SENSOR_ATTR(in5_input, S_IRUGO, show_in, NULL, 5),
584 SENSOR_ATTR(in6_input, S_IRUGO, show_in, NULL, 6),
585 SENSOR_ATTR(in7_input, S_IRUGO, show_in, NULL, 7),
586 SENSOR_ATTR(in8_input, S_IRUGO, show_in, NULL, 8),
587 SENSOR_ATTR(in9_input, S_IRUGO, show_in, NULL, 9),
588 };
589
590 static struct sensor_device_attribute sda_in_alarm[] = {
591 SENSOR_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0),
592 SENSOR_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1),
593 SENSOR_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2),
594 SENSOR_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3),
595 SENSOR_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8),
596 SENSOR_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 21),
597 SENSOR_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 20),
598 SENSOR_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 16),
599 SENSOR_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 17),
600 SENSOR_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL, 19),
601 };
602
603 static struct sensor_device_attribute sda_in_min[] = {
604 SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 0),
605 SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 1),
606 SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 2),
607 SENSOR_ATTR(in3_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 3),
608 SENSOR_ATTR(in4_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 4),
609 SENSOR_ATTR(in5_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 5),
610 SENSOR_ATTR(in6_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 6),
611 SENSOR_ATTR(in7_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 7),
612 SENSOR_ATTR(in8_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 8),
613 SENSOR_ATTR(in9_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 9),
614 };
615
616 static struct sensor_device_attribute sda_in_max[] = {
617 SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 0),
618 SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 1),
619 SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 2),
620 SENSOR_ATTR(in3_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 3),
621 SENSOR_ATTR(in4_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 4),
622 SENSOR_ATTR(in5_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 5),
623 SENSOR_ATTR(in6_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 6),
624 SENSOR_ATTR(in7_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 7),
625 SENSOR_ATTR(in8_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 8),
626 SENSOR_ATTR(in9_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 9),
627 };
628
629 #define show_fan_reg(reg) \
630 static ssize_t \
631 show_##reg(struct device *dev, struct device_attribute *attr, \
632 char *buf) \
633 { \
634 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
635 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
636 int nr = sensor_attr->index; \
637 return sprintf(buf, "%d\n", \
638 fan_from_reg(data->reg[nr], \
639 div_from_reg(data->fan_div[nr]))); \
640 }
641 show_fan_reg(fan);
642 show_fan_reg(fan_min);
643
644 static ssize_t
645 show_fan_div(struct device *dev, struct device_attribute *attr,
646 char *buf)
647 {
648 struct w83627ehf_data *data = w83627ehf_update_device(dev);
649 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
650 int nr = sensor_attr->index;
651 return sprintf(buf, "%u\n", div_from_reg(data->fan_div[nr]));
652 }
653
654 static ssize_t
655 store_fan_min(struct device *dev, struct device_attribute *attr,
656 const char *buf, size_t count)
657 {
658 struct i2c_client *client = to_i2c_client(dev);
659 struct w83627ehf_data *data = i2c_get_clientdata(client);
660 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
661 int nr = sensor_attr->index;
662 unsigned int val = simple_strtoul(buf, NULL, 10);
663 unsigned int reg;
664 u8 new_div;
665
666 mutex_lock(&data->update_lock);
667 if (!val) {
668 /* No min limit, alarm disabled */
669 data->fan_min[nr] = 255;
670 new_div = data->fan_div[nr]; /* No change */
671 dev_info(dev, "fan%u low limit and alarm disabled\n", nr + 1);
672 } else if ((reg = 1350000U / val) >= 128 * 255) {
673 /* Speed below this value cannot possibly be represented,
674 even with the highest divider (128) */
675 data->fan_min[nr] = 254;
676 new_div = 7; /* 128 == (1 << 7) */
677 dev_warn(dev, "fan%u low limit %u below minimum %u, set to "
678 "minimum\n", nr + 1, val, fan_from_reg(254, 128));
679 } else if (!reg) {
680 /* Speed above this value cannot possibly be represented,
681 even with the lowest divider (1) */
682 data->fan_min[nr] = 1;
683 new_div = 0; /* 1 == (1 << 0) */
684 dev_warn(dev, "fan%u low limit %u above maximum %u, set to "
685 "maximum\n", nr + 1, val, fan_from_reg(1, 1));
686 } else {
687 /* Automatically pick the best divider, i.e. the one such
688 that the min limit will correspond to a register value
689 in the 96..192 range */
690 new_div = 0;
691 while (reg > 192 && new_div < 7) {
692 reg >>= 1;
693 new_div++;
694 }
695 data->fan_min[nr] = reg;
696 }
697
698 /* Write both the fan clock divider (if it changed) and the new
699 fan min (unconditionally) */
700 if (new_div != data->fan_div[nr]) {
701 if (new_div > data->fan_div[nr])
702 data->fan[nr] >>= (data->fan_div[nr] - new_div);
703 else
704 data->fan[nr] <<= (new_div - data->fan_div[nr]);
705
706 dev_dbg(dev, "fan%u clock divider changed from %u to %u\n",
707 nr + 1, div_from_reg(data->fan_div[nr]),
708 div_from_reg(new_div));
709 data->fan_div[nr] = new_div;
710 w83627ehf_write_fan_div(client, nr);
711 }
712 w83627ehf_write_value(client, W83627EHF_REG_FAN_MIN[nr],
713 data->fan_min[nr]);
714 mutex_unlock(&data->update_lock);
715
716 return count;
717 }
718
719 static struct sensor_device_attribute sda_fan_input[] = {
720 SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0),
721 SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1),
722 SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2),
723 SENSOR_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3),
724 SENSOR_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4),
725 };
726
727 static struct sensor_device_attribute sda_fan_alarm[] = {
728 SENSOR_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6),
729 SENSOR_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7),
730 SENSOR_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11),
731 SENSOR_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 10),
732 SENSOR_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 23),
733 };
734
735 static struct sensor_device_attribute sda_fan_min[] = {
736 SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min,
737 store_fan_min, 0),
738 SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min,
739 store_fan_min, 1),
740 SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min,
741 store_fan_min, 2),
742 SENSOR_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min,
743 store_fan_min, 3),
744 SENSOR_ATTR(fan5_min, S_IWUSR | S_IRUGO, show_fan_min,
745 store_fan_min, 4),
746 };
747
748 static struct sensor_device_attribute sda_fan_div[] = {
749 SENSOR_ATTR(fan1_div, S_IRUGO, show_fan_div, NULL, 0),
750 SENSOR_ATTR(fan2_div, S_IRUGO, show_fan_div, NULL, 1),
751 SENSOR_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2),
752 SENSOR_ATTR(fan4_div, S_IRUGO, show_fan_div, NULL, 3),
753 SENSOR_ATTR(fan5_div, S_IRUGO, show_fan_div, NULL, 4),
754 };
755
756 #define show_temp1_reg(reg) \
757 static ssize_t \
758 show_##reg(struct device *dev, struct device_attribute *attr, \
759 char *buf) \
760 { \
761 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
762 return sprintf(buf, "%d\n", temp1_from_reg(data->reg)); \
763 }
764 show_temp1_reg(temp1);
765 show_temp1_reg(temp1_max);
766 show_temp1_reg(temp1_max_hyst);
767
768 #define store_temp1_reg(REG, reg) \
769 static ssize_t \
770 store_temp1_##reg(struct device *dev, struct device_attribute *attr, \
771 const char *buf, size_t count) \
772 { \
773 struct i2c_client *client = to_i2c_client(dev); \
774 struct w83627ehf_data *data = i2c_get_clientdata(client); \
775 u32 val = simple_strtoul(buf, NULL, 10); \
776 \
777 mutex_lock(&data->update_lock); \
778 data->temp1_##reg = temp1_to_reg(val, -128000, 127000); \
779 w83627ehf_write_value(client, W83627EHF_REG_TEMP1_##REG, \
780 data->temp1_##reg); \
781 mutex_unlock(&data->update_lock); \
782 return count; \
783 }
784 store_temp1_reg(OVER, max);
785 store_temp1_reg(HYST, max_hyst);
786
787 #define show_temp_reg(reg) \
788 static ssize_t \
789 show_##reg(struct device *dev, struct device_attribute *attr, \
790 char *buf) \
791 { \
792 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
793 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
794 int nr = sensor_attr->index; \
795 return sprintf(buf, "%d\n", \
796 LM75_TEMP_FROM_REG(data->reg[nr])); \
797 }
798 show_temp_reg(temp);
799 show_temp_reg(temp_max);
800 show_temp_reg(temp_max_hyst);
801
802 #define store_temp_reg(REG, reg) \
803 static ssize_t \
804 store_##reg(struct device *dev, struct device_attribute *attr, \
805 const char *buf, size_t count) \
806 { \
807 struct i2c_client *client = to_i2c_client(dev); \
808 struct w83627ehf_data *data = i2c_get_clientdata(client); \
809 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
810 int nr = sensor_attr->index; \
811 u32 val = simple_strtoul(buf, NULL, 10); \
812 \
813 mutex_lock(&data->update_lock); \
814 data->reg[nr] = LM75_TEMP_TO_REG(val); \
815 w83627ehf_write_value(client, W83627EHF_REG_TEMP_##REG[nr], \
816 data->reg[nr]); \
817 mutex_unlock(&data->update_lock); \
818 return count; \
819 }
820 store_temp_reg(OVER, temp_max);
821 store_temp_reg(HYST, temp_max_hyst);
822
823 static struct sensor_device_attribute sda_temp[] = {
824 SENSOR_ATTR(temp1_input, S_IRUGO, show_temp1, NULL, 0),
825 SENSOR_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 0),
826 SENSOR_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 1),
827 SENSOR_ATTR(temp1_max, S_IRUGO | S_IWUSR, show_temp1_max,
828 store_temp1_max, 0),
829 SENSOR_ATTR(temp2_max, S_IRUGO | S_IWUSR, show_temp_max,
830 store_temp_max, 0),
831 SENSOR_ATTR(temp3_max, S_IRUGO | S_IWUSR, show_temp_max,
832 store_temp_max, 1),
833 SENSOR_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, show_temp1_max_hyst,
834 store_temp1_max_hyst, 0),
835 SENSOR_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
836 store_temp_max_hyst, 0),
837 SENSOR_ATTR(temp3_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
838 store_temp_max_hyst, 1),
839 SENSOR_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4),
840 SENSOR_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5),
841 SENSOR_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13),
842 };
843
844 #define show_pwm_reg(reg) \
845 static ssize_t show_##reg (struct device *dev, struct device_attribute *attr, \
846 char *buf) \
847 { \
848 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
849 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
850 int nr = sensor_attr->index; \
851 return sprintf(buf, "%d\n", data->reg[nr]); \
852 }
853
854 show_pwm_reg(pwm_mode)
855 show_pwm_reg(pwm_enable)
856 show_pwm_reg(pwm)
857
858 static ssize_t
859 store_pwm_mode(struct device *dev, struct device_attribute *attr,
860 const char *buf, size_t count)
861 {
862 struct i2c_client *client = to_i2c_client(dev);
863 struct w83627ehf_data *data = i2c_get_clientdata(client);
864 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
865 int nr = sensor_attr->index;
866 u32 val = simple_strtoul(buf, NULL, 10);
867 u16 reg;
868
869 if (val > 1)
870 return -EINVAL;
871 mutex_lock(&data->update_lock);
872 reg = w83627ehf_read_value(client, W83627EHF_REG_PWM_ENABLE[nr]);
873 data->pwm_mode[nr] = val;
874 reg &= ~(1 << W83627EHF_PWM_MODE_SHIFT[nr]);
875 if (!val)
876 reg |= 1 << W83627EHF_PWM_MODE_SHIFT[nr];
877 w83627ehf_write_value(client, W83627EHF_REG_PWM_ENABLE[nr], reg);
878 mutex_unlock(&data->update_lock);
879 return count;
880 }
881
882 static ssize_t
883 store_pwm(struct device *dev, struct device_attribute *attr,
884 const char *buf, size_t count)
885 {
886 struct i2c_client *client = to_i2c_client(dev);
887 struct w83627ehf_data *data = i2c_get_clientdata(client);
888 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
889 int nr = sensor_attr->index;
890 u32 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 0, 255);
891
892 mutex_lock(&data->update_lock);
893 data->pwm[nr] = val;
894 w83627ehf_write_value(client, W83627EHF_REG_PWM[nr], val);
895 mutex_unlock(&data->update_lock);
896 return count;
897 }
898
899 static ssize_t
900 store_pwm_enable(struct device *dev, struct device_attribute *attr,
901 const char *buf, size_t count)
902 {
903 struct i2c_client *client = to_i2c_client(dev);
904 struct w83627ehf_data *data = i2c_get_clientdata(client);
905 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
906 int nr = sensor_attr->index;
907 u32 val = simple_strtoul(buf, NULL, 10);
908 u16 reg;
909
910 if (!val || (val > 2)) /* only modes 1 and 2 are supported */
911 return -EINVAL;
912 mutex_lock(&data->update_lock);
913 reg = w83627ehf_read_value(client, W83627EHF_REG_PWM_ENABLE[nr]);
914 data->pwm_enable[nr] = val;
915 reg &= ~(0x03 << W83627EHF_PWM_ENABLE_SHIFT[nr]);
916 reg |= (val - 1) << W83627EHF_PWM_ENABLE_SHIFT[nr];
917 w83627ehf_write_value(client, W83627EHF_REG_PWM_ENABLE[nr], reg);
918 mutex_unlock(&data->update_lock);
919 return count;
920 }
921
922
923 #define show_tol_temp(reg) \
924 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
925 char *buf) \
926 { \
927 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
928 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
929 int nr = sensor_attr->index; \
930 return sprintf(buf, "%d\n", temp1_from_reg(data->reg[nr])); \
931 }
932
933 show_tol_temp(tolerance)
934 show_tol_temp(target_temp)
935
936 static ssize_t
937 store_target_temp(struct device *dev, struct device_attribute *attr,
938 const char *buf, size_t count)
939 {
940 struct i2c_client *client = to_i2c_client(dev);
941 struct w83627ehf_data *data = i2c_get_clientdata(client);
942 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
943 int nr = sensor_attr->index;
944 u8 val = temp1_to_reg(simple_strtoul(buf, NULL, 10), 0, 127000);
945
946 mutex_lock(&data->update_lock);
947 data->target_temp[nr] = val;
948 w83627ehf_write_value(client, W83627EHF_REG_TARGET[nr], val);
949 mutex_unlock(&data->update_lock);
950 return count;
951 }
952
953 static ssize_t
954 store_tolerance(struct device *dev, struct device_attribute *attr,
955 const char *buf, size_t count)
956 {
957 struct i2c_client *client = to_i2c_client(dev);
958 struct w83627ehf_data *data = i2c_get_clientdata(client);
959 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
960 int nr = sensor_attr->index;
961 u16 reg;
962 /* Limit the temp to 0C - 15C */
963 u8 val = temp1_to_reg(simple_strtoul(buf, NULL, 10), 0, 15000);
964
965 mutex_lock(&data->update_lock);
966 reg = w83627ehf_read_value(client, W83627EHF_REG_TOLERANCE[nr]);
967 data->tolerance[nr] = val;
968 if (nr == 1)
969 reg = (reg & 0x0f) | (val << 4);
970 else
971 reg = (reg & 0xf0) | val;
972 w83627ehf_write_value(client, W83627EHF_REG_TOLERANCE[nr], reg);
973 mutex_unlock(&data->update_lock);
974 return count;
975 }
976
977 static struct sensor_device_attribute sda_pwm[] = {
978 SENSOR_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 0),
979 SENSOR_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 1),
980 SENSOR_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 2),
981 SENSOR_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 3),
982 };
983
984 static struct sensor_device_attribute sda_pwm_mode[] = {
985 SENSOR_ATTR(pwm1_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
986 store_pwm_mode, 0),
987 SENSOR_ATTR(pwm2_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
988 store_pwm_mode, 1),
989 SENSOR_ATTR(pwm3_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
990 store_pwm_mode, 2),
991 SENSOR_ATTR(pwm4_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
992 store_pwm_mode, 3),
993 };
994
995 static struct sensor_device_attribute sda_pwm_enable[] = {
996 SENSOR_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
997 store_pwm_enable, 0),
998 SENSOR_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
999 store_pwm_enable, 1),
1000 SENSOR_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1001 store_pwm_enable, 2),
1002 SENSOR_ATTR(pwm4_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1003 store_pwm_enable, 3),
1004 };
1005
1006 static struct sensor_device_attribute sda_target_temp[] = {
1007 SENSOR_ATTR(pwm1_target, S_IWUSR | S_IRUGO, show_target_temp,
1008 store_target_temp, 0),
1009 SENSOR_ATTR(pwm2_target, S_IWUSR | S_IRUGO, show_target_temp,
1010 store_target_temp, 1),
1011 SENSOR_ATTR(pwm3_target, S_IWUSR | S_IRUGO, show_target_temp,
1012 store_target_temp, 2),
1013 SENSOR_ATTR(pwm4_target, S_IWUSR | S_IRUGO, show_target_temp,
1014 store_target_temp, 3),
1015 };
1016
1017 static struct sensor_device_attribute sda_tolerance[] = {
1018 SENSOR_ATTR(pwm1_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1019 store_tolerance, 0),
1020 SENSOR_ATTR(pwm2_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1021 store_tolerance, 1),
1022 SENSOR_ATTR(pwm3_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1023 store_tolerance, 2),
1024 SENSOR_ATTR(pwm4_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1025 store_tolerance, 3),
1026 };
1027
1028 /* Smart Fan registers */
1029
1030 #define fan_functions(reg, REG) \
1031 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
1032 char *buf) \
1033 { \
1034 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1035 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
1036 int nr = sensor_attr->index; \
1037 return sprintf(buf, "%d\n", data->reg[nr]); \
1038 }\
1039 static ssize_t \
1040 store_##reg(struct device *dev, struct device_attribute *attr, \
1041 const char *buf, size_t count) \
1042 {\
1043 struct i2c_client *client = to_i2c_client(dev); \
1044 struct w83627ehf_data *data = i2c_get_clientdata(client); \
1045 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
1046 int nr = sensor_attr->index; \
1047 u32 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 1, 255); \
1048 mutex_lock(&data->update_lock); \
1049 data->reg[nr] = val; \
1050 w83627ehf_write_value(client, W83627EHF_REG_##REG[nr], val); \
1051 mutex_unlock(&data->update_lock); \
1052 return count; \
1053 }
1054
1055 fan_functions(fan_min_output, FAN_MIN_OUTPUT)
1056
1057 #define fan_time_functions(reg, REG) \
1058 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
1059 char *buf) \
1060 { \
1061 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1062 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
1063 int nr = sensor_attr->index; \
1064 return sprintf(buf, "%d\n", \
1065 step_time_from_reg(data->reg[nr], data->pwm_mode[nr])); \
1066 } \
1067 \
1068 static ssize_t \
1069 store_##reg(struct device *dev, struct device_attribute *attr, \
1070 const char *buf, size_t count) \
1071 { \
1072 struct i2c_client *client = to_i2c_client(dev); \
1073 struct w83627ehf_data *data = i2c_get_clientdata(client); \
1074 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
1075 int nr = sensor_attr->index; \
1076 u8 val = step_time_to_reg(simple_strtoul(buf, NULL, 10), \
1077 data->pwm_mode[nr]); \
1078 mutex_lock(&data->update_lock); \
1079 data->reg[nr] = val; \
1080 w83627ehf_write_value(client, W83627EHF_REG_##REG[nr], val); \
1081 mutex_unlock(&data->update_lock); \
1082 return count; \
1083 } \
1084
1085 fan_time_functions(fan_stop_time, FAN_STOP_TIME)
1086
1087
1088 static struct sensor_device_attribute sda_sf3_arrays_fan4[] = {
1089 SENSOR_ATTR(pwm4_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1090 store_fan_stop_time, 3),
1091 SENSOR_ATTR(pwm4_min_output, S_IWUSR | S_IRUGO, show_fan_min_output,
1092 store_fan_min_output, 3),
1093 };
1094
1095 static struct sensor_device_attribute sda_sf3_arrays[] = {
1096 SENSOR_ATTR(pwm1_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1097 store_fan_stop_time, 0),
1098 SENSOR_ATTR(pwm2_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1099 store_fan_stop_time, 1),
1100 SENSOR_ATTR(pwm3_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1101 store_fan_stop_time, 2),
1102 SENSOR_ATTR(pwm1_min_output, S_IWUSR | S_IRUGO, show_fan_min_output,
1103 store_fan_min_output, 0),
1104 SENSOR_ATTR(pwm2_min_output, S_IWUSR | S_IRUGO, show_fan_min_output,
1105 store_fan_min_output, 1),
1106 SENSOR_ATTR(pwm3_min_output, S_IWUSR | S_IRUGO, show_fan_min_output,
1107 store_fan_min_output, 2),
1108 };
1109
1110 /*
1111 * Driver and client management
1112 */
1113
1114 static void w83627ehf_device_remove_files(struct device *dev)
1115 {
1116 /* some entries in the following arrays may not have been used in
1117 * device_create_file(), but device_remove_file() will ignore them */
1118 int i;
1119
1120 for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++)
1121 device_remove_file(dev, &sda_sf3_arrays[i].dev_attr);
1122 for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++)
1123 device_remove_file(dev, &sda_sf3_arrays_fan4[i].dev_attr);
1124 for (i = 0; i < 10; i++) {
1125 device_remove_file(dev, &sda_in_input[i].dev_attr);
1126 device_remove_file(dev, &sda_in_alarm[i].dev_attr);
1127 device_remove_file(dev, &sda_in_min[i].dev_attr);
1128 device_remove_file(dev, &sda_in_max[i].dev_attr);
1129 }
1130 for (i = 0; i < 5; i++) {
1131 device_remove_file(dev, &sda_fan_input[i].dev_attr);
1132 device_remove_file(dev, &sda_fan_alarm[i].dev_attr);
1133 device_remove_file(dev, &sda_fan_div[i].dev_attr);
1134 device_remove_file(dev, &sda_fan_min[i].dev_attr);
1135 }
1136 for (i = 0; i < 4; i++) {
1137 device_remove_file(dev, &sda_pwm[i].dev_attr);
1138 device_remove_file(dev, &sda_pwm_mode[i].dev_attr);
1139 device_remove_file(dev, &sda_pwm_enable[i].dev_attr);
1140 device_remove_file(dev, &sda_target_temp[i].dev_attr);
1141 device_remove_file(dev, &sda_tolerance[i].dev_attr);
1142 }
1143 for (i = 0; i < ARRAY_SIZE(sda_temp); i++)
1144 device_remove_file(dev, &sda_temp[i].dev_attr);
1145 }
1146
1147 static struct i2c_driver w83627ehf_driver;
1148
1149 static void w83627ehf_init_client(struct i2c_client *client)
1150 {
1151 int i;
1152 u8 tmp;
1153
1154 /* Start monitoring is needed */
1155 tmp = w83627ehf_read_value(client, W83627EHF_REG_CONFIG);
1156 if (!(tmp & 0x01))
1157 w83627ehf_write_value(client, W83627EHF_REG_CONFIG,
1158 tmp | 0x01);
1159
1160 /* Enable temp2 and temp3 if needed */
1161 for (i = 0; i < 2; i++) {
1162 tmp = w83627ehf_read_value(client,
1163 W83627EHF_REG_TEMP_CONFIG[i]);
1164 if (tmp & 0x01)
1165 w83627ehf_write_value(client,
1166 W83627EHF_REG_TEMP_CONFIG[i],
1167 tmp & 0xfe);
1168 }
1169 }
1170
1171 static int w83627ehf_detect(struct i2c_adapter *adapter)
1172 {
1173 struct i2c_client *client;
1174 struct w83627ehf_data *data;
1175 struct device *dev;
1176 u8 fan4pin, fan5pin;
1177 int i, err = 0;
1178
1179 if (!request_region(address + REGION_OFFSET, REGION_LENGTH,
1180 w83627ehf_driver.driver.name)) {
1181 err = -EBUSY;
1182 goto exit;
1183 }
1184
1185 if (!(data = kzalloc(sizeof(struct w83627ehf_data), GFP_KERNEL))) {
1186 err = -ENOMEM;
1187 goto exit_release;
1188 }
1189
1190 client = &data->client;
1191 i2c_set_clientdata(client, data);
1192 client->addr = address;
1193 mutex_init(&data->lock);
1194 client->adapter = adapter;
1195 client->driver = &w83627ehf_driver;
1196 client->flags = 0;
1197 dev = &client->dev;
1198
1199 strlcpy(client->name, "w83627ehf", I2C_NAME_SIZE);
1200 data->valid = 0;
1201 mutex_init(&data->update_lock);
1202
1203 /* Tell the i2c layer a new client has arrived */
1204 if ((err = i2c_attach_client(client)))
1205 goto exit_free;
1206
1207 /* Initialize the chip */
1208 w83627ehf_init_client(client);
1209
1210 /* A few vars need to be filled upon startup */
1211 for (i = 0; i < 5; i++)
1212 data->fan_min[i] = w83627ehf_read_value(client,
1213 W83627EHF_REG_FAN_MIN[i]);
1214
1215 /* fan4 and fan5 share some pins with the GPIO and serial flash */
1216
1217 superio_enter();
1218 fan5pin = superio_inb(0x24) & 0x2;
1219 fan4pin = superio_inb(0x29) & 0x6;
1220 superio_exit();
1221
1222 /* It looks like fan4 and fan5 pins can be alternatively used
1223 as fan on/off switches, but fan5 control is write only :/
1224 We assume that if the serial interface is disabled, designers
1225 connected fan5 as input unless they are emitting log 1, which
1226 is not the default. */
1227
1228 data->has_fan = 0x07; /* fan1, fan2 and fan3 */
1229 i = w83627ehf_read_value(client, W83627EHF_REG_FANDIV1);
1230 if ((i & (1 << 2)) && (!fan4pin))
1231 data->has_fan |= (1 << 3);
1232 if (!(i & (1 << 1)) && (!fan5pin))
1233 data->has_fan |= (1 << 4);
1234
1235 /* Register sysfs hooks */
1236 for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++)
1237 if ((err = device_create_file(dev,
1238 &sda_sf3_arrays[i].dev_attr)))
1239 goto exit_remove;
1240
1241 /* if fan4 is enabled create the sf3 files for it */
1242 if (data->has_fan & (1 << 3))
1243 for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++) {
1244 if ((err = device_create_file(dev,
1245 &sda_sf3_arrays_fan4[i].dev_attr)))
1246 goto exit_remove;
1247 }
1248
1249 for (i = 0; i < 10; i++)
1250 if ((err = device_create_file(dev, &sda_in_input[i].dev_attr))
1251 || (err = device_create_file(dev,
1252 &sda_in_alarm[i].dev_attr))
1253 || (err = device_create_file(dev,
1254 &sda_in_min[i].dev_attr))
1255 || (err = device_create_file(dev,
1256 &sda_in_max[i].dev_attr)))
1257 goto exit_remove;
1258
1259 for (i = 0; i < 5; i++) {
1260 if (data->has_fan & (1 << i)) {
1261 if ((err = device_create_file(dev,
1262 &sda_fan_input[i].dev_attr))
1263 || (err = device_create_file(dev,
1264 &sda_fan_alarm[i].dev_attr))
1265 || (err = device_create_file(dev,
1266 &sda_fan_div[i].dev_attr))
1267 || (err = device_create_file(dev,
1268 &sda_fan_min[i].dev_attr)))
1269 goto exit_remove;
1270 if (i < 4 && /* w83627ehf only has 4 pwm */
1271 ((err = device_create_file(dev,
1272 &sda_pwm[i].dev_attr))
1273 || (err = device_create_file(dev,
1274 &sda_pwm_mode[i].dev_attr))
1275 || (err = device_create_file(dev,
1276 &sda_pwm_enable[i].dev_attr))
1277 || (err = device_create_file(dev,
1278 &sda_target_temp[i].dev_attr))
1279 || (err = device_create_file(dev,
1280 &sda_tolerance[i].dev_attr))))
1281 goto exit_remove;
1282 }
1283 }
1284
1285 for (i = 0; i < ARRAY_SIZE(sda_temp); i++)
1286 if ((err = device_create_file(dev, &sda_temp[i].dev_attr)))
1287 goto exit_remove;
1288
1289 data->class_dev = hwmon_device_register(dev);
1290 if (IS_ERR(data->class_dev)) {
1291 err = PTR_ERR(data->class_dev);
1292 goto exit_remove;
1293 }
1294
1295 return 0;
1296
1297 exit_remove:
1298 w83627ehf_device_remove_files(dev);
1299 i2c_detach_client(client);
1300 exit_free:
1301 kfree(data);
1302 exit_release:
1303 release_region(address + REGION_OFFSET, REGION_LENGTH);
1304 exit:
1305 return err;
1306 }
1307
1308 static int w83627ehf_detach_client(struct i2c_client *client)
1309 {
1310 struct w83627ehf_data *data = i2c_get_clientdata(client);
1311 int err;
1312
1313 hwmon_device_unregister(data->class_dev);
1314 w83627ehf_device_remove_files(&client->dev);
1315
1316 if ((err = i2c_detach_client(client)))
1317 return err;
1318 release_region(client->addr + REGION_OFFSET, REGION_LENGTH);
1319 kfree(data);
1320
1321 return 0;
1322 }
1323
1324 static struct i2c_driver w83627ehf_driver = {
1325 .driver = {
1326 .owner = THIS_MODULE,
1327 .name = "w83627ehf",
1328 },
1329 .attach_adapter = w83627ehf_detect,
1330 .detach_client = w83627ehf_detach_client,
1331 };
1332
1333 static int __init w83627ehf_find(int sioaddr, unsigned short *addr)
1334 {
1335 u16 val;
1336
1337 REG = sioaddr;
1338 VAL = sioaddr + 1;
1339 superio_enter();
1340
1341 val = (superio_inb(SIO_REG_DEVID) << 8)
1342 | superio_inb(SIO_REG_DEVID + 1);
1343 if ((val & SIO_ID_MASK) != SIO_W83627EHF_ID) {
1344 superio_exit();
1345 return -ENODEV;
1346 }
1347
1348 superio_select(W83627EHF_LD_HWM);
1349 val = (superio_inb(SIO_REG_ADDR) << 8)
1350 | superio_inb(SIO_REG_ADDR + 1);
1351 *addr = val & REGION_ALIGNMENT;
1352 if (*addr == 0) {
1353 superio_exit();
1354 return -ENODEV;
1355 }
1356
1357 /* Activate logical device if needed */
1358 val = superio_inb(SIO_REG_ENABLE);
1359 if (!(val & 0x01))
1360 superio_outb(SIO_REG_ENABLE, val | 0x01);
1361
1362 superio_exit();
1363 return 0;
1364 }
1365
1366 static int __init sensors_w83627ehf_init(void)
1367 {
1368 if (w83627ehf_find(0x2e, &address)
1369 && w83627ehf_find(0x4e, &address))
1370 return -ENODEV;
1371
1372 return i2c_isa_add_driver(&w83627ehf_driver);
1373 }
1374
1375 static void __exit sensors_w83627ehf_exit(void)
1376 {
1377 i2c_isa_del_driver(&w83627ehf_driver);
1378 }
1379
1380 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
1381 MODULE_DESCRIPTION("W83627EHF driver");
1382 MODULE_LICENSE("GPL");
1383
1384 module_init(sensors_w83627ehf_init);
1385 module_exit(sensors_w83627ehf_exit);
Linux kernel - Deliverables
This page took 0.061527 seconds and 6 git commands to generate.