fix(chip_type_verification): Enable in SDM, do not rely on magic numbers

Closes espressif#1008

Author: radimkarnis

esptool/cmds.py

@@ -108,10 +108,10 @@ def check_if_stub(instance):
     try:
         print("Detecting chip type...", end="")
         chip_id = detect_port.get_chip_id()
-        for cls in [
-            n for n in ROM_LIST if n.CHIP_NAME not in ("ESP8266", "ESP32", "ESP32-S2")
-        ]:
+        for cls in ROM_LIST:
             # cmd not supported on ESP8266 and ESP32 + ESP32-S2 doesn't return chip_id
+            if cls.USES_MAGIC_VALUE:
+                continue
             if chip_id == cls.IMAGE_CHIP_ID:
                 inst = cls(detect_port._port, baud, trace_enabled=trace_enabled)
                 try:
@@ -144,11 +144,12 @@ def check_if_stub(instance):
             )
 
             for cls in ROM_LIST:
-                if chip_magic_value in cls.CHIP_DETECT_MAGIC_VALUE:
+                if not cls.USES_MAGIC_VALUE:
+                    continue
+                if chip_magic_value == cls.MAGIC_VALUE:
                     inst = cls(detect_port._port, baud, trace_enabled=trace_enabled)
                     inst = check_if_stub(inst)
                     inst._post_connect()
-                    inst.check_chip_id()
                     break
             else:
                 err_msg = f"Unexpected chip magic value {chip_magic_value:#010x}."

esptool/loader.py

@@ -143,13 +143,6 @@ def stub_and_esp32_function_only(func):
     )
 
 
-def esp32s3_or_newer_function_only(func):
-    """Attribute for a function only supported by ESP32S3 and later chips ROM"""
-    return check_supported_function(
-        func, lambda o: o.CHIP_NAME not in ["ESP8266", "ESP32", "ESP32-S2"]
-    )
-
-
 class StubFlasher:
     STUB_DIR = os.path.join(os.path.dirname(__file__), "targets", "stub_flasher")
     # directories will be searched in the order of STUB_SUBDIRS
@@ -302,6 +295,9 @@ class ESPLoader(object):
     # Number of attempts to write flash data
     WRITE_FLASH_ATTEMPTS = 2
 
