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 37static DEFINE_MUTEX(pwm_lookup_lock); 38static LIST_HEAD(pwm_lookup_list); 39static DEFINE_MUTEX(pwm_lock); 40static LIST_HEAD(pwm_chips); 41static DECLARE_BITMAP(allocated_pwms, MAX_PWMS); 42static RADIX_TREE(pwm_tree, GFP_KERNEL); 43 44static struct pwm_device *pwm_to_device(unsigned int pwm) 45{ 46 return radix_tree_lookup(&pwm_tree, pwm); 47} 48 49static 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 72static 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 87static 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 110static 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 134struct pwm_device * 135of_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} 158EXPORT_SYMBOL_GPL(of_pwm_xlate_with_flags); 159 160static struct pwm_device * 161of_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 180static 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 193static 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 */ 204int 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} 213EXPORT_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 */ 219void *pwm_get_chip_data(struct pwm_device *pwm) 220{ 221 return pwm ? pwm->chip_data : NULL; 222} 223EXPORT_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 */ 232int 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 || !chip->npwm) 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 278out: 279 mutex_unlock(&pwm_lock); 280 return ret; 281} 282EXPORT_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 */ 291int 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 316out: 317 mutex_unlock(&pwm_lock); 318 return ret; 319} 320EXPORT_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 */ 329struct 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 349out: 350 mutex_unlock(&pwm_lock); 351 352 return dev; 353} 354EXPORT_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 */ 366struct 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} 386EXPORT_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 */ 394void pwm_free(struct pwm_device *pwm) 395{ 396 pwm_put(pwm); 397} 398EXPORT_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 */ 406int 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} 422EXPORT_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 */ 431int 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} 452EXPORT_SYMBOL_GPL(pwm_set_polarity); 453 454/** 455 * pwm_enable() - start a PWM output toggling 456 * @pwm: PWM device 457 */ 458int 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} 465EXPORT_SYMBOL_GPL(pwm_enable); 466 467/** 468 * pwm_disable() - stop a PWM output toggling 469 * @pwm: PWM device 470 */ 471void 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} 476EXPORT_SYMBOL_GPL(pwm_disable); 477 478static 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 */ 511struct 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 564put: 565 of_node_put(args.np); 566 567 return pwm; 568} 569EXPORT_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 */ 576void __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 */ 600struct 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 best = 0; 606 struct pwm_lookup *p, *chosen = NULL; 607 unsigned int match; 608 609 /* look up via DT first */ 610 if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node) 611 return of_pwm_get(dev->of_node, con_id); 612 613 /* 614 * We look up the provider in the static table typically provided by 615 * board setup code. We first try to lookup the consumer device by 616 * name. If the consumer device was passed in as NULL or if no match 617 * was found, we try to find the consumer by directly looking it up 618 * by name. 619 * 620 * If a match is found, the provider PWM chip is looked up by name 621 * and a PWM device is requested using the PWM device per-chip index. 622 * 623 * The lookup algorithm was shamelessly taken from the clock 624 * framework: 625 * 626 * We do slightly fuzzy matching here: 627 * An entry with a NULL ID is assumed to be a wildcard. 628 * If an entry has a device ID, it must match 629 * If an entry has a connection ID, it must match 630 * Then we take the most specific entry - with the following order 631 * of precedence: dev+con > dev only > con only. 632 */ 633 mutex_lock(&pwm_lookup_lock); 634 635 list_for_each_entry(p, &pwm_lookup_list, list) { 636 match = 0; 637 638 if (p->dev_id) { 639 if (!dev_id || strcmp(p->dev_id, dev_id)) 640 continue; 641 642 match += 2; 643 } 644 645 if (p->con_id) { 646 if (!con_id || strcmp(p->con_id, con_id)) 647 continue; 648 649 match += 1; 650 } 651 652 if (match > best) { 653 chosen = p; 654 655 if (match != 3) 656 best = match; 657 else 658 break; 659 } 660 } 661 662 if (!chosen) 663 goto out; 664 665 chip = pwmchip_find_by_name(chosen->provider); 666 if (!chip) 667 goto out; 668 669 pwm = pwm_request_from_chip(chip, chosen->index, con_id ?: dev_id); 670 if (IS_ERR(pwm)) 671 goto out; 672 673 pwm_set_period(pwm, chosen->period); 674 pwm_set_polarity(pwm, chosen->polarity); 675 676out: 677 mutex_unlock(&pwm_lookup_lock); 678 return pwm; 679} 680EXPORT_SYMBOL_GPL(pwm_get); 681 682/** 683 * pwm_put() - release a PWM device 684 * @pwm: PWM device 685 */ 686void pwm_put(struct pwm_device *pwm) 687{ 688 if (!pwm) 689 return; 690 691 mutex_lock(&pwm_lock); 692 693 if (!test_and_clear_bit(PWMF_REQUESTED, &pwm->flags)) { 694 pr_warn("PWM device already freed\n"); 695 goto out; 696 } 697 698 if (pwm->chip->ops->free) 699 pwm->chip->ops->free(pwm->chip, pwm); 700 701 pwm->label = NULL; 702 703 module_put(pwm->chip->ops->owner); 704out: 705 mutex_unlock(&pwm_lock); 706} 707EXPORT_SYMBOL_GPL(pwm_put); 708 709static void devm_pwm_release(struct device *dev, void *res) 710{ 711 pwm_put(*(struct pwm_device **)res); 712} 713 714/** 715 * devm_pwm_get() - resource managed pwm_get() 716 * @dev: device for PWM consumer 717 * @con_id: consumer name 718 * 719 * This function performs like pwm_get() but the acquired PWM device will 720 * automatically be released on driver detach. 721 */ 722struct pwm_device *devm_pwm_get(struct device *dev, const char *con_id) 723{ 724 struct pwm_device **ptr, *pwm; 725 726 ptr = devres_alloc(devm_pwm_release, sizeof(*ptr), GFP_KERNEL); 727 if (!ptr) 728 return ERR_PTR(-ENOMEM); 729 730 pwm = pwm_get(dev, con_id); 731 if (!IS_ERR(pwm)) { 732 *ptr = pwm; 733 devres_add(dev, ptr); 734 } else { 735 devres_free(ptr); 736 } 737 738 return pwm; 739} 740EXPORT_SYMBOL_GPL(devm_pwm_get); 741 742/** 743 * devm_of_pwm_get() - resource managed of_pwm_get() 744 * @dev: device for PWM consumer 745 * @np: device node to get the PWM from 746 * @con_id: consumer name 747 * 748 * This function performs like of_pwm_get() but the acquired PWM device will 749 * automatically be released on driver detach. 750 */ 751struct pwm_device *devm_of_pwm_get(struct device *dev, struct device_node *np, 752 const char *con_id) 753{ 754 struct pwm_device **ptr, *pwm; 755 756 ptr = devres_alloc(devm_pwm_release, sizeof(*ptr), GFP_KERNEL); 757 if (!ptr) 758 return ERR_PTR(-ENOMEM); 759 760 pwm = of_pwm_get(np, con_id); 761 if (!IS_ERR(pwm)) { 762 *ptr = pwm; 763 devres_add(dev, ptr); 764 } else { 765 devres_free(ptr); 766 } 767 768 return pwm; 769} 770EXPORT_SYMBOL_GPL(devm_of_pwm_get); 771 772static int devm_pwm_match(struct device *dev, void *res, void *data) 773{ 774 struct pwm_device **p = res; 775 776 if (WARN_ON(!p || !*p)) 777 return 0; 778 779 return *p == data; 780} 781 782/** 783 * devm_pwm_put() - resource managed pwm_put() 784 * @dev: device for PWM consumer 785 * @pwm: PWM device 786 * 787 * Release a PWM previously allocated using devm_pwm_get(). Calling this 788 * function is usually not needed because devm-allocated resources are 789 * automatically released on driver detach. 790 */ 791void devm_pwm_put(struct device *dev, struct pwm_device *pwm) 792{ 793 WARN_ON(devres_release(dev, devm_pwm_release, devm_pwm_match, pwm)); 794} 795EXPORT_SYMBOL_GPL(devm_pwm_put); 796 797/** 798 * pwm_can_sleep() - report whether PWM access will sleep 799 * @pwm: PWM device 800 * 801 * It returns true if accessing the PWM can sleep, false otherwise. 802 */ 803bool pwm_can_sleep(struct pwm_device *pwm) 804{ 805 return pwm->chip->can_sleep; 806} 807EXPORT_SYMBOL_GPL(pwm_can_sleep); 808 809#ifdef CONFIG_DEBUG_FS 810static void pwm_dbg_show(struct pwm_chip *chip, struct seq_file *s) 811{ 812 unsigned int i; 813 814 for (i = 0; i < chip->npwm; i++) { 815 struct pwm_device *pwm = &chip->pwms[i]; 816 817 seq_printf(s, " pwm-%-3d (%-20.20s):", i, pwm->label); 818 819 if (test_bit(PWMF_REQUESTED, &pwm->flags)) 820 seq_puts(s, " requested"); 821 822 if (test_bit(PWMF_ENABLED, &pwm->flags)) 823 seq_puts(s, " enabled"); 824 825 seq_puts(s, "\n"); 826 } 827} 828 829static void *pwm_seq_start(struct seq_file *s, loff_t *pos) 830{ 831 mutex_lock(&pwm_lock); 832 s->private = ""; 833 834 return seq_list_start(&pwm_chips, *pos); 835} 836 837static void *pwm_seq_next(struct seq_file *s, void *v, loff_t *pos) 838{ 839 s->private = "\n"; 840 841 return seq_list_next(v, &pwm_chips, pos); 842} 843 844static void pwm_seq_stop(struct seq_file *s, void *v) 845{ 846 mutex_unlock(&pwm_lock); 847} 848 849static int pwm_seq_show(struct seq_file *s, void *v) 850{ 851 struct pwm_chip *chip = list_entry(v, struct pwm_chip, list); 852 853 seq_printf(s, "%s%s/%s, %d PWM device%s\n", (char *)s->private, 854 chip->dev->bus ? chip->dev->bus->name : "no-bus", 855 dev_name(chip->dev), chip->npwm, 856 (chip->npwm != 1) ? "s" : ""); 857 858 if (chip->ops->dbg_show) 859 chip->ops->dbg_show(chip, s); 860 else 861 pwm_dbg_show(chip, s); 862 863 return 0; 864} 865 866static const struct seq_operations pwm_seq_ops = { 867 .start = pwm_seq_start, 868 .next = pwm_seq_next, 869 .stop = pwm_seq_stop, 870 .show = pwm_seq_show, 871}; 872 873static int pwm_seq_open(struct inode *inode, struct file *file) 874{ 875 return seq_open(file, &pwm_seq_ops); 876} 877 878static const struct file_operations pwm_debugfs_ops = { 879 .owner = THIS_MODULE, 880 .open = pwm_seq_open, 881 .read = seq_read, 882 .llseek = seq_lseek, 883 .release = seq_release, 884}; 885 886static int __init pwm_debugfs_init(void) 887{ 888 debugfs_create_file("pwm", S_IFREG | S_IRUGO, NULL, NULL, 889 &pwm_debugfs_ops); 890 891 return 0; 892} 893 894subsys_initcall(pwm_debugfs_init); 895#endif /* CONFIG_DEBUG_FS */ 896