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