1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 2020, Linaro Limited
5 * Tests scmi_agent uclass and the SCMI drivers implemented in other
6 * uclass devices probe when a SCMI server exposes resources.
8 * Note in test.dts the protocol@10 node in agent 1. Protocol 0x10 is not
9 * implemented in U-Boot SCMI components but the implementation is exepected
10 * to not complain on unknown protocol IDs, as long as it is not used. Note
11 * in test.dts tests that SCMI drivers probing does not fail for such an
12 * unknown SCMI protocol ID.
19 #include <asm/scmi_test.h>
20 #include <dm/device-internal.h>
22 #include <linux/kconfig.h>
23 #include <power/regulator.h>
26 static int ut_assert_scmi_state_preprobe(struct unit_test_state *uts)
28 struct sandbox_scmi_service *scmi_ctx = sandbox_scmi_service_ctx();
30 ut_assertnonnull(scmi_ctx);
31 if (scmi_ctx->agent_count)
32 ut_asserteq(2, scmi_ctx->agent_count);
37 static int ut_assert_scmi_state_postprobe(struct unit_test_state *uts,
40 struct sandbox_scmi_devices *scmi_devices;
41 struct sandbox_scmi_service *scmi_ctx;
43 /* Device references to check context against test sequence */
44 scmi_devices = sandbox_scmi_devices_ctx(dev);
46 ut_assertnonnull(scmi_devices);
47 if (IS_ENABLED(CONFIG_CLK_SCMI))
48 ut_asserteq(3, scmi_devices->clk_count);
49 if (IS_ENABLED(CONFIG_RESET_SCMI))
50 ut_asserteq(1, scmi_devices->reset_count);
51 ut_asserteq(2, scmi_devices->regul_count);
53 /* State of the simulated SCMI server exposed */
54 scmi_ctx = sandbox_scmi_service_ctx();
56 ut_asserteq(2, scmi_ctx->agent_count);
58 ut_assertnonnull(scmi_ctx->agent[0]);
59 ut_asserteq(2, scmi_ctx->agent[0]->clk_count);
60 ut_assertnonnull(scmi_ctx->agent[0]->clk);
61 ut_asserteq(1, scmi_ctx->agent[0]->reset_count);
62 ut_assertnonnull(scmi_ctx->agent[0]->reset);
63 ut_asserteq(2, scmi_ctx->agent[0]->voltd_count);
64 ut_assertnonnull(scmi_ctx->agent[0]->voltd);
66 ut_assertnonnull(scmi_ctx->agent[1]);
67 ut_assertnonnull(scmi_ctx->agent[1]->clk);
68 ut_asserteq(1, scmi_ctx->agent[1]->clk_count);
73 static int load_sandbox_scmi_test_devices(struct unit_test_state *uts,
78 ret = ut_assert_scmi_state_preprobe(uts);
82 ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "sandbox_scmi",
84 ut_assertnonnull(*dev);
86 return ut_assert_scmi_state_postprobe(uts, *dev);
89 static int release_sandbox_scmi_test_devices(struct unit_test_state *uts,
92 ut_assertok(device_remove(dev, DM_REMOVE_NORMAL));
94 /* Not sure test devices are fully removed, agent may not be visible */
99 * Test SCMI states when loading and releasing resources
100 * related to SCMI drivers.
102 static int dm_test_scmi_sandbox_agent(struct unit_test_state *uts)
104 struct udevice *dev = NULL;
107 ret = load_sandbox_scmi_test_devices(uts, &dev);
109 ret = release_sandbox_scmi_test_devices(uts, dev);
114 DM_TEST(dm_test_scmi_sandbox_agent, UT_TESTF_SCAN_FDT);
116 static int dm_test_scmi_clocks(struct unit_test_state *uts)
118 struct sandbox_scmi_devices *scmi_devices;
119 struct sandbox_scmi_service *scmi_ctx;
120 struct udevice *dev = NULL;
124 if (!IS_ENABLED(CONFIG_CLK_SCMI))
127 ret = load_sandbox_scmi_test_devices(uts, &dev);
131 scmi_devices = sandbox_scmi_devices_ctx(dev);
132 scmi_ctx = sandbox_scmi_service_ctx();
134 /* Test SCMI clocks rate manipulation */
135 ut_asserteq(1000, clk_get_rate(&scmi_devices->clk[0]));
136 ut_asserteq(333, clk_get_rate(&scmi_devices->clk[1]));
137 ut_asserteq(44, clk_get_rate(&scmi_devices->clk[2]));
139 ret_dev = clk_set_rate(&scmi_devices->clk[1], 1088);
140 ut_assert(!ret_dev || ret_dev == 1088);
142 ut_asserteq(1000, scmi_ctx->agent[0]->clk[0].rate);
143 ut_asserteq(1088, scmi_ctx->agent[0]->clk[1].rate);
144 ut_asserteq(44, scmi_ctx->agent[1]->clk[0].rate);
146 ut_asserteq(1000, clk_get_rate(&scmi_devices->clk[0]));
147 ut_asserteq(1088, clk_get_rate(&scmi_devices->clk[1]));
148 ut_asserteq(44, clk_get_rate(&scmi_devices->clk[2]));
150 /* restore original rate for further tests */
151 ret_dev = clk_set_rate(&scmi_devices->clk[1], 333);
152 ut_assert(!ret_dev || ret_dev == 333);
154 /* Test SCMI clocks gating manipulation */
155 ut_assert(!scmi_ctx->agent[0]->clk[0].enabled);
156 ut_assert(!scmi_ctx->agent[0]->clk[1].enabled);
157 ut_assert(!scmi_ctx->agent[1]->clk[0].enabled);
159 ut_asserteq(0, clk_enable(&scmi_devices->clk[1]));
160 ut_asserteq(0, clk_enable(&scmi_devices->clk[2]));
162 ut_assert(!scmi_ctx->agent[0]->clk[0].enabled);
163 ut_assert(scmi_ctx->agent[0]->clk[1].enabled);
164 ut_assert(scmi_ctx->agent[1]->clk[0].enabled);
166 ut_assertok(clk_disable(&scmi_devices->clk[1]));
167 ut_assertok(clk_disable(&scmi_devices->clk[2]));
169 ut_assert(!scmi_ctx->agent[0]->clk[0].enabled);
170 ut_assert(!scmi_ctx->agent[0]->clk[1].enabled);
171 ut_assert(!scmi_ctx->agent[1]->clk[0].enabled);
173 return release_sandbox_scmi_test_devices(uts, dev);
176 DM_TEST(dm_test_scmi_clocks, UT_TESTF_SCAN_FDT);
178 static int dm_test_scmi_resets(struct unit_test_state *uts)
180 struct sandbox_scmi_devices *scmi_devices;
181 struct sandbox_scmi_service *scmi_ctx;
182 struct udevice *dev = NULL;
185 if (!IS_ENABLED(CONFIG_RESET_SCMI))
188 ret = load_sandbox_scmi_test_devices(uts, &dev);
192 scmi_devices = sandbox_scmi_devices_ctx(dev);
193 scmi_ctx = sandbox_scmi_service_ctx();
195 /* Test SCMI resect controller manipulation */
196 ut_assert(!scmi_ctx->agent[0]->reset[0].asserted)
198 ut_assertok(reset_assert(&scmi_devices->reset[0]));
199 ut_assert(scmi_ctx->agent[0]->reset[0].asserted)
201 ut_assertok(reset_deassert(&scmi_devices->reset[0]));
202 ut_assert(!scmi_ctx->agent[0]->reset[0].asserted);
204 return release_sandbox_scmi_test_devices(uts, dev);
207 DM_TEST(dm_test_scmi_resets, UT_TESTF_SCAN_FDT);
209 static int dm_test_scmi_voltage_domains(struct unit_test_state *uts)
211 struct sandbox_scmi_devices *scmi_devices;
212 struct sandbox_scmi_service *scmi_ctx;
213 struct sandbox_scmi_voltd *sandbox_voltd;
214 struct dm_regulator_uclass_plat *uc_pdata;
216 struct udevice *regul_dev;
218 ut_assertok(load_sandbox_scmi_test_devices(uts, &dev));
220 scmi_devices = sandbox_scmi_devices_ctx(dev);
221 scmi_ctx = sandbox_scmi_service_ctx();
223 /* Set/Get an SCMI voltage domain level */
224 sandbox_voltd = &scmi_ctx->agent[0]->voltd[0];
225 regul_dev = scmi_devices->regul[0];
226 ut_assert(regul_dev);
228 uc_pdata = dev_get_uclass_plat(regul_dev);
231 ut_assertok(regulator_set_value(regul_dev, uc_pdata->min_uV));
232 ut_asserteq(sandbox_voltd->voltage_uv, uc_pdata->min_uV);
234 ut_assert(regulator_get_value(regul_dev) == uc_pdata->min_uV);
236 ut_assertok(regulator_set_value(regul_dev, uc_pdata->max_uV));
237 ut_asserteq(sandbox_voltd->voltage_uv, uc_pdata->max_uV);
239 ut_assert(regulator_get_value(regul_dev) == uc_pdata->max_uV);
241 /* Enable/disable SCMI voltage domains */
242 ut_assertok(regulator_set_enable(scmi_devices->regul[0], false));
243 ut_assertok(regulator_set_enable(scmi_devices->regul[1], false));
244 ut_assert(!scmi_ctx->agent[0]->voltd[0].enabled);
245 ut_assert(!scmi_ctx->agent[0]->voltd[1].enabled);
247 ut_assertok(regulator_set_enable(scmi_devices->regul[0], true));
248 ut_assert(scmi_ctx->agent[0]->voltd[0].enabled);
249 ut_assert(!scmi_ctx->agent[0]->voltd[1].enabled);
251 ut_assertok(regulator_set_enable(scmi_devices->regul[1], true));
252 ut_assert(scmi_ctx->agent[0]->voltd[0].enabled);
253 ut_assert(scmi_ctx->agent[0]->voltd[1].enabled);
255 ut_assertok(regulator_set_enable(scmi_devices->regul[0], false));
256 ut_assert(!scmi_ctx->agent[0]->voltd[0].enabled);
257 ut_assert(scmi_ctx->agent[0]->voltd[1].enabled);
259 return release_sandbox_scmi_test_devices(uts, dev);
261 DM_TEST(dm_test_scmi_voltage_domains, UT_TESTF_SCAN_FDT);