Mirrors/u-boot
2
0
Fork 0
mirror of https://github.com/AsahiLinux/u-boot synced 2024-11-28 15:41:40 +00:00
Code Issues Projects Releases Packages Wiki Activity

dm: core: Add flags parameter to device_remove()

Browse source 
This patch adds the flags parameter to device_remove() and changes all
calls to this function to provide the default value of DM_REMOVE_NORMAL
for "normal" device removal.

This is in preparation for the driver specific pre-OS (e.g. DMA
cancelling) remove support.

Signed-off-by: Stefan Roese <sr@denx.de>
Cc: Simon Glass <sjg@chromium.org>
Acked-by: Simon Glass <sjg@chromium.org>
This commit is contained in:
Stefan Roese 2017-03-20 12:51:48 +01:00 committed by Simon Glass
parent 11db152246
commit 706865afe5
21 changed files with 65 additions and 37 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
arch/x86/cpu/queensbay/tnc.c
View file

@ -76,13 +76,13 @@ static int __maybe_unused disable_igd(void)
*
* So the only option we have is to manually remove these two devices.
*/
ret = device_remove(igd);
ret = device_remove(igd, DM_REMOVE_NORMAL);
if (ret)
return ret;
ret = device_unbind(igd);
if (ret)
return ret;
ret = device_remove(sdvo);
ret = device_remove(sdvo, DM_REMOVE_NORMAL);
if (ret)
return ret;
ret = device_unbind(sdvo);

2
cmd/cros_ec.c
View file

