2 * f71805f.c - driver for the Fintek F71805F/FG Super-I/O chip integrated
3 * hardware monitoring features
4 * Copyright (C) 2005 Jean Delvare <khali@linux-fr.org>
6 * The F71805F/FG is a LPC Super-I/O chip made by Fintek. It integrates
7 * complete hardware monitoring features: voltage, fan and temperature
8 * sensors, and manual and automatic fan speed control.
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
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>
36 static struct platform_device
*pdev
;
38 #define DRVNAME "f71805f"
41 * Super-I/O constants and functions
44 #define F71805F_LD_HWM 0x04
46 #define SIO_REG_LDSEL 0x07 /* Logical device select */
47 #define SIO_REG_DEVID 0x20 /* Device ID (2 bytes) */
48 #define SIO_REG_DEVREV 0x22 /* Device revision */
49 #define SIO_REG_MANID 0x23 /* Fintek ID (2 bytes) */
50 #define SIO_REG_ENABLE 0x30 /* Logical device enable */
51 #define SIO_REG_ADDR 0x60 /* Logical device address (2 bytes) */
53 #define SIO_FINTEK_ID 0x1934
54 #define SIO_F71805F_ID 0x0406
57 superio_inb(int base
, int reg
)
64 superio_inw(int base
, int reg
)
68 val
= inb(base
+ 1) << 8;
75 superio_select(int base
, int ld
)
77 outb(SIO_REG_LDSEL
, base
);
82 superio_enter(int base
)
89 superio_exit(int base
)
98 #define REGION_LENGTH 2
99 #define ADDR_REG_OFFSET 0
100 #define DATA_REG_OFFSET 1
102 static struct resource f71805f_resource __initdata
= {
103 .flags
= IORESOURCE_IO
,
110 /* in nr from 0 to 8 (8-bit values) */
111 #define F71805F_REG_IN(nr) (0x10 + (nr))
112 #define F71805F_REG_IN_HIGH(nr) (0x40 + 2 * (nr))
113 #define F71805F_REG_IN_LOW(nr) (0x41 + 2 * (nr))
114 /* fan nr from 0 to 2 (12-bit values, two registers) */
115 #define F71805F_REG_FAN(nr) (0x20 + 2 * (nr))
116 #define F71805F_REG_FAN_LOW(nr) (0x28 + 2 * (nr))
117 #define F71805F_REG_FAN_CTRL(nr) (0x60 + 16 * (nr))
118 /* temp nr from 0 to 2 (8-bit values) */
119 #define F71805F_REG_TEMP(nr) (0x1B + (nr))
120 #define F71805F_REG_TEMP_HIGH(nr) (0x54 + 2 * (nr))
121 #define F71805F_REG_TEMP_HYST(nr) (0x55 + 2 * (nr))
122 #define F71805F_REG_TEMP_MODE 0x01
124 #define F71805F_REG_START 0x00
125 /* status nr from 0 to 2 */
126 #define F71805F_REG_STATUS(nr) (0x36 + (nr))
129 * Data structures and manipulation thereof
132 struct f71805f_data
{
136 struct class_device
*class_dev
;
138 struct mutex update_lock
;
139 char valid
; /* !=0 if following fields are valid */
140 unsigned long last_updated
; /* In jiffies */
141 unsigned long last_limits
; /* In jiffies */
143 /* Register values */
149 u8 fan_enabled
; /* Read once at init time */
157 static inline long in_from_reg(u8 reg
)
162 /* The 2 least significant bits are not used */
163 static inline u8
in_to_reg(long val
)
169 return (((val
+ 16) / 32) << 2);
172 /* in0 is downscaled by a factor 2 internally */
173 static inline long in0_from_reg(u8 reg
)
178 static inline u8
in0_to_reg(long val
)
184 return (((val
+ 32) / 64) << 2);
187 /* The 4 most significant bits are not used */
188 static inline long fan_from_reg(u16 reg
)
191 if (!reg
|| reg
== 0xfff)
193 return (1500000 / reg
);
196 static inline u16
fan_to_reg(long rpm
)
198 /* If the low limit is set below what the chip can measure,
199 store the largest possible 12-bit value in the registers,
200 so that no alarm will ever trigger. */
203 return (1500000 / rpm
);
206 static inline long temp_from_reg(u8 reg
)
211 static inline u8
temp_to_reg(long val
)
215 else if (val
> 1000 * 0xff)
217 return ((val
+ 500) / 1000);
224 static u8
f71805f_read8(struct f71805f_data
*data
, u8 reg
)
228 mutex_lock(&data
->lock
);
229 outb(reg
, data
->addr
+ ADDR_REG_OFFSET
);
230 val
= inb(data
->addr
+ DATA_REG_OFFSET
);
231 mutex_unlock(&data
->lock
);
236 static void f71805f_write8(struct f71805f_data
*data
, u8 reg
, u8 val
)
238 mutex_lock(&data
->lock
);
239 outb(reg
, data
->addr
+ ADDR_REG_OFFSET
);
240 outb(val
, data
->addr
+ DATA_REG_OFFSET
);
241 mutex_unlock(&data
->lock
);
244 /* It is important to read the MSB first, because doing so latches the
245 value of the LSB, so we are sure both bytes belong to the same value. */
246 static u16
f71805f_read16(struct f71805f_data
*data
, u8 reg
)
250 mutex_lock(&data
->lock
);
251 outb(reg
, data
->addr
+ ADDR_REG_OFFSET
);
252 val
= inb(data
->addr
+ DATA_REG_OFFSET
) << 8;
253 outb(++reg
, data
->addr
+ ADDR_REG_OFFSET
);
254 val
|= inb(data
->addr
+ DATA_REG_OFFSET
);
255 mutex_unlock(&data
->lock
);
260 static void f71805f_write16(struct f71805f_data
*data
, u8 reg
, u16 val
)
262 mutex_lock(&data
->lock
);
263 outb(reg
, data
->addr
+ ADDR_REG_OFFSET
);
264 outb(val
>> 8, data
->addr
+ DATA_REG_OFFSET
);
265 outb(++reg
, data
->addr
+ ADDR_REG_OFFSET
);
266 outb(val
& 0xff, data
->addr
+ DATA_REG_OFFSET
);
267 mutex_unlock(&data
->lock
);
270 static struct f71805f_data
*f71805f_update_device(struct device
*dev
)
272 struct f71805f_data
*data
= dev_get_drvdata(dev
);
275 mutex_lock(&data
->update_lock
);
277 /* Limit registers cache is refreshed after 60 seconds */
278 if (time_after(jiffies
, data
->last_updated
+ 60 * HZ
)
280 for (nr
= 0; nr
< 9; nr
++) {
281 data
->in_high
[nr
] = f71805f_read8(data
,
282 F71805F_REG_IN_HIGH(nr
));
283 data
->in_low
[nr
] = f71805f_read8(data
,
284 F71805F_REG_IN_LOW(nr
));
286 for (nr
= 0; nr
< 3; nr
++) {
287 if (data
->fan_enabled
& (1 << nr
))
288 data
->fan_low
[nr
] = f71805f_read16(data
,
289 F71805F_REG_FAN_LOW(nr
));
291 for (nr
= 0; nr
< 3; nr
++) {
292 data
->temp_high
[nr
] = f71805f_read8(data
,
293 F71805F_REG_TEMP_HIGH(nr
));
294 data
->temp_hyst
[nr
] = f71805f_read8(data
,
295 F71805F_REG_TEMP_HYST(nr
));
297 data
->temp_mode
= f71805f_read8(data
, F71805F_REG_TEMP_MODE
);
299 data
->last_limits
= jiffies
;
302 /* Measurement registers cache is refreshed after 1 second */
303 if (time_after(jiffies
, data
->last_updated
+ HZ
)
305 for (nr
= 0; nr
< 9; nr
++) {
306 data
->in
[nr
] = f71805f_read8(data
,
309 for (nr
= 0; nr
< 3; nr
++) {
310 if (data
->fan_enabled
& (1 << nr
))
311 data
->fan
[nr
] = f71805f_read16(data
,
312 F71805F_REG_FAN(nr
));
314 for (nr
= 0; nr
< 3; nr
++) {
315 data
->temp
[nr
] = f71805f_read8(data
,
316 F71805F_REG_TEMP(nr
));
318 for (nr
= 0; nr
< 3; nr
++) {
319 data
->alarms
[nr
] = f71805f_read8(data
,
320 F71805F_REG_STATUS(nr
));
323 data
->last_updated
= jiffies
;
327 mutex_unlock(&data
->update_lock
);
336 static ssize_t
show_in0(struct device
*dev
, struct device_attribute
*devattr
,
339 struct f71805f_data
*data
= f71805f_update_device(dev
);
341 return sprintf(buf
, "%ld\n", in0_from_reg(data
->in
[0]));
344 static ssize_t
show_in0_max(struct device
*dev
, struct device_attribute
347 struct f71805f_data
*data
= f71805f_update_device(dev
);
349 return sprintf(buf
, "%ld\n", in0_from_reg(data
->in_high
[0]));
352 static ssize_t
show_in0_min(struct device
*dev
, struct device_attribute
355 struct f71805f_data
*data
= f71805f_update_device(dev
);
357 return sprintf(buf
, "%ld\n", in0_from_reg(data
->in_low
[0]));
360 static ssize_t
set_in0_max(struct device
*dev
, struct device_attribute
361 *devattr
, const char *buf
, size_t count
)
363 struct f71805f_data
*data
= dev_get_drvdata(dev
);
364 long val
= simple_strtol(buf
, NULL
, 10);
366 mutex_lock(&data
->update_lock
);
367 data
->in_high
[0] = in0_to_reg(val
);
368 f71805f_write8(data
, F71805F_REG_IN_HIGH(0), data
->in_high
[0]);
369 mutex_unlock(&data
->update_lock
);
374 static ssize_t
set_in0_min(struct device
*dev
, struct device_attribute
375 *devattr
, const char *buf
, size_t count
)
377 struct f71805f_data
*data
= dev_get_drvdata(dev
);
378 long val
= simple_strtol(buf
, NULL
, 10);
380 mutex_lock(&data
->update_lock
);
381 data
->in_low
[0] = in0_to_reg(val
);
382 f71805f_write8(data
, F71805F_REG_IN_LOW(0), data
->in_low
[0]);
383 mutex_unlock(&data
->update_lock
);
388 static ssize_t
show_in(struct device
*dev
, struct device_attribute
*devattr
,
391 struct f71805f_data
*data
= f71805f_update_device(dev
);
392 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
393 int nr
= attr
->index
;
395 return sprintf(buf
, "%ld\n", in_from_reg(data
->in
[nr
]));
398 static ssize_t
show_in_max(struct device
*dev
, struct device_attribute
401 struct f71805f_data
*data
= f71805f_update_device(dev
);
402 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
403 int nr
= attr
->index
;
405 return sprintf(buf
, "%ld\n", in_from_reg(data
->in_high
[nr
]));
408 static ssize_t
show_in_min(struct device
*dev
, struct device_attribute
411 struct f71805f_data
*data
= f71805f_update_device(dev
);
412 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
413 int nr
= attr
->index
;
415 return sprintf(buf
, "%ld\n", in_from_reg(data
->in_low
[nr
]));
418 static ssize_t
set_in_max(struct device
*dev
, struct device_attribute
419 *devattr
, const char *buf
, size_t count
)
421 struct f71805f_data
*data
= dev_get_drvdata(dev
);
422 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
423 int nr
= attr
->index
;
424 long val
= simple_strtol(buf
, NULL
, 10);
426 mutex_lock(&data
->update_lock
);
427 data
->in_high
[nr
] = in_to_reg(val
);
428 f71805f_write8(data
, F71805F_REG_IN_HIGH(nr
), data
->in_high
[nr
]);
429 mutex_unlock(&data
->update_lock
);
434 static ssize_t
set_in_min(struct device
*dev
, struct device_attribute
435 *devattr
, const char *buf
, size_t count
)
437 struct f71805f_data
*data
= dev_get_drvdata(dev
);
438 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
439 int nr
= attr
->index
;
440 long val
= simple_strtol(buf
, NULL
, 10);
442 mutex_lock(&data
->update_lock
);
443 data
->in_low
[nr
] = in_to_reg(val
);
444 f71805f_write8(data
, F71805F_REG_IN_LOW(nr
), data
->in_low
[nr
]);
445 mutex_unlock(&data
->update_lock
);
450 static ssize_t
show_fan(struct device
*dev
, struct device_attribute
*devattr
,
453 struct f71805f_data
*data
= f71805f_update_device(dev
);
454 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
455 int nr
= attr
->index
;
457 return sprintf(buf
, "%ld\n", fan_from_reg(data
->fan
[nr
]));
460 static ssize_t
show_fan_min(struct device
*dev
, struct device_attribute
463 struct f71805f_data
*data
= f71805f_update_device(dev
);
464 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
465 int nr
= attr
->index
;
467 return sprintf(buf
, "%ld\n", fan_from_reg(data
->fan_low
[nr
]));
470 static ssize_t
set_fan_min(struct device
*dev
, struct device_attribute
471 *devattr
, const char *buf
, size_t count
)
473 struct f71805f_data
*data
= dev_get_drvdata(dev
);
474 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
475 int nr
= attr
->index
;
476 long val
= simple_strtol(buf
, NULL
, 10);
478 mutex_lock(&data
->update_lock
);
479 data
->fan_low
[nr
] = fan_to_reg(val
);
480 f71805f_write16(data
, F71805F_REG_FAN_LOW(nr
), data
->fan_low
[nr
]);
481 mutex_unlock(&data
->update_lock
);
486 static ssize_t
show_temp(struct device
*dev
, struct device_attribute
*devattr
,
489 struct f71805f_data
*data
= f71805f_update_device(dev
);
490 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
491 int nr
= attr
->index
;
493 return sprintf(buf
, "%ld\n", temp_from_reg(data
->temp
[nr
]));
496 static ssize_t
show_temp_max(struct device
*dev
, struct device_attribute
499 struct f71805f_data
*data
= f71805f_update_device(dev
);
500 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
501 int nr
= attr
->index
;
503 return sprintf(buf
, "%ld\n", temp_from_reg(data
->temp_high
[nr
]));
506 static ssize_t
show_temp_hyst(struct device
*dev
, struct device_attribute
509 struct f71805f_data
*data
= f71805f_update_device(dev
);
510 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
511 int nr
= attr
->index
;
513 return sprintf(buf
, "%ld\n", temp_from_reg(data
->temp_hyst
[nr
]));
516 static ssize_t
show_temp_type(struct device
*dev
, struct device_attribute
519 struct f71805f_data
*data
= f71805f_update_device(dev
);
520 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
521 int nr
= attr
->index
;
523 /* 3 is diode, 4 is thermistor */
524 return sprintf(buf
, "%u\n", (data
->temp_mode
& (1 << nr
)) ? 3 : 4);
527 static ssize_t
set_temp_max(struct device
*dev
, struct device_attribute
528 *devattr
, const char *buf
, size_t count
)
530 struct f71805f_data
*data
= dev_get_drvdata(dev
);
531 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
532 int nr
= attr
->index
;
533 long val
= simple_strtol(buf
, NULL
, 10);
535 mutex_lock(&data
->update_lock
);
536 data
->temp_high
[nr
] = temp_to_reg(val
);
537 f71805f_write8(data
, F71805F_REG_TEMP_HIGH(nr
), data
->temp_high
[nr
]);
538 mutex_unlock(&data
->update_lock
);
543 static ssize_t
set_temp_hyst(struct device
*dev
, struct device_attribute
544 *devattr
, const char *buf
, size_t count
)
546 struct f71805f_data
*data
= dev_get_drvdata(dev
);
547 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
548 int nr
= attr
->index
;
549 long val
= simple_strtol(buf
, NULL
, 10);
551 mutex_lock(&data
->update_lock
);
552 data
->temp_hyst
[nr
] = temp_to_reg(val
);
553 f71805f_write8(data
, F71805F_REG_TEMP_HYST(nr
), data
->temp_hyst
[nr
]);
554 mutex_unlock(&data
->update_lock
);
559 static ssize_t
show_alarms_in(struct device
*dev
, struct device_attribute
562 struct f71805f_data
*data
= f71805f_update_device(dev
);
564 return sprintf(buf
, "%d\n", data
->alarms
[0] |
565 ((data
->alarms
[1] & 0x01) << 8));
568 static ssize_t
show_alarms_fan(struct device
*dev
, struct device_attribute
571 struct f71805f_data
*data
= f71805f_update_device(dev
);
573 return sprintf(buf
, "%d\n", data
->alarms
[2] & 0x07);
576 static ssize_t
show_alarms_temp(struct device
*dev
, struct device_attribute
579 struct f71805f_data
*data
= f71805f_update_device(dev
);
581 return sprintf(buf
, "%d\n", (data
->alarms
[1] >> 3) & 0x07);
584 static ssize_t
show_name(struct device
*dev
, struct device_attribute
587 struct f71805f_data
*data
= dev_get_drvdata(dev
);
589 return sprintf(buf
, "%s\n", data
->name
);
592 static struct device_attribute f71805f_dev_attr
[] = {
593 __ATTR(in0_input
, S_IRUGO
, show_in0
, NULL
),
594 __ATTR(in0_max
, S_IRUGO
| S_IWUSR
, show_in0_max
, set_in0_max
),
595 __ATTR(in0_min
, S_IRUGO
| S_IWUSR
, show_in0_min
, set_in0_min
),
596 __ATTR(alarms_in
, S_IRUGO
, show_alarms_in
, NULL
),
597 __ATTR(alarms_fan
, S_IRUGO
, show_alarms_fan
, NULL
),
598 __ATTR(alarms_temp
, S_IRUGO
, show_alarms_temp
, NULL
),
599 __ATTR(name
, S_IRUGO
, show_name
, NULL
),
602 static struct sensor_device_attribute f71805f_sensor_attr
[] = {
603 SENSOR_ATTR(in1_input
, S_IRUGO
, show_in
, NULL
, 1),
604 SENSOR_ATTR(in1_max
, S_IRUGO
| S_IWUSR
,
605 show_in_max
, set_in_max
, 1),
606 SENSOR_ATTR(in1_min
, S_IRUGO
| S_IWUSR
,
607 show_in_min
, set_in_min
, 1),
608 SENSOR_ATTR(in2_input
, S_IRUGO
, show_in
, NULL
, 2),
609 SENSOR_ATTR(in2_max
, S_IRUGO
| S_IWUSR
,
610 show_in_max
, set_in_max
, 2),
611 SENSOR_ATTR(in2_min
, S_IRUGO
| S_IWUSR
,
612 show_in_min
, set_in_min
, 2),
613 SENSOR_ATTR(in3_input
, S_IRUGO
, show_in
, NULL
, 3),
614 SENSOR_ATTR(in3_max
, S_IRUGO
| S_IWUSR
,
615 show_in_max
, set_in_max
, 3),
616 SENSOR_ATTR(in3_min
, S_IRUGO
| S_IWUSR
,
617 show_in_min
, set_in_min
, 3),
618 SENSOR_ATTR(in4_input
, S_IRUGO
, show_in
, NULL
, 4),
619 SENSOR_ATTR(in4_max
, S_IRUGO
| S_IWUSR
,
620 show_in_max
, set_in_max
, 4),
621 SENSOR_ATTR(in4_min
, S_IRUGO
| S_IWUSR
,
622 show_in_min
, set_in_min
, 4),
623 SENSOR_ATTR(in5_input
, S_IRUGO
, show_in
, NULL
, 5),
624 SENSOR_ATTR(in5_max
, S_IRUGO
| S_IWUSR
,
625 show_in_max
, set_in_max
, 5),
626 SENSOR_ATTR(in5_min
, S_IRUGO
| S_IWUSR
,
627 show_in_min
, set_in_min
, 5),
628 SENSOR_ATTR(in6_input
, S_IRUGO
, show_in
, NULL
, 6),
629 SENSOR_ATTR(in6_max
, S_IRUGO
| S_IWUSR
,
630 show_in_max
, set_in_max
, 6),
631 SENSOR_ATTR(in6_min
, S_IRUGO
| S_IWUSR
,
632 show_in_min
, set_in_min
, 6),
633 SENSOR_ATTR(in7_input
, S_IRUGO
, show_in
, NULL
, 7),
634 SENSOR_ATTR(in7_max
, S_IRUGO
| S_IWUSR
,
635 show_in_max
, set_in_max
, 7),
636 SENSOR_ATTR(in7_min
, S_IRUGO
| S_IWUSR
,
637 show_in_min
, set_in_min
, 7),
638 SENSOR_ATTR(in8_input
, S_IRUGO
, show_in
, NULL
, 8),
639 SENSOR_ATTR(in8_max
, S_IRUGO
| S_IWUSR
,
640 show_in_max
, set_in_max
, 8),
641 SENSOR_ATTR(in8_min
, S_IRUGO
| S_IWUSR
,
642 show_in_min
, set_in_min
, 8),
644 SENSOR_ATTR(temp1_input
, S_IRUGO
, show_temp
, NULL
, 0),
645 SENSOR_ATTR(temp1_max
, S_IRUGO
| S_IWUSR
,
646 show_temp_max
, set_temp_max
, 0),
647 SENSOR_ATTR(temp1_max_hyst
, S_IRUGO
| S_IWUSR
,
648 show_temp_hyst
, set_temp_hyst
, 0),
649 SENSOR_ATTR(temp1_type
, S_IRUGO
, show_temp_type
, NULL
, 0),
650 SENSOR_ATTR(temp2_input
, S_IRUGO
, show_temp
, NULL
, 1),
651 SENSOR_ATTR(temp2_max
, S_IRUGO
| S_IWUSR
,
652 show_temp_max
, set_temp_max
, 1),
653 SENSOR_ATTR(temp2_max_hyst
, S_IRUGO
| S_IWUSR
,
654 show_temp_hyst
, set_temp_hyst
, 1),
655 SENSOR_ATTR(temp2_type
, S_IRUGO
, show_temp_type
, NULL
, 1),
656 SENSOR_ATTR(temp3_input
, S_IRUGO
, show_temp
, NULL
, 2),
657 SENSOR_ATTR(temp3_max
, S_IRUGO
| S_IWUSR
,
658 show_temp_max
, set_temp_max
, 2),
659 SENSOR_ATTR(temp3_max_hyst
, S_IRUGO
| S_IWUSR
,
660 show_temp_hyst
, set_temp_hyst
, 2),
661 SENSOR_ATTR(temp3_type
, S_IRUGO
, show_temp_type
, NULL
, 2),
664 static struct sensor_device_attribute f71805f_fan_attr
[] = {
665 SENSOR_ATTR(fan1_input
, S_IRUGO
, show_fan
, NULL
, 0),
666 SENSOR_ATTR(fan1_min
, S_IRUGO
| S_IWUSR
,
667 show_fan_min
, set_fan_min
, 0),
668 SENSOR_ATTR(fan2_input
, S_IRUGO
, show_fan
, NULL
, 1),
669 SENSOR_ATTR(fan2_min
, S_IRUGO
| S_IWUSR
,
670 show_fan_min
, set_fan_min
, 1),
671 SENSOR_ATTR(fan3_input
, S_IRUGO
, show_fan
, NULL
, 2),
672 SENSOR_ATTR(fan3_min
, S_IRUGO
| S_IWUSR
,
673 show_fan_min
, set_fan_min
, 2),
677 * Device registration and initialization
680 static void __devinit
f71805f_init_device(struct f71805f_data
*data
)
685 reg
= f71805f_read8(data
, F71805F_REG_START
);
686 if ((reg
& 0x41) != 0x01) {
687 printk(KERN_DEBUG DRVNAME
": Starting monitoring "
689 f71805f_write8(data
, F71805F_REG_START
, (reg
| 0x01) & ~0x40);
692 /* Fan monitoring can be disabled. If it is, we won't be polling
693 the register values, and won't create the related sysfs files. */
694 for (i
= 0; i
< 3; i
++) {
695 reg
= f71805f_read8(data
, F71805F_REG_FAN_CTRL(i
));
697 data
->fan_enabled
|= (1 << i
);
701 static int __devinit
f71805f_probe(struct platform_device
*pdev
)
703 struct f71805f_data
*data
;
704 struct resource
*res
;
707 if (!(data
= kzalloc(sizeof(struct f71805f_data
), GFP_KERNEL
))) {
709 printk(KERN_ERR DRVNAME
": Out of memory\n");
713 res
= platform_get_resource(pdev
, IORESOURCE_IO
, 0);
714 data
->addr
= res
->start
;
715 mutex_init(&data
->lock
);
716 data
->name
= "f71805f";
717 mutex_init(&data
->update_lock
);
719 platform_set_drvdata(pdev
, data
);
721 data
->class_dev
= hwmon_device_register(&pdev
->dev
);
722 if (IS_ERR(data
->class_dev
)) {
723 err
= PTR_ERR(data
->class_dev
);
724 dev_err(&pdev
->dev
, "Class registration failed (%d)\n", err
);
728 /* Initialize the F71805F chip */
729 f71805f_init_device(data
);
731 /* Register sysfs interface files */
732 for (i
= 0; i
< ARRAY_SIZE(f71805f_dev_attr
); i
++) {
733 err
= device_create_file(&pdev
->dev
, &f71805f_dev_attr
[i
]);
737 for (i
= 0; i
< ARRAY_SIZE(f71805f_sensor_attr
); i
++) {
738 err
= device_create_file(&pdev
->dev
,
739 &f71805f_sensor_attr
[i
].dev_attr
);
743 for (i
= 0; i
< ARRAY_SIZE(f71805f_fan_attr
); i
++) {
744 if (!(data
->fan_enabled
& (1 << (i
/ 2))))
746 err
= device_create_file(&pdev
->dev
,
747 &f71805f_fan_attr
[i
].dev_attr
);
755 dev_err(&pdev
->dev
, "Sysfs interface creation failed\n");
756 hwmon_device_unregister(data
->class_dev
);
763 static int __devexit
f71805f_remove(struct platform_device
*pdev
)
765 struct f71805f_data
*data
= platform_get_drvdata(pdev
);
767 platform_set_drvdata(pdev
, NULL
);
768 hwmon_device_unregister(data
->class_dev
);
774 static struct platform_driver f71805f_driver
= {
776 .owner
= THIS_MODULE
,
779 .probe
= f71805f_probe
,
780 .remove
= __devexit_p(f71805f_remove
),
783 static int __init
f71805f_device_add(unsigned short address
)
787 pdev
= platform_device_alloc(DRVNAME
, address
);
790 printk(KERN_ERR DRVNAME
": Device allocation failed\n");
794 f71805f_resource
.start
= address
;
795 f71805f_resource
.end
= address
+ REGION_LENGTH
- 1;
796 f71805f_resource
.name
= pdev
->name
;
797 err
= platform_device_add_resources(pdev
, &f71805f_resource
, 1);
799 printk(KERN_ERR DRVNAME
": Device resource addition failed "
801 goto exit_device_put
;
804 err
= platform_device_add(pdev
);
806 printk(KERN_ERR DRVNAME
": Device addition failed (%d)\n",
808 goto exit_device_put
;
814 platform_device_put(pdev
);
819 static int __init
f71805f_find(int sioaddr
, unsigned short *address
)
824 superio_enter(sioaddr
);
826 devid
= superio_inw(sioaddr
, SIO_REG_MANID
);
827 if (devid
!= SIO_FINTEK_ID
)
830 devid
= superio_inw(sioaddr
, SIO_REG_DEVID
);
831 if (devid
!= SIO_F71805F_ID
) {
832 printk(KERN_INFO DRVNAME
": Unsupported Fintek device, "
837 superio_select(sioaddr
, F71805F_LD_HWM
);
838 if (!(superio_inb(sioaddr
, SIO_REG_ENABLE
) & 0x01)) {
839 printk(KERN_WARNING DRVNAME
": Device not activated, "
844 *address
= superio_inw(sioaddr
, SIO_REG_ADDR
);
846 printk(KERN_WARNING DRVNAME
": Base address not set, "
852 printk(KERN_INFO DRVNAME
": Found F71805F chip at %#x, revision %u\n",
853 *address
, superio_inb(sioaddr
, SIO_REG_DEVREV
));
856 superio_exit(sioaddr
);
860 static int __init
f71805f_init(void)
863 unsigned short address
;
865 if (f71805f_find(0x2e, &address
)
866 && f71805f_find(0x4e, &address
))
869 err
= platform_driver_register(&f71805f_driver
);
873 /* Sets global pdev as a side effect */
874 err
= f71805f_device_add(address
);
881 platform_driver_unregister(&f71805f_driver
);
886 static void __exit
f71805f_exit(void)
888 platform_device_unregister(pdev
);
889 platform_driver_unregister(&f71805f_driver
);
892 MODULE_AUTHOR("Jean Delvare <khali@linux-fr>");
893 MODULE_LICENSE("GPL");
894 MODULE_DESCRIPTION("F71805F hardware monitoring driver");
896 module_init(f71805f_init
);
897 module_exit(f71805f_exit
);