PyPI - esptool - Versions diffs - 5.2.dev1__tar.gz → 5.2.dev2__tar.gz - Mend

esptool 5.2.dev1tar.gz → 5.2.dev2tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (181) hide show

{esptool-5.2.dev1/esptool.egg-info → esptool-5.2.dev2}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: esptool
-Version: 5.2.dev1
+Version: 5.2.dev2
 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<1.9.0
+Requires-Dist: rich_click<2
 Requires-Dist: click<9
 Provides-Extra: dev
 Requires-Dist: pyelftools; extra == "dev"

{esptool-5.2.dev1 → esptool-5.2.dev2}/espefuse/__init__.py RENAMED Viewed

@@ -7,7 +7,7 @@ import sys
 import rich_click as click
 import esptool
-from esptool.cli_util import ChipType, ResetModeType
+from esptool.cli_util import BaudRateType, ChipType, ResetModeType, SerialPortType
 from esptool.logger import log
 from espefuse.cli_util import Group
@@ -53,7 +53,7 @@ __all__ = [
 @click.option(
     "--baud",
     "-b",
-    type=int,
+    type=BaudRateType(),
     default=esptool.ESPLoader.ESP_ROM_BAUD,
     envvar="ESPTOOL_BAUD",
     help="Serial port baud rate used when flashing/reading.",
@@ -62,7 +62,7 @@ __all__ = [
     "--port",
     "-p",
     envvar="ESPTOOL_PORT",
-    type=click.Path(),
+    type=SerialPortType(),
     help="Serial port device.",
 )
 @click.option(

{esptool-5.2.dev1 → esptool-5.2.dev2}/espefuse/efuse/base_operations.py RENAMED Viewed

@@ -223,16 +223,21 @@ class BaseCommands:
                 f"({self.CHIP_NAME} != {self.esp.CHIP_NAME})"
             )
+    @classmethod
+    def _close_port(
+        cls,
+        esp: esptool.ESPLoader | EmulateEfuseControllerBase | None,
+        external_esp: bool = False,
+    ) -> None:
+        """Close the serial port if it was opened internally."""
+        if esp is not None and not external_esp and isinstance(esp, esptool.ESPLoader):
+            esp._port.close()
     def __enter__(self):
         return self
     def __exit__(self, exc_type, exc_value, traceback):
-        if (
-            self.esp is not None
-            and not self.external_esp
-            and isinstance(self.esp, esptool.ESPLoader)
-        ):
-            self.esp._port.close()
+        self._close_port(self.esp, self.external_esp)
     ################################# CLI definitions #################################

{esptool-5.2.dev1 → esptool-5.2.dev2}/espefuse/efuse_defs/esp32c2.yaml RENAMED Viewed

@@ -1,4 +1,4 @@
-VER_NO: 897499b0349a608b895d467abbcf006b
+VER_NO: 58a0463c13130569739af12cde638a4a
 EFUSES:
   WR_DIS                     : {show: y, blk : 0, word: 0, pos : 0, len  : 8, start  : 0, type  : 'uint:8', wr_dis: null, rd_dis: null, alt                            : '', dict             : '', desc: Disable programming of individual eFuses, rloc: 'EFUSE_RD_WR_DIS_REG[7:0]', bloc: B0}
   RESERVED_0_8               : {show: n, blk : 0, word: 0, pos : 8, len : 24, start  : 8, type : 'uint:24', wr_dis: null, rd_dis: null, alt                            : '', dict             : '', desc: '', rloc: 'EFUSE_RD_WR_DIS_REG[31:8]', bloc: 'B1,B2,B3'}
@@ -49,5 +49,8 @@ EFUSES:
   RESERVED_2_171             : {show: n, blk : 2, word: 5, pos: 11, len : 21, start: 171, type : 'uint:21', wr_dis   : 6, rd_dis: null, alt                            : '', dict             : '', desc: reserved, rloc: 'EFUSE_RD_BLK2_DATA5_REG[31:11]', bloc: 'B21[7:3],B22,B23'}
   ADC_CALIBRATION_3          : {show: y, blk : 2, word: 6, pos : 0, len : 11, start: 192, type : 'uint:11', wr_dis   : 6, rd_dis: null, alt                            : '', dict             : '', desc: 'Store the bit [86:96] of ADC calibration data', rloc: 'EFUSE_RD_BLK2_DATA6_REG[10:0]', bloc: 'B24,B25[2:0]'}
   BLK2_RESERVED_DATA_0       : {show: n, blk : 2, word: 6, pos: 11, len : 21, start: 203, type : 'uint:21', wr_dis   : 6, rd_dis: null, alt                            : '', dict             : '', desc: 'Store the bit [0:20] of block2 reserved data', rloc: 'EFUSE_RD_BLK2_DATA6_REG[31:11]', bloc: 'B25[7:3],B26,B27'}
-  BLK2_RESERVED_DATA_1       : {show: n, blk : 2, word: 7, pos : 0, len : 32, start: 224, type : 'uint:32', wr_dis   : 6, rd_dis: null, alt                            : '', dict             : '', desc: 'Store the bit [21:52] of block2 reserved data', rloc: EFUSE_RD_BLK2_DATA7_REG, bloc: 'B28,B29,B30,B31'}
+  RESERVED_2_224             : {show: n, blk : 2, word: 7, pos : 0, len : 24, start: 224, type : 'uint:24', wr_dis   : 6, rd_dis: null, alt                            : '', dict             : '', desc: reserved, rloc: 'EFUSE_RD_BLK2_DATA7_REG[23:0]', bloc: 'B28,B29,B30'}
+  FLASH_VENDOR               : {show: y, blk : 2, word: 7, pos: 24, len  : 3, start: 248, type  : 'uint:3', wr_dis   : 6, rd_dis: null, alt                            : '', dict             : '', desc: Flash vendor, rloc: 'EFUSE_RD_BLK2_DATA7_REG[26:24]', bloc: 'B31[2:0]'}
+  FLASH_TEMP                 : {show: y, blk : 2, word: 7, pos: 27, len  : 2, start: 251, type  : 'uint:2', wr_dis   : 6, rd_dis: null, alt                            : '', dict             : '', desc: Flash temperature rating, rloc: 'EFUSE_RD_BLK2_DATA7_REG[28:27]', bloc: 'B31[4:3]'}
+  FLASH_CAP                  : {show: y, blk : 2, word: 7, pos: 29, len  : 3, start: 253, type  : 'uint:3', wr_dis   : 6, rd_dis: null, alt                            : '', dict             : '', desc: Flash capacity, rloc: 'EFUSE_RD_BLK2_DATA7_REG[31:29]', bloc: 'B31[7:5]'}
   BLOCK_KEY0                 : {show: y, blk : 3, word: 0, pos : 0, len: 256, start  : 0, type: 'bytes:32', wr_dis   : 7, rd_dis : 0 1, alt                          : KEY0, dict             : '', desc: BLOCK_KEY0 - 256-bits. 256-bit key of Flash Encryption, rloc: EFUSE_RD_BLK3_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'}

{esptool-5.2.dev1 → esptool-5.2.dev2}/espefuse/efuse_defs/esp32c5.yaml RENAMED Viewed

@@ -3,65 +3,65 @@ 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             : '', 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 \hyperref[fielddesc:EFUSEDISUSBJTAG]{EFUSE\_DIS\_USB\_JTAG} is available only when \hyperref[fielddesc:EFUSEDISUSBSERIALJTAG]{EFUSE\_DIS\_USB\_SERIAL\_JTAG} is configured to 0. For more information; please refer to Chapter \ref{mod:bootctrl} \textit{\nameref{mod:bootctrl}}.1: Disabled0: 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 ani-rollback check for the 2nd stage bootloader is enabled.1: Enabled0: 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: Disabled0: 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: Disabled0: 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: Enabled1: 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$^\xAE$ function is disabled.1: Disabled0: 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 \hyperref[fielddesc:EFUSEDISPADJTAG]{EFUSE\_DIS\_PAD\_JTAG}; \hyperref[fielddesc:EFUSEDISUSBJTAG]{EFUSE\_DIS\_USB\_JTAG} and \hyperref[fielddesc:EFUSEDISUSBSERIALJTAG]{EFUSE\_DIS\_USB\_SERIAL\_JTAG} are configured to 0. For more information; please refer to Chapter \ref{mod:bootctrl} \textit{\nameref{mod:bootctrl}}.1: Enabled0: 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: DisabledEven 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             : '', desc: 'Represents whether PAD JTAG is disabled in the hard way (permanently).1: Disabled0: 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: Disabled0: Enabled', rloc: 'EFUSE_RD_REPEAT_DATA0_REG[20]', bloc: 'B6[4]'}
+  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]'}
+  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]'}
   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: Exchanged0: 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: Functioned0: 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.0: The originally configured STG0 threshold \xD7 21: The originally configured STG0 threshold \xD7 42: The originally configured STG0 threshold \xD7 83: The originally configured STG0 threshold \xD7 16", rloc: 'EFUSE_RD_REPEAT_DATA0_REG[28:27]', bloc: 'B7[4:3]'}
