Merge branch 'feature/extend_port' into 'master'

Extended port

See merge request espressif/esp-serial-flasher!23

CMakeLists.txt

@@ -4,7 +4,7 @@ if (DEFINED ESP_PLATFORM)
 
     # Register component to esp-idf build system
     set(COMPONENT_SRCS src/esp_loader.c src/serial_comm.c src/md5_hash.c port/esp32_port.c)
-    set(COMPONENT_ADD_INCLUDEDIRS "include")
+    set(COMPONENT_ADD_INCLUDEDIRS "include" "port")
     set(COMPONENT_PRIV_INCLUDEDIRS "private_include" )
     register_component()
     component_compile_options(-Wstrict-prototypes)
@@ -15,7 +15,7 @@ else()
     # Create traditional CMake target
     add_library(flasher src/esp_loader.c src/serial_comm.c src/md5_hash.c)
 
-    target_include_directories(flasher PUBLIC include PRIVATE private_include)
+    target_include_directories(flasher PUBLIC include port PRIVATE private_include)
 
     if(PORT STREQUAL "STM32")
         target_link_libraries(flasher PUBLIC stm_cube)

README.md

@@ -17,8 +17,6 @@ In order to support new target, following function has to be implemented by user
 
 Following functions are part of serial_io.h header for convenience, however, user does not have to strictly follow function signatures, as there are not called directly from library. 
 
-* loader_port_serial_init()
-* loader_port_serial_deinit()
 * loader_port_change_baudrate()
 * loader_port_reset_target()
 * loader_port_debug_print()

examples/esp32_example/main/main.c

@@ -13,7 +13,7 @@
 #include "esp_log.h"
 #include "driver/uart.h"
 #include "driver/gpio.h"
-#include "serial_io.h"
+#include "esp32_port.h"
 #include "esp_loader.h"
 #include "example_common.h"
 
