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