usb: cdc support, streams redirection; ci, examples upd

tusb: cdc, tasks encapsulation, callbacks api, multiple interfaces
examples: added serial interface and usb console
ci: reimplemented cmake/make test in python with ignore lists

IDF-578

components/tinyusb/additions/src/cdc.c

@@ -0,0 +1,162 @@
+// Copyright 2020 Espressif Systems (Shanghai) Co. Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <stdint.h>
+#include "esp_err.h"
+#include "esp_log.h"
+#include "tusb.h"
+#include "cdc.h"
+#include "sdkconfig.h"
+
+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
+
+static esp_tusb_cdc_t *cdc_obj[CDC_INTF_NUM] = {};
+
+/* Common CDC functions
+   ********************************************************************* */
+bool tinyusb_cdc_initialized(int itf)
+{
+    return (cdc_obj[itf] != NULL);
+}
+
+static esp_err_t cdc_interface_check(int itf)
+{
+    if (tinyusb_cdc_initialized(itf)) {
+        return ESP_OK;
+    } else {
+        ESP_LOGE(TAG, "Interface is not initialized. Use `tinyusb_cdc_init` for initialization");
+        return ESP_ERR_INVALID_STATE;
+    }
+}
+
+/**
+ * @brief
+ *
+ * @param itf
+ * @param expected_inited
+ * @param expected_type use -1 if you don't care
+ * @return esp_err_t
+ */
+static esp_err_t cdc_obj_check(int itf, bool expected_inited, tusb_class_code_t expected_type)
+{
+    bool inited = (cdc_obj[itf] != NULL);
+    if (expected_inited != inited) {
+        ESP_LOGE(TAG, "Wrong state of the interface. Expected state: %s",
+                 expected_inited ? "initialized" : "not initialized");
+        return ESP_ERR_INVALID_STATE;
+    }
+    if (inited && (expected_type != -1) && !(cdc_obj[itf]->type == expected_type)) {
+        ESP_LOGE(TAG, "Wrong type of the interface. Should be : 0x%x (tusb_class_code_t)", expected_type);
+        return ESP_ERR_INVALID_ARG;
+    }
+    return ESP_OK;
+}
+
+esp_tusb_cdc_t *tinyusb_cdc_get_intf(int itf_num)
+{
+    if (cdc_interface_check(itf_num) != ESP_OK) {
+        return NULL;
+    }
+    return cdc_obj[itf_num];
+}
+
+/*********************************************************************** Common CDC functions*/
+/* CDC class funcs
+   ********************************************************************* */
+static esp_err_t tusb_cdc_comm_init(int itf)
+{
+    ESP_RETURN_ON_ERROR(cdc_obj_check(itf, false, -1));
+    cdc_obj[itf] = calloc(1, sizeof(esp_tusb_cdc_t));
+    if (cdc_obj[itf] != NULL) {
+        cdc_obj[itf]->type = TUSB_CLASS_CDC;
+        ESP_LOGD(TAG, "CDC Comm class initialized");
+        return ESP_OK;
+    } else {
+        ESP_LOGE(TAG, "CDC Comm initialization error");
+        return ESP_FAIL;
+    }
+}
+
+static esp_err_t tusb_cdc_deinit_comm(int itf)
+{
+    ESP_RETURN_ON_ERROR(cdc_obj_check(itf, true, TUSB_CLASS_CDC));
+    free(cdc_obj[itf]);
+    cdc_obj[itf] = NULL;
+    return ESP_OK;
+}
+
+static esp_err_t tusb_cdc_data_init(int itf)
+{
+    ESP_RETURN_ON_ERROR(cdc_obj_check(itf, false, TUSB_CLASS_CDC_DATA));
+    cdc_obj[itf] = calloc(1, sizeof(esp_tusb_cdc_t));
+    if (cdc_obj[itf] != NULL) {
+        cdc_obj[itf]->type = TUSB_CLASS_CDC_DATA;
+        ESP_LOGD(TAG, "CDC Data class initialized");
+        return ESP_OK;
+    } else {
+        ESP_LOGE(TAG, "CDC Data initialization error");
+        return ESP_FAIL;
+    }
+}
+
+static esp_err_t tusb_cdc_deinit_data(int itf)
+{
+    ESP_RETURN_ON_ERROR(cdc_obj_check(itf, true, TUSB_CLASS_CDC_DATA));
+    free(cdc_obj[itf]);
+    cdc_obj[itf] = NULL;
+    return ESP_OK;
+}
+/*********************************************************************** CDC class funcs*/
+/* CDC initialization
+   ********************************************************************* */
+esp_err_t tinyusb_cdc_init(int itf, const tinyusb_config_cdc_t *cfg)
+{
+    ESP_LOGD(TAG, "CDC initialization...");
+    if (itf != 0) {
+        ESP_LOGE(TAG, "There is not CDC no.%d", itf);
+        return ESP_ERR_INVALID_ARG;
+    }
+    if (cfg->cdc_class == TUSB_CLASS_CDC) {
+        ESP_RETURN_ON_ERROR(tusb_cdc_comm_init(itf));
+        cdc_obj[itf]->cdc_subclass.comm_subclass = cfg->cdc_subclass.comm_subclass;
+    } else {
+        ESP_RETURN_ON_ERROR(tusb_cdc_data_init(itf));
+        cdc_obj[itf]->cdc_subclass.data_subclass = cfg->cdc_subclass.data_subclass;
+    }
+    cdc_obj[itf]->usb_dev = cfg->usb_dev;
+    return ESP_OK;
+}
+
+
+esp_err_t tinyusb_cdc_deinit(int itf)
+{
+    if (itf != 0) {
+        ESP_LOGE(TAG, "There is not CDC no.%d", itf);
+        return ESP_ERR_INVALID_ARG;
+    }
+    if (cdc_obj[itf]->type == TUSB_CLASS_CDC) {
+        ESP_RETURN_ON_ERROR(tusb_cdc_deinit_comm(itf));
+    } else if (cdc_obj[itf]->type == TUSB_CLASS_CDC_DATA) {
+        ESP_RETURN_ON_ERROR(tusb_cdc_deinit_data(itf));
+    } else {
+        return ESP_ERR_INVALID_ARG;
+    }
+    ESP_LOGD(TAG, "De-initialized");
+    return ESP_OK;
+}
+/*********************************************************************** CDC initialization*/