esptool 4.6.1__tar.gz → 4.7.dev1__tar.gz

{esptool-4.6.1/esptool.egg-info → esptool-4.7.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: esptool
-Version: 4.6.1
+Version: 4.7.dev1
 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
@@ -9,22 +9,6 @@ License: GPLv2+
 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/
-Description: 
-        ==========
-        esptool.py
-        ==========
-        A Python-based, open-source, platform-independent utility to communicate with the ROM bootloader in Espressif chips.
-        
-        The esptool.py project is `hosted on github <https://github.com/espressif/esptool>`_.
-        
-        Documentation
-        -------------
-        Visit online `esptool documentation <https://docs.espressif.com/projects/esptool/>`_ or run ``esptool.py -h``.
-        
-        Contributing
-        ------------
-        Please see the `contributions guide <https://docs.espressif.com/projects/esptool/en/latest/contributing.html>`_.
-        
 Platform: UNKNOWN
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
@@ -42,3 +26,22 @@ Classifier: Programming Language :: Python :: 3.10
 Requires-Python: >=3.7
 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.
+
+The esptool.py project is `hosted on github <https://github.com/espressif/esptool>`_.
+
+Documentation
+-------------
+Visit online `esptool documentation <https://docs.espressif.com/projects/esptool/>`_ or run ``esptool.py -h``.
+
+Contributing
+------------
+Please see the `contributions guide <https://docs.espressif.com/projects/esptool/en/latest/contributing.html>`_.
+
+

{esptool-4.6.1 → esptool-4.7.dev1}/espefuse/__init__.py

@@ -14,6 +14,7 @@ import espefuse.efuse.esp32c3 as esp32c3_efuse
 import espefuse.efuse.esp32c6 as esp32c6_efuse
 import espefuse.efuse.esp32h2 as esp32h2_efuse
 import espefuse.efuse.esp32h2beta1 as esp32h2beta1_efuse
+import espefuse.efuse.esp32p4 as esp32p4_efuse
 import espefuse.efuse.esp32s2 as esp32s2_efuse
 import espefuse.efuse.esp32s3 as esp32s3_efuse
 import espefuse.efuse.esp32s3beta2 as esp32s3beta2_efuse
@@ -49,6 +50,7 @@ SUPPORTED_CHIPS = {
     "esp32c3": DefChip("ESP32-C3", esp32c3_efuse, esptool.targets.ESP32C3ROM),
     "esp32c6": DefChip("ESP32-C6", esp32c6_efuse, esptool.targets.ESP32C6ROM),
     "esp32h2": DefChip("ESP32-H2", esp32h2_efuse, esptool.targets.ESP32H2ROM),
+    "esp32p4": DefChip("ESP32-P4", esp32p4_efuse, esptool.targets.ESP32P4ROM),
     "esp32h2beta1": DefChip(
         "ESP32-H2(beta1)", esp32h2beta1_efuse, esptool.targets.ESP32H2BETA1ROM
     ),

{esptool-4.6.1 → esptool-4.7.dev1}/espefuse/efuse/base_fields.py

@@ -577,6 +577,9 @@ class EfuseFieldBase(EfuseProtectBase):
         self.bitarray.set(0)
         self.update(self.parent.blocks[self.block].bitarray)
 
+    def is_field_calculated(self):
+        return self.word is None or self.pos is None
+
     def check_format(self, new_value_str):
         if new_value_str is None:
             return new_value_str
@@ -669,8 +672,10 @@ class EfuseFieldBase(EfuseProtectBase):
         self.save_to_block(bitarray_field)
 
     def update(self, bit_array_block):
-        if self.word is None or self.pos is None:
-            self.bitarray.overwrite(self.convert_to_bitstring(self.get()), pos=0)
+        if self.is_field_calculated():
+            self.bitarray.overwrite(
+                self.convert_to_bitstring(self.check_format(self.get())), pos=0
+            )
             return
         field_len = self.bitarray.len
         bit_array_block.pos = bit_array_block.length - (

{esptool-4.6.1 → esptool-4.7.dev1}/espefuse/efuse/esp32c6/fields.py

@@ -326,23 +326,27 @@ class EfuseMacField(EfuseField):
             raise esptool.FatalError(
                 "Required MAC Address in AA:CD:EF:01:02:03 format!"
             )
-        if new_value_str.count(":") != 5:
+        num_bytes = 8 if self.name == "MAC_EUI64" else 6
+        if new_value_str.count(":") != num_bytes - 1:
             raise esptool.FatalError(
-                "MAC Address needs to be a 6-byte hexadecimal format "
+                f"MAC Address needs to be a {num_bytes}-byte hexadecimal format "
                 "separated by colons (:)!"
             )
-        hexad = new_value_str.replace(":", "")
-        if len(hexad) != 12:
+        hexad = new_value_str.replace(":", "").split(" ", 1)[0]
+        hexad = hexad.split(" ", 1)[0] if self.is_field_calculated() else hexad
+        if len(hexad) != num_bytes * 2:
             raise esptool.FatalError(
-                "MAC Address needs to be a 6-byte hexadecimal number "
-                "(12 hexadecimal characters)!"
+                f"MAC Address needs to be a {num_bytes}-byte hexadecimal number "
+                f"({num_bytes * 2} hexadecimal characters)!"
             )
         # order of bytearray = b'\xaa\xcd\xef\x01\x02\x03',
         bindata = binascii.unhexlify(hexad)
-        # unicast address check according to
-        # https://tools.ietf.org/html/rfc7042#section-2.1
-        if esptool.util.byte(bindata, 0) & 0x01:
-            raise esptool.FatalError("Custom MAC must be a unicast MAC!")
+
+        if not self.is_field_calculated():
+            # unicast address check according to
+            # https://tools.ietf.org/html/rfc7042#section-2.1
+            if esptool.util.byte(bindata, 0) & 0x01:
+                raise esptool.FatalError("Custom MAC must be a unicast MAC!")
         return bindata
 
     def check(self):
@@ -356,6 +360,13 @@ class EfuseMacField(EfuseField):
     def get(self, from_read=True):
         if self.name == "CUSTOM_MAC":
             mac = self.get_raw(from_read)[::-1]
+        elif self.name == "MAC":
+            mac = self.get_raw(from_read)
+        elif self.name == "MAC_EUI64":
+            mac = self.parent["MAC"].get_bitstring(from_read).copy()
+            mac_ext = self.parent["MAC_EXT"].get_bitstring(from_read)
+            mac.insert(mac_ext, 24)
+            mac = mac.bytes
         else:
             mac = self.get_raw(from_read)
         return "%s %s" % (util.hexify(mac, ":"), self.check())
@@ -375,7 +386,7 @@ class EfuseMacField(EfuseField):
         else:
             # Writing the BLOCK1 (MAC_SPI_8M_0) default MAC is not possible,
             # as it's written in the factory.
-            raise esptool.FatalError("Writing Factory MAC address is not supported")
+            raise esptool.FatalError(f"Burning {self.name} is not supported")
 
 
 # fmt: off

{esptool-4.6.1 → esptool-4.7.dev1}/espefuse/efuse/esp32c6/mem_definition.py

@@ -12,6 +12,7 @@ from ..mem_definition_base import (
     EfuseBlocksBase,
     EfuseFieldsBase,
     EfuseRegistersBase,
+    Field,
 )
 
 
@@ -151,6 +152,16 @@ class EfuseDefineFields(EfuseFieldsBase):
                 self.BLOCK2_CALIBRATION_EFUSES.append(efuse)
                 self.ALL_EFUSES[i] = None
 
+        f = Field()
+        f.name = "MAC_EUI64"
+        f.block = 1
+        f.bit_len = 64
+        f.type = f"bytes:{f.bit_len // 8}"
+        f.category = "MAC"
+        f.class_type = "mac"
+        f.description = "calc MAC_EUI64 = MAC[0]:MAC[1]:MAC[2]:MAC_EXT[0]:MAC_EXT[1]:MAC[3]:MAC[4]:MAC[5]"
+        self.CALC.append(f)
+
         for efuse in self.ALL_EFUSES:
             if efuse is not None:
                 self.EFUSES.append(efuse)

{esptool-4.6.1 → esptool-4.7.dev1}/espefuse/efuse/esp32c6/operations.py

@@ -167,8 +167,7 @@ def add_commands(subparsers, efuses):
     p.add_argument(
         "mac",
         help="Custom MAC Address to burn given in hexadecimal format with bytes "
-        "separated by colons (e.g. AA:CD:EF:01:02:03). "
-        "Final CUSTOM_MAC = CUSTOM_MAC[48] + MAC_EXT[16]",
+        "separated by colons (e.g. AA:CD:EF:01:02:03).",
         type=fields.base_fields.CheckArgValue(efuses, "CUSTOM_MAC"),
     )
     add_force_write_always(p)

{esptool-4.6.1 → esptool-4.7.dev1}/espefuse/efuse/esp32h2/fields.py

@@ -327,23 +327,27 @@ class EfuseMacField(EfuseField):
             raise esptool.FatalError(
                 "Required MAC Address in AA:CD:EF:01:02:03 format!"
             )
-        if new_value_str.count(":") != 5:
+        num_bytes = 8 if self.name == "MAC_EUI64" else 6
+        if new_value_str.count(":") != num_bytes - 1:
             raise esptool.FatalError(
-                "MAC Address needs to be a 6-byte hexadecimal format "
+                f"MAC Address needs to be a {num_bytes}-byte hexadecimal format "
                 "separated by colons (:)!"
             )
         hexad = new_value_str.replace(":", "")
-        if len(hexad) != 12:
+        hexad = hexad.split(" ", 1)[0] if self.is_field_calculated() else hexad
+        if len(hexad) != num_bytes * 2:
             raise esptool.FatalError(
-                "MAC Address needs to be a 6-byte hexadecimal number "
-                "(12 hexadecimal characters)!"
+                f"MAC Address needs to be a {num_bytes}-byte hexadecimal number "
+                f"({num_bytes * 2} hexadecimal characters)!"
             )
         # order of bytearray = b'\xaa\xcd\xef\x01\x02\x03',
         bindata = binascii.unhexlify(hexad)
-        # unicast address check according to
-        # https://tools.ietf.org/html/rfc7042#section-2.1
-        if esptool.util.byte(bindata, 0) & 0x01:
-            raise esptool.FatalError("Custom MAC must be a unicast MAC!")
+
+        if not self.is_field_calculated():
+            # unicast address check according to
+            # https://tools.ietf.org/html/rfc7042#section-2.1
+            if esptool.util.byte(bindata, 0) & 0x01:
+                raise esptool.FatalError("Custom MAC must be a unicast MAC!")
         return bindata
 
     def check(self):
@@ -356,11 +360,14 @@ class EfuseMacField(EfuseField):
 
     def get(self, from_read=True):
         if self.name == "CUSTOM_MAC":
-            mac = self.get_raw(from_read)[::-1] + self.parent["MAC_EXT"].get_raw(
-                from_read
-            )
+            mac = self.get_raw(from_read)[::-1]
         elif self.name == "MAC":
-            mac = self.get_raw(from_read) + self.parent["MAC_EXT"].get_raw(from_read)
+            mac = self.get_raw(from_read)
+        elif self.name == "MAC_EUI64":
+            mac = self.parent["MAC"].get_bitstring(from_read).copy()
+            mac_ext = self.parent["MAC_EXT"].get_bitstring(from_read)
+            mac.insert(mac_ext, 24)
+            mac = mac.bytes
         else:
             mac = self.get_raw(from_read)
         return "%s %s" % (util.hexify(mac, ":"), self.check())
@@ -380,7 +387,7 @@ class EfuseMacField(EfuseField):
         else:
             # Writing the BLOCK1 (MAC_SPI_8M_0) default MAC is not possible,
             # as it's written in the factory.
-            raise esptool.FatalError("Writing Factory MAC address is not supported")
+            raise esptool.FatalError(f"Burning {self.name} is not supported")
 
 
 # fmt: off

{esptool-4.6.1 → esptool-4.7.dev1}/espefuse/efuse/esp32h2/mem_definition.py

@@ -8,7 +8,12 @@ import os
 
 import yaml
 
-from ..mem_definition_base import EfuseBlocksBase, EfuseFieldsBase, EfuseRegistersBase
+from ..mem_definition_base import (
+    EfuseBlocksBase,
+    EfuseFieldsBase,
+    EfuseRegistersBase,
+    Field,
+)
 
 
 class EfuseDefineRegisters(EfuseRegistersBase):
@@ -147,6 +152,16 @@ class EfuseDefineFields(EfuseFieldsBase):
                 self.BLOCK2_CALIBRATION_EFUSES.append(efuse)
                 self.ALL_EFUSES[i] = None
 
+        f = Field()
+        f.name = "MAC_EUI64"
+        f.block = 1
+        f.bit_len = 64
+        f.type = f"bytes:{f.bit_len // 8}"
+        f.category = "MAC"
+        f.class_type = "mac"
+        f.description = "calc MAC_EUI64 = MAC[0]:MAC[1]:MAC[2]:MAC_EXT[0]:MAC_EXT[1]:MAC[3]:MAC[4]:MAC[5]"
+        self.CALC.append(f)
+
         for efuse in self.ALL_EFUSES:
             if efuse is not None:
                 self.EFUSES.append(efuse)

{esptool-4.6.1 → esptool-4.7.dev1}/espefuse/efuse/esp32h2/operations.py

@@ -166,8 +166,7 @@ def add_commands(subparsers, efuses):
     p.add_argument(
         "mac",
         help="Custom MAC Address to burn given in hexadecimal format with bytes "
-        "separated by colons (e.g. AA:CD:EF:01:02:03). "
-        "Final CUSTOM_MAC = CUSTOM_MAC[48] + MAC_EXT[16]",
+        "separated by colons (e.g. AA:CD:EF:01:02:03).",
         type=fields.base_fields.CheckArgValue(efuses, "CUSTOM_MAC"),
     )
     add_force_write_always(p)

{esptool-4.6.1 → esptool-4.7.dev1}/espefuse/efuse/esp32h2beta1/fields.py

@@ -326,23 +326,27 @@ class EfuseMacField(EfuseField):
             raise esptool.FatalError(
                 "Required MAC Address in AA:CD:EF:01:02:03 format!"
             )
-        if new_value_str.count(":") != 5:
+        num_bytes = 8 if self.name == "MAC_EUI64" else 6
+        if new_value_str.count(":") != num_bytes - 1:
             raise esptool.FatalError(
-                "MAC Address needs to be a 6-byte hexadecimal format "
+                f"MAC Address needs to be a {num_bytes}-byte hexadecimal format "
                 "separated by colons (:)!"
             )
-        hexad = new_value_str.replace(":", "")
-        if len(hexad) != 12:
+        hexad = new_value_str.replace(":", "").split(" ", 1)[0]
+        hexad = hexad.split(" ", 1)[0] if self.is_field_calculated() else hexad
+        if len(hexad) != num_bytes * 2:
             raise esptool.FatalError(
-                "MAC Address needs to be a 6-byte hexadecimal number "
-                "(12 hexadecimal characters)!"
+                f"MAC Address needs to be a {num_bytes}-byte hexadecimal number "
+                f"({num_bytes * 2} hexadecimal characters)!"
             )
         # order of bytearray = b'\xaa\xcd\xef\x01\x02\x03',
         bindata = binascii.unhexlify(hexad)
-        # unicast address check according to
-        # https://tools.ietf.org/html/rfc7042#section-2.1
-        if esptool.util.byte(bindata, 0) & 0x01:
-            raise esptool.FatalError("Custom MAC must be a unicast MAC!")
+
+        if not self.is_field_calculated():
+            # unicast address check according to
+            # https://tools.ietf.org/html/rfc7042#section-2.1
+            if esptool.util.byte(bindata, 0) & 0x01:
+                raise esptool.FatalError("Custom MAC must be a unicast MAC!")
         return bindata
 
     def check(self):
@@ -355,11 +359,14 @@ class EfuseMacField(EfuseField):
 
     def get(self, from_read=True):
         if self.name == "CUSTOM_MAC":
-            mac = self.get_raw(from_read)[::-1] + self.parent["MAC_EXT"].get_raw(
-                from_read
-            )
+            mac = self.get_raw(from_read)[::-1]
         elif self.name == "MAC":
-            mac = self.get_raw(from_read) + self.parent["MAC_EXT"].get_raw(from_read)
+            mac = self.get_raw(from_read)
+        elif self.name == "MAC_EUI64":
+            mac = self.parent["MAC"].get_bitstring(from_read).copy()
+            mac_ext = self.parent["MAC_EXT"].get_bitstring(from_read)
+            mac.insert(mac_ext, 24)
+            mac = mac.bytes
         else:
             mac = self.get_raw(from_read)
         return "%s %s" % (util.hexify(mac, ":"), self.check())
@@ -379,6 +386,7 @@ class EfuseMacField(EfuseField):
         else:
             # Writing the BLOCK1 (MAC_SPI_8M_0) default MAC is not possible,
             # as it's written in the factory.
+            raise esptool.FatalError(f"Burning {self.name} is not supported")
             raise esptool.FatalError("Writing Factory MAC address is not supported")
 
 

{esptool-4.6.1 → esptool-4.7.dev1}/espefuse/efuse/esp32h2beta1/operations.py

@@ -166,8 +166,7 @@ def add_commands(subparsers, efuses):
     p.add_argument(
         "mac",
         help="Custom MAC Address to burn given in hexadecimal format with bytes "
-        "separated by colons (e.g. AA:CD:EF:01:02:03). "
-        "Final CUSTOM_MAC = CUSTOM_MAC[48] + MAC_EXT[16]",
+        "separated by colons (e.g. AA:CD:EF:01:02:03).",
         type=fields.base_fields.CheckArgValue(efuses, "CUSTOM_MAC"),
     )
     add_force_write_always(p)

esptool-4.7.dev1/espefuse/efuse/esp32p4/emulate_efuse_controller.py

@@ -0,0 +1,92 @@
+# This file describes eFuses controller for ESP32-P4 chip
+#
+# SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+import reedsolo
+
+from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters
+from ..emulate_efuse_controller_base import EmulateEfuseControllerBase, FatalError
+
+
+class EmulateEfuseController(EmulateEfuseControllerBase):
+    """The class for virtual efuse operation. Using for HOST_TEST."""
+
+    CHIP_NAME = "ESP32-P4"
+    mem = None
+    debug = False
+
+    def __init__(self, efuse_file=None, debug=False):
+        self.Blocks = EfuseDefineBlocks
+        self.Fields = EfuseDefineFields()
+        self.REGS = EfuseDefineRegisters
+        super(EmulateEfuseController, self).__init__(efuse_file, debug)
+        self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
+
+    """ esptool method start >>"""
+
+    def get_major_chip_version(self):
+        return 0
+
+    def get_minor_chip_version(self):
+        return 0
+
+    def get_crystal_freq(self):
+        return 40  # MHz (common for all chips)
+
+    def get_security_info(self):
+        return {
+            "flags": 0,
+            "flash_crypt_cnt": 0,
+            "key_purposes": 0,
+            "chip_id": 0,
+            "api_version": 0,
+        }
+
+    """ << esptool method end """
+
+    def handle_writing_event(self, addr, value):
+        if addr == self.REGS.EFUSE_CMD_REG:
+            if value & self.REGS.EFUSE_PGM_CMD:
+                self.copy_blocks_wr_regs_to_rd_regs(updated_block=(value >> 2) & 0xF)
+                self.clean_blocks_wr_regs()
+                self.check_rd_protection_area()
+                self.write_reg(addr, 0)
+                self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
+            elif value == self.REGS.EFUSE_READ_CMD:
+                self.write_reg(addr, 0)
+                self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
+                self.save_to_file()
+
+    def get_bitlen_of_block(self, blk, wr=False):
+        if blk.id == 0:
+            if wr:
+                return 32 * 8
+            else:
+                return 32 * blk.len
+        else:
+            if wr:
+                rs_coding = 32 * 3
+                return 32 * 8 + rs_coding
+            else:
+                return 32 * blk.len
+
+    def handle_coding_scheme(self, blk, data):
+        if blk.id != 0:
+            # CODING_SCHEME RS applied only for all blocks except BLK0.
+            coded_bytes = 12
+            data.pos = coded_bytes * 8
+            plain_data = data.readlist("32*uint:8")[::-1]
+            # takes 32 bytes
+            # apply RS encoding
+            rs = reedsolo.RSCodec(coded_bytes)
+            # 32 byte of data + 12 bytes RS
+            calc_encoded_data = list(rs.encode([x for x in plain_data]))
+            data.pos = 0
+            if calc_encoded_data != data.readlist("44*uint:8")[::-1]:
+                raise FatalError("Error in coding scheme data")
+            data = data[coded_bytes * 8 :]
+        if blk.len < 8:
+            data = data[(8 - blk.len) * 32 :]
+        return data