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