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 ret = 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 ssize_t capture_show(struct device *child, 212 struct device_attribute *attr, 213 char *buf) 214 { 215 struct pwm_device *pwm = child_to_pwm_device(child); 216 struct pwm_capture result; 217 int ret; 218 219 ret = pwm_capture(pwm, &result, jiffies_to_msecs(HZ)); 220 if (ret) 221 return ret; 222 223 return sprintf(buf, "%u %u\n", result.period, result.duty_cycle); 224 } 225 226 static DEVICE_ATTR_RW(period); 227 static DEVICE_ATTR_RW(duty_cycle); 228 static DEVICE_ATTR_RW(enable); 229 static DEVICE_ATTR_RW(polarity); 230 static DEVICE_ATTR_RO(capture); 231 232 static struct attribute *pwm_attrs[] = { 233 &dev_attr_period.attr, 234 &dev_attr_duty_cycle.attr, 235 &dev_attr_enable.attr, 236 &dev_attr_polarity.attr, 237 &dev_attr_capture.attr, 238 NULL 239 }; 240 ATTRIBUTE_GROUPS(pwm); 241 242 static void pwm_export_release(struct device *child) 243 { 244 struct pwm_export *export = child_to_pwm_export(child); 245 246 kfree(export); 247 } 248 249 static int pwm_export_child(struct device *parent, struct pwm_device *pwm) 250 { 251 struct pwm_export *export; 252 char *pwm_prop[2]; 253 int ret; 254 255 if (test_and_set_bit(PWMF_EXPORTED, &pwm->flags)) 256 return -EBUSY; 257 258 export = kzalloc(sizeof(*export), GFP_KERNEL); 259 if (!export) { 260 clear_bit(PWMF_EXPORTED, &pwm->flags); 261 return -ENOMEM; 262 } 263 264 export->pwm = pwm; 265 mutex_init(&export->lock); 266 267 export->child.release = pwm_export_release; 268 export->child.parent = parent; 269 export->child.devt = MKDEV(0, 0); 270 export->child.groups = pwm_groups; 271 dev_set_name(&export->child, "pwm%u", pwm->hwpwm); 272 273 ret = device_register(&export->child); 274 if (ret) { 275 clear_bit(PWMF_EXPORTED, &pwm->flags); 276 put_device(&export->child); 277 export = NULL; 278 return ret; 279 } 280 pwm_prop[0] = kasprintf(GFP_KERNEL, "EXPORT=pwm%u", pwm->hwpwm); 281 pwm_prop[1] = NULL; 282 kobject_uevent_env(&parent->kobj, KOBJ_CHANGE, pwm_prop); 283 kfree(pwm_prop[0]); 284 285 return 0; 286 } 287 288 static int pwm_unexport_match(struct device *child, void *data) 289 { 290 return child_to_pwm_device(child) == data; 291 } 292 293 static int pwm_unexport_child(struct device *parent, struct pwm_device *pwm) 294 { 295 struct device *child; 296 char *pwm_prop[2]; 297 298 if (!test_and_clear_bit(PWMF_EXPORTED, &pwm->flags)) 299 return -ENODEV; 300 301 child = device_find_child(parent, pwm, pwm_unexport_match); 302 if (!child) 303 return -ENODEV; 304 305 pwm_prop[0] = kasprintf(GFP_KERNEL, "UNEXPORT=pwm%u", pwm->hwpwm); 306 pwm_prop[1] = NULL; 307 kobject_uevent_env(&parent->kobj, KOBJ_CHANGE, pwm_prop); 308 kfree(pwm_prop[0]); 309 310 /* for device_find_child() */ 311 put_device(child); 312 device_unregister(child); 313 pwm_put(pwm); 314 315 return 0; 316 } 317 318 static ssize_t export_store(struct device *parent, 319 struct device_attribute *attr, 320 const char *buf, size_t len) 321 { 322 struct pwm_chip *chip = dev_get_drvdata(parent); 323 struct pwm_device *pwm; 324 unsigned int hwpwm; 325 int ret; 326 327 ret = kstrtouint(buf, 0, &hwpwm); 328 if (ret < 0) 329 return ret; 330 331 if (hwpwm >= chip->npwm) 332 return -ENODEV; 333 334 pwm = pwm_request_from_chip(chip, hwpwm, "sysfs"); 335 if (IS_ERR(pwm)) 336 return PTR_ERR(pwm); 337 338 ret = pwm_export_child(parent, pwm); 339 if (ret < 0) 340 pwm_put(pwm); 341 342 return ret ? : len; 343 } 344 static DEVICE_ATTR_WO(export); 345 346 static ssize_t unexport_store(struct device *parent, 347 struct device_attribute *attr, 348 const char *buf, size_t len) 349 { 350 struct pwm_chip *chip = dev_get_drvdata(parent); 351 unsigned int hwpwm; 352 int ret; 353 354 ret = kstrtouint(buf, 0, &hwpwm); 355 if (ret < 0) 356 return ret; 357 358 if (hwpwm >= chip->npwm) 359 return -ENODEV; 360 361 ret = pwm_unexport_child(parent, &chip->pwms[hwpwm]); 362 363 return ret ? : len; 364 } 365 static DEVICE_ATTR_WO(unexport); 366 367 static ssize_t npwm_show(struct device *parent, struct device_attribute *attr, 368 char *buf) 369 { 370 const struct pwm_chip *chip = dev_get_drvdata(parent); 371 372 return sprintf(buf, "%u\n", chip->npwm); 373 } 374 static DEVICE_ATTR_RO(npwm); 375 376 static struct attribute *pwm_chip_attrs[] = { 377 &dev_attr_export.attr, 378 &dev_attr_unexport.attr, 379 &dev_attr_npwm.attr, 380 NULL, 381 }; 382 ATTRIBUTE_GROUPS(pwm_chip); 383 384 static struct class pwm_class = { 385 .name = "pwm", 386 .owner = THIS_MODULE, 387 .dev_groups = pwm_chip_groups, 388 }; 389 390 static int pwmchip_sysfs_match(struct device *parent, const void *data) 391 { 392 return dev_get_drvdata(parent) == data; 393 } 394 395 void pwmchip_sysfs_export(struct pwm_chip *chip) 396 { 397 struct device *parent; 398 399 /* 400 * If device_create() fails the pwm_chip is still usable by 401 * the kernel its just not exported. 402 */ 403 parent = device_create(&pwm_class, chip->dev, MKDEV(0, 0), chip, 404 "pwmchip%d", chip->base); 405 if (IS_ERR(parent)) { 406 dev_warn(chip->dev, 407 "device_create failed for pwm_chip sysfs export\n"); 408 } 409 } 410 411 void pwmchip_sysfs_unexport(struct pwm_chip *chip) 412 { 413 struct device *parent; 414 415 parent = class_find_device(&pwm_class, NULL, chip, 416 pwmchip_sysfs_match); 417 if (parent) { 418 /* for class_find_device() */ 419 put_device(parent); 420 device_unregister(parent); 421 } 422 } 423 424 void pwmchip_sysfs_unexport_children(struct pwm_chip *chip) 425 { 426 struct device *parent; 427 unsigned int i; 428 429 parent = class_find_device(&pwm_class, NULL, chip, 430 pwmchip_sysfs_match); 431 if (!parent) 432 return; 433 434 for (i = 0; i < chip->npwm; i++) { 435 struct pwm_device *pwm = &chip->pwms[i]; 436 437 if (test_bit(PWMF_EXPORTED, &pwm->flags)) 438 pwm_unexport_child(parent, pwm); 439 } 440 441 put_device(parent); 442 } 443 444 static int __init pwm_sysfs_init(void) 445 { 446 return class_register(&pwm_class); 447 } 448 subsys_initcall(pwm_sysfs_init); 449