esptool 4.8.dev4__tar.gz → 4.8.dev5__tar.gz

{esptool-4.8.dev4 → esptool-4.8.dev5}/MANIFEST.in

@@ -1,11 +1,11 @@
 include README.md
 include LICENSE
-include esptool/targets/stub_flasher/*.json
+include esptool/targets/stub_flasher/1/*
+include esptool/targets/stub_flasher/2/*
 include espefuse/efuse_defs/*.yaml
 # sdist includes test/test*.py by default, but esptool.py tests
 # are so far only intended to run from the git repo itself
 prune test
-prune flasher_stub
 prune .github
 prune docs
 exclude .git*

esptool-4.8.dev5/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.1
+Name: esptool
+Version: 4.8.dev5
+Summary: A serial utility to communicate & flash code to Espressif chips.
+Author: Fredrik Ahlberg (themadinventor), Angus Gratton (projectgus), Espressif Systems
+License: GPLv2+
+Project-URL: Homepage, https://github.com/espressif/esptool/
+Project-URL: Documentation, https://docs.espressif.com/projects/esptool/
+Project-URL: Source, https://github.com/espressif/esptool/
+Project-URL: Tracker, https://github.com/espressif/esptool/issues/
+Project-URL: Changelog, https://github.com/espressif/esptool/blob/master/CHANGELOG.md
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Topic :: Software Development :: Embedded Systems
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Provides-Extra: hsm
+License-File: LICENSE
+
+# esptool.py
+
+A Python-based, open-source, platform-independent utility to communicate with the ROM bootloader in Espressif chips.
+
+[![Test esptool](https://github.com/espressif/esptool/actions/workflows/test_esptool.yml/badge.svg?branch=master)](https://github.com/espressif/esptool/actions/workflows/test_esptool.yml) [![Build esptool](https://github.com/espressif/esptool/actions/workflows/build_esptool.yml/badge.svg?branch=master)](https://github.com/espressif/esptool/actions/workflows/build_esptool.yml)
+
+## Documentation
+
+Visit the [documentation](https://docs.espressif.com/projects/esptool/) or run `esptool.py -h`.
+
+## Contribute
+
+If you're interested in contributing to esptool.py, please check the [contributions guide](https://docs.espressif.com/projects/esptool/en/latest/contributing.html).
+
+## About
+
+esptool.py was initially created by Fredrik Ahlberg (@[themadinventor](https://github.com/themadinventor/)), and later maintained by Angus Gratton (@[projectgus](https://github.com/projectgus/)). It is now supported by Espressif Systems. It has also received improvements from many members of the community.
+
+## License
+
+This document and the attached source code are released as Free Software under GNU General Public License Version 2 or later. See the accompanying [LICENSE file](https://github.com/espressif/esptool/blob/master/LICENSE) for a copy.

{esptool-4.8.dev4 → esptool-4.8.dev5}/espefuse/__init__.py

@@ -1,6 +1,7 @@
 # SPDX-FileCopyrightText: 2016-2022 Espressif Systems (Shanghai) CO LTD
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
+# PYTHON_ARGCOMPLETE_OK
 
 import argparse
 import os
@@ -39,13 +40,15 @@ SUPPORTED_BURN_COMMANDS = [
     "execute_scripts",
 ]
 
-SUPPORTED_COMMANDS = [
+SUPPORTED_READ_COMMANDS = [
     "summary",
     "dump",
     "get_custom_mac",
     "adc_info",
     "check_error",
-] + SUPPORTED_BURN_COMMANDS
+]
+
+SUPPORTED_COMMANDS = SUPPORTED_READ_COMMANDS + SUPPORTED_BURN_COMMANDS
 
 SUPPORTED_CHIPS = {
     "esp32": DefChip("ESP32", esp32_efuse, esptool.targets.ESP32ROM),
@@ -94,15 +97,25 @@ def get_esp(
             )
             if not skip_connect:
                 esp.connect(connect_mode)
+                if esp.sync_stub_detected:
+                    esp = esp.STUB_CLASS(esp)
     return esp
 
 
-def get_efuses(esp, skip_connect=False, debug_mode=False, do_not_confirm=False):
+def get_efuses(
+    esp,
+    skip_connect=False,
+    debug_mode=False,
+    do_not_confirm=False,
+    extend_efuse_table=None,
+):
     for name in SUPPORTED_CHIPS:
         if SUPPORTED_CHIPS[name].chip_name == esp.CHIP_NAME:
             efuse = SUPPORTED_CHIPS[name].efuse_lib
             return (
-                efuse.EspEfuses(esp, skip_connect, debug_mode, do_not_confirm),
+                efuse.EspEfuses(
+                    esp, skip_connect, debug_mode, do_not_confirm, extend_efuse_table
+                ),
                 efuse.operations,
             )
     else:
@@ -224,9 +237,15 @@ def main(custom_commandline=None, esp=None):
         "(efuses which disable access to blocks or chip).",
         action="store_true",
     )
+    init_parser.add_argument(
+        "--extend-efuse-table",
+        help="CSV file from ESP-IDF (esp_efuse_custom_table.csv)",
+        type=argparse.FileType("r"),
+        default=None,
+    )
 
     common_args, remaining_args = init_parser.parse_known_args(custom_commandline)
-    debug_mode = common_args.debug or ("dump" in remaining_args)
+    debug_mode = common_args.debug
     just_print_help = [
         True for arg in remaining_args if arg in ["--help", "-h"]
     ] or remaining_args == []
@@ -253,7 +272,11 @@ def main(custom_commandline=None, esp=None):
             # TODO: Require the --port argument in the next major release, ESPTOOL-490
 
     efuses, efuse_operations = get_efuses(
-        esp, just_print_help, debug_mode, common_args.do_not_confirm
+        esp,
+        just_print_help,
+        debug_mode,
+        common_args.do_not_confirm,
+        common_args.extend_efuse_table,
     )
 
     parser = argparse.ArgumentParser(parents=[init_parser])
@@ -263,6 +286,15 @@ def main(custom_commandline=None, esp=None):
 
     efuse_operations.add_commands(subparsers, efuses)
 
+    # Enable argcomplete only on Unix-like systems
+    if sys.platform != "win32":
+        try:
+            import argcomplete
+
+            argcomplete.autocomplete(parser)
+        except ImportError:
+            pass
+
     grouped_remaining_args, used_cmds = split_on_groups(remaining_args)
     if len(grouped_remaining_args) == 0:
         parser.print_help()
@@ -302,6 +334,22 @@ def main(custom_commandline=None, esp=None):
             if not efuses.burn_all(check_batch_mode=True):
                 raise esptool.FatalError("BURN was not done")
             print("Successful")
+
+        if (
+            sum(cmd in SUPPORTED_BURN_COMMANDS for cmd in used_cmds) > 0
+            and sum(cmd in SUPPORTED_READ_COMMANDS for cmd in used_cmds) > 0
+        ):
+            # [burn_cmd1] [burn_cmd2] [read_cmd1] [burn_cmd3] [read_cmd2]
+            print("\n=== Run read commands after burn commands ===")
+            for rem_args in grouped_remaining_args:
+                args, unused_args = parser.parse_known_args(
+                    rem_args, namespace=common_args
+                )
+                current_cmd = args.operation
+                if current_cmd in SUPPORTED_READ_COMMANDS:
+                    print(f"\n=== Run {args.operation} command ===")
+                    operation_func = vars(efuse_operations)[current_cmd]
+                    operation_func(esp, efuses, args)
     finally:
         if not external_esp and not common_args.virt and esp._port:
             esp._port.close()

{esptool-4.8.dev4 → esptool-4.8.dev5}/espefuse/efuse/base_fields.py

@@ -649,6 +649,10 @@ class EspEfusesBase(object):
         """Returns (error count, failure boolean flag)"""
         return self.blocks[block_num].num_errors, self.blocks[block_num].fail
 
+    def is_efuses_incompatible_for_burn(self):
+        # Overwrite this function for a specific target if you want to check if a certain eFuse(s) can be burned.
+        return False
+
 
 class EfuseFieldBase(EfuseProtectBase):
     def __init__(self, parent, param):

{esptool-4.8.dev4 → esptool-4.8.dev5}/espefuse/efuse/base_operations.py

@@ -5,6 +5,7 @@
 # SPDX-License-Identifier: GPL-2.0-or-later
 
 import argparse
+import os
 import json
 import sys
 
@@ -74,6 +75,11 @@ def add_common_commands(subparsers, efuses):
         + [name for e in efuses.efuses for name in e.alt_names if name != ""],
         efuses=efuses,
     )
+    burn.add_argument(
+        "--force",
+        help="Suppress an error to burn eFuses",
+        action="store_true",
+    )
 
     read_protect_efuse = subparsers.add_parser(
         "read_protect_efuse",
@@ -168,12 +174,22 @@ def add_common_commands(subparsers, efuses):
         help="Display information about ADC calibration data stored in efuse.",
     )
 
-    dump_cmd = subparsers.add_parser("dump", help="Dump raw hex values of all efuses")
+    dump_cmd = subparsers.add_parser("dump", help="Dump raw hex values of all eFuses")
+    dump_cmd.add_argument(
+        "--format",
+        help="Select the dump format: "
+        "default - usual console eFuse dump; "
+        "joint - all eFuse blocks are stored in one file; "
+        "split - each eFuse block is placed into its own file. The tool will create multiple files based on "
+        "the given --file_name (/path/blk.bin): blk0.bin, blk1.bin ... blkN.bin. Use the burn_block_data cmd "
+        "to write it back to another chip.",
+        choices=["default", "split", "joint"],
+        default="default",
+    )
     dump_cmd.add_argument(
         "--file_name",
-        help="Saves dump for each block into separate file. Provide the common "
-        "path name /path/blk.bin, it will create: blk0.bin, blk1.bin ... blkN.bin. "
-        "Use burn_block_data to write it back to another chip.",
+        help="The path to the file in which to save the dump, if not specified, output to the console.",
+        default=sys.stdout,
     )
 
     summary_cmd = subparsers.add_parser(
@@ -374,23 +390,48 @@ def summary(esp, efuses, args):
 
 def dump(esp, efuses, args):
     """Dump raw efuse data registers"""
-    # Using --debug option allows to print dump.
-    # Nothing to do here. The log will be printed
-    # during EspEfuses.__init__() in self.read_blocks()
-    if args.file_name:
-        # save dump to the file
+    dump_file = args.file_name
+    to_console = args.file_name == sys.stdout
+
+    def output_block_to_file(block, f, to_console):
+        block_dump = BitStream(block.get_bitstring())
+        block_dump.byteswap()
+        if to_console:
+            f.write(block_dump.hex + "\n")
+        else:
+            block_dump.tofile(f)
+
+    if args.format == "default":
+        if to_console:
+            # for "espefuse.py dump" cmd
+            for block in efuses.blocks:
+                block.print_block(block.get_bitstring(), "dump", debug=True)
+            return
+        else:
+            # for back compatibility to support "espefuse.py dump --file_name dump.bin"
+            args.format = "split"
+
+    if args.format == "split":
+        # each efuse block is placed into its own file
         for block in efuses.blocks:
-            file_dump_name = args.file_name
-            place_for_index = file_dump_name.find(".bin")
-            file_dump_name = (
-                file_dump_name[:place_for_index]
-                + str(block.id)
-                + file_dump_name[place_for_index:]
-            )
-            print(file_dump_name)
-            with open(file_dump_name, "wb") as f:
-                block.get_bitstring().byteswap()
-                block.get_bitstring().tofile(f)
+            if not to_console:
+                file_dump_name = args.file_name
+                fname, fextension = os.path.splitext(file_dump_name)
+                file_dump_name = f"{fname}{block.id}{fextension}"
+                print(f"Dump efuse block{block.id} -> {file_dump_name}")
+                dump_file = open(file_dump_name, "wb")
+            output_block_to_file(block, dump_file, to_console)
+            if not to_console:
+                dump_file.close()
+    elif args.format == "joint":
+        # all efuse blocks are stored in one file
+        if not to_console:
+            print(f"Dump efuse blocks -> {args.file_name}")
+            dump_file = open(args.file_name, "wb")
+        for block in efuses.blocks:
+            output_block_to_file(block, dump_file, to_console)
+        if not to_console:
+            dump_file.close()
 
 
 def burn_efuse(esp, efuses, args):
@@ -480,6 +521,14 @@ def burn_efuse(esp, efuses, args):
         )
         print("                        espefuse/esptool will not work.")
 
+    if efuses.is_efuses_incompatible_for_burn():
+        if args.force:
+            print("Ignore incompatible eFuse settings.")
+        else:
+            raise esptool.FatalError(
+                "Incompatible eFuse settings detected, abort. (use --force flag to skip it)."
+            )
+
     if not efuses.burn_all(check_batch_mode=True):
         return
 

esptool-4.8.dev5/espefuse/efuse/csv_table_parser.py

@@ -0,0 +1,266 @@
+# This file helps to parse CSV eFuse tables
+#
+# SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+import os
+import re
+import sys
+
+
+class CSVFuseTable(list):
+    @classmethod
+    def from_csv(cls, csv_contents):
+        res = CSVFuseTable()
+        lines = csv_contents.splitlines()
+
+        def expand_vars(f):
+            f = os.path.expandvars(f)
+            m = re.match(r"(?<!\\)\$([A-Za-z_]\w*)", f)
+            if m:
+                raise InputError(f"unknown variable '{m.group(1)}'")
+            return f
+
+        for line_no, line in enumerate(lines):
+            line = expand_vars(line).strip()
+            if line.startswith("#") or len(line) == 0:
+                continue
+            try:
+                res.append(FuseDefinition.from_csv(line))
+            except InputError as err:
+                raise InputError(f"Error at line {line_no + 1}: {err}")
+            except Exception:
+                sys.stderr.write(f"Unexpected error parsing line {line_no + 1}: {line}")
+                raise
+
+        # fix up missing bit_start
+        last_efuse_block = None
+        for i in res:
+            if last_efuse_block != i.efuse_block:
+                last_end = 0
+            if i.bit_start is None:
+                i.bit_start = last_end
+            last_end = i.bit_start + i.bit_count
+            last_efuse_block = i.efuse_block
+
+        res.verify_duplicate_name()
+
+        # fix up missing field_name
+        last_field = None
+        for i in res:
+            if i.field_name == "":
+                if last_field is None:
+                    raise InputError(
+                        f"Error at line {line_no + 1}: {i} missing field name"
+                    )
+                elif last_field is not None:
+                    i.field_name = last_field.field_name
+            last_field = i
+
+        # fill group
+        names = [p.field_name for p in res]
+        duplicates = set(n for n in names if names.count(n) > 1)
+        for dname in duplicates:
+            i_count = 0
+            for p in res:
+                if p.field_name != dname:
+                    continue
+                if len(duplicates.intersection([p.field_name])) != 0:
+                    p.field_name = f"{p.field_name}_{i_count}"
+                    if p.alt_names:
+                        p.alt_names = f"{p.alt_names}_{i_count}"
+                    i_count += 1
+                else:
+                    i_count = 0
+
+        for p in res:
+            p.field_name = p.field_name.replace(".", "_")
+            if p.alt_names:
+                p.alt_names = p.alt_names.replace(".", "_")
+        res.verify_duplicate_name()
+        return res
+
+    def verify_duplicate_name(self):
+        # check on duplicate name
+        names = [p.field_name for p in self]
+        names += [name.replace(".", "_") for name in names if "." in name]
+        duplicates = set(n for n in names if names.count(n) > 1)
+
+        # print sorted duplicate partitions by name
+        if len(duplicates) != 0:
+            fl_error = False
+            for p in self:
+                field_name = p.field_name + p.group
+                if field_name != "" and len(duplicates.intersection([field_name])) != 0:
+                    fl_error = True
+                    print(
+                        f"Field at {p.field_name}, {p.efuse_block}, "
+                        f"{p.bit_start}, {p.bit_count} have duplicate field_name"
+                    )
+            if fl_error is True:
+                raise InputError("Field names must be unique")
+
+    def check_struct_field_name(self):
+        # check that structured fields have a root field
+        for p in self:
+            if "." in p.field_name:
+                name = ""
+                for sub in p.field_name.split(".")[:-1]:
+                    name = sub if name == "" else name + "." + sub
+                    missed_name = True
+                    for d in self:
+                        if (
+                            p is not d
+                            and p.efuse_block == d.efuse_block
+                            and name == d.field_name
+                        ):
+                            missed_name = False
+                    if missed_name:
+                        raise InputError(f"{name} is not found")
+
+    def verify(self, type_table=None):
+        def check(p, n):
+            left = n.bit_start
+            right = n.bit_start + n.bit_count - 1
+            start = p.bit_start
+            end = p.bit_start + p.bit_count - 1
+            if left <= start <= right:
+                if left <= end <= right:
+                    return "included in"  # [n  [p...p]  n]
+                return "intersected with"  # [n  [p..n]..p]
+            if left <= end <= right:
+                return "intersected with"  # [p..[n..p] n]
+            if start <= left and right <= end:
+                return "wraps"  # [p  [n...n]  p]
+            return "ok"  # [p] [n]  or  [n] [p]
+
+        def print_error(p, n, state):
+            raise InputError(
+                f"Field at {p.field_name}, {p.efuse_block}, {p.bit_start}, {p.bit_count}  {state}  {n.field_name}, {n.efuse_block}, {n.bit_start}, {n.bit_count}"
+            )
+
+        for p in self:
+            p.verify(type_table)
+
+        self.verify_duplicate_name()
+        if type_table != "custom_table":
+            # check will be done for common and custom tables together
+            self.check_struct_field_name()
+
+        # check for overlaps
+        for p in self:
+            for n in self:
+                if p is not n and p.efuse_block == n.efuse_block:
+                    state = check(p, n)
+                    if state != "ok":
+                        if "." in p.field_name:
+                            name = ""
+                            for sub in p.field_name.split("."):
+                                name = sub if name == "" else name + "." + sub
+                                for d in self:
+                                    if (
+                                        p is not d
+                                        and p.efuse_block == d.efuse_block
+                                        and name == d.field_name
+                                    ):
+                                        state = check(p, d)
+                                        if state == "included in":
+                                            break
+                                        elif state != "intersected with":
+                                            state = "out of range"
+                                        print_error(p, d, state)
+                            continue
+                        elif "." in n.field_name:
+                            continue
+                        print_error(p, n, state)
+
+
+class FuseDefinition(object):
+    def __init__(self):
+        self.field_name = ""
+        self.group = ""
+        self.efuse_block = ""
+        self.bit_start = None
+        self.bit_count = None
+        self.define = None
+        self.comment = ""
+        self.alt_names = ""
+        self.MAX_BITS_OF_BLOCK = 256
+
+    @classmethod
+    def from_csv(cls, line):
+        """Parse a line from the CSV"""
+        line_w_defaults = line + ",,,,"
+        fields = [f.strip() for f in line_w_defaults.split(",")]
+
+        res = FuseDefinition()
+        res.field_name = fields[0]
+        res.efuse_block = res.parse_block(fields[1])
+        res.bit_start = res.parse_num(fields[2])
+        res.bit_count = res.parse_bit_count(fields[3])
+        if res.bit_count is None or res.bit_count == 0:
+            raise InputError("Field bit_count can't be empty")
+        res.comment = fields[4].rstrip("\\").rstrip()
+        res.comment += f" ({res.bit_start}-{res.bit_start + res.bit_count - 1})"
+        res.alt_names = res.get_alt_names(res.comment)
+        return res
+
+    def parse_num(self, strval):
+        if strval == "":
+            return None
+        return self.parse_int(strval)
+
+    def parse_bit_count(self, strval):
+        if strval == "MAX_BLK_LEN":
+            self.define = strval
+            return self.MAX_BITS_OF_BLOCK
+        else:
+            return self.parse_num(strval)
+
+    def parse_int(self, v):
+        try:
+            return int(v, 0)
+        except ValueError:
+            raise InputError(f"Invalid field value {v}")
+
+    def parse_block(self, strval):
+        if strval == "":
+            raise InputError("Field 'efuse_block' can't be left empty.")
+        return self.parse_int(strval.lstrip("EFUSE_BLK"))
+
+    def verify(self, type_table):
+        if self.efuse_block is None:
+            raise ValidationError(self, "efuse_block field is not set")
+        if self.bit_count is None:
+            raise ValidationError(self, "bit_count field is not set")
+        max_bits = self.MAX_BITS_OF_BLOCK
+        if self.bit_start + self.bit_count > max_bits:
+            raise ValidationError(
+                self,
+                f"The field is outside the boundaries(max_bits = {max_bits}) of the {self.efuse_block} block",
+            )
+
+    def get_bit_count(self, check_define=True):
+        if check_define is True and self.define is not None:
+            return self.define
+        else:
+            return self.bit_count
+
+    def get_alt_names(self, comment):
+        result = re.search(r"^\[(.*?)\]", comment)
+        if result:
+            return result.group(1)
+        return ""
+
+
+class InputError(RuntimeError):
+    def __init__(self, e):
+        super(InputError, self).__init__(e)
+
+
+class ValidationError(InputError):
+    def __init__(self, p, message):
+        super(ValidationError, self).__init__(
+            f"Entry {p.field_name} invalid: {message}"
+        )

{esptool-4.8.dev4 → esptool-4.8.dev5}/espefuse/efuse/esp32/emulate_efuse_controller.py

@@ -19,7 +19,7 @@ class EmulateEfuseController(EmulateEfuseControllerBase):
 
     def __init__(self, efuse_file=None, debug=False):
         self.Blocks = EfuseDefineBlocks
-        self.Fields = EfuseDefineFields()
+        self.Fields = EfuseDefineFields(None)
         self.REGS = EfuseDefineRegisters
         super(EmulateEfuseController, self).__init__(efuse_file, debug)
 
@@ -38,12 +38,7 @@ class EmulateEfuseController(EmulateEfuseControllerBase):
         if addr == self.REGS.APB_CTL_DATE_ADDR:
             return self.REGS.APB_CTL_DATE_V << self.REGS.APB_CTL_DATE_S
         else:
-            val = 0
-            if addr == self.REGS.EFUSE_BLK0_RDATA3_REG:
-                val = self.REGS.EFUSE_RD_CHIP_VER_REV1
-            if addr == self.REGS.EFUSE_BLK0_RDATA5_REG:
-                val = self.REGS.EFUSE_RD_CHIP_VER_REV2
-            return val | super(EmulateEfuseController, self).read_reg(addr)
+            return super(EmulateEfuseController, self).read_reg(addr)
 
     """ << esptool method end """
 

{esptool-4.8.dev4 → esptool-4.8.dev5}/espefuse/efuse/esp32/fields.py

@@ -68,9 +68,16 @@ class EspEfuses(base_fields.EspEfusesBase):
     debug = False
     do_not_confirm = False
 
-    def __init__(self, esp, skip_connect=False, debug=False, do_not_confirm=False):
+    def __init__(
+        self,
+        esp,
+        skip_connect=False,
+        debug=False,
+        do_not_confirm=False,
+        extend_efuse_table=None,
+    ):
         self.Blocks = EfuseDefineBlocks()
-        self.Fields = EfuseDefineFields()
+        self.Fields = EfuseDefineFields(extend_efuse_table)
         self.REGS = EfuseDefineRegisters
         self.BURN_BLOCK_DATA_NAMES = self.Blocks.get_burn_block_data_names()
         self.BLOCKS_FOR_KEYS = self.Blocks.get_blocks_for_keys()

{esptool-4.8.dev4 → esptool-4.8.dev5}/espefuse/efuse/esp32/mem_definition.py

@@ -89,7 +89,7 @@ class EfuseDefineBlocks(EfuseBlocksBase):
 
 
 class EfuseDefineFields(EfuseFieldsBase):
-    def __init__(self) -> None:
+    def __init__(self, extend_efuse_table) -> None:
         self.EFUSES = []
         # if MAC_VERSION is set "1", these efuse fields are in BLOCK3:
         self.CUSTOM_MAC = []
@@ -109,7 +109,7 @@ class EfuseDefineFields(EfuseFieldsBase):
         efuse_file = os.path.join(dir_name, "efuse_defs", file_name)
         with open(f"{efuse_file}", "r") as r_file:
             e_desc = yaml.safe_load(r_file)
-        super().__init__(e_desc)
+        super().__init__(e_desc, extend_efuse_table)
 
         for i, efuse in enumerate(self.ALL_EFUSES):
             if efuse.name == "BLOCK1" or efuse.name == "BLOCK2":

{esptool-4.8.dev4 → esptool-4.8.dev5}/espefuse/efuse/esp32c2/emulate_efuse_controller.py

@@ -21,7 +21,7 @@ class EmulateEfuseController(EmulateEfuseControllerBase):
 
     def __init__(self, efuse_file=None, debug=False):
         self.Blocks = EfuseDefineBlocks
-        self.Fields = EfuseDefineFields()
+        self.Fields = EfuseDefineFields(None)
         self.REGS = EfuseDefineRegisters
         super(EmulateEfuseController, self).__init__(efuse_file, debug)
         self.write_reg(self.REGS.EFUSE_CMD_REG, 0)