brain-hackers_pepepper-mirror
/
u-boot-brain
mirror of https://github.com/brain-hackers/u-boot-brain
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

dm: Drop the unused arg in uclass_find_device_by_seq() 

Now that there is only one sequence number (rather than both requested and
assigned ones) we can simplify this function. Also update its caller to
simplify the logic.

Signed-off-by: Simon Glass <sjg@chromium.org>
This commit is contained in:
Simon Glass 2020-12-16 21:20:29 -07:00
parent b5b11558bc
commit 991759196f
12 changed files with 64 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
arch/arm/mach-k3/am6_init.c
View File

@ -208,7 +208,7 @@ void board_init_f(ulong dummy)
* firmware (SYSFW) image for various purposes and SYSFW depends on us
* to initialize its pin settings.
*/
ret = uclass_find_device_by_seq(UCLASS_SERIAL, 0, true, &dev);
ret = uclass_find_device_by_seq(UCLASS_SERIAL, 0, &dev);
if (!ret)
pinctrl_select_state(dev, "default");

2
arch/arm/mach-k3/j721e_init.c
View File

@ -167,7 +167,7 @@ void board_init_f(ulong dummy)
* firmware (SYSFW) image for various purposes and SYSFW depends on us
* to initialize its pin settings.
*/
ret = uclass_find_device_by_seq(UCLASS_SERIAL, 0, true, &dev);
ret = uclass_find_device_by_seq(UCLASS_SERIAL, 0, &dev);
if (!ret)
pinctrl_select_state(dev, "default");

2
arch/arm/mach-k3/sysfw-loader.c
View File

@ -223,7 +223,7 @@ static void *k3_sysfw_get_spi_addr(void)
int ret;
ret = uclass_find_device_by_seq(UCLASS_SPI, CONFIG_SF_DEFAULT_BUS,
true, &dev);
&dev);
if (ret)
return NULL;

16
drivers/core/device.c
View File

