2 * f71805f.c - driver for the Fintek F71805F/FG and F71872F/FG Super-I/O
3 * chips integrated hardware monitoring features
4 * Copyright (C) 2005-2006 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 * The F71872F/FG is almost the same, with two more voltages monitored,
13 * The F71806F/FG is essentially the same as the F71872F/FG. It even has
14 * the same chip ID, so the driver can't differentiate between.
16 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2 of the License, or
19 * (at your option) any later version.
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
31 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
33 #include <linux/module.h>
34 #include <linux/init.h>
35 #include <linux/slab.h>
36 #include <linux/jiffies.h>
37 #include <linux/platform_device.h>
38 #include <linux/hwmon.h>
39 #include <linux/hwmon-sysfs.h>
40 #include <linux/err.h>
41 #include <linux/mutex.h>
42 #include <linux/sysfs.h>
43 #include <linux/ioport.h>
44 #include <linux/acpi.h>
47 static unsigned short force_id
;
48 module_param(force_id
, ushort
, 0);
49 MODULE_PARM_DESC(force_id
, "Override the detected device ID");
51 static struct platform_device
*pdev
;
53 #define DRVNAME "f71805f"
54 enum kinds
{ f71805f
, f71872f
};
57 * Super-I/O constants and functions
60 #define F71805F_LD_HWM 0x04
62 #define SIO_REG_LDSEL 0x07 /* Logical device select */
63 #define SIO_REG_DEVID 0x20 /* Device ID (2 bytes) */
64 #define SIO_REG_DEVREV 0x22 /* Device revision */
65 #define SIO_REG_MANID 0x23 /* Fintek ID (2 bytes) */
66 #define SIO_REG_FNSEL1 0x29 /* Multi Function Select 1 (F71872F) */
67 #define SIO_REG_ENABLE 0x30 /* Logical device enable */
68 #define SIO_REG_ADDR 0x60 /* Logical device address (2 bytes) */
70 #define SIO_FINTEK_ID 0x1934
71 #define SIO_F71805F_ID 0x0406
72 #define SIO_F71872F_ID 0x0341
75 superio_inb(int base
, int reg
)
82 superio_inw(int base
, int reg
)
86 val
= inb(base
+ 1) << 8;
93 superio_select(int base
, int ld
)
95 outb(SIO_REG_LDSEL
, base
);
100 superio_enter(int base
)
107 superio_exit(int base
)
116 #define REGION_LENGTH 8
117 #define ADDR_REG_OFFSET 5
118 #define DATA_REG_OFFSET 6
124 /* in nr from 0 to 10 (8-bit values) */
125 #define F71805F_REG_IN(nr) (0x10 + (nr))
126 #define F71805F_REG_IN_HIGH(nr) ((nr) < 10 ? 0x40 + 2 * (nr) : 0x2E)
127 #define F71805F_REG_IN_LOW(nr) ((nr) < 10 ? 0x41 + 2 * (nr) : 0x2F)
128 /* fan nr from 0 to 2 (12-bit values, two registers) */
129 #define F71805F_REG_FAN(nr) (0x20 + 2 * (nr))
130 #define F71805F_REG_FAN_LOW(nr) (0x28 + 2 * (nr))
131 #define F71805F_REG_FAN_TARGET(nr) (0x69 + 16 * (nr))
132 #define F71805F_REG_FAN_CTRL(nr) (0x60 + 16 * (nr))
133 #define F71805F_REG_PWM_FREQ(nr) (0x63 + 16 * (nr))
134 #define F71805F_REG_PWM_DUTY(nr) (0x6B + 16 * (nr))
135 /* temp nr from 0 to 2 (8-bit values) */
136 #define F71805F_REG_TEMP(nr) (0x1B + (nr))
137 #define F71805F_REG_TEMP_HIGH(nr) (0x54 + 2 * (nr))
138 #define F71805F_REG_TEMP_HYST(nr) (0x55 + 2 * (nr))
139 #define F71805F_REG_TEMP_MODE 0x01
140 /* pwm/fan pwmnr from 0 to 2, auto point apnr from 0 to 2 */
141 /* map Fintek numbers to our numbers as follows: 9->0, 5->1, 1->2 */
142 #define F71805F_REG_PWM_AUTO_POINT_TEMP(pwmnr, apnr) \
143 (0xA0 + 0x10 * (pwmnr) + (2 - (apnr)))
144 #define F71805F_REG_PWM_AUTO_POINT_FAN(pwmnr, apnr) \
145 (0xA4 + 0x10 * (pwmnr) + \
148 #define F71805F_REG_START 0x00
149 /* status nr from 0 to 2 */
150 #define F71805F_REG_STATUS(nr) (0x36 + (nr))
152 /* individual register bits */
153 #define FAN_CTRL_DC_MODE 0x10
154 #define FAN_CTRL_LATCH_FULL 0x08
155 #define FAN_CTRL_MODE_MASK 0x03
156 #define FAN_CTRL_MODE_SPEED 0x00
157 #define FAN_CTRL_MODE_TEMPERATURE 0x01
158 #define FAN_CTRL_MODE_MANUAL 0x02
161 * Data structures and manipulation thereof
164 struct f71805f_auto_point
{
169 struct f71805f_data
{
172 struct device
*hwmon_dev
;
174 struct mutex update_lock
;
175 char valid
; /* !=0 if following fields are valid */
176 unsigned long last_updated
; /* In jiffies */
177 unsigned long last_limits
; /* In jiffies */
179 /* Register values */
194 unsigned long alarms
;
195 struct f71805f_auto_point auto_points
[3];
198 struct f71805f_sio_data
{
203 static inline long in_from_reg(u8 reg
)
208 /* The 2 least significant bits are not used */
209 static inline u8
in_to_reg(long val
)
215 return ((val
+ 16) / 32) << 2;
218 /* in0 is downscaled by a factor 2 internally */
219 static inline long in0_from_reg(u8 reg
)
224 static inline u8
in0_to_reg(long val
)
230 return ((val
+ 32) / 64) << 2;
233 /* The 4 most significant bits are not used */
234 static inline long fan_from_reg(u16 reg
)
237 if (!reg
|| reg
== 0xfff)
239 return 1500000 / reg
;
242 static inline u16
fan_to_reg(long rpm
)
245 * If the low limit is set below what the chip can measure,
246 * store the largest possible 12-bit value in the registers,
247 * so that no alarm will ever trigger.
251 return 1500000 / rpm
;
254 static inline unsigned long pwm_freq_from_reg(u8 reg
)
256 unsigned long clock
= (reg
& 0x80) ? 48000000UL : 1000000UL;
261 return clock
/ (reg
<< 8);
264 static inline u8
pwm_freq_to_reg(unsigned long val
)
266 if (val
>= 187500) /* The highest we can do */
268 if (val
>= 1475) /* Use 48 MHz clock */
269 return 0x80 | (48000000UL / (val
<< 8));
270 if (val
< 31) /* The lowest we can do */
272 else /* Use 1 MHz clock */
273 return 1000000UL / (val
<< 8);
276 static inline int pwm_mode_from_reg(u8 reg
)
278 return !(reg
& FAN_CTRL_DC_MODE
);
281 static inline long temp_from_reg(u8 reg
)
286 static inline u8
temp_to_reg(long val
)
290 if (val
>= 1000 * 0xff)
292 return (val
+ 500) / 1000;
299 /* Must be called with data->update_lock held, except during initialization */
300 static u8
f71805f_read8(struct f71805f_data
*data
, u8 reg
)
302 outb(reg
, data
->addr
+ ADDR_REG_OFFSET
);
303 return inb(data
->addr
+ DATA_REG_OFFSET
);
306 /* Must be called with data->update_lock held, except during initialization */
307 static void f71805f_write8(struct f71805f_data
*data
, u8 reg
, u8 val
)
309 outb(reg
, data
->addr
+ ADDR_REG_OFFSET
);
310 outb(val
, data
->addr
+ DATA_REG_OFFSET
);
314 * It is important to read the MSB first, because doing so latches the
315 * value of the LSB, so we are sure both bytes belong to the same value.
316 * Must be called with data->update_lock held, except during initialization
318 static u16
f71805f_read16(struct f71805f_data
*data
, u8 reg
)
322 outb(reg
, data
->addr
+ ADDR_REG_OFFSET
);
323 val
= inb(data
->addr
+ DATA_REG_OFFSET
) << 8;
324 outb(++reg
, data
->addr
+ ADDR_REG_OFFSET
);
325 val
|= inb(data
->addr
+ DATA_REG_OFFSET
);
330 /* Must be called with data->update_lock held, except during initialization */
331 static void f71805f_write16(struct f71805f_data
*data
, u8 reg
, u16 val
)
333 outb(reg
, data
->addr
+ ADDR_REG_OFFSET
);
334 outb(val
>> 8, data
->addr
+ DATA_REG_OFFSET
);
335 outb(++reg
, data
->addr
+ ADDR_REG_OFFSET
);
336 outb(val
& 0xff, data
->addr
+ DATA_REG_OFFSET
);
339 static struct f71805f_data
*f71805f_update_device(struct device
*dev
)
341 struct f71805f_data
*data
= dev_get_drvdata(dev
);
344 mutex_lock(&data
->update_lock
);
346 /* Limit registers cache is refreshed after 60 seconds */
347 if (time_after(jiffies
, data
->last_updated
+ 60 * HZ
)
349 for (nr
= 0; nr
< 11; nr
++) {
350 if (!(data
->has_in
& (1 << nr
)))
352 data
->in_high
[nr
] = f71805f_read8(data
,
353 F71805F_REG_IN_HIGH(nr
));
354 data
->in_low
[nr
] = f71805f_read8(data
,
355 F71805F_REG_IN_LOW(nr
));
357 for (nr
= 0; nr
< 3; nr
++) {
358 data
->fan_low
[nr
] = f71805f_read16(data
,
359 F71805F_REG_FAN_LOW(nr
));
360 data
->fan_target
[nr
] = f71805f_read16(data
,
361 F71805F_REG_FAN_TARGET(nr
));
362 data
->pwm_freq
[nr
] = f71805f_read8(data
,
363 F71805F_REG_PWM_FREQ(nr
));
365 for (nr
= 0; nr
< 3; nr
++) {
366 data
->temp_high
[nr
] = f71805f_read8(data
,
367 F71805F_REG_TEMP_HIGH(nr
));
368 data
->temp_hyst
[nr
] = f71805f_read8(data
,
369 F71805F_REG_TEMP_HYST(nr
));
371 data
->temp_mode
= f71805f_read8(data
, F71805F_REG_TEMP_MODE
);
372 for (nr
= 0; nr
< 3; nr
++) {
373 for (apnr
= 0; apnr
< 3; apnr
++) {
374 data
->auto_points
[nr
].temp
[apnr
] =
376 F71805F_REG_PWM_AUTO_POINT_TEMP(nr
,
378 data
->auto_points
[nr
].fan
[apnr
] =
380 F71805F_REG_PWM_AUTO_POINT_FAN(nr
,
385 data
->last_limits
= jiffies
;
388 /* Measurement registers cache is refreshed after 1 second */
389 if (time_after(jiffies
, data
->last_updated
+ HZ
)
391 for (nr
= 0; nr
< 11; nr
++) {
392 if (!(data
->has_in
& (1 << nr
)))
394 data
->in
[nr
] = f71805f_read8(data
,
397 for (nr
= 0; nr
< 3; nr
++) {
398 data
->fan
[nr
] = f71805f_read16(data
,
399 F71805F_REG_FAN(nr
));
400 data
->fan_ctrl
[nr
] = f71805f_read8(data
,
401 F71805F_REG_FAN_CTRL(nr
));
402 data
->pwm
[nr
] = f71805f_read8(data
,
403 F71805F_REG_PWM_DUTY(nr
));
405 for (nr
= 0; nr
< 3; nr
++) {
406 data
->temp
[nr
] = f71805f_read8(data
,
407 F71805F_REG_TEMP(nr
));
409 data
->alarms
= f71805f_read8(data
, F71805F_REG_STATUS(0))
410 + (f71805f_read8(data
, F71805F_REG_STATUS(1)) << 8)
411 + (f71805f_read8(data
, F71805F_REG_STATUS(2)) << 16);
413 data
->last_updated
= jiffies
;
417 mutex_unlock(&data
->update_lock
);
426 static ssize_t
show_in0(struct device
*dev
, struct device_attribute
*devattr
,
429 struct f71805f_data
*data
= f71805f_update_device(dev
);
430 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
431 int nr
= attr
->index
;
433 return sprintf(buf
, "%ld\n", in0_from_reg(data
->in
[nr
]));
436 static ssize_t
show_in0_max(struct device
*dev
, struct device_attribute
439 struct f71805f_data
*data
= f71805f_update_device(dev
);
440 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
441 int nr
= attr
->index
;
443 return sprintf(buf
, "%ld\n", in0_from_reg(data
->in_high
[nr
]));
446 static ssize_t
show_in0_min(struct device
*dev
, struct device_attribute
449 struct f71805f_data
*data
= f71805f_update_device(dev
);
450 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
451 int nr
= attr
->index
;
453 return sprintf(buf
, "%ld\n", in0_from_reg(data
->in_low
[nr
]));
456 static ssize_t
set_in0_max(struct device
*dev
, struct device_attribute
457 *devattr
, const char *buf
, size_t count
)
459 struct f71805f_data
*data
= dev_get_drvdata(dev
);
460 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
461 int nr
= attr
->index
;
465 err
= kstrtol(buf
, 10, &val
);
469 mutex_lock(&data
->update_lock
);
470 data
->in_high
[nr
] = in0_to_reg(val
);
471 f71805f_write8(data
, F71805F_REG_IN_HIGH(nr
), data
->in_high
[nr
]);
472 mutex_unlock(&data
->update_lock
);
477 static ssize_t
set_in0_min(struct device
*dev
, struct device_attribute
478 *devattr
, const char *buf
, size_t count
)
480 struct f71805f_data
*data
= dev_get_drvdata(dev
);
481 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
482 int nr
= attr
->index
;
486 err
= kstrtol(buf
, 10, &val
);
490 mutex_lock(&data
->update_lock
);
491 data
->in_low
[nr
] = in0_to_reg(val
);
492 f71805f_write8(data
, F71805F_REG_IN_LOW(nr
), data
->in_low
[nr
]);
493 mutex_unlock(&data
->update_lock
);
498 static ssize_t
show_in(struct device
*dev
, struct device_attribute
*devattr
,
501 struct f71805f_data
*data
= f71805f_update_device(dev
);
502 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
503 int nr
= attr
->index
;
505 return sprintf(buf
, "%ld\n", in_from_reg(data
->in
[nr
]));
508 static ssize_t
show_in_max(struct device
*dev
, struct device_attribute
511 struct f71805f_data
*data
= f71805f_update_device(dev
);
512 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
513 int nr
= attr
->index
;
515 return sprintf(buf
, "%ld\n", in_from_reg(data
->in_high
[nr
]));
518 static ssize_t
show_in_min(struct device
*dev
, struct device_attribute
521 struct f71805f_data
*data
= f71805f_update_device(dev
);
522 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
523 int nr
= attr
->index
;
525 return sprintf(buf
, "%ld\n", in_from_reg(data
->in_low
[nr
]));
528 static ssize_t
set_in_max(struct device
*dev
, struct device_attribute
529 *devattr
, const char *buf
, size_t count
)
531 struct f71805f_data
*data
= dev_get_drvdata(dev
);
532 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
533 int nr
= attr
->index
;
537 err
= kstrtol(buf
, 10, &val
);
541 mutex_lock(&data
->update_lock
);
542 data
->in_high
[nr
] = in_to_reg(val
);
543 f71805f_write8(data
, F71805F_REG_IN_HIGH(nr
), data
->in_high
[nr
]);
544 mutex_unlock(&data
->update_lock
);
549 static ssize_t
set_in_min(struct device
*dev
, struct device_attribute
550 *devattr
, const char *buf
, size_t count
)
552 struct f71805f_data
*data
= dev_get_drvdata(dev
);
553 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
554 int nr
= attr
->index
;
558 err
= kstrtol(buf
, 10, &val
);
562 mutex_lock(&data
->update_lock
);
563 data
->in_low
[nr
] = in_to_reg(val
);
564 f71805f_write8(data
, F71805F_REG_IN_LOW(nr
), data
->in_low
[nr
]);
565 mutex_unlock(&data
->update_lock
);
570 static ssize_t
show_fan(struct device
*dev
, struct device_attribute
*devattr
,
573 struct f71805f_data
*data
= f71805f_update_device(dev
);
574 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
575 int nr
= attr
->index
;
577 return sprintf(buf
, "%ld\n", fan_from_reg(data
->fan
[nr
]));
580 static ssize_t
show_fan_min(struct device
*dev
, struct device_attribute
583 struct f71805f_data
*data
= f71805f_update_device(dev
);
584 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
585 int nr
= attr
->index
;
587 return sprintf(buf
, "%ld\n", fan_from_reg(data
->fan_low
[nr
]));
590 static ssize_t
show_fan_target(struct device
*dev
, struct device_attribute
593 struct f71805f_data
*data
= f71805f_update_device(dev
);
594 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
595 int nr
= attr
->index
;
597 return sprintf(buf
, "%ld\n", fan_from_reg(data
->fan_target
[nr
]));
600 static ssize_t
set_fan_min(struct device
*dev
, struct device_attribute
601 *devattr
, const char *buf
, size_t count
)
603 struct f71805f_data
*data
= dev_get_drvdata(dev
);
604 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
605 int nr
= attr
->index
;
609 err
= kstrtol(buf
, 10, &val
);
613 mutex_lock(&data
->update_lock
);
614 data
->fan_low
[nr
] = fan_to_reg(val
);
615 f71805f_write16(data
, F71805F_REG_FAN_LOW(nr
), data
->fan_low
[nr
]);
616 mutex_unlock(&data
->update_lock
);
621 static ssize_t
set_fan_target(struct device
*dev
, struct device_attribute
622 *devattr
, const char *buf
, size_t count
)
624 struct f71805f_data
*data
= dev_get_drvdata(dev
);
625 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
626 int nr
= attr
->index
;
630 err
= kstrtol(buf
, 10, &val
);
634 mutex_lock(&data
->update_lock
);
635 data
->fan_target
[nr
] = fan_to_reg(val
);
636 f71805f_write16(data
, F71805F_REG_FAN_TARGET(nr
),
637 data
->fan_target
[nr
]);
638 mutex_unlock(&data
->update_lock
);
643 static ssize_t
show_pwm(struct device
*dev
, struct device_attribute
*devattr
,
646 struct f71805f_data
*data
= f71805f_update_device(dev
);
647 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
648 int nr
= attr
->index
;
650 return sprintf(buf
, "%d\n", (int)data
->pwm
[nr
]);
653 static ssize_t
show_pwm_enable(struct device
*dev
, struct device_attribute
656 struct f71805f_data
*data
= f71805f_update_device(dev
);
657 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
658 int nr
= attr
->index
;
661 switch (data
->fan_ctrl
[nr
] & FAN_CTRL_MODE_MASK
) {
662 case FAN_CTRL_MODE_SPEED
:
665 case FAN_CTRL_MODE_TEMPERATURE
:
668 default: /* MANUAL */
672 return sprintf(buf
, "%d\n", mode
);
675 static ssize_t
show_pwm_freq(struct device
*dev
, struct device_attribute
678 struct f71805f_data
*data
= f71805f_update_device(dev
);
679 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
680 int nr
= attr
->index
;
682 return sprintf(buf
, "%lu\n", pwm_freq_from_reg(data
->pwm_freq
[nr
]));
685 static ssize_t
show_pwm_mode(struct device
*dev
, struct device_attribute
688 struct f71805f_data
*data
= f71805f_update_device(dev
);
689 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
690 int nr
= attr
->index
;
692 return sprintf(buf
, "%d\n", pwm_mode_from_reg(data
->fan_ctrl
[nr
]));
695 static ssize_t
set_pwm(struct device
*dev
, struct device_attribute
*devattr
,
696 const char *buf
, size_t count
)
698 struct f71805f_data
*data
= dev_get_drvdata(dev
);
699 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
700 int nr
= attr
->index
;
704 err
= kstrtoul(buf
, 10, &val
);
711 mutex_lock(&data
->update_lock
);
713 f71805f_write8(data
, F71805F_REG_PWM_DUTY(nr
), data
->pwm
[nr
]);
714 mutex_unlock(&data
->update_lock
);
719 static struct attribute
*f71805f_attr_pwm
[];
721 static ssize_t
set_pwm_enable(struct device
*dev
, struct device_attribute
722 *devattr
, const char *buf
, size_t count
)
724 struct f71805f_data
*data
= dev_get_drvdata(dev
);
725 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
726 int nr
= attr
->index
;
731 err
= kstrtoul(buf
, 10, &val
);
735 if (val
< 1 || val
> 3)
738 if (val
> 1) { /* Automatic mode, user can't set PWM value */
739 if (sysfs_chmod_file(&dev
->kobj
, f71805f_attr_pwm
[nr
],
741 dev_dbg(dev
, "chmod -w pwm%d failed\n", nr
+ 1);
744 mutex_lock(&data
->update_lock
);
745 reg
= f71805f_read8(data
, F71805F_REG_FAN_CTRL(nr
))
746 & ~FAN_CTRL_MODE_MASK
;
749 reg
|= FAN_CTRL_MODE_MANUAL
;
752 reg
|= FAN_CTRL_MODE_TEMPERATURE
;
755 reg
|= FAN_CTRL_MODE_SPEED
;
758 data
->fan_ctrl
[nr
] = reg
;
759 f71805f_write8(data
, F71805F_REG_FAN_CTRL(nr
), reg
);
760 mutex_unlock(&data
->update_lock
);
762 if (val
== 1) { /* Manual mode, user can set PWM value */
763 if (sysfs_chmod_file(&dev
->kobj
, f71805f_attr_pwm
[nr
],
765 dev_dbg(dev
, "chmod +w pwm%d failed\n", nr
+ 1);
771 static ssize_t
set_pwm_freq(struct device
*dev
, struct device_attribute
772 *devattr
, const char *buf
, size_t count
)
774 struct f71805f_data
*data
= dev_get_drvdata(dev
);
775 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
776 int nr
= attr
->index
;
780 err
= kstrtoul(buf
, 10, &val
);
784 mutex_lock(&data
->update_lock
);
785 data
->pwm_freq
[nr
] = pwm_freq_to_reg(val
);
786 f71805f_write8(data
, F71805F_REG_PWM_FREQ(nr
), data
->pwm_freq
[nr
]);
787 mutex_unlock(&data
->update_lock
);
792 static ssize_t
show_pwm_auto_point_temp(struct device
*dev
,
793 struct device_attribute
*devattr
,
796 struct f71805f_data
*data
= dev_get_drvdata(dev
);
797 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
798 int pwmnr
= attr
->nr
;
799 int apnr
= attr
->index
;
801 return sprintf(buf
, "%ld\n",
802 temp_from_reg(data
->auto_points
[pwmnr
].temp
[apnr
]));
805 static ssize_t
set_pwm_auto_point_temp(struct device
*dev
,
806 struct device_attribute
*devattr
,
807 const char *buf
, size_t count
)
809 struct f71805f_data
*data
= dev_get_drvdata(dev
);
810 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
811 int pwmnr
= attr
->nr
;
812 int apnr
= attr
->index
;
816 err
= kstrtoul(buf
, 10, &val
);
820 mutex_lock(&data
->update_lock
);
821 data
->auto_points
[pwmnr
].temp
[apnr
] = temp_to_reg(val
);
822 f71805f_write8(data
, F71805F_REG_PWM_AUTO_POINT_TEMP(pwmnr
, apnr
),
823 data
->auto_points
[pwmnr
].temp
[apnr
]);
824 mutex_unlock(&data
->update_lock
);
829 static ssize_t
show_pwm_auto_point_fan(struct device
*dev
,
830 struct device_attribute
*devattr
,
833 struct f71805f_data
*data
= dev_get_drvdata(dev
);
834 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
835 int pwmnr
= attr
->nr
;
836 int apnr
= attr
->index
;
838 return sprintf(buf
, "%ld\n",
839 fan_from_reg(data
->auto_points
[pwmnr
].fan
[apnr
]));
842 static ssize_t
set_pwm_auto_point_fan(struct device
*dev
,
843 struct device_attribute
*devattr
,
844 const char *buf
, size_t count
)
846 struct f71805f_data
*data
= dev_get_drvdata(dev
);
847 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
848 int pwmnr
= attr
->nr
;
849 int apnr
= attr
->index
;
853 err
= kstrtoul(buf
, 10, &val
);
857 mutex_lock(&data
->update_lock
);
858 data
->auto_points
[pwmnr
].fan
[apnr
] = fan_to_reg(val
);
859 f71805f_write16(data
, F71805F_REG_PWM_AUTO_POINT_FAN(pwmnr
, apnr
),
860 data
->auto_points
[pwmnr
].fan
[apnr
]);
861 mutex_unlock(&data
->update_lock
);
866 static ssize_t
show_temp(struct device
*dev
, struct device_attribute
*devattr
,
869 struct f71805f_data
*data
= f71805f_update_device(dev
);
870 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
871 int nr
= attr
->index
;
873 return sprintf(buf
, "%ld\n", temp_from_reg(data
->temp
[nr
]));
876 static ssize_t
show_temp_max(struct device
*dev
, struct device_attribute
879 struct f71805f_data
*data
= f71805f_update_device(dev
);
880 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
881 int nr
= attr
->index
;
883 return sprintf(buf
, "%ld\n", temp_from_reg(data
->temp_high
[nr
]));
886 static ssize_t
show_temp_hyst(struct device
*dev
, struct device_attribute
889 struct f71805f_data
*data
= f71805f_update_device(dev
);
890 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
891 int nr
= attr
->index
;
893 return sprintf(buf
, "%ld\n", temp_from_reg(data
->temp_hyst
[nr
]));
896 static ssize_t
show_temp_type(struct device
*dev
, struct device_attribute
899 struct f71805f_data
*data
= f71805f_update_device(dev
);
900 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
901 int nr
= attr
->index
;
903 /* 3 is diode, 4 is thermistor */
904 return sprintf(buf
, "%u\n", (data
->temp_mode
& (1 << nr
)) ? 3 : 4);
907 static ssize_t
set_temp_max(struct device
*dev
, struct device_attribute
908 *devattr
, const char *buf
, size_t count
)
910 struct f71805f_data
*data
= dev_get_drvdata(dev
);
911 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
912 int nr
= attr
->index
;
916 err
= kstrtol(buf
, 10, &val
);
920 mutex_lock(&data
->update_lock
);
921 data
->temp_high
[nr
] = temp_to_reg(val
);
922 f71805f_write8(data
, F71805F_REG_TEMP_HIGH(nr
), data
->temp_high
[nr
]);
923 mutex_unlock(&data
->update_lock
);
928 static ssize_t
set_temp_hyst(struct device
*dev
, struct device_attribute
929 *devattr
, const char *buf
, size_t count
)
931 struct f71805f_data
*data
= dev_get_drvdata(dev
);
932 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
933 int nr
= attr
->index
;
937 err
= kstrtol(buf
, 10, &val
);
941 mutex_lock(&data
->update_lock
);
942 data
->temp_hyst
[nr
] = temp_to_reg(val
);
943 f71805f_write8(data
, F71805F_REG_TEMP_HYST(nr
), data
->temp_hyst
[nr
]);
944 mutex_unlock(&data
->update_lock
);
949 static ssize_t
show_alarms_in(struct device
*dev
, struct device_attribute
952 struct f71805f_data
*data
= f71805f_update_device(dev
);
954 return sprintf(buf
, "%lu\n", data
->alarms
& 0x7ff);
957 static ssize_t
show_alarms_fan(struct device
*dev
, struct device_attribute
960 struct f71805f_data
*data
= f71805f_update_device(dev
);
962 return sprintf(buf
, "%lu\n", (data
->alarms
>> 16) & 0x07);
965 static ssize_t
show_alarms_temp(struct device
*dev
, struct device_attribute
968 struct f71805f_data
*data
= f71805f_update_device(dev
);
970 return sprintf(buf
, "%lu\n", (data
->alarms
>> 11) & 0x07);
973 static ssize_t
show_alarm(struct device
*dev
, struct device_attribute
976 struct f71805f_data
*data
= f71805f_update_device(dev
);
977 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
978 int bitnr
= attr
->index
;
980 return sprintf(buf
, "%lu\n", (data
->alarms
>> bitnr
) & 1);
983 static ssize_t
show_name(struct device
*dev
, struct device_attribute
986 struct f71805f_data
*data
= dev_get_drvdata(dev
);
988 return sprintf(buf
, "%s\n", data
->name
);
991 static SENSOR_DEVICE_ATTR(in0_input
, S_IRUGO
, show_in0
, NULL
, 0);
992 static SENSOR_DEVICE_ATTR(in0_max
, S_IRUGO
| S_IWUSR
,
993 show_in0_max
, set_in0_max
, 0);
994 static SENSOR_DEVICE_ATTR(in0_min
, S_IRUGO
| S_IWUSR
,
995 show_in0_min
, set_in0_min
, 0);
996 static SENSOR_DEVICE_ATTR(in1_input
, S_IRUGO
, show_in
, NULL
, 1);
997 static SENSOR_DEVICE_ATTR(in1_max
, S_IRUGO
| S_IWUSR
,
998 show_in_max
, set_in_max
, 1);
999 static SENSOR_DEVICE_ATTR(in1_min
, S_IRUGO
| S_IWUSR
,
1000 show_in_min
, set_in_min
, 1);
1001 static SENSOR_DEVICE_ATTR(in2_input
, S_IRUGO
, show_in
, NULL
, 2);
1002 static SENSOR_DEVICE_ATTR(in2_max
, S_IRUGO
| S_IWUSR
,
1003 show_in_max
, set_in_max
, 2);
1004 static SENSOR_DEVICE_ATTR(in2_min
, S_IRUGO
| S_IWUSR
,
1005 show_in_min
, set_in_min
, 2);
1006 static SENSOR_DEVICE_ATTR(in3_input
, S_IRUGO
, show_in
, NULL
, 3);
1007 static SENSOR_DEVICE_ATTR(in3_max
, S_IRUGO
| S_IWUSR
,
1008 show_in_max
, set_in_max
, 3);
1009 static SENSOR_DEVICE_ATTR(in3_min
, S_IRUGO
| S_IWUSR
,
1010 show_in_min
, set_in_min
, 3);
1011 static SENSOR_DEVICE_ATTR(in4_input
, S_IRUGO
, show_in
, NULL
, 4);
1012 static SENSOR_DEVICE_ATTR(in4_max
, S_IRUGO
| S_IWUSR
,
1013 show_in_max
, set_in_max
, 4);
1014 static SENSOR_DEVICE_ATTR(in4_min
, S_IRUGO
| S_IWUSR
,
1015 show_in_min
, set_in_min
, 4);
1016 static SENSOR_DEVICE_ATTR(in5_input
, S_IRUGO
, show_in
, NULL
, 5);
1017 static SENSOR_DEVICE_ATTR(in5_max
, S_IRUGO
| S_IWUSR
,
1018 show_in_max
, set_in_max
, 5);
1019 static SENSOR_DEVICE_ATTR(in5_min
, S_IRUGO
| S_IWUSR
,
1020 show_in_min
, set_in_min
, 5);
1021 static SENSOR_DEVICE_ATTR(in6_input
, S_IRUGO
, show_in
, NULL
, 6);
1022 static SENSOR_DEVICE_ATTR(in6_max
, S_IRUGO
| S_IWUSR
,
1023 show_in_max
, set_in_max
, 6);
1024 static SENSOR_DEVICE_ATTR(in6_min
, S_IRUGO
| S_IWUSR
,
1025 show_in_min
, set_in_min
, 6);
1026 static SENSOR_DEVICE_ATTR(in7_input
, S_IRUGO
, show_in
, NULL
, 7);
1027 static SENSOR_DEVICE_ATTR(in7_max
, S_IRUGO
| S_IWUSR
,
1028 show_in_max
, set_in_max
, 7);
1029 static SENSOR_DEVICE_ATTR(in7_min
, S_IRUGO
| S_IWUSR
,
1030 show_in_min
, set_in_min
, 7);
1031 static SENSOR_DEVICE_ATTR(in8_input
, S_IRUGO
, show_in
, NULL
, 8);
1032 static SENSOR_DEVICE_ATTR(in8_max
, S_IRUGO
| S_IWUSR
,
1033 show_in_max
, set_in_max
, 8);
1034 static SENSOR_DEVICE_ATTR(in8_min
, S_IRUGO
| S_IWUSR
,
1035 show_in_min
, set_in_min
, 8);
1036 static SENSOR_DEVICE_ATTR(in9_input
, S_IRUGO
, show_in0
, NULL
, 9);
1037 static SENSOR_DEVICE_ATTR(in9_max
, S_IRUGO
| S_IWUSR
,
1038 show_in0_max
, set_in0_max
, 9);
1039 static SENSOR_DEVICE_ATTR(in9_min
, S_IRUGO
| S_IWUSR
,
1040 show_in0_min
, set_in0_min
, 9);
1041 static SENSOR_DEVICE_ATTR(in10_input
, S_IRUGO
, show_in0
, NULL
, 10);
1042 static SENSOR_DEVICE_ATTR(in10_max
, S_IRUGO
| S_IWUSR
,
1043 show_in0_max
, set_in0_max
, 10);
1044 static SENSOR_DEVICE_ATTR(in10_min
, S_IRUGO
| S_IWUSR
,
1045 show_in0_min
, set_in0_min
, 10);
1047 static SENSOR_DEVICE_ATTR(fan1_input
, S_IRUGO
, show_fan
, NULL
, 0);
1048 static SENSOR_DEVICE_ATTR(fan1_min
, S_IRUGO
| S_IWUSR
,
1049 show_fan_min
, set_fan_min
, 0);
1050 static SENSOR_DEVICE_ATTR(fan1_target
, S_IRUGO
| S_IWUSR
,
1051 show_fan_target
, set_fan_target
, 0);
1052 static SENSOR_DEVICE_ATTR(fan2_input
, S_IRUGO
, show_fan
, NULL
, 1);
1053 static SENSOR_DEVICE_ATTR(fan2_min
, S_IRUGO
| S_IWUSR
,
1054 show_fan_min
, set_fan_min
, 1);
1055 static SENSOR_DEVICE_ATTR(fan2_target
, S_IRUGO
| S_IWUSR
,
1056 show_fan_target
, set_fan_target
, 1);
1057 static SENSOR_DEVICE_ATTR(fan3_input
, S_IRUGO
, show_fan
, NULL
, 2);
1058 static SENSOR_DEVICE_ATTR(fan3_min
, S_IRUGO
| S_IWUSR
,
1059 show_fan_min
, set_fan_min
, 2);
1060 static SENSOR_DEVICE_ATTR(fan3_target
, S_IRUGO
| S_IWUSR
,
1061 show_fan_target
, set_fan_target
, 2);
1063 static SENSOR_DEVICE_ATTR(temp1_input
, S_IRUGO
, show_temp
, NULL
, 0);
1064 static SENSOR_DEVICE_ATTR(temp1_max
, S_IRUGO
| S_IWUSR
,
1065 show_temp_max
, set_temp_max
, 0);
1066 static SENSOR_DEVICE_ATTR(temp1_max_hyst
, S_IRUGO
| S_IWUSR
,
1067 show_temp_hyst
, set_temp_hyst
, 0);
1068 static SENSOR_DEVICE_ATTR(temp1_type
, S_IRUGO
, show_temp_type
, NULL
, 0);
1069 static SENSOR_DEVICE_ATTR(temp2_input
, S_IRUGO
, show_temp
, NULL
, 1);
1070 static SENSOR_DEVICE_ATTR(temp2_max
, S_IRUGO
| S_IWUSR
,
1071 show_temp_max
, set_temp_max
, 1);
1072 static SENSOR_DEVICE_ATTR(temp2_max_hyst
, S_IRUGO
| S_IWUSR
,
1073 show_temp_hyst
, set_temp_hyst
, 1);
1074 static SENSOR_DEVICE_ATTR(temp2_type
, S_IRUGO
, show_temp_type
, NULL
, 1);
1075 static SENSOR_DEVICE_ATTR(temp3_input
, S_IRUGO
, show_temp
, NULL
, 2);
1076 static SENSOR_DEVICE_ATTR(temp3_max
, S_IRUGO
| S_IWUSR
,
1077 show_temp_max
, set_temp_max
, 2);
1078 static SENSOR_DEVICE_ATTR(temp3_max_hyst
, S_IRUGO
| S_IWUSR
,
1079 show_temp_hyst
, set_temp_hyst
, 2);
1080 static SENSOR_DEVICE_ATTR(temp3_type
, S_IRUGO
, show_temp_type
, NULL
, 2);
1083 * pwm (value) files are created read-only, write permission is
1084 * then added or removed dynamically as needed
1086 static SENSOR_DEVICE_ATTR(pwm1
, S_IRUGO
, show_pwm
, set_pwm
, 0);
1087 static SENSOR_DEVICE_ATTR(pwm1_enable
, S_IRUGO
| S_IWUSR
,
1088 show_pwm_enable
, set_pwm_enable
, 0);
1089 static SENSOR_DEVICE_ATTR(pwm1_freq
, S_IRUGO
| S_IWUSR
,
1090 show_pwm_freq
, set_pwm_freq
, 0);
1091 static SENSOR_DEVICE_ATTR(pwm1_mode
, S_IRUGO
, show_pwm_mode
, NULL
, 0);
1092 static SENSOR_DEVICE_ATTR(pwm2
, S_IRUGO
, show_pwm
, set_pwm
, 1);
1093 static SENSOR_DEVICE_ATTR(pwm2_enable
, S_IRUGO
| S_IWUSR
,
1094 show_pwm_enable
, set_pwm_enable
, 1);
1095 static SENSOR_DEVICE_ATTR(pwm2_freq
, S_IRUGO
| S_IWUSR
,
1096 show_pwm_freq
, set_pwm_freq
, 1);
1097 static SENSOR_DEVICE_ATTR(pwm2_mode
, S_IRUGO
, show_pwm_mode
, NULL
, 1);
1098 static SENSOR_DEVICE_ATTR(pwm3
, S_IRUGO
, show_pwm
, set_pwm
, 2);
1099 static SENSOR_DEVICE_ATTR(pwm3_enable
, S_IRUGO
| S_IWUSR
,
1100 show_pwm_enable
, set_pwm_enable
, 2);
1101 static SENSOR_DEVICE_ATTR(pwm3_freq
, S_IRUGO
| S_IWUSR
,
1102 show_pwm_freq
, set_pwm_freq
, 2);
1103 static SENSOR_DEVICE_ATTR(pwm3_mode
, S_IRUGO
, show_pwm_mode
, NULL
, 2);
1105 static SENSOR_DEVICE_ATTR_2(pwm1_auto_point1_temp
, S_IRUGO
| S_IWUSR
,
1106 show_pwm_auto_point_temp
, set_pwm_auto_point_temp
,
1108 static SENSOR_DEVICE_ATTR_2(pwm1_auto_point1_fan
, S_IRUGO
| S_IWUSR
,
1109 show_pwm_auto_point_fan
, set_pwm_auto_point_fan
,
1111 static SENSOR_DEVICE_ATTR_2(pwm1_auto_point2_temp
, S_IRUGO
| S_IWUSR
,
1112 show_pwm_auto_point_temp
, set_pwm_auto_point_temp
,
1114 static SENSOR_DEVICE_ATTR_2(pwm1_auto_point2_fan
, S_IRUGO
| S_IWUSR
,
1115 show_pwm_auto_point_fan
, set_pwm_auto_point_fan
,
1117 static SENSOR_DEVICE_ATTR_2(pwm1_auto_point3_temp
, S_IRUGO
| S_IWUSR
,
1118 show_pwm_auto_point_temp
, set_pwm_auto_point_temp
,
1120 static SENSOR_DEVICE_ATTR_2(pwm1_auto_point3_fan
, S_IRUGO
| S_IWUSR
,
1121 show_pwm_auto_point_fan
, set_pwm_auto_point_fan
,
1124 static SENSOR_DEVICE_ATTR_2(pwm2_auto_point1_temp
, S_IRUGO
| S_IWUSR
,
1125 show_pwm_auto_point_temp
, set_pwm_auto_point_temp
,
1127 static SENSOR_DEVICE_ATTR_2(pwm2_auto_point1_fan
, S_IRUGO
| S_IWUSR
,
1128 show_pwm_auto_point_fan
, set_pwm_auto_point_fan
,
1130 static SENSOR_DEVICE_ATTR_2(pwm2_auto_point2_temp
, S_IRUGO
| S_IWUSR
,
1131 show_pwm_auto_point_temp
, set_pwm_auto_point_temp
,
1133 static SENSOR_DEVICE_ATTR_2(pwm2_auto_point2_fan
, S_IRUGO
| S_IWUSR
,
1134 show_pwm_auto_point_fan
, set_pwm_auto_point_fan
,
1136 static SENSOR_DEVICE_ATTR_2(pwm2_auto_point3_temp
, S_IRUGO
| S_IWUSR
,
1137 show_pwm_auto_point_temp
, set_pwm_auto_point_temp
,
1139 static SENSOR_DEVICE_ATTR_2(pwm2_auto_point3_fan
, S_IRUGO
| S_IWUSR
,
1140 show_pwm_auto_point_fan
, set_pwm_auto_point_fan
,
1143 static SENSOR_DEVICE_ATTR_2(pwm3_auto_point1_temp
, S_IRUGO
| S_IWUSR
,
1144 show_pwm_auto_point_temp
, set_pwm_auto_point_temp
,
1146 static SENSOR_DEVICE_ATTR_2(pwm3_auto_point1_fan
, S_IRUGO
| S_IWUSR
,
1147 show_pwm_auto_point_fan
, set_pwm_auto_point_fan
,
1149 static SENSOR_DEVICE_ATTR_2(pwm3_auto_point2_temp
, S_IRUGO
| S_IWUSR
,
1150 show_pwm_auto_point_temp
, set_pwm_auto_point_temp
,
1152 static SENSOR_DEVICE_ATTR_2(pwm3_auto_point2_fan
, S_IRUGO
| S_IWUSR
,
1153 show_pwm_auto_point_fan
, set_pwm_auto_point_fan
,
1155 static SENSOR_DEVICE_ATTR_2(pwm3_auto_point3_temp
, S_IRUGO
| S_IWUSR
,
1156 show_pwm_auto_point_temp
, set_pwm_auto_point_temp
,
1158 static SENSOR_DEVICE_ATTR_2(pwm3_auto_point3_fan
, S_IRUGO
| S_IWUSR
,
1159 show_pwm_auto_point_fan
, set_pwm_auto_point_fan
,
1162 static SENSOR_DEVICE_ATTR(in0_alarm
, S_IRUGO
, show_alarm
, NULL
, 0);
1163 static SENSOR_DEVICE_ATTR(in1_alarm
, S_IRUGO
, show_alarm
, NULL
, 1);
1164 static SENSOR_DEVICE_ATTR(in2_alarm
, S_IRUGO
, show_alarm
, NULL
, 2);
1165 static SENSOR_DEVICE_ATTR(in3_alarm
, S_IRUGO
, show_alarm
, NULL
, 3);
1166 static SENSOR_DEVICE_ATTR(in4_alarm
, S_IRUGO
, show_alarm
, NULL
, 4);
1167 static SENSOR_DEVICE_ATTR(in5_alarm
, S_IRUGO
, show_alarm
, NULL
, 5);
1168 static SENSOR_DEVICE_ATTR(in6_alarm
, S_IRUGO
, show_alarm
, NULL
, 6);
1169 static SENSOR_DEVICE_ATTR(in7_alarm
, S_IRUGO
, show_alarm
, NULL
, 7);
1170 static SENSOR_DEVICE_ATTR(in8_alarm
, S_IRUGO
, show_alarm
, NULL
, 8);
1171 static SENSOR_DEVICE_ATTR(in9_alarm
, S_IRUGO
, show_alarm
, NULL
, 9);
1172 static SENSOR_DEVICE_ATTR(in10_alarm
, S_IRUGO
, show_alarm
, NULL
, 10);
1173 static SENSOR_DEVICE_ATTR(temp1_alarm
, S_IRUGO
, show_alarm
, NULL
, 11);
1174 static SENSOR_DEVICE_ATTR(temp2_alarm
, S_IRUGO
, show_alarm
, NULL
, 12);
1175 static SENSOR_DEVICE_ATTR(temp3_alarm
, S_IRUGO
, show_alarm
, NULL
, 13);
1176 static SENSOR_DEVICE_ATTR(fan1_alarm
, S_IRUGO
, show_alarm
, NULL
, 16);
1177 static SENSOR_DEVICE_ATTR(fan2_alarm
, S_IRUGO
, show_alarm
, NULL
, 17);
1178 static SENSOR_DEVICE_ATTR(fan3_alarm
, S_IRUGO
, show_alarm
, NULL
, 18);
1179 static DEVICE_ATTR(alarms_in
, S_IRUGO
, show_alarms_in
, NULL
);
1180 static DEVICE_ATTR(alarms_fan
, S_IRUGO
, show_alarms_fan
, NULL
);
1181 static DEVICE_ATTR(alarms_temp
, S_IRUGO
, show_alarms_temp
, NULL
);
1183 static DEVICE_ATTR(name
, S_IRUGO
, show_name
, NULL
);
1185 static struct attribute
*f71805f_attributes
[] = {
1186 &sensor_dev_attr_in0_input
.dev_attr
.attr
,
1187 &sensor_dev_attr_in0_max
.dev_attr
.attr
,
1188 &sensor_dev_attr_in0_min
.dev_attr
.attr
,
1189 &sensor_dev_attr_in1_input
.dev_attr
.attr
,
1190 &sensor_dev_attr_in1_max
.dev_attr
.attr
,
1191 &sensor_dev_attr_in1_min
.dev_attr
.attr
,
1192 &sensor_dev_attr_in2_input
.dev_attr
.attr
,
1193 &sensor_dev_attr_in2_max
.dev_attr
.attr
,
1194 &sensor_dev_attr_in2_min
.dev_attr
.attr
,
1195 &sensor_dev_attr_in3_input
.dev_attr
.attr
,
1196 &sensor_dev_attr_in3_max
.dev_attr
.attr
,
1197 &sensor_dev_attr_in3_min
.dev_attr
.attr
,
1198 &sensor_dev_attr_in5_input
.dev_attr
.attr
,
1199 &sensor_dev_attr_in5_max
.dev_attr
.attr
,
1200 &sensor_dev_attr_in5_min
.dev_attr
.attr
,
1201 &sensor_dev_attr_in6_input
.dev_attr
.attr
,
1202 &sensor_dev_attr_in6_max
.dev_attr
.attr
,
1203 &sensor_dev_attr_in6_min
.dev_attr
.attr
,
1204 &sensor_dev_attr_in7_input
.dev_attr
.attr
,
1205 &sensor_dev_attr_in7_max
.dev_attr
.attr
,
1206 &sensor_dev_attr_in7_min
.dev_attr
.attr
,
1208 &sensor_dev_attr_fan1_input
.dev_attr
.attr
,
1209 &sensor_dev_attr_fan1_min
.dev_attr
.attr
,
1210 &sensor_dev_attr_fan1_alarm
.dev_attr
.attr
,
1211 &sensor_dev_attr_fan1_target
.dev_attr
.attr
,
1212 &sensor_dev_attr_fan2_input
.dev_attr
.attr
,
1213 &sensor_dev_attr_fan2_min
.dev_attr
.attr
,
1214 &sensor_dev_attr_fan2_alarm
.dev_attr
.attr
,
1215 &sensor_dev_attr_fan2_target
.dev_attr
.attr
,
1216 &sensor_dev_attr_fan3_input
.dev_attr
.attr
,
1217 &sensor_dev_attr_fan3_min
.dev_attr
.attr
,
1218 &sensor_dev_attr_fan3_alarm
.dev_attr
.attr
,
1219 &sensor_dev_attr_fan3_target
.dev_attr
.attr
,
1221 &sensor_dev_attr_pwm1
.dev_attr
.attr
,
1222 &sensor_dev_attr_pwm1_enable
.dev_attr
.attr
,
1223 &sensor_dev_attr_pwm1_mode
.dev_attr
.attr
,
1224 &sensor_dev_attr_pwm2
.dev_attr
.attr
,
1225 &sensor_dev_attr_pwm2_enable
.dev_attr
.attr
,
1226 &sensor_dev_attr_pwm2_mode
.dev_attr
.attr
,
1227 &sensor_dev_attr_pwm3
.dev_attr
.attr
,
1228 &sensor_dev_attr_pwm3_enable
.dev_attr
.attr
,
1229 &sensor_dev_attr_pwm3_mode
.dev_attr
.attr
,
1231 &sensor_dev_attr_temp1_input
.dev_attr
.attr
,
1232 &sensor_dev_attr_temp1_max
.dev_attr
.attr
,
1233 &sensor_dev_attr_temp1_max_hyst
.dev_attr
.attr
,
1234 &sensor_dev_attr_temp1_type
.dev_attr
.attr
,
1235 &sensor_dev_attr_temp2_input
.dev_attr
.attr
,
1236 &sensor_dev_attr_temp2_max
.dev_attr
.attr
,
1237 &sensor_dev_attr_temp2_max_hyst
.dev_attr
.attr
,
1238 &sensor_dev_attr_temp2_type
.dev_attr
.attr
,
1239 &sensor_dev_attr_temp3_input
.dev_attr
.attr
,
1240 &sensor_dev_attr_temp3_max
.dev_attr
.attr
,
1241 &sensor_dev_attr_temp3_max_hyst
.dev_attr
.attr
,
1242 &sensor_dev_attr_temp3_type
.dev_attr
.attr
,
1244 &sensor_dev_attr_pwm1_auto_point1_temp
.dev_attr
.attr
,
1245 &sensor_dev_attr_pwm1_auto_point1_fan
.dev_attr
.attr
,
1246 &sensor_dev_attr_pwm1_auto_point2_temp
.dev_attr
.attr
,
1247 &sensor_dev_attr_pwm1_auto_point2_fan
.dev_attr
.attr
,
1248 &sensor_dev_attr_pwm1_auto_point3_temp
.dev_attr
.attr
,
1249 &sensor_dev_attr_pwm1_auto_point3_fan
.dev_attr
.attr
,
1250 &sensor_dev_attr_pwm2_auto_point1_temp
.dev_attr
.attr
,
1251 &sensor_dev_attr_pwm2_auto_point1_fan
.dev_attr
.attr
,
1252 &sensor_dev_attr_pwm2_auto_point2_temp
.dev_attr
.attr
,
1253 &sensor_dev_attr_pwm2_auto_point2_fan
.dev_attr
.attr
,
1254 &sensor_dev_attr_pwm2_auto_point3_temp
.dev_attr
.attr
,
1255 &sensor_dev_attr_pwm2_auto_point3_fan
.dev_attr
.attr
,
1256 &sensor_dev_attr_pwm3_auto_point1_temp
.dev_attr
.attr
,
1257 &sensor_dev_attr_pwm3_auto_point1_fan
.dev_attr
.attr
,
1258 &sensor_dev_attr_pwm3_auto_point2_temp
.dev_attr
.attr
,
1259 &sensor_dev_attr_pwm3_auto_point2_fan
.dev_attr
.attr
,
1260 &sensor_dev_attr_pwm3_auto_point3_temp
.dev_attr
.attr
,
1261 &sensor_dev_attr_pwm3_auto_point3_fan
.dev_attr
.attr
,
1263 &sensor_dev_attr_in0_alarm
.dev_attr
.attr
,
1264 &sensor_dev_attr_in1_alarm
.dev_attr
.attr
,
1265 &sensor_dev_attr_in2_alarm
.dev_attr
.attr
,
1266 &sensor_dev_attr_in3_alarm
.dev_attr
.attr
,
1267 &sensor_dev_attr_in5_alarm
.dev_attr
.attr
,
1268 &sensor_dev_attr_in6_alarm
.dev_attr
.attr
,
1269 &sensor_dev_attr_in7_alarm
.dev_attr
.attr
,
1270 &dev_attr_alarms_in
.attr
,
1271 &sensor_dev_attr_temp1_alarm
.dev_attr
.attr
,
1272 &sensor_dev_attr_temp2_alarm
.dev_attr
.attr
,
1273 &sensor_dev_attr_temp3_alarm
.dev_attr
.attr
,
1274 &dev_attr_alarms_temp
.attr
,
1275 &dev_attr_alarms_fan
.attr
,
1277 &dev_attr_name
.attr
,
1281 static const struct attribute_group f71805f_group
= {
1282 .attrs
= f71805f_attributes
,
1285 static struct attribute
*f71805f_attributes_optin
[4][5] = {
1287 &sensor_dev_attr_in4_input
.dev_attr
.attr
,
1288 &sensor_dev_attr_in4_max
.dev_attr
.attr
,
1289 &sensor_dev_attr_in4_min
.dev_attr
.attr
,
1290 &sensor_dev_attr_in4_alarm
.dev_attr
.attr
,
1293 &sensor_dev_attr_in8_input
.dev_attr
.attr
,
1294 &sensor_dev_attr_in8_max
.dev_attr
.attr
,
1295 &sensor_dev_attr_in8_min
.dev_attr
.attr
,
1296 &sensor_dev_attr_in8_alarm
.dev_attr
.attr
,
1299 &sensor_dev_attr_in9_input
.dev_attr
.attr
,
1300 &sensor_dev_attr_in9_max
.dev_attr
.attr
,
1301 &sensor_dev_attr_in9_min
.dev_attr
.attr
,
1302 &sensor_dev_attr_in9_alarm
.dev_attr
.attr
,
1305 &sensor_dev_attr_in10_input
.dev_attr
.attr
,
1306 &sensor_dev_attr_in10_max
.dev_attr
.attr
,
1307 &sensor_dev_attr_in10_min
.dev_attr
.attr
,
1308 &sensor_dev_attr_in10_alarm
.dev_attr
.attr
,
1313 static const struct attribute_group f71805f_group_optin
[4] = {
1314 { .attrs
= f71805f_attributes_optin
[0] },
1315 { .attrs
= f71805f_attributes_optin
[1] },
1316 { .attrs
= f71805f_attributes_optin
[2] },
1317 { .attrs
= f71805f_attributes_optin
[3] },
1321 * We don't include pwm_freq files in the arrays above, because they must be
1322 * created conditionally (only if pwm_mode is 1 == PWM)
1324 static struct attribute
*f71805f_attributes_pwm_freq
[] = {
1325 &sensor_dev_attr_pwm1_freq
.dev_attr
.attr
,
1326 &sensor_dev_attr_pwm2_freq
.dev_attr
.attr
,
1327 &sensor_dev_attr_pwm3_freq
.dev_attr
.attr
,
1331 static const struct attribute_group f71805f_group_pwm_freq
= {
1332 .attrs
= f71805f_attributes_pwm_freq
,
1335 /* We also need an indexed access to pwmN files to toggle writability */
1336 static struct attribute
*f71805f_attr_pwm
[] = {
1337 &sensor_dev_attr_pwm1
.dev_attr
.attr
,
1338 &sensor_dev_attr_pwm2
.dev_attr
.attr
,
1339 &sensor_dev_attr_pwm3
.dev_attr
.attr
,
1343 * Device registration and initialization
1346 static void __devinit
f71805f_init_device(struct f71805f_data
*data
)
1351 reg
= f71805f_read8(data
, F71805F_REG_START
);
1352 if ((reg
& 0x41) != 0x01) {
1353 printk(KERN_DEBUG DRVNAME
": Starting monitoring "
1355 f71805f_write8(data
, F71805F_REG_START
, (reg
| 0x01) & ~0x40);
1359 * Fan monitoring can be disabled. If it is, we won't be polling
1360 * the register values, and won't create the related sysfs files.
1362 for (i
= 0; i
< 3; i
++) {
1363 data
->fan_ctrl
[i
] = f71805f_read8(data
,
1364 F71805F_REG_FAN_CTRL(i
));
1366 * Clear latch full bit, else "speed mode" fan speed control
1369 if (data
->fan_ctrl
[i
] & FAN_CTRL_LATCH_FULL
) {
1370 data
->fan_ctrl
[i
] &= ~FAN_CTRL_LATCH_FULL
;
1371 f71805f_write8(data
, F71805F_REG_FAN_CTRL(i
),
1377 static int __devinit
f71805f_probe(struct platform_device
*pdev
)
1379 struct f71805f_sio_data
*sio_data
= pdev
->dev
.platform_data
;
1380 struct f71805f_data
*data
;
1381 struct resource
*res
;
1384 static const char * const names
[] = {
1389 data
= devm_kzalloc(&pdev
->dev
, sizeof(struct f71805f_data
),
1392 pr_err("Out of memory\n");
1396 res
= platform_get_resource(pdev
, IORESOURCE_IO
, 0);
1397 if (!devm_request_region(&pdev
->dev
, res
->start
+ ADDR_REG_OFFSET
, 2,
1399 dev_err(&pdev
->dev
, "Failed to request region 0x%lx-0x%lx\n",
1400 (unsigned long)(res
->start
+ ADDR_REG_OFFSET
),
1401 (unsigned long)(res
->start
+ ADDR_REG_OFFSET
+ 1));
1404 data
->addr
= res
->start
;
1405 data
->name
= names
[sio_data
->kind
];
1406 mutex_init(&data
->update_lock
);
1408 platform_set_drvdata(pdev
, data
);
1410 /* Some voltage inputs depend on chip model and configuration */
1411 switch (sio_data
->kind
) {
1413 data
->has_in
= 0x1ff;
1416 data
->has_in
= 0x6ef;
1417 if (sio_data
->fnsel1
& 0x01)
1418 data
->has_in
|= (1 << 4); /* in4 */
1419 if (sio_data
->fnsel1
& 0x02)
1420 data
->has_in
|= (1 << 8); /* in8 */
1424 /* Initialize the F71805F chip */
1425 f71805f_init_device(data
);
1427 /* Register sysfs interface files */
1428 err
= sysfs_create_group(&pdev
->dev
.kobj
, &f71805f_group
);
1431 if (data
->has_in
& (1 << 4)) { /* in4 */
1432 err
= sysfs_create_group(&pdev
->dev
.kobj
,
1433 &f71805f_group_optin
[0]);
1435 goto exit_remove_files
;
1437 if (data
->has_in
& (1 << 8)) { /* in8 */
1438 err
= sysfs_create_group(&pdev
->dev
.kobj
,
1439 &f71805f_group_optin
[1]);
1441 goto exit_remove_files
;
1443 if (data
->has_in
& (1 << 9)) { /* in9 (F71872F/FG only) */
1444 err
= sysfs_create_group(&pdev
->dev
.kobj
,
1445 &f71805f_group_optin
[2]);
1447 goto exit_remove_files
;
1449 if (data
->has_in
& (1 << 10)) { /* in9 (F71872F/FG only) */
1450 err
= sysfs_create_group(&pdev
->dev
.kobj
,
1451 &f71805f_group_optin
[3]);
1453 goto exit_remove_files
;
1455 for (i
= 0; i
< 3; i
++) {
1456 /* If control mode is PWM, create pwm_freq file */
1457 if (!(data
->fan_ctrl
[i
] & FAN_CTRL_DC_MODE
)) {
1458 err
= sysfs_create_file(&pdev
->dev
.kobj
,
1459 f71805f_attributes_pwm_freq
[i
]);
1461 goto exit_remove_files
;
1463 /* If PWM is in manual mode, add write permission */
1464 if (data
->fan_ctrl
[i
] & FAN_CTRL_MODE_MANUAL
) {
1465 err
= sysfs_chmod_file(&pdev
->dev
.kobj
,
1466 f71805f_attr_pwm
[i
],
1469 dev_err(&pdev
->dev
, "chmod +w pwm%d failed\n",
1471 goto exit_remove_files
;
1476 data
->hwmon_dev
= hwmon_device_register(&pdev
->dev
);
1477 if (IS_ERR(data
->hwmon_dev
)) {
1478 err
= PTR_ERR(data
->hwmon_dev
);
1479 dev_err(&pdev
->dev
, "Class registration failed (%d)\n", err
);
1480 goto exit_remove_files
;
1486 sysfs_remove_group(&pdev
->dev
.kobj
, &f71805f_group
);
1487 for (i
= 0; i
< 4; i
++)
1488 sysfs_remove_group(&pdev
->dev
.kobj
, &f71805f_group_optin
[i
]);
1489 sysfs_remove_group(&pdev
->dev
.kobj
, &f71805f_group_pwm_freq
);
1493 static int __devexit
f71805f_remove(struct platform_device
*pdev
)
1495 struct f71805f_data
*data
= platform_get_drvdata(pdev
);
1498 hwmon_device_unregister(data
->hwmon_dev
);
1499 sysfs_remove_group(&pdev
->dev
.kobj
, &f71805f_group
);
1500 for (i
= 0; i
< 4; i
++)
1501 sysfs_remove_group(&pdev
->dev
.kobj
, &f71805f_group_optin
[i
]);
1502 sysfs_remove_group(&pdev
->dev
.kobj
, &f71805f_group_pwm_freq
);
1507 static struct platform_driver f71805f_driver
= {
1509 .owner
= THIS_MODULE
,
1512 .probe
= f71805f_probe
,
1513 .remove
= __devexit_p(f71805f_remove
),
1516 static int __init
f71805f_device_add(unsigned short address
,
1517 const struct f71805f_sio_data
*sio_data
)
1519 struct resource res
= {
1521 .end
= address
+ REGION_LENGTH
- 1,
1522 .flags
= IORESOURCE_IO
,
1526 pdev
= platform_device_alloc(DRVNAME
, address
);
1529 pr_err("Device allocation failed\n");
1533 res
.name
= pdev
->name
;
1534 err
= acpi_check_resource_conflict(&res
);
1536 goto exit_device_put
;
1538 err
= platform_device_add_resources(pdev
, &res
, 1);
1540 pr_err("Device resource addition failed (%d)\n", err
);
1541 goto exit_device_put
;
1544 err
= platform_device_add_data(pdev
, sio_data
,
1545 sizeof(struct f71805f_sio_data
));
1547 pr_err("Platform data allocation failed\n");
1548 goto exit_device_put
;
1551 err
= platform_device_add(pdev
);
1553 pr_err("Device addition failed (%d)\n", err
);
1554 goto exit_device_put
;
1560 platform_device_put(pdev
);
1565 static int __init
f71805f_find(int sioaddr
, unsigned short *address
,
1566 struct f71805f_sio_data
*sio_data
)
1571 static const char * const names
[] = {
1573 "F71872F/FG or F71806F/FG",
1576 superio_enter(sioaddr
);
1578 devid
= superio_inw(sioaddr
, SIO_REG_MANID
);
1579 if (devid
!= SIO_FINTEK_ID
)
1582 devid
= force_id
? force_id
: superio_inw(sioaddr
, SIO_REG_DEVID
);
1584 case SIO_F71805F_ID
:
1585 sio_data
->kind
= f71805f
;
1587 case SIO_F71872F_ID
:
1588 sio_data
->kind
= f71872f
;
1589 sio_data
->fnsel1
= superio_inb(sioaddr
, SIO_REG_FNSEL1
);
1592 pr_info("Unsupported Fintek device, skipping\n");
1596 superio_select(sioaddr
, F71805F_LD_HWM
);
1597 if (!(superio_inb(sioaddr
, SIO_REG_ENABLE
) & 0x01)) {
1598 pr_warn("Device not activated, skipping\n");
1602 *address
= superio_inw(sioaddr
, SIO_REG_ADDR
);
1603 if (*address
== 0) {
1604 pr_warn("Base address not set, skipping\n");
1607 *address
&= ~(REGION_LENGTH
- 1); /* Ignore 3 LSB */
1610 pr_info("Found %s chip at %#x, revision %u\n",
1611 names
[sio_data
->kind
], *address
,
1612 superio_inb(sioaddr
, SIO_REG_DEVREV
));
1615 superio_exit(sioaddr
);
1619 static int __init
f71805f_init(void)
1622 unsigned short address
;
1623 struct f71805f_sio_data sio_data
;
1625 if (f71805f_find(0x2e, &address
, &sio_data
)
1626 && f71805f_find(0x4e, &address
, &sio_data
))
1629 err
= platform_driver_register(&f71805f_driver
);
1633 /* Sets global pdev as a side effect */
1634 err
= f71805f_device_add(address
, &sio_data
);
1641 platform_driver_unregister(&f71805f_driver
);
1646 static void __exit
f71805f_exit(void)
1648 platform_device_unregister(pdev
);
1649 platform_driver_unregister(&f71805f_driver
);
1652 MODULE_AUTHOR("Jean Delvare <khali@linux-fr>");
1653 MODULE_LICENSE("GPL");
1654 MODULE_DESCRIPTION("F71805F/F71872F hardware monitoring driver");
1656 module_init(f71805f_init
);
1657 module_exit(f71805f_exit
);