1 2 /* 3 * Copyright (c) 2019-2025, Arm Limited and Contributors. All rights reserved. 4 * Copyright (c) 2019-2023, Intel Corporation. All rights reserved. 5 * Copyright (c) 2024-2025, Altera Corporation. All rights reserved. 6 * 7 * SPDX-License-Identifier: BSD-3-Clause 8 */ 9 10 #include <assert.h> 11 #include <common/debug.h> 12 #include <common/runtime_svc.h> 13 #include <drivers/delay_timer.h> 14 #include <lib/mmio.h> 15 #include <tools_share/uuid.h> 16 17 #include "lib/utils/alignment_utils.h" 18 #include "socfpga_fcs.h" 19 #include "socfpga_mailbox.h" 20 #include "socfpga_plat_def.h" 21 #include "socfpga_reset_manager.h" 22 #include "socfpga_sip_svc.h" 23 #include "socfpga_system_manager.h" 24 25 /* Total buffer the driver can hold */ 26 #define FPGA_CONFIG_BUFFER_SIZE 4 27 28 static config_type request_type = NO_REQUEST; 29 static int current_block, current_buffer; 30 static int read_block, max_blocks; 31 static uint32_t send_id, rcv_id; 32 static uint32_t bytes_per_block, blocks_submitted; 33 static bool bridge_disable; 34 #if PLATFORM_MODEL == PLAT_SOCFPGA_AGILEX5 35 static uint32_t g_remapper_bypass; 36 #endif 37 38 /* RSU static variables */ 39 static uint32_t rsu_dcmf_ver[4] = {0}; 40 static uint16_t rsu_dcmf_stat[4] = {0}; 41 static uint32_t rsu_max_retry; 42 43 /* SiP Service UUID */ 44 DEFINE_SVC_UUID2(intl_svc_uid, 45 0xa85273b0, 0xe85a, 0x4862, 0xa6, 0x2a, 46 0xfa, 0x88, 0x88, 0x17, 0x68, 0x81); 47 48 static uint64_t socfpga_sip_handler(uint32_t smc_fid, 49 uint64_t x1, 50 uint64_t x2, 51 uint64_t x3, 52 uint64_t x4, 53 void *cookie, 54 void *handle, 55 uint64_t flags) 56 { 57 ERROR("%s: unhandled SMC (0x%x)\n", __func__, smc_fid); 58 SMC_RET1(handle, SMC_UNK); 59 } 60 61 struct fpga_config_info fpga_config_buffers[FPGA_CONFIG_BUFFER_SIZE]; 62 63 static int intel_fpga_sdm_write_buffer(struct fpga_config_info *buffer) 64 { 65 uint32_t args[3]; 66 67 while (max_blocks > 0 && buffer->size > buffer->size_written) { 68 args[0] = (1<<8); 69 args[1] = buffer->addr + buffer->size_written; 70 if (buffer->size - buffer->size_written <= bytes_per_block) { 71 args[2] = buffer->size - buffer->size_written; 72 current_buffer++; 73 current_buffer %= FPGA_CONFIG_BUFFER_SIZE; 74 } else { 75 args[2] = bytes_per_block; 76 } 77 78 buffer->size_written += args[2]; 79 mailbox_send_cmd_async(&send_id, MBOX_RECONFIG_DATA, args, 80 3U, CMD_INDIRECT); 81 82 buffer->subblocks_sent++; 83 max_blocks--; 84 } 85 86 return !max_blocks; 87 } 88 89 static int intel_fpga_sdm_write_all(void) 90 { 91 for (int i = 0; i < FPGA_CONFIG_BUFFER_SIZE; i++) { 92 if (intel_fpga_sdm_write_buffer( 93 &fpga_config_buffers[current_buffer])) { 94 break; 95 } 96 } 97 return 0; 98 } 99 100 static uint32_t intel_mailbox_fpga_config_isdone(uint32_t *err_states) 101 { 102 uint32_t ret; 103 104 if (err_states == NULL) 105 return INTEL_SIP_SMC_STATUS_REJECTED; 106 107 switch (request_type) { 108 case RECONFIGURATION: 109 ret = intel_mailbox_get_config_status(MBOX_RECONFIG_STATUS, 110 true, err_states); 111 break; 112 case BITSTREAM_AUTH: 113 ret = intel_mailbox_get_config_status(MBOX_RECONFIG_STATUS, 114 false, err_states); 115 break; 116 default: 117 ret = intel_mailbox_get_config_status(MBOX_CONFIG_STATUS, 118 false, err_states); 119 break; 120 } 121 122 if (ret != 0U) { 123 if (ret == MBOX_CFGSTAT_STATE_CONFIG) { 124 return INTEL_SIP_SMC_STATUS_BUSY; 125 } else { 126 request_type = NO_REQUEST; 127 return INTEL_SIP_SMC_STATUS_ERROR; 128 } 129 } 130 131 if (bridge_disable != 0U) { 132 socfpga_bridges_enable(~0); /* Enable bridge */ 133 bridge_disable = false; 134 } 135 request_type = NO_REQUEST; 136 137 return INTEL_SIP_SMC_STATUS_OK; 138 } 139 140 static int mark_last_buffer_xfer_completed(uint32_t *buffer_addr_completed) 141 { 142 int i; 143 144 for (i = 0; i < FPGA_CONFIG_BUFFER_SIZE; i++) { 145 if (fpga_config_buffers[i].block_number == current_block) { 146 fpga_config_buffers[i].subblocks_sent--; 147 if (fpga_config_buffers[i].subblocks_sent == 0 148 && fpga_config_buffers[i].size <= 149 fpga_config_buffers[i].size_written) { 150 fpga_config_buffers[i].write_requested = 0; 151 current_block++; 152 *buffer_addr_completed = 153 fpga_config_buffers[i].addr; 154 return 0; 155 } 156 } 157 } 158 159 return -1; 160 } 161 162 static int intel_fpga_config_completed_write(uint32_t *completed_addr, 163 uint32_t *count, uint32_t *job_id) 164 { 165 uint32_t resp[5]; 166 unsigned int resp_len = ARRAY_SIZE(resp); 167 int status = INTEL_SIP_SMC_STATUS_OK; 168 int all_completed = 1; 169 *count = 0; 170 171 while (*count < 3) { 172 173 status = mailbox_read_response(job_id, 174 resp, &resp_len); 175 176 if (status < 0) { 177 break; 178 } 179 180 max_blocks++; 181 182 if (mark_last_buffer_xfer_completed( 183 &completed_addr[*count]) == 0) { 184 *count = *count + 1; 185 } else { 186 break; 187 } 188 } 189 190 if (*count <= 0) { 191 if (status != MBOX_NO_RESPONSE && 192 status != MBOX_TIMEOUT && resp_len != 0) { 193 mailbox_clear_response(); 194 request_type = NO_REQUEST; 195 return INTEL_SIP_SMC_STATUS_ERROR; 196 } 197 198 *count = 0; 199 } 200 201 intel_fpga_sdm_write_all(); 202 203 if (*count > 0) { 204 status = INTEL_SIP_SMC_STATUS_OK; 205 } else if (*count == 0) { 206 status = INTEL_SIP_SMC_STATUS_BUSY; 207 } 208 209 for (int i = 0; i < FPGA_CONFIG_BUFFER_SIZE; i++) { 210 if (fpga_config_buffers[i].write_requested != 0) { 211 all_completed = 0; 212 break; 213 } 214 } 215 216 if (all_completed == 1) { 217 return INTEL_SIP_SMC_STATUS_OK; 218 } 219 220 return status; 221 } 222 223 static int intel_fpga_config_start(uint32_t flag) 224 { 225 uint32_t argument = 0x1; 226 uint32_t response[3]; 227 int status = 0; 228 unsigned int size = 0; 229 unsigned int resp_len = ARRAY_SIZE(response); 230 231 #if PLATFORM_MODEL == PLAT_SOCFPGA_AGILEX5 232 /* 233 * To trigger isolation 234 * FPGA configuration complete signal should be de-asserted 235 */ 236 INFO("SOCFPGA: Request SDM to trigger isolation\n"); 237 status = mailbox_send_fpga_config_comp(); 238 239 if (status < 0) { 240 INFO("SOCFPGA: Isolation for FPGA configuration complete is not executed\n"); 241 } 242 #endif 243 244 request_type = RECONFIGURATION; 245 246 if (!CONFIG_TEST_FLAG(flag, PARTIAL_CONFIG)) { 247 bridge_disable = true; 248 } 249 250 if (CONFIG_TEST_FLAG(flag, AUTHENTICATION)) { 251 size = 1; 252 bridge_disable = false; 253 request_type = BITSTREAM_AUTH; 254 } 255 256 #if PLATFORM_MODEL == PLAT_SOCFPGA_AGILEX5 257 intel_smmu_hps_remapper_init(0U); 258 #endif 259 260 mailbox_clear_response(); 261 262 mailbox_send_cmd(MBOX_JOB_ID, MBOX_CMD_CANCEL, NULL, 0U, 263 CMD_CASUAL, NULL, NULL); 264 265 status = mailbox_send_cmd(MBOX_JOB_ID, MBOX_RECONFIG, &argument, size, 266 CMD_CASUAL, response, &resp_len); 267 268 if (status < 0) { 269 bridge_disable = false; 270 request_type = NO_REQUEST; 271 return INTEL_SIP_SMC_STATUS_ERROR; 272 } 273 274 max_blocks = response[0]; 275 bytes_per_block = response[1]; 276 277 for (int i = 0; i < FPGA_CONFIG_BUFFER_SIZE; i++) { 278 fpga_config_buffers[i].size = 0; 279 fpga_config_buffers[i].size_written = 0; 280 fpga_config_buffers[i].addr = 0; 281 fpga_config_buffers[i].write_requested = 0; 282 fpga_config_buffers[i].block_number = 0; 283 fpga_config_buffers[i].subblocks_sent = 0; 284 } 285 286 blocks_submitted = 0; 287 current_block = 0; 288 read_block = 0; 289 current_buffer = 0; 290 291 /* Disable bridge on full reconfiguration */ 292 if (bridge_disable) { 293 socfpga_bridges_disable(~0); 294 } 295 296 return INTEL_SIP_SMC_STATUS_OK; 297 } 298 299 static bool is_fpga_config_buffer_full(void) 300 { 301 for (int i = 0; i < FPGA_CONFIG_BUFFER_SIZE; i++) { 302 if (!fpga_config_buffers[i].write_requested) { 303 return false; 304 } 305 } 306 return true; 307 } 308 309 bool is_address_in_ddr_range(uint64_t addr, uint64_t size) 310 { 311 uint128_t dram_max_sz = (uint128_t)DRAM_BASE + (uint128_t)DRAM_SIZE; 312 uint128_t dram_region_end = (uint128_t)addr + (uint128_t)size; 313 314 if (!addr && !size) { 315 return true; 316 } 317 if (size > (UINT64_MAX - addr)) { 318 return false; 319 } 320 if (addr < BL31_LIMIT) { 321 return false; 322 } 323 if (dram_region_end > dram_max_sz) { 324 return false; 325 } 326 327 return true; 328 } 329 330 static uint32_t intel_fpga_config_write(uint64_t mem, uint64_t size) 331 { 332 int i; 333 334 intel_fpga_sdm_write_all(); 335 336 if (!is_address_in_ddr_range(mem, size) || 337 is_fpga_config_buffer_full()) { 338 return INTEL_SIP_SMC_STATUS_REJECTED; 339 } 340 341 #if PLATFORM_MODEL == PLAT_SOCFPGA_AGILEX5 342 intel_smmu_hps_remapper_init(&mem); 343 #endif 344 345 for (i = 0; i < FPGA_CONFIG_BUFFER_SIZE; i++) { 346 int j = (i + current_buffer) % FPGA_CONFIG_BUFFER_SIZE; 347 348 if (!fpga_config_buffers[j].write_requested) { 349 fpga_config_buffers[j].addr = mem; 350 fpga_config_buffers[j].size = size; 351 fpga_config_buffers[j].size_written = 0; 352 fpga_config_buffers[j].write_requested = 1; 353 fpga_config_buffers[j].block_number = 354 blocks_submitted++; 355 fpga_config_buffers[j].subblocks_sent = 0; 356 break; 357 } 358 } 359 360 if (is_fpga_config_buffer_full()) { 361 return INTEL_SIP_SMC_STATUS_BUSY; 362 } 363 364 return INTEL_SIP_SMC_STATUS_OK; 365 } 366 367 static int is_out_of_sec_range(uint64_t reg_addr) 368 { 369 #if DEBUG 370 return 0; 371 #endif 372 373 #if PLATFORM_MODEL != PLAT_SOCFPGA_AGILEX5 374 switch (reg_addr) { 375 case(0xF8011100): /* ECCCTRL1 */ 376 case(0xF8011104): /* ECCCTRL2 */ 377 case(0xF8011110): /* ERRINTEN */ 378 case(0xF8011114): /* ERRINTENS */ 379 case(0xF8011118): /* ERRINTENR */ 380 case(0xF801111C): /* INTMODE */ 381 case(0xF8011120): /* INTSTAT */ 382 case(0xF8011124): /* DIAGINTTEST */ 383 case(0xF801112C): /* DERRADDRA */ 384 case(0xFA000000): /* SMMU SCR0 */ 385 case(0xFA000004): /* SMMU SCR1 */ 386 case(0xFA000400): /* SMMU NSCR0 */ 387 case(0xFA004000): /* SMMU SSD0_REG */ 388 case(0xFA000820): /* SMMU SMR8 */ 389 case(0xFA000c20): /* SMMU SCR8 */ 390 case(0xFA028000): /* SMMU CB8_SCTRL */ 391 case(0xFA001020): /* SMMU CBAR8 */ 392 case(0xFA028030): /* SMMU TCR_LPAE */ 393 case(0xFA028020): /* SMMU CB8_TTBR0_LOW */ 394 case(0xFA028024): /* SMMU CB8_PRRR_HIGH */ 395 case(0xFA028038): /* SMMU CB8_PRRR_MIR0 */ 396 case(0xFA02803C): /* SMMU CB8_PRRR_MIR1 */ 397 case(0xFA028010): /* SMMU_CB8)TCR2 */ 398 case(0xFFD080A4): /* SDM SMMU STREAM ID REG */ 399 case(0xFA001820): /* SMMU_CBA2R8 */ 400 case(0xFA000074): /* SMMU_STLBGSTATUS */ 401 case(0xFA0287F4): /* SMMU_CB8_TLBSTATUS */ 402 case(0xFA000060): /* SMMU_STLBIALL */ 403 case(0xFA000070): /* SMMU_STLBGSYNC */ 404 case(0xFA028618): /* CB8_TLBALL */ 405 case(0xFA0287F0): /* CB8_TLBSYNC */ 406 case(0xFFD12028): /* SDMMCGRP_CTRL */ 407 case(0xFFD12044): /* EMAC0 */ 408 case(0xFFD12048): /* EMAC1 */ 409 case(0xFFD1204C): /* EMAC2 */ 410 case(0xFFD12090): /* ECC_INT_MASK_VALUE */ 411 case(0xFFD12094): /* ECC_INT_MASK_SET */ 412 case(0xFFD12098): /* ECC_INT_MASK_CLEAR */ 413 case(0xFFD1209C): /* ECC_INTSTATUS_SERR */ 414 case(0xFFD120A0): /* ECC_INTSTATUS_DERR */ 415 case(0xFFD120C0): /* NOC_TIMEOUT */ 416 case(0xFFD120C4): /* NOC_IDLEREQ_SET */ 417 case(0xFFD120C8): /* NOC_IDLEREQ_CLR */ 418 case(0xFFD120D0): /* NOC_IDLEACK */ 419 case(0xFFD120D4): /* NOC_IDLESTATUS */ 420 case(0xFFD12200): /* BOOT_SCRATCH_COLD0 */ 421 case(0xFFD12204): /* BOOT_SCRATCH_COLD1 */ 422 case(0xFFD12220): /* BOOT_SCRATCH_COLD8 */ 423 case(0xFFD12224): /* BOOT_SCRATCH_COLD9 */ 424 return 0; 425 #else 426 switch (reg_addr) { 427 428 case(0xF8011104): /* ECCCTRL2 */ 429 case(0xFFD12028): /* SDMMCGRP_CTRL */ 430 case(0xFFD120C4): /* NOC_IDLEREQ_SET */ 431 case(0xFFD120C8): /* NOC_IDLEREQ_CLR */ 432 case(0xFFD120D0): /* NOC_IDLEACK */ 433 434 435 case(SOCFPGA_MEMCTRL(ECCCTRL1)): /* ECCCTRL1 */ 436 case(SOCFPGA_MEMCTRL(ERRINTEN)): /* ERRINTEN */ 437 case(SOCFPGA_MEMCTRL(ERRINTENS)): /* ERRINTENS */ 438 case(SOCFPGA_MEMCTRL(ERRINTENR)): /* ERRINTENR */ 439 case(SOCFPGA_MEMCTRL(INTMODE)): /* INTMODE */ 440 case(SOCFPGA_MEMCTRL(INTSTAT)): /* INTSTAT */ 441 case(SOCFPGA_MEMCTRL(DIAGINTTEST)): /* DIAGINTTEST */ 442 case(SOCFPGA_MEMCTRL(DERRADDRA)): /* DERRADDRA */ 443 444 case(SOCFPGA_ECC_QSPI(INITSTAT)): /* ECC_QSPI_INITSTAT */ 445 case(SOCFPGA_SYSMGR(EMAC_0)): /* EMAC0 */ 446 case(SOCFPGA_SYSMGR(EMAC_1)): /* EMAC1 */ 447 case(SOCFPGA_SYSMGR(EMAC_2)): /* EMAC2 */ 448 449 /* TSN stream control registers — only accessible on Agilex5 B0 */ 450 case SOCFPGA_SYSMGR(TSN_TBU_STREAM_CTRL_REG_3_TSN0): 451 case SOCFPGA_SYSMGR(TSN_TBU_STREAM_CTRL_REG_3_TSN1): 452 case SOCFPGA_SYSMGR(TSN_TBU_STREAM_CTRL_REG_3_TSN2): 453 if (is_agilex5_A5F4() == true) { 454 return 0; 455 } 456 break; 457 458 case(SOCFPGA_SYSMGR(ECC_INTMASK_VALUE)): /* ECC_INT_MASK_VALUE */ 459 case(SOCFPGA_SYSMGR(ECC_INTMASK_SET)): /* ECC_INT_MASK_SET */ 460 case(SOCFPGA_SYSMGR(ECC_INTMASK_CLR)): /* ECC_INT_MASK_CLEAR */ 461 case(SOCFPGA_SYSMGR(ECC_INTMASK_SERR)): /* ECC_INTSTATUS_SERR */ 462 case(SOCFPGA_SYSMGR(ECC_INTMASK_DERR)): /* ECC_INTSTATUS_DERR */ 463 case(SOCFPGA_SYSMGR(NOC_TIMEOUT)): /* NOC_TIMEOUT */ 464 case(SOCFPGA_SYSMGR(NOC_IDLESTATUS)): /* NOC_IDLESTATUS */ 465 case(SOCFPGA_SYSMGR(BOOT_SCRATCH_COLD_0)): /* BOOT_SCRATCH_COLD0 */ 466 case(SOCFPGA_SYSMGR(BOOT_SCRATCH_COLD_1)): /* BOOT_SCRATCH_COLD1 */ 467 case(SOCFPGA_SYSMGR(BOOT_SCRATCH_COLD_8)): /* BOOT_SCRATCH_COLD8 */ 468 case(SOCFPGA_SYSMGR(BOOT_SCRATCH_COLD_9)): /* BOOT_SCRATCH_COLD9 */ 469 #endif 470 case(SOCFPGA_ECC_QSPI(CTRL)): /* ECC_QSPI_CTRL */ 471 case(SOCFPGA_ECC_QSPI(ERRINTEN)): /* ECC_QSPI_ERRINTEN */ 472 case(SOCFPGA_ECC_QSPI(ERRINTENS)): /* ECC_QSPI_ERRINTENS */ 473 case(SOCFPGA_ECC_QSPI(ERRINTENR)): /* ECC_QSPI_ERRINTENR */ 474 case(SOCFPGA_ECC_QSPI(INTMODE)): /* ECC_QSPI_INTMODE */ 475 case(SOCFPGA_ECC_QSPI(ECC_ACCCTRL)): /* ECC_QSPI_ECC_ACCCTRL */ 476 case(SOCFPGA_ECC_QSPI(ECC_STARTACC)): /* ECC_QSPI_ECC_STARTACC */ 477 case(SOCFPGA_ECC_QSPI(ECC_WDCTRL)): /* ECC_QSPI_ECC_WDCTRL */ 478 case(SOCFPGA_ECC_QSPI(INTSTAT)): /* ECC_QSPI_INTSTAT */ 479 case(SOCFPGA_ECC_QSPI(INTTEST)): /* ECC_QSPI_INTMODE */ 480 return 0; 481 482 default: 483 break; 484 } 485 486 return -1; 487 } 488 489 /* Secure register access */ 490 uint32_t intel_secure_reg_read(uint64_t reg_addr, uint32_t *retval) 491 { 492 if (is_out_of_sec_range(reg_addr)) { 493 return INTEL_SIP_SMC_STATUS_ERROR; 494 } 495 496 *retval = mmio_read_32(reg_addr); 497 498 return INTEL_SIP_SMC_STATUS_OK; 499 } 500 501 uint32_t intel_secure_reg_write(uint64_t reg_addr, uint32_t val, 502 uint32_t *retval) 503 { 504 if (is_out_of_sec_range(reg_addr)) { 505 return INTEL_SIP_SMC_STATUS_ERROR; 506 } 507 508 switch (reg_addr) { 509 case(SOCFPGA_ECC_QSPI(INTSTAT)): /* ECC_QSPI_INTSTAT */ 510 case(SOCFPGA_ECC_QSPI(INTTEST)): /* ECC_QSPI_INTMODE */ 511 mmio_write_16(reg_addr, val); 512 break; 513 default: 514 mmio_write_32(reg_addr, val); 515 break; 516 } 517 518 return intel_secure_reg_read(reg_addr, retval); 519 } 520 521 uint32_t intel_secure_reg_update(uint64_t reg_addr, uint32_t mask, 522 uint32_t val, uint32_t *retval) 523 { 524 if (!intel_secure_reg_read(reg_addr, retval)) { 525 *retval &= ~mask; 526 *retval |= val & mask; 527 return intel_secure_reg_write(reg_addr, *retval, retval); 528 } 529 530 return INTEL_SIP_SMC_STATUS_ERROR; 531 } 532 533 /* Intel Remote System Update (RSU) services */ 534 uint64_t intel_rsu_update_address; 535 536 static uint32_t intel_rsu_status(uint64_t *respbuf, unsigned int respbuf_sz) 537 { 538 if (mailbox_rsu_status((uint32_t *)respbuf, respbuf_sz) < 0) { 539 return INTEL_SIP_SMC_RSU_ERROR; 540 } 541 542 return INTEL_SIP_SMC_STATUS_OK; 543 } 544 545 static uint32_t intel_rsu_get_device_info(uint32_t *respbuf, 546 unsigned int respbuf_sz) 547 { 548 if (mailbox_rsu_get_device_info((uint32_t *)respbuf, respbuf_sz) < 0) { 549 return INTEL_SIP_SMC_RSU_ERROR; 550 } 551 552 return INTEL_SIP_SMC_STATUS_OK; 553 } 554 555 uint32_t intel_rsu_update(uint64_t update_address) 556 { 557 if (update_address > SIZE_MAX) { 558 return INTEL_SIP_SMC_STATUS_REJECTED; 559 } 560 561 intel_rsu_update_address = update_address; 562 return INTEL_SIP_SMC_STATUS_OK; 563 } 564 565 static uint32_t intel_rsu_notify(uint32_t execution_stage) 566 { 567 if (mailbox_hps_stage_notify(execution_stage) < 0) { 568 return INTEL_SIP_SMC_RSU_ERROR; 569 } 570 571 return INTEL_SIP_SMC_STATUS_OK; 572 } 573 574 static uint32_t intel_rsu_retry_counter(uint32_t *respbuf, uint32_t respbuf_sz, 575 uint32_t *ret_stat) 576 { 577 if (mailbox_rsu_status((uint32_t *)respbuf, respbuf_sz) < 0) { 578 return INTEL_SIP_SMC_RSU_ERROR; 579 } 580 581 *ret_stat = respbuf[8]; 582 return INTEL_SIP_SMC_STATUS_OK; 583 } 584 585 static uint32_t intel_rsu_copy_dcmf_version(uint64_t dcmf_ver_1_0, 586 uint64_t dcmf_ver_3_2) 587 { 588 rsu_dcmf_ver[0] = dcmf_ver_1_0; 589 rsu_dcmf_ver[1] = dcmf_ver_1_0 >> 32; 590 rsu_dcmf_ver[2] = dcmf_ver_3_2; 591 rsu_dcmf_ver[3] = dcmf_ver_3_2 >> 32; 592 593 return INTEL_SIP_SMC_STATUS_OK; 594 } 595 596 static uint32_t intel_rsu_copy_dcmf_status(uint64_t dcmf_stat) 597 { 598 rsu_dcmf_stat[0] = 0xFFFF & (dcmf_stat >> (0 * 16)); 599 rsu_dcmf_stat[1] = 0xFFFF & (dcmf_stat >> (1 * 16)); 600 rsu_dcmf_stat[2] = 0xFFFF & (dcmf_stat >> (2 * 16)); 601 rsu_dcmf_stat[3] = 0xFFFF & (dcmf_stat >> (3 * 16)); 602 603 return INTEL_SIP_SMC_STATUS_OK; 604 } 605 606 /* Intel HWMON services */ 607 static uint32_t intel_hwmon_readtemp(uint32_t chan, uint32_t *retval) 608 { 609 if (mailbox_hwmon_readtemp(chan, retval) < 0) { 610 return INTEL_SIP_SMC_STATUS_ERROR; 611 } 612 613 return INTEL_SIP_SMC_STATUS_OK; 614 } 615 616 static uint32_t intel_hwmon_readvolt(uint32_t chan, uint32_t *retval) 617 { 618 if (mailbox_hwmon_readvolt(chan, retval) < 0) { 619 return INTEL_SIP_SMC_STATUS_ERROR; 620 } 621 622 return INTEL_SIP_SMC_STATUS_OK; 623 } 624 625 /* Mailbox services */ 626 static uint32_t intel_smc_fw_version(uint32_t *fw_version) 627 { 628 int status; 629 unsigned int resp_len = CONFIG_STATUS_WORD_SIZE; 630 uint32_t resp_data[CONFIG_STATUS_WORD_SIZE] = {0U}; 631 632 status = mailbox_send_cmd(MBOX_JOB_ID, MBOX_CONFIG_STATUS, NULL, 0U, 633 CMD_CASUAL, resp_data, &resp_len); 634 635 if (status < 0) { 636 return INTEL_SIP_SMC_STATUS_ERROR; 637 } 638 639 if (resp_len <= CONFIG_STATUS_FW_VER_OFFSET) { 640 return INTEL_SIP_SMC_STATUS_ERROR; 641 } 642 643 *fw_version = resp_data[CONFIG_STATUS_FW_VER_OFFSET] & CONFIG_STATUS_FW_VER_MASK; 644 645 return INTEL_SIP_SMC_STATUS_OK; 646 } 647 648 static uint32_t intel_mbox_send_cmd(uint32_t cmd, uint32_t *args, 649 unsigned int len, uint32_t urgent, uint64_t response, 650 unsigned int resp_len, int *mbox_status, 651 unsigned int *len_in_resp) 652 { 653 *len_in_resp = 0; 654 *mbox_status = GENERIC_RESPONSE_ERROR; 655 656 if (!is_address_in_ddr_range((uint64_t)args, sizeof(uint32_t) * len)) { 657 return INTEL_SIP_SMC_STATUS_REJECTED; 658 } 659 660 int status = mailbox_send_cmd(MBOX_JOB_ID, cmd, args, len, urgent, 661 (uint32_t *) response, &resp_len); 662 663 if (status < 0) { 664 *mbox_status = -status; 665 return INTEL_SIP_SMC_STATUS_ERROR; 666 } 667 668 *mbox_status = 0; 669 *len_in_resp = resp_len; 670 671 flush_dcache_range(response, resp_len * MBOX_WORD_BYTE); 672 673 return INTEL_SIP_SMC_STATUS_OK; 674 } 675 676 static int intel_smc_get_usercode(uint32_t *user_code) 677 { 678 int status; 679 unsigned int resp_len = sizeof(user_code) / MBOX_WORD_BYTE; 680 681 status = mailbox_send_cmd(MBOX_JOB_ID, MBOX_CMD_GET_USERCODE, NULL, 682 0U, CMD_CASUAL, user_code, &resp_len); 683 684 if (status < 0) { 685 return INTEL_SIP_SMC_STATUS_ERROR; 686 } 687 688 return INTEL_SIP_SMC_STATUS_OK; 689 } 690 691 uint32_t intel_smc_service_completed(uint64_t addr, uint32_t size, 692 uint32_t mode, uint32_t *job_id, 693 uint32_t *ret_size, uint32_t *mbox_error) 694 { 695 int status = 0; 696 uint32_t resp_len = size / MBOX_WORD_BYTE; 697 698 if (resp_len > MBOX_DATA_MAX_LEN) { 699 return INTEL_SIP_SMC_STATUS_REJECTED; 700 } 701 702 if (!is_address_in_ddr_range(addr, size)) { 703 return INTEL_SIP_SMC_STATUS_REJECTED; 704 } 705 706 if (mode == SERVICE_COMPLETED_MODE_ASYNC) { 707 status = mailbox_read_response_async(job_id, 708 NULL, (uint32_t *) addr, &resp_len, 0); 709 } else { 710 status = mailbox_read_response(job_id, 711 (uint32_t *) addr, &resp_len); 712 713 if (status == MBOX_NO_RESPONSE) { 714 status = MBOX_BUSY; 715 } 716 } 717 718 if (status == MBOX_NO_RESPONSE) { 719 return INTEL_SIP_SMC_STATUS_NO_RESPONSE; 720 } 721 722 if (status == MBOX_BUSY) { 723 return INTEL_SIP_SMC_STATUS_BUSY; 724 } 725 726 *ret_size = resp_len * MBOX_WORD_BYTE; 727 flush_dcache_range(addr, *ret_size); 728 729 if (status == MBOX_RET_SDOS_DECRYPTION_ERROR_102 || 730 status == MBOX_RET_SDOS_DECRYPTION_ERROR_103) { 731 *mbox_error = -status; 732 } else if (status != MBOX_RET_OK) { 733 *mbox_error = -status; 734 return INTEL_SIP_SMC_STATUS_ERROR; 735 } 736 737 return INTEL_SIP_SMC_STATUS_OK; 738 } 739 740 /* Miscellaneous HPS services */ 741 uint32_t intel_hps_set_bridges(uint64_t enable, uint64_t mask) 742 { 743 int status = 0; 744 745 if ((enable & SOCFPGA_BRIDGE_ENABLE) != 0U) { 746 if ((enable & SOCFPGA_BRIDGE_HAS_MASK) != 0U) { 747 status = socfpga_bridges_enable((uint32_t)mask); 748 } else { 749 status = socfpga_bridges_enable(~0); 750 } 751 } else { 752 if ((enable & SOCFPGA_BRIDGE_HAS_MASK) != 0U) { 753 status = socfpga_bridges_disable((uint32_t)mask); 754 } else { 755 status = socfpga_bridges_disable(~0); 756 } 757 } 758 759 if (status < 0) { 760 return INTEL_SIP_SMC_STATUS_ERROR; 761 } 762 763 return INTEL_SIP_SMC_STATUS_OK; 764 } 765 766 /* SDM SEU Error services */ 767 static uint32_t intel_sdm_seu_err_read(uint32_t *respbuf, unsigned int respbuf_sz) 768 { 769 if (mailbox_seu_err_status(respbuf, respbuf_sz) < 0) { 770 return INTEL_SIP_SMC_SEU_ERR_READ_ERROR; 771 } 772 773 return INTEL_SIP_SMC_STATUS_OK; 774 } 775 776 /* SDM SAFE SEU Error inject services */ 777 static uint32_t intel_sdm_safe_inject_seu_err(uint32_t *command, uint32_t len) 778 { 779 if (mailbox_safe_inject_seu_err(command, len) < 0) { 780 return INTEL_SIP_SMC_SEU_ERR_READ_ERROR; 781 } 782 783 return INTEL_SIP_SMC_STATUS_OK; 784 } 785 786 #if PLATFORM_MODEL == PLAT_SOCFPGA_AGILEX5 787 /* SMMU HPS Remapper */ 788 void intel_smmu_hps_remapper_init(uint64_t *mem) 789 { 790 /* Read out Bit 1 value */ 791 uint32_t remap = (mmio_read_32(SOCFPGA_SYSMGR(BOOT_SCRATCH_POR_1)) & 0x02); 792 793 if ((remap == 0x00) && (g_remapper_bypass == 0x00)) { 794 /* Update DRAM Base address for SDM SMMU */ 795 mmio_write_32(SOCFPGA_SYSMGR(SDM_BE_ARADDR_REMAP), DRAM_BASE); 796 mmio_write_32(SOCFPGA_SYSMGR(SDM_BE_AWADDR_REMAP), DRAM_BASE); 797 *mem = *mem - DRAM_BASE; 798 } else { 799 *mem = *mem - DRAM_BASE; 800 } 801 } 802 803 int intel_smmu_hps_remapper_config(uint32_t remapper_bypass) 804 { 805 /* Read out the JTAG-ID from boot scratch register */ 806 if (is_agilex5_A5C0() || is_agilex5_A5C4()) { 807 if (remapper_bypass == 0x01) { 808 g_remapper_bypass = remapper_bypass; 809 mmio_write_32(SOCFPGA_SYSMGR(SDM_BE_ARADDR_REMAP), 0); 810 mmio_write_32(SOCFPGA_SYSMGR(SDM_BE_AWADDR_REMAP), 0); 811 } 812 } 813 return INTEL_SIP_SMC_STATUS_OK; 814 } 815 816 static void intel_inject_io96b_ecc_err(const uint32_t *syndrome, const uint32_t command) 817 { 818 volatile uint64_t atf_ddr_buffer; 819 volatile uint64_t val; 820 821 mmio_write_32(IOSSM_CMD_PARAM, *syndrome); 822 mmio_write_32(IOSSM_CMD_TRIG_OP, command); 823 udelay(IOSSM_ECC_ERR_INJ_DELAY_USECS); 824 atf_ddr_buffer = 0xCAFEBABEFEEDFACE; /* Write data */ 825 memcpy_s((void *)&val, sizeof(val), 826 (void *)&atf_ddr_buffer, sizeof(atf_ddr_buffer)); 827 828 /* Clear response_ready BIT0 of status_register before sending next command. */ 829 mmio_clrbits_32(IOSSM_CMD_RESP_STATUS, IOSSM_CMD_STATUS_RESP_READY); 830 } 831 #endif 832 833 #if SIP_SVC_V3 834 uint8_t sip_smc_cmd_cb_ret2(void *resp_desc, void *cmd_desc, uint64_t *ret_args) 835 { 836 uint8_t ret_args_len = 0U; 837 sdm_response_t *resp = (sdm_response_t *)resp_desc; 838 sdm_command_t *cmd = (sdm_command_t *)cmd_desc; 839 840 (void)cmd; 841 /* Returns 3 SMC arguments for SMC_RET3 */ 842 ret_args[ret_args_len++] = INTEL_SIP_SMC_STATUS_OK; 843 ret_args[ret_args_len++] = resp->err_code; 844 845 return ret_args_len; 846 } 847 848 uint8_t sip_smc_cmd_cb_ret3(void *resp_desc, void *cmd_desc, uint64_t *ret_args) 849 { 850 uint8_t ret_args_len = 0U; 851 sdm_response_t *resp = (sdm_response_t *)resp_desc; 852 sdm_command_t *cmd = (sdm_command_t *)cmd_desc; 853 854 (void)cmd; 855 /* Returns 3 SMC arguments for SMC_RET3 */ 856 ret_args[ret_args_len++] = INTEL_SIP_SMC_STATUS_OK; 857 ret_args[ret_args_len++] = resp->err_code; 858 ret_args[ret_args_len++] = resp->resp_data[0]; 859 860 return ret_args_len; 861 } 862 863 uint8_t sip_smc_ret_nbytes_cb(void *resp_desc, void *cmd_desc, uint64_t *ret_args) 864 { 865 uint8_t ret_args_len = 0U; 866 sdm_response_t *resp = (sdm_response_t *)resp_desc; 867 sdm_command_t *cmd = (sdm_command_t *)cmd_desc; 868 869 INFO("MBOX: %s: mailbox_err 0%x, nbytes_ret %d\n", 870 __func__, resp->err_code, resp->rcvd_resp_len * MBOX_WORD_BYTE); 871 872 ret_args[ret_args_len++] = INTEL_SIP_SMC_STATUS_OK; 873 ret_args[ret_args_len++] = resp->err_code; 874 ret_args[ret_args_len++] = resp->rcvd_resp_len * MBOX_WORD_BYTE; 875 876 /* Flush the response data buffer. */ 877 flush_dcache_range((uintptr_t)cmd->cb_args, resp->rcvd_resp_len * MBOX_WORD_BYTE); 878 879 return ret_args_len; 880 } 881 882 uint8_t sip_smc_get_chipid_cb(void *resp_desc, void *cmd_desc, uint64_t *ret_args) 883 { 884 uint8_t ret_args_len = 0U; 885 sdm_response_t *resp = (sdm_response_t *)resp_desc; 886 sdm_command_t *cmd = (sdm_command_t *)cmd_desc; 887 888 (void)cmd; 889 INFO("MBOX: %s: mailbox_err 0%x, data[0] 0x%x, data[1] 0x%x\n", 890 __func__, resp->err_code, resp->resp_data[0], resp->resp_data[1]); 891 892 ret_args[ret_args_len++] = INTEL_SIP_SMC_STATUS_OK; 893 ret_args[ret_args_len++] = resp->err_code; 894 ret_args[ret_args_len++] = resp->resp_data[0]; 895 ret_args[ret_args_len++] = resp->resp_data[1]; 896 897 return ret_args_len; 898 } 899 900 uint8_t sip_smc_cmd_cb_rsu_status(void *resp_desc, void *cmd_desc, uint64_t *ret_args) 901 { 902 uint8_t ret_args_len = 0U; 903 uint32_t retry_counter = ~0U; 904 uint32_t failure_source = 0U; 905 sdm_response_t *resp = (sdm_response_t *)resp_desc; 906 sdm_command_t *cmd = (sdm_command_t *)cmd_desc; 907 908 (void)cmd; 909 /* Get the failure source and current image retry counter value from the response. */ 910 failure_source = resp->resp_data[5] & RSU_VERSION_ACMF_MASK; 911 retry_counter = resp->resp_data[8]; 912 913 if ((retry_counter != ~0U) && (failure_source == 0U)) 914 resp->resp_data[5] |= RSU_VERSION_ACMF; 915 916 ret_args[ret_args_len++] = INTEL_SIP_SMC_STATUS_OK; 917 ret_args[ret_args_len++] = resp->err_code; 918 /* Current CMF */ 919 ret_args[ret_args_len++] = GET_ADDR64(resp->resp_data[1], resp->resp_data[0]); 920 /* Last Failing CMF Address */ 921 ret_args[ret_args_len++] = GET_ADDR64(resp->resp_data[3], resp->resp_data[2]); 922 /* Config State */ 923 ret_args[ret_args_len++] = resp->resp_data[4]; 924 /* Version */ 925 ret_args[ret_args_len++] = resp->resp_data[5]; 926 /* Failure Source */ 927 ret_args[ret_args_len++] = ((GENMASK(32, 17) & resp->resp_data[5]) >> 16); 928 /* Error location */ 929 ret_args[ret_args_len++] = resp->resp_data[6]; 930 /* Error details */ 931 ret_args[ret_args_len++] = resp->resp_data[7]; 932 /* Current image retry counter */ 933 ret_args[ret_args_len++] = resp->resp_data[8]; 934 935 return ret_args_len; 936 } 937 938 uint8_t sip_smc_cmd_cb_rsu_spt(void *resp_desc, void *cmd_desc, uint64_t *ret_args) 939 { 940 uint8_t ret_args_len = 0U; 941 sdm_response_t *resp = (sdm_response_t *)resp_desc; 942 sdm_command_t *cmd = (sdm_command_t *)cmd_desc; 943 944 (void)cmd; 945 946 ret_args[ret_args_len++] = INTEL_SIP_SMC_STATUS_OK; 947 ret_args[ret_args_len++] = resp->err_code; 948 /* Sub Partition Table (SPT) 0 address */ 949 ret_args[ret_args_len++] = GET_ADDR64(resp->resp_data[0], resp->resp_data[1]); 950 /* Sub Partition Table (SPT) 1 address */ 951 ret_args[ret_args_len++] = GET_ADDR64(resp->resp_data[2], resp->resp_data[3]); 952 953 return ret_args_len; 954 } 955 956 static uintptr_t smc_ret(void *handle, uint64_t *ret_args, uint32_t ret_args_len) 957 { 958 959 switch (ret_args_len) { 960 case SMC_RET_ARGS_ONE: 961 VERBOSE("SVC V3: %s: x0 0x%lx\n", __func__, ret_args[0]); 962 SMC_RET1(handle, ret_args[0]); 963 break; 964 965 case SMC_RET_ARGS_TWO: 966 VERBOSE("SVC V3: %s: x0 0x%lx, x1 0x%lx\n", __func__, ret_args[0], ret_args[1]); 967 SMC_RET2(handle, ret_args[0], ret_args[1]); 968 break; 969 970 case SMC_RET_ARGS_THREE: 971 VERBOSE("SVC V3: %s: x0 0x%lx, x1 0x%lx, x2 0x%lx\n", 972 __func__, ret_args[0], ret_args[1], ret_args[2]); 973 SMC_RET3(handle, ret_args[0], ret_args[1], ret_args[2]); 974 break; 975 976 case SMC_RET_ARGS_FOUR: 977 VERBOSE("SVC V3: %s: x0 0x%lx, x1 0x%lx, x2 0x%lx, x3 0x%lx\n", 978 __func__, ret_args[0], ret_args[1], ret_args[2], ret_args[3]); 979 SMC_RET4(handle, ret_args[0], ret_args[1], ret_args[2], ret_args[3]); 980 break; 981 982 case SMC_RET_ARGS_FIVE: 983 VERBOSE("SVC V3: %s: x0 0x%lx, x1 0x%lx, x2 0x%lx, x3 0x%lx, x4 0x%lx\n", 984 __func__, ret_args[0], ret_args[1], ret_args[2], ret_args[3], ret_args[4]); 985 SMC_RET5(handle, ret_args[0], ret_args[1], ret_args[2], ret_args[3], ret_args[4]); 986 break; 987 988 case SMC_RET_ARGS_SIX: 989 VERBOSE("SVC V3: %s: x0 0x%lx, x1 0x%lx x2 0x%lx x3 0x%lx, x4 0x%lx x5 0x%lx\n", 990 __func__, ret_args[0], ret_args[1], ret_args[2], ret_args[3], ret_args[4], 991 ret_args[5]); 992 SMC_RET6(handle, ret_args[0], ret_args[1], ret_args[2], ret_args[3], ret_args[4], 993 ret_args[5]); 994 break; 995 996 case SMC_RET_ARGS_SEVEN: 997 VERBOSE("SVC V3: %s: x0 0x%lx, x1 0x%lx x2 0x%lx, x3 0x%lx, x4 0x%lx, x5 0x%lx\t" 998 "x6 0x%lx\n", 999 __func__, ret_args[0], ret_args[1], ret_args[2], ret_args[3], ret_args[4], 1000 ret_args[5], ret_args[6]); 1001 SMC_RET7(handle, ret_args[0], ret_args[1], ret_args[2], ret_args[3], ret_args[4], 1002 ret_args[5], ret_args[6]); 1003 break; 1004 1005 case SMC_RET_ARGS_EIGHT: 1006 VERBOSE("SVC V3: %s: x0 0x%lx, x1 0x%lx x2 0x%lx, x3 0x%lx, x4 0x%lx x5 0x%lx\t" 1007 "x6 0x%lx, x7 0x%lx\n", 1008 __func__, ret_args[0], ret_args[1], ret_args[2], ret_args[3], ret_args[4], 1009 ret_args[5], ret_args[6], ret_args[7]); 1010 SMC_RET8(handle, ret_args[0], ret_args[1], ret_args[2], ret_args[3], ret_args[4], 1011 ret_args[5], ret_args[6], ret_args[7]); 1012 break; 1013 1014 case SMC_RET_ARGS_NINE: 1015 VERBOSE("SVC V3: %s: x0 0x%lx, x1 0x%lx x2 0x%lx, x3 0x%lx, x4 0x%lx, x5 0x%lx\t" 1016 "x6 0x%lx, x7 0x%lx, x8 0x%lx\n", 1017 __func__, ret_args[0], ret_args[1], ret_args[2], ret_args[3], ret_args[4], 1018 ret_args[5], ret_args[6], ret_args[7], ret_args[8]); 1019 SMC_RET18(handle, ret_args[0], ret_args[1], ret_args[2], ret_args[3], ret_args[4], 1020 ret_args[5], ret_args[6], ret_args[7], ret_args[8], 1021 0, 0, 0, 0, 0, 0, 0, 0, 0); 1022 break; 1023 1024 case SMC_RET_ARGS_TEN: 1025 VERBOSE("SVC V3: %s: x0 0x%lx, x1 0x%lx, x2 0x%lx, x3 0x%lx, x4 0x%lx x5 0x%lx\t" 1026 "x6 0x%lx, x7 0x%lx x8 0x%lx, x9 0x%lx, x10 0x%lx\n", 1027 __func__, ret_args[0], ret_args[1], ret_args[2], ret_args[3], 1028 ret_args[4], ret_args[5], ret_args[6], ret_args[7], ret_args[8], 1029 ret_args[9], ret_args[10]); 1030 SMC_RET18(handle, ret_args[0], ret_args[1], ret_args[2], ret_args[3], ret_args[4], 1031 ret_args[5], ret_args[6], ret_args[7], ret_args[8], ret_args[9], 1032 0, 0, 0, 0, 0, 0, 0, 0); 1033 break; 1034 1035 default: 1036 VERBOSE("SVC V3: %s ret_args_len is wrong, please check %d\n ", 1037 __func__, ret_args_len); 1038 SMC_RET1(handle, INTEL_SIP_SMC_STATUS_ERROR); 1039 break; 1040 } 1041 } 1042 1043 static inline bool is_gen_mbox_cmd_allowed(uint32_t cmd) 1044 { 1045 /* Check if the command is allowed to be executed in generic mbox format */ 1046 bool is_cmd_allowed = false; 1047 1048 switch (cmd) { 1049 case MBOX_FCS_OPEN_CS_SESSION: 1050 case MBOX_FCS_CLOSE_CS_SESSION: 1051 case MBOX_FCS_IMPORT_CS_KEY: 1052 case MBOX_FCS_EXPORT_CS_KEY: 1053 case MBOX_FCS_REMOVE_CS_KEY: 1054 case MBOX_FCS_GET_CS_KEY_INFO: 1055 case MBOX_FCS_CREATE_CS_KEY: 1056 case MBOX_FCS_GET_DIGEST_REQ: 1057 case MBOX_FCS_MAC_VERIFY_REQ: 1058 case MBOX_FCS_ECDSA_HASH_SIGN_REQ: 1059 case MBOX_FCS_GET_PROVISION: 1060 case MBOX_FCS_CNTR_SET_PREAUTH: 1061 case MBOX_FCS_ENCRYPT_REQ: 1062 case MBOX_FCS_DECRYPT_REQ: 1063 case MBOX_FCS_RANDOM_GEN: 1064 case MBOX_FCS_AES_CRYPT_REQ: 1065 case MBOX_FCS_ECDSA_SHA2_DATA_SIGN_REQ: 1066 case MBOX_FCS_ECDSA_HASH_SIG_VERIFY: 1067 case MBOX_FCS_ECDSA_SHA2_DATA_SIGN_VERIFY: 1068 case MBOX_FCS_ECDSA_GET_PUBKEY: 1069 case MBOX_FCS_ECDH_REQUEST: 1070 case MBOX_FCS_HKDF_REQUEST: 1071 /* These mailbox commands are not supported in the generic mailbox format. */ 1072 break; 1073 1074 default: 1075 is_cmd_allowed = true; 1076 break; 1077 } /* switch */ 1078 1079 return is_cmd_allowed; 1080 } 1081 1082 /* 1083 * This function is responsible for handling all SiP SVC V3 calls from the 1084 * non-secure world. 1085 */ 1086 static uintptr_t sip_smc_handler_v3(uint32_t smc_fid, 1087 u_register_t x1, 1088 u_register_t x2, 1089 u_register_t x3, 1090 u_register_t x4, 1091 void *cookie, 1092 void *handle, 1093 u_register_t flags) 1094 { 1095 int status = 0; 1096 uint32_t mbox_error = 0U; 1097 u_register_t x5, x6, x7, x8, x9, x10, x11; 1098 1099 /* Get all the SMC call arguments */ 1100 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 1101 x6 = SMC_GET_GP(handle, CTX_GPREG_X6); 1102 x7 = SMC_GET_GP(handle, CTX_GPREG_X7); 1103 x8 = SMC_GET_GP(handle, CTX_GPREG_X8); 1104 x9 = SMC_GET_GP(handle, CTX_GPREG_X9); 1105 x10 = SMC_GET_GP(handle, CTX_GPREG_X10); 1106 x11 = SMC_GET_GP(handle, CTX_GPREG_X11); 1107 1108 INFO("MBOX: SVC_V3: x0 0x%x, x1 0x%lx, x2 0x%lx, x3 0x%lx, x4 0x%lx, x5 0x%lx\n", 1109 smc_fid, x1, x2, x3, x4, x5); 1110 INFO("MBOX: SVC_V3: x6 0x%lx, x7 0x%lx, x8 0x%lx, x9 0x%lx, x10 0x%lx x11 0x%lx\n", 1111 x6, x7, x8, x9, x10, x11); 1112 1113 switch (smc_fid) { 1114 case ALTERA_SIP_SMC_ASYNC_RESP_POLL: 1115 { 1116 uint64_t ret_args[16] = {0}; 1117 uint32_t ret_args_len = 0; 1118 1119 status = mailbox_response_poll_v3(GET_CLIENT_ID(x1), 1120 GET_JOB_ID(x1), 1121 ret_args, 1122 &ret_args_len); 1123 /* Always reserve [0] index for command status. */ 1124 ret_args[0] = status; 1125 1126 /* Return SMC call based on the number of return arguments */ 1127 return smc_ret(handle, ret_args, ret_args_len); 1128 } 1129 1130 case ALTERA_SIP_SMC_ASYNC_RESP_POLL_ON_INTR: 1131 { 1132 /* TBD: Here now we don't need these CID and JID?? */ 1133 uint8_t client_id = 0U; 1134 uint8_t job_id = 0U; 1135 uint64_t trans_id_bitmap[4] = {0U}; 1136 1137 status = mailbox_response_poll_on_intr_v3(&client_id, 1138 &job_id, 1139 trans_id_bitmap); 1140 1141 SMC_RET5(handle, status, trans_id_bitmap[0], trans_id_bitmap[1], 1142 trans_id_bitmap[2], trans_id_bitmap[3]); 1143 break; 1144 } 1145 1146 case ALTERA_SIP_SMC_ASYNC_GET_DEVICE_IDENTITY: 1147 { 1148 status = mailbox_send_cmd_async_v3(GET_CLIENT_ID(x1), 1149 GET_JOB_ID(x1), 1150 MBOX_CMD_GET_DEVICEID, 1151 NULL, 1152 0U, 1153 MBOX_CMD_FLAG_CASUAL, 1154 sip_smc_ret_nbytes_cb, 1155 (uint32_t *)x2, 1156 2); 1157 1158 SMC_RET1(handle, status); 1159 } 1160 1161 case ALTERA_SIP_SMC_ASYNC_GET_IDCODE: 1162 { 1163 status = mailbox_send_cmd_async_v3(GET_CLIENT_ID(x1), 1164 GET_JOB_ID(x1), 1165 MBOX_CMD_GET_IDCODE, 1166 NULL, 1167 0U, 1168 MBOX_CMD_FLAG_CASUAL, 1169 sip_smc_cmd_cb_ret3, 1170 NULL, 1171 0); 1172 1173 SMC_RET1(handle, status); 1174 } 1175 1176 case ALTERA_SIP_SMC_ASYNC_QSPI_OPEN: 1177 { 1178 status = mailbox_send_cmd_async_v3(GET_CLIENT_ID(x1), 1179 GET_JOB_ID(x1), 1180 MBOX_CMD_QSPI_OPEN, 1181 NULL, 1182 0U, 1183 MBOX_CMD_FLAG_CASUAL, 1184 sip_smc_cmd_cb_ret2, 1185 NULL, 1186 0U); 1187 1188 SMC_RET1(handle, status); 1189 } 1190 1191 case ALTERA_SIP_SMC_ASYNC_QSPI_CLOSE: 1192 { 1193 status = mailbox_send_cmd_async_v3(GET_CLIENT_ID(x1), 1194 GET_JOB_ID(x1), 1195 MBOX_CMD_QSPI_CLOSE, 1196 NULL, 1197 0U, 1198 MBOX_CMD_FLAG_CASUAL, 1199 sip_smc_cmd_cb_ret2, 1200 NULL, 1201 0U); 1202 1203 SMC_RET1(handle, status); 1204 } 1205 1206 case ALTERA_SIP_SMC_ASYNC_QSPI_SET_CS: 1207 { 1208 uint32_t cmd_data = 0U; 1209 uint32_t chip_sel = (uint32_t)x2; 1210 uint32_t comb_addr_mode = (uint32_t)x3; 1211 uint32_t ext_dec_mode = (uint32_t)x4; 1212 1213 cmd_data = (chip_sel << MBOX_QSPI_SET_CS_OFFSET) | 1214 (comb_addr_mode << MBOX_QSPI_SET_CS_CA_OFFSET) | 1215 (ext_dec_mode << MBOX_QSPI_SET_CS_MODE_OFFSET); 1216 1217 status = mailbox_send_cmd_async_v3(GET_CLIENT_ID(x1), 1218 GET_JOB_ID(x1), 1219 MBOX_CMD_QSPI_SET_CS, 1220 &cmd_data, 1221 1U, 1222 MBOX_CMD_FLAG_CASUAL, 1223 sip_smc_cmd_cb_ret2, 1224 NULL, 1225 0U); 1226 1227 SMC_RET1(handle, status); 1228 } 1229 1230 case ALTERA_SIP_SMC_ASYNC_QSPI_ERASE: 1231 { 1232 uint32_t qspi_addr = (uint32_t)x2; 1233 uint32_t qspi_nwords = (uint32_t)x3; 1234 1235 /* QSPI address offset to start erase, must be 4K aligned */ 1236 if (MBOX_IS_4K_ALIGNED(qspi_addr)) { 1237 ERROR("MBOX: 0x%x: QSPI address not 4K aligned\n", 1238 smc_fid); 1239 status = INTEL_SIP_SMC_STATUS_REJECTED; 1240 SMC_RET1(handle, status); 1241 } 1242 1243 /* Number of words to erase, multiples of 0x400 or 4K */ 1244 if (qspi_nwords % MBOX_QSPI_ERASE_SIZE_GRAN) { 1245 ERROR("MBOX: 0x%x: Given words not in multiples of 4K\n", 1246 smc_fid); 1247 status = INTEL_SIP_SMC_STATUS_REJECTED; 1248 SMC_RET1(handle, status); 1249 } 1250 1251 uint32_t cmd_data[2] = {qspi_addr, qspi_nwords}; 1252 1253 status = mailbox_send_cmd_async_v3(GET_CLIENT_ID(x1), 1254 GET_JOB_ID(x1), 1255 MBOX_CMD_QSPI_ERASE, 1256 cmd_data, 1257 sizeof(cmd_data) / MBOX_WORD_BYTE, 1258 MBOX_CMD_FLAG_CASUAL, 1259 sip_smc_cmd_cb_ret2, 1260 NULL, 1261 0U); 1262 1263 SMC_RET1(handle, status); 1264 } 1265 1266 case ALTERA_SIP_SMC_ASYNC_QSPI_WRITE: 1267 { 1268 uint32_t *qspi_payload = (uint32_t *)x2; 1269 uint32_t qspi_total_nwords = (((uint32_t)x3) / MBOX_WORD_BYTE); 1270 uint32_t qspi_addr = qspi_payload[0]; 1271 uint32_t qspi_nwords = qspi_payload[1]; 1272 1273 if (!MBOX_IS_WORD_ALIGNED(qspi_addr)) { 1274 ERROR("MBOX: 0x%x: Given address is not WORD aligned\n", 1275 smc_fid); 1276 status = INTEL_SIP_SMC_STATUS_REJECTED; 1277 SMC_RET1(handle, status); 1278 } 1279 1280 if (qspi_nwords > MBOX_QSPI_RW_MAX_WORDS) { 1281 ERROR("MBOX: 0x%x: Number of words exceeds max limit\n", 1282 smc_fid); 1283 status = INTEL_SIP_SMC_STATUS_REJECTED; 1284 SMC_RET1(handle, status); 1285 } 1286 1287 status = mailbox_send_cmd_async_v3(GET_CLIENT_ID(x1), 1288 GET_JOB_ID(x1), 1289 MBOX_CMD_QSPI_WRITE, 1290 qspi_payload, 1291 qspi_total_nwords, 1292 MBOX_CMD_FLAG_CASUAL, 1293 sip_smc_cmd_cb_ret2, 1294 NULL, 1295 0U); 1296 1297 SMC_RET1(handle, status); 1298 } 1299 1300 case ALTERA_SIP_SMC_ASYNC_QSPI_READ: 1301 { 1302 uint32_t qspi_addr = (uint32_t)x2; 1303 uint32_t qspi_nwords = (((uint32_t)x4) / MBOX_WORD_BYTE); 1304 1305 if (qspi_nwords > MBOX_QSPI_RW_MAX_WORDS) { 1306 ERROR("MBOX: 0x%x: Number of words exceeds max limit\n", 1307 smc_fid); 1308 status = INTEL_SIP_SMC_STATUS_REJECTED; 1309 SMC_RET1(handle, status); 1310 } 1311 1312 uint32_t cmd_data[2] = {qspi_addr, qspi_nwords}; 1313 1314 status = mailbox_send_cmd_async_v3(GET_CLIENT_ID(x1), 1315 GET_JOB_ID(x1), 1316 MBOX_CMD_QSPI_READ, 1317 cmd_data, 1318 sizeof(cmd_data) / MBOX_WORD_BYTE, 1319 MBOX_CMD_FLAG_CASUAL, 1320 sip_smc_ret_nbytes_cb, 1321 (uint32_t *)x3, 1322 2); 1323 1324 SMC_RET1(handle, status); 1325 } 1326 1327 case ALTERA_SIP_SMC_ASYNC_QSPI_GET_DEV_INFO: 1328 { 1329 uint32_t *dst_addr = (uint32_t *)x2; 1330 1331 status = mailbox_send_cmd_async_v3(GET_CLIENT_ID(x1), 1332 GET_JOB_ID(x1), 1333 MBOX_CMD_QSPI_GET_DEV_INFO, 1334 NULL, 1335 0U, 1336 MBOX_CMD_FLAG_CASUAL, 1337 sip_smc_ret_nbytes_cb, 1338 (uint32_t *)dst_addr, 1339 2); 1340 1341 SMC_RET1(handle, status); 1342 } 1343 1344 case ALTERA_SIP_SMC_ASYNC_HWMON_READVOLT: 1345 case ALTERA_SIP_SMC_ASYNC_HWMON_READTEMP: 1346 { 1347 uint32_t channel = (uint32_t)x2; 1348 uint32_t mbox_cmd = ((smc_fid == ALTERA_SIP_SMC_ASYNC_HWMON_READVOLT) ? 1349 MBOX_HWMON_READVOLT : MBOX_HWMON_READTEMP); 1350 1351 status = mailbox_send_cmd_async_v3(GET_CLIENT_ID(x1), 1352 GET_JOB_ID(x1), 1353 mbox_cmd, 1354 &channel, 1355 1U, 1356 MBOX_CMD_FLAG_CASUAL, 1357 sip_smc_cmd_cb_ret3, 1358 NULL, 1359 0); 1360 1361 SMC_RET1(handle, status); 1362 } 1363 1364 case ALTERA_SIP_SMC_ASYNC_RSU_GET_SPT: 1365 { 1366 status = mailbox_send_cmd_async_v3(GET_CLIENT_ID(x1), 1367 GET_JOB_ID(x1), 1368 MBOX_GET_SUBPARTITION_TABLE, 1369 NULL, 1370 0, 1371 MBOX_CMD_FLAG_CASUAL, 1372 sip_smc_cmd_cb_rsu_spt, 1373 NULL, 1374 0); 1375 1376 SMC_RET1(handle, status); 1377 } 1378 1379 case ALTERA_SIP_SMC_ASYNC_RSU_GET_STATUS: 1380 { 1381 status = mailbox_send_cmd_async_v3(GET_CLIENT_ID(x1), 1382 GET_JOB_ID(x1), 1383 MBOX_RSU_STATUS, 1384 NULL, 1385 0, 1386 MBOX_CMD_FLAG_CASUAL, 1387 sip_smc_cmd_cb_rsu_status, 1388 NULL, 1389 0); 1390 1391 SMC_RET1(handle, status); 1392 } 1393 1394 case ALTERA_SIP_SMC_ASYNC_RSU_NOTIFY: 1395 { 1396 uint32_t notify_code = (uint32_t)x2; 1397 1398 status = mailbox_send_cmd_async_v3(GET_CLIENT_ID(x1), 1399 GET_JOB_ID(x1), 1400 MBOX_HPS_STAGE_NOTIFY, 1401 ¬ify_code, 1402 1U, 1403 MBOX_CMD_FLAG_CASUAL, 1404 sip_smc_cmd_cb_ret2, 1405 NULL, 1406 0); 1407 1408 SMC_RET1(handle, status); 1409 } 1410 1411 case ALTERA_SIP_SMC_ASYNC_GEN_MBOX_CMD: 1412 { 1413 /* Collect all the args passed in, and send the mailbox command. */ 1414 uint32_t mbox_cmd = (uint32_t)x2; 1415 uint32_t *cmd_payload_addr = NULL; 1416 uint32_t cmd_payload_len = (uint32_t)x4 / MBOX_WORD_BYTE; 1417 uint32_t *resp_payload_addr = NULL; 1418 uint32_t resp_payload_len = (uint32_t)x6 / MBOX_WORD_BYTE; 1419 1420 /* Filter the required commands here. */ 1421 if (!is_gen_mbox_cmd_allowed(mbox_cmd)) { 1422 status = INTEL_SIP_SMC_STATUS_REJECTED; 1423 SMC_RET1(handle, status); 1424 } 1425 1426 if ((cmd_payload_len > MBOX_GEN_CMD_MAX_WORDS) || 1427 (resp_payload_len > MBOX_GEN_CMD_MAX_WORDS)) { 1428 ERROR("MBOX: 0x%x: Command/Response payload length exceeds max limit\n", 1429 smc_fid); 1430 status = INTEL_SIP_SMC_STATUS_REJECTED; 1431 SMC_RET1(handle, status); 1432 } 1433 1434 /* Make sure we have valid command payload length and buffer */ 1435 if (cmd_payload_len != 0U) { 1436 cmd_payload_addr = (uint32_t *)x3; 1437 if (cmd_payload_addr == NULL) { 1438 ERROR("MBOX: 0x%x: Command payload address is NULL\n", 1439 smc_fid); 1440 status = INTEL_SIP_SMC_STATUS_REJECTED; 1441 SMC_RET1(handle, status); 1442 } 1443 } 1444 1445 /* Make sure we have valid response payload length and buffer */ 1446 if (resp_payload_len != 0U) { 1447 resp_payload_addr = (uint32_t *)x5; 1448 if (resp_payload_addr == NULL) { 1449 ERROR("MBOX: 0x%x: Response payload address is NULL\n", 1450 smc_fid); 1451 status = INTEL_SIP_SMC_STATUS_REJECTED; 1452 SMC_RET1(handle, status); 1453 } 1454 } 1455 1456 status = mailbox_send_cmd_async_v3(GET_CLIENT_ID(x1), 1457 GET_JOB_ID(x1), 1458 mbox_cmd, 1459 (uint32_t *)cmd_payload_addr, 1460 cmd_payload_len, 1461 MBOX_CMD_FLAG_CASUAL, 1462 sip_smc_ret_nbytes_cb, 1463 (uint32_t *)resp_payload_addr, 1464 resp_payload_len); 1465 1466 SMC_RET1(handle, status); 1467 } 1468 1469 case ALTERA_SIP_SMC_ASYNC_FCS_RANDOM_NUMBER_EXT: 1470 { 1471 uint32_t session_id = (uint32_t)x2; 1472 uint32_t context_id = (uint32_t)x3; 1473 uint64_t ret_random_addr = (uint64_t)x4; 1474 uint32_t random_len = (uint32_t)SMC_GET_GP(handle, CTX_GPREG_X5); 1475 uint32_t crypto_header = 0U; 1476 1477 if ((random_len > (FCS_RANDOM_EXT_MAX_WORD_SIZE * MBOX_WORD_BYTE)) || 1478 (random_len == 0U) || 1479 (!is_size_4_bytes_aligned(random_len))) { 1480 ERROR("MBOX: 0x%x is rejected\n", smc_fid); 1481 status = INTEL_SIP_SMC_STATUS_REJECTED; 1482 SMC_RET1(handle, status); 1483 } 1484 1485 crypto_header = ((FCS_CS_FIELD_FLAG_INIT | FCS_CS_FIELD_FLAG_FINALIZE) << 1486 FCS_CS_FIELD_FLAG_OFFSET); 1487 fcs_rng_payload payload = {session_id, context_id, 1488 crypto_header, random_len}; 1489 1490 status = mailbox_send_cmd_async_v3(GET_CLIENT_ID(x1), 1491 GET_JOB_ID(x1), 1492 MBOX_FCS_RANDOM_GEN, 1493 (uint32_t *)&payload, 1494 sizeof(payload) / MBOX_WORD_BYTE, 1495 MBOX_CMD_FLAG_CASUAL, 1496 sip_smc_ret_nbytes_cb, 1497 (uint32_t *)ret_random_addr, 1498 2); 1499 SMC_RET1(handle, status); 1500 } 1501 1502 case ALTERA_SIP_SMC_ASYNC_FCS_GET_PROVISION_DATA: 1503 { 1504 status = mailbox_send_cmd_async_v3(GET_CLIENT_ID(x1), 1505 GET_JOB_ID(x1), 1506 MBOX_FCS_GET_PROVISION, 1507 NULL, 1508 0U, 1509 MBOX_CMD_FLAG_CASUAL, 1510 sip_smc_ret_nbytes_cb, 1511 (uint32_t *)x2, 1512 2); 1513 SMC_RET1(handle, status); 1514 } 1515 1516 case ALTERA_SIP_SMC_ASYNC_FCS_CNTR_SET_PREAUTH: 1517 { 1518 status = intel_fcs_cntr_set_preauth(smc_fid, x1, x2, x3, 1519 x4, &mbox_error); 1520 SMC_RET1(handle, status); 1521 } 1522 1523 case ALTERA_SIP_SMC_ASYNC_FCS_CHIP_ID: 1524 { 1525 status = mailbox_send_cmd_async_v3(GET_CLIENT_ID(x1), 1526 GET_JOB_ID(x1), 1527 MBOX_CMD_GET_CHIPID, 1528 NULL, 1529 0U, 1530 MBOX_CMD_FLAG_CASUAL, 1531 sip_smc_get_chipid_cb, 1532 NULL, 1533 0); 1534 SMC_RET1(handle, status); 1535 } 1536 1537 case ALTERA_SIP_SMC_ASYNC_FCS_GET_ATTESTATION_CERT: 1538 { 1539 status = intel_fcs_get_attestation_cert(smc_fid, x1, x2, x3, 1540 (uint32_t *) &x4, &mbox_error); 1541 SMC_RET1(handle, status); 1542 } 1543 1544 case ALTERA_SIP_SMC_ASYNC_FCS_CREATE_CERT_ON_RELOAD: 1545 { 1546 status = intel_fcs_create_cert_on_reload(smc_fid, x1, 1547 x2, &mbox_error); 1548 SMC_RET1(handle, status); 1549 } 1550 1551 case ALTERA_SIP_SMC_ASYNC_FCS_CRYPTION_EXT: 1552 { 1553 if (x4 == FCS_MODE_ENCRYPT) { 1554 status = intel_fcs_encryption_ext(smc_fid, x1, x2, x3, 1555 x5, x6, x7, (uint32_t *) &x8, 1556 &mbox_error, x10, x11); 1557 } else if (x4 == FCS_MODE_DECRYPT) { 1558 status = intel_fcs_decryption_ext(smc_fid, x1, x2, x3, 1559 x5, x6, x7, (uint32_t *) &x8, 1560 &mbox_error, x9, x10, x11); 1561 } else { 1562 ERROR("MBOX: 0x%x: Wrong crypto mode\n", smc_fid); 1563 status = INTEL_SIP_SMC_STATUS_REJECTED; 1564 } 1565 SMC_RET1(handle, status); 1566 } 1567 1568 case ALTERA_SIP_SMC_ASYNC_FCS_SEND_CERTIFICATE: 1569 { 1570 status = intel_fcs_send_cert(smc_fid, x1, x2, x3, &mbox_error); 1571 SMC_RET1(handle, status); 1572 } 1573 1574 case ALTERA_SIP_SMC_ASYNC_FCS_OPEN_CS_SESSION: 1575 { 1576 status = mailbox_send_cmd_async_v3(GET_CLIENT_ID(x1), 1577 GET_JOB_ID(x1), 1578 MBOX_FCS_OPEN_CS_SESSION, 1579 NULL, 1580 0U, 1581 MBOX_CMD_FLAG_CASUAL, 1582 sip_smc_cmd_cb_ret3, 1583 NULL, 1584 0); 1585 SMC_RET1(handle, status); 1586 } 1587 1588 case ALTERA_SIP_SMC_ASYNC_FCS_CLOSE_CS_SESSION: 1589 { 1590 uint32_t session_id = (uint32_t)x2; 1591 1592 status = mailbox_send_cmd_async_v3(GET_CLIENT_ID(x1), 1593 GET_JOB_ID(x1), 1594 MBOX_FCS_CLOSE_CS_SESSION, 1595 &session_id, 1596 1U, 1597 MBOX_CMD_FLAG_CASUAL, 1598 sip_smc_cmd_cb_ret2, 1599 NULL, 1600 0); 1601 SMC_RET1(handle, status); 1602 } 1603 1604 case ALTERA_SIP_SMC_ASYNC_FCS_IMPORT_CS_KEY: 1605 { 1606 uint64_t key_addr = x2; 1607 uint32_t key_len_words = (uint32_t)x3 / MBOX_WORD_BYTE; 1608 1609 if ((key_len_words > FCS_CS_KEY_OBJ_MAX_WORD_SIZE) || 1610 (!is_address_in_ddr_range(key_addr, key_len_words * 4))) { 1611 ERROR("MBOX: 0x%x: Addr not in DDR range or key len exceeds\n", 1612 smc_fid); 1613 status = INTEL_SIP_SMC_STATUS_REJECTED; 1614 SMC_RET1(handle, status); 1615 } 1616 1617 status = mailbox_send_cmd_async_v3(GET_CLIENT_ID(x1), 1618 GET_JOB_ID(x1), 1619 MBOX_FCS_IMPORT_CS_KEY, 1620 (uint32_t *)key_addr, 1621 key_len_words, 1622 MBOX_CMD_FLAG_CASUAL, 1623 sip_smc_cmd_cb_ret3, 1624 NULL, 1625 0); 1626 SMC_RET1(handle, status); 1627 } 1628 1629 case ALTERA_SIP_SMC_ASYNC_FCS_CREATE_CS_KEY: 1630 { 1631 uint64_t key_addr = x2; 1632 uint32_t key_len_words = (uint32_t)x3 / MBOX_WORD_BYTE; 1633 1634 if (!is_address_in_ddr_range(key_addr, key_len_words * 4)) { 1635 ERROR("MBOX: 0x%x: Addr not in DDR range\n", smc_fid); 1636 status = INTEL_SIP_SMC_STATUS_REJECTED; 1637 SMC_RET1(handle, status); 1638 } 1639 1640 status = mailbox_send_cmd_async_v3(GET_CLIENT_ID(x1), 1641 GET_JOB_ID(x1), 1642 MBOX_FCS_CREATE_CS_KEY, 1643 (uint32_t *)key_addr, 1644 key_len_words, 1645 MBOX_CMD_FLAG_CASUAL, 1646 sip_smc_cmd_cb_ret3, 1647 NULL, 1648 0); 1649 SMC_RET1(handle, status); 1650 } 1651 1652 case ALTERA_SIP_SMC_ASYNC_FCS_EXPORT_CS_KEY: 1653 { 1654 uint32_t session_id = (uint32_t)x2; 1655 uint32_t key_uid = (uint32_t)x3; 1656 uint64_t ret_key_addr = (uint64_t)x4; 1657 uint32_t key_len = (uint32_t)SMC_GET_GP(handle, CTX_GPREG_X5); 1658 1659 if (!is_address_in_ddr_range(ret_key_addr, key_len)) { 1660 ERROR("MBOX: 0x%x: Addr not in DDR range\n", smc_fid); 1661 status = INTEL_SIP_SMC_STATUS_REJECTED; 1662 SMC_RET1(handle, status); 1663 } 1664 1665 fcs_cs_key_payload payload = {session_id, RESERVED_AS_ZERO, 1666 RESERVED_AS_ZERO, key_uid}; 1667 1668 status = mailbox_send_cmd_async_v3(GET_CLIENT_ID(x1), 1669 GET_JOB_ID(x1), 1670 MBOX_FCS_EXPORT_CS_KEY, 1671 (uint32_t *)&payload, 1672 sizeof(payload) / MBOX_WORD_BYTE, 1673 MBOX_CMD_FLAG_CASUAL, 1674 sip_smc_ret_nbytes_cb, 1675 (uint32_t *)ret_key_addr, 1676 2); 1677 SMC_RET1(handle, status); 1678 } 1679 1680 case ALTERA_SIP_SMC_ASYNC_FCS_REMOVE_CS_KEY: 1681 { 1682 uint32_t session_id = (uint32_t)x2; 1683 uint32_t key_uid = (uint32_t)x3; 1684 1685 fcs_cs_key_payload payload = {session_id, RESERVED_AS_ZERO, 1686 RESERVED_AS_ZERO, key_uid}; 1687 1688 status = mailbox_send_cmd_async_v3(GET_CLIENT_ID(x1), 1689 GET_JOB_ID(x1), 1690 MBOX_FCS_REMOVE_CS_KEY, 1691 (uint32_t *)&payload, 1692 sizeof(payload) / MBOX_WORD_BYTE, 1693 MBOX_CMD_FLAG_CASUAL, 1694 sip_smc_cmd_cb_ret3, 1695 NULL, 1696 0); 1697 SMC_RET1(handle, status); 1698 } 1699 1700 case ALTERA_SIP_SMC_ASYNC_FCS_GET_CS_KEY_INFO: 1701 { 1702 uint32_t session_id = (uint32_t)x2; 1703 uint32_t key_uid = (uint32_t)x3; 1704 uint64_t ret_key_addr = (uint64_t)x4; 1705 uint32_t key_len = (uint32_t)SMC_GET_GP(handle, CTX_GPREG_X5); 1706 1707 if (!is_address_in_ddr_range(ret_key_addr, key_len)) { 1708 ERROR("MBOX: 0x%x: Addr not in DDR range\n", smc_fid); 1709 status = INTEL_SIP_SMC_STATUS_REJECTED; 1710 SMC_RET1(handle, status); 1711 } 1712 1713 fcs_cs_key_payload payload = {session_id, RESERVED_AS_ZERO, 1714 RESERVED_AS_ZERO, key_uid}; 1715 1716 status = mailbox_send_cmd_async_v3(GET_CLIENT_ID(x1), 1717 GET_JOB_ID(x1), 1718 MBOX_FCS_GET_CS_KEY_INFO, 1719 (uint32_t *)&payload, 1720 sizeof(payload) / MBOX_WORD_BYTE, 1721 MBOX_CMD_FLAG_CASUAL, 1722 sip_smc_ret_nbytes_cb, 1723 (uint32_t *)ret_key_addr, 1724 2); 1725 SMC_RET1(handle, status); 1726 } 1727 1728 case ALTERA_SIP_SMC_ASYNC_FCS_AES_CRYPT_INIT: 1729 { 1730 status = intel_fcs_aes_crypt_init(x2, x3, x4, x5, 1731 x6, &mbox_error); 1732 SMC_RET1(handle, status); 1733 } 1734 1735 case ALTERA_SIP_SMC_ASYNC_FCS_AES_CRYPT_UPDATE: 1736 case ALTERA_SIP_SMC_ASYNC_FCS_AES_CRYPT_FINALIZE: 1737 { 1738 uint32_t job_id = 0U; 1739 bool is_final = (smc_fid == ALTERA_SIP_SMC_ASYNC_FCS_AES_CRYPT_FINALIZE) ? 1740 true : false; 1741 1742 status = intel_fcs_aes_crypt_update_finalize(smc_fid, x1, x2, 1743 x3, x4, x5, x6, x7, x8, is_final, 1744 &job_id, x9, x10); 1745 SMC_RET1(handle, status); 1746 } 1747 1748 case ALTERA_SIP_SMC_ASYNC_FCS_GET_DIGEST_INIT: 1749 { 1750 status = intel_fcs_get_digest_init(x2, x3, x4, x5, x6, 1751 &mbox_error); 1752 SMC_RET1(handle, status); 1753 } 1754 1755 case ALTERA_SIP_SMC_ASYNC_FCS_GET_DIGEST_UPDATE: 1756 case ALTERA_SIP_SMC_ASYNC_FCS_GET_DIGEST_FINALIZE: 1757 { 1758 bool is_final = (smc_fid == ALTERA_SIP_SMC_ASYNC_FCS_GET_DIGEST_FINALIZE) ? 1759 true : false; 1760 1761 status = intel_fcs_get_digest_update_finalize(smc_fid, x1, x2, 1762 x3, x4, x5, x6, (uint32_t *) &x7, 1763 is_final, &mbox_error, x8); 1764 1765 SMC_RET1(handle, status); 1766 } 1767 1768 case ALTERA_SIP_SMC_ASYNC_FCS_MAC_VERIFY_INIT: 1769 { 1770 status = intel_fcs_mac_verify_init(x2, x3, x4, x5, x6, 1771 &mbox_error); 1772 SMC_RET1(handle, status); 1773 } 1774 1775 case ALTERA_SIP_SMC_ASYNC_FCS_MAC_VERIFY_UPDATE: 1776 case ALTERA_SIP_SMC_ASYNC_FCS_MAC_VERIFY_FINALIZE: 1777 { 1778 bool is_final = (smc_fid == ALTERA_SIP_SMC_ASYNC_FCS_MAC_VERIFY_FINALIZE) ? 1779 true : false; 1780 1781 status = intel_fcs_mac_verify_update_finalize(smc_fid, x1, x2, 1782 x3, x4, x5, x6, (uint32_t *) &x7, x8, 1783 is_final, &mbox_error, x9); 1784 SMC_RET1(handle, status); 1785 } 1786 1787 case ALTERA_SIP_SMC_ASYNC_FCS_ECDSA_HASH_SIGN_INIT: 1788 { 1789 status = intel_fcs_ecdsa_hash_sign_init(x2, x3, x4, x5, x6, 1790 &mbox_error); 1791 SMC_RET1(handle, status); 1792 } 1793 1794 case ALTERA_SIP_SMC_ASYNC_FCS_ECDSA_HASH_SIGN_FINALIZE: 1795 { 1796 status = intel_fcs_ecdsa_hash_sign_finalize(smc_fid, x1, x2, x3, 1797 x4, x5, x6, (uint32_t *) &x7, 1798 &mbox_error); 1799 SMC_RET1(handle, status); 1800 } 1801 1802 case ALTERA_SIP_SMC_ASYNC_FCS_ECDSA_SHA2_DATA_SIGN_INIT: 1803 { 1804 status = intel_fcs_ecdsa_sha2_data_sign_init(x2, x3, x4, x5, x6, 1805 &mbox_error); 1806 SMC_RET1(handle, status); 1807 } 1808 1809 case ALTERA_SIP_SMC_ASYNC_FCS_ECDSA_SHA2_DATA_SIGN_UPDATE: 1810 case ALTERA_SIP_SMC_ASYNC_FCS_ECDSA_SHA2_DATA_SIGN_FINALIZE: 1811 { 1812 bool is_final = (smc_fid == ALTERA_SIP_SMC_ASYNC_FCS_ECDSA_SHA2_DATA_SIGN_FINALIZE) 1813 ? true : false; 1814 1815 status = intel_fcs_ecdsa_sha2_data_sign_update_finalize(smc_fid, 1816 x1, x2, x3, x4, x5, x6, (uint32_t *) &x7, 1817 is_final, &mbox_error, x8); 1818 SMC_RET1(handle, status); 1819 } 1820 1821 case ALTERA_SIP_SMC_ASYNC_FCS_ECDSA_HASH_SIG_VERIFY_INIT: 1822 { 1823 status = intel_fcs_ecdsa_hash_sig_verify_init(x2, x3, x4, x5, 1824 x6, &mbox_error); 1825 SMC_RET1(handle, status); 1826 } 1827 1828 case ALTERA_SIP_SMC_ASYNC_FCS_ECDSA_HASH_SIG_VERIFY_FINALIZE: 1829 { 1830 status = intel_fcs_ecdsa_hash_sig_verify_finalize(smc_fid, x1, 1831 x2, x3, x4, x5, x6, (uint32_t *) &x7, 1832 &mbox_error); 1833 SMC_RET1(handle, status); 1834 } 1835 1836 case ALTERA_SIP_SMC_ASYNC_FCS_ECDSA_SHA2_DATA_SIG_VERIFY_INIT: 1837 { 1838 status = intel_fcs_ecdsa_sha2_data_sig_verify_init(x2, x3, x4, 1839 x5, x6, &mbox_error); 1840 SMC_RET1(handle, status); 1841 } 1842 1843 case ALTERA_SIP_SMC_ASYNC_FCS_ECDSA_SHA2_DATA_SIG_VERIFY_UPDATE: 1844 case ALTERA_SIP_SMC_ASYNC_FCS_ECDSA_SHA2_DATA_SIG_VERIFY_FINALIZE: 1845 { 1846 bool is_final = (smc_fid == 1847 ALTERA_SIP_SMC_ASYNC_FCS_ECDSA_SHA2_DATA_SIG_VERIFY_FINALIZE) ? 1848 true : false; 1849 1850 status = intel_fcs_ecdsa_sha2_data_sig_verify_update_finalize( 1851 smc_fid, x1, x2, x3, x4, x5, x6, 1852 (uint32_t *) &x7, x8, is_final, 1853 &mbox_error, x9); 1854 SMC_RET1(handle, status); 1855 } 1856 1857 case ALTERA_SIP_SMC_ASYNC_FCS_ECDSA_GET_PUBKEY_INIT: 1858 { 1859 status = intel_fcs_ecdsa_get_pubkey_init(x2, x3, x4, x5, x6, 1860 &mbox_error); 1861 SMC_RET1(handle, status); 1862 } 1863 1864 case ALTERA_SIP_SMC_ASYNC_FCS_ECDSA_GET_PUBKEY_FINALIZE: 1865 { 1866 status = intel_fcs_ecdsa_get_pubkey_finalize(smc_fid, x1, x2, x3, 1867 x4, (uint32_t *) &x5, &mbox_error); 1868 SMC_RET1(handle, status); 1869 } 1870 1871 case ALTERA_SIP_SMC_ASYNC_FCS_ECDH_REQUEST_INIT: 1872 { 1873 status = intel_fcs_ecdh_request_init(x2, x3, x4, x5, x6, 1874 &mbox_error); 1875 SMC_RET1(handle, status); 1876 } 1877 1878 case ALTERA_SIP_SMC_ASYNC_FCS_ECDH_REQUEST_FINALIZE: 1879 { 1880 uint32_t dest_size = (uint32_t)x7; 1881 1882 NOTICE("MBOX: %s, %d: x7 0x%x, dest_size 0x%x\n", 1883 __func__, __LINE__, (uint32_t)x7, dest_size); 1884 1885 status = intel_fcs_ecdh_request_finalize(smc_fid, x1, x2, x3, 1886 x4, x5, x6, (uint32_t *) &dest_size, 1887 &mbox_error); 1888 SMC_RET1(handle, status); 1889 } 1890 1891 case ALTERA_SIP_SMC_ASYNC_MCTP_MSG: 1892 { 1893 uint32_t *src_addr = (uint32_t *)x2; 1894 uint32_t src_size = (uint32_t)x3; 1895 uint32_t *dst_addr = (uint32_t *)x4; 1896 1897 status = mailbox_send_cmd_async_v3(GET_CLIENT_ID(x1), 1898 GET_JOB_ID(x1), 1899 MBOX_CMD_MCTP_MSG, 1900 src_addr, 1901 src_size / MBOX_WORD_BYTE, 1902 MBOX_CMD_FLAG_CASUAL, 1903 sip_smc_ret_nbytes_cb, 1904 dst_addr, 1905 2); 1906 1907 SMC_RET1(handle, status); 1908 } 1909 1910 case ALTERA_SIP_SMC_ASYNC_FCS_HKDF_REQUEST: 1911 { 1912 status = intel_fcs_hkdf_request(smc_fid, x1, x2, x3, x4, x5, x6, 1913 x7); 1914 SMC_RET1(handle, status); 1915 } 1916 1917 default: 1918 return socfpga_sip_handler(smc_fid, x1, x2, x3, x4, 1919 cookie, handle, flags); 1920 } /* switch (smc_fid) */ 1921 } 1922 #endif 1923 1924 /* 1925 * This function is responsible for handling all SiP calls from the NS world 1926 */ 1927 1928 uintptr_t sip_smc_handler_v1(uint32_t smc_fid, 1929 u_register_t x1, 1930 u_register_t x2, 1931 u_register_t x3, 1932 u_register_t x4, 1933 void *cookie, 1934 void *handle, 1935 u_register_t flags) 1936 { 1937 uint32_t retval = 0, completed_addr[3]; 1938 uint32_t retval2 = 0; 1939 uint32_t mbox_error = 0; 1940 uint32_t err_states = 0; 1941 uint64_t retval64, rsu_respbuf[9]; 1942 uint32_t seu_respbuf[3]; 1943 int status = INTEL_SIP_SMC_STATUS_OK; 1944 int mbox_status; 1945 unsigned int len_in_resp = 0; 1946 u_register_t x5, x6, x7; 1947 1948 switch (smc_fid) { 1949 case SIP_SVC_UID: 1950 /* Return UID to the caller */ 1951 SMC_UUID_RET(handle, intl_svc_uid); 1952 1953 case INTEL_SIP_SMC_FPGA_CONFIG_ISDONE: 1954 status = intel_mailbox_fpga_config_isdone(&err_states); 1955 SMC_RET4(handle, status, err_states, 0, 0); 1956 1957 case INTEL_SIP_SMC_FPGA_CONFIG_GET_MEM: 1958 SMC_RET3(handle, INTEL_SIP_SMC_STATUS_OK, 1959 INTEL_SIP_SMC_FPGA_CONFIG_ADDR, 1960 INTEL_SIP_SMC_FPGA_CONFIG_SIZE - 1961 INTEL_SIP_SMC_FPGA_CONFIG_ADDR); 1962 1963 case INTEL_SIP_SMC_FPGA_CONFIG_START: 1964 status = intel_fpga_config_start(x1); 1965 SMC_RET4(handle, status, 0, 0, 0); 1966 1967 case INTEL_SIP_SMC_FPGA_CONFIG_WRITE: 1968 status = intel_fpga_config_write(x1, x2); 1969 SMC_RET4(handle, status, 0, 0, 0); 1970 1971 case INTEL_SIP_SMC_FPGA_CONFIG_COMPLETED_WRITE: 1972 status = intel_fpga_config_completed_write(completed_addr, 1973 &retval, &rcv_id); 1974 switch (retval) { 1975 case 1: 1976 SMC_RET4(handle, INTEL_SIP_SMC_STATUS_OK, 1977 completed_addr[0], 0, 0); 1978 1979 case 2: 1980 SMC_RET4(handle, INTEL_SIP_SMC_STATUS_OK, 1981 completed_addr[0], 1982 completed_addr[1], 0); 1983 1984 case 3: 1985 SMC_RET4(handle, INTEL_SIP_SMC_STATUS_OK, 1986 completed_addr[0], 1987 completed_addr[1], 1988 completed_addr[2]); 1989 1990 case 0: 1991 SMC_RET4(handle, status, 0, 0, 0); 1992 1993 default: 1994 mailbox_clear_response(); 1995 SMC_RET1(handle, INTEL_SIP_SMC_STATUS_ERROR); 1996 } 1997 1998 case INTEL_SIP_SMC_REG_READ: 1999 status = intel_secure_reg_read(x1, &retval); 2000 SMC_RET3(handle, status, retval, x1); 2001 2002 case INTEL_SIP_SMC_REG_WRITE: 2003 status = intel_secure_reg_write(x1, (uint32_t)x2, &retval); 2004 SMC_RET3(handle, status, retval, x1); 2005 2006 case INTEL_SIP_SMC_REG_UPDATE: 2007 status = intel_secure_reg_update(x1, (uint32_t)x2, 2008 (uint32_t)x3, &retval); 2009 SMC_RET3(handle, status, retval, x1); 2010 2011 case INTEL_SIP_SMC_RSU_STATUS: 2012 status = intel_rsu_status(rsu_respbuf, 2013 ARRAY_SIZE(rsu_respbuf)); 2014 if (status) { 2015 SMC_RET1(handle, status); 2016 } else { 2017 SMC_RET4(handle, rsu_respbuf[0], rsu_respbuf[1], 2018 rsu_respbuf[2], rsu_respbuf[3]); 2019 } 2020 2021 case INTEL_SIP_SMC_RSU_UPDATE: 2022 status = intel_rsu_update(x1); 2023 SMC_RET1(handle, status); 2024 2025 case INTEL_SIP_SMC_RSU_NOTIFY: 2026 status = intel_rsu_notify(x1); 2027 SMC_RET1(handle, status); 2028 2029 case INTEL_SIP_SMC_RSU_RETRY_COUNTER: 2030 status = intel_rsu_retry_counter((uint32_t *)rsu_respbuf, 2031 ARRAY_SIZE(rsu_respbuf), &retval); 2032 if (status) { 2033 SMC_RET1(handle, status); 2034 } else { 2035 SMC_RET2(handle, status, retval); 2036 } 2037 2038 case INTEL_SIP_SMC_RSU_DCMF_VERSION: 2039 SMC_RET3(handle, INTEL_SIP_SMC_STATUS_OK, 2040 ((uint64_t)rsu_dcmf_ver[1] << 32) | rsu_dcmf_ver[0], 2041 ((uint64_t)rsu_dcmf_ver[3] << 32) | rsu_dcmf_ver[2]); 2042 2043 case INTEL_SIP_SMC_RSU_COPY_DCMF_VERSION: 2044 status = intel_rsu_copy_dcmf_version(x1, x2); 2045 SMC_RET1(handle, status); 2046 2047 case INTEL_SIP_SMC_RSU_GET_DEVICE_INFO: 2048 status = intel_rsu_get_device_info((uint32_t *)rsu_respbuf, 2049 ARRAY_SIZE(rsu_respbuf)); 2050 if (status) { 2051 SMC_RET1(handle, status); 2052 } else { 2053 SMC_RET5(handle, status, rsu_respbuf[0], rsu_respbuf[1], 2054 rsu_respbuf[2], rsu_respbuf[3]); 2055 } 2056 2057 case INTEL_SIP_SMC_RSU_DCMF_STATUS: 2058 SMC_RET2(handle, INTEL_SIP_SMC_STATUS_OK, 2059 ((uint64_t)rsu_dcmf_stat[3] << 48) | 2060 ((uint64_t)rsu_dcmf_stat[2] << 32) | 2061 ((uint64_t)rsu_dcmf_stat[1] << 16) | 2062 rsu_dcmf_stat[0]); 2063 2064 case INTEL_SIP_SMC_RSU_COPY_DCMF_STATUS: 2065 status = intel_rsu_copy_dcmf_status(x1); 2066 SMC_RET1(handle, status); 2067 2068 case INTEL_SIP_SMC_RSU_MAX_RETRY: 2069 SMC_RET2(handle, INTEL_SIP_SMC_STATUS_OK, rsu_max_retry); 2070 2071 case INTEL_SIP_SMC_RSU_COPY_MAX_RETRY: 2072 rsu_max_retry = x1; 2073 SMC_RET1(handle, INTEL_SIP_SMC_STATUS_OK); 2074 2075 case INTEL_SIP_SMC_ECC_DBE: 2076 status = intel_ecc_dbe_notification(x1); 2077 SMC_RET1(handle, status); 2078 2079 case INTEL_SIP_SMC_SERVICE_COMPLETED: 2080 status = intel_smc_service_completed(x1, x2, x3, &rcv_id, 2081 &len_in_resp, &mbox_error); 2082 SMC_RET4(handle, status, mbox_error, x1, len_in_resp); 2083 2084 case INTEL_SIP_SMC_FIRMWARE_VERSION: 2085 status = intel_smc_fw_version(&retval); 2086 SMC_RET2(handle, status, retval); 2087 2088 case INTEL_SIP_SMC_MBOX_SEND_CMD: 2089 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2090 x6 = SMC_GET_GP(handle, CTX_GPREG_X6); 2091 status = intel_mbox_send_cmd(x1, (uint32_t *)x2, x3, x4, x5, x6, 2092 &mbox_status, &len_in_resp); 2093 SMC_RET3(handle, status, mbox_status, len_in_resp); 2094 2095 case INTEL_SIP_SMC_GET_USERCODE: 2096 status = intel_smc_get_usercode(&retval); 2097 SMC_RET2(handle, status, retval); 2098 2099 case INTEL_SIP_SMC_FCS_CRYPTION: 2100 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2101 2102 if (x1 == FCS_MODE_DECRYPT) { 2103 status = intel_fcs_decryption(x2, x3, x4, x5, &send_id); 2104 } else if (x1 == FCS_MODE_ENCRYPT) { 2105 status = intel_fcs_encryption(x2, x3, x4, x5, &send_id); 2106 } else { 2107 status = INTEL_SIP_SMC_STATUS_REJECTED; 2108 } 2109 2110 SMC_RET3(handle, status, x4, x5); 2111 2112 case INTEL_SIP_SMC_FCS_CRYPTION_EXT: 2113 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2114 x6 = SMC_GET_GP(handle, CTX_GPREG_X6); 2115 x7 = SMC_GET_GP(handle, CTX_GPREG_X7); 2116 2117 if (x3 == FCS_MODE_DECRYPT) { 2118 status = intel_fcs_decryption_ext(smc_fid, 0, x1, x2, x4, x5, x6, 2119 (uint32_t *) &x7, &mbox_error, 0, 0, 0); 2120 } else if (x3 == FCS_MODE_ENCRYPT) { 2121 status = intel_fcs_encryption_ext(smc_fid, 0, x1, x2, x4, x5, x6, 2122 (uint32_t *) &x7, &mbox_error, 0, 0); 2123 } else { 2124 status = INTEL_SIP_SMC_STATUS_REJECTED; 2125 } 2126 2127 SMC_RET4(handle, status, mbox_error, x6, x7); 2128 2129 case INTEL_SIP_SMC_FCS_RANDOM_NUMBER: 2130 status = intel_fcs_random_number_gen(x1, &retval64, 2131 &mbox_error); 2132 SMC_RET4(handle, status, mbox_error, x1, retval64); 2133 2134 case INTEL_SIP_SMC_FCS_RANDOM_NUMBER_EXT: 2135 status = intel_fcs_random_number_gen_ext(x1, x2, x3, 2136 &send_id); 2137 SMC_RET1(handle, status); 2138 2139 case INTEL_SIP_SMC_FCS_SEND_CERTIFICATE: 2140 status = intel_fcs_send_cert(smc_fid, 0, x1, x2, &send_id); 2141 SMC_RET1(handle, status); 2142 2143 case INTEL_SIP_SMC_FCS_GET_PROVISION_DATA: 2144 status = intel_fcs_get_provision_data(&send_id); 2145 SMC_RET1(handle, status); 2146 2147 case INTEL_SIP_SMC_FCS_CNTR_SET_PREAUTH: 2148 status = intel_fcs_cntr_set_preauth(smc_fid, 0, x1, x2, x3, 2149 &mbox_error); 2150 SMC_RET2(handle, status, mbox_error); 2151 2152 case INTEL_SIP_SMC_HPS_SET_BRIDGES: 2153 status = intel_hps_set_bridges(x1, x2); 2154 SMC_RET1(handle, status); 2155 2156 case INTEL_SIP_SMC_HWMON_READTEMP: 2157 status = intel_hwmon_readtemp(x1, &retval); 2158 SMC_RET2(handle, status, retval); 2159 2160 case INTEL_SIP_SMC_HWMON_READVOLT: 2161 status = intel_hwmon_readvolt(x1, &retval); 2162 SMC_RET2(handle, status, retval); 2163 2164 case INTEL_SIP_SMC_FCS_PSGSIGMA_TEARDOWN: 2165 status = intel_fcs_sigma_teardown(x1, &mbox_error); 2166 SMC_RET2(handle, status, mbox_error); 2167 2168 case INTEL_SIP_SMC_FCS_CHIP_ID: 2169 status = intel_fcs_chip_id(&retval, &retval2, &mbox_error); 2170 SMC_RET4(handle, status, mbox_error, retval, retval2); 2171 2172 case INTEL_SIP_SMC_FCS_ATTESTATION_SUBKEY: 2173 status = intel_fcs_attestation_subkey(x1, x2, x3, 2174 (uint32_t *) &x4, &mbox_error); 2175 SMC_RET4(handle, status, mbox_error, x3, x4); 2176 2177 case INTEL_SIP_SMC_FCS_ATTESTATION_MEASUREMENTS: 2178 status = intel_fcs_get_measurement(x1, x2, x3, 2179 (uint32_t *) &x4, &mbox_error); 2180 SMC_RET4(handle, status, mbox_error, x3, x4); 2181 2182 case INTEL_SIP_SMC_FCS_GET_ATTESTATION_CERT: 2183 status = intel_fcs_get_attestation_cert(smc_fid, 0, x1, x2, 2184 (uint32_t *) &x3, &mbox_error); 2185 SMC_RET4(handle, status, mbox_error, x2, x3); 2186 2187 case INTEL_SIP_SMC_FCS_CREATE_CERT_ON_RELOAD: 2188 status = intel_fcs_create_cert_on_reload(smc_fid, 0, x1, &mbox_error); 2189 SMC_RET2(handle, status, mbox_error); 2190 2191 case INTEL_SIP_SMC_FCS_OPEN_CS_SESSION: 2192 status = intel_fcs_open_crypto_service_session(&retval, &mbox_error); 2193 SMC_RET3(handle, status, mbox_error, retval); 2194 2195 case INTEL_SIP_SMC_FCS_CLOSE_CS_SESSION: 2196 status = intel_fcs_close_crypto_service_session(x1, &mbox_error); 2197 SMC_RET2(handle, status, mbox_error); 2198 2199 case INTEL_SIP_SMC_FCS_IMPORT_CS_KEY: 2200 status = intel_fcs_import_crypto_service_key(x1, x2, &send_id); 2201 SMC_RET1(handle, status); 2202 2203 case INTEL_SIP_SMC_FCS_EXPORT_CS_KEY: 2204 status = intel_fcs_export_crypto_service_key(x1, x2, x3, 2205 (uint32_t *) &x4, &mbox_error); 2206 SMC_RET4(handle, status, mbox_error, x3, x4); 2207 2208 case INTEL_SIP_SMC_FCS_REMOVE_CS_KEY: 2209 status = intel_fcs_remove_crypto_service_key(x1, x2, 2210 &mbox_error); 2211 SMC_RET2(handle, status, mbox_error); 2212 2213 case INTEL_SIP_SMC_FCS_GET_CS_KEY_INFO: 2214 status = intel_fcs_get_crypto_service_key_info(x1, x2, x3, 2215 (uint32_t *) &x4, &mbox_error); 2216 SMC_RET4(handle, status, mbox_error, x3, x4); 2217 2218 case INTEL_SIP_SMC_FCS_GET_DIGEST_INIT: 2219 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2220 status = intel_fcs_get_digest_init(x1, x2, x3, 2221 x4, x5, &mbox_error); 2222 SMC_RET2(handle, status, mbox_error); 2223 2224 case INTEL_SIP_SMC_FCS_GET_DIGEST_UPDATE: 2225 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2226 x6 = SMC_GET_GP(handle, CTX_GPREG_X6); 2227 status = intel_fcs_get_digest_update_finalize(smc_fid, 0, x1, x2, 2228 x3, x4, x5, (uint32_t *) &x6, false, 2229 &mbox_error, 0); 2230 SMC_RET4(handle, status, mbox_error, x5, x6); 2231 2232 case INTEL_SIP_SMC_FCS_GET_DIGEST_FINALIZE: 2233 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2234 x6 = SMC_GET_GP(handle, CTX_GPREG_X6); 2235 status = intel_fcs_get_digest_update_finalize(smc_fid, 0, x1, x2, 2236 x3, x4, x5, (uint32_t *) &x6, true, 2237 &mbox_error, 0); 2238 SMC_RET4(handle, status, mbox_error, x5, x6); 2239 2240 case INTEL_SIP_SMC_FCS_GET_DIGEST_SMMU_UPDATE: 2241 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2242 x6 = SMC_GET_GP(handle, CTX_GPREG_X6); 2243 status = intel_fcs_get_digest_smmu_update_finalize(x1, x2, x3, 2244 x4, x5, (uint32_t *) &x6, false, 2245 &mbox_error, &send_id); 2246 SMC_RET4(handle, status, mbox_error, x5, x6); 2247 2248 case INTEL_SIP_SMC_FCS_GET_DIGEST_SMMU_FINALIZE: 2249 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2250 x6 = SMC_GET_GP(handle, CTX_GPREG_X6); 2251 status = intel_fcs_get_digest_smmu_update_finalize(x1, x2, x3, 2252 x4, x5, (uint32_t *) &x6, true, 2253 &mbox_error, &send_id); 2254 SMC_RET4(handle, status, mbox_error, x5, x6); 2255 2256 case INTEL_SIP_SMC_FCS_MAC_VERIFY_INIT: 2257 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2258 status = intel_fcs_mac_verify_init(x1, x2, x3, 2259 x4, x5, &mbox_error); 2260 SMC_RET2(handle, status, mbox_error); 2261 2262 case INTEL_SIP_SMC_FCS_MAC_VERIFY_UPDATE: 2263 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2264 x6 = SMC_GET_GP(handle, CTX_GPREG_X6); 2265 x7 = SMC_GET_GP(handle, CTX_GPREG_X7); 2266 status = intel_fcs_mac_verify_update_finalize(smc_fid, 0, x1, x2, 2267 x3, x4, x5, (uint32_t *) &x6, x7, false, 2268 &mbox_error, 0); 2269 SMC_RET4(handle, status, mbox_error, x5, x6); 2270 2271 case INTEL_SIP_SMC_FCS_MAC_VERIFY_FINALIZE: 2272 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2273 x6 = SMC_GET_GP(handle, CTX_GPREG_X6); 2274 x7 = SMC_GET_GP(handle, CTX_GPREG_X7); 2275 status = intel_fcs_mac_verify_update_finalize(smc_fid, 0, x1, x2, 2276 x3, x4, x5, (uint32_t *) &x6, x7, true, 2277 &mbox_error, 0); 2278 SMC_RET4(handle, status, mbox_error, x5, x6); 2279 2280 case INTEL_SIP_SMC_FCS_MAC_VERIFY_SMMU_UPDATE: 2281 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2282 x6 = SMC_GET_GP(handle, CTX_GPREG_X6); 2283 x7 = SMC_GET_GP(handle, CTX_GPREG_X7); 2284 status = intel_fcs_mac_verify_smmu_update_finalize(x1, x2, x3, 2285 x4, x5, (uint32_t *) &x6, x7, 2286 false, &mbox_error, &send_id); 2287 SMC_RET4(handle, status, mbox_error, x5, x6); 2288 2289 case INTEL_SIP_SMC_FCS_MAC_VERIFY_SMMU_FINALIZE: 2290 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2291 x6 = SMC_GET_GP(handle, CTX_GPREG_X6); 2292 x7 = SMC_GET_GP(handle, CTX_GPREG_X7); 2293 status = intel_fcs_mac_verify_smmu_update_finalize(x1, x2, x3, 2294 x4, x5, (uint32_t *) &x6, x7, 2295 true, &mbox_error, &send_id); 2296 SMC_RET4(handle, status, mbox_error, x5, x6); 2297 2298 case INTEL_SIP_SMC_FCS_ECDSA_SHA2_DATA_SIGN_INIT: 2299 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2300 status = intel_fcs_ecdsa_sha2_data_sign_init(x1, x2, x3, 2301 x4, x5, &mbox_error); 2302 SMC_RET2(handle, status, mbox_error); 2303 2304 case INTEL_SIP_SMC_FCS_ECDSA_SHA2_DATA_SIGN_UPDATE: 2305 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2306 x6 = SMC_GET_GP(handle, CTX_GPREG_X6); 2307 status = intel_fcs_ecdsa_sha2_data_sign_update_finalize(smc_fid, 2308 0, x1, x2, x3, x4, x5, (uint32_t *) &x6, 2309 false, &mbox_error, 0); 2310 SMC_RET4(handle, status, mbox_error, x5, x6); 2311 2312 case INTEL_SIP_SMC_FCS_ECDSA_SHA2_DATA_SIGN_FINALIZE: 2313 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2314 x6 = SMC_GET_GP(handle, CTX_GPREG_X6); 2315 status = intel_fcs_ecdsa_sha2_data_sign_update_finalize(smc_fid, 2316 0, x1, x2, x3, x4, x5, (uint32_t *) &x6, 2317 true, &mbox_error, 0); 2318 SMC_RET4(handle, status, mbox_error, x5, x6); 2319 2320 case INTEL_SIP_SMC_FCS_ECDSA_SHA2_DATA_SIGN_SMMU_UPDATE: 2321 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2322 x6 = SMC_GET_GP(handle, CTX_GPREG_X6); 2323 status = intel_fcs_ecdsa_sha2_data_sign_smmu_update_finalize(x1, 2324 x2, x3, x4, x5, (uint32_t *) &x6, false, 2325 &mbox_error, &send_id); 2326 SMC_RET4(handle, status, mbox_error, x5, x6); 2327 2328 case INTEL_SIP_SMC_FCS_ECDSA_SHA2_DATA_SIGN_SMMU_FINALIZE: 2329 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2330 x6 = SMC_GET_GP(handle, CTX_GPREG_X6); 2331 status = intel_fcs_ecdsa_sha2_data_sign_smmu_update_finalize(x1, 2332 x2, x3, x4, x5, (uint32_t *) &x6, true, 2333 &mbox_error, &send_id); 2334 SMC_RET4(handle, status, mbox_error, x5, x6); 2335 2336 case INTEL_SIP_SMC_FCS_ECDSA_HASH_SIGN_INIT: 2337 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2338 status = intel_fcs_ecdsa_hash_sign_init(x1, x2, x3, 2339 x4, x5, &mbox_error); 2340 SMC_RET2(handle, status, mbox_error); 2341 2342 case INTEL_SIP_SMC_FCS_ECDSA_HASH_SIGN_FINALIZE: 2343 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2344 x6 = SMC_GET_GP(handle, CTX_GPREG_X6); 2345 status = intel_fcs_ecdsa_hash_sign_finalize(smc_fid, 0, x1, x2, 2346 x3, x4, x5, (uint32_t *) &x6, 2347 &mbox_error); 2348 SMC_RET4(handle, status, mbox_error, x5, x6); 2349 2350 case INTEL_SIP_SMC_FCS_ECDSA_HASH_SIG_VERIFY_INIT: 2351 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2352 status = intel_fcs_ecdsa_hash_sig_verify_init(x1, x2, x3, 2353 x4, x5, &mbox_error); 2354 SMC_RET2(handle, status, mbox_error); 2355 2356 case INTEL_SIP_SMC_FCS_ECDSA_HASH_SIG_VERIFY_FINALIZE: 2357 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2358 x6 = SMC_GET_GP(handle, CTX_GPREG_X6); 2359 status = intel_fcs_ecdsa_hash_sig_verify_finalize(smc_fid, 0, x1, 2360 x2, x3, x4, x5, (uint32_t *) &x6, 2361 &mbox_error); 2362 SMC_RET4(handle, status, mbox_error, x5, x6); 2363 2364 case INTEL_SIP_SMC_FCS_ECDSA_SHA2_DATA_SIG_VERIFY_INIT: 2365 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2366 status = intel_fcs_ecdsa_sha2_data_sig_verify_init(x1, x2, x3, 2367 x4, x5, &mbox_error); 2368 SMC_RET2(handle, status, mbox_error); 2369 2370 case INTEL_SIP_SMC_FCS_ECDSA_SHA2_DATA_SIG_VERIFY_UPDATE: 2371 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2372 x6 = SMC_GET_GP(handle, CTX_GPREG_X6); 2373 x7 = SMC_GET_GP(handle, CTX_GPREG_X7); 2374 status = intel_fcs_ecdsa_sha2_data_sig_verify_update_finalize( 2375 smc_fid, 0, x1, x2, x3, x4, x5, 2376 (uint32_t *) &x6, x7, false, 2377 &mbox_error, 0); 2378 SMC_RET4(handle, status, mbox_error, x5, x6); 2379 2380 case INTEL_SIP_SMC_FCS_ECDSA_SHA2_DATA_SIG_VERIFY_SMMU_UPDATE: 2381 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2382 x6 = SMC_GET_GP(handle, CTX_GPREG_X6); 2383 x7 = SMC_GET_GP(handle, CTX_GPREG_X7); 2384 status = intel_fcs_ecdsa_sha2_data_sig_verify_smmu_update_finalize( 2385 x1, x2, x3, x4, x5, (uint32_t *) &x6, 2386 x7, false, &mbox_error, &send_id); 2387 SMC_RET4(handle, status, mbox_error, x5, x6); 2388 2389 case INTEL_SIP_SMC_FCS_ECDSA_SHA2_DATA_SIG_VERIFY_SMMU_FINALIZE: 2390 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2391 x6 = SMC_GET_GP(handle, CTX_GPREG_X6); 2392 x7 = SMC_GET_GP(handle, CTX_GPREG_X7); 2393 status = intel_fcs_ecdsa_sha2_data_sig_verify_smmu_update_finalize( 2394 x1, x2, x3, x4, x5, (uint32_t *) &x6, 2395 x7, true, &mbox_error, &send_id); 2396 SMC_RET4(handle, status, mbox_error, x5, x6); 2397 2398 case INTEL_SIP_SMC_FCS_ECDSA_SHA2_DATA_SIG_VERIFY_FINALIZE: 2399 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2400 x6 = SMC_GET_GP(handle, CTX_GPREG_X6); 2401 x7 = SMC_GET_GP(handle, CTX_GPREG_X7); 2402 status = intel_fcs_ecdsa_sha2_data_sig_verify_update_finalize( 2403 smc_fid, 0, x1, x2, x3, x4, x5, 2404 (uint32_t *) &x6, x7, true, 2405 &mbox_error, 0); 2406 SMC_RET4(handle, status, mbox_error, x5, x6); 2407 2408 case INTEL_SIP_SMC_FCS_ECDSA_GET_PUBKEY_INIT: 2409 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2410 status = intel_fcs_ecdsa_get_pubkey_init(x1, x2, x3, 2411 x4, x5, &mbox_error); 2412 SMC_RET2(handle, status, mbox_error); 2413 2414 case INTEL_SIP_SMC_FCS_ECDSA_GET_PUBKEY_FINALIZE: 2415 status = intel_fcs_ecdsa_get_pubkey_finalize( 2416 INTEL_SIP_SMC_FCS_ECDSA_GET_PUBKEY_FINALIZE, 0, 2417 x1, x2, x3, (uint32_t *) &x4, &mbox_error); 2418 SMC_RET4(handle, status, mbox_error, x3, x4); 2419 2420 case INTEL_SIP_SMC_FCS_ECDH_REQUEST_INIT: 2421 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2422 status = intel_fcs_ecdh_request_init(x1, x2, x3, 2423 x4, x5, &mbox_error); 2424 SMC_RET2(handle, status, mbox_error); 2425 2426 case INTEL_SIP_SMC_FCS_ECDH_REQUEST_FINALIZE: 2427 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2428 x6 = SMC_GET_GP(handle, CTX_GPREG_X6); 2429 status = intel_fcs_ecdh_request_finalize(smc_fid, 0, x1, x2, x3, 2430 x4, x5, (uint32_t *) &x6, &mbox_error); 2431 SMC_RET4(handle, status, mbox_error, x5, x6); 2432 2433 case INTEL_SIP_SMC_FCS_AES_CRYPT_INIT: 2434 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2435 status = intel_fcs_aes_crypt_init(x1, x2, x3, x4, x5, 2436 &mbox_error); 2437 SMC_RET2(handle, status, mbox_error); 2438 2439 case INTEL_SIP_SMC_FCS_AES_CRYPT_UPDATE: 2440 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2441 x6 = SMC_GET_GP(handle, CTX_GPREG_X6); 2442 status = intel_fcs_aes_crypt_update_finalize(smc_fid, 0, x1, x2, 2443 x3, x4, x5, x6, 0, false, &send_id, 0, 0); 2444 SMC_RET1(handle, status); 2445 2446 case INTEL_SIP_SMC_FCS_AES_CRYPT_FINALIZE: 2447 x5 = SMC_GET_GP(handle, CTX_GPREG_X5); 2448 x6 = SMC_GET_GP(handle, CTX_GPREG_X6); 2449 status = intel_fcs_aes_crypt_update_finalize(smc_fid, 0, x1, x2, 2450 x3, x4, x5, x6, 0, true, &send_id, 0, 0); 2451 SMC_RET1(handle, status); 2452 2453 #if PLATFORM_MODEL == PLAT_SOCFPGA_AGILEX5 2454 case INTEL_SIP_SMC_FCS_SDM_REMAPPER_CONFIG: 2455 status = intel_smmu_hps_remapper_config(x1); 2456 SMC_RET1(handle, status); 2457 #endif 2458 2459 case INTEL_SIP_SMC_GET_ROM_PATCH_SHA384: 2460 status = intel_fcs_get_rom_patch_sha384(x1, &retval64, 2461 &mbox_error); 2462 SMC_RET4(handle, status, mbox_error, x1, retval64); 2463 2464 case INTEL_SIP_SMC_SVC_VERSION: 2465 SMC_RET3(handle, INTEL_SIP_SMC_STATUS_OK, 2466 SIP_SVC_VERSION_MAJOR, 2467 SIP_SVC_VERSION_MINOR); 2468 2469 case INTEL_SIP_SMC_SEU_ERR_STATUS: 2470 status = intel_sdm_seu_err_read(seu_respbuf, 2471 ARRAY_SIZE(seu_respbuf)); 2472 if (status) { 2473 SMC_RET1(handle, status); 2474 } else { 2475 SMC_RET3(handle, seu_respbuf[0], seu_respbuf[1], seu_respbuf[2]); 2476 } 2477 2478 case INTEL_SIP_SMC_SAFE_INJECT_SEU_ERR: 2479 status = intel_sdm_safe_inject_seu_err((uint32_t *)&x1, (uint32_t)x2); 2480 SMC_RET1(handle, status); 2481 2482 case INTEL_SIP_SMC_ATF_BUILD_VER: 2483 SMC_RET4(handle, INTEL_SIP_SMC_STATUS_OK, VERSION_MAJOR, 2484 VERSION_MINOR, VERSION_PATCH); 2485 2486 #if PLATFORM_MODEL == PLAT_SOCFPGA_AGILEX5 2487 case INTEL_SIP_SMC_INJECT_IO96B_ECC_ERR: 2488 intel_inject_io96b_ecc_err((uint32_t *)&x1, (uint32_t)x2); 2489 SMC_RET1(handle, INTEL_SIP_SMC_STATUS_OK); 2490 #endif 2491 2492 default: 2493 return socfpga_sip_handler(smc_fid, x1, x2, x3, x4, 2494 cookie, handle, flags); 2495 } 2496 } 2497 2498 uintptr_t sip_smc_handler(uint32_t smc_fid, 2499 u_register_t x1, 2500 u_register_t x2, 2501 u_register_t x3, 2502 u_register_t x4, 2503 void *cookie, 2504 void *handle, 2505 u_register_t flags) 2506 { 2507 uint32_t cmd = smc_fid & INTEL_SIP_SMC_CMD_MASK; 2508 2509 if (cmd >= INTEL_SIP_SMC_CMD_V2_RANGE_BEGIN && 2510 cmd <= INTEL_SIP_SMC_CMD_V2_RANGE_END) { 2511 return sip_smc_handler_v2(smc_fid, x1, x2, x3, x4, 2512 cookie, handle, flags); 2513 } 2514 #if SIP_SVC_V3 2515 else if ((cmd >= INTEL_SIP_SMC_CMD_V3_RANGE_BEGIN) && 2516 (cmd <= INTEL_SIP_SMC_CMD_V3_RANGE_END)) { 2517 uintptr_t ret = sip_smc_handler_v3(smc_fid, x1, x2, x3, x4, 2518 cookie, handle, flags); 2519 return ret; 2520 } 2521 #endif 2522 else { 2523 return sip_smc_handler_v1(smc_fid, x1, x2, x3, x4, 2524 cookie, handle, flags); 2525 } 2526 } 2527 2528 DECLARE_RT_SVC( 2529 socfpga_sip_svc, 2530 OEN_SIP_START, 2531 OEN_SIP_END, 2532 SMC_TYPE_FAST, 2533 NULL, 2534 sip_smc_handler 2535 ); 2536 2537 DECLARE_RT_SVC( 2538 socfpga_sip_svc_std, 2539 OEN_SIP_START, 2540 OEN_SIP_END, 2541 SMC_TYPE_YIELD, 2542 NULL, 2543 sip_smc_handler 2544 ); 2545