1 /* 2 * Copyright (c) 2022-2024, ARM Limited and Contributors. All rights reserved. 3 * 4 * SPDX-License-Identifier: BSD-3-Clause 5 */ 6 7 #include <assert.h> 8 #include <errno.h> 9 #include <stdio.h> 10 11 #include <arch_helpers.h> 12 #include <bl31/bl31.h> 13 #include <bl31/ehf.h> 14 #include <bl31/interrupt_mgmt.h> 15 #include <common/debug.h> 16 #include <common/fdt_wrappers.h> 17 #include <common/runtime_svc.h> 18 #include <common/uuid.h> 19 #include <lib/el3_runtime/context_mgmt.h> 20 #include <lib/smccc.h> 21 #include <lib/utils.h> 22 #include <lib/xlat_tables/xlat_tables_v2.h> 23 #include <libfdt.h> 24 #include <plat/common/platform.h> 25 #include <services/el3_spmc_logical_sp.h> 26 #include <services/ffa_svc.h> 27 #include <services/spmc_svc.h> 28 #include <services/spmd_svc.h> 29 #include "spmc.h" 30 #include "spmc_shared_mem.h" 31 32 #include <platform_def.h> 33 34 /* FFA_MEM_PERM_* helpers */ 35 #define FFA_MEM_PERM_MASK U(7) 36 #define FFA_MEM_PERM_DATA_MASK U(3) 37 #define FFA_MEM_PERM_DATA_SHIFT U(0) 38 #define FFA_MEM_PERM_DATA_NA U(0) 39 #define FFA_MEM_PERM_DATA_RW U(1) 40 #define FFA_MEM_PERM_DATA_RES U(2) 41 #define FFA_MEM_PERM_DATA_RO U(3) 42 #define FFA_MEM_PERM_INST_EXEC (U(0) << 2) 43 #define FFA_MEM_PERM_INST_NON_EXEC (U(1) << 2) 44 45 /* Declare the maximum number of SPs and El3 LPs. */ 46 #define MAX_SP_LP_PARTITIONS SECURE_PARTITION_COUNT + MAX_EL3_LP_DESCS_COUNT 47 48 /* 49 * Allocate a secure partition descriptor to describe each SP in the system that 50 * does not reside at EL3. 51 */ 52 static struct secure_partition_desc sp_desc[SECURE_PARTITION_COUNT]; 53 54 /* 55 * Allocate an NS endpoint descriptor to describe each VM and the Hypervisor in 56 * the system that interacts with a SP. It is used to track the Hypervisor 57 * buffer pair, version and ID for now. It could be extended to track VM 58 * properties when the SPMC supports indirect messaging. 59 */ 60 static struct ns_endpoint_desc ns_ep_desc[NS_PARTITION_COUNT]; 61 62 static uint64_t spmc_sp_interrupt_handler(uint32_t id, 63 uint32_t flags, 64 void *handle, 65 void *cookie); 66 67 /* 68 * Helper function to obtain the array storing the EL3 69 * Logical Partition descriptors. 70 */ 71 struct el3_lp_desc *get_el3_lp_array(void) 72 { 73 return (struct el3_lp_desc *) EL3_LP_DESCS_START; 74 } 75 76 /* 77 * Helper function to obtain the descriptor of the last SP to whom control was 78 * handed to on this physical cpu. Currently, we assume there is only one SP. 79 * TODO: Expand to track multiple partitions when required. 80 */ 81 struct secure_partition_desc *spmc_get_current_sp_ctx(void) 82 { 83 return &(sp_desc[ACTIVE_SP_DESC_INDEX]); 84 } 85 86 /* 87 * Helper function to obtain the execution context of an SP on the 88 * current physical cpu. 89 */ 90 struct sp_exec_ctx *spmc_get_sp_ec(struct secure_partition_desc *sp) 91 { 92 return &(sp->ec[get_ec_index(sp)]); 93 } 94 95 /* Helper function to get pointer to SP context from its ID. */ 96 struct secure_partition_desc *spmc_get_sp_ctx(uint16_t id) 97 { 98 /* Check for Secure World Partitions. */ 99 for (unsigned int i = 0U; i < SECURE_PARTITION_COUNT; i++) { 100 if (sp_desc[i].sp_id == id) { 101 return &(sp_desc[i]); 102 } 103 } 104 return NULL; 105 } 106 107 /* 108 * Helper function to obtain the descriptor of the Hypervisor or OS kernel. 109 * We assume that the first descriptor is reserved for this entity. 110 */ 111 struct ns_endpoint_desc *spmc_get_hyp_ctx(void) 112 { 113 return &(ns_ep_desc[0]); 114 } 115 116 /* 117 * Helper function to obtain the RX/TX buffer pair descriptor of the Hypervisor 118 * or OS kernel in the normal world or the last SP that was run. 119 */ 120 struct mailbox *spmc_get_mbox_desc(bool secure_origin) 121 { 122 /* Obtain the RX/TX buffer pair descriptor. */ 123 if (secure_origin) { 124 return &(spmc_get_current_sp_ctx()->mailbox); 125 } else { 126 return &(spmc_get_hyp_ctx()->mailbox); 127 } 128 } 129 130 /****************************************************************************** 131 * This function returns to the place where spmc_sp_synchronous_entry() was 132 * called originally. 133 ******************************************************************************/ 134 __dead2 void spmc_sp_synchronous_exit(struct sp_exec_ctx *ec, uint64_t rc) 135 { 136 /* 137 * The SPM must have initiated the original request through a 138 * synchronous entry into the secure partition. Jump back to the 139 * original C runtime context with the value of rc in x0; 140 */ 141 spm_secure_partition_exit(ec->c_rt_ctx, rc); 142 143 panic(); 144 } 145 146 /******************************************************************************* 147 * Return FFA_ERROR with specified error code. 148 ******************************************************************************/ 149 uint64_t spmc_ffa_error_return(void *handle, int error_code) 150 { 151 SMC_RET8(handle, FFA_ERROR, 152 FFA_TARGET_INFO_MBZ, error_code, 153 FFA_PARAM_MBZ, FFA_PARAM_MBZ, FFA_PARAM_MBZ, 154 FFA_PARAM_MBZ, FFA_PARAM_MBZ); 155 } 156 157 /****************************************************************************** 158 * Helper function to validate a secure partition ID to ensure it does not 159 * conflict with any other FF-A component and follows the convention to 160 * indicate it resides within the secure world. 161 ******************************************************************************/ 162 bool is_ffa_secure_id_valid(uint16_t partition_id) 163 { 164 struct el3_lp_desc *el3_lp_descs = get_el3_lp_array(); 165 166 /* Ensure the ID is not the invalid partition ID. */ 167 if (partition_id == INV_SP_ID) { 168 return false; 169 } 170 171 /* Ensure the ID is not the SPMD ID. */ 172 if (partition_id == SPMD_DIRECT_MSG_ENDPOINT_ID) { 173 return false; 174 } 175 176 /* 177 * Ensure the ID follows the convention to indicate it resides 178 * in the secure world. 179 */ 180 if (!ffa_is_secure_world_id(partition_id)) { 181 return false; 182 } 183 184 /* Ensure we don't conflict with the SPMC partition ID. */ 185 if (partition_id == FFA_SPMC_ID) { 186 return false; 187 } 188 189 /* Ensure we do not already have an SP context with this ID. */ 190 if (spmc_get_sp_ctx(partition_id)) { 191 return false; 192 } 193 194 /* Ensure we don't clash with any Logical SP's. */ 195 for (unsigned int i = 0U; i < EL3_LP_DESCS_COUNT; i++) { 196 if (el3_lp_descs[i].sp_id == partition_id) { 197 return false; 198 } 199 } 200 201 return true; 202 } 203 204 /******************************************************************************* 205 * This function either forwards the request to the other world or returns 206 * with an ERET depending on the source of the call. 207 * We can assume that the destination is for an entity at a lower exception 208 * level as any messages destined for a logical SP resident in EL3 will have 209 * already been taken care of by the SPMC before entering this function. 210 ******************************************************************************/ 211 static uint64_t spmc_smc_return(uint32_t smc_fid, 212 bool secure_origin, 213 uint64_t x1, 214 uint64_t x2, 215 uint64_t x3, 216 uint64_t x4, 217 void *handle, 218 void *cookie, 219 uint64_t flags, 220 uint16_t dst_id) 221 { 222 /* If the destination is in the normal world always go via the SPMD. */ 223 if (ffa_is_normal_world_id(dst_id)) { 224 return spmd_smc_handler(smc_fid, x1, x2, x3, x4, 225 cookie, handle, flags); 226 } 227 /* 228 * If the caller is secure and we want to return to the secure world, 229 * ERET directly. 230 */ 231 else if (secure_origin && ffa_is_secure_world_id(dst_id)) { 232 SMC_RET5(handle, smc_fid, x1, x2, x3, x4); 233 } 234 /* If we originated in the normal world then switch contexts. */ 235 else if (!secure_origin && ffa_is_secure_world_id(dst_id)) { 236 return spmd_smc_switch_state(smc_fid, secure_origin, x1, x2, 237 x3, x4, handle, flags); 238 } else { 239 /* Unknown State. */ 240 panic(); 241 } 242 243 /* Shouldn't be Reached. */ 244 return 0; 245 } 246 247 /******************************************************************************* 248 * FF-A ABI Handlers. 249 ******************************************************************************/ 250 251 /******************************************************************************* 252 * Helper function to validate arg2 as part of a direct message. 253 ******************************************************************************/ 254 static inline bool direct_msg_validate_arg2(uint64_t x2) 255 { 256 /* Check message type. */ 257 if (x2 & FFA_FWK_MSG_BIT) { 258 /* We have a framework message, ensure it is a known message. */ 259 if (x2 & ~(FFA_FWK_MSG_MASK | FFA_FWK_MSG_BIT)) { 260 VERBOSE("Invalid message format 0x%lx.\n", x2); 261 return false; 262 } 263 } else { 264 /* We have a partition messages, ensure x2 is not set. */ 265 if (x2 != (uint64_t) 0) { 266 VERBOSE("Arg2 MBZ for partition messages. (0x%lx).\n", 267 x2); 268 return false; 269 } 270 } 271 return true; 272 } 273 274 /******************************************************************************* 275 * Helper function to validate the destination ID of a direct response. 276 ******************************************************************************/ 277 static bool direct_msg_validate_dst_id(uint16_t dst_id) 278 { 279 struct secure_partition_desc *sp; 280 281 /* Check if we're targeting a normal world partition. */ 282 if (ffa_is_normal_world_id(dst_id)) { 283 return true; 284 } 285 286 /* Or directed to the SPMC itself.*/ 287 if (dst_id == FFA_SPMC_ID) { 288 return true; 289 } 290 291 /* Otherwise ensure the SP exists. */ 292 sp = spmc_get_sp_ctx(dst_id); 293 if (sp != NULL) { 294 return true; 295 } 296 297 return false; 298 } 299 300 /******************************************************************************* 301 * Helper function to validate the response from a Logical Partition. 302 ******************************************************************************/ 303 static bool direct_msg_validate_lp_resp(uint16_t origin_id, uint16_t lp_id, 304 void *handle) 305 { 306 /* Retrieve populated Direct Response Arguments. */ 307 uint64_t smc_fid = SMC_GET_GP(handle, CTX_GPREG_X0); 308 uint64_t x1 = SMC_GET_GP(handle, CTX_GPREG_X1); 309 uint64_t x2 = SMC_GET_GP(handle, CTX_GPREG_X2); 310 uint16_t src_id = ffa_endpoint_source(x1); 311 uint16_t dst_id = ffa_endpoint_destination(x1); 312 313 if (src_id != lp_id) { 314 ERROR("Invalid EL3 LP source ID (0x%x).\n", src_id); 315 return false; 316 } 317 318 /* 319 * Check the destination ID is valid and ensure the LP is responding to 320 * the original request. 321 */ 322 if ((!direct_msg_validate_dst_id(dst_id)) || (dst_id != origin_id)) { 323 ERROR("Invalid EL3 LP destination ID (0x%x).\n", dst_id); 324 return false; 325 } 326 327 if ((smc_fid != FFA_MSG_SEND_DIRECT_RESP2_SMC64) && 328 !direct_msg_validate_arg2(x2)) { 329 ERROR("Invalid EL3 LP message encoding.\n"); 330 return false; 331 } 332 return true; 333 } 334 335 /******************************************************************************* 336 * Helper function to check that partition can receive direct msg or not. 337 ******************************************************************************/ 338 static bool direct_msg_receivable(uint32_t properties, uint16_t dir_req_fnum) 339 { 340 if ((dir_req_fnum == FFA_FNUM_MSG_SEND_DIRECT_REQ && 341 ((properties & FFA_PARTITION_DIRECT_REQ_RECV) == 0U)) || 342 (dir_req_fnum == FFA_FNUM_MSG_SEND_DIRECT_REQ2 && 343 ((properties & FFA_PARTITION_DIRECT_REQ2_RECV) == 0U))) { 344 return false; 345 } 346 347 return true; 348 } 349 350 /******************************************************************************* 351 * Handle direct request messages and route to the appropriate destination. 352 ******************************************************************************/ 353 static uint64_t direct_req_smc_handler(uint32_t smc_fid, 354 bool secure_origin, 355 uint64_t x1, 356 uint64_t x2, 357 uint64_t x3, 358 uint64_t x4, 359 void *cookie, 360 void *handle, 361 uint64_t flags) 362 { 363 uint16_t src_id = ffa_endpoint_source(x1); 364 uint16_t dst_id = ffa_endpoint_destination(x1); 365 uint16_t dir_req_funcid; 366 struct el3_lp_desc *el3_lp_descs; 367 struct secure_partition_desc *sp; 368 unsigned int idx; 369 370 dir_req_funcid = (smc_fid != FFA_MSG_SEND_DIRECT_REQ2_SMC64) ? 371 FFA_FNUM_MSG_SEND_DIRECT_REQ : FFA_FNUM_MSG_SEND_DIRECT_REQ2; 372 373 /* 374 * Sanity check for DIRECT_REQ: 375 * Check if arg2 has been populated correctly based on message type 376 */ 377 if ((dir_req_funcid == FFA_FNUM_MSG_SEND_DIRECT_REQ) && 378 !direct_msg_validate_arg2(x2)) { 379 return spmc_ffa_error_return(handle, FFA_ERROR_INVALID_PARAMETER); 380 } 381 382 /* Validate Sender is either the current SP or from the normal world. */ 383 if ((secure_origin && src_id != spmc_get_current_sp_ctx()->sp_id) || 384 (!secure_origin && !ffa_is_normal_world_id(src_id))) { 385 ERROR("Invalid direct request source ID (0x%x).\n", src_id); 386 return spmc_ffa_error_return(handle, 387 FFA_ERROR_INVALID_PARAMETER); 388 } 389 390 el3_lp_descs = get_el3_lp_array(); 391 392 /* Check if the request is destined for a Logical Partition. */ 393 for (unsigned int i = 0U; i < MAX_EL3_LP_DESCS_COUNT; i++) { 394 if (el3_lp_descs[i].sp_id == dst_id) { 395 if (!direct_msg_receivable(el3_lp_descs[i].properties, dir_req_funcid)) { 396 return spmc_ffa_error_return(handle, FFA_ERROR_DENIED); 397 } 398 399 uint64_t ret = el3_lp_descs[i].direct_req( 400 smc_fid, secure_origin, x1, x2, 401 x3, x4, cookie, handle, flags); 402 if (!direct_msg_validate_lp_resp(src_id, dst_id, 403 handle)) { 404 panic(); 405 } 406 407 /* Message checks out. */ 408 return ret; 409 } 410 } 411 412 /* 413 * If the request was not targeted to a LSP and from the secure world 414 * then it is invalid since a SP cannot call into the Normal world and 415 * there is no other SP to call into. If there are other SPs in future 416 * then the partition runtime model would need to be validated as well. 417 */ 418 if (secure_origin) { 419 VERBOSE("Direct request not supported to the Normal World.\n"); 420 return spmc_ffa_error_return(handle, 421 FFA_ERROR_INVALID_PARAMETER); 422 } 423 424 /* Check if the SP ID is valid. */ 425 sp = spmc_get_sp_ctx(dst_id); 426 if (sp == NULL) { 427 VERBOSE("Direct request to unknown partition ID (0x%x).\n", 428 dst_id); 429 return spmc_ffa_error_return(handle, 430 FFA_ERROR_INVALID_PARAMETER); 431 } 432 433 if (!direct_msg_receivable(sp->properties, dir_req_funcid)) { 434 return spmc_ffa_error_return(handle, FFA_ERROR_DENIED); 435 } 436 437 /* Protect the runtime state of a UP S-EL0 SP with a lock. */ 438 if (sp->runtime_el == S_EL0) { 439 spin_lock(&sp->rt_state_lock); 440 } 441 442 /* 443 * Check that the target execution context is in a waiting state before 444 * forwarding the direct request to it. 445 */ 446 idx = get_ec_index(sp); 447 if (sp->ec[idx].rt_state != RT_STATE_WAITING) { 448 VERBOSE("SP context on core%u is not waiting (%u).\n", 449 idx, sp->ec[idx].rt_model); 450 451 if (sp->runtime_el == S_EL0) { 452 spin_unlock(&sp->rt_state_lock); 453 } 454 455 return spmc_ffa_error_return(handle, FFA_ERROR_BUSY); 456 } 457 458 /* 459 * Everything checks out so forward the request to the SP after updating 460 * its state and runtime model. 461 */ 462 sp->ec[idx].rt_state = RT_STATE_RUNNING; 463 sp->ec[idx].rt_model = RT_MODEL_DIR_REQ; 464 sp->ec[idx].dir_req_origin_id = src_id; 465 sp->ec[idx].dir_req_funcid = dir_req_funcid; 466 467 if (sp->runtime_el == S_EL0) { 468 spin_unlock(&sp->rt_state_lock); 469 } 470 471 return spmc_smc_return(smc_fid, secure_origin, x1, x2, x3, x4, 472 handle, cookie, flags, dst_id); 473 } 474 475 /******************************************************************************* 476 * Handle direct response messages and route to the appropriate destination. 477 ******************************************************************************/ 478 static uint64_t direct_resp_smc_handler(uint32_t smc_fid, 479 bool secure_origin, 480 uint64_t x1, 481 uint64_t x2, 482 uint64_t x3, 483 uint64_t x4, 484 void *cookie, 485 void *handle, 486 uint64_t flags) 487 { 488 uint16_t dst_id = ffa_endpoint_destination(x1); 489 uint16_t dir_req_funcid; 490 struct secure_partition_desc *sp; 491 unsigned int idx; 492 493 dir_req_funcid = (smc_fid != FFA_MSG_SEND_DIRECT_RESP2_SMC64) ? 494 FFA_FNUM_MSG_SEND_DIRECT_REQ : FFA_FNUM_MSG_SEND_DIRECT_REQ2; 495 496 /* Check if arg2 has been populated correctly based on message type. */ 497 if (!direct_msg_validate_arg2(x2)) { 498 return spmc_ffa_error_return(handle, 499 FFA_ERROR_INVALID_PARAMETER); 500 } 501 502 /* Check that the response did not originate from the Normal world. */ 503 if (!secure_origin) { 504 VERBOSE("Direct Response not supported from Normal World.\n"); 505 return spmc_ffa_error_return(handle, 506 FFA_ERROR_INVALID_PARAMETER); 507 } 508 509 /* 510 * Check that the response is either targeted to the Normal world or the 511 * SPMC e.g. a PM response. 512 */ 513 if (!direct_msg_validate_dst_id(dst_id)) { 514 VERBOSE("Direct response to invalid partition ID (0x%x).\n", 515 dst_id); 516 return spmc_ffa_error_return(handle, 517 FFA_ERROR_INVALID_PARAMETER); 518 } 519 520 /* Obtain the SP descriptor and update its runtime state. */ 521 sp = spmc_get_sp_ctx(ffa_endpoint_source(x1)); 522 if (sp == NULL) { 523 VERBOSE("Direct response to unknown partition ID (0x%x).\n", 524 dst_id); 525 return spmc_ffa_error_return(handle, 526 FFA_ERROR_INVALID_PARAMETER); 527 } 528 529 if (sp->runtime_el == S_EL0) { 530 spin_lock(&sp->rt_state_lock); 531 } 532 533 /* Sanity check state is being tracked correctly in the SPMC. */ 534 idx = get_ec_index(sp); 535 assert(sp->ec[idx].rt_state == RT_STATE_RUNNING); 536 537 /* Ensure SP execution context was in the right runtime model. */ 538 if (sp->ec[idx].rt_model != RT_MODEL_DIR_REQ) { 539 VERBOSE("SP context on core%u not handling direct req (%u).\n", 540 idx, sp->ec[idx].rt_model); 541 if (sp->runtime_el == S_EL0) { 542 spin_unlock(&sp->rt_state_lock); 543 } 544 return spmc_ffa_error_return(handle, FFA_ERROR_DENIED); 545 } 546 547 if (dir_req_funcid != sp->ec[idx].dir_req_funcid) { 548 WARN("Unmatched direct req/resp func id. req:%x, resp:%x on core%u.\n", 549 sp->ec[idx].dir_req_funcid, (smc_fid & FUNCID_NUM_MASK), idx); 550 if (sp->runtime_el == S_EL0) { 551 spin_unlock(&sp->rt_state_lock); 552 } 553 return spmc_ffa_error_return(handle, FFA_ERROR_DENIED); 554 } 555 556 if (sp->ec[idx].dir_req_origin_id != dst_id) { 557 WARN("Invalid direct resp partition ID 0x%x != 0x%x on core%u.\n", 558 dst_id, sp->ec[idx].dir_req_origin_id, idx); 559 if (sp->runtime_el == S_EL0) { 560 spin_unlock(&sp->rt_state_lock); 561 } 562 return spmc_ffa_error_return(handle, FFA_ERROR_DENIED); 563 } 564 565 /* Update the state of the SP execution context. */ 566 sp->ec[idx].rt_state = RT_STATE_WAITING; 567 568 /* Clear the ongoing direct request ID. */ 569 sp->ec[idx].dir_req_origin_id = INV_SP_ID; 570 571 /* Clear the ongoing direct request message version. */ 572 sp->ec[idx].dir_req_funcid = 0U; 573 574 if (sp->runtime_el == S_EL0) { 575 spin_unlock(&sp->rt_state_lock); 576 } 577 578 /* 579 * If the receiver is not the SPMC then forward the response to the 580 * Normal world. 581 */ 582 if (dst_id == FFA_SPMC_ID) { 583 spmc_sp_synchronous_exit(&sp->ec[idx], x4); 584 /* Should not get here. */ 585 panic(); 586 } 587 588 return spmc_smc_return(smc_fid, secure_origin, x1, x2, x3, x4, 589 handle, cookie, flags, dst_id); 590 } 591 592 /******************************************************************************* 593 * This function handles the FFA_MSG_WAIT SMC to allow an SP to relinquish its 594 * cycles. 595 ******************************************************************************/ 596 static uint64_t msg_wait_handler(uint32_t smc_fid, 597 bool secure_origin, 598 uint64_t x1, 599 uint64_t x2, 600 uint64_t x3, 601 uint64_t x4, 602 void *cookie, 603 void *handle, 604 uint64_t flags) 605 { 606 struct secure_partition_desc *sp; 607 unsigned int idx; 608 609 /* 610 * Check that the response did not originate from the Normal world as 611 * only the secure world can call this ABI. 612 */ 613 if (!secure_origin) { 614 VERBOSE("Normal world cannot call FFA_MSG_WAIT.\n"); 615 return spmc_ffa_error_return(handle, FFA_ERROR_NOT_SUPPORTED); 616 } 617 618 /* Get the descriptor of the SP that invoked FFA_MSG_WAIT. */ 619 sp = spmc_get_current_sp_ctx(); 620 if (sp == NULL) { 621 return spmc_ffa_error_return(handle, 622 FFA_ERROR_INVALID_PARAMETER); 623 } 624 625 /* 626 * Get the execution context of the SP that invoked FFA_MSG_WAIT. 627 */ 628 idx = get_ec_index(sp); 629 if (sp->runtime_el == S_EL0) { 630 spin_lock(&sp->rt_state_lock); 631 } 632 633 /* Ensure SP execution context was in the right runtime model. */ 634 if (sp->ec[idx].rt_model == RT_MODEL_DIR_REQ) { 635 if (sp->runtime_el == S_EL0) { 636 spin_unlock(&sp->rt_state_lock); 637 } 638 return spmc_ffa_error_return(handle, FFA_ERROR_DENIED); 639 } 640 641 /* Sanity check the state is being tracked correctly in the SPMC. */ 642 assert(sp->ec[idx].rt_state == RT_STATE_RUNNING); 643 644 /* 645 * Perform a synchronous exit if the partition was initialising. The 646 * state is updated after the exit. 647 */ 648 if (sp->ec[idx].rt_model == RT_MODEL_INIT) { 649 if (sp->runtime_el == S_EL0) { 650 spin_unlock(&sp->rt_state_lock); 651 } 652 spmc_sp_synchronous_exit(&sp->ec[idx], x4); 653 /* Should not get here */ 654 panic(); 655 } 656 657 /* Update the state of the SP execution context. */ 658 sp->ec[idx].rt_state = RT_STATE_WAITING; 659 660 /* Resume normal world if a secure interrupt was handled. */ 661 if (sp->ec[idx].rt_model == RT_MODEL_INTR) { 662 /* FFA_MSG_WAIT can only be called from the secure world. */ 663 unsigned int secure_state_in = SECURE; 664 unsigned int secure_state_out = NON_SECURE; 665 666 cm_el1_sysregs_context_save(secure_state_in); 667 cm_el1_sysregs_context_restore(secure_state_out); 668 cm_set_next_eret_context(secure_state_out); 669 670 if (sp->runtime_el == S_EL0) { 671 spin_unlock(&sp->rt_state_lock); 672 } 673 674 SMC_RET0(cm_get_context(secure_state_out)); 675 } 676 677 /* Protect the runtime state of a S-EL0 SP with a lock. */ 678 if (sp->runtime_el == S_EL0) { 679 spin_unlock(&sp->rt_state_lock); 680 } 681 682 /* Forward the response to the Normal world. */ 683 return spmc_smc_return(smc_fid, secure_origin, x1, x2, x3, x4, 684 handle, cookie, flags, FFA_NWD_ID); 685 } 686 687 static uint64_t ffa_error_handler(uint32_t smc_fid, 688 bool secure_origin, 689 uint64_t x1, 690 uint64_t x2, 691 uint64_t x3, 692 uint64_t x4, 693 void *cookie, 694 void *handle, 695 uint64_t flags) 696 { 697 struct secure_partition_desc *sp; 698 unsigned int idx; 699 700 /* Check that the response did not originate from the Normal world. */ 701 if (!secure_origin) { 702 return spmc_ffa_error_return(handle, FFA_ERROR_NOT_SUPPORTED); 703 } 704 705 /* Get the descriptor of the SP that invoked FFA_ERROR. */ 706 sp = spmc_get_current_sp_ctx(); 707 if (sp == NULL) { 708 return spmc_ffa_error_return(handle, 709 FFA_ERROR_INVALID_PARAMETER); 710 } 711 712 /* Get the execution context of the SP that invoked FFA_ERROR. */ 713 idx = get_ec_index(sp); 714 715 /* 716 * We only expect FFA_ERROR to be received during SP initialisation 717 * otherwise this is an invalid call. 718 */ 719 if (sp->ec[idx].rt_model == RT_MODEL_INIT) { 720 ERROR("SP 0x%x failed to initialize.\n", sp->sp_id); 721 spmc_sp_synchronous_exit(&sp->ec[idx], x2); 722 /* Should not get here. */ 723 panic(); 724 } 725 726 return spmc_ffa_error_return(handle, FFA_ERROR_NOT_SUPPORTED); 727 } 728 729 static uint64_t ffa_version_handler(uint32_t smc_fid, 730 bool secure_origin, 731 uint64_t x1, 732 uint64_t x2, 733 uint64_t x3, 734 uint64_t x4, 735 void *cookie, 736 void *handle, 737 uint64_t flags) 738 { 739 uint32_t requested_version = x1 & FFA_VERSION_MASK; 740 741 if (requested_version & FFA_VERSION_BIT31_MASK) { 742 /* Invalid encoding, return an error. */ 743 SMC_RET1(handle, FFA_ERROR_NOT_SUPPORTED); 744 /* Execution stops here. */ 745 } 746 747 /* Determine the caller to store the requested version. */ 748 if (secure_origin) { 749 /* 750 * Ensure that the SP is reporting the same version as 751 * specified in its manifest. If these do not match there is 752 * something wrong with the SP. 753 * TODO: Should we abort the SP? For now assert this is not 754 * case. 755 */ 756 assert(requested_version == 757 spmc_get_current_sp_ctx()->ffa_version); 758 } else { 759 /* 760 * If this is called by the normal world, record this 761 * information in its descriptor. 762 */ 763 spmc_get_hyp_ctx()->ffa_version = requested_version; 764 } 765 766 SMC_RET1(handle, MAKE_FFA_VERSION(FFA_VERSION_MAJOR, 767 FFA_VERSION_MINOR)); 768 } 769 770 /******************************************************************************* 771 * Helper function to obtain the FF-A version of the calling partition. 772 ******************************************************************************/ 773 uint32_t get_partition_ffa_version(bool secure_origin) 774 { 775 if (secure_origin) { 776 return spmc_get_current_sp_ctx()->ffa_version; 777 } else { 778 return spmc_get_hyp_ctx()->ffa_version; 779 } 780 } 781 782 static uint64_t rxtx_map_handler(uint32_t smc_fid, 783 bool secure_origin, 784 uint64_t x1, 785 uint64_t x2, 786 uint64_t x3, 787 uint64_t x4, 788 void *cookie, 789 void *handle, 790 uint64_t flags) 791 { 792 int ret; 793 uint32_t error_code; 794 uint32_t mem_atts = secure_origin ? MT_SECURE : MT_NS; 795 struct mailbox *mbox; 796 uintptr_t tx_address = x1; 797 uintptr_t rx_address = x2; 798 uint32_t page_count = x3 & FFA_RXTX_PAGE_COUNT_MASK; /* Bits [5:0] */ 799 uint32_t buf_size = page_count * FFA_PAGE_SIZE; 800 801 /* 802 * The SPMC does not support mapping of VM RX/TX pairs to facilitate 803 * indirect messaging with SPs. Check if the Hypervisor has invoked this 804 * ABI on behalf of a VM and reject it if this is the case. 805 */ 806 if (tx_address == 0 || rx_address == 0) { 807 WARN("Mapping RX/TX Buffers on behalf of VM not supported.\n"); 808 return spmc_ffa_error_return(handle, 809 FFA_ERROR_INVALID_PARAMETER); 810 } 811 812 /* Ensure the specified buffers are not the same. */ 813 if (tx_address == rx_address) { 814 WARN("TX Buffer must not be the same as RX Buffer.\n"); 815 return spmc_ffa_error_return(handle, 816 FFA_ERROR_INVALID_PARAMETER); 817 } 818 819 /* Ensure the buffer size is not 0. */ 820 if (buf_size == 0U) { 821 WARN("Buffer size must not be 0\n"); 822 return spmc_ffa_error_return(handle, 823 FFA_ERROR_INVALID_PARAMETER); 824 } 825 826 /* 827 * Ensure the buffer size is a multiple of the translation granule size 828 * in TF-A. 829 */ 830 if (buf_size % PAGE_SIZE != 0U) { 831 WARN("Buffer size must be aligned to translation granule.\n"); 832 return spmc_ffa_error_return(handle, 833 FFA_ERROR_INVALID_PARAMETER); 834 } 835 836 /* Obtain the RX/TX buffer pair descriptor. */ 837 mbox = spmc_get_mbox_desc(secure_origin); 838 839 spin_lock(&mbox->lock); 840 841 /* Check if buffers have already been mapped. */ 842 if (mbox->rx_buffer != 0 || mbox->tx_buffer != 0) { 843 WARN("RX/TX Buffers already mapped (%p/%p)\n", 844 (void *) mbox->rx_buffer, (void *)mbox->tx_buffer); 845 error_code = FFA_ERROR_DENIED; 846 goto err; 847 } 848 849 /* memmap the TX buffer as read only. */ 850 ret = mmap_add_dynamic_region(tx_address, /* PA */ 851 tx_address, /* VA */ 852 buf_size, /* size */ 853 mem_atts | MT_RO_DATA); /* attrs */ 854 if (ret != 0) { 855 /* Return the correct error code. */ 856 error_code = (ret == -ENOMEM) ? FFA_ERROR_NO_MEMORY : 857 FFA_ERROR_INVALID_PARAMETER; 858 WARN("Unable to map TX buffer: %d\n", error_code); 859 goto err; 860 } 861 862 /* memmap the RX buffer as read write. */ 863 ret = mmap_add_dynamic_region(rx_address, /* PA */ 864 rx_address, /* VA */ 865 buf_size, /* size */ 866 mem_atts | MT_RW_DATA); /* attrs */ 867 868 if (ret != 0) { 869 error_code = (ret == -ENOMEM) ? FFA_ERROR_NO_MEMORY : 870 FFA_ERROR_INVALID_PARAMETER; 871 WARN("Unable to map RX buffer: %d\n", error_code); 872 /* Unmap the TX buffer again. */ 873 mmap_remove_dynamic_region(tx_address, buf_size); 874 goto err; 875 } 876 877 mbox->tx_buffer = (void *) tx_address; 878 mbox->rx_buffer = (void *) rx_address; 879 mbox->rxtx_page_count = page_count; 880 spin_unlock(&mbox->lock); 881 882 SMC_RET1(handle, FFA_SUCCESS_SMC32); 883 /* Execution stops here. */ 884 err: 885 spin_unlock(&mbox->lock); 886 return spmc_ffa_error_return(handle, error_code); 887 } 888 889 static uint64_t rxtx_unmap_handler(uint32_t smc_fid, 890 bool secure_origin, 891 uint64_t x1, 892 uint64_t x2, 893 uint64_t x3, 894 uint64_t x4, 895 void *cookie, 896 void *handle, 897 uint64_t flags) 898 { 899 struct mailbox *mbox = spmc_get_mbox_desc(secure_origin); 900 uint32_t buf_size = mbox->rxtx_page_count * FFA_PAGE_SIZE; 901 902 /* 903 * The SPMC does not support mapping of VM RX/TX pairs to facilitate 904 * indirect messaging with SPs. Check if the Hypervisor has invoked this 905 * ABI on behalf of a VM and reject it if this is the case. 906 */ 907 if (x1 != 0UL) { 908 return spmc_ffa_error_return(handle, 909 FFA_ERROR_INVALID_PARAMETER); 910 } 911 912 spin_lock(&mbox->lock); 913 914 /* Check if buffers are currently mapped. */ 915 if (mbox->rx_buffer == 0 || mbox->tx_buffer == 0) { 916 spin_unlock(&mbox->lock); 917 return spmc_ffa_error_return(handle, 918 FFA_ERROR_INVALID_PARAMETER); 919 } 920 921 /* Unmap RX Buffer */ 922 if (mmap_remove_dynamic_region((uintptr_t) mbox->rx_buffer, 923 buf_size) != 0) { 924 WARN("Unable to unmap RX buffer!\n"); 925 } 926 927 mbox->rx_buffer = 0; 928 929 /* Unmap TX Buffer */ 930 if (mmap_remove_dynamic_region((uintptr_t) mbox->tx_buffer, 931 buf_size) != 0) { 932 WARN("Unable to unmap TX buffer!\n"); 933 } 934 935 mbox->tx_buffer = 0; 936 mbox->rxtx_page_count = 0; 937 938 spin_unlock(&mbox->lock); 939 SMC_RET1(handle, FFA_SUCCESS_SMC32); 940 } 941 942 /* 943 * Helper function to populate the properties field of a Partition Info Get 944 * descriptor. 945 */ 946 static uint32_t 947 partition_info_get_populate_properties(uint32_t sp_properties, 948 enum sp_execution_state sp_ec_state) 949 { 950 uint32_t properties = sp_properties; 951 uint32_t ec_state; 952 953 /* Determine the execution state of the SP. */ 954 ec_state = sp_ec_state == SP_STATE_AARCH64 ? 955 FFA_PARTITION_INFO_GET_AARCH64_STATE : 956 FFA_PARTITION_INFO_GET_AARCH32_STATE; 957 958 properties |= ec_state << FFA_PARTITION_INFO_GET_EXEC_STATE_SHIFT; 959 960 return properties; 961 } 962 963 /* 964 * Collate the partition information in a v1.1 partition information 965 * descriptor format, this will be converter later if required. 966 */ 967 static int partition_info_get_handler_v1_1(uint32_t *uuid, 968 struct ffa_partition_info_v1_1 969 *partitions, 970 uint32_t max_partitions, 971 uint32_t *partition_count) 972 { 973 uint32_t index; 974 struct ffa_partition_info_v1_1 *desc; 975 bool null_uuid = is_null_uuid(uuid); 976 struct el3_lp_desc *el3_lp_descs = get_el3_lp_array(); 977 978 /* Deal with Logical Partitions. */ 979 for (index = 0U; index < EL3_LP_DESCS_COUNT; index++) { 980 if (null_uuid || uuid_match(uuid, el3_lp_descs[index].uuid)) { 981 /* Found a matching UUID, populate appropriately. */ 982 if (*partition_count >= max_partitions) { 983 return FFA_ERROR_NO_MEMORY; 984 } 985 986 desc = &partitions[*partition_count]; 987 desc->ep_id = el3_lp_descs[index].sp_id; 988 desc->execution_ctx_count = PLATFORM_CORE_COUNT; 989 /* LSPs must be AArch64. */ 990 desc->properties = 991 partition_info_get_populate_properties( 992 el3_lp_descs[index].properties, 993 SP_STATE_AARCH64); 994 995 if (null_uuid) { 996 copy_uuid(desc->uuid, el3_lp_descs[index].uuid); 997 } 998 (*partition_count)++; 999 } 1000 } 1001 1002 /* Deal with physical SP's. */ 1003 for (index = 0U; index < SECURE_PARTITION_COUNT; index++) { 1004 if (null_uuid || uuid_match(uuid, sp_desc[index].uuid)) { 1005 /* Found a matching UUID, populate appropriately. */ 1006 if (*partition_count >= max_partitions) { 1007 return FFA_ERROR_NO_MEMORY; 1008 } 1009 1010 desc = &partitions[*partition_count]; 1011 desc->ep_id = sp_desc[index].sp_id; 1012 /* 1013 * Execution context count must match No. cores for 1014 * S-EL1 SPs. 1015 */ 1016 desc->execution_ctx_count = PLATFORM_CORE_COUNT; 1017 desc->properties = 1018 partition_info_get_populate_properties( 1019 sp_desc[index].properties, 1020 sp_desc[index].execution_state); 1021 1022 if (null_uuid) { 1023 copy_uuid(desc->uuid, sp_desc[index].uuid); 1024 } 1025 (*partition_count)++; 1026 } 1027 } 1028 return 0; 1029 } 1030 1031 /* 1032 * Handle the case where that caller only wants the count of partitions 1033 * matching a given UUID and does not want the corresponding descriptors 1034 * populated. 1035 */ 1036 static uint32_t partition_info_get_handler_count_only(uint32_t *uuid) 1037 { 1038 uint32_t index = 0; 1039 uint32_t partition_count = 0; 1040 bool null_uuid = is_null_uuid(uuid); 1041 struct el3_lp_desc *el3_lp_descs = get_el3_lp_array(); 1042 1043 /* Deal with Logical Partitions. */ 1044 for (index = 0U; index < EL3_LP_DESCS_COUNT; index++) { 1045 if (null_uuid || 1046 uuid_match(uuid, el3_lp_descs[index].uuid)) { 1047 (partition_count)++; 1048 } 1049 } 1050 1051 /* Deal with physical SP's. */ 1052 for (index = 0U; index < SECURE_PARTITION_COUNT; index++) { 1053 if (null_uuid || uuid_match(uuid, sp_desc[index].uuid)) { 1054 (partition_count)++; 1055 } 1056 } 1057 return partition_count; 1058 } 1059 1060 /* 1061 * If the caller of the PARTITION_INFO_GET ABI was a v1.0 caller, populate 1062 * the corresponding descriptor format from the v1.1 descriptor array. 1063 */ 1064 static uint64_t partition_info_populate_v1_0(struct ffa_partition_info_v1_1 1065 *partitions, 1066 struct mailbox *mbox, 1067 int partition_count) 1068 { 1069 uint32_t index; 1070 uint32_t buf_size; 1071 uint32_t descriptor_size; 1072 struct ffa_partition_info_v1_0 *v1_0_partitions = 1073 (struct ffa_partition_info_v1_0 *) mbox->rx_buffer; 1074 1075 buf_size = mbox->rxtx_page_count * FFA_PAGE_SIZE; 1076 descriptor_size = partition_count * 1077 sizeof(struct ffa_partition_info_v1_0); 1078 1079 if (descriptor_size > buf_size) { 1080 return FFA_ERROR_NO_MEMORY; 1081 } 1082 1083 for (index = 0U; index < partition_count; index++) { 1084 v1_0_partitions[index].ep_id = partitions[index].ep_id; 1085 v1_0_partitions[index].execution_ctx_count = 1086 partitions[index].execution_ctx_count; 1087 /* Only report v1.0 properties. */ 1088 v1_0_partitions[index].properties = 1089 (partitions[index].properties & 1090 FFA_PARTITION_INFO_GET_PROPERTIES_V1_0_MASK); 1091 } 1092 return 0; 1093 } 1094 1095 /* 1096 * Main handler for FFA_PARTITION_INFO_GET which supports both FF-A v1.1 and 1097 * v1.0 implementations. 1098 */ 1099 static uint64_t partition_info_get_handler(uint32_t smc_fid, 1100 bool secure_origin, 1101 uint64_t x1, 1102 uint64_t x2, 1103 uint64_t x3, 1104 uint64_t x4, 1105 void *cookie, 1106 void *handle, 1107 uint64_t flags) 1108 { 1109 int ret; 1110 uint32_t partition_count = 0; 1111 uint32_t size = 0; 1112 uint32_t ffa_version = get_partition_ffa_version(secure_origin); 1113 struct mailbox *mbox; 1114 uint64_t info_get_flags; 1115 bool count_only; 1116 uint32_t uuid[4]; 1117 1118 uuid[0] = x1; 1119 uuid[1] = x2; 1120 uuid[2] = x3; 1121 uuid[3] = x4; 1122 1123 /* Determine if the Partition descriptors should be populated. */ 1124 info_get_flags = SMC_GET_GP(handle, CTX_GPREG_X5); 1125 count_only = (info_get_flags & FFA_PARTITION_INFO_GET_COUNT_FLAG_MASK); 1126 1127 /* Handle the case where we don't need to populate the descriptors. */ 1128 if (count_only) { 1129 partition_count = partition_info_get_handler_count_only(uuid); 1130 if (partition_count == 0) { 1131 return spmc_ffa_error_return(handle, 1132 FFA_ERROR_INVALID_PARAMETER); 1133 } 1134 } else { 1135 struct ffa_partition_info_v1_1 partitions[MAX_SP_LP_PARTITIONS]; 1136 1137 /* 1138 * Handle the case where the partition descriptors are required, 1139 * check we have the buffers available and populate the 1140 * appropriate structure version. 1141 */ 1142 1143 /* Obtain the v1.1 format of the descriptors. */ 1144 ret = partition_info_get_handler_v1_1(uuid, partitions, 1145 MAX_SP_LP_PARTITIONS, 1146 &partition_count); 1147 1148 /* Check if an error occurred during discovery. */ 1149 if (ret != 0) { 1150 goto err; 1151 } 1152 1153 /* If we didn't find any matches the UUID is unknown. */ 1154 if (partition_count == 0) { 1155 ret = FFA_ERROR_INVALID_PARAMETER; 1156 goto err; 1157 } 1158 1159 /* Obtain the partition mailbox RX/TX buffer pair descriptor. */ 1160 mbox = spmc_get_mbox_desc(secure_origin); 1161 1162 /* 1163 * If the caller has not bothered registering its RX/TX pair 1164 * then return an error code. 1165 */ 1166 spin_lock(&mbox->lock); 1167 if (mbox->rx_buffer == NULL) { 1168 ret = FFA_ERROR_BUSY; 1169 goto err_unlock; 1170 } 1171 1172 /* Ensure the RX buffer is currently free. */ 1173 if (mbox->state != MAILBOX_STATE_EMPTY) { 1174 ret = FFA_ERROR_BUSY; 1175 goto err_unlock; 1176 } 1177 1178 /* Zero the RX buffer before populating. */ 1179 (void)memset(mbox->rx_buffer, 0, 1180 mbox->rxtx_page_count * FFA_PAGE_SIZE); 1181 1182 /* 1183 * Depending on the FF-A version of the requesting partition 1184 * we may need to convert to a v1.0 format otherwise we can copy 1185 * directly. 1186 */ 1187 if (ffa_version == MAKE_FFA_VERSION(U(1), U(0))) { 1188 ret = partition_info_populate_v1_0(partitions, 1189 mbox, 1190 partition_count); 1191 if (ret != 0) { 1192 goto err_unlock; 1193 } 1194 } else { 1195 uint32_t buf_size = mbox->rxtx_page_count * 1196 FFA_PAGE_SIZE; 1197 1198 /* Ensure the descriptor will fit in the buffer. */ 1199 size = sizeof(struct ffa_partition_info_v1_1); 1200 if (partition_count * size > buf_size) { 1201 ret = FFA_ERROR_NO_MEMORY; 1202 goto err_unlock; 1203 } 1204 memcpy(mbox->rx_buffer, partitions, 1205 partition_count * size); 1206 } 1207 1208 mbox->state = MAILBOX_STATE_FULL; 1209 spin_unlock(&mbox->lock); 1210 } 1211 SMC_RET4(handle, FFA_SUCCESS_SMC32, 0, partition_count, size); 1212 1213 err_unlock: 1214 spin_unlock(&mbox->lock); 1215 err: 1216 return spmc_ffa_error_return(handle, ret); 1217 } 1218 1219 static uint64_t ffa_feature_success(void *handle, uint32_t arg2) 1220 { 1221 SMC_RET3(handle, FFA_SUCCESS_SMC32, 0, arg2); 1222 } 1223 1224 static uint64_t ffa_features_retrieve_request(bool secure_origin, 1225 uint32_t input_properties, 1226 void *handle) 1227 { 1228 /* 1229 * If we're called by the normal world we don't support any 1230 * additional features. 1231 */ 1232 if (!secure_origin) { 1233 if ((input_properties & FFA_FEATURES_RET_REQ_NS_BIT) != 0U) { 1234 return spmc_ffa_error_return(handle, 1235 FFA_ERROR_NOT_SUPPORTED); 1236 } 1237 1238 } else { 1239 struct secure_partition_desc *sp = spmc_get_current_sp_ctx(); 1240 /* 1241 * If v1.1 the NS bit must be set otherwise it is an invalid 1242 * call. If v1.0 check and store whether the SP has requested 1243 * the use of the NS bit. 1244 */ 1245 if (sp->ffa_version == MAKE_FFA_VERSION(1, 1)) { 1246 if ((input_properties & 1247 FFA_FEATURES_RET_REQ_NS_BIT) == 0U) { 1248 return spmc_ffa_error_return(handle, 1249 FFA_ERROR_NOT_SUPPORTED); 1250 } 1251 return ffa_feature_success(handle, 1252 FFA_FEATURES_RET_REQ_NS_BIT); 1253 } else { 1254 sp->ns_bit_requested = (input_properties & 1255 FFA_FEATURES_RET_REQ_NS_BIT) != 1256 0U; 1257 } 1258 if (sp->ns_bit_requested) { 1259 return ffa_feature_success(handle, 1260 FFA_FEATURES_RET_REQ_NS_BIT); 1261 } 1262 } 1263 SMC_RET1(handle, FFA_SUCCESS_SMC32); 1264 } 1265 1266 static uint64_t ffa_features_handler(uint32_t smc_fid, 1267 bool secure_origin, 1268 uint64_t x1, 1269 uint64_t x2, 1270 uint64_t x3, 1271 uint64_t x4, 1272 void *cookie, 1273 void *handle, 1274 uint64_t flags) 1275 { 1276 uint32_t function_id = (uint32_t) x1; 1277 uint32_t input_properties = (uint32_t) x2; 1278 1279 /* Check if a Feature ID was requested. */ 1280 if ((function_id & FFA_FEATURES_BIT31_MASK) == 0U) { 1281 /* We currently don't support any additional features. */ 1282 return spmc_ffa_error_return(handle, FFA_ERROR_NOT_SUPPORTED); 1283 } 1284 1285 /* 1286 * Handle the cases where we have separate handlers due to additional 1287 * properties. 1288 */ 1289 switch (function_id) { 1290 case FFA_MEM_RETRIEVE_REQ_SMC32: 1291 case FFA_MEM_RETRIEVE_REQ_SMC64: 1292 return ffa_features_retrieve_request(secure_origin, 1293 input_properties, 1294 handle); 1295 } 1296 1297 /* 1298 * We don't currently support additional input properties for these 1299 * other ABIs therefore ensure this value is set to 0. 1300 */ 1301 if (input_properties != 0U) { 1302 return spmc_ffa_error_return(handle, 1303 FFA_ERROR_NOT_SUPPORTED); 1304 } 1305 1306 /* Report if any other FF-A ABI is supported. */ 1307 switch (function_id) { 1308 /* Supported features from both worlds. */ 1309 case FFA_ERROR: 1310 case FFA_SUCCESS_SMC32: 1311 case FFA_INTERRUPT: 1312 case FFA_SPM_ID_GET: 1313 case FFA_ID_GET: 1314 case FFA_FEATURES: 1315 case FFA_VERSION: 1316 case FFA_RX_RELEASE: 1317 case FFA_MSG_SEND_DIRECT_REQ_SMC32: 1318 case FFA_MSG_SEND_DIRECT_REQ_SMC64: 1319 case FFA_MSG_SEND_DIRECT_REQ2_SMC64: 1320 case FFA_PARTITION_INFO_GET: 1321 case FFA_RXTX_MAP_SMC32: 1322 case FFA_RXTX_MAP_SMC64: 1323 case FFA_RXTX_UNMAP: 1324 case FFA_MEM_FRAG_TX: 1325 case FFA_MSG_RUN: 1326 1327 /* 1328 * We are relying on the fact that the other registers 1329 * will be set to 0 as these values align with the 1330 * currently implemented features of the SPMC. If this 1331 * changes this function must be extended to handle 1332 * reporting the additional functionality. 1333 */ 1334 1335 SMC_RET1(handle, FFA_SUCCESS_SMC32); 1336 /* Execution stops here. */ 1337 1338 /* Supported ABIs only from the secure world. */ 1339 case FFA_SECONDARY_EP_REGISTER_SMC64: 1340 case FFA_MSG_SEND_DIRECT_RESP_SMC32: 1341 case FFA_MSG_SEND_DIRECT_RESP_SMC64: 1342 case FFA_MSG_SEND_DIRECT_RESP2_SMC64: 1343 case FFA_MEM_RELINQUISH: 1344 case FFA_MSG_WAIT: 1345 case FFA_CONSOLE_LOG_SMC32: 1346 case FFA_CONSOLE_LOG_SMC64: 1347 1348 if (!secure_origin) { 1349 return spmc_ffa_error_return(handle, 1350 FFA_ERROR_NOT_SUPPORTED); 1351 } 1352 SMC_RET1(handle, FFA_SUCCESS_SMC32); 1353 /* Execution stops here. */ 1354 1355 /* Supported features only from the normal world. */ 1356 case FFA_MEM_SHARE_SMC32: 1357 case FFA_MEM_SHARE_SMC64: 1358 case FFA_MEM_LEND_SMC32: 1359 case FFA_MEM_LEND_SMC64: 1360 case FFA_MEM_RECLAIM: 1361 case FFA_MEM_FRAG_RX: 1362 1363 if (secure_origin) { 1364 return spmc_ffa_error_return(handle, 1365 FFA_ERROR_NOT_SUPPORTED); 1366 } 1367 SMC_RET1(handle, FFA_SUCCESS_SMC32); 1368 /* Execution stops here. */ 1369 1370 default: 1371 return spmc_ffa_error_return(handle, 1372 FFA_ERROR_NOT_SUPPORTED); 1373 } 1374 } 1375 1376 static uint64_t ffa_id_get_handler(uint32_t smc_fid, 1377 bool secure_origin, 1378 uint64_t x1, 1379 uint64_t x2, 1380 uint64_t x3, 1381 uint64_t x4, 1382 void *cookie, 1383 void *handle, 1384 uint64_t flags) 1385 { 1386 if (secure_origin) { 1387 SMC_RET3(handle, FFA_SUCCESS_SMC32, 0x0, 1388 spmc_get_current_sp_ctx()->sp_id); 1389 } else { 1390 SMC_RET3(handle, FFA_SUCCESS_SMC32, 0x0, 1391 spmc_get_hyp_ctx()->ns_ep_id); 1392 } 1393 } 1394 1395 /* 1396 * Enable an SP to query the ID assigned to the SPMC. 1397 */ 1398 static uint64_t ffa_spm_id_get_handler(uint32_t smc_fid, 1399 bool secure_origin, 1400 uint64_t x1, 1401 uint64_t x2, 1402 uint64_t x3, 1403 uint64_t x4, 1404 void *cookie, 1405 void *handle, 1406 uint64_t flags) 1407 { 1408 assert(x1 == 0UL); 1409 assert(x2 == 0UL); 1410 assert(x3 == 0UL); 1411 assert(x4 == 0UL); 1412 assert(SMC_GET_GP(handle, CTX_GPREG_X5) == 0UL); 1413 assert(SMC_GET_GP(handle, CTX_GPREG_X6) == 0UL); 1414 assert(SMC_GET_GP(handle, CTX_GPREG_X7) == 0UL); 1415 1416 SMC_RET3(handle, FFA_SUCCESS_SMC32, 0x0, FFA_SPMC_ID); 1417 } 1418 1419 static uint64_t ffa_run_handler(uint32_t smc_fid, 1420 bool secure_origin, 1421 uint64_t x1, 1422 uint64_t x2, 1423 uint64_t x3, 1424 uint64_t x4, 1425 void *cookie, 1426 void *handle, 1427 uint64_t flags) 1428 { 1429 struct secure_partition_desc *sp; 1430 uint16_t target_id = FFA_RUN_EP_ID(x1); 1431 uint16_t vcpu_id = FFA_RUN_VCPU_ID(x1); 1432 unsigned int idx; 1433 unsigned int *rt_state; 1434 unsigned int *rt_model; 1435 1436 /* Can only be called from the normal world. */ 1437 if (secure_origin) { 1438 ERROR("FFA_RUN can only be called from NWd.\n"); 1439 return spmc_ffa_error_return(handle, 1440 FFA_ERROR_INVALID_PARAMETER); 1441 } 1442 1443 /* Cannot run a Normal world partition. */ 1444 if (ffa_is_normal_world_id(target_id)) { 1445 ERROR("Cannot run a NWd partition (0x%x).\n", target_id); 1446 return spmc_ffa_error_return(handle, 1447 FFA_ERROR_INVALID_PARAMETER); 1448 } 1449 1450 /* Check that the target SP exists. */ 1451 sp = spmc_get_sp_ctx(target_id); 1452 ERROR("Unknown partition ID (0x%x).\n", target_id); 1453 if (sp == NULL) { 1454 return spmc_ffa_error_return(handle, 1455 FFA_ERROR_INVALID_PARAMETER); 1456 } 1457 1458 idx = get_ec_index(sp); 1459 1460 if (idx != vcpu_id) { 1461 ERROR("Cannot run vcpu %d != %d.\n", idx, vcpu_id); 1462 return spmc_ffa_error_return(handle, 1463 FFA_ERROR_INVALID_PARAMETER); 1464 } 1465 if (sp->runtime_el == S_EL0) { 1466 spin_lock(&sp->rt_state_lock); 1467 } 1468 rt_state = &((sp->ec[idx]).rt_state); 1469 rt_model = &((sp->ec[idx]).rt_model); 1470 if (*rt_state == RT_STATE_RUNNING) { 1471 if (sp->runtime_el == S_EL0) { 1472 spin_unlock(&sp->rt_state_lock); 1473 } 1474 ERROR("Partition (0x%x) is already running.\n", target_id); 1475 return spmc_ffa_error_return(handle, FFA_ERROR_BUSY); 1476 } 1477 1478 /* 1479 * Sanity check that if the execution context was not waiting then it 1480 * was either in the direct request or the run partition runtime model. 1481 */ 1482 if (*rt_state == RT_STATE_PREEMPTED || *rt_state == RT_STATE_BLOCKED) { 1483 assert(*rt_model == RT_MODEL_RUN || 1484 *rt_model == RT_MODEL_DIR_REQ); 1485 } 1486 1487 /* 1488 * If the context was waiting then update the partition runtime model. 1489 */ 1490 if (*rt_state == RT_STATE_WAITING) { 1491 *rt_model = RT_MODEL_RUN; 1492 } 1493 1494 /* 1495 * Forward the request to the correct SP vCPU after updating 1496 * its state. 1497 */ 1498 *rt_state = RT_STATE_RUNNING; 1499 1500 if (sp->runtime_el == S_EL0) { 1501 spin_unlock(&sp->rt_state_lock); 1502 } 1503 1504 return spmc_smc_return(smc_fid, secure_origin, x1, 0, 0, 0, 1505 handle, cookie, flags, target_id); 1506 } 1507 1508 static uint64_t rx_release_handler(uint32_t smc_fid, 1509 bool secure_origin, 1510 uint64_t x1, 1511 uint64_t x2, 1512 uint64_t x3, 1513 uint64_t x4, 1514 void *cookie, 1515 void *handle, 1516 uint64_t flags) 1517 { 1518 struct mailbox *mbox = spmc_get_mbox_desc(secure_origin); 1519 1520 spin_lock(&mbox->lock); 1521 1522 if (mbox->state != MAILBOX_STATE_FULL) { 1523 spin_unlock(&mbox->lock); 1524 return spmc_ffa_error_return(handle, FFA_ERROR_DENIED); 1525 } 1526 1527 mbox->state = MAILBOX_STATE_EMPTY; 1528 spin_unlock(&mbox->lock); 1529 1530 SMC_RET1(handle, FFA_SUCCESS_SMC32); 1531 } 1532 1533 static uint64_t spmc_ffa_console_log(uint32_t smc_fid, 1534 bool secure_origin, 1535 uint64_t x1, 1536 uint64_t x2, 1537 uint64_t x3, 1538 uint64_t x4, 1539 void *cookie, 1540 void *handle, 1541 uint64_t flags) 1542 { 1543 /* Maximum number of characters is 48: 6 registers of 8 bytes each. */ 1544 char chars[48] = {0}; 1545 size_t chars_max; 1546 size_t chars_count = x1; 1547 1548 /* Does not support request from Nwd. */ 1549 if (!secure_origin) { 1550 return spmc_ffa_error_return(handle, FFA_ERROR_NOT_SUPPORTED); 1551 } 1552 1553 assert(smc_fid == FFA_CONSOLE_LOG_SMC32 || smc_fid == FFA_CONSOLE_LOG_SMC64); 1554 if (smc_fid == FFA_CONSOLE_LOG_SMC32) { 1555 uint32_t *registers = (uint32_t *)chars; 1556 registers[0] = (uint32_t)x2; 1557 registers[1] = (uint32_t)x3; 1558 registers[2] = (uint32_t)x4; 1559 registers[3] = (uint32_t)SMC_GET_GP(handle, CTX_GPREG_X5); 1560 registers[4] = (uint32_t)SMC_GET_GP(handle, CTX_GPREG_X6); 1561 registers[5] = (uint32_t)SMC_GET_GP(handle, CTX_GPREG_X7); 1562 chars_max = 6 * sizeof(uint32_t); 1563 } else { 1564 uint64_t *registers = (uint64_t *)chars; 1565 registers[0] = x2; 1566 registers[1] = x3; 1567 registers[2] = x4; 1568 registers[3] = SMC_GET_GP(handle, CTX_GPREG_X5); 1569 registers[4] = SMC_GET_GP(handle, CTX_GPREG_X6); 1570 registers[5] = SMC_GET_GP(handle, CTX_GPREG_X7); 1571 chars_max = 6 * sizeof(uint64_t); 1572 } 1573 1574 if ((chars_count == 0) || (chars_count > chars_max)) { 1575 return spmc_ffa_error_return(handle, FFA_ERROR_INVALID_PARAMETER); 1576 } 1577 1578 for (size_t i = 0; (i < chars_count) && (chars[i] != '\0'); i++) { 1579 putchar(chars[i]); 1580 } 1581 1582 SMC_RET1(handle, FFA_SUCCESS_SMC32); 1583 } 1584 1585 /* 1586 * Perform initial validation on the provided secondary entry point. 1587 * For now ensure it does not lie within the BL31 Image or the SP's 1588 * RX/TX buffers as these are mapped within EL3. 1589 * TODO: perform validation for additional invalid memory regions. 1590 */ 1591 static int validate_secondary_ep(uintptr_t ep, struct secure_partition_desc *sp) 1592 { 1593 struct mailbox *mb; 1594 uintptr_t buffer_size; 1595 uintptr_t sp_rx_buffer; 1596 uintptr_t sp_tx_buffer; 1597 uintptr_t sp_rx_buffer_limit; 1598 uintptr_t sp_tx_buffer_limit; 1599 1600 mb = &sp->mailbox; 1601 buffer_size = (uintptr_t) (mb->rxtx_page_count * FFA_PAGE_SIZE); 1602 sp_rx_buffer = (uintptr_t) mb->rx_buffer; 1603 sp_tx_buffer = (uintptr_t) mb->tx_buffer; 1604 sp_rx_buffer_limit = sp_rx_buffer + buffer_size; 1605 sp_tx_buffer_limit = sp_tx_buffer + buffer_size; 1606 1607 /* 1608 * Check if the entry point lies within BL31, or the 1609 * SP's RX or TX buffer. 1610 */ 1611 if ((ep >= BL31_BASE && ep < BL31_LIMIT) || 1612 (ep >= sp_rx_buffer && ep < sp_rx_buffer_limit) || 1613 (ep >= sp_tx_buffer && ep < sp_tx_buffer_limit)) { 1614 return -EINVAL; 1615 } 1616 return 0; 1617 } 1618 1619 /******************************************************************************* 1620 * This function handles the FFA_SECONDARY_EP_REGISTER SMC to allow an SP to 1621 * register an entry point for initialization during a secondary cold boot. 1622 ******************************************************************************/ 1623 static uint64_t ffa_sec_ep_register_handler(uint32_t smc_fid, 1624 bool secure_origin, 1625 uint64_t x1, 1626 uint64_t x2, 1627 uint64_t x3, 1628 uint64_t x4, 1629 void *cookie, 1630 void *handle, 1631 uint64_t flags) 1632 { 1633 struct secure_partition_desc *sp; 1634 struct sp_exec_ctx *sp_ctx; 1635 1636 /* This request cannot originate from the Normal world. */ 1637 if (!secure_origin) { 1638 WARN("%s: Can only be called from SWd.\n", __func__); 1639 return spmc_ffa_error_return(handle, FFA_ERROR_NOT_SUPPORTED); 1640 } 1641 1642 /* Get the context of the current SP. */ 1643 sp = spmc_get_current_sp_ctx(); 1644 if (sp == NULL) { 1645 WARN("%s: Cannot find SP context.\n", __func__); 1646 return spmc_ffa_error_return(handle, 1647 FFA_ERROR_INVALID_PARAMETER); 1648 } 1649 1650 /* Only an S-EL1 SP should be invoking this ABI. */ 1651 if (sp->runtime_el != S_EL1) { 1652 WARN("%s: Can only be called for a S-EL1 SP.\n", __func__); 1653 return spmc_ffa_error_return(handle, FFA_ERROR_DENIED); 1654 } 1655 1656 /* Ensure the SP is in its initialization state. */ 1657 sp_ctx = spmc_get_sp_ec(sp); 1658 if (sp_ctx->rt_model != RT_MODEL_INIT) { 1659 WARN("%s: Can only be called during SP initialization.\n", 1660 __func__); 1661 return spmc_ffa_error_return(handle, FFA_ERROR_DENIED); 1662 } 1663 1664 /* Perform initial validation of the secondary entry point. */ 1665 if (validate_secondary_ep(x1, sp)) { 1666 WARN("%s: Invalid entry point provided (0x%lx).\n", 1667 __func__, x1); 1668 return spmc_ffa_error_return(handle, 1669 FFA_ERROR_INVALID_PARAMETER); 1670 } 1671 1672 /* 1673 * Update the secondary entrypoint in SP context. 1674 * We don't need a lock here as during partition initialization there 1675 * will only be a single core online. 1676 */ 1677 sp->secondary_ep = x1; 1678 VERBOSE("%s: 0x%lx\n", __func__, sp->secondary_ep); 1679 1680 SMC_RET1(handle, FFA_SUCCESS_SMC32); 1681 } 1682 1683 /******************************************************************************* 1684 * Permissions are encoded using a different format in the FFA_MEM_PERM_* ABIs 1685 * than in the Trusted Firmware, where the mmap_attr_t enum type is used. This 1686 * function converts a permission value from the FF-A format to the mmap_attr_t 1687 * format by setting MT_RW/MT_RO, MT_USER/MT_PRIVILEGED and 1688 * MT_EXECUTE/MT_EXECUTE_NEVER. The other fields are left as 0 because they are 1689 * ignored by the function xlat_change_mem_attributes_ctx(). 1690 ******************************************************************************/ 1691 static unsigned int ffa_perm_to_mmap_perm(unsigned int perms) 1692 { 1693 unsigned int tf_attr = 0U; 1694 unsigned int access; 1695 1696 /* Deal with data access permissions first. */ 1697 access = (perms & FFA_MEM_PERM_DATA_MASK) >> FFA_MEM_PERM_DATA_SHIFT; 1698 1699 switch (access) { 1700 case FFA_MEM_PERM_DATA_RW: 1701 /* Return 0 if the execute is set with RW. */ 1702 if ((perms & FFA_MEM_PERM_INST_NON_EXEC) != 0) { 1703 tf_attr |= MT_RW | MT_USER | MT_EXECUTE_NEVER; 1704 } 1705 break; 1706 1707 case FFA_MEM_PERM_DATA_RO: 1708 tf_attr |= MT_RO | MT_USER; 1709 /* Deal with the instruction access permissions next. */ 1710 if ((perms & FFA_MEM_PERM_INST_NON_EXEC) == 0) { 1711 tf_attr |= MT_EXECUTE; 1712 } else { 1713 tf_attr |= MT_EXECUTE_NEVER; 1714 } 1715 break; 1716 1717 case FFA_MEM_PERM_DATA_NA: 1718 default: 1719 return tf_attr; 1720 } 1721 1722 return tf_attr; 1723 } 1724 1725 /******************************************************************************* 1726 * Handler to set the permissions of a set of contiguous pages of a S-EL0 SP 1727 ******************************************************************************/ 1728 static uint64_t ffa_mem_perm_set_handler(uint32_t smc_fid, 1729 bool secure_origin, 1730 uint64_t x1, 1731 uint64_t x2, 1732 uint64_t x3, 1733 uint64_t x4, 1734 void *cookie, 1735 void *handle, 1736 uint64_t flags) 1737 { 1738 struct secure_partition_desc *sp; 1739 unsigned int idx; 1740 uintptr_t base_va = (uintptr_t) x1; 1741 size_t size = (size_t)(x2 * PAGE_SIZE); 1742 uint32_t tf_attr; 1743 int ret; 1744 1745 /* This request cannot originate from the Normal world. */ 1746 if (!secure_origin) { 1747 return spmc_ffa_error_return(handle, FFA_ERROR_NOT_SUPPORTED); 1748 } 1749 1750 if (size == 0) { 1751 return spmc_ffa_error_return(handle, 1752 FFA_ERROR_INVALID_PARAMETER); 1753 } 1754 1755 /* Get the context of the current SP. */ 1756 sp = spmc_get_current_sp_ctx(); 1757 if (sp == NULL) { 1758 return spmc_ffa_error_return(handle, 1759 FFA_ERROR_INVALID_PARAMETER); 1760 } 1761 1762 /* A S-EL1 SP has no business invoking this ABI. */ 1763 if (sp->runtime_el == S_EL1) { 1764 return spmc_ffa_error_return(handle, FFA_ERROR_DENIED); 1765 } 1766 1767 if ((x3 & ~((uint64_t)FFA_MEM_PERM_MASK)) != 0) { 1768 return spmc_ffa_error_return(handle, 1769 FFA_ERROR_INVALID_PARAMETER); 1770 } 1771 1772 /* Get the execution context of the calling SP. */ 1773 idx = get_ec_index(sp); 1774 1775 /* 1776 * Ensure that the S-EL0 SP is initialising itself. We do not need to 1777 * synchronise this operation through a spinlock since a S-EL0 SP is UP 1778 * and can only be initialising on this cpu. 1779 */ 1780 if (sp->ec[idx].rt_model != RT_MODEL_INIT) { 1781 return spmc_ffa_error_return(handle, FFA_ERROR_DENIED); 1782 } 1783 1784 VERBOSE("Setting memory permissions:\n"); 1785 VERBOSE(" Start address : 0x%lx\n", base_va); 1786 VERBOSE(" Number of pages: %lu (%zu bytes)\n", x2, size); 1787 VERBOSE(" Attributes : 0x%x\n", (uint32_t)x3); 1788 1789 /* Convert inbound permissions to TF-A permission attributes */ 1790 tf_attr = ffa_perm_to_mmap_perm((unsigned int)x3); 1791 if (tf_attr == 0U) { 1792 return spmc_ffa_error_return(handle, 1793 FFA_ERROR_INVALID_PARAMETER); 1794 } 1795 1796 /* Request the change in permissions */ 1797 ret = xlat_change_mem_attributes_ctx(sp->xlat_ctx_handle, 1798 base_va, size, tf_attr); 1799 if (ret != 0) { 1800 return spmc_ffa_error_return(handle, 1801 FFA_ERROR_INVALID_PARAMETER); 1802 } 1803 1804 SMC_RET1(handle, FFA_SUCCESS_SMC32); 1805 } 1806 1807 /******************************************************************************* 1808 * Permissions are encoded using a different format in the FFA_MEM_PERM_* ABIs 1809 * than in the Trusted Firmware, where the mmap_attr_t enum type is used. This 1810 * function converts a permission value from the mmap_attr_t format to the FF-A 1811 * format. 1812 ******************************************************************************/ 1813 static unsigned int mmap_perm_to_ffa_perm(unsigned int attr) 1814 { 1815 unsigned int perms = 0U; 1816 unsigned int data_access; 1817 1818 if ((attr & MT_USER) == 0) { 1819 /* No access from EL0. */ 1820 data_access = FFA_MEM_PERM_DATA_NA; 1821 } else { 1822 if ((attr & MT_RW) != 0) { 1823 data_access = FFA_MEM_PERM_DATA_RW; 1824 } else { 1825 data_access = FFA_MEM_PERM_DATA_RO; 1826 } 1827 } 1828 1829 perms |= (data_access & FFA_MEM_PERM_DATA_MASK) 1830 << FFA_MEM_PERM_DATA_SHIFT; 1831 1832 if ((attr & MT_EXECUTE_NEVER) != 0U) { 1833 perms |= FFA_MEM_PERM_INST_NON_EXEC; 1834 } 1835 1836 return perms; 1837 } 1838 1839 /******************************************************************************* 1840 * Handler to get the permissions of a set of contiguous pages of a S-EL0 SP 1841 ******************************************************************************/ 1842 static uint64_t ffa_mem_perm_get_handler(uint32_t smc_fid, 1843 bool secure_origin, 1844 uint64_t x1, 1845 uint64_t x2, 1846 uint64_t x3, 1847 uint64_t x4, 1848 void *cookie, 1849 void *handle, 1850 uint64_t flags) 1851 { 1852 struct secure_partition_desc *sp; 1853 unsigned int idx; 1854 uintptr_t base_va = (uintptr_t)x1; 1855 uint32_t tf_attr = 0; 1856 int ret; 1857 1858 /* This request cannot originate from the Normal world. */ 1859 if (!secure_origin) { 1860 return spmc_ffa_error_return(handle, FFA_ERROR_NOT_SUPPORTED); 1861 } 1862 1863 /* Get the context of the current SP. */ 1864 sp = spmc_get_current_sp_ctx(); 1865 if (sp == NULL) { 1866 return spmc_ffa_error_return(handle, 1867 FFA_ERROR_INVALID_PARAMETER); 1868 } 1869 1870 /* A S-EL1 SP has no business invoking this ABI. */ 1871 if (sp->runtime_el == S_EL1) { 1872 return spmc_ffa_error_return(handle, FFA_ERROR_DENIED); 1873 } 1874 1875 /* Get the execution context of the calling SP. */ 1876 idx = get_ec_index(sp); 1877 1878 /* 1879 * Ensure that the S-EL0 SP is initialising itself. We do not need to 1880 * synchronise this operation through a spinlock since a S-EL0 SP is UP 1881 * and can only be initialising on this cpu. 1882 */ 1883 if (sp->ec[idx].rt_model != RT_MODEL_INIT) { 1884 return spmc_ffa_error_return(handle, FFA_ERROR_DENIED); 1885 } 1886 1887 /* Request the permissions */ 1888 ret = xlat_get_mem_attributes_ctx(sp->xlat_ctx_handle, base_va, &tf_attr); 1889 if (ret != 0) { 1890 return spmc_ffa_error_return(handle, 1891 FFA_ERROR_INVALID_PARAMETER); 1892 } 1893 1894 /* Convert TF-A permission to FF-A permissions attributes. */ 1895 x2 = mmap_perm_to_ffa_perm(tf_attr); 1896 1897 SMC_RET3(handle, FFA_SUCCESS_SMC32, 0, x2); 1898 } 1899 1900 /******************************************************************************* 1901 * This function will parse the Secure Partition Manifest. From manifest, it 1902 * will fetch details for preparing Secure partition image context and secure 1903 * partition image boot arguments if any. 1904 ******************************************************************************/ 1905 static int sp_manifest_parse(void *sp_manifest, int offset, 1906 struct secure_partition_desc *sp, 1907 entry_point_info_t *ep_info, 1908 int32_t *boot_info_reg) 1909 { 1910 int32_t ret, node; 1911 uint32_t config_32; 1912 1913 /* 1914 * Look for the mandatory fields that are expected to be present in 1915 * the SP manifests. 1916 */ 1917 node = fdt_path_offset(sp_manifest, "/"); 1918 if (node < 0) { 1919 ERROR("Did not find root node.\n"); 1920 return node; 1921 } 1922 1923 ret = fdt_read_uint32_array(sp_manifest, node, "uuid", 1924 ARRAY_SIZE(sp->uuid), sp->uuid); 1925 if (ret != 0) { 1926 ERROR("Missing Secure Partition UUID.\n"); 1927 return ret; 1928 } 1929 1930 ret = fdt_read_uint32(sp_manifest, node, "exception-level", &config_32); 1931 if (ret != 0) { 1932 ERROR("Missing SP Exception Level information.\n"); 1933 return ret; 1934 } 1935 1936 sp->runtime_el = config_32; 1937 1938 ret = fdt_read_uint32(sp_manifest, node, "ffa-version", &config_32); 1939 if (ret != 0) { 1940 ERROR("Missing Secure Partition FF-A Version.\n"); 1941 return ret; 1942 } 1943 1944 sp->ffa_version = config_32; 1945 1946 ret = fdt_read_uint32(sp_manifest, node, "execution-state", &config_32); 1947 if (ret != 0) { 1948 ERROR("Missing Secure Partition Execution State.\n"); 1949 return ret; 1950 } 1951 1952 sp->execution_state = config_32; 1953 1954 ret = fdt_read_uint32(sp_manifest, node, 1955 "messaging-method", &config_32); 1956 if (ret != 0) { 1957 ERROR("Missing Secure Partition messaging method.\n"); 1958 return ret; 1959 } 1960 1961 /* Validate this entry, we currently only support direct messaging. */ 1962 if ((config_32 & ~(FFA_PARTITION_DIRECT_REQ_RECV | 1963 FFA_PARTITION_DIRECT_REQ_SEND | 1964 FFA_PARTITION_DIRECT_REQ2_RECV | 1965 FFA_PARTITION_DIRECT_REQ2_SEND)) != 0U) { 1966 WARN("Invalid Secure Partition messaging method (0x%x)\n", 1967 config_32); 1968 return -EINVAL; 1969 } 1970 1971 sp->properties = config_32; 1972 1973 ret = fdt_read_uint32(sp_manifest, node, 1974 "execution-ctx-count", &config_32); 1975 1976 if (ret != 0) { 1977 ERROR("Missing SP Execution Context Count.\n"); 1978 return ret; 1979 } 1980 1981 /* 1982 * Ensure this field is set correctly in the manifest however 1983 * since this is currently a hardcoded value for S-EL1 partitions 1984 * we don't need to save it here, just validate. 1985 */ 1986 if ((sp->runtime_el == S_EL1) && (config_32 != PLATFORM_CORE_COUNT)) { 1987 ERROR("SP Execution Context Count (%u) must be %u.\n", 1988 config_32, PLATFORM_CORE_COUNT); 1989 return -EINVAL; 1990 } 1991 1992 /* 1993 * Look for the optional fields that are expected to be present in 1994 * an SP manifest. 1995 */ 1996 ret = fdt_read_uint32(sp_manifest, node, "id", &config_32); 1997 if (ret != 0) { 1998 WARN("Missing Secure Partition ID.\n"); 1999 } else { 2000 if (!is_ffa_secure_id_valid(config_32)) { 2001 ERROR("Invalid Secure Partition ID (0x%x).\n", 2002 config_32); 2003 return -EINVAL; 2004 } 2005 sp->sp_id = config_32; 2006 } 2007 2008 ret = fdt_read_uint32(sp_manifest, node, 2009 "power-management-messages", &config_32); 2010 if (ret != 0) { 2011 WARN("Missing Power Management Messages entry.\n"); 2012 } else { 2013 if ((sp->runtime_el == S_EL0) && (config_32 != 0)) { 2014 ERROR("Power messages not supported for S-EL0 SP\n"); 2015 return -EINVAL; 2016 } 2017 2018 /* 2019 * Ensure only the currently supported power messages have 2020 * been requested. 2021 */ 2022 if (config_32 & ~(FFA_PM_MSG_SUB_CPU_OFF | 2023 FFA_PM_MSG_SUB_CPU_SUSPEND | 2024 FFA_PM_MSG_SUB_CPU_SUSPEND_RESUME)) { 2025 ERROR("Requested unsupported PM messages (%x)\n", 2026 config_32); 2027 return -EINVAL; 2028 } 2029 sp->pwr_mgmt_msgs = config_32; 2030 } 2031 2032 ret = fdt_read_uint32(sp_manifest, node, 2033 "gp-register-num", &config_32); 2034 if (ret != 0) { 2035 WARN("Missing boot information register.\n"); 2036 } else { 2037 /* Check if a register number between 0-3 is specified. */ 2038 if (config_32 < 4) { 2039 *boot_info_reg = config_32; 2040 } else { 2041 WARN("Incorrect boot information register (%u).\n", 2042 config_32); 2043 } 2044 } 2045 2046 return 0; 2047 } 2048 2049 /******************************************************************************* 2050 * This function gets the Secure Partition Manifest base and maps the manifest 2051 * region. 2052 * Currently only one Secure Partition manifest is considered which is used to 2053 * prepare the context for the single Secure Partition. 2054 ******************************************************************************/ 2055 static int find_and_prepare_sp_context(void) 2056 { 2057 void *sp_manifest; 2058 uintptr_t manifest_base; 2059 uintptr_t manifest_base_align; 2060 entry_point_info_t *next_image_ep_info; 2061 int32_t ret, boot_info_reg = -1; 2062 struct secure_partition_desc *sp; 2063 2064 next_image_ep_info = bl31_plat_get_next_image_ep_info(SECURE); 2065 if (next_image_ep_info == NULL) { 2066 WARN("No Secure Partition image provided by BL2.\n"); 2067 return -ENOENT; 2068 } 2069 2070 sp_manifest = (void *)next_image_ep_info->args.arg0; 2071 if (sp_manifest == NULL) { 2072 WARN("Secure Partition manifest absent.\n"); 2073 return -ENOENT; 2074 } 2075 2076 manifest_base = (uintptr_t)sp_manifest; 2077 manifest_base_align = page_align(manifest_base, DOWN); 2078 2079 /* 2080 * Map the secure partition manifest region in the EL3 translation 2081 * regime. 2082 * Map an area equal to (2 * PAGE_SIZE) for now. During manifest base 2083 * alignment the region of 1 PAGE_SIZE from manifest align base may 2084 * not completely accommodate the secure partition manifest region. 2085 */ 2086 ret = mmap_add_dynamic_region((unsigned long long)manifest_base_align, 2087 manifest_base_align, 2088 PAGE_SIZE * 2, 2089 MT_RO_DATA); 2090 if (ret != 0) { 2091 ERROR("Error while mapping SP manifest (%d).\n", ret); 2092 return ret; 2093 } 2094 2095 ret = fdt_node_offset_by_compatible(sp_manifest, -1, 2096 "arm,ffa-manifest-1.0"); 2097 if (ret < 0) { 2098 ERROR("Error happened in SP manifest reading.\n"); 2099 return -EINVAL; 2100 } 2101 2102 /* 2103 * Store the size of the manifest so that it can be used later to pass 2104 * the manifest as boot information later. 2105 */ 2106 next_image_ep_info->args.arg1 = fdt_totalsize(sp_manifest); 2107 INFO("Manifest adr = %lx , size = %lu bytes\n", manifest_base, 2108 next_image_ep_info->args.arg1); 2109 2110 /* 2111 * Select an SP descriptor for initialising the partition's execution 2112 * context on the primary CPU. 2113 */ 2114 sp = spmc_get_current_sp_ctx(); 2115 2116 #if SPMC_AT_EL3_SEL0_SP 2117 /* Assign translation tables context. */ 2118 sp_desc->xlat_ctx_handle = spm_get_sp_xlat_context(); 2119 2120 #endif /* SPMC_AT_EL3_SEL0_SP */ 2121 /* Initialize entry point information for the SP */ 2122 SET_PARAM_HEAD(next_image_ep_info, PARAM_EP, VERSION_1, 2123 SECURE | EP_ST_ENABLE); 2124 2125 /* Parse the SP manifest. */ 2126 ret = sp_manifest_parse(sp_manifest, ret, sp, next_image_ep_info, 2127 &boot_info_reg); 2128 if (ret != 0) { 2129 ERROR("Error in Secure Partition manifest parsing.\n"); 2130 return ret; 2131 } 2132 2133 /* Perform any common initialisation. */ 2134 spmc_sp_common_setup(sp, next_image_ep_info, boot_info_reg); 2135 2136 /* Perform any initialisation specific to S-EL1 SPs. */ 2137 if (sp->runtime_el == S_EL1) { 2138 spmc_el1_sp_setup(sp, next_image_ep_info); 2139 spmc_sp_common_ep_commit(sp, next_image_ep_info); 2140 } 2141 #if SPMC_AT_EL3_SEL0_SP 2142 /* Perform any initialisation specific to S-EL0 SPs. */ 2143 else if (sp->runtime_el == S_EL0) { 2144 /* Setup spsr in endpoint info for common context management routine. */ 2145 spmc_el0_sp_spsr_setup(next_image_ep_info); 2146 2147 spmc_sp_common_ep_commit(sp, next_image_ep_info); 2148 2149 /* 2150 * Perform any initialisation specific to S-EL0 not set by common 2151 * context management routine. 2152 */ 2153 spmc_el0_sp_setup(sp, boot_info_reg, sp_manifest); 2154 } 2155 #endif /* SPMC_AT_EL3_SEL0_SP */ 2156 else { 2157 ERROR("Unexpected runtime EL: %u\n", sp->runtime_el); 2158 return -EINVAL; 2159 } 2160 2161 return 0; 2162 } 2163 2164 /******************************************************************************* 2165 * This function takes an SP context pointer and performs a synchronous entry 2166 * into it. 2167 ******************************************************************************/ 2168 static int32_t logical_sp_init(void) 2169 { 2170 int32_t rc = 0; 2171 struct el3_lp_desc *el3_lp_descs; 2172 2173 /* Perform initial validation of the Logical Partitions. */ 2174 rc = el3_sp_desc_validate(); 2175 if (rc != 0) { 2176 ERROR("Logical Partition validation failed!\n"); 2177 return rc; 2178 } 2179 2180 el3_lp_descs = get_el3_lp_array(); 2181 2182 INFO("Logical Secure Partition init start.\n"); 2183 for (unsigned int i = 0U; i < EL3_LP_DESCS_COUNT; i++) { 2184 rc = el3_lp_descs[i].init(); 2185 if (rc != 0) { 2186 ERROR("Logical SP (0x%x) Failed to Initialize\n", 2187 el3_lp_descs[i].sp_id); 2188 return rc; 2189 } 2190 VERBOSE("Logical SP (0x%x) Initialized\n", 2191 el3_lp_descs[i].sp_id); 2192 } 2193 2194 INFO("Logical Secure Partition init completed.\n"); 2195 2196 return rc; 2197 } 2198 2199 uint64_t spmc_sp_synchronous_entry(struct sp_exec_ctx *ec) 2200 { 2201 uint64_t rc; 2202 2203 assert(ec != NULL); 2204 2205 /* Assign the context of the SP to this CPU */ 2206 cm_set_context(&(ec->cpu_ctx), SECURE); 2207 2208 /* Restore the context assigned above */ 2209 cm_el1_sysregs_context_restore(SECURE); 2210 cm_set_next_eret_context(SECURE); 2211 2212 /* Invalidate TLBs at EL1. */ 2213 tlbivmalle1(); 2214 dsbish(); 2215 2216 /* Enter Secure Partition */ 2217 rc = spm_secure_partition_enter(&ec->c_rt_ctx); 2218 2219 /* Save secure state */ 2220 cm_el1_sysregs_context_save(SECURE); 2221 2222 return rc; 2223 } 2224 2225 /******************************************************************************* 2226 * SPMC Helper Functions. 2227 ******************************************************************************/ 2228 static int32_t sp_init(void) 2229 { 2230 uint64_t rc; 2231 struct secure_partition_desc *sp; 2232 struct sp_exec_ctx *ec; 2233 2234 sp = spmc_get_current_sp_ctx(); 2235 ec = spmc_get_sp_ec(sp); 2236 ec->rt_model = RT_MODEL_INIT; 2237 ec->rt_state = RT_STATE_RUNNING; 2238 2239 INFO("Secure Partition (0x%x) init start.\n", sp->sp_id); 2240 2241 rc = spmc_sp_synchronous_entry(ec); 2242 if (rc != 0) { 2243 /* Indicate SP init was not successful. */ 2244 ERROR("SP (0x%x) failed to initialize (%lu).\n", 2245 sp->sp_id, rc); 2246 return 0; 2247 } 2248 2249 ec->rt_state = RT_STATE_WAITING; 2250 INFO("Secure Partition initialized.\n"); 2251 2252 return 1; 2253 } 2254 2255 static void initalize_sp_descs(void) 2256 { 2257 struct secure_partition_desc *sp; 2258 2259 for (unsigned int i = 0U; i < SECURE_PARTITION_COUNT; i++) { 2260 sp = &sp_desc[i]; 2261 sp->sp_id = INV_SP_ID; 2262 sp->mailbox.rx_buffer = NULL; 2263 sp->mailbox.tx_buffer = NULL; 2264 sp->mailbox.state = MAILBOX_STATE_EMPTY; 2265 sp->secondary_ep = 0; 2266 } 2267 } 2268 2269 static void initalize_ns_ep_descs(void) 2270 { 2271 struct ns_endpoint_desc *ns_ep; 2272 2273 for (unsigned int i = 0U; i < NS_PARTITION_COUNT; i++) { 2274 ns_ep = &ns_ep_desc[i]; 2275 /* 2276 * Clashes with the Hypervisor ID but will not be a 2277 * problem in practice. 2278 */ 2279 ns_ep->ns_ep_id = 0; 2280 ns_ep->ffa_version = 0; 2281 ns_ep->mailbox.rx_buffer = NULL; 2282 ns_ep->mailbox.tx_buffer = NULL; 2283 ns_ep->mailbox.state = MAILBOX_STATE_EMPTY; 2284 } 2285 } 2286 2287 /******************************************************************************* 2288 * Initialize SPMC attributes for the SPMD. 2289 ******************************************************************************/ 2290 void spmc_populate_attrs(spmc_manifest_attribute_t *spmc_attrs) 2291 { 2292 spmc_attrs->major_version = FFA_VERSION_MAJOR; 2293 spmc_attrs->minor_version = FFA_VERSION_MINOR; 2294 spmc_attrs->exec_state = MODE_RW_64; 2295 spmc_attrs->spmc_id = FFA_SPMC_ID; 2296 } 2297 2298 /******************************************************************************* 2299 * Initialize contexts of all Secure Partitions. 2300 ******************************************************************************/ 2301 int32_t spmc_setup(void) 2302 { 2303 int32_t ret; 2304 uint32_t flags; 2305 2306 /* Initialize endpoint descriptors */ 2307 initalize_sp_descs(); 2308 initalize_ns_ep_descs(); 2309 2310 /* 2311 * Retrieve the information of the datastore for tracking shared memory 2312 * requests allocated by platform code and zero the region if available. 2313 */ 2314 ret = plat_spmc_shmem_datastore_get(&spmc_shmem_obj_state.data, 2315 &spmc_shmem_obj_state.data_size); 2316 if (ret != 0) { 2317 ERROR("Failed to obtain memory descriptor backing store!\n"); 2318 return ret; 2319 } 2320 memset(spmc_shmem_obj_state.data, 0, spmc_shmem_obj_state.data_size); 2321 2322 /* Setup logical SPs. */ 2323 ret = logical_sp_init(); 2324 if (ret != 0) { 2325 ERROR("Failed to initialize Logical Partitions.\n"); 2326 return ret; 2327 } 2328 2329 /* Perform physical SP setup. */ 2330 2331 /* Disable MMU at EL1 (initialized by BL2) */ 2332 disable_mmu_icache_el1(); 2333 2334 /* Initialize context of the SP */ 2335 INFO("Secure Partition context setup start.\n"); 2336 2337 ret = find_and_prepare_sp_context(); 2338 if (ret != 0) { 2339 ERROR("Error in SP finding and context preparation.\n"); 2340 return ret; 2341 } 2342 2343 /* Register power management hooks with PSCI */ 2344 psci_register_spd_pm_hook(&spmc_pm); 2345 2346 /* 2347 * Register an interrupt handler for S-EL1 interrupts 2348 * when generated during code executing in the 2349 * non-secure state. 2350 */ 2351 flags = 0; 2352 set_interrupt_rm_flag(flags, NON_SECURE); 2353 ret = register_interrupt_type_handler(INTR_TYPE_S_EL1, 2354 spmc_sp_interrupt_handler, 2355 flags); 2356 if (ret != 0) { 2357 ERROR("Failed to register interrupt handler! (%d)\n", ret); 2358 panic(); 2359 } 2360 2361 /* Register init function for deferred init. */ 2362 bl31_register_bl32_init(&sp_init); 2363 2364 INFO("Secure Partition setup done.\n"); 2365 2366 return 0; 2367 } 2368 2369 /******************************************************************************* 2370 * Secure Partition Manager SMC handler. 2371 ******************************************************************************/ 2372 uint64_t spmc_smc_handler(uint32_t smc_fid, 2373 bool secure_origin, 2374 uint64_t x1, 2375 uint64_t x2, 2376 uint64_t x3, 2377 uint64_t x4, 2378 void *cookie, 2379 void *handle, 2380 uint64_t flags) 2381 { 2382 switch (smc_fid) { 2383 2384 case FFA_VERSION: 2385 return ffa_version_handler(smc_fid, secure_origin, x1, x2, x3, 2386 x4, cookie, handle, flags); 2387 2388 case FFA_SPM_ID_GET: 2389 return ffa_spm_id_get_handler(smc_fid, secure_origin, x1, x2, 2390 x3, x4, cookie, handle, flags); 2391 2392 case FFA_ID_GET: 2393 return ffa_id_get_handler(smc_fid, secure_origin, x1, x2, x3, 2394 x4, cookie, handle, flags); 2395 2396 case FFA_FEATURES: 2397 return ffa_features_handler(smc_fid, secure_origin, x1, x2, x3, 2398 x4, cookie, handle, flags); 2399 2400 case FFA_SECONDARY_EP_REGISTER_SMC64: 2401 return ffa_sec_ep_register_handler(smc_fid, secure_origin, x1, 2402 x2, x3, x4, cookie, handle, 2403 flags); 2404 2405 case FFA_MSG_SEND_DIRECT_REQ_SMC32: 2406 case FFA_MSG_SEND_DIRECT_REQ_SMC64: 2407 case FFA_MSG_SEND_DIRECT_REQ2_SMC64: 2408 return direct_req_smc_handler(smc_fid, secure_origin, x1, x2, 2409 x3, x4, cookie, handle, flags); 2410 2411 case FFA_MSG_SEND_DIRECT_RESP_SMC32: 2412 case FFA_MSG_SEND_DIRECT_RESP_SMC64: 2413 case FFA_MSG_SEND_DIRECT_RESP2_SMC64: 2414 return direct_resp_smc_handler(smc_fid, secure_origin, x1, x2, 2415 x3, x4, cookie, handle, flags); 2416 2417 case FFA_RXTX_MAP_SMC32: 2418 case FFA_RXTX_MAP_SMC64: 2419 return rxtx_map_handler(smc_fid, secure_origin, x1, x2, x3, x4, 2420 cookie, handle, flags); 2421 2422 case FFA_RXTX_UNMAP: 2423 return rxtx_unmap_handler(smc_fid, secure_origin, x1, x2, x3, 2424 x4, cookie, handle, flags); 2425 2426 case FFA_PARTITION_INFO_GET: 2427 return partition_info_get_handler(smc_fid, secure_origin, x1, 2428 x2, x3, x4, cookie, handle, 2429 flags); 2430 2431 case FFA_RX_RELEASE: 2432 return rx_release_handler(smc_fid, secure_origin, x1, x2, x3, 2433 x4, cookie, handle, flags); 2434 2435 case FFA_MSG_WAIT: 2436 return msg_wait_handler(smc_fid, secure_origin, x1, x2, x3, x4, 2437 cookie, handle, flags); 2438 2439 case FFA_ERROR: 2440 return ffa_error_handler(smc_fid, secure_origin, x1, x2, x3, x4, 2441 cookie, handle, flags); 2442 2443 case FFA_MSG_RUN: 2444 return ffa_run_handler(smc_fid, secure_origin, x1, x2, x3, x4, 2445 cookie, handle, flags); 2446 2447 case FFA_MEM_SHARE_SMC32: 2448 case FFA_MEM_SHARE_SMC64: 2449 case FFA_MEM_LEND_SMC32: 2450 case FFA_MEM_LEND_SMC64: 2451 return spmc_ffa_mem_send(smc_fid, secure_origin, x1, x2, x3, x4, 2452 cookie, handle, flags); 2453 2454 case FFA_MEM_FRAG_TX: 2455 return spmc_ffa_mem_frag_tx(smc_fid, secure_origin, x1, x2, x3, 2456 x4, cookie, handle, flags); 2457 2458 case FFA_MEM_FRAG_RX: 2459 return spmc_ffa_mem_frag_rx(smc_fid, secure_origin, x1, x2, x3, 2460 x4, cookie, handle, flags); 2461 2462 case FFA_MEM_RETRIEVE_REQ_SMC32: 2463 case FFA_MEM_RETRIEVE_REQ_SMC64: 2464 return spmc_ffa_mem_retrieve_req(smc_fid, secure_origin, x1, x2, 2465 x3, x4, cookie, handle, flags); 2466 2467 case FFA_MEM_RELINQUISH: 2468 return spmc_ffa_mem_relinquish(smc_fid, secure_origin, x1, x2, 2469 x3, x4, cookie, handle, flags); 2470 2471 case FFA_MEM_RECLAIM: 2472 return spmc_ffa_mem_reclaim(smc_fid, secure_origin, x1, x2, x3, 2473 x4, cookie, handle, flags); 2474 case FFA_CONSOLE_LOG_SMC32: 2475 case FFA_CONSOLE_LOG_SMC64: 2476 return spmc_ffa_console_log(smc_fid, secure_origin, x1, x2, x3, 2477 x4, cookie, handle, flags); 2478 2479 case FFA_MEM_PERM_GET_SMC32: 2480 case FFA_MEM_PERM_GET_SMC64: 2481 return ffa_mem_perm_get_handler(smc_fid, secure_origin, x1, x2, 2482 x3, x4, cookie, handle, flags); 2483 2484 case FFA_MEM_PERM_SET_SMC32: 2485 case FFA_MEM_PERM_SET_SMC64: 2486 return ffa_mem_perm_set_handler(smc_fid, secure_origin, x1, x2, 2487 x3, x4, cookie, handle, flags); 2488 2489 default: 2490 WARN("Unsupported FF-A call 0x%08x.\n", smc_fid); 2491 break; 2492 } 2493 return spmc_ffa_error_return(handle, FFA_ERROR_NOT_SUPPORTED); 2494 } 2495 2496 /******************************************************************************* 2497 * This function is the handler registered for S-EL1 interrupts by the SPMC. It 2498 * validates the interrupt and upon success arranges entry into the SP for 2499 * handling the interrupt. 2500 ******************************************************************************/ 2501 static uint64_t spmc_sp_interrupt_handler(uint32_t id, 2502 uint32_t flags, 2503 void *handle, 2504 void *cookie) 2505 { 2506 struct secure_partition_desc *sp = spmc_get_current_sp_ctx(); 2507 struct sp_exec_ctx *ec; 2508 uint32_t linear_id = plat_my_core_pos(); 2509 2510 /* Sanity check for a NULL pointer dereference. */ 2511 assert(sp != NULL); 2512 2513 /* Check the security state when the exception was generated. */ 2514 assert(get_interrupt_src_ss(flags) == NON_SECURE); 2515 2516 /* Panic if not an S-EL1 Partition. */ 2517 if (sp->runtime_el != S_EL1) { 2518 ERROR("Interrupt received for a non S-EL1 SP on core%u.\n", 2519 linear_id); 2520 panic(); 2521 } 2522 2523 /* Obtain a reference to the SP execution context. */ 2524 ec = spmc_get_sp_ec(sp); 2525 2526 /* Ensure that the execution context is in waiting state else panic. */ 2527 if (ec->rt_state != RT_STATE_WAITING) { 2528 ERROR("SP EC on core%u is not waiting (%u), it is (%u).\n", 2529 linear_id, RT_STATE_WAITING, ec->rt_state); 2530 panic(); 2531 } 2532 2533 /* Update the runtime model and state of the partition. */ 2534 ec->rt_model = RT_MODEL_INTR; 2535 ec->rt_state = RT_STATE_RUNNING; 2536 2537 VERBOSE("SP (0x%x) interrupt start on core%u.\n", sp->sp_id, linear_id); 2538 2539 /* 2540 * Forward the interrupt to the S-EL1 SP. The interrupt ID is not 2541 * populated as the SP can determine this by itself. 2542 * The flags field is forced to 0 mainly to pass the SVE hint bit 2543 * cleared for consumption by the lower EL. 2544 */ 2545 return spmd_smc_switch_state(FFA_INTERRUPT, false, 2546 FFA_PARAM_MBZ, FFA_PARAM_MBZ, 2547 FFA_PARAM_MBZ, FFA_PARAM_MBZ, 2548 handle, 0ULL); 2549 } 2550