Drivers/Usb/DwUsbDxe/DwUsbDxe.c

/** @file

  Copyright (c) 2015-2017, Linaro. All rights reserved.

  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 <IndustryStandard/Usb.h>
#include <Library/ArmLib.h>
#include <Library/TimerLib.h>
#include <Library/DebugLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiDriverEntryPoint.h>
#include <Library/UefiRuntimeServicesTableLib.h>
#include <Library/IoLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/UncachedMemoryAllocationLib.h>
#include <Library/CacheMaintenanceLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/BaseLib.h>
#include <Protocol/DwUsb.h>
#include <Protocol/UsbDevice.h>

#include "DwUsbDxe.h"

#define USB_TYPE_LENGTH               16
#define USB_BLOCK_HIGH_SPEED_SIZE     512
#define DATA_SIZE                     32768
#define CMD_SIZE                      512
#define MATCH_CMD_LITERAL(Cmd, Buf)   !AsciiStrnCmp (Cmd, Buf, sizeof (Cmd) - 1)

// The time between interrupt polls, in units of 100 nanoseconds
// 10 Microseconds
#define DW_INTERRUPT_POLL_PERIOD      10000

EFI_GUID  gDwUsbProtocolGuid = DW_USB_PROTOCOL_GUID;

STATIC dwc_otg_dev_dma_desc_t *gDmaDesc,*gDmaDescEp0,*gDmaDescIn;
STATIC USB_DEVICE_REQUEST *gCtrlReq;
STATIC VOID *RxBuf;
STATIC UINTN RxDescBytes = 0;
STATIC UINTN mNumDataBytes;

STATIC DW_USB_PROTOCOL          *DwUsb;

STATIC USB_DEVICE_DESCRIPTOR    *mDeviceDescriptor;

// The config descriptor, interface descriptor, and endpoint descriptors in a
// buffer (in that order)
STATIC VOID                     *mDescriptors;
// Convenience pointers to those descriptors inside the buffer:
STATIC USB_INTERFACE_DESCRIPTOR *mInterfaceDescriptor;
STATIC USB_CONFIG_DESCRIPTOR    *mConfigDescriptor;
STATIC USB_ENDPOINT_DESCRIPTOR  *mEndpointDescriptors;

STATIC USB_DEVICE_RX_CALLBACK   mDataReceivedCallback;
STATIC USB_DEVICE_TX_CALLBACK   mDataSentCallback;


/* To detect which mode was run, high speed or full speed */
STATIC
UINTN
UsbDrvPortSpeed (
  VOID
  )
{
  /*
  * 2'b00: High speed (PHY clock is running at 30 or 60 MHz)
  */
  UINT32          Val = READ_REG32 (DSTS) & 2;
  return (!Val);
}

STATIC
VOID
ResetEndpoints (
  VOID
  )
{
  /* EP0 IN ACTIVE NEXT=1 */
  WRITE_REG32 (DIEPCTL0, DXEPCTL_USBACTEP | BIT11);

  /* EP0 OUT ACTIVE */
  WRITE_REG32 (DOEPCTL0, DXEPCTL_USBACTEP);

  /* Clear any pending OTG Interrupts */
  WRITE_REG32 (GOTGINT, ~0);

  /* Clear any pending interrupts */
  WRITE_REG32 (GINTSTS, ~0);
  WRITE_REG32 (DIEPINT0, ~0);
  WRITE_REG32 (DOEPINT0, ~0);
  WRITE_REG32 (DIEPINT1, ~0);
  WRITE_REG32 (DOEPINT1, ~0);

  /* IN EP interrupt mask */
  WRITE_REG32 (DIEPMSK, DXEPMSK_TIMEOUTMSK | DXEPMSK_AHBERMSK | DXEPMSK_XFERCOMPLMSK);
  /* OUT EP interrupt mask */
  WRITE_REG32 (DOEPMSK, DXEPMSK_TIMEOUTMSK | DXEPMSK_AHBERMSK | DXEPMSK_XFERCOMPLMSK);
  /* Enable interrupts on Ep0 */
  WRITE_REG32 (DAINTMSK, (1 << DAINTMSK_OUTEPMSK_SHIFT) | (1 << DAINTMSK_INEPMSK_SHIFT));

  /* EP0 OUT Transfer Size:64 Bytes, 1 Packet, 3 Setup Packet, Read to receive setup packet*/
  WRITE_REG32 (DOEPTSIZ0, DXEPTSIZ_SUPCNT(3) | DXEPTSIZ_PKTCNT(1) | DXEPTSIZ_XFERSIZE(64));

  //notes that:the compulsive conversion is expectable.
  gDmaDescEp0->status.b.bs = 0x3;
  gDmaDescEp0->status.b.mtrf = 0;
  gDmaDescEp0->status.b.sr = 0;
  gDmaDescEp0->status.b.l = 1;
  gDmaDescEp0->status.b.ioc = 1;
  gDmaDescEp0->status.b.sp = 0;
  gDmaDescEp0->status.b.bytes = 64;
  gDmaDescEp0->buf = (UINT32)(UINTN)(gCtrlReq);
  gDmaDescEp0->status.b.sts = 0;
  gDmaDescEp0->status.b.bs = 0x0;
  WRITE_REG32 (DOEPDMA0, (UINT32)(UINTN)(gDmaDescEp0));
  /* EP0 OUT ENABLE CLEARNAK */
  WRITE_REG32 (DOEPCTL0, (READ_REG32 (DOEPCTL0) | DXEPCTL_EPENA | DXEPCTL_CNAK));
}

