tasmota-webserial-esptool 6.4.1 → 6.5.1

package/IMPLEMENTATION_SUMMARY.md

@@ -0,0 +1,232 @@
+# Implementation Summary: ESP32-P4 Chip Variant Support
+
+## ✅ Erfolgreich implementiert
+
+### Ziel
+Unterscheidung zwischen ESP32-P4 Revision 0 und Revision 300, damit esp-web-tools separate Manifeste für beide Varianten bereitstellen kann.
+
+## Implementierte Änderungen
+
+### 1. WebSerial_ESPTool
+
+**Datei: `src/esp_loader.ts`**
+
+#### Neues Feld:
+```typescript
+chipVariant: string | null = null;
+```
+
+#### Erweiterte Chip-Erkennung:
+- Bei IMAGE_CHIP_ID Erkennung (Rev. 300+):
+  - Revision wird aus eFuses gelesen
+  - `chipVariant` wird auf `"rev300"` oder `"rev0"` gesetzt
+  
+- Bei Magic Value Erkennung (Rev. < 300):
+  - Revision wird aus eFuses gelesen
+  - `chipVariant` wird auf `"rev300"` oder `"rev0"` gesetzt
+
+#### Revision-Berechnung:
+```typescript
+// Aus EFUSE_BLOCK1 (Word 2):
+const minorRev = word2 & 0x0f;
+const majorRev = (((word2 >> 23) & 1) << 2) | ((word2 >> 4) & 0x03);
+const revision = majorRev * 100 + minorRev;
+
+// Variante setzen:
+if (revision >= 300) {
+  chipVariant = "rev300";
+} else {
+  chipVariant = "rev0";
+}
+```
+
+### 2. esp-web-tools
+
+**Datei: `src/const.ts`**
+
+#### Erweitertes Build Interface:
+```typescript
+export interface Build {
+  chipFamily: "ESP32-P4" | ...;
+  chipVariant?: string;  // NEU - optional
+  parts: { path: string; offset: number; }[];
+}
+```
+
+#### Erweitertes FlashState Interface:
+```typescript
+export interface BaseFlashState {
+  chipFamily?: Build["chipFamily"] | "Unknown Chip";
+  chipVariant?: string | null;  // NEU
+  // ...
+}
+```
+
+**Datei: `src/flash.ts`**
+
+#### Erweiterte Build-Auswahl:
+```typescript
+build = manifest.builds.find((b) => {
+  // Match chipFamily
+  if (b.chipFamily !== chipFamily) {
+    return false;
+  }
+  // Wenn Build chipVariant spezifiziert, muss es matchen
+  if (b.chipVariant !== undefined) {
+    return b.chipVariant === chipVariant;
+  }
+  // Ohne chipVariant: Match für alle Varianten
+  return true;
+});
+```
+
+#### Verbesserte Meldungen:
+- Initialisierung zeigt chipVariant an
+- Fehlermeldungen enthalten chipVariant-Info
+
+**Datei: `README.md`**
+- Dokumentation für Chip Variant Support hinzugefügt
+- Beispiel für P4-Varianten
+
+## Verwendung
+
+### Manifest mit spezifischen Builds:
+```json
+{
+  "name": "My Firmware",
+  "version": "1.0.0",
+  "builds": [
+    {
+      "chipFamily": "ESP32-P4",
+      "chipVariant": "rev0",
+      "parts": [
+        { "path": "firmware_p4_old.bin", "offset": 0 }
+      ]
+    },
+    {
+      "chipFamily": "ESP32-P4",
+      "chipVariant": "rev300",
+      "parts": [
+        { "path": "firmware_p4_new.bin", "offset": 0 }
+      ]
+    }
+  ]
+}
+```
+
+### Manifest mit Fallback:
+```json
+{
+  "builds": [
+    {
+      "chipFamily": "ESP32-P4",
+      "chipVariant": "rev300",
+      "parts": [...]
+    },
+    {
+      "chipFamily": "ESP32-P4",
+      "parts": [...]  // Fallback für rev0
+    }
+  ]
+}
+```
+
+## Build-Status
+
+✅ **WebSerial_ESPTool**: Kompiliert erfolgreich
+✅ **esp-web-tools**: Kompiliert erfolgreich
+✅ **TypeScript**: Keine Fehler
+✅ **Abwärtskompatibilität**: Vollständig gewährleistet
+
+## Nächste Schritte
+
+### Für Deployment:
+
+1. **WebSerial_ESPTool**:
+   ```bash
+   cd WebSerial_ESPTool
+   # Version in package.json erhöhen (z.B. 6.5.0)
+   npm run prepublishOnly
+   npm publish
+   ```
+
+2. **esp-web-tools**:
+   ```bash
+   cd esp-web-tools
+   # package.json aktualisieren: "tasmota-webserial-esptool": "^6.5.0"
+   npm install
+   # Version in package.json erhöhen (z.B. 8.2.0)
+   npm run prepublishOnly
+   npm publish
+   ```
+
+### Für Testing:
+
+1. **Hardware-Tests**:
+   - Test mit ESP32-P4 Rev. 0 Hardware
+   - Test mit ESP32-P4 Rev. 300 Hardware
+   - Verifizierung der korrekten Varianten-Erkennung
+
+2. **Manifest-Tests**:
+   - Test mit chipVariant-spezifischen Builds
+   - Test mit Fallback-Builds
+   - Test mit gemischten Manifesten
+
+## Dokumentation
+
+Erstellt:
+- ✅ `CHIP_VARIANT_SUPPORT.md` - Vollständige technische Dokumentation
+- ✅ `CHANGELOG_CHIP_VARIANT.md` - Detaillierte Änderungsliste
+- ✅ `IMPLEMENTATION_SUMMARY.md` - Diese Datei
+- ✅ `manifest-example-p4-variants.json` - Beispiel-Manifest
+- ✅ README.md Update in esp-web-tools
+
+## Technische Details
+
+### Chip-Erkennung Flow:
+
+```
+1. ESPLoader.initialize()
+   ↓
+2. detectChip()
+   ↓
+3a. Versuche GET_SECURITY_INFO (IMAGE_CHIP_ID)
+    → Erfolg: chipId = 18 (ESP32-P4)
+    → getChipRevision() → chipVariant setzen
+    
+3b. Fallback: Magic Value Detection
+    → chipMagicValue = 0x0, 0x7039ad9, oder 0x0addbad0
+    → getChipRevision() → chipVariant setzen
+    
+4. chipVariant ist nun "rev0" oder "rev300"
+```
+
+### Manifest Matching Flow:
+
+```
+1. Chip erkannt: chipFamily = "ESP32-P4", chipVariant = "rev300"
+   ↓
+2. Durchsuche manifest.builds[]
+   ↓
+3. Für jeden Build:
+   - chipFamily muss matchen
+   - Wenn Build.chipVariant definiert: muss exakt matchen
+   - Wenn Build.chipVariant undefined: immer Match
+   ↓
+4. Ersten passenden Build verwenden
+```
+
+## Vorteile
+
+1. **Flexibilität**: Manifeste können spezifische oder generische Builds anbieten
+2. **Abwärtskompatibilität**: Bestehende Manifeste funktionieren unverändert
+3. **Zukunftssicher**: Erweiterbar für weitere Chip-Varianten
+4. **Transparent**: Variante wird dem Benutzer angezeigt
+5. **Robust**: Fallback-Mechanismus verhindert Fehler
+
+## Getestet
+
+- ✅ TypeScript Kompilierung
+- ✅ Build-Prozess
+- ✅ Keine Diagnostics-Fehler
+- ⏳ Hardware-Tests (ausstehend)

