[PATCH 2/5] sandbox: scmi: test against a single scmi agent
Patrick DELAUNAY
patrick.delaunay at foss.st.com
Fri Feb 11 14:46:35 CET 2022
Hi Etienne,
On 2/11/22 13:07, Etienne Carriere wrote:
> As per DT bindings since Linux kernel v5.14, the device tree can define
> only 1 SCMI agent node that is named scmi [1]. As a consequence, change
> implementation of the SCMI driver test through sandbox architecture to
> reflect that.
>
> This change updates sandbox test DT and sandbox SCMI driver accordingly
> since all these are impacted.
>
> Cc: Simon Glass <sjg at chromium.org>
> Signed-off-by: Etienne Carriere <etienne.carriere at linaro.org>
> ---
> arch/sandbox/dts/test.dts | 37 ++--
> arch/sandbox/include/asm/scmi_test.h | 12 +-
> drivers/firmware/scmi/sandbox-scmi_agent.c | 167 ++++++-------------
> drivers/firmware/scmi/sandbox-scmi_devices.c | 4 +-
> test/dm/scmi.c | 117 +++++++------
> 5 files changed, 129 insertions(+), 208 deletions(-)
>
> diff --git a/arch/sandbox/dts/test.dts b/arch/sandbox/dts/test.dts
> index 48ca3e1e47..30874b038b 100644
> --- a/arch/sandbox/dts/test.dts
> +++ b/arch/sandbox/dts/test.dts
> @@ -574,17 +574,21 @@
> compatible = "sandbox,firmware";
> };
>
> - sandbox-scmi-agent at 0 {
> + scmi {
> compatible = "sandbox,scmi-agent";
> #address-cells = <1>;
> #size-cells = <0>;
>
> - clk_scmi0: protocol at 14 {
> + protocol at 10 {
> + reg = <0x10>;
> + };
> +
> + clk_scmi: protocol at 14 {
> reg = <0x14>;
> #clock-cells = <1>;
> };
>
> - reset_scmi0: protocol at 16 {
> + reset_scmi: protocol at 16 {
> reg = <0x16>;
> #reset-cells = <1>;
> };
> @@ -596,13 +600,13 @@
> #address-cells = <1>;
> #size-cells = <0>;
>
> - regul0_scmi0: reg at 0 {
> + regul0_scmi: reg at 0 {
> reg = <0>;
> regulator-name = "sandbox-voltd0";
> regulator-min-microvolt = <1100000>;
> regulator-max-microvolt = <3300000>;
> };
> - regul1_scmi0: reg at 1 {
> + regul1_scmi: reg at 1 {
> reg = <0x1>;
> regulator-name = "sandbox-voltd1";
> regulator-min-microvolt = <1800000>;
> @@ -610,21 +614,6 @@
> };
> };
> };
> -
> - sandbox-scmi-agent at 1 {
> - compatible = "sandbox,scmi-agent";
> - #address-cells = <1>;
> - #size-cells = <0>;
> -
> - clk_scmi1: protocol at 14 {
> - reg = <0x14>;
> - #clock-cells = <1>;
> - };
> -
> - protocol at 10 {
> - reg = <0x10>;
> - };
> - };
> };
>
> pinctrl-gpio {
> @@ -1403,10 +1392,10 @@
>
> sandbox_scmi {
> compatible = "sandbox,scmi-devices";
> - clocks = <&clk_scmi0 7>, <&clk_scmi0 3>, <&clk_scmi1 1>;
> - resets = <&reset_scmi0 3>;
> - regul0-supply = <®ul0_scmi0>;
> - regul1-supply = <®ul1_scmi0>;
> + clocks = <&clk_scmi 7>, <&clk_scmi 3>;
> + resets = <&reset_scmi 3>;
> + regul0-supply = <®ul0_scmi>;
> + regul1-supply = <®ul1_scmi>;
> };
>
> pinctrl {
> diff --git a/arch/sandbox/include/asm/scmi_test.h b/arch/sandbox/include/asm/scmi_test.h
> index 2930e686d7..054be5f14e 100644
> --- a/arch/sandbox/include/asm/scmi_test.h
> +++ b/arch/sandbox/include/asm/scmi_test.h
> @@ -46,7 +46,6 @@ struct sandbox_scmi_voltd {
>
> /**
> * struct sandbox_scmi_agent - Simulated SCMI service seen by SCMI agent
> - * @idx: Identifier for the SCMI agent, its index
> * @clk: Simulated clocks
> * @clk_count: Simulated clocks array size
> * @reset: Simulated reset domains
> @@ -55,7 +54,6 @@ struct sandbox_scmi_voltd {
> * @voltd_count: Simulated voltage domains array size
> */
> struct sandbox_scmi_agent {
> - uint idx;
> struct sandbox_scmi_clk *clk;
> size_t clk_count;
> struct sandbox_scmi_reset *reset;
> @@ -66,12 +64,10 @@ struct sandbox_scmi_agent {
>
> /**
> * struct sandbox_scmi_service - Reference to simutaed SCMI agents/services
> - * @agent: Pointer to SCMI sandbox agent pointers array
> - * @agent_count: Number of emulated agents exposed in array @agent.
> + * @agent: Pointer to SCMI sandbox agent or NULL if not probed
> */
> struct sandbox_scmi_service {
> - struct sandbox_scmi_agent **agent;
> - size_t agent_count;
> + struct sandbox_scmi_agent *agent;
> };
>
> /**
> @@ -94,13 +90,13 @@ struct sandbox_scmi_devices {
>
> #ifdef CONFIG_SCMI_FIRMWARE
> /**
> - * sandbox_scmi_service_context - Get the simulated SCMI services context
> + * sandbox_scmi_service_ctx - Get the simulated SCMI services context
> * @return: Reference to backend simulated resources state
> */
> struct sandbox_scmi_service *sandbox_scmi_service_ctx(void);
>
> /**
> - * sandbox_scmi_devices_get_ref - Get references to devices accessed through SCMI
> + * sandbox_scmi_devices_ctx - Get references to devices accessed through SCMI
> * @dev: Reference to the test device used get test resources
> * @return: Reference to the devices probed by the SCMI test
> */
> diff --git a/drivers/firmware/scmi/sandbox-scmi_agent.c b/drivers/firmware/scmi/sandbox-scmi_agent.c
> index 4b968205c2..4fbff3e7ed 100644
> --- a/drivers/firmware/scmi/sandbox-scmi_agent.c
> +++ b/drivers/firmware/scmi/sandbox-scmi_agent.c
> @@ -19,51 +19,35 @@
> * The sandbox SCMI agent driver simulates to some extend a SCMI message
> * processing. It simulates few of the SCMI services for some of the
> * SCMI protocols embedded in U-Boot. Currently:
> - * - SCMI clock protocol: emulate 2 agents each exposing few clocks
> - * - SCMI reset protocol: emulate 1 agent exposing a reset controller
> - * - SCMI voltage domain protocol: emulate 1 agent exposing 2 regulators
> + * - SCMI clock protocol emulates an agent exposing 2 clocks
> + * - SCMI reset protocol emulates an agent exposing a reset controller
> + * - SCMI voltage domain protocol emulates an agent exposing 2 regulators
> *
> - * Agent #0 simulates 2 clocks, 1 reset domain and 1 voltage domain.
> - * See IDs in scmi0_clk[]/scmi0_reset[] and "sandbox-scmi-agent at 0" in test.dts.
> - *
> - * Agent #1 simulates 1 clock.
> - * See IDs in scmi1_clk[] and "sandbox-scmi-agent at 1" in test.dts.
> + * As per DT bindings, the device node name shall be scmi.
> *
> * All clocks and regulators are default disabled and reset controller down.
> *
> - * This Driver exports sandbox_scmi_service_ctx() for the test sequence to
> + * This driver exports sandbox_scmi_service_ctx() for the test sequence to
> * get the state of the simulated services (clock state, rate, ...) and
> * check back-end device state reflects the request send through the
> * various uclass devices, as clocks and reset controllers.
> */
>
> -#define SANDBOX_SCMI_AGENT_COUNT 2
> -
> -static struct sandbox_scmi_clk scmi0_clk[] = {
> +static struct sandbox_scmi_clk scmi_clk[] = {
> { .id = 7, .rate = 1000 },
> { .id = 3, .rate = 333 },
> };
>
> -static struct sandbox_scmi_reset scmi0_reset[] = {
> +static struct sandbox_scmi_reset scmi_reset[] = {
> { .id = 3 },
> };
>
> -static struct sandbox_scmi_voltd scmi0_voltd[] = {
> +static struct sandbox_scmi_voltd scmi_voltd[] = {
> { .id = 0, .voltage_uv = 3300000 },
> { .id = 1, .voltage_uv = 1800000 },
> };
>
> -static struct sandbox_scmi_clk scmi1_clk[] = {
> - { .id = 1, .rate = 44 },
> -};
> -
> -/* The list saves to simulted end devices references for test purpose */
> -struct sandbox_scmi_agent *sandbox_scmi_agent_list[SANDBOX_SCMI_AGENT_COUNT];
> -
> -static struct sandbox_scmi_service sandbox_scmi_service_state = {
> - .agent = sandbox_scmi_agent_list,
> - .agent_count = SANDBOX_SCMI_AGENT_COUNT,
> -};
> +static struct sandbox_scmi_service sandbox_scmi_service_state;
>
> struct sandbox_scmi_service *sandbox_scmi_service_ctx(void)
> {
> @@ -74,9 +58,8 @@ static void debug_print_agent_state(struct udevice *dev, char *str)
> {
> struct sandbox_scmi_agent *agent = dev_get_priv(dev);
>
> - dev_dbg(dev, "Dump sandbox_scmi_agent %u: %s\n", agent->idx, str);
> - dev_dbg(dev, " scmi%u_clk (%zu): %d/%ld, %d/%ld, %d/%ld, ...\n",
> - agent->idx,
> + dev_dbg(dev, "Dump sandbox_scmi_agent: %s\n", str);
> + dev_dbg(dev, " scmi_clk (%zu): %d/%ld, %d/%ld, %d/%ld, ...\n",
> agent->clk_count,
> agent->clk_count ? agent->clk[0].enabled : -1,
> agent->clk_count ? agent->clk[0].rate : -1,
> @@ -84,13 +67,11 @@ static void debug_print_agent_state(struct udevice *dev, char *str)
> agent->clk_count > 1 ? agent->clk[1].rate : -1,
> agent->clk_count > 2 ? agent->clk[2].enabled : -1,
> agent->clk_count > 2 ? agent->clk[2].rate : -1);
> - dev_dbg(dev, " scmi%u_reset (%zu): %d, %d, ...\n",
> - agent->idx,
> + dev_dbg(dev, " scmi_reset (%zu): %d, %d, ...\n",
> agent->reset_count,
> agent->reset_count ? agent->reset[0].asserted : -1,
> agent->reset_count > 1 ? agent->reset[1].asserted : -1);
> - dev_dbg(dev, " scmi%u_voltd (%zu): %u/%d, %u/%d, ...\n",
> - agent->idx,
> + dev_dbg(dev, " scmi_voltd (%zu): %u/%d, %u/%d, ...\n",
> agent->voltd_count,
> agent->voltd_count ? agent->voltd[0].enabled : -1,
> agent->voltd_count ? agent->voltd[0].voltage_uv : -1,
> @@ -98,56 +79,35 @@ static void debug_print_agent_state(struct udevice *dev, char *str)
> agent->voltd_count ? agent->voltd[1].voltage_uv : -1);
> };
>
> -static struct sandbox_scmi_clk *get_scmi_clk_state(uint agent_id, uint clock_id)
> +static struct sandbox_scmi_clk *get_scmi_clk_state(uint clock_id)
> {
> - struct sandbox_scmi_clk *target = NULL;
> - size_t target_count = 0;
> size_t n;
>
> - switch (agent_id) {
> - case 0:
> - target = scmi0_clk;
> - target_count = ARRAY_SIZE(scmi0_clk);
> - break;
> - case 1:
> - target = scmi1_clk;
> - target_count = ARRAY_SIZE(scmi1_clk);
> - break;
> - default:
> - return NULL;
> - }
> -
> - for (n = 0; n < target_count; n++)
> - if (target[n].id == clock_id)
> - return target + n;
> + for (n = 0; n < ARRAY_SIZE(scmi_clk); n++)
> + if (scmi_clk[n].id == clock_id)
> + return scmi_clk + n;
>
> return NULL;
> }
>
> -static struct sandbox_scmi_reset *get_scmi_reset_state(uint agent_id,
> - uint reset_id)
> +static struct sandbox_scmi_reset *get_scmi_reset_state(uint reset_id)
> {
> size_t n;
>
> - if (agent_id == 0) {
> - for (n = 0; n < ARRAY_SIZE(scmi0_reset); n++)
> - if (scmi0_reset[n].id == reset_id)
> - return scmi0_reset + n;
> - }
> + for (n = 0; n < ARRAY_SIZE(scmi_reset); n++)
> + if (scmi_reset[n].id == reset_id)
> + return scmi_reset + n;
>
> return NULL;
> }
>
> -static struct sandbox_scmi_voltd *get_scmi_voltd_state(uint agent_id,
> - uint domain_id)
> +static struct sandbox_scmi_voltd *get_scmi_voltd_state(uint domain_id)
> {
> size_t n;
>
> - if (agent_id == 0) {
> - for (n = 0; n < ARRAY_SIZE(scmi0_voltd); n++)
> - if (scmi0_voltd[n].id == domain_id)
> - return scmi0_voltd + n;
> - }
> + for (n = 0; n < ARRAY_SIZE(scmi_voltd); n++)
> + if (scmi_voltd[n].id == domain_id)
> + return scmi_voltd + n;
>
> return NULL;
> }
> @@ -159,7 +119,6 @@ static struct sandbox_scmi_voltd *get_scmi_voltd_state(uint agent_id,
> static int sandbox_scmi_clock_rate_set(struct udevice *dev,
> struct scmi_msg *msg)
> {
> - struct sandbox_scmi_agent *agent = dev_get_priv(dev);
> struct scmi_clk_rate_set_in *in = NULL;
> struct scmi_clk_rate_set_out *out = NULL;
> struct sandbox_scmi_clk *clk_state = NULL;
> @@ -171,7 +130,7 @@ static int sandbox_scmi_clock_rate_set(struct udevice *dev,
> in = (struct scmi_clk_rate_set_in *)msg->in_msg;
> out = (struct scmi_clk_rate_set_out *)msg->out_msg;
>
> - clk_state = get_scmi_clk_state(agent->idx, in->clock_id);
> + clk_state = get_scmi_clk_state(in->clock_id);
> if (!clk_state) {
> dev_err(dev, "Unexpected clock ID %u\n", in->clock_id);
>
> @@ -190,7 +149,6 @@ static int sandbox_scmi_clock_rate_set(struct udevice *dev,
> static int sandbox_scmi_clock_rate_get(struct udevice *dev,
> struct scmi_msg *msg)
> {
> - struct sandbox_scmi_agent *agent = dev_get_priv(dev);
> struct scmi_clk_rate_get_in *in = NULL;
> struct scmi_clk_rate_get_out *out = NULL;
> struct sandbox_scmi_clk *clk_state = NULL;
> @@ -202,7 +160,7 @@ static int sandbox_scmi_clock_rate_get(struct udevice *dev,
> in = (struct scmi_clk_rate_get_in *)msg->in_msg;
> out = (struct scmi_clk_rate_get_out *)msg->out_msg;
>
> - clk_state = get_scmi_clk_state(agent->idx, in->clock_id);
> + clk_state = get_scmi_clk_state(in->clock_id);
> if (!clk_state) {
> dev_err(dev, "Unexpected clock ID %u\n", in->clock_id);
>
> @@ -219,7 +177,6 @@ static int sandbox_scmi_clock_rate_get(struct udevice *dev,
>
> static int sandbox_scmi_clock_gate(struct udevice *dev, struct scmi_msg *msg)
> {
> - struct sandbox_scmi_agent *agent = dev_get_priv(dev);
> struct scmi_clk_state_in *in = NULL;
> struct scmi_clk_state_out *out = NULL;
> struct sandbox_scmi_clk *clk_state = NULL;
> @@ -231,7 +188,7 @@ static int sandbox_scmi_clock_gate(struct udevice *dev, struct scmi_msg *msg)
> in = (struct scmi_clk_state_in *)msg->in_msg;
> out = (struct scmi_clk_state_out *)msg->out_msg;
>
> - clk_state = get_scmi_clk_state(agent->idx, in->clock_id);
> + clk_state = get_scmi_clk_state(in->clock_id);
> if (!clk_state) {
> dev_err(dev, "Unexpected clock ID %u\n", in->clock_id);
>
> @@ -249,7 +206,6 @@ static int sandbox_scmi_clock_gate(struct udevice *dev, struct scmi_msg *msg)
>
> static int sandbox_scmi_rd_attribs(struct udevice *dev, struct scmi_msg *msg)
> {
> - struct sandbox_scmi_agent *agent = dev_get_priv(dev);
> struct scmi_rd_attr_in *in = NULL;
> struct scmi_rd_attr_out *out = NULL;
> struct sandbox_scmi_reset *reset_state = NULL;
> @@ -261,7 +217,7 @@ static int sandbox_scmi_rd_attribs(struct udevice *dev, struct scmi_msg *msg)
> in = (struct scmi_rd_attr_in *)msg->in_msg;
> out = (struct scmi_rd_attr_out *)msg->out_msg;
>
> - reset_state = get_scmi_reset_state(agent->idx, in->domain_id);
> + reset_state = get_scmi_reset_state(in->domain_id);
> if (!reset_state) {
> dev_err(dev, "Unexpected reset domain ID %u\n", in->domain_id);
>
> @@ -278,7 +234,6 @@ static int sandbox_scmi_rd_attribs(struct udevice *dev, struct scmi_msg *msg)
>
> static int sandbox_scmi_rd_reset(struct udevice *dev, struct scmi_msg *msg)
> {
> - struct sandbox_scmi_agent *agent = dev_get_priv(dev);
> struct scmi_rd_reset_in *in = NULL;
> struct scmi_rd_reset_out *out = NULL;
> struct sandbox_scmi_reset *reset_state = NULL;
> @@ -290,7 +245,7 @@ static int sandbox_scmi_rd_reset(struct udevice *dev, struct scmi_msg *msg)
> in = (struct scmi_rd_reset_in *)msg->in_msg;
> out = (struct scmi_rd_reset_out *)msg->out_msg;
>
> - reset_state = get_scmi_reset_state(agent->idx, in->domain_id);
> + reset_state = get_scmi_reset_state(in->domain_id);
> if (!reset_state) {
> dev_err(dev, "Unexpected reset domain ID %u\n", in->domain_id);
>
> @@ -321,7 +276,6 @@ static int sandbox_scmi_rd_reset(struct udevice *dev, struct scmi_msg *msg)
>
> static int sandbox_scmi_voltd_attribs(struct udevice *dev, struct scmi_msg *msg)
> {
> - struct sandbox_scmi_agent *agent = dev_get_priv(dev);
> struct scmi_voltd_attr_in *in = NULL;
> struct scmi_voltd_attr_out *out = NULL;
> struct sandbox_scmi_voltd *voltd_state = NULL;
> @@ -333,7 +287,7 @@ static int sandbox_scmi_voltd_attribs(struct udevice *dev, struct scmi_msg *msg)
> in = (struct scmi_voltd_attr_in *)msg->in_msg;
> out = (struct scmi_voltd_attr_out *)msg->out_msg;
>
> - voltd_state = get_scmi_voltd_state(agent->idx, in->domain_id);
> + voltd_state = get_scmi_voltd_state(in->domain_id);
> if (!voltd_state) {
> dev_err(dev, "Unexpected domain ID %u\n", in->domain_id);
>
> @@ -351,7 +305,6 @@ static int sandbox_scmi_voltd_attribs(struct udevice *dev, struct scmi_msg *msg)
> static int sandbox_scmi_voltd_config_set(struct udevice *dev,
> struct scmi_msg *msg)
> {
> - struct sandbox_scmi_agent *agent = dev_get_priv(dev);
> struct scmi_voltd_config_set_in *in = NULL;
> struct scmi_voltd_config_set_out *out = NULL;
> struct sandbox_scmi_voltd *voltd_state = NULL;
> @@ -363,7 +316,7 @@ static int sandbox_scmi_voltd_config_set(struct udevice *dev,
> in = (struct scmi_voltd_config_set_in *)msg->in_msg;
> out = (struct scmi_voltd_config_set_out *)msg->out_msg;
>
> - voltd_state = get_scmi_voltd_state(agent->idx, in->domain_id);
> + voltd_state = get_scmi_voltd_state(in->domain_id);
> if (!voltd_state) {
> dev_err(dev, "Unexpected domain ID %u\n", in->domain_id);
>
> @@ -388,7 +341,6 @@ static int sandbox_scmi_voltd_config_set(struct udevice *dev,
> static int sandbox_scmi_voltd_config_get(struct udevice *dev,
> struct scmi_msg *msg)
> {
> - struct sandbox_scmi_agent *agent = dev_get_priv(dev);
> struct scmi_voltd_config_get_in *in = NULL;
> struct scmi_voltd_config_get_out *out = NULL;
> struct sandbox_scmi_voltd *voltd_state = NULL;
> @@ -400,7 +352,7 @@ static int sandbox_scmi_voltd_config_get(struct udevice *dev,
> in = (struct scmi_voltd_config_get_in *)msg->in_msg;
> out = (struct scmi_voltd_config_get_out *)msg->out_msg;
>
> - voltd_state = get_scmi_voltd_state(agent->idx, in->domain_id);
> + voltd_state = get_scmi_voltd_state(in->domain_id);
> if (!voltd_state) {
> dev_err(dev, "Unexpected domain ID %u\n", in->domain_id);
>
> @@ -420,7 +372,6 @@ static int sandbox_scmi_voltd_config_get(struct udevice *dev,
> static int sandbox_scmi_voltd_level_set(struct udevice *dev,
> struct scmi_msg *msg)
> {
> - struct sandbox_scmi_agent *agent = dev_get_priv(dev);
> struct scmi_voltd_level_set_in *in = NULL;
> struct scmi_voltd_level_set_out *out = NULL;
> struct sandbox_scmi_voltd *voltd_state = NULL;
> @@ -432,7 +383,7 @@ static int sandbox_scmi_voltd_level_set(struct udevice *dev,
> in = (struct scmi_voltd_level_set_in *)msg->in_msg;
> out = (struct scmi_voltd_level_set_out *)msg->out_msg;
>
> - voltd_state = get_scmi_voltd_state(agent->idx, in->domain_id);
> + voltd_state = get_scmi_voltd_state(in->domain_id);
> if (!voltd_state) {
> dev_err(dev, "Unexpected domain ID %u\n", in->domain_id);
>
> @@ -448,7 +399,6 @@ static int sandbox_scmi_voltd_level_set(struct udevice *dev,
> static int sandbox_scmi_voltd_level_get(struct udevice *dev,
> struct scmi_msg *msg)
> {
> - struct sandbox_scmi_agent *agent = dev_get_priv(dev);
> struct scmi_voltd_level_get_in *in = NULL;
> struct scmi_voltd_level_get_out *out = NULL;
> struct sandbox_scmi_voltd *voltd_state = NULL;
> @@ -460,7 +410,7 @@ static int sandbox_scmi_voltd_level_get(struct udevice *dev,
> in = (struct scmi_voltd_level_get_in *)msg->in_msg;
> out = (struct scmi_voltd_level_get_out *)msg->out_msg;
>
> - voltd_state = get_scmi_voltd_state(agent->idx, in->domain_id);
> + voltd_state = get_scmi_voltd_state(in->domain_id);
> if (!voltd_state) {
> dev_err(dev, "Unexpected domain ID %u\n", in->domain_id);
>
> @@ -541,52 +491,41 @@ static int sandbox_scmi_test_remove(struct udevice *dev)
> {
> struct sandbox_scmi_agent *agent = dev_get_priv(dev);
>
> + if (agent != sandbox_scmi_service_ctx()->agent)
> + return -EINVAL;
> +
> debug_print_agent_state(dev, "removed");
>
> /* We only need to dereference the agent in the context */
> - sandbox_scmi_service_ctx()->agent[agent->idx] = NULL;
> + sandbox_scmi_service_ctx()->agent = NULL;
>
> return 0;
> }
>
> static int sandbox_scmi_test_probe(struct udevice *dev)
> {
> - static const char basename[] = "sandbox-scmi-agent@";
> + static const char basename[] = "scmi";
> struct sandbox_scmi_agent *agent = dev_get_priv(dev);
> - const size_t basename_size = sizeof(basename) - 1;
>
> - if (strncmp(basename, dev->name, basename_size))
> + if (strcmp(basename, dev->name))
> return -ENOENT;
This check is still needed ?
you test in drivier if device is correct
- static const char basename[] = "scmi";
....
- if (strcmp(basename, dev->name))
- return -ENOENT;
>
> - switch (dev->name[basename_size]) {
> - case '0':
> - *agent = (struct sandbox_scmi_agent){
> - .idx = 0,
> - .clk = scmi0_clk,
> - .clk_count = ARRAY_SIZE(scmi0_clk),
> - .reset = scmi0_reset,
> - .reset_count = ARRAY_SIZE(scmi0_reset),
> - .voltd = scmi0_voltd,
> - .voltd_count = ARRAY_SIZE(scmi0_voltd),
> - };
> - break;
> - case '1':
> - *agent = (struct sandbox_scmi_agent){
> - .idx = 1,
> - .clk = scmi1_clk,
> - .clk_count = ARRAY_SIZE(scmi1_clk),
> - };
> - break;
> - default:
> - dev_err(dev, "%s(): Unexpected agent ID %s\n",
> - __func__, dev->name + basename_size);
> - return -ENOENT;
> - }
> + if (sandbox_scmi_service_ctx()->agent)
> + return -EINVAL;
> +
> + *agent = (struct sandbox_scmi_agent){
> + .clk = scmi_clk,
> + .clk_count = ARRAY_SIZE(scmi_clk),
> + .reset = scmi_reset,
> + .reset_count = ARRAY_SIZE(scmi_reset),
> + .voltd = scmi_voltd,
> + .voltd_count = ARRAY_SIZE(scmi_voltd),
> + };
>
> debug_print_agent_state(dev, "probed");
>
> /* Save reference for tests purpose */
> - sandbox_scmi_service_ctx()->agent[agent->idx] = agent;
> + sandbox_scmi_service_ctx()->agent = agent;
>
> return 0;
> };
> diff --git a/drivers/firmware/scmi/sandbox-scmi_devices.c b/drivers/firmware/scmi/sandbox-scmi_devices.c
> index 66a6792881..9baeb469ec 100644
> --- a/drivers/firmware/scmi/sandbox-scmi_devices.c
> +++ b/drivers/firmware/scmi/sandbox-scmi_devices.c
> @@ -23,7 +23,7 @@
> * and reset controllers.
> */
>
> -#define SCMI_TEST_DEVICES_CLK_COUNT 3
> +#define SCMI_TEST_DEVICES_CLK_COUNT 2
> #define SCMI_TEST_DEVICES_RD_COUNT 1
> #define SCMI_TEST_DEVICES_VOLTD_COUNT 2
>
> @@ -135,7 +135,7 @@ U_BOOT_DRIVER(sandbox_scmi_devices) = {
> .name = "sandbox-scmi_devices",
> .id = UCLASS_MISC,
> .of_match = sandbox_scmi_devices_ids,
> - .priv_auto = sizeof(struct sandbox_scmi_device_priv),
> + .priv_auto = sizeof(struct sandbox_scmi_device_priv),
> .remove = sandbox_scmi_devices_remove,
> .probe = sandbox_scmi_devices_probe,
> };
> diff --git a/test/dm/scmi.c b/test/dm/scmi.c
> index c938e6d4fc..2f19b99d7c 100644
> --- a/test/dm/scmi.c
> +++ b/test/dm/scmi.c
> @@ -5,7 +5,7 @@
> * Tests scmi_agent uclass and the SCMI drivers implemented in other
> * uclass devices probe when a SCMI server exposes resources.
> *
> - * Note in test.dts the protocol at 10 node in agent 1. Protocol 0x10 is not
> + * Note in test.dts the protocol at 10 node in scmi node. Protocol 0x10 is not
> * implemented in U-Boot SCMI components but the implementation is exepected
> * to not complain on unknown protocol IDs, as long as it is not used. Note
> * in test.dts tests that SCMI drivers probing does not fail for such an
> @@ -28,8 +28,7 @@ static int ut_assert_scmi_state_preprobe(struct unit_test_state *uts)
> struct sandbox_scmi_service *scmi_ctx = sandbox_scmi_service_ctx();
>
> ut_assertnonnull(scmi_ctx);
> - if (scmi_ctx->agent_count)
> - ut_asserteq(2, scmi_ctx->agent_count);
> + ut_assertnull(scmi_ctx->agent);
>
> return 0;
> }
> @@ -39,35 +38,28 @@ static int ut_assert_scmi_state_postprobe(struct unit_test_state *uts,
> {
> struct sandbox_scmi_devices *scmi_devices;
> struct sandbox_scmi_service *scmi_ctx;
> - struct sandbox_scmi_agent *agent0;
> - struct sandbox_scmi_agent *agent1;
> + struct sandbox_scmi_agent *agent;
>
> /* Device references to check context against test sequence */
> scmi_devices = sandbox_scmi_devices_ctx(dev);
> -
> ut_assertnonnull(scmi_devices);
> - ut_asserteq(3, scmi_devices->clk_count);
> +
added line ?
> + ut_asserteq(2, scmi_devices->clk_count);
> ut_asserteq(1, scmi_devices->reset_count);
> ut_asserteq(2, scmi_devices->regul_count);
>
> /* State of the simulated SCMI server exposed */
> scmi_ctx = sandbox_scmi_service_ctx();
> - agent0 = scmi_ctx->agent[0];
> - agent1 = scmi_ctx->agent[1];
> -
> - ut_asserteq(2, scmi_ctx->agent_count);
> -
> - ut_assertnonnull(agent0);
> - ut_asserteq(2, agent0->clk_count);
> - ut_assertnonnull(agent0->clk);
> - ut_asserteq(1, agent0->reset_count);
> - ut_assertnonnull(agent0->reset);
> - ut_asserteq(2, agent0->voltd_count);
> - ut_assertnonnull(agent0->voltd);
> + ut_assertnonnull(scmi_ctx);
> + agent = scmi_ctx->agent;
> + ut_assertnonnull(agent);
>
line to remove
> - ut_assertnonnull(agent1);
> - ut_assertnonnull(agent1->clk);
> - ut_asserteq(1, agent1->clk_count);
> + ut_asserteq(2, agent->clk_count);
> + ut_assertnonnull(agent->clk);
> + ut_asserteq(1, agent->reset_count);
> + ut_assertnonnull(agent->reset);
> + ut_asserteq(2, agent->voltd_count);
> + ut_assertnonnull(agent->voltd);
>
> return 0;
> }
> @@ -118,9 +110,8 @@ static int dm_test_scmi_clocks(struct unit_test_state *uts)
> {
> struct sandbox_scmi_devices *scmi_devices;
> struct sandbox_scmi_service *scmi_ctx;
> - struct sandbox_scmi_agent *agent0;
> - struct sandbox_scmi_agent *agent1;
> - struct udevice *dev = NULL;
> + struct sandbox_scmi_agent *agent;
> + struct udevice *dev;
> int ret_dev;
> int ret;
>
> @@ -129,48 +120,46 @@ static int dm_test_scmi_clocks(struct unit_test_state *uts)
> return ret;
>
> scmi_devices = sandbox_scmi_devices_ctx(dev);
> + ut_assertnonnull(scmi_devices);
> +
> scmi_ctx = sandbox_scmi_service_ctx();
> - agent0 = scmi_ctx->agent[0];
> - agent1 = scmi_ctx->agent[1];
> + ut_assertnonnull(scmi_ctx);
> + agent = scmi_ctx->agent;
> + ut_assertnonnull(agent);
>
> /* Test SCMI clocks rate manipulation */
> ut_asserteq(1000, clk_get_rate(&scmi_devices->clk[0]));
> ut_asserteq(333, clk_get_rate(&scmi_devices->clk[1]));
> - ut_asserteq(44, clk_get_rate(&scmi_devices->clk[2]));
>
> ret_dev = clk_set_rate(&scmi_devices->clk[1], 1088);
> ut_assert(!ret_dev || ret_dev == 1088);
>
> - ut_asserteq(1000, agent0->clk[0].rate);
> - ut_asserteq(1088, agent0->clk[1].rate);
> - ut_asserteq(44, agent1->clk[0].rate);
> + ut_asserteq(1000, agent->clk[0].rate);
> + ut_asserteq(1088, agent->clk[1].rate);
>
> ut_asserteq(1000, clk_get_rate(&scmi_devices->clk[0]));
> ut_asserteq(1088, clk_get_rate(&scmi_devices->clk[1]));
> - ut_asserteq(44, clk_get_rate(&scmi_devices->clk[2]));
>
> /* restore original rate for further tests */
> ret_dev = clk_set_rate(&scmi_devices->clk[1], 333);
> ut_assert(!ret_dev || ret_dev == 333);
>
> /* Test SCMI clocks gating manipulation */
> - ut_assert(!agent0->clk[0].enabled);
> - ut_assert(!agent0->clk[1].enabled);
> - ut_assert(!agent1->clk[0].enabled);
> + ut_assert(!agent->clk[0].enabled);
> + ut_assert(!agent->clk[1].enabled);
> + ut_assert(!agent->clk[2].enabled);
>
> ut_asserteq(0, clk_enable(&scmi_devices->clk[1]));
> - ut_asserteq(0, clk_enable(&scmi_devices->clk[2]));
>
> - ut_assert(!agent0->clk[0].enabled);
> - ut_assert(agent0->clk[1].enabled);
> - ut_assert(agent1->clk[0].enabled);
> + ut_assert(!agent->clk[0].enabled);
> + ut_assert(agent->clk[1].enabled);
> + ut_assert(!agent->clk[2].enabled);
>
> ut_assertok(clk_disable(&scmi_devices->clk[1]));
> - ut_assertok(clk_disable(&scmi_devices->clk[2]));
>
> - ut_assert(!agent0->clk[0].enabled);
> - ut_assert(!agent0->clk[1].enabled);
> - ut_assert(!agent1->clk[0].enabled);
> + ut_assert(!agent->clk[0].enabled);
> + ut_assert(!agent->clk[1].enabled);
> + ut_assert(!agent->clk[2].enabled);
>
> return release_sandbox_scmi_test_devices(uts, dev);
> }
> @@ -180,7 +169,7 @@ static int dm_test_scmi_resets(struct unit_test_state *uts)
> {
> struct sandbox_scmi_devices *scmi_devices;
> struct sandbox_scmi_service *scmi_ctx;
> - struct sandbox_scmi_agent *agent0;
> + struct sandbox_scmi_agent *agent;
> struct udevice *dev = NULL;
> int ret;
>
> @@ -189,17 +178,21 @@ static int dm_test_scmi_resets(struct unit_test_state *uts)
> return ret;
>
> scmi_devices = sandbox_scmi_devices_ctx(dev);
> + ut_assertnonnull(scmi_devices);
> +
> scmi_ctx = sandbox_scmi_service_ctx();
> - agent0 = scmi_ctx->agent[0];
> + ut_assertnonnull(scmi_ctx);
> + agent = scmi_ctx->agent;
> + ut_assertnonnull(agent);
>
> /* Test SCMI resect controller manipulation */
> - ut_assert(!agent0->reset[0].asserted)
> + ut_assert(!agent->reset[0].asserted)
>
> ut_assertok(reset_assert(&scmi_devices->reset[0]));
> - ut_assert(agent0->reset[0].asserted)
> + ut_assert(agent->reset[0].asserted)
>
> ut_assertok(reset_deassert(&scmi_devices->reset[0]));
> - ut_assert(!agent0->reset[0].asserted);
> + ut_assert(!agent->reset[0].asserted);
>
> return release_sandbox_scmi_test_devices(uts, dev);
> }
> @@ -209,7 +202,7 @@ static int dm_test_scmi_voltage_domains(struct unit_test_state *uts)
> {
> struct sandbox_scmi_devices *scmi_devices;
> struct sandbox_scmi_service *scmi_ctx;
> - struct sandbox_scmi_agent *agent0;
> + struct sandbox_scmi_agent *agent;
> struct dm_regulator_uclass_plat *uc_pdata;
> struct udevice *dev;
> struct udevice *regul0_dev;
> @@ -217,8 +210,12 @@ static int dm_test_scmi_voltage_domains(struct unit_test_state *uts)
> ut_assertok(load_sandbox_scmi_test_devices(uts, &dev));
>
> scmi_devices = sandbox_scmi_devices_ctx(dev);
> + ut_assertnonnull(scmi_devices);
> +
> scmi_ctx = sandbox_scmi_service_ctx();
> - agent0 = scmi_ctx->agent[0];
> + ut_assertnonnull(scmi_ctx);
> + agent = scmi_ctx->agent;
> + ut_assertnonnull(agent);
>
> /* Set/Get an SCMI voltage domain level */
> regul0_dev = scmi_devices->regul[0];
> @@ -228,32 +225,32 @@ static int dm_test_scmi_voltage_domains(struct unit_test_state *uts)
> ut_assert(uc_pdata);
>
> ut_assertok(regulator_set_value(regul0_dev, uc_pdata->min_uV));
> - ut_asserteq(agent0->voltd[0].voltage_uv, uc_pdata->min_uV);
> + ut_asserteq(agent->voltd[0].voltage_uv, uc_pdata->min_uV);
>
> ut_assert(regulator_get_value(regul0_dev) == uc_pdata->min_uV);
>
> ut_assertok(regulator_set_value(regul0_dev, uc_pdata->max_uV));
> - ut_asserteq(agent0->voltd[0].voltage_uv, uc_pdata->max_uV);
> + ut_asserteq(agent->voltd[0].voltage_uv, uc_pdata->max_uV);
>
> ut_assert(regulator_get_value(regul0_dev) == uc_pdata->max_uV);
>
> /* Enable/disable SCMI voltage domains */
> ut_assertok(regulator_set_enable(scmi_devices->regul[0], false));
> ut_assertok(regulator_set_enable(scmi_devices->regul[1], false));
> - ut_assert(!agent0->voltd[0].enabled);
> - ut_assert(!agent0->voltd[1].enabled);
> + ut_assert(!agent->voltd[0].enabled);
> + ut_assert(!agent->voltd[1].enabled);
>
> ut_assertok(regulator_set_enable(scmi_devices->regul[0], true));
> - ut_assert(agent0->voltd[0].enabled);
> - ut_assert(!agent0->voltd[1].enabled);
> + ut_assert(agent->voltd[0].enabled);
> + ut_assert(!agent->voltd[1].enabled);
>
> ut_assertok(regulator_set_enable(scmi_devices->regul[1], true));
> - ut_assert(agent0->voltd[0].enabled);
> - ut_assert(agent0->voltd[1].enabled);
> + ut_assert(agent->voltd[0].enabled);
> + ut_assert(agent->voltd[1].enabled);
>
> ut_assertok(regulator_set_enable(scmi_devices->regul[0], false));
> - ut_assert(!agent0->voltd[0].enabled);
> - ut_assert(agent0->voltd[1].enabled);
> + ut_assert(!agent->voltd[0].enabled);
> + ut_assert(agent->voltd[1].enabled);
>
> return release_sandbox_scmi_test_devices(uts, dev);
> }
with few minor remarks
Reviewed-by: Patrick Delaunay <patrick.delaunay at foss.st.com>
Thanks
Patrick
More information about the U-Boot
mailing list