sdio_slave: format source file

components/driver/sdio_slave.c

@@ -104,7 +104,7 @@ static const char TAG[] = "sdio_slave";
 
 
 // sdio_slave_buf_handle_t is of type recv_desc_t*;
-typedef struct recv_desc_s{
+typedef struct recv_desc_s {
     union {
         struct {
             // the third word, pointer to next desc, is shared with the tailq entry.
@@ -163,10 +163,10 @@ typedef struct {
 
 static sdio_context_t context = CONTEXT_INIT_VAL;
 
-static void sdio_intr(void*);
-static void sdio_intr_host(void*);
-static void sdio_intr_send(void*);
-static void sdio_intr_recv(void*);
+static void sdio_intr(void *);
+static void sdio_intr_host(void *);
+static void sdio_intr_send(void *);
+static void sdio_intr_recv(void *);
 
 static esp_err_t send_flush_data(void);
 static esp_err_t recv_flush_data(void);
@@ -196,8 +196,8 @@ static void __attribute((unused)) dump_ll(lldesc_t *queue)
 
 static inline void deinit_context(void)
 {
-    context.config = (sdio_slave_config_t){};
-    for(int i = 0; i < 9; i++) {
+    context.config = (sdio_slave_config_t) {};
+    for (int i = 0; i < 9; i++) {
         if (context.events[i] != NULL) {
             vSemaphoreDelete(context.events[i]);
             context.events[i] = NULL;
@@ -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);
@@ -216,13 +218,15 @@ static inline void deinit_context(void)
 
 static esp_err_t init_context(const sdio_slave_config_t *config)
 {
-    SDIO_SLAVE_CHECK(*(uint32_t*)&context.config == 0, "sdio slave already initialized", ESP_ERR_INVALID_STATE);
+    SDIO_SLAVE_CHECK(*(uint32_t *)&context.config == 0, "sdio slave already initialized", ESP_ERR_INVALID_STATE);
     context = (sdio_context_t)CONTEXT_INIT_VAL;
     context.config = *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;
+    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;
+    }
 
     context.hal->sending_mode = config->sending_mode;
     context.hal->timing = config->timing;
@@ -231,16 +235,18 @@ static esp_err_t init_context(const sdio_slave_config_t *config)
     //initialize ringbuffer resources
     sdio_ringbuf_t *buf = &(context.hal->send_desc_queue);
     //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;
+    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;
+    }
 
     sdio_slave_hal_init(context.hal);
 
     // in theory we can queue infinite buffers in the linked list, but for multi-core reason we have to use a queue to
     // count the finished buffers.
     context.recv_event = xSemaphoreCreateCounting(UINT32_MAX, 0);
-    for(int i = 0; i < 9; i++) {
+    for (int i = 0; i < 9; i++) {
         if (i < 8) {
             context.events[i] = xSemaphoreCreateBinary();
         }   //for 8, already created.
@@ -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;
+    context.ret_queue = xQueueCreate(config->send_queue_size, sizeof(void *));
+    if (context.ret_queue == NULL) {
+        goto no_mem;
+    }
 
     return ESP_OK;
 
@@ -289,11 +299,11 @@ static inline esp_err_t sdio_slave_hw_init(sdio_slave_config_t *config)
     configure_pin(slot->clk_gpio, slot->func, false);   //clk doesn't need a pullup
     configure_pin(slot->cmd_gpio, slot->func, pullup);
     configure_pin(slot->d0_gpio, slot->func, pullup);
-    if ((config->flags & SDIO_SLAVE_FLAG_HOST_INTR_DISABLED)==0) {
+    if ((config->flags & SDIO_SLAVE_FLAG_HOST_INTR_DISABLED) == 0) {
         configure_pin(slot->d1_gpio, slot->func, pullup);
     }
-    if ((config->flags & SDIO_SLAVE_FLAG_DAT2_DISABLED)==0) {
-       configure_pin(slot->d2_gpio, slot->func, pullup);
+    if ((config->flags & SDIO_SLAVE_FLAG_DAT2_DISABLED) == 0) {
+        configure_pin(slot->d2_gpio, slot->func, pullup);
     }
     configure_pin(slot->d3_gpio, slot->func, pullup);
 
@@ -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;
@@ -361,12 +377,14 @@ 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;
+        desc = (recv_desc_t *)sdio_slave_hal_recv_unload_desc(context.hal);
+        if (desc == NULL) {
+            break;
+        }
         free(desc);
     }
     esp_err_t ret = esp_intr_free(context.intr_handle);
-    assert(ret==ESP_OK);
+    assert(ret == ESP_OK);
     (void)ret;
     context.intr_handle = NULL;
     deinit_context();
@@ -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;
@@ -422,7 +444,7 @@ void sdio_slave_stop(void)
     sdio_slave_hal_recv_stop(context.hal);
 }
 
-static void sdio_intr(void* arg)
+static void sdio_intr(void *arg)
 {
     sdio_intr_send(arg);
     sdio_intr_recv(arg);
@@ -432,18 +454,22 @@ static void sdio_intr(void* arg)
 /*---------------------------------------------------------------------------
  *                  Host
  *--------------------------------------------------------------------------*/
-static void sdio_intr_host(void* arg)
+static void sdio_intr_host(void *arg)
 {
     sdio_slave_ll_slvint_t int_val;
     sdio_slave_hal_slvint_fetch_clear(context.hal, &int_val);
     portBASE_TYPE yield = pdFALSE;
-    for(int i = 0; i < 8; i++) {
+    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 < 0 || pos >= 64) SDIO_SLAVE_LOGE("read register address wrong");
+    if (pos >= 28 && pos <= 31) {
+        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);
 }
 
@@ -515,7 +545,7 @@ esp_err_t sdio_slave_send_host_int(uint8_t pos)
  * If driver is stopped, the link list is stopped as well as the ISR invoker.
  */
 
-static void sdio_intr_send(void* arg)
+static void sdio_intr_send(void *arg)
 {
     ESP_EARLY_LOGV(TAG, "intr_send");
     portBASE_TYPE yield = pdFALSE;
@@ -541,7 +571,7 @@ static void sdio_intr_send(void* arg)
             assert(ret == pdTRUE);
         }
         //get_next_finished_arg returns the total amount of returned descs.
-        for(size_t i = 0; i < returned_cnt; i++) {
+        for (size_t i = 0; i < returned_cnt; i++) {
             ret = xSemaphoreGiveFromISR(context.remain_cnt, &yield);
             assert(ret == pdTRUE);
         }
@@ -549,44 +579,58 @@ 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)
+esp_err_t sdio_slave_send_queue(uint8_t *addr, size_t len, void *arg, TickType_t wait)
 {
     SDIO_SLAVE_CHECK(len > 0, "len <= 0", ESP_ERR_INVALID_ARG);
-    SDIO_SLAVE_CHECK(esp_ptr_dma_capable(addr) && (uint32_t)addr%4==0, "buffer to send should be DMA capable and 32-bit aligned",
-        ESP_ERR_INVALID_ARG);
+    SDIO_SLAVE_CHECK(esp_ptr_dma_capable(addr) && (uint32_t)addr % 4 == 0, "buffer to send should be DMA capable and 32-bit aligned",
+                     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;
 }
 
-esp_err_t sdio_slave_send_get_finished(void** out_arg, TickType_t wait)
+esp_err_t sdio_slave_send_get_finished(void **out_arg, TickType_t wait)
 {
-    void* arg = NULL;
+    void *arg = NULL;
     portBASE_TYPE err = xQueueReceive(context.ret_queue, &arg, wait);
-    if (out_arg) *out_arg = arg;
-    if (err != pdTRUE) return ESP_ERR_TIMEOUT;
+    if (out_arg) {
+        *out_arg = arg;
+    }
+    if (err != pdTRUE) {
+        return ESP_ERR_TIMEOUT;
+    }
     return ESP_OK;
 }
 
-esp_err_t sdio_slave_transmit(uint8_t* addr, size_t len)
+esp_err_t sdio_slave_transmit(uint8_t *addr, size_t len)
 {
     uint32_t timestamp = cpu_hal_get_cycle_count();
     uint32_t ret_stamp;
 
-    esp_err_t err = sdio_slave_send_queue(addr, len, (void*)timestamp, portMAX_DELAY);
-    if (err != ESP_OK) return err;
-    err = sdio_slave_send_get_finished((void**)&ret_stamp, portMAX_DELAY);
-    if (err != ESP_OK) return err;
+    esp_err_t err = sdio_slave_send_queue(addr, len, (void *)timestamp, portMAX_DELAY);
+    if (err != ESP_OK) {
+        return err;
+    }
+    err = sdio_slave_send_get_finished((void **)&ret_stamp, portMAX_DELAY);
+    if (err != ESP_OK) {
+        return err;
+    }
     SDIO_SLAVE_CHECK(ret_stamp == timestamp, "already sent without return before", ESP_ERR_INVALID_STATE);
 
     return ESP_OK;
@@ -642,9 +686,11 @@ static inline void critical_exit_recv(void)
 // remove data, still increase the counter
 static esp_err_t recv_flush_data(void)
 {
-    while(1) {
+    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();
@@ -652,7 +698,7 @@ static esp_err_t recv_flush_data(void)
     return ESP_OK;
 }
 
-static void sdio_intr_recv(void* arg)
+static void sdio_intr_recv(void *arg)
 {
     portBASE_TYPE yield = 0;
     while (sdio_slave_hal_recv_done(context.hal)) {
@@ -667,12 +713,14 @@ 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)
 {
-    recv_desc_t *desc = (recv_desc_t*)handle;
+    recv_desc_t *desc = (recv_desc_t *)handle;
     CHECK_HANDLE_IDLE(desc);
     assert(desc->not_receiving);
 
@@ -686,9 +734,9 @@ esp_err_t sdio_slave_recv_load_buf(sdio_slave_buf_handle_t handle)
 
 sdio_slave_buf_handle_t sdio_slave_recv_register_buf(uint8_t *start)
 {
-    SDIO_SLAVE_CHECK(esp_ptr_dma_capable(start) && (uint32_t)start%4==0,
-        "buffer to register should be DMA capable and 32-bit aligned", NULL);
-    recv_desc_t *desc = (recv_desc_t*)heap_caps_malloc(sizeof(recv_desc_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
+    SDIO_SLAVE_CHECK(esp_ptr_dma_capable(start) && (uint32_t)start % 4 == 0,
+                     "buffer to register should be DMA capable and 32-bit aligned", NULL);
+    recv_desc_t *desc = (recv_desc_t *)heap_caps_malloc(sizeof(recv_desc_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
     if (desc == NULL) {
         SDIO_SLAVE_LOGE("cannot allocate lldesc for new buffer");
         return NULL;
@@ -702,7 +750,7 @@ sdio_slave_buf_handle_t sdio_slave_recv_register_buf(uint8_t *start)
     return desc;
 }
 
-esp_err_t sdio_slave_recv(sdio_slave_buf_handle_t* handle_ret, uint8_t **out_addr, size_t *out_len, TickType_t wait)
+esp_err_t sdio_slave_recv(sdio_slave_buf_handle_t *handle_ret, uint8_t **out_addr, size_t *out_len, TickType_t wait)
 {
     esp_err_t ret = sdio_slave_recv_packet(handle_ret, wait);
     if (ret == ESP_ERR_NOT_FINISHED) {
@@ -710,23 +758,29 @@ esp_err_t sdio_slave_recv(sdio_slave_buf_handle_t* handle_ret, uint8_t **out_add
         ret = ESP_OK;
     }
     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_len) *out_len = desc->hal_desc.length;
+        recv_desc_t *desc = (recv_desc_t *)(*handle_ret);
+        if (out_addr) {
+            *out_addr = (uint8_t *)desc->hal_desc.buf;
+        }
+        if (out_len) {
+            *out_len = desc->hal_desc.length;
+        }
     }
     return ret;
 }
 
-esp_err_t sdio_slave_recv_packet(sdio_slave_buf_handle_t* handle_ret, TickType_t wait)
+esp_err_t sdio_slave_recv_packet(sdio_slave_buf_handle_t *handle_ret, TickType_t wait)
 {
     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();
     //remove from queue, add back to reg list.
-    recv_desc_t *desc = (recv_desc_t*)sdio_slave_hal_recv_unload_desc(context.hal);
+    recv_desc_t *desc = (recv_desc_t *)sdio_slave_hal_recv_unload_desc(context.hal);
     assert(desc != NULL && desc->hal_desc.owner == 0);
     TAILQ_INSERT_TAIL(&context.recv_reg_list, desc, te);
     critical_exit_recv();
@@ -741,7 +795,7 @@ esp_err_t sdio_slave_recv_packet(sdio_slave_buf_handle_t* handle_ret, TickType_t
 
 esp_err_t sdio_slave_recv_unregister_buf(sdio_slave_buf_handle_t handle)
 {
-    recv_desc_t *desc = (recv_desc_t*)handle;
+    recv_desc_t *desc = (recv_desc_t *)handle;
     CHECK_HANDLE_IDLE(desc); //in the queue, fail.
 
     critical_enter_recv();
@@ -751,11 +805,15 @@ esp_err_t sdio_slave_recv_unregister_buf(sdio_slave_buf_handle_t handle)
     return ESP_OK;
 }
 
-uint8_t* sdio_slave_recv_get_buf(sdio_slave_buf_handle_t handle, size_t *len_o)
+uint8_t *sdio_slave_recv_get_buf(sdio_slave_buf_handle_t handle, size_t *len_o)
 {
-    if (handle == NULL) return NULL;
-    recv_desc_t *desc = (recv_desc_t*)handle;
+    if (handle == NULL) {
+        return NULL;
+    }
+    recv_desc_t *desc = (recv_desc_t *)handle;
 
-    if (len_o!= NULL) *len_o= desc->hal_desc.length;
-    return (uint8_t*)desc->hal_desc.buf;
+    if (len_o != NULL) {
+        *len_o = desc->hal_desc.length;
+    }
+    return (uint8_t *)desc->hal_desc.buf;
 }