Merge tag 'v2021.01-rc5' into next

[platform/kernel/u-boot.git] / drivers / core / device-remove.c

diff --git a/drivers/core/device-remove.c b/drivers/core/device-remove.c
index 586fade..8a5f958 100644 (file)
--- a/drivers/core/device-remove.c
+++ b/drivers/core/device-remove.c
@@ -10,12 +10,14 @@
 
 #include <common.h>
 #include <errno.h>
+#include <log.h>
 #include <malloc.h>
 #include <dm/device.h>
 #include <dm/device-internal.h>
 #include <dm/uclass.h>
 #include <dm/uclass-internal.h>
 #include <dm/util.h>
+#include <power-domain.h>
 
 int device_chld_unbind(struct udevice *dev, struct driver *drv)
 {
@@ -29,11 +31,14 @@ int device_chld_unbind(struct udevice *dev, struct driver *drv)
                        continue;
 
                ret = device_unbind(pos);
-               if (ret && !saved_ret)
+               if (ret && !saved_ret) {
+                       log_warning("device '%s' failed to unbind\n",
+                                   pos->name);
                        saved_ret = ret;
+               }
        }
 
-       return saved_ret;
+       return log_ret(saved_ret);
 }
 
 int device_chld_remove(struct udevice *dev, struct driver *drv,
@@ -62,13 +67,13 @@ int device_unbind(struct udevice *dev)
        int ret;
 
        if (!dev)
-               return -EINVAL;
+               return log_msg_ret("dev", -EINVAL);
 
        if (dev->flags & DM_FLAG_ACTIVATED)
-               return -EINVAL;
+               return log_msg_ret("active", -EINVAL);
 
        if (!(dev->flags & DM_FLAG_BOUND))
-               return -EINVAL;
+               return log_msg_ret("not-bound", -EINVAL);
 
        drv = dev->driver;
        assert(drv);
@@ -76,28 +81,28 @@ int device_unbind(struct udevice *dev)
        if (drv->unbind) {
                ret = drv->unbind(dev);
                if (ret)
-                       return ret;
+                       return log_msg_ret("unbind", ret);
        }
 
        ret = device_chld_unbind(dev, NULL);
        if (ret)
-               return ret;
+               return log_msg_ret("child unbind", ret);
 
        if (dev->flags & DM_FLAG_ALLOC_PDATA) {
-               free(dev->platdata);
-               dev->platdata = NULL;
+               free(dev->plat);
+               dev->plat = NULL;
        }
        if (dev->flags & DM_FLAG_ALLOC_UCLASS_PDATA) {
-               free(dev->uclass_platdata);
-               dev->uclass_platdata = NULL;
+               free(dev->uclass_plat);
+               dev->uclass_plat = NULL;
        }
        if (dev->flags & DM_FLAG_ALLOC_PARENT_PDATA) {
-               free(dev->parent_platdata);
-               dev->parent_platdata = NULL;
+               free(dev->parent_plat);
+               dev->parent_plat = NULL;
        }
        ret = uclass_unbind_device(dev);
        if (ret)
-               return ret;
+               return log_msg_ret("uc", ret);
 
        if (dev->parent)
                list_del(&dev->sibling_node);
@@ -119,26 +124,27 @@ void device_free(struct udevice *dev)
 {
        int size;
 
-       if (dev->driver->priv_auto_alloc_size) {
+       if (dev->driver->priv_auto) {
                free(dev->priv);
                dev->priv = NULL;
        }
-       size = dev->uclass->uc_drv->per_device_auto_alloc_size;
+       size = dev->uclass->uc_drv->per_device_auto;
        if (size) {
                free(dev->uclass_priv);
                dev->uclass_priv = NULL;
        }
        if (dev->parent) {
-               size = dev->parent->driver->per_child_auto_alloc_size;
+               size = dev->parent->driver->per_child_auto;
                if (!size) {
                        size = dev->parent->uclass->uc_drv->
-                                       per_child_auto_alloc_size;
+                                       per_child_auto;
                }
                if (size) {
                        free(dev->parent_priv);
                        dev->parent_priv = NULL;
                }
        }
+       dev->flags &= ~DM_FLAG_PLATDATA_VALID;
 
        devres_release_probe(dev);
 }
@@ -146,7 +152,7 @@ void device_free(struct udevice *dev)
 static bool flags_remove(uint flags, uint drv_flags)
 {
        if ((flags & DM_REMOVE_NORMAL) ||
-           (flags & (drv_flags & (DM_FLAG_ACTIVE_DMA | DM_FLAG_OS_PREPARE))))
+           (flags && (drv_flags & (DM_FLAG_ACTIVE_DMA | DM_FLAG_OS_PREPARE))))
                return true;
 
        return false;
@@ -192,10 +198,15 @@ int device_remove(struct udevice *dev, uint flags)
                }
        }
 
+       if (!(flags & DM_REMOVE_NO_PD) &&
+           !(drv->flags &
+             (DM_FLAG_DEFAULT_PD_CTRL_OFF | DM_FLAG_REMOVE_WITH_PD_ON)) &&
+           dev != gd->cur_serial_dev)
+               dev_power_domain_off(dev);
+
        if (flags_remove(flags, drv->flags)) {
                device_free(dev);
 
-               dev->seq = -1;
                dev->flags &= ~DM_FLAG_ACTIVATED;
        }