1 /* 2 * pwm-fan.c - Hwmon driver for fans connected to PWM lines. 3 * 4 * Copyright (c) 2014 Samsung Electronics Co., Ltd. 5 * 6 * Author: Kamil Debski <k.debski@samsung.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 */ 18 19 #include <linux/hwmon.h> 20 #include <linux/hwmon-sysfs.h> 21 #include <linux/module.h> 22 #include <linux/mutex.h> 23 #include <linux/of.h> 24 #include <linux/platform_device.h> 25 #include <linux/pwm.h> 26 #include <linux/sysfs.h> 27 #include <linux/thermal.h> 28 29 #define MAX_PWM 255 30 31 struct pwm_fan_ctx { 32 struct mutex lock; 33 struct pwm_device *pwm; 34 unsigned int pwm_value; 35 unsigned int pwm_fan_state; 36 unsigned int pwm_fan_max_state; 37 unsigned int *pwm_fan_cooling_levels; 38 struct thermal_cooling_device *cdev; 39 }; 40 41 static int __set_pwm(struct pwm_fan_ctx *ctx, unsigned long pwm) 42 { 43 unsigned long period; 44 int ret = 0; 45 struct pwm_state state = { }; 46 47 mutex_lock(&ctx->lock); 48 if (ctx->pwm_value == pwm) 49 goto exit_set_pwm_err; 50 51 pwm_init_state(ctx->pwm, &state); 52 period = ctx->pwm->args.period; 53 state.duty_cycle = DIV_ROUND_UP(pwm * (period - 1), MAX_PWM); 54 state.enabled = pwm ? true : false; 55 56 ret = pwm_apply_state(ctx->pwm, &state); 57 if (!ret) 58 ctx->pwm_value = pwm; 59 exit_set_pwm_err: 60 mutex_unlock(&ctx->lock); 61 return ret; 62 } 63 64 static void pwm_fan_update_state(struct pwm_fan_ctx *ctx, unsigned long pwm) 65 { 66 int i; 67 68 for (i = 0; i < ctx->pwm_fan_max_state; ++i) 69 if (pwm < ctx->pwm_fan_cooling_levels[i + 1]) 70 break; 71 72 ctx->pwm_fan_state = i; 73 } 74 75 static ssize_t pwm_store(struct device *dev, struct device_attribute *attr, 76 const char *buf, size_t count) 77 { 78 struct pwm_fan_ctx *ctx = dev_get_drvdata(dev); 79 unsigned long pwm; 80 int ret; 81 82 if (kstrtoul(buf, 10, &pwm) || pwm > MAX_PWM) 83 return -EINVAL; 84 85 ret = __set_pwm(ctx, pwm); 86 if (ret) 87 return ret; 88 89 pwm_fan_update_state(ctx, pwm); 90 return count; 91 } 92 93 static ssize_t pwm_show(struct device *dev, struct device_attribute *attr, 94 char *buf) 95 { 96 struct pwm_fan_ctx *ctx = dev_get_drvdata(dev); 97 98 return sprintf(buf, "%u\n", ctx->pwm_value); 99 } 100 101 102 static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0); 103 104 static struct attribute *pwm_fan_attrs[] = { 105 &sensor_dev_attr_pwm1.dev_attr.attr, 106 NULL, 107 }; 108 109 ATTRIBUTE_GROUPS(pwm_fan); 110 111 /* thermal cooling device callbacks */ 112 static int pwm_fan_get_max_state(struct thermal_cooling_device *cdev, 113 unsigned long *state) 114 { 115 struct pwm_fan_ctx *ctx = cdev->devdata; 116 117 if (!ctx) 118 return -EINVAL; 119 120 *state = ctx->pwm_fan_max_state; 121 122 return 0; 123 } 124 125 static int pwm_fan_get_cur_state(struct thermal_cooling_device *cdev, 126 unsigned long *state) 127 { 128 struct pwm_fan_ctx *ctx = cdev->devdata; 129 130 if (!ctx) 131 return -EINVAL; 132 133 *state = ctx->pwm_fan_state; 134 135 return 0; 136 } 137 138 static int 139 pwm_fan_set_cur_state(struct thermal_cooling_device *cdev, unsigned long state) 140 { 141 struct pwm_fan_ctx *ctx = cdev->devdata; 142 int ret; 143 144 if (!ctx || (state > ctx->pwm_fan_max_state)) 145 return -EINVAL; 146 147 if (state == ctx->pwm_fan_state) 148 return 0; 149 150 ret = __set_pwm(ctx, ctx->pwm_fan_cooling_levels[state]); 151 if (ret) { 152 dev_err(&cdev->device, "Cannot set pwm!\n"); 153 return ret; 154 } 155 156 ctx->pwm_fan_state = state; 157 158 return ret; 159 } 160 161 static const struct thermal_cooling_device_ops pwm_fan_cooling_ops = { 162 .get_max_state = pwm_fan_get_max_state, 163 .get_cur_state = pwm_fan_get_cur_state, 164 .set_cur_state = pwm_fan_set_cur_state, 165 }; 166 167 static int pwm_fan_of_get_cooling_data(struct device *dev, 168 struct pwm_fan_ctx *ctx) 169 { 170 struct device_node *np = dev->of_node; 171 int num, i, ret; 172 173 if (!of_find_property(np, "cooling-levels", NULL)) 174 return 0; 175 176 ret = of_property_count_u32_elems(np, "cooling-levels"); 177 if (ret <= 0) { 178 dev_err(dev, "Wrong data!\n"); 179 return ret ? : -EINVAL; 180 } 181 182 num = ret; 183 ctx->pwm_fan_cooling_levels = devm_kcalloc(dev, num, sizeof(u32), 184 GFP_KERNEL); 185 if (!ctx->pwm_fan_cooling_levels) 186 return -ENOMEM; 187 188 ret = of_property_read_u32_array(np, "cooling-levels", 189 ctx->pwm_fan_cooling_levels, num); 190 if (ret) { 191 dev_err(dev, "Property 'cooling-levels' cannot be read!\n"); 192 return ret; 193 } 194 195 for (i = 0; i < num; i++) { 196 if (ctx->pwm_fan_cooling_levels[i] > MAX_PWM) { 197 dev_err(dev, "PWM fan state[%d]:%d > %d\n", i, 198 ctx->pwm_fan_cooling_levels[i], MAX_PWM); 199 return -EINVAL; 200 } 201 } 202 203 ctx->pwm_fan_max_state = num - 1; 204 205 return 0; 206 } 207 208 static int pwm_fan_probe(struct platform_device *pdev) 209 { 210 struct thermal_cooling_device *cdev; 211 struct pwm_fan_ctx *ctx; 212 struct device *hwmon; 213 int ret; 214 struct pwm_state state = { }; 215 216 ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL); 217 if (!ctx) 218 return -ENOMEM; 219 220 mutex_init(&ctx->lock); 221 222 ctx->pwm = devm_of_pwm_get(&pdev->dev, pdev->dev.of_node, NULL); 223 if (IS_ERR(ctx->pwm)) { 224 ret = PTR_ERR(ctx->pwm); 225 226 if (ret != -EPROBE_DEFER) 227 dev_err(&pdev->dev, "Could not get PWM: %d\n", ret); 228 229 return ret; 230 } 231 232 platform_set_drvdata(pdev, ctx); 233 234 ctx->pwm_value = MAX_PWM; 235 236 /* Set duty cycle to maximum allowed and enable PWM output */ 237 pwm_init_state(ctx->pwm, &state); 238 state.duty_cycle = ctx->pwm->args.period - 1; 239 state.enabled = true; 240 241 ret = pwm_apply_state(ctx->pwm, &state); 242 if (ret) { 243 dev_err(&pdev->dev, "Failed to configure PWM\n"); 244 return ret; 245 } 246 247 hwmon = devm_hwmon_device_register_with_groups(&pdev->dev, "pwmfan", 248 ctx, pwm_fan_groups); 249 if (IS_ERR(hwmon)) { 250 dev_err(&pdev->dev, "Failed to register hwmon device\n"); 251 ret = PTR_ERR(hwmon); 252 goto err_pwm_disable; 253 } 254 255 ret = pwm_fan_of_get_cooling_data(&pdev->dev, ctx); 256 if (ret) 257 return ret; 258 259 ctx->pwm_fan_state = ctx->pwm_fan_max_state; 260 if (IS_ENABLED(CONFIG_THERMAL)) { 261 cdev = thermal_of_cooling_device_register(pdev->dev.of_node, 262 "pwm-fan", ctx, 263 &pwm_fan_cooling_ops); 264 if (IS_ERR(cdev)) { 265 dev_err(&pdev->dev, 266 "Failed to register pwm-fan as cooling device"); 267 ret = PTR_ERR(cdev); 268 goto err_pwm_disable; 269 } 270 ctx->cdev = cdev; 271 thermal_cdev_update(cdev); 272 } 273 274 return 0; 275 276 err_pwm_disable: 277 state.enabled = false; 278 pwm_apply_state(ctx->pwm, &state); 279 280 return ret; 281 } 282 283 static int pwm_fan_remove(struct platform_device *pdev) 284 { 285 struct pwm_fan_ctx *ctx = platform_get_drvdata(pdev); 286 287 thermal_cooling_device_unregister(ctx->cdev); 288 if (ctx->pwm_value) 289 pwm_disable(ctx->pwm); 290 return 0; 291 } 292 293 #ifdef CONFIG_PM_SLEEP 294 static int pwm_fan_suspend(struct device *dev) 295 { 296 struct pwm_fan_ctx *ctx = dev_get_drvdata(dev); 297 struct pwm_args args; 298 int ret; 299 300 pwm_get_args(ctx->pwm, &args); 301 302 if (ctx->pwm_value) { 303 ret = pwm_config(ctx->pwm, 0, args.period); 304 if (ret < 0) 305 return ret; 306 307 pwm_disable(ctx->pwm); 308 } 309 310 return 0; 311 } 312 313 static int pwm_fan_resume(struct device *dev) 314 { 315 struct pwm_fan_ctx *ctx = dev_get_drvdata(dev); 316 struct pwm_args pargs; 317 unsigned long duty; 318 int ret; 319 320 if (ctx->pwm_value == 0) 321 return 0; 322 323 pwm_get_args(ctx->pwm, &pargs); 324 duty = DIV_ROUND_UP(ctx->pwm_value * (pargs.period - 1), MAX_PWM); 325 ret = pwm_config(ctx->pwm, duty, pargs.period); 326 if (ret) 327 return ret; 328 return pwm_enable(ctx->pwm); 329 } 330 #endif 331 332 static SIMPLE_DEV_PM_OPS(pwm_fan_pm, pwm_fan_suspend, pwm_fan_resume); 333 334 static const struct of_device_id of_pwm_fan_match[] = { 335 { .compatible = "pwm-fan", }, 336 {}, 337 }; 338 MODULE_DEVICE_TABLE(of, of_pwm_fan_match); 339 340 static struct platform_driver pwm_fan_driver = { 341 .probe = pwm_fan_probe, 342 .remove = pwm_fan_remove, 343 .driver = { 344 .name = "pwm-fan", 345 .pm = &pwm_fan_pm, 346 .of_match_table = of_pwm_fan_match, 347 }, 348 }; 349 350 module_platform_driver(pwm_fan_driver); 351 352 MODULE_AUTHOR("Kamil Debski <k.debski@samsung.com>"); 353 MODULE_ALIAS("platform:pwm-fan"); 354 MODULE_DESCRIPTION("PWM FAN driver"); 355 MODULE_LICENSE("GPL"); 356