esptool 5.1.0__tar.gz → 5.2.dev1__tar.gz

{esptool-5.1.0/esptool.egg-info → esptool-5.2.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: esptool
-Version: 5.1.0
+Version: 5.2.dev1
 Summary: A serial utility for flashing, provisioning, and interacting with Espressif SoCs.
 Author: Fredrik Ahlberg (themadinventor), Angus Gratton (projectgus), Espressif Systems
 License: GPLv2+
@@ -31,7 +31,7 @@ Requires-Dist: pyserial>=3.3
 Requires-Dist: reedsolo<1.8,>=1.5.3
 Requires-Dist: PyYAML>=5.1
 Requires-Dist: intelhex
-Requires-Dist: rich_click
+Requires-Dist: rich_click<1.9.0
 Requires-Dist: click<9
 Provides-Extra: dev
 Requires-Dist: pyelftools; extra == "dev"

{esptool-5.1.0 → esptool-5.2.dev1}/espefuse/__init__.py

@@ -93,9 +93,10 @@ __all__ = [
     "Use with caution!",
 )
 @click.option(
-    "--postpone",
-    is_flag=True,
-    help="Postpone burning some eFuses from BLOCK0 at the end.",
+    "--postpone/--no-postpone",
+    default=True,
+    help="Postpone burning some eFuses from BLOCK0 at the end "
+    "(enabled by default, can be disabled with --no-postpone).",
 )
 @click.option(
     "--extend-efuse-table",

{esptool-5.1.0 → esptool-5.2.dev1}/espefuse/efuse/esp32p4/emulate_efuse_controller.py

@@ -27,7 +27,7 @@ class EmulateEfuseController(EmulateEfuseControllerBase):
     """ esptool method start >>"""
 
     def get_major_chip_version(self):
-        return 0
+        return 3
 
     def get_minor_chip_version(self):
         return 0

{esptool-5.1.0 → esptool-5.2.dev1}/espefuse/efuse/esp32p4/fields.py

@@ -290,9 +290,50 @@ class EfuseField(base_fields.EfuseFieldBase):
             "t_sensor": EfuseTempSensor,
             "adc_tp": EfuseAdcPointCalibration,
             "wafer": EfuseWafer,
+            "recovery_bootloader": EfuseBtldrRecoveryField,
         }.get(efuse.class_type, EfuseField)(parent, efuse)
 
 
+class EfuseBtldrRecoveryField(EfuseField):
+    """
+    Handles composite recovery bootloader flash sector fields for ESP32-P4 ECO5 (v3.0).
+    Combines/splits the following eFuse fields:
+      - RECOVERY_BOOTLOADER_FLASH_SECTOR_0_1  (bits 1:0, uint:2)
+      - RECOVERY_BOOTLOADER_FLASH_SECTOR_2_2  (bit 2, bool)
+      - RECOVERY_BOOTLOADER_FLASH_SECTOR_3_6  (bits 6:3, uint:4)
+      - RECOVERY_BOOTLOADER_FLASH_SECTOR_7_7  (bit 7, bool)
+      - RECOVERY_BOOTLOADER_FLASH_SECTOR_8_10 (bits 10:8, uint:3)
+      - RECOVERY_BOOTLOADER_FLASH_SECTOR_11_11(bit 11, bool)
+    """
+
+    FIELD_ORDER = [
+        ("RECOVERY_BOOTLOADER_FLASH_SECTOR_0_1", 0, 2),
+        ("RECOVERY_BOOTLOADER_FLASH_SECTOR_2_2", 2, 1),
+        ("RECOVERY_BOOTLOADER_FLASH_SECTOR_3_6", 3, 4),
+        ("RECOVERY_BOOTLOADER_FLASH_SECTOR_7_7", 7, 1),
+        ("RECOVERY_BOOTLOADER_FLASH_SECTOR_8_10", 8, 3),
+        ("RECOVERY_BOOTLOADER_FLASH_SECTOR_11_11", 11, 1),
+    ]
+
+    def get(self, from_read=True):
+        value = 0
+        for field_name, bit_offset, bit_len in self.FIELD_ORDER:
+            field = self.parent[field_name]
+            field_val = field.get(from_read)
+            assert field.bit_len == bit_len
+            value |= (field_val & ((1 << bit_len) - 1)) << bit_offset
+        return value
+
+    def save(self, new_value):
+        for field_name, bit_offset, bit_len in self.FIELD_ORDER:
+            field = self.parent[field_name]
+            field_val = (new_value >> bit_offset) & ((1 << bit_len) - 1)
+            field.save(field_val)
+            log.print(
+                f"\t    - '{field.name}' {field.get_bitstring()} -> {field.get_bitstring(from_read=False)}"
+            )
+
+
 class EfuseWafer(EfuseField):
     def get(self, from_read=True):
         hi_bits = self.parent["WAFER_VERSION_MAJOR_HI"].get(from_read)
@@ -389,10 +430,11 @@ class EfuseMacField(EfuseField):
 
 # fmt: off
 class EfuseKeyPurposeField(EfuseField):
-    key_purpose_len = 4  # bits for key purpose
+    key_purpose_len = 5  # bits for key purpose
     KeyPurposeType = tuple[str, int, str | None, str | None, str]
     KEY_PURPOSES: list[KeyPurposeType] = [
         ("USER",                         0,  None,       None,      "no_need_rd_protect"),   # User purposes (software-only use)
+        ("ECDSA_KEY_P256",               1,  None,       "Reverse", "need_rd_protect"),      # ECDSA key P256
         ("ECDSA_KEY",                    1,  None,       "Reverse", "need_rd_protect"),      # ECDSA key
         ("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)
@@ -406,6 +448,10 @@ class EfuseKeyPurposeField(EfuseField):
         ("SECURE_BOOT_DIGEST2",          11, "DIGEST",   None,      "no_need_rd_protect"),   # SECURE_BOOT_DIGEST2 (Secure Boot key digest)
         ("KM_INIT_KEY",                  12, None,       None,      "need_rd_protect"),      # init key that is used for the generation of AES/ECDSA key
         ("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
+        ("ECDSA_KEY_P192",               16, None,       "Reverse", "need_rd_protect"),      # ECDSA key P192
+        ("ECDSA_KEY_P384_L",             17, None,       "Reverse", "need_rd_protect"),      # ECDSA key P384 low
+        ("ECDSA_KEY_P384_H",             18, None,       "Reverse", "need_rd_protect"),      # ECDSA key P384 high
+        ("ECDSA_KEY_P384",               -3, "VIRTUAL",  None,      "need_rd_protect"),      # Virtual purpose splits to ECDSA_KEY_P384_L and ECDSA_KEY_P384_H
     ]
     CUSTOM_KEY_PURPOSES: list[KeyPurposeType] = []
     for id in range(0, 1 << key_purpose_len):
@@ -445,9 +491,25 @@ class EfuseKeyPurposeField(EfuseField):
                 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]
+        # Handle special case for KEY_PURPOSE_<digit>_H fields (e.g., KEY_PURPOSE_0_H ... KEY_PURPOSE_9_H)
+        if self.name.startswith("KEY_PURPOSE_") and self.name.endswith("_H"):
+            return self.get_raw(from_read)
+        else:
+            if any(
+                efuse is not None
+                and getattr(efuse, "name", None) == "KEY_PURPOSE_0_H"
+                for efuse in self.parent
+            ):  # check if the hi bit field for KEY_PURPOSE_.. exists
+                hi_bits = self.parent[f"{self.name}_H"].get_raw(from_read)
+                assert self.parent[f"{self.name}_H"].bit_len == 1
+                lo_bits = self.parent[f"{self.name}"].get_raw(from_read)
+                assert self.parent[f"{self.name}"].bit_len == 4
+                raw_val = (hi_bits << 4) + lo_bits
+            else:
+                raw_val = self.get_raw(from_read)
+            for p in self.KEY_PURPOSES:
+                if p[1] == raw_val:
+                    return p[0]
         return "FORBIDDEN_STATE"
 
     def get_name(self, raw_val):
@@ -457,4 +519,31 @@ class EfuseKeyPurposeField(EfuseField):
 
     def save(self, new_value):
         raw_val = int(self.check_format(str(new_value)))
-        return super().save(raw_val)
+        # Check if _H field exists (5-bit key purpose split into lo/hi)
+        if (any(
+                efuse is not None
+                and getattr(efuse, "name", None) == "KEY_PURPOSE_0_H"
+                for efuse in self.parent
+            )
+            and self.name.startswith("KEY_PURPOSE_")
+            and not self.name.endswith("_H")
+        ):
+            FIELD_ORDER = [
+                (self.name, 0),  # lo bits (bits 0-3)
+                (f"{self.name}_H", 4),  # hi bit (bit 4)
+            ]
+            for field_name, bit_offset in FIELD_ORDER:
+                field = self.parent[field_name]
+                field_val = (raw_val >> bit_offset) & ((1 << field.bit_len) - 1)
+                print(field_val, field_name)
+                if field_val != 0:
+                    if field_name.endswith("_H"):
+                        field.save(field_val)
+                    else:
+                        super().save(field_val)
+                    log.print(
+                        f"\t    - '{field.name}' {field.get_bitstring()} -> {field.get_bitstring(from_read=False)}"
+                    )
+        else:
+            # Single field, just save as usual
+            super().save(raw_val)

{esptool-5.1.0 → esptool-5.2.dev1}/espefuse/efuse/esp32p4/mem_definition.py

@@ -160,6 +160,21 @@ class EfuseDefineFields(EfuseFieldsBase):
         f.description = "calc WAFER VERSION MAJOR from (WAFER_VERSION_MAJOR_HI << 2) + WAFER_VERSION_MAJOR_LO (read only)"
         self.CALC.append(f)
 
+        if any(
+            efuse is not None
+            and getattr(efuse, "name", None) == "RECOVERY_BOOTLOADER_FLASH_SECTOR_0_1"
+            for efuse in self.ALL_EFUSES
+        ):
+            f = Field()
+            f.name = "RECOVERY_BOOTLOADER_FLASH_SECTOR"
+            f.block = 0
+            f.bit_len = 12
+            f.type = f"uint:{f.bit_len}"
+            f.category = "config"
+            f.class_type = "recovery_bootloader"
+            f.description = "recovery_bootloader = RECOVERY_BOOTLOADER_FLASH_SECTOR_0_1 + 2_2 + 3_6 + 7_7 + 8_10 + 11_11"
+            self.CALC.append(f)
+
         for efuse in self.ALL_EFUSES:
             if efuse is not None:
                 self.EFUSES.append(efuse)

esptool-5.2.dev1/espefuse/efuse/esp32s31/__init__.py

@@ -0,0 +1,5 @@
+from . import operations
+from .emulate_efuse_controller import EmulateEfuseController
+from .fields import EspEfuses
+
+commands = operations.ESP32S31Commands

esptool-5.2.dev1/espefuse/efuse/esp32s31/emulate_efuse_controller.py

@@ -0,0 +1,92 @@
+# This file describes eFuses controller for ESP32-S31 chip
+#
+# SPDX-FileCopyrightText: 2025 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-S31"
+    mem = None
+    debug = False
+
+    def __init__(self, efuse_file=None, debug=False):
+        self.Blocks = EfuseDefineBlocks
+        self.Fields = EfuseDefineFields(None)
+        self.REGS = EfuseDefineRegisters
+        super().__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
+
+    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