andy/tinyUSB
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Merge pull request #1765 from hathach/rp2040-host-bulk-comment

Browse Source 
Rp2040 host bulk comment
This commit is contained in:
Ha Thach
2022-12-01 10:10:40 +07:00
committed by GitHub
parent 2ae6a4d519 c9c7dfa868
commit f24f47d038
3 changed files with 351 additions and 328 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
src/portable/raspberrypi/rp2040/hcd_rp2040.c
View File

@@ -84,7 +84,7 @@ TU_ATTR_ALWAYS_INLINE static inline uint8_t dev_speed(void)
return (usb_hw->sie_status & USB_SIE_STATUS_SPEED_BITS) >> USB_SIE_STATUS_SPEED_LSB; return (usb_hw->sie_status & USB_SIE_STATUS_SPEED_BITS) >> USB_SIE_STATUS_SPEED_LSB;
} }
static bool need_pre(uint8_t dev_addr) TU_ATTR_ALWAYS_INLINE static inline bool need_pre(uint8_t dev_addr)
{ {
// If this device is different to the speed of the root device // If this device is different to the speed of the root device
// (i.e. is a low speed device on a full speed hub) then need pre // (i.e. is a low speed device on a full speed hub) then need pre
@@ -107,7 +107,7 @@ static void __tusb_irq_path_func(_handle_buff_status_bit)(uint bit, struct hw_en
// EP may have been stalled? // EP may have been stalled?
assert(ep->active); assert(ep->active);
bool done = hw_endpoint_xfer_continue(ep); bool done = hw_endpoint_xfer_continue(ep);
if (done) if ( done )
{ {
hw_xfer_complete(ep, XFER_RESULT_SUCCESS); hw_xfer_complete(ep, XFER_RESULT_SUCCESS);
} }
@@ -120,16 +120,17 @@ static void __tusb_irq_path_func(hw_handle_buff_status)(void)
// Check EPX first // Check EPX first
uint bit = 0b1; uint bit = 0b1;
if (remaining_buffers & bit) if ( remaining_buffers & bit )
{ {
remaining_buffers &= ~bit; remaining_buffers &= ~bit;
struct hw_endpoint *ep = &epx; struct hw_endpoint * ep = &epx;
uint32_t ep_ctrl = *ep->endpoint_control; uint32_t ep_ctrl = *ep->endpoint_control;
if (ep_ctrl & EP_CTRL_DOUBLE_BUFFERED_BITS) if ( ep_ctrl & EP_CTRL_DOUBLE_BUFFERED_BITS )
{ {
TU_LOG(3, "Double Buffered: "); TU_LOG(3, "Double Buffered: ");
}else }
else
{ {
TU_LOG(3, "Single Buffered: "); TU_LOG(3, "Single Buffered: ");
} }
@@ -139,7 +140,7 @@ static void __tusb_irq_path_func(hw_handle_buff_status)(void)
} }
// Check "interrupt" (asynchronous) endpoints for both IN and OUT // Check "interrupt" (asynchronous) endpoints for both IN and OUT
for (uint i = 1; i <= USB_HOST_INTERRUPT_ENDPOINTS && remaining_buffers; i++) for ( uint i = 1; i <= USB_HOST_INTERRUPT_ENDPOINTS && remaining_buffers; i++ )
{ {
// EPX is bit 0 & 1 // EPX is bit 0 & 1
// IEP1 IN is bit 2 // IEP1 IN is bit 2
@@ -149,10 +150,10 @@ static void __tusb_irq_path_func(hw_handle_buff_status)(void)
// IEP3 IN is bit 6 // IEP3 IN is bit 6
// IEP3 OUT is bit 7 // IEP3 OUT is bit 7
// etc // etc
for(uint j = 0; j < 2; j++) for ( uint j = 0; j < 2; j++ )
{ {
bit = 1 << (i*2+j); bit = 1 << (i * 2 + j);
if (remaining_buffers & bit) if ( remaining_buffers & bit )
{ {
remaining_buffers &= ~bit; remaining_buffers &= ~bit;
_handle_buff_status_bit(bit, &ep_pool[i]); _handle_buff_status_bit(bit, &ep_pool[i]);
@@ -160,7 +161,7 @@ static void __tusb_irq_path_func(hw_handle_buff_status)(void)
} }
} }
if (remaining_buffers) if ( remaining_buffers )
{ {
panic("Unhandled buffer %d\n", remaining_buffers); panic("Unhandled buffer %d\n", remaining_buffers);
} }
@@ -189,11 +190,11 @@ static void __tusb_irq_path_func(hcd_rp2040_irq)(void)
uint32_t status = usb_hw->ints; uint32_t status = usb_hw->ints;
uint32_t handled = 0; uint32_t handled = 0;
if (status & USB_INTS_HOST_CONN_DIS_BITS) if ( status & USB_INTS_HOST_CONN_DIS_BITS )
{ {
handled |= USB_INTS_HOST_CONN_DIS_BITS; handled |= USB_INTS_HOST_CONN_DIS_BITS;
if (dev_speed()) if ( dev_speed() )
{ {
hcd_event_device_attach(RHPORT_NATIVE, true); hcd_event_device_attach(RHPORT_NATIVE, true);
} }
@@ -206,7 +207,7 @@ static void __tusb_irq_path_func(hcd_rp2040_irq)(void)
usb_hw_clear->sie_status = USB_SIE_STATUS_SPEED_BITS; usb_hw_clear->sie_status = USB_SIE_STATUS_SPEED_BITS;
} }
if (status & USB_INTS_STALL_BITS) if ( status & USB_INTS_STALL_BITS )
{ {
// We have rx'd a stall from the device // We have rx'd a stall from the device
// NOTE THIS SHOULD HAVE PRIORITY OVER BUFF_STATUS // NOTE THIS SHOULD HAVE PRIORITY OVER BUFF_STATUS
@@ -218,14 +219,14 @@ static void __tusb_irq_path_func(hcd_rp2040_irq)(void)
hw_xfer_complete(&epx, XFER_RESULT_STALLED); hw_xfer_complete(&epx, XFER_RESULT_STALLED);
} }
if (status & USB_INTS_BUFF_STATUS_BITS) if ( status & USB_INTS_BUFF_STATUS_BITS )
{ {
handled |= USB_INTS_BUFF_STATUS_BITS; handled |= USB_INTS_BUFF_STATUS_BITS;
TU_LOG(2, "Buffer complete\n"); TU_LOG(2, "Buffer complete\n");
hw_handle_buff_status(); hw_handle_buff_status();
} }
if (status & USB_INTS_TRANS_COMPLETE_BITS) if ( status & USB_INTS_TRANS_COMPLETE_BITS )
{ {
handled |= USB_INTS_TRANS_COMPLETE_BITS; handled |= USB_INTS_TRANS_COMPLETE_BITS;
usb_hw_clear->sie_status = USB_SIE_STATUS_TRANS_COMPLETE_BITS; usb_hw_clear->sie_status = USB_SIE_STATUS_TRANS_COMPLETE_BITS;
@@ -233,20 +234,22 @@ static void __tusb_irq_path_func(hcd_rp2040_irq)(void)
hw_trans_complete(); hw_trans_complete();
} }
if (status & USB_INTS_ERROR_RX_TIMEOUT_BITS) if ( status & USB_INTS_ERROR_RX_TIMEOUT_BITS )
{ {
handled |= USB_INTS_ERROR_RX_TIMEOUT_BITS; handled |= USB_INTS_ERROR_RX_TIMEOUT_BITS;
usb_hw_clear->sie_status = USB_SIE_STATUS_RX_TIMEOUT_BITS; usb_hw_clear->sie_status = USB_SIE_STATUS_RX_TIMEOUT_BITS;
} }
if (status & USB_INTS_ERROR_DATA_SEQ_BITS) if ( status & USB_INTS_ERROR_DATA_SEQ_BITS )
{ {
usb_hw_clear->sie_status = USB_SIE_STATUS_DATA_SEQ_ERROR_BITS; usb_hw_clear->sie_status = USB_SIE_STATUS_DATA_SEQ_ERROR_BITS;
TU_LOG(3, " Seq Error: [0] = 0x%04u [1] = 0x%04x\r\n", tu_u32_low16(*epx.buffer_control), tu_u32_high16(*epx.buffer_control)); TU_LOG(3, " Seq Error: [0] = 0x%04u [1] = 0x%04x\r\n",
tu_u32_low16(*epx.buffer_control),
tu_u32_high16(*epx.buffer_control));
panic("Data Seq Error \n"); panic("Data Seq Error \n");
} }
if (status ^ handled) if ( status ^ handled )
{ {
panic("Unhandled IRQ 0x%x\n", (uint) (status ^ handled)); panic("Unhandled IRQ 0x%x\n", (uint) (status ^ handled));
} }
@@ -260,11 +263,11 @@ void __tusb_irq_path_func(hcd_int_handler)(uint8_t rhport)
static struct hw_endpoint *_next_free_interrupt_ep(void) static struct hw_endpoint *_next_free_interrupt_ep(void)
{ {
struct hw_endpoint *ep = NULL; struct hw_endpoint * ep = NULL;
for (uint i = 1; i < TU_ARRAY_SIZE(ep_pool); i++) for ( uint i = 1; i < TU_ARRAY_SIZE(ep_pool); i++ )
{ {
ep = &ep_pool[i]; ep = &ep_pool[i];
if (!ep->configured) if ( !ep->configured )
{ {
// Will be configured by _hw_endpoint_init / _hw_endpoint_allocate // Will be configured by _hw_endpoint_init / _hw_endpoint_allocate
ep->interrupt_num = (uint8_t) (i - 1); ep->interrupt_num = (uint8_t) (i - 1);
@@ -276,9 +279,9 @@ static struct hw_endpoint *_next_free_interrupt_ep(void)
static struct hw_endpoint *_hw_endpoint_allocate(uint8_t transfer_type) static struct hw_endpoint *_hw_endpoint_allocate(uint8_t transfer_type)
{ {
struct hw_endpoint *ep = NULL; struct hw_endpoint * ep = NULL;
if (transfer_type != TUSB_XFER_CONTROL) if ( transfer_type != TUSB_XFER_CONTROL )
{ {
// Note: even though datasheet name these "Interrupt" endpoints. These are actually // Note: even though datasheet name these "Interrupt" endpoints. These are actually
// "Asynchronous" endpoints and can be used for other type such as: Bulk (ISO need confirmation) // "Asynchronous" endpoints and can be used for other type such as: Bulk (ISO need confirmation)
@@ -325,8 +328,10 @@ static void _hw_endpoint_init(struct hw_endpoint *ep, uint8_t dev_addr, uint8_t
ep->wMaxPacketSize = wMaxPacketSize; ep->wMaxPacketSize = wMaxPacketSize;
ep->transfer_type = transfer_type; ep->transfer_type = transfer_type;
pico_trace("hw_endpoint_init dev %d ep %d %s xfer %d\n", ep->dev_addr, tu_edpt_number(ep->ep_addr), ep_dir_string[tu_edpt_dir(ep->ep_addr)], ep->transfer_type); pico_trace("hw_endpoint_init dev %d ep %d %s xfer %d\n", ep->dev_addr, tu_edpt_number(ep->ep_addr),
pico_trace("dev %d ep %d %s setup buffer @ 0x%p\n", ep->dev_addr, tu_edpt_number(ep->ep_addr), ep_dir_string[tu_edpt_dir(ep->ep_addr)], ep->hw_data_buf); ep_dir_string[tu_edpt_dir(ep->ep_addr)], ep->transfer_type);
pico_trace("dev %d ep %d %s setup buffer @ 0x%p\n", ep->dev_addr, tu_edpt_number(ep->ep_addr),
ep_dir_string[tu_edpt_dir(ep->ep_addr)], ep->hw_data_buf);
uint dpram_offset = hw_data_offset(ep->hw_data_buf); uint dpram_offset = hw_data_offset(ep->hw_data_buf);
// Bits 0-5 should be 0 // Bits 0-5 should be 0
assert(!(dpram_offset & 0b111111)); assert(!(dpram_offset & 0b111111));
@@ -336,7 +341,7 @@ static void _hw_endpoint_init(struct hw_endpoint *ep, uint8_t dev_addr, uint8_t
| EP_CTRL_INTERRUPT_PER_BUFFER | EP_CTRL_INTERRUPT_PER_BUFFER
| (ep->transfer_type << EP_CTRL_BUFFER_TYPE_LSB) | (ep->transfer_type << EP_CTRL_BUFFER_TYPE_LSB)
| dpram_offset; | dpram_offset;
if (bmInterval) if ( bmInterval )
{ {
ep_reg |= (uint32_t) ((bmInterval - 1) << EP_CTRL_HOST_INTERRUPT_INTERVAL_LSB); ep_reg |= (uint32_t) ((bmInterval - 1) << EP_CTRL_HOST_INTERRUPT_INTERVAL_LSB);
} }
@@ -344,7 +349,7 @@ static void _hw_endpoint_init(struct hw_endpoint *ep, uint8_t dev_addr, uint8_t
pico_trace("endpoint control (0x%p) <- 0x%x\n", ep->endpoint_control, ep_reg); pico_trace("endpoint control (0x%p) <- 0x%x\n", ep->endpoint_control, ep_reg);
ep->configured = true; ep->configured = true;
if (ep != &epx) if ( ep != &epx )
{ {
// Endpoint has its own addr_endp and interrupt bits to be setup! // Endpoint has its own addr_endp and interrupt bits to be setup!
// This is an interrupt/async endpoint. so need to set up ADDR_ENDP register with: // This is an interrupt/async endpoint. so need to set up ADDR_ENDP register with:
@@ -353,12 +358,12 @@ static void _hw_endpoint_init(struct hw_endpoint *ep, uint8_t dev_addr, uint8_t
// - preamble // - preamble
uint32_t reg = (uint32_t) (dev_addr | (num << USB_ADDR_ENDP1_ENDPOINT_LSB)); uint32_t reg = (uint32_t) (dev_addr | (num << USB_ADDR_ENDP1_ENDPOINT_LSB));
if (dir == TUSB_DIR_OUT) if ( dir == TUSB_DIR_OUT )
{ {
reg |= USB_ADDR_ENDP1_INTEP_DIR_BITS; reg |= USB_ADDR_ENDP1_INTEP_DIR_BITS;
} }
if (need_pre(dev_addr)) if ( need_pre(dev_addr) )
{ {
reg |= USB_ADDR_ENDP1_INTEP_PREAMBLE_BITS; reg |= USB_ADDR_ENDP1_INTEP_PREAMBLE_BITS;
} }
@@ -434,8 +439,9 @@ tusb_speed_t hcd_port_speed_get(uint8_t rhport)
{ {
(void) rhport; (void) rhport;
assert(rhport == 0); assert(rhport == 0);
// TODO: Should enumval this register // TODO: Should enumval this register
switch (dev_speed()) switch ( dev_speed() )
{ {
case 1: case 1:
return TUSB_SPEED_LOW; return TUSB_SPEED_LOW;
@@ -548,7 +554,8 @@ bool hcd_edpt_xfer(uint8_t rhport, uint8_t dev_addr, uint8_t ep_addr, uint8_t *
// If a normal transfer (non-interrupt) then initiate using // If a normal transfer (non-interrupt) then initiate using
// sie ctrl registers. Otherwise interrupt ep registers should // sie ctrl registers. Otherwise interrupt ep registers should
// already be configured // already be configured
if (ep == &epx) { if ( ep == &epx )
{
hw_endpoint_xfer_start(ep, buffer, buflen); hw_endpoint_xfer_start(ep, buffer, buflen);
// That has set up buffer control, endpoint control etc // That has set up buffer control, endpoint control etc
@@ -556,10 +563,8 @@ bool hcd_edpt_xfer(uint8_t rhport, uint8_t dev_addr, uint8_t ep_addr, uint8_t *
usb_hw->dev_addr_ctrl = (uint32_t) (dev_addr | (ep_num << USB_ADDR_ENDP_ENDPOINT_LSB)); usb_hw->dev_addr_ctrl = (uint32_t) (dev_addr | (ep_num << USB_ADDR_ENDP_ENDPOINT_LSB));
uint32_t flags = USB_SIE_CTRL_START_TRANS_BITS | SIE_CTRL_BASE | uint32_t flags = USB_SIE_CTRL_START_TRANS_BITS | SIE_CTRL_BASE |
(ep_dir ? USB_SIE_CTRL_RECEIVE_DATA_BITS : USB_SIE_CTRL_SEND_DATA_BITS); (ep_dir ? USB_SIE_CTRL_RECEIVE_DATA_BITS : USB_SIE_CTRL_SEND_DATA_BITS) |
// Set pre if we are a low speed device on full speed hub (need_pre(dev_addr) ? USB_SIE_CTRL_PREAMBLE_EN_BITS : 0);
flags |= need_pre(dev_addr) ? USB_SIE_CTRL_PREAMBLE_EN_BITS : 0;
usb_hw->sie_ctrl = flags; usb_hw->sie_ctrl = flags;
}else }else
{ {
@@ -574,13 +579,13 @@ bool hcd_setup_send(uint8_t rhport, uint8_t dev_addr, uint8_t const setup_packet
(void) rhport; (void) rhport;
// Copy data into setup packet buffer // Copy data into setup packet buffer
for(uint8_t i=0; i<8; i++) for ( uint8_t i = 0; i < 8; i++ )
{ {
usbh_dpram->setup_packet[i] = setup_packet[i]; usbh_dpram->setup_packet[i] = setup_packet[i];
} }
// Configure EP0 struct with setup info for the trans complete // Configure EP0 struct with setup info for the trans complete
struct hw_endpoint *ep = _hw_endpoint_allocate(0); struct hw_endpoint * ep = _hw_endpoint_allocate(0);
TU_ASSERT(ep); TU_ASSERT(ep);
// EPX should be inactive // EPX should be inactive

32
src/portable/raspberrypi/rp2040/rp2040_usb.c
View File

@@ -47,6 +47,12 @@ TU_ATTR_ALWAYS_INLINE static inline void _hw_endpoint_lock_update(__unused struc
static void _hw_endpoint_xfer_sync(struct hw_endpoint *ep); static void _hw_endpoint_xfer_sync(struct hw_endpoint *ep);
static void _hw_endpoint_start_next_buffer(struct hw_endpoint *ep); static void _hw_endpoint_start_next_buffer(struct hw_endpoint *ep);
// if usb hardware is in host mode
TU_ATTR_ALWAYS_INLINE static inline bool is_host_mode(void)
{
return (usb_hw->main_ctrl & USB_MAIN_CTRL_HOST_NDEVICE_BITS) ? true : false;
}
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// //
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
@@ -69,6 +75,8 @@ void rp2040_usb_init(void)
// Mux the controller to the onboard usb phy // Mux the controller to the onboard usb phy
usb_hw->muxing = USB_USB_MUXING_TO_PHY_BITS | USB_USB_MUXING_SOFTCON_BITS; usb_hw->muxing = USB_USB_MUXING_TO_PHY_BITS | USB_USB_MUXING_SOFTCON_BITS;
TU_LOG2_INT(sizeof(hw_endpoint_t));
} }
void __tusb_irq_path_func(hw_endpoint_reset_transfer)(struct hw_endpoint *ep) void __tusb_irq_path_func(hw_endpoint_reset_transfer)(struct hw_endpoint *ep)
@@ -81,13 +89,17 @@ void __tusb_irq_path_func(hw_endpoint_reset_transfer)(struct hw_endpoint *ep)
void __tusb_irq_path_func(_hw_endpoint_buffer_control_update32)(struct hw_endpoint *ep, uint32_t and_mask, uint32_t or_mask) { void __tusb_irq_path_func(_hw_endpoint_buffer_control_update32)(struct hw_endpoint *ep, uint32_t and_mask, uint32_t or_mask) {
uint32_t value = 0; uint32_t value = 0;
if (and_mask) { if ( and_mask )
{
value = *ep->buffer_control & and_mask; value = *ep->buffer_control & and_mask;
} }
if (or_mask) { if ( or_mask )
{
value |= or_mask; value |= or_mask;
if (or_mask & USB_BUF_CTRL_AVAIL) { if ( or_mask & USB_BUF_CTRL_AVAIL )
if (*ep->buffer_control & USB_BUF_CTRL_AVAIL) { {
if ( *ep->buffer_control & USB_BUF_CTRL_AVAIL )
{
panic("ep %d %s was already available", tu_edpt_number(ep->ep_addr), ep_dir_string[tu_edpt_dir(ep->ep_addr)]); panic("ep %d %s was already available", tu_edpt_number(ep->ep_addr), ep_dir_string[tu_edpt_dir(ep->ep_addr)]);
} }
*ep->buffer_control = value & ~USB_BUF_CTRL_AVAIL; *ep->buffer_control = value & ~USB_BUF_CTRL_AVAIL;
@@ -152,12 +164,14 @@ static void __tusb_irq_path_func(_hw_endpoint_start_next_buffer)(struct hw_endpo
// always compute and start with buffer 0 // always compute and start with buffer 0
uint32_t buf_ctrl = prepare_ep_buffer(ep, 0) | USB_BUF_CTRL_SEL; uint32_t buf_ctrl = prepare_ep_buffer(ep, 0) | USB_BUF_CTRL_SEL;
// For now: skip double buffered for Device mode, OUT endpoint since // For now: skip double buffered for OUT endpoint in Device mode, since
// host could send < 64 bytes and cause short packet on buffer0 // host could send < 64 bytes and cause short packet on buffer0
// NOTE this could happen to Host mode IN endpoint // NOTE: this could happen to Host mode IN endpoint
// Also, Host mode interrupt endpoint hardware is only single buffered // Also, Host mode "interrupt" endpoint hardware is only single buffered,
bool const force_single = (!(usb_hw->main_ctrl & USB_MAIN_CTRL_HOST_NDEVICE_BITS) && !tu_edpt_dir(ep->ep_addr)) || // NOTE2: Currently Host bulk is implemented using "interrupt" endpoint
((usb_hw->main_ctrl & USB_MAIN_CTRL_HOST_NDEVICE_BITS) && tu_edpt_number(ep->ep_addr) != 0); bool const is_host = is_host_mode();
bool const force_single = (!is_host && !tu_edpt_dir(ep->ep_addr)) ||
(is_host && tu_edpt_number(ep->ep_addr) != 0);
if(ep->remaining_len && !force_single) if(ep->remaining_len && !force_single)
{ {

16
src/portable/raspberrypi/rp2040/rp2040_usb.h
View File

@@ -82,26 +82,30 @@ void hw_endpoint_reset_transfer(struct hw_endpoint *ep);
void _hw_endpoint_buffer_control_update32(struct hw_endpoint *ep, uint32_t and_mask, uint32_t or_mask); void _hw_endpoint_buffer_control_update32(struct hw_endpoint *ep, uint32_t and_mask, uint32_t or_mask);
TU_ATTR_ALWAYS_INLINE static inline uint32_t _hw_endpoint_buffer_control_get_value32(struct hw_endpoint *ep) { TU_ATTR_ALWAYS_INLINE static inline uint32_t _hw_endpoint_buffer_control_get_value32 (struct hw_endpoint *ep)
{
return *ep->buffer_control; return *ep->buffer_control;
} }
TU_ATTR_ALWAYS_INLINE static inline void _hw_endpoint_buffer_control_set_value32(struct hw_endpoint *ep, uint32_t value) { TU_ATTR_ALWAYS_INLINE static inline void _hw_endpoint_buffer_control_set_value32 (struct hw_endpoint *ep, uint32_t value)
{
return _hw_endpoint_buffer_control_update32(ep, 0, value); return _hw_endpoint_buffer_control_update32(ep, 0, value);
} }
TU_ATTR_ALWAYS_INLINE static inline void _hw_endpoint_buffer_control_set_mask32(struct hw_endpoint *ep, uint32_t value) { TU_ATTR_ALWAYS_INLINE static inline void _hw_endpoint_buffer_control_set_mask32 (struct hw_endpoint *ep, uint32_t value)
{
return _hw_endpoint_buffer_control_update32(ep, ~value, value); return _hw_endpoint_buffer_control_update32(ep, ~value, value);
} }
TU_ATTR_ALWAYS_INLINE static inline void _hw_endpoint_buffer_control_clear_mask32(struct hw_endpoint *ep, uint32_t value) { TU_ATTR_ALWAYS_INLINE static inline void _hw_endpoint_buffer_control_clear_mask32 (struct hw_endpoint *ep, uint32_t value)
{
return _hw_endpoint_buffer_control_update32(ep, ~value, 0); return _hw_endpoint_buffer_control_update32(ep, ~value, 0);
} }
static inline uintptr_t hw_data_offset(uint8_t *buf) static inline uintptr_t hw_data_offset (uint8_t *buf)
{ {
// Remove usb base from buffer pointer // Remove usb base from buffer pointer
return (uintptr_t)buf ^ (uintptr_t)usb_dpram; return (uintptr_t) buf ^ (uintptr_t) usb_dpram;
} }
extern const char *ep_dir_string[]; extern const char *ep_dir_string[];