/**************************************************************************//**
|
* @file endpoint.c
|
* @version V1.00
|
* $Revision: 2 $
|
* $Date: 20/08/04 14:25 $
|
* @brief Endpoint interrupt routine for MUSBFSFC firmware
|
*
|
* @note
|
* Copyright (C) 2020 Panchip Technology Corp. All rights reserved.
|
*****************************************************************************/
|
#include "endpoint.h"
|
#include "PanSeries.h"
|
#include "usb.h"
|
|
USB_BulkInStatus gepbin1 = {0,}, gepbin2 = {0,}, gepbin3 = {0,};
|
USB_BulkOutStatus gepbout1 = {0,}, gepbout2 = {0,}, gepbout3 = {0,};
|
/****************************************
|
EndpointBulkIn service routine
|
This routine provides simple handling for bulk in endpoints.
|
Endpoint MaxP is defined in endpoint.h.
|
While the nBytesLeft field of the pbostate structure is >= 0
|
the endpoint will send packets of MaxP, with the residue in the last packet.
|
If the data to send is an exact multiple of MaxP then a null data packet
|
will be sent.
|
****************************************/
|
void EndpointBulkIn(USB_BulkInStatus *pbistate, uint32_t nCallState)
|
{
|
uint32_t nBytes;
|
uint8_t byInCSR;
|
|
/* Reset endpoint */
|
if (nCallState == M_EP_RESET) {
|
pbistate->nBytesLeft = M_EP_NODATA;
|
WRITE_REG(USB->INDEX, pbistate->byEP);
|
|
byInCSR = M_INCSR_CDT | M_INCSR_FF;
|
WRITE_REG(USB->CSR0_INCSR1, byInCSR);
|
return;
|
}
|
|
/* Check whether there is any data to send */
|
if (pbistate->nBytesLeft == M_EP_NODATA)
|
return;
|
|
/* Determine number of bytes to send */
|
if (pbistate->nBytesLeft < M_EP_MAXP) {
|
nBytes = pbistate->nBytesLeft;
|
pbistate->nBytesLeft = M_EP_NODATA;
|
}
|
else {
|
nBytes = M_EP_MAXP;
|
pbistate->nBytesLeft -= M_EP_MAXP;
|
}
|
|
///* Load FIFO */
|
WRITE_REG(USB->INDEX, pbistate->byEP);
|
USB_Write((uint32_t)pbistate->byEP, nBytes, pbistate->pData);
|
pbistate->pData = (uint8_t *)pbistate->pData + nBytes;
|
|
byInCSR = M_INCSR_IPR;
|
WRITE_REG(USB->CSR0_INCSR1, byInCSR);
|
}
|
|
|
/****************************************
|
EndpointBulkOut service routine
|
This routine provides simple handling for bulk out endpoints.
|
Endpoint MaxP is defined in endpoint.h.
|
It assumes a transfer is complete when a packet of less than MaxP is received.
|
****************************************/
|
void EndpointBulkOut (USB_BulkOutStatus *pbostate, uint32_t nCallState)
|
{
|
uint32_t nBytes;
|
uint8_t byOutCSR;
|
|
/* Reset endpoint */
|
if (nCallState == M_EP_RESET) {
|
pbostate->nBytesRecv = 0;
|
pbostate->nBuffLen = 0;
|
WRITE_REG(USB->INDEX, pbostate->byEP);
|
byOutCSR = M_OUTCSR_CDT | M_OUTCSR_FF;
|
WRITE_REG(USB->OUT_CSR1, byOutCSR);
|
return;
|
}
|
|
/* Set index register */
|
WRITE_REG(USB->INDEX, pbostate->byEP);
|
/* Read OUT CSR register */
|
byOutCSR = READ_REG(USB->OUT_CSR1);
|
|
/* Get packet, */
|
/* may need to unload more than one packet if double buffering enabled */
|
while (byOutCSR & M_OUTCSR_OPR) {
|
/* Get packet size */
|
nBytes = (int)READ_REG(USB->OUT_COUNT2);
|
nBytes <<= 8;
|
nBytes |= (int)READ_REG(USB->OUT_COUNT1);
|
pbostate->nBuffLen = READ_REG(USB->MAX_PKT_OUT)<<3;
|
|
/* Check there is room in the buffer */
|
// SYS_TEST("AA :%x,%x,%x \r\n",pbostate->nBytesRecv,nBytes,pbostate->nBuffLen);
|
if (pbostate->nBytesRecv + nBytes > pbostate->nBuffLen) {
|
/* Call to function to handle buffer over run */
|
WRITE_REG(USB->OUT_CSR1, 0);
|
return;
|
}
|
|
/* Unload FIFO */
|
USB_Read ((int)pbostate->byEP, nBytes, pbostate->pData);
|
/* Update status */
|
pbostate->nBytesRecv += nBytes;
|
pbostate->pData = (uint8_t *)pbostate->pData + nBytes;
|
|
/* Check for end of transfer */
|
if (nBytes < M_EP_MAXP) {
|
/* Call function to handle received data */
|
}
|
|
/* Clear OutPktRdy */
|
WRITE_REG(USB->OUT_CSR1, 0);
|
/* Check for another packet */
|
byOutCSR = READ_REG(USB->OUT_CSR1);
|
// WRITE_REG(USB->OUT_CSR1, M_OUTCSR_CDT);
|
}
|
}
|
|
#if 1
|
void USB_DmaTransfer(uint8_t *pBuffer,uint8_t u8Ep,uint32_t data_len)
|
{
|
// uint32_t ret= 0,i=0,k=0;
|
uint32_t usb_pkt_size,usbdma_pkt_size;
|
|
WRITE_REG (USB->INDEX,u8Ep);
|
if(data_len > 32){
|
usbdma_pkt_size = DmaMode1Max4;
|
WRITE_REG(USB->MAX_PKT_IN, 4);
|
}
|
else{
|
usb_pkt_size = (data_len/8);
|
usbdma_pkt_size = (data_len/8)<<8;
|
WRITE_REG(USB->MAX_PKT_IN, usb_pkt_size);
|
}
|
|
// WRITE_REG (USB->IN_CSR2,M_INCSR2_MODE | M_INCSR2_DMAEnab | M_INCSR2_AUTOSET ); //set as in mode,AUTO SET INPKTRDY
|
|
//set DMA CONTROL REGISTER
|
WRITE_REG (USBDMA->ADDR1,(uint32_t)pBuffer); //ADDR1 32
|
WRITE_REG (USBDMA->COUNT1, data_len);
|
// WRITE_REG (USBDMA->CNTL1,(EnableDMA | DIR_IN | (u8Ep<<4) | IntEnab| usbdma_pkt_size)); //CNTRL
|
WRITE_REG (USBDMA->CNTL1,(EnableDMA | DIR_IN | DMAMode1 | (u8Ep<<4) | IntEnab| usbdma_pkt_size)); //CNTRL
|
|
// while(!(READ_REG(USB->CSR0_INCSR1) & 0x01));//wait inpktrdy set
|
// while((READ_REG(USB->CSR0_INCSR1) & 0x01)); //wait data sent
|
//
|
// //SECOND PACKET
|
// WRITE_REG(USBDMA->CNTL1,(EnableDMA | DIR_IN | DMAMode1 | (u8Ep<<4) | IntEnab | DmaMode1Max4)); //CNTRL
|
// // WRITE_REG (COUNT1, 64);
|
|
// // while(!(READ_REG(USB->CSR0_INCSR1) & 0x01));//wait inpktrdy set
|
// while((READ_REG(USB->CSR0_INCSR1) & 0x02)); //wait data sent
|
|
// //THIRD PACKET
|
// WRITE_REG (USB->MAX_PKT_IN, 1);
|
// WRITE_REG (USBDMA->CNTL1,(EnableDMA | DIR_IN | DMAMode1 | (u8Ep<<4) | IntEnab | DmaMode1Max1)); //CNTRL
|
// WRITE_REG (USB->CSR0_INCSR1, 1);
|
|
// // while(!(READ_REG(USB->CSR0_INCSR1) & 0x01));//wait inpktrdy set
|
// while((READ_REG(USB->CSR0_INCSR1) & 0x02)); //wait data sent
|
}
|
|
void USB_DmaReceivePre(uint8_t *pBuffer,uint8_t u8Ep,uint32_t data_len)
|
{
|
// uint32_t ret= 0,i=0,k=0;
|
uint32_t /*reg_outcnt,*/usb_pkt_size,usbdma_pkt_size;
|
|
//PID_OUT TEST
|
WRITE_REG(USBDMA->CNTL1,DIR_OUT); //CNTRL
|
WRITE_REG(USB->INDEX,u8Ep);
|
if(data_len > 32){
|
usbdma_pkt_size = DmaMode1Max4;
|
WRITE_REG(USB->MAX_PKT_OUT, 4);
|
}
|
else{
|
usb_pkt_size = (data_len/8);
|
usbdma_pkt_size = (data_len/8)<<8;
|
WRITE_REG(USB->MAX_PKT_OUT, usb_pkt_size);
|
}
|
|
// WRITE_REG(USB->OUT_CSR2, M_OUTCSR2_DMAEnab | M_OUTCSR2_DMAMode | M_OUTCSR2_AutoClear);
|
|
WRITE_REG(USBDMA->ADDR1,(uint32_t)pBuffer); //ADDR1 32
|
WRITE_REG(USBDMA->COUNT1, data_len);
|
WRITE_REG(USBDMA->CNTL1,(EnableDMA | DIR_OUT | DMAMode1 | EndPoint2 | IntEnab | usbdma_pkt_size)); //CNTRL
|
// reg_outcnt = (READ_REG(USB->OUT_COUNT1) | (READ_REG(USB->OUT_COUNT1)<<8));
|
// SYS_TEST("USBDMA->CNTL1:%x \r\n",USBDMA->CNTL1);
|
}
|
|
#endif
|
