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