STATIC
VOID
EpTx (
  IN UINT8          Ep,
  IN CONST VOID    *Ptr,
  IN UINTN          Len
  )
{
    UINT32          BlockSize;
    UINT32          Packets;

    /* EPx OUT ACTIVE */
    WRITE_REG32 (DIEPCTL (Ep), (READ_REG32 (DIEPCTL (Ep))) | DXEPCTL_USBACTEP);
    if (!Ep) {
        BlockSize = 64;
    } else {
        BlockSize = UsbDrvPortSpeed () ? USB_BLOCK_HIGH_SPEED_SIZE : 64;
    }
    Packets = (Len + BlockSize - 1) / BlockSize;

    if (!Len) {
      /* send one empty packet */
      gDmaDescIn->status.b.bs = 0x3;
      gDmaDescIn->status.b.l = 1;
      gDmaDescIn->status.b.ioc = 1;
      gDmaDescIn->status.b.sp = 1;
      gDmaDescIn->status.b.bytes = 0;
      gDmaDescIn->buf = 0;
      gDmaDescIn->status.b.sts = 0;
      gDmaDescIn->status.b.bs = 0x0;

      WRITE_REG32 (DIEPDMA (Ep), (UINT32)(UINTN)(gDmaDescIn));             // DMA Address (DMAAddr) is zero
    } else {
      WRITE_REG32 (DIEPTSIZ (Ep), Len | (Packets << 19));

      //flush cache
      WriteBackDataCacheRange ((VOID *)Ptr, Len);

      gDmaDescIn->status.b.bs = 0x3;
      gDmaDescIn->status.b.l = 1;
      gDmaDescIn->status.b.ioc = 1;
      gDmaDescIn->status.b.sp = 1;
      gDmaDescIn->status.b.bytes = Len;
      gDmaDescIn->buf = (UINT32)((UINTN)Ptr);
      gDmaDescIn->status.b.sts = 0;
      gDmaDescIn->status.b.bs = 0x0;
      WRITE_REG32 (DIEPDMA (Ep), (UINT32)(UINTN)(gDmaDescIn));         // Ptr is DMA address
    }
    ArmDataSynchronizationBarrier ();
    /* epena & cnak */
    WRITE_REG32 (DIEPCTL (Ep), READ_REG32 (DIEPCTL (Ep)) | DXEPCTL_EPENA | DXEPCTL_CNAK | BIT11);
}

