sdio_slave: format source file

components/driver/sdio_slave.c

@@ -207,7 +207,9 @@ static inline void deinit_context(void)
         vQueueDelete(context.ret_queue);
         context.ret_queue = NULL;
     }
-    if (context.remain_cnt != NULL) vSemaphoreDelete(context.remain_cnt);
+    if (context.remain_cnt != NULL) {
+        vSemaphoreDelete(context.remain_cnt);
+    }
     free(context.hal->send_desc_queue.data);
     context.hal->send_desc_queue.data = NULL;
     free(context.hal);
@@ -222,7 +224,9 @@ static esp_err_t init_context(const sdio_slave_config_t *config)
 
     //initialize and configure the HAL
     context.hal = (sdio_slave_context_t *)heap_caps_calloc(sizeof(sdio_slave_context_t), 1, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
-    if (context.hal == NULL) goto no_mem;
+    if (context.hal == NULL) {
+        goto no_mem;
+    }
 
     context.hal->sending_mode = config->sending_mode;
     context.hal->timing = config->timing;
@@ -233,7 +237,9 @@ static esp_err_t init_context(const sdio_slave_config_t *config)
     //one item is not used.
     buf->size = SDIO_SLAVE_SEND_DESC_SIZE * (config->send_queue_size + 1);
     buf->data = (uint8_t *)heap_caps_malloc(buf->size, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
-    if (buf->data == NULL) goto no_mem;
+    if (buf->data == NULL) {
+        goto no_mem;
+    }
 
     sdio_slave_hal_init(context.hal);
 
@@ -251,10 +257,14 @@ static esp_err_t init_context(const sdio_slave_config_t *config)
     }
 
     context.remain_cnt = xSemaphoreCreateCounting(context.config.send_queue_size, context.config.send_queue_size);
-    if (context.remain_cnt == NULL) goto no_mem;
+    if (context.remain_cnt == NULL) {
+        goto no_mem;
+    }
 
     context.ret_queue = xQueueCreate(config->send_queue_size, sizeof(void *));
-    if (context.ret_queue == NULL) goto no_mem;
+    if (context.ret_queue == NULL) {
+        goto no_mem;
+    }
 
     return ESP_OK;
 
@@ -335,14 +345,20 @@ esp_err_t sdio_slave_initialize(sdio_slave_config_t *config)
     intr_handle_t intr_handle = NULL;
     const int flags = 0;
     r = esp_intr_alloc(ETS_SLC0_INTR_SOURCE, flags, sdio_intr, NULL, &intr_handle);
-    if (r != ESP_OK) return r;
+    if (r != ESP_OK) {
+        return r;
+    }
 
     r = init_context(config);
-    if (r != ESP_OK) return r;
+    if (r != ESP_OK) {
+        return r;
+    }
     context.intr_handle = intr_handle;
 
     r = sdio_slave_hw_init(config);
-    if (r != ESP_OK) return r;
+    if (r != ESP_OK) {
+        return r;
+    }
 
     sdio_slave_reset();
     return ESP_OK;
@@ -362,7 +378,9 @@ void sdio_slave_deinit(void)
     //unregister all buffers that is loaded and not returned
     while (1) {
         desc = (recv_desc_t *)sdio_slave_hal_recv_unload_desc(context.hal);
-        if (desc == NULL) break;
+        if (desc == NULL) {
+            break;
+        }
         free(desc);
     }
     esp_err_t ret = esp_intr_free(context.intr_handle);
@@ -378,13 +396,17 @@ esp_err_t sdio_slave_start(void)
     sdio_slave_hostint_t intr = (sdio_slave_hostint_t)UINT32_MAX;
     sdio_slave_hal_hostint_clear(context.hal, &intr);
     ret = sdio_slave_hal_send_start(context.hal);
-    if (ret != ESP_OK) return ret;
+    if (ret != ESP_OK) {
+        return ret;
+    }
 
     critical_enter_recv();
     sdio_slave_hal_recv_start(context.hal);
     critical_exit_recv();
     ret = ESP_OK;
-    if (ret != ESP_OK) return ret;
+    if (ret != ESP_OK) {
+        return ret;
+    }
 
     sdio_slave_hal_set_ioready(context.hal, true);
     return ESP_OK;
@@ -439,11 +461,15 @@ static void sdio_intr_host(void* arg)
     portBASE_TYPE yield = pdFALSE;
     for (int i = 0; i < 8; i++) {
         if (BIT(i) & int_val) {
-            if (context.config.event_cb != NULL) (*context.config.event_cb)(i);
+            if (context.config.event_cb != NULL) {
+                (*context.config.event_cb)(i);
+            }
             xSemaphoreGiveFromISR(context.events[i], &yield);
         }
     }
-    if (yield) portYIELD_FROM_ISR();
+    if (yield) {
+        portYIELD_FROM_ISR();
+    }
 }
 
 esp_err_t sdio_slave_wait_int(int pos, TickType_t wait)
@@ -454,8 +480,12 @@ esp_err_t sdio_slave_wait_int(int pos, TickType_t wait)
 
 uint8_t sdio_slave_read_reg(int pos)
 {
-    if (pos >= 28 && pos <= 31) SDIO_SLAVE_LOGW("%s: interrupt reg, for reference", __FUNCTION__);
+    if (pos >= 28 && pos <= 31) {
-    if (pos < 0 || pos >= 64) SDIO_SLAVE_LOGE("read register address wrong");
+        SDIO_SLAVE_LOGW("%s: interrupt reg, for reference", __FUNCTION__);
+    }
+    if (pos < 0 || pos >= 64) {
+        SDIO_SLAVE_LOGE("read register address wrong");
+    }
     return sdio_slave_hal_host_get_reg(context.hal, pos);
 }
 
