void usbc_ep0_send(const void *buf, size_t len, size_t maxlen)
{
LTRACEF("buf %p, len %zu, maxlen %zu\n", buf, len, maxlen);
USBEndpointDataPut(USB0_BASE, USB_EP_0, (void *)buf, MIN(len, maxlen));
USBEndpointDataSend(USB0_BASE, USB_EP_0, USB_TRANS_SETUP);
}
//*****************************************************************************
//
//! Transmits a packet of data to the USB host via the bulk data interface.
//!
//! \param pvInstance is the pointer to the device instance structure as
//! returned by USBDBulkInit().
//! \param pcData points to the first byte of data which is to be transmitted.
//! \param ulLength is the number of bytes of data to transmit.
//! \param bLast indicates whether more data is to be written before a packet
//! should be scheduled for transmission. If \b true, the client will make
//! a further call to this function. If \b false, no further call will be
//! made and the driver should schedule transmission of a short packet.
//!
//! This function schedules the supplied data for transmission to the USB
//! host in a single USB packet. If no transmission is currently ongoing,
//! the data is immediately copied to the relevant USB endpoint FIFO for
//! transmission. Whenever a USB packet is acknowledged by the host, a
//! USB_EVENT_TX_COMPLETE event will be sent to the transmit channel callback
//! indicating that more data can now be transmitted.
//!
//! The maximum value for \e ulLength is 64 bytes (the maximum USB packet size
//! for the bulk endpoints in use by the device). Attempts to send more data
//! than this will result in a return code of 0 indicating that the data cannot
//! be sent.
//!
//! The \e bLast parameter allows a client to make multiple calls to this
//! function before scheduling transmission of the packet to the host. This
//! can be helpful if, for example, constructing a packet on the fly or
//! writing a packet which spans the wrap point in a ring buffer.
//!
//! \return Returns the number of bytes actually sent. At this level, this
//! will either be the number of bytes passed (if less than or equal to the
//! maximum packet size for the USB endpoint in use and no outstanding
//! transmission ongoing) or 0 to indicate a failure.
//
//*****************************************************************************
unsigned int
USBDBulkPacketWrite(void *pvInstance, unsigned char *pcData,
unsigned int ulLength, tBoolean bLast)
{
tBulkInstance *psInst;
int iRetcode;
ASSERT(pvInstance);
//
// Get our instance data pointer
//
psInst = ((tUSBDBulkDevice *)pvInstance)->psPrivateBulkData;
//
// Can we send the data provided?
//
if((ulLength > DATA_IN_EP_MAX_SIZE) ||
(psInst->eBulkTxState != BULK_STATE_IDLE))
{
//
// Either the packet was too big or we are in the middle of sending
// another packet. Return 0 to indicate that we can't send this data.
//
return (0);
}
//
// Copy the data into the USB endpoint FIFO.
//
iRetcode = USBEndpointDataPut(psInst->ulUSBBase, psInst->ucINEndpoint,
pcData, ulLength);
//
// Did we copy the data successfully?
//
if(iRetcode != -1)
{
//
// Remember how many bytes we sent.
//
psInst->usLastTxSize += (unsigned short)ulLength;
//
// If this is the last call for this packet, schedule transmission.
//
if(bLast)
{
//
// Send the packet to the host if we have received all the data we
// can expect for this packet.
//
psInst->eBulkTxState = BULK_STATE_WAIT_DATA;
iRetcode = USBEndpointDataSend(psInst->ulUSBBase,
psInst->ucINEndpoint, USB_TRANS_IN);
}
}
//
// Did an error occur while trying to send the data?
//
if(iRetcode != -1)
{
//
// No - tell the caller we sent all the bytes provided.
//
return (ulLength);
}
else
{
//
// Yes - tell the caller we couldn't send the data.
//
return (0);
}
}