+  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]'}
+  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: Represents whether the new ECDSA key deployment is disabled0: Enabled1: DisabledBit1: Represents whether the new XTS-AES (flash and PSRAM) key deployment is disabled0: Enabled1: DisabledBit2: Represents whether the new HMAC key deployment is disabled0: Enabled1: DisabledBit3: Represents whether the new DS key deployment is disabled0: Enabled1: 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             : '', desc: 'Represents the cycle at which the Key Manager switches random numbers.0: Controlled by the \hyperref[fielddesc:KEYMNGRNDSWITCHCYCLE]{KEYMNG\_RND\_SWITCH\_CYCLE} register. For more information; please refer to Chapter \ref{mod:keymng} \textit{\nameref{mod:keymng}}1: 8 Key Manager clock cycles2: 16 Key Manager clock cycles3: 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: Represents whether the ECDSA key can be deployed only once0: The key can be deployed multiple times1: The key can be deployed only onceBit1: Represents whether the XTS-AES (flash and PSRAM) key can be deployed only once0: The key can be deployed multiple times1: The key can be deployed only onceBit2: Represents whether the HMAC key can be deployed only once0: The key can be deployed multiple times1: The key can be deployed only onceBit3: Represents whether the DS key can be deployed only once0: The key can be deployed multiple times1: The key can be deployed 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: Represents whether the ECDSA key must come from Key Manager.0: The key does not need to come from Key Manager1: The key must come from Key ManagerBit1: Represents whether the XTS-AES (flash and PSRAM) key must come from Key Manager.0: The key does not need to come from Key Manager1: The key must come from Key ManagerBit2: Represents whether the HMAC key must come from Key Manager.0: The key does not need to come from Key Manager1: The key must come from Key ManagerBit3: Represents whether the DS key must come from Key Manager.0: The key does not need to come from Key Manager1: The key must come from Key Manager', 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: 'Represents whether to disable the use of the initialization key written by software and instead force use efuse\_init\_key.0: Enable1: 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 ani-rollback SECURE_VERSION will be updated from the ROM bootloader.1: Enable0: Disable', rloc: 'EFUSE_RD_REPEAT_DATA1_REG[15]', bloc: 'B9[7]'}
+  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_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]'}
   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]'}
   SECURE_BOOT_KEY_REVOKE2                   : {show: y, blk : 0, word: 2, pos: 21, len  : 1, start : 85, type      : bool, wr_dis   : 7, rd_dis: null, alt                            : '', dict             : '', desc: Revoke 3rd secure boot key, rloc: 'EFUSE_RD_REPEAT_DATA1_REG[21]', bloc: 'B10[5]'}
