GD32F1x0: USB/GD32_USB_Device_Driver/src/usb_core.c Source File

GD32F1x0

 
 /* Includes ------------------------------------------------------------------*/
 #include "usb_core.h"
 
 uint32_t InterruptMask = 0;
 
 void DR_Init (void)
 {
  /* Just reset the CLOSE bit */
  _SetCTLR(CTLR_SETRST);
 
  /* May be need wait some time(tSTARTUP) ... */
 
  /* Clear SETRST bit in CTLR register */
  _SetCTLR(0);
 
  /* Clear all pending interrupts */
  _SetIFR(0);
 
  /* Set allocation buffer address */
  _SetBAR(BUFFER_ADDRESS);
 
  InterruptMask = IER_MASK;
  
 #ifdef LPM_ENABLED
  /* enable L1REQ interrupt */
  _SetLPM_CNTR(LPM_STIE);
 #endif
 
  /* Enable all interrupts mask bits */
  _SetCTLR(InterruptMask); 
 }
 
 void DR_StopDevice (void)
 {
  /* Disable all interrupts and set USB reset */
  _SetCTLR(CTLR_SETRST);
 
  /* Clear all interrupt flags */
  _SetIFR(0);
 
  /* Close device */
  _SetCTLR(CTLR_SETRST | CTLR_CLOSE); 
 }
 
 void USB_EP_BufConfig (USB_CORE_HANDLE *pudev,
  uint8_t EpAddr,
  uint8_t EpKind,
  uint32_t BufAddr)
 
 {
  USB_EP *ep;
  uint8_t EpID = EpAddr & 0x7F;
 
  if (EpAddr >> 7)
  {
  /* Get an IN endpoint */
  ep = &pudev->dev.in_ep[EpID];
  }
  else
  {
  /* Get a OUT endpoint */
  ep = &pudev->dev.out_ep[EpID];
  }
 
  if (EpKind == USB_SNG_BUFTYPE)
  {
  /* Endpoint is single buffer kind */
  ep->is_dblbuf = 0;
 
  /* Configure the buffer address */
  ep->bufaddress = (uint16_t)BufAddr;
  }
  else if(EpKind == USB_DBL_BUFTYPE)
  {
  /* Endpoint is double buffer kind */
  ep->is_dblbuf = 1;
 
  /* Get the buffer0 and buffer1 address */
  ep->buf0addr = BufAddr & 0xFFFF;
  ep->buf1addr = (BufAddr & 0xFFFF0000) >> 16;
 
  /* Set the endpoint kind as double buffer */
  _SetEPDoubleBuff(EpID);
 
  /* Set buffer address for double buffered endpoint */
  _SetEPDblBufAddr(EpID, ep->buf0addr, ep->buf1addr);
  }
 }
 
 
 void USB_EP_Init (USB_CORE_HANDLE *pudev,
  uint8_t EpAddr,
  uint8_t EpType,
  uint16_t EpMps)
 {
  USB_EP *ep;
  uint8_t EpID = EpAddr & 0x7F;
 
  /* Set the endpoint type */
  switch (EpType)
  {
  case USB_EPTYPE_CONTROL:
  _SetEPType(EpID, EP_CONTROL);
  break;
 
  case USB_EPTYPE_BULK:
  _SetEPType(EpID, EP_BULK);
  break;
 
  case USB_EPTYPE_INT:
  _SetEPType(EpID, EP_INTERRUPT);
  break;
 
  case USB_EPTYPE_ISOC:
  _SetEPType(EpID, EP_ISO);
  break;
  }
 
  if (EpAddr >> 7)
  {
  ep = &pudev->dev.in_ep[EpID];
 
  /* Initialize the transmit endpoint data toggle bit */
  _ClearDTG_TX(EpID);
 
  if(ep->is_dblbuf == 0)
  {
  /* Set the endpoint transmit buffer address */
  _SetEPTxAddr(EpID, ep->bufaddress);
 
  /* Configure the endpoint status as NAK status */
  _SetEPTxStatus(EpID, EPTX_NAK);
 
  /* Control endpoint need toggle data toggle bit */
  if(EpID == 0) _ToggleDTG_TX(EpID);
  }
  else
  {
  /* Clear another direction data toggle bit when use double buffer */
  _ClearDTG_RX(EpID);
 
  /* Set the Double buffer counter */
  _SetEPDblBuffCount(EpID, DBUF_EP_IN, 0);
 
  /* Configure the double buffer endpoint status */
  _SetEPRxStatus(EpID, EPRX_DISABLED);
  _SetEPTxStatus(EpID, EPTX_VALID);
  }
  }
  else
  {
  ep = &pudev->dev.out_ep[EpID];
 
  _ClearDTG_RX(EpID);
 
  if(ep->is_dblbuf == 0)
  {
  /*Set the endpoint receive buffer address */
  _SetEPRxAddr(EpID, ep->bufaddress);
 
  /* Configure the endpoint status as NAK */
  _SetEPRxStatus(EpID, EPRX_NAK);
  }
  else
  {
  _ClearDTG_TX(EpID);
 
  /* Toggle the SW_BUF bit(TX data toggle bit) */
  _ToggleDTG_TX(EpID);
 
  /* Configure the endpoint status as DISABLED in two direction */
  _SetEPRxStatus(EpID, EPRX_DISABLED);
  _SetEPTxStatus(EpID, EPTX_DISABLED);
  }
  }
 
  /* Initialize the basic parameters */
  ep->maxpacket = EpMps;
  ep->is_stall = 0;
 
  /* Initialize the transaction level parameters */
  ep->xfer_buf = 0;
  ep->xfer_len = 0;
  ep->xfer_count = 0;
  ep->ctrl_count = 0;
 }
 
 void USB_EP_DeInit (USB_CORE_HANDLE *pudev, uint8_t EpAddr)
 {
  USB_EP *ep;
  uint8_t EpID = EpAddr & 0x7F;
 
  if (EpAddr >> 7)
  {
  ep = &pudev->dev.in_ep[EpID];
 
  _ClearDTG_TX(EpID);
 
  if(ep->is_dblbuf != 0)
  {
  /* Clear the data toggle bits of the endpoint */
  _ClearDTG_RX(EpID);
 
  /* Reset value of the data toggle bits for the endpoint IN */
  _ToggleDTG_TX(EpID);
 
  /* Configure the endpoint status as DISABLED */
  _SetEPRxStatus(EpID, EPRX_DISABLED);
  }
 
  /* Configure the endpoint status as DISABLED */
  _SetEPTxStatus(EpID, EPTX_DISABLED); 
  }
  else
  {
  ep = &pudev->dev.out_ep[EpID];
 
  _ClearDTG_RX(EpID);
 
  if(ep->is_dblbuf != 0)
  {
  /* Clear the data toggle bits of the endpoint */
  _ClearDTG_TX(EpID);
 
  /* Reset value of the data toggle bits for the endpoint OUT */
  _ToggleDTG_RX(EpID);
 
  /* Configure the endpoint status as DISABLED */
  _SetEPTxStatus(EpID, EPTX_DISABLED);
  }
 
  /* Configure the endpoint status as DISABLED */
  _SetEPRxStatus(EpID, EPRX_DISABLED);
  }
 }
 
 
 void USB_EP_Rx (USB_CORE_HANDLE *pudev,
  uint8_t EpAddr,
  uint8_t *pbuf,
  uint16_t BufLen)
 {
  USB_EP *ep;
  uint8_t EpID = EpAddr & 0x7F;
 
  ep = &pudev->dev.out_ep[EpID];
 
  /* Configure the transaction level parameters */
  ep->xfer_buf = pbuf;
  ep->xfer_len = BufLen;
 
  if (ep->is_dblbuf == 0) 
  {
  /* Set receive buffer byte count */
  _SetEPRxCount(EpID, ep->maxpacket);
  }
  else
  {
  /* Set the double buffer receive byte count */
  _SetEPDblBuffCount(EpID, DBUF_EP_OUT, ep->maxpacket);
  }
 
  /* Enable endpoint to receive */
  _SetEPRxStatus(EpID, EPRX_VALID);
 }
 
 void USB_EP_Tx (USB_CORE_HANDLE *pudev,
  uint8_t EpAddr,
  uint8_t *pbuf,
  uint16_t BufLen)
 {
  USB_EP *ep;
  __IO uint32_t len = 0;
  uint8_t EpID = EpAddr & 0x7F;
 
  ep = &pudev->dev.in_ep[EpID];
 
  /* Configure the transaction level parameters */
  ep->xfer_buf = pbuf;
  ep->xfer_len = BufLen;
  ep->xfer_count = 0;
 
  /* Transmit length is more than one packet */
  if (ep->xfer_len > ep->maxpacket)
  {
  len = ep->maxpacket;
  }
  else
  {
  len = ep->xfer_len;
  }
 
  if (ep->is_dblbuf == 0)
  {
  UserCopyToBuffer(ep->xfer_buf, ep->bufaddress, len);
  _SetEPTxCount(EpID, len);
  }
  else
  {
  /* Set the Double buffer counter */
  _SetEPDblBuffCount(EpID, DBUF_EP_IN, len);
 
  /* Copy the data to the double buffered endpoint buffer */
  if (_GetEPxCSR(EpID) & EPTX_DTG)
  {
  UserCopyToBuffer(ep->xfer_buf, ep->buf1addr, len);
  }
  else
  {
  UserCopyToBuffer(ep->xfer_buf, ep->buf0addr, len);
  }
 
  FreeUserBuffer(EpID, DBUF_EP_IN);
  }
 
  /* Enable endpoint to transmit */
  _SetEPTxStatus(EpID, EPTX_VALID);
 }
 
 void USB_EP_Stall (USB_CORE_HANDLE *pudev, uint8_t EpAddr)
 {
  USB_EP *ep;
  uint8_t EpID = EpAddr & 0x7F;
 
  if (EpAddr >> 7)
  {
  ep = &pudev->dev.in_ep[EpID]; 
  _SetEPTxStatus(EpID, EPTX_STALL);
  }
  else
  {
  ep = &pudev->dev.out_ep[EpID];
  _SetEPRxStatus(EpID, EPRX_STALL);
  }
 
  if (EpID == 0)
  {
  /* Control endpoint need to be stalled in two directions */
  _SetEPRxTxStatus(EpID, EPRX_STALL, EPTX_STALL); 
  }
 
  /* Endpoint now is stalled */
  ep->is_stall = 1;
 }
 
 void USB_EP_ClrStall (USB_CORE_HANDLE *pudev, uint8_t EpAddr)
 {
  USB_EP *ep;
  uint8_t EpID = EpAddr & 0x7F;
 
  if (EpAddr >> 7)
  {
  ep = &pudev->dev.in_ep[EpID];
  _ClearDTG_TX(EpID);
  _SetEPTxStatus(EpID, EPTX_VALID);
  }
  else
  {
  ep = &pudev->dev.out_ep[EpID];
  _ClearDTG_RX(EpID);
  _SetEPRxStatus(EpID, EPRX_VALID);
  }
 
  /* Endpoint now is not stalled */
  ep->is_stall = 0;
 }
 
 void USB_EP_SetAddress (USB_CORE_HANDLE *pudev, uint8_t Addr)
 {
  uint8_t i;
 
  /* Set endpoints address */
  for (i = 0; i < EP_COUNT; i++)
  {
  _SetEPAddress(i, i);
  }
 
  /* Set device address and enable USB module */
  _SetAR(Addr | AR_USBEN); 
 }
 
 uint8_t USB_EP_GetStatus (USB_CORE_HANDLE *pudev, uint8_t EpAddr)
 {
  if (EpAddr >> 7)
  {
  return _GetEPTxStatus((EpAddr & 0x7F));
  }
  else
  {
  return _GetEPRxStatus(EpAddr);
  }
 }
 
 uint8_t USB_CtlTx (USB_CORE_HANDLE *pudev,
  uint8_t *pbuf,
  uint16_t Len)
 { 
  pudev->dev.device_cur_state = USB_CTRL_DATA_IN;
 
  USB_EP_Tx(pudev, EP0_IN, pbuf, Len);
 
  return USB_OK;
 }
 
 uint8_t USB_CtlContinueTx (USB_CORE_HANDLE *pudev,
  uint8_t *pbuf,
  uint16_t Len)
 {
  USB_EP_Tx (pudev, EP0_IN, pbuf, Len);
 
  return USB_OK;
 }
 
 uint8_t USB_CtlRx (USB_CORE_HANDLE *pudev,
  uint8_t *pbuf,
  uint16_t Len)
 {
  pudev->dev.device_cur_state = USB_CTRL_DATA_OUT;
 
  USB_EP_Rx(pudev, EP0_OUT, pbuf, Len);
 
  return USB_OK;
 }
 
 uint8_t USB_CtlContinueRx (USB_CORE_HANDLE *pudev,
  uint8_t *pbuf,
  uint16_t Len)
 {
  USB_EP_Rx(pudev, EP0_OUT, pbuf, Len);
 
  return USB_OK;
 }
 
 uint8_t USB_CtlTransmitStatus (USB_CORE_HANDLE *pudev)
 {
  pudev->dev.device_cur_state = USB_CTRL_STATUS_IN;
 
  USB_EP_Tx(pudev, EP0_IN, NULL, 0);
 
  return USB_OK;
 }
 
 uint8_t USB_CtlReceiveStatus (USB_CORE_HANDLE *pudev)
 {
  _Set_Status_Out(EP0);
 
  pudev->dev.device_cur_state = USB_CTRL_STATUS_OUT;
 
  USB_EP_Rx(pudev, EP0_OUT, NULL, 0); 
 
  return USB_OK;
 }
 
 uint16_t USB_GetRxCount (USB_CORE_HANDLE *pudev, uint8_t EpID)
 {
  return pudev->dev.out_ep[EpID].xfer_count;
 }
 
 /************************ (C) COPYRIGHT 2014 GIGADEVICE *****END OF FILE****/
Generated by
1.8.10
previous page start next page