2 * gpio-fan.c - Hwmon driver for fans connected to GPIO lines.
4 * Copyright (C) 2010 LaCie
6 * Author: Simon Guinot <sguinot@lacie.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include <linux/module.h>
24 #include <linux/init.h>
25 #include <linux/slab.h>
26 #include <linux/interrupt.h>
27 #include <linux/irq.h>
28 #include <linux/platform_device.h>
29 #include <linux/err.h>
30 #include <linux/mutex.h>
31 #include <linux/hwmon.h>
32 #include <linux/gpio.h>
33 #include <linux/gpio-fan.h>
35 struct gpio_fan_data
{
36 struct platform_device
*pdev
;
37 struct device
*hwmon_dev
;
38 struct mutex lock
; /* lock GPIOs operations. */
42 struct gpio_fan_speed
*speed
;
44 #ifdef CONFIG_PM_SLEEP
48 struct gpio_fan_alarm
*alarm
;
49 struct work_struct alarm_work
;
56 static void fan_alarm_notify(struct work_struct
*ws
)
58 struct gpio_fan_data
*fan_data
=
59 container_of(ws
, struct gpio_fan_data
, alarm_work
);
61 sysfs_notify(&fan_data
->pdev
->dev
.kobj
, NULL
, "fan1_alarm");
62 kobject_uevent(&fan_data
->pdev
->dev
.kobj
, KOBJ_CHANGE
);
65 static irqreturn_t
fan_alarm_irq_handler(int irq
, void *dev_id
)
67 struct gpio_fan_data
*fan_data
= dev_id
;
69 schedule_work(&fan_data
->alarm_work
);
74 static ssize_t
show_fan_alarm(struct device
*dev
,
75 struct device_attribute
*attr
, char *buf
)
77 struct gpio_fan_data
*fan_data
= dev_get_drvdata(dev
);
78 struct gpio_fan_alarm
*alarm
= fan_data
->alarm
;
79 int value
= gpio_get_value(alarm
->gpio
);
81 if (alarm
->active_low
)
84 return sprintf(buf
, "%d\n", value
);
87 static DEVICE_ATTR(fan1_alarm
, S_IRUGO
, show_fan_alarm
, NULL
);
89 static int fan_alarm_init(struct gpio_fan_data
*fan_data
,
90 struct gpio_fan_alarm
*alarm
)
94 struct platform_device
*pdev
= fan_data
->pdev
;
96 fan_data
->alarm
= alarm
;
98 err
= devm_gpio_request(&pdev
->dev
, alarm
->gpio
, "GPIO fan alarm");
102 err
= gpio_direction_input(alarm
->gpio
);
106 err
= device_create_file(&pdev
->dev
, &dev_attr_fan1_alarm
);
111 * If the alarm GPIO don't support interrupts, just leave
112 * without initializing the fail notification support.
114 alarm_irq
= gpio_to_irq(alarm
->gpio
);
118 INIT_WORK(&fan_data
->alarm_work
, fan_alarm_notify
);
119 irq_set_irq_type(alarm_irq
, IRQ_TYPE_EDGE_BOTH
);
120 err
= devm_request_irq(&pdev
->dev
, alarm_irq
, fan_alarm_irq_handler
,
121 IRQF_SHARED
, "GPIO fan alarm", fan_data
);
128 device_remove_file(&pdev
->dev
, &dev_attr_fan1_alarm
);
132 static void fan_alarm_free(struct gpio_fan_data
*fan_data
)
134 struct platform_device
*pdev
= fan_data
->pdev
;
136 device_remove_file(&pdev
->dev
, &dev_attr_fan1_alarm
);
143 /* Must be called with fan_data->lock held, except during initialization. */
144 static void __set_fan_ctrl(struct gpio_fan_data
*fan_data
, int ctrl_val
)
148 for (i
= 0; i
< fan_data
->num_ctrl
; i
++)
149 gpio_set_value(fan_data
->ctrl
[i
], (ctrl_val
>> i
) & 1);
152 static int __get_fan_ctrl(struct gpio_fan_data
*fan_data
)
157 for (i
= 0; i
< fan_data
->num_ctrl
; i
++) {
160 value
= gpio_get_value(fan_data
->ctrl
[i
]);
161 ctrl_val
|= (value
<< i
);
166 /* Must be called with fan_data->lock held, except during initialization. */
167 static void set_fan_speed(struct gpio_fan_data
*fan_data
, int speed_index
)
169 if (fan_data
->speed_index
== speed_index
)
172 __set_fan_ctrl(fan_data
, fan_data
->speed
[speed_index
].ctrl_val
);
173 fan_data
->speed_index
= speed_index
;
176 static int get_fan_speed_index(struct gpio_fan_data
*fan_data
)
178 int ctrl_val
= __get_fan_ctrl(fan_data
);
181 for (i
= 0; i
< fan_data
->num_speed
; i
++)
182 if (fan_data
->speed
[i
].ctrl_val
== ctrl_val
)
185 dev_warn(&fan_data
->pdev
->dev
,
186 "missing speed array entry for GPIO value 0x%x\n", ctrl_val
);
191 static int rpm_to_speed_index(struct gpio_fan_data
*fan_data
, int rpm
)
193 struct gpio_fan_speed
*speed
= fan_data
->speed
;
196 for (i
= 0; i
< fan_data
->num_speed
; i
++)
197 if (speed
[i
].rpm
>= rpm
)
200 return fan_data
->num_speed
- 1;
203 static ssize_t
show_pwm(struct device
*dev
,
204 struct device_attribute
*attr
, char *buf
)
206 struct gpio_fan_data
*fan_data
= dev_get_drvdata(dev
);
207 u8 pwm
= fan_data
->speed_index
* 255 / (fan_data
->num_speed
- 1);
209 return sprintf(buf
, "%d\n", pwm
);
212 static ssize_t
set_pwm(struct device
*dev
, struct device_attribute
*attr
,
213 const char *buf
, size_t count
)
215 struct gpio_fan_data
*fan_data
= dev_get_drvdata(dev
);
220 if (kstrtoul(buf
, 10, &pwm
) || pwm
> 255)
223 mutex_lock(&fan_data
->lock
);
225 if (!fan_data
->pwm_enable
) {
230 speed_index
= DIV_ROUND_UP(pwm
* (fan_data
->num_speed
- 1), 255);
231 set_fan_speed(fan_data
, speed_index
);
234 mutex_unlock(&fan_data
->lock
);
239 static ssize_t
show_pwm_enable(struct device
*dev
,
240 struct device_attribute
*attr
, char *buf
)
242 struct gpio_fan_data
*fan_data
= dev_get_drvdata(dev
);
244 return sprintf(buf
, "%d\n", fan_data
->pwm_enable
);
247 static ssize_t
set_pwm_enable(struct device
*dev
, struct device_attribute
*attr
,
248 const char *buf
, size_t count
)
250 struct gpio_fan_data
*fan_data
= dev_get_drvdata(dev
);
253 if (kstrtoul(buf
, 10, &val
) || val
> 1)
256 if (fan_data
->pwm_enable
== val
)
259 mutex_lock(&fan_data
->lock
);
261 fan_data
->pwm_enable
= val
;
263 /* Disable manual control mode: set fan at full speed. */
265 set_fan_speed(fan_data
, fan_data
->num_speed
- 1);
267 mutex_unlock(&fan_data
->lock
);
272 static ssize_t
show_pwm_mode(struct device
*dev
,
273 struct device_attribute
*attr
, char *buf
)
275 return sprintf(buf
, "0\n");
278 static ssize_t
show_rpm_min(struct device
*dev
,
279 struct device_attribute
*attr
, char *buf
)
281 struct gpio_fan_data
*fan_data
= dev_get_drvdata(dev
);
283 return sprintf(buf
, "%d\n", fan_data
->speed
[0].rpm
);
286 static ssize_t
show_rpm_max(struct device
*dev
,
287 struct device_attribute
*attr
, char *buf
)
289 struct gpio_fan_data
*fan_data
= dev_get_drvdata(dev
);
291 return sprintf(buf
, "%d\n",
292 fan_data
->speed
[fan_data
->num_speed
- 1].rpm
);
295 static ssize_t
show_rpm(struct device
*dev
,
296 struct device_attribute
*attr
, char *buf
)
298 struct gpio_fan_data
*fan_data
= dev_get_drvdata(dev
);
300 return sprintf(buf
, "%d\n", fan_data
->speed
[fan_data
->speed_index
].rpm
);
303 static ssize_t
set_rpm(struct device
*dev
, struct device_attribute
*attr
,
304 const char *buf
, size_t count
)
306 struct gpio_fan_data
*fan_data
= dev_get_drvdata(dev
);
310 if (kstrtoul(buf
, 10, &rpm
))
313 mutex_lock(&fan_data
->lock
);
315 if (!fan_data
->pwm_enable
) {
320 set_fan_speed(fan_data
, rpm_to_speed_index(fan_data
, rpm
));
323 mutex_unlock(&fan_data
->lock
);
328 static DEVICE_ATTR(pwm1
, S_IRUGO
| S_IWUSR
, show_pwm
, set_pwm
);
329 static DEVICE_ATTR(pwm1_enable
, S_IRUGO
| S_IWUSR
,
330 show_pwm_enable
, set_pwm_enable
);
331 static DEVICE_ATTR(pwm1_mode
, S_IRUGO
, show_pwm_mode
, NULL
);
332 static DEVICE_ATTR(fan1_min
, S_IRUGO
, show_rpm_min
, NULL
);
333 static DEVICE_ATTR(fan1_max
, S_IRUGO
, show_rpm_max
, NULL
);
334 static DEVICE_ATTR(fan1_input
, S_IRUGO
, show_rpm
, NULL
);
335 static DEVICE_ATTR(fan1_target
, S_IRUGO
| S_IWUSR
, show_rpm
, set_rpm
);
337 static struct attribute
*gpio_fan_ctrl_attributes
[] = {
339 &dev_attr_pwm1_enable
.attr
,
340 &dev_attr_pwm1_mode
.attr
,
341 &dev_attr_fan1_input
.attr
,
342 &dev_attr_fan1_target
.attr
,
343 &dev_attr_fan1_min
.attr
,
344 &dev_attr_fan1_max
.attr
,
348 static const struct attribute_group gpio_fan_ctrl_group
= {
349 .attrs
= gpio_fan_ctrl_attributes
,
352 static int fan_ctrl_init(struct gpio_fan_data
*fan_data
,
353 struct gpio_fan_platform_data
*pdata
)
355 struct platform_device
*pdev
= fan_data
->pdev
;
356 int num_ctrl
= pdata
->num_ctrl
;
357 unsigned *ctrl
= pdata
->ctrl
;
360 for (i
= 0; i
< num_ctrl
; i
++) {
361 err
= devm_gpio_request(&pdev
->dev
, ctrl
[i
],
366 err
= gpio_direction_output(ctrl
[i
], gpio_get_value(ctrl
[i
]));
371 fan_data
->num_ctrl
= num_ctrl
;
372 fan_data
->ctrl
= ctrl
;
373 fan_data
->num_speed
= pdata
->num_speed
;
374 fan_data
->speed
= pdata
->speed
;
375 fan_data
->pwm_enable
= true; /* Enable manual fan speed control. */
376 fan_data
->speed_index
= get_fan_speed_index(fan_data
);
377 if (fan_data
->speed_index
< 0)
380 err
= sysfs_create_group(&pdev
->dev
.kobj
, &gpio_fan_ctrl_group
);
384 static void fan_ctrl_free(struct gpio_fan_data
*fan_data
)
386 struct platform_device
*pdev
= fan_data
->pdev
;
388 sysfs_remove_group(&pdev
->dev
.kobj
, &gpio_fan_ctrl_group
);
395 static ssize_t
show_name(struct device
*dev
,
396 struct device_attribute
*attr
, char *buf
)
398 return sprintf(buf
, "gpio-fan\n");
401 static DEVICE_ATTR(name
, S_IRUGO
, show_name
, NULL
);
403 static int __devinit
gpio_fan_probe(struct platform_device
*pdev
)
406 struct gpio_fan_data
*fan_data
;
407 struct gpio_fan_platform_data
*pdata
= pdev
->dev
.platform_data
;
412 fan_data
= devm_kzalloc(&pdev
->dev
, sizeof(struct gpio_fan_data
),
417 fan_data
->pdev
= pdev
;
418 platform_set_drvdata(pdev
, fan_data
);
419 mutex_init(&fan_data
->lock
);
421 /* Configure alarm GPIO if available. */
423 err
= fan_alarm_init(fan_data
, pdata
->alarm
);
428 /* Configure control GPIOs if available. */
429 if (pdata
->ctrl
&& pdata
->num_ctrl
> 0) {
430 if (!pdata
->speed
|| pdata
->num_speed
<= 1) {
434 err
= fan_ctrl_init(fan_data
, pdata
);
439 err
= device_create_file(&pdev
->dev
, &dev_attr_name
);
443 /* Make this driver part of hwmon class. */
444 fan_data
->hwmon_dev
= hwmon_device_register(&pdev
->dev
);
445 if (IS_ERR(fan_data
->hwmon_dev
)) {
446 err
= PTR_ERR(fan_data
->hwmon_dev
);
447 goto err_remove_name
;
450 dev_info(&pdev
->dev
, "GPIO fan initialized\n");
455 device_remove_file(&pdev
->dev
, &dev_attr_name
);
458 fan_ctrl_free(fan_data
);
461 fan_alarm_free(fan_data
);
465 static int __devexit
gpio_fan_remove(struct platform_device
*pdev
)
467 struct gpio_fan_data
*fan_data
= platform_get_drvdata(pdev
);
469 hwmon_device_unregister(fan_data
->hwmon_dev
);
470 device_remove_file(&pdev
->dev
, &dev_attr_name
);
472 fan_alarm_free(fan_data
);
474 fan_ctrl_free(fan_data
);
479 #ifdef CONFIG_PM_SLEEP
480 static int gpio_fan_suspend(struct device
*dev
)
482 struct gpio_fan_data
*fan_data
= dev_get_drvdata(dev
);
484 if (fan_data
->ctrl
) {
485 fan_data
->resume_speed
= fan_data
->speed_index
;
486 set_fan_speed(fan_data
, 0);
492 static int gpio_fan_resume(struct device
*dev
)
494 struct gpio_fan_data
*fan_data
= dev_get_drvdata(dev
);
497 set_fan_speed(fan_data
, fan_data
->resume_speed
);
502 static SIMPLE_DEV_PM_OPS(gpio_fan_pm
, gpio_fan_suspend
, gpio_fan_resume
);
503 #define GPIO_FAN_PM &gpio_fan_pm
505 #define GPIO_FAN_PM NULL
508 static struct platform_driver gpio_fan_driver
= {
509 .probe
= gpio_fan_probe
,
510 .remove
= __devexit_p(gpio_fan_remove
),
517 module_platform_driver(gpio_fan_driver
);
519 MODULE_AUTHOR("Simon Guinot <sguinot@lacie.com>");
520 MODULE_DESCRIPTION("GPIO FAN driver");
521 MODULE_LICENSE("GPL");
522 MODULE_ALIAS("platform:gpio-fan");