1//single ended buffer descriptor
2typedef struct __attribute__((packed)) {
3    PMAWord tx_addr;
4    PMAWord tx_count;
5    PMAWord rx_addr;
6    PMAWord rx_count;
7} USBBufferDescriptor;

 1/**
 2 * Start of the wide open free packet memory area, provided by the linker script
 3 */
 4extern PMAWord _pma_end;
 5
 6/**
 7 * Current memory break in PMA space (note that the pointer itself it is stored
 8 * in normal memory).
 9 *
10 * On usb reset all packet buffers are considered deallocated and this resets
11 * back to the _pma_end address. This is a uint16_t because all address in
12 * PMA must be 2-byte aligned if they are to be used in an endpoint buffer.
13 */
14static PMAWord *pma_break;
15
16/**
17 * Dynamically allocates a buffer from the PMA
18 * len: Buffer length in bytes
19 *
20 * Returns PMA buffer address
21 */
22static PMAWord *usb_allocate_pma_buffer(uint16_t len)
23{
24    PMAWord *buffer = pma_break;
25
26    //move the break, ensuring that the next buffer doesn't collide with this one
27    len = (len + 1) / sizeof(PMAWord); //divide len by sizeof(PMAWord), rounding up (should be optimized to a right shift)
28    pma_break += len; //mmm pointer arithmetic (pma_break is the appropriate size to advance the break correctly)
29
30    return buffer;
31}
32
33/**
34 * Called during interrupt for a usb reset
35 */
36static void usb_reset(void)
37{
38...
39    //All packet buffers are now deallocated and considered invalid. All endpoints statuses are reset.
40    memset(APPLICATION_ADDR(bt), 0, APPLICATION_SIZEOF(bt));
41    pma_break = &_pma_end;
42    if (!pma_break)
43        pma_break++; //we use the assumption that 0 = none = invalid all over
44...
45}

 1void usb_endpoint_setup(uint8_t endpoint, uint8_t address, uint16_t size, USBEndpointType type, USBTransferFlags flags)
 2{
 3    if (endpoint > 7 || type > USB_ENDPOINT_INTERRUPT)
 4        return; //protect against tomfoolery
 5
 6    endpoint_status[endpoint].size = size;
 7    endpoint_status[endpoint].flags = flags;
 8    USB_ENDPOINT_REGISTER(endpoint) = (type == USB_ENDPOINT_BULK ? USB_EP_BULK :
 9            type == USB_ENDPOINT_CONTROL ? USB_EP_CONTROL :
10            USB_EP_INTERRUPT) |
11        (address & 0xF);
12}
13
14void usb_endpoint_send(uint8_t endpoint, void *buf, uint16_t len)
15{
16...
17    uint16_t packetSize = endpoint_status[endpoint].size;
18
19    //check for PMA buffer presence, allocate if needed
20    if (!*APPLICATION_ADDR(&bt[endpoint].tx_addr))
21    {
22        *APPLICATION_ADDR(&bt[endpoint].tx_addr) = USB_LOCAL_ADDR(usb_allocate_pma_buffer(packetSize));
23    }
24...
25}
26
27...receive looks similar, but more on that later...

  1/**
  2 * Endpoint status, tracked here to enable easy sending and receiving through
  3 * USB by the application program.
  4 *
  5 * size: Endpoint packet size in PMA (buffer table contains PMA buffer addresses)
  6 * flags: Flags for this endpoint (such as class-specific disabling of ZLPs)
  7 *
  8 * tx_buf: Start of transmit buffer located in main memory
  9 * tx_pos: Current transmit position within the buffer or zero if transmission is finished
 10 * tx_len: Transmit buffer length in bytes
 11 *
 12 * rx_buf: Start of receive buffer located in main memory
 13 * rx_pos: Current receive position within the buffer
 14 * rx_len: Receive buffer length
 15 *
 16 * last_setup: Last received setup packet for this endpoint
 17 */
 18typedef struct {
 19    uint16_t size; //endpoint packet size
 20    USBTransferFlags flags; //flags for this endpoint
 21    void *tx_buf; //transmit buffer located in main memory
 22    void *tx_pos; //next transmit position in the buffer or zero if done
 23    uint16_t tx_len; //transmit buffer length
 24    void *rx_buf; //receive buffer located in main memory
 25    void *rx_pos; //next transmit position in the buffer or zero if done
 26    uint16_t rx_len; //receive buffer length
 27    USBSetupPacket last_setup; //last setup packet received by this endpoint (oh man what a waste of RAM, good thing its only 8 bytes)
 28} USBEndpointStatus;
 29
 30typedef enum { USB_TOK_ANY, USB_TOK_SETUP, USB_TOK_IN, USB_TOK_OUT, USB_TOK_RESET } USBToken;
 31
 32typedef enum { USB_RX_WORKING, USB_RX_DONE = 1 << 0, USB_RX_SETUP = 1 << 1 } USBRXStatus;
 33
 34/**
 35 * Sets the status bits to the appropriate value, preserving non-toggle fields
 36 *
 37 * endpoint: Endpoint register to modify
 38 * status: Desired value of status bits (i.e. USB_EP_TX_DIS, USB_EP_RX_STALL, etc)
 39 * tx_rx_mask: Mask indicating which bits are being modified (USB_EPTX_STAT or USB_EPRX_STAT)
 40 */
 41static inline void usb_set_endpoint_status(uint8_t endpoint, uint32_t status, uint32_t tx_rx_mask)
 42{
 43    uint32_t val = USB_ENDPOINT_REGISTER(endpoint);
 44    USB_ENDPOINT_REGISTER(endpoint) = (val ^ (status & tx_rx_mask)) & (USB_EPREG_MASK | tx_rx_mask);
 45}
 46
 47void usb_endpoint_send(uint8_t endpoint, void *buf, uint16_t len)
 48{
 49    //TODO: Race condition here since usb_endpoint_send_next_packet is called during ISRs.
 50    if (buf)
 51    {
 52        endpoint_status[endpoint].tx_buf = buf;
 53        endpoint_status[endpoint].tx_len = len;
 54        endpoint_status[endpoint].tx_pos = buf;
 55        usb_endpoint_send_next_packet(endpoint);
 56    }
 57    else
 58    {
 59        endpoint_status[endpoint].tx_pos = 0;
 60        usb_set_endpoint_status(endpoint, USB_EP_TX_DIS, USB_EPTX_STAT);
 61    }
 62}
 63
 64/**
 65 * Sends the next packet for the passed endpoint. If there is no remaining data
 66 * to send, no operation occurs.
 67 *
 68 * endpoint: Endpoint to send a packet on
 69 */
 70static void usb_endpoint_send_next_packet(uint8_t endpoint)
 71{
 72    uint16_t packetSize = endpoint_status[endpoint].size;
 73
 74    //is transmission finished (or never started)?
 75    if (!endpoint_status[endpoint].tx_pos || !packetSize)
 76        return;
 77
 78    //if we get this far, we have something to transmit, even if its nothing
 79
 80    //check for PMA buffer presence, allocate if needed
 81    if (!*APPLICATION_ADDR(&bt[endpoint].tx_addr))
 82    {
 83        *APPLICATION_ADDR(&bt[endpoint].tx_addr) = USB_LOCAL_ADDR(usb_allocate_pma_buffer(packetSize));
 84    }
 85
 86    //determine actual packet length, capped at the packet size
 87    uint16_t completedLength = endpoint_status[endpoint].tx_pos - endpoint_status[endpoint].tx_buf;
 88    uint16_t len = endpoint_status[endpoint].tx_len - completedLength;
 89    if (len > packetSize)
 90        len = packetSize;
 91
 92    //copy to PMA tx buffer
 93    uint16_t localBufAddr = *APPLICATION_ADDR(&bt[endpoint].tx_addr);
 94    usb_pma_copy_in(endpoint_status[endpoint].tx_pos, PMA_ADDR_FROM_USB_LOCAL(localBufAddr), len);
 95
 96    //set count to actual packet length
 97    *APPLICATION_ADDR(&bt[endpoint].tx_count) = len;
 98
 99    //move tx_pos
100    endpoint_status[endpoint].tx_pos += len;
101
102    //There are now three cases:
103    // 1. We still have bytes to send
104    // 2. We have sent all bytes and len == packetSize
105    // 3. We have sent all bytes and len != packetSize
106    //
107    //Case 1 obviously needs another packet. Case 2 needs a zero length packet.
108    //Case 3 should result in no further packets and the application being
109    //notified once the packet being queued here is completed.
110    //
111    //Responses:
112    // 1. We add len to tx_pos. On the next completed IN token, this function
113    //    will be called again.
114    // 2. We add len to tx_pos. On the next completed IN token, this function
115    //    will be called again. A zero length packet will then be produced.
116    //    Since len will not equal packetSize at that point, Response 3 will
117    //    happen.
118    // 3. We now set tx_pos to zero. On the next completed IN token, the
119    //    application can be notified. Further IN tokens will result in a NAK
120    //    condition which will prevent repeated notifications. Further calls to
121    //    this function will result in no operation until usb_endpoint_send is
122    //    called again.
123    //
124    //Exceptions:
125    // - Certain classes (such as HID) do not normally send ZLPs, so the
126    //   case 3 logic is supplemented by the condition that if the NOZLP
127    //   flag is set, the len == packetSize, and completedLength + len
128    //   >= tx_len.
129    //
130    if (len != packetSize ||
131            ((endpoint_status[endpoint].flags & USB_FLAGS_NOZLP) && len == packetSize && (len + completedLength >= endpoint_status[endpoint].tx_len)))
132    {
133        endpoint_status[endpoint].tx_pos = 0;
134    }
135    else
136    {
137        endpoint_status[endpoint].tx_pos += len;
138    }
139
140    //Inform the endpoint that the packet is ready.
141    usb_set_endpoint_status(endpoint, USB_EP_TX_VALID, USB_EPTX_STAT);
142}
143
144void USB_IRQHandler(void)
145{
146    volatile uint16_t stat = USB->ISTR;
147
148...
149
150    while ((stat = USB->ISTR) & USB_ISTR_CTR)
151    {
152        uint8_t endpoint = stat & USB_ISTR_EP_ID;
153        uint16_t val = USB_ENDPOINT_REGISTER(endpoint);
154
155        if (val & USB_EP_CTR_RX)
156        {
157...
158        }
159
160        if (val & USB_EP_CTR_TX)
161        {
162            usb_endpoint_send_next_packet(endpoint);
163            USB_ENDPOINT_REGISTER(endpoint) = val & USB_EPREG_MASK & ~USB_EP_CTR_TX;
164            if (!endpoint_status[endpoint].tx_pos)
165            {
166                if (endpoint)
167                {
168                    hook_usb_endpoint_sent(endpoint, endpoint_status[endpoint].tx_buf, endpoint_status[endpoint].tx_len);
169                }
170                else
171                {
172                    //endpoint 0 IN complete
173                    usb_handle_endp0(USB_TOK_IN);
174                }
175            }
176        }
177    }
178}