-  KEY_PURPOSE_0                             : {show: y, blk : 0, word: 2, pos: 22, len  : 5, start : 86, type  : 'uint:5', wr_dis   : 8, rd_dis: null, alt                  : KEY0_PURPOSE, dict             : '', desc: 'Represents the purpose of Key0. See Table \ref{tab:efuse-key-purpose}', rloc: 'EFUSE_RD_REPEAT_DATA1_REG[26:22]', bloc: 'B10[7:6],B11[2:0]'}
-  KEY_PURPOSE_1                             : {show: y, blk : 0, word: 2, pos: 27, len  : 5, start : 91, type  : 'uint:5', wr_dis   : 9, rd_dis: null, alt                  : KEY1_PURPOSE, dict             : '', desc: 'Represents the purpose of Key1. See Table \ref{tab:efuse-key-purpose}', rloc: 'EFUSE_RD_REPEAT_DATA1_REG[31:27]', bloc: 'B11[7:3]'}
-  KEY_PURPOSE_2                             : {show: y, blk : 0, word: 3, pos : 0, len  : 5, start : 96, type  : 'uint:5', wr_dis  : 10, rd_dis: null, alt                  : KEY2_PURPOSE, dict             : '', desc: 'Represents the purpose of Key2. See Table \ref{tab:efuse-key-purpose}', rloc: 'EFUSE_RD_REPEAT_DATA2_REG[4:0]', bloc: 'B12[4:0]'}
-  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. See Table \ref{tab:efuse-key-purpose}', 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. See Table \ref{tab:efuse-key-purpose}', 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. See Table \ref{tab:efuse-key-purpose}', 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             : '', 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\_OFF1: Security level is SEC\_DPA\_LOW2: Security level is SEC\_DPA\_MIDDLE3: Security level is SEC\_DPA\_HIGHFor more information; please refer to Chapter \ref{mod:sysreg} \textit{\nameref{mod:sysreg}} > Section \ref{sec:sysreg-anti-dpa-attack-security-control} \textit{\nameref{sec:sysreg-anti-dpa-attack-security-control}}.', rloc: 'EFUSE_RD_REPEAT_DATA2_REG[21:20]', bloc: 'B14[5:4]'}
+  KEY_PURPOSE_0                             : {show: y, blk : 0, word: 2, pos: 22, len  : 5, start : 86, type  : 'uint:5', wr_dis   : 8, rd_dis: null, alt                  : KEY0_PURPOSE, dict             : '', desc: 'Represents the purpose of Key0.', rloc: 'EFUSE_RD_REPEAT_DATA1_REG[26:22]', bloc: 'B10[7:6],B11[2:0]'}
+  KEY_PURPOSE_1                             : {show: y, blk : 0, word: 2, pos: 27, len  : 5, start : 91, type  : 'uint:5', wr_dis   : 9, rd_dis: null, alt                  : KEY1_PURPOSE, dict             : '', desc: 'Represents the purpose of Key1.', rloc: 'EFUSE_RD_REPEAT_DATA1_REG[31:27]', bloc: 'B11[7:3]'}
+  KEY_PURPOSE_2                             : {show: y, blk : 0, word: 3, pos : 0, len  : 5, start : 96, type  : 'uint:5', wr_dis  : 10, rd_dis: null, alt                  : KEY2_PURPOSE, dict             : '', desc: 'Represents the purpose of Key2.', rloc: 'EFUSE_RD_REPEAT_DATA2_REG[4:0]', bloc: 'B12[4:0]'}
+  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]'}
   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             : '', desc: 'Represents whether Secure Boot is enabled.1: Enabled0: 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: Enabled0: 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 key1: XTS-AES-128 key', 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: '{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]'}
   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             : '', 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 locked1: 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: Enabled0: 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]'}
