summaryrefslogtreecommitdiff
path: root/src/tusb.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/tusb.c')
-rw-r--r--src/tusb.c327
1 files changed, 145 insertions, 182 deletions
diff --git a/src/tusb.c b/src/tusb.c
index 083e6d861..634cbc10b 100644
--- a/src/tusb.c
+++ b/src/tusb.c
@@ -39,23 +39,38 @@
#include "host/usbh_pvt.h"
#endif
+// Suppress IAR warning
+// Warning[Pe111]: statement is unreachable
+#if defined(__ICCARM__)
+#pragma diag_suppress = Pe111
+#endif
+
tusb_role_t _tusb_rhport_role[TUP_USBIP_CONTROLLER_NUM] = { TUSB_ROLE_INVALID };
//--------------------------------------------------------------------
// Weak/Default API, can be overwritten by Application
//--------------------------------------------------------------------
-TU_ATTR_WEAK void tusb_time_delay_ms_api(uint32_t ms) {
#if CFG_TUSB_OS != OPT_OS_NONE
+TU_ATTR_WEAK uint32_t tusb_time_millis_api(void) {
+ return osal_time_millis();
+}
+
+TU_ATTR_WEAK void tusb_time_delay_ms_api(uint32_t ms) {
osal_task_delay(ms);
+}
+
#else
- // delay using millis() (if implemented) and/or frame number if possible
+// tusb_time_millis_api() must be implemented by user application.
+
+TU_ATTR_WEAK void tusb_time_delay_ms_api(uint32_t ms) {
+ // delay using millis()
const uint32_t time_ms = tusb_time_millis_api();
while ((tusb_time_millis_api() - time_ms) < ms) {}
-#endif
}
+#endif
-TU_ATTR_WEAK void* tusb_app_virt_to_phys(void *virt_addr) {
+TU_ATTR_WEAK void *tusb_app_virt_to_phys(void *virt_addr) {
return virt_addr;
}
@@ -117,11 +132,15 @@ bool tusb_inited(void) {
bool ret = false;
#if CFG_TUD_ENABLED
- ret = ret || tud_inited();
+ if (tud_inited()) {
+ ret = true;
+ }
#endif
#if CFG_TUH_ENABLED
- ret = ret || tuh_inited();
+ if (tuh_inited()) {
+ ret = true;
+ }
#endif
return ret;
@@ -205,44 +224,46 @@ uint8_t const* tu_desc_find3(uint8_t const* desc, uint8_t const* end, uint8_t by
// Endpoint Helper for both Host and Device stack
//--------------------------------------------------------------------+
-bool tu_edpt_claim(tu_edpt_state_t* ep_state, osal_mutex_t mutex) {
+bool tu_edpt_claim(volatile uint8_t* ep_state, osal_mutex_t mutex) {
(void) mutex;
// pre-check to help reducing mutex lock
- TU_VERIFY((ep_state->busy == 0) && (ep_state->claimed == 0));
+ TU_VERIFY((*ep_state & (TU_EDPT_STATE_BUSY | TU_EDPT_STATE_CLAIMED)) == 0);
(void) osal_mutex_lock(mutex, OSAL_TIMEOUT_WAIT_FOREVER);
// can only claim the endpoint if it is not busy and not claimed yet.
- bool const available = (ep_state->busy == 0) && (ep_state->claimed == 0);
+ bool const available = (*ep_state & (TU_EDPT_STATE_BUSY | TU_EDPT_STATE_CLAIMED)) == 0;
if (available) {
- ep_state->claimed = 1;
+ *ep_state |= TU_EDPT_STATE_CLAIMED;
}
(void) osal_mutex_unlock(mutex);
return available;
}
-bool tu_edpt_release(tu_edpt_state_t* ep_state, osal_mutex_t mutex) {
+bool tu_edpt_release(volatile uint8_t* ep_state, osal_mutex_t mutex) {
(void) mutex;
(void) osal_mutex_lock(mutex, OSAL_TIMEOUT_WAIT_FOREVER);
// can only release the endpoint if it is claimed and not busy
- bool const ret = (ep_state->claimed == 1) && (ep_state->busy == 0);
+ bool const ret = (*ep_state & (TU_EDPT_STATE_CLAIMED | TU_EDPT_STATE_BUSY)) == TU_EDPT_STATE_CLAIMED;
if (ret) {
- ep_state->claimed = 0;
+ *ep_state &= (uint8_t) ~TU_EDPT_STATE_CLAIMED;
}
(void) osal_mutex_unlock(mutex);
return ret;
}
-bool tu_edpt_validate(tusb_desc_endpoint_t const* desc_ep, tusb_speed_t speed, bool is_host) {
- uint16_t const max_packet_size = tu_edpt_packet_size(desc_ep);
+#if CFG_TUSB_DEBUG
+bool tu_edpt_validate(const tusb_desc_endpoint_t *desc_ep, tusb_speed_t speed) {
+ const uint16_t max_packet_size = tu_edpt_packet_size(desc_ep);
TU_LOG2(" Open EP %02X with Size = %u\r\n", desc_ep->bEndpointAddress, max_packet_size);
+ TU_ASSERT(max_packet_size > 0);
switch (desc_ep->bmAttributes.xfer) {
case TUSB_XFER_ISOCHRONOUS: {
- uint16_t const spec_size = (speed == TUSB_SPEED_HIGH ? 1024 : 1023);
+ const uint16_t spec_size = (speed == TUSB_SPEED_HIGH ? 1024 : 1023);
TU_ASSERT(max_packet_size <= spec_size);
break;
}
@@ -253,21 +274,12 @@ bool tu_edpt_validate(tusb_desc_endpoint_t const* desc_ep, tusb_speed_t speed, b
TU_ASSERT(max_packet_size == 512);
} else {
// Bulk fullspeed can only be 8, 16, 32, 64
- if (is_host && max_packet_size == 512) {
- // HACK: while in host mode, some device incorrectly always report 512 regardless of link speed
- // overwrite descriptor to force 64
- TU_LOG1(" WARN: EP max packet size is 512 in fullspeed, force to 64\r\n");
- tusb_desc_endpoint_t* hacked_ep = (tusb_desc_endpoint_t*) (uintptr_t) desc_ep;
- hacked_ep->wMaxPacketSize = tu_htole16(64);
- } else {
- TU_ASSERT(max_packet_size == 8 || max_packet_size == 16 ||
- max_packet_size == 32 || max_packet_size == 64);
- }
+ TU_ASSERT(max_packet_size == 8 || max_packet_size == 16 || max_packet_size == 32 || max_packet_size == 64);
}
break;
case TUSB_XFER_INTERRUPT: {
- uint16_t const spec_size = (speed == TUSB_SPEED_HIGH ? 1024 : 64);
+ const uint16_t spec_size = (speed == TUSB_SPEED_HIGH ? 1024 : 64);
TU_ASSERT(max_packet_size <= spec_size);
break;
}
@@ -278,121 +290,99 @@ bool tu_edpt_validate(tusb_desc_endpoint_t const* desc_ep, tusb_speed_t speed, b
return true;
}
+#endif
-void tu_edpt_bind_driver(uint8_t ep2drv[][2], tusb_desc_interface_t const* desc_itf, uint16_t desc_len,
- uint8_t driver_id) {
- uint8_t const* p_desc = (uint8_t const*) desc_itf;
- uint8_t const* desc_end = p_desc + desc_len;
+bool tu_bind_driver_to_ep_itf(uint8_t driver_id, uint8_t ep2drv[][2], uint8_t itf2drv[], uint8_t itf_max,
+ const uint8_t *p_desc, uint16_t desc_len) {
+ const uint8_t *desc_end = p_desc + desc_len;
+ while (tu_desc_in_bounds(p_desc, desc_end)) {
+ const uint8_t desc_type = tu_desc_type(p_desc);
- while (p_desc < desc_end) {
- if (TUSB_DESC_ENDPOINT == tu_desc_type(p_desc)) {
- uint8_t const ep_addr = ((tusb_desc_endpoint_t const*) p_desc)->bEndpointAddress;
- TU_LOG(2, " Bind EP %02x to driver id %u\r\n", ep_addr, driver_id);
- ep2drv[tu_edpt_number(ep_addr)][tu_edpt_dir(ep_addr)] = driver_id;
+ if (desc_type == TUSB_DESC_ENDPOINT) {
+ const uint8_t ep_addr = ((const tusb_desc_endpoint_t *)p_desc)->bEndpointAddress;
+ const uint8_t ep_num = tu_edpt_number(ep_addr);
+ const uint8_t ep_dir = tu_edpt_dir(ep_addr);
+ ep2drv[ep_num][ep_dir] = driver_id;
+ } else if (desc_type == TUSB_DESC_INTERFACE) {
+ const tusb_desc_interface_t *desc_itf = (const tusb_desc_interface_t *)p_desc;
+ if (desc_itf->bAlternateSetting == 0) {
+ TU_ASSERT(desc_itf->bInterfaceNumber < itf_max);
+ itf2drv[desc_itf->bInterfaceNumber] = driver_id;
+ }
}
- p_desc = tu_desc_next(p_desc);
- }
-}
-uint16_t tu_desc_get_interface_total_len(tusb_desc_interface_t const* desc_itf, uint8_t itf_count, uint16_t max_len) {
- uint8_t const* p_desc = (uint8_t const*) desc_itf;
- uint16_t len = 0;
-
- while (itf_count--) {
- // Next on interface desc
- len += tu_desc_len(desc_itf);
p_desc = tu_desc_next(p_desc);
-
- while (len < max_len) {
- if (tu_desc_len(p_desc) == 0) {
- // Escape infinite loop
- break;
- }
- // return on IAD regardless of itf count
- if (tu_desc_type(p_desc) == TUSB_DESC_INTERFACE_ASSOCIATION) {
- return len;
- }
- if ((tu_desc_type(p_desc) == TUSB_DESC_INTERFACE) &&
- ((tusb_desc_interface_t const*) p_desc)->bAlternateSetting == 0) {
- break;
- }
-
- len += tu_desc_len(p_desc);
- p_desc = tu_desc_next(p_desc);
- }
}
-
- return len;
+ return true;
}
//--------------------------------------------------------------------+
// Endpoint Stream Helper for both Host and Device stack
//--------------------------------------------------------------------+
-bool tu_edpt_stream_init(tu_edpt_stream_t* s, bool is_host, bool is_tx, bool overwritable,
- void* ff_buf, uint16_t ff_bufsize, uint8_t* ep_buf, uint16_t ep_bufsize) {
+bool tu_edpt_stream_init(tu_edpt_stream_t *s, bool is_host, bool is_tx, bool overwritable, void *ff_buf,
+ uint16_t ff_bufsize, uint8_t *ep_buf) {
(void) is_tx;
+ if (ff_buf == NULL || ff_bufsize == 0) {
+ return false;
+ }
+
s->is_host = is_host;
- tu_fifo_config(&s->ff, ff_buf, ff_bufsize, 1, overwritable);
+ tu_fifo_config(&s->ff, ff_buf, ff_bufsize, overwritable);
#if OSAL_MUTEX_REQUIRED
- if (ff_buf && ff_bufsize) {
+ if (ff_buf != NULL && ff_bufsize > 0) {
osal_mutex_t new_mutex = osal_mutex_create(&s->ff_mutexdef);
tu_fifo_config_mutex(&s->ff, is_tx ? new_mutex : NULL, is_tx ? NULL : new_mutex);
}
#endif
s->ep_buf = ep_buf;
- s->ep_bufsize = ep_bufsize;
return true;
}
-bool tu_edpt_stream_deinit(tu_edpt_stream_t* s) {
- (void) s;
- #if OSAL_MUTEX_REQUIRED
- if (s->ff.mutex_wr) osal_mutex_delete(s->ff.mutex_wr);
- if (s->ff.mutex_rd) osal_mutex_delete(s->ff.mutex_rd);
- #endif
- return true;
-}
-
-TU_ATTR_ALWAYS_INLINE static inline bool stream_claim(uint8_t hwid, tu_edpt_stream_t* s) {
+static bool stream_claim(tu_edpt_stream_t *s) {
+ TU_VERIFY(s->ep_addr != 0); // must be opened
if (s->is_host) {
#if CFG_TUH_ENABLED
- return usbh_edpt_claim(hwid, s->ep_addr);
- #endif
+ return usbh_edpt_claim(s->hwid, s->ep_addr);
+ #endif
} else {
#if CFG_TUD_ENABLED
- return usbd_edpt_claim(hwid, s->ep_addr);
- #endif
+ return usbd_edpt_claim(s->hwid, s->ep_addr);
+ #endif
}
return false;
}
-TU_ATTR_ALWAYS_INLINE static inline bool stream_xfer(uint8_t hwid, tu_edpt_stream_t* s, uint16_t count) {
+static bool stream_xfer(tu_edpt_stream_t *s, uint16_t count) {
if (s->is_host) {
#if CFG_TUH_ENABLED
- return usbh_edpt_xfer(hwid, s->ep_addr, count ? s->ep_buf : NULL, count);
- #endif
+ return usbh_edpt_xfer(s->hwid, s->ep_addr, count ? s->ep_buf : NULL, count);
+ #endif
} else {
#if CFG_TUD_ENABLED
- return usbd_edpt_xfer(hwid, s->ep_addr, count ? s->ep_buf : NULL, count);
- #endif
+ if (s->ep_buf == NULL) {
+ return usbd_edpt_xfer_fifo(s->hwid, s->ep_addr, &s->ff, count, false);
+ } else {
+ return usbd_edpt_xfer(s->hwid, s->ep_addr, count ? s->ep_buf : NULL, count, false);
+ }
+ #endif
}
return false;
}
-TU_ATTR_ALWAYS_INLINE static inline bool stream_release(uint8_t hwid, tu_edpt_stream_t* s) {
+static bool stream_release(tu_edpt_stream_t *s) {
if (s->is_host) {
#if CFG_TUH_ENABLED
- return usbh_edpt_release(hwid, s->ep_addr);
- #endif
+ return usbh_edpt_release(s->hwid, s->ep_addr);
+ #endif
} else {
#if CFG_TUD_ENABLED
- return usbd_edpt_release(hwid, s->ep_addr);
- #endif
+ return usbd_edpt_release(s->hwid, s->ep_addr);
+ #endif
}
return false;
}
@@ -400,117 +390,84 @@ TU_ATTR_ALWAYS_INLINE static inline bool stream_release(uint8_t hwid, tu_edpt_st
//--------------------------------------------------------------------+
// Stream Write
//--------------------------------------------------------------------+
-bool tu_edpt_stream_write_zlp_if_needed(uint8_t hwid, tu_edpt_stream_t* s, uint32_t last_xferred_bytes) {
+bool tu_edpt_stream_write_zlp_if_needed(tu_edpt_stream_t *s, uint32_t last_xferred_bytes) {
// ZLP condition: no pending data, last transferred bytes is multiple of packet size
- const uint16_t mps = s->is_mps512 ? TUSB_EPSIZE_BULK_HS : TUSB_EPSIZE_BULK_FS;
- TU_VERIFY(!tu_fifo_count(&s->ff) && last_xferred_bytes && (0 == (last_xferred_bytes & (mps - 1))));
- TU_VERIFY(stream_claim(hwid, s));
- TU_ASSERT(stream_xfer(hwid, s, 0));
+ TU_VERIFY(tu_fifo_empty(&s->ff) && last_xferred_bytes > 0 && (0 == (last_xferred_bytes & (s->mps - 1))));
+ TU_VERIFY(stream_claim(s));
+ TU_ASSERT(stream_xfer(s, 0));
return true;
}
-uint32_t tu_edpt_stream_write_xfer(uint8_t hwid, tu_edpt_stream_t* s) {
- // skip if no data
- TU_VERIFY(tu_fifo_count(&s->ff), 0);
-
- TU_VERIFY(stream_claim(hwid, s), 0);
+uint32_t tu_edpt_stream_write_xfer(tu_edpt_stream_t *s) {
+ const uint16_t ff_count = tu_fifo_count(&s->ff);
+ TU_VERIFY(ff_count > 0, 0); // skip if no data
+ TU_VERIFY(stream_claim(s), 0);
// Pull data from FIFO -> EP buf
- uint16_t const count = tu_fifo_read_n(&s->ff, s->ep_buf, s->ep_bufsize);
+ uint16_t count;
+ if (s->ep_buf == NULL) {
+ count = tu_fifo_count(&s->ff); // re-get count since fifo can be changed
+ } else {
+ count = tu_fifo_read_n(&s->ff, s->ep_buf, s->xfer_len);
+ }
- if (count) {
- TU_ASSERT(stream_xfer(hwid, s, count), 0);
+ if (count > 0) {
+ TU_ASSERT(stream_xfer(s, count), 0);
return count;
} else {
// Release endpoint since we don't make any transfer
// Note: data is dropped if terminal is not connected
- stream_release(hwid, s);
+ stream_release(s);
return 0;
}
}
-uint32_t tu_edpt_stream_write(uint8_t hwid, tu_edpt_stream_t* s, void const* buffer, uint32_t bufsize) {
- TU_VERIFY(bufsize); // TODO support ZLP
-
- if (0 == tu_fifo_depth(&s->ff)) {
- // no fifo for buffered
- TU_VERIFY(stream_claim(hwid, s), 0);
- const uint32_t xact_len = tu_min32(bufsize, s->ep_bufsize);
- memcpy(s->ep_buf, buffer, xact_len);
- TU_ASSERT(stream_xfer(hwid, s, (uint16_t) xact_len), 0);
- return xact_len;
- } else {
- const uint16_t ret = tu_fifo_write_n(&s->ff, buffer, (uint16_t) bufsize);
+uint32_t tu_edpt_stream_write(tu_edpt_stream_t *s, const void *buffer, uint32_t bufsize) {
+ TU_VERIFY(bufsize > 0);
+ const uint16_t ret = tu_fifo_write_n(&s->ff, buffer, (uint16_t) bufsize);
- // flush if fifo has more than packet size or
- // in rare case: fifo depth is configured too small (which never reach packet size)
- const uint16_t mps = s->is_mps512 ? TUSB_EPSIZE_BULK_HS : TUSB_EPSIZE_BULK_FS;
- if ((tu_fifo_count(&s->ff) >= mps) || (tu_fifo_depth(&s->ff) < mps)) {
- tu_edpt_stream_write_xfer(hwid, s);
- }
- return ret;
+ // flush if fifo has more than packet size or
+ // in rare case: fifo depth is configured too small (which never reach packet size)
+ if ((tu_fifo_count(&s->ff) >= s->mps) || (tu_fifo_depth(&s->ff) < s->mps)) {
+ tu_edpt_stream_write_xfer(s);
}
+ return ret;
}
-uint32_t tu_edpt_stream_write_available(uint8_t hwid, tu_edpt_stream_t* s) {
- if (tu_fifo_depth(&s->ff)) {
- return (uint32_t) tu_fifo_remaining(&s->ff);
- } else {
- bool is_busy = true;
- if (s->is_host) {
- #if CFG_TUH_ENABLED
- is_busy = usbh_edpt_busy(hwid, s->ep_addr);
- #endif
- } else {
- #if CFG_TUD_ENABLED
- is_busy = usbd_edpt_busy(hwid, s->ep_addr);
- #endif
- }
- return is_busy ? 0 : s->ep_bufsize;
- }
+uint32_t tu_edpt_stream_write_available(tu_edpt_stream_t *s) {
+ return (uint32_t)tu_fifo_remaining(&s->ff);
}
//--------------------------------------------------------------------+
// Stream Read
//--------------------------------------------------------------------+
-uint32_t tu_edpt_stream_read_xfer(uint8_t hwid, tu_edpt_stream_t* s) {
- if (0 == tu_fifo_depth(&s->ff)) {
- // no fifo for buffered
- TU_VERIFY(stream_claim(hwid, s), 0);
- TU_ASSERT(stream_xfer(hwid, s, s->ep_bufsize), 0);
- return s->ep_bufsize;
- } else {
- const uint16_t mps = s->is_mps512 ? TUSB_EPSIZE_BULK_HS : TUSB_EPSIZE_BULK_FS;
- uint16_t available = tu_fifo_remaining(&s->ff);
-
- // Prepare for incoming data but only allow what we can store in the ring buffer.
- // TODO Actually we can still carry out the transfer, keeping count of received bytes
- // and slowly move it to the FIFO when read().
- // This pre-check reduces endpoint claiming
- TU_VERIFY(available >= mps);
-
- TU_VERIFY(stream_claim(hwid, s), 0);
+uint32_t tu_edpt_stream_read_xfer(tu_edpt_stream_t *s) {
+ uint16_t available = tu_fifo_remaining(&s->ff);
- // get available again since fifo can be changed before endpoint is claimed
- available = tu_fifo_remaining(&s->ff);
+ // Prepare for incoming data but only allow what we can store in the ring buffer.
+ // TODO Actually we can still carry out the transfer, keeping count of received bytes
+ // and slowly move it to the FIFO when read().
+ // This pre-check reduces endpoint claiming
+ TU_VERIFY(available >= s->mps);
+ TU_VERIFY(stream_claim(s), 0);
+ available = tu_fifo_remaining(&s->ff); // re-get available since fifo can be changed
- if (available >= mps) {
- // multiple of packet size limit by ep bufsize
- uint16_t count = (uint16_t) (available & ~(mps - 1));
- count = tu_min16(count, s->ep_bufsize);
- TU_ASSERT(stream_xfer(hwid, s, count), 0);
- return count;
- } else {
- // Release endpoint since we don't make any transfer
- stream_release(hwid, s);
- return 0;
- }
+ if (available >= s->mps) {
+ // multiple of packet size limit by ep bufsize
+ uint16_t count = (uint16_t) (available & ~(s->mps - 1));
+ count = tu_min16(count, s->xfer_len);
+ TU_ASSERT(stream_xfer(s, count), 0);
+ return count;
+ } else {
+ // Release endpoint since we don't make any transfer
+ stream_release(s);
+ return 0;
}
}
-uint32_t tu_edpt_stream_read(uint8_t hwid, tu_edpt_stream_t* s, void* buffer, uint32_t bufsize) {
- uint32_t num_read = tu_fifo_read_n(&s->ff, buffer, (uint16_t) bufsize);
- tu_edpt_stream_read_xfer(hwid, s);
+uint32_t tu_edpt_stream_read(tu_edpt_stream_t *s, void *buffer, uint32_t bufsize) {
+ const uint32_t num_read = tu_fifo_read_n(&s->ff, buffer, (uint16_t)bufsize);
+ tu_edpt_stream_read_xfer(s);
return num_read;
}
@@ -540,7 +497,7 @@ char const* const tu_str_std_request[] = {
};
char const* const tu_str_xfer_result[] = {
- "OK", "FAILED", "STALLED", "TIMEOUT"
+ "OK", "FAILED", "STALLED", "TIMEOUT", "ABORTED", "INVALID"
};
#endif
@@ -576,8 +533,12 @@ void tu_print_mem(void const* buf, uint32_t count, uint8_t indent) {
if (i % item_per_line == 0) {
// Print Ascii
- if (i != 0) dump_str_line(buf8 - 16, 16);
- for (uint8_t s = 0; s < indent; s++) tu_printf(" ");
+ if (i != 0) {
+ dump_str_line(buf8 - 16, 16);
+ }
+ for (uint8_t s = 0; s < indent; s++) {
+ tu_printf(" ");
+ }
// print offset or absolute address
tu_printf("%04X: ", 16 * i / item_per_line);
}
@@ -592,10 +553,12 @@ void tu_print_mem(void const* buf, uint32_t count, uint8_t indent) {
// fill up last row to 16 for printing ascii
const uint32_t remain = count % 16;
uint8_t nback = (uint8_t) (remain ? remain : 16);
- if (remain) {
+ if (remain > 0) {
for (uint32_t i = 0; i < 16 - remain; i++) {
tu_printf(" ");
- for (int j = 0; j < 2 * size; j++) tu_printf(" ");
+ for (int j = 0; j < 2 * size; j++) {
+ tu_printf(" ");
+ }
}
}
generated by cgit v1.3.1 (git 2.54.0) at 2026-08-17 07:07:27 +0000