esptool 4.8.dev2__tar.gz → 4.8.dev4__tar.gz

{esptool-4.8.dev2/esptool.egg-info → esptool-4.8.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: esptool
-Version: 4.8.dev2
+Version: 4.8.dev4
 Summary: A serial utility to communicate & flash code to Espressif chips.
 Home-page: https://github.com/espressif/esptool/
 Author: Fredrik Ahlberg (themadinventor) & Angus Gratton (projectgus) & Espressif Systems

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

@@ -12,6 +12,7 @@ from bitstring import BitArray, BitStream, CreationError
 import esptool
 
 from . import util
+from typing import List
 
 
 class CheckArgValue(object):
@@ -227,13 +228,14 @@ class EfuseBlockBase(EfuseProtectBase):
 
         return [self.parent.read_reg(offs) for offs in get_offsets(self)]
 
-    def read(self):
+    def read(self, print_info=True):
         words = self.get_words()
         data = BitArray()
         for word in reversed(words):
             data.append("uint:32=%d" % word)
         self.bitarray.overwrite(data, pos=0)
-        self.print_block(self.bitarray, "read_regs")
+        if print_info:
+            self.print_block(self.bitarray, "read_regs")
 
     def print_block(self, bit_string, comment, debug=False):
         if self.parent.debug or debug:
@@ -385,6 +387,18 @@ class EfuseBlockBase(EfuseProtectBase):
                     )
                     break
             if not self.fail and self.num_errors == 0:
+                self.read(print_info=False)
+                if self.wr_bitarray & self.bitarray != self.wr_bitarray:
+                    # if the required bits are not set then we need to re-burn it again.
+                    if burns < 2:
+                        print(
+                            f"\nRepeat burning BLOCK{self.id} (#{burns + 2}) because not all bits were set"
+                        )
+                        continue
+                    else:
+                        print(
+                            f"\nAfter {burns + 1} attempts, the required data was not set to BLOCK{self.id}"
+                        )
                 break
 
     def burn(self):
