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