cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

core.c (32272B)


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