@ -647,15 +647,15 @@ int device_get_child_count(const struct udevice *parent)
return count;
}
int device_find_child_by_seq(const struct udevice *parent, int seq_or_req_seq,
bool find_req_seq, struct udevice **devp)
int device_find_child_by_seq(const struct udevice *parent, int seq,
struct udevice **devp)
{
struct udevice *dev;
*devp = NULL;
list_for_each_entry(dev, &parent->child_head, sibling_node) {
if (dev->sqq == seq_or_req_seq) {
if (dev->sqq == seq) {
*devp = dev;
return 0;
}
@ -671,14 +671,8 @@ int device_get_child_by_seq(const struct udevice *parent, int seq,
int ret;
*devp = NULL;
ret = device_find_child_by_seq(parent, seq, false, &dev);
if (ret == -ENODEV) {
/*
* We didn't find it in probed devices. See if there is one
* that will request this seq if probed.
*/
ret = device_find_child_by_seq(parent, seq, true, &dev);
}
ret = device_find_child_by_seq(parent, seq, &dev);
return device_get_device_tail(dev, ret, devp);
}

22
drivers/core/uclass.c
View File

@ -288,25 +288,23 @@ int uclass_find_next_free_req_seq(struct uclass *uc)
return max + 1;
}
int uclass_find_device_by_seq(enum uclass_id id, int seq_or_req_seq,
bool find_req_seq, struct udevice **devp)
int uclass_find_device_by_seq(enum uclass_id id, int seq, struct udevice **devp)
{
struct uclass *uc;
struct udevice *dev;
int ret;
*devp = NULL;
log_debug("%d %d\n", find_req_seq, seq_or_req_seq);
if (seq_or_req_seq == -1)
log_debug("%d\n", seq);
if (seq == -1)
return -ENODEV;
ret = uclass_get(id, &uc);
if (ret)
return ret;
uclass_foreach_dev(dev, uc) {
log_debug(" - %d %d '%s'\n",
dev->req_seq, dev_seq(dev), dev->name);
if (dev_seq(dev) == seq_or_req_seq) {
log_debug(" - %d '%s'\n", dev->sqq, dev->name);
if (dev->sqq == seq) {
*devp = dev;
log_debug(" - found\n");
return 0;
@ -466,14 +464,8 @@ int uclass_get_device_by_seq(enum uclass_id id, int seq, struct udevice **devp)
int ret;
*devp = NULL;
ret = uclass_find_device_by_seq(id, seq, false, &dev);
if (ret == -ENODEV) {
/*
* We didn't find it in probed devices. See if there is one
* that will request this seq if probed.
*/
ret = uclass_find_device_by_seq(id, seq, true, &dev);
}
ret = uclass_find_device_by_seq(id, seq, &dev);
return uclass_get_device_tail(dev, ret, devp);
}

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

@ -273,7 +273,7 @@ int spi_cs_is_valid(unsigned int busnum, unsigned int cs)
struct udevice *bus;
int ret;
ret = uclass_find_device_by_seq(UCLASS_SPI, busnum, false, &bus);
ret = uclass_find_device_by_seq(UCLASS_SPI, busnum, &bus);
if (ret) {
debug("%s: No bus %d\n", __func__, busnum);
return ret;
@ -302,7 +302,7 @@ int spi_find_bus_and_cs(int busnum, int cs, struct udevice **busp,
struct udevice *bus, *dev;
int ret;
ret = uclass_find_device_by_seq(UCLASS_SPI, busnum, false, &bus);
ret = uclass_find_device_by_seq(UCLASS_SPI, busnum, &bus);
if (ret) {
debug("%s: No bus %d\n", __func__, busnum);
return ret;

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

@ -394,7 +394,7 @@ int usb_setup_ehci_gadget(struct ehci_ctrl **ctlrp)
int ret;
/* Find the old device and remove it */
ret = uclass_find_device_by_seq(UCLASS_USB, 0, true, &dev);
ret = uclass_find_device_by_seq(UCLASS_USB, 0, &dev);
if (ret)
return ret;
ret = device_remove(dev, DM_REMOVE_NORMAL);
@ -417,7 +417,7 @@ int usb_remove_ehci_gadget(struct ehci_ctrl **ctlrp)
int ret;
/* Find the old device and remove it */
ret = uclass_find_device_by_seq(UCLASS_USB, 0, true, &dev);
ret = uclass_find_device_by_seq(UCLASS_USB, 0, &dev);
if (ret)
return ret;
ret = device_remove(dev, DM_REMOVE_NORMAL);

18
include/dm/device.h
View File

@ -452,24 +452,16 @@ int device_get_child_count(const struct udevice *parent);
/**
* device_find_child_by_seq() - Find a child device based on a sequence
*
* This searches for a device with the given seq or req_seq.
*
* For seq, if an active device has this sequence it will be returned.
* If there is no such device then this will return -ENODEV.
*
* For req_seq, if a device (whether activated or not) has this req_seq
* value, that device will be returned. This is a strong indication that
* the device will receive that sequence when activated.
* This searches for a device with the given seq.
*
* @parent: Parent device
* @seq_or_req_seq: Sequence number to find (0=first)
* @find_req_seq: true to find req_seq, false to find seq
* @seq: Sequence number to find (0=first)
* @devp: Returns pointer to device (there is only one per for each seq).
* Set to NULL if none is found
* @return 0 if OK, -ve on error
* @return 0 if OK, -ENODEV if not found
*/
int device_find_child_by_seq(const struct udevice *parent, int seq_or_req_seq,
bool find_req_seq, struct udevice **devp);
int device_find_child_by_seq(const struct udevice *parent, int seq,
struct udevice **devp);
/**
* device_get_child_by_seq() - Get a child device based on a sequence

18
include/dm/uclass-internal.h
View File

@ -103,25 +103,17 @@ int uclass_find_device_by_name(enum uclass_id id, const char *name,
/**
* uclass_find_device_by_seq() - Find uclass device based on ID and sequence
*
* This searches for a device with the given seq or req_seq.
*
* For seq, if an active device has this sequence it will be returned.
* If there is no such device then this will return -ENODEV.
*
* For req_seq, if a device (whether activated or not) has this req_seq
* value, that device will be returned. This is a strong indication that
* the device will receive that sequence when activated.
* This searches for a device with the given seq.
*
* The device is NOT probed, it is merely returned.
*
* @id: ID to look up
* @seq_or_req_seq: Sequence number to find (0=first)
* @find_req_seq: true to find req_seq, false to find seq
* @seq: Sequence number to find (0=first)
* @devp: Returns pointer to device (there is only one per for each seq)
* @return 0 if OK, -ve on error
* @return 0 if OK, -ENODEV if not found
*/
int uclass_find_device_by_seq(enum uclass_id id, int seq_or_req_seq,
bool find_req_seq, struct udevice **devp);
int uclass_find_device_by_seq(enum uclass_id id, int seq,
struct udevice **devp);
/**
* uclass_find_device_by_of_offset() - Find a uclass device by device tree node

2
net/eth-uclass.c
View File

@ -232,7 +232,7 @@ static int on_ethaddr(const char *name, const char *value, enum env_op op,
/* look for an index after "eth" */
index = simple_strtoul(name + 3, NULL, 10);
retval = uclass_find_device_by_seq(UCLASS_ETH, index, false, &dev);
retval = uclass_find_device_by_seq(UCLASS_ETH, index, &dev);
if (!retval) {
struct eth_pdata *pdata = dev->plat;
switch (op) {

16
test/dm/bus.c
View File

@ -156,17 +156,17 @@ static int dm_test_bus_children_funcs(struct unit_test_state *uts)
ut_asserteq_str("c-test@5", dev->name);
/* Device with sequence number 0 should be accessible */
ut_asserteq(-ENODEV, device_find_child_by_seq(bus, -1, true, &dev));
ut_assertok(device_find_child_by_seq(bus, 0, true, &dev));
ut_asserteq(-ENODEV, device_find_child_by_seq(bus, -1, &dev));
ut_assertok(device_find_child_by_seq(bus, 0, &dev));
ut_assert(!(dev->flags & DM_FLAG_ACTIVATED));
ut_asserteq(0, device_find_child_by_seq(bus, 0, false, &dev));
ut_asserteq(0, device_find_child_by_seq(bus, 0, &dev));
ut_assertok(device_get_child_by_seq(bus, 0, &dev));
ut_assert(dev->flags & DM_FLAG_ACTIVATED);
ut_asserteq(0, device_find_child_by_seq(bus, 0, false, &dev));
ut_asserteq(0, device_find_child_by_seq(bus, 0, &dev));
/* There is no device with sequence number 2 */
ut_asserteq(-ENODEV, device_find_child_by_seq(bus, 2, false, &dev));
ut_asserteq(-ENODEV, device_find_child_by_seq(bus, 2, true, &dev));
ut_asserteq(-ENODEV, device_find_child_by_seq(bus, 2, &dev));
ut_asserteq(-ENODEV, device_find_child_by_seq(bus, 2, &dev));
ut_asserteq(-ENODEV, device_get_child_by_seq(bus, 2, &dev));
/* Looking for something that is not a child */
@ -220,7 +220,7 @@ static int dm_test_bus_children_iterators(struct unit_test_state *uts)
ut_asserteq_ptr(dev, NULL);
/* Move to the next child without using device_find_first_child() */
ut_assertok(device_find_child_by_seq(bus, 5, true, &dev));
ut_assertok(device_find_child_by_seq(bus, 5, &dev));
ut_asserteq_str("c-test@5", dev->name);
ut_assertok(device_find_next_child(&dev));
ut_asserteq_str("c-test@0", dev->name);
@ -245,7 +245,7 @@ static int test_bus_parent_data(struct unit_test_state *uts)
ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
/* Check that parent data is allocated */
ut_assertok(device_find_child_by_seq(bus, 0, true, &dev));
ut_assertok(device_find_child_by_seq(bus, 0, &dev));
ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
ut_assertok(device_get_child_by_seq(bus, 0, &dev));
parent_data = dev_get_parent_priv(dev);

52
test/dm/test-fdt.c
View File

@ -348,11 +348,11 @@ static int dm_test_fdt_uclass_seq(struct unit_test_state *uts)
struct udevice *dev;
/* A few basic santiy tests */
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_FDT, 3, true, &dev));
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_FDT, 3, &dev));
ut_asserteq_str("b-test", dev->name);
ut_asserteq(3, dev_seq(dev));
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_FDT, 8, true, &dev));
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_FDT, 8, &dev));
ut_asserteq_str("a-test", dev->name);
ut_asserteq(8, dev_seq(dev));
@ -360,11 +360,11 @@ static int dm_test_fdt_uclass_seq(struct unit_test_state *uts)
* This device has no alias so gets the next value after all available
* aliases. The last alias is testfdt12
*/
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_FDT, 13, true, &dev));
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_FDT, 13, &dev));
ut_asserteq_str("d-test", dev->name);
ut_asserteq(13, dev_seq(dev));
ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 9, true,
ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 9,
&dev));
ut_asserteq_ptr(NULL, dev);
@ -395,22 +395,22 @@ static int dm_test_fdt_uclass_seq(struct unit_test_state *uts)
ut_asserteq(15, dev_seq(dev));
/* And we should still have holes in our sequence numbers */
ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 0, true,
ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 0,
&dev));
ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 1, true,
ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 1,
&dev));
ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 2, true,
ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 2,
&dev));
ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 4, true,
ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 4,
&dev));
ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 7, true,
ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 7,
&dev));
ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 9, true,
ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 9,
&dev));
ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 10,
true, &dev));
&dev));
ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 11,
true, &dev));
&dev));
return 0;
}
@ -636,30 +636,30 @@ static int dm_test_fdt_translation(struct unit_test_state *uts)
fdt32_t dma_addr[2];
/* Some simple translations */
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, &dev));
ut_asserteq_str("dev@0,0", dev->name);
ut_asserteq(0x8000, dev_read_addr(dev));
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 1, true, &dev));
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 1, &dev));
ut_asserteq_str("dev@1,100", dev->name);
ut_asserteq(0x9000, dev_read_addr(dev));
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 2, true, &dev));
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 2, &dev));
ut_asserteq_str("dev@2,200", dev->name);
ut_asserteq(0xA000, dev_read_addr(dev));
/* No translation for busses with #size-cells == 0 */
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 3, true, &dev));
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 3, &dev));
ut_asserteq_str("dev@42", dev->name);
ut_asserteq(0x42, dev_read_addr(dev));
/* dma address translation */
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, &dev));
dma_addr[0] = cpu_to_be32(0);
dma_addr[1] = cpu_to_be32(0);
ut_asserteq(0x10000000, dev_translate_dma_address(dev, dma_addr));
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 1, true, &dev));
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 1, &dev));
dma_addr[0] = cpu_to_be32(1);
dma_addr[1] = cpu_to_be32(0x100);
ut_asserteq(0x20000000, dev_translate_dma_address(dev, dma_addr));
@ -677,7 +677,7 @@ static int dm_test_fdt_get_addr_ptr_flat(struct unit_test_state *uts)
ut_assertok(uclass_first_device_err(UCLASS_GPIO, &gpio));
ut_assertnull(devfdt_get_addr_ptr(gpio));
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, &dev));
ptr = devfdt_get_addr_ptr(dev);
ut_asserteq_ptr((void *)0x8000, ptr);
@ -692,7 +692,7 @@ static int dm_test_fdt_remap_addr_flat(struct unit_test_state *uts)
fdt_addr_t addr;
void *paddr;
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, &dev));
addr = devfdt_get_addr(dev);
ut_asserteq(0x8000, addr);
@ -713,7 +713,7 @@ static int dm_test_fdt_remap_addr_index_flat(struct unit_test_state *uts)
fdt_size_t size;
void *paddr;
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, &dev));
addr = devfdt_get_addr_size_index(dev, 0, &size);
ut_asserteq(0x8000, addr);
@ -735,7 +735,7 @@ static int dm_test_fdt_remap_addr_name_flat(struct unit_test_state *uts)
fdt_size_t size;
void *paddr;
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, &dev));
addr = devfdt_get_addr_size_name(dev, "sandbox-dummy-0", &size);
ut_asserteq(0x8000, addr);
@ -756,7 +756,7 @@ static int dm_test_fdt_remap_addr_live(struct unit_test_state *uts)
fdt_addr_t addr;
void *paddr;
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, &dev));
addr = dev_read_addr(dev);
ut_asserteq(0x8000, addr);
@ -777,7 +777,7 @@ static int dm_test_fdt_remap_addr_index_live(struct unit_test_state *uts)
fdt_size_t size;
void *paddr;
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, &dev));
addr = dev_read_addr_size_index(dev, 0, &size);
ut_asserteq(0x8000, addr);
@ -799,7 +799,7 @@ static int dm_test_fdt_remap_addr_name_live(struct unit_test_state *uts)
fdt_size_t size;
void *paddr;
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, &dev));
addr = dev_read_addr_size_name(dev, "sandbox-dummy-0", &size);
ut_asserteq(0x8000, addr);
@ -834,7 +834,7 @@ static int dm_test_fdt_livetree_writing(struct unit_test_state *uts)
device_bind_driver_to_node(dm_root(), "usb_sandbox", "usb@2", node,
&dev);
ut_assertok(uclass_find_device_by_seq(UCLASS_USB, 2, true, &dev));
ut_assertok(uclass_find_device_by_seq(UCLASS_USB, 2, &dev));
/* Test string property setting */