STATIC
VOID
EpRx (
  IN UINTN            Ep,
  IN UINTN            Len
  )
{
  /* EPx UNSTALL */
  WRITE_REG32 (DOEPCTL (Ep), ((READ_REG32 (DOEPCTL (Ep))) & (~DXEPCTL_STALL)));
  /* EPx OUT ACTIVE */
  WRITE_REG32 (DOEPCTL (Ep), (READ_REG32 (DOEPCTL (Ep)) | DXEPCTL_USBACTEP));

  if (Len >= DATA_SIZE) {
    RxDescBytes = DATA_SIZE;
  } else {
    RxDescBytes = Len;
  }

  RxBuf = AllocatePool (DATA_SIZE);
  ASSERT (RxBuf != NULL);

  InvalidateDataCacheRange (RxBuf, Len);

  gDmaDesc->status.b.bs = 0x3;
  gDmaDesc->status.b.mtrf = 0;
  gDmaDesc->status.b.sr = 0;
  gDmaDesc->status.b.l = 1;
  gDmaDesc->status.b.ioc = 1;
  gDmaDesc->status.b.sp = 0;
  gDmaDesc->status.b.bytes = (UINT32)RxDescBytes;
  gDmaDesc->buf = (UINT32)((UINTN)RxBuf);
  gDmaDesc->status.b.sts = 0;
  gDmaDesc->status.b.bs = 0x0;

  ArmDataSynchronizationBarrier ();
  WRITE_REG32 (DOEPDMA (Ep), (UINT32)((UINTN)gDmaDesc));
  /* EPx OUT ENABLE CLEARNAK */
  WRITE_REG32 (DOEPCTL (Ep), (READ_REG32 (DOEPCTL (Ep)) | DXEPCTL_EPENA | DXEPCTL_CNAK));
}

STATIC
EFI_STATUS
HandleGetDescriptor (
  IN USB_DEVICE_REQUEST  *Request
  )
{
  UINT8       DescriptorType;
  UINTN       ResponseSize;
  VOID       *ResponseData;
  EFI_USB_STRING_DESCRIPTOR        *Descriptor = NULL;
  UINTN                             DescriptorSize;

  ResponseSize = 0;
  ResponseData = NULL;

  // Pretty confused if bmRequestType is anything but this:
  ASSERT (Request->RequestType == USB_DEV_GET_DESCRIPTOR_REQ_TYPE);

  // Choose the response
  DescriptorType = Request->Value >> 8;
  switch (DescriptorType) {
  case USB_DESC_TYPE_DEVICE:
    DEBUG ((DEBUG_INFO, "USB: Got a request for device descriptor\n"));
    ResponseSize = sizeof (USB_DEVICE_DESCRIPTOR);
    ResponseData = mDeviceDescriptor;
    break;
  case USB_DESC_TYPE_CONFIG:
    DEBUG ((DEBUG_INFO, "USB: Got a request for config descriptor\n"));
    ResponseSize = mConfigDescriptor->TotalLength;
    ResponseData = mDescriptors;
    break;
  case USB_DESC_TYPE_STRING:
    DEBUG ((DEBUG_INFO, "USB: Got a request for String descriptor %d\n", Request->Value & 0xFF));
    switch (Request->Value & 0xff) {
    case 0:
      DescriptorSize = sizeof (EFI_USB_STRING_DESCRIPTOR) +
                       LANG_LENGTH * sizeof (CHAR16) + 1;
      Descriptor = (EFI_USB_STRING_DESCRIPTOR *)AllocateZeroPool (DescriptorSize);
      ASSERT (Descriptor != NULL);
      Descriptor->Length = LANG_LENGTH * sizeof (CHAR16);
      Descriptor->DescriptorType = USB_DESC_TYPE_STRING;
      DwUsb->GetLang (Descriptor->String, &Descriptor->Length);
      ResponseSize = Descriptor->Length;
      ResponseData = Descriptor;
      break;
    case 1:
      DescriptorSize = sizeof (EFI_USB_STRING_DESCRIPTOR) +
                       MANU_FACTURER_STRING_LENGTH * sizeof (CHAR16) + 1;
      Descriptor = (EFI_USB_STRING_DESCRIPTOR *)AllocateZeroPool (DescriptorSize);
      ASSERT (Descriptor != NULL);
      Descriptor->Length = MANU_FACTURER_STRING_LENGTH * sizeof (CHAR16);
      Descriptor->DescriptorType = USB_DESC_TYPE_STRING;
      DwUsb->GetManuFacturer (Descriptor->String, &Descriptor->Length);
      ResponseSize = Descriptor->Length;
      ResponseData = Descriptor;
      break;
    case 2:
      DescriptorSize = sizeof (EFI_USB_STRING_DESCRIPTOR) +
                       PRODUCT_STRING_LENGTH * sizeof (CHAR16) + 1;
      Descriptor = (EFI_USB_STRING_DESCRIPTOR *)AllocateZeroPool (DescriptorSize);
      ASSERT (Descriptor != NULL);
      Descriptor->Length = PRODUCT_STRING_LENGTH * sizeof (CHAR16);
      Descriptor->DescriptorType = USB_DESC_TYPE_STRING;
      DwUsb->GetProduct (Descriptor->String, &Descriptor->Length);
      ResponseSize = Descriptor->Length;
      ResponseData = Descriptor;
      break;
    case 3:
      DescriptorSize = sizeof (EFI_USB_STRING_DESCRIPTOR) +
                       SERIAL_STRING_LENGTH * sizeof (CHAR16) + 1;
      Descriptor = (EFI_USB_STRING_DESCRIPTOR *)AllocateZeroPool (DescriptorSize);
      ASSERT (Descriptor != NULL);
      Descriptor->Length = SERIAL_STRING_LENGTH * sizeof (CHAR16);
      Descriptor->DescriptorType = USB_DESC_TYPE_STRING;
      DwUsb->GetSerialNo (Descriptor->String, &Descriptor->Length);
      ResponseSize = Descriptor->Length;
      ResponseData = Descriptor;
      break;
    }
    break;
  default:
    DEBUG ((DEBUG_INFO, "USB: Didn't understand request for descriptor 0x%04x\n", Request->Value));
    break;
  }

  // Send the response
  if (ResponseData) {
    ASSERT (ResponseSize != 0);

    if (Request->Length < ResponseSize) {
      // Truncate response
      ResponseSize = Request->Length;
    } else if (Request->Length > ResponseSize) {
      DEBUG ((DEBUG_INFO, "USB: Info: ResponseSize < wLength\n"));
    }

    EpTx (0, ResponseData, ResponseSize);
  }
  if (Descriptor) {
    FreePool (Descriptor);
  }

  return EFI_SUCCESS;
}

