Import SourceLevelDebugPkg.

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@10867 6f19259b-4bc3-4df7-8a09-765794883524

2 files changed, 1129 insertions, 0 deletions

diff --git a/SourceLevelDebugPkg/Library/DebugCommunicationLibUsb/DebugCommunicationLibUsb.c b/SourceLevelDebugPkg/Library/DebugCommunicationLibUsb/DebugCommunicationLibUsb.c
new file mode 100644
index 0000000000..588e45853d
--- /dev/null
+++ b/SourceLevelDebugPkg/Library/DebugCommunicationLibUsb/DebugCommunicationLibUsb.c
@@ -0,0 +1,1076 @@
+/** @file

+  Debug Port Library implementation based on usb debug port.

+

+  Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php.

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include <Base.h>

+#include <IndustryStandard/Pci.h>

+#include <IndustryStandard/Usb.h>

+#include <Library/IoLib.h>

+#include <Library/PciLib.h>

+#include <Library/PcdLib.h>

+#include <Library/TimerLib.h>

+#include <Library/DebugCommunicationLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/BaseLib.h>

+

+#define SETUP_PID            0x2D

+#define INPUT_PID            0x69

+#define OUTPUT_PID           0xE1

+#define ERROR_PID            0x55

+#define DATA0_PID            0xC3

+#define DATA1_PID            0x4B

+#define DATA2_PID            0x87

+#define MDATA_PID            0x0F

+#define ACK_PID              0xD2

+#define NAK_PID              0x5A

+#define STALL_PID            0x1E

+#define NYET_PID             0x96

+

+#define PCI_CAPABILITY_ID_DEBUG_PORT   0x0A

+#define USB_DEBUG_PORT_MAX_PACKET_SIZE 0x08

+

+#define USB_DEBUG_PORT_IN_USE     BIT10

+#define USB_DEBUG_PORT_ENABLE     BIT28

+#define USB_DEBUG_PORT_OWNER      BIT30

+

+#define USB_PORT_LINE_STATUS_LS   0x400

+#define USB_PORT_LINE_STATUS_MASK 0xC00

+

+//

+// Usb debug device descriptor, which is defined at

+// USB2 Debug Device Specification.

+//

+typedef struct _USB_DEBUG_PORT_DESCRIPTOR {

+  UINT8          Length;

+  UINT8          DescriptorType;

+  UINT8          DebugInEndpoint;

+  UINT8          DebugOutEndpoint;

+}USB_DEBUG_PORT_DESCRIPTOR;

+

+USB_DEVICE_REQUEST mGetDebugDescriptor = {

+  0x80,

+  USB_REQ_GET_DESCRIPTOR,

+  (UINT16)(0x0A << 8),

+  0x0000,

+  sizeof(USB_DEBUG_PORT_DESCRIPTOR)

+  };

+

+USB_DEVICE_REQUEST mSetDebugFeature = {

+  0x0,

+  USB_REQ_SET_FEATURE,

+  (UINT16)(0x06),

+  0x0000,

+  0x0

+  };

+

+USB_DEVICE_REQUEST mSetDebugAddress = {

+  0x0,

+  USB_REQ_SET_ADDRESS,

+  (UINT16)(0x7F),

+  0x0000,

+  0x0

+  };

+

+//

+// Usb debug port register file, which is defined at

+// EHCI Specification.

+//

+typedef struct _USB_DEBUG_PORT_REGISTER {

+  UINT32         ControlStatus;

+  UINT8          TokenPid;

+  UINT8          SendPid;

+  UINT8          ReceivedPid;

+  UINT8          Reserved1;

+  UINT8          DataBuffer[8];

+  UINT8          UsbEndPoint;

+  UINT8          UsbAddress;

+  UINT8          Reserved2;

+  UINT8          Reserved3;

+}USB_DEBUG_PORT_REGISTER;

+

+#pragma pack(1)

+//

+// The internal data structure of DEBUG_PORT_HANDLE, which stores some

+// important datum which are used across various phases.

+//

+typedef struct _USB_DEBUG_PORT_HANDLE{

+  //

+  // The usb debug port memory BAR number in EHCI configuration space.

+  //

+  UINT8        DebugPortBarNumber;

+  UINT8        Reserved;

+  //

+  // The offset of usb debug port registers in EHCI memory range.

+  //

+  UINT16       DebugPortOffset;

+  //

+  // The usb debug port memory BAR address.

+  //

+  UINTN        UsbDebugPortMemoryBase;

+  //

+  // The EHCI memory BAR address.

+  //

+  UINTN        EhciMemoryBase;

+  //

+  // The Bulk In endpoint toggle bit.

+  //

+  UINT8        BulkInToggle;

+  //

+  // The Bulk Out endpoint toggle bit.

+  //

+  UINT8        BulkOutToggle;

+  //

+  // The available data length in the following data buffer.

+  //

+  UINT8        DataCount;

+  //

+  // The data buffer. Maximum length is 8 bytes.

+  //

+  UINT8        Data[8];

+} USB_DEBUG_PORT_HANDLE;

+#pragma pack()

+

+//

+// The global variable which can be used after memory is ready.

+//

+USB_DEBUG_PORT_HANDLE     mUsbDebugPortHandle;

+

+/**

+  Calculate the usb debug port bar address.

+

+  @param  DebugPortOffset    Get usb debug port offset in the usb debug port memory space.

+  @param  DebugPortBarNumbar Get the bar number at which usb debug port is located.

+

+  @retval RETURN_UNSUPPORTED The usb host controller does not supported usb debug port capability.

+  @retval RETURN_SUCCESS     Get bar and offset successfully.

+

+**/

+RETURN_STATUS

+EFIAPI

