rename fifo * to tu_fifo to avoid conflict with other module

4 files changed, 67 insertions, 67 deletions

diff --git a/src/class/cdc/cdc_device.c b/src/class/cdc/cdc_device.c
index 583180fcc..585c8c685 100644
--- a/src/class/cdc/cdc_device.c
+++ b/src/class/cdc/cdc_device.c
@@ -71,8 +71,8 @@ typedef struct {
 CFG_TUSB_ATTR_USBRAM CFG_TUSB_MEM_ALIGN uint8_t _tmp_rx_buf[64];

 CFG_TUSB_ATTR_USBRAM CFG_TUSB_MEM_ALIGN uint8_t _tmp_tx_buf[64];

 

-FIFO_DEF(_rx_ff, CFG_TUD_CDC_RX_BUFSIZE, uint8_t, true);

-FIFO_DEF(_tx_ff, CFG_TUD_CDC_TX_BUFSIZE, uint8_t, false);

+TU_FIFO_DEF(_rx_ff, CFG_TUD_CDC_RX_BUFSIZE, uint8_t, true);

+TU_FIFO_DEF(_tx_ff, CFG_TUD_CDC_TX_BUFSIZE, uint8_t, false);

 

 //--------------------------------------------------------------------+

 // INTERNAL OBJECT & FUNCTION DECLARATION

@@ -104,18 +104,18 @@ void tud_n_cdc_get_line_coding (uint8_t rhport, cdc_line_coding_t* coding)
 //--------------------------------------------------------------------+

 uint32_t tud_n_cdc_available(uint8_t rhport)

 {

-  return fifo_count(&_rx_ff);

+  return tu_fifo_count(&_rx_ff);

 }

 

 int8_t tud_n_cdc_read_char(uint8_t rhport)

 {

   int8_t ch;

-  return fifo_read(&_rx_ff, &ch) ? ch : (-1);

+  return tu_fifo_read(&_rx_ff, &ch) ? ch : (-1);

 }

 

 uint32_t tud_n_cdc_read(uint8_t rhport, void* buffer, uint32_t bufsize)

 {

-  return fifo_read_n(&_rx_ff, buffer, bufsize);

+  return tu_fifo_read_n(&_rx_ff, buffer, bufsize);

 }

 

 //--------------------------------------------------------------------+

@@ -124,12 +124,12 @@ uint32_t tud_n_cdc_read(uint8_t rhport, void* buffer, uint32_t bufsize)
 

 uint32_t tud_n_cdc_write_char(uint8_t rhport, char ch)

 {

-  return fifo_write(&_tx_ff, &ch) ? 1 : 0;

+  return tu_fifo_write(&_tx_ff, &ch) ? 1 : 0;

 }

 

 uint32_t tud_n_cdc_write(uint8_t rhport, void const* buffer, uint32_t bufsize)

 {

-  return fifo_write_n(&_tx_ff, buffer, bufsize);

+  return tu_fifo_write_n(&_tx_ff, buffer, bufsize);

 }

 

 bool tud_n_cdc_flush (uint8_t rhport)

@@ -137,7 +137,7 @@ bool tud_n_cdc_flush (uint8_t rhport)
   uint8_t  edpt = _cdcd_itf[rhport].ep_in;

   VERIFY( !dcd_edpt_busy(rhport, edpt) ); // skip if previous transfer not complete

 

-  uint16_t count = fifo_read_n(&_tx_ff, _tmp_tx_buf, sizeof(_tmp_tx_buf));

+  uint16_t count = tu_fifo_read_n(&_tx_ff, _tmp_tx_buf, sizeof(_tmp_tx_buf));

 

   VERIFY( tud_n_cdc_connected(rhport) ); // fifo is empty if not connected

 

@@ -230,8 +230,8 @@ void cdcd_close(uint8_t rhport)
   // no need to close opened pipe, dcd bus reset will put controller's endpoints to default state

   memclr_(&_cdcd_itf[rhport], sizeof(cdcd_interface_t));

 

-  fifo_clear(&_rx_ff);

-  fifo_clear(&_tx_ff);

+  tu_fifo_clear(&_rx_ff);

+  tu_fifo_clear(&_tx_ff);

 }

 

 tusb_error_t cdcd_control_request_st(uint8_t rhport, tusb_control_request_t const * p_request)