+    # Chip uses magic number for chip type autodetection
+    USES_MAGIC_VALUE = True
+
     def __init__(self, port=DEFAULT_PORT, baud=ESP_ROM_BAUD, trace_enabled=False):
         """Base constructor for ESPLoader bootloader interaction
 
@@ -752,41 +748,75 @@ def connect(
             )
 
         if not detecting:
-            try:
-                from .targets import ROM_LIST
+            from .targets import ROM_LIST
 
-                # check the date code registers match what we expect to see
+            # Perform a dummy read_reg to check if the chip is in secure download mode
+            try:
                 chip_magic_value = self.read_reg(ESPLoader.CHIP_DETECT_MAGIC_REG_ADDR)
-                if chip_magic_value not in self.CHIP_DETECT_MAGIC_VALUE:
-                    actually = None
-                    for cls in ROM_LIST:
-                        if chip_magic_value in cls.CHIP_DETECT_MAGIC_VALUE:
-                            actually = cls
-                            break
-                    if warnings and actually is None:
-                        print(
-                            "WARNING: This chip doesn't appear to be a %s "
-                            "(chip magic value 0x%08x). "
-                            "Probably it is unsupported by this version of esptool."
-                            % (self.CHIP_NAME, chip_magic_value)
-                        )
-                    else:
-                        raise FatalError(
-                            "This chip is %s not %s. Wrong --chip argument?"
-                            % (actually.CHIP_NAME, self.CHIP_NAME)
-                        )
             except UnsupportedCommandError:
                 self.secure_download_mode = True
 
+            # Check if chip supports reading chip ID from the get_security_info command
             try:
-                self.check_chip_id()
-            except UnsupportedCommandError:
-                # Fix for ROM not responding in SDM, reconnect and try again
-                if self.secure_download_mode:
-                    self._connect_attempt(mode, reset_sequence[0])
-                    self.check_chip_id()
+                chip_id = self.get_chip_id()
+            except (UnsupportedCommandError, struct.error, FatalError):
+                chip_id = None
+
+            detected = None
+            chip_arg_wrong = False
+
+            # If we can read chip ID (ESP32-S3 and later), verify the ID
+            if chip_id and (self.USES_MAGIC_VALUE or chip_id != self.IMAGE_CHIP_ID):
+                chip_arg_wrong = True
+                for cls in ROM_LIST:
+                    if not cls.USES_MAGIC_VALUE and chip_id == cls.IMAGE_CHIP_ID:
+                        detected = cls
+                        break
+            # If we can't read chip ID (ESP8266, ESP32, ESP32-S2),
+            # try to verify the chip by magic value
+            elif (
+                not chip_id
+                and not self.secure_download_mode
+                and (not self.USES_MAGIC_VALUE or chip_magic_value != self.MAGIC_VALUE)
+            ):
+                chip_arg_wrong = True
+                for cls in ROM_LIST:
+                    if cls.USES_MAGIC_VALUE and chip_magic_value == cls.MAGIC_VALUE:
+                        detected = cls
+                        break
+            # If we can't read chip ID and the chip is in SDM (ESP32 or ESP32-S2),
+            # we can't verify
+            elif not chip_id and self.secure_download_mode:
+                if self.CHIP_NAME not in ["ESP32", "ESP32-S2"]:
+                    chip_arg_wrong = True
+                    detected = "ESP32 or ESP32-S2"
                 else:
-                    raise
+                    print(
+                        f"WARNING: Can't verify this chip is {self.CHIP_NAME} "
+                        "because of active Secure Download Mode. "
+                        "Please check it manually."
+                    )
+
+            if chip_arg_wrong:
+                if warnings and detected is None:
+                    specifier = (
+                        f"(read chip ID {chip_id})"
+                        if chip_id
+                        else f"(read chip magic value {chip_magic_value:#08x})"
+                    )
+                    print(
+                        f"WARNING: This chip doesn't appear to be an {self.CHIP_NAME} "
+                        f"{specifier}. Probably it is unsupported by this version "
+                        "of esptool. Will attempt to continue anyway."
+                    )
+                else:
+                    chip_type = (
+                        detected if isinstance(detected, str) else detected.CHIP_NAME
+                    )
+                    raise FatalError(
+                        f"This chip is {chip_type}, not {self.CHIP_NAME}. "
+                        "Wrong --chip argument?"
+                    )
             self._post_connect()
 
     def _post_connect(self):
@@ -1002,7 +1032,6 @@ def get_security_info(self):
             "api_version": None if esp32s2 else res[10],
         }
 
-    @esp32s3_or_newer_function_only
     def get_chip_id(self):
         if self.cache["chip_id"] is None:
             res = self.check_command(
@@ -1552,23 +1581,6 @@ def soft_reset(self, stay_in_bootloader):
                 # in the stub loader
                 self.command(self.ESP_RUN_USER_CODE, wait_response=False)
 
-    def check_chip_id(self):
-        try:
-            chip_id = self.get_chip_id()
-            if chip_id != self.IMAGE_CHIP_ID:
-                print(
-                    "WARNING: Chip ID {} ({}) doesn't match expected Chip ID {}. "
-                    "esptool may not work correctly.".format(
-                        chip_id,
-                        self.UNSUPPORTED_CHIPS.get(chip_id, "Unknown"),
-                        self.IMAGE_CHIP_ID,
-                    )
-                )
-                # Try to flash anyways by disabling stub
-                self.stub_is_disabled = True
-        except NotImplementedInROMError:
-            pass
-
 
 def slip_reader(port, trace_function):
     """Generator to read SLIP packets from a serial port.

esptool/targets/esp32.py

@@ -18,7 +18,7 @@ class ESP32ROM(ESPLoader):
     IMAGE_CHIP_ID = 0
     IS_STUB = False
 