+CalculateUsbDebugPortBar (

+  OUT UINT16     *DebugPortOffset,

+  OUT UINT8      *DebugPortBarNumbar

+ )

+{

+  UINT16     PciStatus;

+  UINT8      CapabilityPtr;

+  UINT8      CapabilityId;

+

+  //

+  // Enable Ehci Host Controller MMIO Space.

+  //

+  PciStatus = PciRead16 (PcdGet32(PcdUsbEhciPciAddress) + PCI_PRIMARY_STATUS_OFFSET);

+

+  if ((PciStatus & EFI_PCI_STATUS_CAPABILITY) == 0) {

+    //

+    // The Pci Device Doesn't Support Capability Pointer.

+    //

+    return RETURN_UNSUPPORTED;

+  }

+

+  //

+  // Get Pointer To Capability List

+  //

+  CapabilityPtr = PciRead8(PcdGet32(PcdUsbEhciPciAddress) + PCI_CAPBILITY_POINTER_OFFSET);

+

+  //

+  // Find Capability ID 0xA, Which Is For Debug Port

+  //

+  while (CapabilityPtr != 0) {

+    CapabilityId = PciRead8(PcdGet32(PcdUsbEhciPciAddress) + CapabilityPtr);

+    if (CapabilityId == PCI_CAPABILITY_ID_DEBUG_PORT) {

+      break;

+    }

+    CapabilityPtr = PciRead8(PcdGet32(PcdUsbEhciPciAddress) + CapabilityPtr + 1);

+  }

+

+  //

+  // No Debug Port Capability Found

+  //

+  if (CapabilityPtr == 0) {

+    return RETURN_UNSUPPORTED;

+  }

+

+  //

+  // Get The Base Address Of Debug Port Register In Debug Port Capability Register

+  //

+  *DebugPortOffset    = (UINT16)(PciRead16(PcdGet32(PcdUsbEhciPciAddress) + CapabilityPtr + 2) & 0x1FFF);

+  *DebugPortBarNumbar = (UINT8)((PciRead16(PcdGet32(PcdUsbEhciPciAddress) + CapabilityPtr + 2) >> 13) - 1);

+

+  return RETURN_SUCCESS;

+}

+

+/**

+  Do a usb IN transaction by usb debug port.

+

+  @param  DebugPortRegister        Pointer to the base address of usb debug port register interface.

+  @param  Buffer                   Pointer to the buffer receiving data.

+  @param  Length                   Number of bytes of the received data.

+  @param  Token                    The token PID for each USB transaction.

+  @param  Addr                     The usb device address for usb transaction.

+  @param  Ep                       The endpoint for usb transaction.

+  @param  DataToggle               The toggle bit used at usb transaction.

+

+  @retval RETURN_SUCCESS           The IN transaction is executed successfully.

+  @retval RETURN_INVALID_PARAMETER The parameters passed in are invalid.

+  @retval RETURN_DEVICE_ERROR      The IN transaction comes across error.

+

+**/

+RETURN_STATUS

+EFIAPI

+UsbDebugPortIn (

+  IN      USB_DEBUG_PORT_REGISTER         *DebugPortRegister,

+  IN  OUT UINT8                           *Buffer,

+      OUT UINT8                           *Length,

+  IN      UINT8                           Token,

+  IN      UINT8                           Addr,

+  IN      UINT8                           Ep,

+  IN      UINT8                           DataToggle

+  )

+{

+  UINTN                   Index;

+

+  if (Length == NULL) {

+    return RETURN_INVALID_PARAMETER;

+  }

+  *Length = 0;

+

+  DebugPortRegister->TokenPid = Token;

+  if (DataToggle != 0) {

+    DebugPortRegister->SendPid = DATA1_PID;

+  } else {

+    DebugPortRegister->SendPid = DATA0_PID;

+  }

+

+  DebugPortRegister->UsbAddress  = (UINT8)(Addr & 0x7F);

+  DebugPortRegister->UsbEndPoint = (UINT8)(Ep & 0xF);

+

+  //

+  // Clearing W/R bit to indicate it's a READ operation

+  //

+  MmioAnd32((UINTN)&DebugPortRegister->ControlStatus, (UINT32)~BIT4);

+

+  //

+  // Setting GO bit as well as clearing DONE bit

+  //

+  MmioOr32((UINTN)&DebugPortRegister->ControlStatus, (UINT32)BIT5);

+

+  //

+  // Wait for completing the request

+  //

+  while ((MmioRead32((UINTN)&DebugPortRegister->ControlStatus) & (UINT32)BIT16) == 0);

+

+  //

+  // Check if the request is executed successfully or not.

+  //

+  if ((MmioRead32((UINTN)&DebugPortRegister->ControlStatus)) & BIT6) {

+    return RETURN_DEVICE_ERROR;

+  }

+

+  //

+  // Make sure the received data are not beyond the allowable maximum length - 8 byte

+  //

+  if (((MmioRead32((UINTN)&DebugPortRegister->ControlStatus)) & 0xF) > USB_DEBUG_PORT_MAX_PACKET_SIZE) {

+    return RETURN_DEVICE_ERROR;

+  }

+

+  *Length = (UINT8)(MmioRead32((UINTN)&DebugPortRegister->ControlStatus) & 0xF);

+  for (Index = 0; Index < *Length; Index++) {

+    Buffer[Index] = DebugPortRegister->DataBuffer[Index];

+  }

+  return RETURN_SUCCESS;

+}

+

