1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Generic pwmlib implementation 4 * 5 * Copyright (C) 2011 Sascha Hauer <s.hauer@pengutronix.de> 6 * Copyright (C) 2011-2012 Avionic Design GmbH 7 */ 8 9 #include <linux/acpi.h> 10 #include <linux/module.h> 11 #include <linux/pwm.h> 12 #include <linux/radix-tree.h> 13 #include <linux/list.h> 14 #include <linux/mutex.h> 15 #include <linux/err.h> 16 #include <linux/slab.h> 17 #include <linux/device.h> 18 #include <linux/debugfs.h> 19 #include <linux/seq_file.h> 20 21 #include <dt-bindings/pwm/pwm.h> 22 23 #define CREATE_TRACE_POINTS 24 #include <trace/events/pwm.h> 25 26 #define MAX_PWMS 1024 27 28 static DEFINE_MUTEX(pwm_lookup_lock); 29 static LIST_HEAD(pwm_lookup_list); 30 static DEFINE_MUTEX(pwm_lock); 31 static LIST_HEAD(pwm_chips); 32 static DECLARE_BITMAP(allocated_pwms, MAX_PWMS); 33 static RADIX_TREE(pwm_tree, GFP_KERNEL); 34 35 static struct pwm_device *pwm_to_device(unsigned int pwm) 36 { 37 return radix_tree_lookup(&pwm_tree, pwm); 38 } 39 40 static int alloc_pwms(int pwm, unsigned int count) 41 { 42 unsigned int from = 0; 43 unsigned int start; 44 45 if (pwm >= MAX_PWMS) 46 return -EINVAL; 47 48 if (pwm >= 0) 49 from = pwm; 50 51 start = bitmap_find_next_zero_area(allocated_pwms, MAX_PWMS, from, 52 count, 0); 53 54 if (pwm >= 0 && start != pwm) 55 return -EEXIST; 56 57 if (start + count > MAX_PWMS) 58 return -ENOSPC; 59 60 return start; 61 } 62 63 static void free_pwms(struct pwm_chip *chip) 64 { 65 unsigned int i; 66 67 for (i = 0; i < chip->npwm; i++) { 68 struct pwm_device *pwm = &chip->pwms[i]; 69 70 radix_tree_delete(&pwm_tree, pwm->pwm); 71 } 72 73 bitmap_clear(allocated_pwms, chip->base, chip->npwm); 74 75 kfree(chip->pwms); 76 chip->pwms = NULL; 77 } 78 79 static struct pwm_chip *pwmchip_find_by_name(const char *name) 80 { 81 struct pwm_chip *chip; 82 83 if (!name) 84 return NULL; 85 86 mutex_lock(&pwm_lock); 87 88 list_for_each_entry(chip, &pwm_chips, list) { 89 const char *chip_name = dev_name(chip->dev); 90 91 if (chip_name && strcmp(chip_name, name) == 0) { 92 mutex_unlock(&pwm_lock); 93 return chip; 94 } 95 } 96 97 mutex_unlock(&pwm_lock); 98 99 return NULL; 100 } 101 102 static int pwm_device_request(struct pwm_device *pwm, const char *label) 103 { 104 int err; 105 106 if (test_bit(PWMF_REQUESTED, &pwm->flags)) 107 return -EBUSY; 108 109 if (!try_module_get(pwm->chip->ops->owner)) 110 return -ENODEV; 111 112 if (pwm->chip->ops->request) { 113 err = pwm->chip->ops->request(pwm->chip, pwm); 114 if (err) { 115 module_put(pwm->chip->ops->owner); 116 return err; 117 } 118 } 119 120 if (pwm->chip->ops->get_state) { 121 pwm->chip->ops->get_state(pwm->chip, pwm, &pwm->state); 122 trace_pwm_get(pwm, &pwm->state); 123 124 if (IS_ENABLED(CONFIG_PWM_DEBUG)) 125 pwm->last = pwm->state; 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 /* check, whether the driver supports a third cell for flags */ 140 if (pc->of_pwm_n_cells < 3) 141 return ERR_PTR(-EINVAL); 142 143 /* flags in the third cell are optional */ 144 if (args->args_count < 2) 145 return ERR_PTR(-EINVAL); 146 147 if (args->args[0] >= pc->npwm) 148 return ERR_PTR(-EINVAL); 149 150 pwm = pwm_request_from_chip(pc, args->args[0], NULL); 151 if (IS_ERR(pwm)) 152 return pwm; 153 154 pwm->args.period = args->args[1]; 155 pwm->args.polarity = PWM_POLARITY_NORMAL; 156 157 if (args->args_count > 2 && args->args[2] & PWM_POLARITY_INVERTED) 158 pwm->args.polarity = PWM_POLARITY_INVERSED; 159 160 return pwm; 161 } 162 EXPORT_SYMBOL_GPL(of_pwm_xlate_with_flags); 163 164 static struct pwm_device * 165 of_pwm_simple_xlate(struct pwm_chip *pc, const struct of_phandle_args *args) 166 { 167 struct pwm_device *pwm; 168 169 /* sanity check driver support */ 170 if (pc->of_pwm_n_cells < 2) 171 return ERR_PTR(-EINVAL); 172 173 /* all cells are required */ 174 if (args->args_count != pc->of_pwm_n_cells) 175 return ERR_PTR(-EINVAL); 176 177 if (args->args[0] >= pc->npwm) 178 return ERR_PTR(-EINVAL); 179 180 pwm = pwm_request_from_chip(pc, args->args[0], NULL); 181 if (IS_ERR(pwm)) 182 return pwm; 183 184 pwm->args.period = args->args[1]; 185 186 return pwm; 187 } 188 189 static void of_pwmchip_add(struct pwm_chip *chip) 190 { 191 if (!chip->dev || !chip->dev->of_node) 192 return; 193 194 if (!chip->of_xlate) { 195 chip->of_xlate = of_pwm_simple_xlate; 196 chip->of_pwm_n_cells = 2; 197 } 198 199 of_node_get(chip->dev->of_node); 200 } 201 202 static void of_pwmchip_remove(struct pwm_chip *chip) 203 { 204 if (chip->dev) 205 of_node_put(chip->dev->of_node); 206 } 207 208 /** 209 * pwm_set_chip_data() - set private chip data for a PWM 210 * @pwm: PWM device 211 * @data: pointer to chip-specific data 212 * 213 * Returns: 0 on success or a negative error code on failure. 214 */ 215 int pwm_set_chip_data(struct pwm_device *pwm, void *data) 216 { 217 if (!pwm) 218 return -EINVAL; 219 220 pwm->chip_data = data; 221 222 return 0; 223 } 224 EXPORT_SYMBOL_GPL(pwm_set_chip_data); 225 226 /** 227 * pwm_get_chip_data() - get private chip data for a PWM 228 * @pwm: PWM device 229 * 230 * Returns: A pointer to the chip-private data for the PWM device. 231 */ 232 void *pwm_get_chip_data(struct pwm_device *pwm) 233 { 234 return pwm ? pwm->chip_data : NULL; 235 } 236 EXPORT_SYMBOL_GPL(pwm_get_chip_data); 237 238 static bool pwm_ops_check(const struct pwm_chip *chip) 239 { 240 241 const struct pwm_ops *ops = chip->ops; 242 243 /* driver supports legacy, non-atomic operation */ 244 if (ops->config && ops->enable && ops->disable) { 245 if (IS_ENABLED(CONFIG_PWM_DEBUG)) 246 dev_warn(chip->dev, 247 "Driver needs updating to atomic API\n"); 248 249 return true; 250 } 251 252 if (!ops->apply) 253 return false; 254 255 if (IS_ENABLED(CONFIG_PWM_DEBUG) && !ops->get_state) 256 dev_warn(chip->dev, 257 "Please implement the .get_state() callback\n"); 258 259 return true; 260 } 261 262 /** 263 * pwmchip_add_with_polarity() - register a new PWM chip 264 * @chip: the PWM chip to add 265 * @polarity: initial polarity of PWM channels 266 * 267 * Register a new PWM chip. If chip->base < 0 then a dynamically assigned base 268 * will be used. The initial polarity for all channels is specified by the 269 * @polarity parameter. 270 * 271 * Returns: 0 on success or a negative error code on failure. 272 */ 273 int pwmchip_add_with_polarity(struct pwm_chip *chip, 274 enum pwm_polarity polarity) 275 { 276 struct pwm_device *pwm; 277 unsigned int i; 278 int ret; 279 280 if (!chip || !chip->dev || !chip->ops || !chip->npwm) 281 return -EINVAL; 282 283 if (!pwm_ops_check(chip)) 284 return -EINVAL; 285 286 mutex_lock(&pwm_lock); 287 288 ret = alloc_pwms(chip->base, chip->npwm); 289 if (ret < 0) 290 goto out; 291 292 chip->pwms = kcalloc(chip->npwm, sizeof(*pwm), GFP_KERNEL); 293 if (!chip->pwms) { 294 ret = -ENOMEM; 295 goto out; 296 } 297 298 chip->base = ret; 299 300 for (i = 0; i < chip->npwm; i++) { 301 pwm = &chip->pwms[i]; 302 303 pwm->chip = chip; 304 pwm->pwm = chip->base + i; 305 pwm->hwpwm = i; 306 pwm->state.polarity = polarity; 307 308 radix_tree_insert(&pwm_tree, pwm->pwm, pwm); 309 } 310 311 bitmap_set(allocated_pwms, chip->base, chip->npwm); 312 313 INIT_LIST_HEAD(&chip->list); 314 list_add(&chip->list, &pwm_chips); 315 316 ret = 0; 317 318 if (IS_ENABLED(CONFIG_OF)) 319 of_pwmchip_add(chip); 320 321 out: 322 mutex_unlock(&pwm_lock); 323 324 if (!ret) 325 pwmchip_sysfs_export(chip); 326 327 return ret; 328 } 329 EXPORT_SYMBOL_GPL(pwmchip_add_with_polarity); 330 331 /** 332 * pwmchip_add() - register a new PWM chip 333 * @chip: the PWM chip to add 334 * 335 * Register a new PWM chip. If chip->base < 0 then a dynamically assigned base 336 * will be used. The initial polarity for all channels is normal. 337 * 338 * Returns: 0 on success or a negative error code on failure. 339 */ 340 int pwmchip_add(struct pwm_chip *chip) 341 { 342 return pwmchip_add_with_polarity(chip, PWM_POLARITY_NORMAL); 343 } 344 EXPORT_SYMBOL_GPL(pwmchip_add); 345 346 /** 347 * pwmchip_remove() - remove a PWM chip 348 * @chip: the PWM chip to remove 349 * 350 * Removes a PWM chip. This function may return busy if the PWM chip provides 351 * a PWM device that is still requested. 352 * 353 * Returns: 0 on success or a negative error code on failure. 354 */ 355 int pwmchip_remove(struct pwm_chip *chip) 356 { 357 unsigned int i; 358 int ret = 0; 359 360 pwmchip_sysfs_unexport(chip); 361 362 mutex_lock(&pwm_lock); 363 364 for (i = 0; i < chip->npwm; i++) { 365 struct pwm_device *pwm = &chip->pwms[i]; 366 367 if (test_bit(PWMF_REQUESTED, &pwm->flags)) { 368 ret = -EBUSY; 369 goto out; 370 } 371 } 372 373 list_del_init(&chip->list); 374 375 if (IS_ENABLED(CONFIG_OF)) 376 of_pwmchip_remove(chip); 377 378 free_pwms(chip); 379 380 out: 381 mutex_unlock(&pwm_lock); 382 return ret; 383 } 384 EXPORT_SYMBOL_GPL(pwmchip_remove); 385 386 /** 387 * pwm_request() - request a PWM device 388 * @pwm: global PWM device index 389 * @label: PWM device label 390 * 391 * This function is deprecated, use pwm_get() instead. 392 * 393 * Returns: A pointer to a PWM device or an ERR_PTR()-encoded error code on 394 * failure. 395 */ 396 struct pwm_device *pwm_request(int pwm, const char *label) 397 { 398 struct pwm_device *dev; 399 int err; 400 401 if (pwm < 0 || pwm >= MAX_PWMS) 402 return ERR_PTR(-EINVAL); 403 404 mutex_lock(&pwm_lock); 405 406 dev = pwm_to_device(pwm); 407 if (!dev) { 408 dev = ERR_PTR(-EPROBE_DEFER); 409 goto out; 410 } 411 412 err = pwm_device_request(dev, label); 413 if (err < 0) 414 dev = ERR_PTR(err); 415 416 out: 417 mutex_unlock(&pwm_lock); 418 419 return dev; 420 } 421 EXPORT_SYMBOL_GPL(pwm_request); 422 423 /** 424 * pwm_request_from_chip() - request a PWM device relative to a PWM chip 425 * @chip: PWM chip 426 * @index: per-chip index of the PWM to request 427 * @label: a literal description string of this PWM 428 * 429 * Returns: A pointer to the PWM device at the given index of the given PWM 430 * chip. A negative error code is returned if the index is not valid for the 431 * specified PWM chip or if the PWM device cannot be requested. 432 */ 433 struct pwm_device *pwm_request_from_chip(struct pwm_chip *chip, 434 unsigned int index, 435 const char *label) 436 { 437 struct pwm_device *pwm; 438 int err; 439 440 if (!chip || index >= chip->npwm) 441 return ERR_PTR(-EINVAL); 442 443 mutex_lock(&pwm_lock); 444 pwm = &chip->pwms[index]; 445 446 err = pwm_device_request(pwm, label); 447 if (err < 0) 448 pwm = ERR_PTR(err); 449 450 mutex_unlock(&pwm_lock); 451 return pwm; 452 } 453 EXPORT_SYMBOL_GPL(pwm_request_from_chip); 454 455 /** 456 * pwm_free() - free a PWM device 457 * @pwm: PWM device 458 * 459 * This function is deprecated, use pwm_put() instead. 460 */ 461 void pwm_free(struct pwm_device *pwm) 462 { 463 pwm_put(pwm); 464 } 465 EXPORT_SYMBOL_GPL(pwm_free); 466 467 static void pwm_apply_state_debug(struct pwm_device *pwm, 468 const struct pwm_state *state) 469 { 470 struct pwm_state *last = &pwm->last; 471 struct pwm_chip *chip = pwm->chip; 472 struct pwm_state s1, s2; 473 int err; 474 475 if (!IS_ENABLED(CONFIG_PWM_DEBUG)) 476 return; 477 478 /* No reasonable diagnosis possible without .get_state() */ 479 if (!chip->ops->get_state) 480 return; 481 482 /* 483 * *state was just applied. Read out the hardware state and do some 484 * checks. 485 */ 486 487 chip->ops->get_state(chip, pwm, &s1); 488 trace_pwm_get(pwm, &s1); 489 490 /* 491 * The lowlevel driver either ignored .polarity (which is a bug) or as 492 * best effort inverted .polarity and fixed .duty_cycle respectively. 493 * Undo this inversion and fixup for further tests. 494 */ 495 if (s1.enabled && s1.polarity != state->polarity) { 496 s2.polarity = state->polarity; 497 s2.duty_cycle = s1.period - s1.duty_cycle; 498 s2.period = s1.period; 499 s2.enabled = s1.enabled; 500 } else { 501 s2 = s1; 502 } 503 504 if (s2.polarity != state->polarity && 505 state->duty_cycle < state->period) 506 dev_warn(chip->dev, ".apply ignored .polarity\n"); 507 508 if (state->enabled && 509 last->polarity == state->polarity && 510 last->period > s2.period && 511 last->period <= state->period) 512 dev_warn(chip->dev, 513 ".apply didn't pick the best available period (requested: %llu, applied: %llu, possible: %llu)\n", 514 state->period, s2.period, last->period); 515 516 if (state->enabled && state->period < s2.period) 517 dev_warn(chip->dev, 518 ".apply is supposed to round down period (requested: %llu, applied: %llu)\n", 519 state->period, s2.period); 520 521 if (state->enabled && 522 last->polarity == state->polarity && 523 last->period == s2.period && 524 last->duty_cycle > s2.duty_cycle && 525 last->duty_cycle <= state->duty_cycle) 526 dev_warn(chip->dev, 527 ".apply didn't pick the best available duty cycle (requested: %llu/%llu, applied: %llu/%llu, possible: %llu/%llu)\n", 528 state->duty_cycle, state->period, 529 s2.duty_cycle, s2.period, 530 last->duty_cycle, last->period); 531 532 if (state->enabled && state->duty_cycle < s2.duty_cycle) 533 dev_warn(chip->dev, 534 ".apply is supposed to round down duty_cycle (requested: %llu/%llu, applied: %llu/%llu)\n", 535 state->duty_cycle, state->period, 536 s2.duty_cycle, s2.period); 537 538 if (!state->enabled && s2.enabled && s2.duty_cycle > 0) 539 dev_warn(chip->dev, 540 "requested disabled, but yielded enabled with duty > 0\n"); 541 542 /* reapply the state that the driver reported being configured. */ 543 err = chip->ops->apply(chip, pwm, &s1); 544 if (err) { 545 *last = s1; 546 dev_err(chip->dev, "failed to reapply current setting\n"); 547 return; 548 } 549 550 trace_pwm_apply(pwm, &s1); 551 552 chip->ops->get_state(chip, pwm, last); 553 trace_pwm_get(pwm, last); 554 555 /* reapplication of the current state should give an exact match */ 556 if (s1.enabled != last->enabled || 557 s1.polarity != last->polarity || 558 (s1.enabled && s1.period != last->period) || 559 (s1.enabled && s1.duty_cycle != last->duty_cycle)) { 560 dev_err(chip->dev, 561 ".apply is not idempotent (ena=%d pol=%d %llu/%llu) -> (ena=%d pol=%d %llu/%llu)\n", 562 s1.enabled, s1.polarity, s1.duty_cycle, s1.period, 563 last->enabled, last->polarity, last->duty_cycle, 564 last->period); 565 } 566 } 567 568 /** 569 * pwm_apply_state() - atomically apply a new state to a PWM device 570 * @pwm: PWM device 571 * @state: new state to apply 572 */ 573 int pwm_apply_state(struct pwm_device *pwm, const struct pwm_state *state) 574 { 575 struct pwm_chip *chip; 576 int err; 577 578 if (!pwm || !state || !state->period || 579 state->duty_cycle > state->period) 580 return -EINVAL; 581 582 chip = pwm->chip; 583 584 if (state->period == pwm->state.period && 585 state->duty_cycle == pwm->state.duty_cycle && 586 state->polarity == pwm->state.polarity && 587 state->enabled == pwm->state.enabled) 588 return 0; 589 590 if (chip->ops->apply) { 591 err = chip->ops->apply(chip, pwm, state); 592 if (err) 593 return err; 594 595 trace_pwm_apply(pwm, state); 596 597 pwm->state = *state; 598 599 /* 600 * only do this after pwm->state was applied as some 601 * implementations of .get_state depend on this 602 */ 603 pwm_apply_state_debug(pwm, state); 604 } else { 605 /* 606 * FIXME: restore the initial state in case of error. 607 */ 608 if (state->polarity != pwm->state.polarity) { 609 if (!chip->ops->set_polarity) 610 return -ENOTSUPP; 611 612 /* 613 * Changing the polarity of a running PWM is 614 * only allowed when the PWM driver implements 615 * ->apply(). 616 */ 617 if (pwm->state.enabled) { 618 chip->ops->disable(chip, pwm); 619 pwm->state.enabled = false; 620 } 621 622 err = chip->ops->set_polarity(chip, pwm, 623 state->polarity); 624 if (err) 625 return err; 626 627 pwm->state.polarity = state->polarity; 628 } 629 630 if (state->period != pwm->state.period || 631 state->duty_cycle != pwm->state.duty_cycle) { 632 err = chip->ops->config(pwm->chip, pwm, 633 state->duty_cycle, 634 state->period); 635 if (err) 636 return err; 637 638 pwm->state.duty_cycle = state->duty_cycle; 639 pwm->state.period = state->period; 640 } 641 642 if (state->enabled != pwm->state.enabled) { 643 if (state->enabled) { 644 err = chip->ops->enable(chip, pwm); 645 if (err) 646 return err; 647 } else { 648 chip->ops->disable(chip, pwm); 649 } 650 651 pwm->state.enabled = state->enabled; 652 } 653 } 654 655 return 0; 656 } 657 EXPORT_SYMBOL_GPL(pwm_apply_state); 658 659 /** 660 * pwm_capture() - capture and report a PWM signal 661 * @pwm: PWM device 662 * @result: structure to fill with capture result 663 * @timeout: time to wait, in milliseconds, before giving up on capture 664 * 665 * Returns: 0 on success or a negative error code on failure. 666 */ 667 int pwm_capture(struct pwm_device *pwm, struct pwm_capture *result, 668 unsigned long timeout) 669 { 670 int err; 671 672 if (!pwm || !pwm->chip->ops) 673 return -EINVAL; 674 675 if (!pwm->chip->ops->capture) 676 return -ENOSYS; 677 678 mutex_lock(&pwm_lock); 679 err = pwm->chip->ops->capture(pwm->chip, pwm, result, timeout); 680 mutex_unlock(&pwm_lock); 681 682 return err; 683 } 684 EXPORT_SYMBOL_GPL(pwm_capture); 685 686 /** 687 * pwm_adjust_config() - adjust the current PWM config to the PWM arguments 688 * @pwm: PWM device 689 * 690 * This function will adjust the PWM config to the PWM arguments provided 691 * by the DT or PWM lookup table. This is particularly useful to adapt 692 * the bootloader config to the Linux one. 693 */ 694 int pwm_adjust_config(struct pwm_device *pwm) 695 { 696 struct pwm_state state; 697 struct pwm_args pargs; 698 699 pwm_get_args(pwm, &pargs); 700 pwm_get_state(pwm, &state); 701 702 /* 703 * If the current period is zero it means that either the PWM driver 704 * does not support initial state retrieval or the PWM has not yet 705 * been configured. 706 * 707 * In either case, we setup the new period and polarity, and assign a 708 * duty cycle of 0. 709 */ 710 if (!state.period) { 711 state.duty_cycle = 0; 712 state.period = pargs.period; 713 state.polarity = pargs.polarity; 714 715 return pwm_apply_state(pwm, &state); 716 } 717 718 /* 719 * Adjust the PWM duty cycle/period based on the period value provided 720 * in PWM args. 721 */ 722 if (pargs.period != state.period) { 723 u64 dutycycle = (u64)state.duty_cycle * pargs.period; 724 725 do_div(dutycycle, state.period); 726 state.duty_cycle = dutycycle; 727 state.period = pargs.period; 728 } 729 730 /* 731 * If the polarity changed, we should also change the duty cycle. 732 */ 733 if (pargs.polarity != state.polarity) { 734 state.polarity = pargs.polarity; 735 state.duty_cycle = state.period - state.duty_cycle; 736 } 737 738 return pwm_apply_state(pwm, &state); 739 } 740 EXPORT_SYMBOL_GPL(pwm_adjust_config); 741 742 static struct pwm_chip *of_node_to_pwmchip(struct device_node *np) 743 { 744 struct pwm_chip *chip; 745 746 mutex_lock(&pwm_lock); 747 748 list_for_each_entry(chip, &pwm_chips, list) 749 if (chip->dev && chip->dev->of_node == np) { 750 mutex_unlock(&pwm_lock); 751 return chip; 752 } 753 754 mutex_unlock(&pwm_lock); 755 756 return ERR_PTR(-EPROBE_DEFER); 757 } 758 759 static struct device_link *pwm_device_link_add(struct device *dev, 760 struct pwm_device *pwm) 761 { 762 struct device_link *dl; 763 764 if (!dev) { 765 /* 766 * No device for the PWM consumer has been provided. It may 767 * impact the PM sequence ordering: the PWM supplier may get 768 * suspended before the consumer. 769 */ 770 dev_warn(pwm->chip->dev, 771 "No consumer device specified to create a link to\n"); 772 return NULL; 773 } 774 775 dl = device_link_add(dev, pwm->chip->dev, DL_FLAG_AUTOREMOVE_CONSUMER); 776 if (!dl) { 777 dev_err(dev, "failed to create device link to %s\n", 778 dev_name(pwm->chip->dev)); 779 return ERR_PTR(-EINVAL); 780 } 781 782 return dl; 783 } 784 785 /** 786 * of_pwm_get() - request a PWM via the PWM framework 787 * @dev: device for PWM consumer 788 * @np: device node to get the PWM from 789 * @con_id: consumer name 790 * 791 * Returns the PWM device parsed from the phandle and index specified in the 792 * "pwms" property of a device tree node or a negative error-code on failure. 793 * Values parsed from the device tree are stored in the returned PWM device 794 * object. 795 * 796 * If con_id is NULL, the first PWM device listed in the "pwms" property will 797 * be requested. Otherwise the "pwm-names" property is used to do a reverse 798 * lookup of the PWM index. This also means that the "pwm-names" property 799 * becomes mandatory for devices that look up the PWM device via the con_id 800 * parameter. 801 * 802 * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded 803 * error code on failure. 804 */ 805 struct pwm_device *of_pwm_get(struct device *dev, struct device_node *np, 806 const char *con_id) 807 { 808 struct pwm_device *pwm = NULL; 809 struct of_phandle_args args; 810 struct device_link *dl; 811 struct pwm_chip *pc; 812 int index = 0; 813 int err; 814 815 if (con_id) { 816 index = of_property_match_string(np, "pwm-names", con_id); 817 if (index < 0) 818 return ERR_PTR(index); 819 } 820 821 err = of_parse_phandle_with_args(np, "pwms", "#pwm-cells", index, 822 &args); 823 if (err) { 824 pr_err("%s(): can't parse \"pwms\" property\n", __func__); 825 return ERR_PTR(err); 826 } 827 828 pc = of_node_to_pwmchip(args.np); 829 if (IS_ERR(pc)) { 830 if (PTR_ERR(pc) != -EPROBE_DEFER) 831 pr_err("%s(): PWM chip not found\n", __func__); 832 833 pwm = ERR_CAST(pc); 834 goto put; 835 } 836 837 pwm = pc->of_xlate(pc, &args); 838 if (IS_ERR(pwm)) 839 goto put; 840 841 dl = pwm_device_link_add(dev, pwm); 842 if (IS_ERR(dl)) { 843 /* of_xlate ended up calling pwm_request_from_chip() */ 844 pwm_free(pwm); 845 pwm = ERR_CAST(dl); 846 goto put; 847 } 848 849 /* 850 * If a consumer name was not given, try to look it up from the 851 * "pwm-names" property if it exists. Otherwise use the name of 852 * the user device node. 853 */ 854 if (!con_id) { 855 err = of_property_read_string_index(np, "pwm-names", index, 856 &con_id); 857 if (err < 0) 858 con_id = np->name; 859 } 860 861 pwm->label = con_id; 862 863 put: 864 of_node_put(args.np); 865 866 return pwm; 867 } 868 EXPORT_SYMBOL_GPL(of_pwm_get); 869 870 #if IS_ENABLED(CONFIG_ACPI) 871 static struct pwm_chip *device_to_pwmchip(struct device *dev) 872 { 873 struct pwm_chip *chip; 874 875 mutex_lock(&pwm_lock); 876 877 list_for_each_entry(chip, &pwm_chips, list) { 878 struct acpi_device *adev = ACPI_COMPANION(chip->dev); 879 880 if ((chip->dev == dev) || (adev && &adev->dev == dev)) { 881 mutex_unlock(&pwm_lock); 882 return chip; 883 } 884 } 885 886 mutex_unlock(&pwm_lock); 887 888 return ERR_PTR(-EPROBE_DEFER); 889 } 890 #endif 891 892 /** 893 * acpi_pwm_get() - request a PWM via parsing "pwms" property in ACPI 894 * @fwnode: firmware node to get the "pwm" property from 895 * 896 * Returns the PWM device parsed from the fwnode and index specified in the 897 * "pwms" property or a negative error-code on failure. 898 * Values parsed from the device tree are stored in the returned PWM device 899 * object. 900 * 901 * This is analogous to of_pwm_get() except con_id is not yet supported. 902 * ACPI entries must look like 903 * Package () {"pwms", Package () 904 * { <PWM device reference>, <PWM index>, <PWM period> [, <PWM flags>]}} 905 * 906 * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded 907 * error code on failure. 908 */ 909 static struct pwm_device *acpi_pwm_get(struct fwnode_handle *fwnode) 910 { 911 struct pwm_device *pwm = ERR_PTR(-ENODEV); 912 #if IS_ENABLED(CONFIG_ACPI) 913 struct fwnode_reference_args args; 914 struct acpi_device *acpi; 915 struct pwm_chip *chip; 916 int ret; 917 918 memset(&args, 0, sizeof(args)); 919 920 ret = __acpi_node_get_property_reference(fwnode, "pwms", 0, 3, &args); 921 if (ret < 0) 922 return ERR_PTR(ret); 923 924 acpi = to_acpi_device_node(args.fwnode); 925 if (!acpi) 926 return ERR_PTR(-EINVAL); 927 928 if (args.nargs < 2) 929 return ERR_PTR(-EPROTO); 930 931 chip = device_to_pwmchip(&acpi->dev); 932 if (IS_ERR(chip)) 933 return ERR_CAST(chip); 934 935 pwm = pwm_request_from_chip(chip, args.args[0], NULL); 936 if (IS_ERR(pwm)) 937 return pwm; 938 939 pwm->args.period = args.args[1]; 940 pwm->args.polarity = PWM_POLARITY_NORMAL; 941 942 if (args.nargs > 2 && args.args[2] & PWM_POLARITY_INVERTED) 943 pwm->args.polarity = PWM_POLARITY_INVERSED; 944 #endif 945 946 return pwm; 947 } 948 949 /** 950 * pwm_add_table() - register PWM device consumers 951 * @table: array of consumers to register 952 * @num: number of consumers in table 953 */ 954 void pwm_add_table(struct pwm_lookup *table, size_t num) 955 { 956 mutex_lock(&pwm_lookup_lock); 957 958 while (num--) { 959 list_add_tail(&table->list, &pwm_lookup_list); 960 table++; 961 } 962 963 mutex_unlock(&pwm_lookup_lock); 964 } 965 966 /** 967 * pwm_remove_table() - unregister PWM device consumers 968 * @table: array of consumers to unregister 969 * @num: number of consumers in table 970 */ 971 void pwm_remove_table(struct pwm_lookup *table, size_t num) 972 { 973 mutex_lock(&pwm_lookup_lock); 974 975 while (num--) { 976 list_del(&table->list); 977 table++; 978 } 979 980 mutex_unlock(&pwm_lookup_lock); 981 } 982 983 /** 984 * pwm_get() - look up and request a PWM device 985 * @dev: device for PWM consumer 986 * @con_id: consumer name 987 * 988 * Lookup is first attempted using DT. If the device was not instantiated from 989 * a device tree, a PWM chip and a relative index is looked up via a table 990 * supplied by board setup code (see pwm_add_table()). 991 * 992 * Once a PWM chip has been found the specified PWM device will be requested 993 * and is ready to be used. 994 * 995 * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded 996 * error code on failure. 997 */ 998 struct pwm_device *pwm_get(struct device *dev, const char *con_id) 999 { 1000 const char *dev_id = dev ? dev_name(dev) : NULL; 1001 struct pwm_device *pwm; 1002 struct pwm_chip *chip; 1003 struct device_link *dl; 1004 unsigned int best = 0; 1005 struct pwm_lookup *p, *chosen = NULL; 1006 unsigned int match; 1007 int err; 1008 1009 /* look up via DT first */ 1010 if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node) 1011 return of_pwm_get(dev, dev->of_node, con_id); 1012 1013 /* then lookup via ACPI */ 1014 if (dev && is_acpi_node(dev->fwnode)) { 1015 pwm = acpi_pwm_get(dev->fwnode); 1016 if (!IS_ERR(pwm) || PTR_ERR(pwm) != -ENOENT) 1017 return pwm; 1018 } 1019 1020 /* 1021 * We look up the provider in the static table typically provided by 1022 * board setup code. We first try to lookup the consumer device by 1023 * name. If the consumer device was passed in as NULL or if no match 1024 * was found, we try to find the consumer by directly looking it up 1025 * by name. 1026 * 1027 * If a match is found, the provider PWM chip is looked up by name 1028 * and a PWM device is requested using the PWM device per-chip index. 1029 * 1030 * The lookup algorithm was shamelessly taken from the clock 1031 * framework: 1032 * 1033 * We do slightly fuzzy matching here: 1034 * An entry with a NULL ID is assumed to be a wildcard. 1035 * If an entry has a device ID, it must match 1036 * If an entry has a connection ID, it must match 1037 * Then we take the most specific entry - with the following order 1038 * of precedence: dev+con > dev only > con only. 1039 */ 1040 mutex_lock(&pwm_lookup_lock); 1041 1042 list_for_each_entry(p, &pwm_lookup_list, list) { 1043 match = 0; 1044 1045 if (p->dev_id) { 1046 if (!dev_id || strcmp(p->dev_id, dev_id)) 1047 continue; 1048 1049 match += 2; 1050 } 1051 1052 if (p->con_id) { 1053 if (!con_id || strcmp(p->con_id, con_id)) 1054 continue; 1055 1056 match += 1; 1057 } 1058 1059 if (match > best) { 1060 chosen = p; 1061 1062 if (match != 3) 1063 best = match; 1064 else 1065 break; 1066 } 1067 } 1068 1069 mutex_unlock(&pwm_lookup_lock); 1070 1071 if (!chosen) 1072 return ERR_PTR(-ENODEV); 1073 1074 chip = pwmchip_find_by_name(chosen->provider); 1075 1076 /* 1077 * If the lookup entry specifies a module, load the module and retry 1078 * the PWM chip lookup. This can be used to work around driver load 1079 * ordering issues if driver's can't be made to properly support the 1080 * deferred probe mechanism. 1081 */ 1082 if (!chip && chosen->module) { 1083 err = request_module(chosen->module); 1084 if (err == 0) 1085 chip = pwmchip_find_by_name(chosen->provider); 1086 } 1087 1088 if (!chip) 1089 return ERR_PTR(-EPROBE_DEFER); 1090 1091 pwm = pwm_request_from_chip(chip, chosen->index, con_id ?: dev_id); 1092 if (IS_ERR(pwm)) 1093 return pwm; 1094 1095 dl = pwm_device_link_add(dev, pwm); 1096 if (IS_ERR(dl)) { 1097 pwm_free(pwm); 1098 return ERR_CAST(dl); 1099 } 1100 1101 pwm->args.period = chosen->period; 1102 pwm->args.polarity = chosen->polarity; 1103 1104 return pwm; 1105 } 1106 EXPORT_SYMBOL_GPL(pwm_get); 1107 1108 /** 1109 * pwm_put() - release a PWM device 1110 * @pwm: PWM device 1111 */ 1112 void pwm_put(struct pwm_device *pwm) 1113 { 1114 if (!pwm) 1115 return; 1116 1117 mutex_lock(&pwm_lock); 1118 1119 if (!test_and_clear_bit(PWMF_REQUESTED, &pwm->flags)) { 1120 pr_warn("PWM device already freed\n"); 1121 goto out; 1122 } 1123 1124 if (pwm->chip->ops->free) 1125 pwm->chip->ops->free(pwm->chip, pwm); 1126 1127 pwm_set_chip_data(pwm, NULL); 1128 pwm->label = NULL; 1129 1130 module_put(pwm->chip->ops->owner); 1131 out: 1132 mutex_unlock(&pwm_lock); 1133 } 1134 EXPORT_SYMBOL_GPL(pwm_put); 1135 1136 static void devm_pwm_release(struct device *dev, void *res) 1137 { 1138 pwm_put(*(struct pwm_device **)res); 1139 } 1140 1141 /** 1142 * devm_pwm_get() - resource managed pwm_get() 1143 * @dev: device for PWM consumer 1144 * @con_id: consumer name 1145 * 1146 * This function performs like pwm_get() but the acquired PWM device will 1147 * automatically be released on driver detach. 1148 * 1149 * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded 1150 * error code on failure. 1151 */ 1152 struct pwm_device *devm_pwm_get(struct device *dev, const char *con_id) 1153 { 1154 struct pwm_device **ptr, *pwm; 1155 1156 ptr = devres_alloc(devm_pwm_release, sizeof(*ptr), GFP_KERNEL); 1157 if (!ptr) 1158 return ERR_PTR(-ENOMEM); 1159 1160 pwm = pwm_get(dev, con_id); 1161 if (!IS_ERR(pwm)) { 1162 *ptr = pwm; 1163 devres_add(dev, ptr); 1164 } else { 1165 devres_free(ptr); 1166 } 1167 1168 return pwm; 1169 } 1170 EXPORT_SYMBOL_GPL(devm_pwm_get); 1171 1172 /** 1173 * devm_of_pwm_get() - resource managed of_pwm_get() 1174 * @dev: device for PWM consumer 1175 * @np: device node to get the PWM from 1176 * @con_id: consumer name 1177 * 1178 * This function performs like of_pwm_get() but the acquired PWM device will 1179 * automatically be released on driver detach. 1180 * 1181 * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded 1182 * error code on failure. 1183 */ 1184 struct pwm_device *devm_of_pwm_get(struct device *dev, struct device_node *np, 1185 const char *con_id) 1186 { 1187 struct pwm_device **ptr, *pwm; 1188 1189 ptr = devres_alloc(devm_pwm_release, sizeof(*ptr), GFP_KERNEL); 1190 if (!ptr) 1191 return ERR_PTR(-ENOMEM); 1192 1193 pwm = of_pwm_get(dev, np, con_id); 1194 if (!IS_ERR(pwm)) { 1195 *ptr = pwm; 1196 devres_add(dev, ptr); 1197 } else { 1198 devres_free(ptr); 1199 } 1200 1201 return pwm; 1202 } 1203 EXPORT_SYMBOL_GPL(devm_of_pwm_get); 1204 1205 /** 1206 * devm_fwnode_pwm_get() - request a resource managed PWM from firmware node 1207 * @dev: device for PWM consumer 1208 * @fwnode: firmware node to get the PWM from 1209 * @con_id: consumer name 1210 * 1211 * Returns the PWM device parsed from the firmware node. See of_pwm_get() and 1212 * acpi_pwm_get() for a detailed description. 1213 * 1214 * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded 1215 * error code on failure. 1216 */ 1217 struct pwm_device *devm_fwnode_pwm_get(struct device *dev, 1218 struct fwnode_handle *fwnode, 1219 const char *con_id) 1220 { 1221 struct pwm_device **ptr, *pwm = ERR_PTR(-ENODEV); 1222 1223 ptr = devres_alloc(devm_pwm_release, sizeof(*ptr), GFP_KERNEL); 1224 if (!ptr) 1225 return ERR_PTR(-ENOMEM); 1226 1227 if (is_of_node(fwnode)) 1228 pwm = of_pwm_get(dev, to_of_node(fwnode), con_id); 1229 else if (is_acpi_node(fwnode)) 1230 pwm = acpi_pwm_get(fwnode); 1231 1232 if (!IS_ERR(pwm)) { 1233 *ptr = pwm; 1234 devres_add(dev, ptr); 1235 } else { 1236 devres_free(ptr); 1237 } 1238 1239 return pwm; 1240 } 1241 EXPORT_SYMBOL_GPL(devm_fwnode_pwm_get); 1242 1243 static int devm_pwm_match(struct device *dev, void *res, void *data) 1244 { 1245 struct pwm_device **p = res; 1246 1247 if (WARN_ON(!p || !*p)) 1248 return 0; 1249 1250 return *p == data; 1251 } 1252 1253 /** 1254 * devm_pwm_put() - resource managed pwm_put() 1255 * @dev: device for PWM consumer 1256 * @pwm: PWM device 1257 * 1258 * Release a PWM previously allocated using devm_pwm_get(). Calling this 1259 * function is usually not needed because devm-allocated resources are 1260 * automatically released on driver detach. 1261 */ 1262 void devm_pwm_put(struct device *dev, struct pwm_device *pwm) 1263 { 1264 WARN_ON(devres_release(dev, devm_pwm_release, devm_pwm_match, pwm)); 1265 } 1266 EXPORT_SYMBOL_GPL(devm_pwm_put); 1267 1268 #ifdef CONFIG_DEBUG_FS 1269 static void pwm_dbg_show(struct pwm_chip *chip, struct seq_file *s) 1270 { 1271 unsigned int i; 1272 1273 for (i = 0; i < chip->npwm; i++) { 1274 struct pwm_device *pwm = &chip->pwms[i]; 1275 struct pwm_state state; 1276 1277 pwm_get_state(pwm, &state); 1278 1279 seq_printf(s, " pwm-%-3d (%-20.20s):", i, pwm->label); 1280 1281 if (test_bit(PWMF_REQUESTED, &pwm->flags)) 1282 seq_puts(s, " requested"); 1283 1284 if (state.enabled) 1285 seq_puts(s, " enabled"); 1286 1287 seq_printf(s, " period: %llu ns", state.period); 1288 seq_printf(s, " duty: %llu ns", state.duty_cycle); 1289 seq_printf(s, " polarity: %s", 1290 state.polarity ? "inverse" : "normal"); 1291 1292 seq_puts(s, "\n"); 1293 } 1294 } 1295 1296 static void *pwm_seq_start(struct seq_file *s, loff_t *pos) 1297 { 1298 mutex_lock(&pwm_lock); 1299 s->private = ""; 1300 1301 return seq_list_start(&pwm_chips, *pos); 1302 } 1303 1304 static void *pwm_seq_next(struct seq_file *s, void *v, loff_t *pos) 1305 { 1306 s->private = "\n"; 1307 1308 return seq_list_next(v, &pwm_chips, pos); 1309 } 1310 1311 static void pwm_seq_stop(struct seq_file *s, void *v) 1312 { 1313 mutex_unlock(&pwm_lock); 1314 } 1315 1316 static int pwm_seq_show(struct seq_file *s, void *v) 1317 { 1318 struct pwm_chip *chip = list_entry(v, struct pwm_chip, list); 1319 1320 seq_printf(s, "%s%s/%s, %d PWM device%s\n", (char *)s->private, 1321 chip->dev->bus ? chip->dev->bus->name : "no-bus", 1322 dev_name(chip->dev), chip->npwm, 1323 (chip->npwm != 1) ? "s" : ""); 1324 1325 pwm_dbg_show(chip, s); 1326 1327 return 0; 1328 } 1329 1330 static const struct seq_operations pwm_seq_ops = { 1331 .start = pwm_seq_start, 1332 .next = pwm_seq_next, 1333 .stop = pwm_seq_stop, 1334 .show = pwm_seq_show, 1335 }; 1336 1337 static int pwm_seq_open(struct inode *inode, struct file *file) 1338 { 1339 return seq_open(file, &pwm_seq_ops); 1340 } 1341 1342 static const struct file_operations pwm_debugfs_ops = { 1343 .owner = THIS_MODULE, 1344 .open = pwm_seq_open, 1345 .read = seq_read, 1346 .llseek = seq_lseek, 1347 .release = seq_release, 1348 }; 1349 1350 static int __init pwm_debugfs_init(void) 1351 { 1352 debugfs_create_file("pwm", S_IFREG | S_IRUGO, NULL, NULL, 1353 &pwm_debugfs_ops); 1354 1355 return 0; 1356 } 1357 subsys_initcall(pwm_debugfs_init); 1358 #endif /* CONFIG_DEBUG_FS */ 1359