Mirrors/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2026-09-22 13:01:16 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'test/peripheral_drivers_on_real_encryption_runner_v6.1' into 'release/v6.1'

Browse Source 
test(drivers): run flash encryption apps on real hardware (v6.1)

See merge request espressif/esp-idf!50675
This commit is contained in:
morris
2026-07-29 18:52:19 +08:00
parent 8f2ac25de4 13282c44b0
commit 967f047b62
45 changed files with 252 additions and 545 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
components/esp_driver_dma/src/gdma.c
View File

@@ -484,6 +484,16 @@ esp_err_t gdma_config_transfer(gdma_channel_handle_t dma_chan, const gdma_transf
ext_mem_alignment = BIT(31);
}
#if CONFIG_IDF_TARGET_ESP32S31 && SOC_HAS(LP_AHB_GDMA)
// ESP32-S31 LP AHB GDMA can't burst-access encrypted external memory.
// Keep configuration/installation permissive for callers that only intend to
// use internal buffers, but poison the external-memory alignment so any
// later PSRAM use fails the caller-side validation.
if (config->access_ext_mem && group->bus_id == SOC_GDMA_BUS_LP && esp_efuse_is_flash_encryption_enabled()) {
ext_mem_alignment = BIT(31);
}
#endif
dma_chan->int_mem_alignment = int_mem_alignment;
dma_chan->ext_mem_alignment = ext_mem_alignment;
return ESP_OK;

2
components/esp_driver_dma/src/gdma_priv.h
View File

@@ -41,7 +41,7 @@
#if CI_TEST_SW_RETENTION
#define GDMA_RETENTION_ENTRY REGDMA_SW_TRIGGER_ENTRY
#else
#if SOC_PHY_SUPPORTED
#if SOC_PM_SUPPORT_PMU_MODEM_STATE
#define GDMA_RETENTION_ENTRY (ENTRY(0) | ENTRY(2))
#else
#define GDMA_RETENTION_ENTRY (ENTRY(0))

12
components/esp_driver_dma/test_apps/dma/main/gdma_test_utils.h
View File

@@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2024-2026 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@@ -7,8 +7,18 @@
#pragma once
#include <stdbool.h>
#include "sdkconfig.h"
#include "esp_private/gdma.h"
#if CONFIG_IDF_TARGET_ESP32S31
// ESP32-S31 LP AHB GDMA can't burst-access external PSRAM. Skip the
// flash-encrypted PSRAM test paths because encrypted PSRAM requires burst
// accesses aligned to the encryption block size.
#define GDMA_TEST_LP_AHB_BURST_PSRAM_SUPPORTED 0
#else
#define GDMA_TEST_LP_AHB_BURST_PSRAM_SUPPORTED 1
#endif
#ifdef __cplusplus
extern "C" {
#endif

13
components/esp_driver_dma/test_apps/dma/main/test_async_memcpy.c
View File

@@ -18,6 +18,7 @@
#include "esp_async_memcpy.h"
#include "hal/efuse_hal.h"
#include "esp_efuse.h"
#include "gdma_test_utils.h"
#if SOC_GDMA_SUPPORTED
#include "hal/gdma_ll.h"
@@ -425,10 +426,14 @@ TEST_CASE("memory copy performance 40KB: PSRAM->PSRAM", "[async mcp]")
#if SOC_HAS(LP_AHB_GDMA)
#if GDMA_LL_GET(LP_AHB_PSRAM_CAPABLE)
printf("Testing memcpy by LP AHB GDMA\r\n");
TEST_ESP_OK(esp_async_memcpy_install_gdma_lp_ahb(&driver_config, &driver));
test_memcpy_performance(driver, 40 * 1024, true, true);
TEST_ESP_OK(esp_async_memcpy_uninstall(driver));
if (esp_efuse_is_flash_encryption_enabled() && !GDMA_TEST_LP_AHB_BURST_PSRAM_SUPPORTED) {
TEST_IGNORE_MESSAGE("Skipping LP AHB GDMA PSRAM->PSRAM under flash encryption");
} else {
printf("Testing memcpy by LP AHB GDMA\r\n");
TEST_ESP_OK(esp_async_memcpy_install_gdma_lp_ahb(&driver_config, &driver));
test_memcpy_performance(driver, 40 * 1024, true, true);
TEST_ESP_OK(esp_async_memcpy_uninstall(driver));
}
#endif // GDMA_LL_GET(LP_AHB_PSRAM_CAPABLE)
#endif // SOC_HAS(LP_AHB_GDMA)
}

31
components/esp_driver_dma/test_apps/dma/main/test_gdma.c
View File

