tasmota-webserial-esptool 9.1.4 → 9.1.6

package/src/esp_loader.ts

@@ -42,6 +42,7 @@ import {
   USB_RAM_BLOCK,
   ChipFamily,
   ESP_ERASE_FLASH,
+  ESP_ERASE_REGION,
   ESP_READ_FLASH,
   CHIP_ERASE_TIMEOUT,
   FLASH_READ_TIMEOUT,
@@ -77,10 +78,10 @@ interface WebUSBSerialPort extends SerialPort {
 }
 
 export class ESPLoader extends EventTarget {
-  chipFamily!: ChipFamily;
-  chipName: string | null = null;
-  chipRevision: number | null = null;
-  chipVariant: string | null = null;
+  __chipFamily?: ChipFamily;
+  __chipName: string | null = null;
+  __chipRevision: number | null = null;
+  __chipVariant: string | null = null;
   _efuses = new Array(4).fill(0);
   _flashsize = 4 * 1024 * 1024;
   debug = false;
@@ -116,6 +117,55 @@ export class ESPLoader extends EventTarget {
     super();
   }
 
+  // Chip properties with parent delegation
+  get chipFamily(): ChipFamily {
+    return this._parent ? this._parent.chipFamily : this.__chipFamily!;
+  }
+
+  set chipFamily(value: ChipFamily) {
+    if (this._parent) {
+      this._parent.chipFamily = value;
+    } else {
+      this.__chipFamily = value;
+    }
+  }
+
+  get chipName(): string | null {
+    return this._parent ? this._parent.chipName : this.__chipName;
+  }
+
+  set chipName(value: string | null) {
+    if (this._parent) {
+      this._parent.chipName = value;
+    } else {
+      this.__chipName = value;
+    }
+  }
+
+  get chipRevision(): number | null {
+    return this._parent ? this._parent.chipRevision : this.__chipRevision;
+  }
+
+  set chipRevision(value: number | null) {
+    if (this._parent) {
+      this._parent.chipRevision = value;
+    } else {
+      this.__chipRevision = value;
+    }
+  }
+
+  get chipVariant(): string | null {
+    return this._parent ? this._parent.chipVariant : this.__chipVariant;
+  }
+
+  set chipVariant(value: string | null) {
+    if (this._parent) {
+      this._parent.chipVariant = value;
+    } else {
+      this.__chipVariant = value;
+    }
+  }
+
   private get _inputBuffer(): number[] {
     return this._parent ? this._parent._inputBuffer : this.__inputBuffer!;
   }
@@ -564,6 +614,21 @@ export class ESPLoader extends EventTarget {
     };
   }
 
+  /**
+   * Get MAC address from efuses
+   */
+  async getMacAddress(): Promise<string> {
+    if (!this._initializationSucceeded) {
+      throw new Error(
+        "getMacAddress() requires initialize() to have completed successfully",
+      );
+    }
+    const macBytes = this.macAddr(); // chip-family-aware
+    return macBytes
+      .map((b) => b.toString(16).padStart(2, "0").toUpperCase())
+      .join(":");
+  }
+
   /**
    * @name readLoop
    * Reads data from the input stream and places it in the inputBuffer
@@ -598,7 +663,13 @@ export class ESPLoader extends EventTarget {
       }
     } catch {
       this.logger.error("Read loop got disconnected");
+    } finally {
+      // Always reset reconfiguring flag when read loop ends
+      // This prevents "Cannot write during port reconfiguration" errors
+      // when the read loop dies unexpectedly
+      this._isReconfiguring = false;
     }
+
     // Disconnected!
     this.connected = false;
 
@@ -2559,50 +2630,43 @@ export class ESPLoader extends EventTarget {
       return;
     }
 
+    // Wait for pending writes to complete
     try {
-      // Wait for pending writes to complete
+      await this._writeChain;
+    } catch (err) {
+      this.logger.debug(`Pending write error during disconnect: ${err}`);
+    }
+
+    // Release persistent writer before closing
+    if (this._writer) {
       try {
-        await this._writeChain;
+        await this._writer.close();
+        this._writer.releaseLock();
       } catch (err) {
-        this.logger.debug(`Pending write error during disconnect: ${err}`);
+        this.logger.debug(`Writer close/release error: ${err}`);
       }
-
-      // Block new writes during disconnect
-      this._isReconfiguring = true;
-
-      // Release persistent writer before closing
-      if (this._writer) {
-        try {
-          await this._writer.close();
-          this._writer.releaseLock();
-        } catch (err) {
-          this.logger.debug(`Writer close/release error: ${err}`);
-        }
-        this._writer = undefined;
-      } else {
-        // No persistent writer exists, close stream directly
-        // This path is taken when no writes have been queued
-        try {
-          const writer = this.port.writable.getWriter();
-          await writer.close();
-          writer.releaseLock();
-        } catch (err) {
-          this.logger.debug(`Direct writer close error: ${err}`);
-        }
+      this._writer = undefined;
+    } else {
+      // No persistent writer exists, close stream directly
+      // This path is taken when no writes have been queued
+      try {
+        const writer = this.port.writable.getWriter();
+        await writer.close();
+        writer.releaseLock();
+      } catch (err) {
+        this.logger.debug(`Direct writer close error: ${err}`);
       }
-
-      await new Promise((resolve) => {
-        if (!this._reader) {
-          resolve(undefined);
-          return;
-        }
-        this.addEventListener("disconnect", resolve, { once: true });
-        this._reader!.cancel();
-      });
-      this.connected = false;
-    } finally {
-      this._isReconfiguring = false;
     }
+
+    await new Promise((resolve) => {
+      if (!this._reader) {
+        resolve(undefined);
+        return;
+      }
+      this.addEventListener("disconnect", resolve, { once: true });
+      this._reader!.cancel();
+    });
+    this.connected = false;
   }
 
   /**
@@ -2980,8 +3044,9 @@ export class ESPLoader extends EventTarget {
               newResp.set(packetData, resp.length);
               resp = newResp;
 
-              // Send acknowledgment after receiving maxInFlight bytes
-              // This unblocks the stub to send the next batch of packets
+              // Send acknowledgment when we've received maxInFlight bytes
+              // The stub sends packets until (num_sent - num_acked) >= max_in_flight
+              // We MUST wait for all packets before sending ACK
               const shouldAck =
                 resp.length >= chunkSize || // End of chunk
                 resp.length >= lastAckedLength + maxInFlight; // Received all packets
@@ -3225,10 +3290,55 @@ class EspStubLoader extends ESPLoader {
   }
 
   /**
-   * @name getEraseSize
-   * depending on flash chip model the erase may take this long (maybe longer!)
+   * @name eraseFlash
+   * Erase entire flash chip
    */
   async eraseFlash() {
     await this.checkCommand(ESP_ERASE_FLASH, [], 0, CHIP_ERASE_TIMEOUT);
   }
+
+  /**
+   * @name eraseRegion
+   * Erase a specific region of flash
+   */
+  async eraseRegion(offset: number, size: number) {
+    // Validate inputs
+    if (offset < 0) {
+      throw new Error(`Invalid offset: ${offset} (must be non-negative)`);
+    }
+    if (size < 0) {
+      throw new Error(`Invalid size: ${size} (must be non-negative)`);
+    }
+
+    // No-op for zero size
+    if (size === 0) {
+      this.logger.log("eraseRegion: size is 0, skipping erase");
+      return;
+    }
+
+    // Check for sector alignment
+    if (offset % FLASH_SECTOR_SIZE !== 0) {
+      throw new Error(
+        `Offset ${offset} (0x${offset.toString(16)}) is not aligned to flash sector size ${FLASH_SECTOR_SIZE} (0x${FLASH_SECTOR_SIZE.toString(16)})`,
+      );
+    }
+    if (size % FLASH_SECTOR_SIZE !== 0) {
+      throw new Error(
+        `Size ${size} (0x${size.toString(16)}) is not aligned to flash sector size ${FLASH_SECTOR_SIZE} (0x${FLASH_SECTOR_SIZE.toString(16)})`,
+      );
+    }
+
+    // Check for reasonable bounds (prevent wrapping in pack)
+    const maxValue = 0xffffffff; // 32-bit unsigned max
+    if (offset > maxValue) {
+      throw new Error(`Offset ${offset} exceeds maximum value ${maxValue}`);
+    }
+    if (size > maxValue) {
+      throw new Error(`Size ${size} exceeds maximum value ${maxValue}`);
+    }
+
+    const timeout = timeoutPerMb(ERASE_REGION_TIMEOUT_PER_MB, size);
+    const buffer = pack("<II", offset, size);
+    await this.checkCommand(ESP_ERASE_REGION, buffer, 0, timeout);
+  }
 }