mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-20 17:08:52 +09:00
![Anatolij Gustschin](/assets/img/avatar_default.png)
The power domain associated with a device is enabled when probing, but currently the domain remains enabled when the device is removed. Some boards started to disable power domains for selected devices via custom board_quiesce_devices(), but it doesn't work in many cases, i. e. because devices still can be accessed later in .remove() callback on behalf of dm_remove_devices_flags(). Utilize the DM core to power off the device power domain, but add a device flag to be able to selectively let the power domain enabled after device removal. This might be required for devices that must remain enabled when booting OS, i. e. serial console for debug output, etc. Signed-off-by: Anatolij Gustschin <agust@denx.de> Signed-off-by: Lokesh Vutla <lokeshvutla@ti.com> Reviewed-by: Simon Glass <sjg@chromium.org>
222 lines
4.1 KiB
C
222 lines
4.1 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* Device manager
|
|
*
|
|
* Copyright (c) 2014 Google, Inc
|
|
*
|
|
* (C) Copyright 2012
|
|
* Pavel Herrmann <morpheus.ibis@gmail.com>
|
|
*/
|
|
|
|
#include <common.h>
|
|
#include <errno.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>
|
|
|
|
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)
|
|
saved_ret = ret;
|
|
}
|
|
|
|
return saved_ret;
|
|
}
|
|
|
|
int device_chld_remove(struct udevice *dev, struct driver *drv,
|
|
uint flags)
|
|
{
|
|
struct udevice *pos, *n;
|
|
int ret;
|
|
|
|
assert(dev);
|
|
|
|
list_for_each_entry_safe(pos, n, &dev->child_head, sibling_node) {
|
|
if (drv && (pos->driver != drv))
|
|
continue;
|
|
|
|
ret = device_remove(pos, flags);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int device_unbind(struct udevice *dev)
|
|
{
|
|
const struct driver *drv;
|
|
int ret;
|
|
|
|
if (!dev)
|
|
return -EINVAL;
|
|
|
|
if (dev->flags & DM_FLAG_ACTIVATED)
|
|
return -EINVAL;
|
|
|
|
if (!(dev->flags & DM_FLAG_BOUND))
|
|
return -EINVAL;
|
|
|
|
drv = dev->driver;
|
|
assert(drv);
|
|
|
|
if (drv->unbind) {
|
|
ret = drv->unbind(dev);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
ret = device_chld_unbind(dev, NULL);
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (dev->flags & DM_FLAG_ALLOC_PDATA) {
|
|
free(dev->platdata);
|
|
dev->platdata = NULL;
|
|
}
|
|
if (dev->flags & DM_FLAG_ALLOC_UCLASS_PDATA) {
|
|
free(dev->uclass_platdata);
|
|
dev->uclass_platdata = NULL;
|
|
}
|
|
if (dev->flags & DM_FLAG_ALLOC_PARENT_PDATA) {
|
|
free(dev->parent_platdata);
|
|
dev->parent_platdata = NULL;
|
|
}
|
|
ret = uclass_unbind_device(dev);
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (dev->parent)
|
|
list_del(&dev->sibling_node);
|
|
|
|
devres_release_all(dev);
|
|
|
|
if (dev->flags & 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_alloc_size) {
|
|
free(dev->priv);
|
|
dev->priv = NULL;
|
|
}
|
|
size = dev->uclass->uc_drv->per_device_auto_alloc_size;
|
|
if (size) {
|
|
free(dev->uclass_priv);
|
|
dev->uclass_priv = NULL;
|
|
}
|
|
if (dev->parent) {
|
|
size = dev->parent->driver->per_child_auto_alloc_size;
|
|
if (!size) {
|
|
size = dev->parent->uclass->uc_drv->
|
|
per_child_auto_alloc_size;
|
|
}
|
|
if (size) {
|
|
free(dev->parent_priv);
|
|
dev->parent_priv = NULL;
|
|
}
|
|
}
|
|
|
|
devres_release_probe(dev);
|
|
}
|
|
|
|
static bool flags_remove(uint flags, uint drv_flags)
|
|
{
|
|
if ((flags & DM_REMOVE_NORMAL) ||
|
|
(flags & (drv_flags & (DM_FLAG_ACTIVE_DMA | DM_FLAG_OS_PREPARE))))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
int device_remove(struct udevice *dev, uint flags)
|
|
{
|
|
const struct driver *drv;
|
|
int ret;
|
|
|
|
if (!dev)
|
|
return -EINVAL;
|
|
|
|
if (!(dev->flags & DM_FLAG_ACTIVATED))
|
|
return 0;
|
|
|
|
drv = dev->driver;
|
|
assert(drv);
|
|
|
|
ret = uclass_pre_remove_device(dev);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = device_chld_remove(dev, NULL, flags);
|
|
if (ret)
|
|
goto err;
|
|
|
|
/*
|
|
* Remove the device if called with the "normal" remove flag set,
|
|
* or if the remove flag matches any of the drivers remove flags
|
|
*/
|
|
if (drv->remove && flags_remove(flags, drv->flags)) {
|
|
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 (!(drv->flags & DM_FLAG_DEFAULT_PD_CTRL_OFF) &&
|
|
(dev != gd->cur_serial_dev))
|
|
dev_power_domain_off(dev);
|
|
|
|
if (flags_remove(flags, drv->flags)) {
|
|
device_free(dev);
|
|
|
|
dev->seq = -1;
|
|
dev->flags &= ~DM_FLAG_ACTIVATED;
|
|
}
|
|
|
|
return ret;
|
|
|
|
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);
|
|
err:
|
|
ret = uclass_post_probe_device(dev);
|
|
if (ret) {
|
|
dm_warn("%s: Device '%s' failed to post_probe on error path\n",
|
|
__func__, dev->name);
|
|
}
|
|
|
|
return ret;
|
|
}
|