esp32tool 1.3.7 → 1.4.0

package/src/esp_loader.ts

@@ -109,6 +109,29 @@ import {
   ESP32P4_PMU_0P1A_TARGET0_0,
   ESP32P4_PMU_0P1A_FORCE_TIEH_SEL_0,
   ESP32P4_PMU_DATE_REG,
+  ESP32S2_UARTDEV_BUF_NO,
+  ESP32S2_UARTDEV_BUF_NO_USB_OTG,
+  ESP32S3_UARTDEV_BUF_NO,
+  ESP32S3_UARTDEV_BUF_NO_USB_OTG,
+  ESP32S3_UARTDEV_BUF_NO_USB_JTAG_SERIAL,
+  ESP32C3_UARTDEV_BUF_NO_USB_JTAG_SERIAL,
+  ESP32C3_BUF_UART_NO_OFFSET,
+  ESP32C5_UARTDEV_BUF_NO,
+  ESP32C5_UARTDEV_BUF_NO_USB_JTAG_SERIAL,
+  ESP32C6_UARTDEV_BUF_NO,
+  ESP32C6_UARTDEV_BUF_NO_USB_JTAG_SERIAL,
+  ESP32C61_UARTDEV_BUF_NO_REV_LE2,
+  ESP32C61_UARTDEV_BUF_NO_REV_GT2,
+  ESP32C61_UARTDEV_BUF_NO_USB_JTAG_SERIAL_REV_LE2,
+  ESP32C61_UARTDEV_BUF_NO_USB_JTAG_SERIAL_REV_GT2,
+  ESP32H2_UARTDEV_BUF_NO,
+  ESP32H2_UARTDEV_BUF_NO_USB_JTAG_SERIAL,
+  ESP32H4_UARTDEV_BUF_NO,
+  ESP32H4_UARTDEV_BUF_NO_USB_JTAG_SERIAL,
+  ESP32P4_UARTDEV_BUF_NO_REV0,
+  ESP32P4_UARTDEV_BUF_NO_REV300,
+  ESP32P4_UARTDEV_BUF_NO_USB_OTG,
+  ESP32P4_UARTDEV_BUF_NO_USB_JTAG_SERIAL,
 } from "./const";
 import { getStubCode } from "./stubs";
 import { hexFormatter, sleep, slipEncode, toHex } from "./util";
@@ -536,7 +559,15 @@ export class ESPLoader extends EventTarget {
       );
     } catch (err) {
       this.logger.debug(`Could not detect USB connection type: ${err}`);
-      // Leave as undefined if detection fails
+    }
+
+    try {
+      const usbMode = await this.getUsbMode();
+      this.logger.debug(
+        `USB mode (register): ${usbMode.mode} (uartNo=${usbMode.uartNo})`,
+      );
+    } catch (err) {
+      this.logger.debug(`Could not detect USB mode: ${err}`);
     }
 
     // Read the OTP data for this chip and store into this.efuses array
@@ -952,10 +983,6 @@ export class ESPLoader extends EventTarget {
     this.logger.debug("Finished read loop");
   }
 
-  sleep(ms = 100) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-
   state_DTR = false;
   state_RTS = false;
 
@@ -986,28 +1013,46 @@ export class ESPLoader extends EventTarget {
     });
   }
 
+  private async runSignalSequence(
+    steps: Array<{ dtr?: boolean; rts?: boolean; delayMs?: number }>,
+  ): Promise<void> {
+    const webusb = (this.port as any).isWebUSB === true;
+    for (const step of steps) {
+      if (step.dtr !== undefined && step.rts !== undefined) {
+        if (webusb) {
+          await this.setDTRandRTSWebUSB(step.dtr, step.rts);
+        } else {
+          await this.setDTRandRTS(step.dtr, step.rts);
+        }
+      } else {
+        if (step.dtr !== undefined) {
+          webusb
+            ? await this.setDTRWebUSB(step.dtr)
+            : await this.setDTR(step.dtr);
+        }
+        if (step.rts !== undefined) {
+          webusb
+            ? await this.setRTSWebUSB(step.rts)
+            : await this.setRTS(step.rts);
+        }
+      }
+      if (step.delayMs) await sleep(step.delayMs);
+    }
+  }
+
   /**
    * @name hardResetUSBJTAGSerial
    * USB-JTAG/Serial reset for Web Serial (Desktop)
    */
   async hardResetUSBJTAGSerial() {
-    await this.setRTS(false);
-    await this.setDTR(false); // Idle
-    await this.sleep(100);
-
-    await this.setDTR(true); // Set IO0
-    await this.setRTS(false);
-    await this.sleep(100);
-
-    await this.setRTS(true); // Reset
-    await this.setDTR(false);
-    await this.setRTS(true);
-    await this.sleep(100);
-
-    await this.setDTR(false);
-    await this.setRTS(false); // Chip out of reset
-
-    await this.sleep(200);
+    await this.runSignalSequence([
+      { rts: false },
+      { dtr: false, delayMs: 100 },
+      { dtr: true, rts: false, delayMs: 100 },
+      { rts: true },
+      { dtr: false, rts: true, delayMs: 100 },
+      { dtr: false, rts: false, delayMs: 200 },
+    ]);
   }
 
   /**
@@ -1015,15 +1060,11 @@ export class ESPLoader extends EventTarget {
    * Classic reset for Web Serial (Desktop) DTR = IO0, RTS = EN
    */
   async hardResetClassic() {
-    await this.setDTR(false); // IO0=HIGH
-    await this.setRTS(true); // EN=LOW, chip in reset
-    await this.sleep(100);
-    await this.setDTR(true); // IO0=LOW
-    await this.setRTS(false); // EN=HIGH, chip out of reset
-    await this.sleep(50);
-    await this.setDTR(false); // IO0=HIGH, done
-
-    await this.sleep(200);
+    await this.runSignalSequence([
+      { dtr: false, rts: true, delayMs: 100 },
+      { dtr: true, rts: false, delayMs: 50 },
+      { dtr: false, delayMs: 200 },
+    ]);
   }
 
   /**
@@ -1031,27 +1072,11 @@ export class ESPLoader extends EventTarget {
    * Keeps IO0=HIGH during reset so chip boots into firmware
    */
   async hardResetToFirmware() {
-    await this.setDTR(false); // IO0=HIGH
-    await this.setRTS(true); // EN=LOW, chip in reset
-    await this.sleep(100);
-    await this.setRTS(false); // EN=HIGH, chip out of reset (IO0 stays HIGH)
-    await this.sleep(50);
-
-    await this.sleep(200);
-  }
-
-  /**
-   * Reset to firmware mode (not bootloader) for WebUSB
-   * Keeps IO0=HIGH during reset so chip boots into firmware
-   */
-  async hardResetToFirmwareWebUSB() {
-    await this.setDTRWebUSB(false); // IO0=HIGH
-    await this.setRTSWebUSB(true); // EN=LOW, chip in reset
-    await this.sleep(100);
-    await this.setRTSWebUSB(false); // EN=HIGH, chip out of reset (IO0 stays HIGH)
-    await this.sleep(50);
-
-    await this.sleep(200);
+    await this.runSignalSequence([
+      { dtr: false, rts: true, delayMs: 100 },
+      { rts: false, delayMs: 50 },
+      { delayMs: 200 },
+    ]);
   }
 
   /**
@@ -1059,16 +1084,14 @@ export class ESPLoader extends EventTarget {
    * Unix Tight reset for Web Serial (Desktop) - sets DTR and RTS simultaneously
    */
   async hardResetUnixTight() {
-    await this.setDTRandRTS(true, true);
-    await this.setDTRandRTS(false, false);
-    await this.setDTRandRTS(false, true); // IO0=HIGH & EN=LOW, chip in reset
-    await this.sleep(100);
-    await this.setDTRandRTS(true, false); // IO0=LOW & EN=HIGH, chip out of reset
-    await this.sleep(50);
-    await this.setDTRandRTS(false, false); // IO0=HIGH, done
-    await this.setDTR(false); // Needed in some environments to ensure IO0=HIGH
-
-    await this.sleep(200);
+    await this.runSignalSequence([
+      { dtr: true, rts: true },
+      { dtr: false, rts: false },
+      { dtr: false, rts: true, delayMs: 100 },
+      { dtr: true, rts: false, delayMs: 50 },
+      { dtr: false, rts: false },
+      { dtr: false, delayMs: 200 },
+    ]);
   }
 
   // ============================================================================
