TianoCore EDK2 master
Loading...
Searching...
No Matches
DxeTcgPhysicalPresenceLib.c
Go to the documentation of this file.
1
16#include <PiDxe.h>
17
18#include <Protocol/TcgService.h>
19#include <Protocol/VariableLock.h>
20#include <Library/DebugLib.h>
21#include <Library/BaseMemoryLib.h>
22#include <Library/UefiRuntimeServicesTableLib.h>
23#include <Library/UefiDriverEntryPoint.h>
24#include <Library/UefiBootServicesTableLib.h>
25#include <Library/UefiLib.h>
26#include <Library/MemoryAllocationLib.h>
27#include <Library/PrintLib.h>
28#include <Library/HiiLib.h>
29#include <Guid/EventGroup.h>
30#include <Guid/PhysicalPresenceData.h>
31#include <Library/TcgPpVendorLib.h>
32
33#define CONFIRM_BUFFER_SIZE 4096
34
35EFI_HII_HANDLE mPpStringPackHandle;
36
46CHAR16 *
47PhysicalPresenceGetStringById (
48 IN EFI_STRING_ID Id
49 )
50{
51 return HiiGetString (mPpStringPackHandle, Id, NULL);
52}
53
65EFI_STATUS
66GetTpmCapability (
67 IN EFI_TCG_PROTOCOL *TcgProtocol,
68 OUT BOOLEAN *LifetimeLock,
69 OUT BOOLEAN *CmdEnable
70 )
71{
72 EFI_STATUS Status;
73 TPM_RQU_COMMAND_HDR *TpmRqu;
74 TPM_RSP_COMMAND_HDR *TpmRsp;
75 UINT32 *SendBufPtr;
76 UINT8 SendBuffer[sizeof (*TpmRqu) + sizeof (UINT32) * 3];
77 TPM_PERMANENT_FLAGS *TpmPermanentFlags;
78 UINT8 RecvBuffer[40];
79
80 //
81 // Fill request header
82 //
83 TpmRsp = (TPM_RSP_COMMAND_HDR *)RecvBuffer;
84 TpmRqu = (TPM_RQU_COMMAND_HDR *)SendBuffer;
85
86 TpmRqu->tag = SwapBytes16 (TPM_TAG_RQU_COMMAND);
87 TpmRqu->paramSize = SwapBytes32 (sizeof (SendBuffer));
88 TpmRqu->ordinal = SwapBytes32 (TPM_ORD_GetCapability);
89
90 //
91 // Set request parameter
92 //
93 SendBufPtr = (UINT32 *)(TpmRqu + 1);
94 WriteUnaligned32 (SendBufPtr++, SwapBytes32 (TPM_CAP_FLAG));
95 WriteUnaligned32 (SendBufPtr++, SwapBytes32 (sizeof (TPM_CAP_FLAG_PERMANENT)));
96 WriteUnaligned32 (SendBufPtr, SwapBytes32 (TPM_CAP_FLAG_PERMANENT));
97
98 Status = TcgProtocol->PassThroughToTpm (
99 TcgProtocol,
100 sizeof (SendBuffer),
101 (UINT8 *)TpmRqu,
102 sizeof (RecvBuffer),
103 (UINT8 *)&RecvBuffer
104 );
105 if (EFI_ERROR (Status)) {
106 return Status;
107 }
108
109 if ((TpmRsp->tag != SwapBytes16 (TPM_TAG_RSP_COMMAND)) || (TpmRsp->returnCode != 0)) {
110 return EFI_DEVICE_ERROR;
111 }
112
113 TpmPermanentFlags = (TPM_PERMANENT_FLAGS *)&RecvBuffer[sizeof (TPM_RSP_COMMAND_HDR) + sizeof (UINT32)];
114
115 if (LifetimeLock != NULL) {
116 *LifetimeLock = TpmPermanentFlags->physicalPresenceLifetimeLock;
117 }
118
119 if (CmdEnable != NULL) {
120 *CmdEnable = TpmPermanentFlags->physicalPresenceCMDEnable;
121 }
122
123 return Status;
124}
125
137EFI_STATUS
138TpmPhysicalPresence (
139 IN EFI_TCG_PROTOCOL *TcgProtocol,
140 IN TPM_PHYSICAL_PRESENCE PhysicalPresence
141 )
142{
143 EFI_STATUS Status;
144 TPM_RQU_COMMAND_HDR *TpmRqu;
145 TPM_PHYSICAL_PRESENCE *TpmPp;
146 TPM_RSP_COMMAND_HDR TpmRsp;
147 UINT8 Buffer[sizeof (*TpmRqu) + sizeof (*TpmPp)];
148
149 TpmRqu = (TPM_RQU_COMMAND_HDR *)Buffer;
150 TpmPp = (TPM_PHYSICAL_PRESENCE *)(TpmRqu + 1);
151
152 TpmRqu->tag = SwapBytes16 (TPM_TAG_RQU_COMMAND);
153 TpmRqu->paramSize = SwapBytes32 (sizeof (Buffer));
154 TpmRqu->ordinal = SwapBytes32 (TSC_ORD_PhysicalPresence);
155 WriteUnaligned16 (TpmPp, (TPM_PHYSICAL_PRESENCE)SwapBytes16 (PhysicalPresence));
156
157 Status = TcgProtocol->PassThroughToTpm (
158 TcgProtocol,
159 sizeof (Buffer),
160 (UINT8 *)TpmRqu,
161 sizeof (TpmRsp),
162 (UINT8 *)&TpmRsp
163 );
164 if (EFI_ERROR (Status)) {
165 return Status;
166 }
167
168 if (TpmRsp.tag != SwapBytes16 (TPM_TAG_RSP_COMMAND)) {
169 return EFI_DEVICE_ERROR;
170 }
171
172 if (TpmRsp.returnCode != 0) {
173 //
174 // If it fails, some requirements may be needed for this command.
175 //
176 return EFI_SECURITY_VIOLATION;
177 }
178
179 return Status;
180}
181
195UINT32
196TpmCommandNoReturnData (
197 IN EFI_TCG_PROTOCOL *TcgProtocol,
198 IN TPM_COMMAND_CODE Ordinal,
199 IN UINTN AdditionalParameterSize,
200 IN VOID *AdditionalParameters
201 )
202{
203 EFI_STATUS Status;
204 TPM_RQU_COMMAND_HDR *TpmRqu;
205 TPM_RSP_COMMAND_HDR TpmRsp;
206 UINT32 Size;
207
208 TpmRqu = (TPM_RQU_COMMAND_HDR *)AllocatePool (sizeof (*TpmRqu) + AdditionalParameterSize);
209 if (TpmRqu == NULL) {
210 return TCG_PP_OPERATION_RESPONSE_BIOS_FAILURE;
211 }
212
213 TpmRqu->tag = SwapBytes16 (TPM_TAG_RQU_COMMAND);
214 Size = (UINT32)(sizeof (*TpmRqu) + AdditionalParameterSize);
215 TpmRqu->paramSize = SwapBytes32 (Size);
216 TpmRqu->ordinal = SwapBytes32 (Ordinal);
217 CopyMem (TpmRqu + 1, AdditionalParameters, AdditionalParameterSize);
218
219 Status = TcgProtocol->PassThroughToTpm (
220 TcgProtocol,
221 Size,
222 (UINT8 *)TpmRqu,
223 (UINT32)sizeof (TpmRsp),
224 (UINT8 *)&TpmRsp
225 );
226 FreePool (TpmRqu);
227 if (EFI_ERROR (Status) || (TpmRsp.tag != SwapBytes16 (TPM_TAG_RSP_COMMAND))) {
228 return TCG_PP_OPERATION_RESPONSE_BIOS_FAILURE;
229 }
230
231 return SwapBytes32 (TpmRsp.returnCode);
232}
233
247UINT32
248ExecutePhysicalPresence (
249 IN EFI_TCG_PROTOCOL *TcgProtocol,
250 IN UINT32 CommandCode,
251 IN OUT EFI_PHYSICAL_PRESENCE_FLAGS *PpiFlags
252 )
253{
254 BOOLEAN BoolVal;
255 UINT32 TpmResponse;
256 UINT32 InData[5];
257
258 switch (CommandCode) {
259 case PHYSICAL_PRESENCE_ENABLE:
260 return TpmCommandNoReturnData (
261 TcgProtocol,
262 TPM_ORD_PhysicalEnable,
263 0,
264 NULL
265 );
266
267 case PHYSICAL_PRESENCE_DISABLE:
268 return TpmCommandNoReturnData (
269 TcgProtocol,
270 TPM_ORD_PhysicalDisable,
271 0,
272 NULL
273 );
274
275 case PHYSICAL_PRESENCE_ACTIVATE:
276 BoolVal = FALSE;
277 return TpmCommandNoReturnData (
278 TcgProtocol,
279 TPM_ORD_PhysicalSetDeactivated,
280 sizeof (BoolVal),
281 &BoolVal
282 );
283
284 case PHYSICAL_PRESENCE_DEACTIVATE:
285 BoolVal = TRUE;
286 return TpmCommandNoReturnData (
287 TcgProtocol,
288 TPM_ORD_PhysicalSetDeactivated,
289 sizeof (BoolVal),
290 &BoolVal
291 );
292
293 case PHYSICAL_PRESENCE_CLEAR:
294 return TpmCommandNoReturnData (
295 TcgProtocol,
296 TPM_ORD_ForceClear,
297 0,
298 NULL
299 );
300
301 case PHYSICAL_PRESENCE_ENABLE_ACTIVATE:
302 TpmResponse = ExecutePhysicalPresence (TcgProtocol, PHYSICAL_PRESENCE_ENABLE, PpiFlags);
303 if (TpmResponse == 0) {
304 TpmResponse = ExecutePhysicalPresence (TcgProtocol, PHYSICAL_PRESENCE_ACTIVATE, PpiFlags);
305 }
306
307 return TpmResponse;
308
309 case PHYSICAL_PRESENCE_DEACTIVATE_DISABLE:
310 TpmResponse = ExecutePhysicalPresence (TcgProtocol, PHYSICAL_PRESENCE_DEACTIVATE, PpiFlags);
311 if (TpmResponse == 0) {
312 TpmResponse = ExecutePhysicalPresence (TcgProtocol, PHYSICAL_PRESENCE_DISABLE, PpiFlags);
313 }
314
315 return TpmResponse;
316
317 case PHYSICAL_PRESENCE_SET_OWNER_INSTALL_TRUE:
318 BoolVal = TRUE;
319 return TpmCommandNoReturnData (
320 TcgProtocol,
321 TPM_ORD_SetOwnerInstall,
322 sizeof (BoolVal),
323 &BoolVal
324 );
325
326 case PHYSICAL_PRESENCE_SET_OWNER_INSTALL_FALSE:
327 BoolVal = FALSE;
328 return TpmCommandNoReturnData (
329 TcgProtocol,
330 TPM_ORD_SetOwnerInstall,
331 sizeof (BoolVal),
332 &BoolVal
333 );
334
335 case PHYSICAL_PRESENCE_ENABLE_ACTIVATE_OWNER_TRUE:
336 //
337 // PHYSICAL_PRESENCE_ENABLE_ACTIVATE + PHYSICAL_PRESENCE_SET_OWNER_INSTALL_TRUE
338 // PHYSICAL_PRESENCE_SET_OWNER_INSTALL_TRUE will be executed after reboot
339 //
340 if ((PpiFlags->PPFlags & TCG_VENDOR_LIB_FLAG_RESET_TRACK) == 0) {
341 TpmResponse = ExecutePhysicalPresence (TcgProtocol, PHYSICAL_PRESENCE_ENABLE_ACTIVATE, PpiFlags);
342 PpiFlags->PPFlags |= TCG_VENDOR_LIB_FLAG_RESET_TRACK;
343 } else {
344 TpmResponse = ExecutePhysicalPresence (TcgProtocol, PHYSICAL_PRESENCE_SET_OWNER_INSTALL_TRUE, PpiFlags);
345 PpiFlags->PPFlags &= ~TCG_VENDOR_LIB_FLAG_RESET_TRACK;
346 }
347
348 return TpmResponse;
349
350 case PHYSICAL_PRESENCE_DEACTIVATE_DISABLE_OWNER_FALSE:
351 TpmResponse = ExecutePhysicalPresence (TcgProtocol, PHYSICAL_PRESENCE_SET_OWNER_INSTALL_FALSE, PpiFlags);
352 if (TpmResponse == 0) {
353 TpmResponse = ExecutePhysicalPresence (TcgProtocol, PHYSICAL_PRESENCE_DEACTIVATE_DISABLE, PpiFlags);
354 }
355
356 return TpmResponse;
357
358 case PHYSICAL_PRESENCE_DEFERRED_PP_UNOWNERED_FIELD_UPGRADE:
359 InData[0] = SwapBytes32 (TPM_SET_STCLEAR_DATA); // CapabilityArea
360 InData[1] = SwapBytes32 (sizeof (UINT32)); // SubCapSize
361 InData[2] = SwapBytes32 (TPM_SD_DEFERREDPHYSICALPRESENCE); // SubCap
362 InData[3] = SwapBytes32 (sizeof (UINT32)); // SetValueSize
363 InData[4] = SwapBytes32 (1); // UnownedFieldUpgrade; bit0
364 return TpmCommandNoReturnData (
365 TcgProtocol,
366 TPM_ORD_SetCapability,
367 sizeof (UINT32) * 5,
368 InData
369 );
370
371 case PHYSICAL_PRESENCE_SET_OPERATOR_AUTH:
372 //
373 // TPM_SetOperatorAuth
374 // This command requires UI to prompt user for Auth data
375 // Here it is NOT implemented
376 //
377 return TCG_PP_OPERATION_RESPONSE_BIOS_FAILURE;
378
379 case PHYSICAL_PRESENCE_CLEAR_ENABLE_ACTIVATE:
380 TpmResponse = ExecutePhysicalPresence (TcgProtocol, PHYSICAL_PRESENCE_CLEAR, PpiFlags);
381 if (TpmResponse == 0) {
382 TpmResponse = ExecutePhysicalPresence (TcgProtocol, PHYSICAL_PRESENCE_ENABLE_ACTIVATE, PpiFlags);
383 }
384
385 return TpmResponse;
386
387 case PHYSICAL_PRESENCE_SET_NO_PPI_PROVISION_FALSE:
388 PpiFlags->PPFlags &= ~TCG_BIOS_TPM_MANAGEMENT_FLAG_NO_PPI_PROVISION;
389 return 0;
390
391 case PHYSICAL_PRESENCE_SET_NO_PPI_PROVISION_TRUE:
392 PpiFlags->PPFlags |= TCG_BIOS_TPM_MANAGEMENT_FLAG_NO_PPI_PROVISION;
393 return 0;
394
395 case PHYSICAL_PRESENCE_SET_NO_PPI_CLEAR_FALSE:
396 PpiFlags->PPFlags &= ~TCG_BIOS_TPM_MANAGEMENT_FLAG_NO_PPI_CLEAR;
397 return 0;
398
399 case PHYSICAL_PRESENCE_SET_NO_PPI_CLEAR_TRUE:
400 PpiFlags->PPFlags |= TCG_BIOS_TPM_MANAGEMENT_FLAG_NO_PPI_CLEAR;
401 return 0;
402
403 case PHYSICAL_PRESENCE_SET_NO_PPI_MAINTENANCE_FALSE:
404 PpiFlags->PPFlags &= ~TCG_BIOS_TPM_MANAGEMENT_FLAG_NO_PPI_MAINTENANCE;
405 return 0;
406
407 case PHYSICAL_PRESENCE_SET_NO_PPI_MAINTENANCE_TRUE:
408 PpiFlags->PPFlags |= TCG_BIOS_TPM_MANAGEMENT_FLAG_NO_PPI_MAINTENANCE;
409 return 0;
410
411 case PHYSICAL_PRESENCE_ENABLE_ACTIVATE_CLEAR:
412 //
413 // PHYSICAL_PRESENCE_ENABLE_ACTIVATE + PHYSICAL_PRESENCE_CLEAR
414 // PHYSICAL_PRESENCE_CLEAR will be executed after reboot.
415 //
416 if ((PpiFlags->PPFlags & TCG_VENDOR_LIB_FLAG_RESET_TRACK) == 0) {
417 TpmResponse = ExecutePhysicalPresence (TcgProtocol, PHYSICAL_PRESENCE_ENABLE_ACTIVATE, PpiFlags);
418 PpiFlags->PPFlags |= TCG_VENDOR_LIB_FLAG_RESET_TRACK;
419 } else {
420 TpmResponse = ExecutePhysicalPresence (TcgProtocol, PHYSICAL_PRESENCE_CLEAR, PpiFlags);
421 PpiFlags->PPFlags &= ~TCG_VENDOR_LIB_FLAG_RESET_TRACK;
422 }
423
424 return TpmResponse;
425
426 case PHYSICAL_PRESENCE_ENABLE_ACTIVATE_CLEAR_ENABLE_ACTIVATE:
427 //
428 // PHYSICAL_PRESENCE_ENABLE_ACTIVATE + PHYSICAL_PRESENCE_CLEAR_ENABLE_ACTIVATE
429 // PHYSICAL_PRESENCE_CLEAR_ENABLE_ACTIVATE will be executed after reboot.
430 //
431 if ((PpiFlags->PPFlags & TCG_VENDOR_LIB_FLAG_RESET_TRACK) == 0) {
432 TpmResponse = ExecutePhysicalPresence (TcgProtocol, PHYSICAL_PRESENCE_ENABLE_ACTIVATE, PpiFlags);
433 PpiFlags->PPFlags |= TCG_VENDOR_LIB_FLAG_RESET_TRACK;
434 } else {
435 TpmResponse = ExecutePhysicalPresence (TcgProtocol, PHYSICAL_PRESENCE_CLEAR_ENABLE_ACTIVATE, PpiFlags);
436 PpiFlags->PPFlags &= ~TCG_VENDOR_LIB_FLAG_RESET_TRACK;
437 }
438
439 return TpmResponse;
440
441 default:
442 ;
443 }
444
445 return TCG_PP_OPERATION_RESPONSE_BIOS_FAILURE;
446}
447
458BOOLEAN
459ReadUserKey (
460 IN BOOLEAN CautionKey
461 )
462{
463 EFI_STATUS Status;
464 EFI_INPUT_KEY Key;
465 UINT16 InputKey;
466 UINTN Index;
467
468 InputKey = 0;
469 do {
470 Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
471 if (Status == EFI_NOT_READY) {
472 gBS->WaitForEvent (1, &gST->ConIn->WaitForKey, &Index);
473 continue;
474 }
475
476 if (Status == EFI_DEVICE_ERROR) {
477 return FALSE;
478 }
479
480 if (Key.ScanCode == SCAN_ESC) {
481 InputKey = Key.ScanCode;
482 }
483
484 if ((Key.ScanCode == SCAN_F10) && !CautionKey) {
485 InputKey = Key.ScanCode;
486 }
487
488 if ((Key.ScanCode == SCAN_F12) && CautionKey) {
489 InputKey = Key.ScanCode;
490 }
491 } while (InputKey == 0);
492
493 if (InputKey != SCAN_ESC) {
494 return TRUE;
495 }
496
497 return FALSE;
498}
499
512EFI_STATUS
513EFIAPI
514TcgPhysicalPresenceLibConstructor (
515 IN EFI_HANDLE ImageHandle,
516 IN EFI_SYSTEM_TABLE *SystemTable
517 )
518{
519 mPpStringPackHandle = HiiAddPackages (&gEfiPhysicalPresenceGuid, ImageHandle, DxeTcgPhysicalPresenceLibStrings, NULL);
520 ASSERT (mPpStringPackHandle != NULL);
521
522 return EFI_SUCCESS;
523}
524
533BOOLEAN
534UserConfirm (
535 IN UINT32 TpmPpCommand
536 )
537{
538 CHAR16 *ConfirmText;
539 CHAR16 *TmpStr1;
540 CHAR16 *TmpStr2;
541 UINTN BufSize;
542 BOOLEAN CautionKey;
543 UINT16 Index;
544 CHAR16 DstStr[81];
545
546 TmpStr2 = NULL;
547 CautionKey = FALSE;
548 BufSize = CONFIRM_BUFFER_SIZE;
549 ConfirmText = AllocateZeroPool (BufSize);
550 ASSERT (ConfirmText != NULL);
551
552 switch (TpmPpCommand) {
553 case PHYSICAL_PRESENCE_ENABLE:
554 TmpStr2 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_ENABLE));
555
556 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_HEAD_STR));
557 UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
558 FreePool (TmpStr1);
559
560 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_ACCEPT_KEY));
561 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
562 FreePool (TmpStr1);
563 break;
564
565 case PHYSICAL_PRESENCE_DISABLE:
566 TmpStr2 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_DISABLE));
567
568 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_HEAD_STR));
569 UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
570 FreePool (TmpStr1);
571
572 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_WARNING));
573 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
574 FreePool (TmpStr1);
575
576 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_ACCEPT_KEY));
577 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
578 FreePool (TmpStr1);
579 break;
580
581 case PHYSICAL_PRESENCE_ACTIVATE:
582 TmpStr2 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_ACTIVATE));
583
584 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_HEAD_STR));
585 UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
586 FreePool (TmpStr1);
587
588 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_ACCEPT_KEY));
589 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
590 FreePool (TmpStr1);
591 break;
592
593 case PHYSICAL_PRESENCE_DEACTIVATE:
594 TmpStr2 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_DEACTIVATE));
595
596 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_HEAD_STR));
597 UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
598 FreePool (TmpStr1);
599
600 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_WARNING));
601 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
602 FreePool (TmpStr1);
603
604 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_ACCEPT_KEY));
605 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
606 FreePool (TmpStr1);
607 break;
608
609 case PHYSICAL_PRESENCE_CLEAR:
610 CautionKey = TRUE;
611 TmpStr2 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_CLEAR));
612
613 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_HEAD_STR));
614 UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
615 FreePool (TmpStr1);
616
617 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_WARNING_CLEAR));
618 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
619 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), L" \n\n", (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
620 FreePool (TmpStr1);
621
622 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_CAUTION_KEY));
623 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
624 FreePool (TmpStr1);
625 break;
626
627 case PHYSICAL_PRESENCE_ENABLE_ACTIVATE:
628 TmpStr2 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_ENABLE_ACTIVATE));
629
630 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_HEAD_STR));
631 UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
632 FreePool (TmpStr1);
633
634 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_NOTE_ON));
635 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
636 FreePool (TmpStr1);
637
638 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_ACCEPT_KEY));
639 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
640 FreePool (TmpStr1);
641 break;
642
643 case PHYSICAL_PRESENCE_DEACTIVATE_DISABLE:
644 TmpStr2 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_DEACTIVATE_DISABLE));
645
646 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_HEAD_STR));
647 UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
648 FreePool (TmpStr1);
649
650 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_NOTE_OFF));
651 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
652 FreePool (TmpStr1);
653
654 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_WARNING));
655 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
656 FreePool (TmpStr1);
657
658 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_ACCEPT_KEY));
659 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
660 FreePool (TmpStr1);
661 break;
662
663 case PHYSICAL_PRESENCE_SET_OWNER_INSTALL_TRUE:
664 TmpStr2 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_ALLOW_TAKE_OWNERSHIP));
665
666 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_HEAD_STR));
667 UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
668 FreePool (TmpStr1);
669
670 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_ACCEPT_KEY));
671 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
672 FreePool (TmpStr1);
673 break;
674
675 case PHYSICAL_PRESENCE_SET_OWNER_INSTALL_FALSE:
676 TmpStr2 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_DISALLOW_TAKE_OWNERSHIP));
677
678 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_HEAD_STR));
679 UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
680 FreePool (TmpStr1);
681
682 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_ACCEPT_KEY));
683 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
684 FreePool (TmpStr1);
685 break;
686
687 case PHYSICAL_PRESENCE_ENABLE_ACTIVATE_OWNER_TRUE:
688 TmpStr2 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_TURN_ON));
689
690 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_HEAD_STR));
691 UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
692 FreePool (TmpStr1);
693
694 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_NOTE_ON));
695 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
696 FreePool (TmpStr1);
697
698 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_ACCEPT_KEY));
699 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
700 FreePool (TmpStr1);
701 break;
702
703 case PHYSICAL_PRESENCE_DEACTIVATE_DISABLE_OWNER_FALSE:
704 TmpStr2 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_TURN_OFF));
705
706 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_HEAD_STR));
707 UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
708 FreePool (TmpStr1);
709
710 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_NOTE_OFF));
711 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
712 FreePool (TmpStr1);
713
714 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_WARNING));
715 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
716 FreePool (TmpStr1);
717
718 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_ACCEPT_KEY));
719 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
720 FreePool (TmpStr1);
721 break;
722
723 case PHYSICAL_PRESENCE_DEFERRED_PP_UNOWNERED_FIELD_UPGRADE:
724 CautionKey = TRUE;
725 TmpStr2 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_UNOWNED_FIELD_UPGRADE));
726
727 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_UPGRADE_HEAD_STR));
728 UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
729 FreePool (TmpStr1);
730
731 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_WARNING_MAINTAIN));
732 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
733 FreePool (TmpStr1);
734
735 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_CAUTION_KEY));
736 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
737 FreePool (TmpStr1);
738 break;
739
740 case PHYSICAL_PRESENCE_SET_OPERATOR_AUTH:
741 //
742 // TPM_SetOperatorAuth
743 // This command requires UI to prompt user for Auth data
744 // Here it is NOT implemented
745 //
746 break;
747
748 case PHYSICAL_PRESENCE_CLEAR_ENABLE_ACTIVATE:
749 CautionKey = TRUE;
750 TmpStr2 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_CLEAR_TURN_ON));
751
752 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_HEAD_STR));
753 UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
754 FreePool (TmpStr1);
755
756 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_NOTE_ON));
757 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
758 FreePool (TmpStr1);
759
760 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_WARNING_CLEAR));
761 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
762 FreePool (TmpStr1);
763
764 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_WARNING_CLEAR_CONT));
765 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
766 FreePool (TmpStr1);
767
768 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_CAUTION_KEY));
769 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
770 FreePool (TmpStr1);
771 break;
772
773 case PHYSICAL_PRESENCE_SET_NO_PPI_PROVISION_TRUE:
774 TmpStr2 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_NO_PPI_PROVISION));
775
776 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_PPI_HEAD_STR));
777 UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
778 FreePool (TmpStr1);
779
780 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_ACCEPT_KEY));
781 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
782 FreePool (TmpStr1);
783
784 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_NO_PPI_INFO));
785 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
786 FreePool (TmpStr1);
787 break;
788
789 case PHYSICAL_PRESENCE_SET_NO_PPI_CLEAR_TRUE:
790 CautionKey = TRUE;
791 TmpStr2 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_CLEAR));
792
793 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_PPI_HEAD_STR));
794 UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
795 FreePool (TmpStr1);
796
797 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_NOTE_CLEAR));
798 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
799 FreePool (TmpStr1);
800
801 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_WARNING_CLEAR));
802 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
803 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), L" \n\n", (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
804 FreePool (TmpStr1);
805
806 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_CAUTION_KEY));
807 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
808 FreePool (TmpStr1);
809
810 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_NO_PPI_INFO));
811 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
812 FreePool (TmpStr1);
813 break;
814
815 case PHYSICAL_PRESENCE_SET_NO_PPI_MAINTENANCE_TRUE:
816 CautionKey = TRUE;
817 TmpStr2 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_NO_PPI_MAINTAIN));
818
819 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_PPI_HEAD_STR));
820 UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
821 FreePool (TmpStr1);
822
823 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_WARNING_MAINTAIN));
824 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
825 FreePool (TmpStr1);
826
827 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_CAUTION_KEY));
828 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
829 FreePool (TmpStr1);
830
831 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_NO_PPI_INFO));
832 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
833 FreePool (TmpStr1);
834 break;
835
836 case PHYSICAL_PRESENCE_ENABLE_ACTIVATE_CLEAR:
837 CautionKey = TRUE;
838 TmpStr2 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_ENABLE_ACTIVATE_CLEAR));
839
840 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_HEAD_STR));
841 UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
842 FreePool (TmpStr1);
843
844 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_WARNING_CLEAR));
845 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
846 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), L" \n\n", (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
847 FreePool (TmpStr1);
848
849 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_CAUTION_KEY));
850 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
851 FreePool (TmpStr1);
852 break;
853
854 case PHYSICAL_PRESENCE_ENABLE_ACTIVATE_CLEAR_ENABLE_ACTIVATE:
855 CautionKey = TRUE;
856 TmpStr2 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_ENABLE_ACTIVATE_CLEAR_ENABLE_ACTIVATE));
857
858 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_HEAD_STR));
859 UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
860 FreePool (TmpStr1);
861
862 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_NOTE_ON));
863 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
864 FreePool (TmpStr1);
865
866 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_WARNING_CLEAR));
867 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
868 FreePool (TmpStr1);
869
870 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_WARNING_CLEAR_CONT));
871 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
872 FreePool (TmpStr1);
873
874 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_CAUTION_KEY));
875 StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
876 FreePool (TmpStr1);
877 break;
878
879 default:
880 ;
881 }
882
883 if (TmpStr2 == NULL) {
884 FreePool (ConfirmText);
885 return FALSE;
886 }
887
888 TmpStr1 = PhysicalPresenceGetStringById (STRING_TOKEN (TPM_REJECT_KEY));
889 BufSize -= StrSize (ConfirmText);
890 UnicodeSPrint (ConfirmText + StrLen (ConfirmText), BufSize, TmpStr1, TmpStr2);
891
892 DstStr[80] = L'\0';
893 for (Index = 0; Index < StrLen (ConfirmText); Index += 80) {
894 StrnCpyS (DstStr, sizeof (DstStr) / sizeof (CHAR16), ConfirmText + Index, sizeof (DstStr) / sizeof (CHAR16) - 1);
895 Print (DstStr);
896 }
897
898 FreePool (TmpStr1);
899 FreePool (TmpStr2);
900 FreePool (ConfirmText);
901
902 if (ReadUserKey (CautionKey)) {
903 return TRUE;
904 }
905
906 return FALSE;
907}
908
924BOOLEAN
925HaveValidTpmRequest (
926 IN EFI_PHYSICAL_PRESENCE *TcgPpData,
927 IN EFI_PHYSICAL_PRESENCE_FLAGS Flags,
928 OUT BOOLEAN *RequestConfirmed
929 )
930{
931 BOOLEAN IsRequestValid;
932
933 *RequestConfirmed = FALSE;
934
935 switch (TcgPpData->PPRequest) {
936 case PHYSICAL_PRESENCE_NO_ACTION:
937 *RequestConfirmed = TRUE;
938 return TRUE;
939 case PHYSICAL_PRESENCE_ENABLE:
940 case PHYSICAL_PRESENCE_DISABLE:
941 case PHYSICAL_PRESENCE_ACTIVATE:
942 case PHYSICAL_PRESENCE_DEACTIVATE:
943 case PHYSICAL_PRESENCE_ENABLE_ACTIVATE:
944 case PHYSICAL_PRESENCE_DEACTIVATE_DISABLE:
945 case PHYSICAL_PRESENCE_SET_OWNER_INSTALL_TRUE:
946 case PHYSICAL_PRESENCE_SET_OWNER_INSTALL_FALSE:
947 case PHYSICAL_PRESENCE_ENABLE_ACTIVATE_OWNER_TRUE:
948 case PHYSICAL_PRESENCE_DEACTIVATE_DISABLE_OWNER_FALSE:
949 case PHYSICAL_PRESENCE_SET_OPERATOR_AUTH:
950 if ((Flags.PPFlags & TCG_BIOS_TPM_MANAGEMENT_FLAG_NO_PPI_PROVISION) != 0) {
951 *RequestConfirmed = TRUE;
952 }
953
954 break;
955
956 case PHYSICAL_PRESENCE_CLEAR:
957 case PHYSICAL_PRESENCE_ENABLE_ACTIVATE_CLEAR:
958 if ((Flags.PPFlags & TCG_BIOS_TPM_MANAGEMENT_FLAG_NO_PPI_CLEAR) != 0) {
959 *RequestConfirmed = TRUE;
960 }
961
962 break;
963
964 case PHYSICAL_PRESENCE_DEFERRED_PP_UNOWNERED_FIELD_UPGRADE:
965 if ((Flags.PPFlags & TCG_BIOS_TPM_MANAGEMENT_FLAG_NO_PPI_MAINTENANCE) != 0) {
966 *RequestConfirmed = TRUE;
967 }
968
969 break;
970
971 case PHYSICAL_PRESENCE_CLEAR_ENABLE_ACTIVATE:
972 case PHYSICAL_PRESENCE_ENABLE_ACTIVATE_CLEAR_ENABLE_ACTIVATE:
973 if (((Flags.PPFlags & TCG_BIOS_TPM_MANAGEMENT_FLAG_NO_PPI_CLEAR) != 0) && ((Flags.PPFlags & TCG_BIOS_TPM_MANAGEMENT_FLAG_NO_PPI_PROVISION) != 0)) {
974 *RequestConfirmed = TRUE;
975 }
976
977 break;
978
979 case PHYSICAL_PRESENCE_SET_NO_PPI_PROVISION_FALSE:
980 case PHYSICAL_PRESENCE_SET_NO_PPI_CLEAR_FALSE:
981 case PHYSICAL_PRESENCE_SET_NO_PPI_MAINTENANCE_FALSE:
982 *RequestConfirmed = TRUE;
983 break;
984
985 case PHYSICAL_PRESENCE_SET_NO_PPI_PROVISION_TRUE:
986 case PHYSICAL_PRESENCE_SET_NO_PPI_CLEAR_TRUE:
987 case PHYSICAL_PRESENCE_SET_NO_PPI_MAINTENANCE_TRUE:
988 break;
989
990 default:
991 if (TcgPpData->PPRequest >= TCG_PHYSICAL_PRESENCE_VENDOR_SPECIFIC_OPERATION) {
992 IsRequestValid = TcgPpVendorLibHasValidRequest (TcgPpData->PPRequest, Flags.PPFlags, RequestConfirmed);
993 if (!IsRequestValid) {
994 return FALSE;
995 } else {
996 break;
997 }
998 } else {
999 //
1000 // Wrong Physical Presence command
1001 //
1002 return FALSE;
1003 }
1004 }
1005
1006 if ((Flags.PPFlags & TCG_VENDOR_LIB_FLAG_RESET_TRACK) != 0) {
1007 //
1008 // It had been confirmed in last boot, it doesn't need confirm again.
1009 //
1010 *RequestConfirmed = TRUE;
1011 }
1012
1013 //
1014 // Physical Presence command is correct
1015 //
1016 return TRUE;
1017}
1018
1031VOID
1032ExecutePendingTpmRequest (
1033 IN EFI_TCG_PROTOCOL *TcgProtocol,
1034 IN EFI_PHYSICAL_PRESENCE *TcgPpData,
1035 IN EFI_PHYSICAL_PRESENCE_FLAGS Flags
1036 )
1037{
1038 EFI_STATUS Status;
1039 UINTN DataSize;
1040 BOOLEAN RequestConfirmed;
1041 EFI_PHYSICAL_PRESENCE_FLAGS NewFlags;
1042 BOOLEAN ResetRequired;
1043 UINT32 NewPPFlags;
1044
1045 if (!HaveValidTpmRequest (TcgPpData, Flags, &RequestConfirmed)) {
1046 //
1047 // Invalid operation request.
1048 //
1049 TcgPpData->PPResponse = TCG_PP_OPERATION_RESPONSE_BIOS_FAILURE;
1050 TcgPpData->LastPPRequest = TcgPpData->PPRequest;
1051 TcgPpData->PPRequest = PHYSICAL_PRESENCE_NO_ACTION;
1052 DataSize = sizeof (EFI_PHYSICAL_PRESENCE);
1053 Status = gRT->SetVariable (
1054 PHYSICAL_PRESENCE_VARIABLE,
1055 &gEfiPhysicalPresenceGuid,
1056 EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
1057 DataSize,
1058 TcgPpData
1059 );
1060 return;
1061 }
1062
1063 ResetRequired = FALSE;
1064 if (TcgPpData->PPRequest >= TCG_PHYSICAL_PRESENCE_VENDOR_SPECIFIC_OPERATION) {
1065 NewFlags = Flags;
1066 NewPPFlags = NewFlags.PPFlags;
1067 TcgPpData->PPResponse = TcgPpVendorLibExecutePendingRequest (TcgPpData->PPRequest, &NewPPFlags, &ResetRequired);
1068 NewFlags.PPFlags = (UINT8)NewPPFlags;
1069 } else {
1070 if (!RequestConfirmed) {
1071 //
1072 // Print confirm text and wait for approval.
1073 //
1074 RequestConfirmed = UserConfirm (TcgPpData->PPRequest);
1075 }
1076
1077 //
1078 // Execute requested physical presence command
1079 //
1080 TcgPpData->PPResponse = TCG_PP_OPERATION_RESPONSE_USER_ABORT;
1081 NewFlags = Flags;
1082 if (RequestConfirmed) {
1083 TcgPpData->PPResponse = ExecutePhysicalPresence (TcgProtocol, TcgPpData->PPRequest, &NewFlags);
1084 }
1085 }
1086
1087 //
1088 // Save the flags if it is updated.
1089 //
1090 if (CompareMem (&Flags, &NewFlags, sizeof (EFI_PHYSICAL_PRESENCE_FLAGS)) != 0) {
1091 Status = gRT->SetVariable (
1092 PHYSICAL_PRESENCE_FLAGS_VARIABLE,
1093 &gEfiPhysicalPresenceGuid,
1094 EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
1095 sizeof (EFI_PHYSICAL_PRESENCE_FLAGS),
1096 &NewFlags
1097 );
1098 if (EFI_ERROR (Status)) {
1099 return;
1100 }
1101 }
1102
1103 //
1104 // Clear request
1105 //
1106 if ((NewFlags.PPFlags & TCG_VENDOR_LIB_FLAG_RESET_TRACK) == 0) {
1107 TcgPpData->LastPPRequest = TcgPpData->PPRequest;
1108 TcgPpData->PPRequest = PHYSICAL_PRESENCE_NO_ACTION;
1109 }
1110
1111 //
1112 // Save changes
1113 //
1114 DataSize = sizeof (EFI_PHYSICAL_PRESENCE);
1115 Status = gRT->SetVariable (
1116 PHYSICAL_PRESENCE_VARIABLE,
1117 &gEfiPhysicalPresenceGuid,
1118 EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
1119 DataSize,
1120 TcgPpData
1121 );
1122 if (EFI_ERROR (Status)) {
1123 return;
1124 }
1125
1126 if (TcgPpData->PPResponse == TCG_PP_OPERATION_RESPONSE_USER_ABORT) {
1127 return;
1128 }
1129
1130 //
1131 // Reset system to make new TPM settings in effect
1132 //
1133 switch (TcgPpData->LastPPRequest) {
1134 case PHYSICAL_PRESENCE_ACTIVATE:
1135 case PHYSICAL_PRESENCE_DEACTIVATE:
1136 case PHYSICAL_PRESENCE_CLEAR:
1137 case PHYSICAL_PRESENCE_ENABLE_ACTIVATE:
1138 case PHYSICAL_PRESENCE_DEACTIVATE_DISABLE:
1139 case PHYSICAL_PRESENCE_ENABLE_ACTIVATE_OWNER_TRUE:
1140 case PHYSICAL_PRESENCE_DEACTIVATE_DISABLE_OWNER_FALSE:
1141 case PHYSICAL_PRESENCE_DEFERRED_PP_UNOWNERED_FIELD_UPGRADE:
1142 case PHYSICAL_PRESENCE_CLEAR_ENABLE_ACTIVATE:
1143 case PHYSICAL_PRESENCE_ENABLE_ACTIVATE_CLEAR:
1144 case PHYSICAL_PRESENCE_ENABLE_ACTIVATE_CLEAR_ENABLE_ACTIVATE:
1145 break;
1146 default:
1147 if (TcgPpData->LastPPRequest >= TCG_PHYSICAL_PRESENCE_VENDOR_SPECIFIC_OPERATION) {
1148 if (ResetRequired) {
1149 break;
1150 } else {
1151 return;
1152 }
1153 }
1154
1155 if (TcgPpData->PPRequest != PHYSICAL_PRESENCE_NO_ACTION) {
1156 break;
1157 }
1158
1159 return;
1160 }
1161
1162 Print (L"Rebooting system to make TPM settings in effect\n");
1163 gRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
1164 ASSERT (FALSE);
1165}
1166
1180VOID
1181EFIAPI
1182TcgPhysicalPresenceLibProcessRequest (
1183 VOID
1184 )
1185{
1186 EFI_STATUS Status;
1187 BOOLEAN LifetimeLock;
1188 BOOLEAN CmdEnable;
1189 UINTN DataSize;
1190 EFI_PHYSICAL_PRESENCE TcgPpData;
1191 EFI_TCG_PROTOCOL *TcgProtocol;
1192 EDKII_VARIABLE_LOCK_PROTOCOL *VariableLockProtocol;
1193 EFI_PHYSICAL_PRESENCE_FLAGS PpiFlags;
1194
1195 Status = gBS->LocateProtocol (&gEfiTcgProtocolGuid, NULL, (VOID **)&TcgProtocol);
1196 if (EFI_ERROR (Status)) {
1197 return;
1198 }
1199
1200 //
1201 // Initialize physical presence flags.
1202 //
1203 DataSize = sizeof (EFI_PHYSICAL_PRESENCE_FLAGS);
1204 Status = gRT->GetVariable (
1205 PHYSICAL_PRESENCE_FLAGS_VARIABLE,
1206 &gEfiPhysicalPresenceGuid,
1207 NULL,
1208 &DataSize,
1209 &PpiFlags
1210 );
1211 if (EFI_ERROR (Status)) {
1212 PpiFlags.PPFlags = TCG_BIOS_TPM_MANAGEMENT_FLAG_NO_PPI_PROVISION;
1213 Status = gRT->SetVariable (
1214 PHYSICAL_PRESENCE_FLAGS_VARIABLE,
1215 &gEfiPhysicalPresenceGuid,
1216 EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
1217 sizeof (EFI_PHYSICAL_PRESENCE_FLAGS),
1218 &PpiFlags
1219 );
1220 if (EFI_ERROR (Status)) {
1221 DEBUG ((DEBUG_ERROR, "[TPM] Set physical presence flag failed, Status = %r\n", Status));
1222 return;
1223 }
1224 }
1225
1226 DEBUG ((DEBUG_INFO, "[TPM] PpiFlags = %x\n", PpiFlags.PPFlags));
1227
1228 //
1229 // This flags variable controls whether physical presence is required for TPM command.
1230 // It should be protected from malicious software. We set it as read-only variable here.
1231 //
1232 Status = gBS->LocateProtocol (&gEdkiiVariableLockProtocolGuid, NULL, (VOID **)&VariableLockProtocol);
1233 if (!EFI_ERROR (Status)) {
1234 Status = VariableLockProtocol->RequestToLock (
1235 VariableLockProtocol,
1236 PHYSICAL_PRESENCE_FLAGS_VARIABLE,
1237 &gEfiPhysicalPresenceGuid
1238 );
1239 if (EFI_ERROR (Status)) {
1240 DEBUG ((DEBUG_ERROR, "[TPM] Error when lock variable %s, Status = %r\n", PHYSICAL_PRESENCE_FLAGS_VARIABLE, Status));
1241 ASSERT_EFI_ERROR (Status);
1242 }
1243 }
1244
1245 //
1246 // Initialize physical presence variable.
1247 //
1248 DataSize = sizeof (EFI_PHYSICAL_PRESENCE);
1249 Status = gRT->GetVariable (
1250 PHYSICAL_PRESENCE_VARIABLE,
1251 &gEfiPhysicalPresenceGuid,
1252 NULL,
1253 &DataSize,
1254 &TcgPpData
1255 );
1256 if (EFI_ERROR (Status)) {
1257 ZeroMem ((VOID *)&TcgPpData, sizeof (TcgPpData));
1258 DataSize = sizeof (EFI_PHYSICAL_PRESENCE);
1259 Status = gRT->SetVariable (
1260 PHYSICAL_PRESENCE_VARIABLE,
1261 &gEfiPhysicalPresenceGuid,
1262 EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
1263 DataSize,
1264 &TcgPpData
1265 );
1266 if (EFI_ERROR (Status)) {
1267 DEBUG ((DEBUG_ERROR, "[TPM] Set physical presence variable failed, Status = %r\n", Status));
1268 return;
1269 }
1270 }
1271
1272 DEBUG ((DEBUG_INFO, "[TPM] Flags=%x, PPRequest=%x\n", PpiFlags.PPFlags, TcgPpData.PPRequest));
1273
1274 if (TcgPpData.PPRequest == PHYSICAL_PRESENCE_NO_ACTION) {
1275 //
1276 // No operation request
1277 //
1278 return;
1279 }
1280
1281 Status = GetTpmCapability (TcgProtocol, &LifetimeLock, &CmdEnable);
1282 if (EFI_ERROR (Status)) {
1283 return;
1284 }
1285
1286 if (!CmdEnable) {
1287 if (LifetimeLock) {
1288 //
1289 // physicalPresenceCMDEnable is locked, can't execute physical presence command.
1290 //
1291 return;
1292 }
1293
1294 Status = TpmPhysicalPresence (TcgProtocol, TPM_PHYSICAL_PRESENCE_CMD_ENABLE);
1295 if (EFI_ERROR (Status)) {
1296 return;
1297 }
1298 }
1299
1300 //
1301 // Set operator physical presence flags
1302 //
1303 Status = TpmPhysicalPresence (TcgProtocol, TPM_PHYSICAL_PRESENCE_PRESENT);
1304 if (EFI_ERROR (Status)) {
1305 return;
1306 }
1307
1308 //
1309 // Execute pending TPM request.
1310 //
1311 ExecutePendingTpmRequest (TcgProtocol, &TcgPpData, PpiFlags);
1312 DEBUG ((DEBUG_INFO, "[TPM] PPResponse = %x\n", TcgPpData.PPResponse));
1313
1314 //
1315 // Lock physical presence.
1316 //
1317 TpmPhysicalPresence (TcgProtocol, TPM_PHYSICAL_PRESENCE_NOTPRESENT | TPM_PHYSICAL_PRESENCE_LOCK);
1318}
1319
1330BOOLEAN
1331EFIAPI
1332TcgPhysicalPresenceLibNeedUserConfirm (
1333 VOID
1334 )
1335{
1336 EFI_STATUS Status;
1337 EFI_PHYSICAL_PRESENCE TcgPpData;
1338 UINTN DataSize;
1339 BOOLEAN RequestConfirmed;
1340 BOOLEAN LifetimeLock;
1341 BOOLEAN CmdEnable;
1342 EFI_TCG_PROTOCOL *TcgProtocol;
1343 EFI_PHYSICAL_PRESENCE_FLAGS PpiFlags;
1344
1345 Status = gBS->LocateProtocol (&gEfiTcgProtocolGuid, NULL, (VOID **)&TcgProtocol);
1346 if (EFI_ERROR (Status)) {
1347 return FALSE;
1348 }
1349
1350 //
1351 // Check Tpm requests
1352 //
1353 DataSize = sizeof (EFI_PHYSICAL_PRESENCE);
1354 Status = gRT->GetVariable (
1355 PHYSICAL_PRESENCE_VARIABLE,
1356 &gEfiPhysicalPresenceGuid,
1357 NULL,
1358 &DataSize,
1359 &TcgPpData
1360 );
1361 if (EFI_ERROR (Status)) {
1362 return FALSE;
1363 }
1364
1365 DataSize = sizeof (EFI_PHYSICAL_PRESENCE_FLAGS);
1366 Status = gRT->GetVariable (
1367 PHYSICAL_PRESENCE_FLAGS_VARIABLE,
1368 &gEfiPhysicalPresenceGuid,
1369 NULL,
1370 &DataSize,
1371 &PpiFlags
1372 );
1373 if (EFI_ERROR (Status)) {
1374 return FALSE;
1375 }
1376
1377 if (TcgPpData.PPRequest == PHYSICAL_PRESENCE_NO_ACTION) {
1378 //
1379 // No operation request
1380 //
1381 return FALSE;
1382 }
1383
1384 if (!HaveValidTpmRequest (&TcgPpData, PpiFlags, &RequestConfirmed)) {
1385 //
1386 // Invalid operation request.
1387 //
1388 return FALSE;
1389 }
1390
1391 //
1392 // Check Tpm Capability
1393 //
1394 Status = GetTpmCapability (TcgProtocol, &LifetimeLock, &CmdEnable);
1395 if (EFI_ERROR (Status)) {
1396 return FALSE;
1397 }
1398
1399 if (!CmdEnable) {
1400 if (LifetimeLock) {
1401 //
1402 // physicalPresenceCMDEnable is locked, can't execute physical presence command.
1403 //
1404 return FALSE;
1405 }
1406 }
1407
1408 if (!RequestConfirmed) {
1409 //
1410 // Need UI to confirm
1411 //
1412 return TRUE;
1413 }
1414
1415 return FALSE;
1416}
UINTN
UINT64 UINTN
Definition: ProcessorBind.h:112
StrSize
UINTN EFIAPI StrSize(IN CONST CHAR16 *String)
Definition: String.c:72
SwapBytes16
UINT16 EFIAPI SwapBytes16(IN UINT16 Value)
Definition: SwapBytes16.c:25
SwapBytes32
UINT32 EFIAPI SwapBytes32(IN UINT32 Value)
Definition: SwapBytes32.c:25
WriteUnaligned32
UINT32 EFIAPI WriteUnaligned32(OUT UINT32 *Buffer, IN UINT32 Value)
Definition: Unaligned.c:177
StrnCatS
RETURN_STATUS EFIAPI StrnCatS(IN OUT CHAR16 *Destination, IN UINTN DestMax, IN CONST CHAR16 *Source, IN UINTN Length)
Definition: SafeString.c:507
WriteUnaligned16
UINT16 EFIAPI WriteUnaligned16(OUT UINT16 *Buffer, IN UINT16 Value)
Definition: Unaligned.c:61
StrnCpyS
RETURN_STATUS EFIAPI StrnCpyS(OUT CHAR16 *Destination, IN UINTN DestMax, IN CONST CHAR16 *Source, IN UINTN Length)
Definition: SafeString.c:310
StrLen
UINTN EFIAPI StrLen(IN CONST CHAR16 *String)
Definition: String.c:30
CompareMem
INTN EFIAPI CompareMem(IN CONST VOID *DestinationBuffer, IN CONST VOID *SourceBuffer, IN UINTN Length)
Definition: CompareMemWrapper.c:45
CopyMem
VOID *EFIAPI CopyMem(OUT VOID *DestinationBuffer, IN CONST VOID *SourceBuffer, IN UINTN Length)
Definition: CopyMemWrapper.c:41
ZeroMem
VOID *EFIAPI ZeroMem(OUT VOID *Buffer, IN UINTN Length)
Definition: ZeroMemWrapper.c:38
TcgPhysicalPresenceLibNeedUserConfirm
BOOLEAN EFIAPI TcgPhysicalPresenceLibNeedUserConfirm(VOID)
Definition: DxeTcgPhysicalPresenceLib.c:1332
TpmCommandNoReturnData
UINT32 TpmCommandNoReturnData(IN EFI_TCG_PROTOCOL *TcgProtocol, IN TPM_COMMAND_CODE Ordinal, IN UINTN AdditionalParameterSize, IN VOID *AdditionalParameters)
Definition: DxeTcgPhysicalPresenceLib.c:196
GetTpmCapability
EFI_STATUS GetTpmCapability(IN EFI_TCG_PROTOCOL *TcgProtocol, OUT BOOLEAN *LifetimeLock, OUT BOOLEAN *CmdEnable)
Definition: DxeTcgPhysicalPresenceLib.c:66
TcgPhysicalPresenceLibConstructor
EFI_STATUS EFIAPI TcgPhysicalPresenceLibConstructor(IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable)
Definition: DxeTcgPhysicalPresenceLib.c:514
UserConfirm
BOOLEAN UserConfirm(IN UINT32 TpmPpCommand)
Definition: DxeTcgPhysicalPresenceLib.c:534
ExecutePhysicalPresence
UINT32 ExecutePhysicalPresence(IN EFI_TCG_PROTOCOL *TcgProtocol, IN UINT32 CommandCode, IN OUT EFI_PHYSICAL_PRESENCE_FLAGS *PpiFlags)
Definition: DxeTcgPhysicalPresenceLib.c:248
ReadUserKey
BOOLEAN ReadUserKey(IN BOOLEAN CautionKey)
Definition: DxeTcgPhysicalPresenceLib.c:459
TpmPhysicalPresence
EFI_STATUS TpmPhysicalPresence(IN EFI_TCG_PROTOCOL *TcgProtocol, IN TPM_PHYSICAL_PRESENCE PhysicalPresence)
Definition: DxeTcgPhysicalPresenceLib.c:138
TcgPhysicalPresenceLibProcessRequest
VOID EFIAPI TcgPhysicalPresenceLibProcessRequest(VOID)
Definition: DxeTcgPhysicalPresenceLib.c:1182
PhysicalPresenceGetStringById
CHAR16 * PhysicalPresenceGetStringById(IN EFI_STRING_ID Id)
Definition: DxeTcgPhysicalPresenceLib.c:47
ExecutePendingTpmRequest
VOID ExecutePendingTpmRequest(IN EFI_TCG_PROTOCOL *TcgProtocol, IN EFI_PHYSICAL_PRESENCE *TcgPpData, IN EFI_PHYSICAL_PRESENCE_FLAGS Flags)
Definition: DxeTcgPhysicalPresenceLib.c:1032
HaveValidTpmRequest
BOOLEAN HaveValidTpmRequest(IN EFI_PHYSICAL_PRESENCE *TcgPpData, IN EFI_PHYSICAL_PRESENCE_FLAGS Flags, OUT BOOLEAN *RequestConfirmed)
Definition: DxeTcgPhysicalPresenceLib.c:925
AllocateZeroPool
VOID *EFIAPI AllocateZeroPool(IN UINTN AllocationSize)
Definition: MemoryAllocationLib.c:234
FreePool
VOID EFIAPI FreePool(IN VOID *Buffer)
Definition: MemoryAllocationLib.c:266
HiiAddPackages
EFI_HII_HANDLE EFIAPI HiiAddPackages(IN CONST EFI_GUID *PackageListGuid, IN EFI_HANDLE DeviceHandle OPTIONAL,...)
Definition: HiiLib.c:141
HiiGetString
EFI_STRING EFIAPI HiiGetString(IN EFI_HII_HANDLE HiiHandle, IN EFI_STRING_ID StringId, IN CONST CHAR8 *Language OPTIONAL)
Definition: HiiString.c:211
UnicodeSPrint
UINTN EFIAPI UnicodeSPrint(OUT CHAR16 *StartOfBuffer, IN UINTN BufferSize, IN CONST CHAR16 *FormatString,...)
Definition: PrintLib.c:408
gRT
EFI_RUNTIME_SERVICES * gRT
Definition: MockUefiRuntimeServicesTableLib.c:13
NULL
#define NULL
Definition: Base.h:319
TRUE
#define TRUE
Definition: Base.h:301
FALSE
#define FALSE
Definition: Base.h:307
IN
#define IN
Definition: Base.h:279
OUT
#define OUT
Definition: Base.h:284
ASSERT_EFI_ERROR
#define ASSERT_EFI_ERROR(StatusParameter)
Definition: DebugLib.h:462
DEBUG
#define DEBUG(Expression)
Definition: DebugLib.h:434
AllocatePool
VOID *EFIAPI AllocatePool(IN UINTN AllocationSize)
Definition: MemoryAllocationLib.c:195
TcgPpVendorLibHasValidRequest
BOOLEAN EFIAPI TcgPpVendorLibHasValidRequest(IN UINT32 OperationRequest, IN UINT32 ManagementFlags, OUT BOOLEAN *RequestConfirmed)
Definition: TcgPpVendorLibNull.c:61
TcgPpVendorLibExecutePendingRequest
UINT32 EFIAPI TcgPpVendorLibExecutePendingRequest(IN UINT32 OperationRequest, IN OUT UINT32 *ManagementFlags, OUT BOOLEAN *ResetRequired)
Definition: TcgPpVendorLibNull.c:31
TPM_PHYSICAL_PRESENCE_LOCK
#define TPM_PHYSICAL_PRESENCE_LOCK
Sets PhysicalPresenceLock = TRUE.
Definition: Tpm12.h:383
TPM_COMMAND_CODE
UINT32 TPM_COMMAND_CODE
Definition: Tpm12.h:93
TPM_PHYSICAL_PRESENCE_PRESENT
#define TPM_PHYSICAL_PRESENCE_PRESENT
Sets PhysicalPresence = TRUE.
Definition: Tpm12.h:382
TPM_PHYSICAL_PRESENCE
UINT16 TPM_PHYSICAL_PRESENCE
Definition: Tpm12.h:69
TPM_PHYSICAL_PRESENCE_NOTPRESENT
#define TPM_PHYSICAL_PRESENCE_NOTPRESENT
Sets PhysicalPresence = FALSE.
Definition: Tpm12.h:381
TPM_PHYSICAL_PRESENCE_CMD_ENABLE
#define TPM_PHYSICAL_PRESENCE_CMD_ENABLE
Sets the physicalPresenceCMDEnable to TRUE.
Definition: Tpm12.h:380
EFI_STATUS
RETURN_STATUS EFI_STATUS
Definition: UefiBaseType.h:29
EFI_HANDLE
VOID * EFI_HANDLE
Definition: UefiBaseType.h:33
EFI_SUCCESS
#define EFI_SUCCESS
Definition: UefiBaseType.h:112
gST
EFI_SYSTEM_TABLE * gST
Definition: UefiBootServicesTableLib.c:16
gBS
EFI_BOOT_SERVICES * gBS
Definition: UefiBootServicesTableLib.c:17
UefiDriverEntryPoint.h
STRING_TOKEN
#define STRING_TOKEN(t)
Definition: UefiInternalFormRepresentation.h:2128
EFI_HII_HANDLE
VOID * EFI_HII_HANDLE
Definition: UefiInternalFormRepresentation.h:23
Print
UINTN EFIAPI Print(IN CONST CHAR16 *Format,...)
Definition: UefiLibPrint.c:113
EfiResetCold
@ EfiResetCold
Definition: UefiMultiPhase.h:139
EFI_VARIABLE_NON_VOLATILE
#define EFI_VARIABLE_NON_VOLATILE
Definition: UefiMultiPhase.h:15
_EDKII_VARIABLE_LOCK_PROTOCOL
Definition: VariableLock.h:50
_EFI_SIMPLE_TEXT_INPUT_PROTOCOL::WaitForKey
EFI_EVENT WaitForKey
Definition: SimpleTextIn.h:123
_EFI_TCG_PROTOCOL
Definition: TcgService.h:185
EFI_INPUT_KEY
Definition: SimpleTextIn.h:35
EFI_PHYSICAL_PRESENCE_FLAGS
Definition: PhysicalPresenceData.h:60
EFI_PHYSICAL_PRESENCE
Definition: PhysicalPresenceData.h:22
EFI_PHYSICAL_PRESENCE::PPRequest
UINT8 PPRequest
Physical Presence request command.
Definition: PhysicalPresenceData.h:23
EFI_SYSTEM_TABLE
Definition: UefiSpec.h:2028
EFI_SYSTEM_TABLE::ConIn
EFI_SIMPLE_TEXT_INPUT_PROTOCOL * ConIn
Definition: UefiSpec.h:2053
tdTPM_PERMANENT_FLAGS
Definition: Tpm12.h:732
tdTPM_RQU_COMMAND_HDR
Definition: Tpm12.h:2148
tdTPM_RSP_COMMAND_HDR
Definition: Tpm12.h:2157