Merge pull request #103 from tessel/usb-daemon-close

Close and Re-open USBDaemon with USB Connection lifecycle

Author: johnnyman727

.gitignore

@@ -1,3 +1,5 @@
 build
 target
 node_modules
+spid
+usbexecd

boot.mk

@@ -11,5 +11,5 @@ $(TARGET)_SRC += \
   boot/usb.c \
   $(USB_PATH)/class/dfu/dfu.c
 
-$(TARGET)_LDSCRIPT = deps/sam0/linker_scripts/samd21/gcc/samd21g15a_flash.ld
-$(TARGET)_DEFINE += -D __SAMD21G15A__
+$(TARGET)_LDSCRIPT = deps/sam0/linker_scripts/samd21/gcc/samd21g18a_flash.ld
+$(TARGET)_DEFINE += -D __SAMD21G18A__

common/samd21g15a_firmware_partition.ld common/samd21g18a_firmware_partition.ld

@@ -49,7 +49,7 @@ SEARCH_DIR(.)
 /* Memory Spaces Definitions */
 MEMORY
 {
-  rom    (rx)  : ORIGIN = 0x00001000, LENGTH = 0x00008000
+  rom    (rx)  : ORIGIN = 0x00001000, LENGTH = 0x0003efff
   ram    (rwx) : ORIGIN = 0x20000000, LENGTH = 0x00001000
 }
 

firmware.mk

@@ -12,5 +12,5 @@ $(TARGET)_SRC += \
   firmware/usbpipe.c \
   firmware/usbserial.c \
 
-$(TARGET)_LDSCRIPT = common/samd21g15a_firmware_partition.ld
-$(TARGET)_DEFINE += -D __SAMD21G15A__
+$(TARGET)_LDSCRIPT = common/samd21g18a_firmware_partition.ld
+$(TARGET)_DEFINE += -D __SAMD21G18A__

firmware/bridge.c

@@ -111,6 +111,9 @@ void bridge_handle_sync() {
             return;
         }
 
+        // Set this flag so the LED boot sequence stops
+        booted = true;
+
         u8 desc = 0;
 
         // Create DMA chain
