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