#include <freertos/semphr.h>
#include <unity.h>
+#include <test_utils.h>
#include <esp_spi_flash.h>
#include <esp_attr.h>
#include <esp_flash_encrypt.h>
-#include "test_config.h"
-
static void test_encrypted_write(size_t offset, const uint8_t *data, size_t length);
static void verify_erased_flash(size_t offset, size_t length);
+static size_t start;
+
+static void setup_tests()
+{
+ if (start == 0) {
+ const esp_partition_t *part = get_test_data_partition();
+ start = part->address;
+ printf("Test data partition @ 0x%x\n", start);
+ }
+}
+
TEST_CASE("test 16 byte encrypted writes", "[spi_flash]")
{
+ setup_tests();
+
if (!esp_flash_encryption_enabled()) {
TEST_IGNORE_MESSAGE("flash encryption disabled, skipping spi_flash_write_encrypted() tests");
}
TEST_ASSERT_EQUAL_HEX(ESP_OK,
- spi_flash_erase_sector(TEST_REGION_START / SPI_FLASH_SEC_SIZE));
+ spi_flash_erase_sector(start / SPI_FLASH_SEC_SIZE));
uint8_t fortyeight_bytes[0x30]; // 0, 1, 2, 3, 4... 47
for(int i = 0; i < sizeof(fortyeight_bytes); i++) {
/* Verify unaligned start or length fails */
TEST_ASSERT_EQUAL_HEX(ESP_ERR_INVALID_ARG,
- spi_flash_write_encrypted(TEST_REGION_START+1, fortyeight_bytes, 32));
+ spi_flash_write_encrypted(start+1, fortyeight_bytes, 32));
TEST_ASSERT_EQUAL_HEX(ESP_ERR_INVALID_SIZE,
- spi_flash_write_encrypted(TEST_REGION_START, fortyeight_bytes, 15));
+ spi_flash_write_encrypted(start, fortyeight_bytes, 15));
/* ensure nothing happened to the flash yet */
- verify_erased_flash(TEST_REGION_START, 0x20);
+ verify_erased_flash(start, 0x20);
/* Write 32 byte block, this is the "normal" encrypted write */
- test_encrypted_write(TEST_REGION_START, fortyeight_bytes, 0x20);
- verify_erased_flash(TEST_REGION_START + 0x20, 0x20);
+ test_encrypted_write(start, fortyeight_bytes, 0x20);
+ verify_erased_flash(start + 0x20, 0x20);
/* Slip in an unaligned spi_flash_read_encrypted() test */
uint8_t buf[0x10];
- spi_flash_read_encrypted(TEST_REGION_START+0x10, buf, 0x10);
+ spi_flash_read_encrypted(start+0x10, buf, 0x10);
TEST_ASSERT_EQUAL_HEX8_ARRAY(fortyeight_bytes+0x10, buf, 16);
/* Write 16 bytes unaligned */
- test_encrypted_write(TEST_REGION_START + 0x30, fortyeight_bytes, 0x10);
+ test_encrypted_write(start + 0x30, fortyeight_bytes, 0x10);
/* the 16 byte regions before and after the 16 bytes we just wrote should still be 0xFF */
- verify_erased_flash(TEST_REGION_START + 0x20, 0x10);
- verify_erased_flash(TEST_REGION_START + 0x40, 0x10);
+ verify_erased_flash(start + 0x20, 0x10);
+ verify_erased_flash(start + 0x40, 0x10);
/* Write 48 bytes starting at a 32-byte aligned offset */
- test_encrypted_write(TEST_REGION_START + 0x40, fortyeight_bytes, 0x30);
+ test_encrypted_write(start + 0x40, fortyeight_bytes, 0x30);
/* 16 bytes after this write should still be 0xFF -unencrypted- */
- verify_erased_flash(TEST_REGION_START + 0x70, 0x10);
+ verify_erased_flash(start + 0x70, 0x10);
/* Write 48 bytes starting at a 16-byte aligned offset */
- test_encrypted_write(TEST_REGION_START + 0x90, fortyeight_bytes, 0x30);
+ test_encrypted_write(start + 0x90, fortyeight_bytes, 0x30);
/* 16 bytes after this write should still be 0xFF -unencrypted- */
- verify_erased_flash(TEST_REGION_START + 0x120, 0x10);
+ verify_erased_flash(start + 0x120, 0x10);
}
static void test_encrypted_write(size_t offset, const uint8_t *data, size_t length)
#include <esp_partition.h>
#include <esp_flash_encrypt.h>
-#include "test_config.h"
+#include "test_utils.h"
static uint32_t buffer[1024];
-/* read-only region used for mmap tests */
-static const uint32_t start = 0x100000;
-static const uint32_t end = 0x200000;
+/* read-only region used for mmap tests, intialised in setup_mmap_tests() */
+static uint32_t start;
+static uint32_t end;
static spi_flash_mmap_handle_t handle1, handle2, handle3;
static void setup_mmap_tests()
{
+ if (start == 0) {
+ const esp_partition_t *part = get_test_data_partition();
+ start = part->address;
+ end = part->address + part->size;
+ printf("Test data partition @ 0x%x - 0x%x\n", start, end);
+ }
+ TEST_ASSERT(end > start);
+ TEST_ASSERT(end - start >= 512*1024);
+
/* clean up any mmap handles left over from failed tests */
if (handle1) {
spi_flash_munmap(handle1);
srand(0);
for (int block = start / 0x10000; block < end / 0x10000; ++block) {
for (int sector = 0; sector < 16; ++sector) {
- uint32_t abs_sector = (block) * 16 + sector;
+ uint32_t abs_sector = (block * 16) + sector;
uint32_t sector_offs = abs_sector * SPI_FLASH_SEC_SIZE;
bool sector_needs_write = false;
for (uint32_t word = 0; word < 1024; ++word) {
uint32_t val = rand();
if (block == start / 0x10000 && sector == 0 && word == 0) {
- printf("setup_mmap_tests(): first prepped word: %08x\n", val);
+ printf("setup_mmap_tests(): first prepped word: 0x%08x (flash holds 0x%08x)\n", val, buffer[word]);
}
if (buffer[word] != val) {
buffer[word] = val;
}
}
-TEST_CASE("Can mmap into data address space", "[mmap]")
+TEST_CASE("Can mmap into data address space", "[spi_flash]")
{
setup_mmap_tests();
srand(0);
const uint32_t *data = (const uint32_t *) ptr1;
for (int block = 0; block < (end - start) / 0x10000; ++block) {
+ printf("block %d\n", block);
for (int sector = 0; sector < 16; ++sector) {
+ printf("sector %d\n", sector);
for (uint32_t word = 0; word < 1024; ++word) {
- TEST_ASSERT_EQUAL_UINT32(rand(), data[(block * 16 + sector) * 1024 + word]);
+ TEST_ASSERT_EQUAL_HEX32(rand(), data[(block * 16 + sector) * 1024 + word]);
}
}
}
TEST_IGNORE_MESSAGE("flash encryption enabled, spi_flash_write_encrypted() test won't pass as-is");
}
- ESP_ERROR_CHECK( spi_flash_erase_sector(TEST_REGION_START / SPI_FLASH_SEC_SIZE) );
+ ESP_ERROR_CHECK( spi_flash_erase_sector(start / SPI_FLASH_SEC_SIZE) );
/* map erased test region to ptr1 */
- ESP_ERROR_CHECK( spi_flash_mmap(TEST_REGION_START, test_size, SPI_FLASH_MMAP_DATA, &ptr1, &handle1) );
+ ESP_ERROR_CHECK( spi_flash_mmap(start, test_size, SPI_FLASH_MMAP_DATA, &ptr1, &handle1) );
printf("mmap_res ptr1: handle=%d ptr=%p\n", handle1, ptr1);
/* verify it's all 0xFF */
/* write flash region to 0xEE */
uint8_t buf[test_size];
memset(buf, 0xEE, test_size);
- ESP_ERROR_CHECK( spi_flash_write(TEST_REGION_START, buf, test_size) );
+ ESP_ERROR_CHECK( spi_flash_write(start, buf, test_size) );
/* re-map the test region at ptr1.
this is a fresh mmap call so should trigger a cache flush,
ensuring we see the updated flash.
*/
- ESP_ERROR_CHECK( spi_flash_mmap(TEST_REGION_START, test_size, SPI_FLASH_MMAP_DATA, &ptr1, &handle1) );
+ ESP_ERROR_CHECK( spi_flash_mmap(start, test_size, SPI_FLASH_MMAP_DATA, &ptr1, &handle1) );
printf("mmap_res ptr1 #2: handle=%d ptr=%p\n", handle1, ptr1);
/* assert that ptr1 now maps to the new values on flash,
TEST_CASE("phys2cache/cache2phys basic checks", "[spi_flash]")
{
- uint8_t buf_a[32], buf_b[32];
+ uint8_t buf[64];
+
+ static const uint8_t constant_data[] = { 1, 2, 3, 7, 11, 16, 3, 88 };
/* esp_partition_find is in IROM */
uint32_t phys = spi_flash_cache2phys(esp_partition_find);
TEST_ASSERT_EQUAL_PTR(esp_partition_find, spi_flash_phys2cache(phys, SPI_FLASH_MMAP_INST));
TEST_ASSERT_EQUAL_PTR(NULL, spi_flash_phys2cache(phys, SPI_FLASH_MMAP_DATA));
- /* Read the flash @ 'phys' and compare it to the data we get via cache */
- memcpy(buf_a, esp_partition_find, sizeof(buf_a));
- spi_flash_read(phys, buf_b, sizeof(buf_b));
- TEST_ASSERT_EQUAL_HEX8_ARRAY(buf_a, buf_b, sizeof(buf_b));
+ /* Read the flash @ 'phys' and compare it to the data we get via regular cache access */
+ spi_flash_read(phys, buf, sizeof(buf));
+ TEST_ASSERT_EQUAL_HEX32_ARRAY((void *)esp_partition_find, buf, sizeof(buf)/sizeof(uint32_t));
/* spi_flash_mmap is in IRAM */
printf("%p\n", spi_flash_mmap);
TEST_ASSERT_EQUAL_HEX32(SPI_FLASH_CACHE2PHYS_FAIL,
spi_flash_cache2phys(spi_flash_mmap));
- /* 'start' should be in DROM */
- phys = spi_flash_cache2phys(&start);
+ /* 'constant_data' should be in DROM */
+ phys = spi_flash_cache2phys(&constant_data);
TEST_ASSERT_NOT_EQUAL(SPI_FLASH_CACHE2PHYS_FAIL, phys);
- TEST_ASSERT_EQUAL_PTR(&start,
+ TEST_ASSERT_EQUAL_PTR(&constant_data,
spi_flash_phys2cache(phys, SPI_FLASH_MMAP_DATA));
TEST_ASSERT_EQUAL_PTR(NULL, spi_flash_phys2cache(phys, SPI_FLASH_MMAP_INST));
- /* Read the flash @ 'phys' and compare it to the data we get via cache */
- memcpy(buf_a, &start, sizeof(start));
- spi_flash_read(phys, buf_b, sizeof(start));
- TEST_ASSERT_EQUAL_HEX8_ARRAY(buf_a, buf_b, sizeof(start));
+ /* Read the flash @ 'phys' and compare it to the data we get via normal cache access */
+ spi_flash_read(phys, buf, sizeof(constant_data));
+ TEST_ASSERT_EQUAL_HEX8_ARRAY(constant_data, buf, sizeof(constant_data));
}
TEST_CASE("mmap consistent with phys2cache/cache2phys", "[spi_flash]")
TEST_ASSERT_EQUAL_HEX(SPI_FLASH_CACHE2PHYS_FAIL, spi_flash_cache2phys(ptr));
- ESP_ERROR_CHECK( spi_flash_mmap(TEST_REGION_START, test_size, SPI_FLASH_MMAP_DATA, &ptr, &handle1) );
+ ESP_ERROR_CHECK( spi_flash_mmap(start, test_size, SPI_FLASH_MMAP_DATA, &ptr, &handle1) );
TEST_ASSERT_NOT_NULL(ptr);
TEST_ASSERT_NOT_EQUAL(0, handle1);
- TEST_ASSERT_EQUAL_HEX(TEST_REGION_START, spi_flash_cache2phys(ptr));
- TEST_ASSERT_EQUAL_HEX(TEST_REGION_START + 1024, spi_flash_cache2phys((void *)((intptr_t)ptr + 1024)));
- TEST_ASSERT_EQUAL_HEX(TEST_REGION_START + 3000, spi_flash_cache2phys((void *)((intptr_t)ptr + 3000)));
+ TEST_ASSERT_EQUAL_HEX(start, spi_flash_cache2phys(ptr));
+ TEST_ASSERT_EQUAL_HEX(start + 1024, spi_flash_cache2phys((void *)((intptr_t)ptr + 1024)));
+ TEST_ASSERT_EQUAL_HEX(start + 3000, spi_flash_cache2phys((void *)((intptr_t)ptr + 3000)));
/* this pointer lands in a different MMU table entry */
- TEST_ASSERT_EQUAL_HEX(TEST_REGION_START + test_size - 4, spi_flash_cache2phys((void *)((intptr_t)ptr + test_size - 4)));
+ TEST_ASSERT_EQUAL_HEX(start + test_size - 4, spi_flash_cache2phys((void *)((intptr_t)ptr + test_size - 4)));
spi_flash_munmap(handle1);
handle1 = 0;
#include <sys/param.h>
#include <unity.h>
+#include <test_utils.h>
#include <esp_spi_flash.h>
#include <rom/spi_flash.h>
#include "../cache_utils.h"
#include "soc/timer_group_struct.h"
#include "soc/timer_group_reg.h"
-#include "test_config.h"
-
/* Base offset in flash for tests. */
-#define FLASH_BASE TEST_REGION_START
+static size_t start;
+
+static void setup_tests()
+{
+ if (start == 0) {
+ const esp_partition_t *part = get_test_data_partition();
+ start = part->address;
+ printf("Test data partition @ 0x%x\n", start);
+ }
+}
#ifndef CONFIG_SPI_FLASH_MINIMAL_TEST
#define CONFIG_SPI_FLASH_MINIMAL_TEST 1
fprintf(stderr, "src=%d dst=%d len=%d\n", src_off, dst_off, len);
memset(src_buf, 0xAA, sizeof(src_buf));
fill(((char *) src_buf) + src_off, src_off, len);
- ESP_ERROR_CHECK(spi_flash_erase_sector((FLASH_BASE + src_off) / SPI_FLASH_SEC_SIZE));
+ ESP_ERROR_CHECK(spi_flash_erase_sector((start + src_off) / SPI_FLASH_SEC_SIZE));
spi_flash_disable_interrupts_caches_and_other_cpu();
- SpiFlashOpResult rc = SPIWrite(FLASH_BASE, src_buf, sizeof(src_buf));
+ SpiFlashOpResult rc = SPIWrite(start, src_buf, sizeof(src_buf));
spi_flash_enable_interrupts_caches_and_other_cpu();
TEST_ASSERT_EQUAL_INT(rc, SPI_FLASH_RESULT_OK);
memset(dst_buf, 0x55, sizeof(dst_buf));
memset(dst_gold, 0x55, sizeof(dst_gold));
fill(dst_gold + dst_off, src_off, len);
- ESP_ERROR_CHECK(spi_flash_read(FLASH_BASE + src_off, dst_buf + dst_off, len));
+ ESP_ERROR_CHECK(spi_flash_read(start + src_off, dst_buf + dst_off, len));
TEST_ASSERT_EQUAL_INT(cmp_or_dump(dst_buf, dst_gold, sizeof(dst_buf)), 0);
}
TEST_CASE("Test spi_flash_read", "[spi_flash_read]")
{
+ setup_tests();
#if CONFIG_SPI_FLASH_MINIMAL_TEST
test_read(0, 0, 0);
test_read(0, 0, 4);
memset(src_buf, 0x55, sizeof(src_buf));
fill(src_buf + src_off, src_off, len);
// Fills with 0xff
- ESP_ERROR_CHECK(spi_flash_erase_sector((FLASH_BASE + dst_off) / SPI_FLASH_SEC_SIZE));
+ ESP_ERROR_CHECK(spi_flash_erase_sector((start + dst_off) / SPI_FLASH_SEC_SIZE));
memset(dst_gold, 0xff, sizeof(dst_gold));
if (len > 0) {
int pad_left_off = (dst_off & ~3U);
}
fill(dst_gold + dst_off, src_off, len);
}
- ESP_ERROR_CHECK(spi_flash_write(FLASH_BASE + dst_off, src_buf + src_off, len));
+ ESP_ERROR_CHECK(spi_flash_write(start + dst_off, src_buf + src_off, len));
spi_flash_disable_interrupts_caches_and_other_cpu();
- SpiFlashOpResult rc = SPIRead(FLASH_BASE, dst_buf, sizeof(dst_buf));
+ SpiFlashOpResult rc = SPIRead(start, dst_buf, sizeof(dst_buf));
spi_flash_enable_interrupts_caches_and_other_cpu();
TEST_ASSERT_EQUAL_INT(rc, SPI_FLASH_RESULT_OK);
TEST_ASSERT_EQUAL_INT(cmp_or_dump(dst_buf, dst_gold, sizeof(dst_buf)), 0);
TEST_CASE("Test spi_flash_write", "[spi_flash_write]")
{
+ setup_tests();
#if CONFIG_SPI_FLASH_MINIMAL_TEST
test_write(0, 0, 0);
test_write(0, 0, 4);
* NB: At the moment these only support aligned addresses, because memcpy
* is not aware of the 32-but load requirements for these regions.
*/
- ESP_ERROR_CHECK(spi_flash_write(FLASH_BASE, (char *) 0x40000000, 16));
- ESP_ERROR_CHECK(spi_flash_write(FLASH_BASE, (char *) 0x40070000, 16));
- ESP_ERROR_CHECK(spi_flash_write(FLASH_BASE, (char *) 0x40078000, 16));
- ESP_ERROR_CHECK(spi_flash_write(FLASH_BASE, (char *) 0x40080000, 16));
+ ESP_ERROR_CHECK(spi_flash_write(start, (char *) 0x40000000, 16));
+ ESP_ERROR_CHECK(spi_flash_write(start, (char *) 0x40070000, 16));
+ ESP_ERROR_CHECK(spi_flash_write(start, (char *) 0x40078000, 16));
+ ESP_ERROR_CHECK(spi_flash_write(start, (char *) 0x40080000, 16));
}
#include <esp_spi_flash.h>
#include <esp_attr.h>
-#include "test_config.h"
-
struct flash_test_ctx {
uint32_t offset;
bool fail;
-// Copyright 2010-2016 Espressif Systems (Shanghai) PTE LTD
+// Copyright 2015-2016 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.
// 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.
-
-// Common header for SPI flash test data
#pragma once
-/* Define a region of flash we can mess up for testing...
+// Utilities for esp-idf unit tests
+
+#include <esp_partition.h>
+
+/* Return the 'flash_test' custom data partition (type 0x55)
+ defined in the custom partition table.
+*/
+const esp_partition_t *get_test_data_partition();
- This is pretty ugly, better to do something with a partition but
- this is OK for now.
- */
-#define TEST_REGION_START 0x180000
-#define TEST_REGION_END 0x1E0000
--- /dev/null
+// Copyright 2015-2016 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.
+
+#include "unity.h"
+#include "test_utils.h"
+
+const esp_partition_t *get_test_data_partition()
+{
+ /* This user type/subtype (0x55) is set in
+ partition_table_unit_test_app.csv */
+ const esp_partition_t *result = esp_partition_find_first(0x55, 0x55, NULL);
+ TEST_ASSERT_NOT_NULL(result); /* means partition table set wrong */
+ return result;
+}
--- /dev/null
+# Special partition table for unit test app
+#
+# Name, Type, SubType, Offset, Size, Flags
+# Note: if you change the phy_init or app partition offset, make sure to change the offset in Kconfig.projbuild
+nvs, data, nvs, 0x9000, 0x4000
+otadata, data, ota, 0xd000, 0x2000
+phy_init, data, phy, 0xf000, 0x1000
+factory, 0, 0, 0x10000, 1M
+ota_0, 0, ota_0, , 1M
+ota_1, 0, ota_1, , 1M
+# flash_test partition used for SPI flash tests
+flash_test, 0x55, 0x55, , 512K
CONFIG_LOG_BOOTLOADER_LEVEL=2
#
-# Secure boot configuration
+# Security features
#
-CONFIG_SECURE_BOOTLOADER_DISABLED=y
-# CONFIG_SECURE_BOOTLOADER_ONE_TIME_FLASH is not set
-# CONFIG_SECURE_BOOTLOADER_REFLASHABLE is not set
-# CONFIG_SECURE_BOOTLOADER_ENABLED is not set
+# CONFIG_SECURE_BOOT_ENABLED is not set
+# CONFIG_FLASH_ENCRYPTION_ENABLED is not set
#
# Serial flasher config
# CONFIG_ESPTOOLPY_FLASHSIZE_8MB is not set
# CONFIG_ESPTOOLPY_FLASHSIZE_16MB is not set
CONFIG_ESPTOOLPY_FLASHSIZE="2MB"
+CONFIG_ESPTOOLPY_FLASHSIZE_DETECT=y
+CONFIG_ESPTOOLPY_BEFORE_RESET=y
+# CONFIG_ESPTOOLPY_BEFORE_NORESET is not set
+# CONFIG_ESPTOOLPY_BEFORE_ESP32R0 is not set
+CONFIG_ESPTOOLPY_BEFORE="default_reset"
+CONFIG_ESPTOOLPY_AFTER_RESET=y
+# CONFIG_ESPTOOLPY_AFTER_NORESET is not set
+CONFIG_ESPTOOLPY_AFTER="hard_reset"
+# CONFIG_MONITOR_BAUD_9600B is not set
+# CONFIG_MONITOR_BAUD_57600B is not set
+CONFIG_MONITOR_BAUD_115200B=y
+# CONFIG_MONITOR_BAUD_230400B is not set
+# CONFIG_MONITOR_BAUD_921600B is not set
+# CONFIG_MONITOR_BAUD_2MB is not set
+# CONFIG_MONITOR_BAUD_OTHER is not set
+CONFIG_MONITOR_BAUD_OTHER_VAL=115200
+CONFIG_MONITOR_BAUD=115200
#
# Partition Table
#
-CONFIG_PARTITION_TABLE_SINGLE_APP=y
+# CONFIG_PARTITION_TABLE_SINGLE_APP is not set
# CONFIG_PARTITION_TABLE_TWO_OTA is not set
-# CONFIG_PARTITION_TABLE_CUSTOM is not set
-CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv"
+CONFIG_PARTITION_TABLE_CUSTOM=y
+CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partition_table_unit_test_app.csv"
CONFIG_PARTITION_TABLE_CUSTOM_APP_BIN_OFFSET=0x10000
-CONFIG_PARTITION_TABLE_FILENAME="partitions_singleapp.csv"
+CONFIG_PARTITION_TABLE_FILENAME="partition_table_unit_test_app.csv"
CONFIG_APP_OFFSET=0x10000
-CONFIG_PHY_DATA_OFFSET=0xf000
+CONFIG_PHY_DATA_OFFSET=
CONFIG_OPTIMIZATION_LEVEL_DEBUG=y
# CONFIG_OPTIMIZATION_LEVEL_RELEASE is not set
#
# Component config
#
-CONFIG_BTC_TASK_STACK_SIZE=2048
+# CONFIG_BT_ENABLED is not set
CONFIG_BT_RESERVE_DRAM=0
#
-# ESP32-specific config
+# ESP32-specific
#
# CONFIG_ESP32_DEFAULT_CPU_FREQ_80 is not set
# CONFIG_ESP32_DEFAULT_CPU_FREQ_160 is not set
CONFIG_ESP32_DEFAULT_CPU_FREQ_240=y
CONFIG_ESP32_DEFAULT_CPU_FREQ_MHZ=240
-# CONFIG_ESP32_ENABLE_STACK_WIFI is not set
-# CONFIG_ESP32_ENABLE_STACK_BT is not set
CONFIG_MEMMAP_SMP=y
# CONFIG_MEMMAP_TRACEMEM is not set
CONFIG_TRACEMEM_RESERVE_DRAM=0x0
+# CONFIG_ESP32_ENABLE_COREDUMP_TO_FLASH is not set
+# CONFIG_ESP32_ENABLE_COREDUMP_TO_UART is not set
+CONFIG_ESP32_ENABLE_COREDUMP_TO_NONE=y
+# CONFIG_ESP32_ENABLE_COREDUMP is not set
CONFIG_SYSTEM_EVENT_QUEUE_SIZE=32
CONFIG_SYSTEM_EVENT_TASK_STACK_SIZE=2048
CONFIG_MAIN_TASK_STACK_SIZE=4096
# CONFIG_ESP32_TIME_SYSCALL_USE_FRC1 is not set
# CONFIG_ESP32_TIME_SYSCALL_USE_NONE is not set
CONFIG_ESP32_RTC_CLOCK_SOURCE_INTERNAL_RC=y
+CONFIG_ESP32_DEEP_SLEEP_WAKEUP_DELAY=0
+CONFIG_WIFI_ENABLED=y
+CONFIG_ESP32_WIFI_RX_BUFFER_NUM=10
+CONFIG_PHY_ENABLED=y
+
+#
+# PHY
+#
CONFIG_ESP32_PHY_AUTO_INIT=y
# CONFIG_ESP32_PHY_INIT_DATA_IN_PARTITION is not set
+CONFIG_ESP32_PHY_MAX_WIFI_TX_POWER=20
CONFIG_ESP32_PHY_MAX_TX_POWER=20
# CONFIG_ETHERNET is not set
# CONFIG_FREERTOS_UNICORE is not set
CONFIG_FREERTOS_CORETIMER_0=y
# CONFIG_FREERTOS_CORETIMER_1 is not set
-# CONFIG_FREERTOS_CORETIMER_2 is not set
CONFIG_FREERTOS_HZ=1000
CONFIG_FREERTOS_ASSERT_ON_UNTESTED_FUNCTION=y
# CONFIG_FREERTOS_CHECK_STACKOVERFLOW_NONE is not set
CONFIG_LWIP_MAX_SOCKETS=4
CONFIG_LWIP_THREAD_LOCAL_STORAGE_INDEX=0
# CONFIG_LWIP_SO_REUSE is not set
+# CONFIG_LWIP_SO_RCVBUF is not set
CONFIG_LWIP_DHCP_MAX_NTP_SERVERS=1
+# CONFIG_LWIP_IP_FRAG is not set
+# CONFIG_LWIP_IP_REASSEMBLY is not set
+CONFIG_TCP_MAXRTX=12
+CONFIG_TCP_SYNMAXRTX=6
+# CONFIG_LWIP_DHCP_DOES_ARP_CHECK is not set
#
# mbedTLS
CONFIG_MBEDTLS_HAVE_TIME=y
# CONFIG_MBEDTLS_HAVE_TIME_DATE is not set
+#
+# OpenSSL
+#
+# CONFIG_OPENSSL_DEBUG is not set
+CONFIG_OPENSSL_ASSERT_DO_NOTHING=y
+# CONFIG_OPENSSL_ASSERT_EXIT is not set
+
#
# SPI Flash driver
#
projects / esp-idf / commitdiff