@@ -178,8 +181,6 @@ void bridge_dma_rx_completion() {
         #define CHECK_CLOSE(x) \
             if (!(ctrl_rx.status & (0x10<<x)) && (was_open & (0x10<<x))) { \
                 bridge_close_##x(ctrl_rx.size[x]); \
-                out_chan_ready &= ~ (1<<x); \
-                in_chan_size[x] = 0; \
             }
 
         CHECK_OPEN(0)
@@ -220,3 +221,14 @@ void bridge_start_out(u8 channel, u8* data) {
     out_chan_ready |= (1<<channel);
     pin_high(PIN_BRIDGE_IRQ);
 }
+
+void bridge_enable_chan(u8 channel) {
+    out_chan_ready |= (0x10<<channel);
+    pin_high(PIN_BRIDGE_IRQ);
+}
+
+void bridge_disable_chan(u8 channel) {
+    out_chan_ready &= ~(0x11<<channel); // Also clears the "ready to accept data" bit
+    in_chan_size[channel] = 0; // Clears any data that was waiting to be sent
+    pin_high(PIN_BRIDGE_IRQ);
+}

firmware/firmware.h

@@ -75,6 +75,8 @@ void bridge_dma_rx_completion();
 
 void bridge_start_in(u8 channel, u8* data, u8 length);
 void bridge_start_out(u8 channel, u8* data);
+void bridge_enable_chan(u8 channel);
+void bridge_disable_chan(u8 channel);
 
 void bridge_completion_in_0();
 void bridge_completion_in_1();

firmware/port.c

@@ -84,6 +84,8 @@ void port_init(PortData* p, u8 chan, const TesselPort* port,
 
     sercom_clock_enable(p->port->spi, p->clock_channel, 1);
     sercom_clock_enable(p->port->uart_i2c, p->clock_channel, 1);
+
+    bridge_enable_chan(chan);
 }
 
 void port_enable(PortData* p) {
@@ -122,11 +124,14 @@ void port_disable(PortData* p) {
     EIC->INTFLAG.reg = p->port->pin_interrupts;
 
     pin_low(p->port->power);
+
+    // After the port has been reset, re-enable it
+    bridge_enable_chan(p->chan);
 }
 
 void port_send_status(PortData* p, u8 d) {
     if (p->reply_len >= BRIDGE_BUF_SIZE) {
-        invalid();
+        bridge_disable_chan(p->chan);
         return;
     }
     p->reply_buf[p->reply_len++] = d;
@@ -219,7 +224,8 @@ Pin port_selected_pin(PortData* p) {
 
 void port_exec_async_complete(PortData* p, ExecStatus s) {
     if (p->state != PORT_EXEC_ASYNC) {
-        invalid();
+        bridge_disable_chan(p->chan);
+        return;
     }
     p->state = s;
     port_step(p);
@@ -236,7 +242,8 @@ void uart_send_data(PortData *p){
         if (count + 2 > BRIDGE_BUF_SIZE - p->reply_len) {
             // Shouldn't have to worry about insufficient buffer space because the buffer is
             // always flushed before enabling async events, but assert to be sure.
-            invalid();
+            bridge_disable_chan(p->chan);
+            return;
         }
 
         p->reply_buf[p->reply_len++] = REPLY_ASYNC_UART_RX;
@@ -409,7 +416,7 @@ ExecStatus port_begin_cmd(PortData *p) {
             pin_gpio(p->port->rx);
             return EXEC_DONE;
     }
-    invalid();
+    bridge_disable_chan(p->chan);
     return EXEC_DONE;
 }
 
@@ -523,7 +530,7 @@ inline bool port_async_events_allowed(PortData* p) {
 
 void port_step(PortData* p) {
     if (p->state == PORT_DISABLE) {
-        invalid();
+        bridge_disable_chan(p->chan);
         return;
     }
 
@@ -565,7 +572,10 @@ void port_step(PortData* p) {
                 p->state = port_begin_cmd(p);
             }
         } else if (p->state == PORT_READ_ARG) {
-            if (p->arg_len == 0) invalid();
+            if (p->arg_len == 0) {
+                bridge_disable_chan(p->chan);
+                return;
+            }
             p->arg[p->arg_pos++] = p->cmd_buf[p->cmd_pos++];
             p->arg_len--;
 
@@ -598,7 +608,8 @@ void port_dma_rx_completion(PortData* p) {
         p->state = (p->arg[0] == 0 ? EXEC_DONE : EXEC_CONTINUE);
         port_step(p);
     } else {
-        invalid();
+        bridge_disable_chan(p->chan);
+        return;
     }
 }
 
@@ -607,7 +618,8 @@ void port_dma_tx_completion(PortData* p) {
         p->state = (p->arg[0] == 0 ? EXEC_DONE : EXEC_CONTINUE);
         port_step(p);
     } else {
-        invalid();
+        bridge_disable_chan(p->chan);
+        return;
     }
 }
 
@@ -642,10 +654,12 @@ void bridge_handle_sercom_uart_i2c(PortData* p) {
             p->state = (p->arg[0] == 0 ? EXEC_DONE : EXEC_CONTINUE);
             port_step(p);
         } else {
-            invalid();
+            bridge_disable_chan(p->chan);
+            return;
         }
     } else {
-        invalid();
+        bridge_disable_chan(p->chan);
+        return;
     }
 }
 
@@ -666,7 +680,8 @@ void port_handle_extint(PortData *p, u32 flags) {
         }
         EIC->INTFLAG.reg = p->port->pin_interrupts & flags;
     } else {
-        invalid();
+        bridge_disable_chan(p->chan);
+        return;
     }
 
     port_step(p);

firmware/usbpipe.c

@@ -1,56 +1,103 @@
 #include "firmware.h"
-
-#define FLASH_BUFFER_SIZE 64
+#define OUT_RING_SIZE 10
+#define PACKET_SIZE 64
+u8 out_ring_buf[OUT_RING_SIZE][PACKET_SIZE];
+volatile u8 out_ring_count = 0; // Number of packets in the ring buffer
+volatile u8 out_ring_write_pos = 0; // Packet index in which we're currently receiving a packet, or will once it's free
+volatile u8 out_ring_read_pos = 0; // Packet index from which we're currently sending a packet, or will once it's filled.
+volatile u8 out_ring_short_packet = 0; // If nonzero, the ring ends with a short packet of this size
+volatile bool out_usb_pending = false;
+volatile bool out_bridge_pending = false;
 
 typedef enum {
     PIPE_DISABLE,
     PIPE_WAIT_FOR_USB,
     PIPE_WAIT_FOR_BRIDGE,
 } PipeState;
 
-PipeState pipe_state_pc_to_soc;
 PipeState pipe_state_soc_to_pc;
-USB_ALIGN u8 pipe_buffer_pc_to_soc[BRIDGE_BUF_SIZE];
 USB_ALIGN u8 pipe_buffer_soc_to_pc[BRIDGE_BUF_SIZE];
 
 void usbpipe_init() {
     usb_enable_ep(USB_EP_PIPE_OUT, USB_EP_TYPE_BULK, 64);
     usb_enable_ep(USB_EP_PIPE_IN, USB_EP_TYPE_BULK, 64);
 
-    usb_ep_start_out(USB_EP_PIPE_OUT, pipe_buffer_pc_to_soc, FLASH_BUFFER_SIZE);
-    pipe_state_pc_to_soc = PIPE_WAIT_FOR_USB;
+    usb_ep_start_out(USB_EP_PIPE_OUT, out_ring_buf[out_ring_write_pos], PACKET_SIZE);
+    out_usb_pending = true;
+    out_bridge_pending = false;
 
     bridge_start_out(BRIDGE_USB, pipe_buffer_soc_to_pc);
-    pipe_state_soc_to_pc  = PIPE_WAIT_FOR_BRIDGE;
+    pipe_state_soc_to_pc = PIPE_WAIT_FOR_BRIDGE;
+
+    bridge_enable_chan(BRIDGE_USB); // Tells SPI Daemon to start connection to USB Daemon
 }
 
 void usbpipe_disable() {
     usb_disable_ep(USB_EP_PIPE_IN);
     usb_disable_ep(USB_EP_PIPE_OUT);
-    pipe_state_pc_to_soc = PIPE_DISABLE;
+    out_ring_count = 0;
+    out_ring_write_pos = 0;
+    out_ring_read_pos = 0;
+    out_ring_short_packet = 0;
     pipe_state_soc_to_pc = PIPE_DISABLE;
+    bridge_disable_chan(BRIDGE_USB); // Tells SPI Daemon to close connection to USB Daemon
 }
 
-// Received from USB, send to bridge
-void pipe_usb_out_completion() {
-    if (pipe_state_pc_to_soc == PIPE_WAIT_FOR_USB) {
-        u32 len = usb_ep_out_length(USB_EP_PIPE_OUT);
-        bridge_start_in(BRIDGE_USB, pipe_buffer_pc_to_soc, len);
-        pipe_state_pc_to_soc = PIPE_WAIT_FOR_BRIDGE;
-    } else {
-        invalid();
+void out_ring_step() {
+    // If we are not currently receiving
+    // And there is an empty buffer to receive data into
+    // And there isn't an unprocessed short packet
+    if (!out_usb_pending && out_ring_count < OUT_RING_SIZE && out_ring_short_packet == 0) {
+        // Start reading data in over USB to the buffer at the correct position (up to 64 bytes)
+        usb_ep_start_out(USB_EP_PIPE_OUT, out_ring_buf[out_ring_write_pos], PACKET_SIZE);
+        // We are waiting for the transfer to complete
+        out_usb_pending = true;
+    }
+
+    // If we are not waiting on a bridge transaction to complete and we have packets to send
+    if (!out_bridge_pending && out_ring_count > 0) {
+        // The size of the packet is 64 bytes (unless the below case is true)
+        u8 len = PACKET_SIZE;
+        // If we only have one outgoing packet and it is a short packet
+        if (out_ring_count == 1 && out_ring_short_packet != 0) {
+             // The length is actually a subset of a full packet
+             len = out_ring_short_packet;
+             // Reset the short packet var
+             out_ring_short_packet = 0;
+        }
+        // Start sending data to the spi daemon
+        bridge_start_in(BRIDGE_USB, out_ring_buf[out_ring_read_pos], len);
+        // We are currently waiting on the SPI
+        out_bridge_pending = true;
     }
+}
 
+// Received from USB, send to bridge
+void pipe_usb_out_completion() {
+    // Get the length of the packet from USB
+    u32 len = usb_ep_out_length(USB_EP_PIPE_OUT);
+    // If it is less than one full packet, mark the short packet var with the length
+    if (len < PACKET_SIZE) out_ring_short_packet = len;
+    // Increase the next writable buffer by 1 (but loop to the beginning if necessary)
+    out_ring_write_pos = (out_ring_write_pos + 1) % OUT_RING_SIZE;
+    // Mark that we have one packet that needs attention
+    out_ring_count += 1;
+    // We are no longer operating over USB
+    out_usb_pending = false;
+    // Push the data to the correct place
+    out_ring_step();
 }
 
 // Finished sending on bridge, start receive from USB
 void pipe_bridge_in_completion() {
-    if (pipe_state_pc_to_soc == PIPE_WAIT_FOR_BRIDGE) {
-        usb_ep_start_out(USB_EP_PIPE_OUT, pipe_buffer_pc_to_soc, FLASH_BUFFER_SIZE);
-        pipe_state_pc_to_soc = PIPE_WAIT_FOR_USB;
-    } else {
-        invalid();
-    }
+    // Increment the location of where we will read from next (to send over USB)
+    out_ring_read_pos = (out_ring_read_pos + 1) % OUT_RING_SIZE;
+    // Decrement the number of packets that need reading
+    out_ring_count -= 1;
+    // Mark the bridge transfer as complete
+    out_bridge_pending = false;
+    // Move data along
+    out_ring_step();
 }
 
 // Received from bridge, send to USB