STATIC
EFI_STATUS
HandleSetAddress (
  IN USB_DEVICE_REQUEST  *Request
  )
{
  // Pretty confused if bmRequestType is anything but this:
  ASSERT (Request->RequestType == USB_DEV_SET_ADDRESS_REQ_TYPE);
  DEBUG ((DEBUG_INFO, "USB: Setting address to %d\n", Request->Value));
  ResetEndpoints ();

  WRITE_REG32 (DCFG, (READ_REG32 (DCFG) & ~DCFG_DEVADDR_MASK) | DCFG_DEVADDR(Request->Value));
  EpTx (0, 0, 0);

  return EFI_SUCCESS;
}

STATIC
UINTN
UsbDrvRequestEndpoint (
  IN UINTN           Type,
  IN UINTN           Dir
  )
{
  UINTN              Ep = 1;
  UINTN              Ret, NewBits;

  Ret = Ep | Dir;
  NewBits = (Type << 18) | 0x10000000;

  /*
   * (Type << 18):Endpoint Type (EPType)
   * 0x10000000:Endpoint Enable (EPEna)
   * 0x000C000:Endpoint Type (EPType);Hardcoded to 00 for control.
   * (ep<<22):TxFIFO Number (TxFNum)
   * 0x20000:NAK Status (NAKSts);The core is transmitting NAK handshakes on this endpoint.
   */
  if (Dir) {  // IN: to host
    WRITE_REG32 (DIEPCTL (Ep), ((READ_REG32 (DIEPCTL (Ep))) & ~DXEPCTL_EPTYPE_MASK) | NewBits | (Ep << 22) | DXEPCTL_NAKSTS);
  } else {    // OUT: to device
    WRITE_REG32 (DOEPCTL (Ep), ((READ_REG32 (DOEPCTL (Ep))) & ~DXEPCTL_EPTYPE_MASK) | NewBits);
  }

  return Ret;
}

STATIC
EFI_STATUS
HandleSetConfiguration (
  IN USB_DEVICE_REQUEST  *Request
  )
{
  ASSERT (Request->RequestType == USB_DEV_SET_CONFIGURATION_REQ_TYPE);

  // Cancel all transfers
  ResetEndpoints ();

  UsbDrvRequestEndpoint (2, 0);
  UsbDrvRequestEndpoint (2, 0x80);

  WRITE_REG32 (DIEPCTL1, (READ_REG32 (DIEPCTL1)) | BIT28 | BIT19 | DXEPCTL_USBACTEP | BIT11);

  /* Enable interrupts on all endpoints */
  WRITE_REG32 (DAINTMSK, ~0);

  EpRx (1, CMD_SIZE);
  EpTx (0, 0, 0);
  return EFI_SUCCESS;
}