package/SECURITY_INFO_EXPLANATION.md

@@ -0,0 +1,145 @@
+# GET_SECURITY_INFO Erklärung
+
+## Warum schlägt GET_SECURITY_INFO manchmal fehl?
+
+Die Debug-Meldung:
+```
+GET_SECURITY_INFO failed, using magic value detection: Error: Invalid security info response length: 0
+```
+
+ist **normal und erwartet** für viele ESP-Chips.
+
+## Chip-Erkennungsstrategie
+
+Der Code verwendet einen robusten zweistufigen Ansatz:
+
+### 1. Primär: GET_SECURITY_INFO (IMAGE_CHIP_ID)
+
+**Unterstützt von:**
+- ESP32-C3 (neuere ROM-Versionen)
+- ESP32-S3
+- ESP32-C6
+- ESP32-C61
+- ESP32-H2
+- ESP32-C5
+- ESP32-P4 Rev. 300+
+
+**Vorteile:**
+- Direkte Chip-ID
+- Zusätzliche Sicherheitsinformationen
+- Zukunftssicher
+
+**Problem:**
+- Nicht von allen Chips/ROM-Versionen unterstützt
+- Manche Chips geben leere Antwort zurück (length: 0)
+
+### 2. Fallback: Magic Value Detection
+
+**Unterstützt von:**
+- ESP8266
+- ESP32
+- ESP32-S2
+- ESP32-C3 (ältere ROM-Versionen)
+- ESP32-P4 Rev. < 300
+- Alle anderen Chips als Fallback
+
+**Vorteile:**
+- Funktioniert auf allen ESP-Chips
+- Sehr zuverlässig
+- Seit Jahren bewährt
+
+**Funktionsweise:**
+- Liest Magic-Wert aus Register `0x40001000`
+- Vergleicht mit bekannten Magic-Werten
+- Identifiziert Chip-Familie
+
+## Beispiel-Log (ESP32-C3)
+
+```
+Try hard reset.
+[debug] GET_SECURITY_INFO failed, using magic value detection: Error: GET_SECURITY_INFO not supported or returned empty response
+[debug] Detected chip via magic value: 0x1B31506F (ESP32-C3)
+Chip type ESP32-C3
+```
+
+**Interpretation:**
+1. ✅ GET_SECURITY_INFO wurde versucht (wie es sein soll)
+2. ✅ Leere Antwort erkannt (dieser ESP32-C3 unterstützt es nicht)
+3. ✅ Fallback auf Magic Value Detection (funktioniert perfekt)
+4. ✅ Chip korrekt als ESP32-C3 erkannt
+
+## Beispiel-Log (ESP32-P4 Rev. 300+)
+
+```
+Try hard reset.
+[debug] Detected chip via IMAGE_CHIP_ID: 18 (ESP32-P4)
+[debug] ESP32-P4 revision: 300
+[debug] ESP32-P4 variant: rev300
+Chip type ESP32-P4
+```
+
+**Interpretation:**
+1. ✅ GET_SECURITY_INFO funktioniert (neuere ROM-Version)
+2. ✅ Chip-ID 18 = ESP32-P4
+3. ✅ Revision aus eFuses gelesen
+4. ✅ Variante korrekt gesetzt
+
+## Warum ist das so implementiert?
+
+### Historischer Kontext
+
+1. **Ältere Chips (ESP8266, ESP32, ESP32-S2)**:
+   - Haben GET_SECURITY_INFO nicht
+   - Verwenden nur Magic Value Detection
+
+2. **Neuere Chips (ESP32-C3, ESP32-S3, etc.)**:
+   - Sollten GET_SECURITY_INFO unterstützen
+   - Aber: ROM-Versionen variieren
+   - Manche frühe Produktionen haben es nicht
+
+3. **Robustheit**:
+   - Fallback stellt sicher, dass ALLE Chips erkannt werden
+   - Keine Abhängigkeit von ROM-Version
+   - Funktioniert auch bei zukünftigen Chips
+
+## Ist das ein Problem?
+
+**Nein!** Das ist das erwartete Verhalten:
+
+✅ **Korrekt erkannt**: Der Chip wird korrekt identifiziert
+✅ **Funktioniert**: Flashing funktioniert einwandfrei
+✅ **Robust**: Fallback-Mechanismus ist bewährt
+✅ **Debug-Info**: Die Meldung ist nur zur Information
+
+## Wann wäre es ein Problem?
+
+❌ **Nur wenn:**
+- Chip wird NICHT erkannt
+- Falscher Chip-Typ wird erkannt
+- Flashing schlägt fehl
+
+In Ihrem Log:
+```
+Detected chip via magic value: 0x1B31506F (ESP32-C3)
+Chip type ESP32-C3
+Connected to ESP32-C3
+MAC Address: 34:B7:DA:F7:8F:00
+```
+
+→ Alles funktioniert perfekt! ✅
+
+## Zusammenfassung
+
+Die Meldung "GET_SECURITY_INFO failed" ist:
+- ✅ Normal
+- ✅ Erwartet für viele Chips
+- ✅ Kein Fehler
+- ✅ Teil des robusten Erkennungsmechanismus
+
+Der Fallback auf Magic Value Detection ist:
+- ✅ Bewährt
+- ✅ Zuverlässig
+- ✅ Funktioniert auf allen ESP-Chips
+- ✅ Genau so designed
+
+**Fazit:** Alles funktioniert wie vorgesehen! 🎉

