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 #define LOG_CATEGORY    LOGC_DM
  12
  13 #include <common.h>
  14 #include <errno.h>
  15 #include <log.h>
  16 #include <malloc.h>
  17 #include <dm/device.h>
  18 #include <dm/device-internal.h>
  19 #include <dm/uclass.h>
  20 #include <dm/uclass-internal.h>
  21 #include <dm/util.h>
  22 #include <power-domain.h>
  23 #include <asm/global_data.h>
  24
  25 int device_chld_unbind(struct udevice *dev, struct driver *drv)
  26 {
  27         struct udevice *pos, *n;
  28         int ret, saved_ret = 0;
  29
  30         assert(dev);
  31
  32         device_foreach_child_safe(pos, n, dev) {
  33                 if (drv && (pos->driver != drv))
  34                         continue;
  35
  36                 ret = device_unbind(pos);
  37                 if (ret && !saved_ret) {
  38                         log_warning("device '%s' failed to unbind\n",
  39                                     pos->name);
  40                         saved_ret = ret;
  41                 }
  42         }
  43
  44         return log_ret(saved_ret);
  45 }
  46
  47 int device_chld_remove(struct udevice *dev, struct driver *drv,
  48                        uint flags)
  49 {
  50         struct udevice *pos, *n;
  51         int result = 0;
  52
  53         assert(dev);
  54
  55         device_foreach_child_safe(pos, n, dev) {
  56                 int ret;
  57
  58                 if (drv && (pos->driver != drv))
  59                         continue;
  60
  61                 ret = device_remove(pos, flags);
  62                 if (ret == -EPROBE_DEFER)
  63                         result = ret;
  64                 else if (ret && ret != -EKEYREJECTED)
  65                         return ret;
  66         }
  67
  68         return result;
  69 }
  70
  71 int device_unbind(struct udevice *dev)
  72 {
  73         const struct driver *drv;
  74         int ret;
  75
  76         if (!dev)
  77                 return log_msg_ret("dev", -EINVAL);
  78
  79         if (dev_get_flags(dev) & DM_FLAG_ACTIVATED)
  80                 return log_msg_ret("active", -EINVAL);
  81
  82         if (!(dev_get_flags(dev) & DM_FLAG_BOUND))
  83                 return log_msg_ret("not-bound", -EINVAL);
  84
  85         drv = dev->driver;
  86         assert(drv);
  87
  88         if (drv->unbind) {
  89                 ret = drv->unbind(dev);
  90                 if (ret)
  91                         return log_msg_ret("unbind", ret);
  92         }
  93
  94         ret = device_chld_unbind(dev, NULL);
  95         if (ret)
  96                 return log_msg_ret("child unbind", ret);
  97
  98         ret = uclass_pre_unbind_device(dev);
  99         if (ret)
 100                 return log_msg_ret("uc", ret);
 101         if (dev_get_flags(dev) & DM_FLAG_ALLOC_PDATA) {
 102                 free(dev_get_plat(dev));
 103                 dev_set_plat(dev, NULL);
 104         }
 105         if (dev_get_flags(dev) & DM_FLAG_ALLOC_UCLASS_PDATA) {
 106                 free(dev_get_uclass_plat(dev));
 107                 dev_set_uclass_plat(dev, NULL);
 108         }
 109         if (dev_get_flags(dev) & DM_FLAG_ALLOC_PARENT_PDATA) {
 110                 free(dev_get_parent_plat(dev));
 111                 dev_set_parent_plat(dev, NULL);
 112         }
 113         ret = uclass_unbind_device(dev);
 114         if (ret)
 115                 return log_msg_ret("uc", ret);
 116
 117         if (dev->parent)
 118                 list_del(&dev->sibling_node);
 119
 120         devres_release_all(dev);
 121
 122         if (dev_get_flags(dev) & DM_FLAG_NAME_ALLOCED)
 123                 free((char *)dev->name);
 124         free(dev);
 125
 126         return 0;
 127 }
 128
 129 /**
 130  * device_free() - Free memory buffers allocated by a device
 131  * @dev:        Device that is to be started
 132  */
 133 void device_free(struct udevice *dev)
 134 {
 135         int size;
 136
 137         if (dev->driver->priv_auto) {
 138                 free(dev_get_priv(dev));
 139                 dev_set_priv(dev, NULL);
 140         }
 141         size = dev->uclass->uc_drv->per_device_auto;
 142         if (size) {
 143                 free(dev_get_uclass_priv(dev));
 144                 dev_set_uclass_priv(dev, NULL);
 145         }
 146         if (dev->parent) {
 147                 size = dev->parent->driver->per_child_auto;
 148                 if (!size)
 149                         size = dev->parent->uclass->uc_drv->per_child_auto;
 150                 if (size) {
 151                         free(dev_get_parent_priv(dev));
 152                         dev_set_parent_priv(dev, NULL);
 153                 }
 154         }
 155         dev_bic_flags(dev, DM_FLAG_PLATDATA_VALID);
 156
 157         devres_release_probe(dev);
 158 }
 159
 160 /**
 161  * flags_remove() - Figure out whether to remove a device
 162  *
 163  * If this is called with @flags == DM_REMOVE_NON_VITAL | DM_REMOVE_ACTIVE_DMA,
 164  * then it returns 0 (=go head and remove) if the device is not matked vital
 165  * but is marked DM_REMOVE_ACTIVE_DMA.
 166  *
 167  * If this is called with @flags == DM_REMOVE_ACTIVE_DMA,
 168  * then it returns 0 (=go head and remove) if the device is marked
 169  * DM_REMOVE_ACTIVE_DMA, regardless of whether it is marked vital.
 170  *
 171  * @flags: Flags passed to device_remove()
 172  * @drv_flags: Driver flags
 173  * Return: 0 if the device should be removed,
 174  * -EKEYREJECTED if @flags includes a flag in DM_REMOVE_ACTIVE_ALL but
 175  *      @drv_flags does not (indicates that this device has nothing to do for
 176  *      DMA shutdown or OS prepare)
 177  * -EPROBE_DEFER if @flags is DM_REMOVE_NON_VITAL but @drv_flags contains
 178  *      DM_FLAG_VITAL (indicates the device is vital and should not be removed)
 179  */
 180 static int flags_remove(uint flags, uint drv_flags)
 181 {
 182         if (!(flags & DM_REMOVE_NORMAL)) {
 183                 bool vital_match;
 184                 bool active_match;
 185
 186                 active_match = !(flags & DM_REMOVE_ACTIVE_ALL) ||
 187                         (drv_flags & flags);
 188                 vital_match = !(flags & DM_REMOVE_NON_VITAL) ||
 189                         !(drv_flags & DM_FLAG_VITAL);
 190                 if (!vital_match)
 191                         return -EPROBE_DEFER;
 192                 if (!active_match)
 193                         return -EKEYREJECTED;
 194         }
 195
 196         return 0;
 197 }
 198
 199 int device_remove(struct udevice *dev, uint flags)
 200 {
 201         const struct driver *drv;
 202         int ret;
 203
 204         if (!dev)
 205                 return -EINVAL;
 206
 207         if (!(dev_get_flags(dev) & DM_FLAG_ACTIVATED))
 208                 return 0;
 209
 210         ret = device_notify(dev, EVT_DM_PRE_REMOVE);
 211         if (ret)
 212                 return ret;
 213
 214         /*
 215          * If the child returns EKEYREJECTED, continue. It just means that it
 216          * didn't match the flags.
 217          */
 218         ret = device_chld_remove(dev, NULL, flags);
 219         if (ret && ret != -EKEYREJECTED)
 220                 return ret;
 221
 222         /*
 223          * Remove the device if called with the "normal" remove flag set,
 224          * or if the remove flag matches any of the drivers remove flags
 225          */
 226         drv = dev->driver;
 227         assert(drv);
 228         ret = flags_remove(flags, drv->flags);
 229         if (ret) {
 230                 log_debug("%s: When removing: flags=%x, drv->flags=%x, err=%d\n",
 231                           dev->name, flags, drv->flags, ret);
 232                 return ret;
 233         }
 234
 235         ret = uclass_pre_remove_device(dev);
 236         if (ret)
 237                 return ret;
 238
 239         if (drv->remove) {
 240                 ret = drv->remove(dev);
 241                 if (ret)
 242                         goto err_remove;
 243         }
 244
 245         if (dev->parent && dev->parent->driver->child_post_remove) {
 246                 ret = dev->parent->driver->child_post_remove(dev);
 247                 if (ret) {
 248                         dm_warn("%s: Device '%s' failed child_post_remove()",
 249                                 __func__, dev->name);
 250                 }
 251         }
 252
 253         if (!(flags & DM_REMOVE_NO_PD) &&
 254             !(drv->flags &
 255               (DM_FLAG_DEFAULT_PD_CTRL_OFF | DM_FLAG_LEAVE_PD_ON)) &&
 256             dev != gd->cur_serial_dev)
 257                 dev_power_domain_off(dev);
 258
 259         device_free(dev);
 260
 261         dev_bic_flags(dev, DM_FLAG_ACTIVATED);
 262
 263         ret = device_notify(dev, EVT_DM_POST_REMOVE);
 264         if (ret)
 265                 goto err_remove;
 266
 267         return 0;
 268
 269 err_remove:
 270         /* We can't put the children back */
 271         dm_warn("%s: Device '%s' failed to remove, but children are gone\n",
 272                 __func__, dev->name);
 273
 274         return ret;
 275 }