esptool 4.12.dev1__tar.gz → 4.12.dev2__tar.gz

{esptool-4.12.dev1/esptool.egg-info → esptool-4.12.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: esptool
-Version: 4.12.dev1
+Version: 4.12.dev2
 Summary: A serial utility to communicate & flash code to Espressif chips.
 Author: Fredrik Ahlberg (themadinventor), Angus Gratton (projectgus), Espressif Systems
 License: GPLv2+

{esptool-4.12.dev1 → esptool-4.12.dev2}/esp_rfc2217_server/__init__.py

@@ -91,8 +91,16 @@ def main():
     srv.listen(1)
     logging.info(f"TCP/IP port: {args.localport}")
 
-    host_ip = socket.gethostbyname(socket.gethostname())
-    wait_msg = f"Waiting for connection ... use the 'rfc2217://{host_ip}:{args.localport}?ign_set_control' as a PORT"
+    try:
+        host_ip = socket.gethostbyname(socket.gethostname())
+    except OSError:
+        # CI/minimal containers often have no DNS for gethostname(); the server
+        # is still reachable on loopback.
+        host_ip = "127.0.0.1"
+    wait_msg = (
+        "Waiting for connection ... use the 'rfc2217://"
+        f"{host_ip}:{args.localport}?ign_set_control' as a PORT"
+    )
     logging.info(wait_msg)
 
     while True:

{esptool-4.12.dev1 → esptool-4.12.dev2}/espefuse/efuse/base_operations.py

@@ -356,6 +356,9 @@ def summary(esp, efuses, args):
                 json_efuse[e.name] = {
                     "name": e.name,
                     "value": base_value if readable else value,
+                    "raw_value": util.json_raw_value_hex(
+                        e.efuse_type, e.get_bitstring()
+                    ),
                     "readable": readable,
                     "writeable": writeable,
                     "description": e.description,

{esptool-4.12.dev1 → esptool-4.12.dev2}/espefuse/efuse/util.py

@@ -6,12 +6,31 @@
 
 import esptool
 
+from bitstring import Bits
+
 
 def hexify(bitstring, separator=""):
     as_bytes = tuple(b for b in bitstring)
     return separator.join(("%02x" % b) for b in as_bytes)
 
 
+def json_raw_value_hex(efuse_type: str, bits: Bits) -> str:
+    """``0x``-prefixed lowercase hex string for JSON ``raw_value``,
+    same style for all field types.
+
+    For ``bytes`` fields, uses the same byte order as the text/JSON ``value`` hex
+    (``bits.bytes`` reversed). For other types, encodes the field bit pattern with
+    leading zero bits padded to a nibble boundary so ``Bits.hex`` is defined.
+    """
+    if efuse_type.startswith("bytes"):
+        return "0x" + str(bits.bytes[::-1].hex())
+    b = bits if isinstance(bits, Bits) else Bits(bits)
+    pad = (4 - (b.len % 4)) % 4
+    if pad:
+        b = Bits(pad) + b
+    return "0x" + str(b.hex)
+
+
 def popcnt(b):
     """Return number of "1" bits set in 'b'"""
     return len([x for x in bin(b) if x == "1"])

{esptool-4.12.dev1 → esptool-4.12.dev2}/espefuse/efuse_defs/esp32c5.yaml

@@ -3,29 +3,29 @@ 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_DIS_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]'}
   BOOTLOADER_ANTI_ROLLBACK_SECURE_VERSION_HI: {show: y, blk : 0, word: 1, pos : 7, len  : 1, start : 39, type      : bool, wr_dis: null, rd_dis: null, alt                            : '', dict             : '', desc: Represents the anti-rollback secure version of the 2nd stage bootloader used by the ROM bootloader (the high part of the field), 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: '{0: "Enabled", 1: "Disabled"}', desc: Represents whether cache is disabled, 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: '{0: "Enabled", 1: "Disabled"}', desc: 'Represents whether the USB-to-JTAG function in USB Serial/JTAG is disabled. Note that EFUSE_DIS_USB_JTAG is available only when EFUSE_DIS_USB_SERIAL_JTAG is configured to 0', rloc: 'EFUSE_RD_REPEAT_DATA0_REG[9]', bloc: 'B5[1]'}
-  BOOTLOADER_ANTI_ROLLBACK_EN               : {show: y, blk : 0, word: 1, pos: 10, len  : 1, start : 42, type      : bool, wr_dis: null, rd_dis: null, alt                            : '', dict: '{0: "Disabled", 1: "Enabled"}', desc: Represents whether the ani-rollback check for the 2nd stage bootloader is enabled, 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: '{0: "Enabled", 1: "Disabled"}', desc: Represents whether USB Serial/JTAG is disabled, 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: '{0: "Enabled", 1: "Disabled"}', desc: Represents whether the function that forces chip into Download mode is disabled, 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: '{0: "Enabled", 1: "Disabled"}', desc: Represents whether SPI0 controller during boot_mode_download is disabled, 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: '{0: "Enabled", 1: "Disabled"}', desc: Represents whether TWAI function is disabled, 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: '{0: "Disabled", 1: "Enabled"}', desc: 'Represents whether the selection of a JTAG signal source through the strapping pin value is enabled when all of EFUSE_DIS_PAD_JTAG; EFUSE_DIS_USB_JTAG and EFUSE_DIS_USB_SERIAL_JTAG are configured to 0', rloc: 'EFUSE_RD_REPEAT_DATA0_REG[15]', bloc: 'B5[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 cache is disabled. 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 USB-to-JTAG function in USB Serial/JTAG is disabled. Note that EFUSE_DIS_USB_JTAG is available only when EFUSE_DIS_USB_SERIAL_JTAG is configured to 0. 1: Disabled 0: Enabled', rloc: 'EFUSE_RD_REPEAT_DATA0_REG[9]', bloc: 'B5[1]'}
+  BOOTLOADER_ANTI_ROLLBACK_EN               : {show: y, blk : 0, word: 1, pos: 10, len  : 1, start : 42, type      : bool, wr_dis: null, rd_dis: null, alt                            : '', dict             : '', desc: 'Represents whether the anti-rollback check for the 2nd stage bootloader is enabled. 1: Enabled 0: Disabled', 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. 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. 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. 0: Enabled 1: Disabled', 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. 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 of a JTAG signal source through the strapping pin value is enabled when all of EFUSE_DIS_PAD_JTAG; EFUSE_DIS_USB_JTAG and EFUSE_DIS_USB_SERIAL_JTAG are configured to 0. 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 PAD JTAG is disabled in the soft way. It can be restarted via HMAC. Odd count of bits with a value of 1: Disabled; Even count of bits with a value of 1: 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: '{0: "Enabled", 1: "Disabled"}', desc: Represents whether PAD JTAG is disabled in the hard way (permanently), 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: '{0: "Enabled", 1: "Disabled"}', desc: Represents whether flash encryption is disabled (except in SPI boot mode), rloc: 'EFUSE_RD_REPEAT_DATA0_REG[20]', bloc: 'B6[4]'}
+  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 PAD 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 encryption is disabled (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: '{0: "Not exchanged", 1: "Exchanged"}', desc: Represents whether the D+ and D- pins is 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: '{0: "Not functioned", 1: "Functioned"}', desc: Represents whether VDD SPI pin is functioned as GPIO, rloc: 'EFUSE_RD_REPEAT_DATA0_REG[26]', bloc: 'B7[2]'}
+  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]'}
   WDT_DELAY_SEL                             : {show: y, blk : 0, word: 1, pos: 27, len  : 2, start : 59, type  : 'uint:2', wr_dis   : 3, rd_dis: null, alt                            : '', dict             : '', desc: "Represents RTC watchdog timeout threshold. The originally configured STG0 threshold * (2 ^ (EFUSE_WDT_DELAY_SEL + 1))", rloc: 'EFUSE_RD_REPEAT_DATA0_REG[28:27]', bloc: 'B7[4:3]'}
   BOOTLOADER_ANTI_ROLLBACK_SECURE_VERSION_LO: {show: y, blk : 0, word: 1, pos: 29, len  : 3, start : 61, type  : 'uint:3', wr_dis: null, rd_dis: null, alt                            : '', dict             : '', desc: Represents the anti-rollback secure version of the 2nd stage bootloader used by the ROM bootloader (the low part of the field), rloc: 'EFUSE_RD_REPEAT_DATA0_REG[31:29]', bloc: 'B7[7:5]'}
   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 new key deployment of key manager is disabled. Bit0: ECDSA key deployment (0: Enabled, 1: Disabled). Bit1: XTS-AES (flash and PSRAM) key deployment (0: Enabled, 1: Disabled). Bit2: HMAC key deployment (0: Enabled, 1: Disabled). Bit3: DS key deployment (0: Enabled, 1: Disabled)', 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: '{0: "Controlled by the KEYMNG_RND_SWITCH_CYCLE register", 1: "8 Key Manager clock cycles", 2: "16 Key Manager clock cycles", 3: "32 Key Manager clock cycles"}', desc: Represents the cycle at which the Key Manager switches random numbers, rloc: 'EFUSE_RD_REPEAT_DATA1_REG[5:4]', bloc: 'B8[5:4]'}
+  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: 'Represents the cycle at which the Key Manager switches random numbers. 0: Controlled by the KEYMNG_RND_SWITCH_CYCLE register. 1: 8 Key Manager clock cycles 2: 16 Key Manager clock cycles 3: 32 Key Manager clock 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: 'Represents whether the corresponding key can be deployed only once. Bit0: ECDSA key (0: Multiple times, 1: Only once). Bit1: XTS-AES (flash and PSRAM) key (0: Multiple times, 1: Only once). Bit2: HMAC key (0: Multiple times, 1: Only once). Bit3: DS key (0: Multiple times, 1: Only once)', 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: 'Represents whether the corresponding key must come from Key Manager. Bit0: ECDSA key (0: Not required, 1: Required). Bit1: XTS-AES (flash and PSRAM) key (0: Not required, 1: Required). Bit2: HMAC key (0: Not required, 1: Required). Bit3: DS key (0: Not required, 1: Required)', 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: '{0: "Enable", 1: "Disable"}', desc: Represents whether to disable the use of the initialization key written by software and instead force use efuse_init_key, rloc: 'EFUSE_RD_REPEAT_DATA1_REG[14]', bloc: 'B9[6]'}
-  BOOTLOADER_ANTI_ROLLBACK_UPDATE_IN_ROM    : {show: y, blk : 0, word: 2, pos: 15, len  : 1, start : 79, type      : bool, wr_dis: null, rd_dis: null, alt                            : '', dict: '{0: "Disable", 1: "Enable"}', desc: Represents whether the ani-rollback SECURE_VERSION will be updated from the ROM bootloader, rloc: 'EFUSE_RD_REPEAT_DATA1_REG[15]', bloc: 'B9[7]'}
+  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: 'Represents whether to disable the use of the initialization key written by software and instead force use efuse_init_key. 0: Enable 1: Disable', rloc: 'EFUSE_RD_REPEAT_DATA1_REG[14]', bloc: 'B9[6]'}
+  BOOTLOADER_ANTI_ROLLBACK_UPDATE_IN_ROM    : {show: y, blk : 0, word: 2, pos: 15, len  : 1, start : 79, type      : bool, wr_dis: null, rd_dis: null, alt                            : '', dict             : '', desc: 'Represents whether the anti-rollback SECURE_VERSION will be updated from the ROM bootloader. 1: Enable 0: Disable', rloc: 'EFUSE_RD_REPEAT_DATA1_REG[15]', bloc: 'B9[7]'}
   SPI_BOOT_CRYPT_CNT                        : {show: y, blk : 0, word: 2, pos: 16, len  : 3, start : 80, 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[18:16]', bloc: 'B10[2:0]'}
   SECURE_BOOT_KEY_REVOKE0                   : {show: y, blk : 0, word: 2, pos: 19, len  : 1, start : 83, type      : bool, wr_dis   : 5, rd_dis: null, alt                            : '', dict             : '', desc: Revoke 1st secure boot key, rloc: 'EFUSE_RD_REPEAT_DATA1_REG[19]', bloc: 'B10[3]'}
   SECURE_BOOT_KEY_REVOKE1                   : {show: y, blk : 0, word: 2, pos: 20, len  : 1, start : 84, type      : bool, wr_dis   : 6, rd_dis: null, alt                            : '', dict             : '', desc: Revoke 2nd secure boot key, rloc: 'EFUSE_RD_REPEAT_DATA1_REG[20]', bloc: 'B10[4]'}
@@ -36,32 +36,32 @@ EFUSES:
   KEY_PURPOSE_3                             : {show: y, blk : 0, word: 3, pos : 5, len  : 5, start: 101, type  : 'uint:5', wr_dis  : 11, rd_dis: null, alt                  : KEY3_PURPOSE, dict             : '', desc: 'Represents the purpose of Key3.', rloc: 'EFUSE_RD_REPEAT_DATA2_REG[9:5]', bloc: 'B12[7:5],B13[1:0]'}
   KEY_PURPOSE_4                             : {show: y, blk : 0, word: 3, pos: 10, len  : 5, start: 106, type  : 'uint:5', wr_dis  : 12, rd_dis: null, alt                  : KEY4_PURPOSE, dict             : '', desc: 'Represents the purpose of Key4.', rloc: 'EFUSE_RD_REPEAT_DATA2_REG[14:10]', bloc: 'B13[6:2]'}
   KEY_PURPOSE_5                             : {show: y, blk : 0, word: 3, pos: 15, len  : 5, start: 111, type  : 'uint:5', wr_dis  : 13, rd_dis: null, alt                  : KEY5_PURPOSE, dict             : '', desc: 'Represents the purpose of Key5.', rloc: 'EFUSE_RD_REPEAT_DATA2_REG[19:15]', bloc: 'B13[7],B14[3:0]'}
-  SEC_DPA_LEVEL                             : {show: y, blk : 0, word: 3, pos: 20, len  : 2, start: 116, type  : 'uint:2', wr_dis  : 14, rd_dis: null, alt                            : '', dict: '{0: "SEC_DPA_OFF", 1: "SEC_DPA_LOW", 2: "SEC_DPA_MIDDLE", 3: "SEC_DPA_HIGH"}', desc: Represents the security level of anti-DPA attack. The level is adjusted by configuring the clock random frequency division mode, rloc: 'EFUSE_RD_REPEAT_DATA2_REG[21:20]', bloc: 'B14[5:4]'}
+  SEC_DPA_LEVEL                             : {show: y, blk : 0, word: 3, pos: 20, len  : 2, start: 116, type  : 'uint:2', wr_dis  : 14, rd_dis: null, alt                            : '', dict             : '', desc: 'Represents the security level of anti-DPA attack. The level is adjusted by configuring the clock random frequency division mode. 0: Security level is SEC_DPA_OFF 1: Security level is SEC_DPA_LOW 2: Security level is SEC_DPA_MIDDLE 3: Security level is SEC_DPA_HIGH.', rloc: 'EFUSE_RD_REPEAT_DATA2_REG[21:20]', bloc: 'B14[5:4]'}
   RECOVERY_BOOTLOADER_FLASH_SECTOR_HI       : {show: y, blk : 0, word: 3, pos: 22, len  : 3, start: 118, type  : 'uint:3', wr_dis: null, rd_dis: null, alt                            : '', dict             : '', desc: Represents the starting flash sector (flash sector size is 0x1000) of the recovery bootloader used by the ROM bootloader If the primary bootloader fails. 0 and 0xFFF - this feature is disabled. (The high part of the field), rloc: 'EFUSE_RD_REPEAT_DATA2_REG[24:22]', bloc: 'B14[7:6],B15[0]'}
-  SECURE_BOOT_EN                            : {show: y, blk : 0, word: 3, pos: 25, len  : 1, start: 121, type      : bool, wr_dis  : 15, rd_dis: null, alt                            : '', dict: '{0: "Disabled", 1: "Enabled"}', desc: Represents whether Secure Boot is enabled, rloc: 'EFUSE_RD_REPEAT_DATA2_REG[25]', bloc: 'B15[1]'}
-  SECURE_BOOT_AGGRESSIVE_REVOKE             : {show: y, blk : 0, word: 3, pos: 26, len  : 1, start: 122, type      : bool, wr_dis  : 16, rd_dis: null, alt                            : '', dict: '{0: "Disabled", 1: "Enabled"}', desc: Represents whether aggressive revocation of Secure Boot is enabled, rloc: 'EFUSE_RD_REPEAT_DATA2_REG[26]', bloc: 'B15[2]'}
-  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: '{0: "XTS-AES-256 key", 1: "XTS-AES-128 key"}', desc: Represents which key flash encryption uses, rloc: 'EFUSE_RD_REPEAT_DATA2_REG[27]', bloc: 'B15[3]'}
+  SECURE_BOOT_EN                            : {show: y, blk : 0, word: 3, pos: 25, len  : 1, start: 121, type      : bool, wr_dis  : 15, rd_dis: null, alt                            : '', dict             : '', desc: 'Represents whether Secure Boot is enabled. 1: Enabled 0: Disabled', rloc: 'EFUSE_RD_REPEAT_DATA2_REG[25]', bloc: 'B15[1]'}
+  SECURE_BOOT_AGGRESSIVE_REVOKE             : {show: y, blk : 0, word: 3, pos: 26, len  : 1, start: 122, type      : bool, wr_dis  : 16, rd_dis: null, alt                            : '', dict             : '', desc: 'Represents whether aggressive revocation of Secure Boot is enabled. 1: Enabled 0: Disabled', rloc: 'EFUSE_RD_REPEAT_DATA2_REG[26]', bloc: 'B15[2]'}
+  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: 'Represents which key flash encryption uses. 0: XTS-AES-256 key 1: XTS-AES-128 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. Measurement unit: ms. When the value is less than 15; the waiting time is the programmed value. Otherwise; the waiting time is a fixed value; i.e. 30 ms', 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: '{0: "Enable", 1: "Disable"}', desc: Represents whether Download mode is disable or enable, 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: '{0: "Enable", 1: "Disable"}', desc: Represents whether direct boot mode is disabled or 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: '{0: "Enable", 1: "Disable"}', desc: Represents whether print from USB-Serial-JTAG is disabled or 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: '{0: "Not locked", 1: "Locked"}', desc: Represents whether the keys in the Key Manager are locked after deployment, 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: '{0: "Enable", 1: "Disable"}', desc: Represents whether the USB-Serial-JTAG download function is disabled or enabled, 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: '{0: "Disabled", 1: "Enabled"}', desc: 'Represents whether security download is enabled. Only downloading into flash is supported. Reading/writing RAM or registers is not supported (i.e. stub download is not supported)', rloc: 'EFUSE_RD_REPEAT_DATA3_REG[5]', bloc: 'B16[5]'}
+  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 disable or enable. 1. Disable 0: Enable', 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. Disable 0: Enable', 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. Disable 0: Enable', 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: 'Represents whether the keys in the Key Manager are locked after deployment. 0: Not locked 1: Locked', 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. Only downloading into flash is supported. Reading/writing RAM or registers is not supported (i.e. stub download is not supported). 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 UART boot 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: '{0: "Not forced", 1: "Forced"}', desc: Represents whether ROM code is forced to send a resume command during SPI boot, rloc: 'EFUSE_RD_REPEAT_DATA3_REG[8]', bloc: 'B17[0]'}
+  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  : 9, start: 137, type  : 'uint:9', wr_dis  : 18, rd_dis: null, alt                            : '', dict             : '', desc: Represents the app secure version used by ESP-IDF anti-rollback feature, rloc: 'EFUSE_RD_REPEAT_DATA3_REG[17:9]', bloc: 'B17[7:1],B18[1:0]'}
   RESERVE_0_146                             : {show: n, blk : 0, word: 4, pos: 18, len  : 7, start: 146, type  : 'uint:7', 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[24:18]', bloc: 'B18[7:2],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: '{0: "Enabled", 1: "Disabled"}', desc: Represents whether FAST VERIFY ON WAKE is disabled when Secure Boot is 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: '{0: "Disabled", 1: "Enabled"}', desc: Represents whether the hysteresis function of PAD0 - PAD27 is enabled, 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: '{0: "Disabled", 1: "Low", 2: "Moderate", 3: "High"}', desc: Represents the pseudo round level of XTS-AES anti-DPA attack, 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: '{0: "Disable", 1: "Enabled"}', desc: Represents whether XTS-AES anti-DPA attack clock is enabled, rloc: 'EFUSE_RD_REPEAT_DATA3_REG[29]', bloc: 'B19[5]'}
