tasmota-webserial-esptool 9.1.5 → 9.1.7

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,
@@ -613,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
@@ -647,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;
 
@@ -1256,7 +1278,9 @@ export class ESPLoader extends EventTarget {
       }
     }
 
-    // All strategies failed
+    // All strategies failed - reset abandon flag before throwing
+    this._abandonCurrentOperation = false;
+
     throw new Error(
       `Couldn't sync to ESP. Try resetting manually. Last error: ${lastError?.message}`,
     );
@@ -2608,50 +2632,51 @@ 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}`);
       }
+      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}`);
+      }
+    }
 
-      // 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}`);
-        }
+    await new Promise((resolve) => {
+      if (!this._reader) {
+        resolve(undefined);
+        return;
       }
+      this.addEventListener("disconnect", resolve, { once: true });
 
-      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;
-    }
+      // Only cancel if reader is still active
+      try {
+        this._reader.cancel();
+      } catch (err) {
+        this.logger.debug(`Reader cancel error: ${err}`);
+        // Reader already released, resolve immediately
+        resolve(undefined);
+      }
+    });
+    this.connected = false;
   }
 
   /**
@@ -3029,8 +3054,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
@@ -3274,10 +3300,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);
+  }
 }