esptool 4.8.dev1__tar.gz → 4.8.dev3__tar.gz

{esptool-4.8.dev1/esptool.egg-info → esptool-4.8.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: esptool
-Version: 4.8.dev1
+Version: 4.8.dev3
 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,6 +9,22 @@ 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
@@ -28,22 +44,3 @@ Classifier: Programming Language :: Python :: 3.12
 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.8.dev1 → esptool-4.8.dev3}/esp_rfc2217_server.py

@@ -9,7 +9,7 @@
 # This is a modified version of rfc2217_server.py provided by the pyserial package
 # (pythonhosted.org/pyserial/examples.html#single-port-tcp-ip-serial-bridge-rfc-2217).
 # It uses a custom PortManager to properly apply the RTS & DTR signals
-# for reseting ESP chips.
+# for resetting ESP chips.
 #
 # Run the following command on the server side to make
 # connection between /dev/ttyUSB1 and TCP port 4000:
@@ -256,7 +256,7 @@ def main():
     logging.getLogger("rfc2217").setLevel(level)
 
     # connect to serial port
-    ser = serial.serial_for_url(args.SERIALPORT, do_not_open=True)
+    ser = serial.serial_for_url(args.SERIALPORT, do_not_open=True, exclusive=True)
     ser.timeout = 3  # required so that the reader thread can exit
     # reset control line as no _remote_ "terminal" has been connected yet
     ser.dtr = False

{esptool-4.8.dev1 → esptool-4.8.dev3}/espefuse/__init__.py

@@ -11,8 +11,10 @@ from io import StringIO
 import espefuse.efuse.esp32 as esp32_efuse
 import espefuse.efuse.esp32c2 as esp32c2_efuse
 import espefuse.efuse.esp32c3 as esp32c3_efuse
+import espefuse.efuse.esp32c5 as esp32c5_efuse
 import espefuse.efuse.esp32c5beta3 as esp32c5beta3_efuse
 import espefuse.efuse.esp32c6 as esp32c6_efuse
+import espefuse.efuse.esp32c61 as esp32c61_efuse
 import espefuse.efuse.esp32h2 as esp32h2_efuse
 import espefuse.efuse.esp32h2beta1 as esp32h2beta1_efuse
 import espefuse.efuse.esp32p4 as esp32p4_efuse
@@ -50,6 +52,8 @@ SUPPORTED_CHIPS = {
     "esp32c2": DefChip("ESP32-C2", esp32c2_efuse, esptool.targets.ESP32C2ROM),
     "esp32c3": DefChip("ESP32-C3", esp32c3_efuse, esptool.targets.ESP32C3ROM),
     "esp32c6": DefChip("ESP32-C6", esp32c6_efuse, esptool.targets.ESP32C6ROM),
+    "esp32c61": DefChip("ESP32-C61", esp32c61_efuse, esptool.targets.ESP32C61ROM),
+    "esp32c5": DefChip("ESP32-C5", esp32c5_efuse, esptool.targets.ESP32C5ROM),
     "esp32c5beta3": DefChip(
         "ESP32-C5(beta3)", esp32c5beta3_efuse, esptool.targets.ESP32C5BETA3ROM
     ),
@@ -214,6 +218,12 @@ def main(custom_commandline=None, esp=None):
         "Use with caution.",
         action="store_true",
     )
+    init_parser.add_argument(
+        "--postpone",
+        help="Postpone burning some efuses from BLOCK0 at the end, "
+        "(efuses which disable access to blocks or chip).",
+        action="store_true",
+    )
 
     common_args, remaining_args = init_parser.parse_known_args(custom_commandline)
     debug_mode = common_args.debug or ("dump" in remaining_args)
@@ -263,6 +273,8 @@ def main(custom_commandline=None, esp=None):
     if there_are_multiple_burn_commands_in_args:
         efuses.batch_mode_cnt += 1
 
+    efuses.postpone = common_args.postpone
+
     try:
         for rem_args in grouped_remaining_args:
             args, unused_args = parser.parse_known_args(rem_args, namespace=common_args)
@@ -289,6 +301,7 @@ def main(custom_commandline=None, esp=None):
             efuses.batch_mode_cnt -= 1
             if not efuses.burn_all(check_batch_mode=True):
                 raise esptool.FatalError("BURN was not done")
+            print("Successful")
     finally:
         if not external_esp and not common_args.virt and esp._port:
             esp._port.close()

{esptool-4.8.dev1 → esptool-4.8.dev3}/espefuse/efuse/base_fields.py

