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

reduce ep stream footprint by using is_mps512 since it only support bulk so far

Browse Source
This commit is contained in:
hathach
2024-09-10 18:37:53 +07:00
parent 3ab63fbc65
commit dd1822ba03
2 changed files with 14 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
src/common/tusb_private.h
View File

@@ -41,13 +41,14 @@ typedef struct TU_ATTR_PACKED {
}tu_edpt_state_t; }tu_edpt_state_t;
typedef struct { typedef struct {
uint8_t is_host; // 1: host, 0: device struct TU_ATTR_PACKED {
uint8_t is_host : 1; // 1: host, 0: device
uint8_t is_mps512 : 1; // 1: 512, 0: 64 since stream is used for Bulk only
};
uint8_t ep_addr; uint8_t ep_addr;
uint16_t ep_packetsize;
uint16_t ep_bufsize; uint16_t ep_bufsize;
uint8_t* ep_buf; // TODO xfer_fifo can skip this buffer
uint8_t* ep_buf; // TODO xfer_fifo can skip this buffer
tu_fifo_t ff; tu_fifo_t ff;
// mutex: read if rx, otherwise write // mutex: read if rx, otherwise write
@@ -90,7 +91,7 @@ TU_ATTR_ALWAYS_INLINE static inline
void tu_edpt_stream_open(tu_edpt_stream_t* s, tusb_desc_endpoint_t const *desc_ep) { void tu_edpt_stream_open(tu_edpt_stream_t* s, tusb_desc_endpoint_t const *desc_ep) {
tu_fifo_clear(&s->ff); tu_fifo_clear(&s->ff);
s->ep_addr = desc_ep->bEndpointAddress; s->ep_addr = desc_ep->bEndpointAddress;
s->ep_packetsize = tu_edpt_packet_size(desc_ep); s->is_mps512 = (tu_edpt_packet_size(desc_ep) == 512) ? 1 : 0;
} }
TU_ATTR_ALWAYS_INLINE static inline TU_ATTR_ALWAYS_INLINE static inline

13
src/tusb.c
View File

@@ -283,7 +283,8 @@ TU_ATTR_ALWAYS_INLINE static inline bool stream_release(uint8_t hwid, tu_edpt_st
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
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(uint8_t hwid, tu_edpt_stream_t* s, uint32_t last_xferred_bytes) {
// ZLP condition: no pending data, last transferred bytes is multiple of packet size // ZLP condition: no pending data, last transferred bytes is multiple of packet size
TU_VERIFY(!tu_fifo_count(&s->ff) && last_xferred_bytes && (0 == (last_xferred_bytes & (s->ep_packetsize - 1)))); 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_VERIFY(stream_claim(hwid, s));
TU_ASSERT(stream_xfer(hwid, s, 0)); TU_ASSERT(stream_xfer(hwid, s, 0));
return true; return true;
@@ -324,7 +325,8 @@ uint32_t tu_edpt_stream_write(uint8_t hwid, tu_edpt_stream_t* s, void const* buf
// flush if fifo has more than packet size or // flush if fifo has more than packet size or
// in rare case: fifo depth is configured too small (which never reach packet size) // in rare case: fifo depth is configured too small (which never reach packet size)
if ((tu_fifo_count(&s->ff) >= s->ep_packetsize) || (tu_fifo_depth(&s->ff) < s->ep_packetsize)) { 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); tu_edpt_stream_write_xfer(hwid, s);
} }
return ret; return ret;
@@ -359,22 +361,23 @@ uint32_t tu_edpt_stream_read_xfer(uint8_t hwid, tu_edpt_stream_t* s) {
TU_ASSERT(stream_xfer(hwid, s, s->ep_bufsize), 0); TU_ASSERT(stream_xfer(hwid, s, s->ep_bufsize), 0);
return s->ep_bufsize; return s->ep_bufsize;
} else { } else {
const uint16_t mps = s->is_mps512 ? TUSB_EPSIZE_BULK_HS : TUSB_EPSIZE_BULK_FS;
uint16_t available = tu_fifo_remaining(&s->ff); uint16_t available = tu_fifo_remaining(&s->ff);
// Prepare for incoming data but only allow what we can store in the ring buffer. // 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 // TODO Actually we can still carry out the transfer, keeping count of received bytes
// and slowly move it to the FIFO when read(). // and slowly move it to the FIFO when read().
// This pre-check reduces endpoint claiming // This pre-check reduces endpoint claiming
TU_VERIFY(available >= s->ep_packetsize); TU_VERIFY(available >= mps);
TU_VERIFY(stream_claim(hwid, s), 0); TU_VERIFY(stream_claim(hwid, s), 0);
// get available again since fifo can be changed before endpoint is claimed // get available again since fifo can be changed before endpoint is claimed
available = tu_fifo_remaining(&s->ff); available = tu_fifo_remaining(&s->ff);
if (available >= s->ep_packetsize) { if (available >= mps) {
// multiple of packet size limit by ep bufsize // multiple of packet size limit by ep bufsize
uint16_t count = (uint16_t) (available & ~(s->ep_packetsize - 1)); uint16_t count = (uint16_t) (available & ~(mps - 1));
count = tu_min16(count, s->ep_bufsize); count = tu_min16(count, s->ep_bufsize);
TU_ASSERT(stream_xfer(hwid, s, count), 0); TU_ASSERT(stream_xfer(hwid, s, count), 0);
return count; return count;