@@ -282,7 +282,7 @@ tusb_error_t cdcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, tusb_event_t event, u
 

   if ( ep_addr == p_cdc->ep_out )

   {

-    fifo_write_n(&_rx_ff, _tmp_rx_buf, xferred_bytes);

+    tu_fifo_write_n(&_rx_ff, _tmp_rx_buf, xferred_bytes);

 

     // preparing for next

     TU_ASSERT( dcd_edpt_xfer(rhport, p_cdc->ep_out, _tmp_rx_buf, sizeof(_tmp_rx_buf)), TUSB_ERROR_DCD_EDPT_XFER );

diff --git a/src/common/tusb_fifo.c b/src/common/tusb_fifo.c
index d6f34f33f..03c0b63ab 100644
--- a/src/common/tusb_fifo.c
+++ b/src/common/tusb_fifo.c
@@ -1,6 +1,6 @@
 /**************************************************************************/

 /*!

-    @file     fifo.c

+    @file     tusb_fifo.c

     @author   hathach (tinyusb.org)

 

     @section LICENSE

@@ -44,8 +44,8 @@
  *------------------------------------------------------------------*/

 #if CFG_FIFO_MUTEX

 

-#define mutex_lock_if_needed(_ff)     if (_ff->mutex) fifo_mutex_lock(_ff->mutex)

-#define mutex_unlock_if_needed(_ff)   if (_ff->mutex) fifo_mutex_unlock(_ff->mutex)

+#define mutex_lock_if_needed(_ff)     if (_ff->mutex) tu_fifo_mutex_lock(_ff->mutex)

+#define mutex_unlock_if_needed(_ff)   if (_ff->mutex) tu_fifo_mutex_unlock(_ff->mutex)

 

 #else

 

@@ -59,13 +59,13 @@ static inline uint16_t min16_of(uint16_t x, uint16_t y)
   return (x < y) ? x : y;

 }

 

-static inline bool fifo_initalized(fifo_t* f)

+static inline bool tu_fifo_initalized(tu_fifo_t* f)

 {

   return (f->buffer != NULL) && (f->depth > 0) && (f->item_size > 0);

 }

 

 

-void fifo_config(fifo_t *f, void* buffer, uint16_t depth, uint16_t item_size, bool overwritable)