@@ -401,6 +401,7 @@ static void test_gdma_m2m_mode(bool trig_retention_backup)
gdma_channel_alloc_config_t chan_alloc_config = {};
#if SOC_HAS(AHB_GDMA)
printf("Testing GDMA M2M Mode by AHB GDMA%s\n", trig_retention_backup ? " with retention backup" : "");
TEST_ESP_OK(gdma_new_ahb_channel(&chan_alloc_config, &tx_chan, &rx_chan));
test_gdma_m2m_transaction(tx_chan, rx_chan, false, trig_retention_backup);
@@ -410,6 +411,7 @@ static void test_gdma_m2m_mode(bool trig_retention_backup)
#endif // SOC_HAS(AHB_GDMA)
#if SOC_HAS(AXI_GDMA)
printf("Testing GDMA M2M Mode by AXI GDMA%s\n", trig_retention_backup ? " with retention backup" : "");
TEST_ESP_OK(gdma_new_axi_channel(&chan_alloc_config, &tx_chan, &rx_chan));
bool lli_in_ext_mem = false;
@@ -424,12 +426,17 @@ static void test_gdma_m2m_mode(bool trig_retention_backup)
#endif // SOC_HAS(AXI_GDMA)
#if SOC_HAS(LP_AHB_GDMA)
TEST_ESP_OK(gdma_new_lp_ahb_channel(&chan_alloc_config, &tx_chan, &rx_chan));
if (esp_efuse_is_flash_encryption_enabled() && !GDMA_TEST_LP_AHB_BURST_PSRAM_SUPPORTED) {
TEST_IGNORE_MESSAGE("Skip LP-AHB-GDMA GDMA M2M Mode under flash encryption");
} else {
printf("Testing GDMA M2M Mode by LP-AHB GDMA%s\n", trig_retention_backup ? " with retention backup" : "");
TEST_ESP_OK(gdma_new_lp_ahb_channel(&chan_alloc_config, &tx_chan, &rx_chan));
test_gdma_m2m_transaction(tx_chan, rx_chan, false, trig_retention_backup);
test_gdma_m2m_transaction(tx_chan, rx_chan, false, trig_retention_backup);
TEST_ESP_OK(gdma_del_channel(tx_chan));
TEST_ESP_OK(gdma_del_channel(rx_chan));
TEST_ESP_OK(gdma_del_channel(tx_chan));
TEST_ESP_OK(gdma_del_channel(rx_chan));
}
#endif // SOC_HAS(LP_AHB_GDMA)
}
@@ -839,13 +846,19 @@ TEST_CASE("GDMA memory copy SRAM->PSRAM->SRAM", "[GDMA][M2M]")
#endif // SOC_HAS(AXI_GDMA)
#if SOC_HAS(LP_AHB_GDMA)
printf("Testing LP-AHB-GDMA memory copy SRAM->PSRAM->SRAM\n");
TEST_ESP_OK(gdma_new_lp_ahb_channel(&chan_alloc_config, &tx_chan, &rx_chan));
#if GDMA_LL_GET(LP_AHB_PSRAM_CAPABLE)
if (esp_efuse_is_flash_encryption_enabled() && !GDMA_TEST_LP_AHB_BURST_PSRAM_SUPPORTED) {
TEST_IGNORE_MESSAGE("Skipping LP-AHB-GDMA SRAM->PSRAM->SRAM under flash encryption");
} else {
printf("Testing LP-AHB-GDMA memory copy SRAM->PSRAM->SRAM\n");
TEST_ESP_OK(gdma_new_lp_ahb_channel(&chan_alloc_config, &tx_chan, &rx_chan));
test_gdma_memcpy_from_to_psram(tx_chan, rx_chan);
test_gdma_memcpy_from_to_psram(tx_chan, rx_chan);
TEST_ESP_OK(gdma_del_channel(tx_chan));
TEST_ESP_OK(gdma_del_channel(rx_chan));
TEST_ESP_OK(gdma_del_channel(tx_chan));
TEST_ESP_OK(gdma_del_channel(rx_chan));
}
#endif // GDMA_LL_GET(LP_AHB_PSRAM_CAPABLE)
#endif // SOC_HAS(LP_AHB_GDMA)
}
#endif // SOC_SPIRAM_SUPPORTED

12
components/esp_driver_dma/test_apps/dma/pytest_dma.py
View File

@@ -71,7 +71,17 @@ def test_dma_weighted_arbitration(dut: Dut) -> None:
],
indirect=True,
)
@idf_parametrize('target', ['esp32p4', 'esp32c5'], indirect=['target'])
@idf_parametrize(
'target',
soc_filtered_targets(
'SOC_GDMA_SUPPORTED == 1 and '
'SOC_PSRAM_DMA_CAPABLE == 1 and '
'SOC_FLASH_ENC_SUPPORTED == 1 and '
'IDF_TARGET not in ["esp32s3"]'
),
indirect=['target'],
)
@pytest.mark.temp_skip_ci(targets=['esp32h4', 'esp32c61'], reason='no runner yet')
def test_dma_flash_encryption(dut: Dut) -> None:
dut.run_all_single_board_cases()

5
components/esp_driver_dma/test_apps/dma2d/pytest_dma2d.py
View File

@@ -41,7 +41,8 @@ def test_dma2d_esp32p4_rev1(dut: Dut) -> None:
],
indirect=True,
)
@idf_parametrize('target', soc_filtered_targets('SOC_DMA2D_SUPPORTED == 1'), indirect=['target'])
@pytest.mark.temp_skip_ci(targets=['esp32s31'], reason='TODO: IDFCI-10377 no runner yet')
@idf_parametrize(
'target', soc_filtered_targets('SOC_DMA2D_SUPPORTED == 1 and SOC_FLASH_ENC_SUPPORTED == 1'), indirect=['target']
)
def test_dma2d_flash_encryption(dut: Dut) -> None:
dut.run_all_single_board_cases()

35
components/esp_driver_parlio/test_apps/parlio/conftest.py
View File

@@ -1,35 +0,0 @@
# SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
# SPDX-License-Identifier: Apache-2.0
import pytest
from _pytest.fixtures import FixtureRequest
from _pytest.monkeypatch import MonkeyPatch
from pytest_embedded_idf.serial import IdfSerial
# This is a custom IdfSerial class to support custom functionality
# which is required only for this test
class EfuseFlashEncSerial(IdfSerial):
@IdfSerial.use_esptool()
def write_flash_no_enc(self) -> None:
self.app.flash_settings['encrypt'] = False
flash_files = []
for file in self.app.flash_files:
# Set encrypted flag to false for each file.
flash_files.append(file._replace(encrypted=False))
# Replace the original tuple with modified tuple with all the files marked as unencrypted.
self.app.flash_files = tuple(flash_files)
# Now flash the files
self.flash()
@pytest.fixture(scope='module')
def monkeypatch_module(request: FixtureRequest) -> MonkeyPatch:
mp = MonkeyPatch()
request.addfinalizer(mp.undo)
return mp
@pytest.fixture(scope='module', autouse=True)
def replace_dut_class(monkeypatch_module: MonkeyPatch) -> None:
monkeypatch_module.setattr('pytest_embedded_idf.IdfSerial', EfuseFlashEncSerial)

7
components/esp_driver_parlio/test_apps/parlio/partitions_efuse_emul.csv
View File

@@ -1,7 +0,0 @@
# Name, Type, SubType, Offset, Size, Flags
bootloader, bootloader, primary, N/A, N/A,
partition_table, partition_table, primary, N/A, N/A,
nvs, data, nvs, , 0x4000,
phy_init, data, phy, , 0x1000,
emul_efuse, data, efuse, , 0x2000,
factory, app, factory, , 1M,
1 # Name Type SubType Offset Size Flags
2 bootloader bootloader primary N/A N/A
3 partition_table partition_table primary N/A N/A
4 nvs data nvs 0x4000
5 phy_init data phy 0x1000
6 emul_efuse data efuse 0x2000
7 factory app factory 1M

22
components/esp_driver_parlio/test_apps/parlio/pytest_parlio_unity.py
View File

