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