+  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 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 PAD0 - PAD27 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. 0: Disabled 1: Low 2: Moderate 3: High', 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. 0: Disable 1: Enabled', rloc: 'EFUSE_RD_REPEAT_DATA3_REG[29]', bloc: 'B19[5]'}
   RESERVE_0_158                             : {show: n, blk : 0, word: 4, pos: 30, len  : 1, start: 158, 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_DATA3_REG[30]', bloc: 'B19[6]'}
   SECURE_BOOT_SHA384_EN                     : {show: y, blk : 0, word: 4, pos: 31, len  : 1, start: 159, type      : bool, wr_dis  : 14, rd_dis: null, alt                            : '', dict             : '', desc: Represents if the chip supports Secure Boot using SHA-384, rloc: 'EFUSE_RD_REPEAT_DATA3_REG[31]', bloc: 'B19[7]'}
   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: 'Represents whether the HUK generate mode is valid. Odd count of bits with a value of 1: Invalid; Even count of bits with a value of 1: 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: '{0: "Strapping PAD state", 1: "EFUSE_XTAL_48M_SEL in eFuse"}', desc: Represents what determines the XTAL frequency in Joint Download Boot mode, rloc: 'EFUSE_RD_REPEAT_DATA4_REG[12]', bloc: 'B21[4]'}
-  ECC_FORCE_CONST_TIME                      : {show: y, blk : 0, word: 5, pos: 13, len  : 1, start: 173, type      : bool, wr_dis  : 14, rd_dis: null, alt                            : '', dict: '{0: "Not force", 1: "Force"}', desc: Represents whether to force ECC to use constant-time mode for point multiplication calculation, rloc: 'EFUSE_RD_REPEAT_DATA4_REG[13]', bloc: 'B21[5]'}
+  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: 'Represents what determines the XTAL frequency in Joint Download Boot mode. 0: Strapping PAD state 1: EFUSE_XTAL_48M_SEL in eFuse', rloc: 'EFUSE_RD_REPEAT_DATA4_REG[12]', bloc: 'B21[4]'}
+  ECC_FORCE_CONST_TIME                      : {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 force ECC to use constant-time mode for point multiplication calculation. 0: Not force 1: Force', rloc: 'EFUSE_RD_REPEAT_DATA4_REG[13]', bloc: 'B21[5]'}
   RECOVERY_BOOTLOADER_FLASH_SECTOR_LO       : {show: y, blk : 0, word: 5, pos: 14, len  : 9, start: 174, type  : 'uint:9', wr_dis: null, rd_dis: null, alt                            : '', dict             : '', desc: Represents the starting flash sector (flash sector size is 0x1000) of the recovery bootloader used by the ROM bootloader If the primary bootloader fails. 0 and 0xFFF - this feature is disabled. (The low part of the field), rloc: 'EFUSE_RD_REPEAT_DATA4_REG[22:14]', bloc: 'B21[7:6],B22[6:0]'}
   RESERVE_0_183                             : {show: n, blk : 0, word: 5, pos: 23, len  : 9, start: 183, type  : 'uint:9', 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:23]', bloc: 'B22[7],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'}

{esptool-4.12.dev1 → esptool-4.12.dev2}/espefuse/efuse_defs/esp32p4.yaml

@@ -1,4 +1,4 @@
-VER_NO: 73787d3f5ae45b80abca925a7562120b
+VER_NO: f7765f0ac3faf4b54f8c1f064307522c
 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_DIS_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]'}
