1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * pwm-fan.c - Hwmon driver for fans connected to PWM lines.
4 *
5 * Copyright (c) 2014 Samsung Electronics Co., Ltd.
6 *
7 * Author: Kamil Debski <k.debski@samsung.com>
8 */
9
10#include <linux/hwmon.h>
11#include <linux/interrupt.h>
12#include <linux/module.h>
13#include <linux/mutex.h>
14#include <linux/of.h>
15#include <linux/platform_device.h>
16#include <linux/pwm.h>
17#include <linux/regulator/consumer.h>
18#include <linux/sysfs.h>
19#include <linux/thermal.h>
20#include <linux/timer.h>
21
22#define MAX_PWM 255
23
24struct pwm_fan_tach {
25	int irq;
26	atomic_t pulses;
27	unsigned int rpm;
28	u8 pulses_per_revolution;
29};
30
31enum pwm_fan_enable_mode {
32	pwm_off_reg_off,
33	pwm_disable_reg_enable,
34	pwm_enable_reg_enable,
35	pwm_disable_reg_disable,
36};
37
38struct pwm_fan_ctx {
39	struct device *dev;
40
41	struct mutex lock;
42	struct pwm_device *pwm;
43	struct pwm_state pwm_state;
44	struct regulator *reg_en;
45	enum pwm_fan_enable_mode enable_mode;
46	bool regulator_enabled;
47	bool enabled;
48
49	int tach_count;
50	struct pwm_fan_tach *tachs;
51	ktime_t sample_start;
52	struct timer_list rpm_timer;
53
54	unsigned int pwm_value;
55	unsigned int pwm_fan_state;
56	unsigned int pwm_fan_max_state;
57	unsigned int *pwm_fan_cooling_levels;
58	struct thermal_cooling_device *cdev;
59
60	struct hwmon_chip_info info;
61	struct hwmon_channel_info fan_channel;
62};
63
64/* This handler assumes self resetting edge triggered interrupt. */
65static irqreturn_t pulse_handler(int irq, void *dev_id)
66{
67	struct pwm_fan_tach *tach = dev_id;
68
69	atomic_inc(&tach->pulses);
70
71	return IRQ_HANDLED;
72}
73
74static void sample_timer(struct timer_list *t)
75{
76	struct pwm_fan_ctx *ctx = from_timer(ctx, t, rpm_timer);
77	unsigned int delta = ktime_ms_delta(ktime_get(), ctx->sample_start);
78	int i;
79
80	if (delta) {
81		for (i = 0; i < ctx->tach_count; i++) {
82			struct pwm_fan_tach *tach = &ctx->tachs[i];
83			int pulses;
84
85			pulses = atomic_read(&tach->pulses);
86			atomic_sub(pulses, &tach->pulses);
87			tach->rpm = (unsigned int)(pulses * 1000 * 60) /
88				(tach->pulses_per_revolution * delta);
89		}
90
91		ctx->sample_start = ktime_get();
92	}
93
94	mod_timer(&ctx->rpm_timer, jiffies + HZ);
95}
96
97static void pwm_fan_enable_mode_2_state(int enable_mode,
98					struct pwm_state *state,
99					bool *enable_regulator)
100{
101	switch (enable_mode) {
102	case pwm_disable_reg_enable:
103		/* disable pwm, keep regulator enabled */
104		state->enabled = false;
105		*enable_regulator = true;
106		break;
107	case pwm_enable_reg_enable:
108		/* keep pwm and regulator enabled */
109		state->enabled = true;
110		*enable_regulator = true;
111		break;
112	case pwm_off_reg_off:
113	case pwm_disable_reg_disable:
114		/* disable pwm and regulator */
115		state->enabled = false;
116		*enable_regulator = false;
117	}
118}
119
120static int pwm_fan_switch_power(struct pwm_fan_ctx *ctx, bool on)
121{
122	int ret = 0;
123
124	if (!ctx->reg_en)
125		return ret;
126
127	if (!ctx->regulator_enabled && on) {
128		ret = regulator_enable(ctx->reg_en);
129		if (ret == 0)
130			ctx->regulator_enabled = true;
131	} else if (ctx->regulator_enabled && !on) {
132		ret = regulator_disable(ctx->reg_en);
133		if (ret == 0)
134			ctx->regulator_enabled = false;
135	}
136	return ret;
137}
138
139static int pwm_fan_power_on(struct pwm_fan_ctx *ctx)
140{
141	struct pwm_state *state = &ctx->pwm_state;
142	int ret;
143
144	if (ctx->enabled)
145		return 0;
146
147	ret = pwm_fan_switch_power(ctx, true);
148	if (ret < 0) {
149		dev_err(ctx->dev, "failed to enable power supply\n");
150		return ret;
151	}
152
153	state->enabled = true;
154	ret = pwm_apply_might_sleep(ctx->pwm, state);
155	if (ret) {
156		dev_err(ctx->dev, "failed to enable PWM\n");
157		goto disable_regulator;
158	}
159
160	ctx->enabled = true;
161
162	return 0;
163
164disable_regulator:
165	pwm_fan_switch_power(ctx, false);
166	return ret;
167}
168
169static int pwm_fan_power_off(struct pwm_fan_ctx *ctx)
170{
171	struct pwm_state *state = &ctx->pwm_state;
172	bool enable_regulator = false;
173	int ret;
174
175	if (!ctx->enabled)
176		return 0;
177
178	pwm_fan_enable_mode_2_state(ctx->enable_mode,
179				    state,
180				    &enable_regulator);
181
182	state->enabled = false;
183	state->duty_cycle = 0;
184	ret = pwm_apply_might_sleep(ctx->pwm, state);
185	if (ret) {
186		dev_err(ctx->dev, "failed to disable PWM\n");
187		return ret;
188	}
189
190	pwm_fan_switch_power(ctx, enable_regulator);
191
192	ctx->enabled = false;
193
194	return 0;
195}
196
197static int  __set_pwm(struct pwm_fan_ctx *ctx, unsigned long pwm)
198{
199	struct pwm_state *state = &ctx->pwm_state;
200	unsigned long period;
201	int ret = 0;
202
203	if (pwm > 0) {
204		if (ctx->enable_mode == pwm_off_reg_off)
205			/* pwm-fan hard disabled */
206			return 0;
207
208		period = state->period;
209		state->duty_cycle = DIV_ROUND_UP(pwm * (period - 1), MAX_PWM);
210		ret = pwm_apply_might_sleep(ctx->pwm, state);
211		if (ret)
212			return ret;
213		ret = pwm_fan_power_on(ctx);
214	} else {
215		ret = pwm_fan_power_off(ctx);
216	}
217	if (!ret)
218		ctx->pwm_value = pwm;
219
220	return ret;
221}
222
223static int set_pwm(struct pwm_fan_ctx *ctx, unsigned long pwm)
224{
225	int ret;
226
227	mutex_lock(&ctx->lock);
228	ret = __set_pwm(ctx, pwm);
229	mutex_unlock(&ctx->lock);
230
231	return ret;
232}
233
234static void pwm_fan_update_state(struct pwm_fan_ctx *ctx, unsigned long pwm)
235{
236	int i;
237
238	for (i = 0; i < ctx->pwm_fan_max_state; ++i)
239		if (pwm < ctx->pwm_fan_cooling_levels[i + 1])
240			break;
241
242	ctx->pwm_fan_state = i;
243}
244
245static int pwm_fan_update_enable(struct pwm_fan_ctx *ctx, long val)
246{
247	int ret = 0;
248	int old_val;
249
250	mutex_lock(&ctx->lock);
251
252	if (ctx->enable_mode == val)
253		goto out;
254
255	old_val = ctx->enable_mode;
256	ctx->enable_mode = val;
257
258	if (val == 0) {
259		/* Disable pwm-fan unconditionally */
260		if (ctx->enabled)
261			ret = __set_pwm(ctx, 0);
262		else
263			ret = pwm_fan_switch_power(ctx, false);
264		if (ret)
265			ctx->enable_mode = old_val;
266		pwm_fan_update_state(ctx, 0);
267	} else {
268		/*
269		 * Change PWM and/or regulator state if currently disabled
270		 * Nothing to do if currently enabled
271		 */
272		if (!ctx->enabled) {
273			struct pwm_state *state = &ctx->pwm_state;
274			bool enable_regulator = false;
275
276			state->duty_cycle = 0;
277			pwm_fan_enable_mode_2_state(val,
278						    state,
279						    &enable_regulator);
280
281			pwm_apply_might_sleep(ctx->pwm, state);
282			pwm_fan_switch_power(ctx, enable_regulator);
283			pwm_fan_update_state(ctx, 0);
284		}
285	}
286out:
287	mutex_unlock(&ctx->lock);
288
289	return ret;
290}
291
292static int pwm_fan_write(struct device *dev, enum hwmon_sensor_types type,
293			 u32 attr, int channel, long val)
294{
295	struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
296	int ret;
297
298	switch (attr) {
299	case hwmon_pwm_input:
300		if (val < 0 || val > MAX_PWM)
301			return -EINVAL;
302		ret = set_pwm(ctx, val);
303		if (ret)
304			return ret;
305		pwm_fan_update_state(ctx, val);
306		break;
307	case hwmon_pwm_enable:
308		if (val < 0 || val > 3)
309			ret = -EINVAL;
310		else
311			ret = pwm_fan_update_enable(ctx, val);
312
313		return ret;
314	default:
315		return -EOPNOTSUPP;
316	}
317
318	return 0;
319}
320
321static int pwm_fan_read(struct device *dev, enum hwmon_sensor_types type,
322			u32 attr, int channel, long *val)
323{
324	struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
325
326	switch (type) {
327	case hwmon_pwm:
328		switch (attr) {
329		case hwmon_pwm_input:
330			*val = ctx->pwm_value;
331			return 0;
332		case hwmon_pwm_enable:
333			*val = ctx->enable_mode;
334			return 0;
335		}
336		return -EOPNOTSUPP;
337	case hwmon_fan:
338		*val = ctx->tachs[channel].rpm;
339		return 0;
340
341	default:
342		return -ENOTSUPP;
343	}
344}
345
346static umode_t pwm_fan_is_visible(const void *data,
347				  enum hwmon_sensor_types type,
348				  u32 attr, int channel)
349{
350	switch (type) {
351	case hwmon_pwm:
352		return 0644;
353
354	case hwmon_fan:
355		return 0444;
356
357	default:
358		return 0;
359	}
360}
361
362static const struct hwmon_ops pwm_fan_hwmon_ops = {
363	.is_visible = pwm_fan_is_visible,
364	.read = pwm_fan_read,
365	.write = pwm_fan_write,
366};
367
368/* thermal cooling device callbacks */
369static int pwm_fan_get_max_state(struct thermal_cooling_device *cdev,
370				 unsigned long *state)
371{
372	struct pwm_fan_ctx *ctx = cdev->devdata;
373
374	if (!ctx)
375		return -EINVAL;
376
377	*state = ctx->pwm_fan_max_state;
378
379	return 0;
380}
381
382static int pwm_fan_get_cur_state(struct thermal_cooling_device *cdev,
383				 unsigned long *state)
384{
385	struct pwm_fan_ctx *ctx = cdev->devdata;
386
387	if (!ctx)
388		return -EINVAL;
389
390	*state = ctx->pwm_fan_state;
391
392	return 0;
393}
394
395static int
396pwm_fan_set_cur_state(struct thermal_cooling_device *cdev, unsigned long state)
397{
398	struct pwm_fan_ctx *ctx = cdev->devdata;
399	int ret;
400
401	if (!ctx || (state > ctx->pwm_fan_max_state))
402		return -EINVAL;
403
404	if (state == ctx->pwm_fan_state)
405		return 0;
406
407	ret = set_pwm(ctx, ctx->pwm_fan_cooling_levels[state]);
408	if (ret) {
409		dev_err(&cdev->device, "Cannot set pwm!\n");
410		return ret;
411	}
412
413	ctx->pwm_fan_state = state;
414
415	return ret;
416}
417
418static const struct thermal_cooling_device_ops pwm_fan_cooling_ops = {
419	.get_max_state = pwm_fan_get_max_state,
420	.get_cur_state = pwm_fan_get_cur_state,
421	.set_cur_state = pwm_fan_set_cur_state,
422};
423
424static int pwm_fan_of_get_cooling_data(struct device *dev,
425				       struct pwm_fan_ctx *ctx)
426{
427	struct device_node *np = dev->of_node;
428	int num, i, ret;
429
430	if (!of_property_present(np, "cooling-levels"))
431		return 0;
432
433	ret = of_property_count_u32_elems(np, "cooling-levels");
434	if (ret <= 0) {
435		dev_err(dev, "Wrong data!\n");
436		return ret ? : -EINVAL;
437	}
438
439	num = ret;
440	ctx->pwm_fan_cooling_levels = devm_kcalloc(dev, num, sizeof(u32),
441						   GFP_KERNEL);
442	if (!ctx->pwm_fan_cooling_levels)
443		return -ENOMEM;
444
445	ret = of_property_read_u32_array(np, "cooling-levels",
446					 ctx->pwm_fan_cooling_levels, num);
447	if (ret) {
448		dev_err(dev, "Property 'cooling-levels' cannot be read!\n");
449		return ret;
450	}
451
452	for (i = 0; i < num; i++) {
453		if (ctx->pwm_fan_cooling_levels[i] > MAX_PWM) {
454			dev_err(dev, "PWM fan state[%d]:%d > %d\n", i,
455				ctx->pwm_fan_cooling_levels[i], MAX_PWM);
456			return -EINVAL;
457		}
458	}
459
460	ctx->pwm_fan_max_state = num - 1;
461
462	return 0;
463}
464
465static void pwm_fan_cleanup(void *__ctx)
466{
467	struct pwm_fan_ctx *ctx = __ctx;
468
469	del_timer_sync(&ctx->rpm_timer);
470	/* Switch off everything */
471	ctx->enable_mode = pwm_disable_reg_disable;
472	pwm_fan_power_off(ctx);
473}
474
475static int pwm_fan_probe(struct platform_device *pdev)
476{
477	struct thermal_cooling_device *cdev;
478	struct device *dev = &pdev->dev;
479	struct pwm_fan_ctx *ctx;
480	struct device *hwmon;
481	int ret;
482	const struct hwmon_channel_info **channels;
483	u32 *fan_channel_config;
484	int channel_count = 1;	/* We always have a PWM channel. */
485	int i;
486
487	ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
488	if (!ctx)
489		return -ENOMEM;
490
491	mutex_init(&ctx->lock);
492
493	ctx->dev = &pdev->dev;
494	ctx->pwm = devm_pwm_get(dev, NULL);
495	if (IS_ERR(ctx->pwm))
496		return dev_err_probe(dev, PTR_ERR(ctx->pwm), "Could not get PWM\n");
497
498	platform_set_drvdata(pdev, ctx);
499
500	ctx->reg_en = devm_regulator_get_optional(dev, "fan");
501	if (IS_ERR(ctx->reg_en)) {
502		if (PTR_ERR(ctx->reg_en) != -ENODEV)
503			return PTR_ERR(ctx->reg_en);
504
505		ctx->reg_en = NULL;
506	}
507
508	pwm_init_state(ctx->pwm, &ctx->pwm_state);
509
510	/*
511	 * PWM fans are controlled solely by the duty cycle of the PWM signal,
512	 * they do not care about the exact timing. Thus set usage_power to true
513	 * to allow less flexible hardware to work as a PWM source for fan
514	 * control.
515	 */
516	ctx->pwm_state.usage_power = true;
517
518	/*
519	 * set_pwm assumes that MAX_PWM * (period - 1) fits into an unsigned
520	 * long. Check this here to prevent the fan running at a too low
521	 * frequency.
522	 */
523	if (ctx->pwm_state.period > ULONG_MAX / MAX_PWM + 1) {
524		dev_err(dev, "Configured period too big\n");
525		return -EINVAL;
526	}
527
528	ctx->enable_mode = pwm_disable_reg_enable;
529
530	/*
531	 * Set duty cycle to maximum allowed and enable PWM output as well as
532	 * the regulator. In case of error nothing is changed
533	 */
534	ret = set_pwm(ctx, MAX_PWM);
535	if (ret) {
536		dev_err(dev, "Failed to configure PWM: %d\n", ret);
537		return ret;
538	}
539	timer_setup(&ctx->rpm_timer, sample_timer, 0);
540	ret = devm_add_action_or_reset(dev, pwm_fan_cleanup, ctx);
541	if (ret)
542		return ret;
543
544	ctx->tach_count = platform_irq_count(pdev);
545	if (ctx->tach_count < 0)
546		return dev_err_probe(dev, ctx->tach_count,
547				     "Could not get number of fan tachometer inputs\n");
548	dev_dbg(dev, "%d fan tachometer inputs\n", ctx->tach_count);
549
550	if (ctx->tach_count) {
551		channel_count++;	/* We also have a FAN channel. */
552
553		ctx->tachs = devm_kcalloc(dev, ctx->tach_count,
554					  sizeof(struct pwm_fan_tach),
555					  GFP_KERNEL);
556		if (!ctx->tachs)
557			return -ENOMEM;
558
559		ctx->fan_channel.type = hwmon_fan;
560		fan_channel_config = devm_kcalloc(dev, ctx->tach_count + 1,
561						  sizeof(u32), GFP_KERNEL);
562		if (!fan_channel_config)
563			return -ENOMEM;
564		ctx->fan_channel.config = fan_channel_config;
565	}
566
567	channels = devm_kcalloc(dev, channel_count + 1,
568				sizeof(struct hwmon_channel_info *), GFP_KERNEL);
569	if (!channels)
570		return -ENOMEM;
571
572	channels[0] = HWMON_CHANNEL_INFO(pwm, HWMON_PWM_INPUT | HWMON_PWM_ENABLE);
573
574	for (i = 0; i < ctx->tach_count; i++) {
575		struct pwm_fan_tach *tach = &ctx->tachs[i];
576		u32 ppr = 2;
577
578		tach->irq = platform_get_irq(pdev, i);
579		if (tach->irq == -EPROBE_DEFER)
580			return tach->irq;
581		if (tach->irq > 0) {
582			ret = devm_request_irq(dev, tach->irq, pulse_handler, 0,
583					       pdev->name, tach);
584			if (ret) {
585				dev_err(dev,
586					"Failed to request interrupt: %d\n",
587					ret);
588				return ret;
589			}
590		}
591
592		of_property_read_u32_index(dev->of_node,
593					   "pulses-per-revolution",
594					   i,
595					   &ppr);
596		tach->pulses_per_revolution = ppr;
597		if (!tach->pulses_per_revolution) {
598			dev_err(dev, "pulses-per-revolution can't be zero.\n");
599			return -EINVAL;
600		}
601
602		fan_channel_config[i] = HWMON_F_INPUT;
603
604		dev_dbg(dev, "tach%d: irq=%d, pulses_per_revolution=%d\n",
605			i, tach->irq, tach->pulses_per_revolution);
606	}
607
608	if (ctx->tach_count > 0) {
609		ctx->sample_start = ktime_get();
610		mod_timer(&ctx->rpm_timer, jiffies + HZ);
611
612		channels[1] = &ctx->fan_channel;
613	}
614
615	ctx->info.ops = &pwm_fan_hwmon_ops;
616	ctx->info.info = channels;
617
618	hwmon = devm_hwmon_device_register_with_info(dev, "pwmfan",
619						     ctx, &ctx->info, NULL);
620	if (IS_ERR(hwmon)) {
621		dev_err(dev, "Failed to register hwmon device\n");
622		return PTR_ERR(hwmon);
623	}
624
625	ret = pwm_fan_of_get_cooling_data(dev, ctx);
626	if (ret)
627		return ret;
628
629	ctx->pwm_fan_state = ctx->pwm_fan_max_state;
630	if (IS_ENABLED(CONFIG_THERMAL)) {
631		cdev = devm_thermal_of_cooling_device_register(dev,
632			dev->of_node, "pwm-fan", ctx, &pwm_fan_cooling_ops);
633		if (IS_ERR(cdev)) {
634			ret = PTR_ERR(cdev);
635			dev_err(dev,
636				"Failed to register pwm-fan as cooling device: %d\n",
637				ret);
638			return ret;
639		}
640		ctx->cdev = cdev;
641	}
642
643	return 0;
644}
645
646static void pwm_fan_shutdown(struct platform_device *pdev)
647{
648	struct pwm_fan_ctx *ctx = platform_get_drvdata(pdev);
649
650	pwm_fan_cleanup(ctx);
651}
652
653static int pwm_fan_suspend(struct device *dev)
654{
655	struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
656
657	return pwm_fan_power_off(ctx);
658}
659
660static int pwm_fan_resume(struct device *dev)
661{
662	struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
663
664	return set_pwm(ctx, ctx->pwm_value);
665}
666
667static DEFINE_SIMPLE_DEV_PM_OPS(pwm_fan_pm, pwm_fan_suspend, pwm_fan_resume);
668
669static const struct of_device_id of_pwm_fan_match[] = {
670	{ .compatible = "pwm-fan", },
671	{},
672};
673MODULE_DEVICE_TABLE(of, of_pwm_fan_match);
674
675static struct platform_driver pwm_fan_driver = {
676	.probe		= pwm_fan_probe,
677	.shutdown	= pwm_fan_shutdown,
678	.driver	= {
679		.name		= "pwm-fan",
680		.pm		= pm_sleep_ptr(&pwm_fan_pm),
681		.of_match_table	= of_pwm_fan_match,
682	},
683};
684
685module_platform_driver(pwm_fan_driver);
686
687MODULE_AUTHOR("Kamil Debski <k.debski@samsung.com>");
688MODULE_ALIAS("platform:pwm-fan");
689MODULE_DESCRIPTION("PWM FAN driver");
690MODULE_LICENSE("GPL");
691