]>
Commit | Line | Data |
---|---|---|
c942fddf | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
d82d5776 KD |
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> | |
d82d5776 KD |
8 | */ |
9 | ||
10 | #include <linux/hwmon.h> | |
6b1ec478 | 11 | #include <linux/interrupt.h> |
d82d5776 KD |
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> | |
b57e1d42 | 17 | #include <linux/regulator/consumer.h> |
d82d5776 | 18 | #include <linux/sysfs.h> |
b6bddec0 | 19 | #include <linux/thermal.h> |
6b1ec478 | 20 | #include <linux/timer.h> |
d82d5776 KD |
21 | |
22 | #define MAX_PWM 255 | |
23 | ||
01695410 PB |
24 | struct pwm_fan_tach { |
25 | int irq; | |
26 | atomic_t pulses; | |
27 | unsigned int rpm; | |
28 | u8 pulses_per_revolution; | |
29 | }; | |
30 | ||
b99152d4 AS |
31 | enum 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 | ||
d82d5776 | 38 | struct pwm_fan_ctx { |
b77f0c76 AS |
39 | struct device *dev; |
40 | ||
d82d5776 KD |
41 | struct mutex lock; |
42 | struct pwm_device *pwm; | |
86585c61 | 43 | struct pwm_state pwm_state; |
b57e1d42 | 44 | struct regulator *reg_en; |
b99152d4 | 45 | enum pwm_fan_enable_mode enable_mode; |
9bf3aa60 | 46 | bool regulator_enabled; |
b77f0c76 | 47 | bool enabled; |
6b1ec478 | 48 | |
f0dc7cb6 PB |
49 | int tach_count; |
50 | struct pwm_fan_tach *tachs; | |
6b1ec478 SW |
51 | ktime_t sample_start; |
52 | struct timer_list rpm_timer; | |
53 | ||
2e5219c7 LM |
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; | |
b6bddec0 | 58 | struct thermal_cooling_device *cdev; |
1aa03655 PB |
59 | |
60 | struct hwmon_chip_info info; | |
f0dc7cb6 | 61 | struct hwmon_channel_info fan_channel; |
1aa03655 PB |
62 | }; |
63 | ||
6b1ec478 SW |
64 | /* This handler assumes self resetting edge triggered interrupt. */ |
65 | static irqreturn_t pulse_handler(int irq, void *dev_id) | |
66 | { | |
01695410 | 67 | struct pwm_fan_tach *tach = dev_id; |
6b1ec478 | 68 | |
01695410 | 69 | atomic_inc(&tach->pulses); |
6b1ec478 SW |
70 | |
71 | return IRQ_HANDLED; | |
72 | } | |
73 | ||
74 | static void sample_timer(struct timer_list *t) | |
75 | { | |
76 | struct pwm_fan_ctx *ctx = from_timer(ctx, t, rpm_timer); | |
fd8feec6 | 77 | unsigned int delta = ktime_ms_delta(ktime_get(), ctx->sample_start); |
f0dc7cb6 | 78 | int i; |
6b1ec478 | 79 | |
fd8feec6 | 80 | if (delta) { |
f0dc7cb6 PB |
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 | } | |
fd8feec6 PB |
90 | |
91 | ctx->sample_start = ktime_get(); | |
92 | } | |
6b1ec478 | 93 | |
6b1ec478 SW |
94 | mod_timer(&ctx->rpm_timer, jiffies + HZ); |
95 | } | |
96 | ||
b99152d4 AS |
97 | static 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 | ||
9bf3aa60 AS |
120 | static 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 | ||
bf10ccad | 139 | static int pwm_fan_power_on(struct pwm_fan_ctx *ctx) |
d82d5776 | 140 | { |
bf10ccad | 141 | struct pwm_state *state = &ctx->pwm_state; |
bf10ccad AS |
142 | int ret; |
143 | ||
b77f0c76 AS |
144 | if (ctx->enabled) |
145 | return 0; | |
146 | ||
b99152d4 AS |
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 | ||
bf10ccad AS |
153 | state->enabled = true; |
154 | ret = pwm_apply_state(ctx->pwm, state); | |
b77f0c76 AS |
155 | if (ret) { |
156 | dev_err(ctx->dev, "failed to enable PWM\n"); | |
b99152d4 | 157 | goto disable_regulator; |
b77f0c76 AS |
158 | } |
159 | ||
160 | ctx->enabled = true; | |
bf10ccad | 161 | |
b99152d4 AS |
162 | return 0; |
163 | ||
164 | disable_regulator: | |
165 | pwm_fan_switch_power(ctx, false); | |
bf10ccad AS |
166 | return ret; |
167 | } | |
168 | ||
169 | static int pwm_fan_power_off(struct pwm_fan_ctx *ctx) | |
170 | { | |
86585c61 | 171 | struct pwm_state *state = &ctx->pwm_state; |
b99152d4 | 172 | bool enable_regulator = false; |
b77f0c76 AS |
173 | int ret; |
174 | ||
175 | if (!ctx->enabled) | |
176 | return 0; | |
2289711c | 177 | |
b99152d4 AS |
178 | pwm_fan_enable_mode_2_state(ctx->enable_mode, |
179 | state, | |
180 | &enable_regulator); | |
181 | ||
bf10ccad AS |
182 | state->enabled = false; |
183 | state->duty_cycle = 0; | |
b77f0c76 AS |
184 | ret = pwm_apply_state(ctx->pwm, state); |
185 | if (ret) { | |
186 | dev_err(ctx->dev, "failed to disable PWM\n"); | |
187 | return ret; | |
188 | } | |
189 | ||
b99152d4 AS |
190 | pwm_fan_switch_power(ctx, enable_regulator); |
191 | ||
b77f0c76 | 192 | ctx->enabled = false; |
bf10ccad AS |
193 | |
194 | return 0; | |
195 | } | |
196 | ||
197 | static int __set_pwm(struct pwm_fan_ctx *ctx, unsigned long pwm) | |
198 | { | |
b77f0c76 AS |
199 | struct pwm_state *state = &ctx->pwm_state; |
200 | unsigned long period; | |
bf10ccad AS |
201 | int ret = 0; |
202 | ||
b77f0c76 | 203 | if (pwm > 0) { |
b99152d4 AS |
204 | if (ctx->enable_mode == pwm_off_reg_off) |
205 | /* pwm-fan hard disabled */ | |
206 | return 0; | |
207 | ||
b77f0c76 AS |
208 | period = state->period; |
209 | state->duty_cycle = DIV_ROUND_UP(pwm * (period - 1), MAX_PWM); | |
210 | ret = pwm_apply_state(ctx->pwm, state); | |
211 | if (ret) | |
9db6e7f5 | 212 | return ret; |
bf10ccad | 213 | ret = pwm_fan_power_on(ctx); |
b77f0c76 | 214 | } else { |
bf10ccad | 215 | ret = pwm_fan_power_off(ctx); |
b77f0c76 | 216 | } |
677252a1 BZ |
217 | if (!ret) |
218 | ctx->pwm_value = pwm; | |
bf10ccad | 219 | |
9db6e7f5 AS |
220 | return ret; |
221 | } | |
222 | ||
223 | static 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); | |
d82d5776 | 229 | mutex_unlock(&ctx->lock); |
9db6e7f5 | 230 | |
d82d5776 KD |
231 | return ret; |
232 | } | |
233 | ||
b6bddec0 LM |
234 | static 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 | ||
b99152d4 AS |
245 | static 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 */ | |
3008d20f MS |
260 | if (ctx->enabled) |
261 | ret = __set_pwm(ctx, 0); | |
262 | else | |
263 | ret = pwm_fan_switch_power(ctx, false); | |
b99152d4 AS |
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_state(ctx->pwm, state); | |
282 | pwm_fan_switch_power(ctx, enable_regulator); | |
283 | pwm_fan_update_state(ctx, 0); | |
284 | } | |
285 | } | |
286 | out: | |
287 | mutex_unlock(&ctx->lock); | |
288 | ||
289 | return ret; | |
290 | } | |
291 | ||
1aa03655 PB |
292 | static int pwm_fan_write(struct device *dev, enum hwmon_sensor_types type, |
293 | u32 attr, int channel, long val) | |
cb85ca33 LM |
294 | { |
295 | struct pwm_fan_ctx *ctx = dev_get_drvdata(dev); | |
cb85ca33 LM |
296 | int ret; |
297 | ||
b99152d4 AS |
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); | |
cb85ca33 | 312 | |
cb85ca33 | 313 | return ret; |
b99152d4 AS |
314 | default: |
315 | return -EOPNOTSUPP; | |
316 | } | |
cb85ca33 | 317 | |
1aa03655 | 318 | return 0; |
cb85ca33 LM |
319 | } |
320 | ||
1aa03655 PB |
321 | static int pwm_fan_read(struct device *dev, enum hwmon_sensor_types type, |
322 | u32 attr, int channel, long *val) | |
d82d5776 KD |
323 | { |
324 | struct pwm_fan_ctx *ctx = dev_get_drvdata(dev); | |
325 | ||
1aa03655 PB |
326 | switch (type) { |
327 | case hwmon_pwm: | |
b99152d4 AS |
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; | |
1aa03655 | 337 | case hwmon_fan: |
f0dc7cb6 | 338 | *val = ctx->tachs[channel].rpm; |
1aa03655 | 339 | return 0; |
6b1ec478 | 340 | |
1aa03655 PB |
341 | default: |
342 | return -ENOTSUPP; | |
343 | } | |
6b1ec478 | 344 | } |
d82d5776 | 345 | |
1aa03655 PB |
346 | static umode_t pwm_fan_is_visible(const void *data, |
347 | enum hwmon_sensor_types type, | |
348 | u32 attr, int channel) | |
6b1ec478 | 349 | { |
1aa03655 PB |
350 | switch (type) { |
351 | case hwmon_pwm: | |
352 | return 0644; | |
6b1ec478 | 353 | |
1aa03655 PB |
354 | case hwmon_fan: |
355 | return 0444; | |
6b1ec478 | 356 | |
1aa03655 PB |
357 | default: |
358 | return 0; | |
359 | } | |
6b1ec478 SW |
360 | } |
361 | ||
1aa03655 PB |
362 | static 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, | |
6b1ec478 | 366 | }; |
d82d5776 | 367 | |
b6bddec0 LM |
368 | /* thermal cooling device callbacks */ |
369 | static 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 | ||
382 | static 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 | ||
395 | static int | |
396 | pwm_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 | ||
9db6e7f5 | 407 | ret = set_pwm(ctx, ctx->pwm_fan_cooling_levels[state]); |
b6bddec0 LM |
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 | ||
418 | static 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 | ||
de52b049 GR |
424 | static int pwm_fan_of_get_cooling_data(struct device *dev, |
425 | struct pwm_fan_ctx *ctx) | |
2e5219c7 LM |
426 | { |
427 | struct device_node *np = dev->of_node; | |
428 | int num, i, ret; | |
429 | ||
914b2fd2 | 430 | if (!of_property_present(np, "cooling-levels")) |
2e5219c7 LM |
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; | |
a86854d0 | 440 | ctx->pwm_fan_cooling_levels = devm_kcalloc(dev, num, sizeof(u32), |
2e5219c7 LM |
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 | ||
b99152d4 | 465 | static void pwm_fan_cleanup(void *__ctx) |
37bcec5d | 466 | { |
a455eda3 | 467 | struct pwm_fan_ctx *ctx = __ctx; |
86585c61 | 468 | |
a455eda3 | 469 | del_timer_sync(&ctx->rpm_timer); |
b99152d4 AS |
470 | /* Switch off everything */ |
471 | ctx->enable_mode = pwm_disable_reg_disable; | |
472 | pwm_fan_power_off(ctx); | |
37bcec5d GR |
473 | } |
474 | ||
d82d5776 KD |
475 | static int pwm_fan_probe(struct platform_device *pdev) |
476 | { | |
b6bddec0 | 477 | struct thermal_cooling_device *cdev; |
37bcec5d | 478 | struct device *dev = &pdev->dev; |
d82d5776 | 479 | struct pwm_fan_ctx *ctx; |
b6bddec0 | 480 | struct device *hwmon; |
d82d5776 | 481 | int ret; |
1aa03655 | 482 | const struct hwmon_channel_info **channels; |
f0dc7cb6 PB |
483 | u32 *fan_channel_config; |
484 | int channel_count = 1; /* We always have a PWM channel. */ | |
485 | int i; | |
d82d5776 | 486 | |
37bcec5d | 487 | ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL); |
d82d5776 KD |
488 | if (!ctx) |
489 | return -ENOMEM; | |
490 | ||
491 | mutex_init(&ctx->lock); | |
492 | ||
b77f0c76 | 493 | ctx->dev = &pdev->dev; |
2e2aa25c | 494 | ctx->pwm = devm_pwm_get(dev, NULL); |
65b2aad0 AH |
495 | if (IS_ERR(ctx->pwm)) |
496 | return dev_err_probe(dev, PTR_ERR(ctx->pwm), "Could not get PWM\n"); | |
d82d5776 | 497 | |
d82d5776 KD |
498 | platform_set_drvdata(pdev, ctx); |
499 | ||
37bcec5d | 500 | ctx->reg_en = devm_regulator_get_optional(dev, "fan"); |
b57e1d42 SW |
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; | |
b57e1d42 SW |
506 | } |
507 | ||
86585c61 UKK |
508 | pwm_init_state(ctx->pwm, &ctx->pwm_state); |
509 | ||
a7da8a8b LB |
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 | ||
1eda5233 | 518 | /* |
9db6e7f5 | 519 | * set_pwm assumes that MAX_PWM * (period - 1) fits into an unsigned |
1eda5233 UKK |
520 | * long. Check this here to prevent the fan running at a too low |
521 | * frequency. | |
522 | */ | |
86585c61 | 523 | if (ctx->pwm_state.period > ULONG_MAX / MAX_PWM + 1) { |
1eda5233 UKK |
524 | dev_err(dev, "Configured period too big\n"); |
525 | return -EINVAL; | |
526 | } | |
527 | ||
b99152d4 AS |
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 | */ | |
9db6e7f5 | 534 | ret = set_pwm(ctx, MAX_PWM); |
d82d5776 | 535 | if (ret) { |
a455eda3 | 536 | dev_err(dev, "Failed to configure PWM: %d\n", ret); |
37bcec5d | 537 | return ret; |
d82d5776 | 538 | } |
6b1ec478 | 539 | timer_setup(&ctx->rpm_timer, sample_timer, 0); |
b99152d4 | 540 | ret = devm_add_action_or_reset(dev, pwm_fan_cleanup, ctx); |
5696e4aa GR |
541 | if (ret) |
542 | return ret; | |
6b1ec478 | 543 | |
f0dc7cb6 PB |
544 | ctx->tach_count = platform_irq_count(pdev); |
545 | if (ctx->tach_count < 0) | |
546 | return dev_err_probe(dev, ctx->tach_count, | |
b5fcb8a4 | 547 | "Could not get number of fan tachometer inputs\n"); |
f0dc7cb6 | 548 | dev_dbg(dev, "%d fan tachometer inputs\n", ctx->tach_count); |
b5fcb8a4 | 549 | |
f0dc7cb6 PB |
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, | |
1aa03655 PB |
568 | sizeof(struct hwmon_channel_info *), GFP_KERNEL); |
569 | if (!channels) | |
570 | return -ENOMEM; | |
571 | ||
b99152d4 | 572 | channels[0] = HWMON_CHANNEL_INFO(pwm, HWMON_PWM_INPUT | HWMON_PWM_ENABLE); |
1aa03655 | 573 | |
f0dc7cb6 PB |
574 | for (i = 0; i < ctx->tach_count; i++) { |
575 | struct pwm_fan_tach *tach = &ctx->tachs[i]; | |
b5fcb8a4 PB |
576 | u32 ppr = 2; |
577 | ||
f0dc7cb6 | 578 | tach->irq = platform_get_irq(pdev, i); |
01695410 PB |
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); | |
b5fcb8a4 PB |
584 | if (ret) { |
585 | dev_err(dev, | |
586 | "Failed to request interrupt: %d\n", | |
587 | ret); | |
588 | return ret; | |
589 | } | |
590 | } | |
6b1ec478 | 591 | |
f0dc7cb6 PB |
592 | of_property_read_u32_index(dev->of_node, |
593 | "pulses-per-revolution", | |
594 | i, | |
595 | &ppr); | |
01695410 PB |
596 | tach->pulses_per_revolution = ppr; |
597 | if (!tach->pulses_per_revolution) { | |
b5fcb8a4 PB |
598 | dev_err(dev, "pulses-per-revolution can't be zero.\n"); |
599 | return -EINVAL; | |
6b1ec478 | 600 | } |
b5fcb8a4 | 601 | |
f0dc7cb6 PB |
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 | } | |
b5fcb8a4 | 607 | |
f0dc7cb6 | 608 | if (ctx->tach_count > 0) { |
6b1ec478 SW |
609 | ctx->sample_start = ktime_get(); |
610 | mod_timer(&ctx->rpm_timer, jiffies + HZ); | |
1aa03655 | 611 | |
f0dc7cb6 | 612 | channels[1] = &ctx->fan_channel; |
6b1ec478 SW |
613 | } |
614 | ||
1aa03655 PB |
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); | |
d82d5776 | 620 | if (IS_ERR(hwmon)) { |
37bcec5d GR |
621 | dev_err(dev, "Failed to register hwmon device\n"); |
622 | return PTR_ERR(hwmon); | |
d82d5776 | 623 | } |
2e5219c7 | 624 | |
37bcec5d | 625 | ret = pwm_fan_of_get_cooling_data(dev, ctx); |
2e5219c7 LM |
626 | if (ret) |
627 | return ret; | |
628 | ||
b6bddec0 LM |
629 | ctx->pwm_fan_state = ctx->pwm_fan_max_state; |
630 | if (IS_ENABLED(CONFIG_THERMAL)) { | |
37bcec5d GR |
631 | cdev = devm_thermal_of_cooling_device_register(dev, |
632 | dev->of_node, "pwm-fan", ctx, &pwm_fan_cooling_ops); | |
b6bddec0 | 633 | if (IS_ERR(cdev)) { |
677252a1 | 634 | ret = PTR_ERR(cdev); |
37bcec5d | 635 | dev_err(dev, |
841cf676 RM |
636 | "Failed to register pwm-fan as cooling device: %d\n", |
637 | ret); | |
a455eda3 | 638 | return ret; |
b6bddec0 LM |
639 | } |
640 | ctx->cdev = cdev; | |
b6bddec0 LM |
641 | } |
642 | ||
d82d5776 | 643 | return 0; |
d82d5776 KD |
644 | } |
645 | ||
7992db7c AM |
646 | static void pwm_fan_shutdown(struct platform_device *pdev) |
647 | { | |
b99152d4 AS |
648 | struct pwm_fan_ctx *ctx = platform_get_drvdata(pdev); |
649 | ||
650 | pwm_fan_cleanup(ctx); | |
7992db7c AM |
651 | } |
652 | ||
7992db7c AM |
653 | static int pwm_fan_suspend(struct device *dev) |
654 | { | |
b99152d4 AS |
655 | struct pwm_fan_ctx *ctx = dev_get_drvdata(dev); |
656 | ||
657 | return pwm_fan_power_off(ctx); | |
7992db7c AM |
658 | } |
659 | ||
d82d5776 KD |
660 | static int pwm_fan_resume(struct device *dev) |
661 | { | |
662 | struct pwm_fan_ctx *ctx = dev_get_drvdata(dev); | |
48b9d5b4 | 663 | |
b99152d4 | 664 | return set_pwm(ctx, ctx->pwm_value); |
d82d5776 | 665 | } |
d82d5776 | 666 | |
1839391b | 667 | static DEFINE_SIMPLE_DEV_PM_OPS(pwm_fan_pm, pwm_fan_suspend, pwm_fan_resume); |
d82d5776 | 668 | |
d720acac | 669 | static const struct of_device_id of_pwm_fan_match[] = { |
d82d5776 KD |
670 | { .compatible = "pwm-fan", }, |
671 | {}, | |
672 | }; | |
f491e70c | 673 | MODULE_DEVICE_TABLE(of, of_pwm_fan_match); |
d82d5776 KD |
674 | |
675 | static struct platform_driver pwm_fan_driver = { | |
676 | .probe = pwm_fan_probe, | |
7992db7c | 677 | .shutdown = pwm_fan_shutdown, |
d82d5776 KD |
678 | .driver = { |
679 | .name = "pwm-fan", | |
1839391b | 680 | .pm = pm_sleep_ptr(&pwm_fan_pm), |
d82d5776 KD |
681 | .of_match_table = of_pwm_fan_match, |
682 | }, | |
683 | }; | |
684 | ||
685 | module_platform_driver(pwm_fan_driver); | |
686 | ||
687 | MODULE_AUTHOR("Kamil Debski <k.debski@samsung.com>"); | |
688 | MODULE_ALIAS("platform:pwm-fan"); | |
689 | MODULE_DESCRIPTION("PWM FAN driver"); | |
690 | MODULE_LICENSE("GPL"); |