]> git.proxmox.com Git - mirror_edk2.git/blob - SecurityPkg/Tcg/Tcg2Config/Tcg2ConfigImpl.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
SecurityPkg: Tcg2ConfigDxe: Remove duplicate local variable
[mirror_edk2.git] / SecurityPkg / Tcg / Tcg2Config / Tcg2ConfigImpl.c
1 /** @file
2 HII Config Access protocol implementation of TCG2 configuration module.
3 NOTE: This module is only for reference only, each platform should have its own setup page.
4
5 Copyright (c) 2015 - 2017, Intel Corporation. All rights reserved.<BR>
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php
10
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13
14 **/
15
16 #include "Tcg2ConfigImpl.h"
17 #include <Library/PcdLib.h>
18 #include <Library/Tpm2CommandLib.h>
19 #include <Library/IoLib.h>
20 #include <Guid/TpmInstance.h>
21
22 #include <IndustryStandard/TpmPtp.h>
23
24 #define EFI_TCG2_EVENT_LOG_FORMAT_ALL (EFI_TCG2_EVENT_LOG_FORMAT_TCG_1_2 | EFI_TCG2_EVENT_LOG_FORMAT_TCG_2)
25
26 TPM_INSTANCE_ID mTpmInstanceId[TPM_DEVICE_MAX + 1] = TPM_INSTANCE_ID_LIST;
27
28 TCG2_CONFIG_PRIVATE_DATA *mTcg2ConfigPrivateDate;
29 TCG2_CONFIG_PRIVATE_DATA mTcg2ConfigPrivateDateTemplate = {
30 TCG2_CONFIG_PRIVATE_DATA_SIGNATURE,
31 {
32 Tcg2ExtractConfig,
33 Tcg2RouteConfig,
34 Tcg2Callback
35 }
36 };
37
38 HII_VENDOR_DEVICE_PATH mTcg2HiiVendorDevicePath = {
39 {
40 {
41 HARDWARE_DEVICE_PATH,
42 HW_VENDOR_DP,
43 {
44 (UINT8) (sizeof (VENDOR_DEVICE_PATH)),
45 (UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8)
46 }
47 },
48 TCG2_CONFIG_FORM_SET_GUID
49 },
50 {
51 END_DEVICE_PATH_TYPE,
52 END_ENTIRE_DEVICE_PATH_SUBTYPE,
53 {
54 (UINT8) (END_DEVICE_PATH_LENGTH),
55 (UINT8) ((END_DEVICE_PATH_LENGTH) >> 8)
56 }
57 }
58 };
59
60 UINT8 mCurrentPpRequest;
61
62 /**
63 Return PTP interface type.
64
65 @param[in] Register Pointer to PTP register.
66
67 @return PTP interface type.
68 **/
69 UINT8
70 GetPtpInterface (
71 IN VOID *Register
72 )
73 {
74 PTP_CRB_INTERFACE_IDENTIFIER InterfaceId;
75 PTP_FIFO_INTERFACE_CAPABILITY InterfaceCapability;
76
77 //
78 // Check interface id
79 //
80 InterfaceId.Uint32 = MmioRead32 ((UINTN)&((PTP_CRB_REGISTERS *)Register)->InterfaceId);
81 InterfaceCapability.Uint32 = MmioRead32 ((UINTN)&((PTP_FIFO_REGISTERS *)Register)->InterfaceCapability);
82
83 if ((InterfaceId.Bits.InterfaceType == PTP_INTERFACE_IDENTIFIER_INTERFACE_TYPE_CRB) &&
84 (InterfaceId.Bits.InterfaceVersion == PTP_INTERFACE_IDENTIFIER_INTERFACE_VERSION_CRB) &&
85 (InterfaceId.Bits.CapCRB != 0)) {
86 return TPM_DEVICE_INTERFACE_PTP_CRB;
87 }
88 if ((InterfaceId.Bits.InterfaceType == PTP_INTERFACE_IDENTIFIER_INTERFACE_TYPE_FIFO) &&
89 (InterfaceId.Bits.InterfaceVersion == PTP_INTERFACE_IDENTIFIER_INTERFACE_VERSION_FIFO) &&
90 (InterfaceId.Bits.CapFIFO != 0) &&
91 (InterfaceCapability.Bits.InterfaceVersion == INTERFACE_CAPABILITY_INTERFACE_VERSION_PTP)) {
92 return TPM_DEVICE_INTERFACE_PTP_FIFO;
93 }
94 return TPM_DEVICE_INTERFACE_TIS;
95 }
96
97 /**
98 Return if PTP CRB is supported.
99
100 @param[in] Register Pointer to PTP register.
101
102 @retval TRUE PTP CRB is supported.
103 @retval FALSE PTP CRB is unsupported.
104 **/
105 BOOLEAN
106 IsPtpCrbSupported (
107 IN VOID *Register
108 )
109 {
110 PTP_CRB_INTERFACE_IDENTIFIER InterfaceId;
111
112 //
113 // Check interface id
114 //
115 InterfaceId.Uint32 = MmioRead32 ((UINTN)&((PTP_CRB_REGISTERS *)Register)->InterfaceId);
116
117 if (((InterfaceId.Bits.InterfaceType == PTP_INTERFACE_IDENTIFIER_INTERFACE_TYPE_CRB) ||
118 (InterfaceId.Bits.InterfaceType == PTP_INTERFACE_IDENTIFIER_INTERFACE_TYPE_FIFO)) &&
119 (InterfaceId.Bits.CapCRB != 0)) {
120 return TRUE;
121 }
122 return FALSE;
123 }
124
125 /**
126 Return if PTP FIFO is supported.
127
128 @param[in] Register Pointer to PTP register.
129
130 @retval TRUE PTP FIFO is supported.
131 @retval FALSE PTP FIFO is unsupported.
132 **/
133 BOOLEAN
134 IsPtpFifoSupported (
135 IN VOID *Register
136 )
137 {
138 PTP_CRB_INTERFACE_IDENTIFIER InterfaceId;
139
140 //
141 // Check interface id
142 //
143 InterfaceId.Uint32 = MmioRead32 ((UINTN)&((PTP_CRB_REGISTERS *)Register)->InterfaceId);
144
145 if (((InterfaceId.Bits.InterfaceType == PTP_INTERFACE_IDENTIFIER_INTERFACE_TYPE_CRB) ||
146 (InterfaceId.Bits.InterfaceType == PTP_INTERFACE_IDENTIFIER_INTERFACE_TYPE_FIFO)) &&
147 (InterfaceId.Bits.CapFIFO != 0)) {
148 return TRUE;
149 }
150 return FALSE;
151 }
152
153 /**
154 Set PTP interface type.
155
156 @param[in] Register Pointer to PTP register.
157 @param[in] PtpInterface PTP interface type.
158
159 @retval EFI_SUCCESS PTP interface type is set.
160 @retval EFI_INVALID_PARAMETER PTP interface type is invalid.
161 @retval EFI_UNSUPPORTED PTP interface type is unsupported.
162 @retval EFI_WRITE_PROTECTED PTP interface is locked.
163 **/
164 EFI_STATUS
165 SetPtpInterface (
166 IN VOID *Register,
167 IN UINT8 PtpInterface
168 )
169 {
170 UINT8 PtpInterfaceCurrent;
171 PTP_CRB_INTERFACE_IDENTIFIER InterfaceId;
172
173 PtpInterfaceCurrent = GetPtpInterface (Register);
174 if ((PtpInterfaceCurrent != TPM_DEVICE_INTERFACE_PTP_FIFO) &&
175 (PtpInterfaceCurrent != TPM_DEVICE_INTERFACE_PTP_CRB)) {
176 return EFI_UNSUPPORTED;
177 }
178 InterfaceId.Uint32 = MmioRead32 ((UINTN)&((PTP_CRB_REGISTERS *)Register)->InterfaceId);
179 if (InterfaceId.Bits.IntfSelLock != 0) {
180 return EFI_WRITE_PROTECTED;
181 }
182
183 switch (PtpInterface) {
184 case TPM_DEVICE_INTERFACE_PTP_FIFO:
185 if (InterfaceId.Bits.CapFIFO == 0) {
186 return EFI_UNSUPPORTED;
187 }
188 InterfaceId.Bits.InterfaceSelector = PTP_INTERFACE_IDENTIFIER_INTERFACE_SELECTOR_FIFO;
189 MmioWrite32 ((UINTN)&((PTP_CRB_REGISTERS *)Register)->InterfaceId, InterfaceId.Uint32);
190 return EFI_SUCCESS;
191 case TPM_DEVICE_INTERFACE_PTP_CRB:
192 if (InterfaceId.Bits.CapCRB == 0) {
193 return EFI_UNSUPPORTED;
194 }
195 InterfaceId.Bits.InterfaceSelector = PTP_INTERFACE_IDENTIFIER_INTERFACE_SELECTOR_CRB;
196 MmioWrite32 ((UINTN)&((PTP_CRB_REGISTERS *)Register)->InterfaceId, InterfaceId.Uint32);
197 return EFI_SUCCESS;
198 default:
199 return EFI_INVALID_PARAMETER;
200 }
201 }
202
203 /**
204 This function allows a caller to extract the current configuration for one
205 or more named elements from the target driver.
206
207 @param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
208 @param[in] Request A null-terminated Unicode string in
209 <ConfigRequest> format.
210 @param[out] Progress On return, points to a character in the Request
211 string. Points to the string's null terminator if
212 request was successful. Points to the most recent
213 '&' before the first failing name/value pair (or
214 the beginning of the string if the failure is in
215 the first name/value pair) if the request was not
216 successful.
217 @param[out] Results A null-terminated Unicode string in
218 <ConfigAltResp> format which has all values filled
219 in for the names in the Request string. String to
220 be allocated by the called function.
221
222 @retval EFI_SUCCESS The Results is filled with the requested values.
223 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the results.
224 @retval EFI_INVALID_PARAMETER Request is illegal syntax, or unknown name.
225 @retval EFI_NOT_FOUND Routing data doesn't match any storage in this
226 driver.
227
228 **/
229 EFI_STATUS
230 EFIAPI
231 Tcg2ExtractConfig (
232 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
233 IN CONST EFI_STRING Request,
234 OUT EFI_STRING *Progress,
235 OUT EFI_STRING *Results
236 )
237 {
238 if (Progress == NULL || Results == NULL) {
239 return EFI_INVALID_PARAMETER;
240 }
241
242 *Progress = Request;
243 return EFI_NOT_FOUND;
244 }
245
246 /**
247 Save TPM request to variable space.
248
249 @param[in] PpRequest Physical Presence request command.
250
251 @retval EFI_SUCCESS The operation is finished successfully.
252 @retval Others Other errors as indicated.
253
254 **/
255 EFI_STATUS
256 SaveTcg2PpRequest (
257 IN UINT8 PpRequest
258 )
259 {
260 UINT32 ReturnCode;
261 EFI_STATUS Status;
262
263 ReturnCode = Tcg2PhysicalPresenceLibSubmitRequestToPreOSFunction (PpRequest, 0);
264 if (ReturnCode == TCG_PP_SUBMIT_REQUEST_TO_PREOS_SUCCESS) {
265 mCurrentPpRequest = PpRequest;
266 Status = EFI_SUCCESS;
267 } else if (ReturnCode == TCG_PP_SUBMIT_REQUEST_TO_PREOS_GENERAL_FAILURE) {
268 Status = EFI_OUT_OF_RESOURCES;
269 } else if (ReturnCode == TCG_PP_SUBMIT_REQUEST_TO_PREOS_NOT_IMPLEMENTED) {
270 Status = EFI_UNSUPPORTED;
271 } else {
272 Status = EFI_DEVICE_ERROR;
273 }
274
275 return Status;
276 }
277
278 /**
279 Save TPM request to variable space.
280
281 @param[in] PpRequestParameter Physical Presence request parameter.
282
283 @retval EFI_SUCCESS The operation is finished successfully.
284 @retval Others Other errors as indicated.
285
286 **/
287 EFI_STATUS
288 SaveTcg2PpRequestParameter (
289 IN UINT32 PpRequestParameter
290 )
291 {
292 UINT32 ReturnCode;
293 EFI_STATUS Status;
294
295 ReturnCode = Tcg2PhysicalPresenceLibSubmitRequestToPreOSFunction (mCurrentPpRequest, PpRequestParameter);
296 if (ReturnCode == TCG_PP_SUBMIT_REQUEST_TO_PREOS_SUCCESS) {
297 Status = EFI_SUCCESS;
298 } else if (ReturnCode == TCG_PP_SUBMIT_REQUEST_TO_PREOS_GENERAL_FAILURE) {
299 Status = EFI_OUT_OF_RESOURCES;
300 } else if (ReturnCode == TCG_PP_SUBMIT_REQUEST_TO_PREOS_NOT_IMPLEMENTED) {
301 Status = EFI_UNSUPPORTED;
302 } else {
303 Status = EFI_DEVICE_ERROR;
304 }
305
306 return Status;
307 }
308
309 /**
310 Save Tcg2 PCR Banks request request to variable space.
311
312 @param[in] PCRBankIndex PCR Bank Index.
313 @param[in] Enable Enable or disable this PCR Bank.
314
315 @retval EFI_SUCCESS The operation is finished successfully.
316 @retval Others Other errors as indicated.
317
318 **/
319 EFI_STATUS
320 SaveTcg2PCRBanksRequest (
321 IN UINTN PCRBankIndex,
322 IN BOOLEAN Enable
323 )
324 {
325 UINT32 ReturnCode;
326 EFI_STATUS Status;
327
328 if (Enable) {
329 mTcg2ConfigPrivateDate->PCRBanksDesired |= (0x1 << PCRBankIndex);
330 } else {
331 mTcg2ConfigPrivateDate->PCRBanksDesired &= ~(0x1 << PCRBankIndex);
332 }
333
334 ReturnCode = Tcg2PhysicalPresenceLibSubmitRequestToPreOSFunction (TCG2_PHYSICAL_PRESENCE_SET_PCR_BANKS, mTcg2ConfigPrivateDate->PCRBanksDesired);
335 if (ReturnCode == TCG_PP_SUBMIT_REQUEST_TO_PREOS_SUCCESS) {
336 Status = EFI_SUCCESS;
337 } else if (ReturnCode == TCG_PP_SUBMIT_REQUEST_TO_PREOS_GENERAL_FAILURE) {
338 Status = EFI_OUT_OF_RESOURCES;
339 } else if (ReturnCode == TCG_PP_SUBMIT_REQUEST_TO_PREOS_NOT_IMPLEMENTED) {
340 Status = EFI_UNSUPPORTED;
341 } else {
342 Status = EFI_DEVICE_ERROR;
343 }
344
345 return Status;
346 }
347
348 /**
349 This function processes the results of changes in configuration.
350
351 @param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
352 @param[in] Configuration A null-terminated Unicode string in <ConfigResp>
353 format.
354 @param[out] Progress A pointer to a string filled in with the offset of
355 the most recent '&' before the first failing
356 name/value pair (or the beginning of the string if
357 the failure is in the first name/value pair) or
358 the terminating NULL if all was successful.
359
360 @retval EFI_SUCCESS The Results is processed successfully.
361 @retval EFI_INVALID_PARAMETER Configuration is NULL.
362 @retval EFI_NOT_FOUND Routing data doesn't match any storage in this
363 driver.
364
365 **/
366 EFI_STATUS
367 EFIAPI
368 Tcg2RouteConfig (
369 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
370 IN CONST EFI_STRING Configuration,
371 OUT EFI_STRING *Progress
372 )
373 {
374 if (Configuration == NULL || Progress == NULL) {
375 return EFI_INVALID_PARAMETER;
376 }
377
378 return EFI_NOT_FOUND;
379 }
380
381 /**
382 Get HID string of TPM2 ACPI device object
383
384 @param[in] Hid Points to HID String Buffer.
385 @param[in] Size HID String size in bytes. Must >= TPM_HID_ACPI_SIZE
386
387 @return HID String get status.
388
389 **/
390 EFI_STATUS
391 GetTpm2HID(
392 CHAR8 *Hid,
393 UINTN Size
394 )
395 {
396 EFI_STATUS Status;
397 UINT32 ManufacturerID;
398 UINT32 FirmwareVersion1;
399 UINT32 FirmwareVersion2;
400 BOOLEAN PnpHID;
401
402 PnpHID = TRUE;
403
404 ZeroMem(Hid, Size);
405
406 //
407 // Get Manufacturer ID
408 //
409 Status = Tpm2GetCapabilityManufactureID(&ManufacturerID);
410 if (!EFI_ERROR(Status)) {
411 DEBUG((DEBUG_INFO, "TPM_PT_MANUFACTURER 0x%08x\n", ManufacturerID));
412 //
413 // ManufacturerID defined in TCG Vendor ID Registry
414 // may tailed with 0x00 or 0x20
415 //
416 if ((ManufacturerID >> 24) == 0x00 || ((ManufacturerID >> 24) == 0x20)) {
417 //
418 // HID containing PNP ID "NNN####"
419 // NNN is uppercase letter for Vendor ID specified by manufacturer
420 //
421 CopyMem(Hid, &ManufacturerID, 3);
422 } else {
423 //
424 // HID containing ACP ID "NNNN####"
425 // NNNN is uppercase letter for Vendor ID specified by manufacturer
426 //
427 CopyMem(Hid, &ManufacturerID, 4);
428 PnpHID = FALSE;
429 }
430 } else {
431 DEBUG ((DEBUG_ERROR, "Get TPM_PT_MANUFACTURER failed %x!\n", Status));
432 ASSERT(FALSE);
433 return Status;
434 }
435
436 Status = Tpm2GetCapabilityFirmwareVersion(&FirmwareVersion1, &FirmwareVersion2);
437 if (!EFI_ERROR(Status)) {
438 DEBUG((DEBUG_INFO, "TPM_PT_FIRMWARE_VERSION_1 0x%x\n", FirmwareVersion1));
439 DEBUG((DEBUG_INFO, "TPM_PT_FIRMWARE_VERSION_2 0x%x\n", FirmwareVersion2));
440 //
441 // #### is Firmware Version 1
442 //
443 if (PnpHID) {
444 AsciiSPrint(Hid + 3, TPM_HID_PNP_SIZE - 3, "%02d%02d", ((FirmwareVersion1 & 0xFFFF0000) >> 16), (FirmwareVersion1 && 0x0000FFFF));
445 } else {
446 AsciiSPrint(Hid + 4, TPM_HID_ACPI_SIZE - 4, "%02d%02d", ((FirmwareVersion1 & 0xFFFF0000) >> 16), (FirmwareVersion1 && 0x0000FFFF));
447 }
448
449 } else {
450 DEBUG ((DEBUG_ERROR, "Get TPM_PT_FIRMWARE_VERSION_X failed %x!\n", Status));
451 ASSERT(FALSE);
452 return Status;
453 }
454
455 return EFI_SUCCESS;
456 }
457
458 /**
459 This function processes the results of changes in configuration.
460
461 @param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
462 @param[in] Action Specifies the type of action taken by the browser.
463 @param[in] QuestionId A unique value which is sent to the original
464 exporting driver so that it can identify the type
465 of data to expect.
466 @param[in] Type The type of value for the question.
467 @param[in] Value A pointer to the data being sent to the original
468 exporting driver.
469 @param[out] ActionRequest On return, points to the action requested by the
470 callback function.
471
472 @retval EFI_SUCCESS The callback successfully handled the action.
473 @retval EFI_OUT_OF_RESOURCES Not enough storage is available to hold the
474 variable and its data.
475 @retval EFI_DEVICE_ERROR The variable could not be saved.
476 @retval EFI_UNSUPPORTED The specified Action is not supported by the
477 callback.
478
479 **/
480 EFI_STATUS
481 EFIAPI
482 Tcg2Callback (
483 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
484 IN EFI_BROWSER_ACTION Action,
485 IN EFI_QUESTION_ID QuestionId,
486 IN UINT8 Type,
487 IN EFI_IFR_TYPE_VALUE *Value,
488 OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest
489 )
490 {
491 EFI_STATUS Status;
492 EFI_INPUT_KEY Key;
493 CHAR8 HidStr[16];
494 CHAR16 UnHidStr[16];
495 TCG2_CONFIG_PRIVATE_DATA *Private;
496
497 if ((This == NULL) || (Value == NULL) || (ActionRequest == NULL)) {
498 return EFI_INVALID_PARAMETER;
499 }
500
501 Private = TCG2_CONFIG_PRIVATE_DATA_FROM_THIS (This);
502
503 if (Action == EFI_BROWSER_ACTION_FORM_OPEN) {
504 //
505 // Update TPM2 HID info
506 //
507 if (QuestionId == KEY_TPM_DEVICE) {
508 Status = GetTpm2HID(HidStr, 16);
509
510 if (EFI_ERROR(Status)) {
511 //
512 // Fail to get TPM2 HID
513 //
514 HiiSetString (Private->HiiHandle, STRING_TOKEN (STR_TPM2_ACPI_HID_CONTENT), L"Unknown", NULL);
515 } else {
516 AsciiStrToUnicodeStrS(HidStr, UnHidStr, 16);
517 HiiSetString (Private->HiiHandle, STRING_TOKEN (STR_TPM2_ACPI_HID_CONTENT), UnHidStr, NULL);
518 }
519 }
520 return EFI_SUCCESS;
521 }
522
523 if (Action == EFI_BROWSER_ACTION_CHANGING) {
524 if (QuestionId == KEY_TPM_DEVICE_INTERFACE) {
525 Status = SetPtpInterface ((VOID *) (UINTN) PcdGet64 (PcdTpmBaseAddress), Value->u8);
526 if (EFI_ERROR (Status)) {
527 CreatePopUp (
528 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
529 &Key,
530 L"Error: Fail to set PTP interface!",
531 NULL
532 );
533 return EFI_DEVICE_ERROR;
534 }
535 }
536 }
537
538 if (Action == EFI_BROWSER_ACTION_CHANGED) {
539 if (QuestionId == KEY_TPM_DEVICE) {
540 return EFI_SUCCESS;
541 }
542 if (QuestionId == KEY_TPM2_OPERATION) {
543 return SaveTcg2PpRequest (Value->u8);
544 }
545 if (QuestionId == KEY_TPM2_OPERATION_PARAMETER) {
546 return SaveTcg2PpRequestParameter (Value->u32);
547 }
548 if ((QuestionId >= KEY_TPM2_PCR_BANKS_REQUEST_0) && (QuestionId <= KEY_TPM2_PCR_BANKS_REQUEST_4)) {
549 SaveTcg2PCRBanksRequest (QuestionId - KEY_TPM2_PCR_BANKS_REQUEST_0, Value->b);
550 }
551 }
552
553 return EFI_UNSUPPORTED;
554 }
555
556 /**
557 Append Buffer With TpmAlgHash.
558
559 @param[in] Buffer Buffer to be appended.
560 @param[in] BufferSize Size of buffer.
561 @param[in] TpmAlgHash TpmAlgHash.
562
563 **/
564 VOID
565 AppendBufferWithTpmAlgHash (
566 IN UINT16 *Buffer,
567 IN UINTN BufferSize,
568 IN UINT32 TpmAlgHash
569 )
570 {
571 switch (TpmAlgHash) {
572 case TPM_ALG_SHA1:
573 if (Buffer[0] != 0) {
574 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L", ");
575 }
576 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L"SHA1");
577 break;
578 case TPM_ALG_SHA256:
579 if (Buffer[0] != 0) {
580 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L", ");
581 }
582 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L"SHA256");
583 break;
584 case TPM_ALG_SHA384:
585 if (Buffer[0] != 0) {
586 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L", ");
587 }
588 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L"SHA384");
589 break;
590 case TPM_ALG_SHA512:
591 if (Buffer[0] != 0) {
592 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L", ");
593 }
594 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L"SHA512");
595 break;
596 case TPM_ALG_SM3_256:
597 if (Buffer[0] != 0) {
598 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L", ");
599 }
600 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L"SM3_256");
601 break;
602 }
603 }
604
605 /**
606 Fill Buffer With BootHashAlg.
607
608 @param[in] Buffer Buffer to be filled.
609 @param[in] BufferSize Size of buffer.
610 @param[in] BootHashAlg BootHashAlg.
611
612 **/
613 VOID
614 FillBufferWithBootHashAlg (
615 IN UINT16 *Buffer,
616 IN UINTN BufferSize,
617 IN UINT32 BootHashAlg
618 )
619 {
620 Buffer[0] = 0;
621 if ((BootHashAlg & EFI_TCG2_BOOT_HASH_ALG_SHA1) != 0) {
622 if (Buffer[0] != 0) {
623 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L", ");
624 }
625 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L"SHA1");
626 }
627 if ((BootHashAlg & EFI_TCG2_BOOT_HASH_ALG_SHA256) != 0) {
628 if (Buffer[0] != 0) {
629 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L", ");
630 }
631 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L"SHA256");
632 }
633 if ((BootHashAlg & EFI_TCG2_BOOT_HASH_ALG_SHA384) != 0) {
634 if (Buffer[0] != 0) {
635 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L", ");
636 }
637 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L"SHA384");
638 }
639 if ((BootHashAlg & EFI_TCG2_BOOT_HASH_ALG_SHA512) != 0) {
640 if (Buffer[0] != 0) {
641 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L", ");
642 }
643 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L"SHA512");
644 }
645 if ((BootHashAlg & EFI_TCG2_BOOT_HASH_ALG_SM3_256) != 0) {
646 if (Buffer[0] != 0) {
647 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L", ");
648 }
649 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L"SM3_256");
650 }
651 }
652
653 /**
654 Set ConfigInfo according to TpmAlgHash.
655
656 @param[in,out] Tcg2ConfigInfo TCG2 config info.
657 @param[in] TpmAlgHash TpmAlgHash.
658
659 **/
660 VOID
661 SetConfigInfo (
662 IN OUT TCG2_CONFIGURATION_INFO *Tcg2ConfigInfo,
663 IN UINT32 TpmAlgHash
664 )
665 {
666 switch (TpmAlgHash) {
667 case TPM_ALG_SHA1:
668 Tcg2ConfigInfo->Sha1Supported = TRUE;
669 break;
670 case TPM_ALG_SHA256:
671 Tcg2ConfigInfo->Sha256Supported = TRUE;
672 break;
673 case TPM_ALG_SHA384:
674 Tcg2ConfigInfo->Sha384Supported = TRUE;
675 break;
676 case TPM_ALG_SHA512:
677 Tcg2ConfigInfo->Sha512Supported = TRUE;
678 break;
679 case TPM_ALG_SM3_256:
680 Tcg2ConfigInfo->Sm3Supported = TRUE;
681 break;
682 }
683 }
684
685 /**
686 Fill Buffer With TCG2EventLogFormat.
687
688 @param[in] Buffer Buffer to be filled.
689 @param[in] BufferSize Size of buffer.
690 @param[in] TCG2EventLogFormat TCG2EventLogFormat.
691
692 **/
693 VOID
694 FillBufferWithTCG2EventLogFormat (
695 IN UINT16 *Buffer,
696 IN UINTN BufferSize,
697 IN UINT32 TCG2EventLogFormat
698 )
699 {
700 Buffer[0] = 0;
701 if ((TCG2EventLogFormat & EFI_TCG2_EVENT_LOG_FORMAT_TCG_1_2) != 0) {
702 if (Buffer[0] != 0) {
703 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L", ");
704 }
705 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L"TCG_1_2");
706 }
707 if ((TCG2EventLogFormat & EFI_TCG2_EVENT_LOG_FORMAT_TCG_2) != 0) {
708 if (Buffer[0] != 0) {
709 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L", ");
710 }
711 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L"TCG_2");
712 }
713 if ((TCG2EventLogFormat & (~EFI_TCG2_EVENT_LOG_FORMAT_ALL)) != 0) {
714 if (Buffer[0] != 0) {
715 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L", ");
716 }
717 StrCatS (Buffer, BufferSize / sizeof (CHAR16), L"UNKNOWN");
718 }
719 }
720
721 /**
722 This function publish the TCG2 configuration Form for TPM device.
723
724 @param[in, out] PrivateData Points to TCG2 configuration private data.
725
726 @retval EFI_SUCCESS HII Form is installed for this network device.
727 @retval EFI_OUT_OF_RESOURCES Not enough resource for HII Form installation.
728 @retval Others Other errors as indicated.
729
730 **/
731 EFI_STATUS
732 InstallTcg2ConfigForm (
733 IN OUT TCG2_CONFIG_PRIVATE_DATA *PrivateData
734 )
735 {
736 EFI_STATUS Status;
737 EFI_HII_HANDLE HiiHandle;
738 EFI_HANDLE DriverHandle;
739 EFI_HII_CONFIG_ACCESS_PROTOCOL *ConfigAccess;
740 UINTN Index;
741 TPML_PCR_SELECTION Pcrs;
742 CHAR16 TempBuffer[1024];
743 TCG2_CONFIGURATION_INFO Tcg2ConfigInfo;
744 UINT8 TpmDeviceInterfaceDetected;
745
746 DriverHandle = NULL;
747 ConfigAccess = &PrivateData->ConfigAccess;
748 Status = gBS->InstallMultipleProtocolInterfaces (
749 &DriverHandle,
750 &gEfiDevicePathProtocolGuid,
751 &mTcg2HiiVendorDevicePath,
752 &gEfiHiiConfigAccessProtocolGuid,
753 ConfigAccess,
754 NULL
755 );
756 if (EFI_ERROR (Status)) {
757 return Status;
758 }
759
760 PrivateData->DriverHandle = DriverHandle;
761
762 //
763 // Publish the HII package list
764 //
765 HiiHandle = HiiAddPackages (
766 &gTcg2ConfigFormSetGuid,
767 DriverHandle,
768 Tcg2ConfigDxeStrings,
769 Tcg2ConfigBin,
770 NULL
771 );
772 if (HiiHandle == NULL) {
773 gBS->UninstallMultipleProtocolInterfaces (
774 DriverHandle,
775 &gEfiDevicePathProtocolGuid,
776 &mTcg2HiiVendorDevicePath,
777 &gEfiHiiConfigAccessProtocolGuid,
778 ConfigAccess,
779 NULL
780 );
781
782 return EFI_OUT_OF_RESOURCES;
783 }
784
785 PrivateData->HiiHandle = HiiHandle;
786
787 //
788 // Update static data
789 //
790 switch (PrivateData->TpmDeviceDetected) {
791 case TPM_DEVICE_NULL:
792 HiiSetString (PrivateData->HiiHandle, STRING_TOKEN (STR_TCG2_DEVICE_STATE_CONTENT), L"Not Found", NULL);
793 break;
794 case TPM_DEVICE_1_2:
795 HiiSetString (PrivateData->HiiHandle, STRING_TOKEN (STR_TCG2_DEVICE_STATE_CONTENT), L"TPM 1.2", NULL);
796 break;
797 case TPM_DEVICE_2_0_DTPM:
798 HiiSetString (PrivateData->HiiHandle, STRING_TOKEN (STR_TCG2_DEVICE_STATE_CONTENT), L"TPM 2.0", NULL);
799 break;
800 default:
801 HiiSetString (PrivateData->HiiHandle, STRING_TOKEN (STR_TCG2_DEVICE_STATE_CONTENT), L"Unknown", NULL);
802 break;
803 }
804
805 ZeroMem (&Tcg2ConfigInfo, sizeof(Tcg2ConfigInfo));
806 Status = Tpm2GetCapabilityPcrs (&Pcrs);
807 if (EFI_ERROR (Status)) {
808 HiiSetString (PrivateData->HiiHandle, STRING_TOKEN (STR_TPM2_ACTIVE_HASH_ALGO_CONTENT), L"[Unknown]", NULL);
809 HiiSetString (PrivateData->HiiHandle, STRING_TOKEN (STR_TPM2_SUPPORTED_HASH_ALGO_CONTENT), L"[Unknown]", NULL);
810 } else {
811 TempBuffer[0] = 0;
812 for (Index = 0; Index < Pcrs.count; Index++) {
813 if (!IsZeroBuffer (Pcrs.pcrSelections[Index].pcrSelect, Pcrs.pcrSelections[Index].sizeofSelect)) {
814 AppendBufferWithTpmAlgHash (TempBuffer, sizeof(TempBuffer), Pcrs.pcrSelections[Index].hash);
815 }
816 }
817 HiiSetString (PrivateData->HiiHandle, STRING_TOKEN (STR_TPM2_ACTIVE_HASH_ALGO_CONTENT), TempBuffer, NULL);
818
819 TempBuffer[0] = 0;
820 for (Index = 0; Index < Pcrs.count; Index++) {
821 AppendBufferWithTpmAlgHash (TempBuffer, sizeof(TempBuffer), Pcrs.pcrSelections[Index].hash);
822 SetConfigInfo (&Tcg2ConfigInfo, Pcrs.pcrSelections[Index].hash);
823 }
824 HiiSetString (PrivateData->HiiHandle, STRING_TOKEN (STR_TPM2_SUPPORTED_HASH_ALGO_CONTENT), TempBuffer, NULL);
825 }
826
827 FillBufferWithBootHashAlg (TempBuffer, sizeof(TempBuffer), PcdGet32 (PcdTcg2HashAlgorithmBitmap));
828 HiiSetString (PrivateData->HiiHandle, STRING_TOKEN (STR_BIOS_HASH_ALGO_CONTENT), TempBuffer, NULL);
829
830 //
831 // Tcg2 Capability
832 //
833 FillBufferWithTCG2EventLogFormat (TempBuffer, sizeof(TempBuffer), PrivateData->ProtocolCapability.SupportedEventLogs);
834 HiiSetString (PrivateData->HiiHandle, STRING_TOKEN (STR_TCG2_SUPPORTED_EVENT_LOG_FORMAT_CONTENT), TempBuffer, NULL);
835
836 FillBufferWithBootHashAlg (TempBuffer, sizeof(TempBuffer), PrivateData->ProtocolCapability.HashAlgorithmBitmap);
837 HiiSetString (PrivateData->HiiHandle, STRING_TOKEN (STR_TCG2_HASH_ALGO_BITMAP_CONTENT), TempBuffer, NULL);
838
839 UnicodeSPrint (TempBuffer, sizeof (TempBuffer), L"%d", PrivateData->ProtocolCapability.NumberOfPCRBanks);
840 HiiSetString (PrivateData->HiiHandle, STRING_TOKEN (STR_TCG2_NUMBER_OF_PCR_BANKS_CONTENT), TempBuffer, NULL);
841
842 FillBufferWithBootHashAlg (TempBuffer, sizeof(TempBuffer), PrivateData->ProtocolCapability.ActivePcrBanks);
843 HiiSetString (PrivateData->HiiHandle, STRING_TOKEN (STR_TCG2_ACTIVE_PCR_BANKS_CONTENT), TempBuffer, NULL);
844
845 //
846 // Update TPM device interface type
847 //
848 if (PrivateData->TpmDeviceDetected == TPM_DEVICE_2_0_DTPM) {
849 TpmDeviceInterfaceDetected = GetPtpInterface ((VOID *) (UINTN) PcdGet64 (PcdTpmBaseAddress));
850 switch (TpmDeviceInterfaceDetected) {
851 case TPM_DEVICE_INTERFACE_TIS:
852 HiiSetString (PrivateData->HiiHandle, STRING_TOKEN (STR_TCG2_DEVICE_INTERFACE_STATE_CONTENT), L"TIS", NULL);
853 break;
854 case TPM_DEVICE_INTERFACE_PTP_FIFO:
855 HiiSetString (PrivateData->HiiHandle, STRING_TOKEN (STR_TCG2_DEVICE_INTERFACE_STATE_CONTENT), L"PTP FIFO", NULL);
856 break;
857 case TPM_DEVICE_INTERFACE_PTP_CRB:
858 HiiSetString (PrivateData->HiiHandle, STRING_TOKEN (STR_TCG2_DEVICE_INTERFACE_STATE_CONTENT), L"PTP CRB", NULL);
859 break;
860 default:
861 HiiSetString (PrivateData->HiiHandle, STRING_TOKEN (STR_TCG2_DEVICE_INTERFACE_STATE_CONTENT), L"Unknown", NULL);
862 break;
863 }
864
865 Tcg2ConfigInfo.TpmDeviceInterfaceAttempt = TpmDeviceInterfaceDetected;
866 switch (TpmDeviceInterfaceDetected) {
867 case TPM_DEVICE_INTERFACE_TIS:
868 Tcg2ConfigInfo.TpmDeviceInterfacePtpFifoSupported = FALSE;
869 Tcg2ConfigInfo.TpmDeviceInterfacePtpCrbSupported = FALSE;
870 HiiSetString (PrivateData->HiiHandle, STRING_TOKEN (STR_TCG2_DEVICE_INTERFACE_CAPABILITY_CONTENT), L"TIS", NULL);
871 break;
872 case TPM_DEVICE_INTERFACE_PTP_FIFO:
873 case TPM_DEVICE_INTERFACE_PTP_CRB:
874 Tcg2ConfigInfo.TpmDeviceInterfacePtpFifoSupported = IsPtpFifoSupported((VOID *) (UINTN) PcdGet64 (PcdTpmBaseAddress));
875 Tcg2ConfigInfo.TpmDeviceInterfacePtpCrbSupported = IsPtpCrbSupported((VOID *) (UINTN) PcdGet64 (PcdTpmBaseAddress));
876 TempBuffer[0] = 0;
877 if (Tcg2ConfigInfo.TpmDeviceInterfacePtpFifoSupported) {
878 if (TempBuffer[0] != 0) {
879 StrCatS (TempBuffer, sizeof(TempBuffer) / sizeof (CHAR16), L", ");
880 }
881 StrCatS (TempBuffer, sizeof(TempBuffer) / sizeof (CHAR16), L"PTP FIFO");
882 }
883 if (Tcg2ConfigInfo.TpmDeviceInterfacePtpCrbSupported) {
884 if (TempBuffer[0] != 0) {
885 StrCatS (TempBuffer, sizeof(TempBuffer) / sizeof (CHAR16), L", ");
886 }
887 StrCatS (TempBuffer, sizeof(TempBuffer) / sizeof (CHAR16), L"PTP CRB");
888 }
889 HiiSetString (PrivateData->HiiHandle, STRING_TOKEN (STR_TCG2_DEVICE_INTERFACE_CAPABILITY_CONTENT), TempBuffer, NULL);
890 break;
891 default:
892 Tcg2ConfigInfo.TpmDeviceInterfacePtpFifoSupported = FALSE;
893 Tcg2ConfigInfo.TpmDeviceInterfacePtpCrbSupported = FALSE;
894 HiiSetString (PrivateData->HiiHandle, STRING_TOKEN (STR_TCG2_DEVICE_INTERFACE_CAPABILITY_CONTENT), L"Unknown", NULL);
895 break;
896 }
897 }
898
899 //
900 // Set ConfigInfo, to control the check box.
901 //
902 Status = gRT->SetVariable (
903 TCG2_STORAGE_INFO_NAME,
904 &gTcg2ConfigFormSetGuid,
905 EFI_VARIABLE_BOOTSERVICE_ACCESS,
906 sizeof(Tcg2ConfigInfo),
907 &Tcg2ConfigInfo
908 );
909 if (EFI_ERROR (Status)) {
910 DEBUG ((EFI_D_ERROR, "Tcg2ConfigDriver: Fail to set TCG2_STORAGE_INFO_NAME\n"));
911 }
912 return EFI_SUCCESS;
913 }
914
915 /**
916 This function removes TCG2 configuration Form.
917
918 @param[in, out] PrivateData Points to TCG2 configuration private data.
919
920 **/
921 VOID
922 UninstallTcg2ConfigForm (
923 IN OUT TCG2_CONFIG_PRIVATE_DATA *PrivateData
924 )
925 {
926 //
927 // Uninstall HII package list
928 //
929 if (PrivateData->HiiHandle != NULL) {
930 HiiRemovePackages (PrivateData->HiiHandle);
931 PrivateData->HiiHandle = NULL;
932 }
933
934 //
935 // Uninstall HII Config Access Protocol
936 //
937 if (PrivateData->DriverHandle != NULL) {
938 gBS->UninstallMultipleProtocolInterfaces (
939 PrivateData->DriverHandle,
940 &gEfiDevicePathProtocolGuid,
941 &mTcg2HiiVendorDevicePath,
942 &gEfiHiiConfigAccessProtocolGuid,
943 &PrivateData->ConfigAccess,
944 NULL
945 );
946 PrivateData->DriverHandle = NULL;
947 }
948
949 FreePool (PrivateData);
950 }
EFI Development Kit II mirror for PVE