blob: d4ff60e0006967f44f741545173db12baa56033c [file] [log] [blame]
Etienne Carriere02fd1262020-09-09 18:44:00 +02001// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2020, Linaro Limited
4 *
5 * Tests scmi_agent uclass and the SCMI drivers implemented in other
6 * uclass devices probe when a SCMI server exposes resources.
7 *
Etienne Carriere09665cb2022-02-21 09:22:39 +01008 * Note in test.dts the protocol@10 node in scmi node. Protocol 0x10 is not
Yuepeng Xing71cc0212022-12-02 14:23:07 +08009 * implemented in U-Boot SCMI components but the implementation is expected
Etienne Carriere02fd1262020-09-09 18:44:00 +020010 * 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.
13 */
14
15#include <common.h>
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +020016#include <clk.h>
Etienne Carriere02fd1262020-09-09 18:44:00 +020017#include <dm.h>
Etienne Carriere8b9b6892020-09-09 18:44:07 +020018#include <reset.h>
AKASHI Takahirocc4ecda2023-10-11 19:06:59 +090019#include <scmi_agent.h>
AKASHI Takahiro49f366b2023-10-11 19:07:06 +090020#include <scmi_agent-uclass.h>
AKASHI Takahirocc4ecda2023-10-11 19:06:59 +090021#include <scmi_protocols.h>
Etienne Carriere02fd1262020-09-09 18:44:00 +020022#include <asm/scmi_test.h>
23#include <dm/device-internal.h>
24#include <dm/test.h>
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +020025#include <linux/kconfig.h>
Etienne Carriereb8f15cd2021-03-08 22:38:07 +010026#include <power/regulator.h>
Etienne Carriere02fd1262020-09-09 18:44:00 +020027#include <test/ut.h>
28
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +020029static int ut_assert_scmi_state_postprobe(struct unit_test_state *uts,
AKASHI Takahirodae00462023-10-11 19:07:03 +090030 struct sandbox_scmi_agent *agent,
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +020031 struct udevice *dev)
32{
33 struct sandbox_scmi_devices *scmi_devices;
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +020034
35 /* Device references to check context against test sequence */
36 scmi_devices = sandbox_scmi_devices_ctx(dev);
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +020037 ut_assertnonnull(scmi_devices);
Etienne Carriere09665cb2022-02-21 09:22:39 +010038 ut_asserteq(2, scmi_devices->clk_count);
Etienne Carrierec83a8432021-03-08 22:38:08 +010039 ut_asserteq(1, scmi_devices->reset_count);
Etienne Carriereb8f15cd2021-03-08 22:38:07 +010040 ut_asserteq(2, scmi_devices->regul_count);
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +020041
42 /* State of the simulated SCMI server exposed */
Etienne Carrierebf1f1322022-02-21 09:22:41 +010043 ut_asserteq(3, agent->clk_count);
Etienne Carriere09665cb2022-02-21 09:22:39 +010044 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);
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +020049
50 return 0;
51}
52
53static int load_sandbox_scmi_test_devices(struct unit_test_state *uts,
AKASHI Takahirodae00462023-10-11 19:07:03 +090054 struct sandbox_scmi_agent **ctx,
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +020055 struct udevice **dev)
56{
AKASHI Takahirodae00462023-10-11 19:07:03 +090057 struct udevice *agent_dev;
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +020058
AKASHI Takahirodae00462023-10-11 19:07:03 +090059 ut_assertok(uclass_get_device_by_name(UCLASS_SCMI_AGENT, "scmi",
60 &agent_dev));
61 ut_assertnonnull(agent_dev);
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +020062
AKASHI Takahirodae00462023-10-11 19:07:03 +090063 *ctx = sandbox_scmi_agent_ctx(agent_dev);
64 ut_assertnonnull(*ctx);
65
66 /* probe */
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +020067 ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "sandbox_scmi",
68 dev));
69 ut_assertnonnull(*dev);
70
AKASHI Takahirodae00462023-10-11 19:07:03 +090071 return ut_assert_scmi_state_postprobe(uts, *ctx, *dev);
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +020072}
73
74static int release_sandbox_scmi_test_devices(struct unit_test_state *uts,
75 struct udevice *dev)
76{
AKASHI Takahirodae00462023-10-11 19:07:03 +090077 /* un-probe */
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +020078 ut_assertok(device_remove(dev, DM_REMOVE_NORMAL));
79
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +020080 return 0;
81}
82
Etienne Carriere02fd1262020-09-09 18:44:00 +020083/*
84 * Test SCMI states when loading and releasing resources
85 * related to SCMI drivers.
86 */
87static int dm_test_scmi_sandbox_agent(struct unit_test_state *uts)
88{
AKASHI Takahirodae00462023-10-11 19:07:03 +090089 struct sandbox_scmi_agent *ctx;
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +020090 struct udevice *dev = NULL;
91 int ret;
Etienne Carriere02fd1262020-09-09 18:44:00 +020092
AKASHI Takahirodae00462023-10-11 19:07:03 +090093 ret = load_sandbox_scmi_test_devices(uts, &ctx, &dev);
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +020094 if (!ret)
95 ret = release_sandbox_scmi_test_devices(uts, dev);
Etienne Carriere02fd1262020-09-09 18:44:00 +020096
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +020097 return ret;
Etienne Carriere02fd1262020-09-09 18:44:00 +020098}
Etienne Carriere02fd1262020-09-09 18:44:00 +020099DM_TEST(dm_test_scmi_sandbox_agent, UT_TESTF_SCAN_FDT);
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +0200100
AKASHI Takahiro49f366b2023-10-11 19:07:06 +0900101static int dm_test_scmi_base(struct unit_test_state *uts)
102{
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;
108 int ret;
109
110 /* preparation */
111 ut_assertok(uclass_get_device_by_name(UCLASS_SCMI_AGENT, "scmi",
112 &agent_dev));
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));
117
118 /* version */
119 ret = scmi_base_protocol_version(base, &version);
120 ut_assertok(ret);
121 ut_asserteq(priv->version, version);
122
123 /* protocol attributes */
124 ret = scmi_base_protocol_attrs(base, &num_agents, &num_protocols);
125 ut_assertok(ret);
126 ut_asserteq(priv->num_agents, num_agents);
127 ut_asserteq(priv->num_protocols, num_protocols);
128
129 /* discover vendor */
130 ret = scmi_base_discover_vendor(base, &vendor);
131 ut_assertok(ret);
132 ut_asserteq_str(priv->vendor, vendor);
133 free(vendor);
134
135 /* message attributes */
136 ret = scmi_base_protocol_message_attrs(base,
137 SCMI_BASE_DISCOVER_SUB_VENDOR,
138 &attributes);
139 ut_assertok(ret);
140 ut_assertok(attributes);
141
142 /* discover sub vendor */
143 ret = scmi_base_discover_sub_vendor(base, &vendor);
144 ut_assertok(ret);
145 ut_asserteq_str(priv->sub_vendor, vendor);
146 free(vendor);
147
148 /* impl version */
149 ret = scmi_base_discover_impl_version(base, &impl_version);
150 ut_assertok(ret);
151 ut_asserteq(priv->impl_version, impl_version);
152
153 /* discover agent (my self) */
154 ret = scmi_base_discover_agent(base, 0xffffffff, &agent_id,
155 &agent_name);
156 ut_assertok(ret);
157 ut_asserteq(priv->agent_id, agent_id);
158 ut_asserteq_str(priv->agent_name, agent_name);
159 free(agent_name);
160
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);
165 free(protocols);
166
167 /*
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.
171 */
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 */
181
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 */
194
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 */
203
204 return 0;
205}
206
207DM_TEST(dm_test_scmi_base, UT_TESTF_SCAN_FDT);
208
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +0200209static int dm_test_scmi_clocks(struct unit_test_state *uts)
210{
Etienne Carriere09665cb2022-02-21 09:22:39 +0100211 struct sandbox_scmi_agent *agent;
AKASHI Takahirodae00462023-10-11 19:07:03 +0900212 struct sandbox_scmi_devices *scmi_devices;
AKASHI Takahirocc4ecda2023-10-11 19:06:59 +0900213 struct udevice *agent_dev, *clock_dev, *dev;
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +0200214 int ret_dev;
215 int ret;
216
AKASHI Takahirodae00462023-10-11 19:07:03 +0900217 ret = load_sandbox_scmi_test_devices(uts, &agent, &dev);
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +0200218 if (ret)
219 return ret;
220
221 scmi_devices = sandbox_scmi_devices_ctx(dev);
Etienne Carriere09665cb2022-02-21 09:22:39 +0100222 ut_assertnonnull(scmi_devices);
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +0200223
AKASHI Takahirocc4ecda2023-10-11 19:06:59 +0900224 /* Sandbox SCMI clock protocol has its own channel */
225 ut_assertok(uclass_get_device_by_name(UCLASS_SCMI_AGENT, "scmi",
226 &agent_dev));
227 ut_assertnonnull(agent_dev);
228 clock_dev = scmi_get_protocol(agent_dev, SCMI_PROTOCOL_ID_CLOCK);
229 ut_assertnonnull(clock_dev);
230 ut_asserteq(0x14, sandbox_scmi_channel_id(clock_dev));
231
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +0200232 /* Test SCMI clocks rate manipulation */
Etienne Carrierebf1f1322022-02-21 09:22:41 +0100233 ut_asserteq(333, agent->clk[0].rate);
234 ut_asserteq(200, agent->clk[1].rate);
235 ut_asserteq(1000, agent->clk[2].rate);
236
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +0200237 ut_asserteq(1000, clk_get_rate(&scmi_devices->clk[0]));
238 ut_asserteq(333, clk_get_rate(&scmi_devices->clk[1]));
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +0200239
240 ret_dev = clk_set_rate(&scmi_devices->clk[1], 1088);
241 ut_assert(!ret_dev || ret_dev == 1088);
242
Etienne Carrierebf1f1322022-02-21 09:22:41 +0100243 ut_asserteq(1088, agent->clk[0].rate);
244 ut_asserteq(200, agent->clk[1].rate);
245 ut_asserteq(1000, agent->clk[2].rate);
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +0200246
247 ut_asserteq(1000, clk_get_rate(&scmi_devices->clk[0]));
248 ut_asserteq(1088, clk_get_rate(&scmi_devices->clk[1]));
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +0200249
250 /* restore original rate for further tests */
251 ret_dev = clk_set_rate(&scmi_devices->clk[1], 333);
252 ut_assert(!ret_dev || ret_dev == 333);
253
254 /* Test SCMI clocks gating manipulation */
Etienne Carriere09665cb2022-02-21 09:22:39 +0100255 ut_assert(!agent->clk[0].enabled);
256 ut_assert(!agent->clk[1].enabled);
257 ut_assert(!agent->clk[2].enabled);
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +0200258
259 ut_asserteq(0, clk_enable(&scmi_devices->clk[1]));
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +0200260
Etienne Carrierebf1f1322022-02-21 09:22:41 +0100261 ut_assert(agent->clk[0].enabled);
262 ut_assert(!agent->clk[1].enabled);
Etienne Carriere09665cb2022-02-21 09:22:39 +0100263 ut_assert(!agent->clk[2].enabled);
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +0200264
265 ut_assertok(clk_disable(&scmi_devices->clk[1]));
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +0200266
Etienne Carriere09665cb2022-02-21 09:22:39 +0100267 ut_assert(!agent->clk[0].enabled);
268 ut_assert(!agent->clk[1].enabled);
269 ut_assert(!agent->clk[2].enabled);
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +0200270
271 return release_sandbox_scmi_test_devices(uts, dev);
272}
Etienne Carriere2d94c08fa2020-09-09 18:44:05 +0200273DM_TEST(dm_test_scmi_clocks, UT_TESTF_SCAN_FDT);
Etienne Carriere8b9b6892020-09-09 18:44:07 +0200274
275static int dm_test_scmi_resets(struct unit_test_state *uts)
276{
Etienne Carriere09665cb2022-02-21 09:22:39 +0100277 struct sandbox_scmi_agent *agent;
AKASHI Takahirodae00462023-10-11 19:07:03 +0900278 struct sandbox_scmi_devices *scmi_devices;
AKASHI Takahirocc4ecda2023-10-11 19:06:59 +0900279 struct udevice *agent_dev, *reset_dev, *dev = NULL;
Etienne Carriere8b9b6892020-09-09 18:44:07 +0200280 int ret;
281
AKASHI Takahirodae00462023-10-11 19:07:03 +0900282 ret = load_sandbox_scmi_test_devices(uts, &agent, &dev);
Etienne Carriere8b9b6892020-09-09 18:44:07 +0200283 if (ret)
284 return ret;
285
286 scmi_devices = sandbox_scmi_devices_ctx(dev);
Etienne Carriere09665cb2022-02-21 09:22:39 +0100287 ut_assertnonnull(scmi_devices);
Etienne Carriere8b9b6892020-09-09 18:44:07 +0200288
AKASHI Takahirocc4ecda2023-10-11 19:06:59 +0900289 /* Sandbox SCMI reset protocol doesn't have its own channel */
290 ut_assertok(uclass_get_device_by_name(UCLASS_SCMI_AGENT, "scmi",
291 &agent_dev));
292 ut_assertnonnull(agent_dev);
293 reset_dev = scmi_get_protocol(agent_dev, SCMI_PROTOCOL_ID_RESET_DOMAIN);
294 ut_assertnonnull(reset_dev);
295 ut_asserteq(0x0, sandbox_scmi_channel_id(reset_dev));
296
Etienne Carriere8b9b6892020-09-09 18:44:07 +0200297 /* Test SCMI resect controller manipulation */
Marek Vasut1531c4e2023-03-10 04:33:13 +0100298 ut_assert(!agent->reset[0].asserted);
Etienne Carriere8b9b6892020-09-09 18:44:07 +0200299
300 ut_assertok(reset_assert(&scmi_devices->reset[0]));
Marek Vasut1531c4e2023-03-10 04:33:13 +0100301 ut_assert(agent->reset[0].asserted);
Etienne Carriere8b9b6892020-09-09 18:44:07 +0200302
303 ut_assertok(reset_deassert(&scmi_devices->reset[0]));
Etienne Carriere09665cb2022-02-21 09:22:39 +0100304 ut_assert(!agent->reset[0].asserted);
Etienne Carriere8b9b6892020-09-09 18:44:07 +0200305
306 return release_sandbox_scmi_test_devices(uts, dev);
307}
Etienne Carriere8b9b6892020-09-09 18:44:07 +0200308DM_TEST(dm_test_scmi_resets, UT_TESTF_SCAN_FDT);
Etienne Carriereb8f15cd2021-03-08 22:38:07 +0100309
310static int dm_test_scmi_voltage_domains(struct unit_test_state *uts)
311{
Etienne Carriere09665cb2022-02-21 09:22:39 +0100312 struct sandbox_scmi_agent *agent;
AKASHI Takahirodae00462023-10-11 19:07:03 +0900313 struct sandbox_scmi_devices *scmi_devices;
Etienne Carriereb8f15cd2021-03-08 22:38:07 +0100314 struct dm_regulator_uclass_plat *uc_pdata;
315 struct udevice *dev;
Etienne Carriereeeaf2822021-03-08 22:38:09 +0100316 struct udevice *regul0_dev;
Etienne Carriereb8f15cd2021-03-08 22:38:07 +0100317
AKASHI Takahirodae00462023-10-11 19:07:03 +0900318 ut_assertok(load_sandbox_scmi_test_devices(uts, &agent, &dev));
Etienne Carriereb8f15cd2021-03-08 22:38:07 +0100319
320 scmi_devices = sandbox_scmi_devices_ctx(dev);
Etienne Carriere09665cb2022-02-21 09:22:39 +0100321 ut_assertnonnull(scmi_devices);
Etienne Carriereb8f15cd2021-03-08 22:38:07 +0100322
323 /* Set/Get an SCMI voltage domain level */
Etienne Carriereeeaf2822021-03-08 22:38:09 +0100324 regul0_dev = scmi_devices->regul[0];
325 ut_assert(regul0_dev);
Etienne Carriereb8f15cd2021-03-08 22:38:07 +0100326
Etienne Carriereeeaf2822021-03-08 22:38:09 +0100327 uc_pdata = dev_get_uclass_plat(regul0_dev);
Etienne Carriereb8f15cd2021-03-08 22:38:07 +0100328 ut_assert(uc_pdata);
329
Etienne Carriereeeaf2822021-03-08 22:38:09 +0100330 ut_assertok(regulator_set_value(regul0_dev, uc_pdata->min_uV));
Etienne Carriere09665cb2022-02-21 09:22:39 +0100331 ut_asserteq(agent->voltd[0].voltage_uv, uc_pdata->min_uV);
Etienne Carriereb8f15cd2021-03-08 22:38:07 +0100332
Etienne Carriereeeaf2822021-03-08 22:38:09 +0100333 ut_assert(regulator_get_value(regul0_dev) == uc_pdata->min_uV);
Etienne Carriereb8f15cd2021-03-08 22:38:07 +0100334
Etienne Carriereeeaf2822021-03-08 22:38:09 +0100335 ut_assertok(regulator_set_value(regul0_dev, uc_pdata->max_uV));
Etienne Carriere09665cb2022-02-21 09:22:39 +0100336 ut_asserteq(agent->voltd[0].voltage_uv, uc_pdata->max_uV);
Etienne Carriereb8f15cd2021-03-08 22:38:07 +0100337
Etienne Carriereeeaf2822021-03-08 22:38:09 +0100338 ut_assert(regulator_get_value(regul0_dev) == uc_pdata->max_uV);
Etienne Carriereb8f15cd2021-03-08 22:38:07 +0100339
340 /* Enable/disable SCMI voltage domains */
341 ut_assertok(regulator_set_enable(scmi_devices->regul[0], false));
342 ut_assertok(regulator_set_enable(scmi_devices->regul[1], false));
Etienne Carriere09665cb2022-02-21 09:22:39 +0100343 ut_assert(!agent->voltd[0].enabled);
344 ut_assert(!agent->voltd[1].enabled);
Etienne Carriereb8f15cd2021-03-08 22:38:07 +0100345
346 ut_assertok(regulator_set_enable(scmi_devices->regul[0], true));
Etienne Carriere09665cb2022-02-21 09:22:39 +0100347 ut_assert(agent->voltd[0].enabled);
348 ut_assert(!agent->voltd[1].enabled);
Etienne Carriereb8f15cd2021-03-08 22:38:07 +0100349
350 ut_assertok(regulator_set_enable(scmi_devices->regul[1], true));
Etienne Carriere09665cb2022-02-21 09:22:39 +0100351 ut_assert(agent->voltd[0].enabled);
352 ut_assert(agent->voltd[1].enabled);
Etienne Carriereb8f15cd2021-03-08 22:38:07 +0100353
354 ut_assertok(regulator_set_enable(scmi_devices->regul[0], false));
Etienne Carriere09665cb2022-02-21 09:22:39 +0100355 ut_assert(!agent->voltd[0].enabled);
356 ut_assert(agent->voltd[1].enabled);
Etienne Carriereb8f15cd2021-03-08 22:38:07 +0100357
358 return release_sandbox_scmi_test_devices(uts, dev);
359}
360DM_TEST(dm_test_scmi_voltage_domains, UT_TESTF_SCAN_FDT);