drivers/hwmon/pwm-fan.c

   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 <[email protected]>
   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 initial_pwm, 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         ret = pwm_fan_get_cooling_data(dev, ctx);
 549         if (ret)
 550                 return ret;
 551
 552         /* use maximum cooling level if provided */
 553         if (ctx->pwm_fan_cooling_levels)
 554                 initial_pwm = ctx->pwm_fan_cooling_levels[ctx->pwm_fan_max_state];
 555         else
 556                 initial_pwm = MAX_PWM;
 557
 558         /*
 559          * Set duty cycle to maximum allowed and enable PWM output as well as
 560          * the regulator. In case of error nothing is changed
 561          */
 562         ret = set_pwm(ctx, initial_pwm);
 563         if (ret) {
 564                 dev_err(dev, "Failed to configure PWM: %d\n", ret);
 565                 return ret;
 566         }
 567         timer_setup(&ctx->rpm_timer, sample_timer, 0);
 568         ret = devm_add_action_or_reset(dev, pwm_fan_cleanup, ctx);
 569         if (ret)
 570                 return ret;
 571
 572         ctx->tach_count = platform_irq_count(pdev);
 573         if (ctx->tach_count < 0)
 574                 return dev_err_probe(dev, ctx->tach_count,
 575                                      "Could not get number of fan tachometer inputs\n");
 576         dev_dbg(dev, "%d fan tachometer inputs\n", ctx->tach_count);
 577
 578         if (ctx->tach_count) {
 579                 channel_count++;        /* We also have a FAN channel. */
 580
 581                 ctx->tachs = devm_kcalloc(dev, ctx->tach_count,
 582                                           sizeof(struct pwm_fan_tach),
 583                                           GFP_KERNEL);
 584                 if (!ctx->tachs)
 585                         return -ENOMEM;
 586
 587                 ctx->fan_channel.type = hwmon_fan;
 588                 fan_channel_config = devm_kcalloc(dev, ctx->tach_count + 1,
 589                                                   sizeof(u32), GFP_KERNEL);
 590                 if (!fan_channel_config)
 591                         return -ENOMEM;
 592                 ctx->fan_channel.config = fan_channel_config;
 593
 594                 ctx->pulses_per_revolution = devm_kmalloc_array(dev,
 595                                                                 ctx->tach_count,
 596                                                                 sizeof(*ctx->pulses_per_revolution),
 597                                                                 GFP_KERNEL);
 598                 if (!ctx->pulses_per_revolution)
 599                         return -ENOMEM;
 600
 601                 /* Setup default pulses per revolution */
 602                 for (i = 0; i < ctx->tach_count; i++)
 603                         ctx->pulses_per_revolution[i] = 2;
 604
 605                 device_property_read_u32_array(dev, "pulses-per-revolution",
 606                                                ctx->pulses_per_revolution, ctx->tach_count);
 607         }
 608
 609         channels = devm_kcalloc(dev, channel_count + 1,
 610                                 sizeof(struct hwmon_channel_info *), GFP_KERNEL);
 611         if (!channels)
 612                 return -ENOMEM;
 613
 614         channels[0] = HWMON_CHANNEL_INFO(pwm, HWMON_PWM_INPUT | HWMON_PWM_ENABLE);
 615
 616         for (i = 0; i < ctx->tach_count; i++) {
 617                 struct pwm_fan_tach *tach = &ctx->tachs[i];
 618
 619                 tach->irq = platform_get_irq(pdev, i);
 620                 if (tach->irq == -EPROBE_DEFER)
 621                         return tach->irq;
 622                 if (tach->irq > 0) {
 623                         ret = devm_request_irq(dev, tach->irq, pulse_handler, 0,
 624                                                pdev->name, tach);
 625                         if (ret) {
 626                                 dev_err(dev,
 627                                         "Failed to request interrupt: %d\n",
 628                                         ret);
 629                                 return ret;
 630                         }
 631                 }
 632
 633                 if (!ctx->pulses_per_revolution[i]) {
 634                         dev_err(dev, "pulses-per-revolution can't be zero.\n");
 635                         return -EINVAL;
 636                 }
 637
 638                 fan_channel_config[i] = HWMON_F_INPUT;
 639
 640                 dev_dbg(dev, "tach%d: irq=%d, pulses_per_revolution=%d\n",
 641                         i, tach->irq, ctx->pulses_per_revolution[i]);
 642         }
 643
 644         if (ctx->tach_count > 0) {
 645                 ctx->sample_start = ktime_get();
 646                 mod_timer(&ctx->rpm_timer, jiffies + HZ);
 647
 648                 channels[1] = &ctx->fan_channel;
 649         }
 650
 651         ret = device_property_read_u32(dev, "fan-stop-to-start-percent",
 652                                        &pwm_min_from_stopped);
 653         if (!ret && pwm_min_from_stopped) {
 654                 ctx->pwm_duty_cycle_from_stopped =
 655                         DIV_ROUND_UP_ULL(pwm_min_from_stopped *
 656                                          (ctx->pwm_state.period - 1),
 657                                          100);
 658         }
 659         ret = device_property_read_u32(dev, "fan-stop-to-start-us",
 660                                        &ctx->pwm_usec_from_stopped);
 661         if (ret)
 662                 ctx->pwm_usec_from_stopped = 250000;
 663
 664         ctx->info.ops = &pwm_fan_hwmon_ops;
 665         ctx->info.info = channels;
 666
 667         hwmon = devm_hwmon_device_register_with_info(dev, "pwmfan",
 668                                                      ctx, &ctx->info, NULL);
 669         if (IS_ERR(hwmon)) {
 670                 dev_err(dev, "Failed to register hwmon device\n");
 671                 return PTR_ERR(hwmon);
 672         }
 673
 674         ctx->pwm_fan_state = ctx->pwm_fan_max_state;
 675         if (IS_ENABLED(CONFIG_THERMAL)) {
 676                 cdev = devm_thermal_of_cooling_device_register(dev,
 677                         dev->of_node, "pwm-fan", ctx, &pwm_fan_cooling_ops);
 678                 if (IS_ERR(cdev)) {
 679                         ret = PTR_ERR(cdev);
 680                         dev_err(dev,
 681                                 "Failed to register pwm-fan as cooling device: %d\n",
 682                                 ret);
 683                         return ret;
 684                 }
 685                 ctx->cdev = cdev;
 686         }
 687
 688         return 0;
 689 }
 690
 691 static void pwm_fan_shutdown(struct platform_device *pdev)
 692 {
 693         struct pwm_fan_ctx *ctx = platform_get_drvdata(pdev);
 694
 695         pwm_fan_cleanup(ctx);
 696 }
 697
 698 static int pwm_fan_suspend(struct device *dev)
 699 {
 700         struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
 701
 702         return pwm_fan_power_off(ctx, true);
 703 }
 704
 705 static int pwm_fan_resume(struct device *dev)
 706 {
 707         struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
 708
 709         return set_pwm(ctx, ctx->pwm_value);
 710 }
 711
 712 static DEFINE_SIMPLE_DEV_PM_OPS(pwm_fan_pm, pwm_fan_suspend, pwm_fan_resume);
 713
 714 static const struct of_device_id of_pwm_fan_match[] = {
 715         { .compatible = "pwm-fan", },
 716         {},
 717 };
 718 MODULE_DEVICE_TABLE(of, of_pwm_fan_match);
 719
 720 static struct platform_driver pwm_fan_driver = {
 721         .probe          = pwm_fan_probe,
 722         .shutdown       = pwm_fan_shutdown,
 723         .driver = {
 724                 .name           = "pwm-fan",
 725                 .pm             = pm_sleep_ptr(&pwm_fan_pm),
 726                 .of_match_table = of_pwm_fan_match,
 727         },
 728 };
 729
 730 module_platform_driver(pwm_fan_driver);
 731
 732 MODULE_AUTHOR("Kamil Debski <[email protected]>");
 733 MODULE_ALIAS("platform:pwm-fan");
 734 MODULE_DESCRIPTION("PWM FAN driver");
 735 MODULE_LICENSE("GPL");