Merge remote-tracking branch 'tinyusb/master' into copilot/fix-dcd-edpt-xfer-issue

Signed-off-by: HiFiPhile <[email protected]>

14 files changed, 350 insertions, 247 deletions

diff --git a/src/class/audio/audio.h b/src/class/audio/audio.h
index 47d25dd81..cff38cc22 100644
--- a/src/class/audio/audio.h
+++ b/src/class/audio/audio.h
@@ -867,11 +867,11 @@ typedef enum {
 
 // A.2.1 - Audio Class-Audio Data Format Type I UAC2
 typedef enum {
-  AUDIO20_DATA_FORMAT_TYPE_I_PCM = (uint32_t) (1 << 0),
-  AUDIO20_DATA_FORMAT_TYPE_I_PCM8 = (uint32_t) (1 << 1),
-  AUDIO20_DATA_FORMAT_TYPE_I_IEEE_FLOAT = (uint32_t) (1 << 2),
-  AUDIO20_DATA_FORMAT_TYPE_I_ALAW = (uint32_t) (1 << 3),
-  AUDIO20_DATA_FORMAT_TYPE_I_MULAW = (uint32_t) (1 << 4),
+  AUDIO20_DATA_FORMAT_TYPE_I_PCM = 1 << 0,
+  AUDIO20_DATA_FORMAT_TYPE_I_PCM8 = 1 << 1,
+  AUDIO20_DATA_FORMAT_TYPE_I_IEEE_FLOAT = 1 << 2,
+  AUDIO20_DATA_FORMAT_TYPE_I_ALAW = 1 << 3,
+  AUDIO20_DATA_FORMAT_TYPE_I_MULAW = 1 << 4,
   AUDIO20_DATA_FORMAT_TYPE_I_RAW_DATA = 0x80000000u,
 } audio20_data_format_type_I_t;
 
@@ -905,7 +905,7 @@ typedef enum {
   AUDIO20_CHANNEL_CONFIG_BOTTOM_CENTER = 0x01000000,
   AUDIO20_CHANNEL_CONFIG_BACK_LEFT_OF_CENTER = 0x02000000,
   AUDIO20_CHANNEL_CONFIG_BACK_RIGHT_OF_CENTER = 0x04000000,
-  AUDIO20_CHANNEL_CONFIG_RAW_DATA = 0x80000000,
+  AUDIO20_CHANNEL_CONFIG_RAW_DATA = 0x80000000u,
 } audio20_channel_config_t;
 
 /// All remaining definitions are taken from the descriptor descriptions in the UAC2 main specification
diff --git a/src/class/audio/audio_device.c b/src/class/audio/audio_device.c
index 731834357..1dda8af99 100644
--- a/src/class/audio/audio_device.c
+++ b/src/class/audio/audio_device.c
@@ -217,6 +217,7 @@ typedef struct
   uint16_t ep_in_sz;        // Current size of TX EP
   uint8_t ep_in_as_intf_num;// Corresponding Standard AS Interface Descriptor (4.9.1) belonging to output terminal to which this EP belongs - 0 is invalid (this fits to UAC2 specification since AS interfaces can not have interface number equal to zero)
   uint8_t ep_in_alt;        // Current alternate setting of TX EP
+  uint16_t ep_in_fifo_threshold;// Target size for the EP IN FIFO.
   #endif
 
 #if CFG_TUD_AUDIO_ENABLE_EP_OUT
@@ -269,10 +270,6 @@ typedef struct
   uint16_t packet_sz_tx[3];
   uint8_t bclock_id_tx;
   uint8_t interval_tx;
-#endif
-
-// Encoding parameters - parameters are set when alternate AS interface is set by host
-#if CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_EP_IN_FLOW_CONTROL
   uint8_t format_type_tx;
   uint8_t n_channels_tx;
   uint8_t n_bytes_per_sample_tx;
@@ -455,7 +452,7 @@ static inline uint8_t audiod_get_audio_fct_idx(audiod_function_t *audio);
 #if CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_EP_IN_FLOW_CONTROL
 static void audiod_parse_flow_control_params(audiod_function_t *audio, uint8_t const *p_desc);
 static bool audiod_calc_tx_packet_sz(audiod_function_t *audio);
-static uint16_t audiod_tx_packet_size(const uint16_t *norminal_size, uint16_t data_count, uint16_t fifo_depth, uint16_t max_size);
+static uint16_t audiod_tx_packet_size(const uint16_t *nominal_size, uint16_t data_count, uint16_t fifo_depth, uint16_t fifo_threshold, uint16_t max_size);
 #endif
 
 #if CFG_TUD_AUDIO_ENABLE_EP_OUT && CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
@@ -503,7 +500,7 @@ static bool audiod_rx_xfer_isr(uint8_t rhport, audiod_function_t* audio, uint16_
 
   #if USE_LINEAR_BUFFER_RX
   // Data currently is in linear buffer, copy into EP OUT FIFO
-  TU_VERIFY(tu_fifo_write_n(&audio->ep_out_ff, audio->lin_buf_out, n_bytes_received));
+  TU_VERIFY(0 < tu_fifo_write_n(&audio->ep_out_ff, audio->lin_buf_out, n_bytes_received));
 
   // Schedule for next receive
   TU_VERIFY(usbd_edpt_xfer(rhport, audio->ep_out, audio->lin_buf_out, audio->ep_out_sz, true));
@@ -549,6 +546,17 @@ tu_fifo_t *tud_audio_n_get_ep_in_ff(uint8_t func_id) {
   return NULL;
 }
 
+uint16_t tud_audio_n_get_ep_in_fifo_threshold(uint8_t func_id) {
+  if (func_id < CFG_TUD_AUDIO) return _audiod_fct[func_id].ep_in_fifo_threshold;
+  return 0;
+}
+
+void tud_audio_n_set_ep_in_fifo_threshold(uint8_t func_id, uint16_t threshold) {
+  if (func_id < CFG_TUD_AUDIO && threshold < _audiod_fct[func_id].ep_in_ff.depth) {
+    _audiod_fct[func_id].ep_in_fifo_threshold = threshold;
+  }
+}
+
 static bool audiod_tx_xfer_isr(uint8_t rhport, audiod_function_t * audio, uint16_t n_bytes_sent) {
   uint8_t idx_audio_fct = audiod_get_audio_fct_idx(audio);
 
@@ -560,7 +568,7 @@ static bool audiod_tx_xfer_isr(uint8_t rhport, audiod_function_t * audio, uint16
 
   #if CFG_TUD_AUDIO_EP_IN_FLOW_CONTROL
   // packet_sz_tx is based on total packet size, here we want size for each support buffer.
-  n_bytes_tx = audiod_tx_packet_size(audio->packet_sz_tx, tu_fifo_count(&audio->ep_in_ff), audio->ep_in_ff.depth, audio->ep_in_sz);
+  n_bytes_tx = audiod_tx_packet_size(audio->packet_sz_tx, tu_fifo_count(&audio->ep_in_ff), audio->ep_in_ff.depth, audio->ep_in_fifo_threshold, audio->ep_in_sz);
   #else
   n_bytes_tx = tu_min16(tu_fifo_count(&audio->ep_in_ff), audio->ep_in_sz);// Limit up to max packet size, more can not be done for ISO
   #endif
@@ -630,19 +638,6 @@ static inline bool audiod_fb_send(uint8_t func_id, bool is_isr) {
     *audio->fb_buf = audio->feedback.value;
   }
 
-  // About feedback format on FS
-  //
-  // 3 variables: Format | packetSize | sendSize | Working OS:
-  //              16.16    4            4          Linux, Windows
-  //              16.16    4            3          Linux
-  //              16.16    3            4          Linux
-  //              16.16    3            3          Linux
-  //              10.14    4            4          Linux
-  //              10.14    4            3          Linux
-  //              10.14    3            4          Linux, OSX
-  //              10.14    3            3          Linux, OSX
-  //
-  // We send 3 bytes since sending packet larger than wMaxPacketSize is pretty ugly
   return usbd_edpt_xfer(audio->rhport, audio->ep_fb, (uint8_t *) audio->fb_buf, uac_version == 1 ? 3 : 4, is_isr);
 }
 
@@ -672,8 +667,12 @@ uint32_t tud_audio_feedback_update(uint8_t func_id, uint32_t cycles) {
   // The size of isochronous packets created by the device must be within the limits specified in FMT-2.0 section 2.3.1.1.
   // This means that the deviation of actual packet size from nominal size must not exceed +/- one audio slot
   // (audio slot = channel count samples).
-  if (feedback > audio->feedback.max_value) feedback = audio->feedback.max_value;
-  if (feedback < audio->feedback.min_value) feedback = audio->feedback.min_value;
+  if (feedback > audio->feedback.max_value) {
+    feedback = audio->feedback.max_value;
+  }
+  if (feedback < audio->feedback.min_value) {
+    feedback = audio->feedback.min_value;
+  }
 
   tud_audio_n_fb_set(func_id, feedback);
 
@@ -714,7 +713,6 @@ void audiod_init(void) {
 
       // Initialize IN EP FIFO if required
 #if CFG_TUD_AUDIO_ENABLE_EP_IN
-
     switch (i) {
   #if CFG_TUD_AUDIO_FUNC_1_EP_IN_SW_BUF_SZ > 0
       case 0:
@@ -883,9 +881,11 @@ uint16_t audiod_open(uint8_t rhport, tusb_desc_interface_t const *itf_desc, uint
               || tu_desc_type(p_desc) == TUSB_DESC_INTERFACE_ASSOCIATION) {
             break;
           } else if (tu_desc_type(p_desc) == TUSB_DESC_INTERFACE && ((tusb_desc_interface_t const *) p_desc)->bInterfaceSubClass == AUDIO_SUBCLASS_STREAMING) {
-            if (_audiod_fct[i].p_desc_as == 0) {
+            if (_audiod_fct[i].p_desc_as == NULL) {
               _audiod_fct[i].p_desc_as = p_desc;
             }
+          } else {
+            // nothing to do
           }
           total_len += p_desc[0];
           p_desc = tu_desc_next(p_desc);
@@ -957,19 +957,19 @@ uint16_t audiod_open(uint8_t rhport, tusb_desc_interface_t const *itf_desc, uint
         }
 
   #if CFG_TUD_AUDIO_ENABLE_EP_IN
-        if (ep_in) {
+        if (ep_in != 0) {
           usbd_edpt_iso_alloc(rhport, ep_in, ep_in_size);
         }
   #endif
 
   #if CFG_TUD_AUDIO_ENABLE_EP_OUT
-        if (ep_out) {
+        if (ep_out != 0) {
           usbd_edpt_iso_alloc(rhport, ep_out, ep_out_size);
         }
   #endif
 
   #if CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
-        if (ep_fb) {
+        if (ep_fb != 0) {
           usbd_edpt_iso_alloc(rhport, ep_fb, 4);
         }
   #endif
@@ -998,6 +998,8 @@ uint16_t audiod_open(uint8_t rhport, tusb_desc_interface_t const *itf_desc, uint
             if (tu_unaligned_read16(p_desc + 4) == AUDIO_TERM_TYPE_USB_STREAMING) {
               _audiod_fct[i].bclock_id_tx = p_desc[8];
             }
+          } else {
+            // nothing to do
           }
           p_desc = tu_desc_next(p_desc);
         }
@@ -1197,6 +1199,8 @@ static bool audiod_set_interface(uint8_t rhport, tusb_control_request_t const *p
             audio->ep_in_as_intf_num = itf;
             audio->ep_in_alt = alt;
             audio->ep_in_sz = tu_edpt_packet_size(desc_ep);
+            // Set the default EP IN FIFO threshold to half fifo depth.
+            audio->ep_in_fifo_threshold = audio->ep_in_ff.depth / 2;
 
             // If flow control is enabled, parse for the corresponding parameters - doing this here means only AS interfaces with EPs get scanned for parameters
   #if  CFG_TUD_AUDIO_EP_IN_FLOW_CONTROL
@@ -1458,6 +1462,8 @@ bool audiod_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_
     return audiod_control_request(rhport, request);
   } else if (stage == CONTROL_STAGE_DATA) {
     return audiod_control_complete(rhport, request);
+  } else {
+    // nothing to do
   }
 
   return true;
@@ -1549,7 +1555,7 @@ static bool audiod_fb_params_prepare(uint8_t func_id, uint8_t alt) {
 
   // Prepare feedback computation if endpoint is available
   if (audio->ep_fb != 0) {
-    audio_feedback_params_t fb_param;
+    audio_feedback_params_t fb_param = {0};
 
     tud_audio_feedback_params_cb(func_id, alt, &fb_param);
     audio->feedback.compute_method = fb_param.method;
@@ -1590,15 +1596,15 @@ static bool audiod_fb_params_prepare(uint8_t func_id, uint8_t alt) {
       } break;
 
       case AUDIO_FEEDBACK_METHOD_FIFO_COUNT: {
-        // Initialize the threshold level to half filled
-        uint16_t fifo_lvl_thr = tu_fifo_depth(&audio->ep_out_ff) / 2;
-        audio->feedback.compute.fifo_count.fifo_lvl_thr = fifo_lvl_thr;
-        audio->feedback.compute.fifo_count.fifo_lvl_avg = ((uint32_t) fifo_lvl_thr) << 16;
+        // Determine FIFO threshold
+        uint16_t fifo_threshold = fb_param.fifo_count.fifo_threshold ? fb_param.fifo_count.fifo_threshold : tu_fifo_depth(&audio->ep_out_ff) / 2;
+        audio->feedback.compute.fifo_count.fifo_lvl_thr = fifo_threshold;
+        audio->feedback.compute.fifo_count.fifo_lvl_avg = ((uint32_t) fifo_threshold) << 16;
         // Avoid 64bit division
         uint32_t nominal = ((fb_param.sample_freq / 100) << 16) / (frame_div / 100);
         audio->feedback.compute.fifo_count.nom_value = nominal;
-        audio->feedback.compute.fifo_count.rate_const[0] = (uint16_t) ((audio->feedback.max_value - nominal) / fifo_lvl_thr);
-        audio->feedback.compute.fifo_count.rate_const[1] = (uint16_t) ((nominal - audio->feedback.min_value) / fifo_lvl_thr);
+        audio->feedback.compute.fifo_count.rate_const[0] = (uint16_t) ((audio->feedback.max_value - nominal) / fifo_threshold);
+        audio->feedback.compute.fifo_count.rate_const[1] = (uint16_t) ((nominal - audio->feedback.min_value) / fifo_threshold);
         // On HS feedback is more sensitive since packet size can vary every MSOF, could cause instability
         if (tud_speed_get() == TUSB_SPEED_HIGH) {
           audio->feedback.compute.fifo_count.rate_const[0] /= 8;
@@ -1633,8 +1639,12 @@ static void audiod_fb_fifo_count_update(audiod_function_t *audio, uint16_t lvl_n
     feedback = audio->feedback.compute.fifo_count.nom_value - (ff_lvl - ff_thr) * rate[1];
   }
 
-  if (feedback > audio->feedback.max_value) feedback = audio->feedback.max_value;
-  if (feedback < audio->feedback.min_value) feedback = audio->feedback.min_value;
+  if (feedback > audio->feedback.max_value) {
+    feedback = audio->feedback.max_value;
+  }
+  if (feedback < audio->feedback.min_value) {
+    feedback = audio->feedback.min_value;
+  }
   audio->feedback.value = feedback;
 }
 
@@ -1754,7 +1764,7 @@ static bool audiod_verify_entity_exists(uint8_t itf, uint8_t entityID, uint8_t *
 static bool audiod_verify_itf_exists(uint8_t itf, uint8_t *func_id) {
   uint8_t i;
   for (i = 0; i < CFG_TUD_AUDIO; i++) {
-    if (_audiod_fct[i].p_desc) {
+    if (_audiod_fct[i].p_desc != NULL) {
       // Get pointer at beginning and end
       uint8_t const *p_desc = _audiod_fct[i].p_desc;
       uint8_t const *p_desc_end = _audiod_fct[i].p_desc + _audiod_fct[i].desc_length;
@@ -1861,22 +1871,22 @@ static bool audiod_calc_tx_packet_sz(audiod_function_t *audio) {
   return true;
 }
 
-static uint16_t audiod_tx_packet_size(const uint16_t *norminal_size, uint16_t data_count, uint16_t fifo_depth, uint16_t max_depth) {
+static uint16_t audiod_tx_packet_size(const uint16_t *nominal_size, uint16_t data_count, uint16_t fifo_depth, uint16_t fifo_threshold, uint16_t max_depth) {
   // Flow control need a FIFO size of at least 4*Navg
-  if (norminal_size[1] && norminal_size[1] <= fifo_depth * 4) {
+  if (nominal_size[1] && nominal_size[1] <= fifo_depth * 4) {
     // Use blackout to prioritize normal size packet
     static int ctrl_blackout = 0;
     uint16_t packet_size;
-    uint16_t slot_size = norminal_size[2] - norminal_size[1];
-    if (data_count < norminal_size[0]) {
+    uint16_t slot_size = nominal_size[2] - nominal_size[1];
+    if (data_count < nominal_size[0]) {
       // If you get here frequently, then your I2S clock deviation is too big !
       packet_size = 0;
-    } else if (data_count < fifo_depth / 2 - slot_size && !ctrl_blackout) {
-      packet_size = norminal_size[0];
+    } else if (data_count < (fifo_threshold - slot_size) && !ctrl_blackout) {
+      packet_size = nominal_size[0];
       ctrl_blackout = 10;
-    } else if (data_count > fifo_depth / 2 + slot_size && !ctrl_blackout) {
-      packet_size = norminal_size[2];
-      if (norminal_size[0] == norminal_size[1]) {
+    } else if (data_count > (fifo_threshold + slot_size) && !ctrl_blackout) {
+      packet_size = nominal_size[2];
+      if (nominal_size[0] == nominal_size[1]) {
         // nav > INT(nav), eg. 44.1k, 88.2k
         ctrl_blackout = 0;
       } else {
@@ -1884,7 +1894,7 @@ static uint16_t audiod_tx_packet_size(const uint16_t *norminal_size, uint16_t da
         ctrl_blackout = 10;
       }
     } else {
-      packet_size = norminal_size[1];
+      packet_size = nominal_size[1];
       if (ctrl_blackout) {
         ctrl_blackout--;
       }
diff --git a/src/class/audio/audio_device.h b/src/class/audio/audio_device.h
index 2bd432d48..1e0c46915 100644
--- a/src/class/audio/audio_device.h
+++ b/src/class/audio/audio_device.h
@@ -188,6 +188,8 @@ tu_fifo_t* tud_audio_n_get_ep_out_ff   (uint8_t func_id);
 uint16_t   tud_audio_n_write          (uint8_t func_id, const void * data, uint16_t len);
 bool       tud_audio_n_clear_ep_in_ff (uint8_t func_id);
 tu_fifo_t* tud_audio_n_get_ep_in_ff   (uint8_t func_id);
+uint16_t   tud_audio_n_get_ep_in_fifo_threshold(uint8_t func_id);
+void       tud_audio_n_set_ep_in_fifo_threshold(uint8_t func_id, uint16_t threshold);
 #endif
 
 #if CFG_TUD_AUDIO_ENABLE_INTERRUPT_EP
@@ -331,10 +333,12 @@ typedef struct {
   union {
     struct {
       uint32_t mclk_freq; // Main clock frequency in Hz i.e. master clock to which sample clock is based on
-    }frequency;
-
+    } frequency;
+    struct {
+      uint16_t fifo_threshold;  // Target FIFO threshold level, default to half FIFO if not set
+    } fifo_count;
   };
-}audio_feedback_params_t;
+} audio_feedback_params_t;
 
 // Invoked when needed to set feedback parameters
 void tud_audio_feedback_params_cb(uint8_t func_id, uint8_t alt_itf, audio_feedback_params_t* feedback_param);
@@ -424,6 +428,16 @@ TU_ATTR_ALWAYS_INLINE static inline tu_fifo_t* tud_audio_get_ep_in_ff(void) {
   return tud_audio_n_get_ep_in_ff(0);
 }
 
+TU_ATTR_ALWAYS_INLINE static inline uint16_t tud_audio_get_ep_in_fifo_threshold(void)
+{
+  return tud_audio_n_get_ep_in_fifo_threshold(0);
+}
+
+TU_ATTR_ALWAYS_INLINE static inline void tud_audio_set_ep_in_fifo_threshold(uint16_t threshold)
+{
+  tud_audio_n_set_ep_in_fifo_threshold(0, threshold);
+}
+
 #endif
 
 #if CFG_TUD_AUDIO_ENABLE_INTERRUPT_EP
diff --git a/src/class/cdc/cdc.h b/src/class/cdc/cdc.h
index 6d207c717..679723ba6 100644
--- a/src/class/cdc/cdc.h
+++ b/src/class/cdc/cdc.h
@@ -192,10 +192,10 @@ typedef enum {
   CDC_LINE_CODING_STOP_BITS_2   = 2, // 2   bits
 } cdc_line_coding_stopbits_t;
 
-#define CDC_LINE_CODING_STOP_BITS_TEXT(STOP_BITS) (        \
-  STOP_BITS == CDC_LINE_CODING_STOP_BITS_1 ?   "1" :       \
-  STOP_BITS == CDC_LINE_CODING_STOP_BITS_1_5 ? "1.5" :     \
-  STOP_BITS == CDC_LINE_CODING_STOP_BITS_2 ?   "2"   : "?" )
+#define CDC_LINE_CODING_STOP_BITS_TEXT(STOP_BITS) (          \
+  (STOP_BITS) == CDC_LINE_CODING_STOP_BITS_1   ? "1" :       \
+  (STOP_BITS) == CDC_LINE_CODING_STOP_BITS_1_5 ? "1.5" :     \
+  (STOP_BITS) == CDC_LINE_CODING_STOP_BITS_2   ? "2"   : "?" )
 
 // TODO Backward compatible for typos. Maybe removed in the future release
 #define CDC_LINE_CONDING_STOP_BITS_1   CDC_LINE_CODING_STOP_BITS_1
@@ -211,11 +211,11 @@ typedef enum {
 } cdc_line_coding_parity_t;
 
 #define CDC_LINE_CODING_PARITY_CHAR(PARITY) (        \
-  PARITY == CDC_LINE_CODING_PARITY_NONE  ? 'N' :     \
-  PARITY == CDC_LINE_CODING_PARITY_ODD   ? 'O' :     \
-  PARITY == CDC_LINE_CODING_PARITY_EVEN  ? 'E' :     \
-  PARITY == CDC_LINE_CODING_PARITY_MARK  ? 'M' :     \
-  PARITY == CDC_LINE_CODING_PARITY_SPACE ? 'S' : '?' )
+  (PARITY) == CDC_LINE_CODING_PARITY_NONE  ? 'N' :     \
+  (PARITY) == CDC_LINE_CODING_PARITY_ODD   ? 'O' :     \
+  (PARITY) == CDC_LINE_CODING_PARITY_EVEN  ? 'E' :     \
+  (PARITY) == CDC_LINE_CODING_PARITY_MARK  ? 'M' :     \
+  (PARITY) == CDC_LINE_CODING_PARITY_SPACE ? 'S' : '?' )
 
 //--------------------------------------------------------------------+
 // Management Element Notification (Notification Endpoint)
diff --git a/src/class/cdc/cdc_device.c b/src/class/cdc/cdc_device.c
index 2bf017aca..bf631908f 100644
--- a/src/class/cdc/cdc_device.c
+++ b/src/class/cdc/cdc_device.c
@@ -270,7 +270,7 @@ uint32_t tud_cdc_n_write_flush(uint8_t itf) {
   TU_VERIFY(tud_ready(), 0); // Skip if usb is not ready yet
 
   // No data to send
-  if (!tu_fifo_count(&p_cdc->tx_ff)) {
+  if (0 == tu_fifo_count(&p_cdc->tx_ff)) {
     return 0;
   }
 
@@ -279,7 +279,7 @@ uint32_t tud_cdc_n_write_flush(uint8_t itf) {
   // Pull data from FIFO
   const uint16_t count = tu_fifo_read_n(&p_cdc->tx_ff, p_epbuf->epin, CFG_TUD_CDC_EP_BUFSIZE);
 
-  if (count) {
+  if (count > 0) {
     TU_ASSERT(usbd_edpt_xfer(p_cdc->rhport, p_cdc->ep_in, p_epbuf->epin, count, false), 0);
     return count;
   } else {
@@ -337,15 +337,15 @@ bool cdcd_deinit(void) {
   #if OSAL_MUTEX_REQUIRED
   for(uint8_t i=0; i<CFG_TUD_CDC; i++) {
     cdcd_interface_t* p_cdc = &_cdcd_itf[i];
-    osal_mutex_t mutex_rd = p_cdc->rx_ff.mutex_rd;
-    osal_mutex_t mutex_wr = p_cdc->tx_ff.mutex_wr;
+    const osal_mutex_t mutex_rd = p_cdc->rx_ff.mutex_rd;
+    const osal_mutex_t mutex_wr = p_cdc->tx_ff.mutex_wr;
 
-    if (mutex_rd) {
+    if (mutex_rd != NULL) {
       osal_mutex_delete(mutex_rd);
       tu_fifo_config_mutex(&p_cdc->rx_ff, NULL, NULL);
     }
 
-    if (mutex_wr) {
+    if (mutex_wr != NULL) {
       osal_mutex_delete(mutex_wr);
       tu_fifo_config_mutex(&p_cdc->tx_ff, NULL, NULL);
     }
@@ -449,13 +449,15 @@ bool cdcd_control_xfer_cb(uint8_t rhport, uint8_t stage, const tusb_control_requ
   }
   TU_VERIFY(itf < CFG_TUD_CDC);
 
-  switch (request->bRequest) {
+  switch (request->bRequest) { //-V2520 //-V2659
     case CDC_REQUEST_SET_LINE_CODING:
       if (stage == CONTROL_STAGE_SETUP) {
         TU_LOG_DRV("  Set Line Coding\r\n");
         tud_control_xfer(rhport, request, &p_cdc->line_coding, sizeof(cdc_line_coding_t));
       } else if (stage == CONTROL_STAGE_ACK) {
         tud_cdc_line_coding_cb(itf, &p_cdc->line_coding);
+      } else {
+        // nothing to do
       }
       break;
 
@@ -491,6 +493,8 @@ bool cdcd_control_xfer_cb(uint8_t rhport, uint8_t stage, const tusb_control_requ
 
         // Invoke callback
         tud_cdc_line_state_cb(itf, dtr, rts);
+      } else {
+        // nothing to do
       }
       break;
 
@@ -500,7 +504,10 @@ bool cdcd_control_xfer_cb(uint8_t rhport, uint8_t stage, const tusb_control_requ
       } else if (stage == CONTROL_STAGE_ACK) {
         TU_LOG_DRV("  Send Break\r\n");
         tud_cdc_send_break_cb(itf, request->wValue);
+      } else {
+        // nothing to do
       }
+
       break;
 
     default:
@@ -558,7 +565,7 @@ bool cdcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_
     if (0 == tud_cdc_n_write_flush(itf)) {
       // If there is no data left, a ZLP should be sent if
       // xferred_bytes is multiple of EP Packet size and not zero
-      if (!tu_fifo_count(&p_cdc->tx_ff) && xferred_bytes && (0 == (xferred_bytes & (BULK_PACKET_SIZE - 1)))) {
+      if (0 == tu_fifo_count(&p_cdc->tx_ff) && xferred_bytes > 0 && (0 == (xferred_bytes & (BULK_PACKET_SIZE - 1)))) {
         if (usbd_edpt_claim(rhport, p_cdc->ep_in)) {
           TU_ASSERT(usbd_edpt_xfer(rhport, p_cdc->ep_in, NULL, 0, false));
         }
diff --git a/src/class/cdc/cdc_device.h b/src/class/cdc/cdc_device.h
index c321f3d16..6f21af4f3 100644
--- a/src/class/cdc/cdc_device.h
+++ b/src/class/cdc/cdc_device.h
@@ -53,15 +53,16 @@
 // Driver Configuration
 //--------------------------------------------------------------------+
 typedef struct TU_ATTR_PACKED {
-  uint8_t rx_persistent : 1; // keep rx fifo data even with bus reset or disconnect
-  uint8_t tx_persistent : 1; // keep tx fifo data even with reset or disconnect
-  uint8_t tx_overwritabe_if_not_connected : 1; // if not connected, tx fifo can be overwritten
+  bool rx_persistent : 1; // keep rx fifo data even with bus reset or disconnect
+  bool tx_persistent : 1; // keep tx fifo data even with reset or disconnect
+  bool tx_overwritabe_if_not_connected : 1; // if not connected, tx fifo can be overwritten
 } tud_cdc_configure_t;
+TU_VERIFY_STATIC(sizeof(tud_cdc_configure_t) == 1, "size is not correct");
 
 #define TUD_CDC_CONFIGURE_DEFAULT() { \
-  .rx_persistent = 0, \
-  .tx_persistent = 0, \
-  .tx_overwritabe_if_not_connected = 1, \
+  .rx_persistent = false, \
+  .tx_persistent = false, \
+  .tx_overwritabe_if_not_connected = true, \
 }
 
 // Configure CDC driver behavior
diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 3fc6a9adf..7fdf0a7b9 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -602,7 +602,7 @@ bool tuh_cdc_set_line_coding(uint8_t idx, cdc_line_coding_t const *line_coding,
   p_cdc->requested_line.coding = *line_coding;
   p_cdc->user_complete_cb = complete_cb;
 
-  if (driver->set_line_coding) {
+  if (driver->set_line_coding != NULL) {
     // driver support set_line_coding request
     TU_VERIFY(driver->set_line_coding(p_cdc, complete_cb ? cdch_internal_control_complete : NULL, user_data));
 
@@ -611,7 +611,7 @@ bool tuh_cdc_set_line_coding(uint8_t idx, cdc_line_coding_t const *line_coding,
     }
   } else {
     // driver does not support set_line_coding and need 2 stage to set baudrate and data format separately
-    if (complete_cb) {
+    if (complete_cb != NULL) {
       // non-blocking
       TU_VERIFY(driver->set_baudrate(p_cdc, cdch_set_line_coding_stage1_baudrate_complete, user_data));
     } else {
@@ -619,7 +619,7 @@ bool tuh_cdc_set_line_coding(uint8_t idx, cdc_line_coding_t const *line_coding,
       xfer_result_t result = XFER_RESULT_INVALID;
 
       TU_VERIFY(driver->set_baudrate(p_cdc, NULL, (uintptr_t) &result));
-      if (user_data) {
+      if (user_data != 0) {
         *((xfer_result_t *) user_data) = result;
       }
       TU_VERIFY(result == XFER_RESULT_SUCCESS);
@@ -627,7 +627,7 @@ bool tuh_cdc_set_line_coding(uint8_t idx, cdc_line_coding_t const *line_coding,
 
       result = XFER_RESULT_INVALID;
       TU_VERIFY(driver->set_data_format(p_cdc, NULL, (uintptr_t) &result));
-      if (user_data) {
+      if (user_data != 0) {
         *((xfer_result_t *) user_data) = result;
       }
       TU_VERIFY(result == XFER_RESULT_SUCCESS);
@@ -777,6 +777,8 @@ bool cdch_open(uint8_t rhport, uint8_t daddr, tusb_desc_interface_t const *itf_d
         }
       }
     }
+  } else {
+    // not supported class
   }
 
   return false;
@@ -894,7 +896,7 @@ static void cdch_internal_control_complete(tuh_xfer_t *xfer) {
 
   // Invoke application callback
   xfer->complete_cb = p_cdc->user_complete_cb;
-  if (xfer->complete_cb) {
+  if (xfer->complete_cb != NULL) {
     xfer->complete_cb(xfer);
   }
 }
@@ -910,7 +912,7 @@ static void cdch_set_line_coding_stage1_baudrate_complete(tuh_xfer_t *xfer) {
     TU_ASSERT(driver->set_data_format(p_cdc, cdch_set_line_coding_stage2_data_format_complete, xfer->user_data),);
   } else {
     xfer->complete_cb = p_cdc->user_complete_cb;
-    if (xfer->complete_cb) {
+    if (xfer->complete_cb != NULL) {
       xfer->complete_cb(xfer);
     }
   }
@@ -926,7 +928,7 @@ static void cdch_set_line_coding_stage2_data_format_complete(tuh_xfer_t *xfer) {
   }
 
   xfer->complete_cb = p_cdc->user_complete_cb;
-  if (xfer->complete_cb) {
+  if (xfer->complete_cb != NULL) {
     xfer->complete_cb(xfer);
   }
 }
@@ -950,12 +952,12 @@ static void acm_internal_control_complete(cdch_interface_t *p_cdc, tuh_xfer_t *x
       break;
 
     default:
-      break;
+      break; // unknown request
   }
 }
 
 static bool acm_set_control_line_state(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  TU_VERIFY(p_cdc->acm.capability.support_line_request);
+  TU_VERIFY(p_cdc->acm.capability.support_line_request != 0);
 
   const tusb_control_request_t request = {
     .bmRequestType_bit = {
@@ -982,7 +984,7 @@ static bool acm_set_control_line_state(cdch_interface_t *p_cdc, tuh_xfer_cb_t co
 }
 
 static bool acm_set_line_coding(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  TU_VERIFY(p_cdc->acm.capability.support_line_request);
+  TU_VERIFY(p_cdc->acm.capability.support_line_request != 0);
   TU_VERIFY((p_cdc->requested_line.coding.data_bits >= 5 && p_cdc->requested_line.coding.data_bits <= 8) ||
             p_cdc->requested_line.coding.data_bits == 16);
 
@@ -1167,10 +1169,10 @@ static bool ftdi_set_data_format(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete
 
 static bool ftdi_set_baudrate(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   uint32_t index_value = ftdi_get_divisor(p_cdc);
-  TU_VERIFY(index_value);
+  TU_VERIFY(index_value != 0);
   uint16_t value = (uint16_t) index_value;
   uint16_t index = (uint16_t) (index_value >> 16);
-  if (p_cdc->ftdi.channel) {
+  if (p_cdc->ftdi.channel != 0) {
     index = (uint16_t) ((index << 8) | p_cdc->ftdi.channel);
   }
 
@@ -1372,6 +1374,8 @@ static uint32_t ftdi_232bm_baud_base_to_divisor(uint32_t baud, uint32_t base) {
     divisor = 0;
   } else if (divisor == 0x4001) /* 1.5 */ {
     divisor = 1;
+  } else {
+    // nothing to do
   }
   return divisor;
 }
@@ -1395,12 +1399,13 @@ static uint32_t ftdi_2232h_baud_base_to_divisor(uint32_t baud, uint32_t base) {
     divisor = 0;
   } else if (divisor == 0x4001) /* 1.5 */ {
     divisor = 1;
+  } else {
+    // nothing to do
   }
-  /*
-   * Set this bit to turn off a divide by 2.5 on baud rate generator
+
+  /* Set this bit to turn off a divide by 2.5 on baud rate generator
    * This enables baud rates up to 12Mbaud but cannot reach below 1200
-   * baud with this bit set
-   */
+   * baud with this bit set */
   divisor |= 0x00020000;
   return divisor;
 }
@@ -1412,7 +1417,7 @@ static inline uint32_t ftdi_2232h_baud_to_divisor(uint32_t baud) {
 static inline uint32_t ftdi_get_divisor(cdch_interface_t *p_cdc) {
   uint32_t baud = p_cdc->requested_line.coding.bit_rate;
   uint32_t div_value = 0;
-  TU_VERIFY(baud);
+  TU_VERIFY(baud != 0);
 
   switch (p_cdc->ftdi.chip_type) {
     case FTDI_UNKNOWN:
@@ -1552,7 +1557,8 @@ static void cp210x_internal_control_complete(cdch_interface_t *p_cdc, tuh_xfer_t
       p_cdc->line.coding.bit_rate = p_cdc->requested_line.coding.bit_rate;
       break;
 
-    default: break;
+    default:
+      break; // unsupported request
   }
 }
 
@@ -1713,7 +1719,8 @@ static void ch34x_internal_control_complete(cdch_interface_t *p_cdc, tuh_xfer_t
           p_cdc->line.coding.data_bits = p_cdc->requested_line.coding.data_bits;
           break;
 
-        default: break;
+        default:
+          break; // unsupported
       }
       break;
 
@@ -1721,19 +1728,20 @@ static void ch34x_internal_control_complete(cdch_interface_t *p_cdc, tuh_xfer_t
       p_cdc->line.control_state = p_cdc->requested_line.control_state;
       break;
 
-    default: break;
+    default:
+      break; // unsupported request
   }
 }
 
 static bool ch34x_set_data_format(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   const uint8_t lcr = ch34x_get_lcr(p_cdc);
-  TU_VERIFY(lcr);
+  TU_VERIFY(lcr > 0);
   return ch34x_write_reg(p_cdc, CH32X_REG16_LCR2_LCR, lcr, complete_cb, user_data);
 }
 
 static bool ch34x_set_baudrate(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   const uint16_t div_ps = ch34x_get_divisor_prescaler(p_cdc);
-  TU_VERIFY(div_ps);
+  TU_VERIFY(div_ps > 0);
   return ch34x_write_reg(p_cdc, CH34X_REG16_DIVISOR_PRESCALER, div_ps, complete_cb, user_data);
 }
 
@@ -1916,7 +1924,8 @@ static uint8_t ch34x_get_lcr(cdch_interface_t *p_cdc) {
       lcr |= CH34X_LCR_ENABLE_PAR | CH34X_LCR_MARK_SPACE | CH34X_LCR_PAR_EVEN;
       break;
 
-    default: break;
+    default:
+      break; // invalid parity
   }
 
   // 1.5 stop bits not supported
@@ -1999,13 +2008,15 @@ static inline bool pl2303_supports_hx_status(cdch_interface_t *p_cdc, tuh_xfer_c
 //  return pl2303_set_request(p_cdc, PL2303_BREAK_REQUEST, PL2303_BREAK_REQUEST_TYPE, state, 0, NULL, 0);
 //}
 
-static inline int pl2303_clear_halt(cdch_interface_t *p_cdc, uint8_t endp, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+static inline bool
+pl2303_clear_halt(cdch_interface_t *p_cdc, uint8_t endp, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   /* we don't care if it wasn't halted first. in fact some devices
    * (like some ibmcam model 1 units) seem to expect hosts to make
    * this request for iso endpoints, which can't halt!
    */
-  return pl2303_set_request(p_cdc, TUSB_REQ_CLEAR_FEATURE, PL2303_CLEAR_HALT_REQUEST_TYPE, TUSB_REQ_FEATURE_EDPT_HALT, endp,
-                            NULL, 0, complete_cb, user_data);
+  return pl2303_set_request(
+      p_cdc, TUSB_REQ_CLEAR_FEATURE, PL2303_CLEAR_HALT_REQUEST_TYPE, TUSB_REQ_FEATURE_EDPT_HALT, endp, NULL, 0,
+      complete_cb, user_data);
 }
 
 //------------- Driver API -------------//
@@ -2130,10 +2141,9 @@ static bool pl2303_process_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer)
       if (type == PL2303_TYPE_NEED_SUPPORTS_HX_STATUS) {
         TU_ASSERT(pl2303_supports_hx_status(p_cdc, cdch_process_set_config, CONFIG_PL2303_READ1));
         break;
-      } else {
-        // no transfer triggered and continue with CONFIG_PL2303_READ1
-        TU_ATTR_FALLTHROUGH;
       }
+      // no transfer triggered and continue with CONFIG_PL2303_READ1
+      TU_ATTR_FALLTHROUGH;
 
     case CONFIG_PL2303_READ1:
       // get supports_hx_status, type and quirks (step 2), do special read
@@ -2378,10 +2388,12 @@ static pl2303_type_t pl2303_detect_type(cdch_interface_t *p_cdc, uint8_t step) {
           return PL2303_TYPE_HXN;
 
         default:
-          break;
+          break; // unknown device
       }
       break;
-    default: break;
+
+    default:
+      break; // unknown device
   }
 
   TU_LOG_CDC(p_cdc, "unknown device type bcdUSB = 0x%04x", desc_dev.bcdUSB);
@@ -2443,8 +2455,9 @@ static uint32_t pl2303_encode_baud_rate_divisor(uint8_t buf[PL2303_LINE_CODING_B
    */
   baseline = 12000000 * 32;
   mantissa = baseline / baud;
-  if (mantissa == 0)
+  if (mantissa == 0) {
     mantissa = 1; /* Avoid dividing by zero if baud > 32 * 12M. */
+  }
   exponent = 0;
   while (mantissa >= 512) {
     if (exponent < 7) {
@@ -2516,7 +2529,7 @@ static bool pl2303_encode_baud_rate(cdch_interface_t *p_cdc, uint8_t buf[PL2303_
    * Use direct method for supported baud rates, otherwise use divisors.
    * Newer chip types do not support divisor encoding.
    */
-  if (type_data->no_divisors) {
+  if (type_data->no_divisors != 0) {
     baud_sup = baud;
   } else {
     baud_sup = pl2303_get_supported_baud_rate(baud);
@@ -2524,7 +2537,7 @@ static bool pl2303_encode_baud_rate(cdch_interface_t *p_cdc, uint8_t buf[PL2303_
 
   if (baud == baud_sup) {
     baud = pl2303_encode_baud_rate_direct(buf, baud);
-  } else if (type_data->alt_divisors) {
+  } else if (type_data->alt_divisors != 0) {
     baud = pl2303_encode_baud_rate_divisor_alt(buf, baud);
   } else {
     baud = pl2303_encode_baud_rate_divisor(buf, baud);
diff --git a/src/class/msc/msc_device.c b/src/class/msc/msc_device.c
index b272c80c0..15bfafc35 100644
--- a/src/class/msc/msc_device.c
+++ b/src/class/msc/msc_device.c
@@ -83,7 +83,7 @@ typedef struct {
   uint8_t add_sense_code;
   uint8_t add_sense_qualifier;
 
-  uint8_t pending_io; // pending async IO
+  bool pending_io; // pending async IO
 }mscd_interface_t;
 
 static mscd_interface_t _mscd_itf;
@@ -92,6 +92,8 @@ CFG_TUD_MEM_SECTION static struct {
   TUD_EPBUF_DEF(buf, CFG_TUD_MSC_EP_BUFSIZE);
 } _mscd_epbuf;
 
+TU_VERIFY_STATIC(CFG_TUD_MSC_EP_BUFSIZE >= 64, "CFG_TUD_MSC_EP_BUFSIZE must be at least 64");
+
 //--------------------------------------------------------------------+
 // INTERNAL OBJECT & FUNCTION DECLARATION
 //--------------------------------------------------------------------+
@@ -107,16 +109,16 @@ TU_ATTR_ALWAYS_INLINE static inline bool is_data_in(uint8_t dir) {
   return tu_bit_test(dir, 7);
 }
 
-static inline bool send_csw(mscd_interface_t* p_msc) {
+TU_ATTR_ALWAYS_INLINE static inline bool send_csw(mscd_interface_t* p_msc) {
   // Data residue is always = host expect - actual transferred
   uint8_t rhport = p_msc->rhport;
   p_msc->csw.data_residue = p_msc->cbw.total_bytes - p_msc->xferred_len;
   p_msc->stage = MSC_STAGE_STATUS_SENT;
-  memcpy(_mscd_epbuf.buf, &p_msc->csw, sizeof(msc_csw_t));
+  memcpy(_mscd_epbuf.buf, &p_msc->csw, sizeof(msc_csw_t)); //-V1086
   return usbd_edpt_xfer(rhport, p_msc->ep_in , _mscd_epbuf.buf, sizeof(msc_csw_t), false);
 }
 
-static inline bool prepare_cbw(mscd_interface_t* p_msc) {
+TU_ATTR_ALWAYS_INLINE static inline bool prepare_cbw(mscd_interface_t* p_msc) {
   uint8_t rhport = p_msc->rhport;
   p_msc->stage = MSC_STAGE_CMD;
   return usbd_edpt_xfer(rhport, p_msc->ep_out,  _mscd_epbuf.buf, sizeof(msc_cbw_t), false);
@@ -133,7 +135,7 @@ static void fail_scsi_op(mscd_interface_t* p_msc, uint8_t status) {
 
   // failed but sense key is not set: default to Illegal Request
   if (p_msc->sense_key == 0) {
-    tud_msc_set_sense(p_cbw->lun, SCSI_SENSE_ILLEGAL_REQUEST, 0x20, 0x00);
+    (void) tud_msc_set_sense(p_cbw->lun, SCSI_SENSE_ILLEGAL_REQUEST, 0x20, 0x00);
   }
 
   // If there is data stage and not yet complete, stall it
@@ -146,18 +148,18 @@ static void fail_scsi_op(mscd_interface_t* p_msc, uint8_t status) {
   }
 }
 
-static inline uint32_t rdwr10_get_lba(uint8_t const command[]) {
+TU_ATTR_ALWAYS_INLINE static inline uint32_t rdwr10_get_lba(uint8_t const command[]) {
   // use offsetof to avoid pointer to the odd/unaligned address
   const uint32_t lba = tu_unaligned_read32(command + offsetof(scsi_write10_t, lba));
   return tu_ntohl(lba); // lba is in Big Endian
 }
 
-static inline uint16_t rdwr10_get_blockcount(msc_cbw_t const* cbw) {
+TU_ATTR_ALWAYS_INLINE static inline uint16_t rdwr10_get_blockcount(msc_cbw_t const* cbw) {
   uint16_t const block_count = tu_unaligned_read16(cbw->command + offsetof(scsi_write10_t, block_count));
   return tu_ntohs(block_count);
 }
 
-static inline uint16_t rdwr10_get_blocksize(msc_cbw_t const* cbw) {
+TU_ATTR_ALWAYS_INLINE static inline uint16_t rdwr10_get_blocksize(msc_cbw_t const* cbw) {
   // first extract block count in the command
   uint16_t const block_count = rdwr10_get_blockcount(cbw);
   if (block_count == 0) {
@@ -171,7 +173,7 @@ static uint8_t rdwr10_validate_cmd(msc_cbw_t const* cbw) {
   uint16_t const block_count = rdwr10_get_blockcount(cbw);
 
   if (cbw->total_bytes == 0) {
-    if (block_count) {
+    if (block_count > 0) {
       TU_LOG_DRV("  SCSI case 2 (Hn < Di) or case 3 (Hn < Do) \r\n");
       status = MSC_CSW_STATUS_PHASE_ERROR;
     } else {
@@ -190,6 +192,8 @@ static uint8_t rdwr10_validate_cmd(msc_cbw_t const* cbw) {
     } else if (cbw->total_bytes / block_count == 0) {
       TU_LOG_DRV(" Computed block size = 0. SCSI case 7 Hi < Di (READ10) or case 13 Ho < Do (WRIT10)\r\n");
       status = MSC_CSW_STATUS_PHASE_ERROR;
+    } else {
+      // nothing to do
     }
   }
 
@@ -309,7 +313,7 @@ bool tud_msc_set_sense(uint8_t lun, uint8_t sense_key, uint8_t add_sense_code, u
 
 TU_ATTR_ALWAYS_INLINE static inline void set_sense_medium_not_present(uint8_t lun) {
   // default sense is NOT READY, MEDIUM NOT PRESENT
-  tud_msc_set_sense(lun, SCSI_SENSE_NOT_READY, 0x3A, 0x00);
+  (void) tud_msc_set_sense(lun, SCSI_SENSE_NOT_READY, 0x3A, 0x00);
 }
 
 static void proc_async_io_done(void *bytes_io) {
@@ -318,7 +322,7 @@ static void proc_async_io_done(void *bytes_io) {
   const int32_t nbytes = (int32_t) (intptr_t) bytes_io;
   const uint8_t cmd = p_msc->cbw.command[0];
 
-  p_msc->pending_io = 0;
+  p_msc->pending_io = false;
   switch (cmd) {
     case SCSI_CMD_READ_10:
       proc_read_io_data(p_msc, nbytes);
@@ -328,7 +332,7 @@ static void proc_async_io_done(void *bytes_io) {
       proc_write_io_data(p_msc, (uint32_t) nbytes, nbytes);
       break;
 
-    default: break;
+    default: break; // nothing to do
   }
 
   // send status if stage is transitioned to STATUS
@@ -429,6 +433,8 @@ bool mscd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t
             TU_ASSERT(prepare_cbw(p_msc));
           }
         }
+      } else {
+        // nothing to do
       }
     }
 
@@ -451,7 +457,7 @@ bool mscd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t
       TU_VERIFY(request->wValue == 0 && request->wLength == 1);
 
       uint8_t maxlun = tud_msc_get_maxlun_cb();
-      TU_VERIFY(maxlun);
+      TU_VERIFY(maxlun != 0);
       maxlun--; // MAX LUN is minus 1 by specs
       tud_control_xfer(rhport, request, &maxlun, 1);
       break;
@@ -510,7 +516,7 @@ bool mscd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t event, uint32_t
 
         if (status != MSC_CSW_STATUS_PASSED) {
           fail_scsi_op(p_msc, status);
-        } else if (p_cbw->total_bytes) {
+        } else if (p_cbw->total_bytes > 0) {
           if (SCSI_CMD_READ_10 == p_cbw->command[0]) {
             proc_read10_cmd(p_msc);
           } else {
@@ -547,7 +553,7 @@ bool mscd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t event, uint32_t
             TU_LOG_DRV("  SCSI unsupported or failed command\r\n");
             fail_scsi_op(p_msc, MSC_CSW_STATUS_FAILED);
           } else if (resplen == 0) {
-            if (p_cbw->total_bytes) {
+            if (p_cbw->total_bytes > 0) {
               // 6.7 The 13 Cases: case 4 (Hi > Dn)
               // TU_LOG_DRV("  SCSI case 4 (Hi > Dn): %lu\r\n", p_cbw->total_bytes);
               fail_scsi_op(p_msc, MSC_CSW_STATUS_FAILED);
@@ -647,7 +653,7 @@ bool mscd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t event, uint32_t
       }
       break;
 
-    default: break;
+    default: break; // nothing to do
   }
 
   if (p_msc->stage == MSC_STAGE_STATUS) {
@@ -683,9 +689,8 @@ static int32_t proc_builtin_scsi(uint8_t lun, uint8_t const scsi_cmd[16], uint8_
       }
       break;
 
-    case SCSI_CMD_START_STOP_UNIT:
+    case SCSI_CMD_START_STOP_UNIT: {
       resplen = 0;
-
       scsi_start_stop_unit_t const* start_stop = (scsi_start_stop_unit_t const*)scsi_cmd;
       if (!tud_msc_start_stop_cb(lun, start_stop->power_condition, start_stop->start, start_stop->load_eject)) {
         // Failed status response
@@ -697,10 +702,10 @@ static int32_t proc_builtin_scsi(uint8_t lun, uint8_t const scsi_cmd[16], uint8_
         }
       }
       break;
+    }
 
-    case SCSI_CMD_PREVENT_ALLOW_MEDIUM_REMOVAL:
+    case SCSI_CMD_PREVENT_ALLOW_MEDIUM_REMOVAL: {
       resplen = 0;
-
       scsi_prevent_allow_medium_removal_t const* prevent_allow = (scsi_prevent_allow_medium_removal_t const*)scsi_cmd;
       if (!tud_msc_prevent_allow_medium_removal_cb(lun, prevent_allow->prohibit_removal, prevent_allow->control)) {
         // Failed status response
@@ -712,7 +717,7 @@ static int32_t proc_builtin_scsi(uint8_t lun, uint8_t const scsi_cmd[16], uint8_
         }
       }
       break;
-
+    }
 
     case SCSI_CMD_READ_CAPACITY_10: {
       uint32_t block_count;
@@ -740,8 +745,8 @@ static int32_t proc_builtin_scsi(uint8_t lun, uint8_t const scsi_cmd[16], uint8_
         resplen = sizeof(read_capa10);
         TU_VERIFY(0 == tu_memcpy_s(buffer, bufsize, &read_capa10, (size_t) resplen));
       }
+      break;
     }
-    break;
 
     case SCSI_CMD_READ_FORMAT_CAPACITY: {
       scsi_read_format_capacity_data_t read_fmt_capa = {
@@ -772,8 +777,8 @@ static int32_t proc_builtin_scsi(uint8_t lun, uint8_t const scsi_cmd[16], uint8_
         resplen = sizeof(read_fmt_capa);
         TU_VERIFY(0 == tu_memcpy_s(buffer, bufsize, &read_fmt_capa, (size_t) resplen));
       }
+      break;
     }
-    break;
 
     case SCSI_CMD_INQUIRY: {
       scsi_inquiry_resp_t *inquiry_rsp = (scsi_inquiry_resp_t *) buffer;
@@ -789,8 +794,8 @@ static int32_t proc_builtin_scsi(uint8_t lun, uint8_t const scsi_cmd[16], uint8_
         tud_msc_inquiry_cb(lun, inquiry_rsp->vendor_id, inquiry_rsp->product_id, inquiry_rsp->product_rev);
         resplen = sizeof(scsi_inquiry_resp_t);
       }
+      break;
     }
-    break;
 
     case SCSI_CMD_MODE_SENSE_6: {
       scsi_mode_sense6_resp_t mode_resp = {
@@ -807,8 +812,8 @@ static int32_t proc_builtin_scsi(uint8_t lun, uint8_t const scsi_cmd[16], uint8_
 
       resplen = sizeof(mode_resp);
       TU_VERIFY(0 == tu_memcpy_s(buffer, bufsize, &mode_resp, (size_t) resplen));
+      break;
     }
-    break;
 
     case SCSI_CMD_REQUEST_SENSE: {
       scsi_sense_fixed_resp_t sense_rsp = {
@@ -828,9 +833,9 @@ static int32_t proc_builtin_scsi(uint8_t lun, uint8_t const scsi_cmd[16], uint8_
       resplen = tud_msc_request_sense_cb(lun, buffer, (uint16_t)bufsize);
 
       // Clear sense data after copy
-      tud_msc_set_sense(lun, 0, 0, 0);
+      (void) tud_msc_set_sense(lun, 0, 0, 0);
+      break;
     }
-    break;
 
     default: resplen = -1;
       break;
@@ -842,6 +847,7 @@ static int32_t proc_builtin_scsi(uint8_t lun, uint8_t const scsi_cmd[16], uint8_
 static void proc_read10_cmd(mscd_interface_t* p_msc) {
   msc_cbw_t const* p_cbw = &p_msc->cbw;
   uint16_t const block_sz = rdwr10_get_blocksize(p_cbw); // already verified non-zero
+  TU_VERIFY(block_sz != 0, );
   // Adjust lba & offset with transferred bytes
   uint32_t const lba = rdwr10_get_lba(p_cbw->command) + (p_msc->xferred_len / block_sz);
   uint32_t const offset = p_msc->xferred_len % block_sz;
@@ -849,10 +855,10 @@ static void proc_read10_cmd(mscd_interface_t* p_msc) {
   // remaining bytes capped at class buffer
   int32_t nbytes = (int32_t)tu_min32(CFG_TUD_MSC_EP_BUFSIZE, p_cbw->total_bytes - p_msc->xferred_len);
 
-  p_msc->pending_io = 1;
+  p_msc->pending_io = true;
   nbytes = tud_msc_read10_cb(p_cbw->lun, lba, offset, _mscd_epbuf.buf, (uint32_t)nbytes);
   if (nbytes != TUD_MSC_RET_ASYNC) {
-    p_msc->pending_io = 0;
+    p_msc->pending_io = false;
     proc_read_io_data(p_msc, nbytes);
   }
 }
@@ -876,19 +882,19 @@ static void proc_read_io_data(mscd_interface_t* p_msc, int32_t nbytes) {
         dcd_event_xfer_complete(rhport, p_msc->ep_in, 0, XFER_RESULT_SUCCESS, false);
         break;
 
-      default: break;
+      default: break; // nothing to do
     }
   }
 }
 
 static void proc_write10_cmd(mscd_interface_t* p_msc) {
   msc_cbw_t const* p_cbw = &p_msc->cbw;
-  bool writable = tud_msc_is_writable_cb(p_cbw->lun);
+  const bool writable = tud_msc_is_writable_cb(p_cbw->lun);
 
   if (!writable) {
     // Not writable, complete this SCSI op with error
     // Sense = Write protected
-    tud_msc_set_sense(p_cbw->lun, SCSI_SENSE_DATA_PROTECT, 0x27, 0x00);
+    (void) tud_msc_set_sense(p_cbw->lun, SCSI_SENSE_DATA_PROTECT, 0x27, 0x00);
     fail_scsi_op(p_msc, MSC_CSW_STATUS_FAILED);
     return;
   }
@@ -903,15 +909,16 @@ static void proc_write10_cmd(mscd_interface_t* p_msc) {
 static void proc_write10_host_data(mscd_interface_t* p_msc, uint32_t xferred_bytes) {
   msc_cbw_t const* p_cbw = &p_msc->cbw;
   uint16_t const block_sz = rdwr10_get_blocksize(p_cbw); // already verified non-zero
+  TU_VERIFY(block_sz != 0, );
 
   // Adjust lba & offset with transferred bytes
   uint32_t const lba = rdwr10_get_lba(p_cbw->command) + (p_msc->xferred_len / block_sz);
   uint32_t const offset = p_msc->xferred_len % block_sz;
 
-  p_msc->pending_io = 1;
+  p_msc->pending_io = true;
   int32_t nbytes =  tud_msc_write10_cb(p_cbw->lun, lba, offset, _mscd_epbuf.buf, xferred_bytes);
   if (nbytes != TUD_MSC_RET_ASYNC) {
-    p_msc->pending_io = 0;
+    p_msc->pending_io = false;
     proc_write_io_data(p_msc, xferred_bytes, nbytes);
   }
 }
@@ -927,7 +934,7 @@ static void proc_write_io_data(mscd_interface_t* p_msc, uint32_t xferred_bytes,
         fail_scsi_op(p_msc, MSC_CSW_STATUS_FAILED);
         break;
 
-      default: break;
+      default: break; // nothing to do
     }
   } else {
     if ((uint32_t)nbytes < xferred_bytes) {
diff --git a/src/class/msc/msc_host.c b/src/class/msc/msc_host.c
index eb69ae400..daff345c5 100644
--- a/src/class/msc/msc_host.c
+++ b/src/class/msc/msc_host.c
@@ -123,7 +123,10 @@ bool tuh_msc_mounted(uint8_t dev_addr) {
 
 bool tuh_msc_ready(uint8_t dev_addr) {
   msch_interface_t* p_msc = get_itf(dev_addr);
-  return p_msc->mounted && !usbh_edpt_busy(dev_addr, p_msc->ep_in) && !usbh_edpt_busy(dev_addr, p_msc->ep_out);
+  TU_VERIFY(p_msc->mounted);
+  const bool epin_busy = usbh_edpt_busy(dev_addr, p_msc->ep_in);
+  const bool epout_busy = usbh_edpt_busy(dev_addr, p_msc->ep_out);
+  return !epin_busy && !epout_busy;
 }
 
 //--------------------------------------------------------------------+
@@ -152,7 +155,7 @@ bool tuh_msc_scsi_command(uint8_t daddr, msc_cbw_t const* cbw, void* data,
   p_msc->stage = MSC_STAGE_CMD;
 
   if (!usbh_edpt_xfer(daddr, p_msc->ep_out, (uint8_t*) &epbuf->cbw, sizeof(msc_cbw_t))) {
-    usbh_edpt_release(daddr, p_msc->ep_out);
+    (void) usbh_edpt_release(daddr, p_msc->ep_out);
     return false;
   }
 
@@ -191,7 +194,7 @@ bool tuh_msc_inquiry(uint8_t dev_addr, uint8_t lun, scsi_inquiry_resp_t* respons
       .cmd_code     = SCSI_CMD_INQUIRY,
       .alloc_length = sizeof(scsi_inquiry_resp_t)
   };
-  memcpy(cbw.command, &cmd_inquiry, cbw.cmd_len);
+  memcpy(cbw.command, &cmd_inquiry, cbw.cmd_len); //-V1086
 
   return tuh_msc_scsi_command(dev_addr, &cbw, response, complete_cb, arg);
 }
@@ -225,7 +228,7 @@ bool tuh_msc_request_sense(uint8_t dev_addr, uint8_t lun, void* response,
       .cmd_code     = SCSI_CMD_REQUEST_SENSE,
       .alloc_length = 18
   };
-  memcpy(cbw.command, &cmd_request_sense, cbw.cmd_len);
+  memcpy(cbw.command, &cmd_request_sense, cbw.cmd_len); //-V1086
 
   return tuh_msc_scsi_command(dev_addr, &cbw, response, complete_cb, arg);
 }
@@ -247,7 +250,7 @@ bool tuh_msc_read10(uint8_t dev_addr, uint8_t lun, void* buffer, uint32_t lba, u
       .lba         = tu_htonl(lba),
       .block_count = tu_htons(block_count)
   };
-  memcpy(cbw.command, &cmd_read10, cbw.cmd_len);
+  memcpy(cbw.command, &cmd_read10, cbw.cmd_len); //-V1086
 
   return tuh_msc_scsi_command(dev_addr, &cbw, buffer, complete_cb, arg);
 }
@@ -269,7 +272,7 @@ bool tuh_msc_write10(uint8_t dev_addr, uint8_t lun, void const* buffer, uint32_t
       .lba         = tu_htonl(lba),
       .block_count = tu_htons(block_count)
   };
-  memcpy(cbw.command, &cmd_write10, cbw.cmd_len);
+  memcpy(cbw.command, &cmd_write10, cbw.cmd_len); //-V1086
 
   return tuh_msc_scsi_command(dev_addr, &cbw, (void*) (uintptr_t) buffer, complete_cb, arg);
 }
@@ -338,8 +341,7 @@ bool msch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32
         TU_ASSERT(usbh_edpt_xfer(dev_addr, ep_data, p_msc->buffer, (uint16_t) cbw->total_bytes));
         break;
       }
-
-      TU_ATTR_FALLTHROUGH; // fallthrough to status stage
+      TU_ATTR_FALLTHROUGH; // fallthrough to data stage
 
     case MSC_STAGE_DATA:
       // Status stage
@@ -350,20 +352,19 @@ bool msch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32
     case MSC_STAGE_STATUS:
       // SCSI op is complete
       p_msc->stage = MSC_STAGE_IDLE;
-
-      if (p_msc->complete_cb) {
+      if (p_msc->complete_cb != NULL) {
         tuh_msc_complete_data_t const cb_data = {
             .cbw = cbw,
             .csw = csw,
             .scsi_data = p_msc->buffer,
             .user_arg = p_msc->complete_arg
         };
-        p_msc->complete_cb(dev_addr, &cb_data);
+        (void) p_msc->complete_cb(dev_addr, &cb_data);
       }
       break;
 
-      // unknown state
     default:
+      // unknown state
       break;
   }
 
@@ -501,7 +502,7 @@ static bool config_read_capacity_complete(uint8_t dev_addr, tuh_msc_complete_dat
 
   // Capacity response field: Block size and Last LBA are both Big-Endian
   scsi_read_capacity10_resp_t* resp = (scsi_read_capacity10_resp_t*) (uintptr_t) enum_buf;
-  p_msc->capacity[cbw->lun].block_count = tu_ntohl(resp->last_lba) + 1;
+  p_msc->capacity[cbw->lun].block_count = (uint32_t) (tu_ntohl(resp->last_lba) + 1u);
   p_msc->capacity[cbw->lun].block_size  = tu_ntohl(resp->block_size);
 
   // Mark enumeration is complete
diff --git a/src/class/mtp/mtp.h b/src/class/mtp/mtp.h
index 40b6dd8b0..236cf98e0 100644
--- a/src/class/mtp/mtp.h
+++ b/src/class/mtp/mtp.h
@@ -799,18 +799,18 @@ TU_ATTR_ALWAYS_INLINE static inline uint32_t mtp_container_add_array(mtp_contain
 
 TU_ATTR_ALWAYS_INLINE static inline uint32_t mtp_container_add_string(mtp_container_info_t* p_container, uint16_t* utf16) {
   uint8_t count = 0;
-  while (utf16[count]) {
+  while (utf16[count] != 0u) {
     count++;
   }
-  const uint32_t added_len = 1u + 2u * count;
+  const uint32_t added_len = 1u + (uint32_t) count * 2u;
   TU_ASSERT(p_container->header->len + added_len < CFG_TUD_MTP_EP_BUFSIZE, 0);
   uint8_t* buf = p_container->payload + p_container->header->len - sizeof(mtp_container_header_t);
 
   *buf++ = count;
   p_container->header->len++;
 
-  memcpy(buf, utf16, 2 * count);
-  p_container->header->len += 2 * count;
+  memcpy(buf, utf16, 2u * (uint32_t) count);
+  p_container->header->len += 2u * count;
 
   return added_len;
 }
@@ -824,7 +824,7 @@ TU_ATTR_ALWAYS_INLINE static inline uint32_t mtp_container_add_cstring(mtp_conta
     // empty string (null only): single zero byte
     *buf = 0;
     p_container->header->len++;
-    return 1;
+    return 1u;
   } else {
     *buf++ = len;
     p_container->header->len++;
@@ -875,8 +875,8 @@ TU_ATTR_ALWAYS_INLINE static inline uint32_t mtp_container_add_auint32(mtp_conta
 //
 //--------------------------------------------------------------------+
 TU_ATTR_ALWAYS_INLINE static inline uint32_t mtp_container_get_string(uint8_t* buf, uint16_t utf16[]) {
-  uint8_t nchars = *buf++;
-  memcpy(utf16, buf, 2 * nchars);
+  size_t nchars = *buf++;
+  memcpy(utf16, buf, 2u * nchars);
   return 1u + 2u * nchars;
 }
 
diff --git a/src/class/mtp/mtp_device.h b/src/class/mtp/mtp_device.h
index 397fbbbce..a33f1dc08 100644
--- a/src/class/mtp/mtp_device.h
+++ b/src/class/mtp/mtp_device.h
@@ -53,12 +53,14 @@ typedef struct {
 typedef struct {
   uint8_t idx;
   uint8_t stage; // control stage
-  uint32_t session_id;
 
-  const tusb_control_request_t* request;
   // buffer for data stage
-  uint8_t* buf;
   uint16_t bufsize;
+  uint8_t* buf;
+
+  const tusb_control_request_t* request;
+
+  uint32_t session_id;
 } tud_mtp_request_cb_data_t;
 
 // Number of supported operations, events, device properties, capture formats, playback formats
@@ -78,7 +80,7 @@ typedef struct {
     /* string fields will be added using append function */ \
   }
 
-typedef MTP_DEVICE_INFO_STRUCT(
+typedef MTP_DEVICE_INFO_STRUCT( //-V2586 [MISRA-C-18.7] Flexible array members should not be declared
   sizeof(CFG_TUD_MTP_DEVICEINFO_EXTENSIONS), TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_SUPPORTED_OPERATIONS),
   TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_SUPPORTED_EVENTS), TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_SUPPORTED_DEVICE_PROPERTIES),
   TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_CAPTURE_FORMATS), TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_PLAYBACK_FORMATS)
diff --git a/src/class/net/ncm_device.c b/src/class/net/ncm_device.c
index 335f6ad09..3e19b5f3a 100644
--- a/src/class/net/ncm_device.c
+++ b/src/class/net/ncm_device.c
@@ -50,10 +50,6 @@
 
 #if (CFG_TUD_ENABLED && CFG_TUD_NCM)
 
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-
 #include "device/usbd.h"
 #include "device/usbd_pvt.h"
 
diff --git a/src/class/video/video.h b/src/class/video/video.h
index f348e187b..5bdf4b840 100644
--- a/src/class/video/video.h
+++ b/src/class/video/video.h
@@ -219,11 +219,11 @@ typedef enum {
     uint8_t  baInterfaceNr[_nitf]; \
   }
 
-typedef tusb_desc_video_control_header_nitf_t()  tusb_desc_video_control_header_t;
-typedef tusb_desc_video_control_header_nitf_t(1) tusb_desc_video_control_header_1itf_t;
-typedef tusb_desc_video_control_header_nitf_t(2) tusb_desc_video_control_header_2itf_t;
-typedef tusb_desc_video_control_header_nitf_t(3) tusb_desc_video_control_header_3itf_t;
-typedef tusb_desc_video_control_header_nitf_t(4) tusb_desc_video_control_header_4itf_t;
+typedef tusb_desc_video_control_header_nitf_t()  tusb_desc_video_control_header_t; //-V2586 incorrectly detected as flexible array
+typedef tusb_desc_video_control_header_nitf_t(1) tusb_desc_video_control_header_1itf_t; //-V2586 incorrectly detected as flexible array
+typedef tusb_desc_video_control_header_nitf_t(2) tusb_desc_video_control_header_2itf_t; //-V2586 incorrectly detected as flexible array
+typedef tusb_desc_video_control_header_nitf_t(3) tusb_desc_video_control_header_3itf_t; //-V2586 incorrectly detected as flexible array
+typedef tusb_desc_video_control_header_nitf_t(4) tusb_desc_video_control_header_4itf_t; //-V2586 incorrectly detected as flexible array
 
 typedef struct TU_ATTR_PACKED {
   uint8_t  bLength;
diff --git a/src/class/video/video_device.c b/src/class/video/video_device.c
index 2c610c469..85e85e75e 100644
--- a/src/class/video/video_device.c
+++ b/src/class/video/video_device.c
@@ -103,7 +103,7 @@ typedef struct TU_ATTR_PACKED {
   uint8_t index_vc;  /* index of bound video control interface */
   uint8_t index_vs;  /* index from the video control interface */
   struct {
-    uint16_t beg;    /* Offset of the begging of video streaming interface descriptor */
+    uint16_t beg;    /* Offset of the beginning of video streaming interface descriptor */
     uint16_t end;    /* Offset of the end of video streaming interface descriptor */
     uint16_t cur;    /* Offset of the current settings */
     uint16_t ep[2];  /* Offset of endpoint descriptors. 0: streaming, 1: still capture */
@@ -244,9 +244,13 @@ static inline uint8_t _desc_ep_addr(void const *desc) {
  * @return instance */
 static videod_streaming_interface_t* _get_instance_streaming(uint_fast8_t ctl_idx, uint_fast8_t stm_idx) {
   videod_interface_t *ctl = &_videod_itf[ctl_idx];
-  if (!ctl->beg) return NULL;
+  if (!ctl->beg) {
+    return NULL;
+  }
   videod_streaming_interface_t *stm = &_videod_streaming_itf[ctl->stm[stm_idx]];
-  if (!stm->desc.beg) return NULL;
+  if (!stm->desc.beg) {
+    return NULL;
+  }
   return stm;
 }
 
@@ -255,7 +259,9 @@ static tusb_desc_vc_itf_t const* _get_desc_vc(videod_interface_t const *self) {
 }
 
 static tusb_desc_vs_itf_t const* _get_desc_vs(videod_streaming_interface_t const *self) {
-  if (!self->desc.cur) return NULL;
+  if (!self->desc.cur) {
+    return NULL;
+  }
   uint8_t const *desc = _videod_itf[self->index_vc].beg;
   return (tusb_desc_vs_itf_t const*)(desc + self->desc.cur);
 }
@@ -366,8 +372,12 @@ static void const* _find_desc_ep(void const *beg, void const *end)
 {
   for (void const *cur = beg; cur < end; cur = tu_desc_next(cur)) {
     uint_fast8_t desc_type = tu_desc_type(cur);
-    if (TUSB_DESC_ENDPOINT == desc_type) return cur;
-    if (TUSB_DESC_INTERFACE == desc_type) break;
+    if (TUSB_DESC_ENDPOINT == desc_type) {
+      return cur;
+    }
+    if (TUSB_DESC_INTERFACE == desc_type) {
+      break;
+    }
   }
   return end;
 }
@@ -453,8 +463,10 @@ static bool _update_streaming_parameters(videod_streaming_interface_t const *stm
   tusb_desc_vs_itf_t const *vs = _get_desc_vs(stm);
   uint_fast8_t fmtnum = param->bFormatIndex;
   TU_ASSERT(vs && fmtnum <= vs->stm.bNumFormats);
-  if (!fmtnum) {
-    if (1 < vs->stm.bNumFormats) return true; /* Need to negotiate all variables. */
+  if (0 == fmtnum) {
+    if (1 < vs->stm.bNumFormats) {
+      return true; /* Need to negotiate all variables. */
+    }
     fmtnum = 1;
     param->bFormatIndex = 1;
   }
@@ -492,8 +504,10 @@ static bool _update_streaming_parameters(videod_streaming_interface_t const *stm
 
   uint_fast8_t frmnum = param->bFrameIndex;
   TU_ASSERT(frmnum <= fmt->bNumFrameDescriptors);
-  if (!frmnum) {
-    if (1 < fmt->bNumFrameDescriptors) return true;
+  if (0 == frmnum) {
+    if (1 < fmt->bNumFrameDescriptors) {
+      return true;
+    }
     frmnum = 1;
     param->bFrameIndex = 1;
   }
@@ -502,7 +516,7 @@ static bool _update_streaming_parameters(videod_streaming_interface_t const *stm
 
   /* Set the parameters determined by the frame  */
   uint_fast32_t frame_size = param->dwMaxVideoFrameSize;
-  if (!frame_size) {
+  if (0 == frame_size) {
     switch (fmt->bDescriptorSubType) {
       case VIDEO_CS_ITF_VS_FORMAT_UNCOMPRESSED:
         frame_size = (uint_fast32_t)frm->wWidth * frm->wHeight * fmt->uncompressed.bBitsPerPixel / 8;
@@ -522,7 +536,7 @@ static bool _update_streaming_parameters(videod_streaming_interface_t const *stm
   }
 
   uint_fast32_t interval = param->dwFrameInterval;
-  if (!interval) {
+  if (0 == interval) {
     if ((1 < frm->uncompressed.bFrameIntervalType) ||
         ((0 == frm->uncompressed.bFrameIntervalType) &&
          (frm->uncompressed.dwFrameInterval[1] != frm->uncompressed.dwFrameInterval[0]))) {
@@ -532,7 +546,7 @@ static bool _update_streaming_parameters(videod_streaming_interface_t const *stm
     param->dwFrameInterval = interval;
   }
   uint_fast32_t interval_ms = interval / 10000;
-  TU_ASSERT(interval_ms);
+  TU_ASSERT(interval_ms != 0);
   uint_fast32_t payload_size = (frame_size + interval_ms - 1) / interval_ms + 2;
   if (CFG_TUD_VIDEO_STREAMING_EP_BUFSIZE < payload_size) {
     payload_size = CFG_TUD_VIDEO_STREAMING_EP_BUFSIZE;
@@ -550,7 +564,7 @@ static bool _negotiate_streaming_parameters(videod_streaming_interface_t const *
                                             video_probe_and_commit_control_t *param)
 {
   uint_fast8_t const fmtnum = param->bFormatIndex;
-  if (!fmtnum) {
+  if (0 == fmtnum) {
     switch (request) {
       case VIDEO_REQUEST_GET_MAX:
         if (_get_desc_vs(stm))
@@ -581,7 +595,7 @@ static bool _negotiate_streaming_parameters(videod_streaming_interface_t const *
   }
 
   uint_fast8_t frmnum = param->bFrameIndex;
-  if (!frmnum) {
+  if (0 == frmnum) {
     tusb_desc_vs_itf_t const *vs = _get_desc_vs(stm);
     TU_ASSERT(vs);
     void const *end = _end_of_streaming_descriptor(vs);
@@ -637,7 +651,7 @@ static bool _negotiate_streaming_parameters(videod_streaming_interface_t const *
     return true;
   }
 
-  if (!param->dwFrameInterval) {
+  if (0 == param->dwFrameInterval) {
     tusb_desc_vs_itf_t const *vs = _get_desc_vs(stm);
     TU_ASSERT(vs);
     void const *end = _end_of_streaming_descriptor(vs);
@@ -686,12 +700,12 @@ static bool _negotiate_streaming_parameters(videod_streaming_interface_t const *
       default: return false;
     }
     param->dwFrameInterval = interval;
-    if (!interval) {
+    if (0 == interval) {
       param->dwMaxPayloadTransferSize = 0;
     } else {
       uint_fast32_t frame_size = param->dwMaxVideoFrameSize;
       uint_fast32_t payload_size;
-      if (!interval_ms) {
+      if (0 == interval_ms) {
         payload_size = frame_size + 2;
       } else {
         payload_size = (frame_size + interval_ms - 1) / interval_ms + 2;
@@ -719,7 +733,7 @@ static bool _close_vc_itf(uint8_t rhport, videod_interface_t *self)
 
   /* The end of the video control interface descriptor. */
   void const *end = _end_of_control_descriptor(vc);
-  if (vc->std.bNumEndpoints) {
+  if (vc->std.bNumEndpoints != 0) {
     /* Find the notification endpoint descriptor. */
     cur = _find_desc(cur, end, TUSB_DESC_ENDPOINT);
     TU_ASSERT(cur < end);
@@ -757,7 +771,7 @@ static bool _open_vc_itf(uint8_t rhport, videod_interface_t *self, uint_fast8_t
   cur += vc->std.bLength + vc->ctl.bLength;
   TU_LOG_DRV("    bNumEndpoints %d\r\n", vc->std.bNumEndpoints);
   /* Open the notification endpoint if it exist. */
-  if (vc->std.bNumEndpoints) {
+  if (vc->std.bNumEndpoints != 0) {
     /* Support for 1 endpoint only. */
     TU_VERIFY(1 == vc->std.bNumEndpoints);
     /* Find the notification endpoint descriptor. */
@@ -843,7 +857,7 @@ static bool _open_vs_itf(uint8_t rhport, videod_streaming_interface_t *stm, uint
     stm->desc.ep[i] = (uint16_t) (cur - desc);
     TU_LOG_DRV("    open EP%02x\r\n", _desc_ep_addr(cur));
   }
-  if (altnum) {
+  if (altnum != 0) {
     stm->state = VS_STATE_STREAMING;
   }
   TU_LOG_DRV("    done\r\n");
@@ -929,16 +943,14 @@ static int handle_video_ctl_cs_req(uint8_t rhport, uint8_t stage,
           return VIDEO_ERROR_NONE;
 
         case VIDEO_REQUEST_GET_CUR:
-          if (stage == CONTROL_STAGE_SETUP)
-          {
+          if (stage == CONTROL_STAGE_SETUP) {
             TU_VERIFY(1 == request->wLength, VIDEO_ERROR_UNKNOWN);
             TU_VERIFY(tud_control_xfer(rhport, request, &self->power_mode, sizeof(self->power_mode)), VIDEO_ERROR_UNKNOWN);
           }
           return VIDEO_ERROR_NONE;
 
         case VIDEO_REQUEST_GET_INFO:
-          if (stage == CONTROL_STAGE_SETUP)
-          {
+          if (stage == CONTROL_STAGE_SETUP) {
             TU_VERIFY(1 == request->wLength, VIDEO_ERROR_UNKNOWN);
             TU_VERIFY(tud_control_xfer(rhport, request, (uint8_t*)(uintptr_t) &_cap_get_set, sizeof(_cap_get_set)), VIDEO_ERROR_UNKNOWN);
           }
@@ -951,15 +963,13 @@ static int handle_video_ctl_cs_req(uint8_t rhport, uint8_t stage,
     case VIDEO_VC_CTL_REQUEST_ERROR_CODE:
       switch (request->bRequest) {
         case VIDEO_REQUEST_GET_CUR:
-          if (stage == CONTROL_STAGE_SETUP)
-          {
+          if (stage == CONTROL_STAGE_SETUP) {
             TU_VERIFY(tud_control_xfer(rhport, request, &self->error_code, sizeof(uint8_t)), VIDEO_ERROR_UNKNOWN);
           }
           return VIDEO_ERROR_NONE;
 
         case VIDEO_REQUEST_GET_INFO:
-          if (stage == CONTROL_STAGE_SETUP)
-          {
+          if (stage == CONTROL_STAGE_SETUP) {
             TU_VERIFY(tud_control_xfer(rhport, request, (uint8_t*)(uintptr_t) &_cap_get, sizeof(_cap_get)), VIDEO_ERROR_UNKNOWN);
           }
           return VIDEO_ERROR_NONE;
@@ -986,7 +996,7 @@ static int handle_video_ctl_req(uint8_t rhport, uint8_t stage,
 
     case TUSB_REQ_TYPE_CLASS: {
       uint_fast8_t entity_id = TU_U16_HIGH(request->wIndex);
-      if (!entity_id) {
+      if (0 == entity_id) {
         return handle_video_ctl_cs_req(rhport, stage, request, ctl_idx);
       } else {
         TU_VERIFY(_find_desc_entity(_get_desc_vc(&_videod_itf[ctl_idx]), entity_id), VIDEO_ERROR_INVALID_REQUEST);
@@ -1001,14 +1011,12 @@ static int handle_video_ctl_req(uint8_t rhport, uint8_t stage,
 
 static int handle_video_stm_std_req(uint8_t rhport, uint8_t stage,
                                     tusb_control_request_t const *request,
-                                    uint_fast8_t stm_idx)
-{
+                                    uint_fast8_t stm_idx) {
   TU_LOG_DRV("\r\n");
   videod_streaming_interface_t *self = &_videod_streaming_itf[stm_idx];
   switch (request->bRequest) {
     case TUSB_REQ_GET_INTERFACE:
-      if (stage == CONTROL_STAGE_SETUP)
-      {
+      if (stage == CONTROL_STAGE_SETUP) {
         TU_VERIFY(1 == request->wLength, VIDEO_ERROR_UNKNOWN);
         tusb_desc_vs_itf_t const *vs = _get_desc_vs(self);
         TU_VERIFY(vs, VIDEO_ERROR_UNKNOWN);
@@ -1075,12 +1083,14 @@ static int handle_video_stm_cs_req(uint8_t rhport, uint8_t stage,
           } else if (stage == CONTROL_STAGE_DATA) {
             TU_VERIFY(_update_streaming_parameters(stm, &stm->probe_commit_payload),
                       VIDEO_ERROR_INVALID_VALUE_WITHIN_RANGE);
+          } else {
+            // nothing to do
           }
           return VIDEO_ERROR_NONE;
 
         case VIDEO_REQUEST_GET_CUR:
           if (stage == CONTROL_STAGE_SETUP) {
-            TU_VERIFY(request->wLength, VIDEO_ERROR_UNKNOWN);
+            TU_VERIFY(request->wLength != 0, VIDEO_ERROR_UNKNOWN);
             TU_VERIFY(tud_control_xfer(rhport, request, &stm->probe_commit_payload, sizeof(video_probe_and_commit_control_t)), VIDEO_ERROR_UNKNOWN);
           }
           return VIDEO_ERROR_NONE;
@@ -1090,7 +1100,7 @@ static int handle_video_stm_cs_req(uint8_t rhport, uint8_t stage,
         case VIDEO_REQUEST_GET_RES:
         case VIDEO_REQUEST_GET_DEF:
           if (stage == CONTROL_STAGE_SETUP) {
-            TU_VERIFY(request->wLength, VIDEO_ERROR_UNKNOWN);
+            TU_VERIFY(request->wLength != 0, VIDEO_ERROR_UNKNOWN);
             video_probe_and_commit_control_t tmp = stm->probe_commit_payload;
             TU_VERIFY(_negotiate_streaming_parameters(stm, request->bRequest, &tmp), VIDEO_ERROR_INVALID_VALUE_WITHIN_RANGE);
             TU_VERIFY(tud_control_xfer(rhport, request, &tmp, sizeof(tmp)), VIDEO_ERROR_UNKNOWN);
@@ -1137,12 +1147,14 @@ static int handle_video_stm_cs_req(uint8_t rhport, uint8_t stage,
               hdr->bHeaderLength = sizeof(*hdr);
               hdr->bmHeaderInfo  = 0;
             }
+          } else {
+            // nothing to do
           }
           return VIDEO_ERROR_NONE;
 
         case VIDEO_REQUEST_GET_CUR:
           if (stage == CONTROL_STAGE_SETUP) {
-            TU_VERIFY(request->wLength, VIDEO_ERROR_UNKNOWN);
+            TU_VERIFY(request->wLength != 0, VIDEO_ERROR_UNKNOWN);
             TU_VERIFY(tud_control_xfer(rhport, request, &stm->probe_commit_payload, sizeof(video_probe_and_commit_control_t)), VIDEO_ERROR_UNKNOWN);
           }
           return VIDEO_ERROR_NONE;
@@ -1185,14 +1197,15 @@ static int handle_video_stm_cs_req(uint8_t rhport, uint8_t stage,
 
 static int handle_video_stm_req(uint8_t rhport, uint8_t stage,
                                 tusb_control_request_t const *request,
-                                uint_fast8_t stm_idx)
-{
+                                uint_fast8_t stm_idx) {
   switch (request->bmRequestType_bit.type) {
     case TUSB_REQ_TYPE_STANDARD:
       return handle_video_stm_std_req(rhport, stage, request, stm_idx);
 
     case TUSB_REQ_TYPE_CLASS:
-      if (TU_U16_HIGH(request->wIndex)) return VIDEO_ERROR_INVALID_REQUEST;
+      if (0 != TU_U16_HIGH(request->wIndex)) {
+        return VIDEO_ERROR_INVALID_REQUEST;
+      }
       return handle_video_stm_cs_req(rhport, stage, request, stm_idx);
 
     default: return VIDEO_ERROR_INVALID_REQUEST;
@@ -1203,11 +1216,12 @@ static int handle_video_stm_req(uint8_t rhport, uint8_t stage,
 // APPLICATION API
 //--------------------------------------------------------------------+
 
-bool tud_video_n_connected(uint_fast8_t ctl_idx)
-{
+bool tud_video_n_connected(uint_fast8_t ctl_idx) {
   TU_ASSERT(ctl_idx < CFG_TUD_VIDEO);
   videod_streaming_interface_t *stm = _get_instance_streaming(ctl_idx, 0);
-  if (stm) return true;
+  if (stm != NULL) {
+    return true;
+  }
   return false;
 }
 
@@ -1216,15 +1230,21 @@ bool tud_video_n_streaming(uint_fast8_t ctl_idx, uint_fast8_t stm_idx)
   TU_ASSERT(ctl_idx < CFG_TUD_VIDEO);
   TU_ASSERT(stm_idx < CFG_TUD_VIDEO_STREAMING);
   videod_streaming_interface_t *stm = _get_instance_streaming(ctl_idx, stm_idx);
-  if (!stm || !stm->desc.ep[0]) return false;
-  if (stm->state == VS_STATE_PROBING) return false;
+  if (NULL == stm || 0 == stm->desc.ep[0]) {
+    return false;
+  }
+  if (stm->state == VS_STATE_PROBING) {
+    return false;
+  }
 
-#ifdef TUP_DCD_EDPT_ISO_ALLOC
+  #ifdef TUP_DCD_EDPT_ISO_ALLOC
   uint8_t const *desc = _videod_itf[stm->index_vc].beg;
   uint_fast16_t ofs_ep = stm->desc.ep[0];
   tusb_desc_endpoint_t const *ep = (tusb_desc_endpoint_t const*)(desc + ofs_ep);
   if (ep->bmAttributes.xfer == TUSB_XFER_ISOCHRONOUS) {
-    if (stm->state == VS_STATE_COMMITTED) return false;
+    if (stm->state == VS_STATE_COMMITTED) {
+      return false;
+    }
   }
 #endif
 
@@ -1235,25 +1255,35 @@ bool tud_video_n_frame_xfer(uint_fast8_t ctl_idx, uint_fast8_t stm_idx, void *bu
   TU_ASSERT(ctl_idx < CFG_TUD_VIDEO);
   TU_ASSERT(stm_idx < CFG_TUD_VIDEO_STREAMING);
 
-  if (!buffer || !bufsize) return false;
+  if (NULL == buffer || 0 == bufsize) {
+    return false;
+  }
   videod_streaming_interface_t *stm = _get_instance_streaming(ctl_idx, stm_idx);
   videod_streaming_epbuf_t *stm_epbuf = &_videod_streaming_epbuf[ctl_idx];
 
-  if (!stm || !stm->desc.ep[0] || stm->buffer) return false;
-  if (stm->state == VS_STATE_PROBING) return false;
+  if (NULL == stm || 0 == stm->desc.ep[0] || stm->buffer) {
+    return false;
+  }
+  if (stm->state == VS_STATE_PROBING) {
+    return false;
+  }
 
   /* Find EP address */
   uint8_t const *desc = _videod_itf[stm->index_vc].beg;
   uint8_t ep_addr = 0;
   for (uint_fast8_t i = 0; i < CFG_TUD_VIDEO_STREAMING; ++i) {
     uint_fast16_t ofs_ep = stm->desc.ep[i];
-    if (!ofs_ep) continue;
+    if (0 == ofs_ep) {
+      continue;
+    }
     ep_addr = _desc_ep_addr(desc + ofs_ep);
     break;
   }
-  if (!ep_addr) return false;
+  if (0 == ep_addr) {
+    return false;
+  }
 
-  TU_VERIFY( usbd_edpt_claim(0, ep_addr) );
+  TU_VERIFY(usbd_edpt_claim(0, ep_addr));
   /* update the packet header */
   tusb_video_payload_header_t *hdr = (tusb_video_payload_header_t*)stm_epbuf->buf;
   hdr->FrameID   ^= 1;
@@ -1305,7 +1335,9 @@ uint16_t videod_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uin
   videod_interface_t *self = NULL;
   uint8_t ctl_idx;
   for (ctl_idx = 0; ctl_idx < CFG_TUD_VIDEO; ++ctl_idx) {
-    if (_videod_itf[ctl_idx].beg) continue;
+    if (NULL != _videod_itf[ctl_idx].beg) {
+      continue;
+    }
     self = &_videod_itf[ctl_idx];
     break;
   }
@@ -1326,7 +1358,9 @@ uint16_t videod_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uin
     videod_streaming_interface_t *stm = NULL;
     /* find free streaming interface handle */
     for (uint8_t i = 0; i < CFG_TUD_VIDEO_STREAMING; ++i) {
-      if (_videod_streaming_itf[i].desc.beg) continue;
+      if (0 != _videod_streaming_itf[i].desc.beg) {
+        continue;
+      }
       stm = &_videod_streaming_itf[i];
       self->stm[stm_idx] = i;
       break;
@@ -1354,7 +1388,9 @@ uint16_t videod_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uin
       }
       p_desc = tu_desc_next(p_desc);
     }
-    if(ep_addr > 0 && ep_size > 0) usbd_edpt_iso_alloc(rhport, ep_addr, ep_size);
+    if(ep_addr > 0 && ep_size > 0) {
+      usbd_edpt_iso_alloc(rhport, ep_addr, ep_size);
+    }
 #endif
     if (0 == stm_idx && 1 == bInCollection) {
       /* If there is only one streaming interface and no alternate settings,
@@ -1381,31 +1417,43 @@ bool videod_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_
   uint_fast8_t itf;
   for (itf = 0; itf < CFG_TUD_VIDEO; ++itf) {
     void const *desc = _videod_itf[itf].beg;
-    if (!desc) continue;
-    if (itfnum == _desc_itfnum(desc)) break;
+    if (!desc) {
+      continue;
+    }
+    if (itfnum == _desc_itfnum(desc)) {
+      break;
+    }
   }
 
   if (itf < CFG_TUD_VIDEO) {
     TU_LOG_DRV("  VC[%d]: ", itf);
     err = handle_video_ctl_req(rhport, stage, request, itf);
     _videod_itf[itf].error_code = (uint8_t)err;
-    if (err) return false;
+    if (0 != err) {
+      return false;
+    }
     return true;
   }
 
   /* Identify which streaming interface to use */
   for (itf = 0; itf < CFG_TUD_VIDEO_STREAMING; ++itf) {
     videod_streaming_interface_t *stm = &_videod_streaming_itf[itf];
-    if (!stm->desc.beg) continue;
+    if (0 == stm->desc.beg) {
+      continue;
+    }
     uint8_t const *desc = _videod_itf[stm->index_vc].beg;
-    if (itfnum == _desc_itfnum(desc + stm->desc.beg)) break;
+    if (itfnum == _desc_itfnum(desc + stm->desc.beg)) {
+      break;
+    }
   }
 
   if (itf < CFG_TUD_VIDEO_STREAMING) {
     TU_LOG_DRV("  VS[%d]: ", itf);
     err = handle_video_stm_req(rhport, stage, request, itf);
     _videod_streaming_itf[itf].error_code = (uint8_t)err;
-    if (err) return false;
+    if (err != 0) {
+      return false;
+    }
     return true;
   }
   return false;
@@ -1421,19 +1469,23 @@ bool videod_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint3
   for (itf = 0; itf < CFG_TUD_VIDEO_STREAMING; ++itf) {
     stm = &_videod_streaming_itf[itf];
     uint_fast16_t const ep_ofs = stm->desc.ep[0];
-    if (!ep_ofs) continue;
+    if (0 == ep_ofs) {
+      continue;
+    }
     ctl = &_videod_itf[stm->index_vc];
     uint8_t const *desc = ctl->beg;
-    if (ep_addr == _desc_ep_addr(desc + ep_ofs)) break;
+    if (ep_addr == _desc_ep_addr(desc + ep_ofs)) {
+      break;
+    }
   }
   TU_ASSERT(itf < CFG_TUD_VIDEO_STREAMING);
   videod_streaming_epbuf_t *stm_epbuf = &_videod_streaming_epbuf[itf];
 
   if (stm->offset < stm->bufsize) {
     /* Claim the endpoint */
-    TU_VERIFY( usbd_edpt_claim(rhport, ep_addr), 0);
+    TU_VERIFY(usbd_edpt_claim(rhport, ep_addr), 0);
     uint_fast16_t pkt_len = _prepare_in_payload(stm, stm_epbuf->buf);
-    TU_ASSERT( usbd_edpt_xfer(rhport, ep_addr, stm_epbuf->buf, (uint16_t) pkt_len, false), 0);
+    TU_ASSERT(usbd_edpt_xfer(rhport, ep_addr, stm_epbuf->buf, (uint16_t) pkt_len, false), 0);
   } else {
     stm->buffer  = NULL;
     stm->bufsize = 0;