mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-19 08:28:51 +09:00
267 lines
5.8 KiB
C
267 lines
5.8 KiB
C
// 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;
|
|
}
|