vsf_err_t stm32_usbd_ep_read_OUT_buffer(uint8_t idx, uint8_t *buffer,
uint16_t size)
{
int8_t index;
index = stm32_usbd_ep(idx);
if (index < 0)
{
return VSFERR_FAIL;
}
idx = (uint8_t)index;
if (stm32_usbd_OUT_dbuffer[idx])
{
if(GetENDPOINT(idx) & EP_DTOG_TX)
{
PMAToUserBufferCopy(buffer, GetEPDblBuf1Addr(idx), size);
}
else
{
PMAToUserBufferCopy(buffer, GetEPDblBuf0Addr(idx), size);
}
}
else
{
PMAToUserBufferCopy(buffer, GetEPRxAddr(idx), size);
}
return VSFERR_NONE;
}
uint16_t stm32_usbd_ep_get_OUT_count(uint8_t idx)
{
int8_t index;
index = stm32_usbd_ep(idx);
if (index < 0)
{
return 0;
}
idx = (uint8_t)index;
if (stm32_usbd_OUT_dbuffer[idx])
{
if(GetENDPOINT(idx) & EP_DTOG_TX)
{
return GetEPDblBuf1Count(idx);
}
else
{
return GetEPDblBuf0Count(idx);
}
}
else
{
return GetEPRxCount(idx);
}
}
vsf_err_t stm32_usbd_ep_write_IN_buffer(uint8_t idx, uint8_t *buffer,
uint16_t size)
{
uint32_t PMA_ptr;
int8_t index;
index = stm32_usbd_ep(idx);
if (index < 0)
{
return VSFERR_FAIL;
}
idx = (uint8_t)index;
if (stm32_usbd_IN_dbuffer[idx])
{
if(GetENDPOINT(idx) & EP_DTOG_RX)
{
PMA_ptr = GetEPDblBuf1Addr(idx);
}
else
{
PMA_ptr = GetEPDblBuf0Addr(idx);
}
}
else
{
PMA_ptr = GetEPTxAddr(idx);
}
UserToPMABufferCopy(buffer, PMA_ptr, size);
return VSFERR_NONE;
}
vsf_err_t stm32_usbd_ep_set_IN_count(uint8_t idx, uint16_t size)
{
int8_t index;
index = stm32_usbd_ep(idx);
if (index < 0)
{
return VSFERR_FAIL;
}
idx = (uint8_t)index;
if (stm32_usbd_IN_dbuffer[idx])
{
if(GetENDPOINT(idx) & EP_DTOG_RX)
{
SetEPDblBuf1Count(idx, EP_DBUF_IN, size);
}
else
{
SetEPDblBuf0Count(idx, EP_DBUF_IN, size);
}
}
else
{
SetEPTxCount(idx, size);
}
SetEPTxStatus(idx, EP_TX_VALID);
return VSFERR_NONE;
}
/**
* @brief Transmit data Buffer
* @param pdev: device instance
* @param ep_addr: endpoint address
* @param pbuf: pointer to Tx buffer
* @param buf_len: data length
* @retval : status
*/
uint32_t DCD_EP_Tx ( USB_CORE_HANDLE *pdev,
uint8_t ep_addr,
uint8_t *pbuf,
uint32_t buf_len)
{
__IO uint32_t len = 0;
USB_EP *ep;
ep = &pdev->dev.in_ep[ep_addr & 0x7F];
/*setup and start the Xfer */
ep->num = ep_addr & 0x7F;
ep->xfer_buff = pbuf;
ep->xfer_len = buf_len;
ep->xfer_count = 0;
/*Multi packet transfer*/
if (ep->xfer_len > ep->maxpacket)
{
len=ep->maxpacket;
ep->xfer_len-=len;
}
else
{
len=ep->xfer_len;
ep->xfer_len =0;
}
/* configure and validate Tx endpoint */
if (ep->doublebuffer == 0)
{
UserToPMABufferCopy(ep->xfer_buff, ep->pmaadress, len);
SetEPTxCount(ep->num, len);
}
else
{
uint16_t pmabuffer=0;
/*Set the Double buffer counter*/
SetEPDblBuffCount(ep->num, ep->is_in, len);
/*Write the data to the USB endpoint*/
if (GetENDPOINT(ep->num)&EP_DTOG_TX)
{
pmabuffer = ep->pmaaddr1;
}
else
{
pmabuffer = ep->pmaaddr0;
}
UserToPMABufferCopy(ep->xfer_buff, pmabuffer, len);
FreeUserBuffer(ep->num, ep->is_in);
}
SetEPTxStatus(ep->num, EP_TX_VALID);
return USB_OK;
}
/*******************************************************************************
* Function Name : EP1_OUT_Callback
* Description : Endpoint 1 out callback routine.
* Input : None.
* Output : None.
* Return : None.
*******************************************************************************/
void EP1_OUT_Callback(void)
{
uint16_t Data_Len; /* data length*/
if (GetENDPOINT(ENDP1) & EP_DTOG_TX)
{
/*read from ENDP1_BUF0Addr buffer*/
Data_Len = GetEPDblBuf0Count(ENDP1);
PMAToUserBufferCopy(Stream_Buff, ENDP1_BUF0Addr, Data_Len);
}
else
{
/*read from ENDP1_BUF1Addr buffer*/
Data_Len = GetEPDblBuf1Count(ENDP1);
PMAToUserBufferCopy(Stream_Buff, ENDP1_BUF1Addr, Data_Len);
}
FreeUserBuffer(ENDP1, EP_DBUF_OUT);
In_Data_Offset += Data_Len;
}
/**
* @brief Correct Transfer interrupt's service
* @param None
* @retval None
*/
void CTR(void)
{
USB_EP *ep;
uint16_t count=0;
uint8_t EPindex;
__IO uint16_t wIstr;
__IO uint16_t wEPVal = 0;
/* stay in loop while pending interrupts */
while (((wIstr = _GetISTR()) & ISTR_CTR) != 0)
{
/* extract highest priority endpoint number */
EPindex = (uint8_t)(wIstr & ISTR_EP_ID);
if (EPindex == 0)
{
/* Decode and service control endpoint interrupt */
/* DIR bit = origin of the interrupt */
if ((wIstr & ISTR_DIR) == 0)
{
/* DIR = 0 */
/* DIR = 0 => IN int */
/* DIR = 0 implies that (EP_CTR_TX = 1) always */
_ClearEP_CTR_TX(ENDP0);
ep = &((&USB_Device_dev)->dev.in_ep[0]);
ep->xfer_count = GetEPTxCount(ep->num);
ep->xfer_buff += ep->xfer_count;
/* TX COMPLETE */
USBD_DCD_INT_fops->DataInStage(&USB_Device_dev, 0x00);
}
else
{
/* DIR = 1 */
/* DIR = 1 & CTR_RX => SETUP or OUT int */
/* DIR = 1 & (CTR_TX | CTR_RX) => 2 int pending */
ep = &((&USB_Device_dev)->dev.out_ep[0]);
wEPVal = _GetENDPOINT(ENDP0);
if ((wEPVal &EP_SETUP) != 0)
{
/* Get SETUP Packet*/
ep->xfer_count = GetEPRxCount(ep->num);
PMAToUserBufferCopy(&((&USB_Device_dev)->dev.setup_packet[0]),ep->pmaadress , ep->xfer_count);
/* SETUP bit kept frozen while CTR_RX = 1*/
_ClearEP_CTR_RX(ENDP0);
/* Process SETUP Packet*/
USBD_DCD_INT_fops->SetupStage(&USB_Device_dev);
}
else if ((wEPVal & EP_CTR_RX) != 0)
{
_ClearEP_CTR_RX(ENDP0);
/* Get Control Data OUT Packet*/
ep->xfer_count = GetEPRxCount(ep->num);
if (ep->xfer_count != 0)
{
PMAToUserBufferCopy(ep->xfer_buff, ep->pmaadress, ep->xfer_count);
ep->xfer_buff+=ep->xfer_count;
}
/* Process Control Data OUT Packet*/
USBD_DCD_INT_fops->DataOutStage(&USB_Device_dev, 0x00);
_SetEPRxCount(ENDP0, ep->maxpacket);
_SetEPRxStatus(ENDP0,EP_RX_VALID);
}
}
}/* if(EPindex == 0) */
else
{
/* Decode and service non control endpoints interrupt */
/* process related endpoint register */
wEPVal = _GetENDPOINT(EPindex);
if ((wEPVal & EP_CTR_RX) != 0)
{
/* clear int flag */
_ClearEP_CTR_RX(EPindex);
ep = &((&USB_Device_dev)->dev.out_ep[EPindex]);
/* OUT double Buffering*/
if (ep->doublebuffer == 0)
{
count = GetEPRxCount(ep->num);
if (count != 0)
{
PMAToUserBufferCopy(ep->xfer_buff, ep->pmaadress, count);
}
}
else
{
if (GetENDPOINT(ep->num) & EP_DTOG_RX)
{
/*read from endpoint BUF0Addr buffer*/
count = GetEPDblBuf0Count(ep->num);
if (count != 0)
{
PMAToUserBufferCopy(ep->xfer_buff, ep->pmaaddr0, count);
}
}
else
{
/*read from endpoint BUF1Addr buffer*/
count = GetEPDblBuf1Count(ep->num);
if (count != 0)
{
PMAToUserBufferCopy(ep->xfer_buff, ep->pmaaddr1, count);
}
}
FreeUserBuffer(ep->num, EP_DBUF_OUT);
}
/*multi-packet on the NON control OUT endpoint*/
ep->xfer_count+=count;
ep->xfer_buff+=count;
if ((ep->xfer_len == 0) || (count < ep->maxpacket))
{
/* RX COMPLETE */
USBD_DCD_INT_fops->DataOutStage(&USB_Device_dev, ep->num);
}
else
{
DCD_EP_PrepareRx (&USB_Device_dev,ep->num, ep->xfer_buff, ep->xfer_len);
}
} /* if((wEPVal & EP_CTR_RX) */
if ((wEPVal & EP_CTR_TX) != 0)
{
ep = &((&USB_Device_dev)->dev.in_ep[EPindex]);
/* clear int flag */
_ClearEP_CTR_TX(EPindex);
/* IN double Buffering*/
if (ep->doublebuffer == 0)
{
ep->xfer_count = GetEPTxCount(ep->num);
if (ep->xfer_count != 0)
{
UserToPMABufferCopy(ep->xfer_buff, ep->pmaadress, ep->xfer_count);
}
}
else
{
if (GetENDPOINT(ep->num) & EP_DTOG_TX)
{
/*read from endpoint BUF0Addr buffer*/
ep->xfer_count = GetEPDblBuf0Count(ep->num);
if (ep->xfer_count != 0)
{
UserToPMABufferCopy(ep->xfer_buff, ep->pmaaddr0, ep->xfer_count);
}
}
else
{
/*read from endpoint BUF1Addr buffer*/
ep->xfer_count = GetEPDblBuf1Count(ep->num);
if (ep->xfer_count != 0)
{
UserToPMABufferCopy(ep->xfer_buff, ep->pmaaddr1, ep->xfer_count);
}
}
FreeUserBuffer(ep->num, EP_DBUF_IN);
}
/*multi-packet on the NON control IN endpoint*/
ep->xfer_count =GetEPTxCount(ep->num);
ep->xfer_buff+=ep->xfer_count;
/* Zero Length Packet? */
if (ep->xfer_len == 0)
{
/* TX COMPLETE */
USBD_DCD_INT_fops->DataInStage(&USB_Device_dev, ep->num);
}
else
{
DCD_EP_Tx (&USB_Device_dev,ep->num, ep->xfer_buff, ep->xfer_len);
}
} /* if((wEPVal & EP_CTR_TX) != 0) */
}/* if(EPindex == 0) else */
}/* while(...) */
}
