1 /* 2 * Generic pwmlib implementation 3 * 4 * Copyright (C) 2011 Sascha Hauer <s.hauer@pengutronix.de> 5 * Copyright (C) 2011-2012 Avionic Design GmbH 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2, or (at your option) 10 * any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; see the file COPYING. If not, write to 19 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 20 */ 21 22 #include <linux/module.h> 23 #include <linux/pwm.h> 24 #include <linux/radix-tree.h> 25 #include <linux/list.h> 26 #include <linux/mutex.h> 27 #include <linux/err.h> 28 #include <linux/slab.h> 29 #include <linux/device.h> 30 #include <linux/debugfs.h> 31 #include <linux/seq_file.h> 32 33 #define MAX_PWMS 1024 34 35 /* flags in the third cell of the DT PWM specifier */ 36 #define PWM_SPEC_POLARITY (1 << 0) 37 38 static DEFINE_MUTEX(pwm_lookup_lock); 39 static LIST_HEAD(pwm_lookup_list); 40 static DEFINE_MUTEX(pwm_lock); 41 static LIST_HEAD(pwm_chips); 42 static DECLARE_BITMAP(allocated_pwms, MAX_PWMS); 43 static RADIX_TREE(pwm_tree, GFP_KERNEL); 44 45 static struct pwm_device *pwm_to_device(unsigned int pwm) 46 { 47 return radix_tree_lookup(&pwm_tree, pwm); 48 } 49 50 static int alloc_pwms(int pwm, unsigned int count) 51 { 52 unsigned int from = 0; 53 unsigned int start; 54 55 if (pwm >= MAX_PWMS) 56 return -EINVAL; 57 58 if (pwm >= 0) 59 from = pwm; 60 61 start = bitmap_find_next_zero_area(allocated_pwms, MAX_PWMS, from, 62 count, 0); 63 64 if (pwm >= 0 && start != pwm) 65 return -EEXIST; 66 67 if (start + count > MAX_PWMS) 68 return -ENOSPC; 69 70 return start; 71 } 72 73 static void free_pwms(struct pwm_chip *chip) 74 { 75 unsigned int i; 76 77 for (i = 0; i < chip->npwm; i++) { 78 struct pwm_device *pwm = &chip->pwms[i]; 79 radix_tree_delete(&pwm_tree, pwm->pwm); 80 } 81 82 bitmap_clear(allocated_pwms, chip->base, chip->npwm); 83 84 kfree(chip->pwms); 85 chip->pwms = NULL; 86 } 87 88 static struct pwm_chip *pwmchip_find_by_name(const char *name) 89 { 90 struct pwm_chip *chip; 91 92 if (!name) 93 return NULL; 94 95 mutex_lock(&pwm_lock); 96 97 list_for_each_entry(chip, &pwm_chips, list) { 98 const char *chip_name = dev_name(chip->dev); 99 100 if (chip_name && strcmp(chip_name, name) == 0) { 101 mutex_unlock(&pwm_lock); 102 return chip; 103 } 104 } 105 106 mutex_unlock(&pwm_lock); 107 108 return NULL; 109 } 110 111 static int pwm_device_request(struct pwm_device *pwm, const char *label) 112 { 113 int err; 114 115 if (test_bit(PWMF_REQUESTED, &pwm->flags)) 116 return -EBUSY; 117 118 if (!try_module_get(pwm->chip->ops->owner)) 119 return -ENODEV; 120 121 if (pwm->chip->ops->request) { 122 err = pwm->chip->ops->request(pwm->chip, pwm); 123 if (err) { 124 module_put(pwm->chip->ops->owner); 125 return err; 126 } 127 } 128 129 set_bit(PWMF_REQUESTED, &pwm->flags); 130 pwm->label = label; 131 132 return 0; 133 } 134 135 struct pwm_device * 136 of_pwm_xlate_with_flags(struct pwm_chip *pc, const struct of_phandle_args *args) 137 { 138 struct pwm_device *pwm; 139 140 if (pc->of_pwm_n_cells < 3) 141 return ERR_PTR(-EINVAL); 142 143 if (args->args[0] >= pc->npwm) 144 return ERR_PTR(-EINVAL); 145 146 pwm = pwm_request_from_chip(pc, args->args[0], NULL); 147 if (IS_ERR(pwm)) 148 return pwm; 149 150 pwm_set_period(pwm, args->args[1]); 151 152 if (args->args[2] & PWM_SPEC_POLARITY) 153 pwm_set_polarity(pwm, PWM_POLARITY_INVERSED); 154 else 155 pwm_set_polarity(pwm, PWM_POLARITY_NORMAL); 156 157 return pwm; 158 } 159 EXPORT_SYMBOL_GPL(of_pwm_xlate_with_flags); 160 161 static struct pwm_device * 162 of_pwm_simple_xlate(struct pwm_chip *pc, const struct of_phandle_args *args) 163 { 164 struct pwm_device *pwm; 165 166 if (pc->of_pwm_n_cells < 2) 167 return ERR_PTR(-EINVAL); 168 169 if (args->args[0] >= pc->npwm) 170 return ERR_PTR(-EINVAL); 171 172 pwm = pwm_request_from_chip(pc, args->args[0], NULL); 173 if (IS_ERR(pwm)) 174 return pwm; 175 176 pwm_set_period(pwm, args->args[1]); 177 178 return pwm; 179 } 180 181 static void of_pwmchip_add(struct pwm_chip *chip) 182 { 183 if (!chip->dev || !chip->dev->of_node) 184 return; 185 186 if (!chip->of_xlate) { 187 chip->of_xlate = of_pwm_simple_xlate; 188 chip->of_pwm_n_cells = 2; 189 } 190 191 of_node_get(chip->dev->of_node); 192 } 193 194 static void of_pwmchip_remove(struct pwm_chip *chip) 195 { 196 if (chip->dev && chip->dev->of_node) 197 of_node_put(chip->dev->of_node); 198 } 199 200 /** 201 * pwm_set_chip_data() - set private chip data for a PWM 202 * @pwm: PWM device 203 * @data: pointer to chip-specific data 204 */ 205 int pwm_set_chip_data(struct pwm_device *pwm, void *data) 206 { 207 if (!pwm) 208 return -EINVAL; 209 210 pwm->chip_data = data; 211 212 return 0; 213 } 214 EXPORT_SYMBOL_GPL(pwm_set_chip_data); 215 216 /** 217 * pwm_get_chip_data() - get private chip data for a PWM 218 * @pwm: PWM device 219 */ 220 void *pwm_get_chip_data(struct pwm_device *pwm) 221 { 222 return pwm ? pwm->chip_data : NULL; 223 } 224 EXPORT_SYMBOL_GPL(pwm_get_chip_data); 225 226 /** 227 * pwmchip_add() - register a new PWM chip 228 * @chip: the PWM chip to add 229 * 230 * Register a new PWM chip. If chip->base < 0 then a dynamically assigned base 231 * will be used. 232 */ 233 int pwmchip_add(struct pwm_chip *chip) 234 { 235 struct pwm_device *pwm; 236 unsigned int i; 237 int ret; 238 239 if (!chip || !chip->dev || !chip->ops || !chip->ops->config || 240 !chip->ops->enable || !chip->ops->disable) 241 return -EINVAL; 242 243 mutex_lock(&pwm_lock); 244 245 ret = alloc_pwms(chip->base, chip->npwm); 246 if (ret < 0) 247 goto out; 248 249 chip->pwms = kzalloc(chip->npwm * sizeof(*pwm), GFP_KERNEL); 250 if (!chip->pwms) { 251 ret = -ENOMEM; 252 goto out; 253 } 254 255 chip->base = ret; 256 257 for (i = 0; i < chip->npwm; i++) { 258 pwm = &chip->pwms[i]; 259 260 pwm->chip = chip; 261 pwm->pwm = chip->base + i; 262 pwm->hwpwm = i; 263 264 radix_tree_insert(&pwm_tree, pwm->pwm, pwm); 265 } 266 267 bitmap_set(allocated_pwms, chip->base, chip->npwm); 268 269 INIT_LIST_HEAD(&chip->list); 270 list_add(&chip->list, &pwm_chips); 271 272 ret = 0; 273 274 if (IS_ENABLED(CONFIG_OF)) 275 of_pwmchip_add(chip); 276 277 pwmchip_sysfs_export(chip); 278 279 out: 280 mutex_unlock(&pwm_lock); 281 return ret; 282 } 283 EXPORT_SYMBOL_GPL(pwmchip_add); 284 285 /** 286 * pwmchip_remove() - remove a PWM chip 287 * @chip: the PWM chip to remove 288 * 289 * Removes a PWM chip. This function may return busy if the PWM chip provides 290 * a PWM device that is still requested. 291 */ 292 int pwmchip_remove(struct pwm_chip *chip) 293 { 294 unsigned int i; 295 int ret = 0; 296 297 mutex_lock(&pwm_lock); 298 299 for (i = 0; i < chip->npwm; i++) { 300 struct pwm_device *pwm = &chip->pwms[i]; 301 302 if (test_bit(PWMF_REQUESTED, &pwm->flags)) { 303 ret = -EBUSY; 304 goto out; 305 } 306 } 307 308 list_del_init(&chip->list); 309 310 if (IS_ENABLED(CONFIG_OF)) 311 of_pwmchip_remove(chip); 312 313 free_pwms(chip); 314 315 pwmchip_sysfs_unexport(chip); 316 317 out: 318 mutex_unlock(&pwm_lock); 319 return ret; 320 } 321 EXPORT_SYMBOL_GPL(pwmchip_remove); 322 323 /** 324 * pwm_request() - request a PWM device 325 * @pwm_id: global PWM device index 326 * @label: PWM device label 327 * 328 * This function is deprecated, use pwm_get() instead. 329 */ 330 struct pwm_device *pwm_request(int pwm, const char *label) 331 { 332 struct pwm_device *dev; 333 int err; 334 335 if (pwm < 0 || pwm >= MAX_PWMS) 336 return ERR_PTR(-EINVAL); 337 338 mutex_lock(&pwm_lock); 339 340 dev = pwm_to_device(pwm); 341 if (!dev) { 342 dev = ERR_PTR(-EPROBE_DEFER); 343 goto out; 344 } 345 346 err = pwm_device_request(dev, label); 347 if (err < 0) 348 dev = ERR_PTR(err); 349 350 out: 351 mutex_unlock(&pwm_lock); 352 353 return dev; 354 } 355 EXPORT_SYMBOL_GPL(pwm_request); 356 357 /** 358 * pwm_request_from_chip() - request a PWM device relative to a PWM chip 359 * @chip: PWM chip 360 * @index: per-chip index of the PWM to request 361 * @label: a literal description string of this PWM 362 * 363 * Returns the PWM at the given index of the given PWM chip. A negative error 364 * code is returned if the index is not valid for the specified PWM chip or 365 * if the PWM device cannot be requested. 366 */ 367 struct pwm_device *pwm_request_from_chip(struct pwm_chip *chip, 368 unsigned int index, 369 const char *label) 370 { 371 struct pwm_device *pwm; 372 int err; 373 374 if (!chip || index >= chip->npwm) 375 return ERR_PTR(-EINVAL); 376 377 mutex_lock(&pwm_lock); 378 pwm = &chip->pwms[index]; 379 380 err = pwm_device_request(pwm, label); 381 if (err < 0) 382 pwm = ERR_PTR(err); 383 384 mutex_unlock(&pwm_lock); 385 return pwm; 386 } 387 EXPORT_SYMBOL_GPL(pwm_request_from_chip); 388 389 /** 390 * pwm_free() - free a PWM device 391 * @pwm: PWM device 392 * 393 * This function is deprecated, use pwm_put() instead. 394 */ 395 void pwm_free(struct pwm_device *pwm) 396 { 397 pwm_put(pwm); 398 } 399 EXPORT_SYMBOL_GPL(pwm_free); 400 401 /** 402 * pwm_config() - change a PWM device configuration 403 * @pwm: PWM device 404 * @duty_ns: "on" time (in nanoseconds) 405 * @period_ns: duration (in nanoseconds) of one cycle 406 */ 407 int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns) 408 { 409 int err; 410 411 if (!pwm || duty_ns < 0 || period_ns <= 0 || duty_ns > period_ns) 412 return -EINVAL; 413 414 err = pwm->chip->ops->config(pwm->chip, pwm, duty_ns, period_ns); 415 if (err) 416 return err; 417 418 pwm->duty_cycle = duty_ns; 419 pwm->period = period_ns; 420 421 return 0; 422 } 423 EXPORT_SYMBOL_GPL(pwm_config); 424 425 /** 426 * pwm_set_polarity() - configure the polarity of a PWM signal 427 * @pwm: PWM device 428 * @polarity: new polarity of the PWM signal 429 * 430 * Note that the polarity cannot be configured while the PWM device is enabled 431 */ 432 int pwm_set_polarity(struct pwm_device *pwm, enum pwm_polarity polarity) 433 { 434 int err; 435 436 if (!pwm || !pwm->chip->ops) 437 return -EINVAL; 438 439 if (!pwm->chip->ops->set_polarity) 440 return -ENOSYS; 441 442 if (test_bit(PWMF_ENABLED, &pwm->flags)) 443 return -EBUSY; 444 445 err = pwm->chip->ops->set_polarity(pwm->chip, pwm, polarity); 446 if (err) 447 return err; 448 449 pwm->polarity = polarity; 450 451 return 0; 452 } 453 EXPORT_SYMBOL_GPL(pwm_set_polarity); 454 455 /** 456 * pwm_enable() - start a PWM output toggling 457 * @pwm: PWM device 458 */ 459 int pwm_enable(struct pwm_device *pwm) 460 { 461 if (pwm && !test_and_set_bit(PWMF_ENABLED, &pwm->flags)) 462 return pwm->chip->ops->enable(pwm->chip, pwm); 463 464 return pwm ? 0 : -EINVAL; 465 } 466 EXPORT_SYMBOL_GPL(pwm_enable); 467 468 /** 469 * pwm_disable() - stop a PWM output toggling 470 * @pwm: PWM device 471 */ 472 void pwm_disable(struct pwm_device *pwm) 473 { 474 if (pwm && test_and_clear_bit(PWMF_ENABLED, &pwm->flags)) 475 pwm->chip->ops->disable(pwm->chip, pwm); 476 } 477 EXPORT_SYMBOL_GPL(pwm_disable); 478 479 static struct pwm_chip *of_node_to_pwmchip(struct device_node *np) 480 { 481 struct pwm_chip *chip; 482 483 mutex_lock(&pwm_lock); 484 485 list_for_each_entry(chip, &pwm_chips, list) 486 if (chip->dev && chip->dev->of_node == np) { 487 mutex_unlock(&pwm_lock); 488 return chip; 489 } 490 491 mutex_unlock(&pwm_lock); 492 493 return ERR_PTR(-EPROBE_DEFER); 494 } 495 496 /** 497 * of_pwm_get() - request a PWM via the PWM framework 498 * @np: device node to get the PWM from 499 * @con_id: consumer name 500 * 501 * Returns the PWM device parsed from the phandle and index specified in the 502 * "pwms" property of a device tree node or a negative error-code on failure. 503 * Values parsed from the device tree are stored in the returned PWM device 504 * object. 505 * 506 * If con_id is NULL, the first PWM device listed in the "pwms" property will 507 * be requested. Otherwise the "pwm-names" property is used to do a reverse 508 * lookup of the PWM index. This also means that the "pwm-names" property 509 * becomes mandatory for devices that look up the PWM device via the con_id 510 * parameter. 511 */ 512 struct pwm_device *of_pwm_get(struct device_node *np, const char *con_id) 513 { 514 struct pwm_device *pwm = NULL; 515 struct of_phandle_args args; 516 struct pwm_chip *pc; 517 int index = 0; 518 int err; 519 520 if (con_id) { 521 index = of_property_match_string(np, "pwm-names", con_id); 522 if (index < 0) 523 return ERR_PTR(index); 524 } 525 526 err = of_parse_phandle_with_args(np, "pwms", "#pwm-cells", index, 527 &args); 528 if (err) { 529 pr_debug("%s(): can't parse \"pwms\" property\n", __func__); 530 return ERR_PTR(err); 531 } 532 533 pc = of_node_to_pwmchip(args.np); 534 if (IS_ERR(pc)) { 535 pr_debug("%s(): PWM chip not found\n", __func__); 536 pwm = ERR_CAST(pc); 537 goto put; 538 } 539 540 if (args.args_count != pc->of_pwm_n_cells) { 541 pr_debug("%s: wrong #pwm-cells for %s\n", np->full_name, 542 args.np->full_name); 543 pwm = ERR_PTR(-EINVAL); 544 goto put; 545 } 546 547 pwm = pc->of_xlate(pc, &args); 548 if (IS_ERR(pwm)) 549 goto put; 550 551 /* 552 * If a consumer name was not given, try to look it up from the 553 * "pwm-names" property if it exists. Otherwise use the name of 554 * the user device node. 555 */ 556 if (!con_id) { 557 err = of_property_read_string_index(np, "pwm-names", index, 558 &con_id); 559 if (err < 0) 560 con_id = np->name; 561 } 562 563 pwm->label = con_id; 564 565 put: 566 of_node_put(args.np); 567 568 return pwm; 569 } 570 EXPORT_SYMBOL_GPL(of_pwm_get); 571 572 /** 573 * pwm_add_table() - register PWM device consumers 574 * @table: array of consumers to register 575 * @num: number of consumers in table 576 */ 577 void __init pwm_add_table(struct pwm_lookup *table, size_t num) 578 { 579 mutex_lock(&pwm_lookup_lock); 580 581 while (num--) { 582 list_add_tail(&table->list, &pwm_lookup_list); 583 table++; 584 } 585 586 mutex_unlock(&pwm_lookup_lock); 587 } 588 589 /** 590 * pwm_get() - look up and request a PWM device 591 * @dev: device for PWM consumer 592 * @con_id: consumer name 593 * 594 * Lookup is first attempted using DT. If the device was not instantiated from 595 * a device tree, a PWM chip and a relative index is looked up via a table 596 * supplied by board setup code (see pwm_add_table()). 597 * 598 * Once a PWM chip has been found the specified PWM device will be requested 599 * and is ready to be used. 600 */ 601 struct pwm_device *pwm_get(struct device *dev, const char *con_id) 602 { 603 struct pwm_device *pwm = ERR_PTR(-EPROBE_DEFER); 604 const char *dev_id = dev ? dev_name(dev) : NULL; 605 struct pwm_chip *chip = NULL; 606 unsigned int index = 0; 607 unsigned int best = 0; 608 struct pwm_lookup *p; 609 unsigned int match; 610 611 /* look up via DT first */ 612 if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node) 613 return of_pwm_get(dev->of_node, con_id); 614 615 /* 616 * We look up the provider in the static table typically provided by 617 * board setup code. We first try to lookup the consumer device by 618 * name. If the consumer device was passed in as NULL or if no match 619 * was found, we try to find the consumer by directly looking it up 620 * by name. 621 * 622 * If a match is found, the provider PWM chip is looked up by name 623 * and a PWM device is requested using the PWM device per-chip index. 624 * 625 * The lookup algorithm was shamelessly taken from the clock 626 * framework: 627 * 628 * We do slightly fuzzy matching here: 629 * An entry with a NULL ID is assumed to be a wildcard. 630 * If an entry has a device ID, it must match 631 * If an entry has a connection ID, it must match 632 * Then we take the most specific entry - with the following order 633 * of precedence: dev+con > dev only > con only. 634 */ 635 mutex_lock(&pwm_lookup_lock); 636 637 list_for_each_entry(p, &pwm_lookup_list, list) { 638 match = 0; 639 640 if (p->dev_id) { 641 if (!dev_id || strcmp(p->dev_id, dev_id)) 642 continue; 643 644 match += 2; 645 } 646 647 if (p->con_id) { 648 if (!con_id || strcmp(p->con_id, con_id)) 649 continue; 650 651 match += 1; 652 } 653 654 if (match > best) { 655 chip = pwmchip_find_by_name(p->provider); 656 index = p->index; 657 658 if (match != 3) 659 best = match; 660 else 661 break; 662 } 663 } 664 665 if (chip) 666 pwm = pwm_request_from_chip(chip, index, con_id ?: dev_id); 667 668 mutex_unlock(&pwm_lookup_lock); 669 670 return pwm; 671 } 672 EXPORT_SYMBOL_GPL(pwm_get); 673 674 /** 675 * pwm_put() - release a PWM device 676 * @pwm: PWM device 677 */ 678 void pwm_put(struct pwm_device *pwm) 679 { 680 if (!pwm) 681 return; 682 683 mutex_lock(&pwm_lock); 684 685 if (!test_and_clear_bit(PWMF_REQUESTED, &pwm->flags)) { 686 pr_warn("PWM device already freed\n"); 687 goto out; 688 } 689 690 if (pwm->chip->ops->free) 691 pwm->chip->ops->free(pwm->chip, pwm); 692 693 pwm->label = NULL; 694 695 module_put(pwm->chip->ops->owner); 696 out: 697 mutex_unlock(&pwm_lock); 698 } 699 EXPORT_SYMBOL_GPL(pwm_put); 700 701 static void devm_pwm_release(struct device *dev, void *res) 702 { 703 pwm_put(*(struct pwm_device **)res); 704 } 705 706 /** 707 * devm_pwm_get() - resource managed pwm_get() 708 * @dev: device for PWM consumer 709 * @con_id: consumer name 710 * 711 * This function performs like pwm_get() but the acquired PWM device will 712 * automatically be released on driver detach. 713 */ 714 struct pwm_device *devm_pwm_get(struct device *dev, const char *con_id) 715 { 716 struct pwm_device **ptr, *pwm; 717 718 ptr = devres_alloc(devm_pwm_release, sizeof(*ptr), GFP_KERNEL); 719 if (!ptr) 720 return ERR_PTR(-ENOMEM); 721 722 pwm = pwm_get(dev, con_id); 723 if (!IS_ERR(pwm)) { 724 *ptr = pwm; 725 devres_add(dev, ptr); 726 } else { 727 devres_free(ptr); 728 } 729 730 return pwm; 731 } 732 EXPORT_SYMBOL_GPL(devm_pwm_get); 733 734 /** 735 * devm_of_pwm_get() - resource managed of_pwm_get() 736 * @dev: device for PWM consumer 737 * @np: device node to get the PWM from 738 * @con_id: consumer name 739 * 740 * This function performs like of_pwm_get() but the acquired PWM device will 741 * automatically be released on driver detach. 742 */ 743 struct pwm_device *devm_of_pwm_get(struct device *dev, struct device_node *np, 744 const char *con_id) 745 { 746 struct pwm_device **ptr, *pwm; 747 748 ptr = devres_alloc(devm_pwm_release, sizeof(*ptr), GFP_KERNEL); 749 if (!ptr) 750 return ERR_PTR(-ENOMEM); 751 752 pwm = of_pwm_get(np, con_id); 753 if (!IS_ERR(pwm)) { 754 *ptr = pwm; 755 devres_add(dev, ptr); 756 } else { 757 devres_free(ptr); 758 } 759 760 return pwm; 761 } 762 EXPORT_SYMBOL_GPL(devm_of_pwm_get); 763 764 static int devm_pwm_match(struct device *dev, void *res, void *data) 765 { 766 struct pwm_device **p = res; 767 768 if (WARN_ON(!p || !*p)) 769 return 0; 770 771 return *p == data; 772 } 773 774 /** 775 * devm_pwm_put() - resource managed pwm_put() 776 * @dev: device for PWM consumer 777 * @pwm: PWM device 778 * 779 * Release a PWM previously allocated using devm_pwm_get(). Calling this 780 * function is usually not needed because devm-allocated resources are 781 * automatically released on driver detach. 782 */ 783 void devm_pwm_put(struct device *dev, struct pwm_device *pwm) 784 { 785 WARN_ON(devres_release(dev, devm_pwm_release, devm_pwm_match, pwm)); 786 } 787 EXPORT_SYMBOL_GPL(devm_pwm_put); 788 789 /** 790 * pwm_can_sleep() - report whether PWM access will sleep 791 * @pwm: PWM device 792 * 793 * It returns true if accessing the PWM can sleep, false otherwise. 794 */ 795 bool pwm_can_sleep(struct pwm_device *pwm) 796 { 797 return pwm->chip->can_sleep; 798 } 799 EXPORT_SYMBOL_GPL(pwm_can_sleep); 800 801 #ifdef CONFIG_DEBUG_FS 802 static void pwm_dbg_show(struct pwm_chip *chip, struct seq_file *s) 803 { 804 unsigned int i; 805 806 for (i = 0; i < chip->npwm; i++) { 807 struct pwm_device *pwm = &chip->pwms[i]; 808 809 seq_printf(s, " pwm-%-3d (%-20.20s):", i, pwm->label); 810 811 if (test_bit(PWMF_REQUESTED, &pwm->flags)) 812 seq_printf(s, " requested"); 813 814 if (test_bit(PWMF_ENABLED, &pwm->flags)) 815 seq_printf(s, " enabled"); 816 817 seq_printf(s, "\n"); 818 } 819 } 820 821 static void *pwm_seq_start(struct seq_file *s, loff_t *pos) 822 { 823 mutex_lock(&pwm_lock); 824 s->private = ""; 825 826 return seq_list_start(&pwm_chips, *pos); 827 } 828 829 static void *pwm_seq_next(struct seq_file *s, void *v, loff_t *pos) 830 { 831 s->private = "\n"; 832 833 return seq_list_next(v, &pwm_chips, pos); 834 } 835 836 static void pwm_seq_stop(struct seq_file *s, void *v) 837 { 838 mutex_unlock(&pwm_lock); 839 } 840 841 static int pwm_seq_show(struct seq_file *s, void *v) 842 { 843 struct pwm_chip *chip = list_entry(v, struct pwm_chip, list); 844 845 seq_printf(s, "%s%s/%s, %d PWM device%s\n", (char *)s->private, 846 chip->dev->bus ? chip->dev->bus->name : "no-bus", 847 dev_name(chip->dev), chip->npwm, 848 (chip->npwm != 1) ? "s" : ""); 849 850 if (chip->ops->dbg_show) 851 chip->ops->dbg_show(chip, s); 852 else 853 pwm_dbg_show(chip, s); 854 855 return 0; 856 } 857 858 static const struct seq_operations pwm_seq_ops = { 859 .start = pwm_seq_start, 860 .next = pwm_seq_next, 861 .stop = pwm_seq_stop, 862 .show = pwm_seq_show, 863 }; 864 865 static int pwm_seq_open(struct inode *inode, struct file *file) 866 { 867 return seq_open(file, &pwm_seq_ops); 868 } 869 870 static const struct file_operations pwm_debugfs_ops = { 871 .owner = THIS_MODULE, 872 .open = pwm_seq_open, 873 .read = seq_read, 874 .llseek = seq_lseek, 875 .release = seq_release, 876 }; 877 878 static int __init pwm_debugfs_init(void) 879 { 880 debugfs_create_file("pwm", S_IFREG | S_IRUGO, NULL, NULL, 881 &pwm_debugfs_ops); 882 883 return 0; 884 } 885 886 subsys_initcall(pwm_debugfs_init); 887 #endif /* CONFIG_DEBUG_FS */ 888