-    CHIP_DETECT_MAGIC_VALUE = [0x00F01D83]
+    MAGIC_VALUE = 0x00F01D83
 
     IROM_MAP_START = 0x400D0000
     IROM_MAP_END = 0x40400000

esptool/targets/esp32c2.py

@@ -21,9 +21,6 @@ class ESP32C2ROM(ESP32C3ROM):
     DROM_MAP_START = 0x3C000000
     DROM_MAP_END = 0x3C400000
 
-    # Magic value for ESP32C2 ECO0 , ECO1 and ECO4 respectively
-    CHIP_DETECT_MAGIC_VALUE = [0x6F51306F, 0x7C41A06F, 0x0C21E06F]
-
     EFUSE_BASE = 0x60008800
     EFUSE_BLOCK2_ADDR = EFUSE_BASE + 0x040
     MAC_EFUSE_REG = EFUSE_BASE + 0x040

esptool/targets/esp32c3.py

@@ -30,10 +30,9 @@ class ESP32C3ROM(ESP32ROM):
 
     SPI_ADDR_REG_MSB = False
 
-    BOOTLOADER_FLASH_OFFSET = 0x0
+    USES_MAGIC_VALUE = False
 
-    # Magic values for ESP32-C3 eco 1+2, eco 3, eco 6, and eco 7 respectively
-    CHIP_DETECT_MAGIC_VALUE = [0x6921506F, 0x1B31506F, 0x4881606F, 0x4361606F]
+    BOOTLOADER_FLASH_OFFSET = 0x0
 
     UART_DATE_REG_ADDR = 0x60000000 + 0x7C
 

esptool/targets/esp32c5.py

@@ -54,9 +54,6 @@ class ESP32C5ROM(ESP32C6ROM):
 
     UARTDEV_BUF_NO = 0x4085F51C  # Variable in ROM .bss which indicates the port in use
 
-    # Magic values for ESP32C5 ECO0 and ECO1, respectively
-    CHIP_DETECT_MAGIC_VALUE = [0x1101406F, 0x63E1406F]
-
     FLASH_FREQUENCY = {
         "80m": 0xF,
         "40m": 0x0,

esptool/targets/esp32c5beta3.py

@@ -19,9 +19,6 @@ class ESP32C5BETA3ROM(ESP32C6ROM):
     DROM_MAP_START = 0x41000000
     DROM_MAP_END = 0x41800000
 
-    # Magic value for ESP32C5(beta3)
-    CHIP_DETECT_MAGIC_VALUE = [0xE10D8082]
-
     FLASH_FREQUENCY = {
         "80m": 0xF,
         "40m": 0x0,

esptool/targets/esp32c6.py

@@ -21,9 +21,6 @@ class ESP32C6ROM(ESP32C3ROM):
 
     BOOTLOADER_FLASH_OFFSET = 0x0
 
-    # Magic value for ESP32C6
-    CHIP_DETECT_MAGIC_VALUE = [0x2CE0806F]
-
     SPI_REG_BASE = 0x60003000
     SPI_USR_OFFS = 0x18
     SPI_USR1_OFFS = 0x1C

esptool/targets/esp32c61.py

@@ -12,9 +12,6 @@ class ESP32C61ROM(ESP32C6ROM):
     CHIP_NAME = "ESP32-C61"
     IMAGE_CHIP_ID = 20
 
-    # Magic value for ESP32C61
-    CHIP_DETECT_MAGIC_VALUE = [0x33F0206F, 0x2421606F]
-
     UART_DATE_REG_ADDR = 0x60000000 + 0x7C
 
     EFUSE_BASE = 0x600B4800

esptool/targets/esp32c6beta.py

@@ -10,8 +10,6 @@ class ESP32C6BETAROM(ESP32C3ROM):
     CHIP_NAME = "ESP32-C6(beta)"
     IMAGE_CHIP_ID = 7
 
-    CHIP_DETECT_MAGIC_VALUE = [0x0DA1806F]
-
     UART_DATE_REG_ADDR = 0x00000500
 
     def get_chip_description(self):