@@ -58,8 +58,9 @@ class CheckArgValue(object):
             elif efuse.efuse_type.startswith("bytes"):
                 if new_value is None:
                     raise esptool.FatalError(
-                        "New value required for efuse '{}' "
-                        "(given None)".format(efuse.name)
+                        "New value required for efuse '{}' (given None)".format(
+                            efuse.name
+                        )
                     )
                 if len(new_value) * 8 != efuse.bitarray.len:
                     raise esptool.FatalError(
@@ -316,7 +317,7 @@ class EfuseBlockBase(EfuseProtectBase):
                                     if rd_chunk == wr_chunk:
                                         print(
                                             "wr_chunk == rd_chunk. "
-                                            "Countinue with empty chunk."
+                                            "Continue with empty chunk."
                                         )
                                         wr_data[i : i + 6 * 8 :].set(0)
                                     else:
@@ -445,6 +446,7 @@ class EspEfusesBase(object):
     coding_scheme = None
     force_write_always = None
     batch_mode_cnt = 0
+    postpone = False
 
     def __iter__(self):
         return self.efuses.__iter__()
@@ -489,6 +491,59 @@ class EspEfusesBase(object):
         for efuse in self.efuses:
             efuse.update(self.blocks[efuse.block].bitarray)
 
+    def postpone_efuses_from_block0_to_burn(self, block):
+        postpone_efuses = {}
+
+        if block.id != 0:
+            return postpone_efuses
+
+        # We need to check this list of efuses. If we are going to burn an efuse
+        # from this list, then we need to split the burn operation into two
+        # steps. The first step involves burning efuses not in this list. In
+        # case of an error during this step, we can recover by burning the
+        # efuses from this list at the very end. This approach provides the
+        # ability to recover efuses if an error occurs during the initial burn
+        # operation.
+
+        # List the efuses here that must be burned at the very end, such as read
+        # and write protection fields, as well as efuses that disable
+        # communication with the espefuse tool.
+        efuses_list = ["WR_DIS", "RD_DIS"]
+        if self._esp.CHIP_NAME == "ESP32":
+            # Efuses below disables communication with the espefuse tool.
+            efuses_list.append("UART_DOWNLOAD_DIS")
+            # other efuses that are better to burn at the very end.
+            efuses_list.append("ABS_DONE_1")
+            efuses_list.append("FLASH_CRYPT_CNT")
+        else:
+            # Efuses below disables communication with the espefuse tool.
+            efuses_list.append("ENABLE_SECURITY_DOWNLOAD")
+            efuses_list.append("DIS_DOWNLOAD_MODE")
+            # other efuses that are better to burn at the very end.
+            efuses_list.append("SPI_BOOT_CRYPT_CNT")
+            efuses_list.append("SECURE_BOOT_EN")
+
+        def get_raw_value_from_write(self, efuse_name):
+            return self[efuse_name].get_bitstring(from_read=False)
+
+        for efuse_name in efuses_list:
+            postpone_efuses[efuse_name] = get_raw_value_from_write(self, efuse_name)
+
+        if any(value != 0 for value in postpone_efuses.values()):
+            if self.debug:
+                print("These BLOCK0 efuses will be burned later at the very end:")
+                print(postpone_efuses)
+            # exclude these efuses from the first burn (postpone them till the end).
+            for key_name in postpone_efuses.keys():
+                self[key_name].reset()
+        return postpone_efuses
+
+    def recover_postponed_efuses_from_block0_to_burn(self, postpone_efuses):
+        if any(value != 0 for value in postpone_efuses.values()):
+            print("Burn postponed efuses from BLOCK0.")
+            for key_name in postpone_efuses.keys():
+                self[key_name].save(postpone_efuses[key_name])
+
     def burn_all(self, check_batch_mode=False):
         if check_batch_mode:
             if self.batch_mode_cnt != 0:
@@ -508,18 +563,44 @@ class EspEfusesBase(object):
                 have_wr_data_for_burn = True
         if not have_wr_data_for_burn:
             print("Nothing to burn, see messages above.")
-            return
+            return True
         EspEfusesBase.confirm("", self.do_not_confirm)
 
-        # Burn from BLKn -> BLK0. Because BLK0 can set rd or/and wr protection bits.
-        for block in reversed(self.blocks):
+        def burn_block(block, postponed_efuses):
             old_fail = block.fail
             old_num_errors = block.num_errors
             block.burn()
             if (block.fail and old_fail != block.fail) or (
                 block.num_errors and block.num_errors > old_num_errors
             ):
+                if postponed_efuses:
+                    print("The postponed efuses were not burned due to an error.")
+                    print("\t1. Try to fix a coding error by this cmd:")
+                    print("\t   'espefuse.py check_error --recovery'")
+                    command_string = " ".join(
+                        f"{key} {value}"
+                        for key, value in postponed_efuses.items()
+                        if value.any(True)
+                    )
+                    print("\t2. Then run the cmd to burn all postponed efuses:")
+                    print(f"\t   'espefuse.py burn_efuse {command_string}'")
+
                 raise esptool.FatalError("Error(s) were detected in eFuses")
+
+        # Burn from BLKn -> BLK0. Because BLK0 can set rd or/and wr protection bits.
+        for block in reversed(self.blocks):
+            postponed_efuses = (
+                self.postpone_efuses_from_block0_to_burn(block)
+                if self.postpone
+                else None
+            )
+
+            burn_block(block, postponed_efuses)
+
+            if postponed_efuses:
+                self.recover_postponed_efuses_from_block0_to_burn(postponed_efuses)
+                burn_block(block, postponed_efuses)
+
         print("Reading updated efuses...")
         self.read_coding_scheme()
         self.read_blocks()
@@ -628,6 +709,10 @@ class EfuseFieldBase(EfuseProtectBase):
 
     def check_new_value(self, bitarray_new_value):
         bitarray_old_value = self.get_bitstring() | self.get_bitstring(from_read=False)
+
+        if not bitarray_new_value.any(True) and not bitarray_old_value.any(True):
+            return
+
         if bitarray_new_value.len != bitarray_old_value.len:
             raise esptool.FatalError(
                 "For {} efuse, the length of the new value is wrong, "
@@ -635,7 +720,10 @@ class EfuseFieldBase(EfuseProtectBase):
                     self.name, bitarray_old_value.len, bitarray_new_value.len
                 )
             )
