mirror/tinyusb
1
0
Fork 0
mirror of https://github.com/hathach/tinyusb.git synced 2025-03-29 01:20:19 +00:00
Code Issues Packages Projects Releases Wiki Activity

code format

Browse Source
This commit is contained in:
hathach 2024-03-22 12:30:14 +07:00
parent 74bd264758
commit 2cf171095e
No known key found for this signature in database
GPG Key ID: 26FAB84F615C3C52
2 changed files with 113 additions and 195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
src/common/tusb_fifo.h
View File

@ -102,10 +102,8 @@ extern "C" {
* | * |
* ------------------------- * -------------------------
* | R | 1 | 2 | W | 4 | 5 | * | R | 1 | 2 | W | 4 | 5 |
*/ */
typedef struct typedef struct {
{
uint8_t* buffer ; // buffer pointer uint8_t* buffer ; // buffer pointer
uint16_t depth ; // max items uint16_t depth ; // max items
@ -124,16 +122,14 @@ typedef struct
} tu_fifo_t; } tu_fifo_t;
typedef struct typedef struct {
{
uint16_t len_lin ; ///< linear length in item size uint16_t len_lin ; ///< linear length in item size
uint16_t len_wrap ; ///< wrapped length in item size uint16_t len_wrap ; ///< wrapped length in item size
void * ptr_lin ; ///< linear part start pointer void * ptr_lin ; ///< linear part start pointer
void * ptr_wrap ; ///< wrapped part start pointer void * ptr_wrap ; ///< wrapped part start pointer
} tu_fifo_buffer_info_t; } tu_fifo_buffer_info_t;
#define TU_FIFO_INIT(_buffer, _depth, _type, _overwritable) \ #define TU_FIFO_INIT(_buffer, _depth, _type, _overwritable){\
{ \
.buffer = _buffer, \ .buffer = _buffer, \
.depth = _depth, \ .depth = _depth, \
.item_size = sizeof(_type), \ .item_size = sizeof(_type), \
@ -144,23 +140,18 @@ typedef struct
uint8_t _name##_buf[_depth*sizeof(_type)]; \ uint8_t _name##_buf[_depth*sizeof(_type)]; \
tu_fifo_t _name = TU_FIFO_INIT(_name##_buf, _depth, _type, _overwritable) tu_fifo_t _name = TU_FIFO_INIT(_name##_buf, _depth, _type, _overwritable)
bool tu_fifo_set_overwritable(tu_fifo_t *f, bool overwritable); bool tu_fifo_set_overwritable(tu_fifo_t *f, bool overwritable);
bool tu_fifo_clear(tu_fifo_t *f); bool tu_fifo_clear(tu_fifo_t *f);
bool tu_fifo_config(tu_fifo_t *f, void* buffer, uint16_t depth, uint16_t item_size, bool overwritable); bool tu_fifo_config(tu_fifo_t *f, void* buffer, uint16_t depth, uint16_t item_size, bool overwritable);
#if OSAL_MUTEX_REQUIRED #if OSAL_MUTEX_REQUIRED
TU_ATTR_ALWAYS_INLINE static inline TU_ATTR_ALWAYS_INLINE static inline
void tu_fifo_config_mutex(tu_fifo_t *f, osal_mutex_t wr_mutex, osal_mutex_t rd_mutex) void tu_fifo_config_mutex(tu_fifo_t *f, osal_mutex_t wr_mutex, osal_mutex_t rd_mutex) {
{ f->mutex_wr = wr_mutex;
f->mutex_wr = wr_mutex; f->mutex_rd = rd_mutex;
f->mutex_rd = rd_mutex; }
}
#else #else
#define tu_fifo_config_mutex(_f, _wr_mutex, _rd_mutex)
#define tu_fifo_config_mutex(_f, _wr_mutex, _rd_mutex)
#endif #endif
bool tu_fifo_write (tu_fifo_t* f, void const * p_data); bool tu_fifo_write (tu_fifo_t* f, void const * p_data);
@ -182,8 +173,7 @@ bool tu_fifo_overflowed (tu_fifo_t* f);
void tu_fifo_correct_read_pointer (tu_fifo_t* f); void tu_fifo_correct_read_pointer (tu_fifo_t* f);
TU_ATTR_ALWAYS_INLINE static inline TU_ATTR_ALWAYS_INLINE static inline
uint16_t tu_fifo_depth(tu_fifo_t* f) uint16_t tu_fifo_depth(tu_fifo_t* f) {
{
return f->depth; return f->depth;
} }
@ -198,7 +188,6 @@ void tu_fifo_advance_read_pointer (tu_fifo_t *f, uint16_t n);
void tu_fifo_get_read_info (tu_fifo_t *f, tu_fifo_buffer_info_t *info); void tu_fifo_get_read_info (tu_fifo_t *f, tu_fifo_buffer_info_t *info);
void tu_fifo_get_write_info(tu_fifo_t *f, tu_fifo_buffer_info_t *info); void tu_fifo_get_write_info(tu_fifo_t *f, tu_fifo_buffer_info_t *info);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

277
src/tusb.c
View File

@ -43,32 +43,30 @@
// Public API // Public API
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
bool tusb_init(void) bool tusb_init(void) {
{ #if CFG_TUD_ENABLED && defined(TUD_OPT_RHPORT)
#if CFG_TUD_ENABLED && defined(TUD_OPT_RHPORT)
// init device stack CFG_TUSB_RHPORTx_MODE must be defined // init device stack CFG_TUSB_RHPORTx_MODE must be defined
TU_ASSERT ( tud_init(TUD_OPT_RHPORT) ); TU_ASSERT ( tud_init(TUD_OPT_RHPORT) );
#endif #endif
#if CFG_TUH_ENABLED && defined(TUH_OPT_RHPORT) #if CFG_TUH_ENABLED && defined(TUH_OPT_RHPORT)
// init host stack CFG_TUSB_RHPORTx_MODE must be defined // init host stack CFG_TUSB_RHPORTx_MODE must be defined
TU_ASSERT( tuh_init(TUH_OPT_RHPORT) ); TU_ASSERT( tuh_init(TUH_OPT_RHPORT) );
#endif #endif
return true; return true;
} }
bool tusb_inited(void) bool tusb_inited(void) {
{
bool ret = false; bool ret = false;
#if CFG_TUD_ENABLED #if CFG_TUD_ENABLED
ret = ret || tud_inited(); ret = ret || tud_inited();
#endif #endif
#if CFG_TUH_ENABLED #if CFG_TUH_ENABLED
ret = ret || tuh_inited(); ret = ret || tuh_inited();
#endif #endif
return ret; return ret;
} }
@ -77,30 +75,24 @@ bool tusb_inited(void)
// Descriptor helper // Descriptor helper
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
uint8_t const * tu_desc_find(uint8_t const* desc, uint8_t const* end, uint8_t byte1) uint8_t const* tu_desc_find(uint8_t const* desc, uint8_t const* end, uint8_t byte1) {
{ while (desc + 1 < end) {
while(desc+1 < end) if (desc[1] == byte1) return desc;
{
if ( desc[1] == byte1 ) return desc;
desc += desc[DESC_OFFSET_LEN]; desc += desc[DESC_OFFSET_LEN];
} }
return NULL; return NULL;
} }
uint8_t const * tu_desc_find2(uint8_t const* desc, uint8_t const* end, uint8_t byte1, uint8_t byte2) uint8_t const* tu_desc_find2(uint8_t const* desc, uint8_t const* end, uint8_t byte1, uint8_t byte2) {
{ while (desc + 2 < end) {
while(desc+2 < end) if (desc[1] == byte1 && desc[2] == byte2) return desc;
{
if ( desc[1] == byte1 && desc[2] == byte2) return desc;
desc += desc[DESC_OFFSET_LEN]; desc += desc[DESC_OFFSET_LEN];
} }
return NULL; return NULL;
} }
uint8_t const * tu_desc_find3(uint8_t const* desc, uint8_t const* end, uint8_t byte1, uint8_t byte2, uint8_t byte3) uint8_t const* tu_desc_find3(uint8_t const* desc, uint8_t const* end, uint8_t byte1, uint8_t byte2, uint8_t byte3) {
{ while (desc + 3 < end) {
while(desc+3 < end)
{
if (desc[1] == byte1 && desc[2] == byte2 && desc[3] == byte3) return desc; if (desc[1] == byte1 && desc[2] == byte2 && desc[3] == byte3) return desc;
desc += desc[DESC_OFFSET_LEN]; desc += desc[DESC_OFFSET_LEN];
} }
@ -146,83 +138,71 @@ bool tu_edpt_release(tu_edpt_state_t* ep_state, osal_mutex_t mutex) {
return ret; return ret;
} }
bool tu_edpt_validate(tusb_desc_endpoint_t const * desc_ep, tusb_speed_t speed) bool tu_edpt_validate(tusb_desc_endpoint_t const* desc_ep, tusb_speed_t speed) {
{
uint16_t const max_packet_size = tu_edpt_packet_size(desc_ep); uint16_t const 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_LOG2(" Open EP %02X with Size = %u\r\n", desc_ep->bEndpointAddress, max_packet_size);
switch (desc_ep->bmAttributes.xfer) switch (desc_ep->bmAttributes.xfer) {
{ case TUSB_XFER_ISOCHRONOUS: {
case TUSB_XFER_ISOCHRONOUS:
{
uint16_t const spec_size = (speed == TUSB_SPEED_HIGH ? 1024 : 1023); uint16_t const spec_size = (speed == TUSB_SPEED_HIGH ? 1024 : 1023);
TU_ASSERT(max_packet_size <= spec_size); TU_ASSERT(max_packet_size <= spec_size);
break;
} }
break;
case TUSB_XFER_BULK: case TUSB_XFER_BULK:
if (speed == TUSB_SPEED_HIGH) if (speed == TUSB_SPEED_HIGH) {
{
// Bulk highspeed must be EXACTLY 512 // Bulk highspeed must be EXACTLY 512
TU_ASSERT(max_packet_size == 512); TU_ASSERT(max_packet_size == 512);
}else } else {
{
// TODO Bulk fullspeed can only be 8, 16, 32, 64 // TODO Bulk fullspeed can only be 8, 16, 32, 64
TU_ASSERT(max_packet_size <= 64); TU_ASSERT(max_packet_size <= 64);
} }
break; break;
case TUSB_XFER_INTERRUPT: case TUSB_XFER_INTERRUPT: {
{
uint16_t const spec_size = (speed == TUSB_SPEED_HIGH ? 1024 : 64); uint16_t const spec_size = (speed == TUSB_SPEED_HIGH ? 1024 : 64);
TU_ASSERT(max_packet_size <= spec_size); TU_ASSERT(max_packet_size <= spec_size);
break;
} }
break;
default: return false; default:
return false;
} }
return true; return true;
} }
void tu_edpt_bind_driver(uint8_t ep2drv[][2], tusb_desc_interface_t const* desc_itf, uint16_t desc_len, uint8_t driver_id) 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* p_desc = (uint8_t const*) desc_itf;
uint8_t const* desc_end = p_desc + desc_len; uint8_t const* desc_end = p_desc + desc_len;
while( p_desc < desc_end ) while (p_desc < desc_end) {
{ if (TUSB_DESC_ENDPOINT == tu_desc_type(p_desc)) {
if ( TUSB_DESC_ENDPOINT == tu_desc_type(p_desc) )
{
uint8_t const ep_addr = ((tusb_desc_endpoint_t const*) p_desc)->bEndpointAddress; 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); 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; ep2drv[tu_edpt_number(ep_addr)][tu_edpt_dir(ep_addr)] = driver_id;
} }
p_desc = tu_desc_next(p_desc); 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) 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; uint8_t const* p_desc = (uint8_t const*) desc_itf;
uint16_t len = 0; uint16_t len = 0;
while (itf_count--) while (itf_count--) {
{
// Next on interface desc // Next on interface desc
len += tu_desc_len(desc_itf); len += tu_desc_len(desc_itf);
p_desc = tu_desc_next(p_desc); p_desc = tu_desc_next(p_desc);
while (len < max_len) while (len < max_len) {
{
// return on IAD regardless of itf count // 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_ASSOCIATION) {
return len;
if ( (tu_desc_type(p_desc) == TUSB_DESC_INTERFACE) && }
((tusb_desc_interface_t const*) p_desc)->bAlternateSetting == 0 ) if ((tu_desc_type(p_desc) == TUSB_DESC_INTERFACE) &&
{ ((tusb_desc_interface_t const*) p_desc)->bAlternateSetting == 0) {
break; break;
} }
@ -239,8 +219,7 @@ uint16_t tu_desc_get_interface_total_len(tusb_desc_interface_t const* desc_itf,
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
bool tu_edpt_stream_init(tu_edpt_stream_t* s, bool is_host, bool is_tx, bool overwritable, 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) void* ff_buf, uint16_t ff_bufsize, uint8_t* ep_buf, uint16_t ep_bufsize) {
{
osal_mutex_t new_mutex = osal_mutex_create(&s->ff_mutex); osal_mutex_t new_mutex = osal_mutex_create(&s->ff_mutex);
(void) new_mutex; (void) new_mutex;
(void) is_tx; (void) is_tx;
@ -256,91 +235,72 @@ bool tu_edpt_stream_init(tu_edpt_stream_t* s, bool is_host, bool is_tx, bool ove
} }
TU_ATTR_ALWAYS_INLINE static inline TU_ATTR_ALWAYS_INLINE static inline
bool stream_claim(tu_edpt_stream_t* s) bool stream_claim(tu_edpt_stream_t* s) {
{ if (s->is_host) {
if (s->is_host)
{
#if CFG_TUH_ENABLED #if CFG_TUH_ENABLED
return usbh_edpt_claim(s->daddr, s->ep_addr); return usbh_edpt_claim(s->daddr, s->ep_addr);
#endif #endif
}else } else {
{
#if CFG_TUD_ENABLED #if CFG_TUD_ENABLED
return usbd_edpt_claim(s->rhport, s->ep_addr); return usbd_edpt_claim(s->rhport, s->ep_addr);
#endif #endif
} }
return false; return false;
} }
TU_ATTR_ALWAYS_INLINE static inline TU_ATTR_ALWAYS_INLINE static inline
bool stream_xfer(tu_edpt_stream_t* s, uint16_t count) bool stream_xfer(tu_edpt_stream_t* s, uint16_t count) {
{ if (s->is_host) {
if (s->is_host)
{
#if CFG_TUH_ENABLED #if CFG_TUH_ENABLED
return usbh_edpt_xfer(s->daddr, s->ep_addr, count ? s->ep_buf : NULL, count); return usbh_edpt_xfer(s->daddr, s->ep_addr, count ? s->ep_buf : NULL, count);
#endif #endif
}else } else {
{
#if CFG_TUD_ENABLED #if CFG_TUD_ENABLED
return usbd_edpt_xfer(s->rhport, s->ep_addr, count ? s->ep_buf : NULL, count); return usbd_edpt_xfer(s->rhport, s->ep_addr, count ? s->ep_buf : NULL, count);
#endif #endif
} }
return false; return false;
} }
TU_ATTR_ALWAYS_INLINE static inline TU_ATTR_ALWAYS_INLINE static inline
bool stream_release(tu_edpt_stream_t* s) bool stream_release(tu_edpt_stream_t* s) {
{ if (s->is_host) {
if (s->is_host)
{
#if CFG_TUH_ENABLED #if CFG_TUH_ENABLED
return usbh_edpt_release(s->daddr, s->ep_addr); return usbh_edpt_release(s->daddr, s->ep_addr);
#endif #endif
}else } else {
{
#if CFG_TUD_ENABLED #if CFG_TUD_ENABLED
return usbd_edpt_release(s->rhport, s->ep_addr); return usbd_edpt_release(s->rhport, s->ep_addr);
#endif #endif
} }
return false; return false;
} }
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// Stream Write // Stream Write
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
bool tu_edpt_stream_write_zlp_if_needed(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 // 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))) ); TU_VERIFY(!tu_fifo_count(&s->ff) && last_xferred_bytes && (0 == (last_xferred_bytes & (s->ep_packetsize - 1))));
TU_VERIFY(stream_claim(s));
TU_VERIFY( stream_claim(s) ); TU_ASSERT(stream_xfer(s, 0));
TU_ASSERT( stream_xfer(s, 0) );
return true; return true;
} }
uint32_t tu_edpt_stream_write_xfer(tu_edpt_stream_t* s) uint32_t tu_edpt_stream_write_xfer(tu_edpt_stream_t* s) {
{
// skip if no data // skip if no data
TU_VERIFY( tu_fifo_count(&s->ff), 0 ); TU_VERIFY(tu_fifo_count(&s->ff), 0);
// Claim the endpoint // Claim the endpoint
TU_VERIFY( stream_claim(s), 0 ); TU_VERIFY(stream_claim(s), 0);
// Pull data from FIFO -> EP buf // Pull data from FIFO -> EP buf
uint16_t const count = tu_fifo_read_n(&s->ff, s->ep_buf, s->ep_bufsize); uint16_t const count = tu_fifo_read_n(&s->ff, s->ep_buf, s->ep_bufsize);
if ( count ) if (count) {
{ TU_ASSERT(stream_xfer(s, count), 0);
TU_ASSERT( stream_xfer(s, count), 0 );
return count; return count;
}else } else {
{
// Release endpoint since we don't make any transfer // Release endpoint since we don't make any transfer
// Note: data is dropped if terminal is not connected // Note: data is dropped if terminal is not connected
stream_release(s); stream_release(s);
@ -348,16 +308,13 @@ uint32_t tu_edpt_stream_write_xfer(tu_edpt_stream_t* s)
} }
} }
uint32_t tu_edpt_stream_write(tu_edpt_stream_t* s, void const *buffer, uint32_t bufsize) uint32_t tu_edpt_stream_write(tu_edpt_stream_t* s, void const* buffer, uint32_t bufsize) {
{
TU_VERIFY(bufsize); // TODO support ZLP TU_VERIFY(bufsize); // TODO support ZLP
uint16_t ret = tu_fifo_write_n(&s->ff, buffer, (uint16_t) bufsize); uint16_t ret = tu_fifo_write_n(&s->ff, buffer, (uint16_t) bufsize);
// 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) ) if ((tu_fifo_count(&s->ff) >= s->ep_packetsize) || (tu_fifo_depth(&s->ff) < s->ep_packetsize)) {
{
tu_edpt_stream_write_xfer(s); tu_edpt_stream_write_xfer(s);
} }
@ -367,9 +324,7 @@ uint32_t tu_edpt_stream_write(tu_edpt_stream_t* s, void const *buffer, uint32_t
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// Stream Read // Stream Read
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
uint32_t tu_edpt_stream_read_xfer(tu_edpt_stream_t* s) {
uint32_t tu_edpt_stream_read_xfer(tu_edpt_stream_t* s)
{
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.
@ -384,25 +339,21 @@ uint32_t tu_edpt_stream_read_xfer(tu_edpt_stream_t* s)
// 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 >= s->ep_packetsize) {
{
// 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 & ~(s->ep_packetsize - 1));
count = tu_min16(count, s->ep_bufsize); count = tu_min16(count, s->ep_bufsize);
TU_ASSERT( stream_xfer(s, count), 0 ); TU_ASSERT(stream_xfer(s, count), 0);
return count; return count;
}else } else {
{
// Release endpoint since we don't make any transfer // Release endpoint since we don't make any transfer
stream_release(s); stream_release(s);
return 0; return 0;
} }
} }
uint32_t tu_edpt_stream_read(tu_edpt_stream_t* s, void* buffer, uint32_t bufsize) uint32_t tu_edpt_stream_read(tu_edpt_stream_t* s, void* buffer, uint32_t bufsize) {
{
uint32_t num_read = tu_fifo_read_n(&s->ff, buffer, (uint16_t) bufsize); uint32_t num_read = tu_fifo_read_n(&s->ff, buffer, (uint16_t) bufsize);
tu_edpt_stream_read_xfer(s); tu_edpt_stream_read_xfer(s);
return num_read; return num_read;
@ -416,42 +367,35 @@ uint32_t tu_edpt_stream_read(tu_edpt_stream_t* s, void* buffer, uint32_t bufsize
#include <ctype.h> #include <ctype.h>
#if CFG_TUSB_DEBUG >= CFG_TUH_LOG_LEVEL || CFG_TUSB_DEBUG >= CFG_TUD_LOG_LEVEL #if CFG_TUSB_DEBUG >= CFG_TUH_LOG_LEVEL || CFG_TUSB_DEBUG >= CFG_TUD_LOG_LEVEL
char const* const tu_str_speed[] = {"Full", "Low", "High"};
char const* const tu_str_speed[] = { "Full", "Low", "High" }; char const* const tu_str_std_request[] = {
char const* const tu_str_std_request[] = "Get Status",
{ "Clear Feature",
"Get Status" , "Reserved",
"Clear Feature" , "Set Feature",
"Reserved" , "Reserved",
"Set Feature" , "Set Address",
"Reserved" , "Get Descriptor",
"Set Address" , "Set Descriptor",
"Get Descriptor" , "Get Configuration",
"Set Descriptor" , "Set Configuration",
"Get Configuration" , "Get Interface",
"Set Configuration" , "Set Interface",
"Get Interface" , "Synch Frame"
"Set Interface" ,
"Synch Frame"
}; };
char const* const tu_str_xfer_result[] = { char const* const tu_str_xfer_result[] = {
"OK", "FAILED", "STALLED", "TIMEOUT" "OK", "FAILED", "STALLED", "TIMEOUT"
}; };
#endif #endif
static void dump_str_line(uint8_t const* buf, uint16_t count) static void dump_str_line(uint8_t const* buf, uint16_t count) {
{
tu_printf(" |"); tu_printf(" |");
// each line is 16 bytes // each line is 16 bytes
for(uint16_t i=0; i<count; i++) for (uint16_t i = 0; i < count; i++) {
{
const char ch = buf[i]; const char ch = buf[i];
tu_printf("%c", isprint(ch) ? ch : '.'); tu_printf("%c", isprint(ch) ? ch : '.');
} }
tu_printf("|\r\n"); tu_printf("|\r\n");
} }
@ -460,39 +404,27 @@ static void dump_str_line(uint8_t const* buf, uint16_t count)
* - count : number of item * - count : number of item
* - indent: prefix spaces on every line * - indent: prefix spaces on every line
*/ */
void tu_print_mem(void const *buf, uint32_t count, uint8_t indent) void tu_print_mem(void const* buf, uint32_t count, uint8_t indent) {
{
uint8_t const size = 1; // fixed 1 byte for now uint8_t const size = 1; // fixed 1 byte for now
if (!buf || !count) {
if ( !buf || !count )
{
tu_printf("NULL\r\n"); tu_printf("NULL\r\n");
return; return;
} }
uint8_t const *buf8 = (uint8_t const *) buf; uint8_t const* buf8 = (uint8_t const*) buf;
char format[] = "%00X"; char format[] = "%00X";
format[2] += (uint8_t) (2*size); // 1 byte = 2 hex digits format[2] += (uint8_t) (2 * size); // 1 byte = 2 hex digits
const uint8_t item_per_line = 16 / size;
const uint8_t item_per_line = 16 / size; for (unsigned int i = 0; i < count; i++) {
unsigned int value = 0;
for(unsigned int i=0; i<count; i++) if (i % item_per_line == 0) {
{
unsigned int value=0;
if ( i%item_per_line == 0 )
{
// Print Ascii // Print Ascii
if ( i != 0 ) if (i != 0) dump_str_line(buf8 - 16, 16);
{ for (uint8_t s = 0; s < indent; s++) tu_printf(" ");
dump_str_line(buf8-16, 16);
}
for(uint8_t s=0; s < indent; s++) tu_printf(" ");
// print offset or absolute address // print offset or absolute address
tu_printf("%04X: ", 16*i/item_per_line); tu_printf("%04X: ", 16 * i / item_per_line);
} }
tu_memcpy_s(&value, sizeof(value), buf8, size); tu_memcpy_s(&value, sizeof(value), buf8, size);
@ -503,19 +435,16 @@ void tu_print_mem(void const *buf, uint32_t count, uint8_t indent)
} }
// fill up last row to 16 for printing ascii // fill up last row to 16 for printing ascii
const uint32_t remain = count%16; const uint32_t remain = count % 16;
uint8_t nback = (uint8_t)(remain ? remain : 16); uint8_t nback = (uint8_t) (remain ? remain : 16);
if (remain) {
if ( remain ) for (uint32_t i = 0; i < 16 - remain; i++) {
{
for(uint32_t i=0; i< 16-remain; i++)
{
tu_printf(" "); tu_printf(" ");
for(int j=0; j<2*size; j++) tu_printf(" "); for (int j = 0; j < 2 * size; j++) tu_printf(" ");
} }
} }
dump_str_line(buf8-nback, nback); dump_str_line(buf8 - nback, nback);
} }
#endif #endif