1 /* 2 * A simple sysfs interface for the generic PWM framework 3 * 4 * Copyright (C) 2013 H Hartley Sweeten <hsweeten@visionengravers.com> 5 * 6 * Based on previous work by Lars Poeschel <poeschel@lemonage.de> 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, or (at your option) 11 * 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/device.h> 20 #include <linux/mutex.h> 21 #include <linux/err.h> 22 #include <linux/slab.h> 23 #include <linux/kdev_t.h> 24 #include <linux/pwm.h> 25 26 struct pwm_export { 27 struct device child; 28 struct pwm_device *pwm; 29 struct mutex lock; 30 }; 31 32 static struct pwm_export *child_to_pwm_export(struct device *child) 33 { 34 return container_of(child, struct pwm_export, child); 35 } 36 37 static struct pwm_device *child_to_pwm_device(struct device *child) 38 { 39 struct pwm_export *export = child_to_pwm_export(child); 40 41 return export->pwm; 42 } 43 44 static ssize_t period_show(struct device *child, 45 struct device_attribute *attr, 46 char *buf) 47 { 48 const struct pwm_device *pwm = child_to_pwm_device(child); 49 struct pwm_state state; 50 51 pwm_get_state(pwm, &state); 52 53 return sprintf(buf, "%u\n", state.period); 54 } 55 56 static ssize_t period_store(struct device *child, 57 struct device_attribute *attr, 58 const char *buf, size_t size) 59 { 60 struct pwm_export *export = child_to_pwm_export(child); 61 struct pwm_device *pwm = export->pwm; 62 struct pwm_state state; 63 unsigned int val; 64 int ret; 65 66 ret = kstrtouint(buf, 0, &val); 67 if (ret) 68 return ret; 69 70 mutex_lock(&export->lock); 71 pwm_get_state(pwm, &state); 72 state.period = val; 73 ret = pwm_apply_state(pwm, &state); 74 mutex_unlock(&export->lock); 75 76 return ret ? : size; 77 } 78 79 static ssize_t duty_cycle_show(struct device *child, 80 struct device_attribute *attr, 81 char *buf) 82 { 83 const struct pwm_device *pwm = child_to_pwm_device(child); 84 struct pwm_state state; 85 86 pwm_get_state(pwm, &state); 87 88 return sprintf(buf, "%u\n", state.duty_cycle); 89 } 90 91 static ssize_t duty_cycle_store(struct device *child, 92 struct device_attribute *attr, 93 const char *buf, size_t size) 94 { 95 struct pwm_export *export = child_to_pwm_export(child); 96 struct pwm_device *pwm = export->pwm; 97 struct pwm_state state; 98 unsigned int val; 99 int ret; 100 101 ret = kstrtouint(buf, 0, &val); 102 if (ret) 103 return ret; 104 105 mutex_lock(&export->lock); 106 pwm_get_state(pwm, &state); 107 state.duty_cycle = val; 108 ret = pwm_apply_state(pwm, &state); 109 mutex_unlock(&export->lock); 110 111 return ret ? : size; 112 } 113 114 static ssize_t enable_show(struct device *child, 115 struct device_attribute *attr, 116 char *buf) 117 { 118 const struct pwm_device *pwm = child_to_pwm_device(child); 119 struct pwm_state state; 120 121 pwm_get_state(pwm, &state); 122 123 return sprintf(buf, "%d\n", state.enabled); 124 } 125 126 static ssize_t enable_store(struct device *child, 127 struct device_attribute *attr, 128 const char *buf, size_t size) 129 { 130 struct pwm_export *export = child_to_pwm_export(child); 131 struct pwm_device *pwm = export->pwm; 132 struct pwm_state state; 133 int val, ret; 134 135 ret = kstrtoint(buf, 0, &val); 136 if (ret) 137 return ret; 138 139 mutex_lock(&export->lock); 140 141 pwm_get_state(pwm, &state); 142 143 switch (val) { 144 case 0: 145 state.enabled = false; 146 break; 147 case 1: 148 state.enabled = true; 149 break; 150 default: 151 ret = -EINVAL; 152 goto unlock; 153 } 154 155 pwm_apply_state(pwm, &state); 156 157 unlock: 158 mutex_unlock(&export->lock); 159 return ret ? : size; 160 } 161 162 static ssize_t polarity_show(struct device *child, 163 struct device_attribute *attr, 164 char *buf) 165 { 166 const struct pwm_device *pwm = child_to_pwm_device(child); 167 const char *polarity = "unknown"; 168 struct pwm_state state; 169 170 pwm_get_state(pwm, &state); 171 172 switch (state.polarity) { 173 case PWM_POLARITY_NORMAL: 174 polarity = "normal"; 175 break; 176 177 case PWM_POLARITY_INVERSED: 178 polarity = "inversed"; 179 break; 180 } 181 182 return sprintf(buf, "%s\n", polarity); 183 } 184 185 static ssize_t polarity_store(struct device *child, 186 struct device_attribute *attr, 187 const char *buf, size_t size) 188 { 189 struct pwm_export *export = child_to_pwm_export(child); 190 struct pwm_device *pwm = export->pwm; 191 enum pwm_polarity polarity; 192 struct pwm_state state; 193 int ret; 194 195 if (sysfs_streq(buf, "normal")) 196 polarity = PWM_POLARITY_NORMAL; 197 else if (sysfs_streq(buf, "inversed")) 198 polarity = PWM_POLARITY_INVERSED; 199 else 200 return -EINVAL; 201 202 mutex_lock(&export->lock); 203 pwm_get_state(pwm, &state); 204 state.polarity = polarity; 205 ret = pwm_apply_state(pwm, &state); 206 mutex_unlock(&export->lock); 207 208 return ret ? : size; 209 } 210 211 static DEVICE_ATTR_RW(period); 212 static DEVICE_ATTR_RW(duty_cycle); 213 static DEVICE_ATTR_RW(enable); 214 static DEVICE_ATTR_RW(polarity); 215 216 static struct attribute *pwm_attrs[] = { 217 &dev_attr_period.attr, 218 &dev_attr_duty_cycle.attr, 219 &dev_attr_enable.attr, 220 &dev_attr_polarity.attr, 221 NULL 222 }; 223 ATTRIBUTE_GROUPS(pwm); 224 225 static void pwm_export_release(struct device *child) 226 { 227 struct pwm_export *export = child_to_pwm_export(child); 228 229 kfree(export); 230 } 231 232 static int pwm_export_child(struct device *parent, struct pwm_device *pwm) 233 { 234 struct pwm_export *export; 235 int ret; 236 237 if (test_and_set_bit(PWMF_EXPORTED, &pwm->flags)) 238 return -EBUSY; 239 240 export = kzalloc(sizeof(*export), GFP_KERNEL); 241 if (!export) { 242 clear_bit(PWMF_EXPORTED, &pwm->flags); 243 return -ENOMEM; 244 } 245 246 export->pwm = pwm; 247 mutex_init(&export->lock); 248 249 export->child.release = pwm_export_release; 250 export->child.parent = parent; 251 export->child.devt = MKDEV(0, 0); 252 export->child.groups = pwm_groups; 253 dev_set_name(&export->child, "pwm%u", pwm->hwpwm); 254 255 ret = device_register(&export->child); 256 if (ret) { 257 clear_bit(PWMF_EXPORTED, &pwm->flags); 258 kfree(export); 259 return ret; 260 } 261 262 return 0; 263 } 264 265 static int pwm_unexport_match(struct device *child, void *data) 266 { 267 return child_to_pwm_device(child) == data; 268 } 269 270 static int pwm_unexport_child(struct device *parent, struct pwm_device *pwm) 271 { 272 struct device *child; 273 274 if (!test_and_clear_bit(PWMF_EXPORTED, &pwm->flags)) 275 return -ENODEV; 276 277 child = device_find_child(parent, pwm, pwm_unexport_match); 278 if (!child) 279 return -ENODEV; 280 281 /* for device_find_child() */ 282 put_device(child); 283 device_unregister(child); 284 pwm_put(pwm); 285 286 return 0; 287 } 288 289 static ssize_t export_store(struct device *parent, 290 struct device_attribute *attr, 291 const char *buf, size_t len) 292 { 293 struct pwm_chip *chip = dev_get_drvdata(parent); 294 struct pwm_device *pwm; 295 unsigned int hwpwm; 296 int ret; 297 298 ret = kstrtouint(buf, 0, &hwpwm); 299 if (ret < 0) 300 return ret; 301 302 if (hwpwm >= chip->npwm) 303 return -ENODEV; 304 305 pwm = pwm_request_from_chip(chip, hwpwm, "sysfs"); 306 if (IS_ERR(pwm)) 307 return PTR_ERR(pwm); 308 309 ret = pwm_export_child(parent, pwm); 310 if (ret < 0) 311 pwm_put(pwm); 312 313 return ret ? : len; 314 } 315 static DEVICE_ATTR_WO(export); 316 317 static ssize_t unexport_store(struct device *parent, 318 struct device_attribute *attr, 319 const char *buf, size_t len) 320 { 321 struct pwm_chip *chip = dev_get_drvdata(parent); 322 unsigned int hwpwm; 323 int ret; 324 325 ret = kstrtouint(buf, 0, &hwpwm); 326 if (ret < 0) 327 return ret; 328 329 if (hwpwm >= chip->npwm) 330 return -ENODEV; 331 332 ret = pwm_unexport_child(parent, &chip->pwms[hwpwm]); 333 334 return ret ? : len; 335 } 336 static DEVICE_ATTR_WO(unexport); 337 338 static ssize_t npwm_show(struct device *parent, struct device_attribute *attr, 339 char *buf) 340 { 341 const struct pwm_chip *chip = dev_get_drvdata(parent); 342 343 return sprintf(buf, "%u\n", chip->npwm); 344 } 345 static DEVICE_ATTR_RO(npwm); 346 347 static struct attribute *pwm_chip_attrs[] = { 348 &dev_attr_export.attr, 349 &dev_attr_unexport.attr, 350 &dev_attr_npwm.attr, 351 NULL, 352 }; 353 ATTRIBUTE_GROUPS(pwm_chip); 354 355 static struct class pwm_class = { 356 .name = "pwm", 357 .owner = THIS_MODULE, 358 .dev_groups = pwm_chip_groups, 359 }; 360 361 static int pwmchip_sysfs_match(struct device *parent, const void *data) 362 { 363 return dev_get_drvdata(parent) == data; 364 } 365 366 void pwmchip_sysfs_export(struct pwm_chip *chip) 367 { 368 struct device *parent; 369 370 /* 371 * If device_create() fails the pwm_chip is still usable by 372 * the kernel its just not exported. 373 */ 374 parent = device_create(&pwm_class, chip->dev, MKDEV(0, 0), chip, 375 "pwmchip%d", chip->base); 376 if (IS_ERR(parent)) { 377 dev_warn(chip->dev, 378 "device_create failed for pwm_chip sysfs export\n"); 379 } 380 } 381 382 void pwmchip_sysfs_unexport(struct pwm_chip *chip) 383 { 384 struct device *parent; 385 386 parent = class_find_device(&pwm_class, NULL, chip, 387 pwmchip_sysfs_match); 388 if (parent) { 389 /* for class_find_device() */ 390 put_device(parent); 391 device_unregister(parent); 392 } 393 } 394 395 static int __init pwm_sysfs_init(void) 396 { 397 return class_register(&pwm_class); 398 } 399 subsys_initcall(pwm_sysfs_init); 400