DebugCommunicationLibUsb3Dxe.c

Go to the documentation of this file.

 
#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;
 
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;
}
 
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));
}
 
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
    );
}
 
VOID
EFIAPI
Usb3DxeSmmReadyToLockNotify (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  USB3_DEBUG_PORT_HANDLE  *Instance;
 
  DEBUG ((DEBUG_INFO, "%a()\n", __func__));
 
  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);
}
 
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;
}
 
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", __func__));
        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);
  }
}
 
EFI_PHYSICAL_ADDRESS *
GetUsb3DebugPortInstanceAddrPtr (
  VOID
  )
{
  if (mUsb3InstanceAddrPtr == NULL) {
    //
    // Use the local variables temporarily.
    //
    mUsb3InstanceAddr    = (EFI_PHYSICAL_ADDRESS)(UINTN)&mUsb3Instance;
    mUsb3InstanceAddrPtr = &mUsb3InstanceAddr;
  }
 
  return mUsb3InstanceAddrPtr;
}
 
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;
}
 
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;
}
 
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;
}
 
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;
}