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