| /** @file | |
| Debug Port Library implementation based on usb3 debug port. | |
| Copyright (c) 2014 - 2018, Intel Corporation. All rights reserved.<BR> | |
| SPDX-License-Identifier: BSD-2-Clause-Patent | |
| **/ | |
| #include <Base.h> | |
| #include <PiDxe.h> | |
| #include <Library/UefiBootServicesTableLib.h> | |
| #include <Library/HobLib.h> | |
| #include <Protocol/PciIo.h> | |
| #include <Protocol/IoMmu.h> | |
| #include <Protocol/DxeSmmReadyToLock.h> | |
| #include "DebugCommunicationLibUsb3Internal.h" | |
| GUID gUsb3DbgGuid = USB3_DBG_GUID; | |
| USB3_DEBUG_PORT_HANDLE mUsb3Instance = { USB3DBG_UNINITIALIZED }; | |
| EFI_PHYSICAL_ADDRESS mUsb3InstanceAddr = 0; | |
| EFI_PHYSICAL_ADDRESS *mUsb3InstanceAddrPtr = NULL; | |
| EFI_PCI_IO_PROTOCOL *mUsb3PciIo = NULL; | |
| /** | |
| Creates a named event that can be signaled. | |
| This function creates an event using NotifyTpl, NotifyFunction. | |
| If Name is NULL, then ASSERT(). | |
| If NotifyTpl is not a legal TPL value, then ASSERT(). | |
| If NotifyFunction is NULL, then ASSERT(). | |
| @param Name Supplies the GUID name of the event. | |
| @param NotifyTpl Supplies the task priority level of the event notifications. | |
| @param NotifyFunction Supplies the function to notify when the event is signaled. | |
| @param Event A pointer to the event created. | |
| @retval EFI_SUCCESS A named event was created. | |
| @retval EFI_OUT_OF_RESOURCES There are not enough resource to create the named event. | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| Usb3NamedEventListen ( | |
| IN CONST EFI_GUID *Name, | |
| IN EFI_TPL NotifyTpl, | |
| IN EFI_EVENT_NOTIFY NotifyFunction, | |
| IN EFI_EVENT *Event | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| VOID *RegistrationLocal; | |
| ASSERT (Name != NULL); | |
| ASSERT (NotifyFunction != NULL); | |
| ASSERT (NotifyTpl <= TPL_HIGH_LEVEL); | |
| // | |
| // Create event | |
| // | |
| Status = gBS->CreateEvent ( | |
| EVT_NOTIFY_SIGNAL, | |
| NotifyTpl, | |
| NotifyFunction, | |
| NULL, | |
| Event | |
| ); | |
| ASSERT_EFI_ERROR (Status); | |
| // | |
| // Register for an installation of protocol interface | |
| // | |
| Status = gBS->RegisterProtocolNotify ( | |
| (EFI_GUID *)Name, | |
| *Event, | |
| &RegistrationLocal | |
| ); | |
| ASSERT_EFI_ERROR (Status); | |
| return Status; | |
| } | |
| /** | |
| USB3 map one DMA buffer. | |
| @param PciIo Pointer to PciIo for USB3 debug port. | |
| @param Address DMA buffer address to be mapped. | |
| @param NumberOfBytes Number of bytes to be mapped. | |
| **/ | |
| VOID | |
| Usb3MapOneDmaBuffer ( | |
| IN EFI_PCI_IO_PROTOCOL *PciIo, | |
| IN EFI_PHYSICAL_ADDRESS Address, | |
| IN UINTN NumberOfBytes | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| VOID *HostAddress; | |
| EFI_PHYSICAL_ADDRESS DeviceAddress; | |
| VOID *Mapping; | |
| HostAddress = (VOID *)(UINTN)Address; | |
| Status = PciIo->Map ( | |
| PciIo, | |
| EfiPciIoOperationBusMasterCommonBuffer, | |
| HostAddress, | |
| &NumberOfBytes, | |
| &DeviceAddress, | |
| &Mapping | |
| ); | |
| ASSERT_EFI_ERROR (Status); | |
| ASSERT (DeviceAddress == ((EFI_PHYSICAL_ADDRESS)(UINTN)HostAddress)); | |
| } | |
| /** | |
| USB3 map DMA buffers. | |
| @param Instance Pointer to USB3 debug port instance. | |
| @param PciIo Pointer to PciIo for USB3 debug port. | |
| **/ | |
| VOID | |
| Usb3MapDmaBuffers ( | |
| IN USB3_DEBUG_PORT_HANDLE *Instance, | |
| IN EFI_PCI_IO_PROTOCOL *PciIo | |
| ) | |
| { | |
| Usb3MapOneDmaBuffer ( | |
| PciIo, | |
| Instance->UrbIn.Data, | |
| XHCI_DEBUG_DEVICE_MAX_PACKET_SIZE * 2 + USB3_DEBUG_PORT_WRITE_MAX_PACKET_SIZE | |
| ); | |
| Usb3MapOneDmaBuffer ( | |
| PciIo, | |
| Instance->TransferRingIn.RingSeg0, | |
| sizeof (TRB_TEMPLATE) * TR_RING_TRB_NUMBER | |
| ); | |
| Usb3MapOneDmaBuffer ( | |
| PciIo, | |
| Instance->TransferRingOut.RingSeg0, | |
| sizeof (TRB_TEMPLATE) * TR_RING_TRB_NUMBER | |
| ); | |
| Usb3MapOneDmaBuffer ( | |
| PciIo, | |
| Instance->EventRing.EventRingSeg0, | |
| sizeof (TRB_TEMPLATE) * EVENT_RING_TRB_NUMBER | |
| ); | |
| Usb3MapOneDmaBuffer ( | |
| PciIo, | |
| Instance->EventRing.ERSTBase, | |
| sizeof (EVENT_RING_SEG_TABLE_ENTRY) * ERST_NUMBER | |
| ); | |
| Usb3MapOneDmaBuffer ( | |
| PciIo, | |
| Instance->DebugCapabilityContext, | |
| sizeof (XHC_DC_CONTEXT) | |
| ); | |
| Usb3MapOneDmaBuffer ( | |
| PciIo, | |
| ((XHC_DC_CONTEXT *)(UINTN)Instance->DebugCapabilityContext)->DbcInfoContext.String0DescAddress, | |
| STRING0_DESC_LEN + MANU_DESC_LEN + PRODUCT_DESC_LEN + SERIAL_DESC_LEN | |
| ); | |
| } | |
| /** | |
| Invoke a notification event | |
| @param[in] Event Event whose notification function is being invoked. | |
| @param[in] Context The pointer to the notification function's context, | |
| which is implementation-dependent. | |
| **/ | |
| VOID | |
| EFIAPI | |
| Usb3DxeSmmReadyToLockNotify ( | |
| IN EFI_EVENT Event, | |
| IN VOID *Context | |
| ) | |
| { | |
| USB3_DEBUG_PORT_HANDLE *Instance; | |
| DEBUG ((DEBUG_INFO, "%a()\n", __FUNCTION__)); | |
| Instance = GetUsb3DebugPortInstance (); | |
| ASSERT (Instance != NULL); | |
| Instance->InNotify = TRUE; | |
| // | |
| // For the case that the USB3 debug port instance and DMA buffers are | |
| // from PEI HOB with IOMMU enabled. | |
| // Reinitialize USB3 debug port with granted DXE DMA buffer accessible | |
| // by SMM environment. | |
| // | |
| InitializeUsbDebugHardware (Instance); | |
| // | |
| // Wait some time for host to be ready after re-initialization. | |
| // | |
| MicroSecondDelay (1000000); | |
| Instance->InNotify = FALSE; | |
| gBS->CloseEvent (Event); | |
| } | |
| /** | |
| USB3 get IOMMU protocol. | |
| @return Pointer to IOMMU protocol. | |
| **/ | |
| EDKII_IOMMU_PROTOCOL * | |
| Usb3GetIoMmu ( | |
| VOID | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| EDKII_IOMMU_PROTOCOL *IoMmu; | |
| IoMmu = NULL; | |
| Status = gBS->LocateProtocol ( | |
| &gEdkiiIoMmuProtocolGuid, | |
| NULL, | |
| (VOID **)&IoMmu | |
| ); | |
| if (!EFI_ERROR (Status) && (IoMmu != NULL)) { | |
| return IoMmu; | |
| } | |
| return NULL; | |
| } | |
| /** | |
| Invoke a notification event | |
| @param[in] Event Event whose notification function is being invoked. | |
| @param[in] Context The pointer to the notification function's context, | |
| which is implementation-dependent. | |
| **/ | |
| VOID | |
| EFIAPI | |
| Usb3PciIoNotify ( | |
| IN EFI_EVENT Event, | |
| IN VOID *Context | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| UINTN PciIoHandleCount; | |
| EFI_HANDLE *PciIoHandleBuffer; | |
| UINTN Index; | |
| EFI_PCI_IO_PROTOCOL *PciIo; | |
| UINTN PciSegment; | |
| UINTN PciBusNumber; | |
| UINTN PciDeviceNumber; | |
| UINTN PciFunctionNumber; | |
| UINT32 PciAddress; | |
| USB3_DEBUG_PORT_HANDLE *Instance; | |
| EFI_EVENT SmmReadyToLockEvent; | |
| Status = gBS->LocateHandleBuffer ( | |
| ByProtocol, | |
| &gEfiPciIoProtocolGuid, | |
| NULL, | |
| &PciIoHandleCount, | |
| &PciIoHandleBuffer | |
| ); | |
| if (!EFI_ERROR (Status) && | |
| (PciIoHandleBuffer != NULL) && | |
| (PciIoHandleCount != 0)) | |
| { | |
| for (Index = 0; Index < PciIoHandleCount; Index++) { | |
| Status = gBS->HandleProtocol ( | |
| PciIoHandleBuffer[Index], | |
| &gEfiPciIoProtocolGuid, | |
| (VOID **)&PciIo | |
| ); | |
| ASSERT_EFI_ERROR (Status); | |
| Status = PciIo->GetLocation (PciIo, &PciSegment, &PciBusNumber, &PciDeviceNumber, &PciFunctionNumber); | |
| ASSERT_EFI_ERROR (Status); | |
| PciAddress = (UINT32)((PciBusNumber << 20) | (PciDeviceNumber << 15) | (PciFunctionNumber << 12)); | |
| if (PciAddress == PcdGet32 (PcdUsbXhciPciAddress)) { | |
| // | |
| // Found the PciIo for USB3 debug port. | |
| // | |
| DEBUG ((DEBUG_INFO, "%a()\n", __FUNCTION__)); | |
| if (Usb3GetIoMmu () != NULL) { | |
| Instance = GetUsb3DebugPortInstance (); | |
| ASSERT (Instance != NULL); | |
| if (Instance->Ready) { | |
| Instance->InNotify = TRUE; | |
| Usb3MapDmaBuffers (Instance, PciIo); | |
| Instance->InNotify = FALSE; | |
| if (Instance->FromHob) { | |
| mUsb3PciIo = PciIo; | |
| Usb3NamedEventListen ( | |
| &gEfiDxeSmmReadyToLockProtocolGuid, | |
| TPL_NOTIFY, | |
| Usb3DxeSmmReadyToLockNotify, | |
| &SmmReadyToLockEvent | |
| ); | |
| } | |
| } | |
| } | |
| gBS->CloseEvent (Event); | |
| break; | |
| } | |
| } | |
| gBS->FreePool (PciIoHandleBuffer); | |
| } | |
| } | |
| /** | |
| Return USB3 debug instance address pointer. | |
| **/ | |
| EFI_PHYSICAL_ADDRESS * | |
| GetUsb3DebugPortInstanceAddrPtr ( | |
| VOID | |
| ) | |
| { | |
| if (mUsb3InstanceAddrPtr == NULL) { | |
| // | |
| // Use the local variables temporarily. | |
| // | |
| mUsb3InstanceAddr = (EFI_PHYSICAL_ADDRESS)(UINTN)&mUsb3Instance; | |
| mUsb3InstanceAddrPtr = &mUsb3InstanceAddr; | |
| } | |
| return mUsb3InstanceAddrPtr; | |
| } | |
| /** | |
| Allocates pages that are suitable for an OperationBusMasterCommonBuffer or | |
| OperationBusMasterCommonBuffer64 mapping. | |
| @param PciIo Pointer to PciIo for USB3 debug port. | |
| @param Pages The number of pages to allocate. | |
| @param Address A pointer to store the base system memory address of the | |
| allocated range. | |
| @retval EFI_SUCCESS The requested memory pages were allocated. | |
| @retval EFI_UNSUPPORTED Attributes is unsupported. The only legal attribute bits are | |
| MEMORY_WRITE_COMBINE and MEMORY_CACHED. | |
| @retval EFI_INVALID_PARAMETER One or more parameters are invalid. | |
| @retval EFI_OUT_OF_RESOURCES The memory pages could not be allocated. | |
| **/ | |
| EFI_STATUS | |
| Usb3AllocateDmaBuffer ( | |
| IN EFI_PCI_IO_PROTOCOL *PciIo, | |
| IN UINTN Pages, | |
| OUT VOID **Address | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| *Address = NULL; | |
| Status = PciIo->AllocateBuffer ( | |
| PciIo, | |
| AllocateAnyPages, | |
| EfiRuntimeServicesData, | |
| Pages, | |
| Address, | |
| 0 | |
| ); | |
| if (!EFI_ERROR (Status)) { | |
| Usb3MapOneDmaBuffer ( | |
| PciIo, | |
| (EFI_PHYSICAL_ADDRESS)(UINTN)*Address, | |
| EFI_PAGES_TO_SIZE (Pages) | |
| ); | |
| } | |
| return Status; | |
| } | |
| /** | |
| Allocate aligned memory for XHC's usage. | |
| @param BufferSize The size, in bytes, of the Buffer. | |
| @return A pointer to the allocated buffer or NULL if allocation fails. | |
| **/ | |
| VOID * | |
| AllocateAlignBuffer ( | |
| IN UINTN BufferSize | |
| ) | |
| { | |
| EFI_PHYSICAL_ADDRESS TmpAddr; | |
| EFI_STATUS Status; | |
| VOID *Buf; | |
| Buf = NULL; | |
| if (gBS != NULL) { | |
| if (mUsb3PciIo != NULL) { | |
| Usb3AllocateDmaBuffer ( | |
| mUsb3PciIo, | |
| EFI_SIZE_TO_PAGES (BufferSize), | |
| &Buf | |
| ); | |
| } else { | |
| TmpAddr = 0xFFFFFFFF; | |
| Status = gBS->AllocatePages ( | |
| AllocateMaxAddress, | |
| EfiACPIMemoryNVS, | |
| EFI_SIZE_TO_PAGES (BufferSize), | |
| &TmpAddr | |
| ); | |
| if (!EFI_ERROR (Status)) { | |
| Buf = (VOID *)(UINTN)TmpAddr; | |
| } | |
| } | |
| } | |
| return Buf; | |
| } | |
| /** | |
| The constructor function initialize USB3 debug port. | |
| @param ImageHandle The firmware allocated handle for the EFI image. | |
| @param SystemTable A pointer to the EFI System Table. | |
| @retval EFI_SUCCESS The constructor always returns EFI_SUCCESS. | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| DebugCommunicationUsb3DxeConstructor ( | |
| IN EFI_HANDLE ImageHandle, | |
| IN EFI_SYSTEM_TABLE *SystemTable | |
| ) | |
| { | |
| EFI_PHYSICAL_ADDRESS *AddrPtr; | |
| USB3_DEBUG_PORT_HANDLE *Instance; | |
| EFI_PHYSICAL_ADDRESS Address; | |
| EFI_STATUS Status; | |
| EFI_EVENT Event; | |
| Status = EfiGetSystemConfigurationTable (&gUsb3DbgGuid, (VOID **)&AddrPtr); | |
| if (EFI_ERROR (Status) || (AddrPtr == NULL)) { | |
| // | |
| // Instead of using local variables, install system configuration table for | |
| // the local instance and the buffer to save instance address pointer. | |
| // | |
| Address = SIZE_4GB; | |
| Status = gBS->AllocatePages ( | |
| AllocateMaxAddress, | |
| EfiACPIMemoryNVS, | |
| EFI_SIZE_TO_PAGES (sizeof (EFI_PHYSICAL_ADDRESS) + sizeof (USB3_DEBUG_PORT_HANDLE)), | |
| &Address | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| return Status; | |
| } | |
| AddrPtr = (EFI_PHYSICAL_ADDRESS *)(UINTN)Address; | |
| ZeroMem (AddrPtr, sizeof (EFI_PHYSICAL_ADDRESS) + sizeof (USB3_DEBUG_PORT_HANDLE)); | |
| Instance = (USB3_DEBUG_PORT_HANDLE *)(AddrPtr + 1); | |
| CopyMem (Instance, &mUsb3Instance, sizeof (USB3_DEBUG_PORT_HANDLE)); | |
| *AddrPtr = (EFI_PHYSICAL_ADDRESS)(UINTN)Instance; | |
| Status = gBS->InstallConfigurationTable (&gUsb3DbgGuid, AddrPtr); | |
| if (EFI_ERROR (Status)) { | |
| return Status; | |
| } | |
| } | |
| if (mUsb3InstanceAddrPtr != NULL) { | |
| *AddrPtr = *mUsb3InstanceAddrPtr; | |
| } | |
| mUsb3InstanceAddrPtr = AddrPtr; | |
| Instance = GetUsb3DebugPortInstance (); | |
| ASSERT (Instance != NULL); | |
| if (Instance->PciIoEvent == 0) { | |
| Status = Usb3NamedEventListen ( | |
| &gEfiPciIoProtocolGuid, | |
| TPL_NOTIFY, | |
| Usb3PciIoNotify, | |
| &Event | |
| ); | |
| if (!EFI_ERROR (Status)) { | |
| Instance->PciIoEvent = (EFI_PHYSICAL_ADDRESS)(UINTN)Event; | |
| } | |
| } | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| The destructor function. | |
| @param ImageHandle The firmware allocated handle for the EFI image. | |
| @param SystemTable A pointer to the EFI System Table. | |
| @retval EFI_SUCCESS The destructor always returns EFI_SUCCESS. | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| DebugCommunicationUsb3DxeDestructor ( | |
| IN EFI_HANDLE ImageHandle, | |
| IN EFI_SYSTEM_TABLE *SystemTable | |
| ) | |
| { | |
| USB3_DEBUG_PORT_HANDLE *Instance; | |
| Instance = GetUsb3DebugPortInstance (); | |
| ASSERT (Instance != NULL); | |
| if (Instance->PciIoEvent != 0) { | |
| // | |
| // Close the event created. | |
| // | |
| gBS->CloseEvent ((EFI_EVENT)(UINTN)Instance->PciIoEvent); | |
| Instance->PciIoEvent = 0; | |
| } | |
| return EFI_SUCCESS; | |
| } |