sandbox: scmi: test against a single scmi agent
authorEtienne Carriere <etienne.carriere@linaro.org>
Mon, 21 Feb 2022 08:22:39 +0000 (09:22 +0100)
committerTom Rini <trini@konsulko.com>
Wed, 2 Mar 2022 22:42:06 +0000 (17:42 -0500)
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@chromium.org>
Reviewed-by: Patrick Delaunay <patrick.delaunay@foss.st.com>
Signed-off-by: Etienne Carriere <etienne.carriere@linaro.org>
arch/sandbox/dts/test.dts
arch/sandbox/include/asm/scmi_test.h
drivers/firmware/scmi/sandbox-scmi_agent.c
drivers/firmware/scmi/sandbox-scmi_devices.c
test/dm/scmi.c

index 48ca3e1..30874b0 100644 (file)
                        compatible = "sandbox,firmware";
                };
 
-               sandbox-scmi-agent@0 {
+               scmi {
                        compatible = "sandbox,scmi-agent";
                        #address-cells = <1>;
                        #size-cells = <0>;
 
-                       clk_scmi0: protocol@14 {
+                       protocol@10 {
+                               reg = <0x10>;
+                       };
+
+                       clk_scmi: protocol@14 {
                                reg = <0x14>;
                                #clock-cells = <1>;
                        };
 
-                       reset_scmi0: protocol@16 {
+                       reset_scmi: protocol@16 {
                                reg = <0x16>;
                                #reset-cells = <1>;
                        };
                                        #address-cells = <1>;
                                        #size-cells = <0>;
 
-                                       regul0_scmi0: reg@0 {
+                                       regul0_scmi: reg@0 {
                                                reg = <0>;
                                                regulator-name = "sandbox-voltd0";
                                                regulator-min-microvolt = <1100000>;
                                                regulator-max-microvolt = <3300000>;
                                        };
-                                       regul1_scmi0: reg@1 {
+                                       regul1_scmi: reg@1 {
                                                reg = <0x1>;
                                                regulator-name = "sandbox-voltd1";
                                                regulator-min-microvolt = <1800000>;
                                };
                        };
                };
-
-               sandbox-scmi-agent@1 {
-                       compatible = "sandbox,scmi-agent";
-                       #address-cells = <1>;
-                       #size-cells = <0>;
-
-                       clk_scmi1: protocol@14 {
-                               reg = <0x14>;
-                               #clock-cells = <1>;
-                       };
-
-                       protocol@10 {
-                               reg = <0x10>;
-                       };
-               };
        };
 
        pinctrl-gpio {
 
        sandbox_scmi {
                compatible = "sandbox,scmi-devices";
-               clocks = <&clk_scmi0 7>, <&clk_scmi0 3>, <&clk_scmi1 1>;
-               resets = <&reset_scmi0 3>;
-               regul0-supply = <&regul0_scmi0>;
-               regul1-supply = <&regul1_scmi0>;
+               clocks = <&clk_scmi 7>, <&clk_scmi 3>;
+               resets = <&reset_scmi 3>;
+               regul0-supply = <&regul0_scmi>;
+               regul1-supply = <&regul1_scmi>;
        };
 
        pinctrl {
index 2930e68..054be5f 100644 (file)
@@ -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
  */
index 4b96820..51474b5 100644 (file)
  * 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@0" in test.dts.
- *
- * Agent #1 simulates 1 clock.
- * See IDs in scmi1_clk[] and "sandbox-scmi-agent@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,37 @@ 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@";
        struct sandbox_scmi_agent *agent = dev_get_priv(dev);
-       const size_t basename_size = sizeof(basename) - 1;
-
-       if (strncmp(basename, dev->name, basename_size))
-               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;
 };
index 66a6792..9baeb46 100644 (file)
@@ -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,
 };
index c938e6d..d576b5f 100644 (file)
@@ -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@10 node in agent 1. Protocol 0x10 is not
+ * Note in test.dts the protocol@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,26 @@ 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);
+       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(agent1);
-       ut_assertnonnull(agent1->clk);
-       ut_asserteq(1, agent1->clk_count);
+       ut_assertnonnull(scmi_ctx);
+       agent = scmi_ctx->agent;
+       ut_assertnonnull(agent);
+       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 +108,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 +118,45 @@ 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 +166,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 +175,20 @@ 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 +198,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 +206,11 @@ 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 +220,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);
 }