@@ -36,27 +36,21 @@ def test_parlio(dut: Dut) -> None:
dut.run_all_single_board_cases()
@pytest.mark.generic
@pytest.mark.flash_encryption
@pytest.mark.parametrize(
'config, skip_autoflash',
'config',
[
('virt_flash_enc', 'y'),
'flash_enc',
],
indirect=True,
)
@idf_parametrize(
'target', soc_filtered_targets('SOC_PARLIO_SUPPORTED == 1 and SOC_FLASH_ENC_SUPPORTED == 1'), indirect=['target']
'target',
soc_filtered_targets('SOC_PARLIO_SUPPORTED == 1 and SOC_PSRAM_DMA_CAPABLE == 1 and SOC_FLASH_ENC_SUPPORTED == 1'),
indirect=['target'],
)
def test_parlio_with_virt_flash_enc(dut: Dut) -> None:
print(' - Erase flash')
dut.serial.erase_flash()
print(' - Start app (flash partition_table and app)')
dut.serial.write_flash_no_enc()
dut.expect('Loading virtual efuse blocks from real efuses')
dut.expect('Checking flash encryption...')
dut.expect('Generating new flash encryption key...')
@pytest.mark.temp_skip_ci(targets=['esp32h4'], reason='no runner yet')
def test_parlio_with_flash_encryption(dut: Dut) -> None:
dut.run_all_single_board_cases(group='!release_only')

9
components/esp_driver_parlio/test_apps/parlio/sdkconfig.ci.flash_enc Normal file
View File

@@ -0,0 +1,9 @@
CONFIG_PARTITION_TABLE_OFFSET=0x9000
CONFIG_SECURE_FLASH_ENC_ENABLED=y
CONFIG_SECURE_FLASH_ENCRYPTION_MODE_DEVELOPMENT=y
CONFIG_SECURE_BOOT_ALLOW_ROM_BASIC=y
CONFIG_SECURE_BOOT_ALLOW_JTAG=y
CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_ENC=y
CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_DEC=y
CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_CACHE=y
CONFIG_SECURE_FLASH_REQUIRE_ALREADY_ENABLED=y

12
components/esp_driver_parlio/test_apps/parlio/sdkconfig.ci.virt_flash_enc
View File

@@ -1,12 +0,0 @@
# FLASH_ENCRYPTION with EFUSE_VIRTUAL_KEEP_IN_FLASH
CONFIG_PARTITION_TABLE_OFFSET=0xC000
CONFIG_PARTITION_TABLE_CUSTOM=y
CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions_efuse_emul.csv"
CONFIG_SECURE_FLASH_ENC_ENABLED=y
# Virtual eFuse mode is enough for driver behaviour test.
# Real encryption tests are guaranteed by DMA tests
CONFIG_EFUSE_VIRTUAL=y
CONFIG_EFUSE_VIRTUAL_KEEP_IN_FLASH=y

5
components/esp_driver_ppa/test_apps/pytest_ppa.py
View File

@@ -41,7 +41,8 @@ def test_ppa_esp32p4_rev1(dut: Dut) -> None:
],
indirect=True,
)
@idf_parametrize('target', soc_filtered_targets('SOC_PPA_SUPPORTED == 1'), indirect=['target'])
@pytest.mark.temp_skip_ci(targets=['esp32s31'], reason='TODO: IDFCI-10377 no runner yet')
@idf_parametrize(
'target', soc_filtered_targets('SOC_PPA_SUPPORTED == 1 and SOC_FLASH_ENC_SUPPORTED == 1'), indirect=['target']
)
def test_ppa_flash_encryption(dut: Dut) -> None:
dut.run_all_single_board_cases()

35
components/esp_driver_rmt/test_apps/rmt/conftest.py
View File

@@ -1,35 +0,0 @@
# SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
# SPDX-License-Identifier: Apache-2.0
import pytest
from _pytest.fixtures import FixtureRequest
from _pytest.monkeypatch import MonkeyPatch
from pytest_embedded_idf.serial import IdfSerial
# This is a custom IdfSerial class to support custom functionality
# which is required only for this test
class EfuseFlashEncSerial(IdfSerial):
@IdfSerial.use_esptool()
def write_flash_no_enc(self) -> None:
self.app.flash_settings['encrypt'] = False
flash_files = []
for file in self.app.flash_files:
# Set encrypted flag to false for each file.
flash_files.append(file._replace(encrypted=False))
# Replace the original tuple with modified tuple with all the files marked as unencrypted.
self.app.flash_files = tuple(flash_files)
# Now flash the files
self.flash()
@pytest.fixture(scope='module')
def monkeypatch_module(request: FixtureRequest) -> MonkeyPatch:
mp = MonkeyPatch()
request.addfinalizer(mp.undo)
return mp
@pytest.fixture(scope='module', autouse=True)
def replace_dut_class(monkeypatch_module: MonkeyPatch) -> None:
monkeypatch_module.setattr('pytest_embedded_idf.IdfSerial', EfuseFlashEncSerial)

7
components/esp_driver_rmt/test_apps/rmt/partitions_efuse_emul.csv
View File

@@ -1,7 +0,0 @@
# Name, Type, SubType, Offset, Size, Flags
bootloader, bootloader, primary, N/A, N/A,
partition_table, partition_table, primary, N/A, N/A,
nvs, data, nvs, , 0x4000,
phy_init, data, phy, , 0x1000,
emul_efuse, data, efuse, , 0x2000,
factory, app, factory, , 1M,
1 # Name Type SubType Offset Size Flags
2 bootloader bootloader primary N/A N/A
3 partition_table partition_table primary N/A N/A
4 nvs data nvs 0x4000
5 phy_init data phy 0x1000
6 emul_efuse data efuse 0x2000
7 factory app factory 1M

60
components/esp_driver_rmt/test_apps/rmt/pytest_rmt.py
View File

