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