linux/drivers/pwm/core.c
<<
>>
Prefs
   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
  37static DEFINE_MUTEX(pwm_lookup_lock);
  38static LIST_HEAD(pwm_lookup_list);
  39static DEFINE_MUTEX(pwm_lock);
  40static LIST_HEAD(pwm_chips);
  41static DECLARE_BITMAP(allocated_pwms, MAX_PWMS);
  42static RADIX_TREE(pwm_tree, GFP_KERNEL);
  43
  44static struct pwm_device *pwm_to_device(unsigned int pwm)
  45{
  46        return radix_tree_lookup(&pwm_tree, pwm);
  47}
  48
  49static 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
  72static 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                radix_tree_delete(&pwm_tree, pwm->pwm);
  79        }
  80
  81        bitmap_clear(allocated_pwms, chip->base, chip->npwm);
  82
  83        kfree(chip->pwms);
  84        chip->pwms = NULL;
  85}
  86
  87static struct pwm_chip *pwmchip_find_by_name(const char *name)
  88{
  89        struct pwm_chip *chip;
  90
  91        if (!name)
  92                return NULL;
  93
  94        mutex_lock(&pwm_lock);
  95
  96        list_for_each_entry(chip, &pwm_chips, list) {
  97                const char *chip_name = dev_name(chip->dev);
  98
  99                if (chip_name && strcmp(chip_name, name) == 0) {
 100                        mutex_unlock(&pwm_lock);
 101                        return chip;
 102                }
 103        }
 104
 105        mutex_unlock(&pwm_lock);
 106
 107        return NULL;
 108}
 109
 110static int pwm_device_request(struct pwm_device *pwm, const char *label)
 111{
 112        int err;
 113
 114        if (test_bit(PWMF_REQUESTED, &pwm->flags))
 115                return -EBUSY;
 116
 117        if (!try_module_get(pwm->chip->ops->owner))
 118                return -ENODEV;
 119
 120        if (pwm->chip->ops->request) {
 121                err = pwm->chip->ops->request(pwm->chip, pwm);
 122                if (err) {
 123                        module_put(pwm->chip->ops->owner);
 124                        return err;
 125                }
 126        }
 127
 128        set_bit(PWMF_REQUESTED, &pwm->flags);
 129        pwm->label = label;
 130
 131        return 0;
 132}
 133
 134struct pwm_device *
 135of_pwm_xlate_with_flags(struct pwm_chip *pc, const struct of_phandle_args *args)
 136{
 137        struct pwm_device *pwm;
 138
 139        if (pc->of_pwm_n_cells < 3)
 140                return ERR_PTR(-EINVAL);
 141
 142        if (args->args[0] >= pc->npwm)
 143                return ERR_PTR(-EINVAL);
 144
 145        pwm = pwm_request_from_chip(pc, args->args[0], NULL);
 146        if (IS_ERR(pwm))
 147                return pwm;
 148
 149        pwm_set_period(pwm, args->args[1]);
 150
 151        if (args->args[2] & PWM_POLARITY_INVERTED)
 152                pwm_set_polarity(pwm, PWM_POLARITY_INVERSED);
 153        else
 154                pwm_set_polarity(pwm, PWM_POLARITY_NORMAL);
 155
 156        return pwm;
 157}
 158EXPORT_SYMBOL_GPL(of_pwm_xlate_with_flags);
 159
 160static struct pwm_device *
 161of_pwm_simple_xlate(struct pwm_chip *pc, const struct of_phandle_args *args)
 162{
 163        struct pwm_device *pwm;
 164
 165        if (pc->of_pwm_n_cells < 2)
 166                return ERR_PTR(-EINVAL);
 167
 168        if (args->args[0] >= pc->npwm)
 169                return ERR_PTR(-EINVAL);
 170
 171        pwm = pwm_request_from_chip(pc, args->args[0], NULL);
 172        if (IS_ERR(pwm))
 173                return pwm;
 174
 175        pwm_set_period(pwm, args->args[1]);
 176
 177        return pwm;
 178}
 179
 180static void of_pwmchip_add(struct pwm_chip *chip)
 181{
 182        if (!chip->dev || !chip->dev->of_node)
 183                return;
 184
 185        if (!chip->of_xlate) {
 186                chip->of_xlate = of_pwm_simple_xlate;
 187                chip->of_pwm_n_cells = 2;
 188        }
 189
 190        of_node_get(chip->dev->of_node);
 191}
 192
 193static void of_pwmchip_remove(struct pwm_chip *chip)
 194{
 195        if (chip->dev && chip->dev->of_node)
 196                of_node_put(chip->dev->of_node);
 197}
 198
 199/**
 200 * pwm_set_chip_data() - set private chip data for a PWM
 201 * @pwm: PWM device
 202 * @data: pointer to chip-specific data
 203 */
 204int pwm_set_chip_data(struct pwm_device *pwm, void *data)
 205{
 206        if (!pwm)
 207                return -EINVAL;
 208
 209        pwm->chip_data = data;
 210
 211        return 0;
 212}
 213EXPORT_SYMBOL_GPL(pwm_set_chip_data);
 214
 215/**
 216 * pwm_get_chip_data() - get private chip data for a PWM
 217 * @pwm: PWM device
 218 */
 219void *pwm_get_chip_data(struct pwm_device *pwm)
 220{
 221        return pwm ? pwm->chip_data : NULL;
 222}
 223EXPORT_SYMBOL_GPL(pwm_get_chip_data);
 224
 225/**
 226 * pwmchip_add() - register a new PWM chip
 227 * @chip: the PWM chip to add
 228 *
 229 * Register a new PWM chip. If chip->base < 0 then a dynamically assigned base
 230 * will be used.
 231 */
 232int pwmchip_add(struct pwm_chip *chip)
 233{
 234        struct pwm_device *pwm;
 235        unsigned int i;
 236        int ret;
 237
 238        if (!chip || !chip->dev || !chip->ops || !chip->ops->config ||
 239            !chip->ops->enable || !chip->ops->disable)
 240                return -EINVAL;
 241
 242        mutex_lock(&pwm_lock);
 243
 244        ret = alloc_pwms(chip->base, chip->npwm);
 245        if (ret < 0)
 246                goto out;
 247
 248        chip->pwms = kzalloc(chip->npwm * sizeof(*pwm), GFP_KERNEL);
 249        if (!chip->pwms) {
 250                ret = -ENOMEM;
 251                goto out;
 252        }
 253
 254        chip->base = ret;
 255
 256        for (i = 0; i < chip->npwm; i++) {
 257                pwm = &chip->pwms[i];
 258
 259                pwm->chip = chip;
 260                pwm->pwm = chip->base + i;
 261                pwm->hwpwm = i;
 262
 263                radix_tree_insert(&pwm_tree, pwm->pwm, pwm);
 264        }
 265
 266        bitmap_set(allocated_pwms, chip->base, chip->npwm);
 267
 268        INIT_LIST_HEAD(&chip->list);
 269        list_add(&chip->list, &pwm_chips);
 270
 271        ret = 0;
 272
 273        if (IS_ENABLED(CONFIG_OF))
 274                of_pwmchip_add(chip);
 275
 276        pwmchip_sysfs_export(chip);
 277
 278out:
 279        mutex_unlock(&pwm_lock);
 280        return ret;
 281}
 282EXPORT_SYMBOL_GPL(pwmchip_add);
 283
 284/**
 285 * pwmchip_remove() - remove a PWM chip
 286 * @chip: the PWM chip to remove
 287 *
 288 * Removes a PWM chip. This function may return busy if the PWM chip provides
 289 * a PWM device that is still requested.
 290 */
 291int pwmchip_remove(struct pwm_chip *chip)
 292{
 293        unsigned int i;
 294        int ret = 0;
 295
 296        mutex_lock(&pwm_lock);
 297
 298        for (i = 0; i < chip->npwm; i++) {
 299                struct pwm_device *pwm = &chip->pwms[i];
 300
 301                if (test_bit(PWMF_REQUESTED, &pwm->flags)) {
 302                        ret = -EBUSY;
 303                        goto out;
 304                }
 305        }
 306
 307        list_del_init(&chip->list);
 308
 309        if (IS_ENABLED(CONFIG_OF))
 310                of_pwmchip_remove(chip);
 311
 312        free_pwms(chip);
 313
 314        pwmchip_sysfs_unexport(chip);
 315
 316out:
 317        mutex_unlock(&pwm_lock);
 318        return ret;
 319}
 320EXPORT_SYMBOL_GPL(pwmchip_remove);
 321
 322/**
 323 * pwm_request() - request a PWM device
 324 * @pwm_id: global PWM device index
 325 * @label: PWM device label
 326 *
 327 * This function is deprecated, use pwm_get() instead.
 328 */
 329struct pwm_device *pwm_request(int pwm, const char *label)
 330{
 331        struct pwm_device *dev;
 332        int err;
 333
 334        if (pwm < 0 || pwm >= MAX_PWMS)
 335                return ERR_PTR(-EINVAL);
 336
 337        mutex_lock(&pwm_lock);
 338
 339        dev = pwm_to_device(pwm);
 340        if (!dev) {
 341                dev = ERR_PTR(-EPROBE_DEFER);
 342                goto out;
 343        }
 344
 345        err = pwm_device_request(dev, label);
 346        if (err < 0)
 347                dev = ERR_PTR(err);
 348
 349out:
 350        mutex_unlock(&pwm_lock);
 351
 352        return dev;
 353}
 354EXPORT_SYMBOL_GPL(pwm_request);
 355
 356/**
 357 * pwm_request_from_chip() - request a PWM device relative to a PWM chip
 358 * @chip: PWM chip
 359 * @index: per-chip index of the PWM to request
 360 * @label: a literal description string of this PWM
 361 *
 362 * Returns the PWM at the given index of the given PWM chip. A negative error
 363 * code is returned if the index is not valid for the specified PWM chip or
 364 * if the PWM device cannot be requested.
 365 */
 366struct pwm_device *pwm_request_from_chip(struct pwm_chip *chip,
 367                                         unsigned int index,
 368                                         const char *label)
 369{
 370        struct pwm_device *pwm;
 371        int err;
 372
 373        if (!chip || index >= chip->npwm)
 374                return ERR_PTR(-EINVAL);
 375
 376        mutex_lock(&pwm_lock);
 377        pwm = &chip->pwms[index];
 378
 379        err = pwm_device_request(pwm, label);
 380        if (err < 0)
 381                pwm = ERR_PTR(err);
 382
 383        mutex_unlock(&pwm_lock);
 384        return pwm;
 385}
 386EXPORT_SYMBOL_GPL(pwm_request_from_chip);
 387
 388/**
 389 * pwm_free() - free a PWM device
 390 * @pwm: PWM device
 391 *
 392 * This function is deprecated, use pwm_put() instead.
 393 */
 394void pwm_free(struct pwm_device *pwm)
 395{
 396        pwm_put(pwm);
 397}
 398EXPORT_SYMBOL_GPL(pwm_free);
 399
 400/**
 401 * pwm_config() - change a PWM device configuration
 402 * @pwm: PWM device
 403 * @duty_ns: "on" time (in nanoseconds)
 404 * @period_ns: duration (in nanoseconds) of one cycle
 405 */
 406int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns)
 407{
 408        int err;
 409
 410        if (!pwm || duty_ns < 0 || period_ns <= 0 || duty_ns > period_ns)
 411                return -EINVAL;
 412
 413        err = pwm->chip->ops->config(pwm->chip, pwm, duty_ns, period_ns);
 414        if (err)
 415                return err;
 416
 417        pwm->duty_cycle = duty_ns;
 418        pwm->period = period_ns;
 419
 420        return 0;
 421}
 422EXPORT_SYMBOL_GPL(pwm_config);
 423
 424/**
 425 * pwm_set_polarity() - configure the polarity of a PWM signal
 426 * @pwm: PWM device
 427 * @polarity: new polarity of the PWM signal
 428 *
 429 * Note that the polarity cannot be configured while the PWM device is enabled
 430 */
 431int pwm_set_polarity(struct pwm_device *pwm, enum pwm_polarity polarity)
 432{
 433        int err;
 434
 435        if (!pwm || !pwm->chip->ops)
 436                return -EINVAL;
 437
 438        if (!pwm->chip->ops->set_polarity)
 439                return -ENOSYS;
 440
 441        if (test_bit(PWMF_ENABLED, &pwm->flags))
 442                return -EBUSY;
 443
 444        err = pwm->chip->ops->set_polarity(pwm->chip, pwm, polarity);
 445        if (err)
 446                return err;
 447
 448        pwm->polarity = polarity;
 449
 450        return 0;
 451}
 452EXPORT_SYMBOL_GPL(pwm_set_polarity);
 453
 454/**
 455 * pwm_enable() - start a PWM output toggling
 456 * @pwm: PWM device
 457 */
 458int pwm_enable(struct pwm_device *pwm)
 459{
 460        if (pwm && !test_and_set_bit(PWMF_ENABLED, &pwm->flags))
 461                return pwm->chip->ops->enable(pwm->chip, pwm);
 462
 463        return pwm ? 0 : -EINVAL;
 464}
 465EXPORT_SYMBOL_GPL(pwm_enable);
 466
 467/**
 468 * pwm_disable() - stop a PWM output toggling
 469 * @pwm: PWM device
 470 */
 471void pwm_disable(struct pwm_device *pwm)
 472{
 473        if (pwm && test_and_clear_bit(PWMF_ENABLED, &pwm->flags))
 474                pwm->chip->ops->disable(pwm->chip, pwm);
 475}
 476EXPORT_SYMBOL_GPL(pwm_disable);
 477
 478static struct pwm_chip *of_node_to_pwmchip(struct device_node *np)
 479{
 480        struct pwm_chip *chip;
 481
 482        mutex_lock(&pwm_lock);
 483
 484        list_for_each_entry(chip, &pwm_chips, list)
 485                if (chip->dev && chip->dev->of_node == np) {
 486                        mutex_unlock(&pwm_lock);
 487                        return chip;
 488                }
 489
 490        mutex_unlock(&pwm_lock);
 491
 492        return ERR_PTR(-EPROBE_DEFER);
 493}
 494
 495/**
 496 * of_pwm_get() - request a PWM via the PWM framework
 497 * @np: device node to get the PWM from
 498 * @con_id: consumer name
 499 *
 500 * Returns the PWM device parsed from the phandle and index specified in the
 501 * "pwms" property of a device tree node or a negative error-code on failure.
 502 * Values parsed from the device tree are stored in the returned PWM device
 503 * object.
 504 *
 505 * If con_id is NULL, the first PWM device listed in the "pwms" property will
 506 * be requested. Otherwise the "pwm-names" property is used to do a reverse
 507 * lookup of the PWM index. This also means that the "pwm-names" property
 508 * becomes mandatory for devices that look up the PWM device via the con_id
 509 * parameter.
 510 */
 511struct pwm_device *of_pwm_get(struct device_node *np, const char *con_id)
 512{
 513        struct pwm_device *pwm = NULL;
 514        struct of_phandle_args args;
 515        struct pwm_chip *pc;
 516        int index = 0;
 517        int err;
 518
 519        if (con_id) {
 520                index = of_property_match_string(np, "pwm-names", con_id);
 521                if (index < 0)
 522                        return ERR_PTR(index);
 523        }
 524
 525        err = of_parse_phandle_with_args(np, "pwms", "#pwm-cells", index,
 526                                         &args);
 527        if (err) {
 528                pr_debug("%s(): can't parse \"pwms\" property\n", __func__);
 529                return ERR_PTR(err);
 530        }
 531
 532        pc = of_node_to_pwmchip(args.np);
 533        if (IS_ERR(pc)) {
 534                pr_debug("%s(): PWM chip not found\n", __func__);
 535                pwm = ERR_CAST(pc);
 536                goto put;
 537        }
 538
 539        if (args.args_count != pc->of_pwm_n_cells) {
 540                pr_debug("%s: wrong #pwm-cells for %s\n", np->full_name,
 541                         args.np->full_name);
 542                pwm = ERR_PTR(-EINVAL);
 543                goto put;
 544        }
 545
 546        pwm = pc->of_xlate(pc, &args);
 547        if (IS_ERR(pwm))
 548                goto put;
 549
 550        /*
 551         * If a consumer name was not given, try to look it up from the
 552         * "pwm-names" property if it exists. Otherwise use the name of
 553         * the user device node.
 554         */
 555        if (!con_id) {
 556                err = of_property_read_string_index(np, "pwm-names", index,
 557                                                    &con_id);
 558                if (err < 0)
 559                        con_id = np->name;
 560        }
 561
 562        pwm->label = con_id;
 563
 564put:
 565        of_node_put(args.np);
 566
 567        return pwm;
 568}
 569EXPORT_SYMBOL_GPL(of_pwm_get);
 570
 571/**
 572 * pwm_add_table() - register PWM device consumers
 573 * @table: array of consumers to register
 574 * @num: number of consumers in table
 575 */
 576void __init pwm_add_table(struct pwm_lookup *table, size_t num)
 577{
 578        mutex_lock(&pwm_lookup_lock);
 579
 580        while (num--) {
 581                list_add_tail(&table->list, &pwm_lookup_list);
 582                table++;
 583        }
 584
 585        mutex_unlock(&pwm_lookup_lock);
 586}
 587
 588/**
 589 * pwm_get() - look up and request a PWM device
 590 * @dev: device for PWM consumer
 591 * @con_id: consumer name
 592 *
 593 * Lookup is first attempted using DT. If the device was not instantiated from
 594 * a device tree, a PWM chip and a relative index is looked up via a table
 595 * supplied by board setup code (see pwm_add_table()).
 596 *
 597 * Once a PWM chip has been found the specified PWM device will be requested
 598 * and is ready to be used.
 599 */
 600struct pwm_device *pwm_get(struct device *dev, const char *con_id)
 601{
 602        struct pwm_device *pwm = ERR_PTR(-EPROBE_DEFER);
 603        const char *dev_id = dev ? dev_name(dev) : NULL;
 604        struct pwm_chip *chip = NULL;
 605        unsigned int index = 0;
 606        unsigned int best = 0;
 607        struct pwm_lookup *p;
 608        unsigned int match;
 609
 610        /* look up via DT first */
 611        if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node)
 612                return of_pwm_get(dev->of_node, con_id);
 613
 614        /*
 615         * We look up the provider in the static table typically provided by
 616         * board setup code. We first try to lookup the consumer device by
 617         * name. If the consumer device was passed in as NULL or if no match
 618         * was found, we try to find the consumer by directly looking it up
 619         * by name.
 620         *
 621         * If a match is found, the provider PWM chip is looked up by name
 622         * and a PWM device is requested using the PWM device per-chip index.
 623         *
 624         * The lookup algorithm was shamelessly taken from the clock
 625         * framework:
 626         *
 627         * We do slightly fuzzy matching here:
 628         *  An entry with a NULL ID is assumed to be a wildcard.
 629         *  If an entry has a device ID, it must match
 630         *  If an entry has a connection ID, it must match
 631         * Then we take the most specific entry - with the following order
 632         * of precedence: dev+con > dev only > con only.
 633         */
 634        mutex_lock(&pwm_lookup_lock);
 635
 636        list_for_each_entry(p, &pwm_lookup_list, list) {
 637                match = 0;
 638
 639                if (p->dev_id) {
 640                        if (!dev_id || strcmp(p->dev_id, dev_id))
 641                                continue;
 642
 643                        match += 2;
 644                }
 645
 646                if (p->con_id) {
 647                        if (!con_id || strcmp(p->con_id, con_id))
 648                                continue;
 649
 650                        match += 1;
 651                }
 652
 653                if (match > best) {
 654                        chip = pwmchip_find_by_name(p->provider);
 655                        index = p->index;
 656
 657                        if (match != 3)
 658                                best = match;
 659                        else
 660                                break;
 661                }
 662        }
 663
 664        if (chip)
 665                pwm = pwm_request_from_chip(chip, index, con_id ?: dev_id);
 666
 667        mutex_unlock(&pwm_lookup_lock);
 668
 669        return pwm;
 670}
 671EXPORT_SYMBOL_GPL(pwm_get);
 672
 673/**
 674 * pwm_put() - release a PWM device
 675 * @pwm: PWM device
 676 */
 677void pwm_put(struct pwm_device *pwm)
 678{
 679        if (!pwm)
 680                return;
 681
 682        mutex_lock(&pwm_lock);
 683
 684        if (!test_and_clear_bit(PWMF_REQUESTED, &pwm->flags)) {
 685                pr_warn("PWM device already freed\n");
 686                goto out;
 687        }
 688
 689        if (pwm->chip->ops->free)
 690                pwm->chip->ops->free(pwm->chip, pwm);
 691
 692        pwm->label = NULL;
 693
 694        module_put(pwm->chip->ops->owner);
 695out:
 696        mutex_unlock(&pwm_lock);
 697}
 698EXPORT_SYMBOL_GPL(pwm_put);
 699
 700static void devm_pwm_release(struct device *dev, void *res)
 701{
 702        pwm_put(*(struct pwm_device **)res);
 703}
 704
 705/**
 706 * devm_pwm_get() - resource managed pwm_get()
 707 * @dev: device for PWM consumer
 708 * @con_id: consumer name
 709 *
 710 * This function performs like pwm_get() but the acquired PWM device will
 711 * automatically be released on driver detach.
 712 */
 713struct pwm_device *devm_pwm_get(struct device *dev, const char *con_id)
 714{
 715        struct pwm_device **ptr, *pwm;
 716
 717        ptr = devres_alloc(devm_pwm_release, sizeof(*ptr), GFP_KERNEL);
 718        if (!ptr)
 719                return ERR_PTR(-ENOMEM);
 720
 721        pwm = pwm_get(dev, con_id);
 722        if (!IS_ERR(pwm)) {
 723                *ptr = pwm;
 724                devres_add(dev, ptr);
 725        } else {
 726                devres_free(ptr);
 727        }
 728
 729        return pwm;
 730}
 731EXPORT_SYMBOL_GPL(devm_pwm_get);
 732
 733/**
 734 * devm_of_pwm_get() - resource managed of_pwm_get()
 735 * @dev: device for PWM consumer
 736 * @np: device node to get the PWM from
 737 * @con_id: consumer name
 738 *
 739 * This function performs like of_pwm_get() but the acquired PWM device will
 740 * automatically be released on driver detach.
 741 */
 742struct pwm_device *devm_of_pwm_get(struct device *dev, struct device_node *np,
 743                                   const char *con_id)
 744{
 745        struct pwm_device **ptr, *pwm;
 746
 747        ptr = devres_alloc(devm_pwm_release, sizeof(*ptr), GFP_KERNEL);
 748        if (!ptr)
 749                return ERR_PTR(-ENOMEM);
 750
 751        pwm = of_pwm_get(np, con_id);
 752        if (!IS_ERR(pwm)) {
 753                *ptr = pwm;
 754                devres_add(dev, ptr);
 755        } else {
 756                devres_free(ptr);
 757        }
 758
 759        return pwm;
 760}
 761EXPORT_SYMBOL_GPL(devm_of_pwm_get);
 762
 763static int devm_pwm_match(struct device *dev, void *res, void *data)
 764{
 765        struct pwm_device **p = res;
 766
 767        if (WARN_ON(!p || !*p))
 768                return 0;
 769
 770        return *p == data;
 771}
 772
 773/**
 774 * devm_pwm_put() - resource managed pwm_put()
 775 * @dev: device for PWM consumer
 776 * @pwm: PWM device
 777 *
 778 * Release a PWM previously allocated using devm_pwm_get(). Calling this
 779 * function is usually not needed because devm-allocated resources are
 780 * automatically released on driver detach.
 781 */
 782void devm_pwm_put(struct device *dev, struct pwm_device *pwm)
 783{
 784        WARN_ON(devres_release(dev, devm_pwm_release, devm_pwm_match, pwm));
 785}
 786EXPORT_SYMBOL_GPL(devm_pwm_put);
 787
 788/**
 789  * pwm_can_sleep() - report whether PWM access will sleep
 790  * @pwm: PWM device
 791  *
 792  * It returns true if accessing the PWM can sleep, false otherwise.
 793  */
 794bool pwm_can_sleep(struct pwm_device *pwm)
 795{
 796        return pwm->chip->can_sleep;
 797}
 798EXPORT_SYMBOL_GPL(pwm_can_sleep);
 799
 800#ifdef CONFIG_DEBUG_FS
 801static void pwm_dbg_show(struct pwm_chip *chip, struct seq_file *s)
 802{
 803        unsigned int i;
 804
 805        for (i = 0; i < chip->npwm; i++) {
 806                struct pwm_device *pwm = &chip->pwms[i];
 807
 808                seq_printf(s, " pwm-%-3d (%-20.20s):", i, pwm->label);
 809
 810                if (test_bit(PWMF_REQUESTED, &pwm->flags))
 811                        seq_printf(s, " requested");
 812
 813                if (test_bit(PWMF_ENABLED, &pwm->flags))
 814                        seq_printf(s, " enabled");
 815
 816                seq_printf(s, "\n");
 817        }
 818}
 819
 820static void *pwm_seq_start(struct seq_file *s, loff_t *pos)
 821{
 822        mutex_lock(&pwm_lock);
 823        s->private = "";
 824
 825        return seq_list_start(&pwm_chips, *pos);
 826}
 827
 828static void *pwm_seq_next(struct seq_file *s, void *v, loff_t *pos)
 829{
 830        s->private = "\n";
 831
 832        return seq_list_next(v, &pwm_chips, pos);
 833}
 834
 835static void pwm_seq_stop(struct seq_file *s, void *v)
 836{
 837        mutex_unlock(&pwm_lock);
 838}
 839
 840static int pwm_seq_show(struct seq_file *s, void *v)
 841{
 842        struct pwm_chip *chip = list_entry(v, struct pwm_chip, list);
 843
 844        seq_printf(s, "%s%s/%s, %d PWM device%s\n", (char *)s->private,
 845                   chip->dev->bus ? chip->dev->bus->name : "no-bus",
 846                   dev_name(chip->dev), chip->npwm,
 847                   (chip->npwm != 1) ? "s" : "");
 848
 849        if (chip->ops->dbg_show)
 850                chip->ops->dbg_show(chip, s);
 851        else
 852                pwm_dbg_show(chip, s);
 853
 854        return 0;
 855}
 856
 857static const struct seq_operations pwm_seq_ops = {
 858        .start = pwm_seq_start,
 859        .next = pwm_seq_next,
 860        .stop = pwm_seq_stop,
 861        .show = pwm_seq_show,
 862};
 863
 864static int pwm_seq_open(struct inode *inode, struct file *file)
 865{
 866        return seq_open(file, &pwm_seq_ops);
 867}
 868
 869static const struct file_operations pwm_debugfs_ops = {
 870        .owner = THIS_MODULE,
 871        .open = pwm_seq_open,
 872        .read = seq_read,
 873        .llseek = seq_lseek,
 874        .release = seq_release,
 875};
 876
 877static int __init pwm_debugfs_init(void)
 878{
 879        debugfs_create_file("pwm", S_IFREG | S_IRUGO, NULL, NULL,
 880                            &pwm_debugfs_ops);
 881
 882        return 0;
 883}
 884
 885subsys_initcall(pwm_debugfs_init);
 886#endif /* CONFIG_DEBUG_FS */
 887
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.