@@ -74,7 +74,7 @@ EFUSES:
   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_SYS_0_REG, bloc: 'B0,B1,B2,B3,B4,B5'}
   RESERVED_1_16                    : {show: n, blk : 1, word: 1, pos: 16, len : 16, start : 48, type : 'uint:16', wr_dis  : 20, rd_dis: null, alt                            : '', dict             : '', desc: Stores the extended bits of MAC address, rloc: 'EFUSE_RD_MAC_SYS_1_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_SYS_2_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: Major chip version, rloc: 'EFUSE_RD_MAC_SYS_2_REG[5:4]', bloc: 'B8[5:4]'}
+  WAFER_VERSION_MAJOR_LO           : {show: y, blk : 1, word: 2, pos : 4, len  : 2, start : 68, type  : 'uint:2', wr_dis  : 20, rd_dis: null, alt                            : '', dict             : '', desc: Major chip version (lower 2 bits), rloc: 'EFUSE_RD_MAC_SYS_2_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_SYS_2_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_SYS_2_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_SYS_2_REG[10:8]', bloc: 'B9[2:0]'}
@@ -83,7 +83,7 @@ EFUSES:
   TEMP                             : {show: y, blk : 1, word: 2, pos: 16, len  : 2, start : 80, type  : 'uint:2', wr_dis  : 20, rd_dis: null, alt                            : '', dict             : '', desc: Operating temperature of the ESP chip, rloc: 'EFUSE_RD_MAC_SYS_2_REG[17:16]', bloc: 'B10[1:0]'}
   PSRAM_VENDOR                     : {show: y, blk : 1, word: 2, pos: 18, len  : 2, start : 82, type  : 'uint:2', wr_dis  : 20, rd_dis: null, alt                            : '', dict             : '', desc: PSRAM vendor, rloc: 'EFUSE_RD_MAC_SYS_2_REG[19:18]', bloc: 'B10[3:2]'}
   PKG_VERSION                      : {show: y, blk : 1, word: 2, pos: 20, len  : 3, start : 84, type  : 'uint:3', wr_dis  : 20, rd_dis: null, alt                            : '', dict             : '', desc: Package version, rloc: 'EFUSE_RD_MAC_SYS_2_REG[22:20]', bloc: 'B10[6:4]'}
-  RESERVED_1_87                    : {show: n, blk : 1, word: 2, pos: 23, len  : 1, start : 87, type      : bool, wr_dis  : 20, rd_dis: null, alt                            : '', dict             : '', desc: reserved, rloc: 'EFUSE_RD_MAC_SYS_2_REG[23]', bloc: 'B10[7]'}
+  WAFER_VERSION_MAJOR_HI           : {show: y, blk : 1, word: 2, pos: 23, len  : 1, start : 87, type      : bool, wr_dis  : 20, rd_dis: null, alt                            : '', dict             : '', desc: Major chip version (MSB), rloc: 'EFUSE_RD_MAC_SYS_2_REG[23]', bloc: 'B10[7]'}
   LDO_VO1_DREF                     : {show: y, blk : 1, word: 2, pos: 24, len  : 4, start : 88, type  : 'uint:4', wr_dis  : 20, rd_dis: null, alt                            : '', dict             : '', desc: Output VO1 parameter, rloc: 'EFUSE_RD_MAC_SYS_2_REG[27:24]', bloc: 'B11[3:0]'}
   LDO_VO2_DREF                     : {show: y, blk : 1, word: 2, pos: 28, len  : 4, start : 92, type  : 'uint:4', wr_dis  : 20, rd_dis: null, alt                            : '', dict             : '', desc: Output VO2 parameter, rloc: 'EFUSE_RD_MAC_SYS_2_REG[31:28]', bloc: 'B11[7:4]'}
   LDO_VO1_MUL                      : {show: y, blk : 1, word: 3, pos : 0, len  : 3, start : 96, type  : 'uint:3', wr_dis  : 20, rd_dis: null, alt                            : '', dict             : '', desc: Output VO1 parameter, rloc: 'EFUSE_RD_MAC_SYS_3_REG[2:0]', bloc: 'B12[2:0]'}

{esptool-4.12.dev1 → esptool-4.12.dev2}/espefuse/efuse_defs/esp32p4_v3.0.yaml

@@ -25,7 +25,7 @@ EFUSES:
   FORCE_DISABLE_SW_INIT_KEY             : {show: y, blk : 0, word: 2, pos: 13, len  : 1, start : 77, 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[13]', bloc: 'B9[5]'}
   KM_XTS_KEY_LENGTH_256                 : {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 config flash encryption xts-512 key; else use xts-256 key when using the key manager, rloc: 'EFUSE_RD_REPEAT_DATA1_REG[14]', bloc: 'B9[6]'}
   ECC_FORCE_CONST_TIME                  : {show: y, blk : 0, word: 2, pos: 15, len  : 1, start : 79, type      : bool, wr_dis  : 14, rd_dis: null, alt                            : '', dict             : '', desc: Set this bit to permanently turn on ECC const-time mode, rloc: 'EFUSE_RD_REPEAT_DATA1_REG[15]', bloc: 'B9[7]'}
-  RESERVE_0_80                          : {show: n, blk : 0, word: 2, pos: 16, len  : 1, start : 80, 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[16]', bloc: 'B10[0]'}
+  DOWNLOAD_MODE_XPD_ON                  : {show: y, blk : 0, word: 2, pos: 16, len  : 1, start : 80, type      : bool, wr_dis: null, rd_dis: null, alt                            : '', dict             : '', desc: Set this bit to power on XPD in download mode, rloc: 'EFUSE_RD_REPEAT_DATA1_REG[16]', bloc: 'B10[0]'}
   WDT_DELAY_SEL                         : {show: y, blk : 0, word: 2, pos: 17, len  : 1, start : 81, type      : bool, wr_dis   : 2, rd_dis: null, alt                            : '', dict             : '', desc: Select lp wdt timeout threshold at startup = initial timeout value * (2 ^ (EFUSE_WDT_DELAY_SEL + 1)), rloc: 'EFUSE_RD_REPEAT_DATA1_REG[17]', bloc: 'B10[1]'}
   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: 'Set this bit to enable SPI boot encrypt/decrypt. Odd number of 1: enable. even number of 1: disable', 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]'}

{esptool-4.12.dev1 → esptool-4.12.dev2}/esptool/__init__.py

@@ -29,7 +29,7 @@ __all__ = [
     "write_mem",
 ]
 
-__version__ = "4.12.dev1"
+__version__ = "4.12.dev2"
 
 import argparse
 import inspect
@@ -171,8 +171,8 @@ def main(argv=None, esp=None):
     # --stub-version can be set with --no-stub so the tests wouldn't fail if this option is implied globally
     parser.add_argument(
         "--stub-version",
-        default=os.environ.get("ESPTOOL_STUB_VERSION", StubFlasher.STUB_SUBDIRS[0]),
-        choices=StubFlasher.STUB_SUBDIRS,
+        default=os.environ.get("ESPTOOL_STUB_VERSION", None),
+        choices=["1", "2"],
         # not a public option and is not subject to the semantic versioning policy
         help=argparse.SUPPRESS,
     )
@@ -728,7 +728,8 @@ def main(argv=None, esp=None):
     print("esptool.py v%s" % __version__)
     load_config_file(verbose=True)
 
-    StubFlasher.set_preferred_stub_subdir(args.stub_version)
+    if args.stub_version is not None:
+        StubFlasher.set_stub_subdir(args.stub_version)
 
     # Parse filter arguments into separate lists
     args.filterVids = []

{esptool-4.12.dev1 → esptool-4.12.dev2}/esptool/cmds.py

@@ -632,10 +632,12 @@ def write_flash(esp, args):
                     # Decompress the compressed binary a block at a time,
                     # to dynamically calculate the timeout based on the real write size
                     decompress = zlib.decompressobj()
-                    blocks = esp.flash_defl_begin(uncsize, len(image), address)
+                    blocks = esp.flash_defl_begin(
+                        uncsize, len(image), address, encrypted_write=encrypted
+                    )
                 else:
                     blocks = esp.flash_begin(
-                        uncsize, address, begin_rom_encrypted=encrypted
+                        uncsize, address, encrypted_write=encrypted
                     )
                 argfile.seek(0)  # in case we need it again
                 seq = 0
@@ -673,10 +675,7 @@ def write_flash(esp, args):
                     else:
                         # Pad the last block
                         block = block + b"\xff" * (esp.FLASH_WRITE_SIZE - len(block))
-                        if encrypted:
-                            esp.flash_encrypt_block(block, seq)
-                        else:
-                            esp.flash_block(block, seq)
+                        esp.flash_block(block, seq, encrypted=encrypted)
                         bytes_written += len(block)
                     bytes_sent += len(block)
                     image = image[esp.FLASH_WRITE_SIZE :]

{esptool-4.12.dev1 → esptool-4.12.dev2}/esptool/loader.py

@@ -147,6 +147,7 @@ class StubFlasher:
     STUB_DIR = os.path.join(os.path.dirname(__file__), "targets", "stub_flasher")
     # directories will be searched in the order of STUB_SUBDIRS
     STUB_SUBDIRS = ["1", "2"]
+    STUB_VERSION_EXPLICIT = False
 
     def __init__(self, target):
         json_name = target.STUB_CLASS.stub_json_name(target)
@@ -171,20 +172,30 @@ class StubFlasher:
         for i, subdir in enumerate(self.STUB_SUBDIRS):
             json_path = os.path.join(self.STUB_DIR, subdir, json_name)
             if os.path.exists(json_path):
-                if i:
+                if i and self.STUB_VERSION_EXPLICIT:
                     print(
-                        f"Warning: Stub version {self.STUB_SUBDIRS[0]} doesn't exist, using {subdir} instead"
+                        f"WARNING: {chip_name} stub version {self.STUB_SUBDIRS[0]} "
+                        f"doesn't exist, using {subdir} instead."
                     )
-
+                if subdir == "2":  # TODO: Remove this after legacy stub deprecation
+                    print("Using the new stub flasher.")
                 return json_path
         else:
-            raise FileNotFoundError(f"Stub flasher JSON file for {chip_name} not found")
+            raise FatalError(
+                f"Flasher stub data is missing for {chip_name}. \n"
+                "This means the esptool installation is incomplete or broken - "
+                "stub JSON files were removed or a third-party distribution package "
+                "didn't ship them. "
+                "It is unlikely to be a defect in esptool itself.\n\n"
+                "Try reinstalling esptool or restoring the stub files "
+                "from the upstream source tree. As a workaround, "
+                "you can pass --no-stub (slower operation, fewer features)."
+            )
 
     @classmethod
-    def set_preferred_stub_subdir(cls, subdir):
-        if subdir in cls.STUB_SUBDIRS:
-            cls.STUB_SUBDIRS.remove(subdir)
-            cls.STUB_SUBDIRS.insert(0, subdir)
+    def set_stub_subdir(cls, subdir):
+        cls.STUB_SUBDIRS = [subdir] + [x for x in cls.STUB_SUBDIRS if x != subdir]
+        cls.STUB_VERSION_EXPLICIT = True
 
 
 class ESPLoader(object):
@@ -965,7 +976,14 @@ class ESPLoader(object):
                 raise
             pass
 
-    def flash_begin(self, size, offset, begin_rom_encrypted=False, logging=True):
+    def flash_begin(
+        self,
+        size,
+        offset,
+        begin_rom_encrypted=False,
+        logging=True,
+        encrypted_write=None,
+    ):
         """
         Start downloading to Flash (performs an erase)
 
@@ -985,8 +1003,10 @@ class ESPLoader(object):
         params = struct.pack(
             "<IIII", erase_size, num_blocks, self.FLASH_WRITE_SIZE, offset
         )
-        if self.SUPPORTS_ENCRYPTED_FLASH and not self.IS_STUB:
-            params += struct.pack("<I", 1 if begin_rom_encrypted else 0)
+        if encrypted_write is None:
+            encrypted_write = begin_rom_encrypted
+        if self.IS_STUB or self.SUPPORTS_ENCRYPTED_FLASH:
+            params += struct.pack("<I", 1 if encrypted_write else 0)
         self.check_command(
             "enter Flash download mode", self.ESP_FLASH_BEGIN, params, timeout=timeout
         )
@@ -994,12 +1014,13 @@ class ESPLoader(object):
             print("Took %.2fs to erase flash block" % (time.time() - t))
         return num_blocks
 
-    def flash_block(self, data, seq, timeout=DEFAULT_TIMEOUT):
+    def flash_block(self, data, seq, timeout=DEFAULT_TIMEOUT, encrypted=False):
         """Write block to flash, retry if fail"""
+        operation = "encrypted " if encrypted else ""
         for attempts_left in range(WRITE_BLOCK_ATTEMPTS - 1, -1, -1):
             try:
                 self.check_command(
-                    "write to target Flash after seq %d" % seq,
+                    "write %sto target Flash after seq %d" % (operation, seq),
                     self.ESP_FLASH_DATA,
                     struct.pack("<IIII", len(data), seq, 0, 0) + data,
                     self.checksum(data),
@@ -1009,7 +1030,7 @@ class ESPLoader(object):
             except FatalError:
                 if attempts_left:
                     self.trace(
-                        "Block write failed, "
+                        f"{operation.capitalize()}block write failed, "
                         f"retrying with {attempts_left} attempts left"
                     )
                 else:
@@ -1017,29 +1038,8 @@ class ESPLoader(object):
 
     def flash_encrypt_block(self, data, seq, timeout=DEFAULT_TIMEOUT):
         """Encrypt, write block to flash, retry if fail"""
-        if self.SUPPORTS_ENCRYPTED_FLASH and not self.IS_STUB:
-            # ROM support performs the encrypted writes via the normal write command,
-            # triggered by flash_begin(begin_rom_encrypted=True)
-            return self.flash_block(data, seq, timeout)
-
-        for attempts_left in range(WRITE_BLOCK_ATTEMPTS - 1, -1, -1):
-            try:
-                self.check_command(
-                    "Write encrypted to target Flash after seq %d" % seq,
-                    self.ESP_FLASH_ENCRYPT_DATA,
-                    struct.pack("<IIII", len(data), seq, 0, 0) + data,
-                    self.checksum(data),
-                    timeout=timeout,
-                )
-                break
-            except FatalError:
-                if attempts_left:
-                    self.trace(
-                        "Encrypted block write failed, "
-                        f"retrying with {attempts_left} attempts left"
-                    )
-                else:
-                    raise
+        # Encryption is selected by the fifth word in flash_begin().
+        return self.flash_block(data, seq, timeout, encrypted=True)
 
     def flash_finish(self, reboot=False, timeout=DEFAULT_TIMEOUT):
         """Leave flash mode and run/reboot"""
@@ -1266,7 +1266,7 @@ class ESPLoader(object):
         return self.STUB_CLASS(self)
 
     @stub_and_esp32_function_only
-    def flash_defl_begin(self, size, compsize, offset):
+    def flash_defl_begin(self, size, compsize, offset, encrypted_write=False):
         """
         Start downloading compressed data to Flash (performs an erase)
 
@@ -1292,10 +1292,8 @@ class ESPLoader(object):
         params = struct.pack(
             "<IIII", write_size, num_blocks, self.FLASH_WRITE_SIZE, offset
         )
-        if self.SUPPORTS_ENCRYPTED_FLASH and not self.IS_STUB:
-            # extra param is to enter encrypted flash mode via ROM
-            # (not supported currently)
-            params += struct.pack("<I", 0)
+        if self.IS_STUB or self.SUPPORTS_ENCRYPTED_FLASH:
+            params += struct.pack("<I", 1 if encrypted_write else 0)
         self.check_command(
             "enter compressed flash mode",
             self.ESP_FLASH_DEFL_BEGIN,

{esptool-4.12.dev1 → esptool-4.12.dev2}/esptool/targets/esp32c2.py

@@ -29,7 +29,7 @@ class ESP32C2ROM(ESP32C3ROM):
     EFUSE_SECURE_BOOT_EN_MASK = 1 << 21
 
     EFUSE_SPI_BOOT_CRYPT_CNT_REG = EFUSE_BASE + 0x30
-    EFUSE_SPI_BOOT_CRYPT_CNT_MASK = 0x7 << 18
+    EFUSE_SPI_BOOT_CRYPT_CNT_MASK = 0x7 << 7
 
     EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT_REG = EFUSE_BASE + 0x30
     EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT = 1 << 6

{esptool-4.12.dev1 → esptool-4.12.dev2}/esptool/targets/esp32c5.py

@@ -44,7 +44,7 @@ class ESP32C5ROM(ESP32C6ROM):
     EFUSE_SPI_BOOT_CRYPT_CNT_MASK = 0x7 << 18
 
     EFUSE_SECURE_BOOT_EN_REG = EFUSE_BASE + 0x038
-    EFUSE_SECURE_BOOT_EN_MASK = 1 << 20
+    EFUSE_SECURE_BOOT_EN_MASK = 1 << 25
 
     IROM_MAP_START = 0x42000000
     IROM_MAP_END = 0x44000000

{esptool-4.12.dev1 → esptool-4.12.dev2}/esptool/targets/esp32c61.py

@@ -35,7 +35,7 @@ class ESP32C61ROM(ESP32C6ROM):
     EFUSE_PURPOSE_KEY5_SHIFT = 20
 
     EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT_REG = EFUSE_RD_REG_BASE
-    EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT = 1 << 20
+    EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT = 1 << 14
 
     EFUSE_SPI_BOOT_CRYPT_CNT_REG = EFUSE_BASE + 0x030
     EFUSE_SPI_BOOT_CRYPT_CNT_MASK = 0x7 << 23

{esptool-4.12.dev1 → esptool-4.12.dev2}/esptool/targets/esp32h4.py

@@ -85,7 +85,7 @@ class ESP32H4ROM(ESP32C3ROM):
     PCR_SYSCLK_XTAL_FREQ_S = 24
 
     FLASH_FREQUENCY = {
-        "48m": 0x0,
+        "48m": 0xF,
         "24m": 0x0,
         "16m": 0x1,
         "12m": 0x2,

{esptool-4.12.dev1 → esptool-4.12.dev2}/esptool/targets/esp32p4.py

@@ -59,8 +59,10 @@ class ESP32P4ROM(ESP32ROM):
     EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT_REG = EFUSE_RD_REG_BASE
     EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT = 1 << 20
 
-    EFUSE_SPI_BOOT_CRYPT_CNT_REG = EFUSE_BASE + 0x034
+    EFUSE_RD_REPEAT_DATA1_REG = EFUSE_BASE + 0x034
+    EFUSE_SPI_BOOT_CRYPT_CNT_REG = EFUSE_RD_REPEAT_DATA1_REG
     EFUSE_SPI_BOOT_CRYPT_CNT_MASK = 0x7 << 18
+    EFUSE_DOWNLOAD_MODE_XPD_ON_MASK = 0x1 << 16
 
     EFUSE_SECURE_BOOT_EN_REG = EFUSE_BASE + 0x038
     EFUSE_SECURE_BOOT_EN_MASK = 1 << 20
@@ -162,7 +164,8 @@ class ESP32P4ROM(ESP32ROM):
 
     def get_major_chip_version(self):
         num_word = 2
-        return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 4) & 0x03
+        word = self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word))
+        return (((word >> 23) & 1) << 2) | ((word >> 4) & 0x03)
 
     def get_chip_description(self):
         chip_name = {
@@ -309,10 +312,29 @@ class ESP32P4ROM(ESP32ROM):
         if self.secure_download_mode:
             raise NotSupportedError(self, "Powering on flash in secure download mode")
 
-        if self.get_chip_revision() != 301:  # !=ECO6
-            # The flash chip is powered off by default on ECO6, when the default flash
-            # voltage changed from 1.8V to 3.3V. This is to prevent damage to 1.8V flash
-            # chips. Board designers must set the appropriate voltage level in eFuse.
+        revision = self.get_chip_revision()
+        # Flash defaults off on ECO6/ECO7 after the 1.8 V → 3.3 V default change
+        # (protects 1.8 V parts, board voltage must be set in eFuse). Other silicon
+        # revisions do not need this sequence.
+        if revision not in [301, 302]:
+            return
+
+        # On ECO7, also skip when DOWNLOAD_MODE_XPD_ON is programmed: ROM already
+        # asserts flash XPD in download mode, so esptool must not run this path.
+        if revision == 302 and (
+            self.read_reg(self.EFUSE_RD_REPEAT_DATA1_REG)
+            & self.EFUSE_DOWNLOAD_MODE_XPD_ON_MASK
+        ):
+            # ECO7 ROM bug: on a cold power-on, ROM can assert flash XPD (force
+            # the flash supply/pads on) and the first download session works.
+            # A subsequent entry into ROM download mode over USB–UART reset leaves
+            # the flash already powered, but ROM still runs the same “turn flash XPD on”
+            # path. That path is not safe to run twice while flash is already on,
+            # so the second attach/download can fail.
+            #
+            # Clear PMU_DATE_REG so the “flash force on” state from the power-up
+            # sequence is released before the loader proceeds to SPI flash attach.
+            self.write_reg(self.PMU_DATE_REG, 0)
             return
 
         # Power up pad group
@@ -376,7 +398,7 @@ class ESP32P4StubLoader(ESP32P4ROM):
 
     def stub_json_name(self):
         if self.get_chip_revision() < 300:
-            return "esp32p4rc1.json"
+            return "esp32p4-rev1.json"
         return "esp32p4.json"