STM32: USB: correctly detect when read/write must be called without blocking

[bertos.git] / bertos / cpu / cortex-m3 / drv / usb_stm32.c

diff --git a/bertos/cpu/cortex-m3/drv/usb_stm32.c b/bertos/cpu/cortex-m3/drv/usb_stm32.c
index a1a50b3bea4fb094d9c69c6b78ed129c6dabf767..ac3f55fa40bc2af8ffb05a10130a43adf464647e 100644 (file)
--- a/bertos/cpu/cortex-m3/drv/usb_stm32.c
+++ b/bertos/cpu/cortex-m3/drv/usb_stm32.c
@@ -54,6 +54,8 @@
 #include <drv/timer.h>
 #include <drv/usb.h>
 
+#include <mware/event.h>
+
 #include <string.h> /* memcpy() */
 
 #include "usb_stm32.h"
@@ -115,7 +117,7 @@ static const UsbEndpointDesc USB_CtrlEpDescr1 =
 static UsbCtrlRequest setup_packet;
 
 /* USB device controller: max supported interfaces */
-#define USB_MAX_INTERFACE      1
+#define USB_MAX_INTERFACE      CONFIG_USB_INTERFACE_MAX
 
 /* USB device controller features */
 #define STM32_UDC_FEATURE_SELFPOWERED  BV(0)
@@ -148,7 +150,6 @@ static stm32_UsbMemSlot memory_buffer[EP_MAX_NUM];
 /* Endpoint TX and RX buffers */
 /// \cond
 /* XXX: use the empty cond section to silent a buggy doxygen warning */
-static bool rx_done, tx_done;
 static size_t rx_size, tx_size;
 
 #define EP_BUFFER_SIZE _MIN(CONFIG_USB_BUFSIZE, USB_XFER_MAX_SIZE)
@@ -157,6 +158,11 @@ STATIC_ASSERT(!(EP_BUFFER_SIZE & 0x03));
 static uint8_t ep_buffer[EP_MAX_NUM][EP_BUFFER_SIZE] ALIGNED(4);
 /// \endcond
 
+static Event usb_event_done[EP_MAX_SLOTS];
+
+/* Check if we're running in atomic (non-sleepable) context or not */
+static volatile bool in_atomic = false;
+
 /* Allocate a free block of the packet memory */
 static stm32_UsbMemSlot *usb_malloc(void)
 {
@@ -811,22 +817,27 @@ static int usb_ep_configure(const UsbEndpointDesc *epd, bool enable)
                switch (ep_hw->type)
                {
                case USB_ENDPOINT_XFER_CONTROL:
-                       LOG_INFO("EP%d: CONTROL IN\n", EP >> 1);
+                       LOG_INFO("EP%d: CONTROL %s\n", EP >> 1,
+                                       EP & 1 ? "IN" : "OUT");
                        ep_ctrl_set_ep_type(hw, EP_CTRL);
                        ep_ctrl_set_ep_kind(hw, 0);
                        break;
                case USB_ENDPOINT_XFER_INT:
-                       LOG_INFO("EP%d: INTERRUPT IN\n", EP >> 1);
+                       LOG_INFO("EP%d: INTERRUPT %s\n", EP >> 1,
+                                       EP & 1 ? "IN" : "OUT");
                        ep_ctrl_set_ep_type(hw, EP_INTERRUPT);
                        ep_ctrl_set_ep_kind(hw, 0);
                        break;
                case USB_ENDPOINT_XFER_BULK:
-                       LOG_INFO("EP%d: BULK IN\n", EP >> 1);
+                       LOG_INFO("EP%d: BULK %s\n", EP >> 1,
+                                       EP & 1 ? "IN" : "OUT");
                        ep_ctrl_set_ep_type(hw, EP_BULK);
                        ep_ctrl_set_ep_kind(hw, 0);
                        break;
                case USB_ENDPOINT_XFER_ISOC:
-                       LOG_ERR("EP%d: ISOCHRONOUS IN: not supported\n", EP >> 1);
+                       LOG_ERR("EP%d: ISOCHRONOUS %s: not supported\n",
+                                       EP >> 1,
+                                       EP & 1 ? "IN" : "OUT");
                        /* Fallback to default */
                default:
                        ASSERT(0);
@@ -1111,7 +1122,7 @@ static void usb_endpointRead_complete(int ep)
        }
        ASSERT(!(ep & 0x01));
 
-       rx_done = true;
+       event_do(&usb_event_done[ep >> 1]);
        rx_size = ep_cnfg[ep].size;
 }
 
