espressif/esp-idf
1
0
Fork 1
mirror of https://github.com/espressif/esp-idf.git synced 2025-08-04 13:14:32 +02:00
Code Issues Packages Projects Releases Wiki Activity

sdio_slave: format source file

Browse Source
This commit is contained in:
Michael (XIAO Xufeng)
2021-06-16 23:04:41 +08:00
parent 591e4c4b31
commit 18860ff304
1 changed files with 132 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files

200
components/driver/sdio_slave.c
View File

@@ -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,10 +299,10 @@ 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) {
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",
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,
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);
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;
}