-        if bitarray_new_value == bitarray_old_value:
+        if (
+            bitarray_new_value == bitarray_old_value
+            or bitarray_new_value & self.get_bitstring() == bitarray_new_value
+        ):
             error_msg = "\tThe same value for {} ".format(self.name)
             error_msg += "is already burned. Do not change the efuse."
             print(error_msg)
@@ -648,7 +736,7 @@ class EfuseFieldBase(EfuseProtectBase):
         else:
             if self.name not in ["WR_DIS", "RD_DIS"]:
                 # WR_DIS, RD_DIS fields can have already set bits.
-                # Do not neeed to check below condition for them.
+                # Do not need to check below condition for them.
                 if bitarray_new_value | bitarray_old_value != bitarray_new_value:
                     error_msg = "\tNew value contains some bits that cannot be cleared "
                     error_msg += "(value will be {})".format(
@@ -752,3 +840,14 @@ class EfuseFieldBase(EfuseProtectBase):
             if name is not None:
                 output += f"\n  Purpose: {self.parent[name].get()}\n "
         return output
+
+    def reset(self):
+        # resets a efuse that is prepared for burning
+        bitarray_field = self.convert_to_bitstring(0)
+        block = self.parent.blocks[self.block]
+        wr_bitarray_temp = block.wr_bitarray.copy()
+        position = wr_bitarray_temp.length - (
+            self.word * 32 + self.pos + bitarray_field.len
+        )
+        wr_bitarray_temp.overwrite(bitarray_field, pos=position)
+        block.wr_bitarray = wr_bitarray_temp

{esptool-4.8.dev1 → esptool-4.8.dev3}/espefuse/efuse/base_operations.py

@@ -684,7 +684,8 @@ def burn_bit(esp, efuses, args):
 
 
 def get_error_summary(efuses):
-    error_in_blocks = efuses.get_coding_scheme_warnings()
+    efuses.get_coding_scheme_warnings()
+    error_in_blocks = any(blk.fail or blk.num_errors != 0 for blk in efuses.blocks)
     if not error_in_blocks:
         return False
     writable = True

{esptool-4.8.dev1 → esptool-4.8.dev3}/espefuse/efuse/esp32/emulate_efuse_controller.py

@@ -75,10 +75,14 @@ class EmulateEfuseController(EmulateEfuseControllerBase):
                 self.save_to_file()
 
     def read_raw_coding_scheme(self):
-        return (
+        coding_scheme = (
             self.read_efuse(self.REGS.EFUSE_CODING_SCHEME_WORD)
             & self.REGS.EFUSE_CODING_SCHEME_MASK
         )
+        if coding_scheme == self.REGS.CODING_SCHEME_NONE_RECOVERY:
+            return self.REGS.CODING_SCHEME_NONE
+        else:
+            return coding_scheme
 
     def write_raw_coding_scheme(self, value):
         self.write_efuse(

{esptool-4.8.dev1 → esptool-4.8.dev3}/espefuse/efuse/esp32/fields.py

@@ -157,10 +157,14 @@ class EspEfuses(base_fields.EspEfusesBase):
         raise KeyError
 
     def read_coding_scheme(self):
-        self.coding_scheme = (
+        coding_scheme = (
             self.read_efuse(self.REGS.EFUSE_CODING_SCHEME_WORD)
             & self.REGS.EFUSE_CODING_SCHEME_MASK
         )
+        if coding_scheme == self.REGS.CODING_SCHEME_NONE_RECOVERY:
+            self.coding_scheme = self.REGS.CODING_SCHEME_NONE
+        else:
+            self.coding_scheme = coding_scheme
 
     def print_status_regs(self):
         print("")

{esptool-4.8.dev1 → esptool-4.8.dev3}/espefuse/efuse/esp32c2/fields.py

@@ -368,15 +368,14 @@ class EfuseMacField(EfuseField):
 
 
 class EfuseKeyPurposeField(EfuseField):
+    # fmt: off
     KEY_PURPOSES = [
-        # fmt: off
         ("USER",                                        0, None),      # User purposes (software-only use)
         ("XTS_AES_128_KEY",                             1, None),      # (whole 256bits) flash/PSRAM encryption
         ("XTS_AES_128_KEY_DERIVED_FROM_128_EFUSE_BITS", 2, None),      # (lo 128bits) flash/PSRAM encryption
         ("SECURE_BOOT_DIGEST",                          3, "DIGEST"),
         # (hi 128bits) Secure Boot key digest
-        # fmt: on
-    ]
+    ]  # fmt: on
 
     KEY_PURPOSES_NAME = [name[0] for name in KEY_PURPOSES]
     DIGEST_KEY_PURPOSES = [name[0] for name in KEY_PURPOSES if name[2] == "DIGEST"]

{esptool-4.8.dev1 → esptool-4.8.dev3}/espefuse/efuse/esp32c2/operations.py

@@ -153,18 +153,13 @@ def adc_info(esp, efuses, args):
     print("")
     # fmt: off
     if efuses["BLK_VERSION_MINOR"].get() == 1:
-        print("    RF_REF_I_BIAS_CONFIG:        {}".format(efuses["RF_REF_I_BIAS_CONFIG"].get()))
-
-        print("    LDO_VOL_BIAS_CONFIG_LOW:     {}".format(efuses["LDO_VOL_BIAS_CONFIG_LOW"].get()))
-        print("    LDO_VOL_BIAS_CONFIG_HIGH:    {}".format(efuses["LDO_VOL_BIAS_CONFIG_HIGH"].get()))
-
-        print("    PVT_LOW:                     {}".format(efuses["PVT_LOW"].get()))
-        print("    PVT_HIGH:                    {}".format(efuses["PVT_HIGH"].get()))
-
-        print("    ADC_CALIBRATION_0:           {}".format(efuses["ADC_CALIBRATION_0"].get()))
-        print("    ADC_CALIBRATION_1:           {}".format(efuses["ADC_CALIBRATION_1"].get()))
-        print("    ADC_CALIBRATION_2:           {}".format(efuses["ADC_CALIBRATION_2"].get()))
-
+        print("Temperature Sensor Calibration = {}C".format(efuses["TEMP_CALIB"].get()))
+        print("ADC OCode        = ", efuses["OCODE"].get())
+        print("ADC1:")
+        print("INIT_CODE_ATTEN0 = ", efuses["ADC1_INIT_CODE_ATTEN0"].get())
+        print("INIT_CODE_ATTEN3 = ", efuses["ADC1_INIT_CODE_ATTEN3"].get())
+        print("CAL_VOL_ATTEN0   = ", efuses["ADC1_CAL_VOL_ATTEN0"].get())
+        print("CAL_VOL_ATTEN3   = ", efuses["ADC1_CAL_VOL_ATTEN3"].get())
     else:
         print("BLK_VERSION_MINOR = {}".format(efuses["BLK_VERSION_MINOR"].get_meaning()))
     # fmt: on

{esptool-4.8.dev1/espefuse/efuse/esp32c5beta3 → esptool-4.8.dev3/espefuse/efuse/esp32c3}/operations.py

@@ -1,6 +1,6 @@
-# This file includes the operations with eFuses for ESP32-C5 beta3 chip
+# This file includes the operations with eFuses for ESP32-C3 chip
 #
-# SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -194,29 +194,20 @@ def set_flash_voltage(esp, efuses, args):
 def adc_info(esp, efuses, args):
     print("")
     # fmt: off
-    if efuses["BLK_VERSION_MINOR"].get() == 1:
+    if efuses["BLK_VERSION_MAJOR"].get() == 1:
         print("Temperature Sensor Calibration = {}C".format(efuses["TEMP_CALIB"].get()))
-
-        print("")
-        print("ADC1 Calibration data stored in efuse BLOCK2:")
-        print(f"OCODE: {efuses['OCODE'].get()}")
-        print(f"INIT_CODE_ATTEN0: {efuses['ADC1_INIT_CODE_ATTEN0'].get()}")
-        print(f"INIT_CODE_ATTEN1: {efuses['ADC1_INIT_CODE_ATTEN1'].get()}")
-        print(f"INIT_CODE_ATTEN2: {efuses['ADC1_INIT_CODE_ATTEN2'].get()}")
-        print(f"INIT_CODE_ATTEN3: {efuses['ADC1_INIT_CODE_ATTEN3'].get()}")
-        print(f"CAL_VOL_ATTEN0: {efuses['ADC1_CAL_VOL_ATTEN0'].get()}")
-        print(f"CAL_VOL_ATTEN1: {efuses['ADC1_CAL_VOL_ATTEN1'].get()}")
-        print(f"CAL_VOL_ATTEN2: {efuses['ADC1_CAL_VOL_ATTEN2'].get()}")
-        print(f"CAL_VOL_ATTEN3: {efuses['ADC1_CAL_VOL_ATTEN3'].get()}")
-        print(f"INIT_CODE_ATTEN0_CH0: {efuses['ADC1_INIT_CODE_ATTEN0_CH0'].get()}")
-        print(f"INIT_CODE_ATTEN0_CH1: {efuses['ADC1_INIT_CODE_ATTEN0_CH1'].get()}")
-        print(f"INIT_CODE_ATTEN0_CH2: {efuses['ADC1_INIT_CODE_ATTEN0_CH2'].get()}")
-        print(f"INIT_CODE_ATTEN0_CH3: {efuses['ADC1_INIT_CODE_ATTEN0_CH3'].get()}")
-        print(f"INIT_CODE_ATTEN0_CH4: {efuses['ADC1_INIT_CODE_ATTEN0_CH4'].get()}")
-        print(f"INIT_CODE_ATTEN0_CH5: {efuses['ADC1_INIT_CODE_ATTEN0_CH5'].get()}")
-        print(f"INIT_CODE_ATTEN0_CH6: {efuses['ADC1_INIT_CODE_ATTEN0_CH6'].get()}")
+        print("ADC OCode        = ", efuses["OCODE"].get())
+        print("ADC1:")
+        print("INIT_CODE_ATTEN0 = ", efuses["ADC1_INIT_CODE_ATTEN0"].get())
+        print("INIT_CODE_ATTEN1 = ", efuses["ADC1_INIT_CODE_ATTEN1"].get())
+        print("INIT_CODE_ATTEN2 = ", efuses["ADC1_INIT_CODE_ATTEN2"].get())
+        print("INIT_CODE_ATTEN3 = ", efuses["ADC1_INIT_CODE_ATTEN3"].get())
+        print("CAL_VOL_ATTEN0   = ", efuses["ADC1_CAL_VOL_ATTEN0"].get())
+        print("CAL_VOL_ATTEN1   = ", efuses["ADC1_CAL_VOL_ATTEN1"].get())
+        print("CAL_VOL_ATTEN2   = ", efuses["ADC1_CAL_VOL_ATTEN2"].get())
+        print("CAL_VOL_ATTEN3   = ", efuses["ADC1_CAL_VOL_ATTEN3"].get())
     else:
-        print("BLK_VERSION_MINOR = {}".format(efuses["BLK_VERSION_MINOR"].get_meaning()))
+        print("BLK_VERSION_MAJOR = {}".format(efuses["BLK_VERSION_MAJOR"].get_meaning()))
     # fmt: on
 
 

esptool-4.8.dev3/espefuse/efuse/esp32c5/emulate_efuse_controller.py

@@ -0,0 +1,92 @@
+# This file describes eFuses controller for ESP32-C5 chip
+#
+# SPDX-FileCopyrightText: 2024 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-C5"
+    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_CMD_REG, 0)
+
+    """ 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_CMD_REG, 0)
+            elif value == self.REGS.EFUSE_READ_CMD:
+                self.write_reg(addr, 0)
+                self.write_reg(self.REGS.EFUSE_CMD_REG, 0)
+                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