xref: /openbmc/linux/drivers/hwmon/gpio-fan.c (revision 6774def6)
1 /*
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 #include <linux/of.h>
35 #include <linux/of_platform.h>
36 #include <linux/of_gpio.h>
37 
38 struct gpio_fan_data {
39 	struct platform_device	*pdev;
40 	struct device		*hwmon_dev;
41 	struct mutex		lock; /* lock GPIOs operations. */
42 	int			num_ctrl;
43 	unsigned		*ctrl;
44 	int			num_speed;
45 	struct gpio_fan_speed	*speed;
46 	int			speed_index;
47 #ifdef CONFIG_PM_SLEEP
48 	int			resume_speed;
49 #endif
50 	bool			pwm_enable;
51 	struct gpio_fan_alarm	*alarm;
52 	struct work_struct	alarm_work;
53 };
54 
55 /*
56  * Alarm GPIO.
57  */
58 
59 static void fan_alarm_notify(struct work_struct *ws)
60 {
61 	struct gpio_fan_data *fan_data =
62 		container_of(ws, struct gpio_fan_data, alarm_work);
63 
64 	sysfs_notify(&fan_data->pdev->dev.kobj, NULL, "fan1_alarm");
65 	kobject_uevent(&fan_data->pdev->dev.kobj, KOBJ_CHANGE);
66 }
67 
68 static irqreturn_t fan_alarm_irq_handler(int irq, void *dev_id)
69 {
70 	struct gpio_fan_data *fan_data = dev_id;
71 
72 	schedule_work(&fan_data->alarm_work);
73 
74 	return IRQ_NONE;
75 }
76 
77 static ssize_t show_fan_alarm(struct device *dev,
78 			      struct device_attribute *attr, char *buf)
79 {
80 	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
81 	struct gpio_fan_alarm *alarm = fan_data->alarm;
82 	int value = gpio_get_value(alarm->gpio);
83 
84 	if (alarm->active_low)
85 		value = !value;
86 
87 	return sprintf(buf, "%d\n", value);
88 }
89 
90 static DEVICE_ATTR(fan1_alarm, S_IRUGO, show_fan_alarm, NULL);
91 
92 static int fan_alarm_init(struct gpio_fan_data *fan_data,
93 			  struct gpio_fan_alarm *alarm)
94 {
95 	int err;
96 	int alarm_irq;
97 	struct platform_device *pdev = fan_data->pdev;
98 
99 	fan_data->alarm = alarm;
100 
101 	err = devm_gpio_request(&pdev->dev, alarm->gpio, "GPIO fan alarm");
102 	if (err)
103 		return err;
104 
105 	err = gpio_direction_input(alarm->gpio);
106 	if (err)
107 		return err;
108 
109 	/*
110 	 * If the alarm GPIO don't support interrupts, just leave
111 	 * without initializing the fail notification support.
112 	 */
113 	alarm_irq = gpio_to_irq(alarm->gpio);
114 	if (alarm_irq < 0)
115 		return 0;
116 
117 	INIT_WORK(&fan_data->alarm_work, fan_alarm_notify);
118 	irq_set_irq_type(alarm_irq, IRQ_TYPE_EDGE_BOTH);
119 	err = devm_request_irq(&pdev->dev, alarm_irq, fan_alarm_irq_handler,
120 			       IRQF_SHARED, "GPIO fan alarm", fan_data);
121 	return err;
122 }
123 
124 /*
125  * Control GPIOs.
126  */
127 
128 /* Must be called with fan_data->lock held, except during initialization. */
129 static void __set_fan_ctrl(struct gpio_fan_data *fan_data, int ctrl_val)
130 {
131 	int i;
132 
133 	for (i = 0; i < fan_data->num_ctrl; i++)
134 		gpio_set_value(fan_data->ctrl[i], (ctrl_val >> i) & 1);
135 }
136 
137 static int __get_fan_ctrl(struct gpio_fan_data *fan_data)
138 {
139 	int i;
140 	int ctrl_val = 0;
141 
142 	for (i = 0; i < fan_data->num_ctrl; i++) {
143 		int value;
144 
145 		value = gpio_get_value(fan_data->ctrl[i]);
146 		ctrl_val |= (value << i);
147 	}
148 	return ctrl_val;
149 }
150 
151 /* Must be called with fan_data->lock held, except during initialization. */
152 static void set_fan_speed(struct gpio_fan_data *fan_data, int speed_index)
153 {
154 	if (fan_data->speed_index == speed_index)
155 		return;
156 
157 	__set_fan_ctrl(fan_data, fan_data->speed[speed_index].ctrl_val);
158 	fan_data->speed_index = speed_index;
159 }
160 
161 static int get_fan_speed_index(struct gpio_fan_data *fan_data)
162 {
163 	int ctrl_val = __get_fan_ctrl(fan_data);
164 	int i;
165 
166 	for (i = 0; i < fan_data->num_speed; i++)
167 		if (fan_data->speed[i].ctrl_val == ctrl_val)
168 			return i;
169 
170 	dev_warn(&fan_data->pdev->dev,
171 		 "missing speed array entry for GPIO value 0x%x\n", ctrl_val);
172 
173 	return -ENODEV;
174 }
175 
176 static int rpm_to_speed_index(struct gpio_fan_data *fan_data, unsigned long rpm)
177 {
178 	struct gpio_fan_speed *speed = fan_data->speed;
179 	int i;
180 
181 	for (i = 0; i < fan_data->num_speed; i++)
182 		if (speed[i].rpm >= rpm)
183 			return i;
184 
185 	return fan_data->num_speed - 1;
186 }
187 
188 static ssize_t show_pwm(struct device *dev,
189 			struct device_attribute *attr, char *buf)
190 {
191 	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
192 	u8 pwm = fan_data->speed_index * 255 / (fan_data->num_speed - 1);
193 
194 	return sprintf(buf, "%d\n", pwm);
195 }
196 
197 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
198 		       const char *buf, size_t count)
199 {
200 	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
201 	unsigned long pwm;
202 	int speed_index;
203 	int ret = count;
204 
205 	if (kstrtoul(buf, 10, &pwm) || pwm > 255)
206 		return -EINVAL;
207 
208 	mutex_lock(&fan_data->lock);
209 
210 	if (!fan_data->pwm_enable) {
211 		ret = -EPERM;
212 		goto exit_unlock;
213 	}
214 
215 	speed_index = DIV_ROUND_UP(pwm * (fan_data->num_speed - 1), 255);
216 	set_fan_speed(fan_data, speed_index);
217 
218 exit_unlock:
219 	mutex_unlock(&fan_data->lock);
220 
221 	return ret;
222 }
223 
224 static ssize_t show_pwm_enable(struct device *dev,
225 			       struct device_attribute *attr, char *buf)
226 {
227 	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
228 
229 	return sprintf(buf, "%d\n", fan_data->pwm_enable);
230 }
231 
232 static ssize_t set_pwm_enable(struct device *dev, struct device_attribute *attr,
233 			      const char *buf, size_t count)
234 {
235 	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
236 	unsigned long val;
237 
238 	if (kstrtoul(buf, 10, &val) || val > 1)
239 		return -EINVAL;
240 
241 	if (fan_data->pwm_enable == val)
242 		return count;
243 
244 	mutex_lock(&fan_data->lock);
245 
246 	fan_data->pwm_enable = val;
247 
248 	/* Disable manual control mode: set fan at full speed. */
249 	if (val == 0)
250 		set_fan_speed(fan_data, fan_data->num_speed - 1);
251 
252 	mutex_unlock(&fan_data->lock);
253 
254 	return count;
255 }
256 
257 static ssize_t show_pwm_mode(struct device *dev,
258 			     struct device_attribute *attr, char *buf)
259 {
260 	return sprintf(buf, "0\n");
261 }
262 
263 static ssize_t show_rpm_min(struct device *dev,
264 			    struct device_attribute *attr, char *buf)
265 {
266 	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
267 
268 	return sprintf(buf, "%d\n", fan_data->speed[0].rpm);
269 }
270 
271 static ssize_t show_rpm_max(struct device *dev,
272 			    struct device_attribute *attr, char *buf)
273 {
274 	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
275 
276 	return sprintf(buf, "%d\n",
277 		       fan_data->speed[fan_data->num_speed - 1].rpm);
278 }
279 
280 static ssize_t show_rpm(struct device *dev,
281 			struct device_attribute *attr, char *buf)
282 {
283 	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
284 
285 	return sprintf(buf, "%d\n", fan_data->speed[fan_data->speed_index].rpm);
286 }
287 
288 static ssize_t set_rpm(struct device *dev, struct device_attribute *attr,
289 		       const char *buf, size_t count)
290 {
291 	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
292 	unsigned long rpm;
293 	int ret = count;
294 
295 	if (kstrtoul(buf, 10, &rpm))
296 		return -EINVAL;
297 
298 	mutex_lock(&fan_data->lock);
299 
300 	if (!fan_data->pwm_enable) {
301 		ret = -EPERM;
302 		goto exit_unlock;
303 	}
304 
305 	set_fan_speed(fan_data, rpm_to_speed_index(fan_data, rpm));
306 
307 exit_unlock:
308 	mutex_unlock(&fan_data->lock);
309 
310 	return ret;
311 }
312 
313 static DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, set_pwm);
314 static DEVICE_ATTR(pwm1_enable, S_IRUGO | S_IWUSR,
315 		   show_pwm_enable, set_pwm_enable);
316 static DEVICE_ATTR(pwm1_mode, S_IRUGO, show_pwm_mode, NULL);
317 static DEVICE_ATTR(fan1_min, S_IRUGO, show_rpm_min, NULL);
318 static DEVICE_ATTR(fan1_max, S_IRUGO, show_rpm_max, NULL);
319 static DEVICE_ATTR(fan1_input, S_IRUGO, show_rpm, NULL);
320 static DEVICE_ATTR(fan1_target, S_IRUGO | S_IWUSR, show_rpm, set_rpm);
321 
322 static umode_t gpio_fan_is_visible(struct kobject *kobj,
323 				   struct attribute *attr, int index)
324 {
325 	struct device *dev = container_of(kobj, struct device, kobj);
326 	struct gpio_fan_data *data = dev_get_drvdata(dev);
327 
328 	if (index == 0 && !data->alarm)
329 		return 0;
330 	if (index > 0 && !data->ctrl)
331 		return 0;
332 
333 	return attr->mode;
334 }
335 
336 static struct attribute *gpio_fan_attributes[] = {
337 	&dev_attr_fan1_alarm.attr,		/* 0 */
338 	&dev_attr_pwm1.attr,			/* 1 */
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 
348 static const struct attribute_group gpio_fan_group = {
349 	.attrs = gpio_fan_attributes,
350 	.is_visible = gpio_fan_is_visible,
351 };
352 
353 static const struct attribute_group *gpio_fan_groups[] = {
354 	&gpio_fan_group,
355 	NULL
356 };
357 
358 static int fan_ctrl_init(struct gpio_fan_data *fan_data,
359 			 struct gpio_fan_platform_data *pdata)
360 {
361 	struct platform_device *pdev = fan_data->pdev;
362 	int num_ctrl = pdata->num_ctrl;
363 	unsigned *ctrl = pdata->ctrl;
364 	int i, err;
365 
366 	for (i = 0; i < num_ctrl; i++) {
367 		err = devm_gpio_request(&pdev->dev, ctrl[i],
368 					"GPIO fan control");
369 		if (err)
370 			return err;
371 
372 		err = gpio_direction_output(ctrl[i], gpio_get_value(ctrl[i]));
373 		if (err)
374 			return err;
375 	}
376 
377 	fan_data->num_ctrl = num_ctrl;
378 	fan_data->ctrl = ctrl;
379 	fan_data->num_speed = pdata->num_speed;
380 	fan_data->speed = pdata->speed;
381 	fan_data->pwm_enable = true; /* Enable manual fan speed control. */
382 	fan_data->speed_index = get_fan_speed_index(fan_data);
383 	if (fan_data->speed_index < 0)
384 		return fan_data->speed_index;
385 
386 	return 0;
387 }
388 
389 #ifdef CONFIG_OF_GPIO
390 /*
391  * Translate OpenFirmware node properties into platform_data
392  */
393 static int gpio_fan_get_of_pdata(struct device *dev,
394 			    struct gpio_fan_platform_data *pdata)
395 {
396 	struct device_node *node;
397 	struct gpio_fan_speed *speed;
398 	unsigned *ctrl;
399 	unsigned i;
400 	u32 u;
401 	struct property *prop;
402 	const __be32 *p;
403 
404 	node = dev->of_node;
405 
406 	/* Fill GPIO pin array */
407 	pdata->num_ctrl = of_gpio_count(node);
408 	if (pdata->num_ctrl <= 0) {
409 		dev_err(dev, "gpios DT property empty / missing");
410 		return -ENODEV;
411 	}
412 	ctrl = devm_kzalloc(dev, pdata->num_ctrl * sizeof(unsigned),
413 				GFP_KERNEL);
414 	if (!ctrl)
415 		return -ENOMEM;
416 	for (i = 0; i < pdata->num_ctrl; i++) {
417 		int val;
418 
419 		val = of_get_gpio(node, i);
420 		if (val < 0)
421 			return val;
422 		ctrl[i] = val;
423 	}
424 	pdata->ctrl = ctrl;
425 
426 	/* Get number of RPM/ctrl_val pairs in speed map */
427 	prop = of_find_property(node, "gpio-fan,speed-map", &i);
428 	if (!prop) {
429 		dev_err(dev, "gpio-fan,speed-map DT property missing");
430 		return -ENODEV;
431 	}
432 	i = i / sizeof(u32);
433 	if (i == 0 || i & 1) {
434 		dev_err(dev, "gpio-fan,speed-map contains zero/odd number of entries");
435 		return -ENODEV;
436 	}
437 	pdata->num_speed = i / 2;
438 
439 	/*
440 	 * Populate speed map
441 	 * Speed map is in the form <RPM ctrl_val RPM ctrl_val ...>
442 	 * this needs splitting into pairs to create gpio_fan_speed structs
443 	 */
444 	speed = devm_kzalloc(dev,
445 			pdata->num_speed * sizeof(struct gpio_fan_speed),
446 			GFP_KERNEL);
447 	if (!speed)
448 		return -ENOMEM;
449 	p = NULL;
450 	for (i = 0; i < pdata->num_speed; i++) {
451 		p = of_prop_next_u32(prop, p, &u);
452 		if (!p)
453 			return -ENODEV;
454 		speed[i].rpm = u;
455 		p = of_prop_next_u32(prop, p, &u);
456 		if (!p)
457 			return -ENODEV;
458 		speed[i].ctrl_val = u;
459 	}
460 	pdata->speed = speed;
461 
462 	/* Alarm GPIO if one exists */
463 	if (of_gpio_named_count(node, "alarm-gpios") > 0) {
464 		struct gpio_fan_alarm *alarm;
465 		int val;
466 		enum of_gpio_flags flags;
467 
468 		alarm = devm_kzalloc(dev, sizeof(struct gpio_fan_alarm),
469 					GFP_KERNEL);
470 		if (!alarm)
471 			return -ENOMEM;
472 
473 		val = of_get_named_gpio_flags(node, "alarm-gpios", 0, &flags);
474 		if (val < 0)
475 			return val;
476 		alarm->gpio = val;
477 		alarm->active_low = flags & OF_GPIO_ACTIVE_LOW;
478 
479 		pdata->alarm = alarm;
480 	}
481 
482 	return 0;
483 }
484 
485 static const struct of_device_id of_gpio_fan_match[] = {
486 	{ .compatible = "gpio-fan", },
487 	{},
488 };
489 #endif /* CONFIG_OF_GPIO */
490 
491 static int gpio_fan_probe(struct platform_device *pdev)
492 {
493 	int err;
494 	struct gpio_fan_data *fan_data;
495 	struct gpio_fan_platform_data *pdata = dev_get_platdata(&pdev->dev);
496 
497 #ifdef CONFIG_OF_GPIO
498 	if (!pdata) {
499 		pdata = devm_kzalloc(&pdev->dev,
500 					sizeof(struct gpio_fan_platform_data),
501 					GFP_KERNEL);
502 		if (!pdata)
503 			return -ENOMEM;
504 
505 		err = gpio_fan_get_of_pdata(&pdev->dev, pdata);
506 		if (err)
507 			return err;
508 	}
509 #else /* CONFIG_OF_GPIO */
510 	if (!pdata)
511 		return -EINVAL;
512 #endif /* CONFIG_OF_GPIO */
513 
514 	fan_data = devm_kzalloc(&pdev->dev, sizeof(struct gpio_fan_data),
515 				GFP_KERNEL);
516 	if (!fan_data)
517 		return -ENOMEM;
518 
519 	fan_data->pdev = pdev;
520 	platform_set_drvdata(pdev, fan_data);
521 	mutex_init(&fan_data->lock);
522 
523 	/* Configure alarm GPIO if available. */
524 	if (pdata->alarm) {
525 		err = fan_alarm_init(fan_data, pdata->alarm);
526 		if (err)
527 			return err;
528 	}
529 
530 	/* Configure control GPIOs if available. */
531 	if (pdata->ctrl && pdata->num_ctrl > 0) {
532 		if (!pdata->speed || pdata->num_speed <= 1)
533 			return -EINVAL;
534 		err = fan_ctrl_init(fan_data, pdata);
535 		if (err)
536 			return err;
537 	}
538 
539 	/* Make this driver part of hwmon class. */
540 	fan_data->hwmon_dev =
541 		devm_hwmon_device_register_with_groups(&pdev->dev,
542 						       "gpio_fan", fan_data,
543 						       gpio_fan_groups);
544 	if (IS_ERR(fan_data->hwmon_dev))
545 		return PTR_ERR(fan_data->hwmon_dev);
546 
547 	dev_info(&pdev->dev, "GPIO fan initialized\n");
548 
549 	return 0;
550 }
551 
552 #ifdef CONFIG_PM_SLEEP
553 static int gpio_fan_suspend(struct device *dev)
554 {
555 	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
556 
557 	if (fan_data->ctrl) {
558 		fan_data->resume_speed = fan_data->speed_index;
559 		set_fan_speed(fan_data, 0);
560 	}
561 
562 	return 0;
563 }
564 
565 static int gpio_fan_resume(struct device *dev)
566 {
567 	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
568 
569 	if (fan_data->ctrl)
570 		set_fan_speed(fan_data, fan_data->resume_speed);
571 
572 	return 0;
573 }
574 
575 static SIMPLE_DEV_PM_OPS(gpio_fan_pm, gpio_fan_suspend, gpio_fan_resume);
576 #define GPIO_FAN_PM	(&gpio_fan_pm)
577 #else
578 #define GPIO_FAN_PM	NULL
579 #endif
580 
581 static struct platform_driver gpio_fan_driver = {
582 	.probe		= gpio_fan_probe,
583 	.driver	= {
584 		.name	= "gpio-fan",
585 		.pm	= GPIO_FAN_PM,
586 #ifdef CONFIG_OF_GPIO
587 		.of_match_table = of_match_ptr(of_gpio_fan_match),
588 #endif
589 	},
590 };
591 
592 module_platform_driver(gpio_fan_driver);
593 
594 MODULE_AUTHOR("Simon Guinot <sguinot@lacie.com>");
595 MODULE_DESCRIPTION("GPIO FAN driver");
596 MODULE_LICENSE("GPL");
597 MODULE_ALIAS("platform:gpio-fan");
598