/*
Function: USBD_Write
Sends data through a USB endpoint. Sets up the transfer descriptor,
writes one or two data payloads (depending on the number of FIFO bank
for the endpoint) and then starts the actual transfer. The operation is
complete when all the data has been sent.
*If the size of the buffer is greater than the size of the endpoint
(or twice the size if the endpoint has two FIFO banks), then the buffer
must be kept allocated until the transfer is finished*. This means that
it is not possible to declare it on the stack (i.e. as a local variable
of a function which returns after starting a transfer).
Parameters:
eptnum - Endpoint number.
data - Pointer to a buffer with the data to send.
size - Size of the data buffer.
callback - Optional callback function to invoke when the transfer is
complete.
argument - Optional argument to the callback function.
Returns:
USBD_STATUS_SUCCESS if the transfer has been started; otherwise, the
corresponding error status code.
*/
char USBD_Write(unsigned char eptnum,
const void *data,
unsigned int size,
TransferCallback callback,
void *argument)
{
Endpoint *endpoint = &(endpoints[eptnum]);
Transfer *transfer = &(endpoint->transfer);
// Check that the endpoint is in Idle state
if (endpoint->state != UDP_ENDPOINT_IDLE) {
return USBD_STATUS_LOCKED;
}
//TRACE_INFO( "Write%d(%u) ", eptnum, size);
// Setup the transfer descriptor
transfer->data = (void *) data;
transfer->remaining = size;
transfer->buffered = 0;
transfer->transferred = 0;
transfer->callback = callback;
transfer->argument = argument;
// Send the first packet
endpoint->state = UDP_ENDPOINT_SENDING;
while((AT91C_BASE_UDP->UDP_CSR[eptnum]&AT91C_UDP_TXPKTRDY)==AT91C_UDP_TXPKTRDY);
UDP_WritePayload(eptnum);
SET_CSR(eptnum, AT91C_UDP_TXPKTRDY);
// If double buffering is enabled and there is data remaining,
// prepare another packet
if ((BOARD_USB_ENDPOINTS_BANKS(eptnum) > 1) && (transfer->remaining > 0)) {
UDP_WritePayload(eptnum);
}
// Enable interrupt on endpoint
AT91C_BASE_UDP->UDP_IER = 1 << eptnum;
return USBD_STATUS_SUCCESS;
}
/*
Function: UDP_EndpointHandler
Endpoint interrupt handler. Manages IN, OUT & SETUP transaction, as well
as the STALL condition.
Parameters:
eptnum - Number of the endpoint to handle interrupt for.
*/
static void UDP_EndpointHandler(unsigned char eptnum)
{
Endpoint *endpoint = &(endpoints[eptnum]);
Transfer *transfer = &(endpoint->transfer);
unsigned int status = AT91C_BASE_UDP->UDP_CSR[eptnum];
//TRACE_INFO( "Ept%d ", eptnum);
//TRACE_INFO( "[");
// Handle interrupts
// IN packet sent
if ((status & AT91C_UDP_TXCOMP) != 0) {
//TRACE_INFO( "Wr ");
// Check that endpoint was in Sending state
if (endpoint->state == UDP_ENDPOINT_SENDING) {
// End of transfer ?
if (UDP_IsTransferFinished(eptnum)) {
// TRACE_INFO( "%d ", transfer->buffered);
transfer->transferred += transfer->buffered;
transfer->buffered = 0;
// Disable interrupt if this is not a control endpoint
if ((status & AT91C_UDP_EPTYPE) != AT91C_UDP_EPTYPE_CTRL) {
AT91C_BASE_UDP->UDP_IDR = 1 << eptnum;
}
UDP_EndOfTransfer(eptnum, USBD_STATUS_SUCCESS);
CLEAR_CSR(eptnum, AT91C_UDP_TXCOMP);
}
else {
// Transfer remaining data
//TRACE_INFO( "PQ:%d ", endpoint->size);
transfer->transferred += endpoint->size;
transfer->buffered -= endpoint->size;
// Send next packet
if (BOARD_USB_ENDPOINTS_BANKS(eptnum) == 1) {
// No double buffering
UDP_WritePayload(eptnum);
SET_CSR(eptnum, AT91C_UDP_TXPKTRDY);
CLEAR_CSR(eptnum, AT91C_UDP_TXCOMP);
}
else {
// Double buffering
SET_CSR(eptnum, AT91C_UDP_TXPKTRDY);
CLEAR_CSR(eptnum, AT91C_UDP_TXCOMP);
UDP_WritePayload(eptnum);
}
}
}
else {
// Acknowledge interrupt
CLEAR_CSR(eptnum, AT91C_UDP_TXCOMP);
}
}
// OUT packet received
if ((status & UDP_RXDATA) != 0) {
//TRACE_INFO( "Rd ");
// Check that the endpoint is in Receiving state
if (endpoint->state != UDP_ENDPOINT_RECEIVING) {
// Check if an ACK has been received on a Control endpoint
if (((status & AT91C_UDP_EPTYPE) == AT91C_UDP_EPTYPE_CTRL)
&& ((status & AT91C_UDP_RXBYTECNT) == 0)) {
// Acknowledge the data and finish the current transfer
///TRACE_INFO( "[%d]Ack ",eptnum);
UDP_ClearRxFlag(eptnum);
UDP_EndOfTransfer(eptnum, USBD_STATUS_SUCCESS);
}
// Check if the data has been STALLed
else if ((status & AT91C_UDP_FORCESTALL) != 0) {
// Discard STALLed data
TRACE_INFO( "[%d]Disc ",eptnum);
UDP_ClearRxFlag(eptnum);
}
// NAK the data
else {
TRACE_INFO( "[%d]Nak ",eptnum);
AT91C_BASE_UDP->UDP_IDR = 1 << eptnum;
}
}
// Endpoint is in Read state
else {
// Retrieve data and store it into the current transfer buffer
unsigned short size = (unsigned short) (status >> 16);
//TRACE_INFO( "-[%d]-", size);
//TRACE_INFO( "Rec ");
UDP_ReadPayload(eptnum, size);
UDP_ClearRxFlag(eptnum);
// Check if the transfer is finished
if ((transfer->remaining == 0) || (size < endpoint->size)) {
// Disable interrupt if this is not a control endpoint
if ((status & AT91C_UDP_EPTYPE) != AT91C_UDP_EPTYPE_CTRL) {
AT91C_BASE_UDP->UDP_IDR = 1 << eptnum;
}
UDP_EndOfTransfer(eptnum, USBD_STATUS_SUCCESS);
}
}
}
// SETUP packet received
if ((status & AT91C_UDP_RXSETUP) != 0) {
//TRACE_INFO( "Stp ");
// If a transfer was pending, complete it
// Handles the case where during the status phase of a control write
// transfer, the host receives the device ZLP and ack it, but the ack
// is not received by the device
if ((endpoint->state == UDP_ENDPOINT_RECEIVING)
|| (endpoint->state == UDP_ENDPOINT_SENDING)) {
UDP_EndOfTransfer(eptnum, USBD_STATUS_SUCCESS);
}
USBGenericRequest request;
UDP_ReadRequest(&request);
// Set the DIR bit before clearing RXSETUP in Control IN sequence
if (USBGenericRequest_GetDirection(&request) == USBGenericRequest_IN) {
SET_CSR(eptnum, AT91C_UDP_DIR);
}
CLEAR_CSR(eptnum, AT91C_UDP_RXSETUP);
// Forward the request to the upper layer
USBDCallbacks_RequestReceived(&request);//------------------------------------
}
// STALL sent
if ((status & AT91C_UDP_STALLSENT) != 0) {
TRACE_INFO( "STA ");
// If the endpoint is not halted, clear the STALL condition
CLEAR_CSR(eptnum, AT91C_UDP_STALLSENT);
if (endpoint->state != UDP_ENDPOINT_HALTED) {
CLEAR_CSR(eptnum, AT91C_UDP_FORCESTALL);
}
}
//TRACE_INFO( "]");
}
//------------------------------------------------------------------------------
// \brief Endpoint interrupt handler.
//
// Handle IN/OUT transfers, received SETUP packets and STALLing
// \param pUsb Pointer to a S_usb instance
// \param bEndpoint Index of endpoint
// \see S_usb
//------------------------------------------------------------------------------
static void UDP_EndpointHandler(const S_usb *pUsb, unsigned char bEndpoint)
{
S_usb_endpoint *pEndpoint = USB_GetEndpoint(pUsb, bEndpoint);
AT91PS_UDP pInterface = UDP_GetDriverInterface(pUsb);
unsigned int dStatus = pInterface->UDP_CSR[bEndpoint];
TRACE_DEBUG_L("Ept%d ", bEndpoint);
// Handle interrupts
// IN packet sent
if (ISSET(dStatus, AT91C_UDP_TXCOMP)) {
TRACE_DEBUG_L("Wr ");
// Check that endpoint was in Write state
if (pEndpoint->dState == endpointStateWrite) {
// End of transfer ?
if ((pEndpoint->dBytesBuffered < pEndpoint->wMaxPacketSize)
||
(!ISCLEARED(dStatus, AT91C_UDP_EPTYPE)
&& (pEndpoint->dBytesRemaining == 0)
&& (pEndpoint->dBytesBuffered == pEndpoint->wMaxPacketSize))) {
TRACE_DEBUG_L("%d ", pEndpoint->dBytesBuffered);
pEndpoint->dBytesTransferred += pEndpoint->dBytesBuffered;
pEndpoint->dBytesBuffered = 0;
// Disable interrupt if this is not a control endpoint
if (!ISCLEARED(dStatus, AT91C_UDP_EPTYPE)) {
SET(pInterface->UDP_IDR, 1 << bEndpoint);
}
UDP_EndOfTransfer(pEndpoint, USB_STATUS_SUCCESS);
}
else {
// Transfer remaining data
TRACE_DEBUG_L("%d ", pEndpoint->wMaxPacketSize);
pEndpoint->dBytesTransferred += pEndpoint->wMaxPacketSize;
pEndpoint->dBytesBuffered -= pEndpoint->wMaxPacketSize;
// Send next packet
if (pEndpoint->dNumFIFO == 1) {
// No double buffering
UDP_WritePayload(pUsb, bEndpoint);
UDP_SETEPFLAGS(pUsb, bEndpoint, AT91C_UDP_TXPKTRDY);
}
else {
// Double buffering
UDP_SETEPFLAGS(pUsb, bEndpoint, AT91C_UDP_TXPKTRDY);
UDP_WritePayload(pUsb, bEndpoint);
}
}
}
// Acknowledge interrupt
UDP_CLEAREPFLAGS(pUsb, bEndpoint, AT91C_UDP_TXCOMP);
}
// OUT packet received
if (ISSET(dStatus, AT91C_UDP_RX_DATA_BK0)
|| ISSET(dStatus, AT91C_UDP_RX_DATA_BK1)) {
TRACE_DEBUG_L("Rd ");
// Check that the endpoint is in Read state
if (pEndpoint->dState != endpointStateRead) {
// Endpoint is NOT in Read state
if (ISCLEARED(dStatus, AT91C_UDP_EPTYPE)
&& ISCLEARED(dStatus, 0xFFFF0000)) {
// Control endpoint, 0 bytes received
// Acknowledge the data and finish the current transfer
TRACE_DEBUG_L("Ack ");
UDP_ClearRXFlag(pUsb, bEndpoint);
UDP_EndOfTransfer(pEndpoint, USB_STATUS_SUCCESS);
}
else if (ISSET(dStatus, AT91C_UDP_FORCESTALL)) {
// Non-control endpoint
// Discard stalled data
TRACE_DEBUG_L("Disc ");
UDP_ClearRXFlag(pUsb, bEndpoint);
}
else {
// Non-control endpoint
// Nak data
TRACE_DEBUG_L("Nak ");
SET(pInterface->UDP_IDR, 1 << bEndpoint);
}
}
else {
// Endpoint is in Read state
// Retrieve data and store it into the current transfer buffer
unsigned short wPacketSize = (unsigned short) (dStatus >> 16);
TRACE_DEBUG_L("%d ", wPacketSize);
UDP_GetPayload(pUsb, bEndpoint, wPacketSize);
UDP_ClearRXFlag(pUsb, bEndpoint);
if ((pEndpoint->dBytesRemaining == 0)
|| (wPacketSize < pEndpoint->wMaxPacketSize)) {
// Disable interrupt if this is not a control endpoint
if (!ISCLEARED(dStatus, AT91C_UDP_EPTYPE)) {
SET(pInterface->UDP_IDR, 1 << bEndpoint);
}
UDP_EndOfTransfer(pEndpoint, USB_STATUS_SUCCESS);
}
}
}