bool udd_ep_run(udd_ep_id_t ep, bool b_shortpacket,
uint8_t * buf, iram_size_t buf_size,
udd_callback_trans_t callback)
{
udd_ep_id_t ep_num;
udd_ep_job_t *ptr_job;
irqflags_t flags;
ep_num = ep & USB_EP_ADDR_MASK;
if (USB_DEVICE_MAX_EP < ep_num) {
return false;
}
if ((!Is_udd_endpoint_enabled(ep_num))
|| Is_udd_endpoint_stall_requested(ep_num)) {
return false; // Endpoint is halted
}
// Get job about endpoint
ptr_job = &udd_ep_job[ep_num - 1];
flags = cpu_irq_save();
if (ptr_job->busy == true) {
cpu_irq_restore(flags);
return false; // Job already on going
}
ptr_job->busy = true;
cpu_irq_restore(flags);
// No job running. Let's setup a new one.
//
ptr_job->buf = buf;
ptr_job->buf_size = buf_size;
ptr_job->nb_trans = 0;
ptr_job->call_trans = callback;
ptr_job->b_shortpacket = b_shortpacket;
ptr_job->b_use_out_cache_buffer = false;
if ( (USB_EP_DIR_IN != (ep & USB_EP_DIR_IN))
&& (AVR32_USBC_PTYPE_ISOCHRONOUS == udd_get_endpoint_type(ep_num))
&& (0 != (buf_size % udd_get_endpoint_size(ep_num)))) {
// The user must use a buffer size modulo endpoint size
// for an isochronous IN endpoint
ptr_job->busy = false;
return false;
}
// Initialize value to simulate a empty transfer
udd_udesc_rst_buf0_ctn(ep_num);
udd_udesc_rst_buf0_size(ep_num);
// Request next transfer
udd_ep_trans_done(ep);
return true;
}
/**
* \brief Waits a DATA IN packets on control endpoint
*
* \param payload RAM buffer to store data received
* \param size Size of RAM buffer waiting
*/
static void main_usb_send_in(uint8_t *payload, uint8_t size)
{
uint8_t *ptr_dest;
do {
while (!Is_udd_in_send(0));
// Fill buffer of endpoint control
ptr_dest = (uint8_t *) & udd_get_endpoint_fifo_access(0, 8);
// Write quickly the IN data
for (uint8_t i = 0; (i<udd_get_endpoint_size(0)) && size; i++) {
*ptr_dest++ = *payload++;
size--;
}
// Validate and send the data available in the control endpoint buffer
udd_ack_in_send(0);
} while (size);
while (!Is_udd_in_send(0));
}
static void udd_ep_trans_done(udd_ep_id_t ep)
{
uint32_t udd_dma_ctrl = 0;
udd_ep_job_t *ptr_job;
iram_size_t next_trans;
irqflags_t flags;
// Get job corresponding at endpoint
ptr_job = &udd_ep_job[ep - 1];
if (!ptr_job->busy) {
return; // No job is running, then ignore it (system error)
}
if (ptr_job->nb_trans != ptr_job->buf_size) {
// Need to send or receive other data
next_trans = ptr_job->buf_size - ptr_job->nb_trans;
if (UDD_ENDPOINT_MAX_TRANS < next_trans) {
// The USB hardware support a maximum
// transfer size of UDD_ENDPOINT_MAX_TRANS Bytes
next_trans = UDD_ENDPOINT_MAX_TRANS;
// Set 0 to transfer the maximum
udd_dma_ctrl = (0 <<
AVR32_USBB_UDDMA1_CONTROL_CH_BYTE_LENGTH_OFFSET)
& AVR32_USBB_UDDMA1_CONTROL_CH_BYTE_LENGTH_MASK;
} else {
udd_dma_ctrl = (next_trans <<
AVR32_USBB_UDDMA1_CONTROL_CH_BYTE_LENGTH_OFFSET)
& AVR32_USBB_UDDMA1_CONTROL_CH_BYTE_LENGTH_MASK;
}
if (Is_udd_endpoint_in(ep)) {
if (0 != next_trans % udd_get_endpoint_size(ep)) {
// Enable short packet option
// else the DMA transfer is accepted
// and interrupt DMA valid but nothing is sent.
udd_dma_ctrl |= AVR32_USBB_UDDMA1_CONTROL_DMAEND_EN_MASK;
// No need to request another ZLP
ptr_job->b_shortpacket = false;
}
} else {
if ((USB_EP_TYPE_ISOCHRONOUS != udd_get_endpoint_type(ep))
|| (next_trans <= udd_get_endpoint_size(ep))) {
// Enable short packet reception
udd_dma_ctrl |= AVR32_USBB_UDDMA1_CONTROL_EOT_IRQ_EN_MASK
| AVR32_USBB_UDDMA1_CONTROL_BUFF_CLOSE_IN_EN_MASK;
}
}
// Start USB DMA to fill or read fifo of the selected endpoint
udd_endpoint_dma_set_addr(ep, (U32) &ptr_job->buf[ptr_job->nb_trans]);
udd_dma_ctrl |= AVR32_USBB_UDDMA1_CONTROL_EOBUFF_IRQ_EN_MASK |
AVR32_USBB_UDDMA1_CONTROL_CH_EN_MASK;
// Disable IRQs to have a short sequence
// between read of EOT_STA and DMA enable
flags = cpu_irq_save();
if ( !(udd_endpoint_dma_get_status(ep)
& AVR32_USBB_UDDMA1_STATUS_EOT_STA_MASK)) {
udd_endpoint_dma_set_control(ep, udd_dma_ctrl);
ptr_job->nb_trans += next_trans;
udd_enable_endpoint_dma_interrupt(ep);
cpu_irq_restore(flags);
return;
}
cpu_irq_restore(flags);
// Here a ZLP has been received
// and the DMA transfer must be not started.
// It is the end of transfer
ptr_job->buf_size = ptr_job->nb_trans;
}
if (Is_udd_endpoint_in(ep)) {
if (ptr_job->b_shortpacket) {
// Need to send a ZLP (No possible with USB DMA)
// enable interrupt to wait a free bank to sent ZLP
udd_ack_in_send(ep);
if (Is_udd_write_enabled(ep)) {
// Force interrupt in case of ep already free
udd_raise_in_send(ep);
}
udd_enable_in_send_interrupt(ep);
udd_enable_endpoint_interrupt(ep);
return;
}
}
// Call callback to signal end of transfer
udd_ep_finish_job(ptr_job, false, ep);
}
bool udd_ep_run(udd_ep_id_t ep, bool b_shortpacket,
uint8_t * buf, iram_size_t buf_size,
udd_callback_trans_t callback)
{
bool b_dir_in;
uint32_t udd_dma_ctrl = 0;
udd_ep_job_t *ptr_job;
irqflags_t flags;
b_dir_in = (USB_EP_DIR_IN == (ep & USB_EP_DIR_IN));
ep &= USB_EP_ADDR_MASK;
if (USB_DEVICE_MAX_EP < ep)
return false;
// Get job about endpoint
ptr_job = &udd_ep_job[ep - 1];
if ((!Is_udd_endpoint_enabled(ep))
|| Is_udd_endpoint_stall_requested(ep)
|| ptr_job->stall_requested)
return false; // Endpoint is halted
flags = cpu_irq_save();
if (ptr_job->busy == true) {
cpu_irq_restore(flags);
return false; // Job already on going
}
ptr_job->busy = true;
cpu_irq_restore(flags);
// The USBB supports a maximum transfer size of 64KB
if (0x10000 <= buf_size) {
// Transfer size = 64KB
ptr_job->buf_size = 0x10000;
buf_size = 0;
} else {
ptr_job->buf_size = buf_size;
if (b_dir_in && (0 != buf_size % udd_get_endpoint_size(ep))) {
// Force short packet option to send a shortpacket on IN,
// else the DMA transfer is accepted and interrupt DMA valid but nothing is sent.
b_shortpacket = true;
}
}
ptr_job->buf = buf;
ptr_job->call_trans = callback;
// Start USB DMA to fill or read fifo of the selected endpoint
udd_endpoint_dma_set_addr(ep, (U32) buf);
if (b_shortpacket) {
if (b_dir_in) {
udd_dma_ctrl = AVR32_USBB_UDDMA1_CONTROL_DMAEND_EN_MASK;
} else {
udd_dma_ctrl = AVR32_USBB_UDDMA1_CONTROL_EOT_IRQ_EN_MASK
|
AVR32_USBB_UDDMA1_CONTROL_BUFF_CLOSE_IN_EN_MASK;
}
}
udd_dma_ctrl |= (buf_size <<
AVR32_USBB_UDDMA1_CONTROL_CH_BYTE_LENGTH_OFFSET)
& AVR32_USBB_UDDMA1_CONTROL_CH_BYTE_LENGTH_MASK;
udd_dma_ctrl |= AVR32_USBB_UDDMA1_CONTROL_EOBUFF_IRQ_EN_MASK |
AVR32_USBB_UDDMA1_CONTROL_CH_EN_MASK;
udd_enable_endpoint_bank_autoswitch(ep);
udd_endpoint_dma_set_control(ep, udd_dma_ctrl);
flags = cpu_irq_save();
udd_enable_endpoint_dma_interrupt(ep);
cpu_irq_restore(flags);
return true;
}
static void udd_ep_trans_done(udd_ep_id_t ep)
{
udd_ep_job_t *ptr_job;
uint16_t ep_size, nb_trans;
uint16_t next_trans;
udd_ep_id_t ep_num;
irqflags_t flags;
ep_num = ep & USB_EP_ADDR_MASK;
ep_size = udd_get_endpoint_size(ep_num);
// Get job corresponding at endpoint
ptr_job = &udd_ep_job[ep_num - 1];
// Disable interrupt of endpoint
flags = cpu_irq_save();
udd_disable_endpoint_interrupt(ep_num);
cpu_irq_restore(flags);
if (!ptr_job->busy) {
return; // No job is running, then ignore it (system error)
}
if (USB_EP_DIR_IN == (ep & USB_EP_DIR_IN)) {
// Transfer complete on IN
nb_trans = udd_udesc_get_buf0_size(ep_num);
// Lock emission of new IN packet
udd_enable_busy_bank0(ep_num);
// Ack interrupt
udd_ack_in_send(ep_num);
if (0 == nb_trans) {
if (0 == udd_nb_busy_bank(ep_num)) {
// All byte are transfered than take nb byte requested
nb_trans = udd_udesc_get_buf0_ctn(ep_num);
}
}
// Update number of data transfered
ptr_job->nb_trans += nb_trans;
// Need to send other data
if ((ptr_job->nb_trans != ptr_job->buf_size)
|| ptr_job->b_shortpacket) {
next_trans = ptr_job->buf_size - ptr_job->nb_trans;
if (UDD_ENDPOINT_MAX_TRANS < next_trans) {
// The USB hardware support a maximum
// transfer size of UDD_ENDPOINT_MAX_TRANS Bytes
next_trans = UDD_ENDPOINT_MAX_TRANS -
(UDD_ENDPOINT_MAX_TRANS % ep_size);
udd_udesc_set_buf0_autozlp(ep_num, false);
} else {
// Need ZLP, if requested and last packet is not a short packet
udd_udesc_set_buf0_autozlp(ep_num, ptr_job->b_shortpacket);
ptr_job->b_shortpacket = false; // No need to request another ZLP
}
udd_udesc_set_buf0_ctn(ep_num, next_trans);
udd_udesc_rst_buf0_size(ep_num);
// Link the user buffer directly on USB hardware DMA
udd_udesc_set_buf0_addr(ep_num,
&ptr_job->buf[ptr_job->nb_trans]);
// Start transfer
udd_ack_fifocon(ep_num);
udd_disable_busy_bank0(ep_num);
// Enable interrupt
flags = cpu_irq_save();
udd_enable_in_send_interrupt(ep_num);
udd_enable_endpoint_interrupt(ep_num);
cpu_irq_restore(flags);
return;
}
} else {
// Transfer complete on OUT
nb_trans = udd_udesc_get_buf0_ctn(ep_num);
// Lock reception of new OUT packet
udd_enable_busy_bank0(ep_num);
// Ack interrupt
udd_ack_out_received(ep_num);
udd_ack_fifocon(ep_num);
// Can be necessary to copy data receive from cache buffer to user buffer
if (ptr_job->b_use_out_cache_buffer) {
memcpy(&ptr_job->buf[ptr_job->nb_trans],
udd_ep_out_cache_buffer[ep_num - 1],
ptr_job->buf_size % ep_size);
}
// Update number of data transfered
ptr_job->nb_trans += nb_trans;
if (ptr_job->nb_trans > ptr_job->buf_size) {
ptr_job->nb_trans = ptr_job->buf_size;
}
// If all previous data requested are received and user buffer not full
// then need to receive other data
if ((nb_trans == udd_udesc_get_buf0_size(ep_num))
&& (ptr_job->nb_trans != ptr_job->buf_size)) {
next_trans = ptr_job->buf_size - ptr_job->nb_trans;
if (UDD_ENDPOINT_MAX_TRANS < next_trans) {
// The USB hardware support a maximum transfer size
// of UDD_ENDPOINT_MAX_TRANS Bytes
next_trans = UDD_ENDPOINT_MAX_TRANS
- (UDD_ENDPOINT_MAX_TRANS % ep_size);
} else {
next_trans -= next_trans % ep_size;
}
udd_udesc_rst_buf0_ctn(ep_num);
if (next_trans < ep_size) {
// Use the cache buffer for Bulk or Interrupt size endpoint
ptr_job->b_use_out_cache_buffer = true;
udd_udesc_set_buf0_addr(ep_num,
udd_ep_out_cache_buffer[ep_num-1]);
udd_udesc_set_buf0_size(ep_num, ep_size);
} else {
// Link the user buffer directly on USB hardware DMA
udd_udesc_set_buf0_addr(ep_num, &ptr_job->buf[ptr_job->nb_trans]);
udd_udesc_set_buf0_size(ep_num, next_trans);
}
// Start transfer
udd_disable_busy_bank0(ep_num);
// Enable interrupt
flags = cpu_irq_save();
udd_enable_out_received_interrupt(ep_num);
udd_enable_endpoint_interrupt(ep_num);
cpu_irq_restore(flags);
return;
}
}
// Job complete then call callback
ptr_job->busy = false;
if (NULL != ptr_job->call_trans) {
ptr_job->call_trans(UDD_EP_TRANSFER_OK, ptr_job->nb_trans, ep);
}
return;
}
bool udd_ep_run(udd_ep_id_t ep, bool b_shortpacket,
uint8_t * buf, iram_size_t buf_size,
udd_callback_trans_t callback)
{
uint16_t ep_size, trans_size, short_packet;
bool b_dir_in;
udd_ep_job_t *ptr_job;
irqflags_t flags;
b_dir_in = (USB_EP_DIR_IN == (ep & USB_EP_DIR_IN));
ep &= USB_EP_ADDR_MASK;
if (USB_DEVICE_MAX_EP < ep)
return false;
// Get job about endpoint
ptr_job = &udd_ep_job[ep - 1];
if ((!Is_udd_endpoint_enabled(ep))
|| Is_udd_endpoint_stall_requested(ep))
return false; // Endpoint is halted
flags = cpu_irq_save();
if (ptr_job->busy == true) {
cpu_irq_restore(flags);
return false; // Job already on going
}
ptr_job->busy = true;
cpu_irq_restore(flags);
// No job running. Let's setup a new one.
//
// The USB hardware support a maximum transfer size of 0x7FFF Bytes
ep_size = udd_get_endpoint_size(ep);
if (0x7FFF < buf_size) {
trans_size = 0x7FFF - (0x7FFF % ep_size);
short_packet = 0;
} else {
trans_size = buf_size;
short_packet = trans_size % ep_size;
}
if (b_dir_in) {
// Need ZLP, if requested and last packet is not a short packet
udd_udesc_set_buf0_autozlp(ep, b_shortpacket);
udd_udesc_set_buf0_ctn(ep, trans_size);
udd_udesc_rst_buf0_size(ep);
// Link the user buffer directly on USB hardware DMA
udd_udesc_set_buf0_addr(ep, buf);
} else {
udd_udesc_rst_buf0_ctn(ep);
ptr_job->nb_trans = 0;
if (trans_size < ep_size) {
// The user buffer is smaller than endpoint size
if (AVR32_USBC_PTYPE_ISOCHRONOUS ==
udd_get_endpoint_type(ep)) {
ptr_job->busy = false;
return false; // The user must use a buffer corresponding at isochrnous endpoint size
}
// Use the cache buffer for Bulk or Interrupt size endpoint
ptr_job->b_use_out_cache_buffer = true;
udd_udesc_set_buf0_addr(ep,
udd_ep_out_cache_buffer[ep - 1]);
udd_udesc_set_buf0_size(ep, ep_size);
} else {
// Link the user buffer directly on USB hardware DMA
ptr_job->b_use_out_cache_buffer = false;
udd_udesc_set_buf0_addr(ep, buf);
udd_udesc_set_buf0_size(ep, trans_size - short_packet);
}
}
// Update Job information
ptr_job->buf = buf;
ptr_job->buf_size = trans_size;
ptr_job->call_trans = callback;
ptr_job->busy = true;
// Start transfer
udd_disable_busy_bank0(ep);
// Enable interrupt
flags = cpu_irq_save();
if (b_dir_in) {
udd_ack_fifocon(ep);
udd_ack_in_send(ep);
udd_enable_in_send_interrupt(ep);
} else {
udd_enable_out_received_interrupt(ep);
}
udd_enable_endpoint_interrupt(ep);
cpu_irq_restore(flags);
return true;
}
