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 scmi node. Protocol 0x10 is not
9 * implemented in U-Boot SCMI components but the implementation is expected
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 <scmi_agent.h>
20 #include <scmi_agent-uclass.h>
21 #include <scmi_protocols.h>
22 #include <asm/scmi_test.h>
23 #include <dm/device-internal.h>
25 #include <linux/kconfig.h>
26 #include <power/regulator.h>
29 static int ut_assert_scmi_state_postprobe(struct unit_test_state
*uts
,
30 struct sandbox_scmi_agent
*agent
,
33 struct sandbox_scmi_devices
*scmi_devices
;
35 /* Device references to check context against test sequence */
36 scmi_devices
= sandbox_scmi_devices_ctx(dev
);
37 ut_assertnonnull(scmi_devices
);
38 ut_asserteq(2, scmi_devices
->clk_count
);
39 ut_asserteq(1, scmi_devices
->reset_count
);
40 ut_asserteq(2, scmi_devices
->regul_count
);
42 /* State of the simulated SCMI server exposed */
43 ut_asserteq(3, agent
->clk_count
);
44 ut_assertnonnull(agent
->clk
);
45 ut_asserteq(1, agent
->reset_count
);
46 ut_assertnonnull(agent
->reset
);
47 ut_asserteq(2, agent
->voltd_count
);
48 ut_assertnonnull(agent
->voltd
);
53 static int load_sandbox_scmi_test_devices(struct unit_test_state
*uts
,
54 struct sandbox_scmi_agent
**ctx
,
57 struct udevice
*agent_dev
;
59 ut_assertok(uclass_get_device_by_name(UCLASS_SCMI_AGENT
, "scmi",
61 ut_assertnonnull(agent_dev
);
63 *ctx
= sandbox_scmi_agent_ctx(agent_dev
);
64 ut_assertnonnull(*ctx
);
67 ut_assertok(uclass_get_device_by_name(UCLASS_MISC
, "sandbox_scmi",
69 ut_assertnonnull(*dev
);
71 return ut_assert_scmi_state_postprobe(uts
, *ctx
, *dev
);
74 static int release_sandbox_scmi_test_devices(struct unit_test_state
*uts
,
78 ut_assertok(device_remove(dev
, DM_REMOVE_NORMAL
));
84 * Test SCMI states when loading and releasing resources
85 * related to SCMI drivers.
87 static int dm_test_scmi_sandbox_agent(struct unit_test_state
*uts
)
89 struct sandbox_scmi_agent
*ctx
;
90 struct udevice
*dev
= NULL
;
93 ret
= load_sandbox_scmi_test_devices(uts
, &ctx
, &dev
);
95 ret
= release_sandbox_scmi_test_devices(uts
, dev
);
99 DM_TEST(dm_test_scmi_sandbox_agent
, UT_TESTF_SCAN_FDT
);
101 static int dm_test_scmi_base(struct unit_test_state
*uts
)
103 struct udevice
*agent_dev
, *base
;
104 struct scmi_agent_priv
*priv
;
105 u32 version
, num_agents
, num_protocols
, impl_version
;
106 u32 attributes
, agent_id
;
107 u8
*vendor
, *agent_name
, *protocols
;
111 ut_assertok(uclass_get_device_by_name(UCLASS_SCMI_AGENT
, "scmi",
113 ut_assertnonnull(agent_dev
);
114 ut_assertnonnull(priv
= dev_get_uclass_plat(agent_dev
));
115 ut_assertnonnull(base
= scmi_get_protocol(agent_dev
,
116 SCMI_PROTOCOL_ID_BASE
));
119 ret
= scmi_base_protocol_version(base
, &version
);
121 ut_asserteq(priv
->version
, version
);
123 /* protocol attributes */
124 ret
= scmi_base_protocol_attrs(base
, &num_agents
, &num_protocols
);
126 ut_asserteq(priv
->num_agents
, num_agents
);
127 ut_asserteq(priv
->num_protocols
, num_protocols
);
129 /* discover vendor */
130 ret
= scmi_base_discover_vendor(base
, &vendor
);
132 ut_asserteq_str(priv
->vendor
, vendor
);
135 /* message attributes */
136 ret
= scmi_base_protocol_message_attrs(base
,
137 SCMI_BASE_DISCOVER_SUB_VENDOR
,
140 ut_assertok(attributes
);
142 /* discover sub vendor */
143 ret
= scmi_base_discover_sub_vendor(base
, &vendor
);
145 ut_asserteq_str(priv
->sub_vendor
, vendor
);
149 ret
= scmi_base_discover_impl_version(base
, &impl_version
);
151 ut_asserteq(priv
->impl_version
, impl_version
);
153 /* discover agent (my self) */
154 ret
= scmi_base_discover_agent(base
, 0xffffffff, &agent_id
,
157 ut_asserteq(priv
->agent_id
, agent_id
);
158 ut_asserteq_str(priv
->agent_name
, agent_name
);
161 /* discover protocols */
162 ret
= scmi_base_discover_list_protocols(base
, &protocols
);
163 ut_asserteq(num_protocols
, ret
);
164 ut_asserteq_mem(priv
->protocols
, protocols
, sizeof(u8
) * num_protocols
);
168 * NOTE: Sandbox SCMI driver handles device-0 only. It supports setting
169 * access and protocol permissions, but doesn't allow unsetting them nor
170 * resetting the configurations.
172 /* set device permissions */
173 ret
= scmi_base_set_device_permissions(base
, agent_id
, 0,
174 SCMI_BASE_SET_DEVICE_PERMISSIONS_ACCESS
);
175 ut_assertok(ret
); /* SCMI_SUCCESS */
176 ret
= scmi_base_set_device_permissions(base
, agent_id
, 1,
177 SCMI_BASE_SET_DEVICE_PERMISSIONS_ACCESS
);
178 ut_asserteq(-ENOENT
, ret
); /* SCMI_NOT_FOUND */
179 ret
= scmi_base_set_device_permissions(base
, agent_id
, 0, 0);
180 ut_asserteq(-EACCES
, ret
); /* SCMI_DENIED */
182 /* set protocol permissions */
183 ret
= scmi_base_set_protocol_permissions(base
, agent_id
, 0,
184 SCMI_PROTOCOL_ID_CLOCK
,
185 SCMI_BASE_SET_PROTOCOL_PERMISSIONS_ACCESS
);
186 ut_assertok(ret
); /* SCMI_SUCCESS */
187 ret
= scmi_base_set_protocol_permissions(base
, agent_id
, 1,
188 SCMI_PROTOCOL_ID_CLOCK
,
189 SCMI_BASE_SET_PROTOCOL_PERMISSIONS_ACCESS
);
190 ut_asserteq(-ENOENT
, ret
); /* SCMI_NOT_FOUND */
191 ret
= scmi_base_set_protocol_permissions(base
, agent_id
, 0,
192 SCMI_PROTOCOL_ID_CLOCK
, 0);
193 ut_asserteq(-EACCES
, ret
); /* SCMI_DENIED */
195 /* reset agent configuration */
196 ret
= scmi_base_reset_agent_configuration(base
, agent_id
, 0);
197 ut_asserteq(-EACCES
, ret
); /* SCMI_DENIED */
198 ret
= scmi_base_reset_agent_configuration(base
, agent_id
,
199 SCMI_BASE_RESET_ALL_ACCESS_PERMISSIONS
);
200 ut_asserteq(-EACCES
, ret
); /* SCMI_DENIED */
201 ret
= scmi_base_reset_agent_configuration(base
, agent_id
, 0);
202 ut_asserteq(-EACCES
, ret
); /* SCMI_DENIED */
207 DM_TEST(dm_test_scmi_base
, UT_TESTF_SCAN_FDT
);
209 static int dm_test_scmi_power_domains(struct unit_test_state
*uts
)
211 struct sandbox_scmi_agent
*agent
;
212 struct sandbox_scmi_devices
*scmi_devices
;
213 struct udevice
*agent_dev
, *pwd
, *dev
;
214 u32 version
, count
, attributes
, pstate
;
221 ut_assertok(load_sandbox_scmi_test_devices(uts
, &agent
, &dev
));
222 ut_assertnonnull(agent
);
223 scmi_devices
= sandbox_scmi_devices_ctx(dev
);
224 ut_assertnonnull(scmi_devices
);
225 ut_asserteq(2, scmi_devices
->pwdom
->id
); /* in test.dts */
227 ut_assertok(uclass_get_device_by_name(UCLASS_SCMI_AGENT
, "scmi",
229 ut_assertnonnull(agent_dev
);
230 pwd
= scmi_get_protocol(agent_dev
, SCMI_PROTOCOL_ID_POWER_DOMAIN
);
231 ut_assertnonnull(pwd
);
234 * SCMI Power domain management protocol interfaces
237 ret
= scmi_generic_protocol_version(pwd
, SCMI_PROTOCOL_ID_POWER_DOMAIN
,
240 ut_asserteq(agent
->pwdom_version
, version
);
242 /* protocol attributes */
243 ret
= scmi_pwd_protocol_attrs(pwd
, &count
, &stats_addr
, &stats_len
);
245 ut_asserteq(agent
->pwdom_count
, count
);
246 ut_asserteq(0, stats_len
);
248 /* protocol message attributes */
249 ret
= scmi_pwd_protocol_message_attrs(pwd
, SCMI_PWD_STATE_SET
,
252 ret
= scmi_pwd_protocol_message_attrs(pwd
, SCMI_PWD_STATE_NOTIFY
,
254 ut_asserteq(-ENOENT
, ret
); /* the protocol not supported */
256 /* power domain attributes */
257 ret
= scmi_pwd_attrs(pwd
, 0, &attributes
, &name
);
259 ut_asserteq_str("power-domain--0", name
);
262 ret
= scmi_pwd_attrs(pwd
, 10, &attributes
, &name
);
263 ut_asserteq(-ENOENT
, ret
); /* domain-10 doesn't exist */
265 /* power domain state set/get */
266 ret
= scmi_pwd_state_set(pwd
, 0, 0, 0);
268 ret
= scmi_pwd_state_get(pwd
, 0, &pstate
);
270 ut_asserteq(0, pstate
); /* ON */
272 ret
= scmi_pwd_state_set(pwd
, 0, 0, SCMI_PWD_PSTATE_TYPE_LOST
);
274 ret
= scmi_pwd_state_get(pwd
, 0, &pstate
);
276 ut_asserteq(SCMI_PWD_PSTATE_TYPE_LOST
, pstate
); /* OFF */
278 ret
= scmi_pwd_state_set(pwd
, 0, 10, 0);
279 ut_asserteq(-ENOENT
, ret
);
281 /* power domain name get */
282 ret
= scmi_pwd_name_get(pwd
, 0, &name
);
284 ut_asserteq_str("power-domain--0-extended", name
);
287 ret
= scmi_pwd_name_get(pwd
, 10, &name
);
288 ut_asserteq(-ENOENT
, ret
); /* domain-10 doesn't exist */
291 * U-Boot driver model interfaces
293 /* power_domain_on */
294 ret
= power_domain_on(scmi_devices
->pwdom
);
296 ret
= scmi_pwd_state_get(pwd
, scmi_devices
->pwdom
->id
, &pstate
);
298 ut_asserteq(0, pstate
); /* ON */
300 /* power_domain_off */
301 ret
= power_domain_off(scmi_devices
->pwdom
);
303 ret
= scmi_pwd_state_get(pwd
, scmi_devices
->pwdom
->id
, &pstate
);
305 ut_asserteq(SCMI_PWD_PSTATE_TYPE_LOST
, pstate
); /* OFF */
307 return release_sandbox_scmi_test_devices(uts
, dev
);
310 DM_TEST(dm_test_scmi_power_domains
, UT_TESTF_SCAN_FDT
);
312 static int dm_test_scmi_clocks(struct unit_test_state
*uts
)
314 struct sandbox_scmi_agent
*agent
;
315 struct sandbox_scmi_devices
*scmi_devices
;
316 struct udevice
*agent_dev
, *clock_dev
, *dev
;
320 ret
= load_sandbox_scmi_test_devices(uts
, &agent
, &dev
);
324 scmi_devices
= sandbox_scmi_devices_ctx(dev
);
325 ut_assertnonnull(scmi_devices
);
327 /* Sandbox SCMI clock protocol has its own channel */
328 ut_assertok(uclass_get_device_by_name(UCLASS_SCMI_AGENT
, "scmi",
330 ut_assertnonnull(agent_dev
);
331 clock_dev
= scmi_get_protocol(agent_dev
, SCMI_PROTOCOL_ID_CLOCK
);
332 ut_assertnonnull(clock_dev
);
333 ut_asserteq(0x14, sandbox_scmi_channel_id(clock_dev
));
335 /* Test SCMI clocks rate manipulation */
336 ut_asserteq(333, agent
->clk
[0].rate
);
337 ut_asserteq(200, agent
->clk
[1].rate
);
338 ut_asserteq(1000, agent
->clk
[2].rate
);
340 ut_asserteq(1000, clk_get_rate(&scmi_devices
->clk
[0]));
341 ut_asserteq(333, clk_get_rate(&scmi_devices
->clk
[1]));
343 ret_dev
= clk_set_rate(&scmi_devices
->clk
[1], 1088);
344 ut_assert(!ret_dev
|| ret_dev
== 1088);
346 ut_asserteq(1088, agent
->clk
[0].rate
);
347 ut_asserteq(200, agent
->clk
[1].rate
);
348 ut_asserteq(1000, agent
->clk
[2].rate
);
350 ut_asserteq(1000, clk_get_rate(&scmi_devices
->clk
[0]));
351 ut_asserteq(1088, clk_get_rate(&scmi_devices
->clk
[1]));
353 /* restore original rate for further tests */
354 ret_dev
= clk_set_rate(&scmi_devices
->clk
[1], 333);
355 ut_assert(!ret_dev
|| ret_dev
== 333);
357 /* Test SCMI clocks gating manipulation */
358 ut_assert(!agent
->clk
[0].enabled
);
359 ut_assert(!agent
->clk
[1].enabled
);
360 ut_assert(!agent
->clk
[2].enabled
);
362 ut_asserteq(0, clk_enable(&scmi_devices
->clk
[1]));
364 ut_assert(agent
->clk
[0].enabled
);
365 ut_assert(!agent
->clk
[1].enabled
);
366 ut_assert(!agent
->clk
[2].enabled
);
368 ut_assertok(clk_disable(&scmi_devices
->clk
[1]));
370 ut_assert(!agent
->clk
[0].enabled
);
371 ut_assert(!agent
->clk
[1].enabled
);
372 ut_assert(!agent
->clk
[2].enabled
);
374 return release_sandbox_scmi_test_devices(uts
, dev
);
376 DM_TEST(dm_test_scmi_clocks
, UT_TESTF_SCAN_FDT
);
378 static int dm_test_scmi_resets(struct unit_test_state
*uts
)
380 struct sandbox_scmi_agent
*agent
;
381 struct sandbox_scmi_devices
*scmi_devices
;
382 struct udevice
*agent_dev
, *reset_dev
, *dev
= NULL
;
385 ret
= load_sandbox_scmi_test_devices(uts
, &agent
, &dev
);
389 scmi_devices
= sandbox_scmi_devices_ctx(dev
);
390 ut_assertnonnull(scmi_devices
);
392 /* Sandbox SCMI reset protocol doesn't have its own channel */
393 ut_assertok(uclass_get_device_by_name(UCLASS_SCMI_AGENT
, "scmi",
395 ut_assertnonnull(agent_dev
);
396 reset_dev
= scmi_get_protocol(agent_dev
, SCMI_PROTOCOL_ID_RESET_DOMAIN
);
397 ut_assertnonnull(reset_dev
);
398 ut_asserteq(0x0, sandbox_scmi_channel_id(reset_dev
));
400 /* Test SCMI resect controller manipulation */
401 ut_assert(!agent
->reset
[0].asserted
);
403 ut_assertok(reset_assert(&scmi_devices
->reset
[0]));
404 ut_assert(agent
->reset
[0].asserted
);
406 ut_assertok(reset_deassert(&scmi_devices
->reset
[0]));
407 ut_assert(!agent
->reset
[0].asserted
);
409 return release_sandbox_scmi_test_devices(uts
, dev
);
411 DM_TEST(dm_test_scmi_resets
, UT_TESTF_SCAN_FDT
);
413 static int dm_test_scmi_voltage_domains(struct unit_test_state
*uts
)
415 struct sandbox_scmi_agent
*agent
;
416 struct sandbox_scmi_devices
*scmi_devices
;
417 struct dm_regulator_uclass_plat
*uc_pdata
;
419 struct udevice
*regul0_dev
;
421 ut_assertok(load_sandbox_scmi_test_devices(uts
, &agent
, &dev
));
423 scmi_devices
= sandbox_scmi_devices_ctx(dev
);
424 ut_assertnonnull(scmi_devices
);
426 /* Set/Get an SCMI voltage domain level */
427 regul0_dev
= scmi_devices
->regul
[0];
428 ut_assert(regul0_dev
);
430 uc_pdata
= dev_get_uclass_plat(regul0_dev
);
433 ut_assertok(regulator_set_value(regul0_dev
, uc_pdata
->min_uV
));
434 ut_asserteq(agent
->voltd
[0].voltage_uv
, uc_pdata
->min_uV
);
436 ut_assert(regulator_get_value(regul0_dev
) == uc_pdata
->min_uV
);
438 ut_assertok(regulator_set_value(regul0_dev
, uc_pdata
->max_uV
));
439 ut_asserteq(agent
->voltd
[0].voltage_uv
, uc_pdata
->max_uV
);
441 ut_assert(regulator_get_value(regul0_dev
) == uc_pdata
->max_uV
);
443 /* Enable/disable SCMI voltage domains */
444 ut_assertok(regulator_set_enable(scmi_devices
->regul
[0], false));
445 ut_assertok(regulator_set_enable(scmi_devices
->regul
[1], false));
446 ut_assert(!agent
->voltd
[0].enabled
);
447 ut_assert(!agent
->voltd
[1].enabled
);
449 ut_assertok(regulator_set_enable(scmi_devices
->regul
[0], true));
450 ut_assert(agent
->voltd
[0].enabled
);
451 ut_assert(!agent
->voltd
[1].enabled
);
453 ut_assertok(regulator_set_enable(scmi_devices
->regul
[1], true));
454 ut_assert(agent
->voltd
[0].enabled
);
455 ut_assert(agent
->voltd
[1].enabled
);
457 ut_assertok(regulator_set_enable(scmi_devices
->regul
[0], false));
458 ut_assert(!agent
->voltd
[0].enabled
);
459 ut_assert(agent
->voltd
[1].enabled
);
461 return release_sandbox_scmi_test_devices(uts
, dev
);
463 DM_TEST(dm_test_scmi_voltage_domains
, UT_TESTF_SCAN_FDT
);