drivers/core/device-remove.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Device manager
   4  *
   5  * Copyright (c) 2014 Google, Inc
   6  *
   7  * (C) Copyright 2012
   8  * Pavel Herrmann <morpheus.ibis@gmail.com>
   9  */
  10
  11 #include <common.h>
  12 #include <errno.h>
  13 #include <log.h>
  14 #include <malloc.h>
  15 #include <dm/device.h>
  16 #include <dm/device-internal.h>
  17 #include <dm/uclass.h>
  18 #include <dm/uclass-internal.h>
  19 #include <dm/util.h>
  20 #include <power-domain.h>
  21 #include <asm/global_data.h>
  22
  23 int device_chld_unbind(struct udevice *dev, struct driver *drv)
  24 {
  25         struct udevice *pos, *n;
  26         int ret, saved_ret = 0;
  27
  28         assert(dev);
  29
  30         list_for_each_entry_safe(pos, n, &dev->child_head, sibling_node) {
  31                 if (drv && (pos->driver != drv))
  32                         continue;
  33
  34                 ret = device_unbind(pos);
  35                 if (ret && !saved_ret) {
  36                         log_warning("device '%s' failed to unbind\n",
  37                                     pos->name);
  38                         saved_ret = ret;
  39                 }
  40         }
  41
  42         return log_ret(saved_ret);
  43 }
  44
  45 int device_chld_remove(struct udevice *dev, struct driver *drv,
  46                        uint flags)
  47 {
  48         struct udevice *pos, *n;
  49         int ret;
  50
  51         assert(dev);
  52
  53         list_for_each_entry_safe(pos, n, &dev->child_head, sibling_node) {
  54                 if (drv && (pos->driver != drv))
  55                         continue;
  56
  57                 ret = device_remove(pos, flags);
  58                 if (ret)
  59                         return ret;
  60         }
  61
  62         return 0;
  63 }
  64
  65 int device_unbind(struct udevice *dev)
  66 {
  67         const struct driver *drv;
  68         int ret;
  69
  70         if (!dev)
  71                 return log_msg_ret("dev", -EINVAL);
  72
  73         if (dev_get_flags(dev) & DM_FLAG_ACTIVATED)
  74                 return log_msg_ret("active", -EINVAL);
  75
  76         if (!(dev_get_flags(dev) & DM_FLAG_BOUND))
  77                 return log_msg_ret("not-bound", -EINVAL);
  78
  79         drv = dev->driver;
  80         assert(drv);
  81
  82         if (drv->unbind) {
  83                 ret = drv->unbind(dev);
  84                 if (ret)
  85                         return log_msg_ret("unbind", ret);
  86         }
  87
  88         ret = device_chld_unbind(dev, NULL);
  89         if (ret)
  90                 return log_msg_ret("child unbind", ret);
  91
  92         if (dev_get_flags(dev) & DM_FLAG_ALLOC_PDATA) {
  93                 free(dev_get_plat(dev));
  94                 dev_set_plat(dev, NULL);
  95         }
  96         if (dev_get_flags(dev) & DM_FLAG_ALLOC_UCLASS_PDATA) {
  97                 free(dev_get_uclass_plat(dev));
  98                 dev_set_uclass_plat(dev, NULL);
  99         }
 100         if (dev_get_flags(dev) & DM_FLAG_ALLOC_PARENT_PDATA) {
 101                 free(dev_get_parent_plat(dev));
 102                 dev_set_parent_plat(dev, NULL);
 103         }
 104         ret = uclass_unbind_device(dev);
 105         if (ret)
 106                 return log_msg_ret("uc", ret);
 107
 108         if (dev->parent)
 109                 list_del(&dev->sibling_node);
 110
 111         devres_release_all(dev);
 112
 113         if (dev_get_flags(dev) & DM_FLAG_NAME_ALLOCED)
 114                 free((char *)dev->name);
 115         free(dev);
 116
 117         return 0;
 118 }
 119
 120 /**
 121  * device_free() - Free memory buffers allocated by a device
 122  * @dev:        Device that is to be started
 123  */
 124 void device_free(struct udevice *dev)
 125 {
 126         int size;
 127
 128         if (dev->driver->priv_auto) {
 129                 free(dev_get_priv(dev));
 130                 dev_set_priv(dev, NULL);
 131         }
 132         size = dev->uclass->uc_drv->per_device_auto;
 133         if (size) {
 134                 free(dev_get_uclass_priv(dev));
 135                 dev_set_uclass_priv(dev, NULL);
 136         }
 137         if (dev->parent) {
 138                 size = dev->parent->driver->per_child_auto;
 139                 if (!size) {
 140                         size = dev->parent->uclass->uc_drv->
 141                                         per_child_auto;
 142                 }
 143                 if (size) {
 144                         free(dev_get_parent_priv(dev));
 145                         dev_set_parent_priv(dev, NULL);
 146                 }
 147         }
 148         dev_bic_flags(dev, DM_FLAG_PLATDATA_VALID);
 149
 150         devres_release_probe(dev);
 151 }
 152
 153 static bool flags_remove(uint flags, uint drv_flags)
 154 {
 155         if ((flags & DM_REMOVE_NORMAL) ||
 156             (flags && (drv_flags & (DM_FLAG_ACTIVE_DMA | DM_FLAG_OS_PREPARE))))
 157                 return true;
 158
 159         return false;
 160 }
 161
 162 int device_remove(struct udevice *dev, uint flags)
 163 {
 164         const struct driver *drv;
 165         int ret;
 166
 167         if (!dev)
 168                 return -EINVAL;
 169
 170         if (!(dev_get_flags(dev) & DM_FLAG_ACTIVATED))
 171                 return 0;
 172
 173         drv = dev->driver;
 174         assert(drv);
 175
 176         ret = uclass_pre_remove_device(dev);
 177         if (ret)
 178                 return ret;
 179
 180         ret = device_chld_remove(dev, NULL, flags);
 181         if (ret)
 182                 goto err;
 183
 184         /*
 185          * Remove the device if called with the "normal" remove flag set,
 186          * or if the remove flag matches any of the drivers remove flags
 187          */
 188         if (drv->remove && flags_remove(flags, drv->flags)) {
 189                 ret = drv->remove(dev);
 190                 if (ret)
 191                         goto err_remove;
 192         }
 193
 194         if (dev->parent && dev->parent->driver->child_post_remove) {
 195                 ret = dev->parent->driver->child_post_remove(dev);
 196                 if (ret) {
 197                         dm_warn("%s: Device '%s' failed child_post_remove()",
 198                                 __func__, dev->name);
 199                 }
 200         }
 201
 202         if (!(flags & DM_REMOVE_NO_PD) &&
 203             !(drv->flags &
 204               (DM_FLAG_DEFAULT_PD_CTRL_OFF | DM_FLAG_REMOVE_WITH_PD_ON)) &&
 205             dev != gd->cur_serial_dev)
 206                 dev_power_domain_off(dev);
 207
 208         if (flags_remove(flags, drv->flags)) {
 209                 device_free(dev);
 210
 211                 dev_bic_flags(dev, DM_FLAG_ACTIVATED);
 212         }
 213
 214         return ret;
 215
 216 err_remove:
 217         /* We can't put the children back */
 218         dm_warn("%s: Device '%s' failed to remove, but children are gone\n",
 219                 __func__, dev->name);
 220 err:
 221         ret = uclass_post_probe_device(dev);
 222         if (ret) {
 223                 dm_warn("%s: Device '%s' failed to post_probe on error path\n",
 224                         __func__, dev->name);
 225         }
 226
 227         return ret;
 228 }