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_adjust_config() - adjust the current PWM config to the PWM arguments 530 * @pwm: PWM device 531 * 532 * This function will adjust the PWM config to the PWM arguments provided 533 * by the DT or PWM lookup table. This is particularly useful to adapt 534 * the bootloader config to the Linux one. 535 */ 536 int pwm_adjust_config(struct pwm_device *pwm) 537 { 538 struct pwm_state state; 539 struct pwm_args pargs; 540 541 pwm_get_args(pwm, &pargs); 542 pwm_get_state(pwm, &state); 543 544 /* 545 * If the current period is zero it means that either the PWM driver 546 * does not support initial state retrieval or the PWM has not yet 547 * been configured. 548 * 549 * In either case, we setup the new period and polarity, and assign a 550 * duty cycle of 0. 551 */ 552 if (!state.period) { 553 state.duty_cycle = 0; 554 state.period = pargs.period; 555 state.polarity = pargs.polarity; 556 557 return pwm_apply_state(pwm, &state); 558 } 559 560 /* 561 * Adjust the PWM duty cycle/period based on the period value provided 562 * in PWM args. 563 */ 564 if (pargs.period != state.period) { 565 u64 dutycycle = (u64)state.duty_cycle * pargs.period; 566 567 do_div(dutycycle, state.period); 568 state.duty_cycle = dutycycle; 569 state.period = pargs.period; 570 } 571 572 /* 573 * If the polarity changed, we should also change the duty cycle. 574 */ 575 if (pargs.polarity != state.polarity) { 576 state.polarity = pargs.polarity; 577 state.duty_cycle = state.period - state.duty_cycle; 578 } 579 580 return pwm_apply_state(pwm, &state); 581 } 582 EXPORT_SYMBOL_GPL(pwm_adjust_config); 583 584 static struct pwm_chip *of_node_to_pwmchip(struct device_node *np) 585 { 586 struct pwm_chip *chip; 587 588 mutex_lock(&pwm_lock); 589 590 list_for_each_entry(chip, &pwm_chips, list) 591 if (chip->dev && chip->dev->of_node == np) { 592 mutex_unlock(&pwm_lock); 593 return chip; 594 } 595 596 mutex_unlock(&pwm_lock); 597 598 return ERR_PTR(-EPROBE_DEFER); 599 } 600 601 /** 602 * of_pwm_get() - request a PWM via the PWM framework 603 * @np: device node to get the PWM from 604 * @con_id: consumer name 605 * 606 * Returns the PWM device parsed from the phandle and index specified in the 607 * "pwms" property of a device tree node or a negative error-code on failure. 608 * Values parsed from the device tree are stored in the returned PWM device 609 * object. 610 * 611 * If con_id is NULL, the first PWM device listed in the "pwms" property will 612 * be requested. Otherwise the "pwm-names" property is used to do a reverse 613 * lookup of the PWM index. This also means that the "pwm-names" property 614 * becomes mandatory for devices that look up the PWM device via the con_id 615 * parameter. 616 * 617 * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded 618 * error code on failure. 619 */ 620 struct pwm_device *of_pwm_get(struct device_node *np, const char *con_id) 621 { 622 struct pwm_device *pwm = NULL; 623 struct of_phandle_args args; 624 struct pwm_chip *pc; 625 int index = 0; 626 int err; 627 628 if (con_id) { 629 index = of_property_match_string(np, "pwm-names", con_id); 630 if (index < 0) 631 return ERR_PTR(index); 632 } 633 634 err = of_parse_phandle_with_args(np, "pwms", "#pwm-cells", index, 635 &args); 636 if (err) { 637 pr_debug("%s(): can't parse \"pwms\" property\n", __func__); 638 return ERR_PTR(err); 639 } 640 641 pc = of_node_to_pwmchip(args.np); 642 if (IS_ERR(pc)) { 643 pr_debug("%s(): PWM chip not found\n", __func__); 644 pwm = ERR_CAST(pc); 645 goto put; 646 } 647 648 if (args.args_count != pc->of_pwm_n_cells) { 649 pr_debug("%s: wrong #pwm-cells for %s\n", np->full_name, 650 args.np->full_name); 651 pwm = ERR_PTR(-EINVAL); 652 goto put; 653 } 654 655 pwm = pc->of_xlate(pc, &args); 656 if (IS_ERR(pwm)) 657 goto put; 658 659 /* 660 * If a consumer name was not given, try to look it up from the 661 * "pwm-names" property if it exists. Otherwise use the name of 662 * the user device node. 663 */ 664 if (!con_id) { 665 err = of_property_read_string_index(np, "pwm-names", index, 666 &con_id); 667 if (err < 0) 668 con_id = np->name; 669 } 670 671 pwm->label = con_id; 672 673 put: 674 of_node_put(args.np); 675 676 return pwm; 677 } 678 EXPORT_SYMBOL_GPL(of_pwm_get); 679 680 /** 681 * pwm_add_table() - register PWM device consumers 682 * @table: array of consumers to register 683 * @num: number of consumers in table 684 */ 685 void pwm_add_table(struct pwm_lookup *table, size_t num) 686 { 687 mutex_lock(&pwm_lookup_lock); 688 689 while (num--) { 690 list_add_tail(&table->list, &pwm_lookup_list); 691 table++; 692 } 693 694 mutex_unlock(&pwm_lookup_lock); 695 } 696 697 /** 698 * pwm_remove_table() - unregister PWM device consumers 699 * @table: array of consumers to unregister 700 * @num: number of consumers in table 701 */ 702 void pwm_remove_table(struct pwm_lookup *table, size_t num) 703 { 704 mutex_lock(&pwm_lookup_lock); 705 706 while (num--) { 707 list_del(&table->list); 708 table++; 709 } 710 711 mutex_unlock(&pwm_lookup_lock); 712 } 713 714 /** 715 * pwm_get() - look up and request a PWM device 716 * @dev: device for PWM consumer 717 * @con_id: consumer name 718 * 719 * Lookup is first attempted using DT. If the device was not instantiated from 720 * a device tree, a PWM chip and a relative index is looked up via a table 721 * supplied by board setup code (see pwm_add_table()). 722 * 723 * Once a PWM chip has been found the specified PWM device will be requested 724 * and is ready to be used. 725 * 726 * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded 727 * error code on failure. 728 */ 729 struct pwm_device *pwm_get(struct device *dev, const char *con_id) 730 { 731 struct pwm_device *pwm = ERR_PTR(-EPROBE_DEFER); 732 const char *dev_id = dev ? dev_name(dev) : NULL; 733 struct pwm_chip *chip = NULL; 734 unsigned int best = 0; 735 struct pwm_lookup *p, *chosen = NULL; 736 unsigned int match; 737 738 /* look up via DT first */ 739 if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node) 740 return of_pwm_get(dev->of_node, con_id); 741 742 /* 743 * We look up the provider in the static table typically provided by 744 * board setup code. We first try to lookup the consumer device by 745 * name. If the consumer device was passed in as NULL or if no match 746 * was found, we try to find the consumer by directly looking it up 747 * by name. 748 * 749 * If a match is found, the provider PWM chip is looked up by name 750 * and a PWM device is requested using the PWM device per-chip index. 751 * 752 * The lookup algorithm was shamelessly taken from the clock 753 * framework: 754 * 755 * We do slightly fuzzy matching here: 756 * An entry with a NULL ID is assumed to be a wildcard. 757 * If an entry has a device ID, it must match 758 * If an entry has a connection ID, it must match 759 * Then we take the most specific entry - with the following order 760 * of precedence: dev+con > dev only > con only. 761 */ 762 mutex_lock(&pwm_lookup_lock); 763 764 list_for_each_entry(p, &pwm_lookup_list, list) { 765 match = 0; 766 767 if (p->dev_id) { 768 if (!dev_id || strcmp(p->dev_id, dev_id)) 769 continue; 770 771 match += 2; 772 } 773 774 if (p->con_id) { 775 if (!con_id || strcmp(p->con_id, con_id)) 776 continue; 777 778 match += 1; 779 } 780 781 if (match > best) { 782 chosen = p; 783 784 if (match != 3) 785 best = match; 786 else 787 break; 788 } 789 } 790 791 if (!chosen) { 792 pwm = ERR_PTR(-ENODEV); 793 goto out; 794 } 795 796 chip = pwmchip_find_by_name(chosen->provider); 797 if (!chip) 798 goto out; 799 800 pwm = pwm_request_from_chip(chip, chosen->index, con_id ?: dev_id); 801 if (IS_ERR(pwm)) 802 goto out; 803 804 pwm->args.period = chosen->period; 805 pwm->args.polarity = chosen->polarity; 806 807 out: 808 mutex_unlock(&pwm_lookup_lock); 809 return pwm; 810 } 811 EXPORT_SYMBOL_GPL(pwm_get); 812 813 /** 814 * pwm_put() - release a PWM device 815 * @pwm: PWM device 816 */ 817 void pwm_put(struct pwm_device *pwm) 818 { 819 if (!pwm) 820 return; 821 822 mutex_lock(&pwm_lock); 823 824 if (!test_and_clear_bit(PWMF_REQUESTED, &pwm->flags)) { 825 pr_warn("PWM device already freed\n"); 826 goto out; 827 } 828 829 if (pwm->chip->ops->free) 830 pwm->chip->ops->free(pwm->chip, pwm); 831 832 pwm->label = NULL; 833 834 module_put(pwm->chip->ops->owner); 835 out: 836 mutex_unlock(&pwm_lock); 837 } 838 EXPORT_SYMBOL_GPL(pwm_put); 839 840 static void devm_pwm_release(struct device *dev, void *res) 841 { 842 pwm_put(*(struct pwm_device **)res); 843 } 844 845 /** 846 * devm_pwm_get() - resource managed pwm_get() 847 * @dev: device for PWM consumer 848 * @con_id: consumer name 849 * 850 * This function performs like pwm_get() but the acquired PWM device will 851 * automatically be released on driver detach. 852 * 853 * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded 854 * error code on failure. 855 */ 856 struct pwm_device *devm_pwm_get(struct device *dev, const char *con_id) 857 { 858 struct pwm_device **ptr, *pwm; 859 860 ptr = devres_alloc(devm_pwm_release, sizeof(*ptr), GFP_KERNEL); 861 if (!ptr) 862 return ERR_PTR(-ENOMEM); 863 864 pwm = pwm_get(dev, con_id); 865 if (!IS_ERR(pwm)) { 866 *ptr = pwm; 867 devres_add(dev, ptr); 868 } else { 869 devres_free(ptr); 870 } 871 872 return pwm; 873 } 874 EXPORT_SYMBOL_GPL(devm_pwm_get); 875 876 /** 877 * devm_of_pwm_get() - resource managed of_pwm_get() 878 * @dev: device for PWM consumer 879 * @np: device node to get the PWM from 880 * @con_id: consumer name 881 * 882 * This function performs like of_pwm_get() but the acquired PWM device will 883 * automatically be released on driver detach. 884 * 885 * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded 886 * error code on failure. 887 */ 888 struct pwm_device *devm_of_pwm_get(struct device *dev, struct device_node *np, 889 const char *con_id) 890 { 891 struct pwm_device **ptr, *pwm; 892 893 ptr = devres_alloc(devm_pwm_release, sizeof(*ptr), GFP_KERNEL); 894 if (!ptr) 895 return ERR_PTR(-ENOMEM); 896 897 pwm = of_pwm_get(np, con_id); 898 if (!IS_ERR(pwm)) { 899 *ptr = pwm; 900 devres_add(dev, ptr); 901 } else { 902 devres_free(ptr); 903 } 904 905 return pwm; 906 } 907 EXPORT_SYMBOL_GPL(devm_of_pwm_get); 908 909 static int devm_pwm_match(struct device *dev, void *res, void *data) 910 { 911 struct pwm_device **p = res; 912 913 if (WARN_ON(!p || !*p)) 914 return 0; 915 916 return *p == data; 917 } 918 919 /** 920 * devm_pwm_put() - resource managed pwm_put() 921 * @dev: device for PWM consumer 922 * @pwm: PWM device 923 * 924 * Release a PWM previously allocated using devm_pwm_get(). Calling this 925 * function is usually not needed because devm-allocated resources are 926 * automatically released on driver detach. 927 */ 928 void devm_pwm_put(struct device *dev, struct pwm_device *pwm) 929 { 930 WARN_ON(devres_release(dev, devm_pwm_release, devm_pwm_match, pwm)); 931 } 932 EXPORT_SYMBOL_GPL(devm_pwm_put); 933 934 /** 935 * pwm_can_sleep() - report whether PWM access will sleep 936 * @pwm: PWM device 937 * 938 * Returns: True if accessing the PWM can sleep, false otherwise. 939 */ 940 bool pwm_can_sleep(struct pwm_device *pwm) 941 { 942 return true; 943 } 944 EXPORT_SYMBOL_GPL(pwm_can_sleep); 945 946 #ifdef CONFIG_DEBUG_FS 947 static void pwm_dbg_show(struct pwm_chip *chip, struct seq_file *s) 948 { 949 unsigned int i; 950 951 for (i = 0; i < chip->npwm; i++) { 952 struct pwm_device *pwm = &chip->pwms[i]; 953 struct pwm_state state; 954 955 pwm_get_state(pwm, &state); 956 957 seq_printf(s, " pwm-%-3d (%-20.20s):", i, pwm->label); 958 959 if (test_bit(PWMF_REQUESTED, &pwm->flags)) 960 seq_puts(s, " requested"); 961 962 if (state.enabled) 963 seq_puts(s, " enabled"); 964 965 seq_printf(s, " period: %u ns", state.period); 966 seq_printf(s, " duty: %u ns", state.duty_cycle); 967 seq_printf(s, " polarity: %s", 968 state.polarity ? "inverse" : "normal"); 969 970 seq_puts(s, "\n"); 971 } 972 } 973 974 static void *pwm_seq_start(struct seq_file *s, loff_t *pos) 975 { 976 mutex_lock(&pwm_lock); 977 s->private = ""; 978 979 return seq_list_start(&pwm_chips, *pos); 980 } 981 982 static void *pwm_seq_next(struct seq_file *s, void *v, loff_t *pos) 983 { 984 s->private = "\n"; 985 986 return seq_list_next(v, &pwm_chips, pos); 987 } 988 989 static void pwm_seq_stop(struct seq_file *s, void *v) 990 { 991 mutex_unlock(&pwm_lock); 992 } 993 994 static int pwm_seq_show(struct seq_file *s, void *v) 995 { 996 struct pwm_chip *chip = list_entry(v, struct pwm_chip, list); 997 998 seq_printf(s, "%s%s/%s, %d PWM device%s\n", (char *)s->private, 999 chip->dev->bus ? chip->dev->bus->name : "no-bus", 1000 dev_name(chip->dev), chip->npwm, 1001 (chip->npwm != 1) ? "s" : ""); 1002 1003 if (chip->ops->dbg_show) 1004 chip->ops->dbg_show(chip, s); 1005 else 1006 pwm_dbg_show(chip, s); 1007 1008 return 0; 1009 } 1010 1011 static const struct seq_operations pwm_seq_ops = { 1012 .start = pwm_seq_start, 1013 .next = pwm_seq_next, 1014 .stop = pwm_seq_stop, 1015 .show = pwm_seq_show, 1016 }; 1017 1018 static int pwm_seq_open(struct inode *inode, struct file *file) 1019 { 1020 return seq_open(file, &pwm_seq_ops); 1021 } 1022 1023 static const struct file_operations pwm_debugfs_ops = { 1024 .owner = THIS_MODULE, 1025 .open = pwm_seq_open, 1026 .read = seq_read, 1027 .llseek = seq_lseek, 1028 .release = seq_release, 1029 }; 1030 1031 static int __init pwm_debugfs_init(void) 1032 { 1033 debugfs_create_file("pwm", S_IFREG | S_IRUGO, NULL, NULL, 1034 &pwm_debugfs_ops); 1035 1036 return 0; 1037 } 1038 subsys_initcall(pwm_debugfs_init); 1039 #endif /* CONFIG_DEBUG_FS */ 1040