@@ -24,32 +24,6 @@ def test_rmt(dut: Dut) -> None:
dut.run_all_single_board_cases()
@pytest.mark.generic
@pytest.mark.parametrize(
'config, skip_autoflash',
[
('virt_flash_enc', 'y'),
],
indirect=True,
)
@idf_parametrize(
'target',
soc_filtered_targets('SOC_RMT_SUPPORTED == 1 and SOC_FLASH_ENC_SUPPORTED == 1 and IDF_TARGET not in ["esp32s3"]'),
indirect=['target'],
)
def test_rmt_with_virt_flash_enc(dut: Dut) -> None:
print(' - Erase flash')
dut.serial.erase_flash()
print(' - Start app (flash partition_table and app)')
dut.serial.write_flash_no_enc()
dut.expect('Loading virtual efuse blocks from real efuses')
dut.expect('Checking flash encryption...')
dut.expect('Generating new flash encryption key...')
dut.run_all_single_board_cases()
@pytest.mark.generic
@pytest.mark.parametrize(
'config',
@@ -91,23 +65,31 @@ def test_rmt_psram(dut: Dut) -> None:
dut.run_all_single_board_cases()
@pytest.mark.octal_psram
@pytest.mark.flash_encryption_f4r8
@pytest.mark.parametrize(
'config, skip_autoflash',
'config',
[
('virt_flash_enc', 'y'),
'flash_enc',
],
indirect=True,
)
@idf_parametrize('target', ['esp32s3'], indirect=['target'])
def test_rmt_psram_with_virt_flash_enc(dut: Dut) -> None:
print(' - Erase flash')
dut.serial.erase_flash()
print(' - Start app (flash partition_table and app)')
dut.serial.write_flash_no_enc()
dut.expect('Loading virtual efuse blocks from real efuses')
dut.expect('Checking flash encryption...')
dut.expect('Generating new flash encryption key...')
def test_rmt_with_flash_encryption_esp32s3_f4r8(dut: Dut) -> None:
dut.run_all_single_board_cases()
@pytest.mark.flash_encryption
@pytest.mark.parametrize(
'config',
[
'flash_enc',
],
indirect=True,
)
@idf_parametrize(
'target',
soc_filtered_targets('SOC_RMT_SUPPORT_DMA == 1 and SOC_FLASH_ENC_SUPPORTED == 1 and IDF_TARGET not in ["esp32s3"]'),
indirect=['target'],
)
def test_rmt_with_flash_encryption(dut: Dut) -> None:
dut.run_all_single_board_cases()

9
components/esp_driver_rmt/test_apps/rmt/sdkconfig.ci.flash_enc Normal file
View File

@@ -0,0 +1,9 @@
CONFIG_PARTITION_TABLE_OFFSET=0x9000
CONFIG_SECURE_FLASH_ENC_ENABLED=y
CONFIG_SECURE_FLASH_ENCRYPTION_MODE_DEVELOPMENT=y
CONFIG_SECURE_BOOT_ALLOW_ROM_BASIC=y
CONFIG_SECURE_BOOT_ALLOW_JTAG=y
CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_ENC=y
CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_DEC=y
CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_CACHE=y
CONFIG_SECURE_FLASH_REQUIRE_ALREADY_ENABLED=y

12
components/esp_driver_rmt/test_apps/rmt/sdkconfig.ci.virt_flash_enc
View File

@@ -1,12 +0,0 @@
# FLASH_ENCRYPTION with EFUSE_VIRTUAL_KEEP_IN_FLASH
CONFIG_PARTITION_TABLE_OFFSET=0xC000
CONFIG_PARTITION_TABLE_CUSTOM=y
CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions_efuse_emul.csv"
CONFIG_SECURE_FLASH_ENC_ENABLED=y
# Virtual eFuse mode is enough for driver behaviour test.
# Real encryption tests are guaranteed by DMA tests
CONFIG_EFUSE_VIRTUAL=y
CONFIG_EFUSE_VIRTUAL_KEEP_IN_FLASH=y

2
components/esp_lcd/test_apps/.build-test-rules.yml
View File

@@ -58,4 +58,4 @@ components/esp_lcd/test_apps/spi_lcd:
- esp_driver_spi
disable:
- if: SOC_GPSPI_SUPPORTED != 1
- if: CONFIG_NAME == "virt_flash_enc" and SOC_FLASH_ENC_SUPPORTED != 1
- if: CONFIG_NAME == "flash_enc" and SOC_FLASH_ENC_SUPPORTED != 1

35
components/esp_lcd/test_apps/i80_lcd/conftest.py
View File

@@ -1,35 +0,0 @@
# SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
# SPDX-License-Identifier: Apache-2.0
import pytest
from _pytest.fixtures import FixtureRequest
from _pytest.monkeypatch import MonkeyPatch
from pytest_embedded_idf.serial import IdfSerial
# This is a custom IdfSerial class to support custom functionality
# which is required only for this test
class EfuseFlashEncSerial(IdfSerial):
@IdfSerial.use_esptool()
def write_flash_no_enc(self) -> None:
self.app.flash_settings['encrypt'] = False
flash_files = []
for file in self.app.flash_files:
# Set encrypted flag to false for each file.
flash_files.append(file._replace(encrypted=False))
# Replace the original tuple with modified tuple with all the files marked as unencrypted.
self.app.flash_files = tuple(flash_files)
# Now flash the files
self.flash()
@pytest.fixture(scope='module')
def monkeypatch_module(request: FixtureRequest) -> MonkeyPatch:
mp = MonkeyPatch()
request.addfinalizer(mp.undo)
return mp
@pytest.fixture(scope='module', autouse=True)
def replace_dut_class(monkeypatch_module: MonkeyPatch) -> None:
monkeypatch_module.setattr('pytest_embedded_idf.IdfSerial', EfuseFlashEncSerial)

7
components/esp_lcd/test_apps/i80_lcd/partitions_efuse_emul.csv
View File

@@ -1,7 +0,0 @@
# Name, Type, SubType, Offset, Size, Flags
bootloader, bootloader, primary, N/A, N/A,
partition_table, partition_table, primary, N/A, N/A,
nvs, data, nvs, , 0x4000,
phy_init, data, phy, , 0x1000,
emul_efuse, data, efuse, , 0x2000,
factory, app, factory, , 1M,
1 # Name Type SubType Offset Size Flags
2 bootloader bootloader primary N/A N/A
3 partition_table partition_table primary N/A N/A
4 nvs data nvs 0x4000
5 phy_init data phy 0x1000
6 emul_efuse data efuse 0x2000
7 factory app factory 1M

37
components/esp_lcd/test_apps/i80_lcd/pytest_i80_lcd.py
View File

@@ -19,27 +19,36 @@ def test_i80_lcd(dut: Dut) -> None:
dut.run_all_single_board_cases()
@pytest.mark.generic
@pytest.mark.flash_encryption_f4r8
@pytest.mark.parametrize(
'config, skip_autoflash',
'config',
[
('virt_flash_enc', 'y'),
'flash_enc',
],
indirect=True,
)
@idf_parametrize('target', ['esp32s3'], indirect=['target'])
def test_i80_lcd_with_flash_encryption_esp32s3_f4r8(dut: Dut) -> None:
dut.run_all_single_board_cases()
@pytest.mark.flash_encryption
@pytest.mark.parametrize(
'config',
[
'flash_enc',
],
indirect=True,
)
@idf_parametrize(
'target',
soc_filtered_targets('SOC_LCD_I80_SUPPORTED == 1 and SOC_FLASH_ENC_SUPPORTED == 1'),
soc_filtered_targets(
'SOC_LCD_I80_SUPPORTED == 1 and '
'SOC_PSRAM_DMA_CAPABLE == 1 and '
'SOC_FLASH_ENC_SUPPORTED == 1 and '
'IDF_TARGET not in ["esp32s3"]'
),
indirect=['target'],
)
def test_i80_lcd_with_virt_flash_enc(dut: Dut) -> None:
print(' - Erase flash')
dut.serial.erase_flash()
print(' - Start app (flash partition_table and app)')
dut.serial.write_flash_no_enc()
dut.expect('Loading virtual efuse blocks from real efuses')
dut.expect('Checking flash encryption...')
dut.expect('Generating new flash encryption key...')
def test_i80_lcd_with_flash_encryption(dut: Dut) -> None:
dut.run_all_single_board_cases()

9
components/esp_lcd/test_apps/i80_lcd/sdkconfig.ci.flash_enc Normal file
View File

@@ -0,0 +1,9 @@
CONFIG_PARTITION_TABLE_OFFSET=0x9000
CONFIG_SECURE_FLASH_ENC_ENABLED=y
CONFIG_SECURE_FLASH_ENCRYPTION_MODE_DEVELOPMENT=y
CONFIG_SECURE_BOOT_ALLOW_ROM_BASIC=y
CONFIG_SECURE_BOOT_ALLOW_JTAG=y
CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_ENC=y
CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_DEC=y
CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_CACHE=y
CONFIG_SECURE_FLASH_REQUIRE_ALREADY_ENABLED=y

12
components/esp_lcd/test_apps/i80_lcd/sdkconfig.ci.virt_flash_enc
View File

@@ -1,12 +0,0 @@
# FLASH_ENCRYPTION with EFUSE_VIRTUAL_KEEP_IN_FLASH
CONFIG_PARTITION_TABLE_OFFSET=0xC000
CONFIG_PARTITION_TABLE_CUSTOM=y
CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions_efuse_emul.csv"
CONFIG_SECURE_FLASH_ENC_ENABLED=y
# Virtual eFuse mode is enough for driver behaviour test.
# Real encryption tests are guaranteed by DMA tests
CONFIG_EFUSE_VIRTUAL=y
CONFIG_EFUSE_VIRTUAL_KEEP_IN_FLASH=y

35
components/esp_lcd/test_apps/mipi_dsi_lcd/conftest.py
View File

@@ -1,35 +0,0 @@
# SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
# SPDX-License-Identifier: Apache-2.0
import pytest
from _pytest.fixtures import FixtureRequest
from _pytest.monkeypatch import MonkeyPatch
from pytest_embedded_idf.serial import IdfSerial
# This is a custom IdfSerial class to support custom functionality
# which is required only for this test
class EfuseFlashEncSerial(IdfSerial):
@IdfSerial.use_esptool()
def write_flash_no_enc(self) -> None:
self.app.flash_settings['encrypt'] = False
flash_files = []
for file in self.app.flash_files:
# Set encrypted flag to false for each file.
flash_files.append(file._replace(encrypted=False))
# Replace the original tuple with modified tuple with all the files marked as unencrypted.
self.app.flash_files = tuple(flash_files)
# Now flash the files
self.flash()
@pytest.fixture(scope='module')
def monkeypatch_module(request: FixtureRequest) -> MonkeyPatch:
mp = MonkeyPatch()
request.addfinalizer(mp.undo)
return mp
@pytest.fixture(scope='module', autouse=True)
def replace_dut_class(monkeypatch_module: MonkeyPatch) -> None:
monkeypatch_module.setattr('pytest_embedded_idf.IdfSerial', EfuseFlashEncSerial)

7
components/esp_lcd/test_apps/mipi_dsi_lcd/partitions_efuse_emul.csv
View File

@@ -1,7 +0,0 @@
# Name, Type, SubType, Offset, Size, Flags
bootloader, bootloader, primary, N/A, N/A,
partition_table, partition_table, primary, N/A, N/A,
nvs, data, nvs, , 0x4000,
phy_init, data, phy, , 0x1000,
emul_efuse, data, efuse, , 0x2000,
factory, app, factory, , 1M,
1 # Name Type SubType Offset Size Flags
2 bootloader bootloader primary N/A N/A
3 partition_table partition_table primary N/A N/A
4 nvs data nvs 0x4000
5 phy_init data phy 0x1000
6 emul_efuse data efuse 0x2000
7 factory app factory 1M

24
components/esp_lcd/test_apps/mipi_dsi_lcd/pytest_mipi_dsi_lcd.py
View File

@@ -3,6 +3,7 @@
import pytest
from pytest_embedded import Dut
from pytest_embedded_idf.utils import idf_parametrize
from pytest_embedded_idf.utils import soc_filtered_targets
@pytest.mark.generic
@@ -20,26 +21,21 @@ def test_dsi_lcd(dut: Dut) -> None:
dut.run_all_single_board_cases()
@pytest.mark.generic
@pytest.mark.flash_encryption
@pytest.mark.parametrize(
'config, skip_autoflash',
'config',
[
('virt_flash_enc', 'y'),
'flash_enc',
],
indirect=True,
)
@idf_parametrize('target', ['esp32p4'], indirect=['target'])
@idf_parametrize(
'target',
soc_filtered_targets('SOC_MIPI_DSI_SUPPORTED == 1 and SOC_FLASH_ENC_SUPPORTED == 1'),
indirect=['target'],
)
@pytest.mark.temp_skip_ci(targets=['esp32p4'], reason='no runner')
def test_dsi_lcd_with_virt_flash_enc(dut: Dut) -> None:
print(' - Erase flash')
dut.serial.erase_flash()
print(' - Start app (flash partition_table and app)')
dut.serial.write_flash_no_enc()
dut.expect('Loading virtual efuse blocks from real efuses')
dut.expect('Checking flash encryption...')
dut.expect('Generating new flash encryption key...')
def test_dsi_lcd_with_flash_encryption(dut: Dut) -> None:
dut.run_all_single_board_cases()

9
components/esp_lcd/test_apps/mipi_dsi_lcd/sdkconfig.ci.flash_enc Normal file
View File

@@ -0,0 +1,9 @@
CONFIG_PARTITION_TABLE_OFFSET=0x9000
CONFIG_SECURE_FLASH_ENC_ENABLED=y
CONFIG_SECURE_FLASH_ENCRYPTION_MODE_DEVELOPMENT=y
CONFIG_SECURE_BOOT_ALLOW_ROM_BASIC=y
CONFIG_SECURE_BOOT_ALLOW_JTAG=y
CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_ENC=y
CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_DEC=y
CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_CACHE=y
CONFIG_SECURE_FLASH_REQUIRE_ALREADY_ENABLED=y

12
components/esp_lcd/test_apps/mipi_dsi_lcd/sdkconfig.ci.virt_flash_enc
View File

@@ -1,12 +0,0 @@
# FLASH_ENCRYPTION with EFUSE_VIRTUAL_KEEP_IN_FLASH
CONFIG_PARTITION_TABLE_OFFSET=0xC000
CONFIG_PARTITION_TABLE_CUSTOM=y
CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions_efuse_emul.csv"
CONFIG_SECURE_FLASH_ENC_ENABLED=y
# Virtual eFuse mode is enough for driver behaviour test.
# Real encryption tests are guaranteed by DMA tests
CONFIG_EFUSE_VIRTUAL=y
CONFIG_EFUSE_VIRTUAL_KEEP_IN_FLASH=y

35
components/esp_lcd/test_apps/parlio_lcd/conftest.py
View File

@@ -1,35 +0,0 @@
# SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
# SPDX-License-Identifier: Apache-2.0
import pytest
from _pytest.fixtures import FixtureRequest
from _pytest.monkeypatch import MonkeyPatch
from pytest_embedded_idf.serial import IdfSerial
# This is a custom IdfSerial class to support custom functionality
# which is required only for this test
class EfuseFlashEncSerial(IdfSerial):
@IdfSerial.use_esptool()
def write_flash_no_enc(self) -> None:
self.app.flash_settings['encrypt'] = False
flash_files = []
for file in self.app.flash_files:
# Set encrypted flag to false for each file.
flash_files.append(file._replace(encrypted=False))
# Replace the original tuple with modified tuple with all the files marked as unencrypted.
self.app.flash_files = tuple(flash_files)
# Now flash the files
self.flash()
@pytest.fixture(scope='module')
def monkeypatch_module(request: FixtureRequest) -> MonkeyPatch:
mp = MonkeyPatch()
request.addfinalizer(mp.undo)
return mp
@pytest.fixture(scope='module', autouse=True)
def replace_dut_class(monkeypatch_module: MonkeyPatch) -> None:
monkeypatch_module.setattr('pytest_embedded_idf.IdfSerial', EfuseFlashEncSerial)

7
components/esp_lcd/test_apps/parlio_lcd/partitions_efuse_emul.csv
View File

@@ -1,7 +0,0 @@
# Name, Type, SubType, Offset, Size, Flags
bootloader, bootloader, primary, N/A, N/A,
partition_table, partition_table, primary, N/A, N/A,
nvs, data, nvs, , 0x4000,
phy_init, data, phy, , 0x1000,
emul_efuse, data, efuse, , 0x2000,
factory, app, factory, , 1M,
1 # Name Type SubType Offset Size Flags
2 bootloader bootloader primary N/A N/A
3 partition_table partition_table primary N/A N/A
4 nvs data nvs 0x4000
5 phy_init data phy 0x1000
6 emul_efuse data efuse 0x2000
7 factory app factory 1M

22
components/esp_lcd/test_apps/parlio_lcd/pytest_parlio_lcd.py
View File

@@ -19,27 +19,21 @@ def test_parlio_lcd(dut: Dut) -> None:
dut.run_all_single_board_cases()
@pytest.mark.generic
@pytest.mark.flash_encryption
@pytest.mark.parametrize(
'config, skip_autoflash',
'config',
[
('virt_flash_enc', 'y'),
'flash_enc',
],
indirect=True,
)
@idf_parametrize(
'target',
soc_filtered_targets('SOC_PARLIO_LCD_SUPPORTED == 1 and SOC_FLASH_ENC_SUPPORTED == 1'),
soc_filtered_targets(
'SOC_PARLIO_LCD_SUPPORTED == 1 and SOC_PSRAM_DMA_CAPABLE == 1 and SOC_FLASH_ENC_SUPPORTED == 1'
),
indirect=['target'],
)
def test_parlio_lcd_with_virt_flash_enc(dut: Dut) -> None:
print(' - Erase flash')
dut.serial.erase_flash()
print(' - Start app (flash partition_table and app)')
dut.serial.write_flash_no_enc()
dut.expect('Loading virtual efuse blocks from real efuses')
dut.expect('Checking flash encryption...')
dut.expect('Generating new flash encryption key...')
@pytest.mark.temp_skip_ci(targets=['esp32h4'], reason='no runner yet')
def test_parlio_lcd_with_flash_encryption(dut: Dut) -> None:
dut.run_all_single_board_cases()

9
components/esp_lcd/test_apps/parlio_lcd/sdkconfig.ci.flash_enc Normal file
View File

@@ -0,0 +1,9 @@
CONFIG_PARTITION_TABLE_OFFSET=0x9000
CONFIG_SECURE_FLASH_ENC_ENABLED=y
CONFIG_SECURE_FLASH_ENCRYPTION_MODE_DEVELOPMENT=y
CONFIG_SECURE_BOOT_ALLOW_ROM_BASIC=y
CONFIG_SECURE_BOOT_ALLOW_JTAG=y
CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_ENC=y
CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_DEC=y
CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_CACHE=y
CONFIG_SECURE_FLASH_REQUIRE_ALREADY_ENABLED=y

12
components/esp_lcd/test_apps/parlio_lcd/sdkconfig.ci.virt_flash_enc
View File

@@ -1,12 +0,0 @@
# FLASH_ENCRYPTION with EFUSE_VIRTUAL_KEEP_IN_FLASH
CONFIG_PARTITION_TABLE_OFFSET=0xC000
CONFIG_PARTITION_TABLE_CUSTOM=y
CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions_efuse_emul.csv"
CONFIG_SECURE_FLASH_ENC_ENABLED=y
# Virtual eFuse mode is enough for driver behaviour test.
# Real encryption tests are guaranteed by DMA tests
CONFIG_EFUSE_VIRTUAL=y
CONFIG_EFUSE_VIRTUAL_KEEP_IN_FLASH=y

35
components/esp_lcd/test_apps/rgb_lcd/conftest.py
View File

@@ -1,35 +0,0 @@
# SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
# SPDX-License-Identifier: Apache-2.0
import pytest
from _pytest.fixtures import FixtureRequest
from _pytest.monkeypatch import MonkeyPatch
from pytest_embedded_idf.serial import IdfSerial
# This is a custom IdfSerial class to support custom functionality
# which is required only for this test
class EfuseFlashEncSerial(IdfSerial):
@IdfSerial.use_esptool()
def write_flash_no_enc(self) -> None:
self.app.flash_settings['encrypt'] = False
flash_files = []
for file in self.app.flash_files:
# Set encrypted flag to false for each file.
flash_files.append(file._replace(encrypted=False))
# Replace the original tuple with modified tuple with all the files marked as unencrypted.
self.app.flash_files = tuple(flash_files)
# Now flash the files
self.flash()
@pytest.fixture(scope='module')
def monkeypatch_module(request: FixtureRequest) -> MonkeyPatch:
mp = MonkeyPatch()
request.addfinalizer(mp.undo)
return mp
@pytest.fixture(scope='module', autouse=True)
def replace_dut_class(monkeypatch_module: MonkeyPatch) -> None:
monkeypatch_module.setattr('pytest_embedded_idf.IdfSerial', EfuseFlashEncSerial)

4
components/esp_lcd/test_apps/rgb_lcd/main/test_rgb_panel.c
View File

@@ -219,6 +219,10 @@ TEST_CASE("lcd_rgb_panel_update_pclk", "[lcd]")
TEST_CASE("lcd_rgb_panel_restart", "[lcd]")
{
#if CONFIG_IDF_TARGET_ESP32S31 // IDF-15960
TEST_IGNORE_MESSAGE("Known issue: lcd_rgb_panel_restart underruns on flash-encrypted runners");
#endif // CONFIG_IDF_TARGET_ESP32S31
uint8_t *img = malloc(TEST_IMG_SIZE);
TEST_ASSERT_NOT_NULL(img);

7
components/esp_lcd/test_apps/rgb_lcd/partitions_efuse_emul.csv
View File

@@ -1,7 +0,0 @@
# Name, Type, SubType, Offset, Size, Flags
bootloader, bootloader, primary, N/A, N/A,
partition_table, partition_table, primary, N/A, N/A,
nvs, data, nvs, , 0x4000,
phy_init, data, phy, , 0x1000,
emul_efuse, data, efuse, , 0x2000,
factory, app, factory, , 1M,
1 # Name Type SubType Offset Size Flags
2 bootloader bootloader primary N/A N/A
3 partition_table partition_table primary N/A N/A
4 nvs data nvs 0x4000
5 phy_init data phy 0x1000
6 emul_efuse data efuse 0x2000
7 factory app factory 1M

62
components/esp_lcd/test_apps/rgb_lcd/pytest_rgb_lcd.py
View File

@@ -20,28 +20,6 @@ def test_rgb_lcd_esp32s3(dut: Dut) -> None:
dut.run_all_single_board_cases()
@pytest.mark.octal_psram
@pytest.mark.parametrize(
'config, skip_autoflash',
[
('virt_flash_enc', 'y'),
],
indirect=True,
)
@idf_parametrize('target', ['esp32s3'], indirect=['target'])
def test_rgb_lcd_esp32s3_with_virt_flash_enc(dut: Dut) -> None:
print(' - Erase flash')
dut.serial.erase_flash()
print(' - Start app (flash partition_table and app)')
dut.serial.write_flash_no_enc()
dut.expect('Loading virtual efuse blocks from real efuses')
dut.expect('Checking flash encryption...')
dut.expect('Generating new flash encryption key...')
dut.run_all_single_board_cases()
@pytest.mark.generic
@pytest.mark.parametrize(
'config',
@@ -51,32 +29,42 @@ def test_rgb_lcd_esp32s3_with_virt_flash_enc(dut: Dut) -> None:
],
indirect=True,
)
@idf_parametrize('target', ['esp32p4', 'esp32s31'], indirect=['target'])
@idf_parametrize(
'target',
soc_filtered_targets('SOC_LCD_RGB_SUPPORTED == 1 and IDF_TARGET not in ["esp32s3"]'),
indirect=['target'],
)
def test_rgb_lcd(dut: Dut) -> None:
dut.run_all_single_board_cases()
@pytest.mark.generic
@pytest.mark.flash_encryption_f4r8
@pytest.mark.parametrize(
'config, skip_autoflash',
'config',
[
('virt_flash_enc', 'y'),
'flash_enc',
],
indirect=True,
)
@idf_parametrize('target', ['esp32s3'], indirect=['target'])
def test_rgb_lcd_with_flash_encryption_esp32s3_f4r8(dut: Dut) -> None:
dut.run_all_single_board_cases()
@pytest.mark.flash_encryption
@pytest.mark.parametrize(
'config',
[
'flash_enc',
],
indirect=True,
)
@idf_parametrize(
'target',
soc_filtered_targets('IDF_TARGET in ["esp32p4", "esp32s31"] and SOC_FLASH_ENC_SUPPORTED == 1'),
soc_filtered_targets(
'SOC_LCD_RGB_SUPPORTED == 1 and SOC_FLASH_ENC_SUPPORTED == 1 and IDF_TARGET not in ["esp32s3"]'
),
indirect=['target'],
)
def test_rgb_lcd_with_virt_flash_enc(dut: Dut) -> None:
print(' - Erase flash')
dut.serial.erase_flash()
print(' - Start app (flash partition_table and app)')
dut.serial.write_flash_no_enc()
dut.expect('Loading virtual efuse blocks from real efuses')
dut.expect('Checking flash encryption...')
dut.expect('Generating new flash encryption key...')
def test_rgb_lcd_with_flash_encryption(dut: Dut) -> None:
dut.run_all_single_board_cases()

9
components/esp_lcd/test_apps/rgb_lcd/sdkconfig.ci.flash_enc Normal file
View File

@@ -0,0 +1,9 @@
CONFIG_PARTITION_TABLE_OFFSET=0x9000
CONFIG_SECURE_FLASH_ENC_ENABLED=y
CONFIG_SECURE_FLASH_ENCRYPTION_MODE_DEVELOPMENT=y
CONFIG_SECURE_BOOT_ALLOW_ROM_BASIC=y
CONFIG_SECURE_BOOT_ALLOW_JTAG=y
CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_ENC=y
CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_DEC=y
CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_CACHE=y
CONFIG_SECURE_FLASH_REQUIRE_ALREADY_ENABLED=y

12
components/esp_lcd/test_apps/rgb_lcd/sdkconfig.ci.virt_flash_enc
View File

@@ -1,12 +0,0 @@
# FLASH_ENCRYPTION with EFUSE_VIRTUAL_KEEP_IN_FLASH
CONFIG_PARTITION_TABLE_OFFSET=0xC000
CONFIG_PARTITION_TABLE_CUSTOM=y
CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions_efuse_emul.csv"
CONFIG_SECURE_FLASH_ENC_ENABLED=y
# Virtual eFuse mode is enough for driver behaviour test.
# Real encryption tests are guaranteed by DMA tests
CONFIG_EFUSE_VIRTUAL=y
CONFIG_EFUSE_VIRTUAL_KEEP_IN_FLASH=y

35
components/esp_lcd/test_apps/spi_lcd/conftest.py
View File

@@ -1,35 +0,0 @@
# SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
# SPDX-License-Identifier: Apache-2.0
import pytest
from _pytest.fixtures import FixtureRequest
from _pytest.monkeypatch import MonkeyPatch
from pytest_embedded_idf.serial import IdfSerial
# This is a custom IdfSerial class to support custom functionality
# which is required only for this test
class EfuseFlashEncSerial(IdfSerial):
@IdfSerial.use_esptool()
def write_flash_no_enc(self) -> None:
self.app.flash_settings['encrypt'] = False
flash_files = []
for file in self.app.flash_files:
# Set encrypted flag to false for each file.
flash_files.append(file._replace(encrypted=False))
# Replace the original tuple with modified tuple with all the files marked as unencrypted.
self.app.flash_files = tuple(flash_files)
# Now flash the files
self.flash()
@pytest.fixture(scope='module')
def monkeypatch_module(request: FixtureRequest) -> MonkeyPatch:
mp = MonkeyPatch()
request.addfinalizer(mp.undo)
return mp
@pytest.fixture(scope='module', autouse=True)
def replace_dut_class(monkeypatch_module: MonkeyPatch) -> None:
monkeypatch_module.setattr('pytest_embedded_idf.IdfSerial', EfuseFlashEncSerial)

7
components/esp_lcd/test_apps/spi_lcd/partitions_efuse_emul.csv
View File

@@ -1,7 +0,0 @@
# Name, Type, SubType, Offset, Size, Flags
bootloader, bootloader, primary, N/A, N/A,
partition_table, partition_table, primary, N/A, N/A,
nvs, data, nvs, , 0x4000,
phy_init, data, phy, , 0x1000,
emul_efuse, data, efuse, , 0x2000,
factory, app, factory, , 1M,
1 # Name Type SubType Offset Size Flags
2 bootloader bootloader primary N/A N/A
3 partition_table partition_table primary N/A N/A
4 nvs data nvs 0x4000
5 phy_init data phy 0x1000
6 emul_efuse data efuse 0x2000
7 factory app factory 1M

33
components/esp_lcd/test_apps/spi_lcd/pytest_spi_lcd.py
View File

@@ -3,6 +3,7 @@
import pytest
from pytest_embedded import Dut
from pytest_embedded_idf.utils import idf_parametrize
from pytest_embedded_idf.utils import soc_filtered_targets
@pytest.mark.generic
@@ -18,23 +19,27 @@ def test_spi_lcd(dut: Dut) -> None:
dut.run_all_single_board_cases()
@pytest.mark.generic
@pytest.mark.flash_encryption
@pytest.mark.parametrize(
'config, skip_autoflash',
'config',
[
('virt_flash_enc', 'y'),
'flash_enc',
],
indirect=True,
)
@idf_parametrize('target', ['supported_targets'], indirect=['target'])
def test_spi_lcd_with_virt_flash_enc(dut: Dut) -> None:
print(' - Erase flash')
dut.serial.erase_flash()
print(' - Start app (flash partition_table and app)')
dut.serial.write_flash_no_enc()
dut.expect('Loading virtual efuse blocks from real efuses')
dut.expect('Checking flash encryption...')
dut.expect('Generating new flash encryption key...')
@idf_parametrize(
'target',
soc_filtered_targets('SOC_GPSPI_SUPPORTED == 1 and SOC_PSRAM_DMA_CAPABLE == 1 and SOC_FLASH_ENC_SUPPORTED == 1'),
indirect=['target'],
)
@pytest.mark.temp_skip_ci(
targets=[
'esp32c61',
'esp32h4',
'esp32s2',
'esp32s3',
],
reason='no runner yet',
)
def test_spi_lcd_with_flash_encryption(dut: Dut) -> None:
dut.run_all_single_board_cases()

9
components/esp_lcd/test_apps/spi_lcd/sdkconfig.ci.flash_enc Normal file
View File

@@ -0,0 +1,9 @@
CONFIG_PARTITION_TABLE_OFFSET=0x9000
CONFIG_SECURE_FLASH_ENC_ENABLED=y
CONFIG_SECURE_FLASH_ENCRYPTION_MODE_DEVELOPMENT=y
CONFIG_SECURE_BOOT_ALLOW_ROM_BASIC=y
CONFIG_SECURE_BOOT_ALLOW_JTAG=y
CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_ENC=y
CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_DEC=y
CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_CACHE=y
CONFIG_SECURE_FLASH_REQUIRE_ALREADY_ENABLED=y

12
components/esp_lcd/test_apps/spi_lcd/sdkconfig.ci.virt_flash_enc
View File

@@ -1,12 +0,0 @@
# FLASH_ENCRYPTION with EFUSE_VIRTUAL_KEEP_IN_FLASH
CONFIG_PARTITION_TABLE_OFFSET=0xC000
CONFIG_PARTITION_TABLE_CUSTOM=y
CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions_efuse_emul.csv"
CONFIG_SECURE_FLASH_ENC_ENABLED=y
# Virtual eFuse mode is enough for driver behaviour test.
# Real encryption tests are guaranteed by DMA tests
CONFIG_EFUSE_VIRTUAL=y
CONFIG_EFUSE_VIRTUAL_KEEP_IN_FLASH=y