@ -110,7 +110,7 @@ static int do_cros_ec(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
/* Remove any existing device */
ret = uclass_find_device(UCLASS_CROS_EC, 0, &udev);
if (!ret)
device_remove(udev);
device_remove(udev, DM_REMOVE_NORMAL);
ret = uclass_get_device(UCLASS_CROS_EC, 0, &udev);
if (ret) {
printf("Could not init cros_ec device (err %d)\n", ret);

2
cmd/sf.c
View file

@ -124,7 +124,7 @@ static int do_spi_flash_probe(int argc, char * const argv[])
/* Remove the old device, otherwise probe will just be a nop */
ret = spi_find_bus_and_cs(bus, cs, &bus_dev, &new);
if (!ret) {
device_remove(new);
device_remove(new, DM_REMOVE_NORMAL);
}
flash = NULL;
ret = spi_flash_probe_bus_cs(bus, cs, speed, mode, &new);

2
drivers/block/blk-uclass.c
View file

@ -530,7 +530,7 @@ int blk_unbind_all(int if_type)
struct blk_desc *desc = dev_get_uclass_platdata(dev);
if (desc->if_type == if_type) {
ret = device_remove(dev);
ret = device_remove(dev, DM_REMOVE_NORMAL);
if (ret)
return ret;
ret = device_unbind(dev);

2
drivers/block/sandbox.c
View file

@ -98,7 +98,7 @@ int host_dev_bind(int devnum, char *filename)
/* Remove and unbind the old device, if any */
ret = blk_get_device(IF_TYPE_HOST, devnum, &dev);
if (ret == 0) {
ret = device_remove(dev);
ret = device_remove(dev, DM_REMOVE_NORMAL);
if (ret)
return ret;
ret = device_unbind(dev);

9
drivers/core/device-remove.c
View file

@ -46,9 +46,10 @@ static int device_chld_unbind(struct udevice *dev)
/**
* device_chld_remove() - Stop all device's children
* @dev: The device whose children are to be removed
* @pre_os_remove: Flag, if this functions is called in the pre-OS stage
* @return 0 on success, -ve on error
*/
static int device_chld_remove(struct udevice *dev)
static int device_chld_remove(struct udevice *dev, uint flags)
{
struct udevice *pos, *n;
int ret;
@ -56,7 +57,7 @@ static int device_chld_remove(struct udevice *dev)
assert(dev);
list_for_each_entry_safe(pos, n, &dev->child_head, sibling_node) {
ret = device_remove(pos);
ret = device_remove(pos, flags);
if (ret)
return ret;
}
@ -151,7 +152,7 @@ void device_free(struct udevice *dev)
devres_release_probe(dev);
}
int device_remove(struct udevice *dev)
int device_remove(struct udevice *dev, uint flags)
{
const struct driver *drv;
int ret;
@ -169,7 +170,7 @@ int device_remove(struct udevice *dev)
if (ret)
return ret;
ret = device_chld_remove(dev);
ret = device_chld_remove(dev, flags);
if (ret)
goto err;

2
drivers/core/device.c
View file

@ -378,7 +378,7 @@ int device_probe(struct udevice *dev)
return 0;
fail_uclass:
if (device_remove(dev)) {
if (device_remove(dev, DM_REMOVE_NORMAL)) {
dm_warn("%s: Device '%s' failed to remove on error path\n",
__func__, dev->name);
}

2
drivers/core/root.c
View file

@ -178,7 +178,7 @@ int dm_init(void)
int dm_uninit(void)
{
device_remove(dm_root());
device_remove(dm_root(), DM_REMOVE_NORMAL);
device_unbind(dm_root());
return 0;

2
drivers/core/uclass.c
View file

@ -116,7 +116,7 @@ int uclass_destroy(struct uclass *uc)
while (!list_empty(&uc->dev_head)) {
dev = list_first_entry(&uc->dev_head, struct udevice,
uclass_node);
ret = device_remove(dev);
ret = device_remove(dev, DM_REMOVE_NORMAL);
if (ret)
return ret;
ret = device_unbind(dev);

2
drivers/mmc/mmc-uclass.c
View file

@ -232,7 +232,7 @@ int mmc_unbind(struct udevice *dev)
device_find_first_child(dev, &bdev);
if (bdev) {
device_remove(bdev);
device_remove(bdev, DM_REMOVE_NORMAL);
device_unbind(bdev);
}

2
drivers/mtd/spi/sandbox.c
View file

@ -595,7 +595,7 @@ void sandbox_sf_unbind_emul(struct sandbox_state *state, int busnum, int cs)
struct udevice *dev;
dev = state->spi[busnum][cs].emul;
device_remove(dev);
device_remove(dev, DM_REMOVE_NORMAL);
device_unbind(dev);
state->spi[busnum][cs].emul = NULL;
}

2
drivers/mtd/spi/sf-uclass.c
View file

@ -46,7 +46,7 @@ struct spi_flash *spi_flash_probe(unsigned int bus, unsigned int cs,
void spi_flash_free(struct spi_flash *flash)
{
device_remove(flash->spi->dev);
device_remove(flash->spi->dev, DM_REMOVE_NORMAL);
}
int spi_flash_probe_bus_cs(unsigned int busnum, unsigned int cs,

4
drivers/spi/spi-uclass.c
View file

@ -343,7 +343,7 @@ err:
debug("%s: Error path, created=%d, device '%s'\n", __func__,
created, dev->name);
if (created) {
device_remove(dev);
device_remove(dev, DM_REMOVE_NORMAL);
device_unbind(dev);
}
@ -384,7 +384,7 @@ struct spi_slave *spi_setup_slave(unsigned int busnum, unsigned int cs,
void spi_free_slave(struct spi_slave *slave)
{
device_remove(slave->dev);
device_remove(slave->dev, DM_REMOVE_NORMAL);
slave->dev = NULL;
}

2
drivers/usb/emul/sandbox_hub.c
View file

@ -156,7 +156,7 @@ static int clrset_post_state(struct udevice *hub, int port, int clear, int set)
} else if (clear & USB_PORT_STAT_POWER) {
debug("%s: %s: power off, removed, ret=%d\n",
__func__, dev->name, ret);
ret = device_remove(dev);
ret = device_remove(dev, DM_REMOVE_NORMAL);
clear |= USB_PORT_STAT_CONNECTION;
}
}

4
drivers/usb/host/usb-uclass.c
View file

@ -154,7 +154,7 @@ int usb_stop(void)
uc_priv = uc->priv;
uclass_foreach_dev(bus, uc) {
ret = device_remove(bus);
ret = device_remove(bus, DM_REMOVE_NORMAL);
if (ret && !err)
err = ret;
}
@ -358,7 +358,7 @@ int usb_setup_ehci_gadget(struct ehci_ctrl **ctlrp)
ret = uclass_find_device_by_seq(UCLASS_USB, 0, true, &dev);
if (ret)
return ret;
ret = device_remove(dev);
ret = device_remove(dev, DM_REMOVE_NORMAL);
if (ret)
return ret;

5
include/dm/device-internal.h
View file

@ -96,12 +96,13 @@ int device_probe(struct udevice *dev);
* children are deactivated first.
*
* @dev: Pointer to device to remove
* @flags: Flags for selective device removal
* @return 0 if OK, -ve on error (an error here is normally a very bad thing)
*/
#if CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)
int device_remove(struct udevice *dev);
int device_remove(struct udevice *dev, uint flags);
#else
static inline int device_remove(struct udevice *dev) { return 0; }
static inline int device_remove(struct udevice *dev, uint flags) { return 0; }
#endif
/**

26
include/dm/device.h
View file

@ -46,6 +46,32 @@ struct driver_info;
#define DM_FLAG_OF_PLATDATA (1 << 8)
/*
* Call driver remove function to stop currently active DMA transfers or
* give DMA buffers back to the HW / controller. This may be needed for
* some drivers to do some final stage cleanup before the OS is called
* (U-Boot exit)
*/
#define DM_FLAG_ACTIVE_DMA (1 << 9)
/*
* One or multiple of these flags are passed to device_remove() so that
* a selective device removal as specified by the remove-stage and the
* driver flags can be done.
*/
enum {
/* Normal remove, remove all devices */
DM_REMOVE_NORMAL = 1 << 0,
/* Remove devices with active DMA */
DM_REMOVE_ACTIVE_DMA = DM_FLAG_ACTIVE_DMA,
/* Add more use cases here */
/* Remove devices with any active flag */
DM_REMOVE_ACTIVE_ALL = DM_REMOVE_ACTIVE_DMA,
};
/**
* struct udevice - An instance of a driver
*

8
test/dm/bus.c
View file

@ -222,7 +222,7 @@ static int test_bus_parent_data(struct unit_test_state *uts)
/* Check that it starts at 0 and goes away when device is removed */
parent_data->sum += 5;
ut_asserteq(5, parent_data->sum);
device_remove(dev);
device_remove(dev, DM_REMOVE_NORMAL);
ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
/* Check that we can do this twice */
@ -323,7 +323,7 @@ static int dm_test_bus_parent_ops(struct unit_test_state *uts)
continue;
parent_data = dev_get_parent_priv(dev);
ut_asserteq(FLAG_CHILD_PROBED, parent_data->flag);
ut_assertok(device_remove(dev));
ut_assertok(device_remove(dev, DM_REMOVE_NORMAL));
ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
ut_asserteq_ptr(dms->removed, dev);
}
@ -360,7 +360,7 @@ static int test_bus_parent_platdata(struct unit_test_state *uts)
plat->count++;
ut_asserteq(1, plat->count);
device_probe(dev);
device_remove(dev);
device_remove(dev, DM_REMOVE_NORMAL);
ut_asserteq_ptr(plat, dev_get_parent_platdata(dev));
ut_asserteq(1, plat->count);
@ -370,7 +370,7 @@ static int test_bus_parent_platdata(struct unit_test_state *uts)
ut_asserteq(3, child_count);
/* Removing the bus should also have no effect (it is still bound) */
device_remove(bus);
device_remove(bus, DM_REMOVE_NORMAL);
for (device_find_first_child(bus, &dev), child_count = 0;
dev;
device_find_next_child(&dev)) {

16
test/dm/core.c
View file

@ -319,7 +319,7 @@ static int dm_test_lifecycle(struct unit_test_state *uts)
/* Now remove device 3 */
ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_PRE_REMOVE]);
ut_assertok(device_remove(dev));
ut_assertok(device_remove(dev, DM_REMOVE_NORMAL));
ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_PRE_REMOVE]);
ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_UNBIND]);
@ -352,7 +352,7 @@ static int dm_test_ordering(struct unit_test_state *uts)
ut_assert(dev_last);
/* Now remove device 3 */
ut_assertok(device_remove(dev));
ut_assertok(device_remove(dev, DM_REMOVE_NORMAL));
ut_assertok(device_unbind(dev));
/* The device numbering should have shifted down one */
@ -371,9 +371,9 @@ static int dm_test_ordering(struct unit_test_state *uts)
ut_assert(pingret == 102);
/* Remove 3 and 4 */
ut_assertok(device_remove(dev_penultimate));
ut_assertok(device_remove(dev_penultimate, DM_REMOVE_NORMAL));
ut_assertok(device_unbind(dev_penultimate));
ut_assertok(device_remove(dev_last));
ut_assertok(device_remove(dev_last, DM_REMOVE_NORMAL));
ut_assertok(device_unbind(dev_last));
/* Our device should now be in position 3 */
@ -381,7 +381,7 @@ static int dm_test_ordering(struct unit_test_state *uts)
ut_assert(dev == test_dev);
/* Now remove device 3 */
ut_assertok(device_remove(dev));
ut_assertok(device_remove(dev, DM_REMOVE_NORMAL));
ut_assertok(device_unbind(dev));
return 0;
@ -457,7 +457,7 @@ static int dm_test_remove(struct unit_test_state *uts)
ut_assert(dev);
ut_assertf(dev->flags & DM_FLAG_ACTIVATED,
"Driver %d/%s not activated", i, dev->name);
ut_assertok(device_remove(dev));
ut_assertok(device_remove(dev, DM_REMOVE_NORMAL));
ut_assertf(!(dev->flags & DM_FLAG_ACTIVATED),
"Driver %d/%s should have deactivated", i,
dev->name);
@ -611,14 +611,14 @@ static int dm_test_children(struct unit_test_state *uts)
ut_asserteq(total, dm_testdrv_op_count[DM_TEST_OP_PROBE]);
/* Remove a top-level child and check that the children are removed */
ut_assertok(device_remove(top[2]));
ut_assertok(device_remove(top[2], DM_REMOVE_NORMAL));
ut_asserteq(NODE_COUNT + 1, dm_testdrv_op_count[DM_TEST_OP_REMOVE]);
dm_testdrv_op_count[DM_TEST_OP_REMOVE] = 0;
/* Try one with grandchildren */
ut_assertok(uclass_get_device(UCLASS_TEST, 5, &dev));
ut_asserteq_ptr(dev, top[5]);
ut_assertok(device_remove(dev));
ut_assertok(device_remove(dev, DM_REMOVE_NORMAL));
ut_asserteq(1 + NODE_COUNT * (1 + NODE_COUNT),
dm_testdrv_op_count[DM_TEST_OP_REMOVE]);

2
test/dm/eth.c
View file

@ -116,7 +116,7 @@ static int dm_test_eth_act(struct unit_test_state *uts)
for (i = 0; i < DM_TEST_ETH_NUM; i++) {
ut_assertok(uclass_find_device_by_name(UCLASS_ETH,
ethname[i], &dev[i]));
ut_assertok(device_remove(dev[i]));
ut_assertok(device_remove(dev[i], DM_REMOVE_NORMAL));
/* Invalidate MAC address */
strcpy(ethaddr[i], getenv(addrname[i]));

2
test/dm/spi.c
View file

@ -36,7 +36,7 @@ static int dm_test_spi_find(struct unit_test_state *uts)
ut_asserteq(0, uclass_get_device_by_seq(UCLASS_SPI, busnum, &bus));
ut_assertok(spi_cs_info(bus, cs, &info));
of_offset = dev_of_offset(info.dev);
device_remove(info.dev);
device_remove(info.dev, DM_REMOVE_NORMAL);
device_unbind(info.dev);
/*