From 8f1c206675dd40af26876d18792bfe5a1e2d5348 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Radim=20Karni=C5=A1?= Date: Wed, 22 Jan 2025 23:12:20 +0100 Subject: [PATCH] remove(beta_targets): Removed support for beta chip targets BREAKING CHANGE --- .gitlab-ci.yml | 3 - ci/download_flasher_stubs.py | 7 +- docs/en/migration-guide.rst | 28 +- espefuse/__init__.py | 14 +- espefuse/efuse/esp32c5beta3/__init__.py | 3 - .../esp32c5beta3/emulate_efuse_controller.py | 92 ---- espefuse/efuse/esp32c5beta3/fields.py | 464 ---------------- espefuse/efuse/esp32c5beta3/mem_definition.py | 165 ------ espefuse/efuse/esp32c5beta3/operations.py | 395 ------------- espefuse/efuse/esp32h2beta1/__init__.py | 3 - .../esp32h2beta1/emulate_efuse_controller.py | 92 ---- espefuse/efuse/esp32h2beta1/fields.py | 465 ---------------- espefuse/efuse/esp32h2beta1/mem_definition.py | 152 ----- espefuse/efuse/esp32h2beta1/operations.py | 405 -------------- espefuse/efuse/esp32s3beta2/__init__.py | 3 - .../esp32s3beta2/emulate_efuse_controller.py | 92 ---- espefuse/efuse/esp32s3beta2/fields.py | 489 ----------------- espefuse/efuse/esp32s3beta2/mem_definition.py | 167 ------ espefuse/efuse/esp32s3beta2/operations.py | 519 ------------------ espefuse/efuse_defs/esp32c5beta3.yaml | 104 ---- esptool/bin_image.py | 57 +- esptool/loader.py | 11 +- esptool/targets/__init__.py | 10 - esptool/targets/esp32c5beta3.py | 114 ---- esptool/targets/esp32c6beta.py | 25 - esptool/targets/esp32h2beta1.py | 172 ------ esptool/targets/esp32h2beta2.py | 29 - esptool/targets/esp32s3beta2.py | 23 - .../targets/stub_flasher/1/esp32c5beta3.json | 8 - .../targets/stub_flasher/1/esp32c6beta.json | 8 - .../targets/stub_flasher/1/esp32h2beta1.json | 8 - .../targets/stub_flasher/1/esp32h2beta2.json | 8 - .../targets/stub_flasher/1/esp32s3beta2.json | 8 - test/images/ram_helloworld/source/Makefile | 5 - test/test_espefuse.py | 39 +- 35 files changed, 44 insertions(+), 4143 deletions(-) delete mode 100644 espefuse/efuse/esp32c5beta3/__init__.py delete mode 100644 espefuse/efuse/esp32c5beta3/emulate_efuse_controller.py delete mode 100644 espefuse/efuse/esp32c5beta3/fields.py delete mode 100644 espefuse/efuse/esp32c5beta3/mem_definition.py delete mode 100644 espefuse/efuse/esp32c5beta3/operations.py delete mode 100644 espefuse/efuse/esp32h2beta1/__init__.py delete mode 100644 espefuse/efuse/esp32h2beta1/emulate_efuse_controller.py delete mode 100644 espefuse/efuse/esp32h2beta1/fields.py delete mode 100644 espefuse/efuse/esp32h2beta1/mem_definition.py delete mode 100644 espefuse/efuse/esp32h2beta1/operations.py delete mode 100644 espefuse/efuse/esp32s3beta2/__init__.py delete mode 100644 espefuse/efuse/esp32s3beta2/emulate_efuse_controller.py delete mode 100644 espefuse/efuse/esp32s3beta2/fields.py delete mode 100644 espefuse/efuse/esp32s3beta2/mem_definition.py delete mode 100644 espefuse/efuse/esp32s3beta2/operations.py delete mode 100644 espefuse/efuse_defs/esp32c5beta3.yaml delete mode 100644 esptool/targets/esp32c5beta3.py delete mode 100644 esptool/targets/esp32c6beta.py delete mode 100644 esptool/targets/esp32h2beta1.py delete mode 100644 esptool/targets/esp32h2beta2.py delete mode 100644 esptool/targets/esp32s3beta2.py delete mode 100644 esptool/targets/stub_flasher/1/esp32c5beta3.json delete mode 100644 esptool/targets/stub_flasher/1/esp32c6beta.json delete mode 100644 esptool/targets/stub_flasher/1/esp32h2beta1.json delete mode 100644 esptool/targets/stub_flasher/1/esp32h2beta2.json delete mode 100644 esptool/targets/stub_flasher/1/esp32s3beta2.json diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 4773cfc7a1..8a81e9648f 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -110,15 +110,12 @@ host_tests_espefuse: - esp32c2 - esp32c3 - esp32c5 - - esp32c5beta3 - esp32c6 - esp32c61 - esp32h2 - - esp32h2beta1 - esp32p4 - esp32s2 - esp32s3 - - esp32s3beta2 - esp32h21 script: - coverage run --parallel-mode -m pytest ${CI_PROJECT_DIR}/test/test_espefuse.py --chip ${TARGET} diff --git a/ci/download_flasher_stubs.py b/ci/download_flasher_stubs.py index 49ecc6d5f5..da6bc52320 100755 --- a/ci/download_flasher_stubs.py +++ b/ci/download_flasher_stubs.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -# SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD +# SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD # SPDX-License-Identifier: GPL-2.0-or-later import glob @@ -18,17 +18,12 @@ "esp32c2", "esp32c3", "esp32c5", - "esp32c5beta3", "esp32c6", "esp32c61", - "esp32c6beta", "esp32h2", - "esp32h2beta1", - "esp32h2beta2", "esp32p4", "esp32s2", "esp32s3", - "esp32s3beta2", "esp8266", ), "LICENSE": "released as Free Software under GNU General Public License Version 2 or later", diff --git a/docs/en/migration-guide.rst b/docs/en/migration-guide.rst index 7d50eaab79..934c04f645 100644 --- a/docs/en/migration-guide.rst +++ b/docs/en/migration-guide.rst @@ -13,14 +13,14 @@ The output format of the :ref:`image_info ` command has been **updat **Changes in the New Format:** -- Improved readability and structure -- Additional metadata fields for better debugging and analysis -- Consistent formatting for all ESP chip variants +- Improved readability and structure. +- Additional metadata fields for better debugging and analysis. +- Consistent formatting for all ESP chip variants. **Migration Steps:** -1. Update any scripts or tools that parse the ``image_info`` output to use the new format -2. Remove any ``--version`` arguments from ``image_info`` commands +1. Update any scripts or tools that parse the ``image_info`` output to use the new format. +2. Remove any ``--version`` arguments from ``image_info`` commands. Output Logging ************** @@ -73,3 +73,21 @@ In ``v5``, error handling and output behavior have been improved to provide bett 1. Update scripts that rely on parsing STDOUT for error messages to check STDERR instead. 2. Ensure scripts handle non-zero exit codes correctly in the case of operations interrupted by the user. + +Beta Target Support Removal +*************************** + +Support for the following beta targets has been **removed in v5**: + +- ESP32-C5(beta3) +- ESP32-C6(beta) +- ESP32-H2(beta1) +- ESP32-H2(beta2) +- ESP32-S3(beta2) + +**Migration Steps:** + +1. Update any scripts or workflows not to target these beta chips. +2. Remove any references to these beta targets from CI/CD pipelines or build scripts. + +Use esptool ``v4`` for legacy workflows targeting these beta chips. diff --git a/espefuse/__init__.py b/espefuse/__init__.py index 43f067ce81..726ccece0b 100755 --- a/espefuse/__init__.py +++ b/espefuse/__init__.py @@ -1,4 +1,4 @@ -# SPDX-FileCopyrightText: 2016-2022 Espressif Systems (Shanghai) CO LTD +# SPDX-FileCopyrightText: 2016-2025 Espressif Systems (Shanghai) CO LTD # # SPDX-License-Identifier: GPL-2.0-or-later # PYTHON_ARGCOMPLETE_OK @@ -13,16 +13,13 @@ import espefuse.efuse.esp32c2 as esp32c2_efuse import espefuse.efuse.esp32c3 as esp32c3_efuse import espefuse.efuse.esp32c5 as esp32c5_efuse -import espefuse.efuse.esp32c5beta3 as esp32c5beta3_efuse import espefuse.efuse.esp32c6 as esp32c6_efuse import espefuse.efuse.esp32c61 as esp32c61_efuse import espefuse.efuse.esp32h2 as esp32h2_efuse import espefuse.efuse.esp32h21 as esp32h21_efuse -import espefuse.efuse.esp32h2beta1 as esp32h2beta1_efuse import espefuse.efuse.esp32p4 as esp32p4_efuse import espefuse.efuse.esp32s2 as esp32s2_efuse import espefuse.efuse.esp32s3 as esp32s3_efuse -import espefuse.efuse.esp32s3beta2 as esp32s3beta2_efuse import esptool from esptool.logger import log @@ -59,20 +56,11 @@ "esp32c6": DefChip("ESP32-C6", esp32c6_efuse, esptool.targets.ESP32C6ROM), "esp32c61": DefChip("ESP32-C61", esp32c61_efuse, esptool.targets.ESP32C61ROM), "esp32c5": DefChip("ESP32-C5", esp32c5_efuse, esptool.targets.ESP32C5ROM), - "esp32c5beta3": DefChip( - "ESP32-C5(beta3)", esp32c5beta3_efuse, esptool.targets.ESP32C5BETA3ROM - ), "esp32h2": DefChip("ESP32-H2", esp32h2_efuse, esptool.targets.ESP32H2ROM), "esp32h21": DefChip("ESP32-H21", esp32h21_efuse, esptool.targets.ESP32H21ROM), "esp32p4": DefChip("ESP32-P4", esp32p4_efuse, esptool.targets.ESP32P4ROM), - "esp32h2beta1": DefChip( - "ESP32-H2(beta1)", esp32h2beta1_efuse, esptool.targets.ESP32H2BETA1ROM - ), "esp32s2": DefChip("ESP32-S2", esp32s2_efuse, esptool.targets.ESP32S2ROM), "esp32s3": DefChip("ESP32-S3", esp32s3_efuse, esptool.targets.ESP32S3ROM), - "esp32s3beta2": DefChip( - "ESP32-S3(beta2)", esp32s3beta2_efuse, esptool.targets.ESP32S3BETA2ROM - ), } diff --git a/espefuse/efuse/esp32c5beta3/__init__.py b/espefuse/efuse/esp32c5beta3/__init__.py deleted file mode 100644 index a3b55a8023..0000000000 --- a/espefuse/efuse/esp32c5beta3/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -from . import operations -from .emulate_efuse_controller import EmulateEfuseController -from .fields import EspEfuses diff --git a/espefuse/efuse/esp32c5beta3/emulate_efuse_controller.py b/espefuse/efuse/esp32c5beta3/emulate_efuse_controller.py deleted file mode 100644 index 3fdab6f816..0000000000 --- a/espefuse/efuse/esp32c5beta3/emulate_efuse_controller.py +++ /dev/null @@ -1,92 +0,0 @@ -# This file describes eFuses controller for ESP32-C5 beta3 chip -# -# SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD -# -# SPDX-License-Identifier: GPL-2.0-or-later - -import reedsolo - -from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters -from ..emulate_efuse_controller_base import EmulateEfuseControllerBase, FatalError - - -class EmulateEfuseController(EmulateEfuseControllerBase): - """The class for virtual efuse operation. Using for HOST_TEST.""" - - CHIP_NAME = "ESP32-C5(beta3)" - mem = None - debug = False - - def __init__(self, efuse_file=None, debug=False): - self.Blocks = EfuseDefineBlocks - self.Fields = EfuseDefineFields(None) - self.REGS = EfuseDefineRegisters - super(EmulateEfuseController, self).__init__(efuse_file, debug) - self.write_reg(self.REGS.EFUSE_CMD_REG, 0) - - """ esptool method start >>""" - - def get_major_chip_version(self): - return 0 - - def get_minor_chip_version(self): - return 0 - - def get_crystal_freq(self): - return 40 # MHz (common for all chips) - - def get_security_info(self): - return { - "flags": 0, - "flash_crypt_cnt": 0, - "key_purposes": 0, - "chip_id": 0, - "api_version": 0, - } - - """ << esptool method end """ - - def handle_writing_event(self, addr, value): - if addr == self.REGS.EFUSE_CMD_REG: - if value & self.REGS.EFUSE_PGM_CMD: - self.copy_blocks_wr_regs_to_rd_regs(updated_block=(value >> 2) & 0xF) - self.clean_blocks_wr_regs() - self.check_rd_protection_area() - self.write_reg(addr, 0) - self.write_reg(self.REGS.EFUSE_CMD_REG, 0) - elif value == self.REGS.EFUSE_READ_CMD: - self.write_reg(addr, 0) - self.write_reg(self.REGS.EFUSE_CMD_REG, 0) - self.save_to_file() - - def get_bitlen_of_block(self, blk, wr=False): - if blk.id == 0: - if wr: - return 32 * 8 - else: - return 32 * blk.len - else: - if wr: - rs_coding = 32 * 3 - return 32 * 8 + rs_coding - else: - return 32 * blk.len - - def handle_coding_scheme(self, blk, data): - if blk.id != 0: - # CODING_SCHEME RS applied only for all blocks except BLK0. - coded_bytes = 12 - data.pos = coded_bytes * 8 - plain_data = data.readlist("32*uint:8")[::-1] - # takes 32 bytes - # apply RS encoding - rs = reedsolo.RSCodec(coded_bytes) - # 32 byte of data + 12 bytes RS - calc_encoded_data = list(rs.encode([x for x in plain_data])) - data.pos = 0 - if calc_encoded_data != data.readlist("44*uint:8")[::-1]: - raise FatalError("Error in coding scheme data") - data = data[coded_bytes * 8 :] - if blk.len < 8: - data = data[(8 - blk.len) * 32 :] - return data diff --git a/espefuse/efuse/esp32c5beta3/fields.py b/espefuse/efuse/esp32c5beta3/fields.py deleted file mode 100644 index d3788fed5b..0000000000 --- a/espefuse/efuse/esp32c5beta3/fields.py +++ /dev/null @@ -1,464 +0,0 @@ -# This file describes eFuses for ESP32-C5 beta3 chip -# -# SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD -# -# SPDX-License-Identifier: GPL-2.0-or-later - -import binascii -import struct -import sys -import time - -from bitstring import BitArray - -import esptool - -import reedsolo - -from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters -from .. import base_fields -from .. import util - - -class EfuseBlock(base_fields.EfuseBlockBase): - def len_of_burn_unit(self): - # The writing register window is 8 registers for any blocks. - # len in bytes - return 8 * 4 - - def __init__(self, parent, param, skip_read=False): - parent.read_coding_scheme() - super(EfuseBlock, self).__init__(parent, param, skip_read=skip_read) - - def apply_coding_scheme(self): - data = self.get_raw(from_read=False)[::-1] - if len(data) < self.len_of_burn_unit(): - add_empty_bytes = self.len_of_burn_unit() - len(data) - data = data + (b"\x00" * add_empty_bytes) - if self.get_coding_scheme() == self.parent.REGS.CODING_SCHEME_RS: - # takes 32 bytes - # apply RS encoding - rs = reedsolo.RSCodec(12) - # 32 byte of data + 12 bytes RS - encoded_data = rs.encode([x for x in data]) - words = struct.unpack("<" + "I" * 11, encoded_data) - # returns 11 words (8 words of data + 3 words of RS coding) - else: - # takes 32 bytes - words = struct.unpack("<" + ("I" * (len(data) // 4)), data) - # returns 8 words - return words - - -class EspEfuses(base_fields.EspEfusesBase): - """ - Wrapper object to manage the efuse fields in a connected ESP bootloader - """ - - debug = False - do_not_confirm = False - - def __init__( - self, - esp, - skip_connect=False, - debug=False, - do_not_confirm=False, - extend_efuse_table=None, - ): - self.Blocks = EfuseDefineBlocks() - self.Fields = EfuseDefineFields(extend_efuse_table) - self.REGS = EfuseDefineRegisters - self.BURN_BLOCK_DATA_NAMES = self.Blocks.get_burn_block_data_names() - self.BLOCKS_FOR_KEYS = self.Blocks.get_blocks_for_keys() - self._esp = esp - self.debug = debug - self.do_not_confirm = do_not_confirm - if esp.CHIP_NAME != "ESP32-C5(beta3)": - raise esptool.FatalError( - "Expected the 'esp' param for ESP32-C5(beta3) chip but got for '%s'." - % (esp.CHIP_NAME) - ) - if not skip_connect: - flags = self._esp.get_security_info()["flags"] - GET_SECURITY_INFO_FLAG_SECURE_DOWNLOAD_ENABLE = 1 << 2 - if flags & GET_SECURITY_INFO_FLAG_SECURE_DOWNLOAD_ENABLE: - raise esptool.FatalError( - "Secure Download Mode is enabled. The tool can not read eFuses." - ) - self.blocks = [ - EfuseBlock(self, self.Blocks.get(block), skip_read=skip_connect) - for block in self.Blocks.BLOCKS - ] - if not skip_connect: - self.get_coding_scheme_warnings() - self.efuses = [EfuseField.convert(self, efuse) for efuse in self.Fields.EFUSES] - self.efuses += [ - EfuseField.convert(self, efuse) for efuse in self.Fields.KEYBLOCKS - ] - if skip_connect: - self.efuses += [ - EfuseField.convert(self, efuse) - for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES - ] - else: - if self.get_block_version() >= 1: - self.efuses += [ - EfuseField.convert(self, efuse) - for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES - ] - self.efuses += [ - EfuseField.convert(self, efuse) for efuse in self.Fields.CALC - ] - - def __getitem__(self, efuse_name): - """Return the efuse field with the given name""" - for e in self.efuses: - if efuse_name == e.name or any(x == efuse_name for x in e.alt_names): - return e - new_fields = False - for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES: - if efuse.name == efuse_name or any( - x == efuse_name for x in efuse.alt_names - ): - self.efuses += [ - EfuseField.convert(self, efuse) - for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES - ] - new_fields = True - if new_fields: - for e in self.efuses: - if efuse_name == e.name or any(x == efuse_name for x in e.alt_names): - return e - raise KeyError - - def read_coding_scheme(self): - self.coding_scheme = self.REGS.CODING_SCHEME_RS - - def print_status_regs(self): - print("") - self.blocks[0].print_block(self.blocks[0].err_bitarray, "err__regs", debug=True) - print( - "{:27} 0x{:08x}".format( - "EFUSE_RD_RS_ERR0_REG", self.read_reg(self.REGS.EFUSE_RD_RS_ERR0_REG) - ) - ) - print( - "{:27} 0x{:08x}".format( - "EFUSE_RD_RS_ERR1_REG", self.read_reg(self.REGS.EFUSE_RD_RS_ERR1_REG) - ) - ) - - def efuse_controller_setup(self): - self.set_efuse_timing() - self.clear_pgm_registers() - self.wait_efuse_idle() - - def write_efuses(self, block): - self.efuse_program(block) - return self.get_coding_scheme_warnings(silent=True) - - def clear_pgm_registers(self): - self.wait_efuse_idle() - for r in range( - self.REGS.EFUSE_PGM_DATA0_REG, self.REGS.EFUSE_PGM_DATA0_REG + 32, 4 - ): - self.write_reg(r, 0) - - def wait_efuse_idle(self): - deadline = time.time() + self.REGS.EFUSE_BURN_TIMEOUT - while time.time() < deadline: - cmds = self.REGS.EFUSE_PGM_CMD | self.REGS.EFUSE_READ_CMD - if self.read_reg(self.REGS.EFUSE_CMD_REG) & cmds == 0: - if self.read_reg(self.REGS.EFUSE_CMD_REG) & cmds == 0: - # Due to a hardware error, we have to read READ_CMD again - # to make sure the efuse clock is normal. - # For PGM_CMD it is not necessary. - return - raise esptool.FatalError( - "Timed out waiting for Efuse controller command to complete" - ) - - def efuse_program(self, block): - self.wait_efuse_idle() - self.write_reg(self.REGS.EFUSE_CONF_REG, self.REGS.EFUSE_WRITE_OP_CODE) - self.write_reg(self.REGS.EFUSE_CMD_REG, self.REGS.EFUSE_PGM_CMD | (block << 2)) - self.wait_efuse_idle() - self.clear_pgm_registers() - self.efuse_read() - - def efuse_read(self): - self.wait_efuse_idle() - self.write_reg(self.REGS.EFUSE_CONF_REG, self.REGS.EFUSE_READ_OP_CODE) - # need to add a delay after triggering EFUSE_READ_CMD, as ROM loader checks some - # efuse registers after each command is completed - # if ENABLE_SECURITY_DOWNLOAD or DIS_DOWNLOAD_MODE is enabled by the current cmd, then we need to try to reconnect to the chip. - try: - self.write_reg( - self.REGS.EFUSE_CMD_REG, self.REGS.EFUSE_READ_CMD, delay_after_us=1000 - ) - self.wait_efuse_idle() - except esptool.FatalError: - secure_download_mode_before = self._esp.secure_download_mode - - try: - self._esp = self.reconnect_chip(self._esp) - except esptool.FatalError: - print("Can not re-connect to the chip") - if not self["DIS_DOWNLOAD_MODE"].get() and self[ - "DIS_DOWNLOAD_MODE" - ].get(from_read=False): - print( - "This is the correct behavior as we are actually burning " - "DIS_DOWNLOAD_MODE which disables the connection to the chip" - ) - print("DIS_DOWNLOAD_MODE is enabled") - print("Successful") - sys.exit(0) # finish without errors - raise - - print("Established a connection with the chip") - if self._esp.secure_download_mode and not secure_download_mode_before: - print("Secure download mode is enabled") - if not self["ENABLE_SECURITY_DOWNLOAD"].get() and self[ - "ENABLE_SECURITY_DOWNLOAD" - ].get(from_read=False): - print( - "espefuse tool can not continue to work in Secure download mode" - ) - print("ENABLE_SECURITY_DOWNLOAD is enabled") - print("Successful") - sys.exit(0) # finish without errors - raise - - def set_efuse_timing(self): - """Set timing registers for burning efuses""" - # Configure clock - apb_freq = self.get_crystal_freq() - if apb_freq not in [40, 48]: - raise esptool.FatalError( - "The eFuse supports only xtal=40M and 48M (xtal was %d)" % apb_freq - ) - - self.update_reg(self.REGS.EFUSE_DAC_CONF_REG, self.REGS.EFUSE_DAC_NUM_M, 0xFF) - self.update_reg( - self.REGS.EFUSE_DAC_CONF_REG, self.REGS.EFUSE_DAC_CLK_DIV_M, 0x28 - ) - self.update_reg( - self.REGS.EFUSE_WR_TIM_CONF1_REG, self.REGS.EFUSE_PWR_ON_NUM_M, 0x3000 - ) - self.update_reg( - self.REGS.EFUSE_WR_TIM_CONF2_REG, self.REGS.EFUSE_PWR_OFF_NUM_M, 0x190 - ) - - def get_coding_scheme_warnings(self, silent=False): - """Check if the coding scheme has detected any errors.""" - old_addr_reg = 0 - reg_value = 0 - ret_fail = False - for block in self.blocks: - if block.id == 0: - words = [ - self.read_reg(self.REGS.EFUSE_RD_REPEAT_ERR0_REG + offs * 4) - for offs in range(5) - ] - block.err_bitarray.pos = 0 - for word in reversed(words): - block.err_bitarray.overwrite(BitArray("uint:32=%d" % word)) - block.num_errors = block.err_bitarray.count(True) - block.fail = block.num_errors != 0 - else: - addr_reg, err_num_mask, err_num_offs, fail_bit = self.REGS.BLOCK_ERRORS[ - block.id - ] - if err_num_mask is None or err_num_offs is None or fail_bit is None: - continue - if addr_reg != old_addr_reg: - old_addr_reg = addr_reg - reg_value = self.read_reg(addr_reg) - block.fail = reg_value & (1 << fail_bit) != 0 - block.num_errors = (reg_value >> err_num_offs) & err_num_mask - ret_fail |= block.fail - if not silent and (block.fail or block.num_errors): - print( - "Error(s) in BLOCK%d [ERRORS:%d FAIL:%d]" - % (block.id, block.num_errors, block.fail) - ) - if (self.debug or ret_fail) and not silent: - self.print_status_regs() - return ret_fail - - def summary(self): - # TODO add support set_flash_voltage - "Flash voltage (VDD_SPI)" - return "" - - -class EfuseField(base_fields.EfuseFieldBase): - @staticmethod - def convert(parent, efuse): - return { - "mac": EfuseMacField, - "keypurpose": EfuseKeyPurposeField, - "t_sensor": EfuseTempSensor, - "adc_tp": EfuseAdcPointCalibration, - "wafer": EfuseWafer, - }.get(efuse.class_type, EfuseField)(parent, efuse) - - -class EfuseWafer(EfuseField): - def get(self, from_read=True): - hi_bits = self.parent["WAFER_VERSION_MINOR_HI"].get(from_read) - assert self.parent["WAFER_VERSION_MINOR_HI"].bit_len == 1 - lo_bits = self.parent["WAFER_VERSION_MINOR_LO"].get(from_read) - assert self.parent["WAFER_VERSION_MINOR_LO"].bit_len == 3 - return (hi_bits << 3) + lo_bits - - def save(self, new_value): - raise esptool.FatalError("Burning %s is not supported" % self.name) - - -class EfuseTempSensor(EfuseField): - def get(self, from_read=True): - value = self.get_bitstring(from_read) - sig = -1 if value[0] else 1 - return sig * value[1:].uint * 0.1 - - -class EfuseAdcPointCalibration(EfuseField): - def get(self, from_read=True): - STEP_SIZE = 4 - value = self.get_bitstring(from_read) - sig = -1 if value[0] else 1 - return sig * value[1:].uint * STEP_SIZE - - -class EfuseMacField(EfuseField): - def check_format(self, new_value_str): - if new_value_str is None: - raise esptool.FatalError( - "Required MAC Address in AA:CD:EF:01:02:03 format!" - ) - num_bytes = 8 if self.name == "MAC_EUI64" else 6 - if new_value_str.count(":") != num_bytes - 1: - raise esptool.FatalError( - f"MAC Address needs to be a {num_bytes}-byte hexadecimal format " - "separated by colons (:)!" - ) - hexad = new_value_str.replace(":", "").split(" ", 1)[0] - hexad = hexad.split(" ", 1)[0] if self.is_field_calculated() else hexad - if len(hexad) != num_bytes * 2: - raise esptool.FatalError( - f"MAC Address needs to be a {num_bytes}-byte hexadecimal number " - f"({num_bytes * 2} hexadecimal characters)!" - ) - # order of bytearray = b'\xaa\xcd\xef\x01\x02\x03', - bindata = binascii.unhexlify(hexad) - - if not self.is_field_calculated(): - # unicast address check according to - # https://tools.ietf.org/html/rfc7042#section-2.1 - if esptool.util.byte(bindata, 0) & 0x01: - raise esptool.FatalError("Custom MAC must be a unicast MAC!") - return bindata - - def check(self): - errs, fail = self.parent.get_block_errors(self.block) - if errs != 0 or fail: - output = "Block%d has ERRORS:%d FAIL:%d" % (self.block, errs, fail) - else: - output = "OK" - return "(" + output + ")" - - def get(self, from_read=True): - if self.name == "CUSTOM_MAC": - mac = self.get_raw(from_read)[::-1] - elif self.name == "MAC": - mac = self.get_raw(from_read) - elif self.name == "MAC_EUI64": - mac = self.parent["MAC"].get_bitstring(from_read).copy() - mac_ext = self.parent["MAC_EXT"].get_bitstring(from_read) - mac.insert(mac_ext, 24) - mac = mac.bytes - else: - mac = self.get_raw(from_read) - return "%s %s" % (util.hexify(mac, ":"), self.check()) - - def save(self, new_value): - def print_field(e, new_value): - print( - " - '{}' ({}) {} -> {}".format( - e.name, e.description, e.get_bitstring(), new_value - ) - ) - - if self.name == "CUSTOM_MAC": - bitarray_mac = self.convert_to_bitstring(new_value) - print_field(self, bitarray_mac) - super(EfuseMacField, self).save(new_value) - else: - # Writing the BLOCK1 (MAC_SPI_8M_0) default MAC is not possible, - # as it's written in the factory. - raise esptool.FatalError(f"Burning {self.name} is not supported") - - -# fmt: off -class EfuseKeyPurposeField(EfuseField): - KEY_PURPOSES = [ - ("USER", 0, None, None, "no_need_rd_protect"), # User purposes (software-only use) - ("ECDSA_KEY", 1, None, "Reverse", "need_rd_protect"), # ECDSA key - ("RESERVED", 1, None, None, "no_need_rd_protect"), # Reserved - ("XTS_AES_128_KEY", 4, None, "Reverse", "need_rd_protect"), # XTS_AES_128_KEY (flash/PSRAM encryption) - ("HMAC_DOWN_ALL", 5, None, None, "need_rd_protect"), # HMAC Downstream mode - ("HMAC_DOWN_JTAG", 6, None, None, "need_rd_protect"), # JTAG soft enable key (uses HMAC Downstream mode) - ("HMAC_DOWN_DIGITAL_SIGNATURE", 7, None, None, "need_rd_protect"), # Digital Signature peripheral key (uses HMAC Downstream mode) - ("HMAC_UP", 8, None, None, "need_rd_protect"), # HMAC Upstream mode - ("SECURE_BOOT_DIGEST0", 9, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST0 (Secure Boot key digest) - ("SECURE_BOOT_DIGEST1", 10, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST1 (Secure Boot key digest) - ("SECURE_BOOT_DIGEST2", 11, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST2 (Secure Boot key digest) - ] -# fmt: on - KEY_PURPOSES_NAME = [name[0] for name in KEY_PURPOSES] - DIGEST_KEY_PURPOSES = [name[0] for name in KEY_PURPOSES if name[2] == "DIGEST"] - - def check_format(self, new_value_str): - # str convert to int: "XTS_AES_128_KEY" - > str(4) - # if int: 4 -> str(4) - raw_val = new_value_str - for purpose_name in self.KEY_PURPOSES: - if purpose_name[0] == new_value_str: - raw_val = str(purpose_name[1]) - break - if raw_val.isdigit(): - if int(raw_val) not in [p[1] for p in self.KEY_PURPOSES if p[1] > 0]: - raise esptool.FatalError("'%s' can not be set (value out of range)" % raw_val) - else: - raise esptool.FatalError("'%s' unknown name" % raw_val) - return raw_val - - def need_reverse(self, new_key_purpose): - for key in self.KEY_PURPOSES: - if key[0] == new_key_purpose: - return key[3] == "Reverse" - - def need_rd_protect(self, new_key_purpose): - for key in self.KEY_PURPOSES: - if key[0] == new_key_purpose: - return key[4] == "need_rd_protect" - - def get(self, from_read=True): - for p in self.KEY_PURPOSES: - if p[1] == self.get_raw(from_read): - return p[0] - return "FORBIDDEN_STATE" - - def get_name(self, raw_val): - for key in self.KEY_PURPOSES: - if key[1] == raw_val: - return key[0] - - def save(self, new_value): - raw_val = int(self.check_format(str(new_value))) - str_new_value = self.get_name(raw_val) - if self.name == "KEY_PURPOSE_5" and str_new_value.startswith("XTS_AES"): - raise esptool.FatalError(f"{self.name} can not have {str_new_value} key due to a hardware bug (please see TRM for more details)") - return super(EfuseKeyPurposeField, self).save(raw_val) diff --git a/espefuse/efuse/esp32c5beta3/mem_definition.py b/espefuse/efuse/esp32c5beta3/mem_definition.py deleted file mode 100644 index 9ba5b719ec..0000000000 --- a/espefuse/efuse/esp32c5beta3/mem_definition.py +++ /dev/null @@ -1,165 +0,0 @@ -# This file describes eFuses fields and registers for ESP32-C5 beta3 chip -# -# SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD -# -# SPDX-License-Identifier: GPL-2.0-or-later - -import os - -import yaml - -from ..mem_definition_base import ( - EfuseBlocksBase, - EfuseFieldsBase, - EfuseRegistersBase, - Field, -) - - -class EfuseDefineRegisters(EfuseRegistersBase): - EFUSE_MEM_SIZE = 0x01FC + 4 - - # EFUSE registers & command/conf values - DR_REG_EFUSE_BASE = 0x600B0800 - EFUSE_PGM_DATA0_REG = DR_REG_EFUSE_BASE - EFUSE_CHECK_VALUE0_REG = DR_REG_EFUSE_BASE + 0x020 - EFUSE_CLK_REG = DR_REG_EFUSE_BASE + 0x1C8 - EFUSE_CONF_REG = DR_REG_EFUSE_BASE + 0x1CC - EFUSE_STATUS_REG = DR_REG_EFUSE_BASE + 0x1D0 - EFUSE_CMD_REG = DR_REG_EFUSE_BASE + 0x1D4 - EFUSE_RD_RS_ERR0_REG = DR_REG_EFUSE_BASE + 0x1C0 - EFUSE_RD_RS_ERR1_REG = DR_REG_EFUSE_BASE + 0x1C4 - EFUSE_RD_REPEAT_ERR0_REG = DR_REG_EFUSE_BASE + 0x17C - EFUSE_RD_REPEAT_ERR1_REG = DR_REG_EFUSE_BASE + 0x180 - EFUSE_RD_REPEAT_ERR2_REG = DR_REG_EFUSE_BASE + 0x184 - EFUSE_RD_REPEAT_ERR3_REG = DR_REG_EFUSE_BASE + 0x188 - EFUSE_RD_REPEAT_ERR4_REG = DR_REG_EFUSE_BASE + 0x18C - EFUSE_DAC_CONF_REG = DR_REG_EFUSE_BASE + 0x1E8 - EFUSE_RD_TIM_CONF_REG = DR_REG_EFUSE_BASE + 0x1EC - EFUSE_WR_TIM_CONF1_REG = DR_REG_EFUSE_BASE + 0x1F0 - EFUSE_WR_TIM_CONF2_REG = DR_REG_EFUSE_BASE + 0x1F4 - EFUSE_DATE_REG = DR_REG_EFUSE_BASE + 0x1FC - EFUSE_WRITE_OP_CODE = 0x5A5A - EFUSE_READ_OP_CODE = 0x5AA5 - EFUSE_PGM_CMD_MASK = 0x3 - EFUSE_PGM_CMD = 0x2 - EFUSE_READ_CMD = 0x1 - - BLOCK_ERRORS = [ - # error_reg, err_num_mask, err_num_offs, fail_bit - (EFUSE_RD_REPEAT_ERR0_REG, None, None, None), # BLOCK0 - (EFUSE_RD_RS_ERR0_REG, 0x7, 0, 3), # MAC_SPI_8M_0 - (EFUSE_RD_RS_ERR0_REG, 0x7, 4, 7), # BLOCK_SYS_DATA - (EFUSE_RD_RS_ERR0_REG, 0x7, 8, 11), # BLOCK_USR_DATA - (EFUSE_RD_RS_ERR0_REG, 0x7, 12, 15), # BLOCK_KEY0 - (EFUSE_RD_RS_ERR0_REG, 0x7, 16, 19), # BLOCK_KEY1 - (EFUSE_RD_RS_ERR0_REG, 0x7, 20, 23), # BLOCK_KEY2 - (EFUSE_RD_RS_ERR0_REG, 0x7, 24, 27), # BLOCK_KEY3 - (EFUSE_RD_RS_ERR0_REG, 0x7, 28, 31), # BLOCK_KEY4 - (EFUSE_RD_RS_ERR1_REG, 0x7, 0, 3), # BLOCK_KEY5 - (EFUSE_RD_RS_ERR1_REG, 0x7, 4, 7), # BLOCK_SYS_DATA2 - ] - - # EFUSE_WR_TIM_CONF2_REG - EFUSE_PWR_OFF_NUM_S = 0 - EFUSE_PWR_OFF_NUM_M = 0xFFFF << EFUSE_PWR_OFF_NUM_S - - # EFUSE_WR_TIM_CONF1_REG - EFUSE_PWR_ON_NUM_S = 8 - EFUSE_PWR_ON_NUM_M = 0x0000FFFF << EFUSE_PWR_ON_NUM_S - - # EFUSE_DAC_CONF_REG - EFUSE_DAC_CLK_DIV_S = 0 - EFUSE_DAC_CLK_DIV_M = 0xFF << EFUSE_DAC_CLK_DIV_S - - # EFUSE_DAC_CONF_REG - EFUSE_DAC_NUM_S = 9 - EFUSE_DAC_NUM_M = 0xFF << EFUSE_DAC_NUM_S - - -class EfuseDefineBlocks(EfuseBlocksBase): - __base_rd_regs = EfuseDefineRegisters.DR_REG_EFUSE_BASE - __base_wr_regs = EfuseDefineRegisters.EFUSE_PGM_DATA0_REG - # List of efuse blocks - # fmt: off - BLOCKS = [ - # Name, Alias, Index, Read address, Write address, Write protect bit, Read protect bit, Len, key_purpose - ("BLOCK0", [], 0, __base_rd_regs + 0x02C, __base_wr_regs, None, None, 6, None), - ("MAC_SPI_8M_0", ["BLOCK1"], 1, __base_rd_regs + 0x044, __base_wr_regs, 20, None, 6, None), - ("BLOCK_SYS_DATA", ["BLOCK2"], 2, __base_rd_regs + 0x05C, __base_wr_regs, 21, None, 8, None), - ("BLOCK_USR_DATA", ["BLOCK3"], 3, __base_rd_regs + 0x07C, __base_wr_regs, 22, None, 8, None), - ("BLOCK_KEY0", ["BLOCK4"], 4, __base_rd_regs + 0x09C, __base_wr_regs, 23, 0, 8, "KEY_PURPOSE_0"), - ("BLOCK_KEY1", ["BLOCK5"], 5, __base_rd_regs + 0x0BC, __base_wr_regs, 24, 1, 8, "KEY_PURPOSE_1"), - ("BLOCK_KEY2", ["BLOCK6"], 6, __base_rd_regs + 0x0DC, __base_wr_regs, 25, 2, 8, "KEY_PURPOSE_2"), - ("BLOCK_KEY3", ["BLOCK7"], 7, __base_rd_regs + 0x0FC, __base_wr_regs, 26, 3, 8, "KEY_PURPOSE_3"), - ("BLOCK_KEY4", ["BLOCK8"], 8, __base_rd_regs + 0x11C, __base_wr_regs, 27, 4, 8, "KEY_PURPOSE_4"), - ("BLOCK_KEY5", ["BLOCK9"], 9, __base_rd_regs + 0x13C, __base_wr_regs, 28, 5, 8, "KEY_PURPOSE_5"), - ("BLOCK_SYS_DATA2", ["BLOCK10"], 10, __base_rd_regs + 0x15C, __base_wr_regs, 29, 6, 8, None), - ] - # fmt: on - - def get_burn_block_data_names(self): - list_of_names = [] - for block in self.BLOCKS: - blk = self.get(block) - if blk.name: - list_of_names.append(blk.name) - if blk.alias: - for alias in blk.alias: - list_of_names.append(alias) - return list_of_names - - -class EfuseDefineFields(EfuseFieldsBase): - def __init__(self, extend_efuse_table) -> None: - # List of efuse fields from TRM the chapter eFuse Controller. - self.EFUSES = [] - self.KEYBLOCKS = [] - self.BLOCK2_CALIBRATION_EFUSES = [] - self.CALC = [] - - dir_name = os.path.dirname(os.path.abspath(__file__)) - dir_name, file_name = os.path.split(dir_name) - file_name = file_name + ".yaml" - dir_name, _ = os.path.split(dir_name) - efuse_file = os.path.join(dir_name, "efuse_defs", file_name) - with open(f"{efuse_file}", "r") as r_file: - e_desc = yaml.safe_load(r_file) - super().__init__(e_desc, extend_efuse_table) - - for i, efuse in enumerate(self.ALL_EFUSES): - if efuse.name in [ - "BLOCK_USR_DATA", - "BLOCK_KEY0", - "BLOCK_KEY1", - "BLOCK_KEY2", - "BLOCK_KEY3", - "BLOCK_KEY4", - "BLOCK_KEY5", - "BLOCK_SYS_DATA2", - ]: - if efuse.name == "BLOCK_USR_DATA": - efuse.bit_len = 256 - efuse.type = "bytes:32" - self.KEYBLOCKS.append(efuse) - self.ALL_EFUSES[i] = None - - elif efuse.category == "calibration": - self.BLOCK2_CALIBRATION_EFUSES.append(efuse) - self.ALL_EFUSES[i] = None - - f = Field() - f.name = "MAC_EUI64" - f.block = 1 - f.bit_len = 64 - f.type = f"bytes:{f.bit_len // 8}" - f.category = "MAC" - f.class_type = "mac" - f.description = "calc MAC_EUI64 = MAC[0]:MAC[1]:MAC[2]:MAC_EXT[0]:MAC_EXT[1]:MAC[3]:MAC[4]:MAC[5]" - self.CALC.append(f) - - for efuse in self.ALL_EFUSES: - if efuse is not None: - self.EFUSES.append(efuse) - - self.ALL_EFUSES = [] diff --git a/espefuse/efuse/esp32c5beta3/operations.py b/espefuse/efuse/esp32c5beta3/operations.py deleted file mode 100644 index fbd721bd63..0000000000 --- a/espefuse/efuse/esp32c5beta3/operations.py +++ /dev/null @@ -1,395 +0,0 @@ -# This file includes the operations with eFuses for ESP32-C5 beta3 chip -# -# SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD -# -# SPDX-License-Identifier: GPL-2.0-or-later - -import argparse -import os # noqa: F401. It is used in IDF scripts -import traceback - -import espsecure - -import esptool - -from . import fields -from .. import util -from ..base_operations import ( - add_common_commands, - add_force_write_always, - add_show_sensitive_info_option, - burn_bit, - burn_block_data, - burn_efuse, - check_error, - dump, - read_protect_efuse, - summary, - write_protect_efuse, -) - - -def protect_options(p): - p.add_argument( - "--no-write-protect", - help="Disable write-protecting of the key. The key remains writable. " - "(The keys use the RS coding scheme that does not support " - "post-write data changes. Forced write can damage RS encoding bits.) " - "The write-protecting of keypurposes does not depend on the option, " - "it will be set anyway.", - action="store_true", - ) - p.add_argument( - "--no-read-protect", - help="Disable read-protecting of the key. The key remains readable software." - "The key with keypurpose[USER, RESERVED and *_DIGEST] " - "will remain readable anyway. For the rest keypurposes the read-protection " - "will be defined the option (Read-protect by default).", - action="store_true", - ) - - -def add_commands(subparsers, efuses): - add_common_commands(subparsers, efuses) - burn_key = subparsers.add_parser( - "burn_key", help="Burn the key block with the specified name" - ) - protect_options(burn_key) - add_force_write_always(burn_key) - add_show_sensitive_info_option(burn_key) - burn_key.add_argument( - "block", - help="Key block to burn", - action="append", - choices=efuses.BLOCKS_FOR_KEYS, - ) - burn_key.add_argument( - "keyfile", - help="File containing 256 bits of binary key data. For the ECDSA_KEY purpose use PEM file.", - action="append", - type=argparse.FileType("rb"), - ) - burn_key.add_argument( - "keypurpose", - help="Purpose to set.", - action="append", - choices=fields.EfuseKeyPurposeField.KEY_PURPOSES_NAME, - ) - for _ in efuses.BLOCKS_FOR_KEYS: - burn_key.add_argument( - "block", - help="Key block to burn", - nargs="?", - action="append", - metavar="BLOCK", - choices=efuses.BLOCKS_FOR_KEYS, - ) - burn_key.add_argument( - "keyfile", - help="File containing 256 bits of binary key data. For the ECDSA_KEY purpose use PEM file.", - nargs="?", - action="append", - metavar="KEYFILE", - type=argparse.FileType("rb"), - ) - burn_key.add_argument( - "keypurpose", - help="Purpose to set.", - nargs="?", - action="append", - metavar="KEYPURPOSE", - choices=fields.EfuseKeyPurposeField.KEY_PURPOSES_NAME, - ) - - burn_key_digest = subparsers.add_parser( - "burn_key_digest", - help="Parse a RSA public key and burn the digest to key efuse block", - ) - protect_options(burn_key_digest) - add_force_write_always(burn_key_digest) - add_show_sensitive_info_option(burn_key_digest) - burn_key_digest.add_argument( - "block", - help="Key block to burn", - action="append", - choices=efuses.BLOCKS_FOR_KEYS, - ) - burn_key_digest.add_argument( - "keyfile", - help="Key file to digest (PEM format)", - action="append", - type=argparse.FileType("rb"), - ) - burn_key_digest.add_argument( - "keypurpose", - help="Purpose to set.", - action="append", - choices=fields.EfuseKeyPurposeField.DIGEST_KEY_PURPOSES, - ) - for _ in efuses.BLOCKS_FOR_KEYS: - burn_key_digest.add_argument( - "block", - help="Key block to burn", - nargs="?", - action="append", - metavar="BLOCK", - choices=efuses.BLOCKS_FOR_KEYS, - ) - burn_key_digest.add_argument( - "keyfile", - help="Key file to digest (PEM format)", - nargs="?", - action="append", - metavar="KEYFILE", - type=argparse.FileType("rb"), - ) - burn_key_digest.add_argument( - "keypurpose", - help="Purpose to set.", - nargs="?", - action="append", - metavar="KEYPURPOSE", - choices=fields.EfuseKeyPurposeField.DIGEST_KEY_PURPOSES, - ) - - p = subparsers.add_parser( - "set_flash_voltage", - help="Permanently set the internal flash voltage regulator " - "to either 1.8V, 3.3V or OFF. " - "This means GPIO45 can be high or low at reset without " - "changing the flash voltage.", - ) - p.add_argument("voltage", help="Voltage selection", choices=["1.8V", "3.3V", "OFF"]) - - p = subparsers.add_parser( - "burn_custom_mac", help="Burn a 48-bit Custom MAC Address to EFUSE BLOCK3." - ) - p.add_argument( - "mac", - help="Custom MAC Address to burn given in hexadecimal format with bytes " - "separated by colons (e.g. AA:CD:EF:01:02:03).", - type=fields.base_fields.CheckArgValue(efuses, "CUSTOM_MAC"), - ) - add_force_write_always(p) - - p = subparsers.add_parser("get_custom_mac", help="Prints the Custom MAC Address.") - - -def burn_custom_mac(esp, efuses, args): - efuses["CUSTOM_MAC"].save(args.mac) - if not efuses.burn_all(check_batch_mode=True): - return - get_custom_mac(esp, efuses, args) - print("Successful") - - -def get_custom_mac(esp, efuses, args): - print("Custom MAC Address: {}".format(efuses["CUSTOM_MAC"].get())) - - -def set_flash_voltage(esp, efuses, args): - raise esptool.FatalError("set_flash_voltage is not supported!") - - -def adc_info(esp, efuses, args): - print("not supported yet") - - -def burn_key(esp, efuses, args, digest=None): - if digest is None: - datafile_list = args.keyfile[ - 0 : len([name for name in args.keyfile if name is not None]) : - ] - else: - datafile_list = digest[0 : len([name for name in digest if name is not None]) :] - efuses.force_write_always = args.force_write_always - block_name_list = args.block[ - 0 : len([name for name in args.block if name is not None]) : - ] - keypurpose_list = args.keypurpose[ - 0 : len([name for name in args.keypurpose if name is not None]) : - ] - - util.check_duplicate_name_in_list(block_name_list) - if len(block_name_list) != len(datafile_list) or len(block_name_list) != len( - keypurpose_list - ): - raise esptool.FatalError( - "The number of blocks (%d), datafile (%d) and keypurpose (%d) " - "should be the same." - % (len(block_name_list), len(datafile_list), len(keypurpose_list)) - ) - - print("Burn keys to blocks:") - for block_name, datafile, keypurpose in zip( - block_name_list, datafile_list, keypurpose_list - ): - efuse = None - for block in efuses.blocks: - if block_name == block.name or block_name in block.alias: - efuse = efuses[block.name] - if efuse is None: - raise esptool.FatalError("Unknown block name - %s" % (block_name)) - num_bytes = efuse.bit_len // 8 - - block_num = efuses.get_index_block_by_name(block_name) - block = efuses.blocks[block_num] - - if digest is None: - if keypurpose == "ECDSA_KEY": - sk = espsecure.load_ecdsa_signing_key(datafile) - data = sk.to_string() - if len(data) == 24: - # the private key is 24 bytes long for NIST192p, and 8 bytes of padding - data = b"\x00" * 8 + data - else: - data = datafile.read() - else: - data = datafile - - print(" - %s" % (efuse.name), end=" ") - revers_msg = None - if efuses[block.key_purpose_name].need_reverse(keypurpose): - revers_msg = f"\tReversing byte order for {keypurpose} hardware peripheral" - data = data[::-1] - print( - "-> [{}]".format( - util.hexify(data, " ") - if args.show_sensitive_info - else " ".join(["??"] * len(data)) - ) - ) - if revers_msg: - print(revers_msg) - if len(data) != num_bytes: - raise esptool.FatalError( - "Incorrect key file size %d. Key file must be %d bytes (%d bits) " - "of raw binary key data." % (len(data), num_bytes, num_bytes * 8) - ) - - if efuses[block.key_purpose_name].need_rd_protect(keypurpose): - read_protect = False if args.no_read_protect else True - else: - read_protect = False - write_protect = not args.no_write_protect - - # using efuse instead of a block gives the advantage of checking it as the whole field. - efuse.save(data) - - disable_wr_protect_key_purpose = False - if efuses[block.key_purpose_name].get() != keypurpose: - if efuses[block.key_purpose_name].is_writeable(): - print( - "\t'%s': '%s' -> '%s'." - % ( - block.key_purpose_name, - efuses[block.key_purpose_name].get(), - keypurpose, - ) - ) - efuses[block.key_purpose_name].save(keypurpose) - disable_wr_protect_key_purpose = True - else: - raise esptool.FatalError( - "It is not possible to change '%s' to '%s' " - "because write protection bit is set." - % (block.key_purpose_name, keypurpose) - ) - else: - print("\t'%s' is already '%s'." % (block.key_purpose_name, keypurpose)) - if efuses[block.key_purpose_name].is_writeable(): - disable_wr_protect_key_purpose = True - - if disable_wr_protect_key_purpose: - print("\tDisabling write to '%s'." % block.key_purpose_name) - efuses[block.key_purpose_name].disable_write() - - if read_protect: - print("\tDisabling read to key block") - efuse.disable_read() - - if write_protect: - print("\tDisabling write to key block") - efuse.disable_write() - print("") - - if not write_protect: - print("Keys will remain writeable (due to --no-write-protect)") - if args.no_read_protect: - print("Keys will remain readable (due to --no-read-protect)") - - if not efuses.burn_all(check_batch_mode=True): - return - print("Successful") - - -def burn_key_digest(esp, efuses, args): - digest_list = [] - datafile_list = args.keyfile[ - 0 : len([name for name in args.keyfile if name is not None]) : - ] - block_list = args.block[ - 0 : len([block for block in args.block if block is not None]) : - ] - for block_name, datafile in zip(block_list, datafile_list): - efuse = None - for block in efuses.blocks: - if block_name == block.name or block_name in block.alias: - efuse = efuses[block.name] - if efuse is None: - raise esptool.FatalError("Unknown block name - %s" % (block_name)) - num_bytes = efuse.bit_len // 8 - digest = espsecure._digest_sbv2_public_key(datafile) - if len(digest) != num_bytes: - raise esptool.FatalError( - "Incorrect digest size %d. Digest must be %d bytes (%d bits) " - "of raw binary key data." % (len(digest), num_bytes, num_bytes * 8) - ) - digest_list.append(digest) - burn_key(esp, efuses, args, digest=digest_list) - - -def espefuse(esp, efuses, args, command): - parser = argparse.ArgumentParser() - subparsers = parser.add_subparsers(dest="operation") - add_commands(subparsers, efuses) - try: - cmd_line_args = parser.parse_args(command.split()) - except SystemExit: - traceback.print_stack() - raise esptool.FatalError('"{}" - incorrect command'.format(command)) - if cmd_line_args.operation == "execute_scripts": - configfiles = cmd_line_args.configfiles - index = cmd_line_args.index - # copy arguments from args to cmd_line_args - vars(cmd_line_args).update(vars(args)) - if cmd_line_args.operation == "execute_scripts": - cmd_line_args.configfiles = configfiles - cmd_line_args.index = index - if cmd_line_args.operation is None: - parser.print_help() - parser.exit(1) - operation_func = globals()[cmd_line_args.operation] - # each 'operation' is a module-level function of the same name - operation_func(esp, efuses, cmd_line_args) - - -def execute_scripts(esp, efuses, args): - efuses.batch_mode_cnt += 1 - del args.operation - scripts = args.scripts - del args.scripts - - for file in scripts: - with open(file.name, "r") as file: - exec(compile(file.read(), file.name, "exec")) - - if args.debug: - for block in efuses.blocks: - data = block.get_bitstring(from_read=False) - block.print_block(data, "regs_for_burn", args.debug) - - efuses.batch_mode_cnt -= 1 - if not efuses.burn_all(check_batch_mode=True): - return - print("Successful") diff --git a/espefuse/efuse/esp32h2beta1/__init__.py b/espefuse/efuse/esp32h2beta1/__init__.py deleted file mode 100644 index a3b55a8023..0000000000 --- a/espefuse/efuse/esp32h2beta1/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -from . import operations -from .emulate_efuse_controller import EmulateEfuseController -from .fields import EspEfuses diff --git a/espefuse/efuse/esp32h2beta1/emulate_efuse_controller.py b/espefuse/efuse/esp32h2beta1/emulate_efuse_controller.py deleted file mode 100644 index 1c336cbfea..0000000000 --- a/espefuse/efuse/esp32h2beta1/emulate_efuse_controller.py +++ /dev/null @@ -1,92 +0,0 @@ -# This file describes eFuses controller for ESP32-H2 chip -# -# SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD -# -# SPDX-License-Identifier: GPL-2.0-or-later - -import reedsolo - -from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters -from ..emulate_efuse_controller_base import EmulateEfuseControllerBase, FatalError - - -class EmulateEfuseController(EmulateEfuseControllerBase): - """The class for virtual efuse operation. Using for HOST_TEST.""" - - CHIP_NAME = "ESP32-H2(beta1)" - mem = None - debug = False - - def __init__(self, efuse_file=None, debug=False): - self.Blocks = EfuseDefineBlocks - self.Fields = EfuseDefineFields(None) - self.REGS = EfuseDefineRegisters - super(EmulateEfuseController, self).__init__(efuse_file, debug) - self.write_reg(self.REGS.EFUSE_CMD_REG, 0) - - """ esptool method start >>""" - - def get_major_chip_version(self): - return 0 - - def get_minor_chip_version(self): - return 0 - - def get_crystal_freq(self): - return 32 # MHz (common for all chips) - - def get_security_info(self): - return { - "flags": 0, - "flash_crypt_cnt": 0, - "key_purposes": 0, - "chip_id": 0, - "api_version": 0, - } - - """ << esptool method end """ - - def handle_writing_event(self, addr, value): - if addr == self.REGS.EFUSE_CMD_REG: - if value & self.REGS.EFUSE_PGM_CMD: - self.copy_blocks_wr_regs_to_rd_regs(updated_block=(value >> 2) & 0xF) - self.clean_blocks_wr_regs() - self.check_rd_protection_area() - self.write_reg(addr, 0) - self.write_reg(self.REGS.EFUSE_CMD_REG, 0) - elif value == self.REGS.EFUSE_READ_CMD: - self.write_reg(addr, 0) - self.write_reg(self.REGS.EFUSE_CMD_REG, 0) - self.save_to_file() - - def get_bitlen_of_block(self, blk, wr=False): - if blk.id == 0: - if wr: - return 32 * 8 - else: - return 32 * blk.len - else: - if wr: - rs_coding = 32 * 3 - return 32 * 8 + rs_coding - else: - return 32 * blk.len - - def handle_coding_scheme(self, blk, data): - if blk.id != 0: - # CODING_SCHEME RS applied only for all blocks except BLK0. - coded_bytes = 12 - data.pos = coded_bytes * 8 - plain_data = data.readlist("32*uint:8")[::-1] - # takes 32 bytes - # apply RS encoding - rs = reedsolo.RSCodec(coded_bytes) - # 32 byte of data + 12 bytes RS - calc_encoded_data = list(rs.encode([x for x in plain_data])) - data.pos = 0 - if calc_encoded_data != data.readlist("44*uint:8")[::-1]: - raise FatalError("Error in coding scheme data") - data = data[coded_bytes * 8 :] - if blk.len < 8: - data = data[(8 - blk.len) * 32 :] - return data diff --git a/espefuse/efuse/esp32h2beta1/fields.py b/espefuse/efuse/esp32h2beta1/fields.py deleted file mode 100644 index 92e1d0392b..0000000000 --- a/espefuse/efuse/esp32h2beta1/fields.py +++ /dev/null @@ -1,465 +0,0 @@ -# This file describes eFuses for ESP32-H2 chip -# -# SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD -# -# SPDX-License-Identifier: GPL-2.0-or-later - -import binascii -import struct -import sys -import time - -from bitstring import BitArray - -import esptool - -import reedsolo - -from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters -from .. import base_fields -from .. import util - - -class EfuseBlock(base_fields.EfuseBlockBase): - def len_of_burn_unit(self): - # The writing register window is 8 registers for any blocks. - # len in bytes - return 8 * 4 - - def __init__(self, parent, param, skip_read=False): - parent.read_coding_scheme() - super(EfuseBlock, self).__init__(parent, param, skip_read=skip_read) - - def apply_coding_scheme(self): - data = self.get_raw(from_read=False)[::-1] - if len(data) < self.len_of_burn_unit(): - add_empty_bytes = self.len_of_burn_unit() - len(data) - data = data + (b"\x00" * add_empty_bytes) - if self.get_coding_scheme() == self.parent.REGS.CODING_SCHEME_RS: - # takes 32 bytes - # apply RS encoding - rs = reedsolo.RSCodec(12) - # 32 byte of data + 12 bytes RS - encoded_data = rs.encode([x for x in data]) - words = struct.unpack("<" + "I" * 11, encoded_data) - # returns 11 words (8 words of data + 3 words of RS coding) - else: - # takes 32 bytes - words = struct.unpack("<" + ("I" * (len(data) // 4)), data) - # returns 8 words - return words - - -class EspEfuses(base_fields.EspEfusesBase): - """ - Wrapper object to manage the efuse fields in a connected ESP bootloader - """ - - debug = False - do_not_confirm = False - - def __init__( - self, - esp, - skip_connect=False, - debug=False, - do_not_confirm=False, - extend_efuse_table=None, - ): - self.Blocks = EfuseDefineBlocks() - self.Fields = EfuseDefineFields(extend_efuse_table) - self.REGS = EfuseDefineRegisters - self.BURN_BLOCK_DATA_NAMES = self.Blocks.get_burn_block_data_names() - self.BLOCKS_FOR_KEYS = self.Blocks.get_blocks_for_keys() - self._esp = esp - self.debug = debug - self.do_not_confirm = do_not_confirm - if esp.CHIP_NAME != "ESP32-H2(beta1)": - raise esptool.FatalError( - "Expected the 'esp' param for ESP32-H2(beta1) chip but got for '%s'." - % (esp.CHIP_NAME) - ) - if not skip_connect: - flags = self._esp.get_security_info()["flags"] - GET_SECURITY_INFO_FLAG_SECURE_DOWNLOAD_ENABLE = 1 << 2 - if flags & GET_SECURITY_INFO_FLAG_SECURE_DOWNLOAD_ENABLE: - raise esptool.FatalError( - "Secure Download Mode is enabled. The tool can not read eFuses." - ) - self.blocks = [ - EfuseBlock(self, self.Blocks.get(block), skip_read=skip_connect) - for block in self.Blocks.BLOCKS - ] - if not skip_connect: - self.get_coding_scheme_warnings() - self.efuses = [EfuseField.convert(self, efuse) for efuse in self.Fields.EFUSES] - self.efuses += [ - EfuseField.convert(self, efuse) for efuse in self.Fields.KEYBLOCKS - ] - if skip_connect: - self.efuses += [ - EfuseField.convert(self, efuse) - for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES - ] - else: - if self.get_block_version() >= 2: - self.efuses += [ - EfuseField.convert(self, efuse) - for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES - ] - self.efuses += [ - EfuseField.convert(self, efuse) for efuse in self.Fields.CALC - ] - - def __getitem__(self, efuse_name): - """Return the efuse field with the given name""" - for e in self.efuses: - if efuse_name == e.name or any(x == efuse_name for x in e.alt_names): - return e - new_fields = False - for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES: - if efuse.name == efuse_name or any( - x == efuse_name for x in efuse.alt_names - ): - self.efuses += [ - EfuseField.convert(self, efuse) - for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES - ] - new_fields = True - if new_fields: - for e in self.efuses: - if efuse_name == e.name or any(x == efuse_name for x in e.alt_names): - return e - raise KeyError - - def read_coding_scheme(self): - self.coding_scheme = self.REGS.CODING_SCHEME_RS - - def print_status_regs(self): - print("") - self.blocks[0].print_block(self.blocks[0].err_bitarray, "err__regs", debug=True) - print( - "{:27} 0x{:08x}".format( - "EFUSE_RD_RS_ERR0_REG", self.read_reg(self.REGS.EFUSE_RD_RS_ERR0_REG) - ) - ) - print( - "{:27} 0x{:08x}".format( - "EFUSE_RD_RS_ERR1_REG", self.read_reg(self.REGS.EFUSE_RD_RS_ERR1_REG) - ) - ) - - def efuse_controller_setup(self): - self.set_efuse_timing() - self.clear_pgm_registers() - self.wait_efuse_idle() - - def write_efuses(self, block): - self.efuse_program(block) - return self.get_coding_scheme_warnings(silent=True) - - def clear_pgm_registers(self): - self.wait_efuse_idle() - for r in range( - self.REGS.EFUSE_PGM_DATA0_REG, self.REGS.EFUSE_PGM_DATA0_REG + 32, 4 - ): - self.write_reg(r, 0) - - def wait_efuse_idle(self): - deadline = time.time() + self.REGS.EFUSE_BURN_TIMEOUT - while time.time() < deadline: - cmds = self.REGS.EFUSE_PGM_CMD | self.REGS.EFUSE_READ_CMD - if self.read_reg(self.REGS.EFUSE_CMD_REG) & cmds == 0: - if self.read_reg(self.REGS.EFUSE_CMD_REG) & cmds == 0: - # Due to a hardware error, we have to read READ_CMD again - # to make sure the efuse clock is normal. - # For PGM_CMD it is not necessary. - return - raise esptool.FatalError( - "Timed out waiting for Efuse controller command to complete" - ) - - def efuse_program(self, block): - self.wait_efuse_idle() - self.write_reg(self.REGS.EFUSE_CONF_REG, self.REGS.EFUSE_WRITE_OP_CODE) - self.write_reg(self.REGS.EFUSE_CMD_REG, self.REGS.EFUSE_PGM_CMD | (block << 2)) - self.wait_efuse_idle() - self.clear_pgm_registers() - self.efuse_read() - - def efuse_read(self): - self.wait_efuse_idle() - self.write_reg(self.REGS.EFUSE_CONF_REG, self.REGS.EFUSE_READ_OP_CODE) - # need to add a delay after triggering EFUSE_READ_CMD, as ROM loader checks some - # efuse registers after each command is completed - # if ENABLE_SECURITY_DOWNLOAD or DIS_DOWNLOAD_MODE is enabled by the current cmd, then we need to try to reconnect to the chip. - try: - self.write_reg( - self.REGS.EFUSE_CMD_REG, self.REGS.EFUSE_READ_CMD, delay_after_us=1000 - ) - self.wait_efuse_idle() - except esptool.FatalError: - secure_download_mode_before = self._esp.secure_download_mode - - try: - self._esp = self.reconnect_chip(self._esp) - except esptool.FatalError: - print("Can not re-connect to the chip") - if not self["DIS_DOWNLOAD_MODE"].get() and self[ - "DIS_DOWNLOAD_MODE" - ].get(from_read=False): - print( - "This is the correct behavior as we are actually burning " - "DIS_DOWNLOAD_MODE which disables the connection to the chip" - ) - print("DIS_DOWNLOAD_MODE is enabled") - print("Successful") - sys.exit(0) # finish without errors - raise - - print("Established a connection with the chip") - if self._esp.secure_download_mode and not secure_download_mode_before: - print("Secure download mode is enabled") - if not self["ENABLE_SECURITY_DOWNLOAD"].get() and self[ - "ENABLE_SECURITY_DOWNLOAD" - ].get(from_read=False): - print( - "espefuse tool can not continue to work in Secure download mode" - ) - print("ENABLE_SECURITY_DOWNLOAD is enabled") - print("Successful") - sys.exit(0) # finish without errors - raise - - def set_efuse_timing(self): - """Set timing registers for burning efuses""" - # Configure clock - apb_freq = self.get_crystal_freq() - if apb_freq != 32: - raise esptool.FatalError( - "The eFuse supports only xtal=32M (xtal was %d)" % apb_freq - ) - - self.update_reg(self.REGS.EFUSE_DAC_CONF_REG, self.REGS.EFUSE_DAC_NUM_M, 0xFF) - self.update_reg( - self.REGS.EFUSE_DAC_CONF_REG, self.REGS.EFUSE_DAC_CLK_DIV_M, 0x28 - ) - self.update_reg( - self.REGS.EFUSE_WR_TIM_CONF1_REG, self.REGS.EFUSE_PWR_ON_NUM_M, 0x3000 - ) - self.update_reg( - self.REGS.EFUSE_WR_TIM_CONF2_REG, self.REGS.EFUSE_PWR_OFF_NUM_M, 0x190 - ) - - def get_coding_scheme_warnings(self, silent=False): - """Check if the coding scheme has detected any errors.""" - old_addr_reg = 0 - reg_value = 0 - ret_fail = False - for block in self.blocks: - if block.id == 0: - words = [ - self.read_reg(self.REGS.EFUSE_RD_REPEAT_ERR0_REG + offs * 4) - for offs in range(5) - ] - block.err_bitarray.pos = 0 - for word in reversed(words): - block.err_bitarray.overwrite(BitArray("uint:32=%d" % word)) - block.num_errors = block.err_bitarray.count(True) - block.fail = block.num_errors != 0 - else: - addr_reg, err_num_mask, err_num_offs, fail_bit = self.REGS.BLOCK_ERRORS[ - block.id - ] - if err_num_mask is None or err_num_offs is None or fail_bit is None: - continue - if addr_reg != old_addr_reg: - old_addr_reg = addr_reg - reg_value = self.read_reg(addr_reg) - block.fail = reg_value & (1 << fail_bit) != 0 - block.num_errors = (reg_value >> err_num_offs) & err_num_mask - ret_fail |= block.fail - if not silent and (block.fail or block.num_errors): - print( - "Error(s) in BLOCK%d [ERRORS:%d FAIL:%d]" - % (block.id, block.num_errors, block.fail) - ) - if (self.debug or ret_fail) and not silent: - self.print_status_regs() - return ret_fail - - def summary(self): - # TODO add support set_flash_voltage - "Flash voltage (VDD_SPI)" - return "" - - -class EfuseField(base_fields.EfuseFieldBase): - @staticmethod - def convert(parent, efuse): - return { - "mac": EfuseMacField, - "keypurpose": EfuseKeyPurposeField, - "t_sensor": EfuseTempSensor, - "adc_tp": EfuseAdcPointCalibration, - "wafer": EfuseWafer, - }.get(efuse.class_type, EfuseField)(parent, efuse) - - -class EfuseWafer(EfuseField): - def get(self, from_read=True): - hi_bits = self.parent["WAFER_VERSION_MINOR_HI"].get(from_read) - assert self.parent["WAFER_VERSION_MINOR_HI"].bit_len == 1 - lo_bits = self.parent["WAFER_VERSION_MINOR_LO"].get(from_read) - assert self.parent["WAFER_VERSION_MINOR_LO"].bit_len == 3 - return (hi_bits << 3) + lo_bits - - def save(self, new_value): - raise esptool.FatalError("Burning %s is not supported" % self.name) - - -class EfuseTempSensor(EfuseField): - def get(self, from_read=True): - value = self.get_bitstring(from_read) - sig = -1 if value[0] else 1 - return sig * value[1:].uint * 0.1 - - -class EfuseAdcPointCalibration(EfuseField): - def get(self, from_read=True): - STEP_SIZE = 4 - value = self.get_bitstring(from_read) - sig = -1 if value[0] else 1 - return sig * value[1:].uint * STEP_SIZE - - -class EfuseMacField(EfuseField): - def check_format(self, new_value_str): - if new_value_str is None: - raise esptool.FatalError( - "Required MAC Address in AA:CD:EF:01:02:03 format!" - ) - num_bytes = 8 if self.name == "MAC_EUI64" else 6 - if new_value_str.count(":") != num_bytes - 1: - raise esptool.FatalError( - f"MAC Address needs to be a {num_bytes}-byte hexadecimal format " - "separated by colons (:)!" - ) - hexad = new_value_str.replace(":", "").split(" ", 1)[0] - hexad = hexad.split(" ", 1)[0] if self.is_field_calculated() else hexad - if len(hexad) != num_bytes * 2: - raise esptool.FatalError( - f"MAC Address needs to be a {num_bytes}-byte hexadecimal number " - f"({num_bytes * 2} hexadecimal characters)!" - ) - # order of bytearray = b'\xaa\xcd\xef\x01\x02\x03', - bindata = binascii.unhexlify(hexad) - - if not self.is_field_calculated(): - # unicast address check according to - # https://tools.ietf.org/html/rfc7042#section-2.1 - if esptool.util.byte(bindata, 0) & 0x01: - raise esptool.FatalError("Custom MAC must be a unicast MAC!") - return bindata - - def check(self): - errs, fail = self.parent.get_block_errors(self.block) - if errs != 0 or fail: - output = "Block%d has ERRORS:%d FAIL:%d" % (self.block, errs, fail) - else: - output = "OK" - return "(" + output + ")" - - def get(self, from_read=True): - if self.name == "CUSTOM_MAC": - mac = self.get_raw(from_read)[::-1] - elif self.name == "MAC": - mac = self.get_raw(from_read) - elif self.name == "MAC_EUI64": - mac = self.parent["MAC"].get_bitstring(from_read).copy() - mac_ext = self.parent["MAC_EXT"].get_bitstring(from_read) - mac.insert(mac_ext, 24) - mac = mac.bytes - else: - mac = self.get_raw(from_read) - return "%s %s" % (util.hexify(mac, ":"), self.check()) - - def save(self, new_value): - def print_field(e, new_value): - print( - " - '{}' ({}) {} -> {}".format( - e.name, e.description, e.get_bitstring(), new_value - ) - ) - - if self.name == "CUSTOM_MAC": - bitarray_mac = self.convert_to_bitstring(new_value) - print_field(self, bitarray_mac) - super(EfuseMacField, self).save(new_value) - else: - # Writing the BLOCK1 (MAC_SPI_8M_0) default MAC is not possible, - # as it's written in the factory. - raise esptool.FatalError(f"Burning {self.name} is not supported") - raise esptool.FatalError("Writing Factory MAC address is not supported") - - -# fmt: off -class EfuseKeyPurposeField(EfuseField): - KEY_PURPOSES = [ - ("USER", 0, None, None, "no_need_rd_protect"), # User purposes (software-only use) - ("RESERVED", 1, None, None, "no_need_rd_protect"), # Reserved - ("XTS_AES_128_KEY", 4, None, "Reverse", "need_rd_protect"), # XTS_AES_128_KEY (flash/PSRAM encryption) - ("HMAC_DOWN_ALL", 5, None, None, "need_rd_protect"), # HMAC Downstream mode - ("HMAC_DOWN_JTAG", 6, None, None, "need_rd_protect"), # JTAG soft enable key (uses HMAC Downstream mode) - ("HMAC_DOWN_DIGITAL_SIGNATURE", 7, None, None, "need_rd_protect"), # Digital Signature peripheral key (uses HMAC Downstream mode) - ("HMAC_UP", 8, None, None, "need_rd_protect"), # HMAC Upstream mode - ("SECURE_BOOT_DIGEST0", 9, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST0 (Secure Boot key digest) - ("SECURE_BOOT_DIGEST1", 10, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST1 (Secure Boot key digest) - ("SECURE_BOOT_DIGEST2", 11, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST2 (Secure Boot key digest) - ] -# fmt: on - - KEY_PURPOSES_NAME = [name[0] for name in KEY_PURPOSES] - DIGEST_KEY_PURPOSES = [name[0] for name in KEY_PURPOSES if name[2] == "DIGEST"] - - def check_format(self, new_value_str): - # str convert to int: "XTS_AES_128_KEY" - > str(4) - # if int: 4 -> str(4) - raw_val = new_value_str - for purpose_name in self.KEY_PURPOSES: - if purpose_name[0] == new_value_str: - raw_val = str(purpose_name[1]) - break - if raw_val.isdigit(): - if int(raw_val) not in [p[1] for p in self.KEY_PURPOSES if p[1] > 0]: - raise esptool.FatalError("'%s' can not be set (value out of range)" % raw_val) - else: - raise esptool.FatalError("'%s' unknown name" % raw_val) - return raw_val - - def need_reverse(self, new_key_purpose): - for key in self.KEY_PURPOSES: - if key[0] == new_key_purpose: - return key[3] == "Reverse" - - def need_rd_protect(self, new_key_purpose): - for key in self.KEY_PURPOSES: - if key[0] == new_key_purpose: - return key[4] == "need_rd_protect" - - def get(self, from_read=True): - for p in self.KEY_PURPOSES: - if p[1] == self.get_raw(from_read): - return p[0] - return "FORBIDDEN_STATE" - - def get_name(self, raw_val): - for key in self.KEY_PURPOSES: - if key[1] == raw_val: - return key[0] - - def save(self, new_value): - raw_val = int(self.check_format(str(new_value))) - str_new_value = self.get_name(raw_val) - if self.name == "KEY_PURPOSE_5" and str_new_value.startswith("XTS_AES"): - raise esptool.FatalError(f"{self.name} can not have {str_new_value} key due to a hardware bug (please see TRM for more details)") - return super(EfuseKeyPurposeField, self).save(raw_val) diff --git a/espefuse/efuse/esp32h2beta1/mem_definition.py b/espefuse/efuse/esp32h2beta1/mem_definition.py deleted file mode 100644 index 360ae73b0a..0000000000 --- a/espefuse/efuse/esp32h2beta1/mem_definition.py +++ /dev/null @@ -1,152 +0,0 @@ -# This file describes eFuses fields and registers for ESP32-H2 chip -# -# SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD -# -# SPDX-License-Identifier: GPL-2.0-or-later - -import os - -import yaml - -from ..mem_definition_base import EfuseBlocksBase, EfuseFieldsBase, EfuseRegistersBase -from typing import List - - -class EfuseDefineRegisters(EfuseRegistersBase): - EFUSE_MEM_SIZE = 0x01FC + 4 - - # EFUSE registers & command/conf values - DR_REG_EFUSE_BASE = 0x6001A000 - EFUSE_PGM_DATA0_REG = DR_REG_EFUSE_BASE - EFUSE_CHECK_VALUE0_REG = DR_REG_EFUSE_BASE + 0x020 - EFUSE_CLK_REG = DR_REG_EFUSE_BASE + 0x1C8 - EFUSE_CONF_REG = DR_REG_EFUSE_BASE + 0x1CC - EFUSE_STATUS_REG = DR_REG_EFUSE_BASE + 0x1D0 - EFUSE_CMD_REG = DR_REG_EFUSE_BASE + 0x1D4 - EFUSE_RD_RS_ERR0_REG = DR_REG_EFUSE_BASE + 0x1C0 - EFUSE_RD_RS_ERR1_REG = DR_REG_EFUSE_BASE + 0x1C4 - EFUSE_RD_REPEAT_ERR0_REG = DR_REG_EFUSE_BASE + 0x17C - EFUSE_RD_REPEAT_ERR1_REG = DR_REG_EFUSE_BASE + 0x180 - EFUSE_RD_REPEAT_ERR2_REG = DR_REG_EFUSE_BASE + 0x184 - EFUSE_RD_REPEAT_ERR3_REG = DR_REG_EFUSE_BASE + 0x188 - EFUSE_RD_REPEAT_ERR4_REG = DR_REG_EFUSE_BASE + 0x18C - EFUSE_DAC_CONF_REG = DR_REG_EFUSE_BASE + 0x1E8 - EFUSE_RD_TIM_CONF_REG = DR_REG_EFUSE_BASE + 0x1EC - EFUSE_WR_TIM_CONF1_REG = DR_REG_EFUSE_BASE + 0x1F0 - EFUSE_WR_TIM_CONF2_REG = DR_REG_EFUSE_BASE + 0x1F4 - EFUSE_DATE_REG = DR_REG_EFUSE_BASE + 0x1FC - EFUSE_WRITE_OP_CODE = 0x5A5A - EFUSE_READ_OP_CODE = 0x5AA5 - EFUSE_PGM_CMD_MASK = 0x3 - EFUSE_PGM_CMD = 0x2 - EFUSE_READ_CMD = 0x1 - - BLOCK_ERRORS = [ - # error_reg, err_num_mask, err_num_offs, fail_bit - (EFUSE_RD_REPEAT_ERR0_REG, None, None, None), # BLOCK0 - (EFUSE_RD_RS_ERR0_REG, 0x7, 0, 3), # MAC_SPI_8M_0 - (EFUSE_RD_RS_ERR0_REG, 0x7, 4, 7), # BLOCK_SYS_DATA - (EFUSE_RD_RS_ERR0_REG, 0x7, 8, 11), # BLOCK_USR_DATA - (EFUSE_RD_RS_ERR0_REG, 0x7, 12, 15), # BLOCK_KEY0 - (EFUSE_RD_RS_ERR0_REG, 0x7, 16, 19), # BLOCK_KEY1 - (EFUSE_RD_RS_ERR0_REG, 0x7, 20, 23), # BLOCK_KEY2 - (EFUSE_RD_RS_ERR0_REG, 0x7, 24, 27), # BLOCK_KEY3 - (EFUSE_RD_RS_ERR0_REG, 0x7, 28, 31), # BLOCK_KEY4 - (EFUSE_RD_RS_ERR1_REG, 0x7, 0, 3), # BLOCK_KEY5 - (EFUSE_RD_RS_ERR1_REG, 0x7, 4, 7), # BLOCK_SYS_DATA2 - ] - - # EFUSE_WR_TIM_CONF2_REG - EFUSE_PWR_OFF_NUM_S = 0 - EFUSE_PWR_OFF_NUM_M = 0xFFFF << EFUSE_PWR_OFF_NUM_S - - # EFUSE_WR_TIM_CONF1_REG - EFUSE_PWR_ON_NUM_S = 8 - EFUSE_PWR_ON_NUM_M = 0x0000FFFF << EFUSE_PWR_ON_NUM_S - - # EFUSE_DAC_CONF_REG - EFUSE_DAC_CLK_DIV_S = 0 - EFUSE_DAC_CLK_DIV_M = 0xFF << EFUSE_DAC_CLK_DIV_S - - # EFUSE_DAC_CONF_REG - EFUSE_DAC_NUM_S = 9 - EFUSE_DAC_NUM_M = 0xFF << EFUSE_DAC_NUM_S - - -class EfuseDefineBlocks(EfuseBlocksBase): - __base_rd_regs = EfuseDefineRegisters.DR_REG_EFUSE_BASE - __base_wr_regs = EfuseDefineRegisters.EFUSE_PGM_DATA0_REG - # List of efuse blocks - # fmt: off - BLOCKS = [ - # Name, Alias, Index, Read address, Write address, Write protect bit, Read protect bit, Len, key_purpose - ("BLOCK0", [], 0, __base_rd_regs + 0x02C, __base_wr_regs, None, None, 6, None), - ("MAC_SPI_8M_0", ["BLOCK1"], 1, __base_rd_regs + 0x044, __base_wr_regs, 20, None, 6, None), - ("BLOCK_SYS_DATA", ["BLOCK2"], 2, __base_rd_regs + 0x05C, __base_wr_regs, 21, None, 8, None), - ("BLOCK_USR_DATA", ["BLOCK3"], 3, __base_rd_regs + 0x07C, __base_wr_regs, 22, None, 8, None), - ("BLOCK_KEY0", ["BLOCK4"], 4, __base_rd_regs + 0x09C, __base_wr_regs, 23, 0, 8, "KEY_PURPOSE_0"), - ("BLOCK_KEY1", ["BLOCK5"], 5, __base_rd_regs + 0x0BC, __base_wr_regs, 24, 1, 8, "KEY_PURPOSE_1"), - ("BLOCK_KEY2", ["BLOCK6"], 6, __base_rd_regs + 0x0DC, __base_wr_regs, 25, 2, 8, "KEY_PURPOSE_2"), - ("BLOCK_KEY3", ["BLOCK7"], 7, __base_rd_regs + 0x0FC, __base_wr_regs, 26, 3, 8, "KEY_PURPOSE_3"), - ("BLOCK_KEY4", ["BLOCK8"], 8, __base_rd_regs + 0x11C, __base_wr_regs, 27, 4, 8, "KEY_PURPOSE_4"), - ("BLOCK_KEY5", ["BLOCK9"], 9, __base_rd_regs + 0x13C, __base_wr_regs, 28, 5, 8, "KEY_PURPOSE_5"), - ("BLOCK_SYS_DATA2", ["BLOCK10"], 10, __base_rd_regs + 0x15C, __base_wr_regs, 29, 6, 8, None), - ] - # fmt: on - - def get_burn_block_data_names(self): - list_of_names = [] - for block in self.BLOCKS: - blk = self.get(block) - if blk.name: - list_of_names.append(blk.name) - if blk.alias: - for alias in blk.alias: - list_of_names.append(alias) - return list_of_names - - -class EfuseDefineFields(EfuseFieldsBase): - def __init__(self, extend_efuse_table) -> None: - # List of efuse fields from TRM the chapter eFuse Controller. - self.EFUSES = [] - self.KEYBLOCKS = [] - self.BLOCK2_CALIBRATION_EFUSES = [] - self.CALC: List = [] - - dir_name = os.path.dirname(os.path.abspath(__file__)) - dir_name, file_name = os.path.split(dir_name) - file_name = file_name + ".yaml" - dir_name, _ = os.path.split(dir_name) - efuse_file = os.path.join(dir_name, "efuse_defs", file_name) - efuse_file = efuse_file.replace("esp32h2beta1", "esp32h2") - with open(f"{efuse_file}", "r") as r_file: - e_desc = yaml.safe_load(r_file) - super().__init__(e_desc, extend_efuse_table) - - for i, efuse in enumerate(self.ALL_EFUSES): - if efuse.name in [ - "BLOCK_USR_DATA", - "BLOCK_KEY0", - "BLOCK_KEY1", - "BLOCK_KEY2", - "BLOCK_KEY3", - "BLOCK_KEY4", - "BLOCK_KEY5", - "BLOCK_SYS_DATA2", - ]: - if efuse.name == "BLOCK_USR_DATA": - efuse.bit_len = 256 - efuse.type = "bytes:32" - self.KEYBLOCKS.append(efuse) - self.ALL_EFUSES[i] = None - - elif efuse.category == "calibration": - self.BLOCK2_CALIBRATION_EFUSES.append(efuse) - self.ALL_EFUSES[i] = None - - for efuse in self.ALL_EFUSES: - if efuse is not None: - self.EFUSES.append(efuse) - - self.ALL_EFUSES = [] diff --git a/espefuse/efuse/esp32h2beta1/operations.py b/espefuse/efuse/esp32h2beta1/operations.py deleted file mode 100644 index 0058a33b90..0000000000 --- a/espefuse/efuse/esp32h2beta1/operations.py +++ /dev/null @@ -1,405 +0,0 @@ -# This file includes the operations with eFuses for ESP32-H2 chip -# -# SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD -# -# SPDX-License-Identifier: GPL-2.0-or-later - -import argparse -import os # noqa: F401. It is used in IDF scripts -import traceback - -import espsecure - -import esptool - -from . import fields -from .. import util -from ..base_operations import ( - add_common_commands, - add_force_write_always, - add_show_sensitive_info_option, - burn_bit, - burn_block_data, - burn_efuse, - check_error, - dump, - read_protect_efuse, - summary, - write_protect_efuse, -) - - -def protect_options(p): - p.add_argument( - "--no-write-protect", - help="Disable write-protecting of the key. The key remains writable. " - "(The keys use the RS coding scheme that does not support post-write " - "data changes. Forced write can damage RS encoding bits.) " - "The write-protecting of keypurposes does not depend on the option, " - "it will be set anyway.", - action="store_true", - ) - p.add_argument( - "--no-read-protect", - help="Disable read-protecting of the key. The key remains readable software." - "The key with keypurpose[USER, RESERVED and *_DIGEST] will remain " - "readable anyway. For the rest keypurposes the read-protection will be " - "defined the option (Read-protect by default).", - action="store_true", - ) - - -def add_commands(subparsers, efuses): - add_common_commands(subparsers, efuses) - burn_key = subparsers.add_parser( - "burn_key", help="Burn the key block with the specified name" - ) - protect_options(burn_key) - add_force_write_always(burn_key) - add_show_sensitive_info_option(burn_key) - burn_key.add_argument( - "block", - help="Key block to burn", - action="append", - choices=efuses.BLOCKS_FOR_KEYS, - ) - burn_key.add_argument( - "keyfile", - help="File containing 256 bits of binary key data", - action="append", - type=argparse.FileType("rb"), - ) - burn_key.add_argument( - "keypurpose", - help="Purpose to set.", - action="append", - choices=fields.EfuseKeyPurposeField.KEY_PURPOSES_NAME, - ) - for _ in efuses.BLOCKS_FOR_KEYS: - burn_key.add_argument( - "block", - help="Key block to burn", - nargs="?", - action="append", - metavar="BLOCK", - choices=efuses.BLOCKS_FOR_KEYS, - ) - burn_key.add_argument( - "keyfile", - help="File containing 256 bits of binary key data", - nargs="?", - action="append", - metavar="KEYFILE", - type=argparse.FileType("rb"), - ) - burn_key.add_argument( - "keypurpose", - help="Purpose to set.", - nargs="?", - action="append", - metavar="KEYPURPOSE", - choices=fields.EfuseKeyPurposeField.KEY_PURPOSES_NAME, - ) - - burn_key_digest = subparsers.add_parser( - "burn_key_digest", - help="Parse a RSA public key and burn the digest to key efuse block", - ) - protect_options(burn_key_digest) - add_force_write_always(burn_key_digest) - add_show_sensitive_info_option(burn_key_digest) - burn_key_digest.add_argument( - "block", - help="Key block to burn", - action="append", - choices=efuses.BLOCKS_FOR_KEYS, - ) - burn_key_digest.add_argument( - "keyfile", - help="Key file to digest (PEM format)", - action="append", - type=argparse.FileType("rb"), - ) - burn_key_digest.add_argument( - "keypurpose", - help="Purpose to set.", - action="append", - choices=fields.EfuseKeyPurposeField.DIGEST_KEY_PURPOSES, - ) - for _ in efuses.BLOCKS_FOR_KEYS: - burn_key_digest.add_argument( - "block", - help="Key block to burn", - nargs="?", - action="append", - metavar="BLOCK", - choices=efuses.BLOCKS_FOR_KEYS, - ) - burn_key_digest.add_argument( - "keyfile", - help="Key file to digest (PEM format)", - nargs="?", - action="append", - metavar="KEYFILE", - type=argparse.FileType("rb"), - ) - burn_key_digest.add_argument( - "keypurpose", - help="Purpose to set.", - nargs="?", - action="append", - metavar="KEYPURPOSE", - choices=fields.EfuseKeyPurposeField.DIGEST_KEY_PURPOSES, - ) - - p = subparsers.add_parser( - "set_flash_voltage", - help="Permanently set the internal flash voltage regulator " - "to either 1.8V, 3.3V or OFF. This means GPIO45 can be high or low " - "at reset without changing the flash voltage.", - ) - p.add_argument("voltage", help="Voltage selection", choices=["1.8V", "3.3V", "OFF"]) - - p = subparsers.add_parser( - "burn_custom_mac", help="Burn a 48-bit Custom MAC Address to EFUSE BLOCK3." - ) - p.add_argument( - "mac", - help="Custom MAC Address to burn given in hexadecimal format with bytes " - "separated by colons (e.g. AA:CD:EF:01:02:03).", - type=fields.base_fields.CheckArgValue(efuses, "CUSTOM_MAC"), - ) - add_force_write_always(p) - - p = subparsers.add_parser("get_custom_mac", help="Prints the Custom MAC Address.") - - -def burn_custom_mac(esp, efuses, args): - efuses["CUSTOM_MAC"].save(args.mac) - if not efuses.burn_all(check_batch_mode=True): - return - get_custom_mac(esp, efuses, args) - print("Successful") - - -def get_custom_mac(esp, efuses, args): - print("Custom MAC Address: {}".format(efuses["CUSTOM_MAC"].get())) - - -def set_flash_voltage(esp, efuses, args): - raise esptool.FatalError("set_flash_voltage is not supported!") - - -def adc_info(esp, efuses, args): - # fmt: off - print("Block version:", efuses.get_block_version()) - if efuses.get_block_version() >= 2: - print("Temperature Sensor Calibration = {}C".format(efuses["TEMP_CALIB"].get())) - print("") - print("ADC1:") - print("AVE_INITCODE_ATTEN0 = ", efuses["ADC1_AVE_INITCODE_ATTEN0"].get()) - print("AVE_INITCODE_ATTEN1 = ", efuses["ADC1_AVE_INITCODE_ATTEN1"].get()) - print("AVE_INITCODE_ATTEN2 = ", efuses["ADC1_AVE_INITCODE_ATTEN2"].get()) - print("AVE_INITCODE_ATTEN3 = ", efuses["ADC1_AVE_INITCODE_ATTEN3"].get()) - print("HI_DOUT_ATTEN0 = ", efuses["ADC1_HI_DOUT_ATTEN0"].get()) - print("HI_DOUT_ATTEN1 = ", efuses["ADC1_HI_DOUT_ATTEN1"].get()) - print("HI_DOUT_ATTEN2 = ", efuses["ADC1_HI_DOUT_ATTEN2"].get()) - print("HI_DOUT_ATTEN3 = ", efuses["ADC1_HI_DOUT_ATTEN3"].get()) - print("CH0_ATTEN0_INITCODE_DIFF = ", efuses["ADC1_CH0_ATTEN0_INITCODE_DIFF"].get()) - print("CH1_ATTEN0_INITCODE_DIFF = ", efuses["ADC1_CH1_ATTEN0_INITCODE_DIFF"].get()) - print("CH2_ATTEN0_INITCODE_DIFF = ", efuses["ADC1_CH2_ATTEN0_INITCODE_DIFF"].get()) - print("CH3_ATTEN0_INITCODE_DIFF = ", efuses["ADC1_CH3_ATTEN0_INITCODE_DIFF"].get()) - print("CH4_ATTEN0_INITCODE_DIFF = ", efuses["ADC1_CH4_ATTEN0_INITCODE_DIFF"].get()) - # fmt: on - - -def burn_key(esp, efuses, args, digest=None): - if digest is None: - datafile_list = args.keyfile[ - 0 : len([name for name in args.keyfile if name is not None]) : - ] - else: - datafile_list = digest[0 : len([name for name in digest if name is not None]) :] - efuses.force_write_always = args.force_write_always - block_name_list = args.block[ - 0 : len([name for name in args.block if name is not None]) : - ] - keypurpose_list = args.keypurpose[ - 0 : len([name for name in args.keypurpose if name is not None]) : - ] - - util.check_duplicate_name_in_list(block_name_list) - if len(block_name_list) != len(datafile_list) or len(block_name_list) != len( - keypurpose_list - ): - raise esptool.FatalError( - "The number of blocks (%d), datafile (%d) and keypurpose (%d) " - "should be the same." - % (len(block_name_list), len(datafile_list), len(keypurpose_list)) - ) - - print("Burn keys to blocks:") - for block_name, datafile, keypurpose in zip( - block_name_list, datafile_list, keypurpose_list - ): - efuse = None - for block in efuses.blocks: - if block_name == block.name or block_name in block.alias: - efuse = efuses[block.name] - if efuse is None: - raise esptool.FatalError("Unknown block name - %s" % (block_name)) - num_bytes = efuse.bit_len // 8 - - block_num = efuses.get_index_block_by_name(block_name) - block = efuses.blocks[block_num] - - if digest is None: - data = datafile.read() - else: - data = datafile - - print(" - %s" % (efuse.name), end=" ") - revers_msg = None - if efuses[block.key_purpose_name].need_reverse(keypurpose): - revers_msg = "\tReversing byte order for AES-XTS hardware peripheral" - data = data[::-1] - print( - "-> [{}]".format( - util.hexify(data, " ") - if args.show_sensitive_info - else " ".join(["??"] * len(data)) - ) - ) - if revers_msg: - print(revers_msg) - if len(data) != num_bytes: - raise esptool.FatalError( - "Incorrect key file size %d. Key file must be %d bytes (%d bits) " - "of raw binary key data." % (len(data), num_bytes, num_bytes * 8) - ) - - if efuses[block.key_purpose_name].need_rd_protect(keypurpose): - read_protect = False if args.no_read_protect else True - else: - read_protect = False - write_protect = not args.no_write_protect - - # using efuse instead of a block gives the advantage of checking it as the whole field. - efuse.save(data) - - disable_wr_protect_key_purpose = False - if efuses[block.key_purpose_name].get() != keypurpose: - if efuses[block.key_purpose_name].is_writeable(): - print( - "\t'%s': '%s' -> '%s'." - % ( - block.key_purpose_name, - efuses[block.key_purpose_name].get(), - keypurpose, - ) - ) - efuses[block.key_purpose_name].save(keypurpose) - disable_wr_protect_key_purpose = True - else: - raise esptool.FatalError( - "It is not possible to change '%s' to '%s' because write " - "protection bit is set." % (block.key_purpose_name, keypurpose) - ) - else: - print("\t'%s' is already '%s'." % (block.key_purpose_name, keypurpose)) - if efuses[block.key_purpose_name].is_writeable(): - disable_wr_protect_key_purpose = True - - if disable_wr_protect_key_purpose: - print("\tDisabling write to '%s'." % block.key_purpose_name) - efuses[block.key_purpose_name].disable_write() - - if read_protect: - print("\tDisabling read to key block") - efuse.disable_read() - - if write_protect: - print("\tDisabling write to key block") - efuse.disable_write() - print("") - - if not write_protect: - print("Keys will remain writeable (due to --no-write-protect)") - if args.no_read_protect: - print("Keys will remain readable (due to --no-read-protect)") - - if not efuses.burn_all(check_batch_mode=True): - return - print("Successful") - - -def burn_key_digest(esp, efuses, args): - digest_list = [] - datafile_list = args.keyfile[ - 0 : len([name for name in args.keyfile if name is not None]) : - ] - block_list = args.block[ - 0 : len([block for block in args.block if block is not None]) : - ] - for block_name, datafile in zip(block_list, datafile_list): - efuse = None - for block in efuses.blocks: - if block_name == block.name or block_name in block.alias: - efuse = efuses[block.name] - if efuse is None: - raise esptool.FatalError("Unknown block name - %s" % (block_name)) - num_bytes = efuse.bit_len // 8 - digest = espsecure._digest_sbv2_public_key(datafile) - if len(digest) != num_bytes: - raise esptool.FatalError( - "Incorrect digest size %d. Digest must be %d bytes (%d bits) of raw " - "binary key data." % (len(digest), num_bytes, num_bytes * 8) - ) - digest_list.append(digest) - burn_key(esp, efuses, args, digest=digest_list) - - -def espefuse(esp, efuses, args, command): - parser = argparse.ArgumentParser() - subparsers = parser.add_subparsers(dest="operation") - add_commands(subparsers, efuses) - try: - cmd_line_args = parser.parse_args(command.split()) - except SystemExit: - traceback.print_stack() - raise esptool.FatalError('"{}" - incorrect command'.format(command)) - if cmd_line_args.operation == "execute_scripts": - configfiles = cmd_line_args.configfiles - index = cmd_line_args.index - # copy arguments from args to cmd_line_args - vars(cmd_line_args).update(vars(args)) - if cmd_line_args.operation == "execute_scripts": - cmd_line_args.configfiles = configfiles - cmd_line_args.index = index - if cmd_line_args.operation is None: - parser.print_help() - parser.exit(1) - operation_func = globals()[cmd_line_args.operation] - # each 'operation' is a module-level function of the same name - operation_func(esp, efuses, cmd_line_args) - - -def execute_scripts(esp, efuses, args): - efuses.batch_mode_cnt += 1 - del args.operation - scripts = args.scripts - del args.scripts - - for file in scripts: - with open(file.name, "r") as file: - exec(compile(file.read(), file.name, "exec")) - - if args.debug: - for block in efuses.blocks: - data = block.get_bitstring(from_read=False) - block.print_block(data, "regs_for_burn", args.debug) - - efuses.batch_mode_cnt -= 1 - if not efuses.burn_all(check_batch_mode=True): - return - print("Successful") diff --git a/espefuse/efuse/esp32s3beta2/__init__.py b/espefuse/efuse/esp32s3beta2/__init__.py deleted file mode 100644 index a3b55a8023..0000000000 --- a/espefuse/efuse/esp32s3beta2/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -from . import operations -from .emulate_efuse_controller import EmulateEfuseController -from .fields import EspEfuses diff --git a/espefuse/efuse/esp32s3beta2/emulate_efuse_controller.py b/espefuse/efuse/esp32s3beta2/emulate_efuse_controller.py deleted file mode 100644 index 949fc562b9..0000000000 --- a/espefuse/efuse/esp32s3beta2/emulate_efuse_controller.py +++ /dev/null @@ -1,92 +0,0 @@ -# This file describes eFuses controller for ESP32-S3(beta2) chip -# -# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD -# -# SPDX-License-Identifier: GPL-2.0-or-later - -import reedsolo - -from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters -from ..emulate_efuse_controller_base import EmulateEfuseControllerBase, FatalError - - -class EmulateEfuseController(EmulateEfuseControllerBase): - """The class for virtual efuse operation. Using for HOST_TEST.""" - - CHIP_NAME = "ESP32-S3(beta2)" - mem = None - debug = False - - def __init__(self, efuse_file=None, debug=False): - self.Blocks = EfuseDefineBlocks - self.Fields = EfuseDefineFields(None) - self.REGS = EfuseDefineRegisters - super(EmulateEfuseController, self).__init__(efuse_file, debug) - self.write_reg(self.REGS.EFUSE_CMD_REG, 0) - - """ esptool method start >>""" - - def get_major_chip_version(self): - return 0 - - def get_minor_chip_version(self): - return 2 - - def get_crystal_freq(self): - return 40 # MHz (common for all chips) - - def get_security_info(self): - return { - "flags": 0, - "flash_crypt_cnt": 0, - "key_purposes": 0, - "chip_id": 0, - "api_version": 0, - } - - """ << esptool method end """ - - def handle_writing_event(self, addr, value): - if addr == self.REGS.EFUSE_CMD_REG: - if value & self.REGS.EFUSE_PGM_CMD: - self.copy_blocks_wr_regs_to_rd_regs(updated_block=(value >> 2) & 0xF) - self.clean_blocks_wr_regs() - self.check_rd_protection_area() - self.write_reg(addr, 0) - self.write_reg(self.REGS.EFUSE_CMD_REG, 0) - elif value == self.REGS.EFUSE_READ_CMD: - self.write_reg(addr, 0) - self.write_reg(self.REGS.EFUSE_CMD_REG, 0) - self.save_to_file() - - def get_bitlen_of_block(self, blk, wr=False): - if blk.id == 0: - if wr: - return 32 * 8 - else: - return 32 * blk.len - else: - if wr: - rs_coding = 32 * 3 - return 32 * 8 + rs_coding - else: - return 32 * blk.len - - def handle_coding_scheme(self, blk, data): - if blk.id != 0: - # CODING_SCHEME RS applied only for all blocks except BLK0. - coded_bytes = 12 - data.pos = coded_bytes * 8 - plain_data = data.readlist("32*uint:8")[::-1] - # takes 32 bytes - # apply RS encoding - rs = reedsolo.RSCodec(coded_bytes) - # 32 byte of data + 12 bytes RS - calc_encoded_data = list(rs.encode([x for x in plain_data])) - data.pos = 0 - if calc_encoded_data != data.readlist("44*uint:8")[::-1]: - raise FatalError("Error in coding scheme data") - data = data[coded_bytes * 8 :] - if blk.len < 8: - data = data[(8 - blk.len) * 32 :] - return data diff --git a/espefuse/efuse/esp32s3beta2/fields.py b/espefuse/efuse/esp32s3beta2/fields.py deleted file mode 100644 index b884ed74d5..0000000000 --- a/espefuse/efuse/esp32s3beta2/fields.py +++ /dev/null @@ -1,489 +0,0 @@ -# This file describes eFuses for ESP32-S3 chip -# -# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD -# -# SPDX-License-Identifier: GPL-2.0-or-later - -import binascii -import struct -import sys -import time - -from bitstring import BitArray - -import esptool - -import reedsolo - -from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters -from .. import base_fields -from .. import util - - -class EfuseBlock(base_fields.EfuseBlockBase): - def len_of_burn_unit(self): - # The writing register window is 8 registers for any blocks. - # len in bytes - return 8 * 4 - - def __init__(self, parent, param, skip_read=False): - parent.read_coding_scheme() - super(EfuseBlock, self).__init__(parent, param, skip_read=skip_read) - - def apply_coding_scheme(self): - data = self.get_raw(from_read=False)[::-1] - if len(data) < self.len_of_burn_unit(): - add_empty_bytes = self.len_of_burn_unit() - len(data) - data = data + (b"\x00" * add_empty_bytes) - if self.get_coding_scheme() == self.parent.REGS.CODING_SCHEME_RS: - # takes 32 bytes - # apply RS encoding - rs = reedsolo.RSCodec(12) - # 32 byte of data + 12 bytes RS - encoded_data = rs.encode([x for x in data]) - words = struct.unpack("<" + "I" * 11, encoded_data) - # returns 11 words (8 words of data + 3 words of RS coding) - else: - # takes 32 bytes - words = struct.unpack("<" + ("I" * (len(data) // 4)), data) - # returns 8 words - return words - - -class EspEfuses(base_fields.EspEfusesBase): - """ - Wrapper object to manage the efuse fields in a connected ESP bootloader - """ - - debug = False - do_not_confirm = False - - def __init__( - self, - esp, - skip_connect=False, - debug=False, - do_not_confirm=False, - extend_efuse_table=None, - ): - self.Blocks = EfuseDefineBlocks() - self.Fields = EfuseDefineFields(extend_efuse_table) - self.REGS = EfuseDefineRegisters - self.BURN_BLOCK_DATA_NAMES = self.Blocks.get_burn_block_data_names() - self.BLOCKS_FOR_KEYS = self.Blocks.get_blocks_for_keys() - self._esp = esp - self.debug = debug - self.do_not_confirm = do_not_confirm - if esp.CHIP_NAME != "ESP32-S3(beta2)": - raise esptool.FatalError( - "Expected the 'esp' param for ESP32-S3(beta2) chip but got for '%s'." - % (esp.CHIP_NAME) - ) - if not skip_connect: - flags = self._esp.get_security_info()["flags"] - GET_SECURITY_INFO_FLAG_SECURE_DOWNLOAD_ENABLE = 1 << 2 - if flags & GET_SECURITY_INFO_FLAG_SECURE_DOWNLOAD_ENABLE: - raise esptool.FatalError( - "Secure Download Mode is enabled. The tool can not read eFuses." - ) - self.blocks = [ - EfuseBlock(self, self.Blocks.get(block), skip_read=skip_connect) - for block in self.Blocks.BLOCKS - ] - if not skip_connect: - self.get_coding_scheme_warnings() - self.efuses = [EfuseField.convert(self, efuse) for efuse in self.Fields.EFUSES] - self.efuses += [ - EfuseField.convert(self, efuse) for efuse in self.Fields.KEYBLOCKS - ] - if skip_connect: - self.efuses += [ - EfuseField.convert(self, efuse) - for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES - ] - else: - if self.get_block_version() >= 100: - self.efuses += [ - EfuseField.convert(self, efuse) - for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES - ] - self.efuses += [ - EfuseField.convert(self, efuse) for efuse in self.Fields.CALC - ] - - def __getitem__(self, efuse_name): - """Return the efuse field with the given name""" - for e in self.efuses: - if efuse_name == e.name or any(x == efuse_name for x in e.alt_names): - return e - new_fields = False - for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES: - if efuse.name == efuse_name or any( - x == efuse_name for x in efuse.alt_names - ): - self.efuses += [ - EfuseField.convert(self, efuse) - for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES - ] - new_fields = True - if new_fields: - for e in self.efuses: - if efuse_name == e.name or any(x == efuse_name for x in e.alt_names): - return e - raise KeyError - - def read_coding_scheme(self): - self.coding_scheme = self.REGS.CODING_SCHEME_RS - - def print_status_regs(self): - print("") - self.blocks[0].print_block(self.blocks[0].err_bitarray, "err__regs", debug=True) - print( - "{:27} 0x{:08x}".format( - "EFUSE_RD_RS_ERR0_REG", self.read_reg(self.REGS.EFUSE_RD_RS_ERR0_REG) - ) - ) - print( - "{:27} 0x{:08x}".format( - "EFUSE_RD_RS_ERR1_REG", self.read_reg(self.REGS.EFUSE_RD_RS_ERR1_REG) - ) - ) - - def efuse_controller_setup(self): - self.set_efuse_timing() - self.clear_pgm_registers() - self.wait_efuse_idle() - - def write_efuses(self, block): - self.efuse_program(block) - return self.get_coding_scheme_warnings(silent=True) - - def clear_pgm_registers(self): - self.wait_efuse_idle() - for r in range( - self.REGS.EFUSE_PGM_DATA0_REG, self.REGS.EFUSE_PGM_DATA0_REG + 32, 4 - ): - self.write_reg(r, 0) - - def wait_efuse_idle(self): - deadline = time.time() + self.REGS.EFUSE_BURN_TIMEOUT - while time.time() < deadline: - cmds = self.REGS.EFUSE_PGM_CMD | self.REGS.EFUSE_READ_CMD - if self.read_reg(self.REGS.EFUSE_CMD_REG) & cmds == 0: - if self.read_reg(self.REGS.EFUSE_CMD_REG) & cmds == 0: - # Due to a hardware error, we have to read READ_CMD again - # to make sure the efuse clock is normal. - # For PGM_CMD it is not necessary. - return - raise esptool.FatalError( - "Timed out waiting for Efuse controller command to complete" - ) - - def efuse_program(self, block): - self.wait_efuse_idle() - self.write_reg(self.REGS.EFUSE_CONF_REG, self.REGS.EFUSE_WRITE_OP_CODE) - self.write_reg(self.REGS.EFUSE_CMD_REG, self.REGS.EFUSE_PGM_CMD | (block << 2)) - self.wait_efuse_idle() - self.clear_pgm_registers() - self.efuse_read() - - def efuse_read(self): - self.wait_efuse_idle() - self.write_reg(self.REGS.EFUSE_CONF_REG, self.REGS.EFUSE_READ_OP_CODE) - # need to add a delay after triggering EFUSE_READ_CMD, as ROM loader checks some - # efuse registers after each command is completed - # if ENABLE_SECURITY_DOWNLOAD or DIS_DOWNLOAD_MODE is enabled by the current cmd, then we need to try to reconnect to the chip. - try: - self.write_reg( - self.REGS.EFUSE_CMD_REG, self.REGS.EFUSE_READ_CMD, delay_after_us=1000 - ) - self.wait_efuse_idle() - except esptool.FatalError: - secure_download_mode_before = self._esp.secure_download_mode - - try: - self._esp = self.reconnect_chip(self._esp) - except esptool.FatalError: - print("Can not re-connect to the chip") - if not self["DIS_DOWNLOAD_MODE"].get() and self[ - "DIS_DOWNLOAD_MODE" - ].get(from_read=False): - print( - "This is the correct behavior as we are actually burning " - "DIS_DOWNLOAD_MODE which disables the connection to the chip" - ) - print("DIS_DOWNLOAD_MODE is enabled") - print("Successful") - sys.exit(0) # finish without errors - raise - - print("Established a connection with the chip") - if self._esp.secure_download_mode and not secure_download_mode_before: - print("Secure download mode is enabled") - if not self["ENABLE_SECURITY_DOWNLOAD"].get() and self[ - "ENABLE_SECURITY_DOWNLOAD" - ].get(from_read=False): - print( - "espefuse tool can not continue to work in Secure download mode" - ) - print("ENABLE_SECURITY_DOWNLOAD is enabled") - print("Successful") - sys.exit(0) # finish without errors - raise - - def set_efuse_timing(self): - """Set timing registers for burning efuses""" - # Configure clock - apb_freq = self.get_crystal_freq() - if apb_freq != 40: - raise esptool.FatalError( - "The eFuse supports only xtal=40M (xtal was %d)" % apb_freq - ) - - self.update_reg(self.REGS.EFUSE_DAC_CONF_REG, self.REGS.EFUSE_DAC_NUM_M, 0xFF) - self.update_reg( - self.REGS.EFUSE_DAC_CONF_REG, self.REGS.EFUSE_DAC_CLK_DIV_M, 0x28 - ) - self.update_reg( - self.REGS.EFUSE_WR_TIM_CONF1_REG, self.REGS.EFUSE_PWR_ON_NUM_M, 0x3000 - ) - self.update_reg( - self.REGS.EFUSE_WR_TIM_CONF2_REG, self.REGS.EFUSE_PWR_OFF_NUM_M, 0x190 - ) - - def get_coding_scheme_warnings(self, silent=False): - """Check if the coding scheme has detected any errors.""" - old_addr_reg = 0 - reg_value = 0 - ret_fail = False - for block in self.blocks: - if block.id == 0: - words = [ - self.read_reg(self.REGS.EFUSE_RD_REPEAT_ERR0_REG + offs * 4) - for offs in range(5) - ] - block.err_bitarray.pos = 0 - for word in reversed(words): - block.err_bitarray.overwrite(BitArray("uint:32=%d" % word)) - block.num_errors = block.err_bitarray.count(True) - block.fail = block.num_errors != 0 - else: - addr_reg, err_num_mask, err_num_offs, fail_bit = self.REGS.BLOCK_ERRORS[ - block.id - ] - if err_num_mask is None or err_num_offs is None or fail_bit is None: - continue - if addr_reg != old_addr_reg: - old_addr_reg = addr_reg - reg_value = self.read_reg(addr_reg) - block.fail = reg_value & (1 << fail_bit) != 0 - block.num_errors = (reg_value >> err_num_offs) & err_num_mask - ret_fail |= block.fail - if not silent and (block.fail or block.num_errors): - print( - "Error(s) in BLOCK%d [ERRORS:%d FAIL:%d]" - % (block.id, block.num_errors, block.fail) - ) - if (self.debug or ret_fail) and not silent: - self.print_status_regs() - return ret_fail - - def summary(self): - if self["VDD_SPI_FORCE"].get() == 0: - output = "Flash voltage (VDD_SPI) determined by GPIO45 on reset " - output += "(GPIO45=High: VDD_SPI pin is powered from internal 1.8V LDO\n" - output += "GPIO45=Low or NC: VDD_SPI pin is powered directly from " - output += "VDD3P3_RTC_IO via resistor Rspi. " - output += "Typically this voltage is 3.3 V)." - elif self["VDD_SPI_XPD"].get() == 0: - output = "Flash voltage (VDD_SPI) internal regulator disabled by efuse." - elif self["VDD_SPI_TIEH"].get() == 0: - output = "Flash voltage (VDD_SPI) set to 1.8V by efuse." - else: - output = "Flash voltage (VDD_SPI) set to 3.3V by efuse." - return output - - def is_efuses_incompatible_for_burn(self): - # getting chip version: self._esp.get_chip_revision() - if ( - ( - self["DIS_USB_JTAG"].get(from_read=True) - and self["DIS_USB_SERIAL_JTAG"].get(from_read=False) - ) - or ( - self["DIS_USB_JTAG"].get(from_read=False) - and self["DIS_USB_SERIAL_JTAG"].get(from_read=True) - ) - or ( - self["DIS_USB_JTAG"].get(from_read=False) - and self["DIS_USB_SERIAL_JTAG"].get(from_read=False) - ) - ): - print( - "DIS_USB_JTAG and DIS_USB_SERIAL_JTAG cannot be set together due to a bug in the ROM bootloader" - ) - return True - return False - - -class EfuseField(base_fields.EfuseFieldBase): - @staticmethod - def convert(parent, efuse): - return { - "mac": EfuseMacField, - "keypurpose": EfuseKeyPurposeField, - "t_sensor": EfuseTempSensor, - "adc_tp": EfuseAdcPointCalibration, - "wafer": EfuseWafer, - }.get(efuse.class_type, EfuseField)(parent, efuse) - - -class EfuseWafer(EfuseField): - def get(self, from_read=True): - hi_bits = self.parent["WAFER_VERSION_MINOR_HI"].get(from_read) - assert self.parent["WAFER_VERSION_MINOR_HI"].bit_len == 1 - lo_bits = self.parent["WAFER_VERSION_MINOR_LO"].get(from_read) - assert self.parent["WAFER_VERSION_MINOR_LO"].bit_len == 3 - return (hi_bits << 3) + lo_bits - - def save(self, new_value): - raise esptool.FatalError("Burning %s is not supported" % self.name) - - -class EfuseTempSensor(EfuseField): - def get(self, from_read=True): - value = self.get_bitstring(from_read) - sig = -1 if value[0] else 1 - return sig * value[1:].uint * 0.1 - - -class EfuseAdcPointCalibration(EfuseField): - def get(self, from_read=True): - STEP_SIZE = 4 - value = self.get_bitstring(from_read) - sig = -1 if value[0] else 1 - return sig * value[1:].uint * STEP_SIZE - - -class EfuseMacField(EfuseField): - def check_format(self, new_value_str): - if new_value_str is None: - raise esptool.FatalError( - "Required MAC Address in AA:CD:EF:01:02:03 format!" - ) - if new_value_str.count(":") != 5: - raise esptool.FatalError( - "MAC Address needs to be a 6-byte hexadecimal format " - "separated by colons (:)!" - ) - hexad = new_value_str.replace(":", "") - if len(hexad) != 12: - raise esptool.FatalError( - "MAC Address needs to be a 6-byte hexadecimal number " - "(12 hexadecimal characters)!" - ) - # order of bytearray = b'\xaa\xcd\xef\x01\x02\x03', - bindata = binascii.unhexlify(hexad) - # unicast address check according to - # https://tools.ietf.org/html/rfc7042#section-2.1 - if esptool.util.byte(bindata, 0) & 0x01: - raise esptool.FatalError("Custom MAC must be a unicast MAC!") - return bindata - - def check(self): - errs, fail = self.parent.get_block_errors(self.block) - if errs != 0 or fail: - output = "Block%d has ERRORS:%d FAIL:%d" % (self.block, errs, fail) - else: - output = "OK" - return "(" + output + ")" - - def get(self, from_read=True): - if self.name == "CUSTOM_MAC": - mac = self.get_raw(from_read)[::-1] - else: - mac = self.get_raw(from_read) - return "%s %s" % (util.hexify(mac, ":"), self.check()) - - def save(self, new_value): - def print_field(e, new_value): - print( - " - '{}' ({}) {} -> {}".format( - e.name, e.description, e.get_bitstring(), new_value - ) - ) - - if self.name == "CUSTOM_MAC": - bitarray_mac = self.convert_to_bitstring(new_value) - print_field(self, bitarray_mac) - super(EfuseMacField, self).save(new_value) - else: - # Writing the BLOCK1 (MAC_SPI_8M_0) default MAC is not possible, - # as it's written in the factory. - raise esptool.FatalError("Writing Factory MAC address is not supported") - - -# fmt: off -class EfuseKeyPurposeField(EfuseField): - KEY_PURPOSES = [ - ("USER", 0, None, None, "no_need_rd_protect"), # User purposes (software-only use) - ("RESERVED", 1, None, None, "no_need_rd_protect"), # Reserved - ("XTS_AES_256_KEY_1", 2, None, "Reverse", "need_rd_protect"), # XTS_AES_256_KEY_1 (flash/PSRAM encryption) - ("XTS_AES_256_KEY_2", 3, None, "Reverse", "need_rd_protect"), # XTS_AES_256_KEY_2 (flash/PSRAM encryption) - ("XTS_AES_128_KEY", 4, None, "Reverse", "need_rd_protect"), # XTS_AES_128_KEY (flash/PSRAM encryption) - ("HMAC_DOWN_ALL", 5, None, None, "need_rd_protect"), # HMAC Downstream mode - ("HMAC_DOWN_JTAG", 6, None, None, "need_rd_protect"), # JTAG soft enable key (uses HMAC Downstream mode) - ("HMAC_DOWN_DIGITAL_SIGNATURE", 7, None, None, "need_rd_protect"), # Digital Signature peripheral key (uses HMAC Downstream mode) - ("HMAC_UP", 8, None, None, "need_rd_protect"), # HMAC Upstream mode - ("SECURE_BOOT_DIGEST0", 9, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST0 (Secure Boot key digest) - ("SECURE_BOOT_DIGEST1", 10, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST1 (Secure Boot key digest) - ("SECURE_BOOT_DIGEST2", 11, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST2 (Secure Boot key digest) - ("XTS_AES_256_KEY", -1, "VIRTUAL", None, "no_need_rd_protect"), # Virtual purpose splits to XTS_AES_256_KEY_1 and XTS_AES_256_KEY_2 - ] -# fmt: on - - KEY_PURPOSES_NAME = [name[0] for name in KEY_PURPOSES] - DIGEST_KEY_PURPOSES = [name[0] for name in KEY_PURPOSES if name[2] == "DIGEST"] - - def check_format(self, new_value_str): - # str convert to int: "XTS_AES_128_KEY" - > str(4) - # if int: 4 -> str(4) - raw_val = new_value_str - for purpose_name in self.KEY_PURPOSES: - if purpose_name[0] == new_value_str: - raw_val = str(purpose_name[1]) - break - if raw_val.isdigit(): - if int(raw_val) not in [p[1] for p in self.KEY_PURPOSES if p[1] > 0]: - raise esptool.FatalError("'%s' can not be set (value out of range)" % raw_val) - else: - raise esptool.FatalError("'%s' unknown name" % raw_val) - return raw_val - - def need_reverse(self, new_key_purpose): - for key in self.KEY_PURPOSES: - if key[0] == new_key_purpose: - return key[3] == "Reverse" - - def need_rd_protect(self, new_key_purpose): - for key in self.KEY_PURPOSES: - if key[0] == new_key_purpose: - return key[4] == "need_rd_protect" - - def get(self, from_read=True): - for p in self.KEY_PURPOSES: - if p[1] == self.get_raw(from_read): - return p[0] - return "FORBIDDEN_STATE" - - def get_name(self, raw_val): - for key in self.KEY_PURPOSES: - if key[1] == raw_val: - return key[0] - - def save(self, new_value): - raw_val = int(self.check_format(str(new_value))) - str_new_value = self.get_name(raw_val) - if self.name == "KEY_PURPOSE_5" and str_new_value.startswith("XTS_AES"): - raise esptool.FatalError(f"{self.name} can not have {str_new_value} key due to a hardware bug (please see TRM for more details)") - return super(EfuseKeyPurposeField, self).save(raw_val) diff --git a/espefuse/efuse/esp32s3beta2/mem_definition.py b/espefuse/efuse/esp32s3beta2/mem_definition.py deleted file mode 100644 index 0bba61c485..0000000000 --- a/espefuse/efuse/esp32s3beta2/mem_definition.py +++ /dev/null @@ -1,167 +0,0 @@ -# This file describes eFuses fields and registers for ESP32-S3(beta2) chip -# -# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD -# -# SPDX-License-Identifier: GPL-2.0-or-later - -import os - -import yaml - -from ..mem_definition_base import ( - EfuseBlocksBase, - EfuseFieldsBase, - EfuseRegistersBase, - Field, -) - - -class EfuseDefineRegisters(EfuseRegistersBase): - EFUSE_ADDR_MASK = 0x00000FFF - EFUSE_MEM_SIZE = 0x01FC + 4 - - # EFUSE registers & command/conf values - DR_REG_EFUSE_BASE = 0x6001A000 - EFUSE_PGM_DATA0_REG = DR_REG_EFUSE_BASE - EFUSE_CHECK_VALUE0_REG = DR_REG_EFUSE_BASE + 0x020 - EFUSE_CLK_REG = DR_REG_EFUSE_BASE + 0x1C8 - EFUSE_CONF_REG = DR_REG_EFUSE_BASE + 0x1CC - EFUSE_STATUS_REG = DR_REG_EFUSE_BASE + 0x1D0 - EFUSE_CMD_REG = DR_REG_EFUSE_BASE + 0x1D4 - EFUSE_RD_RS_ERR0_REG = DR_REG_EFUSE_BASE + 0x1C0 - EFUSE_RD_RS_ERR1_REG = DR_REG_EFUSE_BASE + 0x1C4 - EFUSE_RD_REPEAT_ERR0_REG = DR_REG_EFUSE_BASE + 0x17C - EFUSE_RD_REPEAT_ERR1_REG = DR_REG_EFUSE_BASE + 0x180 - EFUSE_RD_REPEAT_ERR2_REG = DR_REG_EFUSE_BASE + 0x184 - EFUSE_RD_REPEAT_ERR3_REG = DR_REG_EFUSE_BASE + 0x188 - EFUSE_RD_REPEAT_ERR4_REG = DR_REG_EFUSE_BASE + 0x18C - EFUSE_DAC_CONF_REG = DR_REG_EFUSE_BASE + 0x1E8 - EFUSE_RD_TIM_CONF_REG = DR_REG_EFUSE_BASE + 0x1EC - EFUSE_WR_TIM_CONF1_REG = DR_REG_EFUSE_BASE + 0x1F4 - EFUSE_WR_TIM_CONF2_REG = DR_REG_EFUSE_BASE + 0x1F8 - EFUSE_DATE_REG = DR_REG_EFUSE_BASE + 0x1FC - EFUSE_WRITE_OP_CODE = 0x5A5A - EFUSE_READ_OP_CODE = 0x5AA5 - EFUSE_PGM_CMD_MASK = 0x3 - EFUSE_PGM_CMD = 0x2 - EFUSE_READ_CMD = 0x1 - - BLOCK_ERRORS = [ - # error_reg, err_num_mask, err_num_offs, fail_bit - (EFUSE_RD_REPEAT_ERR0_REG, None, None, None), # BLOCK0 - (EFUSE_RD_RS_ERR0_REG, 0x7, 0, 3), # MAC_SPI_8M_0 - (EFUSE_RD_RS_ERR0_REG, 0x7, 4, 7), # BLOCK_SYS_DATA - (EFUSE_RD_RS_ERR0_REG, 0x7, 8, 11), # BLOCK_USR_DATA - (EFUSE_RD_RS_ERR0_REG, 0x7, 12, 15), # BLOCK_KEY0 - (EFUSE_RD_RS_ERR0_REG, 0x7, 16, 19), # BLOCK_KEY1 - (EFUSE_RD_RS_ERR0_REG, 0x7, 20, 23), # BLOCK_KEY2 - (EFUSE_RD_RS_ERR0_REG, 0x7, 24, 27), # BLOCK_KEY3 - (EFUSE_RD_RS_ERR0_REG, 0x7, 28, 31), # BLOCK_KEY4 - (EFUSE_RD_RS_ERR1_REG, 0x7, 0, 3), # BLOCK_KEY5 - (EFUSE_RD_RS_ERR1_REG, 0x7, 4, 7), # BLOCK_SYS_DATA2 - ] - - # EFUSE_WR_TIM_CONF2_REG - EFUSE_PWR_OFF_NUM_S = 0 - EFUSE_PWR_OFF_NUM_M = 0xFFFF << EFUSE_PWR_OFF_NUM_S - - # EFUSE_WR_TIM_CONF1_REG - EFUSE_PWR_ON_NUM_S = 8 - EFUSE_PWR_ON_NUM_M = 0x0000FFFF << EFUSE_PWR_ON_NUM_S - - # EFUSE_DAC_CONF_REG - EFUSE_DAC_CLK_DIV_S = 0 - EFUSE_DAC_CLK_DIV_M = 0xFF << EFUSE_DAC_CLK_DIV_S - - # EFUSE_DAC_CONF_REG - EFUSE_DAC_NUM_S = 9 - EFUSE_DAC_NUM_M = 0xFF << EFUSE_DAC_NUM_S - - -class EfuseDefineBlocks(EfuseBlocksBase): - __base_rd_regs = EfuseDefineRegisters.DR_REG_EFUSE_BASE - __base_wr_regs = EfuseDefineRegisters.EFUSE_PGM_DATA0_REG - # List of efuse blocks - # fmt: off - BLOCKS = [ - # Name, Alias, Index, Read address, Write address, Write protect bit, Read protect bit, Len, key_purpose - ("BLOCK0", [], 0, __base_rd_regs + 0x02C, __base_wr_regs, None, None, 6, None), - ("MAC_SPI_8M_0", ["BLOCK1"], 1, __base_rd_regs + 0x044, __base_wr_regs, 20, None, 6, None), - ("BLOCK_SYS_DATA", ["BLOCK2"], 2, __base_rd_regs + 0x05C, __base_wr_regs, 21, None, 8, None), - ("BLOCK_USR_DATA", ["BLOCK3"], 3, __base_rd_regs + 0x07C, __base_wr_regs, 22, None, 8, None), - ("BLOCK_KEY0", ["BLOCK4"], 4, __base_rd_regs + 0x09C, __base_wr_regs, 23, 0, 8, "KEY_PURPOSE_0"), - ("BLOCK_KEY1", ["BLOCK5"], 5, __base_rd_regs + 0x0BC, __base_wr_regs, 24, 1, 8, "KEY_PURPOSE_1"), - ("BLOCK_KEY2", ["BLOCK6"], 6, __base_rd_regs + 0x0DC, __base_wr_regs, 25, 2, 8, "KEY_PURPOSE_2"), - ("BLOCK_KEY3", ["BLOCK7"], 7, __base_rd_regs + 0x0FC, __base_wr_regs, 26, 3, 8, "KEY_PURPOSE_3"), - ("BLOCK_KEY4", ["BLOCK8"], 8, __base_rd_regs + 0x11C, __base_wr_regs, 27, 4, 8, "KEY_PURPOSE_4"), - ("BLOCK_KEY5", ["BLOCK9"], 9, __base_rd_regs + 0x13C, __base_wr_regs, 28, 5, 8, "KEY_PURPOSE_5"), - ("BLOCK_SYS_DATA2", ["BLOCK10"], 10, __base_rd_regs + 0x15C, __base_wr_regs, 29, 6, 8, None), - ] - # fmt: on - - def get_burn_block_data_names(self): - list_of_names = [] - for block in self.BLOCKS: - blk = self.get(block) - if blk.name: - list_of_names.append(blk.name) - if blk.alias: - for alias in blk.alias: - list_of_names.append(alias) - return list_of_names - - -class EfuseDefineFields(EfuseFieldsBase): - def __init__(self, extend_efuse_table) -> None: - # List of efuse fields from TRM the chapter eFuse Controller. - self.EFUSES = [] - self.KEYBLOCKS = [] - self.BLOCK2_CALIBRATION_EFUSES = [] - self.CALC = [] - - dir_name = os.path.dirname(os.path.abspath(__file__)) - dir_name, file_name = os.path.split(dir_name) - file_name = file_name + ".yaml" - dir_name, _ = os.path.split(dir_name) - efuse_file = os.path.join(dir_name, "efuse_defs", file_name) - efuse_file = efuse_file.replace("esp32s3beta2", "esp32s3") - with open(f"{efuse_file}", "r") as r_file: - e_desc = yaml.safe_load(r_file) - super().__init__(e_desc, extend_efuse_table) - - for i, efuse in enumerate(self.ALL_EFUSES): - if efuse.name in [ - "BLOCK_USR_DATA", - "BLOCK_KEY0", - "BLOCK_KEY1", - "BLOCK_KEY2", - "BLOCK_KEY3", - "BLOCK_KEY4", - "BLOCK_KEY5", - "BLOCK_SYS_DATA2", - ]: - if efuse.name == "BLOCK_USR_DATA": - efuse.bit_len = 256 - efuse.type = "bytes:32" - self.KEYBLOCKS.append(efuse) - self.ALL_EFUSES[i] = None - - elif efuse.category == "calibration": - self.BLOCK2_CALIBRATION_EFUSES.append(efuse) - self.ALL_EFUSES[i] = None - - f = Field() - f.name = "WAFER_VERSION_MINOR" - f.block = 0 - f.bit_len = 4 - f.type = f"uint:{f.bit_len}" - f.category = "identity" - f.class_type = "wafer" - f.description = "calc WAFER VERSION MINOR = WAFER_VERSION_MINOR_HI << 3 + WAFER_VERSION_MINOR_LO (read only)" - self.CALC.append(f) - - for efuse in self.ALL_EFUSES: - if efuse is not None: - self.EFUSES.append(efuse) - - self.ALL_EFUSES = [] diff --git a/espefuse/efuse/esp32s3beta2/operations.py b/espefuse/efuse/esp32s3beta2/operations.py deleted file mode 100644 index 3b45e79d62..0000000000 --- a/espefuse/efuse/esp32s3beta2/operations.py +++ /dev/null @@ -1,519 +0,0 @@ -# This file includes the operations with eFuses for ESP32-S3(beta2) chip -# -# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD -# -# SPDX-License-Identifier: GPL-2.0-or-later - -import argparse -import io -import os # noqa: F401. It is used in IDF scripts -import traceback - -import espsecure - -import esptool - -from . import fields -from .. import util -from ..base_operations import ( - add_common_commands, - add_force_write_always, - add_show_sensitive_info_option, - burn_bit, - burn_block_data, - burn_efuse, - check_error, - dump, - read_protect_efuse, - summary, - write_protect_efuse, -) - - -def protect_options(p): - p.add_argument( - "--no-write-protect", - help="Disable write-protecting of the key. The key remains writable. " - "(The keys use the RS coding scheme that does not support post-write " - "data changes. Forced write can damage RS encoding bits.) " - "The write-protecting of keypurposes does not depend on the option, " - "it will be set anyway.", - action="store_true", - ) - p.add_argument( - "--no-read-protect", - help="Disable read-protecting of the key. The key remains readable software." - "The key with keypurpose[USER, RESERVED and *_DIGEST] " - "will remain readable anyway. " - "For the rest keypurposes the read-protection will be defined the option " - "(Read-protect by default).", - action="store_true", - ) - - -def add_commands(subparsers, efuses): - add_common_commands(subparsers, efuses) - burn_key = subparsers.add_parser( - "burn_key", help="Burn the key block with the specified name" - ) - protect_options(burn_key) - add_force_write_always(burn_key) - add_show_sensitive_info_option(burn_key) - burn_key.add_argument( - "block", - help="Key block to burn", - action="append", - choices=efuses.BLOCKS_FOR_KEYS, - ) - burn_key.add_argument( - "keyfile", - help="File containing 256 bits of binary key data", - action="append", - type=argparse.FileType("rb"), - ) - burn_key.add_argument( - "keypurpose", - help="Purpose to set.", - action="append", - choices=fields.EfuseKeyPurposeField.KEY_PURPOSES_NAME, - ) - for _ in efuses.BLOCKS_FOR_KEYS: - burn_key.add_argument( - "block", - help="Key block to burn", - nargs="?", - action="append", - metavar="BLOCK", - choices=efuses.BLOCKS_FOR_KEYS, - ) - burn_key.add_argument( - "keyfile", - help="File containing 256 bits of binary key data", - nargs="?", - action="append", - metavar="KEYFILE", - type=argparse.FileType("rb"), - ) - burn_key.add_argument( - "keypurpose", - help="Purpose to set.", - nargs="?", - action="append", - metavar="KEYPURPOSE", - choices=fields.EfuseKeyPurposeField.KEY_PURPOSES_NAME, - ) - - burn_key_digest = subparsers.add_parser( - "burn_key_digest", - help="Parse a RSA public key and burn the digest to key efuse block", - ) - protect_options(burn_key_digest) - add_force_write_always(burn_key_digest) - add_show_sensitive_info_option(burn_key_digest) - burn_key_digest.add_argument( - "block", - help="Key block to burn", - action="append", - choices=efuses.BLOCKS_FOR_KEYS, - ) - burn_key_digest.add_argument( - "keyfile", - help="Key file to digest (PEM format)", - action="append", - type=argparse.FileType("rb"), - ) - burn_key_digest.add_argument( - "keypurpose", - help="Purpose to set.", - action="append", - choices=fields.EfuseKeyPurposeField.DIGEST_KEY_PURPOSES, - ) - for _ in efuses.BLOCKS_FOR_KEYS: - burn_key_digest.add_argument( - "block", - help="Key block to burn", - nargs="?", - action="append", - metavar="BLOCK", - choices=efuses.BLOCKS_FOR_KEYS, - ) - burn_key_digest.add_argument( - "keyfile", - help="Key file to digest (PEM format)", - nargs="?", - action="append", - metavar="KEYFILE", - type=argparse.FileType("rb"), - ) - burn_key_digest.add_argument( - "keypurpose", - help="Purpose to set.", - nargs="?", - action="append", - metavar="KEYPURPOSE", - choices=fields.EfuseKeyPurposeField.DIGEST_KEY_PURPOSES, - ) - - p = subparsers.add_parser( - "set_flash_voltage", - help="Permanently set the internal flash voltage regulator " - "to either 1.8V, 3.3V or OFF. This means GPIO45 can be high or low at reset " - "without changing the flash voltage.", - ) - p.add_argument("voltage", help="Voltage selection", choices=["1.8V", "3.3V", "OFF"]) - - p = subparsers.add_parser( - "burn_custom_mac", help="Burn a 48-bit Custom MAC Address to EFUSE BLOCK3." - ) - p.add_argument( - "mac", - help="Custom MAC Address to burn given in hexadecimal format with bytes " - "separated by colons (e.g. AA:CD:EF:01:02:03).", - type=fields.base_fields.CheckArgValue(efuses, "CUSTOM_MAC"), - ) - add_force_write_always(p) - - p = subparsers.add_parser("get_custom_mac", help="Prints the Custom MAC Address.") - - -def burn_custom_mac(esp, efuses, args): - efuses["CUSTOM_MAC"].save(args.mac) - if not efuses.burn_all(check_batch_mode=True): - return - get_custom_mac(esp, efuses, args) - print("Successful") - - -def get_custom_mac(esp, efuses, args): - print("Custom MAC Address: {}".format(efuses["CUSTOM_MAC"].get())) - - -def set_flash_voltage(esp, efuses, args): - sdio_force = efuses["VDD_SPI_FORCE"] - sdio_tieh = efuses["VDD_SPI_TIEH"] - sdio_reg = efuses["VDD_SPI_XPD"] - - # check efuses aren't burned in a way which makes this impossible - if args.voltage == "OFF" and sdio_reg.get() != 0: - raise esptool.FatalError( - "Can't set flash regulator to OFF as VDD_SPI_XPD efuse is already burned" - ) - - if args.voltage == "1.8V" and sdio_tieh.get() != 0: - raise esptool.FatalError( - "Can't set regulator to 1.8V is VDD_SPI_TIEH efuse is already burned" - ) - - if args.voltage == "OFF": - msg = "Disable internal flash voltage regulator (VDD_SPI). " - "SPI flash will need to be powered from an external source.\n" - "The following efuse is burned: VDD_SPI_FORCE.\n" - "It is possible to later re-enable the internal regulator (%s) " % ( - "to 3.3V" if sdio_tieh.get() != 0 else "to 1.8V or 3.3V" - ) - "by burning an additional efuse" - elif args.voltage == "1.8V": - msg = "Set internal flash voltage regulator (VDD_SPI) to 1.8V.\n" - "The following efuses are burned: VDD_SPI_FORCE, VDD_SPI_XPD.\n" - "It is possible to later increase the voltage to 3.3V (permanently) " - "by burning additional efuse VDD_SPI_TIEH" - elif args.voltage == "3.3V": - msg = "Enable internal flash voltage regulator (VDD_SPI) to 3.3V.\n" - "The following efuses are burned: VDD_SPI_FORCE, VDD_SPI_XPD, VDD_SPI_TIEH." - print(msg) - - sdio_force.save(1) # Disable GPIO45 - if args.voltage != "OFF": - sdio_reg.save(1) # Enable internal regulator - if args.voltage == "3.3V": - sdio_tieh.save(1) - print("VDD_SPI setting complete.") - if not efuses.burn_all(check_batch_mode=True): - return - print("Successful") - - -def adc_info(esp, efuses, args): - # fmt: off - print("Block version:", efuses.get_block_version()) - if efuses.get_block_version() >= 100: - print("Temperature Sensor Calibration = {}C".format(efuses["TEMP_CALIB"].get())) - print("ADC OCode = ", efuses["OCODE"].get()) - print("ADC1:") - print("INIT_CODE_ATTEN0 = ", efuses["ADC1_INIT_CODE_ATTEN0"].get()) - print("INIT_CODE_ATTEN1 = ", efuses["ADC1_INIT_CODE_ATTEN1"].get()) - print("INIT_CODE_ATTEN2 = ", efuses["ADC1_INIT_CODE_ATTEN2"].get()) - print("INIT_CODE_ATTEN3 = ", efuses["ADC1_INIT_CODE_ATTEN3"].get()) - print("CAL_VOL_ATTEN0 = ", efuses["ADC1_CAL_VOL_ATTEN0"].get()) - print("CAL_VOL_ATTEN1 = ", efuses["ADC1_CAL_VOL_ATTEN1"].get()) - print("CAL_VOL_ATTEN2 = ", efuses["ADC1_CAL_VOL_ATTEN2"].get()) - print("CAL_VOL_ATTEN3 = ", efuses["ADC1_CAL_VOL_ATTEN3"].get()) - print("ADC2:") - print("INIT_CODE_ATTEN0 = ", efuses["ADC2_INIT_CODE_ATTEN0"].get()) - print("INIT_CODE_ATTEN1 = ", efuses["ADC2_INIT_CODE_ATTEN1"].get()) - print("INIT_CODE_ATTEN2 = ", efuses["ADC2_INIT_CODE_ATTEN2"].get()) - print("INIT_CODE_ATTEN3 = ", efuses["ADC2_INIT_CODE_ATTEN3"].get()) - print("CAL_VOL_ATTEN0 = ", efuses["ADC2_CAL_VOL_ATTEN0"].get()) - print("CAL_VOL_ATTEN1 = ", efuses["ADC2_CAL_VOL_ATTEN1"].get()) - print("CAL_VOL_ATTEN2 = ", efuses["ADC2_CAL_VOL_ATTEN2"].get()) - # fmt: on - - -def key_block_is_unused(block, key_purpose_block): - if not block.is_readable() or not block.is_writeable(): - return False - - if key_purpose_block.get() != "USER" or not key_purpose_block.is_writeable(): - return False - - if not block.get_bitstring().all(False): - return False - - return True - - -def get_next_key_block(efuses, current_key_block, block_name_list): - key_blocks = [b for b in efuses.blocks if b.key_purpose_name] - start = key_blocks.index(current_key_block) - - # Sort key blocks so that we pick the next free block (and loop around if necessary) - key_blocks = key_blocks[start:] + key_blocks[0:start] - - # Exclude any other blocks that will be be burned - key_blocks = [b for b in key_blocks if b.name not in block_name_list] - - for block in key_blocks: - key_purpose_block = efuses[block.key_purpose_name] - if key_block_is_unused(block, key_purpose_block): - return block - - return None - - -def split_512_bit_key(efuses, block_name_list, datafile_list, keypurpose_list): - i = keypurpose_list.index("XTS_AES_256_KEY") - block_name = block_name_list[i] - - block_num = efuses.get_index_block_by_name(block_name) - block = efuses.blocks[block_num] - - data = datafile_list[i].read() - if len(data) != 64: - raise esptool.FatalError( - "Incorrect key file size %d, XTS_AES_256_KEY should be 64 bytes" % len(data) - ) - - key_block_2 = get_next_key_block(efuses, block, block_name_list) - if not key_block_2: - raise esptool.FatalError("XTS_AES_256_KEY requires two free keyblocks") - - keypurpose_list.append("XTS_AES_256_KEY_1") - datafile_list.append(io.BytesIO(data[:32])) - block_name_list.append(block_name) - - keypurpose_list.append("XTS_AES_256_KEY_2") - datafile_list.append(io.BytesIO(data[32:])) - block_name_list.append(key_block_2.name) - - keypurpose_list.pop(i) - datafile_list.pop(i) - block_name_list.pop(i) - - -def burn_key(esp, efuses, args, digest=None): - if digest is None: - datafile_list = args.keyfile[ - 0 : len([name for name in args.keyfile if name is not None]) : - ] - else: - datafile_list = digest[0 : len([name for name in digest if name is not None]) :] - efuses.force_write_always = args.force_write_always - block_name_list = args.block[ - 0 : len([name for name in args.block if name is not None]) : - ] - keypurpose_list = args.keypurpose[ - 0 : len([name for name in args.keypurpose if name is not None]) : - ] - - if "XTS_AES_256_KEY" in keypurpose_list: - # XTS_AES_256_KEY is not an actual HW key purpose, needs to be split into - # XTS_AES_256_KEY_1 and XTS_AES_256_KEY_2 - split_512_bit_key(efuses, block_name_list, datafile_list, keypurpose_list) - - util.check_duplicate_name_in_list(block_name_list) - if len(block_name_list) != len(datafile_list) or len(block_name_list) != len( - keypurpose_list - ): - raise esptool.FatalError( - "The number of blocks (%d), datafile (%d) and keypurpose (%d) " - "should be the same." - % (len(block_name_list), len(datafile_list), len(keypurpose_list)) - ) - - print("Burn keys to blocks:") - for block_name, datafile, keypurpose in zip( - block_name_list, datafile_list, keypurpose_list - ): - efuse = None - for block in efuses.blocks: - if block_name == block.name or block_name in block.alias: - efuse = efuses[block.name] - if efuse is None: - raise esptool.FatalError("Unknown block name - %s" % (block_name)) - num_bytes = efuse.bit_len // 8 - - block_num = efuses.get_index_block_by_name(block_name) - block = efuses.blocks[block_num] - - if digest is None: - data = datafile.read() - else: - data = datafile - - print(" - %s" % (efuse.name), end=" ") - revers_msg = None - if efuses[block.key_purpose_name].need_reverse(keypurpose): - revers_msg = "\tReversing byte order for AES-XTS hardware peripheral" - data = data[::-1] - print( - "-> [{}]".format( - util.hexify(data, " ") - if args.show_sensitive_info - else " ".join(["??"] * len(data)) - ) - ) - if revers_msg: - print(revers_msg) - if len(data) != num_bytes: - raise esptool.FatalError( - "Incorrect key file size %d. Key file must be %d bytes (%d bits) " - "of raw binary key data." % (len(data), num_bytes, num_bytes * 8) - ) - - if efuses[block.key_purpose_name].need_rd_protect(keypurpose): - read_protect = False if args.no_read_protect else True - else: - read_protect = False - write_protect = not args.no_write_protect - - # using efuse instead of a block gives the advantage of - # checking it as the whole field. - efuse.save(data) - - disable_wr_protect_key_purpose = False - if efuses[block.key_purpose_name].get() != keypurpose: - if efuses[block.key_purpose_name].is_writeable(): - print( - "\t'%s': '%s' -> '%s'." - % ( - block.key_purpose_name, - efuses[block.key_purpose_name].get(), - keypurpose, - ) - ) - efuses[block.key_purpose_name].save(keypurpose) - disable_wr_protect_key_purpose = True - else: - raise esptool.FatalError( - "It is not possible to change '%s' to '%s' because " - "write protection bit is set." - % (block.key_purpose_name, keypurpose) - ) - else: - print("\t'%s' is already '%s'." % (block.key_purpose_name, keypurpose)) - if efuses[block.key_purpose_name].is_writeable(): - disable_wr_protect_key_purpose = True - - if disable_wr_protect_key_purpose: - print("\tDisabling write to '%s'." % block.key_purpose_name) - efuses[block.key_purpose_name].disable_write() - - if read_protect: - print("\tDisabling read to key block") - efuse.disable_read() - - if write_protect: - print("\tDisabling write to key block") - efuse.disable_write() - print("") - - if not write_protect: - print("Keys will remain writeable (due to --no-write-protect)") - if args.no_read_protect: - print("Keys will remain readable (due to --no-read-protect)") - - if not efuses.burn_all(check_batch_mode=True): - return - print("Successful") - - -def burn_key_digest(esp, efuses, args): - digest_list = [] - datafile_list = args.keyfile[ - 0 : len([name for name in args.keyfile if name is not None]) : - ] - block_list = args.block[ - 0 : len([block for block in args.block if block is not None]) : - ] - for block_name, datafile in zip(block_list, datafile_list): - efuse = None - for block in efuses.blocks: - if block_name == block.name or block_name in block.alias: - efuse = efuses[block.name] - if efuse is None: - raise esptool.FatalError("Unknown block name - %s" % (block_name)) - num_bytes = efuse.bit_len // 8 - digest = espsecure._digest_sbv2_public_key(datafile) - if len(digest) != num_bytes: - raise esptool.FatalError( - "Incorrect digest size %d. Digest must be %d bytes (%d bits) " - "of raw binary key data." % (len(digest), num_bytes, num_bytes * 8) - ) - digest_list.append(digest) - burn_key(esp, efuses, args, digest=digest_list) - - -def espefuse(esp, efuses, args, command): - parser = argparse.ArgumentParser() - subparsers = parser.add_subparsers(dest="operation") - add_commands(subparsers, efuses) - try: - cmd_line_args = parser.parse_args(command.split()) - except SystemExit: - traceback.print_stack() - raise esptool.FatalError('"{}" - incorrect command'.format(command)) - if cmd_line_args.operation == "execute_scripts": - configfiles = cmd_line_args.configfiles - index = cmd_line_args.index - # copy arguments from args to cmd_line_args - vars(cmd_line_args).update(vars(args)) - if cmd_line_args.operation == "execute_scripts": - cmd_line_args.configfiles = configfiles - cmd_line_args.index = index - if cmd_line_args.operation is None: - parser.print_help() - parser.exit(1) - operation_func = globals()[cmd_line_args.operation] - # each 'operation' is a module-level function of the same name - operation_func(esp, efuses, cmd_line_args) - - -def execute_scripts(esp, efuses, args): - efuses.batch_mode_cnt += 1 - del args.operation - scripts = args.scripts - del args.scripts - - for file in scripts: - with open(file.name, "r") as file: - exec(compile(file.read(), file.name, "exec")) - - if args.debug: - for block in efuses.blocks: - data = block.get_bitstring(from_read=False) - block.print_block(data, "regs_for_burn", args.debug) - - efuses.batch_mode_cnt -= 1 - if not efuses.burn_all(check_batch_mode=True): - return - print("Successful") diff --git a/espefuse/efuse_defs/esp32c5beta3.yaml b/espefuse/efuse_defs/esp32c5beta3.yaml deleted file mode 100644 index 31af46a56d..0000000000 --- a/espefuse/efuse_defs/esp32c5beta3.yaml +++ /dev/null @@ -1,104 +0,0 @@ -VER_NO: b09fa417de505238a601eddce188b696 -EFUSES: - WR_DIS : {show: y, blk : 0, word: 0, pos : 0, len : 32, start : 0, type : 'uint:32', wr_dis: null, rd_dis: null, alt : '', dict : '', desc: Disable programming of individual eFuses, rloc: EFUSE_RD_WR_DIS0_REG, bloc: 'B0,B1,B2,B3'} - RD_DIS : {show: y, blk : 0, word: 1, pos : 0, len : 7, start : 32, type : 'uint:7', wr_dis : 0, rd_dis: null, alt : '', dict : '', desc: Disable reading from BlOCK4-10, rloc: 'EFUSE_RD_REPEAT_DATA0_REG[6:0]', bloc: 'B4[6:0]'} - RESERVE_0_39 : {show: n, blk : 0, word: 1, pos : 7, len : 1, start : 39, type : bool, wr_dis: null, rd_dis: null, alt : '', dict : '', desc: Reserved; it was created by set_missed_fields_in_regs func, rloc: 'EFUSE_RD_REPEAT_DATA0_REG[7]', bloc: 'B4[7]'} - DIS_ICACHE : {show: y, blk : 0, word: 1, pos : 8, len : 1, start : 40, type : bool, wr_dis : 2, rd_dis: null, alt : '', dict : '', desc: 'Represents whether icache is disabled or enabled.\\ 1: disabled\\ 0: enabled\\', rloc: 'EFUSE_RD_REPEAT_DATA0_REG[8]', bloc: 'B5[0]'} - DIS_USB_JTAG : {show: y, blk : 0, word: 1, pos : 9, len : 1, start : 41, type : bool, wr_dis : 2, rd_dis: null, alt : '', dict : '', desc: 'Represents whether the function of usb switch to jtag is disabled or enabled.\\ 1: disabled\\ 0: enabled\\', rloc: 'EFUSE_RD_REPEAT_DATA0_REG[9]', bloc: 'B5[1]'} - RESERVE_0_42 : {show: n, blk : 0, word: 1, pos: 10, len : 1, start : 42, type : bool, wr_dis: null, rd_dis: null, alt : '', dict : '', desc: Reserved; it was created by set_missed_fields_in_regs func, rloc: 'EFUSE_RD_REPEAT_DATA0_REG[10]', bloc: 'B5[2]'} - DIS_USB_SERIAL_JTAG : {show: n, blk : 0, word: 1, pos: 11, len : 1, start : 43, type : bool, wr_dis : 2, rd_dis: null, alt : '', dict : '', desc: 'Represents whether USB-Serial-JTAG is disabled or enabled.\\ 1: disabled\\ 0: enabled\\', rloc: 'EFUSE_RD_REPEAT_DATA0_REG[11]', bloc: 'B5[3]'} - DIS_FORCE_DOWNLOAD : {show: y, blk : 0, word: 1, pos: 12, len : 1, start : 44, type : bool, wr_dis : 2, rd_dis: null, alt : '', dict : '', desc: 'Represents whether the function that forces chip into download mode is disabled or enabled.\\ 1: disabled\\ 0: enabled\\', rloc: 'EFUSE_RD_REPEAT_DATA0_REG[12]', bloc: 'B5[4]'} - SPI_DOWNLOAD_MSPI_DIS : {show: y, blk : 0, word: 1, pos: 13, len : 1, start : 45, type : bool, wr_dis : 2, rd_dis: null, alt : '', dict : '', desc: 'Represents whether SPI0 controller during boot_mode_download is disabled or enabled.\\ 1: disabled\\ 0: enabled\\', rloc: 'EFUSE_RD_REPEAT_DATA0_REG[13]', bloc: 'B5[5]'} - DIS_TWAI : {show: y, blk : 0, word: 1, pos: 14, len : 1, start : 46, type : bool, wr_dis : 2, rd_dis: null, alt : '', dict : '', desc: 'Represents whether TWAI function is disabled or enabled.\\ 1: disabled\\ 0: enabled\\', rloc: 'EFUSE_RD_REPEAT_DATA0_REG[14]', bloc: 'B5[6]'} - JTAG_SEL_ENABLE : {show: y, blk : 0, word: 1, pos: 15, len : 1, start : 47, type : bool, wr_dis : 2, rd_dis: null, alt : '', dict : '', desc: 'Represents whether the selection between usb_to_jtag and pad_to_jtag through strapping gpio15 when both EFUSE_DIS_PAD_JTAG and EFUSE_DIS_USB_JTAG are equal to 0 is enabled or disabled.\\ 1: enabled\\ 0: disabled\\', rloc: 'EFUSE_RD_REPEAT_DATA0_REG[15]', bloc: 'B5[7]'} - SOFT_DIS_JTAG : {show: y, blk : 0, word: 1, pos: 16, len : 3, start : 48, type : 'uint:3', wr_dis : 31, rd_dis: null, alt : '', dict : '', desc: 'Represents whether JTAG is disabled in soft way.\\ Odd number: disabled\\ Even number: enabled\\', rloc: 'EFUSE_RD_REPEAT_DATA0_REG[18:16]', bloc: 'B6[2:0]'} - DIS_PAD_JTAG : {show: y, blk : 0, word: 1, pos: 19, len : 1, start : 51, type : bool, wr_dis : 2, rd_dis: null, alt : '', dict : '', desc: 'Represents whether JTAG is disabled in the hard way(permanently).\\ 1: disabled\\ 0: enabled\\', rloc: 'EFUSE_RD_REPEAT_DATA0_REG[19]', bloc: 'B6[3]'} - DIS_DOWNLOAD_MANUAL_ENCRYPT : {show: y, blk : 0, word: 1, pos: 20, len : 1, start : 52, type : bool, wr_dis : 2, rd_dis: null, alt : '', dict : '', desc: 'Represents whether flash encrypt function is disabled or enabled(except in SPI boot mode).\\ 1: disabled\\ 0: enabled\\', rloc: 'EFUSE_RD_REPEAT_DATA0_REG[20]', bloc: 'B6[4]'} - USB_DREFH : {show: n, blk : 0, word: 1, pos: 21, len : 2, start : 53, type : 'uint:2', wr_dis : 30, rd_dis: null, alt : '', dict : '', desc: Represents the single-end input threshold vrefh; 1.76 V to 2 V with step of 80 mV, rloc: 'EFUSE_RD_REPEAT_DATA0_REG[22:21]', bloc: 'B6[6:5]'} - USB_DREFL : {show: n, blk : 0, word: 1, pos: 23, len : 2, start : 55, type : 'uint:2', wr_dis : 30, rd_dis: null, alt : '', dict : '', desc: Represents the single-end input threshold vrefl; 1.76 V to 2 V with step of 80 mV, rloc: 'EFUSE_RD_REPEAT_DATA0_REG[24:23]', bloc: 'B6[7],B7[0]'} - USB_EXCHG_PINS : {show: y, blk : 0, word: 1, pos: 25, len : 1, start : 57, type : bool, wr_dis : 30, rd_dis: null, alt : '', dict : '', desc: 'Represents whether the D+ and D- pins is exchanged.\\ 1: exchanged\\ 0: not exchanged\\', rloc: 'EFUSE_RD_REPEAT_DATA0_REG[25]', bloc: 'B7[1]'} - VDD_SPI_AS_GPIO : {show: y, blk : 0, word: 1, pos: 26, len : 1, start : 58, type : bool, wr_dis : 30, rd_dis: null, alt : '', dict : '', desc: 'Represents whether vdd spi pin is functioned as gpio.\\ 1: functioned\\ 0: not functioned\\', rloc: 'EFUSE_RD_REPEAT_DATA0_REG[26]', bloc: 'B7[2]'} - RESERVE_0_59 : {show: n, blk : 0, word: 1, pos: 27, len : 5, start : 59, type : 'uint:5', wr_dis: null, rd_dis: null, alt : '', dict : '', desc: Reserved; it was created by set_missed_fields_in_regs func, rloc: 'EFUSE_RD_REPEAT_DATA0_REG[31:27]', bloc: 'B7[7:3]'} - KM_DISABLE_DEPLOY_MODE : {show: y, blk : 0, word: 2, pos : 0, len : 4, start : 64, type : 'uint:4', wr_dis : 1, rd_dis: null, alt : '', dict : '', desc: 'Represents whether the deploy mode of key manager is disable or not. \\ 1: disabled \\ 0: enabled.\\', rloc: 'EFUSE_RD_REPEAT_DATA1_REG[3:0]', bloc: 'B8[3:0]'} - KM_RND_SWITCH_CYCLE : {show: y, blk : 0, word: 2, pos : 4, len : 2, start : 68, type : 'uint:2', wr_dis : 1, rd_dis: null, alt : '', dict : '', desc: 'Set the bits to control key manager random number switch cycle. 0: control by register. 1: 8 km clk cycles. 2: 16 km cycles. 3: 32 km cycles', rloc: 'EFUSE_RD_REPEAT_DATA1_REG[5:4]', bloc: 'B8[5:4]'} - KM_DEPLOY_ONLY_ONCE : {show: y, blk : 0, word: 2, pos : 6, len : 4, start : 70, type : 'uint:4', wr_dis : 1, rd_dis: null, alt : '', dict : '', desc: 'Set each bit to control whether corresponding key can only be deployed once. 1 is true; 0 is false. bit 0: ecsda; bit 1: xts; bit2: hmac; bit3: ds', rloc: 'EFUSE_RD_REPEAT_DATA1_REG[9:6]', bloc: 'B8[7:6],B9[1:0]'} - FORCE_USE_KEY_MANAGER_KEY : {show: y, blk : 0, word: 2, pos: 10, len : 4, start : 74, type : 'uint:4', wr_dis : 1, rd_dis: null, alt : '', dict : '', desc: 'Set each bit to control whether corresponding key must come from key manager. 1 is true; 0 is false. bit 0: ecsda; bit 1: xts; bit2: hmac; bit3: ds', rloc: 'EFUSE_RD_REPEAT_DATA1_REG[13:10]', bloc: 'B9[5:2]'} - FORCE_DISABLE_SW_INIT_KEY : {show: y, blk : 0, word: 2, pos: 14, len : 1, start : 78, type : bool, wr_dis : 1, rd_dis: null, alt : '', dict : '', desc: Set this bit to disable software written init key; and force use efuse_init_key, rloc: 'EFUSE_RD_REPEAT_DATA1_REG[14]', bloc: 'B9[6]'} - RESERVE_0_79 : {show: n, blk : 0, word: 2, pos: 15, len : 1, start : 79, type : bool, wr_dis: null, rd_dis: null, alt : '', dict : '', desc: Reserved; it was created by set_missed_fields_in_regs func, rloc: 'EFUSE_RD_REPEAT_DATA1_REG[15]', bloc: 'B9[7]'} - WDT_DELAY_SEL : {show: y, blk : 0, word: 2, pos: 16, len : 2, start : 80, type : 'uint:2', wr_dis : 3, rd_dis: null, alt : '', dict : '', desc: 'Represents the threshold level of the RTC watchdog STG0 timeout.\\ 0: Original threshold configuration value of STG0 *2 \\1: Original threshold configuration value of STG0 *4 \\2: Original threshold configuration value of STG0 *8 \\3: Original threshold configuration value of STG0 *16 \\', rloc: 'EFUSE_RD_REPEAT_DATA1_REG[17:16]', bloc: 'B10[1:0]'} - SPI_BOOT_CRYPT_CNT : {show: y, blk : 0, word: 2, pos: 18, len : 3, start : 82, type : 'uint:3', wr_dis : 4, rd_dis: null, alt : '', dict: '{0: "Disable", 1: "Enable", 3: "Disable", 7: "Enable"}', desc: Enables flash encryption when 1 or 3 bits are set and disables otherwise, rloc: 'EFUSE_RD_REPEAT_DATA1_REG[20:18]', bloc: 'B10[4:2]'} - SECURE_BOOT_KEY_REVOKE0 : {show: y, blk : 0, word: 2, pos: 21, len : 1, start : 85, type : bool, wr_dis : 5, rd_dis: null, alt : '', dict : '', desc: Revoke 1st secure boot key, rloc: 'EFUSE_RD_REPEAT_DATA1_REG[21]', bloc: 'B10[5]'} - SECURE_BOOT_KEY_REVOKE1 : {show: y, blk : 0, word: 2, pos: 22, len : 1, start : 86, type : bool, wr_dis : 6, rd_dis: null, alt : '', dict : '', desc: Revoke 2nd secure boot key, rloc: 'EFUSE_RD_REPEAT_DATA1_REG[22]', bloc: 'B10[6]'} - SECURE_BOOT_KEY_REVOKE2 : {show: y, blk : 0, word: 2, pos: 23, len : 1, start : 87, type : bool, wr_dis : 7, rd_dis: null, alt : '', dict : '', desc: Revoke 3rd secure boot key, rloc: 'EFUSE_RD_REPEAT_DATA1_REG[23]', bloc: 'B10[7]'} - KEY_PURPOSE_0 : {show: y, blk : 0, word: 2, pos: 24, len : 4, start : 88, type : 'uint:4', wr_dis : 8, rd_dis: null, alt : KEY0_PURPOSE, dict : '', desc: Represents the purpose of Key0, rloc: 'EFUSE_RD_REPEAT_DATA1_REG[27:24]', bloc: 'B11[3:0]'} - KEY_PURPOSE_1 : {show: y, blk : 0, word: 2, pos: 28, len : 4, start : 92, type : 'uint:4', wr_dis : 9, rd_dis: null, alt : KEY1_PURPOSE, dict : '', desc: Represents the purpose of Key1, rloc: 'EFUSE_RD_REPEAT_DATA1_REG[31:28]', bloc: 'B11[7:4]'} - KEY_PURPOSE_2 : {show: y, blk : 0, word: 3, pos : 0, len : 4, start : 96, type : 'uint:4', wr_dis : 10, rd_dis: null, alt : KEY2_PURPOSE, dict : '', desc: Represents the purpose of Key2, rloc: 'EFUSE_RD_REPEAT_DATA2_REG[3:0]', bloc: 'B12[3:0]'} - KEY_PURPOSE_3 : {show: y, blk : 0, word: 3, pos : 4, len : 4, start: 100, type : 'uint:4', wr_dis : 11, rd_dis: null, alt : KEY3_PURPOSE, dict : '', desc: Represents the purpose of Key3, rloc: 'EFUSE_RD_REPEAT_DATA2_REG[7:4]', bloc: 'B12[7:4]'} - KEY_PURPOSE_4 : {show: y, blk : 0, word: 3, pos : 8, len : 4, start: 104, type : 'uint:4', wr_dis : 12, rd_dis: null, alt : KEY4_PURPOSE, dict : '', desc: Represents the purpose of Key4, rloc: 'EFUSE_RD_REPEAT_DATA2_REG[11:8]', bloc: 'B13[3:0]'} - KEY_PURPOSE_5 : {show: y, blk : 0, word: 3, pos: 12, len : 4, start: 108, type : 'uint:4', wr_dis : 13, rd_dis: null, alt : KEY5_PURPOSE, dict : '', desc: Represents the purpose of Key5, rloc: 'EFUSE_RD_REPEAT_DATA2_REG[15:12]', bloc: 'B13[7:4]'} - SEC_DPA_LEVEL : {show: y, blk : 0, word: 3, pos: 16, len : 2, start: 112, type : 'uint:2', wr_dis : 14, rd_dis: null, alt : '', dict : '', desc: Represents the spa secure level by configuring the clock random divide mode, rloc: 'EFUSE_RD_REPEAT_DATA2_REG[17:16]', bloc: 'B14[1:0]'} - RESERVE_0_114 : {show: n, blk : 0, word: 3, pos: 18, len : 2, start: 114, type : 'uint:2', wr_dis: null, rd_dis: null, alt : '', dict : '', desc: Reserved; it was created by set_missed_fields_in_regs func, rloc: 'EFUSE_RD_REPEAT_DATA2_REG[19:18]', bloc: 'B14[3:2]'} - SECURE_BOOT_EN : {show: y, blk : 0, word: 3, pos: 20, len : 1, start: 116, type : bool, wr_dis : 15, rd_dis: null, alt : '', dict : '', desc: 'Represents whether secure boot is enabled or disabled.\\ 1: enabled\\ 0: disabled\\', rloc: 'EFUSE_RD_REPEAT_DATA2_REG[20]', bloc: 'B14[4]'} - SECURE_BOOT_AGGRESSIVE_REVOKE : {show: y, blk : 0, word: 3, pos: 21, len : 1, start: 117, type : bool, wr_dis : 16, rd_dis: null, alt : '', dict : '', desc: 'Represents whether revoking aggressive secure boot is enabled or disabled.\\ 1: enabled.\\ 0: disabled\\', rloc: 'EFUSE_RD_REPEAT_DATA2_REG[21]', bloc: 'B14[5]'} - RESERVE_0_118 : {show: n, blk : 0, word: 3, pos: 22, len : 5, start: 118, type : 'uint:5', wr_dis: null, rd_dis: null, alt : '', dict : '', desc: Reserved; it was created by set_missed_fields_in_regs func, rloc: 'EFUSE_RD_REPEAT_DATA2_REG[26:22]', bloc: 'B14[7:6],B15[2:0]'} - KM_XTS_KEY_LENGTH_256 : {show: y, blk : 0, word: 3, pos: 27, len : 1, start: 123, type : bool, wr_dis : 1, rd_dis: null, alt : '', dict : '', desc: Set this bitto configure flash encryption use xts-128 key. else use xts-256 key, rloc: 'EFUSE_RD_REPEAT_DATA2_REG[27]', bloc: 'B15[3]'} - FLASH_TPUW : {show: y, blk : 0, word: 3, pos: 28, len : 4, start: 124, type : 'uint:4', wr_dis : 18, rd_dis: null, alt : '', dict : '', desc: Represents the flash waiting time after power-up; in unit of ms. When the value less than 15; the waiting time is the programmed value. Otherwise; the waiting time is 2 times the programmed value, rloc: 'EFUSE_RD_REPEAT_DATA2_REG[31:28]', bloc: 'B15[7:4]'} - DIS_DOWNLOAD_MODE : {show: y, blk : 0, word: 4, pos : 0, len : 1, start: 128, type : bool, wr_dis : 18, rd_dis: null, alt : '', dict : '', desc: 'Represents whether Download mode is disabled or enabled.\\ 1: disabled\\ 0: enabled\\', rloc: 'EFUSE_RD_REPEAT_DATA3_REG[0]', bloc: 'B16[0]'} - DIS_DIRECT_BOOT : {show: y, blk : 0, word: 4, pos : 1, len : 1, start: 129, type : bool, wr_dis : 18, rd_dis: null, alt : '', dict : '', desc: 'Represents whether direct boot mode is disabled or enabled.\\ 1: disabled\\ 0: enabled\\', rloc: 'EFUSE_RD_REPEAT_DATA3_REG[1]', bloc: 'B16[1]'} - DIS_USB_SERIAL_JTAG_ROM_PRINT : {show: y, blk : 0, word: 4, pos : 2, len : 1, start: 130, type : bool, wr_dis : 18, rd_dis: null, alt : '', dict : '', desc: 'Represents whether print from USB-Serial-JTAG is disabled or enabled.\\ 1: disabled\\ 0: enabled\\', rloc: 'EFUSE_RD_REPEAT_DATA3_REG[2]', bloc: 'B16[2]'} - LOCK_KM_KEY : {show: y, blk : 0, word: 4, pos : 3, len : 1, start: 131, type : bool, wr_dis : 1, rd_dis: null, alt : '', dict : '', desc: 'Represetns whether to lock the efuse xts key.\\ 1. Lock\\ 0: Unlock\\', rloc: 'EFUSE_RD_REPEAT_DATA3_REG[3]', bloc: 'B16[3]'} - DIS_USB_SERIAL_JTAG_DOWNLOAD_MODE: {show: y, blk : 0, word: 4, pos : 4, len : 1, start: 132, type : bool, wr_dis : 18, rd_dis: null, alt : '', dict : '', desc: 'Represents whether the USB-Serial-JTAG download function is disabled or enabled.\\ 1: Disable\\ 0: Enable\\', rloc: 'EFUSE_RD_REPEAT_DATA3_REG[4]', bloc: 'B16[4]'} - ENABLE_SECURITY_DOWNLOAD : {show: y, blk : 0, word: 4, pos : 5, len : 1, start: 133, type : bool, wr_dis : 18, rd_dis: null, alt : '', dict : '', desc: 'Represents whether security download is enabled or disabled.\\ 1: enabled\\ 0: disabled\\', rloc: 'EFUSE_RD_REPEAT_DATA3_REG[5]', bloc: 'B16[5]'} - UART_PRINT_CONTROL : {show: y, blk : 0, word: 4, pos : 6, len : 2, start: 134, type : 'uint:2', wr_dis : 18, rd_dis: null, alt : '', dict: '{0: "Enable", 1: "Enable when GPIO8 is low at reset", 2: "Enable when GPIO8 is high at reset", 3: "Disable"}', desc: Set the default UARTboot message output mode, rloc: 'EFUSE_RD_REPEAT_DATA3_REG[7:6]', bloc: 'B16[7:6]'} - FORCE_SEND_RESUME : {show: y, blk : 0, word: 4, pos : 8, len : 1, start: 136, type : bool, wr_dis : 18, rd_dis: null, alt : '', dict : '', desc: 'Represents whether ROM code is forced to send a resume command during SPI boot.\\ 1: forced\\ 0:not forced\\', rloc: 'EFUSE_RD_REPEAT_DATA3_REG[8]', bloc: 'B17[0]'} - SECURE_VERSION : {show: y, blk : 0, word: 4, pos : 9, len : 16, start: 137, type : 'uint:16', wr_dis : 18, rd_dis: null, alt : '', dict : '', desc: Represents the version used by ESP-IDF anti-rollback feature, rloc: 'EFUSE_RD_REPEAT_DATA3_REG[24:9]', bloc: 'B17[7:1],B18,B19[0]'} - SECURE_BOOT_DISABLE_FAST_WAKE : {show: y, blk : 0, word: 4, pos: 25, len : 1, start: 153, type : bool, wr_dis : 18, rd_dis: null, alt : '', dict : '', desc: 'Represents whether FAST VERIFY ON WAKE is disabled or enabled when Secure Boot is enabled.\\ 1: disabled\\ 0: enabled\\', rloc: 'EFUSE_RD_REPEAT_DATA3_REG[25]', bloc: 'B19[1]'} - HYS_EN_PAD : {show: y, blk : 0, word: 4, pos: 26, len : 1, start: 154, type : bool, wr_dis : 2, rd_dis: null, alt : '', dict : '', desc: 'Represents whether the hysteresis function of corresponding PAD is enabled.\\ 1: enabled\\ 0:disabled\\', rloc: 'EFUSE_RD_REPEAT_DATA3_REG[26]', bloc: 'B19[2]'} - XTS_DPA_PSEUDO_LEVEL : {show: y, blk : 0, word: 4, pos: 27, len : 2, start: 155, type : 'uint:2', wr_dis : 14, rd_dis: null, alt : '', dict : '', desc: 'Represents the pseudo round level of xts-aes anti-dpa attack.\\ 3: High.\\ 2: Moderate 1. Low\\ 0: Disabled\\', rloc: 'EFUSE_RD_REPEAT_DATA3_REG[28:27]', bloc: 'B19[4:3]'} - XTS_DPA_CLK_ENABLE : {show: y, blk : 0, word: 4, pos: 29, len : 1, start: 157, type : bool, wr_dis : 14, rd_dis: null, alt : '', dict : '', desc: 'Represents whether xts-aes anti-dpa attack clock is enabled.\\ 1. Enable.\\ 0: Disable.\\', rloc: 'EFUSE_RD_REPEAT_DATA3_REG[29]', bloc: 'B19[5]'} - RESERVE_0_158 : {show: n, blk : 0, word: 4, pos: 30, len : 2, start: 158, type : 'uint:2', wr_dis: null, rd_dis: null, alt : '', dict : '', desc: Reserved; it was created by set_missed_fields_in_regs func, rloc: 'EFUSE_RD_REPEAT_DATA3_REG[31:30]', bloc: 'B19[7:6]'} - HUK_GEN_STATE : {show: y, blk : 0, word: 5, pos : 0, len : 9, start: 160, type : 'uint:9', wr_dis : 19, rd_dis: null, alt : '', dict : '', desc: Set the bits to control validation of HUK generate mode.\\ Odd of 1 is invalid.\\ Even of 1 is valid.\\, rloc: 'EFUSE_RD_REPEAT_DATA4_REG[8:0]', bloc: 'B20,B21[0]'} - XTAL_48M_SEL : {show: y, blk : 0, word: 5, pos : 9, len : 3, start: 169, type : 'uint:3', wr_dis : 17, rd_dis: null, alt : '', dict : '', desc: 'Represents whether XTAL frequency is 48MHz or not. If not; 40MHz XTAL will be used. If this field contains Odd number bit 1: Enable 48MHz XTAL\ Even number bit 1: Enable 40MHz XTAL', rloc: 'EFUSE_RD_REPEAT_DATA4_REG[11:9]', bloc: 'B21[3:1]'} - XTAL_48M_SEL_MODE : {show: y, blk : 0, word: 5, pos: 12, len : 1, start: 172, type : bool, wr_dis : 17, rd_dis: null, alt : '', dict : '', desc: 'Specify the XTAL frequency selection is decided by eFuse or strapping-PAD-state. 1: eFuse\\ 0: strapping-PAD-state', rloc: 'EFUSE_RD_REPEAT_DATA4_REG[12]', bloc: 'B21[4]'} - ECDSA_DISABLE_P192 : {show: y, blk : 0, word: 5, pos: 13, len : 1, start: 173, type : bool, wr_dis : 14, rd_dis: null, alt : '', dict : '', desc: 'Represents whether to disable P192 curve in ECDSA.\\ 1: Disabled.\\ 0: Not disable', rloc: 'EFUSE_RD_REPEAT_DATA4_REG[13]', bloc: 'B21[5]'} - ECC_FORCE_CONST_TIME : {show: y, blk : 0, word: 5, pos: 14, len : 1, start: 174, type : bool, wr_dis : 14, rd_dis: null, alt : '', dict : '', desc: 'Represents whether to force ecc to use const-time calculation mode. \\ 1: Enable. \\ 0: Disable', rloc: 'EFUSE_RD_REPEAT_DATA4_REG[14]', bloc: 'B21[6]'} - RESERVE_0_175 : {show: n, blk : 0, word: 5, pos: 15, len : 17, start: 175, type : 'uint:17', wr_dis: null, rd_dis: null, alt : '', dict : '', desc: Reserved; it was created by set_missed_fields_in_regs func, rloc: 'EFUSE_RD_REPEAT_DATA4_REG[31:15]', bloc: 'B21[7],B22,B23'} - MAC : {show: y, blk : 1, word: 0, pos : 0, len : 48, start : 0, type : 'bytes:6', wr_dis : 20, rd_dis: null, alt : MAC_FACTORY, dict : '', desc: MAC address, rloc: EFUSE_RD_MAC_SYS0_REG, bloc: 'B0,B1,B2,B3,B4,B5'} - MAC_EXT : {show: y, blk : 1, word: 1, pos: 16, len : 16, start : 48, type : 'bytes:2', wr_dis : 20, rd_dis: null, alt : '', dict : '', desc: Represents the extended bits of MAC address, rloc: 'EFUSE_RD_MAC_SYS1_REG[31:16]', bloc: 'B6,B7'} - WAFER_VERSION_MINOR : {show: y, blk : 1, word: 2, pos : 0, len : 4, start : 64, type : 'uint:4', wr_dis : 20, rd_dis: null, alt : '', dict : '', desc: Minor chip version, rloc: 'EFUSE_RD_MAC_SYS2_REG[3:0]', bloc: 'B8[3:0]'} - WAFER_VERSION_MAJOR : {show: y, blk : 1, word: 2, pos : 4, len : 2, start : 68, type : 'uint:2', wr_dis : 20, rd_dis: null, alt : '', dict : '', desc: Minor chip version, rloc: 'EFUSE_RD_MAC_SYS2_REG[5:4]', bloc: 'B8[5:4]'} - DISABLE_WAFER_VERSION_MAJOR : {show: y, blk : 1, word: 2, pos : 6, len : 1, start : 70, type : bool, wr_dis : 20, rd_dis: null, alt : '', dict : '', desc: Disables check of wafer version major, rloc: 'EFUSE_RD_MAC_SYS2_REG[6]', bloc: 'B8[6]'} - DISABLE_BLK_VERSION_MAJOR : {show: y, blk : 1, word: 2, pos : 7, len : 1, start : 71, type : bool, wr_dis : 20, rd_dis: null, alt : '', dict : '', desc: Disables check of blk version major, rloc: 'EFUSE_RD_MAC_SYS2_REG[7]', bloc: 'B8[7]'} - BLK_VERSION_MINOR : {show: y, blk : 1, word: 2, pos : 8, len : 3, start : 72, type : 'uint:3', wr_dis : 20, rd_dis: null, alt : '', dict : '', desc: BLK_VERSION_MINOR of BLOCK2, rloc: 'EFUSE_RD_MAC_SYS2_REG[10:8]', bloc: 'B9[2:0]'} - BLK_VERSION_MAJOR : {show: y, blk : 1, word: 2, pos: 11, len : 2, start : 75, type : 'uint:2', wr_dis : 20, rd_dis: null, alt : '', dict : '', desc: BLK_VERSION_MAJOR of BLOCK2, rloc: 'EFUSE_RD_MAC_SYS2_REG[12:11]', bloc: 'B9[4:3]'} - FLASH_CAP : {show: y, blk : 1, word: 2, pos: 13, len : 3, start : 77, type : 'uint:3', wr_dis : 20, rd_dis: null, alt : '', dict : '', desc: Flash capacity, rloc: 'EFUSE_RD_MAC_SYS2_REG[15:13]', bloc: 'B9[7:5]'} - FLASH_VENDOR : {show: y, blk : 1, word: 2, pos: 16, len : 3, start : 80, type : 'uint:3', wr_dis : 20, rd_dis: null, alt : '', dict : '', desc: Flash vendor, rloc: 'EFUSE_RD_MAC_SYS2_REG[18:16]', bloc: 'B10[2:0]'} - PSRAM_CAP : {show: y, blk : 1, word: 2, pos: 19, len : 3, start : 83, type : 'uint:3', wr_dis : 20, rd_dis: null, alt : '', dict : '', desc: Psram capacity, rloc: 'EFUSE_RD_MAC_SYS2_REG[21:19]', bloc: 'B10[5:3]'} - PSRAM_VENDOR : {show: y, blk : 1, word: 2, pos: 22, len : 2, start : 86, type : 'uint:2', wr_dis : 20, rd_dis: null, alt : '', dict : '', desc: Psram vendor, rloc: 'EFUSE_RD_MAC_SYS2_REG[23:22]', bloc: 'B10[7:6]'} - TEMP : {show: y, blk : 1, word: 2, pos: 24, len : 2, start : 88, type : 'uint:2', wr_dis : 20, rd_dis: null, alt : '', dict : '', desc: Temp (die embedded inside), rloc: 'EFUSE_RD_MAC_SYS2_REG[25:24]', bloc: 'B11[1:0]'} - PKG_VERSION : {show: y, blk : 1, word: 2, pos: 26, len : 3, start : 90, type : 'uint:3', wr_dis : 20, rd_dis: null, alt : '', dict : '', desc: Package version, rloc: 'EFUSE_RD_MAC_SYS2_REG[28:26]', bloc: 'B11[4:2]'} - PA_TRIM_VERSION : {show: y, blk : 1, word: 2, pos: 29, len : 3, start : 93, type : 'uint:3', wr_dis : 20, rd_dis: null, alt : '', dict : '', desc: PADC CAL PA trim version, rloc: 'EFUSE_RD_MAC_SYS2_REG[31:29]', bloc: 'B11[7:5]'} - TRIM_N_BIAS : {show: y, blk : 1, word: 3, pos : 0, len : 5, start : 96, type : 'uint:5', wr_dis : 20, rd_dis: null, alt : '', dict : '', desc: PADC CAL N bias, rloc: 'EFUSE_RD_MAC_SYS3_REG[4:0]', bloc: 'B12[4:0]'} - TRIM_P_BIAS : {show: y, blk : 1, word: 3, pos : 5, len : 5, start: 101, type : 'uint:5', wr_dis : 20, rd_dis: null, alt : '', dict : '', desc: PADC CAL P bias, rloc: 'EFUSE_RD_MAC_SYS3_REG[9:5]', bloc: 'B12[7:5],B13[1:0]'} - RESERVED_1_106 : {show: n, blk : 1, word: 3, pos: 10, len : 8, start: 106, type : 'uint:8', wr_dis : 20, rd_dis: null, alt : '', dict : '', desc: reserved, rloc: 'EFUSE_RD_MAC_SYS3_REG[17:10]', bloc: 'B13[7:2],B14[1:0]'} - SYS_DATA_PART0_0 : {show: n, blk : 1, word: 3, pos: 18, len : 14, start: 114, type : 'uint:14', wr_dis : 20, rd_dis: null, alt : '', dict : '', desc: Represents the first 14-bit of zeroth part of system data, rloc: 'EFUSE_RD_MAC_SYS3_REG[31:18]', bloc: 'B14[7:2],B15'} - SYS_DATA_PART0_1 : {show: n, blk : 1, word: 4, pos : 0, len : 32, start: 128, type : 'uint:32', wr_dis : 20, rd_dis: null, alt : '', dict : '', desc: Represents the first 14-bit of zeroth part of system data, rloc: EFUSE_RD_MAC_SYS4_REG, bloc: 'B16,B17,B18,B19'} - SYS_DATA_PART0_2 : {show: n, blk : 1, word: 5, pos : 0, len : 32, start: 160, type : 'uint:32', wr_dis : 20, rd_dis: null, alt : '', dict : '', desc: Represents the second 32-bit of zeroth part of system data, rloc: EFUSE_RD_MAC_SYS5_REG, bloc: 'B20,B21,B22,B23'} - OPTIONAL_UNIQUE_ID : {show: y, blk : 2, word: 0, pos : 0, len: 128, start : 0, type: 'bytes:16', wr_dis : 21, rd_dis: null, alt : '', dict : '', desc: Optional unique 128-bit ID, rloc: EFUSE_RD_SYS_PART1_DATA0_REG, bloc: 'B0,B1,B2,B3,B4,B5,B6,B7,B8,B9,B10,B11,B12,B13,B14,B15'} - RESERVED_2_128 : {show: n, blk : 2, word: 4, pos : 0, len : 9, start: 128, type : 'uint:9', wr_dis : 21, rd_dis: null, alt : '', dict : '', desc: reserved, rloc: 'EFUSE_RD_SYS_PART1_DATA4_REG[8:0]', bloc: 'B16,B17[0]'} - OCODE : {show: y, blk : 2, word: 4, pos : 9, len : 8, start: 137, type : 'uint:8', wr_dis : 21, rd_dis: null, alt : '', dict : '', desc: ADC OCode, rloc: 'EFUSE_RD_SYS_PART1_DATA4_REG[16:9]', bloc: 'B17[7:1],B18[0]'} - RESERVED_2_145 : {show: n, blk : 2, word: 4, pos: 17, len : 15, start: 145, type : 'uint:15', wr_dis : 21, rd_dis: null, alt : '', dict : '', desc: reserved, rloc: 'EFUSE_RD_SYS_PART1_DATA4_REG[31:17]', bloc: 'B18[7:1],B19'} - SYS_DATA_PART1_5 : {show: n, blk : 2, word: 5, pos : 0, len : 32, start: 160, type : 'uint:32', wr_dis : 21, rd_dis: null, alt : '', dict : '', desc: Represents the zeroth 32-bit of first part of system data, rloc: EFUSE_RD_SYS_PART1_DATA5_REG, bloc: 'B20,B21,B22,B23'} - SYS_DATA_PART1_6 : {show: n, blk : 2, word: 6, pos : 0, len : 32, start: 192, type : 'uint:32', wr_dis : 21, rd_dis: null, alt : '', dict : '', desc: Represents the zeroth 32-bit of first part of system data, rloc: EFUSE_RD_SYS_PART1_DATA6_REG, bloc: 'B24,B25,B26,B27'} - SYS_DATA_PART1_7 : {show: n, blk : 2, word: 7, pos : 0, len : 32, start: 224, type : 'uint:32', wr_dis : 21, rd_dis: null, alt : '', dict : '', desc: Represents the zeroth 32-bit of first part of system data, rloc: EFUSE_RD_SYS_PART1_DATA7_REG, bloc: 'B28,B29,B30,B31'} - BLOCK_USR_DATA : {show: y, blk : 3, word: 0, pos : 0, len: 192, start : 0, type: 'bytes:24', wr_dis : 22, rd_dis: null, alt : USER_DATA, dict : '', desc: User data, rloc: EFUSE_RD_USR_DATA0_REG, bloc: 'B0,B1,B2,B3,B4,B5,B6,B7,B8,B9,B10,B11,B12,B13,B14,B15,B16,B17,B18,B19,B20,B21,B22,B23'} - RESERVED_3_192 : {show: n, blk : 3, word: 6, pos : 0, len : 8, start: 192, type : 'uint:8', wr_dis : 22, rd_dis: null, alt : '', dict : '', desc: reserved, rloc: 'EFUSE_RD_USR_DATA6_REG[7:0]', bloc: B24} - CUSTOM_MAC : {show: y, blk : 3, word: 6, pos : 8, len : 48, start: 200, type : 'bytes:6', wr_dis : 22, rd_dis: null, alt: MAC_CUSTOM USER_DATA_MAC_CUSTOM, dict : '', desc: Custom MAC, rloc: 'EFUSE_RD_USR_DATA6_REG[31:8]', bloc: 'B25,B26,B27,B28,B29,B30'} - RESERVED_3_248 : {show: n, blk : 3, word: 7, pos: 24, len : 8, start: 248, type : 'uint:8', wr_dis : 22, rd_dis: null, alt : '', dict : '', desc: reserved, rloc: 'EFUSE_RD_USR_DATA7_REG[31:24]', bloc: B31} - BLOCK_KEY0 : {show: y, blk : 4, word: 0, pos : 0, len: 256, start : 0, type: 'bytes:32', wr_dis : 23, rd_dis : 0, alt : KEY0, dict : '', desc: Key0 or user data, rloc: EFUSE_RD_KEY0_DATA0_REG, bloc: 'B0,B1,B2,B3,B4,B5,B6,B7,B8,B9,B10,B11,B12,B13,B14,B15,B16,B17,B18,B19,B20,B21,B22,B23,B24,B25,B26,B27,B28,B29,B30,B31'} - BLOCK_KEY1 : {show: y, blk : 5, word: 0, pos : 0, len: 256, start : 0, type: 'bytes:32', wr_dis : 24, rd_dis : 1, alt : KEY1, dict : '', desc: Key1 or user data, rloc: EFUSE_RD_KEY1_DATA0_REG, bloc: 'B0,B1,B2,B3,B4,B5,B6,B7,B8,B9,B10,B11,B12,B13,B14,B15,B16,B17,B18,B19,B20,B21,B22,B23,B24,B25,B26,B27,B28,B29,B30,B31'} - BLOCK_KEY2 : {show: y, blk : 6, word: 0, pos : 0, len: 256, start : 0, type: 'bytes:32', wr_dis : 25, rd_dis : 2, alt : KEY2, dict : '', desc: Key2 or user data, rloc: EFUSE_RD_KEY2_DATA0_REG, bloc: 'B0,B1,B2,B3,B4,B5,B6,B7,B8,B9,B10,B11,B12,B13,B14,B15,B16,B17,B18,B19,B20,B21,B22,B23,B24,B25,B26,B27,B28,B29,B30,B31'} - BLOCK_KEY3 : {show: y, blk : 7, word: 0, pos : 0, len: 256, start : 0, type: 'bytes:32', wr_dis : 26, rd_dis : 3, alt : KEY3, dict : '', desc: Key3 or user data, rloc: EFUSE_RD_KEY3_DATA0_REG, bloc: 'B0,B1,B2,B3,B4,B5,B6,B7,B8,B9,B10,B11,B12,B13,B14,B15,B16,B17,B18,B19,B20,B21,B22,B23,B24,B25,B26,B27,B28,B29,B30,B31'} - BLOCK_KEY4 : {show: y, blk : 8, word: 0, pos : 0, len: 256, start : 0, type: 'bytes:32', wr_dis : 27, rd_dis : 4, alt : KEY4, dict : '', desc: Key4 or user data, rloc: EFUSE_RD_KEY4_DATA0_REG, bloc: 'B0,B1,B2,B3,B4,B5,B6,B7,B8,B9,B10,B11,B12,B13,B14,B15,B16,B17,B18,B19,B20,B21,B22,B23,B24,B25,B26,B27,B28,B29,B30,B31'} - BLOCK_KEY5 : {show: y, blk : 9, word: 0, pos : 0, len: 256, start : 0, type: 'bytes:32', wr_dis : 28, rd_dis : 5, alt : KEY5, dict : '', desc: Key5 or user data, rloc: EFUSE_RD_KEY5_DATA0_REG, bloc: 'B0,B1,B2,B3,B4,B5,B6,B7,B8,B9,B10,B11,B12,B13,B14,B15,B16,B17,B18,B19,B20,B21,B22,B23,B24,B25,B26,B27,B28,B29,B30,B31'} - BLOCK_SYS_DATA2 : {show: y, blk: 10, word: 0, pos : 0, len: 256, start : 0, type: 'bytes:32', wr_dis : 29, rd_dis : 6, alt : SYS_DATA_PART2, dict : '', desc: System data part 2 (reserved), rloc: EFUSE_RD_SYS_PART2_DATA0_REG, bloc: 'B0,B1,B2,B3,B4,B5,B6,B7,B8,B9,B10,B11,B12,B13,B14,B15,B16,B17,B18,B19,B20,B21,B22,B23,B24,B25,B26,B27,B28,B29,B30,B31'} diff --git a/esptool/bin_image.py b/esptool/bin_image.py index cd52c0305f..1ee866c36b 100644 --- a/esptool/bin_image.py +++ b/esptool/bin_image.py @@ -1,4 +1,4 @@ -# SPDX-FileCopyrightText: 2014-2022 Fredrik Ahlberg, Angus Gratton, +# SPDX-FileCopyrightText: 2014-2025 Fredrik Ahlberg, Angus Gratton, # Espressif Systems (Shanghai) CO LTD, other contributors as noted. # # SPDX-License-Identifier: GPL-2.0-or-later @@ -21,18 +21,13 @@ ESP32C2ROM, ESP32C3ROM, ESP32C5ROM, - ESP32C5BETA3ROM, - ESP32C6BETAROM, ESP32C6ROM, ESP32C61ROM, - ESP32H2BETA1ROM, - ESP32H2BETA2ROM, ESP32H2ROM, ESP32H21ROM, ESP32P4ROM, ESP32ROM, ESP32S2ROM, - ESP32S3BETA2ROM, ESP32S3ROM, ESP8266ROM, ) @@ -83,17 +78,12 @@ def select_image_class(f, chip): return { "esp32": ESP32FirmwareImage, "esp32s2": ESP32S2FirmwareImage, - "esp32s3beta2": ESP32S3BETA2FirmwareImage, "esp32s3": ESP32S3FirmwareImage, "esp32c3": ESP32C3FirmwareImage, - "esp32c6beta": ESP32C6BETAFirmwareImage, - "esp32h2beta1": ESP32H2BETA1FirmwareImage, - "esp32h2beta2": ESP32H2BETA2FirmwareImage, "esp32c2": ESP32C2FirmwareImage, "esp32c6": ESP32C6FirmwareImage, "esp32c61": ESP32C61FirmwareImage, "esp32c5": ESP32C5FirmwareImage, - "esp32c5beta3": ESP32C5BETA3FirmwareImage, "esp32h2": ESP32H2FirmwareImage, "esp32h21": ESP32H21FirmwareImage, "esp32p4": ESP32P4FirmwareImage, @@ -1066,15 +1056,6 @@ class ESP32S2FirmwareImage(ESP32FirmwareImage): ESP32S2ROM.BOOTLOADER_IMAGE = ESP32S2FirmwareImage -class ESP32S3BETA2FirmwareImage(ESP32FirmwareImage): - """ESP32S3 Firmware Image almost exactly the same as ESP32FirmwareImage""" - - ROM_LOADER = ESP32S3BETA2ROM - - -ESP32S3BETA2ROM.BOOTLOADER_IMAGE = ESP32S3BETA2FirmwareImage - - class ESP32S3FirmwareImage(ESP32FirmwareImage): """ESP32S3 Firmware Image almost exactly the same as ESP32FirmwareImage""" @@ -1093,33 +1074,6 @@ class ESP32C3FirmwareImage(ESP32FirmwareImage): ESP32C3ROM.BOOTLOADER_IMAGE = ESP32C3FirmwareImage -class ESP32C6BETAFirmwareImage(ESP32FirmwareImage): - """ESP32C6 Firmware Image almost exactly the same as ESP32FirmwareImage""" - - ROM_LOADER = ESP32C6BETAROM - - -ESP32C6BETAROM.BOOTLOADER_IMAGE = ESP32C6BETAFirmwareImage - - -class ESP32H2BETA1FirmwareImage(ESP32FirmwareImage): - """ESP32H2 Firmware Image almost exactly the same as ESP32FirmwareImage""" - - ROM_LOADER = ESP32H2BETA1ROM - - -ESP32H2BETA1ROM.BOOTLOADER_IMAGE = ESP32H2BETA1FirmwareImage - - -class ESP32H2BETA2FirmwareImage(ESP32FirmwareImage): - """ESP32H2 Firmware Image almost exactly the same as ESP32FirmwareImage""" - - ROM_LOADER = ESP32H2BETA2ROM - - -ESP32H2BETA2ROM.BOOTLOADER_IMAGE = ESP32H2BETA2FirmwareImage - - class ESP32C2FirmwareImage(ESP32FirmwareImage): """ESP32C2 Firmware Image almost exactly the same as ESP32FirmwareImage""" @@ -1172,15 +1126,6 @@ class ESP32C5FirmwareImage(ESP32C6FirmwareImage): ESP32C5ROM.BOOTLOADER_IMAGE = ESP32C5FirmwareImage -class ESP32C5BETA3FirmwareImage(ESP32C6FirmwareImage): - """ESP32C5BETA3 Firmware Image almost exactly the same as ESP32C6FirmwareImage""" - - ROM_LOADER = ESP32C5BETA3ROM - - -ESP32C5BETA3ROM.BOOTLOADER_IMAGE = ESP32C5BETA3FirmwareImage - - class ESP32P4FirmwareImage(ESP32FirmwareImage): """ESP32P4 Firmware Image almost exactly the same as ESP32FirmwareImage""" diff --git a/esptool/loader.py b/esptool/loader.py index 5376baaf5a..90246e401a 100644 --- a/esptool/loader.py +++ b/esptool/loader.py @@ -1,4 +1,4 @@ -# SPDX-FileCopyrightText: 2014-2023 Fredrik Ahlberg, Angus Gratton, +# SPDX-FileCopyrightText: 2014-2025 Fredrik Ahlberg, Angus Gratton, # Espressif Systems (Shanghai) CO LTD, other contributors as noted. # # SPDX-License-Identifier: GPL-2.0-or-later @@ -292,7 +292,14 @@ class ESPLoader(object): USB_JTAG_SERIAL_PID = 0x1001 # Chip IDs that are no longer supported by esptool - UNSUPPORTED_CHIPS = {6: "ESP32-S3(beta 3)"} + UNSUPPORTED_CHIPS = { + 4: "ESP32-S3(beta2)", + 6: "ESP32-S3(beta3)", + 7: "ESP32-C6(beta)", + 10: "ESP32-H2(beta1)", + 14: "ESP32-H2(beta2)", + 17: "ESP32-C5(beta3)", + } # Number of attempts to write flash data WRITE_FLASH_ATTEMPTS = 2 diff --git a/esptool/targets/__init__.py b/esptool/targets/__init__.py index 08900107f6..bcf9a179e3 100644 --- a/esptool/targets/__init__.py +++ b/esptool/targets/__init__.py @@ -2,18 +2,13 @@ from .esp32c2 import ESP32C2ROM from .esp32c3 import ESP32C3ROM from .esp32c5 import ESP32C5ROM -from .esp32c5beta3 import ESP32C5BETA3ROM from .esp32c6 import ESP32C6ROM from .esp32c61 import ESP32C61ROM -from .esp32c6beta import ESP32C6BETAROM from .esp32h2 import ESP32H2ROM from .esp32h21 import ESP32H21ROM -from .esp32h2beta1 import ESP32H2BETA1ROM -from .esp32h2beta2 import ESP32H2BETA2ROM from .esp32p4 import ESP32P4ROM from .esp32s2 import ESP32S2ROM from .esp32s3 import ESP32S3ROM -from .esp32s3beta2 import ESP32S3BETA2ROM from .esp8266 import ESP8266ROM @@ -21,17 +16,12 @@ "esp8266": ESP8266ROM, "esp32": ESP32ROM, "esp32s2": ESP32S2ROM, - "esp32s3beta2": ESP32S3BETA2ROM, "esp32s3": ESP32S3ROM, "esp32c3": ESP32C3ROM, - "esp32c6beta": ESP32C6BETAROM, - "esp32h2beta1": ESP32H2BETA1ROM, - "esp32h2beta2": ESP32H2BETA2ROM, "esp32c2": ESP32C2ROM, "esp32c6": ESP32C6ROM, "esp32c61": ESP32C61ROM, "esp32c5": ESP32C5ROM, - "esp32c5beta3": ESP32C5BETA3ROM, "esp32h2": ESP32H2ROM, "esp32h21": ESP32H21ROM, "esp32p4": ESP32P4ROM, diff --git a/esptool/targets/esp32c5beta3.py b/esptool/targets/esp32c5beta3.py deleted file mode 100644 index 3d0a8c7157..0000000000 --- a/esptool/targets/esp32c5beta3.py +++ /dev/null @@ -1,114 +0,0 @@ -# SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD -# -# SPDX-License-Identifier: GPL-2.0-or-later - -import struct -import time -from typing import Dict - -from .esp32c6 import ESP32C6ROM -from ..loader import ESPLoader, StubMixin -from ..logger import log - - -class ESP32C5BETA3ROM(ESP32C6ROM): - CHIP_NAME = "ESP32-C5(beta3)" - IMAGE_CHIP_ID = 17 - - IROM_MAP_START = 0x41000000 - IROM_MAP_END = 0x41800000 - DROM_MAP_START = 0x41000000 - DROM_MAP_END = 0x41800000 - - FLASH_FREQUENCY = { - "80m": 0xF, - "40m": 0x0, - "20m": 0x2, - } - - MEMORY_MAP = [ - [0x00000000, 0x00010000, "PADDING"], - [0x41800000, 0x42000000, "DROM"], - [0x40800000, 0x40880000, "DRAM"], - [0x40800000, 0x40880000, "BYTE_ACCESSIBLE"], - [0x4004A000, 0x40050000, "DROM_MASK"], - [0x40000000, 0x4004A000, "IROM_MASK"], - [0x41000000, 0x41800000, "IROM"], - [0x40800000, 0x40880000, "IRAM"], - [0x50000000, 0x50004000, "RTC_IRAM"], - [0x50000000, 0x50004000, "RTC_DRAM"], - [0x600FE000, 0x60100000, "MEM_INTERNAL2"], - ] - - EFUSE_MAX_KEY = 5 - KEY_PURPOSES: Dict[int, str] = { - 0: "USER/EMPTY", - 1: "ECDSA_KEY", - 2: "XTS_AES_256_KEY_1", - 3: "XTS_AES_256_KEY_2", - 4: "XTS_AES_128_KEY", - 5: "HMAC_DOWN_ALL", - 6: "HMAC_DOWN_JTAG", - 7: "HMAC_DOWN_DIGITAL_SIGNATURE", - 8: "HMAC_UP", - 9: "SECURE_BOOT_DIGEST0", - 10: "SECURE_BOOT_DIGEST1", - 11: "SECURE_BOOT_DIGEST2", - 12: "KM_INIT_KEY", - } - - def get_pkg_version(self): - num_word = 2 - return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 26) & 0x07 - - def get_minor_chip_version(self): - num_word = 2 - return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 0) & 0x0F - - def get_major_chip_version(self): - num_word = 2 - return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 4) & 0x03 - - def get_chip_description(self): - chip_name = { - 0: "ESP32-C5 beta3 (QFN40)", - }.get(self.get_pkg_version(), "unknown ESP32-C5 beta3") - major_rev = self.get_major_chip_version() - minor_rev = self.get_minor_chip_version() - return f"{chip_name} (revision v{major_rev}.{minor_rev})" - - def get_crystal_freq(self): - # The crystal detection algorithm of ESP32/ESP8266 - # works for ESP32-C5 beta3 as well. - return ESPLoader.get_crystal_freq(self) - - def change_baud(self, baud): - rom_with_48M_XTAL = not self.IS_STUB and self.get_crystal_freq() == 48 - if rom_with_48M_XTAL: - # The code is copied over from ESPLoader.change_baud(). - # Probably this is just a temporary solution until the next chip revision. - - # The ROM code thinks it uses a 40 MHz XTAL. Recompute the baud rate - # in order to trick the ROM code to set the correct baud rate for - # a 48 MHz XTAL. - false_rom_baud = baud * 40 // 48 - - log.print(f"Changing baud rate to {baud}") - self.command( - self.ESP_CHANGE_BAUDRATE, struct.pack("> 0) & 0x07 - - def get_minor_chip_version(self): - num_word = 3 - return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 18) & 0x07 - - def get_major_chip_version(self): - num_word = 3 - return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 21) & 0x03 - - def get_chip_description(self): - chip_name = { - 0: "ESP32-H2", - }.get(self.get_pkg_version(), "unknown ESP32-H2") - major_rev = self.get_major_chip_version() - minor_rev = self.get_minor_chip_version() - return f"{chip_name} (revision v{major_rev}.{minor_rev})" - - def get_chip_features(self): - return ["BLE", "IEEE802.15.4"] - - def get_crystal_freq(self): - return 32 - - def override_vddsdio(self, new_voltage): - raise NotImplementedInROMError( - "VDD_SDIO overrides are not supported for ESP32-H2" - ) - - def read_mac(self, mac_type="BASE_MAC"): - """Read MAC from EFUSE region""" - if mac_type != "BASE_MAC": - return None - mac0 = self.read_reg(self.MAC_EFUSE_REG) - mac1 = self.read_reg(self.MAC_EFUSE_REG + 4) # only bottom 16 bits are MAC - bitstring = struct.pack(">II", mac1, mac0)[2:] - return tuple(bitstring) - - def get_flash_crypt_config(self): - return None # doesn't exist on ESP32-H2 - - def get_key_block_purpose(self, key_block): - if key_block < 0 or key_block > self.EFUSE_MAX_KEY: - raise FatalError( - f"Valid key block numbers must be in range 0-{self.EFUSE_MAX_KEY}" - ) - - reg, shift = [ - (self.EFUSE_PURPOSE_KEY0_REG, self.EFUSE_PURPOSE_KEY0_SHIFT), - (self.EFUSE_PURPOSE_KEY1_REG, self.EFUSE_PURPOSE_KEY1_SHIFT), - (self.EFUSE_PURPOSE_KEY2_REG, self.EFUSE_PURPOSE_KEY2_SHIFT), - (self.EFUSE_PURPOSE_KEY3_REG, self.EFUSE_PURPOSE_KEY3_SHIFT), - (self.EFUSE_PURPOSE_KEY4_REG, self.EFUSE_PURPOSE_KEY4_SHIFT), - (self.EFUSE_PURPOSE_KEY5_REG, self.EFUSE_PURPOSE_KEY5_SHIFT), - ][key_block] - return (self.read_reg(reg) >> shift) & 0xF - - def is_flash_encryption_key_valid(self): - # Need to see an AES-128 key - purposes = [ - self.get_key_block_purpose(b) for b in range(self.EFUSE_MAX_KEY + 1) - ] - - return any(p == self.PURPOSE_VAL_XTS_AES128_KEY for p in purposes) - - def _post_connect(self): - pass - - -class ESP32H2BETA1StubLoader(StubMixin, ESP32H2BETA1ROM): - """Stub loader for ESP32-H2(beta1), runs on top of ROM.""" - - pass - - -ESP32H2BETA1ROM.STUB_CLASS = ESP32H2BETA1StubLoader diff --git a/esptool/targets/esp32h2beta2.py b/esptool/targets/esp32h2beta2.py deleted file mode 100644 index 149bed1864..0000000000 --- a/esptool/targets/esp32h2beta2.py +++ /dev/null @@ -1,29 +0,0 @@ -# SPDX-FileCopyrightText: 2025 Fredrik Ahlberg, Angus Gratton, -# Espressif Systems (Shanghai) CO LTD, other contributors as noted. -# -# SPDX-License-Identifier: GPL-2.0-or-later - -from .esp32h2beta1 import ESP32H2BETA1ROM -from ..loader import StubMixin - - -class ESP32H2BETA2ROM(ESP32H2BETA1ROM): - CHIP_NAME = "ESP32-H2(beta2)" - IMAGE_CHIP_ID = 14 - - def get_chip_description(self): - chip_name = { - 1: "ESP32-H2(beta2)", - }.get(self.get_pkg_version(), "unknown ESP32-H2") - major_rev = self.get_major_chip_version() - minor_rev = self.get_minor_chip_version() - return f"{chip_name} (revision v{major_rev}.{minor_rev})" - - -class ESP32H2BETA2StubLoader(StubMixin, ESP32H2BETA2ROM): - """Stub loader for ESP32-H2(beta2), runs on top of ROM.""" - - pass - - -ESP32H2BETA2ROM.STUB_CLASS = ESP32H2BETA2StubLoader diff --git a/esptool/targets/esp32s3beta2.py b/esptool/targets/esp32s3beta2.py deleted file mode 100644 index 53099ebcd4..0000000000 --- a/esptool/targets/esp32s3beta2.py +++ /dev/null @@ -1,23 +0,0 @@ -# SPDX-FileCopyrightText: 2025 Fredrik Ahlberg, Angus Gratton, -# Espressif Systems (Shanghai) CO LTD, other contributors as noted. -# -# SPDX-License-Identifier: GPL-2.0-or-later - -from .esp32s3 import ESP32S3ROM -from ..loader import StubMixin - - -class ESP32S3BETA2ROM(ESP32S3ROM): - CHIP_NAME = "ESP32-S3(beta2)" - IMAGE_CHIP_ID = 4 - - EFUSE_BASE = 0x6001A000 # BLOCK0 read base address - - -class ESP32S3BETA2StubLoader(StubMixin, ESP32S3BETA2ROM): - """Stub loader for ESP32-S3(beta2), runs on top of ROM.""" - - pass - - -ESP32S3BETA2ROM.STUB_CLASS = ESP32S3BETA2StubLoader diff --git a/esptool/targets/stub_flasher/1/esp32c5beta3.json b/esptool/targets/stub_flasher/1/esp32c5beta3.json deleted file mode 100644 index c41e549ca9..0000000000 --- a/esptool/targets/stub_flasher/1/esp32c5beta3.json +++ /dev/null @@ -1,8 +0,0 @@ -{ - "entry": 1082131910, - "text": "ARG3BwBgTsaDqYcASsg3CYRAJspSxAbOIsy3BABgfVoTCQkAwEwTdPQ/DeDyQGJEI6g0AUJJ0kSySSJKBWGCgIhAgycJABN19Q+Cl30U4xlE/8m/EwcADJRBqodjGOUAhUeFxiOgBQB5VYKABUdjh+YACUZjjcYAfVWCgEIFEwewDUGFY5XnAolHnMH1t5MGwA1jFtUAmMETBQAMgoCTBtANfVVjldcAmMETBbANgoC3NYVAQRGThQW6BsZhP2NFBQa3N4VAk4eHsQOnBwgD1kcIE3X1D5MGFgDCBsGCI5LXCDKXIwCnAAPXRwiRZ5OHBwRjHvcCN7eEQBMHh7GhZ7qXA6YHCLf2hEC3N4VAk4eHsZOGhrVjH+YAI6bHCCOg1wgjkgcIIaD5V+MG9fyyQEEBgoAjptcII6DnCN23NzcAYHxLnYv1/zcnAGB8S52L9f+CgEERBsbdN7c3AGAjpgcCNwcACJjDmEN9/8hXskATRfX/BYlBAYKAQREGxtk/fd03BwBAtzcAYJjDNzcAYBxD/f+yQEEBgoBBESLEN4SEQJMHxABKwAOpBwEGxibCYwoJBEU3OcW9RxMExACBRGPWJwEERL2Ik7QUAH03hT8cRDcGgAATl8cAmeA3BgABt/b/AHWPtzYAYNjCkMKYQn3/QUeR4AVHMwnpQLqXIygkARzEskAiRJJEAklBAYKAQREGxhMHAAxjEOUCEwWwDZcAgP/ngIDjEwXADbJAQQEXA4D/ZwCD4hMHsA3jGOX+lwCA/+eAgOETBdANxbdBESLEJsIGxiqEswS1AGMXlACyQCJEkkRBAYKAA0UEAAUERTfttxMFAAwXA4D/ZwAD3jVxJstOx/1yhWn9dCLNSslSxVbDBs+ThIT6FpGThwkHppcYCLOE5wAqiSaFLoSXAID/54DgSJOHCQcYCAVqupezikdBMeQFZ311kwWF+pMHBwcTBYX5FAiqlzOF1wCTBwcHrpezhdcAKsaXAID/54CgRTJFwUWhPwFFhWIWkfpAakTaREpJukkqSppKDWGCgKKJY3OKAIVpTobWhUqFlwCA/+eA4OITdfUPAe1OhtaFJoWXAID/54DgQE6ZMwQ0QVG3EwUwBlW/MXH9ck7XUtVW017PBt8i3SbbStla0WLNZstqyW7HqokWkRMFAAIuirKKtosCypcAgP/ngKA7hWdj4FcThWR9dBMEhPqThwQHopcYCDOE5wAihZcAgP/ngCA6fXsTDDv5kwyL+ROHBAeThwQHFAhil+aXAUkzDNcAs4zXAFJNY3xNCWNxqQNBqFU1poUIAaU9cT0mhgwBIoWXAID/54AANqaZJpljdUkDswepQWPxdwOzBCpBY/OaANaEJoYMAU6FlwCA/+eAQNQTdfUPVd0CzIFEeV2NTaMJAQBihZcAgP/ngMDDffkDRTEB5oUFMWNPBQDj4p3+hWeThwcHppcYCLqX2pcjiqf4hQTxt+MVpf2RR+OF9PYFZ311kwcHB5MFhfoTBYX5FAiqlzOF1wCTBwcHrpezhdcAKsaXAID/54AgLO0zMkXBRX07zTMTBQAClwCA/+eAwCmFYhaR+lBqVNpUSlm6WSpamloKW/pLakzaTEpNuk0pYYKAAREGziLMnTk3BM4/bAATBUT/lwCA/+eAwMqqhwVFleeyR5P3ByA+xkE5NzcAYBxHtwZAABMFRP/VjxzHskWXAID/54BAyDM1oADyQGJEBWGCgEERt4eEQAbGk4fHAAVHI4DnABPXxQCYxwVnfRfMw8jH+Y06laqVsYGMyyOqBwBBNxnBEwVQDLJAQQGCgAERIsw3hIRAkwfEACbKxEdOxgbOSsiqiRMExABj85UAroSpwAMpRAAmmRNZyQAcSGNV8AAcRGNe+QLpNn3dSEAmhs6FlwCA/+eAQLsTdfUPAcWTB0AMXMhcQKaXXMBcRIWPXMTyQGJE0kRCSbJJBWGCgOE+bb+3V0FJGXGTh/eEAUU+zobeotym2srYztbS1NbS2tDezuLM5srqyO7GlwCA/+eAoK23B4RANzeFQJOHBwATB4e6Y+DnFK0xkUVoCD05jTG3t4RAk4eHsSFnPpcjIPcItwWAQLcHgEABRpOHBwuThQUANwmEQBVFIyD5AJcAgP/ngMAONwcAYFxHEwUAAreEhECT5xcQXMeXAID/54CADbcXCWCIX4FFtzmFQHGJYRUTNRUAlwCA/+eAQLbBZ/0XEwcAEIVmQWa3BQABAUWThMQAtwqEQA1qlwCA/+eAAKyTiYmxEwkJABOLygAmmoOnyQj134OryQiFRyOmCQgjAvECg8cbAAlHIxPhAqMC8QIC1E1HY4vnBlFHY4nnBilHY5/nAIPHOwADxysAogfZjxFHY5bnAIOniwCcQz7UjT6hRUgQmTaDxzsAA8crAKIH2Y8RZ0EHY373AhMFsA2XAID/54BgkxMFwA2XAID/54CgkhMF4A6XAID/54DgkQ0+vbcjoAcAkQdtvclHIxPxAn23A8cbANFGY+fmAoVGY+bmAAFMEwTwD52oeRcTd/cPyUbj6Ob+tzaFQAoHk4bGujaXGEMCh5MGBwOT9vYPEUbjadb8Ewf3AhN39w+NRmPu5gi3NoVACgeThoa/NpcYQwKHEwdAAmOa5xAC1B1EAUWXAID/54BAiQFFiTRVNE00oUVIEH0UlTx98AFMAUQTdfQPLTQTdfwPFTRZNOMRBOyDxxsASUdjZfcwCUfjeffq9ReT9/cPPUfjY/fqNzeFQIoHEweHwLqXnEOChwVEnetwEIFFAUWXAID/54BgiR3h0UVoEBk8AUQxqAVEge+XAID/54DgjTM0oAApoCFHY4XnAAVEAUxhtwOsiwADpMsAs2eMANIH9feZOWX1wWwinP0cfX0zBYxAXdyzd5UBlePBbDMFjEBj5owC/XwzBYxAXdAxgZcAgP/ngICKXflmlPW3MYGXAID/54CAiV3xapTRt0GBlwCA/+eAwIhZ+TMElEHBtyFH44rn8AFMEwQADDm3QUfNv0FHBUTjnef2g6XLAAOliwBZOrm/QUcFROOT5/YDpwsBkWdj6Oceg6VLAQOliwAxMYG3QUcFROOU5/SDpwsBEWdjafccA6fLAIOlSwEDpYsAM4TnAt02I6wEACMkirAJvwPHBABjAwcUA6eLAMEXEwQADGMT9wDASAFHkwbwDmNG9wKDx1sAA8dLAAFMogfZjwPHawBCB12Pg8d7AOIH2Y/jhPbmEwQQDIW1M4brAANGhgEFB7GO4beDxwQA/cfcRGOdBxTASCOABABVvWFHY5bnAoOnywEDp4sBg6ZLAQOmCwGDpcsAA6WLAJfwf//ngIB5KowzNKAAAb0BTAVEKbURRwVE453n5reXAGC0X2V3fRcFZvmO0Y4DpYsAtN+0V4FF+Y7RjrTX9F/5jtGO9N/0U3WPUY/405fwf//ngKB8BbUT9/cA4xcH6pPcRwAThIsAAUx9XeN3nNtIRJfwf//ngGBgGERUQBBA+Y5jB6cBHEITR/f/fY/ZjhTCBQxBBNm/EUe1tUFHBUTjmufeg6eLAAOnSwEjJPkAIyLpAMmzgyVJAMEXkeWJzwFMEwRgDKG7AyeJAGNm9wYT9zcA4xsH4gMoiQABRgFHMwXoQLOG5QBjafcA4wcG0iMkqQAjItkADbMzhusAEE4RB5DCBUbpvyFHBUTjlOfYAySJABnAEwSADCMkCQAjIgkAMzSAAL2zAUwTBCAMxbkBTBMEgAzlsQFMEwSQDMWxEwcgDWOD5wwTB0AN45HnugPEOwCDxysAIgRdjJfwf//ngIBfA6zEAEEUY3OEASKM4w8MtsBAYpQxgJxIY1XwAJxEY1r0Cu/wr+B13chAYoaThYsBl/B//+eAgFsBxZMHQAzcyNxA4pfcwNxEs4eHQdzEl/B//+eAYFoVvgllEwUFcQOsywADpIsAl/B//+eA4Eq3BwBg2Eu3BgABwRaTV0cBEgd1j72L2Y+zh4cDAUWz1YcCl/B//+eAQEwTBYA+l/B//+eAgEfdtIOmSwEDpgsBg6XLAAOliwDv8K/2wbyDxTsAg8crABOFiwGiBd2NwRWpOm287/AP2oG3A8Q7AIPHKwATjIsBIgRdjNxEQRTF45FHhUtj/ocIkweQDNzIebQDpw0AItAFSLOH7EA+1oMnirBjc/QADUhCxjrE7/CP1SJHMkg3hYRA4oV8EJOGygAQEBMFRQKX8H//54AASje3hECTCMcAglcDp4iwg6UNAB2MHY8+nLJXI6TosKqLvpUjoL0Ak4fKAJ2NAcWhZ2OW9QBahV04I6BtAQnE3ESZw+NAcPlj3wsAkwdwDIW/hUu3PYVAt4yEQJONjbqTjMwA6b/jlQue3ETjggeekweADLG3g6eLAOObB5wBRZfwf//ngCA5CWUTBQVxl/B//+eAwDSX8H//54DAOU26A6TLAOMGBJoBRZfwf//ngIA2EwWAPpfwf//ngEAyApRBuvZQZlTWVEZZtlkmWpZaBlv2S2ZM1kxGTbZNCWGCgAAA", - "text_start": 1082130432, - "data": "DACEQO4IgEA6CYBAkgmAQGAKgEDMCoBAegqAQLYHgEAcCoBAXAqAQKYJgEBmB4BA2gmAQGYHgEDICIBADAmAQDoJgECSCYBA2giAQCAIgEBQCIBA1giAQCQNgEA6CYBA5AuAQNgMgECyBoBAAg2AQLIGgECyBoBAsgaAQLIGgECyBoBAsgaAQLIGgECyBoBAgAuAQLIGgEAADIBA2AyAQA==", - "data_start": 1082469288, - "bss_start": 1082392576 -} \ No newline at end of file diff --git a/esptool/targets/stub_flasher/1/esp32c6beta.json b/esptool/targets/stub_flasher/1/esp32c6beta.json deleted file mode 100644 index 7fd5c0ec6c..0000000000 --- a/esptool/targets/stub_flasher/1/esp32c6beta.json +++ /dev/null @@ -1,8 +0,0 @@ -{ - "entry": 1077413318, - "text": "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", - "text_start": 1077411840, - "data": "DEDIP/gIOEBECThAnAk4QGoKOEDWCjhAhAo4QMAHOEAmCjhAZgo4QLAJOEBwBzhA5Ak4QHAHOEDSCDhAFgk4QEQJOECcCThA5Ag4QCoIOEBaCDhA4Ag4QC4NOEBECThA7gs4QOIMOEC8BjhADA04QLwGOEC8BjhAvAY4QLwGOEC8BjhAvAY4QLwGOEC8BjhAigs4QLwGOEAKDDhA4gw4QA==", - "data_start": 1070164904, - "bss_start": 1070088192 -} \ No newline at end of file diff --git a/esptool/targets/stub_flasher/1/esp32h2beta1.json b/esptool/targets/stub_flasher/1/esp32h2beta1.json deleted file mode 100644 index 03e110c5c2..0000000000 --- a/esptool/targets/stub_flasher/1/esp32h2beta1.json +++ /dev/null @@ -1,8 +0,0 @@ -{ - "entry": 1077413318, - "text": "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", - "text_start": 1077411840, - "data": "DEDIP/gIOEBECThAnAk4QGoKOEDWCjhAhAo4QMAHOEAmCjhAZgo4QLAJOEBwBzhA5Ak4QHAHOEDSCDhAFgk4QEQJOECcCThA5Ag4QCoIOEBaCDhA4Ag4QC4NOEBECThA7gs4QOIMOEC8BjhADA04QLwGOEC8BjhAvAY4QLwGOEC8BjhAvAY4QLwGOEC8BjhAigs4QLwGOEAKDDhA4gw4QA==", - "data_start": 1070164904, - "bss_start": 1070088192 -} \ No newline at end of file diff --git a/esptool/targets/stub_flasher/1/esp32h2beta2.json b/esptool/targets/stub_flasher/1/esp32h2beta2.json deleted file mode 100644 index ce3afe7ac0..0000000000 --- a/esptool/targets/stub_flasher/1/esp32h2beta2.json +++ /dev/null @@ -1,8 +0,0 @@ -{ - "entry": 1077413318, - "text": "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", - "text_start": 1077411840, - "data": "DEDIP/gIOEBECThAnAk4QGoKOEDWCjhAhAo4QMAHOEAmCjhAZgo4QLAJOEBwBzhA5Ak4QHAHOEDSCDhAFgk4QEQJOECcCThA5Ag4QCoIOEBaCDhA4Ag4QC4NOEBECThA7gs4QOIMOEC8BjhADA04QLwGOEC8BjhAvAY4QLwGOEC8BjhAvAY4QLwGOEC8BjhAigs4QLwGOEAKDDhA4gw4QA==", - "data_start": 1070164904, - "bss_start": 1070088192 -} \ No newline at end of file diff --git a/esptool/targets/stub_flasher/1/esp32s3beta2.json b/esptool/targets/stub_flasher/1/esp32s3beta2.json deleted file mode 100644 index da770f7b97..0000000000 --- a/esptool/targets/stub_flasher/1/esp32s3beta2.json +++ /dev/null @@ -1,8 +0,0 @@ -{ - "entry": 1077380596, - "text": "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", - "text_start": 1077379072, - "data": "DADKPxeIN0CriDdAw403QDeJN0DLiDdAN4k3QJaJN0C2ijdAKIs3QNGKN0ChhzdASIo3QKiKN0C5iTdATIs3QOGJN0BMizdAmYg3QPiIN0A3iTdAlok3QLGIN0DjhzdABIw3QIWNN0DAhjdAp403QMCGN0DAhjdAwIY3QMCGN0DAhjdAwIY3QMCGN0DAhjdAqYs3QMCGN0CZjDdAhY03QA==", - "data_start": 1070279592, - "bss_start": 1070202880 -} \ No newline at end of file diff --git a/test/images/ram_helloworld/source/Makefile b/test/images/ram_helloworld/source/Makefile index 0132b9ebee..1378440f2c 100644 --- a/test/images/ram_helloworld/source/Makefile +++ b/test/images/ram_helloworld/source/Makefile @@ -21,7 +21,6 @@ BUILD_DIR = build APP_ELF_8266 = $(BUILD_DIR)/$(APP)-esp8266.elf APP_ELF_32 = $(BUILD_DIR)/$(APP)-esp32.elf APP_ELF_32S2 = $(BUILD_DIR)/$(APP)-esp32s2.elf -APP_ELF_32S3_BETA_2 = $(BUILD_DIR)/$(APP)-esp32s3beta2.elf APP_ELF_32S3 = $(BUILD_DIR)/$(APP)-esp32s3.elf APP_ELF_32C3 = $(BUILD_DIR)/$(APP)-esp32c3.elf APP_ELF_32C2 = $(BUILD_DIR)/$(APP)-esp32c2.elf @@ -61,10 +60,6 @@ $(APP_ELF_32S2): $(SRCS) $(BUILD_DIR) ld/app_32s2.ld @echo " CC(32S2) $^ -> $@" $(Q) $(CROSS_32S2)gcc $(CFLAGS) -DESP32S2=1 -Tapp_32s2.ld -Wl,-Map=$(@:.elf=.map) -o $@ $(filter %.c, $^) $(LDLIBS) -$(APP_ELF_32S3_BETA_2): $(SRCS) $(BUILD_DIR) ld/app_32s3_beta_2.ld - @echo " CC(32S3) $^ -> $@" - $(Q) $(CROSS_32S3)gcc $(CFLAGS) -DESP32S3=1 -Tapp_32s3.ld -Wl,-Map=$(@:.elf=.map) -o $@ $(filter %.c, $^) $(LDLIBS) - $(APP_ELF_32S3): $(SRCS) $(BUILD_DIR) ld/app_32s3.ld @echo " CC(32S3) $^ -> $@" $(Q) $(CROSS_32S3)gcc $(CFLAGS) -DESP32S3=1 -Tapp_32s3.ld -Wl,-Map=$(@:.elf=.map) -o $@ $(filter %.c, $^) $(LDLIBS) diff --git a/test/test_espefuse.py b/test/test_espefuse.py index d83a7783ac..68996d3fcc 100755 --- a/test/test_espefuse.py +++ b/test/test_espefuse.py @@ -1,8 +1,8 @@ # HOST_TEST for espefuse.py using the pytest framework # -# Supports esp32, esp32s2, esp32s3beta2, esp32s3, -# esp32c3, esp32h2beta1, esp32c2, esp32c6, esp32p4, -# esp32c61, esp32c5, esp32c5beta3. +# Supports esp32, esp32s2, esp32s3, esp32c3, +# esp32c2, esp32c6, esp32p4, esp32c61, +# esp32c5, # # How to use: # @@ -238,11 +238,11 @@ def test_adc_info(self): def test_adc_info_2(self): if arg_chip == "esp32": self.espefuse_py("burn_efuse BLK3_PART_RESERVE 1") - elif arg_chip in ["esp32c3", "esp32s3", "esp32s3beta2"]: + elif arg_chip in ["esp32c3", "esp32s3"]: self.espefuse_py("burn_efuse BLK_VERSION_MAJOR 1") elif arg_chip in ["esp32c2", "esp32s2", "esp32c6"]: self.espefuse_py("burn_efuse BLK_VERSION_MINOR 1") - elif arg_chip in ["esp32h2", "esp32h2beta1", "esp32p4"]: + elif arg_chip in ["esp32h2", "esp32p4"]: self.espefuse_py("burn_efuse BLK_VERSION_MINOR 2") self.espefuse_py("adc_info") @@ -337,9 +337,7 @@ def test_read_protect_efuse4(self): ) else: key1_purpose = ( - "USER" - if arg_chip in ["esp32p4", "esp32c61", "esp32c5", "esp32c5beta3"] - else "RESERVED" + "USER" if arg_chip in ["esp32p4", "esp32c61", "esp32c5"] else "RESERVED" ) self.espefuse_py( f"burn_key BLOCK_KEY0 {IMAGES_DIR}/256bit USER \ @@ -428,11 +426,9 @@ def test_write_protect_efuse(self): BLOCK_KEY2 BLOCK_KEY3 BLOCK_KEY4 BLOCK_KEY5""" if arg_chip not in [ "esp32h2", - "esp32h2beta1", "esp32c6", "esp32c61", "esp32c5", - "esp32c5beta3", ]: efuse_lists += """ DIS_DOWNLOAD_ICACHE SPI_PAD_CONFIG_CLK SPI_PAD_CONFIG_Q @@ -757,7 +753,7 @@ def test_burn_efuse(self): SECURE_BOOT_EN 1 \ UART_PRINT_CONTROL 1" ) - if arg_chip not in ["esp32c5", "esp32c5beta3", "esp32c61"]: + if arg_chip not in ["esp32c5", "esp32c61"]: # chips having the OPTIONAL_UNIQUE_ID field self.espefuse_py( "burn_efuse \ @@ -965,14 +961,11 @@ def test_burn_key_one_key_block_with_fe_and_sb_keys(self): not in [ "esp32s2", "esp32s3", - "esp32s3beta1", "esp32c3", - "esp32h2beta1", "esp32c6", "esp32h2", "esp32p4", "esp32c5", - "esp32c5beta3", "esp32c61", ], reason="Only chips with 6 keys", @@ -986,9 +979,7 @@ def test_burn_key_with_6_keys(self): "esp32c3", "esp32c6", "esp32h2", - "esp32h2beta1", "esp32c5", - "esp32c5beta3", ]: cmd = cmd.replace("XTS_AES_256_KEY_1", "XTS_AES_128_KEY") cmd = cmd.replace("XTS_AES_256_KEY_2", "XTS_AES_128_KEY") @@ -1156,7 +1147,7 @@ def test_burn_key_512bit_non_consecutive_blocks_loop_around(self): ) in output @pytest.mark.skipif( - arg_chip not in ["esp32h2", "esp32c5", "esp32c5beta3", "esp32c61", "esp32p4"], + arg_chip not in ["esp32h2", "esp32c5", "esp32c61", "esp32p4"], reason="These chips support ECDSA_KEY", ) def test_burn_key_ecdsa_key(self): @@ -1182,7 +1173,7 @@ def test_burn_key_ecdsa_key(self): ) in output @pytest.mark.skipif( - arg_chip not in ["esp32h2", "esp32c5", "esp32c5beta3", "esp32c61", "esp32p4"], + arg_chip not in ["esp32h2", "esp32c5", "esp32c61", "esp32p4"], reason="These chips support ECDSA_KEY", ) def test_burn_key_ecdsa_key_check_byte_order(self): @@ -1281,14 +1272,11 @@ def test_burn_block_data_with_1_key_block(self): not in [ "esp32s2", "esp32s3", - "esp32s3beta1", "esp32c3", - "esp32h2beta1", "esp32c6", "esp32h2", "esp32p4", "esp32c5", - "esp32c5beta3", "esp32c61", ], reason="Only chip with 6 keys", @@ -1424,14 +1412,11 @@ def test_burn_block_data_with_offset_1_key_block(self): not in [ "esp32s2", "esp32s3", - "esp32s3beta1", "esp32c3", - "esp32h2beta1", "esp32c6", "esp32h2", "esp32p4", "esp32c5", - "esp32c5beta3", "esp32c61", ], reason="Only chips with 6 keys", @@ -1623,14 +1608,11 @@ def test_burn_key_from_digest2(self): not in [ "esp32s2", "esp32s3", - "esp32s3beta1", "esp32c3", - "esp32h2beta1", "esp32c6", "esp32h2", "esp32p4", "esp32c5", - "esp32c5beta3", "esp32c61", ], reason="Supports 6 key blocks", @@ -1738,14 +1720,11 @@ def test_burn_bit_for_chips_with_1_key_block(self): not in [ "esp32s2", "esp32s3", - "esp32s3beta1", "esp32c3", - "esp32h2beta1", "esp32c6", "esp32h2", "esp32p4", "esp32c5", - "esp32c5beta3", "esp32c61", ], reason="Only chip with 6 keys",