kingkevin
/
passkey_fw
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

code format

This commit is contained in:
hathach 2024-03-15 17:58:27 +07:00
parent a4101c4174
commit 6352081ded
No known key found for this signature in database
GPG Key ID: 26FAB84F615C3C52
1 changed files with 93 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

248
src/tusb.c
View File

@ -43,8 +43,7 @@
// 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) );
@ -58,8 +57,7 @@ bool tusb_init(void)
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
@ -77,37 +75,30 @@ 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];
} }
return NULL; return NULL;
} }
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// Endpoint Helper for both Host and Device stack // Endpoint Helper for both Host and Device stack
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
@ -126,13 +117,11 @@ bool tu_edpt_claim(tu_edpt_state_t* ep_state, osal_mutex_t mutex) {
} }
(void) osal_mutex_unlock(mutex); (void) osal_mutex_unlock(mutex);
return available; return available;
} }
bool tu_edpt_release(tu_edpt_state_t* ep_state, osal_mutex_t mutex) { bool tu_edpt_release(tu_edpt_state_t* ep_state, osal_mutex_t mutex) {
(void) mutex; (void) mutex;
(void) osal_mutex_lock(mutex, OSAL_TIMEOUT_WAIT_FOREVER); (void) osal_mutex_lock(mutex, OSAL_TIMEOUT_WAIT_FOREVER);
// can only release the endpoint if it is claimed and not busy // can only release the endpoint if it is claimed and not busy
@ -142,58 +131,49 @@ bool tu_edpt_release(tu_edpt_state_t* ep_state, osal_mutex_t mutex) {
} }
(void) osal_mutex_unlock(mutex); (void) osal_mutex_unlock(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);
@ -204,25 +184,21 @@ void tu_edpt_bind_driver(uint8_t ep2drv[][2], tusb_desc_interface_t const* 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) && if ((tu_desc_type(p_desc) == TUSB_DESC_INTERFACE) &&
((tusb_desc_interface_t const*) p_desc)->bAlternateSetting == 0 ) ((tusb_desc_interface_t const*) p_desc)->bAlternateSetting == 0) {
{
break; break;
} }
@ -239,8 +215,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;
@ -255,16 +230,12 @@ bool tu_edpt_stream_init(tu_edpt_stream_t* s, bool is_host, bool is_tx, bool ove
return true; return true;
} }
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
@ -273,16 +244,12 @@ bool stream_claim(tu_edpt_stream_t* s)
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
@ -291,16 +258,12 @@ bool stream_xfer(tu_edpt_stream_t* s, uint16_t count)
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
@ -313,34 +276,29 @@ bool stream_release(tu_edpt_stream_t* s)
// 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 +306,14 @@ 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);
} }
@ -368,8 +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,20 @@ 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,38 +366,33 @@ 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 : '.');
} }
@ -460,39 +405,34 @@ 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++) for (unsigned int i = 0; i < count; i++) {
{ unsigned int value = 0;
unsigned int value=0;
if ( i%item_per_line == 0 ) if (i % item_per_line == 0) {
{
// Print Ascii // Print Ascii
if ( i != 0 ) if (i != 0) {
{ dump_str_line(buf8 - 16, 16);
dump_str_line(buf8-16, 16);
} }
for(uint8_t s=0; s < indent; s++) tu_printf(" "); 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 +443,17 @@ 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