From 04acc88023caae96c02d8c2a80f4a904de035e07 Mon Sep 17 00:00:00 2001 From: Alexey Gerenkov Date: Thu, 19 Jan 2017 20:24:55 +0300 Subject: [PATCH 1/8] esp32: Fixes watchdog problem when printing core dump to uart Also fixes generation of core dumps when flash cache is disabled --- components/esp32/core_dump.c | 39 +++++++++-------- components/esp32/cpu_start.c | 8 ++-- components/esp32/intr_alloc.c | 4 +- components/esp32/ld/esp32.common.ld | 1 + components/esp32/panic.c | 6 ++- components/spi_flash/flash_ops.c | 44 ++++++++++++++------ components/spi_flash/include/esp_spi_flash.h | 34 +++++++++++++-- 7 files changed, 93 insertions(+), 43 deletions(-) diff --git a/components/esp32/core_dump.c b/components/esp32/core_dump.c index 85301f4dd6..ecc658ebdc 100644 --- a/components/esp32/core_dump.c +++ b/components/esp32/core_dump.c @@ -26,16 +26,17 @@ #if CONFIG_ESP32_ENABLE_COREDUMP #define LOG_LOCAL_LEVEL CONFIG_ESP32_CORE_DUMP_LOG_LEVEL #include "esp_log.h" -const static char *TAG = "esp_core_dump"; +const static DRAM_ATTR char TAG[] = "esp_core_dump"; -#define ESP_COREDUMP_LOGE( format, ... ) if (LOG_LOCAL_LEVEL >= ESP_LOG_ERROR) { ets_printf(LOG_FORMAT(E, format), esp_log_early_timestamp(), TAG, ##__VA_ARGS__); } -#define ESP_COREDUMP_LOGW( format, ... ) if (LOG_LOCAL_LEVEL >= ESP_LOG_WARN) { ets_printf(LOG_FORMAT(W, format), esp_log_early_timestamp(), TAG, ##__VA_ARGS__); } -#define ESP_COREDUMP_LOGI( format, ... ) if (LOG_LOCAL_LEVEL >= ESP_LOG_INFO) { ets_printf(LOG_FORMAT(I, format), esp_log_early_timestamp(), TAG, ##__VA_ARGS__); } -#define ESP_COREDUMP_LOGD( format, ... ) if (LOG_LOCAL_LEVEL >= ESP_LOG_DEBUG) { ets_printf(LOG_FORMAT(D, format), esp_log_early_timestamp(), TAG, ##__VA_ARGS__); } -#define ESP_COREDUMP_LOGV( format, ... ) if (LOG_LOCAL_LEVEL >= ESP_LOG_VERBOSE) { ets_printf(LOG_FORMAT(V, format), esp_log_early_timestamp(), TAG, ##__VA_ARGS__); } +#define ESP_COREDUMP_LOG( level, format, ... ) if (LOG_LOCAL_LEVEL >= level) { ets_printf(DRAM_STR(format), esp_log_early_timestamp(), (const char *)TAG, ##__VA_ARGS__); } +#define ESP_COREDUMP_LOGE( format, ... ) ESP_COREDUMP_LOG(ESP_LOG_ERROR, LOG_FORMAT(E, format), ##__VA_ARGS__) +#define ESP_COREDUMP_LOGW( format, ... ) ESP_COREDUMP_LOG(ESP_LOG_WARN, LOG_FORMAT(W, format), ##__VA_ARGS__) +#define ESP_COREDUMP_LOGI( format, ... ) ESP_COREDUMP_LOG(ESP_LOG_INFO, LOG_FORMAT(I, format), ##__VA_ARGS__) +#define ESP_COREDUMP_LOGD( format, ... ) ESP_COREDUMP_LOG(ESP_LOG_DEBUG, LOG_FORMAT(D, format), ##__VA_ARGS__) +#define ESP_COREDUMP_LOGV( format, ... ) ESP_COREDUMP_LOG(ESP_LOG_VERBOSE, LOG_FORMAT(V, format), ##__VA_ARGS__) #if CONFIG_ESP32_ENABLE_COREDUMP_TO_FLASH -#define ESP_COREDUMP_LOG_PROCESS( format, ... ) if (LOG_LOCAL_LEVEL >= ESP_LOG_DEBUG) { ets_printf(LOG_FORMAT(D, format), esp_log_early_timestamp(), TAG, ##__VA_ARGS__); } +#define ESP_COREDUMP_LOG_PROCESS( format, ... ) ESP_COREDUMP_LOGD(format, ##__VA_ARGS__) #else #define ESP_COREDUMP_LOG_PROCESS( format, ... ) do{/*(__VA_ARGS__);*/}while(0) #endif @@ -345,8 +346,9 @@ void esp_core_dump_to_flash(XtExcFrame *frame) #endif #if CONFIG_ESP32_ENABLE_COREDUMP_TO_UART + static void esp_core_dump_b64_encode(const uint8_t *src, uint32_t src_len, uint8_t *dst) { - static const char *b64 = + const static DRAM_ATTR char b64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; int i, j, a, b, c; @@ -373,14 +375,14 @@ static void esp_core_dump_b64_encode(const uint8_t *src, uint32_t src_len, uint8 static esp_err_t esp_core_dump_uart_write_start(void *priv) { esp_err_t err = ESP_OK; - ets_printf("================= CORE DUMP START =================\r\n"); + ets_printf(DRAM_STR("================= CORE DUMP START =================\r\n")); return err; } static esp_err_t esp_core_dump_uart_write_end(void *priv) { esp_err_t err = ESP_OK; - ets_printf("================= CORE DUMP END =================\r\n"); + ets_printf(DRAM_STR("================= CORE DUMP END =================\r\n")); return err; } @@ -398,7 +400,7 @@ static esp_err_t esp_core_dump_uart_write_data(void *priv, void * data, uint32_t memcpy(tmp, addr, len); esp_core_dump_b64_encode((const uint8_t *)tmp, len, (uint8_t *)buf); addr += len; - ets_printf("%s\r\n", buf); + ets_printf(DRAM_STR("%s\r\n"), buf); } return err; @@ -427,7 +429,8 @@ void esp_core_dump_to_uart(XtExcFrame *frame) wr_cfg.priv = NULL; //Make sure txd/rxd are enabled - gpio_pullup_dis(1); + // use direct reg access instead of gpio_pullup_dis which can cause exception when flash cache is disabled + REG_CLR_BIT(GPIO_PIN_REG_1, FUN_PU); PIN_FUNC_SELECT(PERIPHS_IO_MUX_U0RXD_U, FUNC_U0RXD_U0RXD); PIN_FUNC_SELECT(PERIPHS_IO_MUX_U0TXD_U, FUNC_U0TXD_U0TXD); @@ -438,10 +441,6 @@ void esp_core_dump_to_uart(XtExcFrame *frame) tm_cur = xthal_get_ccount() / (XT_CLOCK_FREQ / 1000); if (tm_cur >= tm_end) break; - /* Feed the Cerberus. */ - TIMERG0.wdt_wprotect = TIMG_WDT_WKEY_VALUE; - TIMERG0.wdt_feed = 1; - TIMERG0.wdt_wprotect = 0; ch = esp_core_dump_uart_get_char(); } ESP_COREDUMP_LOGI("Print core dump to uart..."); @@ -455,18 +454,18 @@ void esp_core_dump_init() #if CONFIG_ESP32_ENABLE_COREDUMP_TO_FLASH const esp_partition_t *core_part; - ESP_LOGI(TAG, "Init core dump to flash"); + ESP_COREDUMP_LOGI("Init core dump to flash"); core_part = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_DATA_COREDUMP, NULL); if (!core_part) { - ESP_LOGE(TAG, "No core dump partition found!"); + ESP_COREDUMP_LOGE("No core dump partition found!"); return; } - ESP_LOGI(TAG, "Found partition '%s' @ %x %d bytes", core_part->label, core_part->address, core_part->size); + ESP_COREDUMP_LOGI("Found partition '%s' @ %x %d bytes", core_part->label, core_part->address, core_part->size); s_core_part_start = core_part->address; s_core_part_size = core_part->size; #endif #if CONFIG_ESP32_ENABLE_COREDUMP_TO_UART - ESP_LOGI(TAG, "Init core dump to UART"); + ESP_COREDUMP_LOGI("Init core dump to UART"); #endif } diff --git a/components/esp32/cpu_start.c b/components/esp32/cpu_start.c index edc2881a28..001d1706e1 100644 --- a/components/esp32/cpu_start.c +++ b/components/esp32/cpu_start.c @@ -210,6 +210,10 @@ void start_cpu0_default(void) /* init default OS-aware flash access critical section */ spi_flash_guard_set(&g_flash_guard_default_ops); +#if CONFIG_ESP32_ENABLE_COREDUMP + esp_core_dump_init(); +#endif + #if CONFIG_ESP32_PHY_AUTO_INIT nvs_flash_init(); do_phy_init(); @@ -221,10 +225,6 @@ void start_cpu0_default(void) } #endif -#if CONFIG_ESP32_ENABLE_COREDUMP - esp_core_dump_init(); -#endif - xTaskCreatePinnedToCore(&main_task, "main", ESP_TASK_MAIN_STACK, NULL, ESP_TASK_MAIN_PRIO, NULL, 0); diff --git a/components/esp32/intr_alloc.c b/components/esp32/intr_alloc.c index d9cc627e17..b35973144c 100644 --- a/components/esp32/intr_alloc.c +++ b/components/esp32/intr_alloc.c @@ -686,7 +686,7 @@ esp_err_t IRAM_ATTR esp_intr_disable(intr_handle_t handle) } -void esp_intr_noniram_disable() +void IRAM_ATTR esp_intr_noniram_disable() { int oldint; int cpu=xPortGetCoreID(); @@ -705,7 +705,7 @@ void esp_intr_noniram_disable() non_iram_int_disabled[cpu]=oldint&non_iram_int_mask[cpu]; } -void esp_intr_noniram_enable() +void IRAM_ATTR esp_intr_noniram_enable() { int cpu=xPortGetCoreID(); int intmask=non_iram_int_disabled[cpu]; diff --git a/components/esp32/ld/esp32.common.ld b/components/esp32/ld/esp32.common.ld index 3e5d6b7d83..ac04c07d57 100644 --- a/components/esp32/ld/esp32.common.ld +++ b/components/esp32/ld/esp32.common.ld @@ -80,6 +80,7 @@ SECTIONS *(.iram1 .iram1.*) *libfreertos.a:(.literal .text .literal.* .text.*) *libesp32.a:panic.o(.literal .text .literal.* .text.*) + *libesp32.a:core_dump.o(.literal .text .literal.* .text.*) *libphy.a:(.literal .text .literal.* .text.*) *librtc.a:(.literal .text .literal.* .text.*) *libpp.a:(.literal .text .literal.* .text.*) diff --git a/components/esp32/panic.c b/components/esp32/panic.c index 6180770bd6..4f0497d6ea 100644 --- a/components/esp32/panic.c +++ b/components/esp32/panic.c @@ -267,7 +267,7 @@ static void reconfigureAllWdts() TIMERG1.wdt_wprotect = 0; } -#if CONFIG_ESP32_PANIC_GDBSTUB || CONFIG_ESP32_PANIC_PRINT_HALT +#if CONFIG_ESP32_PANIC_GDBSTUB || CONFIG_ESP32_PANIC_PRINT_HALT || CONFIG_ESP32_ENABLE_COREDUMP /* This disables all the watchdogs for when we call the gdbstub. */ @@ -367,11 +367,15 @@ static void commonErrorHandler(XtExcFrame *frame) panicPutStr("Entering gdb stub now.\r\n"); esp_gdbstub_panic_handler(frame); #else +#if CONFIG_ESP32_ENABLE_COREDUMP + disableAllWdts(); #if CONFIG_ESP32_ENABLE_COREDUMP_TO_FLASH esp_core_dump_to_flash(frame); #endif #if CONFIG_ESP32_ENABLE_COREDUMP_TO_UART && !CONFIG_ESP32_PANIC_SILENT_REBOOT esp_core_dump_to_uart(frame); +#endif + reconfigureAllWdts(); #endif #if CONFIG_ESP32_PANIC_PRINT_REBOOT || CONFIG_ESP32_PANIC_SILENT_REBOOT panicPutStr("Rebooting...\r\n"); diff --git a/components/spi_flash/flash_ops.c b/components/spi_flash/flash_ops.c index 0d3e0da87c..3581b34141 100644 --- a/components/spi_flash/flash_ops.c +++ b/components/spi_flash/flash_ops.c @@ -61,13 +61,17 @@ static spi_flash_counters_t s_flash_stats; static esp_err_t spi_flash_translate_rc(SpiFlashOpResult rc); const DRAM_ATTR spi_flash_guard_funcs_t g_flash_guard_default_ops = { - .start = spi_flash_disable_interrupts_caches_and_other_cpu, - .end = spi_flash_enable_interrupts_caches_and_other_cpu + .start = spi_flash_disable_interrupts_caches_and_other_cpu, + .end = spi_flash_enable_interrupts_caches_and_other_cpu, + .op_lock = spi_flash_op_lock, + .op_unlock = spi_flash_op_unlock }; const DRAM_ATTR spi_flash_guard_funcs_t g_flash_guard_no_os_ops = { - .start = spi_flash_disable_interrupts_caches_and_other_cpu_no_os, - .end = spi_flash_enable_interrupts_caches_no_os + .start = spi_flash_disable_interrupts_caches_and_other_cpu_no_os, + .end = spi_flash_enable_interrupts_caches_no_os, + .op_lock = 0, + .op_unlock = 0 }; static const spi_flash_guard_funcs_t *s_flash_guard_ops; @@ -80,12 +84,12 @@ void spi_flash_init() #endif } -void spi_flash_guard_set(const spi_flash_guard_funcs_t* funcs) +void IRAM_ATTR spi_flash_guard_set(const spi_flash_guard_funcs_t* funcs) { s_flash_guard_ops = funcs; } -size_t spi_flash_get_chip_size() +size_t IRAM_ATTR spi_flash_get_chip_size() { return g_rom_flashchip.chip_size; } @@ -105,18 +109,32 @@ static SpiFlashOpResult IRAM_ATTR spi_flash_unlock() static inline void IRAM_ATTR spi_flash_guard_start() { - if (s_flash_guard_ops) { + if (s_flash_guard_ops && s_flash_guard_ops->start) { s_flash_guard_ops->start(); } } static inline void IRAM_ATTR spi_flash_guard_end() { - if (s_flash_guard_ops) { + if (s_flash_guard_ops && s_flash_guard_ops->end) { s_flash_guard_ops->end(); } } +static inline void IRAM_ATTR spi_flash_guard_op_lock() +{ + if (s_flash_guard_ops && s_flash_guard_ops->op_lock) { + s_flash_guard_ops->op_lock(); + } +} + +static inline void IRAM_ATTR spi_flash_guard_op_unlock() +{ + if (s_flash_guard_ops && s_flash_guard_ops->op_unlock) { + s_flash_guard_ops->op_unlock(); + } +} + esp_err_t IRAM_ATTR spi_flash_erase_sector(size_t sec) { return spi_flash_erase_range(sec * SPI_FLASH_SEC_SIZE, SPI_FLASH_SEC_SIZE); @@ -251,9 +269,9 @@ esp_err_t IRAM_ATTR spi_flash_write(size_t dst, const void *srcv, size_t size) out: COUNTER_STOP(write); - spi_flash_op_lock(); + spi_flash_guard_op_lock(); spi_flash_mark_modified_region(dst, size); - spi_flash_op_unlock(); + spi_flash_guard_op_unlock(); return spi_flash_translate_rc(rc); } @@ -320,9 +338,9 @@ esp_err_t IRAM_ATTR spi_flash_write_encrypted(size_t dest_addr, const void *src, } COUNTER_ADD_BYTES(write, size); - spi_flash_op_lock(); + spi_flash_guard_op_lock(); spi_flash_mark_modified_region(dest_addr, size); - spi_flash_op_unlock(); + spi_flash_guard_op_unlock(); return spi_flash_translate_rc(rc); } @@ -444,7 +462,7 @@ esp_err_t IRAM_ATTR spi_flash_read_encrypted(size_t src, void *dstv, size_t size } -static esp_err_t spi_flash_translate_rc(SpiFlashOpResult rc) +static esp_err_t IRAM_ATTR spi_flash_translate_rc(SpiFlashOpResult rc) { switch (rc) { case SPI_FLASH_RESULT_OK: diff --git a/components/spi_flash/include/esp_spi_flash.h b/components/spi_flash/include/esp_spi_flash.h index c1ad7d56fa..060d598ec0 100644 --- a/components/spi_flash/include/esp_spi_flash.h +++ b/components/spi_flash/include/esp_spi_flash.h @@ -205,16 +205,44 @@ typedef void (*spi_flash_guard_start_func_t)(void); * @brief SPI flash critical section exit function. */ typedef void (*spi_flash_guard_end_func_t)(void); +/** + * @brief SPI flash operation lock function. + */ +typedef void (*spi_flash_op_lock_func_t)(void); +/** + * @brief SPI flash operation unlock function. + */ +typedef void (*spi_flash_op_unlock_func_t)(void); /** - * Structure holding SPI flash access critical section management functions + * Structure holding SPI flash access critical sections management functions. + * + * Flash API uses two types of flash access management functions: + * 1) Functions which prepare/restore flash cache and interrupts before calling + * appropriate ROM functions (SPIWrite, SPIRead and SPIEraseBlock): + * - 'start' function should disables flash cache and non-IRAM interrupts and + * is invoked before the call to one of ROM function above. + * - 'end' function should restore state of flash cache and non-IRAM interrupts and + * is invoked after the call to one of ROM function above. + * 2) Functions which synchronizes access to internal data used by flash API. + * This functions are mostly intended to synchronize access to flash API internal data + * in multithreaded environment and use OS primitives: + * - 'op_lock' locks access to flash API internal data. + * - 'op_unlock' unlocks access to flash API internal data. + * Different versions of the guarding functions should be used depending on the context of + * execution (with or without functional OS). In normal conditions when flash API is called + * from task the functions use OS primitives. When there is no OS at all or when + * it is not guaranteed that OS is functional (accessing flash from exception handler) these + * functions cannot use OS primitives or even does not need them (multithreaded access is not possible). * * @note Structure and corresponding guard functions should not reside in flash. * For example structure can be placed in DRAM and functions in IRAM sections. */ typedef struct { - spi_flash_guard_start_func_t start; /**< critical section start func */ - spi_flash_guard_end_func_t end; /**< critical section end func */ + spi_flash_guard_start_func_t start; /**< critical section start func */ + spi_flash_guard_end_func_t end; /**< critical section end func */ + spi_flash_op_lock_func_t op_lock; /**< flash access API lock func */ + spi_flash_op_unlock_func_t op_unlock; /**< flash access API unlock func */ } spi_flash_guard_funcs_t; /** From 732a5fd0b2c2e6ff3742781714c4d3d204d90865 Mon Sep 17 00:00:00 2001 From: He Yin Ling Date: Thu, 2 Feb 2017 21:59:00 +0800 Subject: [PATCH 2/8] CI: get test env config from gitlab Previous design was put test env config on local runners. It's not easy to manage as test runners count growing. Now we'll put config files for test runners to a Gitlab repository. Test runners will get its config from Gitlab every time before running. --- .gitlab-ci.yml | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 5cd5fcecec..8ea64e142b 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -291,8 +291,7 @@ check_doc_links: allow_failure: true variables: - # LOCAL_ENV_CONFIG_PATH: define in template and jobs can overwrite if required - LOCAL_ENV_CONFIG_PATH: /home/gitlab-runner/LocalConfig/ESP32_IDF + LOCAL_ENV_CONFIG_PATH: $CI_PROJECT_DIR/ci-test-runner-configs/$CI_RUNNER_DESCRIPTION/ESP32_IDF BIN_PATH: "$CI_PROJECT_DIR/SSC/ssc_bin/SSC" APP_NAME: "ssc" LOG_PATH: "$CI_PROJECT_DIR/$CI_BUILD_REF" @@ -317,6 +316,8 @@ check_doc_links: - base64 --decode --ignore-garbage ~/.ssh/id_rsa_base64 > ~/.ssh/id_rsa - chmod 600 ~/.ssh/id_rsa - echo -e "Host gitlab.espressif.cn\n\tStrictHostKeyChecking no\n" >> ~/.ssh/config + # clone local test env configs + - git clone $GITLAB_SSH_SERVER/qa/ci-test-runner-configs.git # clone test bench - git clone $GITLAB_SSH_SERVER/yinling/auto_test_script.git - cd auto_test_script @@ -342,6 +343,8 @@ check_doc_links: - base64 --decode --ignore-garbage ~/.ssh/id_rsa_base64 > ~/.ssh/id_rsa - chmod 600 ~/.ssh/id_rsa - echo -e "Host gitlab.espressif.cn\n\tStrictHostKeyChecking no\n" >> ~/.ssh/config + # clone local test env configs + - git clone $GITLAB_SSH_SERVER/qa/ci-test-runner-configs.git # clone test bench - git clone $GITLAB_SSH_SERVER/yinling/auto_test_script.git - cd auto_test_script @@ -355,8 +358,7 @@ check_doc_links: stage: unit_test variables: - # jobs MUST set CONFIG_FILE in before_script, and overwrite the variables above if necessary - LOCAL_ENV_CONFIG_PATH: /home/gitlab-runner/LocalConfig/ESP32_IDF + LOCAL_ENV_CONFIG_PATH: $CI_PROJECT_DIR/ci-test-runner-configs/$CI_RUNNER_DESCRIPTION/ESP32_IDF BIN_PATH: "$CI_PROJECT_DIR/tools/unit-test-app/build/" LOG_PATH: "$CI_PROJECT_DIR/$CI_BUILD_REF" APP_NAME: "ut" From 627bc23b1c3aa049b5d65762ba6ae996ebe13aaf Mon Sep 17 00:00:00 2001 From: shangke Date: Mon, 6 Feb 2017 11:19:16 +0800 Subject: [PATCH 3/8] ethernet:disable flow control when select l2_to_l3_copy_mode --- components/ethernet/emac_main.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/components/ethernet/emac_main.c b/components/ethernet/emac_main.c index 853887cfc5..fd0f59604f 100644 --- a/components/ethernet/emac_main.c +++ b/components/ethernet/emac_main.c @@ -537,6 +537,10 @@ static void emac_check_phy_init(void) } else { REG_CLR_BIT(EMAC_GMACCONFIG_REG, EMAC_GMACFESPEED); } +#if CONFIG_EMAC_L2_TO_L3_RX_BUF_MODE + emac_disable_flowctrl(); + emac_config.emac_flow_ctrl_partner_support = false; +#else if (emac_config.emac_flow_ctrl_enable == true) { if (emac_config.emac_phy_get_partner_pause_enable() == true && emac_config.emac_phy_get_duplex_mode() == ETH_MDOE_FULLDUPLEX) { emac_enable_flowctrl(); @@ -549,6 +553,7 @@ static void emac_check_phy_init(void) emac_disable_flowctrl(); emac_config.emac_flow_ctrl_partner_support = false; } +#endif emac_mac_enable_txrx(); } static void emac_process_link_updown(bool link_status) From d07a149e2cc32ecb9b5d933ff88e3e1613ce3fc7 Mon Sep 17 00:00:00 2001 From: Jeroen Domburg Date: Fri, 27 Jan 2017 17:17:05 +0800 Subject: [PATCH 4/8] Fix interrupting task on other CPU that has lower prio than current task on current CPU --- components/freertos/tasks.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/components/freertos/tasks.c b/components/freertos/tasks.c index 0b5cc42957..f885e9c013 100644 --- a/components/freertos/tasks.c +++ b/components/freertos/tasks.c @@ -632,7 +632,7 @@ static void prvAddNewTaskToReadyList( TCB_t *pxNewTCB, TaskFunction_t pxTaskCode */ void taskYIELD_OTHER_CORE( BaseType_t xCoreID, UBaseType_t uxPriority ) { - TCB_t *curTCB = xTaskGetCurrentTaskHandle(); + TCB_t *curTCB = pxCurrentTCB[xCoreID]; BaseType_t i; if (xCoreID != tskNO_AFFINITY) { From b748a63a43efa4118157fed4f4c0488b0baf38c9 Mon Sep 17 00:00:00 2001 From: Liu Zhi Fu Date: Mon, 6 Feb 2017 17:56:42 +0800 Subject: [PATCH 5/8] esp32: fix several misc wifi issue 1. Fix ssid_str not free issue 2. Fix sniffer not work issue 3. Fix null parameter cause esp_wifi_init crash issue 4. Enable ap ampdu rx interface --- components/esp32/lib | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/components/esp32/lib b/components/esp32/lib index 45414a6778..d0b9797601 160000 --- a/components/esp32/lib +++ b/components/esp32/lib @@ -1 +1 @@ -Subproject commit 45414a6778e1bf2855f18a8c6b954d5cf575bb40 +Subproject commit d0b97976010528cbb469d5bb12f2c20449ca6c5b From 2c334b46e06cddbc2cf9dc155c233e2d27d8cde0 Mon Sep 17 00:00:00 2001 From: Tian Hao Date: Wed, 8 Feb 2017 15:03:57 +0800 Subject: [PATCH 6/8] component/bt : fix BLUFI bug with small MTU size --- .../bt/bluedroid/btc/profile/esp/blufi/blufi_prf.c | 13 +++++++++---- .../btc/profile/esp/blufi/include/blufi_int.h | 5 ++++- 2 files changed, 13 insertions(+), 5 deletions(-) diff --git a/components/bt/bluedroid/btc/profile/esp/blufi/blufi_prf.c b/components/bt/bluedroid/btc/profile/esp/blufi/blufi_prf.c index 15b4ccf5a9..bf9ba35a04 100644 --- a/components/bt/bluedroid/btc/profile/esp/blufi/blufi_prf.c +++ b/components/bt/bluedroid/btc/profile/esp/blufi/blufi_prf.c @@ -177,6 +177,10 @@ static void blufi_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data) blufi_env.prepare_buf = NULL; } + break; + case BTA_GATTS_MTU_EVT: + LOG_DEBUG("MTU size %d\n", p_data->req_data.p_data->mtu); + blufi_env.frag_size = p_data->req_data.p_data->mtu - BLUFI_MTU_RESERVED_SIZE; break; case BTA_GATTS_CONF_EVT: LOG_DEBUG("CONIRM EVT\n"); @@ -294,6 +298,7 @@ static tGATT_STATUS btc_blufi_profile_init(void) memset(&blufi_env, 0x0, sizeof(blufi_env)); blufi_env.cbs = store_p; /* if set callback prior, restore the point */ + blufi_env.frag_size = BLUFI_FRAG_DATA_DEFAULT_LEN; /* register the BLUFI profile to the BTA_GATTS module*/ BTA_GATTS_AppRegister(&blufi_app_uuid, blufi_profile_cb); @@ -406,16 +411,16 @@ void btc_blufi_send_encap(uint8_t type, uint8_t *data, int total_data_len) int ret; while (remain_len > 0) { - if (remain_len > BLUFI_FRAG_DATA_MAX_LEN) { - hdr = GKI_getbuf(sizeof(struct blufi_hdr) + 2 + BLUFI_FRAG_DATA_MAX_LEN + 2); + if (remain_len > blufi_env.frag_size) { + hdr = GKI_getbuf(sizeof(struct blufi_hdr) + 2 + blufi_env.frag_size + 2); if (hdr == NULL) { LOG_ERROR("%s no mem\n", __func__); return; } hdr->fc = 0x0; - hdr->data_len = BLUFI_FRAG_DATA_MAX_LEN + 2; + hdr->data_len = blufi_env.frag_size + 2; *(uint16_t *)hdr->data = remain_len; - memcpy(hdr->data + 2, &data[total_data_len - remain_len], BLUFI_FRAG_DATA_MAX_LEN); //copy first, easy for check sum + memcpy(hdr->data + 2, &data[total_data_len - remain_len], blufi_env.frag_size); //copy first, easy for check sum hdr->fc |= BLUFI_FC_FRAG; } else { hdr = GKI_getbuf(sizeof(struct blufi_hdr) + remain_len + 2); diff --git a/components/bt/bluedroid/btc/profile/esp/blufi/include/blufi_int.h b/components/bt/bluedroid/btc/profile/esp/blufi/include/blufi_int.h index c21b41c4ca..c8b002348d 100644 --- a/components/bt/bluedroid/btc/profile/esp/blufi/include/blufi_int.h +++ b/components/bt/bluedroid/btc/profile/esp/blufi/include/blufi_int.h @@ -33,6 +33,7 @@ typedef struct { BD_ADDR remote_bda; UINT32 trans_id; UINT8 congest; + UINT16 frag_size; #define BLUFI_PREPAIR_BUF_MAX_SIZE 1024 uint8_t *prepare_buf; int prepare_len; @@ -160,7 +161,9 @@ typedef struct blufi_frag_hdr blufi_frag_hdr_t; #define BLUFI_FC_IS_REQ_ACK(fc) ((fc) & BLUFI_FC_REQ_ACK_MASK) #define BLUFI_FC_IS_FRAG(fc) ((fc) & BLUFI_FC_FRAG_MASK) -#define BLUFI_FRAG_DATA_MAX_LEN 50 +/* BLUFI HEADER + TOTAL(REMAIN) LENGTH + CRC + L2CAP RESERVED */ +#define BLUFI_MTU_RESERVED_SIZE (sizeof(struct blufi_hdr) + 2 + 2 + 3) +#define BLUFI_FRAG_DATA_DEFAULT_LEN (GATT_DEF_BLE_MTU_SIZE - BLUFI_MTU_RESERVED_SIZE) //function declare void btc_blufi_protocol_handler(uint8_t type, uint8_t *data, int len); From cf917567e9ae55aa96633094afcc9b771fb466e4 Mon Sep 17 00:00:00 2001 From: Tian Hao Date: Fri, 10 Feb 2017 11:02:10 +0800 Subject: [PATCH 7/8] component/bt : use real adv data to set raw adv data --- examples/bluetooth/gatt_server/main/Kconfig | 10 +++++---- .../bluetooth/gatt_server/main/gatts_demo.c | 22 +++++++++++-------- 2 files changed, 19 insertions(+), 13 deletions(-) diff --git a/examples/bluetooth/gatt_server/main/Kconfig b/examples/bluetooth/gatt_server/main/Kconfig index e37d40057f..7f01d57447 100644 --- a/examples/bluetooth/gatt_server/main/Kconfig +++ b/examples/bluetooth/gatt_server/main/Kconfig @@ -1,10 +1,12 @@ menu "Example 'GATT SERVER' Config" config SET_RAW_ADV_DATA - bool "adv data or scan_rsp data use raw data or structure" - default "y" + bool "Use raw data for advertising packets and scan response data" help - Set raw advertising data/scan response data by self or use adv_data/scan_rsp_data structure to - set advertising data/scan response data. If use structure, lower layer will encapsulate the packets. + If this config item is set, raw binary data will be used to generate advertising & scan response data. + This option uses the esp_ble_gap_config_adv_data_raw() and esp_ble_gap_config_scan_rsp_data_raw() functions. + + If this config item is unset, advertising & scan response data is provided via a higher-level esp_ble_adv_data_t structure. + The lower layer will generate the BLE packets. This option has higher overhead at runtime. endmenu diff --git a/examples/bluetooth/gatt_server/main/gatts_demo.c b/examples/bluetooth/gatt_server/main/gatts_demo.c index a018ddb752..0afa1630ba 100644 --- a/examples/bluetooth/gatt_server/main/gatts_demo.c +++ b/examples/bluetooth/gatt_server/main/gatts_demo.c @@ -51,21 +51,25 @@ static void gatts_profile_b_event_handler(esp_gatts_cb_event_t event, esp_gatt_i #define TEST_DEVICE_NAME "ESP_GATTS_DEMO" #define TEST_MANUFACTURER_DATA_LEN 17 -#define GATTS_DEMO_CHAR_VAL_LEN_MAX 0x40 +#define GATTS_DEMO_CHAR_VAL_LEN_MAX 0x40 uint8_t char1_str[] = {0x11,0x22,0x33}; esp_attr_value_t gatts_demo_char1_val = { - .attr_max_len = GATTS_DEMO_CHAR_VAL_LEN_MAX, - .attr_len = sizeof(char1_str), - .attr_value = char1_str, + .attr_max_len = GATTS_DEMO_CHAR_VAL_LEN_MAX, + .attr_len = sizeof(char1_str), + .attr_value = char1_str, }; #ifdef CONFIG_SET_RAW_ADV_DATA -static uint8_t raw_adv_data[] = {0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, - 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe}; -static uint8_t raw_scan_rsp_data[] = {0x7, 0x7, 0x7, 0x7, 0x8, 0x8, 0x8, 0x8, 0x9, 0x9, 0x9, 0x9, 0xa, 0xa, 0xa, 0xa, - 0xb, 0xb, 0xb, 0xb, 0xc, 0xc, 0xc, 0xc, 0xd, 0xd, 0xd, 0xd, 0xe, 0xe, 0xe}; +static uint8_t raw_adv_data[] = { + 0x02, 0x01, 0x06, 0x0f, 0x09, 0x45, 0x53, 0x50, 0x5f, 0x47, 0x41, 0x54, 0x54, 0x53, 0x5f, 0x44, + 0x45, 0x4d, 0x4f, 0x02, 0x0a, 0xeb, 0x03, 0x03, 0xab, 0xcd +}; +static uint8_t raw_scan_rsp_data[] = { + 0x02, 0x01, 0x06, 0x0f, 0x09, 0x45, 0x53, 0x50, 0x5f, 0x47, 0x41, 0x54, 0x54, 0x53, 0x5f, 0x44, + 0x45, 0x4d, 0x4f, 0x02, 0x0a, 0xeb, 0x03, 0x03, 0xab, 0xcd +}; #else static uint8_t test_service_uuid128[32] = { /* LSB <--------------------------------------------------------------------------------> MSB */ @@ -211,7 +215,7 @@ static void gatts_profile_a_event_handler(esp_gatts_cb_event_t event, esp_gatt_i case ESP_GATTS_ADD_INCL_SRVC_EVT: break; case ESP_GATTS_ADD_CHAR_EVT: { - uint16_t length = 0; + uint16_t length = 0; const uint8_t *prf_char; ESP_LOGI(GATTS_TAG, "ADD_CHAR_EVT, status %d, attr_handle %d, service_handle %d\n", From 5fd7bd14dbc3adc6aedb74918103c9999f1dc322 Mon Sep 17 00:00:00 2001 From: Tian Hao Date: Mon, 13 Feb 2017 14:00:26 +0800 Subject: [PATCH 8/8] component/bt : fix GATT disconnect memory leak bug --- components/bt/bluedroid/stack/gatt/gatt_sr.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/components/bt/bluedroid/stack/gatt/gatt_sr.c b/components/bt/bluedroid/stack/gatt/gatt_sr.c index a7ee3b5ad0..793ac1a9b0 100644 --- a/components/bt/bluedroid/stack/gatt/gatt_sr.c +++ b/components/bt/bluedroid/stack/gatt/gatt_sr.c @@ -1162,6 +1162,10 @@ static void gatts_process_read_req(tGATT_TCB *p_tcb, tGATT_SR_REG *p_rcb, UINT8 } else if (reason == GATT_SUCCESS || reason == GATT_STACK_RSP) { attp_send_sr_msg(p_tcb, p_msg); gatt_dequeue_sr_cmd(p_tcb); + } else { + if (p_msg) { + GKI_freebuf(p_msg); + } } }