1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * pwm-fan.c - Hwmon driver for fans connected to PWM lines.
5 * Copyright (c) 2014 Samsung Electronics Co., Ltd.
7 * Author: Kamil Debski <k.debski@samsung.com>
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>
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>
27 struct pwm_device
*pwm
;
28 struct regulator
*reg_en
;
33 u8 pulses_per_revolution
;
35 struct timer_list rpm_timer
;
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
;
44 /* This handler assumes self resetting edge triggered interrupt. */
45 static irqreturn_t
pulse_handler(int irq
, void *dev_id
)
47 struct pwm_fan_ctx
*ctx
= dev_id
;
49 atomic_inc(&ctx
->pulses
);
54 static void sample_timer(struct timer_list
*t
)
56 struct pwm_fan_ctx
*ctx
= from_timer(ctx
, t
, rpm_timer
);
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);
66 ctx
->sample_start
= ktime_get();
67 mod_timer(&ctx
->rpm_timer
, jiffies
+ HZ
);
70 static int __set_pwm(struct pwm_fan_ctx
*ctx
, unsigned long pwm
)
74 struct pwm_state state
= { };
76 mutex_lock(&ctx
->lock
);
77 if (ctx
->pwm_value
== pwm
)
78 goto exit_set_pwm_err
;
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;
85 ret
= pwm_apply_state(ctx
->pwm
, &state
);
89 mutex_unlock(&ctx
->lock
);
93 static void pwm_fan_update_state(struct pwm_fan_ctx
*ctx
, unsigned long pwm
)
97 for (i
= 0; i
< ctx
->pwm_fan_max_state
; ++i
)
98 if (pwm
< ctx
->pwm_fan_cooling_levels
[i
+ 1])
101 ctx
->pwm_fan_state
= i
;
104 static ssize_t
pwm_store(struct device
*dev
, struct device_attribute
*attr
,
105 const char *buf
, size_t count
)
107 struct pwm_fan_ctx
*ctx
= dev_get_drvdata(dev
);
111 if (kstrtoul(buf
, 10, &pwm
) || pwm
> MAX_PWM
)
114 ret
= __set_pwm(ctx
, pwm
);
118 pwm_fan_update_state(ctx
, pwm
);
122 static ssize_t
pwm_show(struct device
*dev
, struct device_attribute
*attr
,
125 struct pwm_fan_ctx
*ctx
= dev_get_drvdata(dev
);
127 return sprintf(buf
, "%u\n", ctx
->pwm_value
);
130 static ssize_t
rpm_show(struct device
*dev
,
131 struct device_attribute
*attr
, char *buf
)
133 struct pwm_fan_ctx
*ctx
= dev_get_drvdata(dev
);
135 return sprintf(buf
, "%u\n", ctx
->rpm
);
138 static SENSOR_DEVICE_ATTR_RW(pwm1
, pwm
, 0);
139 static SENSOR_DEVICE_ATTR_RO(fan1_input
, rpm
, 0);
141 static struct attribute
*pwm_fan_attrs
[] = {
142 &sensor_dev_attr_pwm1
.dev_attr
.attr
,
143 &sensor_dev_attr_fan1_input
.dev_attr
.attr
,
147 static umode_t
pwm_fan_attrs_visible(struct kobject
*kobj
, struct attribute
*a
,
150 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
151 struct pwm_fan_ctx
*ctx
= dev_get_drvdata(dev
);
153 /* Hide fan_input in case no interrupt is available */
154 if (n
== 1 && ctx
->irq
<= 0)
160 static const struct attribute_group pwm_fan_group
= {
161 .attrs
= pwm_fan_attrs
,
162 .is_visible
= pwm_fan_attrs_visible
,
165 static const struct attribute_group
*pwm_fan_groups
[] = {
170 /* thermal cooling device callbacks */
171 static int pwm_fan_get_max_state(struct thermal_cooling_device
*cdev
,
172 unsigned long *state
)
174 struct pwm_fan_ctx
*ctx
= cdev
->devdata
;
179 *state
= ctx
->pwm_fan_max_state
;
184 static int pwm_fan_get_cur_state(struct thermal_cooling_device
*cdev
,
185 unsigned long *state
)
187 struct pwm_fan_ctx
*ctx
= cdev
->devdata
;
192 *state
= ctx
->pwm_fan_state
;
198 pwm_fan_set_cur_state(struct thermal_cooling_device
*cdev
, unsigned long state
)
200 struct pwm_fan_ctx
*ctx
= cdev
->devdata
;
203 if (!ctx
|| (state
> ctx
->pwm_fan_max_state
))
206 if (state
== ctx
->pwm_fan_state
)
209 ret
= __set_pwm(ctx
, ctx
->pwm_fan_cooling_levels
[state
]);
211 dev_err(&cdev
->device
, "Cannot set pwm!\n");
215 ctx
->pwm_fan_state
= state
;
220 static 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
,
226 static int pwm_fan_of_get_cooling_data(struct device
*dev
,
227 struct pwm_fan_ctx
*ctx
)
229 struct device_node
*np
= dev
->of_node
;
232 if (!of_find_property(np
, "cooling-levels", NULL
))
235 ret
= of_property_count_u32_elems(np
, "cooling-levels");
237 dev_err(dev
, "Wrong data!\n");
238 return ret
? : -EINVAL
;
242 ctx
->pwm_fan_cooling_levels
= devm_kcalloc(dev
, num
, sizeof(u32
),
244 if (!ctx
->pwm_fan_cooling_levels
)
247 ret
= of_property_read_u32_array(np
, "cooling-levels",
248 ctx
->pwm_fan_cooling_levels
, num
);
250 dev_err(dev
, "Property 'cooling-levels' cannot be read!\n");
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
);
262 ctx
->pwm_fan_max_state
= num
- 1;
267 static void pwm_fan_regulator_disable(void *data
)
269 regulator_disable(data
);
272 static void pwm_fan_pwm_disable(void *__ctx
)
274 struct pwm_fan_ctx
*ctx
= __ctx
;
275 pwm_disable(ctx
->pwm
);
276 del_timer_sync(&ctx
->rpm_timer
);
279 static int pwm_fan_probe(struct platform_device
*pdev
)
281 struct thermal_cooling_device
*cdev
;
282 struct device
*dev
= &pdev
->dev
;
283 struct pwm_fan_ctx
*ctx
;
284 struct device
*hwmon
;
286 struct pwm_state state
= { };
289 ctx
= devm_kzalloc(dev
, sizeof(*ctx
), GFP_KERNEL
);
293 mutex_init(&ctx
->lock
);
295 ctx
->pwm
= devm_of_pwm_get(dev
, dev
->of_node
, NULL
);
296 if (IS_ERR(ctx
->pwm
)) {
297 ret
= PTR_ERR(ctx
->pwm
);
299 if (ret
!= -EPROBE_DEFER
)
300 dev_err(dev
, "Could not get PWM: %d\n", ret
);
305 platform_set_drvdata(pdev
, ctx
);
307 ctx
->irq
= platform_get_irq_optional(pdev
, 0);
308 if (ctx
->irq
== -EPROBE_DEFER
)
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
);
318 ret
= regulator_enable(ctx
->reg_en
);
320 dev_err(dev
, "Failed to enable fan supply: %d\n", ret
);
323 ret
= devm_add_action_or_reset(dev
, pwm_fan_regulator_disable
,
329 ctx
->pwm_value
= MAX_PWM
;
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;
336 ret
= pwm_apply_state(ctx
->pwm
, &state
);
338 dev_err(dev
, "Failed to configure PWM: %d\n", ret
);
341 timer_setup(&ctx
->rpm_timer
, sample_timer
, 0);
342 ret
= devm_add_action_or_reset(dev
, pwm_fan_pwm_disable
, ctx
);
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");
354 ret
= devm_request_irq(dev
, ctx
->irq
, pulse_handler
, 0,
357 dev_err(dev
, "Failed to request interrupt: %d\n", ret
);
360 ctx
->sample_start
= ktime_get();
361 mod_timer(&ctx
->rpm_timer
, jiffies
+ HZ
);
364 hwmon
= devm_hwmon_device_register_with_groups(dev
, "pwmfan",
365 ctx
, pwm_fan_groups
);
367 dev_err(dev
, "Failed to register hwmon device\n");
368 return PTR_ERR(hwmon
);
371 ret
= pwm_fan_of_get_cooling_data(dev
, ctx
);
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
);
382 "Failed to register pwm-fan as cooling device: %d\n",
387 thermal_cdev_update(cdev
);
393 static int pwm_fan_disable(struct device
*dev
)
395 struct pwm_fan_ctx
*ctx
= dev_get_drvdata(dev
);
396 struct pwm_args args
;
399 pwm_get_args(ctx
->pwm
, &args
);
401 if (ctx
->pwm_value
) {
402 ret
= pwm_config(ctx
->pwm
, 0, args
.period
);
406 pwm_disable(ctx
->pwm
);
410 ret
= regulator_disable(ctx
->reg_en
);
412 dev_err(dev
, "Failed to disable fan supply: %d\n", ret
);
420 static void pwm_fan_shutdown(struct platform_device
*pdev
)
422 pwm_fan_disable(&pdev
->dev
);
425 #ifdef CONFIG_PM_SLEEP
426 static int pwm_fan_suspend(struct device
*dev
)
428 return pwm_fan_disable(dev
);
431 static int pwm_fan_resume(struct device
*dev
)
433 struct pwm_fan_ctx
*ctx
= dev_get_drvdata(dev
);
434 struct pwm_args pargs
;
439 ret
= regulator_enable(ctx
->reg_en
);
441 dev_err(dev
, "Failed to enable fan supply: %d\n", ret
);
446 if (ctx
->pwm_value
== 0)
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
);
454 return pwm_enable(ctx
->pwm
);
458 static SIMPLE_DEV_PM_OPS(pwm_fan_pm
, pwm_fan_suspend
, pwm_fan_resume
);
460 static const struct of_device_id of_pwm_fan_match
[] = {
461 { .compatible
= "pwm-fan", },
464 MODULE_DEVICE_TABLE(of
, of_pwm_fan_match
);
466 static struct platform_driver pwm_fan_driver
= {
467 .probe
= pwm_fan_probe
,
468 .shutdown
= pwm_fan_shutdown
,
472 .of_match_table
= of_pwm_fan_match
,
476 module_platform_driver(pwm_fan_driver
);
478 MODULE_AUTHOR("Kamil Debski <k.debski@samsung.com>");
479 MODULE_ALIAS("platform:pwm-fan");
480 MODULE_DESCRIPTION("PWM FAN driver");
481 MODULE_LICENSE("GPL");