@@ -1121,7 +1132,7 @@ ssize_t usb_endpointRead(int ep, void *buffer, ssize_t size)
        ssize_t max_size = sizeof(ep_buffer[ep_num]);
 
        /* Non-blocking read for EP0 */
-       if (ep_num == CTRL_ENP_OUT)
+       if (in_atomic && (ep_num == CTRL_ENP_OUT))
        {
                size = usb_size(size, usb_le16_to_cpu(setup_packet.wLength));
                if (UNLIKELY(size > max_size))
@@ -1144,14 +1155,13 @@ ssize_t usb_endpointRead(int ep, void *buffer, ssize_t size)
        if (UNLIKELY(!size))
                return 0;
        size = MIN(size, max_size);
-       rx_done = false;
+       event_initGeneric(&usb_event_done[ep_num >> 1]);
        rx_size = 0;
 
        /* Blocking read */
        __usb_ep_read(ep_num, ep_buffer[ep_num], size,
                                usb_endpointRead_complete);
-       while (!rx_done)
-               cpu_relax();
+       event_wait(&usb_event_done[ep_num >> 1]);
        memcpy(buffer, ep_buffer[ep_num], rx_size);
 
        return rx_size;
@@ -1166,7 +1176,7 @@ static void usb_endpointWrite_complete(int ep)
        }
        ASSERT(ep & 0x01);
 
-       tx_done = true;
+       event_do(&usb_event_done[ep >> 1]);
        tx_size = ep_cnfg[ep].size;
 }
 
@@ -1176,7 +1186,7 @@ ssize_t usb_endpointWrite(int ep, const void *buffer, ssize_t size)
        ssize_t max_size = sizeof(ep_buffer[ep_num]);
 
        /* Non-blocking write for EP0 */
-       if (ep_num == CTRL_ENP_IN)
+       if (in_atomic && (ep_num == CTRL_ENP_IN))
        {
                size = usb_size(size, usb_le16_to_cpu(setup_packet.wLength));
                if (UNLIKELY(size > max_size))
@@ -1199,15 +1209,14 @@ ssize_t usb_endpointWrite(int ep, const void *buffer, ssize_t size)
        if (UNLIKELY(!size))
                return 0;
        size = MIN(size, max_size);
-       tx_done = false;
+       event_initGeneric(&usb_event_done[ep_num >> 1]);
        tx_size = 0;
 
        /* Blocking write */
        memcpy(ep_buffer[ep_num], buffer, size);
        __usb_ep_write(ep_num, ep_buffer[ep_num], size,
                                usb_endpointWrite_complete);
-       while (!tx_done)
-               cpu_relax();
+       event_wait(&usb_event_done[ep_num >> 1]);
 
        return tx_size;
 }
@@ -1489,11 +1498,8 @@ static void usb_get_descriptor_handler(void)
        if ((setup_packet.mRequestType & USB_RECIP_MASK) ==
                        USB_RECIP_DEVICE)
                usb_get_descriptor();
-       /* Getting descriptor for a device is a standard request */
-       else if ((setup_packet.mRequestType & USB_DIR_MASK) == USB_DIR_IN)
-               usb_event_handler(usb_dev);
        else
-               ep_cnfg[CTRL_ENP_OUT].status = STALLED;
+               usb_event_handler(usb_dev);
 }
 
 /* USB setup packet: SET_ADDRESS handler */
@@ -1579,6 +1585,7 @@ static int usb_set_config_state(uint32_t conf)
                        udc.alt[i] = 0;
                usb_set_device_state(USB_STATE_CONFIGURED);
                usb_dev->configured = true;
+               event_do(&usb_event_done[0]);
                LOG_INFO("%s: device configured\n", __func__);
        }
        else
@@ -1802,6 +1809,9 @@ static void usb_isr(void)
        interrupt.status = usb->ISTR;
        interrupt.status &= usb->CNTR | 0x1f;
 
+       /* Set the context as atomic */
+       in_atomic = true;
+
        if (interrupt.PMAOVR)
        {
                LOG_WARN("%s: DMA overrun / underrun\n", __func__);
@@ -1851,6 +1861,7 @@ static void usb_isr(void)
        {
                usb_isr_correct_transfer(interrupt);
        }
+       in_atomic = false;
 }
 
 /* USB: hardware initialization */
@@ -1915,8 +1926,11 @@ int usb_deviceRegister(UsbDevice *dev)
        MOD_CHECK(proc);
 #endif
        usb_dev = dev;
+       usb_dev->configured = false;
+
+       event_initGeneric(&usb_event_done[0]);
        usb_init();
-       while (!usb_dev->configured)
-               cpu_relax();
+       event_wait(&usb_event_done[0]);
+
        return 0;
 }