+/**

+  Do a usb SETUP/OUT transaction by usb debug port.

+

+  @param  DebugPortRegister        Pointer to the base address of usb debug port register interface.

+  @param  Buffer                   Pointer to the buffer receiving data.

+  @param  Length                   Number of bytes of the received data.

+  @param  Token                    The token PID for each USB transaction.

+  @param  Addr                     The usb device address for usb transaction.

+  @param  Ep                       The endpoint for usb transaction.

+  @param  DataToggle               The toggle bit used at usb transaction.

+

+  @retval RETURN_SUCCESS           The IN transaction is executed successfully.

+  @retval RETURN_INVALID_PARAMETER The parameters passed in are invalid.

+  @retval RETURN_DEVICE_ERROR      The IN transaction comes across error.

+

+**/

+RETURN_STATUS

+EFIAPI

+UsbDebugPortOut (

+  IN  USB_DEBUG_PORT_REGISTER         *DebugPortRegister,

+  IN  UINT8                           *Buffer,

+  IN  UINT8                           Length,

+  IN  UINT8                           Token,

+  IN  UINT8                           Addr,

+  IN  UINT8                           Ep,

+  IN  UINT8                           DataToggle

+  )

+{

+  UINT8             Index;

+

+  if (Length > 8) {

+    return RETURN_INVALID_PARAMETER;

+  }

+

+  DebugPortRegister->TokenPid = Token;

+  if (DataToggle != 0) {

+    DebugPortRegister->SendPid = DATA1_PID;

+  } else {

+    DebugPortRegister->SendPid = DATA0_PID;

+  }

+  DebugPortRegister->UsbAddress  = (UINT8)(Addr & 0x7F);

+  DebugPortRegister->UsbEndPoint = (UINT8)(Ep & 0xF);

+

+  //

+  // Fill in the data length and corresponding data.

+  //

+  MmioAnd32((UINTN)&DebugPortRegister->ControlStatus, (UINT32)~0xF);

+  MmioOr32((UINTN)&DebugPortRegister->ControlStatus, Length & 0xF);

+  for (Index = 0; Index < Length; Index++) {

+    DebugPortRegister->DataBuffer[Index] = Buffer[Index];

+  }

+

+  //

+  // Setting W/R bit to indicate it's a WRITE operation

+  //

+  MmioOr32((UINTN)&DebugPortRegister->ControlStatus, BIT4);

+  //

+  // Setting GO bit as well as clearing DONE bit

+  //

+  MmioOr32((UINTN)&DebugPortRegister->ControlStatus, BIT5);

+

+  //

+  // Wait for completing the request

+  //

+  while ((MmioRead32((UINTN)&DebugPortRegister->ControlStatus) & BIT16) == 0);

+

+  //

+  // Check if the request is executed successfully or not.

+  //

+  if ((MmioRead32((UINTN)&DebugPortRegister->ControlStatus)) & BIT6) {

+    return RETURN_DEVICE_ERROR;

+  }

+

+  //

+  // Make sure the sent data are not beyond the allowable maximum length - 8 byte

+  //

+  if (((MmioRead32((UINTN)&DebugPortRegister->ControlStatus)) & 0xF) > USB_DEBUG_PORT_MAX_PACKET_SIZE) {

+    return RETURN_DEVICE_ERROR;

+  }

+

+  return RETURN_SUCCESS;

+}

+

+/**

+  Do a usb control transfer by usb debug port.

+

+  @param  DebugPortRegister        Pointer to the base address of usb debug port register interface.

+  @param  SetupPacket              The token PID for each USB transaction.

+  @param  Addr                     The usb device address for usb transaction.

+  @param  Ep                       The endpoint for usb transaction.

+  @param  Data                     Pointer to the buffer receiving data.

+  @param  DataLength               Number of bytes of the received data.

+

+  @retval RETURN_SUCCESS           The IN transaction is executed successfully.

+  @retval RETURN_INVALID_PARAMETER The parameters passed in are invalid.

+  @retval RETURN_DEVICE_ERROR      The IN transaction comes across error.

+

+**/

+RETURN_STATUS

+EFIAPI

+UsbDebugPortControlTransfer (

+  IN      USB_DEBUG_PORT_REGISTER         *DebugPortRegister,

+  IN      USB_DEVICE_REQUEST              *SetupPacket,

+  IN      UINT8                           Addr,

+  IN      UINT8                           Ep,

+      OUT UINT8                           *Data,

+  IN  OUT UINT8                           *DataLength

+  )

+{

+  RETURN_STATUS          Status;

+  UINT8                  Temp;

+

+  //

+  // Setup Phase

+  //

+  Status = UsbDebugPortOut(DebugPortRegister, (UINT8 *)SetupPacket, (UINT8)sizeof(USB_DEVICE_REQUEST), SETUP_PID, Addr, Ep, 0);

+  if (RETURN_ERROR(Status)) {

+    return Status;

+  }

+

+  //

+  // Data Phase

+  //

+  if (SetupPacket->Length != 0) {

+    if ((SetupPacket->RequestType & BIT7) != 0) {

+      //

+      // Get Data From Device

+      //

+      Status = UsbDebugPortIn(DebugPortRegister, Data, DataLength, INPUT_PID, Addr, Ep, 1);

+      if (RETURN_ERROR(Status)) {

+        return Status;

+      }

+    } else {

+      //

+      // Send Data To Device

+      //

+      Status = UsbDebugPortOut(DebugPortRegister, Data, *DataLength, OUTPUT_PID, Addr, Ep, 1);

+      if (RETURN_ERROR(Status)) {

+        return Status;

+      }

+    }

+  }

+

+  //

+  // Status Phase

+  //

+  if ((SetupPacket->RequestType & BIT7) != 0) {

+    //

+    // For READ operation, Data Toggle in Status Phase Should be 1.

+    //

+    Status = UsbDebugPortOut(DebugPortRegister, NULL, 0, OUTPUT_PID, Addr, Ep, 1);

+  } else {

+    //

+    // For WRITE operation, Data Toggle in Status Phase Should be 1.

+    //

+    Status = UsbDebugPortIn(DebugPortRegister, NULL, &Temp, INPUT_PID, Addr, Ep, 1);

+  }

+

+  return Status;

+}

