alex/esp-idf
alex/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2024-10-05 20:47:46 -04:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

tinyusb: use the generic error check macros

Browse Source
This commit is contained in:
Shu Chen 2021-04-02 17:48:13 +08:00
parent 7702060967
commit 1b5894a5cb
2 changed files with 26 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
components/tinyusb/additions/src/cdc.c
View File

@ -13,6 +13,7 @@
// limitations under the License. // limitations under the License.
#include <stdint.h> #include <stdint.h>
#include "esp_check.h"
#include "esp_err.h" #include "esp_err.h"
#include "esp_log.h" #include "esp_log.h"
#include "tusb.h" #include "tusb.h"
@ -21,8 +22,6 @@
static const char *TAG = "tusb_cdc"; static const char *TAG = "tusb_cdc";
#define ESP_RETURN_ON_ERROR(x) do {esp_err_t r = (x); if (r != ESP_OK) return r;} while(0)
#define CDC_INTF_NUM CFG_TUD_CDC // number of cdc blocks #define CDC_INTF_NUM CFG_TUD_CDC // number of cdc blocks
static esp_tusb_cdc_t *cdc_obj[CDC_INTF_NUM] = {}; static esp_tusb_cdc_t *cdc_obj[CDC_INTF_NUM] = {};
@ -80,7 +79,7 @@ esp_tusb_cdc_t *tinyusb_cdc_get_intf(int itf_num)
********************************************************************* */ ********************************************************************* */
static esp_err_t tusb_cdc_comm_init(int itf) static esp_err_t tusb_cdc_comm_init(int itf)
{ {
ESP_RETURN_ON_ERROR(cdc_obj_check(itf, false, -1)); ESP_RETURN_ON_ERROR(cdc_obj_check(itf, false, -1), TAG, "cdc_obj_check failed");
cdc_obj[itf] = calloc(1, sizeof(esp_tusb_cdc_t)); cdc_obj[itf] = calloc(1, sizeof(esp_tusb_cdc_t));
if (cdc_obj[itf] != NULL) { if (cdc_obj[itf] != NULL) {
cdc_obj[itf]->type = TUSB_CLASS_CDC; cdc_obj[itf]->type = TUSB_CLASS_CDC;
@ -94,7 +93,7 @@ static esp_err_t tusb_cdc_comm_init(int itf)
static esp_err_t tusb_cdc_deinit_comm(int itf) static esp_err_t tusb_cdc_deinit_comm(int itf)
{ {
ESP_RETURN_ON_ERROR(cdc_obj_check(itf, true, TUSB_CLASS_CDC)); ESP_RETURN_ON_ERROR(cdc_obj_check(itf, true, TUSB_CLASS_CDC), TAG, "cdc_obj_check failed");
free(cdc_obj[itf]); free(cdc_obj[itf]);
cdc_obj[itf] = NULL; cdc_obj[itf] = NULL;
return ESP_OK; return ESP_OK;
@ -102,7 +101,7 @@ static esp_err_t tusb_cdc_deinit_comm(int itf)
static esp_err_t tusb_cdc_data_init(int itf) static esp_err_t tusb_cdc_data_init(int itf)
{ {
ESP_RETURN_ON_ERROR(cdc_obj_check(itf, false, TUSB_CLASS_CDC_DATA)); ESP_RETURN_ON_ERROR(cdc_obj_check(itf, false, TUSB_CLASS_CDC_DATA), TAG, "cdc_obj_check failed");
cdc_obj[itf] = calloc(1, sizeof(esp_tusb_cdc_t)); cdc_obj[itf] = calloc(1, sizeof(esp_tusb_cdc_t));
if (cdc_obj[itf] != NULL) { if (cdc_obj[itf] != NULL) {
cdc_obj[itf]->type = TUSB_CLASS_CDC_DATA; cdc_obj[itf]->type = TUSB_CLASS_CDC_DATA;
@ -116,7 +115,7 @@ static esp_err_t tusb_cdc_data_init(int itf)
static esp_err_t tusb_cdc_deinit_data(int itf) static esp_err_t tusb_cdc_deinit_data(int itf)
{ {
ESP_RETURN_ON_ERROR(cdc_obj_check(itf, true, TUSB_CLASS_CDC_DATA)); ESP_RETURN_ON_ERROR(cdc_obj_check(itf, true, TUSB_CLASS_CDC_DATA), TAG, "cdc_obj_check failed");
free(cdc_obj[itf]); free(cdc_obj[itf]);
cdc_obj[itf] = NULL; cdc_obj[itf] = NULL;
return ESP_OK; return ESP_OK;
@ -132,10 +131,10 @@ esp_err_t tinyusb_cdc_init(int itf, const tinyusb_config_cdc_t *cfg)
return ESP_ERR_INVALID_ARG; return ESP_ERR_INVALID_ARG;
} }
if (cfg->cdc_class == TUSB_CLASS_CDC) { if (cfg->cdc_class == TUSB_CLASS_CDC) {
ESP_RETURN_ON_ERROR(tusb_cdc_comm_init(itf)); ESP_RETURN_ON_ERROR(tusb_cdc_comm_init(itf), TAG, "tusb_cdc_comm_init failed");
cdc_obj[itf]->cdc_subclass.comm_subclass = cfg->cdc_subclass.comm_subclass; cdc_obj[itf]->cdc_subclass.comm_subclass = cfg->cdc_subclass.comm_subclass;
} else { } else {
ESP_RETURN_ON_ERROR(tusb_cdc_data_init(itf)); ESP_RETURN_ON_ERROR(tusb_cdc_data_init(itf), TAG, "tusb_cdc_data_init failed");
cdc_obj[itf]->cdc_subclass.data_subclass = cfg->cdc_subclass.data_subclass; cdc_obj[itf]->cdc_subclass.data_subclass = cfg->cdc_subclass.data_subclass;
} }
cdc_obj[itf]->usb_dev = cfg->usb_dev; cdc_obj[itf]->usb_dev = cfg->usb_dev;
@ -150,9 +149,9 @@ esp_err_t tinyusb_cdc_deinit(int itf)
return ESP_ERR_INVALID_ARG; return ESP_ERR_INVALID_ARG;
} }
if (cdc_obj[itf]->type == TUSB_CLASS_CDC) { if (cdc_obj[itf]->type == TUSB_CLASS_CDC) {
ESP_RETURN_ON_ERROR(tusb_cdc_deinit_comm(itf)); ESP_RETURN_ON_ERROR(tusb_cdc_deinit_comm(itf), TAG, "tusb_cdc_deinit_comm failed");
} else if (cdc_obj[itf]->type == TUSB_CLASS_CDC_DATA) { } else if (cdc_obj[itf]->type == TUSB_CLASS_CDC_DATA) {
ESP_RETURN_ON_ERROR(tusb_cdc_deinit_data(itf)); ESP_RETURN_ON_ERROR(tusb_cdc_deinit_data(itf), TAG, "tusb_cdc_deinit_data failed");
} else { } else {
return ESP_ERR_INVALID_ARG; return ESP_ERR_INVALID_ARG;
} }

35
components/tinyusb/additions/src/tusb_cdc_acm.c
View File

@ -13,6 +13,7 @@
// limitations under the License. // limitations under the License.
#include <stdint.h> #include <stdint.h>
#include "esp_check.h"
#include "esp_err.h" #include "esp_err.h"
#include "esp_log.h" #include "esp_log.h"
#include "freertos/FreeRTOS.h" #include "freertos/FreeRTOS.h"
@ -22,8 +23,6 @@
#include "cdc.h" #include "cdc.h"
#include "sdkconfig.h" #include "sdkconfig.h"
#define ESP_RETURN_ON_ERROR(x) do{esp_err_t r = (x); if (r != ESP_OK) return r;} while(0)
#define RX_UNREADBUF_SZ_DEFAULT 64 // buffer storing all unread RX data #define RX_UNREADBUF_SZ_DEFAULT 64 // buffer storing all unread RX data
@ -240,15 +239,17 @@ static esp_err_t read_from_rx_unread_to_buffer(esp_tusb_cdcacm_t *acm, uint8_t *
} }
} }
static esp_err_t ringbuf_mux_take(esp_tusb_cdcacm_t *acm){ static esp_err_t ringbuf_mux_take(esp_tusb_cdcacm_t *acm)
if(xSemaphoreTake(acm->ringbuf_read_mux, 0) != pdTRUE){ {
if (xSemaphoreTake(acm->ringbuf_read_mux, 0) != pdTRUE) {
ESP_LOGW(TAG, "Read error: ACM is busy"); ESP_LOGW(TAG, "Read error: ACM is busy");
return ESP_ERR_INVALID_STATE; return ESP_ERR_INVALID_STATE;
} }
return ESP_OK; return ESP_OK;
} }
static esp_err_t ringbuf_mux_give(esp_tusb_cdcacm_t *acm) { static esp_err_t ringbuf_mux_give(esp_tusb_cdcacm_t *acm)
{
BaseType_t ret = xSemaphoreGive(acm->ringbuf_read_mux); BaseType_t ret = xSemaphoreGive(acm->ringbuf_read_mux);
assert(ret == pdTRUE); assert(ret == pdTRUE);
return ESP_OK; return ESP_OK;
@ -257,28 +258,25 @@ static esp_err_t ringbuf_mux_give(esp_tusb_cdcacm_t *acm) {
esp_err_t tinyusb_cdcacm_read(tinyusb_cdcacm_itf_t itf, uint8_t *out_buf, size_t out_buf_sz, size_t *rx_data_size) esp_err_t tinyusb_cdcacm_read(tinyusb_cdcacm_itf_t itf, uint8_t *out_buf, size_t out_buf_sz, size_t *rx_data_size)
{ {
esp_tusb_cdcacm_t *acm = get_acm(itf); esp_tusb_cdcacm_t *acm = get_acm(itf);
if (!acm) { ESP_RETURN_ON_FALSE(acm, ESP_ERR_INVALID_STATE, TAG, "Interface is not initialized. Use `tinyusb_cdc_init` for initialization");
ESP_LOGE(TAG, "Interface is not initialized. Use `tinyusb_cdc_init` for initialization");
return ESP_ERR_INVALID_STATE;
}
size_t read_sz; size_t read_sz;
/* Take a mutex to proceed two uninterrupted read operations */ /* Take a mutex to proceed two uninterrupted read operations */
ESP_RETURN_ON_ERROR(ringbuf_mux_take(acm)); ESP_RETURN_ON_ERROR(ringbuf_mux_take(acm), TAG, "ringbuf_mux_take failed");
esp_err_t res = read_from_rx_unread_to_buffer(acm, out_buf, out_buf_sz, &read_sz); esp_err_t res = read_from_rx_unread_to_buffer(acm, out_buf, out_buf_sz, &read_sz);
if (res != ESP_OK){ if (res != ESP_OK) {
ESP_RETURN_ON_ERROR(ringbuf_mux_give(acm)); ESP_RETURN_ON_ERROR(ringbuf_mux_give(acm), TAG, "ringbuf_mux_give failed");
return res; return res;
} }
*rx_data_size = read_sz; *rx_data_size = read_sz;
/* Buffer's data can be wrapped, at that situations we should make another retrievement */ /* Buffer's data can be wrapped, at that situations we should make another retrievement */
if (read_from_rx_unread_to_buffer(acm, out_buf+read_sz, out_buf_sz-read_sz, &read_sz) == ESP_OK) { if (read_from_rx_unread_to_buffer(acm, out_buf + read_sz, out_buf_sz - read_sz, &read_sz) == ESP_OK) {
*rx_data_size += read_sz; *rx_data_size += read_sz;
} }
ESP_RETURN_ON_ERROR(ringbuf_mux_give(acm)); ESP_RETURN_ON_ERROR(ringbuf_mux_give(acm), TAG, "ringbuf_mux_give failed");
return ESP_OK; return ESP_OK;
} }
@ -300,7 +298,8 @@ size_t tinyusb_cdcacm_write_queue(tinyusb_cdcacm_itf_t itf, uint8_t *in_buf, siz
return tud_cdc_n_write(itf, in_buf, in_size); return tud_cdc_n_write(itf, in_buf, in_size);
} }
static uint32_t tud_cdc_n_write_occupied(tinyusb_cdcacm_itf_t itf){ static uint32_t tud_cdc_n_write_occupied(tinyusb_cdcacm_itf_t itf)
{
return CFG_TUD_CDC_TX_BUFSIZE - tud_cdc_n_write_available(itf); return CFG_TUD_CDC_TX_BUFSIZE - tud_cdc_n_write_available(itf);
} }
@ -370,8 +369,8 @@ esp_err_t tusb_cdc_acm_init(const tinyusb_config_cdcacm_t *cfg)
.cdc_class = TUSB_CLASS_CDC, .cdc_class = TUSB_CLASS_CDC,
.cdc_subclass.comm_subclass = CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL .cdc_subclass.comm_subclass = CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL
}; };
ESP_RETURN_ON_ERROR(tinyusb_cdc_init(itf, &cdc_cfg)); ESP_RETURN_ON_ERROR(tinyusb_cdc_init(itf, &cdc_cfg), TAG, "tinyusb_cdc_init failed");
ESP_RETURN_ON_ERROR(alloc_obj(itf)); ESP_RETURN_ON_ERROR(alloc_obj(itf), TAG, "alloc_obj failed");
esp_tusb_cdcacm_t *acm = get_acm(itf); esp_tusb_cdcacm_t *acm = get_acm(itf);
/* Callbacks setting up*/ /* Callbacks setting up*/
@ -391,7 +390,7 @@ esp_err_t tusb_cdc_acm_init(const tinyusb_config_cdcacm_t *cfg)
/* Buffers */ /* Buffers */
acm->ringbuf_read_mux = xSemaphoreCreateMutex(); acm->ringbuf_read_mux = xSemaphoreCreateMutex();
if (acm->ringbuf_read_mux == NULL){ if (acm->ringbuf_read_mux == NULL) {
ESP_LOGE(TAG, "Creation of a ringbuf mutex failed"); ESP_LOGE(TAG, "Creation of a ringbuf mutex failed");
free_obj(itf); free_obj(itf);
return ESP_ERR_NO_MEM; return ESP_ERR_NO_MEM;