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 int ret; 253 254 if (test_and_set_bit(PWMF_EXPORTED, &pwm->flags)) 255 return -EBUSY; 256 257 export = kzalloc(sizeof(*export), GFP_KERNEL); 258 if (!export) { 259 clear_bit(PWMF_EXPORTED, &pwm->flags); 260 return -ENOMEM; 261 } 262 263 export->pwm = pwm; 264 mutex_init(&export->lock); 265 266 export->child.release = pwm_export_release; 267 export->child.parent = parent; 268 export->child.devt = MKDEV(0, 0); 269 export->child.groups = pwm_groups; 270 dev_set_name(&export->child, "pwm%u", pwm->hwpwm); 271 272 ret = device_register(&export->child); 273 if (ret) { 274 clear_bit(PWMF_EXPORTED, &pwm->flags); 275 kfree(export); 276 return ret; 277 } 278 279 return 0; 280 } 281 282 static int pwm_unexport_match(struct device *child, void *data) 283 { 284 return child_to_pwm_device(child) == data; 285 } 286 287 static int pwm_unexport_child(struct device *parent, struct pwm_device *pwm) 288 { 289 struct device *child; 290 291 if (!test_and_clear_bit(PWMF_EXPORTED, &pwm->flags)) 292 return -ENODEV; 293 294 child = device_find_child(parent, pwm, pwm_unexport_match); 295 if (!child) 296 return -ENODEV; 297 298 /* for device_find_child() */ 299 put_device(child); 300 device_unregister(child); 301 pwm_put(pwm); 302 303 return 0; 304 } 305 306 static ssize_t export_store(struct device *parent, 307 struct device_attribute *attr, 308 const char *buf, size_t len) 309 { 310 struct pwm_chip *chip = dev_get_drvdata(parent); 311 struct pwm_device *pwm; 312 unsigned int hwpwm; 313 int ret; 314 315 ret = kstrtouint(buf, 0, &hwpwm); 316 if (ret < 0) 317 return ret; 318 319 if (hwpwm >= chip->npwm) 320 return -ENODEV; 321 322 pwm = pwm_request_from_chip(chip, hwpwm, "sysfs"); 323 if (IS_ERR(pwm)) 324 return PTR_ERR(pwm); 325 326 ret = pwm_export_child(parent, pwm); 327 if (ret < 0) 328 pwm_put(pwm); 329 330 return ret ? : len; 331 } 332 static DEVICE_ATTR_WO(export); 333 334 static ssize_t unexport_store(struct device *parent, 335 struct device_attribute *attr, 336 const char *buf, size_t len) 337 { 338 struct pwm_chip *chip = dev_get_drvdata(parent); 339 unsigned int hwpwm; 340 int ret; 341 342 ret = kstrtouint(buf, 0, &hwpwm); 343 if (ret < 0) 344 return ret; 345 346 if (hwpwm >= chip->npwm) 347 return -ENODEV; 348 349 ret = pwm_unexport_child(parent, &chip->pwms[hwpwm]); 350 351 return ret ? : len; 352 } 353 static DEVICE_ATTR_WO(unexport); 354 355 static ssize_t npwm_show(struct device *parent, struct device_attribute *attr, 356 char *buf) 357 { 358 const struct pwm_chip *chip = dev_get_drvdata(parent); 359 360 return sprintf(buf, "%u\n", chip->npwm); 361 } 362 static DEVICE_ATTR_RO(npwm); 363 364 static struct attribute *pwm_chip_attrs[] = { 365 &dev_attr_export.attr, 366 &dev_attr_unexport.attr, 367 &dev_attr_npwm.attr, 368 NULL, 369 }; 370 ATTRIBUTE_GROUPS(pwm_chip); 371 372 static struct class pwm_class = { 373 .name = "pwm", 374 .owner = THIS_MODULE, 375 .dev_groups = pwm_chip_groups, 376 }; 377 378 static int pwmchip_sysfs_match(struct device *parent, const void *data) 379 { 380 return dev_get_drvdata(parent) == data; 381 } 382 383 void pwmchip_sysfs_export(struct pwm_chip *chip) 384 { 385 struct device *parent; 386 387 /* 388 * If device_create() fails the pwm_chip is still usable by 389 * the kernel its just not exported. 390 */ 391 parent = device_create(&pwm_class, chip->dev, MKDEV(0, 0), chip, 392 "pwmchip%d", chip->base); 393 if (IS_ERR(parent)) { 394 dev_warn(chip->dev, 395 "device_create failed for pwm_chip sysfs export\n"); 396 } 397 } 398 399 void pwmchip_sysfs_unexport(struct pwm_chip *chip) 400 { 401 struct device *parent; 402 403 parent = class_find_device(&pwm_class, NULL, chip, 404 pwmchip_sysfs_match); 405 if (parent) { 406 /* for class_find_device() */ 407 put_device(parent); 408 device_unregister(parent); 409 } 410 } 411 412 void pwmchip_sysfs_unexport_children(struct pwm_chip *chip) 413 { 414 struct device *parent; 415 unsigned int i; 416 417 parent = class_find_device(&pwm_class, NULL, chip, 418 pwmchip_sysfs_match); 419 if (!parent) 420 return; 421 422 for (i = 0; i < chip->npwm; i++) { 423 struct pwm_device *pwm = &chip->pwms[i]; 424 425 if (test_bit(PWMF_EXPORTED, &pwm->flags)) 426 pwm_unexport_child(parent, pwm); 427 } 428 } 429 430 static int __init pwm_sysfs_init(void) 431 { 432 return class_register(&pwm_class); 433 } 434 subsys_initcall(pwm_sysfs_init); 435