drivers/reset/core.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Reset Controller framework
   4  *
   5  * Copyright 2013 Philipp Zabel, Pengutronix
   6  */
   7 #include <linux/atomic.h>
   8 #include <linux/cleanup.h>
   9 #include <linux/device.h>
  10 #include <linux/err.h>
  11 #include <linux/export.h>
  12 #include <linux/kernel.h>
  13 #include <linux/kref.h>
  14 #include <linux/gpio/driver.h>
  15 #include <linux/gpio/machine.h>
  16 #include <linux/idr.h>
  17 #include <linux/module.h>
  18 #include <linux/of.h>
  19 #include <linux/acpi.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/reset.h>
  22 #include <linux/reset-controller.h>
  23 #include <linux/slab.h>
  24
  25 static DEFINE_MUTEX(reset_list_mutex);
  26 static LIST_HEAD(reset_controller_list);
  27
  28 static DEFINE_MUTEX(reset_lookup_mutex);
  29 static LIST_HEAD(reset_lookup_list);
  30
  31 /* Protects reset_gpio_lookup_list */
  32 static DEFINE_MUTEX(reset_gpio_lookup_mutex);
  33 static LIST_HEAD(reset_gpio_lookup_list);
  34 static DEFINE_IDA(reset_gpio_ida);
  35
  36 /**
  37  * struct reset_control - a reset control
  38  * @rcdev: a pointer to the reset controller device
  39  *         this reset control belongs to
  40  * @list: list entry for the rcdev's reset controller list
  41  * @id: ID of the reset controller in the reset
  42  *      controller device
  43  * @refcnt: Number of gets of this reset_control
  44  * @acquired: Only one reset_control may be acquired for a given rcdev and id.
  45  * @shared: Is this a shared (1), or an exclusive (0) reset_control?
  46  * @array: Is this an array of reset controls (1)?
  47  * @deassert_count: Number of times this reset line has been deasserted
  48  * @triggered_count: Number of times this reset line has been reset. Currently
  49  *                   only used for shared resets, which means that the value
  50  *                   will be either 0 or 1.
  51  */
  52 struct reset_control {
  53         struct reset_controller_dev *rcdev;
  54         struct list_head list;
  55         unsigned int id;
  56         struct kref refcnt;
  57         bool acquired;
  58         bool shared;
  59         bool array;
  60         atomic_t deassert_count;
  61         atomic_t triggered_count;
  62 };
  63
  64 /**
  65  * struct reset_control_array - an array of reset controls
  66  * @base: reset control for compatibility with reset control API functions
  67  * @num_rstcs: number of reset controls
  68  * @rstc: array of reset controls
  69  */
  70 struct reset_control_array {
  71         struct reset_control base;
  72         unsigned int num_rstcs;
  73         struct reset_control *rstc[] __counted_by(num_rstcs);
  74 };
  75
  76 /**
  77  * struct reset_gpio_lookup - lookup key for ad-hoc created reset-gpio devices
  78  * @of_args: phandle to the reset controller with all the args like GPIO number
  79  * @list: list entry for the reset_gpio_lookup_list
  80  */
  81 struct reset_gpio_lookup {
  82         struct of_phandle_args of_args;
  83         struct list_head list;
  84 };
  85
  86 static const char *rcdev_name(struct reset_controller_dev *rcdev)
  87 {
  88         if (rcdev->dev)
  89                 return dev_name(rcdev->dev);
  90
  91         if (rcdev->of_node)
  92                 return rcdev->of_node->full_name;
  93
  94         if (rcdev->of_args)
  95                 return rcdev->of_args->np->full_name;
  96
  97         return NULL;
  98 }
  99
 100 /**
 101  * of_reset_simple_xlate - translate reset_spec to the reset line number
 102  * @rcdev: a pointer to the reset controller device
 103  * @reset_spec: reset line specifier as found in the device tree
 104  *
 105  * This static translation function is used by default if of_xlate in
 106  * :c:type:`reset_controller_dev` is not set. It is useful for all reset
 107  * controllers with 1:1 mapping, where reset lines can be indexed by number
 108  * without gaps.
 109  */
 110 static int of_reset_simple_xlate(struct reset_controller_dev *rcdev,
 111                                  const struct of_phandle_args *reset_spec)
 112 {
 113         if (reset_spec->args[0] >= rcdev->nr_resets)
 114                 return -EINVAL;
 115
 116         return reset_spec->args[0];
 117 }
 118
 119 /**
 120  * reset_controller_register - register a reset controller device
 121  * @rcdev: a pointer to the initialized reset controller device
 122  */
 123 int reset_controller_register(struct reset_controller_dev *rcdev)
 124 {
 125         if (rcdev->of_node && rcdev->of_args)
 126                 return -EINVAL;
 127
 128         if (!rcdev->of_xlate) {
 129                 rcdev->of_reset_n_cells = 1;
 130                 rcdev->of_xlate = of_reset_simple_xlate;
 131         }
 132
 133         INIT_LIST_HEAD(&rcdev->reset_control_head);
 134
 135         mutex_lock(&reset_list_mutex);
 136         list_add(&rcdev->list, &reset_controller_list);
 137         mutex_unlock(&reset_list_mutex);
 138
 139         return 0;
 140 }
 141 EXPORT_SYMBOL_GPL(reset_controller_register);
 142
 143 /**
 144  * reset_controller_unregister - unregister a reset controller device
 145  * @rcdev: a pointer to the reset controller device
 146  */
 147 void reset_controller_unregister(struct reset_controller_dev *rcdev)
 148 {
 149         mutex_lock(&reset_list_mutex);
 150         list_del(&rcdev->list);
 151         mutex_unlock(&reset_list_mutex);
 152 }
 153 EXPORT_SYMBOL_GPL(reset_controller_unregister);
 154
 155 static void devm_reset_controller_release(struct device *dev, void *res)
 156 {
 157         reset_controller_unregister(*(struct reset_controller_dev **)res);
 158 }
 159
 160 /**
 161  * devm_reset_controller_register - resource managed reset_controller_register()
 162  * @dev: device that is registering this reset controller
 163  * @rcdev: a pointer to the initialized reset controller device
 164  *
 165  * Managed reset_controller_register(). For reset controllers registered by
 166  * this function, reset_controller_unregister() is automatically called on
 167  * driver detach. See reset_controller_register() for more information.
 168  */
 169 int devm_reset_controller_register(struct device *dev,
 170                                    struct reset_controller_dev *rcdev)
 171 {
 172         struct reset_controller_dev **rcdevp;
 173         int ret;
 174
 175         rcdevp = devres_alloc(devm_reset_controller_release, sizeof(*rcdevp),
 176                               GFP_KERNEL);
 177         if (!rcdevp)
 178                 return -ENOMEM;
 179
 180         ret = reset_controller_register(rcdev);
 181         if (ret) {
 182                 devres_free(rcdevp);
 183                 return ret;
 184         }
 185
 186         *rcdevp = rcdev;
 187         devres_add(dev, rcdevp);
 188
 189         return ret;
 190 }
 191 EXPORT_SYMBOL_GPL(devm_reset_controller_register);
 192
 193 /**
 194  * reset_controller_add_lookup - register a set of lookup entries
 195  * @lookup: array of reset lookup entries
 196  * @num_entries: number of entries in the lookup array
 197  */
 198 void reset_controller_add_lookup(struct reset_control_lookup *lookup,
 199                                  unsigned int num_entries)
 200 {
 201         struct reset_control_lookup *entry;
 202         unsigned int i;
 203
 204         mutex_lock(&reset_lookup_mutex);
 205         for (i = 0; i < num_entries; i++) {
 206                 entry = &lookup[i];
 207
 208                 if (!entry->dev_id || !entry->provider) {
 209                         pr_warn("%s(): reset lookup entry badly specified, skipping\n",
 210                                 __func__);
 211                         continue;
 212                 }
 213
 214                 list_add_tail(&entry->list, &reset_lookup_list);
 215         }
 216         mutex_unlock(&reset_lookup_mutex);
 217 }
 218 EXPORT_SYMBOL_GPL(reset_controller_add_lookup);
 219
 220 static inline struct reset_control_array *
 221 rstc_to_array(struct reset_control *rstc) {
 222         return container_of(rstc, struct reset_control_array, base);
 223 }
 224
 225 static int reset_control_array_reset(struct reset_control_array *resets)
 226 {
 227         int ret, i;
 228
 229         for (i = 0; i < resets->num_rstcs; i++) {
 230                 ret = reset_control_reset(resets->rstc[i]);
 231                 if (ret)
 232                         return ret;
 233         }
 234
 235         return 0;
 236 }
 237
 238 static int reset_control_array_rearm(struct reset_control_array *resets)
 239 {
 240         struct reset_control *rstc;
 241         int i;
 242
 243         for (i = 0; i < resets->num_rstcs; i++) {
 244                 rstc = resets->rstc[i];
 245
 246                 if (!rstc)
 247                         continue;
 248
 249                 if (WARN_ON(IS_ERR(rstc)))
 250                         return -EINVAL;
 251
 252                 if (rstc->shared) {
 253                         if (WARN_ON(atomic_read(&rstc->deassert_count) != 0))
 254                                 return -EINVAL;
 255                 } else {
 256                         if (!rstc->acquired)
 257                                 return -EPERM;
 258                 }
 259         }
 260
 261         for (i = 0; i < resets->num_rstcs; i++) {
 262                 rstc = resets->rstc[i];
 263
 264                 if (rstc && rstc->shared)
 265                         WARN_ON(atomic_dec_return(&rstc->triggered_count) < 0);
 266         }
 267
 268         return 0;
 269 }
 270
 271 static int reset_control_array_assert(struct reset_control_array *resets)
 272 {
 273         int ret, i;
 274
 275         for (i = 0; i < resets->num_rstcs; i++) {
 276                 ret = reset_control_assert(resets->rstc[i]);
 277                 if (ret)
 278                         goto err;
 279         }
 280
 281         return 0;
 282
 283 err:
 284         while (i--)
 285                 reset_control_deassert(resets->rstc[i]);
 286         return ret;
 287 }
 288
 289 static int reset_control_array_deassert(struct reset_control_array *resets)
 290 {
 291         int ret, i;
 292
 293         for (i = 0; i < resets->num_rstcs; i++) {
 294                 ret = reset_control_deassert(resets->rstc[i]);
 295                 if (ret)
 296                         goto err;
 297         }
 298
 299         return 0;
 300
 301 err:
 302         while (i--)
 303                 reset_control_assert(resets->rstc[i]);
 304         return ret;
 305 }
 306
 307 static int reset_control_array_acquire(struct reset_control_array *resets)
 308 {
 309         unsigned int i;
 310         int err;
 311
 312         for (i = 0; i < resets->num_rstcs; i++) {
 313                 err = reset_control_acquire(resets->rstc[i]);
 314                 if (err < 0)
 315                         goto release;
 316         }
 317
 318         return 0;
 319
 320 release:
 321         while (i--)
 322                 reset_control_release(resets->rstc[i]);
 323
 324         return err;
 325 }
 326
 327 static void reset_control_array_release(struct reset_control_array *resets)
 328 {
 329         unsigned int i;
 330
 331         for (i = 0; i < resets->num_rstcs; i++)
 332                 reset_control_release(resets->rstc[i]);
 333 }
 334
 335 static inline bool reset_control_is_array(struct reset_control *rstc)
 336 {
 337         return rstc->array;
 338 }
 339
 340 /**
 341  * reset_control_reset - reset the controlled device
 342  * @rstc: reset controller
 343  *
 344  * On a shared reset line the actual reset pulse is only triggered once for the
 345  * lifetime of the reset_control instance: for all but the first caller this is
 346  * a no-op.
 347  * Consumers must not use reset_control_(de)assert on shared reset lines when
 348  * reset_control_reset has been used.
 349  *
 350  * If rstc is NULL it is an optional reset and the function will just
 351  * return 0.
 352  */
 353 int reset_control_reset(struct reset_control *rstc)
 354 {
 355         int ret;
 356
 357         if (!rstc)
 358                 return 0;
 359
 360         if (WARN_ON(IS_ERR(rstc)))
 361                 return -EINVAL;
 362
 363         if (reset_control_is_array(rstc))
 364                 return reset_control_array_reset(rstc_to_array(rstc));
 365
 366         if (!rstc->rcdev->ops->reset)
 367                 return -ENOTSUPP;
 368
 369         if (rstc->shared) {
 370                 if (WARN_ON(atomic_read(&rstc->deassert_count) != 0))
 371                         return -EINVAL;
 372
 373                 if (atomic_inc_return(&rstc->triggered_count) != 1)
 374                         return 0;
 375         } else {
 376                 if (!rstc->acquired)
 377                         return -EPERM;
 378         }
 379
 380         ret = rstc->rcdev->ops->reset(rstc->rcdev, rstc->id);
 381         if (rstc->shared && ret)
 382                 atomic_dec(&rstc->triggered_count);
 383
 384         return ret;
 385 }
 386 EXPORT_SYMBOL_GPL(reset_control_reset);
 387
 388 /**
 389  * reset_control_bulk_reset - reset the controlled devices in order
 390  * @num_rstcs: number of entries in rstcs array
 391  * @rstcs: array of struct reset_control_bulk_data with reset controls set
 392  *
 393  * Issue a reset on all provided reset controls, in order.
 394  *
 395  * See also: reset_control_reset()
 396  */
 397 int reset_control_bulk_reset(int num_rstcs,
 398                              struct reset_control_bulk_data *rstcs)
 399 {
 400         int ret, i;
 401
 402         for (i = 0; i < num_rstcs; i++) {
 403                 ret = reset_control_reset(rstcs[i].rstc);
 404                 if (ret)
 405                         return ret;
 406         }
 407
 408         return 0;
 409 }
 410 EXPORT_SYMBOL_GPL(reset_control_bulk_reset);
 411
 412 /**
 413  * reset_control_rearm - allow shared reset line to be re-triggered"
 414  * @rstc: reset controller
 415  *
 416  * On a shared reset line the actual reset pulse is only triggered once for the
 417  * lifetime of the reset_control instance, except if this call is used.
 418  *
 419  * Calls to this function must be balanced with calls to reset_control_reset,
 420  * a warning is thrown in case triggered_count ever dips below 0.
 421  *
 422  * Consumers must not use reset_control_(de)assert on shared reset lines when
 423  * reset_control_reset or reset_control_rearm have been used.
 424  *
 425  * If rstc is NULL the function will just return 0.
 426  */
 427 int reset_control_rearm(struct reset_control *rstc)
 428 {
 429         if (!rstc)
 430                 return 0;
 431
 432         if (WARN_ON(IS_ERR(rstc)))
 433                 return -EINVAL;
 434
 435         if (reset_control_is_array(rstc))
 436                 return reset_control_array_rearm(rstc_to_array(rstc));
 437
 438         if (rstc->shared) {
 439                 if (WARN_ON(atomic_read(&rstc->deassert_count) != 0))
 440                         return -EINVAL;
 441
 442                 WARN_ON(atomic_dec_return(&rstc->triggered_count) < 0);
 443         } else {
 444                 if (!rstc->acquired)
 445                         return -EPERM;
 446         }
 447
 448         return 0;
 449 }
 450 EXPORT_SYMBOL_GPL(reset_control_rearm);
 451
 452 /**
 453  * reset_control_assert - asserts the reset line
 454  * @rstc: reset controller
 455  *
 456  * Calling this on an exclusive reset controller guarantees that the reset
 457  * will be asserted. When called on a shared reset controller the line may
 458  * still be deasserted, as long as other users keep it so.
 459  *
 460  * For shared reset controls a driver cannot expect the hw's registers and
 461  * internal state to be reset, but must be prepared for this to happen.
 462  * Consumers must not use reset_control_reset on shared reset lines when
 463  * reset_control_(de)assert has been used.
 464  *
 465  * If rstc is NULL it is an optional reset and the function will just
 466  * return 0.
 467  */
 468 int reset_control_assert(struct reset_control *rstc)
 469 {
 470         if (!rstc)
 471                 return 0;
 472
 473         if (WARN_ON(IS_ERR(rstc)))
 474                 return -EINVAL;
 475
 476         if (reset_control_is_array(rstc))
 477                 return reset_control_array_assert(rstc_to_array(rstc));
 478
 479         if (rstc->shared) {
 480                 if (WARN_ON(atomic_read(&rstc->triggered_count) != 0))
 481                         return -EINVAL;
 482
 483                 if (WARN_ON(atomic_read(&rstc->deassert_count) == 0))
 484                         return -EINVAL;
 485
 486                 if (atomic_dec_return(&rstc->deassert_count) != 0)
 487                         return 0;
 488
 489                 /*
 490                  * Shared reset controls allow the reset line to be in any state
 491                  * after this call, so doing nothing is a valid option.
 492                  */
 493                 if (!rstc->rcdev->ops->assert)
 494                         return 0;
 495         } else {
 496                 /*
 497                  * If the reset controller does not implement .assert(), there
 498                  * is no way to guarantee that the reset line is asserted after
 499                  * this call.
 500                  */
 501                 if (!rstc->rcdev->ops->assert)
 502                         return -ENOTSUPP;
 503
 504                 if (!rstc->acquired) {
 505                         WARN(1, "reset %s (ID: %u) is not acquired\n",
 506                              rcdev_name(rstc->rcdev), rstc->id);
 507                         return -EPERM;
 508                 }
 509         }
 510
 511         return rstc->rcdev->ops->assert(rstc->rcdev, rstc->id);
 512 }
 513 EXPORT_SYMBOL_GPL(reset_control_assert);
 514
 515 /**
 516  * reset_control_bulk_assert - asserts the reset lines in order
 517  * @num_rstcs: number of entries in rstcs array
 518  * @rstcs: array of struct reset_control_bulk_data with reset controls set
 519  *
 520  * Assert the reset lines for all provided reset controls, in order.
 521  * If an assertion fails, already asserted resets are deasserted again.
 522  *
 523  * See also: reset_control_assert()
 524  */
 525 int reset_control_bulk_assert(int num_rstcs,
 526                               struct reset_control_bulk_data *rstcs)
 527 {
 528         int ret, i;
 529
 530         for (i = 0; i < num_rstcs; i++) {
 531                 ret = reset_control_assert(rstcs[i].rstc);
 532                 if (ret)
 533                         goto err;
 534         }
 535
 536         return 0;
 537
 538 err:
 539         while (i--)
 540                 reset_control_deassert(rstcs[i].rstc);
 541         return ret;
 542 }
 543 EXPORT_SYMBOL_GPL(reset_control_bulk_assert);
 544
 545 /**
 546  * reset_control_deassert - deasserts the reset line
 547  * @rstc: reset controller
 548  *
 549  * After calling this function, the reset is guaranteed to be deasserted.
 550  * Consumers must not use reset_control_reset on shared reset lines when
 551  * reset_control_(de)assert has been used.
 552  *
 553  * If rstc is NULL it is an optional reset and the function will just
 554  * return 0.
 555  */
 556 int reset_control_deassert(struct reset_control *rstc)
 557 {
 558         if (!rstc)
 559                 return 0;
 560
 561         if (WARN_ON(IS_ERR(rstc)))
 562                 return -EINVAL;
 563
 564         if (reset_control_is_array(rstc))
 565                 return reset_control_array_deassert(rstc_to_array(rstc));
 566
 567         if (rstc->shared) {
 568                 if (WARN_ON(atomic_read(&rstc->triggered_count) != 0))
 569                         return -EINVAL;
 570
 571                 if (atomic_inc_return(&rstc->deassert_count) != 1)
 572                         return 0;
 573         } else {
 574                 if (!rstc->acquired) {
 575                         WARN(1, "reset %s (ID: %u) is not acquired\n",
 576                              rcdev_name(rstc->rcdev), rstc->id);
 577                         return -EPERM;
 578                 }
 579         }
 580
 581         /*
 582          * If the reset controller does not implement .deassert(), we assume
 583          * that it handles self-deasserting reset lines via .reset(). In that
 584          * case, the reset lines are deasserted by default. If that is not the
 585          * case, the reset controller driver should implement .deassert() and
 586          * return -ENOTSUPP.
 587          */
 588         if (!rstc->rcdev->ops->deassert)
 589                 return 0;
 590
 591         return rstc->rcdev->ops->deassert(rstc->rcdev, rstc->id);
 592 }
 593 EXPORT_SYMBOL_GPL(reset_control_deassert);
 594
 595 /**
 596  * reset_control_bulk_deassert - deasserts the reset lines in reverse order
 597  * @num_rstcs: number of entries in rstcs array
 598  * @rstcs: array of struct reset_control_bulk_data with reset controls set
 599  *
 600  * Deassert the reset lines for all provided reset controls, in reverse order.
 601  * If a deassertion fails, already deasserted resets are asserted again.
 602  *
 603  * See also: reset_control_deassert()
 604  */
 605 int reset_control_bulk_deassert(int num_rstcs,
 606                                 struct reset_control_bulk_data *rstcs)
 607 {
 608         int ret, i;
 609
 610         for (i = num_rstcs - 1; i >= 0; i--) {
 611                 ret = reset_control_deassert(rstcs[i].rstc);
 612                 if (ret)
 613                         goto err;
 614         }
 615
 616         return 0;
 617
 618 err:
 619         while (i < num_rstcs)
 620                 reset_control_assert(rstcs[i++].rstc);
 621         return ret;
 622 }
 623 EXPORT_SYMBOL_GPL(reset_control_bulk_deassert);
 624
 625 /**
 626  * reset_control_status - returns a negative errno if not supported, a
 627  * positive value if the reset line is asserted, or zero if the reset
 628  * line is not asserted or if the desc is NULL (optional reset).
 629  * @rstc: reset controller
 630  */
 631 int reset_control_status(struct reset_control *rstc)
 632 {
 633         if (!rstc)
 634                 return 0;
 635
 636         if (WARN_ON(IS_ERR(rstc)) || reset_control_is_array(rstc))
 637                 return -EINVAL;
 638
 639         if (rstc->rcdev->ops->status)
 640                 return rstc->rcdev->ops->status(rstc->rcdev, rstc->id);
 641
 642         return -ENOTSUPP;
 643 }
 644 EXPORT_SYMBOL_GPL(reset_control_status);
 645
 646 /**
 647  * reset_control_acquire() - acquires a reset control for exclusive use
 648  * @rstc: reset control
 649  *
 650  * This is used to explicitly acquire a reset control for exclusive use. Note
 651  * that exclusive resets are requested as acquired by default. In order for a
 652  * second consumer to be able to control the reset, the first consumer has to
 653  * release it first. Typically the easiest way to achieve this is to call the
 654  * reset_control_get_exclusive_released() to obtain an instance of the reset
 655  * control. Such reset controls are not acquired by default.
 656  *
 657  * Consumers implementing shared access to an exclusive reset need to follow
 658  * a specific protocol in order to work together. Before consumers can change
 659  * a reset they must acquire exclusive access using reset_control_acquire().
 660  * After they are done operating the reset, they must release exclusive access
 661  * with a call to reset_control_release(). Consumers are not granted exclusive
 662  * access to the reset as long as another consumer hasn't released a reset.
 663  *
 664  * See also: reset_control_release()
 665  */
 666 int reset_control_acquire(struct reset_control *rstc)
 667 {
 668         struct reset_control *rc;
 669
 670         if (!rstc)
 671                 return 0;
 672
 673         if (WARN_ON(IS_ERR(rstc)))
 674                 return -EINVAL;
 675
 676         if (reset_control_is_array(rstc))
 677                 return reset_control_array_acquire(rstc_to_array(rstc));
 678
 679         mutex_lock(&reset_list_mutex);
 680
 681         if (rstc->acquired) {
 682                 mutex_unlock(&reset_list_mutex);
 683                 return 0;
 684         }
 685
 686         list_for_each_entry(rc, &rstc->rcdev->reset_control_head, list) {
 687                 if (rstc != rc && rstc->id == rc->id) {
 688                         if (rc->acquired) {
 689                                 mutex_unlock(&reset_list_mutex);
 690                                 return -EBUSY;
 691                         }
 692                 }
 693         }
 694
 695         rstc->acquired = true;
 696
 697         mutex_unlock(&reset_list_mutex);
 698         return 0;
 699 }
 700 EXPORT_SYMBOL_GPL(reset_control_acquire);
 701
 702 /**
 703  * reset_control_bulk_acquire - acquires reset controls for exclusive use
 704  * @num_rstcs: number of entries in rstcs array
 705  * @rstcs: array of struct reset_control_bulk_data with reset controls set
 706  *
 707  * This is used to explicitly acquire reset controls requested with
 708  * reset_control_bulk_get_exclusive_release() for temporary exclusive use.
 709  *
 710  * See also: reset_control_acquire(), reset_control_bulk_release()
 711  */
 712 int reset_control_bulk_acquire(int num_rstcs,
 713                                struct reset_control_bulk_data *rstcs)
 714 {
 715         int ret, i;
 716
 717         for (i = 0; i < num_rstcs; i++) {
 718                 ret = reset_control_acquire(rstcs[i].rstc);
 719                 if (ret)
 720                         goto err;
 721         }
 722
 723         return 0;
 724
 725 err:
 726         while (i--)
 727                 reset_control_release(rstcs[i].rstc);
 728         return ret;
 729 }
 730 EXPORT_SYMBOL_GPL(reset_control_bulk_acquire);
 731
 732 /**
 733  * reset_control_release() - releases exclusive access to a reset control
 734  * @rstc: reset control
 735  *
 736  * Releases exclusive access right to a reset control previously obtained by a
 737  * call to reset_control_acquire(). Until a consumer calls this function, no
 738  * other consumers will be granted exclusive access.
 739  *
 740  * See also: reset_control_acquire()
 741  */
 742 void reset_control_release(struct reset_control *rstc)
 743 {
 744         if (!rstc || WARN_ON(IS_ERR(rstc)))
 745                 return;
 746
 747         if (reset_control_is_array(rstc))
 748                 reset_control_array_release(rstc_to_array(rstc));
 749         else
 750                 rstc->acquired = false;
 751 }
 752 EXPORT_SYMBOL_GPL(reset_control_release);
 753
 754 /**
 755  * reset_control_bulk_release() - releases exclusive access to reset controls
 756  * @num_rstcs: number of entries in rstcs array
 757  * @rstcs: array of struct reset_control_bulk_data with reset controls set
 758  *
 759  * Releases exclusive access right to reset controls previously obtained by a
 760  * call to reset_control_bulk_acquire().
 761  *
 762  * See also: reset_control_release(), reset_control_bulk_acquire()
 763  */
 764 void reset_control_bulk_release(int num_rstcs,
 765                                 struct reset_control_bulk_data *rstcs)
 766 {
 767         int i;
 768
 769         for (i = 0; i < num_rstcs; i++)
 770                 reset_control_release(rstcs[i].rstc);
 771 }
 772 EXPORT_SYMBOL_GPL(reset_control_bulk_release);
 773
 774 static struct reset_control *
 775 __reset_control_get_internal(struct reset_controller_dev *rcdev,
 776                              unsigned int index, bool shared, bool acquired)
 777 {
 778         struct reset_control *rstc;
 779
 780         lockdep_assert_held(&reset_list_mutex);
 781
 782         list_for_each_entry(rstc, &rcdev->reset_control_head, list) {
 783                 if (rstc->id == index) {
 784                         /*
 785                          * Allow creating a secondary exclusive reset_control
 786                          * that is initially not acquired for an already
 787                          * controlled reset line.
 788                          */
 789                         if (!rstc->shared && !shared && !acquired)
 790                                 break;
 791
 792                         if (WARN_ON(!rstc->shared || !shared))
 793                                 return ERR_PTR(-EBUSY);
 794
 795                         kref_get(&rstc->refcnt);
 796                         return rstc;
 797                 }
 798         }
 799
 800         rstc = kzalloc(sizeof(*rstc), GFP_KERNEL);
 801         if (!rstc)
 802                 return ERR_PTR(-ENOMEM);
 803
 804         if (!try_module_get(rcdev->owner)) {
 805                 kfree(rstc);
 806                 return ERR_PTR(-ENODEV);
 807         }
 808
 809         rstc->rcdev = rcdev;
 810         list_add(&rstc->list, &rcdev->reset_control_head);
 811         rstc->id = index;
 812         kref_init(&rstc->refcnt);
 813         rstc->acquired = acquired;
 814         rstc->shared = shared;
 815
 816         return rstc;
 817 }
 818
 819 static void __reset_control_release(struct kref *kref)
 820 {
 821         struct reset_control *rstc = container_of(kref, struct reset_control,
 822                                                   refcnt);
 823
 824         lockdep_assert_held(&reset_list_mutex);
 825
 826         module_put(rstc->rcdev->owner);
 827
 828         list_del(&rstc->list);
 829         kfree(rstc);
 830 }
 831
 832 static void __reset_control_put_internal(struct reset_control *rstc)
 833 {
 834         lockdep_assert_held(&reset_list_mutex);
 835
 836         if (IS_ERR_OR_NULL(rstc))
 837                 return;
 838
 839         kref_put(&rstc->refcnt, __reset_control_release);
 840 }
 841
 842 static int __reset_add_reset_gpio_lookup(int id, struct device_node *np,
 843                                          unsigned int gpio,
 844                                          unsigned int of_flags)
 845 {
 846         const struct fwnode_handle *fwnode = of_fwnode_handle(np);
 847         unsigned int lookup_flags;
 848         const char *label_tmp;
 849
 850         /*
 851          * Later we map GPIO flags between OF and Linux, however not all
 852          * constants from include/dt-bindings/gpio/gpio.h and
 853          * include/linux/gpio/machine.h match each other.
 854          */
 855         if (of_flags > GPIO_ACTIVE_LOW) {
 856                 pr_err("reset-gpio code does not support GPIO flags %u for GPIO %u\n",
 857                        of_flags, gpio);
 858                 return -EINVAL;
 859         }
 860
 861         struct gpio_device *gdev __free(gpio_device_put) = gpio_device_find_by_fwnode(fwnode);
 862         if (!gdev)
 863                 return -EPROBE_DEFER;
 864
 865         label_tmp = gpio_device_get_label(gdev);
 866         if (!label_tmp)
 867                 return -EINVAL;
 868
 869         char *label __free(kfree) = kstrdup(label_tmp, GFP_KERNEL);
 870         if (!label)
 871                 return -ENOMEM;
 872
 873         /* Size: one lookup entry plus sentinel */
 874         struct gpiod_lookup_table *lookup __free(kfree) = kzalloc(struct_size(lookup, table, 2),
 875                                                                   GFP_KERNEL);
 876         if (!lookup)
 877                 return -ENOMEM;
 878
 879         lookup->dev_id = kasprintf(GFP_KERNEL, "reset-gpio.%d", id);
 880         if (!lookup->dev_id)
 881                 return -ENOMEM;
 882
 883         lookup_flags = GPIO_PERSISTENT;
 884         lookup_flags |= of_flags & GPIO_ACTIVE_LOW;
 885         lookup->table[0] = GPIO_LOOKUP(no_free_ptr(label), gpio, "reset",
 886                                        lookup_flags);
 887
 888         /* Not freed on success, because it is persisent subsystem data. */
 889         gpiod_add_lookup_table(no_free_ptr(lookup));
 890
 891         return 0;
 892 }
 893
 894 /*
 895  * @args:       phandle to the GPIO provider with all the args like GPIO number
 896  */
 897 static int __reset_add_reset_gpio_device(const struct of_phandle_args *args)
 898 {
 899         struct reset_gpio_lookup *rgpio_dev;
 900         struct platform_device *pdev;
 901         int id, ret;
 902
 903         /*
 904          * Currently only #gpio-cells=2 is supported with the meaning of:
 905          * args[0]: GPIO number
 906          * args[1]: GPIO flags
 907          * TODO: Handle other cases.
 908          */
 909         if (args->args_count != 2)
 910                 return -ENOENT;
 911
 912         /*
 913          * Registering reset-gpio device might cause immediate
 914          * bind, resulting in its probe() registering new reset controller thus
 915          * taking reset_list_mutex lock via reset_controller_register().
 916          */
 917         lockdep_assert_not_held(&reset_list_mutex);
 918
 919         mutex_lock(&reset_gpio_lookup_mutex);
 920
 921         list_for_each_entry(rgpio_dev, &reset_gpio_lookup_list, list) {
 922                 if (args->np == rgpio_dev->of_args.np) {
 923                         if (of_phandle_args_equal(args, &rgpio_dev->of_args))
 924                                 goto out; /* Already on the list, done */
 925                 }
 926         }
 927
 928         id = ida_alloc(&reset_gpio_ida, GFP_KERNEL);
 929         if (id < 0) {
 930                 ret = id;
 931                 goto err_unlock;
 932         }
 933
 934         /* Not freed on success, because it is persisent subsystem data. */
 935         rgpio_dev = kzalloc(sizeof(*rgpio_dev), GFP_KERNEL);
 936         if (!rgpio_dev) {
 937                 ret = -ENOMEM;
 938                 goto err_ida_free;
 939         }
 940
 941         ret = __reset_add_reset_gpio_lookup(id, args->np, args->args[0],
 942                                             args->args[1]);
 943         if (ret < 0)
 944                 goto err_kfree;
 945
 946         rgpio_dev->of_args = *args;
 947         /*
 948          * We keep the device_node reference, but of_args.np is put at the end
 949          * of __of_reset_control_get(), so get it one more time.
 950          * Hold reference as long as rgpio_dev memory is valid.
 951          */
 952         of_node_get(rgpio_dev->of_args.np);
 953         pdev = platform_device_register_data(NULL, "reset-gpio", id,
 954                                              &rgpio_dev->of_args,
 955                                              sizeof(rgpio_dev->of_args));
 956         ret = PTR_ERR_OR_ZERO(pdev);
 957         if (ret)
 958                 goto err_put;
 959
 960         list_add(&rgpio_dev->list, &reset_gpio_lookup_list);
 961
 962 out:
 963         mutex_unlock(&reset_gpio_lookup_mutex);
 964
 965         return 0;
 966
 967 err_put:
 968         of_node_put(rgpio_dev->of_args.np);
 969 err_kfree:
 970         kfree(rgpio_dev);
 971 err_ida_free:
 972         ida_free(&reset_gpio_ida, id);
 973 err_unlock:
 974         mutex_unlock(&reset_gpio_lookup_mutex);
 975
 976         return ret;
 977 }
 978
 979 static struct reset_controller_dev *__reset_find_rcdev(const struct of_phandle_args *args,
 980                                                        bool gpio_fallback)
 981 {
 982         struct reset_controller_dev *rcdev;
 983
 984         lockdep_assert_held(&reset_list_mutex);
 985
 986         list_for_each_entry(rcdev, &reset_controller_list, list) {
 987                 if (gpio_fallback) {
 988                         if (rcdev->of_args && of_phandle_args_equal(args,
 989                                                                     rcdev->of_args))
 990                                 return rcdev;
 991                 } else {
 992                         if (args->np == rcdev->of_node)
 993                                 return rcdev;
 994                 }
 995         }
 996
 997         return NULL;
 998 }
 999
