diff --git a/components/driver/include/driver/uart.h b/components/driver/include/driver/uart.h
index eb5f27a56a..ac43dda8b8 100644
--- a/components/driver/include/driver/uart.h
+++ b/components/driver/include/driver/uart.h
@@ -680,44 +680,46 @@ esp_err_t uart_disable_pattern_det_intr(uart_port_t uart_num);
  * @brief UART enable pattern detect function.
  *        Designed for applications like 'AT commands'.
  *        When the hardware detect a series of one same character, the interrupt will be triggered.
+ * @note  This function only works for esp32. And this function is deprecated, please use
+ *        uart_enable_pattern_det_baud_intr instead.
  *
  * @param uart_num UART port number.
- * @param pattern_chr character of the pattern
+ * @param pattern_chr character of the pattern.
  * @param chr_num number of the character, 8bit value.
  * @param chr_tout timeout of the interval between each pattern characters, 24bit value, unit is APB (80Mhz) clock cycle.
- *        When the duration is less than this value, it will not take this data as at_cmd char
+ *        When the duration is less than this value, it will not take this data as at_cmd char.
  * @param post_idle idle time after the last pattern character, 24bit value, unit is APB (80Mhz) clock cycle.
  *        When the duration is less than this value, it will not take the previous data as the last at_cmd char
  * @param pre_idle idle time before the first pattern character, 24bit value, unit is APB (80Mhz) clock cycle.
- *        When the duration is less than this value, it will not take this data as the first at_cmd char
+ *        When the duration is less than this value, it will not take this data as the first at_cmd char.
  *
  * @return
  *     - ESP_OK Success
  *     - ESP_FAIL Parameter error
  */
-esp_err_t uart_enable_pattern_det_intr(uart_port_t uart_num, char pattern_chr, uint8_t chr_num, int chr_tout, int post_idle, int pre_idle);
-#elif CONFIG_IDF_TARGET_ESP32S2BETA
+esp_err_t uart_enable_pattern_det_intr(uart_port_t uart_num, char pattern_chr, uint8_t chr_num, int chr_tout, int post_idle, int pre_idle) __attribute__((deprecated));
+#endif
+
 /**
  * @brief UART enable pattern detect function.
  *        Designed for applications like 'AT commands'.
  *        When the hardware detect a series of one same character, the interrupt will be triggered.
  *
  * @param uart_num UART port number.
- * @param pattern_chr character of the pattern
+ * @param pattern_chr character of the pattern.
  * @param chr_num number of the character, 8bit value.
- * @param chr_tout timeout of the interval between each pattern characters, 16bit value, unit is baud rate.
- *        When the duration is more than this value, it will not take this data as at_cmd char
- * @param post_idle idle time after the last pattern character, 16bit value, unit is baud rate.
+ * @param chr_tout timeout of the interval between each pattern characters, 16bit value, unit is the baud-rate cycle you configured.
+ *        When the duration is more than this value, it will not take this data as at_cmd char.
+ * @param post_idle idle time after the last pattern character, 16bit value, unit is the baud-rate cycle you configured.
  *        When the duration is less than this value, it will not take the previous data as the last at_cmd char
- * @param pre_idle idle time before the first pattern character, 16bit value, unit is baud rate.
- *        When the duration is less than this value, it will not take this data as the first at_cmd char
+ * @param pre_idle idle time before the first pattern character, 16bit value, unit is the baud-rate cycle you configured.
+ *        When the duration is less than this value, it will not take this data as the first at_cmd char.
  *
  * @return
  *     - ESP_OK Success
  *     - ESP_FAIL Parameter error
  */
-esp_err_t uart_enable_pattern_det_intr(uart_port_t uart_num, char pattern_chr, uint8_t chr_num, int chr_tout, int post_idle, int pre_idle);
-#endif
+esp_err_t uart_enable_pattern_det_baud_intr(uart_port_t uart_num, char pattern_chr, uint8_t chr_num, int chr_tout, int post_idle, int pre_idle);
 
 /**
  * @brief Return the nearest detected pattern position in buffer.
diff --git a/components/driver/uart.c b/components/driver/uart.c
index 6e6cd2994d..ed6bfb660c 100644
--- a/components/driver/uart.c
+++ b/components/driver/uart.c
@@ -36,12 +36,10 @@
 
 #define UART_NUM SOC_UART_NUM
 
-#define UART_NUM SOC_UART_NUM
-
 #define XOFF (char)0x13
 #define XON (char)0x11
 
-static const char* UART_TAG = "uart";
+static const char *UART_TAG = "uart";
 #define UART_CHECK(a, str, ret_val) \
     if (!(a)) { \
         ESP_LOGE(UART_TAG,"%s(%d): %s", __FUNCTION__, __LINE__, str); \
@@ -78,7 +76,7 @@ typedef struct {
     int wr;
     int rd;
     int len;
-    int* data;
+    int *data;
 } uart_pat_rb_t;
 
 typedef struct {
@@ -96,8 +94,8 @@ typedef struct {
     RingbufHandle_t rx_ring_buf;        /*!< RX ring buffer handler*/
     bool rx_buffer_full_flg;            /*!< RX ring buffer full flag. */
     int rx_cur_remain;                  /*!< Data number that waiting to be read out in ring buffer item*/
-    uint8_t* rx_ptr;                    /*!< pointer to the current data in ring buffer*/
-    uint8_t* rx_head_ptr;               /*!< pointer to the head of RX item*/
+    uint8_t *rx_ptr;                    /*!< pointer to the current data in ring buffer*/
+    uint8_t *rx_head_ptr;               /*!< pointer to the head of RX item*/
     uint8_t rx_data_buf[UART_FIFO_LEN]; /*!< Data buffer to stash FIFO data*/
     uint8_t rx_stash_len;               /*!< stashed data length.(When using flow control, after reading out FIFO data, if we fail to push to buffer, we can just stash them.) */
     uart_pat_rb_t rx_pattern_pos;
