Tom Rini | 83d290c | 2018-05-06 17:58:06 -0400 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0+ |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 2 | /* |
| 3 | * Device manager |
| 4 | * |
| 5 | * Copyright (c) 2014 Google, Inc |
| 6 | * |
| 7 | * (C) Copyright 2012 |
| 8 | * Pavel Herrmann <morpheus.ibis@gmail.com> |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 9 | */ |
| 10 | |
Simon Glass | c51d2e7 | 2021-01-24 14:32:45 -0700 | [diff] [blame] | 11 | #define LOG_CATEGORY LOGC_DM |
| 12 | |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 13 | #include <common.h> |
| 14 | #include <errno.h> |
Simon Glass | 8474da9 | 2020-03-28 14:03:47 -0600 | [diff] [blame] | 15 | #include <log.h> |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 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> |
Anatolij Gustschin | 52edfed | 2019-09-27 13:48:15 +0530 | [diff] [blame] | 22 | #include <power-domain.h> |
Simon Glass | 401d1c4 | 2020-10-30 21:38:53 -0600 | [diff] [blame] | 23 | #include <asm/global_data.h> |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 24 | |
Jean-Jacques Hiblot | 3be9bcb | 2018-08-09 16:17:45 +0200 | [diff] [blame] | 25 | int device_chld_unbind(struct udevice *dev, struct driver *drv) |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 26 | { |
| 27 | struct udevice *pos, *n; |
| 28 | int ret, saved_ret = 0; |
| 29 | |
| 30 | assert(dev); |
| 31 | |
Sean Anderson | 501a9a7 | 2022-03-30 12:26:40 -0400 | [diff] [blame] | 32 | device_foreach_child_safe(pos, n, dev) { |
Jean-Jacques Hiblot | 3be9bcb | 2018-08-09 16:17:45 +0200 | [diff] [blame] | 33 | if (drv && (pos->driver != drv)) |
| 34 | continue; |
| 35 | |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 36 | ret = device_unbind(pos); |
Simon Glass | 8474da9 | 2020-03-28 14:03:47 -0600 | [diff] [blame] | 37 | if (ret && !saved_ret) { |
| 38 | log_warning("device '%s' failed to unbind\n", |
| 39 | pos->name); |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 40 | saved_ret = ret; |
Simon Glass | 8474da9 | 2020-03-28 14:03:47 -0600 | [diff] [blame] | 41 | } |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 42 | } |
| 43 | |
Simon Glass | 8474da9 | 2020-03-28 14:03:47 -0600 | [diff] [blame] | 44 | return log_ret(saved_ret); |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 45 | } |
| 46 | |
Jean-Jacques Hiblot | 3be9bcb | 2018-08-09 16:17:45 +0200 | [diff] [blame] | 47 | int device_chld_remove(struct udevice *dev, struct driver *drv, |
| 48 | uint flags) |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 49 | { |
| 50 | struct udevice *pos, *n; |
Marek Vasut | cc6f4c8 | 2021-01-24 14:32:46 -0700 | [diff] [blame] | 51 | int result = 0; |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 52 | |
| 53 | assert(dev); |
| 54 | |
Sean Anderson | 501a9a7 | 2022-03-30 12:26:40 -0400 | [diff] [blame] | 55 | device_foreach_child_safe(pos, n, dev) { |
Marek Vasut | cc6f4c8 | 2021-01-24 14:32:46 -0700 | [diff] [blame] | 56 | int ret; |
| 57 | |
Jean-Jacques Hiblot | 3be9bcb | 2018-08-09 16:17:45 +0200 | [diff] [blame] | 58 | if (drv && (pos->driver != drv)) |
| 59 | continue; |
| 60 | |
Stefan Roese | 706865a | 2017-03-20 12:51:48 +0100 | [diff] [blame] | 61 | ret = device_remove(pos, flags); |
Marek Vasut | cc6f4c8 | 2021-01-24 14:32:46 -0700 | [diff] [blame] | 62 | if (ret == -EPROBE_DEFER) |
| 63 | result = ret; |
| 64 | else if (ret && ret != -EKEYREJECTED) |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 65 | return ret; |
| 66 | } |
| 67 | |
Marek Vasut | cc6f4c8 | 2021-01-24 14:32:46 -0700 | [diff] [blame] | 68 | return result; |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 69 | } |
| 70 | |
| 71 | int device_unbind(struct udevice *dev) |
| 72 | { |
Simon Glass | 3479253 | 2015-03-25 12:21:54 -0600 | [diff] [blame] | 73 | const struct driver *drv; |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 74 | int ret; |
| 75 | |
| 76 | if (!dev) |
Simon Glass | 8474da9 | 2020-03-28 14:03:47 -0600 | [diff] [blame] | 77 | return log_msg_ret("dev", -EINVAL); |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 78 | |
Simon Glass | 73466df | 2020-12-19 10:40:10 -0700 | [diff] [blame] | 79 | if (dev_get_flags(dev) & DM_FLAG_ACTIVATED) |
Simon Glass | 8474da9 | 2020-03-28 14:03:47 -0600 | [diff] [blame] | 80 | return log_msg_ret("active", -EINVAL); |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 81 | |
Simon Glass | 73466df | 2020-12-19 10:40:10 -0700 | [diff] [blame] | 82 | if (!(dev_get_flags(dev) & DM_FLAG_BOUND)) |
Simon Glass | 8474da9 | 2020-03-28 14:03:47 -0600 | [diff] [blame] | 83 | return log_msg_ret("not-bound", -EINVAL); |
Masahiro Yamada | aed1a4d | 2015-07-25 21:52:34 +0900 | [diff] [blame] | 84 | |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 85 | drv = dev->driver; |
| 86 | assert(drv); |
| 87 | |
| 88 | if (drv->unbind) { |
| 89 | ret = drv->unbind(dev); |
| 90 | if (ret) |
Simon Glass | 8474da9 | 2020-03-28 14:03:47 -0600 | [diff] [blame] | 91 | return log_msg_ret("unbind", ret); |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 92 | } |
| 93 | |
Jean-Jacques Hiblot | 3be9bcb | 2018-08-09 16:17:45 +0200 | [diff] [blame] | 94 | ret = device_chld_unbind(dev, NULL); |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 95 | if (ret) |
Simon Glass | 8474da9 | 2020-03-28 14:03:47 -0600 | [diff] [blame] | 96 | return log_msg_ret("child unbind", ret); |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 97 | |
Simon Glass | 8044318 | 2021-10-23 17:26:05 -0600 | [diff] [blame] | 98 | ret = uclass_pre_unbind_device(dev); |
| 99 | if (ret) |
| 100 | return log_msg_ret("uc", ret); |
Simon Glass | 73466df | 2020-12-19 10:40:10 -0700 | [diff] [blame] | 101 | if (dev_get_flags(dev) & DM_FLAG_ALLOC_PDATA) { |
Simon Glass | 0fd3d91 | 2020-12-22 19:30:28 -0700 | [diff] [blame] | 102 | free(dev_get_plat(dev)); |
| 103 | dev_set_plat(dev, NULL); |
Simon Glass | f8a8544 | 2015-01-25 08:27:00 -0700 | [diff] [blame] | 104 | } |
Simon Glass | 73466df | 2020-12-19 10:40:10 -0700 | [diff] [blame] | 105 | if (dev_get_flags(dev) & DM_FLAG_ALLOC_UCLASS_PDATA) { |
Simon Glass | 0fd3d91 | 2020-12-22 19:30:28 -0700 | [diff] [blame] | 106 | free(dev_get_uclass_plat(dev)); |
Simon Glass | 89ba6d5 | 2020-12-22 19:30:29 -0700 | [diff] [blame] | 107 | dev_set_uclass_plat(dev, NULL); |
Przemyslaw Marczak | 5eaed88 | 2015-04-15 13:07:18 +0200 | [diff] [blame] | 108 | } |
Simon Glass | 73466df | 2020-12-19 10:40:10 -0700 | [diff] [blame] | 109 | if (dev_get_flags(dev) & DM_FLAG_ALLOC_PARENT_PDATA) { |
Simon Glass | 0fd3d91 | 2020-12-22 19:30:28 -0700 | [diff] [blame] | 110 | free(dev_get_parent_plat(dev)); |
Simon Glass | 89ba6d5 | 2020-12-22 19:30:29 -0700 | [diff] [blame] | 111 | dev_set_parent_plat(dev, NULL); |
Simon Glass | cdc133b | 2015-01-25 08:27:01 -0700 | [diff] [blame] | 112 | } |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 113 | ret = uclass_unbind_device(dev); |
| 114 | if (ret) |
Simon Glass | 8474da9 | 2020-03-28 14:03:47 -0600 | [diff] [blame] | 115 | return log_msg_ret("uc", ret); |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 116 | |
| 117 | if (dev->parent) |
| 118 | list_del(&dev->sibling_node); |
Masahiro Yamada | 608f26c | 2015-07-25 21:52:35 +0900 | [diff] [blame] | 119 | |
| 120 | devres_release_all(dev); |
| 121 | |
Simon Glass | 73466df | 2020-12-19 10:40:10 -0700 | [diff] [blame] | 122 | if (dev_get_flags(dev) & DM_FLAG_NAME_ALLOCED) |
Simon Glass | a2040fa | 2016-05-01 13:52:23 -0600 | [diff] [blame] | 123 | free((char *)dev->name); |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 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 | |
Simon Glass | 41575d8 | 2020-12-03 16:55:17 -0700 | [diff] [blame] | 137 | if (dev->driver->priv_auto) { |
Simon Glass | 0fd3d91 | 2020-12-22 19:30:28 -0700 | [diff] [blame] | 138 | free(dev_get_priv(dev)); |
| 139 | dev_set_priv(dev, NULL); |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 140 | } |
Simon Glass | 41575d8 | 2020-12-03 16:55:17 -0700 | [diff] [blame] | 141 | size = dev->uclass->uc_drv->per_device_auto; |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 142 | if (size) { |
Simon Glass | 0fd3d91 | 2020-12-22 19:30:28 -0700 | [diff] [blame] | 143 | free(dev_get_uclass_priv(dev)); |
Simon Glass | 89ba6d5 | 2020-12-22 19:30:29 -0700 | [diff] [blame] | 144 | dev_set_uclass_priv(dev, NULL); |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 145 | } |
| 146 | if (dev->parent) { |
Simon Glass | 41575d8 | 2020-12-03 16:55:17 -0700 | [diff] [blame] | 147 | size = dev->parent->driver->per_child_auto; |
Simon Glass | 8044318 | 2021-10-23 17:26:05 -0600 | [diff] [blame] | 148 | if (!size) |
| 149 | size = dev->parent->uclass->uc_drv->per_child_auto; |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 150 | if (size) { |
Simon Glass | 0fd3d91 | 2020-12-22 19:30:28 -0700 | [diff] [blame] | 151 | free(dev_get_parent_priv(dev)); |
Simon Glass | 89ba6d5 | 2020-12-22 19:30:29 -0700 | [diff] [blame] | 152 | dev_set_parent_priv(dev, NULL); |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 153 | } |
| 154 | } |
Simon Glass | 73466df | 2020-12-19 10:40:10 -0700 | [diff] [blame] | 155 | dev_bic_flags(dev, DM_FLAG_PLATDATA_VALID); |
Masahiro Yamada | 608f26c | 2015-07-25 21:52:35 +0900 | [diff] [blame] | 156 | |
| 157 | devres_release_probe(dev); |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 158 | } |
| 159 | |
Simon Glass | c51d2e7 | 2021-01-24 14:32:45 -0700 | [diff] [blame] | 160 | /** |
| 161 | * flags_remove() - Figure out whether to remove a device |
| 162 | * |
Marek Vasut | cc6f4c8 | 2021-01-24 14:32:46 -0700 | [diff] [blame] | 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 | * |
Simon Glass | c51d2e7 | 2021-01-24 14:32:45 -0700 | [diff] [blame] | 171 | * @flags: Flags passed to device_remove() |
| 172 | * @drv_flags: Driver flags |
Heinrich Schuchardt | 185f812 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 173 | * Return: 0 if the device should be removed, |
Simon Glass | c51d2e7 | 2021-01-24 14:32:45 -0700 | [diff] [blame] | 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) |
Marek Vasut | cc6f4c8 | 2021-01-24 14:32:46 -0700 | [diff] [blame] | 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) |
Simon Glass | c51d2e7 | 2021-01-24 14:32:45 -0700 | [diff] [blame] | 179 | */ |
| 180 | static int flags_remove(uint flags, uint drv_flags) |
Stefan Roese | 426f99f | 2017-04-24 09:48:02 +0200 | [diff] [blame] | 181 | { |
Marek Vasut | cc6f4c8 | 2021-01-24 14:32:46 -0700 | [diff] [blame] | 182 | if (!(flags & DM_REMOVE_NORMAL)) { |
| 183 | bool vital_match; |
| 184 | bool active_match; |
Stefan Roese | 426f99f | 2017-04-24 09:48:02 +0200 | [diff] [blame] | 185 | |
Marek Vasut | cc6f4c8 | 2021-01-24 14:32:46 -0700 | [diff] [blame] | 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; |
Stefan Roese | 426f99f | 2017-04-24 09:48:02 +0200 | [diff] [blame] | 197 | } |
| 198 | |
Stefan Roese | 706865a | 2017-03-20 12:51:48 +0100 | [diff] [blame] | 199 | int device_remove(struct udevice *dev, uint flags) |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 200 | { |
Simon Glass | 3479253 | 2015-03-25 12:21:54 -0600 | [diff] [blame] | 201 | const struct driver *drv; |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 202 | int ret; |
| 203 | |
| 204 | if (!dev) |
| 205 | return -EINVAL; |
| 206 | |
Simon Glass | 73466df | 2020-12-19 10:40:10 -0700 | [diff] [blame] | 207 | if (!(dev_get_flags(dev) & DM_FLAG_ACTIVATED)) |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 208 | return 0; |
| 209 | |
Simon Glass | 5b896ed | 2022-03-04 08:43:03 -0700 | [diff] [blame] | 210 | ret = device_notify(dev, EVT_DM_PRE_REMOVE); |
| 211 | if (ret) |
| 212 | return ret; |
| 213 | |
Simon Glass | c51d2e7 | 2021-01-24 14:32:45 -0700 | [diff] [blame] | 214 | /* |
| 215 | * If the child returns EKEYREJECTED, continue. It just means that it |
| 216 | * didn't match the flags. |
| 217 | */ |
Simon Glass | b1f25fc | 2021-01-24 14:32:44 -0700 | [diff] [blame] | 218 | ret = device_chld_remove(dev, NULL, flags); |
Simon Glass | c51d2e7 | 2021-01-24 14:32:45 -0700 | [diff] [blame] | 219 | if (ret && ret != -EKEYREJECTED) |
Simon Glass | b1f25fc | 2021-01-24 14:32:44 -0700 | [diff] [blame] | 220 | return ret; |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 221 | |
Stefan Roese | bc85aa4 | 2017-03-27 10:58:53 +0200 | [diff] [blame] | 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 | */ |
Simon Glass | c51d2e7 | 2021-01-24 14:32:45 -0700 | [diff] [blame] | 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) { |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 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 | |
Simon Glass | ced1080 | 2020-03-28 14:03:48 -0600 | [diff] [blame] | 253 | if (!(flags & DM_REMOVE_NO_PD) && |
| 254 | !(drv->flags & |
Simon Glass | a547fcb | 2021-01-24 14:32:42 -0700 | [diff] [blame] | 255 | (DM_FLAG_DEFAULT_PD_CTRL_OFF | DM_FLAG_LEAVE_PD_ON)) && |
Anatolij Gustschin | 5349e25 | 2020-02-17 12:36:43 +0100 | [diff] [blame] | 256 | dev != gd->cur_serial_dev) |
Anatolij Gustschin | 52edfed | 2019-09-27 13:48:15 +0530 | [diff] [blame] | 257 | dev_power_domain_off(dev); |
| 258 | |
Simon Glass | c51d2e7 | 2021-01-24 14:32:45 -0700 | [diff] [blame] | 259 | device_free(dev); |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 260 | |
Simon Glass | c51d2e7 | 2021-01-24 14:32:45 -0700 | [diff] [blame] | 261 | dev_bic_flags(dev, DM_FLAG_ACTIVATED); |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 262 | |
Simon Glass | 5b896ed | 2022-03-04 08:43:03 -0700 | [diff] [blame] | 263 | ret = device_notify(dev, EVT_DM_POST_REMOVE); |
| 264 | if (ret) |
| 265 | goto err_remove; |
| 266 | |
Simon Glass | c51d2e7 | 2021-01-24 14:32:45 -0700 | [diff] [blame] | 267 | return 0; |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 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); |
Simon Glass | 3ac435d | 2014-11-10 17:16:47 -0700 | [diff] [blame] | 273 | |
| 274 | return ret; |
| 275 | } |