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