1 files changed, 266 insertions, 0 deletions
diff --git a/roms/u-boot/drivers/core/device-remove.c b/roms/u-boot/drivers/core/device-remove.c
new file mode 100644
index 000000000..11d3959d2
--- /dev/null
+++ b/roms/u-boot/drivers/core/device-remove.c
@@ -0,0 +1,266 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Device manager
+ *
+ * Copyright (c) 2014 Google, Inc
+ *
+ * (C) Copyright 2012
+ * Pavel Herrmann <morpheus.ibis@gmail.com>
+ */
+
+#define LOG_CATEGORY	LOGC_DM
+
+#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>
+#include <asm/global_data.h>
+
+int device_chld_unbind(struct udevice *dev, struct driver *drv)
+{
+	struct udevice *pos, *n;
+	int ret, saved_ret = 0;
+
+	assert(dev);
+
+	list_for_each_entry_safe(pos, n, &dev->child_head, sibling_node) {
+		if (drv && (pos->driver != drv))
+			continue;
+
+		ret = device_unbind(pos);
+		if (ret && !saved_ret) {
+			log_warning("device '%s' failed to unbind\n",
+				    pos->name);
+			saved_ret = ret;
+		}
+	}
+
+	return log_ret(saved_ret);
+}
+
+int device_chld_remove(struct udevice *dev, struct driver *drv,
+		       uint flags)
+{
+	struct udevice *pos, *n;
+	int result = 0;
+
+	assert(dev);
+
+	list_for_each_entry_safe(pos, n, &dev->child_head, sibling_node) {
+		int ret;
+
+		if (drv && (pos->driver != drv))
+			continue;
+
+		ret = device_remove(pos, flags);
+		if (ret == -EPROBE_DEFER)
+			result = ret;
+		else if (ret && ret != -EKEYREJECTED)
+			return ret;
+	}
+
+	return result;
+}
+
+int device_unbind(struct udevice *dev)
+{
+	const struct driver *drv;
+	int ret;
+
+	if (!dev)
+		return log_msg_ret("dev", -EINVAL);
+
+	if (dev_get_flags(dev) & DM_FLAG_ACTIVATED)
+		return log_msg_ret("active", -EINVAL);
+
+	if (!(dev_get_flags(dev) & DM_FLAG_BOUND))
+		return log_msg_ret("not-bound", -EINVAL);
+
+	drv = dev->driver;
+	assert(drv);
+
+	if (drv->unbind) {
+		ret = drv->unbind(dev);
+		if (ret)
+			return log_msg_ret("unbind", ret);
+	}
+
+	ret = device_chld_unbind(dev, NULL);
+	if (ret)
+		return log_msg_ret("child unbind", ret);
+
+	if (dev_get_flags(dev) & DM_FLAG_ALLOC_PDATA) {
+		free(dev_get_plat(dev));
+		dev_set_plat(dev, NULL);
+	}
+	if (dev_get_flags(dev) & DM_FLAG_ALLOC_UCLASS_PDATA) {
+		free(dev_get_uclass_plat(dev));
+		dev_set_uclass_plat(dev, NULL);
+	}
+	if (dev_get_flags(dev) & DM_FLAG_ALLOC_PARENT_PDATA) {
+		free(dev_get_parent_plat(dev));
+		dev_set_parent_plat(dev, NULL);
+	}
+	ret = uclass_unbind_device(dev);
+	if (ret)
+		return log_msg_ret("uc", ret);
+
+	if (dev->parent)
+		list_del(&dev->sibling_node);
+
+	devres_release_all(dev);
+
+	if (dev_get_flags(dev) & DM_FLAG_NAME_ALLOCED)
+		free((char *)dev->name);
+	free(dev);
+
+	return 0;
+}
+
+/**
+ * device_free() - Free memory buffers allocated by a device
+ * @dev:	Device that is to be started
+ */
+void device_free(struct udevice *dev)
+{
+	int size;
+
+	if (dev->driver->priv_auto) {
+		free(dev_get_priv(dev));
+		dev_set_priv(dev, NULL);
+	}
+	size = dev->uclass->uc_drv->per_device_auto;
+	if (size) {
+		free(dev_get_uclass_priv(dev));
+		dev_set_uclass_priv(dev, NULL);
+	}
+	if (dev->parent) {
+		size = dev->parent->driver->per_child_auto;
+		if (!size) {
+			size = dev->parent->uclass->uc_drv->
+					per_child_auto;
+		}
+		if (size) {
+			free(dev_get_parent_priv(dev));
+			dev_set_parent_priv(dev, NULL);
+		}
+	}
+	dev_bic_flags(dev, DM_FLAG_PLATDATA_VALID);
+
+	devres_release_probe(dev);
+}
+
+/**
+ * flags_remove() - Figure out whether to remove a device
+ *
+ * If this is called with @flags == DM_REMOVE_NON_VITAL | DM_REMOVE_ACTIVE_DMA,
+ * then it returns 0 (=go head and remove) if the device is not matked vital
+ * but is marked DM_REMOVE_ACTIVE_DMA.
+ *
+ * If this is called with @flags == DM_REMOVE_ACTIVE_DMA,
+ * then it returns 0 (=go head and remove) if the device is marked
+ * DM_REMOVE_ACTIVE_DMA, regardless of whether it is marked vital.
+ *
+ * @flags: Flags passed to device_remove()
+ * @drv_flags: Driver flags
+ * @return 0 if the device should be removed,
+ * -EKEYREJECTED if @flags includes a flag in DM_REMOVE_ACTIVE_ALL but
+ *	@drv_flags does not (indicates that this device has nothing to do for
+ *	DMA shutdown or OS prepare)
+ * -EPROBE_DEFER if @flags is DM_REMOVE_NON_VITAL but @drv_flags contains
+ *	DM_FLAG_VITAL (indicates the device is vital and should not be removed)
+ */
+static int flags_remove(uint flags, uint drv_flags)
+{
+	if (!(flags & DM_REMOVE_NORMAL)) {
+		bool vital_match;
+		bool active_match;
+
+		active_match = !(flags & DM_REMOVE_ACTIVE_ALL) ||
+			(drv_flags & flags);
+		vital_match = !(flags & DM_REMOVE_NON_VITAL) ||
+			!(drv_flags & DM_FLAG_VITAL);
+		if (!vital_match)
+			return -EPROBE_DEFER;
+		if (!active_match)
+			return -EKEYREJECTED;
+	}
+
+	return 0;
+}
+
+int device_remove(struct udevice *dev, uint flags)
+{
+	const struct driver *drv;
+	int ret;
+
+	if (!dev)
+		return -EINVAL;
+
+	if (!(dev_get_flags(dev) & DM_FLAG_ACTIVATED))
+		return 0;
+
+	/*
+	 * If the child returns EKEYREJECTED, continue. It just means that it
+	 * didn't match the flags.
+	 */
+	ret = device_chld_remove(dev, NULL, flags);
+	if (ret && ret != -EKEYREJECTED)
+		return ret;
+
+	/*
+	 * Remove the device if called with the "normal" remove flag set,
+	 * or if the remove flag matches any of the drivers remove flags
+	 */
+	drv = dev->driver;
+	assert(drv);
+	ret = flags_remove(flags, drv->flags);
+	if (ret) {
+		log_debug("%s: When removing: flags=%x, drv->flags=%x, err=%d\n",
+			  dev->name, flags, drv->flags, ret);
+		return ret;
+	}
+
+	ret = uclass_pre_remove_device(dev);
+	if (ret)
+		return ret;
+
+	if (drv->remove) {
+		ret = drv->remove(dev);
+		if (ret)
+			goto err_remove;
+	}
+
+	if (dev->parent && dev->parent->driver->child_post_remove) {
+		ret = dev->parent->driver->child_post_remove(dev);
+		if (ret) {
+			dm_warn("%s: Device '%s' failed child_post_remove()",
+				__func__, dev->name);
+		}
+	}
+
+	if (!(flags & DM_REMOVE_NO_PD) &&
+	    !(drv->flags &
+	      (DM_FLAG_DEFAULT_PD_CTRL_OFF | DM_FLAG_LEAVE_PD_ON)) &&
+	    dev != gd->cur_serial_dev)
+		dev_power_domain_off(dev);
+
+	device_free(dev);
+
+	dev_bic_flags(dev, DM_FLAG_ACTIVATED);
+
+	return 0;
+
+err_remove:
+	/* We can't put the children back */
+	dm_warn("%s: Device '%s' failed to remove, but children are gone\n",
+		__func__, dev->name);
+
+	return ret;
+}