Re: [PATCH 2/5] sandbox: scmi: test against a single scmi agent

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@chromium.org Signed-off-by: Etienne Carriere etienne.carriere@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@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>;
  };
  

@@ -596,13 +600,13 @@ #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>;
  

@@ -610,21 +614,6 @@ }; }; };

• 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 {

@@ -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 = <&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 {

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@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,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@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,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@foss.st.com

Thanks Patrick