lpi2c: Fix bus stop problem in xfer

[u-boot] / drivers / reset / reset-uclass.c

diff --git a/drivers/reset/reset-uclass.c b/drivers/reset/reset-uclass.c
index edaecfbc99b1ee9ca2bad669101038d811b0020a..38995376350b757aae7efb9114d2eac5763bb4e0 100644 (file)
--- a/drivers/reset/reset-uclass.c
+++ b/drivers/reset/reset-uclass.c
@@ -1,7 +1,6 @@
+// SPDX-License-Identifier: GPL-2.0
 /*
  * Copyright (c) 2016, NVIDIA CORPORATION.
- *
- * SPDX-License-Identifier: GPL-2.0
  */
 
 #include <common.h>
@@ -10,15 +9,13 @@
 #include <reset.h>
 #include <reset-uclass.h>
 
-DECLARE_GLOBAL_DATA_PTR;
-
 static inline struct reset_ops *reset_dev_ops(struct udevice *dev)
 {
        return (struct reset_ops *)dev->driver->ops;
 }
 
 static int reset_of_xlate_default(struct reset_ctl *reset_ctl,
-                                 struct fdtdec_phandle_args *args)
+                                 struct ofnode_phandle_args *args)
 {
        debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
 
@@ -35,28 +32,29 @@ static int reset_of_xlate_default(struct reset_ctl *reset_ctl,
 int reset_get_by_index(struct udevice *dev, int index,
                       struct reset_ctl *reset_ctl)
 {
-       struct fdtdec_phandle_args args;
+       struct ofnode_phandle_args args;
        int ret;
        struct udevice *dev_reset;
        struct reset_ops *ops;
 
        debug("%s(dev=%p, index=%d, reset_ctl=%p)\n", __func__, dev, index,
              reset_ctl);
+       reset_ctl->dev = NULL;
 
-       ret = fdtdec_parse_phandle_with_args(gd->fdt_blob, dev->of_offset,
-                                            "resets", "#reset-cells", 0,
-                                            index, &args);
+       ret = dev_read_phandle_with_args(dev, "resets", "#reset-cells", 0,
+                                         index, &args);
        if (ret) {
-               debug("%s: fdtdec_parse_phandle_with_args failed: %d\n",
+               debug("%s: fdtdec_parse_phandle_with_args() failed: %d\n",
                      __func__, ret);
                return ret;
        }
 
-       ret = uclass_get_device_by_of_offset(UCLASS_RESET, args.node,
-                                            &dev_reset);
+       ret = uclass_get_device_by_ofnode(UCLASS_RESET, args.node,
+                                         &dev_reset);
        if (ret) {
-               debug("%s: uclass_get_device_by_of_offset failed: %d\n",
+               debug("%s: uclass_get_device_by_ofnode() failed: %d\n",
                      __func__, ret);
+               debug("%s %d\n", ofnode_get_name(args.node), args.args[0]);
                return ret;
        }
        ops = reset_dev_ops(dev_reset);
@@ -80,6 +78,40 @@ int reset_get_by_index(struct udevice *dev, int index,
        return 0;
 }
 
+int reset_get_bulk(struct udevice *dev, struct reset_ctl_bulk *bulk)
+{
+       int i, ret, err, count;
+       
+       bulk->count = 0;
+
+       count = dev_count_phandle_with_args(dev, "resets", "#reset-cells");
+       if (count < 1)
+               return count;
+
+       bulk->resets = devm_kcalloc(dev, count, sizeof(struct reset_ctl),
+                                   GFP_KERNEL);
+       if (!bulk->resets)
+               return -ENOMEM;
+
+       for (i = 0; i < count; i++) {
+               ret = reset_get_by_index(dev, i, &bulk->resets[i]);
+               if (ret < 0)
+                       goto bulk_get_err;
+
+               ++bulk->count;
+       }
+
+       return 0;
+
+bulk_get_err:
+       err = reset_release_all(bulk->resets, bulk->count);
+       if (err)
+               debug("%s: could release all resets for %p\n",
+                     __func__, dev);
+
+       return ret;
+}
+
 int reset_get_by_name(struct udevice *dev, const char *name,
                     struct reset_ctl *reset_ctl)
 {
@@ -87,17 +119,26 @@ int reset_get_by_name(struct udevice *dev, const char *name,
 
        debug("%s(dev=%p, name=%s, reset_ctl=%p)\n", __func__, dev, name,
              reset_ctl);
+       reset_ctl->dev = NULL;
 
-       index = fdt_find_string(gd->fdt_blob, dev->of_offset, "reset-names",
-                               name);
+       index = dev_read_stringlist_search(dev, "reset-names", name);
        if (index < 0) {
-               debug("fdt_find_string() failed: %d\n", index);
+               debug("fdt_stringlist_search() failed: %d\n", index);
                return index;
        }
 
        return reset_get_by_index(dev, index, reset_ctl);
 }
 
+int reset_request(struct reset_ctl *reset_ctl)
+{
+       struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
+
+       debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
+
+       return ops->request(reset_ctl);
+}
+
 int reset_free(struct reset_ctl *reset_ctl)
 {
        struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
@@ -116,6 +157,19 @@ int reset_assert(struct reset_ctl *reset_ctl)
        return ops->rst_assert(reset_ctl);
 }
 
+int reset_assert_bulk(struct reset_ctl_bulk *bulk)
+{
+       int i, ret;
+
+       for (i = 0; i < bulk->count; i++) {
+               ret = reset_assert(&bulk->resets[i]);
+               if (ret < 0)
+                       return ret;
+       }
+
+       return 0;
+}
+
 int reset_deassert(struct reset_ctl *reset_ctl)
 {
        struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
@@ -125,6 +179,42 @@ int reset_deassert(struct reset_ctl *reset_ctl)
        return ops->rst_deassert(reset_ctl);
 }
 
+int reset_deassert_bulk(struct reset_ctl_bulk *bulk)
+{
+       int i, ret;
+
+       for (i = 0; i < bulk->count; i++) {
+               ret = reset_deassert(&bulk->resets[i]);
+               if (ret < 0)
+                       return ret;
+       }
+
+       return 0;
+}
+
+int reset_release_all(struct reset_ctl *reset_ctl, int count)
+{
+       int i, ret;
+
+       for (i = 0; i < count; i++) {
+               debug("%s(reset_ctl[%d]=%p)\n", __func__, i, &reset_ctl[i]);
+
+               /* check if reset has been previously requested */
+               if (!reset_ctl[i].dev)
+                       continue;
+
+               ret = reset_assert(&reset_ctl[i]);
+               if (ret)
+                       return ret;
+
+               ret = reset_free(&reset_ctl[i]);
+               if (ret)
+                       return ret;
+       }
+
+       return 0;
+}
+
 UCLASS_DRIVER(reset) = {
        .id             = UCLASS_RESET,
        .name           = "reset",