@@ -110,8 +108,8 @@ typedef struct {
     int tx_buf_size;                    /*!< TX ring buffer size */
     RingbufHandle_t tx_ring_buf;        /*!< TX ring buffer handler*/
     bool tx_waiting_fifo;               /*!< this flag indicates that some task is waiting for FIFO empty interrupt, used to send all data without any data buffer*/
-    uint8_t* tx_ptr;                    /*!< TX data pointer to push to FIFO in TX buffer mode*/
-    uart_tx_data_t* tx_head;            /*!< TX data pointer to head of the current buffer in TX ring buffer*/
+    uint8_t *tx_ptr;                    /*!< TX data pointer to push to FIFO in TX buffer mode*/
+    uart_tx_data_t *tx_head;            /*!< TX data pointer to head of the current buffer in TX ring buffer*/
     uint32_t tx_len_tot;                /*!< Total length of current item in ring buffer*/
     uint32_t tx_len_cur;
     uint8_t tx_brk_flg;                 /*!< Flag to indicate to send a break signal in the end of the item sending procedure */
@@ -122,7 +120,7 @@ typedef struct {
 
 static uart_obj_t *p_uart_obj[UART_NUM_MAX] = {0};
 /* DRAM_ATTR is required to avoid UART array placed in flash, due to accessed from ISR */
-static DRAM_ATTR uart_dev_t* const UART[UART_NUM_MAX] = {
+static DRAM_ATTR uart_dev_t *const UART[UART_NUM_MAX] = {
     &UART0,
     &UART1,
 #if UART_NUM > 2
@@ -148,7 +146,7 @@ esp_err_t uart_set_word_length(uart_port_t uart_num, uart_word_length_t data_bit
     return ESP_OK;
 }
 
-esp_err_t uart_get_word_length(uart_port_t uart_num, uart_word_length_t* data_bit)
+esp_err_t uart_get_word_length(uart_port_t uart_num, uart_word_length_t *data_bit)
 {
     UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);
     *(data_bit) = UART[uart_num]->conf0.bit_num;
@@ -161,7 +159,6 @@ esp_err_t uart_set_stop_bits(uart_port_t uart_num, uart_stop_bits_t stop_bit)
     UART_CHECK((stop_bit < UART_STOP_BITS_MAX), "stop bit error", ESP_FAIL);
 
     UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);
-#if UART_NUM > 2
     //workaround for hardware bug, when uart stop bit set as 2-bit mode.
     if (stop_bit == UART_STOP_BITS_2) {
         stop_bit = UART_STOP_BITS_1;
@@ -169,13 +166,12 @@ esp_err_t uart_set_stop_bits(uart_port_t uart_num, uart_stop_bits_t stop_bit)
     } else {
         UART[uart_num]->rs485_conf.dl1_en = 0;
     }
-#endif
     UART[uart_num]->conf0.stop_bit_num = stop_bit;
     UART_EXIT_CRITICAL(&uart_spinlock[uart_num]);
     return ESP_OK;
 }
 
-esp_err_t uart_get_stop_bits(uart_port_t uart_num, uart_stop_bits_t* stop_bit)
+esp_err_t uart_get_stop_bits(uart_port_t uart_num, uart_stop_bits_t *stop_bit)
 {
     UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);
 #if CONFIG_IDF_TARGET_ESP32
@@ -201,12 +197,12 @@ esp_err_t uart_set_parity(uart_port_t uart_num, uart_parity_t parity_mode)
     return ESP_OK;
 }
 
-esp_err_t uart_get_parity(uart_port_t uart_num, uart_parity_t* parity_mode)
+esp_err_t uart_get_parity(uart_port_t uart_num, uart_parity_t *parity_mode)
 {
     UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);
     int val = UART[uart_num]->conf0.val;
-    if(val & UART_PARITY_EN_M) {
-        if(val & UART_PARITY_M) {
+    if (val & UART_PARITY_EN_M) {
+        if (val & UART_PARITY_M) {
             (*parity_mode) = UART_PARITY_ODD;
         } else {
             (*parity_mode) = UART_PARITY_EVEN;
@@ -241,14 +237,14 @@ esp_err_t uart_set_baudrate(uart_port_t uart_num, uint32_t baud_rate)
     return ret;
 }
 
-esp_err_t uart_get_baudrate(uart_port_t uart_num, uint32_t* baudrate)
+esp_err_t uart_get_baudrate(uart_port_t uart_num, uint32_t *baudrate)
 {
     UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);
     UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);
     uint32_t clk_div = (UART[uart_num]->clk_div.div_int << 4) | UART[uart_num]->clk_div.div_frag;
     UART_EXIT_CRITICAL(&uart_spinlock[uart_num]);
     uint32_t uart_clk_freq = esp_clk_apb_freq();
-    if(UART[uart_num]->conf0.tick_ref_always_on == 0) {
+    if (UART[uart_num]->conf0.tick_ref_always_on == 0) {
         uart_clk_freq = REF_CLK_FREQ;
     }
     (*baudrate) = ((uart_clk_freq) << 4) / clk_div;
@@ -272,8 +268,8 @@ esp_err_t uart_set_sw_flow_ctrl(uart_port_t uart_num, bool enable,  uint8_t rx_t
     UART_CHECK((rx_thresh_xon < UART_FIFO_LEN), "rx flow xon thresh error", ESP_FAIL);
     UART_CHECK((rx_thresh_xoff < UART_FIFO_LEN), "rx flow xon thresh error", ESP_FAIL);
     UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);
-    UART[uart_num]->flow_conf.sw_flow_con_en = enable? 1:0;
-    UART[uart_num]->flow_conf.xonoff_del = enable?1:0;
+    UART[uart_num]->flow_conf.sw_flow_con_en = enable ? 1 : 0;
+    UART[uart_num]->flow_conf.xonoff_del = enable ? 1 : 0;
 #if CONFIG_IDF_TARGET_ESP32
     UART[uart_num]->swfc_conf.xon_threshold =  rx_thresh_xon;
     UART[uart_num]->swfc_conf.xoff_threshold =  rx_thresh_xoff;
@@ -296,7 +292,7 @@ esp_err_t uart_set_hw_flow_ctrl(uart_port_t uart_num, uart_hw_flowcontrol_t flow
     UART_CHECK((rx_thresh < UART_FIFO_LEN), "rx flow thresh error", ESP_FAIL);
     UART_CHECK((flow_ctrl < UART_HW_FLOWCTRL_MAX), "hw_flowctrl mode error", ESP_FAIL);
     UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);
-    if(flow_ctrl & UART_HW_FLOWCTRL_RTS) {
+    if (flow_ctrl & UART_HW_FLOWCTRL_RTS) {
 #if CONFIG_IDF_TARGET_ESP32
         UART[uart_num]->conf1.rx_flow_thrhd = rx_thresh;
 #elif CONFIG_IDF_TARGET_ESP32S2BETA
@@ -306,7 +302,7 @@ esp_err_t uart_set_hw_flow_ctrl(uart_port_t uart_num, uart_hw_flowcontrol_t flow
     } else {
         UART[uart_num]->conf1.rx_flow_en = 0;
     }
-    if(flow_ctrl & UART_HW_FLOWCTRL_CTS) {
+    if (flow_ctrl & UART_HW_FLOWCTRL_CTS) {
         UART[uart_num]->conf0.tx_flow_en = 1;
     } else {
         UART[uart_num]->conf0.tx_flow_en = 0;
@@ -315,14 +311,14 @@ esp_err_t uart_set_hw_flow_ctrl(uart_port_t uart_num, uart_hw_flowcontrol_t flow
     return ESP_OK;
 }
 
-esp_err_t uart_get_hw_flow_ctrl(uart_port_t uart_num, uart_hw_flowcontrol_t* flow_ctrl)
+esp_err_t uart_get_hw_flow_ctrl(uart_port_t uart_num, uart_hw_flowcontrol_t *flow_ctrl)
 {
     UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);
     uart_hw_flowcontrol_t val = UART_HW_FLOWCTRL_DISABLE;
-    if(UART[uart_num]->conf1.rx_flow_en) {
+    if (UART[uart_num]->conf1.rx_flow_en) {
         val |= UART_HW_FLOWCTRL_RTS;
     }
-    if(UART[uart_num]->conf0.tx_flow_en) {
+    if (UART[uart_num]->conf0.tx_flow_en) {
         val |= UART_HW_FLOWCTRL_CTS;
     }
     (*flow_ctrl) = val;
@@ -337,7 +333,7 @@ static esp_err_t uart_reset_rx_fifo(uart_port_t uart_num)
     //See description about UART_TXFIFO_RST and UART_RXFIFO_RST in <<esp32_technical_reference_manual>> v2.6 or later.
 
     // we read the data out and make `fifo_len == 0 && rd_addr == wr_addr`.
-    while(UART[uart_num]->status.rxfifo_cnt != 0 || (UART[uart_num]->mem_rx_status.wr_addr != UART[uart_num]->mem_rx_status.rd_addr)) {
+    while (UART[uart_num]->status.rxfifo_cnt != 0 || (UART[uart_num]->mem_rx_status.wr_addr != UART[uart_num]->mem_rx_status.rd_addr)) {
         READ_PERI_REG(UART_FIFO_REG(uart_num));
     }
 #elif CONFIG_IDF_TARGET_ESP32S2BETA
@@ -393,7 +389,7 @@ static esp_err_t uart_pattern_link_free(uart_port_t uart_num)
 {
     UART_CHECK((p_uart_obj[uart_num]), "uart driver error", ESP_FAIL);
     if (p_uart_obj[uart_num]->rx_pattern_pos.data != NULL) {
-        int* pdata = p_uart_obj[uart_num]->rx_pattern_pos.data;
+        int *pdata = p_uart_obj[uart_num]->rx_pattern_pos.data;
         UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);
         p_uart_obj[uart_num]->rx_pattern_pos.data = NULL;
         p_uart_obj[uart_num]->rx_pattern_pos.wr = 0;
@@ -409,7 +405,7 @@ static esp_err_t uart_pattern_enqueue(uart_port_t uart_num, int pos)
     UART_CHECK((p_uart_obj[uart_num]), "uart driver error", ESP_FAIL);
     esp_err_t ret = ESP_OK;
     UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);
-    uart_pat_rb_t* p_pos = &p_uart_obj[uart_num]->rx_pattern_pos;
+    uart_pat_rb_t *p_pos = &p_uart_obj[uart_num]->rx_pattern_pos;
     int next = p_pos->wr + 1;
     if (next >= p_pos->len) {
         next = 0;
@@ -429,12 +425,12 @@ static esp_err_t uart_pattern_enqueue(uart_port_t uart_num, int pos)
 static esp_err_t uart_pattern_dequeue(uart_port_t uart_num)
 {
     UART_CHECK((p_uart_obj[uart_num]), "uart driver error", ESP_FAIL);
-    if(p_uart_obj[uart_num]->rx_pattern_pos.data == NULL) {
+    if (p_uart_obj[uart_num]->rx_pattern_pos.data == NULL) {
         return ESP_ERR_INVALID_STATE;
     } else {
         esp_err_t ret = ESP_OK;
         UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);
-        uart_pat_rb_t* p_pos = &p_uart_obj[uart_num]->rx_pattern_pos;
+        uart_pat_rb_t *p_pos = &p_uart_obj[uart_num]->rx_pattern_pos;
         if (p_pos->rd == p_pos->wr) {
             ret = ESP_FAIL;
         } else {
@@ -452,9 +448,9 @@ static esp_err_t uart_pattern_queue_update(uart_port_t uart_num, int diff_len)
 {
     UART_CHECK((p_uart_obj[uart_num]), "uart driver error", ESP_FAIL);
     UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);
-    uart_pat_rb_t* p_pos = &p_uart_obj[uart_num]->rx_pattern_pos;
+    uart_pat_rb_t *p_pos = &p_uart_obj[uart_num]->rx_pattern_pos;
     int rd = p_pos->rd;
-    while(rd != p_pos->wr) {
+    while (rd != p_pos->wr) {
         p_pos->data[rd] -= diff_len;
         int rd_rec = rd;
         rd ++;
@@ -473,7 +469,7 @@ int uart_pattern_pop_pos(uart_port_t uart_num)
 {
     UART_CHECK((p_uart_obj[uart_num]), "uart driver error", (-1));
     UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);
-    uart_pat_rb_t* pat_pos = &p_uart_obj[uart_num]->rx_pattern_pos;
+    uart_pat_rb_t *pat_pos = &p_uart_obj[uart_num]->rx_pattern_pos;
     int pos = -1;
     if (pat_pos != NULL && pat_pos->rd != pat_pos->wr) {
         pos = pat_pos->data[pat_pos->rd];
@@ -487,7 +483,7 @@ int uart_pattern_get_pos(uart_port_t uart_num)
 {
     UART_CHECK((p_uart_obj[uart_num]), "uart driver error", (-1));
     UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);
-    uart_pat_rb_t* pat_pos = &p_uart_obj[uart_num]->rx_pattern_pos;
+    uart_pat_rb_t *pat_pos = &p_uart_obj[uart_num]->rx_pattern_pos;
     int pos = -1;
     if (pat_pos != NULL && pat_pos->rd != pat_pos->wr) {
         pos = pat_pos->data[pat_pos->rd];
@@ -501,12 +497,12 @@ esp_err_t uart_pattern_queue_reset(uart_port_t uart_num, int queue_length)
     UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);
     UART_CHECK((p_uart_obj[uart_num]), "uart driver error", ESP_ERR_INVALID_STATE);
 
-    int* pdata = (int*) malloc(queue_length * sizeof(int));
-    if(pdata == NULL) {
+    int *pdata = (int *) malloc(queue_length * sizeof(int));
+    if (pdata == NULL) {
         return ESP_ERR_NO_MEM;
     }
     UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);
-    int* ptmp = p_uart_obj[uart_num]->rx_pattern_pos.data;
+    int *ptmp = p_uart_obj[uart_num]->rx_pattern_pos.data;
     p_uart_obj[uart_num]->rx_pattern_pos.data = pdata;
     p_uart_obj[uart_num]->rx_pattern_pos.len = queue_length;
     p_uart_obj[uart_num]->rx_pattern_pos.rd = 0;
@@ -516,8 +512,10 @@ esp_err_t uart_pattern_queue_reset(uart_port_t uart_num, int queue_length)
     return ESP_OK;
 }
 
+#if CONFIG_IDF_TARGET_ESP32
 esp_err_t uart_enable_pattern_det_intr(uart_port_t uart_num, char pattern_chr, uint8_t chr_num, int chr_tout, int post_idle, int pre_idle)
 {
+    //This function is deprecated, please use uart_enable_pattern_det_baud_intr instead.
     UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);
     UART_CHECK(chr_tout >= 0 && chr_tout <= UART_RX_GAP_TOUT_V, "uart pattern set error\n", ESP_FAIL);
     UART_CHECK(post_idle >= 0 && post_idle <= UART_POST_IDLE_NUM_V, "uart pattern set error\n", ESP_FAIL);
@@ -529,6 +527,37 @@ esp_err_t uart_enable_pattern_det_intr(uart_port_t uart_num, char pattern_chr, u
     UART[uart_num]->at_cmd_precnt.pre_idle_num = pre_idle;
     return uart_enable_intr_mask(uart_num, UART_AT_CMD_CHAR_DET_INT_ENA_M);
 }
+#endif
+
+esp_err_t uart_enable_pattern_det_baud_intr(uart_port_t uart_num, char pattern_chr, uint8_t chr_num, int chr_tout, int post_idle, int pre_idle)
+{
+    UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);
+    UART_CHECK(chr_tout >= 0 && chr_tout <= UART_RX_GAP_TOUT_V, "uart pattern set error\n", ESP_FAIL);
+    UART_CHECK(post_idle >= 0 && post_idle <= UART_POST_IDLE_NUM_V, "uart pattern set error\n", ESP_FAIL);
+    UART_CHECK(pre_idle >= 0 && pre_idle <= UART_PRE_IDLE_NUM_V, "uart pattern set error\n", ESP_FAIL);
+    UART[uart_num]->at_cmd_char.data = pattern_chr;
+    UART[uart_num]->at_cmd_char.char_num = chr_num;
+
+#if CONFIG_IDF_TARGET_ESP32
+    int apb_clk_freq = 0;
+    uint32_t uart_baud = 0;
+    uint32_t uart_div = 0;
+
+    uart_get_baudrate(uart_num, &uart_baud);
+    apb_clk_freq = esp_clk_apb_freq();
+    uart_div = apb_clk_freq / uart_baud;
+
+    UART[uart_num]->at_cmd_gaptout.rx_gap_tout = chr_tout * uart_div;
+    UART[uart_num]->at_cmd_postcnt.post_idle_num = post_idle * uart_div;
+    UART[uart_num]->at_cmd_precnt.pre_idle_num = pre_idle * uart_div;
+#elif CONFIG_IDF_TARGET_ESP32S2BETA
+    UART[uart_num]->at_cmd_gaptout.rx_gap_tout = chr_tout;
+    UART[uart_num]->at_cmd_postcnt.post_idle_num = post_idle;
+    UART[uart_num]->at_cmd_precnt.pre_idle_num = pre_idle;
+#endif
+
+    return uart_enable_intr_mask(uart_num, UART_AT_CMD_CHAR_DET_INT_ENA_M);
+}
 
 esp_err_t uart_disable_pattern_det_intr(uart_port_t uart_num)
 {
@@ -537,12 +566,12 @@ esp_err_t uart_disable_pattern_det_intr(uart_port_t uart_num)
 
 esp_err_t uart_enable_rx_intr(uart_port_t uart_num)
 {
-    return uart_enable_intr_mask(uart_num, UART_RXFIFO_FULL_INT_ENA|UART_RXFIFO_TOUT_INT_ENA);
+    return uart_enable_intr_mask(uart_num, UART_RXFIFO_FULL_INT_ENA | UART_RXFIFO_TOUT_INT_ENA);
 }
 
 esp_err_t uart_disable_rx_intr(uart_port_t uart_num)
 {
-    return uart_disable_intr_mask(uart_num, UART_RXFIFO_FULL_INT_ENA|UART_RXFIFO_TOUT_INT_ENA);
+    return uart_disable_intr_mask(uart_num, UART_RXFIFO_FULL_INT_ENA | UART_RXFIFO_TOUT_INT_ENA);
 }
 
 esp_err_t uart_disable_tx_intr(uart_port_t uart_num)
@@ -562,24 +591,24 @@ esp_err_t uart_enable_tx_intr(uart_port_t uart_num, int enable, int thresh)
     return ESP_OK;
 }
 
-esp_err_t uart_isr_register(uart_port_t uart_num, void (*fn)(void*), void * arg, int intr_alloc_flags,  uart_isr_handle_t *handle)
+esp_err_t uart_isr_register(uart_port_t uart_num, void (*fn)(void *), void *arg, int intr_alloc_flags,  uart_isr_handle_t *handle)
 {
     int ret;
     UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);
     UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);
-    switch(uart_num) {
-        case UART_NUM_1:
-            ret=esp_intr_alloc(ETS_UART1_INTR_SOURCE, intr_alloc_flags, fn, arg, handle);
-            break;
+    switch (uart_num) {
+    case UART_NUM_1:
+        ret = esp_intr_alloc(ETS_UART1_INTR_SOURCE, intr_alloc_flags, fn, arg, handle);
+        break;
 #if UART_NUM > 2
-        case UART_NUM_2:
-            ret=esp_intr_alloc(ETS_UART2_INTR_SOURCE, intr_alloc_flags, fn, arg, handle);
-            break;
+    case UART_NUM_2:
+        ret = esp_intr_alloc(ETS_UART2_INTR_SOURCE, intr_alloc_flags, fn, arg, handle);
+        break;
 #endif
-        case UART_NUM_0:
-            default:
-            ret=esp_intr_alloc(ETS_UART0_INTR_SOURCE, intr_alloc_flags, fn, arg, handle);
-            break;
+    case UART_NUM_0:
+    default:
+        ret = esp_intr_alloc(ETS_UART0_INTR_SOURCE, intr_alloc_flags, fn, arg, handle);
+        break;
     }
     UART_EXIT_CRITICAL(&uart_spinlock[uart_num]);
     return ret;
@@ -590,10 +619,12 @@ esp_err_t uart_isr_free(uart_port_t uart_num)
 {
     esp_err_t ret;
     UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);
-    if (p_uart_obj[uart_num]->intr_handle==NULL) return ESP_ERR_INVALID_ARG;
+    if (p_uart_obj[uart_num]->intr_handle == NULL) {
+        return ESP_ERR_INVALID_ARG;
+    }
     UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);
-    ret=esp_intr_free(p_uart_obj[uart_num]->intr_handle);
-    p_uart_obj[uart_num]->intr_handle=NULL;
+    ret = esp_intr_free(p_uart_obj[uart_num]->intr_handle);
+    p_uart_obj[uart_num]->intr_handle = NULL;
     UART_EXIT_CRITICAL(&uart_spinlock[uart_num]);
     return ret;
 }
@@ -609,53 +640,53 @@ esp_err_t uart_set_pin(uart_port_t uart_num, int tx_io_num, int rx_io_num, int r
     UART_CHECK((cts_io_num < 0 || (GPIO_IS_VALID_GPIO(cts_io_num))), "cts_io_num error", ESP_FAIL);
 
     int tx_sig, rx_sig, rts_sig, cts_sig;
-    switch(uart_num) {
-        case UART_NUM_0:
-            tx_sig = U0TXD_OUT_IDX;
-            rx_sig = U0RXD_IN_IDX;
-            rts_sig = U0RTS_OUT_IDX;
-            cts_sig = U0CTS_IN_IDX;
-            break;
-        case UART_NUM_1:
-            tx_sig = U1TXD_OUT_IDX;
-            rx_sig = U1RXD_IN_IDX;
-            rts_sig = U1RTS_OUT_IDX;
-            cts_sig = U1CTS_IN_IDX;
-            break;
+    switch (uart_num) {
+    case UART_NUM_0:
+        tx_sig = U0TXD_OUT_IDX;
+        rx_sig = U0RXD_IN_IDX;
+        rts_sig = U0RTS_OUT_IDX;
+        cts_sig = U0CTS_IN_IDX;
+        break;
+    case UART_NUM_1:
+        tx_sig = U1TXD_OUT_IDX;
+        rx_sig = U1RXD_IN_IDX;
+        rts_sig = U1RTS_OUT_IDX;
+        cts_sig = U1CTS_IN_IDX;
+        break;
 #if UART_NUM > 2
-        case UART_NUM_2:
-            tx_sig = U2TXD_OUT_IDX;
-            rx_sig = U2RXD_IN_IDX;
-            rts_sig = U2RTS_OUT_IDX;
-            cts_sig = U2CTS_IN_IDX;
-            break;
+    case UART_NUM_2:
+        tx_sig = U2TXD_OUT_IDX;
+        rx_sig = U2RXD_IN_IDX;
+        rts_sig = U2RTS_OUT_IDX;
+        cts_sig = U2CTS_IN_IDX;
+        break;
 #endif
-        case UART_NUM_MAX:
-            default:
-            tx_sig = U0TXD_OUT_IDX;
-            rx_sig = U0RXD_IN_IDX;
-            rts_sig = U0RTS_OUT_IDX;
-            cts_sig = U0CTS_IN_IDX;
-            break;
+    case UART_NUM_MAX:
+    default:
+        tx_sig = U0TXD_OUT_IDX;
+        rx_sig = U0RXD_IN_IDX;
+        rts_sig = U0RTS_OUT_IDX;
+        cts_sig = U0CTS_IN_IDX;
+        break;
     }
-    if(tx_io_num >= 0) {
+    if (tx_io_num >= 0) {
         PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[tx_io_num], PIN_FUNC_GPIO);
         gpio_set_level(tx_io_num, 1);
         gpio_matrix_out(tx_io_num, tx_sig, 0, 0);
     }
 
-    if(rx_io_num >= 0) {
+    if (rx_io_num >= 0) {
         PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[rx_io_num], PIN_FUNC_GPIO);
         gpio_set_pull_mode(rx_io_num, GPIO_PULLUP_ONLY);
         gpio_set_direction(rx_io_num, GPIO_MODE_INPUT);
         gpio_matrix_in(rx_io_num, rx_sig, 0);
     }
-    if(rts_io_num >= 0) {
+    if (rts_io_num >= 0) {
         PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[rts_io_num], PIN_FUNC_GPIO);
         gpio_set_direction(rts_io_num, GPIO_MODE_OUTPUT);
         gpio_matrix_out(rts_io_num, rts_sig, 0, 0);
     }
-    if(cts_io_num >= 0) {
+    if (cts_io_num >= 0) {
         PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[cts_io_num], PIN_FUNC_GPIO);
         gpio_set_pull_mode(cts_io_num, GPIO_PULLUP_ONLY);
         gpio_set_direction(cts_io_num, GPIO_MODE_INPUT);
@@ -699,28 +730,34 @@ esp_err_t uart_param_config(uart_port_t uart_num, const uart_config_t *uart_conf
     esp_err_t r;
     UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);
     UART_CHECK((uart_config), "param null", ESP_FAIL);
-    if(uart_num == UART_NUM_0) {
+    if (uart_num == UART_NUM_0) {
         periph_module_enable(PERIPH_UART0_MODULE);
-    } else if(uart_num == UART_NUM_1) {
+    } else if (uart_num == UART_NUM_1) {
         periph_module_enable(PERIPH_UART1_MODULE);
 #if UART_NUM > 2
-    } else if(uart_num == UART_NUM_2) {
+    } else if (uart_num == UART_NUM_2) {
         periph_module_enable(PERIPH_UART2_MODULE);
 #endif
     }
     r = uart_set_hw_flow_ctrl(uart_num, uart_config->flow_ctrl, uart_config->rx_flow_ctrl_thresh);
-    if (r != ESP_OK) return r;
+    if (r != ESP_OK) {
+        return r;
+    }
 
     UART[uart_num]->conf0.val =
-          (uart_config->parity << UART_PARITY_S)
+        (uart_config->parity << UART_PARITY_S)
         | (uart_config->data_bits << UART_BIT_NUM_S)
         | ((uart_config->flow_ctrl & UART_HW_FLOWCTRL_CTS) ? UART_TX_FLOW_EN : 0x0)
         | (uart_config->use_ref_tick ? 0 : UART_TICK_REF_ALWAYS_ON_M);
 
     r = uart_set_baudrate(uart_num, uart_config->baud_rate);
-    if (r != ESP_OK) return r;
+    if (r != ESP_OK) {
+        return r;
+    }
     r = uart_set_tx_idle_num(uart_num, UART_TX_IDLE_NUM_DEFAULT);
-    if (r != ESP_OK) return r;
+    if (r != ESP_OK) {
+        return r;
+    }
     r = uart_set_stop_bits(uart_num, uart_config->stop_bits);
     //A hardware reset does not reset the fifo,
     //so we need to reset the fifo manually.
@@ -734,11 +771,11 @@ esp_err_t uart_intr_config(uart_port_t uart_num, const uart_intr_config_t *intr_
     UART_CHECK((intr_conf), "param null", ESP_FAIL);
     UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);
     UART[uart_num]->int_clr.val = UART_INTR_MASK;
-    if(intr_conf->intr_enable_mask & UART_RXFIFO_TOUT_INT_ENA_M) {
+    if (intr_conf->intr_enable_mask & UART_RXFIFO_TOUT_INT_ENA_M) {
 #if CONFIG_IDF_TARGET_ESP32
         //Hardware issue workaround: when using ref_tick, the rx timeout threshold needs increase to 10 times.
         //T_ref = T_apb * APB_CLK/(REF_TICK << CLKDIV_FRAG_BIT_WIDTH)
-        if(UART[uart_num]->conf0.tick_ref_always_on == 0) {
+        if (UART[uart_num]->conf0.tick_ref_always_on == 0) {
             UART[uart_num]->conf1.rx_tout_thrhd = ((intr_conf->rx_timeout_thresh * UART_TOUT_REF_FACTOR_DEFAULT) & UART_RX_TOUT_THRHD_V);
         } else {
             UART[uart_num]->conf1.rx_tout_thrhd = ((intr_conf->rx_timeout_thresh) & UART_RX_TOUT_THRHD_V);
@@ -750,10 +787,10 @@ esp_err_t uart_intr_config(uart_port_t uart_num, const uart_intr_config_t *intr_
     } else {
         UART[uart_num]->conf1.rx_tout_en = 0;
     }
-    if(intr_conf->intr_enable_mask & UART_RXFIFO_FULL_INT_ENA_M) {
+    if (intr_conf->intr_enable_mask & UART_RXFIFO_FULL_INT_ENA_M) {
         UART[uart_num]->conf1.rxfifo_full_thrhd = intr_conf->rxfifo_full_thresh;
     }
-    if(intr_conf->intr_enable_mask & UART_TXFIFO_EMPTY_INT_ENA_M) {
+    if (intr_conf->intr_enable_mask & UART_TXFIFO_EMPTY_INT_ENA_M) {
         UART[uart_num]->conf1.txfifo_empty_thrhd = intr_conf->txfifo_empty_intr_thresh;
     }
     UART[uart_num]->int_ena.val = intr_conf->intr_enable_mask;
@@ -761,7 +798,7 @@ esp_err_t uart_intr_config(uart_port_t uart_num, const uart_intr_config_t *intr_
     return ESP_OK;
 }
 
-static int uart_find_pattern_from_last(uint8_t* buf, int length, uint8_t pat_chr, int pat_num)
+static int uart_find_pattern_from_last(uint8_t *buf, int length, uint8_t pat_chr, int pat_num)
 {
     int cnt = 0;
     int len = length;
@@ -782,34 +819,34 @@ static int uart_find_pattern_from_last(uint8_t* buf, int length, uint8_t pat_chr
 //internal isr handler for default driver code.
 static void uart_rx_intr_handler_default(void *param)
 {
-    uart_obj_t *p_uart = (uart_obj_t*) param;
+    uart_obj_t *p_uart = (uart_obj_t *) param;
     uint8_t uart_num = p_uart->uart_num;
-    uart_dev_t* uart_reg = UART[uart_num];
+    uart_dev_t *uart_reg = UART[uart_num];
     int rx_fifo_len = uart_reg->status.rxfifo_cnt;
     uint8_t buf_idx = 0;
     uint32_t uart_intr_status = UART[uart_num]->int_st.val;
     uart_event_t uart_event;
     portBASE_TYPE HPTaskAwoken = 0;
     static uint8_t pat_flg = 0;
-    while(uart_intr_status != 0x0) {
+    while (uart_intr_status != 0x0) {
         buf_idx = 0;
         uart_event.type = UART_EVENT_MAX;
-        if(uart_intr_status & UART_TXFIFO_EMPTY_INT_ST_M) {
+        if (uart_intr_status & UART_TXFIFO_EMPTY_INT_ST_M) {
             uart_clear_intr_status(uart_num, UART_TXFIFO_EMPTY_INT_CLR_M);
             uart_disable_intr_mask_from_isr(uart_num, UART_TXFIFO_EMPTY_INT_ENA_M);
-            if(p_uart->tx_waiting_brk) {
+            if (p_uart->tx_waiting_brk) {
                 continue;
             }
             //TX semaphore will only be used when tx_buf_size is zero.
-            if(p_uart->tx_waiting_fifo == true && p_uart->tx_buf_size == 0) {
+            if (p_uart->tx_waiting_fifo == true && p_uart->tx_buf_size == 0) {
                 p_uart->tx_waiting_fifo = false;
                 xSemaphoreGiveFromISR(p_uart->tx_fifo_sem, &HPTaskAwoken);
-                if(HPTaskAwoken == pdTRUE) {
+                if (HPTaskAwoken == pdTRUE) {
                     portYIELD_FROM_ISR();
                 }
             } else {
                 //We don't use TX ring buffer, because the size is zero.
-                if(p_uart->tx_buf_size == 0) {
+                if (p_uart->tx_buf_size == 0) {
                     continue;
                 }
                 int tx_fifo_rem = UART_FIFO_LEN - UART[uart_num]->status.txfifo_cnt;
@@ -817,33 +854,32 @@ static void uart_rx_intr_handler_default(void *param)
                 //We need to put a loop here, in case all the buffer items are very short.
                 //That would cause a watch_dog reset because empty interrupt happens so often.
                 //Although this is a loop in ISR, this loop will execute at most 128 turns.
-                while(tx_fifo_rem) {
-                    if(p_uart->tx_len_tot == 0 || p_uart->tx_ptr == NULL || p_uart->tx_len_cur == 0) {
+                while (tx_fifo_rem) {
+                    if (p_uart->tx_len_tot == 0 || p_uart->tx_ptr == NULL || p_uart->tx_len_cur == 0) {
                         size_t size;
-                        p_uart->tx_head = (uart_tx_data_t*) xRingbufferReceiveFromISR(p_uart->tx_ring_buf, &size);
-                        if(p_uart->tx_head) {
+                        p_uart->tx_head = (uart_tx_data_t *) xRingbufferReceiveFromISR(p_uart->tx_ring_buf, &size);
+                        if (p_uart->tx_head) {
                             //The first item is the data description
                             //Get the first item to get the data information
-                            if(p_uart->tx_len_tot == 0) {
+                            if (p_uart->tx_len_tot == 0) {
                                 p_uart->tx_ptr = NULL;
                                 p_uart->tx_len_tot = p_uart->tx_head->tx_data.size;
-                                if(p_uart->tx_head->type == UART_DATA_BREAK) {
+                                if (p_uart->tx_head->type == UART_DATA_BREAK) {
                                     p_uart->tx_brk_flg = 1;
                                     p_uart->tx_brk_len = p_uart->tx_head->tx_data.brk_len;
                                 }
                                 //We have saved the data description from the 1st item, return buffer.
                                 vRingbufferReturnItemFromISR(p_uart->tx_ring_buf, p_uart->tx_head, &HPTaskAwoken);
-                                if(HPTaskAwoken == pdTRUE) {
+                                if (HPTaskAwoken == pdTRUE) {
                                     portYIELD_FROM_ISR();
                                 }
-                            }else if(p_uart->tx_ptr == NULL) {
+                            } else if (p_uart->tx_ptr == NULL) {
                                 //Update the TX item pointer, we will need this to return item to buffer.
-                                p_uart->tx_ptr =  (uint8_t*) p_uart->tx_head;
+                                p_uart->tx_ptr =  (uint8_t *) p_uart->tx_head;
                                 en_tx_flg = true;
                                 p_uart->tx_len_cur = size;
                             }
-                        }
-                        else {
+                        } else {
                             //Can not get data from ring buffer, return;
                             break;
                         }
@@ -860,7 +896,7 @@ static void uart_rx_intr_handler_default(void *param)
                         }
                         for (buf_idx = 0; buf_idx < send_len; buf_idx++) {
                             WRITE_PERI_REG(UART_FIFO_AHB_REG(uart_num),
-                                    *(p_uart->tx_ptr++) & 0xff);
+                                           *(p_uart->tx_ptr++) & 0xff);
                         }
                         p_uart->tx_len_tot -= send_len;
                         p_uart->tx_len_cur -= send_len;
@@ -868,14 +904,14 @@ static void uart_rx_intr_handler_default(void *param)
                         if (p_uart->tx_len_cur == 0) {
                             //Return item to ring buffer.
                             vRingbufferReturnItemFromISR(p_uart->tx_ring_buf, p_uart->tx_head, &HPTaskAwoken);
-                            if(HPTaskAwoken == pdTRUE) {
+                            if (HPTaskAwoken == pdTRUE) {
                                 portYIELD_FROM_ISR();
                             }
                             p_uart->tx_head = NULL;
                             p_uart->tx_ptr = NULL;
                             //Sending item done, now we need to send break if there is a record.
                             //Set TX break signal after FIFO is empty
-                            if(p_uart->tx_len_tot == 0 && p_uart->tx_brk_flg == 1) {
+                            if (p_uart->tx_len_tot == 0 && p_uart->tx_brk_flg == 1) {
                                 UART_ENTER_CRITICAL_ISR(&uart_spinlock[uart_num]);
                                 uart_reg->int_ena.tx_brk_done = 0;
                                 uart_reg->idle_conf.tx_brk_num = p_uart->tx_brk_len;
@@ -901,13 +937,12 @@ static void uart_rx_intr_handler_default(void *param)
                     uart_enable_intr_mask_from_isr(uart_num, UART_TXFIFO_EMPTY_INT_ENA_M);
                 }
             }
-        }
-        else if ((uart_intr_status & UART_RXFIFO_TOUT_INT_ST_M)
-                || (uart_intr_status & UART_RXFIFO_FULL_INT_ST_M)
-                || (uart_intr_status & UART_AT_CMD_CHAR_DET_INT_ST_M)
-                ) {
+        } else if ((uart_intr_status & UART_RXFIFO_TOUT_INT_ST_M)
+                   || (uart_intr_status & UART_RXFIFO_FULL_INT_ST_M)
+                   || (uart_intr_status & UART_AT_CMD_CHAR_DET_INT_ST_M)
+                  ) {
             rx_fifo_len = uart_reg->status.rxfifo_cnt;
-            if(pat_flg == 1) {
+            if (pat_flg == 1) {
                 uart_intr_status |= UART_AT_CMD_CHAR_DET_INT_ST_M;
                 pat_flg = 0;
             }
@@ -944,7 +979,7 @@ static void uart_rx_intr_handler_default(void *param)
                 p_uart->rx_stash_len = rx_fifo_len;
                 //If we fail to push data to ring buffer, we will have to stash the data, and send next time.
                 //Mainly for applications that uses flow control or small ring buffer.
-                if(pdFALSE == xRingbufferSendFromISR(p_uart->rx_ring_buf, p_uart->rx_data_buf, p_uart->rx_stash_len, &HPTaskAwoken)) {
+                if (pdFALSE == xRingbufferSendFromISR(p_uart->rx_ring_buf, p_uart->rx_data_buf, p_uart->rx_stash_len, &HPTaskAwoken)) {
                     p_uart->rx_buffer_full_flg = true;
                     uart_disable_intr_mask_from_isr(uart_num, UART_RXFIFO_TOUT_INT_ENA_M | UART_RXFIFO_FULL_INT_ENA_M);
                     if (uart_event.type == UART_PATTERN_DET) {
@@ -953,11 +988,11 @@ static void uart_rx_intr_handler_default(void *param)
                             uart_pattern_enqueue(uart_num, p_uart->rx_buffered_len - (pat_num - rx_fifo_len));
                         } else {
                             uart_pattern_enqueue(uart_num,
-                                    pat_idx <= -1 ?
-                                            //can not find the pattern in buffer,
-                                            p_uart->rx_buffered_len + p_uart->rx_stash_len :
-                                            // find the pattern in buffer
-                                            p_uart->rx_buffered_len + pat_idx);
+                                                 pat_idx <= -1 ?
+                                                 //can not find the pattern in buffer,
+                                                 p_uart->rx_buffered_len + p_uart->rx_stash_len :
+                                                 // find the pattern in buffer
+                                                 p_uart->rx_buffered_len + pat_idx);
                         }
                         if ((p_uart->xQueueUart != NULL) && (pdFALSE == xQueueSendFromISR(p_uart->xQueueUart, (void * )&uart_event, &HPTaskAwoken))) {
                             ESP_EARLY_LOGV(UART_TAG, "UART event queue full");
@@ -970,7 +1005,7 @@ static void uart_rx_intr_handler_default(void *param)
                         if (rx_fifo_len < pat_num) {
                             //some of the characters are read out in last interrupt
                             uart_pattern_enqueue(uart_num, p_uart->rx_buffered_len - (pat_num - rx_fifo_len));
-                        } else if(pat_idx >= 0) {
+                        } else if (pat_idx >= 0) {
                             // find pattern in statsh buffer.
                             uart_pattern_enqueue(uart_num, p_uart->rx_buffered_len + pat_idx);
                         }
@@ -978,20 +1013,20 @@ static void uart_rx_intr_handler_default(void *param)
                     p_uart->rx_buffered_len += p_uart->rx_stash_len;
                     UART_EXIT_CRITICAL_ISR(&uart_spinlock[uart_num]);
                 }
-                if(HPTaskAwoken == pdTRUE) {
+                if (HPTaskAwoken == pdTRUE) {
                     portYIELD_FROM_ISR();
                 }
             } else {
                 uart_disable_intr_mask_from_isr(uart_num, UART_RXFIFO_FULL_INT_ENA_M | UART_RXFIFO_TOUT_INT_ENA_M);
                 uart_clear_intr_status(uart_num, UART_RXFIFO_FULL_INT_CLR_M | UART_RXFIFO_TOUT_INT_CLR_M);
-                if(uart_intr_status & UART_AT_CMD_CHAR_DET_INT_ST_M) {
+                if (uart_intr_status & UART_AT_CMD_CHAR_DET_INT_ST_M) {
                     uart_reg->int_clr.at_cmd_char_det = 1;
                     uart_event.type = UART_PATTERN_DET;
                     uart_event.size = rx_fifo_len;
                     pat_flg = 1;
                 }
             }
-        } else if(uart_intr_status & UART_RXFIFO_OVF_INT_ST_M) {
+        } else if (uart_intr_status & UART_RXFIFO_OVF_INT_ST_M) {
             // When fifo overflows, we reset the fifo.
             UART_ENTER_CRITICAL_ISR(&uart_spinlock[uart_num]);
             uart_reset_rx_fifo(uart_num);
@@ -1003,10 +1038,10 @@ static void uart_rx_intr_handler_default(void *param)
                 p_uart->uart_select_notif_callback(uart_num, UART_SELECT_ERROR_NOTIF, &HPTaskAwoken);
             }
             UART_EXIT_CRITICAL_ISR(&uart_selectlock);
-        } else if(uart_intr_status & UART_BRK_DET_INT_ST_M) {
+        } else if (uart_intr_status & UART_BRK_DET_INT_ST_M) {
             uart_reg->int_clr.brk_det = 1;
             uart_event.type = UART_BREAK;
-        } else if(uart_intr_status & UART_FRM_ERR_INT_ST_M) {
+        } else if (uart_intr_status & UART_FRM_ERR_INT_ST_M) {
             uart_reg->int_clr.frm_err = 1;
             uart_event.type = UART_FRAME_ERR;
             UART_ENTER_CRITICAL_ISR(&uart_selectlock);
@@ -1014,7 +1049,7 @@ static void uart_rx_intr_handler_default(void *param)
                 p_uart->uart_select_notif_callback(uart_num, UART_SELECT_ERROR_NOTIF, &HPTaskAwoken);
             }
             UART_EXIT_CRITICAL_ISR(&uart_selectlock);
-        } else if(uart_intr_status & UART_PARITY_ERR_INT_ST_M) {
+        } else if (uart_intr_status & UART_PARITY_ERR_INT_ST_M) {
             uart_reg->int_clr.parity_err = 1;
             uart_event.type = UART_PARITY_ERR;
             UART_ENTER_CRITICAL_ISR(&uart_selectlock);
@@ -1022,33 +1057,33 @@ static void uart_rx_intr_handler_default(void *param)
                 p_uart->uart_select_notif_callback(uart_num, UART_SELECT_ERROR_NOTIF, &HPTaskAwoken);
             }
             UART_EXIT_CRITICAL_ISR(&uart_selectlock);
-        } else if(uart_intr_status & UART_TX_BRK_DONE_INT_ST_M) {
+        } else if (uart_intr_status & UART_TX_BRK_DONE_INT_ST_M) {
             UART_ENTER_CRITICAL_ISR(&uart_spinlock[uart_num]);
             uart_reg->conf0.txd_brk = 0;
             uart_reg->int_ena.tx_brk_done = 0;
             uart_reg->int_clr.tx_brk_done = 1;
-            if(p_uart->tx_brk_flg == 1) {
+            if (p_uart->tx_brk_flg == 1) {
                 uart_reg->int_ena.txfifo_empty = 1;
             }
             UART_EXIT_CRITICAL_ISR(&uart_spinlock[uart_num]);
-            if(p_uart->tx_brk_flg == 1) {
+            if (p_uart->tx_brk_flg == 1) {
                 p_uart->tx_brk_flg = 0;
                 p_uart->tx_waiting_brk = 0;
             } else {
                 xSemaphoreGiveFromISR(p_uart->tx_brk_sem, &HPTaskAwoken);
-                if(HPTaskAwoken == pdTRUE) {
+                if (HPTaskAwoken == pdTRUE) {
                     portYIELD_FROM_ISR();
                 }
             }
-        } else if(uart_intr_status & UART_TX_BRK_IDLE_DONE_INT_ST_M) {
+        } else if (uart_intr_status & UART_TX_BRK_IDLE_DONE_INT_ST_M) {
             uart_disable_intr_mask_from_isr(uart_num, UART_TX_BRK_IDLE_DONE_INT_ENA_M);
             uart_clear_intr_status(uart_num, UART_TX_BRK_IDLE_DONE_INT_CLR_M);
-        } else if(uart_intr_status & UART_AT_CMD_CHAR_DET_INT_ST_M) {
+        } else if (uart_intr_status & UART_AT_CMD_CHAR_DET_INT_ST_M) {
             uart_reg->int_clr.at_cmd_char_det = 1;
             uart_event.type = UART_PATTERN_DET;
         } else if ((uart_intr_status & UART_RS485_CLASH_INT_ST_M)
-                || (uart_intr_status & UART_RS485_FRM_ERR_INT_ENA)
-                || (uart_intr_status & UART_RS485_PARITY_ERR_INT_ENA)) {
+                   || (uart_intr_status & UART_RS485_FRM_ERR_INT_ENA)
+                   || (uart_intr_status & UART_RS485_PARITY_ERR_INT_ENA)) {
             // RS485 collision or frame error interrupt triggered
             uart_clear_intr_status(uart_num, UART_RS485_CLASH_INT_CLR_M);
             UART_ENTER_CRITICAL_ISR(&uart_spinlock[uart_num]);
@@ -1057,7 +1092,7 @@ static void uart_rx_intr_handler_default(void *param)
             p_uart_obj[uart_num]->coll_det_flg = true;
             UART_EXIT_CRITICAL_ISR(&uart_spinlock[uart_num]);
             uart_event.type = UART_EVENT_MAX;
-        } else if(uart_intr_status & UART_TX_DONE_INT_ST_M) {
+        } else if (uart_intr_status & UART_TX_DONE_INT_ST_M) {
             uart_disable_intr_mask_from_isr(uart_num, UART_TX_DONE_INT_ENA_M);
             uart_clear_intr_status(uart_num, UART_TX_DONE_INT_CLR_M);
             // If RS485 half duplex mode is enable then reset FIFO and
@@ -1077,11 +1112,11 @@ static void uart_rx_intr_handler_default(void *param)
             uart_event.type = UART_EVENT_MAX;
         }
 
-        if(uart_event.type != UART_EVENT_MAX && p_uart->xQueueUart) {
+        if (uart_event.type != UART_EVENT_MAX && p_uart->xQueueUart) {
             if (pdFALSE == xQueueSendFromISR(p_uart->xQueueUart, (void * )&uart_event, &HPTaskAwoken)) {
                 ESP_EARLY_LOGV(UART_TAG, "UART event queue full");
             }
-            if(HPTaskAwoken == pdTRUE) {
+            if (HPTaskAwoken == pdTRUE) {
                 portYIELD_FROM_ISR();
             }
         }
@@ -1098,11 +1133,11 @@ esp_err_t uart_wait_tx_done(uart_port_t uart_num, TickType_t ticks_to_wait)
     portTickType ticks_start = xTaskGetTickCount();
     //Take tx_mux
     res = xSemaphoreTake(p_uart_obj[uart_num]->tx_mux, (portTickType)ticks_to_wait);
-    if(res == pdFALSE) {
+    if (res == pdFALSE) {
         return ESP_ERR_TIMEOUT;
     }
     xSemaphoreTake(p_uart_obj[uart_num]->tx_done_sem, 0);
-    if(UART[uart_num]->status.txfifo_cnt == 0) {
+    if (UART[uart_num]->status.txfifo_cnt == 0) {
         xSemaphoreGive(p_uart_obj[uart_num]->tx_mux);
         return ESP_OK;
     }
@@ -1116,7 +1151,7 @@ esp_err_t uart_wait_tx_done(uart_port_t uart_num, TickType_t ticks_to_wait)
     }
     //take 2nd tx_done_sem, wait given from ISR
     res = xSemaphoreTake(p_uart_obj[uart_num]->tx_done_sem, (portTickType)ticks_to_wait);
-    if(res == pdFALSE) {
+    if (res == pdFALSE) {
         uart_disable_intr_mask(uart_num, UART_TX_DONE_INT_ENA_M);
         xSemaphoreGive(p_uart_obj[uart_num]->tx_mux);
         return ESP_ERR_TIMEOUT;
@@ -1138,7 +1173,7 @@ static esp_err_t uart_set_break(uart_port_t uart_num, int break_num)
 
 //Fill UART tx_fifo and return a number,
 //This function by itself is not thread-safe, always call from within a muxed section.
-static int uart_fill_fifo(uart_port_t uart_num, const char* buffer, uint32_t len)
+static int uart_fill_fifo(uart_port_t uart_num, const char *buffer, uint32_t len)
 {
     uint8_t i = 0;
     uint8_t tx_fifo_cnt = UART[uart_num]->status.txfifo_cnt;
@@ -1155,23 +1190,23 @@ static int uart_fill_fifo(uart_port_t uart_num, const char* buffer, uint32_t len
     return copy_cnt;
 }
 
-int uart_tx_chars(uart_port_t uart_num, const char* buffer, uint32_t len)
+int uart_tx_chars(uart_port_t uart_num, const char *buffer, uint32_t len)
 {
     UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", (-1));
     UART_CHECK((p_uart_obj[uart_num]), "uart driver error", (-1));
     UART_CHECK(buffer, "buffer null", (-1));
-    if(len == 0) {
+    if (len == 0) {
         return 0;
     }
     xSemaphoreTake(p_uart_obj[uart_num]->tx_mux, (portTickType)portMAX_DELAY);
-    int tx_len = uart_fill_fifo(uart_num, (const char*) buffer, len);
+    int tx_len = uart_fill_fifo(uart_num, (const char *) buffer, len);
     xSemaphoreGive(p_uart_obj[uart_num]->tx_mux);
     return tx_len;
 }
 
-static int uart_tx_all(uart_port_t uart_num, const char* src, size_t size, bool brk_en, int brk_len)
+static int uart_tx_all(uart_port_t uart_num, const char *src, size_t size, bool brk_en, int brk_len)
 {
-    if(size == 0) {
+    if (size == 0) {
         return 0;
     }
     size_t original_size = size;
@@ -1179,31 +1214,31 @@ static int uart_tx_all(uart_port_t uart_num, const char* src, size_t size, bool
     //lock for uart_tx
     xSemaphoreTake(p_uart_obj[uart_num]->tx_mux, (portTickType)portMAX_DELAY);
     p_uart_obj[uart_num]->coll_det_flg = false;
-    if(p_uart_obj[uart_num]->tx_buf_size > 0) {
+    if (p_uart_obj[uart_num]->tx_buf_size > 0) {
         int max_size = xRingbufferGetMaxItemSize(p_uart_obj[uart_num]->tx_ring_buf);
         int offset = 0;
         uart_tx_data_t evt;
         evt.tx_data.size = size;
         evt.tx_data.brk_len = brk_len;
-        if(brk_en) {
+        if (brk_en) {
             evt.type = UART_DATA_BREAK;
         } else {
             evt.type = UART_DATA;
         }
-        xRingbufferSend(p_uart_obj[uart_num]->tx_ring_buf, (void*) &evt, sizeof(uart_tx_data_t), portMAX_DELAY);
-        while(size > 0) {
+        xRingbufferSend(p_uart_obj[uart_num]->tx_ring_buf, (void *) &evt, sizeof(uart_tx_data_t), portMAX_DELAY);
+        while (size > 0) {
             int send_size = size > max_size / 2 ? max_size / 2 : size;
-            xRingbufferSend(p_uart_obj[uart_num]->tx_ring_buf, (void*) (src + offset), send_size, portMAX_DELAY);
+            xRingbufferSend(p_uart_obj[uart_num]->tx_ring_buf, (void *) (src + offset), send_size, portMAX_DELAY);
             size -= send_size;
             offset += send_size;
             uart_enable_tx_intr(uart_num, 1, UART_EMPTY_THRESH_DEFAULT);
         }
     } else {
-        while(size) {
+        while (size) {
             //semaphore for tx_fifo available
-            if(pdTRUE == xSemaphoreTake(p_uart_obj[uart_num]->tx_fifo_sem, (portTickType)portMAX_DELAY)) {
-                size_t sent = uart_fill_fifo(uart_num, (char*) src, size);
-                if(sent < size) {
+            if (pdTRUE == xSemaphoreTake(p_uart_obj[uart_num]->tx_fifo_sem, (portTickType)portMAX_DELAY)) {
+                size_t sent = uart_fill_fifo(uart_num, (char *) src, size);
+                if (sent < size) {
                     p_uart_obj[uart_num]->tx_waiting_fifo = true;
                     uart_enable_tx_intr(uart_num, 1, UART_EMPTY_THRESH_DEFAULT);
                 }
@@ -1211,7 +1246,7 @@ static int uart_tx_all(uart_port_t uart_num, const char* src, size_t size, bool
                 src += sent;
             }
         }
-        if(brk_en) {
+        if (brk_en) {
             uart_set_break(uart_num, brk_len);
             xSemaphoreTake(p_uart_obj[uart_num]->tx_brk_sem, (portTickType)portMAX_DELAY);
         }
@@ -1221,7 +1256,7 @@ static int uart_tx_all(uart_port_t uart_num, const char* src, size_t size, bool
     return original_size;
 }
 
-int uart_write_bytes(uart_port_t uart_num, const char* src, size_t size)
+int uart_write_bytes(uart_port_t uart_num, const char *src, size_t size)
 {
     UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", (-1));
     UART_CHECK((p_uart_obj[uart_num] != NULL), "uart driver error", (-1));
@@ -1229,7 +1264,7 @@ int uart_write_bytes(uart_port_t uart_num, const char* src, size_t size)
     return uart_tx_all(uart_num, src, size, 0, 0);
 }
 
-int uart_write_bytes_with_break(uart_port_t uart_num, const char* src, size_t size, int brk_len)
+int uart_write_bytes_with_break(uart_port_t uart_num, const char *src, size_t size, int brk_len)
 {
     UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", (-1));
     UART_CHECK((p_uart_obj[uart_num]), "uart driver error", (-1));
@@ -1241,9 +1276,9 @@ int uart_write_bytes_with_break(uart_port_t uart_num, const char* src, size_t si
 
 static bool uart_check_buf_full(uart_port_t uart_num)
 {
-    if(p_uart_obj[uart_num]->rx_buffer_full_flg) {
+    if (p_uart_obj[uart_num]->rx_buffer_full_flg) {
         BaseType_t res = xRingbufferSend(p_uart_obj[uart_num]->rx_ring_buf, p_uart_obj[uart_num]->rx_data_buf, p_uart_obj[uart_num]->rx_stash_len, 1);
-        if(res == pdTRUE) {
+        if (res == pdTRUE) {
             UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);
             p_uart_obj[uart_num]->rx_buffered_len += p_uart_obj[uart_num]->rx_stash_len;
             p_uart_obj[uart_num]->rx_buffer_full_flg = false;
@@ -1255,22 +1290,22 @@ static bool uart_check_buf_full(uart_port_t uart_num)
     return false;
 }
 
-int uart_read_bytes(uart_port_t uart_num, uint8_t* buf, uint32_t length, TickType_t ticks_to_wait)
+int uart_read_bytes(uart_port_t uart_num, uint8_t *buf, uint32_t length, TickType_t ticks_to_wait)
 {
     UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", (-1));
     UART_CHECK((buf), "uart data null", (-1));
     UART_CHECK((p_uart_obj[uart_num]), "uart driver error", (-1));
-    uint8_t* data = NULL;
+    uint8_t *data = NULL;
     size_t size;
     size_t copy_len = 0;
     int len_tmp;
-    if(xSemaphoreTake(p_uart_obj[uart_num]->rx_mux,(portTickType)ticks_to_wait) != pdTRUE) {
+    if (xSemaphoreTake(p_uart_obj[uart_num]->rx_mux, (portTickType)ticks_to_wait) != pdTRUE) {
         return -1;
     }
-    while(length) {
-        if(p_uart_obj[uart_num]->rx_cur_remain == 0) {
-            data = (uint8_t*) xRingbufferReceive(p_uart_obj[uart_num]->rx_ring_buf, &size, (portTickType) ticks_to_wait);
-            if(data) {
+    while (length) {
+        if (p_uart_obj[uart_num]->rx_cur_remain == 0) {
+            data = (uint8_t *) xRingbufferReceive(p_uart_obj[uart_num]->rx_ring_buf, &size, (portTickType) ticks_to_wait);
+            if (data) {
                 p_uart_obj[uart_num]->rx_head_ptr = data;
                 p_uart_obj[uart_num]->rx_ptr = data;
                 p_uart_obj[uart_num]->rx_cur_remain = size;
@@ -1278,7 +1313,7 @@ int uart_read_bytes(uart_port_t uart_num, uint8_t* buf, uint32_t length, TickTyp
                 //When using dual cores, `rx_buffer_full_flg` may read and write on different cores at same time,
                 //which may lose synchronization. So we also need to call `uart_check_buf_full` once when ringbuffer is empty
                 //to solve the possible asynchronous issues.
-                if(uart_check_buf_full(uart_num)) {
+                if (uart_check_buf_full(uart_num)) {
                     //This condition will never be true if `uart_read_bytes`
                     //and `uart_rx_intr_handler_default` are scheduled on the same core.
                     continue;
@@ -1288,7 +1323,7 @@ int uart_read_bytes(uart_port_t uart_num, uint8_t* buf, uint32_t length, TickTyp
                 }
             }
         }
-        if(p_uart_obj[uart_num]->rx_cur_remain > length) {
+        if (p_uart_obj[uart_num]->rx_cur_remain > length) {
             len_tmp = length;
         } else {
             len_tmp = p_uart_obj[uart_num]->rx_cur_remain;
@@ -1302,7 +1337,7 @@ int uart_read_bytes(uart_port_t uart_num, uint8_t* buf, uint32_t length, TickTyp
         p_uart_obj[uart_num]->rx_cur_remain -= len_tmp;
         copy_len += len_tmp;
         length -= len_tmp;
-        if(p_uart_obj[uart_num]->rx_cur_remain == 0) {
+        if (p_uart_obj[uart_num]->rx_cur_remain == 0) {
             vRingbufferReturnItem(p_uart_obj[uart_num]->rx_ring_buf, p_uart_obj[uart_num]->rx_head_ptr);
             p_uart_obj[uart_num]->rx_head_ptr = NULL;
             p_uart_obj[uart_num]->rx_ptr = NULL;
@@ -1314,7 +1349,7 @@ int uart_read_bytes(uart_port_t uart_num, uint8_t* buf, uint32_t length, TickTyp
     return copy_len;
 }
 
-esp_err_t uart_get_buffered_data_len(uart_port_t uart_num, size_t* size)
+esp_err_t uart_get_buffered_data_len(uart_port_t uart_num, size_t *size)
 {
     UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);
     UART_CHECK((p_uart_obj[uart_num]), "uart driver error", ESP_FAIL);
@@ -1328,15 +1363,15 @@ esp_err_t uart_flush_input(uart_port_t uart_num)
 {
     UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);
     UART_CHECK((p_uart_obj[uart_num]), "uart driver error", ESP_FAIL);
-    uart_obj_t* p_uart = p_uart_obj[uart_num];
-    uint8_t* data;
+    uart_obj_t *p_uart = p_uart_obj[uart_num];
+    uint8_t *data;
     size_t size;
 
     //rx sem protect the ring buffer read related functions
     xSemaphoreTake(p_uart->rx_mux, (portTickType)portMAX_DELAY);
     uart_disable_rx_intr(p_uart_obj[uart_num]->uart_num);
-    while(true) {
-        if(p_uart->rx_head_ptr) {
+    while (true) {
+        if (p_uart->rx_head_ptr) {
             vRingbufferReturnItem(p_uart->rx_ring_buf, p_uart->rx_head_ptr);
             UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);
             p_uart_obj[uart_num]->rx_buffered_len -= p_uart->rx_cur_remain;
@@ -1346,9 +1381,9 @@ esp_err_t uart_flush_input(uart_port_t uart_num)
             p_uart->rx_cur_remain = 0;
             p_uart->rx_head_ptr = NULL;
         }
-        data = (uint8_t*) xRingbufferReceive(p_uart->rx_ring_buf, &size, (portTickType) 0);
-        if(data == NULL) {
-            if( p_uart_obj[uart_num]->rx_buffered_len != 0 ) {
+        data = (uint8_t *) xRingbufferReceive(p_uart->rx_ring_buf, &size, (portTickType) 0);
+        if (data == NULL) {
+            if ( p_uart_obj[uart_num]->rx_buffered_len != 0 ) {
                 ESP_LOGE(UART_TAG, "rx_buffered_len error");
                 p_uart_obj[uart_num]->rx_buffered_len = 0;
             }
@@ -1363,9 +1398,9 @@ esp_err_t uart_flush_input(uart_port_t uart_num)
         uart_pattern_queue_update(uart_num, size);
         UART_EXIT_CRITICAL(&uart_spinlock[uart_num]);
         vRingbufferReturnItem(p_uart->rx_ring_buf, data);
-        if(p_uart_obj[uart_num]->rx_buffer_full_flg) {
+        if (p_uart_obj[uart_num]->rx_buffer_full_flg) {
             BaseType_t res = xRingbufferSend(p_uart_obj[uart_num]->rx_ring_buf, p_uart_obj[uart_num]->rx_data_buf, p_uart_obj[uart_num]->rx_stash_len, 1);
-            if(res == pdTRUE) {
+            if (res == pdTRUE) {
                 UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);
                 p_uart_obj[uart_num]->rx_buffered_len += p_uart_obj[uart_num]->rx_stash_len;
                 p_uart_obj[uart_num]->rx_buffer_full_flg = false;
@@ -1390,9 +1425,9 @@ esp_err_t uart_driver_install(uart_port_t uart_num, int rx_buffer_size, int tx_b
     UART_CHECK((tx_buffer_size > UART_FIFO_LEN) || (tx_buffer_size == 0), "uart tx buffer length error(>128 or 0)", ESP_FAIL);
     UART_CHECK((intr_alloc_flags & ESP_INTR_FLAG_IRAM) == 0, "ESP_INTR_FLAG_IRAM set in intr_alloc_flags", ESP_FAIL); /* uart_rx_intr_handler_default is not in IRAM */
 
-    if(p_uart_obj[uart_num] == NULL) {
-        p_uart_obj[uart_num] = (uart_obj_t*) calloc(1, sizeof(uart_obj_t));
-        if(p_uart_obj[uart_num] == NULL) {
+    if (p_uart_obj[uart_num] == NULL) {
+        p_uart_obj[uart_num] = (uart_obj_t *) calloc(1, sizeof(uart_obj_t));
+        if (p_uart_obj[uart_num] == NULL) {
             ESP_LOGE(UART_TAG, "UART driver malloc error");
             return ESP_FAIL;
         }
@@ -1415,7 +1450,7 @@ esp_err_t uart_driver_install(uart_port_t uart_num, int rx_buffer_size, int tx_b
         p_uart_obj[uart_num]->rx_buffered_len = 0;
         uart_pattern_queue_reset(uart_num, UART_PATTERN_DET_QLEN_DEFAULT);
 
-        if(uart_queue) {
+        if (uart_queue) {
             p_uart_obj[uart_num]->xQueueUart = xQueueCreate(queue_size, sizeof(uart_event_t));
             *uart_queue = p_uart_obj[uart_num]->xQueueUart;
             ESP_LOGI(UART_TAG, "queue free spaces: %d", uxQueueSpacesAvailable(p_uart_obj[uart_num]->xQueueUart));
@@ -1428,7 +1463,7 @@ esp_err_t uart_driver_install(uart_port_t uart_num, int rx_buffer_size, int tx_b
         p_uart_obj[uart_num]->rx_cur_remain = 0;
         p_uart_obj[uart_num]->rx_head_ptr = NULL;
         p_uart_obj[uart_num]->rx_ring_buf = xRingbufferCreate(rx_buffer_size, RINGBUF_TYPE_BYTEBUF);
-        if(tx_buffer_size > 0) {
+        if (tx_buffer_size > 0) {
             p_uart_obj[uart_num]->tx_ring_buf = xRingbufferCreate(tx_buffer_size, RINGBUF_TYPE_NOSPLIT);
             p_uart_obj[uart_num]->tx_buf_size = tx_buffer_size;
         } else {
@@ -1441,21 +1476,25 @@ esp_err_t uart_driver_install(uart_port_t uart_num, int rx_buffer_size, int tx_b
         return ESP_FAIL;
     }
 
-    r=uart_isr_register(uart_num, uart_rx_intr_handler_default, p_uart_obj[uart_num], intr_alloc_flags, &p_uart_obj[uart_num]->intr_handle);
-    if (r!=ESP_OK) goto err;
+    r = uart_isr_register(uart_num, uart_rx_intr_handler_default, p_uart_obj[uart_num], intr_alloc_flags, &p_uart_obj[uart_num]->intr_handle);
+    if (r != ESP_OK) {
+        goto err;
+    }
     uart_intr_config_t uart_intr = {
         .intr_enable_mask = UART_RXFIFO_FULL_INT_ENA_M
-                            | UART_RXFIFO_TOUT_INT_ENA_M
-                            | UART_FRM_ERR_INT_ENA_M
-                            | UART_RXFIFO_OVF_INT_ENA_M
-                            | UART_BRK_DET_INT_ENA_M
-                            | UART_PARITY_ERR_INT_ENA_M,
+        | UART_RXFIFO_TOUT_INT_ENA_M
+        | UART_FRM_ERR_INT_ENA_M
+        | UART_RXFIFO_OVF_INT_ENA_M
+        | UART_BRK_DET_INT_ENA_M
+        | UART_PARITY_ERR_INT_ENA_M,
         .rxfifo_full_thresh = UART_FULL_THRESH_DEFAULT,
         .rx_timeout_thresh = UART_TOUT_THRESH_DEFAULT,
         .txfifo_empty_intr_thresh = UART_EMPTY_THRESH_DEFAULT
     };
-    r=uart_intr_config(uart_num, &uart_intr);
-    if (r!=ESP_OK) goto err;
+    r = uart_intr_config(uart_num, &uart_intr);
+    if (r != ESP_OK) {
+        goto err;
+    }
     return r;
 
 err:
@@ -1467,7 +1506,7 @@ err:
 esp_err_t uart_driver_delete(uart_port_t uart_num)
 {
     UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);
-    if(p_uart_obj[uart_num] == NULL) {
+    if (p_uart_obj[uart_num] == NULL) {
         ESP_LOGI(UART_TAG, "ALREADY NULL");
         return ESP_OK;
     }
@@ -1476,35 +1515,35 @@ esp_err_t uart_driver_delete(uart_port_t uart_num)
     uart_disable_tx_intr(uart_num);
     uart_pattern_link_free(uart_num);
 
-    if(p_uart_obj[uart_num]->tx_fifo_sem) {
+    if (p_uart_obj[uart_num]->tx_fifo_sem) {
         vSemaphoreDelete(p_uart_obj[uart_num]->tx_fifo_sem);
         p_uart_obj[uart_num]->tx_fifo_sem = NULL;
     }
-    if(p_uart_obj[uart_num]->tx_done_sem) {
+    if (p_uart_obj[uart_num]->tx_done_sem) {
         vSemaphoreDelete(p_uart_obj[uart_num]->tx_done_sem);
         p_uart_obj[uart_num]->tx_done_sem = NULL;
     }
-    if(p_uart_obj[uart_num]->tx_brk_sem) {
+    if (p_uart_obj[uart_num]->tx_brk_sem) {
         vSemaphoreDelete(p_uart_obj[uart_num]->tx_brk_sem);
         p_uart_obj[uart_num]->tx_brk_sem = NULL;
     }
-    if(p_uart_obj[uart_num]->tx_mux) {
+    if (p_uart_obj[uart_num]->tx_mux) {
         vSemaphoreDelete(p_uart_obj[uart_num]->tx_mux);
         p_uart_obj[uart_num]->tx_mux = NULL;
     }
-    if(p_uart_obj[uart_num]->rx_mux) {
+    if (p_uart_obj[uart_num]->rx_mux) {
         vSemaphoreDelete(p_uart_obj[uart_num]->rx_mux);
         p_uart_obj[uart_num]->rx_mux = NULL;
     }
-    if(p_uart_obj[uart_num]->xQueueUart) {
+    if (p_uart_obj[uart_num]->xQueueUart) {
         vQueueDelete(p_uart_obj[uart_num]->xQueueUart);
         p_uart_obj[uart_num]->xQueueUart = NULL;
     }
-    if(p_uart_obj[uart_num]->rx_ring_buf) {
+    if (p_uart_obj[uart_num]->rx_ring_buf) {
         vRingbufferDelete(p_uart_obj[uart_num]->rx_ring_buf);
         p_uart_obj[uart_num]->rx_ring_buf = NULL;
     }
-    if(p_uart_obj[uart_num]->tx_ring_buf) {
+    if (p_uart_obj[uart_num]->tx_ring_buf) {
         vRingbufferDelete(p_uart_obj[uart_num]->tx_ring_buf);
         p_uart_obj[uart_num]->tx_ring_buf = NULL;
     }
@@ -1513,15 +1552,15 @@ esp_err_t uart_driver_delete(uart_port_t uart_num)
     p_uart_obj[uart_num] = NULL;
 
     if (uart_num != CONFIG_ESP_CONSOLE_UART_NUM ) {
-       if(uart_num == UART_NUM_0) {
-           periph_module_disable(PERIPH_UART0_MODULE);
-       } else if(uart_num == UART_NUM_1) {
-           periph_module_disable(PERIPH_UART1_MODULE);
+        if (uart_num == UART_NUM_0) {
+            periph_module_disable(PERIPH_UART0_MODULE);
+        } else if (uart_num == UART_NUM_1) {
+            periph_module_disable(PERIPH_UART1_MODULE);
 #if UART_NUM > 2
-       } else if(uart_num == UART_NUM_2) {
-           periph_module_disable(PERIPH_UART2_MODULE);
+        } else if (uart_num == UART_NUM_2) {
+            periph_module_disable(PERIPH_UART2_MODULE);
 #endif
-       }
+        }
     }
     return ESP_OK;
 }
@@ -1546,7 +1585,7 @@ esp_err_t uart_set_mode(uart_port_t uart_num, uart_mode_t mode)
     if ((mode == UART_MODE_RS485_COLLISION_DETECT) || (mode == UART_MODE_RS485_APP_CTRL)
             || (mode == UART_MODE_RS485_HALF_DUPLEX)) {
         UART_CHECK((UART[uart_num]->conf1.rx_flow_en != 1),
-                "disable hw flowctrl before using RS485 mode", ESP_ERR_INVALID_ARG);
+                   "disable hw flowctrl before using RS485 mode", ESP_ERR_INVALID_ARG);
     }
     UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);
     UART[uart_num]->rs485_conf.en = 0;
@@ -1567,10 +1606,10 @@ esp_err_t uart_set_mode(uart_port_t uart_num, uart_mode_t mode)
         UART[uart_num]->rs485_conf.en = 1;
         // Enable collision detection interrupts
         uart_enable_intr_mask(uart_num, UART_RXFIFO_TOUT_INT_ENA
-                                        | UART_RXFIFO_FULL_INT_ENA
-                                        | UART_RS485_CLASH_INT_ENA
-                                        | UART_RS485_FRM_ERR_INT_ENA
-                                        | UART_RS485_PARITY_ERR_INT_ENA);
+                              | UART_RXFIFO_FULL_INT_ENA
+                              | UART_RS485_CLASH_INT_ENA
+                              | UART_RS485_FRM_ERR_INT_ENA
+                              | UART_RS485_PARITY_ERR_INT_ENA);
         break;
     case UART_MODE_RS485_APP_CTRL:
         // Application software control, remove echo
@@ -1607,7 +1646,7 @@ esp_err_t uart_set_rx_timeout(uart_port_t uart_num, const uint8_t tout_thresh)
     // transmission time of one symbol (~11 bit) on current baudrate
     if (tout_thresh > 0) {
 #if CONFIG_IDF_TARGET_ESP32
-        if(UART[uart_num]->conf0.tick_ref_always_on == 0) {
+        if (UART[uart_num]->conf0.tick_ref_always_on == 0) {
             UART[uart_num]->conf1.rx_tout_thrhd = ((tout_thresh * UART_TOUT_REF_FACTOR_DEFAULT) & UART_RX_TOUT_THRHD_V);
         } else {
             UART[uart_num]->conf1.rx_tout_thrhd = ((tout_thresh) & UART_RX_TOUT_THRHD_V);
@@ -1623,13 +1662,13 @@ esp_err_t uart_set_rx_timeout(uart_port_t uart_num, const uint8_t tout_thresh)
     return ESP_OK;
 }
 
-esp_err_t uart_get_collision_flag(uart_port_t uart_num, bool* collision_flag)
+esp_err_t uart_get_collision_flag(uart_port_t uart_num, bool *collision_flag)
 {
     UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_ERR_INVALID_ARG);
     UART_CHECK((collision_flag != NULL), "wrong parameter pointer", ESP_ERR_INVALID_ARG);
     UART_CHECK((UART_IS_MODE_SET(uart_num, UART_MODE_RS485_HALF_DUPLEX)
-                    || UART_IS_MODE_SET(uart_num, UART_MODE_RS485_COLLISION_DETECT)),
-                    "wrong mode", ESP_ERR_INVALID_ARG);
+                || UART_IS_MODE_SET(uart_num, UART_MODE_RS485_COLLISION_DETECT)),
+               "wrong mode", ESP_ERR_INVALID_ARG);
     *collision_flag = p_uart_obj[uart_num]->coll_det_flg;
     return ESP_OK;
 }
@@ -1639,13 +1678,13 @@ esp_err_t uart_set_wakeup_threshold(uart_port_t uart_num, int wakeup_threshold)
     UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_ERR_INVALID_ARG);
     UART_CHECK((wakeup_threshold <= UART_ACTIVE_THRESHOLD_V &&
                 wakeup_threshold > UART_MIN_WAKEUP_THRESH),
-                "wakeup_threshold out of bounds", ESP_ERR_INVALID_ARG);
+               "wakeup_threshold out of bounds", ESP_ERR_INVALID_ARG);
 
     UART[uart_num]->sleep_conf.active_threshold = wakeup_threshold - UART_MIN_WAKEUP_THRESH;
     return ESP_OK;
 }
 
-esp_err_t uart_get_wakeup_threshold(uart_port_t uart_num, int* out_wakeup_threshold)
+esp_err_t uart_get_wakeup_threshold(uart_port_t uart_num, int *out_wakeup_threshold)
 {
     UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_ERR_INVALID_ARG);
     UART_CHECK((out_wakeup_threshold != NULL), "argument is NULL", ESP_ERR_INVALID_ARG);
diff --git a/components/soc/esp32s2beta/include/soc/uart_caps.h b/components/soc/esp32s2beta/include/soc/uart_caps.h
index a1c263e7c8..1981f7ebf1 100644
--- a/components/soc/esp32s2beta/include/soc/uart_caps.h
+++ b/components/soc/esp32s2beta/include/soc/uart_caps.h
@@ -11,8 +11,9 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-#ifndef _SOC_UART_CAPS_H_
-#define _SOC_UART_CAPS_H_
+
+#pragma once
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -22,5 +23,3 @@ extern "C" {
 #ifdef __cplusplus
 }
 #endif
-
-#endif  /* _SOC_UART_CAPS_H_ */
diff --git a/components/vfs/test/test_vfs_access.c b/components/vfs/test/test_vfs_access.c
index 02e7d56f82..4f3988842a 100644
--- a/components/vfs/test/test_vfs_access.c
+++ b/components/vfs/test/test_vfs_access.c
@@ -27,11 +27,19 @@ static wl_handle_t test_wl_handle;
 
 TEST_CASE("Can use access() for UART", "[vfs]")
 {
-    const char *uarts[] = {"/dev/uart/0", "/dev/uart/1", "/dev/uart/2"};
+    const char *uarts[] = {
+        "/dev/uart/0",
+        "/dev/uart/1",
+#if SOC_UART_NUM > 2
+        "/dev/uart/2"
+#endif
+        };
 
     uart_driver_install(UART_NUM_0, 256, 0, 0, NULL, 0);
     uart_driver_install(UART_NUM_1, 256, 0, 0, NULL, 0);
+#if SOC_UART_NUM > 2
     uart_driver_install(UART_NUM_2, 256, 0, 0, NULL, 0);
+#endif
 
     for (int i = 0; i < sizeof(uarts)/sizeof(uarts[0]); ++i) {
         TEST_ASSERT_EQUAL_MESSAGE(access(uarts[i], F_OK), 0, uarts[i]);
@@ -55,7 +63,9 @@ TEST_CASE("Can use access() for UART", "[vfs]")
 
     uart_driver_delete(UART_NUM_0);
     uart_driver_delete(UART_NUM_1);
+#if SOC_UART_NUM > 2
     uart_driver_delete(UART_NUM_2);
+#endif
 }
 
 static inline void test_spi_flash_setup()
diff --git a/docs/en/api-reference/peripherals/uart.rst b/docs/en/api-reference/peripherals/uart.rst
index cf704bf194..4805ceda7c 100644
--- a/docs/en/api-reference/peripherals/uart.rst
+++ b/docs/en/api-reference/peripherals/uart.rst
@@ -169,7 +169,7 @@ The API provides a convenient way to handle specific interrupts discussed above
 
 * **FIFO space threshold or transmission timeout reached** - the interrupts on TX or Rx FIFO buffer being filled with specific number of characters or on a timeout of sending or receiving data. To use these interrupts, first configure respective threshold values of the buffer length and the timeout by entering them in :cpp:type:`uart_intr_config_t` structure and calling :cpp:func:`uart_intr_config`. Then enable interrupts with functions :cpp:func:`uart_enable_rx_intr` and :cpp:func:`uart_enable_tx_intr`. To disable these interrupts there are corresponding functions :cpp:func:`uart_disable_rx_intr` or :cpp:func:`uart_disable_tx_intr`.
 
-* **Pattern detection** - an interrupt triggered on detecting a 'pattern' of the same character being sent number of times. The functions that allow to configure, enable and disable this interrupt are :cpp:func:`uart_enable_pattern_det_intr` and cpp:func:`uart_disable_pattern_det_intr`.
+* **Pattern detection** - an interrupt triggered on detecting a 'pattern' of the same character being sent number of times. The functions that allow to configure, enable and disable this interrupt are :cpp:func:`uart_enable_pattern_det_baud_intr` and cpp:func:`uart_disable_pattern_det_intr`.
 
 Macros
 ^^^^^^
diff --git a/examples/peripherals/uart/nmea0183_parser/main/nmea_parser.c b/examples/peripherals/uart/nmea0183_parser/main/nmea_parser.c
index 0dc244afe2..89457e4921 100644
--- a/examples/peripherals/uart/nmea0183_parser/main/nmea_parser.c
+++ b/examples/peripherals/uart/nmea0183_parser/main/nmea_parser.c
@@ -699,7 +699,7 @@ nmea_parser_handle_t nmea_parser_init(const nmea_parser_config_t *config)
         goto err_uart_install;
     }
     /* Set pattern interrupt, used to detect the end of a line */
-    uart_enable_pattern_det_intr(esp_gps->uart_port, '\n', 1, 10000, 10, 10);
+    uart_enable_pattern_det_baud_intr(esp_gps->uart_port, '\n', 1, 9, 0, 0);
     /* Set pattern queue size */
     uart_pattern_queue_reset(esp_gps->uart_port, config->uart.event_queue_size);
     uart_flush(esp_gps->uart_port);
diff --git a/examples/peripherals/uart/uart_echo_rs485/main/rs485_example.c b/examples/peripherals/uart/uart_echo_rs485/main/rs485_example.c
index 22204b73fe..7860966072 100644
--- a/examples/peripherals/uart/uart_echo_rs485/main/rs485_example.c
+++ b/examples/peripherals/uart/uart_echo_rs485/main/rs485_example.c
@@ -47,7 +47,7 @@
 #define PACKET_READ_TICS        (100 / portTICK_RATE_MS)
 #define ECHO_TASK_STACK_SIZE    (2048)
 #define ECHO_TASK_PRIO          (10)
-#define ECHO_UART_PORT          (UART_NUM_2)
+#define ECHO_UART_PORT          (UART_NUM_MAX - 1)
 
 static const char *TAG = "RS485_ECHO_APP";
 
diff --git a/examples/peripherals/uart/uart_events/main/uart_events_example_main.c b/examples/peripherals/uart/uart_events/main/uart_events_example_main.c
index 48b7bc49b9..ea851006b1 100644
--- a/examples/peripherals/uart/uart_events/main/uart_events_example_main.c
+++ b/examples/peripherals/uart/uart_events/main/uart_events_example_main.c
@@ -140,11 +140,7 @@ void app_main()
     uart_driver_install(EX_UART_NUM, BUF_SIZE * 2, BUF_SIZE * 2, 20, &uart0_queue, 0);
 
     //Set uart pattern detect function.
-#if CONFIG_IDF_TARGET_ESP32
-    uart_enable_pattern_det_intr(EX_UART_NUM, '+', PATTERN_CHR_NUM, 10000, 10, 10);
-#elif CONFIG_IDF_TARGET_ESP32S2BETA
-    uart_enable_pattern_det_intr(EX_UART_NUM, '+', PATTERN_CHR_NUM, 9, 0, 0);
-#endif
+    uart_enable_pattern_det_baud_intr(EX_UART_NUM, '+', PATTERN_CHR_NUM, 9, 0, 0);
     //Reset the pattern queue length to record at most 20 pattern positions.
     uart_pattern_queue_reset(EX_UART_NUM, 20);
 
diff --git a/examples/protocols/pppos_client/components/modem/src/esp_modem.c b/examples/protocols/pppos_client/components/modem/src/esp_modem.c
index 148d67473c..a75fa95865 100644
--- a/examples/protocols/pppos_client/components/modem/src/esp_modem.c
+++ b/examples/protocols/pppos_client/components/modem/src/esp_modem.c
@@ -28,9 +28,9 @@
 #define ESP_MODEM_LINE_BUFFER_SIZE (CONFIG_EXAMPLE_UART_RX_BUFFER_SIZE / 2)
 #define ESP_MODEM_EVENT_QUEUE_SIZE (16)
 
-#define MIN_PATTERN_INTERVAL (10000)
-#define MIN_POST_IDLE (10)
-#define MIN_PRE_IDLE (10)
+#define MIN_PATTERN_INTERVAL (9)
+#define MIN_POST_IDLE (0)
+#define MIN_PRE_IDLE (0)
 
 /**
  * @brief Macro defined for error checking
@@ -264,12 +264,12 @@ static esp_err_t esp_modem_dte_send_wait(modem_dte_t *dte, const char *data, uin
     MODEM_CHECK(res >= len, "wait prompt [%s] timeout", err, prompt);
     MODEM_CHECK(!strncmp(prompt, (const char *)buffer, len), "get wrong prompt: %s", err, buffer);
     free(buffer);
-    uart_enable_pattern_det_intr(esp_dte->uart_port, '\n', 1, MIN_PATTERN_INTERVAL, MIN_POST_IDLE, MIN_PRE_IDLE);
+    uart_enable_pattern_det_baud_intr(esp_dte->uart_port, '\n', 1, MIN_PATTERN_INTERVAL, MIN_POST_IDLE, MIN_PRE_IDLE);
     return ESP_OK;
 err:
     free(buffer);
 err_write:
-    uart_enable_pattern_det_intr(esp_dte->uart_port, '\n', 1, MIN_PATTERN_INTERVAL, MIN_POST_IDLE, MIN_PRE_IDLE);
+    uart_enable_pattern_det_baud_intr(esp_dte->uart_port, '\n', 1, MIN_PATTERN_INTERVAL, MIN_POST_IDLE, MIN_PRE_IDLE);
 err_param:
     return ESP_FAIL;
 }
@@ -298,7 +298,7 @@ static esp_err_t esp_modem_dte_change_mode(modem_dte_t *dte, modem_mode_t new_mo
     case MODEM_COMMAND_MODE:
         uart_disable_rx_intr(esp_dte->uart_port);
         uart_flush(esp_dte->uart_port);
-        uart_enable_pattern_det_intr(esp_dte->uart_port, '\n', 1, MIN_PATTERN_INTERVAL, MIN_POST_IDLE, MIN_PRE_IDLE);
+        uart_enable_pattern_det_baud_intr(esp_dte->uart_port, '\n', 1, MIN_PATTERN_INTERVAL, MIN_POST_IDLE, MIN_PRE_IDLE);
         uart_pattern_queue_reset(esp_dte->uart_port, CONFIG_EXAMPLE_UART_PATTERN_QUEUE_SIZE);
         MODEM_CHECK(dce->set_working_mode(dce, new_mode) == ESP_OK, "set new working mode:%d failed", err, new_mode);
         break;
@@ -392,7 +392,7 @@ modem_dte_t *esp_modem_dte_init(const esp_modem_dte_config_t *config)
                               CONFIG_EXAMPLE_UART_EVENT_QUEUE_SIZE, &(esp_dte->event_queue), 0);
     MODEM_CHECK(res == ESP_OK, "install uart driver failed", err_uart_config);
     /* Set pattern interrupt, used to detect the end of a line. */
-    res = uart_enable_pattern_det_intr(esp_dte->uart_port, '\n', 1, MIN_PATTERN_INTERVAL, MIN_POST_IDLE, MIN_PRE_IDLE);
+    res = uart_enable_pattern_det_baud_intr(esp_dte->uart_port, '\n', 1, MIN_PATTERN_INTERVAL, MIN_POST_IDLE, MIN_PRE_IDLE);
     /* Set pattern queue size */
     res |= uart_pattern_queue_reset(esp_dte->uart_port, CONFIG_EXAMPLE_UART_PATTERN_QUEUE_SIZE);
     MODEM_CHECK(res == ESP_OK, "config uart pattern failed", err_uart_pattern);