STATIC
EFI_STATUS
HandleDeviceRequest (
  IN USB_DEVICE_REQUEST  *Request
  )
{
  EFI_STATUS  Status;

  switch (Request->Request) {
  case USB_DEV_GET_DESCRIPTOR:
    Status = HandleGetDescriptor (Request);
    break;
  case USB_DEV_SET_ADDRESS:
    Status = HandleSetAddress (Request);
    break;
  case USB_DEV_SET_CONFIGURATION:
    Status = HandleSetConfiguration (Request);
    break;
  default:
    DEBUG ((DEBUG_ERROR,
      "Didn't understand RequestType 0x%x Request 0x%x\n",
      Request->RequestType, Request->Request));
      Status = EFI_INVALID_PARAMETER;
    break;
  }

  return Status;
}


// Instead of actually registering interrupt handlers, we poll the controller's
//  interrupt source register in this function.
STATIC
VOID
CheckInterrupts (
  IN EFI_EVENT        Event,
  IN VOID            *Context
  )
{
  UINT32              Ints, EpInts;


  // interrupt register
  Ints = READ_REG32 (GINTSTS);

  /*
   * bus reset
   * The core sets this bit to indicate that a reset is detected on the USB.
   */
  if (Ints & GINTSTS_USBRST) {
    WRITE_REG32 (DCFG, DCFG_DESCDMA | DCFG_NZ_STS_OUT_HSHK);
    ResetEndpoints ();
  }

  /*
   * enumeration done, we now know the speed
   * The core sets this bit to indicate that speed enumeration is complete. The
   * application must read the Device Status (DSTS) register to obtain the
   * enumerated speed.
   */
  if (Ints & GINTSTS_ENUMDONE) {
    /* Set up the maximum packet sizes accordingly */
    UINTN MaxPacket = UsbDrvPortSpeed () ? USB_BLOCK_HIGH_SPEED_SIZE : 64;
    //Set Maximum In Packet Size (MPS)
    WRITE_REG32 (DIEPCTL1, ((READ_REG32 (DIEPCTL1)) & ~DXEPCTL_MPS_MASK) | MaxPacket);
    //Set Maximum Out Packet Size (MPS)
    WRITE_REG32 (DOEPCTL1, ((READ_REG32 (DOEPCTL1)) & ~DXEPCTL_MPS_MASK) | MaxPacket);
  }

  /*
   * IN EP event
   * The core sets this bit to indicate that an interrupt is pending on one of the IN
   * endpoInts of the core (in Device mode). The application must read the
   * Device All EndpoInts Interrupt (DAINT) register to determine the exact
   * number of the IN endpoint on which the interrupt occurred, and then read
   * the corresponding Device IN Endpoint-n Interrupt (DIEPINTn) register to
   * determine the exact cause of the interrupt. The application must clear the
   * appropriate status bit in the corresponding DIEPINTn register to clear this bit.
   */
  if (Ints & GINTSTS_IEPINT) {
    EpInts = READ_REG32 (DIEPINT0);
    WRITE_REG32 (DIEPINT0, EpInts);
    if (EpInts & DXEPINT_XFERCOMPL) {
      DEBUG ((DEBUG_INFO, "INT: IN TX completed.DIEPTSIZ (0) = 0x%x.\n", READ_REG32 (DIEPTSIZ0)));
    }

    EpInts = READ_REG32 (DIEPINT1);
    WRITE_REG32 (DIEPINT1, EpInts);
    if (EpInts & DXEPINT_XFERCOMPL) {
      DEBUG ((DEBUG_INFO, "ep1: IN TX completed\n"));
    }
  }

  /*
   * OUT EP event
   * The core sets this bit to indicate that an interrupt is pending on one of the
   * OUT endpoints of the core (in Device mode). The application must read the
   * Device All EndpoInts Interrupt (DAINT) register to determine the exact
   * number of the OUT endpoint on which the interrupt occurred, and then read
   * the corresponding Device OUT Endpoint-n Interrupt (DOEPINTn) register
   * to determine the exact cause of the interrupt. The application must clear the
   * appropriate status bit in the corresponding DOEPINTn register to clear this bit.
   */
  if (Ints & GINTSTS_OEPINT) {
    /* indicates the status of an endpoint
     * with respect to USB- and AHB-related events. */
    EpInts = READ_REG32 (DOEPINT0);
    if (EpInts) {
      WRITE_REG32 (DOEPINT0, EpInts);
      if (EpInts & DXEPINT_XFERCOMPL) {
        DEBUG ((DEBUG_INFO, "INT: EP0 RX completed. DOEPTSIZ(0) = 0x%x.\n", READ_REG32 (DOEPTSIZ0)));
      }
      /*
       *
       IN Token Received When TxFIFO is Empty (INTknTXFEmp)
       * Indicates that an IN token was received when the associated TxFIFO (periodic/nonperiodic)
       * was empty. This interrupt is asserted on the endpoint for which the IN token
       * was received.
       */
      if (EpInts & BIT3) { /* SETUP phase done */
        WRITE_REG32 (DIEPCTL0, READ_REG32 (DIEPCTL0) | DXEPCTL_SNAK);
        WRITE_REG32 (DOEPCTL0, READ_REG32 (DOEPCTL0) | DXEPCTL_SNAK);
        /*clear IN EP intr*/
        WRITE_REG32 (DIEPINT0, ~0);
        HandleDeviceRequest((USB_DEVICE_REQUEST *)gCtrlReq);
      }

      /* Make sure EP0 OUT is set up to accept the next request */
      WRITE_REG32 (DOEPTSIZ0, DXEPTSIZ_SUPCNT(3) | DXEPTSIZ_PKTCNT(1) | DXEPTSIZ_XFERSIZE(64));
      /*
       * IN Token Received When TxFIFO is Empty (INTknTXFEmp)
       * Indicates that an IN token was received when the associated TxFIFO (periodic/nonperiodic)
       * was empty. This interrupt is asserted on the endpoint for which the IN token
       * was received.
       */
      gDmaDescEp0->status.b.bs = 0x3;
      gDmaDescEp0->status.b.mtrf = 0;
      gDmaDescEp0->status.b.sr = 0;
      gDmaDescEp0->status.b.l = 1;
      gDmaDescEp0->status.b.ioc = 1;
      gDmaDescEp0->status.b.sp = 0;
      gDmaDescEp0->status.b.bytes = 64;
      gDmaDescEp0->buf = (UINT32)(UINTN)(gCtrlReq);
      gDmaDescEp0->status.b.sts = 0;
      gDmaDescEp0->status.b.bs = 0x0;
      WRITE_REG32 (DOEPDMA0, (UINT32)(UINTN)(gDmaDescEp0));
      // endpoint enable; clear NAK
      WRITE_REG32 (DOEPCTL0, DXEPCTL_EPENA | DXEPCTL_CNAK);
    }

    EpInts = (READ_REG32 (DOEPINT1));
    if (EpInts) {
      WRITE_REG32 (DOEPINT1, EpInts);
      /* Transfer Completed Interrupt (XferCompl);Transfer completed */
      if (EpInts & DXEPINT_XFERCOMPL) {

        UINTN Bytes = RxDescBytes - gDmaDesc->status.b.bytes;
        UINTN Len = 0;

        ArmDataSynchronizationBarrier ();
        if (MATCH_CMD_LITERAL ("download:", RxBuf)) {
          mNumDataBytes = AsciiStrHexToUint64 (RxBuf + sizeof ("download:"));
        } else {
          if (mNumDataBytes != 0) {
            mNumDataBytes -= Bytes;
          }
        }

        mDataReceivedCallback (Bytes, RxBuf);

        if (mNumDataBytes == 0) {
          Len = CMD_SIZE;
        } else if (mNumDataBytes > DATA_SIZE) {
          Len = DATA_SIZE;
        } else {
          Len = mNumDataBytes;
        }

        EpRx (1, Len);
      }
    }
  }

  //WRITE_REG32 clear ints
  WRITE_REG32 (GINTSTS, Ints);
}