@@ -23,7 +23,7 @@ void app_main(void)
 {
     example_binaries_t bin;
 
-    const loader_serial_config_t config = {
+    const loader_esp32_config_t config = {
         .baud_rate = 115200,
         .uart_port = UART_NUM_1,
         .uart_rx_pin = GPIO_NUM_5,
@@ -32,7 +32,7 @@ void app_main(void)
         .gpio0_trigger_pin = GPIO_NUM_26,
     };
 
-    if ( loader_port_serial_init(&config) != ESP_LOADER_SUCCESS) {
+    if ( loader_port_esp32_init(&config) != ESP_LOADER_SUCCESS) {
         ESP_LOGE("example", "serial initialization failed.");
         return;
     }

examples/raspberry_example/Src/main.c

@@ -12,9 +12,9 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/param.h>
-#include "serial_io.h"
 #include "esp_loader.h"
 #include "example_common.h"
+#include "raspberry_port.h"
 
 #define TARGET_RST_Pin 2
 #define TARGET_IO0_Pin 3
@@ -25,11 +25,6 @@
 
 #define BINARY_PATH       "../../binaries/ESP32_AT_Firmware/Firmware.bin"
 
-esp_loader_error_t loader_port_raspberry_init(const char *device,
-                                              uint32_t baudrate,
-                                              uint32_t reset_trigger_pin,
-                                              uint32_t gpio0_trigger_pin);
-
 
 static void upload_file(const char *path, size_t address)
 {
@@ -69,7 +64,14 @@ cleanup:
 
 int main(void)
 {
-    loader_port_raspberry_init(SERIAL_DEVICE, DEFAULT_BAUD_RATE, TARGET_RST_Pin, TARGET_IO0_Pin);
+    const loader_raspberry_config_t config = {
+        .device = SERIAL_DEVICE,
+        .baudrate = DEFAULT_BAUD_RATE,
+        .reset_trigger_pin = TARGET_RST_Pin,
+        .gpio0_trigger_pin = TARGET_IO0_Pin,
+    };
+
+    loader_port_raspberry_init(&config);
 
     if (connect_to_target(HIGHER_BAUD_RATE) == ESP_LOADER_SUCCESS) {
         upload_file(BINARY_PATH, 0);

examples/stm32_example/Src/main.c

@@ -21,7 +21,7 @@
 #include <stdint.h>
 #include <string.h>
 #include <sys/param.h>
-#include "serial_io.h"
+#include "stm32_port.h"
 #include "esp_loader.h"
 #include "example_common.h"
 
@@ -33,14 +33,9 @@ static void MX_GPIO_Init(void);
 static void MX_USART1_UART_Init(void);
 static void MX_USART2_UART_Init(void);
 
-void loader_port_stm32_init(UART_HandleTypeDef *huart,
-                            GPIO_TypeDef *port_io0,
-                            uint16_t pin_num_io0,
-                            GPIO_TypeDef *port_rst,
-                            uint16_t pin_num_rst);
+#define HIGHER_BAUDRATE 230400
 
 
-#define HIGHER_BAUDRATE 230400
 
 int main(void)
 {
@@ -52,7 +47,15 @@ int main(void)
     MX_USART1_UART_Init();
     MX_USART2_UART_Init();
 
-    loader_port_stm32_init(&huart1, GPIOB, TARGET_IO0_Pin, GPIOB, TARGET_RST_Pin);
+    loader_stm32_config_t config = {
+        .huart = &huart1,
+        .port_io0 = GPIOB,
+        .pin_num_io0 = TARGET_IO0_Pin,
+        .port_rst = GPIOB,
+        .pin_num_rst = TARGET_RST_Pin,
+    };
+
+    loader_port_stm32_init(&config);
     
     if (connect_to_target(HIGHER_BAUDRATE) == ESP_LOADER_SUCCESS) {
         

include/serial_io.h

@@ -22,32 +22,6 @@
 extern "C" {
 #endif
 
-typedef struct
-{
-  uint32_t baud_rate;
-  uint32_t uart_port;
-  uint32_t uart_rx_pin;
-  uint32_t uart_tx_pin;
-  uint32_t reset_trigger_pin;
-  uint32_t gpio0_trigger_pin;
-} loader_serial_config_t;
-
-/**
-  * @brief Initializes serial interface.
-  *
-  * @param baud_rate[in]       Communication speed.
-  *
-  * @return
-  *     - ESP_LOADER_SUCCESS Success
-  *     - ESP_LOADER_ERROR_FAIL Initialization failure
-  */
-esp_loader_error_t loader_port_serial_init(const loader_serial_config_t *config);
-
-/**
-  * @brief Deinitialize serial interface.
-  */
-void loader_port_serial_deinit(void);
-
 /**
   * @brief Changes baud rate of serial peripheral.
   */

port/esp32_port.c

@@ -13,9 +13,7 @@
  * limitations under the License.
  */
 
-#include "serial_io.h"
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
+#include "esp32_port.h"
 #include "driver/uart.h"
 #include "driver/gpio.h"
 #include "esp_timer.h"
@@ -65,7 +63,7 @@ static int32_t s_uart_port;
 static int32_t s_reset_trigger_pin;
 static int32_t s_gpio0_trigger_pin;
 
-esp_loader_error_t loader_port_serial_init(const loader_serial_config_t *config)
+esp_loader_error_t loader_port_esp32_init(const loader_esp32_config_t *config)
 {
     s_uart_port = config->uart_port;
     s_reset_trigger_pin = config->reset_trigger_pin;
@@ -80,8 +78,10 @@ esp_loader_error_t loader_port_serial_init(const loader_serial_config_t *config)
         .flow_ctrl = UART_HW_FLOWCTRL_DISABLE
     };
 
-    const int rx_buffer_size = 2 * 200;
-    const int tx_buffer_size = 2 * 200;
+    int rx_buffer_size = config->rx_buffer_size ? config->rx_buffer_size : 400;
+    int tx_buffer_size = config->tx_buffer_size ? config->tx_buffer_size : 400;
+    QueueHandle_t *uart_queue = config->uart_queue ? config->uart_queue : NULL;
+    int queue_size = config->queue_size ? config->queue_size : 0;
 
     if ( uart_param_config(s_uart_port, &uart_config) != ESP_OK ) {
         return ESP_LOADER_ERROR_FAIL;
@@ -89,7 +89,7 @@ esp_loader_error_t loader_port_serial_init(const loader_serial_config_t *config)
     if ( uart_set_pin(s_uart_port, config->uart_tx_pin, config->uart_rx_pin, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE) != ESP_OK ) {
         return ESP_LOADER_ERROR_FAIL;
     }
-    if ( uart_driver_install(s_uart_port, rx_buffer_size, tx_buffer_size, 0, NULL, 0) != ESP_OK ) {
+    if ( uart_driver_install(s_uart_port, rx_buffer_size, tx_buffer_size, queue_size, uart_queue, 0) != ESP_OK ) {
         return ESP_LOADER_ERROR_FAIL;
     }
 
@@ -105,6 +105,11 @@ esp_loader_error_t loader_port_serial_init(const loader_serial_config_t *config)
     return ESP_LOADER_SUCCESS;
 }
 
+void loader_port_esp32_deinit(void)
+{
+    uart_driver_delete(s_uart_port);
+}
+
 
 esp_loader_error_t loader_port_serial_write(const uint8_t *data, uint16_t size, uint32_t timeout)
 {

port/esp32_port.h

@@ -0,0 +1,51 @@
+/* Copyright 2020 Espressif Systems (Shanghai) PTE 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.
+ */
+
+ #pragma once
+
+#include "serial_io.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/queue.h"
+
+typedef struct
+{
+  uint32_t baud_rate;     /*!< Initial baud rate, can be changed later */
+  uint32_t uart_port;     /*!< UART port */
+  uint32_t uart_rx_pin;   /*!< This pin will be configured as UART Rx pin */
+  uint32_t uart_tx_pin;   /*!< This pin will be configured as UART Tx pin */
+  uint32_t reset_trigger_pin; /*!< This pin will be used to reset target chip */
+  uint32_t gpio0_trigger_pin; /*!< This pin will be used to toggle set IO0 of target chip */
+  uint32_t rx_buffer_size;    /*!< Set to zero for default RX buffer size */
+  uint32_t tx_buffer_size;    /*!< Set to zero for default TX buffer size */
+  uint32_t queue_size;        /*!< Set to zero for default UART queue size */
+  QueueHandle_t *uart_queue;  /*!< Set to NULL, if UART queue handle is not  
+                                   necessary. Otherwise, it will be assigned here */
+} loader_esp32_config_t;
+
+/**
+  * @brief Initializes serial interface.
+  *
+  * @param baud_rate[in]       Communication speed.
+  *
+  * @return
+  *     - ESP_LOADER_SUCCESS Success
+  *     - ESP_LOADER_ERROR_FAIL Initialization failure
+  */
+esp_loader_error_t loader_port_esp32_init(const loader_esp32_config_t *config);
+
+/**
+  * @brief Deinitialize serial interface.
+  */
+void loader_port_esp32_deinit(void);

port/raspberry_port.c

@@ -207,15 +207,12 @@ static esp_loader_error_t read_data(char *buffer, uint32_t size)
     return ESP_LOADER_SUCCESS;
 }
 
-esp_loader_error_t loader_port_raspberry_init(const char *device,
-                                              uint32_t baudrate,
-                                              uint32_t reset_trigger_pin,
-                                              uint32_t gpio0_trigger_pin)
+esp_loader_error_t loader_port_raspberry_init(loader_raspberry_config_t *config)
 {
-    s_reset_trigger_pin = reset_trigger_pin;
-    s_gpio0_trigger_pin = gpio0_trigger_pin;
+    s_reset_trigger_pin = config->reset_trigger_pin;
+    s_gpio0_trigger_pin = config->gpio0_trigger_pin;
 
-    serial = serialOpen(device, baudrate);
+    serial = serialOpen(config->device, config->baudrate);
     if (serial < 0) {
         printf("Serial port could not be opened!\n");
         return ESP_LOADER_ERROR_FAIL;
@@ -226,8 +223,8 @@ esp_loader_error_t loader_port_raspberry_init(const char *device,
         return ESP_LOADER_ERROR_FAIL;
     }
 
-    gpioSetMode(reset_trigger_pin, PI_OUTPUT);
-    gpioSetMode(gpio0_trigger_pin, PI_OUTPUT);
+    gpioSetMode(config->reset_trigger_pin, PI_OUTPUT);
+    gpioSetMode(config->gpio0_trigger_pin, PI_OUTPUT);
 
     return ESP_LOADER_SUCCESS;
 }

port/raspberry_port.h

@@ -0,0 +1,28 @@
+/* Copyright 2020 Espressif Systems (Shanghai) PTE 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.
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include "serial_io.h"
+
+typedef struct {
+    const char *device;
+    uint32_t baudrate;
+    uint32_t reset_trigger_pin;
+    uint32_t gpio0_trigger_pin;
+} loader_raspberry_config_t;
+
+esp_loader_error_t loader_port_raspberry_init(const loader_raspberry_config_t *config);

port/stm32_port.c

@@ -18,8 +18,7 @@
 #include <stdint.h>
 #include <sys/param.h>
 #include <stdio.h>
-#include "serial_io.h"
-#include "stm32f4xx_hal.h"
+#include "stm32_port.h"
 
 // #define SERIAL_DEBUG_ENABLE
 
@@ -98,17 +97,14 @@ esp_loader_error_t loader_port_serial_read(uint8_t *data, uint16_t size, uint32_
     }
 }
 
-void loader_port_stm32_init(UART_HandleTypeDef *huart, 
-                            GPIO_TypeDef* port_io0, 
-                            uint16_t pin_num_io0,
-                            GPIO_TypeDef* port_rst, 
-                            uint16_t pin_num_rst)
+void loader_port_stm32_init(loader_stm32_config_t *config)
+
 {
-    uart = huart;
-    gpio_port_io0 = port_io0; 
-    gpio_port_rst = port_rst;
-    gpio_num_io0 = pin_num_io0;
-    gpio_num_rst = pin_num_rst;
+    uart = config->huart;
+    gpio_port_io0 = config->port_io0; 
+    gpio_port_rst = config->port_rst;
+    gpio_num_io0 = config->pin_num_io0;
+    gpio_num_rst = config->pin_num_rst;
 }
 
 // Set GPIO0 LOW, then

port/stm32_port.h

@@ -0,0 +1,30 @@
+/* Copyright 2020 Espressif Systems (Shanghai) PTE 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.
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include "serial_io.h"
+#include "stm32f4xx_hal.h"
+
+typedef struct {
+    UART_HandleTypeDef *huart;
+    GPIO_TypeDef *port_io0;
+    uint16_t pin_num_io0;
+    GPIO_TypeDef *port_rst;
+    uint16_t pin_num_rst;
+} loader_stm32_config_t;
+
+void loader_port_stm32_init(loader_stm32_config_t *config);

test/CMakeLists.txt

@@ -3,7 +3,7 @@ project(serial_flasher_test)
 
 add_executable( ${PROJECT_NAME} test_main.cpp ../src/serial_comm.c ../src/esp_loader.c ../src/md5_hash.c )
 
-target_include_directories(${PROJECT_NAME} PRIVATE ../include ../private_include ../test)
+target_include_directories(${PROJECT_NAME} PRIVATE ../include ../private_include ../test ../port)
 
 target_compile_options(${PROJECT_NAME} PRIVATE -Wall -Werror -O3)
 
@@ -15,6 +15,4 @@ else()
     target_sources(${PROJECT_NAME} PRIVATE serial_io_mock.cpp test.cpp)
 endif()
 
-if(DEFINED MD5_ENABLED)
-    target_compile_definitions(${PROJECT_NAME} PRIVATE -DMD5_ENABLED=${MD5_ENABLED})
-endif()
+target_compile_definitions(${PROJECT_NAME} PRIVATE -DMD5_ENABLED=1)

test/serial_io_mock.h

@@ -17,6 +17,7 @@
 
 #include <stdint.h>
 #include <stddef.h>
+#include "esp_loader.h"
 
 void clear_buffers();
 
@@ -26,4 +27,12 @@ int8_t* write_buffer_data();
 
 void set_read_buffer(const void *data, size_t size);
 void print_array(int8_t *data, uint32_t size);
-void serial_set_time_delay(uint32_t miliseconds);
+void serial_set_time_delay(uint32_t miliseconds);
+
+
+typedef struct {
+    uint32_t dummy;
+} loader_serial_config_t;
+
+esp_loader_error_t loader_port_serial_init(const loader_serial_config_t *config);
+void loader_port_serial_deinit();

test/test_main.cpp

@@ -18,6 +18,7 @@
 
 #include "catch.hpp"
 #include "serial_io.h"
+#include "serial_io_mock.h"
 
 
 int main( int argc, char* argv[] ) {