+  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]'}
+  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]'}
   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             : '', desc: 'Represents whether FAST VERIFY ON WAKE is disabled when Secure Boot is enabled.1: Disabled0: 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 \u2013 PAD27 is enabled.1: Enabled0: 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: Disabled1: Low2: Moderate3: 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: Disable1: 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: '{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]'}
   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: InvalidEven 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             : '', desc: 'Represents what determines the XTAL frequency in \textbf{Joint Download Boot} mode.  For more information; please refer to Chapter \ref{mod:bootctrl} \textit{\nameref{mod:bootctrl}}.0: Strapping PAD state1: \hyperref[fielddesc:EFUSEXTAL48MSEL]{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 force1: Force', rloc: 'EFUSE_RD_REPEAT_DATA4_REG[13]', bloc: 'B21[5]'}
+  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]'}
   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-5.2.dev1 → esptool-5.2.dev2}/espefuse/efuse_interface.py RENAMED Viewed

@@ -132,15 +132,20 @@ def init_commands(
             port, baud, before, chip, skip_connect, virt, debug, virt_efuse_file
         )
-    commands = _get_command_class(strip_chip_name(esp.CHIP_NAME))
-    commands.esp = esp
-    commands.external_esp = external_esp
-    commands.get_efuses(
-        skip_connect=skip_connect,
-        debug_mode=debug,
-        do_not_confirm=do_not_confirm,
-        extend_efuse_table=extend_efuse_table,
-    )
+    try:
+        commands = _get_command_class(strip_chip_name(esp.CHIP_NAME))
+        commands.esp = esp
+        commands.external_esp = external_esp
+        commands.get_efuses(
+            skip_connect=skip_connect,
+            debug_mode=debug,
+            do_not_confirm=do_not_confirm,
+            extend_efuse_table=extend_efuse_table,
+        )
+    except Exception:
+        # If creating commands fails, ensure the port is closed
+        BaseCommands._close_port(esp, external_esp)
+        raise
     if batch_mode:
         commands.use_batch_mode()
     return commands

