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 = { 0x1b484ea5, 0x698b, 0x4142, 463 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 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 0, 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 = { 0x1b484ea5, 0x698b, 0x4142, 546 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 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 1, 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 = { 0x1b484ea5, 0x698b, 0x4142, 968 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 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 0, 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 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 1054 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 1055 TEEC_UUID *TeecUuid = &tempuuid; 1056 TEEC_Operation TeecOperation = {0}; 1057 struct blk_desc *dev_desc; 1058 dev_desc = rockchip_get_bootdev(); 1059 if (!dev_desc) { 1060 printf("%s: dev_desc is NULL!\n", __func__); 1061 return -TEEC_ERROR_GENERIC; 1062 } 1063 1064 debug("write_to_keymaster\n"); 1065 OpteeClientApiLibInitialize(); 1066 1067 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1068 1069 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, 1070 TEEC_NONE, 1071 TEEC_NONE, 1072 TEEC_NONE); 1073 /*0 nand or emmc "security" partition , 1 rpmb*/ 1074 TeecOperation.params[0].value.a = (dev_desc->if_type == IF_TYPE_MMC) ? 1 : 0; 1075 #ifdef CONFIG_OPTEE_ALWAYS_USE_SECURITY_PARTITION 1076 TeecOperation.params[0].value.a = 0; 1077 #endif 1078 1079 TeecResult = TEEC_OpenSession(&TeecContext, 1080 &TeecSession, 1081 TeecUuid, 1082 TEEC_LOGIN_PUBLIC, 1083 NULL, 1084 &TeecOperation, 1085 &ErrorOrigin); 1086 1087 TEEC_SharedMemory SharedMem0 = {0}; 1088 1089 SharedMem0.size = filename_size; 1090 SharedMem0.flags = 0; 1091 1092 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1093 1094 memcpy(SharedMem0.buffer, filename, SharedMem0.size); 1095 1096 TEEC_SharedMemory SharedMem1 = {0}; 1097 1098 SharedMem1.size = data_size; 1099 SharedMem1.flags = 0; 1100 1101 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 1102 1103 memcpy(SharedMem1.buffer, data, SharedMem1.size); 1104 1105 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1106 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1107 1108 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 1109 TeecOperation.params[1].tmpref.size = SharedMem1.size; 1110 1111 1112 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 1113 TEEC_MEMREF_TEMP_INOUT, 1114 TEEC_NONE, 1115 TEEC_NONE); 1116 1117 TeecResult = TEEC_InvokeCommand(&TeecSession, 1118 1, 1119 &TeecOperation, 1120 &ErrorOrigin); 1121 1122 TEEC_ReleaseSharedMemory(&SharedMem0); 1123 TEEC_ReleaseSharedMemory(&SharedMem1); 1124 TEEC_CloseSession(&TeecSession); 1125 TEEC_FinalizeContext(&TeecContext); 1126 debug("write_to_keymaster end\n"); 1127 debug("TeecResult %x\n", TeecResult); 1128 1129 return TeecResult; 1130 } 1131 1132 uint32_t trusty_read_attribute_hash(uint32_t *buf, uint32_t length) 1133 { 1134 TEEC_Result TeecResult; 1135 TEEC_Context TeecContext; 1136 TEEC_Session TeecSession; 1137 uint32_t ErrorOrigin; 1138 1139 TEEC_UUID tempuuid = { 0x2d26d8a8, 0x5134, 0x4dd8, \ 1140 { 0xb3, 0x2f, 0xb3, 0x4b, 0xce, 0xeb, 0xc4, 0x71 } }; 1141 TEEC_UUID *TeecUuid = &tempuuid; 1142 TEEC_Operation TeecOperation = {0}; 1143 1144 OpteeClientApiLibInitialize(); 1145 1146 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1147 1148 TeecResult = TEEC_OpenSession(&TeecContext, 1149 &TeecSession, 1150 TeecUuid, 1151 TEEC_LOGIN_PUBLIC, 1152 NULL, 1153 NULL, 1154 &ErrorOrigin); 1155 1156 TEEC_SharedMemory SharedMem0 = {0}; 1157 1158 SharedMem0.size = length * sizeof(uint32_t); 1159 SharedMem0.flags = 0; 1160 1161 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1162 1163 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1164 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1165 1166 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_OUTPUT, 1167 TEEC_NONE, 1168 TEEC_NONE, 1169 TEEC_NONE); 1170 1171 TeecResult = TEEC_InvokeCommand(&TeecSession, 1172 0, 1173 &TeecOperation, 1174 &ErrorOrigin); 1175 1176 if (TeecResult == TEEC_SUCCESS) 1177 memcpy(buf, SharedMem0.buffer, SharedMem0.size); 1178 1179 TEEC_ReleaseSharedMemory(&SharedMem0); 1180 TEEC_CloseSession(&TeecSession); 1181 TEEC_FinalizeContext(&TeecContext); 1182 1183 return TeecResult; 1184 } 1185 1186 uint32_t trusty_write_attribute_hash(uint32_t *buf, uint32_t length) 1187 { 1188 TEEC_Result TeecResult; 1189 TEEC_Context TeecContext; 1190 TEEC_Session TeecSession; 1191 uint32_t ErrorOrigin; 1192 1193 TEEC_UUID tempuuid = { 0x2d26d8a8, 0x5134, 0x4dd8, \ 1194 { 0xb3, 0x2f, 0xb3, 0x4b, 0xce, 0xeb, 0xc4, 0x71 } }; 1195 TEEC_UUID *TeecUuid = &tempuuid; 1196 TEEC_Operation TeecOperation = {0}; 1197 1198 OpteeClientApiLibInitialize(); 1199 1200 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1201 1202 TeecResult = TEEC_OpenSession(&TeecContext, 1203 &TeecSession, 1204 TeecUuid, 1205 TEEC_LOGIN_PUBLIC, 1206 NULL, 1207 NULL, 1208 &ErrorOrigin); 1209 1210 TEEC_SharedMemory SharedMem0 = {0}; 1211 1212 SharedMem0.size = length * sizeof(uint32_t); 1213 SharedMem0.flags = 0; 1214 1215 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1216 1217 memcpy(SharedMem0.buffer, buf, SharedMem0.size); 1218 1219 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1220 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1221 1222 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 1223 TEEC_NONE, 1224 TEEC_NONE, 1225 TEEC_NONE); 1226 1227 TeecResult = TEEC_InvokeCommand(&TeecSession, 1228 1, 1229 &TeecOperation, 1230 &ErrorOrigin); 1231 1232 TEEC_ReleaseSharedMemory(&SharedMem0); 1233 TEEC_CloseSession(&TeecSession); 1234 TEEC_FinalizeContext(&TeecContext); 1235 1236 return TeecResult; 1237 } 1238 1239 uint32_t notify_optee_rpmb_ta(void) 1240 { 1241 TEEC_Result TeecResult; 1242 TEEC_Context TeecContext; 1243 TEEC_Session TeecSession; 1244 uint32_t ErrorOrigin; 1245 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 1246 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 1247 TEEC_UUID *TeecUuid = &tempuuid; 1248 TEEC_Operation TeecOperation = {0}; 1249 1250 OpteeClientApiLibInitialize(); 1251 1252 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1253 1254 TeecResult = TEEC_OpenSession(&TeecContext, 1255 &TeecSession, 1256 TeecUuid, 1257 TEEC_LOGIN_PUBLIC, 1258 NULL, 1259 NULL, 1260 &ErrorOrigin); 1261 1262 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, 1263 TEEC_NONE, 1264 TEEC_NONE, 1265 TEEC_NONE); 1266 1267 TeecResult = TEEC_InvokeCommand(&TeecSession, 1268 2, 1269 &TeecOperation, 1270 &ErrorOrigin); 1271 1272 TEEC_CloseSession(&TeecSession); 1273 TEEC_FinalizeContext(&TeecContext); 1274 1275 return TeecResult; 1276 } 1277 1278 uint32_t notify_optee_efuse_ta(void) 1279 { 1280 TEEC_Result TeecResult; 1281 TEEC_Context TeecContext; 1282 TEEC_Session TeecSession; 1283 uint32_t ErrorOrigin; 1284 TEEC_UUID tempuuid = { 0x2d26d8a8, 0x5134, 0x4dd8, \ 1285 { 0xb3, 0x2f, 0xb3, 0x4b, 0xce, 0xeb, 0xc4, 0x71 } }; 1286 1287 TEEC_UUID *TeecUuid = &tempuuid; 1288 TEEC_Operation TeecOperation = {0}; 1289 1290 OpteeClientApiLibInitialize(); 1291 1292 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1293 1294 TeecResult = TEEC_OpenSession(&TeecContext, 1295 &TeecSession, 1296 TeecUuid, 1297 TEEC_LOGIN_PUBLIC, 1298 NULL, 1299 NULL, 1300 &ErrorOrigin); 1301 1302 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, 1303 TEEC_NONE, 1304 TEEC_NONE, 1305 TEEC_NONE); 1306 1307 TeecResult = TEEC_InvokeCommand(&TeecSession, 1308 2, 1309 &TeecOperation, 1310 &ErrorOrigin); 1311 1312 TEEC_CloseSession(&TeecSession); 1313 TEEC_FinalizeContext(&TeecContext); 1314 1315 return TeecResult; 1316 } 1317 1318 uint32_t trusty_notify_optee_uboot_end(void) 1319 { 1320 TEEC_Result res; 1321 res = notify_optee_rpmb_ta(); 1322 res |= notify_optee_efuse_ta(); 1323 return res; 1324 } 1325 1326 uint32_t trusty_read_vbootkey_hash(uint32_t *buf, uint32_t length) 1327 { 1328 TEEC_Result TeecResult; 1329 TEEC_Context TeecContext; 1330 TEEC_Session TeecSession; 1331 uint32_t ErrorOrigin; 1332 1333 TEEC_UUID tempuuid = { 0x2d26d8a8, 0x5134, 0x4dd8, \ 1334 { 0xb3, 0x2f, 0xb3, 0x4b, 0xce, 0xeb, 0xc4, 0x71 } }; 1335 TEEC_UUID *TeecUuid = &tempuuid; 1336 TEEC_Operation TeecOperation = {0}; 1337 1338 OpteeClientApiLibInitialize(); 1339 1340 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1341 1342 TeecResult = TEEC_OpenSession(&TeecContext, 1343 &TeecSession, 1344 TeecUuid, 1345 TEEC_LOGIN_PUBLIC, 1346 NULL, 1347 NULL, 1348 &ErrorOrigin); 1349 1350 TEEC_SharedMemory SharedMem0 = {0}; 1351 1352 SharedMem0.size = length * sizeof(uint32_t); 1353 SharedMem0.flags = 0; 1354 1355 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1356 1357 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1358 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1359 1360 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_OUTPUT, 1361 TEEC_NONE, 1362 TEEC_NONE, 1363 TEEC_NONE); 1364 1365 TeecResult = TEEC_InvokeCommand(&TeecSession, 1366 3, 1367 &TeecOperation, 1368 &ErrorOrigin); 1369 1370 if (TeecResult == TEEC_SUCCESS) 1371 memcpy(buf, SharedMem0.buffer, SharedMem0.size); 1372 1373 TEEC_ReleaseSharedMemory(&SharedMem0); 1374 TEEC_CloseSession(&TeecSession); 1375 TEEC_FinalizeContext(&TeecContext); 1376 1377 return TeecResult; 1378 } 1379 uint32_t trusty_write_vbootkey_hash(uint32_t *buf, uint32_t length) 1380 { 1381 TEEC_Result TeecResult; 1382 TEEC_Context TeecContext; 1383 TEEC_Session TeecSession; 1384 uint32_t ErrorOrigin; 1385 1386 TEEC_UUID tempuuid = { 0x2d26d8a8, 0x5134, 0x4dd8, \ 1387 { 0xb3, 0x2f, 0xb3, 0x4b, 0xce, 0xeb, 0xc4, 0x71 } }; 1388 TEEC_UUID *TeecUuid = &tempuuid; 1389 TEEC_Operation TeecOperation = {0}; 1390 1391 OpteeClientApiLibInitialize(); 1392 1393 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1394 1395 TeecResult = TEEC_OpenSession(&TeecContext, 1396 &TeecSession, 1397 TeecUuid, 1398 TEEC_LOGIN_PUBLIC, 1399 NULL, 1400 NULL, 1401 &ErrorOrigin); 1402 1403 TEEC_SharedMemory SharedMem0 = {0}; 1404 1405 SharedMem0.size = length * sizeof(uint32_t); 1406 SharedMem0.flags = 0; 1407 1408 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1409 1410 memcpy(SharedMem0.buffer, buf, SharedMem0.size); 1411 1412 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1413 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1414 1415 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 1416 TEEC_NONE, 1417 TEEC_NONE, 1418 TEEC_NONE); 1419 1420 TeecResult = TEEC_InvokeCommand(&TeecSession, 1421 4, 1422 &TeecOperation, 1423 &ErrorOrigin); 1424 1425 TEEC_ReleaseSharedMemory(&SharedMem0); 1426 TEEC_CloseSession(&TeecSession); 1427 TEEC_FinalizeContext(&TeecContext); 1428 1429 return TeecResult; 1430 } 1431 1432 uint32_t trusty_read_vbootkey_enable_flag(uint8_t *flag) 1433 { 1434 TEEC_Result TeecResult; 1435 TEEC_Context TeecContext; 1436 TEEC_Session TeecSession; 1437 uint32_t ErrorOrigin; 1438 uint32_t bootflag; 1439 1440 TEEC_UUID tempuuid = { 0x2d26d8a8, 0x5134, 0x4dd8, \ 1441 { 0xb3, 0x2f, 0xb3, 0x4b, 0xce, 0xeb, 0xc4, 0x71 } }; 1442 TEEC_UUID *TeecUuid = &tempuuid; 1443 TEEC_Operation TeecOperation = {0}; 1444 1445 OpteeClientApiLibInitialize(); 1446 1447 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1448 1449 TeecResult = TEEC_OpenSession(&TeecContext, 1450 &TeecSession, 1451 TeecUuid, 1452 TEEC_LOGIN_PUBLIC, 1453 NULL, 1454 NULL, 1455 &ErrorOrigin); 1456 1457 TEEC_SharedMemory SharedMem0 = {0}; 1458 1459 SharedMem0.size = 1 * sizeof(uint32_t); 1460 SharedMem0.flags = 0; 1461 1462 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1463 1464 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1465 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1466 1467 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_OUTPUT, 1468 TEEC_NONE, 1469 TEEC_NONE, 1470 TEEC_NONE); 1471 1472 TeecResult = TEEC_InvokeCommand(&TeecSession, 1473 5, 1474 &TeecOperation, 1475 &ErrorOrigin); 1476 1477 if (TeecResult == TEEC_SUCCESS) { 1478 memcpy(&bootflag, SharedMem0.buffer, SharedMem0.size); 1479 if (bootflag == 0x000000FF) 1480 *flag = 1; 1481 } 1482 1483 TEEC_ReleaseSharedMemory(&SharedMem0); 1484 TEEC_CloseSession(&TeecSession); 1485 TEEC_FinalizeContext(&TeecContext); 1486 1487 return TeecResult; 1488 } 1489 1490 uint32_t trusty_read_permanent_attributes_flag(uint8_t *attributes) 1491 { 1492 TEEC_Result TeecResult; 1493 TEEC_Context TeecContext; 1494 TEEC_Session TeecSession; 1495 uint32_t ErrorOrigin; 1496 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 1497 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 1498 TEEC_UUID *TeecUuid = &tempuuid; 1499 TEEC_Operation TeecOperation = {0}; 1500 struct blk_desc *dev_desc; 1501 dev_desc = rockchip_get_bootdev(); 1502 if (!dev_desc) { 1503 printf("%s: dev_desc is NULL!\n", __func__); 1504 return -TEEC_ERROR_GENERIC; 1505 } 1506 1507 debug("testmm start\n"); 1508 OpteeClientApiLibInitialize(); 1509 1510 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1511 1512 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, 1513 TEEC_NONE, 1514 TEEC_NONE, 1515 TEEC_NONE); 1516 /*0 nand or emmc "security" partition , 1 rpmb*/ 1517 TeecOperation.params[0].value.a = (dev_desc->if_type == IF_TYPE_MMC) ? 1 : 0; 1518 #ifdef CONFIG_OPTEE_ALWAYS_USE_SECURITY_PARTITION 1519 TeecOperation.params[0].value.a = 0; 1520 #endif 1521 1522 TeecResult = TEEC_OpenSession(&TeecContext, 1523 &TeecSession, 1524 TeecUuid, 1525 TEEC_LOGIN_PUBLIC, 1526 NULL, 1527 &TeecOperation, 1528 &ErrorOrigin); 1529 1530 TEEC_SharedMemory SharedMem0 = {0}; 1531 1532 SharedMem0.size = sizeof("attributes_flag"); 1533 SharedMem0.flags = 0; 1534 1535 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1536 1537 memcpy(SharedMem0.buffer, "attributes_flag", SharedMem0.size); 1538 1539 TEEC_SharedMemory SharedMem1 = {0}; 1540 1541 SharedMem1.size = 1; 1542 SharedMem1.flags = 0; 1543 1544 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 1545 1546 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1547 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1548 1549 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 1550 TeecOperation.params[1].tmpref.size = SharedMem1.size; 1551 1552 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 1553 TEEC_MEMREF_TEMP_INOUT, 1554 TEEC_NONE, 1555 TEEC_NONE); 1556 1557 TeecResult = TEEC_InvokeCommand(&TeecSession, 1558 0, 1559 &TeecOperation, 1560 &ErrorOrigin); 1561 if (TeecResult == TEEC_SUCCESS) 1562 memcpy(attributes, SharedMem1.buffer, SharedMem1.size); 1563 TEEC_ReleaseSharedMemory(&SharedMem0); 1564 TEEC_ReleaseSharedMemory(&SharedMem1); 1565 TEEC_CloseSession(&TeecSession); 1566 TEEC_FinalizeContext(&TeecContext); 1567 debug("testmm end\n"); 1568 1569 return TeecResult; 1570 } 1571 1572 uint32_t trusty_write_permanent_attributes_flag(uint8_t attributes) 1573 { 1574 TEEC_Result TeecResult; 1575 TEEC_Context TeecContext; 1576 TEEC_Session TeecSession; 1577 uint32_t ErrorOrigin; 1578 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 1579 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 1580 TEEC_UUID *TeecUuid = &tempuuid; 1581 TEEC_Operation TeecOperation = {0}; 1582 struct blk_desc *dev_desc; 1583 dev_desc = rockchip_get_bootdev(); 1584 if (!dev_desc) { 1585 printf("%s: dev_desc is NULL!\n", __func__); 1586 return -TEEC_ERROR_GENERIC; 1587 } 1588 1589 debug("testmm start\n"); 1590 OpteeClientApiLibInitialize(); 1591 1592 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1593 1594 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, 1595 TEEC_NONE, 1596 TEEC_NONE, 1597 TEEC_NONE); 1598 /*0 nand or emmc "security" partition , 1 rpmb*/ 1599 TeecOperation.params[0].value.a = (dev_desc->if_type == IF_TYPE_MMC) ? 1 : 0; 1600 #ifdef CONFIG_OPTEE_ALWAYS_USE_SECURITY_PARTITION 1601 TeecOperation.params[0].value.a = 0; 1602 #endif 1603 1604 TeecResult = TEEC_OpenSession(&TeecContext, 1605 &TeecSession, 1606 TeecUuid, 1607 TEEC_LOGIN_PUBLIC, 1608 NULL, 1609 &TeecOperation, 1610 &ErrorOrigin); 1611 1612 TEEC_SharedMemory SharedMem0 = {0}; 1613 1614 SharedMem0.size = sizeof("attributes_flag"); 1615 SharedMem0.flags = 0; 1616 1617 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1618 1619 memcpy(SharedMem0.buffer, "attributes_flag", SharedMem0.size); 1620 1621 TEEC_SharedMemory SharedMem1 = {0}; 1622 1623 SharedMem1.size = 1; 1624 SharedMem1.flags = 0; 1625 1626 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 1627 1628 memcpy(SharedMem1.buffer, (char *)&attributes, SharedMem1.size); 1629 1630 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1631 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1632 1633 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 1634 TeecOperation.params[1].tmpref.size = SharedMem1.size; 1635 1636 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 1637 TEEC_MEMREF_TEMP_INOUT, 1638 TEEC_NONE, 1639 TEEC_NONE); 1640 1641 TeecResult = TEEC_InvokeCommand(&TeecSession, 1642 1, 1643 &TeecOperation, 1644 &ErrorOrigin); 1645 1646 TEEC_ReleaseSharedMemory(&SharedMem0); 1647 TEEC_ReleaseSharedMemory(&SharedMem1); 1648 TEEC_CloseSession(&TeecSession); 1649 TEEC_FinalizeContext(&TeecContext); 1650 debug("testmm end\n"); 1651 1652 return TeecResult; 1653 } 1654 1655 uint32_t trusty_attest_dh(uint8_t *dh, uint32_t *dh_size) 1656 { 1657 TEEC_Result TeecResult; 1658 TEEC_Context TeecContext; 1659 TEEC_Session TeecSession; 1660 uint32_t ErrorOrigin; 1661 TEEC_UUID tempuuid = { 0x258be795, 0xf9ca, 0x40e6, 1662 { 0xa8, 0x69, 0x9c, 0xe6, 1663 0x88, 0x6c, 0x5d, 0x5d 1664 } 1665 }; 1666 TEEC_UUID *TeecUuid = &tempuuid; 1667 TEEC_Operation TeecOperation = {0}; 1668 struct blk_desc *dev_desc; 1669 dev_desc = rockchip_get_bootdev(); 1670 if (!dev_desc) { 1671 printf("%s: dev_desc is NULL!\n", __func__); 1672 return -TEEC_ERROR_GENERIC; 1673 } 1674 1675 OpteeClientApiLibInitialize(); 1676 1677 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1678 1679 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, 1680 TEEC_NONE, 1681 TEEC_NONE, 1682 TEEC_NONE); 1683 /*0 nand or emmc "security" partition , 1 rpmb*/ 1684 TeecOperation.params[0].value.a = (dev_desc->if_type == IF_TYPE_MMC) ? 1 : 0; 1685 #ifdef CONFIG_OPTEE_ALWAYS_USE_SECURITY_PARTITION 1686 TeecOperation.params[0].value.a = 0; 1687 #endif 1688 1689 TeecResult = TEEC_OpenSession(&TeecContext, 1690 &TeecSession, 1691 TeecUuid, 1692 TEEC_LOGIN_PUBLIC, 1693 NULL, 1694 &TeecOperation, 1695 &ErrorOrigin); 1696 1697 TEEC_SharedMemory SharedMem0 = {0}; 1698 1699 SharedMem0.size = *dh_size; 1700 SharedMem0.flags = 0; 1701 1702 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1703 1704 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1705 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1706 1707 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INOUT, 1708 TEEC_NONE, 1709 TEEC_NONE, 1710 TEEC_NONE); 1711 1712 TeecResult = TEEC_InvokeCommand(&TeecSession, 1713 143, 1714 &TeecOperation, 1715 &ErrorOrigin); 1716 1717 *dh_size = TeecOperation.params[0].tmpref.size; 1718 memcpy(dh, SharedMem0.buffer, SharedMem0.size); 1719 1720 TEEC_ReleaseSharedMemory(&SharedMem0); 1721 1722 TEEC_CloseSession(&TeecSession); 1723 TeecResult = TEEC_FinalizeContext(&TeecContext); 1724 1725 return TeecResult; 1726 } 1727 1728 uint32_t trusty_attest_uuid(uint8_t *uuid, uint32_t *uuid_size) 1729 { 1730 TEEC_Result TeecResult; 1731 TEEC_Context TeecContext; 1732 TEEC_Session TeecSession; 1733 uint32_t ErrorOrigin; 1734 TEEC_UUID tempuuid = { 0x258be795, 0xf9ca, 0x40e6, 1735 { 0xa8, 0x69, 0x9c, 0xe6, 1736 0x88, 0x6c, 0x5d, 0x5d 1737 } 1738 }; 1739 TEEC_UUID *TeecUuid = &tempuuid; 1740 TEEC_Operation TeecOperation = {0}; 1741 struct blk_desc *dev_desc; 1742 dev_desc = rockchip_get_bootdev(); 1743 if (!dev_desc) { 1744 printf("%s: dev_desc is NULL!\n", __func__); 1745 return -TEEC_ERROR_GENERIC; 1746 } 1747 1748 OpteeClientApiLibInitialize(); 1749 1750 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1751 1752 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, 1753 TEEC_NONE, 1754 TEEC_NONE, 1755 TEEC_NONE); 1756 /*0 nand or emmc "security" partition , 1 rpmb*/ 1757 TeecOperation.params[0].value.a = (dev_desc->if_type == IF_TYPE_MMC) ? 1 : 0; 1758 #ifdef CONFIG_OPTEE_ALWAYS_USE_SECURITY_PARTITION 1759 TeecOperation.params[0].value.a = 0; 1760 #endif 1761 1762 TeecResult = TEEC_OpenSession(&TeecContext, 1763 &TeecSession, 1764 TeecUuid, 1765 TEEC_LOGIN_PUBLIC, 1766 NULL, 1767 &TeecOperation, 1768 &ErrorOrigin); 1769 1770 TEEC_SharedMemory SharedMem0 = {0}; 1771 1772 SharedMem0.size = *uuid_size; 1773 SharedMem0.flags = 0; 1774 1775 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1776 1777 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1778 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1779 1780 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INOUT, 1781 TEEC_NONE, 1782 TEEC_NONE, 1783 TEEC_NONE); 1784 1785 TeecResult = TEEC_InvokeCommand(&TeecSession, 1786 144, 1787 &TeecOperation, 1788 &ErrorOrigin); 1789 1790 *uuid_size = TeecOperation.params[0].tmpref.size; 1791 memcpy(uuid, SharedMem0.buffer, SharedMem0.size); 1792 1793 TEEC_ReleaseSharedMemory(&SharedMem0); 1794 1795 TEEC_CloseSession(&TeecSession); 1796 TeecResult = TEEC_FinalizeContext(&TeecContext); 1797 1798 return TeecResult; 1799 } 1800 1801 uint32_t trusty_attest_get_ca(uint8_t *operation_start, 1802 uint32_t *operation_size, 1803 uint8_t *out, 1804 uint32_t *out_len) 1805 { 1806 TEEC_Result TeecResult; 1807 TEEC_Context TeecContext; 1808 TEEC_Session TeecSession; 1809 uint32_t ErrorOrigin; 1810 1811 OpteeClientApiLibInitialize(); 1812 1813 TEEC_UUID tempuuid = { 0x258be795, 0xf9ca, 0x40e6, 1814 { 0xa8, 0x69, 0x9c, 0xe6, 1815 0x88, 0x6c, 0x5d, 0x5d 1816 } 1817 }; 1818 1819 TEEC_UUID *TeecUuid = &tempuuid; 1820 TEEC_Operation TeecOperation = {0}; 1821 struct blk_desc *dev_desc; 1822 dev_desc = rockchip_get_bootdev(); 1823 if (!dev_desc) { 1824 printf("%s: dev_desc is NULL!\n", __func__); 1825 return -TEEC_ERROR_GENERIC; 1826 } 1827 1828 OpteeClientApiLibInitialize(); 1829 1830 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1831 1832 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, 1833 TEEC_NONE, 1834 TEEC_NONE, 1835 TEEC_NONE); 1836 /*0 nand or emmc "security" partition , 1 rpmb*/ 1837 TeecOperation.params[0].value.a = (dev_desc->if_type == IF_TYPE_MMC) ? 1 : 0; 1838 #ifdef CONFIG_OPTEE_ALWAYS_USE_SECURITY_PARTITION 1839 TeecOperation.params[0].value.a = 0; 1840 #endif 1841 1842 TeecResult = TEEC_OpenSession(&TeecContext, 1843 &TeecSession, 1844 TeecUuid, 1845 TEEC_LOGIN_PUBLIC, 1846 NULL, 1847 &TeecOperation, 1848 &ErrorOrigin); 1849 1850 TEEC_SharedMemory SharedMem0 = {0}; 1851 1852 SharedMem0.size = *operation_size; 1853 SharedMem0.flags = 0; 1854 1855 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1856 1857 memcpy(SharedMem0.buffer, operation_start, SharedMem0.size); 1858 1859 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1860 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1861 1862 TEEC_SharedMemory SharedMem1 = {0}; 1863 1864 SharedMem1.size = *out_len; 1865 SharedMem1.flags = 0; 1866 1867 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 1868 1869 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 1870 TeecOperation.params[1].tmpref.size = SharedMem1.size; 1871 1872 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INOUT, 1873 TEEC_MEMREF_TEMP_INOUT, 1874 TEEC_NONE, 1875 TEEC_NONE); 1876 1877 TeecResult = TEEC_InvokeCommand(&TeecSession, 1878 145, 1879 &TeecOperation, 1880 &ErrorOrigin); 1881 1882 *out_len = TeecOperation.params[1].tmpref.size; 1883 memcpy(out, SharedMem1.buffer, SharedMem1.size); 1884 TEEC_ReleaseSharedMemory(&SharedMem0); 1885 TEEC_ReleaseSharedMemory(&SharedMem1); 1886 1887 return TeecResult; 1888 } 1889 1890 uint32_t trusty_attest_set_ca(uint8_t *ca_response, uint32_t *ca_response_size) 1891 { 1892 TEEC_Result TeecResult; 1893 TEEC_Context TeecContext; 1894 TEEC_Session TeecSession; 1895 uint32_t ErrorOrigin; 1896 TEEC_UUID tempuuid = { 0x258be795, 0xf9ca, 0x40e6, 1897 { 0xa8, 0x69, 0x9c, 0xe6, 1898 0x88, 0x6c, 0x5d, 0x5d 1899 } 1900 }; 1901 TEEC_UUID *TeecUuid = &tempuuid; 1902 TEEC_Operation TeecOperation = {0}; 1903 struct blk_desc *dev_desc; 1904 dev_desc = rockchip_get_bootdev(); 1905 if (!dev_desc) { 1906 printf("%s: dev_desc is NULL!\n", __func__); 1907 return -TEEC_ERROR_GENERIC; 1908 } 1909 1910 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1911 1912 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, 1913 TEEC_NONE, 1914 TEEC_NONE, 1915 TEEC_NONE); 1916 /*0 nand or emmc "security" partition , 1 rpmb*/ 1917 TeecOperation.params[0].value.a = (dev_desc->if_type == IF_TYPE_MMC) ? 1 : 0; 1918 #ifdef CONFIG_OPTEE_ALWAYS_USE_SECURITY_PARTITION 1919 TeecOperation.params[0].value.a = 0; 1920 #endif 1921 1922 TeecResult = TEEC_OpenSession(&TeecContext, 1923 &TeecSession, 1924 TeecUuid, 1925 TEEC_LOGIN_PUBLIC, 1926 NULL, 1927 &TeecOperation, 1928 &ErrorOrigin); 1929 1930 TEEC_SharedMemory SharedMem0 = {0}; 1931 1932 SharedMem0.size = *ca_response_size; 1933 SharedMem0.flags = 0; 1934 1935 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1936 1937 memcpy(SharedMem0.buffer, ca_response, SharedMem0.size); 1938 1939 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1940 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1941 1942 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INOUT, 1943 TEEC_NONE, 1944 TEEC_NONE, 1945 TEEC_NONE); 1946 1947 TeecResult = TEEC_InvokeCommand(&TeecSession, 1948 146, 1949 &TeecOperation, 1950 &ErrorOrigin); 1951 1952 TEEC_ReleaseSharedMemory(&SharedMem0); 1953 1954 TEEC_CloseSession(&TeecSession); 1955 TeecResult = TEEC_FinalizeContext(&TeecContext); 1956 1957 return TeecResult; 1958 } 1959 1960 TEEC_Result trusty_write_oem_unlock(uint8_t unlock) 1961 { 1962 char *file = "oem.unlock"; 1963 TEEC_Result ret; 1964 1965 ret = write_to_keymaster((uint8_t *)file, strlen(file), 1966 (uint8_t *)&unlock, 1); 1967 return ret; 1968 } 1969 1970 TEEC_Result trusty_read_oem_unlock(uint8_t *unlock) 1971 { 1972 char *file = "oem.unlock"; 1973 TEEC_Result ret; 1974 1975 ret = read_from_keymaster((uint8_t *)file, strlen(file), 1976 unlock, 1); 1977 1978 if (ret == TEE_ERROR_ITEM_NOT_FOUND) { 1979 debug("init oem unlock status 0"); 1980 ret = trusty_write_oem_unlock(0); 1981 } 1982 1983 return ret; 1984 } 1985