// SPDX-License-Identifier: GPL-2.0-or-later/* * Reset Controller framework * * Copyright 2013 Philipp Zabel, Pengutronix */ #include <linux/acpi.h>#include <linux/atomic.h>#include <linux/auxiliary_bus.h>#include <linux/cleanup.h>#include <linux/device.h>#include <linux/err.h>#include <linux/export.h>#include <linux/fwnode.h>#include <linux/gpio/driver.h>#include <linux/gpio/machine.h>#include <linux/gpio/property.h>#include <linux/idr.h>#include <linux/kernel.h>#include <linux/kref.h>#include <linux/module.h>#include <linux/of.h>#include <linux/property.h>#include <linux/reset.h>#include <linux/reset-controller.h>#include <linux/slab.h>#include <linux/srcu.h> static DEFINE_MUTEX(reset_list_mutex);static LIST_HEAD(reset_controller_list); /* Protects reset_gpio_lookup_list */static DEFINE_MUTEX(reset_gpio_lookup_mutex);static LIST_HEAD(reset_gpio_lookup_list);static DEFINE_IDA(reset_gpio_ida); /** * struct reset_control - a reset control * @rcdev: a pointer to the reset controller device * this reset control belongs to * @srcu: protects the rcdev pointer from removal during consumer access * @list: list entry for the rcdev's reset controller list * @id: ID of the reset controller in the reset * controller device * @refcnt: Number of gets of this reset_control * @acquired: Only one reset_control may be acquired for a given rcdev and id. * @shared: Is this a shared (1), or an exclusive (0) reset_control? * @array: Is this an array of reset controls (1)? * @deassert_count: Number of times this reset line has been deasserted * @triggered_count: Number of times this reset line has been reset. Currently * only used for shared resets, which means that the value * will be either 0 or 1. * @lock: serializes the internals of reset_control_acquire() */struct reset_control { struct reset_controller_dev __rcu *rcdev; struct srcu_struct srcu; struct list_head list; unsigned int id; struct kref refcnt; bool acquired; bool shared; bool array; atomic_t deassert_count; atomic_t triggered_count; struct mutex lock;}; /** * struct reset_control_array - an array of reset controls * @base: reset control for compatibility with reset control API functions * @num_rstcs: number of reset controls * @rstc: array of reset controls */struct reset_control_array { struct reset_control base; unsigned int num_rstcs; struct reset_control *rstc[] __counted_by(num_rstcs);}; /** * struct reset_gpio_lookup - lookup key for ad-hoc created reset-gpio devices * @ref_args: Reference to the reset controller with all the args like GPIO number * @swnode: Software node containing the reference to the GPIO provider * @list: list entry for the reset_gpio_lookup_list * @adev: Auxiliary device representing the reset controller */struct reset_gpio_lookup { struct fwnode_reference_args ref_args; struct fwnode_handle *swnode; struct list_head list; struct auxiliary_device adev;}; static const char *rcdev_name(struct reset_controller_dev *rcdev){ if (rcdev->dev) return dev_name(rcdev->dev); if (rcdev->fwnode) return fwnode_get_name(rcdev->fwnode); return NULL;} /** * fwnode_reset_simple_xlate - translate reset_spec to the reset line number * @rcdev: a pointer to the reset controller device * @reset_spec: reset line specifier as found in firmware * * This static translation function is used by default if neither fwnode_xlate * not of_xlate in :c:type:`reset_controller_dev` is not set. It is useful for * all reset controllers with 1:1 mapping, where reset lines can be indexed by * number without gaps. */static int fwnode_reset_simple_xlate(struct reset_controller_dev *rcdev, const struct fwnode_reference_args *reset_spec){ if (reset_spec->args[0] >= rcdev->nr_resets) return -EINVAL; return reset_spec->args[0];} /** * reset_controller_register - register a reset controller device * @rcdev: a pointer to the initialized reset controller device */int reset_controller_register(struct reset_controller_dev *rcdev){ if ((rcdev->of_node && rcdev->fwnode) || (rcdev->of_xlate && rcdev->fwnode_xlate)) return -EINVAL; if (rcdev->of_node && !rcdev->fwnode) rcdev->fwnode = of_fwnode_handle(rcdev->of_node); if (!rcdev->fwnode) { rcdev->fwnode = dev_fwnode(rcdev->dev); if (!rcdev->fwnode) return -EINVAL; } if (rcdev->of_xlate) rcdev->fwnode_reset_n_cells = rcdev->of_reset_n_cells; if (!rcdev->fwnode_xlate && !rcdev->of_xlate) { rcdev->fwnode_xlate = fwnode_reset_simple_xlate; rcdev->fwnode_reset_n_cells = 1; } INIT_LIST_HEAD(&rcdev->reset_control_head); mutex_init(&rcdev->lock); guard(mutex)(&reset_list_mutex); list_add(&rcdev->list, &reset_controller_list); return 0;}EXPORT_SYMBOL_GPL(reset_controller_register); static void reset_controller_remove(struct reset_controller_dev *rcdev, struct reset_control *rstc){ lockdep_assert_held(&rcdev->lock); list_del(&rstc->list); module_put(rcdev->owner); put_device(rcdev->dev);} /** * reset_controller_unregister - unregister a reset controller device * @rcdev: a pointer to the reset controller device */void reset_controller_unregister(struct reset_controller_dev *rcdev){ struct reset_control *rstc, *pos; scoped_guard(mutex, &reset_list_mutex) list_del(&rcdev->list); scoped_guard(mutex, &rcdev->lock) { /* * Numb but don't free the remaining reset control handles that are * still held by consumers. */ list_for_each_entry_safe(rstc, pos, &rcdev->reset_control_head, list) { rcu_assign_pointer(rstc->rcdev, NULL); synchronize_srcu(&rstc->srcu); reset_controller_remove(rcdev, rstc); } } mutex_destroy(&rcdev->lock);}EXPORT_SYMBOL_GPL(reset_controller_unregister); static void devm_reset_controller_release(struct device *dev, void *res){ reset_controller_unregister(*(struct reset_controller_dev **)res);} /** * devm_reset_controller_register - resource managed reset_controller_register() * @dev: device that is registering this reset controller * @rcdev: a pointer to the initialized reset controller device * * Managed reset_controller_register(). For reset controllers registered by * this function, reset_controller_unregister() is automatically called on * driver detach. See reset_controller_register() for more information. */int devm_reset_controller_register(struct device *dev, struct reset_controller_dev *rcdev){ struct reset_controller_dev **rcdevp; int ret; rcdevp = devres_alloc(devm_reset_controller_release, sizeof(*rcdevp), GFP_KERNEL); if (!rcdevp) return -ENOMEM; ret = reset_controller_register(rcdev); if (ret) { devres_free(rcdevp); return ret; } *rcdevp = rcdev; devres_add(dev, rcdevp); return ret;}EXPORT_SYMBOL_GPL(devm_reset_controller_register); static inline struct reset_control_array *rstc_to_array(struct reset_control *rstc) { return container_of(rstc, struct reset_control_array, base);} static int reset_control_array_reset(struct reset_control_array *resets){ int ret, i; for (i = 0; i < resets->num_rstcs; i++) { ret = reset_control_reset(resets->rstc[i]); if (ret) return ret; } return 0;} static int reset_control_array_rearm(struct reset_control_array *resets){ struct reset_control *rstc; int i; for (i = 0; i < resets->num_rstcs; i++) { rstc = resets->rstc[i]; if (!rstc) continue; if (WARN_ON(IS_ERR(rstc))) return -EINVAL; if (rstc->shared) { if (WARN_ON(atomic_read(&rstc->deassert_count) != 0)) return -EINVAL; } else { if (!rstc->acquired) return -EPERM; } } for (i = 0; i < resets->num_rstcs; i++) { rstc = resets->rstc[i]; if (rstc && rstc->shared) WARN_ON(atomic_dec_return(&rstc->triggered_count) < 0); } return 0;} static int reset_control_array_assert(struct reset_control_array *resets){ int ret, i; for (i = 0; i < resets->num_rstcs; i++) { ret = reset_control_assert(resets->rstc[i]); if (ret) goto err; } return 0; err: while (i--) reset_control_deassert(resets->rstc[i]); return ret;} static int reset_control_array_deassert(struct reset_control_array *resets){ int ret, i; for (i = 0; i < resets->num_rstcs; i++) { ret = reset_control_deassert(resets->rstc[i]); if (ret) goto err; } return 0; err: while (i--) reset_control_assert(resets->rstc[i]); return ret;} static int reset_control_array_acquire(struct reset_control_array *resets){ unsigned int i; int err; for (i = 0; i < resets->num_rstcs; i++) { err = reset_control_acquire(resets->rstc[i]); if (err < 0) goto release; } return 0; release: while (i--) reset_control_release(resets->rstc[i]); return err;} static void reset_control_array_release(struct reset_control_array *resets){ unsigned int i; for (i = 0; i < resets->num_rstcs; i++) reset_control_release(resets->rstc[i]);} static inline bool reset_control_is_array(struct reset_control *rstc){ return rstc->array;} /** * reset_control_reset - reset the controlled device * @rstc: reset controller * * On a shared reset line the actual reset pulse is only triggered once for the * lifetime of the reset_control instance: for all but the first caller this is * a no-op. * Consumers must not use reset_control_(de)assert on shared reset lines when * reset_control_reset has been used. * * If rstc is NULL it is an optional reset and the function will just * return 0. */int reset_control_reset(struct reset_control *rstc){ struct reset_controller_dev *rcdev; int ret; if (!rstc) return 0; if (WARN_ON(IS_ERR(rstc))) return -EINVAL; if (reset_control_is_array(rstc)) return reset_control_array_reset(rstc_to_array(rstc)); guard(srcu)(&rstc->srcu); rcdev = srcu_dereference(rstc->rcdev, &rstc->srcu); if (!rcdev) return -ENODEV; if (!rcdev->ops->reset) return -ENOTSUPP; if (rstc->shared) { if (WARN_ON(atomic_read(&rstc->deassert_count) != 0)) return -EINVAL; if (atomic_inc_return(&rstc->triggered_count) != 1) return 0; } else { if (!rstc->acquired) return -EPERM; } ret = rcdev->ops->reset(rcdev, rstc->id); if (rstc->shared && ret) atomic_dec(&rstc->triggered_count); return ret;}EXPORT_SYMBOL_GPL(reset_control_reset); /** * reset_control_bulk_reset - reset the controlled devices in order * @num_rstcs: number of entries in rstcs array * @rstcs: array of struct reset_control_bulk_data with reset controls set * * Issue a reset on all provided reset controls, in order. * * See also: reset_control_reset() */int reset_control_bulk_reset(int num_rstcs, struct reset_control_bulk_data *rstcs){ int ret, i; for (i = 0; i < num_rstcs; i++) { ret = reset_control_reset(rstcs[i].rstc); if (ret) return ret; } return 0;}EXPORT_SYMBOL_GPL(reset_control_bulk_reset); /** * reset_control_rearm - allow shared reset line to be re-triggered * @rstc: reset controller * * On a shared reset line the actual reset pulse is only triggered once for the * lifetime of the reset_control instance, except if this call is used. * * Calls to this function must be balanced with calls to reset_control_reset, * a warning is thrown in case triggered_count ever dips below 0. * * Consumers must not use reset_control_(de)assert on shared reset lines when * reset_control_reset or reset_control_rearm have been used. * * If rstc is NULL the function will just return 0. */int reset_control_rearm(struct reset_control *rstc){ if (!rstc) return 0; if (WARN_ON(IS_ERR(rstc))) return -EINVAL; if (reset_control_is_array(rstc)) return reset_control_array_rearm(rstc_to_array(rstc)); if (rstc->shared) { if (WARN_ON(atomic_read(&rstc->deassert_count) != 0)) return -EINVAL; WARN_ON(atomic_dec_return(&rstc->triggered_count) < 0); } else { if (!rstc->acquired) return -EPERM; } return 0;}EXPORT_SYMBOL_GPL(reset_control_rearm); /** * reset_control_assert - asserts the reset line * @rstc: reset controller * * Calling this on an exclusive reset controller guarantees that the reset * will be asserted. When called on a shared reset controller the line may * still be deasserted, as long as other users keep it so. * * For shared reset controls a driver cannot expect the hw's registers and * internal state to be reset, but must be prepared for this to happen. * Consumers must not use reset_control_reset on shared reset lines when * reset_control_(de)assert has been used. * * If rstc is NULL it is an optional reset and the function will just * return 0. */int reset_control_assert(struct reset_control *rstc){ struct reset_controller_dev *rcdev; if (!rstc) return 0; if (WARN_ON(IS_ERR(rstc)))Lines 1–500 of 1606. Load more
// SPDX-License-Identifier: GPL-2.0-or-later /* * Reset Controller framework * * Copyright 2013 Philipp Zabel, Pengutronix */ #include <linux/acpi.h> #include <linux/atomic.h> #include <linux/auxiliary_bus.h> #include <linux/cleanup.h> #include <linux/device.h> #include <linux/err.h> #include <linux/export.h> #include <linux/fwnode.h> #include <linux/gpio/driver.h> #include <linux/gpio/machine.h> #include <linux/gpio/property.h> #include <linux/idr.h> #include <linux/kernel.h> #include <linux/kref.h> #include <linux/module.h> #include <linux/of.h> #include <linux/property.h> #include <linux/reset.h> #include <linux/reset-controller.h> #include <linux/slab.h> #include <linux/srcu.h> static DEFINE_MUTEX(reset_list_mutex); static LIST_HEAD(reset_controller_list); /* Protects reset_gpio_lookup_list */ static DEFINE_MUTEX(reset_gpio_lookup_mutex); static LIST_HEAD(reset_gpio_lookup_list); static DEFINE_IDA(reset_gpio_ida); /** * struct reset_control - a reset control * @rcdev: a pointer to the reset controller device * this reset control belongs to * @srcu: protects the rcdev pointer from removal during consumer access * @list: list entry for the rcdev's reset controller list * @id: ID of the reset controller in the reset * controller device * @refcnt: Number of gets of this reset_control * @acquired: Only one reset_control may be acquired for a given rcdev and id. * @shared: Is this a shared (1), or an exclusive (0) reset_control? * @array: Is this an array of reset controls (1)? * @deassert_count: Number of times this reset line has been deasserted * @triggered_count: Number of times this reset line has been reset. Currently * only used for shared resets, which means that the value * will be either 0 or 1. * @lock: serializes the internals of reset_control_acquire() */ struct reset_control { struct reset_controller_dev __rcu *rcdev; struct srcu_struct srcu; struct list_head list; unsigned int id; struct kref refcnt; bool acquired; bool shared; bool array; atomic_t deassert_count; atomic_t triggered_count; struct mutex lock; }; /** * struct reset_control_array - an array of reset controls * @base: reset control for compatibility with reset control API functions * @num_rstcs: number of reset controls * @rstc: array of reset controls */ struct reset_control_array { struct reset_control base; unsigned int num_rstcs; struct reset_control *rstc[] __counted_by(num_rstcs); }; /** * struct reset_gpio_lookup - lookup key for ad-hoc created reset-gpio devices * @ref_args: Reference to the reset controller with all the args like GPIO number * @swnode: Software node containing the reference to the GPIO provider * @list: list entry for the reset_gpio_lookup_list * @adev: Auxiliary device representing the reset controller */ struct reset_gpio_lookup { struct fwnode_reference_args ref_args; struct fwnode_handle *swnode; struct list_head list; struct auxiliary_device adev; }; static const char *rcdev_name(struct reset_controller_dev *rcdev) { if (rcdev->dev) return dev_name(rcdev->dev); if (rcdev->fwnode) return fwnode_get_name(rcdev->fwnode); return NULL; } /** * fwnode_reset_simple_xlate - translate reset_spec to the reset line number * @rcdev: a pointer to the reset controller device * @reset_spec: reset line specifier as found in firmware * * This static translation function is used by default if neither fwnode_xlate * not of_xlate in :c:type:`reset_controller_dev` is not set. It is useful for * all reset controllers with 1:1 mapping, where reset lines can be indexed by * number without gaps. */ static int fwnode_reset_simple_xlate(struct reset_controller_dev *rcdev, const struct fwnode_reference_args *reset_spec) { if (reset_spec->args[0] >= rcdev->nr_resets) return -EINVAL; return reset_spec->args[0]; } /** * reset_controller_register - register a reset controller device * @rcdev: a pointer to the initialized reset controller device */ int reset_controller_register(struct reset_controller_dev *rcdev) { if ((rcdev->of_node && rcdev->fwnode) || (rcdev->of_xlate && rcdev->fwnode_xlate)) return -EINVAL; if (rcdev->of_node && !rcdev->fwnode) rcdev->fwnode = of_fwnode_handle(rcdev->of_node); if (!rcdev->fwnode) { rcdev->fwnode = dev_fwnode(rcdev->dev); if (!rcdev->fwnode) return -EINVAL; } if (rcdev->of_xlate) rcdev->fwnode_reset_n_cells = rcdev->of_reset_n_cells; if (!rcdev->fwnode_xlate && !rcdev->of_xlate) { rcdev->fwnode_xlate = fwnode_reset_simple_xlate; rcdev->fwnode_reset_n_cells = 1; } INIT_LIST_HEAD(&rcdev->reset_control_head); mutex_init(&rcdev->lock); guard(mutex)(&reset_list_mutex); list_add(&rcdev->list, &reset_controller_list); return 0; } EXPORT_SYMBOL_GPL(reset_controller_register); static void reset_controller_remove(struct reset_controller_dev *rcdev, struct reset_control *rstc) { lockdep_assert_held(&rcdev->lock); list_del(&rstc->list); module_put(rcdev->owner); put_device(rcdev->dev); } /** * reset_controller_unregister - unregister a reset controller device * @rcdev: a pointer to the reset controller device */ void reset_controller_unregister(struct reset_controller_dev *rcdev) { struct reset_control *rstc, *pos; scoped_guard(mutex, &reset_list_mutex) list_del(&rcdev->list); scoped_guard(mutex, &rcdev->lock) { /* * Numb but don't free the remaining reset control handles that are * still held by consumers. */ list_for_each_entry_safe(rstc, pos, &rcdev->reset_control_head, list) { rcu_assign_pointer(rstc->rcdev, NULL); synchronize_srcu(&rstc->srcu); reset_controller_remove(rcdev, rstc); } } mutex_destroy(&rcdev->lock); } EXPORT_SYMBOL_GPL(reset_controller_unregister); static void devm_reset_controller_release(struct device *dev, void *res) { reset_controller_unregister(*(struct reset_controller_dev **)res); } /** * devm_reset_controller_register - resource managed reset_controller_register() * @dev: device that is registering this reset controller * @rcdev: a pointer to the initialized reset controller device * * Managed reset_controller_register(). For reset controllers registered by * this function, reset_controller_unregister() is automatically called on * driver detach. See reset_controller_register() for more information. */ int devm_reset_controller_register(struct device *dev, struct reset_controller_dev *rcdev) { struct reset_controller_dev **rcdevp; int ret; rcdevp = devres_alloc(devm_reset_controller_release, sizeof(*rcdevp), GFP_KERNEL); if (!rcdevp) return -ENOMEM; ret = reset_controller_register(rcdev); if (ret) { devres_free(rcdevp); return ret; } *rcdevp = rcdev; devres_add(dev, rcdevp); return ret; } EXPORT_SYMBOL_GPL(devm_reset_controller_register); static inline struct reset_control_array * rstc_to_array(struct reset_control *rstc) { return container_of(rstc, struct reset_control_array, base); } static int reset_control_array_reset(struct reset_control_array *resets) { int ret, i; for (i = 0; i < resets->num_rstcs; i++) { ret = reset_control_reset(resets->rstc[i]); if (ret) return ret; } return 0; } static int reset_control_array_rearm(struct reset_control_array *resets) { struct reset_control *rstc; int i; for (i = 0; i < resets->num_rstcs; i++) { rstc = resets->rstc[i]; if (!rstc) continue; if (WARN_ON(IS_ERR(rstc))) return -EINVAL; if (rstc->shared) { if (WARN_ON(atomic_read(&rstc->deassert_count) != 0)) return -EINVAL; } else { if (!rstc->acquired) return -EPERM; } } for (i = 0; i < resets->num_rstcs; i++) { rstc = resets->rstc[i]; if (rstc && rstc->shared) WARN_ON(atomic_dec_return(&rstc->triggered_count) < 0); } return 0; } static int reset_control_array_assert(struct reset_control_array *resets) { int ret, i; for (i = 0; i < resets->num_rstcs; i++) { ret = reset_control_assert(resets->rstc[i]); if (ret) goto err; } return 0; err: while (i--) reset_control_deassert(resets->rstc[i]); return ret; } static int reset_control_array_deassert(struct reset_control_array *resets) { int ret, i; for (i = 0; i < resets->num_rstcs; i++) { ret = reset_control_deassert(resets->rstc[i]); if (ret) goto err; } return 0; err: while (i--) reset_control_assert(resets->rstc[i]); return ret; } static int reset_control_array_acquire(struct reset_control_array *resets) { unsigned int i; int err; for (i = 0; i < resets->num_rstcs; i++) { err = reset_control_acquire(resets->rstc[i]); if (err < 0) goto release; } return 0; release: while (i--) reset_control_release(resets->rstc[i]); return err; } static void reset_control_array_release(struct reset_control_array *resets) { unsigned int i; for (i = 0; i < resets->num_rstcs; i++) reset_control_release(resets->rstc[i]); } static inline bool reset_control_is_array(struct reset_control *rstc) { return rstc->array; } /** * reset_control_reset - reset the controlled device * @rstc: reset controller * * On a shared reset line the actual reset pulse is only triggered once for the * lifetime of the reset_control instance: for all but the first caller this is * a no-op. * Consumers must not use reset_control_(de)assert on shared reset lines when * reset_control_reset has been used. * * If rstc is NULL it is an optional reset and the function will just * return 0. */ int reset_control_reset(struct reset_control *rstc) { struct reset_controller_dev *rcdev; int ret; if (!rstc) return 0; if (WARN_ON(IS_ERR(rstc))) return -EINVAL; if (reset_control_is_array(rstc)) return reset_control_array_reset(rstc_to_array(rstc)); guard(srcu)(&rstc->srcu); rcdev = srcu_dereference(rstc->rcdev, &rstc->srcu); if (!rcdev) return -ENODEV; if (!rcdev->ops->reset) return -ENOTSUPP; if (rstc->shared) { if (WARN_ON(atomic_read(&rstc->deassert_count) != 0)) return -EINVAL; if (atomic_inc_return(&rstc->triggered_count) != 1) return 0; } else { if (!rstc->acquired) return -EPERM; } ret = rcdev->ops->reset(rcdev, rstc->id); if (rstc->shared && ret) atomic_dec(&rstc->triggered_count); return ret; } EXPORT_SYMBOL_GPL(reset_control_reset); /** * reset_control_bulk_reset - reset the controlled devices in order * @num_rstcs: number of entries in rstcs array * @rstcs: array of struct reset_control_bulk_data with reset controls set * * Issue a reset on all provided reset controls, in order. * * See also: reset_control_reset() */ int reset_control_bulk_reset(int num_rstcs, struct reset_control_bulk_data *rstcs) { int ret, i; for (i = 0; i < num_rstcs; i++) { ret = reset_control_reset(rstcs[i].rstc); if (ret) return ret; } return 0; } EXPORT_SYMBOL_GPL(reset_control_bulk_reset); /** * reset_control_rearm - allow shared reset line to be re-triggered * @rstc: reset controller * * On a shared reset line the actual reset pulse is only triggered once for the * lifetime of the reset_control instance, except if this call is used. * * Calls to this function must be balanced with calls to reset_control_reset, * a warning is thrown in case triggered_count ever dips below 0. * * Consumers must not use reset_control_(de)assert on shared reset lines when * reset_control_reset or reset_control_rearm have been used. * * If rstc is NULL the function will just return 0. */ int reset_control_rearm(struct reset_control *rstc) { if (!rstc) return 0; if (WARN_ON(IS_ERR(rstc))) return -EINVAL; if (reset_control_is_array(rstc)) return reset_control_array_rearm(rstc_to_array(rstc)); if (rstc->shared) { if (WARN_ON(atomic_read(&rstc->deassert_count) != 0)) return -EINVAL; WARN_ON(atomic_dec_return(&rstc->triggered_count) < 0); } else { if (!rstc->acquired) return -EPERM; } return 0; } EXPORT_SYMBOL_GPL(reset_control_rearm); /** * reset_control_assert - asserts the reset line * @rstc: reset controller * * Calling this on an exclusive reset controller guarantees that the reset * will be asserted. When called on a shared reset controller the line may * still be deasserted, as long as other users keep it so. * * For shared reset controls a driver cannot expect the hw's registers and * internal state to be reset, but must be prepared for this to happen. * Consumers must not use reset_control_reset on shared reset lines when * reset_control_(de)assert has been used. * * If rstc is NULL it is an optional reset and the function will just * return 0. */ int reset_control_assert(struct reset_control *rstc) { struct reset_controller_dev *rcdev; if (!rstc) return 0; if (WARN_ON(IS_ERR(rstc)))