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