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 8 #include <common.h> 9 #include <optee_include/OpteeClientApiLib.h> 10 #include <optee_include/tee_client_api.h> 11 12 void test_optee(void) 13 { 14 TEEC_Result TeecResult; 15 TEEC_Context TeecContext; 16 TEEC_Session TeecSession; 17 uint32_t ErrorOrigin; 18 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 19 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 20 TEEC_UUID *TeecUuid = &tempuuid; 21 TEEC_Operation TeecOperation = {0}; 22 23 debug("testmm start\n"); 24 OpteeClientApiLibInitialize(); 25 26 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 27 28 TeecResult = TEEC_OpenSession(&TeecContext, 29 &TeecSession, 30 TeecUuid, 31 TEEC_LOGIN_PUBLIC, 32 NULL, 33 NULL, 34 &ErrorOrigin); 35 36 TEEC_SharedMemory SharedMem0 = {0}; 37 38 SharedMem0.size = sizeof("filename_test"); 39 SharedMem0.flags = 0; 40 41 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 42 43 memcpy(SharedMem0.buffer, "filename_test", SharedMem0.size); 44 45 TEEC_SharedMemory SharedMem1 = {0}; 46 47 SharedMem1.size = 32; 48 SharedMem1.flags = 0; 49 50 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 51 52 memset(SharedMem1.buffer, 'a', SharedMem1.size); 53 54 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 55 TeecOperation.params[0].tmpref.size = SharedMem0.size; 56 57 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 58 TeecOperation.params[1].tmpref.size = SharedMem1.size; 59 60 61 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 62 TEEC_MEMREF_TEMP_INOUT, 63 TEEC_NONE, 64 TEEC_NONE); 65 66 TeecResult = TEEC_InvokeCommand(&TeecSession, 67 1, 68 &TeecOperation, 69 &ErrorOrigin); 70 71 TEEC_ReleaseSharedMemory(&SharedMem0); 72 TEEC_ReleaseSharedMemory(&SharedMem1); 73 74 TEEC_CloseSession(&TeecSession); 75 76 TEEC_FinalizeContext(&TeecContext); 77 78 debug("testmm end\n"); 79 debug("TeecResult %x\n", TeecResult); 80 } 81 82 static uint8_t b2hs_add_base(uint8_t in) 83 { 84 if (in > 9) 85 return in + 55; 86 else 87 return in + 48; 88 } 89 90 uint32_t b2hs(uint8_t *b, uint8_t *hs, uint32_t blen, uint32_t hslen) 91 { 92 uint32_t i = 0; 93 94 if (blen * 2 + 1 > hslen) 95 return 0; 96 97 for (; i < blen; i++) { 98 hs[i * 2 + 1] = b2hs_add_base(b[i] & 0xf); 99 hs[i * 2] = b2hs_add_base(b[i] >> 4); 100 } 101 hs[blen * 2] = 0; 102 103 return blen * 2; 104 } 105 106 107 uint32_t trusty_read_rollback_index(uint32_t slot, uint64_t *value) 108 { 109 TEEC_Result TeecResult; 110 TEEC_Context TeecContext; 111 TEEC_Session TeecSession; 112 uint32_t ErrorOrigin; 113 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 114 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 115 TEEC_UUID *TeecUuid = &tempuuid; 116 TEEC_Operation TeecOperation = {0}; 117 uint8_t hs[9]; 118 119 b2hs((uint8_t *)&slot, hs, 4, 9); 120 debug("testmm start\n"); 121 OpteeClientApiLibInitialize(); 122 123 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 124 125 TeecResult = TEEC_OpenSession(&TeecContext, 126 &TeecSession, 127 TeecUuid, 128 TEEC_LOGIN_PUBLIC, 129 NULL, 130 NULL, 131 &ErrorOrigin); 132 133 TEEC_SharedMemory SharedMem0 = {0}; 134 135 SharedMem0.size = 8; 136 SharedMem0.flags = 0; 137 138 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 139 140 memcpy(SharedMem0.buffer, hs, SharedMem0.size); 141 142 TEEC_SharedMemory SharedMem1 = {0}; 143 144 SharedMem1.size = 8; 145 SharedMem1.flags = 0; 146 147 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 148 149 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 150 TeecOperation.params[0].tmpref.size = SharedMem0.size; 151 152 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 153 TeecOperation.params[1].tmpref.size = SharedMem1.size; 154 155 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 156 TEEC_MEMREF_TEMP_INOUT, 157 TEEC_NONE, 158 TEEC_NONE); 159 160 TeecResult = TEEC_InvokeCommand(&TeecSession, 161 0, 162 &TeecOperation, 163 &ErrorOrigin); 164 if (TeecResult == TEEC_SUCCESS) 165 memcpy((char *)value, SharedMem1.buffer, SharedMem1.size); 166 167 TEEC_ReleaseSharedMemory(&SharedMem0); 168 TEEC_ReleaseSharedMemory(&SharedMem1); 169 170 TEEC_CloseSession(&TeecSession); 171 172 TEEC_FinalizeContext(&TeecContext); 173 174 debug("testmm end\n"); 175 return TeecResult; 176 } 177 178 uint32_t trusty_write_rollback_index(uint32_t slot, uint64_t value) 179 { 180 TEEC_Result TeecResult; 181 TEEC_Context TeecContext; 182 TEEC_Session TeecSession; 183 uint32_t ErrorOrigin; 184 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 185 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 186 TEEC_UUID *TeecUuid = &tempuuid; 187 TEEC_Operation TeecOperation = {0}; 188 uint8_t hs[9]; 189 b2hs((uint8_t *)&slot, hs, 4, 9); 190 OpteeClientApiLibInitialize(); 191 192 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 193 194 TeecResult = TEEC_OpenSession(&TeecContext, 195 &TeecSession, 196 TeecUuid, 197 TEEC_LOGIN_PUBLIC, 198 NULL, 199 NULL, 200 &ErrorOrigin); 201 202 TEEC_SharedMemory SharedMem0 = {0}; 203 204 SharedMem0.size = 8; 205 SharedMem0.flags = 0; 206 207 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 208 209 memcpy(SharedMem0.buffer, hs, SharedMem0.size); 210 211 TEEC_SharedMemory SharedMem1 = {0}; 212 213 SharedMem1.size = 8; 214 SharedMem1.flags = 0; 215 216 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 217 218 memcpy(SharedMem1.buffer, (char *)&value, SharedMem1.size); 219 220 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 221 TeecOperation.params[0].tmpref.size = SharedMem0.size; 222 223 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 224 TeecOperation.params[1].tmpref.size = SharedMem1.size; 225 226 227 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 228 TEEC_MEMREF_TEMP_INOUT, 229 TEEC_NONE, 230 TEEC_NONE); 231 232 TeecResult = TEEC_InvokeCommand(&TeecSession, 233 1, 234 &TeecOperation, 235 &ErrorOrigin); 236 237 TEEC_ReleaseSharedMemory(&SharedMem0); 238 TEEC_ReleaseSharedMemory(&SharedMem1); 239 240 TEEC_CloseSession(&TeecSession); 241 242 TEEC_FinalizeContext(&TeecContext); 243 244 debug("testmm end\n"); 245 246 return TeecResult; 247 } 248 249 uint32_t trusty_read_permanent_attributes(uint8_t *attributes, uint32_t size) 250 { 251 TEEC_Result TeecResult; 252 TEEC_Context TeecContext; 253 TEEC_Session TeecSession; 254 uint32_t ErrorOrigin; 255 TEEC_UUID tempuuid = { 0x258be795, 0xf9ca, 0x40e6, 256 { 0xa8, 0x69, 0x9c, 0xe6, 0x88, 0x6c, 0x5d, 0x5d } }; 257 TEEC_UUID *TeecUuid = &tempuuid; 258 TEEC_Operation TeecOperation = {0}; 259 260 debug("testmm start\n"); 261 OpteeClientApiLibInitialize(); 262 263 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 264 265 TeecResult = TEEC_OpenSession(&TeecContext, 266 &TeecSession, 267 TeecUuid, 268 TEEC_LOGIN_PUBLIC, 269 NULL, 270 NULL, 271 &ErrorOrigin); 272 273 TEEC_SharedMemory SharedMem0 = {0}; 274 275 SharedMem0.size = sizeof("attributes"); 276 SharedMem0.flags = 0; 277 278 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 279 280 memcpy(SharedMem0.buffer, "attributes", SharedMem0.size); 281 282 TEEC_SharedMemory SharedMem1 = {0}; 283 284 SharedMem1.size = size; 285 SharedMem1.flags = 0; 286 287 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 288 289 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 290 TeecOperation.params[0].tmpref.size = SharedMem0.size; 291 292 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 293 TeecOperation.params[1].tmpref.size = SharedMem1.size; 294 295 296 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 297 TEEC_MEMREF_TEMP_INOUT, 298 TEEC_NONE, 299 TEEC_NONE); 300 301 TeecResult = TEEC_InvokeCommand(&TeecSession, 302 142, 303 &TeecOperation, 304 &ErrorOrigin); 305 if (TeecResult == TEEC_SUCCESS) 306 memcpy(attributes, SharedMem1.buffer, SharedMem1.size); 307 TEEC_ReleaseSharedMemory(&SharedMem0); 308 TEEC_ReleaseSharedMemory(&SharedMem1); 309 TEEC_CloseSession(&TeecSession); 310 TEEC_FinalizeContext(&TeecContext); 311 debug("testmm end\n"); 312 313 return TeecResult; 314 } 315 316 uint32_t trusty_write_permanent_attributes(uint8_t *attributes, uint32_t size) 317 { 318 TEEC_Result TeecResult; 319 TEEC_Context TeecContext; 320 TEEC_Session TeecSession; 321 uint32_t ErrorOrigin; 322 TEEC_UUID tempuuid = { 0x258be795, 0xf9ca, 0x40e6, 323 { 0xa8, 0x69, 0x9c, 0xe6, 0x88, 0x6c, 0x5d, 0x5d } }; 324 TEEC_UUID *TeecUuid = &tempuuid; 325 TEEC_Operation TeecOperation = {0}; 326 327 debug("testmm start\n"); 328 OpteeClientApiLibInitialize(); 329 330 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 331 332 TeecResult = TEEC_OpenSession(&TeecContext, 333 &TeecSession, 334 TeecUuid, 335 TEEC_LOGIN_PUBLIC, 336 NULL, 337 NULL, 338 &ErrorOrigin); 339 340 TEEC_SharedMemory SharedMem0 = {0}; 341 342 SharedMem0.size = sizeof("attributes"); 343 SharedMem0.flags = 0; 344 345 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 346 347 memcpy(SharedMem0.buffer, "attributes", SharedMem0.size); 348 349 TEEC_SharedMemory SharedMem1 = {0}; 350 351 SharedMem1.size = size; 352 SharedMem1.flags = 0; 353 354 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 355 356 memcpy(SharedMem1.buffer, attributes, SharedMem1.size); 357 358 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 359 TeecOperation.params[0].tmpref.size = SharedMem0.size; 360 361 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 362 TeecOperation.params[1].tmpref.size = SharedMem1.size; 363 364 365 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 366 TEEC_MEMREF_TEMP_INOUT, 367 TEEC_NONE, 368 TEEC_NONE); 369 370 TeecResult = TEEC_InvokeCommand(&TeecSession, 371 141, 372 &TeecOperation, 373 &ErrorOrigin); 374 375 TEEC_ReleaseSharedMemory(&SharedMem0); 376 TEEC_ReleaseSharedMemory(&SharedMem1); 377 TEEC_CloseSession(&TeecSession); 378 TEEC_FinalizeContext(&TeecContext); 379 debug("testmm end\n"); 380 381 return TeecResult; 382 } 383 384 uint32_t trusty_read_lock_state(uint8_t *lock_state) 385 { 386 TEEC_Result TeecResult; 387 TEEC_Context TeecContext; 388 TEEC_Session TeecSession; 389 uint32_t ErrorOrigin; 390 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 391 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 392 TEEC_UUID *TeecUuid = &tempuuid; 393 TEEC_Operation TeecOperation = {0}; 394 395 debug("testmm start\n"); 396 OpteeClientApiLibInitialize(); 397 398 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 399 400 401 TeecResult = TEEC_OpenSession(&TeecContext, 402 &TeecSession, 403 TeecUuid, 404 TEEC_LOGIN_PUBLIC, 405 NULL, 406 NULL, 407 &ErrorOrigin); 408 409 TEEC_SharedMemory SharedMem0 = {0}; 410 411 SharedMem0.size = sizeof("lock_state"); 412 SharedMem0.flags = 0; 413 414 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 415 416 memcpy(SharedMem0.buffer, "lock_state", SharedMem0.size); 417 418 TEEC_SharedMemory SharedMem1 = {0}; 419 420 SharedMem1.size = 1; 421 SharedMem1.flags = 0; 422 423 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 424 425 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 426 TeecOperation.params[0].tmpref.size = SharedMem0.size; 427 428 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 429 TeecOperation.params[1].tmpref.size = SharedMem1.size; 430 431 432 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 433 TEEC_MEMREF_TEMP_INOUT, 434 TEEC_NONE, 435 TEEC_NONE); 436 437 TeecResult = TEEC_InvokeCommand(&TeecSession, 438 0, 439 &TeecOperation, 440 &ErrorOrigin); 441 if (TeecResult == TEEC_SUCCESS) 442 memcpy(lock_state, SharedMem1.buffer, SharedMem1.size); 443 TEEC_ReleaseSharedMemory(&SharedMem0); 444 TEEC_ReleaseSharedMemory(&SharedMem1); 445 TEEC_CloseSession(&TeecSession); 446 TEEC_FinalizeContext(&TeecContext); 447 debug("testmm end\n"); 448 449 return TeecResult; 450 } 451 452 uint32_t trusty_write_lock_state(uint8_t lock_state) 453 { 454 TEEC_Result TeecResult; 455 TEEC_Context TeecContext; 456 TEEC_Session TeecSession; 457 uint32_t ErrorOrigin; 458 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 459 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 460 TEEC_UUID *TeecUuid = &tempuuid; 461 TEEC_Operation TeecOperation = {0}; 462 463 debug("testmm start\n"); 464 OpteeClientApiLibInitialize(); 465 466 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 467 468 TeecResult = TEEC_OpenSession(&TeecContext, 469 &TeecSession, 470 TeecUuid, 471 TEEC_LOGIN_PUBLIC, 472 NULL, 473 NULL, 474 &ErrorOrigin); 475 476 TEEC_SharedMemory SharedMem0 = {0}; 477 478 SharedMem0.size = sizeof("lock_state"); 479 SharedMem0.flags = 0; 480 481 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 482 483 memcpy(SharedMem0.buffer, "lock_state", SharedMem0.size); 484 485 TEEC_SharedMemory SharedMem1 = {0}; 486 487 SharedMem1.size = 1; 488 SharedMem1.flags = 0; 489 490 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 491 492 memcpy(SharedMem1.buffer, &lock_state, SharedMem1.size); 493 494 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 495 TeecOperation.params[0].tmpref.size = SharedMem0.size; 496 497 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 498 TeecOperation.params[1].tmpref.size = SharedMem1.size; 499 500 501 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 502 TEEC_MEMREF_TEMP_INOUT, 503 TEEC_NONE, 504 TEEC_NONE); 505 506 TeecResult = TEEC_InvokeCommand(&TeecSession, 507 1, 508 &TeecOperation, 509 &ErrorOrigin); 510 511 TEEC_ReleaseSharedMemory(&SharedMem0); 512 TEEC_ReleaseSharedMemory(&SharedMem1); 513 TEEC_CloseSession(&TeecSession); 514 TEEC_FinalizeContext(&TeecContext); 515 debug("testmm end\n"); 516 517 return TeecResult; 518 } 519 520 uint32_t trusty_read_flash_lock_state(uint8_t *flash_lock_state) 521 { 522 TEEC_Result TeecResult; 523 TEEC_Context TeecContext; 524 TEEC_Session TeecSession; 525 uint32_t ErrorOrigin; 526 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 527 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 528 TEEC_UUID *TeecUuid = &tempuuid; 529 TEEC_Operation TeecOperation = {0}; 530 531 debug("testmm start\n"); 532 OpteeClientApiLibInitialize(); 533 534 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 535 536 537 TeecResult = TEEC_OpenSession(&TeecContext, 538 &TeecSession, 539 TeecUuid, 540 TEEC_LOGIN_PUBLIC, 541 NULL, 542 NULL, 543 &ErrorOrigin); 544 545 TEEC_SharedMemory SharedMem0 = {0}; 546 547 SharedMem0.size = sizeof("flash_lock_state"); 548 SharedMem0.flags = 0; 549 550 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 551 552 memcpy(SharedMem0.buffer, "flash_lock_state", SharedMem0.size); 553 554 TEEC_SharedMemory SharedMem1 = {0}; 555 556 SharedMem1.size = 1; 557 SharedMem1.flags = 0; 558 559 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 560 561 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 562 TeecOperation.params[0].tmpref.size = SharedMem0.size; 563 564 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 565 TeecOperation.params[1].tmpref.size = SharedMem1.size; 566 567 568 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 569 TEEC_MEMREF_TEMP_INOUT, 570 TEEC_NONE, 571 TEEC_NONE); 572 573 TeecResult = TEEC_InvokeCommand(&TeecSession, 574 0, 575 &TeecOperation, 576 &ErrorOrigin); 577 if (TeecResult == TEEC_SUCCESS) 578 memcpy(flash_lock_state, SharedMem1.buffer, SharedMem1.size); 579 TEEC_ReleaseSharedMemory(&SharedMem0); 580 TEEC_ReleaseSharedMemory(&SharedMem1); 581 TEEC_CloseSession(&TeecSession); 582 TEEC_FinalizeContext(&TeecContext); 583 debug("testmm end\n"); 584 585 return TeecResult; 586 } 587 588 589 uint32_t trusty_write_flash_lock_state(uint8_t flash_lock_state) 590 { 591 TEEC_Result TeecResult; 592 TEEC_Context TeecContext; 593 TEEC_Session TeecSession; 594 uint32_t ErrorOrigin; 595 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 596 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 597 TEEC_UUID *TeecUuid = &tempuuid; 598 TEEC_Operation TeecOperation = {0}; 599 600 debug("testmm start\n"); 601 OpteeClientApiLibInitialize(); 602 603 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 604 605 TeecResult = TEEC_OpenSession(&TeecContext, 606 &TeecSession, 607 TeecUuid, 608 TEEC_LOGIN_PUBLIC, 609 NULL, 610 NULL, 611 &ErrorOrigin); 612 613 TEEC_SharedMemory SharedMem0 = {0}; 614 615 SharedMem0.size = sizeof("flash_lock_state"); 616 SharedMem0.flags = 0; 617 618 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 619 620 memcpy(SharedMem0.buffer, "flash_lock_state", SharedMem0.size); 621 622 TEEC_SharedMemory SharedMem1 = {0}; 623 624 SharedMem1.size = 1; 625 SharedMem1.flags = 0; 626 627 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 628 629 memcpy(SharedMem1.buffer, &flash_lock_state, SharedMem1.size); 630 631 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 632 TeecOperation.params[0].tmpref.size = SharedMem0.size; 633 634 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 635 TeecOperation.params[1].tmpref.size = SharedMem1.size; 636 637 638 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 639 TEEC_MEMREF_TEMP_INOUT, 640 TEEC_NONE, 641 TEEC_NONE); 642 643 TeecResult = TEEC_InvokeCommand(&TeecSession, 644 1, 645 &TeecOperation, 646 &ErrorOrigin); 647 648 TEEC_ReleaseSharedMemory(&SharedMem0); 649 TEEC_ReleaseSharedMemory(&SharedMem1); 650 TEEC_CloseSession(&TeecSession); 651 TEEC_FinalizeContext(&TeecContext); 652 debug("testmm end\n"); 653 654 return TeecResult; 655 } 656 657 uint32_t write_to_keymaster(uint8_t *filename, 658 uint32_t filename_size, 659 uint8_t *data, 660 uint32_t data_size) 661 { 662 TEEC_Result TeecResult; 663 TEEC_Context TeecContext; 664 TEEC_Session TeecSession; 665 uint32_t ErrorOrigin; 666 667 TEEC_UUID tempuuid = { 0x258be795, 0xf9ca, 0x40e6, 668 { 0xa8, 0x69, 0x9c, 0xe6, 0x88, 0x6c, 0x5d, 0x5d } }; 669 TEEC_UUID *TeecUuid = &tempuuid; 670 TEEC_Operation TeecOperation = {0}; 671 672 debug("write_to_keymaster\n"); 673 OpteeClientApiLibInitialize(); 674 675 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 676 677 TeecResult = TEEC_OpenSession(&TeecContext, 678 &TeecSession, 679 TeecUuid, 680 TEEC_LOGIN_PUBLIC, 681 NULL, 682 NULL, 683 &ErrorOrigin); 684 685 TEEC_SharedMemory SharedMem0 = {0}; 686 687 SharedMem0.size = filename_size; 688 SharedMem0.flags = 0; 689 690 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 691 692 memcpy(SharedMem0.buffer, filename, SharedMem0.size); 693 694 TEEC_SharedMemory SharedMem1 = {0}; 695 696 SharedMem1.size = data_size; 697 SharedMem1.flags = 0; 698 699 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 700 701 memcpy(SharedMem1.buffer, data, SharedMem1.size); 702 703 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 704 TeecOperation.params[0].tmpref.size = SharedMem0.size; 705 706 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 707 TeecOperation.params[1].tmpref.size = SharedMem1.size; 708 709 710 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 711 TEEC_MEMREF_TEMP_INOUT, 712 TEEC_NONE, 713 TEEC_NONE); 714 715 TeecResult = TEEC_InvokeCommand(&TeecSession, 716 139, 717 &TeecOperation, 718 &ErrorOrigin); 719 720 TEEC_ReleaseSharedMemory(&SharedMem0); 721 TEEC_ReleaseSharedMemory(&SharedMem1); 722 TEEC_CloseSession(&TeecSession); 723 TEEC_FinalizeContext(&TeecContext); 724 debug("testmm end\n"); 725 debug("TeecResult %x\n", TeecResult); 726 727 return TeecResult; 728 } 729 730 uint32_t trusty_read_attribute_hash(uint32_t *buf, uint32_t length) 731 { 732 TEEC_Result TeecResult; 733 TEEC_Context TeecContext; 734 TEEC_Session TeecSession; 735 uint32_t ErrorOrigin; 736 737 TEEC_UUID tempuuid = { 0x2d26d8a8, 0x5134, 0x4dd8, \ 738 { 0xb3, 0x2f, 0xb3, 0x4b, 0xce, 0xeb, 0xc4, 0x71 } }; 739 TEEC_UUID *TeecUuid = &tempuuid; 740 TEEC_Operation TeecOperation = {0}; 741 742 OpteeClientApiLibInitialize(); 743 744 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 745 746 TeecResult = TEEC_OpenSession(&TeecContext, 747 &TeecSession, 748 TeecUuid, 749 TEEC_LOGIN_PUBLIC, 750 NULL, 751 NULL, 752 &ErrorOrigin); 753 754 TEEC_SharedMemory SharedMem0 = {0}; 755 756 SharedMem0.size = length * sizeof(uint32_t); 757 SharedMem0.flags = 0; 758 759 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 760 761 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 762 TeecOperation.params[0].tmpref.size = SharedMem0.size; 763 764 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_OUTPUT, 765 TEEC_NONE, 766 TEEC_NONE, 767 TEEC_NONE); 768 769 TeecResult = TEEC_InvokeCommand(&TeecSession, 770 0, 771 &TeecOperation, 772 &ErrorOrigin); 773 774 if (TeecResult == TEEC_SUCCESS) 775 memcpy(buf, SharedMem0.buffer, SharedMem0.size); 776 777 TEEC_ReleaseSharedMemory(&SharedMem0); 778 TEEC_CloseSession(&TeecSession); 779 TEEC_FinalizeContext(&TeecContext); 780 781 return TeecResult; 782 } 783 784 uint32_t trusty_write_attribute_hash(uint32_t *buf, uint32_t length) 785 { 786 TEEC_Result TeecResult; 787 TEEC_Context TeecContext; 788 TEEC_Session TeecSession; 789 uint32_t ErrorOrigin; 790 791 TEEC_UUID tempuuid = { 0x2d26d8a8, 0x5134, 0x4dd8, \ 792 { 0xb3, 0x2f, 0xb3, 0x4b, 0xce, 0xeb, 0xc4, 0x71 } }; 793 TEEC_UUID *TeecUuid = &tempuuid; 794 TEEC_Operation TeecOperation = {0}; 795 796 OpteeClientApiLibInitialize(); 797 798 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 799 800 TeecResult = TEEC_OpenSession(&TeecContext, 801 &TeecSession, 802 TeecUuid, 803 TEEC_LOGIN_PUBLIC, 804 NULL, 805 NULL, 806 &ErrorOrigin); 807 808 TEEC_SharedMemory SharedMem0 = {0}; 809 810 SharedMem0.size = length * sizeof(uint32_t); 811 SharedMem0.flags = 0; 812 813 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 814 815 memcpy(SharedMem0.buffer, buf, SharedMem0.size); 816 817 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 818 TeecOperation.params[0].tmpref.size = SharedMem0.size; 819 820 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 821 TEEC_NONE, 822 TEEC_NONE, 823 TEEC_NONE); 824 825 TeecResult = TEEC_InvokeCommand(&TeecSession, 826 1, 827 &TeecOperation, 828 &ErrorOrigin); 829 830 TEEC_ReleaseSharedMemory(&SharedMem0); 831 TEEC_CloseSession(&TeecSession); 832 TEEC_FinalizeContext(&TeecContext); 833 834 return TeecResult; 835 } 836 837 uint32_t notify_optee_rpmb_ta(void) 838 { 839 TEEC_Result TeecResult; 840 TEEC_Context TeecContext; 841 TEEC_Session TeecSession; 842 uint32_t ErrorOrigin; 843 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 844 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 845 TEEC_UUID *TeecUuid = &tempuuid; 846 TEEC_Operation TeecOperation = {0}; 847 848 OpteeClientApiLibInitialize(); 849 850 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 851 852 TeecResult = TEEC_OpenSession(&TeecContext, 853 &TeecSession, 854 TeecUuid, 855 TEEC_LOGIN_PUBLIC, 856 NULL, 857 NULL, 858 &ErrorOrigin); 859 860 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, 861 TEEC_NONE, 862 TEEC_NONE, 863 TEEC_NONE); 864 865 TeecResult = TEEC_InvokeCommand(&TeecSession, 866 2, 867 &TeecOperation, 868 &ErrorOrigin); 869 870 TEEC_CloseSession(&TeecSession); 871 TEEC_FinalizeContext(&TeecContext); 872 873 return TeecResult; 874 } 875 876 uint32_t notify_optee_efuse_ta(void) 877 { 878 TEEC_Result TeecResult; 879 TEEC_Context TeecContext; 880 TEEC_Session TeecSession; 881 uint32_t ErrorOrigin; 882 TEEC_UUID tempuuid = { 0x2d26d8a8, 0x5134, 0x4dd8, \ 883 { 0xb3, 0x2f, 0xb3, 0x4b, 0xce, 0xeb, 0xc4, 0x71 } }; 884 885 TEEC_UUID *TeecUuid = &tempuuid; 886 TEEC_Operation TeecOperation = {0}; 887 888 OpteeClientApiLibInitialize(); 889 890 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 891 892 TeecResult = TEEC_OpenSession(&TeecContext, 893 &TeecSession, 894 TeecUuid, 895 TEEC_LOGIN_PUBLIC, 896 NULL, 897 NULL, 898 &ErrorOrigin); 899 900 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, 901 TEEC_NONE, 902 TEEC_NONE, 903 TEEC_NONE); 904 905 TeecResult = TEEC_InvokeCommand(&TeecSession, 906 2, 907 &TeecOperation, 908 &ErrorOrigin); 909 910 TEEC_CloseSession(&TeecSession); 911 TEEC_FinalizeContext(&TeecContext); 912 913 return TeecResult; 914 } 915 916 uint32_t trusty_notify_optee_uboot_end(void) 917 { 918 TEEC_Result res; 919 res = notify_optee_rpmb_ta(); 920 res |= notify_optee_efuse_ta(); 921 return res; 922 } 923 924 uint32_t trusty_read_vbootkey_hash(uint32_t *buf, uint32_t length) 925 { 926 TEEC_Result TeecResult; 927 TEEC_Context TeecContext; 928 TEEC_Session TeecSession; 929 uint32_t ErrorOrigin; 930 931 TEEC_UUID tempuuid = { 0x2d26d8a8, 0x5134, 0x4dd8, \ 932 { 0xb3, 0x2f, 0xb3, 0x4b, 0xce, 0xeb, 0xc4, 0x71 } }; 933 TEEC_UUID *TeecUuid = &tempuuid; 934 TEEC_Operation TeecOperation = {0}; 935 936 OpteeClientApiLibInitialize(); 937 938 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 939 940 TeecResult = TEEC_OpenSession(&TeecContext, 941 &TeecSession, 942 TeecUuid, 943 TEEC_LOGIN_PUBLIC, 944 NULL, 945 NULL, 946 &ErrorOrigin); 947 948 TEEC_SharedMemory SharedMem0 = {0}; 949 950 SharedMem0.size = length * sizeof(uint32_t); 951 SharedMem0.flags = 0; 952 953 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 954 955 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 956 TeecOperation.params[0].tmpref.size = SharedMem0.size; 957 958 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_OUTPUT, 959 TEEC_NONE, 960 TEEC_NONE, 961 TEEC_NONE); 962 963 TeecResult = TEEC_InvokeCommand(&TeecSession, 964 3, 965 &TeecOperation, 966 &ErrorOrigin); 967 968 if (TeecResult == TEEC_SUCCESS) 969 memcpy(buf, SharedMem0.buffer, SharedMem0.size); 970 971 TEEC_ReleaseSharedMemory(&SharedMem0); 972 TEEC_CloseSession(&TeecSession); 973 TEEC_FinalizeContext(&TeecContext); 974 975 return TeecResult; 976 } 977 uint32_t trusty_write_vbootkey_hash(uint32_t *buf, uint32_t length) 978 { 979 TEEC_Result TeecResult; 980 TEEC_Context TeecContext; 981 TEEC_Session TeecSession; 982 uint32_t ErrorOrigin; 983 984 TEEC_UUID tempuuid = { 0x2d26d8a8, 0x5134, 0x4dd8, \ 985 { 0xb3, 0x2f, 0xb3, 0x4b, 0xce, 0xeb, 0xc4, 0x71 } }; 986 TEEC_UUID *TeecUuid = &tempuuid; 987 TEEC_Operation TeecOperation = {0}; 988 989 OpteeClientApiLibInitialize(); 990 991 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 992 993 TeecResult = TEEC_OpenSession(&TeecContext, 994 &TeecSession, 995 TeecUuid, 996 TEEC_LOGIN_PUBLIC, 997 NULL, 998 NULL, 999 &ErrorOrigin); 1000 1001 TEEC_SharedMemory SharedMem0 = {0}; 1002 1003 SharedMem0.size = length * sizeof(uint32_t); 1004 SharedMem0.flags = 0; 1005 1006 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1007 1008 memcpy(SharedMem0.buffer, buf, SharedMem0.size); 1009 1010 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1011 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1012 1013 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 1014 TEEC_NONE, 1015 TEEC_NONE, 1016 TEEC_NONE); 1017 1018 TeecResult = TEEC_InvokeCommand(&TeecSession, 1019 4, 1020 &TeecOperation, 1021 &ErrorOrigin); 1022 1023 TEEC_ReleaseSharedMemory(&SharedMem0); 1024 TEEC_CloseSession(&TeecSession); 1025 TEEC_FinalizeContext(&TeecContext); 1026 1027 return TeecResult; 1028 } 1029