@@ -549,7 +579,9 @@ static void sdio_intr_send(void* arg)
 
     sdio_slave_hal_send_new_packet_if_exist(context.hal);
 
-    if (yield) portYIELD_FROM_ISR();
+    if (yield) {
+        portYIELD_FROM_ISR();
+    }
 }
 
 esp_err_t sdio_slave_send_queue(uint8_t *addr, size_t len, void *arg, TickType_t wait)
@@ -559,12 +591,16 @@ esp_err_t sdio_slave_send_queue(uint8_t* addr, size_t len, void* arg, TickType_t
                      ESP_ERR_INVALID_ARG);
 
     portBASE_TYPE cnt_ret = xSemaphoreTake(context.remain_cnt, wait);
-    if (cnt_ret != pdTRUE) return ESP_ERR_TIMEOUT;
+    if (cnt_ret != pdTRUE) {
+        return ESP_ERR_TIMEOUT;
+    }
 
     portENTER_CRITICAL(&context.write_spinlock);
     esp_err_t ret = sdio_slave_hal_send_queue(context.hal, addr, len, arg);
     portEXIT_CRITICAL(&context.write_spinlock);
-    if (ret != ESP_OK) return ret;
+    if (ret != ESP_OK) {
+        return ret;
+    }
 
     return ESP_OK;
 }
@@ -573,8 +609,12 @@ esp_err_t sdio_slave_send_get_finished(void** out_arg, TickType_t wait)
 {
     void *arg = NULL;
     portBASE_TYPE err = xQueueReceive(context.ret_queue, &arg, wait);
-    if (out_arg) *out_arg = arg;
+    if (out_arg) {
-    if (err != pdTRUE) return ESP_ERR_TIMEOUT;
+        *out_arg = arg;
+    }
+    if (err != pdTRUE) {
+        return ESP_ERR_TIMEOUT;
+    }
     return ESP_OK;
 }
 
@@ -584,9 +624,13 @@ esp_err_t sdio_slave_transmit(uint8_t* addr, size_t len)
     uint32_t ret_stamp;
 
     esp_err_t err = sdio_slave_send_queue(addr, len, (void *)timestamp, portMAX_DELAY);
-    if (err != ESP_OK) return err;
+    if (err != ESP_OK) {
+        return err;
+    }
     err = sdio_slave_send_get_finished((void **)&ret_stamp, portMAX_DELAY);
-    if (err != ESP_OK) return err;
+    if (err != ESP_OK) {
+        return err;
+    }
     SDIO_SLAVE_CHECK(ret_stamp == timestamp, "already sent without return before", ESP_ERR_INVALID_STATE);
 
     return ESP_OK;
@@ -644,7 +688,9 @@ static esp_err_t recv_flush_data(void)
 {
     while (1) {
         portBASE_TYPE ret = xSemaphoreTake(context.recv_event, 0);
-        if (ret == pdFALSE) break;
+        if (ret == pdFALSE) {
+            break;
+        }
         critical_enter_recv();
         sdio_slave_hal_recv_flush_one_buffer(context.hal);
         critical_exit_recv();
@@ -667,7 +713,9 @@ static void sdio_intr_recv(void* arg)
         // if no more items on the list, go back and check again the interrupt,
         // will loop until the interrupt bit is kept cleared.
     }
-    if (yield) portYIELD_FROM_ISR();
+    if (yield) {
+        portYIELD_FROM_ISR();
+    }
 }
 
 esp_err_t sdio_slave_recv_load_buf(sdio_slave_buf_handle_t handle)
@@ -711,8 +759,12 @@ esp_err_t sdio_slave_recv(sdio_slave_buf_handle_t* handle_ret, uint8_t **out_add
     }
     if (ret == ESP_OK) {
         recv_desc_t *desc = (recv_desc_t *)(*handle_ret);
-        if (out_addr) *out_addr = (uint8_t*)desc->hal_desc.buf;
+        if (out_addr) {
-        if (out_len) *out_len = desc->hal_desc.length;
+            *out_addr = (uint8_t *)desc->hal_desc.buf;
+        }
+        if (out_len) {
+            *out_len = desc->hal_desc.length;
+        }
     }
     return ret;
 }
@@ -721,7 +773,9 @@ esp_err_t sdio_slave_recv_packet(sdio_slave_buf_handle_t* handle_ret, TickType_t
 {
     SDIO_SLAVE_CHECK(handle_ret != NULL, "handle address cannot be 0", ESP_ERR_INVALID_ARG);
     portBASE_TYPE err = xSemaphoreTake(context.recv_event, wait);
-    if (err == pdFALSE) return ESP_ERR_TIMEOUT;
+    if (err == pdFALSE) {
+        return ESP_ERR_TIMEOUT;
+    }
 
     esp_err_t ret = ESP_OK;
     critical_enter_recv();
@@ -753,9 +807,13 @@ esp_err_t sdio_slave_recv_unregister_buf(sdio_slave_buf_handle_t handle)
 
 uint8_t *sdio_slave_recv_get_buf(sdio_slave_buf_handle_t handle, size_t *len_o)
 {
-    if (handle == NULL) return NULL;
+    if (handle == NULL) {
+        return NULL;
+    }
     recv_desc_t *desc = (recv_desc_t *)handle;
 
-    if (len_o!= NULL) *len_o= desc->hal_desc.length;
+    if (len_o != NULL) {
+        *len_o = desc->hal_desc.length;
+    }
     return (uint8_t *)desc->hal_desc.buf;
 }