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 duty; 44 int ret = 0; 45 46 mutex_lock(&ctx->lock); 47 if (ctx->pwm_value == pwm) 48 goto exit_set_pwm_err; 49 50 duty = DIV_ROUND_UP(pwm * (ctx->pwm->period - 1), MAX_PWM); 51 ret = pwm_config(ctx->pwm, duty, ctx->pwm->period); 52 if (ret) 53 goto exit_set_pwm_err; 54 55 if (pwm == 0) 56 pwm_disable(ctx->pwm); 57 58 if (ctx->pwm_value == 0) { 59 ret = pwm_enable(ctx->pwm); 60 if (ret) 61 goto exit_set_pwm_err; 62 } 63 64 ctx->pwm_value = pwm; 65 exit_set_pwm_err: 66 mutex_unlock(&ctx->lock); 67 return ret; 68 } 69 70 static void pwm_fan_update_state(struct pwm_fan_ctx *ctx, unsigned long pwm) 71 { 72 int i; 73 74 for (i = 0; i < ctx->pwm_fan_max_state; ++i) 75 if (pwm < ctx->pwm_fan_cooling_levels[i + 1]) 76 break; 77 78 ctx->pwm_fan_state = i; 79 } 80 81 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr, 82 const char *buf, size_t count) 83 { 84 struct pwm_fan_ctx *ctx = dev_get_drvdata(dev); 85 unsigned long pwm; 86 int ret; 87 88 if (kstrtoul(buf, 10, &pwm) || pwm > MAX_PWM) 89 return -EINVAL; 90 91 ret = __set_pwm(ctx, pwm); 92 if (ret) 93 return ret; 94 95 pwm_fan_update_state(ctx, pwm); 96 return count; 97 } 98 99 static ssize_t show_pwm(struct device *dev, 100 struct device_attribute *attr, char *buf) 101 { 102 struct pwm_fan_ctx *ctx = dev_get_drvdata(dev); 103 104 return sprintf(buf, "%u\n", ctx->pwm_value); 105 } 106 107 108 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 0); 109 110 static struct attribute *pwm_fan_attrs[] = { 111 &sensor_dev_attr_pwm1.dev_attr.attr, 112 NULL, 113 }; 114 115 ATTRIBUTE_GROUPS(pwm_fan); 116 117 /* thermal cooling device callbacks */ 118 static int pwm_fan_get_max_state(struct thermal_cooling_device *cdev, 119 unsigned long *state) 120 { 121 struct pwm_fan_ctx *ctx = cdev->devdata; 122 123 if (!ctx) 124 return -EINVAL; 125 126 *state = ctx->pwm_fan_max_state; 127 128 return 0; 129 } 130 131 static int pwm_fan_get_cur_state(struct thermal_cooling_device *cdev, 132 unsigned long *state) 133 { 134 struct pwm_fan_ctx *ctx = cdev->devdata; 135 136 if (!ctx) 137 return -EINVAL; 138 139 *state = ctx->pwm_fan_state; 140 141 return 0; 142 } 143 144 static int 145 pwm_fan_set_cur_state(struct thermal_cooling_device *cdev, unsigned long state) 146 { 147 struct pwm_fan_ctx *ctx = cdev->devdata; 148 int ret; 149 150 if (!ctx || (state > ctx->pwm_fan_max_state)) 151 return -EINVAL; 152 153 if (state == ctx->pwm_fan_state) 154 return 0; 155 156 ret = __set_pwm(ctx, ctx->pwm_fan_cooling_levels[state]); 157 if (ret) { 158 dev_err(&cdev->device, "Cannot set pwm!\n"); 159 return ret; 160 } 161 162 ctx->pwm_fan_state = state; 163 164 return ret; 165 } 166 167 static const struct thermal_cooling_device_ops pwm_fan_cooling_ops = { 168 .get_max_state = pwm_fan_get_max_state, 169 .get_cur_state = pwm_fan_get_cur_state, 170 .set_cur_state = pwm_fan_set_cur_state, 171 }; 172 173 static int pwm_fan_of_get_cooling_data(struct device *dev, 174 struct pwm_fan_ctx *ctx) 175 { 176 struct device_node *np = dev->of_node; 177 int num, i, ret; 178 179 if (!of_find_property(np, "cooling-levels", NULL)) 180 return 0; 181 182 ret = of_property_count_u32_elems(np, "cooling-levels"); 183 if (ret <= 0) { 184 dev_err(dev, "Wrong data!\n"); 185 return ret ? : -EINVAL; 186 } 187 188 num = ret; 189 ctx->pwm_fan_cooling_levels = devm_kzalloc(dev, num * sizeof(u32), 190 GFP_KERNEL); 191 if (!ctx->pwm_fan_cooling_levels) 192 return -ENOMEM; 193 194 ret = of_property_read_u32_array(np, "cooling-levels", 195 ctx->pwm_fan_cooling_levels, num); 196 if (ret) { 197 dev_err(dev, "Property 'cooling-levels' cannot be read!\n"); 198 return ret; 199 } 200 201 for (i = 0; i < num; i++) { 202 if (ctx->pwm_fan_cooling_levels[i] > MAX_PWM) { 203 dev_err(dev, "PWM fan state[%d]:%d > %d\n", i, 204 ctx->pwm_fan_cooling_levels[i], MAX_PWM); 205 return -EINVAL; 206 } 207 } 208 209 ctx->pwm_fan_max_state = num - 1; 210 211 return 0; 212 } 213 214 static int pwm_fan_probe(struct platform_device *pdev) 215 { 216 struct thermal_cooling_device *cdev; 217 struct pwm_fan_ctx *ctx; 218 struct device *hwmon; 219 int duty_cycle; 220 int ret; 221 222 ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL); 223 if (!ctx) 224 return -ENOMEM; 225 226 mutex_init(&ctx->lock); 227 228 ctx->pwm = devm_of_pwm_get(&pdev->dev, pdev->dev.of_node, NULL); 229 if (IS_ERR(ctx->pwm)) { 230 dev_err(&pdev->dev, "Could not get PWM\n"); 231 return PTR_ERR(ctx->pwm); 232 } 233 234 platform_set_drvdata(pdev, ctx); 235 236 /* Set duty cycle to maximum allowed */ 237 duty_cycle = ctx->pwm->period - 1; 238 ctx->pwm_value = MAX_PWM; 239 240 ret = pwm_config(ctx->pwm, duty_cycle, ctx->pwm->period); 241 if (ret) { 242 dev_err(&pdev->dev, "Failed to configure PWM\n"); 243 return ret; 244 } 245 246 /* Enbale PWM output */ 247 ret = pwm_enable(ctx->pwm); 248 if (ret) { 249 dev_err(&pdev->dev, "Failed to enable PWM\n"); 250 return ret; 251 } 252 253 hwmon = devm_hwmon_device_register_with_groups(&pdev->dev, "pwmfan", 254 ctx, pwm_fan_groups); 255 if (IS_ERR(hwmon)) { 256 dev_err(&pdev->dev, "Failed to register hwmon device\n"); 257 pwm_disable(ctx->pwm); 258 return PTR_ERR(hwmon); 259 } 260 261 ret = pwm_fan_of_get_cooling_data(&pdev->dev, ctx); 262 if (ret) 263 return ret; 264 265 ctx->pwm_fan_state = ctx->pwm_fan_max_state; 266 if (IS_ENABLED(CONFIG_THERMAL)) { 267 cdev = thermal_of_cooling_device_register(pdev->dev.of_node, 268 "pwm-fan", ctx, 269 &pwm_fan_cooling_ops); 270 if (IS_ERR(cdev)) { 271 dev_err(&pdev->dev, 272 "Failed to register pwm-fan as cooling device"); 273 pwm_disable(ctx->pwm); 274 return PTR_ERR(cdev); 275 } 276 ctx->cdev = cdev; 277 thermal_cdev_update(cdev); 278 } 279 280 return 0; 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 298 if (ctx->pwm_value) 299 pwm_disable(ctx->pwm); 300 return 0; 301 } 302 303 static int pwm_fan_resume(struct device *dev) 304 { 305 struct pwm_fan_ctx *ctx = dev_get_drvdata(dev); 306 unsigned long duty; 307 int ret; 308 309 if (ctx->pwm_value == 0) 310 return 0; 311 312 duty = DIV_ROUND_UP(ctx->pwm_value * (ctx->pwm->period - 1), MAX_PWM); 313 ret = pwm_config(ctx->pwm, duty, ctx->pwm->period); 314 if (ret) 315 return ret; 316 return pwm_enable(ctx->pwm); 317 } 318 #endif 319 320 static SIMPLE_DEV_PM_OPS(pwm_fan_pm, pwm_fan_suspend, pwm_fan_resume); 321 322 static const struct of_device_id of_pwm_fan_match[] = { 323 { .compatible = "pwm-fan", }, 324 {}, 325 }; 326 MODULE_DEVICE_TABLE(of, of_pwm_fan_match); 327 328 static struct platform_driver pwm_fan_driver = { 329 .probe = pwm_fan_probe, 330 .remove = pwm_fan_remove, 331 .driver = { 332 .name = "pwm-fan", 333 .pm = &pwm_fan_pm, 334 .of_match_table = of_pwm_fan_match, 335 }, 336 }; 337 338 module_platform_driver(pwm_fan_driver); 339 340 MODULE_AUTHOR("Kamil Debski <k.debski@samsung.com>"); 341 MODULE_ALIAS("platform:pwm-fan"); 342 MODULE_DESCRIPTION("PWM FAN driver"); 343 MODULE_LICENSE("GPL"); 344