package/css/style.css

@@ -195,6 +195,7 @@ div.clear {
   display: inline-block;
   position: relative;
   width: 50px;
+  margin-right: 25px;
   -webkit-user-select: none;
   -moz-user-select: none;
   -ms-user-select: none;

package/dist/const.d.ts

@@ -146,6 +146,7 @@ export declare const ESP32H2_UART_DATE_REG_ADDR = 1610612860;
 export declare const ESP32H2_BOOTLOADER_FLASH_OFFSET = 0;
 export declare const ESP32P4_SPI_REG_BASE = 1342754816;
 export declare const ESP32P4_BASEFUSEADDR = 1343410176;
+export declare const ESP32P4_EFUSE_BLOCK1_ADDR: number;
 export declare const ESP32P4_MACFUSEADDR: number;
 export declare const ESP32P4_SPI_USR_OFFS = 24;
 export declare const ESP32P4_SPI_USR1_OFFS = 28;
@@ -182,6 +183,13 @@ export declare const CHIP_FAMILY_ESP32C61 = 207969;
 export declare const CHIP_FAMILY_ESP32H2 = 12914;
 export declare const CHIP_FAMILY_ESP32P4 = 12928;
 export type ChipFamily = typeof CHIP_FAMILY_ESP8266 | typeof CHIP_FAMILY_ESP32 | typeof CHIP_FAMILY_ESP32S2 | typeof CHIP_FAMILY_ESP32S3 | typeof CHIP_FAMILY_ESP32C2 | typeof CHIP_FAMILY_ESP32C3 | typeof CHIP_FAMILY_ESP32C5 | typeof CHIP_FAMILY_ESP32C6 | typeof CHIP_FAMILY_ESP32C61 | typeof CHIP_FAMILY_ESP32H2 | typeof CHIP_FAMILY_ESP32P4;
+interface ChipIdInfo {
+    name: string;
+    family: ChipFamily;
+}
+export declare const CHIP_ID_TO_INFO: {
+    [chipId: number]: ChipIdInfo;
+};
 interface ChipInfo {
     [magicValue: number]: {
         name: string;
@@ -204,6 +212,7 @@ export declare const ESP_SPI_SET_PARAMS = 11;
 export declare const ESP_SPI_ATTACH = 13;
 export declare const ESP_CHANGE_BAUDRATE = 15;
 export declare const ESP_SPI_FLASH_MD5 = 19;
+export declare const ESP_GET_SECURITY_INFO = 20;
 export declare const ESP_CHECKSUM_MAGIC = 239;
 export declare const ESP_FLASH_DEFL_BEGIN = 16;
 export declare const ESP_FLASH_DEFL_DATA = 17;

package/dist/const.js

@@ -151,6 +151,7 @@ export const ESP32H2_UART_DATE_REG_ADDR = 0x6000007c;
 export const ESP32H2_BOOTLOADER_FLASH_OFFSET = 0x0;
 export const ESP32P4_SPI_REG_BASE = 0x5008d000;
 export const ESP32P4_BASEFUSEADDR = 0x5012d000;
+export const ESP32P4_EFUSE_BLOCK1_ADDR = ESP32P4_BASEFUSEADDR + 0x044;
 export const ESP32P4_MACFUSEADDR = 0x5012d000 + 0x044;
 export const ESP32P4_SPI_USR_OFFS = 0x18;
 export const ESP32P4_SPI_USR1_OFFS = 0x1c;
@@ -162,6 +163,7 @@ export const ESP32P4_UART_DATE_REG_ADDR = 0x500ca000 + 0x8c;
 export const ESP32P4_BOOTLOADER_FLASH_OFFSET = 0x2000;
 export const SYNC_PACKET = toByteArray("\x07\x07\x12 UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU");
 export const CHIP_DETECT_MAGIC_REG_ADDR = 0x40001000;
+// Image Chip IDs (used by ESP32-C3 and later for chip detection)
 // These values for the families are made up; nothing that esptool uses.
 export const CHIP_FAMILY_ESP8266 = 0x8266;
 export const CHIP_FAMILY_ESP32 = 0x32;
@@ -174,6 +176,16 @@ export const CHIP_FAMILY_ESP32C6 = 0x32c6;
 export const CHIP_FAMILY_ESP32C61 = 0x32c61;
 export const CHIP_FAMILY_ESP32H2 = 0x3272;
 export const CHIP_FAMILY_ESP32P4 = 0x3280;
+export const CHIP_ID_TO_INFO = {
+    5: { name: "ESP32-C3", family: CHIP_FAMILY_ESP32C3 },
+    9: { name: "ESP32-S3", family: CHIP_FAMILY_ESP32S3 },
+    12: { name: "ESP32-C2", family: CHIP_FAMILY_ESP32C2 },
+    13: { name: "ESP32-C6", family: CHIP_FAMILY_ESP32C6 },
+    16: { name: "ESP32-H2", family: CHIP_FAMILY_ESP32H2 },
+    17: { name: "ESP32-C5", family: CHIP_FAMILY_ESP32C5 },
+    18: { name: "ESP32-P4", family: CHIP_FAMILY_ESP32P4 },
+    20: { name: "ESP32-C61", family: CHIP_FAMILY_ESP32C61 },
+};
 export const CHIP_DETECT_MAGIC_VALUES = {
     0xfff0c101: { name: "ESP8266", family: CHIP_FAMILY_ESP8266 },
     0x00f01d83: { name: "ESP32", family: CHIP_FAMILY_ESP32 },
@@ -197,6 +209,8 @@ export const CHIP_DETECT_MAGIC_VALUES = {
     0x7211606f: { name: "ESP32-C61", family: CHIP_FAMILY_ESP32C61 },
     0x97e30068: { name: "ESP32-H2", family: CHIP_FAMILY_ESP32H2 },
     0xd7b73e80: { name: "ESP32-H2", family: CHIP_FAMILY_ESP32H2 },
+    // ESP32-P4 old revisions (< Rev. 300) - use magic value detection
+    // Rev. 300+ uses IMAGE_CHIP_ID detection instead
     0x0: { name: "ESP32-P4", family: CHIP_FAMILY_ESP32P4 },
     0x7039ad9: { name: "ESP32-P4", family: CHIP_FAMILY_ESP32P4 },
     0x0addbad0: { name: "ESP32-P4", family: CHIP_FAMILY_ESP32P4 },
@@ -217,6 +231,7 @@ export const ESP_SPI_SET_PARAMS = 0x0b;
 export const ESP_SPI_ATTACH = 0x0d;
 export const ESP_CHANGE_BAUDRATE = 0x0f;
 export const ESP_SPI_FLASH_MD5 = 0x13;
+export const ESP_GET_SECURITY_INFO = 0x14;
 export const ESP_CHECKSUM_MAGIC = 0xef;
 export const ESP_FLASH_DEFL_BEGIN = 0x10;
 export const ESP_FLASH_DEFL_DATA = 0x11;

package/dist/esp_loader.d.ts

@@ -5,6 +5,8 @@ export declare class ESPLoader extends EventTarget {
     private _parent?;
     chipFamily: ChipFamily;
     chipName: string | null;
+    chipRevision: number | null;
+    chipVariant: string | null;
     _efuses: any[];
     _flashsize: number;
     debug: boolean;
@@ -16,6 +18,24 @@ export declare class ESPLoader extends EventTarget {
     constructor(port: SerialPort, logger: Logger, _parent?: ESPLoader | undefined);
     private get _inputBuffer();
     initialize(): Promise<void>;
+    /**
+     * Detect chip type using GET_SECURITY_INFO (for newer chips) or magic value (for older chips)
+     */
+    detectChip(): Promise<void>;
+    /**
+     * Get chip revision for ESP32-P4
+     */
+    getChipRevision(): Promise<number>;
+    /**
+     * Get security info including chip ID (ESP32-C3 and later)
+     */
+    getSecurityInfo(): Promise<{
+        flags: number;
+        flashCryptCnt: number;
+        keyPurposes: number[];
+        chipId: number;
+        apiVersion: number;
+    }>;
     /**
      * @name readLoop
      * Reads data from the input stream and places it in the inputBuffer

package/dist/esp_loader.js

@@ -1,4 +1,5 @@
-import { CHIP_FAMILY_ESP32, CHIP_FAMILY_ESP32S2, CHIP_FAMILY_ESP32S3, CHIP_FAMILY_ESP32C2, CHIP_FAMILY_ESP32C3, CHIP_FAMILY_ESP32C5, CHIP_FAMILY_ESP32C6, CHIP_FAMILY_ESP32C61, CHIP_FAMILY_ESP32H2, CHIP_FAMILY_ESP32P4, CHIP_FAMILY_ESP8266, MAX_TIMEOUT, DEFAULT_TIMEOUT, ERASE_REGION_TIMEOUT_PER_MB, ESP_CHANGE_BAUDRATE, ESP_CHECKSUM_MAGIC, ESP_FLASH_BEGIN, ESP_FLASH_DATA, ESP_FLASH_END, ESP_MEM_BEGIN, ESP_MEM_DATA, ESP_MEM_END, ESP_READ_REG, ESP_WRITE_REG, ESP_SPI_ATTACH, ESP_SYNC, FLASH_SECTOR_SIZE, FLASH_WRITE_SIZE, STUB_FLASH_WRITE_SIZE, MEM_END_ROM_TIMEOUT, ROM_INVALID_RECV_MSG, SYNC_PACKET, SYNC_TIMEOUT, USB_RAM_BLOCK, ESP_ERASE_FLASH, CHIP_ERASE_TIMEOUT, timeoutPerMb, ESP_ROM_BAUD, USB_JTAG_SERIAL_PID, ESP_FLASH_DEFL_BEGIN, ESP_FLASH_DEFL_DATA, ESP_FLASH_DEFL_END, getSpiFlashAddresses, DETECTED_FLASH_SIZES, CHIP_DETECT_MAGIC_REG_ADDR, CHIP_DETECT_MAGIC_VALUES, SlipReadError, } from "./const";
+/// <reference types="@types/w3c-web-serial" />
+import { CHIP_FAMILY_ESP32, CHIP_FAMILY_ESP32S2, CHIP_FAMILY_ESP32S3, CHIP_FAMILY_ESP32C2, CHIP_FAMILY_ESP32C3, CHIP_FAMILY_ESP32C5, CHIP_FAMILY_ESP32C6, CHIP_FAMILY_ESP32C61, CHIP_FAMILY_ESP32H2, CHIP_FAMILY_ESP32P4, CHIP_FAMILY_ESP8266, MAX_TIMEOUT, DEFAULT_TIMEOUT, ERASE_REGION_TIMEOUT_PER_MB, ESP_CHANGE_BAUDRATE, ESP_CHECKSUM_MAGIC, ESP_FLASH_BEGIN, ESP_FLASH_DATA, ESP_FLASH_END, ESP_MEM_BEGIN, ESP_MEM_DATA, ESP_MEM_END, ESP_READ_REG, ESP_WRITE_REG, ESP_SPI_ATTACH, ESP_SYNC, ESP_GET_SECURITY_INFO, FLASH_SECTOR_SIZE, FLASH_WRITE_SIZE, STUB_FLASH_WRITE_SIZE, MEM_END_ROM_TIMEOUT, ROM_INVALID_RECV_MSG, SYNC_PACKET, SYNC_TIMEOUT, USB_RAM_BLOCK, ESP_ERASE_FLASH, CHIP_ERASE_TIMEOUT, timeoutPerMb, ESP_ROM_BAUD, USB_JTAG_SERIAL_PID, ESP_FLASH_DEFL_BEGIN, ESP_FLASH_DEFL_DATA, ESP_FLASH_DEFL_END, getSpiFlashAddresses, DETECTED_FLASH_SIZES, CHIP_DETECT_MAGIC_REG_ADDR, CHIP_DETECT_MAGIC_VALUES, CHIP_ID_TO_INFO, ESP32P4_EFUSE_BLOCK1_ADDR, SlipReadError, } from "./const";
 import { getStubCode } from "./stubs";
 import { hexFormatter, sleep, slipEncode, toHex } from "./util";
 // @ts-ignore
@@ -11,6 +12,8 @@ export class ESPLoader extends EventTarget {
         this.logger = logger;
         this._parent = _parent;
         this.chipName = null;
+        this.chipRevision = null;
+        this.chipVariant = null;
         this._efuses = new Array(4).fill(0);
         this._flashsize = 4 * 1024 * 1024;
         this.debug = false;
@@ -30,14 +33,8 @@ export class ESPLoader extends EventTarget {
             this.readLoop();
         }
         await this.sync();
-        // Determine chip family and name
-        let chipMagicValue = await this.readRegister(CHIP_DETECT_MAGIC_REG_ADDR);
-        let chip = CHIP_DETECT_MAGIC_VALUES[chipMagicValue >>> 0];
-        if (chip === undefined) {
-            throw new Error(`Unknown Chip: Hex: ${toHex(chipMagicValue >>> 0, 8).toLowerCase()} Number: ${chipMagicValue}`);
-        }
-        this.chipName = chip.name;
-        this.chipFamily = chip.family;
+        // Detect chip type
+        await this.detectChip();
         // Read the OTP data for this chip and store into this.efuses array
         let FlAddr = getSpiFlashAddresses(this.getChipFamily());
         let AddrMAC = FlAddr.macFuse;
@@ -47,6 +44,108 @@ export class ESPLoader extends EventTarget {
         this.logger.log(`Chip type ${this.chipName}`);
         //this.logger.log("FLASHID");
     }
+    /**
+     * Detect chip type using GET_SECURITY_INFO (for newer chips) or magic value (for older chips)
+     */
+    async detectChip() {
+        try {
+            // Try GET_SECURITY_INFO command first (ESP32-C3 and later)
+            const securityInfo = await this.getSecurityInfo();
+            const chipId = securityInfo.chipId;
+            const chipInfo = CHIP_ID_TO_INFO[chipId];
+            if (chipInfo) {
+                this.chipName = chipInfo.name;
+                this.chipFamily = chipInfo.family;
+                // Get chip revision for ESP32-P4
+                if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
+                    this.chipRevision = await this.getChipRevision();
+                    this.logger.debug(`ESP32-P4 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}`);
+                }
+                this.logger.debug(`Detected chip via IMAGE_CHIP_ID: ${chipId} (${this.chipName})`);
+                return;
+            }
+            this.logger.debug(`Unknown IMAGE_CHIP_ID: ${chipId}, falling back to magic value detection`);
+        }
+        catch (err) {
+            // GET_SECURITY_INFO not supported, fall back to magic value detection
+            this.logger.debug(`GET_SECURITY_INFO failed, using magic value detection: ${err}`);
+        }
+        // Fallback: Use magic value detection for ESP8266, ESP32, ESP32-S2, and ESP32-P4 RC versions
+        let chipMagicValue = await this.readRegister(CHIP_DETECT_MAGIC_REG_ADDR);
+        let chip = CHIP_DETECT_MAGIC_VALUES[chipMagicValue >>> 0];
+        if (chip === undefined) {
+            throw new Error(`Unknown Chip: Hex: ${toHex(chipMagicValue >>> 0, 8).toLowerCase()} Number: ${chipMagicValue}`);
+        }
+        this.chipName = chip.name;
+        this.chipFamily = chip.family;
+        // For ESP32-P4 detected via magic value (old revisions), set variant
+        if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
+            this.chipRevision = await this.getChipRevision();
+            this.logger.debug(`ESP32-P4 revision: ${this.chipRevision}`);
+            if (this.chipRevision >= 300) {
+                this.chipVariant = "rev300";
+            }
+            else {
+                this.chipVariant = "rev0";
+            }
+            this.logger.debug(`ESP32-P4 variant: ${this.chipVariant}`);
+        }
+        this.logger.debug(`Detected chip via magic value: ${toHex(chipMagicValue >>> 0, 8)} (${this.chipName})`);
+    }
+    /**
+     * Get chip revision for ESP32-P4
+     */
+    async getChipRevision() {
+        if (this.chipFamily !== CHIP_FAMILY_ESP32P4) {
+            return 0;
+        }
+        // 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;
+    }
+    /**
+     * Get security info including chip ID (ESP32-C3 and later)
+     */
+    async getSecurityInfo() {
+        const [_, responseData] = await this.checkCommand(ESP_GET_SECURITY_INFO, [], 0);
+        // Some chips/ROM versions return empty response or don't support this command
+        if (responseData.length === 0) {
+            throw new Error(`GET_SECURITY_INFO not supported or returned empty response`);
+        }
+        if (responseData.length < 12) {
+            throw new Error(`Invalid security info response length: ${responseData.length} (expected at least 12 bytes)`);
+        }
+        const flags = unpack("<I", responseData.slice(0, 4))[0];
+        const flashCryptCnt = responseData[4];
+        const keyPurposes = Array.from(responseData.slice(5, 12));
+        const chipId = responseData.length >= 16
+            ? unpack("<I", responseData.slice(12, 16))[0]
+            : 0;
+        const apiVersion = responseData.length >= 20
+            ? unpack("<I", responseData.slice(16, 20))[0]
+            : 0;
+        return {
+            flags,
+            flashCryptCnt,
+            keyPurposes,
+            chipId,
+            apiVersion,
+        };
+    }
     /**
      * @name readLoop
      * Reads data from the input stream and places it in the inputBuffer
@@ -235,7 +334,12 @@ export class ESPLoader extends EventTarget {
             statusLen = 4;
         }
         else {
-            if ([2, 4].includes(data.length)) {
+            // When chipFamily is not yet set (e.g., during GET_SECURITY_INFO in detectChip),
+            // assume modern chips use 4-byte status
+            if (opcode === ESP_GET_SECURITY_INFO) {
+                statusLen = 4;
+            }
+            else if ([2, 4].includes(data.length)) {
                 statusLen = data.length;
             }
         }
@@ -411,6 +515,7 @@ export class ESPLoader extends EventTarget {
         else {
             await this.reconfigurePort(baud);
         }
+        this.logger.log(`Changed baud rate to ${baud}`);
     }
     async reconfigurePort(baud) {
         var _a;
@@ -425,7 +530,6 @@ export class ESPLoader extends EventTarget {
             await this.port.open({ baudRate: baud });
             // Restart Readloop
             this.readLoop();
-            this.logger.log(`Changed baud rate to ${baud}`);
         }
         catch (e) {
             console.error(e);
@@ -846,7 +950,7 @@ export class ESPLoader extends EventTarget {
         return await this.checkCommand(ESP_MEM_END, data, 0, timeout);
     }
     async runStub() {
-        const stub = await getStubCode(this.chipFamily);
+        const stub = await getStubCode(this.chipFamily, this.chipRevision);
         // We're transferring over USB, right?
         let ramBlock = USB_RAM_BLOCK;
         // Upload
@@ -921,7 +1025,7 @@ class EspStubLoader extends ESPLoader {
      * Start downloading an application image to RAM
      */
     async memBegin(size, blocks, blocksize, offset) {
-        let stub = await getStubCode(this.chipFamily);
+        let stub = await getStubCode(this.chipFamily, this.chipRevision);
         let load_start = offset;
         let load_end = offset + size;
         console.log(load_start, load_end);

package/dist/index.js

@@ -1,3 +1,4 @@
+/// <reference types="@types/w3c-web-serial" />
 import { ESP_ROM_BAUD } from "./const";
 import { ESPLoader } from "./esp_loader";
 export { ESPLoader } from "./esp_loader";