2 * pc87427.c - hardware monitoring driver for the
3 * National Semiconductor PC87427 Super-I/O chip
4 * Copyright (C) 2006, 2008, 2010 Jean Delvare <jdelvare@suse.de>
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.
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.
15 * Supports the following chips:
17 * Chip #vin #fan #pwm #temp devid
18 * PC87427 - 8 4 6 0xF2
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.
25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
41 static unsigned short force_id
;
42 module_param(force_id
, ushort
, 0);
43 MODULE_PARM_DESC(force_id
, "Override the detected device ID");
45 static struct platform_device
*pdev
;
47 #define DRVNAME "pc87427"
50 * The lock mutex protects both the I/O accesses (needed because the
51 * device is using banked registers) and the register cache (needed to keep
52 * the data in the registers and the cache in sync at any time).
55 struct device
*hwmon_dev
;
60 unsigned long last_updated
; /* in jiffies */
61 u8 fan_enabled
; /* bit vector */
62 u16 fan
[8]; /* register values */
63 u16 fan_min
[8]; /* register values */
64 u8 fan_status
[8]; /* register values */
66 u8 pwm_enabled
; /* bit vector */
67 u8 pwm_auto_ok
; /* bit vector */
68 u8 pwm_enable
[4]; /* register values */
69 u8 pwm
[4]; /* register values */
71 u8 temp_enabled
; /* bit vector */
72 s16 temp
[6]; /* register values */
73 s8 temp_min
[6]; /* register values */
74 s8 temp_max
[6]; /* register values */
75 s8 temp_crit
[6]; /* register values */
76 u8 temp_status
[6]; /* register values */
77 u8 temp_type
[6]; /* register values */
80 struct pc87427_sio_data
{
81 unsigned short address
[2];
87 * Super-I/O registers and operations
90 #define SIOREG_LDSEL 0x07 /* Logical device select */
91 #define SIOREG_DEVID 0x20 /* Device ID */
92 #define SIOREG_CF2 0x22 /* Configuration 2 */
93 #define SIOREG_CF3 0x23 /* Configuration 3 */
94 #define SIOREG_CF4 0x24 /* Configuration 4 */
95 #define SIOREG_CF5 0x25 /* Configuration 5 */
96 #define SIOREG_CFB 0x2B /* Configuration B */
97 #define SIOREG_CFC 0x2C /* Configuration C */
98 #define SIOREG_CFD 0x2D /* Configuration D */
99 #define SIOREG_ACT 0x30 /* Device activation */
100 #define SIOREG_MAP 0x50 /* I/O or memory mapping */
101 #define SIOREG_IOBASE 0x60 /* I/O base address */
103 static const u8 logdev
[2] = { 0x09, 0x14 };
104 static const char *logdev_str
[2] = { DRVNAME
" FMC", DRVNAME
" HMC" };
109 static inline void superio_outb(int sioaddr
, int reg
, int val
)
112 outb(val
, sioaddr
+ 1);
115 static inline int superio_inb(int sioaddr
, int reg
)
118 return inb(sioaddr
+ 1);
121 static inline void superio_exit(int sioaddr
)
124 outb(0x02, sioaddr
+ 1);
131 #define REGION_LENGTH 32
132 #define PC87427_REG_BANK 0x0f
133 #define BANK_FM(nr) (nr)
134 #define BANK_FT(nr) (0x08 + (nr))
135 #define BANK_FC(nr) (0x10 + (nr) * 2)
136 #define BANK_TM(nr) (nr)
137 #define BANK_VM(nr) (0x08 + (nr))
140 * I/O access functions
143 /* ldi is the logical device index */
144 static inline int pc87427_read8(struct pc87427_data
*data
, u8 ldi
, u8 reg
)
146 return inb(data
->address
[ldi
] + reg
);
149 /* Must be called with data->lock held, except during init */
150 static inline int pc87427_read8_bank(struct pc87427_data
*data
, u8 ldi
,
153 outb(bank
, data
->address
[ldi
] + PC87427_REG_BANK
);
154 return inb(data
->address
[ldi
] + reg
);
157 /* Must be called with data->lock held, except during init */
158 static inline void pc87427_write8_bank(struct pc87427_data
*data
, u8 ldi
,
159 u8 bank
, u8 reg
, u8 value
)
161 outb(bank
, data
->address
[ldi
] + PC87427_REG_BANK
);
162 outb(value
, data
->address
[ldi
] + reg
);
166 * Fan registers and conversions
169 /* fan data registers are 16-bit wide */
170 #define PC87427_REG_FAN 0x12
171 #define PC87427_REG_FAN_MIN 0x14
172 #define PC87427_REG_FAN_STATUS 0x10
174 #define FAN_STATUS_STALL (1 << 3)
175 #define FAN_STATUS_LOSPD (1 << 1)
176 #define FAN_STATUS_MONEN (1 << 0)
179 * Dedicated function to read all registers related to a given fan input.
180 * This saves us quite a few locks and bank selections.
181 * Must be called with data->lock held.
184 static void pc87427_readall_fan(struct pc87427_data
*data
, u8 nr
)
186 int iobase
= data
->address
[LD_FAN
];
188 outb(BANK_FM(nr
), iobase
+ PC87427_REG_BANK
);
189 data
->fan
[nr
] = inw(iobase
+ PC87427_REG_FAN
);
190 data
->fan_min
[nr
] = inw(iobase
+ PC87427_REG_FAN_MIN
);
191 data
->fan_status
[nr
] = inb(iobase
+ PC87427_REG_FAN_STATUS
);
192 /* Clear fan alarm bits */
193 outb(data
->fan_status
[nr
], iobase
+ PC87427_REG_FAN_STATUS
);
197 * The 2 LSB of fan speed registers are used for something different.
198 * The actual 2 LSB of the measurements are not available.
200 static inline unsigned long fan_from_reg(u16 reg
)
203 if (reg
== 0x0000 || reg
== 0xfffc)
205 return 5400000UL / reg
;
208 /* The 2 LSB of the fan speed limit registers are not significant. */
209 static inline u16
fan_to_reg(unsigned long val
)
213 if (val
>= 1350000UL)
215 return ((1350000UL + val
/ 2) / val
) << 2;
219 * PWM registers and conversions
222 #define PC87427_REG_PWM_ENABLE 0x10
223 #define PC87427_REG_PWM_DUTY 0x12
225 #define PWM_ENABLE_MODE_MASK (7 << 4)
226 #define PWM_ENABLE_CTLEN (1 << 0)
228 #define PWM_MODE_MANUAL (0 << 4)
229 #define PWM_MODE_AUTO (1 << 4)
230 #define PWM_MODE_OFF (2 << 4)
231 #define PWM_MODE_ON (7 << 4)
234 * Dedicated function to read all registers related to a given PWM output.
235 * This saves us quite a few locks and bank selections.
236 * Must be called with data->lock held.
239 static void pc87427_readall_pwm(struct pc87427_data
*data
, u8 nr
)
241 int iobase
= data
->address
[LD_FAN
];
243 outb(BANK_FC(nr
), iobase
+ PC87427_REG_BANK
);
244 data
->pwm_enable
[nr
] = inb(iobase
+ PC87427_REG_PWM_ENABLE
);
245 data
->pwm
[nr
] = inb(iobase
+ PC87427_REG_PWM_DUTY
);
248 static inline int pwm_enable_from_reg(u8 reg
)
250 switch (reg
& PWM_ENABLE_MODE_MASK
) {
253 case PWM_MODE_MANUAL
:
263 static inline u8
pwm_enable_to_reg(unsigned long val
, u8 pwmval
)
269 return pwmval
? PWM_MODE_MANUAL
: PWM_MODE_OFF
;
271 return PWM_MODE_AUTO
;
276 * Temperature registers and conversions
279 #define PC87427_REG_TEMP_STATUS 0x10
280 #define PC87427_REG_TEMP 0x14
281 #define PC87427_REG_TEMP_MAX 0x18
282 #define PC87427_REG_TEMP_MIN 0x19
283 #define PC87427_REG_TEMP_CRIT 0x1a
284 #define PC87427_REG_TEMP_TYPE 0x1d
286 #define TEMP_STATUS_CHANEN (1 << 0)
287 #define TEMP_STATUS_LOWFLG (1 << 1)
288 #define TEMP_STATUS_HIGHFLG (1 << 2)
289 #define TEMP_STATUS_CRITFLG (1 << 3)
290 #define TEMP_STATUS_SENSERR (1 << 5)
291 #define TEMP_TYPE_MASK (3 << 5)
293 #define TEMP_TYPE_THERMISTOR (1 << 5)
294 #define TEMP_TYPE_REMOTE_DIODE (2 << 5)
295 #define TEMP_TYPE_LOCAL_DIODE (3 << 5)
298 * Dedicated function to read all registers related to a given temperature
299 * input. This saves us quite a few locks and bank selections.
300 * Must be called with data->lock held.
303 static void pc87427_readall_temp(struct pc87427_data
*data
, u8 nr
)
305 int iobase
= data
->address
[LD_TEMP
];
307 outb(BANK_TM(nr
), iobase
+ PC87427_REG_BANK
);
308 data
->temp
[nr
] = le16_to_cpu(inw(iobase
+ PC87427_REG_TEMP
));
309 data
->temp_max
[nr
] = inb(iobase
+ PC87427_REG_TEMP_MAX
);
310 data
->temp_min
[nr
] = inb(iobase
+ PC87427_REG_TEMP_MIN
);
311 data
->temp_crit
[nr
] = inb(iobase
+ PC87427_REG_TEMP_CRIT
);
312 data
->temp_type
[nr
] = inb(iobase
+ PC87427_REG_TEMP_TYPE
);
313 data
->temp_status
[nr
] = inb(iobase
+ PC87427_REG_TEMP_STATUS
);
314 /* Clear fan alarm bits */
315 outb(data
->temp_status
[nr
], iobase
+ PC87427_REG_TEMP_STATUS
);
318 static inline unsigned int temp_type_from_reg(u8 reg
)
320 switch (reg
& TEMP_TYPE_MASK
) {
321 case TEMP_TYPE_THERMISTOR
:
323 case TEMP_TYPE_REMOTE_DIODE
:
324 case TEMP_TYPE_LOCAL_DIODE
:
332 * We assume 8-bit thermal sensors; 9-bit thermal sensors are possible
333 * too, but I have no idea how to figure out when they are used.
335 static inline long temp_from_reg(s16 reg
)
337 return reg
* 1000 / 256;
340 static inline long temp_from_reg8(s8 reg
)
349 static struct pc87427_data
*pc87427_update_device(struct device
*dev
)
351 struct pc87427_data
*data
= dev_get_drvdata(dev
);
354 mutex_lock(&data
->lock
);
355 if (!time_after(jiffies
, data
->last_updated
+ HZ
)
356 && data
->last_updated
)
360 for (i
= 0; i
< 8; i
++) {
361 if (!(data
->fan_enabled
& (1 << i
)))
363 pc87427_readall_fan(data
, i
);
367 for (i
= 0; i
< 4; i
++) {
368 if (!(data
->pwm_enabled
& (1 << i
)))
370 pc87427_readall_pwm(data
, i
);
373 /* Temperature channels */
374 for (i
= 0; i
< 6; i
++) {
375 if (!(data
->temp_enabled
& (1 << i
)))
377 pc87427_readall_temp(data
, i
);
380 data
->last_updated
= jiffies
;
383 mutex_unlock(&data
->lock
);
387 static ssize_t
show_fan_input(struct device
*dev
, struct device_attribute
390 struct pc87427_data
*data
= pc87427_update_device(dev
);
391 int nr
= to_sensor_dev_attr(devattr
)->index
;
393 return sprintf(buf
, "%lu\n", fan_from_reg(data
->fan
[nr
]));
396 static ssize_t
show_fan_min(struct device
*dev
, struct device_attribute
399 struct pc87427_data
*data
= pc87427_update_device(dev
);
400 int nr
= to_sensor_dev_attr(devattr
)->index
;
402 return sprintf(buf
, "%lu\n", fan_from_reg(data
->fan_min
[nr
]));
405 static ssize_t
show_fan_alarm(struct device
*dev
, struct device_attribute
408 struct pc87427_data
*data
= pc87427_update_device(dev
);
409 int nr
= to_sensor_dev_attr(devattr
)->index
;
411 return sprintf(buf
, "%d\n", !!(data
->fan_status
[nr
]
412 & FAN_STATUS_LOSPD
));
415 static ssize_t
show_fan_fault(struct device
*dev
, struct device_attribute
418 struct pc87427_data
*data
= pc87427_update_device(dev
);
419 int nr
= to_sensor_dev_attr(devattr
)->index
;
421 return sprintf(buf
, "%d\n", !!(data
->fan_status
[nr
]
422 & FAN_STATUS_STALL
));
425 static ssize_t
set_fan_min(struct device
*dev
, struct device_attribute
426 *devattr
, const char *buf
, size_t count
)
428 struct pc87427_data
*data
= dev_get_drvdata(dev
);
429 int nr
= to_sensor_dev_attr(devattr
)->index
;
431 int iobase
= data
->address
[LD_FAN
];
433 if (kstrtoul(buf
, 10, &val
) < 0)
436 mutex_lock(&data
->lock
);
437 outb(BANK_FM(nr
), iobase
+ PC87427_REG_BANK
);
439 * The low speed limit registers are read-only while monitoring
440 * is enabled, so we have to disable monitoring, then change the
441 * limit, and finally enable monitoring again.
443 outb(0, iobase
+ PC87427_REG_FAN_STATUS
);
444 data
->fan_min
[nr
] = fan_to_reg(val
);
445 outw(data
->fan_min
[nr
], iobase
+ PC87427_REG_FAN_MIN
);
446 outb(FAN_STATUS_MONEN
, iobase
+ PC87427_REG_FAN_STATUS
);
447 mutex_unlock(&data
->lock
);
452 static SENSOR_DEVICE_ATTR(fan1_input
, S_IRUGO
, show_fan_input
, NULL
, 0);
453 static SENSOR_DEVICE_ATTR(fan2_input
, S_IRUGO
, show_fan_input
, NULL
, 1);
454 static SENSOR_DEVICE_ATTR(fan3_input
, S_IRUGO
, show_fan_input
, NULL
, 2);
455 static SENSOR_DEVICE_ATTR(fan4_input
, S_IRUGO
, show_fan_input
, NULL
, 3);
456 static SENSOR_DEVICE_ATTR(fan5_input
, S_IRUGO
, show_fan_input
, NULL
, 4);
457 static SENSOR_DEVICE_ATTR(fan6_input
, S_IRUGO
, show_fan_input
, NULL
, 5);
458 static SENSOR_DEVICE_ATTR(fan7_input
, S_IRUGO
, show_fan_input
, NULL
, 6);
459 static SENSOR_DEVICE_ATTR(fan8_input
, S_IRUGO
, show_fan_input
, NULL
, 7);
461 static SENSOR_DEVICE_ATTR(fan1_min
, S_IWUSR
| S_IRUGO
,
462 show_fan_min
, set_fan_min
, 0);
463 static SENSOR_DEVICE_ATTR(fan2_min
, S_IWUSR
| S_IRUGO
,
464 show_fan_min
, set_fan_min
, 1);
465 static SENSOR_DEVICE_ATTR(fan3_min
, S_IWUSR
| S_IRUGO
,
466 show_fan_min
, set_fan_min
, 2);
467 static SENSOR_DEVICE_ATTR(fan4_min
, S_IWUSR
| S_IRUGO
,
468 show_fan_min
, set_fan_min
, 3);
469 static SENSOR_DEVICE_ATTR(fan5_min
, S_IWUSR
| S_IRUGO
,
470 show_fan_min
, set_fan_min
, 4);
471 static SENSOR_DEVICE_ATTR(fan6_min
, S_IWUSR
| S_IRUGO
,
472 show_fan_min
, set_fan_min
, 5);
473 static SENSOR_DEVICE_ATTR(fan7_min
, S_IWUSR
| S_IRUGO
,
474 show_fan_min
, set_fan_min
, 6);
475 static SENSOR_DEVICE_ATTR(fan8_min
, S_IWUSR
| S_IRUGO
,
476 show_fan_min
, set_fan_min
, 7);
478 static SENSOR_DEVICE_ATTR(fan1_alarm
, S_IRUGO
, show_fan_alarm
, NULL
, 0);
479 static SENSOR_DEVICE_ATTR(fan2_alarm
, S_IRUGO
, show_fan_alarm
, NULL
, 1);
480 static SENSOR_DEVICE_ATTR(fan3_alarm
, S_IRUGO
, show_fan_alarm
, NULL
, 2);
481 static SENSOR_DEVICE_ATTR(fan4_alarm
, S_IRUGO
, show_fan_alarm
, NULL
, 3);
482 static SENSOR_DEVICE_ATTR(fan5_alarm
, S_IRUGO
, show_fan_alarm
, NULL
, 4);
483 static SENSOR_DEVICE_ATTR(fan6_alarm
, S_IRUGO
, show_fan_alarm
, NULL
, 5);
484 static SENSOR_DEVICE_ATTR(fan7_alarm
, S_IRUGO
, show_fan_alarm
, NULL
, 6);
485 static SENSOR_DEVICE_ATTR(fan8_alarm
, S_IRUGO
, show_fan_alarm
, NULL
, 7);
487 static SENSOR_DEVICE_ATTR(fan1_fault
, S_IRUGO
, show_fan_fault
, NULL
, 0);
488 static SENSOR_DEVICE_ATTR(fan2_fault
, S_IRUGO
, show_fan_fault
, NULL
, 1);
489 static SENSOR_DEVICE_ATTR(fan3_fault
, S_IRUGO
, show_fan_fault
, NULL
, 2);
490 static SENSOR_DEVICE_ATTR(fan4_fault
, S_IRUGO
, show_fan_fault
, NULL
, 3);
491 static SENSOR_DEVICE_ATTR(fan5_fault
, S_IRUGO
, show_fan_fault
, NULL
, 4);
492 static SENSOR_DEVICE_ATTR(fan6_fault
, S_IRUGO
, show_fan_fault
, NULL
, 5);
493 static SENSOR_DEVICE_ATTR(fan7_fault
, S_IRUGO
, show_fan_fault
, NULL
, 6);
494 static SENSOR_DEVICE_ATTR(fan8_fault
, S_IRUGO
, show_fan_fault
, NULL
, 7);
496 static struct attribute
*pc87427_attributes_fan
[8][5] = {
498 &sensor_dev_attr_fan1_input
.dev_attr
.attr
,
499 &sensor_dev_attr_fan1_min
.dev_attr
.attr
,
500 &sensor_dev_attr_fan1_alarm
.dev_attr
.attr
,
501 &sensor_dev_attr_fan1_fault
.dev_attr
.attr
,
504 &sensor_dev_attr_fan2_input
.dev_attr
.attr
,
505 &sensor_dev_attr_fan2_min
.dev_attr
.attr
,
506 &sensor_dev_attr_fan2_alarm
.dev_attr
.attr
,
507 &sensor_dev_attr_fan2_fault
.dev_attr
.attr
,
510 &sensor_dev_attr_fan3_input
.dev_attr
.attr
,
511 &sensor_dev_attr_fan3_min
.dev_attr
.attr
,
512 &sensor_dev_attr_fan3_alarm
.dev_attr
.attr
,
513 &sensor_dev_attr_fan3_fault
.dev_attr
.attr
,
516 &sensor_dev_attr_fan4_input
.dev_attr
.attr
,
517 &sensor_dev_attr_fan4_min
.dev_attr
.attr
,
518 &sensor_dev_attr_fan4_alarm
.dev_attr
.attr
,
519 &sensor_dev_attr_fan4_fault
.dev_attr
.attr
,
522 &sensor_dev_attr_fan5_input
.dev_attr
.attr
,
523 &sensor_dev_attr_fan5_min
.dev_attr
.attr
,
524 &sensor_dev_attr_fan5_alarm
.dev_attr
.attr
,
525 &sensor_dev_attr_fan5_fault
.dev_attr
.attr
,
528 &sensor_dev_attr_fan6_input
.dev_attr
.attr
,
529 &sensor_dev_attr_fan6_min
.dev_attr
.attr
,
530 &sensor_dev_attr_fan6_alarm
.dev_attr
.attr
,
531 &sensor_dev_attr_fan6_fault
.dev_attr
.attr
,
534 &sensor_dev_attr_fan7_input
.dev_attr
.attr
,
535 &sensor_dev_attr_fan7_min
.dev_attr
.attr
,
536 &sensor_dev_attr_fan7_alarm
.dev_attr
.attr
,
537 &sensor_dev_attr_fan7_fault
.dev_attr
.attr
,
540 &sensor_dev_attr_fan8_input
.dev_attr
.attr
,
541 &sensor_dev_attr_fan8_min
.dev_attr
.attr
,
542 &sensor_dev_attr_fan8_alarm
.dev_attr
.attr
,
543 &sensor_dev_attr_fan8_fault
.dev_attr
.attr
,
548 static const struct attribute_group pc87427_group_fan
[8] = {
549 { .attrs
= pc87427_attributes_fan
[0] },
550 { .attrs
= pc87427_attributes_fan
[1] },
551 { .attrs
= pc87427_attributes_fan
[2] },
552 { .attrs
= pc87427_attributes_fan
[3] },
553 { .attrs
= pc87427_attributes_fan
[4] },
554 { .attrs
= pc87427_attributes_fan
[5] },
555 { .attrs
= pc87427_attributes_fan
[6] },
556 { .attrs
= pc87427_attributes_fan
[7] },
560 * Must be called with data->lock held and pc87427_readall_pwm() freshly
563 static void update_pwm_enable(struct pc87427_data
*data
, int nr
, u8 mode
)
565 int iobase
= data
->address
[LD_FAN
];
566 data
->pwm_enable
[nr
] &= ~PWM_ENABLE_MODE_MASK
;
567 data
->pwm_enable
[nr
] |= mode
;
568 outb(data
->pwm_enable
[nr
], iobase
+ PC87427_REG_PWM_ENABLE
);
571 static ssize_t
show_pwm_enable(struct device
*dev
, struct device_attribute
574 struct pc87427_data
*data
= pc87427_update_device(dev
);
575 int nr
= to_sensor_dev_attr(devattr
)->index
;
578 pwm_enable
= pwm_enable_from_reg(data
->pwm_enable
[nr
]);
581 return sprintf(buf
, "%d\n", pwm_enable
);
584 static ssize_t
set_pwm_enable(struct device
*dev
, struct device_attribute
585 *devattr
, const char *buf
, size_t count
)
587 struct pc87427_data
*data
= dev_get_drvdata(dev
);
588 int nr
= to_sensor_dev_attr(devattr
)->index
;
591 if (kstrtoul(buf
, 10, &val
) < 0 || val
> 2)
593 /* Can't go to automatic mode if it isn't configured */
594 if (val
== 2 && !(data
->pwm_auto_ok
& (1 << nr
)))
597 mutex_lock(&data
->lock
);
598 pc87427_readall_pwm(data
, nr
);
599 update_pwm_enable(data
, nr
, pwm_enable_to_reg(val
, data
->pwm
[nr
]));
600 mutex_unlock(&data
->lock
);
605 static ssize_t
show_pwm(struct device
*dev
, struct device_attribute
608 struct pc87427_data
*data
= pc87427_update_device(dev
);
609 int nr
= to_sensor_dev_attr(devattr
)->index
;
611 return sprintf(buf
, "%d\n", (int)data
->pwm
[nr
]);
614 static ssize_t
set_pwm(struct device
*dev
, struct device_attribute
615 *devattr
, const char *buf
, size_t count
)
617 struct pc87427_data
*data
= dev_get_drvdata(dev
);
618 int nr
= to_sensor_dev_attr(devattr
)->index
;
620 int iobase
= data
->address
[LD_FAN
];
623 if (kstrtoul(buf
, 10, &val
) < 0 || val
> 0xff)
626 mutex_lock(&data
->lock
);
627 pc87427_readall_pwm(data
, nr
);
628 mode
= data
->pwm_enable
[nr
] & PWM_ENABLE_MODE_MASK
;
629 if (mode
!= PWM_MODE_MANUAL
&& mode
!= PWM_MODE_OFF
) {
631 "Can't set PWM%d duty cycle while not in manual mode\n",
633 mutex_unlock(&data
->lock
);
637 /* We may have to change the mode */
638 if (mode
== PWM_MODE_MANUAL
&& val
== 0) {
639 /* Transition from Manual to Off */
640 update_pwm_enable(data
, nr
, PWM_MODE_OFF
);
642 dev_dbg(dev
, "Switching PWM%d from %s to %s\n", nr
+ 1,
644 } else if (mode
== PWM_MODE_OFF
&& val
!= 0) {
645 /* Transition from Off to Manual */
646 update_pwm_enable(data
, nr
, PWM_MODE_MANUAL
);
647 mode
= PWM_MODE_MANUAL
;
648 dev_dbg(dev
, "Switching PWM%d from %s to %s\n", nr
+ 1,
653 if (mode
== PWM_MODE_MANUAL
)
654 outb(val
, iobase
+ PC87427_REG_PWM_DUTY
);
655 mutex_unlock(&data
->lock
);
660 static SENSOR_DEVICE_ATTR(pwm1_enable
, S_IWUSR
| S_IRUGO
,
661 show_pwm_enable
, set_pwm_enable
, 0);
662 static SENSOR_DEVICE_ATTR(pwm2_enable
, S_IWUSR
| S_IRUGO
,
663 show_pwm_enable
, set_pwm_enable
, 1);
664 static SENSOR_DEVICE_ATTR(pwm3_enable
, S_IWUSR
| S_IRUGO
,
665 show_pwm_enable
, set_pwm_enable
, 2);
666 static SENSOR_DEVICE_ATTR(pwm4_enable
, S_IWUSR
| S_IRUGO
,
667 show_pwm_enable
, set_pwm_enable
, 3);
669 static SENSOR_DEVICE_ATTR(pwm1
, S_IWUSR
| S_IRUGO
, show_pwm
, set_pwm
, 0);
670 static SENSOR_DEVICE_ATTR(pwm2
, S_IWUSR
| S_IRUGO
, show_pwm
, set_pwm
, 1);
671 static SENSOR_DEVICE_ATTR(pwm3
, S_IWUSR
| S_IRUGO
, show_pwm
, set_pwm
, 2);
672 static SENSOR_DEVICE_ATTR(pwm4
, S_IWUSR
| S_IRUGO
, show_pwm
, set_pwm
, 3);
674 static struct attribute
*pc87427_attributes_pwm
[4][3] = {
676 &sensor_dev_attr_pwm1_enable
.dev_attr
.attr
,
677 &sensor_dev_attr_pwm1
.dev_attr
.attr
,
680 &sensor_dev_attr_pwm2_enable
.dev_attr
.attr
,
681 &sensor_dev_attr_pwm2
.dev_attr
.attr
,
684 &sensor_dev_attr_pwm3_enable
.dev_attr
.attr
,
685 &sensor_dev_attr_pwm3
.dev_attr
.attr
,
688 &sensor_dev_attr_pwm4_enable
.dev_attr
.attr
,
689 &sensor_dev_attr_pwm4
.dev_attr
.attr
,
694 static const struct attribute_group pc87427_group_pwm
[4] = {
695 { .attrs
= pc87427_attributes_pwm
[0] },
696 { .attrs
= pc87427_attributes_pwm
[1] },
697 { .attrs
= pc87427_attributes_pwm
[2] },
698 { .attrs
= pc87427_attributes_pwm
[3] },
701 static ssize_t
show_temp_input(struct device
*dev
, struct device_attribute
704 struct pc87427_data
*data
= pc87427_update_device(dev
);
705 int nr
= to_sensor_dev_attr(devattr
)->index
;
707 return sprintf(buf
, "%ld\n", temp_from_reg(data
->temp
[nr
]));
710 static ssize_t
show_temp_min(struct device
*dev
, struct device_attribute
713 struct pc87427_data
*data
= pc87427_update_device(dev
);
714 int nr
= to_sensor_dev_attr(devattr
)->index
;
716 return sprintf(buf
, "%ld\n", temp_from_reg8(data
->temp_min
[nr
]));
719 static ssize_t
show_temp_max(struct device
*dev
, struct device_attribute
722 struct pc87427_data
*data
= pc87427_update_device(dev
);
723 int nr
= to_sensor_dev_attr(devattr
)->index
;
725 return sprintf(buf
, "%ld\n", temp_from_reg8(data
->temp_max
[nr
]));
728 static ssize_t
show_temp_crit(struct device
*dev
, struct device_attribute
731 struct pc87427_data
*data
= pc87427_update_device(dev
);
732 int nr
= to_sensor_dev_attr(devattr
)->index
;
734 return sprintf(buf
, "%ld\n", temp_from_reg8(data
->temp_crit
[nr
]));
737 static ssize_t
show_temp_type(struct device
*dev
, struct device_attribute
740 struct pc87427_data
*data
= pc87427_update_device(dev
);
741 int nr
= to_sensor_dev_attr(devattr
)->index
;
743 return sprintf(buf
, "%u\n", temp_type_from_reg(data
->temp_type
[nr
]));
746 static ssize_t
show_temp_min_alarm(struct device
*dev
, struct device_attribute
749 struct pc87427_data
*data
= pc87427_update_device(dev
);
750 int nr
= to_sensor_dev_attr(devattr
)->index
;
752 return sprintf(buf
, "%d\n", !!(data
->temp_status
[nr
]
753 & TEMP_STATUS_LOWFLG
));
756 static ssize_t
show_temp_max_alarm(struct device
*dev
, struct device_attribute
759 struct pc87427_data
*data
= pc87427_update_device(dev
);
760 int nr
= to_sensor_dev_attr(devattr
)->index
;
762 return sprintf(buf
, "%d\n", !!(data
->temp_status
[nr
]
763 & TEMP_STATUS_HIGHFLG
));
766 static ssize_t
show_temp_crit_alarm(struct device
*dev
, struct device_attribute
769 struct pc87427_data
*data
= pc87427_update_device(dev
);
770 int nr
= to_sensor_dev_attr(devattr
)->index
;
772 return sprintf(buf
, "%d\n", !!(data
->temp_status
[nr
]
773 & TEMP_STATUS_CRITFLG
));
776 static ssize_t
show_temp_fault(struct device
*dev
, struct device_attribute
779 struct pc87427_data
*data
= pc87427_update_device(dev
);
780 int nr
= to_sensor_dev_attr(devattr
)->index
;
782 return sprintf(buf
, "%d\n", !!(data
->temp_status
[nr
]
783 & TEMP_STATUS_SENSERR
));
786 static SENSOR_DEVICE_ATTR(temp1_input
, S_IRUGO
, show_temp_input
, NULL
, 0);
787 static SENSOR_DEVICE_ATTR(temp2_input
, S_IRUGO
, show_temp_input
, NULL
, 1);
788 static SENSOR_DEVICE_ATTR(temp3_input
, S_IRUGO
, show_temp_input
, NULL
, 2);
789 static SENSOR_DEVICE_ATTR(temp4_input
, S_IRUGO
, show_temp_input
, NULL
, 3);
790 static SENSOR_DEVICE_ATTR(temp5_input
, S_IRUGO
, show_temp_input
, NULL
, 4);
791 static SENSOR_DEVICE_ATTR(temp6_input
, S_IRUGO
, show_temp_input
, NULL
, 5);
793 static SENSOR_DEVICE_ATTR(temp1_min
, S_IRUGO
, show_temp_min
, NULL
, 0);
794 static SENSOR_DEVICE_ATTR(temp2_min
, S_IRUGO
, show_temp_min
, NULL
, 1);
795 static SENSOR_DEVICE_ATTR(temp3_min
, S_IRUGO
, show_temp_min
, NULL
, 2);
796 static SENSOR_DEVICE_ATTR(temp4_min
, S_IRUGO
, show_temp_min
, NULL
, 3);
797 static SENSOR_DEVICE_ATTR(temp5_min
, S_IRUGO
, show_temp_min
, NULL
, 4);
798 static SENSOR_DEVICE_ATTR(temp6_min
, S_IRUGO
, show_temp_min
, NULL
, 5);
800 static SENSOR_DEVICE_ATTR(temp1_max
, S_IRUGO
, show_temp_max
, NULL
, 0);
801 static SENSOR_DEVICE_ATTR(temp2_max
, S_IRUGO
, show_temp_max
, NULL
, 1);
802 static SENSOR_DEVICE_ATTR(temp3_max
, S_IRUGO
, show_temp_max
, NULL
, 2);
803 static SENSOR_DEVICE_ATTR(temp4_max
, S_IRUGO
, show_temp_max
, NULL
, 3);
804 static SENSOR_DEVICE_ATTR(temp5_max
, S_IRUGO
, show_temp_max
, NULL
, 4);
805 static SENSOR_DEVICE_ATTR(temp6_max
, S_IRUGO
, show_temp_max
, NULL
, 5);
807 static SENSOR_DEVICE_ATTR(temp1_crit
, S_IRUGO
, show_temp_crit
, NULL
, 0);
808 static SENSOR_DEVICE_ATTR(temp2_crit
, S_IRUGO
, show_temp_crit
, NULL
, 1);
809 static SENSOR_DEVICE_ATTR(temp3_crit
, S_IRUGO
, show_temp_crit
, NULL
, 2);
810 static SENSOR_DEVICE_ATTR(temp4_crit
, S_IRUGO
, show_temp_crit
, NULL
, 3);
811 static SENSOR_DEVICE_ATTR(temp5_crit
, S_IRUGO
, show_temp_crit
, NULL
, 4);
812 static SENSOR_DEVICE_ATTR(temp6_crit
, S_IRUGO
, show_temp_crit
, NULL
, 5);
814 static SENSOR_DEVICE_ATTR(temp1_type
, S_IRUGO
, show_temp_type
, NULL
, 0);
815 static SENSOR_DEVICE_ATTR(temp2_type
, S_IRUGO
, show_temp_type
, NULL
, 1);
816 static SENSOR_DEVICE_ATTR(temp3_type
, S_IRUGO
, show_temp_type
, NULL
, 2);
817 static SENSOR_DEVICE_ATTR(temp4_type
, S_IRUGO
, show_temp_type
, NULL
, 3);
818 static SENSOR_DEVICE_ATTR(temp5_type
, S_IRUGO
, show_temp_type
, NULL
, 4);
819 static SENSOR_DEVICE_ATTR(temp6_type
, S_IRUGO
, show_temp_type
, NULL
, 5);
821 static SENSOR_DEVICE_ATTR(temp1_min_alarm
, S_IRUGO
,
822 show_temp_min_alarm
, NULL
, 0);
823 static SENSOR_DEVICE_ATTR(temp2_min_alarm
, S_IRUGO
,
824 show_temp_min_alarm
, NULL
, 1);
825 static SENSOR_DEVICE_ATTR(temp3_min_alarm
, S_IRUGO
,
826 show_temp_min_alarm
, NULL
, 2);
827 static SENSOR_DEVICE_ATTR(temp4_min_alarm
, S_IRUGO
,
828 show_temp_min_alarm
, NULL
, 3);
829 static SENSOR_DEVICE_ATTR(temp5_min_alarm
, S_IRUGO
,
830 show_temp_min_alarm
, NULL
, 4);
831 static SENSOR_DEVICE_ATTR(temp6_min_alarm
, S_IRUGO
,
832 show_temp_min_alarm
, NULL
, 5);
834 static SENSOR_DEVICE_ATTR(temp1_max_alarm
, S_IRUGO
,
835 show_temp_max_alarm
, NULL
, 0);
836 static SENSOR_DEVICE_ATTR(temp2_max_alarm
, S_IRUGO
,
837 show_temp_max_alarm
, NULL
, 1);
838 static SENSOR_DEVICE_ATTR(temp3_max_alarm
, S_IRUGO
,
839 show_temp_max_alarm
, NULL
, 2);
840 static SENSOR_DEVICE_ATTR(temp4_max_alarm
, S_IRUGO
,
841 show_temp_max_alarm
, NULL
, 3);
842 static SENSOR_DEVICE_ATTR(temp5_max_alarm
, S_IRUGO
,
843 show_temp_max_alarm
, NULL
, 4);
844 static SENSOR_DEVICE_ATTR(temp6_max_alarm
, S_IRUGO
,
845 show_temp_max_alarm
, NULL
, 5);
847 static SENSOR_DEVICE_ATTR(temp1_crit_alarm
, S_IRUGO
,
848 show_temp_crit_alarm
, NULL
, 0);
849 static SENSOR_DEVICE_ATTR(temp2_crit_alarm
, S_IRUGO
,
850 show_temp_crit_alarm
, NULL
, 1);
851 static SENSOR_DEVICE_ATTR(temp3_crit_alarm
, S_IRUGO
,
852 show_temp_crit_alarm
, NULL
, 2);
853 static SENSOR_DEVICE_ATTR(temp4_crit_alarm
, S_IRUGO
,
854 show_temp_crit_alarm
, NULL
, 3);
855 static SENSOR_DEVICE_ATTR(temp5_crit_alarm
, S_IRUGO
,
856 show_temp_crit_alarm
, NULL
, 4);
857 static SENSOR_DEVICE_ATTR(temp6_crit_alarm
, S_IRUGO
,
858 show_temp_crit_alarm
, NULL
, 5);
860 static SENSOR_DEVICE_ATTR(temp1_fault
, S_IRUGO
, show_temp_fault
, NULL
, 0);
861 static SENSOR_DEVICE_ATTR(temp2_fault
, S_IRUGO
, show_temp_fault
, NULL
, 1);
862 static SENSOR_DEVICE_ATTR(temp3_fault
, S_IRUGO
, show_temp_fault
, NULL
, 2);
863 static SENSOR_DEVICE_ATTR(temp4_fault
, S_IRUGO
, show_temp_fault
, NULL
, 3);
864 static SENSOR_DEVICE_ATTR(temp5_fault
, S_IRUGO
, show_temp_fault
, NULL
, 4);
865 static SENSOR_DEVICE_ATTR(temp6_fault
, S_IRUGO
, show_temp_fault
, NULL
, 5);
867 static struct attribute
*pc87427_attributes_temp
[6][10] = {
869 &sensor_dev_attr_temp1_input
.dev_attr
.attr
,
870 &sensor_dev_attr_temp1_min
.dev_attr
.attr
,
871 &sensor_dev_attr_temp1_max
.dev_attr
.attr
,
872 &sensor_dev_attr_temp1_crit
.dev_attr
.attr
,
873 &sensor_dev_attr_temp1_type
.dev_attr
.attr
,
874 &sensor_dev_attr_temp1_min_alarm
.dev_attr
.attr
,
875 &sensor_dev_attr_temp1_max_alarm
.dev_attr
.attr
,
876 &sensor_dev_attr_temp1_crit_alarm
.dev_attr
.attr
,
877 &sensor_dev_attr_temp1_fault
.dev_attr
.attr
,
880 &sensor_dev_attr_temp2_input
.dev_attr
.attr
,
881 &sensor_dev_attr_temp2_min
.dev_attr
.attr
,
882 &sensor_dev_attr_temp2_max
.dev_attr
.attr
,
883 &sensor_dev_attr_temp2_crit
.dev_attr
.attr
,
884 &sensor_dev_attr_temp2_type
.dev_attr
.attr
,
885 &sensor_dev_attr_temp2_min_alarm
.dev_attr
.attr
,
886 &sensor_dev_attr_temp2_max_alarm
.dev_attr
.attr
,
887 &sensor_dev_attr_temp2_crit_alarm
.dev_attr
.attr
,
888 &sensor_dev_attr_temp2_fault
.dev_attr
.attr
,
891 &sensor_dev_attr_temp3_input
.dev_attr
.attr
,
892 &sensor_dev_attr_temp3_min
.dev_attr
.attr
,
893 &sensor_dev_attr_temp3_max
.dev_attr
.attr
,
894 &sensor_dev_attr_temp3_crit
.dev_attr
.attr
,
895 &sensor_dev_attr_temp3_type
.dev_attr
.attr
,
896 &sensor_dev_attr_temp3_min_alarm
.dev_attr
.attr
,
897 &sensor_dev_attr_temp3_max_alarm
.dev_attr
.attr
,
898 &sensor_dev_attr_temp3_crit_alarm
.dev_attr
.attr
,
899 &sensor_dev_attr_temp3_fault
.dev_attr
.attr
,
902 &sensor_dev_attr_temp4_input
.dev_attr
.attr
,
903 &sensor_dev_attr_temp4_min
.dev_attr
.attr
,
904 &sensor_dev_attr_temp4_max
.dev_attr
.attr
,
905 &sensor_dev_attr_temp4_crit
.dev_attr
.attr
,
906 &sensor_dev_attr_temp4_type
.dev_attr
.attr
,
907 &sensor_dev_attr_temp4_min_alarm
.dev_attr
.attr
,
908 &sensor_dev_attr_temp4_max_alarm
.dev_attr
.attr
,
909 &sensor_dev_attr_temp4_crit_alarm
.dev_attr
.attr
,
910 &sensor_dev_attr_temp4_fault
.dev_attr
.attr
,
913 &sensor_dev_attr_temp5_input
.dev_attr
.attr
,
914 &sensor_dev_attr_temp5_min
.dev_attr
.attr
,
915 &sensor_dev_attr_temp5_max
.dev_attr
.attr
,
916 &sensor_dev_attr_temp5_crit
.dev_attr
.attr
,
917 &sensor_dev_attr_temp5_type
.dev_attr
.attr
,
918 &sensor_dev_attr_temp5_min_alarm
.dev_attr
.attr
,
919 &sensor_dev_attr_temp5_max_alarm
.dev_attr
.attr
,
920 &sensor_dev_attr_temp5_crit_alarm
.dev_attr
.attr
,
921 &sensor_dev_attr_temp5_fault
.dev_attr
.attr
,
924 &sensor_dev_attr_temp6_input
.dev_attr
.attr
,
925 &sensor_dev_attr_temp6_min
.dev_attr
.attr
,
926 &sensor_dev_attr_temp6_max
.dev_attr
.attr
,
927 &sensor_dev_attr_temp6_crit
.dev_attr
.attr
,
928 &sensor_dev_attr_temp6_type
.dev_attr
.attr
,
929 &sensor_dev_attr_temp6_min_alarm
.dev_attr
.attr
,
930 &sensor_dev_attr_temp6_max_alarm
.dev_attr
.attr
,
931 &sensor_dev_attr_temp6_crit_alarm
.dev_attr
.attr
,
932 &sensor_dev_attr_temp6_fault
.dev_attr
.attr
,
937 static const struct attribute_group pc87427_group_temp
[6] = {
938 { .attrs
= pc87427_attributes_temp
[0] },
939 { .attrs
= pc87427_attributes_temp
[1] },
940 { .attrs
= pc87427_attributes_temp
[2] },
941 { .attrs
= pc87427_attributes_temp
[3] },
942 { .attrs
= pc87427_attributes_temp
[4] },
943 { .attrs
= pc87427_attributes_temp
[5] },
946 static ssize_t
show_name(struct device
*dev
, struct device_attribute
949 struct pc87427_data
*data
= dev_get_drvdata(dev
);
951 return sprintf(buf
, "%s\n", data
->name
);
953 static DEVICE_ATTR(name
, S_IRUGO
, show_name
, NULL
);
957 * Device detection, attach and detach
960 static int pc87427_request_regions(struct platform_device
*pdev
,
963 struct resource
*res
;
966 for (i
= 0; i
< count
; i
++) {
967 res
= platform_get_resource(pdev
, IORESOURCE_IO
, i
);
969 dev_err(&pdev
->dev
, "Missing resource #%d\n", i
);
972 if (!devm_request_region(&pdev
->dev
, res
->start
,
973 resource_size(res
), DRVNAME
)) {
975 "Failed to request region 0x%lx-0x%lx\n",
976 (unsigned long)res
->start
,
977 (unsigned long)res
->end
);
984 static void pc87427_init_device(struct device
*dev
)
986 struct pc87427_sio_data
*sio_data
= dev_get_platdata(dev
);
987 struct pc87427_data
*data
= dev_get_drvdata(dev
);
991 /* The FMC module should be ready */
992 reg
= pc87427_read8(data
, LD_FAN
, PC87427_REG_BANK
);
994 dev_warn(dev
, "%s module not ready!\n", "FMC");
996 /* Check which fans are enabled */
997 for (i
= 0; i
< 8; i
++) {
998 if (!(sio_data
->has_fanin
& (1 << i
))) /* Not wired */
1000 reg
= pc87427_read8_bank(data
, LD_FAN
, BANK_FM(i
),
1001 PC87427_REG_FAN_STATUS
);
1002 if (reg
& FAN_STATUS_MONEN
)
1003 data
->fan_enabled
|= (1 << i
);
1006 if (!data
->fan_enabled
) {
1007 dev_dbg(dev
, "Enabling monitoring of all fans\n");
1008 for (i
= 0; i
< 8; i
++) {
1009 if (!(sio_data
->has_fanin
& (1 << i
))) /* Not wired */
1011 pc87427_write8_bank(data
, LD_FAN
, BANK_FM(i
),
1012 PC87427_REG_FAN_STATUS
,
1015 data
->fan_enabled
= sio_data
->has_fanin
;
1018 /* Check which PWM outputs are enabled */
1019 for (i
= 0; i
< 4; i
++) {
1020 if (!(sio_data
->has_fanout
& (1 << i
))) /* Not wired */
1022 reg
= pc87427_read8_bank(data
, LD_FAN
, BANK_FC(i
),
1023 PC87427_REG_PWM_ENABLE
);
1024 if (reg
& PWM_ENABLE_CTLEN
)
1025 data
->pwm_enabled
|= (1 << i
);
1028 * We don't expose an interface to reconfigure the automatic
1029 * fan control mode, so only allow to return to this mode if
1030 * it was originally set.
1032 if ((reg
& PWM_ENABLE_MODE_MASK
) == PWM_MODE_AUTO
) {
1033 dev_dbg(dev
, "PWM%d is in automatic control mode\n",
1035 data
->pwm_auto_ok
|= (1 << i
);
1039 /* The HMC module should be ready */
1040 reg
= pc87427_read8(data
, LD_TEMP
, PC87427_REG_BANK
);
1042 dev_warn(dev
, "%s module not ready!\n", "HMC");
1044 /* Check which temperature channels are enabled */
1045 for (i
= 0; i
< 6; i
++) {
1046 reg
= pc87427_read8_bank(data
, LD_TEMP
, BANK_TM(i
),
1047 PC87427_REG_TEMP_STATUS
);
1048 if (reg
& TEMP_STATUS_CHANEN
)
1049 data
->temp_enabled
|= (1 << i
);
1053 static void pc87427_remove_files(struct device
*dev
)
1055 struct pc87427_data
*data
= dev_get_drvdata(dev
);
1058 device_remove_file(dev
, &dev_attr_name
);
1059 for (i
= 0; i
< 8; i
++) {
1060 if (!(data
->fan_enabled
& (1 << i
)))
1062 sysfs_remove_group(&dev
->kobj
, &pc87427_group_fan
[i
]);
1064 for (i
= 0; i
< 4; i
++) {
1065 if (!(data
->pwm_enabled
& (1 << i
)))
1067 sysfs_remove_group(&dev
->kobj
, &pc87427_group_pwm
[i
]);
1069 for (i
= 0; i
< 6; i
++) {
1070 if (!(data
->temp_enabled
& (1 << i
)))
1072 sysfs_remove_group(&dev
->kobj
, &pc87427_group_temp
[i
]);
1076 static int pc87427_probe(struct platform_device
*pdev
)
1078 struct pc87427_sio_data
*sio_data
= dev_get_platdata(&pdev
->dev
);
1079 struct pc87427_data
*data
;
1080 int i
, err
, res_count
;
1082 data
= devm_kzalloc(&pdev
->dev
, sizeof(struct pc87427_data
),
1087 data
->address
[0] = sio_data
->address
[0];
1088 data
->address
[1] = sio_data
->address
[1];
1089 res_count
= (data
->address
[0] != 0) + (data
->address
[1] != 0);
1091 err
= pc87427_request_regions(pdev
, res_count
);
1095 mutex_init(&data
->lock
);
1096 data
->name
= "pc87427";
1097 platform_set_drvdata(pdev
, data
);
1098 pc87427_init_device(&pdev
->dev
);
1100 /* Register sysfs hooks */
1101 err
= device_create_file(&pdev
->dev
, &dev_attr_name
);
1104 for (i
= 0; i
< 8; i
++) {
1105 if (!(data
->fan_enabled
& (1 << i
)))
1107 err
= sysfs_create_group(&pdev
->dev
.kobj
,
1108 &pc87427_group_fan
[i
]);
1110 goto exit_remove_files
;
1112 for (i
= 0; i
< 4; i
++) {
1113 if (!(data
->pwm_enabled
& (1 << i
)))
1115 err
= sysfs_create_group(&pdev
->dev
.kobj
,
1116 &pc87427_group_pwm
[i
]);
1118 goto exit_remove_files
;
1120 for (i
= 0; i
< 6; i
++) {
1121 if (!(data
->temp_enabled
& (1 << i
)))
1123 err
= sysfs_create_group(&pdev
->dev
.kobj
,
1124 &pc87427_group_temp
[i
]);
1126 goto exit_remove_files
;
1129 data
->hwmon_dev
= hwmon_device_register(&pdev
->dev
);
1130 if (IS_ERR(data
->hwmon_dev
)) {
1131 err
= PTR_ERR(data
->hwmon_dev
);
1132 dev_err(&pdev
->dev
, "Class registration failed (%d)\n", err
);
1133 goto exit_remove_files
;
1139 pc87427_remove_files(&pdev
->dev
);
1143 static int pc87427_remove(struct platform_device
*pdev
)
1145 struct pc87427_data
*data
= platform_get_drvdata(pdev
);
1147 hwmon_device_unregister(data
->hwmon_dev
);
1148 pc87427_remove_files(&pdev
->dev
);
1154 static struct platform_driver pc87427_driver
= {
1158 .probe
= pc87427_probe
,
1159 .remove
= pc87427_remove
,
1162 static int __init
pc87427_device_add(const struct pc87427_sio_data
*sio_data
)
1164 struct resource res
[2] = {
1165 { .flags
= IORESOURCE_IO
},
1166 { .flags
= IORESOURCE_IO
},
1168 int err
, i
, res_count
;
1171 for (i
= 0; i
< 2; i
++) {
1172 if (!sio_data
->address
[i
])
1174 res
[res_count
].start
= sio_data
->address
[i
];
1175 res
[res_count
].end
= sio_data
->address
[i
] + REGION_LENGTH
- 1;
1176 res
[res_count
].name
= logdev_str
[i
];
1178 err
= acpi_check_resource_conflict(&res
[res_count
]);
1185 pdev
= platform_device_alloc(DRVNAME
, res
[0].start
);
1188 pr_err("Device allocation failed\n");
1192 err
= platform_device_add_resources(pdev
, res
, res_count
);
1194 pr_err("Device resource addition failed (%d)\n", err
);
1195 goto exit_device_put
;
1198 err
= platform_device_add_data(pdev
, sio_data
,
1199 sizeof(struct pc87427_sio_data
));
1201 pr_err("Platform data allocation failed\n");
1202 goto exit_device_put
;
1205 err
= platform_device_add(pdev
);
1207 pr_err("Device addition failed (%d)\n", err
);
1208 goto exit_device_put
;
1214 platform_device_put(pdev
);
1219 static int __init
pc87427_find(int sioaddr
, struct pc87427_sio_data
*sio_data
)
1225 /* Identify device */
1226 val
= force_id
? force_id
: superio_inb(sioaddr
, SIOREG_DEVID
);
1227 if (val
!= 0xf2) { /* PC87427 */
1232 for (i
= 0; i
< 2; i
++) {
1233 sio_data
->address
[i
] = 0;
1234 /* Select logical device */
1235 superio_outb(sioaddr
, SIOREG_LDSEL
, logdev
[i
]);
1237 val
= superio_inb(sioaddr
, SIOREG_ACT
);
1238 if (!(val
& 0x01)) {
1239 pr_info("Logical device 0x%02x not activated\n",
1244 val
= superio_inb(sioaddr
, SIOREG_MAP
);
1246 pr_warn("Logical device 0x%02x is memory-mapped, can't use\n",
1251 val
= (superio_inb(sioaddr
, SIOREG_IOBASE
) << 8)
1252 | superio_inb(sioaddr
, SIOREG_IOBASE
+ 1);
1254 pr_info("I/O base address not set for logical device 0x%02x\n",
1258 sio_data
->address
[i
] = val
;
1261 /* No point in loading the driver if everything is disabled */
1262 if (!sio_data
->address
[0] && !sio_data
->address
[1]) {
1267 /* Check which fan inputs are wired */
1268 sio_data
->has_fanin
= (1 << 2) | (1 << 3); /* FANIN2, FANIN3 */
1270 cfg
= superio_inb(sioaddr
, SIOREG_CF2
);
1271 if (!(cfg
& (1 << 3)))
1272 sio_data
->has_fanin
|= (1 << 0); /* FANIN0 */
1273 if (!(cfg
& (1 << 2)))
1274 sio_data
->has_fanin
|= (1 << 4); /* FANIN4 */
1276 cfg
= superio_inb(sioaddr
, SIOREG_CFD
);
1277 if (!(cfg
& (1 << 0)))
1278 sio_data
->has_fanin
|= (1 << 1); /* FANIN1 */
1280 cfg
= superio_inb(sioaddr
, SIOREG_CF4
);
1281 if (!(cfg
& (1 << 0)))
1282 sio_data
->has_fanin
|= (1 << 7); /* FANIN7 */
1283 cfg_b
= superio_inb(sioaddr
, SIOREG_CFB
);
1284 if (!(cfg
& (1 << 1)) && (cfg_b
& (1 << 3)))
1285 sio_data
->has_fanin
|= (1 << 5); /* FANIN5 */
1286 cfg
= superio_inb(sioaddr
, SIOREG_CF3
);
1287 if ((cfg
& (1 << 3)) && !(cfg_b
& (1 << 5)))
1288 sio_data
->has_fanin
|= (1 << 6); /* FANIN6 */
1290 /* Check which fan outputs are wired */
1291 sio_data
->has_fanout
= (1 << 0); /* FANOUT0 */
1292 if (cfg_b
& (1 << 0))
1293 sio_data
->has_fanout
|= (1 << 3); /* FANOUT3 */
1295 cfg
= superio_inb(sioaddr
, SIOREG_CFC
);
1296 if (!(cfg
& (1 << 4))) {
1297 if (cfg_b
& (1 << 1))
1298 sio_data
->has_fanout
|= (1 << 1); /* FANOUT1 */
1299 if (cfg_b
& (1 << 2))
1300 sio_data
->has_fanout
|= (1 << 2); /* FANOUT2 */
1303 /* FANOUT1 and FANOUT2 can each be routed to 2 different pins */
1304 cfg
= superio_inb(sioaddr
, SIOREG_CF5
);
1306 sio_data
->has_fanout
|= (1 << 1); /* FANOUT1 */
1308 sio_data
->has_fanout
|= (1 << 2); /* FANOUT2 */
1311 superio_exit(sioaddr
);
1315 static int __init
pc87427_init(void)
1318 struct pc87427_sio_data sio_data
;
1320 if (pc87427_find(0x2e, &sio_data
)
1321 && pc87427_find(0x4e, &sio_data
))
1324 err
= platform_driver_register(&pc87427_driver
);
1328 /* Sets global pdev as a side effect */
1329 err
= pc87427_device_add(&sio_data
);
1336 platform_driver_unregister(&pc87427_driver
);
1341 static void __exit
pc87427_exit(void)
1343 platform_device_unregister(pdev
);
1344 platform_driver_unregister(&pc87427_driver
);
1347 MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
1348 MODULE_DESCRIPTION("PC87427 hardware monitoring driver");
1349 MODULE_LICENSE("GPL");
1351 module_init(pc87427_init
);
1352 module_exit(pc87427_exit
);