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