+

+/**

+  Check if it needs to re-initialize usb debug port hardware.

+

+  During different phases switch, such as SEC to PEI or PEI to DXE or DXE to SMM, we should check

+  whether the usb debug port hardware configuration is changed. Such case can be triggerred by

+  Pci bus resource allocation and so on.

+

+  @param  Handle           Debug port handle.

+

+  @retval TRUE             The usb debug port hardware configuration is changed.

+  @retval FALSE            The usb debug port hardware configuration is not changed.

+

+**/

+BOOLEAN

+EFIAPI

+NeedReinitializeHardware(

+  IN USB_DEBUG_PORT_HANDLE *Handle

+  )

+{

+  UINT16                  PciCmd;

+  UINTN                   UsbDebugPortMemoryBase;

+  UINTN                   EhciMemoryBase;

+  BOOLEAN                 Status;

+  USB_DEBUG_PORT_REGISTER *UsbDebugPortRegister;

+

+  Status = FALSE;

+

+  EhciMemoryBase = 0xFFFFFC00 & PciRead32(PcdGet32(PcdUsbEhciPciAddress) + PCI_BASE_ADDRESSREG_OFFSET);

+  if (EhciMemoryBase != Handle->EhciMemoryBase) {

+    Handle->EhciMemoryBase = EhciMemoryBase;

+    Status = TRUE;

+  }

+

+  UsbDebugPortMemoryBase = 0xFFFFFC00 & PciRead32(PcdGet32(PcdUsbEhciPciAddress) + PCI_BASE_ADDRESSREG_OFFSET + Handle->DebugPortBarNumber * 4);

+  if (UsbDebugPortMemoryBase != Handle->UsbDebugPortMemoryBase) {

+    Handle->UsbDebugPortMemoryBase = UsbDebugPortMemoryBase;

+    Status = TRUE;

+  }

+

+  //

+  // Enable Ehci Memory Space Access

+  //

+  PciCmd    = PciRead16 (PcdGet32(PcdUsbEhciPciAddress) + PCI_COMMAND_OFFSET);

+  if (((PciCmd & EFI_PCI_COMMAND_MEMORY_SPACE) == 0) || ((PciCmd & EFI_PCI_COMMAND_BUS_MASTER) == 0)) {

+    Status = TRUE;

+  }

+

+  //

+  // Check if the debug port is enabled and owned by myself.

+  //

+  UsbDebugPortRegister = (USB_DEBUG_PORT_REGISTER *)(Handle->UsbDebugPortMemoryBase + Handle->DebugPortOffset);

+  if ((MmioRead32((UINTN)&UsbDebugPortRegister->ControlStatus) &

+       (USB_DEBUG_PORT_OWNER | USB_DEBUG_PORT_ENABLE | USB_DEBUG_PORT_IN_USE)) == 0) {

+    Status = TRUE;

+  }

+  return Status;

+}

+

+/**

+  Initialize usb debug port hardware.

+

+  1. reset ehci host controller.

+  2. set right port to debug port.

+  3. find a usb debug device is attached by getting debug device descriptor.

+  4. set address for the usb debug device.

+  5. configure the usb debug device to debug mode.

+

+  @param  Handle           Debug port handle.

+

+  @retval TRUE             The usb debug port hardware configuration is changed.

+  @retval FALSE            The usb debug port hardware configuration is not changed.

+

+**/

+RETURN_STATUS

+EFIAPI

+InitializeUsbDebugHardware (

+  IN USB_DEBUG_PORT_HANDLE *Handle

+)

