?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix Tomato RAF theme for all builds. Compilation typo.
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / drivers / hwmon / pc87427.c
blob9ec4daaf6ca6313ee58744f7ffb9eaf5146cce78
1 /*
2 * pc87427.c - hardware monitoring driver for the
3 * National Semiconductor PC87427 Super-I/O chip
4 * Copyright (C) 2006, 2008, 2010 Jean Delvare <khali@linux-fr.org>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * Supports the following chips:
16 *
17 * Chip #vin #fan #pwm #temp devid
18 * PC87427 - 8 4 6 0xF2
19 *
20 * This driver assumes that no more than one chip is present.
21 * Only fans are fully supported so far. Temperatures are in read-only
22 * mode, and voltages aren't supported at all.
23 */
24
25 #include <linux/module.h>
26 #include <linux/init.h>
27 #include <linux/slab.h>
28 #include <linux/jiffies.h>
29 #include <linux/platform_device.h>
30 #include <linux/hwmon.h>
31 #include <linux/hwmon-sysfs.h>
32 #include <linux/err.h>
33 #include <linux/mutex.h>
34 #include <linux/sysfs.h>
35 #include <linux/ioport.h>
36 #include <linux/acpi.h>
37 #include <linux/io.h>
38
39 static unsigned short force_id;
40 module_param(force_id, ushort, 0);
41 MODULE_PARM_DESC(force_id, "Override the detected device ID");
42
43 static struct platform_device *pdev;
44
45 #define DRVNAME "pc87427"
46
47 /* The lock mutex protects both the I/O accesses (needed because the
48 device is using banked registers) and the register cache (needed to keep
49 the data in the registers and the cache in sync at any time). */
50 struct pc87427_data {
51 struct device *hwmon_dev;
52 struct mutex lock;
53 int address[2];
54 const char *name;
55
56 unsigned long last_updated; /* in jiffies */
57 u8 fan_enabled; /* bit vector */
58 u16 fan[8]; /* register values */
59 u16 fan_min[8]; /* register values */
60 u8 fan_status[8]; /* register values */
61
62 u8 pwm_enabled; /* bit vector */
63 u8 pwm_auto_ok; /* bit vector */
64 u8 pwm_enable[4]; /* register values */
65 u8 pwm[4]; /* register values */
66
67 u8 temp_enabled; /* bit vector */
68 s16 temp[6]; /* register values */
69 s8 temp_min[6]; /* register values */
70 s8 temp_max[6]; /* register values */
71 s8 temp_crit[6]; /* register values */
72 u8 temp_status[6]; /* register values */
73 u8 temp_type[6]; /* register values */
74 };
75
76 struct pc87427_sio_data {
77 unsigned short address[2];
78 u8 has_fanin;
79 u8 has_fanout;
80 };
81
82 /*
83 * Super-I/O registers and operations
84 */
85
86 #define SIOREG_LDSEL 0x07 /* Logical device select */
87 #define SIOREG_DEVID 0x20 /* Device ID */
88 #define SIOREG_CF2 0x22 /* Configuration 2 */
89 #define SIOREG_CF3 0x23 /* Configuration 3 */
90 #define SIOREG_CF4 0x24 /* Configuration 4 */
91 #define SIOREG_CF5 0x25 /* Configuration 5 */
92 #define SIOREG_CFB 0x2B /* Configuration B */
93 #define SIOREG_CFC 0x2C /* Configuration C */
94 #define SIOREG_CFD 0x2D /* Configuration D */
95 #define SIOREG_ACT 0x30 /* Device activation */
96 #define SIOREG_MAP 0x50 /* I/O or memory mapping */
97 #define SIOREG_IOBASE 0x60 /* I/O base address */
98
99 static const u8 logdev[2] = { 0x09, 0x14 };
100 static const char *logdev_str[2] = { DRVNAME " FMC", DRVNAME " HMC" };
101 #define LD_FAN 0
102 #define LD_IN 1
103 #define LD_TEMP 1
104
105 static inline void superio_outb(int sioaddr, int reg, int val)
106 {
107 outb(reg, sioaddr);
108 outb(val, sioaddr + 1);
109 }
110
111 static inline int superio_inb(int sioaddr, int reg)
112 {
113 outb(reg, sioaddr);
114 return inb(sioaddr + 1);
115 }
116
117 static inline void superio_exit(int sioaddr)
118 {
119 outb(0x02, sioaddr);
120 outb(0x02, sioaddr + 1);
121 }
122
123 /*
124 * Logical devices
125 */
126
127 #define REGION_LENGTH 32
128 #define PC87427_REG_BANK 0x0f
129 #define BANK_FM(nr) (nr)
130 #define BANK_FT(nr) (0x08 + (nr))
131 #define BANK_FC(nr) (0x10 + (nr) * 2)
132 #define BANK_TM(nr) (nr)
133 #define BANK_VM(nr) (0x08 + (nr))
134
135 /*
136 * I/O access functions
137 */
138
139 /* ldi is the logical device index */
140 static inline int pc87427_read8(struct pc87427_data *data, u8 ldi, u8 reg)
141 {
142 return inb(data->address[ldi] + reg);
143 }
144
145 /* Must be called with data->lock held, except during init */
146 static inline int pc87427_read8_bank(struct pc87427_data *data, u8 ldi,
147 u8 bank, u8 reg)
148 {
149 outb(bank, data->address[ldi] + PC87427_REG_BANK);
150 return inb(data->address[ldi] + reg);
151 }
152
153 /* Must be called with data->lock held, except during init */
154 static inline void pc87427_write8_bank(struct pc87427_data *data, u8 ldi,
155 u8 bank, u8 reg, u8 value)
156 {
157 outb(bank, data->address[ldi] + PC87427_REG_BANK);
158 outb(value, data->address[ldi] + reg);
159 }
160
161 /*
162 * Fan registers and conversions
163 */
164
165 /* fan data registers are 16-bit wide */
166 #define PC87427_REG_FAN 0x12
167 #define PC87427_REG_FAN_MIN 0x14
168 #define PC87427_REG_FAN_STATUS 0x10
169
170 #define FAN_STATUS_STALL (1 << 3)
171 #define FAN_STATUS_LOSPD (1 << 1)
172 #define FAN_STATUS_MONEN (1 << 0)
173
174 /* Dedicated function to read all registers related to a given fan input.
175 This saves us quite a few locks and bank selections.
176 Must be called with data->lock held.
177 nr is from 0 to 7 */
178 static void pc87427_readall_fan(struct pc87427_data *data, u8 nr)
179 {
180 int iobase = data->address[LD_FAN];
181
182 outb(BANK_FM(nr), iobase + PC87427_REG_BANK);
183 data->fan[nr] = inw(iobase + PC87427_REG_FAN);
184 data->fan_min[nr] = inw(iobase + PC87427_REG_FAN_MIN);
185 data->fan_status[nr] = inb(iobase + PC87427_REG_FAN_STATUS);
186 /* Clear fan alarm bits */
187 outb(data->fan_status[nr], iobase + PC87427_REG_FAN_STATUS);
188 }
189
190 /* The 2 LSB of fan speed registers are used for something different.
191 The actual 2 LSB of the measurements are not available. */
192 static inline unsigned long fan_from_reg(u16 reg)
193 {
194 reg &= 0xfffc;
195 if (reg == 0x0000 || reg == 0xfffc)
196 return 0;
197 return 5400000UL / reg;
198 }
199
200 /* The 2 LSB of the fan speed limit registers are not significant. */
201 static inline u16 fan_to_reg(unsigned long val)
202 {
203 if (val < 83UL)
204 return 0xffff;
205 if (val >= 1350000UL)
206 return 0x0004;
207 return ((1350000UL + val / 2) / val) << 2;
208 }
209
210 /*
211 * PWM registers and conversions
212 */
213
214 #define PC87427_REG_PWM_ENABLE 0x10
215 #define PC87427_REG_PWM_DUTY 0x12
216
217 #define PWM_ENABLE_MODE_MASK (7 << 4)
218 #define PWM_ENABLE_CTLEN (1 << 0)
219
220 #define PWM_MODE_MANUAL (0 << 4)
221 #define PWM_MODE_AUTO (1 << 4)
222 #define PWM_MODE_OFF (2 << 4)
223 #define PWM_MODE_ON (7 << 4)
224
225 /* Dedicated function to read all registers related to a given PWM output.
226 This saves us quite a few locks and bank selections.
227 Must be called with data->lock held.
228 nr is from 0 to 3 */
229 static void pc87427_readall_pwm(struct pc87427_data *data, u8 nr)
230 {
231 int iobase = data->address[LD_FAN];
232
233 outb(BANK_FC(nr), iobase + PC87427_REG_BANK);
234 data->pwm_enable[nr] = inb(iobase + PC87427_REG_PWM_ENABLE);
235 data->pwm[nr] = inb(iobase + PC87427_REG_PWM_DUTY);
236 }
237
238 static inline int pwm_enable_from_reg(u8 reg)
239 {
240 switch (reg & PWM_ENABLE_MODE_MASK) {
241 case PWM_MODE_ON:
242 return 0;
243 case PWM_MODE_MANUAL:
244 case PWM_MODE_OFF:
245 return 1;
246 case PWM_MODE_AUTO:
247 return 2;
248 default:
249 return -EPROTO;
250 }
251 }
252
253 static inline u8 pwm_enable_to_reg(unsigned long val, u8 pwmval)
254 {
255 switch (val) {
256 default:
257 return PWM_MODE_ON;
258 case 1:
259 return pwmval ? PWM_MODE_MANUAL : PWM_MODE_OFF;
260 case 2:
261 return PWM_MODE_AUTO;
262 }
263 }
264
265 /*
266 * Temperature registers and conversions
267 */
268
269 #define PC87427_REG_TEMP_STATUS 0x10
270 #define PC87427_REG_TEMP 0x14
271 #define PC87427_REG_TEMP_MAX 0x18
272 #define PC87427_REG_TEMP_MIN 0x19
273 #define PC87427_REG_TEMP_CRIT 0x1a
274 #define PC87427_REG_TEMP_TYPE 0x1d
275
276 #define TEMP_STATUS_CHANEN (1 << 0)
277 #define TEMP_STATUS_LOWFLG (1 << 1)
278 #define TEMP_STATUS_HIGHFLG (1 << 2)
279 #define TEMP_STATUS_CRITFLG (1 << 3)
280 #define TEMP_STATUS_SENSERR (1 << 5)
281 #define TEMP_TYPE_MASK (3 << 5)
282
283 #define TEMP_TYPE_THERMISTOR (1 << 5)
284 #define TEMP_TYPE_REMOTE_DIODE (2 << 5)
285 #define TEMP_TYPE_LOCAL_DIODE (3 << 5)
286
287 /* Dedicated function to read all registers related to a given temperature
288 input. This saves us quite a few locks and bank selections.
289 Must be called with data->lock held.
290 nr is from 0 to 5 */
291 static void pc87427_readall_temp(struct pc87427_data *data, u8 nr)
292 {
293 int iobase = data->address[LD_TEMP];
294
295 outb(BANK_TM(nr), iobase + PC87427_REG_BANK);
296 data->temp[nr] = le16_to_cpu(inw(iobase + PC87427_REG_TEMP));
297 data->temp_max[nr] = inb(iobase + PC87427_REG_TEMP_MAX);
298 data->temp_min[nr] = inb(iobase + PC87427_REG_TEMP_MIN);
299 data->temp_crit[nr] = inb(iobase + PC87427_REG_TEMP_CRIT);
300 data->temp_type[nr] = inb(iobase + PC87427_REG_TEMP_TYPE);
301 data->temp_status[nr] = inb(iobase + PC87427_REG_TEMP_STATUS);
302 /* Clear fan alarm bits */
303 outb(data->temp_status[nr], iobase + PC87427_REG_TEMP_STATUS);
304 }
305
306 static inline unsigned int temp_type_from_reg(u8 reg)
307 {
308 switch (reg & TEMP_TYPE_MASK) {
309 case TEMP_TYPE_THERMISTOR:
310 return 4;
311 case TEMP_TYPE_REMOTE_DIODE:
312 case TEMP_TYPE_LOCAL_DIODE:
313 return 3;
314 default:
315 return 0;
316 }
317 }
318
319 /* We assume 8-bit thermal sensors; 9-bit thermal sensors are possible
320 too, but I have no idea how to figure out when they are used. */
321 static inline long temp_from_reg(s16 reg)
322 {
323 return reg * 1000 / 256;
324 }
325
326 static inline long temp_from_reg8(s8 reg)
327 {
328 return reg * 1000;
329 }
330
331 /*
332 * Data interface
333 */
334
335 static struct pc87427_data *pc87427_update_device(struct device *dev)
336 {
337 struct pc87427_data *data = dev_get_drvdata(dev);
338 int i;
339
340 mutex_lock(&data->lock);
341 if (!time_after(jiffies, data->last_updated + HZ)
342 && data->last_updated)
343 goto done;
344
345 /* Fans */
346 for (i = 0; i < 8; i++) {
347 if (!(data->fan_enabled & (1 << i)))
348 continue;
349 pc87427_readall_fan(data, i);
350 }
351
352 /* PWM outputs */
353 for (i = 0; i < 4; i++) {
354 if (!(data->pwm_enabled & (1 << i)))
355 continue;
356 pc87427_readall_pwm(data, i);
357 }
358
359 /* Temperature channels */
360 for (i = 0; i < 6; i++) {
361 if (!(data->temp_enabled & (1 << i)))
362 continue;
363 pc87427_readall_temp(data, i);
364 }
365
366 data->last_updated = jiffies;
367
368 done:
369 mutex_unlock(&data->lock);
370 return data;
371 }
372
373 static ssize_t show_fan_input(struct device *dev, struct device_attribute
374 *devattr, char *buf)
375 {
376 struct pc87427_data *data = pc87427_update_device(dev);
377 int nr = to_sensor_dev_attr(devattr)->index;
378
379 return sprintf(buf, "%lu\n", fan_from_reg(data->fan[nr]));
380 }
381
382 static ssize_t show_fan_min(struct device *dev, struct device_attribute
383 *devattr, char *buf)
384 {
385 struct pc87427_data *data = pc87427_update_device(dev);
386 int nr = to_sensor_dev_attr(devattr)->index;
387
388 return sprintf(buf, "%lu\n", fan_from_reg(data->fan_min[nr]));
389 }
390
391 static ssize_t show_fan_alarm(struct device *dev, struct device_attribute
392 *devattr, char *buf)
393 {
394 struct pc87427_data *data = pc87427_update_device(dev);
395 int nr = to_sensor_dev_attr(devattr)->index;
396
397 return sprintf(buf, "%d\n", !!(data->fan_status[nr]
398 & FAN_STATUS_LOSPD));
399 }
400
401 static ssize_t show_fan_fault(struct device *dev, struct device_attribute
402 *devattr, char *buf)
403 {
404 struct pc87427_data *data = pc87427_update_device(dev);
405 int nr = to_sensor_dev_attr(devattr)->index;
406
407 return sprintf(buf, "%d\n", !!(data->fan_status[nr]
408 & FAN_STATUS_STALL));
409 }
410
411 static ssize_t set_fan_min(struct device *dev, struct device_attribute
412 *devattr, const char *buf, size_t count)
413 {
414 struct pc87427_data *data = dev_get_drvdata(dev);
415 int nr = to_sensor_dev_attr(devattr)->index;
416 unsigned long val;
417 int iobase = data->address[LD_FAN];
418
419 if (strict_strtoul(buf, 10, &val) < 0)
420 return -EINVAL;
421
422 mutex_lock(&data->lock);
423 outb(BANK_FM(nr), iobase + PC87427_REG_BANK);
424 /* The low speed limit registers are read-only while monitoring
425 is enabled, so we have to disable monitoring, then change the
426 limit, and finally enable monitoring again. */
427 outb(0, iobase + PC87427_REG_FAN_STATUS);
428 data->fan_min[nr] = fan_to_reg(val);
429 outw(data->fan_min[nr], iobase + PC87427_REG_FAN_MIN);
430 outb(FAN_STATUS_MONEN, iobase + PC87427_REG_FAN_STATUS);
431 mutex_unlock(&data->lock);
432
433 return count;
434 }
435
436 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan_input, NULL, 0);
437 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan_input, NULL, 1);
438 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan_input, NULL, 2);
439 static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan_input, NULL, 3);
440 static SENSOR_DEVICE_ATTR(fan5_input, S_IRUGO, show_fan_input, NULL, 4);
441 static SENSOR_DEVICE_ATTR(fan6_input, S_IRUGO, show_fan_input, NULL, 5);
442 static SENSOR_DEVICE_ATTR(fan7_input, S_IRUGO, show_fan_input, NULL, 6);
443 static SENSOR_DEVICE_ATTR(fan8_input, S_IRUGO, show_fan_input, NULL, 7);
444
445 static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO,
446 show_fan_min, set_fan_min, 0);
447 static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO,
448 show_fan_min, set_fan_min, 1);
449 static SENSOR_DEVICE_ATTR(fan3_min, S_IWUSR | S_IRUGO,
450 show_fan_min, set_fan_min, 2);
451 static SENSOR_DEVICE_ATTR(fan4_min, S_IWUSR | S_IRUGO,
452 show_fan_min, set_fan_min, 3);
453 static SENSOR_DEVICE_ATTR(fan5_min, S_IWUSR | S_IRUGO,
454 show_fan_min, set_fan_min, 4);
455 static SENSOR_DEVICE_ATTR(fan6_min, S_IWUSR | S_IRUGO,
456 show_fan_min, set_fan_min, 5);
457 static SENSOR_DEVICE_ATTR(fan7_min, S_IWUSR | S_IRUGO,
458 show_fan_min, set_fan_min, 6);
459 static SENSOR_DEVICE_ATTR(fan8_min, S_IWUSR | S_IRUGO,
460 show_fan_min, set_fan_min, 7);
461
462 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_fan_alarm, NULL, 0);
463 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_fan_alarm, NULL, 1);
464 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_fan_alarm, NULL, 2);
465 static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_fan_alarm, NULL, 3);
466 static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO, show_fan_alarm, NULL, 4);
467 static SENSOR_DEVICE_ATTR(fan6_alarm, S_IRUGO, show_fan_alarm, NULL, 5);
468 static SENSOR_DEVICE_ATTR(fan7_alarm, S_IRUGO, show_fan_alarm, NULL, 6);
469 static SENSOR_DEVICE_ATTR(fan8_alarm, S_IRUGO, show_fan_alarm, NULL, 7);
470
471 static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, show_fan_fault, NULL, 0);
472 static SENSOR_DEVICE_ATTR(fan2_fault, S_IRUGO, show_fan_fault, NULL, 1);
473 static SENSOR_DEVICE_ATTR(fan3_fault, S_IRUGO, show_fan_fault, NULL, 2);
474 static SENSOR_DEVICE_ATTR(fan4_fault, S_IRUGO, show_fan_fault, NULL, 3);
475 static SENSOR_DEVICE_ATTR(fan5_fault, S_IRUGO, show_fan_fault, NULL, 4);
476 static SENSOR_DEVICE_ATTR(fan6_fault, S_IRUGO, show_fan_fault, NULL, 5);
477 static SENSOR_DEVICE_ATTR(fan7_fault, S_IRUGO, show_fan_fault, NULL, 6);
478 static SENSOR_DEVICE_ATTR(fan8_fault, S_IRUGO, show_fan_fault, NULL, 7);
479
480 static struct attribute *pc87427_attributes_fan[8][5] = {
481 {
482 &sensor_dev_attr_fan1_input.dev_attr.attr,
483 &sensor_dev_attr_fan1_min.dev_attr.attr,
484 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
485 &sensor_dev_attr_fan1_fault.dev_attr.attr,
486 NULL
487 }, {
488 &sensor_dev_attr_fan2_input.dev_attr.attr,
489 &sensor_dev_attr_fan2_min.dev_attr.attr,
490 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
491 &sensor_dev_attr_fan2_fault.dev_attr.attr,
492 NULL
493 }, {
494 &sensor_dev_attr_fan3_input.dev_attr.attr,
495 &sensor_dev_attr_fan3_min.dev_attr.attr,
496 &sensor_dev_attr_fan3_alarm.dev_attr.attr,
497 &sensor_dev_attr_fan3_fault.dev_attr.attr,
498 NULL
499 }, {
500 &sensor_dev_attr_fan4_input.dev_attr.attr,
501 &sensor_dev_attr_fan4_min.dev_attr.attr,
502 &sensor_dev_attr_fan4_alarm.dev_attr.attr,
503 &sensor_dev_attr_fan4_fault.dev_attr.attr,
504 NULL
505 }, {
506 &sensor_dev_attr_fan5_input.dev_attr.attr,
507 &sensor_dev_attr_fan5_min.dev_attr.attr,
508 &sensor_dev_attr_fan5_alarm.dev_attr.attr,
509 &sensor_dev_attr_fan5_fault.dev_attr.attr,
510 NULL
511 }, {
512 &sensor_dev_attr_fan6_input.dev_attr.attr,
513 &sensor_dev_attr_fan6_min.dev_attr.attr,
514 &sensor_dev_attr_fan6_alarm.dev_attr.attr,
515 &sensor_dev_attr_fan6_fault.dev_attr.attr,
516 NULL
517 }, {
518 &sensor_dev_attr_fan7_input.dev_attr.attr,
519 &sensor_dev_attr_fan7_min.dev_attr.attr,
520 &sensor_dev_attr_fan7_alarm.dev_attr.attr,
521 &sensor_dev_attr_fan7_fault.dev_attr.attr,
522 NULL
523 }, {
524 &sensor_dev_attr_fan8_input.dev_attr.attr,
525 &sensor_dev_attr_fan8_min.dev_attr.attr,
526 &sensor_dev_attr_fan8_alarm.dev_attr.attr,
527 &sensor_dev_attr_fan8_fault.dev_attr.attr,
528 NULL
529 }
530 };
531
532 static const struct attribute_group pc87427_group_fan[8] = {
533 { .attrs = pc87427_attributes_fan[0] },
534 { .attrs = pc87427_attributes_fan[1] },
535 { .attrs = pc87427_attributes_fan[2] },
536 { .attrs = pc87427_attributes_fan[3] },
537 { .attrs = pc87427_attributes_fan[4] },
538 { .attrs = pc87427_attributes_fan[5] },
539 { .attrs = pc87427_attributes_fan[6] },
540 { .attrs = pc87427_attributes_fan[7] },
541 };
542
543 /* Must be called with data->lock held and pc87427_readall_pwm() freshly
544 called */
545 static void update_pwm_enable(struct pc87427_data *data, int nr, u8 mode)
546 {
547 int iobase = data->address[LD_FAN];
548 data->pwm_enable[nr] &= ~PWM_ENABLE_MODE_MASK;
549 data->pwm_enable[nr] |= mode;
550 outb(data->pwm_enable[nr], iobase + PC87427_REG_PWM_ENABLE);
551 }
552
553 static ssize_t show_pwm_enable(struct device *dev, struct device_attribute
554 *devattr, char *buf)
555 {
556 struct pc87427_data *data = pc87427_update_device(dev);
557 int nr = to_sensor_dev_attr(devattr)->index;
558 int pwm_enable;
559
560 pwm_enable = pwm_enable_from_reg(data->pwm_enable[nr]);
561 if (pwm_enable < 0)
562 return pwm_enable;
563 return sprintf(buf, "%d\n", pwm_enable);
564 }
565
566 static ssize_t set_pwm_enable(struct device *dev, struct device_attribute
567 *devattr, const char *buf, size_t count)
568 {
569 struct pc87427_data *data = dev_get_drvdata(dev);
570 int nr = to_sensor_dev_attr(devattr)->index;
571 unsigned long val;
572
573 if (strict_strtoul(buf, 10, &val) < 0 || val > 2)
574 return -EINVAL;
575 /* Can't go to automatic mode if it isn't configured */
576 if (val == 2 && !(data->pwm_auto_ok & (1 << nr)))
577 return -EINVAL;
578
579 mutex_lock(&data->lock);
580 pc87427_readall_pwm(data, nr);
581 update_pwm_enable(data, nr, pwm_enable_to_reg(val, data->pwm[nr]));
582 mutex_unlock(&data->lock);
583
584 return count;
585 }
586
587 static ssize_t show_pwm(struct device *dev, struct device_attribute
588 *devattr, char *buf)
589 {
590 struct pc87427_data *data = pc87427_update_device(dev);
591 int nr = to_sensor_dev_attr(devattr)->index;
592
593 return sprintf(buf, "%d\n", (int)data->pwm[nr]);
594 }
595
596 static ssize_t set_pwm(struct device *dev, struct device_attribute
597 *devattr, const char *buf, size_t count)
598 {
599 struct pc87427_data *data = dev_get_drvdata(dev);
600 int nr = to_sensor_dev_attr(devattr)->index;
601 unsigned long val;
602 int iobase = data->address[LD_FAN];
603 u8 mode;
604
605 if (strict_strtoul(buf, 10, &val) < 0 || val > 0xff)
606 return -EINVAL;
607
608 mutex_lock(&data->lock);
609 pc87427_readall_pwm(data, nr);
610 mode = data->pwm_enable[nr] & PWM_ENABLE_MODE_MASK;
611 if (mode != PWM_MODE_MANUAL && mode != PWM_MODE_OFF) {
612 dev_notice(dev, "Can't set PWM%d duty cycle while not in "
613 "manual mode\n", nr + 1);
614 mutex_unlock(&data->lock);
615 return -EPERM;
616 }
617
618 /* We may have to change the mode */
619 if (mode == PWM_MODE_MANUAL && val == 0) {
620 /* Transition from Manual to Off */
621 update_pwm_enable(data, nr, PWM_MODE_OFF);
622 mode = PWM_MODE_OFF;
623 dev_dbg(dev, "Switching PWM%d from %s to %s\n", nr + 1,
624 "manual", "off");
625 } else if (mode == PWM_MODE_OFF && val != 0) {
626 /* Transition from Off to Manual */
627 update_pwm_enable(data, nr, PWM_MODE_MANUAL);
628 mode = PWM_MODE_MANUAL;
629 dev_dbg(dev, "Switching PWM%d from %s to %s\n", nr + 1,
630 "off", "manual");
631 }
632
633 data->pwm[nr] = val;
634 if (mode == PWM_MODE_MANUAL)
635 outb(val, iobase + PC87427_REG_PWM_DUTY);
636 mutex_unlock(&data->lock);
637
638 return count;
639 }
640
641 static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO,
642 show_pwm_enable, set_pwm_enable, 0);
643 static SENSOR_DEVICE_ATTR(pwm2_enable, S_IWUSR | S_IRUGO,
644 show_pwm_enable, set_pwm_enable, 1);
645 static SENSOR_DEVICE_ATTR(pwm3_enable, S_IWUSR | S_IRUGO,
646 show_pwm_enable, set_pwm_enable, 2);
647 static SENSOR_DEVICE_ATTR(pwm4_enable, S_IWUSR | S_IRUGO,
648 show_pwm_enable, set_pwm_enable, 3);
649
650 static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 0);
651 static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1);
652 static SENSOR_DEVICE_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 2);
653 static SENSOR_DEVICE_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 3);
654
655 static struct attribute *pc87427_attributes_pwm[4][3] = {
656 {
657 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
658 &sensor_dev_attr_pwm1.dev_attr.attr,
659 NULL
660 }, {
661 &sensor_dev_attr_pwm2_enable.dev_attr.attr,
662 &sensor_dev_attr_pwm2.dev_attr.attr,
663 NULL
664 }, {
665 &sensor_dev_attr_pwm3_enable.dev_attr.attr,
666 &sensor_dev_attr_pwm3.dev_attr.attr,
667 NULL
668 }, {
669 &sensor_dev_attr_pwm4_enable.dev_attr.attr,
670 &sensor_dev_attr_pwm4.dev_attr.attr,
671 NULL
672 }
673 };
674
675 static const struct attribute_group pc87427_group_pwm[4] = {
676 { .attrs = pc87427_attributes_pwm[0] },
677 { .attrs = pc87427_attributes_pwm[1] },
678 { .attrs = pc87427_attributes_pwm[2] },
679 { .attrs = pc87427_attributes_pwm[3] },
680 };
681
682 static ssize_t show_temp_input(struct device *dev, struct device_attribute
683 *devattr, char *buf)
684 {
685 struct pc87427_data *data = pc87427_update_device(dev);
686 int nr = to_sensor_dev_attr(devattr)->index;
687
688 return sprintf(buf, "%ld\n", temp_from_reg(data->temp[nr]));
689 }
690
691 static ssize_t show_temp_min(struct device *dev, struct device_attribute
692 *devattr, char *buf)
693 {
694 struct pc87427_data *data = pc87427_update_device(dev);
695 int nr = to_sensor_dev_attr(devattr)->index;
696
697 return sprintf(buf, "%ld\n", temp_from_reg8(data->temp_min[nr]));
698 }
699
700 static ssize_t show_temp_max(struct device *dev, struct device_attribute
701 *devattr, char *buf)
702 {
703 struct pc87427_data *data = pc87427_update_device(dev);
704 int nr = to_sensor_dev_attr(devattr)->index;
705
706 return sprintf(buf, "%ld\n", temp_from_reg8(data->temp_max[nr]));
707 }
708
709 static ssize_t show_temp_crit(struct device *dev, struct device_attribute
710 *devattr, char *buf)
711 {
712 struct pc87427_data *data = pc87427_update_device(dev);
713 int nr = to_sensor_dev_attr(devattr)->index;
714
715 return sprintf(buf, "%ld\n", temp_from_reg8(data->temp_crit[nr]));
716 }
717
718 static ssize_t show_temp_type(struct device *dev, struct device_attribute
719 *devattr, char *buf)
720 {
721 struct pc87427_data *data = pc87427_update_device(dev);
722 int nr = to_sensor_dev_attr(devattr)->index;
723
724 return sprintf(buf, "%u\n", temp_type_from_reg(data->temp_type[nr]));
725 }
726
727 static ssize_t show_temp_min_alarm(struct device *dev, struct device_attribute
728 *devattr, char *buf)
729 {
730 struct pc87427_data *data = pc87427_update_device(dev);
731 int nr = to_sensor_dev_attr(devattr)->index;
732
733 return sprintf(buf, "%d\n", !!(data->temp_status[nr]
734 & TEMP_STATUS_LOWFLG));
735 }
736
737 static ssize_t show_temp_max_alarm(struct device *dev, struct device_attribute
738 *devattr, char *buf)
739 {
740 struct pc87427_data *data = pc87427_update_device(dev);
741 int nr = to_sensor_dev_attr(devattr)->index;
742
743 return sprintf(buf, "%d\n", !!(data->temp_status[nr]
744 & TEMP_STATUS_HIGHFLG));
745 }
746
747 static ssize_t show_temp_crit_alarm(struct device *dev, struct device_attribute
748 *devattr, char *buf)
749 {
750 struct pc87427_data *data = pc87427_update_device(dev);
751 int nr = to_sensor_dev_attr(devattr)->index;
752
753 return sprintf(buf, "%d\n", !!(data->temp_status[nr]
754 & TEMP_STATUS_CRITFLG));
755 }
756
757 static ssize_t show_temp_fault(struct device *dev, struct device_attribute
758 *devattr, char *buf)
759 {
760 struct pc87427_data *data = pc87427_update_device(dev);
761 int nr = to_sensor_dev_attr(devattr)->index;
762
763 return sprintf(buf, "%d\n", !!(data->temp_status[nr]
764 & TEMP_STATUS_SENSERR));
765 }
766
767 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_input, NULL, 0);
768 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp_input, NULL, 1);
769 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp_input, NULL, 2);
770 static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp_input, NULL, 3);
771 static SENSOR_DEVICE_ATTR(temp5_input, S_IRUGO, show_temp_input, NULL, 4);
772 static SENSOR_DEVICE_ATTR(temp6_input, S_IRUGO, show_temp_input, NULL, 5);
773
774 static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO, show_temp_min, NULL, 0);
775 static SENSOR_DEVICE_ATTR(temp2_min, S_IRUGO, show_temp_min, NULL, 1);
776 static SENSOR_DEVICE_ATTR(temp3_min, S_IRUGO, show_temp_min, NULL, 2);
777 static SENSOR_DEVICE_ATTR(temp4_min, S_IRUGO, show_temp_min, NULL, 3);
778 static SENSOR_DEVICE_ATTR(temp5_min, S_IRUGO, show_temp_min, NULL, 4);
779 static SENSOR_DEVICE_ATTR(temp6_min, S_IRUGO, show_temp_min, NULL, 5);
780
781 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO, show_temp_max, NULL, 0);
782 static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO, show_temp_max, NULL, 1);
783 static SENSOR_DEVICE_ATTR(temp3_max, S_IRUGO, show_temp_max, NULL, 2);
784 static SENSOR_DEVICE_ATTR(temp4_max, S_IRUGO, show_temp_max, NULL, 3);
785 static SENSOR_DEVICE_ATTR(temp5_max, S_IRUGO, show_temp_max, NULL, 4);
786 static SENSOR_DEVICE_ATTR(temp6_max, S_IRUGO, show_temp_max, NULL, 5);
787
788 static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO, show_temp_crit, NULL, 0);
789 static SENSOR_DEVICE_ATTR(temp2_crit, S_IRUGO, show_temp_crit, NULL, 1);
790 static SENSOR_DEVICE_ATTR(temp3_crit, S_IRUGO, show_temp_crit, NULL, 2);
791 static SENSOR_DEVICE_ATTR(temp4_crit, S_IRUGO, show_temp_crit, NULL, 3);
792 static SENSOR_DEVICE_ATTR(temp5_crit, S_IRUGO, show_temp_crit, NULL, 4);
793 static SENSOR_DEVICE_ATTR(temp6_crit, S_IRUGO, show_temp_crit, NULL, 5);
794
795 static SENSOR_DEVICE_ATTR(temp1_type, S_IRUGO, show_temp_type, NULL, 0);
796 static SENSOR_DEVICE_ATTR(temp2_type, S_IRUGO, show_temp_type, NULL, 1);
797 static SENSOR_DEVICE_ATTR(temp3_type, S_IRUGO, show_temp_type, NULL, 2);
798 static SENSOR_DEVICE_ATTR(temp4_type, S_IRUGO, show_temp_type, NULL, 3);
799 static SENSOR_DEVICE_ATTR(temp5_type, S_IRUGO, show_temp_type, NULL, 4);
800 static SENSOR_DEVICE_ATTR(temp6_type, S_IRUGO, show_temp_type, NULL, 5);
801
802 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO,
803 show_temp_min_alarm, NULL, 0);
804 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO,
805 show_temp_min_alarm, NULL, 1);
806 static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO,
807 show_temp_min_alarm, NULL, 2);
808 static SENSOR_DEVICE_ATTR(temp4_min_alarm, S_IRUGO,
809 show_temp_min_alarm, NULL, 3);
810 static SENSOR_DEVICE_ATTR(temp5_min_alarm, S_IRUGO,
811 show_temp_min_alarm, NULL, 4);
812 static SENSOR_DEVICE_ATTR(temp6_min_alarm, S_IRUGO,
813 show_temp_min_alarm, NULL, 5);
814
815 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO,
816 show_temp_max_alarm, NULL, 0);
817 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO,
818 show_temp_max_alarm, NULL, 1);
819 static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO,
820 show_temp_max_alarm, NULL, 2);
821 static SENSOR_DEVICE_ATTR(temp4_max_alarm, S_IRUGO,
822 show_temp_max_alarm, NULL, 3);
823 static SENSOR_DEVICE_ATTR(temp5_max_alarm, S_IRUGO,
824 show_temp_max_alarm, NULL, 4);
825 static SENSOR_DEVICE_ATTR(temp6_max_alarm, S_IRUGO,
826 show_temp_max_alarm, NULL, 5);
827
828 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO,
829 show_temp_crit_alarm, NULL, 0);
830 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO,
831 show_temp_crit_alarm, NULL, 1);
832 static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO,
833 show_temp_crit_alarm, NULL, 2);
834 static SENSOR_DEVICE_ATTR(temp4_crit_alarm, S_IRUGO,
835 show_temp_crit_alarm, NULL, 3);
836 static SENSOR_DEVICE_ATTR(temp5_crit_alarm, S_IRUGO,
837 show_temp_crit_alarm, NULL, 4);
838 static SENSOR_DEVICE_ATTR(temp6_crit_alarm, S_IRUGO,
839 show_temp_crit_alarm, NULL, 5);
840
841 static SENSOR_DEVICE_ATTR(temp1_fault, S_IRUGO, show_temp_fault, NULL, 0);
842 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_temp_fault, NULL, 1);
843 static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_temp_fault, NULL, 2);
844 static SENSOR_DEVICE_ATTR(temp4_fault, S_IRUGO, show_temp_fault, NULL, 3);
845 static SENSOR_DEVICE_ATTR(temp5_fault, S_IRUGO, show_temp_fault, NULL, 4);
846 static SENSOR_DEVICE_ATTR(temp6_fault, S_IRUGO, show_temp_fault, NULL, 5);
847
848 static struct attribute *pc87427_attributes_temp[6][10] = {
849 {
850 &sensor_dev_attr_temp1_input.dev_attr.attr,
851 &sensor_dev_attr_temp1_min.dev_attr.attr,
852 &sensor_dev_attr_temp1_max.dev_attr.attr,
853 &sensor_dev_attr_temp1_crit.dev_attr.attr,
854 &sensor_dev_attr_temp1_type.dev_attr.attr,
855 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
856 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
857 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
858 &sensor_dev_attr_temp1_fault.dev_attr.attr,
859 NULL
860 }, {
861 &sensor_dev_attr_temp2_input.dev_attr.attr,
862 &sensor_dev_attr_temp2_min.dev_attr.attr,
863 &sensor_dev_attr_temp2_max.dev_attr.attr,
864 &sensor_dev_attr_temp2_crit.dev_attr.attr,
865 &sensor_dev_attr_temp2_type.dev_attr.attr,
866 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
867 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
868 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
869 &sensor_dev_attr_temp2_fault.dev_attr.attr,
870 NULL
871 }, {
872 &sensor_dev_attr_temp3_input.dev_attr.attr,
873 &sensor_dev_attr_temp3_min.dev_attr.attr,
874 &sensor_dev_attr_temp3_max.dev_attr.attr,
875 &sensor_dev_attr_temp3_crit.dev_attr.attr,
876 &sensor_dev_attr_temp3_type.dev_attr.attr,
877 &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
878 &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
879 &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
880 &sensor_dev_attr_temp3_fault.dev_attr.attr,
881 NULL
882 }, {
883 &sensor_dev_attr_temp4_input.dev_attr.attr,
884 &sensor_dev_attr_temp4_min.dev_attr.attr,
885 &sensor_dev_attr_temp4_max.dev_attr.attr,
886 &sensor_dev_attr_temp4_crit.dev_attr.attr,
887 &sensor_dev_attr_temp4_type.dev_attr.attr,
888 &sensor_dev_attr_temp4_min_alarm.dev_attr.attr,
889 &sensor_dev_attr_temp4_max_alarm.dev_attr.attr,
890 &sensor_dev_attr_temp4_crit_alarm.dev_attr.attr,
891 &sensor_dev_attr_temp4_fault.dev_attr.attr,
892 NULL
893 }, {
894 &sensor_dev_attr_temp5_input.dev_attr.attr,
895 &sensor_dev_attr_temp5_min.dev_attr.attr,
896 &sensor_dev_attr_temp5_max.dev_attr.attr,
897 &sensor_dev_attr_temp5_crit.dev_attr.attr,
898 &sensor_dev_attr_temp5_type.dev_attr.attr,
899 &sensor_dev_attr_temp5_min_alarm.dev_attr.attr,
900 &sensor_dev_attr_temp5_max_alarm.dev_attr.attr,
901 &sensor_dev_attr_temp5_crit_alarm.dev_attr.attr,
902 &sensor_dev_attr_temp5_fault.dev_attr.attr,
903 NULL
904 }, {
905 &sensor_dev_attr_temp6_input.dev_attr.attr,
906 &sensor_dev_attr_temp6_min.dev_attr.attr,
907 &sensor_dev_attr_temp6_max.dev_attr.attr,
908 &sensor_dev_attr_temp6_crit.dev_attr.attr,
909 &sensor_dev_attr_temp6_type.dev_attr.attr,
910 &sensor_dev_attr_temp6_min_alarm.dev_attr.attr,
911 &sensor_dev_attr_temp6_max_alarm.dev_attr.attr,
912 &sensor_dev_attr_temp6_crit_alarm.dev_attr.attr,
913 &sensor_dev_attr_temp6_fault.dev_attr.attr,
914 NULL
915 }
916 };
917
918 static const struct attribute_group pc87427_group_temp[6] = {
919 { .attrs = pc87427_attributes_temp[0] },
920 { .attrs = pc87427_attributes_temp[1] },
921 { .attrs = pc87427_attributes_temp[2] },
922 { .attrs = pc87427_attributes_temp[3] },
923 { .attrs = pc87427_attributes_temp[4] },
924 { .attrs = pc87427_attributes_temp[5] },
925 };
926
927 static ssize_t show_name(struct device *dev, struct device_attribute
928 *devattr, char *buf)
929 {
930 struct pc87427_data *data = dev_get_drvdata(dev);
931
932 return sprintf(buf, "%s\n", data->name);
933 }
934 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
935
936
937 /*
938 * Device detection, attach and detach
939 */
940
941 static void pc87427_release_regions(struct platform_device *pdev, int count)
942 {
943 struct resource *res;
944 int i;
945
946 for (i = 0; i < count; i++) {
947 res = platform_get_resource(pdev, IORESOURCE_IO, i);
948 release_region(res->start, resource_size(res));
949 }
950 }
951
952 static int __devinit pc87427_request_regions(struct platform_device *pdev,
953 int count)
954 {
955 struct resource *res;
956 int i, err = 0;
957
958 for (i = 0; i < count; i++) {
959 res = platform_get_resource(pdev, IORESOURCE_IO, i);
960 if (!res) {
961 err = -ENOENT;
962 dev_err(&pdev->dev, "Missing resource #%d\n", i);
963 break;
964 }
965 if (!request_region(res->start, resource_size(res), DRVNAME)) {
966 err = -EBUSY;
967 dev_err(&pdev->dev,
968 "Failed to request region 0x%lx-0x%lx\n",
969 (unsigned long)res->start,
970 (unsigned long)res->end);
971 break;
972 }
973 }
974
975 if (err && i)
976 pc87427_release_regions(pdev, i);
977
978 return err;
979 }
980
981 static void __devinit pc87427_init_device(struct device *dev)
982 {
983 struct pc87427_sio_data *sio_data = dev->platform_data;
984 struct pc87427_data *data = dev_get_drvdata(dev);
985 int i;
986 u8 reg;
987
988 /* The FMC module should be ready */
989 reg = pc87427_read8(data, LD_FAN, PC87427_REG_BANK);
990 if (!(reg & 0x80))
991 dev_warn(dev, "%s module not ready!\n", "FMC");
992
993 /* Check which fans are enabled */
994 for (i = 0; i < 8; i++) {
995 if (!(sio_data->has_fanin & (1 << i))) /* Not wired */
996 continue;
997 reg = pc87427_read8_bank(data, LD_FAN, BANK_FM(i),
998 PC87427_REG_FAN_STATUS);
999 if (reg & FAN_STATUS_MONEN)
1000 data->fan_enabled |= (1 << i);
1001 }
1002
1003 if (!data->fan_enabled) {
1004 dev_dbg(dev, "Enabling monitoring of all fans\n");
1005 for (i = 0; i < 8; i++) {
1006 if (!(sio_data->has_fanin & (1 << i))) /* Not wired */
1007 continue;
1008 pc87427_write8_bank(data, LD_FAN, BANK_FM(i),
1009 PC87427_REG_FAN_STATUS,
1010 FAN_STATUS_MONEN);
1011 }
1012 data->fan_enabled = sio_data->has_fanin;
1013 }
1014
1015 /* Check which PWM outputs are enabled */
1016 for (i = 0; i < 4; i++) {
1017 if (!(sio_data->has_fanout & (1 << i))) /* Not wired */
1018 continue;
1019 reg = pc87427_read8_bank(data, LD_FAN, BANK_FC(i),
1020 PC87427_REG_PWM_ENABLE);
1021 if (reg & PWM_ENABLE_CTLEN)
1022 data->pwm_enabled |= (1 << i);
1023
1024 /* We don't expose an interface to reconfigure the automatic
1025 fan control mode, so only allow to return to this mode if
1026 it was originally set. */
1027 if ((reg & PWM_ENABLE_MODE_MASK) == PWM_MODE_AUTO) {
1028 dev_dbg(dev, "PWM%d is in automatic control mode\n",
1029 i + 1);
1030 data->pwm_auto_ok |= (1 << i);
1031 }
1032 }
1033
1034 /* The HMC module should be ready */
1035 reg = pc87427_read8(data, LD_TEMP, PC87427_REG_BANK);
1036 if (!(reg & 0x80))
1037 dev_warn(dev, "%s module not ready!\n", "HMC");
1038
1039 /* Check which temperature channels are enabled */
1040 for (i = 0; i < 6; i++) {
1041 reg = pc87427_read8_bank(data, LD_TEMP, BANK_TM(i),
1042 PC87427_REG_TEMP_STATUS);
1043 if (reg & TEMP_STATUS_CHANEN)
1044 data->temp_enabled |= (1 << i);
1045 }
1046 }
1047
1048 static void pc87427_remove_files(struct device *dev)
1049 {
1050 struct pc87427_data *data = dev_get_drvdata(dev);
1051 int i;
1052
1053 device_remove_file(dev, &dev_attr_name);
1054 for (i = 0; i < 8; i++) {
1055 if (!(data->fan_enabled & (1 << i)))
1056 continue;
1057 sysfs_remove_group(&dev->kobj, &pc87427_group_fan[i]);
1058 }
1059 for (i = 0; i < 4; i++) {
1060 if (!(data->pwm_enabled & (1 << i)))
1061 continue;
1062 sysfs_remove_group(&dev->kobj, &pc87427_group_pwm[i]);
1063 }
1064 for (i = 0; i < 6; i++) {
1065 if (!(data->temp_enabled & (1 << i)))
1066 continue;
1067 sysfs_remove_group(&dev->kobj, &pc87427_group_temp[i]);
1068 }
1069 }
1070
1071 static int __devinit pc87427_probe(struct platform_device *pdev)
1072 {
1073 struct pc87427_sio_data *sio_data = pdev->dev.platform_data;
1074 struct pc87427_data *data;
1075 int i, err, res_count;
1076
1077 data = kzalloc(sizeof(struct pc87427_data), GFP_KERNEL);
1078 if (!data) {
1079 err = -ENOMEM;
1080 printk(KERN_ERR DRVNAME ": Out of memory\n");
1081 goto exit;
1082 }
1083
1084 data->address[0] = sio_data->address[0];
1085 data->address[1] = sio_data->address[1];
1086 res_count = (data->address[0] != 0) + (data->address[1] != 0);
1087
1088 err = pc87427_request_regions(pdev, res_count);
1089 if (err)
1090 goto exit_kfree;
1091
1092 mutex_init(&data->lock);
1093 data->name = "pc87427";
1094 platform_set_drvdata(pdev, data);
1095 pc87427_init_device(&pdev->dev);
1096
1097 /* Register sysfs hooks */
1098 err = device_create_file(&pdev->dev, &dev_attr_name);
1099 if (err)
1100 goto exit_release_region;
1101 for (i = 0; i < 8; i++) {
1102 if (!(data->fan_enabled & (1 << i)))
1103 continue;
1104 err = sysfs_create_group(&pdev->dev.kobj,
1105 &pc87427_group_fan[i]);
1106 if (err)
1107 goto exit_remove_files;
1108 }
1109 for (i = 0; i < 4; i++) {
1110 if (!(data->pwm_enabled & (1 << i)))
1111 continue;
1112 err = sysfs_create_group(&pdev->dev.kobj,
1113 &pc87427_group_pwm[i]);
1114 if (err)
1115 goto exit_remove_files;
1116 }
1117 for (i = 0; i < 6; i++) {
1118 if (!(data->temp_enabled & (1 << i)))
1119 continue;
1120 err = sysfs_create_group(&pdev->dev.kobj,
1121 &pc87427_group_temp[i]);
1122 if (err)
1123 goto exit_remove_files;
1124 }
1125
1126 data->hwmon_dev = hwmon_device_register(&pdev->dev);
1127 if (IS_ERR(data->hwmon_dev)) {
1128 err = PTR_ERR(data->hwmon_dev);
1129 dev_err(&pdev->dev, "Class registration failed (%d)\n", err);
1130 goto exit_remove_files;
1131 }
1132
1133 return 0;
1134
1135 exit_remove_files:
1136 pc87427_remove_files(&pdev->dev);
1137 exit_release_region:
1138 pc87427_release_regions(pdev, res_count);
1139 exit_kfree:
1140 platform_set_drvdata(pdev, NULL);
1141 kfree(data);
1142 exit:
1143 return err;
1144 }
1145
1146 static int __devexit pc87427_remove(struct platform_device *pdev)
1147 {
1148 struct pc87427_data *data = platform_get_drvdata(pdev);
1149 int res_count;
1150
1151 res_count = (data->address[0] != 0) + (data->address[1] != 0);
1152
1153 hwmon_device_unregister(data->hwmon_dev);
1154 pc87427_remove_files(&pdev->dev);
1155 platform_set_drvdata(pdev, NULL);
1156 kfree(data);
1157
1158 pc87427_release_regions(pdev, res_count);
1159
1160 return 0;
1161 }
1162
1163
1164 static struct platform_driver pc87427_driver = {
1165 .driver = {
1166 .owner = THIS_MODULE,
1167 .name = DRVNAME,
1168 },
1169 .probe = pc87427_probe,
1170 .remove = __devexit_p(pc87427_remove),
1171 };
1172
1173 static int __init pc87427_device_add(const struct pc87427_sio_data *sio_data)
1174 {
1175 struct resource res[2] = {
1176 { .flags = IORESOURCE_IO },
1177 { .flags = IORESOURCE_IO },
1178 };
1179 int err, i, res_count;
1180
1181 res_count = 0;
1182 for (i = 0; i < 2; i++) {
1183 if (!sio_data->address[i])
1184 continue;
1185 res[res_count].start = sio_data->address[i];
1186 res[res_count].end = sio_data->address[i] + REGION_LENGTH - 1;
1187 res[res_count].name = logdev_str[i];
1188
1189 err = acpi_check_resource_conflict(&res[res_count]);
1190 if (err)
1191 goto exit;
1192
1193 res_count++;
1194 }
1195
1196 pdev = platform_device_alloc(DRVNAME, res[0].start);
1197 if (!pdev) {
1198 err = -ENOMEM;
1199 printk(KERN_ERR DRVNAME ": Device allocation failed\n");
1200 goto exit;
1201 }
1202
1203 err = platform_device_add_resources(pdev, res, res_count);
1204 if (err) {
1205 printk(KERN_ERR DRVNAME ": Device resource addition failed "
1206 "(%d)\n", err);
1207 goto exit_device_put;
1208 }
1209
1210 err = platform_device_add_data(pdev, sio_data,
1211 sizeof(struct pc87427_sio_data));
1212 if (err) {
1213 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
1214 goto exit_device_put;
1215 }
1216
1217 err = platform_device_add(pdev);
1218 if (err) {
1219 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
1220 err);
1221 goto exit_device_put;
1222 }
1223
1224 return 0;
1225
1226 exit_device_put:
1227 platform_device_put(pdev);
1228 exit:
1229 return err;
1230 }
1231
1232 static int __init pc87427_find(int sioaddr, struct pc87427_sio_data *sio_data)
1233 {
1234 u16 val;
1235 u8 cfg, cfg_b;
1236 int i, err = 0;
1237
1238 /* Identify device */
1239 val = force_id ? force_id : superio_inb(sioaddr, SIOREG_DEVID);
1240 if (val != 0xf2) { /* PC87427 */
1241 err = -ENODEV;
1242 goto exit;
1243 }
1244
1245 for (i = 0; i < 2; i++) {
1246 sio_data->address[i] = 0;
1247 /* Select logical device */
1248 superio_outb(sioaddr, SIOREG_LDSEL, logdev[i]);
1249
1250 val = superio_inb(sioaddr, SIOREG_ACT);
1251 if (!(val & 0x01)) {
1252 printk(KERN_INFO DRVNAME ": Logical device 0x%02x "
1253 "not activated\n", logdev[i]);
1254 continue;
1255 }
1256
1257 val = superio_inb(sioaddr, SIOREG_MAP);
1258 if (val & 0x01) {
1259 printk(KERN_WARNING DRVNAME ": Logical device 0x%02x "
1260 "is memory-mapped, can't use\n", logdev[i]);
1261 continue;
1262 }
1263
1264 val = (superio_inb(sioaddr, SIOREG_IOBASE) << 8)
1265 | superio_inb(sioaddr, SIOREG_IOBASE + 1);
1266 if (!val) {
1267 printk(KERN_INFO DRVNAME ": I/O base address not set "
1268 "for logical device 0x%02x\n", logdev[i]);
1269 continue;
1270 }
1271 sio_data->address[i] = val;
1272 }
1273
1274 /* No point in loading the driver if everything is disabled */
1275 if (!sio_data->address[0] && !sio_data->address[1]) {
1276 err = -ENODEV;
1277 goto exit;
1278 }
1279
1280 /* Check which fan inputs are wired */
1281 sio_data->has_fanin = (1 << 2) | (1 << 3); /* FANIN2, FANIN3 */
1282
1283 cfg = superio_inb(sioaddr, SIOREG_CF2);
1284 if (!(cfg & (1 << 3)))
1285 sio_data->has_fanin |= (1 << 0); /* FANIN0 */
1286 if (!(cfg & (1 << 2)))
1287 sio_data->has_fanin |= (1 << 4); /* FANIN4 */
1288
1289 cfg = superio_inb(sioaddr, SIOREG_CFD);
1290 if (!(cfg & (1 << 0)))
1291 sio_data->has_fanin |= (1 << 1); /* FANIN1 */
1292
1293 cfg = superio_inb(sioaddr, SIOREG_CF4);
1294 if (!(cfg & (1 << 0)))
1295 sio_data->has_fanin |= (1 << 7); /* FANIN7 */
1296 cfg_b = superio_inb(sioaddr, SIOREG_CFB);
1297 if (!(cfg & (1 << 1)) && (cfg_b & (1 << 3)))
1298 sio_data->has_fanin |= (1 << 5); /* FANIN5 */
1299 cfg = superio_inb(sioaddr, SIOREG_CF3);
1300 if ((cfg & (1 << 3)) && !(cfg_b & (1 << 5)))
1301 sio_data->has_fanin |= (1 << 6); /* FANIN6 */
1302
1303 /* Check which fan outputs are wired */
1304 sio_data->has_fanout = (1 << 0); /* FANOUT0 */
1305 if (cfg_b & (1 << 0))
1306 sio_data->has_fanout |= (1 << 3); /* FANOUT3 */
1307
1308 cfg = superio_inb(sioaddr, SIOREG_CFC);
1309 if (!(cfg & (1 << 4))) {
1310 if (cfg_b & (1 << 1))
1311 sio_data->has_fanout |= (1 << 1); /* FANOUT1 */
1312 if (cfg_b & (1 << 2))
1313 sio_data->has_fanout |= (1 << 2); /* FANOUT2 */
1314 }
1315
1316 /* FANOUT1 and FANOUT2 can each be routed to 2 different pins */
1317 cfg = superio_inb(sioaddr, SIOREG_CF5);
1318 if (cfg & (1 << 6))
1319 sio_data->has_fanout |= (1 << 1); /* FANOUT1 */
1320 if (cfg & (1 << 5))
1321 sio_data->has_fanout |= (1 << 2); /* FANOUT2 */
1322
1323 exit:
1324 superio_exit(sioaddr);
1325 return err;
1326 }
1327
1328 static int __init pc87427_init(void)
1329 {
1330 int err;
1331 struct pc87427_sio_data sio_data;
1332
1333 if (pc87427_find(0x2e, &sio_data)
1334 && pc87427_find(0x4e, &sio_data))
1335 return -ENODEV;
1336
1337 err = platform_driver_register(&pc87427_driver);
1338 if (err)
1339 goto exit;
1340
1341 /* Sets global pdev as a side effect */
1342 err = pc87427_device_add(&sio_data);
1343 if (err)
1344 goto exit_driver;
1345
1346 return 0;
1347
1348 exit_driver:
1349 platform_driver_unregister(&pc87427_driver);
1350 exit:
1351 return err;
1352 }
1353
1354 static void __exit pc87427_exit(void)
1355 {
1356 platform_device_unregister(pdev);
1357 platform_driver_unregister(&pc87427_driver);
1358 }
1359
1360 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
1361 MODULE_DESCRIPTION("PC87427 hardware monitoring driver");
1362 MODULE_LICENSE("GPL");
1363
1364 module_init(pc87427_init);
1365 module_exit(pc87427_exit);
Tomato firmware and modifications.