Andrew Geissler | ea144b03 | 2023-01-27 16:03:57 -0600 | [diff] [blame^] | 1 | From de26427c9f9b450ab4a18352fa51f46b3b585bc1 Mon Sep 17 00:00:00 2001 |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 2 | From: Abdellatif El Khlifi <abdellatif.elkhlifi@arm.com> |
| 3 | Date: Mon, 6 Jun 2022 17:26:06 +0100 |
Andrew Geissler | ea144b03 | 2023-01-27 16:03:57 -0600 | [diff] [blame^] | 4 | Subject: [PATCH 07/25] arm_ffa: introduce Sandbox test cases for UCLASS_FFA |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 5 | |
| 6 | Add functional test cases for the FF-A core driver |
| 7 | |
| 8 | These tests rely on the FF-A Sandbox driver which helps in |
| 9 | inspecting the FF-A core driver. |
| 10 | |
| 11 | Signed-off-by: Abdellatif El Khlifi <abdellatif.elkhlifi@arm.com> |
Andrew Geissler | ea144b03 | 2023-01-27 16:03:57 -0600 | [diff] [blame^] | 12 | Cc: Tom Rini <trini@konsulko.com> |
| 13 | Cc: Simon Glass <sjg@chromium.org> |
| 14 | Cc: Ilias Apalodimas <ilias.apalodimas@linaro.org> |
| 15 | Cc: Jens Wiklander <jens.wiklander@linaro.org> |
| 16 | Upstream-Status: Submitted [cover letter: https://lore.kernel.org/all/20221122131751.22747-1-abdellatif.elkhlifi@arm.com/] |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 17 | |
| 18 | Changelog: |
| 19 | =============== |
| 20 | |
Andrew Geissler | ea144b03 | 2023-01-27 16:03:57 -0600 | [diff] [blame^] | 21 | v8: |
| 22 | |
| 23 | * update partition_info_get() second argument to be an SP count |
| 24 | * pass NULL device pointer to the FF-A bus discovery and operations |
| 25 | |
| 26 | v7: set the tests to use 64-bit direct messaging |
| 27 | |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 28 | v4: align sandbox tests with the new FF-A driver interfaces |
| 29 | and new way of error handling |
| 30 | |
| 31 | v1: introduce sandbox tests |
Andrew Geissler | ea144b03 | 2023-01-27 16:03:57 -0600 | [diff] [blame^] | 32 | --- |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 33 | MAINTAINERS | 1 + |
Andrew Geissler | ea144b03 | 2023-01-27 16:03:57 -0600 | [diff] [blame^] | 34 | test/dm/Makefile | 2 + |
| 35 | test/dm/ffa.c | 392 +++++++++++++++++++++++++++++++++++++++++++++++ |
| 36 | 3 files changed, 395 insertions(+) |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 37 | create mode 100644 test/dm/ffa.c |
| 38 | |
| 39 | diff --git a/MAINTAINERS b/MAINTAINERS |
Andrew Geissler | ea144b03 | 2023-01-27 16:03:57 -0600 | [diff] [blame^] | 40 | index 23cebbd526..e682db8d8f 100644 |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 41 | --- a/MAINTAINERS |
| 42 | +++ b/MAINTAINERS |
Andrew Geissler | ea144b03 | 2023-01-27 16:03:57 -0600 | [diff] [blame^] | 43 | @@ -256,6 +256,7 @@ F: doc/arch/arm64.ffa.rst |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 44 | F: drivers/firmware/arm-ffa/ |
| 45 | F: include/arm_ffa.h |
| 46 | F: include/sandbox_arm_ffa.h |
| 47 | +F: test/dm/ffa.c |
| 48 | |
| 49 | ARM FREESCALE IMX |
| 50 | M: Stefano Babic <sbabic@denx.de> |
| 51 | diff --git a/test/dm/Makefile b/test/dm/Makefile |
Andrew Geissler | ea144b03 | 2023-01-27 16:03:57 -0600 | [diff] [blame^] | 52 | index 7543df8823..e5a791768e 100644 |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 53 | --- a/test/dm/Makefile |
| 54 | +++ b/test/dm/Makefile |
Andrew Geissler | ea144b03 | 2023-01-27 16:03:57 -0600 | [diff] [blame^] | 55 | @@ -1,6 +1,7 @@ |
| 56 | # SPDX-License-Identifier: GPL-2.0+ |
| 57 | # |
| 58 | # Copyright (c) 2013 Google, Inc |
| 59 | +# (C) Copyright 2022 ARM Limited |
| 60 | |
| 61 | obj-$(CONFIG_UT_DM) += test-dm.o |
| 62 | |
| 63 | @@ -81,6 +82,7 @@ obj-$(CONFIG_POWER_DOMAIN) += power-domain.o |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 64 | obj-$(CONFIG_ACPI_PMC) += pmc.o |
| 65 | obj-$(CONFIG_DM_PMIC) += pmic.o |
| 66 | obj-$(CONFIG_DM_PWM) += pwm.o |
| 67 | +obj-$(CONFIG_SANDBOX_FFA) += ffa.o |
| 68 | obj-$(CONFIG_QFW) += qfw.o |
| 69 | obj-$(CONFIG_RAM) += ram.o |
| 70 | obj-y += regmap.o |
| 71 | diff --git a/test/dm/ffa.c b/test/dm/ffa.c |
| 72 | new file mode 100644 |
Andrew Geissler | ea144b03 | 2023-01-27 16:03:57 -0600 | [diff] [blame^] | 73 | index 0000000000..128d8626a7 |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 74 | --- /dev/null |
| 75 | +++ b/test/dm/ffa.c |
Andrew Geissler | ea144b03 | 2023-01-27 16:03:57 -0600 | [diff] [blame^] | 76 | @@ -0,0 +1,392 @@ |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 77 | +// SPDX-License-Identifier: GPL-2.0+ |
| 78 | +/* |
| 79 | + * Functional tests for UCLASS_FFA class |
| 80 | + * |
| 81 | + * (C) Copyright 2022 ARM Limited |
| 82 | + * Abdellatif El Khlifi <abdellatif.elkhlifi@arm.com> |
| 83 | + */ |
| 84 | + |
| 85 | +#include <common.h> |
| 86 | +#include <console.h> |
| 87 | +#include <dm.h> |
| 88 | +#include <dm/test.h> |
| 89 | +#include "../../drivers/firmware/arm-ffa/sandbox_arm_ffa_prv.h" |
| 90 | +#include <sandbox_arm_ffa.h> |
| 91 | +#include <test/test.h> |
| 92 | +#include <test/ut.h> |
| 93 | + |
| 94 | +/* Macros */ |
| 95 | + |
| 96 | +#define LOG_MSG_SZ (100) |
| 97 | +#define LOG_CMD_SZ (LOG_MSG_SZ * 2) |
| 98 | + |
| 99 | +/* Functional tests for the UCLASS_FFA */ |
| 100 | + |
| 101 | +static int dm_test_ffa_log(struct unit_test_state *uts, char *msg) |
| 102 | +{ |
| 103 | + char cmd[LOG_CMD_SZ] = {0}; |
| 104 | + |
| 105 | + console_record_reset(); |
| 106 | + |
| 107 | + snprintf(cmd, LOG_CMD_SZ, "echo \"%s\"", msg); |
| 108 | + run_command(cmd, 0); |
| 109 | + |
| 110 | + ut_assert_console_end(); |
| 111 | + |
| 112 | + return CMD_RET_SUCCESS; |
| 113 | +} |
| 114 | + |
| 115 | +static int check_fwk_version(struct ffa_prvdata *prvdata, struct sandbox_ffa_prvdata *sdx_prvdata, |
| 116 | + struct unit_test_state *uts) |
| 117 | +{ |
| 118 | + if (prvdata->fwk_version != sdx_prvdata->fwk_version) { |
| 119 | + char msg[LOG_MSG_SZ] = {0}; |
| 120 | + |
| 121 | + snprintf(msg, LOG_MSG_SZ, |
| 122 | + "[%s]: Error: framework version: core = 0x%x , sandbox = 0x%x", __func__, |
| 123 | + prvdata->fwk_version, |
| 124 | + sdx_prvdata->fwk_version); |
| 125 | + |
| 126 | + dm_test_ffa_log(uts, msg); |
| 127 | + return CMD_RET_FAILURE; |
| 128 | + } |
| 129 | + return CMD_RET_SUCCESS; |
| 130 | +} |
| 131 | + |
| 132 | +static int check_endpoint_id(struct ffa_prvdata *prvdata, struct unit_test_state *uts) |
| 133 | +{ |
| 134 | + if (prvdata->id) { |
| 135 | + char msg[LOG_MSG_SZ] = {0}; |
| 136 | + |
| 137 | + snprintf(msg, LOG_MSG_SZ, |
| 138 | + "[%s]: Error: endpoint id: core = 0x%x", __func__, prvdata->id); |
| 139 | + dm_test_ffa_log(uts, msg); |
| 140 | + return CMD_RET_FAILURE; |
| 141 | + } |
| 142 | + return CMD_RET_SUCCESS; |
| 143 | +} |
| 144 | + |
| 145 | +static int check_core_dev(struct ffa_prvdata *prvdata, struct unit_test_state *uts) |
| 146 | +{ |
| 147 | + if (!prvdata->dev) { |
| 148 | + char msg[LOG_MSG_SZ] = {0}; |
| 149 | + |
| 150 | + snprintf(msg, LOG_MSG_SZ, "[%s]: Error: core device NULL", __func__); |
| 151 | + dm_test_ffa_log(uts, msg); |
| 152 | + return CMD_RET_FAILURE; |
| 153 | + } |
| 154 | + return CMD_RET_SUCCESS; |
| 155 | +} |
| 156 | + |
| 157 | +static int check_sandbox_dev(struct sandbox_ffa_prvdata *sdx_prvdata, struct unit_test_state *uts) |
| 158 | +{ |
| 159 | + if (!sdx_prvdata->dev) { |
| 160 | + char msg[LOG_MSG_SZ] = {0}; |
| 161 | + |
| 162 | + snprintf(msg, LOG_MSG_SZ, "[%s]: Error: sandbox device NULL", __func__); |
| 163 | + dm_test_ffa_log(uts, msg); |
| 164 | + return CMD_RET_FAILURE; |
| 165 | + } |
| 166 | + return CMD_RET_SUCCESS; |
| 167 | +} |
| 168 | + |
| 169 | +static int check_rxtxbuf(struct ffa_prvdata *prvdata, struct unit_test_state *uts) |
| 170 | +{ |
| 171 | + if (!prvdata->pair.rxbuf && prvdata->pair.txbuf) { |
| 172 | + char msg[LOG_MSG_SZ] = {0}; |
| 173 | + |
| 174 | + snprintf(msg, LOG_MSG_SZ, "[%s]: Error: rxbuf = 0x%llx txbuf = 0x%llx", __func__, |
| 175 | + prvdata->pair.rxbuf, |
| 176 | + prvdata->pair.txbuf); |
| 177 | + dm_test_ffa_log(uts, msg); |
| 178 | + return CMD_RET_FAILURE; |
| 179 | + } |
| 180 | + return CMD_RET_SUCCESS; |
| 181 | +} |
| 182 | + |
| 183 | +static int check_features(struct ffa_prvdata *prvdata, struct unit_test_state *uts) |
| 184 | +{ |
| 185 | + char msg[LOG_MSG_SZ] = {0}; |
| 186 | + |
| 187 | + if (prvdata->pair.rxtx_min_pages != RXTX_4K && |
| 188 | + prvdata->pair.rxtx_min_pages != RXTX_16K && |
| 189 | + prvdata->pair.rxtx_min_pages != RXTX_64K) { |
| 190 | + snprintf(msg, |
| 191 | + LOG_MSG_SZ, |
| 192 | + "[%s]: Error: FFA_RXTX_MAP features = 0x%lx", |
| 193 | + __func__, |
| 194 | + prvdata->pair.rxtx_min_pages); |
| 195 | + dm_test_ffa_log(uts, msg); |
| 196 | + return CMD_RET_FAILURE; |
| 197 | + } |
| 198 | + |
| 199 | + return CMD_RET_SUCCESS; |
| 200 | +} |
| 201 | + |
| 202 | +static int check_rxbuf_mapped_flag(u32 queried_func_id, |
| 203 | + u8 rxbuf_mapped, |
| 204 | + struct unit_test_state *uts) |
| 205 | +{ |
| 206 | + char msg[LOG_MSG_SZ] = {0}; |
| 207 | + |
| 208 | + switch (queried_func_id) { |
| 209 | + case FFA_RXTX_MAP: |
| 210 | + { |
| 211 | + if (rxbuf_mapped) |
| 212 | + return CMD_RET_SUCCESS; |
| 213 | + break; |
| 214 | + } |
| 215 | + case FFA_RXTX_UNMAP: |
| 216 | + { |
| 217 | + if (!rxbuf_mapped) |
| 218 | + return CMD_RET_SUCCESS; |
| 219 | + break; |
| 220 | + } |
| 221 | + default: |
| 222 | + return CMD_RET_FAILURE; |
| 223 | + } |
| 224 | + |
| 225 | + snprintf(msg, LOG_MSG_SZ, "[%s]: Error: %s mapping issue", __func__, |
| 226 | + (queried_func_id == FFA_RXTX_MAP ? "FFA_RXTX_MAP" : "FFA_RXTX_UNMAP")); |
| 227 | + dm_test_ffa_log(uts, msg); |
| 228 | + |
| 229 | + return CMD_RET_FAILURE; |
| 230 | +} |
| 231 | + |
| 232 | +static int check_rxbuf_release_flag(u8 rxbuf_owned, struct unit_test_state *uts) |
| 233 | +{ |
| 234 | + if (rxbuf_owned) { |
| 235 | + char msg[LOG_MSG_SZ] = {0}; |
| 236 | + |
| 237 | + snprintf(msg, LOG_MSG_SZ, "[%s]: Error: RX buffer not released", __func__); |
| 238 | + dm_test_ffa_log(uts, msg); |
| 239 | + return CMD_RET_FAILURE; |
| 240 | + } |
| 241 | + return CMD_RET_SUCCESS; |
| 242 | +} |
| 243 | + |
| 244 | +static int test_ffa_msg_send_direct_req(u16 part_id, struct unit_test_state *uts) |
| 245 | +{ |
| 246 | + struct ffa_send_direct_data msg = {0}; |
| 247 | + u8 cnt; |
| 248 | + |
Andrew Geissler | ea144b03 | 2023-01-27 16:03:57 -0600 | [diff] [blame^] | 249 | + ut_assertok(ffa_bus_ops_get()->sync_send_receive(NULL, part_id, &msg, 1)); |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 250 | + |
| 251 | + for (cnt = 0; cnt < sizeof(struct ffa_send_direct_data) / sizeof(u64); cnt++) |
| 252 | + ut_assertok(((u64 *)&msg)[cnt] != 0xffffffffffffffff); |
| 253 | + |
| 254 | + return CMD_RET_SUCCESS; |
| 255 | +} |
| 256 | + |
| 257 | +static int test_partitions_and_comms(const char *service_uuid, |
| 258 | + struct sandbox_ffa_prvdata *sdx_prvdata, |
| 259 | + struct unit_test_state *uts) |
| 260 | +{ |
Andrew Geissler | ea144b03 | 2023-01-27 16:03:57 -0600 | [diff] [blame^] | 261 | + u32 count = 0; |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 262 | + struct ffa_partition_info *parts_info; |
| 263 | + u32 info_idx, exp_info_idx; |
| 264 | + int ret; |
| 265 | + |
| 266 | + /* |
| 267 | + * get from the driver the count of the SPs matching the UUID |
| 268 | + */ |
Andrew Geissler | ea144b03 | 2023-01-27 16:03:57 -0600 | [diff] [blame^] | 269 | + ret = ffa_bus_ops_get()->partition_info_get(NULL, service_uuid, &count, NULL); |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 270 | + /* make sure partitions are detected */ |
| 271 | + ut_assertok(ret != 0); |
| 272 | + ut_assertok(count != SANDBOX_SP_COUNT_PER_VALID_SERVICE); |
| 273 | + |
| 274 | + /* |
| 275 | + * pre-allocate a buffer to be filled by the driver |
| 276 | + * with ffa_partition_info structs |
| 277 | + */ |
| 278 | + |
| 279 | + parts_info = calloc(count, sizeof(struct ffa_partition_info)); |
| 280 | + ut_assertok(!parts_info); |
| 281 | + |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 282 | + /* |
| 283 | + * ask the driver to fill the buffer with the SPs info |
| 284 | + */ |
Andrew Geissler | ea144b03 | 2023-01-27 16:03:57 -0600 | [diff] [blame^] | 285 | + ret = ffa_bus_ops_get()->partition_info_get(NULL, service_uuid, &count, parts_info); |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 286 | + if (ret != 0) { |
| 287 | + free(parts_info); |
| 288 | + ut_assertok(ret != 0); |
| 289 | + } |
| 290 | + |
| 291 | + /* |
| 292 | + * SPs found , verify the partitions information |
| 293 | + */ |
| 294 | + |
| 295 | + ret = CMD_RET_FAILURE; |
| 296 | + |
| 297 | + for (info_idx = 0; info_idx < count ; info_idx++) { |
| 298 | + for (exp_info_idx = 0; |
| 299 | + exp_info_idx < sdx_prvdata->partitions.count; |
| 300 | + exp_info_idx++) { |
| 301 | + if (parts_info[info_idx].id == |
| 302 | + sdx_prvdata->partitions.descs[exp_info_idx].info.id) { |
| 303 | + ret = memcmp(&parts_info[info_idx], |
| 304 | + &sdx_prvdata->partitions.descs[exp_info_idx] |
| 305 | + .info, |
| 306 | + sizeof(struct ffa_partition_info)); |
| 307 | + if (ret) |
| 308 | + free(parts_info); |
| 309 | + ut_assertok(ret != 0); |
| 310 | + /* send and receive data from the current partition */ |
| 311 | + test_ffa_msg_send_direct_req(parts_info[info_idx].id, uts); |
| 312 | + } |
| 313 | + ret = CMD_RET_SUCCESS; |
| 314 | + } |
| 315 | + } |
| 316 | + |
| 317 | + free(parts_info); |
| 318 | + |
| 319 | + /* Verify expected partitions found in the emulated secure world*/ |
| 320 | + ut_assertok(ret != CMD_RET_SUCCESS); |
| 321 | + |
| 322 | + return CMD_RET_SUCCESS; |
| 323 | +} |
| 324 | + |
| 325 | +static int dm_test_ffa_ack(struct unit_test_state *uts) |
| 326 | +{ |
| 327 | + struct ffa_prvdata *prvdata = NULL; |
| 328 | + struct sandbox_ffa_prvdata *sdx_prvdata = NULL; |
| 329 | + struct ffa_sandbox_data func_data = {0}; |
| 330 | + u8 rxbuf_flag = 0; |
| 331 | + const char *svc1_uuid = SANDBOX_SERVICE1_UUID; |
| 332 | + const char *svc2_uuid = SANDBOX_SERVICE2_UUID; |
| 333 | + int ret; |
| 334 | + |
| 335 | + /* test probing FF-A devices */ |
Andrew Geissler | ea144b03 | 2023-01-27 16:03:57 -0600 | [diff] [blame^] | 336 | + ut_assertok(ffa_bus_discover(NULL)); |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 337 | + |
| 338 | + /* get a pointer to the FF-A core and sandbox drivers private data */ |
| 339 | + func_data.data0 = &prvdata; |
| 340 | + func_data.data0_size = sizeof(prvdata); |
| 341 | + func_data.data1 = &sdx_prvdata; |
| 342 | + func_data.data1_size = sizeof(sdx_prvdata); |
| 343 | + |
| 344 | + ut_assertok(sandbox_ffa_query_core_state(FFA_VERSION, &func_data)); |
| 345 | + |
| 346 | + /* make sure private data pointers are retrieved */ |
| 347 | + ut_assertok(prvdata == 0); |
| 348 | + ut_assertok(sdx_prvdata == 0); |
| 349 | + |
| 350 | + /* make sure dev devices created */ |
| 351 | + ut_assertok(check_core_dev(prvdata, uts)); |
| 352 | + ut_assertok(check_sandbox_dev(sdx_prvdata, uts)); |
| 353 | + |
| 354 | + /* test FFA_VERSION */ |
| 355 | + ut_assertok(check_fwk_version(prvdata, sdx_prvdata, uts)); |
| 356 | + |
| 357 | + /* test FFA_ID_GET */ |
| 358 | + ut_assertok(check_endpoint_id(prvdata, uts)); |
| 359 | + |
| 360 | + /* test FFA_FEATURES */ |
| 361 | + ut_assertok(check_features(prvdata, uts)); |
| 362 | + |
| 363 | + /* test core RX/TX buffers */ |
| 364 | + ut_assertok(check_rxtxbuf(prvdata, uts)); |
| 365 | + |
| 366 | + /* test FFA_RXTX_MAP */ |
| 367 | + func_data.data0 = &rxbuf_flag; |
| 368 | + func_data.data0_size = sizeof(rxbuf_flag); |
| 369 | + |
| 370 | + rxbuf_flag = 0; |
| 371 | + ut_assertok(sandbox_ffa_query_core_state(FFA_RXTX_MAP, &func_data)); |
| 372 | + ut_assertok(check_rxbuf_mapped_flag(FFA_RXTX_MAP, rxbuf_flag, uts)); |
| 373 | + |
| 374 | + /* FFA_PARTITION_INFO_GET / FFA_MSG_SEND_DIRECT_REQ */ |
| 375 | + ret = test_partitions_and_comms(svc1_uuid, sdx_prvdata, uts); |
| 376 | + ut_assertok(ret != CMD_RET_SUCCESS); |
| 377 | + |
| 378 | + /* test FFA_RX_RELEASE */ |
| 379 | + rxbuf_flag = 1; |
| 380 | + ut_assertok(sandbox_ffa_query_core_state(FFA_RX_RELEASE, &func_data)); |
| 381 | + ut_assertok(check_rxbuf_release_flag(rxbuf_flag, uts)); |
| 382 | + |
| 383 | + /* FFA_PARTITION_INFO_GET / FFA_MSG_SEND_DIRECT_REQ */ |
| 384 | + ret = test_partitions_and_comms(svc2_uuid, sdx_prvdata, uts); |
| 385 | + ut_assertok(ret != CMD_RET_SUCCESS); |
| 386 | + |
| 387 | + /* test FFA_RX_RELEASE */ |
| 388 | + rxbuf_flag = 1; |
| 389 | + ut_assertok(sandbox_ffa_query_core_state(FFA_RX_RELEASE, &func_data)); |
| 390 | + ut_assertok(check_rxbuf_release_flag(rxbuf_flag, uts)); |
| 391 | + |
| 392 | + /* test FFA_RXTX_UNMAP */ |
Andrew Geissler | ea144b03 | 2023-01-27 16:03:57 -0600 | [diff] [blame^] | 393 | + ut_assertok(ffa_bus_ops_get()->rxtx_unmap(NULL)); |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 394 | + |
| 395 | + rxbuf_flag = 1; |
| 396 | + ut_assertok(sandbox_ffa_query_core_state(FFA_RXTX_UNMAP, &func_data)); |
| 397 | + ut_assertok(check_rxbuf_mapped_flag(FFA_RXTX_UNMAP, rxbuf_flag, uts)); |
| 398 | + |
| 399 | + return CMD_RET_SUCCESS; |
| 400 | +} |
| 401 | + |
| 402 | +DM_TEST(dm_test_ffa_ack, UT_TESTF_SCAN_FDT | UT_TESTF_CONSOLE_REC); |
| 403 | + |
| 404 | +static int dm_test_ffa_nack(struct unit_test_state *uts) |
| 405 | +{ |
| 406 | + struct ffa_prvdata *prvdata = NULL; |
| 407 | + struct sandbox_ffa_prvdata *sdx_prvdata = NULL; |
| 408 | + struct ffa_sandbox_data func_data = {0}; |
| 409 | + const char *valid_svc_uuid = SANDBOX_SERVICE1_UUID; |
| 410 | + const char *unvalid_svc_uuid = SANDBOX_SERVICE3_UUID; |
| 411 | + const char *unvalid_svc_uuid_str = SANDBOX_SERVICE4_UUID; |
| 412 | + struct ffa_send_direct_data msg = {0}; |
| 413 | + int ret; |
| 414 | + u32 count = 0; |
| 415 | + u16 part_id = 0; |
| 416 | + |
| 417 | + /* test probing FF-A devices */ |
Andrew Geissler | ea144b03 | 2023-01-27 16:03:57 -0600 | [diff] [blame^] | 418 | + ut_assertok(ffa_bus_discover(NULL)); |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 419 | + |
| 420 | + /* get a pointer to the FF-A core and sandbox drivers private data */ |
| 421 | + func_data.data0 = &prvdata; |
| 422 | + func_data.data0_size = sizeof(prvdata); |
| 423 | + func_data.data1 = &sdx_prvdata; |
| 424 | + func_data.data1_size = sizeof(sdx_prvdata); |
| 425 | + |
| 426 | + ut_assertok(sandbox_ffa_query_core_state(FFA_VERSION, &func_data)); |
| 427 | + |
| 428 | + /* make sure private data pointers are retrieved */ |
| 429 | + ut_assertok(prvdata == 0); |
| 430 | + ut_assertok(sdx_prvdata == 0); |
| 431 | + |
| 432 | + /* make sure dev devices created */ |
| 433 | + ut_assertok(check_core_dev(prvdata, uts)); |
| 434 | + ut_assertok(check_sandbox_dev(sdx_prvdata, uts)); |
| 435 | + |
| 436 | + /* query partitions count using invalid arguments */ |
Andrew Geissler | ea144b03 | 2023-01-27 16:03:57 -0600 | [diff] [blame^] | 437 | + ret = ffa_bus_ops_get()->partition_info_get(NULL, unvalid_svc_uuid, NULL, NULL); |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 438 | + ut_assertok(ret != -EINVAL); |
| 439 | + |
| 440 | + /* query partitions count using an invalid UUID string */ |
Andrew Geissler | ea144b03 | 2023-01-27 16:03:57 -0600 | [diff] [blame^] | 441 | + ret = ffa_bus_ops_get()->partition_info_get(NULL, unvalid_svc_uuid_str, &count, NULL); |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 442 | + ut_assertok(ret != -EINVAL); |
| 443 | + |
| 444 | + /* query partitions count using an invalid UUID (no matching SP) */ |
| 445 | + count = 0; |
Andrew Geissler | ea144b03 | 2023-01-27 16:03:57 -0600 | [diff] [blame^] | 446 | + ret = ffa_bus_ops_get()->partition_info_get(NULL, unvalid_svc_uuid, &count, NULL); |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 447 | + ut_assertok(count != 0); |
| 448 | + |
| 449 | + /* query partitions count using a valid UUID */ |
| 450 | + count = 0; |
Andrew Geissler | ea144b03 | 2023-01-27 16:03:57 -0600 | [diff] [blame^] | 451 | + ret = ffa_bus_ops_get()->partition_info_get(NULL, valid_svc_uuid, &count, NULL); |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 452 | + /* make sure partitions are detected */ |
| 453 | + ut_assertok(ret != 0); |
| 454 | + ut_assertok(count != SANDBOX_SP_COUNT_PER_VALID_SERVICE); |
| 455 | + |
| 456 | + /* send data to an invalid partition */ |
Andrew Geissler | ea144b03 | 2023-01-27 16:03:57 -0600 | [diff] [blame^] | 457 | + ret = ffa_bus_ops_get()->sync_send_receive(NULL, part_id, &msg, 1); |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 458 | + ut_assertok(ret != -EINVAL); |
| 459 | + |
| 460 | + /* send data to a valid partition */ |
| 461 | + part_id = prvdata->partitions.descs[0].info.id; |
Andrew Geissler | ea144b03 | 2023-01-27 16:03:57 -0600 | [diff] [blame^] | 462 | + ret = ffa_bus_ops_get()->sync_send_receive(NULL, part_id, &msg, 1); |
Patrick Williams | 8dd6848 | 2022-10-04 07:57:18 -0500 | [diff] [blame] | 463 | + ut_assertok(ret != 0); |
| 464 | + |
| 465 | + return CMD_RET_SUCCESS; |
| 466 | +} |
| 467 | + |
| 468 | +DM_TEST(dm_test_ffa_nack, UT_TESTF_SCAN_FDT | UT_TESTF_CONSOLE_REC); |
| 469 | -- |
| 470 | 2.17.1 |
| 471 | |