+{

+  RETURN_STATUS             Status;

+  USB_DEBUG_PORT_REGISTER   *UsbDebugPortRegister;

+  USB_DEBUG_PORT_DESCRIPTOR UsbDebugPortDescriptor;

+  UINT16                    PciCmd;

+  UINT32                    *PortStatus;

+  UINT32                    *UsbCmd;

+  UINT32                    *UsbStatus;

+  UINT32                    *UsbHCSParam;

+  UINT8                     DebugPortNumber;

+  UINT8                     Length;

+

+  UsbDebugPortRegister = (USB_DEBUG_PORT_REGISTER *)(Handle->UsbDebugPortMemoryBase + Handle->DebugPortOffset);

+  PciCmd      = PciRead16 (PcdGet32(PcdUsbEhciPciAddress) + PCI_COMMAND_OFFSET);

+  UsbHCSParam = (UINT32 *)(Handle->EhciMemoryBase + 0x04);

+  UsbCmd      = (UINT32 *)(Handle->EhciMemoryBase + 0x20);

+  UsbStatus   = (UINT32 *)(Handle->EhciMemoryBase + 0x24);

+

+  //

+  // initialize the data toggle used by bulk in/out endpoint.

+  //

+  Handle->BulkInToggle  = 0;

+  Handle->BulkOutToggle = 0;

+

+  //

+  // Enable Ehci Memory Space Access

+  //

+  if (((PciCmd & EFI_PCI_COMMAND_MEMORY_SPACE) == 0) || ((PciCmd & EFI_PCI_COMMAND_BUS_MASTER) == 0)) {

+    PciCmd |= EFI_PCI_COMMAND_MEMORY_SPACE | EFI_PCI_COMMAND_BUS_MASTER;

+    PciWrite16(PcdGet32(PcdUsbEhciPciAddress) + PCI_COMMAND_OFFSET, PciCmd);

+  }

+

+  //

+  // If the host controller is not halted, then halt it.

+  //

+  if ((MmioRead32((UINTN)UsbStatus) & BIT12) == 0) {

+    MmioAnd32((UINTN)UsbCmd, (UINT32)~BIT0);

+    while ((MmioRead32((UINTN)UsbStatus) & BIT12) == 0);

+  }

+  //

+  // reset the host controller.

+  //

+  MmioOr32((UINTN)UsbCmd, BIT1);

+  //

+  // ensure that the host controller is reset.

+  //

+  while (MmioRead32((UINTN)UsbCmd) & BIT1);

+

+  //

+  // Start the host controller if it's not running

+  //

+  if (MmioRead32((UINTN)UsbStatus) & BIT12) {

+    MmioOr32((UINTN)UsbCmd, BIT0);

+    // ensure that the host controller is started (HALTED bit must be cleared)

+    while (MmioRead32((UINTN)UsbStatus) & BIT12);

+  }

+

+  //

+  // First get the ownership of port 0.

+  //

+  MmioOr32((UINTN)&UsbDebugPortRegister->ControlStatus, USB_DEBUG_PORT_OWNER);

+

+  MicroSecondDelay (200000);

+

+  //

+  // Find out which port is used as debug port.

+  //

+  DebugPortNumber = (UINT8)((MmioRead32((UINTN)UsbHCSParam) & 0x00F00000) >> 20);

+  //

+  // Should find a non low-speed device is connected

+  //

+  PortStatus = (UINT32 *)(Handle->EhciMemoryBase + 0x64 + (DebugPortNumber - 1) * 4);

+  if (!(MmioRead32((UINTN)PortStatus) & BIT0) || ((MmioRead32((UINTN)PortStatus) & USB_PORT_LINE_STATUS_MASK) == USB_PORT_LINE_STATUS_LS)) {

+    return RETURN_NOT_FOUND;

+  }

+

+  //

+  // Reset the debug port

+  //

+  MmioOr32((UINTN)PortStatus, BIT8);

+  MicroSecondDelay (200000);

+  MmioAnd32((UINTN)PortStatus, (UINT32)~BIT8);

+  while (MmioRead32((UINTN)PortStatus) & BIT8);

+

+  //

+  // The port enabled bit should be set by HW.

+  //

+  if ((MmioRead32((UINTN)PortStatus) & BIT2) == 0) {

+    return RETURN_DEVICE_ERROR;

+  }

+

+  //

+  // Enable Usb Debug Port Capability

+  //

+  MmioOr32((UINTN)&UsbDebugPortRegister->ControlStatus, USB_DEBUG_PORT_ENABLE | USB_DEBUG_PORT_IN_USE);

+

+  //

+  // Start to communicate with Usb Debug Device to see if the attached device is usb debug device or not.

+  //

+  Length = (UINT8)sizeof (USB_DEBUG_PORT_DESCRIPTOR);

+

+  //

+  // It's not a dedicated usb debug device, should use address 0 to get debug descriptor.

+  //

+  Status = UsbDebugPortControlTransfer (UsbDebugPortRegister, &mGetDebugDescriptor, 0x0, 0x0, (UINT8*)&UsbDebugPortDescriptor, &Length);

+  if (RETURN_ERROR(Status)) {

+    //

+    // The device is not a usb debug device.

+    //

+    return Status;

+  }

+

+  //

+  // set usb debug device address as 0x7F.

+  //

+  Status = UsbDebugPortControlTransfer (UsbDebugPortRegister, &mSetDebugAddress, 0x0, 0x0, (UINT8*)&UsbDebugPortDescriptor, &Length);

+  if (RETURN_ERROR(Status)) {

+    //

+    // The device can not work well.

+    //

+    return Status;

+  }

+

+  //

+  // enable the usb debug feature.

+  //

+  Status = UsbDebugPortControlTransfer (UsbDebugPortRegister, &mSetDebugFeature, 0x7F, 0x0, NULL, NULL);

+

+  return Status;

+}

+

+/**

+  Read data from debug device and save the datas in buffer.

+

+  Reads NumberOfBytes data bytes from a debug device into the buffer

+  specified by Buffer. The number of bytes actually read is returned.

+  If the return value is less than NumberOfBytes, then the rest operation failed.

+  If NumberOfBytes is zero, then return 0.

+

+  @param  Handle           Debug port handle.

+  @param  Buffer           Pointer to the data buffer to store the data read from the debug device.

+  @param  NumberOfBytes    Number of bytes which will be read.

+  @param  Timeout          Timeout value for reading from debug device. It unit is Microsecond.

+

+  @retval 0                Read data failed, no data is to be read.

+  @retval >0               Actual number of bytes read from debug device.

+

+**/

+UINTN

+EFIAPI

+DebugPortReadBuffer (

+  IN   DEBUG_PORT_HANDLE    Handle,

+  IN   UINT8                *Buffer,

+  IN   UINTN                NumberOfBytes,

+  IN   UINTN                Timeout

+  )

