drivers/pwm/core.c

   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/idr.h>
  12 #include <linux/of.h>
  13 #include <linux/pwm.h>
  14 #include <linux/list.h>
  15 #include <linux/mutex.h>
  16 #include <linux/err.h>
  17 #include <linux/slab.h>
  18 #include <linux/device.h>
  19 #include <linux/debugfs.h>
  20 #include <linux/seq_file.h>
  21
  22 #include <dt-bindings/pwm/pwm.h>
  23
  24 #define CREATE_TRACE_POINTS
  25 #include <trace/events/pwm.h>
  26
  27 static DEFINE_MUTEX(pwm_lookup_lock);
  28 static LIST_HEAD(pwm_lookup_list);
  29
  30 /* protects access to pwm_chips */
  31 static DEFINE_MUTEX(pwm_lock);
  32
  33 static DEFINE_IDR(pwm_chips);
  34
  35 static struct pwm_chip *pwmchip_find_by_name(const char *name)
  36 {
  37         struct pwm_chip *chip;
  38         unsigned long id, tmp;
  39
  40         if (!name)
  41                 return NULL;
  42
  43         mutex_lock(&pwm_lock);
  44
  45         idr_for_each_entry_ul(&pwm_chips, chip, tmp, id) {
  46                 const char *chip_name = dev_name(chip->dev);
  47
  48                 if (chip_name && strcmp(chip_name, name) == 0) {
  49                         mutex_unlock(&pwm_lock);
  50                         return chip;
  51                 }
  52         }
  53
  54         mutex_unlock(&pwm_lock);
  55
  56         return NULL;
  57 }
  58
  59 static int pwm_device_request(struct pwm_device *pwm, const char *label)
  60 {
  61         int err;
  62         struct pwm_chip *chip = pwm->chip;
  63         const struct pwm_ops *ops = chip->ops;
  64
  65         if (test_bit(PWMF_REQUESTED, &pwm->flags))
  66                 return -EBUSY;
  67
  68         if (!try_module_get(chip->owner))
  69                 return -ENODEV;
  70
  71         if (ops->request) {
  72                 err = ops->request(chip, pwm);
  73                 if (err) {
  74                         module_put(chip->owner);
  75                         return err;
  76                 }
  77         }
  78
  79         if (ops->get_state) {
  80                 /*
  81                  * Zero-initialize state because most drivers are unaware of
  82                  * .usage_power. The other members of state are supposed to be
  83                  * set by lowlevel drivers. We still initialize the whole
  84                  * structure for simplicity even though this might paper over
  85                  * faulty implementations of .get_state().
  86                  */
  87                 struct pwm_state state = { 0, };
  88
  89                 err = ops->get_state(chip, pwm, &state);
  90                 trace_pwm_get(pwm, &state, err);
  91
  92                 if (!err)
  93                         pwm->state = state;
  94
  95                 if (IS_ENABLED(CONFIG_PWM_DEBUG))
  96                         pwm->last = pwm->state;
  97         }
  98
  99         set_bit(PWMF_REQUESTED, &pwm->flags);
 100         pwm->label = label;
 101
 102         return 0;
 103 }
 104
 105 struct pwm_device *
 106 of_pwm_xlate_with_flags(struct pwm_chip *chip, const struct of_phandle_args *args)
 107 {
 108         struct pwm_device *pwm;
 109
 110         /* period in the second cell and flags in the third cell are optional */
 111         if (args->args_count < 1)
 112                 return ERR_PTR(-EINVAL);
 113
 114         pwm = pwm_request_from_chip(chip, args->args[0], NULL);
 115         if (IS_ERR(pwm))
 116                 return pwm;
 117
 118         if (args->args_count > 1)
 119                 pwm->args.period = args->args[1];
 120
 121         pwm->args.polarity = PWM_POLARITY_NORMAL;
 122         if (args->args_count > 2 && args->args[2] & PWM_POLARITY_INVERTED)
 123                 pwm->args.polarity = PWM_POLARITY_INVERSED;
 124
 125         return pwm;
 126 }
 127 EXPORT_SYMBOL_GPL(of_pwm_xlate_with_flags);
 128
 129 struct pwm_device *
 130 of_pwm_single_xlate(struct pwm_chip *chip, const struct of_phandle_args *args)
 131 {
 132         struct pwm_device *pwm;
 133
 134         pwm = pwm_request_from_chip(chip, 0, NULL);
 135         if (IS_ERR(pwm))
 136                 return pwm;
 137
 138         if (args->args_count > 1)
 139                 pwm->args.period = args->args[0];
 140
 141         pwm->args.polarity = PWM_POLARITY_NORMAL;
 142         if (args->args_count > 1 && args->args[1] & PWM_POLARITY_INVERTED)
 143                 pwm->args.polarity = PWM_POLARITY_INVERSED;
 144
 145         return pwm;
 146 }
 147 EXPORT_SYMBOL_GPL(of_pwm_single_xlate);
 148
 149 static void of_pwmchip_add(struct pwm_chip *chip)
 150 {
 151         if (!chip->dev || !chip->dev->of_node)
 152                 return;
 153
 154         if (!chip->of_xlate)
 155                 chip->of_xlate = of_pwm_xlate_with_flags;
 156
 157         of_node_get(chip->dev->of_node);
 158 }
 159
 160 static void of_pwmchip_remove(struct pwm_chip *chip)
 161 {
 162         if (chip->dev)
 163                 of_node_put(chip->dev->of_node);
 164 }
 165
 166 static bool pwm_ops_check(const struct pwm_chip *chip)
 167 {
 168         const struct pwm_ops *ops = chip->ops;
 169
 170         if (!ops->apply)
 171                 return false;
 172
 173         if (IS_ENABLED(CONFIG_PWM_DEBUG) && !ops->get_state)
 174                 dev_warn(chip->dev,
 175                          "Please implement the .get_state() callback\n");
 176
 177         return true;
 178 }
 179
 180 /**
 181  * __pwmchip_add() - register a new PWM chip
 182  * @chip: the PWM chip to add
 183  * @owner: reference to the module providing the chip.
 184  *
 185  * Register a new PWM chip. @owner is supposed to be THIS_MODULE, use the
 186  * pwmchip_add wrapper to do this right.
 187  *
 188  * Returns: 0 on success or a negative error code on failure.
 189  */
 190 int __pwmchip_add(struct pwm_chip *chip, struct module *owner)
 191 {
 192         unsigned int i;
 193         int ret;
 194
 195         if (!chip || !chip->dev || !chip->ops || !chip->npwm)
 196                 return -EINVAL;
 197
 198         if (!pwm_ops_check(chip))
 199                 return -EINVAL;
 200
 201         chip->owner = owner;
 202
 203         chip->pwms = kcalloc(chip->npwm, sizeof(*chip->pwms), GFP_KERNEL);
 204         if (!chip->pwms)
 205                 return -ENOMEM;
 206
 207         mutex_lock(&pwm_lock);
 208
 209         ret = idr_alloc(&pwm_chips, chip, 0, 0, GFP_KERNEL);
 210         if (ret < 0) {
 211                 mutex_unlock(&pwm_lock);
 212                 kfree(chip->pwms);
 213                 return ret;
 214         }
 215
 216         chip->id = ret;
 217
 218         for (i = 0; i < chip->npwm; i++) {
 219                 struct pwm_device *pwm = &chip->pwms[i];
 220
 221                 pwm->chip = chip;
 222                 pwm->hwpwm = i;
 223         }
 224
 225         mutex_unlock(&pwm_lock);
 226
 227         if (IS_ENABLED(CONFIG_OF))
 228                 of_pwmchip_add(chip);
 229
 230         pwmchip_sysfs_export(chip);
 231
 232         return 0;
 233 }
 234 EXPORT_SYMBOL_GPL(__pwmchip_add);
 235
 236 /**
 237  * pwmchip_remove() - remove a PWM chip
 238  * @chip: the PWM chip to remove
 239  *
 240  * Removes a PWM chip.
 241  */
 242 void pwmchip_remove(struct pwm_chip *chip)
 243 {
 244         pwmchip_sysfs_unexport(chip);
 245
 246         if (IS_ENABLED(CONFIG_OF))
 247                 of_pwmchip_remove(chip);
 248
 249         mutex_lock(&pwm_lock);
 250
 251         idr_remove(&pwm_chips, chip->id);
 252
 253         mutex_unlock(&pwm_lock);
 254
 255         kfree(chip->pwms);
 256 }
 257 EXPORT_SYMBOL_GPL(pwmchip_remove);
 258
 259 static void devm_pwmchip_remove(void *data)
 260 {
 261         struct pwm_chip *chip = data;
 262
 263         pwmchip_remove(chip);
 264 }
 265
 266 int __devm_pwmchip_add(struct device *dev, struct pwm_chip *chip, struct module *owner)
 267 {
 268         int ret;
 269
 270         ret = __pwmchip_add(chip, owner);
 271         if (ret)
 272                 return ret;
 273
 274         return devm_add_action_or_reset(dev, devm_pwmchip_remove, chip);
 275 }
 276 EXPORT_SYMBOL_GPL(__devm_pwmchip_add);
 277
 278 /**
 279  * pwm_request_from_chip() - request a PWM device relative to a PWM chip
 280  * @chip: PWM chip
 281  * @index: per-chip index of the PWM to request
 282  * @label: a literal description string of this PWM
 283  *
 284  * Returns: A pointer to the PWM device at the given index of the given PWM
 285  * chip. A negative error code is returned if the index is not valid for the
 286  * specified PWM chip or if the PWM device cannot be requested.
 287  */
 288 struct pwm_device *pwm_request_from_chip(struct pwm_chip *chip,
 289                                          unsigned int index,
 290                                          const char *label)
 291 {
 292         struct pwm_device *pwm;
 293         int err;
 294
 295         if (!chip || index >= chip->npwm)
 296                 return ERR_PTR(-EINVAL);
 297
 298         mutex_lock(&pwm_lock);
 299         pwm = &chip->pwms[index];
 300
 301         err = pwm_device_request(pwm, label);
 302         if (err < 0)
 303                 pwm = ERR_PTR(err);
 304
 305         mutex_unlock(&pwm_lock);
 306         return pwm;
 307 }
 308 EXPORT_SYMBOL_GPL(pwm_request_from_chip);
 309
 310 static void pwm_apply_debug(struct pwm_device *pwm,
 311                             const struct pwm_state *state)
 312 {
 313         struct pwm_state *last = &pwm->last;
 314         struct pwm_chip *chip = pwm->chip;
 315         struct pwm_state s1 = { 0 }, s2 = { 0 };
 316         int err;
 317
 318         if (!IS_ENABLED(CONFIG_PWM_DEBUG))
 319                 return;
 320
 321         /* No reasonable diagnosis possible without .get_state() */
 322         if (!chip->ops->get_state)
 323                 return;
 324
 325         /*
 326          * *state was just applied. Read out the hardware state and do some
 327          * checks.
 328          */
 329
 330         err = chip->ops->get_state(chip, pwm, &s1);
 331         trace_pwm_get(pwm, &s1, err);
 332         if (err)
 333                 /* If that failed there isn't much to debug */
 334                 return;
 335
 336         /*
 337          * The lowlevel driver either ignored .polarity (which is a bug) or as
 338          * best effort inverted .polarity and fixed .duty_cycle respectively.
 339          * Undo this inversion and fixup for further tests.
 340          */
 341         if (s1.enabled && s1.polarity != state->polarity) {
 342                 s2.polarity = state->polarity;
 343                 s2.duty_cycle = s1.period - s1.duty_cycle;
 344                 s2.period = s1.period;
 345                 s2.enabled = s1.enabled;
 346         } else {
 347                 s2 = s1;
 348         }
 349
 350         if (s2.polarity != state->polarity &&
 351             state->duty_cycle < state->period)
 352                 dev_warn(chip->dev, ".apply ignored .polarity\n");
 353
 354         if (state->enabled &&
 355             last->polarity == state->polarity &&
 356             last->period > s2.period &&
 357             last->period <= state->period)
 358                 dev_warn(chip->dev,
 359                          ".apply didn't pick the best available period (requested: %llu, applied: %llu, possible: %llu)\n",
 360                          state->period, s2.period, last->period);
 361
 362         if (state->enabled && state->period < s2.period)
 363                 dev_warn(chip->dev,
 364                          ".apply is supposed to round down period (requested: %llu, applied: %llu)\n",
 365                          state->period, s2.period);
 366
 367         if (state->enabled &&
 368             last->polarity == state->polarity &&
 369             last->period == s2.period &&
 370             last->duty_cycle > s2.duty_cycle &&
 371             last->duty_cycle <= state->duty_cycle)
 372                 dev_warn(chip->dev,
 373                          ".apply didn't pick the best available duty cycle (requested: %llu/%llu, applied: %llu/%llu, possible: %llu/%llu)\n",
 374                          state->duty_cycle, state->period,
 375                          s2.duty_cycle, s2.period,
 376                          last->duty_cycle, last->period);
 377
 378         if (state->enabled && state->duty_cycle < s2.duty_cycle)
 379                 dev_warn(chip->dev,
 380                          ".apply is supposed to round down duty_cycle (requested: %llu/%llu, applied: %llu/%llu)\n",
 381                          state->duty_cycle, state->period,
 382                          s2.duty_cycle, s2.period);
 383
 384         if (!state->enabled && s2.enabled && s2.duty_cycle > 0)
 385                 dev_warn(chip->dev,
 386                          "requested disabled, but yielded enabled with duty > 0\n");
 387
 388         /* reapply the state that the driver reported being configured. */
 389         err = chip->ops->apply(chip, pwm, &s1);
 390         trace_pwm_apply(pwm, &s1, err);
 391         if (err) {
 392                 *last = s1;
 393                 dev_err(chip->dev, "failed to reapply current setting\n");
 394                 return;
 395         }
 396
 397         *last = (struct pwm_state){ 0 };
 398         err = chip->ops->get_state(chip, pwm, last);
 399         trace_pwm_get(pwm, last, err);
 400         if (err)
 401                 return;
 402
 403         /* reapplication of the current state should give an exact match */
 404         if (s1.enabled != last->enabled ||
 405             s1.polarity != last->polarity ||
 406             (s1.enabled && s1.period != last->period) ||
 407             (s1.enabled && s1.duty_cycle != last->duty_cycle)) {
 408                 dev_err(chip->dev,
 409                         ".apply is not idempotent (ena=%d pol=%d %llu/%llu) -> (ena=%d pol=%d %llu/%llu)\n",
 410                         s1.enabled, s1.polarity, s1.duty_cycle, s1.period,
 411                         last->enabled, last->polarity, last->duty_cycle,
 412                         last->period);
 413         }
 414 }
 415
 416 /**
 417  * __pwm_apply() - atomically apply a new state to a PWM device
 418  * @pwm: PWM device
 419  * @state: new state to apply
 420  */
 421 static int __pwm_apply(struct pwm_device *pwm, const struct pwm_state *state)
 422 {
 423         struct pwm_chip *chip;
 424         int err;
 425
 426         if (!pwm || !state || !state->period ||
 427             state->duty_cycle > state->period)
 428                 return -EINVAL;
 429
 430         chip = pwm->chip;
 431
 432         if (state->period == pwm->state.period &&
 433             state->duty_cycle == pwm->state.duty_cycle &&
 434             state->polarity == pwm->state.polarity &&
 435             state->enabled == pwm->state.enabled &&
 436             state->usage_power == pwm->state.usage_power)
 437                 return 0;
 438
 439         err = chip->ops->apply(chip, pwm, state);
 440         trace_pwm_apply(pwm, state, err);
 441         if (err)
 442                 return err;
 443
 444         pwm->state = *state;
 445
 446         /*
 447          * only do this after pwm->state was applied as some
 448          * implementations of .get_state depend on this
 449          */
 450         pwm_apply_debug(pwm, state);
 451
 452         return 0;
 453 }
 454
 455 /**
 456  * pwm_apply_might_sleep() - atomically apply a new state to a PWM device
 457  * Cannot be used in atomic context.
 458  * @pwm: PWM device
 459  * @state: new state to apply
 460  */
 461 int pwm_apply_might_sleep(struct pwm_device *pwm, const struct pwm_state *state)
 462 {
 463         int err;
 464
 465         /*
 466          * Some lowlevel driver's implementations of .apply() make use of
 467          * mutexes, also with some drivers only returning when the new
 468          * configuration is active calling pwm_apply_might_sleep() from atomic context
 469          * is a bad idea. So make it explicit that calling this function might
 470          * sleep.
 471          */
 472         might_sleep();
 473
 474         if (IS_ENABLED(CONFIG_PWM_DEBUG) && pwm->chip->atomic) {
 475                 /*
 476                  * Catch any drivers that have been marked as atomic but
 477                  * that will sleep anyway.
 478                  */
 479                 non_block_start();
 480                 err = __pwm_apply(pwm, state);
 481                 non_block_end();
 482         } else {
 483                 err = __pwm_apply(pwm, state);
 484         }
 485
 486         return err;
 487 }
 488 EXPORT_SYMBOL_GPL(pwm_apply_might_sleep);
 489
 490 /**
 491  * pwm_apply_atomic() - apply a new state to a PWM device from atomic context
 492  * Not all PWM devices support this function, check with pwm_might_sleep().
 493  * @pwm: PWM device
 494  * @state: new state to apply
 495  */
 496 int pwm_apply_atomic(struct pwm_device *pwm, const struct pwm_state *state)
 497 {
 498         WARN_ONCE(!pwm->chip->atomic,
 499                   "sleeping PWM driver used in atomic context\n");
 500
 501         return __pwm_apply(pwm, state);
 502 }
 503 EXPORT_SYMBOL_GPL(pwm_apply_atomic);
 504
 505 /**
 506  * pwm_capture() - capture and report a PWM signal
 507  * @pwm: PWM device
 508  * @result: structure to fill with capture result
 509  * @timeout: time to wait, in milliseconds, before giving up on capture
 510  *
 511  * Returns: 0 on success or a negative error code on failure.
 512  */
 513 int pwm_capture(struct pwm_device *pwm, struct pwm_capture *result,
 514                 unsigned long timeout)
 515 {
 516         int err;
 517
 518         if (!pwm || !pwm->chip->ops)
 519                 return -EINVAL;
 520
 521         if (!pwm->chip->ops->capture)
 522                 return -ENOSYS;
 523
 524         mutex_lock(&pwm_lock);
 525         err = pwm->chip->ops->capture(pwm->chip, pwm, result, timeout);
 526         mutex_unlock(&pwm_lock);
 527
 528         return err;
 529 }
 530 EXPORT_SYMBOL_GPL(pwm_capture);
 531
 532 /**
 533  * pwm_adjust_config() - adjust the current PWM config to the PWM arguments
 534  * @pwm: PWM device
 535  *
 536  * This function will adjust the PWM config to the PWM arguments provided
 537  * by the DT or PWM lookup table. This is particularly useful to adapt
 538  * the bootloader config to the Linux one.
 539  */
 540 int pwm_adjust_config(struct pwm_device *pwm)
 541 {
 542         struct pwm_state state;
 543         struct pwm_args pargs;
 544
 545         pwm_get_args(pwm, &pargs);
 546         pwm_get_state(pwm, &state);
 547
 548         /*
 549          * If the current period is zero it means that either the PWM driver
 550          * does not support initial state retrieval or the PWM has not yet
 551          * been configured.
 552          *
 553          * In either case, we setup the new period and polarity, and assign a
 554          * duty cycle of 0.
 555          */
 556         if (!state.period) {
 557                 state.duty_cycle = 0;
 558                 state.period = pargs.period;
 559                 state.polarity = pargs.polarity;
 560
 561                 return pwm_apply_might_sleep(pwm, &state);
 562         }
 563
 564         /*
 565          * Adjust the PWM duty cycle/period based on the period value provided
 566          * in PWM args.
 567          */
 568         if (pargs.period != state.period) {
 569                 u64 dutycycle = (u64)state.duty_cycle * pargs.period;
 570
 571                 do_div(dutycycle, state.period);
 572                 state.duty_cycle = dutycycle;
 573                 state.period = pargs.period;
 574         }
 575
 576         /*
 577          * If the polarity changed, we should also change the duty cycle.
 578          */
 579         if (pargs.polarity != state.polarity) {
 580                 state.polarity = pargs.polarity;
 581                 state.duty_cycle = state.period - state.duty_cycle;
 582         }
 583
 584         return pwm_apply_might_sleep(pwm, &state);
 585 }
 586 EXPORT_SYMBOL_GPL(pwm_adjust_config);
 587
 588 static struct pwm_chip *fwnode_to_pwmchip(struct fwnode_handle *fwnode)
 589 {
 590         struct pwm_chip *chip;
 591         unsigned long id, tmp;
 592
 593         mutex_lock(&pwm_lock);
 594
 595         idr_for_each_entry_ul(&pwm_chips, chip, tmp, id)
 596                 if (chip->dev && device_match_fwnode(chip->dev, fwnode)) {
 597                         mutex_unlock(&pwm_lock);
 598                         return chip;
 599                 }
 600
 601         mutex_unlock(&pwm_lock);
 602
 603         return ERR_PTR(-EPROBE_DEFER);
 604 }
 605
 606 static struct device_link *pwm_device_link_add(struct device *dev,
 607                                                struct pwm_device *pwm)
 608 {
 609         struct device_link *dl;
 610
 611         if (!dev) {
 612                 /*
 613                  * No device for the PWM consumer has been provided. It may
 614                  * impact the PM sequence ordering: the PWM supplier may get
 615                  * suspended before the consumer.
 616                  */
 617                 dev_warn(pwm->chip->dev,
 618                          "No consumer device specified to create a link to\n");
 619                 return NULL;
 620         }
 621
 622         dl = device_link_add(dev, pwm->chip->dev, DL_FLAG_AUTOREMOVE_CONSUMER);
 623         if (!dl) {
 624                 dev_err(dev, "failed to create device link to %s\n",
 625                         dev_name(pwm->chip->dev));
 626                 return ERR_PTR(-EINVAL);
 627         }
 628
 629         return dl;
 630 }
 631
 632 /**
 633  * of_pwm_get() - request a PWM via the PWM framework
 634  * @dev: device for PWM consumer
 635  * @np: device node to get the PWM from
 636  * @con_id: consumer name
 637  *
 638  * Returns the PWM device parsed from the phandle and index specified in the
 639  * "pwms" property of a device tree node or a negative error-code on failure.
 640  * Values parsed from the device tree are stored in the returned PWM device
 641  * object.
 642  *
 643  * If con_id is NULL, the first PWM device listed in the "pwms" property will
 644  * be requested. Otherwise the "pwm-names" property is used to do a reverse
 645  * lookup of the PWM index. This also means that the "pwm-names" property
 646  * becomes mandatory for devices that look up the PWM device via the con_id
 647  * parameter.
 648  *
 649  * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded
 650  * error code on failure.
 651  */
 652 static struct pwm_device *of_pwm_get(struct device *dev, struct device_node *np,
 653                                      const char *con_id)
 654 {
 655         struct pwm_device *pwm = NULL;
 656         struct of_phandle_args args;
 657         struct device_link *dl;
 658         struct pwm_chip *chip;
 659         int index = 0;
 660         int err;
 661
 662         if (con_id) {
 663                 index = of_property_match_string(np, "pwm-names", con_id);
 664                 if (index < 0)
 665                         return ERR_PTR(index);
 666         }
 667
 668         err = of_parse_phandle_with_args(np, "pwms", "#pwm-cells", index,
 669                                          &args);
 670         if (err) {
 671                 pr_err("%s(): can't parse \"pwms\" property\n", __func__);
 672                 return ERR_PTR(err);
 673         }
 674
 675         chip = fwnode_to_pwmchip(of_fwnode_handle(args.np));
 676         if (IS_ERR(chip)) {
 677                 if (PTR_ERR(chip) != -EPROBE_DEFER)
 678                         pr_err("%s(): PWM chip not found\n", __func__);
 679
 680                 pwm = ERR_CAST(chip);
 681                 goto put;
 682         }
 683
 684         pwm = chip->of_xlate(chip, &args);
 685         if (IS_ERR(pwm))
 686                 goto put;
 687
 688         dl = pwm_device_link_add(dev, pwm);
 689         if (IS_ERR(dl)) {
 690                 /* of_xlate ended up calling pwm_request_from_chip() */
 691                 pwm_put(pwm);
 692                 pwm = ERR_CAST(dl);
 693                 goto put;
 694         }
 695
 696         /*
 697          * If a consumer name was not given, try to look it up from the
 698          * "pwm-names" property if it exists. Otherwise use the name of
 699          * the user device node.
 700          */
 701         if (!con_id) {
 702                 err = of_property_read_string_index(np, "pwm-names", index,
 703                                                     &con_id);
 704                 if (err < 0)
 705                         con_id = np->name;
 706         }
 707
 708         pwm->label = con_id;
 709
 710 put:
 711         of_node_put(args.np);
 712
 713         return pwm;
 714 }
 715
 716 /**
 717  * acpi_pwm_get() - request a PWM via parsing "pwms" property in ACPI
 718  * @fwnode: firmware node to get the "pwms" property from
 719  *
 720  * Returns the PWM device parsed from the fwnode and index specified in the
 721  * "pwms" property or a negative error-code on failure.
 722  * Values parsed from the device tree are stored in the returned PWM device
 723  * object.
 724  *
 725  * This is analogous to of_pwm_get() except con_id is not yet supported.
 726  * ACPI entries must look like
 727  * Package () {"pwms", Package ()
 728  *     { <PWM device reference>, <PWM index>, <PWM period> [, <PWM flags>]}}
 729  *
 730  * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded
 731  * error code on failure.
 732  */
 733 static struct pwm_device *acpi_pwm_get(const struct fwnode_handle *fwnode)
 734 {
 735         struct pwm_device *pwm;
 736         struct fwnode_reference_args args;
 737         struct pwm_chip *chip;
 738         int ret;
 739
 740         memset(&args, 0, sizeof(args));
 741
 742         ret = __acpi_node_get_property_reference(fwnode, "pwms", 0, 3, &args);
 743         if (ret < 0)
 744                 return ERR_PTR(ret);
 745
 746         if (args.nargs < 2)
 747                 return ERR_PTR(-EPROTO);
 748
 749         chip = fwnode_to_pwmchip(args.fwnode);
 750         if (IS_ERR(chip))
 751                 return ERR_CAST(chip);
 752
 753         pwm = pwm_request_from_chip(chip, args.args[0], NULL);
 754         if (IS_ERR(pwm))
 755                 return pwm;
 756
 757         pwm->args.period = args.args[1];
 758         pwm->args.polarity = PWM_POLARITY_NORMAL;
 759
 760         if (args.nargs > 2 && args.args[2] & PWM_POLARITY_INVERTED)
 761                 pwm->args.polarity = PWM_POLARITY_INVERSED;
 762
 763         return pwm;
 764 }
 765
 766 /**
 767  * pwm_add_table() - register PWM device consumers
 768  * @table: array of consumers to register
 769  * @num: number of consumers in table
 770  */
 771 void pwm_add_table(struct pwm_lookup *table, size_t num)
 772 {
 773         mutex_lock(&pwm_lookup_lock);
 774
 775         while (num--) {
 776                 list_add_tail(&table->list, &pwm_lookup_list);
 777                 table++;
 778         }
 779
 780         mutex_unlock(&pwm_lookup_lock);
 781 }
 782
 783 /**
 784  * pwm_remove_table() - unregister PWM device consumers
 785  * @table: array of consumers to unregister
 786  * @num: number of consumers in table
 787  */
 788 void pwm_remove_table(struct pwm_lookup *table, size_t num)
 789 {
 790         mutex_lock(&pwm_lookup_lock);
 791
 792         while (num--) {
 793                 list_del(&table->list);
 794                 table++;
 795         }
 796
 797         mutex_unlock(&pwm_lookup_lock);
 798 }
 799
 800 /**
 801  * pwm_get() - look up and request a PWM device
 802  * @dev: device for PWM consumer
 803  * @con_id: consumer name
 804  *
 805  * Lookup is first attempted using DT. If the device was not instantiated from
 806  * a device tree, a PWM chip and a relative index is looked up via a table
 807  * supplied by board setup code (see pwm_add_table()).
 808  *
 809  * Once a PWM chip has been found the specified PWM device will be requested
 810  * and is ready to be used.
 811  *
 812  * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded
 813  * error code on failure.
 814  */
 815 struct pwm_device *pwm_get(struct device *dev, const char *con_id)
 816 {
 817         const struct fwnode_handle *fwnode = dev ? dev_fwnode(dev) : NULL;
 818         const char *dev_id = dev ? dev_name(dev) : NULL;
 819         struct pwm_device *pwm;
 820         struct pwm_chip *chip;
 821         struct device_link *dl;
 822         unsigned int best = 0;
 823         struct pwm_lookup *p, *chosen = NULL;
 824         unsigned int match;
 825         int err;
 826
 827         /* look up via DT first */
 828         if (is_of_node(fwnode))
 829                 return of_pwm_get(dev, to_of_node(fwnode), con_id);
 830
 831         /* then lookup via ACPI */
 832         if (is_acpi_node(fwnode)) {
 833                 pwm = acpi_pwm_get(fwnode);
 834                 if (!IS_ERR(pwm) || PTR_ERR(pwm) != -ENOENT)
 835                         return pwm;
 836         }
 837
 838         /*
 839          * We look up the provider in the static table typically provided by
 840          * board setup code. We first try to lookup the consumer device by
 841          * name. If the consumer device was passed in as NULL or if no match
 842          * was found, we try to find the consumer by directly looking it up
 843          * by name.
 844          *
 845          * If a match is found, the provider PWM chip is looked up by name
 846          * and a PWM device is requested using the PWM device per-chip index.
 847          *
 848          * The lookup algorithm was shamelessly taken from the clock
 849          * framework:
 850          *
 851          * We do slightly fuzzy matching here:
 852          *  An entry with a NULL ID is assumed to be a wildcard.
 853          *  If an entry has a device ID, it must match
 854          *  If an entry has a connection ID, it must match
 855          * Then we take the most specific entry - with the following order
 856          * of precedence: dev+con > dev only > con only.
 857          */
 858         mutex_lock(&pwm_lookup_lock);
 859
 860         list_for_each_entry(p, &pwm_lookup_list, list) {
 861                 match = 0;
 862
 863                 if (p->dev_id) {
 864                         if (!dev_id || strcmp(p->dev_id, dev_id))
 865                                 continue;
 866
 867                         match += 2;
 868                 }
 869
 870                 if (p->con_id) {
 871                         if (!con_id || strcmp(p->con_id, con_id))
 872                                 continue;
 873
 874                         match += 1;
 875                 }
 876
 877                 if (match > best) {
 878                         chosen = p;
 879
 880                         if (match != 3)
 881                                 best = match;
 882                         else
 883                                 break;
 884                 }
 885         }
 886
 887         mutex_unlock(&pwm_lookup_lock);
 888
 889         if (!chosen)
 890                 return ERR_PTR(-ENODEV);
 891
 892         chip = pwmchip_find_by_name(chosen->provider);
 893
 894         /*
 895          * If the lookup entry specifies a module, load the module and retry
 896          * the PWM chip lookup. This can be used to work around driver load
 897          * ordering issues if driver's can't be made to properly support the
 898          * deferred probe mechanism.
 899          */
 900         if (!chip && chosen->module) {
 901                 err = request_module(chosen->module);
 902                 if (err == 0)
 903                         chip = pwmchip_find_by_name(chosen->provider);
 904         }
 905
 906         if (!chip)
 907                 return ERR_PTR(-EPROBE_DEFER);
 908
 909         pwm = pwm_request_from_chip(chip, chosen->index, con_id ?: dev_id);
 910         if (IS_ERR(pwm))
 911                 return pwm;
 912
 913         dl = pwm_device_link_add(dev, pwm);
 914         if (IS_ERR(dl)) {
 915                 pwm_put(pwm);
 916                 return ERR_CAST(dl);
 917         }
 918
 919         pwm->args.period = chosen->period;
 920         pwm->args.polarity = chosen->polarity;
 921
 922         return pwm;
 923 }
 924 EXPORT_SYMBOL_GPL(pwm_get);
 925
 926 /**
 927  * pwm_put() - release a PWM device
 928  * @pwm: PWM device
 929  */
 930 void pwm_put(struct pwm_device *pwm)
 931 {
 932         if (!pwm)
 933                 return;
 934
 935         mutex_lock(&pwm_lock);
 936
 937         if (!test_and_clear_bit(PWMF_REQUESTED, &pwm->flags)) {
 938                 pr_warn("PWM device already freed\n");
 939                 goto out;
 940         }
 941
 942         if (pwm->chip->ops->free)
 943                 pwm->chip->ops->free(pwm->chip, pwm);
 944
 945         pwm->label = NULL;
 946
 947         module_put(pwm->chip->owner);
 948 out:
 949         mutex_unlock(&pwm_lock);
 950 }
 951 EXPORT_SYMBOL_GPL(pwm_put);
 952
 953 static void devm_pwm_release(void *pwm)
 954 {
 955         pwm_put(pwm);
 956 }
 957
 958 /**
 959  * devm_pwm_get() - resource managed pwm_get()
 960  * @dev: device for PWM consumer
 961  * @con_id: consumer name
 962  *
 963  * This function performs like pwm_get() but the acquired PWM device will
 964  * automatically be released on driver detach.
 965  *
 966  * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded
 967  * error code on failure.
 968  */
 969 struct pwm_device *devm_pwm_get(struct device *dev, const char *con_id)
 970 {
 971         struct pwm_device *pwm;
 972         int ret;
 973
 974         pwm = pwm_get(dev, con_id);
 975         if (IS_ERR(pwm))
 976                 return pwm;
 977
 978         ret = devm_add_action_or_reset(dev, devm_pwm_release, pwm);
 979         if (ret)
 980                 return ERR_PTR(ret);
 981
 982         return pwm;
 983 }
 984 EXPORT_SYMBOL_GPL(devm_pwm_get);
 985
 986 /**
 987  * devm_fwnode_pwm_get() - request a resource managed PWM from firmware node
 988  * @dev: device for PWM consumer
 989  * @fwnode: firmware node to get the PWM from
 990  * @con_id: consumer name
 991  *
 992  * Returns the PWM device parsed from the firmware node. See of_pwm_get() and
 993  * acpi_pwm_get() for a detailed description.
 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 *devm_fwnode_pwm_get(struct device *dev,
 999                                        struct fwnode_handle *fwnode,
1000                                        const char *con_id)
1001 {
1002         struct pwm_device *pwm = ERR_PTR(-ENODEV);
1003         int ret;
1004
1005         if (is_of_node(fwnode))
1006                 pwm = of_pwm_get(dev, to_of_node(fwnode), con_id);
1007         else if (is_acpi_node(fwnode))
1008                 pwm = acpi_pwm_get(fwnode);
1009         if (IS_ERR(pwm))
1010                 return pwm;
1011
1012         ret = devm_add_action_or_reset(dev, devm_pwm_release, pwm);
1013         if (ret)
1014                 return ERR_PTR(ret);
1015
1016         return pwm;
1017 }
1018 EXPORT_SYMBOL_GPL(devm_fwnode_pwm_get);
1019
1020 #ifdef CONFIG_DEBUG_FS
1021 static void pwm_dbg_show(struct pwm_chip *chip, struct seq_file *s)
1022 {
1023         unsigned int i;
1024
1025         for (i = 0; i < chip->npwm; i++) {
1026                 struct pwm_device *pwm = &chip->pwms[i];
1027                 struct pwm_state state;
1028
1029                 pwm_get_state(pwm, &state);
1030
1031                 seq_printf(s, " pwm-%-3d (%-20.20s):", i, pwm->label);
1032
1033                 if (test_bit(PWMF_REQUESTED, &pwm->flags))
1034                         seq_puts(s, " requested");
1035
1036                 if (state.enabled)
1037                         seq_puts(s, " enabled");
1038
1039                 seq_printf(s, " period: %llu ns", state.period);
1040                 seq_printf(s, " duty: %llu ns", state.duty_cycle);
1041                 seq_printf(s, " polarity: %s",
1042                            state.polarity ? "inverse" : "normal");
1043
1044                 if (state.usage_power)
1045                         seq_puts(s, " usage_power");
1046
1047                 seq_puts(s, "\n");
1048         }
1049 }
1050
1051 static void *pwm_seq_start(struct seq_file *s, loff_t *pos)
1052 {
1053         unsigned long id = *pos;
1054         void *ret;
1055
1056         mutex_lock(&pwm_lock);
1057         s->private = "";
1058
1059         ret = idr_get_next_ul(&pwm_chips, &id);
1060         *pos = id;
1061         return ret;
1062 }
1063
1064 static void *pwm_seq_next(struct seq_file *s, void *v, loff_t *pos)
1065 {
1066         unsigned long id = *pos + 1;
1067         void *ret;
1068
1069         s->private = "\n";
1070
1071         ret = idr_get_next_ul(&pwm_chips, &id);
1072         *pos = id;
1073         return ret;
1074 }
1075
1076 static void pwm_seq_stop(struct seq_file *s, void *v)
1077 {
1078         mutex_unlock(&pwm_lock);
1079 }
1080
1081 static int pwm_seq_show(struct seq_file *s, void *v)
1082 {
1083         struct pwm_chip *chip = v;
1084
1085         seq_printf(s, "%s%d: %s/%s, %d PWM device%s\n",
1086                    (char *)s->private, chip->id,
1087                    chip->dev->bus ? chip->dev->bus->name : "no-bus",
1088                    dev_name(chip->dev), chip->npwm,
1089                    (chip->npwm != 1) ? "s" : "");
1090
1091         pwm_dbg_show(chip, s);
1092
1093         return 0;
1094 }
1095
1096 static const struct seq_operations pwm_debugfs_sops = {
1097         .start = pwm_seq_start,
1098         .next = pwm_seq_next,
1099         .stop = pwm_seq_stop,
1100         .show = pwm_seq_show,
1101 };
1102
1103 DEFINE_SEQ_ATTRIBUTE(pwm_debugfs);
1104
1105 static int __init pwm_debugfs_init(void)
1106 {
1107         debugfs_create_file("pwm", 0444, NULL, NULL, &pwm_debugfs_fops);
1108
1109         return 0;
1110 }
1111 subsys_initcall(pwm_debugfs_init);
1112 #endif /* CONFIG_DEBUG_FS */