@@ -1103,83 +1126,17 @@ export class ESPLoader extends EventTarget {
     });
   }
 
-  /**
-   * @name hardResetUSBJTAGSerialWebUSB
-   * USB-JTAG/Serial reset for WebUSB (Android)
-   */
-  async hardResetUSBJTAGSerialWebUSB() {
-    await this.setRTSWebUSB(false);
-    await this.setDTRWebUSB(false); // Idle
-    await this.sleep(100);
-
-    await this.setDTRWebUSB(true); // Set IO0
-    await this.setRTSWebUSB(false);
-    await this.sleep(100);
-
-    await this.setRTSWebUSB(true); // Reset
-    await this.setDTRWebUSB(false);
-    await this.setRTSWebUSB(true);
-    await this.sleep(100);
-
-    await this.setDTRWebUSB(false);
-    await this.setRTSWebUSB(false); // Chip out of reset
-
-    await this.sleep(200);
-  }
-
   /**
    * @name hardResetUSBJTAGSerialInvertedDTRWebUSB
    * USB-JTAG/Serial reset with inverted DTR for WebUSB (Android)
    */
   async hardResetUSBJTAGSerialInvertedDTRWebUSB() {
-    await this.setRTSWebUSB(false);
-    await this.setDTRWebUSB(true); // Idle (DTR inverted)
-    await this.sleep(100);
-
-    await this.setDTRWebUSB(false); // Set IO0 (DTR inverted)
-    await this.setRTSWebUSB(false);
-    await this.sleep(100);
-
-    await this.setRTSWebUSB(true); // Reset
-    await this.setDTRWebUSB(true); // (DTR inverted)
-    await this.setRTSWebUSB(true);
-    await this.sleep(100);
-
-    await this.setDTRWebUSB(true); // (DTR inverted)
-    await this.setRTSWebUSB(false); // Chip out of reset
-
-    await this.sleep(200);
-  }
-
-  /**
-   * @name hardResetClassicWebUSB
-   * Classic reset for WebUSB (Android)
-   */
-  async hardResetClassicWebUSB() {
-    await this.setDTRWebUSB(false); // IO0=HIGH
-    await this.setRTSWebUSB(true); // EN=LOW, chip in reset
-    await this.sleep(100);
-    await this.setDTRWebUSB(true); // IO0=LOW
-    await this.setRTSWebUSB(false); // EN=HIGH, chip out of reset
-    await this.sleep(50);
-    await this.setDTRWebUSB(false); // IO0=HIGH, done
-    await this.sleep(200);
-  }
-
-  /**
-   * @name hardResetUnixTightWebUSB
-   * Unix Tight reset for WebUSB (Android) - sets DTR and RTS simultaneously
-   */
-  async hardResetUnixTightWebUSB() {
-    await this.setDTRandRTSWebUSB(false, false);
-    await this.setDTRandRTSWebUSB(true, true);
-    await this.setDTRandRTSWebUSB(false, true); // IO0=HIGH & EN=LOW, chip in reset
-    await this.sleep(100);
-    await this.setDTRandRTSWebUSB(true, false); // IO0=LOW & EN=HIGH, chip out of reset
-    await this.sleep(50);
-    await this.setDTRandRTSWebUSB(false, false); // IO0=HIGH, done
-    await this.setDTRWebUSB(false); // Ensure IO0=HIGH
-    await this.sleep(200);
+    await this.runSignalSequence([
+      { rts: false, dtr: true, delayMs: 100 },
+      { dtr: false, rts: false, delayMs: 100 },
+      { rts: true, dtr: true, delayMs: 100 },
+      { dtr: true, rts: false, delayMs: 200 },
+    ]);
   }
 
   /**
@@ -1188,14 +1145,11 @@ export class ESPLoader extends EventTarget {
    * Specifically for CP2102/CH340 which may need more time
    */
   async hardResetClassicLongDelayWebUSB() {
-    await this.setDTRWebUSB(false); // IO0=HIGH
-    await this.setRTSWebUSB(true); // EN=LOW, chip in reset
-    await this.sleep(500); // Extra long delay
-    await this.setDTRWebUSB(true); // IO0=LOW
-    await this.setRTSWebUSB(false); // EN=HIGH, chip out of reset
-    await this.sleep(200);
-    await this.setDTRWebUSB(false); // IO0=HIGH, done
-    await this.sleep(500); // Extra long delay
+    await this.runSignalSequence([
+      { dtr: false, rts: true, delayMs: 500 },
+      { dtr: true, rts: false, delayMs: 200 },
+      { dtr: false, delayMs: 500 },
+    ]);
   }
 
   /**
@@ -1205,12 +1159,12 @@ export class ESPLoader extends EventTarget {
   async hardResetClassicShortDelayWebUSB() {
     await this.setDTRWebUSB(false); // IO0=HIGH
     await this.setRTSWebUSB(true); // EN=LOW, chip in reset
-    await this.sleep(50);
+    await sleep(50);
     await this.setDTRWebUSB(true); // IO0=LOW
     await this.setRTSWebUSB(false); // EN=HIGH, chip out of reset
-    await this.sleep(25);
+    await sleep(25);
     await this.setDTRWebUSB(false); // IO0=HIGH, done
-    await this.sleep(100);
+    await sleep(100);
   }
 
   /**
@@ -1220,12 +1174,12 @@ export class ESPLoader extends EventTarget {
   async hardResetInvertedWebUSB() {
     await this.setDTRWebUSB(true); // IO0=HIGH (inverted)
     await this.setRTSWebUSB(false); // EN=LOW, chip in reset (inverted)
-    await this.sleep(100);
+    await sleep(100);
     await this.setDTRWebUSB(false); // IO0=LOW (inverted)
     await this.setRTSWebUSB(true); // EN=HIGH, chip out of reset (inverted)
-    await this.sleep(50);
+    await sleep(50);
     await this.setDTRWebUSB(true); // IO0=HIGH, done (inverted)
-    await this.sleep(200);
+    await sleep(200);
   }
 
   /**
@@ -1235,12 +1189,12 @@ export class ESPLoader extends EventTarget {
   async hardResetInvertedDTRWebUSB() {
     await this.setDTRWebUSB(true); // IO0=HIGH (DTR inverted)
     await this.setRTSWebUSB(true); // EN=LOW, chip in reset (RTS normal)
-    await this.sleep(100);
+    await sleep(100);
     await this.setDTRWebUSB(false); // IO0=LOW (DTR inverted)
     await this.setRTSWebUSB(false); // EN=HIGH, chip out of reset (RTS normal)
-    await this.sleep(50);
+    await sleep(50);
     await this.setDTRWebUSB(true); // IO0=HIGH, done (DTR inverted)
-    await this.sleep(200);
+    await sleep(200);
   }
 
   /**
@@ -1250,12 +1204,12 @@ export class ESPLoader extends EventTarget {
   async hardResetInvertedRTSWebUSB() {
     await this.setDTRWebUSB(false); // IO0=HIGH (DTR normal)
     await this.setRTSWebUSB(false); // EN=LOW, chip in reset (RTS inverted)
-    await this.sleep(100);
+    await sleep(100);
     await this.setDTRWebUSB(true); // IO0=LOW (DTR normal)
     await this.setRTSWebUSB(true); // EN=HIGH, chip out of reset (RTS inverted)
-    await this.sleep(50);
+    await sleep(50);
     await this.setDTRWebUSB(false); // IO0=HIGH, done (DTR normal)
-    await this.sleep(200);
+    await sleep(200);
   }
 
   /**
@@ -1312,7 +1266,7 @@ export class ESPLoader extends EventTarget {
           resetStrategies.push({
             name: "USB-JTAG/Serial (WebUSB) - ESP32-S2",
             fn: async () => {
-              return await self.hardResetUSBJTAGSerialWebUSB();
+              return await self.hardResetUSBJTAGSerial();
             },
           });
 
@@ -1328,7 +1282,7 @@ export class ESPLoader extends EventTarget {
           resetStrategies.push({
             name: "UnixTight (WebUSB) - ESP32-S2 CDC",
             fn: async () => {
-              return await self.hardResetUnixTightWebUSB();
+              return await self.hardResetUnixTight();
             },
           });
 
@@ -1336,7 +1290,7 @@ export class ESPLoader extends EventTarget {
           resetStrategies.push({
             name: "Classic (WebUSB) - ESP32-S2 CDC",
             fn: async () => {
-              return await self.hardResetClassicWebUSB();
+              return await self.hardResetClassic();
             },
           });
         } else {
@@ -1350,7 +1304,7 @@ export class ESPLoader extends EventTarget {
           resetStrategies.push({
             name: "USB-JTAG/Serial (WebUSB)",
             fn: async () => {
-              return await self.hardResetUSBJTAGSerialWebUSB();
+              return await self.hardResetUSBJTAGSerial();
             },
           });
           resetStrategies.push({
@@ -1369,13 +1323,13 @@ export class ESPLoader extends EventTarget {
           resetStrategies.push({
             name: "UnixTight (WebUSB) - CH34x",
             fn: async () => {
-              return await self.hardResetUnixTightWebUSB();
+              return await self.hardResetUnixTight();
             },
           });
           resetStrategies.push({
             name: "Classic (WebUSB) - CH34x",
             fn: async () => {
-              return await self.hardResetClassicWebUSB();
+              return await self.hardResetClassic();
             },
           });
           resetStrategies.push({
@@ -1403,14 +1357,14 @@ export class ESPLoader extends EventTarget {
           resetStrategies.push({
             name: "UnixTight (WebUSB) - CP2102",
             fn: async () => {
-              return await self.hardResetUnixTightWebUSB();
+              return await self.hardResetUnixTight();
             },
           });
 
           resetStrategies.push({
             name: "Classic (WebUSB) - CP2102",
             fn: async () => {
-              return await self.hardResetClassicWebUSB();
+              return await self.hardResetClassic();
             },
           });
 
@@ -1439,13 +1393,13 @@ export class ESPLoader extends EventTarget {
           resetStrategies.push({
             name: "UnixTight (WebUSB)",
             fn: async () => {
-              return await self.hardResetUnixTightWebUSB();
+              return await self.hardResetUnixTight();
             },
           });
           resetStrategies.push({
             name: "Classic (WebUSB)",
             fn: async function () {
-              return await self.hardResetClassicWebUSB();
+              return await self.hardResetClassic();
             },
           });
           resetStrategies.push({
@@ -1476,7 +1430,7 @@ export class ESPLoader extends EventTarget {
           resetStrategies.push({
             name: "Classic (WebUSB)",
             fn: async function () {
-              return await self.hardResetClassicWebUSB();
+              return await self.hardResetClassic();
             },
           });
         }
@@ -1485,7 +1439,7 @@ export class ESPLoader extends EventTarget {
         resetStrategies.push({
           name: "UnixTight (WebUSB)",
           fn: async function () {
-            return await self.hardResetUnixTightWebUSB();
+            return await self.hardResetUnixTight();
           },
         });
 
@@ -1510,7 +1464,7 @@ export class ESPLoader extends EventTarget {
           resetStrategies.push({
             name: "USB-JTAG/Serial fallback (WebUSB)",
             fn: async function () {
-              return await self.hardResetUSBJTAGSerialWebUSB();
+              return await self.hardResetUSBJTAGSerial();
             },
           });
         }
@@ -1708,34 +1662,152 @@ export class ESPLoader extends EventTarget {
     await this.writeRegister(WDTWPROTECT_REG, 0, undefined, 0);
 
     // Wait for reset to take effect
-    await this.sleep(500);
+    await sleep(500);
   }
 
   /**
-   * Helper: USB-based WDT reset
-   * Returns true if WDT reset was performed, false otherwise
+   * Reset device from bootloader mode to firmware mode
+   * Automatically selects the correct reset strategy based on USB connection type
+   * @param clearForceDownloadFlag - If true, clears the force download boot flag (USB-OTG only)
+   * @returns true if port will change (USB-OTG), false otherwise
    */
