drivers/reset/core.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
rcdev_name
of_reset_simple_xlate
reset_controller_register
reset_controller_unregister
devm_reset_controller_release
devm_reset_controller_register
reset_controller_add_lookup
rstc_to_array
reset_control_array_reset
reset_control_array_assert
reset_control_array_deassert
reset_control_array_acquire
reset_control_array_release
reset_control_is_array
reset_control_reset
reset_control_assert
reset_control_deassert
reset_control_status
reset_control_acquire
reset_control_release
__reset_control_get_internal
__reset_control_release
__reset_control_put_internal
__of_reset_control_get
__reset_controller_by_name
__reset_control_get_from_lookup
__reset_control_get
reset_control_array_put
reset_control_put
devm_reset_control_release
__devm_reset_control_get
__device_reset
of_reset_control_get_count
of_reset_control_array_get
devm_reset_control_array_get
reset_control_get_count_from_lookup
reset_control_get_count
   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/device.h>
   9 #include <linux/err.h>
  10 #include <linux/export.h>
  11 #include <linux/kernel.h>
  12 #include <linux/kref.h>
  13 #include <linux/module.h>
  14 #include <linux/of.h>
  15 #include <linux/reset.h>
  16 #include <linux/reset-controller.h>
  17 #include <linux/slab.h>
  18 
  19 static DEFINE_MUTEX(reset_list_mutex);
  20 static LIST_HEAD(reset_controller_list);
  21 
  22 static DEFINE_MUTEX(reset_lookup_mutex);
  23 static LIST_HEAD(reset_lookup_list);
  24 
  25 /**
  26  * struct reset_control - a reset control
  27  * @rcdev: a pointer to the reset controller device
  28  *         this reset control belongs to
  29  * @list: list entry for the rcdev's reset controller list
  30  * @id: ID of the reset controller in the reset
  31  *      controller device
  32  * @refcnt: Number of gets of this reset_control
  33  * @acquired: Only one reset_control may be acquired for a given rcdev and id.
  34  * @shared: Is this a shared (1), or an exclusive (0) reset_control?
  35  * @deassert_cnt: Number of times this reset line has been deasserted
  36  * @triggered_count: Number of times this reset line has been reset. Currently
  37  *                   only used for shared resets, which means that the value
  38  *                   will be either 0 or 1.
  39  */
  40 struct reset_control {
  41         struct reset_controller_dev *rcdev;
  42         struct list_head list;
  43         unsigned int id;
  44         struct kref refcnt;
  45         bool acquired;
  46         bool shared;
  47         bool array;
  48         atomic_t deassert_count;
  49         atomic_t triggered_count;
  50 };
  51 
  52 /**
  53  * struct reset_control_array - an array of reset controls
  54  * @base: reset control for compatibility with reset control API functions
  55  * @num_rstcs: number of reset controls
  56  * @rstc: array of reset controls
  57  */
  58 struct reset_control_array {
  59         struct reset_control base;
  60         unsigned int num_rstcs;
  61         struct reset_control *rstc[];
  62 };
  63 
  64 static const char *rcdev_name(struct reset_controller_dev *rcdev)
  65 {
  66         if (rcdev->dev)
  67                 return dev_name(rcdev->dev);
  68 
  69         if (rcdev->of_node)
  70                 return rcdev->of_node->full_name;
  71 
  72         return NULL;
  73 }
  74 
  75 /**
  76  * of_reset_simple_xlate - translate reset_spec to the reset line number
  77  * @rcdev: a pointer to the reset controller device
  78  * @reset_spec: reset line specifier as found in the device tree
  79  *
  80  * This simple translation function should be used for reset controllers
  81  * with 1:1 mapping, where reset lines can be indexed by number without gaps.
  82  */
  83 static int of_reset_simple_xlate(struct reset_controller_dev *rcdev,
  84                           const struct of_phandle_args *reset_spec)
  85 {
  86         if (reset_spec->args[0] >= rcdev->nr_resets)
  87                 return -EINVAL;
  88 
  89         return reset_spec->args[0];
  90 }
  91 
  92 /**
  93  * reset_controller_register - register a reset controller device
  94  * @rcdev: a pointer to the initialized reset controller device
  95  */
  96 int reset_controller_register(struct reset_controller_dev *rcdev)
  97 {
  98         if (!rcdev->of_xlate) {
  99                 rcdev->of_reset_n_cells = 1;
 100                 rcdev->of_xlate = of_reset_simple_xlate;
 101         }
 102 
 103         INIT_LIST_HEAD(&rcdev->reset_control_head);
 104 
 105         mutex_lock(&reset_list_mutex);
 106         list_add(&rcdev->list, &reset_controller_list);
 107         mutex_unlock(&reset_list_mutex);
 108 
 109         return 0;
 110 }
 111 EXPORT_SYMBOL_GPL(reset_controller_register);
 112 
 113 /**
 114  * reset_controller_unregister - unregister a reset controller device
 115  * @rcdev: a pointer to the reset controller device
 116  */
 117 void reset_controller_unregister(struct reset_controller_dev *rcdev)
 118 {
 119         mutex_lock(&reset_list_mutex);
 120         list_del(&rcdev->list);
 121         mutex_unlock(&reset_list_mutex);
 122 }
 123 EXPORT_SYMBOL_GPL(reset_controller_unregister);
 124 
 125 static void devm_reset_controller_release(struct device *dev, void *res)
 126 {
 127         reset_controller_unregister(*(struct reset_controller_dev **)res);
 128 }
 129 
 130 /**
 131  * devm_reset_controller_register - resource managed reset_controller_register()
 132  * @dev: device that is registering this reset controller
 133  * @rcdev: a pointer to the initialized reset controller device
 134  *
 135  * Managed reset_controller_register(). For reset controllers registered by
 136  * this function, reset_controller_unregister() is automatically called on
 137  * driver detach. See reset_controller_register() for more information.
 138  */
 139 int devm_reset_controller_register(struct device *dev,
 140                                    struct reset_controller_dev *rcdev)
 141 {
 142         struct reset_controller_dev **rcdevp;
 143         int ret;
 144 
 145         rcdevp = devres_alloc(devm_reset_controller_release, sizeof(*rcdevp),
 146                               GFP_KERNEL);
 147         if (!rcdevp)
 148                 return -ENOMEM;
 149 
 150         ret = reset_controller_register(rcdev);
 151         if (!ret) {
 152                 *rcdevp = rcdev;
 153                 devres_add(dev, rcdevp);
 154         } else {
 155                 devres_free(rcdevp);
 156         }
 157 
 158         return ret;
 159 }
 160 EXPORT_SYMBOL_GPL(devm_reset_controller_register);
 161 
 162 /**
 163  * reset_controller_add_lookup - register a set of lookup entries
 164  * @lookup: array of reset lookup entries
 165  * @num_entries: number of entries in the lookup array
 166  */
 167 void reset_controller_add_lookup(struct reset_control_lookup *lookup,
 168                                  unsigned int num_entries)
 169 {
 170         struct reset_control_lookup *entry;
 171         unsigned int i;
 172 
 173         mutex_lock(&reset_lookup_mutex);
 174         for (i = 0; i < num_entries; i++) {
 175                 entry = &lookup[i];
 176 
 177                 if (!entry->dev_id || !entry->provider) {
 178                         pr_warn("%s(): reset lookup entry badly specified, skipping\n",
 179                                 __func__);
 180                         continue;
 181                 }
 182 
 183                 list_add_tail(&entry->list, &reset_lookup_list);
 184         }
 185         mutex_unlock(&reset_lookup_mutex);
 186 }
 187 EXPORT_SYMBOL_GPL(reset_controller_add_lookup);
 188 
 189 static inline struct reset_control_array *
 190 rstc_to_array(struct reset_control *rstc) {
 191         return container_of(rstc, struct reset_control_array, base);
 192 }
 193 
 194 static int reset_control_array_reset(struct reset_control_array *resets)
 195 {
 196         int ret, i;
 197 
 198         for (i = 0; i < resets->num_rstcs; i++) {
 199                 ret = reset_control_reset(resets->rstc[i]);
 200                 if (ret)
 201                         return ret;
 202         }
 203 
 204         return 0;
 205 }
 206 
 207 static int reset_control_array_assert(struct reset_control_array *resets)
 208 {
 209         int ret, i;
 210 
 211         for (i = 0; i < resets->num_rstcs; i++) {
 212                 ret = reset_control_assert(resets->rstc[i]);
 213                 if (ret)
 214                         goto err;
 215         }
 216 
 217         return 0;
 218 
 219 err:
 220         while (i--)
 221                 reset_control_deassert(resets->rstc[i]);
 222         return ret;
 223 }
 224 
 225 static int reset_control_array_deassert(struct reset_control_array *resets)
 226 {
 227         int ret, i;
 228 
 229         for (i = 0; i < resets->num_rstcs; i++) {
 230                 ret = reset_control_deassert(resets->rstc[i]);
 231                 if (ret)
 232                         goto err;
 233         }
 234 
 235         return 0;
 236 
 237 err:
 238         while (i--)
 239                 reset_control_assert(resets->rstc[i]);
 240         return ret;
 241 }
 242 
 243 static int reset_control_array_acquire(struct reset_control_array *resets)
 244 {
 245         unsigned int i;
 246         int err;
 247 
 248         for (i = 0; i < resets->num_rstcs; i++) {
 249                 err = reset_control_acquire(resets->rstc[i]);
 250                 if (err < 0)
 251                         goto release;
 252         }
 253 
 254         return 0;
 255 
 256 release:
 257         while (i--)
 258                 reset_control_release(resets->rstc[i]);
 259 
 260         return err;
 261 }
 262 
 263 static void reset_control_array_release(struct reset_control_array *resets)
 264 {
 265         unsigned int i;
 266 
 267         for (i = 0; i < resets->num_rstcs; i++)
 268                 reset_control_release(resets->rstc[i]);
 269 }
 270 
 271 static inline bool reset_control_is_array(struct reset_control *rstc)
 272 {
 273         return rstc->array;
 274 }
 275 
 276 /**
 277  * reset_control_reset - reset the controlled device
 278  * @rstc: reset controller
 279  *
 280  * On a shared reset line the actual reset pulse is only triggered once for the
 281  * lifetime of the reset_control instance: for all but the first caller this is
 282  * a no-op.
 283  * Consumers must not use reset_control_(de)assert on shared reset lines when
 284  * reset_control_reset has been used.
 285  *
 286  * If rstc is NULL it is an optional reset and the function will just
 287  * return 0.
 288  */
 289 int reset_control_reset(struct reset_control *rstc)
 290 {
 291         int ret;
 292 
 293         if (!rstc)
 294                 return 0;
 295 
 296         if (WARN_ON(IS_ERR(rstc)))
 297                 return -EINVAL;
 298 
 299         if (reset_control_is_array(rstc))
 300                 return reset_control_array_reset(rstc_to_array(rstc));
 301 
 302         if (!rstc->rcdev->ops->reset)
 303                 return -ENOTSUPP;
 304 
 305         if (rstc->shared) {
 306                 if (WARN_ON(atomic_read(&rstc->deassert_count) != 0))
 307                         return -EINVAL;
 308 
 309                 if (atomic_inc_return(&rstc->triggered_count) != 1)
 310                         return 0;
 311         } else {
 312                 if (!rstc->acquired)
 313                         return -EPERM;
 314         }
 315 
 316         ret = rstc->rcdev->ops->reset(rstc->rcdev, rstc->id);
 317         if (rstc->shared && ret)
 318                 atomic_dec(&rstc->triggered_count);
 319 
 320         return ret;
 321 }
 322 EXPORT_SYMBOL_GPL(reset_control_reset);
 323 
 324 /**
 325  * reset_control_assert - asserts the reset line
 326  * @rstc: reset controller
 327  *
 328  * Calling this on an exclusive reset controller guarantees that the reset
 329  * will be asserted. When called on a shared reset controller the line may
 330  * still be deasserted, as long as other users keep it so.
 331  *
 332  * For shared reset controls a driver cannot expect the hw's registers and
 333  * internal state to be reset, but must be prepared for this to happen.
 334  * Consumers must not use reset_control_reset on shared reset lines when
 335  * reset_control_(de)assert has been used.
 336  * return 0.
 337  *
 338  * If rstc is NULL it is an optional reset and the function will just
 339  * return 0.
 340  */
 341 int reset_control_assert(struct reset_control *rstc)
 342 {
 343         if (!rstc)
 344                 return 0;
 345 
 346         if (WARN_ON(IS_ERR(rstc)))
 347                 return -EINVAL;
 348 
 349         if (reset_control_is_array(rstc))
 350                 return reset_control_array_assert(rstc_to_array(rstc));
 351 
 352         if (rstc->shared) {
 353                 if (WARN_ON(atomic_read(&rstc->triggered_count) != 0))
 354                         return -EINVAL;
 355 
 356                 if (WARN_ON(atomic_read(&rstc->deassert_count) == 0))
 357                         return -EINVAL;
 358 
 359                 if (atomic_dec_return(&rstc->deassert_count) != 0)
 360                         return 0;
 361 
 362                 /*
 363                  * Shared reset controls allow the reset line to be in any state
 364                  * after this call, so doing nothing is a valid option.
 365                  */
 366                 if (!rstc->rcdev->ops->assert)
 367                         return 0;
 368         } else {
 369                 /*
 370                  * If the reset controller does not implement .assert(), there
 371                  * is no way to guarantee that the reset line is asserted after
 372                  * this call.
 373                  */
 374                 if (!rstc->rcdev->ops->assert)
 375                         return -ENOTSUPP;
 376 
 377                 if (!rstc->acquired) {
 378                         WARN(1, "reset %s (ID: %u) is not acquired\n",
 379                              rcdev_name(rstc->rcdev), rstc->id);
 380                         return -EPERM;
 381                 }
 382         }
 383 
 384         return rstc->rcdev->ops->assert(rstc->rcdev, rstc->id);
 385 }
 386 EXPORT_SYMBOL_GPL(reset_control_assert);
 387 
 388 /**
 389  * reset_control_deassert - deasserts the reset line
 390  * @rstc: reset controller
 391  *
 392  * After calling this function, the reset is guaranteed to be deasserted.
 393  * Consumers must not use reset_control_reset on shared reset lines when
 394  * reset_control_(de)assert has been used.
 395  * return 0.
 396  *
 397  * If rstc is NULL it is an optional reset and the function will just
 398  * return 0.
 399  */
 400 int reset_control_deassert(struct reset_control *rstc)
 401 {
 402         if (!rstc)
 403                 return 0;
 404 
 405         if (WARN_ON(IS_ERR(rstc)))
 406                 return -EINVAL;
 407 
 408         if (reset_control_is_array(rstc))
 409                 return reset_control_array_deassert(rstc_to_array(rstc));
 410 
 411         if (rstc->shared) {
 412                 if (WARN_ON(atomic_read(&rstc->triggered_count) != 0))
 413                         return -EINVAL;
 414 
 415                 if (atomic_inc_return(&rstc->deassert_count) != 1)
 416                         return 0;
 417         } else {
 418                 if (!rstc->acquired) {
 419                         WARN(1, "reset %s (ID: %u) is not acquired\n",
 420                              rcdev_name(rstc->rcdev), rstc->id);
 421                         return -EPERM;
 422                 }
 423         }
 424 
 425         /*
 426          * If the reset controller does not implement .deassert(), we assume
 427          * that it handles self-deasserting reset lines via .reset(). In that
 428          * case, the reset lines are deasserted by default. If that is not the
 429          * case, the reset controller driver should implement .deassert() and
 430          * return -ENOTSUPP.
 431          */
 432         if (!rstc->rcdev->ops->deassert)
 433                 return 0;
 434 
 435         return rstc->rcdev->ops->deassert(rstc->rcdev, rstc->id);
 436 }
 437 EXPORT_SYMBOL_GPL(reset_control_deassert);
 438 
 439 /**
 440  * reset_control_status - returns a negative errno if not supported, a
 441  * positive value if the reset line is asserted, or zero if the reset
 442  * line is not asserted or if the desc is NULL (optional reset).
 443  * @rstc: reset controller
 444  */
 445 int reset_control_status(struct reset_control *rstc)
 446 {
 447         if (!rstc)
 448                 return 0;
 449 
 450         if (WARN_ON(IS_ERR(rstc)) || reset_control_is_array(rstc))
 451                 return -EINVAL;
 452 
 453         if (rstc->rcdev->ops->status)
 454                 return rstc->rcdev->ops->status(rstc->rcdev, rstc->id);
 455 
 456         return -ENOTSUPP;
 457 }
 458 EXPORT_SYMBOL_GPL(reset_control_status);
 459 
 460 /**
 461  * reset_control_acquire() - acquires a reset control for exclusive use
 462  * @rstc: reset control
 463  *
 464  * This is used to explicitly acquire a reset control for exclusive use. Note
 465  * that exclusive resets are requested as acquired by default. In order for a
 466  * second consumer to be able to control the reset, the first consumer has to
 467  * release it first. Typically the easiest way to achieve this is to call the
 468  * reset_control_get_exclusive_released() to obtain an instance of the reset
 469  * control. Such reset controls are not acquired by default.
 470  *
 471  * Consumers implementing shared access to an exclusive reset need to follow
 472  * a specific protocol in order to work together. Before consumers can change
 473  * a reset they must acquire exclusive access using reset_control_acquire().
 474  * After they are done operating the reset, they must release exclusive access
 475  * with a call to reset_control_release(). Consumers are not granted exclusive
 476  * access to the reset as long as another consumer hasn't released a reset.
 477  *
 478  * See also: reset_control_release()
 479  */
 480 int reset_control_acquire(struct reset_control *rstc)
 481 {
 482         struct reset_control *rc;
 483 
 484         if (!rstc)
 485                 return 0;
 486 
 487         if (WARN_ON(IS_ERR(rstc)))
 488                 return -EINVAL;
 489 
 490         if (reset_control_is_array(rstc))
 491                 return reset_control_array_acquire(rstc_to_array(rstc));
 492 
 493         mutex_lock(&reset_list_mutex);
 494 
 495         if (rstc->acquired) {
 496                 mutex_unlock(&reset_list_mutex);
 497                 return 0;
 498         }
 499 
 500         list_for_each_entry(rc, &rstc->rcdev->reset_control_head, list) {
 501                 if (rstc != rc && rstc->id == rc->id) {
 502                         if (rc->acquired) {
 503                                 mutex_unlock(&reset_list_mutex);
 504                                 return -EBUSY;
 505                         }
 506                 }
 507         }
 508 
 509         rstc->acquired = true;
 510 
 511         mutex_unlock(&reset_list_mutex);
 512         return 0;
 513 }
 514 EXPORT_SYMBOL_GPL(reset_control_acquire);
 515 
 516 /**
 517  * reset_control_release() - releases exclusive access to a reset control
 518  * @rstc: reset control
 519  *
 520  * Releases exclusive access right to a reset control previously obtained by a
 521  * call to reset_control_acquire(). Until a consumer calls this function, no
 522  * other consumers will be granted exclusive access.
 523  *
 524  * See also: reset_control_acquire()
 525  */
 526 void reset_control_release(struct reset_control *rstc)
 527 {
 528         if (!rstc || WARN_ON(IS_ERR(rstc)))
 529                 return;
 530 
 531         if (reset_control_is_array(rstc))
 532                 reset_control_array_release(rstc_to_array(rstc));
 533         else
 534                 rstc->acquired = false;
 535 }
 536 EXPORT_SYMBOL_GPL(reset_control_release);
 537 
 538 static struct reset_control *__reset_control_get_internal(
 539                                 struct reset_controller_dev *rcdev,
 540                                 unsigned int index, bool shared, bool acquired)
 541 {
 542         struct reset_control *rstc;
 543 
 544         lockdep_assert_held(&reset_list_mutex);
 545 
 546         list_for_each_entry(rstc, &rcdev->reset_control_head, list) {
 547                 if (rstc->id == index) {
 548                         /*
 549                          * Allow creating a secondary exclusive reset_control
 550                          * that is initially not acquired for an already
 551                          * controlled reset line.
 552                          */
 553                         if (!rstc->shared && !shared && !acquired)
 554                                 break;
 555 
 556                         if (WARN_ON(!rstc->shared || !shared))
 557                                 return ERR_PTR(-EBUSY);
 558 
 559                         kref_get(&rstc->refcnt);
 560                         return rstc;
 561                 }
 562         }
 563 
 564         rstc = kzalloc(sizeof(*rstc), GFP_KERNEL);
 565         if (!rstc)
 566                 return ERR_PTR(-ENOMEM);
 567 
 568         try_module_get(rcdev->owner);
 569 
 570         rstc->rcdev = rcdev;
 571         list_add(&rstc->list, &rcdev->reset_control_head);
 572         rstc->id = index;
 573         kref_init(&rstc->refcnt);
 574         rstc->acquired = acquired;
 575         rstc->shared = shared;
 576 
 577         return rstc;
 578 }
 579 
 580 static void __reset_control_release(struct kref *kref)
 581 {
 582         struct reset_control *rstc = container_of(kref, struct reset_control,
 583                                                   refcnt);
 584 
 585         lockdep_assert_held(&reset_list_mutex);
 586 
 587         module_put(rstc->rcdev->owner);
 588 
 589         list_del(&rstc->list);
 590         kfree(rstc);
 591 }
 592 
 593 static void __reset_control_put_internal(struct reset_control *rstc)
 594 {
 595         lockdep_assert_held(&reset_list_mutex);
 596 
 597         kref_put(&rstc->refcnt, __reset_control_release);
 598 }
 599 
 600 struct reset_control *__of_reset_control_get(struct device_node *node,
 601                                      const char *id, int index, bool shared,
 602                                      bool optional, bool acquired)
 603 {
 604         struct reset_control *rstc;
 605         struct reset_controller_dev *r, *rcdev;
 606         struct of_phandle_args args;
 607         int rstc_id;
 608         int ret;
 609 
 610         if (!node)
 611                 return ERR_PTR(-EINVAL);
 612 
 613         if (id) {
 614                 index = of_property_match_string(node,
 615                                                  "reset-names", id);
 616                 if (index == -EILSEQ)
 617                         return ERR_PTR(index);
 618                 if (index < 0)
 619                         return optional ? NULL : ERR_PTR(-ENOENT);
 620         }
 621 
 622         ret = of_parse_phandle_with_args(node, "resets", "#reset-cells",
 623                                          index, &args);
 624         if (ret == -EINVAL)
 625                 return ERR_PTR(ret);
 626         if (ret)
 627                 return optional ? NULL : ERR_PTR(ret);
 628 
 629         mutex_lock(&reset_list_mutex);
 630         rcdev = NULL;
 631         list_for_each_entry(r, &reset_controller_list, list) {
 632                 if (args.np == r->of_node) {
 633                         rcdev = r;
 634                         break;
 635                 }
 636         }
 637 
 638         if (!rcdev) {
 639                 rstc = ERR_PTR(-EPROBE_DEFER);
 640                 goto out;
 641         }
 642 
 643         if (WARN_ON(args.args_count != rcdev->of_reset_n_cells)) {
 644                 rstc = ERR_PTR(-EINVAL);
 645                 goto out;
 646         }
 647 
 648         rstc_id = rcdev->of_xlate(rcdev, &args);
 649         if (rstc_id < 0) {
 650                 rstc = ERR_PTR(rstc_id);
 651                 goto out;
 652         }
 653 
 654         /* reset_list_mutex also protects the rcdev's reset_control list */
 655         rstc = __reset_control_get_internal(rcdev, rstc_id, shared, acquired);
 656 
 657 out:
 658         mutex_unlock(&reset_list_mutex);
 659         of_node_put(args.np);
 660 
 661         return rstc;
 662 }
 663 EXPORT_SYMBOL_GPL(__of_reset_control_get);
 664 
 665 static struct reset_controller_dev *
 666 __reset_controller_by_name(const char *name)
 667 {
 668         struct reset_controller_dev *rcdev;
 669 
 670         lockdep_assert_held(&reset_list_mutex);
 671 
 672         list_for_each_entry(rcdev, &reset_controller_list, list) {
 673                 if (!rcdev->dev)
 674                         continue;
 675 
 676                 if (!strcmp(name, dev_name(rcdev->dev)))
 677                         return rcdev;
 678         }
 679 
 680         return NULL;
 681 }
 682 
 683 static struct reset_control *
 684 __reset_control_get_from_lookup(struct device *dev, const char *con_id,
 685                                 bool shared, bool optional, bool acquired)
 686 {
 687         const struct reset_control_lookup *lookup;
 688         struct reset_controller_dev *rcdev;
 689         const char *dev_id = dev_name(dev);
 690         struct reset_control *rstc = NULL;
 691 
 692         mutex_lock(&reset_lookup_mutex);
 693 
 694         list_for_each_entry(lookup, &reset_lookup_list, list) {
 695                 if (strcmp(lookup->dev_id, dev_id))
 696                         continue;
 697 
 698                 if ((!con_id && !lookup->con_id) ||
 699                     ((con_id && lookup->con_id) &&
 700                      !strcmp(con_id, lookup->con_id))) {
 701                         mutex_lock(&reset_list_mutex);
 702                         rcdev = __reset_controller_by_name(lookup->provider);
 703                         if (!rcdev) {
 704                                 mutex_unlock(&reset_list_mutex);
 705                                 mutex_unlock(&reset_lookup_mutex);
 706                                 /* Reset provider may not be ready yet. */
 707                                 return ERR_PTR(-EPROBE_DEFER);
 708                         }
 709 
 710                         rstc = __reset_control_get_internal(rcdev,
 711                                                             lookup->index,
 712                                                             shared, acquired);
 713                         mutex_unlock(&reset_list_mutex);
 714                         break;
 715                 }
 716         }
 717 
 718         mutex_unlock(&reset_lookup_mutex);
 719 
 720         if (!rstc)
 721                 return optional ? NULL : ERR_PTR(-ENOENT);
 722 
 723         return rstc;
 724 }
 725 
 726 struct reset_control *__reset_control_get(struct device *dev, const char *id,
 727                                           int index, bool shared, bool optional,
 728                                           bool acquired)
 729 {
 730         if (WARN_ON(shared && acquired))
 731                 return ERR_PTR(-EINVAL);
 732 
 733         if (dev->of_node)
 734                 return __of_reset_control_get(dev->of_node, id, index, shared,
 735                                               optional, acquired);
 736 
 737         return __reset_control_get_from_lookup(dev, id, shared, optional,
 738                                                acquired);
 739 }
 740 EXPORT_SYMBOL_GPL(__reset_control_get);
 741 
 742 static void reset_control_array_put(struct reset_control_array *resets)
 743 {
 744         int i;
 745 
 746         mutex_lock(&reset_list_mutex);
 747         for (i = 0; i < resets->num_rstcs; i++)
 748                 __reset_control_put_internal(resets->rstc[i]);
 749         mutex_unlock(&reset_list_mutex);
 750         kfree(resets);
 751 }
 752 
 753 /**
 754  * reset_control_put - free the reset controller
 755  * @rstc: reset controller
 756  */
 757 void reset_control_put(struct reset_control *rstc)
 758 {
 759         if (IS_ERR_OR_NULL(rstc))
 760                 return;
 761 
 762         if (reset_control_is_array(rstc)) {
 763                 reset_control_array_put(rstc_to_array(rstc));
 764                 return;
 765         }
 766 
 767         mutex_lock(&reset_list_mutex);
 768         __reset_control_put_internal(rstc);
 769         mutex_unlock(&reset_list_mutex);
 770 }
 771 EXPORT_SYMBOL_GPL(reset_control_put);
 772 
 773 static void devm_reset_control_release(struct device *dev, void *res)
 774 {
 775         reset_control_put(*(struct reset_control **)res);
 776 }
 777 
 778 struct reset_control *__devm_reset_control_get(struct device *dev,
 779                                      const char *id, int index, bool shared,
 780                                      bool optional, bool acquired)
 781 {
 782         struct reset_control **ptr, *rstc;
 783 
 784         ptr = devres_alloc(devm_reset_control_release, sizeof(*ptr),
 785                            GFP_KERNEL);
 786         if (!ptr)
 787                 return ERR_PTR(-ENOMEM);
 788 
 789         rstc = __reset_control_get(dev, id, index, shared, optional, acquired);
 790         if (!IS_ERR_OR_NULL(rstc)) {
 791                 *ptr = rstc;
 792                 devres_add(dev, ptr);
 793         } else {
 794                 devres_free(ptr);
 795         }
 796 
 797         return rstc;
 798 }
 799 EXPORT_SYMBOL_GPL(__devm_reset_control_get);
 800 
 801 /**
 802  * device_reset - find reset controller associated with the device
 803  *                and perform reset
 804  * @dev: device to be reset by the controller
 805  * @optional: whether it is optional to reset the device
 806  *
 807  * Convenience wrapper for __reset_control_get() and reset_control_reset().
 808  * This is useful for the common case of devices with single, dedicated reset
 809  * lines.
 810  */
 811 int __device_reset(struct device *dev, bool optional)
 812 {
 813         struct reset_control *rstc;
 814         int ret;
 815 
 816         rstc = __reset_control_get(dev, NULL, 0, 0, optional, true);
 817         if (IS_ERR(rstc))
 818                 return PTR_ERR(rstc);
 819 
 820         ret = reset_control_reset(rstc);
 821 
 822         reset_control_put(rstc);
 823 
 824         return ret;
 825 }
 826 EXPORT_SYMBOL_GPL(__device_reset);
 827 
 828 /*
 829  * APIs to manage an array of reset controls.
 830  */
 831 
 832 /**
 833  * of_reset_control_get_count - Count number of resets available with a device
 834  *
 835  * @node: device node that contains 'resets'.
 836  *
 837  * Returns positive reset count on success, or error number on failure and
 838  * on count being zero.
 839  */
 840 static int of_reset_control_get_count(struct device_node *node)
 841 {
 842         int count;
 843 
 844         if (!node)
 845                 return -EINVAL;
 846 
 847         count = of_count_phandle_with_args(node, "resets", "#reset-cells");
 848         if (count == 0)
 849                 count = -ENOENT;
 850 
 851         return count;
 852 }
 853 
 854 /**
 855  * of_reset_control_array_get - Get a list of reset controls using
 856  *                              device node.
 857  *
 858  * @np: device node for the device that requests the reset controls array
 859  * @shared: whether reset controls are shared or not
 860  * @optional: whether it is optional to get the reset controls
 861  * @acquired: only one reset control may be acquired for a given controller
 862  *            and ID
 863  *
 864  * Returns pointer to allocated reset_control on success or error on failure
 865  */
 866 struct reset_control *
 867 of_reset_control_array_get(struct device_node *np, bool shared, bool optional,
 868                            bool acquired)
 869 {
 870         struct reset_control_array *resets;
 871         struct reset_control *rstc;
 872         int num, i;
 873 
 874         num = of_reset_control_get_count(np);
 875         if (num < 0)
 876                 return optional ? NULL : ERR_PTR(num);
 877 
 878         resets = kzalloc(struct_size(resets, rstc, num), GFP_KERNEL);
 879         if (!resets)
 880                 return ERR_PTR(-ENOMEM);
 881 
 882         for (i = 0; i < num; i++) {
 883                 rstc = __of_reset_control_get(np, NULL, i, shared, optional,
 884                                               acquired);
 885                 if (IS_ERR(rstc))
 886                         goto err_rst;
 887                 resets->rstc[i] = rstc;
 888         }
 889         resets->num_rstcs = num;
 890         resets->base.array = true;
 891 
 892         return &resets->base;
 893 
 894 err_rst:
 895         mutex_lock(&reset_list_mutex);
 896         while (--i >= 0)
 897                 __reset_control_put_internal(resets->rstc[i]);
 898         mutex_unlock(&reset_list_mutex);
 899 
 900         kfree(resets);
 901 
 902         return rstc;
 903 }
 904 EXPORT_SYMBOL_GPL(of_reset_control_array_get);
 905 
 906 /**
 907  * devm_reset_control_array_get - Resource managed reset control array get
 908  *
 909  * @dev: device that requests the list of reset controls
 910  * @shared: whether reset controls are shared or not
 911  * @optional: whether it is optional to get the reset controls
 912  *
 913  * The reset control array APIs are intended for a list of resets
 914  * that just have to be asserted or deasserted, without any
 915  * requirements on the order.
 916  *
 917  * Returns pointer to allocated reset_control on success or error on failure
 918  */
 919 struct reset_control *
 920 devm_reset_control_array_get(struct device *dev, bool shared, bool optional)
 921 {
 922         struct reset_control **devres;
 923         struct reset_control *rstc;
 924 
 925         devres = devres_alloc(devm_reset_control_release, sizeof(*devres),
 926                               GFP_KERNEL);
 927         if (!devres)
 928                 return ERR_PTR(-ENOMEM);
 929 
 930         rstc = of_reset_control_array_get(dev->of_node, shared, optional, true);
 931         if (IS_ERR_OR_NULL(rstc)) {
 932                 devres_free(devres);
 933                 return rstc;
 934         }
 935 
 936         *devres = rstc;
 937         devres_add(dev, devres);
 938 
 939         return rstc;
 940 }
 941 EXPORT_SYMBOL_GPL(devm_reset_control_array_get);
 942 
 943 static int reset_control_get_count_from_lookup(struct device *dev)
 944 {
 945         const struct reset_control_lookup *lookup;
 946         const char *dev_id;
 947         int count = 0;
 948 
 949         if (!dev)
 950                 return -EINVAL;
 951 
 952         dev_id = dev_name(dev);
 953         mutex_lock(&reset_lookup_mutex);
 954 
 955         list_for_each_entry(lookup, &reset_lookup_list, list) {
 956                 if (!strcmp(lookup->dev_id, dev_id))
 957                         count++;
 958         }
 959 
 960         mutex_unlock(&reset_lookup_mutex);
 961 
 962         if (count == 0)
 963                 count = -ENOENT;
 964 
 965         return count;
 966 }
 967 
 968 /**
 969  * reset_control_get_count - Count number of resets available with a device
 970  *
 971  * @dev: device for which to return the number of resets
 972  *
 973  * Returns positive reset count on success, or error number on failure and
 974  * on count being zero.
 975  */
 976 int reset_control_get_count(struct device *dev)
 977 {
 978         if (dev->of_node)
 979                 return of_reset_control_get_count(dev->of_node);
 980 
 981         return reset_control_get_count_from_lookup(dev);
 982 }
 983 EXPORT_SYMBOL_GPL(reset_control_get_count);
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/reset/core.c

DEFINITIONS
