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 #include <optee_include/tee_api_defines.h> 12 #include <boot_rkimg.h> 13 #include <stdlib.h> 14 #include <attestation_key.h> 15 16 #define BOOT_FROM_EMMC (1 << 1) 17 #define WIDEVINE_TAG "KBOX" 18 #define ATTESTATION_TAG "ATTE" 19 20 uint32_t rk_send_keybox_to_ta(uint8_t *filename, uint32_t filename_size, 21 TEEC_UUID uuid, 22 uint8_t *key, uint32_t key_size, 23 uint8_t *data, uint32_t data_size) 24 { 25 TEEC_Result TeecResult; 26 TEEC_Context TeecContext; 27 TEEC_Session TeecSession; 28 uint32_t ErrorOrigin; 29 30 TEEC_UUID *TeecUuid = &uuid; 31 TEEC_Operation TeecOperation = {0}; 32 33 struct blk_desc *dev_desc; 34 35 dev_desc = rockchip_get_bootdev(); 36 if (!dev_desc) { 37 printf("%s: dev_desc is NULL!\n", __func__); 38 return -TEEC_ERROR_GENERIC; 39 } 40 41 OpteeClientApiLibInitialize(); 42 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 43 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, 44 TEEC_NONE, 45 TEEC_NONE, 46 TEEC_NONE); 47 48 /* 0 nand or emmc "security" partition , 1 rpmb */ 49 TeecOperation.params[0].value.a = 50 (dev_desc->if_type == IF_TYPE_MMC) ? 1 : 0; 51 #ifdef CONFIG_OPTEE_ALWAYS_USE_SECURITY_PARTITION 52 TeecOperation.params[0].value.a = 0; 53 #endif 54 TeecResult = TEEC_OpenSession(&TeecContext, 55 &TeecSession, 56 TeecUuid, 57 TEEC_LOGIN_PUBLIC, 58 NULL, 59 &TeecOperation, 60 &ErrorOrigin); 61 62 TEEC_SharedMemory SharedMem0 = {0}; 63 64 SharedMem0.size = filename_size; 65 SharedMem0.flags = 0; 66 67 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 68 69 memcpy(SharedMem0.buffer, filename, SharedMem0.size); 70 71 TEEC_SharedMemory SharedMem1 = {0}; 72 73 SharedMem1.size = key_size; 74 SharedMem1.flags = 0; 75 76 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 77 78 memcpy(SharedMem1.buffer, key, SharedMem1.size); 79 80 TEEC_SharedMemory SharedMem2 = {0}; 81 82 SharedMem2.size = data_size; 83 SharedMem2.flags = 0; 84 85 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem2); 86 87 memcpy(SharedMem2.buffer, data, SharedMem2.size); 88 89 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 90 TeecOperation.params[0].tmpref.size = SharedMem0.size; 91 92 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 93 TeecOperation.params[1].tmpref.size = SharedMem1.size; 94 95 TeecOperation.params[2].tmpref.buffer = SharedMem2.buffer; 96 TeecOperation.params[2].tmpref.size = SharedMem2.size; 97 98 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 99 TEEC_MEMREF_TEMP_INPUT, 100 TEEC_MEMREF_TEMP_INOUT, 101 TEEC_NONE); 102 103 printf("write keybox to secure storage\n"); 104 TeecResult = TEEC_InvokeCommand(&TeecSession, 105 6, 106 &TeecOperation, 107 &ErrorOrigin); 108 if (TeecResult != TEEC_SUCCESS) { 109 printf("send data to TA failed with code 0x%x\n", TeecResult); 110 } else { 111 printf("send data to TA success with code 0x%x\n", TeecResult); 112 } 113 114 TEEC_ReleaseSharedMemory(&SharedMem0); 115 TEEC_ReleaseSharedMemory(&SharedMem1); 116 TEEC_ReleaseSharedMemory(&SharedMem2); 117 118 TEEC_CloseSession(&TeecSession); 119 TEEC_FinalizeContext(&TeecContext); 120 121 return TeecResult; 122 } 123 124 int write_keybox_to_secure_storage(uint8_t *uboot_data, uint32_t len) 125 { 126 uint32_t key_size; 127 uint32_t data_size; 128 TEEC_Result ret; 129 int rc = 0; 130 131 if (memcmp(uboot_data, WIDEVINE_TAG, 4) == 0) { 132 /* widevine keybox */ 133 TEEC_UUID widevine_uuid = { 0x1b484ea5, 0x698b, 0x4142, 134 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 135 136 key_size = *(uboot_data + 4); 137 data_size = *(uboot_data + 8); 138 139 ret = rk_send_keybox_to_ta((uint8_t *)"widevine_keybox", 140 sizeof("widevine_keybox"), 141 widevine_uuid, 142 uboot_data + 12, 143 key_size, 144 uboot_data + 12 + key_size, 145 data_size); 146 if (ret == TEEC_SUCCESS) { 147 rc = 0; 148 printf("write widevine keybox to secure storage success\n"); 149 } else { 150 rc = -EIO; 151 printf("write widevine keybox to secure storage fail\n"); 152 } 153 } else if (memcmp(uboot_data, ATTESTATION_TAG, 4) == 0) { 154 /* attestation key */ 155 atap_result ret; 156 157 ret = write_attestation_key_to_secure_storage(uboot_data, len); 158 if (ret == ATAP_RESULT_OK) { 159 rc = 0; 160 printf("write attestation key to secure storage success\n"); 161 } else { 162 rc = -EIO; 163 printf("write attestation key to secure storage fail\n"); 164 } 165 } 166 return rc; 167 } 168 169 void test_optee(void) 170 { 171 TEEC_Result TeecResult; 172 TEEC_Context TeecContext; 173 TEEC_Session TeecSession; 174 uint32_t ErrorOrigin; 175 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, \ 176 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 177 TEEC_UUID *TeecUuid = &tempuuid; 178 TEEC_Operation TeecOperation = {0}; 179 struct blk_desc *dev_desc; 180 dev_desc = rockchip_get_bootdev(); 181 if (!dev_desc) { 182 printf("%s: dev_desc is NULL!\n", __func__); 183 return; 184 } 185 186 debug("testmm start\n"); 187 OpteeClientApiLibInitialize(); 188 189 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 190 191 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, 192 TEEC_NONE, 193 TEEC_NONE, 194 TEEC_NONE); 195 /*0 nand or emmc "security" partition , 1 rpmb*/ 196 TeecOperation.params[0].value.a = (dev_desc->if_type == IF_TYPE_MMC) ? 1 : 0; 197 #ifdef CONFIG_OPTEE_ALWAYS_USE_SECURITY_PARTITION 198 TeecOperation.params[0].value.a = 0; 199 #endif 200 201 TeecResult = TEEC_OpenSession(&TeecContext, 202 &TeecSession, 203 TeecUuid, 204 TEEC_LOGIN_PUBLIC, 205 NULL, 206 &TeecOperation, 207 &ErrorOrigin); 208 209 TEEC_SharedMemory SharedMem0 = {0}; 210 211 SharedMem0.size = sizeof("filename_test"); 212 SharedMem0.flags = 0; 213 214 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 215 216 memcpy(SharedMem0.buffer, "filename_test", SharedMem0.size); 217 218 TEEC_SharedMemory SharedMem1 = {0}; 219 220 SharedMem1.size = 32; 221 SharedMem1.flags = 0; 222 223 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 224 225 memset(SharedMem1.buffer, 'a', SharedMem1.size); 226 227 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 228 TeecOperation.params[0].tmpref.size = SharedMem0.size; 229 230 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 231 TeecOperation.params[1].tmpref.size = SharedMem1.size; 232 233 234 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 235 TEEC_MEMREF_TEMP_INOUT, 236 TEEC_NONE, 237 TEEC_NONE); 238 239 TeecResult = TEEC_InvokeCommand(&TeecSession, 240 1, 241 &TeecOperation, 242 &ErrorOrigin); 243 244 TEEC_ReleaseSharedMemory(&SharedMem0); 245 TEEC_ReleaseSharedMemory(&SharedMem1); 246 247 TEEC_CloseSession(&TeecSession); 248 249 TEEC_FinalizeContext(&TeecContext); 250 251 debug("testmm end\n"); 252 debug("TeecResult %x\n", TeecResult); 253 } 254 255 static uint8_t b2hs_add_base(uint8_t in) 256 { 257 if (in > 9) 258 return in + 55; 259 else 260 return in + 48; 261 } 262 263 uint32_t b2hs(uint8_t *b, uint8_t *hs, uint32_t blen, uint32_t hslen) 264 { 265 uint32_t i = 0; 266 267 if (blen * 2 + 1 > hslen) 268 return 0; 269 270 for (; i < blen; i++) { 271 hs[i * 2 + 1] = b2hs_add_base(b[i] & 0xf); 272 hs[i * 2] = b2hs_add_base(b[i] >> 4); 273 } 274 hs[blen * 2] = 0; 275 276 return blen * 2; 277 } 278 279 280 uint32_t trusty_read_rollback_index(uint32_t slot, uint64_t *value) 281 { 282 TEEC_Result TeecResult; 283 TEEC_Context TeecContext; 284 TEEC_Session TeecSession; 285 uint32_t ErrorOrigin; 286 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 287 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 288 TEEC_UUID *TeecUuid = &tempuuid; 289 TEEC_Operation TeecOperation = {0}; 290 uint8_t hs[9]; 291 292 struct blk_desc *dev_desc; 293 dev_desc = rockchip_get_bootdev(); 294 if (!dev_desc) { 295 printf("%s: dev_desc is NULL!\n", __func__); 296 return -TEEC_ERROR_GENERIC; 297 } 298 299 b2hs((uint8_t *)&slot, hs, 4, 9); 300 debug("testmm start\n"); 301 OpteeClientApiLibInitialize(); 302 303 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 304 305 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, 306 TEEC_NONE, 307 TEEC_NONE, 308 TEEC_NONE); 309 /*0 nand or emmc "security" partition , 1 rpmb*/ 310 TeecOperation.params[0].value.a = (dev_desc->if_type == IF_TYPE_MMC) ? 1 : 0; 311 #ifdef CONFIG_OPTEE_ALWAYS_USE_SECURITY_PARTITION 312 TeecOperation.params[0].value.a = 0; 313 #endif 314 315 TeecResult = TEEC_OpenSession(&TeecContext, 316 &TeecSession, 317 TeecUuid, 318 TEEC_LOGIN_PUBLIC, 319 NULL, 320 &TeecOperation, 321 322 &ErrorOrigin); 323 324 TEEC_SharedMemory SharedMem0 = {0}; 325 326 SharedMem0.size = 8; 327 SharedMem0.flags = 0; 328 329 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 330 331 memcpy(SharedMem0.buffer, hs, SharedMem0.size); 332 333 TEEC_SharedMemory SharedMem1 = {0}; 334 335 SharedMem1.size = 8; 336 SharedMem1.flags = 0; 337 338 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 339 340 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 341 TeecOperation.params[0].tmpref.size = SharedMem0.size; 342 343 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 344 TeecOperation.params[1].tmpref.size = SharedMem1.size; 345 346 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 347 TEEC_MEMREF_TEMP_INOUT, 348 TEEC_NONE, 349 TEEC_NONE); 350 351 TeecResult = TEEC_InvokeCommand(&TeecSession, 352 0, 353 &TeecOperation, 354 &ErrorOrigin); 355 if (TeecResult == TEEC_SUCCESS) 356 memcpy((char *)value, SharedMem1.buffer, SharedMem1.size); 357 358 TEEC_ReleaseSharedMemory(&SharedMem0); 359 TEEC_ReleaseSharedMemory(&SharedMem1); 360 361 TEEC_CloseSession(&TeecSession); 362 363 TEEC_FinalizeContext(&TeecContext); 364 365 debug("testmm end\n"); 366 return TeecResult; 367 } 368 369 uint32_t trusty_write_rollback_index(uint32_t slot, uint64_t value) 370 { 371 TEEC_Result TeecResult; 372 TEEC_Context TeecContext; 373 TEEC_Session TeecSession; 374 uint32_t ErrorOrigin; 375 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 376 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 377 TEEC_UUID *TeecUuid = &tempuuid; 378 TEEC_Operation TeecOperation = {0}; 379 uint8_t hs[9]; 380 struct blk_desc *dev_desc; 381 dev_desc = rockchip_get_bootdev(); 382 if (!dev_desc) { 383 printf("%s: dev_desc is NULL!\n", __func__); 384 return -TEEC_ERROR_GENERIC; 385 } 386 387 b2hs((uint8_t *)&slot, hs, 4, 9); 388 OpteeClientApiLibInitialize(); 389 390 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 391 392 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, 393 TEEC_NONE, 394 TEEC_NONE, 395 TEEC_NONE); 396 /*0 nand or emmc "security" partition , 1 rpmb*/ 397 TeecOperation.params[0].value.a = (dev_desc->if_type == IF_TYPE_MMC) ? 1 : 0; 398 #ifdef CONFIG_OPTEE_ALWAYS_USE_SECURITY_PARTITION 399 TeecOperation.params[0].value.a = 0; 400 #endif 401 402 TeecResult = TEEC_OpenSession(&TeecContext, 403 &TeecSession, 404 TeecUuid, 405 TEEC_LOGIN_PUBLIC, 406 NULL, 407 &TeecOperation, 408 &ErrorOrigin); 409 410 TEEC_SharedMemory SharedMem0 = {0}; 411 412 SharedMem0.size = 8; 413 SharedMem0.flags = 0; 414 415 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 416 417 memcpy(SharedMem0.buffer, hs, SharedMem0.size); 418 419 TEEC_SharedMemory SharedMem1 = {0}; 420 421 SharedMem1.size = 8; 422 SharedMem1.flags = 0; 423 424 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 425 426 memcpy(SharedMem1.buffer, (char *)&value, SharedMem1.size); 427 428 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 429 TeecOperation.params[0].tmpref.size = SharedMem0.size; 430 431 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 432 TeecOperation.params[1].tmpref.size = SharedMem1.size; 433 434 435 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 436 TEEC_MEMREF_TEMP_INOUT, 437 TEEC_NONE, 438 TEEC_NONE); 439 440 TeecResult = TEEC_InvokeCommand(&TeecSession, 441 1, 442 &TeecOperation, 443 &ErrorOrigin); 444 445 TEEC_ReleaseSharedMemory(&SharedMem0); 446 TEEC_ReleaseSharedMemory(&SharedMem1); 447 448 TEEC_CloseSession(&TeecSession); 449 450 TEEC_FinalizeContext(&TeecContext); 451 452 debug("testmm end\n"); 453 454 return TeecResult; 455 } 456 457 uint32_t trusty_read_permanent_attributes(uint8_t *attributes, uint32_t size) 458 { 459 TEEC_Result TeecResult; 460 TEEC_Context TeecContext; 461 TEEC_Session TeecSession; 462 uint32_t ErrorOrigin; 463 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 464 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 465 TEEC_UUID *TeecUuid = &tempuuid; 466 TEEC_Operation TeecOperation = {0}; 467 struct blk_desc *dev_desc; 468 dev_desc = rockchip_get_bootdev(); 469 if (!dev_desc) { 470 printf("%s: dev_desc is NULL!\n", __func__); 471 return -TEEC_ERROR_GENERIC; 472 } 473 474 debug("testmm start\n"); 475 OpteeClientApiLibInitialize(); 476 477 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 478 479 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, 480 TEEC_NONE, 481 TEEC_NONE, 482 TEEC_NONE); 483 /*0 nand or emmc "security" partition , 1 rpmb*/ 484 TeecOperation.params[0].value.a = (dev_desc->if_type == IF_TYPE_MMC) ? 1 : 0; 485 #ifdef CONFIG_OPTEE_ALWAYS_USE_SECURITY_PARTITION 486 TeecOperation.params[0].value.a = 0; 487 #endif 488 489 TeecResult = TEEC_OpenSession(&TeecContext, 490 &TeecSession, 491 TeecUuid, 492 TEEC_LOGIN_PUBLIC, 493 NULL, 494 &TeecOperation, 495 &ErrorOrigin); 496 497 TEEC_SharedMemory SharedMem0 = {0}; 498 499 SharedMem0.size = sizeof("attributes"); 500 SharedMem0.flags = 0; 501 502 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 503 504 memcpy(SharedMem0.buffer, "attributes", SharedMem0.size); 505 506 TEEC_SharedMemory SharedMem1 = {0}; 507 508 SharedMem1.size = size; 509 SharedMem1.flags = 0; 510 511 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 512 513 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 514 TeecOperation.params[0].tmpref.size = SharedMem0.size; 515 516 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 517 TeecOperation.params[1].tmpref.size = SharedMem1.size; 518 519 520 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 521 TEEC_MEMREF_TEMP_INOUT, 522 TEEC_NONE, 523 TEEC_NONE); 524 525 TeecResult = TEEC_InvokeCommand(&TeecSession, 526 0, 527 &TeecOperation, 528 &ErrorOrigin); 529 if (TeecResult == TEEC_SUCCESS) 530 memcpy(attributes, SharedMem1.buffer, SharedMem1.size); 531 TEEC_ReleaseSharedMemory(&SharedMem0); 532 TEEC_ReleaseSharedMemory(&SharedMem1); 533 TEEC_CloseSession(&TeecSession); 534 TEEC_FinalizeContext(&TeecContext); 535 debug("testmm end\n"); 536 537 return TeecResult; 538 } 539 540 uint32_t trusty_write_permanent_attributes(uint8_t *attributes, uint32_t size) 541 { 542 TEEC_Result TeecResult; 543 TEEC_Context TeecContext; 544 TEEC_Session TeecSession; 545 uint32_t ErrorOrigin; 546 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 547 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 548 TEEC_UUID *TeecUuid = &tempuuid; 549 TEEC_Operation TeecOperation = {0}; 550 struct blk_desc *dev_desc; 551 dev_desc = rockchip_get_bootdev(); 552 if (!dev_desc) { 553 printf("%s: dev_desc is NULL!\n", __func__); 554 return -TEEC_ERROR_GENERIC; 555 } 556 557 debug("testmm start\n"); 558 OpteeClientApiLibInitialize(); 559 560 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 561 562 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, 563 TEEC_NONE, 564 TEEC_NONE, 565 TEEC_NONE); 566 /*0 nand or emmc "security" partition , 1 rpmb*/ 567 TeecOperation.params[0].value.a = (dev_desc->if_type == IF_TYPE_MMC) ? 1 : 0; 568 #ifdef CONFIG_OPTEE_ALWAYS_USE_SECURITY_PARTITION 569 TeecOperation.params[0].value.a = 0; 570 #endif 571 572 TeecResult = TEEC_OpenSession(&TeecContext, 573 &TeecSession, 574 TeecUuid, 575 TEEC_LOGIN_PUBLIC, 576 NULL, 577 &TeecOperation, 578 &ErrorOrigin); 579 580 TEEC_SharedMemory SharedMem0 = {0}; 581 582 SharedMem0.size = sizeof("attributes"); 583 SharedMem0.flags = 0; 584 585 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 586 587 memcpy(SharedMem0.buffer, "attributes", SharedMem0.size); 588 589 TEEC_SharedMemory SharedMem1 = {0}; 590 591 SharedMem1.size = size; 592 SharedMem1.flags = 0; 593 594 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 595 596 memcpy(SharedMem1.buffer, attributes, SharedMem1.size); 597 598 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 599 TeecOperation.params[0].tmpref.size = SharedMem0.size; 600 601 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 602 TeecOperation.params[1].tmpref.size = SharedMem1.size; 603 604 605 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 606 TEEC_MEMREF_TEMP_INOUT, 607 TEEC_NONE, 608 TEEC_NONE); 609 610 TeecResult = TEEC_InvokeCommand(&TeecSession, 611 1, 612 &TeecOperation, 613 &ErrorOrigin); 614 615 TEEC_ReleaseSharedMemory(&SharedMem0); 616 TEEC_ReleaseSharedMemory(&SharedMem1); 617 TEEC_CloseSession(&TeecSession); 618 TEEC_FinalizeContext(&TeecContext); 619 debug("testmm end\n"); 620 621 return TeecResult; 622 } 623 624 uint32_t trusty_read_lock_state(uint8_t *lock_state) 625 { 626 TEEC_Result TeecResult; 627 TEEC_Context TeecContext; 628 TEEC_Session TeecSession; 629 uint32_t ErrorOrigin; 630 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 631 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 632 TEEC_UUID *TeecUuid = &tempuuid; 633 TEEC_Operation TeecOperation = {0}; 634 struct blk_desc *dev_desc; 635 dev_desc = rockchip_get_bootdev(); 636 if (!dev_desc) { 637 printf("%s: dev_desc is NULL!\n", __func__); 638 return -TEEC_ERROR_GENERIC; 639 } 640 641 debug("testmm start\n"); 642 OpteeClientApiLibInitialize(); 643 644 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 645 646 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, 647 TEEC_NONE, 648 TEEC_NONE, 649 TEEC_NONE); 650 /*0 nand or emmc "security" partition , 1 rpmb*/ 651 TeecOperation.params[0].value.a = (dev_desc->if_type == IF_TYPE_MMC) ? 1 : 0; 652 #ifdef CONFIG_OPTEE_ALWAYS_USE_SECURITY_PARTITION 653 TeecOperation.params[0].value.a = 0; 654 #endif 655 656 TeecResult = TEEC_OpenSession(&TeecContext, 657 &TeecSession, 658 TeecUuid, 659 TEEC_LOGIN_PUBLIC, 660 NULL, 661 &TeecOperation, 662 &ErrorOrigin); 663 664 TEEC_SharedMemory SharedMem0 = {0}; 665 666 SharedMem0.size = sizeof("lock_state"); 667 SharedMem0.flags = 0; 668 669 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 670 671 memcpy(SharedMem0.buffer, "lock_state", SharedMem0.size); 672 673 TEEC_SharedMemory SharedMem1 = {0}; 674 675 SharedMem1.size = 1; 676 SharedMem1.flags = 0; 677 678 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 679 680 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 681 TeecOperation.params[0].tmpref.size = SharedMem0.size; 682 683 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 684 TeecOperation.params[1].tmpref.size = SharedMem1.size; 685 686 687 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 688 TEEC_MEMREF_TEMP_INOUT, 689 TEEC_NONE, 690 TEEC_NONE); 691 692 TeecResult = TEEC_InvokeCommand(&TeecSession, 693 0, 694 &TeecOperation, 695 &ErrorOrigin); 696 if (TeecResult == TEEC_SUCCESS) 697 memcpy(lock_state, SharedMem1.buffer, SharedMem1.size); 698 TEEC_ReleaseSharedMemory(&SharedMem0); 699 TEEC_ReleaseSharedMemory(&SharedMem1); 700 TEEC_CloseSession(&TeecSession); 701 TEEC_FinalizeContext(&TeecContext); 702 debug("testmm end\n"); 703 704 return TeecResult; 705 } 706 707 uint32_t trusty_write_lock_state(uint8_t lock_state) 708 { 709 TEEC_Result TeecResult; 710 TEEC_Context TeecContext; 711 TEEC_Session TeecSession; 712 uint32_t ErrorOrigin; 713 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 714 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 715 TEEC_UUID *TeecUuid = &tempuuid; 716 TEEC_Operation TeecOperation = {0}; 717 struct blk_desc *dev_desc; 718 dev_desc = rockchip_get_bootdev(); 719 if (!dev_desc) { 720 printf("%s: dev_desc is NULL!\n", __func__); 721 return -TEEC_ERROR_GENERIC; 722 } 723 724 debug("testmm start\n"); 725 OpteeClientApiLibInitialize(); 726 727 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 728 729 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, 730 TEEC_NONE, 731 TEEC_NONE, 732 TEEC_NONE); 733 /*0 nand or emmc "security" partition , 1 rpmb*/ 734 TeecOperation.params[0].value.a = (dev_desc->if_type == IF_TYPE_MMC) ? 1 : 0; 735 #ifdef CONFIG_OPTEE_ALWAYS_USE_SECURITY_PARTITION 736 TeecOperation.params[0].value.a = 0; 737 #endif 738 739 TeecResult = TEEC_OpenSession(&TeecContext, 740 &TeecSession, 741 TeecUuid, 742 TEEC_LOGIN_PUBLIC, 743 NULL, 744 &TeecOperation, 745 &ErrorOrigin); 746 747 TEEC_SharedMemory SharedMem0 = {0}; 748 749 SharedMem0.size = sizeof("lock_state"); 750 SharedMem0.flags = 0; 751 752 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 753 754 memcpy(SharedMem0.buffer, "lock_state", SharedMem0.size); 755 756 TEEC_SharedMemory SharedMem1 = {0}; 757 758 SharedMem1.size = 1; 759 SharedMem1.flags = 0; 760 761 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 762 763 memcpy(SharedMem1.buffer, &lock_state, SharedMem1.size); 764 765 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 766 TeecOperation.params[0].tmpref.size = SharedMem0.size; 767 768 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 769 TeecOperation.params[1].tmpref.size = SharedMem1.size; 770 771 772 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 773 TEEC_MEMREF_TEMP_INOUT, 774 TEEC_NONE, 775 TEEC_NONE); 776 777 TeecResult = TEEC_InvokeCommand(&TeecSession, 778 1, 779 &TeecOperation, 780 &ErrorOrigin); 781 782 TEEC_ReleaseSharedMemory(&SharedMem0); 783 TEEC_ReleaseSharedMemory(&SharedMem1); 784 TEEC_CloseSession(&TeecSession); 785 TEEC_FinalizeContext(&TeecContext); 786 debug("testmm end\n"); 787 788 return TeecResult; 789 } 790 791 uint32_t trusty_read_flash_lock_state(uint8_t *flash_lock_state) 792 { 793 TEEC_Result TeecResult; 794 TEEC_Context TeecContext; 795 TEEC_Session TeecSession; 796 uint32_t ErrorOrigin; 797 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 798 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 799 TEEC_UUID *TeecUuid = &tempuuid; 800 TEEC_Operation TeecOperation = {0}; 801 struct blk_desc *dev_desc; 802 dev_desc = rockchip_get_bootdev(); 803 if (!dev_desc) { 804 printf("%s: dev_desc is NULL!\n", __func__); 805 return -TEEC_ERROR_GENERIC; 806 } 807 808 debug("testmm start\n"); 809 OpteeClientApiLibInitialize(); 810 811 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 812 813 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, 814 TEEC_NONE, 815 TEEC_NONE, 816 TEEC_NONE); 817 /*0 nand or emmc "security" partition , 1 rpmb*/ 818 TeecOperation.params[0].value.a = (dev_desc->if_type == IF_TYPE_MMC) ? 1 : 0; 819 #ifdef CONFIG_OPTEE_ALWAYS_USE_SECURITY_PARTITION 820 TeecOperation.params[0].value.a = 0; 821 #endif 822 823 TeecResult = TEEC_OpenSession(&TeecContext, 824 &TeecSession, 825 TeecUuid, 826 TEEC_LOGIN_PUBLIC, 827 NULL, 828 &TeecOperation, 829 &ErrorOrigin); 830 831 TEEC_SharedMemory SharedMem0 = {0}; 832 833 SharedMem0.size = sizeof("flash_lock_state"); 834 SharedMem0.flags = 0; 835 836 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 837 838 memcpy(SharedMem0.buffer, "flash_lock_state", SharedMem0.size); 839 840 TEEC_SharedMemory SharedMem1 = {0}; 841 842 SharedMem1.size = 1; 843 SharedMem1.flags = 0; 844 845 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 846 847 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 848 TeecOperation.params[0].tmpref.size = SharedMem0.size; 849 850 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 851 TeecOperation.params[1].tmpref.size = SharedMem1.size; 852 853 854 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 855 TEEC_MEMREF_TEMP_INOUT, 856 TEEC_NONE, 857 TEEC_NONE); 858 859 TeecResult = TEEC_InvokeCommand(&TeecSession, 860 0, 861 &TeecOperation, 862 &ErrorOrigin); 863 if (TeecResult == TEEC_SUCCESS) 864 memcpy(flash_lock_state, SharedMem1.buffer, SharedMem1.size); 865 TEEC_ReleaseSharedMemory(&SharedMem0); 866 TEEC_ReleaseSharedMemory(&SharedMem1); 867 TEEC_CloseSession(&TeecSession); 868 TEEC_FinalizeContext(&TeecContext); 869 debug("testmm end\n"); 870 871 return TeecResult; 872 } 873 874 875 uint32_t trusty_write_flash_lock_state(uint8_t flash_lock_state) 876 { 877 TEEC_Result TeecResult; 878 TEEC_Context TeecContext; 879 TEEC_Session TeecSession; 880 uint32_t ErrorOrigin; 881 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 882 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 883 TEEC_UUID *TeecUuid = &tempuuid; 884 TEEC_Operation TeecOperation = {0}; 885 struct blk_desc *dev_desc; 886 dev_desc = rockchip_get_bootdev(); 887 if (!dev_desc) { 888 printf("%s: dev_desc is NULL!\n", __func__); 889 return -TEEC_ERROR_GENERIC; 890 } 891 892 debug("testmm start\n"); 893 OpteeClientApiLibInitialize(); 894 895 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 896 897 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, 898 TEEC_NONE, 899 TEEC_NONE, 900 TEEC_NONE); 901 /*0 nand or emmc "security" partition , 1 rpmb*/ 902 TeecOperation.params[0].value.a = (dev_desc->if_type == IF_TYPE_MMC) ? 1 : 0; 903 #ifdef CONFIG_OPTEE_ALWAYS_USE_SECURITY_PARTITION 904 TeecOperation.params[0].value.a = 0; 905 #endif 906 907 TeecResult = TEEC_OpenSession(&TeecContext, 908 &TeecSession, 909 TeecUuid, 910 TEEC_LOGIN_PUBLIC, 911 NULL, 912 &TeecOperation, 913 &ErrorOrigin); 914 915 TEEC_SharedMemory SharedMem0 = {0}; 916 917 SharedMem0.size = sizeof("flash_lock_state"); 918 SharedMem0.flags = 0; 919 920 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 921 922 memcpy(SharedMem0.buffer, "flash_lock_state", SharedMem0.size); 923 924 TEEC_SharedMemory SharedMem1 = {0}; 925 926 SharedMem1.size = 1; 927 SharedMem1.flags = 0; 928 929 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 930 931 memcpy(SharedMem1.buffer, &flash_lock_state, SharedMem1.size); 932 933 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 934 TeecOperation.params[0].tmpref.size = SharedMem0.size; 935 936 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 937 TeecOperation.params[1].tmpref.size = SharedMem1.size; 938 939 940 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 941 TEEC_MEMREF_TEMP_INOUT, 942 TEEC_NONE, 943 TEEC_NONE); 944 945 TeecResult = TEEC_InvokeCommand(&TeecSession, 946 1, 947 &TeecOperation, 948 &ErrorOrigin); 949 950 TEEC_ReleaseSharedMemory(&SharedMem0); 951 TEEC_ReleaseSharedMemory(&SharedMem1); 952 TEEC_CloseSession(&TeecSession); 953 TEEC_FinalizeContext(&TeecContext); 954 debug("testmm end\n"); 955 956 return TeecResult; 957 } 958 959 TEEC_Result read_from_keymaster(uint8_t *filename, 960 uint32_t filename_size, 961 uint8_t *data, 962 uint32_t size) 963 { 964 TEEC_Result TeecResult; 965 TEEC_Context TeecContext; 966 TEEC_Session TeecSession; 967 uint32_t ErrorOrigin; 968 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 969 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 970 TEEC_UUID *TeecUuid = &tempuuid; 971 TEEC_Operation TeecOperation = {0}; 972 struct blk_desc *dev_desc; 973 dev_desc = rockchip_get_bootdev(); 974 if (!dev_desc) { 975 printf("%s: dev_desc is NULL!\n", __func__); 976 return -TEEC_ERROR_GENERIC; 977 } 978 979 debug("read_from_keymaster start\n"); 980 OpteeClientApiLibInitialize(); 981 982 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 983 984 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, 985 TEEC_NONE, 986 TEEC_NONE, 987 TEEC_NONE); 988 /*0 nand or emmc "security" partition , 1 rpmb*/ 989 TeecOperation.params[0].value.a = (dev_desc->if_type == IF_TYPE_MMC) ? 1 : 0; 990 #ifdef CONFIG_OPTEE_ALWAYS_USE_SECURITY_PARTITION 991 TeecOperation.params[0].value.a = 0; 992 #endif 993 994 TeecResult = TEEC_OpenSession(&TeecContext, 995 &TeecSession, 996 TeecUuid, 997 TEEC_LOGIN_PUBLIC, 998 NULL, 999 &TeecOperation, 1000 &ErrorOrigin); 1001 1002 TEEC_SharedMemory SharedMem0 = {0}; 1003 1004 SharedMem0.size = filename_size; 1005 SharedMem0.flags = 0; 1006 1007 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1008 1009 memcpy(SharedMem0.buffer, filename, SharedMem0.size); 1010 1011 TEEC_SharedMemory SharedMem1 = {0}; 1012 1013 SharedMem1.size = size; 1014 SharedMem1.flags = 0; 1015 1016 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 1017 1018 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1019 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1020 1021 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 1022 TeecOperation.params[1].tmpref.size = SharedMem1.size; 1023 1024 1025 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 1026 TEEC_MEMREF_TEMP_INOUT, 1027 TEEC_NONE, 1028 TEEC_NONE); 1029 1030 TeecResult = TEEC_InvokeCommand(&TeecSession, 1031 0, 1032 &TeecOperation, 1033 &ErrorOrigin); 1034 if (TeecResult == TEEC_SUCCESS) 1035 memcpy(data, SharedMem1.buffer, SharedMem1.size); 1036 TEEC_ReleaseSharedMemory(&SharedMem0); 1037 TEEC_ReleaseSharedMemory(&SharedMem1); 1038 TEEC_CloseSession(&TeecSession); 1039 TEEC_FinalizeContext(&TeecContext); 1040 debug("read_from_keymaster end\n"); 1041 1042 return TeecResult; 1043 } 1044 1045 uint32_t write_to_keymaster(uint8_t *filename, 1046 uint32_t filename_size, 1047 uint8_t *data, 1048 uint32_t data_size) 1049 { 1050 TEEC_Result TeecResult; 1051 TEEC_Context TeecContext; 1052 TEEC_Session TeecSession; 1053 uint32_t ErrorOrigin; 1054 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 1055 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 1056 TEEC_UUID *TeecUuid = &tempuuid; 1057 TEEC_Operation TeecOperation = {0}; 1058 struct blk_desc *dev_desc; 1059 dev_desc = rockchip_get_bootdev(); 1060 if (!dev_desc) { 1061 printf("%s: dev_desc is NULL!\n", __func__); 1062 return -TEEC_ERROR_GENERIC; 1063 } 1064 1065 debug("write_to_keymaster\n"); 1066 OpteeClientApiLibInitialize(); 1067 1068 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1069 1070 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, 1071 TEEC_NONE, 1072 TEEC_NONE, 1073 TEEC_NONE); 1074 /*0 nand or emmc "security" partition , 1 rpmb*/ 1075 TeecOperation.params[0].value.a = (dev_desc->if_type == IF_TYPE_MMC) ? 1 : 0; 1076 #ifdef CONFIG_OPTEE_ALWAYS_USE_SECURITY_PARTITION 1077 TeecOperation.params[0].value.a = 0; 1078 #endif 1079 1080 TeecResult = TEEC_OpenSession(&TeecContext, 1081 &TeecSession, 1082 TeecUuid, 1083 TEEC_LOGIN_PUBLIC, 1084 NULL, 1085 &TeecOperation, 1086 &ErrorOrigin); 1087 1088 TEEC_SharedMemory SharedMem0 = {0}; 1089 1090 SharedMem0.size = filename_size; 1091 SharedMem0.flags = 0; 1092 1093 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1094 1095 memcpy(SharedMem0.buffer, filename, SharedMem0.size); 1096 1097 TEEC_SharedMemory SharedMem1 = {0}; 1098 1099 SharedMem1.size = data_size; 1100 SharedMem1.flags = 0; 1101 1102 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 1103 1104 memcpy(SharedMem1.buffer, data, SharedMem1.size); 1105 1106 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1107 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1108 1109 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 1110 TeecOperation.params[1].tmpref.size = SharedMem1.size; 1111 1112 1113 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 1114 TEEC_MEMREF_TEMP_INOUT, 1115 TEEC_NONE, 1116 TEEC_NONE); 1117 1118 TeecResult = TEEC_InvokeCommand(&TeecSession, 1119 1, 1120 &TeecOperation, 1121 &ErrorOrigin); 1122 1123 TEEC_ReleaseSharedMemory(&SharedMem0); 1124 TEEC_ReleaseSharedMemory(&SharedMem1); 1125 TEEC_CloseSession(&TeecSession); 1126 TEEC_FinalizeContext(&TeecContext); 1127 debug("write_to_keymaster end\n"); 1128 debug("TeecResult %x\n", TeecResult); 1129 1130 return TeecResult; 1131 } 1132 1133 uint32_t trusty_read_attribute_hash(uint32_t *buf, uint32_t length) 1134 { 1135 TEEC_Result TeecResult; 1136 TEEC_Context TeecContext; 1137 TEEC_Session TeecSession; 1138 uint32_t ErrorOrigin; 1139 1140 TEEC_UUID tempuuid = { 0x2d26d8a8, 0x5134, 0x4dd8, \ 1141 { 0xb3, 0x2f, 0xb3, 0x4b, 0xce, 0xeb, 0xc4, 0x71 } }; 1142 TEEC_UUID *TeecUuid = &tempuuid; 1143 TEEC_Operation TeecOperation = {0}; 1144 1145 OpteeClientApiLibInitialize(); 1146 1147 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1148 1149 TeecResult = TEEC_OpenSession(&TeecContext, 1150 &TeecSession, 1151 TeecUuid, 1152 TEEC_LOGIN_PUBLIC, 1153 NULL, 1154 NULL, 1155 &ErrorOrigin); 1156 1157 TEEC_SharedMemory SharedMem0 = {0}; 1158 1159 SharedMem0.size = length * sizeof(uint32_t); 1160 SharedMem0.flags = 0; 1161 1162 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1163 1164 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1165 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1166 1167 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_OUTPUT, 1168 TEEC_NONE, 1169 TEEC_NONE, 1170 TEEC_NONE); 1171 1172 TeecResult = TEEC_InvokeCommand(&TeecSession, 1173 0, 1174 &TeecOperation, 1175 &ErrorOrigin); 1176 1177 if (TeecResult == TEEC_SUCCESS) 1178 memcpy(buf, SharedMem0.buffer, SharedMem0.size); 1179 1180 TEEC_ReleaseSharedMemory(&SharedMem0); 1181 TEEC_CloseSession(&TeecSession); 1182 TEEC_FinalizeContext(&TeecContext); 1183 1184 return TeecResult; 1185 } 1186 1187 uint32_t trusty_write_attribute_hash(uint32_t *buf, uint32_t length) 1188 { 1189 TEEC_Result TeecResult; 1190 TEEC_Context TeecContext; 1191 TEEC_Session TeecSession; 1192 uint32_t ErrorOrigin; 1193 1194 TEEC_UUID tempuuid = { 0x2d26d8a8, 0x5134, 0x4dd8, \ 1195 { 0xb3, 0x2f, 0xb3, 0x4b, 0xce, 0xeb, 0xc4, 0x71 } }; 1196 TEEC_UUID *TeecUuid = &tempuuid; 1197 TEEC_Operation TeecOperation = {0}; 1198 1199 OpteeClientApiLibInitialize(); 1200 1201 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1202 1203 TeecResult = TEEC_OpenSession(&TeecContext, 1204 &TeecSession, 1205 TeecUuid, 1206 TEEC_LOGIN_PUBLIC, 1207 NULL, 1208 NULL, 1209 &ErrorOrigin); 1210 1211 TEEC_SharedMemory SharedMem0 = {0}; 1212 1213 SharedMem0.size = length * sizeof(uint32_t); 1214 SharedMem0.flags = 0; 1215 1216 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1217 1218 memcpy(SharedMem0.buffer, buf, SharedMem0.size); 1219 1220 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1221 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1222 1223 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 1224 TEEC_NONE, 1225 TEEC_NONE, 1226 TEEC_NONE); 1227 1228 TeecResult = TEEC_InvokeCommand(&TeecSession, 1229 1, 1230 &TeecOperation, 1231 &ErrorOrigin); 1232 1233 TEEC_ReleaseSharedMemory(&SharedMem0); 1234 TEEC_CloseSession(&TeecSession); 1235 TEEC_FinalizeContext(&TeecContext); 1236 1237 return TeecResult; 1238 } 1239 1240 uint32_t notify_optee_rpmb_ta(void) 1241 { 1242 TEEC_Result TeecResult; 1243 TEEC_Context TeecContext; 1244 TEEC_Session TeecSession; 1245 uint32_t ErrorOrigin; 1246 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 1247 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 1248 TEEC_UUID *TeecUuid = &tempuuid; 1249 TEEC_Operation TeecOperation = {0}; 1250 1251 OpteeClientApiLibInitialize(); 1252 1253 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1254 1255 TeecResult = TEEC_OpenSession(&TeecContext, 1256 &TeecSession, 1257 TeecUuid, 1258 TEEC_LOGIN_PUBLIC, 1259 NULL, 1260 NULL, 1261 &ErrorOrigin); 1262 1263 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, 1264 TEEC_NONE, 1265 TEEC_NONE, 1266 TEEC_NONE); 1267 1268 TeecResult = TEEC_InvokeCommand(&TeecSession, 1269 2, 1270 &TeecOperation, 1271 &ErrorOrigin); 1272 1273 TEEC_CloseSession(&TeecSession); 1274 TEEC_FinalizeContext(&TeecContext); 1275 1276 return TeecResult; 1277 } 1278 1279 uint32_t notify_optee_efuse_ta(void) 1280 { 1281 TEEC_Result TeecResult; 1282 TEEC_Context TeecContext; 1283 TEEC_Session TeecSession; 1284 uint32_t ErrorOrigin; 1285 TEEC_UUID tempuuid = { 0x2d26d8a8, 0x5134, 0x4dd8, \ 1286 { 0xb3, 0x2f, 0xb3, 0x4b, 0xce, 0xeb, 0xc4, 0x71 } }; 1287 1288 TEEC_UUID *TeecUuid = &tempuuid; 1289 TEEC_Operation TeecOperation = {0}; 1290 1291 OpteeClientApiLibInitialize(); 1292 1293 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1294 1295 TeecResult = TEEC_OpenSession(&TeecContext, 1296 &TeecSession, 1297 TeecUuid, 1298 TEEC_LOGIN_PUBLIC, 1299 NULL, 1300 NULL, 1301 &ErrorOrigin); 1302 1303 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, 1304 TEEC_NONE, 1305 TEEC_NONE, 1306 TEEC_NONE); 1307 1308 TeecResult = TEEC_InvokeCommand(&TeecSession, 1309 2, 1310 &TeecOperation, 1311 &ErrorOrigin); 1312 1313 TEEC_CloseSession(&TeecSession); 1314 TEEC_FinalizeContext(&TeecContext); 1315 1316 return TeecResult; 1317 } 1318 1319 uint32_t trusty_notify_optee_uboot_end(void) 1320 { 1321 TEEC_Result res; 1322 res = notify_optee_rpmb_ta(); 1323 res |= notify_optee_efuse_ta(); 1324 return res; 1325 } 1326 1327 uint32_t trusty_read_vbootkey_hash(uint32_t *buf, uint32_t length) 1328 { 1329 TEEC_Result TeecResult; 1330 TEEC_Context TeecContext; 1331 TEEC_Session TeecSession; 1332 uint32_t ErrorOrigin; 1333 1334 TEEC_UUID tempuuid = { 0x2d26d8a8, 0x5134, 0x4dd8, \ 1335 { 0xb3, 0x2f, 0xb3, 0x4b, 0xce, 0xeb, 0xc4, 0x71 } }; 1336 TEEC_UUID *TeecUuid = &tempuuid; 1337 TEEC_Operation TeecOperation = {0}; 1338 1339 OpteeClientApiLibInitialize(); 1340 1341 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1342 1343 TeecResult = TEEC_OpenSession(&TeecContext, 1344 &TeecSession, 1345 TeecUuid, 1346 TEEC_LOGIN_PUBLIC, 1347 NULL, 1348 NULL, 1349 &ErrorOrigin); 1350 1351 TEEC_SharedMemory SharedMem0 = {0}; 1352 1353 SharedMem0.size = length * sizeof(uint32_t); 1354 SharedMem0.flags = 0; 1355 1356 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1357 1358 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1359 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1360 1361 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_OUTPUT, 1362 TEEC_NONE, 1363 TEEC_NONE, 1364 TEEC_NONE); 1365 1366 TeecResult = TEEC_InvokeCommand(&TeecSession, 1367 3, 1368 &TeecOperation, 1369 &ErrorOrigin); 1370 1371 if (TeecResult == TEEC_SUCCESS) 1372 memcpy(buf, SharedMem0.buffer, SharedMem0.size); 1373 1374 TEEC_ReleaseSharedMemory(&SharedMem0); 1375 TEEC_CloseSession(&TeecSession); 1376 TEEC_FinalizeContext(&TeecContext); 1377 1378 return TeecResult; 1379 } 1380 uint32_t trusty_write_vbootkey_hash(uint32_t *buf, uint32_t length) 1381 { 1382 TEEC_Result TeecResult; 1383 TEEC_Context TeecContext; 1384 TEEC_Session TeecSession; 1385 uint32_t ErrorOrigin; 1386 1387 TEEC_UUID tempuuid = { 0x2d26d8a8, 0x5134, 0x4dd8, \ 1388 { 0xb3, 0x2f, 0xb3, 0x4b, 0xce, 0xeb, 0xc4, 0x71 } }; 1389 TEEC_UUID *TeecUuid = &tempuuid; 1390 TEEC_Operation TeecOperation = {0}; 1391 1392 OpteeClientApiLibInitialize(); 1393 1394 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1395 1396 TeecResult = TEEC_OpenSession(&TeecContext, 1397 &TeecSession, 1398 TeecUuid, 1399 TEEC_LOGIN_PUBLIC, 1400 NULL, 1401 NULL, 1402 &ErrorOrigin); 1403 1404 TEEC_SharedMemory SharedMem0 = {0}; 1405 1406 SharedMem0.size = length * sizeof(uint32_t); 1407 SharedMem0.flags = 0; 1408 1409 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1410 1411 memcpy(SharedMem0.buffer, buf, SharedMem0.size); 1412 1413 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1414 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1415 1416 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 1417 TEEC_NONE, 1418 TEEC_NONE, 1419 TEEC_NONE); 1420 1421 TeecResult = TEEC_InvokeCommand(&TeecSession, 1422 4, 1423 &TeecOperation, 1424 &ErrorOrigin); 1425 1426 TEEC_ReleaseSharedMemory(&SharedMem0); 1427 TEEC_CloseSession(&TeecSession); 1428 TEEC_FinalizeContext(&TeecContext); 1429 1430 return TeecResult; 1431 } 1432 1433 uint32_t trusty_read_vbootkey_enable_flag(uint8_t *flag) 1434 { 1435 TEEC_Result TeecResult; 1436 TEEC_Context TeecContext; 1437 TEEC_Session TeecSession; 1438 uint32_t ErrorOrigin; 1439 uint32_t bootflag; 1440 1441 TEEC_UUID tempuuid = { 0x2d26d8a8, 0x5134, 0x4dd8, \ 1442 { 0xb3, 0x2f, 0xb3, 0x4b, 0xce, 0xeb, 0xc4, 0x71 } }; 1443 TEEC_UUID *TeecUuid = &tempuuid; 1444 TEEC_Operation TeecOperation = {0}; 1445 1446 OpteeClientApiLibInitialize(); 1447 1448 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1449 1450 TeecResult = TEEC_OpenSession(&TeecContext, 1451 &TeecSession, 1452 TeecUuid, 1453 TEEC_LOGIN_PUBLIC, 1454 NULL, 1455 NULL, 1456 &ErrorOrigin); 1457 1458 TEEC_SharedMemory SharedMem0 = {0}; 1459 1460 SharedMem0.size = 1 * sizeof(uint32_t); 1461 SharedMem0.flags = 0; 1462 1463 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1464 1465 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1466 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1467 1468 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_OUTPUT, 1469 TEEC_NONE, 1470 TEEC_NONE, 1471 TEEC_NONE); 1472 1473 TeecResult = TEEC_InvokeCommand(&TeecSession, 1474 5, 1475 &TeecOperation, 1476 &ErrorOrigin); 1477 1478 if (TeecResult == TEEC_SUCCESS) { 1479 memcpy(&bootflag, SharedMem0.buffer, SharedMem0.size); 1480 if (bootflag == 0x000000FF) 1481 *flag = 1; 1482 } 1483 1484 TEEC_ReleaseSharedMemory(&SharedMem0); 1485 TEEC_CloseSession(&TeecSession); 1486 TEEC_FinalizeContext(&TeecContext); 1487 1488 return TeecResult; 1489 } 1490 1491 uint32_t trusty_read_permanent_attributes_flag(uint8_t *attributes) 1492 { 1493 TEEC_Result TeecResult; 1494 TEEC_Context TeecContext; 1495 TEEC_Session TeecSession; 1496 uint32_t ErrorOrigin; 1497 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 1498 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 1499 TEEC_UUID *TeecUuid = &tempuuid; 1500 TEEC_Operation TeecOperation = {0}; 1501 struct blk_desc *dev_desc; 1502 dev_desc = rockchip_get_bootdev(); 1503 if (!dev_desc) { 1504 printf("%s: dev_desc is NULL!\n", __func__); 1505 return -TEEC_ERROR_GENERIC; 1506 } 1507 1508 debug("testmm start\n"); 1509 OpteeClientApiLibInitialize(); 1510 1511 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1512 1513 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, 1514 TEEC_NONE, 1515 TEEC_NONE, 1516 TEEC_NONE); 1517 /*0 nand or emmc "security" partition , 1 rpmb*/ 1518 TeecOperation.params[0].value.a = (dev_desc->if_type == IF_TYPE_MMC) ? 1 : 0; 1519 #ifdef CONFIG_OPTEE_ALWAYS_USE_SECURITY_PARTITION 1520 TeecOperation.params[0].value.a = 0; 1521 #endif 1522 1523 TeecResult = TEEC_OpenSession(&TeecContext, 1524 &TeecSession, 1525 TeecUuid, 1526 TEEC_LOGIN_PUBLIC, 1527 NULL, 1528 &TeecOperation, 1529 &ErrorOrigin); 1530 1531 TEEC_SharedMemory SharedMem0 = {0}; 1532 1533 SharedMem0.size = sizeof("attributes_flag"); 1534 SharedMem0.flags = 0; 1535 1536 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1537 1538 memcpy(SharedMem0.buffer, "attributes_flag", SharedMem0.size); 1539 1540 TEEC_SharedMemory SharedMem1 = {0}; 1541 1542 SharedMem1.size = 1; 1543 SharedMem1.flags = 0; 1544 1545 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 1546 1547 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1548 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1549 1550 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 1551 TeecOperation.params[1].tmpref.size = SharedMem1.size; 1552 1553 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 1554 TEEC_MEMREF_TEMP_INOUT, 1555 TEEC_NONE, 1556 TEEC_NONE); 1557 1558 TeecResult = TEEC_InvokeCommand(&TeecSession, 1559 0, 1560 &TeecOperation, 1561 &ErrorOrigin); 1562 if (TeecResult == TEEC_SUCCESS) 1563 memcpy(attributes, SharedMem1.buffer, SharedMem1.size); 1564 TEEC_ReleaseSharedMemory(&SharedMem0); 1565 TEEC_ReleaseSharedMemory(&SharedMem1); 1566 TEEC_CloseSession(&TeecSession); 1567 TEEC_FinalizeContext(&TeecContext); 1568 debug("testmm end\n"); 1569 1570 return TeecResult; 1571 } 1572 1573 uint32_t trusty_write_permanent_attributes_flag(uint8_t attributes) 1574 { 1575 TEEC_Result TeecResult; 1576 TEEC_Context TeecContext; 1577 TEEC_Session TeecSession; 1578 uint32_t ErrorOrigin; 1579 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 1580 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 1581 TEEC_UUID *TeecUuid = &tempuuid; 1582 TEEC_Operation TeecOperation = {0}; 1583 struct blk_desc *dev_desc; 1584 dev_desc = rockchip_get_bootdev(); 1585 if (!dev_desc) { 1586 printf("%s: dev_desc is NULL!\n", __func__); 1587 return -TEEC_ERROR_GENERIC; 1588 } 1589 1590 debug("testmm start\n"); 1591 OpteeClientApiLibInitialize(); 1592 1593 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1594 1595 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, 1596 TEEC_NONE, 1597 TEEC_NONE, 1598 TEEC_NONE); 1599 /*0 nand or emmc "security" partition , 1 rpmb*/ 1600 TeecOperation.params[0].value.a = (dev_desc->if_type == IF_TYPE_MMC) ? 1 : 0; 1601 #ifdef CONFIG_OPTEE_ALWAYS_USE_SECURITY_PARTITION 1602 TeecOperation.params[0].value.a = 0; 1603 #endif 1604 1605 TeecResult = TEEC_OpenSession(&TeecContext, 1606 &TeecSession, 1607 TeecUuid, 1608 TEEC_LOGIN_PUBLIC, 1609 NULL, 1610 &TeecOperation, 1611 &ErrorOrigin); 1612 1613 TEEC_SharedMemory SharedMem0 = {0}; 1614 1615 SharedMem0.size = sizeof("attributes_flag"); 1616 SharedMem0.flags = 0; 1617 1618 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1619 1620 memcpy(SharedMem0.buffer, "attributes_flag", SharedMem0.size); 1621 1622 TEEC_SharedMemory SharedMem1 = {0}; 1623 1624 SharedMem1.size = 1; 1625 SharedMem1.flags = 0; 1626 1627 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 1628 1629 memcpy(SharedMem1.buffer, (char *)&attributes, SharedMem1.size); 1630 1631 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1632 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1633 1634 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 1635 TeecOperation.params[1].tmpref.size = SharedMem1.size; 1636 1637 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 1638 TEEC_MEMREF_TEMP_INOUT, 1639 TEEC_NONE, 1640 TEEC_NONE); 1641 1642 TeecResult = TEEC_InvokeCommand(&TeecSession, 1643 1, 1644 &TeecOperation, 1645 &ErrorOrigin); 1646 1647 TEEC_ReleaseSharedMemory(&SharedMem0); 1648 TEEC_ReleaseSharedMemory(&SharedMem1); 1649 TEEC_CloseSession(&TeecSession); 1650 TEEC_FinalizeContext(&TeecContext); 1651 debug("testmm end\n"); 1652 1653 return TeecResult; 1654 } 1655 1656 uint32_t trusty_attest_dh(uint8_t *dh, uint32_t *dh_size) 1657 { 1658 TEEC_Result TeecResult; 1659 TEEC_Context TeecContext; 1660 TEEC_Session TeecSession; 1661 uint32_t ErrorOrigin; 1662 TEEC_UUID tempuuid = { 0x258be795, 0xf9ca, 0x40e6, 1663 { 0xa8, 0x69, 0x9c, 0xe6, 1664 0x88, 0x6c, 0x5d, 0x5d 1665 } 1666 }; 1667 TEEC_UUID *TeecUuid = &tempuuid; 1668 TEEC_Operation TeecOperation = {0}; 1669 struct blk_desc *dev_desc; 1670 dev_desc = rockchip_get_bootdev(); 1671 if (!dev_desc) { 1672 printf("%s: dev_desc is NULL!\n", __func__); 1673 return -TEEC_ERROR_GENERIC; 1674 } 1675 1676 OpteeClientApiLibInitialize(); 1677 1678 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1679 1680 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, 1681 TEEC_NONE, 1682 TEEC_NONE, 1683 TEEC_NONE); 1684 /*0 nand or emmc "security" partition , 1 rpmb*/ 1685 TeecOperation.params[0].value.a = (dev_desc->if_type == IF_TYPE_MMC) ? 1 : 0; 1686 #ifdef CONFIG_OPTEE_ALWAYS_USE_SECURITY_PARTITION 1687 TeecOperation.params[0].value.a = 0; 1688 #endif 1689 1690 TeecResult = TEEC_OpenSession(&TeecContext, 1691 &TeecSession, 1692 TeecUuid, 1693 TEEC_LOGIN_PUBLIC, 1694 NULL, 1695 &TeecOperation, 1696 &ErrorOrigin); 1697 1698 TEEC_SharedMemory SharedMem0 = {0}; 1699 1700 SharedMem0.size = *dh_size; 1701 SharedMem0.flags = 0; 1702 1703 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1704 1705 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1706 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1707 1708 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INOUT, 1709 TEEC_NONE, 1710 TEEC_NONE, 1711 TEEC_NONE); 1712 1713 TeecResult = TEEC_InvokeCommand(&TeecSession, 1714 143, 1715 &TeecOperation, 1716 &ErrorOrigin); 1717 1718 *dh_size = TeecOperation.params[0].tmpref.size; 1719 memcpy(dh, SharedMem0.buffer, SharedMem0.size); 1720 1721 TEEC_ReleaseSharedMemory(&SharedMem0); 1722 1723 TEEC_CloseSession(&TeecSession); 1724 TeecResult = TEEC_FinalizeContext(&TeecContext); 1725 1726 return TeecResult; 1727 } 1728 1729 uint32_t trusty_attest_uuid(uint8_t *uuid, uint32_t *uuid_size) 1730 { 1731 TEEC_Result TeecResult; 1732 TEEC_Context TeecContext; 1733 TEEC_Session TeecSession; 1734 uint32_t ErrorOrigin; 1735 TEEC_UUID tempuuid = { 0x258be795, 0xf9ca, 0x40e6, 1736 { 0xa8, 0x69, 0x9c, 0xe6, 1737 0x88, 0x6c, 0x5d, 0x5d 1738 } 1739 }; 1740 TEEC_UUID *TeecUuid = &tempuuid; 1741 TEEC_Operation TeecOperation = {0}; 1742 struct blk_desc *dev_desc; 1743 dev_desc = rockchip_get_bootdev(); 1744 if (!dev_desc) { 1745 printf("%s: dev_desc is NULL!\n", __func__); 1746 return -TEEC_ERROR_GENERIC; 1747 } 1748 1749 OpteeClientApiLibInitialize(); 1750 1751 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1752 1753 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, 1754 TEEC_NONE, 1755 TEEC_NONE, 1756 TEEC_NONE); 1757 /*0 nand or emmc "security" partition , 1 rpmb*/ 1758 TeecOperation.params[0].value.a = (dev_desc->if_type == IF_TYPE_MMC) ? 1 : 0; 1759 #ifdef CONFIG_OPTEE_ALWAYS_USE_SECURITY_PARTITION 1760 TeecOperation.params[0].value.a = 0; 1761 #endif 1762 1763 TeecResult = TEEC_OpenSession(&TeecContext, 1764 &TeecSession, 1765 TeecUuid, 1766 TEEC_LOGIN_PUBLIC, 1767 NULL, 1768 &TeecOperation, 1769 &ErrorOrigin); 1770 1771 TEEC_SharedMemory SharedMem0 = {0}; 1772 1773 SharedMem0.size = *uuid_size; 1774 SharedMem0.flags = 0; 1775 1776 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1777 1778 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1779 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1780 1781 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INOUT, 1782 TEEC_NONE, 1783 TEEC_NONE, 1784 TEEC_NONE); 1785 1786 TeecResult = TEEC_InvokeCommand(&TeecSession, 1787 144, 1788 &TeecOperation, 1789 &ErrorOrigin); 1790 1791 *uuid_size = TeecOperation.params[0].tmpref.size; 1792 memcpy(uuid, SharedMem0.buffer, SharedMem0.size); 1793 1794 TEEC_ReleaseSharedMemory(&SharedMem0); 1795 1796 TEEC_CloseSession(&TeecSession); 1797 TeecResult = TEEC_FinalizeContext(&TeecContext); 1798 1799 return TeecResult; 1800 } 1801 1802 uint32_t trusty_attest_get_ca(uint8_t *operation_start, 1803 uint32_t *operation_size, 1804 uint8_t *out, 1805 uint32_t *out_len) 1806 { 1807 TEEC_Result TeecResult; 1808 TEEC_Context TeecContext; 1809 TEEC_Session TeecSession; 1810 uint32_t ErrorOrigin; 1811 1812 OpteeClientApiLibInitialize(); 1813 1814 TEEC_UUID tempuuid = { 0x258be795, 0xf9ca, 0x40e6, 1815 { 0xa8, 0x69, 0x9c, 0xe6, 1816 0x88, 0x6c, 0x5d, 0x5d 1817 } 1818 }; 1819 1820 TEEC_UUID *TeecUuid = &tempuuid; 1821 TEEC_Operation TeecOperation = {0}; 1822 struct blk_desc *dev_desc; 1823 dev_desc = rockchip_get_bootdev(); 1824 if (!dev_desc) { 1825 printf("%s: dev_desc is NULL!\n", __func__); 1826 return -TEEC_ERROR_GENERIC; 1827 } 1828 1829 OpteeClientApiLibInitialize(); 1830 1831 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1832 1833 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, 1834 TEEC_NONE, 1835 TEEC_NONE, 1836 TEEC_NONE); 1837 /*0 nand or emmc "security" partition , 1 rpmb*/ 1838 TeecOperation.params[0].value.a = (dev_desc->if_type == IF_TYPE_MMC) ? 1 : 0; 1839 #ifdef CONFIG_OPTEE_ALWAYS_USE_SECURITY_PARTITION 1840 TeecOperation.params[0].value.a = 0; 1841 #endif 1842 1843 TeecResult = TEEC_OpenSession(&TeecContext, 1844 &TeecSession, 1845 TeecUuid, 1846 TEEC_LOGIN_PUBLIC, 1847 NULL, 1848 &TeecOperation, 1849 &ErrorOrigin); 1850 1851 TEEC_SharedMemory SharedMem0 = {0}; 1852 1853 SharedMem0.size = *operation_size; 1854 SharedMem0.flags = 0; 1855 1856 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1857 1858 memcpy(SharedMem0.buffer, operation_start, SharedMem0.size); 1859 1860 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1861 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1862 1863 TEEC_SharedMemory SharedMem1 = {0}; 1864 1865 SharedMem1.size = *out_len; 1866 SharedMem1.flags = 0; 1867 1868 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 1869 1870 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 1871 TeecOperation.params[1].tmpref.size = SharedMem1.size; 1872 1873 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INOUT, 1874 TEEC_MEMREF_TEMP_INOUT, 1875 TEEC_NONE, 1876 TEEC_NONE); 1877 1878 TeecResult = TEEC_InvokeCommand(&TeecSession, 1879 145, 1880 &TeecOperation, 1881 &ErrorOrigin); 1882 1883 *out_len = TeecOperation.params[1].tmpref.size; 1884 memcpy(out, SharedMem1.buffer, SharedMem1.size); 1885 TEEC_ReleaseSharedMemory(&SharedMem0); 1886 TEEC_ReleaseSharedMemory(&SharedMem1); 1887 1888 return TeecResult; 1889 } 1890 1891 uint32_t trusty_attest_set_ca(uint8_t *ca_response, uint32_t *ca_response_size) 1892 { 1893 TEEC_Result TeecResult; 1894 TEEC_Context TeecContext; 1895 TEEC_Session TeecSession; 1896 uint32_t ErrorOrigin; 1897 TEEC_UUID tempuuid = { 0x258be795, 0xf9ca, 0x40e6, 1898 { 0xa8, 0x69, 0x9c, 0xe6, 1899 0x88, 0x6c, 0x5d, 0x5d 1900 } 1901 }; 1902 TEEC_UUID *TeecUuid = &tempuuid; 1903 TEEC_Operation TeecOperation = {0}; 1904 struct blk_desc *dev_desc; 1905 dev_desc = rockchip_get_bootdev(); 1906 if (!dev_desc) { 1907 printf("%s: dev_desc is NULL!\n", __func__); 1908 return -TEEC_ERROR_GENERIC; 1909 } 1910 1911 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1912 1913 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, 1914 TEEC_NONE, 1915 TEEC_NONE, 1916 TEEC_NONE); 1917 /*0 nand or emmc "security" partition , 1 rpmb*/ 1918 TeecOperation.params[0].value.a = (dev_desc->if_type == IF_TYPE_MMC) ? 1 : 0; 1919 #ifdef CONFIG_OPTEE_ALWAYS_USE_SECURITY_PARTITION 1920 TeecOperation.params[0].value.a = 0; 1921 #endif 1922 1923 TeecResult = TEEC_OpenSession(&TeecContext, 1924 &TeecSession, 1925 TeecUuid, 1926 TEEC_LOGIN_PUBLIC, 1927 NULL, 1928 &TeecOperation, 1929 &ErrorOrigin); 1930 1931 TEEC_SharedMemory SharedMem0 = {0}; 1932 1933 SharedMem0.size = *ca_response_size; 1934 SharedMem0.flags = 0; 1935 1936 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1937 1938 memcpy(SharedMem0.buffer, ca_response, SharedMem0.size); 1939 1940 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1941 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1942 1943 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INOUT, 1944 TEEC_NONE, 1945 TEEC_NONE, 1946 TEEC_NONE); 1947 1948 TeecResult = TEEC_InvokeCommand(&TeecSession, 1949 146, 1950 &TeecOperation, 1951 &ErrorOrigin); 1952 1953 TEEC_ReleaseSharedMemory(&SharedMem0); 1954 1955 TEEC_CloseSession(&TeecSession); 1956 TeecResult = TEEC_FinalizeContext(&TeecContext); 1957 1958 return TeecResult; 1959 } 1960 1961 TEEC_Result trusty_write_oem_unlock(uint8_t unlock) 1962 { 1963 char *file = "oem.unlock"; 1964 TEEC_Result ret; 1965 1966 ret = write_to_keymaster((uint8_t *)file, strlen(file), 1967 (uint8_t *)&unlock, 1); 1968 return ret; 1969 } 1970 1971 TEEC_Result trusty_read_oem_unlock(uint8_t *unlock) 1972 { 1973 char *file = "oem.unlock"; 1974 TEEC_Result ret; 1975 1976 ret = read_from_keymaster((uint8_t *)file, strlen(file), 1977 unlock, 1); 1978 1979 if (ret == TEE_ERROR_ITEM_NOT_FOUND) { 1980 debug("init oem unlock status 0"); 1981 ret = trusty_write_oem_unlock(0); 1982 } 1983 1984 return ret; 1985 } 1986