1 /* 2 * Copyright 2017, Rockchip Electronics Co., Ltd 3 * hisping lin, <hisping.lin@rock-chips.com> 4 * 5 * SPDX-License-Identifier: GPL-2.0+ 6 */ 7 #include <common.h> 8 #include <stdlib.h> 9 #include <command.h> 10 #include <mmc.h> 11 #include <optee_include/OpteeClientMem.h> 12 #include <optee_include/OpteeClientRPC.h> 13 #include <optee_include/teesmc.h> 14 #include <optee_include/teesmc_v2.h> 15 #include <optee_include/teesmc_optee.h> 16 #include <optee_include/tee_rpc_types.h> 17 #include <optee_include/tee_rpc.h> 18 #ifdef CONFIG_OPTEE_V1 19 #include <optee_include/OpteeClientRkFs.h> 20 #endif 21 #ifdef CONFIG_OPTEE_V2 22 #include <optee_include/OpteeClientRkNewFs.h> 23 #endif 24 25 /* 26 * Memory allocation. 27 * Currently treated the same for both arguments & payloads. 28 */ 29 TEEC_Result OpteeRpcAlloc(uint32_t Size, uint32_t *Address) 30 { 31 TEEC_Result TeecResult = TEEC_SUCCESS; 32 size_t AllocAddress; 33 34 *Address = 0; 35 36 if (Size != 0) { 37 AllocAddress = (size_t) OpteeClientMemAlloc(Size); 38 39 if (AllocAddress == 0) 40 TeecResult = TEEC_ERROR_OUT_OF_MEMORY; 41 else 42 *Address = AllocAddress; 43 } 44 return TeecResult; 45 } 46 47 /* 48 * Memory free. 49 * Currently treated the same for both arguments & payloads. 50 */ 51 TEEC_Result OpteeRpcFree(uint32_t Address) 52 { 53 OpteeClientMemFree((void *)(size_t)Address); 54 return TEEC_SUCCESS; 55 } 56 57 int is_uuid_equal(TEE_UUID uuid1, TEEC_UUID uuid2) 58 { 59 bool a, b, c; 60 61 a = (uuid1.timeLow == uuid2.timeLow); 62 b = (uuid1.timeMid == uuid2.timeMid); 63 c = (uuid1.timeHiAndVersion == uuid2.timeHiAndVersion); 64 if ((a & b & c) == 0) { 65 return 0; 66 } else { 67 if (memcmp(uuid1.clockSeqAndNode, 68 uuid2.clockSeqAndNode, 8) == 0) { 69 return 1; 70 } else { 71 return 0; 72 } 73 } 74 } 75 76 /* 77 * Load a TA from storage into memory and provide it back to OpTEE. 78 * Param[0] = IN: struct tee_rpc_load_ta_cmd 79 * Param[1] = IN: all-zero OUT: TA Image allocated 80 */ 81 TEEC_Result OpteeRpcCmdLoadTa(t_teesmc32_arg *TeeSmc32Arg) 82 { 83 TEEC_Result TeecResult = TEEC_SUCCESS; 84 t_teesmc32_param *TeeSmc32Param = NULL; 85 struct tee_rpc_load_ta_cmd *TeeLoadTaCmd = NULL; 86 uint32_t TeeLoadTaCmdSize = 0; 87 88 if (TeeSmc32Arg->num_params != 2) { 89 TeecResult = TEEC_ERROR_BAD_PARAMETERS; 90 goto Exit; 91 } 92 93 TEEC_UUID TA_RK_KEYMASTER_UUID = {0x258be795, 0xf9ca, 0x40e6, 94 {0xa8, 0x69, 0x9c, 0xe6, 0x88, 0x6c, 0x5d, 0x5d} }; 95 TeeSmc32Param = TEESMC32_GET_PARAMS(TeeSmc32Arg); 96 TeeLoadTaCmd = (struct tee_rpc_load_ta_cmd *) 97 (size_t)TeeSmc32Param[0].u.memref.buf_ptr; 98 TeeLoadTaCmdSize = TeeSmc32Param[0].u.memref.size; 99 100 if ((TeeLoadTaCmd == NULL) || 101 (TeeLoadTaCmdSize != sizeof(*TeeLoadTaCmd))) { 102 TeecResult = TEEC_ERROR_BAD_PARAMETERS; 103 goto Exit; 104 } 105 106 TEEC_Result Status = 0; 107 void *ImageData = NULL; 108 uint32_t ImageSize = 0; 109 size_t AllocAddress = 0; 110 111 if (is_uuid_equal(TeeLoadTaCmd->uuid, TA_RK_KEYMASTER_UUID)) { 112 ImageData = (void *)0; 113 ImageSize = 0; 114 } else { 115 ImageData = (void *)0; 116 ImageSize = 0; 117 } 118 119 if (Status != 0) { 120 TeecResult = TEEC_ERROR_ITEM_NOT_FOUND; 121 goto Exit; 122 } 123 124 AllocAddress = (size_t) OpteeClientMemAlloc(ImageSize); 125 126 if (AllocAddress == 0) { 127 TeecResult = TEEC_ERROR_OUT_OF_MEMORY; 128 goto Exit; 129 } 130 131 memcpy((void *)AllocAddress, ImageData, ImageSize); 132 133 debug("TEEC: ...TA loaded at 0x%zu of size 0x%X bytes\n", 134 AllocAddress, ImageSize); 135 debug("TEEC: ...AllocAddress[0] 0x%X ; AllocAddress[1] 0x%X bytes\n", 136 *(char *)AllocAddress, *(char *)(AllocAddress+1)); 137 138 TeeLoadTaCmd->va = AllocAddress; 139 140 TeeSmc32Param[1].u.memref.buf_ptr = AllocAddress; 141 TeeSmc32Param[1].u.memref.size = ImageSize; 142 143 Exit: 144 TeeSmc32Arg->ret = TeecResult; 145 TeeSmc32Arg->ret_origin = TEEC_ORIGIN_API; 146 147 debug("TEEC: OpteeRpcCmdLoadTa Exit : TeecResult=0x%X\n", TeecResult); 148 149 return TeecResult; 150 } 151 152 TEEC_Result OpteeRpcCmdLoadV2Ta(t_teesmc32_arg *TeeSmc32Arg) 153 { 154 TEEC_Result TeecResult = TEEC_SUCCESS; 155 t_teesmc32_param *TeeSmc32Param = NULL; 156 uint8_t uuid[16]; 157 int i; 158 159 if (TeeSmc32Arg->num_params != 2) { 160 TeecResult = TEEC_ERROR_BAD_PARAMETERS; 161 goto Exit; 162 } 163 164 TeeSmc32Param = TEESMC32_GET_PARAMS(TeeSmc32Arg); 165 166 memcpy(uuid, (void *)&TeeSmc32Param[0].u.value, 16); 167 for (i = 0; i < 16; i++) 168 debug("TEEC: uuid 0x%x", uuid[i]); 169 170 if (TeeSmc32Param[1].u.memref.buf_ptr == 0) { 171 debug("TEEC: return size of TA, keymaster_size = 0\n"); 172 TeeSmc32Param[1].u.memref.size = 0; 173 } else { 174 /*memcpy((void *)(size_t)TeeSmc32Param[1].u.memref.buf_ptr, 175 (void *)keymaster_data, TeeSmc32Param[1].u.memref.size);*/ 176 debug("TEEC: memref.buf_ptr = 0x%llx; memref.size = 0x%llx\n", 177 (uint64_t)TeeSmc32Param[1].u.memref.buf_ptr, 178 (uint64_t)TeeSmc32Param[1].u.memref.size); 179 } 180 181 Exit: 182 TeeSmc32Arg->ret = TeecResult; 183 TeeSmc32Arg->ret_origin = TEEC_ORIGIN_API; 184 185 debug("TEEC: OpteeRpcCmdLoadTa Exit : TeecResult=0x%X\n", TeecResult); 186 187 return TeecResult; 188 } 189 190 /* 191 * Free a previously loaded TA and release the memory 192 * Param[0] = IN: TA Image to free 193 * 194 * Um, why is OpTEE holding on to this memory? The OS code suggests that OpTEE 195 * is using the binary in place out of shared memory but I don't understand how 196 * runtime modifications of the binary are being prevented if that's the case? 197 */ 198 TEEC_Result OpteeRpcCmdFreeTa(t_teesmc32_arg *TeeSmc32Arg) 199 { 200 TEEC_Result TeecResult = TEEC_SUCCESS; 201 t_teesmc32_param *TeeSmc32Param = NULL; 202 uint32_t ImageSize = 0; 203 size_t AllocAddress = 0; 204 205 if (TeeSmc32Arg->num_params != 1) { 206 TeecResult = TEEC_ERROR_BAD_PARAMETERS; 207 goto Exit; 208 } 209 210 TeeSmc32Param = TEESMC32_GET_PARAMS(TeeSmc32Arg); 211 212 AllocAddress = TeeSmc32Param[0].u.memref.buf_ptr; 213 ImageSize = TeeSmc32Param[0].u.memref.size; 214 215 debug("TEEC: OpteeRpcCmdFreeTa Enter: AllocAddress=0x%X, ImageSize=0x%X\n", 216 (uint32_t) AllocAddress, (uint32_t) ImageSize); 217 218 if (AllocAddress == 0) { 219 TeecResult = TEEC_ERROR_BAD_PARAMETERS; 220 goto Exit; 221 } 222 223 OpteeClientMemFree((void *)AllocAddress); 224 225 Exit: 226 TeeSmc32Arg->ret = TeecResult; 227 TeeSmc32Arg->ret_origin = TEEC_ORIGIN_API; 228 229 debug("TEEC: OpteeRpcCmdFreeTa Exit : TeecResult=0x%X\n", TeecResult); 230 231 return TeecResult; 232 } 233 234 /* 235 * Execute an RPMB storage operation. 236 */ 237 238 uint16_t global_block_count; 239 TEEC_Result OpteeRpcCmdRpmb(t_teesmc32_arg *TeeSmc32Arg) 240 { 241 struct tee_rpc_rpmb_dev_info *DevInfo; 242 TEEC_Result EfiStatus; 243 uint16_t RequestMsgType, i; 244 EFI_RK_RPMB_DATA_PACKET *RequestPackets; 245 EFI_RK_RPMB_DATA_PACKET *ResponsePackets; 246 EFI_RK_RPMB_DATA_PACKET *tempPackets; 247 EFI_RK_RPMB_DATA_PACKET_BACK *RequestPackets_back; 248 EFI_RK_RPMB_DATA_PACKET_BACK *tempPackets_back; 249 struct tee_rpc_rpmb_cmd *RpmbRequest; 250 TEEC_Result TeecResult = TEEC_SUCCESS; 251 t_teesmc32_param *TeeSmc32Param; 252 struct mmc *mmc; 253 254 debug("TEEC: Entered RPMB RPC\n"); 255 256 if (TeeSmc32Arg->num_params != 2) { 257 TeecResult = TEEC_ERROR_BAD_PARAMETERS; 258 goto Exit; 259 } 260 261 TeeSmc32Param = TEESMC32_GET_PARAMS(TeeSmc32Arg); 262 RpmbRequest = (struct tee_rpc_rpmb_cmd *)(size_t) 263 TeeSmc32Param[0].u.memref.buf_ptr; 264 switch (RpmbRequest->cmd) { 265 case TEE_RPC_RPMB_CMD_DATA_REQ: { 266 RequestPackets = (EFI_RK_RPMB_DATA_PACKET *)(RpmbRequest + 1); 267 ResponsePackets = (EFI_RK_RPMB_DATA_PACKET *)(size_t) 268 TeeSmc32Param[1].u.memref.buf_ptr; 269 270 global_block_count = 271 (RpmbRequest->block_count == 0 ? 272 1 : RpmbRequest->block_count); 273 RequestPackets_back = 274 malloc(sizeof(EFI_RK_RPMB_DATA_PACKET_BACK) 275 * global_block_count); 276 memcpy(RequestPackets_back->stuff, 277 RequestPackets->stuff_bytes, 278 RPMB_STUFF_DATA_SIZE); 279 memcpy(RequestPackets_back->mac, 280 RequestPackets->key_mac, 281 RPMB_KEY_MAC_SIZE); 282 memcpy(RequestPackets_back->data, 283 RequestPackets->data, 284 RPMB_DATA_SIZE); 285 memcpy(RequestPackets_back->nonce, 286 RequestPackets->nonce, 287 RPMB_NONCE_SIZE); 288 RequestPackets_back->write_counter = 289 ((RequestPackets->write_counter[3]) << 24) + 290 ((RequestPackets->write_counter[2]) << 16) + 291 ((RequestPackets->write_counter[1]) << 8) + 292 (RequestPackets->write_counter[0]); 293 RequestPackets_back->address = 294 ((RequestPackets->address[1]) << 8) + 295 (RequestPackets->address[0]); 296 RequestPackets_back->block_count = 297 ((RequestPackets->block_count[1]) << 8) + 298 (RequestPackets->block_count[0]); 299 RequestPackets_back->result = 300 ((RequestPackets->op_result[1]) << 8) + 301 (RequestPackets->op_result[0]); 302 RequestPackets_back->request = 303 ((RequestPackets->msg_type[1]) << 8) + 304 (RequestPackets->msg_type[0]); 305 306 RequestMsgType = RPMB_PACKET_DATA_TO_UINT16( 307 RequestPackets->msg_type); 308 309 debug("TEEC: RPMB Data request %d\n", RequestMsgType); 310 311 switch (RequestMsgType) { 312 case TEE_RPC_RPMB_MSG_TYPE_REQ_AUTH_KEY_PROGRAM: { 313 if (init_rpmb() != 0) { 314 TeecResult = TEEC_ERROR_GENERIC; 315 break; 316 } 317 318 EfiStatus = do_programkey((struct s_rpmb *) 319 RequestPackets_back); 320 321 if (finish_rpmb() != 0) { 322 TeecResult = TEEC_ERROR_GENERIC; 323 break; 324 } 325 326 if (EfiStatus != 0) { 327 TeecResult = TEEC_ERROR_GENERIC; 328 break; 329 } 330 331 break; 332 } 333 334 case TEE_RPC_RPMB_MSG_TYPE_REQ_WRITE_COUNTER_VAL_READ: { 335 if (init_rpmb() != 0) { 336 TeecResult = TEEC_ERROR_GENERIC; 337 break; 338 } 339 340 EfiStatus = do_readcounter((struct s_rpmb *) 341 RequestPackets_back); 342 343 if (finish_rpmb() != 0) { 344 TeecResult = TEEC_ERROR_GENERIC; 345 break; 346 } 347 348 if (EfiStatus != 0) { 349 TeecResult = TEEC_ERROR_GENERIC; 350 break; 351 } 352 353 break; 354 } 355 356 case TEE_RPC_RPMB_MSG_TYPE_REQ_AUTH_DATA_WRITE: { 357 if (init_rpmb() != 0) { 358 TeecResult = TEEC_ERROR_GENERIC; 359 break; 360 } 361 362 EfiStatus = do_authenticatedwrite((struct s_rpmb *) 363 RequestPackets_back); 364 365 if (finish_rpmb() != 0) { 366 TeecResult = TEEC_ERROR_GENERIC; 367 break; 368 } 369 370 if (EfiStatus != 0) { 371 TeecResult = TEEC_ERROR_GENERIC; 372 break; 373 } 374 375 break; 376 } 377 378 case TEE_RPC_RPMB_MSG_TYPE_REQ_AUTH_DATA_READ: { 379 if (init_rpmb() != 0) { 380 TeecResult = TEEC_ERROR_GENERIC; 381 break; 382 } 383 384 EfiStatus = do_authenticatedread((struct s_rpmb *) 385 RequestPackets_back, global_block_count); 386 387 if (finish_rpmb() != 0) { 388 TeecResult = TEEC_ERROR_GENERIC; 389 break; 390 } 391 392 if (EfiStatus != 0) { 393 TeecResult = TEEC_ERROR_GENERIC; 394 break; 395 } 396 397 break; 398 } 399 400 default: 401 TeecResult = TEEC_ERROR_BAD_PARAMETERS; 402 break; 403 } 404 debug("TEEC: RPMB TeecResult %d\n", TeecResult); 405 break; 406 } 407 408 case TEE_RPC_RPMB_CMD_GET_DEV_INFO: { 409 if (init_rpmb()) { 410 TeecResult = TEEC_ERROR_GENERIC; 411 goto Exit; 412 } 413 414 mmc = do_returnmmc(); 415 if (finish_rpmb()) { 416 TeecResult = TEEC_ERROR_GENERIC; 417 goto Exit; 418 } 419 420 if (mmc == NULL) { 421 TeecResult = TEEC_ERROR_GENERIC; 422 goto Exit; 423 } 424 425 DevInfo = (struct tee_rpc_rpmb_dev_info *)(size_t) 426 TeeSmc32Param[1].u.memref.buf_ptr; 427 428 DevInfo->cid[0] = (mmc->cid[0]) >> 24 & 0xff; 429 DevInfo->cid[1] = (mmc->cid[0]) >> 16 & 0xff; 430 DevInfo->cid[2] = (mmc->cid[0]) >> 8 & 0xff; 431 DevInfo->cid[3] = (mmc->cid[0]) & 0xff; 432 DevInfo->cid[4] = (mmc->cid[1]) >> 24 & 0xff; 433 DevInfo->cid[5] = (mmc->cid[1]) >> 16 & 0xff; 434 DevInfo->cid[6] = (mmc->cid[1]) >> 8 & 0xff; 435 DevInfo->cid[7] = (mmc->cid[1]) & 0xff; 436 DevInfo->cid[8] = (mmc->cid[2]) >> 24 & 0xff; 437 DevInfo->cid[9] = (mmc->cid[2]) >> 16 & 0xff; 438 DevInfo->cid[10] = (mmc->cid[2]) >> 8 & 0xff; 439 DevInfo->cid[11] = (mmc->cid[2]) & 0xff; 440 DevInfo->cid[12] = (mmc->cid[3]) >> 24 & 0xff; 441 DevInfo->cid[13] = (mmc->cid[3]) >> 16 & 0xff; 442 DevInfo->cid[14] = (mmc->cid[3]) >> 8 & 0xff; 443 DevInfo->cid[15] = (mmc->cid[3]) & 0xff; 444 DevInfo->rel_wr_sec_c = 1; 445 DevInfo->rpmb_size_mult = 446 (uint8_t)(mmc->capacity_rpmb / (128 * 1024)); 447 DevInfo->ret_code = 0; 448 449 goto Exit; 450 } 451 452 default: 453 TeecResult = TEEC_ERROR_BAD_PARAMETERS; 454 455 goto Exit; 456 } 457 458 tempPackets = ResponsePackets; 459 tempPackets_back = RequestPackets_back; 460 461 for (i = 0; i < global_block_count; i++) { 462 memcpy(tempPackets->stuff_bytes, 463 tempPackets_back->stuff, 464 RPMB_STUFF_DATA_SIZE); 465 memcpy(tempPackets->key_mac, 466 tempPackets_back->mac, 467 RPMB_KEY_MAC_SIZE); 468 memcpy(tempPackets->data, 469 tempPackets_back->data, 470 RPMB_DATA_SIZE); 471 memcpy(tempPackets->nonce, 472 tempPackets_back->nonce, 473 RPMB_NONCE_SIZE); 474 tempPackets->write_counter[3] = 475 ((tempPackets_back->write_counter) >> 24) & 0xFF; 476 tempPackets->write_counter[2] = 477 ((tempPackets_back->write_counter) >> 16) & 0xFF; 478 tempPackets->write_counter[1] = 479 ((tempPackets_back->write_counter) >> 8) & 0xFF; 480 tempPackets->write_counter[0] = 481 (tempPackets_back->write_counter) & 0xFF; 482 tempPackets->address[1] = 483 ((tempPackets_back->address) >> 8) & 0xFF; 484 tempPackets->address[0] = 485 (tempPackets_back->address) & 0xFF; 486 tempPackets->block_count[1] = 487 ((tempPackets_back->block_count) >> 8) & 0xFF; 488 tempPackets->block_count[0] = 489 (tempPackets_back->block_count) & 0xFF; 490 tempPackets->op_result[1] = 491 ((tempPackets_back->result) >> 8) & 0xFF; 492 tempPackets->op_result[0] = 493 (tempPackets_back->result) & 0xFF; 494 tempPackets->msg_type[1] = 495 ((tempPackets_back->request) >> 8) & 0xFF; 496 tempPackets->msg_type[0] = 497 (tempPackets_back->request) & 0xFF; 498 tempPackets++; 499 tempPackets_back++; 500 } 501 502 free(RequestPackets_back); 503 504 Exit: 505 TeeSmc32Arg->ret = TeecResult; 506 TeeSmc32Arg->ret_origin = TEEC_ORIGIN_API; 507 508 return TeecResult; 509 } 510 511 /* 512 * Execute a normal world local file system operation. 513 */ 514 TEEC_Result OpteeRpcCmdFs(t_teesmc32_arg *TeeSmc32Arg) 515 { 516 TEEC_Result TeecResult = TEEC_SUCCESS; 517 t_teesmc32_param *TeeSmc32Param; 518 519 TeeSmc32Param = TEESMC32_GET_PARAMS(TeeSmc32Arg); 520 #ifdef CONFIG_OPTEE_V1 521 TeecResult = OpteeClientRkFsProcess((void *)(size_t)TeeSmc32Param[0].u.memref.buf_ptr, 522 TeeSmc32Param[0].u.memref.size); 523 #endif 524 #ifdef CONFIG_OPTEE_V2 525 TeecResult = OpteeClientRkFsProcess((size_t)TeeSmc32Arg->num_params, 526 (struct tee_ioctl_param *)TeeSmc32Param); 527 #endif 528 529 return TeecResult; 530 } 531 532 /* 533 * TBD. 534 */ 535 TEEC_Result OpteeRpcCmdGetTime(t_teesmc32_arg *TeeSmc32Arg) 536 { 537 return TEEC_ERROR_NOT_IMPLEMENTED; 538 } 539 540 /* 541 * TBD. 542 */ 543 TEEC_Result OpteeRpcCmdWaitMutex(t_teesmc32_arg *TeeSmc32Arg) 544 { 545 return TEEC_ERROR_NOT_IMPLEMENTED; 546 } 547 548 /* 549 * Handle the callback from secure world. 550 */ 551 TEEC_Result OpteeRpcCallback(ARM_SMC_ARGS *ArmSmcArgs) 552 { 553 TEEC_Result TeecResult = TEEC_SUCCESS; 554 555 //printf("OpteeRpcCallback Enter: Arg0=0x%X, Arg1=0x%X, Arg2=0x%X\n", 556 //ArmSmcArgs->Arg0, ArmSmcArgs->Arg1, ArmSmcArgs->Arg2); 557 558 switch (TEESMC_RETURN_GET_RPC_FUNC(ArmSmcArgs->Arg0)) { 559 case TEESMC_RPC_FUNC_ALLOC_ARG: { 560 debug("TEEC: ArmSmcArgs->Arg1 = 0x%x \n", ArmSmcArgs->Arg1); 561 TeecResult = OpteeRpcAlloc(ArmSmcArgs->Arg1, &ArmSmcArgs->Arg2); 562 ArmSmcArgs->Arg5 = ArmSmcArgs->Arg2; 563 ArmSmcArgs->Arg1 = 0; 564 ArmSmcArgs->Arg4 = 0; 565 break; 566 } 567 568 case TEESMC_RPC_FUNC_ALLOC_PAYLOAD: { 569 TeecResult = OpteeRpcAlloc(ArmSmcArgs->Arg1, &ArmSmcArgs->Arg1); 570 break; 571 } 572 573 case TEESMC_RPC_FUNC_FREE_ARG: { 574 TeecResult = OpteeRpcFree(ArmSmcArgs->Arg2); 575 break; 576 } 577 578 case TEESMC_RPC_FUNC_FREE_PAYLOAD: { 579 TeecResult = OpteeRpcFree(ArmSmcArgs->Arg1); 580 break; 581 } 582 583 case TEESMC_RPC_FUNC_IRQ: { 584 break; 585 } 586 587 case TEESMC_RPC_FUNC_CMD: { 588 t_teesmc32_arg *TeeSmc32Arg = 589 (t_teesmc32_arg *)(size_t)((uint64_t)ArmSmcArgs->Arg1 << 32 | ArmSmcArgs->Arg2); 590 debug("TEEC: TeeSmc32Arg->cmd = 0x%x\n", TeeSmc32Arg->cmd); 591 switch (TeeSmc32Arg->cmd) { 592 case OPTEE_MSG_RPC_CMD_SHM_ALLOC_V2: { 593 uint32_t tempaddr; 594 uint32_t allocsize = TeeSmc32Arg->params[0].u.value.b; 595 TeecResult = OpteeRpcAlloc(allocsize, &tempaddr); 596 debug("TEEC: allocsize = 0x%x tempaddr = 0x%x\n", allocsize, tempaddr); 597 TeeSmc32Arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT_V2; 598 TeeSmc32Arg->params[0].u.memref.buf_ptr = tempaddr; 599 TeeSmc32Arg->params[0].u.memref.size = allocsize; 600 TeeSmc32Arg->params[0].u.memref.shm_ref = tempaddr; 601 TeeSmc32Arg->ret = TEE_SUCCESS; 602 break; 603 } 604 case OPTEE_MSG_RPC_CMD_SHM_FREE_V2: { 605 uint32_t tempaddr = TeeSmc32Arg->params[0].u.value.b; 606 TeecResult = OpteeRpcFree(tempaddr); 607 break; 608 609 } 610 case OPTEE_MSG_RPC_CMD_RPMB_V2: { 611 TeecResult = OpteeRpcCmdRpmb(TeeSmc32Arg); 612 break; 613 } 614 case OPTEE_MSG_RPC_CMD_FS_V2: { 615 TeecResult = OpteeRpcCmdFs(TeeSmc32Arg); 616 TeeSmc32Arg->ret = TEEC_SUCCESS; 617 break; 618 } 619 case OPTEE_MSG_RPC_CMD_LOAD_TA_V2: { 620 TeecResult = OpteeRpcCmdLoadV2Ta(TeeSmc32Arg); 621 break; 622 } 623 624 default: { 625 printf("TEEC: ...unsupported RPC CMD: cmd=0x%X\n", 626 TeeSmc32Arg->cmd); 627 TeecResult = TEEC_ERROR_NOT_IMPLEMENTED; 628 break; 629 } 630 } 631 632 break; 633 } 634 635 case TEESMC_OPTEE_RPC_FUNC_ALLOC_PAYLOAD: { 636 TeecResult = OpteeRpcAlloc(ArmSmcArgs->Arg1, &ArmSmcArgs->Arg1); 637 ArmSmcArgs->Arg2 = ArmSmcArgs->Arg1; 638 break; 639 } 640 641 case TEESMC_OPTEE_RPC_FUNC_FREE_PAYLOAD: { 642 TeecResult = OpteeRpcFree(ArmSmcArgs->Arg1); 643 break; 644 } 645 646 default: { 647 printf("TEEC: ...unsupported RPC : Arg0=0x%X\n", ArmSmcArgs->Arg0); 648 TeecResult = TEEC_ERROR_NOT_IMPLEMENTED; 649 break; 650 } 651 } 652 653 ArmSmcArgs->Arg0 = TEESMC32_CALL_RETURN_FROM_RPC; 654 debug("TEEC: OpteeRpcCallback Exit : TeecResult=0x%X\n", TeecResult); 655 656 return TeecResult; 657 } 658