esp32tool 1.3.2 → 1.3.4

package/src/esp_loader.ts

@@ -64,25 +64,14 @@ import {
   ESP32S2_RTC_CNTL_WDTCONFIG0_REG,
   ESP32S2_RTC_CNTL_WDTCONFIG1_REG,
   ESP32S2_RTC_CNTL_WDT_WKEY,
-  ESP32S2_GPIO_STRAP_REG,
-  ESP32S2_GPIO_STRAP_SPI_BOOT_MASK,
   ESP32S2_RTC_CNTL_OPTION1_REG,
   ESP32S2_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK,
   ESP32S3_RTC_CNTL_WDTWPROTECT_REG,
   ESP32S3_RTC_CNTL_WDTCONFIG0_REG,
   ESP32S3_RTC_CNTL_WDTCONFIG1_REG,
   ESP32S3_RTC_CNTL_WDT_WKEY,
-  ESP32S3_GPIO_STRAP_REG,
-  ESP32S3_GPIO_STRAP_SPI_BOOT_MASK,
   ESP32S3_RTC_CNTL_OPTION1_REG,
   ESP32S3_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK,
-  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,
   ESP32C3_EFUSE_RD_MAC_SPI_SYS_3_REG,
   ESP32C3_EFUSE_RD_MAC_SPI_SYS_5_REG,
   ESP32C3_RTC_CNTL_WDTWPROTECT_REG,
@@ -93,22 +82,12 @@ import {
   ESP32C5_C6_RTC_CNTL_WDTCONFIG0_REG,
   ESP32C5_C6_RTC_CNTL_WDTCONFIG1_REG,
   ESP32C5_C6_RTC_CNTL_WDT_WKEY,
-  ESP32C5_UARTDEV_BUF_NO,
-  ESP32C5_UARTDEV_BUF_NO_USB_JTAG_SERIAL,
-  ESP32C6_UARTDEV_BUF_NO,
-  ESP32C6_UARTDEV_BUF_NO_USB_JTAG_SERIAL,
   ESP32P4_RTC_CNTL_WDTWPROTECT_REG,
   ESP32P4_RTC_CNTL_WDTCONFIG0_REG,
   ESP32P4_RTC_CNTL_WDTCONFIG1_REG,
   ESP32P4_RTC_CNTL_WDT_WKEY,
-  ESP32P4_UARTDEV_BUF_NO_REV0,
-  ESP32P4_UARTDEV_BUF_NO_REV300,
-  ESP32P4_UARTDEV_BUF_NO_USB_OTG,
-  ESP32P4_UARTDEV_BUF_NO_USB_JTAG_SERIAL,
   ESP32P4_RTC_CNTL_OPTION1_REG,
   ESP32P4_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK,
-  ESP32H2_UARTDEV_BUF_NO,
-  ESP32H2_UARTDEV_BUF_NO_USB_JTAG_SERIAL,
 } from "./const";
 import { getStubCode } from "./stubs";
 import { hexFormatter, sleep, slipEncode, toHex } from "./util";
@@ -144,6 +123,10 @@ export class ESPLoader extends EventTarget {
   public currentBaudRate: number = ESP_ROM_BAUD;
   private _maxUSBSerialBaudrate?: number;
   private _reader?: ReadableStreamDefaultReader<Uint8Array>;
+  private SLIP_END = 0xc0;
+  private SLIP_ESC = 0xdb;
+  private SLIP_ESC_END = 0xdc;
+  private SLIP_ESC_ESC = 0xdd;
   private _isESP32S2NativeUSB: boolean = false;
   private _initializationSucceeded: boolean = false;
   private __commandLock: Promise<[number, number[]]> = Promise.resolve([0, []]);
@@ -457,10 +440,8 @@ export class ESPLoader extends EventTarget {
       0x303a: {
         // Espressif (native USB)
         0x2: { name: "ESP32-S2 Native USB", maxBaudrate: 2000000 },
+        0x12: { name: "ESP32-P4 Native USB", maxBaudrate: 2000000 },
         0x1001: { name: "ESP32 Native USB", maxBaudrate: 2000000 },
-        0x1002: { name: "ESP32 Native USB", maxBaudrate: 2000000 },
-        0x4002: { name: "ESP32 Native USB", maxBaudrate: 2000000 },
-        0x1000: { name: "ESP32 Native USB", maxBaudrate: 2000000 },
       },
     };
 
@@ -757,7 +738,7 @@ export class ESPLoader extends EventTarget {
 
         // Always read from browser's serial buffer immediately
         // to prevent browser buffer overflow. Don't apply back-pressure here.
-        const chunk = Array.from(value);
+        const chunk = Array.from(value as Uint8Array);
         Array.prototype.push.apply(this._inputBuffer, chunk);
 
         // Track total bytes read from serial port
@@ -1500,101 +1481,6 @@ export class ESPLoader extends EventTarget {
     await this.rtcWdtResetChipSpecific();
   }
 
-  /**
-   * Check if current chip is using USB-OTG
-   * Supports ESP32-S2 and ESP32-S3
-   */
-  public async usingUsbOtg(): Promise<boolean> {
-    let uartDevBufNo: number;
-    let usbOtgValue: number;
-
-    if (this.chipFamily === CHIP_FAMILY_ESP32S2) {
-      uartDevBufNo = ESP32S2_UARTDEV_BUF_NO;
-      usbOtgValue = ESP32S2_UARTDEV_BUF_NO_USB_OTG;
-    } else if (this.chipFamily === CHIP_FAMILY_ESP32S3) {
-      uartDevBufNo = ESP32S3_UARTDEV_BUF_NO;
-      usbOtgValue = ESP32S3_UARTDEV_BUF_NO_USB_OTG;
-    } else if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
-      // P4: UARTDEV_BUF_NO depends on chip revision
-      if (this.chipRevision === null) {
-        this.chipRevision = await this.getChipRevision();
-      }
-
-      if (this.chipRevision < 300) {
-        uartDevBufNo = ESP32P4_UARTDEV_BUF_NO_REV0;
-      } else {
-        uartDevBufNo = ESP32P4_UARTDEV_BUF_NO_REV300;
-      }
-      usbOtgValue = ESP32P4_UARTDEV_BUF_NO_USB_OTG;
-    } else {
-      return false;
-    }
-
-    const uartNo = (await this.readRegister(uartDevBufNo)) & 0xff;
-    return uartNo === usbOtgValue;
-  }
-
-  /**
-   * Check if current chip is using USB-JTAG/Serial
-   * Supports ESP32-S3 and ESP32-C3
-   */
-  public async usingUsbJtagSerial(): Promise<boolean> {
-    let uartDevBufNo: number;
-    let usbJtagSerialValue: number;
-
-    if (this.chipFamily === CHIP_FAMILY_ESP32S3) {
-      uartDevBufNo = ESP32S3_UARTDEV_BUF_NO;
-      usbJtagSerialValue = ESP32S3_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
-    } else if (this.chipFamily === CHIP_FAMILY_ESP32C3) {
-      // ESP32-C3: BSS_UART_DEV_ADDR depends on chip revision
-      // Revision < 101: 0x3FCDF064
-      // Revision >= 101: 0x3FCDF060
-      let bssUartDevAddr: number;
-
-      // Get chip revision if not already set
-      if (this.chipRevision === null) {
-        this.chipRevision = await this.getChipRevisionC3();
-      }
-
-      if (this.chipRevision < 101) {
-        bssUartDevAddr = 0x3fcdf064;
-      } else {
-        bssUartDevAddr = 0x3fcdf060;
-      }
-
-      uartDevBufNo = bssUartDevAddr + ESP32C3_BUF_UART_NO_OFFSET;
-      usbJtagSerialValue = ESP32C3_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
-    } else if (this.chipFamily === CHIP_FAMILY_ESP32C5) {
-      uartDevBufNo = ESP32C5_UARTDEV_BUF_NO;
-      usbJtagSerialValue = ESP32C5_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
-    } else if (this.chipFamily === CHIP_FAMILY_ESP32C6) {
-      uartDevBufNo = ESP32C6_UARTDEV_BUF_NO;
-      usbJtagSerialValue = ESP32C6_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
-    } else if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
-      // P4: UARTDEV_BUF_NO depends on chip revision
-      // Revision < 300: 0x4FF3FEC8
-      // Revision >= 300: 0x4FFBFEC8
-      if (this.chipRevision === null) {
-        this.chipRevision = await this.getChipRevision();
-      }
-
-      if (this.chipRevision < 300) {
-        uartDevBufNo = ESP32P4_UARTDEV_BUF_NO_REV0;
-      } else {
-        uartDevBufNo = ESP32P4_UARTDEV_BUF_NO_REV300;
-      }
-      usbJtagSerialValue = ESP32P4_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
-    } else if (this.chipFamily === CHIP_FAMILY_ESP32H2) {
-      uartDevBufNo = ESP32H2_UARTDEV_BUF_NO;
-      usbJtagSerialValue = ESP32H2_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
-    } else {
-      return false;
-    }
-
-    const uartNo = (await this.readRegister(uartDevBufNo)) & 0xff;
-    return uartNo === usbJtagSerialValue;
-  }
-
   /**
    * Get chip revision for ESP32-C3
    * Reads from EFUSE registers and calculates revision
@@ -1670,52 +1556,6 @@ export class ESPLoader extends EventTarget {
     // Unlock watchdog registers
     await this.writeRegister(WDTWPROTECT_REG, WDT_WKEY, undefined, 0);
 
-    // Clear force download boot register (if applicable) BEFORE triggering WDT reset
-    // This ensures the chip boots into firmware mode after reset
-    if (this.chipFamily === CHIP_FAMILY_ESP32S2) {
-      try {
-        await this.writeRegister(
-          ESP32S2_RTC_CNTL_OPTION1_REG,
-          0,
-          ESP32S2_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK,
-          0,
-        );
-        this.logger.debug("Cleared force download boot mask");
-      } catch (err) {
-        this.logger.debug(
-          `Expected error clearing force download boot mask: ${err}`,
-        );
-      }
-    } else if (this.chipFamily === CHIP_FAMILY_ESP32S3) {
-      try {
-        await this.writeRegister(
-          ESP32S3_RTC_CNTL_OPTION1_REG,
-          0,
-          ESP32S3_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK,
-          0,
-        );
-        this.logger.debug("Cleared force download boot mask");
-      } catch (err) {
-        this.logger.debug(
-          `Expected error clearing force download boot mask: ${err}`,
-        );
-      }
-    } else if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
-      try {
-        await this.writeRegister(
-          ESP32P4_RTC_CNTL_OPTION1_REG,
-          0,
-          ESP32P4_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK,
-          0,
-        );
-        this.logger.debug("Cleared force download boot mask");
-      } catch (err) {
-        this.logger.debug(
-          `Expected error clearing force download boot mask: ${err}`,
-        );
-      }
-    }
-
     // Set WDT timeout to 2000ms (matches Python esptool)
     await this.writeRegister(WDTCONFIG1_REG, 2000, undefined, 0);
 
@@ -1731,84 +1571,30 @@ export class ESPLoader extends EventTarget {
   }
 
   /**
-   * Helper: Check if USB-based WDT reset should be used for S2/S3
+   * Helper: USB-based WDT reset
    * Returns true if WDT reset was performed, false otherwise
    */
-  private async tryUsbWdtReset(
-    chipName: string,
-    GPIO_STRAP_REG: number,
-    GPIO_STRAP_SPI_BOOT_MASK: number,
-    RTC_CNTL_OPTION1_REG: number,
-    RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK: number,
-  ): Promise<boolean> {
-    const isUsingUsbOtg = await this.usingUsbOtg();
-    const isUsingUsbJtagSerial = await this.usingUsbJtagSerial();
-
-    if (isUsingUsbOtg || isUsingUsbJtagSerial) {
-      const strapReg = await this.readRegister(GPIO_STRAP_REG);
-      const forceDlReg = await this.readRegister(RTC_CNTL_OPTION1_REG);
-
-      // Only use watchdog reset if GPIO0 is low AND force download boot mode is not set
-      if (
-        (strapReg & GPIO_STRAP_SPI_BOOT_MASK) === 0 &&
-        (forceDlReg & RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK) === 0
-      ) {
-        await this.rtcWdtResetChipSpecific();
-        this.logger.debug(
-          `${chipName}: RTC WDT reset (USB detected, GPIO0 low)`,
-        );
-        return true;
-      }
-    }
-    return false;
-  }
+  private async tryUsbWdtReset(chipName: string): Promise<boolean> {
+    const isUsingUsbOtg = await this.detectUsbConnectionType();
 
-  /**
-   * Chip-specific hard reset for ESP32-S2
-   * Checks if using USB-JTAG/Serial and uses watchdog reset if necessary
-   */
-  public async hardResetS2(): Promise<void> {
-    const isUsingUsbOtg = await this.usingUsbOtg();
     if (isUsingUsbOtg) {
+      // Use WDT reset for USB-OTG devices
       await this.rtcWdtResetChipSpecific();
-      this.logger.debug("ESP32-S2: RTC WDT reset (USB-OTG detected)");
-    } else {
-      // Use standard hardware reset
-      await this.hardResetClassic();
-      this.logger.debug("ESP32-S2: Classic reset");
-    }
-  }
-
-  /**
-   * Chip-specific hard reset for ESP32-S3
-   * Checks if using USB-JTAG/Serial and uses watchdog reset if necessary
-   */
-  public async hardResetS3(): Promise<void> {
-    const isUsingUsbJtagSerial = await this.usingUsbJtagSerial();
-    if (isUsingUsbJtagSerial) {
-      await this.rtcWdtResetChipSpecific();
-      this.logger.debug("ESP32-S3: RTC WDT reset (USB-JTAG/Serial detected)");
-    } else {
-      // Use standard hardware reset
-      await this.hardResetClassic();
-      this.logger.debug("ESP32-S3: Classic reset");
-    }
-  }
-
-  /**
-   * Chip-specific hard reset for ESP32-C3
-   * Checks if using USB-JTAG/Serial and uses watchdog reset if necessary
-   */
-  public async hardResetC3(): Promise<void> {
-    const isUsingUsbJtagSerial = await this.usingUsbJtagSerial();
-    if (isUsingUsbJtagSerial) {
-      await this.rtcWdtResetChipSpecific();
-      this.logger.debug("ESP32-C3: RTC WDT reset (USB-JTAG/Serial detected)");
+      this.logger.debug(
+        `${chipName}: RTC WDT reset (USB-JTAG/Serial or USB-OTG detected)`,
+      );
+      return true;
     } else {
-      // Use standard hardware reset
-      await this.hardResetClassic();
-      this.logger.debug("ESP32-C3: Classic reset");
+      // Use classic reset for non-USB devices
+      if (this.isWebUSB()) {
+        await this.hardResetClassicWebUSB();
+        this.logger.debug("Classic reset (WebUSB/Android).");
+      } else {
+        await this.hardResetClassic();
+        this.logger.debug("Classic reset.");
+      }
     }
+    return false;
   }
 
   async hardReset(bootloader = false) {
@@ -1848,27 +1634,25 @@ export class ESPLoader extends EventTarget {
       }
     } else {
       // just reset (no bootloader mode)
-      // For ESP32-S2/S3 with USB-OTG or USB-JTAG/Serial, check if watchdog reset is needed
-      if (this.chipFamily === CHIP_FAMILY_ESP32S2 && !this._consoleMode) {
-        const wdtResetUsed = await this.tryUsbWdtReset(
-          "ESP32-S2",
-          ESP32S2_GPIO_STRAP_REG,
-          ESP32S2_GPIO_STRAP_SPI_BOOT_MASK,
-          ESP32S2_RTC_CNTL_OPTION1_REG,
-          ESP32S2_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK,
-        );
+      // 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 &&
-        !this._consoleMode
-      ) {
-        const wdtResetUsed = await this.tryUsbWdtReset(
-          "ESP32-S3",
-          ESP32S3_GPIO_STRAP_REG,
-          ESP32S3_GPIO_STRAP_SPI_BOOT_MASK,
-          ESP32S3_RTC_CNTL_OPTION1_REG,
-          ESP32S3_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK,
-        );
+      } 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;
       }
 
@@ -2126,47 +1910,47 @@ export class ESPLoader extends EventTarget {
               "Timed out waiting for packet " + waitingFor,
             );
           }
-          const b = this._readByte()!;
+          const byte = this._readByte()!;
 
           if (partialPacket === null) {
             // waiting for packet header
-            if (b == 0xc0) {
+            if (byte == this.SLIP_END) {
               partialPacket = [];
             } else {
               if (this.debug) {
-                this.logger.debug("Read invalid data: " + toHex(b));
+                this.logger.debug("Read invalid data: " + toHex(byte));
                 this.logger.debug(
                   "Remaining data in serial buffer: " +
                     hexFormatter(this._inputBuffer),
                 );
               }
               throw new SlipReadError(
-                "Invalid head of packet (" + toHex(b) + ")",
+                "Invalid head of packet (" + toHex(byte) + ")",
               );
             }
           } else if (inEscape) {
             // part-way through escape sequence
             inEscape = false;
-            if (b == 0xdc) {
-              partialPacket.push(0xc0);
-            } else if (b == 0xdd) {
-              partialPacket.push(0xdb);
+            if (byte == this.SLIP_ESC_END) {
+              partialPacket.push(this.SLIP_END);
+            } else if (byte == this.SLIP_ESC_ESC) {
+              partialPacket.push(this.SLIP_ESC);
             } else {
               if (this.debug) {
-                this.logger.debug("Read invalid data: " + toHex(b));
+                this.logger.debug("Read invalid data: " + toHex(byte));
                 this.logger.debug(
                   "Remaining data in serial buffer: " +
                     hexFormatter(this._inputBuffer),
                 );
               }
               throw new SlipReadError(
-                "Invalid SLIP escape (0xdb, " + toHex(b) + ")",
+                "Invalid SLIP escape (0xdb, " + toHex(byte) + ")",
               );
             }
-          } else if (b == 0xdb) {
+          } else if (byte == this.SLIP_ESC) {
             // start of escape sequence
             inEscape = true;
-          } else if (b == 0xc0) {
+          } else if (byte == this.SLIP_END) {
             // end of packet
             if (this.debug)
               this.logger.debug(
@@ -2177,7 +1961,7 @@ export class ESPLoader extends EventTarget {
             return partialPacket;
           } else {
             // normal byte in packet
-            partialPacket.push(b);
+            partialPacket.push(byte);
           }
         }
       }
@@ -2211,46 +1995,46 @@ export class ESPLoader extends EventTarget {
           this.logger.debug(
             "Read " + readBytes.length + " bytes: " + hexFormatter(readBytes),
           );
-        for (const b of readBytes) {
+        for (const byte of readBytes) {
           if (partialPacket === null) {
             // waiting for packet header
-            if (b == 0xc0) {
+            if (byte == this.SLIP_END) {
               partialPacket = [];
             } else {
               if (this.debug) {
-                this.logger.debug("Read invalid data: " + toHex(b));
+                this.logger.debug("Read invalid data: " + toHex(byte));
                 this.logger.debug(
                   "Remaining data in serial buffer: " +
                     hexFormatter(this._inputBuffer),
                 );
               }
               throw new SlipReadError(
-                "Invalid head of packet (" + toHex(b) + ")",
+                "Invalid head of packet (" + toHex(byte) + ")",
               );
             }
           } else if (inEscape) {
             // part-way through escape sequence
             inEscape = false;
-            if (b == 0xdc) {
-              partialPacket.push(0xc0);
-            } else if (b == 0xdd) {
-              partialPacket.push(0xdb);
+            if (byte == this.SLIP_ESC_END) {
+              partialPacket.push(this.SLIP_END);
+            } else if (byte == this.SLIP_ESC_ESC) {
+              partialPacket.push(this.SLIP_ESC);
             } else {
               if (this.debug) {
-                this.logger.debug("Read invalid data: " + toHex(b));
+                this.logger.debug("Read invalid data: " + toHex(byte));
                 this.logger.debug(
                   "Remaining data in serial buffer: " +
                     hexFormatter(this._inputBuffer),
                 );
               }
               throw new SlipReadError(
-                "Invalid SLIP escape (0xdb, " + toHex(b) + ")",
+                "Invalid SLIP escape (0xdb, " + toHex(byte) + ")",
               );
             }
-          } else if (b == 0xdb) {
+          } else if (byte == this.SLIP_ESC) {
             // start of escape sequence
             inEscape = true;
-          } else if (b == 0xc0) {
+          } else if (byte == this.SLIP_END) {
             // end of packet
             if (this.debug)
               this.logger.debug(
@@ -2261,7 +2045,7 @@ export class ESPLoader extends EventTarget {
             return partialPacket;
           } else {
             // normal byte in packet
-            partialPacket.push(b);
+            partialPacket.push(byte);
           }
         }
       }
@@ -3257,7 +3041,6 @@ export class ESPLoader extends EventTarget {
       try {
         this._reader.cancel();
       } catch (err) {
-        //        this.logger.debug(`Reader cancel error: ${err}`);
         // Reader already released, resolve immediately
         clearTimeout(timeout);
         resolve(undefined);
@@ -3285,14 +3068,6 @@ export class ESPLoader extends EventTarget {
       return;
     }
 
-    // Check if device is in JTAG mode and needs reset to boot into firmware
-    const didReconnect = await this._resetToFirmwareIfNeeded();
-
-    // If we reconnected for console, the reader/writer are already released and restarted
-    if (didReconnect) {
-      return;
-    }
-
     // Wait for pending writes to complete
     try {
       await this._writeChain;
@@ -3347,37 +3122,36 @@ export class ESPLoader extends EventTarget {
   /**
    * @name detectUsbConnectionType
    * Detect if device is using USB-JTAG/Serial or USB-OTG (not external serial chip)
-   * This helper extracts the detection logic from initialize() for reuse
+   * Uses USB PID (Product ID) for reliable detection - does NOT require chipFamily
    * @returns true if USB-JTAG or USB-OTG, false if external serial chip
-   * @throws Error if detection fails and chipFamily is not set
    */
-  private async detectUsbConnectionType(): Promise<boolean> {
-    if (!this.chipFamily) {
-      throw new Error("Cannot detect USB connection type: chipFamily not set");
-    }
+  public async detectUsbConnectionType(): Promise<boolean> {
+    // Use PID-based detection
+    const portInfo = this.port.getInfo();
+    const pid = portInfo.usbProductId;
+    const vid = portInfo.usbVendorId;
 
-    if (
-      this.chipFamily === CHIP_FAMILY_ESP32S2 ||
-      this.chipFamily === CHIP_FAMILY_ESP32S3
-    ) {
-      const isUsingUsbOtg = await this.usingUsbOtg();
-      const isUsingUsbJtagSerial = await this.usingUsbJtagSerial();
-      return isUsingUsbOtg || isUsingUsbJtagSerial;
-    } else if (
-      this.chipFamily === CHIP_FAMILY_ESP32C3 ||
-      this.chipFamily === CHIP_FAMILY_ESP32C5 ||
-      this.chipFamily === CHIP_FAMILY_ESP32C6
-    ) {
-      const isUsingUsbJtagSerial = await this.usingUsbJtagSerial();
-      return isUsingUsbJtagSerial;
-    } else if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
-      const isUsingUsbOtg = await this.usingUsbOtg();
-      const isUsingUsbJtagSerial = await this.usingUsbJtagSerial();
-      return isUsingUsbOtg || isUsingUsbJtagSerial;
-    } else {
-      // Other chips don't have USB-JTAG/OTG
+    // Check if this is an Espressif device
+    const isEspressif = vid === 0x303a;
+
+    if (!isEspressif) {
+      this.logger.debug("Not Espressif VID - external serial chip");
       return false;
     }
+
+    // ESP32-S2/S3/C3/C5/C6/C61/H2/P4 USB-JTAG/OTG PIDs
+    // According to official Espressif documentation:
+    // https://docs.espressif.com/projects/esp-iot-solution/en/latest/usb/usb_overview/usb_device_const_COM.html
+    // 0x0002 = ESP32-S2 USB-OTG, 0x0012 = ESP32-P4 USB-Serial-JTAG
+    // 0x1001 = ESP32-S3, C3, C5, C6, C61, H2 USB-Serial-JTAG
+    const usbJtagPids = [0x0002, 0x0012, 0x1001];
+    const isUsbJtag = usbJtagPids.includes(pid || 0);
+
+    this.logger.debug(
+      `USB-JTAG/OTG detection: ${isUsbJtag ? "YES" : "NO"} (PID=0x${pid?.toString(16)})`,
+    );
+
+    return isUsbJtag;
   }
 
   /**
@@ -3387,17 +3161,24 @@ export class ESPLoader extends EventTarget {
    * @returns true if port was closed (USB-JTAG), false if port stays open (serial chip)
    */
   public async enterConsoleMode(): Promise<boolean> {
-    // Set console mode flag
-    this._consoleMode = true;
+    // Check if port is open - if not, we need a new port selection
+    if (!this.port.writable || !this.port.readable) {
+      this.logger.debug("Port is not open - port selection needed");
+      // Return true to signal that port selection is needed
+      // The caller should handle port selection and try again
+      return true;
+    }
 
     // Re-detect USB connection type to ensure we have a definitive value
-    // This handles cases where isUsbJtagOrOtg might be undefined
     let isUsbJtag: boolean;
     try {
       isUsbJtag = await this.detectUsbConnectionType();
       this.logger.debug(
         `USB connection type detected: ${isUsbJtag ? "USB-JTAG/OTG" : "External Serial Chip"}`,
       );
+
+      // CRITICAL: Set the cached value so _resetToFirmwareIfNeeded() can use it
+      this._isUsbJtagOrOtg = isUsbJtag;
     } catch (err) {
       // If detection fails, fall back to cached value or fail-fast
       if (this.isUsbJtagOrOtg === undefined) {
@@ -3405,12 +3186,17 @@ 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}`,
       );
       isUsbJtag = this.isUsbJtagOrOtg;
     }
 
+    // Release reader/writer so console can create new ones
+    // This is needed for Desktop (Web Serial) to unlock streams
     if (isUsbJtag) {
       // USB-JTAG/OTG devices: Use watchdog reset which closes port
       const wasReset = await this._resetToFirmwareIfNeeded();
@@ -3432,6 +3218,23 @@ export class ESPLoader extends EventTarget {
         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
     }
   }
@@ -3442,80 +3245,179 @@ export class ESPLoader extends EventTarget {
    * 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> {
+  /**
+   * @name _clearForceDownloadBootIfNeeded
+   * Read and clear the force download boot flag if it is set
+   * This should ONLY be called when on ROM (not stub) and before WDT reset
+   * Clearing it on every connect causes issues with flash operations
+   * Returns true if the flag was cleared, false if it was already clear
+   */
+  private async _clearForceDownloadBootIfNeeded(): Promise<boolean> {
     try {
-      // Check if device is using USB-JTAG/Serial or USB-OTG
-      // Value should already be set during main() connection
-      // Use getter to access parent's value if this is a stub
-      const needsReset = this.isUsbJtagOrOtg === true;
-
-      if (needsReset) {
-        const resetMethod =
-          this.chipFamily === CHIP_FAMILY_ESP32S2 ||
-          this.chipFamily === CHIP_FAMILY_ESP32S3
-            ? "USB-JTAG/Serial or USB-OTG"
-            : "USB-JTAG/Serial";
+      let regAddr: number;
+      let mask: number;
+      let chipName: string;
+
+      // Get register address and mask for this chip
+      if (this.chipFamily === CHIP_FAMILY_ESP32S2) {
+        regAddr = ESP32S2_RTC_CNTL_OPTION1_REG;
+        mask = ESP32S2_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK;
+        chipName = "ESP32-S2";
+      } else if (this.chipFamily === CHIP_FAMILY_ESP32S3) {
+        regAddr = ESP32S3_RTC_CNTL_OPTION1_REG;
+        mask = ESP32S3_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK;
+        chipName = "ESP32-S3";
+      } else if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
+        regAddr = ESP32P4_RTC_CNTL_OPTION1_REG;
+        mask = ESP32P4_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK;
+        chipName = "ESP32-P4";
+      } else {
+        // Not a chip that needs this
+        return false;
+      }
 
-        this.logger.log(
-          `Resetting ${this.chipName || "device"} (${resetMethod}) to boot into firmware...`,
+      // Read current register value
+      const currentValue = await this.readRegister(regAddr);
+      this.logger.debug(
+        `${chipName} force download boot register: 0x${currentValue.toString(16)} (mask: 0x${mask.toString(16)})`,
+      );
+
+      // Check if the flag is set
+      const isFlagSet = (currentValue & mask) !== 0;
+
+      if (isFlagSet) {
+        this.logger.debug(
+          `${chipName} force download boot flag is SET - clearing it`,
         );
+        // Clear the flag by writing 0 to the masked bits
+        await this.writeRegister(regAddr, 0, mask, 0);
+        this.logger.debug(`${chipName} force download boot flag cleared`);
+        return true;
+      } else {
+        this.logger.debug(
+          `${chipName} force download boot flag is already CLEAR - no action needed`,
+        );
+        return false;
+      }
+    } catch (err) {
+      this.logger.debug(`Error checking/clearing force download flag: ${err}`);
+      return false;
+    }
+  }
 
-        // Set console mode flag before reset to prevent subsequent hardReset calls
-        this._consoleMode = true;
+  private async _resetToFirmwareIfNeeded(): Promise<boolean> {
+    try {
+      // Check if port is open - if not, assume device is already in firmware mode
+      if (!this.port.writable || !this.port.readable) {
+        this.logger.debug(
+          "Port is not open - assuming device is already in firmware mode",
+        );
+        return false;
+      }
 
-        // For S2/S3: Clear force download boot mask before WDT reset
-        if (
-          this.chipFamily === CHIP_FAMILY_ESP32S2 ||
-          this.chipFamily === CHIP_FAMILY_ESP32S3
-        ) {
-          const OPTION1_REG =
-            this.chipFamily === CHIP_FAMILY_ESP32S2
-              ? ESP32S2_RTC_CNTL_OPTION1_REG
-              : ESP32S3_RTC_CNTL_OPTION1_REG;
-          const FORCE_DOWNLOAD_BOOT_MASK =
-            this.chipFamily === CHIP_FAMILY_ESP32S2
-              ? ESP32S2_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK
-              : ESP32S3_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK;
+      const isUsingUsbOtg = await this.detectUsbConnectionType();
 
-          try {
-            // Clear force download boot mode to avoid chip being stuck in download mode
-            await this.writeRegister(
-              OPTION1_REG,
-              0,
-              FORCE_DOWNLOAD_BOOT_MASK,
-              0,
-            );
-            this.logger.debug("Cleared force download boot mask");
-          } catch (err) {
+      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(
-              `Expected error clearing force download boot mask: ${err}`,
+              `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");
         }
 
-        // Perform watchdog reset to reboot into firmware
-        try {
-          await this.rtcWdtResetChipSpecific();
-          this.logger.debug("Watchdog reset triggered successfully");
-        } catch (err) {
-          // Error is expected - device resets before responding
+        // 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(
-            `Watchdog reset initiated (connection lost as expected: ${err})`,
+            "Force download flag already clear - device will boot to firmware after reset",
           );
         }
 
-        // Wait for device to fully boot into firmware
-        this.logger.log("Waiting for device to boot into firmware...");
-        await this.sleep(1000);
+        // Perform WDT reset BEFORE releasing reader/writer (needs communication)
+        // After WDT reset, the device will reboot into firmware mode
+        await this.hardReset(false);
 
-        // After WDT reset, streams are dead/locked - don't try to manipulate them
-        // Just mark everything as disconnected and let browser clean up
-        this.connected = false;
-        this._writer = undefined;
-        this._reader = undefined;
+        // 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);
 
-        this.logger.debug("Device reset to firmware mode (port closed)");
-        return true;
+        if (portWillChange) {
+          // Port will change - release reader/writer and let the port become invalid
+          await this.releaseReaderWriter();
+
+          this.logger.log(
+            `${this.chipName} USB-OTG: Port will change after WDT reset`,
+          );
+          this.logger.log("Please select the new port for console mode");
+
+          // 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
+          await this.releaseReaderWriter();
+          return false;
+        }
       }
     } catch (err) {
       this.logger.debug(`Could not reset device to firmware mode: ${err}`);
@@ -3788,35 +3690,61 @@ export class ESPLoader extends EventTarget {
     // Clear console mode flag
     this._consoleMode = false;
 
-    // Check if this is ESP32-S2 with USB-JTAG/OTG
-    const isESP32S2 = this.chipFamily === CHIP_FAMILY_ESP32S2;
+    // Check if this is a USB-OTG device (ESP32-S2 or ESP32-P4)
+    const isUsbOtgChip =
+      this.chipFamily === CHIP_FAMILY_ESP32S2 ||
+      this.chipFamily === CHIP_FAMILY_ESP32P4;
 
-    // For ESP32-S2: if _isUsbJtagOrOtg is undefined, try to detect it
+    // For USB-OTG chips: if _isUsbJtagOrOtg is undefined, try to detect it
     // If detection fails or is undefined, assume USB-JTAG/OTG (conservative/safe path)
     let isUsbJtagOrOtg = this._isUsbJtagOrOtg;
-    if (isESP32S2 && isUsbJtagOrOtg === undefined) {
+    if (isUsbOtgChip && isUsbJtagOrOtg === undefined) {
       try {
         isUsbJtagOrOtg = await this.detectUsbConnectionType();
       } catch (err) {
         this.logger.debug(
-          `USB detection failed, assuming USB-JTAG/OTG for ESP32-S2: ${err}`,
+          `USB detection failed, assuming USB-JTAG/OTG for ${this.chipName}: ${err}`,
         );
-        isUsbJtagOrOtg = true; // Conservative fallback for ESP32-S2
+        isUsbJtagOrOtg = true; // Conservative fallback
       }
     }
 
-    if (isESP32S2 && isUsbJtagOrOtg) {
-      // ESP32-S2 USB: Use reconnectToBootloader which handles the mode switch
-      // This will close the port and the device will reboot to bootloader
-      this.logger.log("ESP32-S2 USB detected - reconnecting to bootloader");
+    if (isUsbOtgChip && isUsbJtagOrOtg) {
+      // USB-OTG devices: Need to reset to bootloader, which will cause port change
+      this.logger.log(`${this.chipName} USB: Resetting to bootloader mode`);
 
+      // Perform hardware reset to bootloader (GPIO0=LOW)
+      // This will cause the port to change from CDC (firmware) to JTAG (bootloader)
       try {
-        await this.reconnectToBootloader();
+        if (this.isWebUSB()) {
+          await this.hardResetClassicWebUSB();
+        } else {
+          await this.hardResetClassic();
+        }
+        this.logger.debug("Reset to bootloader initiated");
       } catch (err) {
-        this.logger.debug(`Reconnect error (expected for ESP32-S2): ${err}`);
+        this.logger.debug(`Reset error: ${err}`);
       }
 
-      // For ESP32-S2, port will change, so return true to indicate manual reconnection needed
+      // Wait for reset to complete and port to change
+      await sleep(500);
+
+      this.logger.log(
+        `${this.chipName}: Port changed. Please select the bootloader port.`,
+      );
+
+      // Dispatch event to signal port change
+      this.dispatchEvent(
+        new CustomEvent("usb-otg-port-change", {
+          detail: {
+            chipName: this.chipName,
+            message: `${this.chipName}: Port changed. Please select the bootloader port.`,
+            reason: "exit-console-to-bootloader",
+          },
+        }),
+      );
+
+      // Port will change, so return true to indicate manual reconnection needed
       return true;
     }
 
@@ -3898,7 +3826,7 @@ export class ESPLoader extends EventTarget {
     await sleep(bufferingTime);
 
     // Unsupported command response is sent 8 times and has
-    // 14 bytes length including delimiter 0xC0 bytes.
+    // 14 bytes length including delimiter SLIP_END (0xC0) bytes.
     // At least part of it is read as a command response,
     // but to be safe, read it all.
     const bytesToDrain = 14 * 8;
@@ -4118,7 +4046,7 @@ export class ESPLoader extends EventTarget {
                 // The stub expects 4 bytes (ACK), if we send less it will break out
                 try {
                   // Send SLIP frame with no data (just delimiters)
-                  const abortFrame = [0xc0, 0xc0]; // Empty SLIP frame
+                  const abortFrame = [this.SLIP_END, this.SLIP_END]; // Empty SLIP frame
                   await this.writeToStream(abortFrame);
                   this.logger.debug(`Sent abort frame to stub`);