EFI_STATUS
DwUsbSend (
  IN        UINT8  EndpointIndex,
  IN        UINTN  Size,
  IN  CONST VOID  *Buffer
  )
{
    EpTx (EndpointIndex, Buffer, Size);
    return EFI_SUCCESS;
}

STATIC
VOID
DwUsbInit (
  VOID
  )
{
  VOID     *Buf;
  UINT32   Data;

  Buf = UncachedAllocatePages (16);
  gDmaDesc = Buf;
  gDmaDescEp0 = gDmaDesc + sizeof (dwc_otg_dev_dma_desc_t);
  gDmaDescIn = gDmaDescEp0 + sizeof (dwc_otg_dev_dma_desc_t);
  gCtrlReq = (USB_DEVICE_REQUEST *)gDmaDescIn + sizeof (dwc_otg_dev_dma_desc_t);

  ZeroMem (gDmaDesc, sizeof (dwc_otg_dev_dma_desc_t));
  ZeroMem (gDmaDescEp0, sizeof (dwc_otg_dev_dma_desc_t));
  ZeroMem (gDmaDescIn, sizeof (dwc_otg_dev_dma_desc_t));

  /*Reset usb controller.*/
  /* Wait for OTG AHB master idle */
  do {
    Data = READ_REG32 (GRSTCTL) & GRSTCTL_AHBIDLE;
  } while (Data == 0);

  /* OTG: Assert Software Reset */
  WRITE_REG32 (GRSTCTL, GRSTCTL_CSFTRST);

  /* Wait for OTG to ack reset */
  while (READ_REG32 (GRSTCTL) & GRSTCTL_CSFTRST);

  /* Wait for OTG AHB master idle */
  while ((READ_REG32 (GRSTCTL) & GRSTCTL_AHBIDLE) == 0);

  WRITE_REG32 (GDFIFOCFG, DATA_FIFO_CONFIG);
  WRITE_REG32 (GRXFSIZ, RX_SIZE);
  WRITE_REG32 (GNPTXFSIZ, ENDPOINT_TX_SIZE);
  WRITE_REG32 (DIEPTXF1, DATA_IN_ENDPOINT_TX_FIFO1);
  WRITE_REG32 (DIEPTXF2, DATA_IN_ENDPOINT_TX_FIFO2);
  WRITE_REG32 (DIEPTXF3, DATA_IN_ENDPOINT_TX_FIFO3);
  WRITE_REG32 (DIEPTXF4, DATA_IN_ENDPOINT_TX_FIFO4);
  WRITE_REG32 (DIEPTXF5, DATA_IN_ENDPOINT_TX_FIFO5);
  WRITE_REG32 (DIEPTXF6, DATA_IN_ENDPOINT_TX_FIFO6);
  WRITE_REG32 (DIEPTXF7, DATA_IN_ENDPOINT_TX_FIFO7);
  WRITE_REG32 (DIEPTXF8, DATA_IN_ENDPOINT_TX_FIFO8);
  WRITE_REG32 (DIEPTXF9, DATA_IN_ENDPOINT_TX_FIFO9);
  WRITE_REG32 (DIEPTXF10, DATA_IN_ENDPOINT_TX_FIFO10);
  WRITE_REG32 (DIEPTXF11, DATA_IN_ENDPOINT_TX_FIFO11);
  WRITE_REG32 (DIEPTXF12, DATA_IN_ENDPOINT_TX_FIFO12);
  WRITE_REG32 (DIEPTXF13, DATA_IN_ENDPOINT_TX_FIFO13);
  WRITE_REG32 (DIEPTXF14, DATA_IN_ENDPOINT_TX_FIFO14);
  WRITE_REG32 (DIEPTXF15, DATA_IN_ENDPOINT_TX_FIFO15);

  /*
   * set Periodic TxFIFO Empty Level,
   * Non-Periodic TxFIFO Empty Level,
   * Enable DMA, Unmask Global Intr
   */
  WRITE_REG32 (GAHBCFG, GAHBCFG_CTRL_MASK);

  /*select 8bit UTMI+, ULPI Inerface*/
  WRITE_REG32 (GUSBCFG, 0x2400);

  /* Detect usb work mode,host or device? */
  do {
    Data = READ_REG32 (GINTSTS);
  } while (Data & GINTSTS_CURMODE_HOST);
  MicroSecondDelay (3);

  /*Init global and device mode csr register.*/
  /*set Non-Zero-Length status out handshake */
  Data = (0x20 << DCFG_EPMISCNT_SHIFT) | DCFG_NZ_STS_OUT_HSHK;
  WRITE_REG32 (DCFG, Data);

  /* Interrupt unmask: IN event, OUT event, bus reset */
  Data = GINTSTS_OEPINT | GINTSTS_IEPINT | GINTSTS_ENUMDONE | GINTSTS_USBRST;
  WRITE_REG32 (GINTMSK, Data);

  do {
    Data = READ_REG32 (GINTSTS) & GINTSTS_ENUMDONE;
  } while (Data);

  /* Clear any pending OTG Interrupts */
  WRITE_REG32 (GOTGINT, ~0);
  /* Clear any pending interrupts */
  WRITE_REG32 (GINTSTS, ~0);
  WRITE_REG32 (GINTMSK, ~0);
  Data = READ_REG32 (GOTGINT);
  Data &= ~0x3000;
  WRITE_REG32 (GOTGINT, Data);

  /* endpoint settings cfg */
  ResetEndpoints ();
  MicroSecondDelay (1);

  /* init finish. and ready to transfer data */

  /* Soft Disconnect */
  WRITE_REG32 (DCTL, DCTL_PWRONPRGDONE | DCTL_SFTDISCON);
  MicroSecondDelay (10000);

  /* Soft Reconnect */
  WRITE_REG32 (DCTL, DCTL_PWRONPRGDONE);
}

