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 */
OpteeRpcAlloc(uint32_t Size,uint32_t * Address)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 */
OpteeRpcFree(uint32_t Address)51 TEEC_Result OpteeRpcFree(uint32_t Address)
52 {
53 OpteeClientMemFree((void *)(size_t)Address);
54 return TEEC_SUCCESS;
55 }
56
is_uuid_equal(TEE_UUID uuid1,TEEC_UUID uuid2)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 */
OpteeRpcCmdLoadTa(t_teesmc32_arg * TeeSmc32Arg)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
OpteeRpcCmdLoadV2Ta(t_teesmc32_arg * TeeSmc32Arg)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 */
OpteeRpcCmdFreeTa(t_teesmc32_arg * TeeSmc32Arg)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 #ifdef CONFIG_SUPPORT_EMMC_RPMB
OpteeRpcCmdRpmb(t_teesmc32_arg * TeeSmc32Arg)240 TEEC_Result OpteeRpcCmdRpmb(t_teesmc32_arg *TeeSmc32Arg)
241 {
242 struct tee_rpc_rpmb_dev_info *DevInfo;
243 TEEC_Result EfiStatus;
244 uint16_t RequestMsgType, i;
245 EFI_RK_RPMB_DATA_PACKET *RequestPackets;
246 EFI_RK_RPMB_DATA_PACKET *ResponsePackets;
247 EFI_RK_RPMB_DATA_PACKET *tempPackets;
248 EFI_RK_RPMB_DATA_PACKET_BACK *RequestPackets_back;
249 EFI_RK_RPMB_DATA_PACKET_BACK *tempPackets_back;
250 struct tee_rpc_rpmb_cmd *RpmbRequest;
251 TEEC_Result TeecResult = TEEC_SUCCESS;
252 t_teesmc32_param *TeeSmc32Param;
253 struct mmc *mmc;
254
255 debug("TEEC: Entered RPMB RPC\n");
256
257 if (TeeSmc32Arg->num_params != 2) {
258 TeecResult = TEEC_ERROR_BAD_PARAMETERS;
259 goto Exit;
260 }
261
262 TeeSmc32Param = TEESMC32_GET_PARAMS(TeeSmc32Arg);
263 RpmbRequest = (struct tee_rpc_rpmb_cmd *)(size_t)
264 TeeSmc32Param[0].u.memref.buf_ptr;
265 switch (RpmbRequest->cmd) {
266 case TEE_RPC_RPMB_CMD_DATA_REQ: {
267 RequestPackets = (EFI_RK_RPMB_DATA_PACKET *)(RpmbRequest + 1);
268 ResponsePackets = (EFI_RK_RPMB_DATA_PACKET *)(size_t)
269 TeeSmc32Param[1].u.memref.buf_ptr;
270
271 global_block_count =
272 (RpmbRequest->block_count == 0 ?
273 1 : RpmbRequest->block_count);
274 RequestPackets_back =
275 memalign(CONFIG_SYS_CACHELINE_SIZE,
276 sizeof(EFI_RK_RPMB_DATA_PACKET_BACK) * global_block_count);
277 memcpy(RequestPackets_back->stuff,
278 RequestPackets->stuff_bytes,
279 RPMB_STUFF_DATA_SIZE);
280 memcpy(RequestPackets_back->mac,
281 RequestPackets->key_mac,
282 RPMB_KEY_MAC_SIZE);
283 memcpy(RequestPackets_back->data,
284 RequestPackets->data,
285 RPMB_DATA_SIZE);
286 memcpy(RequestPackets_back->nonce,
287 RequestPackets->nonce,
288 RPMB_NONCE_SIZE);
289 RequestPackets_back->write_counter =
290 ((RequestPackets->write_counter[3]) << 24) +
291 ((RequestPackets->write_counter[2]) << 16) +
292 ((RequestPackets->write_counter[1]) << 8) +
293 (RequestPackets->write_counter[0]);
294 RequestPackets_back->address =
295 ((RequestPackets->address[1]) << 8) +
296 (RequestPackets->address[0]);
297 RequestPackets_back->block_count =
298 ((RequestPackets->block_count[1]) << 8) +
299 (RequestPackets->block_count[0]);
300 RequestPackets_back->result =
301 ((RequestPackets->op_result[1]) << 8) +
302 (RequestPackets->op_result[0]);
303 RequestPackets_back->request =
304 ((RequestPackets->msg_type[1]) << 8) +
305 (RequestPackets->msg_type[0]);
306
307 RequestMsgType = RPMB_PACKET_DATA_TO_UINT16(
308 RequestPackets->msg_type);
309
310 debug("TEEC: RPMB Data request %d\n", RequestMsgType);
311
312 switch (RequestMsgType) {
313 case TEE_RPC_RPMB_MSG_TYPE_REQ_AUTH_KEY_PROGRAM: {
314 if (init_rpmb() != 0) {
315 TeecResult = TEEC_ERROR_GENERIC;
316 break;
317 }
318
319 EfiStatus = do_programkey((struct s_rpmb *)
320 RequestPackets_back);
321
322 if (finish_rpmb() != 0) {
323 TeecResult = TEEC_ERROR_GENERIC;
324 break;
325 }
326
327 if (EfiStatus != 0) {
328 TeecResult = TEEC_ERROR_GENERIC;
329 break;
330 }
331
332 break;
333 }
334
335 case TEE_RPC_RPMB_MSG_TYPE_REQ_WRITE_COUNTER_VAL_READ: {
336 if (init_rpmb() != 0) {
337 TeecResult = TEEC_ERROR_GENERIC;
338 break;
339 }
340
341 EfiStatus = do_readcounter((struct s_rpmb *)
342 RequestPackets_back);
343
344 if (finish_rpmb() != 0) {
345 TeecResult = TEEC_ERROR_GENERIC;
346 break;
347 }
348
349 TeecResult = TEEC_SUCCESS;
350 break;
351 }
352
353 case TEE_RPC_RPMB_MSG_TYPE_REQ_AUTH_DATA_WRITE: {
354 if (init_rpmb() != 0) {
355 TeecResult = TEEC_ERROR_GENERIC;
356 break;
357 }
358
359 EfiStatus = do_authenticatedwrite((struct s_rpmb *)
360 RequestPackets_back);
361
362 if (finish_rpmb() != 0) {
363 TeecResult = TEEC_ERROR_GENERIC;
364 break;
365 }
366
367 if (EfiStatus != 0) {
368 TeecResult = TEEC_ERROR_GENERIC;
369 break;
370 }
371
372 break;
373 }
374
375 case TEE_RPC_RPMB_MSG_TYPE_REQ_AUTH_DATA_READ: {
376 if (init_rpmb() != 0) {
377 TeecResult = TEEC_ERROR_GENERIC;
378 break;
379 }
380
381 EfiStatus = do_authenticatedread((struct s_rpmb *)
382 RequestPackets_back, global_block_count);
383
384 if (finish_rpmb() != 0) {
385 TeecResult = TEEC_ERROR_GENERIC;
386 break;
387 }
388
389 if (EfiStatus != 0) {
390 TeecResult = TEEC_ERROR_GENERIC;
391 break;
392 }
393
394 break;
395 }
396
397 default:
398 TeecResult = TEEC_ERROR_BAD_PARAMETERS;
399 break;
400 }
401 debug("TEEC: RPMB TeecResult %d\n", TeecResult);
402 break;
403 }
404
405 case TEE_RPC_RPMB_CMD_GET_DEV_INFO: {
406 if (init_rpmb()) {
407 TeecResult = TEEC_ERROR_GENERIC;
408 goto Exit;
409 }
410
411 mmc = do_returnmmc();
412 if (finish_rpmb()) {
413 TeecResult = TEEC_ERROR_GENERIC;
414 goto Exit;
415 }
416
417 if (mmc == NULL) {
418 TeecResult = TEEC_ERROR_GENERIC;
419 goto Exit;
420 }
421
422 DevInfo = (struct tee_rpc_rpmb_dev_info *)(size_t)
423 TeeSmc32Param[1].u.memref.buf_ptr;
424
425 DevInfo->cid[0] = (mmc->cid[0]) >> 24 & 0xff;
426 DevInfo->cid[1] = (mmc->cid[0]) >> 16 & 0xff;
427 DevInfo->cid[2] = (mmc->cid[0]) >> 8 & 0xff;
428 DevInfo->cid[3] = (mmc->cid[0]) & 0xff;
429 DevInfo->cid[4] = (mmc->cid[1]) >> 24 & 0xff;
430 DevInfo->cid[5] = (mmc->cid[1]) >> 16 & 0xff;
431 DevInfo->cid[6] = (mmc->cid[1]) >> 8 & 0xff;
432 DevInfo->cid[7] = (mmc->cid[1]) & 0xff;
433 DevInfo->cid[8] = (mmc->cid[2]) >> 24 & 0xff;
434 DevInfo->cid[9] = (mmc->cid[2]) >> 16 & 0xff;
435 DevInfo->cid[10] = (mmc->cid[2]) >> 8 & 0xff;
436 DevInfo->cid[11] = (mmc->cid[2]) & 0xff;
437 DevInfo->cid[12] = (mmc->cid[3]) >> 24 & 0xff;
438 DevInfo->cid[13] = (mmc->cid[3]) >> 16 & 0xff;
439 DevInfo->cid[14] = (mmc->cid[3]) >> 8 & 0xff;
440 DevInfo->cid[15] = (mmc->cid[3]) & 0xff;
441 DevInfo->rel_wr_sec_c = 1;
442 DevInfo->rpmb_size_mult =
443 (uint8_t)(mmc->capacity_rpmb / (128 * 1024));
444 DevInfo->ret_code = 0;
445
446 goto Exit;
447 }
448
449 default:
450 TeecResult = TEEC_ERROR_BAD_PARAMETERS;
451
452 goto Exit;
453 }
454
455 tempPackets = ResponsePackets;
456 tempPackets_back = RequestPackets_back;
457
458 for (i = 0; i < global_block_count; i++) {
459 memcpy(tempPackets->stuff_bytes,
460 tempPackets_back->stuff,
461 RPMB_STUFF_DATA_SIZE);
462 memcpy(tempPackets->key_mac,
463 tempPackets_back->mac,
464 RPMB_KEY_MAC_SIZE);
465 memcpy(tempPackets->data,
466 tempPackets_back->data,
467 RPMB_DATA_SIZE);
468 memcpy(tempPackets->nonce,
469 tempPackets_back->nonce,
470 RPMB_NONCE_SIZE);
471 tempPackets->write_counter[3] =
472 ((tempPackets_back->write_counter) >> 24) & 0xFF;
473 tempPackets->write_counter[2] =
474 ((tempPackets_back->write_counter) >> 16) & 0xFF;
475 tempPackets->write_counter[1] =
476 ((tempPackets_back->write_counter) >> 8) & 0xFF;
477 tempPackets->write_counter[0] =
478 (tempPackets_back->write_counter) & 0xFF;
479 tempPackets->address[1] =
480 ((tempPackets_back->address) >> 8) & 0xFF;
481 tempPackets->address[0] =
482 (tempPackets_back->address) & 0xFF;
483 tempPackets->block_count[1] =
484 ((tempPackets_back->block_count) >> 8) & 0xFF;
485 tempPackets->block_count[0] =
486 (tempPackets_back->block_count) & 0xFF;
487 tempPackets->op_result[1] =
488 ((tempPackets_back->result) >> 8) & 0xFF;
489 tempPackets->op_result[0] =
490 (tempPackets_back->result) & 0xFF;
491 tempPackets->msg_type[1] =
492 ((tempPackets_back->request) >> 8) & 0xFF;
493 tempPackets->msg_type[0] =
494 (tempPackets_back->request) & 0xFF;
495 tempPackets++;
496 tempPackets_back++;
497 }
498
499 free(RequestPackets_back);
500
501 Exit:
502 TeeSmc32Arg->ret = TeecResult;
503 TeeSmc32Arg->ret_origin = TEEC_ORIGIN_API;
504
505 return TeecResult;
506 }
507 #endif
508
509 /*
510 * Execute a normal world local file system operation.
511 */
OpteeRpcCmdFs(t_teesmc32_arg * TeeSmc32Arg)512 TEEC_Result OpteeRpcCmdFs(t_teesmc32_arg *TeeSmc32Arg)
513 {
514 TEEC_Result TeecResult = TEEC_SUCCESS;
515 t_teesmc32_param *TeeSmc32Param;
516
517 TeeSmc32Param = TEESMC32_GET_PARAMS(TeeSmc32Arg);
518 #ifdef CONFIG_OPTEE_V1
519 TeecResult = OpteeClientRkFsProcess((void *)(size_t)TeeSmc32Param[0].u.memref.buf_ptr,
520 TeeSmc32Param[0].u.memref.size);
521 TeeSmc32Arg->ret = TEEC_SUCCESS;
522 #endif
523 #ifdef CONFIG_OPTEE_V2
524 TeecResult = OpteeClientRkFsProcess((size_t)TeeSmc32Arg->num_params,
525 (struct tee_ioctl_param *)TeeSmc32Param);
526 TeeSmc32Arg->ret = TeecResult;
527 #endif
528 return TeecResult;
529 }
530
531 /*
532 * TBD.
533 */
OpteeRpcCmdGetTime(t_teesmc32_arg * TeeSmc32Arg)534 TEEC_Result OpteeRpcCmdGetTime(t_teesmc32_arg *TeeSmc32Arg)
535 {
536 return TEEC_ERROR_NOT_IMPLEMENTED;
537 }
538
539 /*
540 * TBD.
541 */
OpteeRpcCmdWaitMutex(t_teesmc32_arg * TeeSmc32Arg)542 TEEC_Result OpteeRpcCmdWaitMutex(t_teesmc32_arg *TeeSmc32Arg)
543 {
544 return TEEC_ERROR_NOT_IMPLEMENTED;
545 }
546
547 /*
548 * Handle the callback from secure world.
549 */
OpteeRpcCallback(ARM_SMC_ARGS * ArmSmcArgs)550 TEEC_Result OpteeRpcCallback(ARM_SMC_ARGS *ArmSmcArgs)
551 {
552 TEEC_Result TeecResult = TEEC_SUCCESS;
553
554 //printf("OpteeRpcCallback Enter: Arg0=0x%X, Arg1=0x%X, Arg2=0x%X\n",
555 //ArmSmcArgs->Arg0, ArmSmcArgs->Arg1, ArmSmcArgs->Arg2);
556
557 switch (TEESMC_RETURN_GET_RPC_FUNC(ArmSmcArgs->Arg0)) {
558 case TEESMC_RPC_FUNC_ALLOC_ARG: {
559 debug("TEEC: ArmSmcArgs->Arg1 = 0x%x \n", ArmSmcArgs->Arg1);
560 TeecResult = OpteeRpcAlloc(ArmSmcArgs->Arg1, &ArmSmcArgs->Arg2);
561 ArmSmcArgs->Arg5 = ArmSmcArgs->Arg2;
562 ArmSmcArgs->Arg1 = 0;
563 ArmSmcArgs->Arg4 = 0;
564 break;
565 }
566
567 case TEESMC_RPC_FUNC_ALLOC_PAYLOAD: {
568 TeecResult = OpteeRpcAlloc(ArmSmcArgs->Arg1, &ArmSmcArgs->Arg1);
569 break;
570 }
571
572 case TEESMC_RPC_FUNC_FREE_ARG: {
573 TeecResult = OpteeRpcFree(ArmSmcArgs->Arg2);
574 break;
575 }
576
577 case TEESMC_RPC_FUNC_FREE_PAYLOAD: {
578 TeecResult = OpteeRpcFree(ArmSmcArgs->Arg1);
579 break;
580 }
581
582 case TEESMC_RPC_FUNC_IRQ: {
583 break;
584 }
585
586 case TEESMC_RPC_FUNC_CMD: {
587 t_teesmc32_arg *TeeSmc32Arg =
588 (t_teesmc32_arg *)(size_t)((uint64_t)ArmSmcArgs->Arg1 << 32 | ArmSmcArgs->Arg2);
589 debug("TEEC: TeeSmc32Arg->cmd = 0x%x\n", TeeSmc32Arg->cmd);
590 switch (TeeSmc32Arg->cmd) {
591 case OPTEE_MSG_RPC_CMD_SHM_ALLOC_V2: {
592 uint32_t tempaddr;
593 uint32_t allocsize = TeeSmc32Arg->params[0].u.value.b;
594 TeecResult = OpteeRpcAlloc(allocsize, &tempaddr);
595 debug("TEEC: allocsize = 0x%x tempaddr = 0x%x\n", allocsize, tempaddr);
596 TeeSmc32Arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT_V2;
597 TeeSmc32Arg->params[0].u.memref.buf_ptr = tempaddr;
598 TeeSmc32Arg->params[0].u.memref.size = allocsize;
599 TeeSmc32Arg->params[0].u.memref.shm_ref = tempaddr;
600 TeeSmc32Arg->ret = TEE_SUCCESS;
601 break;
602 }
603 case OPTEE_MSG_RPC_CMD_SHM_FREE_V2: {
604 uint32_t tempaddr = TeeSmc32Arg->params[0].u.value.b;
605 TeecResult = OpteeRpcFree(tempaddr);
606 break;
607
608 }
609 #ifdef CONFIG_SUPPORT_EMMC_RPMB
610 case OPTEE_MSG_RPC_CMD_RPMB_V2: {
611 TeecResult = OpteeRpcCmdRpmb(TeeSmc32Arg);
612 break;
613 }
614 #endif
615 case OPTEE_MSG_RPC_CMD_FS_V2: {
616 TeecResult = OpteeRpcCmdFs(TeeSmc32Arg);
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