{esptool-5.2.dev1 → esptool-5.2.dev2}/esptool/__init__.py RENAMED Viewed

@@ -31,7 +31,7 @@ __all__ = [
     "write_mem",
 ]
-__version__ = "5.2.dev1"
+__version__ = "5.2.dev2"
 import os
 import shlex
@@ -75,7 +75,6 @@ from esptool.loader import (
     DEFAULT_OPEN_PORT_ATTEMPTS,
     StubFlasher,
     ESPLoader,
-    list_ports,
 )
 from esptool.logger import log
 from esptool.targets import CHIP_DEFS, CHIP_LIST, ESP32ROM
@@ -91,6 +90,7 @@ import serial
 from esptool.cli_util import (
     AutoSizeType,
+    BaudRateType,
     Group,
     AddrFilenameArg,
     AutoChunkSizeType,
@@ -100,10 +100,12 @@ from esptool.cli_util import (
     MutuallyExclusiveOption,
     ResetModeType,
     SpiConnectionType,
+    SerialPortType,
     AutoHex2BinType,
     AddrFilenamePairType,
     parse_port_filters,
     parse_size_arg,
+    get_port_list,
 )
 # Show arguments in the help output, this was default in argparse
@@ -311,14 +313,14 @@ def check_flash_size(esp: ESPLoader, address: int, size: int) -> None:
 @click.option(
     "--port",
     "-p",
-    type=click.Path(),
+    type=SerialPortType(),
     default=os.environ.get("ESPTOOL_PORT", None),
     help="Serial port device.",
 )
 @click.option(
     "--baud",
     "-b",
-    type=AnyIntType(),
+    type=BaudRateType(),
     default=os.environ.get("ESPTOOL_BAUD", ESPLoader.ESP_ROM_BAUD),
     help="Serial port baud rate used when flashing/reading.",
 )
@@ -1035,85 +1037,6 @@ def main(argv: list[str] | None = None, esp: ESPLoader | None = None):
             raise
-def get_port_list(
-    vids: list[str] = [],
-    pids: list[str] = [],
-    names: list[str] = [],
-    serials: list[str] = [],
-) -> list[str]:
-    if list_ports is None:
-        raise FatalError(
-            "Listing all serial ports is currently not available. "
-            "Please try to specify the port when running esptool or update "
-            "the pyserial package to the latest version."
-        )
-    ports = []
-    for port in list_ports.comports():
-        if sys.platform == "darwin" and port.device.endswith(
-            ("Bluetooth-Incoming-Port", "wlan-debug", "cu.debug-console")
-        ):
-            continue
-        if vids and (port.vid is None or port.vid not in vids):
-            continue
-        if pids and (port.pid is None or port.pid not in pids):
-            continue
-        if names and (
-            port.name is None or all(name not in port.name for name in names)
-        ):
-            continue
-        if serials and (
-            port.serial_number is None
-            or all(serial not in port.serial_number for serial in serials)
-        ):
-            continue
-        ports.append((port.device, port.vid))
-    # Constants for sorting optimization
-    ESPRESSIF_VID = 0x303A
-    LINUX_DEVICE_PATTERNS = ("ttyUSB", "ttyACM")
-    MACOS_DEVICE_PATTERNS = ("usbserial", "usbmodem")
-    def _port_sort_key_linux(port_info):
-        device, vid = port_info
-        if vid == ESPRESSIF_VID:
-            return (3, device)
-        if any(pattern in device for pattern in LINUX_DEVICE_PATTERNS):
-            return (2, device)
-        return (1, device)
-    def _port_sort_key_macos(port_info):
-        device, vid = port_info
-        if vid == ESPRESSIF_VID:
-            return (3, device)
-        if any(pattern in device for pattern in MACOS_DEVICE_PATTERNS):
-            return (2, device)
-        return (1, device)
-    def _port_sort_key_windows(port_info):
-        device, vid = port_info
-        if vid == ESPRESSIF_VID:
-            return (2, device)
-        return (1, device)
-    if sys.platform == "win32":
-        key_func = _port_sort_key_windows
-    elif sys.platform == "darwin":
-        key_func = _port_sort_key_macos
-    else:
-        key_func = _port_sort_key_linux
-    sorted_port_info = sorted(ports, key=key_func)
-    return [device for device, _ in sorted_port_info]
 def expand_file_arguments(argv: list[str]) -> list[str]:
     """
     Any argument starting with "@" gets replaced with all values read from a text file.

{esptool-5.2.dev1 → esptool-5.2.dev2}/esptool/cli_util.py RENAMED Viewed

@@ -3,14 +3,18 @@
 # SPDX-License-Identifier: GPL-2.0-or-later
+import sys
 import rich_click as click
 from esptool.bin_image import ESPLoader, intel_hex_to_bin
 from esptool.cmds import detect_flash_size
 from esptool.util import FatalError, flash_size_bytes, strip_chip_name
 from esptool.logger import log
+from esptool.loader import list_ports, ListPortInfo
 from typing import IO, Any
+from click.shell_completion import CompletionItem
 ################################ Custom types #################################
@@ -98,6 +102,59 @@ class AutoChunkSizeType(AnyIntType):
         return num
+class SerialPortType(click.ParamType):
+    """
+    Custom type for serial port with autocomplete support.
+    Provides shell completion for available serial ports.
+    """
+    name = "serial-port"
+    def convert(
+        self, value: str, param: click.Parameter | None, ctx: click.Context
+    ) -> str:
+        # Just return the value as-is, validation happens elsewhere
+        return value
+    def shell_complete(
+        self, ctx: click.Context, param: click.Parameter, incomplete: str
+    ) -> list[CompletionItem]:
+        """Provide shell completion suggestions for serial ports"""
+        available_ports = _get_port_list()
+        # Filter ports that match the incomplete string (case-insensitive)
+        incomplete_lower = incomplete.lower()
+        return [
+            CompletionItem(
+                port.device,
+                help=f"Description: {port.description}, "
+                f"VID: {port.vid}, PID: {port.pid}"
+                # Avoid printing None values
+                if port.vid is not None
+                else None,
+            )
+            for port in reversed(available_ports)
+            if port.device.lower().startswith(incomplete_lower)
+        ]
+class BaudRateType(click.ParamType):
+    """Custom type for baud rate with autocomplete support"""
+    name = "baud-rate"
+    def convert(
+        self, value: str, param: click.Parameter | None, ctx: click.Context
+    ) -> int:
+        return int(value)
+    def shell_complete(
+        self, ctx: click.Context, param: click.Parameter, incomplete: str
+    ) -> list[CompletionItem]:
+        """Provide shell completion suggestions for common baud rates"""
+        available_baud_rates = [9600, 115200, 230400, 460800, 576000, 921600]
+        return [CompletionItem(str(baud)) for baud in available_baud_rates]
 class SpiConnectionType(click.ParamType):
     """
     Custom type to parse 'spi connection' override.
@@ -400,6 +457,92 @@ def arg_auto_int(x: str) -> int:
     return int(x, 0)
+def get_port_list(
+    vids: list[str] = [],
+    pids: list[str] = [],
+    names: list[str] = [],
+    serials: list[str] = [],
+) -> list[str]:
+    """Get the list of serial ports names with optional filters.
+    For backwards compatibility, this function returns a list of port names.
+    """
+    return [port.device for port in _get_port_list(vids, pids, names, serials)]
+def _get_port_list(
+    vids: list[str] = [],
+    pids: list[str] = [],
+    names: list[str] = [],
+    serials: list[str] = [],
+) -> list[ListPortInfo]:
+    if list_ports is None:
+        raise FatalError(
+            "Listing all serial ports is currently not available. "
+            "Please try to specify the port when running esptool or update "
+            "the pyserial package to the latest version."
+        )
+    ports = []
+    for port in list_ports.comports():
+        if sys.platform == "darwin" and port.device.endswith(
+            ("Bluetooth-Incoming-Port", "wlan-debug", "cu.debug-console")
+        ):
+            continue
+        if vids and (port.vid is None or port.vid not in vids):
+            continue
+        if pids and (port.pid is None or port.pid not in pids):
+            continue
+        if names and (
+            port.name is None or all(name not in port.name for name in names)
+        ):
+            continue
+        if serials and (
+            port.serial_number is None
+            or all(serial not in port.serial_number for serial in serials)
+        ):
+            continue
+        ports.append(port)
+    # Constants for sorting optimization
+    ESPRESSIF_VID = 0x303A
+    LINUX_DEVICE_PATTERNS = ("ttyUSB", "ttyACM")
+    MACOS_DEVICE_PATTERNS = ("usbserial", "usbmodem")
+    def _port_sort_key_linux(port_info: ListPortInfo) -> tuple[int, str]:
+        if port_info.vid == ESPRESSIF_VID:
+            return (3, port_info.device)
+        if any(pattern in port_info.device for pattern in LINUX_DEVICE_PATTERNS):
+            return (2, port_info.device)
+        return (1, port_info.device)
+    def _port_sort_key_macos(port_info: ListPortInfo) -> tuple[int, str]:
+        if port_info.vid == ESPRESSIF_VID:
+            return (3, port_info.device)
+        if any(pattern in port_info.device for pattern in MACOS_DEVICE_PATTERNS):
+            return (2, port_info.device)
+        return (1, port_info.device)
+    def _port_sort_key_windows(port_info: ListPortInfo) -> tuple[int, str]:
+        if port_info.vid == ESPRESSIF_VID:
+            return (2, port_info.device)
+        return (1, port_info.device)
+    if sys.platform == "win32":
+        key_func = _port_sort_key_windows
+    elif sys.platform == "darwin":
+        key_func = _port_sort_key_macos
+    else:
+        key_func = _port_sort_key_linux
+    sorted_port_info = sorted(ports, key=key_func)
+    return sorted_port_info
 def parse_port_filters(
     value: tuple[str],
 ) -> tuple[list[int], list[int], list[str], list[str]]:

esptool 5.2.dev1__tar.gz → 5.2.dev2__tar.gz

esptool 5.2.dev1tar.gz → 5.2.dev2tar.gz