EFI_STATUS
EFIAPI
DwUsbStart (
  IN USB_DEVICE_DESCRIPTOR   *DeviceDescriptor,
  IN VOID                   **Descriptors,
  IN USB_DEVICE_RX_CALLBACK   RxCallback,
  IN USB_DEVICE_TX_CALLBACK   TxCallback
  )
{
  UINT8                    *Ptr;
  EFI_STATUS                Status;
  EFI_EVENT                 TimerEvent;

  ASSERT (DeviceDescriptor != NULL);
  ASSERT (Descriptors[0] != NULL);
  ASSERT (RxCallback != NULL);
  ASSERT (TxCallback != NULL);

  DwUsbInit();

  mDeviceDescriptor = DeviceDescriptor;
  mDescriptors = Descriptors[0];

  // Right now we just support one configuration
  ASSERT (mDeviceDescriptor->NumConfigurations == 1);
  mDeviceDescriptor->StrManufacturer = 1;
  mDeviceDescriptor->StrProduct = 2;
  mDeviceDescriptor->StrSerialNumber = 3;
  // ... and one interface
  mConfigDescriptor = (USB_CONFIG_DESCRIPTOR *)mDescriptors;
  ASSERT (mConfigDescriptor->NumInterfaces == 1);

  Ptr = ((UINT8 *) mDescriptors) + sizeof (USB_CONFIG_DESCRIPTOR);
  mInterfaceDescriptor = (USB_INTERFACE_DESCRIPTOR *) Ptr;
  Ptr += sizeof (USB_INTERFACE_DESCRIPTOR);

  mEndpointDescriptors = (USB_ENDPOINT_DESCRIPTOR *) Ptr;

  mDataReceivedCallback = RxCallback;
  mDataSentCallback = TxCallback;

  // Register a timer event so CheckInterupts gets called periodically
  Status = gBS->CreateEvent (
                  EVT_TIMER | EVT_NOTIFY_SIGNAL,
                  TPL_CALLBACK,
                  CheckInterrupts,
                  NULL,
                  &TimerEvent
                  );
  ASSERT_EFI_ERROR (Status);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  Status = gBS->SetTimer (
                  TimerEvent,
                  TimerPeriodic,
                  DW_INTERRUPT_POLL_PERIOD
                  );
  ASSERT_EFI_ERROR (Status);

  return Status;
}

USB_DEVICE_PROTOCOL mUsbDevice = {
  DwUsbStart,
  DwUsbSend
};


EFI_STATUS
EFIAPI
DwUsbEntryPoint (
  IN EFI_HANDLE                            ImageHandle,
  IN EFI_SYSTEM_TABLE                      *SystemTable
  )
{
  EFI_STATUS      Status;

  Status = gBS->LocateProtocol (&gDwUsbProtocolGuid, NULL, (VOID **) &DwUsb);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  Status = DwUsb->PhyInit(USB_DEVICE_MODE);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  return gBS->InstallProtocolInterface (
                &ImageHandle,
                &gUsbDeviceProtocolGuid,
                EFI_NATIVE_INTERFACE,
                &mUsbDevice
                );
}