+{

+  USB_DEBUG_PORT_HANDLE     *UsbDebugPortHandle;

+  USB_DEBUG_PORT_REGISTER   *UsbDebugPortRegister;

+  RETURN_STATUS             Status;

+  UINT8                     Received;

+  UINTN                     Total;

+  UINTN                     Remaining;

+  UINT8                     Index;

+  UINT8                     Length;

+

+  if (NumberOfBytes == 0 || Buffer == NULL) {

+    return 0;

+  }

+

+  Received  = 0;

+  Total     = 0;

+  Remaining = 0;

+

+  //

+  // If Handle is NULL, it means memory is ready for use.

+  // Use global variable to store handle value.

+  //

+  if (Handle == NULL) {

+    UsbDebugPortHandle = &mUsbDebugPortHandle;

+  } else {

+    UsbDebugPortHandle = (USB_DEBUG_PORT_HANDLE *)Handle;

+  }

+

+  if (NeedReinitializeHardware(UsbDebugPortHandle)) {

+    Status = InitializeUsbDebugHardware (UsbDebugPortHandle);

+    if (RETURN_ERROR(Status)) {

+      return 0;

+    }

+  }

+

+  UsbDebugPortRegister = (USB_DEBUG_PORT_REGISTER *)(UsbDebugPortHandle->UsbDebugPortMemoryBase + UsbDebugPortHandle->DebugPortOffset);

+

+  //

+  // First read data from buffer, then read debug port hw to get received data.

+  //

+  if (UsbDebugPortHandle->DataCount > 0) {

+    if (NumberOfBytes <= UsbDebugPortHandle->DataCount) {

+      Total = NumberOfBytes;

+    } else {

+      Total = UsbDebugPortHandle->DataCount;

+    }

+

+    for (Index = 0; Index < Total; Index++) {

+      Buffer[Index] = UsbDebugPortHandle->Data[Index];

+    }

+

+    for (Index = 0; Index < UsbDebugPortHandle->DataCount - Total; Index++) {

+      if (Total + Index >= 8) {

+        return 0;

+      }

+      UsbDebugPortHandle->Data[Index] = UsbDebugPortHandle->Data[Total + Index];

+    }

+    UsbDebugPortHandle->DataCount = (UINT8)(UsbDebugPortHandle->DataCount - (UINT8)Total);

+  }

+

+  //

+  // If Timeout is equal to 0, then it means it should always wait until all datum required are received.

+  //

+  if (Timeout == 0) {

+    Timeout = 0xFFFFFFFF;

+  }

+

+  //

+  // Read remaining data by executing one or more usb debug transfer transactions at usb debug port hw.

+  //

+  while ((Total < NumberOfBytes) && (Timeout != 0)) {

+    Remaining = NumberOfBytes - Total;

+    if (Remaining >= USB_DEBUG_PORT_MAX_PACKET_SIZE) {

+      Status = UsbDebugPortIn(UsbDebugPortRegister, Buffer + Total, &Received, INPUT_PID, 0x7f, 0x82, UsbDebugPortHandle->BulkInToggle);

+

+      if (RETURN_ERROR(Status)) {

+        return Total;

+      }

+    } else {

+        Status = UsbDebugPortIn(UsbDebugPortRegister, &UsbDebugPortHandle->Data[0], &Received, INPUT_PID, 0x7f, 0x82, UsbDebugPortHandle->BulkInToggle);

+

+        if (RETURN_ERROR(Status)) {

+          return Total;

+        }

+

+        UsbDebugPortHandle->DataCount = Received;

+

+        if (Remaining <= Received) {

+          Length = (UINT8)Remaining;

+        } else {

+          Length = (UINT8)Received;

+        }

+

+        //

+        // Copy required data from the data buffer to user buffer.

+        //

+        for (Index = 0; Index < Length; Index++) {

+          (Buffer + Total)[Index] = UsbDebugPortHandle->Data[Index];

+          UsbDebugPortHandle->DataCount--;

+        }

+

+        //

+        // reorder the data buffer to make available data arranged from the beginning of the data buffer.

+        //

+        for (Index = 0; Index < Received - Length; Index++) {

+          if (Length + Index >= 8) {

+            return 0;

+          }

+          UsbDebugPortHandle->Data[Index] = UsbDebugPortHandle->Data[Length + Index];

+        }

+        //

+        // fixup the real received length in Buffer.

+        //

+        Received = Length;

+      }

+      UsbDebugPortHandle->BulkInToggle ^= 1;

+

+      Total += Received;

+      Timeout -= 100;

+  }

+

+  return Total;

+}

+

+/**

+  Write data from buffer to debug device.

+

+  Writes NumberOfBytes data bytes from Buffer to the debug device.

+  The number of bytes actually written to the debug device is returned.

+  If the return value is less than NumberOfBytes, then the write operation failed.

+  If NumberOfBytes is zero, then return 0.

+

+  @param  Handle           Debug port handle.

+  @param  Buffer           Pointer to the data buffer to be written.

+  @param  NumberOfBytes    Number of bytes to written to the debug device.

+

+  @retval 0                NumberOfBytes is 0.

+  @retval >0               The number of bytes written to the debug device.

+                           If this value is less than NumberOfBytes, then the read operation failed.

+

+**/

+UINTN

+EFIAPI

+DebugPortWriteBuffer (

+  IN   DEBUG_PORT_HANDLE    Handle,

+  IN   UINT8                *Buffer,

+  IN   UINTN                NumberOfBytes

+  )

