reduce code size, use state to replace active + pending

Author: hathach

src/portable/raspberrypi/rp2040/dcd_rp2040.c

@@ -111,7 +111,6 @@ static void hw_endpoint_open(uint8_t ep_addr, uint16_t wMaxPacketSize, uint8_t t
     // double buffered Bulk endpoint
     if (transfer_type == TUSB_XFER_BULK) {
       size *= 2u;
-
   #if CFG_TUSB_RP2_ERRATA_E15
       if (dir == TUSB_DIR_IN) {
         ep->e15_bulk_in = true;
@@ -195,7 +194,7 @@ TU_ATTR_ALWAYS_INLINE static inline void reset_ep0(void) {
   for (uint8_t dir = 0; dir < 2; dir++) {
     struct hw_endpoint *ep = hw_endpoint_get(0, dir);
     ep->next_pid = 1u;
-    if (ep->active) {
+    if (ep->state == EPSTATE_ACTIVE) {
       hw_endpoint_abort_xfer(ep); // Abort any pending transfer per USB specs
     }
   }
@@ -254,12 +253,12 @@ static void __tusb_irq_path_func(dcd_rp2040_irq)(void) {
       struct hw_endpoint *ep = hw_endpoint_get(i, TUSB_DIR_IN);
 
       // Active Bulk IN endpoint requires SOF
-      if (ep->e15_bulk_in && ep->active) {
+      if (ep->e15_bulk_in && ep->state == EPSTATE_ACTIVE) {
         keep_sof_alive = true;
         hw_endpoint_lock_update(ep, 1);
 
-        if (ep->pending) {
-          ep->pending         = 0;
+        if (ep->state == EPSTATE_PENDING) {
+          ep->state = EPSTATE_ACTIVE;
 
           io_rw_32 *buf_reg32 = get_buf_ctrl(i, TUSB_DIR_IN);
           io_rw_16 *buf_reg16 = (io_rw_16 *)buf_reg32;
@@ -501,7 +500,7 @@ bool dcd_edpt_iso_activate(uint8_t rhport, const tusb_desc_endpoint_t *ep_desc)
   struct hw_endpoint *ep    = hw_endpoint_get(epnum, dir);
   TU_ASSERT(ep->dpram_buf != NULL); // must be inited and allocated previously
 
-  if (ep->active) {
+  if (ep->state == EPSTATE_ACTIVE) {
     hw_endpoint_abort_xfer(ep); // abort any pending transfer
   }
   ep->max_packet_size = ep_desc->wMaxPacketSize;

src/portable/raspberrypi/rp2040/hcd_rp2040.c

@@ -66,6 +66,10 @@ enum {
   SIE_CTRL_SPEED_FULL       = 2,
 };
 
+enum {
+  EPX_CTRL_DEFAULT = EP_CTRL_ENABLE_BITS | EP_CTRL_INTERRUPT_PER_BUFFER | offsetof(usb_host_dpram_t, epx_data)
+};
+
 //--------------------------------------------------------------------+
 //
 //--------------------------------------------------------------------+
@@ -123,7 +127,7 @@ TU_ATTR_ALWAYS_INLINE static inline void sie_stop_xfer(void) {
   while (usb_hw->sie_ctrl & USB_SIE_CTRL_STOP_TRANS_BITS) {}
 }
 
-TU_ATTR_ALWAYS_INLINE static inline void sie_start_xfer(bool send_setup, bool is_rx, bool need_pre) {
+static void __tusb_irq_path_func(sie_start_xfer)(bool send_setup, bool is_rx, bool need_pre) {
   uint32_t sie_ctrl = usb_hw->sie_ctrl & SIE_CTRL_BASE_MASK; // preserve base bits
   if (send_setup) {
     sie_ctrl |= USB_SIE_CTRL_SEND_SETUP_BITS;
@@ -135,31 +139,16 @@ TU_ATTR_ALWAYS_INLINE static inline void sie_start_xfer(bool send_setup, bool is
   }
 
   // START_TRANS bit on SIE_CTRL has the same behavior as the AVAILABLE bit
-  // described in RP2040 Datasheet, release 2.1, section "4.1.2.5.1. Concurrent access".
+  // described in RP2040 Datasheet, release 2.1, section "4.1.2.5.1. Concurrent access".!
   // We write everything except the START_TRANS bit first, then wait some cycles.
   usb_hw->sie_ctrl = sie_ctrl;
   busy_wait_at_least_cycles(12);
   usb_hw->sie_ctrl = sie_ctrl | USB_SIE_CTRL_START_TRANS_BITS;
 }
 
-TU_ATTR_ALWAYS_INLINE static inline void epx_start_xfer(hw_endpoint_t *ep, bool is_setup) {
-  usb_hw->dev_addr_ctrl = (uint32_t)(ep->dev_addr | (tu_edpt_number(ep->ep_addr) << USB_ADDR_ENDP_ENDPOINT_LSB));
-  sie_start_xfer(is_setup, tu_edpt_dir(ep->ep_addr) == TUSB_DIR_IN, ep->need_pre);
-}
-
 // prepare epx_ctrl register for new endpoint
-TU_ATTR_ALWAYS_INLINE static inline void epx_ctrl_prepare(hw_endpoint_t *ep) {
-  // RP2040-E4: USB host writes status to the upper half of buffer control in single buffered mode.
-  // The buffer selector toggles even in single-buffered mode, so the previous transfer's status
-  // may have been written to BUF1 half, leaving BUF0 with a stale AVAILABLE bit. Clear it here.
-  #if defined(PICO_RP2040) && PICO_RP2040 == 1
-  usbh_dpram->epx_buf_ctrl = 0;
-  #endif
-
-  // ep control
-  const uint32_t ep_ctrl = EP_CTRL_ENABLE_BITS | EP_CTRL_INTERRUPT_PER_BUFFER |
-                           ((uint32_t)ep->transfer_type << EP_CTRL_BUFFER_TYPE_LSB) | hw_data_offset(ep->dpram_buf);
-  usbh_dpram->epx_ctrl = ep_ctrl;
+TU_ATTR_ALWAYS_INLINE static inline void epx_ctrl_prepare(uint8_t transfer_type) {
+  usbh_dpram->epx_ctrl = EPX_CTRL_DEFAULT | ((uint32_t)transfer_type << EP_CTRL_BUFFER_TYPE_LSB);
 }
 
 // Save buffer context for EPX preemption (called after STOP_TRANS).
@@ -196,44 +185,43 @@ static void __tusb_irq_path_func(epx_save_context)(hw_endpoint_t *ep) {
 
   usbh_dpram->epx_buf_ctrl = 0;
 
-  ep->pending = 1;
-  ep->active  = false;
+  ep->state = EPSTATE_PENDING;
 }
 
-// All non-interrupt endpoints use shared EPX.
-// Save the current EPX context, mark pending, switch to ep
+// switch epx to new endpoint and start the transfer
 static void __tusb_irq_path_func(epx_switch_ep)(hw_endpoint_t *ep) {
-  const bool is_setup = (ep->pending == 2);
+  const bool is_setup = (ep->state == EPSTATE_PENDING_SETUP);
 
-  epx         = ep; // switch pointer
-  ep->pending = 0;
-  ep->active  = true;
+  epx       = ep; // switch pointer
+  ep->state = EPSTATE_ACTIVE;
 
   if (is_setup) {
     // panic("new setup \n");
-    epx_start_xfer(ep, true);
+    usb_hw->dev_addr_ctrl = ep->dev_addr;
+    sie_start_xfer(true, false, ep->need_pre);
   } else {
-    io_rw_32 *ep_reg  = &usbh_dpram->epx_ctrl;
+    const bool is_rx   = (tu_edpt_dir(ep->ep_addr) == TUSB_DIR_IN);
+    io_rw_32  *ep_reg  = &usbh_dpram->epx_ctrl;
     io_rw_32 *buf_reg = &usbh_dpram->epx_buf_ctrl;
 
-    epx_ctrl_prepare(ep);
-    rp2usb_buffer_start(ep, ep_reg, buf_reg, tu_edpt_dir(ep->ep_addr) == TUSB_DIR_IN,
-                         ep->transfer_type == TUSB_XFER_INTERRUPT);
+    epx_ctrl_prepare(ep->transfer_type);
+    rp2usb_buffer_start(ep, ep_reg, buf_reg, is_rx, false);
 
-    epx_start_xfer(ep, false);
+    usb_hw->dev_addr_ctrl = (uint32_t)(ep->dev_addr | (tu_edpt_number(ep->ep_addr) << USB_ADDR_ENDP_ENDPOINT_LSB));
+    sie_start_xfer(is_setup, is_rx, ep->need_pre);
   }
 }
 
 // Round-robin find next pending ep after current epx
 static hw_endpoint_t *__tusb_irq_path_func(epx_next_pending)(hw_endpoint_t *cur_ep) {
   const uint cur_idx = (uint)(cur_ep - &ep_pool[0]);
   for (uint i = cur_idx + 1; i < TU_ARRAY_SIZE(ep_pool); i++) {
-    if (ep_pool[i].pending) {
+    if (ep_pool[i].state >= EPSTATE_PENDING) {
       return &ep_pool[i];
     }
   }
   for (uint i = 0; i < cur_idx; i++) {
-    if (ep_pool[i].pending) {
+    if (ep_pool[i].state >= EPSTATE_PENDING) {
       return &ep_pool[i];
     }
   }
@@ -246,7 +234,7 @@ static hw_endpoint_t *__tusb_irq_path_func(epx_next_pending)(hw_endpoint_t *cur_
 //--------------------------------------------------------------------+
 static void __tusb_irq_path_func(xfer_complete_isr)(hw_endpoint_t *ep, xfer_result_t xfer_result, bool is_more) {
   // Mark transfer as done before we tell the tinyusb stack
-  uint xferred_len = ep->xferred_len;
+  uint32_t xferred_len = ep->xferred_len;
   rp2usb_reset_transfer(ep);
   hcd_event_xfer_complete(ep->dev_addr, ep->ep_addr, xferred_len, xfer_result, true);
 
@@ -345,7 +333,7 @@ static void __tusb_irq_path_func(hcd_rp2040_irq)(void) {
 
     // Even if STOP_TRANS bit is clear, controller maybe in middle of retrying and may re-raise timeout once extra time
     // Only handle if epx is active, don't carry more epx transfer since STOP_TRANS is raced and not safe.
-    if (epx->active) {
+    if (epx->state == EPSTATE_ACTIVE) {
       xfer_complete_isr(epx, XFER_RESULT_FAILED, false);
     }
   }
@@ -392,7 +380,7 @@ static void __tusb_irq_path_func(hcd_rp2040_irq)(void) {
       usb_hw_clear->inte = USB_INTE_HOST_SOF_BITS;
       usb_hw->nak_poll   = USB_NAK_POLL_RESET;
       epx_switch_request = false;
-    } else if (epx->active) {
+    } else if (epx->state == EPSTATE_ACTIVE) {
       if (epx_switch_request) {
         // Second SOF with no transfer completion: endpoint is NAK-retrying, safe to switch.
         epx_switch_request = false;
@@ -498,7 +486,7 @@ void hcd_device_close(uint8_t rhport, uint8_t dev_addr) {
 
   // reset epx if it is currently active with unplugged device
   if (epx->max_packet_size > 0 && epx->dev_addr == dev_addr) {
-    // if (epx->active) {
+    // if (epx->state == EPSTATE_ACTIVE) {
     //   // need to abort transfer
     // }
     epx->max_packet_size = 0;
@@ -507,7 +495,7 @@ void hcd_device_close(uint8_t rhport, uint8_t dev_addr) {
   for (size_t i = 0; i < TU_ARRAY_SIZE(ep_pool); i++) {
     hw_endpoint_t *ep = &ep_pool[i];
     if (ep->dev_addr == dev_addr && ep->max_packet_size > 0) {
-      ep->pending = 0; // clear any pending transfer
+      ep->state = EPSTATE_IDLE; // clear any pending transfer
 
       if (ep->interrupt_num) {
         // disable interrupt endpoint
@@ -642,10 +630,10 @@ bool hcd_edpt_xfer(uint8_t rhport, uint8_t dev_addr, uint8_t ep_addr, uint8_t *b
 
     // If EPX is busy with another transfer, mark as pending
     rp2usb_critical_enter();
-    if (epx->active) {
+    if (epx->state == EPSTATE_ACTIVE) {
       ep->user_buf      = buffer;
       ep->remaining_len = buflen;
-      ep->pending       = 1;
+      ep->state         = EPSTATE_PENDING;
 
   #ifdef HAS_STOP_EPX_ON_NAK
       usb_hw_set->nak_poll = USB_NAK_POLL_STOP_EPX_ON_NAK_BITS;
@@ -660,9 +648,10 @@ bool hcd_edpt_xfer(uint8_t rhport, uint8_t dev_addr, uint8_t ep_addr, uint8_t *b
 
       epx = ep;
 
-      epx_ctrl_prepare(ep);
+      epx_ctrl_prepare(ep->transfer_type);
       rp2usb_xfer_start(ep, ep_reg, buf_reg, buffer, NULL, buflen); // prepare bufctrl
-      epx_start_xfer(ep, false);
+      usb_hw->dev_addr_ctrl = (uint32_t)(ep->dev_addr | (tu_edpt_number(ep->ep_addr) << USB_ADDR_ENDP_ENDPOINT_LSB));
+      sie_start_xfer(false, tu_edpt_dir(ep->ep_addr) == TUSB_DIR_IN, ep->need_pre);
     }
     rp2usb_critical_exit();
   }
@@ -688,18 +677,20 @@ bool hcd_setup_send(uint8_t rhport, uint8_t dev_addr, const uint8_t setup_packet
   ep->xferred_len   = 0;
 
   // If EPX is busy, mark as pending setup (DPRAM already has the packet)
-  if (epx->active) {
-    ep->pending = 2; // setup
+  if (epx->state == EPSTATE_ACTIVE) {
+    ep->state = EPSTATE_PENDING_SETUP;
   #ifdef HAS_STOP_EPX_ON_NAK
     usb_hw_set->nak_poll = USB_NAK_POLL_STOP_EPX_ON_NAK_BITS;
   #else
     usb_hw->nak_poll = (300 << USB_NAK_POLL_DELAY_FS_LSB) | (300 << USB_NAK_POLL_DELAY_LS_LSB);
     usb_hw_set->inte = USB_INTE_HOST_SOF_BITS;
   #endif
   } else {
-    epx        = ep;
-    ep->active = true;
-    epx_start_xfer(ep, true);
+    epx       = ep;
+    ep->state = EPSTATE_ACTIVE;
+
+    usb_hw->dev_addr_ctrl = ep->dev_addr;
+    sie_start_xfer(true, tu_edpt_dir(ep->ep_addr) == TUSB_DIR_IN, ep->need_pre);
   }
 
   rp2usb_critical_exit();

src/portable/raspberrypi/rp2040/rp2040_usb.c

@@ -101,12 +101,13 @@ void rp2usb_init(void) {
 }
 
 void __tusb_irq_path_func(rp2usb_reset_transfer)(hw_endpoint_t *ep) {
-  ep->active        = false;
-  ep->pending       = 0;
+  ep->state         = EPSTATE_IDLE;
   ep->remaining_len = 0;
   ep->xferred_len   = 0;
   ep->user_buf      = 0;
+#if CFG_TUD_EDPT_DEDICATED_HWFIFO
   ep->is_xfer_fifo  = false;
+#endif
 }
 
 void __tusb_irq_path_func(bufctrl_write32)(io_rw_32 *buf_reg, uint32_t value) {
@@ -211,16 +212,15 @@ void rp2usb_xfer_start(hw_endpoint_t *ep, io_rw_32 *ep_reg, io_rw_32 *buf_reg, u
   (void)ff;
   hw_endpoint_lock_update(ep, 1);
 
-  if (ep->active) {
-    // TODO: Is this acceptable for interrupt packets?
+  if (ep->state == EPSTATE_ACTIVE) {
     TU_LOG(1, "WARN: starting new transfer on already active ep %02X\r\n", ep->ep_addr);
     rp2usb_reset_transfer(ep);
   }
 
   // Fill in info now that we're kicking off the hw
   ep->remaining_len = total_len;
   ep->xferred_len   = 0;
-  ep->active        = true;
+  ep->state         = EPSTATE_ACTIVE;
 
   #if CFG_TUD_EDPT_DEDICATED_HWFIFO
   if (ff != NULL) {
@@ -229,59 +229,50 @@ void rp2usb_xfer_start(hw_endpoint_t *ep, io_rw_32 *ep_reg, io_rw_32 *buf_reg, u
   } else
   #endif
   {
-    ep->user_buf     = buffer;
+    ep->user_buf = buffer;
+  #if CFG_TUD_EDPT_DEDICATED_HWFIFO
     ep->is_xfer_fifo = false;
+  #endif
   }
 
   const bool is_host = rp2usb_is_host_mode();
+  const bool is_rx   = (is_host == (tu_edpt_dir(ep->ep_addr) == TUSB_DIR_IN));
 
-  if (ep->future_len > 0) {
-    // only on rx endpoint
+  #if CFG_TUD_ENABLED
+  if (!is_host && ep->future_len > 0) {
+    // Device only: previous short-packet abort saved data from the other buffer
     const uint8_t future_len = ep->future_len;
     memcpy(ep->user_buf, ep->dpram_buf + (ep->future_bufid << 6), future_len);
     ep->xferred_len += future_len;
     ep->remaining_len -= future_len;
     ep->user_buf += future_len;
-
     ep->future_len   = 0;
     ep->future_bufid = 0;
 
     if (ep->remaining_len == 0) {
-      // all data has been received, no need to start hw transfer
-      ep->active                 = false;
       const uint16_t xferred_len = ep->xferred_len;
       rp2usb_reset_transfer(ep);
-
-  #if CFG_TUH_ENABLED
-      if (is_host) {
-        hcd_event_xfer_complete(0, ep->ep_addr, xferred_len, XFER_RESULT_SUCCESS, false);
-      }
-  #endif
-  #if CFG_TUD_ENABLED
-      if (!is_host) {
-        dcd_event_xfer_complete(0, ep->ep_addr, xferred_len, XFER_RESULT_SUCCESS, false);
-      }
-  #endif
-
+      dcd_event_xfer_complete(0, ep->ep_addr, xferred_len, XFER_RESULT_SUCCESS, false);
       hw_endpoint_lock_update(ep, -1);
       return;
     }
   }
 
-  #if CFG_TUSB_RP2_ERRATA_E15
+    #if CFG_TUSB_RP2_ERRATA_E15
   if (ep->e15_bulk_in) {
     usb_hw_set->inte = USB_INTS_DEV_SOF_BITS;
 
     // skip transfer if we are in critical frame period
     if (e15_is_critical_frame_period()) {
-      ep->pending = 1;
+      ep->state = EPSTATE_PENDING;
       hw_endpoint_lock_update(ep, -1);
       return;
     }
   }
-  #endif
+    #endif // CFG_TUSB_RP2_ERRATA_E15
+  #endif   // CFG_TUD_ENABLED
+
 
-  const bool is_rx = (is_host == (tu_edpt_dir(ep->ep_addr) == TUSB_DIR_IN));
   #if CFG_TUH_ENABLED
   const bool force_single = (is_host && ep->transfer_type == TUSB_XFER_INTERRUPT);
   #else
@@ -333,7 +324,7 @@ bool __tusb_irq_path_func(rp2usb_xfer_continue)(hw_endpoint_t *ep, io_rw_32 *ep_
                                                 bool is_rx) {
   hw_endpoint_lock_update(ep, 1);
 
-  if (!ep->active) {
+  if (ep->state != EPSTATE_ACTIVE) {
     // probably land here due to short packet on rx with double buffered
     hw_endpoint_lock_update(ep, -1);
     return false;
@@ -394,12 +385,12 @@ bool __tusb_irq_path_func(rp2usb_xfer_continue)(hw_endpoint_t *ep, io_rw_32 *ep_
     if (buf_ctrl16_other & USB_BUF_CTRL_FULL) {
       // Data already sent into this buffer. Save it for the next transfer.
       // buff_status will be clear by the next run
-      if (is_host) {
-        // host put future_len pointer at end of epx_data
-      } else {
+  #if CFG_TUD_ENABLED
+      if (!is_host) {
         ep->future_len   = (uint8_t)(buf_ctrl16_other & USB_BUF_CTRL_LEN_MASK);
+        ep->future_bufid = buf_id ^ 1;
       }
-      ep->future_bufid = buf_id ^ 1;
+  #endif
     } else {
       ep->next_pid ^= 1u; // roll back pid if aborted
     }
@@ -424,8 +415,8 @@ bool __tusb_irq_path_func(rp2usb_xfer_continue)(hw_endpoint_t *ep, io_rw_32 *ep_
   #if CFG_TUSB_RP2_ERRATA_E15
     if (ep->e15_bulk_in && e15_is_critical_frame_period()) {
       // mark as pending if matches E15 condition
-      ep->pending = 1;
-    } else if (ep->e15_bulk_in && ep->pending) {
+      ep->state = EPSTATE_PENDING;
+    } else if (ep->e15_bulk_in && ep->state == EPSTATE_PENDING) {
       // if already pending, meaning the other buf completes first, don't arm buffer, let SOF handle it
       // do nothing
     } else