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, enum reset_control_flags flags)
 777 {
 778         bool shared = flags & RESET_CONTROL_FLAGS_BIT_SHARED;
 779         bool acquired = flags & RESET_CONTROL_FLAGS_BIT_ACQUIRED;
 780         struct reset_control *rstc;
 781
 782         lockdep_assert_held(&reset_list_mutex);
 783
 784         /* Expect callers to filter out OPTIONAL and DEASSERTED bits */
 785         if (WARN_ON(flags & ~(RESET_CONTROL_FLAGS_BIT_SHARED |
 786                               RESET_CONTROL_FLAGS_BIT_ACQUIRED)))
 787                 return ERR_PTR(-EINVAL);
 788
 789         list_for_each_entry(rstc, &rcdev->reset_control_head, list) {
 790                 if (rstc->id == index) {
 791                         /*
 792                          * Allow creating a secondary exclusive reset_control
 793                          * that is initially not acquired for an already
 794                          * controlled reset line.
 795                          */
 796                         if (!rstc->shared && !shared && !acquired)
 797                                 break;
 798
 799                         if (WARN_ON(!rstc->shared || !shared))
 800                                 return ERR_PTR(-EBUSY);
 801
 802                         kref_get(&rstc->refcnt);
 803                         return rstc;
 804                 }
 805         }
 806
 807         rstc = kzalloc(sizeof(*rstc), GFP_KERNEL);
 808         if (!rstc)
 809                 return ERR_PTR(-ENOMEM);
 810
 811         if (!try_module_get(rcdev->owner)) {
 812                 kfree(rstc);
 813                 return ERR_PTR(-ENODEV);
 814         }
 815
 816         rstc->rcdev = rcdev;
 817         list_add(&rstc->list, &rcdev->reset_control_head);
 818         rstc->id = index;
 819         kref_init(&rstc->refcnt);
 820         rstc->acquired = acquired;
 821         rstc->shared = shared;
 822         get_device(rcdev->dev);
 823
 824         return rstc;
 825 }
 826
 827 static void __reset_control_release(struct kref *kref)
 828 {
 829         struct reset_control *rstc = container_of(kref, struct reset_control,
 830                                                   refcnt);
 831
 832         lockdep_assert_held(&reset_list_mutex);
 833
 834         module_put(rstc->rcdev->owner);
 835
 836         list_del(&rstc->list);
 837         put_device(rstc->rcdev->dev);
 838         kfree(rstc);
 839 }
 840
 841 static void __reset_control_put_internal(struct reset_control *rstc)
 842 {
 843         lockdep_assert_held(&reset_list_mutex);
 844
 845         if (IS_ERR_OR_NULL(rstc))
 846                 return;
 847
 848         kref_put(&rstc->refcnt, __reset_control_release);
 849 }
 850
 851 static int __reset_add_reset_gpio_lookup(int id, struct device_node *np,
 852                                          unsigned int gpio,
 853                                          unsigned int of_flags)
 854 {
 855         const struct fwnode_handle *fwnode = of_fwnode_handle(np);
 856         unsigned int lookup_flags;
 857         const char *label_tmp;
 858
 859         /*
 860          * Later we map GPIO flags between OF and Linux, however not all
 861          * constants from include/dt-bindings/gpio/gpio.h and
 862          * include/linux/gpio/machine.h match each other.
 863          */
 864         if (of_flags > GPIO_ACTIVE_LOW) {
 865                 pr_err("reset-gpio code does not support GPIO flags %u for GPIO %u\n",
 866                        of_flags, gpio);
 867                 return -EINVAL;
 868         }
 869
 870         struct gpio_device *gdev __free(gpio_device_put) = gpio_device_find_by_fwnode(fwnode);
 871         if (!gdev)
 872                 return -EPROBE_DEFER;
 873
 874         label_tmp = gpio_device_get_label(gdev);
 875         if (!label_tmp)
 876                 return -EINVAL;
 877
 878         char *label __free(kfree) = kstrdup(label_tmp, GFP_KERNEL);
 879         if (!label)
 880                 return -ENOMEM;
 881
 882         /* Size: one lookup entry plus sentinel */
 883         struct gpiod_lookup_table *lookup __free(kfree) = kzalloc(struct_size(lookup, table, 2),
 884                                                                   GFP_KERNEL);
 885         if (!lookup)
 886                 return -ENOMEM;
 887
 888         lookup->dev_id = kasprintf(GFP_KERNEL, "reset-gpio.%d", id);
 889         if (!lookup->dev_id)
 890                 return -ENOMEM;
 891
 892         lookup_flags = GPIO_PERSISTENT;
 893         lookup_flags |= of_flags & GPIO_ACTIVE_LOW;
 894         lookup->table[0] = GPIO_LOOKUP(no_free_ptr(label), gpio, "reset",
 895                                        lookup_flags);
 896
 897         /* Not freed on success, because it is persisent subsystem data. */
 898         gpiod_add_lookup_table(no_free_ptr(lookup));
 899
 900         return 0;
 901 }
 902
 903 /*
 904  * @args:       phandle to the GPIO provider with all the args like GPIO number
 905  */
 906 static int __reset_add_reset_gpio_device(const struct of_phandle_args *args)
 907 {
 908         struct reset_gpio_lookup *rgpio_dev;
 909         struct platform_device *pdev;
 910         int id, ret;
 911
 912         /*
 913          * Currently only #gpio-cells=2 is supported with the meaning of:
 914          * args[0]: GPIO number
 915          * args[1]: GPIO flags
 916          * TODO: Handle other cases.
 917          */
 918         if (args->args_count != 2)
 919                 return -ENOENT;
 920
 921         /*
 922          * Registering reset-gpio device might cause immediate
 923          * bind, resulting in its probe() registering new reset controller thus
 924          * taking reset_list_mutex lock via reset_controller_register().
 925          */
 926         lockdep_assert_not_held(&reset_list_mutex);
 927
 928         guard(mutex)(&reset_gpio_lookup_mutex);
 929
 930         list_for_each_entry(rgpio_dev, &reset_gpio_lookup_list, list) {
 931                 if (args->np == rgpio_dev->of_args.np) {
 932                         if (of_phandle_args_equal(args, &rgpio_dev->of_args))
 933                                 return 0; /* Already on the list, done */
 934                 }
 935         }
 936
 937         id = ida_alloc(&reset_gpio_ida, GFP_KERNEL);
 938         if (id < 0)
 939                 return id;
 940
 941         /* Not freed on success, because it is persisent subsystem data. */
 942         rgpio_dev = kzalloc(sizeof(*rgpio_dev), GFP_KERNEL);
 943         if (!rgpio_dev) {
 944                 ret = -ENOMEM;
 945                 goto err_ida_free;
 946         }
 947
 948         ret = __reset_add_reset_gpio_lookup(id, args->np, args->args[0],
 949                                             args->args[1]);
 950         if (ret < 0)
 951                 goto err_kfree;
 952
 953         rgpio_dev->of_args = *args;
 954         /*
 955          * We keep the device_node reference, but of_args.np is put at the end
 956          * of __of_reset_control_get(), so get it one more time.
 957          * Hold reference as long as rgpio_dev memory is valid.
 958          */
 959         of_node_get(rgpio_dev->of_args.np);
 960         pdev = platform_device_register_data(NULL, "reset-gpio", id,
 961                                              &rgpio_dev->of_args,
 962                                              sizeof(rgpio_dev->of_args));
 963         ret = PTR_ERR_OR_ZERO(pdev);
 964         if (ret)
 965                 goto err_put;
 966
 967         list_add(&rgpio_dev->list, &reset_gpio_lookup_list);
 968
 969         return 0;
 970
 971 err_put:
 972         of_node_put(rgpio_dev->of_args.np);
 973 err_kfree:
 974         kfree(rgpio_dev);
 975 err_ida_free:
 976         ida_free(&reset_gpio_ida, id);
 977
 978         return ret;
 979 }
 980
 981 static struct reset_controller_dev *__reset_find_rcdev(const struct of_phandle_args *args,
 982                                                        bool gpio_fallback)
 983 {
 984         struct reset_controller_dev *rcdev;
 985
 986         lockdep_assert_held(&reset_list_mutex);
 987
 988         list_for_each_entry(rcdev, &reset_controller_list, list) {
 989                 if (gpio_fallback) {
 990                         if (rcdev->of_args && of_phandle_args_equal(args,
 991                                                                     rcdev->of_args))
 992                                 return rcdev;
 993                 } else {
 994                         if (args->np == rcdev->of_node)
 995                                 return rcdev;
 996                 }
 997         }
 998
 999         return NULL;
1000 }
1001
1002 struct reset_control *
1003 __of_reset_control_get(struct device_node *node, const char *id, int index,
1004                        enum reset_control_flags flags)
1005 {
1006         bool optional = flags & RESET_CONTROL_FLAGS_BIT_OPTIONAL;
1007         bool gpio_fallback = false;
1008         struct reset_control *rstc;
1009         struct reset_controller_dev *rcdev;
1010         struct of_phandle_args args;
1011         int rstc_id;
1012         int ret;
1013
1014         if (!node)
1015                 return ERR_PTR(-EINVAL);
1016
1017         if (id) {
1018                 index = of_property_match_string(node,
1019                                                  "reset-names", id);
1020                 if (index == -EILSEQ)
1021                         return ERR_PTR(index);
1022                 if (index < 0)
1023                         return optional ? NULL : ERR_PTR(-ENOENT);
1024         }
1025
1026         ret = of_parse_phandle_with_args(node, "resets", "#reset-cells",
1027                                          index, &args);
1028         if (ret == -EINVAL)
1029                 return ERR_PTR(ret);
1030         if (ret) {
1031                 if (!IS_ENABLED(CONFIG_RESET_GPIO))
1032                         return optional ? NULL : ERR_PTR(ret);
1033
1034                 /*
1035                  * There can be only one reset-gpio for regular devices, so
1036                  * don't bother with the "reset-gpios" phandle index.
1037                  */
1038                 ret = of_parse_phandle_with_args(node, "reset-gpios", "#gpio-cells",
1039                                                  0, &args);
1040                 if (ret)
1041                         return optional ? NULL : ERR_PTR(ret);
1042
1043                 gpio_fallback = true;
1044
1045                 ret = __reset_add_reset_gpio_device(&args);
1046                 if (ret) {
1047                         rstc = ERR_PTR(ret);
1048                         goto out_put;
1049                 }
1050         }
1051
1052         mutex_lock(&reset_list_mutex);
1053         rcdev = __reset_find_rcdev(&args, gpio_fallback);
1054         if (!rcdev) {
1055                 rstc = ERR_PTR(-EPROBE_DEFER);
1056                 goto out_unlock;
1057         }
1058
1059         if (WARN_ON(args.args_count != rcdev->of_reset_n_cells)) {
1060                 rstc = ERR_PTR(-EINVAL);
1061                 goto out_unlock;
1062         }
1063
1064         rstc_id = rcdev->of_xlate(rcdev, &args);
1065         if (rstc_id < 0) {
1066                 rstc = ERR_PTR(rstc_id);
1067                 goto out_unlock;
1068         }
1069
1070         flags &= ~RESET_CONTROL_FLAGS_BIT_OPTIONAL;
1071
1072         /* reset_list_mutex also protects the rcdev's reset_control list */
1073         rstc = __reset_control_get_internal(rcdev, rstc_id, flags);
1074
1075 out_unlock:
1076         mutex_unlock(&reset_list_mutex);
1077 out_put:
1078         of_node_put(args.np);
1079
1080         return rstc;
1081 }
1082 EXPORT_SYMBOL_GPL(__of_reset_control_get);
1083
1084 static struct reset_controller_dev *
1085 __reset_controller_by_name(const char *name)
1086 {
1087         struct reset_controller_dev *rcdev;
1088
1089         lockdep_assert_held(&reset_list_mutex);
1090
1091         list_for_each_entry(rcdev, &reset_controller_list, list) {
1092                 if (!rcdev->dev)
1093                         continue;
1094
1095                 if (!strcmp(name, dev_name(rcdev->dev)))
1096                         return rcdev;
1097         }
1098
1099         return NULL;
1100 }
1101
1102 static struct reset_control *
1103 __reset_control_get_from_lookup(struct device *dev, const char *con_id,
1104                                 enum reset_control_flags flags)
1105 {
1106         bool optional = flags & RESET_CONTROL_FLAGS_BIT_OPTIONAL;
1107         const struct reset_control_lookup *lookup;
1108         struct reset_controller_dev *rcdev;
1109         const char *dev_id = dev_name(dev);
1110         struct reset_control *rstc = NULL;
1111
1112         mutex_lock(&reset_lookup_mutex);
1113
1114         list_for_each_entry(lookup, &reset_lookup_list, list) {
1115                 if (strcmp(lookup->dev_id, dev_id))
1116                         continue;
1117
1118                 if ((!con_id && !lookup->con_id) ||
1119                     ((con_id && lookup->con_id) &&
1120                      !strcmp(con_id, lookup->con_id))) {
1121                         mutex_lock(&reset_list_mutex);
1122                         rcdev = __reset_controller_by_name(lookup->provider);
1123                         if (!rcdev) {
1124                                 mutex_unlock(&reset_list_mutex);
1125                                 mutex_unlock(&reset_lookup_mutex);
1126                                 /* Reset provider may not be ready yet. */
1127                                 return ERR_PTR(-EPROBE_DEFER);
1128                         }
1129
1130                         flags &= ~RESET_CONTROL_FLAGS_BIT_OPTIONAL;
1131
1132                         rstc = __reset_control_get_internal(rcdev,
1133                                                             lookup->index,
1134                                                             flags);
1135                         mutex_unlock(&reset_list_mutex);
1136                         break;
1137                 }
1138         }
1139
1140         mutex_unlock(&reset_lookup_mutex);
1141
1142         if (!rstc)
1143                 return optional ? NULL : ERR_PTR(-ENOENT);
1144
1145         return rstc;
1146 }
1147
1148 struct reset_control *__reset_control_get(struct device *dev, const char *id,
1149                                           int index, enum reset_control_flags flags)
1150 {
1151         bool shared = flags & RESET_CONTROL_FLAGS_BIT_SHARED;
1152         bool acquired = flags & RESET_CONTROL_FLAGS_BIT_ACQUIRED;
1153
1154         if (WARN_ON(shared && acquired))
1155                 return ERR_PTR(-EINVAL);
1156
1157         if (dev->of_node)
1158                 return __of_reset_control_get(dev->of_node, id, index, flags);
1159
1160         return __reset_control_get_from_lookup(dev, id, flags);
1161 }
1162 EXPORT_SYMBOL_GPL(__reset_control_get);
1163
1164 int __reset_control_bulk_get(struct device *dev, int num_rstcs,
1165                              struct reset_control_bulk_data *rstcs,
1166                              enum reset_control_flags flags)
1167 {
1168         int ret, i;
1169
1170         for (i = 0; i < num_rstcs; i++) {
1171                 rstcs[i].rstc = __reset_control_get(dev, rstcs[i].id, 0, flags);
1172                 if (IS_ERR(rstcs[i].rstc)) {
1173                         ret = PTR_ERR(rstcs[i].rstc);
1174                         goto err;
1175                 }
1176         }
1177
1178         return 0;
1179
1180 err:
1181         mutex_lock(&reset_list_mutex);
1182         while (i--)
1183                 __reset_control_put_internal(rstcs[i].rstc);
1184         mutex_unlock(&reset_list_mutex);
1185         return ret;
1186 }
1187 EXPORT_SYMBOL_GPL(__reset_control_bulk_get);
1188
1189 static void reset_control_array_put(struct reset_control_array *resets)
1190 {
1191         int i;
1192
1193         mutex_lock(&reset_list_mutex);
1194         for (i = 0; i < resets->num_rstcs; i++)
1195                 __reset_control_put_internal(resets->rstc[i]);
1196         mutex_unlock(&reset_list_mutex);
1197         kfree(resets);
1198 }
1199
1200 /**
1201  * reset_control_put - free the reset controller
1202  * @rstc: reset controller
1203  */
1204 void reset_control_put(struct reset_control *rstc)
1205 {
1206         if (IS_ERR_OR_NULL(rstc))
1207                 return;
1208
1209         if (reset_control_is_array(rstc)) {
1210                 reset_control_array_put(rstc_to_array(rstc));
1211                 return;
1212         }
1213
1214         mutex_lock(&reset_list_mutex);
1215         __reset_control_put_internal(rstc);
1216         mutex_unlock(&reset_list_mutex);
1217 }
1218 EXPORT_SYMBOL_GPL(reset_control_put);
1219
1220 /**
1221  * reset_control_bulk_put - free the reset controllers
1222  * @num_rstcs: number of entries in rstcs array
1223  * @rstcs: array of struct reset_control_bulk_data with reset controls set
1224  */
1225 void reset_control_bulk_put(int num_rstcs, struct reset_control_bulk_data *rstcs)
1226 {
1227         mutex_lock(&reset_list_mutex);
1228         while (num_rstcs--)
1229                 __reset_control_put_internal(rstcs[num_rstcs].rstc);
1230         mutex_unlock(&reset_list_mutex);
1231 }
1232 EXPORT_SYMBOL_GPL(reset_control_bulk_put);
1233
1234 static void devm_reset_control_release(struct device *dev, void *res)
1235 {
1236         reset_control_put(*(struct reset_control **)res);
1237 }
1238
1239 static void devm_reset_control_release_deasserted(struct device *dev, void *res)
1240 {
1241         struct reset_control *rstc = *(struct reset_control **)res;
1242
1243         reset_control_assert(rstc);
1244         reset_control_put(rstc);
1245 }
1246
1247 struct reset_control *
1248 __devm_reset_control_get(struct device *dev, const char *id, int index,
1249                          enum reset_control_flags flags)
1250 {
1251         struct reset_control **ptr, *rstc;
1252         bool deasserted = flags & RESET_CONTROL_FLAGS_BIT_DEASSERTED;
1253
1254         ptr = devres_alloc(deasserted ? devm_reset_control_release_deasserted :
1255                            devm_reset_control_release, sizeof(*ptr),
1256                            GFP_KERNEL);
1257         if (!ptr)
1258                 return ERR_PTR(-ENOMEM);
1259
1260         flags &= ~RESET_CONTROL_FLAGS_BIT_DEASSERTED;
1261
1262         rstc = __reset_control_get(dev, id, index, flags);
1263         if (IS_ERR_OR_NULL(rstc)) {
1264                 devres_free(ptr);
1265                 return rstc;
1266         }
1267
1268         if (deasserted) {
1269                 int ret;
1270
1271                 ret = reset_control_deassert(rstc);
1272                 if (ret) {
1273                         reset_control_put(rstc);
1274                         devres_free(ptr);
1275                         return ERR_PTR(ret);
1276                 }
1277         }
1278
1279         *ptr = rstc;
1280         devres_add(dev, ptr);
1281
1282         return rstc;
1283 }
1284 EXPORT_SYMBOL_GPL(__devm_reset_control_get);
1285
1286 struct reset_control_bulk_devres {
1287         int num_rstcs;
1288         struct reset_control_bulk_data *rstcs;
1289 };
1290
1291 static void devm_reset_control_bulk_release(struct device *dev, void *res)
1292 {
1293         struct reset_control_bulk_devres *devres = res;
1294
1295         reset_control_bulk_put(devres->num_rstcs, devres->rstcs);
1296 }
1297
1298 static void devm_reset_control_bulk_release_deasserted(struct device *dev, void *res)
1299 {
1300         struct reset_control_bulk_devres *devres = res;
1301
1302         reset_control_bulk_assert(devres->num_rstcs, devres->rstcs);
1303         reset_control_bulk_put(devres->num_rstcs, devres->rstcs);
1304 }
1305
1306 int __devm_reset_control_bulk_get(struct device *dev, int num_rstcs,
1307                                   struct reset_control_bulk_data *rstcs,
1308                                   enum reset_control_flags flags)
1309 {
1310         struct reset_control_bulk_devres *ptr;
1311         bool deasserted = flags & RESET_CONTROL_FLAGS_BIT_DEASSERTED;
1312         int ret;
1313
1314         ptr = devres_alloc(deasserted ? devm_reset_control_bulk_release_deasserted :
1315                            devm_reset_control_bulk_release, sizeof(*ptr),
1316                            GFP_KERNEL);
1317         if (!ptr)
1318                 return -ENOMEM;
1319
1320         flags &= ~RESET_CONTROL_FLAGS_BIT_DEASSERTED;
1321
1322         ret = __reset_control_bulk_get(dev, num_rstcs, rstcs, flags);
1323         if (ret < 0) {
1324                 devres_free(ptr);
1325                 return ret;
1326         }
1327
1328         if (deasserted) {
1329                 ret = reset_control_bulk_deassert(num_rstcs, rstcs);
1330                 if (ret) {
1331                         reset_control_bulk_put(num_rstcs, rstcs);
1332                         devres_free(ptr);
1333                         return ret;
1334                 }
1335         }
1336
1337         ptr->num_rstcs = num_rstcs;
1338         ptr->rstcs = rstcs;
1339         devres_add(dev, ptr);
1340
1341         return 0;
1342 }
1343 EXPORT_SYMBOL_GPL(__devm_reset_control_bulk_get);
1344
1345 /**
1346  * __device_reset - find reset controller associated with the device
1347  *                  and perform reset
1348  * @dev: device to be reset by the controller
1349  * @optional: whether it is optional to reset the device
1350  *
1351  * Convenience wrapper for __reset_control_get() and reset_control_reset().
1352  * This is useful for the common case of devices with single, dedicated reset
1353  * lines. _RST firmware method will be called for devices with ACPI.
1354  */
1355 int __device_reset(struct device *dev, bool optional)
1356 {
1357         enum reset_control_flags flags;
1358         struct reset_control *rstc;
1359         int ret;
1360
1361 #ifdef CONFIG_ACPI
1362         acpi_handle handle = ACPI_HANDLE(dev);
1363
1364         if (handle) {
1365                 if (!acpi_has_method(handle, "_RST"))
1366                         return optional ? 0 : -ENOENT;
1367                 if (ACPI_FAILURE(acpi_evaluate_object(handle, "_RST", NULL,
1368                                                       NULL)))
1369                         return -EIO;
1370         }
1371 #endif
1372
1373         flags = optional ? RESET_CONTROL_OPTIONAL_EXCLUSIVE : RESET_CONTROL_EXCLUSIVE;
1374         rstc = __reset_control_get(dev, NULL, 0, flags);
1375         if (IS_ERR(rstc))
1376                 return PTR_ERR(rstc);
1377
1378         ret = reset_control_reset(rstc);
1379
1380         reset_control_put(rstc);
1381
1382         return ret;
1383 }
1384 EXPORT_SYMBOL_GPL(__device_reset);
1385
1386 /*
1387  * APIs to manage an array of reset controls.
1388  */
1389
1390 /**
1391  * of_reset_control_get_count - Count number of resets available with a device
1392  *
1393  * @node: device node that contains 'resets'.
1394  *
1395  * Returns positive reset count on success, or error number on failure and
1396  * on count being zero.
1397  */
1398 static int of_reset_control_get_count(struct device_node *node)
1399 {
1400         int count;
1401
1402         if (!node)
1403                 return -EINVAL;
1404
1405         count = of_count_phandle_with_args(node, "resets", "#reset-cells");
1406         if (count == 0)
1407                 count = -ENOENT;
1408
1409         return count;
1410 }
1411
1412 /**
1413  * of_reset_control_array_get - Get a list of reset controls using
1414  *                              device node.
1415  *
1416  * @np: device node for the device that requests the reset controls array
1417  * @flags: whether reset controls are shared, optional, acquired
1418  *
1419  * Returns pointer to allocated reset_control on success or error on failure
1420  */
1421 struct reset_control *
1422 of_reset_control_array_get(struct device_node *np, enum reset_control_flags flags)
1423 {
1424         bool optional = flags & RESET_CONTROL_FLAGS_BIT_OPTIONAL;
1425         struct reset_control_array *resets;
1426         struct reset_control *rstc;
1427         int num, i;
1428
1429         num = of_reset_control_get_count(np);
1430         if (num < 0)
1431                 return optional ? NULL : ERR_PTR(num);
1432
1433         resets = kzalloc(struct_size(resets, rstc, num), GFP_KERNEL);
1434         if (!resets)
1435                 return ERR_PTR(-ENOMEM);
1436         resets->num_rstcs = num;
1437
1438         for (i = 0; i < num; i++) {
1439                 rstc = __of_reset_control_get(np, NULL, i, flags);
1440                 if (IS_ERR(rstc))
1441                         goto err_rst;
1442                 resets->rstc[i] = rstc;
1443         }
1444         resets->base.array = true;
1445
1446         return &resets->base;
1447
1448 err_rst:
1449         mutex_lock(&reset_list_mutex);
1450         while (--i >= 0)
1451                 __reset_control_put_internal(resets->rstc[i]);
1452         mutex_unlock(&reset_list_mutex);
1453
1454         kfree(resets);
1455
1456         return rstc;
1457 }
1458 EXPORT_SYMBOL_GPL(of_reset_control_array_get);
1459
1460 /**
1461  * devm_reset_control_array_get - Resource managed reset control array get
1462  *
1463  * @dev: device that requests the list of reset controls
1464  * @flags: whether reset controls are shared, optional, acquired
1465  *
1466  * The reset control array APIs are intended for a list of resets
1467  * that just have to be asserted or deasserted, without any
1468  * requirements on the order.
1469  *
1470  * Returns pointer to allocated reset_control on success or error on failure
1471  */
1472 struct reset_control *
1473 devm_reset_control_array_get(struct device *dev, enum reset_control_flags flags)
1474 {
1475         struct reset_control **ptr, *rstc;
1476
1477         ptr = devres_alloc(devm_reset_control_release, sizeof(*ptr),
1478                            GFP_KERNEL);
1479         if (!ptr)
1480                 return ERR_PTR(-ENOMEM);
1481
1482         rstc = of_reset_control_array_get(dev->of_node, flags);
1483         if (IS_ERR_OR_NULL(rstc)) {
1484                 devres_free(ptr);
1485                 return rstc;
1486         }
1487
1488         *ptr = rstc;
1489         devres_add(dev, ptr);
1490
1491         return rstc;
1492 }
1493 EXPORT_SYMBOL_GPL(devm_reset_control_array_get);
1494
1495 static int reset_control_get_count_from_lookup(struct device *dev)
1496 {
1497         const struct reset_control_lookup *lookup;
1498         const char *dev_id;
1499         int count = 0;
1500
1501         if (!dev)
1502                 return -EINVAL;
1503
1504         dev_id = dev_name(dev);
1505         mutex_lock(&reset_lookup_mutex);
1506
1507         list_for_each_entry(lookup, &reset_lookup_list, list) {
1508                 if (!strcmp(lookup->dev_id, dev_id))
1509                         count++;
1510         }
1511
1512         mutex_unlock(&reset_lookup_mutex);
1513
1514         if (count == 0)
1515                 count = -ENOENT;
1516
1517         return count;
1518 }
1519
1520 /**
1521  * reset_control_get_count - Count number of resets available with a device
1522  *
1523  * @dev: device for which to return the number of resets
1524  *
1525  * Returns positive reset count on success, or error number on failure and
1526  * on count being zero.
1527  */
1528 int reset_control_get_count(struct device *dev)
1529 {
1530         if (dev->of_node)
1531                 return of_reset_control_get_count(dev->of_node);
1532
1533         return reset_control_get_count_from_lookup(dev);
1534 }
1535 EXPORT_SYMBOL_GPL(reset_control_get_count);