@@ -441,8 +455,8 @@ class EspEfusesBase(object):
     """
 
     _esp = None
-    blocks = []
-    efuses = []
+    blocks: List[EfuseBlockBase] = []
+    efuses: List = []
     coding_scheme = None
     force_write_always = None
     batch_mode_cnt = 0

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

@@ -65,12 +65,11 @@ def add_common_commands(subparsers, efuses):
     )
     burn.add_argument(
         "name_value_pairs",
-        help="Name of efuse register and New value pairs to burn",
+        help="Name of efuse field and new value pairs to burn. EFUSE_NAME: "
+        "[{}].".format(", ".join([e.name for e in efuses.efuses])),
         action=ActionEfuseValuePair,
         nargs="+",
-        metavar="[EFUSE_NAME VALUE] [{} VALUE".format(
-            " VALUE] [".join([e.name for e in efuses.efuses])
-        ),
+        metavar="[EFUSE_NAME VALUE]",
         efuse_choices=[e.name for e in efuses.efuses]
         + [name for e in efuses.efuses for name in e.alt_names if name != ""],
         efuses=efuses,
@@ -183,7 +182,7 @@ def add_common_commands(subparsers, efuses):
     summary_cmd.add_argument(
         "--format",
         help="Select the summary format",
-        choices=["summary", "json"],
+        choices=["summary", "json", "value_only"],
         default="summary",
     )
     summary_cmd.add_argument(
@@ -192,6 +191,11 @@ def add_common_commands(subparsers, efuses):
         type=argparse.FileType("w"),
         default=sys.stdout,
     )
+    summary_cmd.add_argument(
+        "efuses_to_show",
+        help="The efuses to show. If not provided, all efuses will be shown.",
+        nargs="*",
+    )
 
     execute_scripts = subparsers.add_parser(
         "execute_scripts", help="Executes scripts to burn at one time."
@@ -246,14 +250,21 @@ def add_show_sensitive_info_option(p):
 
 
 def summary(esp, efuses, args):
-    """Print a human-readable summary of efuse contents"""
+    """Print a human-readable or json summary of efuse contents"""
     ROW_FORMAT = "%-50s %-50s%s = %s %s %s"
-    human_output = args.format == "summary"
+    human_output = args.format in ["summary", "value_only"]
+    value_only = args.format == "value_only"
+    if value_only and len(args.efuses_to_show) != 1:
+        raise esptool.FatalError(
+            "The 'value_only' format can be used exactly for one efuse."
+        )
+    do_filtering = bool(args.efuses_to_show)
     json_efuse = {}
+    summary_efuse = []
     if args.file != sys.stdout:
         print("Saving efuse values to " + args.file.name)
-    if human_output:
-        print(
+    if human_output and not value_only:
+        summary_efuse.append(
             ROW_FORMAT.replace("-50", "-12")
             % (
                 "EFUSE_NAME (Block)",
@@ -262,13 +273,12 @@ def summary(esp, efuses, args):
                 "[Meaningful Value]",
                 "[Readable/Writeable]",
                 "(Hex Value)",
-            ),
-            file=args.file,
+            )
         )
-        print("-" * 88, file=args.file)
+        summary_efuse.append("-" * 88)
     for category in sorted(set(e.category for e in efuses), key=lambda c: c.title()):
-        if human_output:
-            print("%s fuses:" % category.title(), file=args.file)
+        if human_output and not value_only:
+            summary_efuse.append(f"{category.title()} fuses:")
         for e in (e for e in efuses if e.category == category):
             if e.efuse_type.startswith("bytes"):
                 raw = ""
@@ -297,8 +307,12 @@ def summary(esp, efuses, args):
                     value = "".join(v)
                 else:
                     value = value.replace("0", "?")
-            if human_output:
-                print(
+            if (
+                human_output
+                and (not do_filtering or e.name in args.efuses_to_show)
+                and not value_only
+            ):
+                summary_efuse.append(
                     ROW_FORMAT
                     % (
                         e.get_info(),
@@ -307,18 +321,20 @@ def summary(esp, efuses, args):
                         value,
                         perms,
                         raw,
-                    ),
-                    file=args.file,
+                    )
                 )
                 desc_len = len(e.description[50:])
                 if desc_len:
                     desc_len += 50
                     for i in range(50, desc_len, 50):
-                        print(
-                            "%-50s %-50s" % ("", e.description[i : (50 + i)]),
-                            file=args.file,
+                        summary_efuse.append(
+                            f"{'':<50} {e.description[i : (50 + i)]:<50}"
                         )
-            if args.format == "json":
+            elif human_output and value_only and e.name in args.efuses_to_show:
+                summary_efuse.append(f"{value}")
+            elif args.format == "json" and (
+                not do_filtering or e.name in args.efuses_to_show
+            ):
                 json_efuse[e.name] = {
                     "name": e.name,
                     "value": base_value if readable else value,
@@ -332,19 +348,26 @@ def summary(esp, efuses, args):
                     "efuse_type": e.efuse_type,
                     "bit_len": e.bit_len,
                 }
-        if human_output:
-            print("", file=args.file)
-    if human_output:
-        print(efuses.summary(), file=args.file)
+        if human_output and not value_only:
+            # Remove empty category if efuses are filtered and there are none to show
+            if do_filtering and summary_efuse[-1] == f"{category.title()} fuses:":
+                summary_efuse.pop()
+            else:
+                summary_efuse.append("")
+    if human_output and not value_only:
+        summary_efuse.append(efuses.summary())
         warnings = efuses.get_coding_scheme_warnings()
         if warnings:
-            print(
-                "WARNING: Coding scheme has encoding bit error warnings", file=args.file
+            summary_efuse.append(
+                "WARNING: Coding scheme has encoding bit error warnings"
             )
+    if human_output:
+        for line in summary_efuse:
+            print(line, file=args.file)
         if args.file != sys.stdout:
             args.file.close()
             print("Done")
-    if args.format == "json":
+    elif args.format == "json":
         json.dump(json_efuse, args.file, sort_keys=True, indent=4)
         print("")
 

{esptool-4.8.dev2 → esptool-4.8.dev4}/espefuse/efuse/esp32c5/mem_definition.py

@@ -20,7 +20,7 @@ class EfuseDefineRegisters(EfuseRegistersBase):
     EFUSE_MEM_SIZE = 0x01FC + 4
 
     # EFUSE registers & command/conf values
-    DR_REG_EFUSE_BASE = 0x600B0800
+    DR_REG_EFUSE_BASE = 0x600B4800
     EFUSE_PGM_DATA0_REG = DR_REG_EFUSE_BASE
     EFUSE_CHECK_VALUE0_REG = DR_REG_EFUSE_BASE + 0x020
     EFUSE_CLK_REG = DR_REG_EFUSE_BASE + 0x1C8

{esptool-4.8.dev2 → esptool-4.8.dev4}/espefuse/efuse/esp32c5/operations.py

@@ -236,14 +236,21 @@ def burn_key(esp, efuses, args, digest=None):
         block = efuses.blocks[block_num]
 
         if digest is None:
-            data = datafile.read()
+            if keypurpose == "ECDSA_KEY":
+                sk = espsecure.load_ecdsa_signing_key(datafile)
+                data = sk.to_string()
+                if len(data) == 24:
+                    # the private key is 24 bytes long for NIST192p, and 8 bytes of padding
+                    data = b"\x00" * 8 + data
+            else:
+                data = datafile.read()
         else:
             data = datafile
 
         print(" - %s" % (efuse.name), end=" ")
         revers_msg = None
         if efuses[block.key_purpose_name].need_reverse(keypurpose):
-            revers_msg = "\tReversing byte order for AES-XTS hardware peripheral"
+            revers_msg = f"\tReversing byte order for {keypurpose} hardware peripheral"
             data = data[::-1]
         print(
             "-> [{}]".format(

{esptool-4.8.dev2 → esptool-4.8.dev4}/espefuse/efuse/esp32c5beta3/operations.py

@@ -236,14 +236,21 @@ def burn_key(esp, efuses, args, digest=None):
         block = efuses.blocks[block_num]
 
         if digest is None:
-            data = datafile.read()
+            if keypurpose == "ECDSA_KEY":
+                sk = espsecure.load_ecdsa_signing_key(datafile)
+                data = sk.to_string()
+                if len(data) == 24:
+                    # the private key is 24 bytes long for NIST192p, and 8 bytes of padding
+                    data = b"\x00" * 8 + data
+            else:
+                data = datafile.read()
         else:
             data = datafile
 
         print(" - %s" % (efuse.name), end=" ")
         revers_msg = None
         if efuses[block.key_purpose_name].need_reverse(keypurpose):
-            revers_msg = "\tReversing byte order for AES-XTS hardware peripheral"
+            revers_msg = f"\tReversing byte order for {keypurpose} hardware peripheral"
             data = data[::-1]
         print(
             "-> [{}]".format(

{esptool-4.8.dev2 → esptool-4.8.dev4}/espefuse/efuse/esp32c61/mem_definition.py

@@ -5,6 +5,7 @@
 # SPDX-License-Identifier: GPL-2.0-or-later
 
 import os
+from typing import List
 
 import yaml
 
@@ -119,7 +120,7 @@ class EfuseDefineFields(EfuseFieldsBase):
         # if BLK_VERSION_MINOR is 1, these efuse fields are in BLOCK2
         self.BLOCK2_CALIBRATION_EFUSES = []
 
-        self.CALC = []
+        self.CALC: List = []
 
         dir_name = os.path.dirname(os.path.abspath(__file__))
         dir_name, file_name = os.path.split(dir_name)

{esptool-4.8.dev2 → esptool-4.8.dev4}/espefuse/efuse/esp32c61/operations.py

@@ -304,7 +304,7 @@ def burn_key(esp, efuses, args, digest=None):
 
         if digest is None:
             if keypurpose == "ECDSA_KEY":
-                sk = espsecure._load_ecdsa_signing_key(datafile)
+                sk = espsecure.load_ecdsa_signing_key(datafile)
                 data = sk.to_string()
                 if len(data) == 24:
                     # the private key is 24 bytes long for NIST192p, and 8 bytes of padding

{esptool-4.8.dev2 → esptool-4.8.dev4}/espefuse/efuse/esp32h2beta1/mem_definition.py

@@ -9,6 +9,7 @@ import os
 import yaml
 
 from ..mem_definition_base import EfuseBlocksBase, EfuseFieldsBase, EfuseRegistersBase
+from typing import List
 
 
 class EfuseDefineRegisters(EfuseRegistersBase):
@@ -115,7 +116,7 @@ class EfuseDefineFields(EfuseFieldsBase):
         # if BLK_VERSION_MAJOR is 1, these efuse fields are in BLOCK2
         self.BLOCK2_CALIBRATION_EFUSES = []
 
-        self.CALC = []
+        self.CALC: List = []
 
         dir_name = os.path.dirname(os.path.abspath(__file__))
         dir_name, file_name = os.path.split(dir_name)

{esptool-4.8.dev2 → esptool-4.8.dev4}/espefuse/efuse/esp32p4/mem_definition.py

@@ -13,6 +13,7 @@ from ..mem_definition_base import (
     EfuseFieldsBase,
     EfuseRegistersBase,
 )
+from typing import List
 
 
 class EfuseDefineRegisters(EfuseRegistersBase):
@@ -119,7 +120,7 @@ class EfuseDefineFields(EfuseFieldsBase):
         # if BLK_VERSION_MINOR is 1, these efuse fields are in BLOCK2
         self.BLOCK2_CALIBRATION_EFUSES = []
 
-        self.CALC = []
+        self.CALC: List = []
 
         dir_name = os.path.dirname(os.path.abspath(__file__))
         dir_name, file_name = os.path.split(dir_name)

{esptool-4.8.dev2 → esptool-4.8.dev4}/espefuse/efuse/mem_definition_base.py

@@ -5,6 +5,7 @@
 # SPDX-License-Identifier: GPL-2.0-or-later
 
 from collections import namedtuple
+from typing import Optional, List
 
 
 class EfuseRegistersBase(object):
@@ -19,9 +20,9 @@ class EfuseRegistersBase(object):
 
 
 class EfuseBlocksBase(object):
-    BLOCKS = None
+    BLOCKS: Optional[List] = None
     NamedtupleBlock = namedtuple(
-        "Block",
+        "NamedtupleBlock",
         "name alias id rd_addr wr_addr write_disable_bit "
         "read_disable_bit len key_purpose",
     )
@@ -49,7 +50,7 @@ class Field:
     word = None
     pos = None
     bit_len = 0
-    alt_names = []
+    alt_names: List[str] = []
     type = ""
     write_disable_bit = None
     read_disable_bit = None
@@ -61,7 +62,7 @@ class Field:
 
 class EfuseFieldsBase(object):
     def __init__(self, e_desc) -> None:
-        self.ALL_EFUSES = []
+        self.ALL_EFUSES: List = []
 
         def set_category_and_class_type(efuse, name):
             def includes(name, names):

{esptool-4.8.dev2 → esptool-4.8.dev4}/esptool/__init__.py

@@ -28,7 +28,7 @@ __all__ = [
     "write_mem",
 ]
 
-__version__ = "4.8.dev2"
+__version__ = "4.8.dev4"
 
 import argparse
 import inspect
@@ -496,7 +496,7 @@ def main(argv=None, esp=None):
         "quantity. This will make the other segments invisible to the ROM "
         "loader. Use this argument with care because the ROM loader will load "
         "only the RAM segments although the other segments being present in "
-        "the output.",
+        "the output. Implies --dont-append-digest",
         action="store_true",
         default=None,
     )

{esptool-4.8.dev2 → esptool-4.8.dev4}/esptool/bin_image.py

@@ -11,7 +11,7 @@ import os
 import re
 import struct
 import tempfile
-from typing import BinaryIO, Optional
+from typing import IO, Optional
 
 from intelhex import HexRecordError, IntelHex
 
@@ -43,7 +43,7 @@ def align_file_position(f, size):
     f.seek(align, 1)
 
 
-def intel_hex_to_bin(file: BinaryIO, start_addr: Optional[int] = None) -> BinaryIO:
+def intel_hex_to_bin(file: IO[bytes], start_addr: Optional[int] = None) -> IO[bytes]:
     """Convert IntelHex file to temp binary file with padding from start_addr
     If hex file was detected return temp bin file object; input file otherwise"""
     INTEL_HEX_MAGIC = b":"
@@ -115,10 +115,11 @@ class ImageSegment(object):
     """Wrapper class for a segment in an ESP image
     (very similar to a section in an ELFImage also)"""
 
-    def __init__(self, addr, data, file_offs=None):
+    def __init__(self, addr, data, file_offs=None, flags=0):
         self.addr = addr
         self.data = data
         self.file_offs = file_offs
+        self.flags = flags
         self.include_in_checksum = True
         if self.addr != 0:
             self.pad_to_alignment(
@@ -167,8 +168,8 @@ class ELFSection(ImageSegment):
     """Wrapper class for a section in an ELF image, has a section
     name as well as the common properties of an ImageSegment."""
 
-    def __init__(self, name, addr, data):
-        super(ELFSection, self).__init__(addr, data)
+    def __init__(self, name, addr, data, flags):
+        super(ELFSection, self).__init__(addr, data, flags=flags)
         self.name = name.decode("utf-8")
 
     def __repr__(self):
@@ -178,6 +179,9 @@ class ELFSection(ImageSegment):
 class BaseFirmwareImage(object):
     SEG_HEADER_LEN = 8
     SHA256_DIGEST_LEN = 32
+    ELF_FLAG_WRITE = 0x1
+    ELF_FLAG_READ = 0x2
+    ELF_FLAG_EXEC = 0x4
 
     """ Base class with common firmware image functions """
 
@@ -352,6 +356,11 @@ class BaseFirmwareImage(object):
         irom_segment = self.get_irom_segment()
         return [s for s in self.segments if s != irom_segment]
 
+    def sort_segments(self):
+        if not self.segments:
+            return  # nothing to sort
+        self.segments = sorted(self.segments, key=lambda s: s.addr)
+
     def merge_adjacent_segments(self):
         if not self.segments:
             return  # nothing to merge
@@ -368,6 +377,8 @@ class BaseFirmwareImage(object):
                     elem.get_memory_type(self) == next_elem.get_memory_type(self),
                     elem.include_in_checksum == next_elem.include_in_checksum,
                     next_elem.addr == elem.addr + len(elem.data),
+                    next_elem.flags & self.ELF_FLAG_EXEC
+                    == elem.flags & self.ELF_FLAG_EXEC,
                 )
             ):
                 # Merge any segment that ends where the next one starts,
@@ -755,8 +766,10 @@ class ESP32FirmwareImage(BaseFirmwareImage):
                         self.ROM_LOADER.BOOTLOADER_FLASH_OFFSET - self.SEG_HEADER_LEN
                     )
                     if pad_len < align_min:
-                        print("Unable to align the segment!")
-                        break
+                        # in case pad_len does not fit minimum alignment,
+                        # pad it to next aligned boundary
+                        pad_len += self.IROM_ALIGN
+
                     pad_len -= self.ROM_LOADER.BOOTLOADER_FLASH_OFFSET
                     pad_segment = ImageSegment(0, b"\x00" * pad_len, f.tell())
                     self.save_segment(f, pad_segment)
@@ -1269,7 +1282,7 @@ class ELFFile(object):
             name_offs, sec_type, _flags, lma, sec_offs, size = struct.unpack_from(
                 "<LLLLLL", section_header[offs:]
             )
-            return (name_offs, sec_type, lma, size, sec_offs)
+            return (name_offs, sec_type, lma, size, sec_offs, _flags)
 
         all_sections = [read_section_header(offs) for offs in section_header_offsets]
         prog_sections = [s for s in all_sections if s[1] in ELFFile.PROG_SEC_TYPES]
@@ -1278,7 +1291,7 @@ class ELFFile(object):
         # search for the string table section
         if (shstrndx * self.LEN_SEC_HEADER) not in section_header_offsets:
             raise FatalError("ELF file has no STRTAB section at shstrndx %d" % shstrndx)
-        _, sec_type, _, sec_size, sec_offs = read_section_header(
+        _, sec_type, _, sec_size, sec_offs, _ = read_section_header(
             shstrndx * self.LEN_SEC_HEADER
         )
         if sec_type != ELFFile.SEC_TYPE_STRTAB:
@@ -1300,14 +1313,14 @@ class ELFFile(object):
             return f.read(size)
 
         prog_sections = [
-            ELFSection(lookup_string(n_offs), lma, read_data(offs, size))
-            for (n_offs, _type, lma, size, offs) in prog_sections
+            ELFSection(lookup_string(n_offs), lma, read_data(offs, size), flags=_flags)
+            for (n_offs, _type, lma, size, offs, _flags) in prog_sections
             if lma != 0 and size > 0
         ]
         self.sections = prog_sections
         self.nobits_sections = [
-            ELFSection(lookup_string(n_offs), lma, b"")
-            for (n_offs, _type, lma, size, offs) in nobits_secitons
+            ELFSection(lookup_string(n_offs), lma, b"", flags=_flags)
+            for (n_offs, _type, lma, size, offs, _flags) in nobits_secitons
             if lma != 0 and size > 0
         ]
 
@@ -1340,7 +1353,7 @@ class ELFFile(object):
                 _flags,
                 _align,
             ) = struct.unpack_from("<LLLLLLLL", segment_header[offs:])
-            return (seg_type, lma, size, seg_offs)
+            return (seg_type, lma, size, seg_offs, _flags)
 
         all_segments = [read_segment_header(offs) for offs in segment_header_offsets]
         prog_segments = [s for s in all_segments if s[0] == ELFFile.SEG_TYPE_LOAD]
@@ -1350,8 +1363,8 @@ class ELFFile(object):
             return f.read(size)
 
         prog_segments = [
-            ELFSection(b"PHDR", lma, read_data(offs, size))
-            for (_type, lma, size, offs) in prog_segments
+            ELFSection(b"PHDR", lma, read_data(offs, size), flags=_flags)
+            for (_type, lma, size, offs, _flags) in prog_segments
             if lma != 0 and size > 0
         ]
         self.segments = prog_segments