diff --git a/go.mod b/go.mod index ab0f92e..b9b696f 100644 --- a/go.mod +++ b/go.mod @@ -1,15 +1,14 @@ module tinygo.org/x/espflasher -go 1.22 +go 1.25.0 require ( github.com/stretchr/testify v1.7.0 - go.bug.st/serial v1.6.2 - golang.org/x/sys v0.0.0-20220829200755-d48e67d00261 + go.bug.st/serial v1.8.0 + golang.org/x/sys v0.43.0 ) require ( - github.com/creack/goselect v0.1.2 // indirect github.com/davecgh/go-spew v1.1.0 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c // indirect diff --git a/go.sum b/go.sum index 95d3bb7..bd86541 100644 --- a/go.sum +++ b/go.sum @@ -1,5 +1,3 @@ -github.com/creack/goselect v0.1.2 h1:2DNy14+JPjRBgPzAd1thbQp4BSIihxcBf0IXhQXDRa0= -github.com/creack/goselect v0.1.2/go.mod h1:a/NhLweNvqIYMuxcMOuWY516Cimucms3DglDzQP3hKY= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= @@ -7,10 +5,10 @@ github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZN github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -go.bug.st/serial v1.6.2 h1:kn9LRX3sdm+WxWKufMlIRndwGfPWsH1/9lCWXQCasq8= -go.bug.st/serial v1.6.2/go.mod h1:UABfsluHAiaNI+La2iESysd9Vetq7VRdpxvjx7CmmOE= -golang.org/x/sys v0.0.0-20220829200755-d48e67d00261 h1:v6hYoSR9T5oet+pMXwUWkbiVqx/63mlHjefrHmxwfeY= -golang.org/x/sys v0.0.0-20220829200755-d48e67d00261/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +go.bug.st/serial v1.8.0 h1:ZtnmN8aYXtPlTghwSvDWPHKBHL9TM6oFDa+KpSn4SQE= +go.bug.st/serial v1.8.0/go.mod h1:d0MmS16Qt9b1m06yoYRNUXhRRTJV5Qg2S5EKqQtnayQ= +golang.org/x/sys v0.43.0 h1:Rlag2XtaFTxp19wS8MXlJwTvoh8ArU6ezoyFsMyCTNI= +golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo= diff --git a/pkg/espflasher/errors.go b/pkg/espflasher/errors.go index b06c249..b8b6183 100644 --- a/pkg/espflasher/errors.go +++ b/pkg/espflasher/errors.go @@ -4,7 +4,7 @@ import "fmt" // Error types for ESP flash operations. -// CommandError is returned when the ROM bootloader returns a non-zero status. +// CommandError is returned when the device returns a non-zero status. type CommandError struct { OpCode byte Status byte @@ -12,27 +12,66 @@ type CommandError struct { } func (e *CommandError) Error() string { + // The v1.1.0+ esp-flasher-stub uses 16-bit big-endian response codes + // where the high byte (Status) encodes the error category and the low + // byte (ErrCode) is always 0x00. Earlier ROM bootloaders use Status=1 + // with the low byte as the detailed error code. desc := "unknown error" - switch e.ErrCode { - case 0x05: - desc = "received message is invalid" - case 0x06: - desc = "failed to act on received message" - case 0x07: - desc = "invalid CRC in message" - case 0x08: - desc = "flash write error" - case 0x09: - desc = "flash read error" - case 0x0A: - desc = "flash read length error" - case 0x0B: - desc = "deflate error" + switch { + // ROM bootloader error codes (Status == 0x01, error in ErrCode) + case e.Status == 0x01: + switch e.ErrCode { + case 0x05: + desc = "received message is invalid" + case 0x06: + desc = "failed to act on received message" + case 0x07: + desc = "invalid CRC in message" + case 0x08: + desc = "flash write error" + case 0x09: + desc = "flash read error" + case 0x0A: + desc = "flash read length error" + case 0x0B: + desc = "deflate error" + } + // Stub response codes (16-bit big-endian, ErrCode == 0x00) + case e.Status == 0xC0 && e.ErrCode == 0x00: + desc = "bad data length" + case e.Status == 0xC1 && e.ErrCode == 0x00: + desc = "bad data checksum" + case e.Status == 0xC2 && e.ErrCode == 0x00: + desc = "bad block size" + case e.Status == 0xC3 && e.ErrCode == 0x00: + desc = "invalid command" + case e.Status == 0xC4 && e.ErrCode == 0x00: + desc = "SPI operation failed" + case e.Status == 0xC5 && e.ErrCode == 0x00: + desc = "SPI unlock failed" + case e.Status == 0xC6 && e.ErrCode == 0x00: + desc = "not in flash mode" + case e.Status == 0xC7 && e.ErrCode == 0x00: + desc = "inflate error" + case e.Status == 0xC8 && e.ErrCode == 0x00: + desc = "not enough data" + case e.Status == 0xC9 && e.ErrCode == 0x00: + desc = "too much data" + case e.Status == 0xFF && e.ErrCode == 0x00: + desc = "command not implemented" } return fmt.Sprintf("command 0x%02X failed: status=0x%02X error=0x%02X (%s)", e.OpCode, e.Status, e.ErrCode, desc) } +// IsRetryable returns true if the error indicates a transient serial data +// loss (bad length or checksum) rather than a persistent device-side failure. +// These errors mean the SLIP frame was corrupted during UART transmission +// but the stub is in a clean state and ready for a resend. +func (e *CommandError) IsRetryable() bool { + return (e.Status == 0xC0 || e.Status == 0xC1) && e.ErrCode == 0x00 +} + // TimeoutError is returned when a response is not received within the timeout. type TimeoutError struct { Op string diff --git a/pkg/espflasher/errors_test.go b/pkg/espflasher/errors_test.go index 735f036..c07c74f 100644 --- a/pkg/espflasher/errors_test.go +++ b/pkg/espflasher/errors_test.go @@ -8,24 +8,39 @@ import ( func TestCommandError(t *testing.T) { tests := []struct { name string + status byte errCode byte contains string }{ - {"invalid message", 0x05, "received message is invalid"}, - {"failed to act", 0x06, "failed to act on received message"}, - {"invalid CRC", 0x07, "invalid CRC in message"}, - {"flash write", 0x08, "flash write error"}, - {"flash read", 0x09, "flash read error"}, - {"flash read length", 0x0A, "flash read length error"}, - {"deflate error", 0x0B, "deflate error"}, - {"unknown error", 0xFF, "unknown error"}, + // ROM bootloader error codes + {"invalid message", 0x01, 0x05, "received message is invalid"}, + {"failed to act", 0x01, 0x06, "failed to act on received message"}, + {"invalid CRC", 0x01, 0x07, "invalid CRC in message"}, + {"flash write", 0x01, 0x08, "flash write error"}, + {"flash read", 0x01, 0x09, "flash read error"}, + {"flash read length", 0x01, 0x0A, "flash read length error"}, + {"deflate error", 0x01, 0x0B, "deflate error"}, + {"unknown ROM error", 0x01, 0xFF, "unknown error"}, + // Stub response codes (v1.1.0+) + {"bad data length", 0xC0, 0x00, "bad data length"}, + {"bad data checksum", 0xC1, 0x00, "bad data checksum"}, + {"bad block size", 0xC2, 0x00, "bad block size"}, + {"invalid command", 0xC3, 0x00, "invalid command"}, + {"SPI op failed", 0xC4, 0x00, "SPI operation failed"}, + {"SPI unlock failed", 0xC5, 0x00, "SPI unlock failed"}, + {"not in flash mode", 0xC6, 0x00, "not in flash mode"}, + {"inflate error", 0xC7, 0x00, "inflate error"}, + {"not enough data", 0xC8, 0x00, "not enough data"}, + {"too much data", 0xC9, 0x00, "too much data"}, + {"cmd not implemented", 0xFF, 0x00, "command not implemented"}, + {"unknown stub error", 0xCF, 0x00, "unknown error"}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { err := &CommandError{ OpCode: 0x02, - Status: 0x01, + Status: tt.status, ErrCode: tt.errCode, } msg := err.Error() @@ -55,6 +70,29 @@ func TestCommandErrorFormat(t *testing.T) { } } +func TestCommandErrorIsRetryable(t *testing.T) { + tests := []struct { + name string + status byte + errCode byte + retryable bool + }{ + {"bad data length", 0xC0, 0x00, true}, + {"bad data checksum", 0xC1, 0x00, true}, + {"SPI op failed", 0xC4, 0x00, false}, + {"inflate error", 0xC7, 0x00, false}, + {"ROM error", 0x01, 0x05, false}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := &CommandError{Status: tt.status, ErrCode: tt.errCode} + if err.IsRetryable() != tt.retryable { + t.Errorf("IsRetryable() = %v, want %v", err.IsRetryable(), tt.retryable) + } + }) + } +} + func TestTimeoutError(t *testing.T) { err := &TimeoutError{Op: "sync"} msg := err.Error() diff --git a/pkg/espflasher/flasher.go b/pkg/espflasher/flasher.go index 2c52ae3..7442599 100644 --- a/pkg/espflasher/flasher.go +++ b/pkg/espflasher/flasher.go @@ -5,6 +5,7 @@ import ( "compress/zlib" "crypto/md5" "encoding/hex" + "errors" "fmt" "io" "net" @@ -741,7 +742,7 @@ func (f *Flasher) flashCompressed(data []byte, offset uint32, progress ProgressF if err := f.retryFlashBlock(seq, numBlocks, func() error { return f.conn.flashDeflData(block, seq) }); err != nil { - return err + return fmt.Errorf("flash block %d of %d: %w", seq, numBlocks, err) } sent += blockLen @@ -759,9 +760,10 @@ func (f *Flasher) flashCompressed(data []byte, offset uint32, progress ProgressF // bootloader upon receiving it, which can interfere with flash operations. // esptool also skips this for ROM: "skip sending flash_finish to ROM loader, // as it causes the loader to exit and run user code." - // For the stub, the end command acts as a write barrier: the stub ACKs each - // block on receive but writes to flash asynchronously, so the end command - // ensures the last block is actually written before we proceed. + // For the stub, the end command acts as a write barrier: the stub uses + // double-buffering (ACKs each block immediately, writes to flash as a + // post-process), so the end command ensures the last block's flash write + // has completed before we proceed. if f.conn.isStub() { if err := f.conn.flashDeflEnd(false); err != nil { return err @@ -816,7 +818,7 @@ func (f *Flasher) flashUncompressed(data []byte, offset uint32, progress Progres if err := f.retryFlashBlock(seq, numBlocks, func() error { return f.conn.flashData(block, seq) }); err != nil { - return err + return fmt.Errorf("flash block %d of %d: %w", seq, numBlocks, err) } sent += blockLen @@ -882,7 +884,7 @@ func (f *Flasher) EraseFlash(progress ProgressFunc) error { return &UnsupportedCommandError{Command: "erase flash (requires stub)"} } - f.logf("Erasing entire flash...") + f.logf("Erasing flash...") if progress == nil { if err := f.conn.eraseFlash(); err != nil { return err @@ -928,17 +930,19 @@ func (f *Flasher) EraseRegion(offset, size uint32, progress ProgressFunc) error }) } -// flashBlockRetries is the number of attempts for each flash data block write. -// Transient serial errors (SLIP timeouts, framing glitches, USB CDC buffer -// drops) are common during flashing and typically resolve on retry. The stub -// handles duplicate sequence numbers gracefully, so resending an -// already-processed block is safe. -const flashBlockRetries = 3 - // eraseProgressInterval is the tick interval used by tickErase when reporting // synthetic erase progress via EraseFlash and EraseRegion. const eraseProgressInterval = 500 * time.Millisecond +// flashBlockRetries is the number of attempts for each flash data block write. +// At high baud rates (460800+), USB-UART bridges occasionally lose bytes during +// transmission, causing the stub to receive a truncated or corrupted SLIP frame. +// The stub detects this (bad data length or bad checksum) and responds with a +// clean error, leaving it ready for a resend. We retry only for these +// serial-integrity errors; device-side failures (SPI errors, inflate errors) +// are not retried. +const flashBlockRetries = 3 + // tickErase runs work (a blocking erase call) while emitting synthetic ETA // progress updates against est every interval, until work returns. progress // is called with (elapsedMs, estMs), capped so elapsed never reaches est @@ -1281,11 +1285,30 @@ func compressData(data []byte) ([]byte, error) { return buf.Bytes(), nil } -// retryFlashBlock attempts a flash block write up to flashBlockRetries times. -// On failure, it flushes stale serial data and waits briefly before retrying. -// This handles transient SLIP timeouts and framing errors that are common -// during ESP32 flash operations, matching esptool.py's WRITE_BLOCK_ATTEMPTS -// retry behavior. +// logf logs a message if a logger is configured. +func (f *Flasher) logf(format string, args ...interface{}) { + if f.opts.Logger != nil { + f.opts.Logger.Logf(format, args...) + } +} + +// retryFlashBlock calls writeFn up to flashBlockRetries times, retrying on +// errors that indicate transient serial data loss. Two cases are retried: +// +// 1. CommandError with IsRetryable() (bad data length / bad checksum): the +// stub received a corrupted frame and responded with a clean error. It is +// ready for a resend. +// +// 2. TimeoutError: the stub never responded, likely because bytes were lost +// during UART transmission, leaving the stub waiting for the rest of an +// incomplete SLIP frame. On resend, the leading 0xC0 terminates the stub's +// partial frame; the stub may then emit a stale error response for the +// truncated frame before processing our retry, which is handled by the +// next retry iteration. +// +// Between retries the serial RX buffer and SLIP reader are flushed so stale +// responses from partial-frame cleanup don't corrupt subsequent reads. +// Device-side failures (SPI errors, inflate errors) are NOT retried. func (f *Flasher) retryFlashBlock(seq, numBlocks uint32, writeFn func() error) error { var err error for attempt := range flashBlockRetries { @@ -1293,26 +1316,32 @@ func (f *Flasher) retryFlashBlock(seq, numBlocks uint32, writeFn func() error) e if err == nil { return nil } + if !isRetryableFlashError(err) { + return err + } if attempt < flashBlockRetries-1 { f.logf("Warning: block %d/%d write failed (attempt %d/%d): %v — retrying", seq, numBlocks, attempt+1, flashBlockRetries, err) - // Wait before flushing so a delayed response from the timed-out - // attempt has time to arrive and gets cleared by the flush. - // Without this ordering, the stale response arrives after the - // flush and corrupts the retry's response parsing (e.g. SLIP - // END 0xC0 read as a status byte). - time.Sleep(200 * time.Millisecond) + // Flush stale data so the retry starts with a clean serial state. + // After a timeout the stub may still be holding a partial frame; + // our next send's leading 0xC0 will terminate it, producing a + // stale error response that the flush on the FOLLOWING iteration + // (if needed) will clear. f.conn.flushInput() } } - return fmt.Errorf("flash block %d of %d: %w", seq, numBlocks, err) + return err } -// logf logs a message if a logger is configured. -func (f *Flasher) logf(format string, args ...interface{}) { - if f.opts.Logger != nil { - f.opts.Logger.Logf(format, args...) +// isRetryableFlashError returns true if the error is a transient serial-link +// issue (data corruption or loss) that can be recovered by resending. +func isRetryableFlashError(err error) bool { + var cmdErr *CommandError + if errors.As(err, &cmdErr) { + return cmdErr.IsRetryable() } + var timeoutErr *TimeoutError + return errors.As(err, &timeoutErr) } // connectStatus emits a connect-phase status update if a ConnectStatus diff --git a/pkg/espflasher/protocol.go b/pkg/espflasher/protocol.go index afcdea8..778e8cb 100644 --- a/pkg/espflasher/protocol.go +++ b/pkg/espflasher/protocol.go @@ -71,12 +71,29 @@ const ( // Default timeouts const ( - defaultTimeout = 3 * time.Second - syncTimeout = 100 * time.Millisecond - chipEraseTimeout = 120 * time.Second - md5Timeout = 30 * time.Second - eraseWritePerMBRate = 10 * time.Second // per megabyte - flashWritePerMBRate = 40 * time.Second // per megabyte + defaultTimeout = 3 * time.Second + syncTimeout = 100 * time.Millisecond + chipEraseTimeout = 120 * time.Second + md5Timeout = 30 * time.Second + eraseWritePerMBRate = 10 * time.Second // per megabyte + flashWritePerMBRate = 40 * time.Second // per megabyte + flashWriteMinTimeout = 10 * time.Second // minimum timeout for any flash write + + // stubFlashPageDelay is the estimated time for the ESP32 ROM to program + // one 256-byte flash page. The stub uses double-buffering: it ACKs each + // flash data block immediately and writes to flash as a post-process. + // During the flash write, the ROM disables interrupts (required because + // the SPI bus is shared with the cache and the cache must be disabled + // while programming). If the next block's data arrives at the UART + // during this window, the 128-byte hardware FIFO overflows and data is + // silently lost. After receiving the ACK, we sleep for the estimated + // flash write duration to let the post-process finish before sending + // more data. + // + // Typical values: 0.2–0.7 ms (Winbond W25Q), up to 3 ms worst-case. + // We use 1 ms as a conservative default that covers common flash chips + // with margin. + stubFlashPageDelay = 1 * time.Millisecond ) // conn wraps the serial port and provides the low-level protocol operations. @@ -164,7 +181,20 @@ func (c *conn) sendCommand(opcode byte, data []byte, chk uint32) error { return err } } - return nil + + // Wait for the kernel to finish transmitting the frame data to the USB + // device. Without this, Write returns as soon as data is copied to the + // kernel buffer, and the caller may issue the next command before the + // previous frame has physically left the host. This matters for flash + // data commands: the stub uses double-buffering — it ACKs each block + // immediately and performs the actual flash write as a post-process. + // If the next block arrives while the stub is still writing flash + // (which may briefly disable interrupts on ESP32), the UART RX FIFO + // can overflow, silently losing data and causing a timeout. Drain + // ensures each frame is committed to the USB-UART bridge before we + // proceed, adding a small but deterministic delay that gives the stub + // more time between consecutive commands. + return c.port.Drain() } // commandResponse represents a parsed response from the ESP device. @@ -431,7 +461,11 @@ func (c *conn) flashData(block []byte, seq uint32) error { timeout := flashWriteTimeoutForSize(uint32(len(block))) _, err := c.checkCommand("write flash block", cmdFlashData, data, checksum(block), timeout, 0) - return err + if err != nil { + return err + } + c.waitForStubFlashWrite(uint32(len(block))) + return nil } // flashEnd finishes flash download. If reboot is true, the device reboots. @@ -494,10 +528,12 @@ func (c *conn) flashDeflData(block []byte, seq uint32) error { binary.LittleEndian.PutUint32(data[12:16], 0) copy(data[16:], block) - // The stub must decompress this block and write the result to flash - // before ACKing. The decompressed data can be much larger than the - // compressed block, so scale the timeout by the compression ratio - // to account for the actual flash write time. + // The stub uses double-buffering: it validates and ACKs this command + // immediately, then decompresses and writes to flash as a post-process + // after the response is sent. The decompressed data can be much larger + // than the compressed block, so scale the timeout by the compression + // ratio to account for the flash write time that occurs before the + // stub is ready for the next command. estimatedSize := uint32(len(block)) if c.deflCompSize > 0 && c.deflUncompSize > c.deflCompSize { ratio := float64(c.deflUncompSize) / float64(c.deflCompSize) @@ -505,7 +541,11 @@ func (c *conn) flashDeflData(block []byte, seq uint32) error { } timeout := flashWriteTimeoutForSize(estimatedSize) _, err := c.checkCommand("write compressed flash block", cmdFlashDeflData, data, checksum(block), timeout, 0) - return err + if err != nil { + return err + } + c.waitForStubFlashWrite(estimatedSize) + return nil } // flashDeflEnd finishes compressed flash download. @@ -672,6 +712,18 @@ func (c *conn) flushInput() { c.reader.reset() } +// waitForStubFlashWrite sleeps to let the stub's flash write post-process +// complete before the caller sends the next command. See stubFlashPageDelay +// for the full rationale. When the ROM bootloader is active (no stub), the +// flash write completes synchronously before the ACK, so no delay is needed. +func (c *conn) waitForStubFlashWrite(dataSize uint32) { + if !c.stub || dataSize == 0 { + return + } + pages := (dataSize + 255) / 256 + time.Sleep(time.Duration(pages) * stubFlashPageDelay) +} + // eraseTimeoutForSize calculates an appropriate timeout for erase operations. func eraseTimeoutForSize(size uint32) time.Duration { // Base timeout + per-MB rate @@ -696,12 +748,13 @@ func md5TimeoutForSize(size uint32) time.Duration { // especially compressed writes that must be decompressed before being // programmed) can take substantially longer than the erase rate on slower // ESP32 processors, so this uses a more generous per-MB rate than -// eraseTimeoutForSize. The floor remains defaultTimeout so small blocks -// are not over-inflated. +// eraseTimeoutForSize. The floor is flashWriteMinTimeout (10s) rather than +// defaultTimeout, because individual block writes can stall while the stub +// erases flash sectors before programming. func flashWriteTimeoutForSize(size uint32) time.Duration { - t := defaultTimeout + time.Duration(float64(flashWritePerMBRate)*float64(size)/float64(1024*1024)) - if t < defaultTimeout { - t = defaultTimeout + t := flashWriteMinTimeout + time.Duration(float64(flashWritePerMBRate)*float64(size)/float64(1024*1024)) + if t < flashWriteMinTimeout { + t = flashWriteMinTimeout } return t } diff --git a/pkg/espflasher/stubs/esp32.json b/pkg/espflasher/stubs/esp32.json index d799af0..84b0a87 100644 --- a/pkg/espflasher/stubs/esp32.json +++ b/pkg/espflasher/stubs/esp32.json @@ -1,8 +1,8 @@ { - "entry": 1074429964, - "text": "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", + "entry": 1074434360, + "text": "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", "text_start": 1074429952, - "data": "XJMKQCxC/T9omgpAaJoKQGiaCkBomgpAaJoKQGiaCkBomgpAaJoKQGiaCkBomgpAaJoKQGiaCkBomgpAaJoKQGiaCkBomgpAaJoKQGiaCkBomgpAaJoKQGiaCkBomgpAaJoKQGiaCkBomgpAaJoKQGiaCkBPSEFJAAAAALWKCkC7igpAI4sKQC6LCkDXiwpAb4sKQIeKCkAQjApAhowKQNGMCkAEjwpAq4wKQASPCkArjQpASo0KQFyNCkAjiwpAwo0KQNiNCkA=", - "data_start": 1073605988, + "data": "AMD8PzyHCkBPSEFJAAAAAFOUCkBalApAxpQKQNCUCkB/lQpAEpUKQB2UCkC9lQpAOJYKQLGWCkC1mApAYZYKQLWYCkAWlwpAO5cKQEyXCkDGlApApZcKQLuXCkAUhQpALIIKQLCCCkCQhApAkIQKQJCECkCQhApAkIQKQJCECkCQhApAkIQKQJCECkCQhApAkIQKQJCECkCQhApAkIQKQJCECkCQhApAkIQKQJCECkCQhApAkIQKQJCECkCQhApAkIQKQJCECkCQhApAkIQKQJCECkA=", + "data_start": 1073605996, "bss_start": 1073528832 } \ No newline at end of file diff --git a/pkg/espflasher/stubs/esp32c2.json b/pkg/espflasher/stubs/esp32c2.json index 12b3845..80a2473 100644 --- a/pkg/espflasher/stubs/esp32c2.json +++ b/pkg/espflasher/stubs/esp32c2.json @@ -1,8 +1,8 @@ { - "entry": 1077411840, - "text": "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", + "entry": 1077416200, + "text": "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", "text_start": 1077411840, - "data": "7hE4QEzCyj+QAzhAkAM4QJADOECQAzhAkAM4QJADOECQAzhAkAM4QJADOECQAzhAkAM4QJADOECQAzhAkAM4QJADOECQAzhAkAM4QJADOECQAzhAkAM4QJADOECQAzhAkAM4QJADOECQAzhAkAM4QJADOECiCjhArgo4QPoKOEAmCzhAsAs4QFoLOECECjhA8gs4QG4MOECUDDhARAo4QIIMOEBECjhA+gw4QAoNOEAODThA+go4QGYNOEB6DThA", - "data_start": 1070296424, + "data": "+gU4QDxAyj/qEzhA9hM4QEYUOEBYFDhAUhU4QNAUOEDCEzhAlBU4QBoWOEByFjhAeBM4QC4WOEB4EzhA7BY4QPwWOEAAFzhARhQ4QE4XOEBoFzhArAM4QFQBOECcAThAPgM4QD4DOEA+AzhAPgM4QD4DOEA+AzhAPgM4QD4DOEA+AzhAPgM4QD4DOEA+AzhAPgM4QD4DOEA+AzhAPgM4QD4DOEA+AzhAPgM4QD4DOEA+AzhAPgM4QD4DOEA+AzhAPgM4QD4DOEA+AzhA", + "data_start": 1070296428, "bss_start": 1070219264 } \ No newline at end of file diff --git a/pkg/espflasher/stubs/esp32c3.json b/pkg/espflasher/stubs/esp32c3.json index 1fbb718..b02fb7e 100644 --- a/pkg/espflasher/stubs/esp32c3.json +++ b/pkg/espflasher/stubs/esp32c3.json @@ -1,8 +1,8 @@ { - "entry": 1077411840, - "text": "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", + "entry": 1077415954, + "text": "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", "text_start": 1077411840, - "data": "7hE4QEzCyD+QAzhAkAM4QJADOECQAzhAkAM4QJADOECQAzhAkAM4QJADOECQAzhAkAM4QJADOECQAzhAkAM4QJADOECQAzhAkAM4QJADOECQAzhAkAM4QJADOECQAzhAkAM4QJADOECQAzhAkAM4QJADOECiCjhArgo4QPoKOEAmCzhAsAs4QFoLOECECjhA8gs4QG4MOECUDDhARAo4QIIMOEBECjhA+gw4QAoNOEAODThA+go4QGYNOEB6DThA", - "data_start": 1070165348, + "data": "wgY4QDhAyD8OFDhAGBQ4QGgUOEB6FDhAdBU4QPIUOEDmEzhAthU4QDwWOECUFjhAnBM4QFAWOECcEzhADhc4QB4XOEAiFzhAaBQ4QHAXOECKFzhA1gM4QFABOECYAThAOgM4QDoDOEA6AzhAOgM4QDoDOEA6AzhAOgM4QDoDOEA6AzhAOgM4QDoDOEA6AzhAOgM4QDoDOEA6AzhAOgM4QDoDOEA6AzhAOgM4QDoDOEA6AzhAOgM4QDoDOEA6AzhAOgM4QDoDOEA6AzhA", + "data_start": 1070165352, "bss_start": 1070088192 } \ No newline at end of file diff --git a/pkg/espflasher/stubs/esp32c5.json b/pkg/espflasher/stubs/esp32c5.json index 2129f22..595eb3d 100644 --- a/pkg/espflasher/stubs/esp32c5.json +++ b/pkg/espflasher/stubs/esp32c5.json @@ -1,8 +1,8 @@ { - "entry": 1082130432, - "text": "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", + "entry": 1082136018, + "text": "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", "text_start": 1082130432, - "data": "8hGAQEyChECQA4BAkAOAQJADgECQA4BAkAOAQJADgECQA4BAkAOAQJADgECQA4BAkAOAQJADgECQA4BAkAOAQJADgECQA4BAkAOAQJADgECQA4BAkAOAQJADgECQA4BAkAOAQJADgECQA4BAkAOAQJADgECiCoBArgqAQPoKgEAmC4BAsAuAQFoLgECECoBA8guAQG4MgECUDIBARAqAQIIMgEBECoBA+gyAQAoNgEAODYBA+gqAQGYNgEB6DYBA", - "data_start": 1082469732, + "data": "2AeAQNwBhEDcGoBA6BqAQDobgEBOG4BAXhyAQNIbgEC0GoBAohyAQCodgECCHYBAXhqAQD4dgEBeGoBA/h2AQA4egEASHoBAOhuAQGIegEB+HoBAFAWAQFABgEAgCYBA1gOAQFABgECYAYBAOgOAQDoDgEA6A4BAOgOAQDoDgEA6A4BAOgOAQDoDgEA6A4BAOgOAQDoDgEA6A4BAOgOAQDoDgEA6A4BAOgOAQDoDgEA6A4BAOgOAQDoDgEA6A4BAOgOAQDoDgEA6A4BAOgOAQDoDgEA6A4BA", + "data_start": 1082470156, "bss_start": 1082392576 } \ No newline at end of file diff --git a/pkg/espflasher/stubs/esp32c6.json b/pkg/espflasher/stubs/esp32c6.json index f81de05..cd3895f 100644 --- a/pkg/espflasher/stubs/esp32c6.json +++ b/pkg/espflasher/stubs/esp32c6.json @@ -1,8 +1,8 @@ { - "entry": 1082130432, - "text": "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", + "entry": 1082135354, + "text": "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", "text_start": 1082130432, - "data": "8BGAQEyChECQA4BAkAOAQJADgECQA4BAkAOAQJADgECQA4BAkAOAQJADgECQA4BAkAOAQJADgECQA4BAkAOAQJADgECQA4BAkAOAQJADgECQA4BAkAOAQJADgECQA4BAkAOAQJADgECQA4BAkAOAQJADgECiCoBArgqAQPoKgEAmC4BAsAuAQFoLgECECoBA8guAQG4MgECUDIBARAqAQIIMgEBECoBA+gyAQAoNgEAODYBA+gqAQGYNgEB6DYBA", - "data_start": 1082469732, + "data": "4AeAQNwBhEAGGIBAEhiAQGQYgEB4GIBAiBmAQPwYgEDeF4BAzBmAQFQagECsGoBAiBeAQGgagECIF4BAKBuAQDgbgEA8G4BAZBiAQIwbgECoG4BAFAWAQFABgEAoCYBA1gOAQFABgECYAYBAOgOAQDoDgEA6A4BAOgOAQDoDgEA6A4BAOgOAQDoDgEA6A4BAOgOAQDoDgEA6A4BAOgOAQDoDgEA6A4BAOgOAQDoDgEA6A4BAOgOAQDoDgEA6A4BAOgOAQDoDgEA6A4BAOgOAQDoDgEA6A4BA", + "data_start": 1082470156, "bss_start": 1082392576 } \ No newline at end of file diff --git a/pkg/espflasher/stubs/esp32h2.json b/pkg/espflasher/stubs/esp32h2.json index 780b7bb..6b83dc1 100644 --- a/pkg/espflasher/stubs/esp32h2.json +++ b/pkg/espflasher/stubs/esp32h2.json @@ -1,8 +1,8 @@ { - "entry": 1082130432, - "text": "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", + "entry": 1082134538, + "text": "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", "text_start": 1082130432, - "data": "8BGAQEyCg0CQA4BAkAOAQJADgECQA4BAkAOAQJADgECQA4BAkAOAQJADgECQA4BAkAOAQJADgECQA4BAkAOAQJADgECQA4BAkAOAQJADgECQA4BAkAOAQJADgECQA4BAkAOAQJADgECQA4BAkAOAQJADgECiCoBArgqAQPoKgEAmC4BAsAuAQFoLgECECoBA8guAQG4MgECUDIBARAqAQIIMgEBECoBA+gyAQAoNgEAODYBA+gqAQGYNgEB6DYBA", - "data_start": 1082404196, + "data": "ugaAQDgAg0AaFIBAJBSAQHQUgECGFIBAgBWAQP4UgEDyE4BAwhWAQEgWgECgFoBAqBOAQFwWgECoE4BAGheAQCoXgEAuF4BAdBSAQHwXgECWF4BA1gOAQFABgECYAYBAOgOAQDoDgEA6A4BAOgOAQDoDgEA6A4BAOgOAQDoDgEA6A4BAOgOAQDoDgEA6A4BAOgOAQDoDgEA6A4BAOgOAQDoDgEA6A4BAOgOAQDoDgEA6A4BAOgOAQDoDgEA6A4BAOgOAQDoDgEA6A4BA", + "data_start": 1082404200, "bss_start": 1082327040 } \ No newline at end of file diff --git a/pkg/espflasher/stubs/esp32p4-rev1.json b/pkg/espflasher/stubs/esp32p4-rev1.json index ef5e338..5a7f0c6 100644 --- a/pkg/espflasher/stubs/esp32p4-rev1.json +++ b/pkg/espflasher/stubs/esp32p4-rev1.json @@ -1,8 +1,8 @@ { - "entry": 1341194240, - "text": "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", + "entry": 1341199430, + "text": "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", "text_start": 1341194240, - "data": "ChLxT0yC9U+QA/FPkAPxT5AD8U+QA/FPkAPxT5AD8U+QA/FPkAPxT5AD8U+QA/FPkAPxT5AD8U+QA/FPkAPxT5AD8U+QA/FPkAPxT5AD8U+QA/FPkAPxT5AD8U+QA/FPkAPxT5AD8U+QA/FPkAPxT5AD8U+iCvFPrgrxT/oK8U8mC/FPsAvxT1oL8U+ECvFP8gvxT24M8U+UDPFPRArxT4IM8U9ECvFP+gzxTwoN8U8ODfFP+grxT2YN8U96DfFP", + "data": "KgfxT4gA9U8+G/FPShvxT5ob8U+sG/FPshzxTyYc8U8WG/FP9BzxT4Ad8U+mHfFPzBrxT5Qd8U/MGvFPIB7xTzAe8U80HvFPmhvxT4Ie8U+cHvFP0APxT0oB8U+SAfFPNAPxTzQD8U80A/FPNAPxTzQD8U80A/FPNAPxTzQD8U80A/FPNAPxTzQD8U80A/FPNAPxTzQD8U80A/FPNAPxTzQD8U80A/FPNAPxTzQD8U80A/FPNAPxTzQD8U80A/FPNAPxTzQD8U80A/FP", "data_start": 1341533624, "bss_start": 1341456384 } \ No newline at end of file diff --git a/pkg/espflasher/stubs/esp32s2.json b/pkg/espflasher/stubs/esp32s2.json index a632858..af9fbf8 100644 --- a/pkg/espflasher/stubs/esp32s2.json +++ b/pkg/espflasher/stubs/esp32s2.json @@ -1,8 +1,8 @@ { - "entry": 1073905676, - "text": "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", + "entry": 1073910244, + "text": "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", "text_start": 1073905664, - "data": "gJMCQCyC/T+wnAJAsJwCQLCcAkCwnAJAsJwCQLCcAkCwnAJAsJwCQLCcAkCwnAJAsJwCQLCcAkCwnAJAsJwCQLCcAkCwnAJAsJwCQLCcAkCwnAJAsJwCQLCcAkCwnAJAsJwCQLCcAkCwnAJAsJwCQLCcAkBPSEFJAAAAAM2KAkDTigJAO4sCQEaLAkDviwJAh4sCQJ+KAkAojAJAnowCQOmMAkAYjwJAw4wCQBiPAkBDjQJAYo0CQHSNAkA7iwJA2o0CQPCNAkA=", - "data_start": 1073622452, + "data": "QAD9P5SHAkBPSEFJAAAAAL2VAkDClQJAKpYCQDOWAkDwlgJAgpYCQIuVAkAslwJAoJcCQAqYAkABmgJAwpcCQAGaAkBqmAJAi5gCQJmYAkAqlgJA7pgCQACZAkAMhQJAJIICQKiCAkCIhAJAiIQCQIiEAkCIhAJAiIQCQIiEAkCIhAJAiIQCQIiEAkCIhAJAiIQCQIiEAkCIhAJAiIQCQIiEAkCIhAJAiIQCQIiEAkCIhAJAiIQCQIiEAkCIhAJAiIQCQIiEAkCIhAJAiIQCQIiEAkA=", + "data_start": 1073622464, "bss_start": 1073545216 } \ No newline at end of file diff --git a/pkg/espflasher/stubs/esp32s3.json b/pkg/espflasher/stubs/esp32s3.json index 959b4e4..033d17d 100644 --- a/pkg/espflasher/stubs/esp32s3.json +++ b/pkg/espflasher/stubs/esp32s3.json @@ -1,28 +1,29 @@ { - "entry": 1077379084, - "text": "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", + "entry": 1077384484, + "text": "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", "text_start": 1077379072, - "data": "aJM3QCyCyj/EnjdAxJ43QMSeN0DEnjdAxJ43QMSeN0DEnjdAxJ43QMSeN0DEnjdAxJ43QMSeN0DEnjdAxJ43QMSeN0DEnjdAxJ43QMSeN0DEnjdAxJ43QMSeN0DEnjdAxJ43QMSeN0DEnjdAxJ43QMSeN0AYGBgYEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAT0hBSQAAAADNijdA04o3QDuLN0BGizdA74s3QIeLN0CfijdAKIw3QJ6MN0DpjDdAGI83QMOMN0AYjzdAQ403QGKNN0B0jTdAO4s3QNqNN0DwjTdA", - "data_start": 1070280116, + "data": "QADKPxgYGBgQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwiDdAT0hBSQAAAAA9mTdAQpk3QKqZN0C1mTdAc5o3QAKaN0ANmTdAqpo3QCibN0CSmzdAjZ03QEqbN0CNnTdA9ps3QBacN0AmnDdAqpk3QHqcN0CMnDdAOIU3QBSCN0CYgjdAeIQ3QHiEN0B4hDdAeIQ3QHiEN0B4hDdAeIQ3QHiEN0B4hDdAeIQ3QHiEN0B4hDdAeIQ3QHiEN0B4hDdAeIQ3QHiEN0B4hDdAeIQ3QHiEN0B4hDdAeIQ3QHiEN0B4hDdAeIQ3QHiEN0B4hDdA", + "data_start": 1070280128, "bss_start": 1070202880, "plugin_first_opcode": 213, - "plugin_table_offset": 8, + "plugin_table_offset": 156, "plugin_table_entries": 27, "plugins": { "nand": { - "text": "NkEAIqADMKMgICIRZkQRZRYA5RsAoCogjFo8EqkFYCIRHfAANmEAIqADMKMgICIRZkQdJRQAgqAAvQGJAeUcAC0KzGqCAQCJBQYBADwSYCIRHfAANkEAIqADICIRZlQVMKMgJREAsgMEZRsAoCogjDo8EmAiER3wsC7LP/QRAEA2QQAMMq0DICIRZkQtZQ4AMfr/HAy9A00KpQIALQrcSkkFHAy9A0ulgfX/4AgAHAiCVSIGAQA8EmAiER3wAAAA6BEAQDZBAK0DzQSMk4x0sqD/gfv/4AgADAId8DZBAK0CpQIAHfAAADZBAK0CvQPNBOUCAB3wAAA2QQAgoiAwsyBlAwCQAAAAXBwAQDZBACCiIIH9/+AIAB3wAABoHABANkEArQK9A0DEIIH8/+AIAB3wAAB0HABANkEAvQKtA4H9/+AIAB3wAAAGAEA2QQAgoiCB/f/gCAAd8AAAsBwAQDZBAL0DzQQgoPSB/P/gCAAtCh3wNkEAkgIBggIAgJkRgJkgggICIgIDAIgRkIgggCIBgCIgHfAANkEAIqD/gCIRHfAANkEADAId8AA2QQAioP+AIhEd8AA2QQAioP+AIhEd8AA2QQAioP+AIhEd8AA2QQAMAh3wADZBAAwSUCIRHfAAADZBABZSAIKvqoJCAIxDgqAAglMADAId8DZBAIwzDAiCQwAMAh3wAAA2QQCMY3z4gkMAgkMBDAId8AAAADZBAAwCHfAANkEADAId8AA2QQB80h3wAA==", - "text_start": 1077387104, - "bss_size": 16, + "text": "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", + "text_start": 1077386912, + "bss_size": 10288, "handlers": { - "0xD5": 0, - "0xD6": 36, - "0xD7": 84, - "0xD8": 408, - "0xD9": 420, - "0xDA": 428, - "0xDB": 440, - "0xDC": 452, - "0xDD": 128 + "0xD5": 1728, + "0xD6": 3056, + "0xD7": 3160, + "0xD8": 3336, + "0xD9": 3416, + "0xDA": 3468, + "0xDE": 3648, + "0xDB": 3752, + "0xDC": 3788, + "0xDD": 3864 } } } diff --git a/pkg/espflasher/stubs/esp8266.json b/pkg/espflasher/stubs/esp8266.json index 69e2d2f..9f3badd 100644 --- a/pkg/espflasher/stubs/esp8266.json +++ b/pkg/espflasher/stubs/esp8266.json @@ -1,8 +1,8 @@ { "entry": 1074840836, - "text": "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", + "text": "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", "text_start": 1074840832, - "data": "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", - "data_start": 1073720924, + "data": "cMwQQCyB/j8AAAAAAAAAAAAAAQAAEAAAAAEAAP//AAD/////R9QQQJXUEEDJ1BBAcdUQQIDkEEDN1RBAJdYQQHTWEECA5BBAT9cQQMbXEEB42BBAgOQQQIDkEEAh2RBAgOQQQOfbEEC73BBA/dwQQIDkEECA5BBAn90QQIDkEECX3hBASd8QQJngEEBn4RBAPeIQQIDkEECA5BBAgOQQQIDkEEBV4xBAgOQQQGzkEEA82hBAOtUQQIDkEEB01xBAt9YQQIDkEED74xBAR+QQQIDkEECA5BBAgOQQQIDkEECA5BBAgOQQQIDkEECA5BBA5dYQQCDXEEC+4hBAhMsQQKjIEEAgyBBAsMUQQLDFEECwxRBAsMUQQLDFEECwxRBAsMUQQLDFEECwxRBAsMUQQLDFEECwxRBAsMUQQLDFEECwxRBAsMUQQLDFEECwxRBAsMUQQLDFEECwxRBAsMUQQLDFEECwxRBAsMUQQLDFEECwxRBAAQAAAAIAAAADAAAABAAAAAUAAAAHAAAACQAAAA0AAAARAAAAGQAAACEAAAAxAAAAQQAAAGEAAACBAAAAwQAAAAEBAACBAQAAAQIAAAEDAAABBAAAAQYAAAEIAAABDAAAARAAAAEYAAABIAAAATAAAAFAAAABYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAACAAAAAgAAAAMAAAADAAAABAAAAAQAAAAFAAAABQAAAAYAAAAGAAAABwAAAAcAAAAIAAAACAAAAAkAAAAJAAAACgAAAAoAAAALAAAACwAAAAwAAAAMAAAADQAAAA0AAAAAAAAAAAAAAAMAAAAEAAAABQAAAAYAAAAHAAAACAAAAAkAAAAKAAAACwAAAA0AAAAPAAAAEQAAABMAAAAXAAAAGwAAAB8AAAAjAAAAKwAAADMAAAA7AAAAQwAAAFMAAABjAAAAcwAAAIMAAACjAAAAwwAAAOMAAAACAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAQAAAAEAAAACAAAAAgAAAAIAAAACAAAAAwAAAAMAAAADAAAAAwAAAAQAAAAEAAAABAAAAAQAAAAFAAAABQAAAAUAAAAFAAAAAAAAAAAAAAAAAAAAEBESAAgHCQYKBQsEDAMNAg4BDwABAQAAAQAAAAQAAAAFBQQAAgMHAAMDCwA=", + "data_start": 1073720940, "bss_start": 1073643776 } \ No newline at end of file diff --git a/tools/update-stubs.go b/tools/update-stubs.go index 4683da6..8c9f216 100644 --- a/tools/update-stubs.go +++ b/tools/update-stubs.go @@ -11,7 +11,7 @@ import ( ) const ( - stubVersion = "v0.5.1" + stubVersion = "v1.1.0" baseURL = "https://github.com/espressif/esp-flasher-stub/releases/download/" + stubVersion )