-  private async tryUsbWdtReset(chipName: string): Promise<boolean> {
-    const isUsingUsbOtg = await this.detectUsbConnectionType();
+  public async resetToFirmwareMode(
+    clearForceDownloadFlag = true,
+  ): Promise<boolean> {
+    this.logger.debug("Resetting from bootloader to firmware mode...");
 
-    if (isUsingUsbOtg) {
-      // Use WDT reset for USB-OTG devices
-      await this.rtcWdtResetChipSpecific();
-      this.logger.debug(
-        `${chipName}: RTC WDT reset (USB-JTAG/Serial or USB-OTG detected)`,
-      );
-      return true;
-    } else {
-      // Use classic reset for non-USB devices
-      if (this.isWebUSB()) {
-        await this.hardResetClassicWebUSB();
-        this.logger.debug("Classic reset (WebUSB/Android).");
+    try {
+      // Detect USB connection type
+      const isUsbJtagOrOtg = await this.detectUsbConnectionType();
+
+      if (isUsbJtagOrOtg) {
+        // USB-JTAG/OTG devices need special handling
+        this.logger.debug("USB-JTAG/OTG detected - checking WDT reset support");
+
+        // Get detailed USB mode information
+        let usbMode: {
+          mode: "uart" | "usb-jtag-serial" | "usb-otg";
+          uartNo: number;
+        };
+        try {
+          usbMode = await this.getUsbMode();
+          this.logger.debug(
+            `USB mode: ${usbMode.mode} (uartNo=${usbMode.uartNo})`,
+          );
+        } catch (err) {
+          this.logger.debug(`Could not get USB mode: ${err}`);
+          // Fall back to generic USB-JTAG/OTG handling
+          usbMode = { mode: "usb-jtag-serial", uartNo: 0 };
+        }
+
+        // Check if chip supports WDT reset
+        // WDT reset is not needed for ESP32-C3
+        // WDT reset is supported by: ESP32-S2, ESP32-S3, ESP32-P4
+        // WDT reset is NOT supported by: ESP32-C5, ESP32-C6, ESP32-C61, ESP32-H2
+        const supportsWdtReset =
+          this.chipFamily === CHIP_FAMILY_ESP32S2 ||
+          this.chipFamily === CHIP_FAMILY_ESP32S3 ||
+          this.chipFamily === CHIP_FAMILY_ESP32P4;
+
+        if (!supportsWdtReset) {
+          this.logger.debug(
+            `${this.chipName} does not support WDT reset - using classic reset instead`,
+          );
+
+          // Use classic reset for chips without WDT support
+          await this.hardResetToFirmware();
+          this.logger.debug("Classic reset to firmware complete");
+          return false; // Port stays open
+        }
+
+        // WDT reset is supported - proceed with WDT reset logic
+        this.logger.debug(
+          `${this.chipName} supports WDT reset - using WDT reset strategy`,
+        );
+
+        // CRITICAL: WDT register writes require ROM (not stub) and baudrate 115200
+
+        // If on stub, need to return to ROM first
+        if (this.IS_STUB) {
+          this.logger.debug("On stub - returning to ROM before WDT reset");
+
+          // Change baudrate back to ROM baudrate if needed
+          if (this.currentBaudRate !== ESP_ROM_BAUD) {
+            this.logger.debug(
+              `Changing baudrate from ${this.currentBaudRate} to ${ESP_ROM_BAUD}`,
+            );
+            await this.reconfigurePort(ESP_ROM_BAUD);
+            this.currentBaudRate = ESP_ROM_BAUD;
+            this.logger.debug("Baudrate changed to 115200");
+          }
+
+          // CRITICAL: Temporarily clear console mode flag so hardReset(true) works
+          const wasInConsoleMode = this._consoleMode;
+          this._consoleMode = false;
+
+          // Reset to bootloader (ROM)
+          await this.hardReset(true);
+          await sleep(200);
+
+          // Restore console mode flag
+          this._consoleMode = wasInConsoleMode;
+
+          // Sync with ROM
+          await this.sync();
+          this.IS_STUB = false;
+          this.logger.debug("Now on ROM");
+        } else {
+          // Even if not on stub, ensure baudrate is 115200 for WDT register writes
+          if (this.currentBaudRate !== ESP_ROM_BAUD) {
+            this.logger.debug(
+              `Not on stub, but baudrate is ${this.currentBaudRate} - changing to ${ESP_ROM_BAUD} for WDT reset`,
+            );
+            await this.reconfigurePort(ESP_ROM_BAUD);
+            this.currentBaudRate = ESP_ROM_BAUD;
+            this.logger.debug("Baudrate changed to 115200");
+          }
+        }
+
+        // Clear force download boot flag if requested (USB-OTG only)
+        if (clearForceDownloadFlag && usbMode.mode === "usb-otg") {
+          const flagCleared = await this._clearForceDownloadBootIfNeeded();
+          if (flagCleared) {
+            this.logger.debug("Force download boot flag cleared");
+          }
+        }
+
+        // Perform WDT reset to boot into firmware
+        await this.rtcWdtResetChipSpecific();
+        this.logger.debug("WDT reset performed - device will boot to firmware");
+
+        // Check if port will change after WDT reset
+        // USB-OTG (ESP32-S2/P4): Port always changes
+        // USB-JTAG/Serial (ESP32-S3/C3/C5/C6/C61/H2/P4): Port may change depending on platform
+        const portWillChange =
+          usbMode.mode === "usb-otg" || usbMode.mode === "usb-jtag-serial";
+
+        if (portWillChange) {
+          this.logger.debug(
+            `Port will change after WDT reset (${usbMode.mode}) - port reselection needed`,
+          );
+          return true;
+        }
+
+        return false;
       } else {
-        await this.hardResetClassic();
-        this.logger.debug("Classic reset.");
+        // External serial chip - use classic reset to firmware
+        this.logger.debug(
+          "External serial chip detected - using classic reset",
+        );
+
+        await this.hardResetToFirmware();
+        this.logger.debug("Classic reset to firmware complete");
+        return false;
       }
+    } catch (err) {
+      this.logger.error(`Failed to reset to firmware mode: ${err}`);
+      throw err;
     }
-    return false;
   }
 
   async hardReset(bootloader = false) {
@@ -1749,68 +1821,83 @@ export class ESPLoader extends EventTarget {
       }
       // Simple hardware reset to restart firmware (IO0=HIGH)
       this.logger.debug("Performing hardware reset (console mode)...");
-      if (this.isWebUSB()) {
-        await this.hardResetToFirmwareWebUSB();
-      } else {
-        await this.hardResetToFirmware();
-      }
+      await this.resetInConsoleMode();
       this.logger.debug("Hardware reset complete");
       return;
     }
 
     if (bootloader) {
-      // enter flash mode
+      // Enter bootloader/flash mode
       if (this.port.getInfo().usbProductId === USB_JTAG_SERIAL_PID) {
         await this.hardResetUSBJTAGSerial();
-        this.logger.debug("USB-JTAG/Serial reset.");
+        this.logger.debug("USB-JTAG/Serial reset to bootloader.");
       } else {
-        // Use different reset strategy for WebUSB (Android) vs Web Serial (Desktop)
-        if (this.isWebUSB()) {
-          await this.hardResetClassicWebUSB();
-          this.logger.debug("Classic reset (WebUSB/Android).");
-        } else {
-          await this.hardResetClassic();
-          this.logger.debug("Classic reset.");
-        }
+        await this.hardResetClassic();
+        this.logger.debug("Classic reset to bootloader.");
       }
     } else {
-      // just reset (no bootloader mode)
-      // For ESP32-S2/S3/P4 with USB-OTG or USB-JTAG/Serial, check if watchdog reset is needed
-      this.logger.debug("*** Performing WDT reset strategy ***");
-      if (this.chipFamily === CHIP_FAMILY_ESP32S2) {
-        const wdtResetUsed = await this.tryUsbWdtReset("ESP32-S2");
-        if (wdtResetUsed) return;
-        //      } else if (this.chipFamily === CHIP_FAMILY_ESP32S3) {
-        //        const wdtResetUsed = await this.tryUsbWdtReset("ESP32-S3");
-        //        if (wdtResetUsed) return;
-      } else if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
-        const wdtResetUsed = await this.tryUsbWdtReset("ESP32-P4");
-        if (wdtResetUsed) return;
-        //      } else if (this.chipFamily === CHIP_FAMILY_ESP32C3) {
-        //        const wdtResetUsed = await this.tryUsbWdtReset("ESP32-C3");
-        //        if (wdtResetUsed) return;
-      } else if (this.chipFamily === CHIP_FAMILY_ESP32C5) {
-        const wdtResetUsed = await this.tryUsbWdtReset("ESP32-C5");
-        if (wdtResetUsed) return;
-      } else if (this.chipFamily === CHIP_FAMILY_ESP32C6) {
-        const wdtResetUsed = await this.tryUsbWdtReset("ESP32-C6");
-        if (wdtResetUsed) return;
-      }
+      // Reset to firmware mode (exit bootloader)
+      // Use intelligent reset strategy based on USB connection type
+      this.logger.debug("Resetting to firmware mode...");
+
+      // Detect USB connection type to choose correct reset method
+      const isUsbJtagOrOtg = await this.detectUsbConnectionType();
+
+      if (isUsbJtagOrOtg) {
+        // USB-JTAG/OTG devices: Use WDT reset
+        this.logger.debug("USB-JTAG/OTG detected - using WDT reset");
+
+        // Get USB mode details
+        let usbMode: {
+          mode: "uart" | "usb-jtag-serial" | "usb-otg";
+          uartNo: number;
+        };
+        try {
+          usbMode = await this.getUsbMode();
+          this.logger.debug(
+            `USB mode: ${usbMode.mode} (uartNo=${usbMode.uartNo})`,
+          );
+        } catch (err) {
+          this.logger.debug(`Could not get USB mode: ${err}`);
+          usbMode = { mode: "usb-jtag-serial", uartNo: 0 };
+        }
 
-      // Standard reset for all other cases
-      if (this.isWebUSB()) {
-        // WebUSB: Use longer delays for better compatibility
-        await this.setRTSWebUSB(true); // EN->LOW
-        await this.sleep(200);
-        await this.setRTSWebUSB(false);
-        await this.sleep(200);
-        this.logger.debug("Hard reset (WebUSB).");
+        // Clear force download flag for USB-OTG devices
+        if (usbMode.mode === "usb-otg") {
+          try {
+            const flagCleared = await this._clearForceDownloadBootIfNeeded();
+            if (flagCleared) {
+              this.logger.debug("Force download boot flag cleared");
+            }
+          } catch (err) {
+            this.logger.debug(`Could not clear force download flag: ${err}`);
+          }
+        }
+
+        // Perform WDT reset
+        await this.rtcWdtResetChipSpecific();
+        this.logger.debug(`${this.chipName}: WDT reset to firmware complete`);
+        return;
       } else {
-        // Web Serial: Standard reset
-        await this.setRTS(true); // EN->LOW
-        await this.sleep(100);
-        await this.setRTS(false);
-        this.logger.debug("Hard reset.");
+        // External serial chip: Use classic reset
+        this.logger.debug(
+          "External serial chip detected - using classic reset",
+        );
+
+        if (this.isWebUSB()) {
+          // WebUSB: Use longer delays for better compatibility
+          await this.setRTSWebUSB(true); // EN->LOW
+          await sleep(200);
+          await this.setRTSWebUSB(false);
+          await sleep(200);
+          this.logger.debug("Hard reset to firmware (WebUSB).");
+        } else {
+          // Web Serial: Standard reset
+          await this.setRTS(true); // EN->LOW
+          await sleep(100);
+          await this.setRTS(false);
+          this.logger.debug("Hard reset to firmware.");
+        }
       }
     }
     await new Promise((resolve) => setTimeout(resolve, 1000));
@@ -3284,26 +3371,27 @@ export class ESPLoader extends EventTarget {
       this._writer = undefined;
     }
 
-    // Cancel and release reader
+    // Cancel reader - let readLoop's finally block handle releaseLock()
     if (this._reader) {
-      const reader = this._reader;
       try {
         // Suppress disconnect event during console mode switching
         this._suppressDisconnect = true;
-        await reader.cancel();
-        this.logger.debug("Reader cancelled");
+
+        // Cancel will cause readLoop to exit and call releaseLock() in its finally block
+        await this._reader.cancel();
+        this.logger.debug("Reader cancelled - waiting for readLoop to finish");
+
+        // CRITICAL: Wait a bit for readLoop's finally block to complete
+        // The finally block needs time to call releaseLock() and set _reader = undefined
+        // This is much faster than waiting for browser to unlock (just waiting for JS execution)
+        await sleep(50);
+
+        this.logger.debug("ReadLoop cleanup should be complete");
       } catch (err) {
         this.logger.debug(`Reader cancel error: ${err}`);
-      } finally {
-        try {
-          reader.releaseLock();
-        } catch (err) {
-          this.logger.debug(`Reader release error: ${err}`);
-        }
-      }
-      if (this._reader === reader) {
-        this._reader = undefined;
       }
+      // Don't call releaseLock() or set _reader to undefined here
+      // Let readLoop's finally block handle it to avoid race conditions
     }
   }
 
@@ -3352,6 +3440,155 @@ export class ESPLoader extends EventTarget {
     return isUsbJtag;
   }
 
+  public async getUsbMode(): Promise<{
+    mode: "uart" | "usb-jtag-serial" | "usb-otg";
+    uartNo: number;
+  }> {
+    const family = this._parent ? this._parent.chipFamily : this.chipFamily;
+    const revision = this._parent
+      ? (this._parent.chipRevision ?? 0)
+      : (this.chipRevision ?? 0);
+
+    let bufNoAddr: number | null = null;
+    let jtagSerialVal: number | null = null;
+    let otgVal: number | null = null;
+
+    switch (family) {
+      case CHIP_FAMILY_ESP32S2:
+        bufNoAddr = ESP32S2_UARTDEV_BUF_NO;
+        otgVal = ESP32S2_UARTDEV_BUF_NO_USB_OTG;
+        break;
+      case CHIP_FAMILY_ESP32S3:
+        bufNoAddr = ESP32S3_UARTDEV_BUF_NO;
+        jtagSerialVal = ESP32S3_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
+        otgVal = ESP32S3_UARTDEV_BUF_NO_USB_OTG;
+        break;
+      case CHIP_FAMILY_ESP32C3: {
+        const bssAddr = revision < 101 ? 0x3fcdf064 : 0x3fcdf060;
+        bufNoAddr = bssAddr + ESP32C3_BUF_UART_NO_OFFSET;
+        jtagSerialVal = ESP32C3_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
+        break;
+      }
+      case CHIP_FAMILY_ESP32C5:
+        bufNoAddr = ESP32C5_UARTDEV_BUF_NO;
+        jtagSerialVal = ESP32C5_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
+        break;
+      case CHIP_FAMILY_ESP32C6:
+        bufNoAddr = ESP32C6_UARTDEV_BUF_NO;
+        jtagSerialVal = ESP32C6_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
+        break;
+      case CHIP_FAMILY_ESP32C61:
+        bufNoAddr =
+          revision <= 200
+            ? ESP32C61_UARTDEV_BUF_NO_REV_LE2
+            : ESP32C61_UARTDEV_BUF_NO_REV_GT2;
+        jtagSerialVal =
+          revision <= 200
+            ? ESP32C61_UARTDEV_BUF_NO_USB_JTAG_SERIAL_REV_LE2
+            : ESP32C61_UARTDEV_BUF_NO_USB_JTAG_SERIAL_REV_GT2;
+        break;
+      case CHIP_FAMILY_ESP32H2:
+        bufNoAddr = ESP32H2_UARTDEV_BUF_NO;
+        jtagSerialVal = ESP32H2_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
+        break;
+      case CHIP_FAMILY_ESP32H4:
+        bufNoAddr = ESP32H4_UARTDEV_BUF_NO;
+        jtagSerialVal = ESP32H4_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
+        break;
+      case CHIP_FAMILY_ESP32P4:
+        bufNoAddr =
+          revision < 300
+            ? ESP32P4_UARTDEV_BUF_NO_REV0
+            : ESP32P4_UARTDEV_BUF_NO_REV300;
+        jtagSerialVal = ESP32P4_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
+        otgVal = ESP32P4_UARTDEV_BUF_NO_USB_OTG;
+        break;
+    }
+
+    if (bufNoAddr === null) {
+      return { mode: "uart", uartNo: 0 };
+    }
+
+    const uartNo = (await this.readRegister(bufNoAddr)) & 0xff;
+
+    if (otgVal !== null && uartNo === otgVal) {
+      this.logger.debug(`USB mode: USB-OTG (uartNo=${uartNo})`);
+      return { mode: "usb-otg", uartNo };
+    }
+    if (jtagSerialVal !== null && uartNo === jtagSerialVal) {
+      this.logger.debug(`USB mode: USB-JTAG/Serial (uartNo=${uartNo})`);
+      return { mode: "usb-jtag-serial", uartNo };
+    }
+
+    this.logger.debug(`USB mode: UART (uartNo=${uartNo})`);
+    return { mode: "uart", uartNo };
+  }
+
+  /**
+   * Check if the current chip supports USB-JTAG or USB-OTG
+   * @returns true if chip has native USB support (JTAG or OTG)
+   */
+  public supportsNativeUsb(): boolean {
+    const family = this._parent ? this._parent.chipFamily : this.chipFamily;
+
+    // Chips with USB-JTAG/Serial or USB-OTG support
+    const usbChips = [
+      CHIP_FAMILY_ESP32S2, // USB-OTG
+      CHIP_FAMILY_ESP32S3, // USB-OTG + USB-JTAG/Serial
+      CHIP_FAMILY_ESP32C3, // USB-JTAG/Serial
+      CHIP_FAMILY_ESP32C5, // USB-JTAG/Serial
+      CHIP_FAMILY_ESP32C6, // USB-JTAG/Serial
+      CHIP_FAMILY_ESP32C61, // USB-JTAG/Serial
+      CHIP_FAMILY_ESP32H2, // USB-JTAG/Serial
+      CHIP_FAMILY_ESP32H4, // USB-JTAG/Serial
+      CHIP_FAMILY_ESP32P4, // USB-OTG + USB-JTAG/Serial
+    ];
+
+    return usbChips.includes(family);
+  }
+
+  /**
+   * @name _ensureStreamsReady
+   * After a hardware reset, ensure port streams are available.
+   * On WebUSB, recreates streams since they break after reset.
+   * On Web Serial, waits for streams to become available.
+   */
+  private async _ensureStreamsReady(): Promise<void> {
+    if (this.isWebUSB()) {
+      try {
+        await (this.port as any).recreateStreams();
+        this.logger.debug("WebUSB streams recreated");
+
+        let retries = 30;
+        while (retries > 0 && !this.port.readable) {
+          await sleep(100);
+          retries--;
+        }
+        if (!this.port.readable) {
+          throw new Error(
+            "Readable stream not available after recreating streams",
+          );
+        }
+        this.logger.debug("WebUSB streams are ready");
+      } catch (err) {
+        this.logger.error(`Failed to recreate WebUSB streams: ${err}`);
+        this._consoleMode = false;
+        throw err;
+      }
+    } else {
+      let retries = 20;
+      while (retries > 0 && !this.port.readable) {
+        await sleep(100);
+        retries--;
+      }
+      if (!this.port.readable) {
+        this._consoleMode = false;
+        throw new Error("Readable stream not available after reset");
+      }
+      this.logger.debug("Port streams are ready");
+    }
+  }
+
   /**
    * @name enterConsoleMode
    * Prepare device for console mode by resetting to firmware
@@ -3384,8 +3621,6 @@ export class ESPLoader extends EventTarget {
           `Cannot enter console mode: USB connection type unknown and detection failed: ${err}`,
         );
       }
-      // Set console mode flag
-      this._consoleMode = false;
 
       this.logger.debug(
         `USB detection failed, using cached value: ${this.isUsbJtagOrOtg}`,
@@ -3393,56 +3628,40 @@ export class ESPLoader extends EventTarget {
       isUsbJtag = this.isUsbJtagOrOtg;
     }
 
-    // Release reader/writer so console can create new ones
-    // This is needed for Desktop (Web Serial) to unlock streams
+    // Set console mode flag BEFORE any operations
+    this._consoleMode = true;
+
     if (isUsbJtag) {
-      // USB-JTAG/OTG devices: Use watchdog reset which closes port
+      // USB-JTAG/OTG devices: Use reset which may close port
       const wasReset = await this._resetToFirmwareIfNeeded();
-      return wasReset; // true = port closed, caller must reopen
+      if (wasReset) {
+        return true; // port closed, caller must reopen
+      }
+
+      // Port stayed open (e.g. C3/C5/C6/H2 classic reset)
+      await this._ensureStreamsReady();
+      return false;
     } else {
       // External serial chip devices: Release locks and do simple reset
       try {
         await this.releaseReaderWriter();
-        await this.sleep(100);
+        await sleep(100);
       } catch (err) {
         this.logger.debug(`Failed to release locks: ${err}`);
       }
 
-      // Hardware reset to firmware mode (IO0=HIGH)
       try {
-        await this.hardReset(false);
-        this.logger.log("Device reset to firmware mode");
+        await this.hardResetToFirmware();
+        this.logger.debug("Device reset to firmware mode");
       } catch (err) {
         this.logger.debug(`Could not reset device: ${err}`);
       }
 
-      // For WebUSB (Android), recreate streams after hardware reset
-      if (this.isWebUSB()) {
-        try {
-          // Use the public recreateStreams() method to safely recreate streams
-          // without closing the port (important after hardware reset)
-          await (this.port as any).recreateStreams();
-          this.logger.debug("WebUSB streams recreated for console mode");
-        } catch (err) {
-          // Set console mode flag
-          this._consoleMode = false;
-          this.logger.debug(`Failed to recreate WebUSB streams: ${err}`);
-        }
-      }
-
-      // Set console mode flag
-      this._consoleMode = true;
-
-      return false; // Port stays open
+      await this._ensureStreamsReady();
+      return false;
     }
   }
 
-  /**
-   * @name _resetToFirmwareIfNeeded
-   * Reset device from bootloader to firmware when switching to console mode
-   * Detects USB-JTAG/Serial and USB-OTG devices and performs appropriate reset
-   * @returns true if reconnect was performed, false otherwise
-   */
   /**
    * @name _clearForceDownloadBootIfNeeded
    * Read and clear the force download boot flag if it is set
@@ -3503,7 +3722,15 @@ export class ESPLoader extends EventTarget {
     }
   }
 
+  /**
+   * @name _resetToFirmwareIfNeeded
+   * Reset device from bootloader to firmware when switching to console mode
+   * Detects USB-JTAG/Serial and USB-OTG devices and performs appropriate reset
+   * @returns true if reconnect was performed, false otherwise
+   */
   private async _resetToFirmwareIfNeeded(): Promise<boolean> {
+    // Detect if we need WDT reset (USB-JTAG/OTG) or classic reset
+    const isUsbJtagOrOtg = await this.detectUsbConnectionType();
     try {
       // Check if port is open - if not, assume device is already in firmware mode
       if (!this.port.writable || !this.port.readable) {
@@ -3513,114 +3740,65 @@ export class ESPLoader extends EventTarget {
         return false;
       }
 
-      const isUsingUsbOtg = await this.detectUsbConnectionType();
-
-      if (isUsingUsbOtg) {
-        // For USB-OTG devices, we need to check if force download flag is set
-        // Only if it's set, we need WDT reset (which causes port change)
-        // If it's clear, we can use normal reset (no port change)
-
-        if (this.IS_STUB) {
-          this.logger.debug("On stub - need to get back to ROM to check flag");
-
-          // If we're running at higher baudrate, we need to change back to ROM baudrate
-          if (this.currentBaudRate !== ESP_ROM_BAUD) {
-            this.logger.debug(
-              `Changing baudrate from ${this.currentBaudRate} to ${ESP_ROM_BAUD} for ROM`,
-            );
-            try {
-              await this.reconfigurePort(ESP_ROM_BAUD);
-              this.currentBaudRate = ESP_ROM_BAUD;
-            } catch (err) {
-              this.logger.debug(`Baudrate change failed: ${err}`);
-              // Continue anyway
-            }
-          }
-
-          this.logger.debug("Resetting to bootloader (ROM)...");
-
-          // Reset to bootloader - this will clear the stub from RAM
-          try {
-            await this.hardReset(true);
-
-            // Wait for reset to complete
-            await sleep(200);
-
-            // Sync with ROM
-            await this.sync();
-
-            this.logger.debug("Now on ROM after reset");
-
-            // Mark that we're no longer on stub
-            this.IS_STUB = false;
-          } catch (resetErr) {
-            this.logger.debug(`Reset to ROM failed: ${resetErr}`);
-            // If reset fails, we might already be in firmware mode
-            // In this case, we don't need to do anything - just use normal reset
-            this.logger.debug("Assuming device is already in firmware mode");
-
-            // Release reader/writer before returning
-            await this.releaseReaderWriter();
-            return false; // No port change needed
-          }
-        } else {
-          this.logger.debug("Already on ROM - checking force download flag");
-        }
-
-        // Now check if force download flag is set and clear it if needed
-        const flagWasCleared = await this._clearForceDownloadBootIfNeeded();
-
-        if (flagWasCleared) {
-          this.logger.debug(
-            "Force download flag was cleared - device will boot to firmware after reset",
-          );
-        } else {
-          this.logger.debug(
-            "Force download flag already clear - device will boot to firmware after reset",
-          );
-        }
-
-        // Perform WDT reset BEFORE releasing reader/writer (needs communication)
-        // After WDT reset, the device will reboot into firmware mode
-        await this.hardReset(false);
-
-        // For USB-OTG devices (ESP32-S2, ESP32-P4), the port will change after WDT reset
-        const portWillChange =
-          (this.chipFamily === CHIP_FAMILY_ESP32S2 && isUsingUsbOtg) ||
-          (this.chipFamily === CHIP_FAMILY_ESP32P4 && isUsingUsbOtg);
+      if (isUsbJtagOrOtg) {
+        // USB-JTAG/OTG: DON'T release reader/writer before WDT reset
+        // The WDT reset needs active communication to send register write commands
+        // The port will close automatically after the WDT reset anyway
+        this.logger.debug(
+          "USB-JTAG/OTG: Keeping reader/writer active for WDT reset",
+        );
+      } else {
+        // External serial chip: Release reader/writer before classic reset
+        await this.releaseReaderWriter();
+        this.logger.debug(
+          "External serial: Reader/writer released before reset",
+        );
+      }
 
-        if (portWillChange) {
-          // Port will change - release reader/writer and let the port become invalid
-          await this.releaseReaderWriter();
+      // Use the new resetToFirmwareMode method which handles all the logic
+      const portWillChange = await this.resetToFirmwareMode(true);
 
-          this.logger.debug(
-            `${this.chipName} USB-OTG: Port will change after WDT reset`,
-          );
+      if (portWillChange) {
+        this.logger.debug(
+          `${this.chipName}: Port will change after WDT reset - user must reselect port`,
+        );
 
-          // Dispatch event to signal port change
-          this.dispatchEvent(
-            new CustomEvent("usb-otg-port-change", {
-              detail: {
-                chipName: this.chipName,
-                message: `${this.chipName} USB port changed after reset. Please select the new port.`,
-                reason: "wdt-reset-to-firmware",
-              },
-            }),
-          );
+        // Dispatch event to signal port change
+        this.dispatchEvent(
+          new CustomEvent("usb-otg-port-change", {
+            detail: {
+              chipName: this.chipName,
+              message: `${this.chipName} USB port changed after reset. Please select the new port.`,
+              reason: "wdt-reset-to-firmware",
+            },
+          }),
+        );
 
-          // Return true to indicate port selection is needed
-          return true;
-        } else {
-          // Port stays the same - release reader/writer so console can use the stream
+        return true;
+      } else {
+        // Port stays the same - release reader/writer now if not already done
+        if (isUsbJtagOrOtg) {
           await this.releaseReaderWriter();
-          return false;
+          this.logger.debug("Reader/writer released after reset");
         }
+        return false;
       }
     } catch (err) {
-      this.logger.debug(`Could not reset device to firmware mode: ${err}`);
-      // Continue anyway - console mode might still work
+      this.logger.error(`Reset to firmware mode failed: ${err}`);
+
+      // For USB-JTAG/OTG, the port is likely dead after a failed reset
+      // For external serial, the port is usually still fine
+      if (isUsbJtagOrOtg) {
+        this.logger.debug(
+          "Forcing port reselection due to USB-JTAG/OTG reset failure",
+        );
+        return true;
+      }
+      this.logger.debug(
+        "External serial reset failed, but port should still be usable",
+      );
+      return false;
     }
-    return false;
   }
 
   /**
@@ -3921,11 +4099,7 @@ export class ESPLoader extends EventTarget {
       // Perform hardware reset to bootloader (GPIO0=LOW)
       // This will cause the port to change from CDC (firmware) to JTAG (bootloader)
       try {
-        if (this.isWebUSB()) {
-          await this.hardResetClassicWebUSB();
-        } else {
-          await this.hardResetClassic();
-        }
+        await this.hardResetClassic();
         this.logger.debug("Reset to bootloader initiated");
       } catch (err) {
         this.logger.debug(`Reset error: ${err}`);
@@ -3992,23 +4166,19 @@ export class ESPLoader extends EventTarget {
 
     if (!this.isConsoleResetSupported()) {
       this.logger.debug(
-        "Console reset not supported for ESP32-S2 USB-JTAG/CDC",
+        "Simple Console reset not supported for ESP32-S2 USB-JTAG/CDC - using exitConsoleMode to enter bootloader",
+      );
+      await this.exitConsoleMode();
+      this.logger.debug(
+        "S2 now in bootloader mode - caller must do syncAndWdtReset on new port, then reconnect console",
       );
-      return; // Do nothing
+      return;
     }
 
     // For other devices: Use standard firmware reset
-    const isWebUSB = (this.port as any).isWebUSB === true;
-
     try {
       this.logger.debug("Resetting device in console mode");
-
-      if (isWebUSB) {
-        await this.hardResetToFirmwareWebUSB();
-      } else {
-        await this.hardResetToFirmware();
-      }
-
+      await this.hardResetToFirmware();
       this.logger.debug("Device reset complete");
     } catch (err) {
       this.logger.error(`Reset failed: ${err}`);
@@ -4016,6 +4186,47 @@ export class ESPLoader extends EventTarget {
     }
   }
 
+  /**
+   * @name syncAndWdtReset
+   * Open a new bootloader port, sync with ROM (no stub, no reset strategies), and fire WDT reset.
+   * This is used for ESP32-S2 USB-OTG devices which require WDT reset to switch modes.
+   * After WDT reset the port will re-enumerate again.
+   * The user must select the new port after this method is called.
+   * @param newPort - The bootloader port selected by the user
+   */
+  async syncAndWdtReset(newPort: SerialPort): Promise<void> {
+    if (this._parent) {
+      await this._parent.syncAndWdtReset(newPort);
+      return;
+    }
+
+    this.port = newPort;
+    this.connected = false;
+    this.IS_STUB = false;
+    this.__inputBuffer = [];
+    this.__inputBufferReadIndex = 0;
+    this.__totalBytesRead = 0;
+
+    this.logger.debug("Opening bootloader port at 115200...");
+    await this.port.open({ baudRate: ESP_ROM_BAUD });
+    this.connected = true;
+    this.currentBaudRate = ESP_ROM_BAUD;
+
+    // Start read loop
+    this.readLoop();
+    await sleep(100);
+
+    // Sync with ROM only - no reset strategies, device is already in bootloader
+    this.logger.debug("Syncing with bootloader ROM...");
+    await this.sync();
+    this.logger.debug("Bootloader sync OK, no stub");
+
+    // Fire WDT reset → device boots into firmware
+    this.logger.debug("Firing WDT reset...");
+    await this.rtcWdtResetChipSpecific();
+    this.logger.debug("WDT reset fired - device will boot to firmware");
+  }
+
   /**
    * @name drainInputBuffer
    * Actively drain the input buffer by reading data for a specified time.