+void tu_fifo_config(tu_fifo_t *f, void* buffer, uint16_t depth, uint16_t item_size, bool overwritable)

 {

   mutex_lock_if_needed(f);

 

@@ -96,10 +96,10 @@ void fifo_config(fifo_t *f, void* buffer, uint16_t depth, uint16_t item_size, bo
     @returns TRUE if the queue is not empty

 */

 /******************************************************************************/

-bool fifo_read(fifo_t* f, void * p_buffer)

+bool tu_fifo_read(tu_fifo_t* f, void * p_buffer)

 {

-  if( !fifo_initalized(f) ) return false;

-  if( fifo_empty(f) ) return false;

+  if( !tu_fifo_initalized(f) ) return false;

+  if( tu_fifo_empty(f) ) return false;

 

   mutex_lock_if_needed(f);

 

@@ -130,10 +130,10 @@ bool fifo_read(fifo_t* f, void * p_buffer)
     @returns number of items read from the FIFO

 */

 /******************************************************************************/

-uint16_t fifo_read_n (fifo_t* f, void * p_buffer, uint16_t count)

+uint16_t tu_fifo_read_n (tu_fifo_t* f, void * p_buffer, uint16_t count)

 {

-  if( !fifo_initalized(f) ) return 0;

-  if( fifo_empty(f) ) return 0;

+  if( !tu_fifo_initalized(f) ) return 0;

+  if( tu_fifo_empty(f) ) return 0;

 

   /* Limit up to fifo's count */

   count = min16_of(count, f->count);

@@ -149,7 +149,7 @@ uint16_t fifo_read_n (fifo_t* f, void * p_buffer, uint16_t count)
 

   uint8_t* p_buf = (uint8_t*) p_buffer;

   uint16_t len = 0;

-  while( (len < count) && fifo_read(f, p_buf) )

+  while( (len < count) && tu_fifo_read(f, p_buf) )

   {

     len++;

     p_buf += f->item_size;

@@ -174,9 +174,9 @@ uint16_t fifo_read_n (fifo_t* f, void * p_buffer, uint16_t count)
     @returns TRUE if the queue is not empty

 */

 /******************************************************************************/

-bool fifo_peek_at(fifo_t* f, uint16_t position, void * p_buffer)

+bool tu_fifo_peek_at(tu_fifo_t* f, uint16_t position, void * p_buffer)

 {

-  if ( !fifo_initalized(f) ) return false;

+  if ( !tu_fifo_initalized(f) ) return false;

   if ( position >= f->count ) return false;

 

   // rd_idx is position=0

@@ -205,12 +205,12 @@ bool fifo_peek_at(fifo_t* f, uint16_t position, void * p_buffer)
              FIFO will always return TRUE)

 */

 /******************************************************************************/

-bool fifo_write(fifo_t* f, void const * p_data)

+bool tu_fifo_write(tu_fifo_t* f, void const * p_data)

 {

-  if ( !fifo_initalized(f) ) return false;

+  if ( !tu_fifo_initalized(f) ) return false;

 

-//  if ( fifo_full(f) && !f->overwritable ) return false;

-  TU_ASSERT( !(fifo_full(f) && !f->overwritable) );

+//  if ( tu_fifo_full(f) && !f->overwritable ) return false;

+  TU_ASSERT( !(tu_fifo_full(f) && !f->overwritable) );

 

   mutex_lock_if_needed(f);

 

@@ -220,7 +220,7 @@ bool fifo_write(fifo_t* f, void const * p_data)
 

   f->wr_idx = (f->wr_idx + 1) % f->depth;

 

-  if (fifo_full(f))

+  if (tu_fifo_full(f))

   {

     f->rd_idx = f->wr_idx; // keep the full state (rd == wr && len = size)

   }

@@ -249,14 +249,14 @@ bool fifo_write(fifo_t* f, void const * p_data)
     @return Number of written elements

 */

 /******************************************************************************/

-uint16_t fifo_write_n(fifo_t* f, void const * p_data, uint16_t count)

+uint16_t tu_fifo_write_n(tu_fifo_t* f, void const * p_data, uint16_t count)

 {

   if ( count == 0 ) return 0;

 

   uint8_t* p_buf = (uint8_t*) p_data;

 

   uint16_t len = 0;

-  while( (len < count) && fifo_write(f, p_buf) )

+  while( (len < count) && tu_fifo_write(f, p_buf) )

   {

     len++;

     p_buf += f->item_size;

@@ -273,7 +273,7 @@ uint16_t fifo_write_n(fifo_t* f, void const * p_data, uint16_t count)
                 Pointer to the FIFO buffer to manipulate

 */

 /******************************************************************************/

-void fifo_clear(fifo_t *f)

+void tu_fifo_clear(tu_fifo_t *f)

 {

   mutex_lock_if_needed(f);

 

diff --git a/src/common/tusb_fifo.h b/src/common/tusb_fifo.h
index 452b1f35f..d87b32395 100644
--- a/src/common/tusb_fifo.h
+++ b/src/common/tusb_fifo.h
@@ -1,6 +1,6 @@
 /**************************************************************************/

 /*!

-    @file     fifo.h

+    @file     tusb_fifo.h

     @author   hathach (tinyusb.org)

 

     @section LICENSE

@@ -65,10 +65,10 @@
 #define _ff_mutex_def(mutex)

 

 #else

-#define fifo_mutex_t          struct os_mutex

+#define tu_fifo_mutex_t          struct os_mutex

 

-#define fifo_mutex_lock(m)    os_mutex_pend(m, OS_TIMEOUT_NEVER)

-#define fifo_mutex_unlock(m)  os_mutex_release(m)

+#define tu_fifo_mutex_lock(m)    os_mutex_pend(m, OS_TIMEOUT_NEVER)

+#define tu_fifo_mutex_unlock(m)  os_mutex_release(m)

 

 /* Internal use only */

 #define _mutex_declare(m)     .mutex = m

@@ -82,7 +82,7 @@
 #endif

 

 

-/** \struct fifo_t

+/** \struct tu_fifo_t

  * \brief Simple Circular FIFO

  */

 typedef struct

@@ -98,59 +98,59 @@ typedef struct
            bool overwritable  ;

 

 #if CFG_FIFO_MUTEX

-  fifo_mutex_t * const mutex;

+  tu_fifo_mutex_t * const mutex;

 #endif

 

-} fifo_t;

+} tu_fifo_t;

 

-#define FIFO_DEF(name, ff_depth, type, is_overwritable) /*, irq_mutex)*/ \

-  uint8_t name##_buffer[ff_depth*sizeof(type)];\

-  fifo_t name = {\

-      .buffer       = name##_buffer,\

-      .depth        = ff_depth,\

-      .item_size    = sizeof(type),\

-      .overwritable = is_overwritable,\

+#define TU_FIFO_DEF(_name, _depth, _type, _overwritable) /*, irq_mutex)*/ \

+  uint8_t _name##_buf[_depth*sizeof(_type)];\

+  tu_fifo_t _name = {\

+      .buffer       = _name##_buf,\

+      .depth        = _depth,\

+      .item_size    = sizeof(_type),\

+      .overwritable = _overwritable,\

       /*.irq          = irq_mutex*/\

       _mutex_declare(_mutex)\

   }

 

-void fifo_clear(fifo_t *f);

-void fifo_config(fifo_t *f, void* buffer, uint16_t depth, uint16_t item_size, bool overwritable);

+void tu_fifo_clear(tu_fifo_t *f);

+void tu_fifo_config(tu_fifo_t *f, void* buffer, uint16_t depth, uint16_t item_size, bool overwritable);

 

-bool     fifo_write   (fifo_t* f, void const * p_data);

-uint16_t fifo_write_n (fifo_t* f, void const * p_data, uint16_t count);

+bool     tu_fifo_write   (tu_fifo_t* f, void const * p_data);

+uint16_t tu_fifo_write_n (tu_fifo_t* f, void const * p_data, uint16_t count);

 

-bool     fifo_read    (fifo_t* f, void * p_buffer);

-uint16_t fifo_read_n  (fifo_t* f, void * p_buffer, uint16_t count);

+bool     tu_fifo_read    (tu_fifo_t* f, void * p_buffer);

+uint16_t tu_fifo_read_n  (tu_fifo_t* f, void * p_buffer, uint16_t count);

 

-bool     fifo_peek_at (fifo_t* f, uint16_t position, void * p_buffer);

+bool     tu_fifo_peek_at (tu_fifo_t* f, uint16_t position, void * p_buffer);

 

-static inline bool fifo_peek(fifo_t* f, void * p_buffer)

+static inline bool tu_fifo_peek(tu_fifo_t* f, void * p_buffer)

 {

-  return fifo_peek_at(f, 0, p_buffer);

+  return tu_fifo_peek_at(f, 0, p_buffer);

 }

 

-static inline bool fifo_empty(fifo_t* f)

+static inline bool tu_fifo_empty(tu_fifo_t* f)

 {

   return (f->count == 0);

 }

 

-static inline bool fifo_full(fifo_t* f)

+static inline bool tu_fifo_full(tu_fifo_t* f)

 {

   return (f->count == f->depth);

 }

 

-static inline uint16_t fifo_count(fifo_t* f)

+static inline uint16_t tu_fifo_count(tu_fifo_t* f)

 {

   return f->count;

 }

 

-static inline uint16_t fifo_remaining(fifo_t* f)

+static inline uint16_t tu_fifo_remaining(tu_fifo_t* f)

 {

   return f->depth - f->count;

 }

 

-static inline uint16_t fifo_depth(fifo_t* f)

+static inline uint16_t tu_fifo_depth(tu_fifo_t* f)

 {

   return f->depth;

 }

diff --git a/src/osal/osal_none.h b/src/osal/osal_none.h
index 9bdb047b4..1328d1753 100644
--- a/src/osal/osal_none.h
+++ b/src/osal/osal_none.h
@@ -130,20 +130,20 @@ static inline osal_task_t osal_task_create(osal_task_def_t* taskdef)
 //--------------------------------------------------------------------+

 // QUEUE API

 //--------------------------------------------------------------------+

-#define OSAL_QUEUE_DEF(_name, _depth, _type)    FIFO_DEF(_name, _depth, _type, false)

+#define OSAL_QUEUE_DEF(_name, _depth, _type)    TU_FIFO_DEF(_name, _depth, _type, false)

 

-typedef fifo_t  osal_queue_def_t;

-typedef fifo_t* osal_queue_t;

+typedef tu_fifo_t  osal_queue_def_t;

+typedef tu_fifo_t* osal_queue_t;

 

 static inline osal_queue_t osal_queue_create(osal_queue_def_t* qdef)

 {

-  fifo_clear(qdef);

+  tu_fifo_clear(qdef);

   return (osal_queue_t) qdef;

 }

 

 static inline bool osal_queue_send_isr(osal_queue_t const queue_hdl, void const * data)

 {

-  return fifo_write( (fifo_t*) queue_hdl, data);

+  return tu_fifo_write( (tu_fifo_t*) queue_hdl, data);

 }

 

 #define osal_queue_send osal_queue_send_isr

@@ -164,7 +164,7 @@ static inline void osal_queue_flush(osal_queue_t const queue_hdl)
         return TUSB_ERROR_OSAL_WAITING;                                                     \

     } else{                                                                                 \

       /*tusb_hal_int_disable_all();*/                                                       \

-      fifo_read(queue_hdl, p_data);                                                         \

+      tu_fifo_read(queue_hdl, p_data);                                                         \

       /*tusb_hal_int_enable_all();*/                                                            \

       *(p_error) = TUSB_ERROR_NONE;                                                         \

     }                                                                                       \