+{

+  USB_DEBUG_PORT_HANDLE     *UsbDebugPortHandle;

+  USB_DEBUG_PORT_REGISTER   *UsbDebugPortRegister;

+  RETURN_STATUS             Status;

+  UINT8                     Sent;

+  UINTN                     Total;

+  UINT8                     ReceivedPid;

+

+  if (NumberOfBytes == 0 || Buffer == NULL) {

+    return 0;

+  }

+

+  Sent  = 0;

+  Total = 0;

+

+  //

+  // If Handle is NULL, it means memory is ready for use.

+  // Use global variable to store handle value.

+  //

+  if (Handle == NULL) {

+    UsbDebugPortHandle = &mUsbDebugPortHandle;

+  } else {

+    UsbDebugPortHandle = (USB_DEBUG_PORT_HANDLE *)Handle;

+  }

+

+  if (NeedReinitializeHardware(UsbDebugPortHandle)) {

+    Status = InitializeUsbDebugHardware (UsbDebugPortHandle);

+    if (RETURN_ERROR(Status)) {

+      return 0;

+    }

+  }

+

+  UsbDebugPortRegister = (USB_DEBUG_PORT_REGISTER *)(UsbDebugPortHandle->UsbDebugPortMemoryBase + UsbDebugPortHandle->DebugPortOffset);

+

+  while ((Total < NumberOfBytes)) {

+    if (NumberOfBytes - Total > USB_DEBUG_PORT_MAX_PACKET_SIZE) {

+      Sent = USB_DEBUG_PORT_MAX_PACKET_SIZE;

+    } else {

+      Sent = (UINT8)(NumberOfBytes - Total);

+    }

+

+    Status = UsbDebugPortOut(UsbDebugPortRegister, Buffer + Total, Sent, OUTPUT_PID, 0x7F, 0x01, UsbDebugPortHandle->BulkOutToggle);

+

+    if (RETURN_ERROR(Status)) {

+      return Total;

+    }

+

+    ReceivedPid = (MmioRead8((UINTN)&UsbDebugPortRegister->ReceivedPid));

+    //

+    // If received a NAK_PID on write transaction, it means the usb debug device is busy and can not handle this transaction.

+    // should send the packet again.

+    //

+    if (ReceivedPid == NAK_PID) {

+      Sent = 0;

+    } else {

+      UsbDebugPortHandle->BulkOutToggle ^= 1;

+    }

+    Total += Sent;

+  }

+  return Total;

+}

+

+/**

+  Polls a debug device to see if there is any data waiting to be read.

+

+  Polls a debug device to see if there is any data waiting to be read.

+  If there is data waiting to be read from the debug device, then TRUE is returned.

+  If there is no data waiting to be read from the debug device, then FALSE is returned.

+

+  @param  Handle           Debug port handle.

+

+  @retval TRUE             Data is waiting to be read from the debug device.

+  @retval FALSE            There is no data waiting to be read from the serial device.

+

+**/

+BOOLEAN

+EFIAPI

+DebugPortPollBuffer (

+  IN DEBUG_PORT_HANDLE      Handle

+  )

+{

+  USB_DEBUG_PORT_HANDLE     *UsbDebugPortHandle;

+  USB_DEBUG_PORT_REGISTER   *UsbDebugPortRegister;

+  UINT8                     Length;

+  UINT8                     Index;

+  RETURN_STATUS             Status;

+

+  //

+  // If Handle is NULL, it means memory is ready for use.

+  // Use global variable to store handle value.

+  //

+  if (Handle == NULL) {

+    UsbDebugPortHandle = &mUsbDebugPortHandle;

+  } else {

+    UsbDebugPortHandle = (USB_DEBUG_PORT_HANDLE *)Handle;

+  }

+

+  if (NeedReinitializeHardware(UsbDebugPortHandle)) {

+    Status = InitializeUsbDebugHardware(UsbDebugPortHandle);

+    if (RETURN_ERROR(Status)) {

+      return FALSE;

+    }

+  }

+

+  //

+  // If the data buffer is not empty, then return TRUE directly.

+  // else initialize a usb read transaction and read data to the data buffer.

+  //

+  if (UsbDebugPortHandle->DataCount != 0) {

+    return TRUE;

+  }

+

+  UsbDebugPortRegister = (USB_DEBUG_PORT_REGISTER *)(UsbDebugPortHandle->UsbDebugPortMemoryBase + UsbDebugPortHandle->DebugPortOffset);

+

+  UsbDebugPortRegister->TokenPid = INPUT_PID;

+  if (UsbDebugPortHandle->BulkInToggle == 0) {

+    UsbDebugPortRegister->SendPid  = DATA0_PID;

+  } else {

+    UsbDebugPortRegister->SendPid  = DATA1_PID;

+  }

+  UsbDebugPortRegister->UsbAddress  = 0x7F;

+  UsbDebugPortRegister->UsbEndPoint = 0x82 & 0x0F;

+

+  //

+  // Clearing W/R bit to indicate it's a READ operation

+  //

+  MmioAnd32((UINTN)&UsbDebugPortRegister->ControlStatus, (UINT32)~BIT4);

+  //

+  // Setting GO bit as well as clearing DONE bit

+  //

+  MmioOr32((UINTN)&UsbDebugPortRegister->ControlStatus, (UINT32)BIT5);

+

+  //

+  // Wait for completing the request

+  //

+  while ((MmioRead32((UINTN)&UsbDebugPortRegister->ControlStatus) & (UINT32)BIT16) == 0);

+

+  if ((MmioRead32((UINTN)&UsbDebugPortRegister->ControlStatus)) & BIT6) {

+    return FALSE;

+  }

+

+  Length = (UINT8)(MmioRead32((UINTN)&UsbDebugPortRegister->ControlStatus) & 0xF);

+

+  if (Length > 8) {

+    return FALSE;

+  }

+

+  UsbDebugPortHandle->BulkInToggle ^= 1;

+

+  if (Length == 0) {

+    return FALSE;

+  }

+

+  for (Index = 0; Index < Length; Index++) {

+    UsbDebugPortHandle->Data[Index] = UsbDebugPortRegister->DataBuffer[Index];

+  }

+  UsbDebugPortHandle->DataCount = Length;

+

+  return TRUE;

+}

+

