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