I2C: i2c.h/i2c.c applied new code formatting

components/driver/i2c.c

@@ -31,7 +31,7 @@
 #include "driver/i2c.h"
 #include "driver/periph_ctrl.h"
 
-static const char* I2C_TAG = "i2c";
+static const char *I2C_TAG = "i2c";
 #define I2C_CHECK(a, str, ret)  if(!(a)) {                                             \
         ESP_LOGE(I2C_TAG,"%s:%d (%s):%s", __FILE__, __LINE__, __FUNCTION__, str);      \
         return (ret);                                                                   \
@@ -92,7 +92,7 @@ static const char* I2C_TAG = "i2c";
 
 typedef struct {
     i2c_hw_cmd_t hw_cmd;
-    uint8_t* data;     /*!< data address */
+    uint8_t *data;     /*!< data address */
     uint8_t byte_cmd;  /*!< to save cmd for one byte command mode */
 } i2c_cmd_t;
 
@@ -102,9 +102,9 @@ typedef struct i2c_cmd_link {
 } i2c_cmd_link_t;
 
 typedef struct {
-    i2c_cmd_link_t* head;     /*!< head of the command link */
-    i2c_cmd_link_t* cur;      /*!< last node of the command link */
-    i2c_cmd_link_t* free;     /*!< the first node to free of the command link */
+    i2c_cmd_link_t *head;     /*!< head of the command link */
+    i2c_cmd_link_t *cur;      /*!< last node of the command link */
+    i2c_cmd_link_t *free;     /*!< the first node to free of the command link */
 } i2c_cmd_desc_t;
 
 typedef enum {
@@ -132,7 +132,7 @@ typedef struct {
     i2c_cmd_desc_t cmd_link;         /*!< I2C command link */
     QueueHandle_t cmd_evt_queue;     /*!< I2C command event queue */
 #if CONFIG_SPIRAM_USE_MALLOC
-    uint8_t* evt_queue_storage;      /*!< The buffer that will hold the items in the queue */
+    uint8_t *evt_queue_storage;      /*!< The buffer that will hold the items in the queue */
     int intr_alloc_flags;            /*!< Used to allocate the interrupt */
     StaticQueue_t evt_queue_buffer;  /*!< The buffer that will hold the queue structure*/
 #endif
@@ -165,14 +165,14 @@ static i2c_context_t i2c_context[I2C_NUM_MAX] = {
 };
 
 static i2c_obj_t *p_i2c_obj[I2C_NUM_MAX] = {0};
-static void i2c_isr_handler_default(void* arg);
+static void i2c_isr_handler_default(void *arg);
 static void IRAM_ATTR i2c_master_cmd_begin_static(i2c_port_t i2c_num);
 static esp_err_t IRAM_ATTR i2c_hw_fsm_reset(i2c_port_t i2c_num);
 
 static void i2c_hw_disable(i2c_port_t i2c_num)
 {
     I2C_ENTER_CRITICAL(&(i2c_context[i2c_num].spinlock));
-    if (i2c_context[i2c_num].hw_enabled != false){
+    if (i2c_context[i2c_num].hw_enabled != false) {
         periph_module_disable(i2c_periph_signal[i2c_num].module);
         i2c_context[i2c_num].hw_enabled = false;
     }
@@ -182,7 +182,7 @@ static void i2c_hw_disable(i2c_port_t i2c_num)
 static void i2c_hw_enable(i2c_port_t i2c_num)
 {
     I2C_ENTER_CRITICAL(&(i2c_context[i2c_num].spinlock));
-    if (i2c_context[i2c_num].hw_enabled != true){
+    if (i2c_context[i2c_num].hw_enabled != true) {
         periph_module_enable(i2c_periph_signal[i2c_num].module);
         i2c_context[i2c_num].hw_enabled = true;
     }
@@ -197,27 +197,27 @@ we should free or modify the source data only after the i2c_master_cmd_begin fun
 has only 32 bytes.
 */
 esp_err_t i2c_driver_install(i2c_port_t i2c_num, i2c_mode_t mode, size_t slv_rx_buf_len, size_t slv_tx_buf_len,
-    int intr_alloc_flags)
+                             int intr_alloc_flags)
 {
     I2C_CHECK(i2c_num < I2C_NUM_MAX, I2C_NUM_ERROR_STR, ESP_ERR_INVALID_ARG);
     I2C_CHECK(mode == I2C_MODE_MASTER || ( slv_rx_buf_len > 100 || slv_tx_buf_len > 100 ), I2C_SLAVE_BUFFER_LEN_ERR_STR,
-        ESP_ERR_INVALID_ARG);
+              ESP_ERR_INVALID_ARG);
     if (p_i2c_obj[i2c_num] == NULL) {
 
 #if !CONFIG_SPIRAM_USE_MALLOC
-        p_i2c_obj[i2c_num] = (i2c_obj_t*) calloc(1, sizeof(i2c_obj_t));
+        p_i2c_obj[i2c_num] = (i2c_obj_t *) calloc(1, sizeof(i2c_obj_t));
 #else
-        if( !(intr_alloc_flags & ESP_INTR_FLAG_IRAM) ) {
-            p_i2c_obj[i2c_num] = (i2c_obj_t*) calloc(1, sizeof(i2c_obj_t));
+        if ( !(intr_alloc_flags & ESP_INTR_FLAG_IRAM) ) {
+            p_i2c_obj[i2c_num] = (i2c_obj_t *) calloc(1, sizeof(i2c_obj_t));
         } else {
-            p_i2c_obj[i2c_num] = (i2c_obj_t*) heap_caps_calloc(1, sizeof(i2c_obj_t), MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
+            p_i2c_obj[i2c_num] = (i2c_obj_t *) heap_caps_calloc(1, sizeof(i2c_obj_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
         }
 #endif
         if (p_i2c_obj[i2c_num] == NULL) {
             ESP_LOGE(I2C_TAG, I2C_DRIVER_MALLOC_ERR_STR);
             return ESP_FAIL;
         }
-        i2c_obj_t* p_i2c = p_i2c_obj[i2c_num];
+        i2c_obj_t *p_i2c = p_i2c_obj[i2c_num];
         p_i2c->i2c_num = i2c_num;
         p_i2c->mode = mode;
         p_i2c->cmd_idx = 0;
@@ -270,11 +270,11 @@ esp_err_t i2c_driver_install(i2c_port_t i2c_num, i2c_mode_t mode, size_t slv_rx_
 #if !CONFIG_SPIRAM_USE_MALLOC
             p_i2c->cmd_evt_queue = xQueueCreate(I2C_EVT_QUEUE_LEN, sizeof(i2c_cmd_evt_t));
 #else
-            if( !(intr_alloc_flags & ESP_INTR_FLAG_IRAM) ) {
+            if ( !(intr_alloc_flags & ESP_INTR_FLAG_IRAM) ) {
                 p_i2c->cmd_evt_queue = xQueueCreate(I2C_EVT_QUEUE_LEN, sizeof(i2c_cmd_evt_t));
             } else {
-                p_i2c->evt_queue_storage = (uint8_t *)heap_caps_calloc(I2C_EVT_QUEUE_LEN, sizeof(i2c_cmd_evt_t), MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
-                if( p_i2c->evt_queue_storage == NULL ) {
+                p_i2c->evt_queue_storage = (uint8_t *)heap_caps_calloc(I2C_EVT_QUEUE_LEN, sizeof(i2c_cmd_evt_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
+                if ( p_i2c->evt_queue_storage == NULL ) {
                     ESP_LOGE(I2C_TAG, I2C_DRIVER_MALLOC_ERR_STR);
                     goto err;
                 }
@@ -307,7 +307,7 @@ esp_err_t i2c_driver_install(i2c_port_t i2c_num, i2c_mode_t mode, size_t slv_rx_
     i2c_isr_register(i2c_num, i2c_isr_handler_default, p_i2c_obj[i2c_num], intr_alloc_flags, &p_i2c_obj[i2c_num]->intr_handle);
     return ESP_OK;
 
-    err:
+err:
     //Some error has happened. Free/destroy all allocated things and return ESP_FAIL.
     if (p_i2c_obj[i2c_num]) {
         if (p_i2c_obj[i2c_num]->rx_ring_buf) {
@@ -356,7 +356,7 @@ esp_err_t i2c_driver_delete(i2c_port_t i2c_num)
     I2C_CHECK(i2c_num < I2C_NUM_MAX, I2C_NUM_ERROR_STR, ESP_ERR_INVALID_ARG);
     I2C_CHECK(p_i2c_obj[i2c_num] != NULL, I2C_DRIVER_ERR_STR, ESP_FAIL);
 
-    i2c_obj_t* p_i2c = p_i2c_obj[i2c_num];
+    i2c_obj_t *p_i2c = p_i2c_obj[i2c_num];
     i2c_hal_disable_intr_mask(&(i2c_context[i2c_num].hal), I2C_INTR_MASK);
     esp_intr_free(p_i2c->intr_handle);
     p_i2c->intr_handle = NULL;
@@ -387,10 +387,10 @@ esp_err_t i2c_driver_delete(i2c_port_t i2c_num)
         p_i2c->tx_buf_length = 0;
     }
 #ifdef CONFIG_PM_ENABLE
-        if (p_i2c->pm_lock) {
-            esp_pm_lock_delete(p_i2c->pm_lock);
-            p_i2c->pm_lock = NULL;
-        }
+    if (p_i2c->pm_lock) {
+        esp_pm_lock_delete(p_i2c->pm_lock);
+        p_i2c->pm_lock = NULL;
+    }
 #endif
 #if CONFIG_SPIRAM_USE_MALLOC
     if (p_i2c_obj[i2c_num]->evt_queue_storage) {
@@ -426,7 +426,7 @@ esp_err_t i2c_reset_rx_fifo(i2c_port_t i2c_num)
 
 static void IRAM_ATTR i2c_isr_handler_default(void *arg)
 {
-    i2c_obj_t* p_i2c = (i2c_obj_t*) arg;
+    i2c_obj_t *p_i2c = (i2c_obj_t *) arg;
     int i2c_num = p_i2c->i2c_num;
     i2c_intr_event_t evt_type = I2C_INTR_EVENT_ERR;
     portBASE_TYPE HPTaskAwoken = pdFALSE;
@@ -439,7 +439,7 @@ static void IRAM_ATTR i2c_isr_handler_default(void *arg)
         if (evt_type == I2C_INTR_EVENT_NACK) {
             p_i2c_obj[i2c_num]->status = I2C_STATUS_ACK_ERROR;
             i2c_master_cmd_begin_static(i2c_num);
-        } else if(evt_type == I2C_INTR_EVENT_TOUT) {
+        } else if (evt_type == I2C_INTR_EVENT_TOUT) {
             p_i2c_obj[i2c_num]->status = I2C_STATUS_TIMEOUT;
             i2c_master_cmd_begin_static(i2c_num);
         } else if (evt_type == I2C_INTR_EVENT_ARBIT_LOST) {
@@ -457,8 +457,8 @@ static void IRAM_ATTR i2c_isr_handler_default(void *arg)
         };
         xQueueSendFromISR(p_i2c->cmd_evt_queue, &evt, &HPTaskAwoken);
     } else {
-       i2c_hal_slave_handle_event(&(i2c_context[i2c_num].hal), &evt_type);
-       if (evt_type == I2C_INTR_EVENT_TRANS_DONE || evt_type == I2C_INTR_EVENT_RXFIFO_FULL) {
+        i2c_hal_slave_handle_event(&(i2c_context[i2c_num].hal), &evt_type);
+        if (evt_type == I2C_INTR_EVENT_TRANS_DONE || evt_type == I2C_INTR_EVENT_RXFIFO_FULL) {
             uint32_t rx_fifo_cnt;
             i2c_hal_get_rxfifo_cnt(&(i2c_context[i2c_num].hal), &rx_fifo_cnt);
             i2c_hal_read_rxfifo(&(i2c_context[i2c_num].hal), p_i2c->data_buf, rx_fifo_cnt);
@@ -468,7 +468,7 @@ static void IRAM_ATTR i2c_isr_handler_default(void *arg)
             uint32_t tx_fifo_rem;
             i2c_hal_get_txfifo_cnt(&(i2c_context[i2c_num].hal), &tx_fifo_rem);
             size_t size = 0;
-            uint8_t *data = (uint8_t*) xRingbufferReceiveUpToFromISR(p_i2c->tx_ring_buf, &size, tx_fifo_rem);
+            uint8_t *data = (uint8_t *) xRingbufferReceiveUpToFromISR(p_i2c->tx_ring_buf, &size, tx_fifo_rem);
             if (data) {
                 i2c_hal_write_txfifo(&(i2c_context[i2c_num].hal), data, size);
                 vRingbufferReturnItemFromISR(p_i2c->tx_ring_buf, data, &HPTaskAwoken);
@@ -530,8 +530,8 @@ static esp_err_t i2c_master_clear_bus(i2c_port_t i2c_num)
         gpio_set_level(scl_io, 0);
         ets_delay_us(scl_half_period);
     }
-    gpio_set_level(sda_io,0); // setup for STOP
-    gpio_set_level(scl_io,1);
+    gpio_set_level(sda_io, 0); // setup for STOP
+    gpio_set_level(scl_io, 1);
     ets_delay_us(scl_half_period);
     gpio_set_level(sda_io, 1); // STOP, SDA low -> high while SCL is HIGH
     i2c_set_pin(i2c_num, sda_io, scl_io, 1, 1, I2C_MODE_MASTER);
@@ -583,7 +583,7 @@ static esp_err_t i2c_hw_fsm_reset(i2c_port_t i2c_num)
     return ESP_OK;
 }
 
-esp_err_t i2c_param_config(i2c_port_t i2c_num, const i2c_config_t* i2c_conf)
+esp_err_t i2c_param_config(i2c_port_t i2c_num, const i2c_config_t *i2c_conf)
 {
     I2C_CHECK(i2c_num < I2C_NUM_MAX, I2C_NUM_ERROR_STR, ESP_ERR_INVALID_ARG);
     I2C_CHECK(i2c_conf != NULL, I2C_ADDR_ERROR_STR, ESP_ERR_INVALID_ARG);
@@ -630,7 +630,7 @@ esp_err_t i2c_set_period(i2c_port_t i2c_num, int high_period, int low_period)
     return ESP_OK;
 }
 
-esp_err_t i2c_get_period(i2c_port_t i2c_num, int* high_period, int* low_period)
+esp_err_t i2c_get_period(i2c_port_t i2c_num, int *high_period, int *low_period)
 {
     I2C_CHECK(i2c_num < I2C_NUM_MAX && high_period != NULL && low_period != NULL, I2C_NUM_ERROR_STR, ESP_ERR_INVALID_ARG);
     I2C_ENTER_CRITICAL(&(i2c_context[i2c_num].spinlock));
@@ -670,7 +670,7 @@ esp_err_t i2c_set_start_timing(i2c_port_t i2c_num, int setup_time, int hold_time
     return ESP_OK;
 }
 
-esp_err_t i2c_get_start_timing(i2c_port_t i2c_num, int* setup_time, int* hold_time)
+esp_err_t i2c_get_start_timing(i2c_port_t i2c_num, int *setup_time, int *hold_time)
 {
     I2C_CHECK(i2c_num < I2C_NUM_MAX && setup_time != NULL && hold_time != NULL, I2C_NUM_ERROR_STR, ESP_ERR_INVALID_ARG);
     I2C_ENTER_CRITICAL(&(i2c_context[i2c_num].spinlock));
@@ -691,7 +691,7 @@ esp_err_t i2c_set_stop_timing(i2c_port_t i2c_num, int setup_time, int hold_time)
     return ESP_OK;
 }
 
-esp_err_t i2c_get_stop_timing(i2c_port_t i2c_num, int* setup_time, int* hold_time)
+esp_err_t i2c_get_stop_timing(i2c_port_t i2c_num, int *setup_time, int *hold_time)
 {
     I2C_CHECK(i2c_num < I2C_NUM_MAX && setup_time != NULL && hold_time != NULL, I2C_NUM_ERROR_STR, ESP_ERR_INVALID_ARG);
     I2C_ENTER_CRITICAL(&(i2c_context[i2c_num].spinlock));
@@ -712,7 +712,7 @@ esp_err_t i2c_set_data_timing(i2c_port_t i2c_num, int sample_time, int hold_time
     return ESP_OK;
 }
 
-esp_err_t i2c_get_data_timing(i2c_port_t i2c_num, int* sample_time, int* hold_time)
+esp_err_t i2c_get_data_timing(i2c_port_t i2c_num, int *sample_time, int *hold_time)
 {
     I2C_CHECK(i2c_num < I2C_NUM_MAX && sample_time != NULL && hold_time != NULL, I2C_NUM_ERROR_STR, ESP_ERR_INVALID_ARG);
     I2C_ENTER_CRITICAL(&(i2c_context[i2c_num].spinlock));
@@ -732,14 +732,14 @@ esp_err_t i2c_set_timeout(i2c_port_t i2c_num, int timeout)
     return ESP_OK;
 }
 
-esp_err_t i2c_get_timeout(i2c_port_t i2c_num, int* timeout)
+esp_err_t i2c_get_timeout(i2c_port_t i2c_num, int *timeout)
 {
     I2C_CHECK(i2c_num < I2C_NUM_MAX && timeout != NULL, I2C_NUM_ERROR_STR, ESP_ERR_INVALID_ARG);
     i2c_hal_get_tout(&(i2c_context[i2c_num].hal), timeout);
     return ESP_OK;
 }
 
-esp_err_t i2c_isr_register(i2c_port_t i2c_num, void (*fn)(void*), void * arg, int intr_alloc_flags, intr_handle_t *handle)
+esp_err_t i2c_isr_register(i2c_port_t i2c_num, void (*fn)(void *), void *arg, int intr_alloc_flags, intr_handle_t *handle)
 {
     I2C_CHECK(i2c_num < I2C_NUM_MAX, I2C_NUM_ERROR_STR, ESP_ERR_INVALID_ARG);
     I2C_CHECK(fn != NULL, I2C_ADDR_ERROR_STR, ESP_ERR_INVALID_ARG);
@@ -762,11 +762,11 @@ esp_err_t i2c_set_pin(i2c_port_t i2c_num, int sda_io_num, int scl_io_num, bool s
               I2C_SCL_IO_ERR_STR,
               ESP_ERR_INVALID_ARG);
     I2C_CHECK(sda_io_num < 0 ||
-               (sda_pullup_en == GPIO_PULLUP_ENABLE && GPIO_IS_VALID_OUTPUT_GPIO(sda_io_num)) ||
-               sda_pullup_en == GPIO_PULLUP_DISABLE, I2C_GPIO_PULLUP_ERR_STR, ESP_ERR_INVALID_ARG);
+              (sda_pullup_en == GPIO_PULLUP_ENABLE && GPIO_IS_VALID_OUTPUT_GPIO(sda_io_num)) ||
+              sda_pullup_en == GPIO_PULLUP_DISABLE, I2C_GPIO_PULLUP_ERR_STR, ESP_ERR_INVALID_ARG);
     I2C_CHECK(scl_io_num < 0 ||
-               (scl_pullup_en == GPIO_PULLUP_ENABLE && GPIO_IS_VALID_OUTPUT_GPIO(scl_io_num)) ||
-               scl_pullup_en == GPIO_PULLUP_DISABLE, I2C_GPIO_PULLUP_ERR_STR, ESP_ERR_INVALID_ARG);
+              (scl_pullup_en == GPIO_PULLUP_ENABLE && GPIO_IS_VALID_OUTPUT_GPIO(scl_io_num)) ||
+              scl_pullup_en == GPIO_PULLUP_DISABLE, I2C_GPIO_PULLUP_ERR_STR, ESP_ERR_INVALID_ARG);
     I2C_CHECK((sda_io_num != scl_io_num), I2C_SCL_SDA_EQUAL_ERR_STR, ESP_ERR_INVALID_ARG);
 
     int sda_in_sig, sda_out_sig, scl_in_sig, scl_out_sig;
@@ -814,9 +814,9 @@ esp_err_t i2c_set_pin(i2c_port_t i2c_num, int sda_io_num, int scl_io_num, bool s
 i2c_cmd_handle_t i2c_cmd_link_create(void)
 {
 #if !CONFIG_SPIRAM_USE_MALLOC
-    i2c_cmd_desc_t* cmd_desc = (i2c_cmd_desc_t*) calloc(1, sizeof(i2c_cmd_desc_t));
+    i2c_cmd_desc_t *cmd_desc = (i2c_cmd_desc_t *) calloc(1, sizeof(i2c_cmd_desc_t));
 #else
-    i2c_cmd_desc_t* cmd_desc = (i2c_cmd_desc_t*) heap_caps_calloc(1, sizeof(i2c_cmd_desc_t), MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
+    i2c_cmd_desc_t *cmd_desc = (i2c_cmd_desc_t *) heap_caps_calloc(1, sizeof(i2c_cmd_desc_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
 #endif
     return (i2c_cmd_handle_t) cmd_desc;
 }
@@ -826,9 +826,9 @@ void i2c_cmd_link_delete(i2c_cmd_handle_t cmd_handle)
     if (cmd_handle == NULL) {
         return;
     }
-    i2c_cmd_desc_t* cmd = (i2c_cmd_desc_t*) cmd_handle;
+    i2c_cmd_desc_t *cmd = (i2c_cmd_desc_t *) cmd_handle;
     while (cmd->free) {
-        i2c_cmd_link_t* ptmp = cmd->free;
+        i2c_cmd_link_t *ptmp = cmd->free;
         cmd->free = cmd->free->next;
         free(ptmp);
     }
@@ -839,14 +839,14 @@ void i2c_cmd_link_delete(i2c_cmd_handle_t cmd_handle)
     return;
 }
 
-static esp_err_t i2c_cmd_link_append(i2c_cmd_handle_t cmd_handle, i2c_cmd_t* cmd)
+static esp_err_t i2c_cmd_link_append(i2c_cmd_handle_t cmd_handle, i2c_cmd_t *cmd)
 {
-    i2c_cmd_desc_t* cmd_desc = (i2c_cmd_desc_t*) cmd_handle;
+    i2c_cmd_desc_t *cmd_desc = (i2c_cmd_desc_t *) cmd_handle;
     if (cmd_desc->head == NULL) {
 #if !CONFIG_SPIRAM_USE_MALLOC
-        cmd_desc->head = (i2c_cmd_link_t*) calloc(1, sizeof(i2c_cmd_link_t));
+        cmd_desc->head = (i2c_cmd_link_t *) calloc(1, sizeof(i2c_cmd_link_t));
 #else
-        cmd_desc->head = (i2c_cmd_link_t*) heap_caps_calloc(1, sizeof(i2c_cmd_link_t), MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
+        cmd_desc->head = (i2c_cmd_link_t *) heap_caps_calloc(1, sizeof(i2c_cmd_link_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
 #endif
         if (cmd_desc->head == NULL) {
             ESP_LOGE(I2C_TAG, I2C_CMD_MALLOC_ERR_STR);
@@ -856,9 +856,9 @@ static esp_err_t i2c_cmd_link_append(i2c_cmd_handle_t cmd_handle, i2c_cmd_t* cmd
         cmd_desc->free = cmd_desc->head;
     } else {
 #if !CONFIG_SPIRAM_USE_MALLOC
-        cmd_desc->cur->next = (i2c_cmd_link_t*) calloc(1, sizeof(i2c_cmd_link_t));
+        cmd_desc->cur->next = (i2c_cmd_link_t *) calloc(1, sizeof(i2c_cmd_link_t));
 #else
-        cmd_desc->cur->next = (i2c_cmd_link_t*) heap_caps_calloc(1, sizeof(i2c_cmd_link_t), MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
+        cmd_desc->cur->next = (i2c_cmd_link_t *) heap_caps_calloc(1, sizeof(i2c_cmd_link_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
 #endif
         if (cmd_desc->cur->next == NULL) {
             ESP_LOGE(I2C_TAG, I2C_CMD_MALLOC_ERR_STR);
@@ -866,11 +866,11 @@ static esp_err_t i2c_cmd_link_append(i2c_cmd_handle_t cmd_handle, i2c_cmd_t* cmd
         }
         cmd_desc->cur = cmd_desc->cur->next;
     }
-    memcpy((uint8_t*) &cmd_desc->cur->cmd, (uint8_t*) cmd, sizeof(i2c_cmd_t));
+    memcpy((uint8_t *) &cmd_desc->cur->cmd, (uint8_t *) cmd, sizeof(i2c_cmd_t));
     cmd_desc->cur->next = NULL;
     return ESP_OK;
 
-    err:
+err:
     return ESP_FAIL;
 }
 
@@ -900,7 +900,7 @@ esp_err_t i2c_master_stop(i2c_cmd_handle_t cmd_handle)
     return i2c_cmd_link_append(cmd_handle, &cmd);
 }
 
-esp_err_t i2c_master_write(i2c_cmd_handle_t cmd_handle, uint8_t* data, size_t data_len, bool ack_en)
+esp_err_t i2c_master_write(i2c_cmd_handle_t cmd_handle, uint8_t *data, size_t data_len, bool ack_en)
 {
     I2C_CHECK((data != NULL), I2C_ADDR_ERROR_STR, ESP_ERR_INVALID_ARG);
     I2C_CHECK(cmd_handle != NULL, I2C_CMD_LINK_INIT_ERR_STR, ESP_ERR_INVALID_ARG);
@@ -941,7 +941,7 @@ esp_err_t i2c_master_write_byte(i2c_cmd_handle_t cmd_handle, uint8_t data, bool
     return i2c_cmd_link_append(cmd_handle, &cmd);
 }
 
-static esp_err_t i2c_master_read_static(i2c_cmd_handle_t cmd_handle, uint8_t* data, size_t data_len, i2c_ack_type_t ack)
+static esp_err_t i2c_master_read_static(i2c_cmd_handle_t cmd_handle, uint8_t *data, size_t data_len, i2c_ack_type_t ack)
 {
     int len_tmp;
     int data_offset = 0;
@@ -965,7 +965,7 @@ static esp_err_t i2c_master_read_static(i2c_cmd_handle_t cmd_handle, uint8_t* da
     return ESP_OK;
 }
 
-esp_err_t i2c_master_read_byte(i2c_cmd_handle_t cmd_handle, uint8_t* data, i2c_ack_type_t ack)
+esp_err_t i2c_master_read_byte(i2c_cmd_handle_t cmd_handle, uint8_t *data, i2c_ack_type_t ack)
 {
     I2C_CHECK((data != NULL), I2C_ADDR_ERROR_STR, ESP_ERR_INVALID_ARG);
     I2C_CHECK(cmd_handle != NULL, I2C_CMD_LINK_INIT_ERR_STR, ESP_ERR_INVALID_ARG);
@@ -981,7 +981,7 @@ esp_err_t i2c_master_read_byte(i2c_cmd_handle_t cmd_handle, uint8_t* data, i2c_a
     return i2c_cmd_link_append(cmd_handle, &cmd);
 }
 
-esp_err_t i2c_master_read(i2c_cmd_handle_t cmd_handle, uint8_t* data, size_t data_len, i2c_ack_type_t ack)
+esp_err_t i2c_master_read(i2c_cmd_handle_t cmd_handle, uint8_t *data, size_t data_len, i2c_ack_type_t ack)
 {
     I2C_CHECK((data != NULL), I2C_ADDR_ERROR_STR, ESP_ERR_INVALID_ARG);
     I2C_CHECK(cmd_handle != NULL, I2C_CMD_LINK_INIT_ERR_STR, ESP_ERR_INVALID_ARG);
@@ -1005,7 +1005,7 @@ esp_err_t i2c_master_read(i2c_cmd_handle_t cmd_handle, uint8_t* data, size_t dat
 
 static void IRAM_ATTR i2c_master_cmd_begin_static(i2c_port_t i2c_num)
 {
-    i2c_obj_t* p_i2c = p_i2c_obj[i2c_num];
+    i2c_obj_t *p_i2c = p_i2c_obj[i2c_num];
     portBASE_TYPE HPTaskAwoken = pdFALSE;
     i2c_cmd_evt_t evt;
     if (p_i2c->cmd_link.head != NULL && p_i2c->status == I2C_STATUS_READ) {
@@ -1018,7 +1018,7 @@ static void IRAM_ATTR i2c_master_cmd_begin_static(i2c_port_t i2c_num)
             p_i2c->cmd_link.head = p_i2c->cmd_link.head->next;
         }
     } else if ((p_i2c->status == I2C_STATUS_ACK_ERROR)
-            || (p_i2c->status == I2C_STATUS_TIMEOUT)) {
+               || (p_i2c->status == I2C_STATUS_TIMEOUT)) {
         evt.type = I2C_CMD_EVT_DONE;
         xQueueOverwriteFromISR(p_i2c->cmd_evt_queue, &evt, &HPTaskAwoken);
         return;
@@ -1093,7 +1093,7 @@ static void IRAM_ATTR i2c_master_cmd_begin_static(i2c_port_t i2c_num)
 //Check whether read or write buffer in cmd_link is internal.
 static bool is_cmd_link_buffer_internal(i2c_cmd_link_t *link)
 {
-    i2c_cmd_link_t* cmd_link = link;
+    i2c_cmd_link_t *cmd_link = link;
     while (cmd_link != NULL)  {
         if (cmd_link->cmd.hw_cmd.op_code == I2C_CMD_WRITE || cmd_link->cmd.hw_cmd.op_code == I2C_CMD_READ) {
             if (cmd_link->cmd.data != NULL && !esp_ptr_internal(cmd_link->cmd.data)) {
@@ -1117,7 +1117,7 @@ esp_err_t i2c_master_cmd_begin(i2c_port_t i2c_num, i2c_cmd_handle_t cmd_handle,
     //If the i2c read or write buffer is not in internal RAM, we will return ESP_FAIL
     //to avoid the ISR handler function crashing when the cache is disabled.
     if ((p_i2c_obj[i2c_num]->intr_alloc_flags & ESP_INTR_FLAG_IRAM)) {
-        if (!is_cmd_link_buffer_internal(((i2c_cmd_desc_t*)cmd_handle)->head) ) {
+        if (!is_cmd_link_buffer_internal(((i2c_cmd_desc_t *)cmd_handle)->head) ) {
             ESP_LOGE(I2C_TAG, I2C_PSRAM_BUFFER_WARN_STR);
             return ESP_ERR_INVALID_ARG;
         }
@@ -1126,7 +1126,7 @@ esp_err_t i2c_master_cmd_begin(i2c_port_t i2c_num, i2c_cmd_handle_t cmd_handle,
     // Sometimes when the FSM get stuck, the ACK_ERR interrupt will occur endlessly until we reset the FSM and clear bus.
     static uint8_t clear_bus_cnt = 0;
     esp_err_t ret = ESP_FAIL;
-    i2c_obj_t* p_i2c = p_i2c_obj[i2c_num];
+    i2c_obj_t *p_i2c = p_i2c_obj[i2c_num];
     portTickType ticks_start = xTaskGetTickCount();
     portBASE_TYPE res = xSemaphoreTake(p_i2c->cmd_mux, ticks_to_wait);
 #ifdef CONFIG_PM_ENABLE
@@ -1137,13 +1137,13 @@ esp_err_t i2c_master_cmd_begin(i2c_port_t i2c_num, i2c_cmd_handle_t cmd_handle,
     }
     xQueueReset(p_i2c->cmd_evt_queue);
     if (p_i2c->status == I2C_STATUS_TIMEOUT
-        || i2c_hal_is_bus_busy(&(i2c_context[i2c_num].hal))) {
+            || i2c_hal_is_bus_busy(&(i2c_context[i2c_num].hal))) {
         i2c_hw_fsm_reset(i2c_num);
         clear_bus_cnt = 0;
     }
     i2c_reset_tx_fifo(i2c_num);
     i2c_reset_rx_fifo(i2c_num);
-    i2c_cmd_desc_t* cmd = (i2c_cmd_desc_t*) cmd_handle;
+    i2c_cmd_desc_t *cmd = (i2c_cmd_desc_t *) cmd_handle;
     p_i2c->cmd_link.free = cmd->free;
     p_i2c->cmd_link.cur = cmd->cur;
     p_i2c->cmd_link.head = cmd->head;
@@ -1213,13 +1213,13 @@ esp_err_t i2c_master_cmd_begin(i2c_port_t i2c_num, i2c_cmd_handle_t cmd_handle,
     return ret;
 }
 
-int i2c_slave_write_buffer(i2c_port_t i2c_num, const uint8_t* data, int size, TickType_t ticks_to_wait)
+int i2c_slave_write_buffer(i2c_port_t i2c_num, const uint8_t *data, int size, TickType_t ticks_to_wait)
 {
     I2C_CHECK(( i2c_num < I2C_NUM_MAX ), I2C_NUM_ERROR_STR, ESP_FAIL);
     I2C_CHECK(p_i2c_obj[i2c_num] != NULL, I2C_DRIVER_ERR_STR, ESP_FAIL);
     I2C_CHECK((data != NULL), I2C_ADDR_ERROR_STR, ESP_FAIL);
     I2C_CHECK(p_i2c_obj[i2c_num]->mode == I2C_MODE_SLAVE, I2C_MODE_SLAVE_ERR_STR, ESP_FAIL);
-    i2c_obj_t* p_i2c = p_i2c_obj[i2c_num];
+    i2c_obj_t *p_i2c = p_i2c_obj[i2c_num];
 
     portBASE_TYPE res;
     int cnt = 0;
@@ -1243,7 +1243,7 @@ int i2c_slave_write_buffer(i2c_port_t i2c_num, const uint8_t* data, int size, Ti
     return cnt;
 }
 
-int i2c_slave_read_buffer(i2c_port_t i2c_num, uint8_t* data, size_t max_size, TickType_t ticks_to_wait)
+int i2c_slave_read_buffer(i2c_port_t i2c_num, uint8_t *data, size_t max_size, TickType_t ticks_to_wait)
 {
     I2C_CHECK(( i2c_num < I2C_NUM_MAX ), I2C_NUM_ERROR_STR, ESP_FAIL);
     I2C_CHECK(p_i2c_obj[i2c_num] != NULL, I2C_DRIVER_ERR_STR, ESP_FAIL);
@@ -1252,7 +1252,7 @@ int i2c_slave_read_buffer(i2c_port_t i2c_num, uint8_t* data, size_t max_size, Ti
 
     size_t size = 0;
     size_t size_rem = max_size;
-    i2c_obj_t* p_i2c = p_i2c_obj[i2c_num];
+    i2c_obj_t *p_i2c = p_i2c_obj[i2c_num];
     if (xSemaphoreTake(p_i2c->slv_rx_mux, ticks_to_wait) == pdFALSE) {
         return 0;
     }
@@ -1261,8 +1261,8 @@ int i2c_slave_read_buffer(i2c_port_t i2c_num, uint8_t* data, size_t max_size, Ti
     I2C_ENTER_CRITICAL(&(i2c_context[i2c_num].spinlock));
     i2c_hal_enable_slave_rx_it(&(i2c_context[i2c_num].hal));
     I2C_EXIT_CRITICAL(&(i2c_context[i2c_num].spinlock));
-    while(size_rem && ticks_rem <= ticks_to_wait) {
-        uint8_t* pdata = (uint8_t*) xRingbufferReceiveUpTo(p_i2c->rx_ring_buf, &size, ticks_to_wait, size_rem);
+    while (size_rem && ticks_rem <= ticks_to_wait) {
+        uint8_t *pdata = (uint8_t *) xRingbufferReceiveUpTo(p_i2c->rx_ring_buf, &size, ticks_to_wait, size_rem);
         if (pdata && size > 0) {
             memcpy(data, pdata, size);
             vRingbufferReturnItem(p_i2c->rx_ring_buf, pdata);

components/driver/include/driver/i2c.h

@@ -38,7 +38,7 @@ extern "C" {
 #define I2C_NUM_1              (1) /*!< I2C port 1 */
 #define I2C_NUM_MAX            (SOC_I2C_NUM) /*!< I2C port max */
 
-typedef void* i2c_cmd_handle_t;    /*!< I2C command handle  */
+typedef void *i2c_cmd_handle_t;    /*!< I2C command handle  */
 
 /**
  * @brief I2C driver install
@@ -86,7 +86,7 @@ esp_err_t i2c_driver_delete(i2c_port_t i2c_num);
  *     - ESP_OK Success
  *     - ESP_ERR_INVALID_ARG Parameter error
  */
-esp_err_t i2c_param_config(i2c_port_t i2c_num, const i2c_config_t* i2c_conf);
+esp_err_t i2c_param_config(i2c_port_t i2c_num, const i2c_config_t *i2c_conf);
 
 /**
  * @brief reset I2C tx hardware fifo
@@ -124,7 +124,7 @@ esp_err_t i2c_reset_rx_fifo(i2c_port_t i2c_num);
  *     - ESP_OK Success
  *     - ESP_ERR_INVALID_ARG Parameter error
  */
-esp_err_t i2c_isr_register(i2c_port_t i2c_num, void (*fn)(void*), void * arg, int intr_alloc_flags, intr_handle_t *handle);
+esp_err_t i2c_isr_register(i2c_port_t i2c_num, void (*fn)(void *), void *arg, int intr_alloc_flags, intr_handle_t *handle);
 
 /**
  * @brief to delete and free I2C isr.
@@ -225,7 +225,7 @@ esp_err_t i2c_master_write_byte(i2c_cmd_handle_t cmd_handle, uint8_t data, bool
  *     - ESP_OK Success
  *     - ESP_ERR_INVALID_ARG Parameter error
  */
-esp_err_t i2c_master_write(i2c_cmd_handle_t cmd_handle, uint8_t* data, size_t data_len, bool ack_en);
+esp_err_t i2c_master_write(i2c_cmd_handle_t cmd_handle, uint8_t *data, size_t data_len, bool ack_en);
 
 /**
  * @brief Queue command for I2C master to read one byte from I2C bus
@@ -243,7 +243,7 @@ esp_err_t i2c_master_write(i2c_cmd_handle_t cmd_handle, uint8_t* data, size_t da
  *     - ESP_OK Success
  *     - ESP_ERR_INVALID_ARG Parameter error
  */
-esp_err_t i2c_master_read_byte(i2c_cmd_handle_t cmd_handle, uint8_t* data, i2c_ack_type_t ack);
+esp_err_t i2c_master_read_byte(i2c_cmd_handle_t cmd_handle, uint8_t *data, i2c_ack_type_t ack);
 
 /**
  * @brief Queue command for I2C master to read data from I2C bus
@@ -262,7 +262,7 @@ esp_err_t i2c_master_read_byte(i2c_cmd_handle_t cmd_handle, uint8_t* data, i2c_a
  *     - ESP_OK Success
  *     - ESP_ERR_INVALID_ARG Parameter error
  */
-esp_err_t i2c_master_read(i2c_cmd_handle_t cmd_handle, uint8_t* data, size_t data_len, i2c_ack_type_t ack);
+esp_err_t i2c_master_read(i2c_cmd_handle_t cmd_handle, uint8_t *data, size_t data_len, i2c_ack_type_t ack);
 
 /**
  * @brief Queue command for I2C master to generate a stop signal
@@ -315,7 +315,7 @@ esp_err_t i2c_master_cmd_begin(i2c_port_t i2c_num, i2c_cmd_handle_t cmd_handle,
  *     - ESP_FAIL(-1) Parameter error
  *     - Others(>=0) The number of data bytes that pushed to the I2C slave buffer.
  */
-int i2c_slave_write_buffer(i2c_port_t i2c_num, const uint8_t* data, int size, TickType_t ticks_to_wait);
+int i2c_slave_write_buffer(i2c_port_t i2c_num, const uint8_t *data, int size, TickType_t ticks_to_wait);
 
 /**
  * @brief I2C slave read data from internal buffer. When I2C slave receive data, isr will copy received data
@@ -332,7 +332,7 @@ int i2c_slave_write_buffer(i2c_port_t i2c_num, const uint8_t* data, int size, Ti
  *     - ESP_FAIL(-1) Parameter error
  *     - Others(>=0) The number of data bytes that read from I2C slave buffer.
  */
-int i2c_slave_read_buffer(i2c_port_t i2c_num, uint8_t* data, size_t max_size, TickType_t ticks_to_wait);
+int i2c_slave_read_buffer(i2c_port_t i2c_num, uint8_t *data, size_t max_size, TickType_t ticks_to_wait);
 
 /**
  * @brief set I2C master clock period
@@ -358,7 +358,7 @@ esp_err_t i2c_set_period(i2c_port_t i2c_num, int high_period, int low_period);
  *     - ESP_OK Success
  *     - ESP_ERR_INVALID_ARG Parameter error
  */
-esp_err_t i2c_get_period(i2c_port_t i2c_num, int* high_period, int* low_period);
+esp_err_t i2c_get_period(i2c_port_t i2c_num, int *high_period, int *low_period);
 
 /**
  * @brief enable hardware filter on I2C bus
@@ -413,7 +413,7 @@ esp_err_t i2c_set_start_timing(i2c_port_t i2c_num, int setup_time, int hold_time
  *     - ESP_OK Success
  *     - ESP_ERR_INVALID_ARG Parameter error
  */
-esp_err_t i2c_get_start_timing(i2c_port_t i2c_num, int* setup_time, int* hold_time);
+esp_err_t i2c_get_start_timing(i2c_port_t i2c_num, int *setup_time, int *hold_time);
 
 /**
  * @brief set I2C master stop signal timing
@@ -439,7 +439,7 @@ esp_err_t i2c_set_stop_timing(i2c_port_t i2c_num, int setup_time, int hold_time)
  *     - ESP_OK Success
  *     - ESP_ERR_INVALID_ARG Parameter error
  */
-esp_err_t i2c_get_stop_timing(i2c_port_t i2c_num, int* setup_time, int* hold_time);
+esp_err_t i2c_get_stop_timing(i2c_port_t i2c_num, int *setup_time, int *hold_time);
 
 /**
  * @brief set I2C data signal timing
@@ -465,7 +465,7 @@ esp_err_t i2c_set_data_timing(i2c_port_t i2c_num, int sample_time, int hold_time
  *     - ESP_OK Success
  *     - ESP_ERR_INVALID_ARG Parameter error
  */
-esp_err_t i2c_get_data_timing(i2c_port_t i2c_num, int* sample_time, int* hold_time);
+esp_err_t i2c_get_data_timing(i2c_port_t i2c_num, int *sample_time, int *hold_time);
 
 /**
  * @brief set I2C timeout value
@@ -485,7 +485,7 @@ esp_err_t i2c_set_timeout(i2c_port_t i2c_num, int timeout);
  *     - ESP_OK Success
  *     - ESP_ERR_INVALID_ARG Parameter error
  */
-esp_err_t i2c_get_timeout(i2c_port_t i2c_num, int* timeout);
+esp_err_t i2c_get_timeout(i2c_port_t i2c_num, int *timeout);
 
 /**
  * @brief set I2C data transfer mode

components/driver/test/test_i2c.c

@@ -93,7 +93,6 @@ static i2c_config_t i2c_slave_init(void)
 
 TEST_CASE("I2C i2c_set_pin() fails if sda and scl gpios are same", "[i2c]")
 {
-    // master test
     TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, i2c_set_pin(0, 0, 0, true, true , I2C_MODE_SLAVE));
 }