+/**

+  Initialize the debug port.

+

+  If Function is not NULL, Debug Communication Libary will call this function

+  by passing in the Context to be the first parameter. If needed, Debug Communication

+  Library will create one debug port handle to be the second argument passing in

+  calling the Function, otherwise it will pass NULL to be the second argument of

+  Function.

+

+  If Function is NULL, and Context is not NULL, the Debug Communication Library could

+    a) Return the same handle as passed in (as Context parameter).

+    b) Ignore the input Context parameter and create new hanlde to be returned.

+

+  If parameter Function is NULL and Context is NULL, Debug Communication Library could

+  created a new handle if needed and return it, otherwise it will return NULL.

+

+  @param[in] Context      Context needed by callback function; it was optional.

+  @param[in] Function     Continue function called by Debug Communication library;

+                          it was optional.

+

+  @return  The debug port handle created by Debug Communication Library if Function

+           is not NULL.

+

+**/

+DEBUG_PORT_HANDLE

+EFIAPI

+DebugPortInitialize (

+  IN VOID                 *Context,

+  IN DEBUG_PORT_CONTINUE  Function

+  )

+{

+  RETURN_STATUS             Status;

+  USB_DEBUG_PORT_HANDLE     Handle;

+

+  if (Function == NULL && Context != NULL) {

+    return (DEBUG_PORT_HANDLE *) Context;

+  }

+

+  ZeroMem(&Handle, sizeof (USB_DEBUG_PORT_HANDLE));

+

+  Status = CalculateUsbDebugPortBar(&Handle.DebugPortOffset, &Handle.DebugPortBarNumber);

+  if (RETURN_ERROR (Status)) {

+    return NULL;

+  }

+

+  Handle.EhciMemoryBase = 0xFFFFFC00 & PciRead32(PcdGet32(PcdUsbEhciPciAddress) + PCI_BASE_ADDRESSREG_OFFSET);

+

+  if (Handle.EhciMemoryBase == 0) {

+    //

+    // Usb Debug Port MMIO Space Is Not Enabled. Assumption here that DebugPortBase is zero

+    //

+    PciWrite32(PcdGet32(PcdUsbEhciPciAddress) + PCI_BASE_ADDRESSREG_OFFSET, PcdGet32(PcdUsbEhciMemorySpaceBase));

+    Handle.EhciMemoryBase = 0xFFFFFC00 & PciRead32(PcdGet32(PcdUsbEhciPciAddress) + PCI_BASE_ADDRESSREG_OFFSET);

+  }

+

+  Handle.UsbDebugPortMemoryBase = 0xFFFFFC00 & PciRead32(PcdGet32(PcdUsbEhciPciAddress) + PCI_BASE_ADDRESSREG_OFFSET + Handle.DebugPortBarNumber * 4);

+

+  if (Handle.UsbDebugPortMemoryBase == 0) {

+    //

+    // Usb Debug Port MMIO Space Is Not Enabled. Assumption here that DebugPortBase is zero

+    //

+    PciWrite32(PcdGet32(PcdUsbEhciPciAddress) + PCI_BASE_ADDRESSREG_OFFSET + Handle.DebugPortBarNumber * 4, PcdGet32(PcdUsbDebugPortMemorySpaceBase));

+    Handle.UsbDebugPortMemoryBase = 0xFFFFFC00 & PciRead32(PcdGet32(PcdUsbEhciPciAddress) + PCI_BASE_ADDRESSREG_OFFSET + Handle.DebugPortBarNumber * 4);

+  }

+

+  Status = InitializeUsbDebugHardware (&Handle);

+  if (RETURN_ERROR(Status)) {

+    return NULL;

+  }

+

+  if (Function != NULL) {

+    Function (Context, &Handle);

+  } else {

+    CopyMem(&mUsbDebugPortHandle, &Handle, sizeof (USB_DEBUG_PORT_HANDLE));

+  }

+

+  return (DEBUG_PORT_HANDLE)(UINTN)&mUsbDebugPortHandle;

+}

+

diff --git a/SourceLevelDebugPkg/Library/DebugCommunicationLibUsb/DebugCommunicationLibUsb.inf b/SourceLevelDebugPkg/Library/DebugCommunicationLibUsb/DebugCommunicationLibUsb.inf
new file mode 100644
index 0000000000..bce5659fe2
--- /dev/null
+++ b/SourceLevelDebugPkg/Library/DebugCommunicationLibUsb/DebugCommunicationLibUsb.inf
@@ -0,0 +1,53 @@
+## @file

+#  Debug Communication Library instance based on usb debug port.

+#

+#  Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>

+#

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution. The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php.

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#

+##

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = DebugCommunicationLibUsb

+  FILE_GUID                      = 87438836-AD8D-4e3e-9249-895120A67240

+  MODULE_TYPE                    = BASE

+  VERSION_STRING                 = 0.7

+  LIBRARY_CLASS                  = DebugCommunicationLib

+

+#

+#  VALID_ARCHITECTURES           = IA32 X64

+#

+

+[Sources.common]

+  DebugCommunicationLibUsb.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  SourceLevelDebugPkg/SourceLevelDebugPkg.dec

+

+[Pcd]

+  ## The memory BAR of usb debug port, it may be different with the memory bar of ehci host controller.

+  ## Note that the memory BAR address is only used before Pci bus resource allocation.

+  gEfiSourceLevelDebugPkgTokenSpaceGuid.PcdUsbDebugPortMemorySpaceBase

+

+  ## The memory BAR of ehci host controller, in which usb debug feature is enabled.

+  ## Note that the memory BAR address is only used before Pci bus resource allocation.

+  gEfiSourceLevelDebugPkgTokenSpaceGuid.PcdUsbEhciMemorySpaceBase

+

+  ## The pci address of ehci host controller, in which usb debug feature is enabled.

+  ## The format of pci address please refer to SourceLevelDebugPkg.dec

+  gEfiSourceLevelDebugPkgTokenSpaceGuid.PcdUsbEhciPciAddress

+

+[LibraryClasses]

+  TimerLib

+  IoLib

+  PciLib

+  PcdLib

+