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