reset: make (de)assert report success for self-deasserting reset drivers

By now there are drivers using shared reset controls and (de)assert
calls on platforms with self-deasserting reset lines and thus reset
drivers that do not implement .assert() and .deassert().
As long as the initial state of the reset line is deasserted, there
is no reason for a reset_control_assert call to return an error for
shared reset controls, or for a reset_control_deassert call to return
an error for either shared or exclusive reset controls: after a call
to reset_control_deassert the reset line is guaranteed to be deasserted,
and after a call to reset_control_assert it is valid for the reset
line to stay deasserted for shared reset controls.

Signed-off-by: Philipp Zabel <p.zabel@pengutronix.de>
Reviewed-by: Linus Walleij <linus.walleij@linaro.org>

diff --git a/drivers/reset/core.c b/drivers/reset/core.c
index c8fb4426b218a81f99e916941e87292cc113432b..1d21c6f7d56cbdec09bd9b9324665d146f67c26f 100644 (file)
--- a/drivers/reset/core.c
+++ b/drivers/reset/core.c
@@ -280,9 +280,6 @@ int reset_control_assert(struct reset_control *rstc)
        if (reset_control_is_array(rstc))
                return reset_control_array_assert(rstc_to_array(rstc));
 
-       if (!rstc->rcdev->ops->assert)
-               return -ENOTSUPP;
-
        if (rstc->shared) {
                if (WARN_ON(atomic_read(&rstc->triggered_count) != 0))
                        return -EINVAL;
@@ -292,6 +289,21 @@ int reset_control_assert(struct reset_control *rstc)
 
                if (atomic_dec_return(&rstc->deassert_count) != 0)
                        return 0;
+
+               /*
+                * Shared reset controls allow the reset line to be in any state
+                * after this call, so doing nothing is a valid option.
+                */
+               if (!rstc->rcdev->ops->assert)
+                       return 0;
+       } else {
+               /*
+                * If the reset controller does not implement .assert(), there
+                * is no way to guarantee that the reset line is asserted after
+                * this call.
+                */
+               if (!rstc->rcdev->ops->assert)
+                       return -ENOTSUPP;
        }
 
        return rstc->rcdev->ops->assert(rstc->rcdev, rstc->id);
@@ -321,9 +333,6 @@ int reset_control_deassert(struct reset_control *rstc)
        if (reset_control_is_array(rstc))
                return reset_control_array_deassert(rstc_to_array(rstc));
 
-       if (!rstc->rcdev->ops->deassert)
-               return -ENOTSUPP;
-
        if (rstc->shared) {
                if (WARN_ON(atomic_read(&rstc->triggered_count) != 0))
                        return -EINVAL;
@@ -332,6 +341,16 @@ int reset_control_deassert(struct reset_control *rstc)
                        return 0;
        }
 
+       /*
+        * If the reset controller does not implement .deassert(), we assume
+        * that it handles self-deasserting reset lines via .reset(). In that
+        * case, the reset lines are deasserted by default. If that is not the
+        * case, the reset controller driver should implement .deassert() and
+        * return -ENOTSUPP.
+        */
+       if (!rstc->rcdev->ops->deassert)
+               return 0;
+
        return rstc->rcdev->ops->deassert(rstc->rcdev, rstc->id);
 }
 EXPORT_SYMBOL_GPL(reset_control_deassert);