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/hwmon-sysfs.h>
 12#include <linux/interrupt.h>
 13#include <linux/module.h>
 14#include <linux/mutex.h>
 15#include <linux/of.h>
 16#include <linux/platform_device.h>
 17#include <linux/pwm.h>
 18#include <linux/regulator/consumer.h>
 19#include <linux/sysfs.h>
 20#include <linux/thermal.h>
 21#include <linux/timer.h>
 22
 23#define MAX_PWM 255
 24
 25struct pwm_fan_ctx {
 26	struct mutex lock;
 27	struct pwm_device *pwm;
 28	struct regulator *reg_en;
 29
 30	int irq;
 31	atomic_t pulses;
 32	unsigned int rpm;
 33	u8 pulses_per_revolution;
 34	ktime_t sample_start;
 35	struct timer_list rpm_timer;
 36
 37	unsigned int pwm_value;
 38	unsigned int pwm_fan_state;
 39	unsigned int pwm_fan_max_state;
 40	unsigned int *pwm_fan_cooling_levels;
 41	struct thermal_cooling_device *cdev;
 42};
 43
 44/* This handler assumes self resetting edge triggered interrupt. */
 45static irqreturn_t pulse_handler(int irq, void *dev_id)
 46{
 47	struct pwm_fan_ctx *ctx = dev_id;
 48
 49	atomic_inc(&ctx->pulses);
 50
 51	return IRQ_HANDLED;
 52}
 53
 54static void sample_timer(struct timer_list *t)
 55{
 56	struct pwm_fan_ctx *ctx = from_timer(ctx, t, rpm_timer);
 57	int pulses;
 58	u64 tmp;
 59
 60	pulses = atomic_read(&ctx->pulses);
 61	atomic_sub(pulses, &ctx->pulses);
 62	tmp = (u64)pulses * ktime_ms_delta(ktime_get(), ctx->sample_start) * 60;
 63	do_div(tmp, ctx->pulses_per_revolution * 1000);
 64	ctx->rpm = tmp;
 65
 66	ctx->sample_start = ktime_get();
 67	mod_timer(&ctx->rpm_timer, jiffies + HZ);
 68}
 69
 70static int  __set_pwm(struct pwm_fan_ctx *ctx, unsigned long pwm)
 71{
 72	unsigned long period;
 73	int ret = 0;
 74	struct pwm_state state = { };
 75
 76	mutex_lock(&ctx->lock);
 77	if (ctx->pwm_value == pwm)
 78		goto exit_set_pwm_err;
 79
 80	pwm_init_state(ctx->pwm, &state);
 81	period = ctx->pwm->args.period;
 82	state.duty_cycle = DIV_ROUND_UP(pwm * (period - 1), MAX_PWM);
 83	state.enabled = pwm ? true : false;
 84
 85	ret = pwm_apply_state(ctx->pwm, &state);
 86	if (!ret)
 87		ctx->pwm_value = pwm;
 88exit_set_pwm_err:
 89	mutex_unlock(&ctx->lock);
 90	return ret;
 91}
 92
 93static void pwm_fan_update_state(struct pwm_fan_ctx *ctx, unsigned long pwm)
 94{
 95	int i;
 96
 97	for (i = 0; i < ctx->pwm_fan_max_state; ++i)
 98		if (pwm < ctx->pwm_fan_cooling_levels[i + 1])
 99			break;
100
101	ctx->pwm_fan_state = i;
102}
103
104static ssize_t pwm_store(struct device *dev, struct device_attribute *attr,
105			 const char *buf, size_t count)
106{
107	struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
108	unsigned long pwm;
109	int ret;
110
111	if (kstrtoul(buf, 10, &pwm) || pwm > MAX_PWM)
112		return -EINVAL;
113
114	ret = __set_pwm(ctx, pwm);
115	if (ret)
116		return ret;
117
118	pwm_fan_update_state(ctx, pwm);
119	return count;
120}
121
122static ssize_t pwm_show(struct device *dev, struct device_attribute *attr,
123			char *buf)
124{
125	struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
126
127	return sprintf(buf, "%u\n", ctx->pwm_value);
128}
129
130static ssize_t rpm_show(struct device *dev,
131			struct device_attribute *attr, char *buf)
132{
133	struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
134
135	return sprintf(buf, "%u\n", ctx->rpm);
136}
137
138static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);
139static SENSOR_DEVICE_ATTR_RO(fan1_input, rpm, 0);
140
141static struct attribute *pwm_fan_attrs[] = {
142	&sensor_dev_attr_pwm1.dev_attr.attr,
143	&sensor_dev_attr_fan1_input.dev_attr.attr,
144	NULL,
145};
146
147static umode_t pwm_fan_attrs_visible(struct kobject *kobj, struct attribute *a,
148				     int n)
149{
150	struct device *dev = container_of(kobj, struct device, kobj);
151	struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
152
153	/* Hide fan_input in case no interrupt is available  */
154	if (n == 1 && ctx->irq <= 0)
155		return 0;
156
157	return a->mode;
158}
159
160static const struct attribute_group pwm_fan_group = {
161	.attrs = pwm_fan_attrs,
162	.is_visible = pwm_fan_attrs_visible,
163};
164
165static const struct attribute_group *pwm_fan_groups[] = {
166	&pwm_fan_group,
167	NULL,
168};
169
170/* thermal cooling device callbacks */
171static int pwm_fan_get_max_state(struct thermal_cooling_device *cdev,
172				 unsigned long *state)
173{
174	struct pwm_fan_ctx *ctx = cdev->devdata;
175
176	if (!ctx)
177		return -EINVAL;
178
179	*state = ctx->pwm_fan_max_state;
180
181	return 0;
182}
183
184static int pwm_fan_get_cur_state(struct thermal_cooling_device *cdev,
185				 unsigned long *state)
186{
187	struct pwm_fan_ctx *ctx = cdev->devdata;
188
189	if (!ctx)
190		return -EINVAL;
191
192	*state = ctx->pwm_fan_state;
193
194	return 0;
195}
196
197static int
198pwm_fan_set_cur_state(struct thermal_cooling_device *cdev, unsigned long state)
199{
200	struct pwm_fan_ctx *ctx = cdev->devdata;
201	int ret;
202
203	if (!ctx || (state > ctx->pwm_fan_max_state))
204		return -EINVAL;
205
206	if (state == ctx->pwm_fan_state)
207		return 0;
208
209	ret = __set_pwm(ctx, ctx->pwm_fan_cooling_levels[state]);
210	if (ret) {
211		dev_err(&cdev->device, "Cannot set pwm!\n");
212		return ret;
213	}
214
215	ctx->pwm_fan_state = state;
216
217	return ret;
218}
219
220static const struct thermal_cooling_device_ops pwm_fan_cooling_ops = {
221	.get_max_state = pwm_fan_get_max_state,
222	.get_cur_state = pwm_fan_get_cur_state,
223	.set_cur_state = pwm_fan_set_cur_state,
224};
225
226static int pwm_fan_of_get_cooling_data(struct device *dev,
227				       struct pwm_fan_ctx *ctx)
228{
229	struct device_node *np = dev->of_node;
230	int num, i, ret;
231
232	if (!of_find_property(np, "cooling-levels", NULL))
233		return 0;
234
235	ret = of_property_count_u32_elems(np, "cooling-levels");
236	if (ret <= 0) {
237		dev_err(dev, "Wrong data!\n");
238		return ret ? : -EINVAL;
239	}
240
241	num = ret;
242	ctx->pwm_fan_cooling_levels = devm_kcalloc(dev, num, sizeof(u32),
243						   GFP_KERNEL);
244	if (!ctx->pwm_fan_cooling_levels)
245		return -ENOMEM;
246
247	ret = of_property_read_u32_array(np, "cooling-levels",
248					 ctx->pwm_fan_cooling_levels, num);
249	if (ret) {
250		dev_err(dev, "Property 'cooling-levels' cannot be read!\n");
251		return ret;
252	}
253
254	for (i = 0; i < num; i++) {
255		if (ctx->pwm_fan_cooling_levels[i] > MAX_PWM) {
256			dev_err(dev, "PWM fan state[%d]:%d > %d\n", i,
257				ctx->pwm_fan_cooling_levels[i], MAX_PWM);
258			return -EINVAL;
259		}
260	}
261
262	ctx->pwm_fan_max_state = num - 1;
263
264	return 0;
265}
266
267static void pwm_fan_regulator_disable(void *data)
268{
269	regulator_disable(data);
270}
271
272static void pwm_fan_pwm_disable(void *__ctx)
273{
274	struct pwm_fan_ctx *ctx = __ctx;
275	pwm_disable(ctx->pwm);
276	del_timer_sync(&ctx->rpm_timer);
277}
278
279static int pwm_fan_probe(struct platform_device *pdev)
280{
281	struct thermal_cooling_device *cdev;
282	struct device *dev = &pdev->dev;
283	struct pwm_fan_ctx *ctx;
284	struct device *hwmon;
285	int ret;
286	struct pwm_state state = { };
287	u32 ppr = 2;
288
289	ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
290	if (!ctx)
291		return -ENOMEM;
292
293	mutex_init(&ctx->lock);
294
295	ctx->pwm = devm_of_pwm_get(dev, dev->of_node, NULL);
296	if (IS_ERR(ctx->pwm)) {
297		ret = PTR_ERR(ctx->pwm);
298
299		if (ret != -EPROBE_DEFER)
300			dev_err(dev, "Could not get PWM: %d\n", ret);
301
302		return ret;
303	}
304
305	platform_set_drvdata(pdev, ctx);
306
307	ctx->irq = platform_get_irq_optional(pdev, 0);
308	if (ctx->irq == -EPROBE_DEFER)
309		return ctx->irq;
310
311	ctx->reg_en = devm_regulator_get_optional(dev, "fan");
312	if (IS_ERR(ctx->reg_en)) {
313		if (PTR_ERR(ctx->reg_en) != -ENODEV)
314			return PTR_ERR(ctx->reg_en);
315
316		ctx->reg_en = NULL;
317	} else {
318		ret = regulator_enable(ctx->reg_en);
319		if (ret) {
320			dev_err(dev, "Failed to enable fan supply: %d\n", ret);
321			return ret;
322		}
323		ret = devm_add_action_or_reset(dev, pwm_fan_regulator_disable,
324					       ctx->reg_en);
325		if (ret)
326			return ret;
327	}
328
329	ctx->pwm_value = MAX_PWM;
330
331	/* Set duty cycle to maximum allowed and enable PWM output */
332	pwm_init_state(ctx->pwm, &state);
333	state.duty_cycle = ctx->pwm->args.period - 1;
334	state.enabled = true;
335
336	ret = pwm_apply_state(ctx->pwm, &state);
337	if (ret) {
338		dev_err(dev, "Failed to configure PWM: %d\n", ret);
339		return ret;
340	}
341	timer_setup(&ctx->rpm_timer, sample_timer, 0);
342	ret = devm_add_action_or_reset(dev, pwm_fan_pwm_disable, ctx);
343	if (ret)
344		return ret;
345
346	of_property_read_u32(dev->of_node, "pulses-per-revolution", &ppr);
347	ctx->pulses_per_revolution = ppr;
348	if (!ctx->pulses_per_revolution) {
349		dev_err(dev, "pulses-per-revolution can't be zero.\n");
350		return -EINVAL;
351	}
352
353	if (ctx->irq > 0) {
354		ret = devm_request_irq(dev, ctx->irq, pulse_handler, 0,
355				       pdev->name, ctx);
356		if (ret) {
357			dev_err(dev, "Failed to request interrupt: %d\n", ret);
358			return ret;
359		}
360		ctx->sample_start = ktime_get();
361		mod_timer(&ctx->rpm_timer, jiffies + HZ);
362	}
363
364	hwmon = devm_hwmon_device_register_with_groups(dev, "pwmfan",
365						       ctx, pwm_fan_groups);
366	if (IS_ERR(hwmon)) {
367		dev_err(dev, "Failed to register hwmon device\n");
368		return PTR_ERR(hwmon);
369	}
370
371	ret = pwm_fan_of_get_cooling_data(dev, ctx);
372	if (ret)
373		return ret;
374
375	ctx->pwm_fan_state = ctx->pwm_fan_max_state;
376	if (IS_ENABLED(CONFIG_THERMAL)) {
377		cdev = devm_thermal_of_cooling_device_register(dev,
378			dev->of_node, "pwm-fan", ctx, &pwm_fan_cooling_ops);
379		if (IS_ERR(cdev)) {
380			ret = PTR_ERR(cdev);
381			dev_err(dev,
382				"Failed to register pwm-fan as cooling device: %d\n",
383				ret);
384			return ret;
385		}
386		ctx->cdev = cdev;
387		thermal_cdev_update(cdev);
388	}
389
390	return 0;
391}
392
393static int pwm_fan_disable(struct device *dev)
394{
395	struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
396	struct pwm_args args;
397	int ret;
398
399	pwm_get_args(ctx->pwm, &args);
400
401	if (ctx->pwm_value) {
402		ret = pwm_config(ctx->pwm, 0, args.period);
403		if (ret < 0)
404			return ret;
405
406		pwm_disable(ctx->pwm);
407	}
408
409	if (ctx->reg_en) {
410		ret = regulator_disable(ctx->reg_en);
411		if (ret) {
412			dev_err(dev, "Failed to disable fan supply: %d\n", ret);
413			return ret;
414		}
415	}
416
417	return 0;
418}
419
420static void pwm_fan_shutdown(struct platform_device *pdev)
421{
422	pwm_fan_disable(&pdev->dev);
423}
424
425#ifdef CONFIG_PM_SLEEP
426static int pwm_fan_suspend(struct device *dev)
427{
428	return pwm_fan_disable(dev);
429}
430
431static int pwm_fan_resume(struct device *dev)
432{
433	struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
434	struct pwm_args pargs;
435	unsigned long duty;
436	int ret;
437
438	if (ctx->reg_en) {
439		ret = regulator_enable(ctx->reg_en);
440		if (ret) {
441			dev_err(dev, "Failed to enable fan supply: %d\n", ret);
442			return ret;
443		}
444	}
445
446	if (ctx->pwm_value == 0)
447		return 0;
448
449	pwm_get_args(ctx->pwm, &pargs);
450	duty = DIV_ROUND_UP_ULL(ctx->pwm_value * (pargs.period - 1), MAX_PWM);
451	ret = pwm_config(ctx->pwm, duty, pargs.period);
452	if (ret)
453		return ret;
454	return pwm_enable(ctx->pwm);
455}
456#endif
457
458static SIMPLE_DEV_PM_OPS(pwm_fan_pm, pwm_fan_suspend, pwm_fan_resume);
459
460static const struct of_device_id of_pwm_fan_match[] = {
461	{ .compatible = "pwm-fan", },
462	{},
463};
464MODULE_DEVICE_TABLE(of, of_pwm_fan_match);
465
466static struct platform_driver pwm_fan_driver = {
467	.probe		= pwm_fan_probe,
468	.shutdown	= pwm_fan_shutdown,
469	.driver	= {
470		.name		= "pwm-fan",
471		.pm		= &pwm_fan_pm,
472		.of_match_table	= of_pwm_fan_match,
473	},
474};
475
476module_platform_driver(pwm_fan_driver);
477
478MODULE_AUTHOR("Kamil Debski <k.debski@samsung.com>");
479MODULE_ALIAS("platform:pwm-fan");
480MODULE_DESCRIPTION("PWM FAN driver");
481MODULE_LICENSE("GPL");