blob: 2f4b01bda87c16bfc7bfb70a48f2c686f27be26c [file] [log] [blame]
Simon Guinotd6fe1362010-10-22 00:44:19 +02001/*
2 * gpio-fan.c - Hwmon driver for fans connected to GPIO lines.
3 *
4 * Copyright (C) 2010 LaCie
5 *
6 * Author: Simon Guinot <sguinot@lacie.com>
7 *
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.
12 *
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.
17 *
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
21 */
22
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>
34
35struct gpio_fan_data {
36 struct platform_device *pdev;
37 struct device *hwmon_dev;
38 struct mutex lock; /* lock GPIOs operations. */
39 int num_ctrl;
40 unsigned *ctrl;
41 int num_speed;
42 struct gpio_fan_speed *speed;
43 int speed_index;
Rafael J. Wysocki6d20a6c2012-07-08 00:01:03 +020044#ifdef CONFIG_PM_SLEEP
Simon Guinotd6fe1362010-10-22 00:44:19 +020045 int resume_speed;
46#endif
47 bool pwm_enable;
48 struct gpio_fan_alarm *alarm;
49 struct work_struct alarm_work;
50};
51
52/*
53 * Alarm GPIO.
54 */
55
56static void fan_alarm_notify(struct work_struct *ws)
57{
58 struct gpio_fan_data *fan_data =
59 container_of(ws, struct gpio_fan_data, alarm_work);
60
61 sysfs_notify(&fan_data->pdev->dev.kobj, NULL, "fan1_alarm");
62 kobject_uevent(&fan_data->pdev->dev.kobj, KOBJ_CHANGE);
63}
64
65static irqreturn_t fan_alarm_irq_handler(int irq, void *dev_id)
66{
67 struct gpio_fan_data *fan_data = dev_id;
68
69 schedule_work(&fan_data->alarm_work);
70
71 return IRQ_NONE;
72}
73
74static ssize_t show_fan_alarm(struct device *dev,
75 struct device_attribute *attr, char *buf)
76{
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);
80
81 if (alarm->active_low)
82 value = !value;
83
84 return sprintf(buf, "%d\n", value);
85}
86
87static DEVICE_ATTR(fan1_alarm, S_IRUGO, show_fan_alarm, NULL);
88
89static int fan_alarm_init(struct gpio_fan_data *fan_data,
90 struct gpio_fan_alarm *alarm)
91{
92 int err;
93 int alarm_irq;
94 struct platform_device *pdev = fan_data->pdev;
95
96 fan_data->alarm = alarm;
97
Guenter Roeckd00985f2012-06-02 09:58:07 -070098 err = devm_gpio_request(&pdev->dev, alarm->gpio, "GPIO fan alarm");
Simon Guinotd6fe1362010-10-22 00:44:19 +020099 if (err)
100 return err;
101
102 err = gpio_direction_input(alarm->gpio);
103 if (err)
Guenter Roeckd00985f2012-06-02 09:58:07 -0700104 return err;
Simon Guinotd6fe1362010-10-22 00:44:19 +0200105
106 err = device_create_file(&pdev->dev, &dev_attr_fan1_alarm);
107 if (err)
Guenter Roeckd00985f2012-06-02 09:58:07 -0700108 return err;
Simon Guinotd6fe1362010-10-22 00:44:19 +0200109
110 /*
111 * If the alarm GPIO don't support interrupts, just leave
112 * without initializing the fail notification support.
113 */
114 alarm_irq = gpio_to_irq(alarm->gpio);
115 if (alarm_irq < 0)
116 return 0;
117
118 INIT_WORK(&fan_data->alarm_work, fan_alarm_notify);
Thomas Gleixnerdced35a2011-03-28 17:49:12 +0200119 irq_set_irq_type(alarm_irq, IRQ_TYPE_EDGE_BOTH);
Guenter Roeckd00985f2012-06-02 09:58:07 -0700120 err = devm_request_irq(&pdev->dev, alarm_irq, fan_alarm_irq_handler,
121 IRQF_SHARED, "GPIO fan alarm", fan_data);
Simon Guinotd6fe1362010-10-22 00:44:19 +0200122 if (err)
123 goto err_free_sysfs;
124
125 return 0;
126
127err_free_sysfs:
128 device_remove_file(&pdev->dev, &dev_attr_fan1_alarm);
Simon Guinotd6fe1362010-10-22 00:44:19 +0200129 return err;
130}
131
132static void fan_alarm_free(struct gpio_fan_data *fan_data)
133{
134 struct platform_device *pdev = fan_data->pdev;
Simon Guinotd6fe1362010-10-22 00:44:19 +0200135
Simon Guinotd6fe1362010-10-22 00:44:19 +0200136 device_remove_file(&pdev->dev, &dev_attr_fan1_alarm);
Simon Guinotd6fe1362010-10-22 00:44:19 +0200137}
138
139/*
140 * Control GPIOs.
141 */
142
143/* Must be called with fan_data->lock held, except during initialization. */
144static void __set_fan_ctrl(struct gpio_fan_data *fan_data, int ctrl_val)
145{
146 int i;
147
148 for (i = 0; i < fan_data->num_ctrl; i++)
149 gpio_set_value(fan_data->ctrl[i], (ctrl_val >> i) & 1);
150}
151
152static int __get_fan_ctrl(struct gpio_fan_data *fan_data)
153{
154 int i;
155 int ctrl_val = 0;
156
157 for (i = 0; i < fan_data->num_ctrl; i++) {
158 int value;
159
160 value = gpio_get_value(fan_data->ctrl[i]);
161 ctrl_val |= (value << i);
162 }
163 return ctrl_val;
164}
165
166/* Must be called with fan_data->lock held, except during initialization. */
167static void set_fan_speed(struct gpio_fan_data *fan_data, int speed_index)
168{
169 if (fan_data->speed_index == speed_index)
170 return;
171
172 __set_fan_ctrl(fan_data, fan_data->speed[speed_index].ctrl_val);
173 fan_data->speed_index = speed_index;
174}
175
176static int get_fan_speed_index(struct gpio_fan_data *fan_data)
177{
178 int ctrl_val = __get_fan_ctrl(fan_data);
179 int i;
180
181 for (i = 0; i < fan_data->num_speed; i++)
182 if (fan_data->speed[i].ctrl_val == ctrl_val)
183 return i;
184
185 dev_warn(&fan_data->pdev->dev,
186 "missing speed array entry for GPIO value 0x%x\n", ctrl_val);
187
188 return -EINVAL;
189}
190
191static int rpm_to_speed_index(struct gpio_fan_data *fan_data, int rpm)
192{
193 struct gpio_fan_speed *speed = fan_data->speed;
194 int i;
195
196 for (i = 0; i < fan_data->num_speed; i++)
197 if (speed[i].rpm >= rpm)
198 return i;
199
200 return fan_data->num_speed - 1;
201}
202
203static ssize_t show_pwm(struct device *dev,
204 struct device_attribute *attr, char *buf)
205{
206 struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
207 u8 pwm = fan_data->speed_index * 255 / (fan_data->num_speed - 1);
208
209 return sprintf(buf, "%d\n", pwm);
210}
211
212static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
213 const char *buf, size_t count)
214{
215 struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
216 unsigned long pwm;
217 int speed_index;
218 int ret = count;
219
Frans Meulenbroeks179c4fd2012-01-04 20:58:52 +0100220 if (kstrtoul(buf, 10, &pwm) || pwm > 255)
Simon Guinotd6fe1362010-10-22 00:44:19 +0200221 return -EINVAL;
222
223 mutex_lock(&fan_data->lock);
224
225 if (!fan_data->pwm_enable) {
226 ret = -EPERM;
227 goto exit_unlock;
228 }
229
230 speed_index = DIV_ROUND_UP(pwm * (fan_data->num_speed - 1), 255);
231 set_fan_speed(fan_data, speed_index);
232
233exit_unlock:
234 mutex_unlock(&fan_data->lock);
235
236 return ret;
237}
238
239static ssize_t show_pwm_enable(struct device *dev,
240 struct device_attribute *attr, char *buf)
241{
242 struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
243
244 return sprintf(buf, "%d\n", fan_data->pwm_enable);
245}
246
247static ssize_t set_pwm_enable(struct device *dev, struct device_attribute *attr,
248 const char *buf, size_t count)
249{
250 struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
251 unsigned long val;
252
Frans Meulenbroeks179c4fd2012-01-04 20:58:52 +0100253 if (kstrtoul(buf, 10, &val) || val > 1)
Simon Guinotd6fe1362010-10-22 00:44:19 +0200254 return -EINVAL;
255
256 if (fan_data->pwm_enable == val)
257 return count;
258
259 mutex_lock(&fan_data->lock);
260
261 fan_data->pwm_enable = val;
262
263 /* Disable manual control mode: set fan at full speed. */
264 if (val == 0)
265 set_fan_speed(fan_data, fan_data->num_speed - 1);
266
267 mutex_unlock(&fan_data->lock);
268
269 return count;
270}
271
272static ssize_t show_pwm_mode(struct device *dev,
273 struct device_attribute *attr, char *buf)
274{
275 return sprintf(buf, "0\n");
276}
277
278static ssize_t show_rpm_min(struct device *dev,
279 struct device_attribute *attr, char *buf)
280{
281 struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
282
283 return sprintf(buf, "%d\n", fan_data->speed[0].rpm);
284}
285
286static ssize_t show_rpm_max(struct device *dev,
287 struct device_attribute *attr, char *buf)
288{
289 struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
290
291 return sprintf(buf, "%d\n",
292 fan_data->speed[fan_data->num_speed - 1].rpm);
293}
294
295static ssize_t show_rpm(struct device *dev,
296 struct device_attribute *attr, char *buf)
297{
298 struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
299
300 return sprintf(buf, "%d\n", fan_data->speed[fan_data->speed_index].rpm);
301}
302
303static ssize_t set_rpm(struct device *dev, struct device_attribute *attr,
304 const char *buf, size_t count)
305{
306 struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
307 unsigned long rpm;
308 int ret = count;
309
Frans Meulenbroeks179c4fd2012-01-04 20:58:52 +0100310 if (kstrtoul(buf, 10, &rpm))
Simon Guinotd6fe1362010-10-22 00:44:19 +0200311 return -EINVAL;
312
313 mutex_lock(&fan_data->lock);
314
315 if (!fan_data->pwm_enable) {
316 ret = -EPERM;
317 goto exit_unlock;
318 }
319
320 set_fan_speed(fan_data, rpm_to_speed_index(fan_data, rpm));
321
322exit_unlock:
323 mutex_unlock(&fan_data->lock);
324
325 return ret;
326}
327
328static DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, set_pwm);
329static DEVICE_ATTR(pwm1_enable, S_IRUGO | S_IWUSR,
330 show_pwm_enable, set_pwm_enable);
331static DEVICE_ATTR(pwm1_mode, S_IRUGO, show_pwm_mode, NULL);
332static DEVICE_ATTR(fan1_min, S_IRUGO, show_rpm_min, NULL);
333static DEVICE_ATTR(fan1_max, S_IRUGO, show_rpm_max, NULL);
334static DEVICE_ATTR(fan1_input, S_IRUGO, show_rpm, NULL);
335static DEVICE_ATTR(fan1_target, S_IRUGO | S_IWUSR, show_rpm, set_rpm);
336
337static struct attribute *gpio_fan_ctrl_attributes[] = {
338 &dev_attr_pwm1.attr,
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,
345 NULL
346};
347
348static const struct attribute_group gpio_fan_ctrl_group = {
349 .attrs = gpio_fan_ctrl_attributes,
350};
351
352static int fan_ctrl_init(struct gpio_fan_data *fan_data,
353 struct gpio_fan_platform_data *pdata)
354{
355 struct platform_device *pdev = fan_data->pdev;
356 int num_ctrl = pdata->num_ctrl;
357 unsigned *ctrl = pdata->ctrl;
358 int i, err;
359
360 for (i = 0; i < num_ctrl; i++) {
Guenter Roeckd00985f2012-06-02 09:58:07 -0700361 err = devm_gpio_request(&pdev->dev, ctrl[i],
362 "GPIO fan control");
Simon Guinotd6fe1362010-10-22 00:44:19 +0200363 if (err)
Guenter Roeckd00985f2012-06-02 09:58:07 -0700364 return err;
Simon Guinotd6fe1362010-10-22 00:44:19 +0200365
366 err = gpio_direction_output(ctrl[i], gpio_get_value(ctrl[i]));
Guenter Roeckd00985f2012-06-02 09:58:07 -0700367 if (err)
368 return err;
Simon Guinotd6fe1362010-10-22 00:44:19 +0200369 }
370
Simon Guinotd6fe1362010-10-22 00:44:19 +0200371 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);
Guenter Roeckd00985f2012-06-02 09:58:07 -0700377 if (fan_data->speed_index < 0)
378 return -ENODEV;
Simon Guinotd6fe1362010-10-22 00:44:19 +0200379
Axel Lin4f5b7992010-11-09 08:41:48 +0000380 err = sysfs_create_group(&pdev->dev.kobj, &gpio_fan_ctrl_group);
Simon Guinotd6fe1362010-10-22 00:44:19 +0200381 return err;
382}
383
384static void fan_ctrl_free(struct gpio_fan_data *fan_data)
385{
386 struct platform_device *pdev = fan_data->pdev;
Simon Guinotd6fe1362010-10-22 00:44:19 +0200387
388 sysfs_remove_group(&pdev->dev.kobj, &gpio_fan_ctrl_group);
Simon Guinotd6fe1362010-10-22 00:44:19 +0200389}
390
391/*
392 * Platform driver.
393 */
394
395static ssize_t show_name(struct device *dev,
396 struct device_attribute *attr, char *buf)
397{
398 return sprintf(buf, "gpio-fan\n");
399}
400
401static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
402
403static int __devinit gpio_fan_probe(struct platform_device *pdev)
404{
405 int err;
406 struct gpio_fan_data *fan_data;
407 struct gpio_fan_platform_data *pdata = pdev->dev.platform_data;
408
409 if (!pdata)
410 return -EINVAL;
411
Guenter Roeckd00985f2012-06-02 09:58:07 -0700412 fan_data = devm_kzalloc(&pdev->dev, sizeof(struct gpio_fan_data),
413 GFP_KERNEL);
Simon Guinotd6fe1362010-10-22 00:44:19 +0200414 if (!fan_data)
415 return -ENOMEM;
416
417 fan_data->pdev = pdev;
418 platform_set_drvdata(pdev, fan_data);
419 mutex_init(&fan_data->lock);
420
421 /* Configure alarm GPIO if available. */
422 if (pdata->alarm) {
423 err = fan_alarm_init(fan_data, pdata->alarm);
424 if (err)
Guenter Roeckd00985f2012-06-02 09:58:07 -0700425 return err;
Simon Guinotd6fe1362010-10-22 00:44:19 +0200426 }
427
428 /* Configure control GPIOs if available. */
429 if (pdata->ctrl && pdata->num_ctrl > 0) {
430 if (!pdata->speed || pdata->num_speed <= 1) {
431 err = -EINVAL;
432 goto err_free_alarm;
433 }
434 err = fan_ctrl_init(fan_data, pdata);
435 if (err)
436 goto err_free_alarm;
437 }
438
439 err = device_create_file(&pdev->dev, &dev_attr_name);
440 if (err)
441 goto err_free_ctrl;
442
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;
448 }
449
450 dev_info(&pdev->dev, "GPIO fan initialized\n");
451
452 return 0;
453
454err_remove_name:
455 device_remove_file(&pdev->dev, &dev_attr_name);
456err_free_ctrl:
457 if (fan_data->ctrl)
458 fan_ctrl_free(fan_data);
459err_free_alarm:
460 if (fan_data->alarm)
461 fan_alarm_free(fan_data);
Simon Guinotd6fe1362010-10-22 00:44:19 +0200462 return err;
463}
464
465static int __devexit gpio_fan_remove(struct platform_device *pdev)
466{
467 struct gpio_fan_data *fan_data = platform_get_drvdata(pdev);
468
469 hwmon_device_unregister(fan_data->hwmon_dev);
470 device_remove_file(&pdev->dev, &dev_attr_name);
471 if (fan_data->alarm)
472 fan_alarm_free(fan_data);
473 if (fan_data->ctrl)
474 fan_ctrl_free(fan_data);
Simon Guinotd6fe1362010-10-22 00:44:19 +0200475
476 return 0;
477}
478
Rafael J. Wysocki6d20a6c2012-07-08 00:01:03 +0200479#ifdef CONFIG_PM_SLEEP
480static int gpio_fan_suspend(struct device *dev)
Simon Guinotd6fe1362010-10-22 00:44:19 +0200481{
Rafael J. Wysocki6d20a6c2012-07-08 00:01:03 +0200482 struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
Simon Guinotd6fe1362010-10-22 00:44:19 +0200483
484 if (fan_data->ctrl) {
485 fan_data->resume_speed = fan_data->speed_index;
486 set_fan_speed(fan_data, 0);
487 }
488
489 return 0;
490}
491
Rafael J. Wysocki6d20a6c2012-07-08 00:01:03 +0200492static int gpio_fan_resume(struct device *dev)
Simon Guinotd6fe1362010-10-22 00:44:19 +0200493{
Rafael J. Wysocki6d20a6c2012-07-08 00:01:03 +0200494 struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
Simon Guinotd6fe1362010-10-22 00:44:19 +0200495
496 if (fan_data->ctrl)
497 set_fan_speed(fan_data, fan_data->resume_speed);
498
499 return 0;
500}
Rafael J. Wysocki6d20a6c2012-07-08 00:01:03 +0200501
502static SIMPLE_DEV_PM_OPS(gpio_fan_pm, gpio_fan_suspend, gpio_fan_resume);
503#define GPIO_FAN_PM &gpio_fan_pm
Simon Guinotd6fe1362010-10-22 00:44:19 +0200504#else
Rafael J. Wysocki6d20a6c2012-07-08 00:01:03 +0200505#define GPIO_FAN_PM NULL
Simon Guinotd6fe1362010-10-22 00:44:19 +0200506#endif
507
508static struct platform_driver gpio_fan_driver = {
509 .probe = gpio_fan_probe,
510 .remove = __devexit_p(gpio_fan_remove),
Simon Guinotd6fe1362010-10-22 00:44:19 +0200511 .driver = {
512 .name = "gpio-fan",
Rafael J. Wysocki6d20a6c2012-07-08 00:01:03 +0200513 .pm = GPIO_FAN_PM,
Simon Guinotd6fe1362010-10-22 00:44:19 +0200514 },
515};
516
Axel Lin25a236a2011-11-25 02:31:00 -0500517module_platform_driver(gpio_fan_driver);
Simon Guinotd6fe1362010-10-22 00:44:19 +0200518
519MODULE_AUTHOR("Simon Guinot <sguinot@lacie.com>");
520MODULE_DESCRIPTION("GPIO FAN driver");
521MODULE_LICENSE("GPL");
522MODULE_ALIAS("platform:gpio-fan");