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) 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 * Returns: 0 on success or a negative error code on failure. 205 */ 206 int pwm_set_chip_data(struct pwm_device *pwm, void *data) 207 { 208 if (!pwm) 209 return -EINVAL; 210 211 pwm->chip_data = data; 212 213 return 0; 214 } 215 EXPORT_SYMBOL_GPL(pwm_set_chip_data); 216 217 /** 218 * pwm_get_chip_data() - get private chip data for a PWM 219 * @pwm: PWM device 220 * 221 * Returns: A pointer to the chip-private data for the PWM device. 222 */ 223 void *pwm_get_chip_data(struct pwm_device *pwm) 224 { 225 return pwm ? pwm->chip_data : NULL; 226 } 227 EXPORT_SYMBOL_GPL(pwm_get_chip_data); 228 229 /** 230 * pwmchip_add_with_polarity() - register a new PWM chip 231 * @chip: the PWM chip to add 232 * @polarity: initial polarity of PWM channels 233 * 234 * Register a new PWM chip. If chip->base < 0 then a dynamically assigned base 235 * will be used. The initial polarity for all channels is specified by the 236 * @polarity parameter. 237 * 238 * Returns: 0 on success or a negative error code on failure. 239 */ 240 int pwmchip_add_with_polarity(struct pwm_chip *chip, 241 enum pwm_polarity polarity) 242 { 243 struct pwm_device *pwm; 244 unsigned int i; 245 int ret; 246 247 if (!chip || !chip->dev || !chip->ops || !chip->ops->config || 248 !chip->ops->enable || !chip->ops->disable || !chip->npwm) 249 return -EINVAL; 250 251 mutex_lock(&pwm_lock); 252 253 ret = alloc_pwms(chip->base, chip->npwm); 254 if (ret < 0) 255 goto out; 256 257 chip->pwms = kzalloc(chip->npwm * sizeof(*pwm), GFP_KERNEL); 258 if (!chip->pwms) { 259 ret = -ENOMEM; 260 goto out; 261 } 262 263 chip->base = ret; 264 265 for (i = 0; i < chip->npwm; i++) { 266 pwm = &chip->pwms[i]; 267 268 pwm->chip = chip; 269 pwm->pwm = chip->base + i; 270 pwm->hwpwm = i; 271 pwm->polarity = polarity; 272 273 radix_tree_insert(&pwm_tree, pwm->pwm, pwm); 274 } 275 276 bitmap_set(allocated_pwms, chip->base, chip->npwm); 277 278 INIT_LIST_HEAD(&chip->list); 279 list_add(&chip->list, &pwm_chips); 280 281 ret = 0; 282 283 if (IS_ENABLED(CONFIG_OF)) 284 of_pwmchip_add(chip); 285 286 pwmchip_sysfs_export(chip); 287 288 out: 289 mutex_unlock(&pwm_lock); 290 return ret; 291 } 292 EXPORT_SYMBOL_GPL(pwmchip_add_with_polarity); 293 294 /** 295 * pwmchip_add() - register a new PWM chip 296 * @chip: the PWM chip to add 297 * 298 * Register a new PWM chip. If chip->base < 0 then a dynamically assigned base 299 * will be used. The initial polarity for all channels is normal. 300 * 301 * Returns: 0 on success or a negative error code on failure. 302 */ 303 int pwmchip_add(struct pwm_chip *chip) 304 { 305 return pwmchip_add_with_polarity(chip, PWM_POLARITY_NORMAL); 306 } 307 EXPORT_SYMBOL_GPL(pwmchip_add); 308 309 /** 310 * pwmchip_remove() - remove a PWM chip 311 * @chip: the PWM chip to remove 312 * 313 * Removes a PWM chip. This function may return busy if the PWM chip provides 314 * a PWM device that is still requested. 315 * 316 * Returns: 0 on success or a negative error code on failure. 317 */ 318 int pwmchip_remove(struct pwm_chip *chip) 319 { 320 unsigned int i; 321 int ret = 0; 322 323 mutex_lock(&pwm_lock); 324 325 for (i = 0; i < chip->npwm; i++) { 326 struct pwm_device *pwm = &chip->pwms[i]; 327 328 if (test_bit(PWMF_REQUESTED, &pwm->flags)) { 329 ret = -EBUSY; 330 goto out; 331 } 332 } 333 334 list_del_init(&chip->list); 335 336 if (IS_ENABLED(CONFIG_OF)) 337 of_pwmchip_remove(chip); 338 339 free_pwms(chip); 340 341 pwmchip_sysfs_unexport(chip); 342 343 out: 344 mutex_unlock(&pwm_lock); 345 return ret; 346 } 347 EXPORT_SYMBOL_GPL(pwmchip_remove); 348 349 /** 350 * pwm_request() - request a PWM device 351 * @pwm: global PWM device index 352 * @label: PWM device label 353 * 354 * This function is deprecated, use pwm_get() instead. 355 * 356 * Returns: A pointer to a PWM device or an ERR_PTR()-encoded error code on 357 * failure. 358 */ 359 struct pwm_device *pwm_request(int pwm, const char *label) 360 { 361 struct pwm_device *dev; 362 int err; 363 364 if (pwm < 0 || pwm >= MAX_PWMS) 365 return ERR_PTR(-EINVAL); 366 367 mutex_lock(&pwm_lock); 368 369 dev = pwm_to_device(pwm); 370 if (!dev) { 371 dev = ERR_PTR(-EPROBE_DEFER); 372 goto out; 373 } 374 375 err = pwm_device_request(dev, label); 376 if (err < 0) 377 dev = ERR_PTR(err); 378 379 out: 380 mutex_unlock(&pwm_lock); 381 382 return dev; 383 } 384 EXPORT_SYMBOL_GPL(pwm_request); 385 386 /** 387 * pwm_request_from_chip() - request a PWM device relative to a PWM chip 388 * @chip: PWM chip 389 * @index: per-chip index of the PWM to request 390 * @label: a literal description string of this PWM 391 * 392 * Returns: A pointer to the PWM device at the given index of the given PWM 393 * chip. A negative error code is returned if the index is not valid for the 394 * specified PWM chip or if the PWM device cannot be requested. 395 */ 396 struct pwm_device *pwm_request_from_chip(struct pwm_chip *chip, 397 unsigned int index, 398 const char *label) 399 { 400 struct pwm_device *pwm; 401 int err; 402 403 if (!chip || index >= chip->npwm) 404 return ERR_PTR(-EINVAL); 405 406 mutex_lock(&pwm_lock); 407 pwm = &chip->pwms[index]; 408 409 err = pwm_device_request(pwm, label); 410 if (err < 0) 411 pwm = ERR_PTR(err); 412 413 mutex_unlock(&pwm_lock); 414 return pwm; 415 } 416 EXPORT_SYMBOL_GPL(pwm_request_from_chip); 417 418 /** 419 * pwm_free() - free a PWM device 420 * @pwm: PWM device 421 * 422 * This function is deprecated, use pwm_put() instead. 423 */ 424 void pwm_free(struct pwm_device *pwm) 425 { 426 pwm_put(pwm); 427 } 428 EXPORT_SYMBOL_GPL(pwm_free); 429 430 /** 431 * pwm_config() - change a PWM device configuration 432 * @pwm: PWM device 433 * @duty_ns: "on" time (in nanoseconds) 434 * @period_ns: duration (in nanoseconds) of one cycle 435 * 436 * Returns: 0 on success or a negative error code on failure. 437 */ 438 int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns) 439 { 440 int err; 441 442 if (!pwm || duty_ns < 0 || period_ns <= 0 || duty_ns > period_ns) 443 return -EINVAL; 444 445 err = pwm->chip->ops->config(pwm->chip, pwm, duty_ns, period_ns); 446 if (err) 447 return err; 448 449 pwm->duty_cycle = duty_ns; 450 pwm->period = period_ns; 451 452 return 0; 453 } 454 EXPORT_SYMBOL_GPL(pwm_config); 455 456 /** 457 * pwm_set_polarity() - configure the polarity of a PWM signal 458 * @pwm: PWM device 459 * @polarity: new polarity of the PWM signal 460 * 461 * Note that the polarity cannot be configured while the PWM device is 462 * enabled. 463 * 464 * Returns: 0 on success or a negative error code on failure. 465 */ 466 int pwm_set_polarity(struct pwm_device *pwm, enum pwm_polarity polarity) 467 { 468 int err; 469 470 if (!pwm || !pwm->chip->ops) 471 return -EINVAL; 472 473 if (!pwm->chip->ops->set_polarity) 474 return -ENOSYS; 475 476 if (pwm_is_enabled(pwm)) 477 return -EBUSY; 478 479 err = pwm->chip->ops->set_polarity(pwm->chip, pwm, polarity); 480 if (err) 481 return err; 482 483 pwm->polarity = polarity; 484 485 return 0; 486 } 487 EXPORT_SYMBOL_GPL(pwm_set_polarity); 488 489 /** 490 * pwm_enable() - start a PWM output toggling 491 * @pwm: PWM device 492 * 493 * Returns: 0 on success or a negative error code on failure. 494 */ 495 int pwm_enable(struct pwm_device *pwm) 496 { 497 if (pwm && !test_and_set_bit(PWMF_ENABLED, &pwm->flags)) 498 return pwm->chip->ops->enable(pwm->chip, pwm); 499 500 return pwm ? 0 : -EINVAL; 501 } 502 EXPORT_SYMBOL_GPL(pwm_enable); 503 504 /** 505 * pwm_disable() - stop a PWM output toggling 506 * @pwm: PWM device 507 */ 508 void pwm_disable(struct pwm_device *pwm) 509 { 510 if (pwm && test_and_clear_bit(PWMF_ENABLED, &pwm->flags)) 511 pwm->chip->ops->disable(pwm->chip, pwm); 512 } 513 EXPORT_SYMBOL_GPL(pwm_disable); 514 515 static struct pwm_chip *of_node_to_pwmchip(struct device_node *np) 516 { 517 struct pwm_chip *chip; 518 519 mutex_lock(&pwm_lock); 520 521 list_for_each_entry(chip, &pwm_chips, list) 522 if (chip->dev && chip->dev->of_node == np) { 523 mutex_unlock(&pwm_lock); 524 return chip; 525 } 526 527 mutex_unlock(&pwm_lock); 528 529 return ERR_PTR(-EPROBE_DEFER); 530 } 531 532 /** 533 * of_pwm_get() - request a PWM via the PWM framework 534 * @np: device node to get the PWM from 535 * @con_id: consumer name 536 * 537 * Returns the PWM device parsed from the phandle and index specified in the 538 * "pwms" property of a device tree node or a negative error-code on failure. 539 * Values parsed from the device tree are stored in the returned PWM device 540 * object. 541 * 542 * If con_id is NULL, the first PWM device listed in the "pwms" property will 543 * be requested. Otherwise the "pwm-names" property is used to do a reverse 544 * lookup of the PWM index. This also means that the "pwm-names" property 545 * becomes mandatory for devices that look up the PWM device via the con_id 546 * parameter. 547 * 548 * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded 549 * error code on failure. 550 */ 551 struct pwm_device *of_pwm_get(struct device_node *np, const char *con_id) 552 { 553 struct pwm_device *pwm = NULL; 554 struct of_phandle_args args; 555 struct pwm_chip *pc; 556 int index = 0; 557 int err; 558 559 if (con_id) { 560 index = of_property_match_string(np, "pwm-names", con_id); 561 if (index < 0) 562 return ERR_PTR(index); 563 } 564 565 err = of_parse_phandle_with_args(np, "pwms", "#pwm-cells", index, 566 &args); 567 if (err) { 568 pr_debug("%s(): can't parse \"pwms\" property\n", __func__); 569 return ERR_PTR(err); 570 } 571 572 pc = of_node_to_pwmchip(args.np); 573 if (IS_ERR(pc)) { 574 pr_debug("%s(): PWM chip not found\n", __func__); 575 pwm = ERR_CAST(pc); 576 goto put; 577 } 578 579 if (args.args_count != pc->of_pwm_n_cells) { 580 pr_debug("%s: wrong #pwm-cells for %s\n", np->full_name, 581 args.np->full_name); 582 pwm = ERR_PTR(-EINVAL); 583 goto put; 584 } 585 586 pwm = pc->of_xlate(pc, &args); 587 if (IS_ERR(pwm)) 588 goto put; 589 590 /* 591 * If a consumer name was not given, try to look it up from the 592 * "pwm-names" property if it exists. Otherwise use the name of 593 * the user device node. 594 */ 595 if (!con_id) { 596 err = of_property_read_string_index(np, "pwm-names", index, 597 &con_id); 598 if (err < 0) 599 con_id = np->name; 600 } 601 602 pwm->label = con_id; 603 604 put: 605 of_node_put(args.np); 606 607 return pwm; 608 } 609 EXPORT_SYMBOL_GPL(of_pwm_get); 610 611 /** 612 * pwm_add_table() - register PWM device consumers 613 * @table: array of consumers to register 614 * @num: number of consumers in table 615 */ 616 void pwm_add_table(struct pwm_lookup *table, size_t num) 617 { 618 mutex_lock(&pwm_lookup_lock); 619 620 while (num--) { 621 list_add_tail(&table->list, &pwm_lookup_list); 622 table++; 623 } 624 625 mutex_unlock(&pwm_lookup_lock); 626 } 627 628 /** 629 * pwm_remove_table() - unregister PWM device consumers 630 * @table: array of consumers to unregister 631 * @num: number of consumers in table 632 */ 633 void pwm_remove_table(struct pwm_lookup *table, size_t num) 634 { 635 mutex_lock(&pwm_lookup_lock); 636 637 while (num--) { 638 list_del(&table->list); 639 table++; 640 } 641 642 mutex_unlock(&pwm_lookup_lock); 643 } 644 645 /** 646 * pwm_get() - look up and request a PWM device 647 * @dev: device for PWM consumer 648 * @con_id: consumer name 649 * 650 * Lookup is first attempted using DT. If the device was not instantiated from 651 * a device tree, a PWM chip and a relative index is looked up via a table 652 * supplied by board setup code (see pwm_add_table()). 653 * 654 * Once a PWM chip has been found the specified PWM device will be requested 655 * and is ready to be used. 656 * 657 * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded 658 * error code on failure. 659 */ 660 struct pwm_device *pwm_get(struct device *dev, const char *con_id) 661 { 662 struct pwm_device *pwm = ERR_PTR(-EPROBE_DEFER); 663 const char *dev_id = dev ? dev_name(dev) : NULL; 664 struct pwm_chip *chip = NULL; 665 unsigned int best = 0; 666 struct pwm_lookup *p, *chosen = NULL; 667 unsigned int match; 668 669 /* look up via DT first */ 670 if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node) 671 return of_pwm_get(dev->of_node, con_id); 672 673 /* 674 * We look up the provider in the static table typically provided by 675 * board setup code. We first try to lookup the consumer device by 676 * name. If the consumer device was passed in as NULL or if no match 677 * was found, we try to find the consumer by directly looking it up 678 * by name. 679 * 680 * If a match is found, the provider PWM chip is looked up by name 681 * and a PWM device is requested using the PWM device per-chip index. 682 * 683 * The lookup algorithm was shamelessly taken from the clock 684 * framework: 685 * 686 * We do slightly fuzzy matching here: 687 * An entry with a NULL ID is assumed to be a wildcard. 688 * If an entry has a device ID, it must match 689 * If an entry has a connection ID, it must match 690 * Then we take the most specific entry - with the following order 691 * of precedence: dev+con > dev only > con only. 692 */ 693 mutex_lock(&pwm_lookup_lock); 694 695 list_for_each_entry(p, &pwm_lookup_list, list) { 696 match = 0; 697 698 if (p->dev_id) { 699 if (!dev_id || strcmp(p->dev_id, dev_id)) 700 continue; 701 702 match += 2; 703 } 704 705 if (p->con_id) { 706 if (!con_id || strcmp(p->con_id, con_id)) 707 continue; 708 709 match += 1; 710 } 711 712 if (match > best) { 713 chosen = p; 714 715 if (match != 3) 716 best = match; 717 else 718 break; 719 } 720 } 721 722 if (!chosen) 723 goto out; 724 725 chip = pwmchip_find_by_name(chosen->provider); 726 if (!chip) 727 goto out; 728 729 pwm = pwm_request_from_chip(chip, chosen->index, con_id ?: dev_id); 730 if (IS_ERR(pwm)) 731 goto out; 732 733 pwm_set_period(pwm, chosen->period); 734 pwm_set_polarity(pwm, chosen->polarity); 735 736 out: 737 mutex_unlock(&pwm_lookup_lock); 738 return pwm; 739 } 740 EXPORT_SYMBOL_GPL(pwm_get); 741 742 /** 743 * pwm_put() - release a PWM device 744 * @pwm: PWM device 745 */ 746 void pwm_put(struct pwm_device *pwm) 747 { 748 if (!pwm) 749 return; 750 751 mutex_lock(&pwm_lock); 752 753 if (!test_and_clear_bit(PWMF_REQUESTED, &pwm->flags)) { 754 pr_warn("PWM device already freed\n"); 755 goto out; 756 } 757 758 if (pwm->chip->ops->free) 759 pwm->chip->ops->free(pwm->chip, pwm); 760 761 pwm->label = NULL; 762 763 module_put(pwm->chip->ops->owner); 764 out: 765 mutex_unlock(&pwm_lock); 766 } 767 EXPORT_SYMBOL_GPL(pwm_put); 768 769 static void devm_pwm_release(struct device *dev, void *res) 770 { 771 pwm_put(*(struct pwm_device **)res); 772 } 773 774 /** 775 * devm_pwm_get() - resource managed pwm_get() 776 * @dev: device for PWM consumer 777 * @con_id: consumer name 778 * 779 * This function performs like pwm_get() but the acquired PWM device will 780 * automatically be released on driver detach. 781 * 782 * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded 783 * error code on failure. 784 */ 785 struct pwm_device *devm_pwm_get(struct device *dev, const char *con_id) 786 { 787 struct pwm_device **ptr, *pwm; 788 789 ptr = devres_alloc(devm_pwm_release, sizeof(*ptr), GFP_KERNEL); 790 if (!ptr) 791 return ERR_PTR(-ENOMEM); 792 793 pwm = pwm_get(dev, con_id); 794 if (!IS_ERR(pwm)) { 795 *ptr = pwm; 796 devres_add(dev, ptr); 797 } else { 798 devres_free(ptr); 799 } 800 801 return pwm; 802 } 803 EXPORT_SYMBOL_GPL(devm_pwm_get); 804 805 /** 806 * devm_of_pwm_get() - resource managed of_pwm_get() 807 * @dev: device for PWM consumer 808 * @np: device node to get the PWM from 809 * @con_id: consumer name 810 * 811 * This function performs like of_pwm_get() but the acquired PWM device will 812 * automatically be released on driver detach. 813 * 814 * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded 815 * error code on failure. 816 */ 817 struct pwm_device *devm_of_pwm_get(struct device *dev, struct device_node *np, 818 const char *con_id) 819 { 820 struct pwm_device **ptr, *pwm; 821 822 ptr = devres_alloc(devm_pwm_release, sizeof(*ptr), GFP_KERNEL); 823 if (!ptr) 824 return ERR_PTR(-ENOMEM); 825 826 pwm = of_pwm_get(np, con_id); 827 if (!IS_ERR(pwm)) { 828 *ptr = pwm; 829 devres_add(dev, ptr); 830 } else { 831 devres_free(ptr); 832 } 833 834 return pwm; 835 } 836 EXPORT_SYMBOL_GPL(devm_of_pwm_get); 837 838 static int devm_pwm_match(struct device *dev, void *res, void *data) 839 { 840 struct pwm_device **p = res; 841 842 if (WARN_ON(!p || !*p)) 843 return 0; 844 845 return *p == data; 846 } 847 848 /** 849 * devm_pwm_put() - resource managed pwm_put() 850 * @dev: device for PWM consumer 851 * @pwm: PWM device 852 * 853 * Release a PWM previously allocated using devm_pwm_get(). Calling this 854 * function is usually not needed because devm-allocated resources are 855 * automatically released on driver detach. 856 */ 857 void devm_pwm_put(struct device *dev, struct pwm_device *pwm) 858 { 859 WARN_ON(devres_release(dev, devm_pwm_release, devm_pwm_match, pwm)); 860 } 861 EXPORT_SYMBOL_GPL(devm_pwm_put); 862 863 /** 864 * pwm_can_sleep() - report whether PWM access will sleep 865 * @pwm: PWM device 866 * 867 * Returns: True if accessing the PWM can sleep, false otherwise. 868 */ 869 bool pwm_can_sleep(struct pwm_device *pwm) 870 { 871 return pwm->chip->can_sleep; 872 } 873 EXPORT_SYMBOL_GPL(pwm_can_sleep); 874 875 #ifdef CONFIG_DEBUG_FS 876 static void pwm_dbg_show(struct pwm_chip *chip, struct seq_file *s) 877 { 878 unsigned int i; 879 880 for (i = 0; i < chip->npwm; i++) { 881 struct pwm_device *pwm = &chip->pwms[i]; 882 883 seq_printf(s, " pwm-%-3d (%-20.20s):", i, pwm->label); 884 885 if (test_bit(PWMF_REQUESTED, &pwm->flags)) 886 seq_puts(s, " requested"); 887 888 if (pwm_is_enabled(pwm)) 889 seq_puts(s, " enabled"); 890 891 seq_puts(s, "\n"); 892 } 893 } 894 895 static void *pwm_seq_start(struct seq_file *s, loff_t *pos) 896 { 897 mutex_lock(&pwm_lock); 898 s->private = ""; 899 900 return seq_list_start(&pwm_chips, *pos); 901 } 902 903 static void *pwm_seq_next(struct seq_file *s, void *v, loff_t *pos) 904 { 905 s->private = "\n"; 906 907 return seq_list_next(v, &pwm_chips, pos); 908 } 909 910 static void pwm_seq_stop(struct seq_file *s, void *v) 911 { 912 mutex_unlock(&pwm_lock); 913 } 914 915 static int pwm_seq_show(struct seq_file *s, void *v) 916 { 917 struct pwm_chip *chip = list_entry(v, struct pwm_chip, list); 918 919 seq_printf(s, "%s%s/%s, %d PWM device%s\n", (char *)s->private, 920 chip->dev->bus ? chip->dev->bus->name : "no-bus", 921 dev_name(chip->dev), chip->npwm, 922 (chip->npwm != 1) ? "s" : ""); 923 924 if (chip->ops->dbg_show) 925 chip->ops->dbg_show(chip, s); 926 else 927 pwm_dbg_show(chip, s); 928 929 return 0; 930 } 931 932 static const struct seq_operations pwm_seq_ops = { 933 .start = pwm_seq_start, 934 .next = pwm_seq_next, 935 .stop = pwm_seq_stop, 936 .show = pwm_seq_show, 937 }; 938 939 static int pwm_seq_open(struct inode *inode, struct file *file) 940 { 941 return seq_open(file, &pwm_seq_ops); 942 } 943 944 static const struct file_operations pwm_debugfs_ops = { 945 .owner = THIS_MODULE, 946 .open = pwm_seq_open, 947 .read = seq_read, 948 .llseek = seq_lseek, 949 .release = seq_release, 950 }; 951 952 static int __init pwm_debugfs_init(void) 953 { 954 debugfs_create_file("pwm", S_IFREG | S_IRUGO, NULL, NULL, 955 &pwm_debugfs_ops); 956 957 return 0; 958 } 959 subsys_initcall(pwm_debugfs_init); 960 #endif /* CONFIG_DEBUG_FS */ 961