848 lines
21 KiB
C
848 lines
21 KiB
C
#include <usb-arch.h>
|
|
#include <usb-interrupt.h>
|
|
#include <AT91SAM7S64.h>
|
|
#include <stdio.h>
|
|
#include <debug-uart.h>
|
|
|
|
|
|
/* #define DEBUG */
|
|
#ifdef DEBUG
|
|
#define PRINTF(...) printf(__VA_ARGS__)
|
|
#else
|
|
#define PRINTF(...)
|
|
#endif
|
|
|
|
#define USB_PULLUP_PIN AT91C_PIO_PA16
|
|
|
|
#ifndef AT91C_UDP_STALLSENT
|
|
#define AT91C_UDP_STALLSENT AT91C_UDP_ISOERROR
|
|
#endif
|
|
|
|
/* Bits that won't effect the state if they're written at a specific level.
|
|
*/
|
|
/* Bits that should be written as 1 */
|
|
#define NO_EFFECT_BITS (AT91C_UDP_TXCOMP | AT91C_UDP_RX_DATA_BK0 | AT91C_UDP_RXSETUP \
|
|
| AT91C_UDP_ISOERROR | AT91C_UDP_RX_DATA_BK1)
|
|
/* Also includes bits that should be written as 0 */
|
|
#define NO_EFFECT_MASK (NO_EFFECT_BITS | AT91C_UDP_TXPKTRDY)
|
|
|
|
#define RXBYTECNT(s) (((s)>>16)&0x7ff)
|
|
|
|
|
|
static inline void
|
|
udp_set_ep_ctrl_flags(AT91_REG *reg, unsigned int flags,
|
|
unsigned int write_mask, unsigned int check_mask)
|
|
{
|
|
while ( (*reg & check_mask) != (flags & check_mask)) {
|
|
*reg = (*reg & ~write_mask) | flags;
|
|
}
|
|
}
|
|
|
|
#define UDP_SET_EP_CTRL_FLAGS(reg, flags, mask) \
|
|
udp_set_ep_ctrl_flags((reg), \
|
|
(NO_EFFECT_BITS & ~(mask)) | ((flags) & (mask)), (mask) | NO_EFFECT_MASK,\
|
|
(mask))
|
|
|
|
|
|
#define USB_DISABLE_INT *AT91C_AIC_IDCR = (1 << AT91C_ID_UDP)
|
|
#define USB_ENABLE_INT *AT91C_AIC_IECR = (1 << AT91C_ID_UDP)
|
|
|
|
#define USB_DISABLE_EP_INT(hw_ep) *AT91C_UDP_IDR = (1 << (hw_ep))
|
|
#define USB_ENABLE_EP_INT(hw_ep) *AT91C_UDP_IER = (1 << (hw_ep))
|
|
|
|
#if CTRL_EP_SIZE > 8
|
|
#error Control endpoint size too big
|
|
#endif
|
|
|
|
#if USB_EP1_SIZE > 64
|
|
#error Endpoint 1 size too big
|
|
#endif
|
|
|
|
#if USB_EP2_SIZE > 64
|
|
#error Endpoint 2 size too big
|
|
#endif
|
|
|
|
#if USB_EP3_SIZE > 64
|
|
#error Endpoint 3 size too big
|
|
#endif
|
|
|
|
static const uint16_t ep_xfer_size[8] =
|
|
{
|
|
CTRL_EP_SIZE,
|
|
USB_EP1_SIZE,
|
|
USB_EP2_SIZE,
|
|
USB_EP3_SIZE
|
|
};
|
|
|
|
#define USB_EP_XFER_SIZE(ep) ep_xfer_size[ep]
|
|
|
|
typedef struct _USBEndpoint USBEndpoint;
|
|
struct _USBEndpoint
|
|
{
|
|
uint16_t status;
|
|
uint8_t addr;
|
|
uint8_t flags;
|
|
USBBuffer *buffer; /* NULL if no current buffer */
|
|
struct process *event_process;
|
|
unsigned int events;
|
|
uint16_t xfer_size;
|
|
};
|
|
|
|
#define USB_EP_FLAGS_TYPE_MASK 0x03
|
|
#define USB_EP_FLAGS_TYPE_BULK 0x00
|
|
#define USB_EP_FLAGS_TYPE_CONTROL 0x01
|
|
#define USB_EP_FLAGS_TYPE_ISO 0x02
|
|
#define USB_EP_FLAGS_TYPE_INTERRUPT 0x03
|
|
|
|
#define EP_TYPE(ep) ((ep)->flags & USB_EP_FLAGS_TYPE_MASK)
|
|
#define IS_EP_TYPE(ep, type) (EP_TYPE(ep) == (type))
|
|
#define IS_CONTROL_EP(ep) IS_EP_TYPE(ep, USB_EP_FLAGS_TYPE_CONTROL)
|
|
#define IS_BULK_EP(ep) IS_EP_TYPE(ep, USB_EP_FLAGS_TYPE_BULK)
|
|
|
|
#define USB_EP_FLAGS_ENABLED 0x04
|
|
|
|
/* A packet has been received but the data is still in hardware buffer */
|
|
#define USB_EP_FLAGS_RECV_PENDING 0x08
|
|
/* The pending packet is a SETUP packet */
|
|
#define USB_EP_FLAGS_SETUP_PENDING 0x10
|
|
|
|
/* The data in the hardware buffer is being transmitted */
|
|
#define USB_EP_FLAGS_TRANSMITTING 0x20
|
|
|
|
/* The receiver is waiting for a packet */
|
|
#define USB_EP_FLAGS_RECEIVING 0x40
|
|
|
|
/* For bulk endpoints. Both buffers are busy are in use, either by
|
|
hardware or software. */
|
|
#define USB_EP_FLAGS_DOUBLE 0x80
|
|
|
|
/* The next packet received should be read from bank 1 if possible */
|
|
#define USB_EP_FLAGS_BANK_1_RECV_NEXT 0x10
|
|
|
|
/* States for double buffered reception:
|
|
|
|
Packets being received 0 1 2 1 0 0
|
|
Packets pending 0 0 0 1 2 1
|
|
|
|
RECVING 0 1 1 1 0 0
|
|
RECV_PENDING 0 0 0 1 1 1
|
|
DOUBLE 0 0 1 0 1 0
|
|
*/
|
|
|
|
/* States for double buffered transmission:
|
|
|
|
Packets being transmitted 0 1 2
|
|
|
|
TRANSMITTING 0 1 1
|
|
DOUBLE 0 0 1
|
|
*/
|
|
|
|
/* Index in endpoint array */
|
|
#define EP_INDEX(addr) ((addr) & 0x7f)
|
|
|
|
/* Get address of endpoint struct */
|
|
#define EP_STRUCT(addr) &usb_endpoints[EP_INDEX(addr)];
|
|
|
|
/* Number of hardware endpoint */
|
|
#define EP_HW_NUM(addr) ((addr) & 0x7f)
|
|
|
|
|
|
static USBEndpoint usb_endpoints[USB_MAX_ENDPOINTS];
|
|
struct process *event_process = 0;
|
|
volatile unsigned int events = 0;
|
|
|
|
static void
|
|
notify_process(unsigned int e)
|
|
{
|
|
events |= e;
|
|
if (event_process) {
|
|
process_poll(event_process);
|
|
}
|
|
}
|
|
|
|
static void
|
|
notify_ep_process(USBEndpoint *ep, unsigned int e)
|
|
{
|
|
ep->events |= e;
|
|
if (ep->event_process) {
|
|
process_poll(ep->event_process);
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
usb_arch_reset(void)
|
|
{
|
|
unsigned int e;
|
|
for (e = 0; e < USB_MAX_ENDPOINTS; e++) {
|
|
if (usb_endpoints[e].flags &USB_EP_FLAGS_ENABLED) {
|
|
USBBuffer *buffer = usb_endpoints[e].buffer;
|
|
usb_endpoints[e].flags = 0;
|
|
usb_disable_endpoint(e);
|
|
while(buffer) {
|
|
buffer->flags &= ~USB_BUFFER_SUBMITTED;
|
|
buffer = buffer->next;
|
|
}
|
|
}
|
|
}
|
|
usb_arch_setup_control_endpoint(0);
|
|
|
|
}
|
|
|
|
void
|
|
usb_arch_setup(void)
|
|
{
|
|
unsigned int i;
|
|
/* Assume 96MHz PLL frequency */
|
|
*AT91C_CKGR_PLLR = ((*AT91C_CKGR_PLLR & ~AT91C_CKGR_USBDIV)
|
|
| AT91C_CKGR_USBDIV_1);
|
|
/* Enable 48MHz USB clock */
|
|
*AT91C_PMC_SCER = AT91C_PMC_UDP;
|
|
/* Enable USB main clock */
|
|
*AT91C_PMC_PCER = (1 << AT91C_ID_UDP);
|
|
|
|
/* Enable pullup */
|
|
*AT91C_PIOA_PER = USB_PULLUP_PIN;
|
|
*AT91C_PIOA_OER = USB_PULLUP_PIN;
|
|
*AT91C_PIOA_CODR = USB_PULLUP_PIN;
|
|
|
|
for(i = 0; i < USB_MAX_ENDPOINTS; i++) {
|
|
usb_endpoints[i].flags = 0;
|
|
usb_endpoints[i].event_process = 0;
|
|
}
|
|
|
|
usb_arch_reset();
|
|
/* Enable usb_interrupt */
|
|
AT91C_AIC_SMR[AT91C_ID_UDP] = AT91C_AIC_SRCTYPE_INT_HIGH_LEVEL | 4;
|
|
AT91C_AIC_SVR[AT91C_ID_UDP] = (unsigned long) usb_int;
|
|
*AT91C_AIC_IECR = (1 << AT91C_ID_UDP);
|
|
}
|
|
|
|
|
|
static void
|
|
usb_arch_setup_endpoint(unsigned char addr, unsigned int hw_type)
|
|
{
|
|
unsigned int ei = EP_HW_NUM(addr);
|
|
USBEndpoint *ep = EP_STRUCT(addr);
|
|
ep->status = 0;
|
|
ep->flags = USB_EP_FLAGS_ENABLED;
|
|
ep->buffer = 0;
|
|
ep->addr = addr;
|
|
ep->events = 0;
|
|
ep->xfer_size = 0;
|
|
|
|
*AT91C_UDP_IDR = 1<<ei;
|
|
|
|
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[ei], hw_type | AT91C_UDP_EPEDS,
|
|
AT91C_UDP_EPTYPE | AT91C_UDP_EPEDS);
|
|
|
|
*AT91C_UDP_IER = 1<<ei;
|
|
};
|
|
|
|
void
|
|
usb_arch_setup_control_endpoint(unsigned char addr)
|
|
{
|
|
unsigned int ei = EP_HW_NUM(addr);
|
|
USBEndpoint *ep = EP_STRUCT(addr);
|
|
usb_arch_setup_endpoint(addr, AT91C_UDP_EPTYPE_CTRL);
|
|
ep->flags |= USB_EP_FLAGS_TYPE_CONTROL;
|
|
ep->xfer_size = ep_xfer_size[ei];
|
|
|
|
}
|
|
|
|
void
|
|
usb_arch_setup_bulk_endpoint(unsigned char addr)
|
|
{
|
|
unsigned int ei = EP_HW_NUM(addr);
|
|
USBEndpoint *ep = EP_STRUCT(addr);
|
|
usb_arch_setup_endpoint(addr, ((addr & 0x80)
|
|
? AT91C_UDP_EPTYPE_BULK_IN
|
|
: AT91C_UDP_EPTYPE_BULK_OUT));
|
|
ep->flags |= USB_EP_FLAGS_TYPE_BULK;
|
|
ep->xfer_size = ep_xfer_size[ei];
|
|
}
|
|
|
|
void
|
|
usb_arch_setup_interrupt_endpoint(unsigned char addr)
|
|
{
|
|
unsigned int ei = EP_HW_NUM(addr);
|
|
USBEndpoint *ep = EP_STRUCT(addr);
|
|
usb_arch_setup_endpoint(addr, ((addr & 0x80)
|
|
? AT91C_UDP_EPTYPE_INT_IN
|
|
: AT91C_UDP_EPTYPE_INT_OUT));
|
|
ep->flags |= USB_EP_FLAGS_TYPE_BULK;
|
|
ep->xfer_size = ep_xfer_size[ei];
|
|
}
|
|
|
|
void
|
|
usb_arch_disable_endpoint(uint8_t addr)
|
|
{
|
|
USBEndpoint *ep = EP_STRUCT(addr);
|
|
ep->flags &= ~USB_EP_FLAGS_ENABLED;
|
|
|
|
*AT91C_UDP_IDR = 1<<EP_HW_NUM(addr);
|
|
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[EP_HW_NUM(addr)], 0, AT91C_UDP_EPEDS);
|
|
}
|
|
|
|
|
|
#define USB_READ_BLOCK 0x01 /* The currently submitted buffers
|
|
can't hold the received data, wait
|
|
for more buffers. No data was read
|
|
from the hardware buffer */
|
|
#define USB_READ_NOTIFY 0x02 /* Some buffers that had the
|
|
USB_BUFFER_NOTIFY flags set were
|
|
released */
|
|
#define USB_READ_FAIL 0x04 /* The received data doesn't match the
|
|
submitted buffers. The hardware
|
|
buffer is discarded. */
|
|
|
|
/* Skip buffers until mask and flags matches*/
|
|
static USBBuffer *
|
|
skip_buffers_until(USBBuffer *buffer, unsigned int mask, unsigned int flags,
|
|
unsigned int *resp)
|
|
{
|
|
while(buffer && !((buffer->flags & mask) == flags)) {
|
|
USBBuffer *next = buffer->next;
|
|
buffer->flags &= ~USB_BUFFER_SUBMITTED ;
|
|
buffer->flags |= USB_BUFFER_FAILED;
|
|
if (buffer->flags & USB_BUFFER_NOTIFY) *resp |= USB_READ_NOTIFY;
|
|
buffer = next;
|
|
}
|
|
return buffer;
|
|
}
|
|
|
|
static void
|
|
read_hw_buffer(uint8_t *data, unsigned int hw_ep, unsigned int len)
|
|
{
|
|
AT91_REG *fdr;
|
|
fdr = &AT91C_UDP_FDR[hw_ep];
|
|
while(len-- > 0) {
|
|
*data++ = *fdr;
|
|
}
|
|
}
|
|
|
|
|
|
#define USB_WRITE_BLOCK 0x01
|
|
#define USB_WRITE_NOTIFY 0x02
|
|
|
|
void
|
|
write_hw_buffer(const uint8_t *data, unsigned int hw_ep, unsigned int len)
|
|
{
|
|
AT91_REG *fdr;
|
|
fdr = &AT91C_UDP_FDR[hw_ep];
|
|
/* PRINTF("Write %d\n", len); */
|
|
while(len-- > 0) {
|
|
*fdr = *data++;
|
|
}
|
|
}
|
|
|
|
static unsigned int
|
|
get_receive_capacity(USBBuffer *buffer)
|
|
{
|
|
unsigned int capacity = 0;
|
|
while(buffer && !(buffer->flags & (USB_BUFFER_IN| USB_BUFFER_SETUP))) {
|
|
capacity += buffer->left;
|
|
buffer = buffer->next;
|
|
}
|
|
return capacity;
|
|
}
|
|
|
|
static int
|
|
handle_pending_receive(USBEndpoint *ep)
|
|
{
|
|
int short_packet;
|
|
unsigned int len;
|
|
unsigned int copy;
|
|
unsigned int res = 0;
|
|
unsigned int hw_ep = EP_HW_NUM(ep->addr);
|
|
USBBuffer *buffer = ep->buffer;
|
|
uint8_t *setup_data = NULL;
|
|
unsigned int flags = ep->flags;
|
|
if (!(flags & USB_EP_FLAGS_ENABLED) || !buffer) return USB_READ_BLOCK;
|
|
len = RXBYTECNT(AT91C_UDP_CSR[hw_ep]);
|
|
PRINTF("handle_pending_receive: %d\n", len);
|
|
switch(flags & USB_EP_FLAGS_TYPE_MASK) {
|
|
case USB_EP_FLAGS_TYPE_CONTROL:
|
|
if (flags & USB_EP_FLAGS_SETUP_PENDING) {
|
|
/* Discard buffers until we find a SETUP buffer */
|
|
buffer =
|
|
skip_buffers_until(buffer, USB_BUFFER_SETUP, USB_BUFFER_SETUP, &res);
|
|
ep->buffer = buffer;
|
|
if (!buffer || buffer->left < len) {
|
|
res |= USB_READ_BLOCK;
|
|
return res;
|
|
}
|
|
/* SETUP packet must fit in a single buffer */
|
|
if (buffer->left < len) {
|
|
buffer->flags |= USB_BUFFER_FAILED;
|
|
buffer->flags &= ~USB_BUFFER_SUBMITTED ;
|
|
if (buffer->flags & USB_BUFFER_NOTIFY) res |= USB_READ_NOTIFY;
|
|
ep->buffer = buffer->next;
|
|
res |= USB_READ_FAIL;
|
|
return res;
|
|
}
|
|
setup_data = buffer->data;
|
|
} else {
|
|
if (buffer->flags & (USB_BUFFER_SETUP|USB_BUFFER_IN)) {
|
|
buffer->flags |= USB_BUFFER_FAILED;
|
|
|
|
buffer->flags &= ~USB_BUFFER_SUBMITTED ;
|
|
if (buffer->flags & USB_BUFFER_NOTIFY) res |= USB_READ_NOTIFY;
|
|
ep->buffer = buffer->next;
|
|
res |= USB_READ_FAIL;
|
|
return res;
|
|
}
|
|
|
|
if (len == 0) {
|
|
/* Status OUT */
|
|
if (buffer->left > 0) {
|
|
buffer->flags |= USB_BUFFER_FAILED;
|
|
res |= USB_READ_FAIL;
|
|
}
|
|
buffer->flags &= ~USB_BUFFER_SUBMITTED ;
|
|
if (buffer->flags & USB_BUFFER_NOTIFY) res |= USB_READ_NOTIFY;
|
|
ep->buffer = buffer->next;
|
|
return res;
|
|
}
|
|
if (get_receive_capacity(buffer) < len) return USB_READ_BLOCK;
|
|
}
|
|
break;
|
|
case USB_EP_FLAGS_TYPE_INTERRUPT:
|
|
case USB_EP_FLAGS_TYPE_BULK:
|
|
case USB_EP_FLAGS_TYPE_ISO:
|
|
if (get_receive_capacity(buffer) < len) {
|
|
return USB_READ_BLOCK;
|
|
}
|
|
break;
|
|
}
|
|
|
|
short_packet = len < ep->xfer_size;
|
|
|
|
do {
|
|
if (buffer->left < len) {
|
|
copy = buffer->left;
|
|
} else {
|
|
copy = len;
|
|
}
|
|
len -= copy;
|
|
buffer->left -= copy;
|
|
read_hw_buffer(buffer->data, hw_ep, copy);
|
|
buffer->data += copy;
|
|
|
|
if (len == 0) break;
|
|
|
|
/* Release buffer */
|
|
buffer->flags &= ~(USB_BUFFER_SUBMITTED | USB_BUFFER_SHORT_PACKET);
|
|
if (buffer->flags & USB_BUFFER_NOTIFY) res |= USB_READ_NOTIFY;
|
|
/* Use next buffer. */
|
|
buffer = buffer->next;
|
|
} while(1);
|
|
|
|
if (short_packet) {
|
|
buffer->flags |= USB_BUFFER_SHORT_PACKET;
|
|
}
|
|
|
|
if ((buffer->left == 0)
|
|
|| (buffer->flags & USB_BUFFER_PACKET_END)
|
|
|| (short_packet && (buffer->flags & USB_BUFFER_SHORT_END))) {
|
|
/* Release buffer */
|
|
buffer->flags &= ~USB_BUFFER_SUBMITTED;
|
|
if (buffer->flags & USB_BUFFER_NOTIFY) res |= USB_READ_NOTIFY;
|
|
/* Use next buffer. */
|
|
buffer = buffer->next;
|
|
}
|
|
|
|
ep->buffer = buffer;
|
|
if (setup_data) {
|
|
/* Set direction according to request */
|
|
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[0],
|
|
((setup_data[0] & 0x80)
|
|
? AT91C_UDP_DIR : 0), AT91C_UDP_DIR);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
|
|
static void
|
|
start_receive(USBEndpoint *ep)
|
|
{
|
|
ep->flags |= USB_EP_FLAGS_RECEIVING;
|
|
}
|
|
|
|
#if 0
|
|
static unsigned int
|
|
get_transmit_length(USBBuffer *buffer)
|
|
{
|
|
unsigned int length = 0;
|
|
while(buffer && (buffer->flags & USB_BUFFER_IN)) {
|
|
length += buffer->left;
|
|
buffer = buffer->next;
|
|
}
|
|
return length;
|
|
}
|
|
#endif
|
|
|
|
static int
|
|
start_transmit(USBEndpoint *ep)
|
|
{
|
|
unsigned int res = 0;
|
|
USBBuffer *buffer = ep->buffer;
|
|
unsigned int len;
|
|
unsigned int hw_ep = EP_HW_NUM(ep->addr);
|
|
unsigned int ep_flags = ep->flags;
|
|
len = ep->xfer_size;
|
|
if (!(ep_flags & USB_EP_FLAGS_ENABLED) || !buffer) return USB_WRITE_BLOCK;
|
|
switch(ep_flags & USB_EP_FLAGS_TYPE_MASK) {
|
|
case USB_EP_FLAGS_TYPE_BULK:
|
|
case USB_EP_FLAGS_TYPE_ISO:
|
|
if (!(ep->flags & USB_EP_FLAGS_TRANSMITTING)) {
|
|
if (AT91C_UDP_CSR[hw_ep] & AT91C_UDP_TXPKTRDY) return USB_WRITE_BLOCK;
|
|
}
|
|
break;
|
|
default:
|
|
if (AT91C_UDP_CSR[hw_ep] & AT91C_UDP_TXPKTRDY) return USB_WRITE_BLOCK;
|
|
}
|
|
|
|
|
|
while (buffer) {
|
|
unsigned int copy;
|
|
if (buffer->left < len) {
|
|
copy = buffer->left;
|
|
} else {
|
|
copy = len;
|
|
}
|
|
len -= copy;
|
|
buffer->left -= copy;
|
|
write_hw_buffer(buffer->data, hw_ep, copy);
|
|
buffer->data += copy;
|
|
if (buffer->left == 0) {
|
|
if (buffer->flags & USB_BUFFER_SHORT_END) {
|
|
if (len == 0) {
|
|
/* Avoid endless loop */
|
|
buffer->flags &= ~USB_BUFFER_SHORT_END;
|
|
/* Send zero length packet. */
|
|
break;
|
|
} else {
|
|
len = 0;
|
|
}
|
|
}
|
|
/* Release buffer */
|
|
buffer->flags &= ~USB_BUFFER_SUBMITTED;
|
|
if (buffer->flags & USB_BUFFER_NOTIFY) res = USB_WRITE_NOTIFY;
|
|
/* Use next buffer. */
|
|
buffer = buffer->next;
|
|
}
|
|
if (len == 0) break;
|
|
}
|
|
ep->buffer = buffer;
|
|
if (ep->flags & USB_EP_FLAGS_TRANSMITTING) {
|
|
ep->flags |= USB_EP_FLAGS_DOUBLE;
|
|
} else {
|
|
ep->flags |= USB_EP_FLAGS_TRANSMITTING;
|
|
}
|
|
|
|
PRINTF("start_transmit: sent %08x\n",AT91C_UDP_CSR[hw_ep]);
|
|
/* Start transmission */
|
|
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[hw_ep],
|
|
AT91C_UDP_TXPKTRDY, AT91C_UDP_TXPKTRDY);
|
|
|
|
return res;
|
|
}
|
|
|
|
static void
|
|
start_transfer(USBEndpoint *ep)
|
|
{
|
|
unsigned int hw_ep = EP_HW_NUM(ep->addr);
|
|
int res;
|
|
while (ep->flags & USB_EP_FLAGS_RECV_PENDING) {
|
|
res = handle_pending_receive(ep);
|
|
if (res & USB_READ_NOTIFY) {
|
|
notify_ep_process(ep, USB_EP_EVENT_NOTIFICATION);
|
|
}
|
|
PRINTF("received res = %d\n", res);
|
|
if (res & USB_READ_BLOCK) {
|
|
*AT91C_UDP_IDR = 1<<hw_ep;
|
|
return;
|
|
}
|
|
if (AT91C_UDP_CSR[hw_ep] & AT91C_UDP_RXSETUP) {
|
|
/* Acknowledge SETUP */
|
|
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[hw_ep],0, AT91C_UDP_RXSETUP);
|
|
} else if (AT91C_UDP_CSR[hw_ep] & (AT91C_UDP_RX_DATA_BK1)) {
|
|
/* Ping-pong */
|
|
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[hw_ep],0,
|
|
(ep->flags & USB_EP_FLAGS_BANK_1_RECV_NEXT)
|
|
? AT91C_UDP_RX_DATA_BK1
|
|
: AT91C_UDP_RX_DATA_BK0);
|
|
ep->flags ^= USB_EP_FLAGS_BANK_1_RECV_NEXT;
|
|
} else {
|
|
/* Ping-pong or single buffer */
|
|
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[hw_ep],0,
|
|
AT91C_UDP_RX_DATA_BK0);
|
|
ep->flags |= USB_EP_FLAGS_BANK_1_RECV_NEXT;
|
|
}
|
|
|
|
if (ep->flags & USB_EP_FLAGS_DOUBLE) {
|
|
ep->flags &= ~USB_EP_FLAGS_DOUBLE;
|
|
} else if IS_CONTROL_EP(ep) {
|
|
ep->flags &= ~(USB_EP_FLAGS_RECV_PENDING|USB_EP_FLAGS_SETUP_PENDING);
|
|
} else {
|
|
ep->flags &= ~USB_EP_FLAGS_RECV_PENDING;
|
|
}
|
|
if (res & USB_READ_FAIL) {
|
|
/* Only fails for control endpoints */
|
|
usb_arch_control_stall(ep->addr);
|
|
return;
|
|
}
|
|
*AT91C_UDP_IER = 1<<hw_ep;
|
|
}
|
|
if (ep->flags & (USB_EP_FLAGS_TRANSMITTING | USB_EP_FLAGS_RECEIVING)) {
|
|
#if 0
|
|
if (!IS_BULK_EP(ep) || (ep->flags & USB_EP_FLAGS_DOUBLE)) {
|
|
#else
|
|
if(1) {
|
|
#endif
|
|
PRINTF("Busy\n");
|
|
return;
|
|
}
|
|
}
|
|
if (ep->status & 0x01) return; /* Don't start transfer if halted */
|
|
if (ep->buffer) {
|
|
if (ep->buffer->flags & USB_BUFFER_IN) {
|
|
res = start_transmit(ep);
|
|
if (res & USB_READ_NOTIFY) {
|
|
notify_ep_process(ep, USB_EP_EVENT_NOTIFICATION);
|
|
}
|
|
} else {
|
|
start_receive(ep);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
usb_arch_transfer_complete(unsigned int hw_ep)
|
|
{
|
|
unsigned int status = AT91C_UDP_CSR[hw_ep];
|
|
USBEndpoint *ep = &usb_endpoints[hw_ep];
|
|
PRINTF("transfer_complete: %d\n", hw_ep);
|
|
if (status & AT91C_UDP_STALLSENT) {
|
|
/* Acknowledge */
|
|
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[hw_ep],0, AT91C_UDP_STALLSENT);
|
|
}
|
|
if (status & (AT91C_UDP_RXSETUP
|
|
| AT91C_UDP_RX_DATA_BK1 | AT91C_UDP_RX_DATA_BK0)) {
|
|
if (status & AT91C_UDP_RXSETUP) {
|
|
PRINTF("SETUP\n");
|
|
ep->flags |= USB_EP_FLAGS_SETUP_PENDING;
|
|
}
|
|
if (ep->flags & USB_EP_FLAGS_DOUBLE) {
|
|
ep->flags &= ~USB_EP_FLAGS_DOUBLE;
|
|
} else {
|
|
ep->flags &= ~USB_EP_FLAGS_RECEIVING;
|
|
}
|
|
if ( ep->flags & USB_EP_FLAGS_RECV_PENDING) {
|
|
ep->flags |= USB_EP_FLAGS_DOUBLE;
|
|
} else {
|
|
ep->flags |= USB_EP_FLAGS_RECV_PENDING;
|
|
}
|
|
start_transfer(ep);
|
|
}
|
|
if (status & AT91C_UDP_TXCOMP) {
|
|
PRINTF("Sent packet\n");
|
|
if (ep->flags & USB_EP_FLAGS_DOUBLE) {
|
|
ep->flags &= ~USB_EP_FLAGS_DOUBLE;
|
|
} else {
|
|
ep->flags &= ~USB_EP_FLAGS_TRANSMITTING;
|
|
}
|
|
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[hw_ep],0, AT91C_UDP_TXCOMP);
|
|
if (ep->status & 0x01) {
|
|
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[hw_ep],
|
|
AT91C_UDP_FORCESTALL, AT91C_UDP_FORCESTALL);
|
|
} else {
|
|
start_transfer(ep);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
void
|
|
usb_set_ep_event_process(unsigned char addr, struct process *p)
|
|
{
|
|
USBEndpoint *ep = &usb_endpoints[EP_INDEX(addr)];
|
|
ep->event_process = p;
|
|
}
|
|
|
|
/* Select what process should be polled when a global event occurs */
|
|
void
|
|
usb_arch_set_global_event_process(struct process *p)
|
|
{
|
|
event_process = p;
|
|
}
|
|
|
|
unsigned int
|
|
usb_arch_get_global_events(void)
|
|
{
|
|
unsigned int e;
|
|
USB_DISABLE_INT;
|
|
e = events;
|
|
events = 0;
|
|
USB_ENABLE_INT;
|
|
return e;
|
|
}
|
|
|
|
unsigned int
|
|
usb_get_ep_events(unsigned char addr)
|
|
{
|
|
unsigned int e;
|
|
unsigned int ei = EP_HW_NUM(addr);
|
|
USB_DISABLE_INT;
|
|
e = usb_endpoints[ei].events;
|
|
usb_endpoints[ei].events = 0;
|
|
USB_ENABLE_INT;
|
|
return e;
|
|
}
|
|
|
|
|
|
void
|
|
usb_submit_recv_buffer(unsigned char ep_addr, USBBuffer *buffer)
|
|
{
|
|
USBBuffer **tailp;
|
|
USBEndpoint *ep = &usb_endpoints[EP_INDEX(ep_addr)];
|
|
if (!(ep->flags & USB_EP_FLAGS_ENABLED)) return;
|
|
/* PRINTF("buffer: %p\n", ep->buffer); */
|
|
/* dbg_drain(); */
|
|
USB_DISABLE_INT;
|
|
tailp = (USBBuffer**)&ep->buffer;
|
|
while(*tailp) {
|
|
tailp = &(*tailp)->next;
|
|
}
|
|
*tailp = buffer;
|
|
while(buffer) {
|
|
buffer->flags |= USB_BUFFER_SUBMITTED;
|
|
buffer = buffer->next;
|
|
}
|
|
start_transfer(ep);
|
|
|
|
USB_ENABLE_INT;
|
|
}
|
|
|
|
void
|
|
usb_submit_xmit_buffer(unsigned char ep_addr, USBBuffer *buffer)
|
|
{
|
|
USBBuffer **tailp;
|
|
USBEndpoint *ep = &usb_endpoints[EP_INDEX(ep_addr)];
|
|
if (!(ep->flags & USB_EP_FLAGS_ENABLED)) return;
|
|
/* PRINTF("usb_submit_xmit_buffer %d\n", buffer->left); */
|
|
USB_DISABLE_INT;
|
|
tailp = (USBBuffer**)&ep->buffer;
|
|
while(*tailp) {
|
|
tailp = &(*tailp)->next;
|
|
}
|
|
*tailp = buffer;
|
|
while(buffer) {
|
|
buffer->flags |= USB_BUFFER_SUBMITTED | USB_BUFFER_IN;
|
|
buffer = buffer->next;
|
|
}
|
|
start_transfer(ep);
|
|
USB_ENABLE_INT;
|
|
}
|
|
|
|
void
|
|
usb_arch_discard_all_buffers(unsigned char ep_addr)
|
|
{
|
|
USBBuffer *buffer;
|
|
volatile USBEndpoint *ep = &usb_endpoints[EP_INDEX(ep_addr)];
|
|
USB_DISABLE_EP_INT(EP_HW_NUM(ep_addr));
|
|
buffer = ep->buffer;
|
|
ep->buffer = NULL;
|
|
|
|
USB_ENABLE_EP_INT(EP_HW_NUM(ep_addr));
|
|
while(buffer) {
|
|
buffer->flags &= ~USB_BUFFER_SUBMITTED;
|
|
buffer = buffer->next;
|
|
}
|
|
}
|
|
|
|
uint16_t
|
|
usb_arch_get_ep_status(uint8_t addr)
|
|
{
|
|
if (EP_INDEX(addr) > USB_MAX_ENDPOINTS) return 0;
|
|
return usb_endpoints[EP_INDEX(addr)].status;
|
|
}
|
|
|
|
void
|
|
usb_arch_set_configuration(uint8_t usb_configuration_value)
|
|
{
|
|
/* Nothing needs to be done */
|
|
}
|
|
|
|
void
|
|
usb_arch_control_stall(unsigned char addr)
|
|
{
|
|
if (EP_INDEX(addr) > USB_MAX_ENDPOINTS) return;
|
|
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[EP_HW_NUM(addr)],
|
|
AT91C_UDP_FORCESTALL, AT91C_UDP_FORCESTALL);
|
|
}
|
|
|
|
/* Not for control endpoints */
|
|
void
|
|
usb_arch_halt_endpoint(unsigned char ep_addr, int halt)
|
|
{
|
|
if (EP_INDEX(ep_addr) > USB_MAX_ENDPOINTS) return;
|
|
if (!usb_endpoints[EP_INDEX(ep_addr)].flags & USB_EP_FLAGS_ENABLED) return;
|
|
*AT91C_UDP_IDR = 1<<EP_HW_NUM(ep_addr);
|
|
if (halt) {
|
|
usb_endpoints[EP_INDEX(ep_addr)].status |= 0x01;
|
|
/* Delay stall if a transmission is i progress */
|
|
if (!(usb_endpoints[EP_INDEX(ep_addr)].flags & USB_EP_FLAGS_TRANSMITTING)){
|
|
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[EP_HW_NUM(ep_addr)],
|
|
AT91C_UDP_FORCESTALL, AT91C_UDP_FORCESTALL);
|
|
}
|
|
} else {
|
|
USBEndpoint *ep = &usb_endpoints[EP_INDEX(ep_addr)];
|
|
ep->status &= ~0x01;
|
|
*AT91C_UDP_IDR = 1<<EP_HW_NUM(ep_addr);
|
|
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[EP_HW_NUM(ep_addr)],
|
|
0, AT91C_UDP_FORCESTALL);
|
|
*AT91C_UDP_RSTEP = 1<<EP_HW_NUM(ep_addr);
|
|
*AT91C_UDP_RSTEP = 0;
|
|
|
|
/* Restart transmission */
|
|
start_transfer(&usb_endpoints[EP_INDEX(ep_addr)]);
|
|
}
|
|
*AT91C_UDP_IER = 1<<EP_HW_NUM(ep_addr);
|
|
}
|
|
|
|
int
|
|
usb_arch_send_pending(uint8_t ep_addr)
|
|
{
|
|
return usb_endpoints[EP_INDEX(ep_addr)].flags & USB_EP_FLAGS_TRANSMITTING;
|
|
}
|
|
|
|
void
|
|
usb_arch_set_address(unsigned char addr)
|
|
{
|
|
*AT91C_UDP_FADDR = AT91C_UDP_FEN | addr;
|
|
*AT91C_UDP_GLBSTATE |= AT91C_UDP_FADDEN;
|
|
}
|
|
|
|
void
|
|
usb_arch_reset_int()
|
|
{
|
|
usb_arch_reset();
|
|
notify_process(USB_EVENT_RESET);
|
|
}
|
|
|
|
void
|
|
usb_arch_suspend_int()
|
|
{
|
|
notify_process(USB_EVENT_SUSPEND);
|
|
}
|
|
|
|
void
|
|
usb_arch_resume_int()
|
|
{
|
|
notify_process(USB_EVENT_RESUME);
|
|
}
|
|
|