esp32tool 1.3.6 → 1.3.7

package/js/script.js

@@ -736,7 +736,7 @@ async function clickConnect() {
     throw err;
   }
 
-  logMsg("Connected to " + esploader.chipName);
+  // logMsg("Connected to " + esploader.chipName);
   logMsg("MAC Address: " + formatMacAddr(esploader.macAddr()));
 
   // Store chip info globally
@@ -934,7 +934,7 @@ async function initConsoleUI() {
   }
   consoleCloseHandler = async () => {
     if (!consoleSwitch.checked) return;
-    debugMsg("Closing console...");
+    logMsg("Closing console");
     consoleSwitch.checked = false;
     saveSetting("console", false);
     await closeConsole();
@@ -1149,8 +1149,8 @@ async function closeConsole() {
       const needsManualReconnect = await espLoaderBeforeConsole.exitConsoleMode();
       
       if (needsManualReconnect) {
-        // ESP32-S2: Port has changed, need to select new port
-        logMsg("ESP32-S2: Port changed - please select the new port");
+        // Port has changed, need to select new port
+        // logMsg("Port changed - please select the new port");
         toggleUIConnected(false);
         espStub = undefined;
         

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "esp32tool",
-  "version": "1.3.6",
+  "version": "1.3.7",
   "type": "module",
   "description": "Flash & Read ESP devices using WebSerial, Electron, and also Android mobile via WebUSB",
   "main": "electron/main.cjs",
@@ -54,22 +54,22 @@
     "@rollup/plugin-node-resolve": "^16.0.0",
     "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^12.3.0",
-    "@types/node": "^25.0.10",
+    "@types/node": "^25.2.3",
     "@types/pako": "^2.0.4",
     "@types/serialport": "^10.2.0",
     "@types/w3c-web-serial": "^1.0.7",
     "archiver": "^7.0.1",
-    "electron": "^40.0.0",
+    "electron": "^40.2.1",
     "electron-squirrel-startup": "^1.0.1",
     "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-prettier": "^5.5.4",
+    "eslint-plugin-prettier": "^5.5.5",
     "npm-run-all": "^4.1.5",
     "prettier": "^3.8.1",
     "rollup": "^4.57.0",
     "serve": "^14.2.4",
     "typescript": "^5.7.3",
-    "typescript-eslint": "^8.54.0"
+    "typescript-eslint": "^8.55.0"
   },
   "dependencies": {
     "pako": "^2.1.0",

package/src/const.ts

@@ -93,9 +93,11 @@ export const ESP32_SPI_MISO_DLEN_OFFS = 0x2c;
 export const ESP32_SPI_W0_OFFS = 0x80;
 export const ESP32_UART_DATE_REG_ADDR = 0x60000078;
 export const ESP32_BOOTLOADER_FLASH_OFFSET = 0x1000;
+export const ESP32_APB_CTL_DATE_ADDR = 0x3ff66000 + 0x7c;
 
 export const ESP32S2_SPI_REG_BASE = 0x3f402000;
 export const ESP32S2_BASEFUSEADDR = 0x3f41a000;
+export const ESP32S2_EFUSE_BLOCK1_ADDR = ESP32S2_BASEFUSEADDR + 0x044;
 export const ESP32S2_MACFUSEADDR = 0x3f41a044;
 export const ESP32S2_SPI_USR_OFFS = 0x18;
 export const ESP32S2_SPI_USR1_OFFS = 0x1c;
@@ -125,6 +127,7 @@ export const ESP32S2_UARTDEV_BUF_NO_USB_OTG = 2; // Value of the above indicatin
 
 export const ESP32S3_SPI_REG_BASE = 0x60002000;
 export const ESP32S3_BASEFUSEADDR = 0x60007000;
+export const ESP32S3_EFUSE_BLOCK1_ADDR = ESP32S3_BASEFUSEADDR + 0x044;
 export const ESP32S3_MACFUSEADDR = 0x60007000 + 0x044;
 export const ESP32S3_SPI_USR_OFFS = 0x18;
 export const ESP32S3_SPI_USR1_OFFS = 0x1c;
@@ -155,6 +158,7 @@ export const ESP32S3_UARTDEV_BUF_NO_USB_JTAG_SERIAL = 4; // The above var when U
 
 export const ESP32C2_SPI_REG_BASE = 0x60002000;
 export const ESP32C2_BASEFUSEADDR = 0x60008800;
+export const ESP32C2_EFUSE_BLOCK2_ADDR = ESP32C2_BASEFUSEADDR + 0x040;
 export const ESP32C2_MACFUSEADDR = ESP32C2_BASEFUSEADDR + 0x040;
 export const ESP32C2_SPI_USR_OFFS = 0x18;
 export const ESP32C2_SPI_USR1_OFFS = 0x1c;
@@ -210,6 +214,7 @@ export const ESP32C3_EFUSE_RD_MAC_SPI_SYS_5_REG = 0x60008858;
 
 export const ESP32C5_SPI_REG_BASE = 0x60003000;
 export const ESP32C5_BASEFUSEADDR = 0x600b4800;
+export const ESP32C5_EFUSE_BLOCK1_ADDR = ESP32C5_BASEFUSEADDR + 0x044;
 export const ESP32C5_MACFUSEADDR = 0x600b4800 + 0x044;
 export const ESP32C5_SPI_USR_OFFS = 0x18;
 export const ESP32C5_SPI_USR1_OFFS = 0x1c;
@@ -218,13 +223,19 @@ export const ESP32C5_SPI_MOSI_DLEN_OFFS = 0x24;
 export const ESP32C5_SPI_MISO_DLEN_OFFS = 0x28;
 export const ESP32C5_SPI_W0_OFFS = 0x58;
 export const ESP32C5_UART_DATE_REG_ADDR = 0x6000007c;
+export const ESP32C5_UART_CLKDIV_REG = 0x60000014;
 export const ESP32C5_BOOTLOADER_FLASH_OFFSET = 0x2000;
+// ESP32-C5 Crystal frequency detection registers
+export const ESP32C5_PCR_SYSCLK_CONF_REG = 0x60096110;
+export const ESP32C5_PCR_SYSCLK_XTAL_FREQ_V = 0x7f << 24;
+export const ESP32C5_PCR_SYSCLK_XTAL_FREQ_S = 24;
 // ESP32-C5 USB-JTAG/Serial detection
 export const ESP32C5_UARTDEV_BUF_NO = 0x4085f514; // Variable in ROM .bss which indicates the port in use
 export const ESP32C5_UARTDEV_BUF_NO_USB_JTAG_SERIAL = 3; // The above var when USB-JTAG/Serial is used
 
 export const ESP32C6_SPI_REG_BASE = 0x60003000;
 export const ESP32C6_BASEFUSEADDR = 0x600b0800;
+export const ESP32C6_EFUSE_BLOCK1_ADDR = ESP32C6_BASEFUSEADDR + 0x044;
 export const ESP32C6_MACFUSEADDR = 0x600b0800 + 0x044;
 export const ESP32C6_SPI_USR_OFFS = 0x18;
 export const ESP32C6_SPI_USR1_OFFS = 0x1c;
@@ -265,6 +276,7 @@ export const ESP32C5_C6_RTC_CNTL_SWD_WPROTECT_REG =
 
 export const ESP32C61_SPI_REG_BASE = 0x60003000;
 export const ESP32C61_BASEFUSEADDR = 0x600b4800;
+export const ESP32C61_EFUSE_BLOCK1_ADDR = ESP32C61_BASEFUSEADDR + 0x044;
 export const ESP32C61_MACFUSEADDR = 0x600b4800 + 0x044;
 export const ESP32C61_SPI_USR_OFFS = 0x18;
 export const ESP32C61_SPI_USR1_OFFS = 0x1c;
@@ -277,6 +289,7 @@ export const ESP32C61_BOOTLOADER_FLASH_OFFSET = 0x0000;
 
 export const ESP32H2_SPI_REG_BASE = 0x60003000;
 export const ESP32H2_BASEFUSEADDR = 0x600b0800;
+export const ESP32H2_EFUSE_BLOCK1_ADDR = ESP32H2_BASEFUSEADDR + 0x044;
 export const ESP32H2_MACFUSEADDR = 0x600b0800 + 0x044;
 export const ESP32H2_SPI_USR_OFFS = 0x18;
 export const ESP32H2_SPI_USR1_OFFS = 0x1c;
@@ -302,6 +315,7 @@ export const ESP32H2_UARTDEV_BUF_NO_USB_JTAG_SERIAL = 3; // The above var when U
 
 export const ESP32H4_SPI_REG_BASE = 0x60099000;
 export const ESP32H4_BASEFUSEADDR = 0x600b1800;
+export const ESP32H4_EFUSE_BLOCK1_ADDR = ESP32H4_BASEFUSEADDR + 0x044;
 export const ESP32H4_MACFUSEADDR = 0x600b1800 + 0x044;
 export const ESP32H4_SPI_USR_OFFS = 0x18;
 export const ESP32H4_SPI_USR1_OFFS = 0x1c;
@@ -324,6 +338,7 @@ export const ESP32H4_RTC_CNTL_SWD_WKEY = 0x50d83aa1; // LP_WDT_SWD_WKEY, same as
 
 export const ESP32H21_SPI_REG_BASE = 0x60003000;
 export const ESP32H21_BASEFUSEADDR = 0x600b4000;
+export const ESP32H21_EFUSE_BLOCK1_ADDR = ESP32H21_BASEFUSEADDR + 0x044;
 export const ESP32H21_MACFUSEADDR = 0x600b4000 + 0x044;
 export const ESP32H21_SPI_USR_OFFS = 0x18;
 export const ESP32H21_SPI_USR1_OFFS = 0x1c;

package/src/esp_loader.ts

@@ -58,7 +58,17 @@ import {
   CHIP_DETECT_MAGIC_REG_ADDR,
   CHIP_DETECT_MAGIC_VALUES,
   CHIP_ID_TO_INFO,
+  ESP32_BASEFUSEADDR,
+  ESP32_APB_CTL_DATE_ADDR,
+  ESP32S2_EFUSE_BLOCK1_ADDR,
+  ESP32S3_EFUSE_BLOCK1_ADDR,
+  ESP32C2_EFUSE_BLOCK2_ADDR,
+  ESP32C5_EFUSE_BLOCK1_ADDR,
+  ESP32C6_EFUSE_BLOCK1_ADDR,
+  ESP32C61_EFUSE_BLOCK1_ADDR,
+  ESP32H2_EFUSE_BLOCK1_ADDR,
   ESP32P4_EFUSE_BLOCK1_ADDR,
+  ESP32S31_EFUSE_BLOCK1_ADDR,
   SlipReadError,
   ESP32S2_RTC_CNTL_WDTWPROTECT_REG,
   ESP32S2_RTC_CNTL_WDTCONFIG0_REG,
@@ -82,6 +92,10 @@ import {
   ESP32C5_C6_RTC_CNTL_WDTCONFIG0_REG,
   ESP32C5_C6_RTC_CNTL_WDTCONFIG1_REG,
   ESP32C5_C6_RTC_CNTL_WDT_WKEY,
+  ESP32C5_UART_CLKDIV_REG,
+  ESP32C5_PCR_SYSCLK_CONF_REG,
+  ESP32C5_PCR_SYSCLK_XTAL_FREQ_V,
+  ESP32C5_PCR_SYSCLK_XTAL_FREQ_S,
   ESP32P4_RTC_CNTL_WDTWPROTECT_REG,
   ESP32P4_RTC_CNTL_WDTCONFIG0_REG,
   ESP32P4_RTC_CNTL_WDTCONFIG1_REG,
@@ -98,6 +112,7 @@ import {
 } from "./const";
 import { getStubCode } from "./stubs";
 import { hexFormatter, sleep, slipEncode, toHex } from "./util";
+import { FLASH_MANUFACTURERS, FLASH_DEVICES } from "./flash_jedec";
 import { deflate } from "pako";
 import { pack, unpack } from "./struct";
 
@@ -530,7 +545,11 @@ export class ESPLoader extends EventTarget {
     for (let i = 0; i < 4; i++) {
       this._efuses[i] = await this.readRegister(AddrMAC + 4 * i);
     }
-    this.logger.log(`Chip type ${this.chipName}`);
+    const revisionInfo =
+      this.chipRevision !== null && this.chipRevision !== undefined
+        ? ` (revision ${this.chipRevision})`
+        : "";
+    this.logger.log(`Connected to ${this.chipName}${revisionInfo}`);
     this.logger.debug(
       `Bootloader flash offset: 0x${FlAddr.flashOffs.toString(16)}`,
     );
@@ -553,21 +572,16 @@ export class ESPLoader extends EventTarget {
         this.chipName = chipInfo.name;
         this.chipFamily = chipInfo.family;
 
-        // Get chip revision for ESP32-P4 and ESP32-C3
-        if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
-          this.chipRevision = await this.getChipRevision();
-          this.logger.debug(`ESP32-P4 revision: ${this.chipRevision}`);
+        this.chipRevision = await this.getChipRevision();
+        this.logger.debug(`${this.chipName} revision: ${this.chipRevision}`);
 
-          // Set chip variant based on revision
-          if (this.chipRevision >= 300) {
-            this.chipVariant = "rev300";
-          } else {
-            this.chipVariant = "rev0";
-          }
-          this.logger.debug(`ESP32-P4 variant: ${this.chipVariant}`);
-        } else if (this.chipFamily === CHIP_FAMILY_ESP32C3) {
-          this.chipRevision = await this.getChipRevision();
-          this.logger.debug(`ESP32-C3 revision: ${this.chipRevision}`);
+        if (
+          this.chipFamily === CHIP_FAMILY_ESP32P4 &&
+          this.chipRevision >= 300
+        ) {
+          this.chipVariant = "rev300";
+        } else if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
+          this.chipVariant = "rev0";
         }
 
         this.logger.debug(
@@ -617,17 +631,12 @@ export class ESPLoader extends EventTarget {
     this.chipName = chip.name;
     this.chipFamily = chip.family;
 
-    if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
-      this.chipRevision = await this.getChipRevision();
+    this.chipRevision = await this.getChipRevision();
+    this.logger.debug(`${this.chipName} revision: ${this.chipRevision}`);
 
-      if (this.chipRevision >= 300) {
-        this.chipVariant = "rev300";
-      } else {
-        this.chipVariant = "rev0";
-      }
+    if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
+      this.chipVariant = this.chipRevision >= 300 ? "rev300" : "rev0";
       this.logger.debug(`ESP32-P4 variant: ${this.chipVariant}`);
-    } else if (this.chipFamily === CHIP_FAMILY_ESP32C3) {
-      this.chipRevision = await this.getChipRevision();
     }
 
     this.logger.debug(
@@ -635,28 +644,102 @@ export class ESPLoader extends EventTarget {
     );
   }
 
-  /**
-   * Get chip revision for ESP32-P4
-   */
   async getChipRevision(): Promise<number> {
-    if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
-      // Read from EFUSE_BLOCK1 to get chip revision
-      // Word 2 contains revision info for ESP32-P4
-      const word2 = await this.readRegister(ESP32P4_EFUSE_BLOCK1_ADDR + 8);
-
-      // Minor revision: bits [3:0]
-      const minorRev = word2 & 0x0f;
-
-      // Major revision: bits [23] << 2 | bits [5:4]
-      const majorRev = (((word2 >> 23) & 1) << 2) | ((word2 >> 4) & 0x03);
-
-      // Revision is major * 100 + minor
-      return majorRev * 100 + minorRev;
-    } else if (this.chipFamily === CHIP_FAMILY_ESP32C3) {
-      return await this.getChipRevisionC3();
+    let minor = 0;
+    let major = 0;
+
+    switch (this.chipFamily) {
+      case CHIP_FAMILY_ESP32: {
+        const efuse3 = await this.readRegister(ESP32_BASEFUSEADDR + 4 * 3);
+        const efuse5 = await this.readRegister(ESP32_BASEFUSEADDR + 4 * 5);
+        minor = (efuse5 >> 24) & 0x3;
+        const revBit0 = (efuse3 >> 15) & 0x1;
+        const revBit1 = (efuse5 >> 20) & 0x1;
+        const apb = await this.readRegister(ESP32_APB_CTL_DATE_ADDR);
+        const revBit2 = (apb >> 31) & 0x1;
+        const combined = (revBit2 << 2) | (revBit1 << 1) | revBit0;
+        major =
+          ({ 0: 0, 1: 1, 3: 2, 7: 3 } as Record<number, number>)[combined] ?? 0;
+        break;
+      }
+      case CHIP_FAMILY_ESP32S2: {
+        const w3 = await this.readRegister(ESP32S2_EFUSE_BLOCK1_ADDR + 4 * 3);
+        const w4 = await this.readRegister(ESP32S2_EFUSE_BLOCK1_ADDR + 4 * 4);
+        const hi = (w3 >> 20) & 0x01;
+        const lo = (w4 >> 4) & 0x07;
+        minor = (hi << 3) + lo;
+        major = (w3 >> 18) & 0x03;
+        break;
+      }
+      case CHIP_FAMILY_ESP32S3: {
+        const w3 = await this.readRegister(ESP32S3_EFUSE_BLOCK1_ADDR + 4 * 3);
+        const w5 = await this.readRegister(ESP32S3_EFUSE_BLOCK1_ADDR + 4 * 5);
+        const hi = (w5 >> 23) & 0x01;
+        const lo = (w3 >> 18) & 0x07;
+        minor = (hi << 3) + lo;
+        major = (w5 >> 24) & 0x03;
+        break;
+      }
+      case CHIP_FAMILY_ESP32C2: {
+        const w1 = await this.readRegister(ESP32C2_EFUSE_BLOCK2_ADDR + 4 * 1);
+        minor = (w1 >> 16) & 0x0f;
+        major = (w1 >> 20) & 0x03;
+        break;
+      }
+      case CHIP_FAMILY_ESP32C3: {
+        const w3 = await this.readRegister(ESP32C3_EFUSE_RD_MAC_SPI_SYS_3_REG);
+        const w5 = await this.readRegister(ESP32C3_EFUSE_RD_MAC_SPI_SYS_5_REG);
+        const hi = (w5 >> 23) & 0x01;
+        const lo = (w3 >> 18) & 0x07;
+        minor = (hi << 3) + lo;
+        major = (w5 >> 24) & 0x03;
+        break;
+      }
+      case CHIP_FAMILY_ESP32C5: {
+        const w2 = await this.readRegister(ESP32C5_EFUSE_BLOCK1_ADDR + 4 * 2);
+        minor = w2 & 0x0f;
+        major = (w2 >> 4) & 0x03;
+        break;
+      }
+      case CHIP_FAMILY_ESP32C6: {
+        const w3 = await this.readRegister(ESP32C6_EFUSE_BLOCK1_ADDR + 4 * 3);
+        minor = (w3 >> 18) & 0x0f;
+        major = (w3 >> 22) & 0x03;
+        break;
+      }
+      case CHIP_FAMILY_ESP32C61: {
+        const w2 = await this.readRegister(ESP32C61_EFUSE_BLOCK1_ADDR + 4 * 2);
+        minor = w2 & 0x0f;
+        major = (w2 >> 4) & 0x03;
+        break;
+      }
+      case CHIP_FAMILY_ESP32H2: {
+        const w3 = await this.readRegister(ESP32H2_EFUSE_BLOCK1_ADDR + 4 * 3);
+        minor = (w3 >> 18) & 0x07;
+        major = (w3 >> 21) & 0x03;
+        break;
+      }
+      case CHIP_FAMILY_ESP32H4: {
+        break;
+      }
+      case CHIP_FAMILY_ESP32H21: {
+        break;
+      }
+      case CHIP_FAMILY_ESP32P4: {
+        const w2 = await this.readRegister(ESP32P4_EFUSE_BLOCK1_ADDR + 4 * 2);
+        minor = w2 & 0x0f;
+        major = (((w2 >> 23) & 1) << 2) | ((w2 >> 4) & 0x03);
+        break;
+      }
+      case CHIP_FAMILY_ESP32S31: {
+        const w2 = await this.readRegister(ESP32S31_EFUSE_BLOCK1_ADDR + 4 * 2);
+        minor = w2 & 0x0f;
+        major = (w2 >> 4) & 0x03;
+        break;
+      }
     }
 
-    return 0;
+    return major * 100 + minor;
   }
 
   /**
@@ -1511,7 +1594,7 @@ export class ESPLoader extends EventTarget {
           try {
             await Promise.race([syncPromise, timeoutPromise]);
             // Sync succeeded
-            this.logger.log(
+            this.logger.debug(
               `Connected CDC/JTAG successfully with ${strategy.name} reset.`,
             );
             return;
@@ -1562,29 +1645,6 @@ export class ESPLoader extends EventTarget {
     await this.rtcWdtResetChipSpecific();
   }
 
-  /**
-   * Get chip revision for ESP32-C3
-   * Reads from EFUSE registers and calculates revision
-   */
-  async getChipRevisionC3(): Promise<number> {
-    if (this.chipFamily !== CHIP_FAMILY_ESP32C3) {
-      return 0;
-    }
-
-    // Read EFUSE_RD_MAC_SPI_SYS_3_REG (bits [20:18] = lower 3 bits of revision)
-    const word3 = await this.readRegister(ESP32C3_EFUSE_RD_MAC_SPI_SYS_3_REG);
-    const low = (word3 >> 18) & 0x07;
-
-    // Read EFUSE_RD_MAC_SPI_SYS_5_REG (bits [25:23] = upper 3 bits of revision)
-    const word5 = await this.readRegister(ESP32C3_EFUSE_RD_MAC_SPI_SYS_5_REG);
-    const hi = (word5 >> 23) & 0x07;
-
-    // Combine: upper 3 bits from word5, lower 3 bits from word3
-    const revision = (hi << 3) | low;
-
-    return revision;
-  }
-
   /**
    * RTC watchdog timer reset for ESP32-S2, ESP32-S3, ESP32-C3, ESP32-C5, ESP32-C6, and ESP32-P4
    * Uses specific registers for each chip family
@@ -2180,16 +2240,38 @@ export class ESPLoader extends EventTarget {
     return state;
   }
 
+  async getC5CrystalFreqRomExpect(): Promise<number> {
+    const reg = await this.readRegister(ESP32C5_PCR_SYSCLK_CONF_REG);
+    return (
+      (reg & ESP32C5_PCR_SYSCLK_XTAL_FREQ_V) >>> ESP32C5_PCR_SYSCLK_XTAL_FREQ_S
+    );
+  }
+
+  async getC5CrystalFreqDetected(): Promise<number> {
+    const UART_CLKDIV_MASK = 0xfffff;
+    const uartDiv =
+      (await this.readRegister(ESP32C5_UART_CLKDIV_REG)) & UART_CLKDIV_MASK;
+    const estXtal = (ESP_ROM_BAUD * uartDiv) / 1e6;
+    if (estXtal > 45) return 48;
+    if (estXtal > 33) return 40;
+    return 26;
+  }
+
   async setBaudrate(baud: number) {
-    try {
-      // Send ESP_ROM_BAUD(115200) as the old one if running STUB otherwise 0
-      const buffer = pack("<II", baud, this.IS_STUB ? ESP_ROM_BAUD : 0);
-      await this.checkCommand(ESP_CHANGE_BAUDRATE, buffer);
-    } catch (e) {
-      this.logger.error(`Baudrate change error: ${e}`);
-      throw new Error(
-        `Unable to change the baud rate to ${baud}: No response from set baud rate command.`,
-      );
+    const chipFamily = this._parent ? this._parent.chipFamily : this.chipFamily;
+
+    if (!this.IS_STUB && chipFamily === CHIP_FAMILY_ESP32C5) {
+      await this.setBaudrateC5Rom(baud);
+    } else {
+      try {
+        const buffer = pack("<II", baud, this.IS_STUB ? ESP_ROM_BAUD : 0);
+        await this.checkCommand(ESP_CHANGE_BAUDRATE, buffer);
+      } catch (e) {
+        this.logger.error(`Baudrate change error: ${e}`);
+        throw new Error(
+          `Unable to change the baud rate to ${baud}: No response from set baud rate command.`,
+        );
+      }
     }
 
     if (this._parent) {
@@ -2221,7 +2303,34 @@ export class ESPLoader extends EventTarget {
       );
     }
 
-    this.logger.log(`Changed baud rate to ${baud}`);
+    this.logger.debug(`Changed baud rate to ${baud}`);
+  }
+
+  private async setBaudrateC5Rom(baud: number) {
+    const crystalFreqRomExpect = await this.getC5CrystalFreqRomExpect();
+    const crystalFreqDetect = await this.getC5CrystalFreqDetected();
+    this.logger.log(
+      `ROM expects crystal freq: ${crystalFreqRomExpect} MHz, detected ${crystalFreqDetect} MHz.`,
+    );
+
+    let baudRate = baud;
+    if (crystalFreqDetect === 48 && crystalFreqRomExpect === 40) {
+      baudRate = Math.trunc((baud * 40) / 48);
+    } else if (crystalFreqDetect === 40 && crystalFreqRomExpect === 48) {
+      baudRate = Math.trunc((baud * 48) / 40);
+    }
+
+    this.logger.log(`Changing baud rate to ${baudRate}...`);
+    try {
+      const buffer = pack("<II", baudRate, 0);
+      await this.checkCommand(ESP_CHANGE_BAUDRATE, buffer);
+    } catch (e) {
+      this.logger.error(`Baudrate change error: ${e}`);
+      throw new Error(
+        `Unable to change the baud rate to ${baudRate}: No response from set baud rate command.`,
+      );
+    }
+    this.logger.log("Changed.");
   }
 
   async reconfigurePort(baud: number) {
@@ -2823,18 +2932,23 @@ export class ESPLoader extends EventTarget {
     return status;
   }
   async detectFlashSize() {
-    this.logger.log("Detecting Flash Size");
+    this.logger.debug("Detecting Flash Size");
 
     const flashId = await this.flashId();
     const manufacturer = flashId & 0xff;
     const flashIdLowbyte = (flashId >> 16) & 0xff;
+    const deviceTypeByte = (flashId >> 8) & 0xff;
+    const deviceId = (deviceTypeByte << 8) | flashIdLowbyte;
+    const jedecId = (manufacturer << 16) | deviceId;
+
+    const mfrName = FLASH_MANUFACTURERS[manufacturer];
+    const deviceName = FLASH_DEVICES[jedecId];
 
-    this.logger.log(`FlashId: ${toHex(flashId)}`);
-    this.logger.log(`Flash Manufacturer: ${manufacturer.toString(16)}`);
     this.logger.log(
-      `Flash Device: ${((flashId >> 8) & 0xff).toString(
-        16,
-      )}${flashIdLowbyte.toString(16)}`,
+      `Flash Manufacturer: ${mfrName || "Unknown"} (0x${manufacturer.toString(16)})`,
+    );
+    this.logger.log(
+      `Flash Device: ${deviceName || `Unknown (0x${deviceId.toString(16)})`}`,
     );
 
     this.flashSize = DETECTED_FLASH_SIZES[flashIdLowbyte];
@@ -2925,7 +3039,7 @@ export class ESPLoader extends EventTarget {
     const ramBlock = USB_RAM_BLOCK;
 
     // Upload
-    this.logger.log("Uploading stub...");
+    this.logger.debug("Uploading stub...");
     for (const field of ["text", "data"] as const) {
       const fieldData = stub[field];
       const offset = stub[`${field}_start` as "text_start" | "data_start"];
@@ -2949,7 +3063,7 @@ export class ESPLoader extends EventTarget {
     if (pChar != "OHAI") {
       throw new Error("Failed to start stub. Unexpected response: " + pChar);
     }
-    this.logger.log("Stub is now running...");
+    this.logger.debug("Stub is now running...");
     const espStubLoader = new EspStubLoader(this.port, this.logger, this);
 
     // Try to autodetect the flash size.
@@ -3479,10 +3593,9 @@ export class ESPLoader extends EventTarget {
           // Port will change - release reader/writer and let the port become invalid
           await this.releaseReaderWriter();
 
-          this.logger.log(
+          this.logger.debug(
             `${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(
@@ -3760,7 +3873,7 @@ export class ESPLoader extends EventTarget {
       // Detect chip type
       await this.detectChip();
 
-      this.logger.log(`Reconnected to bootloader: ${this.chipName}`);
+      this.logger.debug(`Reconnected to bootloader: ${this.chipName}`);
     } catch (err) {
       // Ensure flag is reset on error
       this._isReconfiguring = false;
@@ -3803,7 +3916,7 @@ export class ESPLoader extends EventTarget {
 
     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`);
+      this.logger.debug(`${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)
@@ -3821,7 +3934,7 @@ export class ESPLoader extends EventTarget {
       // Wait for reset to complete and port to change
       await sleep(500);
 
-      this.logger.log(
+      this.logger.debug(
         `${this.chipName}: Port changed. Please select the bootloader port.`,
       );