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