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 | ||
d82d5776 KD |
31 | struct pwm_fan_ctx { |
32 | struct mutex lock; | |
33 | struct pwm_device *pwm; | |
86585c61 | 34 | struct pwm_state pwm_state; |
b57e1d42 | 35 | struct regulator *reg_en; |
6b1ec478 | 36 | |
f0dc7cb6 PB |
37 | int tach_count; |
38 | struct pwm_fan_tach *tachs; | |
6b1ec478 SW |
39 | ktime_t sample_start; |
40 | struct timer_list rpm_timer; | |
41 | ||
2e5219c7 LM |
42 | unsigned int pwm_value; |
43 | unsigned int pwm_fan_state; | |
44 | unsigned int pwm_fan_max_state; | |
45 | unsigned int *pwm_fan_cooling_levels; | |
b6bddec0 | 46 | struct thermal_cooling_device *cdev; |
1aa03655 PB |
47 | |
48 | struct hwmon_chip_info info; | |
f0dc7cb6 | 49 | struct hwmon_channel_info fan_channel; |
1aa03655 PB |
50 | }; |
51 | ||
52 | static const u32 pwm_fan_channel_config_pwm[] = { | |
53 | HWMON_PWM_INPUT, | |
54 | 0 | |
55 | }; | |
56 | ||
57 | static const struct hwmon_channel_info pwm_fan_channel_pwm = { | |
58 | .type = hwmon_pwm, | |
59 | .config = pwm_fan_channel_config_pwm, | |
60 | }; | |
61 | ||
6b1ec478 SW |
62 | /* This handler assumes self resetting edge triggered interrupt. */ |
63 | static irqreturn_t pulse_handler(int irq, void *dev_id) | |
64 | { | |
01695410 | 65 | struct pwm_fan_tach *tach = dev_id; |
6b1ec478 | 66 | |
01695410 | 67 | atomic_inc(&tach->pulses); |
6b1ec478 SW |
68 | |
69 | return IRQ_HANDLED; | |
70 | } | |
71 | ||
72 | static void sample_timer(struct timer_list *t) | |
73 | { | |
74 | struct pwm_fan_ctx *ctx = from_timer(ctx, t, rpm_timer); | |
fd8feec6 | 75 | unsigned int delta = ktime_ms_delta(ktime_get(), ctx->sample_start); |
f0dc7cb6 | 76 | int i; |
6b1ec478 | 77 | |
fd8feec6 | 78 | if (delta) { |
f0dc7cb6 PB |
79 | for (i = 0; i < ctx->tach_count; i++) { |
80 | struct pwm_fan_tach *tach = &ctx->tachs[i]; | |
81 | int pulses; | |
82 | ||
83 | pulses = atomic_read(&tach->pulses); | |
84 | atomic_sub(pulses, &tach->pulses); | |
85 | tach->rpm = (unsigned int)(pulses * 1000 * 60) / | |
86 | (tach->pulses_per_revolution * delta); | |
87 | } | |
fd8feec6 PB |
88 | |
89 | ctx->sample_start = ktime_get(); | |
90 | } | |
6b1ec478 | 91 | |
6b1ec478 SW |
92 | mod_timer(&ctx->rpm_timer, jiffies + HZ); |
93 | } | |
94 | ||
cb85ca33 | 95 | static int __set_pwm(struct pwm_fan_ctx *ctx, unsigned long pwm) |
d82d5776 | 96 | { |
677252a1 | 97 | unsigned long period; |
cb85ca33 | 98 | int ret = 0; |
86585c61 | 99 | struct pwm_state *state = &ctx->pwm_state; |
2289711c | 100 | |
d82d5776 | 101 | mutex_lock(&ctx->lock); |
d82d5776 | 102 | if (ctx->pwm_value == pwm) |
cb85ca33 | 103 | goto exit_set_pwm_err; |
d82d5776 | 104 | |
86585c61 UKK |
105 | period = state->period; |
106 | state->duty_cycle = DIV_ROUND_UP(pwm * (period - 1), MAX_PWM); | |
107 | state->enabled = pwm ? true : false; | |
f354169e | 108 | |
86585c61 | 109 | ret = pwm_apply_state(ctx->pwm, state); |
677252a1 BZ |
110 | if (!ret) |
111 | ctx->pwm_value = pwm; | |
d82d5776 KD |
112 | exit_set_pwm_err: |
113 | mutex_unlock(&ctx->lock); | |
114 | return ret; | |
115 | } | |
116 | ||
b6bddec0 LM |
117 | static void pwm_fan_update_state(struct pwm_fan_ctx *ctx, unsigned long pwm) |
118 | { | |
119 | int i; | |
120 | ||
121 | for (i = 0; i < ctx->pwm_fan_max_state; ++i) | |
122 | if (pwm < ctx->pwm_fan_cooling_levels[i + 1]) | |
123 | break; | |
124 | ||
125 | ctx->pwm_fan_state = i; | |
126 | } | |
127 | ||
1aa03655 PB |
128 | static int pwm_fan_write(struct device *dev, enum hwmon_sensor_types type, |
129 | u32 attr, int channel, long val) | |
cb85ca33 LM |
130 | { |
131 | struct pwm_fan_ctx *ctx = dev_get_drvdata(dev); | |
cb85ca33 LM |
132 | int ret; |
133 | ||
1aa03655 | 134 | if (val < 0 || val > MAX_PWM) |
cb85ca33 LM |
135 | return -EINVAL; |
136 | ||
1aa03655 | 137 | ret = __set_pwm(ctx, val); |
cb85ca33 LM |
138 | if (ret) |
139 | return ret; | |
140 | ||
1aa03655 PB |
141 | pwm_fan_update_state(ctx, val); |
142 | return 0; | |
cb85ca33 LM |
143 | } |
144 | ||
1aa03655 PB |
145 | static int pwm_fan_read(struct device *dev, enum hwmon_sensor_types type, |
146 | u32 attr, int channel, long *val) | |
d82d5776 KD |
147 | { |
148 | struct pwm_fan_ctx *ctx = dev_get_drvdata(dev); | |
149 | ||
1aa03655 PB |
150 | switch (type) { |
151 | case hwmon_pwm: | |
152 | *val = ctx->pwm_value; | |
153 | return 0; | |
d82d5776 | 154 | |
1aa03655 | 155 | case hwmon_fan: |
f0dc7cb6 | 156 | *val = ctx->tachs[channel].rpm; |
1aa03655 | 157 | return 0; |
6b1ec478 | 158 | |
1aa03655 PB |
159 | default: |
160 | return -ENOTSUPP; | |
161 | } | |
6b1ec478 | 162 | } |
d82d5776 | 163 | |
1aa03655 PB |
164 | static umode_t pwm_fan_is_visible(const void *data, |
165 | enum hwmon_sensor_types type, | |
166 | u32 attr, int channel) | |
6b1ec478 | 167 | { |
1aa03655 PB |
168 | switch (type) { |
169 | case hwmon_pwm: | |
170 | return 0644; | |
6b1ec478 | 171 | |
1aa03655 PB |
172 | case hwmon_fan: |
173 | return 0444; | |
6b1ec478 | 174 | |
1aa03655 PB |
175 | default: |
176 | return 0; | |
177 | } | |
6b1ec478 SW |
178 | } |
179 | ||
1aa03655 PB |
180 | static const struct hwmon_ops pwm_fan_hwmon_ops = { |
181 | .is_visible = pwm_fan_is_visible, | |
182 | .read = pwm_fan_read, | |
183 | .write = pwm_fan_write, | |
6b1ec478 | 184 | }; |
d82d5776 | 185 | |
b6bddec0 LM |
186 | /* thermal cooling device callbacks */ |
187 | static int pwm_fan_get_max_state(struct thermal_cooling_device *cdev, | |
188 | unsigned long *state) | |
189 | { | |
190 | struct pwm_fan_ctx *ctx = cdev->devdata; | |
191 | ||
192 | if (!ctx) | |
193 | return -EINVAL; | |
194 | ||
195 | *state = ctx->pwm_fan_max_state; | |
196 | ||
197 | return 0; | |
198 | } | |
199 | ||
200 | static int pwm_fan_get_cur_state(struct thermal_cooling_device *cdev, | |
201 | unsigned long *state) | |
202 | { | |
203 | struct pwm_fan_ctx *ctx = cdev->devdata; | |
204 | ||
205 | if (!ctx) | |
206 | return -EINVAL; | |
207 | ||
208 | *state = ctx->pwm_fan_state; | |
209 | ||
210 | return 0; | |
211 | } | |
212 | ||
213 | static int | |
214 | pwm_fan_set_cur_state(struct thermal_cooling_device *cdev, unsigned long state) | |
215 | { | |
216 | struct pwm_fan_ctx *ctx = cdev->devdata; | |
217 | int ret; | |
218 | ||
219 | if (!ctx || (state > ctx->pwm_fan_max_state)) | |
220 | return -EINVAL; | |
221 | ||
222 | if (state == ctx->pwm_fan_state) | |
223 | return 0; | |
224 | ||
225 | ret = __set_pwm(ctx, ctx->pwm_fan_cooling_levels[state]); | |
226 | if (ret) { | |
227 | dev_err(&cdev->device, "Cannot set pwm!\n"); | |
228 | return ret; | |
229 | } | |
230 | ||
231 | ctx->pwm_fan_state = state; | |
232 | ||
233 | return ret; | |
234 | } | |
235 | ||
236 | static const struct thermal_cooling_device_ops pwm_fan_cooling_ops = { | |
237 | .get_max_state = pwm_fan_get_max_state, | |
238 | .get_cur_state = pwm_fan_get_cur_state, | |
239 | .set_cur_state = pwm_fan_set_cur_state, | |
240 | }; | |
241 | ||
de52b049 GR |
242 | static int pwm_fan_of_get_cooling_data(struct device *dev, |
243 | struct pwm_fan_ctx *ctx) | |
2e5219c7 LM |
244 | { |
245 | struct device_node *np = dev->of_node; | |
246 | int num, i, ret; | |
247 | ||
248 | if (!of_find_property(np, "cooling-levels", NULL)) | |
249 | return 0; | |
250 | ||
251 | ret = of_property_count_u32_elems(np, "cooling-levels"); | |
252 | if (ret <= 0) { | |
253 | dev_err(dev, "Wrong data!\n"); | |
254 | return ret ? : -EINVAL; | |
255 | } | |
256 | ||
257 | num = ret; | |
a86854d0 | 258 | ctx->pwm_fan_cooling_levels = devm_kcalloc(dev, num, sizeof(u32), |
2e5219c7 LM |
259 | GFP_KERNEL); |
260 | if (!ctx->pwm_fan_cooling_levels) | |
261 | return -ENOMEM; | |
262 | ||
263 | ret = of_property_read_u32_array(np, "cooling-levels", | |
264 | ctx->pwm_fan_cooling_levels, num); | |
265 | if (ret) { | |
266 | dev_err(dev, "Property 'cooling-levels' cannot be read!\n"); | |
267 | return ret; | |
268 | } | |
269 | ||
270 | for (i = 0; i < num; i++) { | |
271 | if (ctx->pwm_fan_cooling_levels[i] > MAX_PWM) { | |
272 | dev_err(dev, "PWM fan state[%d]:%d > %d\n", i, | |
273 | ctx->pwm_fan_cooling_levels[i], MAX_PWM); | |
274 | return -EINVAL; | |
275 | } | |
276 | } | |
277 | ||
278 | ctx->pwm_fan_max_state = num - 1; | |
279 | ||
280 | return 0; | |
281 | } | |
282 | ||
37bcec5d GR |
283 | static void pwm_fan_regulator_disable(void *data) |
284 | { | |
285 | regulator_disable(data); | |
286 | } | |
287 | ||
a455eda3 | 288 | static void pwm_fan_pwm_disable(void *__ctx) |
37bcec5d | 289 | { |
a455eda3 | 290 | struct pwm_fan_ctx *ctx = __ctx; |
86585c61 UKK |
291 | |
292 | ctx->pwm_state.enabled = false; | |
293 | pwm_apply_state(ctx->pwm, &ctx->pwm_state); | |
a455eda3 | 294 | del_timer_sync(&ctx->rpm_timer); |
37bcec5d GR |
295 | } |
296 | ||
d82d5776 KD |
297 | static int pwm_fan_probe(struct platform_device *pdev) |
298 | { | |
b6bddec0 | 299 | struct thermal_cooling_device *cdev; |
37bcec5d | 300 | struct device *dev = &pdev->dev; |
d82d5776 | 301 | struct pwm_fan_ctx *ctx; |
b6bddec0 | 302 | struct device *hwmon; |
d82d5776 | 303 | int ret; |
1aa03655 | 304 | const struct hwmon_channel_info **channels; |
f0dc7cb6 PB |
305 | u32 *fan_channel_config; |
306 | int channel_count = 1; /* We always have a PWM channel. */ | |
307 | int i; | |
d82d5776 | 308 | |
37bcec5d | 309 | ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL); |
d82d5776 KD |
310 | if (!ctx) |
311 | return -ENOMEM; | |
312 | ||
313 | mutex_init(&ctx->lock); | |
314 | ||
37bcec5d | 315 | ctx->pwm = devm_of_pwm_get(dev, dev->of_node, NULL); |
65b2aad0 AH |
316 | if (IS_ERR(ctx->pwm)) |
317 | return dev_err_probe(dev, PTR_ERR(ctx->pwm), "Could not get PWM\n"); | |
d82d5776 | 318 | |
d82d5776 KD |
319 | platform_set_drvdata(pdev, ctx); |
320 | ||
37bcec5d | 321 | ctx->reg_en = devm_regulator_get_optional(dev, "fan"); |
b57e1d42 SW |
322 | if (IS_ERR(ctx->reg_en)) { |
323 | if (PTR_ERR(ctx->reg_en) != -ENODEV) | |
324 | return PTR_ERR(ctx->reg_en); | |
325 | ||
326 | ctx->reg_en = NULL; | |
327 | } else { | |
328 | ret = regulator_enable(ctx->reg_en); | |
329 | if (ret) { | |
37bcec5d | 330 | dev_err(dev, "Failed to enable fan supply: %d\n", ret); |
b57e1d42 SW |
331 | return ret; |
332 | } | |
5696e4aa GR |
333 | ret = devm_add_action_or_reset(dev, pwm_fan_regulator_disable, |
334 | ctx->reg_en); | |
335 | if (ret) | |
336 | return ret; | |
b57e1d42 SW |
337 | } |
338 | ||
86585c61 UKK |
339 | pwm_init_state(ctx->pwm, &ctx->pwm_state); |
340 | ||
1eda5233 UKK |
341 | /* |
342 | * __set_pwm assumes that MAX_PWM * (period - 1) fits into an unsigned | |
343 | * long. Check this here to prevent the fan running at a too low | |
344 | * frequency. | |
345 | */ | |
86585c61 | 346 | if (ctx->pwm_state.period > ULONG_MAX / MAX_PWM + 1) { |
1eda5233 UKK |
347 | dev_err(dev, "Configured period too big\n"); |
348 | return -EINVAL; | |
349 | } | |
350 | ||
351 | /* Set duty cycle to maximum allowed and enable PWM output */ | |
86585c61 | 352 | ret = __set_pwm(ctx, MAX_PWM); |
d82d5776 | 353 | if (ret) { |
a455eda3 | 354 | dev_err(dev, "Failed to configure PWM: %d\n", ret); |
37bcec5d | 355 | return ret; |
d82d5776 | 356 | } |
6b1ec478 | 357 | timer_setup(&ctx->rpm_timer, sample_timer, 0); |
5696e4aa GR |
358 | ret = devm_add_action_or_reset(dev, pwm_fan_pwm_disable, ctx); |
359 | if (ret) | |
360 | return ret; | |
6b1ec478 | 361 | |
f0dc7cb6 PB |
362 | ctx->tach_count = platform_irq_count(pdev); |
363 | if (ctx->tach_count < 0) | |
364 | return dev_err_probe(dev, ctx->tach_count, | |
b5fcb8a4 | 365 | "Could not get number of fan tachometer inputs\n"); |
f0dc7cb6 | 366 | dev_dbg(dev, "%d fan tachometer inputs\n", ctx->tach_count); |
b5fcb8a4 | 367 | |
f0dc7cb6 PB |
368 | if (ctx->tach_count) { |
369 | channel_count++; /* We also have a FAN channel. */ | |
370 | ||
371 | ctx->tachs = devm_kcalloc(dev, ctx->tach_count, | |
372 | sizeof(struct pwm_fan_tach), | |
373 | GFP_KERNEL); | |
374 | if (!ctx->tachs) | |
375 | return -ENOMEM; | |
376 | ||
377 | ctx->fan_channel.type = hwmon_fan; | |
378 | fan_channel_config = devm_kcalloc(dev, ctx->tach_count + 1, | |
379 | sizeof(u32), GFP_KERNEL); | |
380 | if (!fan_channel_config) | |
381 | return -ENOMEM; | |
382 | ctx->fan_channel.config = fan_channel_config; | |
383 | } | |
384 | ||
385 | channels = devm_kcalloc(dev, channel_count + 1, | |
1aa03655 PB |
386 | sizeof(struct hwmon_channel_info *), GFP_KERNEL); |
387 | if (!channels) | |
388 | return -ENOMEM; | |
389 | ||
390 | channels[0] = &pwm_fan_channel_pwm; | |
391 | ||
f0dc7cb6 PB |
392 | for (i = 0; i < ctx->tach_count; i++) { |
393 | struct pwm_fan_tach *tach = &ctx->tachs[i]; | |
b5fcb8a4 PB |
394 | u32 ppr = 2; |
395 | ||
f0dc7cb6 | 396 | tach->irq = platform_get_irq(pdev, i); |
01695410 PB |
397 | if (tach->irq == -EPROBE_DEFER) |
398 | return tach->irq; | |
399 | if (tach->irq > 0) { | |
400 | ret = devm_request_irq(dev, tach->irq, pulse_handler, 0, | |
401 | pdev->name, tach); | |
b5fcb8a4 PB |
402 | if (ret) { |
403 | dev_err(dev, | |
404 | "Failed to request interrupt: %d\n", | |
405 | ret); | |
406 | return ret; | |
407 | } | |
408 | } | |
6b1ec478 | 409 | |
f0dc7cb6 PB |
410 | of_property_read_u32_index(dev->of_node, |
411 | "pulses-per-revolution", | |
412 | i, | |
413 | &ppr); | |
01695410 PB |
414 | tach->pulses_per_revolution = ppr; |
415 | if (!tach->pulses_per_revolution) { | |
b5fcb8a4 PB |
416 | dev_err(dev, "pulses-per-revolution can't be zero.\n"); |
417 | return -EINVAL; | |
6b1ec478 | 418 | } |
b5fcb8a4 | 419 | |
f0dc7cb6 PB |
420 | fan_channel_config[i] = HWMON_F_INPUT; |
421 | ||
422 | dev_dbg(dev, "tach%d: irq=%d, pulses_per_revolution=%d\n", | |
423 | i, tach->irq, tach->pulses_per_revolution); | |
424 | } | |
b5fcb8a4 | 425 | |
f0dc7cb6 | 426 | if (ctx->tach_count > 0) { |
6b1ec478 SW |
427 | ctx->sample_start = ktime_get(); |
428 | mod_timer(&ctx->rpm_timer, jiffies + HZ); | |
1aa03655 | 429 | |
f0dc7cb6 | 430 | channels[1] = &ctx->fan_channel; |
6b1ec478 SW |
431 | } |
432 | ||
1aa03655 PB |
433 | ctx->info.ops = &pwm_fan_hwmon_ops; |
434 | ctx->info.info = channels; | |
435 | ||
436 | hwmon = devm_hwmon_device_register_with_info(dev, "pwmfan", | |
437 | ctx, &ctx->info, NULL); | |
d82d5776 | 438 | if (IS_ERR(hwmon)) { |
37bcec5d GR |
439 | dev_err(dev, "Failed to register hwmon device\n"); |
440 | return PTR_ERR(hwmon); | |
d82d5776 | 441 | } |
2e5219c7 | 442 | |
37bcec5d | 443 | ret = pwm_fan_of_get_cooling_data(dev, ctx); |
2e5219c7 LM |
444 | if (ret) |
445 | return ret; | |
446 | ||
b6bddec0 LM |
447 | ctx->pwm_fan_state = ctx->pwm_fan_max_state; |
448 | if (IS_ENABLED(CONFIG_THERMAL)) { | |
37bcec5d GR |
449 | cdev = devm_thermal_of_cooling_device_register(dev, |
450 | dev->of_node, "pwm-fan", ctx, &pwm_fan_cooling_ops); | |
b6bddec0 | 451 | if (IS_ERR(cdev)) { |
677252a1 | 452 | ret = PTR_ERR(cdev); |
37bcec5d | 453 | dev_err(dev, |
841cf676 RM |
454 | "Failed to register pwm-fan as cooling device: %d\n", |
455 | ret); | |
a455eda3 | 456 | return ret; |
b6bddec0 LM |
457 | } |
458 | ctx->cdev = cdev; | |
b6bddec0 LM |
459 | } |
460 | ||
d82d5776 | 461 | return 0; |
d82d5776 KD |
462 | } |
463 | ||
7992db7c | 464 | static int pwm_fan_disable(struct device *dev) |
d82d5776 KD |
465 | { |
466 | struct pwm_fan_ctx *ctx = dev_get_drvdata(dev); | |
95dcd64b TR |
467 | int ret; |
468 | ||
95dcd64b | 469 | if (ctx->pwm_value) { |
86585c61 UKK |
470 | /* keep ctx->pwm_state unmodified for pwm_fan_resume() */ |
471 | struct pwm_state state = ctx->pwm_state; | |
472 | ||
473 | state.duty_cycle = 0; | |
474 | state.enabled = false; | |
475 | ret = pwm_apply_state(ctx->pwm, &state); | |
95dcd64b TR |
476 | if (ret < 0) |
477 | return ret; | |
95dcd64b TR |
478 | } |
479 | ||
b57e1d42 SW |
480 | if (ctx->reg_en) { |
481 | ret = regulator_disable(ctx->reg_en); | |
482 | if (ret) { | |
483 | dev_err(dev, "Failed to disable fan supply: %d\n", ret); | |
484 | return ret; | |
485 | } | |
486 | } | |
487 | ||
d82d5776 KD |
488 | return 0; |
489 | } | |
490 | ||
7992db7c AM |
491 | static void pwm_fan_shutdown(struct platform_device *pdev) |
492 | { | |
493 | pwm_fan_disable(&pdev->dev); | |
494 | } | |
495 | ||
496 | #ifdef CONFIG_PM_SLEEP | |
497 | static int pwm_fan_suspend(struct device *dev) | |
498 | { | |
499 | return pwm_fan_disable(dev); | |
500 | } | |
501 | ||
d82d5776 KD |
502 | static int pwm_fan_resume(struct device *dev) |
503 | { | |
504 | struct pwm_fan_ctx *ctx = dev_get_drvdata(dev); | |
48b9d5b4 | 505 | int ret; |
d82d5776 | 506 | |
b57e1d42 SW |
507 | if (ctx->reg_en) { |
508 | ret = regulator_enable(ctx->reg_en); | |
509 | if (ret) { | |
510 | dev_err(dev, "Failed to enable fan supply: %d\n", ret); | |
511 | return ret; | |
512 | } | |
513 | } | |
514 | ||
48b9d5b4 KD |
515 | if (ctx->pwm_value == 0) |
516 | return 0; | |
517 | ||
86585c61 | 518 | return pwm_apply_state(ctx->pwm, &ctx->pwm_state); |
d82d5776 KD |
519 | } |
520 | #endif | |
521 | ||
522 | static SIMPLE_DEV_PM_OPS(pwm_fan_pm, pwm_fan_suspend, pwm_fan_resume); | |
523 | ||
d720acac | 524 | static const struct of_device_id of_pwm_fan_match[] = { |
d82d5776 KD |
525 | { .compatible = "pwm-fan", }, |
526 | {}, | |
527 | }; | |
f491e70c | 528 | MODULE_DEVICE_TABLE(of, of_pwm_fan_match); |
d82d5776 KD |
529 | |
530 | static struct platform_driver pwm_fan_driver = { | |
531 | .probe = pwm_fan_probe, | |
7992db7c | 532 | .shutdown = pwm_fan_shutdown, |
d82d5776 KD |
533 | .driver = { |
534 | .name = "pwm-fan", | |
535 | .pm = &pwm_fan_pm, | |
536 | .of_match_table = of_pwm_fan_match, | |
537 | }, | |
538 | }; | |
539 | ||
540 | module_platform_driver(pwm_fan_driver); | |
541 | ||
542 | MODULE_AUTHOR("Kamil Debski <k.debski@samsung.com>"); | |
543 | MODULE_ALIAS("platform:pwm-fan"); | |
544 | MODULE_DESCRIPTION("PWM FAN driver"); | |
545 | MODULE_LICENSE("GPL"); |