1000 struct reset_control *
1001 __of_reset_control_get(struct device_node *node, const char *id, int index,
1002                        bool shared, bool optional, bool acquired)
1003 {
1004         bool gpio_fallback = false;
1005         struct reset_control *rstc;
1006         struct reset_controller_dev *rcdev;
1007         struct of_phandle_args args;
1008         int rstc_id;
1009         int ret;
1010
1011         if (!node)
1012                 return ERR_PTR(-EINVAL);
1013
1014         if (id) {
1015                 index = of_property_match_string(node,
1016                                                  "reset-names", id);
1017                 if (index == -EILSEQ)
1018                         return ERR_PTR(index);
1019                 if (index < 0)
1020                         return optional ? NULL : ERR_PTR(-ENOENT);
1021         }
1022
1023         ret = of_parse_phandle_with_args(node, "resets", "#reset-cells",
1024                                          index, &args);
1025         if (ret == -EINVAL)
1026                 return ERR_PTR(ret);
1027         if (ret) {
1028                 if (!IS_ENABLED(CONFIG_RESET_GPIO))
1029                         return optional ? NULL : ERR_PTR(ret);
1030
1031                 /*
1032                  * There can be only one reset-gpio for regular devices, so
1033                  * don't bother with the "reset-gpios" phandle index.
1034                  */
1035                 ret = of_parse_phandle_with_args(node, "reset-gpios", "#gpio-cells",
1036                                                  0, &args);
1037                 if (ret)
1038                         return optional ? NULL : ERR_PTR(ret);
1039
1040                 gpio_fallback = true;
1041
1042                 ret = __reset_add_reset_gpio_device(&args);
1043                 if (ret) {
1044                         rstc = ERR_PTR(ret);
1045                         goto out_put;
1046                 }
1047         }
1048
1049         mutex_lock(&reset_list_mutex);
1050         rcdev = __reset_find_rcdev(&args, gpio_fallback);
1051         if (!rcdev) {
1052                 rstc = ERR_PTR(-EPROBE_DEFER);
1053                 goto out_unlock;
1054         }
1055
1056         if (WARN_ON(args.args_count != rcdev->of_reset_n_cells)) {
1057                 rstc = ERR_PTR(-EINVAL);
1058                 goto out_unlock;
1059         }
1060
1061         rstc_id = rcdev->of_xlate(rcdev, &args);
1062         if (rstc_id < 0) {
1063                 rstc = ERR_PTR(rstc_id);
1064                 goto out_unlock;
1065         }
1066
1067         /* reset_list_mutex also protects the rcdev's reset_control list */
1068         rstc = __reset_control_get_internal(rcdev, rstc_id, shared, acquired);
1069
1070 out_unlock:
1071         mutex_unlock(&reset_list_mutex);
1072 out_put:
1073         of_node_put(args.np);
1074
1075         return rstc;
1076 }
1077 EXPORT_SYMBOL_GPL(__of_reset_control_get);
1078
1079 static struct reset_controller_dev *
1080 __reset_controller_by_name(const char *name)
1081 {
1082         struct reset_controller_dev *rcdev;
1083
1084         lockdep_assert_held(&reset_list_mutex);
1085
1086         list_for_each_entry(rcdev, &reset_controller_list, list) {
1087                 if (!rcdev->dev)
1088                         continue;
1089
1090                 if (!strcmp(name, dev_name(rcdev->dev)))
1091                         return rcdev;
1092         }
1093
1094         return NULL;
1095 }
1096
1097 static struct reset_control *
1098 __reset_control_get_from_lookup(struct device *dev, const char *con_id,
1099                                 bool shared, bool optional, bool acquired)
1100 {
1101         const struct reset_control_lookup *lookup;
1102         struct reset_controller_dev *rcdev;
1103         const char *dev_id = dev_name(dev);
1104         struct reset_control *rstc = NULL;
1105
1106         mutex_lock(&reset_lookup_mutex);
1107
1108         list_for_each_entry(lookup, &reset_lookup_list, list) {
1109                 if (strcmp(lookup->dev_id, dev_id))
1110                         continue;
1111
1112                 if ((!con_id && !lookup->con_id) ||
1113                     ((con_id && lookup->con_id) &&
1114                      !strcmp(con_id, lookup->con_id))) {
1115                         mutex_lock(&reset_list_mutex);
1116                         rcdev = __reset_controller_by_name(lookup->provider);
1117                         if (!rcdev) {
1118                                 mutex_unlock(&reset_list_mutex);
1119                                 mutex_unlock(&reset_lookup_mutex);
1120                                 /* Reset provider may not be ready yet. */
1121                                 return ERR_PTR(-EPROBE_DEFER);
1122                         }
1123
1124                         rstc = __reset_control_get_internal(rcdev,
1125                                                             lookup->index,
1126                                                             shared, acquired);
1127                         mutex_unlock(&reset_list_mutex);
1128                         break;
1129                 }
1130         }
1131
1132         mutex_unlock(&reset_lookup_mutex);
1133
1134         if (!rstc)
1135                 return optional ? NULL : ERR_PTR(-ENOENT);
1136
1137         return rstc;
1138 }
1139
1140 struct reset_control *__reset_control_get(struct device *dev, const char *id,
1141                                           int index, bool shared, bool optional,
1142                                           bool acquired)
1143 {
1144         if (WARN_ON(shared && acquired))
1145                 return ERR_PTR(-EINVAL);
1146
1147         if (dev->of_node)
1148                 return __of_reset_control_get(dev->of_node, id, index, shared,
1149                                               optional, acquired);
1150
1151         return __reset_control_get_from_lookup(dev, id, shared, optional,
1152                                                acquired);
1153 }
1154 EXPORT_SYMBOL_GPL(__reset_control_get);
1155
1156 int __reset_control_bulk_get(struct device *dev, int num_rstcs,
1157                              struct reset_control_bulk_data *rstcs,
1158                              bool shared, bool optional, bool acquired)
1159 {
1160         int ret, i;
1161
1162         for (i = 0; i < num_rstcs; i++) {
1163                 rstcs[i].rstc = __reset_control_get(dev, rstcs[i].id, 0,
1164                                                     shared, optional, acquired);
1165                 if (IS_ERR(rstcs[i].rstc)) {
1166                         ret = PTR_ERR(rstcs[i].rstc);
1167                         goto err;
1168                 }
1169         }
1170
1171         return 0;
1172
1173 err:
1174         mutex_lock(&reset_list_mutex);
1175         while (i--)
1176                 __reset_control_put_internal(rstcs[i].rstc);
1177         mutex_unlock(&reset_list_mutex);
1178         return ret;
1179 }
1180 EXPORT_SYMBOL_GPL(__reset_control_bulk_get);
1181
1182 static void reset_control_array_put(struct reset_control_array *resets)
1183 {
1184         int i;
1185
1186         mutex_lock(&reset_list_mutex);
1187         for (i = 0; i < resets->num_rstcs; i++)
1188                 __reset_control_put_internal(resets->rstc[i]);
1189         mutex_unlock(&reset_list_mutex);
1190         kfree(resets);
1191 }
1192
1193 /**
1194  * reset_control_put - free the reset controller
1195  * @rstc: reset controller
1196  */
1197 void reset_control_put(struct reset_control *rstc)
1198 {
1199         if (IS_ERR_OR_NULL(rstc))
1200                 return;
1201
1202         if (reset_control_is_array(rstc)) {
1203                 reset_control_array_put(rstc_to_array(rstc));
1204                 return;
1205         }
1206
1207         mutex_lock(&reset_list_mutex);
1208         __reset_control_put_internal(rstc);
1209         mutex_unlock(&reset_list_mutex);
1210 }
1211 EXPORT_SYMBOL_GPL(reset_control_put);
1212
1213 /**
1214  * reset_control_bulk_put - free the reset controllers
1215  * @num_rstcs: number of entries in rstcs array
1216  * @rstcs: array of struct reset_control_bulk_data with reset controls set
1217  */
1218 void reset_control_bulk_put(int num_rstcs, struct reset_control_bulk_data *rstcs)
1219 {
1220         mutex_lock(&reset_list_mutex);
1221         while (num_rstcs--)
1222                 __reset_control_put_internal(rstcs[num_rstcs].rstc);
1223         mutex_unlock(&reset_list_mutex);
1224 }
1225 EXPORT_SYMBOL_GPL(reset_control_bulk_put);
1226
1227 static void devm_reset_control_release(struct device *dev, void *res)
1228 {
1229         reset_control_put(*(struct reset_control **)res);
1230 }
1231
1232 struct reset_control *
1233 __devm_reset_control_get(struct device *dev, const char *id, int index,
1234                          bool shared, bool optional, bool acquired)
1235 {
1236         struct reset_control **ptr, *rstc;
1237
1238         ptr = devres_alloc(devm_reset_control_release, sizeof(*ptr),
1239                            GFP_KERNEL);
1240         if (!ptr)
1241                 return ERR_PTR(-ENOMEM);
1242
1243         rstc = __reset_control_get(dev, id, index, shared, optional, acquired);
1244         if (IS_ERR_OR_NULL(rstc)) {
1245                 devres_free(ptr);
1246                 return rstc;
1247         }
1248
1249         *ptr = rstc;
1250         devres_add(dev, ptr);
1251
1252         return rstc;
1253 }
1254 EXPORT_SYMBOL_GPL(__devm_reset_control_get);
1255
1256 struct reset_control_bulk_devres {
1257         int num_rstcs;
1258         struct reset_control_bulk_data *rstcs;
1259 };
1260
1261 static void devm_reset_control_bulk_release(struct device *dev, void *res)
1262 {
1263         struct reset_control_bulk_devres *devres = res;
1264
1265         reset_control_bulk_put(devres->num_rstcs, devres->rstcs);
1266 }
1267
1268 int __devm_reset_control_bulk_get(struct device *dev, int num_rstcs,
1269                                   struct reset_control_bulk_data *rstcs,
1270                                   bool shared, bool optional, bool acquired)
1271 {
1272         struct reset_control_bulk_devres *ptr;
1273         int ret;
1274
1275         ptr = devres_alloc(devm_reset_control_bulk_release, sizeof(*ptr),
1276                            GFP_KERNEL);
1277         if (!ptr)
1278                 return -ENOMEM;
1279
1280         ret = __reset_control_bulk_get(dev, num_rstcs, rstcs, shared, optional, acquired);
1281         if (ret < 0) {
1282                 devres_free(ptr);
1283                 return ret;
1284         }
1285
1286         ptr->num_rstcs = num_rstcs;
1287         ptr->rstcs = rstcs;
1288         devres_add(dev, ptr);
1289
1290         return 0;
1291 }
1292 EXPORT_SYMBOL_GPL(__devm_reset_control_bulk_get);
1293
1294 /**
1295  * __device_reset - find reset controller associated with the device
1296  *                  and perform reset
1297  * @dev: device to be reset by the controller
1298  * @optional: whether it is optional to reset the device
1299  *
1300  * Convenience wrapper for __reset_control_get() and reset_control_reset().
1301  * This is useful for the common case of devices with single, dedicated reset
1302  * lines. _RST firmware method will be called for devices with ACPI.
1303  */
1304 int __device_reset(struct device *dev, bool optional)
1305 {
1306         struct reset_control *rstc;
1307         int ret;
1308
1309 #ifdef CONFIG_ACPI
1310         acpi_handle handle = ACPI_HANDLE(dev);
1311
1312         if (handle) {
1313                 if (!acpi_has_method(handle, "_RST"))
1314                         return optional ? 0 : -ENOENT;
1315                 if (ACPI_FAILURE(acpi_evaluate_object(handle, "_RST", NULL,
1316                                                       NULL)))
1317                         return -EIO;
1318         }
1319 #endif
1320
1321         rstc = __reset_control_get(dev, NULL, 0, 0, optional, true);
1322         if (IS_ERR(rstc))
1323                 return PTR_ERR(rstc);
1324
1325         ret = reset_control_reset(rstc);
1326
1327         reset_control_put(rstc);
1328
1329         return ret;
1330 }
1331 EXPORT_SYMBOL_GPL(__device_reset);
1332
1333 /*
1334  * APIs to manage an array of reset controls.
1335  */
1336
1337 /**
1338  * of_reset_control_get_count - Count number of resets available with a device
1339  *
1340  * @node: device node that contains 'resets'.
1341  *
1342  * Returns positive reset count on success, or error number on failure and
1343  * on count being zero.
1344  */
1345 static int of_reset_control_get_count(struct device_node *node)
1346 {
1347         int count;
1348
1349         if (!node)
1350                 return -EINVAL;
1351
1352         count = of_count_phandle_with_args(node, "resets", "#reset-cells");
1353         if (count == 0)
1354                 count = -ENOENT;
1355
1356         return count;
1357 }
1358
1359 /**
1360  * of_reset_control_array_get - Get a list of reset controls using
1361  *                              device node.
1362  *
1363  * @np: device node for the device that requests the reset controls array
1364  * @shared: whether reset controls are shared or not
1365  * @optional: whether it is optional to get the reset controls
1366  * @acquired: only one reset control may be acquired for a given controller
1367  *            and ID
1368  *
1369  * Returns pointer to allocated reset_control on success or error on failure
1370  */
1371 struct reset_control *
1372 of_reset_control_array_get(struct device_node *np, bool shared, bool optional,
1373                            bool acquired)
1374 {
1375         struct reset_control_array *resets;
1376         struct reset_control *rstc;
1377         int num, i;
1378
1379         num = of_reset_control_get_count(np);
1380         if (num < 0)
1381                 return optional ? NULL : ERR_PTR(num);
1382
1383         resets = kzalloc(struct_size(resets, rstc, num), GFP_KERNEL);
1384         if (!resets)
1385                 return ERR_PTR(-ENOMEM);
1386         resets->num_rstcs = num;
1387
1388         for (i = 0; i < num; i++) {
1389                 rstc = __of_reset_control_get(np, NULL, i, shared, optional,
1390                                               acquired);
1391                 if (IS_ERR(rstc))
1392                         goto err_rst;
1393                 resets->rstc[i] = rstc;
1394         }
1395         resets->base.array = true;
1396
1397         return &resets->base;
1398
1399 err_rst:
1400         mutex_lock(&reset_list_mutex);
1401         while (--i >= 0)
1402                 __reset_control_put_internal(resets->rstc[i]);
1403         mutex_unlock(&reset_list_mutex);
1404
1405         kfree(resets);
1406
1407         return rstc;
1408 }
1409 EXPORT_SYMBOL_GPL(of_reset_control_array_get);
1410
1411 /**
1412  * devm_reset_control_array_get - Resource managed reset control array get
1413  *
1414  * @dev: device that requests the list of reset controls
1415  * @shared: whether reset controls are shared or not
1416  * @optional: whether it is optional to get the reset controls
1417  *
1418  * The reset control array APIs are intended for a list of resets
1419  * that just have to be asserted or deasserted, without any
1420  * requirements on the order.
1421  *
1422  * Returns pointer to allocated reset_control on success or error on failure
1423  */
1424 struct reset_control *
1425 devm_reset_control_array_get(struct device *dev, bool shared, bool optional)
1426 {
1427         struct reset_control **ptr, *rstc;
1428
1429         ptr = devres_alloc(devm_reset_control_release, sizeof(*ptr),
1430                            GFP_KERNEL);
1431         if (!ptr)
1432                 return ERR_PTR(-ENOMEM);
1433
1434         rstc = of_reset_control_array_get(dev->of_node, shared, optional, true);
1435         if (IS_ERR_OR_NULL(rstc)) {
1436                 devres_free(ptr);
1437                 return rstc;
1438         }
1439
1440         *ptr = rstc;
1441         devres_add(dev, ptr);
1442
1443         return rstc;
1444 }
1445 EXPORT_SYMBOL_GPL(devm_reset_control_array_get);
1446
1447 static int reset_control_get_count_from_lookup(struct device *dev)
1448 {
1449         const struct reset_control_lookup *lookup;
1450         const char *dev_id;
1451         int count = 0;
1452
1453         if (!dev)
1454                 return -EINVAL;
1455
1456         dev_id = dev_name(dev);
1457         mutex_lock(&reset_lookup_mutex);
1458
1459         list_for_each_entry(lookup, &reset_lookup_list, list) {
1460                 if (!strcmp(lookup->dev_id, dev_id))
1461                         count++;
1462         }
1463
1464         mutex_unlock(&reset_lookup_mutex);
1465
1466         if (count == 0)
1467                 count = -ENOENT;
1468
1469         return count;
1470 }
1471
1472 /**
1473  * reset_control_get_count - Count number of resets available with a device
1474  *
1475  * @dev: device for which to return the number of resets
1476  *
1477  * Returns positive reset count on success, or error number on failure and
1478  * on count being zero.
1479  */
1480 int reset_control_get_count(struct device *dev)
1481 {
1482         if (dev->of_node)
1483                 return of_reset_control_get_count(dev->of_node);
1484
1485         return reset_control_get_count_from_lookup(dev);
1486 }
1487 EXPORT_SYMBOL_GPL(reset_control_get_count);