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 return dev_err_probe(dev, PTR_ERR(ctx->pwm), "Could not get PWM\n"); 298 299 platform_set_drvdata(pdev, ctx); 300 301 ctx->irq = platform_get_irq_optional(pdev, 0); 302 if (ctx->irq == -EPROBE_DEFER) 303 return ctx->irq; 304 305 ctx->reg_en = devm_regulator_get_optional(dev, "fan"); 306 if (IS_ERR(ctx->reg_en)) { 307 if (PTR_ERR(ctx->reg_en) != -ENODEV) 308 return PTR_ERR(ctx->reg_en); 309 310 ctx->reg_en = NULL; 311 } else { 312 ret = regulator_enable(ctx->reg_en); 313 if (ret) { 314 dev_err(dev, "Failed to enable fan supply: %d\n", ret); 315 return ret; 316 } 317 ret = devm_add_action_or_reset(dev, pwm_fan_regulator_disable, 318 ctx->reg_en); 319 if (ret) 320 return ret; 321 } 322 323 ctx->pwm_value = MAX_PWM; 324 325 /* Set duty cycle to maximum allowed and enable PWM output */ 326 pwm_init_state(ctx->pwm, &state); 327 state.duty_cycle = ctx->pwm->args.period - 1; 328 state.enabled = true; 329 330 ret = pwm_apply_state(ctx->pwm, &state); 331 if (ret) { 332 dev_err(dev, "Failed to configure PWM: %d\n", ret); 333 return ret; 334 } 335 timer_setup(&ctx->rpm_timer, sample_timer, 0); 336 ret = devm_add_action_or_reset(dev, pwm_fan_pwm_disable, ctx); 337 if (ret) 338 return ret; 339 340 of_property_read_u32(dev->of_node, "pulses-per-revolution", &ppr); 341 ctx->pulses_per_revolution = ppr; 342 if (!ctx->pulses_per_revolution) { 343 dev_err(dev, "pulses-per-revolution can't be zero.\n"); 344 return -EINVAL; 345 } 346 347 if (ctx->irq > 0) { 348 ret = devm_request_irq(dev, ctx->irq, pulse_handler, 0, 349 pdev->name, ctx); 350 if (ret) { 351 dev_err(dev, "Failed to request interrupt: %d\n", ret); 352 return ret; 353 } 354 ctx->sample_start = ktime_get(); 355 mod_timer(&ctx->rpm_timer, jiffies + HZ); 356 } 357 358 hwmon = devm_hwmon_device_register_with_groups(dev, "pwmfan", 359 ctx, pwm_fan_groups); 360 if (IS_ERR(hwmon)) { 361 dev_err(dev, "Failed to register hwmon device\n"); 362 return PTR_ERR(hwmon); 363 } 364 365 ret = pwm_fan_of_get_cooling_data(dev, ctx); 366 if (ret) 367 return ret; 368 369 ctx->pwm_fan_state = ctx->pwm_fan_max_state; 370 if (IS_ENABLED(CONFIG_THERMAL)) { 371 cdev = devm_thermal_of_cooling_device_register(dev, 372 dev->of_node, "pwm-fan", ctx, &pwm_fan_cooling_ops); 373 if (IS_ERR(cdev)) { 374 ret = PTR_ERR(cdev); 375 dev_err(dev, 376 "Failed to register pwm-fan as cooling device: %d\n", 377 ret); 378 return ret; 379 } 380 ctx->cdev = cdev; 381 thermal_cdev_update(cdev); 382 } 383 384 return 0; 385 } 386 387 static int pwm_fan_disable(struct device *dev) 388 { 389 struct pwm_fan_ctx *ctx = dev_get_drvdata(dev); 390 struct pwm_args args; 391 int ret; 392 393 pwm_get_args(ctx->pwm, &args); 394 395 if (ctx->pwm_value) { 396 ret = pwm_config(ctx->pwm, 0, args.period); 397 if (ret < 0) 398 return ret; 399 400 pwm_disable(ctx->pwm); 401 } 402 403 if (ctx->reg_en) { 404 ret = regulator_disable(ctx->reg_en); 405 if (ret) { 406 dev_err(dev, "Failed to disable fan supply: %d\n", ret); 407 return ret; 408 } 409 } 410 411 return 0; 412 } 413 414 static void pwm_fan_shutdown(struct platform_device *pdev) 415 { 416 pwm_fan_disable(&pdev->dev); 417 } 418 419 #ifdef CONFIG_PM_SLEEP 420 static int pwm_fan_suspend(struct device *dev) 421 { 422 return pwm_fan_disable(dev); 423 } 424 425 static int pwm_fan_resume(struct device *dev) 426 { 427 struct pwm_fan_ctx *ctx = dev_get_drvdata(dev); 428 struct pwm_args pargs; 429 unsigned long duty; 430 int ret; 431 432 if (ctx->reg_en) { 433 ret = regulator_enable(ctx->reg_en); 434 if (ret) { 435 dev_err(dev, "Failed to enable fan supply: %d\n", ret); 436 return ret; 437 } 438 } 439 440 if (ctx->pwm_value == 0) 441 return 0; 442 443 pwm_get_args(ctx->pwm, &pargs); 444 duty = DIV_ROUND_UP_ULL(ctx->pwm_value * (pargs.period - 1), MAX_PWM); 445 ret = pwm_config(ctx->pwm, duty, pargs.period); 446 if (ret) 447 return ret; 448 return pwm_enable(ctx->pwm); 449 } 450 #endif 451 452 static SIMPLE_DEV_PM_OPS(pwm_fan_pm, pwm_fan_suspend, pwm_fan_resume); 453 454 static const struct of_device_id of_pwm_fan_match[] = { 455 { .compatible = "pwm-fan", }, 456 {}, 457 }; 458 MODULE_DEVICE_TABLE(of, of_pwm_fan_match); 459 460 static struct platform_driver pwm_fan_driver = { 461 .probe = pwm_fan_probe, 462 .shutdown = pwm_fan_shutdown, 463 .driver = { 464 .name = "pwm-fan", 465 .pm = &pwm_fan_pm, 466 .of_match_table = of_pwm_fan_match, 467 }, 468 }; 469 470 module_platform_driver(pwm_fan_driver); 471 472 MODULE_AUTHOR("Kamil Debski <k.debski@samsung.com>"); 473 MODULE_ALIAS("platform:pwm-fan"); 474 MODULE_DESCRIPTION("PWM FAN driver"); 475 MODULE_LICENSE("GPL"); 476