From: Neil Armstrong Date: Thu, 20 Nov 2025 08:12:53 +0000 (+0100) Subject: interconnect: add DM test suite X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=9ab7163710d390672a7325cd0980ce32e2a8191a;p=thirdparty%2Fu-boot.git interconnect: add DM test suite Add a test suite exercising the whole lifetime and callbacks of interconnect with a fake 5 providers with a split node graph. The test suite checks the calculus are right and goes to the correct nodes, and the lifetime of the node is correct. Link: https://patch.msgid.link/20251120-topic-interconnect-next-v5-2-e8a82720da5d@linaro.org Signed-off-by: Neil Armstrong --- diff --git a/arch/sandbox/dts/test.dts b/arch/sandbox/dts/test.dts index 13d8e498b03..0b3fc505e53 100644 --- a/arch/sandbox/dts/test.dts +++ b/arch/sandbox/dts/test.dts @@ -864,6 +864,42 @@ }; }; + icc0: interconnect-0 { + compatible = "sandbox,interconnect0"; + #interconnect-cells = <1>; + }; + + icc1: interconnect-1 { + compatible = "sandbox,interconnect1"; + #interconnect-cells = <1>; + }; + + icc2: interconnect-2 { + compatible = "sandbox,interconnect2"; + #interconnect-cells = <1>; + }; + + icc3: interconnect-3 { + compatible = "sandbox,interconnect3"; + #interconnect-cells = <1>; + }; + + icc4: interconnect-4 { + compatible = "sandbox,interconnect4"; + #interconnect-cells = <1>; + }; + + interconnect-test-0 { + compatible = "sandbox,interconnect-test"; + interconnects = <&icc0 0 &icc3 0>; + }; + + interconnect-test-1 { + compatible = "sandbox,interconnect-test"; + interconnects = <&icc1 0 &icc4 0>; + interconnect-names = "icc-path"; + }; + i2c@0 { #address-cells = <1>; #size-cells = <0>; diff --git a/arch/sandbox/include/asm/interconnect.h b/arch/sandbox/include/asm/interconnect.h new file mode 100644 index 00000000000..17065bf6a11 --- /dev/null +++ b/arch/sandbox/include/asm/interconnect.h @@ -0,0 +1,19 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright (c) 2025 Linaro Limited + */ + +#ifndef __SANDBOX_INTERCONNECT_H +#define __SANDBOX_INTERCONNECT_H + +struct udevice; + +int sandbox_interconnect_get_bw(struct udevice *dev, u64 *avg, u64 *peak); +int sandbox_interconnect_test_get(struct udevice *dev, char *name); +int sandbox_interconnect_test_get_index(struct udevice *dev, int index); +int sandbox_interconnect_test_enable(struct udevice *dev); +int sandbox_interconnect_test_disable(struct udevice *dev); +int sandbox_interconnect_test_set_bw(struct udevice *dev, u32 avg_bw, u32 peak_bw); +int sandbox_interconnect_test_put(struct udevice *dev); + +#endif diff --git a/configs/sandbox64_defconfig b/configs/sandbox64_defconfig index 169d0a2adef..1603e86d184 100644 --- a/configs/sandbox64_defconfig +++ b/configs/sandbox64_defconfig @@ -202,6 +202,8 @@ CONFIG_PINCTRL_SANDBOX=y CONFIG_PINCTRL_SINGLE=y CONFIG_POWER_DOMAIN=y CONFIG_SANDBOX_POWER_DOMAIN=y +CONFIG_INTERCONNECT=y +CONFIG_INTERCONNECT_SANDBOX=y CONFIG_DM_PMIC=y CONFIG_PMIC_ACT8846=y CONFIG_DM_PMIC_PFUZE100=y diff --git a/configs/sandbox_defconfig b/configs/sandbox_defconfig index f4c2cc5d155..57d5b1f15ca 100644 --- a/configs/sandbox_defconfig +++ b/configs/sandbox_defconfig @@ -281,6 +281,8 @@ CONFIG_PINCTRL_SANDBOX=y CONFIG_PINCTRL_SINGLE=y CONFIG_POWER_DOMAIN=y CONFIG_SANDBOX_POWER_DOMAIN=y +CONFIG_INTERCONNECT=y +CONFIG_INTERCONNECT_SANDBOX=y CONFIG_SCMI_POWER_DOMAIN=y CONFIG_DM_PMIC=y CONFIG_PMIC_ACT8846=y diff --git a/drivers/interconnect/Kconfig b/drivers/interconnect/Kconfig index 38d39651ab5..e9f4cc662ae 100644 --- a/drivers/interconnect/Kconfig +++ b/drivers/interconnect/Kconfig @@ -7,4 +7,14 @@ config INTERCONNECT Enable support for the interconnect driver class. Many SoCs allow bandwidth to be tuned on busses within the SoC. +if INTERCONNECT + +config INTERCONNECT_SANDBOX + bool "Enable interconnect sandbox driver" + depends on SANDBOX + help + Enable support for the interconnect sandbox drivers. + +endif + endmenu diff --git a/drivers/interconnect/Makefile b/drivers/interconnect/Makefile index 1f276e98051..04b18589b7f 100644 --- a/drivers/interconnect/Makefile +++ b/drivers/interconnect/Makefile @@ -4,3 +4,4 @@ # obj-$(CONFIG_$(PHASE_)INTERCONNECT) += interconnect-uclass.o +obj-$(CONFIG_$(PHASE_)INTERCONNECT_SANDBOX) += sandbox-interconnect.o sandbox-interconnect-test.o diff --git a/drivers/interconnect/sandbox-interconnect-test.c b/drivers/interconnect/sandbox-interconnect-test.c new file mode 100644 index 00000000000..ff5f327f6da --- /dev/null +++ b/drivers/interconnect/sandbox-interconnect-test.c @@ -0,0 +1,89 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2025 Linaro Limited + */ + +#include +#include +#include +#include +#include + +struct sandbox_interconnect_test { + struct icc_path *path; +}; + +int sandbox_interconnect_test_get(struct udevice *dev, char *name) +{ + struct sandbox_interconnect_test *priv = dev_get_priv(dev); + + priv->path = of_icc_get(dev, name); + if (IS_ERR(priv->path)) + return PTR_ERR(priv->path); + + if (!priv->path) + return -ENOSYS; + + return 0; +} + +int sandbox_interconnect_test_get_index(struct udevice *dev, int index) +{ + struct sandbox_interconnect_test *priv = dev_get_priv(dev); + + priv->path = of_icc_get_by_index(dev, index); + if (IS_ERR(priv->path)) + return PTR_ERR(priv->path); + + if (!priv->path) + return -ENOSYS; + + return 0; +} + +int sandbox_interconnect_test_enable(struct udevice *dev) +{ + struct sandbox_interconnect_test *priv = dev_get_priv(dev); + + return icc_enable(priv->path); +} + +int sandbox_interconnect_test_disable(struct udevice *dev) +{ + struct sandbox_interconnect_test *priv = dev_get_priv(dev); + + return icc_disable(priv->path); +} + +int sandbox_interconnect_test_set_bw(struct udevice *dev, u32 avg_bw, u32 peak_bw) +{ + struct sandbox_interconnect_test *priv = dev_get_priv(dev); + + return icc_set_bw(priv->path, avg_bw, peak_bw); +} + +int sandbox_interconnect_test_put(struct udevice *dev) +{ + struct sandbox_interconnect_test *priv = dev_get_priv(dev); + int ret; + + ret = icc_put(priv->path); + if (ret) + return ret; + + priv->path = NULL; + + return 0; +} + +static const struct udevice_id sandbox_interconnect_test_ids[] = { + { .compatible = "sandbox,interconnect-test" }, + { } +}; + +U_BOOT_DRIVER(sandbox_interconnect_test) = { + .name = "sandbox_interconnect_test", + .id = UCLASS_MISC, + .of_match = sandbox_interconnect_test_ids, + .priv_auto = sizeof(struct sandbox_interconnect_test), +}; diff --git a/drivers/interconnect/sandbox-interconnect.c b/drivers/interconnect/sandbox-interconnect.c new file mode 100644 index 00000000000..0fc0e3e0d49 --- /dev/null +++ b/drivers/interconnect/sandbox-interconnect.c @@ -0,0 +1,303 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2025 Linaro Limited + */ + +#include +#include +#include +#include +#include +#include +#include + +#define MAX_LINKS 2 + +struct sandbox_interconnect_node { + const char *name; + unsigned int num_links; + struct sandbox_interconnect_node *links[MAX_LINKS]; + u64 avg_bw; + u64 peak_bw; +}; + +struct sandbox_interconnect_data { + struct sandbox_interconnect_node **nodes; + const unsigned int num_nodes; +}; + +struct sandbox_interconnect_provider { + struct udevice *dev; + struct sandbox_interconnect_data *data; + u64 avg; + u64 peak; +}; + +/* + * Node graph: + * ______________________________ + * [ NODE0 ]--\ / \ /-->[ NODE3 ] + * |-->| NODE2_SLAVE --> NODE2_MASTER |--| + * [ NODE1 ]--/ \______________________________/ \-->[ NODE4 ] + * + */ + +static struct sandbox_interconnect_node node2_slave; +static struct sandbox_interconnect_node node2_master; +static struct sandbox_interconnect_node node3; +static struct sandbox_interconnect_node node4; + +static struct sandbox_interconnect_node node0 = { + .name = "node0", + .num_links = 1, + .links = { &node2_slave }, +}; + +static struct sandbox_interconnect_node node1 = { + .name = "node1", + .num_links = 1, + .links = { &node2_slave }, +}; + +static struct sandbox_interconnect_node node2_slave = { + .name = "node2_slave", + .num_links = 1, + .links = { &node2_master }, +}; + +static struct sandbox_interconnect_node node2_master = { + .name = "node2_master", + .num_links = 2, + .links = { &node3, &node4 }, +}; + +static struct sandbox_interconnect_node node3 = { + .name = "node3", +}; + +static struct sandbox_interconnect_node node4 = { + .name = "node4", +}; + +/* xlate mapping */ +static struct sandbox_interconnect_node *interconnect0_nodes[] = { + [0] = &node0, +}; + +static struct sandbox_interconnect_node *interconnect1_nodes[] = { + [0] = &node1, +}; + +static struct sandbox_interconnect_node *interconnect2_nodes[] = { + [0] = &node2_slave, + [1] = &node2_master, +}; + +static struct sandbox_interconnect_node *interconnect3_nodes[] = { + [0] = &node3, +}; + +static struct sandbox_interconnect_node *interconnect4_nodes[] = { + [0] = &node4, +}; + +static struct sandbox_interconnect_data interconnect0_data = { + .nodes = interconnect0_nodes, + .num_nodes = ARRAY_SIZE(interconnect0_nodes), +}; + +static struct sandbox_interconnect_data interconnect1_data = { + .nodes = interconnect1_nodes, + .num_nodes = ARRAY_SIZE(interconnect1_nodes), +}; + +static struct sandbox_interconnect_data interconnect2_data = { + .nodes = interconnect2_nodes, + .num_nodes = ARRAY_SIZE(interconnect2_nodes), +}; + +static struct sandbox_interconnect_data interconnect3_data = { + .nodes = interconnect3_nodes, + .num_nodes = ARRAY_SIZE(interconnect3_nodes), +}; + +static struct sandbox_interconnect_data interconnect4_data = { + .nodes = interconnect4_nodes, + .num_nodes = ARRAY_SIZE(interconnect4_nodes), +}; + +int sandbox_interconnect_get_bw(struct udevice *dev, u64 *avg, u64 *peak) +{ + struct sandbox_interconnect_provider *priv = dev_get_plat(dev); + + *avg = priv->avg; + *peak = priv->peak; + + return 0; +} + +static int sandbox_interconnect_links_aggregate(struct udevice *dev) +{ + struct sandbox_interconnect_provider *priv = dev_get_plat(dev); + u64 avg = 0, peak = 0; + int i; + + debug("(provider=%s)\n", dev->name); + + for (i = 0; i < priv->data->num_nodes; i++) { + struct sandbox_interconnect_node *sandbox_node = priv->data->nodes[i]; + + if (!sandbox_node) + continue; + + avg += sandbox_node->avg_bw; + peak = max_t(u32, sandbox_node->peak_bw, peak); + } + + priv->avg = avg / priv->data->num_nodes; + priv->peak = peak; + + debug("(provider=%s,avg=%llu peak=%llu)\n", + dev->name, priv->avg, priv->peak); + + return 0; +} + +static int sandbox_interconnect_set(struct icc_node *src, struct icc_node *dst) +{ + struct icc_node *node; + + debug("(src=%s,dst=%s)\n", src->dev->name, dst->dev->name); + + if (!src) + node = dst; + else + node = src; + + return sandbox_interconnect_links_aggregate(node->dev->parent); +} + +static int sandbox_interconnect_aggregate(struct icc_node *node, u32 tag, u32 avg_bw, + u32 peak_bw, u32 *agg_avg, u32 *agg_peak) +{ + struct sandbox_interconnect_node *sandbox_node = node->data; + + debug("(node=%s,tag=%d,avg=%u,peak=%u)\n", + node->dev->name, tag, avg_bw, peak_bw); + + sandbox_node->avg_bw += avg_bw; + sandbox_node->peak_bw = max_t(u32, sandbox_node->peak_bw, peak_bw); + + *agg_avg += avg_bw; + *agg_peak = max_t(u32, *agg_peak, peak_bw); + + debug("(node=%s,new avg=%llu,new peak=%llu)\n", + node->dev->name, sandbox_node->avg_bw, sandbox_node->peak_bw); + + return 0; +} + +static void sandbox_interconnect_pre_aggregate(struct icc_node *node) +{ + struct sandbox_interconnect_node *sandbox_node = node->data; + + debug("(node=%s)\n", node->dev->name); + + sandbox_node->avg_bw = 0; + sandbox_node->peak_bw = 0; +} + +static struct icc_node *sandbox_interconnect_xlate(struct udevice *dev, + const struct ofnode_phandle_args *spec) +{ + struct icc_provider *plat = dev_get_uclass_plat(dev); + unsigned int idx = spec->args[0]; + + debug("(dev=%s)\n", dev->name); + + if (idx >= plat->xlate_num_nodes) { + pr_err("%s: invalid index %u\n", __func__, idx); + return ERR_PTR(-EINVAL); + } + + return plat->xlate_nodes[idx]; +} + +static int sandbox_interconnect_bind(struct udevice *dev) +{ + struct sandbox_interconnect_provider *priv = dev_get_plat(dev); + struct icc_provider *plat = dev_get_uclass_plat(dev); + size_t i; + + debug("(dev=%s)\n", dev->name); + + priv->data = (struct sandbox_interconnect_data *)dev_get_driver_data(dev); + if (!priv->data) + return -EINVAL; + + plat->xlate_num_nodes = priv->data->num_nodes; + plat->xlate_nodes = calloc(sizeof(struct icc_node *), priv->data->num_nodes); + if (!plat->xlate_nodes) + return -ENOMEM; + + priv->dev = dev; + + for (i = 0; i < priv->data->num_nodes; i++) { + struct sandbox_interconnect_node *sandbox_node; + struct icc_node *node; + int j; + + sandbox_node = priv->data->nodes[i]; + if (!sandbox_node) + continue; + + node = icc_node_create(dev, (ulong)sandbox_node, + sandbox_node->name); + if (IS_ERR(node)) + return PTR_ERR(node); + + node->data = sandbox_node; + + for (j = 0; j < sandbox_node->num_links; ++j) + icc_link_create(node, (ulong)sandbox_node->links[j]); + + plat->xlate_nodes[i] = node; + } + + return 0; +} + +static int sandbox_interconnect_unbind(struct udevice *dev) +{ + struct icc_provider *plat = dev_get_uclass_plat(dev); + + free(plat->xlate_nodes); + + return 0; +} + +static const struct udevice_id sandbox_interconnect_ids[] = { + { .compatible = "sandbox,interconnect0", .data = (ulong)&interconnect0_data, }, + { .compatible = "sandbox,interconnect1", .data = (ulong)&interconnect1_data, }, + { .compatible = "sandbox,interconnect2", .data = (ulong)&interconnect2_data, }, + { .compatible = "sandbox,interconnect3", .data = (ulong)&interconnect3_data, }, + { .compatible = "sandbox,interconnect4", .data = (ulong)&interconnect4_data, }, + { } +}; + +static struct interconnect_ops sandbox_interconnect_ops = { + .of_xlate = sandbox_interconnect_xlate, + .set = sandbox_interconnect_set, + .pre_aggregate = sandbox_interconnect_pre_aggregate, + .aggregate = sandbox_interconnect_aggregate, +}; + +U_BOOT_DRIVER(sandbox_interconnect) = { + .name = "sandbox_interconnect", + .id = UCLASS_INTERCONNECT, + .of_match = sandbox_interconnect_ids, + .bind = sandbox_interconnect_bind, + .unbind = sandbox_interconnect_unbind, + .plat_auto = sizeof(struct sandbox_interconnect_provider), + .ops = &sandbox_interconnect_ops, +}; diff --git a/test/dm/Makefile b/test/dm/Makefile index a261b3fb4b7..771b703b737 100644 --- a/test/dm/Makefile +++ b/test/dm/Makefile @@ -57,6 +57,7 @@ obj-$(CONFIG_DM_FPGA) += fpga.o obj-$(CONFIG_FWU_MDATA_GPT_BLK) += fwu_mdata.o obj-$(CONFIG_SANDBOX) += host.o obj-$(CONFIG_DM_HWSPINLOCK) += hwspinlock.o +obj-$(CONFIG_INTERCONNECT) += interconnect.o obj-$(CONFIG_DM_I2C) += i2c.o obj-$(CONFIG_I3C) += i3c.o obj-$(CONFIG_SOUND) += i2s.o diff --git a/test/dm/interconnect.c b/test/dm/interconnect.c new file mode 100644 index 00000000000..e8c2eccd7b1 --- /dev/null +++ b/test/dm/interconnect.c @@ -0,0 +1,195 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2025 Linaro Limited + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +static int dm_test_interconnect(struct unit_test_state *uts) +{ + struct udevice *dev_interconnect_0, + *dev_interconnect_1, + *dev_interconnect_2, + *dev_interconnect_3, + *dev_interconnect_4; + struct udevice *dev_test_0, *dev_test_1, *dev; + u64 avg = 0, peak = 0; + + ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "interconnect-test-0", + &dev_test_0)); + ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "interconnect-test-1", + &dev_test_1)); + + ut_assertok(sandbox_interconnect_test_get_index(dev_test_0, 0)); + ut_assertok(sandbox_interconnect_test_get(dev_test_1, "icc-path")); + + ut_assertok(uclass_find_device_by_name(UCLASS_INTERCONNECT, + "interconnect-0", + &dev_interconnect_0)); + ut_assertok(uclass_find_device_by_name(UCLASS_INTERCONNECT, + "interconnect-1", + &dev_interconnect_1)); + ut_assertok(uclass_find_device_by_name(UCLASS_INTERCONNECT, + "interconnect-2", + &dev_interconnect_2)); + ut_assertok(uclass_find_device_by_name(UCLASS_INTERCONNECT, + "interconnect-3", + &dev_interconnect_3)); + ut_assertok(uclass_find_device_by_name(UCLASS_INTERCONNECT, + "interconnect-4", + &dev_interconnect_4)); + + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_0, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_1, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_2, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_3, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_4, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + + ut_assertok(sandbox_interconnect_test_set_bw(dev_test_0, 10000, 100000)); + + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_0, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_1, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_2, &avg, &peak)); + ut_asserteq(avg, 10000); ut_asserteq(peak, 100000); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_3, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_4, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + + ut_assertok(sandbox_interconnect_test_set_bw(dev_test_1, 20000, 200000)); + + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_0, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_1, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_2, &avg, &peak)); + ut_asserteq(avg, 30000); ut_asserteq(peak, 200000); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_3, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_4, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + + ut_assertok(sandbox_interconnect_test_disable(dev_test_0)); + + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_0, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_1, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_2, &avg, &peak)); + ut_asserteq(avg, 20000); ut_asserteq(peak, 200000); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_3, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_4, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + + ut_assertok(sandbox_interconnect_test_disable(dev_test_1)); + + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_0, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_1, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_2, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_3, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_4, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + + ut_assertok(sandbox_interconnect_test_enable(dev_test_0)); + + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_0, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_1, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_2, &avg, &peak)); + ut_asserteq(avg, 10000); ut_asserteq(peak, 100000); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_3, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_4, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + + ut_assertok(sandbox_interconnect_test_enable(dev_test_1)); + + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_0, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_1, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_2, &avg, &peak)); + ut_asserteq(avg, 30000); ut_asserteq(peak, 200000); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_3, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_4, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + + ut_asserteq(-EBUSY, device_remove(dev_interconnect_0, DM_REMOVE_NORMAL)); + ut_asserteq(-EBUSY, device_remove(dev_interconnect_1, DM_REMOVE_NORMAL)); + ut_asserteq(-EBUSY, device_remove(dev_interconnect_2, DM_REMOVE_NORMAL)); + ut_asserteq(-EBUSY, device_remove(dev_interconnect_3, DM_REMOVE_NORMAL)); + ut_asserteq(-EBUSY, device_remove(dev_interconnect_4, DM_REMOVE_NORMAL)); + + ut_assertok(sandbox_interconnect_test_put(dev_test_0)); + + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_0, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_1, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_2, &avg, &peak)); + ut_asserteq(avg, 20000); ut_asserteq(peak, 200000); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_3, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_4, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + + ut_assertok(sandbox_interconnect_test_put(dev_test_1)); + + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_0, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_1, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_2, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_3, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + ut_assertok(sandbox_interconnect_get_bw(dev_interconnect_4, &avg, &peak)); + ut_asserteq(avg, 0); ut_asserteq(peak, 0); + + ut_asserteq(-ENOENT, sandbox_interconnect_test_get_index(dev_test_0, 1)); + ut_asserteq(-ENOENT, sandbox_interconnect_test_get_index(dev_test_1, 1)); + ut_asserteq(-ENODATA, sandbox_interconnect_test_get(dev_test_1, "pwet")); + + ut_assertok(device_remove(dev_interconnect_0, DM_REMOVE_NORMAL)); + ut_assertok(device_remove(dev_interconnect_1, DM_REMOVE_NORMAL)); + ut_assertok(device_remove(dev_interconnect_2, DM_REMOVE_NORMAL)); + ut_assertok(device_remove(dev_interconnect_3, DM_REMOVE_NORMAL)); + ut_assertok(device_remove(dev_interconnect_4, DM_REMOVE_NORMAL)); + + ut_assertok(device_unbind(dev_interconnect_0)); + ut_assertok(device_unbind(dev_interconnect_1)); + ut_assertok(device_unbind(dev_interconnect_2)); + ut_assertok(device_unbind(dev_interconnect_3)); + ut_assertok(device_unbind(dev_interconnect_4)); + + uclass_find_first_device(UCLASS_INTERCONNECT, &dev); + ut_assert(!dev); + + uclass_find_first_device(UCLASS_ICC_NODE, &dev); + ut_assert(!dev); + + return 0; +} + +DM_TEST(dm_test_interconnect, UTF_SCAN_FDT);