| /** @file | |
| HII Config Access protocol implementation of TCG configuration module. | |
| Copyright (c) 2011 - 2019, Intel Corporation. All rights reserved.<BR> | |
| SPDX-License-Identifier: BSD-2-Clause-Patent | |
| **/ | |
| #include "TcgConfigImpl.h" | |
| CHAR16 mTcgStorageName[] = L"TCG_CONFIGURATION"; | |
| TCG_CONFIG_PRIVATE_DATA mTcgConfigPrivateDateTemplate = { | |
| TCG_CONFIG_PRIVATE_DATA_SIGNATURE, | |
| { | |
| TcgExtractConfig, | |
| TcgRouteConfig, | |
| TcgCallback | |
| } | |
| }; | |
| HII_VENDOR_DEVICE_PATH mTcgHiiVendorDevicePath = { | |
| { | |
| { | |
| HARDWARE_DEVICE_PATH, | |
| HW_VENDOR_DP, | |
| { | |
| (UINT8)(sizeof (VENDOR_DEVICE_PATH)), | |
| (UINT8)((sizeof (VENDOR_DEVICE_PATH)) >> 8) | |
| } | |
| }, | |
| TCG_CONFIG_FORM_SET_GUID | |
| }, | |
| { | |
| END_DEVICE_PATH_TYPE, | |
| END_ENTIRE_DEVICE_PATH_SUBTYPE, | |
| { | |
| (UINT8)(END_DEVICE_PATH_LENGTH), | |
| (UINT8)((END_DEVICE_PATH_LENGTH) >> 8) | |
| } | |
| } | |
| }; | |
| /** | |
| Get current state of TPM device. | |
| @param[in] TcgProtocol Point to EFI_TCG_PROTOCOL instance. | |
| @param[out] TpmEnable Flag to indicate TPM is enabled or not. | |
| @param[out] TpmActivate Flag to indicate TPM is activated or not. | |
| @retval EFI_SUCCESS State is successfully returned. | |
| @retval EFI_DEVICE_ERROR Failed to get TPM response. | |
| @retval Others Other errors as indicated. | |
| **/ | |
| EFI_STATUS | |
| GetTpmState ( | |
| IN EFI_TCG_PROTOCOL *TcgProtocol, | |
| OUT BOOLEAN *TpmEnable OPTIONAL, | |
| OUT BOOLEAN *TpmActivate OPTIONAL | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| TPM_RSP_COMMAND_HDR *TpmRsp; | |
| UINT32 TpmSendSize; | |
| TPM_PERMANENT_FLAGS *TpmPermanentFlags; | |
| UINT8 CmdBuf[64]; | |
| ASSERT (TcgProtocol != NULL); | |
| // | |
| // Get TPM Permanent flags (TpmEnable, TpmActivate) | |
| // | |
| if ((TpmEnable != NULL) || (TpmActivate != NULL)) { | |
| TpmSendSize = sizeof (TPM_RQU_COMMAND_HDR) + sizeof (UINT32) * 3; | |
| *(UINT16 *)&CmdBuf[0] = SwapBytes16 (TPM_TAG_RQU_COMMAND); | |
| *(UINT32 *)&CmdBuf[2] = SwapBytes32 (TpmSendSize); | |
| *(UINT32 *)&CmdBuf[6] = SwapBytes32 (TPM_ORD_GetCapability); | |
| *(UINT32 *)&CmdBuf[10] = SwapBytes32 (TPM_CAP_FLAG); | |
| *(UINT32 *)&CmdBuf[14] = SwapBytes32 (sizeof (TPM_CAP_FLAG_PERMANENT)); | |
| *(UINT32 *)&CmdBuf[18] = SwapBytes32 (TPM_CAP_FLAG_PERMANENT); | |
| Status = TcgProtocol->PassThroughToTpm ( | |
| TcgProtocol, | |
| TpmSendSize, | |
| CmdBuf, | |
| sizeof (CmdBuf), | |
| CmdBuf | |
| ); | |
| TpmRsp = (TPM_RSP_COMMAND_HDR *)&CmdBuf[0]; | |
| if (EFI_ERROR (Status) || (TpmRsp->tag != SwapBytes16 (TPM_TAG_RSP_COMMAND)) || (TpmRsp->returnCode != 0)) { | |
| return EFI_DEVICE_ERROR; | |
| } | |
| TpmPermanentFlags = (TPM_PERMANENT_FLAGS *)&CmdBuf[sizeof (TPM_RSP_COMMAND_HDR) + sizeof (UINT32)]; | |
| if (TpmEnable != NULL) { | |
| *TpmEnable = (BOOLEAN) !TpmPermanentFlags->disable; | |
| } | |
| if (TpmActivate != NULL) { | |
| *TpmActivate = (BOOLEAN) !TpmPermanentFlags->deactivated; | |
| } | |
| } | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| This function allows a caller to extract the current configuration for one | |
| or more named elements from the target driver. | |
| @param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL. | |
| @param[in] Request A null-terminated Unicode string in | |
| <ConfigRequest> format. | |
| @param[out] Progress On return, points to a character in the Request | |
| string. Points to the string's null terminator if | |
| request was successful. Points to the most recent | |
| '&' before the first failing name/value pair (or | |
| the beginning of the string if the failure is in | |
| the first name/value pair) if the request was not | |
| successful. | |
| @param[out] Results A null-terminated Unicode string in | |
| <ConfigAltResp> format which has all values filled | |
| in for the names in the Request string. String to | |
| be allocated by the called function. | |
| @retval EFI_SUCCESS The Results is filled with the requested values. | |
| @retval EFI_OUT_OF_RESOURCES Not enough memory to store the results. | |
| @retval EFI_INVALID_PARAMETER Request is illegal syntax, or unknown name. | |
| @retval EFI_NOT_FOUND Routing data doesn't match any storage in this | |
| driver. | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| TcgExtractConfig ( | |
| IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This, | |
| IN CONST EFI_STRING Request, | |
| OUT EFI_STRING *Progress, | |
| OUT EFI_STRING *Results | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| TCG_CONFIG_PRIVATE_DATA *PrivateData; | |
| EFI_STRING ConfigRequestHdr; | |
| EFI_STRING ConfigRequest; | |
| BOOLEAN AllocatedRequest; | |
| UINTN Size; | |
| BOOLEAN TpmEnable; | |
| BOOLEAN TpmActivate; | |
| if ((Progress == NULL) || (Results == NULL)) { | |
| return EFI_INVALID_PARAMETER; | |
| } | |
| *Progress = Request; | |
| if ((Request != NULL) && !HiiIsConfigHdrMatch (Request, &gTcgConfigFormSetGuid, mTcgStorageName)) { | |
| return EFI_NOT_FOUND; | |
| } | |
| ConfigRequestHdr = NULL; | |
| ConfigRequest = NULL; | |
| AllocatedRequest = FALSE; | |
| Size = 0; | |
| PrivateData = TCG_CONFIG_PRIVATE_DATA_FROM_THIS (This); | |
| // | |
| // Convert buffer data to <ConfigResp> by helper function BlockToConfig() | |
| // | |
| PrivateData->Configuration->TpmOperation = PHYSICAL_PRESENCE_NO_ACTION; | |
| // | |
| // Get current TPM state. | |
| // | |
| if (PrivateData->TcgProtocol != NULL) { | |
| Status = GetTpmState (PrivateData->TcgProtocol, &TpmEnable, &TpmActivate); | |
| if (EFI_ERROR (Status)) { | |
| return Status; | |
| } | |
| PrivateData->Configuration->TpmEnable = TpmEnable; | |
| PrivateData->Configuration->TpmActivate = TpmActivate; | |
| } | |
| ConfigRequest = Request; | |
| if ((Request == NULL) || (StrStr (Request, L"OFFSET") == NULL)) { | |
| // | |
| // Request has no request element, construct full request string. | |
| // Allocate and fill a buffer large enough to hold the <ConfigHdr> template | |
| // followed by "&OFFSET=0&WIDTH=WWWWWWWWWWWWWWWW" followed by a Null-terminator | |
| // | |
| ConfigRequestHdr = HiiConstructConfigHdr (&gTcgConfigFormSetGuid, mTcgStorageName, PrivateData->DriverHandle); | |
| Size = (StrLen (ConfigRequestHdr) + 32 + 1) * sizeof (CHAR16); | |
| ConfigRequest = AllocateZeroPool (Size); | |
| ASSERT (ConfigRequest != NULL); | |
| AllocatedRequest = TRUE; | |
| UnicodeSPrint (ConfigRequest, Size, L"%s&OFFSET=0&WIDTH=%016LX", ConfigRequestHdr, sizeof (TCG_CONFIGURATION)); | |
| FreePool (ConfigRequestHdr); | |
| } | |
| Status = gHiiConfigRouting->BlockToConfig ( | |
| gHiiConfigRouting, | |
| ConfigRequest, | |
| (UINT8 *)PrivateData->Configuration, | |
| sizeof (TCG_CONFIGURATION), | |
| Results, | |
| Progress | |
| ); | |
| // | |
| // Free the allocated config request string. | |
| // | |
| if (AllocatedRequest) { | |
| FreePool (ConfigRequest); | |
| } | |
| // | |
| // Set Progress string to the original request string. | |
| // | |
| if (Request == NULL) { | |
| *Progress = NULL; | |
| } else if (StrStr (Request, L"OFFSET") == NULL) { | |
| *Progress = Request + StrLen (Request); | |
| } | |
| return Status; | |
| } | |
| /** | |
| This function processes the results of changes in configuration. | |
| @param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL. | |
| @param[in] Configuration A null-terminated Unicode string in <ConfigResp> | |
| format. | |
| @param[out] Progress A pointer to a string filled in with the offset of | |
| the most recent '&' before the first failing | |
| name/value pair (or the beginning of the string if | |
| the failure is in the first name/value pair) or | |
| the terminating NULL if all was successful. | |
| @retval EFI_SUCCESS The Results is processed successfully. | |
| @retval EFI_INVALID_PARAMETER Configuration is NULL. | |
| @retval EFI_NOT_FOUND Routing data doesn't match any storage in this | |
| driver. | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| TcgRouteConfig ( | |
| IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This, | |
| IN CONST EFI_STRING Configuration, | |
| OUT EFI_STRING *Progress | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| UINTN BufferSize; | |
| TCG_CONFIGURATION TcgConfiguration; | |
| if ((Configuration == NULL) || (Progress == NULL)) { | |
| return EFI_INVALID_PARAMETER; | |
| } | |
| *Progress = Configuration; | |
| if (!HiiIsConfigHdrMatch (Configuration, &gTcgConfigFormSetGuid, mTcgStorageName)) { | |
| return EFI_NOT_FOUND; | |
| } | |
| // | |
| // Convert <ConfigResp> to buffer data by helper function ConfigToBlock() | |
| // | |
| BufferSize = sizeof (TCG_CONFIGURATION); | |
| Status = gHiiConfigRouting->ConfigToBlock ( | |
| gHiiConfigRouting, | |
| Configuration, | |
| (UINT8 *)&TcgConfiguration, | |
| &BufferSize, | |
| Progress | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| return Status; | |
| } | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| Save TPM request to variable space. | |
| @param[in] PpRequest Physical Presence request command. | |
| @retval EFI_SUCCESS The operation is finished successfully. | |
| @retval Others Other errors as indicated. | |
| **/ | |
| EFI_STATUS | |
| SavePpRequest ( | |
| IN UINT8 PpRequest | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| UINTN DataSize; | |
| EFI_PHYSICAL_PRESENCE PpData; | |
| // | |
| // Save TPM command to variable. | |
| // | |
| DataSize = sizeof (EFI_PHYSICAL_PRESENCE); | |
| Status = gRT->GetVariable ( | |
| PHYSICAL_PRESENCE_VARIABLE, | |
| &gEfiPhysicalPresenceGuid, | |
| NULL, | |
| &DataSize, | |
| &PpData | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| return Status; | |
| } | |
| PpData.PPRequest = PpRequest; | |
| Status = gRT->SetVariable ( | |
| PHYSICAL_PRESENCE_VARIABLE, | |
| &gEfiPhysicalPresenceGuid, | |
| EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS, | |
| DataSize, | |
| &PpData | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| return Status; | |
| } | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| This function processes the results of changes in configuration. | |
| @param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL. | |
| @param[in] Action Specifies the type of action taken by the browser. | |
| @param[in] QuestionId A unique value which is sent to the original | |
| exporting driver so that it can identify the type | |
| of data to expect. | |
| @param[in] Type The type of value for the question. | |
| @param[in] Value A pointer to the data being sent to the original | |
| exporting driver. | |
| @param[out] ActionRequest On return, points to the action requested by the | |
| callback function. | |
| @retval EFI_SUCCESS The callback successfully handled the action. | |
| @retval EFI_OUT_OF_RESOURCES Not enough storage is available to hold the | |
| variable and its data. | |
| @retval EFI_DEVICE_ERROR The variable could not be saved. | |
| @retval EFI_UNSUPPORTED The specified Action is not supported by the | |
| callback. | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| TcgCallback ( | |
| IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This, | |
| IN EFI_BROWSER_ACTION Action, | |
| IN EFI_QUESTION_ID QuestionId, | |
| IN UINT8 Type, | |
| IN EFI_IFR_TYPE_VALUE *Value, | |
| OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest | |
| ) | |
| { | |
| TCG_CONFIG_PRIVATE_DATA *PrivateData; | |
| CHAR16 State[32]; | |
| if ((This == NULL) || (Value == NULL) || (ActionRequest == NULL)) { | |
| return EFI_INVALID_PARAMETER; | |
| } | |
| if (Action == EFI_BROWSER_ACTION_FORM_OPEN) { | |
| if (QuestionId == KEY_TPM_ACTION) { | |
| PrivateData = TCG_CONFIG_PRIVATE_DATA_FROM_THIS (This); | |
| UnicodeSPrint ( | |
| State, | |
| sizeof (State), | |
| L"%s, and %s", | |
| PrivateData->Configuration->TpmEnable ? L"Enabled" : L"Disabled", | |
| PrivateData->Configuration->TpmActivate ? L"Activated" : L"Deactivated" | |
| ); | |
| HiiSetString (PrivateData->HiiHandle, STRING_TOKEN (STR_TPM_STATE_CONTENT), State, NULL); | |
| } | |
| return EFI_SUCCESS; | |
| } | |
| if ((Action != EFI_BROWSER_ACTION_CHANGED) || (QuestionId != KEY_TPM_ACTION)) { | |
| return EFI_UNSUPPORTED; | |
| } | |
| SavePpRequest (Value->u8); | |
| *ActionRequest = EFI_BROWSER_ACTION_REQUEST_SUBMIT; | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| This function publish the TCG configuration Form for TPM device. | |
| @param[in, out] PrivateData Points to TCG configuration private data. | |
| @retval EFI_SUCCESS HII Form is installed for this network device. | |
| @retval EFI_OUT_OF_RESOURCES Not enough resource for HII Form installation. | |
| @retval Others Other errors as indicated. | |
| **/ | |
| EFI_STATUS | |
| InstallTcgConfigForm ( | |
| IN OUT TCG_CONFIG_PRIVATE_DATA *PrivateData | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| EFI_HII_HANDLE HiiHandle; | |
| EFI_HANDLE DriverHandle; | |
| EFI_HII_CONFIG_ACCESS_PROTOCOL *ConfigAccess; | |
| DriverHandle = NULL; | |
| ConfigAccess = &PrivateData->ConfigAccess; | |
| Status = gBS->InstallMultipleProtocolInterfaces ( | |
| &DriverHandle, | |
| &gEfiDevicePathProtocolGuid, | |
| &mTcgHiiVendorDevicePath, | |
| &gEfiHiiConfigAccessProtocolGuid, | |
| ConfigAccess, | |
| NULL | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| return Status; | |
| } | |
| PrivateData->DriverHandle = DriverHandle; | |
| // | |
| // Publish the HII package list | |
| // | |
| HiiHandle = HiiAddPackages ( | |
| &gTcgConfigFormSetGuid, | |
| DriverHandle, | |
| TcgConfigDxeStrings, | |
| TcgConfigBin, | |
| NULL | |
| ); | |
| if (HiiHandle == NULL) { | |
| gBS->UninstallMultipleProtocolInterfaces ( | |
| DriverHandle, | |
| &gEfiDevicePathProtocolGuid, | |
| &mTcgHiiVendorDevicePath, | |
| &gEfiHiiConfigAccessProtocolGuid, | |
| ConfigAccess, | |
| NULL | |
| ); | |
| return EFI_OUT_OF_RESOURCES; | |
| } | |
| PrivateData->HiiHandle = HiiHandle; | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| This function removes TCG configuration Form. | |
| @param[in, out] PrivateData Points to TCG configuration private data. | |
| **/ | |
| VOID | |
| UninstallTcgConfigForm ( | |
| IN OUT TCG_CONFIG_PRIVATE_DATA *PrivateData | |
| ) | |
| { | |
| // | |
| // Uninstall HII package list | |
| // | |
| if (PrivateData->HiiHandle != NULL) { | |
| HiiRemovePackages (PrivateData->HiiHandle); | |
| PrivateData->HiiHandle = NULL; | |
| } | |
| // | |
| // Uninstall HII Config Access Protocol | |
| // | |
| if (PrivateData->DriverHandle != NULL) { | |
| gBS->UninstallMultipleProtocolInterfaces ( | |
| PrivateData->DriverHandle, | |
| &gEfiDevicePathProtocolGuid, | |
| &mTcgHiiVendorDevicePath, | |
| &gEfiHiiConfigAccessProtocolGuid, | |
| &PrivateData->ConfigAccess, | |
| NULL | |
| ); | |
| PrivateData->DriverHandle = NULL; | |
| } | |
| if (PrivateData->Configuration != NULL) { | |
| FreePool (PrivateData->Configuration); | |
| } | |
| FreePool (PrivateData); | |
| } |