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