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/mod_devicetable.h> 14 #include <linux/module.h> 15 #include <linux/mutex.h> 16 #include <linux/platform_device.h> 17 #include <linux/property.h> 18 #include <linux/pwm.h> 19 #include <linux/regulator/consumer.h> 20 #include <linux/sysfs.h> 21 #include <linux/thermal.h> 22 #include <linux/timer.h> 23 24 #define MAX_PWM 255 25 26 struct pwm_fan_tach { 27 int irq; 28 atomic_t pulses; 29 unsigned int rpm; 30 }; 31 32 enum pwm_fan_enable_mode { 33 pwm_off_reg_off, 34 pwm_disable_reg_enable, 35 pwm_enable_reg_enable, 36 pwm_disable_reg_disable, 37 }; 38 39 struct pwm_fan_ctx { 40 struct device *dev; 41 42 struct mutex lock; 43 struct pwm_device *pwm; 44 struct pwm_state pwm_state; 45 struct regulator *reg_en; 46 enum pwm_fan_enable_mode enable_mode; 47 bool regulator_enabled; 48 bool enabled; 49 50 int tach_count; 51 struct pwm_fan_tach *tachs; 52 u32 *pulses_per_revolution; 53 ktime_t sample_start; 54 struct timer_list rpm_timer; 55 56 unsigned int pwm_value; 57 unsigned int pwm_fan_state; 58 unsigned int pwm_fan_max_state; 59 unsigned int *pwm_fan_cooling_levels; 60 struct thermal_cooling_device *cdev; 61 62 struct hwmon_chip_info info; 63 struct hwmon_channel_info fan_channel; 64 65 u64 pwm_duty_cycle_from_stopped; 66 u32 pwm_usec_from_stopped; 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 = from_timer(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 del_timer_sync(&ctx->rpm_timer); 487 /* Switch off everything */ 488 ctx->enable_mode = pwm_disable_reg_disable; 489 pwm_fan_power_off(ctx, true); 490 } 491 492 static int pwm_fan_probe(struct platform_device *pdev) 493 { 494 struct thermal_cooling_device *cdev; 495 struct device *dev = &pdev->dev; 496 struct pwm_fan_ctx *ctx; 497 struct device *hwmon; 498 int ret; 499 const struct hwmon_channel_info **channels; 500 u32 pwm_min_from_stopped = 0; 501 u32 *fan_channel_config; 502 int channel_count = 1; /* We always have a PWM channel. */ 503 int i; 504 505 ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL); 506 if (!ctx) 507 return -ENOMEM; 508 509 mutex_init(&ctx->lock); 510 511 ctx->dev = &pdev->dev; 512 ctx->pwm = devm_pwm_get(dev, NULL); 513 if (IS_ERR(ctx->pwm)) 514 return dev_err_probe(dev, PTR_ERR(ctx->pwm), "Could not get PWM\n"); 515 516 platform_set_drvdata(pdev, ctx); 517 518 ctx->reg_en = devm_regulator_get_optional(dev, "fan"); 519 if (IS_ERR(ctx->reg_en)) { 520 if (PTR_ERR(ctx->reg_en) != -ENODEV) 521 return PTR_ERR(ctx->reg_en); 522 523 ctx->reg_en = NULL; 524 } 525 526 pwm_init_state(ctx->pwm, &ctx->pwm_state); 527 528 /* 529 * PWM fans are controlled solely by the duty cycle of the PWM signal, 530 * they do not care about the exact timing. Thus set usage_power to true 531 * to allow less flexible hardware to work as a PWM source for fan 532 * control. 533 */ 534 ctx->pwm_state.usage_power = true; 535 536 /* 537 * set_pwm assumes that MAX_PWM * (period - 1) fits into an unsigned 538 * long. Check this here to prevent the fan running at a too low 539 * frequency. 540 */ 541 if (ctx->pwm_state.period > ULONG_MAX / MAX_PWM + 1) { 542 dev_err(dev, "Configured period too big\n"); 543 return -EINVAL; 544 } 545 546 ctx->enable_mode = pwm_disable_reg_enable; 547 548 /* 549 * Set duty cycle to maximum allowed and enable PWM output as well as 550 * the regulator. In case of error nothing is changed 551 */ 552 ret = set_pwm(ctx, MAX_PWM); 553 if (ret) { 554 dev_err(dev, "Failed to configure PWM: %d\n", ret); 555 return ret; 556 } 557 timer_setup(&ctx->rpm_timer, sample_timer, 0); 558 ret = devm_add_action_or_reset(dev, pwm_fan_cleanup, ctx); 559 if (ret) 560 return ret; 561 562 ctx->tach_count = platform_irq_count(pdev); 563 if (ctx->tach_count < 0) 564 return dev_err_probe(dev, ctx->tach_count, 565 "Could not get number of fan tachometer inputs\n"); 566 dev_dbg(dev, "%d fan tachometer inputs\n", ctx->tach_count); 567 568 if (ctx->tach_count) { 569 channel_count++; /* We also have a FAN channel. */ 570 571 ctx->tachs = devm_kcalloc(dev, ctx->tach_count, 572 sizeof(struct pwm_fan_tach), 573 GFP_KERNEL); 574 if (!ctx->tachs) 575 return -ENOMEM; 576 577 ctx->fan_channel.type = hwmon_fan; 578 fan_channel_config = devm_kcalloc(dev, ctx->tach_count + 1, 579 sizeof(u32), GFP_KERNEL); 580 if (!fan_channel_config) 581 return -ENOMEM; 582 ctx->fan_channel.config = fan_channel_config; 583 584 ctx->pulses_per_revolution = devm_kmalloc_array(dev, 585 ctx->tach_count, 586 sizeof(*ctx->pulses_per_revolution), 587 GFP_KERNEL); 588 if (!ctx->pulses_per_revolution) 589 return -ENOMEM; 590 591 /* Setup default pulses per revolution */ 592 for (i = 0; i < ctx->tach_count; i++) 593 ctx->pulses_per_revolution[i] = 2; 594 595 device_property_read_u32_array(dev, "pulses-per-revolution", 596 ctx->pulses_per_revolution, ctx->tach_count); 597 } 598 599 channels = devm_kcalloc(dev, channel_count + 1, 600 sizeof(struct hwmon_channel_info *), GFP_KERNEL); 601 if (!channels) 602 return -ENOMEM; 603 604 channels[0] = HWMON_CHANNEL_INFO(pwm, HWMON_PWM_INPUT | HWMON_PWM_ENABLE); 605 606 for (i = 0; i < ctx->tach_count; i++) { 607 struct pwm_fan_tach *tach = &ctx->tachs[i]; 608 609 tach->irq = platform_get_irq(pdev, i); 610 if (tach->irq == -EPROBE_DEFER) 611 return tach->irq; 612 if (tach->irq > 0) { 613 ret = devm_request_irq(dev, tach->irq, pulse_handler, 0, 614 pdev->name, tach); 615 if (ret) { 616 dev_err(dev, 617 "Failed to request interrupt: %d\n", 618 ret); 619 return ret; 620 } 621 } 622 623 if (!ctx->pulses_per_revolution[i]) { 624 dev_err(dev, "pulses-per-revolution can't be zero.\n"); 625 return -EINVAL; 626 } 627 628 fan_channel_config[i] = HWMON_F_INPUT; 629 630 dev_dbg(dev, "tach%d: irq=%d, pulses_per_revolution=%d\n", 631 i, tach->irq, ctx->pulses_per_revolution[i]); 632 } 633 634 if (ctx->tach_count > 0) { 635 ctx->sample_start = ktime_get(); 636 mod_timer(&ctx->rpm_timer, jiffies + HZ); 637 638 channels[1] = &ctx->fan_channel; 639 } 640 641 ret = of_property_read_u32(dev->of_node, "fan-stop-to-start-percent", 642 &pwm_min_from_stopped); 643 if (!ret && pwm_min_from_stopped) { 644 ctx->pwm_duty_cycle_from_stopped = 645 DIV_ROUND_UP_ULL(pwm_min_from_stopped * 646 (ctx->pwm_state.period - 1), 647 100); 648 } 649 ret = of_property_read_u32(dev->of_node, "fan-stop-to-start-us", 650 &ctx->pwm_usec_from_stopped); 651 if (ret) 652 ctx->pwm_usec_from_stopped = 250000; 653 654 ctx->info.ops = &pwm_fan_hwmon_ops; 655 ctx->info.info = channels; 656 657 hwmon = devm_hwmon_device_register_with_info(dev, "pwmfan", 658 ctx, &ctx->info, NULL); 659 if (IS_ERR(hwmon)) { 660 dev_err(dev, "Failed to register hwmon device\n"); 661 return PTR_ERR(hwmon); 662 } 663 664 ret = pwm_fan_get_cooling_data(dev, ctx); 665 if (ret) 666 return ret; 667 668 ctx->pwm_fan_state = ctx->pwm_fan_max_state; 669 if (IS_ENABLED(CONFIG_THERMAL)) { 670 cdev = devm_thermal_of_cooling_device_register(dev, 671 dev->of_node, "pwm-fan", ctx, &pwm_fan_cooling_ops); 672 if (IS_ERR(cdev)) { 673 ret = PTR_ERR(cdev); 674 dev_err(dev, 675 "Failed to register pwm-fan as cooling device: %d\n", 676 ret); 677 return ret; 678 } 679 ctx->cdev = cdev; 680 } 681 682 return 0; 683 } 684 685 static void pwm_fan_shutdown(struct platform_device *pdev) 686 { 687 struct pwm_fan_ctx *ctx = platform_get_drvdata(pdev); 688 689 pwm_fan_cleanup(ctx); 690 } 691 692 static int pwm_fan_suspend(struct device *dev) 693 { 694 struct pwm_fan_ctx *ctx = dev_get_drvdata(dev); 695 696 return pwm_fan_power_off(ctx, true); 697 } 698 699 static int pwm_fan_resume(struct device *dev) 700 { 701 struct pwm_fan_ctx *ctx = dev_get_drvdata(dev); 702 703 return set_pwm(ctx, ctx->pwm_value); 704 } 705 706 static DEFINE_SIMPLE_DEV_PM_OPS(pwm_fan_pm, pwm_fan_suspend, pwm_fan_resume); 707 708 static const struct of_device_id of_pwm_fan_match[] = { 709 { .compatible = "pwm-fan", }, 710 {}, 711 }; 712 MODULE_DEVICE_TABLE(of, of_pwm_fan_match); 713 714 static struct platform_driver pwm_fan_driver = { 715 .probe = pwm_fan_probe, 716 .shutdown = pwm_fan_shutdown, 717 .driver = { 718 .name = "pwm-fan", 719 .pm = pm_sleep_ptr(&pwm_fan_pm), 720 .of_match_table = of_pwm_fan_match, 721 }, 722 }; 723 724 module_platform_driver(pwm_fan_driver); 725 726 MODULE_AUTHOR("Kamil Debski <k.debski@samsung.com>"); 727 MODULE_ALIAS("platform:pwm-fan"); 728 MODULE_DESCRIPTION("PWM FAN driver"); 729 MODULE_LICENSE("GPL"); 730