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