id
int64 0
458k
| file_name
stringlengths 4
119
| file_path
stringlengths 14
227
| content
stringlengths 24
9.96M
| size
int64 24
9.96M
| language
stringclasses 1
value | extension
stringclasses 14
values | total_lines
int64 1
219k
| avg_line_length
float64 2.52
4.63M
| max_line_length
int64 5
9.91M
| alphanum_fraction
float64 0
1
| repo_name
stringlengths 7
101
| repo_stars
int64 100
139k
| repo_forks
int64 0
26.4k
| repo_open_issues
int64 0
2.27k
| repo_license
stringclasses 12
values | repo_extraction_date
stringclasses 433
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
2,289,600 | __main__.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/__main__.py | # SPDX-FileCopyrightText: 2014-2022 Fredrik Ahlberg, Angus Gratton,
# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
import esptool
if __name__ == "__main__":
esptool._main()
| 246 | Python | .py | 7 | 33.285714 | 67 | 0.738397 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,601 | util.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/util.py | # SPDX-FileCopyrightText: 2014-2022 Fredrik Ahlberg, Angus Gratton,
# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
import os
import re
import struct
import sys
def byte(bitstr, index):
return bitstr[index]
def mask_to_shift(mask):
"""Return the index of the least significant bit in the mask"""
shift = 0
while mask & 0x1 == 0:
shift += 1
mask >>= 1
return shift
def div_roundup(a, b):
"""Return a/b rounded up to nearest integer,
equivalent result to int(math.ceil(float(int(a)) / float(int(b))), only
without possible floating point accuracy errors.
"""
return (int(a) + int(b) - 1) // int(b)
def flash_size_bytes(size):
"""Given a flash size of the type passed in args.flash_size
(ie 512KB or 1MB) then return the size in bytes.
"""
if size is None:
return None
if "MB" in size:
return int(size[: size.index("MB")]) * 1024 * 1024
elif "KB" in size:
return int(size[: size.index("KB")]) * 1024
else:
raise FatalError("Unknown size %s" % size)
def hexify(s, uppercase=True):
format_str = "%02X" if uppercase else "%02x"
return "".join(format_str % c for c in s)
def pad_to(data, alignment, pad_character=b"\xFF"):
"""Pad to the next alignment boundary"""
pad_mod = len(data) % alignment
if pad_mod != 0:
data += pad_character * (alignment - pad_mod)
return data
def print_overwrite(message, last_line=False):
"""Print a message, overwriting the currently printed line.
If last_line is False, don't append a newline at the end
(expecting another subsequent call will overwrite this one.)
After a sequence of calls with last_line=False, call once with last_line=True.
If output is not a TTY (for example redirected a pipe),
no overwriting happens and this function is the same as print().
"""
if sys.stdout.isatty():
print("\r%s" % message, end="\n" if last_line else "")
else:
print(message)
def expand_chip_name(chip_name):
"""Change chip name to official form, e.g. `esp32s3beta2` -> `ESP32-S3(beta2)`"""
# Put "-" after "esp32"
chip_name = re.sub(r"(esp32)(?!$)", r"\1-", chip_name)
# Put "()" around "betaN"
chip_name = re.sub(r"(beta\d*)", r"(\1)", chip_name)
# Uppercase everything before "(betaN)"
chip_name = re.sub(r"^[^\(]+", lambda x: x.group(0).upper(), chip_name)
return chip_name
def strip_chip_name(chip_name):
"""Strip chip name to normalized form, e.g. `ESP32-S3(beta2)` -> `esp32s3beta2`"""
return re.sub(r"[-()]", "", chip_name.lower())
def get_file_size(path_to_file):
"""Returns the file size in bytes"""
file_size = 0
with open(path_to_file, "rb") as f:
f.seek(0, os.SEEK_END)
file_size = f.tell()
return file_size
class FatalError(RuntimeError):
"""
Wrapper class for runtime errors that aren't caused by internal bugs, but by
ESP ROM responses or input content.
"""
def __init__(self, message):
RuntimeError.__init__(self, message)
@staticmethod
def WithResult(message, result):
"""
Return a fatal error object that appends the hex values of
'result' and its meaning as a string formatted argument.
"""
err_defs = {
# ROM error codes
0x101: "Out of memory",
0x102: "Invalid argument",
0x103: "Invalid state",
0x104: "Invalid size",
0x105: "Requested resource not found",
0x106: "Operation or feature not supported",
0x107: "Operation timed out",
0x108: "Received response was invalid",
0x109: "CRC or checksum was invalid",
0x10A: "Version was invalid",
0x10B: "MAC address was invalid",
# Flasher stub error codes
0xC000: "Bad data length",
0xC100: "Bad data checksum",
0xC200: "Bad blocksize",
0xC300: "Invalid command",
0xC400: "Failed SPI operation",
0xC500: "Failed SPI unlock",
0xC600: "Not in flash mode",
0xC700: "Inflate error",
0xC800: "Not enough data",
0xC900: "Too much data",
0xFF00: "Command not implemented",
}
err_code = struct.unpack(">H", result[:2])
message += " (result was {}: {})".format(
hexify(result), err_defs.get(err_code[0], "Unknown result")
)
return FatalError(message)
class NotImplementedInROMError(FatalError):
"""
Wrapper class for the error thrown when a particular ESP bootloader function
is not implemented in the ROM bootloader.
"""
def __init__(self, bootloader, func):
FatalError.__init__(
self,
"%s ROM does not support function %s."
% (bootloader.CHIP_NAME, func.__name__),
)
class NotSupportedError(FatalError):
def __init__(self, esp, function_name):
FatalError.__init__(
self,
"Function %s is not supported for %s." % (function_name, esp.CHIP_NAME),
)
class UnsupportedCommandError(RuntimeError):
"""
Wrapper class for when ROM loader returns an invalid command response.
Usually this indicates the loader is running in Secure Download Mode.
"""
def __init__(self, esp, op):
if esp.secure_download_mode:
msg = "This command (0x%x) is not supported in Secure Download Mode" % op
else:
msg = "Invalid (unsupported) command 0x%x" % op
RuntimeError.__init__(self, msg)
| 5,713 | Python | .py | 147 | 31.666667 | 86 | 0.618057 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,602 | config.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/config.py | # SPDX-FileCopyrightText: 2014-2023 Espressif Systems (Shanghai) CO LTD,
# other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
import configparser
import os
CONFIG_OPTIONS = [
"timeout",
"chip_erase_timeout",
"max_timeout",
"sync_timeout",
"md5_timeout_per_mb",
"erase_region_timeout_per_mb",
"erase_write_timeout_per_mb",
"mem_end_rom_timeout",
"serial_write_timeout",
"connect_attempts",
"write_block_attempts",
"reset_delay",
"custom_reset_sequence",
]
def _validate_config_file(file_path, verbose=False):
if not os.path.exists(file_path):
return False
cfg = configparser.RawConfigParser()
try:
cfg.read(file_path, encoding="UTF-8")
# Only consider it a valid config file if it contains [esptool] section
if cfg.has_section("esptool"):
if verbose:
unknown_opts = list(set(cfg.options("esptool")) - set(CONFIG_OPTIONS))
unknown_opts.sort()
no_of_unknown_opts = len(unknown_opts)
if no_of_unknown_opts > 0:
suffix = "s" if no_of_unknown_opts > 1 else ""
print(
"Ignoring unknown config file option{}: {}".format(
suffix, ", ".join(unknown_opts)
)
)
return True
except (UnicodeDecodeError, configparser.Error) as e:
if verbose:
print(f"Ignoring invalid config file {file_path}: {e}")
return False
def _find_config_file(dir_path, verbose=False):
for candidate in ("esptool.cfg", "setup.cfg", "tox.ini"):
cfg_path = os.path.join(dir_path, candidate)
if _validate_config_file(cfg_path, verbose):
return cfg_path
return None
def load_config_file(verbose=False):
set_with_env_var = False
env_var_path = os.environ.get("ESPTOOL_CFGFILE")
if env_var_path is not None and _validate_config_file(env_var_path):
cfg_file_path = env_var_path
set_with_env_var = True
else:
home_dir = os.path.expanduser("~")
os_config_dir = (
f"{home_dir}/.config/esptool"
if os.name == "posix"
else f"{home_dir}/AppData/Local/esptool/"
)
# Search priority: 1) current dir, 2) OS specific config dir, 3) home dir
for dir_path in (os.getcwd(), os_config_dir, home_dir):
cfg_file_path = _find_config_file(dir_path, verbose)
if cfg_file_path:
break
cfg = configparser.ConfigParser()
cfg["esptool"] = {} # Create an empty esptool config for when no file is found
if cfg_file_path is not None:
# If config file is found and validated, read and parse it
cfg.read(cfg_file_path)
if verbose:
msg = " (set with ESPTOOL_CFGFILE)" if set_with_env_var else ""
print(
f"Loaded custom configuration from "
f"{os.path.abspath(cfg_file_path)}{msg}"
)
return cfg, cfg_file_path
| 3,106 | Python | .py | 81 | 29.308642 | 86 | 0.593232 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,603 | cmds.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/cmds.py | # SPDX-FileCopyrightText: 2014-2022 Fredrik Ahlberg, Angus Gratton,
# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
import hashlib
import io
import os
import struct
import sys
import time
import zlib
from .bin_image import ELFFile, ImageSegment, LoadFirmwareImage
from .bin_image import (
ESP8266ROMFirmwareImage,
ESP8266V2FirmwareImage,
ESP8266V3FirmwareImage,
)
from .loader import (
DEFAULT_CONNECT_ATTEMPTS,
DEFAULT_TIMEOUT,
ERASE_WRITE_TIMEOUT_PER_MB,
ESPLoader,
timeout_per_mb,
)
from .targets import CHIP_DEFS, CHIP_LIST, ROM_LIST
from .util import (
FatalError,
NotImplementedInROMError,
NotSupportedError,
UnsupportedCommandError,
)
from .util import (
div_roundup,
flash_size_bytes,
get_file_size,
hexify,
pad_to,
print_overwrite,
)
DETECTED_FLASH_SIZES = {
0x12: "256KB",
0x13: "512KB",
0x14: "1MB",
0x15: "2MB",
0x16: "4MB",
0x17: "8MB",
0x18: "16MB",
0x19: "32MB",
0x1A: "64MB",
0x1B: "128MB",
0x1C: "256MB",
0x20: "64MB",
0x21: "128MB",
0x22: "256MB",
0x32: "256KB",
0x33: "512KB",
0x34: "1MB",
0x35: "2MB",
0x36: "4MB",
0x37: "8MB",
0x38: "16MB",
0x39: "32MB",
0x3A: "64MB",
}
FLASH_MODES = {"qio": 0, "qout": 1, "dio": 2, "dout": 3}
def detect_chip(
port=ESPLoader.DEFAULT_PORT,
baud=ESPLoader.ESP_ROM_BAUD,
connect_mode="default_reset",
trace_enabled=False,
connect_attempts=DEFAULT_CONNECT_ATTEMPTS,
):
"""Use serial access to detect the chip type.
First, get_security_info command is sent to detect the ID of the chip
(supported only by ESP32-C3 and later, works even in the Secure Download Mode).
If this fails, we reconnect and fall-back to reading the magic number.
It's mapped at a specific ROM address and has a different value on each chip model.
This way we use one memory read and compare it to the magic number for each chip.
This routine automatically performs ESPLoader.connect() (passing
connect_mode parameter) as part of querying the chip.
"""
inst = None
detect_port = ESPLoader(port, baud, trace_enabled=trace_enabled)
if detect_port.serial_port.startswith("rfc2217:"):
detect_port.USES_RFC2217 = True
detect_port.connect(connect_mode, connect_attempts, detecting=True)
try:
print("Detecting chip type...", end="")
chip_id = detect_port.get_chip_id()
for cls in [
n for n in ROM_LIST if n.CHIP_NAME not in ("ESP8266", "ESP32", "ESP32-S2")
]:
# cmd not supported on ESP8266 and ESP32 + ESP32-S2 doesn't return chip_id
if chip_id == cls.IMAGE_CHIP_ID:
inst = cls(detect_port._port, baud, trace_enabled=trace_enabled)
try:
inst.read_reg(
ESPLoader.CHIP_DETECT_MAGIC_REG_ADDR
) # Dummy read to check Secure Download mode
except UnsupportedCommandError:
inst.secure_download_mode = True
inst._post_connect()
break
else:
err_msg = f"Unexpected chip ID value {chip_id}."
except (UnsupportedCommandError, struct.error, FatalError) as e:
# UnsupportedCommmanddError: ESP8266/ESP32 ROM
# struct.error: ESP32-S2
# FatalError: ESP8266/ESP32 STUB
print(" Unsupported detection protocol, switching and trying again...")
try:
# ESP32/ESP8266 are reset after an unsupported command, need to reconnect
# (not needed on ESP32-S2)
if not isinstance(e, struct.error):
detect_port.connect(
connect_mode, connect_attempts, detecting=True, warnings=False
)
print("Detecting chip type...", end="")
sys.stdout.flush()
chip_magic_value = detect_port.read_reg(
ESPLoader.CHIP_DETECT_MAGIC_REG_ADDR
)
for cls in ROM_LIST:
if chip_magic_value in cls.CHIP_DETECT_MAGIC_VALUE:
inst = cls(detect_port._port, baud, trace_enabled=trace_enabled)
inst._post_connect()
inst.check_chip_id()
break
else:
err_msg = f"Unexpected chip magic value {chip_magic_value:#010x}."
except UnsupportedCommandError:
raise FatalError(
"Unsupported Command Error received. "
"Probably this means Secure Download Mode is enabled, "
"autodetection will not work. Need to manually specify the chip."
)
finally:
if inst is not None:
print(" %s" % inst.CHIP_NAME, end="")
if detect_port.sync_stub_detected:
inst = inst.STUB_CLASS(inst)
inst.sync_stub_detected = True
print("") # end line
return inst
raise FatalError(
f"{err_msg} Failed to autodetect chip type."
"\nProbably it is unsupported by this version of esptool."
)
# "Operation" commands, executable at command line. One function each
#
# Each function takes either two args (<ESPLoader instance>, <args>) or a single <args>
# argument.
def load_ram(esp, args):
image = LoadFirmwareImage(esp.CHIP_NAME, args.filename)
print("RAM boot...")
for seg in image.segments:
size = len(seg.data)
print("Downloading %d bytes at %08x..." % (size, seg.addr), end=" ")
sys.stdout.flush()
esp.mem_begin(
size, div_roundup(size, esp.ESP_RAM_BLOCK), esp.ESP_RAM_BLOCK, seg.addr
)
seq = 0
while len(seg.data) > 0:
esp.mem_block(seg.data[0 : esp.ESP_RAM_BLOCK], seq)
seg.data = seg.data[esp.ESP_RAM_BLOCK :]
seq += 1
print("done!")
print("All segments done, executing at %08x" % image.entrypoint)
esp.mem_finish(image.entrypoint)
def read_mem(esp, args):
print("0x%08x = 0x%08x" % (args.address, esp.read_reg(args.address)))
def write_mem(esp, args):
esp.write_reg(args.address, args.value, args.mask, 0)
print("Wrote %08x, mask %08x to %08x" % (args.value, args.mask, args.address))
def dump_mem(esp, args):
with open(args.filename, "wb") as f:
for i in range(args.size // 4):
d = esp.read_reg(args.address + (i * 4))
f.write(struct.pack(b"<I", d))
if f.tell() % 1024 == 0:
print_overwrite(
"%d bytes read... (%d %%)" % (f.tell(), f.tell() * 100 // args.size)
)
sys.stdout.flush()
print_overwrite("Read %d bytes" % f.tell(), last_line=True)
print("Done!")
def detect_flash_size(esp, args=None):
# TODO: Remove the dependency on args in the next major release (v5.0)
if esp.secure_download_mode:
if args is not None and args.flash_size == "detect":
raise FatalError(
"Detecting flash size is not supported in secure download mode. "
"Need to manually specify flash size."
)
else:
return None
flash_id = esp.flash_id()
size_id = flash_id >> 16
flash_size = DETECTED_FLASH_SIZES.get(size_id)
if args is not None and args.flash_size == "detect":
if flash_size is None:
flash_size = "4MB"
print(
"Warning: Could not auto-detect Flash size "
f"(FlashID={flash_id:#x}, SizeID={size_id:#x}), defaulting to 4MB"
)
else:
print("Auto-detected Flash size:", flash_size)
args.flash_size = flash_size
return flash_size
def _update_image_flash_params(esp, address, args, image):
"""
Modify the flash mode & size bytes if this looks like an executable bootloader image
"""
if len(image) < 8:
return image # not long enough to be a bootloader image
# unpack the (potential) image header
magic, _, flash_mode, flash_size_freq = struct.unpack("BBBB", image[:4])
if address != esp.BOOTLOADER_FLASH_OFFSET:
return image # not flashing bootloader offset, so don't modify this
if (args.flash_mode, args.flash_freq, args.flash_size) == ("keep",) * 3:
return image # all settings are 'keep', not modifying anything
# easy check if this is an image: does it start with a magic byte?
if magic != esp.ESP_IMAGE_MAGIC:
print(
"Warning: Image file at 0x%x doesn't look like an image file, "
"so not changing any flash settings." % address
)
return image
# make sure this really is an image, and not just data that
# starts with esp.ESP_IMAGE_MAGIC (mostly a problem for encrypted
# images that happen to start with a magic byte
try:
test_image = esp.BOOTLOADER_IMAGE(io.BytesIO(image))
test_image.verify()
except Exception:
print(
"Warning: Image file at 0x%x is not a valid %s image, "
"so not changing any flash settings." % (address, esp.CHIP_NAME)
)
return image
# After the 8-byte header comes the extended header for chips others than ESP8266.
# The 15th byte of the extended header indicates if the image is protected by
# a SHA256 checksum. In that case we should not modify the header because
# the checksum check would fail.
sha_implies_keep = args.chip != "esp8266" and image[8 + 15] == 1
def print_keep_warning(arg_to_keep, arg_used):
print(
"Warning: Image file at {addr} is protected with a hash checksum, "
"so not changing the flash {arg} setting. "
"Use the --flash_{arg}=keep option instead of --flash_{arg}={arg_orig} "
"in order to remove this warning, or use the --dont-append-digest option "
"for the elf2image command in order to generate an image file "
"without a hash checksum".format(
addr=hex(address), arg=arg_to_keep, arg_orig=arg_used
)
)
if args.flash_mode != "keep":
new_flash_mode = FLASH_MODES[args.flash_mode]
if flash_mode != new_flash_mode and sha_implies_keep:
print_keep_warning("mode", args.flash_mode)
else:
flash_mode = new_flash_mode
flash_freq = flash_size_freq & 0x0F
if args.flash_freq != "keep":
new_flash_freq = esp.parse_flash_freq_arg(args.flash_freq)
if flash_freq != new_flash_freq and sha_implies_keep:
print_keep_warning("frequency", args.flash_freq)
else:
flash_freq = new_flash_freq
flash_size = flash_size_freq & 0xF0
if args.flash_size != "keep":
new_flash_size = esp.parse_flash_size_arg(args.flash_size)
if flash_size != new_flash_size and sha_implies_keep:
print_keep_warning("size", args.flash_size)
else:
flash_size = new_flash_size
flash_params = struct.pack(b"BB", flash_mode, flash_size + flash_freq)
if flash_params != image[2:4]:
print("Flash params set to 0x%04x" % struct.unpack(">H", flash_params))
image = image[0:2] + flash_params + image[4:]
return image
def write_flash(esp, args):
# set args.compress based on default behaviour:
# -> if either --compress or --no-compress is set, honour that
# -> otherwise, set --compress unless --no-stub is set
if args.compress is None and not args.no_compress:
args.compress = not args.no_stub
if not args.force and esp.CHIP_NAME != "ESP8266" and not esp.secure_download_mode:
# Check if secure boot is active
if esp.get_secure_boot_enabled():
for address, _ in args.addr_filename:
if address < 0x8000:
raise FatalError(
"Secure Boot detected, writing to flash regions < 0x8000 "
"is disabled to protect the bootloader. "
"Use --force to override, "
"please use with caution, otherwise it may brick your device!"
)
# Check if chip_id and min_rev in image are valid for the target in use
for _, argfile in args.addr_filename:
try:
image = LoadFirmwareImage(esp.CHIP_NAME, argfile)
except (FatalError, struct.error, RuntimeError):
continue
finally:
argfile.seek(0) # LoadFirmwareImage changes the file handle position
if image.chip_id != esp.IMAGE_CHIP_ID:
raise FatalError(
f"{argfile.name} is not an {esp.CHIP_NAME} image. "
"Use --force to flash anyway."
)
# this logic below decides which min_rev to use, min_rev or min/max_rev_full
if image.max_rev_full == 0: # image does not have max/min_rev_full fields
use_rev_full_fields = False
elif image.max_rev_full == 65535: # image has default value of max_rev_full
use_rev_full_fields = True
if (
image.min_rev_full == 0 and image.min_rev != 0
): # min_rev_full is not set, min_rev is used
use_rev_full_fields = False
else: # max_rev_full set to a version
use_rev_full_fields = True
if use_rev_full_fields:
rev = esp.get_chip_revision()
if rev < image.min_rev_full or rev > image.max_rev_full:
error_str = f"{argfile.name} requires chip revision in range "
error_str += (
f"[v{image.min_rev_full // 100}.{image.min_rev_full % 100} - "
)
if image.max_rev_full == 65535:
error_str += "max rev not set] "
else:
error_str += (
f"v{image.max_rev_full // 100}.{image.max_rev_full % 100}] "
)
error_str += f"(this chip is revision v{rev // 100}.{rev % 100})"
raise FatalError(f"{error_str}. Use --force to flash anyway.")
else:
# In IDF, image.min_rev is set based on Kconfig option.
# For C3 chip, image.min_rev is the Minor revision
# while for the rest chips it is the Major revision.
if esp.CHIP_NAME == "ESP32-C3":
rev = esp.get_minor_chip_version()
else:
rev = esp.get_major_chip_version()
if rev < image.min_rev:
raise FatalError(
f"{argfile.name} requires chip revision "
f"{image.min_rev} or higher (this chip is revision {rev}). "
"Use --force to flash anyway."
)
# In case we have encrypted files to write,
# we first do few sanity checks before actual flash
if args.encrypt or args.encrypt_files is not None:
do_write = True
if not esp.secure_download_mode:
if esp.get_encrypted_download_disabled():
raise FatalError(
"This chip has encrypt functionality "
"in UART download mode disabled. "
"This is the Flash Encryption configuration for Production mode "
"instead of Development mode."
)
crypt_cfg_efuse = esp.get_flash_crypt_config()
if crypt_cfg_efuse is not None and crypt_cfg_efuse != 0xF:
print("Unexpected FLASH_CRYPT_CONFIG value: 0x%x" % (crypt_cfg_efuse))
do_write = False
enc_key_valid = esp.is_flash_encryption_key_valid()
if not enc_key_valid:
print("Flash encryption key is not programmed")
do_write = False
# Determine which files list contain the ones to encrypt
files_to_encrypt = args.addr_filename if args.encrypt else args.encrypt_files
for address, argfile in files_to_encrypt:
if address % esp.FLASH_ENCRYPTED_WRITE_ALIGN:
print(
"File %s address 0x%x is not %d byte aligned, can't flash encrypted"
% (argfile.name, address, esp.FLASH_ENCRYPTED_WRITE_ALIGN)
)
do_write = False
if not do_write and not args.ignore_flash_encryption_efuse_setting:
raise FatalError(
"Can't perform encrypted flash write, "
"consult Flash Encryption documentation for more information"
)
else:
if not args.force and esp.CHIP_NAME != "ESP8266":
# ESP32 does not support `get_security_info()` and `secure_download_mode`
if (
esp.CHIP_NAME != "ESP32"
and esp.secure_download_mode
and bin(esp.get_security_info()["flash_crypt_cnt"]).count("1") & 1 != 0
):
raise FatalError(
"WARNING: Detected flash encryption and "
"secure download mode enabled.\n"
"Flashing plaintext binary may brick your device! "
"Use --force to override the warning."
)
if (
not esp.secure_download_mode
and esp.get_encrypted_download_disabled()
and esp.get_flash_encryption_enabled()
):
raise FatalError(
"WARNING: Detected flash encryption enabled and "
"download manual encrypt disabled.\n"
"Flashing plaintext binary may brick your device! "
"Use --force to override the warning."
)
# verify file sizes fit in flash
flash_end = flash_size_bytes(
detect_flash_size(esp) if args.flash_size == "keep" else args.flash_size
)
if flash_end is not None: # Not in secure download mode
for address, argfile in args.addr_filename:
argfile.seek(0, os.SEEK_END)
if address + argfile.tell() > flash_end:
raise FatalError(
"File %s (length %d) at offset %d "
"will not fit in %d bytes of flash. "
"Use --flash_size argument, or change flashing address."
% (argfile.name, argfile.tell(), address, flash_end)
)
argfile.seek(0)
if args.erase_all:
erase_flash(esp, args)
else:
for address, argfile in args.addr_filename:
argfile.seek(0, os.SEEK_END)
write_end = address + argfile.tell()
argfile.seek(0)
bytes_over = address % esp.FLASH_SECTOR_SIZE
if bytes_over != 0:
print(
"WARNING: Flash address {:#010x} is not aligned "
"to a {:#x} byte flash sector. "
"{:#x} bytes before this address will be erased.".format(
address, esp.FLASH_SECTOR_SIZE, bytes_over
)
)
# Print the address range of to-be-erased flash memory region
print(
"Flash will be erased from {:#010x} to {:#010x}...".format(
address - bytes_over,
div_roundup(write_end, esp.FLASH_SECTOR_SIZE)
* esp.FLASH_SECTOR_SIZE
- 1,
)
)
""" Create a list describing all the files we have to flash.
Each entry holds an "encrypt" flag marking whether the file needs encryption or not.
This list needs to be sorted.
First, append to each entry of our addr_filename list the flag args.encrypt
E.g., if addr_filename is [(0x1000, "partition.bin"), (0x8000, "bootloader")],
all_files will be [
(0x1000, "partition.bin", args.encrypt),
(0x8000, "bootloader", args.encrypt)
],
where, of course, args.encrypt is either True or False
"""
all_files = [
(offs, filename, args.encrypt) for (offs, filename) in args.addr_filename
]
"""
Now do the same with encrypt_files list, if defined.
In this case, the flag is True
"""
if args.encrypt_files is not None:
encrypted_files_flag = [
(offs, filename, True) for (offs, filename) in args.encrypt_files
]
# Concatenate both lists and sort them.
# As both list are already sorted, we could simply do a merge instead,
# but for the sake of simplicity and because the lists are very small,
# let's use sorted.
all_files = sorted(all_files + encrypted_files_flag, key=lambda x: x[0])
for address, argfile, encrypted in all_files:
compress = args.compress
# Check whether we can compress the current file before flashing
if compress and encrypted:
print("\nWARNING: - compress and encrypt options are mutually exclusive ")
print("Will flash %s uncompressed" % argfile.name)
compress = False
if args.no_stub:
print("Erasing flash...")
image = pad_to(
argfile.read(), esp.FLASH_ENCRYPTED_WRITE_ALIGN if encrypted else 4
)
if len(image) == 0:
print("WARNING: File %s is empty" % argfile.name)
continue
image = _update_image_flash_params(esp, address, args, image)
calcmd5 = hashlib.md5(image).hexdigest()
uncsize = len(image)
if compress:
uncimage = image
image = zlib.compress(uncimage, 9)
# Decompress the compressed binary a block at a time,
# to dynamically calculate the timeout based on the real write size
decompress = zlib.decompressobj()
blocks = esp.flash_defl_begin(uncsize, len(image), address)
else:
blocks = esp.flash_begin(uncsize, address, begin_rom_encrypted=encrypted)
argfile.seek(0) # in case we need it again
seq = 0
bytes_sent = 0 # bytes sent on wire
bytes_written = 0 # bytes written to flash
t = time.time()
timeout = DEFAULT_TIMEOUT
while len(image) > 0:
print_overwrite(
"Writing at 0x%08x... (%d %%)"
% (address + bytes_written, 100 * (seq + 1) // blocks)
)
sys.stdout.flush()
block = image[0 : esp.FLASH_WRITE_SIZE]
if compress:
# feeding each compressed block into the decompressor lets us
# see block-by-block how much will be written
block_uncompressed = len(decompress.decompress(block))
bytes_written += block_uncompressed
block_timeout = max(
DEFAULT_TIMEOUT,
timeout_per_mb(ERASE_WRITE_TIMEOUT_PER_MB, block_uncompressed),
)
if not esp.IS_STUB:
timeout = (
block_timeout # ROM code writes block to flash before ACKing
)
esp.flash_defl_block(block, seq, timeout=timeout)
if esp.IS_STUB:
# Stub ACKs when block is received,
# then writes to flash while receiving the block after it
timeout = block_timeout
else:
# Pad the last block
block = block + b"\xff" * (esp.FLASH_WRITE_SIZE - len(block))
if encrypted:
esp.flash_encrypt_block(block, seq)
else:
esp.flash_block(block, seq)
bytes_written += len(block)
bytes_sent += len(block)
image = image[esp.FLASH_WRITE_SIZE :]
seq += 1
if esp.IS_STUB:
# Stub only writes each block to flash after 'ack'ing the receive,
# so do a final dummy operation which will not be 'ack'ed
# until the last block has actually been written out to flash
esp.read_reg(ESPLoader.CHIP_DETECT_MAGIC_REG_ADDR, timeout=timeout)
t = time.time() - t
speed_msg = ""
if compress:
if t > 0.0:
speed_msg = " (effective %.1f kbit/s)" % (uncsize / t * 8 / 1000)
print_overwrite(
"Wrote %d bytes (%d compressed) at 0x%08x in %.1f seconds%s..."
% (uncsize, bytes_sent, address, t, speed_msg),
last_line=True,
)
else:
if t > 0.0:
speed_msg = " (%.1f kbit/s)" % (bytes_written / t * 8 / 1000)
print_overwrite(
"Wrote %d bytes at 0x%08x in %.1f seconds%s..."
% (bytes_written, address, t, speed_msg),
last_line=True,
)
if not encrypted and not esp.secure_download_mode:
try:
res = esp.flash_md5sum(address, uncsize)
if res != calcmd5:
print("File md5: %s" % calcmd5)
print("Flash md5: %s" % res)
print(
"MD5 of 0xFF is %s"
% (hashlib.md5(b"\xFF" * uncsize).hexdigest())
)
raise FatalError("MD5 of file does not match data in flash!")
else:
print("Hash of data verified.")
except NotImplementedInROMError:
pass
print("\nLeaving...")
if esp.IS_STUB:
# skip sending flash_finish to ROM loader here,
# as it causes the loader to exit and run user code
esp.flash_begin(0, 0)
# Get the "encrypted" flag for the last file flashed
# Note: all_files list contains triplets like:
# (address: Integer, filename: String, encrypted: Boolean)
last_file_encrypted = all_files[-1][2]
# Check whether the last file flashed was compressed or not
if args.compress and not last_file_encrypted:
esp.flash_defl_finish(False)
else:
esp.flash_finish(False)
if args.verify:
print("Verifying just-written flash...")
print(
"(This option is deprecated, "
"flash contents are now always read back after flashing.)"
)
# If some encrypted files have been flashed,
# print a warning saying that we won't check them
if args.encrypt or args.encrypt_files is not None:
print("WARNING: - cannot verify encrypted files, they will be ignored")
# Call verify_flash function only if there is at least
# one non-encrypted file flashed
if not args.encrypt:
verify_flash(esp, args)
def image_info(args):
def v2():
def get_key_from_value(dict, val):
"""Get key from value in dictionary"""
for key, value in dict.items():
if value == val:
return key
return None
print()
title = "{} image header".format(args.chip.upper())
print(title)
print("=" * len(title))
print("Image version: {}".format(image.version))
print(
"Entry point: {:#8x}".format(image.entrypoint)
if image.entrypoint != 0
else "Entry point not set"
)
print("Segments: {}".format(len(image.segments)))
# Flash size
flash_s_bits = image.flash_size_freq & 0xF0 # high four bits
flash_s = get_key_from_value(image.ROM_LOADER.FLASH_SIZES, flash_s_bits)
print(
"Flash size: {}".format(flash_s)
if flash_s is not None
else "WARNING: Invalid flash size ({:#02x})".format(flash_s_bits)
)
# Flash frequency
flash_fr_bits = image.flash_size_freq & 0x0F # low four bits
flash_fr = get_key_from_value(image.ROM_LOADER.FLASH_FREQUENCY, flash_fr_bits)
print(
"Flash freq: {}".format(flash_fr)
if flash_fr is not None
else "WARNING: Invalid flash frequency ({:#02x})".format(flash_fr_bits)
)
# Flash mode
flash_mode = get_key_from_value(FLASH_MODES, image.flash_mode)
print(
"Flash mode: {}".format(flash_mode.upper())
if flash_mode is not None
else "WARNING: Invalid flash mode ({})".format(image.flash_mode)
)
# Extended header (ESP32 and later only)
if args.chip != "esp8266":
print()
title = "{} extended image header".format(args.chip.upper())
print(title)
print("=" * len(title))
print(
f"WP pin: {image.wp_pin:#02x}",
*["(disabled)"] if image.wp_pin == image.WP_PIN_DISABLED else [],
)
print(
"Flash pins drive settings: "
"clk_drv: {:#02x}, q_drv: {:#02x}, d_drv: {:#02x}, "
"cs0_drv: {:#02x}, hd_drv: {:#02x}, wp_drv: {:#02x}".format(
image.clk_drv,
image.q_drv,
image.d_drv,
image.cs_drv,
image.hd_drv,
image.wp_drv,
)
)
try:
chip = next(
chip
for chip in CHIP_DEFS.values()
if getattr(chip, "IMAGE_CHIP_ID", None) == image.chip_id
)
print(f"Chip ID: {image.chip_id} ({chip.CHIP_NAME})")
except StopIteration:
print(f"Chip ID: {image.chip_id} (Unknown ID)")
print(
"Minimal chip revision: "
f"v{image.min_rev_full // 100}.{image.min_rev_full % 100}, "
f"(legacy min_rev = {image.min_rev})"
)
print(
"Maximal chip revision: "
f"v{image.max_rev_full // 100}.{image.max_rev_full % 100}"
)
print()
# Segments overview
title = "Segments information"
print(title)
print("=" * len(title))
headers_str = "{:>7} {:>7} {:>10} {:>10} {:10}"
print(
headers_str.format(
"Segment", "Length", "Load addr", "File offs", "Memory types"
)
)
print(
"{} {} {} {} {}".format("-" * 7, "-" * 7, "-" * 10, "-" * 10, "-" * 12)
)
format_str = "{:7} {:#07x} {:#010x} {:#010x} {}"
app_desc = None
bootloader_desc = None
for idx, seg in enumerate(image.segments, start=1):
segs = seg.get_memory_type(image)
seg_name = ", ".join(segs)
if "DROM" in segs: # The DROM segment starts with the esp_app_desc_t struct
app_desc = seg.data[:256]
elif "DRAM" in segs:
# The DRAM segment starts with the esp_bootloader_desc_t struct
if len(seg.data) >= 80:
bootloader_desc = seg.data[:80]
print(
format_str.format(idx, len(seg.data), seg.addr, seg.file_offs, seg_name)
)
print()
# Footer
title = f"{args.chip.upper()} image footer"
print(title)
print("=" * len(title))
calc_checksum = image.calculate_checksum()
print(
"Checksum: {:#02x} ({})".format(
image.checksum,
"valid"
if image.checksum == calc_checksum
else "invalid - calculated {:02x}".format(calc_checksum),
)
)
try:
digest_msg = "Not appended"
if image.append_digest:
is_valid = image.stored_digest == image.calc_digest
digest_msg = "{} ({})".format(
hexify(image.calc_digest, uppercase=False),
"valid" if is_valid else "invalid",
)
print("Validation hash: {}".format(digest_msg))
except AttributeError:
pass # ESP8266 image has no append_digest field
if app_desc:
APP_DESC_STRUCT_FMT = "<II" + "8s" + "32s32s16s16s32s32s" + "80s"
(
magic_word,
secure_version,
reserv1,
version,
project_name,
time,
date,
idf_ver,
app_elf_sha256,
reserv2,
) = struct.unpack(APP_DESC_STRUCT_FMT, app_desc)
if magic_word == 0xABCD5432:
print()
title = "Application information"
print(title)
print("=" * len(title))
print(f'Project name: {project_name.decode("utf-8")}')
print(f'App version: {version.decode("utf-8")}')
print(f'Compile time: {date.decode("utf-8")} {time.decode("utf-8")}')
print(f"ELF file SHA256: {hexify(app_elf_sha256, uppercase=False)}")
print(f'ESP-IDF: {idf_ver.decode("utf-8")}')
print(f"Secure version: {secure_version}")
elif bootloader_desc:
BOOTLOADER_DESC_STRUCT_FMT = "<B" + "3s" + "I32s24s" + "16s"
(
magic_byte,
reserved,
version,
idf_ver,
date_time,
reserved2,
) = struct.unpack(BOOTLOADER_DESC_STRUCT_FMT, bootloader_desc)
if magic_byte == 80:
print()
title = "Bootloader information"
print(title)
print("=" * len(title))
print(f"Bootloader version: {version}")
print(f'ESP-IDF: {idf_ver.decode("utf-8")}')
print(f'Compile time: {date_time.decode("utf-8")}')
print(f"File size: {get_file_size(args.filename)} (bytes)")
with open(args.filename, "rb") as f:
# magic number
try:
common_header = f.read(8)
magic = common_header[0]
except IndexError:
raise FatalError("File is empty")
if magic not in [
ESPLoader.ESP_IMAGE_MAGIC,
ESP8266V2FirmwareImage.IMAGE_V2_MAGIC,
]:
raise FatalError(
"This is not a valid image "
"(invalid magic number: {:#x})".format(magic)
)
if args.chip == "auto":
try:
extended_header = f.read(16)
# append_digest, either 0 or 1
if extended_header[-1] not in [0, 1]:
raise FatalError("Append digest field not 0 or 1")
chip_id = int.from_bytes(extended_header[4:5], "little")
for rom in [n for n in ROM_LIST if n.CHIP_NAME != "ESP8266"]:
if chip_id == rom.IMAGE_CHIP_ID:
args.chip = rom.CHIP_NAME
break
else:
raise FatalError(f"Unknown image chip ID ({chip_id})")
except FatalError:
args.chip = "esp8266"
print(f"Detected image type: {args.chip.upper()}")
image = LoadFirmwareImage(args.chip, args.filename)
if args.version == "2":
v2()
return
print("Image version: {}".format(image.version))
print(
"Entry point: {:8x}".format(image.entrypoint)
if image.entrypoint != 0
else "Entry point not set"
)
print("{} segments".format(len(image.segments)))
print()
idx = 0
for seg in image.segments:
idx += 1
segs = seg.get_memory_type(image)
seg_name = ",".join(segs)
print("Segment {}: {} [{}]".format(idx, seg, seg_name))
calc_checksum = image.calculate_checksum()
print(
"Checksum: {:02x} ({})".format(
image.checksum,
"valid"
if image.checksum == calc_checksum
else "invalid - calculated {:02x}".format(calc_checksum),
)
)
try:
digest_msg = "Not appended"
if image.append_digest:
is_valid = image.stored_digest == image.calc_digest
digest_msg = "{} ({})".format(
hexify(image.calc_digest, uppercase=False),
"valid" if is_valid else "invalid",
)
print("Validation Hash: {}".format(digest_msg))
except AttributeError:
pass # ESP8266 image has no append_digest field
def make_image(args):
print("Creating {} image...".format(args.chip))
image = ESP8266ROMFirmwareImage()
if len(args.segfile) == 0:
raise FatalError("No segments specified")
if len(args.segfile) != len(args.segaddr):
raise FatalError(
"Number of specified files does not match number of specified addresses"
)
for seg, addr in zip(args.segfile, args.segaddr):
with open(seg, "rb") as f:
data = f.read()
image.segments.append(ImageSegment(addr, data))
image.entrypoint = args.entrypoint
image.save(args.output)
print("Successfully created {} image.".format(args.chip))
def elf2image(args):
e = ELFFile(args.input)
if args.chip == "auto": # Default to ESP8266 for backwards compatibility
args.chip = "esp8266"
print("Creating {} image...".format(args.chip))
if args.chip != "esp8266":
image = CHIP_DEFS[args.chip].BOOTLOADER_IMAGE()
if args.chip == "esp32" and args.secure_pad:
image.secure_pad = "1"
if args.secure_pad_v2:
image.secure_pad = "2"
image.min_rev = args.min_rev
image.min_rev_full = args.min_rev_full
image.max_rev_full = args.max_rev_full
image.append_digest = args.append_digest
elif args.version == "1": # ESP8266
image = ESP8266ROMFirmwareImage()
elif args.version == "2":
image = ESP8266V2FirmwareImage()
else:
image = ESP8266V3FirmwareImage()
image.entrypoint = e.entrypoint
image.flash_mode = FLASH_MODES[args.flash_mode]
if args.flash_mmu_page_size:
image.set_mmu_page_size(flash_size_bytes(args.flash_mmu_page_size))
# ELFSection is a subclass of ImageSegment, so can use interchangeably
image.segments = e.segments if args.use_segments else e.sections
if args.pad_to_size:
image.pad_to_size = flash_size_bytes(args.pad_to_size)
image.flash_size_freq = image.ROM_LOADER.parse_flash_size_arg(args.flash_size)
image.flash_size_freq += image.ROM_LOADER.parse_flash_freq_arg(args.flash_freq)
if args.elf_sha256_offset:
image.elf_sha256 = e.sha256()
image.elf_sha256_offset = args.elf_sha256_offset
before = len(image.segments)
image.merge_adjacent_segments()
if len(image.segments) != before:
delta = before - len(image.segments)
print("Merged %d ELF section%s" % (delta, "s" if delta > 1 else ""))
image.verify()
if args.output is None:
args.output = image.default_output_name(args.input)
image.save(args.output)
print("Successfully created {} image.".format(args.chip))
def read_mac(esp, args):
def print_mac(label, mac):
print("%s: %s" % (label, ":".join(map(lambda x: "%02x" % x, mac))))
eui64 = esp.read_mac("EUI64")
if eui64:
print_mac("MAC", eui64)
print_mac("BASE MAC", esp.read_mac("BASE_MAC"))
print_mac("MAC_EXT", esp.read_mac("MAC_EXT"))
else:
print_mac("MAC", esp.read_mac("BASE_MAC"))
def chip_id(esp, args):
try:
chipid = esp.chip_id()
print("Chip ID: 0x%08x" % chipid)
except NotSupportedError:
print("Warning: %s has no Chip ID. Reading MAC instead." % esp.CHIP_NAME)
read_mac(esp, args)
def erase_flash(esp, args):
if not args.force and esp.CHIP_NAME != "ESP8266" and not esp.secure_download_mode:
if esp.get_flash_encryption_enabled() or esp.get_secure_boot_enabled():
raise FatalError(
"Active security features detected, "
"erasing flash is disabled as a safety measure. "
"Use --force to override, "
"please use with caution, otherwise it may brick your device!"
)
print("Erasing flash (this may take a while)...")
t = time.time()
esp.erase_flash()
print("Chip erase completed successfully in %.1fs" % (time.time() - t))
def erase_region(esp, args):
if not args.force and esp.CHIP_NAME != "ESP8266" and not esp.secure_download_mode:
if esp.get_flash_encryption_enabled() or esp.get_secure_boot_enabled():
raise FatalError(
"Active security features detected, "
"erasing flash is disabled as a safety measure. "
"Use --force to override, "
"please use with caution, otherwise it may brick your device!"
)
print("Erasing region (may be slow depending on size)...")
t = time.time()
esp.erase_region(args.address, args.size)
print("Erase completed successfully in %.1f seconds." % (time.time() - t))
def run(esp, args):
esp.run()
def flash_id(esp, args):
flash_id = esp.flash_id()
print("Manufacturer: %02x" % (flash_id & 0xFF))
flid_lowbyte = (flash_id >> 16) & 0xFF
print("Device: %02x%02x" % ((flash_id >> 8) & 0xFF, flid_lowbyte))
print(
"Detected flash size: %s" % (DETECTED_FLASH_SIZES.get(flid_lowbyte, "Unknown"))
)
flash_type = esp.flash_type()
flash_type_dict = {0: "quad (4 data lines)", 1: "octal (8 data lines)"}
flash_type_str = flash_type_dict.get(flash_type)
if flash_type_str:
print(f"Flash type set in eFuse: {flash_type_str}")
def read_flash(esp, args):
if args.no_progress:
flash_progress = None
else:
def flash_progress(progress, length):
msg = "%d (%d %%)" % (progress, progress * 100.0 / length)
padding = "\b" * len(msg)
if progress == length:
padding = "\n"
sys.stdout.write(msg + padding)
sys.stdout.flush()
t = time.time()
data = esp.read_flash(args.address, args.size, flash_progress)
t = time.time() - t
speed_msg = " ({:.1f} kbit/s)".format(len(data) / t * 8 / 1000) if t > 0.0 else ""
print_overwrite(
"Read {:d} bytes at {:#010x} in {:.1f} seconds{}...".format(
len(data), args.address, t, speed_msg
),
last_line=True,
)
with open(args.filename, "wb") as f:
f.write(data)
def verify_flash(esp, args):
differences = False
for address, argfile in args.addr_filename:
image = pad_to(argfile.read(), 4)
argfile.seek(0) # rewind in case we need it again
image = _update_image_flash_params(esp, address, args, image)
image_size = len(image)
print(
"Verifying 0x%x (%d) bytes @ 0x%08x in flash against %s..."
% (image_size, image_size, address, argfile.name)
)
# Try digest first, only read if there are differences.
digest = esp.flash_md5sum(address, image_size)
expected_digest = hashlib.md5(image).hexdigest()
if digest == expected_digest:
print("-- verify OK (digest matched)")
continue
else:
differences = True
if getattr(args, "diff", "no") != "yes":
print("-- verify FAILED (digest mismatch)")
continue
flash = esp.read_flash(address, image_size)
assert flash != image
diff = [i for i in range(image_size) if flash[i] != image[i]]
print(
"-- verify FAILED: %d differences, first @ 0x%08x"
% (len(diff), address + diff[0])
)
for d in diff:
flash_byte = flash[d]
image_byte = image[d]
print(" %08x %02x %02x" % (address + d, flash_byte, image_byte))
if differences:
raise FatalError("Verify failed.")
def read_flash_status(esp, args):
print("Status value: 0x%04x" % esp.read_status(args.bytes))
def write_flash_status(esp, args):
fmt = "0x%%0%dx" % (args.bytes * 2)
args.value = args.value & ((1 << (args.bytes * 8)) - 1)
print(("Initial flash status: " + fmt) % esp.read_status(args.bytes))
print(("Setting flash status: " + fmt) % args.value)
esp.write_status(args.value, args.bytes, args.non_volatile)
print(("After flash status: " + fmt) % esp.read_status(args.bytes))
# The following mapping was taken from the ROM code
# This mapping is same across all targets in the ROM
SECURITY_INFO_FLAG_MAP = {
"SECURE_BOOT_EN": (1 << 0),
"SECURE_BOOT_AGGRESSIVE_REVOKE": (1 << 1),
"SECURE_DOWNLOAD_ENABLE": (1 << 2),
"SECURE_BOOT_KEY_REVOKE0": (1 << 3),
"SECURE_BOOT_KEY_REVOKE1": (1 << 4),
"SECURE_BOOT_KEY_REVOKE2": (1 << 5),
"SOFT_DIS_JTAG": (1 << 6),
"HARD_DIS_JTAG": (1 << 7),
"DIS_USB": (1 << 8),
"DIS_DOWNLOAD_DCACHE": (1 << 9),
"DIS_DOWNLOAD_ICACHE": (1 << 10),
}
# Get the status of respective security flag
def get_security_flag_status(flag_name, flags_value):
try:
return (flags_value & SECURITY_INFO_FLAG_MAP[flag_name]) != 0
except KeyError:
raise ValueError(f"Invalid flag name: {flag_name}")
def get_security_info(esp, args):
si = esp.get_security_info()
print()
title = "Security Information:"
print(title)
print("=" * len(title))
print("Flags: {:#010x} ({})".format(si["flags"], bin(si["flags"])))
print("Key Purposes: {}".format(si["key_purposes"]))
if si["chip_id"] is not None and si["api_version"] is not None:
print("Chip ID: {}".format(si["chip_id"]))
print("API Version: {}".format(si["api_version"]))
flags = si["flags"]
if get_security_flag_status("SECURE_BOOT_EN", flags):
print("Secure Boot: Enabled")
if get_security_flag_status("SECURE_BOOT_AGGRESSIVE_REVOKE", flags):
print("Secure Boot Aggressive key revocation: Enabled")
revoked_keys = []
for i, key in enumerate(
[
"SECURE_BOOT_KEY_REVOKE0",
"SECURE_BOOT_KEY_REVOKE1",
"SECURE_BOOT_KEY_REVOKE2",
]
):
if get_security_flag_status(key, flags):
revoked_keys.append(i)
if len(revoked_keys) > 0:
print("Secure Boot Key Revocation Status:\n")
for i in revoked_keys:
print(f"\tSecure Boot Key{i} is Revoked\n")
else:
print("Secure Boot: Disabled")
flash_crypt_cnt = bin(si["flash_crypt_cnt"])
if (flash_crypt_cnt.count("1") % 2) != 0:
print("Flash Encryption: Enabled")
else:
print("Flash Encryption: Disabled")
CRYPT_CNT_STRING = "SPI Boot Crypt Count (SPI_BOOT_CRYPT_CNT)"
if esp.CHIP_NAME == "esp32":
CRYPT_CNT_STRING = "Flash Crypt Count (FLASH_CRYPT_CNT)"
print(f"{CRYPT_CNT_STRING}: {si['flash_crypt_cnt']:#x}")
if get_security_flag_status("DIS_DOWNLOAD_DCACHE", flags):
print("Dcache in UART download mode: Disabled")
if get_security_flag_status("DIS_DOWNLOAD_ICACHE", flags):
print("Icache in UART download mode: Disabled")
hard_dis_jtag = get_security_flag_status("HARD_DIS_JTAG", flags)
soft_dis_jtag = get_security_flag_status("SOFT_DIS_JTAG", flags)
if hard_dis_jtag:
print("JTAG: Permenantly Disabled")
elif soft_dis_jtag:
print("JTAG: Software Access Disabled")
if get_security_flag_status("DIS_USB", flags):
print("USB Access: Disabled")
def merge_bin(args):
try:
chip_class = CHIP_DEFS[args.chip]
except KeyError:
msg = (
"Please specify the chip argument"
if args.chip == "auto"
else "Invalid chip choice: '{}'".format(args.chip)
)
msg = msg + " (choose from {})".format(", ".join(CHIP_LIST))
raise FatalError(msg)
# sort the files by offset.
# The AddrFilenamePairAction has already checked for overlap
input_files = sorted(args.addr_filename, key=lambda x: x[0])
if not input_files:
raise FatalError("No input files specified")
first_addr = input_files[0][0]
if first_addr < args.target_offset:
raise FatalError(
"Output file target offset is 0x%x. Input file offset 0x%x is before this."
% (args.target_offset, first_addr)
)
if args.format != "raw":
raise FatalError(
"This version of esptool only supports the 'raw' output format"
)
with open(args.output, "wb") as of:
def pad_to(flash_offs):
# account for output file offset if there is any
of.write(b"\xFF" * (flash_offs - args.target_offset - of.tell()))
for addr, argfile in input_files:
pad_to(addr)
image = argfile.read()
image = _update_image_flash_params(chip_class, addr, args, image)
of.write(image)
if args.fill_flash_size:
pad_to(flash_size_bytes(args.fill_flash_size))
print(
"Wrote 0x%x bytes to file %s, ready to flash to offset 0x%x"
% (of.tell(), args.output, args.target_offset)
)
def version(args):
from . import __version__
print(__version__)
| 49,873 | Python | .py | 1,166 | 31.801029 | 88 | 0.563813 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,604 | bin_image.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/bin_image.py | # SPDX-FileCopyrightText: 2014-2022 Fredrik Ahlberg, Angus Gratton,
# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
import binascii
import copy
import hashlib
import io
import os
import re
import struct
from .loader import ESPLoader
from .targets import (
ESP32C2ROM,
ESP32C3ROM,
ESP32C6BETAROM,
ESP32C6ROM,
ESP32H2BETA1ROM,
ESP32H2BETA2ROM,
ESP32H2ROM,
ESP32ROM,
ESP32S2ROM,
ESP32S3BETA2ROM,
ESP32S3ROM,
ESP8266ROM,
)
from .util import FatalError, byte, pad_to
def align_file_position(f, size):
"""Align the position in the file to the next block of specified size"""
align = (size - 1) - (f.tell() % size)
f.seek(align, 1)
def LoadFirmwareImage(chip, image_file):
"""
Load a firmware image. Can be for any supported SoC.
ESP8266 images will be examined to determine if they are original ROM firmware
images (ESP8266ROMFirmwareImage) or "v2" OTA bootloader images.
Returns a BaseFirmwareImage subclass, either ESP8266ROMFirmwareImage (v1)
or ESP8266V2FirmwareImage (v2).
"""
def select_image_class(f, chip):
chip = re.sub(r"[-()]", "", chip.lower())
if chip != "esp8266":
return {
"esp32": ESP32FirmwareImage,
"esp32s2": ESP32S2FirmwareImage,
"esp32s3beta2": ESP32S3BETA2FirmwareImage,
"esp32s3": ESP32S3FirmwareImage,
"esp32c3": ESP32C3FirmwareImage,
"esp32c6beta": ESP32C6BETAFirmwareImage,
"esp32h2beta1": ESP32H2BETA1FirmwareImage,
"esp32h2beta2": ESP32H2BETA2FirmwareImage,
"esp32c2": ESP32C2FirmwareImage,
"esp32c6": ESP32C6FirmwareImage,
"esp32h2": ESP32H2FirmwareImage,
}[chip](f)
else: # Otherwise, ESP8266 so look at magic to determine the image type
magic = ord(f.read(1))
f.seek(0)
if magic == ESPLoader.ESP_IMAGE_MAGIC:
return ESP8266ROMFirmwareImage(f)
elif magic == ESP8266V2FirmwareImage.IMAGE_V2_MAGIC:
return ESP8266V2FirmwareImage(f)
else:
raise FatalError("Invalid image magic number: %d" % magic)
if isinstance(image_file, str):
with open(image_file, "rb") as f:
return select_image_class(f, chip)
return select_image_class(image_file, chip)
class ImageSegment(object):
"""Wrapper class for a segment in an ESP image
(very similar to a section in an ELFImage also)"""
def __init__(self, addr, data, file_offs=None):
self.addr = addr
self.data = data
self.file_offs = file_offs
self.include_in_checksum = True
if self.addr != 0:
self.pad_to_alignment(
4
) # pad all "real" ImageSegments 4 byte aligned length
def copy_with_new_addr(self, new_addr):
"""Return a new ImageSegment with same data, but mapped at
a new address."""
return ImageSegment(new_addr, self.data, 0)
def split_image(self, split_len):
"""Return a new ImageSegment which splits "split_len" bytes
from the beginning of the data. Remaining bytes are kept in
this segment object (and the start address is adjusted to match.)"""
result = copy.copy(self)
result.data = self.data[:split_len]
self.data = self.data[split_len:]
self.addr += split_len
self.file_offs = None
result.file_offs = None
return result
def __repr__(self):
r = "len 0x%05x load 0x%08x" % (len(self.data), self.addr)
if self.file_offs is not None:
r += " file_offs 0x%08x" % (self.file_offs)
return r
def get_memory_type(self, image):
"""
Return a list describing the memory type(s) that is covered by this
segment's start address.
"""
return [
map_range[2]
for map_range in image.ROM_LOADER.MEMORY_MAP
if map_range[0] <= self.addr < map_range[1]
]
def pad_to_alignment(self, alignment):
self.data = pad_to(self.data, alignment, b"\x00")
class ELFSection(ImageSegment):
"""Wrapper class for a section in an ELF image, has a section
name as well as the common properties of an ImageSegment."""
def __init__(self, name, addr, data):
super(ELFSection, self).__init__(addr, data)
self.name = name.decode("utf-8")
def __repr__(self):
return "%s %s" % (self.name, super(ELFSection, self).__repr__())
class BaseFirmwareImage(object):
SEG_HEADER_LEN = 8
SHA256_DIGEST_LEN = 32
""" Base class with common firmware image functions """
def __init__(self):
self.segments = []
self.entrypoint = 0
self.elf_sha256 = None
self.elf_sha256_offset = 0
self.pad_to_size = 0
def load_common_header(self, load_file, expected_magic):
(
magic,
segments,
self.flash_mode,
self.flash_size_freq,
self.entrypoint,
) = struct.unpack("<BBBBI", load_file.read(8))
if magic != expected_magic:
raise FatalError("Invalid firmware image magic=0x%x" % (magic))
return segments
def verify(self):
if len(self.segments) > 16:
raise FatalError(
"Invalid segment count %d (max 16). "
"Usually this indicates a linker script problem." % len(self.segments)
)
def load_segment(self, f, is_irom_segment=False):
"""Load the next segment from the image file"""
file_offs = f.tell()
(offset, size) = struct.unpack("<II", f.read(8))
self.warn_if_unusual_segment(offset, size, is_irom_segment)
segment_data = f.read(size)
if len(segment_data) < size:
raise FatalError(
"End of file reading segment 0x%x, length %d (actual length %d)"
% (offset, size, len(segment_data))
)
segment = ImageSegment(offset, segment_data, file_offs)
self.segments.append(segment)
return segment
def warn_if_unusual_segment(self, offset, size, is_irom_segment):
if not is_irom_segment:
if offset > 0x40200000 or offset < 0x3FFE0000 or size > 65536:
print("WARNING: Suspicious segment 0x%x, length %d" % (offset, size))
def maybe_patch_segment_data(self, f, segment_data):
"""
If SHA256 digest of the ELF file needs to be inserted into this segment, do so.
Returns segment data.
"""
segment_len = len(segment_data)
file_pos = f.tell() # file_pos is position in the .bin file
if (
self.elf_sha256_offset >= file_pos
and self.elf_sha256_offset < file_pos + segment_len
):
# SHA256 digest needs to be patched into this binary segment,
# calculate offset of the digest inside the binary segment.
patch_offset = self.elf_sha256_offset - file_pos
# Sanity checks
if (
patch_offset < self.SEG_HEADER_LEN
or patch_offset + self.SHA256_DIGEST_LEN > segment_len
):
raise FatalError(
"Cannot place SHA256 digest on segment boundary"
"(elf_sha256_offset=%d, file_pos=%d, segment_size=%d)"
% (self.elf_sha256_offset, file_pos, segment_len)
)
# offset relative to the data part
patch_offset -= self.SEG_HEADER_LEN
if (
segment_data[patch_offset : patch_offset + self.SHA256_DIGEST_LEN]
!= b"\x00" * self.SHA256_DIGEST_LEN
):
raise FatalError(
"Contents of segment at SHA256 digest offset 0x%x are not all zero."
" Refusing to overwrite." % self.elf_sha256_offset
)
assert len(self.elf_sha256) == self.SHA256_DIGEST_LEN
segment_data = (
segment_data[0:patch_offset]
+ self.elf_sha256
+ segment_data[patch_offset + self.SHA256_DIGEST_LEN :]
)
return segment_data
def save_segment(self, f, segment, checksum=None):
"""
Save the next segment to the image file,
return next checksum value if provided
"""
segment_data = self.maybe_patch_segment_data(f, segment.data)
f.write(struct.pack("<II", segment.addr, len(segment_data)))
f.write(segment_data)
if checksum is not None:
return ESPLoader.checksum(segment_data, checksum)
def save_flash_segment(self, f, segment, checksum=None):
"""
Save the next segment to the image file, return next checksum value if provided
"""
if self.ROM_LOADER.CHIP_NAME == "ESP32":
# Work around a bug in ESP-IDF 2nd stage bootloader, that it didn't map the
# last MMU page, if an IROM/DROM segment was < 0x24 bytes
# over the page boundary.
segment_end_pos = f.tell() + len(segment.data) + self.SEG_HEADER_LEN
segment_len_remainder = segment_end_pos % self.IROM_ALIGN
if segment_len_remainder < 0x24:
segment.data += b"\x00" * (0x24 - segment_len_remainder)
return self.save_segment(f, segment, checksum)
def read_checksum(self, f):
"""Return ESPLoader checksum from end of just-read image"""
# Skip the padding. The checksum is stored in the last byte so that the
# file is a multiple of 16 bytes.
align_file_position(f, 16)
return ord(f.read(1))
def calculate_checksum(self):
"""
Calculate checksum of loaded image, based on segments in
segment array.
"""
checksum = ESPLoader.ESP_CHECKSUM_MAGIC
for seg in self.segments:
if seg.include_in_checksum:
checksum = ESPLoader.checksum(seg.data, checksum)
return checksum
def append_checksum(self, f, checksum):
"""Append ESPLoader checksum to the just-written image"""
align_file_position(f, 16)
f.write(struct.pack(b"B", checksum))
def write_common_header(self, f, segments):
f.write(
struct.pack(
"<BBBBI",
ESPLoader.ESP_IMAGE_MAGIC,
len(segments),
self.flash_mode,
self.flash_size_freq,
self.entrypoint,
)
)
def is_irom_addr(self, addr):
"""
Returns True if an address starts in the irom region.
Valid for ESP8266 only.
"""
return ESP8266ROM.IROM_MAP_START <= addr < ESP8266ROM.IROM_MAP_END
def get_irom_segment(self):
irom_segments = [s for s in self.segments if self.is_irom_addr(s.addr)]
if len(irom_segments) > 0:
if len(irom_segments) != 1:
raise FatalError(
"Found %d segments that could be irom0. Bad ELF file?"
% len(irom_segments)
)
return irom_segments[0]
return None
def get_non_irom_segments(self):
irom_segment = self.get_irom_segment()
return [s for s in self.segments if s != irom_segment]
def merge_adjacent_segments(self):
if not self.segments:
return # nothing to merge
segments = []
# The easiest way to merge the sections is the browse them backward.
for i in range(len(self.segments) - 1, 0, -1):
# elem is the previous section, the one `next_elem` may need to be
# merged in
elem = self.segments[i - 1]
next_elem = self.segments[i]
if all(
(
elem.get_memory_type(self) == next_elem.get_memory_type(self),
elem.include_in_checksum == next_elem.include_in_checksum,
next_elem.addr == elem.addr + len(elem.data),
)
):
# Merge any segment that ends where the next one starts,
# without spanning memory types
#
# (don't 'pad' any gaps here as they may be excluded from the image
# due to 'noinit' or other reasons.)
elem.data += next_elem.data
else:
# The section next_elem cannot be merged into the previous one,
# which means it needs to be part of the final segments.
# As we are browsing the list backward, the elements need to be
# inserted at the beginning of the final list.
segments.insert(0, next_elem)
# The first segment will always be here as it cannot be merged into any
# "previous" section.
segments.insert(0, self.segments[0])
# note: we could sort segments here as well, but the ordering of segments is
# sometimes important for other reasons (like embedded ELF SHA-256),
# so we assume that the linker script will have produced any adjacent sections
# in linear order in the ELF, anyhow.
self.segments = segments
def set_mmu_page_size(self, size):
"""
If supported, this should be overridden by the chip-specific class.
Gets called in elf2image.
"""
print(
"WARNING: Changing MMU page size is not supported on {}! "
"Defaulting to 64KB.".format(self.ROM_LOADER.CHIP_NAME)
)
class ESP8266ROMFirmwareImage(BaseFirmwareImage):
"""'Version 1' firmware image, segments loaded directly by the ROM bootloader."""
ROM_LOADER = ESP8266ROM
def __init__(self, load_file=None):
super(ESP8266ROMFirmwareImage, self).__init__()
self.flash_mode = 0
self.flash_size_freq = 0
self.version = 1
if load_file is not None:
segments = self.load_common_header(load_file, ESPLoader.ESP_IMAGE_MAGIC)
for _ in range(segments):
self.load_segment(load_file)
self.checksum = self.read_checksum(load_file)
self.verify()
def default_output_name(self, input_file):
"""Derive a default output name from the ELF name."""
return input_file + "-"
def save(self, basename):
"""Save a set of V1 images for flashing. Parameter is a base filename."""
# IROM data goes in its own plain binary file
irom_segment = self.get_irom_segment()
if irom_segment is not None:
with open(
"%s0x%05x.bin"
% (basename, irom_segment.addr - ESP8266ROM.IROM_MAP_START),
"wb",
) as f:
f.write(irom_segment.data)
# everything but IROM goes at 0x00000 in an image file
normal_segments = self.get_non_irom_segments()
with open("%s0x00000.bin" % basename, "wb") as f:
self.write_common_header(f, normal_segments)
checksum = ESPLoader.ESP_CHECKSUM_MAGIC
for segment in normal_segments:
checksum = self.save_segment(f, segment, checksum)
self.append_checksum(f, checksum)
ESP8266ROM.BOOTLOADER_IMAGE = ESP8266ROMFirmwareImage
class ESP8266V2FirmwareImage(BaseFirmwareImage):
"""'Version 2' firmware image, segments loaded by software bootloader stub
(ie Espressif bootloader or rboot)
"""
ROM_LOADER = ESP8266ROM
# First byte of the "v2" application image
IMAGE_V2_MAGIC = 0xEA
# First 'segment' value in a "v2" application image,
# appears to be a constant version value?
IMAGE_V2_SEGMENT = 4
def __init__(self, load_file=None):
super(ESP8266V2FirmwareImage, self).__init__()
self.version = 2
if load_file is not None:
segments = self.load_common_header(load_file, self.IMAGE_V2_MAGIC)
if segments != self.IMAGE_V2_SEGMENT:
# segment count is not really segment count here,
# but we expect to see '4'
print(
'Warning: V2 header has unexpected "segment" count %d (usually 4)'
% segments
)
# irom segment comes before the second header
#
# the file is saved in the image with a zero load address
# in the header, so we need to calculate a load address
irom_segment = self.load_segment(load_file, True)
# for actual mapped addr, add ESP8266ROM.IROM_MAP_START + flashing_addr + 8
irom_segment.addr = 0
irom_segment.include_in_checksum = False
first_flash_mode = self.flash_mode
first_flash_size_freq = self.flash_size_freq
first_entrypoint = self.entrypoint
# load the second header
segments = self.load_common_header(load_file, ESPLoader.ESP_IMAGE_MAGIC)
if first_flash_mode != self.flash_mode:
print(
"WARNING: Flash mode value in first header (0x%02x) disagrees "
"with second (0x%02x). Using second value."
% (first_flash_mode, self.flash_mode)
)
if first_flash_size_freq != self.flash_size_freq:
print(
"WARNING: Flash size/freq value in first header (0x%02x) disagrees "
"with second (0x%02x). Using second value."
% (first_flash_size_freq, self.flash_size_freq)
)
if first_entrypoint != self.entrypoint:
print(
"WARNING: Entrypoint address in first header (0x%08x) disagrees "
"with second header (0x%08x). Using second value."
% (first_entrypoint, self.entrypoint)
)
# load all the usual segments
for _ in range(segments):
self.load_segment(load_file)
self.checksum = self.read_checksum(load_file)
self.verify()
def default_output_name(self, input_file):
"""Derive a default output name from the ELF name."""
irom_segment = self.get_irom_segment()
if irom_segment is not None:
irom_offs = irom_segment.addr - ESP8266ROM.IROM_MAP_START
else:
irom_offs = 0
return "%s-0x%05x.bin" % (
os.path.splitext(input_file)[0],
irom_offs & ~(ESPLoader.FLASH_SECTOR_SIZE - 1),
)
def save(self, filename):
with open(filename, "wb") as f:
# Save first header for irom0 segment
f.write(
struct.pack(
b"<BBBBI",
self.IMAGE_V2_MAGIC,
self.IMAGE_V2_SEGMENT,
self.flash_mode,
self.flash_size_freq,
self.entrypoint,
)
)
irom_segment = self.get_irom_segment()
if irom_segment is not None:
# save irom0 segment, make sure it has load addr 0 in the file
irom_segment = irom_segment.copy_with_new_addr(0)
irom_segment.pad_to_alignment(
16
) # irom_segment must end on a 16 byte boundary
self.save_segment(f, irom_segment)
# second header, matches V1 header and contains loadable segments
normal_segments = self.get_non_irom_segments()
self.write_common_header(f, normal_segments)
checksum = ESPLoader.ESP_CHECKSUM_MAGIC
for segment in normal_segments:
checksum = self.save_segment(f, segment, checksum)
self.append_checksum(f, checksum)
# calculate a crc32 of entire file and append
# (algorithm used by recent 8266 SDK bootloaders)
with open(filename, "rb") as f:
crc = esp8266_crc32(f.read())
with open(filename, "ab") as f:
f.write(struct.pack(b"<I", crc))
def esp8266_crc32(data):
"""
CRC32 algorithm used by 8266 SDK bootloader (and gen_appbin.py).
"""
crc = binascii.crc32(data, 0) & 0xFFFFFFFF
if crc & 0x80000000:
return crc ^ 0xFFFFFFFF
else:
return crc + 1
class ESP32FirmwareImage(BaseFirmwareImage):
"""ESP32 firmware image is very similar to V1 ESP8266 image,
except with an additional 16 byte reserved header at top of image,
and because of new flash mapping capabilities the flash-mapped regions
can be placed in the normal image (just @ 64kB padded offsets).
"""
ROM_LOADER = ESP32ROM
# ROM bootloader will read the wp_pin field if SPI flash
# pins are remapped via flash. IDF actually enables QIO only
# from software bootloader, so this can be ignored. But needs
# to be set to this value so ROM bootloader will skip it.
WP_PIN_DISABLED = 0xEE
EXTENDED_HEADER_STRUCT_FMT = "<BBBBHBHH" + ("B" * 4) + "B"
IROM_ALIGN = 65536
def __init__(self, load_file=None, append_digest=True):
super(ESP32FirmwareImage, self).__init__()
self.secure_pad = None
self.flash_mode = 0
self.flash_size_freq = 0
self.version = 1
self.wp_pin = self.WP_PIN_DISABLED
# SPI pin drive levels
self.clk_drv = 0
self.q_drv = 0
self.d_drv = 0
self.cs_drv = 0
self.hd_drv = 0
self.wp_drv = 0
self.chip_id = 0
self.min_rev = 0
self.min_rev_full = 0
self.max_rev_full = 0
self.append_digest = append_digest
if load_file is not None:
start = load_file.tell()
segments = self.load_common_header(load_file, ESPLoader.ESP_IMAGE_MAGIC)
self.load_extended_header(load_file)
for _ in range(segments):
self.load_segment(load_file)
self.checksum = self.read_checksum(load_file)
if self.append_digest:
end = load_file.tell()
self.stored_digest = load_file.read(32)
load_file.seek(start)
calc_digest = hashlib.sha256()
calc_digest.update(load_file.read(end - start))
self.calc_digest = calc_digest.digest() # TODO: decide what to do here?
self.verify()
def is_flash_addr(self, addr):
return (
self.ROM_LOADER.IROM_MAP_START <= addr < self.ROM_LOADER.IROM_MAP_END
) or (self.ROM_LOADER.DROM_MAP_START <= addr < self.ROM_LOADER.DROM_MAP_END)
def default_output_name(self, input_file):
"""Derive a default output name from the ELF name."""
return "%s.bin" % (os.path.splitext(input_file)[0])
def warn_if_unusual_segment(self, offset, size, is_irom_segment):
pass # TODO: add warnings for wrong ESP32 segment offset/size combinations
def save(self, filename):
total_segments = 0
with io.BytesIO() as f: # write file to memory first
self.write_common_header(f, self.segments)
# first 4 bytes of header are read by ROM bootloader for SPI
# config, but currently unused
self.save_extended_header(f)
checksum = ESPLoader.ESP_CHECKSUM_MAGIC
# split segments into flash-mapped vs ram-loaded,
# and take copies so we can mutate them
flash_segments = [
copy.deepcopy(s)
for s in sorted(self.segments, key=lambda s: s.addr)
if self.is_flash_addr(s.addr)
]
ram_segments = [
copy.deepcopy(s)
for s in sorted(self.segments, key=lambda s: s.addr)
if not self.is_flash_addr(s.addr)
]
# Patch to support 761 union bus memmap // TODO: ESPTOOL-512
# move ".flash.appdesc" segment to the top of the flash segment
for segment in flash_segments:
if segment.name == ".flash.appdesc":
flash_segments.remove(segment)
flash_segments.insert(0, segment)
break
# For the bootloader image
# move ".dram0.bootdesc" segment to the top of the ram segment
# So bootdesc will be at the very top of the binary at 0x20 offset
# (in the first segment).
for segment in ram_segments:
if segment.name == ".dram0.bootdesc":
ram_segments.remove(segment)
ram_segments.insert(0, segment)
break
# check for multiple ELF sections that are mapped in the same
# flash mapping region. This is usually a sign of a broken linker script,
# but if you have a legitimate use case then let us know
if len(flash_segments) > 0:
last_addr = flash_segments[0].addr
for segment in flash_segments[1:]:
if segment.addr // self.IROM_ALIGN == last_addr // self.IROM_ALIGN:
raise FatalError(
"Segment loaded at 0x%08x lands in same 64KB flash mapping "
"as segment loaded at 0x%08x. Can't generate binary. "
"Suggest changing linker script or ELF to merge sections."
% (segment.addr, last_addr)
)
last_addr = segment.addr
def get_alignment_data_needed(segment):
# Actual alignment (in data bytes) required for a segment header:
# positioned so that after we write the next 8 byte header,
# file_offs % IROM_ALIGN == segment.addr % IROM_ALIGN
#
# (this is because the segment's vaddr may not be IROM_ALIGNed,
# more likely is aligned IROM_ALIGN+0x18
# to account for the binary file header
align_past = (segment.addr % self.IROM_ALIGN) - self.SEG_HEADER_LEN
pad_len = (self.IROM_ALIGN - (f.tell() % self.IROM_ALIGN)) + align_past
if pad_len == 0 or pad_len == self.IROM_ALIGN:
return 0 # already aligned
# subtract SEG_HEADER_LEN a second time,
# as the padding block has a header as well
pad_len -= self.SEG_HEADER_LEN
if pad_len < 0:
pad_len += self.IROM_ALIGN
return pad_len
# try to fit each flash segment on a 64kB aligned boundary
# by padding with parts of the non-flash segments...
while len(flash_segments) > 0:
segment = flash_segments[0]
pad_len = get_alignment_data_needed(segment)
if pad_len > 0: # need to pad
if len(ram_segments) > 0 and pad_len > self.SEG_HEADER_LEN:
pad_segment = ram_segments[0].split_image(pad_len)
if len(ram_segments[0].data) == 0:
ram_segments.pop(0)
else:
pad_segment = ImageSegment(0, b"\x00" * pad_len, f.tell())
checksum = self.save_segment(f, pad_segment, checksum)
total_segments += 1
else:
# write the flash segment
assert (
f.tell() + 8
) % self.IROM_ALIGN == segment.addr % self.IROM_ALIGN
checksum = self.save_flash_segment(f, segment, checksum)
flash_segments.pop(0)
total_segments += 1
# flash segments all written, so write any remaining RAM segments
for segment in ram_segments:
checksum = self.save_segment(f, segment, checksum)
total_segments += 1
if self.secure_pad:
# pad the image so that after signing it will end on a a 64KB boundary.
# This ensures all mapped flash content will be verified.
if not self.append_digest:
raise FatalError(
"secure_pad only applies if a SHA-256 digest "
"is also appended to the image"
)
align_past = (f.tell() + self.SEG_HEADER_LEN) % self.IROM_ALIGN
# 16 byte aligned checksum
# (force the alignment to simplify calculations)
checksum_space = 16
if self.secure_pad == "1":
# after checksum: SHA-256 digest +
# (to be added by signing process) version,
# signature + 12 trailing bytes due to alignment
space_after_checksum = 32 + 4 + 64 + 12
elif self.secure_pad == "2": # Secure Boot V2
# after checksum: SHA-256 digest +
# signature sector,
# but we place signature sector after the 64KB boundary
space_after_checksum = 32
pad_len = (
self.IROM_ALIGN - align_past - checksum_space - space_after_checksum
) % self.IROM_ALIGN
pad_segment = ImageSegment(0, b"\x00" * pad_len, f.tell())
checksum = self.save_segment(f, pad_segment, checksum)
total_segments += 1
# done writing segments
self.append_checksum(f, checksum)
image_length = f.tell()
if self.secure_pad:
assert ((image_length + space_after_checksum) % self.IROM_ALIGN) == 0
# kinda hacky: go back to the initial header and write the new segment count
# that includes padding segments. This header is not checksummed
f.seek(1)
f.write(bytes([total_segments]))
if self.append_digest:
# calculate the SHA256 of the whole file and append it
f.seek(0)
digest = hashlib.sha256()
digest.update(f.read(image_length))
f.write(digest.digest())
if self.pad_to_size:
image_length = f.tell()
if image_length % self.pad_to_size != 0:
pad_by = self.pad_to_size - (image_length % self.pad_to_size)
f.write(b"\xff" * pad_by)
with open(filename, "wb") as real_file:
real_file.write(f.getvalue())
def load_extended_header(self, load_file):
def split_byte(n):
return (n & 0x0F, (n >> 4) & 0x0F)
fields = list(
struct.unpack(self.EXTENDED_HEADER_STRUCT_FMT, load_file.read(16))
)
self.wp_pin = fields[0]
# SPI pin drive stengths are two per byte
self.clk_drv, self.q_drv = split_byte(fields[1])
self.d_drv, self.cs_drv = split_byte(fields[2])
self.hd_drv, self.wp_drv = split_byte(fields[3])
self.chip_id = fields[4]
if self.chip_id != self.ROM_LOADER.IMAGE_CHIP_ID:
print(
(
"Unexpected chip id in image. Expected %d but value was %d. "
"Is this image for a different chip model?"
)
% (self.ROM_LOADER.IMAGE_CHIP_ID, self.chip_id)
)
self.min_rev = fields[5]
self.min_rev_full = fields[6]
self.max_rev_full = fields[7]
append_digest = fields[-1] # last byte is append_digest
if append_digest in [0, 1]:
self.append_digest = append_digest == 1
else:
raise RuntimeError(
"Invalid value for append_digest field (0x%02x). Should be 0 or 1.",
append_digest,
)
def save_extended_header(self, save_file):
def join_byte(ln, hn):
return (ln & 0x0F) + ((hn & 0x0F) << 4)
append_digest = 1 if self.append_digest else 0
fields = [
self.wp_pin,
join_byte(self.clk_drv, self.q_drv),
join_byte(self.d_drv, self.cs_drv),
join_byte(self.hd_drv, self.wp_drv),
self.ROM_LOADER.IMAGE_CHIP_ID,
self.min_rev,
self.min_rev_full,
self.max_rev_full,
]
fields += [0] * 4 # padding
fields += [append_digest]
packed = struct.pack(self.EXTENDED_HEADER_STRUCT_FMT, *fields)
save_file.write(packed)
class ESP8266V3FirmwareImage(ESP32FirmwareImage):
"""ESP8266 V3 firmware image is very similar to ESP32 image"""
EXTENDED_HEADER_STRUCT_FMT = "B" * 16
def is_flash_addr(self, addr):
return addr > ESP8266ROM.IROM_MAP_START
def save(self, filename):
total_segments = 0
with io.BytesIO() as f: # write file to memory first
self.write_common_header(f, self.segments)
checksum = ESPLoader.ESP_CHECKSUM_MAGIC
# split segments into flash-mapped vs ram-loaded,
# and take copies so we can mutate them
flash_segments = [
copy.deepcopy(s)
for s in sorted(self.segments, key=lambda s: s.addr)
if self.is_flash_addr(s.addr) and len(s.data)
]
ram_segments = [
copy.deepcopy(s)
for s in sorted(self.segments, key=lambda s: s.addr)
if not self.is_flash_addr(s.addr) and len(s.data)
]
# check for multiple ELF sections that are mapped in the same
# flash mapping region. This is usually a sign of a broken linker script,
# but if you have a legitimate use case then let us know
if len(flash_segments) > 0:
last_addr = flash_segments[0].addr
for segment in flash_segments[1:]:
if segment.addr // self.IROM_ALIGN == last_addr // self.IROM_ALIGN:
raise FatalError(
"Segment loaded at 0x%08x lands in same 64KB flash mapping "
"as segment loaded at 0x%08x. Can't generate binary. "
"Suggest changing linker script or ELF to merge sections."
% (segment.addr, last_addr)
)
last_addr = segment.addr
# try to fit each flash segment on a 64kB aligned boundary
# by padding with parts of the non-flash segments...
while len(flash_segments) > 0:
segment = flash_segments[0]
# remove 8 bytes empty data for insert segment header
if segment.name == ".flash.rodata":
segment.data = segment.data[8:]
# write the flash segment
checksum = self.save_segment(f, segment, checksum)
flash_segments.pop(0)
total_segments += 1
# flash segments all written, so write any remaining RAM segments
for segment in ram_segments:
checksum = self.save_segment(f, segment, checksum)
total_segments += 1
# done writing segments
self.append_checksum(f, checksum)
image_length = f.tell()
# kinda hacky: go back to the initial header and write the new segment count
# that includes padding segments. This header is not checksummed
f.seek(1)
f.write(bytes([total_segments]))
if self.append_digest:
# calculate the SHA256 of the whole file and append it
f.seek(0)
digest = hashlib.sha256()
digest.update(f.read(image_length))
f.write(digest.digest())
with open(filename, "wb") as real_file:
real_file.write(f.getvalue())
def load_extended_header(self, load_file):
def split_byte(n):
return (n & 0x0F, (n >> 4) & 0x0F)
fields = list(
struct.unpack(self.EXTENDED_HEADER_STRUCT_FMT, load_file.read(16))
)
self.wp_pin = fields[0]
# SPI pin drive stengths are two per byte
self.clk_drv, self.q_drv = split_byte(fields[1])
self.d_drv, self.cs_drv = split_byte(fields[2])
self.hd_drv, self.wp_drv = split_byte(fields[3])
if fields[15] in [0, 1]:
self.append_digest = fields[15] == 1
else:
raise RuntimeError(
"Invalid value for append_digest field (0x%02x). Should be 0 or 1.",
fields[15],
)
# remaining fields in the middle should all be zero
if any(f for f in fields[4:15] if f != 0):
print(
"Warning: some reserved header fields have non-zero values. "
"This image may be from a newer esptool.py?"
)
ESP32ROM.BOOTLOADER_IMAGE = ESP32FirmwareImage
class ESP32S2FirmwareImage(ESP32FirmwareImage):
"""ESP32S2 Firmware Image almost exactly the same as ESP32FirmwareImage"""
ROM_LOADER = ESP32S2ROM
ESP32S2ROM.BOOTLOADER_IMAGE = ESP32S2FirmwareImage
class ESP32S3BETA2FirmwareImage(ESP32FirmwareImage):
"""ESP32S3 Firmware Image almost exactly the same as ESP32FirmwareImage"""
ROM_LOADER = ESP32S3BETA2ROM
ESP32S3BETA2ROM.BOOTLOADER_IMAGE = ESP32S3BETA2FirmwareImage
class ESP32S3FirmwareImage(ESP32FirmwareImage):
"""ESP32S3 Firmware Image almost exactly the same as ESP32FirmwareImage"""
ROM_LOADER = ESP32S3ROM
ESP32S3ROM.BOOTLOADER_IMAGE = ESP32S3FirmwareImage
class ESP32C3FirmwareImage(ESP32FirmwareImage):
"""ESP32C3 Firmware Image almost exactly the same as ESP32FirmwareImage"""
ROM_LOADER = ESP32C3ROM
ESP32C3ROM.BOOTLOADER_IMAGE = ESP32C3FirmwareImage
class ESP32C6BETAFirmwareImage(ESP32FirmwareImage):
"""ESP32C6 Firmware Image almost exactly the same as ESP32FirmwareImage"""
ROM_LOADER = ESP32C6BETAROM
ESP32C6BETAROM.BOOTLOADER_IMAGE = ESP32C6BETAFirmwareImage
class ESP32H2BETA1FirmwareImage(ESP32FirmwareImage):
"""ESP32H2 Firmware Image almost exactly the same as ESP32FirmwareImage"""
ROM_LOADER = ESP32H2BETA1ROM
ESP32H2BETA1ROM.BOOTLOADER_IMAGE = ESP32H2BETA1FirmwareImage
class ESP32H2BETA2FirmwareImage(ESP32FirmwareImage):
"""ESP32H2 Firmware Image almost exactly the same as ESP32FirmwareImage"""
ROM_LOADER = ESP32H2BETA2ROM
ESP32H2BETA2ROM.BOOTLOADER_IMAGE = ESP32H2BETA2FirmwareImage
class ESP32C2FirmwareImage(ESP32FirmwareImage):
"""ESP32C2 Firmware Image almost exactly the same as ESP32FirmwareImage"""
ROM_LOADER = ESP32C2ROM
def set_mmu_page_size(self, size):
if size not in [16384, 32768, 65536]:
raise FatalError(
"{} bytes is not a valid ESP32-C2 page size, "
"select from 64KB, 32KB, 16KB.".format(size)
)
self.IROM_ALIGN = size
ESP32C2ROM.BOOTLOADER_IMAGE = ESP32C2FirmwareImage
class ESP32C6FirmwareImage(ESP32FirmwareImage):
"""ESP32C6 Firmware Image almost exactly the same as ESP32FirmwareImage"""
ROM_LOADER = ESP32C6ROM
def set_mmu_page_size(self, size):
if size not in [8192, 16384, 32768, 65536]:
raise FatalError(
"{} bytes is not a valid ESP32-C6 page size, "
"select from 64KB, 32KB, 16KB, 8KB.".format(size)
)
self.IROM_ALIGN = size
ESP32C6ROM.BOOTLOADER_IMAGE = ESP32C6FirmwareImage
class ESP32H2FirmwareImage(ESP32C6FirmwareImage):
"""ESP32H2 Firmware Image almost exactly the same as ESP32FirmwareImage"""
ROM_LOADER = ESP32H2ROM
ESP32H2ROM.BOOTLOADER_IMAGE = ESP32H2FirmwareImage
class ELFFile(object):
SEC_TYPE_PROGBITS = 0x01
SEC_TYPE_STRTAB = 0x03
SEC_TYPE_INITARRAY = 0x0E
SEC_TYPE_FINIARRAY = 0x0F
PROG_SEC_TYPES = (SEC_TYPE_PROGBITS, SEC_TYPE_INITARRAY, SEC_TYPE_FINIARRAY)
LEN_SEC_HEADER = 0x28
SEG_TYPE_LOAD = 0x01
LEN_SEG_HEADER = 0x20
def __init__(self, name):
# Load sections from the ELF file
self.name = name
with open(self.name, "rb") as f:
self._read_elf_file(f)
def get_section(self, section_name):
for s in self.sections:
if s.name == section_name:
return s
raise ValueError("No section %s in ELF file" % section_name)
def _read_elf_file(self, f):
# read the ELF file header
LEN_FILE_HEADER = 0x34
try:
(
ident,
_type,
machine,
_version,
self.entrypoint,
_phoff,
shoff,
_flags,
_ehsize,
_phentsize,
_phnum,
shentsize,
shnum,
shstrndx,
) = struct.unpack("<16sHHLLLLLHHHHHH", f.read(LEN_FILE_HEADER))
except struct.error as e:
raise FatalError(
"Failed to read a valid ELF header from %s: %s" % (self.name, e)
)
if byte(ident, 0) != 0x7F or ident[1:4] != b"ELF":
raise FatalError("%s has invalid ELF magic header" % self.name)
if machine not in [0x5E, 0xF3]:
raise FatalError(
"%s does not appear to be an Xtensa or an RISCV ELF file. "
"e_machine=%04x" % (self.name, machine)
)
if shentsize != self.LEN_SEC_HEADER:
raise FatalError(
"%s has unexpected section header entry size 0x%x (not 0x%x)"
% (self.name, shentsize, self.LEN_SEC_HEADER)
)
if shnum == 0:
raise FatalError("%s has 0 section headers" % (self.name))
self._read_sections(f, shoff, shnum, shstrndx)
self._read_segments(f, _phoff, _phnum, shstrndx)
def _read_sections(self, f, section_header_offs, section_header_count, shstrndx):
f.seek(section_header_offs)
len_bytes = section_header_count * self.LEN_SEC_HEADER
section_header = f.read(len_bytes)
if len(section_header) == 0:
raise FatalError(
"No section header found at offset %04x in ELF file."
% section_header_offs
)
if len(section_header) != (len_bytes):
raise FatalError(
"Only read 0x%x bytes from section header (expected 0x%x.) "
"Truncated ELF file?" % (len(section_header), len_bytes)
)
# walk through the section header and extract all sections
section_header_offsets = range(0, len(section_header), self.LEN_SEC_HEADER)
def read_section_header(offs):
name_offs, sec_type, _flags, lma, sec_offs, size = struct.unpack_from(
"<LLLLLL", section_header[offs:]
)
return (name_offs, sec_type, lma, size, sec_offs)
all_sections = [read_section_header(offs) for offs in section_header_offsets]
prog_sections = [s for s in all_sections if s[1] in ELFFile.PROG_SEC_TYPES]
# search for the string table section
if not (shstrndx * self.LEN_SEC_HEADER) in section_header_offsets:
raise FatalError("ELF file has no STRTAB section at shstrndx %d" % shstrndx)
_, sec_type, _, sec_size, sec_offs = read_section_header(
shstrndx * self.LEN_SEC_HEADER
)
if sec_type != ELFFile.SEC_TYPE_STRTAB:
print(
"WARNING: ELF file has incorrect STRTAB section type 0x%02x" % sec_type
)
f.seek(sec_offs)
string_table = f.read(sec_size)
# build the real list of ELFSections by reading the actual section names from
# the string table section, and actual data for each section
# from the ELF file itself
def lookup_string(offs):
raw = string_table[offs:]
return raw[: raw.index(b"\x00")]
def read_data(offs, size):
f.seek(offs)
return f.read(size)
prog_sections = [
ELFSection(lookup_string(n_offs), lma, read_data(offs, size))
for (n_offs, _type, lma, size, offs) in prog_sections
if lma != 0 and size > 0
]
self.sections = prog_sections
def _read_segments(self, f, segment_header_offs, segment_header_count, shstrndx):
f.seek(segment_header_offs)
len_bytes = segment_header_count * self.LEN_SEG_HEADER
segment_header = f.read(len_bytes)
if len(segment_header) == 0:
raise FatalError(
"No segment header found at offset %04x in ELF file."
% segment_header_offs
)
if len(segment_header) != (len_bytes):
raise FatalError(
"Only read 0x%x bytes from segment header (expected 0x%x.) "
"Truncated ELF file?" % (len(segment_header), len_bytes)
)
# walk through the segment header and extract all segments
segment_header_offsets = range(0, len(segment_header), self.LEN_SEG_HEADER)
def read_segment_header(offs):
(
seg_type,
seg_offs,
_vaddr,
lma,
size,
_memsize,
_flags,
_align,
) = struct.unpack_from("<LLLLLLLL", segment_header[offs:])
return (seg_type, lma, size, seg_offs)
all_segments = [read_segment_header(offs) for offs in segment_header_offsets]
prog_segments = [s for s in all_segments if s[0] == ELFFile.SEG_TYPE_LOAD]
def read_data(offs, size):
f.seek(offs)
return f.read(size)
prog_segments = [
ELFSection(b"PHDR", lma, read_data(offs, size))
for (_type, lma, size, offs) in prog_segments
if lma != 0 and size > 0
]
self.segments = prog_segments
def sha256(self):
# return SHA256 hash of the input ELF file
sha256 = hashlib.sha256()
with open(self.name, "rb") as f:
sha256.update(f.read())
return sha256.digest()
| 46,725 | Python | .py | 1,023 | 33.605083 | 88 | 0.578515 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,605 | loader.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/loader.py | # SPDX-FileCopyrightText: 2014-2023 Fredrik Ahlberg, Angus Gratton,
# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
import base64
import hashlib
import itertools
import json
import os
import re
import string
import struct
import sys
import time
from .config import load_config_file
from .reset import (
ClassicReset,
CustomReset,
DEFAULT_RESET_DELAY,
HardReset,
USBJTAGSerialReset,
UnixTightReset,
)
from .util import FatalError, NotImplementedInROMError, UnsupportedCommandError
from .util import byte, hexify, mask_to_shift, pad_to, strip_chip_name
try:
import serial
except ImportError:
print(
"Pyserial is not installed for %s. "
"Check the README for installation instructions." % (sys.executable)
)
raise
# check 'serial' is 'pyserial' and not 'serial'
# ref. https://github.com/espressif/esptool/issues/269
try:
if "serialization" in serial.__doc__ and "deserialization" in serial.__doc__:
raise ImportError(
"esptool.py depends on pyserial, but there is a conflict with a currently "
"installed package named 'serial'.\n"
"You may work around this by 'pip uninstall serial; pip install pyserial' "
"but this may break other installed Python software "
"that depends on 'serial'.\n"
"There is no good fix for this right now, "
"apart from configuring virtualenvs. "
"See https://github.com/espressif/esptool/issues/269#issuecomment-385298196"
" for discussion of the underlying issue(s)."
)
except TypeError:
pass # __doc__ returns None for pyserial
try:
import serial.tools.list_ports as list_ports
except ImportError:
print(
"The installed version (%s) of pyserial appears to be too old for esptool.py "
"(Python interpreter %s). Check the README for installation instructions."
% (sys.VERSION, sys.executable)
)
raise
except Exception:
if sys.platform == "darwin":
# swallow the exception, this is a known issue in pyserial+macOS Big Sur preview
# ref https://github.com/espressif/esptool/issues/540
list_ports = None
else:
raise
cfg, _ = load_config_file()
cfg = cfg["esptool"]
# Timeout for most flash operations
DEFAULT_TIMEOUT = cfg.getfloat("timeout", 3)
# Timeout for full chip erase
CHIP_ERASE_TIMEOUT = cfg.getfloat("chip_erase_timeout", 120)
# Longest any command can run
MAX_TIMEOUT = cfg.getfloat("max_timeout", CHIP_ERASE_TIMEOUT * 2)
# Timeout for syncing with bootloader
SYNC_TIMEOUT = cfg.getfloat("sync_timeout", 0.1)
# Timeout (per megabyte) for calculating md5sum
MD5_TIMEOUT_PER_MB = cfg.getfloat("md5_timeout_per_mb", 8)
# Timeout (per megabyte) for erasing a region
ERASE_REGION_TIMEOUT_PER_MB = cfg.getfloat("erase_region_timeout_per_mb", 30)
# Timeout (per megabyte) for erasing and writing data
ERASE_WRITE_TIMEOUT_PER_MB = cfg.getfloat("erase_write_timeout_per_mb", 40)
# Short timeout for ESP_MEM_END, as it may never respond
MEM_END_ROM_TIMEOUT = cfg.getfloat("mem_end_rom_timeout", 0.2)
# Timeout for serial port write
DEFAULT_SERIAL_WRITE_TIMEOUT = cfg.getfloat("serial_write_timeout", 10)
# Default number of times to try connection
DEFAULT_CONNECT_ATTEMPTS = cfg.getint("connect_attempts", 7)
# Number of times to try writing a data block
WRITE_BLOCK_ATTEMPTS = cfg.getint("write_block_attempts", 3)
STUBS_DIR = os.path.join(os.path.dirname(__file__), "targets", "stub_flasher")
def get_stub_json_path(chip_name):
chip_name = strip_chip_name(chip_name)
chip_name = chip_name.replace("esp", "")
return os.path.join(STUBS_DIR, f"stub_flasher_{chip_name}.json")
def timeout_per_mb(seconds_per_mb, size_bytes):
"""Scales timeouts which are size-specific"""
result = seconds_per_mb * (size_bytes / 1e6)
if result < DEFAULT_TIMEOUT:
return DEFAULT_TIMEOUT
return result
def check_supported_function(func, check_func):
"""
Decorator implementation that wraps a check around an ESPLoader
bootloader function to check if it's supported.
This is used to capture the multidimensional differences in
functionality between the ESP8266 & ESP32 (and later chips) ROM loaders, and the
software stub that runs on these. Not possible to do this cleanly
via inheritance alone.
"""
def inner(*args, **kwargs):
obj = args[0]
if check_func(obj):
return func(*args, **kwargs)
else:
raise NotImplementedInROMError(obj, func)
return inner
def stub_function_only(func):
"""Attribute for a function only supported in the software stub loader"""
return check_supported_function(func, lambda o: o.IS_STUB)
def stub_and_esp32_function_only(func):
"""Attribute for a function only supported by stubs or ESP32 and later chips ROM"""
return check_supported_function(
func, lambda o: o.IS_STUB or o.CHIP_NAME not in ["ESP8266"]
)
def esp32s3_or_newer_function_only(func):
"""Attribute for a function only supported by ESP32S3 and later chips ROM"""
return check_supported_function(
func, lambda o: o.CHIP_NAME not in ["ESP8266", "ESP32", "ESP32-S2"]
)
class StubFlasher:
def __init__(self, json_path):
with open(json_path) as json_file:
stub = json.load(json_file)
self.text = base64.b64decode(stub["text"])
self.text_start = stub["text_start"]
self.entry = stub["entry"]
try:
self.data = base64.b64decode(stub["data"])
self.data_start = stub["data_start"]
except KeyError:
self.data = None
self.data_start = None
class ESPLoader(object):
"""Base class providing access to ESP ROM & software stub bootloaders.
Subclasses provide ESP8266 & ESP32 Family specific functionality.
Don't instantiate this base class directly, either instantiate a subclass or
call cmds.detect_chip() which will interrogate the chip and return the
appropriate subclass instance.
"""
CHIP_NAME = "Espressif device"
IS_STUB = False
FPGA_SLOW_BOOT = False
DEFAULT_PORT = "/dev/ttyUSB0"
USES_RFC2217 = False
# Commands supported by ESP8266 ROM bootloader
ESP_FLASH_BEGIN = 0x02
ESP_FLASH_DATA = 0x03
ESP_FLASH_END = 0x04
ESP_MEM_BEGIN = 0x05
ESP_MEM_END = 0x06
ESP_MEM_DATA = 0x07
ESP_SYNC = 0x08
ESP_WRITE_REG = 0x09
ESP_READ_REG = 0x0A
# Some comands supported by ESP32 and later chips ROM bootloader (or -8266 w/ stub)
ESP_SPI_SET_PARAMS = 0x0B
ESP_SPI_ATTACH = 0x0D
ESP_READ_FLASH_SLOW = 0x0E # ROM only, much slower than the stub flash read
ESP_CHANGE_BAUDRATE = 0x0F
ESP_FLASH_DEFL_BEGIN = 0x10
ESP_FLASH_DEFL_DATA = 0x11
ESP_FLASH_DEFL_END = 0x12
ESP_SPI_FLASH_MD5 = 0x13
# Commands supported by ESP32-S2 and later chips ROM bootloader only
ESP_GET_SECURITY_INFO = 0x14
# Some commands supported by stub only
ESP_ERASE_FLASH = 0xD0
ESP_ERASE_REGION = 0xD1
ESP_READ_FLASH = 0xD2
ESP_RUN_USER_CODE = 0xD3
# Flash encryption encrypted data command
ESP_FLASH_ENCRYPT_DATA = 0xD4
# Response code(s) sent by ROM
ROM_INVALID_RECV_MSG = 0x05 # response if an invalid message is received
# Maximum block sized for RAM and Flash writes, respectively.
ESP_RAM_BLOCK = 0x1800
FLASH_WRITE_SIZE = 0x400
# Default baudrate. The ROM auto-bauds, so we can use more or less whatever we want.
ESP_ROM_BAUD = 115200
# First byte of the application image
ESP_IMAGE_MAGIC = 0xE9
# Initial state for the checksum routine
ESP_CHECKSUM_MAGIC = 0xEF
# Flash sector size, minimum unit of erase.
FLASH_SECTOR_SIZE = 0x1000
UART_DATE_REG_ADDR = 0x60000078
# This ROM address has a different value on each chip model
CHIP_DETECT_MAGIC_REG_ADDR = 0x40001000
UART_CLKDIV_MASK = 0xFFFFF
# Memory addresses
IROM_MAP_START = 0x40200000
IROM_MAP_END = 0x40300000
# The number of bytes in the UART response that signify command status
STATUS_BYTES_LENGTH = 2
# Bootloader flashing offset
BOOTLOADER_FLASH_OFFSET = 0x0
# ROM supports an encrypted flashing mode
SUPPORTS_ENCRYPTED_FLASH = False
# Response to ESP_SYNC might indicate that flasher stub is running
# instead of the ROM bootloader
sync_stub_detected = False
# Device PIDs
USB_JTAG_SERIAL_PID = 0x1001
# Chip IDs that are no longer supported by esptool
UNSUPPORTED_CHIPS = {6: "ESP32-S3(beta 3)"}
def __init__(self, port=DEFAULT_PORT, baud=ESP_ROM_BAUD, trace_enabled=False):
"""Base constructor for ESPLoader bootloader interaction
Don't call this constructor, either instantiate a specific
ROM class directly, or use cmds.detect_chip().
This base class has all of the instance methods for bootloader
functionality supported across various chips & stub
loaders. Subclasses replace the functions they don't support
with ones which throw NotImplementedInROMError().
"""
# True if esptool detects the ROM is in Secure Download Mode
self.secure_download_mode = False
# True if esptool detects conditions which require the stub to be disabled
self.stub_is_disabled = False
# Device-and-runtime-specific cache
self.cache = {
"flash_id": None,
"chip_id": None,
"uart_no": None,
"usb_pid": None,
}
if isinstance(port, str):
try:
self._port = serial.serial_for_url(port)
except serial.serialutil.SerialException:
raise FatalError(f"Could not open {port}, the port doesn't exist")
else:
self._port = port
self._slip_reader = slip_reader(self._port, self.trace)
# setting baud rate in a separate step is a workaround for
# CH341 driver on some Linux versions (this opens at 9600 then
# sets), shouldn't matter for other platforms/drivers. See
# https://github.com/espressif/esptool/issues/44#issuecomment-107094446
self._set_port_baudrate(baud)
self._trace_enabled = trace_enabled
# set write timeout, to prevent esptool blocked at write forever.
try:
self._port.write_timeout = DEFAULT_SERIAL_WRITE_TIMEOUT
except NotImplementedError:
# no write timeout for RFC2217 ports
# need to set the property back to None or it will continue to fail
self._port.write_timeout = None
@property
def serial_port(self):
return self._port.port
def _set_port_baudrate(self, baud):
try:
self._port.baudrate = baud
except IOError:
raise FatalError(
"Failed to set baud rate %d. The driver may not support this rate."
% baud
)
def read(self):
"""Read a SLIP packet from the serial port"""
return next(self._slip_reader)
def write(self, packet):
"""Write bytes to the serial port while performing SLIP escaping"""
buf = (
b"\xc0"
+ (packet.replace(b"\xdb", b"\xdb\xdd").replace(b"\xc0", b"\xdb\xdc"))
+ b"\xc0"
)
self.trace("Write %d bytes: %s", len(buf), HexFormatter(buf))
self._port.write(buf)
def trace(self, message, *format_args):
if self._trace_enabled:
now = time.time()
try:
delta = now - self._last_trace
except AttributeError:
delta = 0.0
self._last_trace = now
prefix = "TRACE +%.3f " % delta
print(prefix + (message % format_args))
@staticmethod
def checksum(data, state=ESP_CHECKSUM_MAGIC):
"""Calculate checksum of a blob, as it is defined by the ROM"""
for b in data:
state ^= b
return state
def command(
self,
op=None,
data=b"",
chk=0,
wait_response=True,
timeout=DEFAULT_TIMEOUT,
):
"""Send a request and read the response"""
saved_timeout = self._port.timeout
new_timeout = min(timeout, MAX_TIMEOUT)
if new_timeout != saved_timeout:
self._port.timeout = new_timeout
try:
if op is not None:
self.trace(
"command op=0x%02x data len=%s wait_response=%d "
"timeout=%.3f data=%s",
op,
len(data),
1 if wait_response else 0,
timeout,
HexFormatter(data),
)
pkt = struct.pack(b"<BBHI", 0x00, op, len(data), chk) + data
self.write(pkt)
if not wait_response:
return
# tries to get a response until that response has the
# same operation as the request or a retries limit has
# exceeded. This is needed for some esp8266s that
# reply with more sync responses than expected.
for retry in range(100):
p = self.read()
if len(p) < 8:
continue
(resp, op_ret, len_ret, val) = struct.unpack("<BBHI", p[:8])
if resp != 1:
continue
data = p[8:]
if op is None or op_ret == op:
return val, data
if byte(data, 0) != 0 and byte(data, 1) == self.ROM_INVALID_RECV_MSG:
# Unsupported read_reg can result in
# more than one error response for some reason
self.flush_input()
raise UnsupportedCommandError(self, op)
finally:
if new_timeout != saved_timeout:
self._port.timeout = saved_timeout
raise FatalError("Response doesn't match request")
def check_command(
self, op_description, op=None, data=b"", chk=0, timeout=DEFAULT_TIMEOUT
):
"""
Execute a command with 'command', check the result code and throw an appropriate
FatalError if it fails.
Returns the "result" of a successful command.
"""
val, data = self.command(op, data, chk, timeout=timeout)
# things are a bit weird here, bear with us
# the status bytes are the last 2/4 bytes in the data (depending on chip)
if len(data) < self.STATUS_BYTES_LENGTH:
raise FatalError(
"Failed to %s. Only got %d byte status response."
% (op_description, len(data))
)
status_bytes = data[-self.STATUS_BYTES_LENGTH :]
# only care if the first one is non-zero. If it is, the second byte is a reason.
if byte(status_bytes, 0) != 0:
raise FatalError.WithResult("Failed to %s" % op_description, status_bytes)
# if we had more data than just the status bytes, return it as the result
# (this is used by the md5sum command, maybe other commands?)
if len(data) > self.STATUS_BYTES_LENGTH:
return data[: -self.STATUS_BYTES_LENGTH]
else:
# otherwise, just return the 'val' field which comes from the reply header
# (this is used by read_reg)
return val
def flush_input(self):
self._port.flushInput()
self._slip_reader = slip_reader(self._port, self.trace)
def sync(self):
val, _ = self.command(
self.ESP_SYNC, b"\x07\x07\x12\x20" + 32 * b"\x55", timeout=SYNC_TIMEOUT
)
# ROM bootloaders send some non-zero "val" response. The flasher stub sends 0.
# If we receive 0 then it probably indicates that the chip wasn't or couldn't be
# reseted properly and esptool is talking to the flasher stub.
self.sync_stub_detected = val == 0
for _ in range(7):
val, _ = self.command()
self.sync_stub_detected &= val == 0
def _get_pid(self):
if self.cache["usb_pid"] is not None:
return self.cache["usb_pid"]
if list_ports is None:
print(
"\nListing all serial ports is currently not available. "
"Can't get device PID."
)
return
active_port = self._port.port
# Pyserial only identifies regular ports, URL handlers are not supported
if not active_port.lower().startswith(("com", "/dev/")):
print(
"\nDevice PID identification is only supported on "
"COM and /dev/ serial ports."
)
return
# Return the real path if the active port is a symlink
if active_port.startswith("/dev/") and os.path.islink(active_port):
active_port = os.path.realpath(active_port)
active_ports = [active_port]
# The "cu" (call-up) device has to be used for outgoing communication on MacOS
if sys.platform == "darwin" and "tty" in active_port:
active_ports.append(active_port.replace("tty", "cu"))
ports = list_ports.comports()
for p in ports:
if p.device in active_ports:
self.cache["usb_pid"] = p.pid
return p.pid
print(
f"\nFailed to get PID of a device on {active_port}, "
"using standard reset sequence."
)
def _connect_attempt(self, reset_strategy, mode="default_reset"):
"""A single connection attempt"""
last_error = None
boot_log_detected = False
download_mode = False
# If we're doing no_sync, we're likely communicating as a pass through
# with an intermediate device to the ESP32
if mode == "no_reset_no_sync":
return last_error
if mode != "no_reset":
if not self.USES_RFC2217: # Might block on rfc2217 ports
# Empty serial buffer to isolate boot log
self._port.reset_input_buffer()
reset_strategy() # Reset the chip to bootloader (download mode)
# Detect the ROM boot log and check actual boot mode (ESP32 and later only)
waiting = self._port.inWaiting()
read_bytes = self._port.read(waiting)
data = re.search(
b"boot:(0x[0-9a-fA-F]+)(.*waiting for download)?", read_bytes, re.DOTALL
)
if data is not None:
boot_log_detected = True
boot_mode = data.group(1)
download_mode = data.group(2) is not None
for _ in range(5):
try:
self.flush_input()
self._port.flushOutput()
self.sync()
return None
except FatalError as e:
print(".", end="")
sys.stdout.flush()
time.sleep(0.05)
last_error = e
if boot_log_detected:
last_error = FatalError(
"Wrong boot mode detected ({})! "
"The chip needs to be in download mode.".format(
boot_mode.decode("utf-8")
)
)
if download_mode:
last_error = FatalError(
"Download mode successfully detected, but getting no sync reply: "
"The serial TX path seems to be down."
)
return last_error
def get_memory_region(self, name):
"""
Returns a tuple of (start, end) for the memory map entry with the given name,
or None if it doesn't exist
"""
try:
return [(start, end) for (start, end, n) in self.MEMORY_MAP if n == name][0]
except IndexError:
return None
def _construct_reset_strategy_sequence(self, mode):
"""
Constructs a sequence of reset strategies based on the OS,
used ESP chip, external settings, and environment variables.
Returns a tuple of one or more reset strategies to be tried sequentially.
"""
cfg_custom_reset_sequence = cfg.get("custom_reset_sequence")
if cfg_custom_reset_sequence is not None:
return (CustomReset(self._port, cfg_custom_reset_sequence),)
cfg_reset_delay = cfg.getfloat("reset_delay")
if cfg_reset_delay is not None:
delay = extra_delay = cfg_reset_delay
else:
delay = DEFAULT_RESET_DELAY
extra_delay = DEFAULT_RESET_DELAY + 0.5
# This FPGA delay is for Espressif internal use
if (
self.FPGA_SLOW_BOOT
and os.environ.get("ESPTOOL_ENV_FPGA", "").strip() == "1"
):
delay = extra_delay = 7
# USB-JTAG/Serial mode
if mode == "usb_reset" or self._get_pid() == self.USB_JTAG_SERIAL_PID:
return (USBJTAGSerialReset(self._port),)
# USB-to-Serial bridge
if os.name != "nt" and not self._port.name.startswith("rfc2217:"):
return (
UnixTightReset(self._port, delay),
UnixTightReset(self._port, extra_delay),
ClassicReset(self._port, delay),
ClassicReset(self._port, extra_delay),
)
return (
ClassicReset(self._port, delay),
ClassicReset(self._port, extra_delay),
)
def connect(
self,
mode="default_reset",
attempts=DEFAULT_CONNECT_ATTEMPTS,
detecting=False,
warnings=True,
):
"""Try connecting repeatedly until successful, or giving up"""
if warnings and mode in ["no_reset", "no_reset_no_sync"]:
print(
'WARNING: Pre-connection option "{}" was selected.'.format(mode),
"Connection may fail if the chip is not in bootloader "
"or flasher stub mode.",
)
print("Connecting...", end="")
sys.stdout.flush()
last_error = None
reset_sequence = self._construct_reset_strategy_sequence(mode)
try:
for _, reset_strategy in zip(
range(attempts) if attempts > 0 else itertools.count(),
itertools.cycle(reset_sequence),
):
last_error = self._connect_attempt(reset_strategy, mode)
if last_error is None:
break
finally:
print("") # end 'Connecting...' line
if last_error is not None:
raise FatalError(
"Failed to connect to {}: {}"
"\nFor troubleshooting steps visit: "
"https://docs.espressif.com/projects/esptool/en/latest/troubleshooting.html".format( # noqa E501
self.CHIP_NAME, last_error
)
)
if not detecting:
try:
from .targets import ROM_LIST
# check the date code registers match what we expect to see
chip_magic_value = self.read_reg(ESPLoader.CHIP_DETECT_MAGIC_REG_ADDR)
if chip_magic_value not in self.CHIP_DETECT_MAGIC_VALUE:
actually = None
for cls in ROM_LIST:
if chip_magic_value in cls.CHIP_DETECT_MAGIC_VALUE:
actually = cls
break
if warnings and actually is None:
print(
"WARNING: This chip doesn't appear to be a %s "
"(chip magic value 0x%08x). "
"Probably it is unsupported by this version of esptool."
% (self.CHIP_NAME, chip_magic_value)
)
else:
raise FatalError(
"This chip is %s not %s. Wrong --chip argument?"
% (actually.CHIP_NAME, self.CHIP_NAME)
)
except UnsupportedCommandError:
self.secure_download_mode = True
try:
self.check_chip_id()
except UnsupportedCommandError:
# Fix for ROM not responding in SDM, reconnect and try again
if self.secure_download_mode:
self._connect_attempt(mode, reset_sequence[0])
self.check_chip_id()
else:
raise
self._post_connect()
def _post_connect(self):
"""
Additional initialization hook, may be overridden by the chip-specific class.
Gets called after connect, and after auto-detection.
"""
pass
def read_reg(self, addr, timeout=DEFAULT_TIMEOUT):
"""Read memory address in target"""
# we don't call check_command here because read_reg() function is called
# when detecting chip type, and the way we check for success
# (STATUS_BYTES_LENGTH) is different for different chip types (!)
val, data = self.command(
self.ESP_READ_REG, struct.pack("<I", addr), timeout=timeout
)
if byte(data, 0) != 0:
raise FatalError.WithResult(
"Failed to read register address %08x" % addr, data
)
return val
def write_reg(self, addr, value, mask=0xFFFFFFFF, delay_us=0, delay_after_us=0):
"""Write to memory address in target"""
command = struct.pack("<IIII", addr, value, mask, delay_us)
if delay_after_us > 0:
# add a dummy write to a date register as an excuse to have a delay
command += struct.pack(
"<IIII", self.UART_DATE_REG_ADDR, 0, 0, delay_after_us
)
return self.check_command("write target memory", self.ESP_WRITE_REG, command)
def update_reg(self, addr, mask, new_val):
"""
Update register at 'addr', replace the bits masked out by 'mask'
with new_val. new_val is shifted left to match the LSB of 'mask'
Returns just-written value of register.
"""
shift = mask_to_shift(mask)
val = self.read_reg(addr)
val &= ~mask
val |= (new_val << shift) & mask
self.write_reg(addr, val)
return val
def mem_begin(self, size, blocks, blocksize, offset):
"""Start downloading an application image to RAM"""
# check we're not going to overwrite a running stub with this data
if self.IS_STUB:
stub = StubFlasher(get_stub_json_path(self.CHIP_NAME))
load_start = offset
load_end = offset + size
for start, end in [
(stub.data_start, stub.data_start + len(stub.data)),
(stub.text_start, stub.text_start + len(stub.text)),
]:
if load_start < end and load_end > start:
raise FatalError(
"Software loader is resident at 0x%08x-0x%08x. "
"Can't load binary at overlapping address range 0x%08x-0x%08x. "
"Either change binary loading address, or use the --no-stub "
"option to disable the software loader."
% (start, end, load_start, load_end)
)
return self.check_command(
"enter RAM download mode",
self.ESP_MEM_BEGIN,
struct.pack("<IIII", size, blocks, blocksize, offset),
)
def mem_block(self, data, seq):
"""Send a block of an image to RAM"""
return self.check_command(
"write to target RAM",
self.ESP_MEM_DATA,
struct.pack("<IIII", len(data), seq, 0, 0) + data,
self.checksum(data),
)
def mem_finish(self, entrypoint=0):
"""Leave download mode and run the application"""
# Sending ESP_MEM_END usually sends a correct response back, however sometimes
# (with ROM loader) the executed code may reset the UART or change the baud rate
# before the transmit FIFO is empty. So in these cases we set a short timeout
# and ignore errors.
timeout = DEFAULT_TIMEOUT if self.IS_STUB else MEM_END_ROM_TIMEOUT
data = struct.pack("<II", int(entrypoint == 0), entrypoint)
try:
return self.check_command(
"leave RAM download mode", self.ESP_MEM_END, data=data, timeout=timeout
)
except FatalError:
if self.IS_STUB:
raise
pass
def flash_begin(self, size, offset, begin_rom_encrypted=False):
"""
Start downloading to Flash (performs an erase)
Returns number of blocks (of size self.FLASH_WRITE_SIZE) to write.
"""
num_blocks = (size + self.FLASH_WRITE_SIZE - 1) // self.FLASH_WRITE_SIZE
erase_size = self.get_erase_size(offset, size)
t = time.time()
if self.IS_STUB:
timeout = DEFAULT_TIMEOUT
else:
timeout = timeout_per_mb(
ERASE_REGION_TIMEOUT_PER_MB, size
) # ROM performs the erase up front
params = struct.pack(
"<IIII", erase_size, num_blocks, self.FLASH_WRITE_SIZE, offset
)
if self.SUPPORTS_ENCRYPTED_FLASH and not self.IS_STUB:
params += struct.pack("<I", 1 if begin_rom_encrypted else 0)
self.check_command(
"enter Flash download mode", self.ESP_FLASH_BEGIN, params, timeout=timeout
)
if size != 0 and not self.IS_STUB:
print("Took %.2fs to erase flash block" % (time.time() - t))
return num_blocks
def flash_block(self, data, seq, timeout=DEFAULT_TIMEOUT):
"""Write block to flash, retry if fail"""
for attempts_left in range(WRITE_BLOCK_ATTEMPTS - 1, -1, -1):
try:
self.check_command(
"write to target Flash after seq %d" % seq,
self.ESP_FLASH_DATA,
struct.pack("<IIII", len(data), seq, 0, 0) + data,
self.checksum(data),
timeout=timeout,
)
break
except FatalError:
if attempts_left:
self.trace(
"Block write failed, "
f"retrying with {attempts_left} attempts left"
)
else:
raise
def flash_encrypt_block(self, data, seq, timeout=DEFAULT_TIMEOUT):
"""Encrypt, write block to flash, retry if fail"""
if self.SUPPORTS_ENCRYPTED_FLASH and not self.IS_STUB:
# ROM support performs the encrypted writes via the normal write command,
# triggered by flash_begin(begin_rom_encrypted=True)
return self.flash_block(data, seq, timeout)
for attempts_left in range(WRITE_BLOCK_ATTEMPTS - 1, -1, -1):
try:
self.check_command(
"Write encrypted to target Flash after seq %d" % seq,
self.ESP_FLASH_ENCRYPT_DATA,
struct.pack("<IIII", len(data), seq, 0, 0) + data,
self.checksum(data),
timeout=timeout,
)
break
except FatalError:
if attempts_left:
self.trace(
"Encrypted block write failed, "
f"retrying with {attempts_left} attempts left"
)
else:
raise
def flash_finish(self, reboot=False):
"""Leave flash mode and run/reboot"""
pkt = struct.pack("<I", int(not reboot))
# stub sends a reply to this command
self.check_command("leave Flash mode", self.ESP_FLASH_END, pkt)
def run(self, reboot=False):
"""Run application code in flash"""
# Fake flash begin immediately followed by flash end
self.flash_begin(0, 0)
self.flash_finish(reboot)
def flash_id(self):
"""Read SPI flash manufacturer and device id"""
if self.cache["flash_id"] is None:
SPIFLASH_RDID = 0x9F
self.cache["flash_id"] = self.run_spiflash_command(SPIFLASH_RDID, b"", 24)
return self.cache["flash_id"]
def flash_type(self):
"""Read flash type bit field from eFuse. Returns 0, 1, None (not present)"""
return None # not implemented for all chip targets
def get_security_info(self):
res = self.check_command("get security info", self.ESP_GET_SECURITY_INFO, b"")
esp32s2 = True if len(res) == 12 else False
res = struct.unpack("<IBBBBBBBB" if esp32s2 else "<IBBBBBBBBII", res)
return {
"flags": res[0],
"flash_crypt_cnt": res[1],
"key_purposes": res[2:9],
"chip_id": None if esp32s2 else res[9],
"api_version": None if esp32s2 else res[10],
}
@esp32s3_or_newer_function_only
def get_chip_id(self):
if self.cache["chip_id"] is None:
res = self.check_command(
"get security info", self.ESP_GET_SECURITY_INFO, b""
)
res = struct.unpack(
"<IBBBBBBBBI", res[:16]
) # 4b flags, 1b flash_crypt_cnt, 7*1b key_purposes, 4b chip_id
self.cache["chip_id"] = res[9] # 2/4 status bytes invariant
return self.cache["chip_id"]
def get_uart_no(self):
"""
Read the UARTDEV_BUF_NO register to get the number of the currently used console
"""
if self.cache["uart_no"] is None:
self.cache["uart_no"] = self.read_reg(self.UARTDEV_BUF_NO) & 0xFF
return self.cache["uart_no"]
@classmethod
def parse_flash_size_arg(cls, arg):
try:
return cls.FLASH_SIZES[arg]
except KeyError:
raise FatalError(
"Flash size '%s' is not supported by this chip type. "
"Supported sizes: %s" % (arg, ", ".join(cls.FLASH_SIZES.keys()))
)
@classmethod
def parse_flash_freq_arg(cls, arg):
if arg is None:
# The encoding of the default flash frequency in FLASH_FREQUENCY is always 0
return 0
try:
return cls.FLASH_FREQUENCY[arg]
except KeyError:
raise FatalError(
"Flash frequency '%s' is not supported by this chip type. "
"Supported frequencies: %s"
% (arg, ", ".join(cls.FLASH_FREQUENCY.keys()))
)
def run_stub(self, stub=None):
if stub is None:
stub = StubFlasher(get_stub_json_path(self.CHIP_NAME))
if self.sync_stub_detected:
print("Stub is already running. No upload is necessary.")
return self.STUB_CLASS(self)
# Upload
print("Uploading stub...")
for field in [stub.text, stub.data]:
if field is not None:
offs = stub.text_start if field == stub.text else stub.data_start
length = len(field)
blocks = (length + self.ESP_RAM_BLOCK - 1) // self.ESP_RAM_BLOCK
self.mem_begin(length, blocks, self.ESP_RAM_BLOCK, offs)
for seq in range(blocks):
from_offs = seq * self.ESP_RAM_BLOCK
to_offs = from_offs + self.ESP_RAM_BLOCK
self.mem_block(field[from_offs:to_offs], seq)
print("Running stub...")
self.mem_finish(stub.entry)
try:
p = self.read()
except StopIteration:
raise FatalError(
"Failed to start stub. There was no response."
"\nTry increasing timeouts, for more information see: "
"https://docs.espressif.com/projects/esptool/en/latest/esptool/configuration-file.html" # noqa E501
)
if p != b"OHAI":
raise FatalError(f"Failed to start stub. Unexpected response: {p}")
print("Stub running...")
return self.STUB_CLASS(self)
@stub_and_esp32_function_only
def flash_defl_begin(self, size, compsize, offset):
"""
Start downloading compressed data to Flash (performs an erase)
Returns number of blocks (size self.FLASH_WRITE_SIZE) to write.
"""
num_blocks = (compsize + self.FLASH_WRITE_SIZE - 1) // self.FLASH_WRITE_SIZE
erase_blocks = (size + self.FLASH_WRITE_SIZE - 1) // self.FLASH_WRITE_SIZE
t = time.time()
if self.IS_STUB:
write_size = (
size # stub expects number of bytes here, manages erasing internally
)
timeout = DEFAULT_TIMEOUT
else:
write_size = (
erase_blocks * self.FLASH_WRITE_SIZE
) # ROM expects rounded up to erase block size
timeout = timeout_per_mb(
ERASE_REGION_TIMEOUT_PER_MB, write_size
) # ROM performs the erase up front
print("Compressed %d bytes to %d..." % (size, compsize))
params = struct.pack(
"<IIII", write_size, num_blocks, self.FLASH_WRITE_SIZE, offset
)
if self.SUPPORTS_ENCRYPTED_FLASH and not self.IS_STUB:
# extra param is to enter encrypted flash mode via ROM
# (not supported currently)
params += struct.pack("<I", 0)
self.check_command(
"enter compressed flash mode",
self.ESP_FLASH_DEFL_BEGIN,
params,
timeout=timeout,
)
if size != 0 and not self.IS_STUB:
# (stub erases as it writes, but ROM loaders erase on begin)
print("Took %.2fs to erase flash block" % (time.time() - t))
return num_blocks
@stub_and_esp32_function_only
def flash_defl_block(self, data, seq, timeout=DEFAULT_TIMEOUT):
"""Write block to flash, send compressed, retry if fail"""
for attempts_left in range(WRITE_BLOCK_ATTEMPTS - 1, -1, -1):
try:
self.check_command(
"write compressed data to flash after seq %d" % seq,
self.ESP_FLASH_DEFL_DATA,
struct.pack("<IIII", len(data), seq, 0, 0) + data,
self.checksum(data),
timeout=timeout,
)
break
except FatalError:
if attempts_left:
self.trace(
"Compressed block write failed, "
f"retrying with {attempts_left} attempts left"
)
else:
raise
@stub_and_esp32_function_only
def flash_defl_finish(self, reboot=False):
"""Leave compressed flash mode and run/reboot"""
if not reboot and not self.IS_STUB:
# skip sending flash_finish to ROM loader, as this
# exits the bootloader. Stub doesn't do this.
return
pkt = struct.pack("<I", int(not reboot))
self.check_command("leave compressed flash mode", self.ESP_FLASH_DEFL_END, pkt)
self.in_bootloader = False
@stub_and_esp32_function_only
def flash_md5sum(self, addr, size):
# the MD5 command returns additional bytes in the standard
# command reply slot
timeout = timeout_per_mb(MD5_TIMEOUT_PER_MB, size)
res = self.check_command(
"calculate md5sum",
self.ESP_SPI_FLASH_MD5,
struct.pack("<IIII", addr, size, 0, 0),
timeout=timeout,
)
if len(res) == 32:
return res.decode("utf-8") # already hex formatted
elif len(res) == 16:
return hexify(res).lower()
else:
raise FatalError("MD5Sum command returned unexpected result: %r" % res)
@stub_and_esp32_function_only
def change_baud(self, baud):
print("Changing baud rate to %d" % baud)
# stub takes the new baud rate and the old one
second_arg = self._port.baudrate if self.IS_STUB else 0
self.command(self.ESP_CHANGE_BAUDRATE, struct.pack("<II", baud, second_arg))
print("Changed.")
self._set_port_baudrate(baud)
time.sleep(0.05) # get rid of crap sent during baud rate change
self.flush_input()
@stub_function_only
def erase_flash(self):
# depending on flash chip model the erase may take this long (maybe longer!)
self.check_command(
"erase flash", self.ESP_ERASE_FLASH, timeout=CHIP_ERASE_TIMEOUT
)
@stub_function_only
def erase_region(self, offset, size):
if offset % self.FLASH_SECTOR_SIZE != 0:
raise FatalError("Offset to erase from must be a multiple of 4096")
if size % self.FLASH_SECTOR_SIZE != 0:
raise FatalError("Size of data to erase must be a multiple of 4096")
timeout = timeout_per_mb(ERASE_REGION_TIMEOUT_PER_MB, size)
self.check_command(
"erase region",
self.ESP_ERASE_REGION,
struct.pack("<II", offset, size),
timeout=timeout,
)
def read_flash_slow(self, offset, length, progress_fn):
raise NotImplementedInROMError(self, self.read_flash_slow)
def read_flash(self, offset, length, progress_fn=None):
if not self.IS_STUB:
return self.read_flash_slow(offset, length, progress_fn) # ROM-only routine
# issue a standard bootloader command to trigger the read
self.check_command(
"read flash",
self.ESP_READ_FLASH,
struct.pack("<IIII", offset, length, self.FLASH_SECTOR_SIZE, 64),
)
# now we expect (length // block_size) SLIP frames with the data
data = b""
while len(data) < length:
p = self.read()
data += p
if len(data) < length and len(p) < self.FLASH_SECTOR_SIZE:
raise FatalError(
"Corrupt data, expected 0x%x bytes but received 0x%x bytes"
% (self.FLASH_SECTOR_SIZE, len(p))
)
self.write(struct.pack("<I", len(data)))
if progress_fn and (len(data) % 1024 == 0 or len(data) == length):
progress_fn(len(data), length)
if progress_fn:
progress_fn(len(data), length)
if len(data) > length:
raise FatalError("Read more than expected")
digest_frame = self.read()
if len(digest_frame) != 16:
raise FatalError("Expected digest, got: %s" % hexify(digest_frame))
expected_digest = hexify(digest_frame).upper()
digest = hashlib.md5(data).hexdigest().upper()
if digest != expected_digest:
raise FatalError(
"Digest mismatch: expected %s, got %s" % (expected_digest, digest)
)
return data
def flash_spi_attach(self, hspi_arg):
"""Send SPI attach command to enable the SPI flash pins
ESP8266 ROM does this when you send flash_begin, ESP32 ROM
has it as a SPI command.
"""
# last 3 bytes in ESP_SPI_ATTACH argument are reserved values
arg = struct.pack("<I", hspi_arg)
if not self.IS_STUB:
# ESP32 ROM loader takes additional 'is legacy' arg, which is not
# currently supported in the stub loader or esptool.py
# (as it's not usually needed.)
is_legacy = 0
arg += struct.pack("BBBB", is_legacy, 0, 0, 0)
self.check_command("configure SPI flash pins", self.ESP_SPI_ATTACH, arg)
def flash_set_parameters(self, size):
"""Tell the ESP bootloader the parameters of the chip
Corresponds to the "flashchip" data structure that the ROM
has in RAM.
'size' is in bytes.
All other flash parameters are currently hardcoded (on ESP8266
these are mostly ignored by ROM code, on ESP32 I'm not sure.)
"""
fl_id = 0
total_size = size
block_size = 64 * 1024
sector_size = 4 * 1024
page_size = 256
status_mask = 0xFFFF
self.check_command(
"set SPI params",
self.ESP_SPI_SET_PARAMS,
struct.pack(
"<IIIIII",
fl_id,
total_size,
block_size,
sector_size,
page_size,
status_mask,
),
)
def run_spiflash_command(
self,
spiflash_command,
data=b"",
read_bits=0,
addr=None,
addr_len=0,
dummy_len=0,
):
"""Run an arbitrary SPI flash command.
This function uses the "USR_COMMAND" functionality in the ESP
SPI hardware, rather than the precanned commands supported by
hardware. So the value of spiflash_command is an actual command
byte, sent over the wire.
After writing command byte, writes 'data' to MOSI and then
reads back 'read_bits' of reply on MISO. Result is a number.
"""
# SPI_USR register flags
SPI_USR_COMMAND = 1 << 31
SPI_USR_ADDR = 1 << 30
SPI_USR_DUMMY = 1 << 29
SPI_USR_MISO = 1 << 28
SPI_USR_MOSI = 1 << 27
# SPI registers, base address differs ESP32* vs 8266
base = self.SPI_REG_BASE
SPI_CMD_REG = base + 0x00
SPI_ADDR_REG = base + 0x04
SPI_USR_REG = base + self.SPI_USR_OFFS
SPI_USR1_REG = base + self.SPI_USR1_OFFS
SPI_USR2_REG = base + self.SPI_USR2_OFFS
SPI_W0_REG = base + self.SPI_W0_OFFS
# following two registers are ESP32 and later chips only
if self.SPI_MOSI_DLEN_OFFS is not None:
# ESP32 and later chips have a more sophisticated way
# to set up "user" commands
def set_data_lengths(mosi_bits, miso_bits):
SPI_MOSI_DLEN_REG = base + self.SPI_MOSI_DLEN_OFFS
SPI_MISO_DLEN_REG = base + self.SPI_MISO_DLEN_OFFS
if mosi_bits > 0:
self.write_reg(SPI_MOSI_DLEN_REG, mosi_bits - 1)
if miso_bits > 0:
self.write_reg(SPI_MISO_DLEN_REG, miso_bits - 1)
flags = 0
if dummy_len > 0:
flags |= dummy_len - 1
if addr_len > 0:
flags |= (addr_len - 1) << SPI_USR_ADDR_LEN_SHIFT
if flags:
self.write_reg(SPI_USR1_REG, flags)
else:
def set_data_lengths(mosi_bits, miso_bits):
SPI_DATA_LEN_REG = SPI_USR1_REG
SPI_MOSI_BITLEN_S = 17
SPI_MISO_BITLEN_S = 8
mosi_mask = 0 if (mosi_bits == 0) else (mosi_bits - 1)
miso_mask = 0 if (miso_bits == 0) else (miso_bits - 1)
flags = (miso_mask << SPI_MISO_BITLEN_S) | (
mosi_mask << SPI_MOSI_BITLEN_S
)
if dummy_len > 0:
flags |= dummy_len - 1
if addr_len > 0:
flags |= (addr_len - 1) << SPI_USR_ADDR_LEN_SHIFT
self.write_reg(SPI_DATA_LEN_REG, flags)
# SPI peripheral "command" bitmasks for SPI_CMD_REG
SPI_CMD_USR = 1 << 18
# shift values
SPI_USR2_COMMAND_LEN_SHIFT = 28
SPI_USR_ADDR_LEN_SHIFT = 26
if read_bits > 32:
raise FatalError(
"Reading more than 32 bits back from a SPI flash "
"operation is unsupported"
)
if len(data) > 64:
raise FatalError(
"Writing more than 64 bytes of data with one SPI "
"command is unsupported"
)
data_bits = len(data) * 8
old_spi_usr = self.read_reg(SPI_USR_REG)
old_spi_usr2 = self.read_reg(SPI_USR2_REG)
flags = SPI_USR_COMMAND
if read_bits > 0:
flags |= SPI_USR_MISO
if data_bits > 0:
flags |= SPI_USR_MOSI
if addr_len > 0:
flags |= SPI_USR_ADDR
if dummy_len > 0:
flags |= SPI_USR_DUMMY
set_data_lengths(data_bits, read_bits)
self.write_reg(SPI_USR_REG, flags)
self.write_reg(
SPI_USR2_REG, (7 << SPI_USR2_COMMAND_LEN_SHIFT) | spiflash_command
)
if addr and addr_len > 0:
self.write_reg(SPI_ADDR_REG, addr)
if data_bits == 0:
self.write_reg(SPI_W0_REG, 0) # clear data register before we read it
else:
data = pad_to(data, 4, b"\00") # pad to 32-bit multiple
words = struct.unpack("I" * (len(data) // 4), data)
next_reg = SPI_W0_REG
for word in words:
self.write_reg(next_reg, word)
next_reg += 4
self.write_reg(SPI_CMD_REG, SPI_CMD_USR)
def wait_done():
for _ in range(10):
if (self.read_reg(SPI_CMD_REG) & SPI_CMD_USR) == 0:
return
raise FatalError("SPI command did not complete in time")
wait_done()
status = self.read_reg(SPI_W0_REG)
# restore some SPI controller registers
self.write_reg(SPI_USR_REG, old_spi_usr)
self.write_reg(SPI_USR2_REG, old_spi_usr2)
return status
def read_spiflash_sfdp(self, addr, read_bits):
CMD_RDSFDP = 0x5A
return self.run_spiflash_command(
CMD_RDSFDP, read_bits=read_bits, addr=addr, addr_len=24, dummy_len=8
)
def read_status(self, num_bytes=2):
"""Read up to 24 bits (num_bytes) of SPI flash status register contents
via RDSR, RDSR2, RDSR3 commands
Not all SPI flash supports all three commands. The upper 1 or 2
bytes may be 0xFF.
"""
SPIFLASH_RDSR = 0x05
SPIFLASH_RDSR2 = 0x35
SPIFLASH_RDSR3 = 0x15
status = 0
shift = 0
for cmd in [SPIFLASH_RDSR, SPIFLASH_RDSR2, SPIFLASH_RDSR3][0:num_bytes]:
status += self.run_spiflash_command(cmd, read_bits=8) << shift
shift += 8
return status
def write_status(self, new_status, num_bytes=2, set_non_volatile=False):
"""Write up to 24 bits (num_bytes) of new status register
num_bytes can be 1, 2 or 3.
Not all flash supports the additional commands to write the
second and third byte of the status register. When writing 2
bytes, esptool also sends a 16-byte WRSR command (as some
flash types use this instead of WRSR2.)
If the set_non_volatile flag is set, non-volatile bits will
be set as well as volatile ones (WREN used instead of WEVSR).
"""
SPIFLASH_WRSR = 0x01
SPIFLASH_WRSR2 = 0x31
SPIFLASH_WRSR3 = 0x11
SPIFLASH_WEVSR = 0x50
SPIFLASH_WREN = 0x06
SPIFLASH_WRDI = 0x04
enable_cmd = SPIFLASH_WREN if set_non_volatile else SPIFLASH_WEVSR
# try using a 16-bit WRSR (not supported by all chips)
# this may be redundant, but shouldn't hurt
if num_bytes == 2:
self.run_spiflash_command(enable_cmd)
self.run_spiflash_command(SPIFLASH_WRSR, struct.pack("<H", new_status))
# also try using individual commands
# (also not supported by all chips for num_bytes 2 & 3)
for cmd in [SPIFLASH_WRSR, SPIFLASH_WRSR2, SPIFLASH_WRSR3][0:num_bytes]:
self.run_spiflash_command(enable_cmd)
self.run_spiflash_command(cmd, struct.pack("B", new_status & 0xFF))
new_status >>= 8
self.run_spiflash_command(SPIFLASH_WRDI)
def get_crystal_freq(self):
"""
Figure out the crystal frequency from the UART clock divider
Returns a normalized value in integer MHz (only values 40 or 26 are supported)
"""
# The logic here is:
# - We know that our baud rate and the ESP UART baud rate are roughly the same,
# or we couldn't communicate
# - We can read the UART clock divider register to know how the ESP derives this
# from the APB bus frequency
# - Multiplying these two together gives us the bus frequency which is either
# the crystal frequency (ESP32) or double the crystal frequency (ESP8266).
# See the self.XTAL_CLK_DIVIDER parameter for this factor.
uart_div = self.read_reg(self.UART_CLKDIV_REG) & self.UART_CLKDIV_MASK
est_xtal = (self._port.baudrate * uart_div) / 1e6 / self.XTAL_CLK_DIVIDER
norm_xtal = 40 if est_xtal > 33 else 26
if abs(norm_xtal - est_xtal) > 1:
print(
"WARNING: Detected crystal freq %.2fMHz is quite different to "
"normalized freq %dMHz. Unsupported crystal in use?"
% (est_xtal, norm_xtal)
)
return norm_xtal
def hard_reset(self):
print("Hard resetting via RTS pin...")
HardReset(self._port)()
def soft_reset(self, stay_in_bootloader):
if not self.IS_STUB:
if stay_in_bootloader:
return # ROM bootloader is already in bootloader!
else:
# 'run user code' is as close to a soft reset as we can do
self.flash_begin(0, 0)
self.flash_finish(False)
else:
if stay_in_bootloader:
# soft resetting from the stub loader
# will re-load the ROM bootloader
self.flash_begin(0, 0)
self.flash_finish(True)
elif self.CHIP_NAME != "ESP8266":
raise FatalError(
"Soft resetting is currently only supported on ESP8266"
)
else:
# running user code from stub loader requires some hacks
# in the stub loader
self.command(self.ESP_RUN_USER_CODE, wait_response=False)
def check_chip_id(self):
try:
chip_id = self.get_chip_id()
if chip_id != self.IMAGE_CHIP_ID:
print(
"WARNING: Chip ID {} ({}) doesn't match expected Chip ID {}. "
"esptool may not work correctly.".format(
chip_id,
self.UNSUPPORTED_CHIPS.get(chip_id, "Unknown"),
self.IMAGE_CHIP_ID,
)
)
# Try to flash anyways by disabling stub
self.stub_is_disabled = True
except NotImplementedInROMError:
pass
def slip_reader(port, trace_function):
"""Generator to read SLIP packets from a serial port.
Yields one full SLIP packet at a time, raises exception on timeout or invalid data.
Designed to avoid too many calls to serial.read(1), which can bog
down on slow systems.
"""
def detect_panic_handler(input):
"""
Checks the input bytes for panic handler messages.
Raises a FatalError if Guru Meditation or Fatal Exception is found, as both
of these are used between different ROM versions.
Tries to also parse the error cause (e.g. IllegalInstruction).
"""
guru_meditation = (
rb"G?uru Meditation Error: (?:Core \d panic'ed \(([a-zA-Z ]*)\))?"
)
fatal_exception = rb"F?atal exception \(\d+\): (?:([a-zA-Z ]*)?.*epc)?"
# Search either for Guru Meditation or Fatal Exception
data = re.search(
rb"".join([rb"(?:", guru_meditation, rb"|", fatal_exception, rb")"]),
input,
re.DOTALL,
)
if data is not None:
cause = [
"({})".format(i.decode("utf-8"))
for i in [data.group(1), data.group(2)]
if i is not None
]
cause = f" {cause[0]}" if len(cause) else ""
msg = f"Guru Meditation Error detected{cause}"
raise FatalError(msg)
partial_packet = None
in_escape = False
successful_slip = False
while True:
waiting = port.inWaiting()
read_bytes = port.read(1 if waiting == 0 else waiting)
if read_bytes == b"":
if partial_packet is None: # fail due to no data
msg = (
"Serial data stream stopped: Possible serial noise or corruption."
if successful_slip
else "No serial data received."
)
else: # fail during packet transfer
msg = "Packet content transfer stopped (received {} bytes)".format(
len(partial_packet)
)
trace_function(msg)
raise FatalError(msg)
trace_function("Read %d bytes: %s", len(read_bytes), HexFormatter(read_bytes))
for b in read_bytes:
b = bytes([b])
if partial_packet is None: # waiting for packet header
if b == b"\xc0":
partial_packet = b""
else:
trace_function("Read invalid data: %s", HexFormatter(read_bytes))
remaining_data = port.read(port.inWaiting())
trace_function(
"Remaining data in serial buffer: %s",
HexFormatter(remaining_data),
)
detect_panic_handler(read_bytes + remaining_data)
raise FatalError(
"Invalid head of packet (0x%s): "
"Possible serial noise or corruption." % hexify(b)
)
elif in_escape: # part-way through escape sequence
in_escape = False
if b == b"\xdc":
partial_packet += b"\xc0"
elif b == b"\xdd":
partial_packet += b"\xdb"
else:
trace_function("Read invalid data: %s", HexFormatter(read_bytes))
remaining_data = port.read(port.inWaiting())
trace_function(
"Remaining data in serial buffer: %s",
HexFormatter(remaining_data),
)
detect_panic_handler(read_bytes + remaining_data)
raise FatalError("Invalid SLIP escape (0xdb, 0x%s)" % (hexify(b)))
elif b == b"\xdb": # start of escape sequence
in_escape = True
elif b == b"\xc0": # end of packet
trace_function("Received full packet: %s", HexFormatter(partial_packet))
yield partial_packet
partial_packet = None
successful_slip = True
else: # normal byte in packet
partial_packet += b
class HexFormatter(object):
"""
Wrapper class which takes binary data in its constructor
and returns a hex string as it's __str__ method.
This is intended for "lazy formatting" of trace() output
in hex format. Avoids overhead (significant on slow computers)
of generating long hex strings even if tracing is disabled.
Note that this doesn't save any overhead if passed as an
argument to "%", only when passed to trace()
If auto_split is set (default), any long line (> 16 bytes) will be
printed as separately indented lines, with ASCII decoding at the end
of each line.
"""
def __init__(self, binary_string, auto_split=True):
self._s = binary_string
self._auto_split = auto_split
def __str__(self):
if self._auto_split and len(self._s) > 16:
result = ""
s = self._s
while len(s) > 0:
line = s[:16]
ascii_line = "".join(
c
if (
c == " "
or (c in string.printable and c not in string.whitespace)
)
else "."
for c in line.decode("ascii", "replace")
)
s = s[16:]
result += "\n %-16s %-16s | %s" % (
hexify(line[:8], False),
hexify(line[8:], False),
ascii_line,
)
return result
else:
return hexify(self._s, False)
| 60,941 | Python | .py | 1,405 | 31.984342 | 116 | 0.573459 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,606 | __init__.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/__init__.py | # SPDX-FileCopyrightText: 2014-2022 Fredrik Ahlberg, Angus Gratton,
# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
__all__ = [
"chip_id",
"detect_chip",
"dump_mem",
"elf2image",
"erase_flash",
"erase_region",
"flash_id",
"get_security_info",
"image_info",
"load_ram",
"make_image",
"merge_bin",
"read_flash",
"read_flash_status",
"read_mac",
"read_mem",
"run",
"verify_flash",
"version",
"write_flash",
"write_flash_status",
"write_mem",
]
__version__ = "4.7-dev"
import argparse
import inspect
import os
import shlex
import sys
import time
import traceback
from esptool.cmds import (
DETECTED_FLASH_SIZES,
chip_id,
detect_chip,
detect_flash_size,
dump_mem,
elf2image,
erase_flash,
erase_region,
flash_id,
get_security_info,
image_info,
load_ram,
make_image,
merge_bin,
read_flash,
read_flash_status,
read_mac,
read_mem,
run,
verify_flash,
version,
write_flash,
write_flash_status,
write_mem,
)
from esptool.config import load_config_file
from esptool.loader import DEFAULT_CONNECT_ATTEMPTS, ESPLoader, list_ports
from esptool.targets import CHIP_DEFS, CHIP_LIST, ESP32ROM
from esptool.util import (
FatalError,
NotImplementedInROMError,
flash_size_bytes,
strip_chip_name,
)
import serial
def main(argv=None, esp=None):
"""
Main function for esptool
argv - Optional override for default arguments parsing (that uses sys.argv),
can be a list of custom arguments as strings. Arguments and their values
need to be added as individual items to the list
e.g. "-b 115200" thus becomes ['-b', '115200'].
esp - Optional override of the connected device previously
returned by get_default_connected_device()
"""
external_esp = esp is not None
parser = argparse.ArgumentParser(
description="esptool.py v%s - Espressif chips ROM Bootloader Utility"
% __version__,
prog="esptool",
)
parser.add_argument(
"--chip",
"-c",
help="Target chip type",
type=strip_chip_name,
choices=["auto"] + CHIP_LIST,
default=os.environ.get("ESPTOOL_CHIP", "auto"),
)
parser.add_argument(
"--port",
"-p",
help="Serial port device",
default=os.environ.get("ESPTOOL_PORT", None),
)
parser.add_argument(
"--baud",
"-b",
help="Serial port baud rate used when flashing/reading",
type=arg_auto_int,
default=os.environ.get("ESPTOOL_BAUD", ESPLoader.ESP_ROM_BAUD),
)
parser.add_argument(
"--before",
help="What to do before connecting to the chip",
choices=["default_reset", "usb_reset", "no_reset", "no_reset_no_sync"],
default=os.environ.get("ESPTOOL_BEFORE", "default_reset"),
)
parser.add_argument(
"--after",
"-a",
help="What to do after esptool.py is finished",
choices=["hard_reset", "soft_reset", "no_reset", "no_reset_stub"],
default=os.environ.get("ESPTOOL_AFTER", "hard_reset"),
)
parser.add_argument(
"--no-stub",
help="Disable launching the flasher stub, only talk to ROM bootloader. "
"Some features will not be available.",
action="store_true",
)
parser.add_argument(
"--trace",
"-t",
help="Enable trace-level output of esptool.py interactions.",
action="store_true",
)
parser.add_argument(
"--override-vddsdio",
help="Override ESP32 VDDSDIO internal voltage regulator (use with care)",
choices=ESP32ROM.OVERRIDE_VDDSDIO_CHOICES,
nargs="?",
)
parser.add_argument(
"--connect-attempts",
help=(
"Number of attempts to connect, negative or 0 for infinite. "
"Default: %d." % DEFAULT_CONNECT_ATTEMPTS
),
type=int,
default=os.environ.get("ESPTOOL_CONNECT_ATTEMPTS", DEFAULT_CONNECT_ATTEMPTS),
)
subparsers = parser.add_subparsers(
dest="operation", help="Run esptool.py {command} -h for additional help"
)
def add_spi_connection_arg(parent):
parent.add_argument(
"--spi-connection",
"-sc",
help="ESP32-only argument. Override default SPI Flash connection. "
"Value can be SPI, HSPI or a comma-separated list of 5 I/O numbers "
"to use for SPI flash (CLK,Q,D,HD,CS).",
action=SpiConnectionAction,
)
parser_load_ram = subparsers.add_parser(
"load_ram", help="Download an image to RAM and execute"
)
parser_load_ram.add_argument("filename", help="Firmware image")
parser_dump_mem = subparsers.add_parser(
"dump_mem", help="Dump arbitrary memory to disk"
)
parser_dump_mem.add_argument("address", help="Base address", type=arg_auto_int)
parser_dump_mem.add_argument(
"size", help="Size of region to dump", type=arg_auto_int
)
parser_dump_mem.add_argument("filename", help="Name of binary dump")
parser_read_mem = subparsers.add_parser(
"read_mem", help="Read arbitrary memory location"
)
parser_read_mem.add_argument("address", help="Address to read", type=arg_auto_int)
parser_write_mem = subparsers.add_parser(
"write_mem", help="Read-modify-write to arbitrary memory location"
)
parser_write_mem.add_argument("address", help="Address to write", type=arg_auto_int)
parser_write_mem.add_argument("value", help="Value", type=arg_auto_int)
parser_write_mem.add_argument(
"mask",
help="Mask of bits to write",
type=arg_auto_int,
nargs="?",
default="0xFFFFFFFF",
)
def add_spi_flash_subparsers(parent, allow_keep, auto_detect):
"""Add common parser arguments for SPI flash properties"""
extra_keep_args = ["keep"] if allow_keep else []
if auto_detect and allow_keep:
extra_fs_message = ", detect, or keep"
flash_sizes = ["detect", "keep"]
elif auto_detect:
extra_fs_message = ", or detect"
flash_sizes = ["detect"]
elif allow_keep:
extra_fs_message = ", or keep"
flash_sizes = ["keep"]
else:
extra_fs_message = ""
flash_sizes = []
parent.add_argument(
"--flash_freq",
"-ff",
help="SPI Flash frequency",
choices=extra_keep_args
+ [
"80m",
"60m",
"48m",
"40m",
"30m",
"26m",
"24m",
"20m",
"16m",
"15m",
"12m",
],
default=os.environ.get("ESPTOOL_FF", "keep" if allow_keep else None),
)
parent.add_argument(
"--flash_mode",
"-fm",
help="SPI Flash mode",
choices=extra_keep_args + ["qio", "qout", "dio", "dout"],
default=os.environ.get("ESPTOOL_FM", "keep" if allow_keep else "qio"),
)
parent.add_argument(
"--flash_size",
"-fs",
help="SPI Flash size in MegaBytes "
"(1MB, 2MB, 4MB, 8MB, 16MB, 32MB, 64MB, 128MB) "
"plus ESP8266-only (256KB, 512KB, 2MB-c1, 4MB-c1)" + extra_fs_message,
choices=flash_sizes
+ [
"256KB",
"512KB",
"1MB",
"2MB",
"2MB-c1",
"4MB",
"4MB-c1",
"8MB",
"16MB",
"32MB",
"64MB",
"128MB",
],
default=os.environ.get("ESPTOOL_FS", "keep" if allow_keep else "1MB"),
)
add_spi_connection_arg(parent)
parser_write_flash = subparsers.add_parser(
"write_flash", help="Write a binary blob to flash"
)
parser_write_flash.add_argument(
"addr_filename",
metavar="<address> <filename>",
help="Address followed by binary filename, separated by space",
action=AddrFilenamePairAction,
)
parser_write_flash.add_argument(
"--erase-all",
"-e",
help="Erase all regions of flash (not just write areas) before programming",
action="store_true",
)
add_spi_flash_subparsers(parser_write_flash, allow_keep=True, auto_detect=True)
parser_write_flash.add_argument(
"--no-progress", "-p", help="Suppress progress output", action="store_true"
)
parser_write_flash.add_argument(
"--verify",
help="Verify just-written data on flash "
"(mostly superfluous, data is read back during flashing)",
action="store_true",
)
parser_write_flash.add_argument(
"--encrypt",
help="Apply flash encryption when writing data "
"(required correct efuse settings)",
action="store_true",
)
# In order to not break backward compatibility,
# our list of encrypted files to flash is a new parameter
parser_write_flash.add_argument(
"--encrypt-files",
metavar="<address> <filename>",
help="Files to be encrypted on the flash. "
"Address followed by binary filename, separated by space.",
action=AddrFilenamePairAction,
)
parser_write_flash.add_argument(
"--ignore-flash-encryption-efuse-setting",
help="Ignore flash encryption efuse settings ",
action="store_true",
)
parser_write_flash.add_argument(
"--force",
help="Force write, skip security and compatibility checks. Use with caution!",
action="store_true",
)
compress_args = parser_write_flash.add_mutually_exclusive_group(required=False)
compress_args.add_argument(
"--compress",
"-z",
help="Compress data in transfer (default unless --no-stub is specified)",
action="store_true",
default=None,
)
compress_args.add_argument(
"--no-compress",
"-u",
help="Disable data compression during transfer "
"(default if --no-stub is specified)",
action="store_true",
)
subparsers.add_parser("run", help="Run application code in flash")
parser_image_info = subparsers.add_parser(
"image_info", help="Dump headers from a binary file (bootloader or application)"
)
parser_image_info.add_argument("filename", help="Image file to parse")
parser_image_info.add_argument(
"--version",
"-v",
help="Output format version (1 - legacy, 2 - extended)",
choices=["1", "2"],
default="1",
)
parser_make_image = subparsers.add_parser(
"make_image", help="Create an application image from binary files"
)
parser_make_image.add_argument("output", help="Output image file")
parser_make_image.add_argument(
"--segfile", "-f", action="append", help="Segment input file"
)
parser_make_image.add_argument(
"--segaddr",
"-a",
action="append",
help="Segment base address",
type=arg_auto_int,
)
parser_make_image.add_argument(
"--entrypoint",
"-e",
help="Address of entry point",
type=arg_auto_int,
default=0,
)
parser_elf2image = subparsers.add_parser(
"elf2image", help="Create an application image from ELF file"
)
parser_elf2image.add_argument("input", help="Input ELF file")
parser_elf2image.add_argument(
"--output",
"-o",
help="Output filename prefix (for version 1 image), "
"or filename (for version 2 single image)",
type=str,
)
parser_elf2image.add_argument(
"--version",
"-e",
help="Output image version",
choices=["1", "2", "3"],
default="1",
)
parser_elf2image.add_argument(
# it kept for compatibility
# Minimum chip revision (deprecated, consider using --min-rev-full)
"--min-rev",
"-r",
help=argparse.SUPPRESS,
type=int,
choices=range(256),
metavar="{0, ... 255}",
default=0,
)
parser_elf2image.add_argument(
"--min-rev-full",
help="Minimal chip revision (in format: major * 100 + minor)",
type=int,
choices=range(65536),
metavar="{0, ... 65535}",
default=0,
)
parser_elf2image.add_argument(
"--max-rev-full",
help="Maximal chip revision (in format: major * 100 + minor)",
type=int,
choices=range(65536),
metavar="{0, ... 65535}",
default=65535,
)
parser_elf2image.add_argument(
"--secure-pad",
action="store_true",
help="Pad image so once signed it will end on a 64KB boundary. "
"For Secure Boot v1 images only.",
)
parser_elf2image.add_argument(
"--secure-pad-v2",
action="store_true",
help="Pad image to 64KB, so once signed its signature sector will"
"start at the next 64K block. For Secure Boot v2 images only.",
)
parser_elf2image.add_argument(
"--elf-sha256-offset",
help="If set, insert SHA256 hash (32 bytes) of the input ELF file "
"at specified offset in the binary.",
type=arg_auto_int,
default=None,
)
parser_elf2image.add_argument(
"--dont-append-digest",
dest="append_digest",
help="Don't append a SHA256 digest of the entire image after the checksum. "
"This argument is not supported and ignored for ESP8266.",
action="store_false",
default=True,
)
parser_elf2image.add_argument(
"--use_segments",
help="If set, ELF segments will be used instead of ELF sections "
"to genereate the image.",
action="store_true",
)
parser_elf2image.add_argument(
"--flash-mmu-page-size",
help="Change flash MMU page size.",
choices=["64KB", "32KB", "16KB", "8KB"],
)
parser_elf2image.add_argument(
"--pad-to-size",
help="The block size with which the final binary image after padding "
"must be aligned to. Value 0xFF is used for padding, similar to erase_flash",
default=None,
)
add_spi_flash_subparsers(parser_elf2image, allow_keep=False, auto_detect=False)
subparsers.add_parser("read_mac", help="Read MAC address from OTP ROM")
subparsers.add_parser("chip_id", help="Read Chip ID from OTP ROM")
parser_flash_id = subparsers.add_parser(
"flash_id", help="Read SPI flash manufacturer and device ID"
)
add_spi_connection_arg(parser_flash_id)
parser_read_status = subparsers.add_parser(
"read_flash_status", help="Read SPI flash status register"
)
add_spi_connection_arg(parser_read_status)
parser_read_status.add_argument(
"--bytes",
help="Number of bytes to read (1-3)",
type=int,
choices=[1, 2, 3],
default=2,
)
parser_write_status = subparsers.add_parser(
"write_flash_status", help="Write SPI flash status register"
)
add_spi_connection_arg(parser_write_status)
parser_write_status.add_argument(
"--non-volatile",
help="Write non-volatile bits (use with caution)",
action="store_true",
)
parser_write_status.add_argument(
"--bytes",
help="Number of status bytes to write (1-3)",
type=int,
choices=[1, 2, 3],
default=2,
)
parser_write_status.add_argument("value", help="New value", type=arg_auto_int)
parser_read_flash = subparsers.add_parser(
"read_flash", help="Read SPI flash content"
)
add_spi_connection_arg(parser_read_flash)
parser_read_flash.add_argument("address", help="Start address", type=arg_auto_int)
parser_read_flash.add_argument(
"size",
help="Size of region to dump. Use `ALL` to read to the end of flash.",
type=arg_auto_size,
)
parser_read_flash.add_argument("filename", help="Name of binary dump")
parser_read_flash.add_argument(
"--no-progress", "-p", help="Suppress progress output", action="store_true"
)
parser_verify_flash = subparsers.add_parser(
"verify_flash", help="Verify a binary blob against flash"
)
parser_verify_flash.add_argument(
"addr_filename",
help="Address and binary file to verify there, separated by space",
action=AddrFilenamePairAction,
)
parser_verify_flash.add_argument(
"--diff", "-d", help="Show differences", choices=["no", "yes"], default="no"
)
add_spi_flash_subparsers(parser_verify_flash, allow_keep=True, auto_detect=True)
parser_erase_flash = subparsers.add_parser(
"erase_flash", help="Perform Chip Erase on SPI flash"
)
parser_erase_flash.add_argument(
"--force",
help="Erase flash even if security features are enabled. Use with caution!",
action="store_true",
)
add_spi_connection_arg(parser_erase_flash)
parser_erase_region = subparsers.add_parser(
"erase_region", help="Erase a region of the flash"
)
parser_erase_region.add_argument(
"--force",
help="Erase region even if security features are enabled. Use with caution!",
action="store_true",
)
add_spi_connection_arg(parser_erase_region)
parser_erase_region.add_argument(
"address", help="Start address (must be multiple of 4096)", type=arg_auto_int
)
parser_erase_region.add_argument(
"size",
help="Size of region to erase (must be multiple of 4096). "
"Use `ALL` to erase to the end of flash.",
type=arg_auto_size,
)
parser_merge_bin = subparsers.add_parser(
"merge_bin",
help="Merge multiple raw binary files into a single file for later flashing",
)
parser_merge_bin.add_argument(
"--output", "-o", help="Output filename", type=str, required=True
)
parser_merge_bin.add_argument(
"--format", "-f", help="Format of the output file", choices="raw", default="raw"
) # for future expansion
add_spi_flash_subparsers(parser_merge_bin, allow_keep=True, auto_detect=False)
parser_merge_bin.add_argument(
"--target-offset",
"-t",
help="Target offset where the output file will be flashed",
type=arg_auto_int,
default=0,
)
parser_merge_bin.add_argument(
"--fill-flash-size",
help="If set, the final binary file will be padded with FF "
"bytes up to this flash size.",
choices=[
"256KB",
"512KB",
"1MB",
"2MB",
"4MB",
"8MB",
"16MB",
"32MB",
"64MB",
"128MB",
],
)
parser_merge_bin.add_argument(
"addr_filename",
metavar="<address> <filename>",
help="Address followed by binary filename, separated by space",
action=AddrFilenamePairAction,
)
subparsers.add_parser("get_security_info", help="Get some security-related data")
subparsers.add_parser("version", help="Print esptool version")
# internal sanity check - every operation matches a module function of the same name
for operation in subparsers.choices.keys():
assert operation in globals(), "%s should be a module function" % operation
argv = expand_file_arguments(argv or sys.argv[1:])
args = parser.parse_args(argv)
print("esptool.py v%s" % __version__)
load_config_file(verbose=True)
# operation function can take 1 arg (args), 2 args (esp, arg)
# or be a member function of the ESPLoader class.
if args.operation is None:
parser.print_help()
sys.exit(1)
# Forbid the usage of both --encrypt, which means encrypt all the given files,
# and --encrypt-files, which represents the list of files to encrypt.
# The reason is that allowing both at the same time increases the chances of
# having contradictory lists (e.g. one file not available in one of list).
if (
args.operation == "write_flash"
and args.encrypt
and args.encrypt_files is not None
):
raise FatalError(
"Options --encrypt and --encrypt-files "
"must not be specified at the same time."
)
operation_func = globals()[args.operation]
operation_args = inspect.getfullargspec(operation_func).args
if (
operation_args[0] == "esp"
): # operation function takes an ESPLoader connection object
if args.before != "no_reset_no_sync":
initial_baud = min(
ESPLoader.ESP_ROM_BAUD, args.baud
) # don't sync faster than the default baud rate
else:
initial_baud = args.baud
if args.port is None:
ser_list = get_port_list()
print("Found %d serial ports" % len(ser_list))
else:
ser_list = [args.port]
esp = esp or get_default_connected_device(
ser_list,
port=args.port,
connect_attempts=args.connect_attempts,
initial_baud=initial_baud,
chip=args.chip,
trace=args.trace,
before=args.before,
)
if esp is None:
raise FatalError(
"Could not connect to an Espressif device "
"on any of the %d available serial ports." % len(ser_list)
)
if esp.secure_download_mode:
print("Chip is %s in Secure Download Mode" % esp.CHIP_NAME)
else:
print("Chip is %s" % (esp.get_chip_description()))
print("Features: %s" % ", ".join(esp.get_chip_features()))
print("Crystal is %dMHz" % esp.get_crystal_freq())
read_mac(esp, args)
if not args.no_stub:
if esp.secure_download_mode:
print(
"WARNING: Stub loader is not supported in Secure Download Mode, "
"setting --no-stub"
)
args.no_stub = True
elif not esp.IS_STUB and esp.stub_is_disabled:
print(
"WARNING: Stub loader has been disabled for compatibility, "
"setting --no-stub"
)
args.no_stub = True
else:
try:
esp = esp.run_stub()
except Exception:
# The CH9102 bridge (PID: 0x55D4) can have issues on MacOS
if sys.platform == "darwin" and esp._get_pid() == 0x55D4:
print(
"\nNote: If issues persist, "
"try installing the WCH USB-to-Serial MacOS driver."
)
raise
if args.override_vddsdio:
esp.override_vddsdio(args.override_vddsdio)
if args.baud > initial_baud:
try:
esp.change_baud(args.baud)
except NotImplementedInROMError:
print(
"WARNING: ROM doesn't support changing baud rate. "
"Keeping initial baud rate %d" % initial_baud
)
# override common SPI flash parameter stuff if configured to do so
if hasattr(args, "spi_connection") and args.spi_connection is not None:
if esp.CHIP_NAME != "ESP32":
raise FatalError(
"Chip %s does not support --spi-connection option." % esp.CHIP_NAME
)
print("Configuring SPI flash mode...")
esp.flash_spi_attach(args.spi_connection)
elif args.no_stub:
print("Enabling default SPI flash mode...")
# ROM loader doesn't enable flash unless we explicitly do it
esp.flash_spi_attach(0)
# XMC chip startup sequence
XMC_VENDOR_ID = 0x20
def is_xmc_chip_strict():
id = esp.flash_id()
rdid = ((id & 0xFF) << 16) | ((id >> 16) & 0xFF) | (id & 0xFF00)
vendor_id = (rdid >> 16) & 0xFF
mfid = (rdid >> 8) & 0xFF
cpid = rdid & 0xFF
if vendor_id != XMC_VENDOR_ID:
return False
matched = False
if mfid == 0x40:
if cpid >= 0x13 and cpid <= 0x20:
matched = True
elif mfid == 0x41:
if cpid >= 0x17 and cpid <= 0x20:
matched = True
elif mfid == 0x50:
if cpid >= 0x15 and cpid <= 0x16:
matched = True
return matched
def flash_xmc_startup():
# If the RDID value is a valid XMC one, may skip the flow
fast_check = True
if fast_check and is_xmc_chip_strict():
return # Successful XMC flash chip boot-up detected by RDID, skipping.
sfdp_mfid_addr = 0x10
mf_id = esp.read_spiflash_sfdp(sfdp_mfid_addr, 8)
if mf_id != XMC_VENDOR_ID: # Non-XMC chip detected by SFDP Read, skipping.
return
print(
"WARNING: XMC flash chip boot-up failure detected! "
"Running XMC25QHxxC startup flow"
)
esp.run_spiflash_command(0xB9) # Enter DPD
esp.run_spiflash_command(0x79) # Enter UDPD
esp.run_spiflash_command(0xFF) # Exit UDPD
time.sleep(0.002) # Delay tXUDPD
esp.run_spiflash_command(0xAB) # Release Power-Down
time.sleep(0.00002)
# Check for success
if not is_xmc_chip_strict():
print("WARNING: XMC flash boot-up fix failed.")
print("XMC flash chip boot-up fix successful!")
# Check flash chip connection
if not esp.secure_download_mode:
try:
flash_id = esp.flash_id()
if flash_id in (0xFFFFFF, 0x000000):
print(
"WARNING: Failed to communicate with the flash chip, "
"read/write operations will fail. "
"Try checking the chip connections or removing "
"any other hardware connected to IOs."
)
except FatalError as e:
raise FatalError(f"Unable to verify flash chip connection ({e}).")
# Check if XMC SPI flash chip booted-up successfully, fix if not
if not esp.secure_download_mode:
try:
flash_xmc_startup()
except FatalError as e:
esp.trace(f"Unable to perform XMC flash chip startup sequence ({e}).")
if hasattr(args, "flash_size"):
print("Configuring flash size...")
if args.flash_size == "detect":
flash_size = detect_flash_size(esp, args)
elif args.flash_size == "keep":
flash_size = detect_flash_size(esp, args=None)
else:
flash_size = args.flash_size
if flash_size is not None: # Secure download mode
esp.flash_set_parameters(flash_size_bytes(flash_size))
# Check if stub supports chosen flash size
if esp.IS_STUB and flash_size in ("32MB", "64MB", "128MB"):
print(
"WARNING: Flasher stub doesn't fully support flash size larger "
"than 16MB, in case of failure use --no-stub."
)
if getattr(args, "size", "") == "all":
if esp.secure_download_mode:
raise FatalError(
"Detecting flash size is not supported in secure download mode. "
"Set an exact size value."
)
# detect flash size
flash_id = esp.flash_id()
size_id = flash_id >> 16
size_str = DETECTED_FLASH_SIZES.get(size_id)
if size_str is None:
raise FatalError(
"Detecting flash size failed. Set an exact size value."
)
print(f"Detected flash size: {size_str}")
args.size = flash_size_bytes(size_str)
if esp.IS_STUB and hasattr(args, "address") and hasattr(args, "size"):
if args.address + args.size > 0x1000000:
print(
"WARNING: Flasher stub doesn't fully support flash size larger "
"than 16MB, in case of failure use --no-stub."
)
try:
operation_func(esp, args)
finally:
try: # Clean up AddrFilenamePairAction files
for address, argfile in args.addr_filename:
argfile.close()
except AttributeError:
pass
# Handle post-operation behaviour (reset or other)
if operation_func == load_ram:
# the ESP is now running the loaded image, so let it run
print("Exiting immediately.")
elif args.after == "hard_reset":
esp.hard_reset()
elif args.after == "soft_reset":
print("Soft resetting...")
# flash_finish will trigger a soft reset
esp.soft_reset(False)
elif args.after == "no_reset_stub":
print("Staying in flasher stub.")
else: # args.after == 'no_reset'
print("Staying in bootloader.")
if esp.IS_STUB:
esp.soft_reset(True) # exit stub back to ROM loader
if not external_esp:
esp._port.close()
else:
operation_func(args)
def arg_auto_int(x):
return int(x, 0)
def arg_auto_size(x):
x = x.lower()
return x if x == "all" else arg_auto_int(x)
def get_port_list():
if list_ports is None:
raise FatalError(
"Listing all serial ports is currently not available. "
"Please try to specify the port when running esptool.py or update "
"the pyserial package to the latest version"
)
return sorted(ports.device for ports in list_ports.comports())
def expand_file_arguments(argv):
"""
Any argument starting with "@" gets replaced with all values read from a text file.
Text file arguments can be split by newline or by space.
Values are added "as-is", as if they were specified in this order
on the command line.
"""
new_args = []
expanded = False
for arg in argv:
if arg.startswith("@"):
expanded = True
with open(arg[1:], "r") as f:
for line in f.readlines():
new_args += shlex.split(line)
else:
new_args.append(arg)
if expanded:
print(f"esptool.py {' '.join(new_args)}")
return new_args
return argv
def get_default_connected_device(
serial_list,
port,
connect_attempts,
initial_baud,
chip="auto",
trace=False,
before="default_reset",
):
_esp = None
for each_port in reversed(serial_list):
print("Serial port %s" % each_port)
try:
if chip == "auto":
_esp = detect_chip(
each_port, initial_baud, before, trace, connect_attempts
)
else:
chip_class = CHIP_DEFS[chip]
_esp = chip_class(each_port, initial_baud, trace)
_esp.connect(before, connect_attempts)
break
except (FatalError, OSError) as err:
if port is not None:
raise
print("%s failed to connect: %s" % (each_port, err))
if _esp and _esp._port:
_esp._port.close()
_esp = None
return _esp
class SpiConnectionAction(argparse.Action):
"""
Custom action to parse 'spi connection' override.
Values are SPI, HSPI, or a sequence of 5 pin numbers separated by commas.
"""
def __call__(self, parser, namespace, value, option_string=None):
if value.upper() == "SPI":
value = 0
elif value.upper() == "HSPI":
value = 1
elif "," in value:
values = value.split(",")
if len(values) != 5:
raise argparse.ArgumentError(
self,
"%s is not a valid list of comma-separate pin numbers. "
"Must be 5 numbers - CLK,Q,D,HD,CS." % value,
)
try:
values = tuple(int(v, 0) for v in values)
except ValueError:
raise argparse.ArgumentError(
self,
"%s is not a valid argument. All pins must be numeric values"
% values,
)
if any([v for v in values if v > 33 or v < 0]):
raise argparse.ArgumentError(
self, "Pin numbers must be in the range 0-33."
)
# encode the pin numbers as a 32-bit integer with packed 6-bit values,
# the same way ESP32 ROM takes them
# TODO: make this less ESP32 ROM specific somehow...
clk, q, d, hd, cs = values
value = (hd << 24) | (cs << 18) | (d << 12) | (q << 6) | clk
else:
raise argparse.ArgumentError(
self,
"%s is not a valid spi-connection value. "
"Values are SPI, HSPI, or a sequence of 5 pin numbers CLK,Q,D,HD,CS)."
% value,
)
setattr(namespace, self.dest, value)
class AddrFilenamePairAction(argparse.Action):
"""Custom parser class for the address/filename pairs passed as arguments"""
def __init__(self, option_strings, dest, nargs="+", **kwargs):
super(AddrFilenamePairAction, self).__init__(
option_strings, dest, nargs, **kwargs
)
def __call__(self, parser, namespace, values, option_string=None):
# validate pair arguments
pairs = []
for i in range(0, len(values), 2):
try:
address = int(values[i], 0)
except ValueError:
raise argparse.ArgumentError(
self, 'Address "%s" must be a number' % values[i]
)
try:
argfile = open(values[i + 1], "rb")
except IOError as e:
raise argparse.ArgumentError(self, e)
except IndexError:
raise argparse.ArgumentError(
self,
"Must be pairs of an address "
"and the binary filename to write there",
)
pairs.append((address, argfile))
# Sort the addresses and check for overlapping
end = 0
for address, argfile in sorted(pairs, key=lambda x: x[0]):
argfile.seek(0, 2) # seek to end
size = argfile.tell()
argfile.seek(0)
sector_start = address & ~(ESPLoader.FLASH_SECTOR_SIZE - 1)
sector_end = (
(address + size + ESPLoader.FLASH_SECTOR_SIZE - 1)
& ~(ESPLoader.FLASH_SECTOR_SIZE - 1)
) - 1
if sector_start < end:
message = "Detected overlap at address: 0x%x for file: %s" % (
address,
argfile.name,
)
raise argparse.ArgumentError(self, message)
end = sector_end
setattr(namespace, self.dest, pairs)
def _main():
try:
main()
except FatalError as e:
print(f"\nA fatal error occurred: {e}")
sys.exit(2)
except serial.serialutil.SerialException as e:
print(f"\nA serial exception error occurred: {e}")
print(
"Note: This error originates from pySerial. "
"It is likely not a problem with esptool, "
"but with the hardware connection or drivers."
)
print(
"For troubleshooting steps visit: "
"https://docs.espressif.com/projects/esptool/en/latest/troubleshooting.html"
)
sys.exit(1)
except StopIteration:
print(traceback.format_exc())
print("A fatal error occurred: The chip stopped responding.")
sys.exit(2)
if __name__ == "__main__":
_main()
| 36,819 | Python | .py | 987 | 27.443769 | 88 | 0.570165 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,607 | config.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/__pycache__/config.cpython-310.pyc | o
’jÂd" ã @ s: d dl Z d dlZg d¢Zd
dd„Zd
dd„Zd
dd „ZdS ) é N)
ÚtimeoutÚchip_erase_timeoutÚ max_timeoutÚ sync_timeoutÚmd5_timeout_per_mbÚerase_region_timeout_per_mbÚerase_write_timeout_per_mbÚmem_end_rom_timeoutÚserial_write_timeoutÚconnect_attemptsÚwrite_block_attemptsÚ reset_delayÚcustom_reset_sequenceFc
C sì t j | ¡sdS t ¡ }z@|j| dd� | d¡rJ|rGtt| d¡ƒtt
ƒ ƒ}| ¡ t |ƒ}|dkrG|dkr:dnd}t
d |d
|¡¡ƒ W d S W dS ttjfyu } z|rjt
d | › d
|› �ƒ W Y d }~dS W Y d }~dS d }~ww )NFzUTF-8)ÚencodingÚesptoolr é ÚsÚ z)Ignoring unknown config file option{}: {}z, Tz Ignoring invalid config file z: )ÚosÚpathÚexistsÚ configparserÚRawConfigParserÚreadÚ has_sectionÚlistÚsetÚoptionsÚCONFIG_OPTIONSÚsortÚlenÚprintÚformatÚjoinÚUnicodeDecodeErrorÚError)Ú file_pathÚverboseÚcfgÚ unknown_optsÚno_of_unknown_optsÚsuffixÚe© r- ú./home/ceco/Downloads/esptool/esptool/config.pyÚ_validate_config_file s8
ÿÿôı
ş€ır/ c C s. dD ]}t j | |¡}t||ƒr| S qd S )N)z esptool.cfgz setup.cfgztox.ini)r r r# r/ )Údir_pathr' Ú candidateÚcfg_pathr- r- r. Ú_find_config_file5 s
ÿr3 c C sÎ d}t j d¡}|d urt|ƒr|}d}n(t j d¡}t jdkr%|› d�n|› d�}t ¡ ||fD ] }t|| ƒ}|r< nq1t
¡ }i |d< |d urc| |¡ | rc|rTd nd
}t d t j
|¡› |› �ƒ ||fS ) NFÚESPTOOL_CFGFILETú~Úposixz/.config/esptoolz/AppData/Local/esptool/r z (set with ESPTOOL_CFGFILE)r z!Loaded custom configuration from )r ÚenvironÚgetr/ r Ú
expanduserÚnameÚgetcwdr3 r Ú ConfigParserr r! Úabspath) r' Úset_with_env_varÚ env_var_pathÚ
cfg_file_pathÚhome_dirÚ
os_config_dirr0 r( Úmsgr- r- r. Úload_config_file= s: ÿı
ÿ
ÿÿÿrD )F)r r r r/ r3 rD r- r- r- r. Ú<module> s
| 2,152 | Python | .py | 20 | 106.4 | 570 | 0.527426 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,608 | util.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/__pycache__/util.cpython-310.pyc | o
’jÂdQ ã @ sº d dl Z d dlZd dlZd dlZdd„ Zdd„ Zdd„ Zdd „ Zd!d d „Zd"dd„Z d#dd„Z
dd„ Z dd„ Z dd„ Z
G dd„ deƒZG dd „ d eƒZG d d „ d eƒZG d d „ d eƒZdS )$é Nc C s | | S ©N© )ÚbitstrÚindexr r ú,/home/ceco/Downloads/esptool/esptool/util.pyÚbyte s r c C s0 d}| d@ dkr|d7 }| dL } | d@ dks|S )z9Return the index of the least significant bit in the maskr é r )ÚmaskÚshiftr r r Ú
mask_to_shift s şr c C s t | ƒt |ƒ d t |ƒ S )z¯Return a/b rounded up to nearest integer,
equivalent result to int(math.ceil(float(int(a)) / float(int(b))), only
without possible floating point accuracy errors.
r )Úint)ÚaÚbr r r Ú div_roundup s r c C s` | du rdS d| v rt | d| d¡… ƒd d S d| v r*t | d| d¡… ƒd S td| ƒ‚)zrGiven a flash size of the type passed in args.flash_size
(ie 512KB or 1MB) then return the size in bytes.
NÚMBi ÚKBzUnknown size %s)r r Ú
FatalError)Úsizer r r Úflash_size_bytes! s r Tc s$ |rdnd‰ d ‡ fdd„| D ƒ¡S )Nz%02Xz%02xÚ c 3 s � | ]}ˆ | V qd S r r )Ú.0Úc©Ú
format_strr r Ú <genexpr>1 s € zhexify.<locals>.<genexpr>)Újoin)ÚsÚ uppercaser r r Úhexify/ s r ó ÿc C s( t | ƒ| }|dkr| ||| 7 } | S )z"Pad to the next alignment boundaryr )Úlen)ÚdataÚ alignmentÚ
pad_characterÚpad_modr r r Úpad_to4 s r% Fc C s2 t j ¡ rtd| |r
dndd� dS t| ƒ dS )a’ Print a message, overwriting the currently printed line.
If last_line is False, don't append a newline at the end
(expecting another subsequent call will overwrite this one.)
After a sequence of calls with last_line=False, call once with last_line=True.
If output is not a TTY (for example redirected a pipe),
no overwriting happens and this function is the same as print().
z
%sÚ
r )ÚendN)ÚsysÚstdoutÚisattyÚprint)ÚmessageÚ last_liner r r Úprint_overwrite< s
r. c C s2 t dd| ¡} t dd| ¡} t ddd„ | ¡} | S )zKChange chip name to official form, e.g. `esp32s3beta2` -> `ESP32-S3(beta2)`z (esp32)(?!$)z\1-z (beta\d*)z(\1)z^[^\(]+c S s | d¡ ¡ S )Nr )ÚgroupÚupper)Úxr r r Ú<lambda>T s z"expand_chip_name.<locals>.<lambda>)ÚreÚsub©Ú chip_namer r r Úexpand_chip_nameM s r7 c C s t dd| ¡ ¡S )zLStrip chip name to normalized form, e.g. `ESP32-S3(beta2)` -> `esp32s3beta2`z[-()]r )r3 r4 Úlowerr5 r r r Ústrip_chip_nameX s r9 c C sJ d}t | dƒ�}| dtj¡ | ¡ }W d ƒ |S 1 s w Y |S )z Returns the file size in bytesr ÚrbN)ÚopenÚseekÚosÚSEEK_ENDÚtell)Ú path_to_fileÚ file_sizeÚfr r r Ú
get_file_size] s
şırC c @ s$ e Zd ZdZdd„ Zedd„ ƒZdS )r z~
Wrapper class for runtime errors that aren't caused by internal bugs, but by
ESP ROM responses or input content.
c C s t | |¡ d S r )Ú RuntimeErrorÚ__init__)Úselfr, r r r rE l s zFatalError.__init__c C s¶ i dd“dd“dd“dd“d d
“d d “d
d“dd“dd“dd“dd“dd“dd“dd “d d “d d “d!d"“d#d$d%d&d'd(œ¥}t d)|d*d+… ¡}| d, t|ƒ| |d- d.¡¡7 } t| ƒS )/z�
Return a fatal error object that appends the hex values of
'result' and its meaning as a string formatted argument.
i z
Out of memoryi zInvalid argumenti z
Invalid statei z Invalid sizei z Requested resource not foundi z"Operation or feature not supportedi zOperation timed outi z Received response was invalidi zCRC or checksum was invalidi
zVersion was invalidi zMAC address was invalidi À zBad data lengthi Á zBad data checksumi  z
Bad blocksizei à zInvalid commandi Ä zFailed SPI operationi Å zFailed SPI unlockzNot in flash modez
Inflate errorzNot enough dataz
Too much datazCommand not implemented)i Æ i Ç i È i É i ÿ z>HNé z (result was {}: {})r zUnknown result)ÚstructÚunpackÚformatr Úgetr )r, ÚresultÚerr_defsÚerr_coder r r Ú
WithResulto s\ şıüûúùø ÷
ö õ ôòñğïîíèÿzFatalError.WithResultN)Ú__name__Ú
__module__Ú __qualname__Ú__doc__rE Ú staticmethodrO r r r r r f s
r c @ ó e Zd ZdZdd„ ZdS )ÚNotImplementedInROMErrorz„
Wrapper class for the error thrown when a particular ESP bootloader function
is not implemented in the ROM bootloader.
c C s t | d|j|jf ¡ d S )Nz$%s ROM does not support function %s.)r rE Ú CHIP_NAMErP )rF Ú
bootloaderÚfuncr r r rE � s
ÿşz!NotImplementedInROMError.__init__N©rP rQ rR rS rE r r r r rV ˜ s rV c @ s e Zd Zdd„ ZdS )ÚNotSupportedErrorc C s t | d||jf ¡ d S )Nz$Function %s is not supported for %s.)r rE rW )rF ÚespÚ
function_namer r r rE § s şzNotSupportedError.__init__N)rP rQ rR rE r r r r r[ ¦ s r[ c @ rU )ÚUnsupportedCommandErrorz›
Wrapper class for when ROM loader returns an invalid command response.
Usually this indicates the loader is running in Secure Download Mode.
c C s( |j rd| }nd| }t | |¡ d S )Nz<This command (0x%x) is not supported in Secure Download Modez"Invalid (unsupported) command 0x%x)Úsecure_download_moderD rE )rF r\ ÚopÚmsgr r r rE µ s
z UnsupportedCommandError.__init__NrZ r r r r r^ ® s r^ )T)r )F)r= r3 rH r( r r r r r r% r. r7 r9 rC rD r rV r[ r^ r r r r Ú<module> s$
2 | 6,585 | Python | .py | 44 | 146.136364 | 907 | 0.498776 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,609 | bin_image.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/__pycache__/bin_image.cpython-310.pyc | o
’jÂd…¶ ã @ s d dl Z d dlZd dlZd dlZd dlZd dlZd dlZddlmZ ddl m
Z
m Z m Z m
Z
mZmZmZmZmZmZmZmZ ddlmZmZmZ dd„ Zdd „ ZG d
d „ d e ƒZ G d d
„ d
e ƒZ G dd„ de ƒZ G dd„ de ƒZ e e_!G dd„ de ƒZ"dd„ Z#G dd„ de ƒZ$G dd„ de$ƒZ%e$e_!G dd„ de$ƒZ&e&e_!G d d „ d e$ƒZ'e'e_!G d d „ d e$ƒZ(e(e_!G d d!„ d!e$ƒZ)e)e _!G d"d#„ d#e$ƒZ*e*e _!G d$d%„ d%e$ƒZ+e+e_!G d&d'„ d'e$ƒZ,e,e_!G d(d)„ d)e$ƒZ-e-e
_!G d*d+„ d+e$ƒZ.e.e
_!G d,d-„ d-e.ƒZ/e/e_!G d.d/„ d/e ƒZ0dS )0é Né )Ú ESPLoader) Ú
ESP32C2ROMÚ
ESP32C3ROMÚESP32C6BETAROMÚ
ESP32C6ROMÚESP32H2BETA1ROMÚESP32H2BETA2ROMÚ
ESP32H2ROMÚESP32ROMÚ
ESP32S2ROMÚESP32S3BETA2ROMÚ
ESP32S3ROMÚ
ESP8266ROM)Ú
FatalErrorÚbyteÚpad_toc C s$ |d | ¡ | }| |d¡ dS )zBAlign the position in the file to the next block of specified sizer N)ÚtellÚseek)ÚfÚsizeÚalign© r ú1/home/ceco/Downloads/esptool/esptool/bin_image.pyÚalign_file_position s r c C sP dd„ }t |tƒr#t|dƒ�
}||| ƒW d ƒ S 1 s w Y ||| ƒS )aI
Load a firmware image. Can be for any supported SoC.
ESP8266 images will be examined to determine if they are original ROM firmware
images (ESP8266ROMFirmwareImage) or "v2" OTA bootloader images.
Returns a BaseFirmwareImage subclass, either ESP8266ROMFirmwareImage (v1)
or ESP8266V2FirmwareImage (v2).
c S s† t dd| ¡ ¡}|dkr ttttttt t
t t t
dœ | | ƒS t| d¡ƒ}| d¡ |tjkr4t| ƒS |tjkr=t| ƒS td| ƒ‚)Nz[-()]Ú Úesp8266) Úesp32Úesp32s2Ú esp32s3beta2Úesp32s3Úesp32c3Ú esp32c6betaÚ esp32h2beta1Ú esp32h2beta2Úesp32c2Úesp32c6Úesp32h2r r z Invalid image magic number: %d)ÚreÚsubÚlowerÚESP32FirmwareImageÚESP32S2FirmwareImageÚESP32S3BETA2FirmwareImageÚESP32S3FirmwareImageÚESP32C3FirmwareImageÚESP32C6BETAFirmwareImageÚESP32H2BETA1FirmwareImageÚESP32H2BETA2FirmwareImageÚESP32C2FirmwareImageÚESP32C6FirmwareImageÚESP32H2FirmwareImageÚordÚreadr r ÚESP_IMAGE_MAGICÚESP8266ROMFirmwareImageÚESP8266V2FirmwareImageÚIMAGE_V2_MAGICr )r ÚchipÚmagicr r r Úselect_image_class1 s2 õ ô ô
z-LoadFirmwareImage.<locals>.select_image_classÚrbN)Ú
isinstanceÚstrÚopen)r< Ú
image_filer> r r r r ÚLoadFirmwareImage& s
ÿ
rD c @ sB e Zd ZdZddd„Zdd„ Zdd„ Zd d
„ Zd d „ Zd
d„ Z dS )Ú ImageSegmentz_Wrapper class for a segment in an ESP image
(very similar to a section in an ELFImage also)Nc C s4 || _ || _|| _d| _| j dkr| d¡ d S d S )NTr é )ÚaddrÚdataÚ file_offsÚinclude_in_checksumÚpad_to_alignment)ÚselfrG rH rI r r r Ú__init__U s
ÿÿzImageSegment.__init__c C s t || jdƒS )zNReturn a new ImageSegment with same data, but mapped at
a new address.r )rE rH )rL Únew_addrr r r Úcopy_with_new_addr_ s z ImageSegment.copy_with_new_addrc C sH t | ¡}| jd|… |_| j|d… | _| j|7 _d| _d|_|S )zÆReturn a new ImageSegment which splits "split_len" bytes
from the beginning of the data. Remaining bytes are kept in
this segment object (and the start address is adjusted to match.)N)ÚcopyrH rG rI )rL Ú split_lenÚresultr r r Ú split_imaged s
zImageSegment.split_imagec C s0 dt | jƒ| jf }| jd ur|d| j 7 }|S )Nzlen 0x%05x load 0x%08xz file_offs 0x%08x)ÚlenrH rG rI )rL Úrr r r Ú__repr__p s
zImageSegment.__repr__c s ‡ fdd„|j jD ƒS )zv
Return a list describing the memory type(s) that is covered by this
segment's start address.
c s6 g | ]}|d ˆ j kr|d k rn n|d ‘qS )r r é ©rG )Ú.0Ú map_range©rL r r Ú
<listcomp>{ s
ı
ıÿz0ImageSegment.get_memory_type.<locals>.<listcomp>)Ú
ROM_LOADERÚ
MEMORY_MAP)rL Úimager r[ r Úget_memory_typev s
şz ImageSegment.get_memory_typec C s t | j|dƒ| _d S ©Nó )r rH )rL Ú alignmentr r r rK � ó z ImageSegment.pad_to_alignment©N)
Ú__name__Ú
__module__Ú __qualname__Ú__doc__rM rO rS rV r` rK r r r r rE Q s
rE c s, e Zd ZdZ‡ fdd„Z‡ fdd„Z‡ ZS )Ú
ELFSectionzxWrapper class for a section in an ELF image, has a section
name as well as the common properties of an ImageSegment.c s" t t| ƒ ||¡ | d¡| _d S )Nzutf-8)Úsuperrj rM ÚdecodeÚname)rL rm rG rH ©Ú __class__r r rM ‰ s zELFSection.__init__c s d| j tt| ƒ ¡ f S )Nz%s %s)rm rk rj rV r[ rn r r rV � s zELFSection.__repr__)rf rg rh ri rM rV Ú
__classcell__r r rn r rj … s rj c @ s¤ e Zd ZdZdZ dd„ Zdd„ Zdd„ Zd'd
d „Zd d
„ Z dd„ Z
d(dd„Z d(dd„Z dd„ Z
dd„ Zdd„ Zdd „ Zd d „ Zd d „ Zd!d"„ Zd#d$„ Zd%d&„ ZdS ))ÚBaseFirmwareImageé é c C s" g | _ d| _d | _d| _d| _d S ©Nr )ÚsegmentsÚ
entrypointÚ
elf_sha256Úelf_sha256_offsetÚ pad_to_sizer[ r r r rM — s
zBaseFirmwareImage.__init__c C s: t d| d¡¡\}}| _| _| _||krtd| ƒ‚|S )Nú<BBBBIrr z!Invalid firmware image magic=0x%x)ÚstructÚunpackr7 Ú
flash_modeÚflash_size_freqrv r )rL Ú load_fileÚexpected_magicr= ru r r r Úload_common_header� s ú z$BaseFirmwareImage.load_common_headerc C s$ t | jƒdkrtdt | jƒ ƒ‚d S )Né zRInvalid segment count %d (max 16). Usually this indicates a linker script problem.)rT ru r r[ r r r Úverify« s ÿÿÿzBaseFirmwareImage.verifyFc C st | ¡ }t d| d¡¡\}}| |||¡ | |¡}t|ƒ|k r,td||t|ƒf ƒ‚t|||ƒ}| j |¡ |S )z)Load the next segment from the image fileú<IIrr z>End of file reading segment 0x%x, length %d (actual length %d))
r r{ r| r7 Úwarn_if_unusual_segmentrT r rE ru Úappend)rL r Úis_irom_segmentrI Úoffsetr Ú segment_dataÚsegmentr r r Ú load_segment² s
ÿÿ z BaseFirmwareImage.load_segmentc C s8 |s|dks|dk s|dkrt d||f ƒ d S d S d S )Ni @i ş?é z+WARNING: Suspicious segment 0x%x, length %d)Úprint©rL rˆ r r‡ r r r r… Á s
şz)BaseFirmwareImage.warn_if_unusual_segmentc C sÎ t |ƒ}| ¡ }| j|kre| j|| k re| j| }|| jk s%|| j |kr/td| j||f ƒ‚|| j8 }|||| j … d| j krItd| j ƒ‚t | jƒ| jksSJ ‚|d|… | j ||| j d… }|S )z
If SHA256 digest of the ELF file needs to be inserted into this segment, do so.
Returns segment data.
zbCannot place SHA256 digest on segment boundary(elf_sha256_offset=%d, file_pos=%d, segment_size=%d)rb zYContents of segment at SHA256 digest offset 0x%x are not all zero. Refusing to overwrite.r N)rT r rx ÚSEG_HEADER_LENÚSHA256_DIGEST_LENr rw )rL r r‰ Ú segment_lenÚfile_posÚ patch_offsetr r r Úmaybe_patch_segment_dataÆ sD ÿ ş
ÿ ş
şÿ
ÿÿÿÿ
ÿşÿz*BaseFirmwareImage.maybe_patch_segment_dataNc C sJ | ||j¡}| t d|jt|ƒ¡¡ | |¡ |dur#t ||¡S dS )zi
Save the next segment to the image file,
return next checksum value if provided
r„ N) r” rH Úwriter{ ÚpackrG rT r Úchecksum)rL r rŠ r— r‰ r r r Ú save_segmentğ s
ÿz BaseFirmwareImage.save_segmentc C sZ | j jdkr&| ¡ t|jƒ | j }|| j }|dk r&| jdd| 7 _| |||¡S )za
Save the next segment to the image file, return next checksum value if provided
ÚESP32é$ rb )r] Ú CHIP_NAMEr rT rH r� Ú
IROM_ALIGNr˜ )rL r rŠ r— Úsegment_end_posÚsegment_len_remainderr r r Úsave_flash_segmentû s
z$BaseFirmwareImage.save_flash_segmentc C s t |dƒ t| d¡ƒS )z5Return ESPLoader checksum from end of just-read imager‚ r )r r6 r7 )rL r r r r Ú
read_checksum s
z BaseFirmwareImage.read_checksumc C s* t j}| jD ] }|jrt |j|¡}q|S )za
Calculate checksum of loaded image, based on segments in
segment array.
)r ÚESP_CHECKSUM_MAGICru rJ r— rH )rL r— Úsegr r r Úcalculate_checksum s
€z$BaseFirmwareImage.calculate_checksumc C s t |dƒ | t d|¡¡ dS )z3Append ESPLoader checksum to the just-written imager‚ ó BN)r r• r{ r– )rL r r— r r r Úappend_checksum s
z!BaseFirmwareImage.append_checksumc
C s* | t dtjt|ƒ| j| j| j¡¡ d S )Nrz ) r• r{ r– r r8 rT r} r~ rv )rL r ru r r r Úwrite_common_header s úÿz%BaseFirmwareImage.write_common_headerc C s t j| ko t jk S S )zg
Returns True if an address starts in the irom region.
Valid for ESP8266 only.
)r ÚIROM_MAP_STARTÚ IROM_MAP_END©rL rG r r r Ú is_irom_addr, s z BaseFirmwareImage.is_irom_addrc sH ‡ fdd„ˆ j D ƒ}t|ƒdkr"t|ƒdkr tdt|ƒ ƒ‚|d S d S )Nc s g | ]
}ˆ |j¡r|‘qS r )rª rG ©rY Úsr[ r r r\ 4 s z6BaseFirmwareImage.get_irom_segment.<locals>.<listcomp>r r z4Found %d segments that could be irom0. Bad ELF file?)ru rT r )rL Ú
irom_segmentsr r[ r Úget_irom_segment3 s ÿÿz"BaseFirmwareImage.get_irom_segmentc s | ¡ ‰ ‡ fdd„| jD ƒS )Nc s g | ]}|ˆ kr|‘qS r r r« ©Ú irom_segmentr r r\ @ s z;BaseFirmwareImage.get_non_irom_segments.<locals>.<listcomp>)r® ru r[ r r¯ r Úget_non_irom_segments> s z'BaseFirmwareImage.get_non_irom_segmentsc C s´ | j sd S g }tt| j ƒd ddƒD ]9}| j |d }| j | }t| | ¡| | ¡k|j|jk|j|jt|jƒ kfƒrE| j|j7 _q| d|¡ q| d| j d ¡ || _ d S )Nr r éÿÿÿÿ) ru ÚrangerT Úallr` rJ rG rH Úinsert)rL ru ÚiÚelemÚ next_elemr r r Úmerge_adjacent_segmentsB s
ıÿ
z)BaseFirmwareImage.merge_adjacent_segmentsc C s t d | jj¡ƒ dS )zw
If supported, this should be overridden by the chip-specific class.
Gets called in elf2image.
zKWARNING: Changing MMU page size is not supported on {}! Defaulting to 64KB.N)r� Úformatr] r› ©rL r r r r Úset_mmu_page_sizek s
şz#BaseFirmwareImage.set_mmu_page_size)Fre )rf rg rh r� r� rM r� rƒ r‹ r… r” r˜ rŸ r r£ r¥ r¦ rª r® r± r¹ r¼ r r r r rq ‘ s*
*
)rq c s6 e Zd ZdZeZd ‡ fdd„ Zdd„ Zdd„ Z‡ Z S )
r9 zK'Version 1' firmware image, segments loaded directly by the ROM bootloader.Nc sj t t| ƒ ¡ d| _d| _d| _|d ur3| |tj¡}t |ƒD ]}|
|¡ q | |¡| _ |
¡ d S d S )Nr r )rk r9 rM r} r~ Úversionr� r r8 r³ r‹ r r— rƒ )rL r ru Ú_rn r r rM { s ùz ESP8266ROMFirmwareImage.__init__c C s |d S )ú/Derive a default output name from the ELF name.ú-r ©rL Ú
input_filer r r Údefault_output_nameŠ s z+ESP8266ROMFirmwareImage.default_output_namec C sÈ | ¡ }|dur+td||jtj f dƒ�}| |j¡ W d ƒ n1 s&w Y | ¡ }td| dƒ�$}| ||¡ t j
}|D ] }| |||¡}qB| ||¡ W d ƒ dS 1 s]w Y dS )zCSave a set of V1 images for flashing. Parameter is a base filename.Nz %s0x%05x.binÚwbz
%s0x00000.bin)
r® rB rG r r§ r• rH r± r¦ r r¡ r˜ r¥ )rL Úbasenamer° r Únormal_segmentsr— rŠ r r r Úsave� s& ÿı û "ûz ESP8266ROMFirmwareImage.savere )
rf rg rh ri r r] rM rà rÇ rp r r rn r r9 v s r9 c s> e Zd ZdZeZdZdZd ‡ fdd„ Zdd„ Z d d
„ Z
‡ Z S ) r: zs'Version 2' firmware image, segments loaded by software bootloader stub
(ie Espressif bootloader or rboot)
éê rF Nc s t t| ƒ ¡ d| _|d ur~| || j¡}|| jkr td| ƒ | |d¡}d|_ d|_
| j }| j }| j
}| |tj¡}|| j krJtd|| j f ƒ || j krXtd|| j f ƒ || j
krftd|| j
f ƒ t|ƒD ]}| |¡ qj| |¡| _| ¡ d S d S ) NrW z@Warning: V2 header has unexpected "segment" count %d (usually 4)Tr FzfWARNING: Flash mode value in first header (0x%02x) disagrees with second (0x%02x). Using second value.zkWARNING: Flash size/freq value in first header (0x%02x) disagrees with second (0x%02x). Using second value.zoWARNING: Entrypoint address in first header (0x%08x) disagrees with second header (0x%08x). Using second value.)rk r: rM r½ r� r; ÚIMAGE_V2_SEGMENTr� r‹ rG rJ r} r~ rv r r8 r³ r r— rƒ )rL r ru r° Úfirst_flash_modeÚfirst_flash_size_freqÚfirst_entrypointr¾ rn r r rM ´ sP
ÿÿ
şÿ
şÿ
şÿ Îz ESP8266V2FirmwareImage.__init__c C sF | ¡ }|dur|jtj }nd}dtj |¡d |tjd @ f S )r¿ Nr z
%s-0x%05x.binr ) r® rG r r§ ÚosÚpathÚsplitextr ÚFLASH_SECTOR_SIZE)rL r r° Ú irom_offsr r r rà ë s şz*ESP8266V2FirmwareImage.default_output_namec C s4 t |dƒ�Q}| t d| j| j| j| j| j¡¡ | ¡ }|d ur0|
d¡}| d¡ | ||¡ |
¡ }| ||¡ tj}|D ] }| |||¡}q?| ||¡ W d ƒ n1 sYw Y t |dƒ�}t| ¡ ƒ}W d ƒ n1 stw Y t |dƒ�}| t d|¡¡ W d ƒ d S 1 s“w Y d S )NrÄ s <BBBBIr r‚ r? Úabs <I)rB r• r{ r– r; rÉ r} r~ rv r® rO rK r˜ r± r¦ r r¡ r¥ Ú
esp8266_crc32r7 )rL Úfilenamer r° rÆ r— rŠ Úcrcr r r rÇ ÷ s> úÿ
ÿ ä ÿ "ÿzESP8266V2FirmwareImage.savere ) rf rg rh ri r r] r; rÉ rM rà rÇ rp r r rn r r: § s 7 r: c C s( t | d¡d@ }|d@ r|dA S |d S )zJ
CRC32 algorithm used by 8266 SDK bootloader (and gen_appbin.py).
r l ÿÿ l r )ÚbinasciiÚcrc32)rH rÕ r r r rÓ s rÓ c sb e Zd ZdZeZdZdZdZd‡ fdd„ Z d d
„ Z
d d „ Z d
d„ Z dd„ Z
dd„ Zdd„ Z‡ ZS )r+ a ESP32 firmware image is very similar to V1 ESP8266 image,
except with an additional 16 byte reserved header at top of image,
and because of new flash mapping capabilities the flash-mapped regions
can be placed in the normal image (just @ 64kB padded offsets).
éî z<BBBBHBHHBBBBBrŒ NTc s t t| ƒ ¡ d | _d| _d| _d| _| j| _d| _ d| _
d| _ d| _ d| _
d| _d| _d| _d| _d| _|| _|d ur‰| ¡ }| |tj¡}| |¡ t|ƒD ]}| |¡ qP| |¡| _ | jrƒ| ¡ }| d¡| _ | |¡ t !¡ }| "| || ¡¡ | #¡ | _$| %¡ d S d S )Nr r rs )&rk r+ rM Ú
secure_padr} r~ r½ ÚWP_PIN_DISABLEDÚwp_pinÚclk_drvÚq_drvÚd_drvÚcs_drvÚhd_drvÚwp_drvÚchip_idÚmin_revÚ min_rev_fullÚ max_rev_fullÚ
append_digestr r� r r8 Úload_extended_headerr³ r‹ r r— r7 Ú
stored_digestr ÚhashlibÚsha256ÚupdateÚdigestÚ calc_digestrƒ )rL r ræ Ústartru r¾ Úendrí rn r r rM < sB
îzESP32FirmwareImage.__init__c C s@ | j j| ko
| j jk n p | j j| ko | j jk S S re )r] r§ r¨ ÚDROM_MAP_STARTÚ DROM_MAP_ENDr© r r r Ú
is_flash_addre s ÿşşz ESP32FirmwareImage.is_flash_addrc C s dt j |¡d S )r¿ z%s.binr )rÍ rÎ rÏ rÁ r r r rà j s z&ESP32FirmwareImage.default_output_namec C s d S re r r� r r r r… n s z*ESP32FirmwareImage.warn_if_unusual_segmentc sú d}t ¡ ��ë‰ ˆ ˆ ˆj¡ ˆ ˆ ¡ tj}‡fdd„tˆjdd„ d�D ƒ}‡fdd„tˆjdd„ d�D ƒ}|D ]}|jd krM| |¡ |
d|¡ nq9|D ]}|jd
krd| |¡ |
d|¡ nqPt |ƒdkr�|d j }|d d … D ]}|j ˆj
|ˆj
krŒtd |j |f ƒ‚|j }qv‡ ‡fd
d„}t |ƒdk�r|d }||ƒ} | dkrát |ƒdkrË| ˆjkrË|d | ¡}
t |d jƒdkrÊ| d¡ n
tdd| ˆ ¡ ƒ}
ˆ ˆ |
|¡}|d 7 }n!ˆ ¡ d ˆj
|j ˆj
ksòJ ‚ˆ ˆ ||¡}| d¡ |d 7 }t |ƒdks�|D ]}ˆ ˆ ||¡}|d 7 }�q
ˆj�rcˆj�s%tdƒ‚ˆ ¡ ˆj ˆj
} d} ˆjdk�r:d}
nˆjdk�rBd}
ˆj
| | |
ˆj
} tdd| ˆ ¡ ƒ}
ˆ ˆ |
|¡}|d 7 }ˆ ˆ |¡ ˆ ¡ }ˆj�r}||
ˆj
dk�s}J ‚ˆ d ¡ ˆ t |gƒ¡ ˆj�r¦ˆ d¡ t ¡ }| ˆ |¡¡ ˆ | !¡ ¡ ˆj"�rň ¡ }|ˆj" dk�rňj"|ˆj" }ˆ d| ¡ t#|dƒ�}| ˆ $¡ ¡ W d ƒ n1 �sİw Y W d ƒ d S W d ƒ d S 1 �söw Y d S )Nr c s" g | ]
}ˆ |j¡rt |¡‘qS r ©rò rG rP Údeepcopyr« r[ r r r\ ~ ó
ıÿz+ESP32FirmwareImage.save.<locals>.<listcomp>c S ó | j S re rX ©r¬ r r r Ú<lambda>€ ó z)ESP32FirmwareImage.save.<locals>.<lambda>©Úkeyc s" g | ]
}ˆ |j¡st |¡‘qS r ró r« r[ r r r\ ƒ rõ c S rö re rX r÷ r r r rø … rù z.flash.appdescz.dram0.bootdescr ú¦Segment loaded at 0x%08x lands in same 64KB flash mapping as segment loaded at 0x%08x. Can't generate binary. Suggest changing linker script or ELF to merge sections.c s` | j ˆj ˆj }ˆjˆ ¡ ˆj | }|dks |ˆjkr dS |ˆj8 }|dk r.|ˆj7 }|S rt )rG rœ r� r )rŠ Ú
align_pastÚpad_len©r rL r r Úget_alignment_data_neededª s
z:ESP32FirmwareImage.save.<locals>.get_alignment_data_neededrb rr zIsecure_pad only applies if a SHA-256 digest is also appended to the imager‚ Ú1ép Ú2rs ó ÿrÄ )%ÚioÚBytesIOr¦ ru Úsave_extended_headerr r¡ Úsortedrm Úremoverµ rT rG rœ r r� rS rH ÚpoprE r r˜ rŸ rÙ ræ r¥ r r• Úbytesré rê rë r7 rì ry rB Úgetvalue)rL rÔ Útotal_segmentsr— Úflash_segmentsÚ ram_segmentsrŠ Ú last_addrr rş Ú pad_segmentrı Úchecksum_spaceÚspace_after_checksumÚ image_lengthrì Úpad_byÚ real_filer rÿ r rÇ q sÈ
ş
ş
ı
ı
ıÿ
€
ş
ş
í ÿ ş
ÿ �á �$ázESP32FirmwareImage.savec C sÚ dd„ }t t | j| d¡¡ƒ}|d | _||d ƒ\| _| _||d ƒ\| _| _ ||d ƒ\| _
| _ |d | _ | j | j
jkrJtd | j
j| j f ƒ |d
| _|d | _|d | _|d
}|dv rh|dk| _d S td|ƒ‚)Nc S ó | d@ | d? d@ fS ©Né rF r ©Únr r r Ú
split_byte rd z;ESP32FirmwareImage.load_extended_header.<locals>.split_byter‚ r r rW é rF zdUnexpected chip id in image. Expected %d but value was %d. Is this image for a different chip model?é é é r² ©r r úAInvalid value for append_digest field (0x%02x). Should be 0 or 1.)Úlistr{ r| ÚEXTENDED_HEADER_STRUCT_FMTr7 rÛ rÜ rİ rŞ rß rà rá râ r] Ú
IMAGE_CHIP_IDr� rã rä rå ræ Ú RuntimeError)rL r r Úfieldsræ r r r rç s2 ÿ
üÿ
şz'ESP32FirmwareImage.load_extended_headerc C s� dd„ }| j r dnd}| j|| j| jƒ|| j| jƒ|| j| jƒ| jj | j
| j | j g}|dgd 7 }||g7 }t
j| jg|¢R � }| |¡ d S )Nc S s | d@ |d@ d> S r r )ÚlnÚhnr r r Ú join_byte; rd z:ESP32FirmwareImage.save_extended_header.<locals>.join_byter r rF )ræ rÛ rÜ rİ rŞ rß rà rá r] r% rã rä rå r{ r– r$ r• )rL Ú save_filer* ræ r' Úpackedr r r r : s ø
z'ESP32FirmwareImage.save_extended_header)NT)rf rg rh ri r r] rÚ r$ rœ rM rò rà r… rÇ rç r rp r r rn r r+ ) s ) $&r+ c @ s, e Zd ZdZdZdd„ Zdd„ Zdd„ Zd S )
ÚESP8266V3FirmwareImagez8ESP8266 V3 firmware image is very similar to ESP32 imageÚBBBBBBBBBBBBBBBBc C s
|t jkS re )r r§ r© r r r rò V s
z$ESP8266V3FirmwareImage.is_flash_addrc s d}t ¡ �ñ}ˆ |ˆ j¡ tj}‡ fdd„tˆ jdd„ d�D ƒ}‡ fdd„tˆ jdd„ d�D ƒ}t|ƒdkr\|d j}|d d … D ]}|jˆ j |ˆ j krXt
d
|j|f ƒ‚|j}qBt|ƒdkr‰|d }|j d krs|j d d … |_ ˆ
|||¡}| d¡ |d 7 }t|ƒdksb|D ]
}ˆ
|||¡}|d 7 }q‹ˆ ||¡ | ¡ } | d ¡ | t|gƒ¡ ˆ jrË| d¡ t ¡ }
|
| | ¡¡ | |
¡ ¡ t|d
ƒ�} | | ¡ ¡ W d ƒ n1 sâw Y W d ƒ d S W d ƒ d S 1 súw Y d S )Nr c s, g | ]}ˆ |j¡rt|jƒrt |¡‘qS r ©rò rG rT rH rP rô r« r[ r r r\ b ó
ııÿz/ESP8266V3FirmwareImage.save.<locals>.<listcomp>c S rö re rX r÷ r r r rø d rù z-ESP8266V3FirmwareImage.save.<locals>.<lambda>rú c s, g | ]}ˆ |j¡st|jƒrt |¡‘qS r r/ r« r[ r r r\ g r0 c S rö re rX r÷ r r r rø i rù r rü z
.flash.rodatarr rÄ ) r r r¦ ru r r¡ r rT rG rœ r rm rH r˜ r
r¥ r r r• r ræ ré rê rë r7 rì rB r ) rL rÔ r
r r— r r r rŠ r rì r r r[ r rÇ Y s\
ş
ş
ıÿ
ø
ÿ¾B"¾zESP8266V3FirmwareImage.savec C sº dd„ }t t | j| d¡¡ƒ}|d | _||d ƒ\| _| _||d ƒ\| _| _ ||d ƒ\| _
| _ |d d v rA|d dk| _ nt
d
|d ƒ‚td d „ |d
d… D ƒƒr[tdƒ d S d S )Nc S r r r r r r r r ¡ rd z?ESP8266V3FirmwareImage.load_extended_header.<locals>.split_byter‚ r r rW r r r! r" c s s � | ] }|d kr|V qdS )r Nr )rY r r r r Ú <genexpr>¸ s € z>ESP8266V3FirmwareImage.load_extended_header.<locals>.<genexpr>rF zeWarning: some reserved header fields have non-zero values. This image may be from a newer esptool.py?)r# r{ r| r$ r7 rÛ rÜ rİ rŞ rß rà rá ræ r& Úanyr� )rL r r r' r r r rç s& ÿ
şÿÿz+ESP8266V3FirmwareImage.load_extended_headerN)rf rg rh ri r$ rò rÇ rç r r r r r- Q s Gr- c @ ó e Zd ZdZeZdS )r, zDESP32S2 Firmware Image almost exactly the same as ESP32FirmwareImageN)rf rg rh ri r r] r r r r r, Â ó r, c @ r3 )r- úDESP32S3 Firmware Image almost exactly the same as ESP32FirmwareImageN)rf rg rh ri r
r] r r r r r- Ë r4 r- c @ r3 )r. r5 N)rf rg rh ri r r] r r r r r. Ô r4 r. c @ r3 )r/ zDESP32C3 Firmware Image almost exactly the same as ESP32FirmwareImageN)rf rg rh ri r r] r r r r r/ İ r4 r/ c @ r3 )r0 úDESP32C6 Firmware Image almost exactly the same as ESP32FirmwareImageN)rf rg rh ri r r] r r r r r0 æ r4 r0 c @ r3 )r1 úDESP32H2 Firmware Image almost exactly the same as ESP32FirmwareImageN)rf rg rh ri r r] r r r r r1 ï r4 r1 c @ r3 )r2 r7 N)rf rg rh ri r r] r r r r r2 ø r4 r2 c @ ó e Zd ZdZeZdd„ ZdS )r3 zDESP32C2 Firmware Image almost exactly the same as ESP32FirmwareImagec C ó |dvr t d |¡ƒ‚|| _d S )N)é @ é € rŒ zI{} bytes is not a valid ESP32-C2 page size, select from 64KB, 32KB, 16KB.©r rº rœ r» r r r r¼ ó ş
z&ESP32C2FirmwareImage.set_mmu_page_sizeN)rf rg rh ri r r] r¼ r r r r r3 ó r3 c @ r8 )r4 r6 c C r9 )N)i r: r; rŒ zN{} bytes is not a valid ESP32-C6 page size, select from 64KB, 32KB, 16KB, 8KB.r< r» r r r r¼ r= z&ESP32C6FirmwareImage.set_mmu_page_sizeN)rf rg rh ri r r] r¼ r r r r r4 r> r4 c @ r3 )r5 r7 N)rf rg rh ri r
r] r r r r r5 # r4 r5 c @ sb e Zd ZdZdZdZdZeeefZdZdZ dZ
dd„ Z d d
„ Z d d „ Z
d
d„ Zdd„ Zdd„ ZdS )ÚELFFiler r é r é( rs c C sB || _ t| j dƒ�}| |¡ W d ƒ d S 1 sw Y d S ©Nr? )rm rB Ú_read_elf_file)rL rm r r r r rM 9 s "ÿzELFFile.__init__c C s* | j D ] }|j|kr| S qtd| ƒ‚)NzNo section %s in ELF file)Úsectionsrm Ú
ValueError)rL Ú section_namer¬ r r r Ú get_section? s
ÿ zELFFile.get_sectionc C s d}zt d| |¡¡\}}}}| _}}} }
} } }
}}W n t jy2 } z td| j|f ƒ‚d }~ww t|dƒdksB|dd… dkrItd | j ƒ‚|d
vrVtd | j|f ƒ‚|
| jkrftd | j|
| jf ƒ‚|dkrqtd
| j ƒ‚| ||||¡ |
||| |¡ d S )Né4 z<16sHHLLLLLHHHHHHz-Failed to read a valid ELF header from %s: %sr é r rF s ELFz %s has invalid ELF magic header)é^ éó zG%s does not appear to be an Xtensa or an RISCV ELF file. e_machine=%04xz;%s has unexpected section header entry size 0x%x (not 0x%x)z%s has 0 section headers) r{ r| r7 rv Úerrorr rm r ÚLEN_SEC_HEADERÚ_read_sectionsÚ_read_segments)rL r ÚLEN_FILE_HEADERÚidentÚ_typeÚmachineÚ_versionÚ_phoffÚshoffÚ_flagsÚ_ehsizeÚ
_phentsizeÚ_phnumÚ shentsizeÚshnumÚshstrndxÚer r r rC E sT ñ ÿ€ÿ ÿÿ
ÿÿzELFFile._read_elf_filec
s& ˆ |¡ || j }ˆ |¡‰tˆƒdkrtd| ƒ‚tˆƒ|kr+tdtˆƒ|f ƒ‚tdtˆƒ| jƒ}‡fdd„‰‡fdd„|D ƒ}dd„ |D ƒ}|| j |vrWtd | ƒ‚ˆ|| j ƒ\} }
} } } |
tjkrntd
|
ƒ ˆ | ¡ ˆ | ¡‰‡fd d „‰‡ fd
d„‰‡‡fdd„|D ƒ}|| _ d S )Nr z3No section header found at offset %04x in ELF file.zMOnly read 0x%x bytes from section header (expected 0x%x.) Truncated ELF file?c s. t dˆ | d … ¡\}}}}}}|||||fS )Nz<LLLLLL©r{ Ú unpack_from)ÚoffsÚ name_offsÚsec_typerW ÚlmaÚsec_offsr )Úsection_headerr r Úread_section_header� s ÿz3ELFFile._read_sections.<locals>.read_section_headerc ó g | ]}ˆ |ƒ‘qS r r ©rY ra )rg r r r\ ‡ ó z*ELFFile._read_sections.<locals>.<listcomp>c S s g | ] }|d t jv r|‘qS )r )r? ÚPROG_SEC_TYPESr« r r r r\ ˆ ó z-ELF file has no STRTAB section at shstrndx %dz:WARNING: ELF file has incorrect STRTAB section type 0x%02xc s ˆ | d … }|d | d¡… S ra )Úindex)ra Úraw)Ú string_tabler r Ú
lookup_stringš s z-ELFFile._read_sections.<locals>.lookup_stringc ó ˆ | ¡ ˆ |¡S re ©r r7 ©ra r ©r r r Ú read_data� ó
z)ELFFile._read_sections.<locals>.read_datac s< g | ]\}}}}}|d kr|d krt ˆ |ƒ|ˆ||ƒƒ‘qS ©r ©rj )rY Ún_offsrR rd r ra )rp ru r r r\ ¢ s ııÿ)
r rM r7 rT r r³ r? ÚSEC_TYPE_STRTABr� rD )
rL r Úsection_header_offsÚsection_header_countr] Ú len_bytesÚsection_header_offsetsÚ all_sectionsÚ
prog_sectionsr¾ rc Úsec_sizere r )r rp ru rg rf ro r rN o sH
ÿÿ
ÿÿ ÿ
ÿ
ş
zELFFile._read_sectionsc s¼ ˆ |¡ || j }ˆ |¡‰tˆƒdkrtd| ƒ‚tˆƒ|kr+tdtˆƒ|f ƒ‚tdtˆƒ| jƒ}‡fdd„‰‡fdd„|D ƒ}dd„ |D ƒ}‡ fd d
„‰‡fd d„|D ƒ}|| _d S ) Nr z3No segment header found at offset %04x in ELF file.zMOnly read 0x%x bytes from segment header (expected 0x%x.) Truncated ELF file?c s0 t dˆ | d … ¡\}}}}}}}}||||fS )Nz <LLLLLLLLr_ ) ra Úseg_typeÚseg_offsÚ_vaddrrd r Ú_memsizerW Ú_align)Úsegment_headerr r Úread_segment_header» s
÷ z3ELFFile._read_segments.<locals>.read_segment_headerc rh r r ri )rˆ r r r\ È rj z*ELFFile._read_segments.<locals>.<listcomp>c S s g | ] }|d t jkr|‘qS rw )r? Ú
SEG_TYPE_LOADr« r r r r\ É rl c rq re rr rs rt r r ru Ë rv z)ELFFile._read_segments.<locals>.read_datac s6 g | ]\}}}}|d kr|d krt d|ˆ ||ƒƒ‘qS )r s PHDRrx )rY rR rd r ra )ru r r r\ Ï s
ııÿ)r ÚLEN_SEG_HEADERr7 rT r r³ ru ) rL r Úsegment_header_offsÚsegment_header_countr] r} Úsegment_header_offsetsÚ all_segmentsÚ
prog_segmentsr )r ru rˆ r‡ r rO © s0
ÿÿ
ÿÿ
ş
zELFFile._read_segmentsc C sP t ¡ }t| jdƒ�}| | ¡ ¡ W d ƒ | ¡ S 1 s w Y | ¡ S rB )ré rê rB rm rë r7 rì )rL rê r r r r rê Ö s
ÿşzELFFile.sha256N)rf rg rh ÚSEC_TYPE_PROGBITSrz ÚSEC_TYPE_INITARRAYÚSEC_TYPE_FINIARRAYrk rM r‰ rŠ rM rG rC rN rO rê r r r r r? , s
*: -r? )1rÖ rP ré r rÍ r( r{ Úloaderr Útargetsr r r r r r r
r r r
r r Úutilr r r r rD ÚobjectrE rj rq r9 ÚBOOTLOADER_IMAGEr: rÓ r+ r- r, r- r. r/ r0 r1 r2 r3 r4 r5 r? r r r r Ú<module> s\ 8+4 f.w *n | 33,063 | Python | .py | 227 | 143.484581 | 1,670 | 0.442712 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,610 | cmds.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/__pycache__/cmds.cpython-310.pyc | o
’jÂdÑÂ ã @ sL d dl Z d dlZd dlZd dlZd dlZd dlZd dlZddlmZm Z m
Z
ddlm Z m Z m
Z
ddlmZmZmZmZmZ ddlmZmZmZ ddlmZmZmZm Z ddlm Z m Z m Z m Z m!Z!m"Z" i d d
“d d “d
d“dd“dd“dd“dd“dd“dd“dd “d d “d d“d d “d!d “d"d
“d#d “d$d“ddddddd%œ¥Z#d dd&d'd(œZ$ej%ej&d)d*efd+d,„Z'd-d.„ Z(d/d0„ Z)d1d2„ Z*d3d4„ Z+dfd5d6„Z,d7d8„ Z-d9d:„ Z.d;d<„ Z/d=d>„ Z0d?d@„ Z1dAdB„ Z2dCdD„ Z3dEdF„ Z4dGdH„ Z5dIdJ„ Z6dKdL„ Z7dMdN„ Z8dOdP„ Z9dQdR„ Z:dSdT„ Z;dd&dUdVdWd dXdYdZd[d\d]œ Z<d^d_„ Z=d`da„ Z>dbdc„ Z?ddde„ Z@dS )gé Né )ÚELFFileÚ ImageSegmentÚLoadFirmwareImage)ÚESP8266ROMFirmwareImageÚESP8266V2FirmwareImageÚESP8266V3FirmwareImage)ÚDEFAULT_CONNECT_ATTEMPTSÚDEFAULT_TIMEOUTÚERASE_WRITE_TIMEOUT_PER_MBÚ ESPLoaderÚtimeout_per_mb)Ú CHIP_DEFSÚ CHIP_LISTÚROM_LIST)Ú
FatalErrorÚNotImplementedInROMErrorÚNotSupportedErrorÚUnsupportedCommandError)Ú div_roundupÚflash_size_bytesÚ
get_file_sizeÚhexifyÚpad_toÚprint_overwriteé Ú256KBé Ú512KBé Ú1MBé Ú2MBé Ú4MBé Ú8MBé Ú16MBé Ú32MBé Ú64MBé Ú128MBé Ú256MBé é! é" é2 é3 é4 )é5 é6 é7 é8 é9 é: é é )ÚqioÚqoutÚdioÚdoutÚ
default_resetFc C s2 d}t | ||d�}|j d¡rd|_|j||dd� zĞzDtddd� | ¡ }d d
„ tD ƒD ]*}||jkrW||j ||d�}z|
t j ¡ W n t yP d|_
Y nw | ¡ nq-d |› d �} W nk t tjtfyÊ }
z[td
ƒ zEt|
tjƒs|j||ddd� tddd� tj ¡ |
t j ¡} tD ]}| |jv r«||j ||d�}| ¡ | ¡ nq’d| d›d �} W n t y¿ tdƒ‚w W Y d}
~
nd}
~
ww W |durêtd|j dd� |jrä| |¡}d|_tdƒ |S n'|du�rtd|j dd� |j�r| |¡}d|_tdƒ | Y S w t| › d�ƒ‚)aG Use serial access to detect the chip type.
First, get_security_info command is sent to detect the ID of the chip
(supported only by ESP32-C3 and later, works even in the Secure Download Mode).
If this fails, we reconnect and fall-back to reading the magic number.
It's mapped at a specific ROM address and has a different value on each chip model.
This way we use one memory read and compare it to the magic number for each chip.
This routine automatically performs ESPLoader.connect() (passing
connect_mode parameter) as part of querying the chip.
N)Ú
trace_enabledzrfc2217:T)Ú detectingzDetecting chip type...Ú ©Úendc S s g | ] }|j d vr|‘qS ))ÚESP8266ÚESP32zESP32-S2©Ú CHIP_NAME©Ú.0Ún© rP ú,/home/ceco/Downloads/esptool/esptool/cmds.pyÚ
<listcomp>b s
ÿÿz detect_chip.<locals>.<listcomp>zUnexpected chip ID value Ú.z> Unsupported detection protocol, switching and trying again...F)rE Úwarningsz Unexpected chip magic value z#010xz˜Unsupported Command Error received. Probably this means Secure Download Mode is enabled, autodetection will not work. Need to manually specify the chip.z %szW Failed to autodetect chip type.
Probably it is unsupported by this version of esptool.)r Ú serial_portÚ
startswithÚ USES_RFC2217ÚconnectÚprintÚ get_chip_idr Ú
IMAGE_CHIP_IDÚ_portÚread_regÚCHIP_DETECT_MAGIC_REG_ADDRr Úsecure_download_modeÚ
_post_connectÚstructÚerrorr Ú
isinstanceÚsysÚstdoutÚflushÚCHIP_DETECT_MAGIC_VALUEÚ
check_chip_idrL Úsync_stub_detectedÚ
STUB_CLASS) ÚportÚbaudÚ connect_moderD Úconnect_attemptsÚinstÚ detect_portÚchip_idÚclsÚerr_msgÚeÚchip_magic_valuerP rP rQ Ú detect_chipH s�
ÿ
ÿ
ÿ÷ € ÿ
ÿ
ü€ ÿÿ€æ€!
ú
ÿrv c C sà t | j|jƒ}tdƒ |jD ]R}t|jƒ}td||jf dd� tj
¡ | |t || j
ƒ| j
|j¡ d}t|jƒdkr\| |jd| j
… |¡ |j| j
d … |_|d7 }t|jƒdks<tdƒ qtd|j ƒ | |j¡ d S ) Nz RAM boot...z Downloading %d bytes at %08x...ú rG r r zdone!z$All segments done, executing at %08x)r rL ÚfilenamerY ÚsegmentsÚlenÚdataÚaddrrd re rf Ú mem_beginr Ú
ESP_RAM_BLOCKÚ mem_blockÚ
entrypointÚ
mem_finish)ÚespÚargsÚimageÚsegÚsizeÚseqrP rP rQ Úload_ram¦ s$
ÿı
rˆ c C s t d|j| |j¡f ƒ d S )Nz0x%08x = 0x%08x)rY Úaddressr] ©r‚ rƒ rP rP rQ Úread_mem½ s r‹ c C s2 | |j|j|jd¡ td|j|j|jf ƒ d S )Nr z Wrote %08x, mask %08x to %08x)Ú write_regr‰ ÚvalueÚmaskrY rŠ rP rP rQ Ú write_memÁ s r� c C s t |jdƒ�M}t|jd ƒD ]3}| |j|d ¡}| t d|¡¡ | ¡ d dkr<t
d| ¡ | ¡ d |j f ƒ t j
¡ qt
d| ¡ d d
� W d ƒ n1 sVw Y td ƒ d S ) NÚwbé s <Ié r z%d bytes read... (%d %%)éd z
Read %d bytesT©Ú last_linezDone!)Úopenrx Úranger† r] r‰ Úwritera ÚpackÚtellr rd re rf rY )r‚ rƒ ÚfÚiÚdrP rP rQ Údump_memÆ s ÿ ÷
r� c C sŒ | j r|d ur|jdkrtdƒ‚d S | ¡ }|d? }t |¡}|d urD|jdkrD|d u r<d}td|d›d|d›d�ƒ ntd |ƒ ||_|S )
NÚdetectzcDetecting flash size is not supported in secure download mode. Need to manually specify flash size.é r$ z3Warning: Could not auto-detect Flash size (FlashID=ú#xz , SizeID=z), defaulting to 4MBzAuto-detected Flash size:)r_ Ú
flash_sizer Úflash_idÚDETECTED_FLASH_SIZESÚgetrY )r‚ rƒ r£ Úsize_idr¢ rP rP rQ Údetect_flash_sizeÔ s, ÿ
ÿÿÿ
r§ c sÔ t |ƒdk r|S t d|dd… ¡\}}}}ˆ | jkr |S |j|j|jfdkr)|S || jkr6tdˆ ƒ |S z| t
|¡¡}| ¡ W n t
yX tdˆ | jf ƒ | Y S w |jdkoc|d d
k} ‡ fd d „}
|jd
krƒt|j } || kr�| r�|
d|jƒ n| }|d@ } |jd
kr¡| |j¡}
| |
krŸ| rŸ|
d|jƒ n|
} |d@ }|jd
kr¿| |j¡}||kr½| r½|
d|jƒ n|}t d||| ¡}||dd… krètdt d|¡ ƒ |dd… | |dd… }|S )z^
Modify the flash mode & size bytes if this looks like an executable bootloader image
é ÚBBBBNr‘ )Úkeeprª rª z`Warning: Image file at 0x%x doesn't look like an image file, so not changing any flash settings.zXWarning: Image file at 0x%x is not a valid %s image, so not changing any flash settings.Úesp8266r% r c s t djtˆ ƒ| |d�ƒ d S )NaL Warning: Image file at {addr} is protected with a hash checksum, so not changing the flash {arg} setting. Use the --flash_{arg}=keep option instead of --flash_{arg}={arg_orig} in order to remove this warning, or use the --dont-append-digest option for the elf2image command in order to generate an image file without a hash checksum)r| ÚargÚarg_orig)rY ÚformatÚhex)Ú arg_to_keepÚarg_used©r‰ rP rQ Úprint_keep_warning s
úÿz6_update_image_flash_params.<locals>.print_keep_warningrª Úmodeé Ú frequencyéğ r† s BBr= zFlash params set to 0x%04xz>Hr )rz ra ÚunpackÚBOOTLOADER_FLASH_OFFSETÚ
flash_modeÚ
flash_freqr¢ ÚESP_IMAGE_MAGICrY ÚBOOTLOADER_IMAGEÚioÚBytesIOÚverifyÚ ExceptionrL ÚchipÚ FLASH_MODESÚparse_flash_freq_argÚparse_flash_size_argr™ )r‚ r‰ rƒ r„ ÚmagicÚ_rº Úflash_size_freqÚ
test_imageÚsha_implies_keepr³ Únew_flash_moder» Únew_flash_freqr¢ Únew_flash_sizeÚ flash_paramsrP r² rQ Ú_update_image_flash_paramsî sb
ÿÿ ÿÿû
rÏ c $ s¦ ˆ j d u r
ˆ js
ˆ j ˆ _ ˆ j�s
| jdk�r
| j�s
| ¡ r/ˆ jD ] \}}|dk r.tdƒ‚q"ˆ jD ]Ú\}}z#zt | j|ƒ}W n tt
j t fyR Y W |
d¡ q2w W |
d¡ n|
d¡ w |j| jkrrt|j› d| j› d�ƒ‚|jdkrzd}n|jdkr�d }|jdkr�|jdkr�d}nd }|ré| ¡ }||jk s ||jkrè|j› d
�}|d |jd › d
|jd › d�7 }|jdkrÁ|d7 }n|d|jd › d
|jd › d�7 }|d|d › d
|d › d�7 }t|› d�ƒ‚q2| jdkró| ¡ }n| ¡ }||jk �r t|j› d|j› d|› d�ƒ‚q2ˆ j�sˆ jd u�rzd } | j�sI| ¡ �r&tdƒ‚| ¡ }
|
d u�r<|
dk�r<td|
ƒ d} | ¡ } | �sItd ƒ d} ˆ j�rPˆ jnˆ j} | D ]\}}|| j �rltd |j|| j f ƒ d} �qU| �syˆ j �sytd ƒ‚n:ˆ j�s´| jdk�r´| jd k�r¢| j�r¢t | ¡ d ƒ !d!¡d"@ dk�r¢td#ƒ‚| j�s´| ¡ �r´| "¡ �r´td$ƒ‚t#ˆ j$d%k�r¿t%| ƒnˆ j$ƒ}
|
d u�róˆ jD ]'\}}|
dt&j'¡ || (¡ |
k�rìtd&|j| (¡ ||
f ƒ‚|
d¡ �qˈ j)�rıt*| ˆ ƒ nBˆ jD ]>\}}|
dt&j'¡ || (¡ }|
d¡ || j+ }|dk�r*td' ,|| j+|¡ƒ td( ,|| t-|| j+ƒ| j+ d" ¡ƒ �q ‡ fd)d*„ˆ jD ƒ} ˆ jd u�rcd+d*„ ˆ jD ƒ}t.|| d,d-„ d.�}|D �]�\}}}ˆ j }|�r�|�r�td/ƒ td0|j ƒ d}ˆ j�r‰td1ƒ t/| 0¡ |�r“| j nd2ƒ}t1|ƒdk�r¦td3|j ƒ �qet2| |ˆ |ƒ}t3 4|¡ 5¡ }t1|ƒ}|�rÑ|}t6 |d4¡}t6 7¡ }| 8|t1|ƒ|¡}n| j9|||d5�}|
d¡ d}d}d}t: :¡ } t;} t1|ƒdk�rqt<d6|| d |d" | f ƒ t=j> ?¡ |d| j@… } |�r8t1| A| ¡ƒ} || 7 }tBt;tCtD| ƒƒ} | jE�s)| } | jF| || d7� | jE�r7| } n!| d8| j@t1| ƒ } |�rM| G| |¡ n| H| |¡ |t1| ƒ7 }|t1| ƒ7 }|| j@d … }|d"7 }t1|ƒdk�sñ| jE�r}| jItJjK| d7� t: :¡ | } d9}!|�r¥| d:k�r—d;|| d< d= }!t<d>|||| |!f d d?� n| d:k�r´d@|| d< d= }!t<dA||| |!f d d?� |�s| j�sz/| L||¡}"|"|k�rğtdB| ƒ tdC|" ƒ tdDt3 4d8| ¡ 5¡ ƒ tdEƒ‚tdFƒ W �qe tM�y Y �qew �qetdGƒ | jE�r*| 9dd¡ |dH dI }#ˆ j �r%|#�s%| Nd¡ n| Od¡ ˆ jP�rOtdJƒ tdKƒ ˆ j�s@ˆ jd u�rDtdLƒ ˆ j�sQtQ| ˆ ƒ d S d S d S )MNrI i € z´Secure Boot detected, writing to flash regions < 0x8000 is disabled to protect the bootloader. Use --force to override, please use with caution, otherwise it may brick your device!r z is not an z$ image. Use --force to flash anyway.Fiÿÿ Tz! requires chip revision in range z[vr“ rS z - zmax rev not set] Úvz] z(this chip is revision vú)z . Use --force to flash anyway.zESP32-C3z requires chip revision z" or higher (this chip is revision z ). Use --force to flash anyway.zŸThis chip has encrypt functionality in UART download mode disabled. This is the Flash Encryption configuration for Production mode instead of Development mode.rµ z)Unexpected FLASH_CRYPT_CONFIG value: 0x%xz&Flash encryption key is not programmedzBFile %s address 0x%x is not %d byte aligned, can't flash encryptedz`Can't perform encrypted flash write, consult Flash Encryption documentation for more informationrJ Úflash_crypt_cntÚ1r zšWARNING: Detected flash encryption and secure download mode enabled.
Flashing plaintext binary may brick your device! Use --force to override the warning.z¦WARNING: Detected flash encryption enabled and download manual encrypt disabled.
Flashing plaintext binary may brick your device! Use --force to override the warning.rª zzFile %s (length %d) at offset %d will not fit in %d bytes of flash. Use --flash_size argument, or change flashing address.z|WARNING: Flash address {:#010x} is not aligned to a {:#x} byte flash sector. {:#x} bytes before this address will be erased.z1Flash will be erased from {:#010x} to {:#010x}...c s g | ]
\}}||ˆ j f‘qS rP )Úencrypt©rN Úoffsrx ©rƒ rP rQ rR s ÿz write_flash.<locals>.<listcomp>c S s g | ] \}}||d f‘qS )TrP rÕ rP rP rQ rR s ÿc S ó | d S ©Nr rP ©ÚxrP rP rQ Ú<lambda> ó z write_flash.<locals>.<lambda>©Úkeyz@
WARNING: - compress and encrypt options are mutually exclusive zWill flash %s uncompressedzErasing flash...r‘ zWARNING: File %s is emptyé )Úbegin_rom_encryptedz Writing at 0x%08x... (%d %%))Útimeoutó ÿrF ç z (effective %.1f kbit/s)r¨ éè z=Wrote %d bytes (%d compressed) at 0x%08x in %.1f seconds%s...r” z (%.1f kbit/s)z-Wrote %d bytes at 0x%08x in %.1f seconds%s...z
File md5: %sz
Flash md5: %szMD5 of 0xFF is %sz)MD5 of file does not match data in flash!zHash of data verified.z
Leaving...éÿÿÿÿr= z Verifying just-written flash...zT(This option is deprecated, flash contents are now always read back after flashing.)z>WARNING: - cannot verify encrypted files, they will be ignored)RÚcompressÚ no_compressÚno_stubÚforcerL r_ Úget_secure_boot_enabledÚ
addr_filenamer r ra rb Ú RuntimeErrorÚseekrq r[ ÚnameÚ max_rev_fullÚ min_rev_fullÚmin_revÚget_chip_revisionÚget_minor_chip_versionÚget_major_chip_versionrÔ Ú
encrypt_filesÚ get_encrypted_download_disabledÚget_flash_crypt_configrY Ú is_flash_encryption_key_validÚFLASH_ENCRYPTED_WRITE_ALIGNÚ%ignore_flash_encryption_efuse_settingÚbinÚget_security_infoÚcountÚ get_flash_encryption_enabledr r¢ r§ ÚosÚSEEK_ENDrš Ú erase_allÚ erase_flashÚFLASH_SECTOR_SIZEr® r Úsortedr Úreadrz rÏ ÚhashlibÚmd5Ú hexdigestÚzlibÚ
decompressobjÚflash_defl_beginÚ flash_beginÚtimer
r rd re rf ÚFLASH_WRITE_SIZEÚ
decompressÚmaxr
r ÚIS_STUBÚflash_defl_blockÚflash_encrypt_blockÚ flash_blockr] r r^ Ú flash_md5sumr Úflash_defl_finishÚ flash_finishrÀ Ú verify_flash)$r‚ rƒ r‰ rÇ Úargfiler„ Úuse_rev_full_fieldsÚrevÚ error_strÚdo_writeÚcrypt_cfg_efuseÚ
enc_key_validÚfiles_to_encryptÚ flash_endÚ write_endÚ
bytes_overÚ all_filesÚencrypted_files_flagÚ encryptedrç Úcalcmd5ÚuncsizeÚuncimager Úblocksr‡ Ú
bytes_sentÚ
bytes_writtenÚtrâ ÚblockÚblock_uncompressedÚ
block_timeoutÚ speed_msgÚresÚlast_file_encryptedrP r× rQ Ú write_flashB s"
ÿÿ ıÿ ÿ
ÿÿ€ ÿ
ÿ ô
ÿÿÿÿ
ÿ ÿÿ€ÿ€ÿş ıÿÿşıÿÿ
ıÿ
ÿı
ÿşşÿ
ÿ ÿ ÿ
ÿÿ
şÿ€ İ%
ÿı
ÿı
ÿÿÿ€
ÿó r5 c s† ‡ ‡fdd„}t dtˆ jƒ› d�ƒ tˆ jdƒ�‚}z | d¡}|d }W n ty/ tdƒ‚w |tjt j
fvr?td |¡ƒ‚ˆ j d
kr“z8| d ¡}|d d
vrTtdƒ‚t
|dd… d¡}dd„ tD ƒD ]
}||jkrr|jˆ _ n qetd|› d�ƒ‚W n tyˆ dˆ _ Y nw t dˆ j ¡ › �ƒ W d ƒ n1 s�w Y tˆ j ˆ jƒ‰ˆ jdkr³|ƒ d S t d ˆj¡ƒ t ˆjdkrÇd ˆj¡ndƒ t d tˆjƒ¡ƒ t ƒ d}ˆjD ]} |d 7 }| ˆ¡}
d |
¡} t d || | ¡ƒ q܈ ¡ } t d ˆjˆj| k�rd!nd" | ¡¡ƒ z)d#}
ˆj �r5ˆj ˆj k}d$ t ˆj d%d&�|�r(d!nd'¡}
t d( |
¡ƒ W d S W d S t �yB Y d S w ))Nc #
sh dd„ } t ƒ d ˆ j ¡ ¡}t |ƒ t dt|ƒ ƒ t d ˆj¡ƒ t ˆjdkr/d ˆj¡ndƒ t d tˆjƒ¡ƒ ˆjd
@ }| ˆj j
|ƒ}t |d urRd |¡nd |¡ƒ ˆjd
@ }| ˆj j |ƒ}t |d urnd |¡nd |¡ƒ | t ˆj
ƒ}t |d ur†d | ¡ ¡nd ˆj
¡ƒ ˆ jdk�r't ƒ d ˆ j ¡ ¡}t |ƒ t dt|ƒ ƒ t dˆjd›�gˆjˆjkr»dgng ¢R � t d ˆjˆjˆjˆjˆjˆj¡ƒ z t‡fdd„t ¡ D ƒƒ}t dˆj› d|j› d �ƒ W n t�y t dˆj› d �ƒ Y nw t d ˆj d › d ˆj d › d!ˆj › d �ƒ t d"ˆj d › d ˆj d › �ƒ t ƒ d#}t |ƒ t dt|ƒ ƒ d$}t | d%d&d'd(d)¡ƒ t d* d+d+d,d,d-¡ƒ d.} d }
d } t ˆjd/d0�D ]@\} }
|
ˆ¡}d1 !|¡}d2|v �rx|
j"d d3… }
nd4|v �rŒt|
j"ƒd5k�rŒ|
j"d d5… } t | | t|
j"ƒ|
j#|
j$|¡ƒ �q]t ƒ ˆ j ¡ › d6�}t |ƒ t dt|ƒ ƒ ˆ %¡ }t d7 ˆj&ˆj&|k�rÆd8nd9 |¡¡ƒ z%d:}ˆj'�rñˆj(ˆj)k}d; t*ˆj)d<d=�|�rçd8nd>¡}t d? |¡ƒ W n
t+�yü Y nw |
�rld@}t, -||
¡\
}}}}}}}}} } |dAk�rjt ƒ dB}t |ƒ t dt|ƒ ƒ t dC| .dD¡› �ƒ t dE| .dD¡› �ƒ t dF| .dD¡› dG| .dD¡› �ƒ t dHt*| d<d=�› �ƒ t dI| .dD¡› �ƒ t dJ|› �ƒ d S d S | �r°dK} t, -| | ¡\} } }}}!}"| d5k�r²t ƒ dL}t |ƒ t dt|ƒ ƒ t dM|› �ƒ t dI| .dD¡› �ƒ t dF|! .dD¡› �ƒ d S d S d S )NNc S s& | ¡ D ] \}}||kr| S qdS )z Get key from value in dictionaryN)Úitems)ÚdictÚvalrß r� rP rP rQ Úget_key_from_value± s
ÿz2image_info.<locals>.v2.<locals>.get_key_from_valuez{} image headerú=úImage version: {}r zEntry point: {:#8x}úEntry point not setz Segments: {}r· zFlash size: {}z%WARNING: Invalid flash size ({:#02x})rµ zFlash freq: {}z*WARNING: Invalid flash frequency ({:#02x})zFlash mode: {}z WARNING: Invalid flash mode ({})r« z{} extended image headerzWP pin: z#02xz
(disabled)zFlash pins drive settings: clk_drv: {:#02x}, q_drv: {:#02x}, d_drv: {:#02x}, cs0_drv: {:#02x}, hd_drv: {:#02x}, wp_drv: {:#02x}c 3 s& � | ]}t |d dƒˆ jkr|V qdS )r[ N)Úgetattrrq )rN r )r„ rP rQ Ú <genexpr>ö s € ı
ÿz)image_info.<locals>.v2.<locals>.<genexpr>z Chip ID: z (rÑ z
(Unknown ID)zMinimal chip revision: vr“ rS z, (legacy min_rev = zMaximal chip revision: vzSegments informationz#{:>7} {:>7} {:>10} {:>10} {:10}ÚSegmentÚLengthz Load addrz File offsz Memory typesz{} {} {} {} {}z-------z
----------z ------------z%{:7} {:#07x} {:#010x} {:#010x} {}r )Ústartú, ÚDROMé ÚDRAMéP z
image footerzChecksum: {:#02x} ({})Úvalidúinvalid - calculated {:02x}ú Not appendedú{} ({})F©Ú uppercaseÚinvalidzValidation hash: {}z<II8s32s32s16s16s32s32s80sl 2TšW zApplication informationzProject name: zutf-8z
App version: zCompile time: rw zELF file SHA256: z ESP-IDF: zSecure version: z<B3sI32s24s16szBootloader informationzBootloader version: )/rY r® r Úupperrz Úversionr€ ry rÈ Ú
ROM_LOADERÚ FLASH_SIZESÚFLASH_FREQUENCYrà rº Úwp_pinÚWP_PIN_DISABLEDÚclk_drvÚq_drvÚd_drvÚcs_drvÚhd_drvÚwp_drvÚnextr Úvaluesrq rL Ú
StopIterationrñ rò rğ Ú enumerateÚget_memory_typeÚjoinr{ r| Ú file_offsÚcalculate_checksumÚchecksumÚ
append_digestÚ
stored_digestÚ calc_digestr ÚAttributeErrorra r¸ Údecode)#r9 ÚtitleÚ flash_s_bitsÚflash_sÚ
flash_fr_bitsÚflash_frrº rÂ Ú headers_strÚ
format_strÚapp_descÚbootloader_descÚidxr… ÚsegsÚseg_nameÚ
calc_checksumÚ
digest_msgÚis_validÚAPP_DESC_STRUCT_FMTÚ
magic_wordÚsecure_versionÚreserv1rO Ú project_namer ÚdateÚidf_verÚapp_elf_sha256Úreserv2ÚBOOTLOADER_DESC_STRUCT_FMTÚ
magic_byteÚreservedÚ date_timeÚ reserved2©rƒ r„ rP rQ Úv2° s` ÿı
ÿı
ÿı ÿ
ı ÿşúı ş ÿÿÿşÿÿÿÿ
ÿÿÿ
ÿÿüÿ ş€ÿ
õ
ö
ù
î zimage_info.<locals>.v2z File size: z (bytes)Úrbr¨ r z
File is emptyz7This is not a valid image (invalid magic number: {:#x})Úautor ræ ©r r z Append digest field not 0 or 1r‘ é Úlittlec S s g | ] }|j d kr|‘qS )rI rK rM rP rP rQ rR ‰ s z image_info.<locals>.<listcomp>zUnknown image chip ID (rÑ r« zDetected image type: Ú2r; zEntry point: {:8x}r< z {} segmentsr ú,zSegment {}: {} [{}]zChecksum: {:02x} ({})rG rH rI rJ FrK rM zValidation Hash: {})!rY r rx r– r Ú
IndexErrorr r r¼ r ÚIMAGE_V2_MAGICr® r ÚintÚ
from_bytesr r[ rL rN r rO r€ rz ry r_ r` rb rc rd re rf r rg )rƒ r‡ r› Ú
common_headerrÆ Úextended_headerrq Úromrr r… rs rt ru rv rw rP r† rQ Ú
image_info¯ sš @
ÿşş
şş
ÿ€ Ş$
ÿı
ÿüÿ şúÿr– c C sÌ t d | j¡ƒ tƒ }t| jƒdkrtdƒ‚t| jƒt| jƒkr$tdƒ‚t| j| jƒD ]&\}}t |dƒ�}|
¡ }|j t
||ƒ¡ W d ƒ n1 sLw Y q+| j|_| | j¡ t d | j¡ƒ d S )NúCreating {} image...r zNo segments specifiedzFNumber of specified files does not match number of specified addressesrˆ ú Successfully created {} image.)rY r® r r rz Úsegfiler ÚsegaddrÚzipr– r ry Úappendr r€ ÚsaveÚoutput)rƒ r„ r… r| r› r{ rP rP rQ Ú
make_image¾ s" ÿ ş€ rŸ c C sÊ t | jƒ}| jdkr
d| _td | j¡ƒ | jdkrCt| j ¡ }| jdkr,| jr,d|_| jr2d|_| j |_ | j
|_
| j |_ | j |_ n| j
dkrLtƒ }n | j
dkrUtƒ }ntƒ }|j|_t| j |_| jrm| t| jƒ¡ | jrs|jn|j|_| jr€t| jƒ|_|j | j ¡|_ | j |j | j ¡7 _ | j!r | "¡ |_#| j!|_!t$|jƒ}| %¡ t$|jƒ|krÅ|t$|jƒ }td||dkrÀd nd
f ƒ | &¡ | j'd u rÕ| (| j¡| _'| )| j'¡ td | j¡ƒ d S ) Nr‰ r« r— Úesp32rÓ r� zMerged %d ELF section%sr ÚsrF r˜ )*r Úinputr rY r® r r½ Ú
secure_padÚ
secure_pad_v2rò rñ rğ rd rO r r r r€ rà rº Úflash_mmu_page_sizeÚset_mmu_page_sizer Ú use_segmentsry ÚsectionsÚ pad_to_sizerP rÅ r¢ rÈ rÄ r» Úelf_sha256_offsetÚsha256Ú
elf_sha256rz Úmerge_adjacent_segmentsrÀ r� Údefault_output_namer� )rƒ rt r„ ÚbeforeÚdeltarP rP rQ Ú elf2imageĞ sR
r± c C sX dd„ }| d¡}|r"|d|ƒ |d| d¡ƒ |d| d¡ƒ d S |d| d¡ƒ d S )Nc S s$ t d| d tdd„ |ƒ¡f ƒ d S )Nz%s: %sú:c S s d| S )Nz%02xrP rÚ rP rP rQ rÜ rİ z-read_mac.<locals>.print_mac.<locals>.<lambda>)rY r` Úmap)ÚlabelÚmacrP rP rQ Ú print_mac s $zread_mac.<locals>.print_macÚEUI64ÚMACzBASE MACÚBASE_MACÚMAC_EXT)Úread_mac)r‚ rƒ r¶ Úeui64rP rP rQ r» s
r» c C sH z
| ¡ }td| ƒ W d S ty# td| j ƒ t| |ƒ Y d S w )NzChip ID: 0x%08xz0Warning: %s has no Chip ID. Reading MAC instead.)rq rY r rL r» )r‚ rƒ ÚchipidrP rP rQ rq s şrq c C s^ |j s| jdkr| js| ¡ s| ¡ rtdƒ‚tdƒ t ¡ }| ¡ tdt ¡ | ƒ d S )NrI ú§Active security features detected, erasing flash is disabled as a safety measure. Use --force to override, please use with caution, otherwise it may brick your device!z(Erasing flash (this may take a while)...z*Chip erase completed successfully in %.1fs) rê rL r_ rÿ rë r rY r r ©r‚ rƒ r. rP rP rQ r s ÿr c C sf |j s| jdkr| js| ¡ s| ¡ rtdƒ‚tdƒ t ¡ }| |j |j
¡ tdt ¡ | ƒ d S )NrI r¾ z1Erasing region (may be slow depending on size)...z-Erase completed successfully in %.1f seconds.) rê rL r_ rÿ rë r rY r Ú erase_regionr‰ r† r¿ rP rP rQ rÀ , s ÿrÀ c C s | ¡ d S ©N)ÚrunrŠ rP rP rQ r ; s r c C s† | ¡ }td|d@ ƒ |d? d@ }td|d? d@ |f ƒ tdt |d¡ ƒ | ¡ }dd d
œ}| |¡}|rAtd |› �ƒ d S d S ) NzManufacturer: %02xéÿ r zDevice: %02x%02xr¨ zDetected flash size: %sÚUnknownzquad (4 data lines)zoctal (8 data lines)rŠ zFlash type set in eFuse: )r£ rY r¤ r¥ Ú
flash_type)r‚ rƒ r£ Ú flid_lowbyterÅ Úflash_type_dictÚflash_type_strrP rP rQ r£ ? s ÿ
ÿr£ c C sº |j rd }ndd„ }t ¡ }| |j|j|¡}t ¡ | }|dkr.d t|ƒ| d d ¡nd}td t|ƒ|j||¡d d
� t|j d ƒ�}|
|¡ W d ƒ d S 1 sVw Y d S ) Nc S sJ d| | d | f }dt |ƒ }| |krd}tj || ¡ tj ¡ d S )Nz
%d (%d %%)g Y@úÚ
)rz rd re r˜ rf )ÚprogressÚlengthÚmsgÚpaddingrP rP rQ Úflash_progressS s z"read_flash.<locals>.flash_progressrä z ({:.1f} kbit/s)r¨ rå rF z2Read {:d} bytes at {:#010x} in {:.1f} seconds{}...Tr” r� ) Ú no_progressr Ú
read_flashr‰ r† r® rz r r– rx r˜ )r‚ rƒ rÏ r. r{ r2 r› rP rP rQ rÑ N s &ÿü "ÿrÑ c s. d}|j D ]‰\}}t| ¡ dƒ‰| d¡ t| ||ˆƒ‰tˆƒ}td||||jf ƒ | ||¡}t
ˆ¡ ¡ }||krAtdƒ qd}t |ddƒd krPtd
ƒ q|
||¡‰ ˆ ˆks\J ‚‡ ‡fd d „t|ƒD ƒ}td
t|ƒ||d f ƒ |D ]} ˆ | }
ˆ| } td|| |
| f ƒ qxq|r•tdƒ‚d S )NFr‘ r z9Verifying 0x%x (%d) bytes @ 0x%08x in flash against %s...z -- verify OK (digest matched)TÚdiffÚnoÚyesz"-- verify FAILED (digest mismatch)c s g | ] }ˆ | ˆ| kr|‘qS rP rP )rN rœ ©Úflashr„ rP rQ rR … s z verify_flash.<locals>.<listcomp>z0-- verify FAILED: %d differences, first @ 0x%08xz %08x %02x %02xzVerify failed.)rì r r rî rÏ rz rY rï r r r r r= rÑ r— r ) r‚ rƒ Ú differencesr‰ r Ú
image_sizeÚdigestÚexpected_digestrÒ r� Ú
flash_byteÚ
image_byterP rÕ rQ r i sH
ÿÿ ÿÿıÿr c C s t d| |j¡ ƒ d S )NzStatus value: 0x%04x)rY Ú read_statusÚbytesrŠ rP rP rQ Úread_flash_status’ s rß c C s‚ d|j d }|jd|j d > d @ |_td| | |j ¡ ƒ td| |j ƒ | |j|j |j¡ td| | |j ¡ ƒ d S )Nz0x%%0%dxr= r r¨ zInitial flash status: zSetting flash status: zAfter flash status: )rŞ r� rY rİ Ú write_statusÚ non_volatile)r‚ rƒ ÚfmtrP rP rQ Úwrite_flash_status– s rã r‘ r¨ r é@ é€ rD i r’ ) ÚSECURE_BOOT_ENÚ SECURE_BOOT_AGGRESSIVE_REVOKEÚSECURE_DOWNLOAD_ENABLEÚSECURE_BOOT_KEY_REVOKE0ÚSECURE_BOOT_KEY_REVOKE1ÚSECURE_BOOT_KEY_REVOKE2Ú
SOFT_DIS_JTAGÚ
HARD_DIS_JTAGÚDIS_USBÚDIS_DOWNLOAD_DCACHEÚDIS_DOWNLOAD_ICACHEc C s0 z |t | @ dkW S ty td| › �ƒ‚w )Nr zInvalid flag name: )ÚSECURITY_INFO_FLAG_MAPÚKeyErrorÚ
ValueError)Ú flag_nameÚ flags_valuerP rP rQ Úget_security_flag_status± s
ÿrö c C sì | ¡ }tƒ d}t|ƒ tdt|ƒ ƒ td |d t|d ƒ¡ƒ td |d ¡ƒ |d d urJ|d d urJtd |d ¡ƒ td
|d ¡ƒ |d }td |ƒr�td ƒ td
|ƒr`tdƒ g }tg d¢ƒD ]\}}t||ƒrv| |¡ qht|ƒdkr�tdƒ |D ]
}td|› d�ƒ qƒntdƒ t|d ƒ}| d¡d dkr§tdƒ ntdƒ d} | j dkr´d } t| › d |d d ›�ƒ td |ƒrÉtd ƒ td!|ƒrÒtd"ƒ td#|ƒ}
td$|ƒ} |
rãtd%ƒ n| rétd&ƒ td'|ƒrôtd(ƒ d S d S ))NzSecurity Information:r: zFlags: {:#010x} ({})ÚflagszKey Purposes: {}Ú key_purposesrq Ú api_versionz Chip ID: {}zAPI Version: {}ræ zSecure Boot: Enabledrç z.Secure Boot Aggressive key revocation: Enabled)ré rê rë r z#Secure Boot Key Revocation Status:
z Secure Boot Keyz is Revoked
zSecure Boot: DisabledrÒ rÓ r= zFlash Encryption: EnabledzFlash Encryption: Disabledz)SPI Boot Crypt Count (SPI_BOOT_CRYPT_CNT)r z#Flash Crypt Count (FLASH_CRYPT_CNT)z: r¡ rï z&Dcache in UART download mode: Disabledrğ z&Icache in UART download mode: Disabledrí rì zJTAG: Permenantly Disabledz JTAG: Software Access Disabledrî zUSB Access: Disabled)
rı rY rz r® rü rö r^ rœ rş rL ) r‚ rƒ Úsiri r÷ Ú revoked_keysrœ rß rÒ ÚCRYPT_CNT_STRINGÚ
hard_dis_jtagÚ
soft_dis_jtagrP rP rQ rı ¸ sb
ÿ
€ €
ÿrı c sP zt ˆ j }W n" ty) ˆ jdkrdnd ˆ j¡}|d d t¡¡ }t|ƒ‚w tˆ jdd„ d�}|s9td ƒ‚|d
d
}|ˆ j k rMtd ˆ j |f ƒ‚ˆ jd krVtd
ƒ‚t
ˆ j dƒ�B‰‡ ‡fdd„}|D ]\}}||ƒ | ¡ }t
||ˆ |ƒ}ˆ |¡ qfˆ jr‰|tˆ jƒƒ tdˆ ¡ ˆ j ˆ j f ƒ W d ƒ d S 1 s¡w Y d S )Nr‰ z Please specify the chip argumentzInvalid chip choice: '{}'z (choose from {})rB c S rØ rÙ rP rÚ rP rP rQ rÜ rİ zmerge_bin.<locals>.<lambda>rŞ zNo input files specifiedr zIOutput file target offset is 0x%x. Input file offset 0x%x is before this.Úrawz=This version of esptool only supports the 'raw' output formatr� c s ˆ d| ˆ j ˆ ¡ ¡ d S )Nrã )r˜ Ú
target_offsetrš )Ú
flash_offs©rƒ ÚofrP rQ r s zmerge_bin.<locals>.pad_toz:Wrote 0x%x bytes to file %s, ready to flash to offset 0x%x)r r rò r® r` r r r rì r r– r� r rÏ r˜ Úfill_flash_sizer rY rš ) rƒ Ú
chip_classrÍ Ú input_filesÚ
first_addrr r| r r„ rP r rQ Ú merge_binú sN ÿ
ıù
ÿÿ
ÿ ÿÿ"ór c C s ddl m} t|ƒ d S )Nr )Ú __version__)rF r rY )rƒ r rP rP rQ rO * s rO rÁ )Ar r¾ r ra rd r r
Ú bin_imager r r r r r Úloaderr r
r r r
Útargetsr r r Úutilr r r r r r r r r r r¤ rÃ Ú DEFAULT_PORTÚ ESP_ROM_BAUDrv rˆ r‹ r� r� r§ rÏ r5 r– rŸ r± r» rq r rÀ r r£ rÑ r rß rã rñ rö rı r rO rP rP rP rQ Ú<module> sÌ ÿşıüûúùø ÷
ö õ ô
óòñğïé
û^
T o 7
) õB 0 | 30,980 | Python | .py | 223 | 137.650224 | 2,611 | 0.485368 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,611 | __init__.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/__pycache__/__init__.cpython-310.pyc | o
’jÂdÓ� ã @ s| g d ¢Z dZddlZddlZddlZddlZddlZddlZddlZddl m
Z
m Z m Z m
Z
mZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m Z m Z m Z m Z m!Z! ddl"m#Z# ddl$m%Z%m&Z&m'Z' ddl(m)Z)m*Z*m+Z+ ddl,m-Z-m.Z.m/Z/m0Z0 ddl1Z1d d d
„Z2d d „ Z3d
d„ Z4dd„ Z5dd„ Z6 d dd„Z7G dd„ dej8ƒZ9G dd„ dej8ƒZ:d d „ Z;e<d kr¼e;ƒ dS dS )!)Úchip_idÚ detect_chipÚdump_memÚ elf2imageÚ erase_flashÚ erase_regionÚflash_idÚget_security_infoÚ
image_infoÚload_ramÚ
make_imageÚ merge_binÚ
read_flashÚread_flash_statusÚread_macÚread_memÚrunÚ verify_flashÚversionÚ write_flashÚwrite_flash_statusÚ write_memz4.7-devé N)ÚDETECTED_FLASH_SIZESr r Údetect_flash_sizer r r r r r r r
r r r
r r r r r r r r r )Úload_config_file)ÚDEFAULT_CONNECT_ATTEMPTSÚ ESPLoaderÚ
list_ports)Ú CHIP_DEFSÚ CHIP_LISTÚESP32ROM)Ú
FatalErrorÚNotImplementedInROMErrorÚflash_size_bytesÚstrip_chip_namec % sæ ˆdu}t jdt dd�}|jdddtdgt tj d d¡d
� |jd d d
tj dd¡d� |jdddt tj dt
j ¡d� |jddg d¢tj dd¡d� |jdd d g d ¢tj d d ¡d� |jd!d"d#d$� |jd%d&d'd#d$� |jd(d)t j
d*d+� |jd,d-t ttj d.t¡d� |jd/d0d1�}d2d3„ ‰|jd4d5d6�}|jd7d8d6� |jd9d:d6�}|jd;d<t d=� |jd>d?t d=� |jd7d@d6� |jdAdBd6�}|jd;dCt d=� |jdDdEd6�}|jd;dFt d=� |jdGdHt d=� |jdIdJt d*dKdL� ‡fdMdN„} |jdOdPd6�}
|
jdQdRdStdT� |
jdUdVdWd#d$� | |
dXdXdY� |
jdZd d[d#d$� |
jd\d]d#d$� |
jd^d_d#d$� |
jd`dRdatdT� |
jdbdcd#d$� |
jddded#d$� |
jdfdg�} | jdhdidjd#ddk� | jdldmdnd#d$� |jdodpd6� |jdqdrd6�} | jd7dsd6� | jdtdudvdwdxgdwd� |jdydzd6�}
|
jd{d|d6� |
jd}d~dd€d�� |
jd‚d ddƒt d„� |
jd…dVd†t d‡d� |jdˆd‰d6�}|jdŠd‹d6� |jdŒd�d�td=� |jdtdVd�g d�¢dwd� |jd‘d’t jttd“ƒd”d‡d•� |jd–d—ttd˜ƒd™d‡d•� |jdšd›ttd˜ƒd™dœd•� |jd�d#d�d�� |jdŸd#d d�� |jd¡d¢t dd� |jd£d¤d¥d¦dXd§� |jd¨d©d#d$� |jdªd«g d¬¢d� |jd®d¯dd� | |dfdfdY� |jd°d±d6� |jd²d³d6� |jd´dµd6�}ˆ|ƒ |jd¶d·d6�}ˆ|ƒ |jd¸d¹tg dº¢d»d
� |jd¼d½d6�}ˆ|ƒ |jd¾d¿d#d$� |jd¸dÀtg dº¢d»d
� |jdGdÁt d=� |jdÂdÃd6�}ˆ|ƒ |jd;dÄt d=� |jd>dÅtd=� |jd7d@d6� |jdZd d[d#d$� |jdÆdÇd6�}|jdQdÈtd$� |jdÉdÊdËdÌdÍgdÌd� | |dXdXdY� |jdÎdÏd6�}|jdddĞd#d$� ˆ|ƒ |jdÑdÒd6�}|jdddÓd#d$� ˆ|ƒ |jd;dÔt d=� |jd>dÕtd=� |jdÖd×d6�}|jdŒd�dØtdXdÙ� |jdÚd~dÛdÜdÜd� | |dXdfdY� |jdİd&dŞt d‡d� |jdßdàg dá¢d� |jdQdRdStdT� |jdâdãd6� |jdädåd6� |j ¡ D ]}|tƒ v �sxJ dæ| ƒ‚�qjt| �p„t j dçd… ƒ} | | ¡}t dèt ƒ t dXdé� |j!du �r¥| "¡ t #dç¡ |j!dOk�r¹|j$�r¹|j%du�r¹t&dꃂtƒ |j! }t' (|¡j)}|d‡ dëk�rm|j*dìk�rÚt+t
j |j,ƒ}n|j,}|j-du �rït.ƒ } t dít/| ƒ ƒ n|j-g} ˆ�pt0| |j-|j1||j2|j3|j*dî�‰ˆdu �rt&dït/| ƒ ƒ‚ˆj4�r t dğˆj5 ƒ n t dñˆ 6¡ ƒ t dòdó 7ˆ 8¡ ¡ ƒ t dôˆ 9¡ ƒ t:ˆ|ƒ |j;�s€ˆj4�rOt dõƒ dX|_;n1ˆj<�s_ˆj=�r_t döƒ dX|_;n!zˆ >¡ ‰W n t?�y t j@d÷k�r~ˆ A¡ døk�r~t dùƒ ‚ w |jB�rŠˆ B|jB¡ |j,|k�r©zˆ C|j,¡ W n tD�y¨ t dú| ƒ Y nw tE|dûƒ�rÍ|jFdu�r͈j5dük�rÂt&dıˆj5 ƒ‚t dşƒ ˆ G|jF¡ n
|j;�rÚt dÿƒ ˆ Gd‡¡ �d ‰ ‡ ‡f�d�d„‰‡ ‡‡f�d�d„} ˆj4�s zˆ H¡ } | �dv �rt �dƒ W n t&�y } z
t&�d| › �d�ƒ‚d} ~ ww ˆj4�sEz| ƒ W n t&�yD } zˆ 3�d | › �d�¡ W Y d} ~ nd} ~ ww tE|�d
ƒ�r‹t �d ƒ |jI�d k�r^tJˆ|ƒ} n|jI�d
k�rmtJˆd�d�} n|jI} | du�r‹ˆ KtL| ƒ¡ ˆj<�r‹| �dv �r‹t �dƒ tM|d>�dƒ�dk�rĈj4�rŸt&�dƒ‚ˆ H¡ } | �d? }!tN |!¡}"|"du �r·t&�dƒ‚t �d|"› �ƒ tL|"ƒ|_Oˆj<�rãtE|d;ƒ�rãtE|d>ƒ�rã|jP|jO �dk�rãt �dƒ z |ˆ|ƒ W z|jQD ] \}#}$|$ R¡ �qîW n$ tS�y Y nw z|jQD ] \}#}$|$ R¡ �qW w tS�y Y w w |tTk�r)t �dƒ n8|jUd k�r4ˆ V¡ n-|jU�dk�rFt �dƒ ˆ Wdf¡ n|jU�dk�rSt �d ƒ nt �d ƒ ˆj<�raˆ WdX¡ |�skˆjX R¡ dS dS ||ƒ dS ( aš
Main function for esptool
argv - Optional override for default arguments parsing (that uses sys.argv),
can be a list of custom arguments as strings. Arguments and their values
need to be added as individual items to the list
e.g. "-b 115200" thus becomes ['-b', '115200'].
esp - Optional override of the connected device previously
returned by get_default_connected_device()
Nz7esptool.py v%s - Espressif chips ROM Bootloader UtilityÚesptool)Ú descriptionÚprogz--chipz-czTarget chip typeÚautoÚ ESPTOOL_CHIP)ÚhelpÚtypeÚchoicesÚdefaultz--portz-pzSerial port deviceÚ ESPTOOL_PORT)r* r- z--baudz-bz0Serial port baud rate used when flashing/readingÚ ESPTOOL_BAUD)r* r+ r- z--beforez(What to do before connecting to the chip)Ú
default_resetÚ usb_resetÚno_resetÚno_reset_no_syncÚESPTOOL_BEFOREr0 ©r* r, r- z--afterz-az'What to do after esptool.py is finished)Ú
hard_resetÚ
soft_resetr2 Ú
no_reset_stubÚ
ESPTOOL_AFTERr6 z --no-stubzeDisable launching the flasher stub, only talk to ROM bootloader. Some features will not be available.Ú
store_true©r* Úactionz--tracez-tz5Enable trace-level output of esptool.py interactions.z--override-vddsdiozAOverride ESP32 VDDSDIO internal voltage regulator (use with care)ú?)r* r, Únargsz--connect-attemptszGNumber of attempts to connect, negative or 0 for infinite. Default: %d.ÚESPTOOL_CONNECT_ATTEMPTSÚ operationz/Run esptool.py {command} -h for additional help)Údestr* c S s | j dddtd� d S )Nz--spi-connectionz-scz£ESP32-only argument. Override default SPI Flash connection. Value can be SPI, HSPI or a comma-separated list of 5 I/O numbers to use for SPI flash (CLK,Q,D,HD,CS).r; )Ú add_argumentÚSpiConnectionAction)Úparent© rE ú0/home/ceco/Downloads/esptool/esptool/__init__.pyÚadd_spi_connection_arg¯ s
úz$main.<locals>.add_spi_connection_argr
z$Download an image to RAM and execute)r* ÚfilenamezFirmware imager z Dump arbitrary memory to diskÚaddressz Base address)r* r+ ÚsizezSize of region to dumpzName of binary dumpr z Read arbitrary memory locationzAddress to readr z.Read-modify-write to arbitrary memory locationzAddress to writeÚvalueÚValueÚmaskzMask of bits to writeÚ
0xFFFFFFFF)r* r+ r> r- c sæ |rdgng }|r|rd}ddg}n|rd}dg}n |r"d}dg}nd}g }| j ddd |g d
¢ tj d |r8dnd ¡d
� | j ddd|g d¢ tj d|rOdnd¡d
� | j ddd| |g d¢ tj d|rhdnd¡d
� ˆ | ƒ d S )z4Add common parser arguments for SPI flash propertiesÚkeepz, detect, or keepÚdetectz , or detectz , or keepÚ z --flash_freqz-ffzSPI Flash frequency) Ú80mÚ60mÚ48mÚ40mÚ30mÚ26mÚ24mÚ20mÚ16mÚ15mÚ12mÚ
ESPTOOL_FFNr5 z --flash_modez-fmzSPI Flash mode)ÚqioÚqoutÚdioÚdoutÚ
ESPTOOL_FMr^ z --flash_sizez-fszzSPI Flash size in MegaBytes (1MB, 2MB, 4MB, 8MB, 16MB, 32MB, 64MB, 128MB) plus ESP8266-only (256KB, 512KB, 2MB-c1, 4MB-c1)) Ú256KBÚ512KBÚ1MBÚ2MBz2MB-c1Ú4MBz4MB-c1Ú8MBÚ16MBÚ32MBÚ64MBÚ128MBÚ
ESPTOOL_FSre )rB ÚosÚenvironÚget)rD Ú
allow_keepÚ auto_detectÚextra_keep_argsÚextra_fs_messageÚ flash_sizes)rG rE rF Úadd_spi_flash_subparsersÙ sP
ÿî
ûşÿë z&main.<locals>.add_spi_flash_subparsersr z Write a binary blob to flashÚ
addr_filenamez<address> <filename>z7Address followed by binary filename, separated by space)Úmetavarr* r< z --erase-allz-ezDErase all regions of flash (not just write areas) before programmingT)rq rr z
--no-progresszSuppress progress outputz--verifyzYVerify just-written data on flash (mostly superfluous, data is read back during flashing)z --encryptzJApply flash encryption when writing data (required correct efuse settings)z--encrypt-filesz\Files to be encrypted on the flash. Address followed by binary filename, separated by space.z'--ignore-flash-encryption-efuse-settingz'Ignore flash encryption efuse settings z--forcezFForce write, skip security and compatibility checks. Use with caution!F)Úrequiredz
--compressz-zzACompress data in transfer (default unless --no-stub is specified))r* r< r- z
--no-compressz-uzLDisable data compression during transfer (default if --no-stub is specified)r z Run application code in flashr z;Dump headers from a binary file (bootloader or application)zImage file to parsez --versionz-vz0Output format version (1 - legacy, 2 - extended)Ú1Ú2r z-Create an application image from binary filesÚoutputzOutput image filez --segfilez-fÚappendzSegment input file)r< r* z --segaddrzSegment base address)r< r* r+ z --entrypointzAddress of entry pointr r z)Create an application image from ELF fileÚinputzInput ELF filez--outputz-ozVOutput filename prefix (for version 1 image), or filename (for version 2 single image)zOutput image version)rz r{ Ú3z --min-revz-ré z {0, ... 255})r* r+ r, rx r- z--min-rev-fullz6Minimal chip revision (in format: major * 100 + minor)i z{0, ... 65535}z--max-rev-fullz6Maximal chip revision (in format: major * 100 + minor)iÿÿ z --secure-padzXPad image so once signed it will end on a 64KB boundary. For Secure Boot v1 images only.z--secure-pad-v2zwPad image to 64KB, so once signed its signature sector willstart at the next 64K block. For Secure Boot v2 images only.z--elf-sha256-offsetz^If set, insert SHA256 hash (32 bytes) of the input ELF file at specified offset in the binary.z--dont-append-digestÚ
append_digestz|Don't append a SHA256 digest of the entire image after the checksum. This argument is not supported and ignored for ESP8266.Ú store_false)rA r* r< r- z--use_segmentszQIf set, ELF segments will be used instead of ELF sections to genereate the image.z--flash-mmu-page-sizezChange flash MMU page size.)Ú64KBÚ32KBÚ16KBÚ8KB)r* r, z
--pad-to-sizez‰The block size with which the final binary image after padding must be aligned to. Value 0xFF is used for padding, similar to erase_flashr z Read MAC address from OTP ROMr zRead Chip ID from OTP ROMr z)Read SPI flash manufacturer and device IDr z Read SPI flash status registerz--bytesz Number of bytes to read (1-3))é é é rˆ r z Write SPI flash status registerz--non-volatilez*Write non-volatile bits (use with caution)z%Number of status bytes to write (1-3)z New valuer
zRead SPI flash contentz
Start addressz>Size of region to dump. Use `ALL` to read to the end of flash.r z"Verify a binary blob against flashz;Address and binary file to verify there, separated by spacez--diffz-dzShow differencesÚnoÚyesr z Perform Chip Erase on SPI flashzDErase flash even if security features are enabled. Use with caution!r zErase a region of the flashzEErase region even if security features are enabled. Use with caution!z(Start address (must be multiple of 4096)z[Size of region to erase (must be multiple of 4096). Use `ALL` to erase to the end of flash.r zEMerge multiple raw binary files into a single file for later flashingzOutput filename)r* r+ ry z--formatzFormat of the output fileÚrawz--target-offsetz3Target offset where the output file will be flashedz--fill-flash-sizezQIf set, the final binary file will be padded with FF bytes up to this flash size.)
rc rd re rf rg rh ri rj rk rl r z Get some security-related datar zPrint esptool versionz %s should be a module functionr‡ zesptool.py v%s)ÚverbosezMOptions --encrypt and --encrypt-files must not be specified at the same time.Úespr3 zFound %d serial ports)ÚportÚconnect_attemptsÚ initial_baudÚchipÚtraceÚbeforezQCould not connect to an Espressif device on any of the %d available serial ports.z"Chip is %s in Secure Download Modez
Chip is %sz Features: %sz, zCrystal is %dMHzzPWARNING: Stub loader is not supported in Secure Download Mode, setting --no-stubzKWARNING: Stub loader has been disabled for compatibility, setting --no-stubÚdarwiniÔU zL
Note: If issues persist, try installing the WCH USB-to-Serial MacOS driver.zMWARNING: ROM doesn't support changing baud rate. Keeping initial baud rate %dÚspi_connectionÚESP32z1Chip %s does not support --spi-connection option.z Configuring SPI flash mode...z"Enabling default SPI flash mode...é c s¸ ˆ ¡ } | d@ d> | d? d@ B | d@ B }|d? d@ }|d? d@ }|d@ }|ˆ kr*dS d}|dkr<|dkr:|dkr:d }|S |d
krL|d krJ|dkrJd }|S |d krZ|d
krZ|dkrZd }|S )Néÿ é i ÿ é Fé@ é r˜ TéA é éP é é )r )ÚidÚrdidÚ vendor_idÚmfidÚcpidÚmatched)Ú
XMC_VENDOR_IDr� rE rF Úis_xmc_chip_strictó s( úız main.<locals>.is_xmc_chip_strictc sŒ d} | r ˆƒ r d S d}ˆ |d¡}|ˆ krd S tdƒ ˆ d¡ ˆ d¡ ˆ d¡ t d¡ ˆ d ¡ t d
¡ ˆƒ s@td ƒ td ƒ d S )
NTrš r› zQWARNING: XMC flash chip boot-up failure detected! Running XMC25QHxxC startup flowé¹ éy r™ gü©ñÒMb`?é« gñh㈵øô>z&WARNING: XMC flash boot-up fix failed.z&XMC flash chip boot-up fix successful!)Úread_spiflash_sfdpÚprintÚrun_spiflash_commandÚtimeÚsleep)Ú
fast_checkÚsfdp_mfid_addrÚmf_id)r© r� rª rE rF Úflash_xmc_startup
s&
ÿ
z main.<locals>.flash_xmc_startup)iÿÿÿ r z§WARNING: Failed to communicate with the flash chip, read/write operations will fail. Try checking the chip connections or removing any other hardware connected to IOs.z(Unable to verify flash chip connection (z).z3Unable to perform XMC flash chip startup sequence (Ú
flash_sizezConfiguring flash size...rP rO )Úargs)rj rk rl zjWARNING: Flasher stub doesn't fully support flash size larger than 16MB, in case of failure use --no-stub.rQ ÚallzWDetecting flash size is not supported in secure download mode. Set an exact size value.rš z5Detecting flash size failed. Set an exact size value.zDetected flash size: i zExiting immediately.r7 zSoft resetting...r8 zStaying in flasher stub.zStaying in bootloader.)YÚargparseÚArgumentParserÚ __version__rB r$ r rn ro rp Ú arg_auto_intr Ú ESP_ROM_BAUDr ÚOVERRIDE_VDDSDIO_CHOICESr ÚintÚadd_subparsersÚ
add_parserÚAddrFilenamePairActionÚ add_mutually_exclusive_groupÚstrÚSUPPRESSÚrangeÚ
arg_auto_sizer, ÚkeysÚglobalsÚexpand_file_argumentsÚsysÚargvÚ
parse_argsr¯ r r@ Ú
print_helpÚexitÚencryptÚ
encrypt_filesr! ÚinspectÚgetfullargspecr¸ r” ÚminÚbaudr� Ú
get_port_listÚlenÚ get_default_connected_devicer� r’ r“ Úsecure_download_modeÚ CHIP_NAMEÚget_chip_descriptionÚjoinÚget_chip_featuresÚget_crystal_freqr Úno_stubÚIS_STUBÚstub_is_disabledÚrun_stubÚ ExceptionÚplatformÚ_get_pidÚoverride_vddsdioÚ change_baudr" Úhasattrr– Úflash_spi_attachr r· r Úflash_set_parametersr# Úgetattrr rJ rI rw ÚcloseÚAttributeErrorr
Úafterr6 r7 Ú_port)%rÍ r� Ú external_espÚparserÚ
subparsersÚparser_load_ramÚparser_dump_memÚparser_read_memÚparser_write_memrv Úparser_write_flashÚ
compress_argsÚparser_image_infoÚparser_make_imageÚparser_elf2imageÚparser_flash_idÚparser_read_statusÚparser_write_statusÚparser_read_flashÚparser_verify_flashÚparser_erase_flashÚparser_erase_regionÚparser_merge_binr@ r¸ Úoperation_funcÚoperation_argsr‘ Úser_listr¶ r Úer· Úsize_idÚsize_strrI ÚargfilerE )r© rG r� rª rF ÚmainP sr
ÿı ú üû ü ûüüüÿ ù
ÿ
ÿÿÿÿÿû Eÿüüÿüüûıı ûûÿûÿÿûûÿûû÷ úúııûúüıüÿÿûÿıûÿıÿÿıÿÿıÿıÿüş
ÿ
ÿûüü
ÿşıÿ
ÿ ÿ ù
ÿÿ
ÿÿ ÿù ÿÿÿ ÿ
ÿ€€ÿ
"€ÿ
ÿÿ
ÿ
ÿ ÿÿı ÿÿ
ÿ r c C s
t | dƒS ©Nr ©rÀ ©ÚxrE rE rF r½ „ s
r½ c C s | ¡ } | dkr
| S t| ƒS )Nr¹ )Úlowerr½ r rE rE rF rÈ ˆ s rÈ c C s& t d u rtdƒ‚tdd„ t ¡ D ƒƒS )Nz Listing all serial ports is currently not available. Please try to specify the port when running esptool.py or update the pyserial package to the latest versionc s s � | ]}|j V qd S ©N)Údevice)Ú.0ÚportsrE rE rF Ú <genexpr>” s € z get_port_list.<locals>.<genexpr>)r r! ÚsortedÚcomportsrE rE rE rF r× � s
ÿr× c C sš g }d}| D ]6}| d¡r7d}t|dd… dƒ�}| ¡ D ] }|t |¡7 }q W d ƒ n1 s1w Y q| |¡ q|rKtdd |¡› �ƒ |S | S ) zù
Any argument starting with "@" gets replaced with all values read from a text file.
Text file arguments can be split by newline or by space.
Values are added "as-is", as if they were specified in this order
on the command line.
Fú@Tr‡ NÚrz esptool.py ú )Ú
startswithÚopenÚ readlinesÚshlexÚsplitr} r¯ rİ )rÍ Únew_argsÚexpandedÚargÚfÚlinerE rE rF rË — s
ÿ ÿ€ rË r( Fr0 c C sÄ d }t | ƒD ]Y}td| ƒ z$|dkr t|||||ƒ}W |S t| } | |||ƒ}| ||¡ W |S ttfy_ }
z |d urA‚ td||
f ƒ |rS|jrS|j ¡ d }W Y d }
~
qd }
~
ww |S )NzSerial port %sr( z%s failed to connect: %s) Úreversedr¯ r r Úconnectr! ÚOSErrorrğ rí ) Ú serial_listr� r� r‘ r’ r“ r” Ú_espÚ each_portÚ
chip_classÚerrrE rE rF rÙ ® s2
ÿõ ù
€úrÙ c @ s e Zd ZdZddd„ZdS )rC z‰
Custom action to parse 'spi connection' override.
Values are SPI, HSPI, or a sequence of 5 pin numbers separated by commas.
Nc C sü | ¡ dkr d}nl| ¡ dkrd}ncd|v rm| d¡}t|ƒdkr)t | d| ¡‚z tdd „ |D ƒƒ}W n tyC t | d
| ¡‚w td d „ |D ƒƒrSt | d
¡‚|\}}}} }
| d> |
d> B |d> B |d> B |B }nt | d| ¡‚t|| j |ƒ d S )NÚSPIr ÚHSPIr‡ ú,é zX%s is not a valid list of comma-separate pin numbers. Must be 5 numbers - CLK,Q,D,HD,CS.c s s � | ]}t |d ƒV qdS )r Nr ©r ÚvrE rE rF r â s € z/SpiConnectionAction.__call__.<locals>.<genexpr>z;%s is not a valid argument. All pins must be numeric valuesc S s g | ] }|d ks |dk r|‘qS )é! r rE r2 rE rE rF Ú
<listcomp>é s z0SpiConnectionAction.__call__.<locals>.<listcomp>z&Pin numbers must be in the range 0-33.é é é é zl%s is not a valid spi-connection value. Values are SPI, HSPI, or a sequence of 5 pin numbers CLK,Q,D,HD,CS).)
Úupperr rØ rº Ú
ArgumentErrorÚtupleÚ
ValueErrorÚanyÚsetattrrA ) Úselfrò Ú namespacerK Ú
option_stringÚvaluesÚclkÚqÚdÚhdÚcsrE rE rF Ú__call__Ô sH
ÿş ÿşÿÿ&şşz SpiConnectionAction.__call__r )Ú__name__Ú
__module__Ú __qualname__Ú__doc__rI rE rE rE rF rC Î s rC c s, e Zd ZdZd‡ fdd„ Zd dd„Z‡ ZS )
rà zFCustom parser class for the address/filename pairs passed as argumentsú+c s t t| ƒj|||fi |¤� d S r )Úsuperrà Ú__init__)r@ Úoption_stringsrA r> Úkwargs©Ú __class__rE rF rP ÿ s
ÿ
ÿz AddrFilenamePairAction.__init__Nc C sX g }t dt|ƒdƒD ]N}z t|| dƒ}W n ty& t | d|| ¡‚w z t||d dƒ}W n tyD } zt | | ¡‚d } ~ w tyP t | d¡‚w | ||f¡ q
d}
t
|dd„ d �D ]?\}}| dd¡ | ¡ } | d¡ |t
jd @ } || t
j d t
jd @ d }
| |
k r d
||jf }t | |¡‚|
}
qct|| j|ƒ d S ) Nr rˆ z Address "%s" must be a numberr‡ ÚrbzBMust be pairs of an address and the binary filename to write therec S s | d S r
rE r rE rE rF Ú<lambda> s z1AddrFilenamePairAction.__call__.<locals>.<lambda>)Úkeyz.Detected overlap at address: 0x%x for file: %s)rÇ rØ rÀ r= rº r; r ÚIOErrorÚ
IndexErrorr} r ÚseekÚtellr ÚFLASH_SECTOR_SIZEÚnamer? rA )r@ rò rA rC rB ÚpairsÚirI r r ÚendrJ Ú sector_startÚ
sector_endÚmessagerE rE rF rI sP ÿÿ € şÿ
ÿış z AddrFilenamePairAction.__call__)rN r )rJ rK rL rM rP rI Ú
__classcell__rE rE rS rF rà ü s rà c
C sÌ zt ƒ W d S ty% } ztd| › �ƒ t d¡ W Y d } ~ d S d } ~ w tjjyM } ztd| › �ƒ tdƒ tdƒ t d¡ W Y d } ~ d S d } ~ w tye tt
¡ ƒ tdƒ t d¡ Y d S w )Nz
A fatal error occurred: rˆ z$
A serial exception error occurred: z€Note: This error originates from pySerial. It is likely not a problem with esptool, but with the hardware connection or drivers.zkFor troubleshooting steps visit: https://docs.espressif.com/projects/esptool/en/latest/troubleshooting.htmlr‡ z4A fatal error occurred: The chip stopped responding.) r r! r¯ rÌ rĞ ÚserialÚ
serialutilÚSerialExceptionÚ
StopIterationÚ tracebackÚ
format_exc)r rE rE rF Ú_main/ s* €ÿÿ€ ırk Ú__main__)NN)r( Fr0 )=Ú__all__r¼ rº rÓ rn r rÌ r± ri Ú esptool.cmdsr r r r r r r r r r r r
r r r
r r r r r r r r r Úesptool.configr Úesptool.loaderr r r Úesptool.targetsr r r Ú esptool.utilr! r" r# r$ re r r½ rÈ r× rË rÙ ÚActionrC rà rk rJ rE rE rE rF Ú<module> sH h
:
ù .3
ÿ | 23,388 | Python | .py | 151 | 153.423841 | 3,241 | 0.563934 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,612 | loader.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/__pycache__/loader.cpython-310.pyc | o
’jÂd
î ã @ s† d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl Z ddl
m Z ddl m
Z
mZmZmZmZmZ ddlmZmZmZ ddlmZmZmZmZmZ zd dl Z W n e yk e dej ƒ ‚ w zde j v r{d e j v r{e d
ƒ‚W n e!y… Y nw z d dl"m# m$Z$ W n# e y£ e d ej%ej f ƒ ‚ e&y´ ej'd kr±dZ$n‚ Y nw e ƒ \Z(Z)e(d
Z(e( *dd¡Z+e( *dd¡Z,e( *de,d ¡Z-e( *dd¡Z.e( *dd¡Z/e( *dd¡Z0e( *dd¡Z1e( *d d ¡Z2e( *d d ¡Z3e( 4d d!¡Z5e( 4d"d¡Z6ej7 8ej7 9e:¡d#d$¡Z;d%d&„ Z<d'd(„ Z=d)d*„ Z>d+d,„ Z?d-d.„ Z@d/d0„ ZAG d1d2„ d2ƒZBG d3d4„ d4eCƒZDd5d6„ ZEG d7d8„ d8eCƒZFdS )9é Né )Úload_config_file)Ú ClassicResetÚ CustomResetÚDEFAULT_RESET_DELAYÚ HardResetÚUSBJTAGSerialResetÚUnixTightReset)Ú
FatalErrorÚNotImplementedInROMErrorÚUnsupportedCommandError)ÚbyteÚhexifyÚ
mask_to_shiftÚpad_toÚstrip_chip_namezQPyserial is not installed for %s. Check the README for installation instructions.Ú
serializationÚdeserializationaà esptool.py depends on pyserial, but there is a conflict with a currently installed package named 'serial'.
You may work around this by 'pip uninstall serial; pip install pyserial' but this may break other installed Python software that depends on 'serial'.
There is no good fix for this right now, apart from configuring virtualenvs. See https://github.com/espressif/esptool/issues/269#issuecomment-385298196 for discussion of the underlying issue(s).z”The installed version (%s) of pyserial appears to be too old for esptool.py (Python interpreter %s). Check the README for installation instructions.ÚdarwinÚesptoolÚtimeouté Úchip_erase_timeoutéx Ú max_timeouté Ú sync_timeoutgš™™™™™¹?Úmd5_timeout_per_mbé Úerase_region_timeout_per_mbé Úerase_write_timeout_per_mbé( Úmem_end_rom_timeoutgš™™™™™É?Úserial_write_timeouté
Úconnect_attemptsé Úwrite_block_attemptsÚtargetsÚ stub_flasherc C s* t | ƒ} | dd¡} tj td| › d�¡S )NÚespÚ Ú
stub_flasher_z.json)r ÚreplaceÚosÚpathÚjoinÚ STUBS_DIR)Ú chip_name© r4 ú./home/ceco/Downloads/esptool/esptool/loader.pyÚget_stub_json_pathg s r6 c C s | |d }|t k r t S |S )z'Scales timeouts which are size-specificç €„.A)ÚDEFAULT_TIMEOUT)Úseconds_per_mbÚ
size_bytesÚresultr4 r4 r5 Útimeout_per_mbm s r< c s ‡ ‡fdd„}|S )at
Decorator implementation that wraps a check around an ESPLoader
bootloader function to check if it's supported.
This is used to capture the multidimensional differences in
functionality between the ESP8266 & ESP32 (and later chips) ROM loaders, and the
software stub that runs on these. Not possible to do this cleanly
via inheritance alone.
c s( | d }ˆ |ƒrˆ| i |¤�S t |ˆƒ‚)Nr )r )ÚargsÚkwargsÚobj©Ú
check_funcÚfuncr4 r5 Úinner€ s
z'check_supported_function.<locals>.innerr4 )rB rA rC r4 r@ r5 Úcheck_supported_functionu s rD c C ó t | dd„ ƒS )zCAttribute for a function only supported in the software stub loaderc S s | j S ©N)ÚIS_STUB©Úor4 r4 r5 Ú<lambda>Œ s z$stub_function_only.<locals>.<lambda>©rD ©rB r4 r4 r5 Ústub_function_onlyŠ s rM c C rE )zMAttribute for a function only supported by stubs or ESP32 and later chips ROMc S s | j p| jdvS )N)ÚESP8266)rG Ú CHIP_NAMErH r4 r4 r5 rJ ’ s z.stub_and_esp32_function_only.<locals>.<lambda>rK rL r4 r4 r5 Ú stub_and_esp32_function_only� ó ÿrP c C rE )zFAttribute for a function only supported by ESP32S3 and later chips ROMc S s
| j dvS )N)rN ÚESP32zESP32-S2)rO rH r4 r4 r5 rJ ™ s
z0esp32s3_or_newer_function_only.<locals>.<lambda>rK rL r4 r4 r5 Ú esp32s3_or_newer_function_only– rQ rS c @ s e Zd Zdd„ ZdS )Ú StubFlasherc C s˜ t |ƒ�
}t |¡}W d ƒ n1 sw Y t |d ¡| _|d | _|d | _zt |d ¡| _|d | _ W d S t
yK d | _d | _ Y d S w )NÚtextÚ
text_startÚentryÚdataÚ
data_start) ÚopenÚjsonÚloadÚbase64Ú b64decoderU rV rW rX rY ÚKeyError)ÚselfÚ json_pathÚ json_fileÚstubr4 r4 r5 Ú__init__� s
ÿ
şzStubFlasher.__init__N)Ú__name__Ú
__module__Ú __qualname__rd r4 r4 r4 r5 rT � s rT c @ s e Zd ZdZdZdZdZdZdZdZ dZ
dZ dZ d Z
d
Zd Zd Zd
ZdZdZdZdZdZdZdZdZdZdZdZ dZ dZ dZ dZ d Z!d Z"d Z#d Z$d Z%d!Z&d"Z'd#Z(d$Z)d%Z*d&Z+dZ,d'Z-dZ.dZ/d(Z0d d)iZ1ee#dfd*d+„Z2e3d,d-„ ƒZ4d.d/„ Z5d0d1„ Z6d2d3„ Z7d4d5„ Z8e9e%fd6d7„ƒZ:d8d9d'd:e;fd;d<„Z<d8d9d'e;fd=d>„Z=d?d@„ Z>dAdB„ Z?dCdD„ Z@d�dFdG„ZAdHdI„ ZBdJdK„ ZCdEeDdd:fdLdM„ZEdNdO„ ZFe;fdPdQ„ZGd�dSdT„ZHdUdV„ ZIdWdX„ ZJdYdZ„ ZKdŸd[d\„ZLd d]d^„ZMe;fd_d`„ZNe;fdadb„ZOd dcdd„ZPd dedf„ZQdgdh„ ZRdidj„ ZSdkdl„ ZTeUdmdn„ ƒZVdodp„ ZWeXdqdr„ ƒZYeXdsdt„ ƒZZd¡dudv„Z[e\dwdx„ ƒZ]e\e;fdydz„ƒZ^e\d d{d|„ƒZ_e\d}d~„ ƒZ`e\dd€„ ƒZaebd�d‚„ ƒZcebdƒd„„ ƒZdd…d†„ Zed¡d‡dˆ„Zfd‰dŠ„ Zgd‹dŒ„ Zh 9 ' 8 ' 'd¢d�d�„Zid�d�„ Zjd£d‘d’„Zkd¤d“d”„Zld•d–„ Zmd—d˜„ Znd™dš„ Zod›dœ„ Zpd8S )¥Ú ESPLoaderaO Base class providing access to ESP ROM & software stub bootloaders.
Subclasses provide ESP8266 & ESP32 Family specific functionality.
Don't instantiate this base class directly, either instantiate a subclass or
call cmds.detect_chip() which will interrogate the chip and return the
appropriate subclass instance.
zEspressif deviceFz /dev/ttyUSB0r r é é é r' r é r% é é
é é é é é é é éĞ éÑ éÒ éÓ éÔ i é i  éé éï é ix `i @iÿÿ i @i 0@r i zESP32-S3(beta 3)c C s¬ d| _ d| _dddddœ| _t|tƒr-zt |¡| _W n tjj y, t
d|› d�ƒ‚w || _t | j| j ƒ| _
| |¡ || _zt| j_W dS tyU d| j_Y dS w )a½ Base constructor for ESPLoader bootloader interaction
Don't call this constructor, either instantiate a specific
ROM class directly, or use cmds.detect_chip().
This base class has all of the instance methods for bootloader
functionality supported across various chips & stub
loaders. Subclasses replace the functions they don't support
with ones which throw NotImplementedInROMError().
FN)Úflash_idÚchip_idÚuart_noÚusb_pidzCould not open z, the port doesn't exist)Úsecure_download_modeÚstub_is_disabledÚcacheÚ
isinstanceÚstrÚserialÚserial_for_urlÚ_portÚ
serialutilÚSerialExceptionr
Ú slip_readerÚtraceÚ _slip_readerÚ_set_port_baudrateÚ_trace_enabledÚ DEFAULT_SERIAL_WRITE_TIMEOUTÚ
write_timeoutÚNotImplementedError)r` ÚportÚbaudÚ
trace_enabledr4 r4 r5 rd s,
ü
ÿ
ızESPLoader.__init__c C s | j jS rF )rŠ r• ©r` r4 r4 r5 Ú serial_portC s zESPLoader.serial_portc C s* z|| j _W d S ty td| ƒ‚w )NzAFailed to set baud rate %d. The driver may not support this rate.)rŠ ÚbaudrateÚIOErrorr
)r` r– r4 r4 r5 r� G s ÿÿÿz ESPLoader._set_port_baudratec C s
t | jƒS )z'Read a SLIP packet from the serial port)Únextr� r˜ r4 r4 r5 ÚreadP s
zESPLoader.readc C sB d| dd¡ dd¡ d }| dt|ƒt|ƒ¡ | j |¡ dS )z=Write bytes to the serial port while performing SLIP escapingó Àó Ûs Ûİs ÛÜzWrite %d bytes: %sN)r. r� ÚlenÚ HexFormatterrŠ Úwrite)r` ÚpacketÚbufr4 r4 r5 r¢ T s ÿşÿzESPLoader.writec G sZ | j r+t ¡ }z|| j }W n ty d}Y nw || _d| }t||| ƒ d S d S )Ng z TRACE +%.3f )r‘ ÚtimeÚ _last_traceÚAttributeErrorÚprint)r` ÚmessageÚ format_argsÚnowÚdeltaÚprefixr4 r4 r5 r� ^ s ÿøzESPLoader.tracec C s | D ]}||N }q|S )z9Calculate checksum of a blob, as it is defined by the ROMr4 )rX ÚstateÚbr4 r4 r5 Úchecksumi s
zESPLoader.checksumNó Tc C st | j j}t|tƒ}||kr|| j _zŸ|dur:| d|t|ƒ|r!dnd|t|ƒ¡ t dd|t|ƒ|¡| }| |¡ |sIW ||krG|| j _dS dS t
dƒD ]V} | ¡ }
t|
ƒdk rZqMt d|
dd… ¡\} } }
}| dkrmqM|
dd… }|du s{| |kr‹||f W ||krŠ|| j _S S t
|dƒdkr£t
|dƒ| jkr£| ¡ t| |ƒ‚qMW ||kr|| j _td ƒ‚||kr¹|| j _w )
z$Send a request and read the responseNzCcommand op=0x%02x data len=%s wait_response=%d timeout=%.3f data=%sr r s <BBHIéd r z<BBHIz Response doesn't match request)rŠ r ÚminÚ MAX_TIMEOUTr� r r¡ ÚstructÚpackr¢ Úranger� Úunpackr
ÚROM_INVALID_RECV_MSGÚ flush_inputr r
)r` ÚoprX ÚchkÚ
wait_responser Ú
saved_timeoutÚ new_timeoutÚpktÚretryÚpÚrespÚop_retÚlen_retÚvalr4 r4 r5 Úcommandq sX
ù
ÿ î
ÿ ù
€ñı
zESPLoader.commandc C sˆ | j ||||d�\}}t|ƒ| jk r td|t|ƒf ƒ‚|| j d… }t|dƒdkr3t d| |¡‚t|ƒ| jkrB|d| j … S |S )z¹
Execute a command with 'command', check the result code and throw an appropriate
FatalError if it fails.
Returns the "result" of a successful command.
©r z/Failed to %s. Only got %d byte status response.Nr z Failed to %s)rÇ r ÚSTATUS_BYTES_LENGTHr
r
Ú
WithResult)r` Úop_descriptionr» rX r¼ r rÆ Ú status_bytesr4 r4 r5 Ú
check_command« s
ÿÿzESPLoader.check_commandc C s | j ¡ t| j | jƒ| _d S rF )rŠ Ú
flushInputr� r� r� r˜ r4 r4 r5 rº Ì s
zESPLoader.flush_inputc C sP | j | jdtd�\}}|dk| _tdƒD ]}| ¡ \}}| j|dkM _qd S )Ns$ UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUrÈ r r' )rÇ ÚESP_SYNCÚ SYNC_TIMEOUTÚsync_stub_detectedr· )r` rÆ Ú_r4 r4 r5 ÚsyncĞ s
ÿ
şzESPLoader.syncc C sà | j d d ur | j d S td u rtdƒ d S | jj}| ¡ d¡s'tdƒ d S | d¡r8tj |¡r8tj
|¡}|g}t j dkrMd|v rM|
| dd¡¡ t ¡ }|D ]}|j|v re|j| j d< |j S qStd |› d
�ƒ d S ) Nr‚ zK
Listing all serial ports is currently not available. Can't get device PID.)Úcomú/dev/zK
Device PID identification is only supported on COM and /dev/ serial ports.rÕ r ÚttyÚcuz"
Failed to get PID of a device on z , using standard reset sequence.)r… Ú
list_portsr¨ rŠ r• ÚlowerÚ
startswithr/ r0 ÚislinkÚrealpathÚsysÚplatformÚappendr. ÚcomportsÚdeviceÚpid)r` Ú active_portÚ active_portsÚportsr r4 r4 r5 Ú_get_pidŞ s6
ÿÿ
ş
ÿzESPLoader._get_pidÚ
default_resetc C s d}d}d}|dkr |S |dkr@| j s| j ¡ |ƒ | j ¡ }| j |¡}t d|tj¡}|dur@d}| d¡} | d¡du}t d ƒD ]7}
z|
¡ | j ¡ | ¡ W dS t
y{ } ztd
d d � tj ¡ t d
¡ | }W Y d} ~ qDd} ~ ww |r�t
d | d¡¡ƒ}|r�t
dƒ}|S )zA single connection attemptNFÚno_reset_no_syncÚno_resets. boot:(0x[0-9a-fA-F]+)(.*waiting for download)?Tr r rj Ú.r, ©Úendçš™™™™™©?zEWrong boot mode detected ({})! The chip needs to be in download mode.úutf-8zdDownload mode successfully detected, but getting no sync reply: The serial TX path seems to be down.)Ú USES_RFC2217rŠ Úreset_input_bufferÚ inWaitingr� ÚreÚsearchÚDOTALLÚgroupr· rº Ú flushOutputrÓ r
r¨ rİ ÚstdoutÚflushr¥ ÚsleepÚformatÚdecode) r` Úreset_strategyÚmodeÚ
last_errorÚboot_log_detectedÚ
download_modeÚwaitingÚ
read_bytesrX Ú boot_moderÒ Úer4 r4 r5 Ú_connect_attempt sV
ÿ
€üÿşÿzESPLoader._connect_attemptc s0 z
‡ fdd„| j D ƒd W S ty Y dS w )zƒ
Returns a tuple of (start, end) for the memory map entry with the given name,
or None if it doesn't exist
c s" g | ]
\}}}|ˆ kr||f‘qS r4 r4 )Ú.0Ústartrì Ún©Únamer4 r5 Ú
<listcomp>A s " z/ESPLoader.get_memory_region.<locals>.<listcomp>r N)Ú
MEMORY_MAPÚ
IndexError)r` r
r4 r r5 Úget_memory_region; s
ÿzESPLoader.get_memory_regionc C sê t d¡}|durt| j|ƒfS t d¡}|dur | }}nt}td }| jr6tj dd¡ ¡ dkr6d }}|d ksA|
¡ | j krGt | jƒfS tj
d
kri| jj
d ¡sit| j|ƒt| j|ƒt| j|ƒt| j|ƒfS t| j|ƒt| j|ƒfS ) zã
Constructs a sequence of reset strategies based on the OS,
used ESP chip, external settings, and environment variables.
Returns a tuple of one or more reset strategies to be tried sequentially.
Úcustom_reset_sequenceNÚ reset_delayg à?ÚESPTOOL_ENV_FPGAr, Ú1r' Ú usb_resetÚntzrfc2217:)ÚcfgÚgetr rŠ Úgetfloatr ÚFPGA_SLOW_BOOTr/ ÚenvironÚstripræ ÚUSB_JTAG_SERIAL_PIDr r
rÚ r r )r` rı Úcfg_custom_reset_sequenceÚcfg_reset_delayÚdelayÚ extra_delayr4 r4 r5 Ú"_construct_reset_strategy_sequenceE s0
ÿş
ü
şz,ESPLoader._construct_reset_strategy_sequencec
C s¢ |r|dv rt d |¡dƒ t ddd� tj ¡ d}| |¡}z)t|dkr*t|ƒnt ¡ t
|¡ƒD ]\}}| ||¡}|du rC nq3W t dƒ nt dƒ w |dur\t d | j
|¡ƒ‚|sÏz=d
d lm} | tj¡}
|
| jvršd} | D ] } |
| jv r| } nqt|r�| du r�t d | j
|
f ƒ n
t d
| j
| j
f ƒ‚W n ty§ d| _Y nw z| ¡ W n tyÈ | jrÅ| ||d ¡ | ¡ n‚ Y nw | ¡ dS dS )z8Try connecting repeatedly until successful, or giving up)ré rè z1WARNING: Pre-connection option "{}" was selected.zJConnection may fail if the chip is not in bootloader or flasher stub mode.z
Connecting...r, rë Nr z‡Failed to connect to {}: {}
For troubleshooting steps visit: https://docs.espressif.com/projects/esptool/en/latest/troubleshooting.htmlr )ÚROM_LISTz~WARNING: This chip doesn't appear to be a %s (chip magic value 0x%08x). Probably it is unsupported by this version of esptool.z.This chip is %s not %s. Wrong --chip argument?T)r¨ rú rİ r÷ rø r Úzipr· Ú itertoolsÚcountÚcycler r
rO r) r! Úread_regrh ÚCHIP_DETECT_MAGIC_REG_ADDRÚCHIP_DETECT_MAGIC_VALUEr rƒ Ú
check_chip_idÚ
_post_connect)
r` rı ÚattemptsÚ detectingÚwarningsrş Úreset_sequencerÒ rü r! Úchip_magic_valueÚactuallyÚclsr4 r4 r5 Úconnecto s€ ş
ş ÿ€ÿı
ş ıÿ
ÿÿ€
ÿ
şü ÜzESPLoader.connectc C ó dS )zœ
Additional initialization hook, may be overridden by the chip-specific class.
Gets called after connect, and after auto-detection.
Nr4 r˜ r4 r4 r5 r* ¼ s zESPLoader._post_connectc C s@ | j | jt d|¡|d�\}}t|dƒdkr t d| |¡‚|S )z Read memory address in targetú<IrÈ r z$Failed to read register address %08x)rÇ Ú ESP_READ_REGrµ r¶ r
r
rÊ )r` Úaddrr rÆ rX r4 r4 r5 r& Ã s
ÿÿzESPLoader.read_regì ÿÿ c C sB t d||||¡}|dkr|t d| jdd|¡7 }| d| j|¡S )z!Write to memory address in targetú<IIIIr zwrite target memory)rµ r¶ ÚUART_DATE_REG_ADDRrÍ Ú
ESP_WRITE_REG)r` r6 ÚvalueÚmaskÚdelay_usÚdelay_after_usrÇ r4 r4 r5 Ú write_regÑ s ÿzESPLoader.write_regc C s< t |ƒ}| |¡}|| M }|||> |@ O }| ||¡ |S )zÌ
Update register at 'addr', replace the bits masked out by 'mask'
with new_val. new_val is shifted left to match the LSB of 'mask'
Returns just-written value of register.
)r r& r? )r` r6 r< Únew_valÚshiftrÆ r4 r4 r5 Ú
update_regÜ s
zESPLoader.update_regc
C s˜ | j r=tt| jƒƒ}|}|| }|j|jt|jƒ f|j|jt|jƒ ffD ]\}} || k r<||kr<t d|| ||f ƒ‚q&|
d| j t
d||||¡¡S )z-Start downloading an application image to RAMzÍSoftware loader is resident at 0x%08x-0x%08x. Can't load binary at overlapping address range 0x%08x-0x%08x. Either change binary loading address, or use the --no-stub option to disable the software loader.zenter RAM download moder8 )rG rT r6 rO rY r rX rV rU r
rÍ Ú
ESP_MEM_BEGINrµ r¶ )
r` ÚsizeÚblocksÚ blocksizeÚoffsetrc Ú
load_startÚload_endr rì r4 r4 r5 Ú mem_beginë s& ş
üÿ€ızESPLoader.mem_beginc C s. | d| jt dt|ƒ|dd¡| | |¡¡S )z Send a block of an image to RAMzwrite to target RAMr8 r )rÍ Ú ESP_MEM_DATArµ r¶ r r° )r` rX Úseqr4 r4 r5 Ú mem_block s üzESPLoader.mem_blockc C sX | j rtnt}t dt|dkƒ|¡}z | jd| j||d�W S ty+ | j r(‚ Y dS w )z+Leave download mode and run the applicationú<IIr zleave RAM download mode)rX r N) rG r8 ÚMEM_END_ROM_TIMEOUTrµ r¶ ÚintrÍ Ú ESP_MEM_ENDr
)r` Ú
entrypointr rX r4 r4 r5 Ú
mem_finish s
ÿ ızESPLoader.mem_finishc C s° || j d | j }| ||¡}t ¡ }| jrt}ntt|ƒ}t d||| j |¡}| j r;| js;|t d|r7dnd¡7 }| j
d| j ||d� |dkrV| jsVt dt ¡ | ƒ |S )zŒ
Start downloading to Flash (performs an erase)
Returns number of blocks (of size self.FLASH_WRITE_SIZE) to write.
r r8 r4 r zenter Flash download moderÈ ú Took %.2fs to erase flash block)
ÚFLASH_WRITE_SIZEÚget_erase_sizer¥ rG r8 r< ÚERASE_REGION_TIMEOUT_PER_MBrµ r¶ ÚSUPPORTS_ENCRYPTED_FLASHrÍ ÚESP_FLASH_BEGINr¨ ) r` rD rG Úbegin_rom_encryptedÚ
num_blocksÚ
erase_sizeÚtr Úparamsr4 r4 r5 Ú flash_begin s& ÿ ÿ
ÿzESPLoader.flash_beginc C ó„ t td ddƒD ]7}z | jd| | jt dt|ƒ|dd¡| | |¡|d� W d S ty? |r<| d|› d�¡ n‚ Y qw d S )
z#Write block to flash, retry if failr éÿÿÿÿz"write to target Flash after seq %dr8 r rÈ z"Block write failed, retrying with ú attempts leftN)
r· ÚWRITE_BLOCK_ATTEMPTSrÍ ÚESP_FLASH_DATArµ r¶ r r° r
r� ©r` rX rL r Ú
attempts_leftr4 r4 r5 Ú flash_block< s* û ÿÿûşözESPLoader.flash_blockc C s� | j r
| js
| |||¡S ttd ddƒD ]7}z | jd| | jt dt |ƒ|dd¡| |
|¡|d� W d S t yL |rI| d|› d�¡ n‚ Y qw d S )
z,Encrypt, write block to flash, retry if failr ra z,Write encrypted to target Flash after seq %dr8 r rÈ z,Encrypted block write failed, retrying with rb N)
rX rG rg r· rc rÍ ÚESP_FLASH_ENCRYPT_DATArµ r¶ r r° r
r� re r4 r4 r5 Úflash_encrypt_blockQ s. û ÿÿûşöz ESPLoader.flash_encrypt_blockc C s& t dt| ƒ¡}| d| j|¡ dS )z Leave flash mode and run/rebootr4 zleave Flash modeN)rµ r¶ rP rÍ Ú
ESP_FLASH_END©r` ÚrebootrÀ r4 r4 r5 Ú flash_finishk s zESPLoader.flash_finishc C s | dd¡ | |¡ dS )z Run application code in flashr N)r_ rm )r` rl r4 r4 r5 Úrunq s z
ESPLoader.runc C s0 | j d du rd}| |dd¡| j d< | j d S )z)Read SPI flash manufacturer and device idr NéŸ r± é )r… Úrun_spiflash_command)r` Ú
SPIFLASH_RDIDr4 r4 r5 r w s
zESPLoader.flash_idc C r3 )zFRead flash type bit field from eFuse. Returns 0, 1, None (not present)Nr4 r˜ r4 r4 r5 Ú
flash_type~ s zESPLoader.flash_typec C st | d| jd¡}t|ƒdkrdnd}t |rdnd|¡}|d |d |d
d … |r+d n|d |r4d d
œS |d d
œS )Núget security infor± é TFz
<IBBBBBBBBz <IBBBBBBBBIIr r r rl r% )ÚflagsÚflash_crypt_cntÚ key_purposesr€ Ú api_version)rÍ ÚESP_GET_SECURITY_INFOr rµ r¸ )r` ÚresÚesp32s2r4 r4 r5 Úget_security_info‚ s
ûûzESPLoader.get_security_infoc C sJ | j d d u r | d| jd¡}t d|d d… ¡}|d | j d< | j d S )Nr€ rt r± z <IBBBBBBBBIrq rl )r… rÍ rz rµ r¸ )r` r{ r4 r4 r5 Ú get_chip_id� s ÿ ÿ
zESPLoader.get_chip_idc C s. | j d du r| | j¡d@ | j d< | j d S )zb
Read the UARTDEV_BUF_NO register to get the number of the currently used console
r� Néÿ )r… r& ÚUARTDEV_BUF_NOr˜ r4 r4 r5 Ú get_uart_noš s
zESPLoader.get_uart_noc
C s8 z| j | W S ty td|d | j ¡ ¡f ƒ‚w )NzGFlash size '%s' is not supported by this chip type. Supported sizes: %sú, )Ú FLASH_SIZESr_ r
r1 Úkeys©r1 Úargr4 r4 r5 Úparse_flash_size_arg¢ s ÿÿÿz ESPLoader.parse_flash_size_argc
C sD |d u rdS z| j | W S ty! td|d | j ¡ ¡f ƒ‚w )Nr zRFlash frequency '%s' is not supported by this chip type. Supported frequencies: %sr‚ )ÚFLASH_FREQUENCYr_ r
r1 r„ r… r4 r4 r5 Úparse_flash_freq_arg¬ s şÿÿz ESPLoader.parse_flash_freq_argc
C s* |d u r t t| jƒƒ}| jrtdƒ | | ¡S tdƒ |j|jfD ]C}|d urd||jkr/|jn|j }t
|ƒ}|| j d | j }| ||| j |¡ t
|ƒD ]}|| j }|| j }| |||… |¡ qMq!tdƒ | |j¡ z| ¡ } W n ty€ tdƒ‚w | dkrŒtd| › �ƒ‚tdƒ | | ¡S ) Nz0Stub is already running. No upload is necessary.zUploading stub...r zRunning stub...zµFailed to start stub. There was no response.
Try increasing timeouts, for more information see: https://docs.espressif.com/projects/esptool/en/latest/esptool/configuration-file.htmls OHAIz+Failed to start stub. Unexpected response: zStub running...)rT r6 rO rÑ r¨ Ú
STUB_CLASSrU rX rV rY r Ú
ESP_RAM_BLOCKrJ r· rM rS rW r� Ú
StopIterationr
)
r` rc ÚfieldÚoffsÚlengthrE rL Ú from_offsÚto_offsr r4 r4 r5 Úrun_stubº s<
€ ÿÿ
zESPLoader.run_stubc
C sÎ || j d | j }|| j d | j }t ¡ }| jr |}t}n
|| j }tt|ƒ}td||f ƒ t d||| j |¡} | j rJ| jsJ| t dd¡7 } | j
d| j | |d� |dkre| jsetdt ¡ | ƒ |S ) z™
Start downloading compressed data to Flash (performs an erase)
Returns number of blocks (size self.FLASH_WRITE_SIZE) to write.
r z Compressed %d bytes to %d...r8 r4 r zenter compressed flash moderÈ rT ) rU r¥ rG r8 r< rW r¨ rµ r¶ rX rÍ ÚESP_FLASH_DEFL_BEGIN)
r` rD ÚcompsizerG r[ Ú erase_blocksr] Ú
write_sizer r^ r4 r4 r5 Úflash_defl_beginŞ s6 ÿÿÿ ÿ üzESPLoader.flash_defl_beginc C r` )
z4Write block to flash, send compressed, retry if failr ra z+write compressed data to flash after seq %dr8 r rÈ z-Compressed block write failed, retrying with rb N)
r· rc rÍ ÚESP_FLASH_DEFL_DATArµ r¶ r r° r
r� re r4 r4 r5 Úflash_defl_block s* û ÿÿûşözESPLoader.flash_defl_blockc C s: |s| j sdS t dt| ƒ¡}| d| j|¡ d| _dS )z*Leave compressed flash mode and run/rebootNr4 zleave compressed flash modeF)rG rµ r¶ rP rÍ ÚESP_FLASH_DEFL_ENDÚ
in_bootloaderrk r4 r4 r5 Úflash_defl_finish s
zESPLoader.flash_defl_finishc
C sf t t|ƒ}| jd| jt d||dd¡|d�}t|ƒdkr!| d¡S t|ƒdkr-t|ƒ ¡ S t
d| ƒ‚) Nzcalculate md5sumr8 r rÈ é rî rq z-MD5Sum command returned unexpected result: %r) r< ÚMD5_TIMEOUT_PER_MBrÍ ÚESP_SPI_FLASH_MD5rµ r¶ r rû r rÙ r
)r` r6 rD r r{ r4 r4 r5 Ú flash_md5sum) s
ü
zESPLoader.flash_md5sumc C s^ t d| ƒ | jr
| jjnd}| | jt d||¡¡ t dƒ | |¡ t
d¡ | ¡ d S )NzChanging baud rate to %dr rN zChanged.rí ) r¨ rG rŠ rš rÇ ÚESP_CHANGE_BAUDRATErµ r¶ r� r¥ rù rº )r` r– Ú
second_argr4 r4 r5 Ú change_baud< s
zESPLoader.change_baudc C s | j d| jtd� d S )Nz erase flashrÈ )rÍ ÚESP_ERASE_FLASHÚCHIP_ERASE_TIMEOUTr˜ r4 r4 r5 Ú erase_flashG s
ÿzESPLoader.erase_flashc C sX || j dkr tdƒ‚|| j dkrtdƒ‚tt|ƒ}| jd| jt d||¡|d� d S )Nr z/Offset to erase from must be a multiple of 4096z0Size of data to erase must be a multiple of 4096z erase regionrN rÈ )ÚFLASH_SECTOR_SIZEr
r< rW rÍ ÚESP_ERASE_REGIONrµ r¶ )r` rG rD r r4 r4 r5 Ú erase_regionN s
üzESPLoader.erase_regionc C s t | | jƒ‚rF )r Úread_flash_slow)r` rG r� Ú progress_fnr4 r4 r5 rª \ s zESPLoader.read_flash_slowc C sX | j s
| |||¡S | d| jt d||| jd¡¡ d}t|ƒ|k rj| ¡ }||7 }t|ƒ|k rBt|ƒ| jk rBt d| jt|ƒf ƒ‚|
t dt|ƒ¡¡ |rdt|ƒd dks]t|ƒ|krd|t|ƒ|ƒ t|ƒ|k s"|rs|t|ƒ|ƒ t|ƒ|kr}t d ƒ‚| ¡ }t|ƒd
kr�t d t |ƒ ƒ‚t |ƒ ¡ }t
|¡ ¡ ¡ }||krªt d ||f ƒ‚|S )
Nz
read flashr8 é@ r± z9Corrupt data, expected 0x%x bytes but received 0x%x bytesr4 r{ r zRead more than expectedrq zExpected digest, got: %sz$Digest mismatch: expected %s, got %s)rG rª rÍ ÚESP_READ_FLASHrµ r¶ r§ r r� r
r¢ r ÚupperÚhashlibÚmd5Ú hexdigest) r` rG r� r« rX rÂ Ú digest_frameÚexpected_digestÚdigestr4 r4 r5 Ú
read_flash_ sF ı ÿÿ ö
ÿzESPLoader.read_flashc C s@ t d|¡}| jsd}|t d|ddd¡7 }| d| j|¡ dS )z¢Send SPI attach command to enable the SPI flash pins
ESP8266 ROM does this when you send flash_begin, ESP32 ROM
has it as a SPI command.
r4 r ÚBBBBzconfigure SPI flash pinsN)rµ r¶ rG rÍ ÚESP_SPI_ATTACH)r` Úhspi_argr† Ú is_legacyr4 r4 r5 Úflash_spi_attach† s
zESPLoader.flash_spi_attachc
C s> d}|}d}d}d}d}| d| jt d||||||¡¡ dS ) a> Tell the ESP bootloader the parameters of the chip
Corresponds to the "flashchip" data structure that the ROM
has in RAM.
'size' is in bytes.
All other flash parameters are currently hardcoded (on ESP8266
these are mostly ignored by ROM code, on ESP32 I'm not sure.)
r i r~ é iÿÿ zset SPI paramsz<IIIIIIN)rÍ ÚESP_SPI_SET_PARAMSrµ r¶ )r` rD Úfl_idÚ
total_sizeÚ
block_sizeÚ sector_sizeÚ page_sizeÚ status_maskr4 r4 r5 Úflash_set_parameters– s& ùız ESPLoader.flash_set_parametersc s d}d}d} d}
d} ˆj ‰ˆd ‰ ˆd } ˆˆj }
ˆˆj ‰ˆˆj }ˆˆj }ˆjdur:‡‡‡‡‡‡fd d
„}n
‡‡‡‡‡fd d
„}d ‰d
}d‰|dkrRtdƒ‚t|ƒdkr\tdƒ‚t|ƒd }ˆ |
¡}ˆ |¡}|}|dkrv||
O }|dkr~|| O }ˆdkr†||O }ˆdkr�|| O }|||ƒ ˆ |
|¡ ˆ |d|> |B ¡ |r¯ˆdkr¯ˆ | |¡ |dkrºˆ |d¡ n#t
|ddƒ}t dt|ƒd |¡}|}|D ] }ˆ ||¡ |d7 }qЈ ˆ ˆ¡ ‡ ‡‡fdd„}|ƒ ˆ |¡}ˆ |
|¡ ˆ ||¡ |S )a¬ Run an arbitrary SPI flash command.
This function uses the "USR_COMMAND" functionality in the ESP
SPI hardware, rather than the precanned commands supported by
hardware. So the value of spiflash_command is an actual command
byte, sent over the wire.
After writing command byte, writes 'data' to MOSI and then
reads back 'read_bits' of reply on MISO. Result is a number.
l i @i i i r ri Nc sŒ ˆˆj }ˆˆj }| dkrˆ || d ¡ |dkr"ˆ ||d ¡ d}ˆdkr.|ˆd O }ˆdkr:|ˆd ˆ> O }|rDˆ ˆ |¡ d S d S )Nr r )ÚSPI_MOSI_DLEN_OFFSÚSPI_MISO_DLEN_OFFSr? )Ú mosi_bitsÚ miso_bitsÚSPI_MOSI_DLEN_REGÚSPI_MISO_DLEN_REGrv )Ú SPI_USR1_REGÚSPI_USR_ADDR_LEN_SHIFTÚaddr_lenÚbaseÚ dummy_lenr` r4 r5 Úset_data_lengthsİ s
ÿz8ESPLoader.run_spiflash_command.<locals>.set_data_lengthsc s€ ˆ }d}d}| dkr dn| d }|dkrdn|d }||> ||> B }ˆdkr,|ˆd O }ˆdkr8|ˆd ˆ> O }ˆ ||¡ d S )Nrr r r r )r? )rÆ rÇ ÚSPI_DATA_LEN_REGÚSPI_MOSI_BITLEN_SÚSPI_MISO_BITLEN_SÚ mosi_maskÚ miso_maskrv )rÊ rË rÌ rÎ r` r4 r5 rÏ î s ÿ i é é r� zHReading more than 32 bits back from a SPI flash operation is unsupportedr¬ zFWriting more than 64 bytes of data with one SPI command is unsupportedr r' ó ÚIc s. t dƒD ]} ˆ ˆ ¡ˆ@ dkr d S qtdƒ‚)Nr% r z$SPI command did not complete in time)r· r& r
)rÒ )Ú SPI_CMD_REGÚ SPI_CMD_USRr` r4 r5 Ú wait_done- s
ÿz1ESPLoader.run_spiflash_command.<locals>.wait_done)
Ú SPI_REG_BASEÚ SPI_USR_OFFSÚ
SPI_USR1_OFFSÚ
SPI_USR2_OFFSÚ SPI_W0_OFFSrÄ r
r r& r? r rµ r¸ )r` Úspiflash_commandrX Ú read_bitsr6 rÌ rÎ ÚSPI_USR_COMMANDÚ SPI_USR_ADDRÚ
SPI_USR_DUMMYÚ SPI_USR_MISOÚ SPI_USR_MOSIÚ SPI_ADDR_REGÚ SPI_USR_REGÚ SPI_USR2_REGÚ
SPI_W0_REGrÏ ÚSPI_USR2_COMMAND_LEN_SHIFTÚ data_bitsÚ old_spi_usrÚ old_spi_usr2rv ÚwordsÚnext_regÚwordrÛ Ústatusr4 )rÙ rÚ rÊ rË rÌ rÍ rÎ r` r5 rq µ sx
ÿ ÿ
ÿ
z ESPLoader.run_spiflash_commandc C s d}| j |||ddd�S )NéZ rp r )râ r6 rÌ rÎ ©rq )r` r6 râ Ú
CMD_RDSFDPr4 r4 r5 Úread_spiflash_sfdp; s
ÿz ESPLoader.read_spiflash_sfdpc C sN d}d}d}d}d}|||gd|… D ]}|| j |dd�|> 7 }|d7 }q|S )zÙRead up to 24 bits (num_bytes) of SPI flash status register contents
via RDSR, RDSR2, RDSR3 commands
Not all SPI flash supports all three commands. The upper 1 or 2
bytes may be 0xFF.
rj é5 é r r )râ rõ )r` Ú num_bytesÚ
SPIFLASH_RDSRÚSPIFLASH_RDSR2ÚSPIFLASH_RDSR3ró rA Úcmdr4 r4 r5 Ú read_statusA s
zESPLoader.read_statusc C sš d}d}d}d}d}d} |r|n|}
|dkr%| |
¡ | |t d|¡¡ |||gd |… D ]} | |
¡ | | t d
|d @ ¡¡ |d L }q.| | ¡ d
S )aì Write up to 24 bits (num_bytes) of new status register
num_bytes can be 1, 2 or 3.
Not all flash supports the additional commands to write the
second and third byte of the status register. When writing 2
bytes, esptool also sends a 16-byte WRSR command (as some
flash types use this instead of WRSR2.)
If the set_non_volatile flag is set, non-volatile bits will
be set as well as volatile ones (WREN used instead of WEVSR).
r é1 rr éP rk ri r z<Hr ÚBr r N)rq rµ r¶ ) r` Ú
new_statusrú Úset_non_volatileÚ
SPIFLASH_WRSRÚSPIFLASH_WRSR2ÚSPIFLASH_WRSR3ÚSPIFLASH_WEVSRÚ
SPIFLASH_WRENÚ
SPIFLASH_WRDIÚ
enable_cmdrş r4 r4 r5 Ú write_statusS s
zESPLoader.write_statusc C s\ | | j¡| j@ }| jj| d | j }|dkrdnd}t|| ƒdkr,td||f ƒ |S )z¦
Figure out the crystal frequency from the UART clock divider
Returns a normalized value in integer MHz (only values 40 or 26 are supported)
r7 é! r" rÖ r zoWARNING: Detected crystal freq %.2fMHz is quite different to normalized freq %dMHz. Unsupported crystal in use?)r& ÚUART_CLKDIV_REGÚUART_CLKDIV_MASKrŠ rš ÚXTAL_CLK_DIVIDERÚabsr¨ )r` Úuart_divÚest_xtalÚ norm_xtalr4 r4 r5 Úget_crystal_freqy s şÿzESPLoader.get_crystal_freqc C s t dƒ t| jƒƒ d S )Nz Hard resetting via RTS pin...)r¨ r rŠ r˜ r4 r4 r5 Ú
hard_reset’ s zESPLoader.hard_resetc C sl | j s|rd S | dd¡ | d¡ d S |r#| dd¡ | d¡ d S | jdkr,tdƒ‚| j| jdd� d S )Nr FTrN z5Soft resetting is currently only supported on ESP8266)r½ )rG r_ rm rO r
rÇ ÚESP_RUN_USER_CODE)r` Ústay_in_bootloaderr4 r4 r5 Ú
soft_reset– s
ÿzESPLoader.soft_resetc C sX z!| ¡ }|| jkr td || j |d¡| j¡ƒ d| _W d S W d S ty+ Y d S w )Nz[WARNING: Chip ID {} ({}) doesn't match expected Chip ID {}. esptool may not work correctly.ÚUnknownT)r~ Ú
IMAGE_CHIP_IDr¨ rú ÚUNSUPPORTED_CHIPSr r„ r )r` r€ r4 r4 r5 r) s
ış ö ÿzESPLoader.check_chip_id)rç )r7 r r )r )FrF )r± r Nr r )r )r F)qre rf rg Ú__doc__rO rG r Ú DEFAULT_PORTrï rY rd rj rC rQ rK rÏ r: r5 r¼ r· ÚESP_READ_FLASH_SLOWr¡ r“ r˜ rš rŸ rz r¤ r¨ r r rh r¹ r‹ rU Ú ESP_ROM_BAUDÚESP_IMAGE_MAGICÚESP_CHECKSUM_MAGICr§ r9 r' r ÚIROM_MAP_STARTÚ IROM_MAP_ENDrÉ ÚBOOTLOADER_FLASH_OFFSETrX rÑ r r rd Úpropertyr™ r� r� r¢ r� Ú staticmethodr° r8 rÇ rÍ rº rÓ ræ r r r ÚDEFAULT_CONNECT_ATTEMPTSr2 r* r& r? rB rJ rM rS r_ rg ri rm rn r rs r} rS r~ r� Ú classmethodr‡ r‰ r’ rP r— r™ rœ r r£ rM r¦ r© rª rµ rº rà rq r÷ rÿ r r r r r) r4 r4 r4 r5 rh ® s /
ú;
ÿ!
&7
,
ûM
$
)
'"
ù
& rh c c s¦ � dd„ }d}d}d} | ¡ }| |dkrdn|¡}|dkr9|du r*|r'd nd
}nd t|ƒ¡}||ƒ t|ƒ‚|d t|ƒt|ƒƒ |D ]Œ} t| gƒ} |du rz| d
krWd}qE|dt|ƒƒ | | ¡ ¡}
|dt|
ƒƒ |||
ƒ tdt| ƒ ƒ‚|r³d}| dkr‡|d
7 }qE| dkr�|d7 }qE|dt|ƒƒ | | ¡ ¡}
|dt|
ƒƒ |||
ƒ tdt| ƒ ƒ‚| dkrºd}qE| d
krÍ|dt|ƒƒ |V d}d}qE|| 7 }qEq )zğGenerator to read SLIP packets from a serial port.
Yields one full SLIP packet at a time, raises exception on timeout or invalid data.
Designed to avoid too many calls to serial.read(1), which can bog
down on slow systems.
c S s~ d}d}t d d|d|dg¡| t j¡}|dur=dd „ | d
¡| d ¡fD ƒ}t|ƒr2d |d
› �nd}d|› �}t|ƒ‚dS )a
Checks the input bytes for panic handler messages.
Raises a FatalError if Guru Meditation or Fatal Exception is found, as both
of these are used between different ROM versions.
Tries to also parse the error cause (e.g. IllegalInstruction).
s> G?uru Meditation Error: (?:Core \d panic'ed \(([a-zA-Z ]*)\))?s1 F?atal exception \(\d+\): (?:([a-zA-Z ]*)?.*epc)?r± s (?:ó |ó )Nc S s$ g | ]}|d urd | d¡¡‘qS )Nz({})rî )rú rû )r Úir4 r4 r5 r Û s ıÿz=slip_reader.<locals>.detect_panic_handler.<locals>.<listcomp>r r ú r r, z Guru Meditation Error detected)rò ró r1 rô rõ r r
)ÚinputÚguru_meditationÚfatal_exceptionrX ÚcauseÚmsgr4 r4 r5 Údetect_panic_handlerÇ s ÿış
øz)slip_reader.<locals>.detect_panic_handlerNFTr r r± z@Serial data stream stopped: Possible serial noise or corruption.zNo serial data received.z3Packet content transfer stopped (received {} bytes)zRead %d bytes: %sr� zRead invalid data: %sz#Remaining data in serial buffer: %szCInvalid head of packet (0x%s): Possible serial noise or corruption.ó Üó İrŸ z Invalid SLIP escape (0xdb, 0x%s)zReceived full packet: %s)rñ r� rú r r
r¡ Úbytesr ) r• Útrace_functionr3 Úpartial_packetÚ in_escapeÚsuccessful_slipr r r2 r¯ Úremaining_datar4 r4 r5 r� ¿ sx € ÿıÿ
ş ÿÿ
ş
Çr� c @ s" e Zd ZdZddd„Zdd„ ZdS ) r¡ aJ
Wrapper class which takes binary data in its constructor
and returns a hex string as it's __str__ method.
This is intended for "lazy formatting" of trace() output
in hex format. Avoids overhead (significant on slow computers)
of generating long hex strings even if tracing is disabled.
Note that this doesn't save any overhead if passed as an
argument to "%", only when passed to trace()
If auto_split is set (default), any long line (> 16 bytes) will be
printed as separately indented lines, with ASCII decoding at the end
of each line.
Tc C s || _ || _d S rF )Ú_sÚ _auto_split)r` Ú
binary_stringÚ
auto_splitr4 r4 r5 rd 4 s
zHexFormatter.__init__c C s¨ | j rNt| jƒdkrNd}| j}t|ƒdkrL|d d… }d dd„ | dd¡D ƒ¡}|dd … }|dt|d d … d
ƒt|d d … d
ƒ|f 7 }t|ƒdks|S t| jd
ƒS ) Nrq r, r c s s4 � | ]}|d ks|t jv r|t jvr|ndV qdS )r- rê N)ÚstringÚ printableÚ
whitespace)r Úcr4 r4 r5 Ú <genexpr>> s € üşıı
úz'HexFormatter.__str__.<locals>.<genexpr>Úasciir. z
%-16s %-16s | %sr F)r= r r< r1 rû r )r` r; ÚsÚlineÚ
ascii_liner4 r4 r5 Ú__str__8 s"
ù ı ô zHexFormatter.__str__N)T)re rf rg r rd rI r4 r4 r4 r5 r¡ # s
r¡ )Gr] r¯ r# r[ r/ rò r@ rµ rİ r¥ Úconfigr Úresetr r r r r r Úutilr
r r r
r r r r rˆ Ú ImportErrorr¨ Ú
executabler Ú TypeErrorÚserial.tools.list_portsÚtoolsrØ ÚVERSIONÚ ExceptionrŞ r rÒ r r8 r¥ r´ rĞ r� rW ÚERASE_WRITE_TIMEOUT_PER_MBrO r’ Úgetintr( rc r0 r1 ÚdirnameÚ__file__r2 r6 r< rD rM rP rS rT Úobjectrh r� r¡ r4 r4 r4 r5 Ú<module> s¤ ÿÿû ÿ€ ÿ
şÿ
şü
d | 40,782 | Python | .py | 379 | 104.728232 | 978 | 0.510106 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,613 | reset.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/__pycache__/reset.cpython-310.pyc | o
’jÂdo ã @ sÖ d dl Z d dlZd dlZddlmZ e jdkr7d dlZd dlZeeddƒZ eeddƒZ
eed d
ƒZ eed d ƒZ d
Z
G dd„ deƒZG dd„ deƒZG dd„ deƒZG dd„ deƒZG dd„ deƒZG dd„ deƒZdS )é Né )Ú
FatalErrorÚntÚTIOCMSETiT ÚTIOCMGETiT Ú TIOCM_DTRé Ú TIOCM_RTSé gš™™™™™©?c @ s: e Zd Zefdd„Zdd„ Zdd„ Zdd„ Zd
d
d „Zd S )Ú
ResetStrategyc C s || _ || _d S ©N)ÚportÚ reset_delay)Úselfr
r © r ú-/home/ceco/Downloads/esptool/esptool/reset.pyÚ__init__ s
zResetStrategy.__init__c C s d S r r r r r r Ú__call__! s zResetStrategy.__call__c C s | j |¡ d S r )r
ÚsetDTR©r Ústater r r Ú_setDTR$ s zResetStrategy._setDTRc C s | j |¡ | j | j j¡ d S r )r
ÚsetRTSr Údtrr r r r Ú_setRTS' s zResetStrategy._setRTSFc C sx t dt | j ¡ tt dd¡¡¡d }|r|tO }n|t M }|r'|t O }n|t M }t | j ¡ t
t d|¡¡ d S )NÚIr ) ÚstructÚunpackÚfcntlÚioctlr
Úfilenor Úpackr r r )r r ÚrtsÚstatusr r r Ú
_setDTRandRTS. s ÿş
zResetStrategy._setDTRandRTSN)FF) Ú__name__Ú
__module__Ú __qualname__ÚDEFAULT_RESET_DELAYr r r r r$ r r r r r s r c @ ó e Zd ZdZdd„ ZdS )Ú ClassicResetzF
Classic reset sequence, sets DTR and RTS lines sequentially.
c C sL | d¡ | d¡ t d¡ | d¡ | d¡ t | j¡ | d¡ d S ©NFTçš™™™™™¹?)r r ÚtimeÚsleepr ©r r r r r B s
zClassicReset.__call__N©r% r& r' Ú__doc__r r r r r r* = s r* c @ r) )ÚUnixTightResetz{
UNIX-only reset sequence with custom implementation,
which allows setting DTR and RTS lines at the same time.
c C s` | dd¡ | dd¡ | dd¡ t d¡ | dd¡ t | j¡ | dd¡ | d¡ d S r+ )r$ r- r. r r r/ r r r r R s
zUnixTightReset.__call__Nr0 r r r r r2 L ó r2 c @ r) )ÚUSBJTAGSerialResetzx
Custom reset sequence, which is required when the device
is connecting via its USB-JTAG-Serial peripheral.
c C s| | d¡ | d¡ t d¡ | d¡ | d¡ t d¡ | d¡ | d¡ | d¡ t d¡ | d¡ | d¡ d S )NFr, T)r r r- r. r/ r r r r c s
zUSBJTAGSerialReset.__call__Nr0 r r r r r4 ] r3 r4 c s* e Zd ZdZd‡ fdd„ Zdd„ Z‡ ZS )Ú HardResetz�
Reset sequence for hard resetting the chip.
Can be used to reset out of the bootloader or to restart a running app.
Fc s t ƒ |¡ || _d S r )Úsuperr Ú uses_usb_otg)r r
r7 ©Ú __class__r r r x s
zHardReset.__init__c C sJ | d¡ | jrt d¡ | d¡ t d¡ d S t d¡ | d¡ d S )NTgš™™™™™É?Fr, )r r7 r- r. r/ r r r r | s
zHardReset.__call__)F)r% r& r' r1 r r Ú
__classcell__r r r8 r r5 r s r5 c s> e Zd ZdZdddddœZdd„ Z‡ fd d
„Zd d „ Z‡ ZS )
Ú CustomReseta¥
Custom reset strategy defined with a string.
CustomReset object is created as "rst = CustomReset(port, seq_str)"
and can be later executed simply with "rst()"
The seq_str input string consists of individual commands divided by "|".
Commands (e.g. R0) are defined by a code (R) and an argument (0).
The commands are:
D: setDTR - 1=True / 0=False
R: setRTS - 1=True / 0=False
U: setDTRandRTS (Unix-only) - 0,0 / 0,1 / 1,0 / or 1,1
W: Wait (time delay) - positive float number
e.g.
"D0|R1|W0.1|D1|R0|W0.05|D0" represents the ClassicReset strategy
"U1,1|U0,1|W0.1|U1,0|W0.05|U0,0" represents the UnixTightReset strategy
zself.port.setDTR({})zself.port.setRTS({})ztime.sleep({})zself._setDTRandRTS({}))ÚDÚRÚWÚUc C s t | jƒ d S r )ÚexecÚconstructed_strategyr/ r r r r ¥ s zCustomReset.__call__c s t ƒ |¡ | |¡| _d S r )r6 r Ú_parse_string_to_seqrA )r r
Úseq_strr8 r r r ¨ s zCustomReset.__init__c
sR z| d¡}‡ fdd„|D ƒ}W n ty# } ztd|› �ƒ‚d }~ww d |¡S )Nú|c s( g | ]}ˆ j |d |dd… ¡‘qS )r r N)Ú format_dictÚformat)Ú.0Úcmdr/ r r Ú
<listcomp>¯ s ( z4CustomReset._parse_string_to_seq.<locals>.<listcomp>z/Invalid "custom_reset_sequence" option format: Ú
)ÚsplitÚ Exceptionr Újoin)r rC ÚcmdsÚ
fn_calls_listÚer r/ r rB ¬ s
€ÿ
z CustomReset._parse_string_to_seq) r% r& r' r1 rE r r rB r: r r r8 r r; ‰ s ü r; )Úosr r- Úutilr Únamer ÚtermiosÚgetattrr r r r r( Úobjectr r* r2 r4 r5 r; r r r r Ú<module> s$
! | 5,658 | Python | .py | 67 | 81.880597 | 561 | 0.427881 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,614 | esp32c6.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/esp32c6.py | # SPDX-FileCopyrightText: 2022 Fredrik Ahlberg, Angus Gratton,
# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
import struct
from .esp32c3 import ESP32C3ROM
from ..util import FatalError, NotImplementedInROMError
class ESP32C6ROM(ESP32C3ROM):
CHIP_NAME = "ESP32-C6"
IMAGE_CHIP_ID = 13
FPGA_SLOW_BOOT = False
IROM_MAP_START = 0x42000000
IROM_MAP_END = 0x42800000
DROM_MAP_START = 0x42800000
DROM_MAP_END = 0x43000000
BOOTLOADER_FLASH_OFFSET = 0x0
# Magic value for ESP32C6
CHIP_DETECT_MAGIC_VALUE = [0x2CE0806F]
SPI_REG_BASE = 0x60003000
SPI_USR_OFFS = 0x18
SPI_USR1_OFFS = 0x1C
SPI_USR2_OFFS = 0x20
SPI_MOSI_DLEN_OFFS = 0x24
SPI_MISO_DLEN_OFFS = 0x28
SPI_W0_OFFS = 0x58
UART_DATE_REG_ADDR = 0x60000000 + 0x7C
EFUSE_BASE = 0x600B0800
EFUSE_BLOCK1_ADDR = EFUSE_BASE + 0x044
MAC_EFUSE_REG = EFUSE_BASE + 0x044
EFUSE_RD_REG_BASE = EFUSE_BASE + 0x030 # BLOCK0 read base address
EFUSE_PURPOSE_KEY0_REG = EFUSE_BASE + 0x34
EFUSE_PURPOSE_KEY0_SHIFT = 24
EFUSE_PURPOSE_KEY1_REG = EFUSE_BASE + 0x34
EFUSE_PURPOSE_KEY1_SHIFT = 28
EFUSE_PURPOSE_KEY2_REG = EFUSE_BASE + 0x38
EFUSE_PURPOSE_KEY2_SHIFT = 0
EFUSE_PURPOSE_KEY3_REG = EFUSE_BASE + 0x38
EFUSE_PURPOSE_KEY3_SHIFT = 4
EFUSE_PURPOSE_KEY4_REG = EFUSE_BASE + 0x38
EFUSE_PURPOSE_KEY4_SHIFT = 8
EFUSE_PURPOSE_KEY5_REG = EFUSE_BASE + 0x38
EFUSE_PURPOSE_KEY5_SHIFT = 12
EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT_REG = EFUSE_RD_REG_BASE
EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT = 1 << 20
EFUSE_SPI_BOOT_CRYPT_CNT_REG = EFUSE_BASE + 0x034
EFUSE_SPI_BOOT_CRYPT_CNT_MASK = 0x7 << 18
EFUSE_SECURE_BOOT_EN_REG = EFUSE_BASE + 0x038
EFUSE_SECURE_BOOT_EN_MASK = 1 << 20
PURPOSE_VAL_XTS_AES128_KEY = 4
SUPPORTS_ENCRYPTED_FLASH = True
FLASH_ENCRYPTED_WRITE_ALIGN = 16
UARTDEV_BUF_NO = 0x4087F580 # Variable in ROM .bss which indicates the port in use
UARTDEV_BUF_NO_USB_JTAG_SERIAL = 3 # The above var when USB-JTAG/Serial is used
DR_REG_LP_WDT_BASE = 0x600B1C00
RTC_CNTL_WDTCONFIG0_REG = DR_REG_LP_WDT_BASE + 0x0 # LP_WDT_RWDT_CONFIG0_REG
RTC_CNTL_WDTWPROTECT_REG = DR_REG_LP_WDT_BASE + 0x0018 # LP_WDT_RWDT_WPROTECT_REG
RTC_CNTL_SWD_CONF_REG = DR_REG_LP_WDT_BASE + 0x001C # LP_WDT_SWD_CONFIG_REG
RTC_CNTL_SWD_AUTO_FEED_EN = 1 << 18
RTC_CNTL_SWD_WPROTECT_REG = DR_REG_LP_WDT_BASE + 0x0020 # LP_WDT_SWD_WPROTECT_REG
RTC_CNTL_SWD_WKEY = 0x50D83AA1 # LP_WDT_SWD_WKEY, same as WDT key in this case
FLASH_FREQUENCY = {
"80m": 0x0, # workaround for wrong mspi HS div value in ROM
"40m": 0x0,
"20m": 0x2,
}
MEMORY_MAP = [
[0x00000000, 0x00010000, "PADDING"],
[0x42800000, 0x43000000, "DROM"],
[0x40800000, 0x40880000, "DRAM"],
[0x40800000, 0x40880000, "BYTE_ACCESSIBLE"],
[0x4004AC00, 0x40050000, "DROM_MASK"],
[0x40000000, 0x4004AC00, "IROM_MASK"],
[0x42000000, 0x42800000, "IROM"],
[0x40800000, 0x40880000, "IRAM"],
[0x50000000, 0x50004000, "RTC_IRAM"],
[0x50000000, 0x50004000, "RTC_DRAM"],
[0x600FE000, 0x60100000, "MEM_INTERNAL2"],
]
def get_pkg_version(self):
num_word = 3
return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 24) & 0x07
def get_minor_chip_version(self):
num_word = 3
return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 18) & 0x0F
def get_major_chip_version(self):
num_word = 3
return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 22) & 0x03
def get_chip_description(self):
chip_name = {
0: "ESP32-C6 (QFN40)",
1: "ESP32-C6FH4 (QFN32)",
}.get(self.get_pkg_version(), "unknown ESP32-C6")
major_rev = self.get_major_chip_version()
minor_rev = self.get_minor_chip_version()
return f"{chip_name} (revision v{major_rev}.{minor_rev})"
def get_chip_features(self):
return ["WiFi 6", "BT 5", "IEEE802.15.4"]
def get_crystal_freq(self):
# ESP32C6 XTAL is fixed to 40MHz
return 40
def override_vddsdio(self, new_voltage):
raise NotImplementedInROMError(
"VDD_SDIO overrides are not supported for ESP32-C6"
)
def read_mac(self, mac_type="BASE_MAC"):
"""Read MAC from EFUSE region"""
mac0 = self.read_reg(self.MAC_EFUSE_REG)
mac1 = self.read_reg(self.MAC_EFUSE_REG + 4) # only bottom 16 bits are MAC
base_mac = struct.pack(">II", mac1, mac0)[2:]
ext_mac = struct.pack(">H", (mac1 >> 16) & 0xFFFF)
eui64 = base_mac[0:3] + ext_mac + base_mac[3:6]
# BASE MAC: 60:55:f9:f7:2c:a2
# EUI64 MAC: 60:55:f9:ff:fe:f7:2c:a2
# EXT_MAC: ff:fe
macs = {
"BASE_MAC": tuple(base_mac),
"EUI64": tuple(eui64),
"MAC_EXT": tuple(ext_mac),
}
return macs.get(mac_type, None)
def get_flash_crypt_config(self):
return None # doesn't exist on ESP32-C6
def get_secure_boot_enabled(self):
return (
self.read_reg(self.EFUSE_SECURE_BOOT_EN_REG)
& self.EFUSE_SECURE_BOOT_EN_MASK
)
def get_key_block_purpose(self, key_block):
if key_block < 0 or key_block > 5:
raise FatalError("Valid key block numbers must be in range 0-5")
reg, shift = [
(self.EFUSE_PURPOSE_KEY0_REG, self.EFUSE_PURPOSE_KEY0_SHIFT),
(self.EFUSE_PURPOSE_KEY1_REG, self.EFUSE_PURPOSE_KEY1_SHIFT),
(self.EFUSE_PURPOSE_KEY2_REG, self.EFUSE_PURPOSE_KEY2_SHIFT),
(self.EFUSE_PURPOSE_KEY3_REG, self.EFUSE_PURPOSE_KEY3_SHIFT),
(self.EFUSE_PURPOSE_KEY4_REG, self.EFUSE_PURPOSE_KEY4_SHIFT),
(self.EFUSE_PURPOSE_KEY5_REG, self.EFUSE_PURPOSE_KEY5_SHIFT),
][key_block]
return (self.read_reg(reg) >> shift) & 0xF
def is_flash_encryption_key_valid(self):
# Need to see an AES-128 key
purposes = [self.get_key_block_purpose(b) for b in range(6)]
return any(p == self.PURPOSE_VAL_XTS_AES128_KEY for p in purposes)
class ESP32C6StubLoader(ESP32C6ROM):
"""Access class for ESP32C6 stub loader, runs on top of ROM.
(Basically the same as ESP32StubLoader, but different base class.
Can possibly be made into a mixin.)
"""
FLASH_WRITE_SIZE = 0x4000 # matches MAX_WRITE_BLOCK in stub_loader.c
STATUS_BYTES_LENGTH = 2 # same as ESP8266, different to ESP32 ROM
IS_STUB = True
def __init__(self, rom_loader):
self.secure_download_mode = rom_loader.secure_download_mode
self._port = rom_loader._port
self._trace_enabled = rom_loader._trace_enabled
self.cache = rom_loader.cache
self.flush_input() # resets _slip_reader
ESP32C6ROM.STUB_CLASS = ESP32C6StubLoader
| 6,992 | Python | .py | 158 | 37.018987 | 87 | 0.644278 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,615 | esp32h2beta1.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/esp32h2beta1.py | # SPDX-FileCopyrightText: 2014-2022 Fredrik Ahlberg, Angus Gratton,
# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
import struct
from .esp32c3 import ESP32C3ROM
from ..util import FatalError, NotImplementedInROMError
class ESP32H2BETA1ROM(ESP32C3ROM):
CHIP_NAME = "ESP32-H2(beta1)"
IMAGE_CHIP_ID = 10
IROM_MAP_START = 0x42000000
IROM_MAP_END = 0x42800000
DROM_MAP_START = 0x3C000000
DROM_MAP_END = 0x3C800000
SPI_REG_BASE = 0x60002000
SPI_USR_OFFS = 0x18
SPI_USR1_OFFS = 0x1C
SPI_USR2_OFFS = 0x20
SPI_MOSI_DLEN_OFFS = 0x24
SPI_MISO_DLEN_OFFS = 0x28
SPI_W0_OFFS = 0x58
BOOTLOADER_FLASH_OFFSET = 0x0
CHIP_DETECT_MAGIC_VALUE = [0xCA26CC22]
UART_DATE_REG_ADDR = 0x60000000 + 0x7C
EFUSE_BASE = 0x6001A000
EFUSE_BLOCK1_ADDR = EFUSE_BASE + 0x044
MAC_EFUSE_REG = EFUSE_BASE + 0x044
EFUSE_RD_REG_BASE = EFUSE_BASE + 0x030 # BLOCK0 read base address
EFUSE_PURPOSE_KEY0_REG = EFUSE_BASE + 0x34
EFUSE_PURPOSE_KEY0_SHIFT = 24
EFUSE_PURPOSE_KEY1_REG = EFUSE_BASE + 0x34
EFUSE_PURPOSE_KEY1_SHIFT = 28
EFUSE_PURPOSE_KEY2_REG = EFUSE_BASE + 0x38
EFUSE_PURPOSE_KEY2_SHIFT = 0
EFUSE_PURPOSE_KEY3_REG = EFUSE_BASE + 0x38
EFUSE_PURPOSE_KEY3_SHIFT = 4
EFUSE_PURPOSE_KEY4_REG = EFUSE_BASE + 0x38
EFUSE_PURPOSE_KEY4_SHIFT = 8
EFUSE_PURPOSE_KEY5_REG = EFUSE_BASE + 0x38
EFUSE_PURPOSE_KEY5_SHIFT = 12
EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT_REG = EFUSE_RD_REG_BASE
EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT = 1 << 20
EFUSE_SPI_BOOT_CRYPT_CNT_REG = EFUSE_BASE + 0x034
EFUSE_SPI_BOOT_CRYPT_CNT_MASK = 0x7 << 18
EFUSE_SECURE_BOOT_EN_REG = EFUSE_BASE + 0x038
EFUSE_SECURE_BOOT_EN_MASK = 1 << 20
PURPOSE_VAL_XTS_AES128_KEY = 4
SUPPORTS_ENCRYPTED_FLASH = True
FLASH_ENCRYPTED_WRITE_ALIGN = 16
MEMORY_MAP = []
FLASH_FREQUENCY = {
"48m": 0xF,
"24m": 0x0,
"16m": 0x1,
"12m": 0x2,
}
def get_pkg_version(self):
num_word = 4
return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 0) & 0x07
def get_minor_chip_version(self):
num_word = 3
return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 18) & 0x07
def get_major_chip_version(self):
num_word = 3
return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 21) & 0x03
def get_chip_description(self):
chip_name = {
0: "ESP32-H2",
}.get(self.get_pkg_version(), "unknown ESP32-H2")
major_rev = self.get_major_chip_version()
minor_rev = self.get_minor_chip_version()
return f"{chip_name} (revision v{major_rev}.{minor_rev})"
def get_chip_features(self):
return ["BLE", "IEEE802.15.4"]
def get_crystal_freq(self):
return 32
def override_vddsdio(self, new_voltage):
raise NotImplementedInROMError(
"VDD_SDIO overrides are not supported for ESP32-H2"
)
def read_mac(self, mac_type="BASE_MAC"):
"""Read MAC from EFUSE region"""
if mac_type != "BASE_MAC":
return None
mac0 = self.read_reg(self.MAC_EFUSE_REG)
mac1 = self.read_reg(self.MAC_EFUSE_REG + 4) # only bottom 16 bits are MAC
bitstring = struct.pack(">II", mac1, mac0)[2:]
return tuple(bitstring)
def get_flash_crypt_config(self):
return None # doesn't exist on ESP32-H2
def get_key_block_purpose(self, key_block):
if key_block < 0 or key_block > 5:
raise FatalError("Valid key block numbers must be in range 0-5")
reg, shift = [
(self.EFUSE_PURPOSE_KEY0_REG, self.EFUSE_PURPOSE_KEY0_SHIFT),
(self.EFUSE_PURPOSE_KEY1_REG, self.EFUSE_PURPOSE_KEY1_SHIFT),
(self.EFUSE_PURPOSE_KEY2_REG, self.EFUSE_PURPOSE_KEY2_SHIFT),
(self.EFUSE_PURPOSE_KEY3_REG, self.EFUSE_PURPOSE_KEY3_SHIFT),
(self.EFUSE_PURPOSE_KEY4_REG, self.EFUSE_PURPOSE_KEY4_SHIFT),
(self.EFUSE_PURPOSE_KEY5_REG, self.EFUSE_PURPOSE_KEY5_SHIFT),
][key_block]
return (self.read_reg(reg) >> shift) & 0xF
def is_flash_encryption_key_valid(self):
# Need to see an AES-128 key
purposes = [self.get_key_block_purpose(b) for b in range(6)]
return any(p == self.PURPOSE_VAL_XTS_AES128_KEY for p in purposes)
def _post_connect(self):
pass
class ESP32H2BETA1StubLoader(ESP32H2BETA1ROM):
"""Access class for ESP32H2BETA1 stub loader, runs on top of ROM.
(Basically the same as ESP32StubLoader, but different base class.
Can possibly be made into a mixin.)
"""
FLASH_WRITE_SIZE = 0x4000 # matches MAX_WRITE_BLOCK in stub_loader.c
STATUS_BYTES_LENGTH = 2 # same as ESP8266, different to ESP32 ROM
IS_STUB = True
def __init__(self, rom_loader):
self.secure_download_mode = rom_loader.secure_download_mode
self._port = rom_loader._port
self._trace_enabled = rom_loader._trace_enabled
self.cache = rom_loader.cache
self.flush_input() # resets _slip_reader
ESP32H2BETA1ROM.STUB_CLASS = ESP32H2BETA1StubLoader
| 5,228 | Python | .py | 123 | 35.577236 | 84 | 0.655806 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,616 | esp32h2beta2.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/esp32h2beta2.py | # SPDX-FileCopyrightText: 2014-2022 Fredrik Ahlberg, Angus Gratton,
# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
from .esp32h2beta1 import ESP32H2BETA1ROM
class ESP32H2BETA2ROM(ESP32H2BETA1ROM):
CHIP_NAME = "ESP32-H2(beta2)"
IMAGE_CHIP_ID = 14
CHIP_DETECT_MAGIC_VALUE = [0x6881B06F]
def get_chip_description(self):
chip_name = {
1: "ESP32-H2(beta2)",
}.get(self.get_pkg_version(), "unknown ESP32-H2")
major_rev = self.get_major_chip_version()
minor_rev = self.get_minor_chip_version()
return f"{chip_name} (revision v{major_rev}.{minor_rev})"
class ESP32H2BETA2StubLoader(ESP32H2BETA2ROM):
"""Access class for ESP32H2BETA2 stub loader, runs on top of ROM.
(Basically the same as ESP32StubLoader, but different base class.
Can possibly be made into a mixin.)
"""
FLASH_WRITE_SIZE = 0x4000 # matches MAX_WRITE_BLOCK in stub_loader.c
STATUS_BYTES_LENGTH = 2 # same as ESP8266, different to ESP32 ROM
IS_STUB = True
def __init__(self, rom_loader):
self.secure_download_mode = rom_loader.secure_download_mode
self._port = rom_loader._port
self._trace_enabled = rom_loader._trace_enabled
self.cache = rom_loader.cache
self.flush_input() # resets _slip_reader
ESP32H2BETA2ROM.STUB_CLASS = ESP32H2BETA2StubLoader
| 1,429 | Python | .py | 31 | 40.193548 | 73 | 0.699856 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,617 | esp32c3.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/esp32c3.py | # SPDX-FileCopyrightText: 2014-2022 Fredrik Ahlberg, Angus Gratton,
# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
import struct
from .esp32 import ESP32ROM
from ..loader import ESPLoader
from ..util import FatalError, NotImplementedInROMError
class ESP32C3ROM(ESP32ROM):
CHIP_NAME = "ESP32-C3"
IMAGE_CHIP_ID = 5
FPGA_SLOW_BOOT = False
IROM_MAP_START = 0x42000000
IROM_MAP_END = 0x42800000
DROM_MAP_START = 0x3C000000
DROM_MAP_END = 0x3C800000
SPI_REG_BASE = 0x60002000
SPI_USR_OFFS = 0x18
SPI_USR1_OFFS = 0x1C
SPI_USR2_OFFS = 0x20
SPI_MOSI_DLEN_OFFS = 0x24
SPI_MISO_DLEN_OFFS = 0x28
SPI_W0_OFFS = 0x58
BOOTLOADER_FLASH_OFFSET = 0x0
# Magic value for ESP32C3 eco 1+2 and ESP32C3 eco3 respectivly
CHIP_DETECT_MAGIC_VALUE = [0x6921506F, 0x1B31506F]
UART_DATE_REG_ADDR = 0x60000000 + 0x7C
UART_CLKDIV_REG = 0x60000014
EFUSE_BASE = 0x60008800
EFUSE_BLOCK1_ADDR = EFUSE_BASE + 0x044
MAC_EFUSE_REG = EFUSE_BASE + 0x044
EFUSE_RD_REG_BASE = EFUSE_BASE + 0x030 # BLOCK0 read base address
EFUSE_PURPOSE_KEY0_REG = EFUSE_BASE + 0x34
EFUSE_PURPOSE_KEY0_SHIFT = 24
EFUSE_PURPOSE_KEY1_REG = EFUSE_BASE + 0x34
EFUSE_PURPOSE_KEY1_SHIFT = 28
EFUSE_PURPOSE_KEY2_REG = EFUSE_BASE + 0x38
EFUSE_PURPOSE_KEY2_SHIFT = 0
EFUSE_PURPOSE_KEY3_REG = EFUSE_BASE + 0x38
EFUSE_PURPOSE_KEY3_SHIFT = 4
EFUSE_PURPOSE_KEY4_REG = EFUSE_BASE + 0x38
EFUSE_PURPOSE_KEY4_SHIFT = 8
EFUSE_PURPOSE_KEY5_REG = EFUSE_BASE + 0x38
EFUSE_PURPOSE_KEY5_SHIFT = 12
EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT_REG = EFUSE_RD_REG_BASE
EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT = 1 << 20
EFUSE_SPI_BOOT_CRYPT_CNT_REG = EFUSE_BASE + 0x034
EFUSE_SPI_BOOT_CRYPT_CNT_MASK = 0x7 << 18
EFUSE_SECURE_BOOT_EN_REG = EFUSE_BASE + 0x038
EFUSE_SECURE_BOOT_EN_MASK = 1 << 20
PURPOSE_VAL_XTS_AES128_KEY = 4
SUPPORTS_ENCRYPTED_FLASH = True
FLASH_ENCRYPTED_WRITE_ALIGN = 16
UARTDEV_BUF_NO = 0x3FCDF07C # Variable in ROM .bss which indicates the port in use
UARTDEV_BUF_NO_USB_JTAG_SERIAL = 3 # The above var when USB-JTAG/Serial is used
RTCCNTL_BASE_REG = 0x60008000
RTC_CNTL_SWD_CONF_REG = RTCCNTL_BASE_REG + 0x00AC
RTC_CNTL_SWD_AUTO_FEED_EN = 1 << 31
RTC_CNTL_SWD_WPROTECT_REG = RTCCNTL_BASE_REG + 0x00B0
RTC_CNTL_SWD_WKEY = 0x8F1D312A
RTC_CNTL_WDTCONFIG0_REG = RTCCNTL_BASE_REG + 0x0090
RTC_CNTL_WDTWPROTECT_REG = RTCCNTL_BASE_REG + 0x00A8
RTC_CNTL_WDT_WKEY = 0x50D83AA1
MEMORY_MAP = [
[0x00000000, 0x00010000, "PADDING"],
[0x3C000000, 0x3C800000, "DROM"],
[0x3FC80000, 0x3FCE0000, "DRAM"],
[0x3FC88000, 0x3FD00000, "BYTE_ACCESSIBLE"],
[0x3FF00000, 0x3FF20000, "DROM_MASK"],
[0x40000000, 0x40060000, "IROM_MASK"],
[0x42000000, 0x42800000, "IROM"],
[0x4037C000, 0x403E0000, "IRAM"],
[0x50000000, 0x50002000, "RTC_IRAM"],
[0x50000000, 0x50002000, "RTC_DRAM"],
[0x600FE000, 0x60100000, "MEM_INTERNAL2"],
]
def get_pkg_version(self):
num_word = 3
return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 21) & 0x07
def get_minor_chip_version(self):
hi_num_word = 5
hi = (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * hi_num_word)) >> 23) & 0x01
low_num_word = 3
low = (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * low_num_word)) >> 18) & 0x07
return (hi << 3) + low
def get_major_chip_version(self):
num_word = 5
return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 24) & 0x03
def get_flash_cap(self):
num_word = 3
return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 27) & 0x07
def get_flash_vendor(self):
num_word = 4
vendor_id = (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 0) & 0x07
return {1: "XMC", 2: "GD", 3: "FM", 4: "TT", 5: "ZBIT"}.get(vendor_id, "")
def get_chip_description(self):
chip_name = {
0: "ESP32-C3 (QFN32)",
1: "ESP8685 (QFN28)",
2: "ESP32-C3 AZ (QFN32)",
3: "ESP8686 (QFN24)",
}.get(self.get_pkg_version(), "unknown ESP32-C3")
major_rev = self.get_major_chip_version()
minor_rev = self.get_minor_chip_version()
return f"{chip_name} (revision v{major_rev}.{minor_rev})"
def get_chip_features(self):
features = ["WiFi", "BLE"]
flash = {
0: None,
1: "Embedded Flash 4MB",
2: "Embedded Flash 2MB",
3: "Embedded Flash 1MB",
4: "Embedded Flash 8MB",
}.get(self.get_flash_cap(), "Unknown Embedded Flash")
if flash is not None:
features += [flash + f" ({self.get_flash_vendor()})"]
return features
def get_crystal_freq(self):
# ESP32C3 XTAL is fixed to 40MHz
return 40
def override_vddsdio(self, new_voltage):
raise NotImplementedInROMError(
"VDD_SDIO overrides are not supported for ESP32-C3"
)
def read_mac(self, mac_type="BASE_MAC"):
"""Read MAC from EFUSE region"""
if mac_type != "BASE_MAC":
return None
mac0 = self.read_reg(self.MAC_EFUSE_REG)
mac1 = self.read_reg(self.MAC_EFUSE_REG + 4) # only bottom 16 bits are MAC
bitstring = struct.pack(">II", mac1, mac0)[2:]
return tuple(bitstring)
def get_flash_crypt_config(self):
return None # doesn't exist on ESP32-C3
def get_secure_boot_enabled(self):
return (
self.read_reg(self.EFUSE_SECURE_BOOT_EN_REG)
& self.EFUSE_SECURE_BOOT_EN_MASK
)
def get_key_block_purpose(self, key_block):
if key_block < 0 or key_block > 5:
raise FatalError("Valid key block numbers must be in range 0-5")
reg, shift = [
(self.EFUSE_PURPOSE_KEY0_REG, self.EFUSE_PURPOSE_KEY0_SHIFT),
(self.EFUSE_PURPOSE_KEY1_REG, self.EFUSE_PURPOSE_KEY1_SHIFT),
(self.EFUSE_PURPOSE_KEY2_REG, self.EFUSE_PURPOSE_KEY2_SHIFT),
(self.EFUSE_PURPOSE_KEY3_REG, self.EFUSE_PURPOSE_KEY3_SHIFT),
(self.EFUSE_PURPOSE_KEY4_REG, self.EFUSE_PURPOSE_KEY4_SHIFT),
(self.EFUSE_PURPOSE_KEY5_REG, self.EFUSE_PURPOSE_KEY5_SHIFT),
][key_block]
return (self.read_reg(reg) >> shift) & 0xF
def is_flash_encryption_key_valid(self):
# Need to see an AES-128 key
purposes = [self.get_key_block_purpose(b) for b in range(6)]
return any(p == self.PURPOSE_VAL_XTS_AES128_KEY for p in purposes)
def change_baud(self, baud):
ESPLoader.change_baud(self, baud)
def uses_usb_jtag_serial(self):
"""
Check the UARTDEV_BUF_NO register to see if USB-JTAG/Serial is being used
"""
if self.secure_download_mode:
return False # Can't detect USB-JTAG/Serial in secure download mode
return self.get_uart_no() == self.UARTDEV_BUF_NO_USB_JTAG_SERIAL
def disable_watchdogs(self):
# When USB-JTAG/Serial is used, the RTC WDT and SWD watchdog are not reset
# and can then reset the board during flashing. Disable or autofeed them.
if self.uses_usb_jtag_serial():
# Disable RTC WDT
self.write_reg(self.RTC_CNTL_WDTWPROTECT_REG, self.RTC_CNTL_WDT_WKEY)
self.write_reg(self.RTC_CNTL_WDTCONFIG0_REG, 0)
self.write_reg(self.RTC_CNTL_WDTWPROTECT_REG, 0)
# Automatically feed SWD
self.write_reg(self.RTC_CNTL_SWD_WPROTECT_REG, self.RTC_CNTL_SWD_WKEY)
self.write_reg(
self.RTC_CNTL_SWD_CONF_REG,
self.read_reg(self.RTC_CNTL_SWD_CONF_REG)
| self.RTC_CNTL_SWD_AUTO_FEED_EN,
)
self.write_reg(self.RTC_CNTL_SWD_WPROTECT_REG, 0)
def _post_connect(self):
if not self.sync_stub_detected: # Don't run if stub is reused
self.disable_watchdogs()
class ESP32C3StubLoader(ESP32C3ROM):
"""Access class for ESP32C3 stub loader, runs on top of ROM.
(Basically the same as ESP32StubLoader, but different base class.
Can possibly be made into a mixin.)
"""
FLASH_WRITE_SIZE = 0x4000 # matches MAX_WRITE_BLOCK in stub_loader.c
STATUS_BYTES_LENGTH = 2 # same as ESP8266, different to ESP32 ROM
IS_STUB = True
def __init__(self, rom_loader):
self.secure_download_mode = rom_loader.secure_download_mode
self._port = rom_loader._port
self._trace_enabled = rom_loader._trace_enabled
self.cache = rom_loader.cache
self.flush_input() # resets _slip_reader
ESP32C3ROM.STUB_CLASS = ESP32C3StubLoader
| 8,854 | Python | .py | 198 | 36.782828 | 88 | 0.635941 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,618 | esp32s3beta2.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/esp32s3beta2.py | # SPDX-FileCopyrightText: 2014-2022 Fredrik Ahlberg, Angus Gratton,
# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
from .esp32s3 import ESP32S3ROM
class ESP32S3BETA2ROM(ESP32S3ROM):
CHIP_NAME = "ESP32-S3(beta2)"
IMAGE_CHIP_ID = 4
CHIP_DETECT_MAGIC_VALUE = [0xEB004136]
EFUSE_BASE = 0x6001A000 # BLOCK0 read base address
class ESP32S3BETA2StubLoader(ESP32S3BETA2ROM):
"""Access class for ESP32S3 stub loader, runs on top of ROM.
(Basically the same as ESP32StubLoader, but different base class.
Can possibly be made into a mixin.)
"""
FLASH_WRITE_SIZE = 0x4000 # matches MAX_WRITE_BLOCK in stub_loader.c
STATUS_BYTES_LENGTH = 2 # same as ESP8266, different to ESP32 ROM
IS_STUB = True
def __init__(self, rom_loader):
self.secure_download_mode = rom_loader.secure_download_mode
self._port = rom_loader._port
self._trace_enabled = rom_loader._trace_enabled
self.cache = rom_loader.cache
self.flush_input() # resets _slip_reader
ESP32S3BETA2ROM.STUB_CLASS = ESP32S3BETA2StubLoader
| 1,148 | Python | .py | 25 | 40.92 | 73 | 0.726373 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,619 | __init__.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/__init__.py | from .esp32 import ESP32ROM
from .esp32c2 import ESP32C2ROM
from .esp32c3 import ESP32C3ROM
from .esp32c6 import ESP32C6ROM
from .esp32c6beta import ESP32C6BETAROM
from .esp32h2 import ESP32H2ROM
from .esp32h2beta1 import ESP32H2BETA1ROM
from .esp32h2beta2 import ESP32H2BETA2ROM
from .esp32s2 import ESP32S2ROM
from .esp32s3 import ESP32S3ROM
from .esp32s3beta2 import ESP32S3BETA2ROM
from .esp8266 import ESP8266ROM
CHIP_DEFS = {
"esp8266": ESP8266ROM,
"esp32": ESP32ROM,
"esp32s2": ESP32S2ROM,
"esp32s3beta2": ESP32S3BETA2ROM,
"esp32s3": ESP32S3ROM,
"esp32c3": ESP32C3ROM,
"esp32c6beta": ESP32C6BETAROM,
"esp32h2beta1": ESP32H2BETA1ROM,
"esp32h2beta2": ESP32H2BETA2ROM,
"esp32c2": ESP32C2ROM,
"esp32c6": ESP32C6ROM,
"esp32h2": ESP32H2ROM,
}
CHIP_LIST = list(CHIP_DEFS.keys())
ROM_LIST = list(CHIP_DEFS.values())
| 866 | Python | .py | 28 | 28.107143 | 41 | 0.782036 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,620 | esp32c6beta.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/esp32c6beta.py | # SPDX-FileCopyrightText: 2014-2022 Fredrik Ahlberg, Angus Gratton,
# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
from .esp32c3 import ESP32C3ROM
class ESP32C6BETAROM(ESP32C3ROM):
CHIP_NAME = "ESP32-C6(beta)"
IMAGE_CHIP_ID = 7
CHIP_DETECT_MAGIC_VALUE = [0x0DA1806F]
UART_DATE_REG_ADDR = 0x00000500
def get_chip_description(self):
chip_name = {
0: "ESP32-C6 (QFN40)",
1: "ESP32-C6FH4 (QFN32)",
}.get(self.get_pkg_version(), "unknown ESP32-C6")
major_rev = self.get_major_chip_version()
minor_rev = self.get_minor_chip_version()
return f"{chip_name} (revision v{major_rev}.{minor_rev})"
def _post_connect(self):
pass
| 786 | Python | .py | 20 | 33.15 | 67 | 0.662714 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,621 | esp8266.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/esp8266.py | # SPDX-FileCopyrightText: 2014-2022 Fredrik Ahlberg, Angus Gratton,
# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
from ..loader import ESPLoader
from ..util import FatalError, NotImplementedInROMError
class ESP8266ROM(ESPLoader):
"""Access class for ESP8266 ROM bootloader"""
CHIP_NAME = "ESP8266"
IS_STUB = False
CHIP_DETECT_MAGIC_VALUE = [0xFFF0C101]
# OTP ROM addresses
ESP_OTP_MAC0 = 0x3FF00050
ESP_OTP_MAC1 = 0x3FF00054
ESP_OTP_MAC3 = 0x3FF0005C
SPI_REG_BASE = 0x60000200
SPI_USR_OFFS = 0x1C
SPI_USR1_OFFS = 0x20
SPI_USR2_OFFS = 0x24
SPI_MOSI_DLEN_OFFS = None
SPI_MISO_DLEN_OFFS = None
SPI_W0_OFFS = 0x40
UART_CLKDIV_REG = 0x60000014
XTAL_CLK_DIVIDER = 2
FLASH_SIZES = {
"512KB": 0x00,
"256KB": 0x10,
"1MB": 0x20,
"2MB": 0x30,
"4MB": 0x40,
"2MB-c1": 0x50,
"4MB-c1": 0x60,
"8MB": 0x80,
"16MB": 0x90,
}
FLASH_FREQUENCY = {
"80m": 0xF,
"40m": 0x0,
"26m": 0x1,
"20m": 0x2,
}
BOOTLOADER_FLASH_OFFSET = 0
MEMORY_MAP = [
[0x3FF00000, 0x3FF00010, "DPORT"],
[0x3FFE8000, 0x40000000, "DRAM"],
[0x40100000, 0x40108000, "IRAM"],
[0x40201010, 0x402E1010, "IROM"],
]
def get_efuses(self):
# Return the 128 bits of ESP8266 efuse as a single Python integer
result = self.read_reg(0x3FF0005C) << 96
result |= self.read_reg(0x3FF00058) << 64
result |= self.read_reg(0x3FF00054) << 32
result |= self.read_reg(0x3FF00050)
return result
def _get_flash_size(self, efuses):
# rX_Y = EFUSE_DATA_OUTX[Y]
r0_4 = (efuses & (1 << 4)) != 0
r3_25 = (efuses & (1 << 121)) != 0
r3_26 = (efuses & (1 << 122)) != 0
r3_27 = (efuses & (1 << 123)) != 0
if r0_4 and not r3_25:
if not r3_27 and not r3_26:
return 1
elif not r3_27 and r3_26:
return 2
if not r0_4 and r3_25:
if not r3_27 and not r3_26:
return 2
elif not r3_27 and r3_26:
return 4
return -1
def get_chip_description(self):
efuses = self.get_efuses()
is_8285 = (
efuses & ((1 << 4) | 1 << 80)
) != 0 # One or the other efuse bit is set for ESP8285
if is_8285:
flash_size = self._get_flash_size(efuses)
max_temp = (
efuses & (1 << 5)
) != 0 # This efuse bit identifies the max flash temperature
chip_name = {
1: "ESP8285H08" if max_temp else "ESP8285N08",
2: "ESP8285H16" if max_temp else "ESP8285N16",
}.get(flash_size, "ESP8285")
return chip_name
return "ESP8266EX"
def get_chip_features(self):
features = ["WiFi"]
if "ESP8285" in self.get_chip_description():
features += ["Embedded Flash"]
return features
def flash_spi_attach(self, hspi_arg):
if self.IS_STUB:
super(ESP8266ROM, self).flash_spi_attach(hspi_arg)
else:
# ESP8266 ROM has no flash_spi_attach command in serial protocol,
# but flash_begin will do it
self.flash_begin(0, 0)
def flash_set_parameters(self, size):
# not implemented in ROM, but OK to silently skip for ROM
if self.IS_STUB:
super(ESP8266ROM, self).flash_set_parameters(size)
def chip_id(self):
"""
Read Chip ID from efuse - the equivalent of the SDK system_get_chip_id() func
"""
id0 = self.read_reg(self.ESP_OTP_MAC0)
id1 = self.read_reg(self.ESP_OTP_MAC1)
return (id0 >> 24) | ((id1 & 0xFFFFFF) << 8)
def read_mac(self, mac_type="BASE_MAC"):
"""Read MAC from OTP ROM"""
if mac_type != "BASE_MAC":
return None
mac0 = self.read_reg(self.ESP_OTP_MAC0)
mac1 = self.read_reg(self.ESP_OTP_MAC1)
mac3 = self.read_reg(self.ESP_OTP_MAC3)
if mac3 != 0:
oui = ((mac3 >> 16) & 0xFF, (mac3 >> 8) & 0xFF, mac3 & 0xFF)
elif ((mac1 >> 16) & 0xFF) == 0:
oui = (0x18, 0xFE, 0x34)
elif ((mac1 >> 16) & 0xFF) == 1:
oui = (0xAC, 0xD0, 0x74)
else:
raise FatalError("Unknown OUI")
return oui + ((mac1 >> 8) & 0xFF, mac1 & 0xFF, (mac0 >> 24) & 0xFF)
def get_erase_size(self, offset, size):
"""Calculate an erase size given a specific size in bytes.
Provides a workaround for the bootloader erase bug."""
sectors_per_block = 16
sector_size = self.FLASH_SECTOR_SIZE
num_sectors = (size + sector_size - 1) // sector_size
start_sector = offset // sector_size
head_sectors = sectors_per_block - (start_sector % sectors_per_block)
if num_sectors < head_sectors:
head_sectors = num_sectors
if num_sectors < 2 * head_sectors:
return (num_sectors + 1) // 2 * sector_size
else:
return (num_sectors - head_sectors) * sector_size
def override_vddsdio(self, new_voltage):
raise NotImplementedInROMError(
"Overriding VDDSDIO setting only applies to ESP32"
)
class ESP8266StubLoader(ESP8266ROM):
"""Access class for ESP8266 stub loader, runs on top of ROM."""
FLASH_WRITE_SIZE = 0x4000 # matches MAX_WRITE_BLOCK in stub_loader.c
IS_STUB = True
def __init__(self, rom_loader):
self.secure_download_mode = rom_loader.secure_download_mode
self._port = rom_loader._port
self._trace_enabled = rom_loader._trace_enabled
self.cache = rom_loader.cache
self.flush_input() # resets _slip_reader
def get_erase_size(self, offset, size):
return size # stub doesn't have same size bug as ROM loader
ESP8266ROM.STUB_CLASS = ESP8266StubLoader
| 6,050 | Python | .py | 158 | 29.5 | 85 | 0.576575 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,622 | esp32c2.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/esp32c2.py | # SPDX-FileCopyrightText: 2014-2022 Fredrik Ahlberg, Angus Gratton,
# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
import struct
import time
from .esp32c3 import ESP32C3ROM
from ..loader import ESPLoader
class ESP32C2ROM(ESP32C3ROM):
CHIP_NAME = "ESP32-C2"
IMAGE_CHIP_ID = 12
IROM_MAP_START = 0x42000000
IROM_MAP_END = 0x42400000
DROM_MAP_START = 0x3C000000
DROM_MAP_END = 0x3C400000
# Magic value for ESP32C2 ECO0 and ECO1 respectively
CHIP_DETECT_MAGIC_VALUE = [0x6F51306F, 0x7C41A06F]
EFUSE_BASE = 0x60008800
EFUSE_BLOCK2_ADDR = EFUSE_BASE + 0x040
MAC_EFUSE_REG = EFUSE_BASE + 0x040
EFUSE_SECURE_BOOT_EN_REG = EFUSE_BASE + 0x30
EFUSE_SECURE_BOOT_EN_MASK = 1 << 21
EFUSE_SPI_BOOT_CRYPT_CNT_REG = EFUSE_BASE + 0x30
EFUSE_SPI_BOOT_CRYPT_CNT_MASK = 0x7 << 18
EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT_REG = EFUSE_BASE + 0x30
EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT = 1 << 6
EFUSE_XTS_KEY_LENGTH_256_REG = EFUSE_BASE + 0x30
EFUSE_XTS_KEY_LENGTH_256 = 1 << 10
EFUSE_BLOCK_KEY0_REG = EFUSE_BASE + 0x60
EFUSE_RD_DIS_REG = EFUSE_BASE + 0x30
EFUSE_RD_DIS = 3
FLASH_FREQUENCY = {
"60m": 0xF,
"30m": 0x0,
"20m": 0x1,
"15m": 0x2,
}
MEMORY_MAP = [
[0x00000000, 0x00010000, "PADDING"],
[0x3C000000, 0x3C400000, "DROM"],
[0x3FCA0000, 0x3FCE0000, "DRAM"],
[0x3FC88000, 0x3FD00000, "BYTE_ACCESSIBLE"],
[0x3FF00000, 0x3FF50000, "DROM_MASK"],
[0x40000000, 0x40090000, "IROM_MASK"],
[0x42000000, 0x42400000, "IROM"],
[0x4037C000, 0x403C0000, "IRAM"],
]
def get_pkg_version(self):
num_word = 1
return (self.read_reg(self.EFUSE_BLOCK2_ADDR + (4 * num_word)) >> 22) & 0x07
def get_chip_description(self):
chip_name = {
0: "ESP32-C2",
1: "ESP32-C2",
}.get(self.get_pkg_version(), "unknown ESP32-C2")
major_rev = self.get_major_chip_version()
minor_rev = self.get_minor_chip_version()
return f"{chip_name} (revision v{major_rev}.{minor_rev})"
def get_minor_chip_version(self):
num_word = 1
return (self.read_reg(self.EFUSE_BLOCK2_ADDR + (4 * num_word)) >> 16) & 0xF
def get_major_chip_version(self):
num_word = 1
return (self.read_reg(self.EFUSE_BLOCK2_ADDR + (4 * num_word)) >> 20) & 0x3
def get_crystal_freq(self):
# The crystal detection algorithm of ESP32/ESP8266 works for ESP32-C2 as well.
return ESPLoader.get_crystal_freq(self)
def change_baud(self, baud):
rom_with_26M_XTAL = not self.IS_STUB and self.get_crystal_freq() == 26
if rom_with_26M_XTAL:
# The code is copied over from ESPLoader.change_baud().
# Probably this is just a temporary solution until the next chip revision.
# The ROM code thinks it uses a 40 MHz XTAL. Recompute the baud rate
# in order to trick the ROM code to set the correct baud rate for
# a 26 MHz XTAL.
false_rom_baud = baud * 40 // 26
print(f"Changing baud rate to {baud}")
self.command(
self.ESP_CHANGE_BAUDRATE, struct.pack("<II", false_rom_baud, 0)
)
print("Changed.")
self._set_port_baudrate(baud)
time.sleep(0.05) # get rid of garbage sent during baud rate change
self.flush_input()
else:
ESPLoader.change_baud(self, baud)
def _post_connect(self):
# ESP32C2 ECO0 is no longer supported by the flasher stub
if not self.secure_download_mode and self.get_chip_revision() == 0:
self.stub_is_disabled = True
self.IS_STUB = False
""" Try to read (encryption key) and check if it is valid """
def is_flash_encryption_key_valid(self):
key_len_256 = (
self.read_reg(self.EFUSE_XTS_KEY_LENGTH_256_REG)
& self.EFUSE_XTS_KEY_LENGTH_256
)
word0 = self.read_reg(self.EFUSE_RD_DIS_REG) & self.EFUSE_RD_DIS
rd_disable = word0 == 3 if key_len_256 else word0 == 1
# reading of BLOCK3 is NOT ALLOWED so we assume valid key is programmed
if rd_disable:
return True
else:
# reading of BLOCK3 is ALLOWED so we will read and verify for non-zero.
# When chip has not generated AES/encryption key in BLOCK3,
# the contents will be readable and 0.
# If the flash encryption is enabled it is expected to have a valid
# non-zero key. We break out on first occurance of non-zero value
key_word = [0] * 7 if key_len_256 else [0] * 3
for i in range(len(key_word)):
key_word[i] = self.read_reg(self.EFUSE_BLOCK_KEY0_REG + i * 4)
# key is non-zero so break & return
if key_word[i] != 0:
return True
return False
class ESP32C2StubLoader(ESP32C2ROM):
"""Access class for ESP32C2 stub loader, runs on top of ROM.
(Basically the same as ESP32StubLoader, but different base class.
Can possibly be made into a mixin.)
"""
FLASH_WRITE_SIZE = 0x4000 # matches MAX_WRITE_BLOCK in stub_loader.c
STATUS_BYTES_LENGTH = 2 # same as ESP8266, different to ESP32 ROM
IS_STUB = True
def __init__(self, rom_loader):
self.secure_download_mode = rom_loader.secure_download_mode
self._port = rom_loader._port
self._trace_enabled = rom_loader._trace_enabled
self.cache = rom_loader.cache
self.flush_input() # resets _slip_reader
ESP32C2ROM.STUB_CLASS = ESP32C2StubLoader
| 5,769 | Python | .py | 130 | 35.876923 | 86 | 0.624911 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,623 | esp32.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/esp32.py | # SPDX-FileCopyrightText: 2014-2022 Fredrik Ahlberg, Angus Gratton,
# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
import struct
import time
from ..loader import ESPLoader
from ..util import FatalError, NotSupportedError
class ESP32ROM(ESPLoader):
"""Access class for ESP32 ROM bootloader"""
CHIP_NAME = "ESP32"
IMAGE_CHIP_ID = 0
IS_STUB = False
FPGA_SLOW_BOOT = True
CHIP_DETECT_MAGIC_VALUE = [0x00F01D83]
IROM_MAP_START = 0x400D0000
IROM_MAP_END = 0x40400000
DROM_MAP_START = 0x3F400000
DROM_MAP_END = 0x3F800000
# ESP32 uses a 4 byte status reply
STATUS_BYTES_LENGTH = 4
SPI_REG_BASE = 0x3FF42000
SPI_USR_OFFS = 0x1C
SPI_USR1_OFFS = 0x20
SPI_USR2_OFFS = 0x24
SPI_MOSI_DLEN_OFFS = 0x28
SPI_MISO_DLEN_OFFS = 0x2C
EFUSE_RD_REG_BASE = 0x3FF5A000
EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT_REG = EFUSE_RD_REG_BASE + 0x18
EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT = 1 << 7 # EFUSE_RD_DISABLE_DL_ENCRYPT
EFUSE_SPI_BOOT_CRYPT_CNT_REG = EFUSE_RD_REG_BASE # EFUSE_BLK0_WDATA0_REG
EFUSE_SPI_BOOT_CRYPT_CNT_MASK = 0x7F << 20 # EFUSE_FLASH_CRYPT_CNT
EFUSE_RD_ABS_DONE_REG = EFUSE_RD_REG_BASE + 0x018
EFUSE_RD_ABS_DONE_0_MASK = 1 << 4
EFUSE_RD_ABS_DONE_1_MASK = 1 << 5
DR_REG_SYSCON_BASE = 0x3FF66000
APB_CTL_DATE_ADDR = DR_REG_SYSCON_BASE + 0x7C
APB_CTL_DATE_V = 0x1
APB_CTL_DATE_S = 31
SPI_W0_OFFS = 0x80
UART_CLKDIV_REG = 0x3FF40014
XTAL_CLK_DIVIDER = 1
RTCCALICFG1 = 0x3FF5F06C
TIMERS_RTC_CALI_VALUE = 0x01FFFFFF
TIMERS_RTC_CALI_VALUE_S = 7
FLASH_SIZES = {
"1MB": 0x00,
"2MB": 0x10,
"4MB": 0x20,
"8MB": 0x30,
"16MB": 0x40,
"32MB": 0x50,
"64MB": 0x60,
"128MB": 0x70,
}
FLASH_FREQUENCY = {
"80m": 0xF,
"40m": 0x0,
"26m": 0x1,
"20m": 0x2,
}
BOOTLOADER_FLASH_OFFSET = 0x1000
OVERRIDE_VDDSDIO_CHOICES = ["1.8V", "1.9V", "OFF"]
MEMORY_MAP = [
[0x00000000, 0x00010000, "PADDING"],
[0x3F400000, 0x3F800000, "DROM"],
[0x3F800000, 0x3FC00000, "EXTRAM_DATA"],
[0x3FF80000, 0x3FF82000, "RTC_DRAM"],
[0x3FF90000, 0x40000000, "BYTE_ACCESSIBLE"],
[0x3FFAE000, 0x40000000, "DRAM"],
[0x3FFE0000, 0x3FFFFFFC, "DIRAM_DRAM"],
[0x40000000, 0x40070000, "IROM"],
[0x40070000, 0x40078000, "CACHE_PRO"],
[0x40078000, 0x40080000, "CACHE_APP"],
[0x40080000, 0x400A0000, "IRAM"],
[0x400A0000, 0x400BFFFC, "DIRAM_IRAM"],
[0x400C0000, 0x400C2000, "RTC_IRAM"],
[0x400D0000, 0x40400000, "IROM"],
[0x50000000, 0x50002000, "RTC_DATA"],
]
FLASH_ENCRYPTED_WRITE_ALIGN = 32
""" Try to read the BLOCK1 (encryption key) and check if it is valid """
def is_flash_encryption_key_valid(self):
"""Bit 0 of efuse_rd_disable[3:0] is mapped to BLOCK1
this bit is at position 16 in EFUSE_BLK0_RDATA0_REG"""
word0 = self.read_efuse(0)
rd_disable = (word0 >> 16) & 0x1
# reading of BLOCK1 is NOT ALLOWED so we assume valid key is programmed
if rd_disable:
return True
else:
# reading of BLOCK1 is ALLOWED so we will read and verify for non-zero.
# When ESP32 has not generated AES/encryption key in BLOCK1,
# the contents will be readable and 0.
# If the flash encryption is enabled it is expected to have a valid
# non-zero key. We break out on first occurance of non-zero value
key_word = [0] * 7
for i in range(len(key_word)):
key_word[i] = self.read_efuse(14 + i)
# key is non-zero so break & return
if key_word[i] != 0:
return True
return False
def get_flash_crypt_config(self):
"""For flash encryption related commands we need to make sure
user has programmed all the relevant efuse correctly so before
writing encrypted write_flash_encrypt esptool will verify the values
of flash_crypt_config to be non zero if they are not read
protected. If the values are zero a warning will be printed
bit 3 in efuse_rd_disable[3:0] is mapped to flash_crypt_config
this bit is at position 19 in EFUSE_BLK0_RDATA0_REG"""
word0 = self.read_efuse(0)
rd_disable = (word0 >> 19) & 0x1
if rd_disable == 0:
"""we can read the flash_crypt_config efuse value
so go & read it (EFUSE_BLK0_RDATA5_REG[31:28])"""
word5 = self.read_efuse(5)
word5 = (word5 >> 28) & 0xF
return word5
else:
# if read of the efuse is disabled we assume it is set correctly
return 0xF
def get_encrypted_download_disabled(self):
return (
self.read_reg(self.EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT_REG)
& self.EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT
)
def get_flash_encryption_enabled(self):
flash_crypt_cnt = (
self.read_reg(self.EFUSE_SPI_BOOT_CRYPT_CNT_REG)
& self.EFUSE_SPI_BOOT_CRYPT_CNT_MASK
)
# Flash encryption enabled when odd number of bits are set
return bin(flash_crypt_cnt).count("1") & 1 != 0
def get_secure_boot_enabled(self):
efuses = self.read_reg(self.EFUSE_RD_ABS_DONE_REG)
rev = self.get_chip_revision()
return efuses & self.EFUSE_RD_ABS_DONE_0_MASK or (
rev >= 300 and efuses & self.EFUSE_RD_ABS_DONE_1_MASK
)
def get_pkg_version(self):
word3 = self.read_efuse(3)
pkg_version = (word3 >> 9) & 0x07
pkg_version += ((word3 >> 2) & 0x1) << 3
return pkg_version
def get_chip_revision(self):
return self.get_major_chip_version() * 100 + self.get_minor_chip_version()
def get_minor_chip_version(self):
return (self.read_efuse(5) >> 24) & 0x3
def get_major_chip_version(self):
rev_bit0 = (self.read_efuse(3) >> 15) & 0x1
rev_bit1 = (self.read_efuse(5) >> 20) & 0x1
apb_ctl_date = self.read_reg(self.APB_CTL_DATE_ADDR)
rev_bit2 = (apb_ctl_date >> self.APB_CTL_DATE_S) & self.APB_CTL_DATE_V
combine_value = (rev_bit2 << 2) | (rev_bit1 << 1) | rev_bit0
revision = {
0: 0,
1: 1,
3: 2,
7: 3,
}.get(combine_value, 0)
return revision
def get_chip_description(self):
pkg_version = self.get_pkg_version()
major_rev = self.get_major_chip_version()
minor_rev = self.get_minor_chip_version()
rev3 = major_rev == 3
single_core = self.read_efuse(3) & (1 << 0) # CHIP_VER DIS_APP_CPU
chip_name = {
0: "ESP32-S0WDQ6" if single_core else "ESP32-D0WDQ6",
1: "ESP32-S0WD" if single_core else "ESP32-D0WD",
2: "ESP32-D2WD",
4: "ESP32-U4WDH",
5: "ESP32-PICO-V3" if rev3 else "ESP32-PICO-D4",
6: "ESP32-PICO-V3-02",
7: "ESP32-D0WDR2-V3",
}.get(pkg_version, "unknown ESP32")
# ESP32-D0WD-V3, ESP32-D0WDQ6-V3
if chip_name.startswith("ESP32-D0WD") and rev3:
chip_name += "-V3"
return f"{chip_name} (revision v{major_rev}.{minor_rev})"
def get_chip_features(self):
features = ["WiFi"]
word3 = self.read_efuse(3)
# names of variables in this section are lowercase
# versions of EFUSE names as documented in TRM and
# ESP-IDF efuse_reg.h
chip_ver_dis_bt = word3 & (1 << 1)
if chip_ver_dis_bt == 0:
features += ["BT"]
chip_ver_dis_app_cpu = word3 & (1 << 0)
if chip_ver_dis_app_cpu:
features += ["Single Core"]
else:
features += ["Dual Core"]
chip_cpu_freq_rated = word3 & (1 << 13)
if chip_cpu_freq_rated:
chip_cpu_freq_low = word3 & (1 << 12)
if chip_cpu_freq_low:
features += ["160MHz"]
else:
features += ["240MHz"]
pkg_version = self.get_pkg_version()
if pkg_version in [2, 4, 5, 6]:
features += ["Embedded Flash"]
if pkg_version == 6:
features += ["Embedded PSRAM"]
word4 = self.read_efuse(4)
adc_vref = (word4 >> 8) & 0x1F
if adc_vref:
features += ["VRef calibration in efuse"]
blk3_part_res = word3 >> 14 & 0x1
if blk3_part_res:
features += ["BLK3 partially reserved"]
word6 = self.read_efuse(6)
coding_scheme = word6 & 0x3
features += [
"Coding Scheme %s"
% {0: "None", 1: "3/4", 2: "Repeat (UNSUPPORTED)", 3: "Invalid"}[
coding_scheme
]
]
return features
def read_efuse(self, n):
"""Read the nth word of the ESP3x EFUSE region."""
return self.read_reg(self.EFUSE_RD_REG_BASE + (4 * n))
def chip_id(self):
raise NotSupportedError(self, "chip_id")
def read_mac(self, mac_type="BASE_MAC"):
"""Read MAC from EFUSE region"""
if mac_type != "BASE_MAC":
return None
words = [self.read_efuse(2), self.read_efuse(1)]
bitstring = struct.pack(">II", *words)
bitstring = bitstring[2:8] # trim the 2 byte CRC
return tuple(bitstring)
def get_erase_size(self, offset, size):
return size
def override_vddsdio(self, new_voltage):
new_voltage = new_voltage.upper()
if new_voltage not in self.OVERRIDE_VDDSDIO_CHOICES:
raise FatalError(
"The only accepted VDDSDIO overrides are '1.8V', '1.9V' and 'OFF'"
)
RTC_CNTL_SDIO_CONF_REG = 0x3FF48074
RTC_CNTL_XPD_SDIO_REG = 1 << 31
RTC_CNTL_DREFH_SDIO_M = 3 << 29
RTC_CNTL_DREFM_SDIO_M = 3 << 27
RTC_CNTL_DREFL_SDIO_M = 3 << 25
# RTC_CNTL_SDIO_TIEH = (1 << 23)
# not used here, setting TIEH=1 would set 3.3V output,
# not safe for esptool.py to do
RTC_CNTL_SDIO_FORCE = 1 << 22
RTC_CNTL_SDIO_PD_EN = 1 << 21
reg_val = RTC_CNTL_SDIO_FORCE # override efuse setting
reg_val |= RTC_CNTL_SDIO_PD_EN
if new_voltage != "OFF":
reg_val |= RTC_CNTL_XPD_SDIO_REG # enable internal LDO
if new_voltage == "1.9V":
reg_val |= (
RTC_CNTL_DREFH_SDIO_M | RTC_CNTL_DREFM_SDIO_M | RTC_CNTL_DREFL_SDIO_M
) # boost voltage
self.write_reg(RTC_CNTL_SDIO_CONF_REG, reg_val)
print("VDDSDIO regulator set to %s" % new_voltage)
def read_flash_slow(self, offset, length, progress_fn):
BLOCK_LEN = 64 # ROM read limit per command (this limit is why it's so slow)
data = b""
while len(data) < length:
block_len = min(BLOCK_LEN, length - len(data))
r = self.check_command(
"read flash block",
self.ESP_READ_FLASH_SLOW,
struct.pack("<II", offset + len(data), block_len),
)
if len(r) < block_len:
raise FatalError(
"Expected %d byte block, got %d bytes. Serial errors?"
% (block_len, len(r))
)
# command always returns 64 byte buffer,
# regardless of how many bytes were actually read from flash
data += r[:block_len]
if progress_fn and (len(data) % 1024 == 0 or len(data) == length):
progress_fn(len(data), length)
return data
def get_rom_cal_crystal_freq(self):
"""
Get the crystal frequency calculated by the ROM
"""
# - Simulate the calculation in the ROM to get the XTAL frequency
# calculated by the ROM
cali_val = (
self.read_reg(self.RTCCALICFG1) >> self.TIMERS_RTC_CALI_VALUE_S
) & self.TIMERS_RTC_CALI_VALUE
clk_8M_freq = self.read_efuse(4) & (0xFF) # EFUSE_RD_CK8M_FREQ
rom_calculated_freq = cali_val * 15625 * clk_8M_freq / 40
return rom_calculated_freq
def change_baud(self, baud):
assert self.CHIP_NAME == "ESP32", "This workaround should only apply to ESP32"
# It's a workaround to avoid esp32 CK_8M frequency drift.
rom_calculated_freq = self.get_rom_cal_crystal_freq()
valid_freq = 40000000 if rom_calculated_freq > 33000000 else 26000000
false_rom_baud = int(baud * rom_calculated_freq // valid_freq)
print(f"Changing baud rate to {baud}")
self.command(self.ESP_CHANGE_BAUDRATE, struct.pack("<II", false_rom_baud, 0))
print("Changed.")
self._set_port_baudrate(baud)
time.sleep(0.05) # get rid of garbage sent during baud rate change
self.flush_input()
class ESP32StubLoader(ESP32ROM):
"""Access class for ESP32 stub loader, runs on top of ROM."""
FLASH_WRITE_SIZE = 0x4000 # matches MAX_WRITE_BLOCK in stub_loader.c
STATUS_BYTES_LENGTH = 2 # same as ESP8266, different to ESP32 ROM
IS_STUB = True
def __init__(self, rom_loader):
self.secure_download_mode = rom_loader.secure_download_mode
self._port = rom_loader._port
self._trace_enabled = rom_loader._trace_enabled
self.cache = rom_loader.cache
self.flush_input() # resets _slip_reader
def change_baud(self, baud):
ESPLoader.change_baud(self, baud)
ESP32ROM.STUB_CLASS = ESP32StubLoader
| 13,673 | Python | .py | 323 | 33.043344 | 86 | 0.588537 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,624 | esp32s3.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/esp32s3.py | # SPDX-FileCopyrightText: 2014-2023 Fredrik Ahlberg, Angus Gratton,
# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
import os
import struct
from .esp32 import ESP32ROM
from ..loader import ESPLoader
from ..reset import HardReset
from ..util import FatalError, NotImplementedInROMError
class ESP32S3ROM(ESP32ROM):
CHIP_NAME = "ESP32-S3"
IMAGE_CHIP_ID = 9
CHIP_DETECT_MAGIC_VALUE = [0x9]
FPGA_SLOW_BOOT = False
IROM_MAP_START = 0x42000000
IROM_MAP_END = 0x44000000
DROM_MAP_START = 0x3C000000
DROM_MAP_END = 0x3E000000
UART_DATE_REG_ADDR = 0x60000080
SPI_REG_BASE = 0x60002000
SPI_USR_OFFS = 0x18
SPI_USR1_OFFS = 0x1C
SPI_USR2_OFFS = 0x20
SPI_MOSI_DLEN_OFFS = 0x24
SPI_MISO_DLEN_OFFS = 0x28
SPI_W0_OFFS = 0x58
BOOTLOADER_FLASH_OFFSET = 0x0
SUPPORTS_ENCRYPTED_FLASH = True
FLASH_ENCRYPTED_WRITE_ALIGN = 16
# todo: use espefuse APIs to get this info
EFUSE_BASE = 0x60007000 # BLOCK0 read base address
EFUSE_BLOCK1_ADDR = EFUSE_BASE + 0x44
EFUSE_BLOCK2_ADDR = EFUSE_BASE + 0x5C
MAC_EFUSE_REG = EFUSE_BASE + 0x044
EFUSE_RD_REG_BASE = EFUSE_BASE + 0x030 # BLOCK0 read base address
EFUSE_PURPOSE_KEY0_REG = EFUSE_BASE + 0x34
EFUSE_PURPOSE_KEY0_SHIFT = 24
EFUSE_PURPOSE_KEY1_REG = EFUSE_BASE + 0x34
EFUSE_PURPOSE_KEY1_SHIFT = 28
EFUSE_PURPOSE_KEY2_REG = EFUSE_BASE + 0x38
EFUSE_PURPOSE_KEY2_SHIFT = 0
EFUSE_PURPOSE_KEY3_REG = EFUSE_BASE + 0x38
EFUSE_PURPOSE_KEY3_SHIFT = 4
EFUSE_PURPOSE_KEY4_REG = EFUSE_BASE + 0x38
EFUSE_PURPOSE_KEY4_SHIFT = 8
EFUSE_PURPOSE_KEY5_REG = EFUSE_BASE + 0x38
EFUSE_PURPOSE_KEY5_SHIFT = 12
EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT_REG = EFUSE_RD_REG_BASE
EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT = 1 << 20
EFUSE_SPI_BOOT_CRYPT_CNT_REG = EFUSE_BASE + 0x034
EFUSE_SPI_BOOT_CRYPT_CNT_MASK = 0x7 << 18
EFUSE_SECURE_BOOT_EN_REG = EFUSE_BASE + 0x038
EFUSE_SECURE_BOOT_EN_MASK = 1 << 20
EFUSE_RD_REPEAT_DATA3_REG = EFUSE_BASE + 0x3C
EFUSE_RD_REPEAT_DATA3_REG_FLASH_TYPE_MASK = 1 << 9
PURPOSE_VAL_XTS_AES256_KEY_1 = 2
PURPOSE_VAL_XTS_AES256_KEY_2 = 3
PURPOSE_VAL_XTS_AES128_KEY = 4
UARTDEV_BUF_NO = 0x3FCEF14C # Variable in ROM .bss which indicates the port in use
UARTDEV_BUF_NO_USB_OTG = 3 # The above var when USB-OTG is used
UARTDEV_BUF_NO_USB_JTAG_SERIAL = 4 # The above var when USB-JTAG/Serial is used
RTCCNTL_BASE_REG = 0x60008000
RTC_CNTL_SWD_CONF_REG = RTCCNTL_BASE_REG + 0x00B4
RTC_CNTL_SWD_AUTO_FEED_EN = 1 << 31
RTC_CNTL_SWD_WPROTECT_REG = RTCCNTL_BASE_REG + 0x00B8
RTC_CNTL_SWD_WKEY = 0x8F1D312A
RTC_CNTL_WDTCONFIG0_REG = RTCCNTL_BASE_REG + 0x0098
RTC_CNTL_WDTWPROTECT_REG = RTCCNTL_BASE_REG + 0x00B0
RTC_CNTL_WDT_WKEY = 0x50D83AA1
USB_RAM_BLOCK = 0x800 # Max block size USB-OTG is used
GPIO_STRAP_REG = 0x60004038
GPIO_STRAP_SPI_BOOT_MASK = 0x8 # Not download mode
RTC_CNTL_OPTION1_REG = 0x6000812C
RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK = 0x1 # Is download mode forced over USB?
UART_CLKDIV_REG = 0x60000014
MEMORY_MAP = [
[0x00000000, 0x00010000, "PADDING"],
[0x3C000000, 0x3D000000, "DROM"],
[0x3D000000, 0x3E000000, "EXTRAM_DATA"],
[0x600FE000, 0x60100000, "RTC_DRAM"],
[0x3FC88000, 0x3FD00000, "BYTE_ACCESSIBLE"],
[0x3FC88000, 0x403E2000, "MEM_INTERNAL"],
[0x3FC88000, 0x3FD00000, "DRAM"],
[0x40000000, 0x4001A100, "IROM_MASK"],
[0x40370000, 0x403E0000, "IRAM"],
[0x600FE000, 0x60100000, "RTC_IRAM"],
[0x42000000, 0x42800000, "IROM"],
[0x50000000, 0x50002000, "RTC_DATA"],
]
def get_pkg_version(self):
num_word = 3
return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 21) & 0x07
def is_eco0(self, minor_raw):
# Workaround: The major version field was allocated to other purposes
# when block version is v1.1.
# Luckily only chip v0.0 have this kind of block version and efuse usage.
return (
(minor_raw & 0x7) == 0
and self.get_blk_version_major() == 1
and self.get_blk_version_minor() == 1
)
def get_minor_chip_version(self):
minor_raw = self.get_raw_minor_chip_version()
if self.is_eco0(minor_raw):
return 0
return minor_raw
def get_raw_minor_chip_version(self):
hi_num_word = 5
hi = (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * hi_num_word)) >> 23) & 0x01
low_num_word = 3
low = (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * low_num_word)) >> 18) & 0x07
return (hi << 3) + low
def get_blk_version_major(self):
num_word = 4
return (self.read_reg(self.EFUSE_BLOCK2_ADDR + (4 * num_word)) >> 0) & 0x03
def get_blk_version_minor(self):
num_word = 3
return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 24) & 0x07
def get_major_chip_version(self):
minor_raw = self.get_raw_minor_chip_version()
if self.is_eco0(minor_raw):
return 0
return self.get_raw_major_chip_version()
def get_raw_major_chip_version(self):
num_word = 5
return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 24) & 0x03
def get_chip_description(self):
major_rev = self.get_major_chip_version()
minor_rev = self.get_minor_chip_version()
pkg_version = self.get_pkg_version()
chip_name = {
0: "ESP32-S3 (QFN56)",
1: "ESP32-S3-PICO-1 (LGA56)",
}.get(pkg_version, "unknown ESP32-S3")
return f"{chip_name} (revision v{major_rev}.{minor_rev})"
def get_flash_cap(self):
num_word = 3
return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 27) & 0x07
def get_flash_vendor(self):
num_word = 4
vendor_id = (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 0) & 0x07
return {1: "XMC", 2: "GD", 3: "FM", 4: "TT", 5: "BY"}.get(vendor_id, "")
def get_psram_cap(self):
num_word = 4
return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 3) & 0x03
def get_psram_vendor(self):
num_word = 4
vendor_id = (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 7) & 0x03
return {1: "AP_3v3", 2: "AP_1v8"}.get(vendor_id, "")
def get_chip_features(self):
features = ["WiFi", "BLE"]
flash = {
0: None,
1: "Embedded Flash 8MB",
2: "Embedded Flash 4MB",
}.get(self.get_flash_cap(), "Unknown Embedded Flash")
if flash is not None:
features += [flash + f" ({self.get_flash_vendor()})"]
psram = {
0: None,
1: "Embedded PSRAM 8MB",
2: "Embedded PSRAM 2MB",
}.get(self.get_psram_cap(), "Unknown Embedded PSRAM")
if psram is not None:
features += [psram + f" ({self.get_psram_vendor()})"]
return features
def get_crystal_freq(self):
# ESP32S3 XTAL is fixed to 40MHz
return 40
def get_flash_crypt_config(self):
return None # doesn't exist on ESP32-S3
def get_key_block_purpose(self, key_block):
if key_block < 0 or key_block > 5:
raise FatalError("Valid key block numbers must be in range 0-5")
reg, shift = [
(self.EFUSE_PURPOSE_KEY0_REG, self.EFUSE_PURPOSE_KEY0_SHIFT),
(self.EFUSE_PURPOSE_KEY1_REG, self.EFUSE_PURPOSE_KEY1_SHIFT),
(self.EFUSE_PURPOSE_KEY2_REG, self.EFUSE_PURPOSE_KEY2_SHIFT),
(self.EFUSE_PURPOSE_KEY3_REG, self.EFUSE_PURPOSE_KEY3_SHIFT),
(self.EFUSE_PURPOSE_KEY4_REG, self.EFUSE_PURPOSE_KEY4_SHIFT),
(self.EFUSE_PURPOSE_KEY5_REG, self.EFUSE_PURPOSE_KEY5_SHIFT),
][key_block]
return (self.read_reg(reg) >> shift) & 0xF
def is_flash_encryption_key_valid(self):
# Need to see either an AES-128 key or two AES-256 keys
purposes = [self.get_key_block_purpose(b) for b in range(6)]
if any(p == self.PURPOSE_VAL_XTS_AES128_KEY for p in purposes):
return True
return any(p == self.PURPOSE_VAL_XTS_AES256_KEY_1 for p in purposes) and any(
p == self.PURPOSE_VAL_XTS_AES256_KEY_2 for p in purposes
)
def get_secure_boot_enabled(self):
return (
self.read_reg(self.EFUSE_SECURE_BOOT_EN_REG)
& self.EFUSE_SECURE_BOOT_EN_MASK
)
def override_vddsdio(self, new_voltage):
raise NotImplementedInROMError(
"VDD_SDIO overrides are not supported for ESP32-S3"
)
def read_mac(self, mac_type="BASE_MAC"):
"""Read MAC from EFUSE region"""
if mac_type != "BASE_MAC":
return None
mac0 = self.read_reg(self.MAC_EFUSE_REG)
mac1 = self.read_reg(self.MAC_EFUSE_REG + 4) # only bottom 16 bits are MAC
bitstring = struct.pack(">II", mac1, mac0)[2:]
return tuple(bitstring)
def flash_type(self):
return (
1
if self.read_reg(self.EFUSE_RD_REPEAT_DATA3_REG)
& self.EFUSE_RD_REPEAT_DATA3_REG_FLASH_TYPE_MASK
else 0
)
def uses_usb_otg(self):
"""
Check the UARTDEV_BUF_NO register to see if USB-OTG console is being used
"""
if self.secure_download_mode:
return False # can't detect native USB in secure download mode
return self.get_uart_no() == self.UARTDEV_BUF_NO_USB_OTG
def uses_usb_jtag_serial(self):
"""
Check the UARTDEV_BUF_NO register to see if USB-JTAG/Serial is being used
"""
if self.secure_download_mode:
return False # can't detect USB-JTAG/Serial in secure download mode
return self.get_uart_no() == self.UARTDEV_BUF_NO_USB_JTAG_SERIAL
def disable_watchdogs(self):
# When USB-JTAG/Serial is used, the RTC WDT and SWD watchdog are not reset
# and can then reset the board during flashing. Disable them.
if self.uses_usb_jtag_serial():
# Disable RTC WDT
self.write_reg(self.RTC_CNTL_WDTWPROTECT_REG, self.RTC_CNTL_WDT_WKEY)
self.write_reg(self.RTC_CNTL_WDTCONFIG0_REG, 0)
self.write_reg(self.RTC_CNTL_WDTWPROTECT_REG, 0)
# Automatically feed SWD
self.write_reg(self.RTC_CNTL_SWD_WPROTECT_REG, self.RTC_CNTL_SWD_WKEY)
self.write_reg(
self.RTC_CNTL_SWD_CONF_REG,
self.read_reg(self.RTC_CNTL_SWD_CONF_REG)
| self.RTC_CNTL_SWD_AUTO_FEED_EN,
)
self.write_reg(self.RTC_CNTL_SWD_WPROTECT_REG, 0)
def _post_connect(self):
if self.uses_usb_otg():
self.ESP_RAM_BLOCK = self.USB_RAM_BLOCK
if not self.sync_stub_detected: # Don't run if stub is reused
self.disable_watchdogs()
def _check_if_can_reset(self):
"""
Check the strapping register to see if we can reset out of download mode.
"""
if os.getenv("ESPTOOL_TESTING") is not None:
print("ESPTOOL_TESTING is set, ignoring strapping mode check")
# Esptool tests over USB-OTG run with GPIO0 strapped low,
# don't complain in this case.
return
strap_reg = self.read_reg(self.GPIO_STRAP_REG)
force_dl_reg = self.read_reg(self.RTC_CNTL_OPTION1_REG)
if (
strap_reg & self.GPIO_STRAP_SPI_BOOT_MASK == 0
and force_dl_reg & self.RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK == 0
):
print(
"WARNING: {} chip was placed into download mode using GPIO0.\n"
"esptool.py can not exit the download mode over USB. "
"To run the app, reset the chip manually.\n"
"To suppress this note, set --after option to 'no_reset'.".format(
self.get_chip_description()
)
)
raise SystemExit(1)
def hard_reset(self):
uses_usb_otg = self.uses_usb_otg()
if uses_usb_otg:
self._check_if_can_reset()
print("Hard resetting via RTS pin...")
HardReset(self._port, uses_usb_otg)()
def change_baud(self, baud):
ESPLoader.change_baud(self, baud)
class ESP32S3StubLoader(ESP32S3ROM):
"""Access class for ESP32S3 stub loader, runs on top of ROM.
(Basically the same as ESP32StubLoader, but different base class.
Can possibly be made into a mixin.)
"""
FLASH_WRITE_SIZE = 0x4000 # matches MAX_WRITE_BLOCK in stub_loader.c
STATUS_BYTES_LENGTH = 2 # same as ESP8266, different to ESP32 ROM
IS_STUB = True
def __init__(self, rom_loader):
self.secure_download_mode = rom_loader.secure_download_mode
self._port = rom_loader._port
self._trace_enabled = rom_loader._trace_enabled
self.cache = rom_loader.cache
self.flush_input() # resets _slip_reader
if rom_loader.uses_usb_otg():
self.ESP_RAM_BLOCK = self.USB_RAM_BLOCK
self.FLASH_WRITE_SIZE = self.USB_RAM_BLOCK
ESP32S3ROM.STUB_CLASS = ESP32S3StubLoader
| 13,343 | Python | .py | 301 | 35.797342 | 88 | 0.620961 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,625 | esp32h2.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/esp32h2.py | # SPDX-FileCopyrightText: 2022 Fredrik Ahlberg, Angus Gratton,
# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
from .esp32c6 import ESP32C6ROM
class ESP32H2ROM(ESP32C6ROM):
CHIP_NAME = "ESP32-H2"
IMAGE_CHIP_ID = 16
# Magic value for ESP32H2
CHIP_DETECT_MAGIC_VALUE = [0xD7B73E80]
DR_REG_LP_WDT_BASE = 0x600B1C00
RTC_CNTL_WDTCONFIG0_REG = DR_REG_LP_WDT_BASE + 0x0 # LP_WDT_RWDT_CONFIG0_REG
RTC_CNTL_WDTWPROTECT_REG = DR_REG_LP_WDT_BASE + 0x001C # LP_WDT_RWDT_WPROTECT_REG
RTC_CNTL_SWD_CONF_REG = DR_REG_LP_WDT_BASE + 0x0020 # LP_WDT_SWD_CONFIG_REG
RTC_CNTL_SWD_AUTO_FEED_EN = 1 << 18
RTC_CNTL_SWD_WPROTECT_REG = DR_REG_LP_WDT_BASE + 0x0024 # LP_WDT_SWD_WPROTECT_REG
RTC_CNTL_SWD_WKEY = 0x50D83AA1 # LP_WDT_SWD_WKEY, same as WDT key in this case
FLASH_FREQUENCY = {
"48m": 0xF,
"24m": 0x0,
"16m": 0x1,
"12m": 0x2,
}
def get_pkg_version(self):
num_word = 4
return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 0) & 0x07
def get_minor_chip_version(self):
num_word = 3
return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 18) & 0x07
def get_major_chip_version(self):
num_word = 3
return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 21) & 0x03
def get_chip_description(self):
chip_name = {
0: "ESP32-H2",
}.get(self.get_pkg_version(), "unknown ESP32-H2")
major_rev = self.get_major_chip_version()
minor_rev = self.get_minor_chip_version()
return f"{chip_name} (revision v{major_rev}.{minor_rev})"
def get_chip_features(self):
return ["BLE", "IEEE802.15.4"]
def get_crystal_freq(self):
# ESP32H2 XTAL is fixed to 32MHz
return 32
class ESP32H2StubLoader(ESP32H2ROM):
"""Access class for ESP32H2 stub loader, runs on top of ROM.
(Basically the same as ESP32StubLoader, but different base class.
Can possibly be made into a mixin.)
"""
FLASH_WRITE_SIZE = 0x4000 # matches MAX_WRITE_BLOCK in stub_loader.c
STATUS_BYTES_LENGTH = 2 # same as ESP8266, different to ESP32 ROM
IS_STUB = True
def __init__(self, rom_loader):
self.secure_download_mode = rom_loader.secure_download_mode
self._port = rom_loader._port
self._trace_enabled = rom_loader._trace_enabled
self.cache = rom_loader.cache
self.flush_input() # resets _slip_reader
ESP32H2ROM.STUB_CLASS = ESP32H2StubLoader
| 2,597 | Python | .py | 59 | 37.525424 | 86 | 0.653296 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,626 | esp32s2.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/esp32s2.py | # SPDX-FileCopyrightText: 2014-2023 Fredrik Ahlberg, Angus Gratton,
# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
import os
import struct
from .esp32 import ESP32ROM
from ..loader import ESPLoader
from ..reset import HardReset
from ..util import FatalError, NotImplementedInROMError
class ESP32S2ROM(ESP32ROM):
CHIP_NAME = "ESP32-S2"
IMAGE_CHIP_ID = 2
FPGA_SLOW_BOOT = False
IROM_MAP_START = 0x40080000
IROM_MAP_END = 0x40B80000
DROM_MAP_START = 0x3F000000
DROM_MAP_END = 0x3F3F0000
CHIP_DETECT_MAGIC_VALUE = [0x000007C6]
SPI_REG_BASE = 0x3F402000
SPI_USR_OFFS = 0x18
SPI_USR1_OFFS = 0x1C
SPI_USR2_OFFS = 0x20
SPI_MOSI_DLEN_OFFS = 0x24
SPI_MISO_DLEN_OFFS = 0x28
SPI_W0_OFFS = 0x58
MAC_EFUSE_REG = 0x3F41A044 # ESP32-S2 has special block for MAC efuses
UART_CLKDIV_REG = 0x3F400014
SUPPORTS_ENCRYPTED_FLASH = True
FLASH_ENCRYPTED_WRITE_ALIGN = 16
# todo: use espefuse APIs to get this info
EFUSE_BASE = 0x3F41A000
EFUSE_RD_REG_BASE = EFUSE_BASE + 0x030 # BLOCK0 read base address
EFUSE_BLOCK1_ADDR = EFUSE_BASE + 0x044
EFUSE_BLOCK2_ADDR = EFUSE_BASE + 0x05C
EFUSE_PURPOSE_KEY0_REG = EFUSE_BASE + 0x34
EFUSE_PURPOSE_KEY0_SHIFT = 24
EFUSE_PURPOSE_KEY1_REG = EFUSE_BASE + 0x34
EFUSE_PURPOSE_KEY1_SHIFT = 28
EFUSE_PURPOSE_KEY2_REG = EFUSE_BASE + 0x38
EFUSE_PURPOSE_KEY2_SHIFT = 0
EFUSE_PURPOSE_KEY3_REG = EFUSE_BASE + 0x38
EFUSE_PURPOSE_KEY3_SHIFT = 4
EFUSE_PURPOSE_KEY4_REG = EFUSE_BASE + 0x38
EFUSE_PURPOSE_KEY4_SHIFT = 8
EFUSE_PURPOSE_KEY5_REG = EFUSE_BASE + 0x38
EFUSE_PURPOSE_KEY5_SHIFT = 12
EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT_REG = EFUSE_RD_REG_BASE
EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT = 1 << 19
EFUSE_SPI_BOOT_CRYPT_CNT_REG = EFUSE_BASE + 0x034
EFUSE_SPI_BOOT_CRYPT_CNT_MASK = 0x7 << 18
EFUSE_SECURE_BOOT_EN_REG = EFUSE_BASE + 0x038
EFUSE_SECURE_BOOT_EN_MASK = 1 << 20
EFUSE_RD_REPEAT_DATA3_REG = EFUSE_BASE + 0x3C
EFUSE_RD_REPEAT_DATA3_REG_FLASH_TYPE_MASK = 1 << 9
PURPOSE_VAL_XTS_AES256_KEY_1 = 2
PURPOSE_VAL_XTS_AES256_KEY_2 = 3
PURPOSE_VAL_XTS_AES128_KEY = 4
UARTDEV_BUF_NO = 0x3FFFFD14 # Variable in ROM .bss which indicates the port in use
UARTDEV_BUF_NO_USB_OTG = 2 # Value of the above indicating that USB-OTG is in use
USB_RAM_BLOCK = 0x800 # Max block size USB-OTG is used
GPIO_STRAP_REG = 0x3F404038
GPIO_STRAP_SPI_BOOT_MASK = 0x8 # Not download mode
RTC_CNTL_OPTION1_REG = 0x3F408128
RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK = 0x1 # Is download mode forced over USB?
MEMORY_MAP = [
[0x00000000, 0x00010000, "PADDING"],
[0x3F000000, 0x3FF80000, "DROM"],
[0x3F500000, 0x3FF80000, "EXTRAM_DATA"],
[0x3FF9E000, 0x3FFA0000, "RTC_DRAM"],
[0x3FF9E000, 0x40000000, "BYTE_ACCESSIBLE"],
[0x3FF9E000, 0x40072000, "MEM_INTERNAL"],
[0x3FFB0000, 0x40000000, "DRAM"],
[0x40000000, 0x4001A100, "IROM_MASK"],
[0x40020000, 0x40070000, "IRAM"],
[0x40070000, 0x40072000, "RTC_IRAM"],
[0x40080000, 0x40800000, "IROM"],
[0x50000000, 0x50002000, "RTC_DATA"],
]
def get_pkg_version(self):
num_word = 4
return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 0) & 0x0F
def get_minor_chip_version(self):
hi_num_word = 3
hi = (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * hi_num_word)) >> 20) & 0x01
low_num_word = 4
low = (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * low_num_word)) >> 4) & 0x07
return (hi << 3) + low
def get_major_chip_version(self):
num_word = 3
return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 18) & 0x03
def get_flash_version(self):
num_word = 3
return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 21) & 0x0F
def get_flash_cap(self):
return self.get_flash_version()
def get_psram_version(self):
num_word = 3
return (self.read_reg(self.EFUSE_BLOCK1_ADDR + (4 * num_word)) >> 28) & 0x0F
def get_psram_cap(self):
return self.get_psram_version()
def get_block2_version(self):
# BLK_VERSION_MINOR
num_word = 4
return (self.read_reg(self.EFUSE_BLOCK2_ADDR + (4 * num_word)) >> 4) & 0x07
def get_chip_description(self):
chip_name = {
0: "ESP32-S2",
1: "ESP32-S2FH2",
2: "ESP32-S2FH4",
102: "ESP32-S2FNR2",
100: "ESP32-S2R2",
}.get(
self.get_flash_cap() + self.get_psram_cap() * 100,
"unknown ESP32-S2",
)
major_rev = self.get_major_chip_version()
minor_rev = self.get_minor_chip_version()
return f"{chip_name} (revision v{major_rev}.{minor_rev})"
def get_chip_features(self):
features = ["WiFi"]
if self.secure_download_mode:
features += ["Secure Download Mode Enabled"]
flash_version = {
0: "No Embedded Flash",
1: "Embedded Flash 2MB",
2: "Embedded Flash 4MB",
}.get(self.get_flash_cap(), "Unknown Embedded Flash")
features += [flash_version]
psram_version = {
0: "No Embedded PSRAM",
1: "Embedded PSRAM 2MB",
2: "Embedded PSRAM 4MB",
}.get(self.get_psram_cap(), "Unknown Embedded PSRAM")
features += [psram_version]
block2_version = {
0: "No calibration in BLK2 of efuse",
1: "ADC and temperature sensor calibration in BLK2 of efuse V1",
2: "ADC and temperature sensor calibration in BLK2 of efuse V2",
}.get(self.get_block2_version(), "Unknown Calibration in BLK2")
features += [block2_version]
return features
def get_crystal_freq(self):
# ESP32-S2 XTAL is fixed to 40MHz
return 40
def override_vddsdio(self, new_voltage):
raise NotImplementedInROMError(
"VDD_SDIO overrides are not supported for ESP32-S2"
)
def read_mac(self, mac_type="BASE_MAC"):
"""Read MAC from EFUSE region"""
if mac_type != "BASE_MAC":
return None
mac0 = self.read_reg(self.MAC_EFUSE_REG)
mac1 = self.read_reg(self.MAC_EFUSE_REG + 4) # only bottom 16 bits are MAC
bitstring = struct.pack(">II", mac1, mac0)[2:]
return tuple(bitstring)
def flash_type(self):
return (
1
if self.read_reg(self.EFUSE_RD_REPEAT_DATA3_REG)
& self.EFUSE_RD_REPEAT_DATA3_REG_FLASH_TYPE_MASK
else 0
)
def get_flash_crypt_config(self):
return None # doesn't exist on ESP32-S2
def get_secure_boot_enabled(self):
return (
self.read_reg(self.EFUSE_SECURE_BOOT_EN_REG)
& self.EFUSE_SECURE_BOOT_EN_MASK
)
def get_key_block_purpose(self, key_block):
if key_block < 0 or key_block > 5:
raise FatalError("Valid key block numbers must be in range 0-5")
reg, shift = [
(self.EFUSE_PURPOSE_KEY0_REG, self.EFUSE_PURPOSE_KEY0_SHIFT),
(self.EFUSE_PURPOSE_KEY1_REG, self.EFUSE_PURPOSE_KEY1_SHIFT),
(self.EFUSE_PURPOSE_KEY2_REG, self.EFUSE_PURPOSE_KEY2_SHIFT),
(self.EFUSE_PURPOSE_KEY3_REG, self.EFUSE_PURPOSE_KEY3_SHIFT),
(self.EFUSE_PURPOSE_KEY4_REG, self.EFUSE_PURPOSE_KEY4_SHIFT),
(self.EFUSE_PURPOSE_KEY5_REG, self.EFUSE_PURPOSE_KEY5_SHIFT),
][key_block]
return (self.read_reg(reg) >> shift) & 0xF
def is_flash_encryption_key_valid(self):
# Need to see either an AES-128 key or two AES-256 keys
purposes = [self.get_key_block_purpose(b) for b in range(6)]
if any(p == self.PURPOSE_VAL_XTS_AES128_KEY for p in purposes):
return True
return any(p == self.PURPOSE_VAL_XTS_AES256_KEY_1 for p in purposes) and any(
p == self.PURPOSE_VAL_XTS_AES256_KEY_2 for p in purposes
)
def uses_usb_otg(self):
"""
Check the UARTDEV_BUF_NO register to see if USB-OTG console is being used
"""
if self.secure_download_mode:
return False # can't detect native USB in secure download mode
return self.get_uart_no() == self.UARTDEV_BUF_NO_USB_OTG
def _post_connect(self):
if self.uses_usb_otg():
self.ESP_RAM_BLOCK = self.USB_RAM_BLOCK
def _check_if_can_reset(self):
"""
Check the strapping register to see if we can reset out of download mode.
"""
if os.getenv("ESPTOOL_TESTING") is not None:
print("ESPTOOL_TESTING is set, ignoring strapping mode check")
# Esptool tests over USB-OTG run with GPIO0 strapped low,
# don't complain in this case.
return
strap_reg = self.read_reg(self.GPIO_STRAP_REG)
force_dl_reg = self.read_reg(self.RTC_CNTL_OPTION1_REG)
if (
strap_reg & self.GPIO_STRAP_SPI_BOOT_MASK == 0
and force_dl_reg & self.RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK == 0
):
print(
"WARNING: {} chip was placed into download mode using GPIO0.\n"
"esptool.py can not exit the download mode over USB. "
"To run the app, reset the chip manually.\n"
"To suppress this note, set --after option to 'no_reset'.".format(
self.get_chip_description()
)
)
raise SystemExit(1)
def hard_reset(self):
uses_usb_otg = self.uses_usb_otg()
if uses_usb_otg:
self._check_if_can_reset()
print("Hard resetting via RTS pin...")
HardReset(self._port, uses_usb_otg)()
def change_baud(self, baud):
ESPLoader.change_baud(self, baud)
class ESP32S2StubLoader(ESP32S2ROM):
"""Access class for ESP32-S2 stub loader, runs on top of ROM.
(Basically the same as ESP32StubLoader, but different base class.
Can possibly be made into a mixin.)
"""
FLASH_WRITE_SIZE = 0x4000 # matches MAX_WRITE_BLOCK in stub_loader.c
STATUS_BYTES_LENGTH = 2 # same as ESP8266, different to ESP32 ROM
IS_STUB = True
def __init__(self, rom_loader):
self.secure_download_mode = rom_loader.secure_download_mode
self._port = rom_loader._port
self._trace_enabled = rom_loader._trace_enabled
self.cache = rom_loader.cache
self.flush_input() # resets _slip_reader
if rom_loader.uses_usb_otg():
self.ESP_RAM_BLOCK = self.USB_RAM_BLOCK
self.FLASH_WRITE_SIZE = self.USB_RAM_BLOCK
ESP32S2ROM.STUB_CLASS = ESP32S2StubLoader
| 10,851 | Python | .py | 251 | 34.808765 | 87 | 0.622853 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,627 | esp32c6.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/__pycache__/esp32c6.cpython-310.pyc | o
’jÂdP ã @ sN d dl Z ddlmZ ddlmZmZ G dd„ deƒZG dd „ d eƒZee_dS )
é Né )Ú
ESP32C3ROMé )Ú
FatalErrorÚNotImplementedInROMErrorc @ sÊ e Zd ZdZdZdZdZdZdZdZ dZ
dgZ d Z d
Z
d Zd Zd
ZdZdZdZdZed Zed Zed Zed Zd
Zed Zd Zed Z dZ ed Z dZ ed Z dZ!ed Z"dZ#eZ$dZ%ed Z&dZ'ed Z(dZ)dZ*dZ+d Z,d Z-d Z.d Z/e/d Z0e/d
Z1e/d Z2d Z3e/d Z4d!Z5ddd"d#œZ6g d$¢g d%¢g d&¢g d'¢g d(¢g d)¢g d*¢g d+¢g d,¢g d-¢g d.¢g Z7d/d0„ Z8d1d2„ Z9d3d4„ Z:d5d6„ Z;d7d8„ Z<d9d:„ Z=d;d<„ Z>dId>d?„Z?d@dA„ Z@dBdC„ ZAdDdE„ ZBdFdG„ ZCdHS )JÚ
ESP32C6ROMzESP32-C6é
Fé Bé €Bé Cr io€à,i 0 `é é é é$ é( éX i| `i `éD é0 é4 é8 é é é i i Té i€õ‡@é i `i i¡:ØPr )Ú80mÚ40mÚ20m)r i ÚPADDING)r
r ÚDROM)é €@é ˆ@ÚDRAM)r r! ÚBYTE_ACCESSIBLE)é ¬@i @Ú DROM_MASK)i @r$ Ú IROM_MASK)r r
ÚIROM)r r! ÚIRAM)é Pé @ PÚRTC_IRAM)r) r* ÚRTC_DRAM)i à`i `Ú
MEM_INTERNAL2c C ó d}| | jd| ¡d? d@ S )Nr r r é ©Úread_regÚEFUSE_BLOCK1_ADDR©ÚselfÚnum_word© r6 ú7/home/ceco/Downloads/esptool/esptool/targets/esp32c6.pyÚget_pkg_versionh ó zESP32C6ROM.get_pkg_versionc C r. )Nr r é é r0 r3 r6 r6 r7 Úget_minor_chip_versionl r9 z!ESP32C6ROM.get_minor_chip_versionc C s d}| | jd| ¡d? d@ S )Nr r é r0 r3 r6 r6 r7 Úget_major_chip_versionp r9 z!ESP32C6ROM.get_major_chip_versionc C s< dddœ | ¡ d¡}| ¡ }| ¡ }|› d|› d|› d�S )NzESP32-C6 (QFN40)zESP32-C6FH4 (QFN32))r r zunknown ESP32-C6z (revision vÚ.ú))Úgetr8 r> r< )r4 Ú chip_nameÚ major_revÚ minor_revr6 r6 r7 Úget_chip_descriptiont s ş ız ESP32C6ROM.get_chip_descriptionc C s g d¢S )N)zWiFi 6zBT 5z IEEE802.15.4r6 ©r4 r6 r6 r7 Úget_chip_features} s z ESP32C6ROM.get_chip_featuresc C s dS )Nr r6 rF r6 r6 r7 Úget_crystal_freq€ s zESP32C6ROM.get_crystal_freqc C s t dƒ‚)Nz1VDD_SDIO overrides are not supported for ESP32-C6)r )r4 Ú new_voltager6 r6 r7 Úoverride_vddsdio„ s ÿzESP32C6ROM.override_vddsdioÚBASE_MACc C s† | | j¡}| | jd ¡}t d||¡dd… }t d|d? d@ ¡}|dd … | |d d
… }t|ƒt|ƒt|ƒd œ}| |d¡S ) zRead MAC from EFUSE regionr z>IIr Nz>Hr iÿÿ r r é )rK ÚEUI64ÚMAC_EXT)r1 Ú
MAC_EFUSE_REGÚstructÚpackÚtuplerA )r4 Úmac_typeÚmac0Úmac1Úbase_macÚext_macÚeui64Úmacsr6 r6 r7 Úread_mac‰ s ı zESP32C6ROM.read_macc C s d S ©Nr6 rF r6 r6 r7 Úget_flash_crypt_configš s z!ESP32C6ROM.get_flash_crypt_configc C s | | j¡| j@ S r[ )r1 ÚEFUSE_SECURE_BOOT_EN_REGÚEFUSE_SECURE_BOOT_EN_MASKrF r6 r6 r7 Úget_secure_boot_enabled� s
ÿÿz"ESP32C6ROM.get_secure_boot_enabledc C sr |dk s|dkr t dƒ‚| j| jf| j| jf| j| jf| j| jf| j | j
f| j | j fg| \}}|
|¡|? d@ S )Nr é z,Valid key block numbers must be in range 0-5r; )r ÚEFUSE_PURPOSE_KEY0_REGÚEFUSE_PURPOSE_KEY0_SHIFTÚEFUSE_PURPOSE_KEY1_REGÚEFUSE_PURPOSE_KEY1_SHIFTÚEFUSE_PURPOSE_KEY2_REGÚEFUSE_PURPOSE_KEY2_SHIFTÚEFUSE_PURPOSE_KEY3_REGÚEFUSE_PURPOSE_KEY3_SHIFTÚEFUSE_PURPOSE_KEY4_REGÚEFUSE_PURPOSE_KEY4_SHIFTÚEFUSE_PURPOSE_KEY5_REGÚEFUSE_PURPOSE_KEY5_SHIFTr1 )r4 Ú key_blockÚregÚshiftr6 r6 r7 Úget_key_block_purpose£ s
úùz ESP32C6ROM.get_key_block_purposec s, ‡ fdd„t dƒD ƒ}t‡ fdd„|D ƒƒS )Nc s g | ]}ˆ |¡‘qS r6 )rp )Ú.0ÚbrF r6 r7 Ú
<listcomp>³ s z<ESP32C6ROM.is_flash_encryption_key_valid.<locals>.<listcomp>rL c 3 s � | ]}|ˆ j kV qd S r[ )ÚPURPOSE_VAL_XTS_AES128_KEY)rq ÚprF r6 r7 Ú <genexpr>µ s € z;ESP32C6ROM.is_flash_encryption_key_valid.<locals>.<genexpr>)ÚrangeÚany)r4 Úpurposesr6 rF r7 Ú is_flash_encryption_key_valid± s z(ESP32C6ROM.is_flash_encryption_key_validN)rK )DÚ__name__Ú
__module__Ú __qualname__Ú CHIP_NAMEÚ
IMAGE_CHIP_IDÚFPGA_SLOW_BOOTÚIROM_MAP_STARTÚ IROM_MAP_ENDÚDROM_MAP_STARTÚ DROM_MAP_ENDÚBOOTLOADER_FLASH_OFFSETÚCHIP_DETECT_MAGIC_VALUEÚ SPI_REG_BASEÚ SPI_USR_OFFSÚ
SPI_USR1_OFFSÚ
SPI_USR2_OFFSÚSPI_MOSI_DLEN_OFFSÚSPI_MISO_DLEN_OFFSÚ SPI_W0_OFFSÚUART_DATE_REG_ADDRÚ
EFUSE_BASEr2 rO ÚEFUSE_RD_REG_BASEra rb rc rd re rf rg rh ri rj rk rl Ú%EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT_REGÚ!EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPTÚ EFUSE_SPI_BOOT_CRYPT_CNT_REGÚ EFUSE_SPI_BOOT_CRYPT_CNT_MASKr] r^ rt ÚSUPPORTS_ENCRYPTED_FLASHÚFLASH_ENCRYPTED_WRITE_ALIGNÚUARTDEV_BUF_NOÚ UARTDEV_BUF_NO_USB_JTAG_SERIALÚDR_REG_LP_WDT_BASEÚRTC_CNTL_WDTCONFIG0_REGÚRTC_CNTL_WDTWPROTECT_REGÚRTC_CNTL_SWD_CONF_REGÚRTC_CNTL_SWD_AUTO_FEED_ENÚRTC_CNTL_SWD_WPROTECT_REGÚRTC_CNTL_SWD_WKEYÚFLASH_FREQUENCYÚ
MEMORY_MAPr8 r< r> rE rG rH rJ rZ r\ r_ rp rz r6 r6 r6 r7 r s ıõ
r c @ s$ e Zd ZdZdZdZdZdd„ ZdS )ÚESP32C6StubLoaderzAccess class for ESP32C6 stub loader, runs on top of ROM.
(Basically the same as ESP32StubLoader, but different base class.
Can possibly be made into a mixin.)
i @ r Tc C s, |j | _ |j| _|j| _|j| _| ¡ d S r[ )Úsecure_download_modeÚ_portÚ_trace_enabledÚcacheÚ flush_input)r4 Ú
rom_loaderr6 r6 r7 Ú__init__Ã s
zESP32C6StubLoader.__init__N)r{ r| r} Ú__doc__ÚFLASH_WRITE_SIZEÚSTATUS_BYTES_LENGTHÚIS_STUBr© r6 r6 r6 r7 r¢ ¸ s r¢ ) rP Úesp32c3r Úutilr r r r¢ Ú
STUB_CLASSr6 r6 r6 r7 Ú<module> s -
| 6,447 | Python | .py | 33 | 193.939394 | 1,620 | 0.529467 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,628 | esp8266.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/__pycache__/esp8266.cpython-310.pyc | o
’jÂd¢ ã @ sF d dl mZ d dlmZmZ G dd„ deƒZG dd„ deƒZee_dS )é )Ú ESPLoader)Ú
FatalErrorÚNotImplementedInROMErrorc
sò e Zd ZdZdZdZdgZdZdZdZ dZ
d Z d
Z d Z
d Zd Zd
ZdZdZddd
dd
dddddœ ZdddddœZdZg d¢g d ¢g d ¢g d ¢gZd d „ Zd!d"„ Zd#d$„ Zd%d&„ Z‡ fd'd(„Z‡ fd)d*„Z d+d,„ Z d4d.d/„Z d0d1„ Z d2d3„ Z ‡ Z!S )5Ú
ESP8266ROMz'Access class for ESP8266 ROM bootloaderÚESP8266Fl Aá éP ð?éT ð?é\ ð?i `é é é$ Né@ i `r é é é0 éP é` é€ é� ) Ú512KBÚ256KBÚ1MBÚ2MBÚ4MBz2MB-c1z4MB-c1Ú8MBÚ16MBé é )Ú80mÚ40mÚ26mÚ20m)i ð?i ð?ÚDPORT)i €þ?i @ÚDRAM)i @i €@ÚIRAM)i @i.@ÚIROMc C sD | d¡d> }|| d¡d> O }|| d¡d> O }|| d¡O }|S )Nr r iX ð?r
r r r )Úread_reg)ÚselfÚresult© r) ú7/home/ceco/Downloads/esptool/esptool/targets/esp8266.pyÚ
get_efuses? s
zESP8266ROM.get_efusesc C st |d@ dk}|d@ dk}|d@ dk}|d@ dk}|r(|s(|s"|s"dS |s(|r(dS |s8|r8|s2|s2dS |s8|r8dS d S )
Nr r l l l r r é éÿÿÿÿr) )r' ÚefusesÚr0_4Úr3_25Úr3_26Úr3_27r) r) r* Ú_get_flash_sizeG s zESP8266ROM._get_flash_sizec C sX | ¡ }|d@ dk}|r*| |¡}|d@ dk}|rdnd|r dnddœ |d ¡}|S d
S ) Nl r r Ú
ESP8285H08Ú
ESP8285N08Ú
ESP8285H16Ú
ESP8285N16)r r ÚESP8285Ú ESP8266EX)r+ r3 Úget)r' r. Úis_8285Ú
flash_sizeÚmax_tempÚ chip_namer) r) r* Úget_chip_descriptionZ s þ
þ
þýz ESP8266ROM.get_chip_descriptionc C s dg}d| ¡ v r|dg7 }|S )NÚWiFir8 zEmbedded Flash)r? )r' Úfeaturesr) r) r* Úget_chip_featuresk s
z ESP8266ROM.get_chip_featuresc s* | j r
tt| ƒ |¡ d S | dd¡ d S )Nr )ÚIS_STUBÚsuperr Úflash_spi_attachÚ flash_begin)r' Úhspi_arg©Ú __class__r) r* rE q s zESP8266ROM.flash_spi_attachc s | j r
tt| ƒ |¡ d S d S ©N)rC rD r Úflash_set_parameters)r' ÚsizerH r) r* rK y s ÿz ESP8266ROM.flash_set_parametersc C s, | | j¡}| | j¡}|d? |d@ d> B S )z_
Read Chip ID from efuse - the equivalent of the SDK system_get_chip_id() func
é iÿÿÿ é )r& Ú ESP_OTP_MAC0Ú ESP_OTP_MAC1)r' Úid0Úid1r) r) r* Úchip_id~ s zESP8266ROM.chip_idÚBASE_MACc C s® |dkrdS | | j¡}| | j¡}| | j¡}|dkr,|d? d@ |d? d@ |d@ f}n|d? d@ dkr7d}n|d? d@ dkrBd }ntd
ƒ‚||d? d@ |d@ |d ? d@ f S ) zRead MAC from OTP ROMrT Nr r éÿ rN )rM éþ é4 r )é¬ éÐ ét z Unknown OUIrM )r& rO rP Ú ESP_OTP_MAC3r )r' Úmac_typeÚmac0Úmac1Úmac3Úouir) r) r* Úread_mac† s "zESP8266ROM.read_macc C sb d}| j }|| d | }|| }||| }||k r |}|d| k r+|d d | S || | S )ztCalculate an erase size given a specific size in bytes.
Provides a workaround for the bootloader erase bug.r r r )ÚFLASH_SECTOR_SIZE)r' ÚoffsetrL Úsectors_per_blockÚ sector_sizeÚ num_sectorsÚ start_sectorÚ head_sectorsr) r) r* Úget_erase_size— s zESP8266ROM.get_erase_sizec C s t dƒ‚)Nz0Overriding VDDSDIO setting only applies to ESP32)r )r' Ú new_voltager) r) r* Úoverride_vddsdioª s ÿzESP8266ROM.override_vddsdio)rT )"Ú__name__Ú
__module__Ú __qualname__Ú__doc__Ú CHIP_NAMErC ÚCHIP_DETECT_MAGIC_VALUErO rP r[ Ú SPI_REG_BASEÚ SPI_USR_OFFSÚ
SPI_USR1_OFFSÚ
SPI_USR2_OFFSÚSPI_MOSI_DLEN_OFFSÚSPI_MISO_DLEN_OFFSÚ SPI_W0_OFFSÚUART_CLKDIV_REGÚXTAL_CLK_DIVIDERÚ FLASH_SIZESÚFLASH_FREQUENCYÚBOOTLOADER_FLASH_OFFSETÚ
MEMORY_MAPr+ r3 r? rB rE rK rS ra ri rk Ú
__classcell__r) r) rH r* r
s` ÷
üü
r c @ s( e Zd ZdZdZdZdd„ Zdd„ ZdS ) ÚESP8266StubLoaderz9Access class for ESP8266 stub loader, runs on top of ROM.i @ Tc C s, |j | _ |j| _|j| _|j| _| ¡ d S rJ )Úsecure_download_modeÚ_portÚ_trace_enabledÚcacheÚ flush_input)r' Ú
rom_loaderr) r) r* Ú__init__¶ s
zESP8266StubLoader.__init__c C s |S rJ r) )r' rc rL r) r) r* ri ½ s z ESP8266StubLoader.get_erase_sizeN)rl rm rn ro ÚFLASH_WRITE_SIZErC r‡ ri r) r) r) r* r€ ° s r€ N)Úloaderr Úutilr r r r€ Ú
STUB_CLASSr) r) r) r* Ú<module> s '
| 5,153 | Python | .py | 33 | 154.363636 | 550 | 0.460156 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,629 | esp32c2.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/__pycache__/esp32c2.cpython-310.pyc | o
’jÂd‰ ã @ sR d dl Z d dlZddlmZ ddlmZ G dd„ deƒZG dd „ d eƒZee_dS )
é Né )Ú
ESP32C3ROMé )Ú ESPLoaderc @ s e Zd ZdZdZdZdZdZdZddgZ d Z
e
d
Z e
d
Z e
d Z
d Ze
d Zd
Ze
d Zd
Ze
d ZdZe
d Ze
d ZdZdddddœZg d¢g d¢g d¢g d¢g d¢g d¢g d ¢g d ¢gZd d „ Zd d!„ Zd"d#„ Z d$d%„ Z d&d'„ Z d(d)„ Z d*d+„ Z d,d-„ Z!d.S )/Ú
ESP32C2ROMúESP32-C2é é Bé @Bé <é @<io0Qoio A|i ˆ `é@ é0 i i i é` é é r r r )Ú60mÚ30mÚ20mÚ15m)r i ÚPADDING)r r ÚDROM)i Ê?i Î?ÚDRAM)i €È?i Ð?ÚBYTE_ACCESSIBLE)i ð?i õ?Ú DROM_MASK)i @i @Ú IROM_MASK)r r
ÚIROM)i À7@i <@ÚIRAMc C ó d}| | jd| ¡d? d@ S )Nr é é é ©Úread_regÚEFUSE_BLOCK2_ADDR©ÚselfÚnum_word© r( ú7/home/ceco/Downloads/esptool/esptool/targets/esp32c2.pyÚget_pkg_version@ ó zESP32C2ROM.get_pkg_versionc C s< dddœ | ¡ d¡}| ¡ }| ¡ }|› d|› d|› d�S )Nr )r r zunknown ESP32-C2z (revision vÚ.ú))Úgetr* Úget_major_chip_versionÚget_minor_chip_version)r& Ú chip_nameÚ major_revÚ minor_revr( r( r) Úget_chip_descriptionD s þ ýz ESP32C2ROM.get_chip_descriptionc C r )Nr r é r r" r% r( r( r) r0 M r+ z!ESP32C2ROM.get_minor_chip_versionc C r )Nr r é r r" r% r( r( r) r/ Q r+ z!ESP32C2ROM.get_major_chip_versionc C s
t | ¡S ©N)r Úget_crystal_freq©r& r( r( r) r8 U s
zESP32C2ROM.get_crystal_freqc C s‚ | j o | ¡ dk}|r9|d d }td|› �ƒ | | jt d|d¡¡ tdƒ | |¡ t d¡ |
¡ d S t | |¡ d S )Né é( zChanging baud rate to z<IIr zChanged.gš™™™™™©?)
ÚIS_STUBr8 ÚprintÚcommandÚESP_CHANGE_BAUDRATEÚstructÚpackÚ_set_port_baudrateÚtimeÚsleepÚ flush_inputr Ú change_baud)r& ÚbaudÚrom_with_26M_XTALÚfalse_rom_baudr( r( r) rF Y s ÿ
zESP32C2ROM.change_baudc C s* | j s| ¡ dkrd| _d| _d S d S d S )Nr TF)Úsecure_download_modeÚget_chip_revisionÚstub_is_disabledr< r9 r( r( r) Ú
_post_connecto s
þzESP32C2ROM._post_connectc C s˜ | | j¡| j@ }| | j¡| j@ }|r|dkn|dk}|r dS |r'dgd ndgd }tt|ƒƒD ]}| | j|d ¡||< || dkrI dS q2dS )Nr r Tr r! r F)r# Ú EFUSE_XTS_KEY_LENGTH_256_REGÚEFUSE_XTS_KEY_LENGTH_256ÚEFUSE_RD_DIS_REGÚ EFUSE_RD_DISÚrangeÚlenÚEFUSE_BLOCK_KEY0_REG)r& Ú key_len_256Úword0Ú
rd_disableÚkey_wordÚir( r( r) Ú is_flash_encryption_key_validw s
ÿÿ ÿz(ESP32C2ROM.is_flash_encryption_key_validN)"Ú__name__Ú
__module__Ú __qualname__Ú CHIP_NAMEÚ
IMAGE_CHIP_IDÚIROM_MAP_STARTÚ IROM_MAP_ENDÚDROM_MAP_STARTÚ DROM_MAP_ENDÚCHIP_DETECT_MAGIC_VALUEÚ
EFUSE_BASEr$ Ú
MAC_EFUSE_REGÚEFUSE_SECURE_BOOT_EN_REGÚEFUSE_SECURE_BOOT_EN_MASKÚ EFUSE_SPI_BOOT_CRYPT_CNT_REGÚ EFUSE_SPI_BOOT_CRYPT_CNT_MASKÚ%EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT_REGÚ!EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPTrN rO rT rP rQ ÚFLASH_FREQUENCYÚ
MEMORY_MAPr* r4 r0 r/ r8 rF rM rZ r( r( r( r) r
sZ üø r c @ s$ e Zd ZdZdZdZdZdd„ ZdS )ÚESP32C2StubLoaderzAccess class for ESP32C2 stub loader, runs on top of ROM.
(Basically the same as ESP32StubLoader, but different base class.
Can possibly be made into a mixin.)
i @ r Tc C s, |j | _ |j| _|j| _|j| _| ¡ d S r7 )rJ Ú_portÚ_trace_enabledÚcacherE )r& Ú
rom_loaderr( r( r) Ú__init__� s
zESP32C2StubLoader.__init__N)r[ r\ r] Ú__doc__ÚFLASH_WRITE_SIZEÚSTATUS_BYTES_LENGTHr< rt r( r( r( r) ro ’ s ro ) r@ rC Úesp32c3r Úloaderr r ro Ú
STUB_CLASSr( r( r( r) Ú<module> s
| 4,313 | Python | .py | 36 | 118.388889 | 906 | 0.485855 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,630 | esp32s3beta2.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/__pycache__/esp32s3beta2.cpython-310.pyc | o
’jÂd| ã @ s6 d dl mZ G dd„ deƒZG dd„ deƒZee_dS )é )Ú
ESP32S3ROMc @ s e Zd ZdZdZdgZdZdS )ÚESP32S3BETA2ROMzESP32-S3(beta2)é l 6A V i `N)Ú__name__Ú
__module__Ú __qualname__Ú CHIP_NAMEÚ
IMAGE_CHIP_IDÚCHIP_DETECT_MAGIC_VALUEÚ
EFUSE_BASE© r r ú</home/ceco/Downloads/esptool/esptool/targets/esp32s3beta2.pyr s
r c @ s$ e Zd ZdZdZdZdZdd„ ZdS )ÚESP32S3BETA2StubLoaderzAccess class for ESP32S3 stub loader, runs on top of ROM.
(Basically the same as ESP32StubLoader, but different base class.
Can possibly be made into a mixin.)
i @ é Tc C s, |j | _ |j| _|j| _|j| _| ¡ d S )N)Úsecure_download_modeÚ_portÚ_trace_enabledÚcacheÚ flush_input)ÚselfÚ
rom_loaderr r r
Ú__init__ s
z ESP32S3BETA2StubLoader.__init__N)r r r Ú__doc__ÚFLASH_WRITE_SIZEÚSTATUS_BYTES_LENGTHÚIS_STUBr r r r r
r s r N)Úesp32s3r r r Ú
STUB_CLASSr r r r
Ú<module> s
| 1,179 | Python | .py | 13 | 88.538462 | 205 | 0.517153 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,631 | esp32s3.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/__pycache__/esp32s3.cpython-310.pyc | o
’jÂd 4 ã @ sn d dl Z d dlZddlmZ ddlmZ ddlmZ ddlm Z m
Z
G dd „ d eƒZ G d
d „ d e ƒZ e e _
dS ) é Né )ÚESP32ROMé )Ú ESPLoader)Ú HardReset)Ú
FatalErrorÚNotImplementedInROMErrorc
@ sˆ e Zd ZdZdZdgZdZdZdZdZ dZ
dZ d Z d
Z
d Zd Zd
ZdZdZdZdZdZdZed Zed Zed Zed Zed Zd
Z ed Z d Z ed Z dZ ed Z!dZ"ed Z#dZ$ed Z%dZ&eZ'd Z(ed Z)d Z*ed Z+d Z,ed Z-d Z.d Z/d!Z0dZ1d"Z2d!Z3dZ4d#Z5e5d$ Z6d%Z7e5d& Z8d'Z9e5d( Z:e5d) Z;d*Z<d+Z=d,Z>d[email protected]/ZBg d0¢g d1¢g d2¢g d3¢g d4¢g d5¢g d6¢g d7¢g d8¢g d9¢g d:¢g d;¢g ZCd<d=„ ZDd>d?„ ZEd@dA„ ZFdBdC„ ZGdDdE„ ZHdFdG„ ZIdHdI„ ZJdJdK„ ZKdLdM„ ZLdNdO„ ZMdPdQ„ ZNdRdS„ ZOdTdU„ ZPdVdW„ ZQdXdY„ ZRdZd[„ ZSd\d]„ ZTd^d_„ ZUd`da„ ZVdbdc„ ZWdxdedf„ZXdgdh„ ZYdidj„ ZZdkdl„ Z[dmdn„ Z\dodp„ Z]dqdr„ Z^dsdt„ Z_dudv„ Z`dwS )yÚ
ESP32S3ROMzESP32-S3é Fé Bi Dé <é >i€ `i `é é é é$ é( éX r Té i p `éD é\ é0 é4 é8 é é é i i é< i r é iLñÎ?i € `é´ l é¸ l *1: é˜ é° i¡:ØPi i8@ `i,� `r i `)r i ÚPADDING)r é =ÚDROM)r$ r
Ú EXTRAM_DATA)é à`é `ÚRTC_DRAM)é €È?é Ð?ÚBYTE_ACCESSIBLE)r* i >@Ú MEM_INTERNAL)r* r+ ÚDRAM)i @i ¡@Ú IROM_MASK)i 7@i >@ÚIRAM)r' r( ÚRTC_IRAM)r i €BÚIROM)i Pi PÚRTC_DATAc C ó d}| | jd| ¡d? d@ S )Nr r é é ©Úread_regÚEFUSE_BLOCK1_ADDR©ÚselfÚnum_word© r= ú7/home/ceco/Downloads/esptool/esptool/targets/esp32s3.pyÚget_pkg_versionx ó zESP32S3ROM.get_pkg_versionc C s$ |d@ dko| ¡ dko| ¡ dkS )Nr6 r r )Úget_blk_version_majorÚget_blk_version_minor©r; Ú minor_rawr= r= r> Úis_eco0| s
ÿ
ýzESP32S3ROM.is_eco0c C s | ¡ }| |¡r dS |S ©Nr )Úget_raw_minor_chip_versionrE rC r= r= r> Úget_minor_chip_version† s
z!ESP32S3ROM.get_minor_chip_versionc C sL d}| | jd| ¡d? d@ }d}| | jd| ¡d? d@ }|d> | S )Né r é r r é r6 r7 )r; Ú hi_num_wordÚhiÚ low_num_wordÚlowr= r= r> rG Œ s
z%ESP32S3ROM.get_raw_minor_chip_versionc C s d}| | jd| ¡d? d@ S )Nr r r )r8 ÚEFUSE_BLOCK2_ADDRr: r= r= r> rA “ r@ z ESP32S3ROM.get_blk_version_majorc C r4 )Nr r r r6 r7 r: r= r= r> rB — r@ z ESP32S3ROM.get_blk_version_minorc C s | ¡ }| |¡r dS | ¡ S rF )rG rE Úget_raw_major_chip_versionrC r= r= r> Úget_major_chip_version› s
z!ESP32S3ROM.get_major_chip_versionc C r4 )NrI r r r r7 r: r= r= r> rQ ¡ r@ z%ESP32S3ROM.get_raw_major_chip_versionc C s@ | ¡ }| ¡ }| ¡ }dddœ |d¡}|› d|› d|› d�S )NzESP32-S3 (QFN56)zESP32-S3-PICO-1 (LGA56))r r zunknown ESP32-S3z (revision vÚ.ú))rR rH r? Úget)r; Ú major_revÚ minor_revÚ pkg_versionÚ chip_namer= r= r> Úget_chip_description¥ s þýz ESP32S3ROM.get_chip_descriptionc C r4 )Nr r é r6 r7 r: r= r= r> Ú
get_flash_cap± r@ zESP32S3ROM.get_flash_capc C s8 d}| | jd| ¡d? d@ }dddddd œ |d
¡S ) Nr r r6 ÚXMCÚGDÚFMÚTTÚBY)r r r r rI Ú ©r8 r9 rU ©r; r< Ú vendor_idr= r= r> Úget_flash_vendorµ s zESP32S3ROM.get_flash_vendorc C s d}| | jd| ¡d? d@ S )Nr r r7 r: r= r= r> Ú
get_psram_capº r@ zESP32S3ROM.get_psram_capc C s2 d}| | jd| ¡d? d@ }dddœ |d¡S )Nr r6 r ÚAP_3v3ÚAP_1v8)r r rb rc rd r= r= r> Úget_psram_vendor¾ s zESP32S3ROM.get_psram_vendorc C s€ ddg}d dddœ | ¡ d¡}|d ur!||d| ¡ › d� g7 }d d d
dœ | ¡ d ¡}|d ur>||d| ¡ › d� g7 }|S ) NÚWiFiÚBLEzEmbedded Flash 8MBzEmbedded Flash 4MB)r r r zUnknown Embedded Flashz (rT zEmbedded PSRAM 8MBzEmbedded PSRAM 2MBzUnknown Embedded PSRAM)rU r\ rf rg rj )r; ÚfeaturesÚflashÚpsramr= r= r> Úget_chip_featuresà s$ ý üý üz ESP32S3ROM.get_chip_featuresc C s dS )Nr r= ©r; r= r= r> Úget_crystal_freqØ s zESP32S3ROM.get_crystal_freqc C s d S ©Nr= rq r= r= r> Úget_flash_crypt_configÜ s z!ESP32S3ROM.get_flash_crypt_configc C sr |dk s|dkr t dƒ‚| j| jf| j| jf| j| jf| j| jf| j | j
f| j | j fg| \}}|
|¡|? d@ S )Nr rI z,Valid key block numbers must be in range 0-5é )r ÚEFUSE_PURPOSE_KEY0_REGÚEFUSE_PURPOSE_KEY0_SHIFTÚEFUSE_PURPOSE_KEY1_REGÚEFUSE_PURPOSE_KEY1_SHIFTÚEFUSE_PURPOSE_KEY2_REGÚEFUSE_PURPOSE_KEY2_SHIFTÚEFUSE_PURPOSE_KEY3_REGÚEFUSE_PURPOSE_KEY3_SHIFTÚEFUSE_PURPOSE_KEY4_REGÚEFUSE_PURPOSE_KEY4_SHIFTÚEFUSE_PURPOSE_KEY5_REGÚEFUSE_PURPOSE_KEY5_SHIFTr8 )r; Ú key_blockÚregÚshiftr= r= r> Úget_key_block_purposeß s
úùz ESP32S3ROM.get_key_block_purposec s\ ‡ fdd„t dƒD ƒ}t‡ fdd„|D ƒƒrdS t‡ fdd„|D ƒƒo-t‡ fdd„|D ƒƒS ) Nc s g | ]}ˆ |¡‘qS r= )r… )Ú.0Úbrq r= r> Ú
<listcomp>ï s z<ESP32S3ROM.is_flash_encryption_key_valid.<locals>.<listcomp>é c 3 ó � | ]}|ˆ j kV qd S rs )ÚPURPOSE_VAL_XTS_AES128_KEY©r† Úprq r= r> Ú <genexpr>ñ ó € z;ESP32S3ROM.is_flash_encryption_key_valid.<locals>.<genexpr>Tc 3 rŠ rs )Ú PURPOSE_VAL_XTS_AES256_KEY_1rŒ rq r= r> rŽ ô r� c 3 rŠ rs )Ú PURPOSE_VAL_XTS_AES256_KEY_2rŒ rq r= r> rŽ ô s €
ÿ)ÚrangeÚany)r; Úpurposesr= rq r> Ú is_flash_encryption_key_validí s "ÿz(ESP32S3ROM.is_flash_encryption_key_validc C s | | j¡| j@ S rs )r8 ÚEFUSE_SECURE_BOOT_EN_REGÚEFUSE_SECURE_BOOT_EN_MASKrq r= r= r> Úget_secure_boot_enabledø s
ÿÿz"ESP32S3ROM.get_secure_boot_enabledc C s t dƒ‚)Nz1VDD_SDIO overrides are not supported for ESP32-S3)r )r; Ú new_voltager= r= r> Úoverride_vddsdioþ s ÿzESP32S3ROM.override_vddsdioÚBASE_MACc C sF |dkrdS | | j¡}| | jd ¡}t d||¡dd… }t|ƒS )zRead MAC from EFUSE regionr› Nr z>IIr )r8 Ú
MAC_EFUSE_REGÚstructÚpackÚtuple)r; Úmac_typeÚmac0Úmac1Ú bitstringr= r= r> Úread_mac s zESP32S3ROM.read_macc C s | | j¡| j@ r dS dS )Nr r )r8 ÚEFUSE_RD_REPEAT_DATA3_REGÚ)EFUSE_RD_REPEAT_DATA3_REG_FLASH_TYPE_MASKrq r= r= r> Ú
flash_type s
ÿÿÿüzESP32S3ROM.flash_typec C ó | j rdS | ¡ | jkS )z[
Check the UARTDEV_BUF_NO register to see if USB-OTG console is being used
F)Úsecure_download_modeÚ get_uart_noÚUARTDEV_BUF_NO_USB_OTGrq r= r= r> Ú uses_usb_otg ó zESP32S3ROM.uses_usb_otgc C r¨ )z[
Check the UARTDEV_BUF_NO register to see if USB-JTAG/Serial is being used
F)r© rª Ú UARTDEV_BUF_NO_USB_JTAG_SERIALrq r= r= r> Úuses_usb_jtag_serial r z ESP32S3ROM.uses_usb_jtag_serialc C sv | ¡ r9| | j| j¡ | | jd¡ | | jd¡ | | j| j¡ | | j| | j¡| j B ¡ | | jd¡ d S d S rF )
r¯ Ú write_regÚRTC_CNTL_WDTWPROTECT_REGÚRTC_CNTL_WDT_WKEYÚRTC_CNTL_WDTCONFIG0_REGÚRTC_CNTL_SWD_WPROTECT_REGÚRTC_CNTL_SWD_WKEYÚRTC_CNTL_SWD_CONF_REGr8 ÚRTC_CNTL_SWD_AUTO_FEED_ENrq r= r= r> Údisable_watchdogs$ s
ÿþóz ESP32S3ROM.disable_watchdogsc C s& | ¡ r| j| _| js| ¡ d S d S rs )r¬ Ú
USB_RAM_BLOCKÚ
ESP_RAM_BLOCKÚsync_stub_detectedr¸ rq r= r= r> Ú
_post_connect6 s
ÿzESP32S3ROM._post_connectc C sp t d¡dur
tdƒ dS | | j¡}| | j¡}|| j@ dkr4|| j@ dkr6td | ¡ ¡ƒ t
dƒ‚dS dS )z[
Check the strapping register to see if we can reset out of download mode.
ÚESPTOOL_TESTINGNz5ESPTOOL_TESTING is set, ignoring strapping mode checkr zÑWARNING: {} chip was placed into download mode using GPIO0.
esptool.py can not exit the download mode over USB. To run the app, reset the chip manually.
To suppress this note, set --after option to 'no_reset'.r ) ÚosÚgetenvÚprintr8 ÚGPIO_STRAP_REGÚRTC_CNTL_OPTION1_REGÚGPIO_STRAP_SPI_BOOT_MASKÚ!RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASKÚformatrZ Ú
SystemExit)r; Ú strap_regÚ force_dl_regr= r= r> Ú_check_if_can_reset< s" ÿ þÿüôz ESP32S3ROM._check_if_can_resetc C s. | ¡ }|r
| ¡ tdƒ t| j|ƒƒ d S )Nz Hard resetting via RTS pin...)r¬ rÉ rÀ r Ú_port)r; r¬ r= r= r> Ú
hard_resetU s
zESP32S3ROM.hard_resetc C s t | |¡ d S rs )r Ú change_baud)r; Úbaudr= r= r> rÌ ] s zESP32S3ROM.change_baudN)r› )aÚ__name__Ú
__module__Ú __qualname__Ú CHIP_NAMEÚ
IMAGE_CHIP_IDÚCHIP_DETECT_MAGIC_VALUEÚFPGA_SLOW_BOOTÚIROM_MAP_STARTÚ IROM_MAP_ENDÚDROM_MAP_STARTÚ DROM_MAP_ENDÚUART_DATE_REG_ADDRÚ SPI_REG_BASEÚ SPI_USR_OFFSÚ
SPI_USR1_OFFSÚ
SPI_USR2_OFFSÚSPI_MOSI_DLEN_OFFSÚSPI_MISO_DLEN_OFFSÚ SPI_W0_OFFSÚBOOTLOADER_FLASH_OFFSETÚSUPPORTS_ENCRYPTED_FLASHÚFLASH_ENCRYPTED_WRITE_ALIGNÚ
EFUSE_BASEr9 rP rœ ÚEFUSE_RD_REG_BASErv rw rx ry rz r{ r| r} r~ r r€ r� Ú%EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT_REGÚ!EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPTÚ EFUSE_SPI_BOOT_CRYPT_CNT_REGÚ EFUSE_SPI_BOOT_CRYPT_CNT_MASKr– r— r¥ r¦ r� r‘ r‹ ÚUARTDEV_BUF_NOr« r® ÚRTCCNTL_BASE_REGr¶ r· r´ rµ r³ r± r² r¹ rÁ rà r rÄ ÚUART_CLKDIV_REGÚ
MEMORY_MAPr? rE rH rG rA rB rR rQ rZ r\ rf rg rj rp rr rt r… r• r˜ rš r¤ r§ r¬ r¯ r¸ r¼ rÉ rË rÌ r= r= r= r> r sÖ ô
r c @ s$ e Zd ZdZdZdZdZdd„ ZdS )ÚESP32S3StubLoaderzAccess class for ESP32S3 stub loader, runs on top of ROM.
(Basically the same as ESP32StubLoader, but different base class.
Can possibly be made into a mixin.)
i @ r Tc C sH |j | _ |j| _|j| _|j| _| ¡ | ¡ r"| j| _| j| _d S d S rs ) r© rÊ Ú_trace_enabledÚcacheÚ flush_inputr¬ r¹ rº ÚFLASH_WRITE_SIZE)r; Ú
rom_loaderr= r= r> Ú__init__l s þzESP32S3StubLoader.__init__N)rÎ rÏ rÐ Ú__doc__rò ÚSTATUS_BYTES_LENGTHÚIS_STUBrô r= r= r= r> rî a s rî )r¾ r� Úesp32r Úloaderr Úresetr Úutilr r r rî Ú
STUB_CLASSr= r= r= r> Ú<module> s T
| 11,749 | Python | .py | 58 | 200.5 | 951 | 0.492601 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,632 | esp32h2.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/__pycache__/esp32h2.cpython-310.pyc | o
’jÂd%
ã @ s6 d dl mZ G dd„ deƒZG dd„ deƒZee_dS )é )Ú
ESP32C6ROMc @ s„ e Zd ZdZdZdgZdZed Zed Zed Z dZ
ed Z d
Z d dd d
dœZ
dd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ ZdS ) Ú
ESP32H2ROMúESP32-H2é l €>n/ i `é é é i é$ i¡:ØPé r é )Ú48mÚ24mÚ16mÚ12mc C s d}| | jd| ¡d? d@ S )Né r é ©Úread_regÚEFUSE_BLOCK1_ADDR©ÚselfÚnum_word© r ú7/home/ceco/Downloads/esptool/esptool/targets/esp32h2.pyÚget_pkg_version ó zESP32H2ROM.get_pkg_versionc C s d}| | jd| ¡d? d@ S )Né r é r r r r r r Úget_minor_chip_version$ r z!ESP32H2ROM.get_minor_chip_versionc C s d}| | jd| ¡d? d@ S )Nr r é r r r r r Úget_major_chip_version( r z!ESP32H2ROM.get_major_chip_versionc C s: ddi | ¡ d¡}| ¡ }| ¡ }|› d|› d|› d�S )Nr r zunknown ESP32-H2z (revision vÚ.ú))Úgetr r r )r Ú chip_nameÚ major_revÚ minor_revr r r Úget_chip_description, s ÿ şz ESP32H2ROM.get_chip_descriptionc C s ddgS )NÚBLEz IEEE802.15.4r ©r r r r Úget_chip_features4 s z ESP32H2ROM.get_chip_featuresc C s dS )Nr r r) r r r Úget_crystal_freq7 s zESP32H2ROM.get_crystal_freqN)Ú__name__Ú
__module__Ú __qualname__Ú CHIP_NAMEÚ
IMAGE_CHIP_IDÚCHIP_DETECT_MAGIC_VALUEÚDR_REG_LP_WDT_BASEÚRTC_CNTL_WDTCONFIG0_REGÚRTC_CNTL_WDTWPROTECT_REGÚRTC_CNTL_SWD_CONF_REGÚRTC_CNTL_SWD_AUTO_FEED_ENÚRTC_CNTL_SWD_WPROTECT_REGÚRTC_CNTL_SWD_WKEYÚFLASH_FREQUENCYr r r r' r* r+ r r r r r s, ü r c @ s$ e Zd ZdZdZdZdZdd„ ZdS )ÚESP32H2StubLoaderzAccess class for ESP32H2 stub loader, runs on top of ROM.
(Basically the same as ESP32StubLoader, but different base class.
Can possibly be made into a mixin.)
i @ r Tc C s, |j | _ |j| _|j| _|j| _| ¡ d S )N)Úsecure_download_modeÚ_portÚ_trace_enabledÚcacheÚ flush_input)r Ú
rom_loaderr r r Ú__init__G s
zESP32H2StubLoader.__init__N)r, r- r. Ú__doc__ÚFLASH_WRITE_SIZEÚSTATUS_BYTES_LENGTHÚIS_STUBrA r r r r r: < s r: N)Úesp32c6r r r: Ú
STUB_CLASSr r r r Ú<module> s 3
| 2,675 | Python | .py | 15 | 176.4 | 1,290 | 0.480075 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,633 | esp32s2.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/__pycache__/esp32s2.cpython-310.pyc | o
’jÂdc* ã @ sn d dl Z d dlZddlmZ ddlmZ ddlmZ ddlm Z m
Z
G dd „ d eƒZ G d
d „ d e ƒZ e e _
dS ) é Né )ÚESP32ROMé )Ú ESPLoader)Ú HardReset)Ú
FatalErrorÚNotImplementedInROMErrorc
@ s e Zd ZdZdZdZdZdZdZdZ dgZ
d Z d
Z d Z
d Zd
ZdZdZdZdZdZdZdZed Zed Zed Zed Zd
Zed Z d Z ed Z dZ ed Z dZ!ed Z"d Z#ed Z$d Z%eZ&d Z'ed Z(d Z)ed Z*d Z+ed! Z,d"Z-dZ.d#Z/dZ0d$Z1dZ2d%Z3d&Z4d Z5d'Z6d(Z7g d)¢g d*¢g d+¢g d,¢g d-¢g d.¢g d/¢g d0¢g d1¢g d2¢g d3¢g d4¢g Z8d5d6„ Z9d7d8„ Z:d9d:„ Z;d;d<„ Z<d=d>„ Z=d?d@„ Z>dAdB„ Z?dCdD„ Z@dEdF„ ZAdGdH„ ZBdIdJ„ ZCdKdL„ ZDdedNdO„ZEdPdQ„ ZFdRdS„ ZGdTdU„ ZHdVdW„ ZIdXdY„ ZJdZd[„ ZKd\d]„ ZLd^d_„ ZMd`da„ ZNdbdc„ ZOddS )fÚ
ESP32S2ROMúESP32-S2r Fé @i ¸@é ?i ??iÆ i @?é é é é$ é( éX iD A?i @?Té i A?é0 éD é\ é4 é8 r é é é i i i é< i é iıÿ?i i8@@?i(�@?r )r i ÚPADDING)r é ø?ÚDROM)i P?r Ú EXTRAM_DATA)é àù?i ú?ÚRTC_DRAM)r" é @ÚBYTE_ACCESSIBLE)r" é @Ú MEM_INTERNAL)i û?r$ ÚDRAM)r$ i ¡@Ú IROM_MASK)i @é @ÚIRAM)r* r& ÚRTC_IRAM)r i €@ÚIROM)i Pi PÚRTC_DATAc C s d}| | jd| ¡d? d@ S )Nr r é ©Úread_regÚEFUSE_BLOCK1_ADDR©ÚselfÚnum_word© r6 ú7/home/ceco/Downloads/esptool/esptool/targets/esp32s2.pyÚget_pkg_versionh ó zESP32S2ROM.get_pkg_versionc C sL d}| | jd| ¡d? d@ }d}| | jd| ¡d? d@ }|d> | S )Nr r é r é r0 )r4 Ú hi_num_wordÚhiÚ low_num_wordÚlowr6 r6 r7 Úget_minor_chip_versionl s
z!ESP32S2ROM.get_minor_chip_versionc C s d}| | jd| ¡d? d@ S )Nr r é r0 r3 r6 r6 r7 Úget_major_chip_versions r9 z!ESP32S2ROM.get_major_chip_versionc C ó d}| | jd| ¡d? d@ S )Nr r é r/ r0 r3 r6 r6 r7 Úget_flash_versionw r9 z ESP32S2ROM.get_flash_versionc C ó | ¡ S ©N)rE ©r4 r6 r6 r7 Ú
get_flash_cap{ ó zESP32S2ROM.get_flash_capc C rC )Nr r r r/ r0 r3 r6 r6 r7 Úget_psram_version~ r9 z ESP32S2ROM.get_psram_versionc C rF rG )rK rH r6 r6 r7 Ú
get_psram_cap‚ rJ zESP32S2ROM.get_psram_capc C s d}| | jd| ¡d? d@ S )Nr r; )r1 ÚEFUSE_BLOCK2_ADDRr3 r6 r6 r7 Úget_block2_version… s z ESP32S2ROM.get_block2_versionc C sN ddddddœ | ¡ | ¡ d d¡}| ¡ }| ¡ }|› d |› d
|› d �S ) Nr
z ESP32-S2FH2z ESP32-S2FH4z ESP32-S2FNR2z
ESP32-S2R2)r r r éf éd rP zunknown ESP32-S2z (revision vÚ.ú))ÚgetrI rL rB r@ )r4 Ú chip_nameÚ major_revÚ minor_revr6 r6 r7 Úget_chip_descriptionŠ s ûşú
z ESP32S2ROM.get_chip_descriptionc C s€ dg}| j r |dg7 }ddddœ | ¡ d¡}||g7 }dd d
dœ | ¡ d ¡}||g7 }d d
ddœ | ¡ d¡}||g7 }|S )NÚWiFiz Secure Download Mode EnabledzNo Embedded FlashzEmbedded Flash 2MBzEmbedded Flash 4MB)r r r zUnknown Embedded FlashzNo Embedded PSRAMzEmbedded PSRAM 2MBzEmbedded PSRAM 4MBzUnknown Embedded PSRAMz No calibration in BLK2 of efusez:ADC and temperature sensor calibration in BLK2 of efuse V1z:ADC and temperature sensor calibration in BLK2 of efuse V2zUnknown Calibration in BLK2)Úsecure_download_moderS rI rL rN )r4 ÚfeaturesÚ
flash_versionÚ
psram_versionÚblock2_versionr6 r6 r7 Úget_chip_features™ s2
ı ü
ı ü
ı ü
z ESP32S2ROM.get_chip_featuresc C s dS )Nr r6 rH r6 r6 r7 Úget_crystal_freq¶ s zESP32S2ROM.get_crystal_freqc C s t dƒ‚)Nz1VDD_SDIO overrides are not supported for ESP32-S2)r )r4 Ú new_voltager6 r6 r7 Úoverride_vddsdioº s ÿzESP32S2ROM.override_vddsdioÚBASE_MACc C sF |dkrdS | | j¡}| | jd ¡}t d||¡dd… }t|ƒS )zRead MAC from EFUSE regionrb Nr z>IIr )r1 Ú
MAC_EFUSE_REGÚstructÚpackÚtuple)r4 Úmac_typeÚmac0Úmac1Ú bitstringr6 r6 r7 Úread_mac¿ s zESP32S2ROM.read_macc C s | | j¡| j@ r dS dS )Nr r )r1 ÚEFUSE_RD_REPEAT_DATA3_REGÚ)EFUSE_RD_REPEAT_DATA3_REG_FLASH_TYPE_MASKrH r6 r6 r7 Ú
flash_typeÈ s
ÿÿÿüzESP32S2ROM.flash_typec C s d S rG r6 rH r6 r6 r7 Úget_flash_crypt_configĞ s z!ESP32S2ROM.get_flash_crypt_configc C s | | j¡| j@ S rG )r1 ÚEFUSE_SECURE_BOOT_EN_REGÚEFUSE_SECURE_BOOT_EN_MASKrH r6 r6 r7 Úget_secure_boot_enabledÓ s
ÿÿz"ESP32S2ROM.get_secure_boot_enabledc C sr |dk s|dkr t dƒ‚| j| jf| j| jf| j| jf| j| jf| j | j
f| j | j fg| \}}|
|¡|? d@ S )Nr é z,Valid key block numbers must be in range 0-5r/ )r ÚEFUSE_PURPOSE_KEY0_REGÚEFUSE_PURPOSE_KEY0_SHIFTÚEFUSE_PURPOSE_KEY1_REGÚEFUSE_PURPOSE_KEY1_SHIFTÚEFUSE_PURPOSE_KEY2_REGÚEFUSE_PURPOSE_KEY2_SHIFTÚEFUSE_PURPOSE_KEY3_REGÚEFUSE_PURPOSE_KEY3_SHIFTÚEFUSE_PURPOSE_KEY4_REGÚEFUSE_PURPOSE_KEY4_SHIFTÚEFUSE_PURPOSE_KEY5_REGÚEFUSE_PURPOSE_KEY5_SHIFTr1 )r4 Ú key_blockÚregÚshiftr6 r6 r7 Úget_key_block_purposeÙ s
úùz ESP32S2ROM.get_key_block_purposec s\ ‡ fdd„t dƒD ƒ}t‡ fdd„|D ƒƒrdS t‡ fdd„|D ƒƒo-t‡ fdd„|D ƒƒS ) Nc s g | ]}ˆ |¡‘qS r6 )rƒ )Ú.0ÚbrH r6 r7 Ú
<listcomp>é s z<ESP32S2ROM.is_flash_encryption_key_valid.<locals>.<listcomp>é c 3 ó � | ]}|ˆ j kV qd S rG )ÚPURPOSE_VAL_XTS_AES128_KEY©r„ ÚprH r6 r7 Ú <genexpr>ë ó € z;ESP32S2ROM.is_flash_encryption_key_valid.<locals>.<genexpr>Tc 3 rˆ rG )Ú PURPOSE_VAL_XTS_AES256_KEY_1rŠ rH r6 r7 rŒ î r� c 3 rˆ rG )Ú PURPOSE_VAL_XTS_AES256_KEY_2rŠ rH r6 r7 rŒ î s €
ÿ)ÚrangeÚany)r4 Úpurposesr6 rH r7 Ú is_flash_encryption_key_validç s "ÿz(ESP32S2ROM.is_flash_encryption_key_validc C s | j rdS | ¡ | jkS )z[
Check the UARTDEV_BUF_NO register to see if USB-OTG console is being used
F)rY Ú get_uart_noÚUARTDEV_BUF_NO_USB_OTGrH r6 r6 r7 Ú uses_usb_otgò s zESP32S2ROM.uses_usb_otgc C s | ¡ r
| j| _d S d S rG )r– Ú
USB_RAM_BLOCKÚ
ESP_RAM_BLOCKrH r6 r6 r7 Ú
_post_connectú s ÿzESP32S2ROM._post_connectc C sp t d¡dur
tdƒ dS | | j¡}| | j¡}|| j@ dkr4|| j@ dkr6td | ¡ ¡ƒ t
dƒ‚dS dS )z[
Check the strapping register to see if we can reset out of download mode.
ÚESPTOOL_TESTINGNz5ESPTOOL_TESTING is set, ignoring strapping mode checkr zÑWARNING: {} chip was placed into download mode using GPIO0.
esptool.py can not exit the download mode over USB. To run the app, reset the chip manually.
To suppress this note, set --after option to 'no_reset'.r ) ÚosÚgetenvÚprintr1 ÚGPIO_STRAP_REGÚRTC_CNTL_OPTION1_REGÚGPIO_STRAP_SPI_BOOT_MASKÚ!RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASKÚformatrW Ú
SystemExit)r4 Ú strap_regÚ force_dl_regr6 r6 r7 Ú_check_if_can_resetş s" ÿ şÿüôz ESP32S2ROM._check_if_can_resetc C s. | ¡ }|r
| ¡ tdƒ t| j|ƒƒ d S )Nz Hard resetting via RTS pin...)r– r¦ r� r Ú_port)r4 r– r6 r6 r7 Ú
hard_reset s
zESP32S2ROM.hard_resetc C s t | |¡ d S rG )r Ú change_baud)r4 Úbaudr6 r6 r7 r© s zESP32S2ROM.change_baudN)rb )PÚ__name__Ú
__module__Ú __qualname__Ú CHIP_NAMEÚ
IMAGE_CHIP_IDÚFPGA_SLOW_BOOTÚIROM_MAP_STARTÚ IROM_MAP_ENDÚDROM_MAP_STARTÚ DROM_MAP_ENDÚCHIP_DETECT_MAGIC_VALUEÚ SPI_REG_BASEÚ SPI_USR_OFFSÚ
SPI_USR1_OFFSÚ
SPI_USR2_OFFSÚSPI_MOSI_DLEN_OFFSÚSPI_MISO_DLEN_OFFSÚ SPI_W0_OFFSrc ÚUART_CLKDIV_REGÚSUPPORTS_ENCRYPTED_FLASHÚFLASH_ENCRYPTED_WRITE_ALIGNÚ
EFUSE_BASEÚEFUSE_RD_REG_BASEr2 rM rt ru rv rw rx ry rz r{ r| r} r~ r Ú%EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT_REGÚ!EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPTÚ EFUSE_SPI_BOOT_CRYPT_CNT_REGÚ EFUSE_SPI_BOOT_CRYPT_CNT_MASKrp rq rl rm r� r� r‰ ÚUARTDEV_BUF_NOr• r— r� r rŸ r¡ Ú
MEMORY_MAPr8 r@ rB rE rI rK rL rN rW r^ r_ ra rk rn ro rr rƒ r“ r– r™ r¦ r¨ r© r6 r6 r6 r7 r s´ ô
r c @ s$ e Zd ZdZdZdZdZdd„ ZdS )ÚESP32S2StubLoaderz®Access class for ESP32-S2 stub loader, runs on top of ROM.
(Basically the same as ESP32StubLoader, but different base class.
Can possibly be made into a mixin.)
i @ r Tc C sH |j | _ |j| _|j| _|j| _| ¡ | ¡ r"| j| _| j| _d S d S rG ) rY r§ Ú_trace_enabledÚcacheÚ flush_inputr– r— r˜ ÚFLASH_WRITE_SIZE)r4 Ú
rom_loaderr6 r6 r7 Ú__init__. s şzESP32S2StubLoader.__init__N)r« r¬ r Ú__doc__rÌ ÚSTATUS_BYTES_LENGTHÚIS_STUBrÎ r6 r6 r6 r7 rÈ # s rÈ )r› rd Úesp32r Úloaderr Úresetr Úutilr r r rÈ Ú
STUB_CLASSr6 r6 r6 r7 Ú<module> s
| 10,102 | Python | .py | 55 | 181.836364 | 1,041 | 0.517667 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,634 | __init__.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/__pycache__/__init__.cpython-310.pyc | o
’jÂdb ã
@ sÊ d dl mZ d dlmZ d dlmZ d dlmZ d dlm Z d dl
m Z d dl m
Z
d dlmZ d d lmZ d d
lmZ d d lmZ d d lmZ eeeeeee e
eeee d
œ Zee ¡ ƒZee ¡ ƒZ dS )é )ÚESP32ROM)Ú
ESP32C2ROM)Ú
ESP32C3ROM)Ú
ESP32C6ROM)ÚESP32C6BETAROM)Ú
ESP32H2ROM)ÚESP32H2BETA1ROM)ÚESP32H2BETA2ROM)Ú
ESP32S2ROM)Ú
ESP32S3ROM)ÚESP32S3BETA2ROM)Ú
ESP8266ROM) Úesp8266Úesp32Úesp32s2Ú esp32s3beta2Úesp32s3Úesp32c3Ú esp32c6betaÚ esp32h2beta1Ú esp32h2beta2Úesp32c2Úesp32c6Úesp32h2N) r r r r r r r r r r r r r r r r r r
r r r r r r
Ú CHIP_DEFSÚlistÚkeysÚ CHIP_LISTÚvaluesÚROM_LIST© r r ú8/home/ceco/Downloads/esptool/esptool/targets/__init__.pyÚ<module> s6 ô | 885 | Python | .py | 12 | 72.666667 | 228 | 0.551487 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,635 | esp32c3.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/__pycache__/esp32c3.cpython-310.pyc | o
’jÂd–" ã @ sZ d dl Z ddlmZ ddlmZ ddlmZmZ G dd„ deƒZG d d
„ d
eƒZ e e_
dS ) é Né )ÚESP32ROMé )Ú ESPLoader)Ú
FatalErrorÚNotImplementedInROMErrorc @ sø e Zd ZdZdZdZdZdZdZdZ dZ
d Z d
Z d Z
d Zd
ZdZdZddgZdZdZdZed Zed Zed Zed Zd Zed Zd
Z ed Z dZ ed Z dZ ed Z!dZ"ed Z#dZ$eZ%d Z&ed Z'd Z(ed Z)d Z*dZ+d Z,d Z-d Z.d!Z/d"Z0e0d# Z1d$Z2e0d% Z3d&Z4e0d' Z5e0d( Z6d)Z7g d*¢g d+¢g d,¢g d-¢g d.¢g d/¢g d0¢g d1¢g d2¢g d3¢g d4¢g Z8d5d6„ Z9d7d8„ Z:d9d:„ Z;d;d<„ Z<d=d>„ Z=d?d@„ Z>dAdB„ Z?dCdD„ Z@dEdF„ ZAd[dHdI„ZBdJdK„ ZCdLdM„ ZDdNdO„ ZEdPdQ„ ZFdRdS„ ZGdTdU„ ZHdVdW„ ZIdXdY„ ZJdZS )\Ú
ESP32C3ROMzESP32-C3é Fé Bé €Bé <é €<i `é é é é$ é( éX r ioP!iioP1i| `i `i ˆ `éD é0 é4 é8 é é é i i Té i|ğÍ?é i € `é¬ l é° l *1: é� é¨ i¡:ØP)r i ÚPADDING)r r
ÚDROM)i È?i Î?ÚDRAM)i €È?i Ğ?ÚBYTE_ACCESSIBLE)i ğ?i ò?Ú DROM_MASK)i @i @Ú IROM_MASK)r
r ÚIROM)i À7@i >@ÚIRAM)é Pé PÚRTC_IRAM)r) r* ÚRTC_DRAM)i à`i `Ú
MEM_INTERNAL2c C ó d}| | jd| ¡d? d@ S )Nr r é é ©Úread_regÚEFUSE_BLOCK1_ADDR©ÚselfÚnum_word© r7 ú7/home/ceco/Downloads/esptool/esptool/targets/esp32c3.pyÚget_pkg_versionf ó zESP32C3ROM.get_pkg_versionc C sL d}| | jd| ¡d? d@ }d}| | jd| ¡d? d@ }|d> | S )Nr r é r r é r0 r1 )r5 Ú hi_num_wordÚhiÚ low_num_wordÚlowr7 r7 r8 Úget_minor_chip_versionj s
z!ESP32C3ROM.get_minor_chip_versionc C r. )Nr r r r r1 r4 r7 r7 r8 Úget_major_chip_versionq r: z!ESP32C3ROM.get_major_chip_versionc C r. )Nr r é r0 r1 r4 r7 r7 r8 Ú
get_flash_capu r: zESP32C3ROM.get_flash_capc C s8 d}| | jd| ¡d? d@ }dddddd œ |d
¡S ) Nr r r0 ÚXMCÚGDÚFMÚTTÚZBIT)r r r r r Ú )r2 r3 Úget)r5 r6 Ú vendor_idr7 r7 r8 Úget_flash_vendory s zESP32C3ROM.get_flash_vendorc C s@ dddddœ | ¡ d¡}| ¡ }| ¡ }|› d|› d|› d �S )
NzESP32-C3 (QFN32)zESP8685 (QFN28)zESP32-C3 AZ (QFN32)zESP8686 (QFN24))r r r r zunknown ESP32-C3z (revision vÚ.ú))rK r9 rB rA )r5 Ú chip_nameÚ major_revÚ minor_revr7 r7 r8 Úget_chip_description~ s ü ûz ESP32C3ROM.get_chip_descriptionc C sJ ddg}d dddddœ | ¡ d¡}|d ur#||d | ¡ › d
� g7 }|S ) NÚWiFiÚBLEzEmbedded Flash 4MBzEmbedded Flash 2MBzEmbedded Flash 1MBzEmbedded Flash 8MB)r r r r r zUnknown Embedded Flashz (rO )rK rD rM )r5 ÚfeaturesÚflashr7 r7 r8 Úget_chip_features‰ s û úz ESP32C3ROM.get_chip_featuresc C s dS )Nr r7 ©r5 r7 r7 r8 Úget_crystal_freq— s zESP32C3ROM.get_crystal_freqc C s t dƒ‚)Nz1VDD_SDIO overrides are not supported for ESP32-C3)r )r5 Ú new_voltager7 r7 r8 Úoverride_vddsdio› s ÿzESP32C3ROM.override_vddsdioÚBASE_MACc C sF |dkrdS | | j¡}| | jd ¡}t d||¡dd… }t|ƒS )zRead MAC from EFUSE regionr] Nr z>IIr )r2 Ú
MAC_EFUSE_REGÚstructÚpackÚtuple)r5 Úmac_typeÚmac0Úmac1Ú bitstringr7 r7 r8 Úread_mac s zESP32C3ROM.read_macc C s d S ©Nr7 rY r7 r7 r8 Úget_flash_crypt_config© s z!ESP32C3ROM.get_flash_crypt_configc C s | | j¡| j@ S rg )r2 ÚEFUSE_SECURE_BOOT_EN_REGÚEFUSE_SECURE_BOOT_EN_MASKrY r7 r7 r8 Úget_secure_boot_enabled¬ s
ÿÿz"ESP32C3ROM.get_secure_boot_enabledc C sr |dk s|dkr t dƒ‚| j| jf| j| jf| j| jf| j| jf| j | j
f| j | j fg| \}}|
|¡|? d@ S )Nr r z,Valid key block numbers must be in range 0-5é )r ÚEFUSE_PURPOSE_KEY0_REGÚEFUSE_PURPOSE_KEY0_SHIFTÚEFUSE_PURPOSE_KEY1_REGÚEFUSE_PURPOSE_KEY1_SHIFTÚEFUSE_PURPOSE_KEY2_REGÚEFUSE_PURPOSE_KEY2_SHIFTÚEFUSE_PURPOSE_KEY3_REGÚEFUSE_PURPOSE_KEY3_SHIFTÚEFUSE_PURPOSE_KEY4_REGÚEFUSE_PURPOSE_KEY4_SHIFTÚEFUSE_PURPOSE_KEY5_REGÚEFUSE_PURPOSE_KEY5_SHIFTr2 )r5 Ú key_blockÚregÚshiftr7 r7 r8 Úget_key_block_purpose² s
úùz ESP32C3ROM.get_key_block_purposec s, ‡ fdd„t dƒD ƒ}t‡ fdd„|D ƒƒS )Nc s g | ]}ˆ |¡‘qS r7 )r| )Ú.0ÚbrY r7 r8 Ú
<listcomp>Â s z<ESP32C3ROM.is_flash_encryption_key_valid.<locals>.<listcomp>é c 3 s � | ]}|ˆ j kV qd S rg )ÚPURPOSE_VAL_XTS_AES128_KEY)r} ÚprY r7 r8 Ú <genexpr>Ä s € z;ESP32C3ROM.is_flash_encryption_key_valid.<locals>.<genexpr>)ÚrangeÚany)r5 Úpurposesr7 rY r8 Ú is_flash_encryption_key_validÀ s z(ESP32C3ROM.is_flash_encryption_key_validc C s t | |¡ d S rg )r Ú change_baud)r5 Úbaudr7 r7 r8 rˆ Æ s zESP32C3ROM.change_baudc C s | j rdS | ¡ | jkS )z[
Check the UARTDEV_BUF_NO register to see if USB-JTAG/Serial is being used
F)Úsecure_download_modeÚ get_uart_noÚ UARTDEV_BUF_NO_USB_JTAG_SERIALrY r7 r7 r8 Úuses_usb_jtag_serialÉ s z ESP32C3ROM.uses_usb_jtag_serialc C sv | ¡ r9| | j| j¡ | | jd¡ | | jd¡ | | j| j¡ | | j| | j¡| j B ¡ | | jd¡ d S d S )Nr )
r� Ú write_regÚRTC_CNTL_WDTWPROTECT_REGÚRTC_CNTL_WDT_WKEYÚRTC_CNTL_WDTCONFIG0_REGÚRTC_CNTL_SWD_WPROTECT_REGÚRTC_CNTL_SWD_WKEYÚRTC_CNTL_SWD_CONF_REGr2 ÚRTC_CNTL_SWD_AUTO_FEED_ENrY r7 r7 r8 Údisable_watchdogsÑ s
ÿşóz ESP32C3ROM.disable_watchdogsc C s | j s | ¡ d S d S rg )Úsync_stub_detectedr– rY r7 r7 r8 Ú
_post_connectã s ÿzESP32C3ROM._post_connectN)r] )KÚ__name__Ú
__module__Ú __qualname__Ú CHIP_NAMEÚ
IMAGE_CHIP_IDÚFPGA_SLOW_BOOTÚIROM_MAP_STARTÚ IROM_MAP_ENDÚDROM_MAP_STARTÚ DROM_MAP_ENDÚ SPI_REG_BASEÚ SPI_USR_OFFSÚ
SPI_USR1_OFFSÚ
SPI_USR2_OFFSÚSPI_MOSI_DLEN_OFFSÚSPI_MISO_DLEN_OFFSÚ SPI_W0_OFFSÚBOOTLOADER_FLASH_OFFSETÚCHIP_DETECT_MAGIC_VALUEÚUART_DATE_REG_ADDRÚUART_CLKDIV_REGÚ
EFUSE_BASEr3 r^ ÚEFUSE_RD_REG_BASErm rn ro rp rq rr rs rt ru rv rw rx Ú%EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT_REGÚ!EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPTÚ EFUSE_SPI_BOOT_CRYPT_CNT_REGÚ EFUSE_SPI_BOOT_CRYPT_CNT_MASKri rj r� ÚSUPPORTS_ENCRYPTED_FLASHÚFLASH_ENCRYPTED_WRITE_ALIGNÚUARTDEV_BUF_NOrŒ ÚRTCCNTL_BASE_REGr” r• r’ r“ r‘ r� r� Ú
MEMORY_MAPr9 rA rB rD rM rS rX rZ r\ rf rh rk r| r‡ rˆ r� r– r˜ r7 r7 r7 r8 r
s¨ õ
r c @ s$ e Zd ZdZdZdZdZdd„ ZdS )ÚESP32C3StubLoaderzAccess class for ESP32C3 stub loader, runs on top of ROM.
(Basically the same as ESP32StubLoader, but different base class.
Can possibly be made into a mixin.)
i @ r Tc C s, |j | _ |j| _|j| _|j| _| ¡ d S rg )rŠ Ú_portÚ_trace_enabledÚcacheÚ flush_input)r5 Ú
rom_loaderr7 r7 r8 Ú__init__ó s
zESP32C3StubLoader.__init__N)r™ rš r› Ú__doc__ÚFLASH_WRITE_SIZEÚSTATUS_BYTES_LENGTHÚIS_STUBr¿ r7 r7 r7 r8 r¹ è s r¹ ) r_ Úesp32r Úloaderr Úutilr r r r¹ Ú
STUB_CLASSr7 r7 r7 r8 Ú<module> s \
| 8,156 | Python | .py | 39 | 207.358974 | 1,239 | 0.514353 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,636 | esp32c6beta.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/__pycache__/esp32c6beta.cpython-310.pyc | o
’jÂd ã @ s d dl mZ G dd„ deƒZdS )é )Ú
ESP32C3ROMc @ s. e Zd ZdZdZdgZdZdd„ Zdd„ Zd S )
ÚESP32C6BETAROMzESP32-C6(beta)é io€¡
i c C s< dddœ | ¡ d¡}| ¡ }| ¡ }|› d|› d|› d�S )NzESP32-C6 (QFN40)zESP32-C6FH4 (QFN32))é r zunknown ESP32-C6z (revision vÚ.ú))ÚgetÚget_pkg_versionÚget_major_chip_versionÚget_minor_chip_version)ÚselfÚ chip_nameÚ major_revÚ minor_rev© r ú;/home/ceco/Downloads/esptool/esptool/targets/esp32c6beta.pyÚget_chip_description s þ ýz#ESP32C6BETAROM.get_chip_descriptionc C s d S )Nr )r r r r Ú
_post_connect s z ESP32C6BETAROM._post_connectN) Ú__name__Ú
__module__Ú __qualname__Ú CHIP_NAMEÚ
IMAGE_CHIP_IDÚCHIP_DETECT_MAGIC_VALUEÚUART_DATE_REG_ADDRr r r r r r r s r N)Úesp32c3r r r r r r Ú<module> s | 1,029 | Python | .py | 5 | 204.6 | 628 | 0.50439 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,637 | esp32h2beta1.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/__pycache__/esp32h2beta1.cpython-310.pyc | o
’jÂdl ã @ sN d dl Z ddlmZ ddlmZmZ G dd„ deƒZG dd „ d eƒZee_dS )
é Né )Ú
ESP32C3ROMé )Ú
FatalErrorÚNotImplementedInROMErrorc @ sR e Zd ZdZdZdZdZdZdZdZ dZ
d Z d
Z d Z
d Zd
ZdZdgZdZdZed Zed Zed Zed ZdZed Zd Zed ZdZ ed Z dZ ed Z dZ ed Z!dZ"eZ#dZ$ed Z%dZ&ed Z'dZ(dZ)dZ*d Z+g Z,d dd d d œZ-d!d"„ Z.d#d$„ Z/d%d&„ Z0d'd(„ Z1d)d*„ Z2d+d,„ Z3d-d.„ Z4d;d0d1„Z5d2d3„ Z6d4d5„ Z7d6d7„ Z8d8d9„ Z9d:S )<ÚESP32H2BETA1ROMzESP32-H2(beta1)é
i Bi €Bi <i €<i `é é é é$ é( éX r l "LM i| `i `éD é0 é4 é8 é é é i i Té é r r )Ú48mÚ24mÚ16mÚ12mc C s d}| | jd| ¡d? d@ S )Nr r é ©Úread_regÚEFUSE_BLOCK1_ADDR©ÚselfÚnum_word© r# ú</home/ceco/Downloads/esptool/esptool/targets/esp32h2beta1.pyÚget_pkg_versionN ó z ESP32H2BETA1ROM.get_pkg_versionc C s d}| | jd| ¡d? d@ S )Né r é r r r r# r# r$ Úget_minor_chip_versionR r& z&ESP32H2BETA1ROM.get_minor_chip_versionc C s d}| | jd| ¡d? d@ S )Nr' r é r r r# r# r$ Úget_major_chip_versionV r& z&ESP32H2BETA1ROM.get_major_chip_versionc C s: ddi | ¡ d¡}| ¡ }| ¡ }|› d|› d|› d�S )Nr zESP32-H2zunknown ESP32-H2z (revision vÚ.ú))Úgetr% r+ r) )r! Ú chip_nameÚ major_revÚ minor_revr# r# r$ Úget_chip_descriptionZ s ÿ şz$ESP32H2BETA1ROM.get_chip_descriptionc C s ddgS )NÚBLEz IEEE802.15.4r# ©r! r# r# r$ Úget_chip_featuresb s z!ESP32H2BETA1ROM.get_chip_featuresc C s dS )Nr r# r4 r# r# r$ Úget_crystal_freqe ó z ESP32H2BETA1ROM.get_crystal_freqc C s t dƒ‚)Nz1VDD_SDIO overrides are not supported for ESP32-H2)r )r! Ú new_voltager# r# r$ Úoverride_vddsdioh s ÿz ESP32H2BETA1ROM.override_vddsdioÚBASE_MACc C sF |dkrdS | | j¡}| | jd ¡}t d||¡dd… }t|ƒS )zRead MAC from EFUSE regionr: Nr z>IIr )r Ú
MAC_EFUSE_REGÚstructÚpackÚtuple)r! Úmac_typeÚmac0Úmac1Ú bitstringr# r# r$ Úread_macm s zESP32H2BETA1ROM.read_macc C ó d S ©Nr# r4 r# r# r$ Úget_flash_crypt_configv r7 z&ESP32H2BETA1ROM.get_flash_crypt_configc C sr |dk s|dkr t dƒ‚| j| jf| j| jf| j| jf| j| jf| j | j
f| j | j fg| \}}|
|¡|? d@ S )Nr é z,Valid key block numbers must be in range 0-5r )r ÚEFUSE_PURPOSE_KEY0_REGÚEFUSE_PURPOSE_KEY0_SHIFTÚEFUSE_PURPOSE_KEY1_REGÚEFUSE_PURPOSE_KEY1_SHIFTÚEFUSE_PURPOSE_KEY2_REGÚEFUSE_PURPOSE_KEY2_SHIFTÚEFUSE_PURPOSE_KEY3_REGÚEFUSE_PURPOSE_KEY3_SHIFTÚEFUSE_PURPOSE_KEY4_REGÚEFUSE_PURPOSE_KEY4_SHIFTÚEFUSE_PURPOSE_KEY5_REGÚEFUSE_PURPOSE_KEY5_SHIFTr )r! Ú key_blockÚregÚshiftr# r# r$ Úget_key_block_purposey s
úùz%ESP32H2BETA1ROM.get_key_block_purposec s, ‡ fdd„t dƒD ƒ}t‡ fdd„|D ƒƒS )Nc s g | ]}ˆ |¡‘qS r# )rW )Ú.0Úbr4 r# r$ Ú
<listcomp>‰ s zAESP32H2BETA1ROM.is_flash_encryption_key_valid.<locals>.<listcomp>é c 3 s � | ]}|ˆ j kV qd S rE )ÚPURPOSE_VAL_XTS_AES128_KEY)rX Úpr4 r# r$ Ú <genexpr>‹ s € [email protected]_flash_encryption_key_valid.<locals>.<genexpr>)ÚrangeÚany)r! Úpurposesr# r4 r$ Ú is_flash_encryption_key_valid‡ s z-ESP32H2BETA1ROM.is_flash_encryption_key_validc C rD rE r# r4 r# r# r$ Ú
_post_connect� r7 z ESP32H2BETA1ROM._post_connectN)r: ):Ú__name__Ú
__module__Ú __qualname__Ú CHIP_NAMEÚ
IMAGE_CHIP_IDÚIROM_MAP_STARTÚ IROM_MAP_ENDÚDROM_MAP_STARTÚ DROM_MAP_ENDÚ SPI_REG_BASEÚ SPI_USR_OFFSÚ
SPI_USR1_OFFSÚ
SPI_USR2_OFFSÚSPI_MOSI_DLEN_OFFSÚSPI_MISO_DLEN_OFFSÚ SPI_W0_OFFSÚBOOTLOADER_FLASH_OFFSETÚCHIP_DETECT_MAGIC_VALUEÚUART_DATE_REG_ADDRÚ
EFUSE_BASEr r; ÚEFUSE_RD_REG_BASErH rI rJ rK rL rM rN rO rP rQ rR rS Ú%EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT_REGÚ!EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPTÚ EFUSE_SPI_BOOT_CRYPT_CNT_REGÚ EFUSE_SPI_BOOT_CRYPT_CNT_MASKÚEFUSE_SECURE_BOOT_EN_REGÚEFUSE_SECURE_BOOT_EN_MASKr\ ÚSUPPORTS_ENCRYPTED_FLASHÚFLASH_ENCRYPTED_WRITE_ALIGNÚ
MEMORY_MAPÚFLASH_FREQUENCYr% r) r+ r2 r5 r6 r9 rC rF rW rb rc r# r# r# r$ r sx ü
r c @ s$ e Zd ZdZdZdZdZdd„ ZdS )ÚESP32H2BETA1StubLoaderz²Access class for ESP32H2BETA1 stub loader, runs on top of ROM.
(Basically the same as ESP32StubLoader, but different base class.
Can possibly be made into a mixin.)
i @ r Tc C s, |j | _ |j| _|j| _|j| _| ¡ d S rE )Úsecure_download_modeÚ_portÚ_trace_enabledÚcacheÚ flush_input)r! Ú
rom_loaderr# r# r$ Ú__init__œ s
z ESP32H2BETA1StubLoader.__init__N)rd re rf Ú__doc__ÚFLASH_WRITE_SIZEÚSTATUS_BYTES_LENGTHÚIS_STUBrŠ r# r# r# r$ rƒ ‘ s rƒ ) r< Úesp32c3r Úutilr r r rƒ Ú
STUB_CLASSr# r# r# r$ Ú<module> s
| 5,690 | Python | .py | 27 | 209.222222 | 2,133 | 0.524634 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,638 | esp32h2beta2.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/__pycache__/esp32h2beta2.cpython-310.pyc | o
’jÂd• ã @ s6 d dl mZ G dd„ deƒZG dd„ deƒZee_dS )é )ÚESP32H2BETA1ROMc @ s" e Zd ZdZdZdgZdd„ ZdS )ÚESP32H2BETA2ROMúESP32-H2(beta2)é io°�hc C s: ddi | ¡ d¡}| ¡ }| ¡ }|› d|› d|› d�S )Nr r zunknown ESP32-H2z (revision vÚ.ú))ÚgetÚget_pkg_versionÚget_major_chip_versionÚget_minor_chip_version)ÚselfÚ chip_nameÚ major_revÚ minor_rev© r ú</home/ceco/Downloads/esptool/esptool/targets/esp32h2beta2.pyÚget_chip_description s ÿ şz$ESP32H2BETA2ROM.get_chip_descriptionN)Ú__name__Ú
__module__Ú __qualname__Ú CHIP_NAMEÚ
IMAGE_CHIP_IDÚCHIP_DETECT_MAGIC_VALUEr r r r r r s
r c @ s$ e Zd ZdZdZdZdZdd„ ZdS )ÚESP32H2BETA2StubLoaderz²Access class for ESP32H2BETA2 stub loader, runs on top of ROM.
(Basically the same as ESP32StubLoader, but different base class.
Can possibly be made into a mixin.)
i @ é Tc C s, |j | _ |j| _|j| _|j| _| ¡ d S )N)Úsecure_download_modeÚ_portÚ_trace_enabledÚcacheÚ flush_input)r Ú
rom_loaderr r r Ú__init__# s
z ESP32H2BETA2StubLoader.__init__N)r r r Ú__doc__ÚFLASH_WRITE_SIZEÚSTATUS_BYTES_LENGTHÚIS_STUBr! r r r r r s r N)Ú esp32h2beta1r r r Ú
STUB_CLASSr r r r Ú<module> s
| 1,529 | Python | .py | 11 | 136.727273 | 650 | 0.523715 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,639 | esp32.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/__pycache__/esp32.cpython-310.pyc | o
’jÂdi5 ã @ sV d dl Z d dlZddlmZ ddlmZmZ G dd„ deƒZG dd„ deƒZee_ dS ) é Né )Ú ESPLoader)Ú
FatalErrorÚNotSupportedErrorc @ sÔ e Zd ZdZdZdZdZdZdgZdZ dZ
d Z d
Z d Z
d Zd
ZdZdZdZdZdZed ZdZeZdZed ZdZdZdZ e d Z dZ dZ dZ dZ!dZ"d Z#d Z$d Z%dddd d d!d"d#d$œZ&d%ddd&d'œZ'd(Z(g d)¢Z)g d*¢g d+¢g d,¢g d-¢g d.¢g d/¢g d0¢g d1¢g d2¢g d3¢g d4¢g d5¢g d6¢g d7¢g d8¢gZ*dZ+ d9d:„ Z,d;d<„ Z-d=d>„ Z.d?d@„ Z/dAdB„ Z0dCdD„ Z1dEdF„ Z2dGdH„ Z3dIdJ„ Z4dKdL„ Z5dMdN„ Z6dOdP„ Z7dQdR„ Z8dadTdU„Z9dVdW„ Z:dXdY„ Z;dZd[„ Z<d\d]„ Z=d^d_„ Z>d`S )bÚESP32ROMz%Access class for ESP32 ROM bootloaderÚESP32r FTiƒ ð é
@é @@é @?é €?é i ô?é é é$ é( é, i õ?é é€ i ðé i `ö?é| é é i ô?ilðõ?iÿÿÿé é0 é@ éP é` ép )Ú1MBÚ2MBÚ4MBÚ8MBÚ16MBÚ32MBÚ64MBÚ128MBé r )Ú80mÚ40mÚ26mÚ20mé )z1.8Vú1.9VÚOFF)r i ÚPADDING)r
r ÚDROM)r i À?Ú EXTRAM_DATA)i ø?i ø?ÚRTC_DRAM)i ù?é @ÚBYTE_ACCESSIBLE)i àú?r2 ÚDRAM)i þ?iüÿÿ?Ú
DIRAM_DRAM)r2 é @ÚIROM)r6 é €@Ú CACHE_PRO)r8 é @Ú CACHE_APP)r: é
@ÚIRAM)r< iüÿ @Ú
DIRAM_IRAM)i @i @ÚRTC_IRAM)r r r7 )i Pi PÚRTC_DATAc C sb | d¡}|d? d@ }|rdS dgd }tt|ƒƒD ]}| d| ¡||< || dkr. dS qdS )znBit 0 of efuse_rd_disable[3:0] is mapped to BLOCK1
this bit is at position 16 in EFUSE_BLK0_RDATA0_REGr r r Tr é F)Ú
read_efuseÚrangeÚlen)ÚselfÚword0Ú
rd_disableÚkey_wordÚi© rJ ú5/home/ceco/Downloads/esptool/esptool/targets/esp32.pyÚ is_flash_encryption_key_validn s
ÿz&ESP32ROM.is_flash_encryption_key_validc C s> | d¡}|d? d@ }|dkr | d¡}|d? d@ }|S dS )aØ For flash encryption related commands we need to make sure
user has programmed all the relevant efuse correctly so before
writing encrypted write_flash_encrypt esptool will verify the values
of flash_crypt_config to be non zero if they are not read
protected. If the values are zero a warning will be printed
bit 3 in efuse_rd_disable[3:0] is mapped to flash_crypt_config
this bit is at position 19 in EFUSE_BLK0_RDATA0_REGr é r é r
r& ©rB )rE rF rG Úword5rJ rJ rK Úget_flash_crypt_config… s
z ESP32ROM.get_flash_crypt_configc C s | | j¡| j@ S ©N)Úread_regÚ%EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT_REGÚ!EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT©rE rJ rJ rK Ú get_encrypted_download_disabled› s
ÿÿz(ESP32ROM.get_encrypted_download_disabledc C s( | | j¡| j@ }t|ƒ d¡d@ dkS )NÚ1r r )rS Ú EFUSE_SPI_BOOT_CRYPT_CNT_REGÚ EFUSE_SPI_BOOT_CRYPT_CNT_MASKÚbinÚcount)rE Úflash_crypt_cntrJ rJ rK Ú get_flash_encryption_enabled¡ s
ÿÿz%ESP32ROM.get_flash_encryption_enabledc C s0 | | j¡}| ¡ }|| j@ p|dko|| j@ S )Ni, )rS ÚEFUSE_RD_ABS_DONE_REGÚget_chip_revisionÚEFUSE_RD_ABS_DONE_0_MASKÚEFUSE_RD_ABS_DONE_1_MASK)rE ÚefusesÚrevrJ rJ rK Úget_secure_boot_enabled© s
ÿz ESP32ROM.get_secure_boot_enabledc C s. | d¡}|d? d@ }||d? d@ d> 7 }|S )Né é r r r rO )rE Úword3Ú pkg_versionrJ rJ rK Úget_pkg_version° s
zESP32ROM.get_pkg_versionc C s | ¡ d | ¡ S )Néd )Úget_major_chip_versionÚget_minor_chip_versionrV rJ rJ rK r` ¶ s zESP32ROM.get_chip_revisionc C s | d¡d? d@ S )NrN r rf rO rV rJ rJ rK rm ¹ s z ESP32ROM.get_minor_chip_versionc C sn | d¡d? d@ }| d¡d? d@ }| | j¡}|| j? | j@ }|d> |d> B |B }dddddœ |d¡}|S ) Nrf r& r rN é r r )r r rf r )rB rS ÚAPB_CTL_DATE_ADDRÚAPB_CTL_DATE_SÚAPB_CTL_DATE_VÚget)rE Úrev_bit0Úrev_bit1Ú apb_ctl_dateÚrev_bit2Ú
combine_valueÚrevisionrJ rJ rK rl ¼ s üûz ESP32ROM.get_major_chip_versionc C sŽ | ¡ }| ¡ }| ¡ }|dk}| d¡d@ }|rdnd|r dnddd|r'd nd
d d d
œ |d¡}| d¡r<|r<|d7 }|› d|› d|› d�S )Nrf r z ESP32-S0WDQ6z ESP32-D0WDQ6z
ESP32-S0WDz
ESP32-D0WDz
ESP32-D2WDz ESP32-U4WDHz
ESP32-PICO-V3z
ESP32-PICO-D4zESP32-PICO-V3-02zESP32-D0WDR2-V3)r r r r rN é r z
unknown ESP32z-V3z (revision vÚ.ú))rj rl rm rB rr Ú
startswith)rE ri Ú major_revÚ minor_revÚrev3Ú single_coreÚ chip_namerJ rJ rK Úget_chip_descriptionË s$
ùø z ESP32ROM.get_chip_descriptionc
C s dg}| d¡}|d@ }|dkr|dg7 }|d@ }|r!|dg7 }n|dg7 }|d @ }|r=|d
@ }|r8|d g7 }n|d g7 }| ¡ }|d
v rJ|dg7 }|dkrS|dg7 }| d¡}|d? d@ } | re|dg7 }|d? d@ }
|
rr|dg7 }| d¡} | d@ } |dddddd œ| g7 }|S ) NÚWiFirf r r ÚBTr z Single Corez Dual Corei r+ Ú160MHzÚ240MHz)r r rN ry zEmbedded Flashry zEmbedded PSRAMr é r zVRef calibration in efuserA zBLK3 partially reservedzCoding Scheme %sÚNonez3/4zRepeat (UNSUPPORTED)ÚInvalid)r r r rf )rB rj )
rE Úfeaturesrh Úchip_ver_dis_btÚchip_ver_dis_app_cpuÚchip_cpu_freq_ratedÚchip_cpu_freq_lowri Úword4Úadc_vrefÚ
blk3_part_resÚword6Ú
coding_schemerJ rJ rK Úget_chip_featuresâ sJ
ÿÿÿzESP32ROM.get_chip_featuresc C s | | jd| ¡S )z,Read the nth word of the ESP3x EFUSE region.r )rS ÚEFUSE_RD_REG_BASE)rE ÚnrJ rJ rK rB s zESP32ROM.read_efusec C s
t | dƒ‚)NÚchip_id)r rV rJ rJ rK r— s
zESP32ROM.chip_idÚBASE_MACc C sF |dkrdS | d¡| d¡g}tjdg|¢R Ž }|dd… }t|ƒS )zRead MAC from EFUSE regionr˜ Nr r z>IIr‡ )rB ÚstructÚpackÚtuple)rE Úmac_typeÚwordsÚ bitstringrJ rJ rK Úread_mac s zESP32ROM.read_macc C s |S rR rJ )rE ÚoffsetÚsizerJ rJ rK Úget_erase_size' s zESP32ROM.get_erase_sizec
C s† | ¡ }|| jvr
tdƒ‚d}d}d}d}d}d}d}|} | |O } |d kr)| |O } |d
kr5| ||B |B O } | || ¡ td | ƒ d S ) Nz@The only accepted VDDSDIO overrides are '1.8V', '1.9V' and 'OFF'it€ô?l i `i i i @ i r- r, zVDDSDIO regulator set to %s)ÚupperÚOVERRIDE_VDDSDIO_CHOICESr Ú write_regÚprint)
rE Ú new_voltageÚRTC_CNTL_SDIO_CONF_REGÚRTC_CNTL_XPD_SDIO_REGÚRTC_CNTL_DREFH_SDIO_MÚRTC_CNTL_DREFM_SDIO_MÚRTC_CNTL_DREFL_SDIO_MÚRTC_CNTL_SDIO_FORCEÚRTC_CNTL_SDIO_PD_ENÚreg_valrJ rJ rK Úoverride_vddsdio* s,
ÿ
ÿ zESP32ROM.override_vddsdioc
C s¶ d}d}t |ƒ|k rYt||t |ƒ ƒ}| d| jt d|t |ƒ |¡¡}t |ƒ|k r4td|t |ƒf ƒ‚||d |… 7 }|rSt |ƒd dksLt |ƒ|krS|t |ƒ|ƒ t |ƒ|k s
|S )Nr ó zread flash blockú<IIz4Expected %d byte block, got %d bytes. Serial errors?i r )rD ÚminÚ
check_commandÚESP_READ_FLASH_SLOWr™ rš r )rE r ÚlengthÚ progress_fnÚ BLOCK_LENÚdataÚ block_lenÚrrJ rJ rK Úread_flash_slowF s( ý
ÿÿ ðzESP32ROM.read_flash_slowc C s: | | j¡| j? | j@ }| d¡d@ }|d | d }|S )zA
Get the crystal frequency calculated by the ROM
r éÿ i = r )rS Ú RTCCALICFG1ÚTIMERS_RTC_CALI_VALUE_SÚTIMERS_RTC_CALI_VALUErB )rE Úcali_valÚ clk_8M_freqÚrom_calculated_freqrJ rJ rK Úget_rom_cal_crystal_freq] s þz!ESP32ROM.get_rom_cal_crystal_freqc C sˆ | j dks J dƒ‚| ¡ }|dkrdnd}t|| | ƒ}td|› �ƒ | | jt d|d¡¡ td ƒ | |¡ t
d
¡ | ¡ d S ) Nr z*This workaround should only apply to ESP32i@Š÷i Zbi€ºŒzChanging baud rate to r² r zChanged.gš™™™™™©?) Ú CHIP_NAMErÄ Úintr¦ ÚcommandÚESP_CHANGE_BAUDRATEr™ rš Ú_set_port_baudrateÚtimeÚsleepÚ flush_input)rE Úbaudrà Ú
valid_freqÚfalse_rom_baudrJ rJ rK Ú change_baudk s
zESP32ROM.change_baudN)r˜ )?Ú__name__Ú
__module__Ú __qualname__Ú__doc__rÅ Ú
IMAGE_CHIP_IDÚIS_STUBÚFPGA_SLOW_BOOTÚCHIP_DETECT_MAGIC_VALUEÚIROM_MAP_STARTÚ IROM_MAP_ENDÚDROM_MAP_STARTÚ DROM_MAP_ENDÚSTATUS_BYTES_LENGTHÚ SPI_REG_BASEÚ SPI_USR_OFFSÚ
SPI_USR1_OFFSÚ
SPI_USR2_OFFSÚSPI_MOSI_DLEN_OFFSÚSPI_MISO_DLEN_OFFSr• rT rU rY rZ r_ ra rb ÚDR_REG_SYSCON_BASEro rq rp Ú SPI_W0_OFFSÚUART_CLKDIV_REGÚXTAL_CLK_DIVIDERr¾ rÀ r¿ Ú FLASH_SIZESÚFLASH_FREQUENCYÚBOOTLOADER_FLASH_OFFSETr¤ Ú
MEMORY_MAPÚFLASH_ENCRYPTED_WRITE_ALIGNrL rQ rW r^ re rj r` rm rl r‚ r” rB r— rŸ r¢ r° r¼ rÄ rÐ rJ rJ rJ rK r
s² ø üñ5
r c @ s, e Zd ZdZdZdZdZdd„ Zdd„ Zd S )
ÚESP32StubLoaderz7Access class for ESP32 stub loader, runs on top of ROM.i @ r Tc C s, |j | _ |j| _|j| _|j| _| ¡ d S rR )Úsecure_download_modeÚ_portÚ_trace_enabledÚcacherÌ )rE Ú
rom_loaderrJ rJ rK Ú__init__� s
zESP32StubLoader.__init__c C s t | |¡ d S rR )r rÐ )rE rÍ rJ rJ rK rÐ ˆ s zESP32StubLoader.change_baudN) rÑ rÒ rÓ rÔ ÚFLASH_WRITE_SIZErÝ rÖ ró rÐ rJ rJ rJ rK rí z s rí )
r™ rÊ Úloaderr Úutilr r r rí Ú
STUB_CLASSrJ rJ rJ rK Ú<module> s o
| 10,381 | Python | .py | 75 | 136.373333 | 886 | 0.504657 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,640 | __main__.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/__main__.py | # SPDX-FileCopyrightText: 2016-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import espefuse
if __name__ == "__main__":
espefuse._main()
| 184 | Python | .py | 6 | 28.666667 | 71 | 0.721591 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,641 | __init__.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/__init__.py | # SPDX-FileCopyrightText: 2016-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import argparse
import os
import sys
from collections import namedtuple
from io import StringIO
import espefuse.efuse.esp32 as esp32_efuse
import espefuse.efuse.esp32c2 as esp32c2_efuse
import espefuse.efuse.esp32c3 as esp32c3_efuse
import espefuse.efuse.esp32c6 as esp32c6_efuse
import espefuse.efuse.esp32h2 as esp32h2_efuse
import espefuse.efuse.esp32h2beta1 as esp32h2beta1_efuse
import espefuse.efuse.esp32s2 as esp32s2_efuse
import espefuse.efuse.esp32s3 as esp32s3_efuse
import espefuse.efuse.esp32s3beta2 as esp32s3beta2_efuse
import esptool
DefChip = namedtuple("DefChip", ["chip_name", "efuse_lib", "chip_class"])
SUPPORTED_BURN_COMMANDS = [
"read_protect_efuse",
"write_protect_efuse",
"burn_efuse",
"burn_block_data",
"burn_bit",
"burn_key",
"burn_key_digest",
"burn_custom_mac",
"set_flash_voltage",
"execute_scripts",
]
SUPPORTED_COMMANDS = [
"summary",
"dump",
"get_custom_mac",
"adc_info",
"check_error",
] + SUPPORTED_BURN_COMMANDS
SUPPORTED_CHIPS = {
"esp32": DefChip("ESP32", esp32_efuse, esptool.targets.ESP32ROM),
"esp32c2": DefChip("ESP32-C2", esp32c2_efuse, esptool.targets.ESP32C2ROM),
"esp32c3": DefChip("ESP32-C3", esp32c3_efuse, esptool.targets.ESP32C3ROM),
"esp32c6": DefChip("ESP32-C6", esp32c6_efuse, esptool.targets.ESP32C6ROM),
"esp32h2": DefChip("ESP32-H2", esp32h2_efuse, esptool.targets.ESP32H2ROM),
"esp32h2beta1": DefChip(
"ESP32-H2(beta1)", esp32h2beta1_efuse, esptool.targets.ESP32H2BETA1ROM
),
"esp32s2": DefChip("ESP32-S2", esp32s2_efuse, esptool.targets.ESP32S2ROM),
"esp32s3": DefChip("ESP32-S3", esp32s3_efuse, esptool.targets.ESP32S3ROM),
"esp32s3beta2": DefChip(
"ESP32-S3(beta2)", esp32s3beta2_efuse, esptool.targets.ESP32S3BETA2ROM
),
}
def get_esp(
port,
baud,
connect_mode,
chip="auto",
skip_connect=False,
virt=False,
debug=False,
virt_efuse_file=None,
):
if chip not in ["auto"] + list(SUPPORTED_CHIPS.keys()):
raise esptool.FatalError("get_esp: Unsupported chip (%s)" % chip)
if virt:
efuse = SUPPORTED_CHIPS.get(chip, SUPPORTED_CHIPS["esp32"]).efuse_lib
esp = efuse.EmulateEfuseController(virt_efuse_file, debug)
else:
if chip == "auto" and not skip_connect:
esp = esptool.cmds.detect_chip(port, baud, connect_mode)
else:
esp = SUPPORTED_CHIPS.get(chip, SUPPORTED_CHIPS["esp32"]).chip_class(
port if not skip_connect else StringIO(), baud
)
if not skip_connect:
esp.connect(connect_mode)
return esp
def get_efuses(esp, skip_connect=False, debug_mode=False, do_not_confirm=False):
for name in SUPPORTED_CHIPS:
if SUPPORTED_CHIPS[name].chip_name == esp.CHIP_NAME:
efuse = SUPPORTED_CHIPS[name].efuse_lib
return (
efuse.EspEfuses(esp, skip_connect, debug_mode, do_not_confirm),
efuse.operations,
)
else:
raise esptool.FatalError("get_efuses: Unsupported chip (%s)" % esp.CHIP_NAME)
def split_on_groups(all_args):
"""
This function splits the all_args list into groups,
where each item is a cmd with all its args.
Example:
all_args:
['burn_key_digest', 'secure_images/ecdsa256_secure_boot_signing_key_v2.pem',
'burn_key', 'BLOCK_KEY0', 'images/efuse/128bit_key',
'XTS_AES_128_KEY_DERIVED_FROM_128_EFUSE_BITS']
used_cmds: ['burn_key_digest', 'burn_key']
groups:
[['burn_key_digest', 'secure_images/ecdsa256_secure_boot_signing_key_v2.pem'],
['burn_key', 'BLOCK_KEY0', 'images/efuse/128bit_key',
'XTS_AES_128_KEY_DERIVED_FROM_128_EFUSE_BITS']]
"""
groups = []
cmd = []
used_cmds = []
for item in all_args:
if item in SUPPORTED_COMMANDS:
used_cmds.append(item)
if cmd != []:
groups.append(cmd)
cmd = []
cmd.append(item)
if cmd:
groups.append(cmd)
return groups, used_cmds
def main(custom_commandline=None, esp=None):
"""
Main function for espefuse
custom_commandline - Optional override for default arguments parsing
(that uses sys.argv), can be a list of custom arguments as strings.
Arguments and their values need to be added as individual items to the list
e.g. "--port /dev/ttyUSB1" thus becomes ['--port', '/dev/ttyUSB1'].
esp - Optional override of the connected device previously
returned by esptool.get_default_connected_device()
"""
external_esp = esp is not None
init_parser = argparse.ArgumentParser(
description="espefuse.py v%s - [ESP32xx] efuse get/set tool"
% esptool.__version__,
prog="espefuse",
add_help=False,
)
init_parser.add_argument(
"--chip",
"-c",
help="Target chip type",
choices=["auto"] + list(SUPPORTED_CHIPS.keys()),
default=os.environ.get("ESPTOOL_CHIP", "auto"),
)
init_parser.add_argument(
"--baud",
"-b",
help="Serial port baud rate used when flashing/reading",
type=esptool.arg_auto_int,
default=os.environ.get("ESPTOOL_BAUD", esptool.loader.ESPLoader.ESP_ROM_BAUD),
)
init_parser.add_argument(
"--port",
"-p",
help="Serial port device",
default=os.environ.get("ESPTOOL_PORT", esptool.loader.ESPLoader.DEFAULT_PORT),
)
init_parser.add_argument(
"--before",
help="What to do before connecting to the chip",
choices=["default_reset", "usb_reset", "no_reset", "no_reset_no_sync"],
default="default_reset",
)
init_parser.add_argument(
"--debug",
"-d",
help="Show debugging information (loglevel=DEBUG)",
action="store_true",
)
init_parser.add_argument(
"--virt",
help="For host tests, the tool will work in the virtual mode "
"(without connecting to a chip).",
action="store_true",
)
init_parser.add_argument(
"--path-efuse-file",
help="For host tests, saves efuse memory to file.",
type=str,
default=None,
)
init_parser.add_argument(
"--do-not-confirm",
help="Do not pause for confirmation before permanently writing efuses. "
"Use with caution.",
action="store_true",
)
common_args, remaining_args = init_parser.parse_known_args(custom_commandline)
debug_mode = common_args.debug or ("dump" in remaining_args)
just_print_help = [
True for arg in remaining_args if arg in ["--help", "-h"]
] or remaining_args == []
print("espefuse.py v{}".format(esptool.__version__))
if not external_esp:
try:
esp = get_esp(
common_args.port,
common_args.baud,
common_args.before,
common_args.chip,
just_print_help,
common_args.virt,
common_args.debug,
common_args.path_efuse_file,
)
except esptool.FatalError as e:
raise esptool.FatalError(
f"{e}\nPlease make sure that you have specified "
"the right port with the --port argument"
)
# TODO: Require the --port argument in the next major release, ESPTOOL-490
efuses, efuse_operations = get_efuses(
esp, just_print_help, debug_mode, common_args.do_not_confirm
)
parser = argparse.ArgumentParser(parents=[init_parser])
subparsers = parser.add_subparsers(
dest="operation", help="Run espefuse.py {command} -h for additional help"
)
efuse_operations.add_commands(subparsers, efuses)
grouped_remaining_args, used_cmds = split_on_groups(remaining_args)
if len(grouped_remaining_args) == 0:
parser.print_help()
parser.exit(1)
there_are_multiple_burn_commands_in_args = (
sum(cmd in SUPPORTED_BURN_COMMANDS for cmd in used_cmds) > 1
)
if there_are_multiple_burn_commands_in_args:
efuses.batch_mode_cnt += 1
try:
for rem_args in grouped_remaining_args:
args, unused_args = parser.parse_known_args(rem_args, namespace=common_args)
if args.operation is None:
parser.print_help()
parser.exit(1)
assert (
len(unused_args) == 0
), 'Not all commands were recognized "{}"'.format(unused_args)
operation_func = vars(efuse_operations)[args.operation]
# each 'operation' is a module-level function of the same name
print('\n=== Run "{}" command ==='.format(args.operation))
if hasattr(args, "show_sensitive_info"):
if args.show_sensitive_info or args.debug:
args.show_sensitive_info = True
else:
print("Sensitive data will be hidden (see --show-sensitive-info)")
operation_func(esp, efuses, args)
if there_are_multiple_burn_commands_in_args:
efuses.batch_mode_cnt -= 1
if not efuses.burn_all(check_batch_mode=True):
raise esptool.FatalError("BURN was not done")
finally:
if not external_esp and not common_args.virt and esp._port:
esp._port.close()
def _main():
try:
main()
except esptool.FatalError as e:
print("\nA fatal error occurred: %s" % e)
sys.exit(2)
if __name__ == "__main__":
_main()
| 9,718 | Python | .py | 257 | 30.167315 | 88 | 0.631132 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,642 | emulate_efuse_controller_base.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/emulate_efuse_controller_base.py | # This file describes eFuses controller for ESP32 chip
#
# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import re
from bitstring import BitStream
class EmulateEfuseControllerBase(object):
"""The class for virtual efuse operations. Using for HOST_TEST."""
CHIP_NAME = ""
mem = None
debug = False
Blocks = None
Fields = None
REGS = None
def __init__(self, efuse_file=None, debug=False):
self.debug = debug
self.efuse_file = efuse_file
if self.efuse_file:
try:
self.mem = BitStream(
bytes=open(self.efuse_file, "rb").read(),
length=self.REGS.EFUSE_MEM_SIZE * 8,
)
except (ValueError, FileNotFoundError):
# the file is empty or does not fit the length.
self.mem = BitStream(length=self.REGS.EFUSE_MEM_SIZE * 8)
self.mem.set(0)
self.mem.tofile(open(self.efuse_file, "a+b"))
else:
# efuse_file is not provided
# it means we do not want to keep the result of efuse operations
self.mem = BitStream(self.REGS.EFUSE_MEM_SIZE * 8)
self.mem.set(0)
""" esptool method start >> """
def get_chip_description(self):
major_rev = self.get_major_chip_version()
minor_rev = self.get_minor_chip_version()
return f"{self.CHIP_NAME} (revision v{major_rev}.{minor_rev})"
def get_chip_revision(self):
return self.get_major_chip_version() * 100 + self.get_minor_chip_version()
def read_efuse(self, n, block=0):
"""Read the nth word of the ESP3x EFUSE region."""
blk = self.Blocks.get(self.Blocks.BLOCKS[block])
return self.read_reg(blk.rd_addr + (4 * n))
def read_reg(self, addr):
self.mem.pos = self.mem.length - ((addr - self.REGS.DR_REG_EFUSE_BASE) * 8 + 32)
return self.mem.read("uint:32")
def write_reg(self, addr, value, mask=0xFFFFFFFF, delay_us=0, delay_after_us=0):
self.mem.pos = self.mem.length - ((addr - self.REGS.DR_REG_EFUSE_BASE) * 8 + 32)
self.mem.overwrite("uint:32={}".format(value & mask))
self.handle_writing_event(addr, value)
def update_reg(self, addr, mask, new_val):
position = self.mem.length - ((addr - self.REGS.DR_REG_EFUSE_BASE) * 8 + 32)
self.mem.pos = position
cur_val = self.mem.read("uint:32")
self.mem.pos = position
self.mem.overwrite("uint:32={}".format(cur_val | (new_val & mask)))
def write_efuse(self, n, value, block=0):
"""Write the nth word of the ESP3x EFUSE region."""
blk = self.Blocks.get(self.Blocks.BLOCKS[block])
self.write_reg(blk.wr_addr + (4 * n), value)
""" << esptool method end """
def handle_writing_event(self, addr, value):
self.save_to_file()
def save_to_file(self):
if self.efuse_file:
with open(self.efuse_file, "wb") as f:
self.mem.tofile(f)
def handle_coding_scheme(self, blk, data):
return data
def copy_blocks_wr_regs_to_rd_regs(self, updated_block=None):
for b in reversed(self.Blocks.BLOCKS):
blk = self.Blocks.get(b)
if updated_block is not None:
if blk.id != updated_block:
continue
data = self.read_block(blk.id, wr_regs=True)
if self.debug:
print(blk.name, data.hex)
plain_data = self.handle_coding_scheme(blk, data)
plain_data = self.check_wr_protection_area(blk.id, plain_data)
self.update_block(blk, plain_data)
def clean_blocks_wr_regs(self):
for b in self.Blocks.BLOCKS:
blk = self.Blocks.get(b)
for offset in range(0, blk.len * 4, 4):
wr_addr = blk.wr_addr + offset
self.write_reg(wr_addr, 0)
def read_field(self, name, bitstring=True):
for field in self.Fields.EFUSES:
if field.name == name:
self.read_block(field.block)
block = self.read_block(field.block)
if field.type.startswith("bool"):
field_len = 1
else:
field_len = int(re.search(r"\d+", field.type).group())
if field.type.startswith("bytes"):
field_len *= 8
block.pos = block.length - (field.word * 32 + field.pos + field_len)
if bitstring:
return block.read(field_len)
else:
return block.read(field.type)
return None
def get_bitlen_of_block(self, blk, wr=False):
return 32 * blk.len
def read_block(self, idx, wr_regs=False):
block = None
for b in self.Blocks.BLOCKS:
blk = self.Blocks.get(b)
if blk.id == idx:
blk_len_bits = self.get_bitlen_of_block(blk, wr=wr_regs)
addr = blk.wr_addr if wr_regs else blk.rd_addr
self.mem.pos = self.mem.length - (
(addr - self.REGS.DR_REG_EFUSE_BASE) * 8 + blk_len_bits
)
block = self.mem.read(blk_len_bits)
break
return block
def update_block(self, blk, wr_data):
wr_data = self.read_block(blk.id) | wr_data
self.overwrite_mem_from_block(blk, wr_data)
def overwrite_mem_from_block(self, blk, wr_data):
self.mem.pos = self.mem.length - (
(blk.rd_addr - self.REGS.DR_REG_EFUSE_BASE) * 8 + wr_data.len
)
self.mem.overwrite(wr_data)
def check_wr_protection_area(self, num_blk, wr_data):
# checks fields which have the write protection bit.
# if the write protection bit is set, we need to protect that area from changes.
write_disable_bit = self.read_field("WR_DIS", bitstring=False)
mask_wr_data = BitStream(len(wr_data))
mask_wr_data.set(0)
blk = self.Blocks.get(self.Blocks.BLOCKS[num_blk])
if blk.write_disable_bit is not None and write_disable_bit & (
1 << blk.write_disable_bit
):
mask_wr_data.set(1)
else:
for field in self.Fields.EFUSES:
if blk.id == field.block and field.block == num_blk:
if field.write_disable_bit is not None and write_disable_bit & (
1 << field.write_disable_bit
):
data = self.read_field(field.name)
data.set(1)
mask_wr_data.pos = mask_wr_data.length - (
field.word * 32 + field.pos + data.len
)
mask_wr_data.overwrite(data)
mask_wr_data.invert()
return wr_data & mask_wr_data
def check_rd_protection_area(self):
# checks fields which have the read protection bits.
# if the read protection bit is set then we need to reset this field to 0.
read_disable_bit = self.read_field("RD_DIS", bitstring=False)
for b in self.Blocks.BLOCKS:
blk = self.Blocks.get(b)
block = self.read_block(blk.id)
if blk.read_disable_bit is not None and read_disable_bit & (
1 << blk.read_disable_bit
):
block.set(0)
else:
for field in self.Fields.EFUSES:
if (
blk.id == field.block
and field.read_disable_bit is not None
and read_disable_bit & (1 << field.read_disable_bit)
):
raw_data = self.read_field(field.name)
raw_data.set(0)
block.pos = block.length - (
field.word * 32 + field.pos + raw_data.length
)
block.overwrite(BitStream(raw_data.length))
self.overwrite_mem_from_block(blk, block)
def clean_mem(self):
self.mem.set(0)
if self.efuse_file:
with open(self.efuse_file, "wb") as f:
self.mem.tofile(f)
class FatalError(RuntimeError):
"""
Wrapper class for runtime errors that aren't caused by internal bugs
"""
def __init__(self, message):
RuntimeError.__init__(self, message)
@staticmethod
def WithResult(message, result):
return FatalError(result)
| 8,630 | Python | .py | 193 | 32.585492 | 88 | 0.55586 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,643 | util.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/util.py | # This file consists of the common useful functions for eFuse
#
# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import esptool
def hexify(bitstring, separator=""):
as_bytes = tuple(b for b in bitstring)
return separator.join(("%02x" % b) for b in as_bytes)
def popcnt(b):
"""Return number of "1" bits set in 'b'"""
return len([x for x in bin(b) if x == "1"])
def check_duplicate_name_in_list(name_list):
duples_name = [name for i, name in enumerate(name_list) if name in name_list[:i]]
if duples_name != []:
raise esptool.FatalError(
"Found repeated {} in the name list".format(duples_name)
)
class SdkConfig(object):
def __init__(self, path_to_file):
self.sdkconfig = dict()
if path_to_file is None:
return
with open(path_to_file, "r") as file:
for line in file.readlines():
if line.startswith("#"):
continue
config = line.strip().split("=", 1)
if len(config) == 2:
self.sdkconfig[config[0]] = (
True if config[1] == "y" else config[1].strip('"')
)
def __getitem__(self, config_name):
try:
return self.sdkconfig[config_name]
except KeyError:
return False
| 1,416 | Python | .py | 37 | 29.432432 | 85 | 0.577064 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,644 | base_operations.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/base_operations.py | # This file includes the common operations with eFuses for chips
#
# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import argparse
import json
import sys
from bitstring import BitStream
import esptool
from . import base_fields
from . import util
def add_common_commands(subparsers, efuses):
class ActionEfuseValuePair(argparse.Action):
def __init__(self, option_strings, dest, nargs=None, **kwargs):
self._nargs = nargs
self._choices = kwargs.get("efuse_choices")
self.efuses = kwargs.get("efuses")
del kwargs["efuse_choices"]
del kwargs["efuses"]
super(ActionEfuseValuePair, self).__init__(
option_strings, dest, nargs=nargs, **kwargs
)
def __call__(self, parser, namespace, values, option_string=None):
def check_efuse_name(efuse_name, efuse_list):
if efuse_name not in self._choices:
raise esptool.FatalError(
"Invalid the efuse name '{}'. "
"Available the efuse names: {}".format(
efuse_name, self._choices
)
)
efuse_value_pairs = {}
if len(values) > 1:
if len(values) % 2:
raise esptool.FatalError(
"The list does not have a valid pair (name value) {}".format(
values
)
)
for i in range(0, len(values), 2):
efuse_name, new_value = values[i : i + 2 :]
check_efuse_name(efuse_name, self._choices)
check_arg = base_fields.CheckArgValue(self.efuses, efuse_name)
efuse_value_pairs[efuse_name] = check_arg(new_value)
else:
# For the case of compatibility, when only the efuse_name is given
# Fields with 'bitcount' and 'bool' types can be without new_value arg
efuse_name = values[0]
check_efuse_name(efuse_name, self._choices)
check_arg = base_fields.CheckArgValue(self.efuses, efuse_name)
efuse_value_pairs[efuse_name] = check_arg(None)
setattr(namespace, self.dest, efuse_value_pairs)
burn = subparsers.add_parser(
"burn_efuse", help="Burn the efuse with the specified name"
)
burn.add_argument(
"name_value_pairs",
help="Name of efuse register and New value pairs to burn",
action=ActionEfuseValuePair,
nargs="+",
metavar="[EFUSE_NAME VALUE] [{} VALUE".format(
" VALUE] [".join([e.name for e in efuses.efuses])
),
efuse_choices=[e.name for e in efuses.efuses]
+ [name for e in efuses.efuses for name in e.alt_names if name != ""],
efuses=efuses,
)
read_protect_efuse = subparsers.add_parser(
"read_protect_efuse",
help="Disable readback for the efuse with the specified name",
)
read_protect_efuse.add_argument(
"efuse_name",
help="Name of efuse register to burn",
nargs="+",
choices=[e.name for e in efuses.efuses if e.read_disable_bit is not None]
+ [
name
for e in efuses.efuses
if e.read_disable_bit is not None
for name in e.alt_names
if name != ""
],
)
write_protect_efuse = subparsers.add_parser(
"write_protect_efuse",
help="Disable writing to the efuse with the specified name",
)
write_protect_efuse.add_argument(
"efuse_name",
help="Name of efuse register to burn",
nargs="+",
choices=[e.name for e in efuses.efuses if e.write_disable_bit is not None]
+ [
name
for e in efuses.efuses
if e.write_disable_bit is not None
for name in e.alt_names
if name != ""
],
)
burn_block_data = subparsers.add_parser(
"burn_block_data",
help="Burn non-key data to EFUSE blocks. "
"(Don't use this command to burn key data for Flash Encryption or "
"ESP32 Secure Boot V1, as the byte order of keys is swapped (use burn_key)).",
)
add_force_write_always(burn_block_data)
burn_block_data.add_argument(
"--offset", "-o", help="Byte offset in the efuse block", type=int, default=0
)
burn_block_data.add_argument(
"block",
help="Efuse block to burn.",
action="append",
choices=efuses.BURN_BLOCK_DATA_NAMES,
)
burn_block_data.add_argument(
"datafile",
help="File containing data to burn into the efuse block",
action="append",
type=argparse.FileType("rb"),
)
for _ in range(0, len(efuses.BURN_BLOCK_DATA_NAMES)):
burn_block_data.add_argument(
"block",
help="Efuse block to burn.",
metavar="BLOCK",
nargs="?",
action="append",
choices=efuses.BURN_BLOCK_DATA_NAMES,
)
burn_block_data.add_argument(
"datafile",
nargs="?",
help="File containing data to burn into the efuse block",
metavar="DATAFILE",
action="append",
type=argparse.FileType("rb"),
)
set_bit_cmd = subparsers.add_parser("burn_bit", help="Burn bit in the efuse block.")
add_force_write_always(set_bit_cmd)
set_bit_cmd.add_argument(
"block", help="Efuse block to burn.", choices=efuses.BURN_BLOCK_DATA_NAMES
)
set_bit_cmd.add_argument(
"bit_number",
help="Bit number in the efuse block [0..BLK_LEN-1]",
nargs="+",
type=int,
)
subparsers.add_parser(
"adc_info",
help="Display information about ADC calibration data stored in efuse.",
)
dump_cmd = subparsers.add_parser("dump", help="Dump raw hex values of all efuses")
dump_cmd.add_argument(
"--file_name",
help="Saves dump for each block into separate file. Provide the common "
"path name /path/blk.bin, it will create: blk0.bin, blk1.bin ... blkN.bin. "
"Use burn_block_data to write it back to another chip.",
)
summary_cmd = subparsers.add_parser(
"summary", help="Print human-readable summary of efuse values"
)
summary_cmd.add_argument(
"--format",
help="Select the summary format",
choices=["summary", "json"],
default="summary",
)
summary_cmd.add_argument(
"--file",
help="File to save the efuse summary",
type=argparse.FileType("w"),
default=sys.stdout,
)
execute_scripts = subparsers.add_parser(
"execute_scripts", help="Executes scripts to burn at one time."
)
execute_scripts.add_argument(
"scripts",
help="The special format of python scripts.",
nargs="+",
type=argparse.FileType("r"),
)
execute_scripts.add_argument(
"--index",
help="integer index. "
"It allows to retrieve unique data per chip from configfiles "
"and then burn them (ex. CUSTOM_MAC, UNIQUE_ID).",
type=int,
)
execute_scripts.add_argument(
"--configfiles",
help="List of configfiles with data",
nargs="?",
action="append",
type=argparse.FileType("r"),
)
check_error_cmd = subparsers.add_parser("check_error", help="Checks eFuse errors")
check_error_cmd.add_argument(
"--recovery",
help="Recovery of BLOCKs after encoding errors",
action="store_true",
)
def add_force_write_always(p):
p.add_argument(
"--force-write-always",
help="Write the efuse even if it looks like it's already been written, "
"or is write protected. Note that this option can't disable write protection, "
"or clear any bit which has already been set.",
action="store_true",
)
def add_show_sensitive_info_option(p):
p.add_argument(
"--show-sensitive-info",
help="Show data to be burned (may expose sensitive data). "
"Enabled if --debug is used.",
action="store_true",
default=False,
)
def summary(esp, efuses, args):
"""Print a human-readable summary of efuse contents"""
ROW_FORMAT = "%-50s %-50s%s = %s %s %s"
human_output = args.format == "summary"
json_efuse = {}
if args.file != sys.stdout:
print("Saving efuse values to " + args.file.name)
if human_output:
print(
ROW_FORMAT.replace("-50", "-12")
% (
"EFUSE_NAME (Block)",
"Description",
"",
"[Meaningful Value]",
"[Readable/Writeable]",
"(Hex Value)",
),
file=args.file,
)
print("-" * 88, file=args.file)
for category in sorted(set(e.category for e in efuses), key=lambda c: c.title()):
if human_output:
print("%s fuses:" % category.title(), file=args.file)
for e in (e for e in efuses if e.category == category):
if e.efuse_type.startswith("bytes"):
raw = ""
else:
raw = "({})".format(e.get_bitstring())
(readable, writeable) = (e.is_readable(), e.is_writeable())
if readable and writeable:
perms = "R/W"
elif readable:
perms = "R/-"
elif writeable:
perms = "-/W"
else:
perms = "-/-"
base_value = e.get_meaning()
value = str(base_value)
if not readable:
count_read_disable_bits = e.get_count_read_disable_bits()
if count_read_disable_bits == 2:
# On the C2 chip, BLOCK_KEY0 has two read protection bits [0, 1]
# related to the lower and higher part of the block.
v = [value[: (len(value) // 2)], value[(len(value) // 2) :]]
for i in range(count_read_disable_bits):
if not e.is_readable(blk_part=i):
v[i] = v[i].replace("0", "?")
value = "".join(v)
else:
value = value.replace("0", "?")
if human_output:
print(
ROW_FORMAT
% (
e.get_info(),
e.description[:50],
"\n " if len(value) > 20 else "",
value,
perms,
raw,
),
file=args.file,
)
desc_len = len(e.description[50:])
if desc_len:
desc_len += 50
for i in range(50, desc_len, 50):
print(
"%-50s %-50s" % ("", e.description[i : (50 + i)]),
file=args.file,
)
if args.format == "json":
json_efuse[e.name] = {
"name": e.name,
"value": base_value if readable else value,
"readable": readable,
"writeable": writeable,
"description": e.description,
"category": e.category,
"block": e.block,
"word": e.word,
"pos": e.pos,
"efuse_type": e.efuse_type,
"bit_len": e.bit_len,
}
if human_output:
print("", file=args.file)
if human_output:
print(efuses.summary(), file=args.file)
warnings = efuses.get_coding_scheme_warnings()
if warnings:
print(
"WARNING: Coding scheme has encoding bit error warnings", file=args.file
)
if args.file != sys.stdout:
args.file.close()
print("Done")
if args.format == "json":
json.dump(json_efuse, args.file, sort_keys=True, indent=4)
print("")
def dump(esp, efuses, args):
"""Dump raw efuse data registers"""
# Using --debug option allows to print dump.
# Nothing to do here. The log will be printed
# during EspEfuses.__init__() in self.read_blocks()
if args.file_name:
# save dump to the file
for block in efuses.blocks:
file_dump_name = args.file_name
place_for_index = file_dump_name.find(".bin")
file_dump_name = (
file_dump_name[:place_for_index]
+ str(block.id)
+ file_dump_name[place_for_index:]
)
print(file_dump_name)
with open(file_dump_name, "wb") as f:
block.get_bitstring().byteswap()
block.get_bitstring().tofile(f)
def burn_efuse(esp, efuses, args):
def print_attention(blocked_efuses_after_burn):
if len(blocked_efuses_after_burn):
print(
" ATTENTION! This BLOCK uses NOT the NONE coding scheme "
"and after 'BURN', these efuses can not be burned in the feature:"
)
for i in range(0, len(blocked_efuses_after_burn), 5):
print(
" ",
"".join("{}".format(blocked_efuses_after_burn[i : i + 5 :])),
)
efuse_name_list = [name for name in args.name_value_pairs.keys()]
burn_efuses_list = [efuses[name] for name in efuse_name_list]
old_value_list = [efuses[name].get_raw() for name in efuse_name_list]
new_value_list = [value for value in args.name_value_pairs.values()]
util.check_duplicate_name_in_list(efuse_name_list)
attention = ""
print("The efuses to burn:")
for block in efuses.blocks:
burn_list_a_block = [e for e in burn_efuses_list if e.block == block.id]
if len(burn_list_a_block):
print(" from BLOCK%d" % (block.id))
for field in burn_list_a_block:
print(" - %s" % (field.name))
if (
efuses.blocks[field.block].get_coding_scheme()
!= efuses.REGS.CODING_SCHEME_NONE
):
using_the_same_block_names = [
e.name for e in efuses if e.block == field.block
]
wr_names = [e.name for e in burn_list_a_block]
blocked_efuses_after_burn = [
name
for name in using_the_same_block_names
if name not in wr_names
]
attention = " (see 'ATTENTION!' above)"
if attention:
print_attention(blocked_efuses_after_burn)
print("\nBurning efuses{}:".format(attention))
for efuse, new_value in zip(burn_efuses_list, new_value_list):
print(
"\n - '{}' ({}) {} -> {}".format(
efuse.name,
efuse.description,
efuse.get_bitstring(),
efuse.convert_to_bitstring(new_value),
)
)
efuse.save(new_value)
print()
if "ENABLE_SECURITY_DOWNLOAD" in efuse_name_list:
print(
"ENABLE_SECURITY_DOWNLOAD -> 1: eFuses will not be read back "
"for confirmation because this mode disables "
"any SRAM and register operations."
)
print(" espefuse will not work.")
print(" esptool can read/write only flash.")
if "DIS_DOWNLOAD_MODE" in efuse_name_list:
print(
"DIS_DOWNLOAD_MODE -> 1: eFuses will not be read back for "
"confirmation because this mode disables any communication with the chip."
)
print(
" espefuse/esptool will not work because "
"they will not be able to connect to the chip."
)
if (
esp.CHIP_NAME == "ESP32"
and esp.get_chip_revision() >= 300
and "UART_DOWNLOAD_DIS" in efuse_name_list
):
print(
"UART_DOWNLOAD_DIS -> 1: eFuses will be read for confirmation, "
"but after that connection to the chip will become impossible."
)
print(" espefuse/esptool will not work.")
if not efuses.burn_all(check_batch_mode=True):
return
print("Checking efuses...")
raise_error = False
for efuse, old_value, new_value in zip(
burn_efuses_list, old_value_list, new_value_list
):
if not efuse.is_readable():
print(
"Efuse %s is read-protected. Read back the burn value is not possible."
% efuse.name
)
else:
new_value = efuse.convert_to_bitstring(new_value)
burned_value = efuse.get_bitstring()
if burned_value != new_value:
print(
burned_value,
"->",
new_value,
"Efuse %s failed to burn. Protected?" % efuse.name,
)
raise_error = True
if raise_error:
raise esptool.FatalError("The burn was not successful.")
else:
print("Successful")
def read_protect_efuse(esp, efuses, args):
util.check_duplicate_name_in_list(args.efuse_name)
for efuse_name in args.efuse_name:
efuse = efuses[efuse_name]
if not efuse.is_readable():
print("Efuse %s is already read protected" % efuse.name)
else:
if esp.CHIP_NAME == "ESP32":
if (
efuse_name == "BLOCK2"
and not efuses["ABS_DONE_0"].get()
and esp.get_chip_revision() >= 300
):
if efuses["ABS_DONE_1"].get():
raise esptool.FatalError(
"Secure Boot V2 is on (ABS_DONE_1 = True), "
"BLOCK2 must be readable, stop this operation!"
)
else:
print(
"If Secure Boot V2 is used, BLOCK2 must be readable, "
"please stop this operation!"
)
elif esp.CHIP_NAME == "ESP32-C2":
error = (
not efuses["XTS_KEY_LENGTH_256"].get()
and efuse_name == "BLOCK_KEY0"
)
error |= efuses["SECURE_BOOT_EN"].get() and efuse_name in [
"BLOCK_KEY0",
"BLOCK_KEY0_HI_128",
]
if error:
raise esptool.FatalError(
"%s must be readable, stop this operation!" % efuse_name
)
else:
for block in efuses.Blocks.BLOCKS:
block = efuses.Blocks.get(block)
if block.name == efuse_name and block.key_purpose is not None:
if not efuses[block.key_purpose].need_rd_protect(
efuses[block.key_purpose].get()
):
raise esptool.FatalError(
"%s must be readable, stop this operation!" % efuse_name
)
break
# make full list of which efuses will be disabled
# (ie share a read disable bit)
all_disabling = [
e for e in efuses if e.read_disable_bit == efuse.read_disable_bit
]
names = ", ".join(e.name for e in all_disabling)
print(
"Permanently read-disabling efuse%s %s"
% ("s" if len(all_disabling) > 1 else "", names)
)
efuse.disable_read()
if not efuses.burn_all(check_batch_mode=True):
return
print("Checking efuses...")
raise_error = False
for efuse_name in args.efuse_name:
efuse = efuses[efuse_name]
if efuse.is_readable():
print("Efuse %s is not read-protected." % efuse.name)
raise_error = True
if raise_error:
raise esptool.FatalError("The burn was not successful.")
else:
print("Successful")
def write_protect_efuse(esp, efuses, args):
util.check_duplicate_name_in_list(args.efuse_name)
for efuse_name in args.efuse_name:
efuse = efuses[efuse_name]
if not efuse.is_writeable():
print("Efuse %s is already write protected" % efuse.name)
else:
# make full list of which efuses will be disabled
# (ie share a write disable bit)
all_disabling = [
e for e in efuses if e.write_disable_bit == efuse.write_disable_bit
]
names = ", ".join(e.name for e in all_disabling)
print(
"Permanently write-disabling efuse%s %s"
% ("s" if len(all_disabling) > 1 else "", names)
)
efuse.disable_write()
if not efuses.burn_all(check_batch_mode=True):
return
print("Checking efuses...")
raise_error = False
for efuse_name in args.efuse_name:
efuse = efuses[efuse_name]
if efuse.is_writeable():
print("Efuse %s is not write-protected." % efuse.name)
raise_error = True
if raise_error:
raise esptool.FatalError("The burn was not successful.")
else:
print("Successful")
def burn_block_data(esp, efuses, args):
block_name_list = args.block[
0 : len([name for name in args.block if name is not None]) :
]
datafile_list = args.datafile[
0 : len([name for name in args.datafile if name is not None]) :
]
efuses.force_write_always = args.force_write_always
util.check_duplicate_name_in_list(block_name_list)
if args.offset and len(block_name_list) > 1:
raise esptool.FatalError(
"The 'offset' option is not applicable when a few blocks are passed. "
"With 'offset', should only one block be used."
)
else:
offset = args.offset
if offset:
num_block = efuses.get_index_block_by_name(block_name_list[0])
block = efuses.blocks[num_block]
num_bytes = block.get_block_len()
if offset >= num_bytes:
raise esptool.FatalError(
"Invalid offset: the block%d only holds %d bytes."
% (block.id, num_bytes)
)
if len(block_name_list) != len(datafile_list):
raise esptool.FatalError(
"The number of block_name (%d) and datafile (%d) should be the same."
% (len(block_name_list), len(datafile_list))
)
for block_name, datafile in zip(block_name_list, datafile_list):
num_block = efuses.get_index_block_by_name(block_name)
block = efuses.blocks[num_block]
data = datafile.read()
num_bytes = block.get_block_len()
if offset != 0:
data = (b"\x00" * offset) + data
data = data + (b"\x00" * (num_bytes - len(data)))
if len(data) != num_bytes:
raise esptool.FatalError(
"Data does not fit: the block%d size is %d bytes, "
"data file is %d bytes, offset %d"
% (block.id, num_bytes, len(data), offset)
)
print(
"[{:02}] {:20} size={:02} bytes, offset={:02} - > [{}].".format(
block.id, block.name, len(data), offset, util.hexify(data, " ")
)
)
block.save(data)
if not efuses.burn_all(check_batch_mode=True):
return
print("Successful")
def burn_bit(esp, efuses, args):
efuses.force_write_always = args.force_write_always
num_block = efuses.get_index_block_by_name(args.block)
block = efuses.blocks[num_block]
data_block = BitStream(block.get_block_len() * 8)
data_block.set(0)
try:
data_block.set(True, args.bit_number)
except IndexError:
raise esptool.FatalError(
"%s has bit_number in [0..%d]" % (args.block, data_block.len - 1)
)
data_block.reverse()
print(
"bit_number: "
"[%-03d]........................................................[0]"
% (data_block.len - 1)
)
print("BLOCK%-2d :" % block.id, data_block)
block.print_block(data_block, "regs_to_write", debug=True)
block.save(data_block.bytes[::-1])
if not efuses.burn_all(check_batch_mode=True):
return
print("Successful")
def get_error_summary(efuses):
error_in_blocks = efuses.get_coding_scheme_warnings()
if not error_in_blocks:
return False
writable = True
for blk in efuses.blocks:
if blk.fail or blk.num_errors:
if blk.id == 0:
for field in efuses:
if field.block == blk.id and (field.fail or field.num_errors):
wr = "writable" if field.is_writeable() else "not writable"
writable &= wr == "writable"
name = field.name
val = field.get()
print(f"BLOCK{field.block:<2}: {name:<40} = {val:<8} ({wr})")
else:
wr = "writable" if blk.is_writeable() else "not writable"
writable &= wr == "writable"
name = f"{blk.name} [ERRORS:{blk.num_errors} FAIL:{int(blk.fail)}]"
val = str(blk.get_bitstring())
print(f"BLOCK{blk.id:<2}: {name:<40} = {val:<8} ({wr})")
if not writable and error_in_blocks:
print("Not all errors can be fixed because some fields are write-protected!")
return True
def check_error(esp, efuses, args):
error_in_blocks = get_error_summary(efuses)
if args.recovery and error_in_blocks:
confirmed = False
for block in reversed(efuses.blocks):
if block.fail or block.num_errors > 0:
if not block.get_bitstring().all(False):
block.save(block.get_bitstring().bytes[::-1])
if not confirmed:
confirmed = True
efuses.confirm(
"Recovery of block coding errors", args.do_not_confirm
)
block.burn()
if confirmed:
efuses.update_efuses()
error_in_blocks = get_error_summary(efuses)
if error_in_blocks:
raise esptool.FatalError("Error(s) were detected in eFuses")
print("No errors detected")
| 27,177 | Python | .py | 674 | 28.287834 | 88 | 0.527717 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,645 | base_fields.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/base_fields.py | # This file describes the common eFuses structures for chips
#
# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import binascii
import sys
from bitstring import BitArray, BitStream, CreationError
import esptool
from . import util
class CheckArgValue(object):
def __init__(self, efuses, name):
self.efuses = efuses
self.name = name
def __call__(self, new_value_str):
def check_arg_value(efuse, new_value):
if efuse.efuse_type.startswith("bool"):
new_value = 1 if new_value is None else int(new_value, 0)
if new_value != 1:
raise esptool.FatalError(
"New value is not accepted for efuse '{}' "
"(will always burn 0->1), given value={}".format(
efuse.name, new_value
)
)
elif efuse.efuse_type.startswith(("int", "uint")):
if efuse.efuse_class == "bitcount":
if new_value is None:
# find the first unset bit and set it
old_value = efuse.get_raw()
new_value = old_value
bit = 1
while new_value == old_value:
new_value = bit | old_value
bit <<= 1
else:
new_value = int(new_value, 0)
else:
if new_value is None:
raise esptool.FatalError(
"New value required for efuse '{}' (given None)".format(
efuse.name
)
)
new_value = int(new_value, 0)
if new_value == 0:
raise esptool.FatalError(
"New value should not be 0 for '{}' "
"(given value= {})".format(efuse.name, new_value)
)
elif efuse.efuse_type.startswith("bytes"):
if new_value is None:
raise esptool.FatalError(
"New value required for efuse '{}' "
"(given None)".format(efuse.name)
)
if len(new_value) * 8 != efuse.bitarray.len:
raise esptool.FatalError(
"The length of efuse '{}' ({} bits) "
"(given len of the new value= {} bits)".format(
efuse.name, efuse.bitarray.len, len(new_value) * 8
)
)
else:
raise esptool.FatalError(
"The '{}' type for the '{}' efuse is not supported yet.".format(
efuse.efuse_type, efuse.name
)
)
return new_value
efuse = self.efuses[self.name]
new_value = efuse.check_format(new_value_str)
return check_arg_value(efuse, new_value)
class EfuseProtectBase(object):
# This class is used by EfuseBlockBase and EfuseFieldBase
def get_read_disable_mask(self, blk_part=None):
"""Returns mask of read protection bits
blk_part:
- None: Calculate mask for all read protection bits.
- a number: Calculate mask only for specific item in read protection list.
"""
mask = 0
if isinstance(self.read_disable_bit, list):
if blk_part is None:
for i in self.read_disable_bit:
mask |= 1 << i
else:
mask |= 1 << self.read_disable_bit[blk_part]
else:
mask = 1 << self.read_disable_bit
return mask
def get_count_read_disable_bits(self):
"""Returns the number of read protection bits used by the field"""
# On the C2 chip, BLOCK_KEY0 has two read protection bits [0, 1].
return bin(self.get_read_disable_mask()).count("1")
def is_readable(self, blk_part=None):
"""Return true if the efuse is readable by software"""
num_bit = self.read_disable_bit
if num_bit is None:
return True # read cannot be disabled
return (self.parent["RD_DIS"].get() & self.get_read_disable_mask(blk_part)) == 0
def disable_read(self):
num_bit = self.read_disable_bit
if num_bit is None:
raise esptool.FatalError("This efuse cannot be read-disabled")
if not self.parent["RD_DIS"].is_writeable():
raise esptool.FatalError(
"This efuse cannot be read-disabled due the to RD_DIS field is "
"already write-disabled"
)
self.parent["RD_DIS"].save(self.get_read_disable_mask())
def is_writeable(self):
num_bit = self.write_disable_bit
if num_bit is None:
return True # write cannot be disabled
return (self.parent["WR_DIS"].get() & (1 << num_bit)) == 0
def disable_write(self):
num_bit = self.write_disable_bit
if not self.parent["WR_DIS"].is_writeable():
raise esptool.FatalError(
"This efuse cannot be write-disabled due to the WR_DIS field is "
"already write-disabled"
)
self.parent["WR_DIS"].save(1 << num_bit)
def check_wr_rd_protect(self):
if not self.is_readable():
error_msg = "\t{} is read-protected.".format(self.name)
"The written value can not be read, the efuse/block looks as all 0.\n"
error_msg += "\tBurn in this case may damage an already written value."
self.parent.print_error_msg(error_msg)
if not self.is_writeable():
error_msg = "\t{} is write-protected. Burn is not possible.".format(
self.name
)
self.parent.print_error_msg(error_msg)
class EfuseBlockBase(EfuseProtectBase):
def __init__(self, parent, param, skip_read=False):
self.parent = parent
self.name = param.name
self.alias = param.alias
self.id = param.id
self.rd_addr = param.rd_addr
self.wr_addr = param.wr_addr
self.write_disable_bit = param.write_disable_bit
self.read_disable_bit = param.read_disable_bit
self.len = param.len
self.key_purpose_name = param.key_purpose
bit_block_len = self.get_block_len() * 8
self.bitarray = BitStream(bit_block_len)
self.bitarray.set(0)
self.wr_bitarray = BitStream(bit_block_len)
self.wr_bitarray.set(0)
self.fail = False
self.num_errors = 0
if self.id == 0:
self.err_bitarray = BitStream(bit_block_len)
self.err_bitarray.set(0)
else:
self.err_bitarray = None
if not skip_read:
self.read()
def get_block_len(self):
coding_scheme = self.get_coding_scheme()
if coding_scheme == self.parent.REGS.CODING_SCHEME_NONE:
return self.len * 4
elif coding_scheme == self.parent.REGS.CODING_SCHEME_34:
return (self.len * 3 // 4) * 4
elif coding_scheme == self.parent.REGS.CODING_SCHEME_RS:
return self.len * 4
else:
raise esptool.FatalError(
"Coding scheme (%d) not supported" % (coding_scheme)
)
def get_coding_scheme(self):
if self.id == 0:
return self.parent.REGS.CODING_SCHEME_NONE
else:
return self.parent.coding_scheme
def get_raw(self, from_read=True):
if from_read:
return self.bitarray.bytes
else:
return self.wr_bitarray.bytes
def get(self, from_read=True):
self.get_bitstring(from_read=from_read)
def get_bitstring(self, from_read=True):
if from_read:
return self.bitarray
else:
return self.wr_bitarray
def convert_to_bitstring(self, new_data):
if isinstance(new_data, BitArray):
return new_data
else:
return BitArray(bytes=new_data, length=len(new_data) * 8)
def get_words(self):
def get_offsets(self):
return [x + self.rd_addr for x in range(0, self.get_block_len(), 4)]
return [self.parent.read_reg(offs) for offs in get_offsets(self)]
def read(self):
words = self.get_words()
data = BitArray()
for word in reversed(words):
data.append("uint:32=%d" % word)
self.bitarray.overwrite(data, pos=0)
self.print_block(self.bitarray, "read_regs")
def print_block(self, bit_string, comment, debug=False):
if self.parent.debug or debug:
bit_string.pos = 0
print(
"%-15s (%-16s) [%-2d] %s:"
% (self.name, " ".join(self.alias)[:16], self.id, comment),
" ".join(
[
"%08x" % word
for word in bit_string.readlist(
"%d*uint:32" % (bit_string.len / 32)
)[::-1]
]
),
)
def check_wr_data(self):
wr_data = self.wr_bitarray
if wr_data.all(False):
# nothing to burn
if self.parent.debug:
print("[{:02}] {:20} nothing to burn".format(self.id, self.name))
return False
if len(wr_data.bytes) != len(self.bitarray.bytes):
raise esptool.FatalError(
"Data does not fit: the block%d size is %d bytes, data is %d bytes"
% (self.id, len(self.bitarray.bytes), len(wr_data.bytes))
)
self.check_wr_rd_protect()
if self.get_bitstring().all(False):
print(
"[{:02}] {:20} is empty, will burn the new value".format(
self.id, self.name
)
)
else:
# the written block in chip is not empty
if self.get_bitstring() == wr_data:
print(
"[{:02}] {:20} is already written the same value, "
"continue with EMPTY_BLOCK".format(self.id, self.name)
)
wr_data.set(0)
else:
print("[{:02}] {:20} is not empty".format(self.id, self.name))
print("\t(written ):", self.get_bitstring())
print("\t(to write):", wr_data)
mask = self.get_bitstring() & wr_data
if mask == wr_data:
print(
"\tAll wr_data bits are set in the written block, "
"continue with EMPTY_BLOCK."
)
wr_data.set(0)
else:
coding_scheme = self.get_coding_scheme()
if coding_scheme == self.parent.REGS.CODING_SCHEME_NONE:
print("\t(coding scheme = NONE)")
elif coding_scheme == self.parent.REGS.CODING_SCHEME_RS:
print("\t(coding scheme = RS)")
error_msg = (
"\tBurn into %s is forbidden "
"(RS coding scheme does not allow this)." % (self.name)
)
self.parent.print_error_msg(error_msg)
elif coding_scheme == self.parent.REGS.CODING_SCHEME_34:
print("\t(coding scheme = 3/4)")
data_can_not_be_burn = False
for i in range(0, self.get_bitstring().len, 6 * 8):
rd_chunk = self.get_bitstring()[i : i + 6 * 8 :]
wr_chunk = wr_data[i : i + 6 * 8 :]
if rd_chunk.any(True):
if wr_chunk.any(True):
print(
"\twritten chunk [%d] and wr_chunk "
"are not empty. " % (i // (6 * 8)),
end="",
)
if rd_chunk == wr_chunk:
print(
"wr_chunk == rd_chunk. "
"Countinue with empty chunk."
)
wr_data[i : i + 6 * 8 :].set(0)
else:
print("wr_chunk != rd_chunk. Can not burn.")
print("\twritten ", rd_chunk)
print("\tto write", wr_chunk)
data_can_not_be_burn = True
if data_can_not_be_burn:
error_msg = (
"\tBurn into %s is forbidden "
"(3/4 coding scheme does not allow this)." % (self.name)
)
self.parent.print_error_msg(error_msg)
else:
raise esptool.FatalError(
"The coding scheme ({}) is not supported".format(
coding_scheme
)
)
def save(self, new_data):
# new_data will be checked by check_wr_data() during burn_all()
# new_data (bytes) = [0][1][2] ... [N] (original data)
# in string format = [0] [1] [2] ... [N] (util.hexify(data, " "))
# in hex format = 0x[N]....[2][1][0] (from bitstring print(data))
# in reg format = [3][2][1][0] ... [N][][][] (as it will be in the device)
# in bitstring = [N] ... [2][1][0] (to get a correct bitstring
# need to reverse new_data)
# *[x] - means a byte.
data = BitStream(bytes=new_data[::-1], length=len(new_data) * 8)
if self.parent.debug:
print(
"\twritten : {} ->\n\tto write: {}".format(self.get_bitstring(), data)
)
self.wr_bitarray.overwrite(self.wr_bitarray | data, pos=0)
def burn_words(self, words):
for burns in range(3):
self.parent.efuse_controller_setup()
if self.parent.debug:
print("Write data to BLOCK%d" % (self.id))
write_reg_addr = self.wr_addr
for word in words:
# for ep32s2: using EFUSE_PGM_DATA[0..7]_REG for writing data
# 32 bytes to EFUSE_PGM_DATA[0..7]_REG
# 12 bytes to EFUSE_CHECK_VALUE[0..2]_REG. These regs are next after
# EFUSE_PGM_DATA_REG
# for esp32:
# each block has the special regs EFUSE_BLK[0..3]_WDATA[0..7]_REG
# for writing data
if self.parent.debug:
print("Addr 0x%08x, data=0x%08x" % (write_reg_addr, word))
self.parent.write_reg(write_reg_addr, word)
write_reg_addr += 4
self.parent.write_efuses(self.id)
for _ in range(5):
self.parent.efuse_read()
self.parent.get_coding_scheme_warnings(silent=True)
if self.fail or self.num_errors:
print(
"Error in BLOCK%d, re-burn it again (#%d), to fix it. "
"fail_bit=%d, num_errors=%d"
% (self.id, burns, self.fail, self.num_errors)
)
break
if not self.fail and self.num_errors == 0:
break
def burn(self):
if self.wr_bitarray.all(False):
# nothing to burn
return
before_burn_bitarray = self.bitarray[:]
assert before_burn_bitarray is not self.bitarray
self.print_block(self.wr_bitarray, "to_write")
words = self.apply_coding_scheme()
self.burn_words(words)
self.read()
if not self.is_readable():
print(
"{} ({}) is read-protected. "
"Read back the burn value is not possible.".format(
self.name, self.alias
)
)
if self.bitarray.all(False):
print("Read all '0'")
else:
# Should never happen
raise esptool.FatalError(
"The {} is read-protected but not all '0' ({})".format(
self.name, self.bitarray.hex
)
)
else:
if self.wr_bitarray == self.bitarray:
print("BURN BLOCK%-2d - OK (write block == read block)" % self.id)
elif (
self.wr_bitarray & self.bitarray == self.wr_bitarray
and self.bitarray & before_burn_bitarray == before_burn_bitarray
):
print("BURN BLOCK%-2d - OK (all write block bits are set)" % self.id)
else:
# Happens only when an efuse is written and read-protected
# in one command
self.print_block(self.wr_bitarray, "Expected")
self.print_block(self.bitarray, "Real ")
# Read-protected BLK0 values are reported back as zeros,
# raise error only for other blocks
if self.id != 0:
raise esptool.FatalError(
"Burn {} ({}) was not successful".format(self.name, self.alias)
)
self.wr_bitarray.set(0)
class EspEfusesBase(object):
"""
Wrapper object to manage the efuse fields in a connected ESP bootloader
"""
_esp = None
blocks = []
efuses = []
coding_scheme = None
force_write_always = None
batch_mode_cnt = 0
def __iter__(self):
return self.efuses.__iter__()
def get_crystal_freq(self):
return self._esp.get_crystal_freq()
def read_efuse(self, n):
"""Read the nth word of the ESP3x EFUSE region."""
return self._esp.read_efuse(n)
def read_reg(self, addr):
return self._esp.read_reg(addr)
def write_reg(self, addr, value, mask=0xFFFFFFFF, delay_us=0, delay_after_us=0):
return self._esp.write_reg(addr, value, mask, delay_us, delay_after_us)
def update_reg(self, addr, mask, new_val):
return self._esp.update_reg(addr, mask, new_val)
def efuse_controller_setup(self):
pass
def reconnect_chip(self, esp):
print("Re-connecting...")
baudrate = esp._port.baudrate
port = esp._port.port
esp._port.close()
return esptool.cmds.detect_chip(port, baudrate)
def get_index_block_by_name(self, name):
for block in self.blocks:
if block.name == name or name in block.alias:
return block.id
return None
def read_blocks(self):
for block in self.blocks:
block.read()
def update_efuses(self):
for efuse in self.efuses:
efuse.update(self.blocks[efuse.block].bitarray)
def burn_all(self, check_batch_mode=False):
if check_batch_mode:
if self.batch_mode_cnt != 0:
print(
"\nBatch mode is enabled, "
"the burn will be done at the end of the command."
)
return False
print("\nCheck all blocks for burn...")
print("idx, BLOCK_NAME, Conclusion")
have_wr_data_for_burn = False
for block in self.blocks:
block.check_wr_data()
if not have_wr_data_for_burn and block.get_bitstring(from_read=False).any(
True
):
have_wr_data_for_burn = True
if not have_wr_data_for_burn:
print("Nothing to burn, see messages above.")
return
EspEfusesBase.confirm("", self.do_not_confirm)
# Burn from BLKn -> BLK0. Because BLK0 can set rd or/and wr protection bits.
for block in reversed(self.blocks):
old_fail = block.fail
old_num_errors = block.num_errors
block.burn()
if (block.fail and old_fail != block.fail) or (
block.num_errors and block.num_errors > old_num_errors
):
raise esptool.FatalError("Error(s) were detected in eFuses")
print("Reading updated efuses...")
self.read_coding_scheme()
self.read_blocks()
self.update_efuses()
return True
@staticmethod
def confirm(action, do_not_confirm):
print(
"%s%s\nThis is an irreversible operation!"
% (action, "" if action.endswith("\n") else ". ")
)
if not do_not_confirm:
print("Type 'BURN' (all capitals) to continue.")
# required for Pythons which disable line buffering, ie mingw in mintty
sys.stdout.flush()
yes = input()
if yes != "BURN":
print("Aborting.")
sys.exit(0)
def print_error_msg(self, error_msg):
if self.force_write_always is not None:
if not self.force_write_always:
error_msg += "(use '--force-write-always' option to ignore it)"
if self.force_write_always:
print(error_msg, "Skipped because '--force-write-always' option.")
else:
raise esptool.FatalError(error_msg)
def get_block_errors(self, block_num):
"""Returns (error count, failure boolean flag)"""
return self.blocks[block_num].num_errors, self.blocks[block_num].fail
class EfuseFieldBase(EfuseProtectBase):
def __init__(self, parent, param):
self.category = param.category
self.parent = parent
self.block = param.block
self.word = param.word
self.pos = param.pos
self.write_disable_bit = param.write_disable_bit
self.read_disable_bit = param.read_disable_bit
self.name = param.name
self.efuse_class = param.class_type
self.efuse_type = param.type
self.description = param.description
self.dict_value = param.dictionary
self.bit_len = param.bit_len
self.alt_names = param.alt_names
self.fail = False
self.num_errors = 0
self.bitarray = BitStream(self.bit_len)
self.bitarray.set(0)
self.update(self.parent.blocks[self.block].bitarray)
def is_field_calculated(self):
return self.word is None or self.pos is None
def check_format(self, new_value_str):
if new_value_str is None:
return new_value_str
else:
if self.efuse_type.startswith("bytes"):
if new_value_str.startswith("0x"):
# cmd line: 0x0102030405060708 .... 112233ff (hex)
# regs: 112233ff ... 05060708 01020304
# BLK: ff 33 22 11 ... 08 07 06 05 04 03 02 01
return binascii.unhexlify(new_value_str[2:])[::-1]
else:
# cmd line: 0102030405060708 .... 112233ff (string)
# regs: 04030201 08070605 ... ff332211
# BLK: 01 02 03 04 05 06 07 08 ... 11 22 33 ff
return binascii.unhexlify(new_value_str)
else:
return new_value_str
def convert_to_bitstring(self, new_value):
if isinstance(new_value, BitArray):
return new_value
else:
if self.efuse_type.startswith("bytes"):
# new_value (bytes) = [0][1][2] ... [N]
# (original data)
# in string format = [0] [1] [2] ... [N]
# (util.hexify(data, " "))
# in hex format = 0x[N]....[2][1][0]
# (from bitstring print(data))
# in reg format = [3][2][1][0] ... [N][][][]
# (as it will be in the device)
# in bitstring = [N] ... [2][1][0]
# (to get a correct bitstring need to reverse new_value)
# *[x] - means a byte.
return BitArray(bytes=new_value[::-1], length=len(new_value) * 8)
else:
try:
return BitArray(self.efuse_type + "={}".format(new_value))
except CreationError as err:
print(
"New value '{}' is not suitable for {} ({})".format(
new_value, self.name, self.efuse_type
)
)
raise esptool.FatalError(err)
def check_new_value(self, bitarray_new_value):
bitarray_old_value = self.get_bitstring() | self.get_bitstring(from_read=False)
if bitarray_new_value.len != bitarray_old_value.len:
raise esptool.FatalError(
"For {} efuse, the length of the new value is wrong, "
"expected {} bits, was {} bits.".format(
self.name, bitarray_old_value.len, bitarray_new_value.len
)
)
if bitarray_new_value == bitarray_old_value:
error_msg = "\tThe same value for {} ".format(self.name)
error_msg += "is already burned. Do not change the efuse."
print(error_msg)
bitarray_new_value.set(0)
elif bitarray_new_value == self.get_bitstring(from_read=False):
error_msg = "\tThe same value for {} ".format(self.name)
error_msg += "is already prepared for the burn operation."
print(error_msg)
bitarray_new_value.set(0)
else:
if self.name not in ["WR_DIS", "RD_DIS"]:
# WR_DIS, RD_DIS fields can have already set bits.
# Do not neeed to check below condition for them.
if bitarray_new_value | bitarray_old_value != bitarray_new_value:
error_msg = "\tNew value contains some bits that cannot be cleared "
error_msg += "(value will be {})".format(
bitarray_old_value | bitarray_new_value
)
self.parent.print_error_msg(error_msg)
self.check_wr_rd_protect()
def save_to_block(self, bitarray_field):
block = self.parent.blocks[self.block]
wr_bitarray_temp = block.wr_bitarray.copy()
position = wr_bitarray_temp.length - (
self.word * 32 + self.pos + bitarray_field.len
)
wr_bitarray_temp.overwrite(bitarray_field, pos=position)
block.wr_bitarray |= wr_bitarray_temp
def save(self, new_value):
bitarray_field = self.convert_to_bitstring(new_value)
self.check_new_value(bitarray_field)
self.save_to_block(bitarray_field)
def update(self, bit_array_block):
if self.is_field_calculated():
self.bitarray.overwrite(
self.convert_to_bitstring(self.check_format(self.get())), pos=0
)
return
field_len = self.bitarray.len
bit_array_block.pos = bit_array_block.length - (
self.word * 32 + self.pos + field_len
)
self.bitarray.overwrite(bit_array_block.read(field_len), pos=0)
err_bitarray = self.parent.blocks[self.block].err_bitarray
if err_bitarray is not None:
err_bitarray.pos = err_bitarray.length - (
self.word * 32 + self.pos + field_len
)
self.fail = not err_bitarray.read(field_len).all(False)
else:
self.fail = self.parent.blocks[self.block].fail
self.num_errors = self.parent.blocks[self.block].num_errors
def get_raw(self, from_read=True):
"""Return the raw (unformatted) numeric value of the efuse bits
Returns a simple integer or (for some subclasses) a bitstring.
type: int or bool -> int
type: bytes -> bytearray
"""
return self.get_bitstring(from_read).read(self.efuse_type)
def get(self, from_read=True):
"""Get a formatted version of the efuse value, suitable for display
type: int or bool -> int
type: bytes -> string "01 02 03 04 05 06 07 08 ... ".
Byte order [0] ... [N]. dump regs: 0x04030201 0x08070605 ...
"""
if self.efuse_type.startswith("bytes"):
return util.hexify(self.get_bitstring(from_read).bytes[::-1], " ")
else:
return self.get_raw(from_read)
def get_meaning(self, from_read=True):
"""Get the meaning of efuse from dict if possible, suitable for display"""
if self.dict_value:
try:
return self.dict_value[self.get_raw(from_read)]
except KeyError:
pass
return self.get(from_read)
def get_bitstring(self, from_read=True):
if from_read:
self.bitarray.pos = 0
return self.bitarray
else:
field_len = self.bitarray.len
block = self.parent.blocks[self.block]
block.wr_bitarray.pos = block.wr_bitarray.length - (
self.word * 32 + self.pos + field_len
)
return block.wr_bitarray.read(self.bitarray.len)
def burn(self, new_value):
# Burn a efuse. Added for compatibility reason.
self.save(new_value)
self.parent.burn_all()
def get_info(self):
output = f"{self.name} (BLOCK{self.block})"
if self.block == 0:
if self.fail:
output += "[error]"
else:
errs, fail = self.parent.get_block_errors(self.block)
if errs != 0 or fail:
output += "[error]"
if self.efuse_class == "keyblock":
name = self.parent.blocks[self.block].key_purpose_name
if name is not None:
output += f"\n Purpose: {self.parent[name].get()}\n "
return output
| 30,777 | Python | .py | 683 | 30.903367 | 88 | 0.509809 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,646 | mem_definition_base.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/mem_definition_base.py | # This file describes eFuses fields and registers for ESP32 chip
#
# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
from collections import namedtuple
class EfuseRegistersBase(object):
# Coding Scheme values
CODING_SCHEME_NONE = 0
CODING_SCHEME_34 = 1
CODING_SCHEME_REPEAT = 2
CODING_SCHEME_NONE_RECOVERY = 3
CODING_SCHEME_RS = 4
EFUSE_BURN_TIMEOUT = 0.250 # seconds
class EfuseBlocksBase(object):
BLOCKS = None
NamedtupleBlock = namedtuple(
"Block",
"name alias id rd_addr wr_addr write_disable_bit "
"read_disable_bit len key_purpose",
)
@staticmethod
def get(tuple_block):
return EfuseBlocksBase.NamedtupleBlock._make(tuple_block)
def get_blocks_for_keys(self):
list_of_names = []
for block in self.BLOCKS:
blk = self.get(block)
if blk.id > 0:
if blk.name:
list_of_names.append(blk.name)
if blk.alias:
for alias in blk.alias:
list_of_names.append(alias)
return list_of_names
class Field:
name = ""
block = 0
word = None
pos = None
bit_len = 0
alt_names = []
type = ""
write_disable_bit = None
read_disable_bit = None
category = "config"
class_type = ""
description = ""
dictionary = None
class EfuseFieldsBase(object):
def __init__(self, e_desc) -> None:
self.ALL_EFUSES = []
def set_category_and_class_type(efuse, name):
def includes(name, names):
return any([word in name for word in names])
if name.startswith("SPI_PAD_CONFIG"):
efuse.category = "spi pad"
elif "USB" in name:
efuse.category = "usb"
elif "WDT" in name:
efuse.category = "wdt"
elif "JTAG" in name:
efuse.category = "jtag"
elif includes(name, ["FLASH", "FORCE_SEND_RESUME"]):
efuse.category = "flash"
elif includes(name, ["VDD_SPI_", "XPD"]):
efuse.category = "vdd"
elif "MAC" in name:
efuse.category = "MAC"
if name in ["MAC", "CUSTOM_MAC", "MAC_EXT"]:
efuse.class_type = "mac"
elif includes(
name,
[
"BLOCK_KEY0",
"BLOCK_KEY1",
"BLOCK_KEY2",
"BLOCK_KEY3",
"BLOCK_KEY4",
"BLOCK_KEY5",
"BLOCK1",
"BLOCK2",
],
):
efuse.category = "security"
efuse.class_type = "keyblock"
elif includes(
name,
[
"KEY",
"SECURE",
"DOWNLOAD",
"SPI_BOOT_CRYPT_CNT",
"KEY_PURPOSE",
"SECURE_VERSION",
"DPA",
"ECDSA",
"FLASH_CRYPT_CNT",
"ENCRYPT",
"DECRYPT",
"ABS_DONE",
],
):
efuse.category = "security"
if name.startswith("KEY_PURPOSE"):
efuse.class_type = "keypurpose"
elif includes(
name, ["FLASH_CRYPT_CNT", "SPI_BOOT_CRYPT_CNT", "SECURE_VERSION"]
):
efuse.class_type = "bitcount"
elif includes(name, ["VERSION", "WAFER", "_ID", "PKG", "PACKAGE", "REV"]):
efuse.category = "identity"
if name == "OPTIONAL_UNIQUE_ID":
efuse.class_type = "keyblock"
elif includes(name, ["ADC", "LDO", "DBIAS", "_HVT", "CALIB", "OCODE"]):
efuse.category = "calibration"
if name == "ADC_VREF":
efuse.class_type = "vref"
return
if includes(name, ["ADC", "LDO", "DBIAS", "_HVT"]):
efuse.class_type = "adc_tp"
elif name == "TEMP_CALIB":
efuse.class_type = "t_sensor"
for e_name in e_desc["EFUSES"]:
data_dict = e_desc["EFUSES"][e_name]
if data_dict["show"] == "y":
d = Field()
d.name = e_name
d.block = data_dict["blk"]
d.word = data_dict["word"]
d.pos = data_dict["pos"]
d.bit_len = data_dict["len"]
d.type = data_dict["type"]
d.write_disable_bit = data_dict["wr_dis"]
d.read_disable_bit = (
[int(x) for x in data_dict["rd_dis"].split(" ")]
if isinstance(data_dict["rd_dis"], str)
else data_dict["rd_dis"]
)
d.description = data_dict["desc"]
d.alt_names = data_dict["alt"].split(" ") if data_dict["alt"] else []
d.dictionary = (
eval(data_dict["dict"]) if data_dict["dict"] != "" else None
)
set_category_and_class_type(d, e_name)
self.ALL_EFUSES.append(d)
| 5,427 | Python | .py | 146 | 23.342466 | 86 | 0.463851 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,647 | emulate_efuse_controller.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32s2/emulate_efuse_controller.py | # This file describes eFuses controller for ESP32-S2 chip
#
# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import reedsolo
from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters
from ..emulate_efuse_controller_base import EmulateEfuseControllerBase, FatalError
class EmulateEfuseController(EmulateEfuseControllerBase):
"""The class for virtual efuse operation. Using for HOST_TEST."""
CHIP_NAME = "ESP32-S2"
mem = None
debug = False
def __init__(self, efuse_file=None, debug=False):
self.Blocks = EfuseDefineBlocks
self.Fields = EfuseDefineFields()
self.REGS = EfuseDefineRegisters
super(EmulateEfuseController, self).__init__(efuse_file, debug)
self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
""" esptool method start >>"""
def get_major_chip_version(self):
return 1
def get_minor_chip_version(self):
return 0
def get_crystal_freq(self):
return 40 # MHz (common for all chips)
def get_security_info(self):
return {
"flags": 0,
"flash_crypt_cnt": 0,
"key_purposes": 0,
"chip_id": None,
"api_version": None,
}
""" << esptool method end """
def handle_writing_event(self, addr, value):
if addr == self.REGS.EFUSE_CMD_REG:
if value & self.REGS.EFUSE_PGM_CMD:
self.copy_blocks_wr_regs_to_rd_regs(updated_block=(value >> 2) & 0xF)
self.clean_blocks_wr_regs()
self.check_rd_protection_area()
self.write_reg(addr, 0)
self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
elif value == self.REGS.EFUSE_READ_CMD:
self.write_reg(addr, 0)
self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
self.save_to_file()
def get_bitlen_of_block(self, blk, wr=False):
if blk.id == 0:
if wr:
return 32 * 8
else:
return 32 * blk.len
else:
if wr:
rs_coding = 32 * 3
return 32 * 8 + rs_coding
else:
return 32 * blk.len
def handle_coding_scheme(self, blk, data):
if blk.id != 0:
# CODING_SCHEME RS applied only for all blocks except BLK0.
coded_bytes = 12
data.pos = coded_bytes * 8
plain_data = data.readlist("32*uint:8")[::-1]
# takes 32 bytes
# apply RS encoding
rs = reedsolo.RSCodec(coded_bytes)
# 32 byte of data + 12 bytes RS
calc_encoded_data = list(rs.encode([x for x in plain_data]))
data.pos = 0
if calc_encoded_data != data.readlist("44*uint:8")[::-1]:
raise FatalError("Error in coding scheme data")
data = data[coded_bytes * 8 :]
if blk.len < 8:
data = data[(8 - blk.len) * 32 :]
return data
| 3,078 | Python | .py | 77 | 29.74026 | 86 | 0.576691 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,648 | __init__.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32s2/__init__.py | from . import operations
from .emulate_efuse_controller import EmulateEfuseController
from .fields import EspEfuses
| 116 | Python | .py | 3 | 37.666667 | 60 | 0.876106 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,649 | operations.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32s2/operations.py | # This file includes the operations with eFuses for ESP32S2 chip
#
# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import argparse
import io
import os # noqa: F401. It is used in IDF scripts
import traceback
import espsecure
import esptool
from . import fields
from .. import util
from ..base_operations import (
add_common_commands,
add_force_write_always,
add_show_sensitive_info_option,
burn_bit,
burn_block_data,
burn_efuse,
check_error,
dump,
read_protect_efuse,
summary,
write_protect_efuse,
)
def protect_options(p):
p.add_argument(
"--no-write-protect",
help="Disable write-protecting of the key. The key remains writable. "
"(The keys use the RS coding scheme that does not support post-write "
"data changes. Forced write can damage RS encoding bits.) "
"The write-protecting of keypurposes does not depend on the option, "
"it will be set anyway.",
action="store_true",
)
p.add_argument(
"--no-read-protect",
help="Disable read-protecting of the key. The key remains readable software."
"The key with keypurpose[USER, RESERVED and *_DIGEST] "
"will remain readable anyway. For the rest keypurposes the read-protection "
"will be defined the option (Read-protect by default).",
action="store_true",
)
def add_commands(subparsers, efuses):
add_common_commands(subparsers, efuses)
burn_key = subparsers.add_parser(
"burn_key", help="Burn the key block with the specified name"
)
protect_options(burn_key)
add_force_write_always(burn_key)
add_show_sensitive_info_option(burn_key)
burn_key.add_argument(
"block",
help="Key block to burn",
action="append",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key.add_argument(
"keyfile",
help="File containing 256 bits of binary key data",
action="append",
type=argparse.FileType("rb"),
)
burn_key.add_argument(
"keypurpose",
help="Purpose to set.",
action="append",
choices=fields.EfuseKeyPurposeField.KEY_PURPOSES_NAME,
)
for _ in efuses.BLOCKS_FOR_KEYS:
burn_key.add_argument(
"block",
help="Key block to burn",
nargs="?",
action="append",
metavar="BLOCK",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key.add_argument(
"keyfile",
help="File containing 256 bits of binary key data",
nargs="?",
action="append",
metavar="KEYFILE",
type=argparse.FileType("rb"),
)
burn_key.add_argument(
"keypurpose",
help="Purpose to set.",
nargs="?",
action="append",
metavar="KEYPURPOSE",
choices=fields.EfuseKeyPurposeField.KEY_PURPOSES_NAME,
)
burn_key_digest = subparsers.add_parser(
"burn_key_digest",
help="Parse a RSA public key and burn the digest to key efuse block",
)
protect_options(burn_key_digest)
add_force_write_always(burn_key_digest)
add_show_sensitive_info_option(burn_key_digest)
burn_key_digest.add_argument(
"block",
help="Key block to burn",
action="append",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key_digest.add_argument(
"keyfile",
help="Key file to digest (PEM format)",
action="append",
type=argparse.FileType("rb"),
)
burn_key_digest.add_argument(
"keypurpose",
help="Purpose to set.",
action="append",
choices=fields.EfuseKeyPurposeField.DIGEST_KEY_PURPOSES,
)
for _ in efuses.BLOCKS_FOR_KEYS:
burn_key_digest.add_argument(
"block",
help="Key block to burn",
nargs="?",
action="append",
metavar="BLOCK",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key_digest.add_argument(
"keyfile",
help="Key file to digest (PEM format)",
nargs="?",
action="append",
metavar="KEYFILE",
type=argparse.FileType("rb"),
)
burn_key_digest.add_argument(
"keypurpose",
help="Purpose to set.",
nargs="?",
action="append",
metavar="KEYPURPOSE",
choices=fields.EfuseKeyPurposeField.DIGEST_KEY_PURPOSES,
)
p = subparsers.add_parser(
"set_flash_voltage",
help="Permanently set the internal flash voltage regulator "
"to either 1.8V, 3.3V or OFF. "
"This means GPIO45 can be high or low at reset without "
"changing the flash voltage.",
)
p.add_argument("voltage", help="Voltage selection", choices=["1.8V", "3.3V", "OFF"])
p = subparsers.add_parser(
"burn_custom_mac", help="Burn a 48-bit Custom MAC Address to EFUSE BLOCK3."
)
p.add_argument(
"mac",
help="Custom MAC Address to burn given in hexadecimal format with bytes "
"separated by colons (e.g. AA:CD:EF:01:02:03).",
type=fields.base_fields.CheckArgValue(efuses, "CUSTOM_MAC"),
)
add_force_write_always(p)
p = subparsers.add_parser("get_custom_mac", help="Prints the Custom MAC Address.")
def burn_custom_mac(esp, efuses, args):
efuses["CUSTOM_MAC"].save(args.mac)
if not efuses.burn_all(check_batch_mode=True):
return
get_custom_mac(esp, efuses, args)
print("Successful")
def get_custom_mac(esp, efuses, args):
print("Custom MAC Address: {}".format(efuses["CUSTOM_MAC"].get()))
def set_flash_voltage(esp, efuses, args):
sdio_force = efuses["VDD_SPI_FORCE"]
sdio_tieh = efuses["VDD_SPI_TIEH"]
sdio_reg = efuses["VDD_SPI_XPD"]
# check efuses aren't burned in a way which makes this impossible
if args.voltage == "OFF" and sdio_reg.get() != 0:
raise esptool.FatalError(
"Can't set flash regulator to OFF as VDD_SPI_XPD efuse is already burned"
)
if args.voltage == "1.8V" and sdio_tieh.get() != 0:
raise esptool.FatalError(
"Can't set regulator to 1.8V is VDD_SPI_TIEH efuse is already burned"
)
if args.voltage == "OFF":
msg = "Disable internal flash voltage regulator (VDD_SPI). SPI flash will "
"need to be powered from an external source.\n"
"The following efuse is burned: VDD_SPI_FORCE.\n"
"It is possible to later re-enable the internal regulator (%s) " % (
"to 3.3V" if sdio_tieh.get() != 0 else "to 1.8V or 3.3V"
)
"by burning an additional efuse"
elif args.voltage == "1.8V":
msg = "Set internal flash voltage regulator (VDD_SPI) to 1.8V.\n"
"The following efuses are burned: VDD_SPI_FORCE, VDD_SPI_XPD.\n"
"It is possible to later increase the voltage to 3.3V (permanently) "
"by burning additional efuse VDD_SPI_TIEH"
elif args.voltage == "3.3V":
msg = "Enable internal flash voltage regulator (VDD_SPI) to 3.3V.\n"
"The following efuses are burned: VDD_SPI_FORCE, VDD_SPI_XPD, VDD_SPI_TIEH."
print(msg)
sdio_force.save(1) # Disable GPIO45
if args.voltage != "OFF":
sdio_reg.save(1) # Enable internal regulator
if args.voltage == "3.3V":
sdio_tieh.save(1)
print("VDD_SPI setting complete.")
if not efuses.burn_all(check_batch_mode=True):
return
print("Successful")
def adc_info(esp, efuses, args):
print("")
# fmt: off
if efuses["BLK_VERSION_MINOR"].get() == 1:
print("Temperature Sensor Calibration = {}C".format(efuses["TEMP_SENSOR_CAL"].get()))
print("")
print("ADC1 readings stored in efuse BLOCK2:")
print(" MODE0 D1 reading (250mV): {}".format(efuses["ADC1_MODE0_D1"].get()))
print(" MODE0 D2 reading (600mV): {}".format(efuses["ADC1_MODE0_D2"].get()))
print(" MODE1 D1 reading (250mV): {}".format(efuses["ADC1_MODE1_D1"].get()))
print(" MODE1 D2 reading (800mV): {}".format(efuses["ADC1_MODE1_D2"].get()))
print(" MODE2 D1 reading (250mV): {}".format(efuses["ADC1_MODE2_D1"].get()))
print(" MODE2 D2 reading (1000mV): {}".format(efuses["ADC1_MODE2_D2"].get()))
print(" MODE3 D1 reading (250mV): {}".format(efuses["ADC1_MODE3_D1"].get()))
print(" MODE3 D2 reading (2000mV): {}".format(efuses["ADC1_MODE3_D2"].get()))
print("")
print("ADC2 readings stored in efuse BLOCK2:")
print(" MODE0 D1 reading (250mV): {}".format(efuses["ADC2_MODE0_D1"].get()))
print(" MODE0 D2 reading (600mV): {}".format(efuses["ADC2_MODE0_D2"].get()))
print(" MODE1 D1 reading (250mV): {}".format(efuses["ADC2_MODE1_D1"].get()))
print(" MODE1 D2 reading (800mV): {}".format(efuses["ADC2_MODE1_D2"].get()))
print(" MODE2 D1 reading (250mV): {}".format(efuses["ADC2_MODE2_D1"].get()))
print(" MODE2 D2 reading (1000mV): {}".format(efuses["ADC2_MODE2_D2"].get()))
print(" MODE3 D1 reading (250mV): {}".format(efuses["ADC2_MODE3_D1"].get()))
print(" MODE3 D2 reading (2000mV): {}".format(efuses["ADC2_MODE3_D2"].get()))
else:
print("BLK_VERSION_MINOR = {}".format(efuses["BLK_VERSION_MINOR"].get_meaning()))
# fmt: on
def key_block_is_unused(block, key_purpose_block):
if not block.is_readable() or not block.is_writeable():
return False
if key_purpose_block.get() != "USER" or not key_purpose_block.is_writeable():
return False
if not block.get_bitstring().all(False):
return False
return True
def get_next_key_block(efuses, current_key_block, block_name_list):
key_blocks = [b for b in efuses.blocks if b.key_purpose_name]
start = key_blocks.index(current_key_block)
# Sort key blocks so that we pick the next free block (and loop around if necessary)
key_blocks = key_blocks[start:] + key_blocks[0:start]
# Exclude any other blocks that will be be burned
key_blocks = [b for b in key_blocks if b.name not in block_name_list]
for block in key_blocks:
key_purpose_block = efuses[block.key_purpose_name]
if key_block_is_unused(block, key_purpose_block):
return block
return None
def split_512_bit_key(efuses, block_name_list, datafile_list, keypurpose_list):
i = keypurpose_list.index("XTS_AES_256_KEY")
block_name = block_name_list[i]
block_num = efuses.get_index_block_by_name(block_name)
block = efuses.blocks[block_num]
data = datafile_list[i].read()
if len(data) != 64:
raise esptool.FatalError(
"Incorrect key file size %d, XTS_AES_256_KEY should be 64 bytes" % len(data)
)
key_block_2 = get_next_key_block(efuses, block, block_name_list)
if not key_block_2:
raise esptool.FatalError("XTS_AES_256_KEY requires two free keyblocks")
keypurpose_list.append("XTS_AES_256_KEY_1")
datafile_list.append(io.BytesIO(data[:32]))
block_name_list.append(block_name)
keypurpose_list.append("XTS_AES_256_KEY_2")
datafile_list.append(io.BytesIO(data[32:]))
block_name_list.append(key_block_2.name)
keypurpose_list.pop(i)
datafile_list.pop(i)
block_name_list.pop(i)
def burn_key(esp, efuses, args, digest=None):
if digest is None:
datafile_list = args.keyfile[
0 : len([name for name in args.keyfile if name is not None]) :
]
else:
datafile_list = digest[0 : len([name for name in digest if name is not None]) :]
efuses.force_write_always = args.force_write_always
block_name_list = args.block[
0 : len([name for name in args.block if name is not None]) :
]
keypurpose_list = args.keypurpose[
0 : len([name for name in args.keypurpose if name is not None]) :
]
if "XTS_AES_256_KEY" in keypurpose_list:
# XTS_AES_256_KEY is not an actual HW key purpose, needs to be split into
# XTS_AES_256_KEY_1 and XTS_AES_256_KEY_2
split_512_bit_key(efuses, block_name_list, datafile_list, keypurpose_list)
util.check_duplicate_name_in_list(block_name_list)
if len(block_name_list) != len(datafile_list) or len(block_name_list) != len(
keypurpose_list
):
raise esptool.FatalError(
"The number of blocks (%d), datafile (%d) and keypurpose (%d) "
"should be the same."
% (len(block_name_list), len(datafile_list), len(keypurpose_list))
)
print("Burn keys to blocks:")
for block_name, datafile, keypurpose in zip(
block_name_list, datafile_list, keypurpose_list
):
efuse = None
for block in efuses.blocks:
if block_name == block.name or block_name in block.alias:
efuse = efuses[block.name]
if efuse is None:
raise esptool.FatalError("Unknown block name - %s" % (block_name))
num_bytes = efuse.bit_len // 8
block_num = efuses.get_index_block_by_name(block_name)
block = efuses.blocks[block_num]
if digest is None:
data = datafile.read()
else:
data = datafile
print(" - %s" % (efuse.name), end=" ")
revers_msg = None
if efuses[block.key_purpose_name].need_reverse(keypurpose):
revers_msg = "\tReversing byte order for AES-XTS hardware peripheral"
data = data[::-1]
print(
"-> [{}]".format(
util.hexify(data, " ")
if args.show_sensitive_info
else " ".join(["??"] * len(data))
)
)
if revers_msg:
print(revers_msg)
if len(data) != num_bytes:
raise esptool.FatalError(
"Incorrect key file size %d. Key file must be %d bytes (%d bits) "
"of raw binary key data." % (len(data), num_bytes, num_bytes * 8)
)
if efuses[block.key_purpose_name].need_rd_protect(keypurpose):
read_protect = False if args.no_read_protect else True
else:
read_protect = False
write_protect = not args.no_write_protect
# using efuse instead of a block gives the advantage of
# checking it as the whole field.
efuse.save(data)
disable_wr_protect_key_purpose = False
if efuses[block.key_purpose_name].get() != keypurpose:
if efuses[block.key_purpose_name].is_writeable():
print(
"\t'%s': '%s' -> '%s'."
% (
block.key_purpose_name,
efuses[block.key_purpose_name].get(),
keypurpose,
)
)
efuses[block.key_purpose_name].save(keypurpose)
disable_wr_protect_key_purpose = True
else:
raise esptool.FatalError(
"It is not possible to change '%s' to '%s' because "
"write protection bit is set."
% (block.key_purpose_name, keypurpose)
)
else:
print("\t'%s' is already '%s'." % (block.key_purpose_name, keypurpose))
if efuses[block.key_purpose_name].is_writeable():
disable_wr_protect_key_purpose = True
if disable_wr_protect_key_purpose:
print("\tDisabling write to '%s'." % block.key_purpose_name)
efuses[block.key_purpose_name].disable_write()
if read_protect:
print("\tDisabling read to key block")
efuse.disable_read()
if write_protect:
print("\tDisabling write to key block")
efuse.disable_write()
print("")
if not write_protect:
print("Keys will remain writeable (due to --no-write-protect)")
if args.no_read_protect:
print("Keys will remain readable (due to --no-read-protect)")
if not efuses.burn_all(check_batch_mode=True):
return
print("Successful")
def burn_key_digest(esp, efuses, args):
digest_list = []
datafile_list = args.keyfile[
0 : len([name for name in args.keyfile if name is not None]) :
]
block_list = args.block[
0 : len([block for block in args.block if block is not None]) :
]
for block_name, datafile in zip(block_list, datafile_list):
efuse = None
for block in efuses.blocks:
if block_name == block.name or block_name in block.alias:
efuse = efuses[block.name]
if efuse is None:
raise esptool.FatalError("Unknown block name - %s" % (block_name))
num_bytes = efuse.bit_len // 8
digest = espsecure._digest_sbv2_public_key(datafile)
if len(digest) != num_bytes:
raise esptool.FatalError(
"Incorrect digest size %d. Digest must be %d bytes (%d bits) of raw "
"binary key data." % (len(digest), num_bytes, num_bytes * 8)
)
digest_list.append(digest)
burn_key(esp, efuses, args, digest=digest_list)
def espefuse(esp, efuses, args, command):
parser = argparse.ArgumentParser()
subparsers = parser.add_subparsers(dest="operation")
add_commands(subparsers, efuses)
try:
cmd_line_args = parser.parse_args(command.split())
except SystemExit:
traceback.print_stack()
raise esptool.FatalError('"{}" - incorrect command'.format(command))
if cmd_line_args.operation == "execute_scripts":
configfiles = cmd_line_args.configfiles
index = cmd_line_args.index
# copy arguments from args to cmd_line_args
vars(cmd_line_args).update(vars(args))
if cmd_line_args.operation == "execute_scripts":
cmd_line_args.configfiles = configfiles
cmd_line_args.index = index
if cmd_line_args.operation is None:
parser.print_help()
parser.exit(1)
operation_func = globals()[cmd_line_args.operation]
# each 'operation' is a module-level function of the same name
operation_func(esp, efuses, cmd_line_args)
def execute_scripts(esp, efuses, args):
efuses.batch_mode_cnt += 1
del args.operation
scripts = args.scripts
del args.scripts
for file in scripts:
with open(file.name, "r") as file:
exec(compile(file.read(), file.name, "exec"))
if args.debug:
for block in efuses.blocks:
data = block.get_bitstring(from_read=False)
block.print_block(data, "regs_for_burn", args.debug)
efuses.batch_mode_cnt -= 1
if not efuses.burn_all(check_batch_mode=True):
return
print("Successful")
| 18,946 | Python | .py | 455 | 33.085714 | 93 | 0.609428 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,650 | fields.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32s2/fields.py | # This file describes eFuses for ESP32S2 chip
#
# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import binascii
import struct
import time
from bitstring import BitArray
import esptool
import reedsolo
from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters
from .. import base_fields
from .. import util
class EfuseBlock(base_fields.EfuseBlockBase):
def len_of_burn_unit(self):
# The writing register window is 8 registers for any blocks.
# len in bytes
return 8 * 4
def __init__(self, parent, param, skip_read=False):
parent.read_coding_scheme()
super(EfuseBlock, self).__init__(parent, param, skip_read=skip_read)
def apply_coding_scheme(self):
data = self.get_raw(from_read=False)[::-1]
if len(data) < self.len_of_burn_unit():
add_empty_bytes = self.len_of_burn_unit() - len(data)
data = data + (b"\x00" * add_empty_bytes)
if self.get_coding_scheme() == self.parent.REGS.CODING_SCHEME_RS:
# takes 32 bytes
# apply RS encoding
rs = reedsolo.RSCodec(12)
# 32 byte of data + 12 bytes RS
encoded_data = rs.encode([x for x in data])
words = struct.unpack("<" + "I" * 11, encoded_data)
# returns 11 words (8 words of data + 3 words of RS coding)
else:
# takes 32 bytes
words = struct.unpack("<" + ("I" * (len(data) // 4)), data)
# returns 8 words
return words
class EspEfuses(base_fields.EspEfusesBase):
"""
Wrapper object to manage the efuse fields in a connected ESP bootloader
"""
debug = False
do_not_confirm = False
def __init__(self, esp, skip_connect=False, debug=False, do_not_confirm=False):
self.Blocks = EfuseDefineBlocks()
self.Fields = EfuseDefineFields()
self.REGS = EfuseDefineRegisters
self.BURN_BLOCK_DATA_NAMES = self.Blocks.get_burn_block_data_names()
self.BLOCKS_FOR_KEYS = self.Blocks.get_blocks_for_keys()
self._esp = esp
self.debug = debug
self.do_not_confirm = do_not_confirm
if esp.CHIP_NAME != "ESP32-S2":
raise esptool.FatalError(
"Expected the 'esp' param for ESP32-S2 chip but got for '%s'."
% (esp.CHIP_NAME)
)
if not skip_connect:
flags = self._esp.get_security_info()["flags"]
GET_SECURITY_INFO_FLAG_SECURE_DOWNLOAD_ENABLE = 1 << 2
if flags & GET_SECURITY_INFO_FLAG_SECURE_DOWNLOAD_ENABLE:
raise esptool.FatalError(
"Secure Download Mode is enabled. The tool can not read eFuses."
)
self.blocks = [
EfuseBlock(self, self.Blocks.get(block), skip_read=skip_connect)
for block in self.Blocks.BLOCKS
]
if not skip_connect:
self.get_coding_scheme_warnings()
self.efuses = [EfuseField.convert(self, efuse) for efuse in self.Fields.EFUSES]
self.efuses += [
EfuseField.convert(self, efuse) for efuse in self.Fields.KEYBLOCKS
]
if skip_connect:
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
]
else:
if self["BLK_VERSION_MINOR"].get() == 1:
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
]
self.efuses += [
EfuseField.convert(self, efuse) for efuse in self.Fields.CALC
]
def __getitem__(self, efuse_name):
"""Return the efuse field with the given name"""
for e in self.efuses:
if efuse_name == e.name or any(x == efuse_name for x in e.alt_names):
return e
new_fields = False
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES:
if efuse.name == efuse_name or any(
x == efuse_name for x in efuse.alt_names
):
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
]
new_fields = True
if new_fields:
for e in self.efuses:
if efuse_name == e.name or any(x == efuse_name for x in e.alt_names):
return e
raise KeyError
def read_coding_scheme(self):
self.coding_scheme = self.REGS.CODING_SCHEME_RS
def print_status_regs(self):
print("")
self.blocks[0].print_block(self.blocks[0].err_bitarray, "err__regs", debug=True)
print(
"{:27} 0x{:08x}".format(
"EFUSE_RD_RS_ERR0_REG", self.read_reg(self.REGS.EFUSE_RD_RS_ERR0_REG)
)
)
print(
"{:27} 0x{:08x}".format(
"EFUSE_RD_RS_ERR1_REG", self.read_reg(self.REGS.EFUSE_RD_RS_ERR1_REG)
)
)
def efuse_controller_setup(self):
self.set_efuse_timing()
self.clear_pgm_registers()
self.wait_efuse_idle()
def write_efuses(self, block):
self.efuse_program(block)
return self.get_coding_scheme_warnings(silent=True)
def clear_pgm_registers(self):
self.wait_efuse_idle()
for r in range(
self.REGS.EFUSE_PGM_DATA0_REG, self.REGS.EFUSE_PGM_DATA0_REG + 32, 4
):
self.write_reg(r, 0)
def wait_efuse_idle(self):
deadline = time.time() + self.REGS.EFUSE_BURN_TIMEOUT
while time.time() < deadline:
# if self.read_reg(self.EFUSE_CMD_REG) == 0:
if self.read_reg(self.REGS.EFUSE_STATUS_REG) & 0x7 == 1:
return
raise esptool.FatalError(
"Timed out waiting for Efuse controller command to complete"
)
def efuse_program(self, block):
self.wait_efuse_idle()
self.write_reg(self.REGS.EFUSE_CONF_REG, self.REGS.EFUSE_WRITE_OP_CODE)
self.write_reg(self.REGS.EFUSE_CMD_REG, self.REGS.EFUSE_PGM_CMD | (block << 2))
self.wait_efuse_idle()
self.clear_pgm_registers()
self.efuse_read()
def efuse_read(self):
self.wait_efuse_idle()
self.write_reg(self.REGS.EFUSE_CONF_REG, self.REGS.EFUSE_READ_OP_CODE)
# need to add a delay after triggering EFUSE_READ_CMD, as ROM loader checks some
# efuse registers after each command is completed
# if ENABLE_SECURITY_DOWNLOAD or DIS_DOWNLOAD_MODE is enabled by the current cmd, then we need to try to reconnect to the chip.
try:
self.write_reg(
self.REGS.EFUSE_CMD_REG, self.REGS.EFUSE_READ_CMD, delay_after_us=1000
)
self.wait_efuse_idle()
except esptool.FatalError:
secure_download_mode_before = self._esp.secure_download_mode
try:
self._esp = self.reconnect_chip(self._esp)
except esptool.FatalError:
print("Can not re-connect to the chip")
if not self["DIS_DOWNLOAD_MODE"].get() and self[
"DIS_DOWNLOAD_MODE"
].get(from_read=False):
print(
"This is the correct behavior as we are actually burning "
"DIS_DOWNLOAD_MODE which disables the connection to the chip"
)
print("DIS_DOWNLOAD_MODE is enabled")
print("Successful")
exit(0) # finish without errors
raise
print("Established a connection with the chip")
if self._esp.secure_download_mode and not secure_download_mode_before:
print("Secure download mode is enabled")
if not self["ENABLE_SECURITY_DOWNLOAD"].get() and self[
"ENABLE_SECURITY_DOWNLOAD"
].get(from_read=False):
print(
"espefuse tool can not continue to work in Secure download mode"
)
print("ENABLE_SECURITY_DOWNLOAD is enabled")
print("Successful")
exit(0) # finish without errors
raise
def set_efuse_timing(self):
"""Set timing registers for burning efuses"""
# Configure clock
apb_freq = self.get_crystal_freq()
(
EFUSE_TSUP_A,
EFUSE_TPGM,
EFUSE_THP_A,
EFUSE_TPGM_INACTIVE,
) = self.REGS.EFUSE_PROGRAMMING_TIMING_PARAMETERS[apb_freq]
self.update_reg(
self.REGS.EFUSE_WR_TIM_CONF1_REG, self.REGS.EFUSE_TSUP_A_M, EFUSE_TSUP_A
)
self.update_reg(
self.REGS.EFUSE_WR_TIM_CONF0_REG, self.REGS.EFUSE_TPGM_M, EFUSE_TPGM
)
self.update_reg(
self.REGS.EFUSE_WR_TIM_CONF0_REG, self.REGS.EFUSE_THP_A_M, EFUSE_THP_A
)
self.update_reg(
self.REGS.EFUSE_WR_TIM_CONF0_REG,
self.REGS.EFUSE_TPGM_INACTIVE_M,
EFUSE_TPGM_INACTIVE,
)
(
EFUSE_DAC_CLK_DIV,
EFUSE_PWR_ON_NUM,
EFUSE_PWR_OFF_NUM,
) = self.REGS.VDDQ_TIMING_PARAMETERS[apb_freq]
self.update_reg(
self.REGS.EFUSE_DAC_CONF_REG,
self.REGS.EFUSE_DAC_CLK_DIV_M,
EFUSE_DAC_CLK_DIV,
)
self.update_reg(
self.REGS.EFUSE_WR_TIM_CONF1_REG,
self.REGS.EFUSE_PWR_ON_NUM_M,
EFUSE_PWR_ON_NUM,
)
self.update_reg(
self.REGS.EFUSE_WR_TIM_CONF2_REG,
self.REGS.EFUSE_PWR_OFF_NUM_M,
EFUSE_PWR_OFF_NUM,
)
EFUSE_TSUR_A, EFUSE_TRD, EFUSE_THR_A = self.REGS.EFUSE_READING_PARAMETERS[
apb_freq
]
# self.update_reg(
# self.REGS.EFUSE_RD_TIM_CONF_REG, self.REGS.EFUSE_TSUR_A_M, EFUSE_TSUR_A
# )
self.update_reg(
self.REGS.EFUSE_RD_TIM_CONF_REG, self.REGS.EFUSE_TRD_M, EFUSE_TRD
)
self.update_reg(
self.REGS.EFUSE_RD_TIM_CONF_REG, self.REGS.EFUSE_THR_A_M, EFUSE_THR_A
)
def get_coding_scheme_warnings(self, silent=False):
"""Check if the coding scheme has detected any errors."""
old_addr_reg = 0
reg_value = 0
ret_fail = False
for block in self.blocks:
if block.id == 0:
words = [
self.read_reg(self.REGS.EFUSE_RD_REPEAT_ERR0_REG + offs * 4)
for offs in range(5)
]
block.err_bitarray.pos = 0
for word in reversed(words):
block.err_bitarray.overwrite(BitArray("uint:32=%d" % word))
block.num_errors = block.err_bitarray.count(True)
block.fail = block.num_errors != 0
else:
addr_reg, err_num_mask, err_num_offs, fail_bit = self.REGS.BLOCK_ERRORS[
block.id
]
if err_num_mask is None or err_num_offs is None or fail_bit is None:
continue
if addr_reg != old_addr_reg:
old_addr_reg = addr_reg
reg_value = self.read_reg(addr_reg)
block.fail = reg_value & (1 << fail_bit) != 0
block.num_errors = (reg_value >> err_num_offs) & err_num_mask
ret_fail |= block.fail
if not silent and (block.fail or block.num_errors):
print(
"Error(s) in BLOCK%d [ERRORS:%d FAIL:%d]"
% (block.id, block.num_errors, block.fail)
)
if (self.debug or ret_fail) and not silent:
self.print_status_regs()
return ret_fail
def summary(self):
if self["VDD_SPI_FORCE"].get() == 0:
output = "Flash voltage (VDD_SPI) determined by GPIO45 on reset "
output += "(GPIO45=High: VDD_SPI pin is powered from internal 1.8V LDO\n"
output += "GPIO45=Low or NC: VDD_SPI pin is powered directly from "
output += "VDD3P3_RTC_IO via resistor Rspi. "
output += "Typically this voltage is 3.3 V)."
elif self["VDD_SPI_XPD"].get() == 0:
output = "Flash voltage (VDD_SPI) internal regulator disabled by efuse."
elif self["VDD_SPI_TIEH"].get() == 0:
output = "Flash voltage (VDD_SPI) set to 1.8V by efuse."
else:
output = "Flash voltage (VDD_SPI) set to 3.3V by efuse."
return output
class EfuseField(base_fields.EfuseFieldBase):
@staticmethod
def convert(parent, efuse):
return {
"mac": EfuseMacField,
"keypurpose": EfuseKeyPurposeField,
"t_sensor": EfuseTempSensor,
"adc_tp": EfuseAdcPointCalibration,
"wafer": EfuseWafer,
}.get(efuse.class_type, EfuseField)(parent, efuse)
class EfuseWafer(EfuseField):
def get(self, from_read=True):
hi_bits = self.parent["WAFER_VERSION_MINOR_HI"].get(from_read)
assert self.parent["WAFER_VERSION_MINOR_HI"].bit_len == 1
lo_bits = self.parent["WAFER_VERSION_MINOR_LO"].get(from_read)
assert self.parent["WAFER_VERSION_MINOR_LO"].bit_len == 3
return (hi_bits << 3) + lo_bits
def save(self, new_value):
raise esptool.FatalError("Burning %s is not supported" % self.name)
class EfuseTempSensor(EfuseField):
def get(self, from_read=True):
value = self.get_bitstring(from_read)
sig = -1 if value[0] else 1
return sig * value[1:].uint * 0.1
class EfuseAdcPointCalibration(EfuseField):
def get(self, from_read=True):
STEP_SIZE = 4
value = self.get_bitstring(from_read)
sig = -1 if value[0] else 1
return sig * value[1:].uint * STEP_SIZE
class EfuseMacField(EfuseField):
def check_format(self, new_value_str):
if new_value_str is None:
raise esptool.FatalError(
"Required MAC Address in AA:CD:EF:01:02:03 format!"
)
if new_value_str.count(":") != 5:
raise esptool.FatalError(
"MAC Address needs to be a 6-byte hexadecimal format "
"separated by colons (:)!"
)
hexad = new_value_str.replace(":", "")
if len(hexad) != 12:
raise esptool.FatalError(
"MAC Address needs to be a 6-byte hexadecimal number "
"(12 hexadecimal characters)!"
)
# order of bytearray = b'\xaa\xcd\xef\x01\x02\x03',
bindata = binascii.unhexlify(hexad)
# unicast address check according to
# https://tools.ietf.org/html/rfc7042#section-2.1
if esptool.util.byte(bindata, 0) & 0x01:
raise esptool.FatalError("Custom MAC must be a unicast MAC!")
return bindata
def check(self):
errs, fail = self.parent.get_block_errors(self.block)
if errs != 0 or fail:
output = "Block%d has ERRORS:%d FAIL:%d" % (self.block, errs, fail)
else:
output = "OK"
return "(" + output + ")"
def get(self, from_read=True):
if self.name == "CUSTOM_MAC":
mac = self.get_raw(from_read)[::-1]
else:
mac = self.get_raw(from_read)
return "%s %s" % (util.hexify(mac, ":"), self.check())
def save(self, new_value):
def print_field(e, new_value):
print(
" - '{}' ({}) {} -> {}".format(
e.name, e.description, e.get_bitstring(), new_value
)
)
if self.name == "CUSTOM_MAC":
bitarray_mac = self.convert_to_bitstring(new_value)
print_field(self, bitarray_mac)
super(EfuseMacField, self).save(new_value)
else:
# Writing the BLOCK1 (MAC_SPI_8M_0) default MAC is not possible,
# as it's written in the factory.
raise esptool.FatalError("Writing Factory MAC address is not supported")
# fmt: off
class EfuseKeyPurposeField(EfuseField):
KEY_PURPOSES = [
("USER", 0, None, None, "no_need_rd_protect"), # User purposes (software-only use)
("RESERVED", 1, None, None, "no_need_rd_protect"), # Reserved
("XTS_AES_256_KEY_1", 2, None, "Reverse", "need_rd_protect"), # XTS_AES_256_KEY_1 (flash/PSRAM encryption)
("XTS_AES_256_KEY_2", 3, None, "Reverse", "need_rd_protect"), # XTS_AES_256_KEY_2 (flash/PSRAM encryption)
("XTS_AES_128_KEY", 4, None, "Reverse", "need_rd_protect"), # XTS_AES_128_KEY (flash/PSRAM encryption)
("HMAC_DOWN_ALL", 5, None, None, "need_rd_protect"), # HMAC Downstream mode
("HMAC_DOWN_JTAG", 6, None, None, "need_rd_protect"), # JTAG soft enable key (uses HMAC Downstream mode)
("HMAC_DOWN_DIGITAL_SIGNATURE", 7, None, None, "need_rd_protect"), # Digital Signature peripheral key (uses HMAC Downstream mode)
("HMAC_UP", 8, None, None, "need_rd_protect"), # HMAC Upstream mode
("SECURE_BOOT_DIGEST0", 9, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST0 (Secure Boot key digest)
("SECURE_BOOT_DIGEST1", 10, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST1 (Secure Boot key digest)
("SECURE_BOOT_DIGEST2", 11, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST2 (Secure Boot key digest)
("XTS_AES_256_KEY", -1, "VIRTUAL", None, "no_need_rd_protect"), # Virtual purpose splits to XTS_AES_256_KEY_1 and XTS_AES_256_KEY_2
]
# fmt: on
KEY_PURPOSES_NAME = [name[0] for name in KEY_PURPOSES]
DIGEST_KEY_PURPOSES = [name[0] for name in KEY_PURPOSES if name[2] == "DIGEST"]
def check_format(self, new_value_str):
# str convert to int: "XTS_AES_128_KEY" - > str(4)
# if int: 4 -> str(4)
raw_val = new_value_str
for purpose_name in self.KEY_PURPOSES:
if purpose_name[0] == new_value_str:
raw_val = str(purpose_name[1])
break
if raw_val.isdigit():
if int(raw_val) not in [p[1] for p in self.KEY_PURPOSES if p[1] > 0]:
raise esptool.FatalError("'%s' can not be set (value out of range)" % raw_val)
else:
raise esptool.FatalError("'%s' unknown name" % raw_val)
return raw_val
def need_reverse(self, new_key_purpose):
for key in self.KEY_PURPOSES:
if key[0] == new_key_purpose:
return key[3] == "Reverse"
def need_rd_protect(self, new_key_purpose):
for key in self.KEY_PURPOSES:
if key[0] == new_key_purpose:
return key[4] == "need_rd_protect"
def get(self, from_read=True):
for p in self.KEY_PURPOSES:
if p[1] == self.get_raw(from_read):
return p[0]
return "FORBIDDEN_STATE"
def save(self, new_value):
raw_val = int(self.check_format(str(new_value)))
return super(EfuseKeyPurposeField, self).save(raw_val)
| 19,671 | Python | .py | 434 | 34.06682 | 160 | 0.561637 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,651 | mem_definition.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32s2/mem_definition.py | # This file describes eFuses fields and registers for ESP32 chip
#
# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import os
import yaml
from ..mem_definition_base import (
EfuseBlocksBase,
EfuseFieldsBase,
EfuseRegistersBase,
Field,
)
class EfuseDefineRegisters(EfuseRegistersBase):
EFUSE_MEM_SIZE = 0x01FC + 4
# EFUSE registers & command/conf values
DR_REG_EFUSE_BASE = 0x3F41A000
EFUSE_PGM_DATA0_REG = DR_REG_EFUSE_BASE
EFUSE_CHECK_VALUE0_REG = DR_REG_EFUSE_BASE + 0x020
EFUSE_CLK_REG = DR_REG_EFUSE_BASE + 0x1C8
EFUSE_CONF_REG = DR_REG_EFUSE_BASE + 0x1CC
EFUSE_STATUS_REG = DR_REG_EFUSE_BASE + 0x1D0
EFUSE_CMD_REG = DR_REG_EFUSE_BASE + 0x1D4
EFUSE_RD_RS_ERR0_REG = DR_REG_EFUSE_BASE + 0x194
EFUSE_RD_RS_ERR1_REG = DR_REG_EFUSE_BASE + 0x198
EFUSE_RD_REPEAT_ERR0_REG = DR_REG_EFUSE_BASE + 0x17C
EFUSE_RD_REPEAT_ERR1_REG = DR_REG_EFUSE_BASE + 0x180
EFUSE_RD_REPEAT_ERR2_REG = DR_REG_EFUSE_BASE + 0x184
EFUSE_RD_REPEAT_ERR3_REG = DR_REG_EFUSE_BASE + 0x188
EFUSE_RD_REPEAT_ERR4_REG = DR_REG_EFUSE_BASE + 0x18C
EFUSE_DAC_CONF_REG = DR_REG_EFUSE_BASE + 0x1E8
EFUSE_RD_TIM_CONF_REG = DR_REG_EFUSE_BASE + 0x1EC
EFUSE_WR_TIM_CONF1_REG = DR_REG_EFUSE_BASE + 0x1F4
EFUSE_WR_TIM_CONF2_REG = DR_REG_EFUSE_BASE + 0x1F8
EFUSE_DATE_REG = DR_REG_EFUSE_BASE + 0x1FC
EFUSE_WRITE_OP_CODE = 0x5A5A
EFUSE_READ_OP_CODE = 0x5AA5
EFUSE_PGM_CMD_MASK = 0x3
EFUSE_PGM_CMD = 0x2
EFUSE_READ_CMD = 0x1
BLOCK_ERRORS = [
# error_reg, err_num_mask, err_num_offs, fail_bit
(EFUSE_RD_REPEAT_ERR0_REG, None, None, None), # BLOCK0
(EFUSE_RD_RS_ERR0_REG, 0x7, 0, 3), # MAC_SPI_8M_0
(EFUSE_RD_RS_ERR0_REG, 0x7, 4, 7), # BLOCK_SYS_DATA
(EFUSE_RD_RS_ERR0_REG, 0x7, 8, 11), # BLOCK_USR_DATA
(EFUSE_RD_RS_ERR0_REG, 0x7, 12, 15), # BLOCK_KEY0
(EFUSE_RD_RS_ERR0_REG, 0x7, 16, 19), # BLOCK_KEY1
(EFUSE_RD_RS_ERR0_REG, 0x7, 20, 23), # BLOCK_KEY2
(EFUSE_RD_RS_ERR0_REG, 0x7, 24, 27), # BLOCK_KEY3
(EFUSE_RD_RS_ERR0_REG, 0x7, 28, 31), # BLOCK_KEY4
(EFUSE_RD_RS_ERR1_REG, 0x7, 0, 3), # BLOCK_KEY5
(EFUSE_RD_RS_ERR1_REG, 0x7, 4, 7), # BLOCK_SYS_DATA2
]
EFUSE_DAC_CONF_REG = DR_REG_EFUSE_BASE + 0x1E8
EFUSE_DAC_CLK_DIV_S = 0
EFUSE_DAC_CLK_DIV_M = 0xFF << EFUSE_DAC_CLK_DIV_S
EFUSE_RD_TIM_CONF_REG = DR_REG_EFUSE_BASE + 0x1EC
EFUSE_TSUR_A_S = 16
EFUSE_TSUR_A_M = 0xFF << EFUSE_TSUR_A_S
EFUSE_TRD_S = 8
EFUSE_TRD_M = 0xFF << EFUSE_TRD_S
EFUSE_THR_A_S = 0
EFUSE_THR_A_M = 0xFF << EFUSE_THR_A_S
EFUSE_WR_TIM_CONF0_REG = DR_REG_EFUSE_BASE + 0x1F0
EFUSE_TPGM_S = 16
EFUSE_TPGM_M = 0xFFFF << EFUSE_TPGM_S
EFUSE_TPGM_INACTIVE_S = 8
EFUSE_TPGM_INACTIVE_M = 0xFF << EFUSE_TPGM_INACTIVE_S
EFUSE_THP_A_S = 0
EFUSE_THP_A_M = 0xFF << EFUSE_THP_A_S
# EFUSE_WR_TIM_CONF1_REG
EFUSE_PWR_ON_NUM_S = 8
EFUSE_PWR_ON_NUM_M = 0xFFFF << EFUSE_PWR_ON_NUM_S
EFUSE_TSUP_A_S = 0
EFUSE_TSUP_A_M = 0xFF << EFUSE_TSUP_A_S
# EFUSE_WR_TIM_CONF2_REG
EFUSE_PWR_OFF_NUM_S = 0
EFUSE_PWR_OFF_NUM_M = 0xFFFF << EFUSE_PWR_OFF_NUM_S
# Configure clock
EFUSE_PROGRAMMING_TIMING_PARAMETERS = {
# APB Frequency: ( EFUSE_TSUP_A, EFUSE_TPGM, EFUSE_THP_A, EFUSE_TPGM_INACTIVE )
# Taken from TRM chapter "eFuse Controller": eFuse-Programming Timing
80: (0x2, 0x320, 0x2, 0x4),
40: (0x1, 0x190, 0x1, 0x2),
20: (0x1, 0xC8, 0x1, 0x1),
}
VDDQ_TIMING_PARAMETERS = {
# APB Frequency: ( EFUSE_DAC_CLK_DIV, EFUSE_PWR_ON_NUM, EFUSE_PWR_OFF_NUM )
# Taken from TRM chapter "eFuse Controller": eFuse VDDQ Timing Setting
80: (0xA0, 0xA200, 0x100),
40: (0x50, 0x5100, 0x80),
20: (0x28, 0x2880, 0x40),
}
EFUSE_READING_PARAMETERS = {
# APB Frequency: ( EFUSE_TSUR_A, EFUSE_TRD, EFUSE_THR_A )
# Taken from TRM chapter "eFuse Controller": eFuse-Read Timing
80: (0x2, 0x4, 0x2),
40: (0x1, 0x2, 0x1),
20: (0x1, 0x1, 0x1),
}
class EfuseDefineBlocks(EfuseBlocksBase):
__base_rd_regs = EfuseDefineRegisters.DR_REG_EFUSE_BASE
__base_wr_regs = EfuseDefineRegisters.EFUSE_PGM_DATA0_REG
# List of efuse blocks
# fmt: off
BLOCKS = [
# Name, Alias, Index, Read address, Write address, Write protect bit, Read protect bit, Len, key_purpose
("BLOCK0", [], 0, __base_rd_regs + 0x02C, __base_wr_regs, None, None, 6, None),
("MAC_SPI_8M_0", ["BLOCK1"], 1, __base_rd_regs + 0x044, __base_wr_regs, 20, None, 6, None),
("BLOCK_SYS_DATA", ["BLOCK2"], 2, __base_rd_regs + 0x05C, __base_wr_regs, 21, None, 8, None),
("BLOCK_USR_DATA", ["BLOCK3"], 3, __base_rd_regs + 0x07C, __base_wr_regs, 22, None, 8, None),
("BLOCK_KEY0", ["BLOCK4"], 4, __base_rd_regs + 0x09C, __base_wr_regs, 23, 0, 8, "KEY_PURPOSE_0"),
("BLOCK_KEY1", ["BLOCK5"], 5, __base_rd_regs + 0x0BC, __base_wr_regs, 24, 1, 8, "KEY_PURPOSE_1"),
("BLOCK_KEY2", ["BLOCK6"], 6, __base_rd_regs + 0x0DC, __base_wr_regs, 25, 2, 8, "KEY_PURPOSE_2"),
("BLOCK_KEY3", ["BLOCK7"], 7, __base_rd_regs + 0x0FC, __base_wr_regs, 26, 3, 8, "KEY_PURPOSE_3"),
("BLOCK_KEY4", ["BLOCK8"], 8, __base_rd_regs + 0x11C, __base_wr_regs, 27, 4, 8, "KEY_PURPOSE_4"),
("BLOCK_KEY5", ["BLOCK9"], 9, __base_rd_regs + 0x13C, __base_wr_regs, 28, 5, 8, "KEY_PURPOSE_5"),
("BLOCK_SYS_DATA2", ["BLOCK10"], 10, __base_rd_regs + 0x15C, __base_wr_regs, 29, 6, 8, None),
]
# fmt: on
def get_burn_block_data_names(self):
list_of_names = []
for block in self.BLOCKS:
blk = self.get(block)
if blk.name:
list_of_names.append(blk.name)
if blk.alias:
for alias in blk.alias:
list_of_names.append(alias)
return list_of_names
class EfuseDefineFields(EfuseFieldsBase):
def __init__(self) -> None:
# List of efuse fields from TRM the chapter eFuse Controller.
self.EFUSES = []
self.KEYBLOCKS = []
# if BLK_VERSION_MINOR is 1, these efuse fields are in BLOCK2
self.BLOCK2_CALIBRATION_EFUSES = []
self.CALC = []
dir_name = os.path.dirname(os.path.abspath(__file__))
dir_name, file_name = os.path.split(dir_name)
file_name = file_name + ".yaml"
dir_name, _ = os.path.split(dir_name)
efuse_file = os.path.join(dir_name, "efuse_defs", file_name)
with open(f"{efuse_file}", "r") as r_file:
e_desc = yaml.safe_load(r_file)
super().__init__(e_desc)
for i, efuse in enumerate(self.ALL_EFUSES):
if efuse.name in [
"BLOCK_USR_DATA",
"BLOCK_KEY0",
"BLOCK_KEY1",
"BLOCK_KEY2",
"BLOCK_KEY3",
"BLOCK_KEY4",
"BLOCK_KEY5",
"BLOCK_SYS_DATA2",
]:
if efuse.name == "BLOCK_USR_DATA":
efuse.bit_len = 256
efuse.type = "bytes:32"
self.KEYBLOCKS.append(efuse)
self.ALL_EFUSES[i] = None
elif efuse.category == "calibration":
self.BLOCK2_CALIBRATION_EFUSES.append(efuse)
self.ALL_EFUSES[i] = None
f = Field()
f.name = "WAFER_VERSION_MINOR"
f.block = 0
f.bit_len = 4
f.type = f"uint:{f.bit_len}"
f.category = "identity"
f.class_type = "wafer"
f.description = "calc WAFER VERSION MINOR = WAFER_VERSION_MINOR_HI << 3 + WAFER_VERSION_MINOR_LO (read only)"
self.CALC.append(f)
for efuse in self.ALL_EFUSES:
if efuse is not None:
self.EFUSES.append(efuse)
self.ALL_EFUSES = []
| 8,141 | Python | .py | 179 | 37.391061 | 155 | 0.577965 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,652 | emulate_efuse_controller.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32c6/emulate_efuse_controller.py | # This file describes eFuses controller for ESP32-C6 chip
#
# SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import reedsolo
from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters
from ..emulate_efuse_controller_base import EmulateEfuseControllerBase, FatalError
class EmulateEfuseController(EmulateEfuseControllerBase):
"""The class for virtual efuse operation. Using for HOST_TEST."""
CHIP_NAME = "ESP32-C6"
mem = None
debug = False
def __init__(self, efuse_file=None, debug=False):
self.Blocks = EfuseDefineBlocks
self.Fields = EfuseDefineFields()
self.REGS = EfuseDefineRegisters
super(EmulateEfuseController, self).__init__(efuse_file, debug)
self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
""" esptool method start >>"""
def get_major_chip_version(self):
return 0
def get_minor_chip_version(self):
return 0
def get_crystal_freq(self):
return 40 # MHz (common for all chips)
def get_security_info(self):
return {
"flags": 0,
"flash_crypt_cnt": 0,
"key_purposes": 0,
"chip_id": 0,
"api_version": 0,
}
""" << esptool method end """
def handle_writing_event(self, addr, value):
if addr == self.REGS.EFUSE_CMD_REG:
if value & self.REGS.EFUSE_PGM_CMD:
self.copy_blocks_wr_regs_to_rd_regs(updated_block=(value >> 2) & 0xF)
self.clean_blocks_wr_regs()
self.check_rd_protection_area()
self.write_reg(addr, 0)
self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
elif value == self.REGS.EFUSE_READ_CMD:
self.write_reg(addr, 0)
self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
self.save_to_file()
def get_bitlen_of_block(self, blk, wr=False):
if blk.id == 0:
if wr:
return 32 * 8
else:
return 32 * blk.len
else:
if wr:
rs_coding = 32 * 3
return 32 * 8 + rs_coding
else:
return 32 * blk.len
def handle_coding_scheme(self, blk, data):
if blk.id != 0:
# CODING_SCHEME RS applied only for all blocks except BLK0.
coded_bytes = 12
data.pos = coded_bytes * 8
plain_data = data.readlist("32*uint:8")[::-1]
# takes 32 bytes
# apply RS encoding
rs = reedsolo.RSCodec(coded_bytes)
# 32 byte of data + 12 bytes RS
calc_encoded_data = list(rs.encode([x for x in plain_data]))
data.pos = 0
if calc_encoded_data != data.readlist("44*uint:8")[::-1]:
raise FatalError("Error in coding scheme data")
data = data[coded_bytes * 8 :]
if blk.len < 8:
data = data[(8 - blk.len) * 32 :]
return data
| 3,067 | Python | .py | 77 | 29.597403 | 86 | 0.575462 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,653 | __init__.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32c6/__init__.py | from . import operations
from .emulate_efuse_controller import EmulateEfuseController
from .fields import EspEfuses
| 116 | Python | .py | 3 | 37.666667 | 60 | 0.876106 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,654 | operations.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32c6/operations.py | # This file includes the operations with eFuses for ESP32-C6 chip
#
# SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import argparse
import os # noqa: F401. It is used in IDF scripts
import traceback
import espsecure
import esptool
from . import fields
from .. import util
from ..base_operations import (
add_common_commands,
add_force_write_always,
add_show_sensitive_info_option,
burn_bit,
burn_block_data,
burn_efuse,
check_error,
dump,
read_protect_efuse,
summary,
write_protect_efuse,
)
def protect_options(p):
p.add_argument(
"--no-write-protect",
help="Disable write-protecting of the key. The key remains writable. "
"(The keys use the RS coding scheme that does not support "
"post-write data changes. Forced write can damage RS encoding bits.) "
"The write-protecting of keypurposes does not depend on the option, "
"it will be set anyway.",
action="store_true",
)
p.add_argument(
"--no-read-protect",
help="Disable read-protecting of the key. The key remains readable software."
"The key with keypurpose[USER, RESERVED and *_DIGEST] "
"will remain readable anyway. For the rest keypurposes the read-protection "
"will be defined the option (Read-protect by default).",
action="store_true",
)
def add_commands(subparsers, efuses):
add_common_commands(subparsers, efuses)
burn_key = subparsers.add_parser(
"burn_key", help="Burn the key block with the specified name"
)
protect_options(burn_key)
add_force_write_always(burn_key)
add_show_sensitive_info_option(burn_key)
burn_key.add_argument(
"block",
help="Key block to burn",
action="append",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key.add_argument(
"keyfile",
help="File containing 256 bits of binary key data",
action="append",
type=argparse.FileType("rb"),
)
burn_key.add_argument(
"keypurpose",
help="Purpose to set.",
action="append",
choices=fields.EfuseKeyPurposeField.KEY_PURPOSES_NAME,
)
for _ in efuses.BLOCKS_FOR_KEYS:
burn_key.add_argument(
"block",
help="Key block to burn",
nargs="?",
action="append",
metavar="BLOCK",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key.add_argument(
"keyfile",
help="File containing 256 bits of binary key data",
nargs="?",
action="append",
metavar="KEYFILE",
type=argparse.FileType("rb"),
)
burn_key.add_argument(
"keypurpose",
help="Purpose to set.",
nargs="?",
action="append",
metavar="KEYPURPOSE",
choices=fields.EfuseKeyPurposeField.KEY_PURPOSES_NAME,
)
burn_key_digest = subparsers.add_parser(
"burn_key_digest",
help="Parse a RSA public key and burn the digest to key efuse block",
)
protect_options(burn_key_digest)
add_force_write_always(burn_key_digest)
add_show_sensitive_info_option(burn_key_digest)
burn_key_digest.add_argument(
"block",
help="Key block to burn",
action="append",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key_digest.add_argument(
"keyfile",
help="Key file to digest (PEM format)",
action="append",
type=argparse.FileType("rb"),
)
burn_key_digest.add_argument(
"keypurpose",
help="Purpose to set.",
action="append",
choices=fields.EfuseKeyPurposeField.DIGEST_KEY_PURPOSES,
)
for _ in efuses.BLOCKS_FOR_KEYS:
burn_key_digest.add_argument(
"block",
help="Key block to burn",
nargs="?",
action="append",
metavar="BLOCK",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key_digest.add_argument(
"keyfile",
help="Key file to digest (PEM format)",
nargs="?",
action="append",
metavar="KEYFILE",
type=argparse.FileType("rb"),
)
burn_key_digest.add_argument(
"keypurpose",
help="Purpose to set.",
nargs="?",
action="append",
metavar="KEYPURPOSE",
choices=fields.EfuseKeyPurposeField.DIGEST_KEY_PURPOSES,
)
p = subparsers.add_parser(
"set_flash_voltage",
help="Permanently set the internal flash voltage regulator "
"to either 1.8V, 3.3V or OFF. "
"This means GPIO45 can be high or low at reset without "
"changing the flash voltage.",
)
p.add_argument("voltage", help="Voltage selection", choices=["1.8V", "3.3V", "OFF"])
p = subparsers.add_parser(
"burn_custom_mac", help="Burn a 48-bit Custom MAC Address to EFUSE BLOCK3."
)
p.add_argument(
"mac",
help="Custom MAC Address to burn given in hexadecimal format with bytes "
"separated by colons (e.g. AA:CD:EF:01:02:03).",
type=fields.base_fields.CheckArgValue(efuses, "CUSTOM_MAC"),
)
add_force_write_always(p)
p = subparsers.add_parser("get_custom_mac", help="Prints the Custom MAC Address.")
def burn_custom_mac(esp, efuses, args):
efuses["CUSTOM_MAC"].save(args.mac)
if not efuses.burn_all(check_batch_mode=True):
return
get_custom_mac(esp, efuses, args)
print("Successful")
def get_custom_mac(esp, efuses, args):
print("Custom MAC Address: {}".format(efuses["CUSTOM_MAC"].get()))
def set_flash_voltage(esp, efuses, args):
raise esptool.FatalError("set_flash_voltage is not supported!")
def adc_info(esp, efuses, args):
print("")
# fmt: off
if efuses["BLK_VERSION_MINOR"].get() == 1:
print("Temperature Sensor Calibration = {}C".format(efuses["TEMP_CALIB"].get()))
print("")
print("ADC1 Calibration data stored in efuse BLOCK2:")
print(f"OCODE: {efuses['OCODE'].get()}")
print(f"INIT_CODE_ATTEN0: {efuses['ADC1_INIT_CODE_ATTEN0'].get()}")
print(f"INIT_CODE_ATTEN1: {efuses['ADC1_INIT_CODE_ATTEN1'].get()}")
print(f"INIT_CODE_ATTEN2: {efuses['ADC1_INIT_CODE_ATTEN2'].get()}")
print(f"INIT_CODE_ATTEN3: {efuses['ADC1_INIT_CODE_ATTEN3'].get()}")
print(f"CAL_VOL_ATTEN0: {efuses['ADC1_CAL_VOL_ATTEN0'].get()}")
print(f"CAL_VOL_ATTEN1: {efuses['ADC1_CAL_VOL_ATTEN1'].get()}")
print(f"CAL_VOL_ATTEN2: {efuses['ADC1_CAL_VOL_ATTEN2'].get()}")
print(f"CAL_VOL_ATTEN3: {efuses['ADC1_CAL_VOL_ATTEN3'].get()}")
print(f"INIT_CODE_ATTEN0_CH0: {efuses['ADC1_INIT_CODE_ATTEN0_CH0'].get()}")
print(f"INIT_CODE_ATTEN0_CH1: {efuses['ADC1_INIT_CODE_ATTEN0_CH1'].get()}")
print(f"INIT_CODE_ATTEN0_CH2: {efuses['ADC1_INIT_CODE_ATTEN0_CH2'].get()}")
print(f"INIT_CODE_ATTEN0_CH3: {efuses['ADC1_INIT_CODE_ATTEN0_CH3'].get()}")
print(f"INIT_CODE_ATTEN0_CH4: {efuses['ADC1_INIT_CODE_ATTEN0_CH4'].get()}")
print(f"INIT_CODE_ATTEN0_CH5: {efuses['ADC1_INIT_CODE_ATTEN0_CH5'].get()}")
print(f"INIT_CODE_ATTEN0_CH6: {efuses['ADC1_INIT_CODE_ATTEN0_CH6'].get()}")
else:
print("BLK_VERSION_MINOR = {}".format(efuses["BLK_VERSION_MINOR"].get_meaning()))
# fmt: on
def burn_key(esp, efuses, args, digest=None):
if digest is None:
datafile_list = args.keyfile[
0 : len([name for name in args.keyfile if name is not None]) :
]
else:
datafile_list = digest[0 : len([name for name in digest if name is not None]) :]
efuses.force_write_always = args.force_write_always
block_name_list = args.block[
0 : len([name for name in args.block if name is not None]) :
]
keypurpose_list = args.keypurpose[
0 : len([name for name in args.keypurpose if name is not None]) :
]
util.check_duplicate_name_in_list(block_name_list)
if len(block_name_list) != len(datafile_list) or len(block_name_list) != len(
keypurpose_list
):
raise esptool.FatalError(
"The number of blocks (%d), datafile (%d) and keypurpose (%d) "
"should be the same."
% (len(block_name_list), len(datafile_list), len(keypurpose_list))
)
print("Burn keys to blocks:")
for block_name, datafile, keypurpose in zip(
block_name_list, datafile_list, keypurpose_list
):
efuse = None
for block in efuses.blocks:
if block_name == block.name or block_name in block.alias:
efuse = efuses[block.name]
if efuse is None:
raise esptool.FatalError("Unknown block name - %s" % (block_name))
num_bytes = efuse.bit_len // 8
block_num = efuses.get_index_block_by_name(block_name)
block = efuses.blocks[block_num]
if digest is None:
data = datafile.read()
else:
data = datafile
print(" - %s" % (efuse.name), end=" ")
revers_msg = None
if efuses[block.key_purpose_name].need_reverse(keypurpose):
revers_msg = "\tReversing byte order for AES-XTS hardware peripheral"
data = data[::-1]
print(
"-> [{}]".format(
util.hexify(data, " ")
if args.show_sensitive_info
else " ".join(["??"] * len(data))
)
)
if revers_msg:
print(revers_msg)
if len(data) != num_bytes:
raise esptool.FatalError(
"Incorrect key file size %d. Key file must be %d bytes (%d bits) "
"of raw binary key data." % (len(data), num_bytes, num_bytes * 8)
)
if efuses[block.key_purpose_name].need_rd_protect(keypurpose):
read_protect = False if args.no_read_protect else True
else:
read_protect = False
write_protect = not args.no_write_protect
# using efuse instead of a block gives the advantage of checking it as the whole field.
efuse.save(data)
disable_wr_protect_key_purpose = False
if efuses[block.key_purpose_name].get() != keypurpose:
if efuses[block.key_purpose_name].is_writeable():
print(
"\t'%s': '%s' -> '%s'."
% (
block.key_purpose_name,
efuses[block.key_purpose_name].get(),
keypurpose,
)
)
efuses[block.key_purpose_name].save(keypurpose)
disable_wr_protect_key_purpose = True
else:
raise esptool.FatalError(
"It is not possible to change '%s' to '%s' "
"because write protection bit is set."
% (block.key_purpose_name, keypurpose)
)
else:
print("\t'%s' is already '%s'." % (block.key_purpose_name, keypurpose))
if efuses[block.key_purpose_name].is_writeable():
disable_wr_protect_key_purpose = True
if disable_wr_protect_key_purpose:
print("\tDisabling write to '%s'." % block.key_purpose_name)
efuses[block.key_purpose_name].disable_write()
if read_protect:
print("\tDisabling read to key block")
efuse.disable_read()
if write_protect:
print("\tDisabling write to key block")
efuse.disable_write()
print("")
if not write_protect:
print("Keys will remain writeable (due to --no-write-protect)")
if args.no_read_protect:
print("Keys will remain readable (due to --no-read-protect)")
if not efuses.burn_all(check_batch_mode=True):
return
print("Successful")
def burn_key_digest(esp, efuses, args):
digest_list = []
datafile_list = args.keyfile[
0 : len([name for name in args.keyfile if name is not None]) :
]
block_list = args.block[
0 : len([block for block in args.block if block is not None]) :
]
for block_name, datafile in zip(block_list, datafile_list):
efuse = None
for block in efuses.blocks:
if block_name == block.name or block_name in block.alias:
efuse = efuses[block.name]
if efuse is None:
raise esptool.FatalError("Unknown block name - %s" % (block_name))
num_bytes = efuse.bit_len // 8
digest = espsecure._digest_sbv2_public_key(datafile)
if len(digest) != num_bytes:
raise esptool.FatalError(
"Incorrect digest size %d. Digest must be %d bytes (%d bits) "
"of raw binary key data." % (len(digest), num_bytes, num_bytes * 8)
)
digest_list.append(digest)
burn_key(esp, efuses, args, digest=digest_list)
def espefuse(esp, efuses, args, command):
parser = argparse.ArgumentParser()
subparsers = parser.add_subparsers(dest="operation")
add_commands(subparsers, efuses)
try:
cmd_line_args = parser.parse_args(command.split())
except SystemExit:
traceback.print_stack()
raise esptool.FatalError('"{}" - incorrect command'.format(command))
if cmd_line_args.operation == "execute_scripts":
configfiles = cmd_line_args.configfiles
index = cmd_line_args.index
# copy arguments from args to cmd_line_args
vars(cmd_line_args).update(vars(args))
if cmd_line_args.operation == "execute_scripts":
cmd_line_args.configfiles = configfiles
cmd_line_args.index = index
if cmd_line_args.operation is None:
parser.print_help()
parser.exit(1)
operation_func = globals()[cmd_line_args.operation]
# each 'operation' is a module-level function of the same name
operation_func(esp, efuses, cmd_line_args)
def execute_scripts(esp, efuses, args):
efuses.batch_mode_cnt += 1
del args.operation
scripts = args.scripts
del args.scripts
for file in scripts:
with open(file.name, "r") as file:
exec(compile(file.read(), file.name, "exec"))
if args.debug:
for block in efuses.blocks:
data = block.get_bitstring(from_read=False)
block.print_block(data, "regs_for_burn", args.debug)
efuses.batch_mode_cnt -= 1
if not efuses.burn_all(check_batch_mode=True):
return
print("Successful")
| 14,667 | Python | .py | 368 | 30.972826 | 95 | 0.602077 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,655 | fields.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32c6/fields.py | # This file describes eFuses for ESP32-C6 chip
#
# SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import binascii
import struct
import time
from bitstring import BitArray
import esptool
import reedsolo
from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters
from .. import base_fields
from .. import util
class EfuseBlock(base_fields.EfuseBlockBase):
def len_of_burn_unit(self):
# The writing register window is 8 registers for any blocks.
# len in bytes
return 8 * 4
def __init__(self, parent, param, skip_read=False):
parent.read_coding_scheme()
super(EfuseBlock, self).__init__(parent, param, skip_read=skip_read)
def apply_coding_scheme(self):
data = self.get_raw(from_read=False)[::-1]
if len(data) < self.len_of_burn_unit():
add_empty_bytes = self.len_of_burn_unit() - len(data)
data = data + (b"\x00" * add_empty_bytes)
if self.get_coding_scheme() == self.parent.REGS.CODING_SCHEME_RS:
# takes 32 bytes
# apply RS encoding
rs = reedsolo.RSCodec(12)
# 32 byte of data + 12 bytes RS
encoded_data = rs.encode([x for x in data])
words = struct.unpack("<" + "I" * 11, encoded_data)
# returns 11 words (8 words of data + 3 words of RS coding)
else:
# takes 32 bytes
words = struct.unpack("<" + ("I" * (len(data) // 4)), data)
# returns 8 words
return words
class EspEfuses(base_fields.EspEfusesBase):
"""
Wrapper object to manage the efuse fields in a connected ESP bootloader
"""
debug = False
do_not_confirm = False
def __init__(self, esp, skip_connect=False, debug=False, do_not_confirm=False):
self.Blocks = EfuseDefineBlocks()
self.Fields = EfuseDefineFields()
self.REGS = EfuseDefineRegisters
self.BURN_BLOCK_DATA_NAMES = self.Blocks.get_burn_block_data_names()
self.BLOCKS_FOR_KEYS = self.Blocks.get_blocks_for_keys()
self._esp = esp
self.debug = debug
self.do_not_confirm = do_not_confirm
if esp.CHIP_NAME != "ESP32-C6":
raise esptool.FatalError(
"Expected the 'esp' param for ESP32-C6 chip but got for '%s'."
% (esp.CHIP_NAME)
)
if not skip_connect:
flags = self._esp.get_security_info()["flags"]
GET_SECURITY_INFO_FLAG_SECURE_DOWNLOAD_ENABLE = 1 << 2
if flags & GET_SECURITY_INFO_FLAG_SECURE_DOWNLOAD_ENABLE:
raise esptool.FatalError(
"Secure Download Mode is enabled. The tool can not read eFuses."
)
self.blocks = [
EfuseBlock(self, self.Blocks.get(block), skip_read=skip_connect)
for block in self.Blocks.BLOCKS
]
if not skip_connect:
self.get_coding_scheme_warnings()
self.efuses = [EfuseField.convert(self, efuse) for efuse in self.Fields.EFUSES]
self.efuses += [
EfuseField.convert(self, efuse) for efuse in self.Fields.KEYBLOCKS
]
if skip_connect:
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
]
else:
if self["BLK_VERSION_MINOR"].get() == 1:
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
]
self.efuses += [
EfuseField.convert(self, efuse) for efuse in self.Fields.CALC
]
def __getitem__(self, efuse_name):
"""Return the efuse field with the given name"""
for e in self.efuses:
if efuse_name == e.name or any(x == efuse_name for x in e.alt_names):
return e
new_fields = False
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES:
if efuse.name == efuse_name or any(
x == efuse_name for x in efuse.alt_names
):
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
]
new_fields = True
if new_fields:
for e in self.efuses:
if efuse_name == e.name or any(x == efuse_name for x in e.alt_names):
return e
raise KeyError
def read_coding_scheme(self):
self.coding_scheme = self.REGS.CODING_SCHEME_RS
def print_status_regs(self):
print("")
self.blocks[0].print_block(self.blocks[0].err_bitarray, "err__regs", debug=True)
print(
"{:27} 0x{:08x}".format(
"EFUSE_RD_RS_ERR0_REG", self.read_reg(self.REGS.EFUSE_RD_RS_ERR0_REG)
)
)
print(
"{:27} 0x{:08x}".format(
"EFUSE_RD_RS_ERR1_REG", self.read_reg(self.REGS.EFUSE_RD_RS_ERR1_REG)
)
)
def efuse_controller_setup(self):
self.set_efuse_timing()
self.clear_pgm_registers()
self.wait_efuse_idle()
def write_efuses(self, block):
self.efuse_program(block)
return self.get_coding_scheme_warnings(silent=True)
def clear_pgm_registers(self):
self.wait_efuse_idle()
for r in range(
self.REGS.EFUSE_PGM_DATA0_REG, self.REGS.EFUSE_PGM_DATA0_REG + 32, 4
):
self.write_reg(r, 0)
def wait_efuse_idle(self):
deadline = time.time() + self.REGS.EFUSE_BURN_TIMEOUT
while time.time() < deadline:
# if self.read_reg(self.REGS.EFUSE_CMD_REG) == 0:
if self.read_reg(self.REGS.EFUSE_STATUS_REG) & 0x7 == 1:
return
raise esptool.FatalError(
"Timed out waiting for Efuse controller command to complete"
)
def efuse_program(self, block):
self.wait_efuse_idle()
self.write_reg(self.REGS.EFUSE_CONF_REG, self.REGS.EFUSE_WRITE_OP_CODE)
self.write_reg(self.REGS.EFUSE_CMD_REG, self.REGS.EFUSE_PGM_CMD | (block << 2))
self.wait_efuse_idle()
self.clear_pgm_registers()
self.efuse_read()
def efuse_read(self):
self.wait_efuse_idle()
self.write_reg(self.REGS.EFUSE_CONF_REG, self.REGS.EFUSE_READ_OP_CODE)
# need to add a delay after triggering EFUSE_READ_CMD, as ROM loader checks some
# efuse registers after each command is completed
# if ENABLE_SECURITY_DOWNLOAD or DIS_DOWNLOAD_MODE is enabled by the current cmd, then we need to try to reconnect to the chip.
try:
self.write_reg(
self.REGS.EFUSE_CMD_REG, self.REGS.EFUSE_READ_CMD, delay_after_us=1000
)
self.wait_efuse_idle()
except esptool.FatalError:
secure_download_mode_before = self._esp.secure_download_mode
try:
self._esp = self.reconnect_chip(self._esp)
except esptool.FatalError:
print("Can not re-connect to the chip")
if not self["DIS_DOWNLOAD_MODE"].get() and self[
"DIS_DOWNLOAD_MODE"
].get(from_read=False):
print(
"This is the correct behavior as we are actually burning "
"DIS_DOWNLOAD_MODE which disables the connection to the chip"
)
print("DIS_DOWNLOAD_MODE is enabled")
print("Successful")
exit(0) # finish without errors
raise
print("Established a connection with the chip")
if self._esp.secure_download_mode and not secure_download_mode_before:
print("Secure download mode is enabled")
if not self["ENABLE_SECURITY_DOWNLOAD"].get() and self[
"ENABLE_SECURITY_DOWNLOAD"
].get(from_read=False):
print(
"espefuse tool can not continue to work in Secure download mode"
)
print("ENABLE_SECURITY_DOWNLOAD is enabled")
print("Successful")
exit(0) # finish without errors
raise
def set_efuse_timing(self):
"""Set timing registers for burning efuses"""
# Configure clock
apb_freq = self.get_crystal_freq()
if apb_freq != 40:
raise esptool.FatalError(
"The eFuse supports only xtal=40M (xtal was %d)" % apb_freq
)
self.update_reg(self.REGS.EFUSE_DAC_CONF_REG, self.REGS.EFUSE_DAC_NUM_M, 0xFF)
self.update_reg(
self.REGS.EFUSE_DAC_CONF_REG, self.REGS.EFUSE_DAC_CLK_DIV_M, 0x28
)
self.update_reg(
self.REGS.EFUSE_WR_TIM_CONF1_REG, self.REGS.EFUSE_PWR_ON_NUM_M, 0x3000
)
self.update_reg(
self.REGS.EFUSE_WR_TIM_CONF2_REG, self.REGS.EFUSE_PWR_OFF_NUM_M, 0x190
)
def get_coding_scheme_warnings(self, silent=False):
"""Check if the coding scheme has detected any errors."""
old_addr_reg = 0
reg_value = 0
ret_fail = False
for block in self.blocks:
if block.id == 0:
words = [
self.read_reg(self.REGS.EFUSE_RD_REPEAT_ERR0_REG + offs * 4)
for offs in range(5)
]
block.err_bitarray.pos = 0
for word in reversed(words):
block.err_bitarray.overwrite(BitArray("uint:32=%d" % word))
block.num_errors = block.err_bitarray.count(True)
block.fail = block.num_errors != 0
else:
addr_reg, err_num_mask, err_num_offs, fail_bit = self.REGS.BLOCK_ERRORS[
block.id
]
if err_num_mask is None or err_num_offs is None or fail_bit is None:
continue
if addr_reg != old_addr_reg:
old_addr_reg = addr_reg
reg_value = self.read_reg(addr_reg)
block.fail = reg_value & (1 << fail_bit) != 0
block.num_errors = (reg_value >> err_num_offs) & err_num_mask
ret_fail |= block.fail
if not silent and (block.fail or block.num_errors):
print(
"Error(s) in BLOCK%d [ERRORS:%d FAIL:%d]"
% (block.id, block.num_errors, block.fail)
)
if (self.debug or ret_fail) and not silent:
self.print_status_regs()
return ret_fail
def summary(self):
# TODO add support set_flash_voltage - "Flash voltage (VDD_SPI)"
return ""
class EfuseField(base_fields.EfuseFieldBase):
@staticmethod
def convert(parent, efuse):
return {
"mac": EfuseMacField,
"keypurpose": EfuseKeyPurposeField,
"t_sensor": EfuseTempSensor,
"adc_tp": EfuseAdcPointCalibration,
"wafer": EfuseWafer,
}.get(efuse.class_type, EfuseField)(parent, efuse)
class EfuseWafer(EfuseField):
def get(self, from_read=True):
hi_bits = self.parent["WAFER_VERSION_MINOR_HI"].get(from_read)
assert self.parent["WAFER_VERSION_MINOR_HI"].bit_len == 1
lo_bits = self.parent["WAFER_VERSION_MINOR_LO"].get(from_read)
assert self.parent["WAFER_VERSION_MINOR_LO"].bit_len == 3
return (hi_bits << 3) + lo_bits
def save(self, new_value):
raise esptool.FatalError("Burning %s is not supported" % self.name)
class EfuseTempSensor(EfuseField):
def get(self, from_read=True):
value = self.get_bitstring(from_read)
sig = -1 if value[0] else 1
return sig * value[1:].uint * 0.1
class EfuseAdcPointCalibration(EfuseField):
def get(self, from_read=True):
STEP_SIZE = 4
value = self.get_bitstring(from_read)
sig = -1 if value[0] else 1
return sig * value[1:].uint * STEP_SIZE
class EfuseMacField(EfuseField):
def check_format(self, new_value_str):
if new_value_str is None:
raise esptool.FatalError(
"Required MAC Address in AA:CD:EF:01:02:03 format!"
)
num_bytes = 8 if self.name == "MAC_EUI64" else 6
if new_value_str.count(":") != num_bytes - 1:
raise esptool.FatalError(
f"MAC Address needs to be a {num_bytes}-byte hexadecimal format "
"separated by colons (:)!"
)
hexad = new_value_str.replace(":", "").split(" ", 1)[0]
hexad = hexad.split(" ", 1)[0] if self.is_field_calculated() else hexad
if len(hexad) != num_bytes * 2:
raise esptool.FatalError(
f"MAC Address needs to be a {num_bytes}-byte hexadecimal number "
f"({num_bytes * 2} hexadecimal characters)!"
)
# order of bytearray = b'\xaa\xcd\xef\x01\x02\x03',
bindata = binascii.unhexlify(hexad)
if not self.is_field_calculated():
# unicast address check according to
# https://tools.ietf.org/html/rfc7042#section-2.1
if esptool.util.byte(bindata, 0) & 0x01:
raise esptool.FatalError("Custom MAC must be a unicast MAC!")
return bindata
def check(self):
errs, fail = self.parent.get_block_errors(self.block)
if errs != 0 or fail:
output = "Block%d has ERRORS:%d FAIL:%d" % (self.block, errs, fail)
else:
output = "OK"
return "(" + output + ")"
def get(self, from_read=True):
if self.name == "CUSTOM_MAC":
mac = self.get_raw(from_read)[::-1]
elif self.name == "MAC":
mac = self.get_raw(from_read)
elif self.name == "MAC_EUI64":
mac = self.parent["MAC"].get_bitstring(from_read).copy()
mac_ext = self.parent["MAC_EXT"].get_bitstring(from_read)
mac.insert(mac_ext, 24)
mac = mac.bytes
else:
mac = self.get_raw(from_read)
return "%s %s" % (util.hexify(mac, ":"), self.check())
def save(self, new_value):
def print_field(e, new_value):
print(
" - '{}' ({}) {} -> {}".format(
e.name, e.description, e.get_bitstring(), new_value
)
)
if self.name == "CUSTOM_MAC":
bitarray_mac = self.convert_to_bitstring(new_value)
print_field(self, bitarray_mac)
super(EfuseMacField, self).save(new_value)
else:
# Writing the BLOCK1 (MAC_SPI_8M_0) default MAC is not possible,
# as it's written in the factory.
raise esptool.FatalError(f"Burning {self.name} is not supported")
# fmt: off
class EfuseKeyPurposeField(EfuseField):
KEY_PURPOSES = [
("USER", 0, None, None, "no_need_rd_protect"), # User purposes (software-only use)
("RESERVED", 1, None, None, "no_need_rd_protect"), # Reserved
("XTS_AES_128_KEY", 4, None, "Reverse", "need_rd_protect"), # XTS_AES_128_KEY (flash/PSRAM encryption)
("HMAC_DOWN_ALL", 5, None, None, "need_rd_protect"), # HMAC Downstream mode
("HMAC_DOWN_JTAG", 6, None, None, "need_rd_protect"), # JTAG soft enable key (uses HMAC Downstream mode)
("HMAC_DOWN_DIGITAL_SIGNATURE", 7, None, None, "need_rd_protect"), # Digital Signature peripheral key (uses HMAC Downstream mode)
("HMAC_UP", 8, None, None, "need_rd_protect"), # HMAC Upstream mode
("SECURE_BOOT_DIGEST0", 9, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST0 (Secure Boot key digest)
("SECURE_BOOT_DIGEST1", 10, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST1 (Secure Boot key digest)
("SECURE_BOOT_DIGEST2", 11, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST2 (Secure Boot key digest)
]
# fmt: on
KEY_PURPOSES_NAME = [name[0] for name in KEY_PURPOSES]
DIGEST_KEY_PURPOSES = [name[0] for name in KEY_PURPOSES if name[2] == "DIGEST"]
def check_format(self, new_value_str):
# str convert to int: "XTS_AES_128_KEY" - > str(4)
# if int: 4 -> str(4)
raw_val = new_value_str
for purpose_name in self.KEY_PURPOSES:
if purpose_name[0] == new_value_str:
raw_val = str(purpose_name[1])
break
if raw_val.isdigit():
if int(raw_val) not in [p[1] for p in self.KEY_PURPOSES if p[1] > 0]:
raise esptool.FatalError("'%s' can not be set (value out of range)" % raw_val)
else:
raise esptool.FatalError("'%s' unknown name" % raw_val)
return raw_val
def need_reverse(self, new_key_purpose):
for key in self.KEY_PURPOSES:
if key[0] == new_key_purpose:
return key[3] == "Reverse"
def need_rd_protect(self, new_key_purpose):
for key in self.KEY_PURPOSES:
if key[0] == new_key_purpose:
return key[4] == "need_rd_protect"
def get(self, from_read=True):
for p in self.KEY_PURPOSES:
if p[1] == self.get_raw(from_read):
return p[0]
return "FORBIDDEN_STATE"
def get_name(self, raw_val):
for key in self.KEY_PURPOSES:
if key[1] == raw_val:
return key[0]
def save(self, new_value):
raw_val = int(self.check_format(str(new_value)))
str_new_value = self.get_name(raw_val)
if self.name == "KEY_PURPOSE_5" and str_new_value.startswith("XTS_AES"):
raise esptool.FatalError(f"{self.name} can not have {str_new_value} key due to a hardware bug (please see TRM for more details)")
return super(EfuseKeyPurposeField, self).save(raw_val)
| 18,365 | Python | .py | 399 | 34.711779 | 155 | 0.564977 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,656 | mem_definition.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32c6/mem_definition.py | # This file describes eFuses fields and registers for ESP32-C6 chip
#
# SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import os
import yaml
from ..mem_definition_base import (
EfuseBlocksBase,
EfuseFieldsBase,
EfuseRegistersBase,
Field,
)
class EfuseDefineRegisters(EfuseRegistersBase):
EFUSE_MEM_SIZE = 0x01FC + 4
# EFUSE registers & command/conf values
DR_REG_EFUSE_BASE = 0x600B0800
EFUSE_PGM_DATA0_REG = DR_REG_EFUSE_BASE
EFUSE_CHECK_VALUE0_REG = DR_REG_EFUSE_BASE + 0x020
EFUSE_CLK_REG = DR_REG_EFUSE_BASE + 0x1C8
EFUSE_CONF_REG = DR_REG_EFUSE_BASE + 0x1CC
EFUSE_STATUS_REG = DR_REG_EFUSE_BASE + 0x1D0
EFUSE_CMD_REG = DR_REG_EFUSE_BASE + 0x1D4
EFUSE_RD_RS_ERR0_REG = DR_REG_EFUSE_BASE + 0x1C0
EFUSE_RD_RS_ERR1_REG = DR_REG_EFUSE_BASE + 0x1C4
EFUSE_RD_REPEAT_ERR0_REG = DR_REG_EFUSE_BASE + 0x17C
EFUSE_RD_REPEAT_ERR1_REG = DR_REG_EFUSE_BASE + 0x180
EFUSE_RD_REPEAT_ERR2_REG = DR_REG_EFUSE_BASE + 0x184
EFUSE_RD_REPEAT_ERR3_REG = DR_REG_EFUSE_BASE + 0x188
EFUSE_RD_REPEAT_ERR4_REG = DR_REG_EFUSE_BASE + 0x18C
EFUSE_DAC_CONF_REG = DR_REG_EFUSE_BASE + 0x1E8
EFUSE_RD_TIM_CONF_REG = DR_REG_EFUSE_BASE + 0x1EC
EFUSE_WR_TIM_CONF1_REG = DR_REG_EFUSE_BASE + 0x1F0
EFUSE_WR_TIM_CONF2_REG = DR_REG_EFUSE_BASE + 0x1F4
EFUSE_DATE_REG = DR_REG_EFUSE_BASE + 0x1FC
EFUSE_WRITE_OP_CODE = 0x5A5A
EFUSE_READ_OP_CODE = 0x5AA5
EFUSE_PGM_CMD_MASK = 0x3
EFUSE_PGM_CMD = 0x2
EFUSE_READ_CMD = 0x1
BLOCK_ERRORS = [
# error_reg, err_num_mask, err_num_offs, fail_bit
(EFUSE_RD_REPEAT_ERR0_REG, None, None, None), # BLOCK0
(EFUSE_RD_RS_ERR0_REG, 0x7, 0, 3), # MAC_SPI_8M_0
(EFUSE_RD_RS_ERR0_REG, 0x7, 4, 7), # BLOCK_SYS_DATA
(EFUSE_RD_RS_ERR0_REG, 0x7, 8, 11), # BLOCK_USR_DATA
(EFUSE_RD_RS_ERR0_REG, 0x7, 12, 15), # BLOCK_KEY0
(EFUSE_RD_RS_ERR0_REG, 0x7, 16, 19), # BLOCK_KEY1
(EFUSE_RD_RS_ERR0_REG, 0x7, 20, 23), # BLOCK_KEY2
(EFUSE_RD_RS_ERR0_REG, 0x7, 24, 27), # BLOCK_KEY3
(EFUSE_RD_RS_ERR0_REG, 0x7, 28, 31), # BLOCK_KEY4
(EFUSE_RD_RS_ERR1_REG, 0x7, 0, 3), # BLOCK_KEY5
(EFUSE_RD_RS_ERR1_REG, 0x7, 4, 7), # BLOCK_SYS_DATA2
]
# EFUSE_WR_TIM_CONF2_REG
EFUSE_PWR_OFF_NUM_S = 0
EFUSE_PWR_OFF_NUM_M = 0xFFFF << EFUSE_PWR_OFF_NUM_S
# EFUSE_WR_TIM_CONF1_REG
EFUSE_PWR_ON_NUM_S = 8
EFUSE_PWR_ON_NUM_M = 0x0000FFFF << EFUSE_PWR_ON_NUM_S
# EFUSE_DAC_CONF_REG
EFUSE_DAC_CLK_DIV_S = 0
EFUSE_DAC_CLK_DIV_M = 0xFF << EFUSE_DAC_CLK_DIV_S
# EFUSE_DAC_CONF_REG
EFUSE_DAC_NUM_S = 9
EFUSE_DAC_NUM_M = 0xFF << EFUSE_DAC_NUM_S
class EfuseDefineBlocks(EfuseBlocksBase):
__base_rd_regs = EfuseDefineRegisters.DR_REG_EFUSE_BASE
__base_wr_regs = EfuseDefineRegisters.EFUSE_PGM_DATA0_REG
# List of efuse blocks
# fmt: off
BLOCKS = [
# Name, Alias, Index, Read address, Write address, Write protect bit, Read protect bit, Len, key_purpose
("BLOCK0", [], 0, __base_rd_regs + 0x02C, __base_wr_regs, None, None, 6, None),
("MAC_SPI_8M_0", ["BLOCK1"], 1, __base_rd_regs + 0x044, __base_wr_regs, 20, None, 6, None),
("BLOCK_SYS_DATA", ["BLOCK2"], 2, __base_rd_regs + 0x05C, __base_wr_regs, 21, None, 8, None),
("BLOCK_USR_DATA", ["BLOCK3"], 3, __base_rd_regs + 0x07C, __base_wr_regs, 22, None, 8, None),
("BLOCK_KEY0", ["BLOCK4"], 4, __base_rd_regs + 0x09C, __base_wr_regs, 23, 0, 8, "KEY_PURPOSE_0"),
("BLOCK_KEY1", ["BLOCK5"], 5, __base_rd_regs + 0x0BC, __base_wr_regs, 24, 1, 8, "KEY_PURPOSE_1"),
("BLOCK_KEY2", ["BLOCK6"], 6, __base_rd_regs + 0x0DC, __base_wr_regs, 25, 2, 8, "KEY_PURPOSE_2"),
("BLOCK_KEY3", ["BLOCK7"], 7, __base_rd_regs + 0x0FC, __base_wr_regs, 26, 3, 8, "KEY_PURPOSE_3"),
("BLOCK_KEY4", ["BLOCK8"], 8, __base_rd_regs + 0x11C, __base_wr_regs, 27, 4, 8, "KEY_PURPOSE_4"),
("BLOCK_KEY5", ["BLOCK9"], 9, __base_rd_regs + 0x13C, __base_wr_regs, 28, 5, 8, "KEY_PURPOSE_5"),
("BLOCK_SYS_DATA2", ["BLOCK10"], 10, __base_rd_regs + 0x15C, __base_wr_regs, 29, 6, 8, None),
]
# fmt: on
def get_burn_block_data_names(self):
list_of_names = []
for block in self.BLOCKS:
blk = self.get(block)
if blk.name:
list_of_names.append(blk.name)
if blk.alias:
for alias in blk.alias:
list_of_names.append(alias)
return list_of_names
class EfuseDefineFields(EfuseFieldsBase):
def __init__(self) -> None:
# List of efuse fields from TRM the chapter eFuse Controller.
self.EFUSES = []
self.KEYBLOCKS = []
# if BLK_VERSION_MINOR is 1, these efuse fields are in BLOCK2
self.BLOCK2_CALIBRATION_EFUSES = []
self.CALC = []
dir_name = os.path.dirname(os.path.abspath(__file__))
dir_name, file_name = os.path.split(dir_name)
file_name = file_name + ".yaml"
dir_name, _ = os.path.split(dir_name)
efuse_file = os.path.join(dir_name, "efuse_defs", file_name)
with open(f"{efuse_file}", "r") as r_file:
e_desc = yaml.safe_load(r_file)
super().__init__(e_desc)
for i, efuse in enumerate(self.ALL_EFUSES):
if efuse.name in [
"BLOCK_USR_DATA",
"BLOCK_KEY0",
"BLOCK_KEY1",
"BLOCK_KEY2",
"BLOCK_KEY3",
"BLOCK_KEY4",
"BLOCK_KEY5",
"BLOCK_SYS_DATA2",
]:
if efuse.name == "BLOCK_USR_DATA":
efuse.bit_len = 256
efuse.type = "bytes:32"
self.KEYBLOCKS.append(efuse)
self.ALL_EFUSES[i] = None
elif efuse.category == "calibration":
self.BLOCK2_CALIBRATION_EFUSES.append(efuse)
self.ALL_EFUSES[i] = None
f = Field()
f.name = "MAC_EUI64"
f.block = 1
f.bit_len = 64
f.type = f"bytes:{f.bit_len // 8}"
f.category = "MAC"
f.class_type = "mac"
f.description = "calc MAC_EUI64 = MAC[0]:MAC[1]:MAC[2]:MAC_EXT[0]:MAC_EXT[1]:MAC[3]:MAC[4]:MAC[5]"
self.CALC.append(f)
for efuse in self.ALL_EFUSES:
if efuse is not None:
self.EFUSES.append(efuse)
self.ALL_EFUSES = []
| 6,679 | Python | .py | 144 | 37.986111 | 140 | 0.570968 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,657 | emulate_efuse_controller.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32h2beta1/emulate_efuse_controller.py | # This file describes eFuses controller for ESP32-H2 chip
#
# SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import reedsolo
from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters
from ..emulate_efuse_controller_base import EmulateEfuseControllerBase, FatalError
class EmulateEfuseController(EmulateEfuseControllerBase):
"""The class for virtual efuse operation. Using for HOST_TEST."""
CHIP_NAME = "ESP32-H2(beta1)"
mem = None
debug = False
def __init__(self, efuse_file=None, debug=False):
self.Blocks = EfuseDefineBlocks
self.Fields = EfuseDefineFields()
self.REGS = EfuseDefineRegisters
super(EmulateEfuseController, self).__init__(efuse_file, debug)
self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
""" esptool method start >>"""
def get_major_chip_version(self):
return 0
def get_minor_chip_version(self):
return 0
def get_crystal_freq(self):
return 32 # MHz (common for all chips)
def get_security_info(self):
return {
"flags": 0,
"flash_crypt_cnt": 0,
"key_purposes": 0,
"chip_id": 0,
"api_version": 0,
}
""" << esptool method end """
def handle_writing_event(self, addr, value):
if addr == self.REGS.EFUSE_CMD_REG:
if value & self.REGS.EFUSE_PGM_CMD:
self.copy_blocks_wr_regs_to_rd_regs(updated_block=(value >> 2) & 0xF)
self.clean_blocks_wr_regs()
self.check_rd_protection_area()
self.write_reg(addr, 0)
self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
elif value == self.REGS.EFUSE_READ_CMD:
self.write_reg(addr, 0)
self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
self.save_to_file()
def get_bitlen_of_block(self, blk, wr=False):
if blk.id == 0:
if wr:
return 32 * 8
else:
return 32 * blk.len
else:
if wr:
rs_coding = 32 * 3
return 32 * 8 + rs_coding
else:
return 32 * blk.len
def handle_coding_scheme(self, blk, data):
if blk.id != 0:
# CODING_SCHEME RS applied only for all blocks except BLK0.
coded_bytes = 12
data.pos = coded_bytes * 8
plain_data = data.readlist("32*uint:8")[::-1]
# takes 32 bytes
# apply RS encoding
rs = reedsolo.RSCodec(coded_bytes)
# 32 byte of data + 12 bytes RS
calc_encoded_data = list(rs.encode([x for x in plain_data]))
data.pos = 0
if calc_encoded_data != data.readlist("44*uint:8")[::-1]:
raise FatalError("Error in coding scheme data")
data = data[coded_bytes * 8 :]
if blk.len < 8:
data = data[(8 - blk.len) * 32 :]
return data
| 3,079 | Python | .py | 77 | 29.753247 | 86 | 0.576163 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,658 | __init__.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32h2beta1/__init__.py | from . import operations
from .emulate_efuse_controller import EmulateEfuseController
from .fields import EspEfuses
| 116 | Python | .py | 3 | 37.666667 | 60 | 0.876106 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,659 | operations.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32h2beta1/operations.py | # This file includes the operations with eFuses for ESP32-H2 chip
#
# SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import argparse
import os # noqa: F401. It is used in IDF scripts
import traceback
import espsecure
import esptool
from . import fields
from .. import util
from ..base_operations import (
add_common_commands,
add_force_write_always,
add_show_sensitive_info_option,
burn_bit,
burn_block_data,
burn_efuse,
check_error,
dump,
read_protect_efuse,
summary,
write_protect_efuse,
)
def protect_options(p):
p.add_argument(
"--no-write-protect",
help="Disable write-protecting of the key. The key remains writable. "
"(The keys use the RS coding scheme that does not support post-write "
"data changes. Forced write can damage RS encoding bits.) "
"The write-protecting of keypurposes does not depend on the option, "
"it will be set anyway.",
action="store_true",
)
p.add_argument(
"--no-read-protect",
help="Disable read-protecting of the key. The key remains readable software."
"The key with keypurpose[USER, RESERVED and *_DIGEST] will remain "
"readable anyway. For the rest keypurposes the read-protection will be "
"defined the option (Read-protect by default).",
action="store_true",
)
def add_commands(subparsers, efuses):
add_common_commands(subparsers, efuses)
burn_key = subparsers.add_parser(
"burn_key", help="Burn the key block with the specified name"
)
protect_options(burn_key)
add_force_write_always(burn_key)
add_show_sensitive_info_option(burn_key)
burn_key.add_argument(
"block",
help="Key block to burn",
action="append",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key.add_argument(
"keyfile",
help="File containing 256 bits of binary key data",
action="append",
type=argparse.FileType("rb"),
)
burn_key.add_argument(
"keypurpose",
help="Purpose to set.",
action="append",
choices=fields.EfuseKeyPurposeField.KEY_PURPOSES_NAME,
)
for _ in efuses.BLOCKS_FOR_KEYS:
burn_key.add_argument(
"block",
help="Key block to burn",
nargs="?",
action="append",
metavar="BLOCK",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key.add_argument(
"keyfile",
help="File containing 256 bits of binary key data",
nargs="?",
action="append",
metavar="KEYFILE",
type=argparse.FileType("rb"),
)
burn_key.add_argument(
"keypurpose",
help="Purpose to set.",
nargs="?",
action="append",
metavar="KEYPURPOSE",
choices=fields.EfuseKeyPurposeField.KEY_PURPOSES_NAME,
)
burn_key_digest = subparsers.add_parser(
"burn_key_digest",
help="Parse a RSA public key and burn the digest to key efuse block",
)
protect_options(burn_key_digest)
add_force_write_always(burn_key_digest)
add_show_sensitive_info_option(burn_key_digest)
burn_key_digest.add_argument(
"block",
help="Key block to burn",
action="append",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key_digest.add_argument(
"keyfile",
help="Key file to digest (PEM format)",
action="append",
type=argparse.FileType("rb"),
)
burn_key_digest.add_argument(
"keypurpose",
help="Purpose to set.",
action="append",
choices=fields.EfuseKeyPurposeField.DIGEST_KEY_PURPOSES,
)
for _ in efuses.BLOCKS_FOR_KEYS:
burn_key_digest.add_argument(
"block",
help="Key block to burn",
nargs="?",
action="append",
metavar="BLOCK",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key_digest.add_argument(
"keyfile",
help="Key file to digest (PEM format)",
nargs="?",
action="append",
metavar="KEYFILE",
type=argparse.FileType("rb"),
)
burn_key_digest.add_argument(
"keypurpose",
help="Purpose to set.",
nargs="?",
action="append",
metavar="KEYPURPOSE",
choices=fields.EfuseKeyPurposeField.DIGEST_KEY_PURPOSES,
)
p = subparsers.add_parser(
"set_flash_voltage",
help="Permanently set the internal flash voltage regulator "
"to either 1.8V, 3.3V or OFF. This means GPIO45 can be high or low "
"at reset without changing the flash voltage.",
)
p.add_argument("voltage", help="Voltage selection", choices=["1.8V", "3.3V", "OFF"])
p = subparsers.add_parser(
"burn_custom_mac", help="Burn a 48-bit Custom MAC Address to EFUSE BLOCK3."
)
p.add_argument(
"mac",
help="Custom MAC Address to burn given in hexadecimal format with bytes "
"separated by colons (e.g. AA:CD:EF:01:02:03).",
type=fields.base_fields.CheckArgValue(efuses, "CUSTOM_MAC"),
)
add_force_write_always(p)
p = subparsers.add_parser("get_custom_mac", help="Prints the Custom MAC Address.")
def burn_custom_mac(esp, efuses, args):
efuses["CUSTOM_MAC"].save(args.mac)
if not efuses.burn_all(check_batch_mode=True):
return
get_custom_mac(esp, efuses, args)
print("Successful")
def get_custom_mac(esp, efuses, args):
print("Custom MAC Address: {}".format(efuses["CUSTOM_MAC"].get()))
def set_flash_voltage(esp, efuses, args):
raise esptool.FatalError("set_flash_voltage is not supported!")
def adc_info(esp, efuses, args):
print("")
# fmt: off
if efuses["BLK_VERSION_MAJOR"].get() == 1:
print("Temperature Sensor Calibration = {}C".format(efuses["TEMP_SENSOR_CAL"].get()))
print("")
print("ADC1 readings stored in efuse BLOCK2:")
print(" MODE0 D1 reading (250mV): {}".format(efuses["ADC1_MODE0_D1"].get()))
print(" MODE0 D2 reading (600mV): {}".format(efuses["ADC1_MODE0_D2"].get()))
print(" MODE1 D1 reading (250mV): {}".format(efuses["ADC1_MODE1_D1"].get()))
print(" MODE1 D2 reading (800mV): {}".format(efuses["ADC1_MODE1_D2"].get()))
print(" MODE2 D1 reading (250mV): {}".format(efuses["ADC1_MODE2_D1"].get()))
print(" MODE2 D2 reading (1000mV): {}".format(efuses["ADC1_MODE2_D2"].get()))
print(" MODE3 D1 reading (250mV): {}".format(efuses["ADC1_MODE3_D1"].get()))
print(" MODE3 D2 reading (2000mV): {}".format(efuses["ADC1_MODE3_D2"].get()))
print("")
print("ADC2 readings stored in efuse BLOCK2:")
print(" MODE0 D1 reading (250mV): {}".format(efuses["ADC2_MODE0_D1"].get()))
print(" MODE0 D2 reading (600mV): {}".format(efuses["ADC2_MODE0_D2"].get()))
print(" MODE1 D1 reading (250mV): {}".format(efuses["ADC2_MODE1_D1"].get()))
print(" MODE1 D2 reading (800mV): {}".format(efuses["ADC2_MODE1_D2"].get()))
print(" MODE2 D1 reading (250mV): {}".format(efuses["ADC2_MODE2_D1"].get()))
print(" MODE2 D2 reading (1000mV): {}".format(efuses["ADC2_MODE2_D2"].get()))
print(" MODE3 D1 reading (250mV): {}".format(efuses["ADC2_MODE3_D1"].get()))
print(" MODE3 D2 reading (2000mV): {}".format(efuses["ADC2_MODE3_D2"].get()))
else:
print("BLK_VERSION_MAJOR = {}".format(efuses["BLK_VERSION_MAJOR"].get_meaning()))
# fmt: on
def burn_key(esp, efuses, args, digest=None):
if digest is None:
datafile_list = args.keyfile[
0 : len([name for name in args.keyfile if name is not None]) :
]
else:
datafile_list = digest[0 : len([name for name in digest if name is not None]) :]
efuses.force_write_always = args.force_write_always
block_name_list = args.block[
0 : len([name for name in args.block if name is not None]) :
]
keypurpose_list = args.keypurpose[
0 : len([name for name in args.keypurpose if name is not None]) :
]
util.check_duplicate_name_in_list(block_name_list)
if len(block_name_list) != len(datafile_list) or len(block_name_list) != len(
keypurpose_list
):
raise esptool.FatalError(
"The number of blocks (%d), datafile (%d) and keypurpose (%d) "
"should be the same."
% (len(block_name_list), len(datafile_list), len(keypurpose_list))
)
print("Burn keys to blocks:")
for block_name, datafile, keypurpose in zip(
block_name_list, datafile_list, keypurpose_list
):
efuse = None
for block in efuses.blocks:
if block_name == block.name or block_name in block.alias:
efuse = efuses[block.name]
if efuse is None:
raise esptool.FatalError("Unknown block name - %s" % (block_name))
num_bytes = efuse.bit_len // 8
block_num = efuses.get_index_block_by_name(block_name)
block = efuses.blocks[block_num]
if digest is None:
data = datafile.read()
else:
data = datafile
print(" - %s" % (efuse.name), end=" ")
revers_msg = None
if efuses[block.key_purpose_name].need_reverse(keypurpose):
revers_msg = "\tReversing byte order for AES-XTS hardware peripheral"
data = data[::-1]
print(
"-> [{}]".format(
util.hexify(data, " ")
if args.show_sensitive_info
else " ".join(["??"] * len(data))
)
)
if revers_msg:
print(revers_msg)
if len(data) != num_bytes:
raise esptool.FatalError(
"Incorrect key file size %d. Key file must be %d bytes (%d bits) "
"of raw binary key data." % (len(data), num_bytes, num_bytes * 8)
)
if efuses[block.key_purpose_name].need_rd_protect(keypurpose):
read_protect = False if args.no_read_protect else True
else:
read_protect = False
write_protect = not args.no_write_protect
# using efuse instead of a block gives the advantage of checking it as the whole field.
efuse.save(data)
disable_wr_protect_key_purpose = False
if efuses[block.key_purpose_name].get() != keypurpose:
if efuses[block.key_purpose_name].is_writeable():
print(
"\t'%s': '%s' -> '%s'."
% (
block.key_purpose_name,
efuses[block.key_purpose_name].get(),
keypurpose,
)
)
efuses[block.key_purpose_name].save(keypurpose)
disable_wr_protect_key_purpose = True
else:
raise esptool.FatalError(
"It is not possible to change '%s' to '%s' because write "
"protection bit is set." % (block.key_purpose_name, keypurpose)
)
else:
print("\t'%s' is already '%s'." % (block.key_purpose_name, keypurpose))
if efuses[block.key_purpose_name].is_writeable():
disable_wr_protect_key_purpose = True
if disable_wr_protect_key_purpose:
print("\tDisabling write to '%s'." % block.key_purpose_name)
efuses[block.key_purpose_name].disable_write()
if read_protect:
print("\tDisabling read to key block")
efuse.disable_read()
if write_protect:
print("\tDisabling write to key block")
efuse.disable_write()
print("")
if not write_protect:
print("Keys will remain writeable (due to --no-write-protect)")
if args.no_read_protect:
print("Keys will remain readable (due to --no-read-protect)")
if not efuses.burn_all(check_batch_mode=True):
return
print("Successful")
def burn_key_digest(esp, efuses, args):
digest_list = []
datafile_list = args.keyfile[
0 : len([name for name in args.keyfile if name is not None]) :
]
block_list = args.block[
0 : len([block for block in args.block if block is not None]) :
]
for block_name, datafile in zip(block_list, datafile_list):
efuse = None
for block in efuses.blocks:
if block_name == block.name or block_name in block.alias:
efuse = efuses[block.name]
if efuse is None:
raise esptool.FatalError("Unknown block name - %s" % (block_name))
num_bytes = efuse.bit_len // 8
digest = espsecure._digest_sbv2_public_key(datafile)
if len(digest) != num_bytes:
raise esptool.FatalError(
"Incorrect digest size %d. Digest must be %d bytes (%d bits) of raw "
"binary key data." % (len(digest), num_bytes, num_bytes * 8)
)
digest_list.append(digest)
burn_key(esp, efuses, args, digest=digest_list)
def espefuse(esp, efuses, args, command):
parser = argparse.ArgumentParser()
subparsers = parser.add_subparsers(dest="operation")
add_commands(subparsers, efuses)
try:
cmd_line_args = parser.parse_args(command.split())
except SystemExit:
traceback.print_stack()
raise esptool.FatalError('"{}" - incorrect command'.format(command))
if cmd_line_args.operation == "execute_scripts":
configfiles = cmd_line_args.configfiles
index = cmd_line_args.index
# copy arguments from args to cmd_line_args
vars(cmd_line_args).update(vars(args))
if cmd_line_args.operation == "execute_scripts":
cmd_line_args.configfiles = configfiles
cmd_line_args.index = index
if cmd_line_args.operation is None:
parser.print_help()
parser.exit(1)
operation_func = globals()[cmd_line_args.operation]
# each 'operation' is a module-level function of the same name
operation_func(esp, efuses, cmd_line_args)
def execute_scripts(esp, efuses, args):
efuses.batch_mode_cnt += 1
del args.operation
scripts = args.scripts
del args.scripts
for file in scripts:
with open(file.name, "r") as file:
exec(compile(file.read(), file.name, "exec"))
if args.debug:
for block in efuses.blocks:
data = block.get_bitstring(from_read=False)
block.print_block(data, "regs_for_burn", args.debug)
efuses.batch_mode_cnt -= 1
if not efuses.burn_all(check_batch_mode=True):
return
print("Successful")
| 14,929 | Python | .py | 368 | 31.69837 | 95 | 0.597698 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,660 | fields.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32h2beta1/fields.py | # This file describes eFuses for ESP32-H2 chip
#
# SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import binascii
import struct
import time
from bitstring import BitArray
import esptool
import reedsolo
from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters
from .. import base_fields
from .. import util
class EfuseBlock(base_fields.EfuseBlockBase):
def len_of_burn_unit(self):
# The writing register window is 8 registers for any blocks.
# len in bytes
return 8 * 4
def __init__(self, parent, param, skip_read=False):
parent.read_coding_scheme()
super(EfuseBlock, self).__init__(parent, param, skip_read=skip_read)
def apply_coding_scheme(self):
data = self.get_raw(from_read=False)[::-1]
if len(data) < self.len_of_burn_unit():
add_empty_bytes = self.len_of_burn_unit() - len(data)
data = data + (b"\x00" * add_empty_bytes)
if self.get_coding_scheme() == self.parent.REGS.CODING_SCHEME_RS:
# takes 32 bytes
# apply RS encoding
rs = reedsolo.RSCodec(12)
# 32 byte of data + 12 bytes RS
encoded_data = rs.encode([x for x in data])
words = struct.unpack("<" + "I" * 11, encoded_data)
# returns 11 words (8 words of data + 3 words of RS coding)
else:
# takes 32 bytes
words = struct.unpack("<" + ("I" * (len(data) // 4)), data)
# returns 8 words
return words
class EspEfuses(base_fields.EspEfusesBase):
"""
Wrapper object to manage the efuse fields in a connected ESP bootloader
"""
debug = False
do_not_confirm = False
def __init__(self, esp, skip_connect=False, debug=False, do_not_confirm=False):
self.Blocks = EfuseDefineBlocks()
self.Fields = EfuseDefineFields()
self.REGS = EfuseDefineRegisters
self.BURN_BLOCK_DATA_NAMES = self.Blocks.get_burn_block_data_names()
self.BLOCKS_FOR_KEYS = self.Blocks.get_blocks_for_keys()
self._esp = esp
self.debug = debug
self.do_not_confirm = do_not_confirm
if esp.CHIP_NAME != "ESP32-H2(beta1)":
raise esptool.FatalError(
"Expected the 'esp' param for ESP32-H2(beta1) chip but got for '%s'."
% (esp.CHIP_NAME)
)
if not skip_connect:
flags = self._esp.get_security_info()["flags"]
GET_SECURITY_INFO_FLAG_SECURE_DOWNLOAD_ENABLE = 1 << 2
if flags & GET_SECURITY_INFO_FLAG_SECURE_DOWNLOAD_ENABLE:
raise esptool.FatalError(
"Secure Download Mode is enabled. The tool can not read eFuses."
)
self.blocks = [
EfuseBlock(self, self.Blocks.get(block), skip_read=skip_connect)
for block in self.Blocks.BLOCKS
]
if not skip_connect:
self.get_coding_scheme_warnings()
self.efuses = [EfuseField.convert(self, efuse) for efuse in self.Fields.EFUSES]
self.efuses += [
EfuseField.convert(self, efuse) for efuse in self.Fields.KEYBLOCKS
]
if skip_connect:
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
]
else:
if self["BLK_VERSION_MAJOR"].get() == 1:
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
]
self.efuses += [
EfuseField.convert(self, efuse) for efuse in self.Fields.CALC
]
def __getitem__(self, efuse_name):
"""Return the efuse field with the given name"""
for e in self.efuses:
if efuse_name == e.name or any(x == efuse_name for x in e.alt_names):
return e
new_fields = False
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES:
if efuse.name == efuse_name or any(
x == efuse_name for x in efuse.alt_names
):
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
]
new_fields = True
if new_fields:
for e in self.efuses:
if efuse_name == e.name or any(x == efuse_name for x in e.alt_names):
return e
raise KeyError
def read_coding_scheme(self):
self.coding_scheme = self.REGS.CODING_SCHEME_RS
def print_status_regs(self):
print("")
self.blocks[0].print_block(self.blocks[0].err_bitarray, "err__regs", debug=True)
print(
"{:27} 0x{:08x}".format(
"EFUSE_RD_RS_ERR0_REG", self.read_reg(self.REGS.EFUSE_RD_RS_ERR0_REG)
)
)
print(
"{:27} 0x{:08x}".format(
"EFUSE_RD_RS_ERR1_REG", self.read_reg(self.REGS.EFUSE_RD_RS_ERR1_REG)
)
)
def efuse_controller_setup(self):
self.set_efuse_timing()
self.clear_pgm_registers()
self.wait_efuse_idle()
def write_efuses(self, block):
self.efuse_program(block)
return self.get_coding_scheme_warnings(silent=True)
def clear_pgm_registers(self):
self.wait_efuse_idle()
for r in range(
self.REGS.EFUSE_PGM_DATA0_REG, self.REGS.EFUSE_PGM_DATA0_REG + 32, 4
):
self.write_reg(r, 0)
def wait_efuse_idle(self):
deadline = time.time() + self.REGS.EFUSE_BURN_TIMEOUT
while time.time() < deadline:
# if self.read_reg(self.REGS.EFUSE_CMD_REG) == 0:
if self.read_reg(self.REGS.EFUSE_STATUS_REG) & 0x7 == 1:
return
raise esptool.FatalError(
"Timed out waiting for Efuse controller command to complete"
)
def efuse_program(self, block):
self.wait_efuse_idle()
self.write_reg(self.REGS.EFUSE_CONF_REG, self.REGS.EFUSE_WRITE_OP_CODE)
self.write_reg(self.REGS.EFUSE_CMD_REG, self.REGS.EFUSE_PGM_CMD | (block << 2))
self.wait_efuse_idle()
self.clear_pgm_registers()
self.efuse_read()
def efuse_read(self):
self.wait_efuse_idle()
self.write_reg(self.REGS.EFUSE_CONF_REG, self.REGS.EFUSE_READ_OP_CODE)
# need to add a delay after triggering EFUSE_READ_CMD, as ROM loader checks some
# efuse registers after each command is completed
# if ENABLE_SECURITY_DOWNLOAD or DIS_DOWNLOAD_MODE is enabled by the current cmd, then we need to try to reconnect to the chip.
try:
self.write_reg(
self.REGS.EFUSE_CMD_REG, self.REGS.EFUSE_READ_CMD, delay_after_us=1000
)
self.wait_efuse_idle()
except esptool.FatalError:
secure_download_mode_before = self._esp.secure_download_mode
try:
self._esp = self.reconnect_chip(self._esp)
except esptool.FatalError:
print("Can not re-connect to the chip")
if not self["DIS_DOWNLOAD_MODE"].get() and self[
"DIS_DOWNLOAD_MODE"
].get(from_read=False):
print(
"This is the correct behavior as we are actually burning "
"DIS_DOWNLOAD_MODE which disables the connection to the chip"
)
print("DIS_DOWNLOAD_MODE is enabled")
print("Successful")
exit(0) # finish without errors
raise
print("Established a connection with the chip")
if self._esp.secure_download_mode and not secure_download_mode_before:
print("Secure download mode is enabled")
if not self["ENABLE_SECURITY_DOWNLOAD"].get() and self[
"ENABLE_SECURITY_DOWNLOAD"
].get(from_read=False):
print(
"espefuse tool can not continue to work in Secure download mode"
)
print("ENABLE_SECURITY_DOWNLOAD is enabled")
print("Successful")
exit(0) # finish without errors
raise
def set_efuse_timing(self):
"""Set timing registers for burning efuses"""
# Configure clock
apb_freq = self.get_crystal_freq()
if apb_freq != 32:
raise esptool.FatalError(
"The eFuse supports only xtal=32M (xtal was %d)" % apb_freq
)
self.update_reg(self.REGS.EFUSE_DAC_CONF_REG, self.REGS.EFUSE_DAC_NUM_M, 0xFF)
self.update_reg(
self.REGS.EFUSE_DAC_CONF_REG, self.REGS.EFUSE_DAC_CLK_DIV_M, 0x28
)
self.update_reg(
self.REGS.EFUSE_WR_TIM_CONF1_REG, self.REGS.EFUSE_PWR_ON_NUM_M, 0x3000
)
self.update_reg(
self.REGS.EFUSE_WR_TIM_CONF2_REG, self.REGS.EFUSE_PWR_OFF_NUM_M, 0x190
)
def get_coding_scheme_warnings(self, silent=False):
"""Check if the coding scheme has detected any errors."""
old_addr_reg = 0
reg_value = 0
ret_fail = False
for block in self.blocks:
if block.id == 0:
words = [
self.read_reg(self.REGS.EFUSE_RD_REPEAT_ERR0_REG + offs * 4)
for offs in range(5)
]
block.err_bitarray.pos = 0
for word in reversed(words):
block.err_bitarray.overwrite(BitArray("uint:32=%d" % word))
block.num_errors = block.err_bitarray.count(True)
block.fail = block.num_errors != 0
else:
addr_reg, err_num_mask, err_num_offs, fail_bit = self.REGS.BLOCK_ERRORS[
block.id
]
if err_num_mask is None or err_num_offs is None or fail_bit is None:
continue
if addr_reg != old_addr_reg:
old_addr_reg = addr_reg
reg_value = self.read_reg(addr_reg)
block.fail = reg_value & (1 << fail_bit) != 0
block.num_errors = (reg_value >> err_num_offs) & err_num_mask
ret_fail |= block.fail
if not silent and (block.fail or block.num_errors):
print(
"Error(s) in BLOCK%d [ERRORS:%d FAIL:%d]"
% (block.id, block.num_errors, block.fail)
)
if (self.debug or ret_fail) and not silent:
self.print_status_regs()
return ret_fail
def summary(self):
# TODO add support set_flash_voltage - "Flash voltage (VDD_SPI)"
return ""
class EfuseField(base_fields.EfuseFieldBase):
@staticmethod
def convert(parent, efuse):
return {
"mac": EfuseMacField,
"keypurpose": EfuseKeyPurposeField,
"t_sensor": EfuseTempSensor,
"adc_tp": EfuseAdcPointCalibration,
"wafer": EfuseWafer,
}.get(efuse.class_type, EfuseField)(parent, efuse)
class EfuseWafer(EfuseField):
def get(self, from_read=True):
hi_bits = self.parent["WAFER_VERSION_MINOR_HI"].get(from_read)
assert self.parent["WAFER_VERSION_MINOR_HI"].bit_len == 1
lo_bits = self.parent["WAFER_VERSION_MINOR_LO"].get(from_read)
assert self.parent["WAFER_VERSION_MINOR_LO"].bit_len == 3
return (hi_bits << 3) + lo_bits
def save(self, new_value):
raise esptool.FatalError("Burning %s is not supported" % self.name)
class EfuseTempSensor(EfuseField):
def get(self, from_read=True):
value = self.get_bitstring(from_read)
sig = -1 if value[0] else 1
return sig * value[1:].uint * 0.1
class EfuseAdcPointCalibration(EfuseField):
def get(self, from_read=True):
STEP_SIZE = 4
value = self.get_bitstring(from_read)
sig = -1 if value[0] else 1
return sig * value[1:].uint * STEP_SIZE
class EfuseMacField(EfuseField):
def check_format(self, new_value_str):
if new_value_str is None:
raise esptool.FatalError(
"Required MAC Address in AA:CD:EF:01:02:03 format!"
)
num_bytes = 8 if self.name == "MAC_EUI64" else 6
if new_value_str.count(":") != num_bytes - 1:
raise esptool.FatalError(
f"MAC Address needs to be a {num_bytes}-byte hexadecimal format "
"separated by colons (:)!"
)
hexad = new_value_str.replace(":", "").split(" ", 1)[0]
hexad = hexad.split(" ", 1)[0] if self.is_field_calculated() else hexad
if len(hexad) != num_bytes * 2:
raise esptool.FatalError(
f"MAC Address needs to be a {num_bytes}-byte hexadecimal number "
f"({num_bytes * 2} hexadecimal characters)!"
)
# order of bytearray = b'\xaa\xcd\xef\x01\x02\x03',
bindata = binascii.unhexlify(hexad)
if not self.is_field_calculated():
# unicast address check according to
# https://tools.ietf.org/html/rfc7042#section-2.1
if esptool.util.byte(bindata, 0) & 0x01:
raise esptool.FatalError("Custom MAC must be a unicast MAC!")
return bindata
def check(self):
errs, fail = self.parent.get_block_errors(self.block)
if errs != 0 or fail:
output = "Block%d has ERRORS:%d FAIL:%d" % (self.block, errs, fail)
else:
output = "OK"
return "(" + output + ")"
def get(self, from_read=True):
if self.name == "CUSTOM_MAC":
mac = self.get_raw(from_read)[::-1]
elif self.name == "MAC":
mac = self.get_raw(from_read)
elif self.name == "MAC_EUI64":
mac = self.parent["MAC"].get_bitstring(from_read).copy()
mac_ext = self.parent["MAC_EXT"].get_bitstring(from_read)
mac.insert(mac_ext, 24)
mac = mac.bytes
else:
mac = self.get_raw(from_read)
return "%s %s" % (util.hexify(mac, ":"), self.check())
def save(self, new_value):
def print_field(e, new_value):
print(
" - '{}' ({}) {} -> {}".format(
e.name, e.description, e.get_bitstring(), new_value
)
)
if self.name == "CUSTOM_MAC":
bitarray_mac = self.convert_to_bitstring(new_value)
print_field(self, bitarray_mac)
super(EfuseMacField, self).save(new_value)
else:
# Writing the BLOCK1 (MAC_SPI_8M_0) default MAC is not possible,
# as it's written in the factory.
raise esptool.FatalError(f"Burning {self.name} is not supported")
raise esptool.FatalError("Writing Factory MAC address is not supported")
# fmt: off
class EfuseKeyPurposeField(EfuseField):
KEY_PURPOSES = [
("USER", 0, None, None, "no_need_rd_protect"), # User purposes (software-only use)
("RESERVED", 1, None, None, "no_need_rd_protect"), # Reserved
("XTS_AES_128_KEY", 4, None, "Reverse", "need_rd_protect"), # XTS_AES_128_KEY (flash/PSRAM encryption)
("HMAC_DOWN_ALL", 5, None, None, "need_rd_protect"), # HMAC Downstream mode
("HMAC_DOWN_JTAG", 6, None, None, "need_rd_protect"), # JTAG soft enable key (uses HMAC Downstream mode)
("HMAC_DOWN_DIGITAL_SIGNATURE", 7, None, None, "need_rd_protect"), # Digital Signature peripheral key (uses HMAC Downstream mode)
("HMAC_UP", 8, None, None, "need_rd_protect"), # HMAC Upstream mode
("SECURE_BOOT_DIGEST0", 9, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST0 (Secure Boot key digest)
("SECURE_BOOT_DIGEST1", 10, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST1 (Secure Boot key digest)
("SECURE_BOOT_DIGEST2", 11, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST2 (Secure Boot key digest)
]
# fmt: on
KEY_PURPOSES_NAME = [name[0] for name in KEY_PURPOSES]
DIGEST_KEY_PURPOSES = [name[0] for name in KEY_PURPOSES if name[2] == "DIGEST"]
def check_format(self, new_value_str):
# str convert to int: "XTS_AES_128_KEY" - > str(4)
# if int: 4 -> str(4)
raw_val = new_value_str
for purpose_name in self.KEY_PURPOSES:
if purpose_name[0] == new_value_str:
raw_val = str(purpose_name[1])
break
if raw_val.isdigit():
if int(raw_val) not in [p[1] for p in self.KEY_PURPOSES if p[1] > 0]:
raise esptool.FatalError("'%s' can not be set (value out of range)" % raw_val)
else:
raise esptool.FatalError("'%s' unknown name" % raw_val)
return raw_val
def need_reverse(self, new_key_purpose):
for key in self.KEY_PURPOSES:
if key[0] == new_key_purpose:
return key[3] == "Reverse"
def need_rd_protect(self, new_key_purpose):
for key in self.KEY_PURPOSES:
if key[0] == new_key_purpose:
return key[4] == "need_rd_protect"
def get(self, from_read=True):
for p in self.KEY_PURPOSES:
if p[1] == self.get_raw(from_read):
return p[0]
return "FORBIDDEN_STATE"
def get_name(self, raw_val):
for key in self.KEY_PURPOSES:
if key[1] == raw_val:
return key[0]
def save(self, new_value):
raw_val = int(self.check_format(str(new_value)))
str_new_value = self.get_name(raw_val)
if self.name == "KEY_PURPOSE_5" and str_new_value.startswith("XTS_AES"):
raise esptool.FatalError(f"{self.name} can not have {str_new_value} key due to a hardware bug (please see TRM for more details)")
return super(EfuseKeyPurposeField, self).save(raw_val)
| 18,470 | Python | .py | 400 | 34.8525 | 155 | 0.565854 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,661 | mem_definition.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32h2beta1/mem_definition.py | # This file describes eFuses fields and registers for ESP32-H2 chip
#
# SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import os
import yaml
from ..mem_definition_base import EfuseBlocksBase, EfuseFieldsBase, EfuseRegistersBase
class EfuseDefineRegisters(EfuseRegistersBase):
EFUSE_MEM_SIZE = 0x01FC + 4
# EFUSE registers & command/conf values
DR_REG_EFUSE_BASE = 0x6001A000
EFUSE_PGM_DATA0_REG = DR_REG_EFUSE_BASE
EFUSE_CHECK_VALUE0_REG = DR_REG_EFUSE_BASE + 0x020
EFUSE_CLK_REG = DR_REG_EFUSE_BASE + 0x1C8
EFUSE_CONF_REG = DR_REG_EFUSE_BASE + 0x1CC
EFUSE_STATUS_REG = DR_REG_EFUSE_BASE + 0x1D0
EFUSE_CMD_REG = DR_REG_EFUSE_BASE + 0x1D4
EFUSE_RD_RS_ERR0_REG = DR_REG_EFUSE_BASE + 0x1C0
EFUSE_RD_RS_ERR1_REG = DR_REG_EFUSE_BASE + 0x1C4
EFUSE_RD_REPEAT_ERR0_REG = DR_REG_EFUSE_BASE + 0x17C
EFUSE_RD_REPEAT_ERR1_REG = DR_REG_EFUSE_BASE + 0x180
EFUSE_RD_REPEAT_ERR2_REG = DR_REG_EFUSE_BASE + 0x184
EFUSE_RD_REPEAT_ERR3_REG = DR_REG_EFUSE_BASE + 0x188
EFUSE_RD_REPEAT_ERR4_REG = DR_REG_EFUSE_BASE + 0x18C
EFUSE_DAC_CONF_REG = DR_REG_EFUSE_BASE + 0x1E8
EFUSE_RD_TIM_CONF_REG = DR_REG_EFUSE_BASE + 0x1EC
EFUSE_WR_TIM_CONF1_REG = DR_REG_EFUSE_BASE + 0x1F0
EFUSE_WR_TIM_CONF2_REG = DR_REG_EFUSE_BASE + 0x1F4
EFUSE_DATE_REG = DR_REG_EFUSE_BASE + 0x1FC
EFUSE_WRITE_OP_CODE = 0x5A5A
EFUSE_READ_OP_CODE = 0x5AA5
EFUSE_PGM_CMD_MASK = 0x3
EFUSE_PGM_CMD = 0x2
EFUSE_READ_CMD = 0x1
BLOCK_ERRORS = [
# error_reg, err_num_mask, err_num_offs, fail_bit
(EFUSE_RD_REPEAT_ERR0_REG, None, None, None), # BLOCK0
(EFUSE_RD_RS_ERR0_REG, 0x7, 0, 3), # MAC_SPI_8M_0
(EFUSE_RD_RS_ERR0_REG, 0x7, 4, 7), # BLOCK_SYS_DATA
(EFUSE_RD_RS_ERR0_REG, 0x7, 8, 11), # BLOCK_USR_DATA
(EFUSE_RD_RS_ERR0_REG, 0x7, 12, 15), # BLOCK_KEY0
(EFUSE_RD_RS_ERR0_REG, 0x7, 16, 19), # BLOCK_KEY1
(EFUSE_RD_RS_ERR0_REG, 0x7, 20, 23), # BLOCK_KEY2
(EFUSE_RD_RS_ERR0_REG, 0x7, 24, 27), # BLOCK_KEY3
(EFUSE_RD_RS_ERR0_REG, 0x7, 28, 31), # BLOCK_KEY4
(EFUSE_RD_RS_ERR1_REG, 0x7, 0, 3), # BLOCK_KEY5
(EFUSE_RD_RS_ERR1_REG, 0x7, 4, 7), # BLOCK_SYS_DATA2
]
# EFUSE_WR_TIM_CONF2_REG
EFUSE_PWR_OFF_NUM_S = 0
EFUSE_PWR_OFF_NUM_M = 0xFFFF << EFUSE_PWR_OFF_NUM_S
# EFUSE_WR_TIM_CONF1_REG
EFUSE_PWR_ON_NUM_S = 8
EFUSE_PWR_ON_NUM_M = 0x0000FFFF << EFUSE_PWR_ON_NUM_S
# EFUSE_DAC_CONF_REG
EFUSE_DAC_CLK_DIV_S = 0
EFUSE_DAC_CLK_DIV_M = 0xFF << EFUSE_DAC_CLK_DIV_S
# EFUSE_DAC_CONF_REG
EFUSE_DAC_NUM_S = 9
EFUSE_DAC_NUM_M = 0xFF << EFUSE_DAC_NUM_S
class EfuseDefineBlocks(EfuseBlocksBase):
__base_rd_regs = EfuseDefineRegisters.DR_REG_EFUSE_BASE
__base_wr_regs = EfuseDefineRegisters.EFUSE_PGM_DATA0_REG
# List of efuse blocks
# fmt: off
BLOCKS = [
# Name, Alias, Index, Read address, Write address, Write protect bit, Read protect bit, Len, key_purpose
("BLOCK0", [], 0, __base_rd_regs + 0x02C, __base_wr_regs, None, None, 6, None),
("MAC_SPI_8M_0", ["BLOCK1"], 1, __base_rd_regs + 0x044, __base_wr_regs, 20, None, 6, None),
("BLOCK_SYS_DATA", ["BLOCK2"], 2, __base_rd_regs + 0x05C, __base_wr_regs, 21, None, 8, None),
("BLOCK_USR_DATA", ["BLOCK3"], 3, __base_rd_regs + 0x07C, __base_wr_regs, 22, None, 8, None),
("BLOCK_KEY0", ["BLOCK4"], 4, __base_rd_regs + 0x09C, __base_wr_regs, 23, 0, 8, "KEY_PURPOSE_0"),
("BLOCK_KEY1", ["BLOCK5"], 5, __base_rd_regs + 0x0BC, __base_wr_regs, 24, 1, 8, "KEY_PURPOSE_1"),
("BLOCK_KEY2", ["BLOCK6"], 6, __base_rd_regs + 0x0DC, __base_wr_regs, 25, 2, 8, "KEY_PURPOSE_2"),
("BLOCK_KEY3", ["BLOCK7"], 7, __base_rd_regs + 0x0FC, __base_wr_regs, 26, 3, 8, "KEY_PURPOSE_3"),
("BLOCK_KEY4", ["BLOCK8"], 8, __base_rd_regs + 0x11C, __base_wr_regs, 27, 4, 8, "KEY_PURPOSE_4"),
("BLOCK_KEY5", ["BLOCK9"], 9, __base_rd_regs + 0x13C, __base_wr_regs, 28, 5, 8, "KEY_PURPOSE_5"),
("BLOCK_SYS_DATA2", ["BLOCK10"], 10, __base_rd_regs + 0x15C, __base_wr_regs, 29, 6, 8, None),
]
# fmt: on
def get_burn_block_data_names(self):
list_of_names = []
for block in self.BLOCKS:
blk = self.get(block)
if blk.name:
list_of_names.append(blk.name)
if blk.alias:
for alias in blk.alias:
list_of_names.append(alias)
return list_of_names
class EfuseDefineFields(EfuseFieldsBase):
def __init__(self) -> None:
# List of efuse fields from TRM the chapter eFuse Controller.
self.EFUSES = []
self.KEYBLOCKS = []
# if BLK_VERSION_MAJOR is 1, these efuse fields are in BLOCK2
self.BLOCK2_CALIBRATION_EFUSES = []
self.CALC = []
dir_name = os.path.dirname(os.path.abspath(__file__))
dir_name, file_name = os.path.split(dir_name)
file_name = file_name + ".yaml"
dir_name, _ = os.path.split(dir_name)
efuse_file = os.path.join(dir_name, "efuse_defs", file_name)
efuse_file = efuse_file.replace("esp32h2beta1", "esp32h2")
with open(f"{efuse_file}", "r") as r_file:
e_desc = yaml.safe_load(r_file)
super().__init__(e_desc)
for i, efuse in enumerate(self.ALL_EFUSES):
if efuse.name in [
"BLOCK_USR_DATA",
"BLOCK_KEY0",
"BLOCK_KEY1",
"BLOCK_KEY2",
"BLOCK_KEY3",
"BLOCK_KEY4",
"BLOCK_KEY5",
"BLOCK_SYS_DATA2",
]:
if efuse.name == "BLOCK_USR_DATA":
efuse.bit_len = 256
efuse.type = "bytes:32"
self.KEYBLOCKS.append(efuse)
self.ALL_EFUSES[i] = None
elif efuse.category == "calibration":
self.BLOCK2_CALIBRATION_EFUSES.append(efuse)
self.ALL_EFUSES[i] = None
for efuse in self.ALL_EFUSES:
if efuse is not None:
self.EFUSES.append(efuse)
self.ALL_EFUSES = []
| 6,396 | Python | .py | 131 | 40.312977 | 140 | 0.577472 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,662 | emulate_efuse_controller.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32c2/emulate_efuse_controller.py | # This file describes eFuses controller for ESP32-C2 chip
#
# SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
from bitstring import BitStream
import reedsolo
from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters
from ..emulate_efuse_controller_base import EmulateEfuseControllerBase, FatalError
class EmulateEfuseController(EmulateEfuseControllerBase):
"""The class for virtual efuse operation. Using for HOST_TEST."""
CHIP_NAME = "ESP32-C2"
mem = None
debug = False
def __init__(self, efuse_file=None, debug=False):
self.Blocks = EfuseDefineBlocks
self.Fields = EfuseDefineFields()
self.REGS = EfuseDefineRegisters
super(EmulateEfuseController, self).__init__(efuse_file, debug)
self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
""" esptool method start >>"""
def get_major_chip_version(self):
return 1
def get_minor_chip_version(self):
return 0
def get_crystal_freq(self):
return 40 # MHz
def get_security_info(self):
return {
"flags": 0,
"flash_crypt_cnt": 0,
"key_purposes": 0,
"chip_id": 0,
"api_version": 0,
}
""" << esptool method end """
def handle_writing_event(self, addr, value):
if addr == self.REGS.EFUSE_CMD_REG:
if value & self.REGS.EFUSE_PGM_CMD:
self.copy_blocks_wr_regs_to_rd_regs(updated_block=(value >> 2) & 0xF)
self.clean_blocks_wr_regs()
self.check_rd_protection_area()
self.write_reg(addr, 0)
self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
elif value == self.REGS.EFUSE_READ_CMD:
self.write_reg(addr, 0)
self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
self.save_to_file()
def get_bitlen_of_block(self, blk, wr=False):
if blk.id == 0:
if wr:
return 32 * 8
else:
return 32 * blk.len
else:
if wr:
rs_coding = 32 * 3
return 32 * 8 + rs_coding
else:
return 32 * blk.len
def handle_coding_scheme(self, blk, data):
if blk.id != 0:
# CODING_SCHEME RS applied only for all blocks except BLK0.
coded_bytes = 12
data.pos = coded_bytes * 8
plain_data = data.readlist("32*uint:8")[::-1]
# takes 32 bytes
# apply RS encoding
rs = reedsolo.RSCodec(coded_bytes)
# 32 byte of data + 12 bytes RS
calc_encoded_data = list(rs.encode([x for x in plain_data]))
data.pos = 0
if calc_encoded_data != data.readlist("44*uint:8")[::-1]:
raise FatalError("Error in coding scheme data")
data = data[coded_bytes * 8 :]
if blk.len < 8:
data = data[(8 - blk.len) * 32 :]
return data
def check_rd_protection_area(self):
# checks fields which have the read protection bits.
# if the read protection bit is set then we need to reset this field to 0.
def get_read_disable_mask(blk):
mask = 0
if isinstance(blk.read_disable_bit, list):
for i in blk.read_disable_bit:
mask |= 1 << i
else:
mask = 1 << blk.read_disable_bit
return mask
read_disable_bit = self.read_field("RD_DIS", bitstring=False)
for b in self.Blocks.BLOCKS:
blk = self.Blocks.get(b)
block = self.read_block(blk.id)
if (
blk.read_disable_bit is not None
and read_disable_bit & get_read_disable_mask(blk)
):
if isinstance(blk.read_disable_bit, list):
if read_disable_bit & (1 << blk.read_disable_bit[0]):
block.set(
0, [i for i in range(blk.len * 32 // 2, blk.len * 32)]
)
if read_disable_bit & (1 << blk.read_disable_bit[1]):
block.set(0, [i for i in range(0, blk.len * 32 // 2)])
else:
block.set(0)
else:
for field in self.Fields.EFUSES:
if (
blk.id == field.block
and field.read_disable_bit is not None
and read_disable_bit & get_read_disable_mask(field)
):
raw_data = self.read_field(field.name)
raw_data.set(0)
block.pos = block.length - (
field.word * 32 + field.pos + raw_data.length
)
block.overwrite(BitStream(raw_data.length))
self.overwrite_mem_from_block(blk, block)
| 5,056 | Python | .py | 120 | 29.208333 | 86 | 0.532235 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,663 | __init__.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32c2/__init__.py | from . import operations
from .emulate_efuse_controller import EmulateEfuseController
from .fields import EspEfuses
| 116 | Python | .py | 3 | 37.666667 | 60 | 0.876106 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,664 | operations.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32c2/operations.py | # This file includes the operations with eFuses for ESP32-C2 chip
#
# SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import argparse
import os # noqa: F401. It is used in IDF scripts
import traceback
import espsecure
import esptool
from . import fields
from .. import util
from ..base_operations import (
add_common_commands,
add_force_write_always,
add_show_sensitive_info_option,
burn_bit,
burn_block_data,
burn_efuse,
check_error,
dump,
read_protect_efuse,
summary,
write_protect_efuse,
)
def protect_options(p):
p.add_argument(
"--no-write-protect",
help="Disable write-protecting of the key. The key remains writable. "
"(The keys use the RS coding scheme that does not support "
"post-write data changes. Forced write can damage RS encoding bits.) "
"The write-protecting of keypurposes does not depend on the option, "
"it will be set anyway.",
action="store_true",
)
p.add_argument(
"--no-read-protect",
help="Disable read-protecting of the key. The key remains readable software.",
action="store_true",
)
def add_commands(subparsers, efuses):
add_common_commands(subparsers, efuses)
burn_key = subparsers.add_parser(
"burn_key", help="Burn the key block with the specified name"
)
protect_options(burn_key)
add_force_write_always(burn_key)
add_show_sensitive_info_option(burn_key)
burn_key.add_argument(
"block",
help="Key block to burn",
action="append",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key.add_argument(
"keyfile",
help="File containing 128/256 bits of binary key data",
action="append",
type=argparse.FileType("rb"),
)
burn_key.add_argument(
"keypurpose",
help="Purpose to set.",
action="append",
choices=fields.EfuseKeyPurposeField.KEY_PURPOSES_NAME,
)
for _ in range(1):
burn_key.add_argument(
"block",
help="Key block to burn",
nargs="?",
action="append",
metavar="BLOCK",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key.add_argument(
"keyfile",
help="File containing 128/256 bits of binary key data",
nargs="?",
action="append",
metavar="KEYFILE",
type=argparse.FileType("rb"),
)
burn_key.add_argument(
"keypurpose",
help="Purpose to set.",
nargs="?",
action="append",
metavar="KEYPURPOSE",
choices=fields.EfuseKeyPurposeField.KEY_PURPOSES_NAME,
)
burn_key_digest = subparsers.add_parser(
"burn_key_digest",
help="Parse an ECDSA public key and burn the digest "
"to higher 128-bits of BLOCK_KEY0",
)
protect_options(burn_key_digest)
add_force_write_always(burn_key_digest)
add_show_sensitive_info_option(burn_key_digest)
burn_key_digest.add_argument(
"keyfile", help="Key file to digest (PEM format)", type=argparse.FileType("rb")
)
p = subparsers.add_parser(
"set_flash_voltage",
help="Permanently set the internal flash voltage regulator "
"to either 1.8V, 3.3V or OFF. This means GPIO45 can be high or low "
"at reset without changing the flash voltage.",
)
p.add_argument("voltage", help="Voltage selection", choices=["1.8V", "3.3V", "OFF"])
p = subparsers.add_parser(
"burn_custom_mac", help="Burn a 48-bit Custom MAC Address to EFUSE BLOCK1."
)
p.add_argument(
"mac",
help="Custom MAC Address to burn given in hexadecimal format "
"with bytes separated by colons (e.g. AA:CD:EF:01:02:03).",
type=fields.base_fields.CheckArgValue(efuses, "CUSTOM_MAC"),
)
add_force_write_always(p)
p = subparsers.add_parser("get_custom_mac", help="Prints the Custom MAC Address.")
def burn_custom_mac(esp, efuses, args):
efuses["CUSTOM_MAC"].save(args.mac)
efuses["CUSTOM_MAC_USED"].save(1)
if not efuses.burn_all(check_batch_mode=True):
return
get_custom_mac(esp, efuses, args)
print("Successful")
def get_custom_mac(esp, efuses, args):
print("Custom MAC Address: {}".format(efuses["CUSTOM_MAC"].get()))
def set_flash_voltage(esp, efuses, args):
raise esptool.FatalError("set_flash_voltage is not supported!")
def adc_info(esp, efuses, args):
print("")
# fmt: off
if efuses["BLK_VERSION_MINOR"].get() == 1:
print(" RF_REF_I_BIAS_CONFIG: {}".format(efuses["RF_REF_I_BIAS_CONFIG"].get()))
print(" LDO_VOL_BIAS_CONFIG_LOW: {}".format(efuses["LDO_VOL_BIAS_CONFIG_LOW"].get()))
print(" LDO_VOL_BIAS_CONFIG_HIGH: {}".format(efuses["LDO_VOL_BIAS_CONFIG_HIGH"].get()))
print(" PVT_LOW: {}".format(efuses["PVT_LOW"].get()))
print(" PVT_HIGH: {}".format(efuses["PVT_HIGH"].get()))
print(" ADC_CALIBRATION_0: {}".format(efuses["ADC_CALIBRATION_0"].get()))
print(" ADC_CALIBRATION_1: {}".format(efuses["ADC_CALIBRATION_1"].get()))
print(" ADC_CALIBRATION_2: {}".format(efuses["ADC_CALIBRATION_2"].get()))
else:
print("BLK_VERSION_MINOR = {}".format(efuses["BLK_VERSION_MINOR"].get_meaning()))
# fmt: on
def burn_key(esp, efuses, args, digest=None):
if digest is None:
datafile_list = args.keyfile[
0 : len([name for name in args.keyfile if name is not None]) :
]
else:
datafile_list = digest[0 : len([name for name in digest if name is not None]) :]
efuses.force_write_always = args.force_write_always
block_name_list = args.block[
0 : len([name for name in args.block if name is not None]) :
]
keypurpose_list = args.keypurpose[
0 : len([name for name in args.keypurpose if name is not None]) :
]
util.check_duplicate_name_in_list(keypurpose_list)
if len(block_name_list) != len(datafile_list) or len(block_name_list) != len(
keypurpose_list
):
raise esptool.FatalError(
"The number of blocks (%d), datafile (%d) and "
"keypurpose (%d) should be the same."
% (len(block_name_list), len(datafile_list), len(keypurpose_list))
)
assert 1 <= len(block_name_list) <= 2, "Unexpected case"
if len(block_name_list) == 2:
incompatible = True if "XTS_AES_128_KEY" in keypurpose_list else False
permitted_purposes = [
"XTS_AES_128_KEY_DERIVED_FROM_128_EFUSE_BITS",
"SECURE_BOOT_DIGEST",
]
incompatible |= (
keypurpose_list[0] in permitted_purposes
and keypurpose_list[1] not in permitted_purposes
)
if incompatible:
raise esptool.FatalError(
"These keypurposes are incompatible %s" % (keypurpose_list)
)
print("Burn keys to blocks:")
for datafile, keypurpose in zip(datafile_list, keypurpose_list):
data = datafile if isinstance(datafile, bytes) else datafile.read()
if keypurpose == "XTS_AES_128_KEY_DERIVED_FROM_128_EFUSE_BITS":
efuse = efuses["BLOCK_KEY0_LOW_128"]
elif keypurpose == "SECURE_BOOT_DIGEST":
efuse = efuses["BLOCK_KEY0_HI_128"]
if len(data) == 32:
print(
"\tProgramming only left-most 128-bits from SHA256 hash of "
"public key to highest 128-bits of BLOCK KEY0"
)
data = data[:16]
elif len(data) != efuse.bit_len // 8:
raise esptool.FatalError(
"Wrong length of this file for SECURE_BOOT_DIGEST. "
"Got %d (expected %d or %d)" % (len(data), 32, efuse.bit_len // 8)
)
assert len(data) == 16, "Only 16 bytes expected"
else:
efuse = efuses["BLOCK_KEY0"]
num_bytes = efuse.bit_len // 8
print(" - %s" % (efuse.name), end=" ")
revers_msg = None
if keypurpose.startswith("XTS_AES_"):
revers_msg = "\tReversing byte order for AES-XTS hardware peripheral"
data = data[::-1]
print(
"-> [{}]".format(
util.hexify(data, " ")
if args.show_sensitive_info
else " ".join(["??"] * len(data))
)
)
if revers_msg:
print(revers_msg)
if len(data) != num_bytes:
raise esptool.FatalError(
"Incorrect key file size %d. "
"Key file must be %d bytes (%d bits) of raw binary key data."
% (len(data), num_bytes, num_bytes * 8)
)
if keypurpose.startswith("XTS_AES_"):
read_protect = False if args.no_read_protect else True
else:
read_protect = False
write_protect = not args.no_write_protect
# using efuse instead of a block gives the advantage
# of checking it as the whole field.
efuse.save(data)
if keypurpose == "XTS_AES_128_KEY":
if efuses["XTS_KEY_LENGTH_256"].get():
print("\t'XTS_KEY_LENGTH_256' is already '1'")
else:
print("\tXTS_KEY_LENGTH_256 -> 1")
efuses["XTS_KEY_LENGTH_256"].save(1)
if read_protect:
print("\tDisabling read to key block")
efuse.disable_read()
if write_protect:
print("\tDisabling write to key block")
efuse.disable_write()
print("")
if not write_protect:
print("Keys will remain writeable (due to --no-write-protect)")
if args.no_read_protect:
print("Keys will remain readable (due to --no-read-protect)")
if not efuses.burn_all(check_batch_mode=True):
return
print("Successful")
def burn_key_digest(esp, efuses, args):
datafile = args.keyfile
args.keypurpose = ["SECURE_BOOT_DIGEST"]
args.block = ["BLOCK_KEY0"]
digest = espsecure._digest_sbv2_public_key(datafile)
digest = digest[:16]
num_bytes = efuses["BLOCK_KEY0_HI_128"].bit_len // 8
if len(digest) != num_bytes:
raise esptool.FatalError(
"Incorrect digest size %d. "
"Digest must be %d bytes (%d bits) of raw binary key data."
% (len(digest), num_bytes, num_bytes * 8)
)
burn_key(esp, efuses, args, digest=[digest])
def espefuse(esp, efuses, args, command):
parser = argparse.ArgumentParser()
subparsers = parser.add_subparsers(dest="operation")
add_commands(subparsers, efuses)
try:
cmd_line_args = parser.parse_args(command.split())
except SystemExit:
traceback.print_stack()
raise esptool.FatalError('"{}" - incorrect command'.format(command))
if cmd_line_args.operation == "execute_scripts":
configfiles = cmd_line_args.configfiles
index = cmd_line_args.index
# copy arguments from args to cmd_line_args
vars(cmd_line_args).update(vars(args))
if cmd_line_args.operation == "execute_scripts":
cmd_line_args.configfiles = configfiles
cmd_line_args.index = index
if cmd_line_args.operation is None:
parser.print_help()
parser.exit(1)
operation_func = globals()[cmd_line_args.operation]
# each 'operation' is a module-level function of the same name
operation_func(esp, efuses, cmd_line_args)
def execute_scripts(esp, efuses, args):
efuses.batch_mode_cnt += 1
del args.operation
scripts = args.scripts
del args.scripts
for file in scripts:
with open(file.name, "r") as file:
exec(compile(file.read(), file.name, "exec"))
if args.debug:
for block in efuses.blocks:
data = block.get_bitstring(from_read=False)
block.print_block(data, "regs_for_burn", args.debug)
efuses.batch_mode_cnt -= 1
if not efuses.burn_all(check_batch_mode=True):
return
print("Successful")
| 12,287 | Python | .py | 307 | 31.579805 | 101 | 0.602213 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,665 | fields.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32c2/fields.py | # This file describes eFuses for ESP32-C2 chip
#
# SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import binascii
import struct
import time
from bitstring import BitArray
import esptool
import reedsolo
from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters
from .. import base_fields
from .. import util
class EfuseBlock(base_fields.EfuseBlockBase):
def len_of_burn_unit(self):
# The writing register window is 8 registers for any blocks.
# len in bytes
return 8 * 4
def __init__(self, parent, param, skip_read=False):
parent.read_coding_scheme()
super(EfuseBlock, self).__init__(parent, param, skip_read=skip_read)
def apply_coding_scheme(self):
data = self.get_raw(from_read=False)[::-1]
if len(data) < self.len_of_burn_unit():
add_empty_bytes = self.len_of_burn_unit() - len(data)
data = data + (b"\x00" * add_empty_bytes)
if self.get_coding_scheme() == self.parent.REGS.CODING_SCHEME_RS:
# takes 32 bytes
# apply RS encoding
rs = reedsolo.RSCodec(12)
# 32 byte of data + 12 bytes RS
encoded_data = rs.encode([x for x in data])
words = struct.unpack("<" + "I" * 11, encoded_data)
# returns 11 words (8 words of data + 3 words of RS coding)
else:
# takes 32 bytes
words = struct.unpack("<" + ("I" * (len(data) // 4)), data)
# returns 8 words
return words
class EspEfuses(base_fields.EspEfusesBase):
"""
Wrapper object to manage the efuse fields in a connected ESP bootloader
"""
debug = False
do_not_confirm = False
def __init__(self, esp, skip_connect=False, debug=False, do_not_confirm=False):
self.Blocks = EfuseDefineBlocks()
self.Fields = EfuseDefineFields()
self.REGS = EfuseDefineRegisters
self.BURN_BLOCK_DATA_NAMES = self.Blocks.get_burn_block_data_names()
self.BLOCKS_FOR_KEYS = self.Blocks.get_blocks_for_keys()
self._esp = esp
self.debug = debug
self.do_not_confirm = do_not_confirm
if esp.CHIP_NAME != "ESP32-C2":
raise esptool.FatalError(
"Expected the 'esp' param for ESP32-C2 chip but got for '%s'."
% (esp.CHIP_NAME)
)
if not skip_connect:
flags = self._esp.get_security_info()["flags"]
GET_SECURITY_INFO_FLAG_SECURE_DOWNLOAD_ENABLE = 1 << 2
if flags & GET_SECURITY_INFO_FLAG_SECURE_DOWNLOAD_ENABLE:
raise esptool.FatalError(
"Secure Download Mode is enabled. The tool can not read eFuses."
)
self.blocks = [
EfuseBlock(self, self.Blocks.get(block), skip_read=skip_connect)
for block in self.Blocks.BLOCKS
]
if not skip_connect:
self.get_coding_scheme_warnings()
self.efuses = [EfuseField.convert(self, efuse) for efuse in self.Fields.EFUSES]
self.efuses += [
EfuseField.convert(self, efuse) for efuse in self.Fields.KEYBLOCKS
]
if skip_connect:
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
]
else:
if self["BLK_VERSION_MINOR"].get() == 1:
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
]
def __getitem__(self, efuse_name):
"""Return the efuse field with the given name"""
for e in self.efuses:
if efuse_name == e.name or any(x == efuse_name for x in e.alt_names):
return e
new_fields = False
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES:
if efuse.name == efuse_name or any(
x == efuse_name for x in efuse.alt_names
):
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
]
new_fields = True
if new_fields:
for e in self.efuses:
if efuse_name == e.name or any(x == efuse_name for x in e.alt_names):
return e
raise KeyError
def read_coding_scheme(self):
self.coding_scheme = self.REGS.CODING_SCHEME_RS
def print_status_regs(self):
print("")
self.blocks[0].print_block(self.blocks[0].err_bitarray, "err__regs", debug=True)
print(
"{:27} 0x{:08x}".format(
"EFUSE_RD_RS_ERR_REG", self.read_reg(self.REGS.EFUSE_RD_RS_ERR_REG)
)
)
def efuse_controller_setup(self):
self.set_efuse_timing()
self.clear_pgm_registers()
self.wait_efuse_idle()
def write_efuses(self, block):
self.efuse_program(block)
return self.get_coding_scheme_warnings(silent=True)
def clear_pgm_registers(self):
self.wait_efuse_idle()
for r in range(
self.REGS.EFUSE_PGM_DATA0_REG, self.REGS.EFUSE_PGM_DATA0_REG + 32, 4
):
self.write_reg(r, 0)
def wait_efuse_idle(self):
deadline = time.time() + self.REGS.EFUSE_BURN_TIMEOUT
while time.time() < deadline:
# if self.read_reg(self.REGS.EFUSE_CMD_REG) == 0:
if self.read_reg(self.REGS.EFUSE_STATUS_REG) & 0x7 == 1:
return
raise esptool.FatalError(
"Timed out waiting for Efuse controller command to complete"
)
def efuse_program(self, block):
self.wait_efuse_idle()
self.write_reg(self.REGS.EFUSE_CONF_REG, self.REGS.EFUSE_WRITE_OP_CODE)
self.write_reg(self.REGS.EFUSE_CMD_REG, self.REGS.EFUSE_PGM_CMD | (block << 2))
self.wait_efuse_idle()
self.clear_pgm_registers()
self.efuse_read()
def efuse_read(self):
self.wait_efuse_idle()
self.write_reg(self.REGS.EFUSE_CONF_REG, self.REGS.EFUSE_READ_OP_CODE)
# need to add a delay after triggering EFUSE_READ_CMD, as ROM loader checks some
# efuse registers after each command is completed
# if ENABLE_SECURITY_DOWNLOAD or DIS_DOWNLOAD_MODE is enabled by the current cmd, then we need to try to reconnect to the chip.
try:
self.write_reg(
self.REGS.EFUSE_CMD_REG, self.REGS.EFUSE_READ_CMD, delay_after_us=1000
)
self.wait_efuse_idle()
except esptool.FatalError:
secure_download_mode_before = self._esp.secure_download_mode
try:
self._esp = self.reconnect_chip(self._esp)
except esptool.FatalError:
print("Can not re-connect to the chip")
if not self["DIS_DOWNLOAD_MODE"].get() and self[
"DIS_DOWNLOAD_MODE"
].get(from_read=False):
print(
"This is the correct behavior as we are actually burning "
"DIS_DOWNLOAD_MODE which disables the connection to the chip"
)
print("DIS_DOWNLOAD_MODE is enabled")
print("Successful")
exit(0) # finish without errors
raise
print("Established a connection with the chip")
if self._esp.secure_download_mode and not secure_download_mode_before:
print("Secure download mode is enabled")
if not self["ENABLE_SECURITY_DOWNLOAD"].get() and self[
"ENABLE_SECURITY_DOWNLOAD"
].get(from_read=False):
print(
"espefuse tool can not continue to work in Secure download mode"
)
print("ENABLE_SECURITY_DOWNLOAD is enabled")
print("Successful")
exit(0) # finish without errors
raise
def set_efuse_timing(self):
"""Set timing registers for burning efuses"""
# Configure clock
xtal_freq = self.get_crystal_freq()
if xtal_freq not in [26, 40]:
raise esptool.FatalError(
"The eFuse supports only xtal=26M and 40M (xtal was %d)" % xtal_freq
)
self.update_reg(self.REGS.EFUSE_DAC_CONF_REG, self.REGS.EFUSE_DAC_NUM_M, 0xFF)
self.update_reg(
self.REGS.EFUSE_DAC_CONF_REG, self.REGS.EFUSE_DAC_CLK_DIV_M, 0x28
)
self.update_reg(
self.REGS.EFUSE_WR_TIM_CONF1_REG, self.REGS.EFUSE_PWR_ON_NUM_M, 0x3000
)
self.update_reg(
self.REGS.EFUSE_WR_TIM_CONF2_REG, self.REGS.EFUSE_PWR_OFF_NUM_M, 0x190
)
tpgm_inactive_val = 200 if xtal_freq == 40 else 130
self.update_reg(
self.REGS.EFUSE_WR_TIM_CONF0_REG,
self.REGS.EFUSE_TPGM_INACTIVE_M,
tpgm_inactive_val,
)
def get_coding_scheme_warnings(self, silent=False):
"""Check if the coding scheme has detected any errors."""
old_addr_reg = 0
reg_value = 0
ret_fail = False
for block in self.blocks:
if block.id == 0:
words = [
self.read_reg(self.REGS.EFUSE_RD_REPEAT_ERR_REG + offs * 4)
for offs in range(1)
]
block.err_bitarray.pos = 0
for word in reversed(words):
block.err_bitarray.overwrite(BitArray("uint:32=%d" % word))
block.num_errors = block.err_bitarray.count(True)
block.fail = block.num_errors != 0
else:
addr_reg, err_num_mask, err_num_offs, fail_bit = self.REGS.BLOCK_ERRORS[
block.id
]
if err_num_mask is None or err_num_offs is None or fail_bit is None:
continue
if addr_reg != old_addr_reg:
old_addr_reg = addr_reg
reg_value = self.read_reg(addr_reg)
block.fail = reg_value & (1 << fail_bit) != 0
block.num_errors = (reg_value >> err_num_offs) & err_num_mask
ret_fail |= block.fail
if not silent and (block.fail or block.num_errors):
print(
"Error(s) in BLOCK%d [ERRORS:%d FAIL:%d]"
% (block.id, block.num_errors, block.fail)
)
if (self.debug or ret_fail) and not silent:
self.print_status_regs()
return ret_fail
def summary(self):
# TODO add support set_flash_voltage - "Flash voltage (VDD_SPI)"
return ""
class EfuseField(base_fields.EfuseFieldBase):
@staticmethod
def convert(parent, efuse):
return {
"mac": EfuseMacField,
"keypurpose": EfuseKeyPurposeField,
"t_sensor": EfuseTempSensor,
"adc_tp": EfuseAdcPointCalibration,
}.get(efuse.class_type, EfuseField)(parent, efuse)
class EfuseTempSensor(EfuseField):
def get(self, from_read=True):
value = self.get_bitstring(from_read)
sig = -1 if value[0] else 1
return sig * value[1:].uint * 0.1
class EfuseAdcPointCalibration(EfuseField):
def get(self, from_read=True):
STEP_SIZE = 4
value = self.get_bitstring(from_read)
sig = -1 if value[0] else 1
return sig * value[1:].uint * STEP_SIZE
class EfuseMacField(EfuseField):
def check_format(self, new_value_str):
if new_value_str is None:
raise esptool.FatalError(
"Required MAC Address in AA:CD:EF:01:02:03 format!"
)
if new_value_str.count(":") != 5:
raise esptool.FatalError(
"MAC Address needs to be a 6-byte hexadecimal format "
"separated by colons (:)!"
)
hexad = new_value_str.replace(":", "")
if len(hexad) != 12:
raise esptool.FatalError(
"MAC Address needs to be a 6-byte hexadecimal number "
"(12 hexadecimal characters)!"
)
# order of bytearray = b'\xaa\xcd\xef\x01\x02\x03',
bindata = binascii.unhexlify(hexad)
# unicast address check according to
# https://tools.ietf.org/html/rfc7042#section-2.1
if esptool.util.byte(bindata, 0) & 0x01:
raise esptool.FatalError("Custom MAC must be a unicast MAC!")
return bindata
def check(self):
errs, fail = self.parent.get_block_errors(self.block)
if errs != 0 or fail:
output = "Block%d has ERRORS:%d FAIL:%d" % (self.block, errs, fail)
else:
output = "OK"
return "(" + output + ")"
def get(self, from_read=True):
if self.name == "CUSTOM_MAC":
mac = self.get_raw(from_read)[::-1]
else:
mac = self.get_raw(from_read)
return "%s %s" % (util.hexify(mac, ":"), self.check())
def save(self, new_value):
def print_field(e, new_value):
print(
" - '{}' ({}) {} -> {}".format(
e.name, e.description, e.get_bitstring(), new_value
)
)
if self.name == "CUSTOM_MAC":
bitarray_mac = self.convert_to_bitstring(new_value)
print_field(self, bitarray_mac)
super(EfuseMacField, self).save(new_value)
else:
raise esptool.FatalError("Writing Factory MAC address is not supported")
class EfuseKeyPurposeField(EfuseField):
KEY_PURPOSES = [
# fmt: off
("USER", 0, None), # User purposes (software-only use)
("XTS_AES_128_KEY", 1, None), # (whole 256bits) flash/PSRAM encryption
("XTS_AES_128_KEY_DERIVED_FROM_128_EFUSE_BITS", 2, None), # (lo 128bits) flash/PSRAM encryption
("SECURE_BOOT_DIGEST", 3, "DIGEST"),
# (hi 128bits) Secure Boot key digest
# fmt: on
]
KEY_PURPOSES_NAME = [name[0] for name in KEY_PURPOSES]
DIGEST_KEY_PURPOSES = [name[0] for name in KEY_PURPOSES if name[2] == "DIGEST"]
| 14,507 | Python | .py | 333 | 32.114114 | 135 | 0.565534 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,666 | mem_definition.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32c2/mem_definition.py | # This file describes eFuses fields and registers for ESP32-C2 chip
#
# SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import copy
import os
import yaml
from ..mem_definition_base import (
EfuseBlocksBase,
EfuseFieldsBase,
EfuseRegistersBase,
)
class EfuseDefineRegisters(EfuseRegistersBase):
EFUSE_MEM_SIZE = 0x01FC + 4
# EFUSE registers & command/conf values
DR_REG_EFUSE_BASE = 0x60008800
EFUSE_PGM_DATA0_REG = DR_REG_EFUSE_BASE
EFUSE_PGM_CHECK_VALUE0_REG = DR_REG_EFUSE_BASE + 0x020
EFUSE_CLK_REG = DR_REG_EFUSE_BASE + 0x88
EFUSE_CONF_REG = DR_REG_EFUSE_BASE + 0x8C
EFUSE_STATUS_REG = DR_REG_EFUSE_BASE + 0x90
EFUSE_CMD_REG = DR_REG_EFUSE_BASE + 0x94
EFUSE_RD_REPEAT_ERR_REG = DR_REG_EFUSE_BASE + 0x80
EFUSE_RD_RS_ERR_REG = DR_REG_EFUSE_BASE + 0x84
EFUSE_WRITE_OP_CODE = 0x5A5A
EFUSE_READ_OP_CODE = 0x5AA5
EFUSE_PGM_CMD_MASK = 0x3
EFUSE_PGM_CMD = 0x2
EFUSE_READ_CMD = 0x1
BLOCK_ERRORS = [
# error_reg, err_num_mask, err_num_offs, fail_bit
(EFUSE_RD_REPEAT_ERR_REG, None, None, None), # BLOCK0
(EFUSE_RD_RS_ERR_REG, 0x7, 0, 3), # BLOCK1
(EFUSE_RD_RS_ERR_REG, 0x7, 4, 7), # BLOCK2
(EFUSE_RD_RS_ERR_REG, 0x7, 8, 11), # BLOCK3
]
EFUSE_WR_TIM_CONF2_REG = DR_REG_EFUSE_BASE + 0x118
EFUSE_PWR_OFF_NUM_S = 0
EFUSE_PWR_OFF_NUM_M = 0xFFFF << EFUSE_PWR_OFF_NUM_S
EFUSE_WR_TIM_CONF0_REG = DR_REG_EFUSE_BASE + 0x110
EFUSE_TPGM_INACTIVE_S = 8
EFUSE_TPGM_INACTIVE_M = 0xFF << EFUSE_TPGM_INACTIVE_S
EFUSE_WR_TIM_CONF1_REG = DR_REG_EFUSE_BASE + 0x114
EFUSE_PWR_ON_NUM_S = 8
EFUSE_PWR_ON_NUM_M = 0x0000FFFF << EFUSE_PWR_ON_NUM_S
EFUSE_DAC_CONF_REG = DR_REG_EFUSE_BASE + 0x108
EFUSE_DAC_CLK_DIV_S = 0
EFUSE_DAC_CLK_DIV_M = 0xFF << EFUSE_DAC_CLK_DIV_S
# EFUSE_DAC_CONF_REG
EFUSE_DAC_NUM_S = 9
EFUSE_DAC_NUM_M = 0xFF << EFUSE_DAC_NUM_S
class EfuseDefineBlocks(EfuseBlocksBase):
__base_rd_regs = EfuseDefineRegisters.DR_REG_EFUSE_BASE
__base_wr_regs = EfuseDefineRegisters.EFUSE_PGM_DATA0_REG
# List of efuse blocks
# fmt: off
BLOCKS = [
# Name, Alias, Index, Read address, Write address, Write protect bit, Read protect bit, Len, key_purpose
("BLOCK0", ["BLOCK0"], 0, __base_rd_regs + 0x02C, __base_wr_regs, None, None, 2, None),
("BLOCK1", ["BLOCK1"], 1, __base_rd_regs + 0x034, __base_wr_regs, 5, None, 3, None),
("BLOCK2", ["BLOCK2"], 2, __base_rd_regs + 0x040, __base_wr_regs, 6, None, 8, None),
("BLOCK_KEY0", ["BLOCK3"], 3, __base_rd_regs + 0x060, __base_wr_regs, 7, [0, 1], 8, None),
]
# fmt: on
def get_burn_block_data_names(self):
list_of_names = []
for block in self.BLOCKS:
blk = self.get(block)
if blk.name:
list_of_names.append(blk.name)
if blk.alias:
for alias in blk.alias:
list_of_names.append(alias)
return list_of_names
def get_blocks_for_keys(self):
return ["BLOCK_KEY0"]
class EfuseDefineFields(EfuseFieldsBase):
def __init__(self) -> None:
# List of efuse fields from TRM the chapter eFuse Controller.
self.EFUSES = []
self.KEYBLOCKS = []
# if BLK_VERSION_MINOR is 1, these efuse fields are in BLOCK2
self.BLOCK2_CALIBRATION_EFUSES = []
dir_name = os.path.dirname(os.path.abspath(__file__))
dir_name, file_name = os.path.split(dir_name)
file_name = file_name + ".yaml"
dir_name, _ = os.path.split(dir_name)
efuse_file = os.path.join(dir_name, "efuse_defs", file_name)
with open(f"{efuse_file}", "r") as r_file:
e_desc = yaml.safe_load(r_file)
super().__init__(e_desc)
for i, efuse in enumerate(self.ALL_EFUSES):
if efuse.name in ["BLOCK_KEY0"]:
self.KEYBLOCKS.append(efuse)
BLOCK_KEY0_LOW_128 = copy.deepcopy(efuse)
BLOCK_KEY0_LOW_128.name = "BLOCK_KEY0_LOW_128"
BLOCK_KEY0_LOW_128.type = "bytes:16"
BLOCK_KEY0_LOW_128.bit_len = 16 * 8
BLOCK_KEY0_LOW_128.description = (
"BLOCK_KEY0 - lower 128-bits. 128-bit key of Flash Encryption"
)
BLOCK_KEY0_LOW_128.read_disable_bit = efuse.read_disable_bit[0]
self.KEYBLOCKS.append(BLOCK_KEY0_LOW_128)
BLOCK_KEY0_HI_128 = copy.deepcopy(efuse)
BLOCK_KEY0_HI_128.name = "BLOCK_KEY0_HI_128"
BLOCK_KEY0_HI_128.word = 4
BLOCK_KEY0_HI_128.type = "bytes:16"
BLOCK_KEY0_HI_128.bit_len = 16 * 8
BLOCK_KEY0_HI_128.description = (
"BLOCK_KEY0 - higher 128-bits. 128-bits key of Secure Boot"
)
BLOCK_KEY0_HI_128.read_disable_bit = efuse.read_disable_bit[1]
self.KEYBLOCKS.append(BLOCK_KEY0_HI_128)
self.ALL_EFUSES[i] = None
elif efuse.category == "calibration":
self.BLOCK2_CALIBRATION_EFUSES.append(efuse)
self.ALL_EFUSES[i] = None
for efuse in self.ALL_EFUSES:
if efuse is not None:
self.EFUSES.append(efuse)
self.ALL_EFUSES = []
| 5,616 | Python | .py | 122 | 37.090164 | 140 | 0.578899 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,667 | emulate_efuse_controller.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32s3/emulate_efuse_controller.py | # This file describes eFuses controller for ESP32-S3 chip
#
# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import reedsolo
from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters
from ..emulate_efuse_controller_base import EmulateEfuseControllerBase, FatalError
class EmulateEfuseController(EmulateEfuseControllerBase):
"""The class for virtual efuse operation. Using for HOST_TEST."""
CHIP_NAME = "ESP32-S3"
mem = None
debug = False
def __init__(self, efuse_file=None, debug=False):
self.Blocks = EfuseDefineBlocks
self.Fields = EfuseDefineFields()
self.REGS = EfuseDefineRegisters
super(EmulateEfuseController, self).__init__(efuse_file, debug)
self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
""" esptool method start >>"""
def get_major_chip_version(self):
return 0
def get_minor_chip_version(self):
return 2
def get_crystal_freq(self):
return 40 # MHz (common for all chips)
def get_security_info(self):
return {
"flags": 0,
"flash_crypt_cnt": 0,
"key_purposes": 0,
"chip_id": 0,
"api_version": 0,
}
""" << esptool method end """
def handle_writing_event(self, addr, value):
if addr == self.REGS.EFUSE_CMD_REG:
if value & self.REGS.EFUSE_PGM_CMD:
self.copy_blocks_wr_regs_to_rd_regs(updated_block=(value >> 2) & 0xF)
self.clean_blocks_wr_regs()
self.check_rd_protection_area()
self.write_reg(addr, 0)
self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
elif value == self.REGS.EFUSE_READ_CMD:
self.write_reg(addr, 0)
self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
self.save_to_file()
def get_bitlen_of_block(self, blk, wr=False):
if blk.id == 0:
if wr:
return 32 * 8
else:
return 32 * blk.len
else:
if wr:
rs_coding = 32 * 3
return 32 * 8 + rs_coding
else:
return 32 * blk.len
def handle_coding_scheme(self, blk, data):
if blk.id != 0:
# CODING_SCHEME RS applied only for all blocks except BLK0.
coded_bytes = 12
data.pos = coded_bytes * 8
plain_data = data.readlist("32*uint:8")[::-1]
# takes 32 bytes
# apply RS encoding
rs = reedsolo.RSCodec(coded_bytes)
# 32 byte of data + 12 bytes RS
calc_encoded_data = list(rs.encode([x for x in plain_data]))
data.pos = 0
if calc_encoded_data != data.readlist("44*uint:8")[::-1]:
raise FatalError("Error in coding scheme data")
data = data[coded_bytes * 8 :]
if blk.len < 8:
data = data[(8 - blk.len) * 32 :]
return data
| 3,072 | Python | .py | 77 | 29.662338 | 86 | 0.575839 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,668 | __init__.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32s3/__init__.py | from . import operations
from .emulate_efuse_controller import EmulateEfuseController
from .fields import EspEfuses
| 116 | Python | .py | 3 | 37.666667 | 60 | 0.876106 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,669 | operations.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32s3/operations.py | # This file includes the operations with eFuses for ESP32-S3 chip
#
# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import argparse
import io
import os # noqa: F401. It is used in IDF scripts
import traceback
import espsecure
import esptool
from . import fields
from .. import util
from ..base_operations import (
add_common_commands,
add_force_write_always,
add_show_sensitive_info_option,
burn_bit,
burn_block_data,
burn_efuse,
check_error,
dump,
read_protect_efuse,
summary,
write_protect_efuse,
)
def protect_options(p):
p.add_argument(
"--no-write-protect",
help="Disable write-protecting of the key. The key remains writable. "
"(The keys use the RS coding scheme that does not support post-write "
"data changes. Forced write can damage RS encoding bits.) "
"The write-protecting of keypurposes does not depend on the option, "
"it will be set anyway.",
action="store_true",
)
p.add_argument(
"--no-read-protect",
help="Disable read-protecting of the key. The key remains readable software."
"The key with keypurpose[USER, RESERVED and *_DIGEST] "
"will remain readable anyway. "
"For the rest keypurposes the read-protection will be defined the option "
"(Read-protect by default).",
action="store_true",
)
def add_commands(subparsers, efuses):
add_common_commands(subparsers, efuses)
burn_key = subparsers.add_parser(
"burn_key", help="Burn the key block with the specified name"
)
protect_options(burn_key)
add_force_write_always(burn_key)
add_show_sensitive_info_option(burn_key)
burn_key.add_argument(
"block",
help="Key block to burn",
action="append",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key.add_argument(
"keyfile",
help="File containing 256 bits of binary key data",
action="append",
type=argparse.FileType("rb"),
)
burn_key.add_argument(
"keypurpose",
help="Purpose to set.",
action="append",
choices=fields.EfuseKeyPurposeField.KEY_PURPOSES_NAME,
)
for _ in efuses.BLOCKS_FOR_KEYS:
burn_key.add_argument(
"block",
help="Key block to burn",
nargs="?",
action="append",
metavar="BLOCK",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key.add_argument(
"keyfile",
help="File containing 256 bits of binary key data",
nargs="?",
action="append",
metavar="KEYFILE",
type=argparse.FileType("rb"),
)
burn_key.add_argument(
"keypurpose",
help="Purpose to set.",
nargs="?",
action="append",
metavar="KEYPURPOSE",
choices=fields.EfuseKeyPurposeField.KEY_PURPOSES_NAME,
)
burn_key_digest = subparsers.add_parser(
"burn_key_digest",
help="Parse a RSA public key and burn the digest to key efuse block",
)
protect_options(burn_key_digest)
add_force_write_always(burn_key_digest)
add_show_sensitive_info_option(burn_key_digest)
burn_key_digest.add_argument(
"block",
help="Key block to burn",
action="append",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key_digest.add_argument(
"keyfile",
help="Key file to digest (PEM format)",
action="append",
type=argparse.FileType("rb"),
)
burn_key_digest.add_argument(
"keypurpose",
help="Purpose to set.",
action="append",
choices=fields.EfuseKeyPurposeField.DIGEST_KEY_PURPOSES,
)
for _ in efuses.BLOCKS_FOR_KEYS:
burn_key_digest.add_argument(
"block",
help="Key block to burn",
nargs="?",
action="append",
metavar="BLOCK",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key_digest.add_argument(
"keyfile",
help="Key file to digest (PEM format)",
nargs="?",
action="append",
metavar="KEYFILE",
type=argparse.FileType("rb"),
)
burn_key_digest.add_argument(
"keypurpose",
help="Purpose to set.",
nargs="?",
action="append",
metavar="KEYPURPOSE",
choices=fields.EfuseKeyPurposeField.DIGEST_KEY_PURPOSES,
)
p = subparsers.add_parser(
"set_flash_voltage",
help="Permanently set the internal flash voltage regulator "
"to either 1.8V, 3.3V or OFF. This means GPIO45 can be high or low at reset "
"without changing the flash voltage.",
)
p.add_argument("voltage", help="Voltage selection", choices=["1.8V", "3.3V", "OFF"])
p = subparsers.add_parser(
"burn_custom_mac", help="Burn a 48-bit Custom MAC Address to EFUSE BLOCK3."
)
p.add_argument(
"mac",
help="Custom MAC Address to burn given in hexadecimal format with "
"bytes separated by colons (e.g. AA:CD:EF:01:02:03).",
type=fields.base_fields.CheckArgValue(efuses, "CUSTOM_MAC"),
)
add_force_write_always(p)
p = subparsers.add_parser("get_custom_mac", help="Prints the Custom MAC Address.")
def burn_custom_mac(esp, efuses, args):
efuses["CUSTOM_MAC"].save(args.mac)
if not efuses.burn_all(check_batch_mode=True):
return
get_custom_mac(esp, efuses, args)
print("Successful")
def get_custom_mac(esp, efuses, args):
print("Custom MAC Address: {}".format(efuses["CUSTOM_MAC"].get()))
def set_flash_voltage(esp, efuses, args):
sdio_force = efuses["VDD_SPI_FORCE"]
sdio_tieh = efuses["VDD_SPI_TIEH"]
sdio_reg = efuses["VDD_SPI_XPD"]
# check efuses aren't burned in a way which makes this impossible
if args.voltage == "OFF" and sdio_reg.get() != 0:
raise esptool.FatalError(
"Can't set flash regulator to OFF as VDD_SPI_XPD efuse is already burned"
)
if args.voltage == "1.8V" and sdio_tieh.get() != 0:
raise esptool.FatalError(
"Can't set regulator to 1.8V is VDD_SPI_TIEH efuse is already burned"
)
if args.voltage == "OFF":
msg = "Disable internal flash voltage regulator (VDD_SPI). "
"SPI flash will need to be powered from an external source.\n"
"The following efuse is burned: VDD_SPI_FORCE.\n"
"It is possible to later re-enable the internal regulator (%s) " % (
"to 3.3V" if sdio_tieh.get() != 0 else "to 1.8V or 3.3V"
)
"by burning an additional efuse"
elif args.voltage == "1.8V":
msg = "Set internal flash voltage regulator (VDD_SPI) to 1.8V.\n"
"The following efuses are burned: VDD_SPI_FORCE, VDD_SPI_XPD.\n"
"It is possible to later increase the voltage to 3.3V (permanently) "
"by burning additional efuse VDD_SPI_TIEH"
elif args.voltage == "3.3V":
msg = "Enable internal flash voltage regulator (VDD_SPI) to 3.3V.\n"
"The following efuses are burned: VDD_SPI_FORCE, VDD_SPI_XPD, VDD_SPI_TIEH."
print(msg)
sdio_force.save(1) # Disable GPIO45
if args.voltage != "OFF":
sdio_reg.save(1) # Enable internal regulator
if args.voltage == "3.3V":
sdio_tieh.save(1)
print("VDD_SPI setting complete.")
if not efuses.burn_all(check_batch_mode=True):
return
print("Successful")
def adc_info(esp, efuses, args):
print("")
# fmt: off
if efuses["BLK_VERSION_MAJOR"].get() == 1:
print("Temperature Sensor Calibration = {}C".format(efuses["TEMP_SENSOR_CAL"].get()))
print("")
print("ADC1 readings stored in efuse BLOCK2:")
print(" MODE0 D1 reading (250mV): {}".format(efuses["ADC1_MODE0_D1"].get()))
print(" MODE0 D2 reading (600mV): {}".format(efuses["ADC1_MODE0_D2"].get()))
print(" MODE1 D1 reading (250mV): {}".format(efuses["ADC1_MODE1_D1"].get()))
print(" MODE1 D2 reading (800mV): {}".format(efuses["ADC1_MODE1_D2"].get()))
print(" MODE2 D1 reading (250mV): {}".format(efuses["ADC1_MODE2_D1"].get()))
print(" MODE2 D2 reading (1000mV): {}".format(efuses["ADC1_MODE2_D2"].get()))
print(" MODE3 D1 reading (250mV): {}".format(efuses["ADC1_MODE3_D1"].get()))
print(" MODE3 D2 reading (2000mV): {}".format(efuses["ADC1_MODE3_D2"].get()))
print("")
print("ADC2 readings stored in efuse BLOCK2:")
print(" MODE0 D1 reading (250mV): {}".format(efuses["ADC2_MODE0_D1"].get()))
print(" MODE0 D2 reading (600mV): {}".format(efuses["ADC2_MODE0_D2"].get()))
print(" MODE1 D1 reading (250mV): {}".format(efuses["ADC2_MODE1_D1"].get()))
print(" MODE1 D2 reading (800mV): {}".format(efuses["ADC2_MODE1_D2"].get()))
print(" MODE2 D1 reading (250mV): {}".format(efuses["ADC2_MODE2_D1"].get()))
print(" MODE2 D2 reading (1000mV): {}".format(efuses["ADC2_MODE2_D2"].get()))
print(" MODE3 D1 reading (250mV): {}".format(efuses["ADC2_MODE3_D1"].get()))
print(" MODE3 D2 reading (2000mV): {}".format(efuses["ADC2_MODE3_D2"].get()))
else:
print("BLK_VERSION_MAJOR = {}".format(efuses["BLK_VERSION_MAJOR"].get_meaning()))
# fmt: on
def key_block_is_unused(block, key_purpose_block):
if not block.is_readable() or not block.is_writeable():
return False
if key_purpose_block.get() != "USER" or not key_purpose_block.is_writeable():
return False
if not block.get_bitstring().all(False):
return False
return True
def get_next_key_block(efuses, current_key_block, block_name_list):
key_blocks = [b for b in efuses.blocks if b.key_purpose_name]
start = key_blocks.index(current_key_block)
# Sort key blocks so that we pick the next free block (and loop around if necessary)
key_blocks = key_blocks[start:] + key_blocks[0:start]
# Exclude any other blocks that will be be burned
key_blocks = [b for b in key_blocks if b.name not in block_name_list]
for block in key_blocks:
key_purpose_block = efuses[block.key_purpose_name]
if key_block_is_unused(block, key_purpose_block):
return block
return None
def split_512_bit_key(efuses, block_name_list, datafile_list, keypurpose_list):
i = keypurpose_list.index("XTS_AES_256_KEY")
block_name = block_name_list[i]
block_num = efuses.get_index_block_by_name(block_name)
block = efuses.blocks[block_num]
data = datafile_list[i].read()
if len(data) != 64:
raise esptool.FatalError(
"Incorrect key file size %d, XTS_AES_256_KEY should be 64 bytes" % len(data)
)
key_block_2 = get_next_key_block(efuses, block, block_name_list)
if not key_block_2:
raise esptool.FatalError("XTS_AES_256_KEY requires two free keyblocks")
keypurpose_list.append("XTS_AES_256_KEY_1")
datafile_list.append(io.BytesIO(data[:32]))
block_name_list.append(block_name)
keypurpose_list.append("XTS_AES_256_KEY_2")
datafile_list.append(io.BytesIO(data[32:]))
block_name_list.append(key_block_2.name)
keypurpose_list.pop(i)
datafile_list.pop(i)
block_name_list.pop(i)
def burn_key(esp, efuses, args, digest=None):
if digest is None:
datafile_list = args.keyfile[
0 : len([name for name in args.keyfile if name is not None]) :
]
else:
datafile_list = digest[0 : len([name for name in digest if name is not None]) :]
efuses.force_write_always = args.force_write_always
block_name_list = args.block[
0 : len([name for name in args.block if name is not None]) :
]
keypurpose_list = args.keypurpose[
0 : len([name for name in args.keypurpose if name is not None]) :
]
if "XTS_AES_256_KEY" in keypurpose_list:
# XTS_AES_256_KEY is not an actual HW key purpose, needs to be split into
# XTS_AES_256_KEY_1 and XTS_AES_256_KEY_2
split_512_bit_key(efuses, block_name_list, datafile_list, keypurpose_list)
util.check_duplicate_name_in_list(block_name_list)
if len(block_name_list) != len(datafile_list) or len(block_name_list) != len(
keypurpose_list
):
raise esptool.FatalError(
"The number of blocks (%d), datafile (%d) and keypurpose (%d) "
"should be the same."
% (len(block_name_list), len(datafile_list), len(keypurpose_list))
)
print("Burn keys to blocks:")
for block_name, datafile, keypurpose in zip(
block_name_list, datafile_list, keypurpose_list
):
efuse = None
for block in efuses.blocks:
if block_name == block.name or block_name in block.alias:
efuse = efuses[block.name]
if efuse is None:
raise esptool.FatalError("Unknown block name - %s" % (block_name))
num_bytes = efuse.bit_len // 8
block_num = efuses.get_index_block_by_name(block_name)
block = efuses.blocks[block_num]
if digest is None:
data = datafile.read()
else:
data = datafile
print(" - %s" % (efuse.name), end=" ")
revers_msg = None
if efuses[block.key_purpose_name].need_reverse(keypurpose):
revers_msg = "\tReversing byte order for AES-XTS hardware peripheral"
data = data[::-1]
print(
"-> [{}]".format(
util.hexify(data, " ")
if args.show_sensitive_info
else " ".join(["??"] * len(data))
)
)
if revers_msg:
print(revers_msg)
if len(data) != num_bytes:
raise esptool.FatalError(
"Incorrect key file size %d. Key file must be %d bytes (%d bits) "
"of raw binary key data." % (len(data), num_bytes, num_bytes * 8)
)
if efuses[block.key_purpose_name].need_rd_protect(keypurpose):
read_protect = False if args.no_read_protect else True
else:
read_protect = False
write_protect = not args.no_write_protect
# using efuse instead of a block gives the advantage of
# checking it as the whole field.
efuse.save(data)
disable_wr_protect_key_purpose = False
if efuses[block.key_purpose_name].get() != keypurpose:
if efuses[block.key_purpose_name].is_writeable():
print(
"\t'%s': '%s' -> '%s'."
% (
block.key_purpose_name,
efuses[block.key_purpose_name].get(),
keypurpose,
)
)
efuses[block.key_purpose_name].save(keypurpose)
disable_wr_protect_key_purpose = True
else:
raise esptool.FatalError(
"It is not possible to change '%s' to '%s' because "
"write protection bit is set."
% (block.key_purpose_name, keypurpose)
)
else:
print("\t'%s' is already '%s'." % (block.key_purpose_name, keypurpose))
if efuses[block.key_purpose_name].is_writeable():
disable_wr_protect_key_purpose = True
if disable_wr_protect_key_purpose:
print("\tDisabling write to '%s'." % block.key_purpose_name)
efuses[block.key_purpose_name].disable_write()
if read_protect:
print("\tDisabling read to key block")
efuse.disable_read()
if write_protect:
print("\tDisabling write to key block")
efuse.disable_write()
print("")
if not write_protect:
print("Keys will remain writeable (due to --no-write-protect)")
if args.no_read_protect:
print("Keys will remain readable (due to --no-read-protect)")
if not efuses.burn_all(check_batch_mode=True):
return
print("Successful")
def burn_key_digest(esp, efuses, args):
digest_list = []
datafile_list = args.keyfile[
0 : len([name for name in args.keyfile if name is not None]) :
]
block_list = args.block[
0 : len([block for block in args.block if block is not None]) :
]
for block_name, datafile in zip(block_list, datafile_list):
efuse = None
for block in efuses.blocks:
if block_name == block.name or block_name in block.alias:
efuse = efuses[block.name]
if efuse is None:
raise esptool.FatalError("Unknown block name - %s" % (block_name))
num_bytes = efuse.bit_len // 8
digest = espsecure._digest_sbv2_public_key(datafile)
if len(digest) != num_bytes:
raise esptool.FatalError(
"Incorrect digest size %d. Digest must be %d bytes (%d bits) "
"of raw binary key data." % (len(digest), num_bytes, num_bytes * 8)
)
digest_list.append(digest)
burn_key(esp, efuses, args, digest=digest_list)
def espefuse(esp, efuses, args, command):
parser = argparse.ArgumentParser()
subparsers = parser.add_subparsers(dest="operation")
add_commands(subparsers, efuses)
try:
cmd_line_args = parser.parse_args(command.split())
except SystemExit:
traceback.print_stack()
raise esptool.FatalError('"{}" - incorrect command'.format(command))
if cmd_line_args.operation == "execute_scripts":
configfiles = cmd_line_args.configfiles
index = cmd_line_args.index
# copy arguments from args to cmd_line_args
vars(cmd_line_args).update(vars(args))
if cmd_line_args.operation == "execute_scripts":
cmd_line_args.configfiles = configfiles
cmd_line_args.index = index
if cmd_line_args.operation is None:
parser.print_help()
parser.exit(1)
operation_func = globals()[cmd_line_args.operation]
# each 'operation' is a module-level function of the same name
operation_func(esp, efuses, cmd_line_args)
def execute_scripts(esp, efuses, args):
efuses.batch_mode_cnt += 1
del args.operation
scripts = args.scripts
del args.scripts
for file in scripts:
with open(file.name, "r") as file:
exec(compile(file.read(), file.name, "exec"))
if args.debug:
for block in efuses.blocks:
data = block.get_bitstring(from_read=False)
block.print_block(data, "regs_for_burn", args.debug)
efuses.batch_mode_cnt -= 1
if not efuses.burn_all(check_batch_mode=True):
return
print("Successful")
| 18,946 | Python | .py | 455 | 33.087912 | 93 | 0.609395 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,670 | fields.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32s3/fields.py | # This file describes eFuses for ESP32-S3 chip
#
# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import binascii
import struct
import time
from bitstring import BitArray
import esptool
import reedsolo
from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters
from .. import base_fields
from .. import util
class EfuseBlock(base_fields.EfuseBlockBase):
def len_of_burn_unit(self):
# The writing register window is 8 registers for any blocks.
# len in bytes
return 8 * 4
def __init__(self, parent, param, skip_read=False):
parent.read_coding_scheme()
super(EfuseBlock, self).__init__(parent, param, skip_read=skip_read)
def apply_coding_scheme(self):
data = self.get_raw(from_read=False)[::-1]
if len(data) < self.len_of_burn_unit():
add_empty_bytes = self.len_of_burn_unit() - len(data)
data = data + (b"\x00" * add_empty_bytes)
if self.get_coding_scheme() == self.parent.REGS.CODING_SCHEME_RS:
# takes 32 bytes
# apply RS encoding
rs = reedsolo.RSCodec(12)
# 32 byte of data + 12 bytes RS
encoded_data = rs.encode([x for x in data])
words = struct.unpack("<" + "I" * 11, encoded_data)
# returns 11 words (8 words of data + 3 words of RS coding)
else:
# takes 32 bytes
words = struct.unpack("<" + ("I" * (len(data) // 4)), data)
# returns 8 words
return words
class EspEfuses(base_fields.EspEfusesBase):
"""
Wrapper object to manage the efuse fields in a connected ESP bootloader
"""
debug = False
do_not_confirm = False
def __init__(self, esp, skip_connect=False, debug=False, do_not_confirm=False):
self.Blocks = EfuseDefineBlocks()
self.Fields = EfuseDefineFields()
self.REGS = EfuseDefineRegisters
self.BURN_BLOCK_DATA_NAMES = self.Blocks.get_burn_block_data_names()
self.BLOCKS_FOR_KEYS = self.Blocks.get_blocks_for_keys()
self._esp = esp
self.debug = debug
self.do_not_confirm = do_not_confirm
if esp.CHIP_NAME != "ESP32-S3":
raise esptool.FatalError(
"Expected the 'esp' param for ESP32-S3 chip but got for '%s'."
% (esp.CHIP_NAME)
)
if not skip_connect:
flags = self._esp.get_security_info()["flags"]
GET_SECURITY_INFO_FLAG_SECURE_DOWNLOAD_ENABLE = 1 << 2
if flags & GET_SECURITY_INFO_FLAG_SECURE_DOWNLOAD_ENABLE:
raise esptool.FatalError(
"Secure Download Mode is enabled. The tool can not read eFuses."
)
self.blocks = [
EfuseBlock(self, self.Blocks.get(block), skip_read=skip_connect)
for block in self.Blocks.BLOCKS
]
if not skip_connect:
self.get_coding_scheme_warnings()
self.efuses = [EfuseField.convert(self, efuse) for efuse in self.Fields.EFUSES]
self.efuses += [
EfuseField.convert(self, efuse) for efuse in self.Fields.KEYBLOCKS
]
if skip_connect:
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
]
else:
if self["BLK_VERSION_MAJOR"].get() == 1:
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
]
self.efuses += [
EfuseField.convert(self, efuse) for efuse in self.Fields.CALC
]
def __getitem__(self, efuse_name):
"""Return the efuse field with the given name"""
for e in self.efuses:
if efuse_name == e.name or any(x == efuse_name for x in e.alt_names):
return e
new_fields = False
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES:
if efuse.name == efuse_name or any(
x == efuse_name for x in efuse.alt_names
):
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
]
new_fields = True
if new_fields:
for e in self.efuses:
if efuse_name == e.name or any(x == efuse_name for x in e.alt_names):
return e
raise KeyError
def read_coding_scheme(self):
self.coding_scheme = self.REGS.CODING_SCHEME_RS
def print_status_regs(self):
print("")
self.blocks[0].print_block(self.blocks[0].err_bitarray, "err__regs", debug=True)
print(
"{:27} 0x{:08x}".format(
"EFUSE_RD_RS_ERR0_REG", self.read_reg(self.REGS.EFUSE_RD_RS_ERR0_REG)
)
)
print(
"{:27} 0x{:08x}".format(
"EFUSE_RD_RS_ERR1_REG", self.read_reg(self.REGS.EFUSE_RD_RS_ERR1_REG)
)
)
def efuse_controller_setup(self):
self.set_efuse_timing()
self.clear_pgm_registers()
self.wait_efuse_idle()
def write_efuses(self, block):
self.efuse_program(block)
return self.get_coding_scheme_warnings(silent=True)
def clear_pgm_registers(self):
self.wait_efuse_idle()
for r in range(
self.REGS.EFUSE_PGM_DATA0_REG, self.REGS.EFUSE_PGM_DATA0_REG + 32, 4
):
self.write_reg(r, 0)
def wait_efuse_idle(self):
deadline = time.time() + self.REGS.EFUSE_BURN_TIMEOUT
while time.time() < deadline:
# if self.read_reg(self.EFUSE_CMD_REG) == 0:
if self.read_reg(self.REGS.EFUSE_STATUS_REG) & 0x7 == 1:
return
raise esptool.FatalError(
"Timed out waiting for Efuse controller command to complete"
)
def efuse_program(self, block):
self.wait_efuse_idle()
self.write_reg(self.REGS.EFUSE_CONF_REG, self.REGS.EFUSE_WRITE_OP_CODE)
self.write_reg(self.REGS.EFUSE_CMD_REG, self.REGS.EFUSE_PGM_CMD | (block << 2))
self.wait_efuse_idle()
self.clear_pgm_registers()
self.efuse_read()
def efuse_read(self):
self.wait_efuse_idle()
self.write_reg(self.REGS.EFUSE_CONF_REG, self.REGS.EFUSE_READ_OP_CODE)
# need to add a delay after triggering EFUSE_READ_CMD, as ROM loader checks some
# efuse registers after each command is completed
# if ENABLE_SECURITY_DOWNLOAD or DIS_DOWNLOAD_MODE is enabled by the current cmd, then we need to try to reconnect to the chip.
try:
self.write_reg(
self.REGS.EFUSE_CMD_REG, self.REGS.EFUSE_READ_CMD, delay_after_us=1000
)
self.wait_efuse_idle()
except esptool.FatalError:
secure_download_mode_before = self._esp.secure_download_mode
try:
self._esp = self.reconnect_chip(self._esp)
except esptool.FatalError:
print("Can not re-connect to the chip")
if not self["DIS_DOWNLOAD_MODE"].get() and self[
"DIS_DOWNLOAD_MODE"
].get(from_read=False):
print(
"This is the correct behavior as we are actually burning "
"DIS_DOWNLOAD_MODE which disables the connection to the chip"
)
print("DIS_DOWNLOAD_MODE is enabled")
print("Successful")
exit(0) # finish without errors
raise
print("Established a connection with the chip")
if self._esp.secure_download_mode and not secure_download_mode_before:
print("Secure download mode is enabled")
if not self["ENABLE_SECURITY_DOWNLOAD"].get() and self[
"ENABLE_SECURITY_DOWNLOAD"
].get(from_read=False):
print(
"espefuse tool can not continue to work in Secure download mode"
)
print("ENABLE_SECURITY_DOWNLOAD is enabled")
print("Successful")
exit(0) # finish without errors
raise
def set_efuse_timing(self):
"""Set timing registers for burning efuses"""
# Configure clock
apb_freq = self.get_crystal_freq()
if apb_freq != 40:
raise esptool.FatalError(
"The eFuse supports only xtal=40M (xtal was %d)" % apb_freq
)
self.update_reg(self.REGS.EFUSE_DAC_CONF_REG, self.REGS.EFUSE_DAC_NUM_M, 0xFF)
self.update_reg(
self.REGS.EFUSE_DAC_CONF_REG, self.REGS.EFUSE_DAC_CLK_DIV_M, 0x28
)
self.update_reg(
self.REGS.EFUSE_WR_TIM_CONF1_REG, self.REGS.EFUSE_PWR_ON_NUM_M, 0x3000
)
self.update_reg(
self.REGS.EFUSE_WR_TIM_CONF2_REG, self.REGS.EFUSE_PWR_OFF_NUM_M, 0x190
)
def get_coding_scheme_warnings(self, silent=False):
"""Check if the coding scheme has detected any errors."""
old_addr_reg = 0
reg_value = 0
ret_fail = False
for block in self.blocks:
if block.id == 0:
words = [
self.read_reg(self.REGS.EFUSE_RD_REPEAT_ERR0_REG + offs * 4)
for offs in range(5)
]
block.err_bitarray.pos = 0
for word in reversed(words):
block.err_bitarray.overwrite(BitArray("uint:32=%d" % word))
block.num_errors = block.err_bitarray.count(True)
block.fail = block.num_errors != 0
else:
addr_reg, err_num_mask, err_num_offs, fail_bit = self.REGS.BLOCK_ERRORS[
block.id
]
if err_num_mask is None or err_num_offs is None or fail_bit is None:
continue
if addr_reg != old_addr_reg:
old_addr_reg = addr_reg
reg_value = self.read_reg(addr_reg)
block.fail = reg_value & (1 << fail_bit) != 0
block.num_errors = (reg_value >> err_num_offs) & err_num_mask
ret_fail |= block.fail
if not silent and (block.fail or block.num_errors):
print(
"Error(s) in BLOCK%d [ERRORS:%d FAIL:%d]"
% (block.id, block.num_errors, block.fail)
)
if (self.debug or ret_fail) and not silent:
self.print_status_regs()
return ret_fail
def summary(self):
if self["VDD_SPI_FORCE"].get() == 0:
output = "Flash voltage (VDD_SPI) determined by GPIO45 on reset "
output += "(GPIO45=High: VDD_SPI pin is powered from internal 1.8V LDO\n"
output += "GPIO45=Low or NC: VDD_SPI pin is powered directly from "
output += "VDD3P3_RTC_IO via resistor Rspi. "
output += "Typically this voltage is 3.3 V)."
elif self["VDD_SPI_XPD"].get() == 0:
output = "Flash voltage (VDD_SPI) internal regulator disabled by efuse."
elif self["VDD_SPI_TIEH"].get() == 0:
output = "Flash voltage (VDD_SPI) set to 1.8V by efuse."
else:
output = "Flash voltage (VDD_SPI) set to 3.3V by efuse."
return output
class EfuseField(base_fields.EfuseFieldBase):
@staticmethod
def convert(parent, efuse):
return {
"mac": EfuseMacField,
"keypurpose": EfuseKeyPurposeField,
"t_sensor": EfuseTempSensor,
"adc_tp": EfuseAdcPointCalibration,
"wafer": EfuseWafer,
}.get(efuse.class_type, EfuseField)(parent, efuse)
class EfuseWafer(EfuseField):
def get(self, from_read=True):
hi_bits = self.parent["WAFER_VERSION_MINOR_HI"].get(from_read)
assert self.parent["WAFER_VERSION_MINOR_HI"].bit_len == 1
lo_bits = self.parent["WAFER_VERSION_MINOR_LO"].get(from_read)
assert self.parent["WAFER_VERSION_MINOR_LO"].bit_len == 3
return (hi_bits << 3) + lo_bits
def save(self, new_value):
raise esptool.FatalError("Burning %s is not supported" % self.name)
class EfuseTempSensor(EfuseField):
def get(self, from_read=True):
value = self.get_bitstring(from_read)
sig = -1 if value[0] else 1
return sig * value[1:].uint * 0.1
class EfuseAdcPointCalibration(EfuseField):
def get(self, from_read=True):
STEP_SIZE = 4
value = self.get_bitstring(from_read)
sig = -1 if value[0] else 1
return sig * value[1:].uint * STEP_SIZE
class EfuseMacField(EfuseField):
def check_format(self, new_value_str):
if new_value_str is None:
raise esptool.FatalError(
"Required MAC Address in AA:CD:EF:01:02:03 format!"
)
if new_value_str.count(":") != 5:
raise esptool.FatalError(
"MAC Address needs to be a 6-byte hexadecimal format "
"separated by colons (:)!"
)
hexad = new_value_str.replace(":", "")
if len(hexad) != 12:
raise esptool.FatalError(
"MAC Address needs to be a 6-byte hexadecimal number "
"(12 hexadecimal characters)!"
)
# order of bytearray = b'\xaa\xcd\xef\x01\x02\x03',
bindata = binascii.unhexlify(hexad)
# unicast address check according to
# https://tools.ietf.org/html/rfc7042#section-2.1
if esptool.util.byte(bindata, 0) & 0x01:
raise esptool.FatalError("Custom MAC must be a unicast MAC!")
return bindata
def check(self):
errs, fail = self.parent.get_block_errors(self.block)
if errs != 0 or fail:
output = "Block%d has ERRORS:%d FAIL:%d" % (self.block, errs, fail)
else:
output = "OK"
return "(" + output + ")"
def get(self, from_read=True):
if self.name == "CUSTOM_MAC":
mac = self.get_raw(from_read)[::-1]
else:
mac = self.get_raw(from_read)
return "%s %s" % (util.hexify(mac, ":"), self.check())
def save(self, new_value):
def print_field(e, new_value):
print(
" - '{}' ({}) {} -> {}".format(
e.name, e.description, e.get_bitstring(), new_value
)
)
if self.name == "CUSTOM_MAC":
bitarray_mac = self.convert_to_bitstring(new_value)
print_field(self, bitarray_mac)
super(EfuseMacField, self).save(new_value)
else:
# Writing the BLOCK1 (MAC_SPI_8M_0) default MAC is not sensible,
# as it's written in the factory.
raise esptool.FatalError("Writing Factory MAC address is not supported")
# fmt: off
class EfuseKeyPurposeField(EfuseField):
KEY_PURPOSES = [
("USER", 0, None, None, "no_need_rd_protect"), # User purposes (software-only use)
("RESERVED", 1, None, None, "no_need_rd_protect"), # Reserved
("XTS_AES_256_KEY_1", 2, None, "Reverse", "need_rd_protect"), # XTS_AES_256_KEY_1 (flash/PSRAM encryption)
("XTS_AES_256_KEY_2", 3, None, "Reverse", "need_rd_protect"), # XTS_AES_256_KEY_2 (flash/PSRAM encryption)
("XTS_AES_128_KEY", 4, None, "Reverse", "need_rd_protect"), # XTS_AES_128_KEY (flash/PSRAM encryption)
("HMAC_DOWN_ALL", 5, None, None, "need_rd_protect"), # HMAC Downstream mode
("HMAC_DOWN_JTAG", 6, None, None, "need_rd_protect"), # JTAG soft enable key (uses HMAC Downstream mode)
("HMAC_DOWN_DIGITAL_SIGNATURE", 7, None, None, "need_rd_protect"), # Digital Signature peripheral key (uses HMAC Downstream mode)
("HMAC_UP", 8, None, None, "need_rd_protect"), # HMAC Upstream mode
("SECURE_BOOT_DIGEST0", 9, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST0 (Secure Boot key digest)
("SECURE_BOOT_DIGEST1", 10, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST1 (Secure Boot key digest)
("SECURE_BOOT_DIGEST2", 11, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST2 (Secure Boot key digest)
("XTS_AES_256_KEY", -1, "VIRTUAL", None, "no_need_rd_protect"), # Virtual purpose splits to XTS_AES_256_KEY_1 and XTS_AES_256_KEY_2
]
# fmt: on
KEY_PURPOSES_NAME = [name[0] for name in KEY_PURPOSES]
DIGEST_KEY_PURPOSES = [name[0] for name in KEY_PURPOSES if name[2] == "DIGEST"]
def check_format(self, new_value_str):
# str convert to int: "XTS_AES_128_KEY" - > str(4)
# if int: 4 -> str(4)
raw_val = new_value_str
for purpose_name in self.KEY_PURPOSES:
if purpose_name[0] == new_value_str:
raw_val = str(purpose_name[1])
break
if raw_val.isdigit():
if int(raw_val) not in [p[1] for p in self.KEY_PURPOSES if p[1] > 0]:
raise esptool.FatalError("'%s' can not be set (value out of range)" % raw_val)
else:
raise esptool.FatalError("'%s' unknown name" % raw_val)
return raw_val
def need_reverse(self, new_key_purpose):
for key in self.KEY_PURPOSES:
if key[0] == new_key_purpose:
return key[3] == "Reverse"
def need_rd_protect(self, new_key_purpose):
for key in self.KEY_PURPOSES:
if key[0] == new_key_purpose:
return key[4] == "need_rd_protect"
def get(self, from_read=True):
for p in self.KEY_PURPOSES:
if p[1] == self.get_raw(from_read):
return p[0]
return "FORBIDDEN_STATE"
def get_name(self, raw_val):
for key in self.KEY_PURPOSES:
if key[1] == raw_val:
return key[0]
def save(self, new_value):
raw_val = int(self.check_format(str(new_value)))
str_new_value = self.get_name(raw_val)
if self.name == "KEY_PURPOSE_5" and str_new_value.startswith("XTS_AES"):
raise esptool.FatalError(f"{self.name} can not have {str_new_value} key due to a hardware bug (please see TRM for more details)")
return super(EfuseKeyPurposeField, self).save(raw_val)
| 18,884 | Python | .py | 403 | 35.575682 | 160 | 0.56525 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,671 | mem_definition.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32s3/mem_definition.py | # This file describes eFuses fields and registers for ESP32-S3 chip
#
# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import os
import yaml
from ..mem_definition_base import (
EfuseBlocksBase,
EfuseFieldsBase,
EfuseRegistersBase,
Field,
)
class EfuseDefineRegisters(EfuseRegistersBase):
EFUSE_ADDR_MASK = 0x00000FFF
EFUSE_MEM_SIZE = 0x01FC + 4
# EFUSE registers & command/conf values
DR_REG_EFUSE_BASE = 0x60007000
EFUSE_PGM_DATA0_REG = DR_REG_EFUSE_BASE
EFUSE_CHECK_VALUE0_REG = DR_REG_EFUSE_BASE + 0x020
EFUSE_CLK_REG = DR_REG_EFUSE_BASE + 0x1C8
EFUSE_CONF_REG = DR_REG_EFUSE_BASE + 0x1CC
EFUSE_STATUS_REG = DR_REG_EFUSE_BASE + 0x1D0
EFUSE_CMD_REG = DR_REG_EFUSE_BASE + 0x1D4
EFUSE_RD_RS_ERR0_REG = DR_REG_EFUSE_BASE + 0x1C0
EFUSE_RD_RS_ERR1_REG = DR_REG_EFUSE_BASE + 0x1C4
EFUSE_RD_REPEAT_ERR0_REG = DR_REG_EFUSE_BASE + 0x17C
EFUSE_RD_REPEAT_ERR1_REG = DR_REG_EFUSE_BASE + 0x180
EFUSE_RD_REPEAT_ERR2_REG = DR_REG_EFUSE_BASE + 0x184
EFUSE_RD_REPEAT_ERR3_REG = DR_REG_EFUSE_BASE + 0x188
EFUSE_RD_REPEAT_ERR4_REG = DR_REG_EFUSE_BASE + 0x18C
EFUSE_DAC_CONF_REG = DR_REG_EFUSE_BASE + 0x1E8
EFUSE_RD_TIM_CONF_REG = DR_REG_EFUSE_BASE + 0x1EC
EFUSE_WR_TIM_CONF1_REG = DR_REG_EFUSE_BASE + 0x1F4
EFUSE_WR_TIM_CONF2_REG = DR_REG_EFUSE_BASE + 0x1F8
EFUSE_DATE_REG = DR_REG_EFUSE_BASE + 0x1FC
EFUSE_WRITE_OP_CODE = 0x5A5A
EFUSE_READ_OP_CODE = 0x5AA5
EFUSE_PGM_CMD_MASK = 0x3
EFUSE_PGM_CMD = 0x2
EFUSE_READ_CMD = 0x1
BLOCK_ERRORS = [
# error_reg, err_num_mask, err_num_offs, fail_bit
(EFUSE_RD_REPEAT_ERR0_REG, None, None, None), # BLOCK0
(EFUSE_RD_RS_ERR0_REG, 0x7, 0, 3), # MAC_SPI_8M_0
(EFUSE_RD_RS_ERR0_REG, 0x7, 4, 7), # BLOCK_SYS_DATA
(EFUSE_RD_RS_ERR0_REG, 0x7, 8, 11), # BLOCK_USR_DATA
(EFUSE_RD_RS_ERR0_REG, 0x7, 12, 15), # BLOCK_KEY0
(EFUSE_RD_RS_ERR0_REG, 0x7, 16, 19), # BLOCK_KEY1
(EFUSE_RD_RS_ERR0_REG, 0x7, 20, 23), # BLOCK_KEY2
(EFUSE_RD_RS_ERR0_REG, 0x7, 24, 27), # BLOCK_KEY3
(EFUSE_RD_RS_ERR0_REG, 0x7, 28, 31), # BLOCK_KEY4
(EFUSE_RD_RS_ERR1_REG, 0x7, 0, 3), # BLOCK_KEY5
(EFUSE_RD_RS_ERR1_REG, 0x7, 4, 7), # BLOCK_SYS_DATA2
]
# EFUSE_WR_TIM_CONF2_REG
EFUSE_PWR_OFF_NUM_S = 0
EFUSE_PWR_OFF_NUM_M = 0xFFFF << EFUSE_PWR_OFF_NUM_S
# EFUSE_WR_TIM_CONF1_REG
EFUSE_PWR_ON_NUM_S = 8
EFUSE_PWR_ON_NUM_M = 0x0000FFFF << EFUSE_PWR_ON_NUM_S
# EFUSE_DAC_CONF_REG
EFUSE_DAC_CLK_DIV_S = 0
EFUSE_DAC_CLK_DIV_M = 0xFF << EFUSE_DAC_CLK_DIV_S
# EFUSE_DAC_CONF_REG
EFUSE_DAC_NUM_S = 9
EFUSE_DAC_NUM_M = 0xFF << EFUSE_DAC_NUM_S
class EfuseDefineBlocks(EfuseBlocksBase):
__base_rd_regs = EfuseDefineRegisters.DR_REG_EFUSE_BASE
__base_wr_regs = EfuseDefineRegisters.EFUSE_PGM_DATA0_REG
# List of efuse blocks
# fmt: off
BLOCKS = [
# Name, Alias, Index, Read address, Write address, Write protect bit, Read protect bit, Len, key_purpose
("BLOCK0", [], 0, __base_rd_regs + 0x02C, __base_wr_regs, None, None, 6, None),
("MAC_SPI_8M_0", ["BLOCK1"], 1, __base_rd_regs + 0x044, __base_wr_regs, 20, None, 6, None),
("BLOCK_SYS_DATA", ["BLOCK2"], 2, __base_rd_regs + 0x05C, __base_wr_regs, 21, None, 8, None),
("BLOCK_USR_DATA", ["BLOCK3"], 3, __base_rd_regs + 0x07C, __base_wr_regs, 22, None, 8, None),
("BLOCK_KEY0", ["BLOCK4"], 4, __base_rd_regs + 0x09C, __base_wr_regs, 23, 0, 8, "KEY_PURPOSE_0"),
("BLOCK_KEY1", ["BLOCK5"], 5, __base_rd_regs + 0x0BC, __base_wr_regs, 24, 1, 8, "KEY_PURPOSE_1"),
("BLOCK_KEY2", ["BLOCK6"], 6, __base_rd_regs + 0x0DC, __base_wr_regs, 25, 2, 8, "KEY_PURPOSE_2"),
("BLOCK_KEY3", ["BLOCK7"], 7, __base_rd_regs + 0x0FC, __base_wr_regs, 26, 3, 8, "KEY_PURPOSE_3"),
("BLOCK_KEY4", ["BLOCK8"], 8, __base_rd_regs + 0x11C, __base_wr_regs, 27, 4, 8, "KEY_PURPOSE_4"),
("BLOCK_KEY5", ["BLOCK9"], 9, __base_rd_regs + 0x13C, __base_wr_regs, 28, 5, 8, "KEY_PURPOSE_5"),
("BLOCK_SYS_DATA2", ["BLOCK10"], 10, __base_rd_regs + 0x15C, __base_wr_regs, 29, 6, 8, None),
]
# fmt: on
def get_burn_block_data_names(self):
list_of_names = []
for block in self.BLOCKS:
blk = self.get(block)
if blk.name:
list_of_names.append(blk.name)
if blk.alias:
for alias in blk.alias:
list_of_names.append(alias)
return list_of_names
class EfuseDefineFields(EfuseFieldsBase):
def __init__(self) -> None:
# List of efuse fields from TRM the chapter eFuse Controller.
self.EFUSES = []
self.KEYBLOCKS = []
# if BLK_VERSION_MAJOR is 1, these efuse fields are in BLOCK2
self.BLOCK2_CALIBRATION_EFUSES = []
self.CALC = []
dir_name = os.path.dirname(os.path.abspath(__file__))
dir_name, file_name = os.path.split(dir_name)
file_name = file_name + ".yaml"
dir_name, _ = os.path.split(dir_name)
efuse_file = os.path.join(dir_name, "efuse_defs", file_name)
with open(f"{efuse_file}", "r") as r_file:
e_desc = yaml.safe_load(r_file)
super().__init__(e_desc)
for i, efuse in enumerate(self.ALL_EFUSES):
if efuse.name in [
"BLOCK_USR_DATA",
"BLOCK_KEY0",
"BLOCK_KEY1",
"BLOCK_KEY2",
"BLOCK_KEY3",
"BLOCK_KEY4",
"BLOCK_KEY5",
"BLOCK_SYS_DATA2",
]:
if efuse.name == "BLOCK_USR_DATA":
efuse.bit_len = 256
efuse.type = "bytes:32"
self.KEYBLOCKS.append(efuse)
self.ALL_EFUSES[i] = None
elif efuse.category == "calibration":
self.BLOCK2_CALIBRATION_EFUSES.append(efuse)
self.ALL_EFUSES[i] = None
f = Field()
f.name = "WAFER_VERSION_MINOR"
f.block = 0
f.bit_len = 4
f.type = f"uint:{f.bit_len}"
f.category = "identity"
f.class_type = "wafer"
f.description = "calc WAFER VERSION MINOR = WAFER_VERSION_MINOR_HI << 3 + WAFER_VERSION_MINOR_LO (read only)"
self.CALC.append(f)
for efuse in self.ALL_EFUSES:
if efuse is not None:
self.EFUSES.append(efuse)
self.ALL_EFUSES = []
| 6,737 | Python | .py | 145 | 38.089655 | 139 | 0.574844 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,672 | emulate_efuse_controller.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32h2/emulate_efuse_controller.py | # This file describes eFuses controller for ESP32-H2 chip
#
# SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import reedsolo
from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters
from ..emulate_efuse_controller_base import EmulateEfuseControllerBase, FatalError
class EmulateEfuseController(EmulateEfuseControllerBase):
"""The class for virtual efuse operation. Using for HOST_TEST."""
CHIP_NAME = "ESP32-H2"
mem = None
debug = False
def __init__(self, efuse_file=None, debug=False):
self.Blocks = EfuseDefineBlocks
self.Fields = EfuseDefineFields()
self.REGS = EfuseDefineRegisters
super(EmulateEfuseController, self).__init__(efuse_file, debug)
self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
""" esptool method start >>"""
def get_major_chip_version(self):
return 0
def get_minor_chip_version(self):
return 0
def get_crystal_freq(self):
return 32 # MHz
def get_security_info(self):
return {
"flags": 0,
"flash_crypt_cnt": 0,
"key_purposes": 0,
"chip_id": 0,
"api_version": 0,
}
""" << esptool method end """
def handle_writing_event(self, addr, value):
if addr == self.REGS.EFUSE_CMD_REG:
if value & self.REGS.EFUSE_PGM_CMD:
self.copy_blocks_wr_regs_to_rd_regs(updated_block=(value >> 2) & 0xF)
self.clean_blocks_wr_regs()
self.check_rd_protection_area()
self.write_reg(addr, 0)
self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
elif value == self.REGS.EFUSE_READ_CMD:
self.write_reg(addr, 0)
self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
self.save_to_file()
def get_bitlen_of_block(self, blk, wr=False):
if blk.id == 0:
if wr:
return 32 * 8
else:
return 32 * blk.len
else:
if wr:
rs_coding = 32 * 3
return 32 * 8 + rs_coding
else:
return 32 * blk.len
def handle_coding_scheme(self, blk, data):
if blk.id != 0:
# CODING_SCHEME RS applied only for all blocks except BLK0.
coded_bytes = 12
data.pos = coded_bytes * 8
plain_data = data.readlist("32*uint:8")[::-1]
# takes 32 bytes
# apply RS encoding
rs = reedsolo.RSCodec(coded_bytes)
# 32 byte of data + 12 bytes RS
calc_encoded_data = list(rs.encode([x for x in plain_data]))
data.pos = 0
if calc_encoded_data != data.readlist("44*uint:8")[::-1]:
raise FatalError("Error in coding scheme data")
data = data[coded_bytes * 8 :]
if blk.len < 8:
data = data[(8 - blk.len) * 32 :]
return data
| 3,044 | Python | .py | 77 | 29.298701 | 86 | 0.574187 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,673 | __init__.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32h2/__init__.py | from . import operations
from .emulate_efuse_controller import EmulateEfuseController
from .fields import EspEfuses
| 116 | Python | .py | 3 | 37.666667 | 60 | 0.876106 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,674 | operations.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32h2/operations.py | # This file includes the operations with eFuses for ESP32-H2 chip
#
# SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import argparse
import os # noqa: F401. It is used in IDF scripts
import traceback
import espsecure
import esptool
from . import fields
from .. import util
from ..base_operations import (
add_common_commands,
add_force_write_always,
add_show_sensitive_info_option,
burn_bit,
burn_block_data,
burn_efuse,
check_error,
dump,
read_protect_efuse,
summary,
write_protect_efuse,
)
def protect_options(p):
p.add_argument(
"--no-write-protect",
help="Disable write-protecting of the key. The key remains writable. "
"(The keys use the RS coding scheme that does not support "
"post-write data changes. Forced write can damage RS encoding bits.) "
"The write-protecting of keypurposes does not depend on the option, "
"it will be set anyway.",
action="store_true",
)
p.add_argument(
"--no-read-protect",
help="Disable read-protecting of the key. The key remains readable software."
"The key with keypurpose[USER, RESERVED and *_DIGEST] "
"will remain readable anyway. For the rest keypurposes the read-protection "
"will be defined the option (Read-protect by default).",
action="store_true",
)
def add_commands(subparsers, efuses):
add_common_commands(subparsers, efuses)
burn_key = subparsers.add_parser(
"burn_key", help="Burn the key block with the specified name"
)
protect_options(burn_key)
add_force_write_always(burn_key)
add_show_sensitive_info_option(burn_key)
burn_key.add_argument(
"block",
help="Key block to burn",
action="append",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key.add_argument(
"keyfile",
help="File containing 256 bits of binary key data. For the ECDSA_KEY purpose use PEM file.",
action="append",
type=argparse.FileType("rb"),
)
burn_key.add_argument(
"keypurpose",
help="Purpose to set.",
action="append",
choices=fields.EfuseKeyPurposeField.KEY_PURPOSES_NAME,
)
for _ in efuses.BLOCKS_FOR_KEYS:
burn_key.add_argument(
"block",
help="Key block to burn",
nargs="?",
action="append",
metavar="BLOCK",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key.add_argument(
"keyfile",
help="File containing 256 bits of binary key data. For the ECDSA_KEY purpose use PEM file.",
nargs="?",
action="append",
metavar="KEYFILE",
type=argparse.FileType("rb"),
)
burn_key.add_argument(
"keypurpose",
help="Purpose to set.",
nargs="?",
action="append",
metavar="KEYPURPOSE",
choices=fields.EfuseKeyPurposeField.KEY_PURPOSES_NAME,
)
burn_key_digest = subparsers.add_parser(
"burn_key_digest",
help="Parse a RSA public key and burn the digest to key efuse block",
)
protect_options(burn_key_digest)
add_force_write_always(burn_key_digest)
add_show_sensitive_info_option(burn_key_digest)
burn_key_digest.add_argument(
"block",
help="Key block to burn",
action="append",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key_digest.add_argument(
"keyfile",
help="Key file to digest (PEM format)",
action="append",
type=argparse.FileType("rb"),
)
burn_key_digest.add_argument(
"keypurpose",
help="Purpose to set.",
action="append",
choices=fields.EfuseKeyPurposeField.DIGEST_KEY_PURPOSES,
)
for _ in efuses.BLOCKS_FOR_KEYS:
burn_key_digest.add_argument(
"block",
help="Key block to burn",
nargs="?",
action="append",
metavar="BLOCK",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key_digest.add_argument(
"keyfile",
help="Key file to digest (PEM format)",
nargs="?",
action="append",
metavar="KEYFILE",
type=argparse.FileType("rb"),
)
burn_key_digest.add_argument(
"keypurpose",
help="Purpose to set.",
nargs="?",
action="append",
metavar="KEYPURPOSE",
choices=fields.EfuseKeyPurposeField.DIGEST_KEY_PURPOSES,
)
p = subparsers.add_parser(
"set_flash_voltage",
help="Permanently set the internal flash voltage regulator "
"to either 1.8V, 3.3V or OFF. This means GPIO45 can be high or low "
"at reset without changing the flash voltage.",
)
p.add_argument("voltage", help="Voltage selection", choices=["1.8V", "3.3V", "OFF"])
p = subparsers.add_parser(
"burn_custom_mac", help="Burn a 48-bit Custom MAC Address to EFUSE BLOCK3."
)
p.add_argument(
"mac",
help="Custom MAC Address to burn given in hexadecimal format with bytes "
"separated by colons (e.g. AA:CD:EF:01:02:03).",
type=fields.base_fields.CheckArgValue(efuses, "CUSTOM_MAC"),
)
add_force_write_always(p)
p = subparsers.add_parser("get_custom_mac", help="Prints the Custom MAC Address.")
def burn_custom_mac(esp, efuses, args):
efuses["CUSTOM_MAC"].save(args.mac)
if not efuses.burn_all(check_batch_mode=True):
return
get_custom_mac(esp, efuses, args)
print("Successful")
def get_custom_mac(esp, efuses, args):
print("Custom MAC Address: {}".format(efuses["CUSTOM_MAC"].get()))
def set_flash_voltage(esp, efuses, args):
raise esptool.FatalError("set_flash_voltage is not supported!")
def adc_info(esp, efuses, args):
print("")
# fmt: off
if efuses["BLK_VERSION_MAJOR"].get() == 1:
print("Temperature Sensor Calibration = {}C".format(efuses["TEMP_SENSOR_CAL"].get()))
print("")
print("ADC1 readings stored in efuse BLOCK2:")
print(" MODE0 D1 reading (250mV): {}".format(efuses["ADC1_MODE0_D1"].get()))
print(" MODE0 D2 reading (600mV): {}".format(efuses["ADC1_MODE0_D2"].get()))
print(" MODE1 D1 reading (250mV): {}".format(efuses["ADC1_MODE1_D1"].get()))
print(" MODE1 D2 reading (800mV): {}".format(efuses["ADC1_MODE1_D2"].get()))
print(" MODE2 D1 reading (250mV): {}".format(efuses["ADC1_MODE2_D1"].get()))
print(" MODE2 D2 reading (1000mV): {}".format(efuses["ADC1_MODE2_D2"].get()))
print(" MODE3 D1 reading (250mV): {}".format(efuses["ADC1_MODE3_D1"].get()))
print(" MODE3 D2 reading (2000mV): {}".format(efuses["ADC1_MODE3_D2"].get()))
print("")
print("ADC2 readings stored in efuse BLOCK2:")
print(" MODE0 D1 reading (250mV): {}".format(efuses["ADC2_MODE0_D1"].get()))
print(" MODE0 D2 reading (600mV): {}".format(efuses["ADC2_MODE0_D2"].get()))
print(" MODE1 D1 reading (250mV): {}".format(efuses["ADC2_MODE1_D1"].get()))
print(" MODE1 D2 reading (800mV): {}".format(efuses["ADC2_MODE1_D2"].get()))
print(" MODE2 D1 reading (250mV): {}".format(efuses["ADC2_MODE2_D1"].get()))
print(" MODE2 D2 reading (1000mV): {}".format(efuses["ADC2_MODE2_D2"].get()))
print(" MODE3 D1 reading (250mV): {}".format(efuses["ADC2_MODE3_D1"].get()))
print(" MODE3 D2 reading (2000mV): {}".format(efuses["ADC2_MODE3_D2"].get()))
else:
print("BLK_VERSION_MAJOR = {}".format(efuses["BLK_VERSION_MAJOR"].get_meaning()))
# fmt: on
def burn_key(esp, efuses, args, digest=None):
if digest is None:
datafile_list = args.keyfile[
0 : len([name for name in args.keyfile if name is not None]) :
]
else:
datafile_list = digest[0 : len([name for name in digest if name is not None]) :]
efuses.force_write_always = args.force_write_always
block_name_list = args.block[
0 : len([name for name in args.block if name is not None]) :
]
keypurpose_list = args.keypurpose[
0 : len([name for name in args.keypurpose if name is not None]) :
]
util.check_duplicate_name_in_list(block_name_list)
if len(block_name_list) != len(datafile_list) or len(block_name_list) != len(
keypurpose_list
):
raise esptool.FatalError(
"The number of blocks (%d), datafile (%d) and keypurpose (%d) "
"should be the same."
% (len(block_name_list), len(datafile_list), len(keypurpose_list))
)
print("Burn keys to blocks:")
for block_name, datafile, keypurpose in zip(
block_name_list, datafile_list, keypurpose_list
):
efuse = None
for block in efuses.blocks:
if block_name == block.name or block_name in block.alias:
efuse = efuses[block.name]
if efuse is None:
raise esptool.FatalError("Unknown block name - %s" % (block_name))
num_bytes = efuse.bit_len // 8
block_num = efuses.get_index_block_by_name(block_name)
block = efuses.blocks[block_num]
if digest is None:
if keypurpose == "ECDSA_KEY":
sk = espsecure.load_ecdsa_signing_key(datafile)
data = sk.to_string()
if len(data) == 24:
# the private key is 24 bytes long for NIST192p, add 8 bytes of padding
data = b"\x00" * 8 + data
else:
data = datafile.read()
else:
data = datafile
print(" - %s" % (efuse.name), end=" ")
revers_msg = None
if efuses[block.key_purpose_name].need_reverse(keypurpose):
revers_msg = f"\tReversing byte order for {keypurpose} hardware peripheral"
data = data[::-1]
print(
"-> [{}]".format(
util.hexify(data, " ")
if args.show_sensitive_info
else " ".join(["??"] * len(data))
)
)
if revers_msg:
print(revers_msg)
if len(data) != num_bytes:
raise esptool.FatalError(
"Incorrect key file size %d. Key file must be %d bytes (%d bits) "
"of raw binary key data." % (len(data), num_bytes, num_bytes * 8)
)
if efuses[block.key_purpose_name].need_rd_protect(keypurpose):
read_protect = False if args.no_read_protect else True
else:
read_protect = False
write_protect = not args.no_write_protect
# using efuse instead of a block gives the advantage of checking it as the whole field.
efuse.save(data)
disable_wr_protect_key_purpose = False
if efuses[block.key_purpose_name].get() != keypurpose:
if efuses[block.key_purpose_name].is_writeable():
print(
"\t'%s': '%s' -> '%s'."
% (
block.key_purpose_name,
efuses[block.key_purpose_name].get(),
keypurpose,
)
)
efuses[block.key_purpose_name].save(keypurpose)
disable_wr_protect_key_purpose = True
else:
raise esptool.FatalError(
"It is not possible to change '%s' to '%s' "
"because write protection bit is set."
% (block.key_purpose_name, keypurpose)
)
else:
print("\t'%s' is already '%s'." % (block.key_purpose_name, keypurpose))
if efuses[block.key_purpose_name].is_writeable():
disable_wr_protect_key_purpose = True
if disable_wr_protect_key_purpose:
print("\tDisabling write to '%s'." % block.key_purpose_name)
efuses[block.key_purpose_name].disable_write()
if read_protect:
print("\tDisabling read to key block")
efuse.disable_read()
if write_protect:
print("\tDisabling write to key block")
efuse.disable_write()
print("")
if not write_protect:
print("Keys will remain writeable (due to --no-write-protect)")
if args.no_read_protect:
print("Keys will remain readable (due to --no-read-protect)")
if not efuses.burn_all(check_batch_mode=True):
return
print("Successful")
def burn_key_digest(esp, efuses, args):
digest_list = []
datafile_list = args.keyfile[
0 : len([name for name in args.keyfile if name is not None]) :
]
block_list = args.block[
0 : len([block for block in args.block if block is not None]) :
]
for block_name, datafile in zip(block_list, datafile_list):
efuse = None
for block in efuses.blocks:
if block_name == block.name or block_name in block.alias:
efuse = efuses[block.name]
if efuse is None:
raise esptool.FatalError("Unknown block name - %s" % (block_name))
num_bytes = efuse.bit_len // 8
digest = espsecure._digest_sbv2_public_key(datafile)
if len(digest) != num_bytes:
raise esptool.FatalError(
"Incorrect digest size %d. Digest must be %d bytes (%d bits) "
"of raw binary key data." % (len(digest), num_bytes, num_bytes * 8)
)
digest_list.append(digest)
burn_key(esp, efuses, args, digest=digest_list)
def espefuse(esp, efuses, args, command):
parser = argparse.ArgumentParser()
subparsers = parser.add_subparsers(dest="operation")
add_commands(subparsers, efuses)
try:
cmd_line_args = parser.parse_args(command.split())
except SystemExit:
traceback.print_stack()
raise esptool.FatalError('"{}" - incorrect command'.format(command))
if cmd_line_args.operation == "execute_scripts":
configfiles = cmd_line_args.configfiles
index = cmd_line_args.index
# copy arguments from args to cmd_line_args
vars(cmd_line_args).update(vars(args))
if cmd_line_args.operation == "execute_scripts":
cmd_line_args.configfiles = configfiles
cmd_line_args.index = index
if cmd_line_args.operation is None:
parser.print_help()
parser.exit(1)
operation_func = globals()[cmd_line_args.operation]
# each 'operation' is a module-level function of the same name
operation_func(esp, efuses, cmd_line_args)
def execute_scripts(esp, efuses, args):
efuses.batch_mode_cnt += 1
del args.operation
scripts = args.scripts
del args.scripts
for file in scripts:
with open(file.name, "r") as file:
exec(compile(file.read(), file.name, "exec"))
if args.debug:
for block in efuses.blocks:
data = block.get_bitstring(from_read=False)
block.print_block(data, "regs_for_burn", args.debug)
efuses.batch_mode_cnt -= 1
if not efuses.burn_all(check_batch_mode=True):
return
print("Successful")
| 15,372 | Python | .py | 376 | 31.819149 | 104 | 0.594888 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,675 | fields.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32h2/fields.py | # This file describes eFuses for ESP32-H2 chip
#
# SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import binascii
import struct
import time
from bitstring import BitArray
import esptool
import reedsolo
from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters
from .. import base_fields
from .. import util
class EfuseBlock(base_fields.EfuseBlockBase):
def len_of_burn_unit(self):
# The writing register window is 8 registers for any blocks.
# len in bytes
return 8 * 4
def __init__(self, parent, param, skip_read=False):
parent.read_coding_scheme()
super(EfuseBlock, self).__init__(parent, param, skip_read=skip_read)
def apply_coding_scheme(self):
data = self.get_raw(from_read=False)[::-1]
if len(data) < self.len_of_burn_unit():
add_empty_bytes = self.len_of_burn_unit() - len(data)
data = data + (b"\x00" * add_empty_bytes)
if self.get_coding_scheme() == self.parent.REGS.CODING_SCHEME_RS:
# takes 32 bytes
# apply RS encoding
rs = reedsolo.RSCodec(12)
# 32 byte of data + 12 bytes RS
encoded_data = rs.encode([x for x in data])
words = struct.unpack("<" + "I" * 11, encoded_data)
# returns 11 words (8 words of data + 3 words of RS coding)
else:
# takes 32 bytes
words = struct.unpack("<" + ("I" * (len(data) // 4)), data)
# returns 8 words
return words
class EspEfuses(base_fields.EspEfusesBase):
"""
Wrapper object to manage the efuse fields in a connected ESP bootloader
"""
debug = False
do_not_confirm = False
def __init__(self, esp, skip_connect=False, debug=False, do_not_confirm=False):
self.Blocks = EfuseDefineBlocks()
self.Fields = EfuseDefineFields()
self.REGS = EfuseDefineRegisters
self.BURN_BLOCK_DATA_NAMES = self.Blocks.get_burn_block_data_names()
self.BLOCKS_FOR_KEYS = self.Blocks.get_blocks_for_keys()
self._esp = esp
self.debug = debug
self.do_not_confirm = do_not_confirm
if esp.CHIP_NAME != "ESP32-H2":
raise esptool.FatalError(
"Expected the 'esp' param for ESP32-H2 chip but got for '%s'."
% (esp.CHIP_NAME)
)
if not skip_connect:
flags = self._esp.get_security_info()["flags"]
GET_SECURITY_INFO_FLAG_SECURE_DOWNLOAD_ENABLE = 1 << 2
if flags & GET_SECURITY_INFO_FLAG_SECURE_DOWNLOAD_ENABLE:
raise esptool.FatalError(
"Secure Download Mode is enabled. The tool can not read eFuses."
)
self.blocks = [
EfuseBlock(self, self.Blocks.get(block), skip_read=skip_connect)
for block in self.Blocks.BLOCKS
]
if not skip_connect:
self.get_coding_scheme_warnings()
self.efuses = [EfuseField.convert(self, efuse) for efuse in self.Fields.EFUSES]
self.efuses += [
EfuseField.convert(self, efuse) for efuse in self.Fields.KEYBLOCKS
]
if skip_connect:
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
]
else:
if self["BLK_VERSION_MAJOR"].get() == 1:
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
]
self.efuses += [
EfuseField.convert(self, efuse) for efuse in self.Fields.CALC
]
def __getitem__(self, efuse_name):
"""Return the efuse field with the given name"""
for e in self.efuses:
if efuse_name == e.name or any(x == efuse_name for x in e.alt_names):
return e
new_fields = False
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES:
if efuse.name == efuse_name or any(
x == efuse_name for x in efuse.alt_names
):
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
]
new_fields = True
if new_fields:
for e in self.efuses:
if efuse_name == e.name or any(x == efuse_name for x in e.alt_names):
return e
raise KeyError
def read_coding_scheme(self):
self.coding_scheme = self.REGS.CODING_SCHEME_RS
def print_status_regs(self):
print("")
self.blocks[0].print_block(self.blocks[0].err_bitarray, "err__regs", debug=True)
print(
"{:27} 0x{:08x}".format(
"EFUSE_RD_RS_ERR0_REG", self.read_reg(self.REGS.EFUSE_RD_RS_ERR0_REG)
)
)
print(
"{:27} 0x{:08x}".format(
"EFUSE_RD_RS_ERR1_REG", self.read_reg(self.REGS.EFUSE_RD_RS_ERR1_REG)
)
)
def efuse_controller_setup(self):
self.set_efuse_timing()
self.clear_pgm_registers()
self.wait_efuse_idle()
def write_efuses(self, block):
self.efuse_program(block)
return self.get_coding_scheme_warnings(silent=True)
def clear_pgm_registers(self):
self.wait_efuse_idle()
for r in range(
self.REGS.EFUSE_PGM_DATA0_REG, self.REGS.EFUSE_PGM_DATA0_REG + 32, 4
):
self.write_reg(r, 0)
def wait_efuse_idle(self):
deadline = time.time() + self.REGS.EFUSE_BURN_TIMEOUT
while time.time() < deadline:
# if self.read_reg(self.REGS.EFUSE_CMD_REG) == 0:
if self.read_reg(self.REGS.EFUSE_STATUS_REG) & 0x7 == 1:
return
raise esptool.FatalError(
"Timed out waiting for Efuse controller command to complete"
)
def efuse_program(self, block):
self.wait_efuse_idle()
self.write_reg(self.REGS.EFUSE_CONF_REG, self.REGS.EFUSE_WRITE_OP_CODE)
self.write_reg(self.REGS.EFUSE_CMD_REG, self.REGS.EFUSE_PGM_CMD | (block << 2))
self.wait_efuse_idle()
self.clear_pgm_registers()
self.efuse_read()
def efuse_read(self):
self.wait_efuse_idle()
self.write_reg(self.REGS.EFUSE_CONF_REG, self.REGS.EFUSE_READ_OP_CODE)
# need to add a delay after triggering EFUSE_READ_CMD, as ROM loader checks some
# efuse registers after each command is completed
# if ENABLE_SECURITY_DOWNLOAD or DIS_DOWNLOAD_MODE is enabled by the current cmd, then we need to try to reconnect to the chip.
try:
self.write_reg(
self.REGS.EFUSE_CMD_REG, self.REGS.EFUSE_READ_CMD, delay_after_us=1000
)
self.wait_efuse_idle()
except esptool.FatalError:
secure_download_mode_before = self._esp.secure_download_mode
try:
self._esp = self.reconnect_chip(self._esp)
except esptool.FatalError:
print("Can not re-connect to the chip")
if not self["DIS_DOWNLOAD_MODE"].get() and self[
"DIS_DOWNLOAD_MODE"
].get(from_read=False):
print(
"This is the correct behavior as we are actually burning "
"DIS_DOWNLOAD_MODE which disables the connection to the chip"
)
print("DIS_DOWNLOAD_MODE is enabled")
print("Successful")
exit(0) # finish without errors
raise
print("Established a connection with the chip")
if self._esp.secure_download_mode and not secure_download_mode_before:
print("Secure download mode is enabled")
if not self["ENABLE_SECURITY_DOWNLOAD"].get() and self[
"ENABLE_SECURITY_DOWNLOAD"
].get(from_read=False):
print(
"espefuse tool can not continue to work in Secure download mode"
)
print("ENABLE_SECURITY_DOWNLOAD is enabled")
print("Successful")
exit(0) # finish without errors
raise
def set_efuse_timing(self):
"""Set timing registers for burning efuses"""
# Configure clock
apb_freq = self.get_crystal_freq()
# Based on `CONFIG_SOC_XTAL_SUPPORT_32M=y` for this target from ESP-IDF configuration
if apb_freq != 32:
raise esptool.FatalError(
"The eFuse supports only xtal=32M (xtal was %d)" % apb_freq
)
self.update_reg(self.REGS.EFUSE_DAC_CONF_REG, self.REGS.EFUSE_DAC_NUM_M, 0xFF)
self.update_reg(
self.REGS.EFUSE_DAC_CONF_REG, self.REGS.EFUSE_DAC_CLK_DIV_M, 0x28
)
self.update_reg(
self.REGS.EFUSE_WR_TIM_CONF1_REG, self.REGS.EFUSE_PWR_ON_NUM_M, 0x3000
)
self.update_reg(
self.REGS.EFUSE_WR_TIM_CONF2_REG, self.REGS.EFUSE_PWR_OFF_NUM_M, 0x190
)
def get_coding_scheme_warnings(self, silent=False):
"""Check if the coding scheme has detected any errors."""
old_addr_reg = 0
reg_value = 0
ret_fail = False
for block in self.blocks:
if block.id == 0:
words = [
self.read_reg(self.REGS.EFUSE_RD_REPEAT_ERR0_REG + offs * 4)
for offs in range(5)
]
block.err_bitarray.pos = 0
for word in reversed(words):
block.err_bitarray.overwrite(BitArray("uint:32=%d" % word))
block.num_errors = block.err_bitarray.count(True)
block.fail = block.num_errors != 0
else:
addr_reg, err_num_mask, err_num_offs, fail_bit = self.REGS.BLOCK_ERRORS[
block.id
]
if err_num_mask is None or err_num_offs is None or fail_bit is None:
continue
if addr_reg != old_addr_reg:
old_addr_reg = addr_reg
reg_value = self.read_reg(addr_reg)
block.fail = reg_value & (1 << fail_bit) != 0
block.num_errors = (reg_value >> err_num_offs) & err_num_mask
ret_fail |= block.fail
if not silent and (block.fail or block.num_errors):
print(
"Error(s) in BLOCK%d [ERRORS:%d FAIL:%d]"
% (block.id, block.num_errors, block.fail)
)
if (self.debug or ret_fail) and not silent:
self.print_status_regs()
return ret_fail
def summary(self):
# TODO add support set_flash_voltage - "Flash voltage (VDD_SPI)"
return ""
class EfuseField(base_fields.EfuseFieldBase):
@staticmethod
def convert(parent, efuse):
return {
"mac": EfuseMacField,
"keypurpose": EfuseKeyPurposeField,
"t_sensor": EfuseTempSensor,
"adc_tp": EfuseAdcPointCalibration,
"wafer": EfuseWafer,
}.get(efuse.class_type, EfuseField)(parent, efuse)
class EfuseWafer(EfuseField):
def get(self, from_read=True):
hi_bits = self.parent["WAFER_VERSION_MINOR_HI"].get(from_read)
assert self.parent["WAFER_VERSION_MINOR_HI"].bit_len == 1
lo_bits = self.parent["WAFER_VERSION_MINOR_LO"].get(from_read)
assert self.parent["WAFER_VERSION_MINOR_LO"].bit_len == 3
return (hi_bits << 3) + lo_bits
def save(self, new_value):
raise esptool.FatalError("Burning %s is not supported" % self.name)
class EfuseTempSensor(EfuseField):
def get(self, from_read=True):
value = self.get_bitstring(from_read)
sig = -1 if value[0] else 1
return sig * value[1:].uint * 0.1
class EfuseAdcPointCalibration(EfuseField):
def get(self, from_read=True):
STEP_SIZE = 4
value = self.get_bitstring(from_read)
sig = -1 if value[0] else 1
return sig * value[1:].uint * STEP_SIZE
class EfuseMacField(EfuseField):
def check_format(self, new_value_str):
if new_value_str is None:
raise esptool.FatalError(
"Required MAC Address in AA:CD:EF:01:02:03 format!"
)
num_bytes = 8 if self.name == "MAC_EUI64" else 6
if new_value_str.count(":") != num_bytes - 1:
raise esptool.FatalError(
f"MAC Address needs to be a {num_bytes}-byte hexadecimal format "
"separated by colons (:)!"
)
hexad = new_value_str.replace(":", "")
hexad = hexad.split(" ", 1)[0] if self.is_field_calculated() else hexad
if len(hexad) != num_bytes * 2:
raise esptool.FatalError(
f"MAC Address needs to be a {num_bytes}-byte hexadecimal number "
f"({num_bytes * 2} hexadecimal characters)!"
)
# order of bytearray = b'\xaa\xcd\xef\x01\x02\x03',
bindata = binascii.unhexlify(hexad)
if not self.is_field_calculated():
# unicast address check according to
# https://tools.ietf.org/html/rfc7042#section-2.1
if esptool.util.byte(bindata, 0) & 0x01:
raise esptool.FatalError("Custom MAC must be a unicast MAC!")
return bindata
def check(self):
errs, fail = self.parent.get_block_errors(self.block)
if errs != 0 or fail:
output = "Block%d has ERRORS:%d FAIL:%d" % (self.block, errs, fail)
else:
output = "OK"
return "(" + output + ")"
def get(self, from_read=True):
if self.name == "CUSTOM_MAC":
mac = self.get_raw(from_read)[::-1]
elif self.name == "MAC":
mac = self.get_raw(from_read)
elif self.name == "MAC_EUI64":
mac = self.parent["MAC"].get_bitstring(from_read).copy()
mac_ext = self.parent["MAC_EXT"].get_bitstring(from_read)
mac.insert(mac_ext, 24)
mac = mac.bytes
else:
mac = self.get_raw(from_read)
return "%s %s" % (util.hexify(mac, ":"), self.check())
def save(self, new_value):
def print_field(e, new_value):
print(
" - '{}' ({}) {} -> {}".format(
e.name, e.description, e.get_bitstring(), new_value
)
)
if self.name == "CUSTOM_MAC":
bitarray_mac = self.convert_to_bitstring(new_value)
print_field(self, bitarray_mac)
super(EfuseMacField, self).save(new_value)
else:
# Writing the BLOCK1 (MAC_SPI_8M_0) default MAC is not possible,
# as it's written in the factory.
raise esptool.FatalError(f"Burning {self.name} is not supported")
# fmt: off
class EfuseKeyPurposeField(EfuseField):
KEY_PURPOSES = [
("USER", 0, None, None, "no_need_rd_protect"), # User purposes (software-only use)
("ECDSA_KEY", 1, None, "Reverse", "need_rd_protect"), # ECDSA key
("RESERVED", 2, None, None, "no_need_rd_protect"), # Reserved
("XTS_AES_128_KEY", 4, None, "Reverse", "need_rd_protect"), # XTS_AES_128_KEY (flash/PSRAM encryption)
("HMAC_DOWN_ALL", 5, None, None, "need_rd_protect"), # HMAC Downstream mode
("HMAC_DOWN_JTAG", 6, None, None, "need_rd_protect"), # JTAG soft enable key (uses HMAC Downstream mode)
("HMAC_DOWN_DIGITAL_SIGNATURE", 7, None, None, "need_rd_protect"), # Digital Signature peripheral key (uses HMAC Downstream mode)
("HMAC_UP", 8, None, None, "need_rd_protect"), # HMAC Upstream mode
("SECURE_BOOT_DIGEST0", 9, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST0 (Secure Boot key digest)
("SECURE_BOOT_DIGEST1", 10, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST1 (Secure Boot key digest)
("SECURE_BOOT_DIGEST2", 11, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST2 (Secure Boot key digest)
]
# fmt: on
KEY_PURPOSES_NAME = [name[0] for name in KEY_PURPOSES]
DIGEST_KEY_PURPOSES = [name[0] for name in KEY_PURPOSES if name[2] == "DIGEST"]
def check_format(self, new_value_str):
# str convert to int: "XTS_AES_128_KEY" - > str(4)
# if int: 4 -> str(4)
raw_val = new_value_str
for purpose_name in self.KEY_PURPOSES:
if purpose_name[0] == new_value_str:
raw_val = str(purpose_name[1])
break
if raw_val.isdigit():
if int(raw_val) not in [p[1] for p in self.KEY_PURPOSES if p[1] > 0]:
raise esptool.FatalError("'%s' can not be set (value out of range)" % raw_val)
else:
raise esptool.FatalError("'%s' unknown name" % raw_val)
return raw_val
def need_reverse(self, new_key_purpose):
for key in self.KEY_PURPOSES:
if key[0] == new_key_purpose:
return key[3] == "Reverse"
def need_rd_protect(self, new_key_purpose):
for key in self.KEY_PURPOSES:
if key[0] == new_key_purpose:
return key[4] == "need_rd_protect"
def get(self, from_read=True):
for p in self.KEY_PURPOSES:
if p[1] == self.get_raw(from_read):
return p[0]
return "FORBIDDEN_STATE"
def get_name(self, raw_val):
for key in self.KEY_PURPOSES:
if key[1] == raw_val:
return key[0]
def save(self, new_value):
raw_val = int(self.check_format(str(new_value)))
str_new_value = self.get_name(raw_val)
if self.name == "KEY_PURPOSE_5" and str_new_value in ["XTS_AES_128_KEY", "ECDSA_KEY"]:
raise esptool.FatalError(f"{self.name} can not have {str_new_value} key due to a hardware bug (please see TRM for more details)")
return super(EfuseKeyPurposeField, self).save(raw_val)
| 18,561 | Python | .py | 401 | 34.982544 | 155 | 0.564833 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,676 | mem_definition.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32h2/mem_definition.py | # This file describes eFuses fields and registers for ESP32-H2 chip
#
# SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import os
import yaml
from ..mem_definition_base import (
EfuseBlocksBase,
EfuseFieldsBase,
EfuseRegistersBase,
Field,
)
class EfuseDefineRegisters(EfuseRegistersBase):
EFUSE_MEM_SIZE = 0x01FC + 4
# EFUSE registers & command/conf values
DR_REG_EFUSE_BASE = 0x600B0800
EFUSE_PGM_DATA0_REG = DR_REG_EFUSE_BASE
EFUSE_CHECK_VALUE0_REG = DR_REG_EFUSE_BASE + 0x020
EFUSE_CLK_REG = DR_REG_EFUSE_BASE + 0x1C8
EFUSE_CONF_REG = DR_REG_EFUSE_BASE + 0x1CC
EFUSE_STATUS_REG = DR_REG_EFUSE_BASE + 0x1D0
EFUSE_CMD_REG = DR_REG_EFUSE_BASE + 0x1D4
EFUSE_RD_RS_ERR0_REG = DR_REG_EFUSE_BASE + 0x1C0
EFUSE_RD_RS_ERR1_REG = DR_REG_EFUSE_BASE + 0x1C4
EFUSE_RD_REPEAT_ERR0_REG = DR_REG_EFUSE_BASE + 0x17C
EFUSE_RD_REPEAT_ERR1_REG = DR_REG_EFUSE_BASE + 0x180
EFUSE_RD_REPEAT_ERR2_REG = DR_REG_EFUSE_BASE + 0x184
EFUSE_RD_REPEAT_ERR3_REG = DR_REG_EFUSE_BASE + 0x188
EFUSE_RD_REPEAT_ERR4_REG = DR_REG_EFUSE_BASE + 0x18C
EFUSE_DAC_CONF_REG = DR_REG_EFUSE_BASE + 0x1E8
EFUSE_RD_TIM_CONF_REG = DR_REG_EFUSE_BASE + 0x1EC
EFUSE_WR_TIM_CONF1_REG = DR_REG_EFUSE_BASE + 0x1F0
EFUSE_WR_TIM_CONF2_REG = DR_REG_EFUSE_BASE + 0x1F4
EFUSE_DATE_REG = DR_REG_EFUSE_BASE + 0x1FC
EFUSE_WRITE_OP_CODE = 0x5A5A
EFUSE_READ_OP_CODE = 0x5AA5
EFUSE_PGM_CMD_MASK = 0x3
EFUSE_PGM_CMD = 0x2
EFUSE_READ_CMD = 0x1
BLOCK_ERRORS = [
# error_reg, err_num_mask, err_num_offs, fail_bit
(EFUSE_RD_REPEAT_ERR0_REG, None, None, None), # BLOCK0
(EFUSE_RD_RS_ERR0_REG, 0x7, 0, 3), # MAC_SPI_8M_0
(EFUSE_RD_RS_ERR0_REG, 0x7, 4, 7), # BLOCK_SYS_DATA
(EFUSE_RD_RS_ERR0_REG, 0x7, 8, 11), # BLOCK_USR_DATA
(EFUSE_RD_RS_ERR0_REG, 0x7, 12, 15), # BLOCK_KEY0
(EFUSE_RD_RS_ERR0_REG, 0x7, 16, 19), # BLOCK_KEY1
(EFUSE_RD_RS_ERR0_REG, 0x7, 20, 23), # BLOCK_KEY2
(EFUSE_RD_RS_ERR0_REG, 0x7, 24, 27), # BLOCK_KEY3
(EFUSE_RD_RS_ERR0_REG, 0x7, 28, 31), # BLOCK_KEY4
(EFUSE_RD_RS_ERR1_REG, 0x7, 0, 3), # BLOCK_KEY5
(EFUSE_RD_RS_ERR1_REG, 0x7, 4, 7), # BLOCK_SYS_DATA2
]
# EFUSE_WR_TIM_CONF2_REG
EFUSE_PWR_OFF_NUM_S = 0
EFUSE_PWR_OFF_NUM_M = 0xFFFF << EFUSE_PWR_OFF_NUM_S
# EFUSE_WR_TIM_CONF1_REG
EFUSE_PWR_ON_NUM_S = 8
EFUSE_PWR_ON_NUM_M = 0x0000FFFF << EFUSE_PWR_ON_NUM_S
# EFUSE_DAC_CONF_REG
EFUSE_DAC_CLK_DIV_S = 0
EFUSE_DAC_CLK_DIV_M = 0xFF << EFUSE_DAC_CLK_DIV_S
# EFUSE_DAC_CONF_REG
EFUSE_DAC_NUM_S = 9
EFUSE_DAC_NUM_M = 0xFF << EFUSE_DAC_NUM_S
class EfuseDefineBlocks(EfuseBlocksBase):
__base_rd_regs = EfuseDefineRegisters.DR_REG_EFUSE_BASE
__base_wr_regs = EfuseDefineRegisters.EFUSE_PGM_DATA0_REG
# List of efuse blocks
# fmt: off
BLOCKS = [
# Name, Alias, Index, Read address, Write address, Write protect bit, Read protect bit, Len, key_purpose
("BLOCK0", [], 0, __base_rd_regs + 0x02C, __base_wr_regs, None, None, 6, None),
("MAC_SPI_8M_0", ["BLOCK1"], 1, __base_rd_regs + 0x044, __base_wr_regs, 20, None, 6, None),
("BLOCK_SYS_DATA", ["BLOCK2"], 2, __base_rd_regs + 0x05C, __base_wr_regs, 21, None, 8, None),
("BLOCK_USR_DATA", ["BLOCK3"], 3, __base_rd_regs + 0x07C, __base_wr_regs, 22, None, 8, None),
("BLOCK_KEY0", ["BLOCK4"], 4, __base_rd_regs + 0x09C, __base_wr_regs, 23, 0, 8, "KEY_PURPOSE_0"),
("BLOCK_KEY1", ["BLOCK5"], 5, __base_rd_regs + 0x0BC, __base_wr_regs, 24, 1, 8, "KEY_PURPOSE_1"),
("BLOCK_KEY2", ["BLOCK6"], 6, __base_rd_regs + 0x0DC, __base_wr_regs, 25, 2, 8, "KEY_PURPOSE_2"),
("BLOCK_KEY3", ["BLOCK7"], 7, __base_rd_regs + 0x0FC, __base_wr_regs, 26, 3, 8, "KEY_PURPOSE_3"),
("BLOCK_KEY4", ["BLOCK8"], 8, __base_rd_regs + 0x11C, __base_wr_regs, 27, 4, 8, "KEY_PURPOSE_4"),
("BLOCK_KEY5", ["BLOCK9"], 9, __base_rd_regs + 0x13C, __base_wr_regs, 28, 5, 8, "KEY_PURPOSE_5"),
("BLOCK_SYS_DATA2", ["BLOCK10"], 10, __base_rd_regs + 0x15C, __base_wr_regs, 29, 6, 8, None),
]
# fmt: on
def get_burn_block_data_names(self):
list_of_names = []
for block in self.BLOCKS:
blk = self.get(block)
if blk.name:
list_of_names.append(blk.name)
if blk.alias:
for alias in blk.alias:
list_of_names.append(alias)
return list_of_names
class EfuseDefineFields(EfuseFieldsBase):
def __init__(self) -> None:
# List of efuse fields from TRM the chapter eFuse Controller.
self.EFUSES = []
self.KEYBLOCKS = []
# if BLK_VERSION_MAJOR is 1, these efuse fields are in BLOCK2
self.BLOCK2_CALIBRATION_EFUSES = []
self.CALC = []
dir_name = os.path.dirname(os.path.abspath(__file__))
dir_name, file_name = os.path.split(dir_name)
file_name = file_name + ".yaml"
dir_name, _ = os.path.split(dir_name)
efuse_file = os.path.join(dir_name, "efuse_defs", file_name)
with open(f"{efuse_file}", "r") as r_file:
e_desc = yaml.safe_load(r_file)
super().__init__(e_desc)
for i, efuse in enumerate(self.ALL_EFUSES):
if efuse.name in [
"BLOCK_USR_DATA",
"BLOCK_KEY0",
"BLOCK_KEY1",
"BLOCK_KEY2",
"BLOCK_KEY3",
"BLOCK_KEY4",
"BLOCK_KEY5",
"BLOCK_SYS_DATA2",
]:
if efuse.name == "BLOCK_USR_DATA":
efuse.bit_len = 256
efuse.type = "bytes:32"
self.KEYBLOCKS.append(efuse)
self.ALL_EFUSES[i] = None
elif efuse.category == "calibration":
self.BLOCK2_CALIBRATION_EFUSES.append(efuse)
self.ALL_EFUSES[i] = None
f = Field()
f.name = "MAC_EUI64"
f.block = 1
f.bit_len = 64
f.type = f"bytes:{f.bit_len // 8}"
f.category = "MAC"
f.class_type = "mac"
f.description = "calc MAC_EUI64 = MAC[0]:MAC[1]:MAC[2]:MAC_EXT[0]:MAC_EXT[1]:MAC[3]:MAC[4]:MAC[5]"
self.CALC.append(f)
for efuse in self.ALL_EFUSES:
if efuse is not None:
self.EFUSES.append(efuse)
self.ALL_EFUSES = []
| 6,679 | Python | .py | 144 | 37.986111 | 140 | 0.570968 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,677 | emulate_efuse_controller.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32s3beta2/emulate_efuse_controller.py | # This file describes eFuses controller for ESP32-S3(beta2) chip
#
# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import reedsolo
from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters
from ..emulate_efuse_controller_base import EmulateEfuseControllerBase, FatalError
class EmulateEfuseController(EmulateEfuseControllerBase):
"""The class for virtual efuse operation. Using for HOST_TEST."""
CHIP_NAME = "ESP32-S3(beta2)"
mem = None
debug = False
def __init__(self, efuse_file=None, debug=False):
self.Blocks = EfuseDefineBlocks
self.Fields = EfuseDefineFields()
self.REGS = EfuseDefineRegisters
super(EmulateEfuseController, self).__init__(efuse_file, debug)
self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
""" esptool method start >>"""
def get_major_chip_version(self):
return 0
def get_minor_chip_version(self):
return 2
def get_crystal_freq(self):
return 40 # MHz (common for all chips)
def get_security_info(self):
return {
"flags": 0,
"flash_crypt_cnt": 0,
"key_purposes": 0,
"chip_id": 0,
"api_version": 0,
}
""" << esptool method end """
def handle_writing_event(self, addr, value):
if addr == self.REGS.EFUSE_CMD_REG:
if value & self.REGS.EFUSE_PGM_CMD:
self.copy_blocks_wr_regs_to_rd_regs(updated_block=(value >> 2) & 0xF)
self.clean_blocks_wr_regs()
self.check_rd_protection_area()
self.write_reg(addr, 0)
self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
elif value == self.REGS.EFUSE_READ_CMD:
self.write_reg(addr, 0)
self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
self.save_to_file()
def get_bitlen_of_block(self, blk, wr=False):
if blk.id == 0:
if wr:
return 32 * 8
else:
return 32 * blk.len
else:
if wr:
rs_coding = 32 * 3
return 32 * 8 + rs_coding
else:
return 32 * blk.len
def handle_coding_scheme(self, blk, data):
if blk.id != 0:
# CODING_SCHEME RS applied only for all blocks except BLK0.
coded_bytes = 12
data.pos = coded_bytes * 8
plain_data = data.readlist("32*uint:8")[::-1]
# takes 32 bytes
# apply RS encoding
rs = reedsolo.RSCodec(coded_bytes)
# 32 byte of data + 12 bytes RS
calc_encoded_data = list(rs.encode([x for x in plain_data]))
data.pos = 0
if calc_encoded_data != data.readlist("44*uint:8")[::-1]:
raise FatalError("Error in coding scheme data")
data = data[coded_bytes * 8 :]
if blk.len < 8:
data = data[(8 - blk.len) * 32 :]
return data
| 3,086 | Python | .py | 77 | 29.844156 | 86 | 0.576486 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,678 | __init__.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32s3beta2/__init__.py | from . import operations
from .emulate_efuse_controller import EmulateEfuseController
from .fields import EspEfuses
| 116 | Python | .py | 3 | 37.666667 | 60 | 0.876106 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,679 | operations.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32s3beta2/operations.py | # This file includes the operations with eFuses for ESP32-S3(beta2) chip
#
# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import argparse
import io
import os # noqa: F401. It is used in IDF scripts
import traceback
import espsecure
import esptool
from . import fields
from .. import util
from ..base_operations import (
add_common_commands,
add_force_write_always,
add_show_sensitive_info_option,
burn_bit,
burn_block_data,
burn_efuse,
check_error,
dump,
read_protect_efuse,
summary,
write_protect_efuse,
)
def protect_options(p):
p.add_argument(
"--no-write-protect",
help="Disable write-protecting of the key. The key remains writable. "
"(The keys use the RS coding scheme that does not support post-write "
"data changes. Forced write can damage RS encoding bits.) "
"The write-protecting of keypurposes does not depend on the option, "
"it will be set anyway.",
action="store_true",
)
p.add_argument(
"--no-read-protect",
help="Disable read-protecting of the key. The key remains readable software."
"The key with keypurpose[USER, RESERVED and *_DIGEST] "
"will remain readable anyway. "
"For the rest keypurposes the read-protection will be defined the option "
"(Read-protect by default).",
action="store_true",
)
def add_commands(subparsers, efuses):
add_common_commands(subparsers, efuses)
burn_key = subparsers.add_parser(
"burn_key", help="Burn the key block with the specified name"
)
protect_options(burn_key)
add_force_write_always(burn_key)
add_show_sensitive_info_option(burn_key)
burn_key.add_argument(
"block",
help="Key block to burn",
action="append",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key.add_argument(
"keyfile",
help="File containing 256 bits of binary key data",
action="append",
type=argparse.FileType("rb"),
)
burn_key.add_argument(
"keypurpose",
help="Purpose to set.",
action="append",
choices=fields.EfuseKeyPurposeField.KEY_PURPOSES_NAME,
)
for _ in efuses.BLOCKS_FOR_KEYS:
burn_key.add_argument(
"block",
help="Key block to burn",
nargs="?",
action="append",
metavar="BLOCK",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key.add_argument(
"keyfile",
help="File containing 256 bits of binary key data",
nargs="?",
action="append",
metavar="KEYFILE",
type=argparse.FileType("rb"),
)
burn_key.add_argument(
"keypurpose",
help="Purpose to set.",
nargs="?",
action="append",
metavar="KEYPURPOSE",
choices=fields.EfuseKeyPurposeField.KEY_PURPOSES_NAME,
)
burn_key_digest = subparsers.add_parser(
"burn_key_digest",
help="Parse a RSA public key and burn the digest to key efuse block",
)
protect_options(burn_key_digest)
add_force_write_always(burn_key_digest)
add_show_sensitive_info_option(burn_key_digest)
burn_key_digest.add_argument(
"block",
help="Key block to burn",
action="append",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key_digest.add_argument(
"keyfile",
help="Key file to digest (PEM format)",
action="append",
type=argparse.FileType("rb"),
)
burn_key_digest.add_argument(
"keypurpose",
help="Purpose to set.",
action="append",
choices=fields.EfuseKeyPurposeField.DIGEST_KEY_PURPOSES,
)
for _ in efuses.BLOCKS_FOR_KEYS:
burn_key_digest.add_argument(
"block",
help="Key block to burn",
nargs="?",
action="append",
metavar="BLOCK",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key_digest.add_argument(
"keyfile",
help="Key file to digest (PEM format)",
nargs="?",
action="append",
metavar="KEYFILE",
type=argparse.FileType("rb"),
)
burn_key_digest.add_argument(
"keypurpose",
help="Purpose to set.",
nargs="?",
action="append",
metavar="KEYPURPOSE",
choices=fields.EfuseKeyPurposeField.DIGEST_KEY_PURPOSES,
)
p = subparsers.add_parser(
"set_flash_voltage",
help="Permanently set the internal flash voltage regulator "
"to either 1.8V, 3.3V or OFF. This means GPIO45 can be high or low at reset "
"without changing the flash voltage.",
)
p.add_argument("voltage", help="Voltage selection", choices=["1.8V", "3.3V", "OFF"])
p = subparsers.add_parser(
"burn_custom_mac", help="Burn a 48-bit Custom MAC Address to EFUSE BLOCK3."
)
p.add_argument(
"mac",
help="Custom MAC Address to burn given in hexadecimal format with bytes "
"separated by colons (e.g. AA:CD:EF:01:02:03).",
type=fields.base_fields.CheckArgValue(efuses, "CUSTOM_MAC"),
)
add_force_write_always(p)
p = subparsers.add_parser("get_custom_mac", help="Prints the Custom MAC Address.")
def burn_custom_mac(esp, efuses, args):
efuses["CUSTOM_MAC"].save(args.mac)
if not efuses.burn_all(check_batch_mode=True):
return
get_custom_mac(esp, efuses, args)
print("Successful")
def get_custom_mac(esp, efuses, args):
print("Custom MAC Address: {}".format(efuses["CUSTOM_MAC"].get()))
def set_flash_voltage(esp, efuses, args):
sdio_force = efuses["VDD_SPI_FORCE"]
sdio_tieh = efuses["VDD_SPI_TIEH"]
sdio_reg = efuses["VDD_SPI_XPD"]
# check efuses aren't burned in a way which makes this impossible
if args.voltage == "OFF" and sdio_reg.get() != 0:
raise esptool.FatalError(
"Can't set flash regulator to OFF as VDD_SPI_XPD efuse is already burned"
)
if args.voltage == "1.8V" and sdio_tieh.get() != 0:
raise esptool.FatalError(
"Can't set regulator to 1.8V is VDD_SPI_TIEH efuse is already burned"
)
if args.voltage == "OFF":
msg = "Disable internal flash voltage regulator (VDD_SPI). "
"SPI flash will need to be powered from an external source.\n"
"The following efuse is burned: VDD_SPI_FORCE.\n"
"It is possible to later re-enable the internal regulator (%s) " % (
"to 3.3V" if sdio_tieh.get() != 0 else "to 1.8V or 3.3V"
)
"by burning an additional efuse"
elif args.voltage == "1.8V":
msg = "Set internal flash voltage regulator (VDD_SPI) to 1.8V.\n"
"The following efuses are burned: VDD_SPI_FORCE, VDD_SPI_XPD.\n"
"It is possible to later increase the voltage to 3.3V (permanently) "
"by burning additional efuse VDD_SPI_TIEH"
elif args.voltage == "3.3V":
msg = "Enable internal flash voltage regulator (VDD_SPI) to 3.3V.\n"
"The following efuses are burned: VDD_SPI_FORCE, VDD_SPI_XPD, VDD_SPI_TIEH."
print(msg)
sdio_force.save(1) # Disable GPIO45
if args.voltage != "OFF":
sdio_reg.save(1) # Enable internal regulator
if args.voltage == "3.3V":
sdio_tieh.save(1)
print("VDD_SPI setting complete.")
if not efuses.burn_all(check_batch_mode=True):
return
print("Successful")
def adc_info(esp, efuses, args):
print("")
# fmt: off
if efuses["BLK_VERSION_MAJOR"].get() == 1:
print("Temperature Sensor Calibration = {}C".format(efuses["TEMP_SENSOR_CAL"].get()))
print("")
print("ADC1 readings stored in efuse BLOCK2:")
print(" MODE0 D1 reading (250mV): {}".format(efuses["ADC1_MODE0_D1"].get()))
print(" MODE0 D2 reading (600mV): {}".format(efuses["ADC1_MODE0_D2"].get()))
print(" MODE1 D1 reading (250mV): {}".format(efuses["ADC1_MODE1_D1"].get()))
print(" MODE1 D2 reading (800mV): {}".format(efuses["ADC1_MODE1_D2"].get()))
print(" MODE2 D1 reading (250mV): {}".format(efuses["ADC1_MODE2_D1"].get()))
print(" MODE2 D2 reading (1000mV): {}".format(efuses["ADC1_MODE2_D2"].get()))
print(" MODE3 D1 reading (250mV): {}".format(efuses["ADC1_MODE3_D1"].get()))
print(" MODE3 D2 reading (2000mV): {}".format(efuses["ADC1_MODE3_D2"].get()))
print("")
print("ADC2 readings stored in efuse BLOCK2:")
print(" MODE0 D1 reading (250mV): {}".format(efuses["ADC2_MODE0_D1"].get()))
print(" MODE0 D2 reading (600mV): {}".format(efuses["ADC2_MODE0_D2"].get()))
print(" MODE1 D1 reading (250mV): {}".format(efuses["ADC2_MODE1_D1"].get()))
print(" MODE1 D2 reading (800mV): {}".format(efuses["ADC2_MODE1_D2"].get()))
print(" MODE2 D1 reading (250mV): {}".format(efuses["ADC2_MODE2_D1"].get()))
print(" MODE2 D2 reading (1000mV): {}".format(efuses["ADC2_MODE2_D2"].get()))
print(" MODE3 D1 reading (250mV): {}".format(efuses["ADC2_MODE3_D1"].get()))
print(" MODE3 D2 reading (2000mV): {}".format(efuses["ADC2_MODE3_D2"].get()))
else:
print("BLK_VERSION_MAJOR = {}".format(efuses["BLK_VERSION_MAJOR"].get_meaning()))
# fmt: on
def key_block_is_unused(block, key_purpose_block):
if not block.is_readable() or not block.is_writeable():
return False
if key_purpose_block.get() != "USER" or not key_purpose_block.is_writeable():
return False
if not block.get_bitstring().all(False):
return False
return True
def get_next_key_block(efuses, current_key_block, block_name_list):
key_blocks = [b for b in efuses.blocks if b.key_purpose_name]
start = key_blocks.index(current_key_block)
# Sort key blocks so that we pick the next free block (and loop around if necessary)
key_blocks = key_blocks[start:] + key_blocks[0:start]
# Exclude any other blocks that will be be burned
key_blocks = [b for b in key_blocks if b.name not in block_name_list]
for block in key_blocks:
key_purpose_block = efuses[block.key_purpose_name]
if key_block_is_unused(block, key_purpose_block):
return block
return None
def split_512_bit_key(efuses, block_name_list, datafile_list, keypurpose_list):
i = keypurpose_list.index("XTS_AES_256_KEY")
block_name = block_name_list[i]
block_num = efuses.get_index_block_by_name(block_name)
block = efuses.blocks[block_num]
data = datafile_list[i].read()
if len(data) != 64:
raise esptool.FatalError(
"Incorrect key file size %d, XTS_AES_256_KEY should be 64 bytes" % len(data)
)
key_block_2 = get_next_key_block(efuses, block, block_name_list)
if not key_block_2:
raise esptool.FatalError("XTS_AES_256_KEY requires two free keyblocks")
keypurpose_list.append("XTS_AES_256_KEY_1")
datafile_list.append(io.BytesIO(data[:32]))
block_name_list.append(block_name)
keypurpose_list.append("XTS_AES_256_KEY_2")
datafile_list.append(io.BytesIO(data[32:]))
block_name_list.append(key_block_2.name)
keypurpose_list.pop(i)
datafile_list.pop(i)
block_name_list.pop(i)
def burn_key(esp, efuses, args, digest=None):
if digest is None:
datafile_list = args.keyfile[
0 : len([name for name in args.keyfile if name is not None]) :
]
else:
datafile_list = digest[0 : len([name for name in digest if name is not None]) :]
efuses.force_write_always = args.force_write_always
block_name_list = args.block[
0 : len([name for name in args.block if name is not None]) :
]
keypurpose_list = args.keypurpose[
0 : len([name for name in args.keypurpose if name is not None]) :
]
if "XTS_AES_256_KEY" in keypurpose_list:
# XTS_AES_256_KEY is not an actual HW key purpose, needs to be split into
# XTS_AES_256_KEY_1 and XTS_AES_256_KEY_2
split_512_bit_key(efuses, block_name_list, datafile_list, keypurpose_list)
util.check_duplicate_name_in_list(block_name_list)
if len(block_name_list) != len(datafile_list) or len(block_name_list) != len(
keypurpose_list
):
raise esptool.FatalError(
"The number of blocks (%d), datafile (%d) and keypurpose (%d) "
"should be the same."
% (len(block_name_list), len(datafile_list), len(keypurpose_list))
)
print("Burn keys to blocks:")
for block_name, datafile, keypurpose in zip(
block_name_list, datafile_list, keypurpose_list
):
efuse = None
for block in efuses.blocks:
if block_name == block.name or block_name in block.alias:
efuse = efuses[block.name]
if efuse is None:
raise esptool.FatalError("Unknown block name - %s" % (block_name))
num_bytes = efuse.bit_len // 8
block_num = efuses.get_index_block_by_name(block_name)
block = efuses.blocks[block_num]
if digest is None:
data = datafile.read()
else:
data = datafile
print(" - %s" % (efuse.name), end=" ")
revers_msg = None
if efuses[block.key_purpose_name].need_reverse(keypurpose):
revers_msg = "\tReversing byte order for AES-XTS hardware peripheral"
data = data[::-1]
print(
"-> [{}]".format(
util.hexify(data, " ")
if args.show_sensitive_info
else " ".join(["??"] * len(data))
)
)
if revers_msg:
print(revers_msg)
if len(data) != num_bytes:
raise esptool.FatalError(
"Incorrect key file size %d. Key file must be %d bytes (%d bits) "
"of raw binary key data." % (len(data), num_bytes, num_bytes * 8)
)
if efuses[block.key_purpose_name].need_rd_protect(keypurpose):
read_protect = False if args.no_read_protect else True
else:
read_protect = False
write_protect = not args.no_write_protect
# using efuse instead of a block gives the advantage of
# checking it as the whole field.
efuse.save(data)
disable_wr_protect_key_purpose = False
if efuses[block.key_purpose_name].get() != keypurpose:
if efuses[block.key_purpose_name].is_writeable():
print(
"\t'%s': '%s' -> '%s'."
% (
block.key_purpose_name,
efuses[block.key_purpose_name].get(),
keypurpose,
)
)
efuses[block.key_purpose_name].save(keypurpose)
disable_wr_protect_key_purpose = True
else:
raise esptool.FatalError(
"It is not possible to change '%s' to '%s' because "
"write protection bit is set."
% (block.key_purpose_name, keypurpose)
)
else:
print("\t'%s' is already '%s'." % (block.key_purpose_name, keypurpose))
if efuses[block.key_purpose_name].is_writeable():
disable_wr_protect_key_purpose = True
if disable_wr_protect_key_purpose:
print("\tDisabling write to '%s'." % block.key_purpose_name)
efuses[block.key_purpose_name].disable_write()
if read_protect:
print("\tDisabling read to key block")
efuse.disable_read()
if write_protect:
print("\tDisabling write to key block")
efuse.disable_write()
print("")
if not write_protect:
print("Keys will remain writeable (due to --no-write-protect)")
if args.no_read_protect:
print("Keys will remain readable (due to --no-read-protect)")
if not efuses.burn_all(check_batch_mode=True):
return
print("Successful")
def burn_key_digest(esp, efuses, args):
digest_list = []
datafile_list = args.keyfile[
0 : len([name for name in args.keyfile if name is not None]) :
]
block_list = args.block[
0 : len([block for block in args.block if block is not None]) :
]
for block_name, datafile in zip(block_list, datafile_list):
efuse = None
for block in efuses.blocks:
if block_name == block.name or block_name in block.alias:
efuse = efuses[block.name]
if efuse is None:
raise esptool.FatalError("Unknown block name - %s" % (block_name))
num_bytes = efuse.bit_len // 8
digest = espsecure._digest_sbv2_public_key(datafile)
if len(digest) != num_bytes:
raise esptool.FatalError(
"Incorrect digest size %d. Digest must be %d bytes (%d bits) "
"of raw binary key data." % (len(digest), num_bytes, num_bytes * 8)
)
digest_list.append(digest)
burn_key(esp, efuses, args, digest=digest_list)
def espefuse(esp, efuses, args, command):
parser = argparse.ArgumentParser()
subparsers = parser.add_subparsers(dest="operation")
add_commands(subparsers, efuses)
try:
cmd_line_args = parser.parse_args(command.split())
except SystemExit:
traceback.print_stack()
raise esptool.FatalError('"{}" - incorrect command'.format(command))
if cmd_line_args.operation == "execute_scripts":
configfiles = cmd_line_args.configfiles
index = cmd_line_args.index
# copy arguments from args to cmd_line_args
vars(cmd_line_args).update(vars(args))
if cmd_line_args.operation == "execute_scripts":
cmd_line_args.configfiles = configfiles
cmd_line_args.index = index
if cmd_line_args.operation is None:
parser.print_help()
parser.exit(1)
operation_func = globals()[cmd_line_args.operation]
# each 'operation' is a module-level function of the same name
operation_func(esp, efuses, cmd_line_args)
def execute_scripts(esp, efuses, args):
efuses.batch_mode_cnt += 1
del args.operation
scripts = args.scripts
del args.scripts
for file in scripts:
with open(file.name, "r") as file:
exec(compile(file.read(), file.name, "exec"))
if args.debug:
for block in efuses.blocks:
data = block.get_bitstring(from_read=False)
block.print_block(data, "regs_for_burn", args.debug)
efuses.batch_mode_cnt -= 1
if not efuses.burn_all(check_batch_mode=True):
return
print("Successful")
| 18,953 | Python | .py | 455 | 33.103297 | 93 | 0.609434 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,680 | fields.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32s3beta2/fields.py | # This file describes eFuses for ESP32-S3 chip
#
# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import binascii
import struct
import time
from bitstring import BitArray
import esptool
import reedsolo
from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters
from .. import base_fields
from .. import util
class EfuseBlock(base_fields.EfuseBlockBase):
def len_of_burn_unit(self):
# The writing register window is 8 registers for any blocks.
# len in bytes
return 8 * 4
def __init__(self, parent, param, skip_read=False):
parent.read_coding_scheme()
super(EfuseBlock, self).__init__(parent, param, skip_read=skip_read)
def apply_coding_scheme(self):
data = self.get_raw(from_read=False)[::-1]
if len(data) < self.len_of_burn_unit():
add_empty_bytes = self.len_of_burn_unit() - len(data)
data = data + (b"\x00" * add_empty_bytes)
if self.get_coding_scheme() == self.parent.REGS.CODING_SCHEME_RS:
# takes 32 bytes
# apply RS encoding
rs = reedsolo.RSCodec(12)
# 32 byte of data + 12 bytes RS
encoded_data = rs.encode([x for x in data])
words = struct.unpack("<" + "I" * 11, encoded_data)
# returns 11 words (8 words of data + 3 words of RS coding)
else:
# takes 32 bytes
words = struct.unpack("<" + ("I" * (len(data) // 4)), data)
# returns 8 words
return words
class EspEfuses(base_fields.EspEfusesBase):
"""
Wrapper object to manage the efuse fields in a connected ESP bootloader
"""
debug = False
do_not_confirm = False
def __init__(self, esp, skip_connect=False, debug=False, do_not_confirm=False):
self.Blocks = EfuseDefineBlocks()
self.Fields = EfuseDefineFields()
self.REGS = EfuseDefineRegisters
self.BURN_BLOCK_DATA_NAMES = self.Blocks.get_burn_block_data_names()
self.BLOCKS_FOR_KEYS = self.Blocks.get_blocks_for_keys()
self._esp = esp
self.debug = debug
self.do_not_confirm = do_not_confirm
if esp.CHIP_NAME != "ESP32-S3(beta2)":
raise esptool.FatalError(
"Expected the 'esp' param for ESP32-S3(beta2) chip but got for '%s'."
% (esp.CHIP_NAME)
)
if not skip_connect:
flags = self._esp.get_security_info()["flags"]
GET_SECURITY_INFO_FLAG_SECURE_DOWNLOAD_ENABLE = 1 << 2
if flags & GET_SECURITY_INFO_FLAG_SECURE_DOWNLOAD_ENABLE:
raise esptool.FatalError(
"Secure Download Mode is enabled. The tool can not read eFuses."
)
self.blocks = [
EfuseBlock(self, self.Blocks.get(block), skip_read=skip_connect)
for block in self.Blocks.BLOCKS
]
if not skip_connect:
self.get_coding_scheme_warnings()
self.efuses = [EfuseField.convert(self, efuse) for efuse in self.Fields.EFUSES]
self.efuses += [
EfuseField.convert(self, efuse) for efuse in self.Fields.KEYBLOCKS
]
if skip_connect:
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
]
else:
if self["BLK_VERSION_MAJOR"].get() == 1:
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
]
self.efuses += [
EfuseField.convert(self, efuse) for efuse in self.Fields.CALC
]
def __getitem__(self, efuse_name):
"""Return the efuse field with the given name"""
for e in self.efuses:
if efuse_name == e.name or any(x == efuse_name for x in e.alt_names):
return e
new_fields = False
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES:
if efuse.name == efuse_name or any(
x == efuse_name for x in efuse.alt_names
):
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
]
new_fields = True
if new_fields:
for e in self.efuses:
if efuse_name == e.name or any(x == efuse_name for x in e.alt_names):
return e
raise KeyError
def read_coding_scheme(self):
self.coding_scheme = self.REGS.CODING_SCHEME_RS
def print_status_regs(self):
print("")
self.blocks[0].print_block(self.blocks[0].err_bitarray, "err__regs", debug=True)
print(
"{:27} 0x{:08x}".format(
"EFUSE_RD_RS_ERR0_REG", self.read_reg(self.REGS.EFUSE_RD_RS_ERR0_REG)
)
)
print(
"{:27} 0x{:08x}".format(
"EFUSE_RD_RS_ERR1_REG", self.read_reg(self.REGS.EFUSE_RD_RS_ERR1_REG)
)
)
def efuse_controller_setup(self):
self.set_efuse_timing()
self.clear_pgm_registers()
self.wait_efuse_idle()
def write_efuses(self, block):
self.efuse_program(block)
return self.get_coding_scheme_warnings(silent=True)
def clear_pgm_registers(self):
self.wait_efuse_idle()
for r in range(
self.REGS.EFUSE_PGM_DATA0_REG, self.REGS.EFUSE_PGM_DATA0_REG + 32, 4
):
self.write_reg(r, 0)
def wait_efuse_idle(self):
deadline = time.time() + self.REGS.EFUSE_BURN_TIMEOUT
while time.time() < deadline:
# if self.read_reg(self.EFUSE_CMD_REG) == 0:
if self.read_reg(self.REGS.EFUSE_STATUS_REG) & 0x7 == 1:
return
raise esptool.FatalError(
"Timed out waiting for Efuse controller command to complete"
)
def efuse_program(self, block):
self.wait_efuse_idle()
self.write_reg(self.REGS.EFUSE_CONF_REG, self.REGS.EFUSE_WRITE_OP_CODE)
self.write_reg(self.REGS.EFUSE_CMD_REG, self.REGS.EFUSE_PGM_CMD | (block << 2))
self.wait_efuse_idle()
self.clear_pgm_registers()
self.efuse_read()
def efuse_read(self):
self.wait_efuse_idle()
self.write_reg(self.REGS.EFUSE_CONF_REG, self.REGS.EFUSE_READ_OP_CODE)
# need to add a delay after triggering EFUSE_READ_CMD, as ROM loader checks some
# efuse registers after each command is completed
# if ENABLE_SECURITY_DOWNLOAD or DIS_DOWNLOAD_MODE is enabled by the current cmd, then we need to try to reconnect to the chip.
try:
self.write_reg(
self.REGS.EFUSE_CMD_REG, self.REGS.EFUSE_READ_CMD, delay_after_us=1000
)
self.wait_efuse_idle()
except esptool.FatalError:
secure_download_mode_before = self._esp.secure_download_mode
try:
self._esp = self.reconnect_chip(self._esp)
except esptool.FatalError:
print("Can not re-connect to the chip")
if not self["DIS_DOWNLOAD_MODE"].get() and self[
"DIS_DOWNLOAD_MODE"
].get(from_read=False):
print(
"This is the correct behavior as we are actually burning "
"DIS_DOWNLOAD_MODE which disables the connection to the chip"
)
print("DIS_DOWNLOAD_MODE is enabled")
print("Successful")
exit(0) # finish without errors
raise
print("Established a connection with the chip")
if self._esp.secure_download_mode and not secure_download_mode_before:
print("Secure download mode is enabled")
if not self["ENABLE_SECURITY_DOWNLOAD"].get() and self[
"ENABLE_SECURITY_DOWNLOAD"
].get(from_read=False):
print(
"espefuse tool can not continue to work in Secure download mode"
)
print("ENABLE_SECURITY_DOWNLOAD is enabled")
print("Successful")
exit(0) # finish without errors
raise
def set_efuse_timing(self):
"""Set timing registers for burning efuses"""
# Configure clock
apb_freq = self.get_crystal_freq()
if apb_freq != 40:
raise esptool.FatalError(
"The eFuse supports only xtal=40M (xtal was %d)" % apb_freq
)
self.update_reg(self.REGS.EFUSE_DAC_CONF_REG, self.REGS.EFUSE_DAC_NUM_M, 0xFF)
self.update_reg(
self.REGS.EFUSE_DAC_CONF_REG, self.REGS.EFUSE_DAC_CLK_DIV_M, 0x28
)
self.update_reg(
self.REGS.EFUSE_WR_TIM_CONF1_REG, self.REGS.EFUSE_PWR_ON_NUM_M, 0x3000
)
self.update_reg(
self.REGS.EFUSE_WR_TIM_CONF2_REG, self.REGS.EFUSE_PWR_OFF_NUM_M, 0x190
)
def get_coding_scheme_warnings(self, silent=False):
"""Check if the coding scheme has detected any errors."""
old_addr_reg = 0
reg_value = 0
ret_fail = False
for block in self.blocks:
if block.id == 0:
words = [
self.read_reg(self.REGS.EFUSE_RD_REPEAT_ERR0_REG + offs * 4)
for offs in range(5)
]
block.err_bitarray.pos = 0
for word in reversed(words):
block.err_bitarray.overwrite(BitArray("uint:32=%d" % word))
block.num_errors = block.err_bitarray.count(True)
block.fail = block.num_errors != 0
else:
addr_reg, err_num_mask, err_num_offs, fail_bit = self.REGS.BLOCK_ERRORS[
block.id
]
if err_num_mask is None or err_num_offs is None or fail_bit is None:
continue
if addr_reg != old_addr_reg:
old_addr_reg = addr_reg
reg_value = self.read_reg(addr_reg)
block.fail = reg_value & (1 << fail_bit) != 0
block.num_errors = (reg_value >> err_num_offs) & err_num_mask
ret_fail |= block.fail
if not silent and (block.fail or block.num_errors):
print(
"Error(s) in BLOCK%d [ERRORS:%d FAIL:%d]"
% (block.id, block.num_errors, block.fail)
)
if (self.debug or ret_fail) and not silent:
self.print_status_regs()
return ret_fail
def summary(self):
if self["VDD_SPI_FORCE"].get() == 0:
output = "Flash voltage (VDD_SPI) determined by GPIO45 on reset "
output += "(GPIO45=High: VDD_SPI pin is powered from internal 1.8V LDO\n"
output += "GPIO45=Low or NC: VDD_SPI pin is powered directly from "
output += "VDD3P3_RTC_IO via resistor Rspi. "
output += "Typically this voltage is 3.3 V)."
elif self["VDD_SPI_XPD"].get() == 0:
output = "Flash voltage (VDD_SPI) internal regulator disabled by efuse."
elif self["VDD_SPI_TIEH"].get() == 0:
output = "Flash voltage (VDD_SPI) set to 1.8V by efuse."
else:
output = "Flash voltage (VDD_SPI) set to 3.3V by efuse."
return output
class EfuseField(base_fields.EfuseFieldBase):
@staticmethod
def convert(parent, efuse):
return {
"mac": EfuseMacField,
"keypurpose": EfuseKeyPurposeField,
"t_sensor": EfuseTempSensor,
"adc_tp": EfuseAdcPointCalibration,
"wafer": EfuseWafer,
}.get(efuse.class_type, EfuseField)(parent, efuse)
class EfuseWafer(EfuseField):
def get(self, from_read=True):
hi_bits = self.parent["WAFER_VERSION_MINOR_HI"].get(from_read)
assert self.parent["WAFER_VERSION_MINOR_HI"].bit_len == 1
lo_bits = self.parent["WAFER_VERSION_MINOR_LO"].get(from_read)
assert self.parent["WAFER_VERSION_MINOR_LO"].bit_len == 3
return (hi_bits << 3) + lo_bits
def save(self, new_value):
raise esptool.FatalError("Burning %s is not supported" % self.name)
class EfuseTempSensor(EfuseField):
def get(self, from_read=True):
value = self.get_bitstring(from_read)
sig = -1 if value[0] else 1
return sig * value[1:].uint * 0.1
class EfuseAdcPointCalibration(EfuseField):
def get(self, from_read=True):
STEP_SIZE = 4
value = self.get_bitstring(from_read)
sig = -1 if value[0] else 1
return sig * value[1:].uint * STEP_SIZE
class EfuseMacField(EfuseField):
def check_format(self, new_value_str):
if new_value_str is None:
raise esptool.FatalError(
"Required MAC Address in AA:CD:EF:01:02:03 format!"
)
if new_value_str.count(":") != 5:
raise esptool.FatalError(
"MAC Address needs to be a 6-byte hexadecimal format "
"separated by colons (:)!"
)
hexad = new_value_str.replace(":", "")
if len(hexad) != 12:
raise esptool.FatalError(
"MAC Address needs to be a 6-byte hexadecimal number "
"(12 hexadecimal characters)!"
)
# order of bytearray = b'\xaa\xcd\xef\x01\x02\x03',
bindata = binascii.unhexlify(hexad)
# unicast address check according to
# https://tools.ietf.org/html/rfc7042#section-2.1
if esptool.util.byte(bindata, 0) & 0x01:
raise esptool.FatalError("Custom MAC must be a unicast MAC!")
return bindata
def check(self):
errs, fail = self.parent.get_block_errors(self.block)
if errs != 0 or fail:
output = "Block%d has ERRORS:%d FAIL:%d" % (self.block, errs, fail)
else:
output = "OK"
return "(" + output + ")"
def get(self, from_read=True):
if self.name == "CUSTOM_MAC":
mac = self.get_raw(from_read)[::-1]
else:
mac = self.get_raw(from_read)
return "%s %s" % (util.hexify(mac, ":"), self.check())
def save(self, new_value):
def print_field(e, new_value):
print(
" - '{}' ({}) {} -> {}".format(
e.name, e.description, e.get_bitstring(), new_value
)
)
if self.name == "CUSTOM_MAC":
bitarray_mac = self.convert_to_bitstring(new_value)
print_field(self, bitarray_mac)
super(EfuseMacField, self).save(new_value)
else:
# Writing the BLOCK1 (MAC_SPI_8M_0) default MAC is not possible,
# as it's written in the factory.
raise esptool.FatalError("Writing Factory MAC address is not supported")
# fmt: off
class EfuseKeyPurposeField(EfuseField):
KEY_PURPOSES = [
("USER", 0, None, None, "no_need_rd_protect"), # User purposes (software-only use)
("RESERVED", 1, None, None, "no_need_rd_protect"), # Reserved
("XTS_AES_256_KEY_1", 2, None, "Reverse", "need_rd_protect"), # XTS_AES_256_KEY_1 (flash/PSRAM encryption)
("XTS_AES_256_KEY_2", 3, None, "Reverse", "need_rd_protect"), # XTS_AES_256_KEY_2 (flash/PSRAM encryption)
("XTS_AES_128_KEY", 4, None, "Reverse", "need_rd_protect"), # XTS_AES_128_KEY (flash/PSRAM encryption)
("HMAC_DOWN_ALL", 5, None, None, "need_rd_protect"), # HMAC Downstream mode
("HMAC_DOWN_JTAG", 6, None, None, "need_rd_protect"), # JTAG soft enable key (uses HMAC Downstream mode)
("HMAC_DOWN_DIGITAL_SIGNATURE", 7, None, None, "need_rd_protect"), # Digital Signature peripheral key (uses HMAC Downstream mode)
("HMAC_UP", 8, None, None, "need_rd_protect"), # HMAC Upstream mode
("SECURE_BOOT_DIGEST0", 9, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST0 (Secure Boot key digest)
("SECURE_BOOT_DIGEST1", 10, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST1 (Secure Boot key digest)
("SECURE_BOOT_DIGEST2", 11, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST2 (Secure Boot key digest)
("XTS_AES_256_KEY", -1, "VIRTUAL", None, "no_need_rd_protect"), # Virtual purpose splits to XTS_AES_256_KEY_1 and XTS_AES_256_KEY_2
]
# fmt: on
KEY_PURPOSES_NAME = [name[0] for name in KEY_PURPOSES]
DIGEST_KEY_PURPOSES = [name[0] for name in KEY_PURPOSES if name[2] == "DIGEST"]
def check_format(self, new_value_str):
# str convert to int: "XTS_AES_128_KEY" - > str(4)
# if int: 4 -> str(4)
raw_val = new_value_str
for purpose_name in self.KEY_PURPOSES:
if purpose_name[0] == new_value_str:
raw_val = str(purpose_name[1])
break
if raw_val.isdigit():
if int(raw_val) not in [p[1] for p in self.KEY_PURPOSES if p[1] > 0]:
raise esptool.FatalError("'%s' can not be set (value out of range)" % raw_val)
else:
raise esptool.FatalError("'%s' unknown name" % raw_val)
return raw_val
def need_reverse(self, new_key_purpose):
for key in self.KEY_PURPOSES:
if key[0] == new_key_purpose:
return key[3] == "Reverse"
def need_rd_protect(self, new_key_purpose):
for key in self.KEY_PURPOSES:
if key[0] == new_key_purpose:
return key[4] == "need_rd_protect"
def get(self, from_read=True):
for p in self.KEY_PURPOSES:
if p[1] == self.get_raw(from_read):
return p[0]
return "FORBIDDEN_STATE"
def get_name(self, raw_val):
for key in self.KEY_PURPOSES:
if key[1] == raw_val:
return key[0]
def save(self, new_value):
raw_val = int(self.check_format(str(new_value)))
str_new_value = self.get_name(raw_val)
if self.name == "KEY_PURPOSE_5" and str_new_value.startswith("XTS_AES"):
raise esptool.FatalError(f"{self.name} can not have {str_new_value} key due to a hardware bug (please see TRM for more details)")
return super(EfuseKeyPurposeField, self).save(raw_val)
| 18,898 | Python | .py | 403 | 35.610422 | 160 | 0.565364 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,681 | mem_definition.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32s3beta2/mem_definition.py | # This file describes eFuses fields and registers for ESP32-S3(beta2) chip
#
# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import os
import yaml
from ..mem_definition_base import (
EfuseBlocksBase,
EfuseFieldsBase,
EfuseRegistersBase,
Field,
)
class EfuseDefineRegisters(EfuseRegistersBase):
EFUSE_ADDR_MASK = 0x00000FFF
EFUSE_MEM_SIZE = 0x01FC + 4
# EFUSE registers & command/conf values
DR_REG_EFUSE_BASE = 0x6001A000
EFUSE_PGM_DATA0_REG = DR_REG_EFUSE_BASE
EFUSE_CHECK_VALUE0_REG = DR_REG_EFUSE_BASE + 0x020
EFUSE_CLK_REG = DR_REG_EFUSE_BASE + 0x1C8
EFUSE_CONF_REG = DR_REG_EFUSE_BASE + 0x1CC
EFUSE_STATUS_REG = DR_REG_EFUSE_BASE + 0x1D0
EFUSE_CMD_REG = DR_REG_EFUSE_BASE + 0x1D4
EFUSE_RD_RS_ERR0_REG = DR_REG_EFUSE_BASE + 0x1C0
EFUSE_RD_RS_ERR1_REG = DR_REG_EFUSE_BASE + 0x1C4
EFUSE_RD_REPEAT_ERR0_REG = DR_REG_EFUSE_BASE + 0x17C
EFUSE_RD_REPEAT_ERR1_REG = DR_REG_EFUSE_BASE + 0x180
EFUSE_RD_REPEAT_ERR2_REG = DR_REG_EFUSE_BASE + 0x184
EFUSE_RD_REPEAT_ERR3_REG = DR_REG_EFUSE_BASE + 0x188
EFUSE_RD_REPEAT_ERR4_REG = DR_REG_EFUSE_BASE + 0x18C
EFUSE_DAC_CONF_REG = DR_REG_EFUSE_BASE + 0x1E8
EFUSE_RD_TIM_CONF_REG = DR_REG_EFUSE_BASE + 0x1EC
EFUSE_WR_TIM_CONF1_REG = DR_REG_EFUSE_BASE + 0x1F4
EFUSE_WR_TIM_CONF2_REG = DR_REG_EFUSE_BASE + 0x1F8
EFUSE_DATE_REG = DR_REG_EFUSE_BASE + 0x1FC
EFUSE_WRITE_OP_CODE = 0x5A5A
EFUSE_READ_OP_CODE = 0x5AA5
EFUSE_PGM_CMD_MASK = 0x3
EFUSE_PGM_CMD = 0x2
EFUSE_READ_CMD = 0x1
BLOCK_ERRORS = [
# error_reg, err_num_mask, err_num_offs, fail_bit
(EFUSE_RD_REPEAT_ERR0_REG, None, None, None), # BLOCK0
(EFUSE_RD_RS_ERR0_REG, 0x7, 0, 3), # MAC_SPI_8M_0
(EFUSE_RD_RS_ERR0_REG, 0x7, 4, 7), # BLOCK_SYS_DATA
(EFUSE_RD_RS_ERR0_REG, 0x7, 8, 11), # BLOCK_USR_DATA
(EFUSE_RD_RS_ERR0_REG, 0x7, 12, 15), # BLOCK_KEY0
(EFUSE_RD_RS_ERR0_REG, 0x7, 16, 19), # BLOCK_KEY1
(EFUSE_RD_RS_ERR0_REG, 0x7, 20, 23), # BLOCK_KEY2
(EFUSE_RD_RS_ERR0_REG, 0x7, 24, 27), # BLOCK_KEY3
(EFUSE_RD_RS_ERR0_REG, 0x7, 28, 31), # BLOCK_KEY4
(EFUSE_RD_RS_ERR1_REG, 0x7, 0, 3), # BLOCK_KEY5
(EFUSE_RD_RS_ERR1_REG, 0x7, 4, 7), # BLOCK_SYS_DATA2
]
# EFUSE_WR_TIM_CONF2_REG
EFUSE_PWR_OFF_NUM_S = 0
EFUSE_PWR_OFF_NUM_M = 0xFFFF << EFUSE_PWR_OFF_NUM_S
# EFUSE_WR_TIM_CONF1_REG
EFUSE_PWR_ON_NUM_S = 8
EFUSE_PWR_ON_NUM_M = 0x0000FFFF << EFUSE_PWR_ON_NUM_S
# EFUSE_DAC_CONF_REG
EFUSE_DAC_CLK_DIV_S = 0
EFUSE_DAC_CLK_DIV_M = 0xFF << EFUSE_DAC_CLK_DIV_S
# EFUSE_DAC_CONF_REG
EFUSE_DAC_NUM_S = 9
EFUSE_DAC_NUM_M = 0xFF << EFUSE_DAC_NUM_S
class EfuseDefineBlocks(EfuseBlocksBase):
__base_rd_regs = EfuseDefineRegisters.DR_REG_EFUSE_BASE
__base_wr_regs = EfuseDefineRegisters.EFUSE_PGM_DATA0_REG
# List of efuse blocks
# fmt: off
BLOCKS = [
# Name, Alias, Index, Read address, Write address, Write protect bit, Read protect bit, Len, key_purpose
("BLOCK0", [], 0, __base_rd_regs + 0x02C, __base_wr_regs, None, None, 6, None),
("MAC_SPI_8M_0", ["BLOCK1"], 1, __base_rd_regs + 0x044, __base_wr_regs, 20, None, 6, None),
("BLOCK_SYS_DATA", ["BLOCK2"], 2, __base_rd_regs + 0x05C, __base_wr_regs, 21, None, 8, None),
("BLOCK_USR_DATA", ["BLOCK3"], 3, __base_rd_regs + 0x07C, __base_wr_regs, 22, None, 8, None),
("BLOCK_KEY0", ["BLOCK4"], 4, __base_rd_regs + 0x09C, __base_wr_regs, 23, 0, 8, "KEY_PURPOSE_0"),
("BLOCK_KEY1", ["BLOCK5"], 5, __base_rd_regs + 0x0BC, __base_wr_regs, 24, 1, 8, "KEY_PURPOSE_1"),
("BLOCK_KEY2", ["BLOCK6"], 6, __base_rd_regs + 0x0DC, __base_wr_regs, 25, 2, 8, "KEY_PURPOSE_2"),
("BLOCK_KEY3", ["BLOCK7"], 7, __base_rd_regs + 0x0FC, __base_wr_regs, 26, 3, 8, "KEY_PURPOSE_3"),
("BLOCK_KEY4", ["BLOCK8"], 8, __base_rd_regs + 0x11C, __base_wr_regs, 27, 4, 8, "KEY_PURPOSE_4"),
("BLOCK_KEY5", ["BLOCK9"], 9, __base_rd_regs + 0x13C, __base_wr_regs, 28, 5, 8, "KEY_PURPOSE_5"),
("BLOCK_SYS_DATA2", ["BLOCK10"], 10, __base_rd_regs + 0x15C, __base_wr_regs, 29, 6, 8, None),
]
# fmt: on
def get_burn_block_data_names(self):
list_of_names = []
for block in self.BLOCKS:
blk = self.get(block)
if blk.name:
list_of_names.append(blk.name)
if blk.alias:
for alias in blk.alias:
list_of_names.append(alias)
return list_of_names
class EfuseDefineFields(EfuseFieldsBase):
def __init__(self) -> None:
# List of efuse fields from TRM the chapter eFuse Controller.
self.EFUSES = []
self.KEYBLOCKS = []
# if BLK_VERSION_MAJOR is 1, these efuse fields are in BLOCK2
self.BLOCK2_CALIBRATION_EFUSES = []
self.CALC = []
dir_name = os.path.dirname(os.path.abspath(__file__))
dir_name, file_name = os.path.split(dir_name)
file_name = file_name + ".yaml"
dir_name, _ = os.path.split(dir_name)
efuse_file = os.path.join(dir_name, "efuse_defs", file_name)
efuse_file = efuse_file.replace("esp32s3beta2", "esp32s3")
with open(f"{efuse_file}", "r") as r_file:
e_desc = yaml.safe_load(r_file)
super().__init__(e_desc)
for i, efuse in enumerate(self.ALL_EFUSES):
if efuse.name in [
"BLOCK_USR_DATA",
"BLOCK_KEY0",
"BLOCK_KEY1",
"BLOCK_KEY2",
"BLOCK_KEY3",
"BLOCK_KEY4",
"BLOCK_KEY5",
"BLOCK_SYS_DATA2",
]:
if efuse.name == "BLOCK_USR_DATA":
efuse.bit_len = 256
efuse.type = "bytes:32"
self.KEYBLOCKS.append(efuse)
self.ALL_EFUSES[i] = None
elif efuse.category == "calibration":
self.BLOCK2_CALIBRATION_EFUSES.append(efuse)
self.ALL_EFUSES[i] = None
f = Field()
f.name = "WAFER_VERSION_MINOR"
f.block = 0
f.bit_len = 4
f.type = f"uint:{f.bit_len}"
f.category = "identity"
f.class_type = "wafer"
f.description = "calc WAFER VERSION MINOR = WAFER_VERSION_MINOR_HI << 3 + WAFER_VERSION_MINOR_LO (read only)"
self.CALC.append(f)
for efuse in self.ALL_EFUSES:
if efuse is not None:
self.EFUSES.append(efuse)
self.ALL_EFUSES = []
| 6,811 | Python | .py | 146 | 38.273973 | 139 | 0.575904 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,682 | emulate_efuse_controller.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32c3/emulate_efuse_controller.py | # This file describes eFuses controller for ESP32-C3 chip
#
# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import reedsolo
from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters
from ..emulate_efuse_controller_base import EmulateEfuseControllerBase, FatalError
class EmulateEfuseController(EmulateEfuseControllerBase):
"""The class for virtual efuse operation. Using for HOST_TEST."""
CHIP_NAME = "ESP32-C3"
mem = None
debug = False
def __init__(self, efuse_file=None, debug=False):
self.Blocks = EfuseDefineBlocks
self.Fields = EfuseDefineFields()
self.REGS = EfuseDefineRegisters
super(EmulateEfuseController, self).__init__(efuse_file, debug)
self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
""" esptool method start >>"""
def get_major_chip_version(self):
return 0
def get_minor_chip_version(self):
return 4
def get_crystal_freq(self):
return 40 # MHz (common for all chips)
def get_security_info(self):
return {
"flags": 0,
"flash_crypt_cnt": 0,
"key_purposes": 0,
"chip_id": 0,
"api_version": 0,
}
""" << esptool method end """
def handle_writing_event(self, addr, value):
if addr == self.REGS.EFUSE_CMD_REG:
if value & self.REGS.EFUSE_PGM_CMD:
self.copy_blocks_wr_regs_to_rd_regs(updated_block=(value >> 2) & 0xF)
self.clean_blocks_wr_regs()
self.check_rd_protection_area()
self.write_reg(addr, 0)
self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
elif value == self.REGS.EFUSE_READ_CMD:
self.write_reg(addr, 0)
self.write_reg(self.REGS.EFUSE_STATUS_REG, 1)
self.save_to_file()
def get_bitlen_of_block(self, blk, wr=False):
if blk.id == 0:
if wr:
return 32 * 8
else:
return 32 * blk.len
else:
if wr:
rs_coding = 32 * 3
return 32 * 8 + rs_coding
else:
return 32 * blk.len
def handle_coding_scheme(self, blk, data):
if blk.id != 0:
# CODING_SCHEME RS applied only for all blocks except BLK0.
coded_bytes = 12
data.pos = coded_bytes * 8
plain_data = data.readlist("32*uint:8")[::-1]
# takes 32 bytes
# apply RS encoding
rs = reedsolo.RSCodec(coded_bytes)
# 32 byte of data + 12 bytes RS
calc_encoded_data = list(rs.encode([x for x in plain_data]))
data.pos = 0
if calc_encoded_data != data.readlist("44*uint:8")[::-1]:
raise FatalError("Error in coding scheme data")
data = data[coded_bytes * 8 :]
if blk.len < 8:
data = data[(8 - blk.len) * 32 :]
return data
| 3,072 | Python | .py | 77 | 29.662338 | 86 | 0.575839 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,683 | __init__.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32c3/__init__.py | from . import operations
from .emulate_efuse_controller import EmulateEfuseController
from .fields import EspEfuses
| 116 | Python | .py | 3 | 37.666667 | 60 | 0.876106 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,684 | operations.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32c3/operations.py | # This file includes the operations with eFuses for ESP32-C3 chip
#
# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import argparse
import os # noqa: F401. It is used in IDF scripts
import traceback
import espsecure
import esptool
from . import fields
from .. import util
from ..base_operations import (
add_common_commands,
add_force_write_always,
add_show_sensitive_info_option,
burn_bit,
burn_block_data,
burn_efuse,
check_error,
dump,
read_protect_efuse,
summary,
write_protect_efuse,
)
def protect_options(p):
p.add_argument(
"--no-write-protect",
help="Disable write-protecting of the key. The key remains writable. "
"(The keys use the RS coding scheme that does not support "
"post-write data changes. Forced write can damage RS encoding bits.) "
"The write-protecting of keypurposes does not depend on the option, "
"it will be set anyway.",
action="store_true",
)
p.add_argument(
"--no-read-protect",
help="Disable read-protecting of the key. The key remains readable software."
"The key with keypurpose[USER, RESERVED and *_DIGEST] "
"will remain readable anyway. For the rest keypurposes the read-protection "
"will be defined the option (Read-protect by default).",
action="store_true",
)
def add_commands(subparsers, efuses):
add_common_commands(subparsers, efuses)
burn_key = subparsers.add_parser(
"burn_key", help="Burn the key block with the specified name"
)
protect_options(burn_key)
add_force_write_always(burn_key)
add_show_sensitive_info_option(burn_key)
burn_key.add_argument(
"block",
help="Key block to burn",
action="append",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key.add_argument(
"keyfile",
help="File containing 256 bits of binary key data",
action="append",
type=argparse.FileType("rb"),
)
burn_key.add_argument(
"keypurpose",
help="Purpose to set.",
action="append",
choices=fields.EfuseKeyPurposeField.KEY_PURPOSES_NAME,
)
for _ in efuses.BLOCKS_FOR_KEYS:
burn_key.add_argument(
"block",
help="Key block to burn",
nargs="?",
action="append",
metavar="BLOCK",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key.add_argument(
"keyfile",
help="File containing 256 bits of binary key data",
nargs="?",
action="append",
metavar="KEYFILE",
type=argparse.FileType("rb"),
)
burn_key.add_argument(
"keypurpose",
help="Purpose to set.",
nargs="?",
action="append",
metavar="KEYPURPOSE",
choices=fields.EfuseKeyPurposeField.KEY_PURPOSES_NAME,
)
burn_key_digest = subparsers.add_parser(
"burn_key_digest",
help="Parse a RSA public key and burn the digest to key efuse block",
)
protect_options(burn_key_digest)
add_force_write_always(burn_key_digest)
add_show_sensitive_info_option(burn_key_digest)
burn_key_digest.add_argument(
"block",
help="Key block to burn",
action="append",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key_digest.add_argument(
"keyfile",
help="Key file to digest (PEM format)",
action="append",
type=argparse.FileType("rb"),
)
burn_key_digest.add_argument(
"keypurpose",
help="Purpose to set.",
action="append",
choices=fields.EfuseKeyPurposeField.DIGEST_KEY_PURPOSES,
)
for _ in efuses.BLOCKS_FOR_KEYS:
burn_key_digest.add_argument(
"block",
help="Key block to burn",
nargs="?",
action="append",
metavar="BLOCK",
choices=efuses.BLOCKS_FOR_KEYS,
)
burn_key_digest.add_argument(
"keyfile",
help="Key file to digest (PEM format)",
nargs="?",
action="append",
metavar="KEYFILE",
type=argparse.FileType("rb"),
)
burn_key_digest.add_argument(
"keypurpose",
help="Purpose to set.",
nargs="?",
action="append",
metavar="KEYPURPOSE",
choices=fields.EfuseKeyPurposeField.DIGEST_KEY_PURPOSES,
)
p = subparsers.add_parser(
"set_flash_voltage",
help="Permanently set the internal flash voltage regulator "
"to either 1.8V, 3.3V or OFF. "
"This means GPIO45 can be high or low at reset without "
"changing the flash voltage.",
)
p.add_argument("voltage", help="Voltage selection", choices=["1.8V", "3.3V", "OFF"])
p = subparsers.add_parser(
"burn_custom_mac", help="Burn a 48-bit Custom MAC Address to EFUSE BLOCK3."
)
p.add_argument(
"mac",
help="Custom MAC Address to burn given in hexadecimal format with bytes "
"separated by colons (e.g. AA:CD:EF:01:02:03).",
type=fields.base_fields.CheckArgValue(efuses, "CUSTOM_MAC"),
)
add_force_write_always(p)
p = subparsers.add_parser("get_custom_mac", help="Prints the Custom MAC Address.")
def burn_custom_mac(esp, efuses, args):
efuses["CUSTOM_MAC"].save(args.mac)
if not efuses.burn_all(check_batch_mode=True):
return
get_custom_mac(esp, efuses, args)
print("Successful")
def get_custom_mac(esp, efuses, args):
print("Custom MAC Address: {}".format(efuses["CUSTOM_MAC"].get()))
def set_flash_voltage(esp, efuses, args):
raise esptool.FatalError("set_flash_voltage is not supported!")
def adc_info(esp, efuses, args):
print("")
# fmt: off
if efuses["BLK_VERSION_MAJOR"].get() == 1:
print("Temperature Sensor Calibration = {}C".format(efuses["TEMP_SENSOR_CAL"].get()))
print("")
print("ADC1 readings stored in efuse BLOCK2:")
print(" MODE0 D1 reading (250mV): {}".format(efuses["ADC1_MODE0_D1"].get()))
print(" MODE0 D2 reading (600mV): {}".format(efuses["ADC1_MODE0_D2"].get()))
print(" MODE1 D1 reading (250mV): {}".format(efuses["ADC1_MODE1_D1"].get()))
print(" MODE1 D2 reading (800mV): {}".format(efuses["ADC1_MODE1_D2"].get()))
print(" MODE2 D1 reading (250mV): {}".format(efuses["ADC1_MODE2_D1"].get()))
print(" MODE2 D2 reading (1000mV): {}".format(efuses["ADC1_MODE2_D2"].get()))
print(" MODE3 D1 reading (250mV): {}".format(efuses["ADC1_MODE3_D1"].get()))
print(" MODE3 D2 reading (2000mV): {}".format(efuses["ADC1_MODE3_D2"].get()))
print("")
print("ADC2 readings stored in efuse BLOCK2:")
print(" MODE0 D1 reading (250mV): {}".format(efuses["ADC2_MODE0_D1"].get()))
print(" MODE0 D2 reading (600mV): {}".format(efuses["ADC2_MODE0_D2"].get()))
print(" MODE1 D1 reading (250mV): {}".format(efuses["ADC2_MODE1_D1"].get()))
print(" MODE1 D2 reading (800mV): {}".format(efuses["ADC2_MODE1_D2"].get()))
print(" MODE2 D1 reading (250mV): {}".format(efuses["ADC2_MODE2_D1"].get()))
print(" MODE2 D2 reading (1000mV): {}".format(efuses["ADC2_MODE2_D2"].get()))
print(" MODE3 D1 reading (250mV): {}".format(efuses["ADC2_MODE3_D1"].get()))
print(" MODE3 D2 reading (2000mV): {}".format(efuses["ADC2_MODE3_D2"].get()))
else:
print("BLK_VERSION_MAJOR = {}".format(efuses["BLK_VERSION_MAJOR"].get_meaning()))
# fmt: on
def burn_key(esp, efuses, args, digest=None):
if digest is None:
datafile_list = args.keyfile[
0 : len([name for name in args.keyfile if name is not None]) :
]
else:
datafile_list = digest[0 : len([name for name in digest if name is not None]) :]
efuses.force_write_always = args.force_write_always
block_name_list = args.block[
0 : len([name for name in args.block if name is not None]) :
]
keypurpose_list = args.keypurpose[
0 : len([name for name in args.keypurpose if name is not None]) :
]
util.check_duplicate_name_in_list(block_name_list)
if len(block_name_list) != len(datafile_list) or len(block_name_list) != len(
keypurpose_list
):
raise esptool.FatalError(
"The number of blocks (%d), datafile (%d) and keypurpose (%d) "
"should be the same."
% (len(block_name_list), len(datafile_list), len(keypurpose_list))
)
print("Burn keys to blocks:")
for block_name, datafile, keypurpose in zip(
block_name_list, datafile_list, keypurpose_list
):
efuse = None
for block in efuses.blocks:
if block_name == block.name or block_name in block.alias:
efuse = efuses[block.name]
if efuse is None:
raise esptool.FatalError("Unknown block name - %s" % (block_name))
num_bytes = efuse.bit_len // 8
block_num = efuses.get_index_block_by_name(block_name)
block = efuses.blocks[block_num]
if digest is None:
data = datafile.read()
else:
data = datafile
print(" - %s" % (efuse.name), end=" ")
revers_msg = None
if efuses[block.key_purpose_name].need_reverse(keypurpose):
revers_msg = "\tReversing byte order for AES-XTS hardware peripheral"
data = data[::-1]
print(
"-> [{}]".format(
util.hexify(data, " ")
if args.show_sensitive_info
else " ".join(["??"] * len(data))
)
)
if revers_msg:
print(revers_msg)
if len(data) != num_bytes:
raise esptool.FatalError(
"Incorrect key file size %d. Key file must be %d bytes (%d bits) "
"of raw binary key data." % (len(data), num_bytes, num_bytes * 8)
)
if efuses[block.key_purpose_name].need_rd_protect(keypurpose):
read_protect = False if args.no_read_protect else True
else:
read_protect = False
write_protect = not args.no_write_protect
# using efuse instead of a block gives the advantage of checking it as the whole field.
efuse.save(data)
disable_wr_protect_key_purpose = False
if efuses[block.key_purpose_name].get() != keypurpose:
if efuses[block.key_purpose_name].is_writeable():
print(
"\t'%s': '%s' -> '%s'."
% (
block.key_purpose_name,
efuses[block.key_purpose_name].get(),
keypurpose,
)
)
efuses[block.key_purpose_name].save(keypurpose)
disable_wr_protect_key_purpose = True
else:
raise esptool.FatalError(
"It is not possible to change '%s' to '%s' "
"because write protection bit is set."
% (block.key_purpose_name, keypurpose)
)
else:
print("\t'%s' is already '%s'." % (block.key_purpose_name, keypurpose))
if efuses[block.key_purpose_name].is_writeable():
disable_wr_protect_key_purpose = True
if disable_wr_protect_key_purpose:
print("\tDisabling write to '%s'." % block.key_purpose_name)
efuses[block.key_purpose_name].disable_write()
if read_protect:
print("\tDisabling read to key block")
efuse.disable_read()
if write_protect:
print("\tDisabling write to key block")
efuse.disable_write()
print("")
if not write_protect:
print("Keys will remain writeable (due to --no-write-protect)")
if args.no_read_protect:
print("Keys will remain readable (due to --no-read-protect)")
if not efuses.burn_all(check_batch_mode=True):
return
print("Successful")
def burn_key_digest(esp, efuses, args):
digest_list = []
datafile_list = args.keyfile[
0 : len([name for name in args.keyfile if name is not None]) :
]
block_list = args.block[
0 : len([block for block in args.block if block is not None]) :
]
for block_name, datafile in zip(block_list, datafile_list):
efuse = None
for block in efuses.blocks:
if block_name == block.name or block_name in block.alias:
efuse = efuses[block.name]
if efuse is None:
raise esptool.FatalError("Unknown block name - %s" % (block_name))
num_bytes = efuse.bit_len // 8
digest = espsecure._digest_sbv2_public_key(datafile)
if len(digest) != num_bytes:
raise esptool.FatalError(
"Incorrect digest size %d. Digest must be %d bytes (%d bits) "
"of raw binary key data." % (len(digest), num_bytes, num_bytes * 8)
)
digest_list.append(digest)
burn_key(esp, efuses, args, digest=digest_list)
def espefuse(esp, efuses, args, command):
parser = argparse.ArgumentParser()
subparsers = parser.add_subparsers(dest="operation")
add_commands(subparsers, efuses)
try:
cmd_line_args = parser.parse_args(command.split())
except SystemExit:
traceback.print_stack()
raise esptool.FatalError('"{}" - incorrect command'.format(command))
if cmd_line_args.operation == "execute_scripts":
configfiles = cmd_line_args.configfiles
index = cmd_line_args.index
# copy arguments from args to cmd_line_args
vars(cmd_line_args).update(vars(args))
if cmd_line_args.operation == "execute_scripts":
cmd_line_args.configfiles = configfiles
cmd_line_args.index = index
if cmd_line_args.operation is None:
parser.print_help()
parser.exit(1)
operation_func = globals()[cmd_line_args.operation]
# each 'operation' is a module-level function of the same name
operation_func(esp, efuses, cmd_line_args)
def execute_scripts(esp, efuses, args):
efuses.batch_mode_cnt += 1
del args.operation
scripts = args.scripts
del args.scripts
for file in scripts:
with open(file.name, "r") as file:
exec(compile(file.read(), file.name, "exec"))
if args.debug:
for block in efuses.blocks:
data = block.get_bitstring(from_read=False)
block.print_block(data, "regs_for_burn", args.debug)
efuses.batch_mode_cnt -= 1
if not efuses.burn_all(check_batch_mode=True):
return
print("Successful")
| 14,960 | Python | .py | 370 | 31.52973 | 95 | 0.596506 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,685 | fields.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32c3/fields.py | # This file describes eFuses for ESP32-C3 chip
#
# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import binascii
import struct
import time
from bitstring import BitArray
import esptool
import reedsolo
from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters
from .. import base_fields
from .. import util
class EfuseBlock(base_fields.EfuseBlockBase):
def len_of_burn_unit(self):
# The writing register window is 8 registers for any blocks.
# len in bytes
return 8 * 4
def __init__(self, parent, param, skip_read=False):
parent.read_coding_scheme()
super(EfuseBlock, self).__init__(parent, param, skip_read=skip_read)
def apply_coding_scheme(self):
data = self.get_raw(from_read=False)[::-1]
if len(data) < self.len_of_burn_unit():
add_empty_bytes = self.len_of_burn_unit() - len(data)
data = data + (b"\x00" * add_empty_bytes)
if self.get_coding_scheme() == self.parent.REGS.CODING_SCHEME_RS:
# takes 32 bytes
# apply RS encoding
rs = reedsolo.RSCodec(12)
# 32 byte of data + 12 bytes RS
encoded_data = rs.encode([x for x in data])
words = struct.unpack("<" + "I" * 11, encoded_data)
# returns 11 words (8 words of data + 3 words of RS coding)
else:
# takes 32 bytes
words = struct.unpack("<" + ("I" * (len(data) // 4)), data)
# returns 8 words
return words
class EspEfuses(base_fields.EspEfusesBase):
"""
Wrapper object to manage the efuse fields in a connected ESP bootloader
"""
debug = False
do_not_confirm = False
def __init__(self, esp, skip_connect=False, debug=False, do_not_confirm=False):
self.Blocks = EfuseDefineBlocks()
self.Fields = EfuseDefineFields()
self.REGS = EfuseDefineRegisters
self.BURN_BLOCK_DATA_NAMES = self.Blocks.get_burn_block_data_names()
self.BLOCKS_FOR_KEYS = self.Blocks.get_blocks_for_keys()
self._esp = esp
self.debug = debug
self.do_not_confirm = do_not_confirm
if esp.CHIP_NAME != "ESP32-C3":
raise esptool.FatalError(
"Expected the 'esp' param for ESP32-C3 chip but got for '%s'."
% (esp.CHIP_NAME)
)
if not skip_connect:
flags = self._esp.get_security_info()["flags"]
GET_SECURITY_INFO_FLAG_SECURE_DOWNLOAD_ENABLE = 1 << 2
if flags & GET_SECURITY_INFO_FLAG_SECURE_DOWNLOAD_ENABLE:
raise esptool.FatalError(
"Secure Download Mode is enabled. The tool can not read eFuses."
)
self.blocks = [
EfuseBlock(self, self.Blocks.get(block), skip_read=skip_connect)
for block in self.Blocks.BLOCKS
]
if not skip_connect:
self.get_coding_scheme_warnings()
self.efuses = [EfuseField.convert(self, efuse) for efuse in self.Fields.EFUSES]
self.efuses += [
EfuseField.convert(self, efuse) for efuse in self.Fields.KEYBLOCKS
]
if skip_connect:
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
]
else:
if self["BLK_VERSION_MAJOR"].get() == 1:
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
]
self.efuses += [
EfuseField.convert(self, efuse) for efuse in self.Fields.CALC
]
def __getitem__(self, efuse_name):
"""Return the efuse field with the given name"""
for e in self.efuses:
if efuse_name == e.name or any(x == efuse_name for x in e.alt_names):
return e
new_fields = False
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES:
if efuse.name == efuse_name or any(
x == efuse_name for x in efuse.alt_names
):
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
]
new_fields = True
if new_fields:
for e in self.efuses:
if efuse_name == e.name or any(x == efuse_name for x in e.alt_names):
return e
raise KeyError
def read_coding_scheme(self):
self.coding_scheme = self.REGS.CODING_SCHEME_RS
def print_status_regs(self):
print("")
self.blocks[0].print_block(self.blocks[0].err_bitarray, "err__regs", debug=True)
print(
"{:27} 0x{:08x}".format(
"EFUSE_RD_RS_ERR0_REG", self.read_reg(self.REGS.EFUSE_RD_RS_ERR0_REG)
)
)
print(
"{:27} 0x{:08x}".format(
"EFUSE_RD_RS_ERR1_REG", self.read_reg(self.REGS.EFUSE_RD_RS_ERR1_REG)
)
)
def efuse_controller_setup(self):
self.set_efuse_timing()
self.clear_pgm_registers()
self.wait_efuse_idle()
def write_efuses(self, block):
self.efuse_program(block)
return self.get_coding_scheme_warnings(silent=True)
def clear_pgm_registers(self):
self.wait_efuse_idle()
for r in range(
self.REGS.EFUSE_PGM_DATA0_REG, self.REGS.EFUSE_PGM_DATA0_REG + 32, 4
):
self.write_reg(r, 0)
def wait_efuse_idle(self):
deadline = time.time() + self.REGS.EFUSE_BURN_TIMEOUT
while time.time() < deadline:
# if self.read_reg(self.REGS.EFUSE_CMD_REG) == 0:
if self.read_reg(self.REGS.EFUSE_STATUS_REG) & 0x7 == 1:
return
raise esptool.FatalError(
"Timed out waiting for Efuse controller command to complete"
)
def efuse_program(self, block):
self.wait_efuse_idle()
self.write_reg(self.REGS.EFUSE_CONF_REG, self.REGS.EFUSE_WRITE_OP_CODE)
self.write_reg(self.REGS.EFUSE_CMD_REG, self.REGS.EFUSE_PGM_CMD | (block << 2))
self.wait_efuse_idle()
self.clear_pgm_registers()
self.efuse_read()
def efuse_read(self):
self.wait_efuse_idle()
self.write_reg(self.REGS.EFUSE_CONF_REG, self.REGS.EFUSE_READ_OP_CODE)
# need to add a delay after triggering EFUSE_READ_CMD, as ROM loader checks some
# efuse registers after each command is completed
# if ENABLE_SECURITY_DOWNLOAD or DIS_DOWNLOAD_MODE is enabled by the current cmd, then we need to try to reconnect to the chip.
try:
self.write_reg(
self.REGS.EFUSE_CMD_REG, self.REGS.EFUSE_READ_CMD, delay_after_us=1000
)
self.wait_efuse_idle()
except esptool.FatalError:
secure_download_mode_before = self._esp.secure_download_mode
try:
self._esp = self.reconnect_chip(self._esp)
except esptool.FatalError:
print("Can not re-connect to the chip")
if not self["DIS_DOWNLOAD_MODE"].get() and self[
"DIS_DOWNLOAD_MODE"
].get(from_read=False):
print(
"This is the correct behavior as we are actually burning "
"DIS_DOWNLOAD_MODE which disables the connection to the chip"
)
print("DIS_DOWNLOAD_MODE is enabled")
print("Successful")
exit(0) # finish without errors
raise
print("Established a connection with the chip")
if self._esp.secure_download_mode and not secure_download_mode_before:
print("Secure download mode is enabled")
if not self["ENABLE_SECURITY_DOWNLOAD"].get() and self[
"ENABLE_SECURITY_DOWNLOAD"
].get(from_read=False):
print(
"espefuse tool can not continue to work in Secure download mode"
)
print("ENABLE_SECURITY_DOWNLOAD is enabled")
print("Successful")
exit(0) # finish without errors
raise
def set_efuse_timing(self):
"""Set timing registers for burning efuses"""
# Configure clock
apb_freq = self.get_crystal_freq()
if apb_freq != 40:
raise esptool.FatalError(
"The eFuse supports only xtal=40M (xtal was %d)" % apb_freq
)
self.update_reg(self.REGS.EFUSE_DAC_CONF_REG, self.REGS.EFUSE_DAC_NUM_M, 0xFF)
self.update_reg(
self.REGS.EFUSE_DAC_CONF_REG, self.REGS.EFUSE_DAC_CLK_DIV_M, 0x28
)
self.update_reg(
self.REGS.EFUSE_WR_TIM_CONF1_REG, self.REGS.EFUSE_PWR_ON_NUM_M, 0x3000
)
self.update_reg(
self.REGS.EFUSE_WR_TIM_CONF2_REG, self.REGS.EFUSE_PWR_OFF_NUM_M, 0x190
)
def get_coding_scheme_warnings(self, silent=False):
"""Check if the coding scheme has detected any errors."""
ret_fail = False
for block in self.blocks:
if block.id == 0:
words = [
self.read_reg(self.REGS.EFUSE_RD_REPEAT_ERR0_REG + offs * 4)
for offs in range(5)
]
block.err_bitarray.pos = 0
for word in reversed(words):
block.err_bitarray.overwrite(BitArray("uint:32=%d" % word))
block.num_errors = block.err_bitarray.count(True)
block.fail = block.num_errors != 0
else:
addr_reg_f, fail_bit = self.REGS.BLOCK_FAIL_BIT[block.id]
if fail_bit is None:
block.fail = False
else:
block.fail = self.read_reg(addr_reg_f) & (1 << fail_bit) != 0
addr_reg_n, num_mask, num_offs = self.REGS.BLOCK_NUM_ERRORS[block.id]
if num_mask is None or num_offs is None:
block.num_errors = 0
else:
block.num_errors = (
self.read_reg(addr_reg_n) >> num_offs
) & num_mask
ret_fail |= block.fail
if not silent and (block.fail or block.num_errors):
print(
"Error(s) in BLOCK%d [ERRORS:%d FAIL:%d]"
% (block.id, block.num_errors, block.fail)
)
if (self.debug or ret_fail) and not silent:
self.print_status_regs()
return ret_fail
def summary(self):
# TODO add support set_flash_voltage - "Flash voltage (VDD_SPI)"
return ""
class EfuseField(base_fields.EfuseFieldBase):
@staticmethod
def convert(parent, efuse):
return {
"mac": EfuseMacField,
"keypurpose": EfuseKeyPurposeField,
"t_sensor": EfuseTempSensor,
"adc_tp": EfuseAdcPointCalibration,
"wafer": EfuseWafer,
}.get(efuse.class_type, EfuseField)(parent, efuse)
class EfuseWafer(EfuseField):
def get(self, from_read=True):
hi_bits = self.parent["WAFER_VERSION_MINOR_HI"].get(from_read)
assert self.parent["WAFER_VERSION_MINOR_HI"].bit_len == 1
lo_bits = self.parent["WAFER_VERSION_MINOR_LO"].get(from_read)
assert self.parent["WAFER_VERSION_MINOR_LO"].bit_len == 3
return (hi_bits << 3) + lo_bits
def save(self, new_value):
raise esptool.FatalError("Burning %s is not supported" % self.name)
class EfuseTempSensor(EfuseField):
def get(self, from_read=True):
value = self.get_bitstring(from_read)
sig = -1 if value[0] else 1
return sig * value[1:].uint * 0.1
class EfuseAdcPointCalibration(EfuseField):
def get(self, from_read=True):
STEP_SIZE = 4
value = self.get_bitstring(from_read)
sig = -1 if value[0] else 1
return sig * value[1:].uint * STEP_SIZE
class EfuseMacField(EfuseField):
def check_format(self, new_value_str):
if new_value_str is None:
raise esptool.FatalError(
"Required MAC Address in AA:CD:EF:01:02:03 format!"
)
if new_value_str.count(":") != 5:
raise esptool.FatalError(
"MAC Address needs to be a 6-byte hexadecimal format "
"separated by colons (:)!"
)
hexad = new_value_str.replace(":", "")
if len(hexad) != 12:
raise esptool.FatalError(
"MAC Address needs to be a 6-byte hexadecimal number "
"(12 hexadecimal characters)!"
)
# order of bytearray = b'\xaa\xcd\xef\x01\x02\x03',
bindata = binascii.unhexlify(hexad)
# unicast address check according to
# https://tools.ietf.org/html/rfc7042#section-2.1
if esptool.util.byte(bindata, 0) & 0x01:
raise esptool.FatalError("Custom MAC must be a unicast MAC!")
return bindata
def check(self):
errs, fail = self.parent.get_block_errors(self.block)
if errs != 0 or fail:
output = "Block%d has ERRORS:%d FAIL:%d" % (self.block, errs, fail)
else:
output = "OK"
return "(" + output + ")"
def get(self, from_read=True):
if self.name == "CUSTOM_MAC":
mac = self.get_raw(from_read)[::-1]
else:
mac = self.get_raw(from_read)
return "%s %s" % (util.hexify(mac, ":"), self.check())
def save(self, new_value):
def print_field(e, new_value):
print(
" - '{}' ({}) {} -> {}".format(
e.name, e.description, e.get_bitstring(), new_value
)
)
if self.name == "CUSTOM_MAC":
bitarray_mac = self.convert_to_bitstring(new_value)
print_field(self, bitarray_mac)
super(EfuseMacField, self).save(new_value)
else:
# Writing the BLOCK1 (MAC_SPI_8M_0) default MAC is not possible,
# as it's written in the factory.
raise esptool.FatalError("Writing Factory MAC address is not supported")
# fmt: off
class EfuseKeyPurposeField(EfuseField):
KEY_PURPOSES = [
("USER", 0, None, None, "no_need_rd_protect"), # User purposes (software-only use)
("RESERVED", 1, None, None, "no_need_rd_protect"), # Reserved
("XTS_AES_128_KEY", 4, None, "Reverse", "need_rd_protect"), # XTS_AES_128_KEY (flash/PSRAM encryption)
("HMAC_DOWN_ALL", 5, None, None, "need_rd_protect"), # HMAC Downstream mode
("HMAC_DOWN_JTAG", 6, None, None, "need_rd_protect"), # JTAG soft enable key (uses HMAC Downstream mode)
("HMAC_DOWN_DIGITAL_SIGNATURE", 7, None, None, "need_rd_protect"), # Digital Signature peripheral key (uses HMAC Downstream mode)
("HMAC_UP", 8, None, None, "need_rd_protect"), # HMAC Upstream mode
("SECURE_BOOT_DIGEST0", 9, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST0 (Secure Boot key digest)
("SECURE_BOOT_DIGEST1", 10, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST1 (Secure Boot key digest)
("SECURE_BOOT_DIGEST2", 11, "DIGEST", None, "no_need_rd_protect"), # SECURE_BOOT_DIGEST2 (Secure Boot key digest)
]
# fmt: on
KEY_PURPOSES_NAME = [name[0] for name in KEY_PURPOSES]
DIGEST_KEY_PURPOSES = [name[0] for name in KEY_PURPOSES if name[2] == "DIGEST"]
def check_format(self, new_value_str):
# str convert to int: "XTS_AES_128_KEY" - > str(4)
# if int: 4 -> str(4)
raw_val = new_value_str
for purpose_name in self.KEY_PURPOSES:
if purpose_name[0] == new_value_str:
raw_val = str(purpose_name[1])
break
if raw_val.isdigit():
if int(raw_val) not in [p[1] for p in self.KEY_PURPOSES if p[1] > 0]:
raise esptool.FatalError("'%s' can not be set (value out of range)" % raw_val)
else:
raise esptool.FatalError("'%s' unknown name" % raw_val)
return raw_val
def need_reverse(self, new_key_purpose):
for key in self.KEY_PURPOSES:
if key[0] == new_key_purpose:
return key[3] == "Reverse"
def need_rd_protect(self, new_key_purpose):
for key in self.KEY_PURPOSES:
if key[0] == new_key_purpose:
return key[4] == "need_rd_protect"
def get(self, from_read=True):
for p in self.KEY_PURPOSES:
if p[1] == self.get_raw(from_read):
return p[0]
return "FORBIDDEN_STATE"
def get_name(self, raw_val):
for key in self.KEY_PURPOSES:
if key[1] == raw_val:
return key[0]
def save(self, new_value):
raw_val = int(self.check_format(str(new_value)))
str_new_value = self.get_name(raw_val)
if self.name == "KEY_PURPOSE_5" and str_new_value.startswith("XTS_AES"):
raise esptool.FatalError(f"{self.name} can not have {str_new_value} key due to a hardware bug (please see TRM for more details)")
return super(EfuseKeyPurposeField, self).save(raw_val)
| 17,803 | Python | .py | 389 | 34.40874 | 155 | 0.564714 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,686 | mem_definition.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32c3/mem_definition.py | # This file describes eFuses fields and registers for ESP32-C3 chip
#
# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import os
import yaml
from ..mem_definition_base import (
EfuseBlocksBase,
EfuseFieldsBase,
EfuseRegistersBase,
Field,
)
class EfuseDefineRegisters(EfuseRegistersBase):
EFUSE_MEM_SIZE = 0x01FC + 4
# EFUSE registers & command/conf values
DR_REG_EFUSE_BASE = 0x60008800
EFUSE_PGM_DATA0_REG = DR_REG_EFUSE_BASE
EFUSE_CHECK_VALUE0_REG = DR_REG_EFUSE_BASE + 0x020
EFUSE_CLK_REG = DR_REG_EFUSE_BASE + 0x1C8
EFUSE_CONF_REG = DR_REG_EFUSE_BASE + 0x1CC
EFUSE_STATUS_REG = DR_REG_EFUSE_BASE + 0x1D0
EFUSE_CMD_REG = DR_REG_EFUSE_BASE + 0x1D4
EFUSE_RD_RS_ERR0_REG = DR_REG_EFUSE_BASE + 0x1C0
EFUSE_RD_RS_ERR1_REG = DR_REG_EFUSE_BASE + 0x1C4
EFUSE_RD_REPEAT_ERR0_REG = DR_REG_EFUSE_BASE + 0x17C
EFUSE_RD_REPEAT_ERR1_REG = DR_REG_EFUSE_BASE + 0x180
EFUSE_RD_REPEAT_ERR2_REG = DR_REG_EFUSE_BASE + 0x184
EFUSE_RD_REPEAT_ERR3_REG = DR_REG_EFUSE_BASE + 0x188
EFUSE_RD_REPEAT_ERR4_REG = DR_REG_EFUSE_BASE + 0x18C
EFUSE_DAC_CONF_REG = DR_REG_EFUSE_BASE + 0x1E8
EFUSE_RD_TIM_CONF_REG = DR_REG_EFUSE_BASE + 0x1EC
EFUSE_WR_TIM_CONF1_REG = DR_REG_EFUSE_BASE + 0x1F0
EFUSE_WR_TIM_CONF2_REG = DR_REG_EFUSE_BASE + 0x1F4
EFUSE_DATE_REG = DR_REG_EFUSE_BASE + 0x1FC
EFUSE_WRITE_OP_CODE = 0x5A5A
EFUSE_READ_OP_CODE = 0x5AA5
EFUSE_PGM_CMD_MASK = 0x3
EFUSE_PGM_CMD = 0x2
EFUSE_READ_CMD = 0x1
# this chip has a design error so fail_bit is shifted by one block but err_num is in the correct place
BLOCK_FAIL_BIT = [
# error_reg, fail_bit
(EFUSE_RD_REPEAT_ERR0_REG, None), # BLOCK0
(EFUSE_RD_RS_ERR0_REG, 7), # MAC_SPI_8M_0
(EFUSE_RD_RS_ERR0_REG, 11), # BLOCK_SYS_DATA
(EFUSE_RD_RS_ERR0_REG, 15), # BLOCK_USR_DATA
(EFUSE_RD_RS_ERR0_REG, 19), # BLOCK_KEY0
(EFUSE_RD_RS_ERR0_REG, 23), # BLOCK_KEY1
(EFUSE_RD_RS_ERR0_REG, 27), # BLOCK_KEY2
(EFUSE_RD_RS_ERR0_REG, 31), # BLOCK_KEY3
(EFUSE_RD_RS_ERR1_REG, 3), # BLOCK_KEY4
(EFUSE_RD_RS_ERR1_REG, 7), # BLOCK_KEY5
(EFUSE_RD_RS_ERR1_REG, None), # BLOCK_SYS_DATA2
]
BLOCK_NUM_ERRORS = [
# error_reg, err_num_mask, err_num_offs
(EFUSE_RD_REPEAT_ERR0_REG, None, None), # BLOCK0
(EFUSE_RD_RS_ERR0_REG, 0x7, 0), # MAC_SPI_8M_0
(EFUSE_RD_RS_ERR0_REG, 0x7, 4), # BLOCK_SYS_DATA
(EFUSE_RD_RS_ERR0_REG, 0x7, 8), # BLOCK_USR_DATA
(EFUSE_RD_RS_ERR0_REG, 0x7, 12), # BLOCK_KEY0
(EFUSE_RD_RS_ERR0_REG, 0x7, 16), # BLOCK_KEY1
(EFUSE_RD_RS_ERR0_REG, 0x7, 20), # BLOCK_KEY2
(EFUSE_RD_RS_ERR0_REG, 0x7, 24), # BLOCK_KEY3
(EFUSE_RD_RS_ERR0_REG, 0x7, 28), # BLOCK_KEY4
(EFUSE_RD_RS_ERR1_REG, 0x7, 0), # BLOCK_KEY5
(EFUSE_RD_RS_ERR1_REG, 0x7, 4), # BLOCK_SYS_DATA2
]
# EFUSE_WR_TIM_CONF2_REG
EFUSE_PWR_OFF_NUM_S = 0
EFUSE_PWR_OFF_NUM_M = 0xFFFF << EFUSE_PWR_OFF_NUM_S
# EFUSE_WR_TIM_CONF1_REG
EFUSE_PWR_ON_NUM_S = 8
EFUSE_PWR_ON_NUM_M = 0x0000FFFF << EFUSE_PWR_ON_NUM_S
# EFUSE_DAC_CONF_REG
EFUSE_DAC_CLK_DIV_S = 0
EFUSE_DAC_CLK_DIV_M = 0xFF << EFUSE_DAC_CLK_DIV_S
# EFUSE_DAC_CONF_REG
EFUSE_DAC_NUM_S = 9
EFUSE_DAC_NUM_M = 0xFF << EFUSE_DAC_NUM_S
class EfuseDefineBlocks(EfuseBlocksBase):
__base_rd_regs = EfuseDefineRegisters.DR_REG_EFUSE_BASE
__base_wr_regs = EfuseDefineRegisters.EFUSE_PGM_DATA0_REG
# List of efuse blocks
# fmt: off
BLOCKS = [
# Name, Alias, Index, Read address, Write address, Write protect bit, Read protect bit, Len, key_purpose
("BLOCK0", [], 0, __base_rd_regs + 0x02C, __base_wr_regs, None, None, 6, None),
("MAC_SPI_8M_0", ["BLOCK1"], 1, __base_rd_regs + 0x044, __base_wr_regs, 20, None, 6, None),
("BLOCK_SYS_DATA", ["BLOCK2"], 2, __base_rd_regs + 0x05C, __base_wr_regs, 21, None, 8, None),
("BLOCK_USR_DATA", ["BLOCK3"], 3, __base_rd_regs + 0x07C, __base_wr_regs, 22, None, 8, None),
("BLOCK_KEY0", ["BLOCK4"], 4, __base_rd_regs + 0x09C, __base_wr_regs, 23, 0, 8, "KEY_PURPOSE_0"),
("BLOCK_KEY1", ["BLOCK5"], 5, __base_rd_regs + 0x0BC, __base_wr_regs, 24, 1, 8, "KEY_PURPOSE_1"),
("BLOCK_KEY2", ["BLOCK6"], 6, __base_rd_regs + 0x0DC, __base_wr_regs, 25, 2, 8, "KEY_PURPOSE_2"),
("BLOCK_KEY3", ["BLOCK7"], 7, __base_rd_regs + 0x0FC, __base_wr_regs, 26, 3, 8, "KEY_PURPOSE_3"),
("BLOCK_KEY4", ["BLOCK8"], 8, __base_rd_regs + 0x11C, __base_wr_regs, 27, 4, 8, "KEY_PURPOSE_4"),
("BLOCK_KEY5", ["BLOCK9"], 9, __base_rd_regs + 0x13C, __base_wr_regs, 28, 5, 8, "KEY_PURPOSE_5"),
("BLOCK_SYS_DATA2", ["BLOCK10"], 10, __base_rd_regs + 0x15C, __base_wr_regs, 29, 6, 8, None),
]
# fmt: on
def get_burn_block_data_names(self):
list_of_names = []
for block in self.BLOCKS:
blk = self.get(block)
if blk.name:
list_of_names.append(blk.name)
if blk.alias:
for alias in blk.alias:
list_of_names.append(alias)
return list_of_names
class EfuseDefineFields(EfuseFieldsBase):
def __init__(self) -> None:
# List of efuse fields from TRM the chapter eFuse Controller.
self.EFUSES = []
self.KEYBLOCKS = []
# if BLK_VERSION_MAJOR is 1, these efuse fields are in BLOCK2
self.BLOCK2_CALIBRATION_EFUSES = []
self.CALC = []
dir_name = os.path.dirname(os.path.abspath(__file__))
dir_name, file_name = os.path.split(dir_name)
file_name = file_name + ".yaml"
dir_name, _ = os.path.split(dir_name)
efuse_file = os.path.join(dir_name, "efuse_defs", file_name)
with open(f"{efuse_file}", "r") as r_file:
e_desc = yaml.safe_load(r_file)
super().__init__(e_desc)
for i, efuse in enumerate(self.ALL_EFUSES):
if efuse.name in [
"BLOCK_USR_DATA",
"BLOCK_KEY0",
"BLOCK_KEY1",
"BLOCK_KEY2",
"BLOCK_KEY3",
"BLOCK_KEY4",
"BLOCK_KEY5",
"BLOCK_SYS_DATA2",
]:
if efuse.name == "BLOCK_USR_DATA":
efuse.bit_len = 256
efuse.type = "bytes:32"
self.KEYBLOCKS.append(efuse)
self.ALL_EFUSES[i] = None
elif efuse.category == "calibration":
self.BLOCK2_CALIBRATION_EFUSES.append(efuse)
self.ALL_EFUSES[i] = None
# It is not functional, a bug in the hardware
elif efuse.name == "JTAG_SEL_ENABLE":
self.ALL_EFUSES[i] = None
f = Field()
f.name = "WAFER_VERSION_MINOR"
f.block = 0
f.bit_len = 4
f.type = f"uint:{f.bit_len}"
f.category = "identity"
f.class_type = "wafer"
f.description = "calc WAFER VERSION MINOR = WAFER_VERSION_MINOR_HI << 3 + WAFER_VERSION_MINOR_LO (read only)"
self.CALC.append(f)
for efuse in self.ALL_EFUSES:
if efuse is not None:
self.EFUSES.append(efuse)
self.ALL_EFUSES = []
| 7,552 | Python | .py | 162 | 38.117284 | 140 | 0.573272 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,687 | emulate_efuse_controller.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32/emulate_efuse_controller.py | # This file describes eFuses controller for ESP32 chip
#
# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import time
from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters
from ..emulate_efuse_controller_base import EmulateEfuseControllerBase, FatalError
class EmulateEfuseController(EmulateEfuseControllerBase):
"""The class for virtual efuse operations. Using for HOST_TEST."""
CHIP_NAME = "ESP32"
mem = None
debug = False
def __init__(self, efuse_file=None, debug=False):
self.Blocks = EfuseDefineBlocks
self.Fields = EfuseDefineFields()
self.REGS = EfuseDefineRegisters
super(EmulateEfuseController, self).__init__(efuse_file, debug)
""" esptool method start >> """
def get_major_chip_version(self):
return 3
def get_minor_chip_version(self):
return 0
def get_crystal_freq(self):
return 40 # MHz (common for all chips)
def read_reg(self, addr):
if addr == self.REGS.APB_CTL_DATE_ADDR:
return self.REGS.APB_CTL_DATE_V << self.REGS.APB_CTL_DATE_S
else:
val = 0
if addr == self.REGS.EFUSE_BLK0_RDATA3_REG:
val = self.REGS.EFUSE_RD_CHIP_VER_REV1
if addr == self.REGS.EFUSE_BLK0_RDATA5_REG:
val = self.REGS.EFUSE_RD_CHIP_VER_REV2
return val | super(EmulateEfuseController, self).read_reg(addr)
""" << esptool method end """
def send_burn_cmd(self):
def wait_idle():
deadline = time.time() + self.REGS.EFUSE_BURN_TIMEOUT
while time.time() < deadline:
if self.read_reg(self.REGS.EFUSE_REG_CMD) == 0:
return
raise FatalError(
"Timed out waiting for Efuse controller command to complete"
)
self.write_reg(self.REGS.EFUSE_REG_CMD, self.REGS.EFUSE_CMD_WRITE)
wait_idle()
self.write_reg(self.REGS.EFUSE_REG_CONF, self.REGS.EFUSE_CONF_READ)
self.write_reg(self.REGS.EFUSE_REG_CMD, self.REGS.EFUSE_CMD_READ)
wait_idle()
def handle_writing_event(self, addr, value):
if addr == self.REGS.EFUSE_REG_CMD:
if value == self.REGS.EFUSE_CMD_WRITE:
self.write_reg(addr, 0)
elif value == self.REGS.EFUSE_CMD_READ:
self.copy_blocks_wr_regs_to_rd_regs()
self.clean_blocks_wr_regs()
self.check_rd_protection_area()
self.write_reg(addr, 0)
self.save_to_file()
def read_raw_coding_scheme(self):
return (
self.read_efuse(self.REGS.EFUSE_CODING_SCHEME_WORD)
& self.REGS.EFUSE_CODING_SCHEME_MASK
)
def write_raw_coding_scheme(self, value):
self.write_efuse(
self.REGS.EFUSE_CODING_SCHEME_WORD,
value & self.REGS.EFUSE_CODING_SCHEME_MASK,
)
self.send_burn_cmd()
if value != self.read_raw_coding_scheme():
raise FatalError(
"Error during a burning process to set the new coding scheme"
)
print("Set coding scheme = %d" % self.read_raw_coding_scheme())
def get_bitlen_of_block(self, blk, wr=False):
if blk.id == 0:
return 32 * blk.len
else:
coding_scheme = self.read_raw_coding_scheme()
if coding_scheme == self.REGS.CODING_SCHEME_NONE:
return 32 * blk.len
elif coding_scheme == self.REGS.CODING_SCHEME_34:
if wr:
return 32 * 8
else:
return 32 * blk.len * 3 // 4
else:
raise FatalError(
"The {} coding scheme is not supported".format(coding_scheme)
)
def handle_coding_scheme(self, blk, data):
# it verifies the coding scheme part of data and returns just data
if blk.id != 0 and self.read_raw_coding_scheme() == self.REGS.CODING_SCHEME_34:
# CODING_SCHEME 3/4 applied only for BLK1..3
# Takes 24 byte sequence to be represented in 3/4 encoding,
# returns 8 words suitable for writing "encoded" to an efuse block
data.pos = 0
for _ in range(0, 4):
xor_res = 0
mul_res = 0
chunk_data = data.readlist("8*uint:8")
chunk_data = chunk_data[::-1]
for i in range(0, 6):
byte_data = chunk_data[i]
xor_res ^= byte_data
mul_res += (i + 1) * bin(byte_data).count("1")
if xor_res != chunk_data[6] or mul_res != chunk_data[7]:
print(
"xor_res ",
xor_res,
chunk_data[6],
"mul_res",
mul_res,
chunk_data[7],
)
raise FatalError("Error in coding scheme data")
# cut the coded data
for i in range(0, 4):
del data[i * 6 * 8 : (i * 6 * 8) + 16]
return data
| 5,279 | Python | .py | 122 | 31.032787 | 87 | 0.557026 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,688 | __init__.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32/__init__.py | from . import operations
from .emulate_efuse_controller import EmulateEfuseController
from .fields import EspEfuses
| 116 | Python | .py | 3 | 37.666667 | 60 | 0.876106 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,689 | operations.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32/operations.py | # This file includes the operations with eFuses for ESP32 chip
#
# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import argparse
import os # noqa: F401. It is used in IDF scripts
import traceback
import espsecure
import esptool
from . import fields
from .. import util
from ..base_operations import (
add_common_commands,
add_force_write_always,
add_show_sensitive_info_option,
burn_bit,
burn_block_data,
burn_efuse,
check_error,
dump,
read_protect_efuse,
summary,
write_protect_efuse,
)
def add_commands(subparsers, efuses):
add_common_commands(subparsers, efuses)
p = subparsers.add_parser(
"burn_key",
help="Burn a 256-bit key to EFUSE: %s" % ", ".join(efuses.BLOCKS_FOR_KEYS),
)
p.add_argument(
"--no-protect-key",
help="Disable default read- and write-protecting of the key. "
"If this option is not set, once the key is flashed "
"it cannot be read back or changed.",
action="store_true",
)
add_force_write_always(p)
add_show_sensitive_info_option(p)
p.add_argument(
"block",
help='Key block to burn. "flash_encryption" (block1), '
'"secure_boot_v1" (block2), "secure_boot_v2" (block2)',
action="append",
choices=efuses.BLOCKS_FOR_KEYS,
)
p.add_argument(
"keyfile",
help="File containing 256 bits of binary key data",
action="append",
type=argparse.FileType("rb"),
)
for _ in efuses.BLOCKS_FOR_KEYS:
p.add_argument(
"block",
help='Key block to burn. "flash_encryption" (block1), '
'"secure_boot_v1" (block2), "secure_boot_v2" (block2)',
metavar="BLOCK",
nargs="?",
action="append",
choices=efuses.BLOCKS_FOR_KEYS,
)
p.add_argument(
"keyfile",
help="File containing 256 bits of binary key data",
metavar="KEYFILE",
nargs="?",
action="append",
type=argparse.FileType("rb"),
)
burn_key_digest = subparsers.add_parser(
"burn_key_digest",
help="Parse a RSA public key and burn the digest "
"to eFuse for use with Secure Boot V2",
)
burn_key_digest.add_argument(
"keyfile", help="Key file to digest (PEM format)", type=argparse.FileType("rb")
)
burn_key_digest.add_argument(
"--no-protect-key",
help="Disable default write-protecting of the key digest. "
"If this option is not set, once the key is flashed it cannot be changed.",
action="store_true",
)
add_force_write_always(burn_key_digest)
add_show_sensitive_info_option(burn_key_digest)
p = subparsers.add_parser(
"set_flash_voltage",
help="Permanently set the internal flash voltage regulator "
"to either 1.8V, 3.3V or OFF. This means GPIO12 can be high or low at reset "
"without changing the flash voltage.",
)
p.add_argument("voltage", help="Voltage selection", choices=["1.8V", "3.3V", "OFF"])
p = subparsers.add_parser(
"burn_custom_mac", help="Burn a 48-bit Custom MAC Address to EFUSE BLOCK3."
)
p.add_argument(
"mac",
help="Custom MAC Address to burn given in hexadecimal format "
"with bytes separated by colons "
"(e.g. AA:CD:EF:01:02:03).",
type=fields.base_fields.CheckArgValue(efuses, "CUSTOM_MAC"),
)
add_force_write_always(p)
p = subparsers.add_parser("get_custom_mac", help="Prints the Custom MAC Address.")
def burn_custom_mac(esp, efuses, args):
# Writing to BLK3:
# - MAC_VERSION = 1
# - CUSTOM_MAC = AA:CD:EF:01:02:03
# - CUSTOM_MAC_CRC = crc8(CUSTOM_MAC)
efuses["CUSTOM_MAC"].save(args.mac)
if not efuses.burn_all(check_batch_mode=True):
return
get_custom_mac(esp, efuses, args)
print("Successful")
def get_custom_mac(esp, efuses, args):
version = efuses["MAC_VERSION"].get()
if version > 0:
print(
"Custom MAC Address version {}: {}".format(
version, efuses["CUSTOM_MAC"].get()
)
)
else:
print("Custom MAC Address is not set in the device.")
def set_flash_voltage(esp, efuses, args):
sdio_force = efuses["XPD_SDIO_FORCE"]
sdio_tieh = efuses["XPD_SDIO_TIEH"]
sdio_reg = efuses["XPD_SDIO_REG"]
# check efuses aren't burned in a way which makes this impossible
if args.voltage == "OFF" and sdio_reg.get() != 0:
raise esptool.FatalError(
"Can't set flash regulator to OFF as XPD_SDIO_REG efuse is already burned"
)
if args.voltage == "1.8V" and sdio_tieh.get() != 0:
raise esptool.FatalError(
"Can't set regulator to 1.8V is XPD_SDIO_TIEH efuse is already burned"
)
if args.voltage == "OFF":
msg = "Disable internal flash voltage regulator (VDD_SDIO). "
"SPI flash will need to be powered from an external source.\n"
"The following efuse is burned: XPD_SDIO_FORCE.\n"
"It is possible to later re-enable the internal regulator (%s) " % (
"to 3.3V" if sdio_tieh.get() != 0 else "to 1.8V or 3.3V"
)
"by burning an additional efuse"
elif args.voltage == "1.8V":
msg = "Set internal flash voltage regulator (VDD_SDIO) to 1.8V.\n"
"The following efuses are burned: XPD_SDIO_FORCE, XPD_SDIO_REG.\n"
"It is possible to later increase the voltage to 3.3V (permanently) "
"by burning additional efuse XPD_SDIO_TIEH"
elif args.voltage == "3.3V":
msg = "Enable internal flash voltage regulator (VDD_SDIO) to 3.3V.\n"
"The following efuses are burned: XPD_SDIO_FORCE, XPD_SDIO_REG, XPD_SDIO_TIEH."
print(msg)
sdio_force.save(1) # Disable GPIO12
if args.voltage != "OFF":
sdio_reg.save(1) # Enable internal regulator
if args.voltage == "3.3V":
sdio_tieh.save(1)
print("VDD_SDIO setting complete.")
if not efuses.burn_all(check_batch_mode=True):
return
print("Successful")
def adc_info(esp, efuses, args):
adc_vref = efuses["ADC_VREF"]
blk3_reserve = efuses["BLK3_PART_RESERVE"]
vref_raw = adc_vref.get_raw()
if vref_raw == 0:
print("ADC VRef calibration: None (1100mV nominal)")
else:
print("ADC VRef calibration: %dmV" % adc_vref.get())
if blk3_reserve.get():
print("ADC readings stored in efuse BLOCK3:")
print(" ADC1 Low reading (150mV): %d" % efuses["ADC1_TP_LOW"].get())
print(" ADC1 High reading (850mV): %d" % efuses["ADC1_TP_HIGH"].get())
print(" ADC2 Low reading (150mV): %d" % efuses["ADC2_TP_LOW"].get())
print(" ADC2 High reading (850mV): %d" % efuses["ADC2_TP_HIGH"].get())
def burn_key(esp, efuses, args):
datafile_list = args.keyfile[
0 : len([keyfile for keyfile in args.keyfile if keyfile is not None]) :
]
block_name_list = args.block[
0 : len([block for block in args.block if block is not None]) :
]
efuses.force_write_always = args.force_write_always
no_protect_key = args.no_protect_key
util.check_duplicate_name_in_list(block_name_list)
if len(block_name_list) != len(datafile_list):
raise esptool.FatalError(
"The number of blocks (%d) and datafile (%d) should be the same."
% (len(block_name_list), len(datafile_list))
)
print("Burn keys to blocks:")
for block_name, datafile in zip(block_name_list, datafile_list):
efuse = None
for block in efuses.blocks:
if block_name == block.name or block_name in block.alias:
efuse = efuses[block.name]
if efuse is None:
raise esptool.FatalError("Unknown block name - %s" % (block_name))
num_bytes = efuse.bit_len // 8
data = datafile.read()
revers_msg = None
if block_name in ("flash_encryption", "secure_boot_v1"):
revers_msg = "\tReversing the byte order"
data = data[::-1]
print(" - %s" % (efuse.name), end=" ")
print(
"-> [{}]".format(
util.hexify(data, " ")
if args.show_sensitive_info
else " ".join(["??"] * len(data))
)
)
if revers_msg:
print(revers_msg)
if len(data) != num_bytes:
raise esptool.FatalError(
"Incorrect key file size %d. "
"Key file must be %d bytes (%d bits) of raw binary key data."
% (len(data), num_bytes, num_bytes * 8)
)
efuse.save(data)
if block_name in ("flash_encryption", "secure_boot_v1"):
if not no_protect_key:
print("\tDisabling read to key block")
efuse.disable_read()
if not no_protect_key:
print("\tDisabling write to key block")
efuse.disable_write()
print("")
if args.no_protect_key:
print("Key is left unprotected as per --no-protect-key argument.")
msg = "Burn keys in efuse blocks.\n"
if no_protect_key:
msg += (
"The key block will left readable and writeable (due to --no-protect-key)"
)
else:
msg += "The key block will be read and write protected "
"(no further changes or readback)"
print(msg, "\n")
if not efuses.burn_all(check_batch_mode=True):
return
print("Successful")
def burn_key_digest(esp, efuses, args):
if efuses.coding_scheme == efuses.REGS.CODING_SCHEME_34:
raise esptool.FatalError("burn_key_digest only works with 'None' coding scheme")
chip_revision = esp.get_chip_revision()
if chip_revision < 300:
raise esptool.FatalError(
"Incorrect chip revision for Secure boot v2. "
"Detected: v%d.%d. Expected: >= v3.0"
% (chip_revision / 100, chip_revision % 100)
)
digest = espsecure._digest_sbv2_public_key(args.keyfile)
efuse = efuses["BLOCK2"]
num_bytes = efuse.bit_len // 8
if len(digest) != num_bytes:
raise esptool.FatalError(
"Incorrect digest size %d. "
"Digest must be %d bytes (%d bits) of raw binary key data."
% (len(digest), num_bytes, num_bytes * 8)
)
print(" - %s" % (efuse.name), end=" ")
print(
"-> [{}]".format(
util.hexify(digest, " ")
if args.show_sensitive_info
else " ".join(["??"] * len(digest))
)
)
efuse.save(digest)
if not args.no_protect_key:
print("Disabling write to efuse %s..." % (efuse.name))
efuse.disable_write()
if not efuses.burn_all(check_batch_mode=True):
return
print("Successful")
def espefuse(esp, efuses, args, command):
parser = argparse.ArgumentParser()
subparsers = parser.add_subparsers(dest="operation")
add_commands(subparsers, efuses)
try:
cmd_line_args = parser.parse_args(command.split())
except SystemExit:
traceback.print_stack()
raise esptool.FatalError('"{}" - incorrect command'.format(command))
if cmd_line_args.operation == "execute_scripts":
configfiles = cmd_line_args.configfiles
index = cmd_line_args.index
# copy arguments from args to cmd_line_args
vars(cmd_line_args).update(vars(args))
if cmd_line_args.operation == "execute_scripts":
cmd_line_args.configfiles = configfiles
cmd_line_args.index = index
if cmd_line_args.operation is None:
parser.print_help()
parser.exit(1)
operation_func = globals()[cmd_line_args.operation]
# each 'operation' is a module-level function of the same name
operation_func(esp, efuses, cmd_line_args)
def execute_scripts(esp, efuses, args):
efuses.batch_mode_cnt += 1
del args.operation
scripts = args.scripts
del args.scripts
for file in scripts:
with open(file.name, "r") as file:
exec(compile(file.read(), file.name, "exec"))
if args.debug:
for block in efuses.blocks:
data = block.get_bitstring(from_read=False)
block.print_block(data, "regs_for_burn", args.debug)
efuses.batch_mode_cnt -= 1
if not efuses.burn_all(check_batch_mode=True):
return
print("Successful")
| 12,519 | Python | .py | 320 | 31.31875 | 88 | 0.610252 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,690 | fields.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32/fields.py | # This file describes eFuses for ESP32 chip
#
# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import binascii
import struct
import time
import esptool
from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters
from .. import base_fields
from .. import util
class EfuseBlock(base_fields.EfuseBlockBase):
def len_of_burn_unit(self):
# The writing register window is the same as len of a block.
return self.len
def __init__(self, parent, param, skip_read=False):
if skip_read:
parent.coding_scheme = parent.REGS.CODING_SCHEME_NONE
else:
if parent.coding_scheme is None:
parent.read_coding_scheme()
super(EfuseBlock, self).__init__(parent, param, skip_read=skip_read)
def apply_coding_scheme(self):
data = self.get_raw(from_read=False)[::-1]
if self.get_coding_scheme() == self.parent.REGS.CODING_SCHEME_34:
# CODING_SCHEME 3/4 applied only for BLK1..3
# Takes 24 byte sequence to be represented in 3/4 encoding,
# returns 8 words suitable for writing "encoded" to an efuse block
if len(data) != 24:
raise esptool.FatalError("Should take 24 bytes for 3/4 encoding.")
data = data[:24]
outbits = b""
while len(data) > 0: # process in chunks of 6 bytes
bits = data[0:6]
data = data[6:]
xor_res = 0
mul_res = 0
index = 1
for b in struct.unpack("B" * 6, bits):
xor_res ^= b
mul_res += index * util.popcnt(b)
index += 1
outbits += bits
outbits += struct.pack("BB", xor_res, mul_res)
words = struct.unpack("<" + "I" * (len(outbits) // 4), outbits)
# returns 8 words
else:
# CODING_SCHEME NONE applied for BLK0 and BLK1..3
# BLK0 len = 7 words, BLK1..3 len = 8 words.
words = struct.unpack("<" + ("I" * (len(data) // 4)), data)
# returns 7 words for BLK0 or 8 words for BLK1..3
return words
class EspEfuses(base_fields.EspEfusesBase):
"""
Wrapper object to manage the efuse fields in a connected ESP bootloader
"""
debug = False
do_not_confirm = False
def __init__(self, esp, skip_connect=False, debug=False, do_not_confirm=False):
self.Blocks = EfuseDefineBlocks()
self.Fields = EfuseDefineFields()
self.REGS = EfuseDefineRegisters
self.BURN_BLOCK_DATA_NAMES = self.Blocks.get_burn_block_data_names()
self.BLOCKS_FOR_KEYS = self.Blocks.get_blocks_for_keys()
self._esp = esp
self.debug = debug
self.do_not_confirm = do_not_confirm
if esp.CHIP_NAME != "ESP32":
raise esptool.FatalError(
"Expected the 'esp' param for ESP32 chip but got for '%s'."
% (esp.CHIP_NAME)
)
self.blocks = [
EfuseBlock(self, self.Blocks.get(block), skip_read=skip_connect)
for block in self.Blocks.BLOCKS
]
if not skip_connect:
self.get_coding_scheme_warnings()
self.efuses = [EfuseField.convert(self, efuse) for efuse in self.Fields.EFUSES]
if skip_connect:
self.efuses += [
EfuseField.convert(self, efuse) for efuse in self.Fields.KEYBLOCKS_256
]
self.efuses += [
EfuseField.convert(self, efuse) for efuse in self.Fields.CUSTOM_MAC
]
self.efuses += [
EfuseField.convert(self, efuse) for efuse in self.Fields.ADC_CALIBRATION
]
else:
if self.coding_scheme == self.REGS.CODING_SCHEME_NONE:
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.KEYBLOCKS_256
]
elif self.coding_scheme == self.REGS.CODING_SCHEME_34:
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.KEYBLOCKS_192
]
else:
raise esptool.FatalError(
"The coding scheme (%d) - is not supported" % self.coding_scheme
)
if self["MAC_VERSION"].get() == 1:
self.efuses += [
EfuseField.convert(self, efuse) for efuse in self.Fields.CUSTOM_MAC
]
if self["BLK3_PART_RESERVE"].get():
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.ADC_CALIBRATION
]
self.efuses += [
EfuseField.convert(self, efuse) for efuse in self.Fields.CALC
]
def __getitem__(self, efuse_name):
"""Return the efuse field with the given name"""
for e in self.efuses:
if efuse_name == e.name or any(x == efuse_name for x in e.alt_names):
return e
new_fields = False
for efuse in self.Fields.CUSTOM_MAC:
if efuse.name == efuse_name or any(
x == efuse_name for x in efuse.alt_names
):
self.efuses += [
EfuseField.convert(self, efuse) for efuse in self.Fields.CUSTOM_MAC
]
new_fields = True
for efuse in self.Fields.ADC_CALIBRATION:
if efuse.name == efuse_name or any(
x == efuse_name for x in efuse.alt_names
):
self.efuses += [
EfuseField.convert(self, efuse)
for efuse in self.Fields.ADC_CALIBRATION
]
new_fields = True
if new_fields:
for e in self.efuses:
if efuse_name == e.name or any(x == efuse_name for x in e.alt_names):
return e
raise KeyError
def read_coding_scheme(self):
self.coding_scheme = (
self.read_efuse(self.REGS.EFUSE_CODING_SCHEME_WORD)
& self.REGS.EFUSE_CODING_SCHEME_MASK
)
def print_status_regs(self):
print("")
print(
"{:27} 0x{:08x}".format(
"EFUSE_REG_DEC_STATUS", self.read_reg(self.REGS.EFUSE_REG_DEC_STATUS)
)
)
def write_efuses(self, block):
"""Write the values in the efuse write registers to
the efuse hardware, then refresh the efuse read registers.
"""
# Configure clock
apb_freq = self.get_crystal_freq()
clk_sel0, clk_sel1, dac_clk_div = self.REGS.EFUSE_CLK_SETTINGS[apb_freq]
self.update_reg(
self.REGS.EFUSE_DAC_CONF_REG, self.REGS.EFUSE_DAC_CLK_DIV_MASK, dac_clk_div
)
self.update_reg(
self.REGS.EFUSE_CLK_REG, self.REGS.EFUSE_CLK_SEL0_MASK, clk_sel0
)
self.update_reg(
self.REGS.EFUSE_CLK_REG, self.REGS.EFUSE_CLK_SEL1_MASK, clk_sel1
)
self.write_reg(self.REGS.EFUSE_REG_CONF, self.REGS.EFUSE_CONF_WRITE)
self.write_reg(self.REGS.EFUSE_REG_CMD, self.REGS.EFUSE_CMD_WRITE)
self.efuse_read()
return self.get_coding_scheme_warnings(silent=True)
def wait_efuse_idle(self):
deadline = time.time() + self.REGS.EFUSE_BURN_TIMEOUT
while time.time() < deadline:
if self.read_reg(self.REGS.EFUSE_REG_CMD) == 0:
return
raise esptool.FatalError(
"Timed out waiting for Efuse controller command to complete"
)
def efuse_read(self):
self.wait_efuse_idle()
self.write_reg(self.REGS.EFUSE_REG_CONF, self.REGS.EFUSE_CONF_READ)
self.write_reg(self.REGS.EFUSE_REG_CMD, self.REGS.EFUSE_CMD_READ)
self.wait_efuse_idle()
def get_coding_scheme_warnings(self, silent=False):
"""Check if the coding scheme has detected any errors.
Meaningless for default coding scheme (0)
"""
err = (
self.read_reg(self.REGS.EFUSE_REG_DEC_STATUS)
& self.REGS.EFUSE_REG_DEC_STATUS_MASK
)
for block in self.blocks:
if block.id != 0:
block.num_errors = 0
block.fail = err != 0
if not silent and block.fail:
print(
"Error(s) in BLOCK%d [ERRORS:%d FAIL:%d]"
% (block.id, block.num_errors, block.fail)
)
if (self.debug or err) and not silent:
self.print_status_regs()
return err != 0
def summary(self):
if self["XPD_SDIO_FORCE"].get() == 0:
output = "Flash voltage (VDD_SDIO) determined by GPIO12 on reset (High for 1.8V, Low/NC for 3.3V)"
elif self["XPD_SDIO_REG"].get() == 0:
output = "Flash voltage (VDD_SDIO) internal regulator disabled by efuse."
elif self["XPD_SDIO_TIEH"].get() == 0:
output = "Flash voltage (VDD_SDIO) set to 1.8V by efuse."
else:
output = "Flash voltage (VDD_SDIO) set to 3.3V by efuse."
return output
class EfuseField(base_fields.EfuseFieldBase):
@staticmethod
def convert(parent, efuse):
return {
"mac": EfuseMacField,
"spipin": EfuseSpiPinField,
"vref": EfuseVRefField,
"adc_tp": EfuseAdcPointCalibration,
"wafer": EfuseWafer,
"pkg": EfusePkg,
}.get(efuse.class_type, EfuseField)(parent, efuse)
class EfuseMacField(EfuseField):
"""
Supports: MAC and CUSTOM_MAC fields.
(if MAC_VERSION == 1 then the CUSTOM_MAC is used)
"""
def check_format(self, new_value_str):
if new_value_str is None:
raise esptool.FatalError(
"Required MAC Address in AA:CD:EF:01:02:03 format!"
)
if new_value_str.count(":") != 5:
raise esptool.FatalError(
"MAC Address needs to be a 6-byte hexadecimal format "
"separated by colons (:)!"
)
hexad = new_value_str.replace(":", "")
if len(hexad) != 12:
raise esptool.FatalError(
"MAC Address needs to be a 6-byte hexadecimal number "
"(12 hexadecimal characters)!"
)
# order of bytearray = b'\xaa\xcd\xef\x01\x02\x03',
bindata = binascii.unhexlify(hexad)
# unicast address check according to
# https://tools.ietf.org/html/rfc7042#section-2.1
if esptool.util.byte(bindata, 0) & 0x01:
raise esptool.FatalError("Custom MAC must be a unicast MAC!")
return bindata
@staticmethod
def get_and_check(raw_mac, stored_crc):
computed_crc = EfuseMacField.calc_crc(raw_mac)
if computed_crc == stored_crc:
valid_msg = "(CRC 0x%02x OK)" % stored_crc
else:
valid_msg = "(CRC 0x%02x invalid - calculated 0x%02x)" % (
stored_crc,
computed_crc,
)
return "%s %s" % (util.hexify(raw_mac, ":"), valid_msg)
@staticmethod
def calc_crc(raw_mac):
"""
This algorithm is the equivalent of esp_crc8() in ESP32 ROM code
This is CRC-8 w/ inverted polynomial value 0x8C & initial value 0x00.
"""
result = 0x00
for b in struct.unpack("B" * 6, raw_mac):
result ^= b
for _ in range(8):
lsb = result & 1
result >>= 1
if lsb != 0:
result ^= 0x8C
return result
def get(self, from_read=True):
if self.name == "CUSTOM_MAC":
mac = self.get_raw(from_read)[::-1]
stored_crc = self.parent["CUSTOM_MAC_CRC"].get(from_read)
else:
mac = self.get_raw(from_read)
stored_crc = self.parent["MAC_CRC"].get(from_read)
return EfuseMacField.get_and_check(mac, stored_crc)
def save(self, new_value):
def print_field(e, new_value):
print(
" - '{}' ({}) {} -> {}".format(
e.name, e.description, e.get_bitstring(), new_value
)
)
if self.name == "CUSTOM_MAC":
# Writing the BLK3:
# - MAC_VERSION = 1
# - CUSTOM_MAC = AB:CD:EF:01:02:03
# - CUSTOM_MAC_CRC = crc8(CUSTOM_MAC)
mac_version = self.parent["MAC_VERSION"]
if mac_version.get() == 0:
mac_version_value = 1
print_field(mac_version, hex(mac_version_value))
mac_version.save(mac_version_value)
else:
if mac_version.get() != 1:
if not self.parent.force_write_always:
raise esptool.FatalError(
"MAC_VERSION = {}, should be 0 or 1.".format(
mac_version.get()
)
)
bitarray_mac = self.convert_to_bitstring(new_value)
print_field(self, bitarray_mac)
super(EfuseMacField, self).save(new_value)
crc_val = self.calc_crc(new_value)
crc_field = self.parent["CUSTOM_MAC_CRC"]
print_field(crc_field, hex(crc_val))
crc_field.save(crc_val)
else:
# Writing the BLK0 default MAC is not possible,
# as it's written in the factory.
raise esptool.FatalError("Writing Factory MAC address is not supported")
class EfuseWafer(EfuseField):
def get(self, from_read=True):
rev_bit0 = self.parent["CHIP_VER_REV1"].get(from_read)
assert self.parent["CHIP_VER_REV1"].bit_len == 1
rev_bit1 = self.parent["CHIP_VER_REV2"].get(from_read)
assert self.parent["CHIP_VER_REV2"].bit_len == 1
apb_ctl_date = self.parent.read_reg(self.parent.REGS.APB_CTL_DATE_ADDR)
rev_bit2 = (
apb_ctl_date >> self.parent.REGS.APB_CTL_DATE_S
) & self.parent.REGS.APB_CTL_DATE_V
combine_value = (rev_bit2 << 2) | (rev_bit1 << 1) | rev_bit0
revision = {
0: 0,
1: 1,
3: 2,
7: 3,
}.get(combine_value, 0)
return revision
def save(self, new_value):
raise esptool.FatalError("Burning %s is not supported" % self.name)
class EfusePkg(EfuseField):
def get(self, from_read=True):
lo_bits = self.parent["CHIP_PACKAGE"].get(from_read)
hi_bits = self.parent["CHIP_PACKAGE_4BIT"].get(from_read)
return (hi_bits << 3) + lo_bits
def save(self, new_value):
raise esptool.FatalError("Burning %s is not supported" % self.name)
class EfuseSpiPinField(EfuseField):
def get(self, from_read=True):
val = self.get_raw(from_read)
if val >= 30:
val += 2 # values 30,31 map to 32, 33
return val
def check_format(self, new_value_str):
if new_value_str is None:
return new_value_str
new_value_int = int(new_value_str, 0)
if new_value_int in [30, 31]:
raise esptool.FatalError(
"IO pins 30 & 31 cannot be set for SPI flash. 0-29, 32 & 33 only."
)
elif new_value_int > 33:
raise esptool.FatalError(
"IO pin %d cannot be set for SPI flash. 0-29, 32 & 33 only."
% new_value_int
)
elif new_value_int in [32, 33]:
return str(new_value_int - 2)
else:
return new_value_str
class EfuseVRefField(EfuseField):
VREF_OFFSET = 1100 # ideal efuse value in mV
VREF_STEP_SIZE = 7 # 1 count in efuse == 7mV
VREF_SIGN_BIT = 0x10
VREF_MAG_BITS = 0x0F
def get(self, from_read=True):
val = self.get_raw(from_read)
# sign-magnitude format
if val & self.VREF_SIGN_BIT:
val = -(val & self.VREF_MAG_BITS)
else:
val = val & self.VREF_MAG_BITS
val *= self.VREF_STEP_SIZE
return self.VREF_OFFSET + val
def save(self, new_value):
raise esptool.FatalError("Writing to VRef is not supported.")
class EfuseAdcPointCalibration(EfuseField):
TP_OFFSET = { # See TP_xxxx_OFFSET in esp_adc_cal.c in ESP-IDF
"ADC1_TP_LOW": 278,
"ADC2_TP_LOW": 421,
"ADC1_TP_HIGH": 3265,
"ADC2_TP_HIGH": 3406,
}
SIGN_BIT = (0x40, 0x100) # LOW, HIGH (2s complement format)
STEP_SIZE = 4
def get(self, from_read=True):
idx = 0 if self.name.endswith("LOW") else 1
sign_bit = self.SIGN_BIT[idx]
offset = self.TP_OFFSET[self.name]
raw = self.get_raw()
delta = (raw & (sign_bit - 1)) - (raw & sign_bit)
return offset + (delta * self.STEP_SIZE)
| 17,058 | Python | .py | 411 | 30.131387 | 110 | 0.554966 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,691 | mem_definition.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse/efuse/esp32/mem_definition.py | # This file describes eFuses fields and registers for ESP32 chip
#
# SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import copy
import os
import yaml
from ..mem_definition_base import (
EfuseBlocksBase,
EfuseFieldsBase,
EfuseRegistersBase,
Field,
)
class EfuseDefineRegisters(EfuseRegistersBase):
EFUSE_MEM_SIZE = 0x011C + 4
# EFUSE registers & command/conf values
DR_REG_EFUSE_BASE = 0x3FF5A000
EFUSE_REG_CONF = DR_REG_EFUSE_BASE + 0x0FC
EFUSE_CONF_WRITE = 0x5A5A
EFUSE_CONF_READ = 0x5AA5
EFUSE_REG_CMD = DR_REG_EFUSE_BASE + 0x104
EFUSE_CMD_OP_MASK = 0x3
EFUSE_CMD_WRITE = 0x2
EFUSE_CMD_READ = 0x1
# 3/4 Coding scheme warnings registers
EFUSE_REG_DEC_STATUS = DR_REG_EFUSE_BASE + 0x11C
EFUSE_REG_DEC_STATUS_MASK = 0xFFF
# Coding Scheme
EFUSE_CODING_SCHEME_WORD = 6
EFUSE_CODING_SCHEME_MASK = 0x3
# Efuse clock control
EFUSE_DAC_CONF_REG = DR_REG_EFUSE_BASE + 0x118
EFUSE_CLK_REG = DR_REG_EFUSE_BASE + 0x0F8
EFUSE_DAC_CLK_DIV_MASK = 0xFF
EFUSE_CLK_SEL0_MASK = 0x00FF
EFUSE_CLK_SEL1_MASK = 0xFF00
EFUSE_CLK_SETTINGS = {
# APB freq: clk_sel0, clk_sel1, dac_clk_div
# Taken from TRM chapter "eFuse Controller": Timing Configuration
# 80 is here for completeness only as esptool never sets an 80MHz APB clock
26: (250, 255, 52),
40: (160, 255, 80),
80: (80, 128, 100),
}
DR_REG_SYSCON_BASE = 0x3FF66000
APB_CTL_DATE_ADDR = DR_REG_SYSCON_BASE + 0x7C
APB_CTL_DATE_V = 0x1
APB_CTL_DATE_S = 31
EFUSE_BLK0_RDATA3_REG = DR_REG_EFUSE_BASE + 0x00C
EFUSE_RD_CHIP_VER_REV1 = 1 << 15
EFUSE_BLK0_RDATA5_REG = DR_REG_EFUSE_BASE + 0x014
EFUSE_RD_CHIP_VER_REV2 = 1 << 20
class EfuseDefineBlocks(EfuseBlocksBase):
__base_regs = EfuseDefineRegisters.DR_REG_EFUSE_BASE
# List of efuse blocks
# fmt: off
BLOCKS = [
# Name, Alias, Index, Read address, Write address, Write protect bit, Read protect bit, Len, key_purpose
("BLOCK0", [], 0, __base_regs + 0x000, __base_regs + 0x01C, None, None, 7, None),
("BLOCK1", ["flash_encryption"], 1, __base_regs + 0x038, __base_regs + 0x098, 7, 0, 8, None),
("BLOCK2", ["secure_boot_v1", "secure_boot_v2"], 2, __base_regs + 0x058, __base_regs + 0x0B8, 8, 1, 8, None),
("BLOCK3", [], 3, __base_regs + 0x078, __base_regs + 0x0D8, 9, 2, 8, None),
]
# fmt: on
def get_burn_block_data_names(self):
list_of_names = []
for block in self.BLOCKS:
blk = self.get(block)
if blk.name:
list_of_names.append(blk.name)
return list_of_names
class EfuseDefineFields(EfuseFieldsBase):
def __init__(self) -> None:
self.EFUSES = []
# if MAC_VERSION is set "1", these efuse fields are in BLOCK3:
self.CUSTOM_MAC = []
# The len of fields depends on coding scheme: for CODING_SCHEME_NONE
self.KEYBLOCKS_256 = []
# The len of fields depends on coding scheme: for CODING_SCHEME_34
self.KEYBLOCKS_192 = []
# if BLK3_PART_RESERVE is set, these efuse fields are in BLOCK3:
self.ADC_CALIBRATION = []
self.CALC = []
dir_name = os.path.dirname(os.path.abspath(__file__))
dir_name, file_name = os.path.split(dir_name)
file_name = file_name + ".yaml"
dir_name, _ = os.path.split(dir_name)
efuse_file = os.path.join(dir_name, "efuse_defs", file_name)
with open(f"{efuse_file}", "r") as r_file:
e_desc = yaml.safe_load(r_file)
super().__init__(e_desc)
for i, efuse in enumerate(self.ALL_EFUSES):
if efuse.name == "BLOCK1" or efuse.name == "BLOCK2":
self.KEYBLOCKS_256.append(efuse)
BLOCK = copy.deepcopy(efuse)
BLOCK.type = "bytes:24"
BLOCK.bit_len = 24 * 8
self.KEYBLOCKS_192.append(BLOCK)
self.ALL_EFUSES[i] = None
elif efuse.name == "MAC_VERSION":
# A field from BLOCK3, It is used as a template
BLOCK3 = copy.deepcopy(efuse)
BLOCK3.name = "BLOCK3"
BLOCK3.block = 3
BLOCK3.word = 0
BLOCK3.pos = 0
BLOCK3.bit_len = 32 * 8
BLOCK3.type = "bytes:32"
BLOCK3.category = "security"
BLOCK3.class_type = "keyblock"
BLOCK3.description = "Variable Block 3"
self.KEYBLOCKS_256.append(BLOCK3)
BLOCK3 = copy.deepcopy(BLOCK3)
BLOCK3.type = "bytes:24"
BLOCK3.bit_len = 24 * 8
self.KEYBLOCKS_192.append(BLOCK3)
elif efuse.category == "calibration" and efuse.block == 3:
self.ADC_CALIBRATION.append(efuse)
self.ALL_EFUSES[i] = None
elif efuse.name in ["CUSTOM_MAC_CRC", "CUSTOM_MAC"]:
self.CUSTOM_MAC.append(efuse)
self.ALL_EFUSES[i] = None
elif efuse.category == "spi pad":
efuse.class_type = "spipin"
f = Field()
f.name = "WAFER_VERSION_MAJOR"
f.block = 0
f.bit_len = 3
f.type = f"uint:{f.bit_len}"
f.category = "identity"
f.class_type = "wafer"
f.description = "calc WAFER VERSION MAJOR from CHIP_VER_REV1 and CHIP_VER_REV2 and apb_ctl_date (read only)"
self.CALC.append(f)
f = Field()
f.name = "PKG_VERSION"
f.block = 0
f.bit_len = 4
f.type = f"uint:{f.bit_len}"
f.category = "identity"
f.class_type = "pkg"
f.description = (
"calc Chip package = CHIP_PACKAGE_4BIT << 3 + CHIP_PACKAGE (read only)"
)
self.CALC.append(f)
for efuse in self.ALL_EFUSES:
if efuse is not None:
self.EFUSES.append(efuse)
self.ALL_EFUSES = []
| 6,193 | Python | .py | 149 | 32.416107 | 128 | 0.57416 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,692 | config.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/__pycache__/config.cpython-310.pyc | o
’jÂd" ã @ s: d dl Z d dlZg d¢Zd
dd„Zd
dd„Zd
dd „ZdS ) é N)
ÚtimeoutÚchip_erase_timeoutÚ max_timeoutÚ sync_timeoutÚmd5_timeout_per_mbÚerase_region_timeout_per_mbÚerase_write_timeout_per_mbÚmem_end_rom_timeoutÚserial_write_timeoutÚconnect_attemptsÚwrite_block_attemptsÚ reset_delayÚcustom_reset_sequenceFc
C sì t j | ¡sdS t ¡ }z@|j| dd� | d¡rJ|rGtt| d¡ƒtt
ƒ ƒ}| ¡ t |ƒ}|dkrG|dkr:dnd}t
d |d
|¡¡ƒ W d S W dS ttjfyu } z|rjt
d | › d
|› �ƒ W Y d }~dS W Y d }~dS d }~ww )NFzUTF-8)ÚencodingÚesptoolr é ÚsÚ z)Ignoring unknown config file option{}: {}z, Tz Ignoring invalid config file z: )ÚosÚpathÚexistsÚ configparserÚRawConfigParserÚreadÚ has_sectionÚlistÚsetÚoptionsÚCONFIG_OPTIONSÚsortÚlenÚprintÚformatÚjoinÚUnicodeDecodeErrorÚError)Ú file_pathÚverboseÚcfgÚ unknown_optsÚno_of_unknown_optsÚsuffixÚe© r- ú./home/ceco/Downloads/esptool/esptool/config.pyÚ_validate_config_file s8
ÿÿôı
ş€ır/ c C s. dD ]}t j | |¡}t||ƒr| S qd S )N)z esptool.cfgz setup.cfgztox.ini)r r r# r/ )Údir_pathr' Ú candidateÚcfg_pathr- r- r. Ú_find_config_file5 s
ÿr3 c C sÎ d}t j d¡}|d urt|ƒr|}d}n(t j d¡}t jdkr%|› d�n|› d�}t ¡ ||fD ] }t|| ƒ}|r< nq1t
¡ }i |d< |d urc| |¡ | rc|rTd nd
}t d t j
|¡› |› �ƒ ||fS ) NFÚESPTOOL_CFGFILETú~Úposixz/.config/esptoolz/AppData/Local/esptool/r z (set with ESPTOOL_CFGFILE)r z!Loaded custom configuration from )r ÚenvironÚgetr/ r Ú
expanduserÚnameÚgetcwdr3 r Ú ConfigParserr r! Úabspath) r' Úset_with_env_varÚ env_var_pathÚ
cfg_file_pathÚhome_dirÚ
os_config_dirr0 r( Úmsgr- r- r. Úload_config_file= s: ÿı
ÿ
ÿÿÿrD )F)r r r r/ r3 rD r- r- r- r. Ú<module> s
| 2,152 | Python | .pyt | 20 | 106.4 | 570 | 0.527426 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,693 | util.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/__pycache__/util.cpython-310.pyc | o
’jÂdQ ã @ sº d dl Z d dlZd dlZd dlZdd„ Zdd„ Zdd„ Zdd „ Zd!d d „Zd"dd„Z d#dd„Z
dd„ Z dd„ Z dd„ Z
G dd„ deƒZG dd „ d eƒZG d d „ d eƒZG d d „ d eƒZdS )$é Nc C s | | S ©N© )ÚbitstrÚindexr r ú,/home/ceco/Downloads/esptool/esptool/util.pyÚbyte s r c C s0 d}| d@ dkr|d7 }| dL } | d@ dks|S )z9Return the index of the least significant bit in the maskr é r )ÚmaskÚshiftr r r Ú
mask_to_shift s şr c C s t | ƒt |ƒ d t |ƒ S )z¯Return a/b rounded up to nearest integer,
equivalent result to int(math.ceil(float(int(a)) / float(int(b))), only
without possible floating point accuracy errors.
r )Úint)ÚaÚbr r r Ú div_roundup s r c C s` | du rdS d| v rt | d| d¡… ƒd d S d| v r*t | d| d¡… ƒd S td| ƒ‚)zrGiven a flash size of the type passed in args.flash_size
(ie 512KB or 1MB) then return the size in bytes.
NÚMBi ÚKBzUnknown size %s)r r Ú
FatalError)Úsizer r r Úflash_size_bytes! s r Tc s$ |rdnd‰ d ‡ fdd„| D ƒ¡S )Nz%02Xz%02xÚ c 3 s � | ]}ˆ | V qd S r r )Ú.0Úc©Ú
format_strr r Ú <genexpr>1 s € zhexify.<locals>.<genexpr>)Újoin)ÚsÚ uppercaser r r Úhexify/ s r ó ÿc C s( t | ƒ| }|dkr| ||| 7 } | S )z"Pad to the next alignment boundaryr )Úlen)ÚdataÚ alignmentÚ
pad_characterÚpad_modr r r Úpad_to4 s r% Fc C s2 t j ¡ rtd| |r
dndd� dS t| ƒ dS )a’ Print a message, overwriting the currently printed line.
If last_line is False, don't append a newline at the end
(expecting another subsequent call will overwrite this one.)
After a sequence of calls with last_line=False, call once with last_line=True.
If output is not a TTY (for example redirected a pipe),
no overwriting happens and this function is the same as print().
z
%sÚ
r )ÚendN)ÚsysÚstdoutÚisattyÚprint)ÚmessageÚ last_liner r r Úprint_overwrite< s
r. c C s2 t dd| ¡} t dd| ¡} t ddd„ | ¡} | S )zKChange chip name to official form, e.g. `esp32s3beta2` -> `ESP32-S3(beta2)`z (esp32)(?!$)z\1-z (beta\d*)z(\1)z^[^\(]+c S s | d¡ ¡ S )Nr )ÚgroupÚupper)Úxr r r Ú<lambda>T s z"expand_chip_name.<locals>.<lambda>)ÚreÚsub©Ú chip_namer r r Úexpand_chip_nameM s r7 c C s t dd| ¡ ¡S )zLStrip chip name to normalized form, e.g. `ESP32-S3(beta2)` -> `esp32s3beta2`z[-()]r )r3 r4 Úlowerr5 r r r Ústrip_chip_nameX s r9 c C sJ d}t | dƒ�}| dtj¡ | ¡ }W d ƒ |S 1 s w Y |S )z Returns the file size in bytesr ÚrbN)ÚopenÚseekÚosÚSEEK_ENDÚtell)Ú path_to_fileÚ file_sizeÚfr r r Ú
get_file_size] s
şırC c @ s$ e Zd ZdZdd„ Zedd„ ƒZdS )r z~
Wrapper class for runtime errors that aren't caused by internal bugs, but by
ESP ROM responses or input content.
c C s t | |¡ d S r )Ú RuntimeErrorÚ__init__)Úselfr, r r r rE l s zFatalError.__init__c C s¶ i dd“dd“dd“dd“d d
“d d “d
d“dd“dd“dd“dd“dd“dd“dd “d d “d d “d!d"“d#d$d%d&d'd(œ¥}t d)|d*d+… ¡}| d, t|ƒ| |d- d.¡¡7 } t| ƒS )/z�
Return a fatal error object that appends the hex values of
'result' and its meaning as a string formatted argument.
i z
Out of memoryi zInvalid argumenti z
Invalid statei z Invalid sizei z Requested resource not foundi z"Operation or feature not supportedi zOperation timed outi z Received response was invalidi zCRC or checksum was invalidi
zVersion was invalidi zMAC address was invalidi À zBad data lengthi Á zBad data checksumi  z
Bad blocksizei à zInvalid commandi Ä zFailed SPI operationi Å zFailed SPI unlockzNot in flash modez
Inflate errorzNot enough dataz
Too much datazCommand not implemented)i Æ i Ç i È i É i ÿ z>HNé z (result was {}: {})r zUnknown result)ÚstructÚunpackÚformatr Úgetr )r, ÚresultÚerr_defsÚerr_coder r r Ú
WithResulto s\ şıüûúùø ÷
ö õ ôòñğïîíèÿzFatalError.WithResultN)Ú__name__Ú
__module__Ú __qualname__Ú__doc__rE Ú staticmethodrO r r r r r f s
r c @ ó e Zd ZdZdd„ ZdS )ÚNotImplementedInROMErrorz„
Wrapper class for the error thrown when a particular ESP bootloader function
is not implemented in the ROM bootloader.
c C s t | d|j|jf ¡ d S )Nz$%s ROM does not support function %s.)r rE Ú CHIP_NAMErP )rF Ú
bootloaderÚfuncr r r rE � s
ÿşz!NotImplementedInROMError.__init__N©rP rQ rR rS rE r r r r rV ˜ s rV c @ s e Zd Zdd„ ZdS )ÚNotSupportedErrorc C s t | d||jf ¡ d S )Nz$Function %s is not supported for %s.)r rE rW )rF ÚespÚ
function_namer r r rE § s şzNotSupportedError.__init__N)rP rQ rR rE r r r r r[ ¦ s r[ c @ rU )ÚUnsupportedCommandErrorz›
Wrapper class for when ROM loader returns an invalid command response.
Usually this indicates the loader is running in Secure Download Mode.
c C s( |j rd| }nd| }t | |¡ d S )Nz<This command (0x%x) is not supported in Secure Download Modez"Invalid (unsupported) command 0x%x)Úsecure_download_moderD rE )rF r\ ÚopÚmsgr r r rE µ s
z UnsupportedCommandError.__init__NrZ r r r r r^ ® s r^ )T)r )F)r= r3 rH r( r r r r r r% r. r7 r9 rC rD r rV r[ r^ r r r r Ú<module> s$
2 | 6,585 | Python | .pyt | 44 | 146.136364 | 907 | 0.498776 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,694 | bin_image.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/__pycache__/bin_image.cpython-310.pyc | o
’jÂd…¶ ã @ s d dl Z d dlZd dlZd dlZd dlZd dlZd dlZddlmZ ddl m
Z
m Z m Z m
Z
mZmZmZmZmZmZmZmZ ddlmZmZmZ dd„ Zdd „ ZG d
d „ d e ƒZ G d d
„ d
e ƒZ G dd„ de ƒZ G dd„ de ƒZ e e_!G dd„ de ƒZ"dd„ Z#G dd„ de ƒZ$G dd„ de$ƒZ%e$e_!G dd„ de$ƒZ&e&e_!G d d „ d e$ƒZ'e'e_!G d d „ d e$ƒZ(e(e_!G d d!„ d!e$ƒZ)e)e _!G d"d#„ d#e$ƒZ*e*e _!G d$d%„ d%e$ƒZ+e+e_!G d&d'„ d'e$ƒZ,e,e_!G d(d)„ d)e$ƒZ-e-e
_!G d*d+„ d+e$ƒZ.e.e
_!G d,d-„ d-e.ƒZ/e/e_!G d.d/„ d/e ƒZ0dS )0é Né )Ú ESPLoader) Ú
ESP32C2ROMÚ
ESP32C3ROMÚESP32C6BETAROMÚ
ESP32C6ROMÚESP32H2BETA1ROMÚESP32H2BETA2ROMÚ
ESP32H2ROMÚESP32ROMÚ
ESP32S2ROMÚESP32S3BETA2ROMÚ
ESP32S3ROMÚ
ESP8266ROM)Ú
FatalErrorÚbyteÚpad_toc C s$ |d | ¡ | }| |d¡ dS )zBAlign the position in the file to the next block of specified sizer N)ÚtellÚseek)ÚfÚsizeÚalign© r ú1/home/ceco/Downloads/esptool/esptool/bin_image.pyÚalign_file_position s r c C sP dd„ }t |tƒr#t|dƒ�
}||| ƒW d ƒ S 1 s w Y ||| ƒS )aI
Load a firmware image. Can be for any supported SoC.
ESP8266 images will be examined to determine if they are original ROM firmware
images (ESP8266ROMFirmwareImage) or "v2" OTA bootloader images.
Returns a BaseFirmwareImage subclass, either ESP8266ROMFirmwareImage (v1)
or ESP8266V2FirmwareImage (v2).
c S s† t dd| ¡ ¡}|dkr ttttttt t
t t t
dœ | | ƒS t| d¡ƒ}| d¡ |tjkr4t| ƒS |tjkr=t| ƒS td| ƒ‚)Nz[-()]Ú Úesp8266) Úesp32Úesp32s2Ú esp32s3beta2Úesp32s3Úesp32c3Ú esp32c6betaÚ esp32h2beta1Ú esp32h2beta2Úesp32c2Úesp32c6Úesp32h2r r z Invalid image magic number: %d)ÚreÚsubÚlowerÚESP32FirmwareImageÚESP32S2FirmwareImageÚESP32S3BETA2FirmwareImageÚESP32S3FirmwareImageÚESP32C3FirmwareImageÚESP32C6BETAFirmwareImageÚESP32H2BETA1FirmwareImageÚESP32H2BETA2FirmwareImageÚESP32C2FirmwareImageÚESP32C6FirmwareImageÚESP32H2FirmwareImageÚordÚreadr r ÚESP_IMAGE_MAGICÚESP8266ROMFirmwareImageÚESP8266V2FirmwareImageÚIMAGE_V2_MAGICr )r ÚchipÚmagicr r r Úselect_image_class1 s2 õ ô ô
z-LoadFirmwareImage.<locals>.select_image_classÚrbN)Ú
isinstanceÚstrÚopen)r< Ú
image_filer> r r r r ÚLoadFirmwareImage& s
ÿ
rD c @ sB e Zd ZdZddd„Zdd„ Zdd„ Zd d
„ Zd d „ Zd
d„ Z dS )Ú ImageSegmentz_Wrapper class for a segment in an ESP image
(very similar to a section in an ELFImage also)Nc C s4 || _ || _|| _d| _| j dkr| d¡ d S d S )NTr é )ÚaddrÚdataÚ file_offsÚinclude_in_checksumÚpad_to_alignment)ÚselfrG rH rI r r r Ú__init__U s
ÿÿzImageSegment.__init__c C s t || jdƒS )zNReturn a new ImageSegment with same data, but mapped at
a new address.r )rE rH )rL Únew_addrr r r Úcopy_with_new_addr_ s z ImageSegment.copy_with_new_addrc C sH t | ¡}| jd|… |_| j|d… | _| j|7 _d| _d|_|S )zÆReturn a new ImageSegment which splits "split_len" bytes
from the beginning of the data. Remaining bytes are kept in
this segment object (and the start address is adjusted to match.)N)ÚcopyrH rG rI )rL Ú split_lenÚresultr r r Ú split_imaged s
zImageSegment.split_imagec C s0 dt | jƒ| jf }| jd ur|d| j 7 }|S )Nzlen 0x%05x load 0x%08xz file_offs 0x%08x)ÚlenrH rG rI )rL Úrr r r Ú__repr__p s
zImageSegment.__repr__c s ‡ fdd„|j jD ƒS )zv
Return a list describing the memory type(s) that is covered by this
segment's start address.
c s6 g | ]}|d ˆ j kr|d k rn n|d ‘qS )r r é ©rG )Ú.0Ú map_range©rL r r Ú
<listcomp>{ s
ı
ıÿz0ImageSegment.get_memory_type.<locals>.<listcomp>)Ú
ROM_LOADERÚ
MEMORY_MAP)rL Úimager r[ r Úget_memory_typev s
şz ImageSegment.get_memory_typec C s t | j|dƒ| _d S ©Nó )r rH )rL Ú alignmentr r r rK � ó z ImageSegment.pad_to_alignment©N)
Ú__name__Ú
__module__Ú __qualname__Ú__doc__rM rO rS rV r` rK r r r r rE Q s
rE c s, e Zd ZdZ‡ fdd„Z‡ fdd„Z‡ ZS )Ú
ELFSectionzxWrapper class for a section in an ELF image, has a section
name as well as the common properties of an ImageSegment.c s" t t| ƒ ||¡ | d¡| _d S )Nzutf-8)Úsuperrj rM ÚdecodeÚname)rL rm rG rH ©Ú __class__r r rM ‰ s zELFSection.__init__c s d| j tt| ƒ ¡ f S )Nz%s %s)rm rk rj rV r[ rn r r rV � s zELFSection.__repr__)rf rg rh ri rM rV Ú
__classcell__r r rn r rj … s rj c @ s¤ e Zd ZdZdZ dd„ Zdd„ Zdd„ Zd'd
d „Zd d
„ Z dd„ Z
d(dd„Z d(dd„Z dd„ Z
dd„ Zdd„ Zdd „ Zd d „ Zd d „ Zd!d"„ Zd#d$„ Zd%d&„ ZdS ))ÚBaseFirmwareImageé é c C s" g | _ d| _d | _d| _d| _d S ©Nr )ÚsegmentsÚ
entrypointÚ
elf_sha256Úelf_sha256_offsetÚ pad_to_sizer[ r r r rM — s
zBaseFirmwareImage.__init__c C s: t d| d¡¡\}}| _| _| _||krtd| ƒ‚|S )Nú<BBBBIrr z!Invalid firmware image magic=0x%x)ÚstructÚunpackr7 Ú
flash_modeÚflash_size_freqrv r )rL Ú load_fileÚexpected_magicr= ru r r r Úload_common_header� s ú z$BaseFirmwareImage.load_common_headerc C s$ t | jƒdkrtdt | jƒ ƒ‚d S )Né zRInvalid segment count %d (max 16). Usually this indicates a linker script problem.)rT ru r r[ r r r Úverify« s ÿÿÿzBaseFirmwareImage.verifyFc C st | ¡ }t d| d¡¡\}}| |||¡ | |¡}t|ƒ|k r,td||t|ƒf ƒ‚t|||ƒ}| j |¡ |S )z)Load the next segment from the image fileú<IIrr z>End of file reading segment 0x%x, length %d (actual length %d))
r r{ r| r7 Úwarn_if_unusual_segmentrT r rE ru Úappend)rL r Úis_irom_segmentrI Úoffsetr Ú segment_dataÚsegmentr r r Ú load_segment² s
ÿÿ z BaseFirmwareImage.load_segmentc C s8 |s|dks|dk s|dkrt d||f ƒ d S d S d S )Ni @i ş?é z+WARNING: Suspicious segment 0x%x, length %d)Úprint©rL rˆ r r‡ r r r r… Á s
şz)BaseFirmwareImage.warn_if_unusual_segmentc C sÎ t |ƒ}| ¡ }| j|kre| j|| k re| j| }|| jk s%|| j |kr/td| j||f ƒ‚|| j8 }|||| j … d| j krItd| j ƒ‚t | jƒ| jksSJ ‚|d|… | j ||| j d… }|S )z
If SHA256 digest of the ELF file needs to be inserted into this segment, do so.
Returns segment data.
zbCannot place SHA256 digest on segment boundary(elf_sha256_offset=%d, file_pos=%d, segment_size=%d)rb zYContents of segment at SHA256 digest offset 0x%x are not all zero. Refusing to overwrite.r N)rT r rx ÚSEG_HEADER_LENÚSHA256_DIGEST_LENr rw )rL r r‰ Ú segment_lenÚfile_posÚ patch_offsetr r r Úmaybe_patch_segment_dataÆ sD ÿ ş
ÿ ş
şÿ
ÿÿÿÿ
ÿşÿz*BaseFirmwareImage.maybe_patch_segment_dataNc C sJ | ||j¡}| t d|jt|ƒ¡¡ | |¡ |dur#t ||¡S dS )zi
Save the next segment to the image file,
return next checksum value if provided
r„ N) r” rH Úwriter{ ÚpackrG rT r Úchecksum)rL r rŠ r— r‰ r r r Ú save_segmentğ s
ÿz BaseFirmwareImage.save_segmentc C sZ | j jdkr&| ¡ t|jƒ | j }|| j }|dk r&| jdd| 7 _| |||¡S )za
Save the next segment to the image file, return next checksum value if provided
ÚESP32é$ rb )r] Ú CHIP_NAMEr rT rH r� Ú
IROM_ALIGNr˜ )rL r rŠ r— Úsegment_end_posÚsegment_len_remainderr r r Úsave_flash_segmentû s
z$BaseFirmwareImage.save_flash_segmentc C s t |dƒ t| d¡ƒS )z5Return ESPLoader checksum from end of just-read imager‚ r )r r6 r7 )rL r r r r Ú
read_checksum s
z BaseFirmwareImage.read_checksumc C s* t j}| jD ] }|jrt |j|¡}q|S )za
Calculate checksum of loaded image, based on segments in
segment array.
)r ÚESP_CHECKSUM_MAGICru rJ r— rH )rL r— Úsegr r r Úcalculate_checksum s
€z$BaseFirmwareImage.calculate_checksumc C s t |dƒ | t d|¡¡ dS )z3Append ESPLoader checksum to the just-written imager‚ ó BN)r r• r{ r– )rL r r— r r r Úappend_checksum s
z!BaseFirmwareImage.append_checksumc
C s* | t dtjt|ƒ| j| j| j¡¡ d S )Nrz ) r• r{ r– r r8 rT r} r~ rv )rL r ru r r r Úwrite_common_header s úÿz%BaseFirmwareImage.write_common_headerc C s t j| ko t jk S S )zg
Returns True if an address starts in the irom region.
Valid for ESP8266 only.
)r ÚIROM_MAP_STARTÚ IROM_MAP_END©rL rG r r r Ú is_irom_addr, s z BaseFirmwareImage.is_irom_addrc sH ‡ fdd„ˆ j D ƒ}t|ƒdkr"t|ƒdkr tdt|ƒ ƒ‚|d S d S )Nc s g | ]
}ˆ |j¡r|‘qS r )rª rG ©rY Úsr[ r r r\ 4 s z6BaseFirmwareImage.get_irom_segment.<locals>.<listcomp>r r z4Found %d segments that could be irom0. Bad ELF file?)ru rT r )rL Ú
irom_segmentsr r[ r Úget_irom_segment3 s ÿÿz"BaseFirmwareImage.get_irom_segmentc s | ¡ ‰ ‡ fdd„| jD ƒS )Nc s g | ]}|ˆ kr|‘qS r r r« ©Ú irom_segmentr r r\ @ s z;BaseFirmwareImage.get_non_irom_segments.<locals>.<listcomp>)r® ru r[ r r¯ r Úget_non_irom_segments> s z'BaseFirmwareImage.get_non_irom_segmentsc C s´ | j sd S g }tt| j ƒd ddƒD ]9}| j |d }| j | }t| | ¡| | ¡k|j|jk|j|jt|jƒ kfƒrE| j|j7 _q| d|¡ q| d| j d ¡ || _ d S )Nr r éÿÿÿÿ) ru ÚrangerT Úallr` rJ rG rH Úinsert)rL ru ÚiÚelemÚ next_elemr r r Úmerge_adjacent_segmentsB s
ıÿ
z)BaseFirmwareImage.merge_adjacent_segmentsc C s t d | jj¡ƒ dS )zw
If supported, this should be overridden by the chip-specific class.
Gets called in elf2image.
zKWARNING: Changing MMU page size is not supported on {}! Defaulting to 64KB.N)r� Úformatr] r› ©rL r r r r Úset_mmu_page_sizek s
şz#BaseFirmwareImage.set_mmu_page_size)Fre )rf rg rh r� r� rM r� rƒ r‹ r… r” r˜ rŸ r r£ r¥ r¦ rª r® r± r¹ r¼ r r r r rq ‘ s*
*
)rq c s6 e Zd ZdZeZd ‡ fdd„ Zdd„ Zdd„ Z‡ Z S )
r9 zK'Version 1' firmware image, segments loaded directly by the ROM bootloader.Nc sj t t| ƒ ¡ d| _d| _d| _|d ur3| |tj¡}t |ƒD ]}|
|¡ q | |¡| _ |
¡ d S d S )Nr r )rk r9 rM r} r~ Úversionr� r r8 r³ r‹ r r— rƒ )rL r ru Ú_rn r r rM { s ùz ESP8266ROMFirmwareImage.__init__c C s |d S )ú/Derive a default output name from the ELF name.ú-r ©rL Ú
input_filer r r Údefault_output_nameŠ s z+ESP8266ROMFirmwareImage.default_output_namec C sÈ | ¡ }|dur+td||jtj f dƒ�}| |j¡ W d ƒ n1 s&w Y | ¡ }td| dƒ�$}| ||¡ t j
}|D ] }| |||¡}qB| ||¡ W d ƒ dS 1 s]w Y dS )zCSave a set of V1 images for flashing. Parameter is a base filename.Nz %s0x%05x.binÚwbz
%s0x00000.bin)
r® rB rG r r§ r• rH r± r¦ r r¡ r˜ r¥ )rL Úbasenamer° r Únormal_segmentsr— rŠ r r r Úsave� s& ÿı û "ûz ESP8266ROMFirmwareImage.savere )
rf rg rh ri r r] rM rà rÇ rp r r rn r r9 v s r9 c s> e Zd ZdZeZdZdZd ‡ fdd„ Zdd„ Z d d
„ Z
‡ Z S ) r: zs'Version 2' firmware image, segments loaded by software bootloader stub
(ie Espressif bootloader or rboot)
éê rF Nc s t t| ƒ ¡ d| _|d ur~| || j¡}|| jkr td| ƒ | |d¡}d|_ d|_
| j }| j }| j
}| |tj¡}|| j krJtd|| j f ƒ || j krXtd|| j f ƒ || j
krftd|| j
f ƒ t|ƒD ]}| |¡ qj| |¡| _| ¡ d S d S ) NrW z@Warning: V2 header has unexpected "segment" count %d (usually 4)Tr FzfWARNING: Flash mode value in first header (0x%02x) disagrees with second (0x%02x). Using second value.zkWARNING: Flash size/freq value in first header (0x%02x) disagrees with second (0x%02x). Using second value.zoWARNING: Entrypoint address in first header (0x%08x) disagrees with second header (0x%08x). Using second value.)rk r: rM r½ r� r; ÚIMAGE_V2_SEGMENTr� r‹ rG rJ r} r~ rv r r8 r³ r r— rƒ )rL r ru r° Úfirst_flash_modeÚfirst_flash_size_freqÚfirst_entrypointr¾ rn r r rM ´ sP
ÿÿ
şÿ
şÿ
şÿ Îz ESP8266V2FirmwareImage.__init__c C sF | ¡ }|dur|jtj }nd}dtj |¡d |tjd @ f S )r¿ Nr z
%s-0x%05x.binr ) r® rG r r§ ÚosÚpathÚsplitextr ÚFLASH_SECTOR_SIZE)rL r r° Ú irom_offsr r r rà ë s şz*ESP8266V2FirmwareImage.default_output_namec C s4 t |dƒ�Q}| t d| j| j| j| j| j¡¡ | ¡ }|d ur0|
d¡}| d¡ | ||¡ |
¡ }| ||¡ tj}|D ] }| |||¡}q?| ||¡ W d ƒ n1 sYw Y t |dƒ�}t| ¡ ƒ}W d ƒ n1 stw Y t |dƒ�}| t d|¡¡ W d ƒ d S 1 s“w Y d S )NrÄ s <BBBBIr r‚ r? Úabs <I)rB r• r{ r– r; rÉ r} r~ rv r® rO rK r˜ r± r¦ r r¡ r¥ Ú
esp8266_crc32r7 )rL Úfilenamer r° rÆ r— rŠ Úcrcr r r rÇ ÷ s> úÿ
ÿ ä ÿ "ÿzESP8266V2FirmwareImage.savere ) rf rg rh ri r r] r; rÉ rM rà rÇ rp r r rn r r: § s 7 r: c C s( t | d¡d@ }|d@ r|dA S |d S )zJ
CRC32 algorithm used by 8266 SDK bootloader (and gen_appbin.py).
r l ÿÿ l r )ÚbinasciiÚcrc32)rH rÕ r r r rÓ s rÓ c sb e Zd ZdZeZdZdZdZd‡ fdd„ Z d d
„ Z
d d „ Z d
d„ Z dd„ Z
dd„ Zdd„ Z‡ ZS )r+ a ESP32 firmware image is very similar to V1 ESP8266 image,
except with an additional 16 byte reserved header at top of image,
and because of new flash mapping capabilities the flash-mapped regions
can be placed in the normal image (just @ 64kB padded offsets).
éî z<BBBBHBHHBBBBBrŒ NTc s t t| ƒ ¡ d | _d| _d| _d| _| j| _d| _ d| _
d| _ d| _ d| _
d| _d| _d| _d| _d| _|| _|d ur‰| ¡ }| |tj¡}| |¡ t|ƒD ]}| |¡ qP| |¡| _ | jrƒ| ¡ }| d¡| _ | |¡ t !¡ }| "| || ¡¡ | #¡ | _$| %¡ d S d S )Nr r rs )&rk r+ rM Ú
secure_padr} r~ r½ ÚWP_PIN_DISABLEDÚwp_pinÚclk_drvÚq_drvÚd_drvÚcs_drvÚhd_drvÚwp_drvÚchip_idÚmin_revÚ min_rev_fullÚ max_rev_fullÚ
append_digestr r� r r8 Úload_extended_headerr³ r‹ r r— r7 Ú
stored_digestr ÚhashlibÚsha256ÚupdateÚdigestÚ calc_digestrƒ )rL r ræ Ústartru r¾ Úendrí rn r r rM < sB
îzESP32FirmwareImage.__init__c C s@ | j j| ko
| j jk n p | j j| ko | j jk S S re )r] r§ r¨ ÚDROM_MAP_STARTÚ DROM_MAP_ENDr© r r r Ú
is_flash_addre s ÿşşz ESP32FirmwareImage.is_flash_addrc C s dt j |¡d S )r¿ z%s.binr )rÍ rÎ rÏ rÁ r r r rà j s z&ESP32FirmwareImage.default_output_namec C s d S re r r� r r r r… n s z*ESP32FirmwareImage.warn_if_unusual_segmentc sú d}t ¡ ��ë‰ ˆ ˆ ˆj¡ ˆ ˆ ¡ tj}‡fdd„tˆjdd„ d�D ƒ}‡fdd„tˆjdd„ d�D ƒ}|D ]}|jd krM| |¡ |
d|¡ nq9|D ]}|jd
krd| |¡ |
d|¡ nqPt |ƒdkr�|d j }|d d … D ]}|j ˆj
|ˆj
krŒtd |j |f ƒ‚|j }qv‡ ‡fd
d„}t |ƒdk�r|d }||ƒ} | dkrát |ƒdkrË| ˆjkrË|d | ¡}
t |d jƒdkrÊ| d¡ n
tdd| ˆ ¡ ƒ}
ˆ ˆ |
|¡}|d 7 }n!ˆ ¡ d ˆj
|j ˆj
ksòJ ‚ˆ ˆ ||¡}| d¡ |d 7 }t |ƒdks�|D ]}ˆ ˆ ||¡}|d 7 }�q
ˆj�rcˆj�s%tdƒ‚ˆ ¡ ˆj ˆj
} d} ˆjdk�r:d}
nˆjdk�rBd}
ˆj
| | |
ˆj
} tdd| ˆ ¡ ƒ}
ˆ ˆ |
|¡}|d 7 }ˆ ˆ |¡ ˆ ¡ }ˆj�r}||
ˆj
dk�s}J ‚ˆ d ¡ ˆ t |gƒ¡ ˆj�r¦ˆ d¡ t ¡ }| ˆ |¡¡ ˆ | !¡ ¡ ˆj"�rň ¡ }|ˆj" dk�rňj"|ˆj" }ˆ d| ¡ t#|dƒ�}| ˆ $¡ ¡ W d ƒ n1 �sİw Y W d ƒ d S W d ƒ d S 1 �söw Y d S )Nr c s" g | ]
}ˆ |j¡rt |¡‘qS r ©rò rG rP Údeepcopyr« r[ r r r\ ~ ó
ıÿz+ESP32FirmwareImage.save.<locals>.<listcomp>c S ó | j S re rX ©r¬ r r r Ú<lambda>€ ó z)ESP32FirmwareImage.save.<locals>.<lambda>©Úkeyc s" g | ]
}ˆ |j¡st |¡‘qS r ró r« r[ r r r\ ƒ rõ c S rö re rX r÷ r r r rø … rù z.flash.appdescz.dram0.bootdescr ú¦Segment loaded at 0x%08x lands in same 64KB flash mapping as segment loaded at 0x%08x. Can't generate binary. Suggest changing linker script or ELF to merge sections.c s` | j ˆj ˆj }ˆjˆ ¡ ˆj | }|dks |ˆjkr dS |ˆj8 }|dk r.|ˆj7 }|S rt )rG rœ r� r )rŠ Ú
align_pastÚpad_len©r rL r r Úget_alignment_data_neededª s
z:ESP32FirmwareImage.save.<locals>.get_alignment_data_neededrb rr zIsecure_pad only applies if a SHA-256 digest is also appended to the imager‚ Ú1ép Ú2rs ó ÿrÄ )%ÚioÚBytesIOr¦ ru Úsave_extended_headerr r¡ Úsortedrm Úremoverµ rT rG rœ r r� rS rH ÚpoprE r r˜ rŸ rÙ ræ r¥ r r• Úbytesré rê rë r7 rì ry rB Úgetvalue)rL rÔ Útotal_segmentsr— Úflash_segmentsÚ ram_segmentsrŠ Ú last_addrr rş Ú pad_segmentrı Úchecksum_spaceÚspace_after_checksumÚ image_lengthrì Úpad_byÚ real_filer rÿ r rÇ q sÈ
ş
ş
ı
ı
ıÿ
€
ş
ş
í ÿ ş
ÿ �á �$ázESP32FirmwareImage.savec C sÚ dd„ }t t | j| d¡¡ƒ}|d | _||d ƒ\| _| _||d ƒ\| _| _ ||d ƒ\| _
| _ |d | _ | j | j
jkrJtd | j
j| j f ƒ |d
| _|d | _|d | _|d
}|dv rh|dk| _d S td|ƒ‚)Nc S ó | d@ | d? d@ fS ©Né rF r ©Únr r r Ú
split_byte rd z;ESP32FirmwareImage.load_extended_header.<locals>.split_byter‚ r r rW é rF zdUnexpected chip id in image. Expected %d but value was %d. Is this image for a different chip model?é é é r² ©r r úAInvalid value for append_digest field (0x%02x). Should be 0 or 1.)Úlistr{ r| ÚEXTENDED_HEADER_STRUCT_FMTr7 rÛ rÜ rİ rŞ rß rà rá râ r] Ú
IMAGE_CHIP_IDr� rã rä rå ræ Ú RuntimeError)rL r r Úfieldsræ r r r rç s2 ÿ
üÿ
şz'ESP32FirmwareImage.load_extended_headerc C s� dd„ }| j r dnd}| j|| j| jƒ|| j| jƒ|| j| jƒ| jj | j
| j | j g}|dgd 7 }||g7 }t
j| jg|¢R � }| |¡ d S )Nc S s | d@ |d@ d> S r r )ÚlnÚhnr r r Ú join_byte; rd z:ESP32FirmwareImage.save_extended_header.<locals>.join_byter r rF )ræ rÛ rÜ rİ rŞ rß rà rá r] r% rã rä rå r{ r– r$ r• )rL Ú save_filer* ræ r' Úpackedr r r r : s ø
z'ESP32FirmwareImage.save_extended_header)NT)rf rg rh ri r r] rÚ r$ rœ rM rò rà r… rÇ rç r rp r r rn r r+ ) s ) $&r+ c @ s, e Zd ZdZdZdd„ Zdd„ Zdd„ Zd S )
ÚESP8266V3FirmwareImagez8ESP8266 V3 firmware image is very similar to ESP32 imageÚBBBBBBBBBBBBBBBBc C s
|t jkS re )r r§ r© r r r rò V s
z$ESP8266V3FirmwareImage.is_flash_addrc s d}t ¡ �ñ}ˆ |ˆ j¡ tj}‡ fdd„tˆ jdd„ d�D ƒ}‡ fdd„tˆ jdd„ d�D ƒ}t|ƒdkr\|d j}|d d … D ]}|jˆ j |ˆ j krXt
d
|j|f ƒ‚|j}qBt|ƒdkr‰|d }|j d krs|j d d … |_ ˆ
|||¡}| d¡ |d 7 }t|ƒdksb|D ]
}ˆ
|||¡}|d 7 }q‹ˆ ||¡ | ¡ } | d ¡ | t|gƒ¡ ˆ jrË| d¡ t ¡ }
|
| | ¡¡ | |
¡ ¡ t|d
ƒ�} | | ¡ ¡ W d ƒ n1 sâw Y W d ƒ d S W d ƒ d S 1 súw Y d S )Nr c s, g | ]}ˆ |j¡rt|jƒrt |¡‘qS r ©rò rG rT rH rP rô r« r[ r r r\ b ó
ııÿz/ESP8266V3FirmwareImage.save.<locals>.<listcomp>c S rö re rX r÷ r r r rø d rù z-ESP8266V3FirmwareImage.save.<locals>.<lambda>rú c s, g | ]}ˆ |j¡st|jƒrt |¡‘qS r r/ r« r[ r r r\ g r0 c S rö re rX r÷ r r r rø i rù r rü z
.flash.rodatarr rÄ ) r r r¦ ru r r¡ r rT rG rœ r rm rH r˜ r
r¥ r r r• r ræ ré rê rë r7 rì rB r ) rL rÔ r
r r— r r r rŠ r rì r r r[ r rÇ Y s\
ş
ş
ıÿ
ø
ÿ¾B"¾zESP8266V3FirmwareImage.savec C sº dd„ }t t | j| d¡¡ƒ}|d | _||d ƒ\| _| _||d ƒ\| _| _ ||d ƒ\| _
| _ |d d v rA|d dk| _ nt
d
|d ƒ‚td d „ |d
d… D ƒƒr[tdƒ d S d S )Nc S r r r r r r r r ¡ rd z?ESP8266V3FirmwareImage.load_extended_header.<locals>.split_byter‚ r r rW r r r! r" c s s � | ] }|d kr|V qdS )r Nr )rY r r r r Ú <genexpr>¸ s € z>ESP8266V3FirmwareImage.load_extended_header.<locals>.<genexpr>rF zeWarning: some reserved header fields have non-zero values. This image may be from a newer esptool.py?)r# r{ r| r$ r7 rÛ rÜ rİ rŞ rß rà rá ræ r& Úanyr� )rL r r r' r r r rç s& ÿ
şÿÿz+ESP8266V3FirmwareImage.load_extended_headerN)rf rg rh ri r$ rò rÇ rç r r r r r- Q s Gr- c @ ó e Zd ZdZeZdS )r, zDESP32S2 Firmware Image almost exactly the same as ESP32FirmwareImageN)rf rg rh ri r r] r r r r r, Â ó r, c @ r3 )r- úDESP32S3 Firmware Image almost exactly the same as ESP32FirmwareImageN)rf rg rh ri r
r] r r r r r- Ë r4 r- c @ r3 )r. r5 N)rf rg rh ri r r] r r r r r. Ô r4 r. c @ r3 )r/ zDESP32C3 Firmware Image almost exactly the same as ESP32FirmwareImageN)rf rg rh ri r r] r r r r r/ İ r4 r/ c @ r3 )r0 úDESP32C6 Firmware Image almost exactly the same as ESP32FirmwareImageN)rf rg rh ri r r] r r r r r0 æ r4 r0 c @ r3 )r1 úDESP32H2 Firmware Image almost exactly the same as ESP32FirmwareImageN)rf rg rh ri r r] r r r r r1 ï r4 r1 c @ r3 )r2 r7 N)rf rg rh ri r r] r r r r r2 ø r4 r2 c @ ó e Zd ZdZeZdd„ ZdS )r3 zDESP32C2 Firmware Image almost exactly the same as ESP32FirmwareImagec C ó |dvr t d |¡ƒ‚|| _d S )N)é @ é € rŒ zI{} bytes is not a valid ESP32-C2 page size, select from 64KB, 32KB, 16KB.©r rº rœ r» r r r r¼ ó ş
z&ESP32C2FirmwareImage.set_mmu_page_sizeN)rf rg rh ri r r] r¼ r r r r r3 ó r3 c @ r8 )r4 r6 c C r9 )N)i r: r; rŒ zN{} bytes is not a valid ESP32-C6 page size, select from 64KB, 32KB, 16KB, 8KB.r< r» r r r r¼ r= z&ESP32C6FirmwareImage.set_mmu_page_sizeN)rf rg rh ri r r] r¼ r r r r r4 r> r4 c @ r3 )r5 r7 N)rf rg rh ri r
r] r r r r r5 # r4 r5 c @ sb e Zd ZdZdZdZdZeeefZdZdZ dZ
dd„ Z d d
„ Z d d „ Z
d
d„ Zdd„ Zdd„ ZdS )ÚELFFiler r é r é( rs c C sB || _ t| j dƒ�}| |¡ W d ƒ d S 1 sw Y d S ©Nr? )rm rB Ú_read_elf_file)rL rm r r r r rM 9 s "ÿzELFFile.__init__c C s* | j D ] }|j|kr| S qtd| ƒ‚)NzNo section %s in ELF file)Úsectionsrm Ú
ValueError)rL Ú section_namer¬ r r r Ú get_section? s
ÿ zELFFile.get_sectionc C s d}zt d| |¡¡\}}}}| _}}} }
} } }
}}W n t jy2 } z td| j|f ƒ‚d }~ww t|dƒdksB|dd… dkrItd | j ƒ‚|d
vrVtd | j|f ƒ‚|
| jkrftd | j|
| jf ƒ‚|dkrqtd
| j ƒ‚| ||||¡ |
||| |¡ d S )Né4 z<16sHHLLLLLHHHHHHz-Failed to read a valid ELF header from %s: %sr é r rF s ELFz %s has invalid ELF magic header)é^ éó zG%s does not appear to be an Xtensa or an RISCV ELF file. e_machine=%04xz;%s has unexpected section header entry size 0x%x (not 0x%x)z%s has 0 section headers) r{ r| r7 rv Úerrorr rm r ÚLEN_SEC_HEADERÚ_read_sectionsÚ_read_segments)rL r ÚLEN_FILE_HEADERÚidentÚ_typeÚmachineÚ_versionÚ_phoffÚshoffÚ_flagsÚ_ehsizeÚ
_phentsizeÚ_phnumÚ shentsizeÚshnumÚshstrndxÚer r r rC E sT ñ ÿ€ÿ ÿÿ
ÿÿzELFFile._read_elf_filec
s& ˆ |¡ || j }ˆ |¡‰tˆƒdkrtd| ƒ‚tˆƒ|kr+tdtˆƒ|f ƒ‚tdtˆƒ| jƒ}‡fdd„‰‡fdd„|D ƒ}dd„ |D ƒ}|| j |vrWtd | ƒ‚ˆ|| j ƒ\} }
} } } |
tjkrntd
|
ƒ ˆ | ¡ ˆ | ¡‰‡fd d „‰‡ fd
d„‰‡‡fdd„|D ƒ}|| _ d S )Nr z3No section header found at offset %04x in ELF file.zMOnly read 0x%x bytes from section header (expected 0x%x.) Truncated ELF file?c s. t dˆ | d … ¡\}}}}}}|||||fS )Nz<LLLLLL©r{ Ú unpack_from)ÚoffsÚ name_offsÚsec_typerW ÚlmaÚsec_offsr )Úsection_headerr r Úread_section_header� s ÿz3ELFFile._read_sections.<locals>.read_section_headerc ó g | ]}ˆ |ƒ‘qS r r ©rY ra )rg r r r\ ‡ ó z*ELFFile._read_sections.<locals>.<listcomp>c S s g | ] }|d t jv r|‘qS )r )r? ÚPROG_SEC_TYPESr« r r r r\ ˆ ó z-ELF file has no STRTAB section at shstrndx %dz:WARNING: ELF file has incorrect STRTAB section type 0x%02xc s ˆ | d … }|d | d¡… S ra )Úindex)ra Úraw)Ú string_tabler r Ú
lookup_stringš s z-ELFFile._read_sections.<locals>.lookup_stringc ó ˆ | ¡ ˆ |¡S re ©r r7 ©ra r ©r r r Ú read_data� ó
z)ELFFile._read_sections.<locals>.read_datac s< g | ]\}}}}}|d kr|d krt ˆ |ƒ|ˆ||ƒƒ‘qS ©r ©rj )rY Ún_offsrR rd r ra )rp ru r r r\ ¢ s ııÿ)
r rM r7 rT r r³ r? ÚSEC_TYPE_STRTABr� rD )
rL r Úsection_header_offsÚsection_header_countr] Ú len_bytesÚsection_header_offsetsÚ all_sectionsÚ
prog_sectionsr¾ rc Úsec_sizere r )r rp ru rg rf ro r rN o sH
ÿÿ
ÿÿ ÿ
ÿ
ş
zELFFile._read_sectionsc s¼ ˆ |¡ || j }ˆ |¡‰tˆƒdkrtd| ƒ‚tˆƒ|kr+tdtˆƒ|f ƒ‚tdtˆƒ| jƒ}‡fdd„‰‡fdd„|D ƒ}dd„ |D ƒ}‡ fd d
„‰‡fd d„|D ƒ}|| _d S ) Nr z3No segment header found at offset %04x in ELF file.zMOnly read 0x%x bytes from segment header (expected 0x%x.) Truncated ELF file?c s0 t dˆ | d … ¡\}}}}}}}}||||fS )Nz <LLLLLLLLr_ ) ra Úseg_typeÚseg_offsÚ_vaddrrd r Ú_memsizerW Ú_align)Úsegment_headerr r Úread_segment_header» s
÷ z3ELFFile._read_segments.<locals>.read_segment_headerc rh r r ri )rˆ r r r\ È rj z*ELFFile._read_segments.<locals>.<listcomp>c S s g | ] }|d t jkr|‘qS rw )r? Ú
SEG_TYPE_LOADr« r r r r\ É rl c rq re rr rs rt r r ru Ë rv z)ELFFile._read_segments.<locals>.read_datac s6 g | ]\}}}}|d kr|d krt d|ˆ ||ƒƒ‘qS )r s PHDRrx )rY rR rd r ra )ru r r r\ Ï s
ııÿ)r ÚLEN_SEG_HEADERr7 rT r r³ ru ) rL r Úsegment_header_offsÚsegment_header_countr] r} Úsegment_header_offsetsÚ all_segmentsÚ
prog_segmentsr )r ru rˆ r‡ r rO © s0
ÿÿ
ÿÿ
ş
zELFFile._read_segmentsc C sP t ¡ }t| jdƒ�}| | ¡ ¡ W d ƒ | ¡ S 1 s w Y | ¡ S rB )ré rê rB rm rë r7 rì )rL rê r r r r rê Ö s
ÿşzELFFile.sha256N)rf rg rh ÚSEC_TYPE_PROGBITSrz ÚSEC_TYPE_INITARRAYÚSEC_TYPE_FINIARRAYrk rM r‰ rŠ rM rG rC rN rO rê r r r r r? , s
*: -r? )1rÖ rP ré r rÍ r( r{ Úloaderr Útargetsr r r r r r r
r r r
r r Úutilr r r r rD ÚobjectrE rj rq r9 ÚBOOTLOADER_IMAGEr: rÓ r+ r- r, r- r. r/ r0 r1 r2 r3 r4 r5 r? r r r r Ú<module> s\ 8+4 f.w *n | 33,063 | Python | .pyt | 227 | 143.484581 | 1,670 | 0.442712 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,695 | cmds.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/__pycache__/cmds.cpython-310.pyc | o
’jÂdÑÂ ã @ sL d dl Z d dlZd dlZd dlZd dlZd dlZd dlZddlmZm Z m
Z
ddlm Z m Z m
Z
ddlmZmZmZmZmZ ddlmZmZmZ ddlmZmZmZm Z ddlm Z m Z m Z m Z m!Z!m"Z" i d d
“d d “d
d“dd“dd“dd“dd“dd“dd“dd “d d “d d“d d “d!d “d"d
“d#d “d$d“ddddddd%œ¥Z#d dd&d'd(œZ$ej%ej&d)d*efd+d,„Z'd-d.„ Z(d/d0„ Z)d1d2„ Z*d3d4„ Z+dfd5d6„Z,d7d8„ Z-d9d:„ Z.d;d<„ Z/d=d>„ Z0d?d@„ Z1dAdB„ Z2dCdD„ Z3dEdF„ Z4dGdH„ Z5dIdJ„ Z6dKdL„ Z7dMdN„ Z8dOdP„ Z9dQdR„ Z:dSdT„ Z;dd&dUdVdWd dXdYdZd[d\d]œ Z<d^d_„ Z=d`da„ Z>dbdc„ Z?ddde„ Z@dS )gé Né )ÚELFFileÚ ImageSegmentÚLoadFirmwareImage)ÚESP8266ROMFirmwareImageÚESP8266V2FirmwareImageÚESP8266V3FirmwareImage)ÚDEFAULT_CONNECT_ATTEMPTSÚDEFAULT_TIMEOUTÚERASE_WRITE_TIMEOUT_PER_MBÚ ESPLoaderÚtimeout_per_mb)Ú CHIP_DEFSÚ CHIP_LISTÚROM_LIST)Ú
FatalErrorÚNotImplementedInROMErrorÚNotSupportedErrorÚUnsupportedCommandError)Ú div_roundupÚflash_size_bytesÚ
get_file_sizeÚhexifyÚpad_toÚprint_overwriteé Ú256KBé Ú512KBé Ú1MBé Ú2MBé Ú4MBé Ú8MBé Ú16MBé Ú32MBé Ú64MBé Ú128MBé Ú256MBé é! é" é2 é3 é4 )é5 é6 é7 é8 é9 é: é é )ÚqioÚqoutÚdioÚdoutÚ
default_resetFc C s2 d}t | ||d�}|j d¡rd|_|j||dd� zĞzDtddd� | ¡ }d d
„ tD ƒD ]*}||jkrW||j ||d�}z|
t j ¡ W n t yP d|_
Y nw | ¡ nq-d |› d �} W nk t tjtfyÊ }
z[td
ƒ zEt|
tjƒs|j||ddd� tddd� tj ¡ |
t j ¡} tD ]}| |jv r«||j ||d�}| ¡ | ¡ nq’d| d›d �} W n t y¿ tdƒ‚w W Y d}
~
nd}
~
ww W |durêtd|j dd� |jrä| |¡}d|_tdƒ |S n'|du�rtd|j dd� |j�r| |¡}d|_tdƒ | Y S w t| › d�ƒ‚)aG Use serial access to detect the chip type.
First, get_security_info command is sent to detect the ID of the chip
(supported only by ESP32-C3 and later, works even in the Secure Download Mode).
If this fails, we reconnect and fall-back to reading the magic number.
It's mapped at a specific ROM address and has a different value on each chip model.
This way we use one memory read and compare it to the magic number for each chip.
This routine automatically performs ESPLoader.connect() (passing
connect_mode parameter) as part of querying the chip.
N)Ú
trace_enabledzrfc2217:T)Ú detectingzDetecting chip type...Ú ©Úendc S s g | ] }|j d vr|‘qS ))ÚESP8266ÚESP32zESP32-S2©Ú CHIP_NAME©Ú.0Ún© rP ú,/home/ceco/Downloads/esptool/esptool/cmds.pyÚ
<listcomp>b s
ÿÿz detect_chip.<locals>.<listcomp>zUnexpected chip ID value Ú.z> Unsupported detection protocol, switching and trying again...F)rE Úwarningsz Unexpected chip magic value z#010xz˜Unsupported Command Error received. Probably this means Secure Download Mode is enabled, autodetection will not work. Need to manually specify the chip.z %szW Failed to autodetect chip type.
Probably it is unsupported by this version of esptool.)r Ú serial_portÚ
startswithÚ USES_RFC2217ÚconnectÚprintÚ get_chip_idr Ú
IMAGE_CHIP_IDÚ_portÚread_regÚCHIP_DETECT_MAGIC_REG_ADDRr Úsecure_download_modeÚ
_post_connectÚstructÚerrorr Ú
isinstanceÚsysÚstdoutÚflushÚCHIP_DETECT_MAGIC_VALUEÚ
check_chip_idrL Úsync_stub_detectedÚ
STUB_CLASS) ÚportÚbaudÚ connect_moderD Úconnect_attemptsÚinstÚ detect_portÚchip_idÚclsÚerr_msgÚeÚchip_magic_valuerP rP rQ Ú detect_chipH s�
ÿ
ÿ
ÿ÷ € ÿ
ÿ
ü€ ÿÿ€æ€!
ú
ÿrv c C sà t | j|jƒ}tdƒ |jD ]R}t|jƒ}td||jf dd� tj
¡ | |t || j
ƒ| j
|j¡ d}t|jƒdkr\| |jd| j
… |¡ |j| j
d … |_|d7 }t|jƒdks<tdƒ qtd|j ƒ | |j¡ d S ) Nz RAM boot...z Downloading %d bytes at %08x...ú rG r r zdone!z$All segments done, executing at %08x)r rL ÚfilenamerY ÚsegmentsÚlenÚdataÚaddrrd re rf Ú mem_beginr Ú
ESP_RAM_BLOCKÚ mem_blockÚ
entrypointÚ
mem_finish)ÚespÚargsÚimageÚsegÚsizeÚseqrP rP rQ Úload_ram¦ s$
ÿı
rˆ c C s t d|j| |j¡f ƒ d S )Nz0x%08x = 0x%08x)rY Úaddressr] ©r‚ rƒ rP rP rQ Úread_mem½ s r‹ c C s2 | |j|j|jd¡ td|j|j|jf ƒ d S )Nr z Wrote %08x, mask %08x to %08x)Ú write_regr‰ ÚvalueÚmaskrY rŠ rP rP rQ Ú write_memÁ s r� c C s t |jdƒ�M}t|jd ƒD ]3}| |j|d ¡}| t d|¡¡ | ¡ d dkr<t
d| ¡ | ¡ d |j f ƒ t j
¡ qt
d| ¡ d d
� W d ƒ n1 sVw Y td ƒ d S ) NÚwbé s <Ié r z%d bytes read... (%d %%)éd z
Read %d bytesT©Ú last_linezDone!)Úopenrx Úranger† r] r‰ Úwritera ÚpackÚtellr rd re rf rY )r‚ rƒ ÚfÚiÚdrP rP rQ Údump_memÆ s ÿ ÷
r� c C sŒ | j r|d ur|jdkrtdƒ‚d S | ¡ }|d? }t |¡}|d urD|jdkrD|d u r<d}td|d›d|d›d�ƒ ntd |ƒ ||_|S )
NÚdetectzcDetecting flash size is not supported in secure download mode. Need to manually specify flash size.é r$ z3Warning: Could not auto-detect Flash size (FlashID=ú#xz , SizeID=z), defaulting to 4MBzAuto-detected Flash size:)r_ Ú
flash_sizer Úflash_idÚDETECTED_FLASH_SIZESÚgetrY )r‚ rƒ r£ Úsize_idr¢ rP rP rQ Údetect_flash_sizeÔ s, ÿ
ÿÿÿ
r§ c sÔ t |ƒdk r|S t d|dd… ¡\}}}}ˆ | jkr |S |j|j|jfdkr)|S || jkr6tdˆ ƒ |S z| t
|¡¡}| ¡ W n t
yX tdˆ | jf ƒ | Y S w |jdkoc|d d
k} ‡ fd d „}
|jd
krƒt|j } || kr�| r�|
d|jƒ n| }|d@ } |jd
kr¡| |j¡}
| |
krŸ| rŸ|
d|jƒ n|
} |d@ }|jd
kr¿| |j¡}||kr½| r½|
d|jƒ n|}t d||| ¡}||dd… krètdt d|¡ ƒ |dd… | |dd… }|S )z^
Modify the flash mode & size bytes if this looks like an executable bootloader image
é ÚBBBBNr‘ )Úkeeprª rª z`Warning: Image file at 0x%x doesn't look like an image file, so not changing any flash settings.zXWarning: Image file at 0x%x is not a valid %s image, so not changing any flash settings.Úesp8266r% r c s t djtˆ ƒ| |d�ƒ d S )NaL Warning: Image file at {addr} is protected with a hash checksum, so not changing the flash {arg} setting. Use the --flash_{arg}=keep option instead of --flash_{arg}={arg_orig} in order to remove this warning, or use the --dont-append-digest option for the elf2image command in order to generate an image file without a hash checksum)r| ÚargÚarg_orig)rY ÚformatÚhex)Ú arg_to_keepÚarg_used©r‰ rP rQ Úprint_keep_warning s
úÿz6_update_image_flash_params.<locals>.print_keep_warningrª Úmodeé Ú frequencyéğ r† s BBr= zFlash params set to 0x%04xz>Hr )rz ra ÚunpackÚBOOTLOADER_FLASH_OFFSETÚ
flash_modeÚ
flash_freqr¢ ÚESP_IMAGE_MAGICrY ÚBOOTLOADER_IMAGEÚioÚBytesIOÚverifyÚ ExceptionrL ÚchipÚ FLASH_MODESÚparse_flash_freq_argÚparse_flash_size_argr™ )r‚ r‰ rƒ r„ ÚmagicÚ_rº Úflash_size_freqÚ
test_imageÚsha_implies_keepr³ Únew_flash_moder» Únew_flash_freqr¢ Únew_flash_sizeÚ flash_paramsrP r² rQ Ú_update_image_flash_paramsî sb
ÿÿ ÿÿû
rÏ c $ s¦ ˆ j d u r
ˆ js
ˆ j ˆ _ ˆ j�s
| jdk�r
| j�s
| ¡ r/ˆ jD ] \}}|dk r.tdƒ‚q"ˆ jD ]Ú\}}z#zt | j|ƒ}W n tt
j t fyR Y W |
d¡ q2w W |
d¡ n|
d¡ w |j| jkrrt|j› d| j› d�ƒ‚|jdkrzd}n|jdkr�d }|jdkr�|jdkr�d}nd }|ré| ¡ }||jk s ||jkrè|j› d
�}|d |jd › d
|jd › d�7 }|jdkrÁ|d7 }n|d|jd › d
|jd › d�7 }|d|d › d
|d › d�7 }t|› d�ƒ‚q2| jdkró| ¡ }n| ¡ }||jk �r t|j› d|j› d|› d�ƒ‚q2ˆ j�sˆ jd u�rzd } | j�sI| ¡ �r&tdƒ‚| ¡ }
|
d u�r<|
dk�r<td|
ƒ d} | ¡ } | �sItd ƒ d} ˆ j�rPˆ jnˆ j} | D ]\}}|| j �rltd |j|| j f ƒ d} �qU| �syˆ j �sytd ƒ‚n:ˆ j�s´| jdk�r´| jd k�r¢| j�r¢t | ¡ d ƒ !d!¡d"@ dk�r¢td#ƒ‚| j�s´| ¡ �r´| "¡ �r´td$ƒ‚t#ˆ j$d%k�r¿t%| ƒnˆ j$ƒ}
|
d u�róˆ jD ]'\}}|
dt&j'¡ || (¡ |
k�rìtd&|j| (¡ ||
f ƒ‚|
d¡ �qˈ j)�rıt*| ˆ ƒ nBˆ jD ]>\}}|
dt&j'¡ || (¡ }|
d¡ || j+ }|dk�r*td' ,|| j+|¡ƒ td( ,|| t-|| j+ƒ| j+ d" ¡ƒ �q ‡ fd)d*„ˆ jD ƒ} ˆ jd u�rcd+d*„ ˆ jD ƒ}t.|| d,d-„ d.�}|D �]�\}}}ˆ j }|�r�|�r�td/ƒ td0|j ƒ d}ˆ j�r‰td1ƒ t/| 0¡ |�r“| j nd2ƒ}t1|ƒdk�r¦td3|j ƒ �qet2| |ˆ |ƒ}t3 4|¡ 5¡ }t1|ƒ}|�rÑ|}t6 |d4¡}t6 7¡ }| 8|t1|ƒ|¡}n| j9|||d5�}|
d¡ d}d}d}t: :¡ } t;} t1|ƒdk�rqt<d6|| d |d" | f ƒ t=j> ?¡ |d| j@… } |�r8t1| A| ¡ƒ} || 7 }tBt;tCtD| ƒƒ} | jE�s)| } | jF| || d7� | jE�r7| } n!| d8| j@t1| ƒ } |�rM| G| |¡ n| H| |¡ |t1| ƒ7 }|t1| ƒ7 }|| j@d … }|d"7 }t1|ƒdk�sñ| jE�r}| jItJjK| d7� t: :¡ | } d9}!|�r¥| d:k�r—d;|| d< d= }!t<d>|||| |!f d d?� n| d:k�r´d@|| d< d= }!t<dA||| |!f d d?� |�s| j�sz/| L||¡}"|"|k�rğtdB| ƒ tdC|" ƒ tdDt3 4d8| ¡ 5¡ ƒ tdEƒ‚tdFƒ W �qe tM�y Y �qew �qetdGƒ | jE�r*| 9dd¡ |dH dI }#ˆ j �r%|#�s%| Nd¡ n| Od¡ ˆ jP�rOtdJƒ tdKƒ ˆ j�s@ˆ jd u�rDtdLƒ ˆ j�sQtQ| ˆ ƒ d S d S d S )MNrI i € z´Secure Boot detected, writing to flash regions < 0x8000 is disabled to protect the bootloader. Use --force to override, please use with caution, otherwise it may brick your device!r z is not an z$ image. Use --force to flash anyway.Fiÿÿ Tz! requires chip revision in range z[vr“ rS z - zmax rev not set] Úvz] z(this chip is revision vú)z . Use --force to flash anyway.zESP32-C3z requires chip revision z" or higher (this chip is revision z ). Use --force to flash anyway.zŸThis chip has encrypt functionality in UART download mode disabled. This is the Flash Encryption configuration for Production mode instead of Development mode.rµ z)Unexpected FLASH_CRYPT_CONFIG value: 0x%xz&Flash encryption key is not programmedzBFile %s address 0x%x is not %d byte aligned, can't flash encryptedz`Can't perform encrypted flash write, consult Flash Encryption documentation for more informationrJ Úflash_crypt_cntÚ1r zšWARNING: Detected flash encryption and secure download mode enabled.
Flashing plaintext binary may brick your device! Use --force to override the warning.z¦WARNING: Detected flash encryption enabled and download manual encrypt disabled.
Flashing plaintext binary may brick your device! Use --force to override the warning.rª zzFile %s (length %d) at offset %d will not fit in %d bytes of flash. Use --flash_size argument, or change flashing address.z|WARNING: Flash address {:#010x} is not aligned to a {:#x} byte flash sector. {:#x} bytes before this address will be erased.z1Flash will be erased from {:#010x} to {:#010x}...c s g | ]
\}}||ˆ j f‘qS rP )Úencrypt©rN Úoffsrx ©rƒ rP rQ rR s ÿz write_flash.<locals>.<listcomp>c S s g | ] \}}||d f‘qS )TrP rÕ rP rP rQ rR s ÿc S ó | d S ©Nr rP ©ÚxrP rP rQ Ú<lambda> ó z write_flash.<locals>.<lambda>©Úkeyz@
WARNING: - compress and encrypt options are mutually exclusive zWill flash %s uncompressedzErasing flash...r‘ zWARNING: File %s is emptyé )Úbegin_rom_encryptedz Writing at 0x%08x... (%d %%))Útimeoutó ÿrF ç z (effective %.1f kbit/s)r¨ éè z=Wrote %d bytes (%d compressed) at 0x%08x in %.1f seconds%s...r” z (%.1f kbit/s)z-Wrote %d bytes at 0x%08x in %.1f seconds%s...z
File md5: %sz
Flash md5: %szMD5 of 0xFF is %sz)MD5 of file does not match data in flash!zHash of data verified.z
Leaving...éÿÿÿÿr= z Verifying just-written flash...zT(This option is deprecated, flash contents are now always read back after flashing.)z>WARNING: - cannot verify encrypted files, they will be ignored)RÚcompressÚ no_compressÚno_stubÚforcerL r_ Úget_secure_boot_enabledÚ
addr_filenamer r ra rb Ú RuntimeErrorÚseekrq r[ ÚnameÚ max_rev_fullÚ min_rev_fullÚmin_revÚget_chip_revisionÚget_minor_chip_versionÚget_major_chip_versionrÔ Ú
encrypt_filesÚ get_encrypted_download_disabledÚget_flash_crypt_configrY Ú is_flash_encryption_key_validÚFLASH_ENCRYPTED_WRITE_ALIGNÚ%ignore_flash_encryption_efuse_settingÚbinÚget_security_infoÚcountÚ get_flash_encryption_enabledr r¢ r§ ÚosÚSEEK_ENDrš Ú erase_allÚ erase_flashÚFLASH_SECTOR_SIZEr® r Úsortedr Úreadrz rÏ ÚhashlibÚmd5Ú hexdigestÚzlibÚ
decompressobjÚflash_defl_beginÚ flash_beginÚtimer
r rd re rf ÚFLASH_WRITE_SIZEÚ
decompressÚmaxr
r ÚIS_STUBÚflash_defl_blockÚflash_encrypt_blockÚ flash_blockr] r r^ Ú flash_md5sumr Úflash_defl_finishÚ flash_finishrÀ Ú verify_flash)$r‚ rƒ r‰ rÇ Úargfiler„ Úuse_rev_full_fieldsÚrevÚ error_strÚdo_writeÚcrypt_cfg_efuseÚ
enc_key_validÚfiles_to_encryptÚ flash_endÚ write_endÚ
bytes_overÚ all_filesÚencrypted_files_flagÚ encryptedrç Úcalcmd5ÚuncsizeÚuncimager Úblocksr‡ Ú
bytes_sentÚ
bytes_writtenÚtrâ ÚblockÚblock_uncompressedÚ
block_timeoutÚ speed_msgÚresÚlast_file_encryptedrP r× rQ Ú write_flashB s"
ÿÿ ıÿ ÿ
ÿÿ€ ÿ
ÿ ô
ÿÿÿÿ
ÿ ÿÿ€ÿ€ÿş ıÿÿşıÿÿ
ıÿ
ÿı
ÿşşÿ
ÿ ÿ ÿ
ÿÿ
şÿ€ İ%
ÿı
ÿı
ÿÿÿ€
ÿó r5 c s† ‡ ‡fdd„}t dtˆ jƒ› d�ƒ tˆ jdƒ�‚}z | d¡}|d }W n ty/ tdƒ‚w |tjt j
fvr?td |¡ƒ‚ˆ j d
kr“z8| d ¡}|d d
vrTtdƒ‚t
|dd… d¡}dd„ tD ƒD ]
}||jkrr|jˆ _ n qetd|› d�ƒ‚W n tyˆ dˆ _ Y nw t dˆ j ¡ › �ƒ W d ƒ n1 s�w Y tˆ j ˆ jƒ‰ˆ jdkr³|ƒ d S t d ˆj¡ƒ t ˆjdkrÇd ˆj¡ndƒ t d tˆjƒ¡ƒ t ƒ d}ˆjD ]} |d 7 }| ˆ¡}
d |
¡} t d || | ¡ƒ q܈ ¡ } t d ˆjˆj| k�rd!nd" | ¡¡ƒ z)d#}
ˆj �r5ˆj ˆj k}d$ t ˆj d%d&�|�r(d!nd'¡}
t d( |
¡ƒ W d S W d S t �yB Y d S w ))Nc #
sh dd„ } t ƒ d ˆ j ¡ ¡}t |ƒ t dt|ƒ ƒ t d ˆj¡ƒ t ˆjdkr/d ˆj¡ndƒ t d tˆjƒ¡ƒ ˆjd
@ }| ˆj j
|ƒ}t |d urRd |¡nd |¡ƒ ˆjd
@ }| ˆj j |ƒ}t |d urnd |¡nd |¡ƒ | t ˆj
ƒ}t |d ur†d | ¡ ¡nd ˆj
¡ƒ ˆ jdk�r't ƒ d ˆ j ¡ ¡}t |ƒ t dt|ƒ ƒ t dˆjd›�gˆjˆjkr»dgng ¢R � t d ˆjˆjˆjˆjˆjˆj¡ƒ z t‡fdd„t ¡ D ƒƒ}t dˆj› d|j› d �ƒ W n t�y t dˆj› d �ƒ Y nw t d ˆj d › d ˆj d › d!ˆj › d �ƒ t d"ˆj d › d ˆj d › �ƒ t ƒ d#}t |ƒ t dt|ƒ ƒ d$}t | d%d&d'd(d)¡ƒ t d* d+d+d,d,d-¡ƒ d.} d }
d } t ˆjd/d0�D ]@\} }
|
ˆ¡}d1 !|¡}d2|v �rx|
j"d d3… }
nd4|v �rŒt|
j"ƒd5k�rŒ|
j"d d5… } t | | t|
j"ƒ|
j#|
j$|¡ƒ �q]t ƒ ˆ j ¡ › d6�}t |ƒ t dt|ƒ ƒ ˆ %¡ }t d7 ˆj&ˆj&|k�rÆd8nd9 |¡¡ƒ z%d:}ˆj'�rñˆj(ˆj)k}d; t*ˆj)d<d=�|�rçd8nd>¡}t d? |¡ƒ W n
t+�yü Y nw |
�rld@}t, -||
¡\
}}}}}}}}} } |dAk�rjt ƒ dB}t |ƒ t dt|ƒ ƒ t dC| .dD¡› �ƒ t dE| .dD¡› �ƒ t dF| .dD¡› dG| .dD¡› �ƒ t dHt*| d<d=�› �ƒ t dI| .dD¡› �ƒ t dJ|› �ƒ d S d S | �r°dK} t, -| | ¡\} } }}}!}"| d5k�r²t ƒ dL}t |ƒ t dt|ƒ ƒ t dM|› �ƒ t dI| .dD¡› �ƒ t dF|! .dD¡› �ƒ d S d S d S )NNc S s& | ¡ D ] \}}||kr| S qdS )z Get key from value in dictionaryN)Úitems)ÚdictÚvalrß r� rP rP rQ Úget_key_from_value± s
ÿz2image_info.<locals>.v2.<locals>.get_key_from_valuez{} image headerú=úImage version: {}r zEntry point: {:#8x}úEntry point not setz Segments: {}r· zFlash size: {}z%WARNING: Invalid flash size ({:#02x})rµ zFlash freq: {}z*WARNING: Invalid flash frequency ({:#02x})zFlash mode: {}z WARNING: Invalid flash mode ({})r« z{} extended image headerzWP pin: z#02xz
(disabled)zFlash pins drive settings: clk_drv: {:#02x}, q_drv: {:#02x}, d_drv: {:#02x}, cs0_drv: {:#02x}, hd_drv: {:#02x}, wp_drv: {:#02x}c 3 s& � | ]}t |d dƒˆ jkr|V qdS )r[ N)Úgetattrrq )rN r )r„ rP rQ Ú <genexpr>ö s € ı
ÿz)image_info.<locals>.v2.<locals>.<genexpr>z Chip ID: z (rÑ z
(Unknown ID)zMinimal chip revision: vr“ rS z, (legacy min_rev = zMaximal chip revision: vzSegments informationz#{:>7} {:>7} {:>10} {:>10} {:10}ÚSegmentÚLengthz Load addrz File offsz Memory typesz{} {} {} {} {}z-------z
----------z ------------z%{:7} {:#07x} {:#010x} {:#010x} {}r )Ústartú, ÚDROMé ÚDRAMéP z
image footerzChecksum: {:#02x} ({})Úvalidúinvalid - calculated {:02x}ú Not appendedú{} ({})F©Ú uppercaseÚinvalidzValidation hash: {}z<II8s32s32s16s16s32s32s80sl 2TšW zApplication informationzProject name: zutf-8z
App version: zCompile time: rw zELF file SHA256: z ESP-IDF: zSecure version: z<B3sI32s24s16szBootloader informationzBootloader version: )/rY r® r Úupperrz Úversionr€ ry rÈ Ú
ROM_LOADERÚ FLASH_SIZESÚFLASH_FREQUENCYrà rº Úwp_pinÚWP_PIN_DISABLEDÚclk_drvÚq_drvÚd_drvÚcs_drvÚhd_drvÚwp_drvÚnextr Úvaluesrq rL Ú
StopIterationrñ rò rğ Ú enumerateÚget_memory_typeÚjoinr{ r| Ú file_offsÚcalculate_checksumÚchecksumÚ
append_digestÚ
stored_digestÚ calc_digestr ÚAttributeErrorra r¸ Údecode)#r9 ÚtitleÚ flash_s_bitsÚflash_sÚ
flash_fr_bitsÚflash_frrº rÂ Ú headers_strÚ
format_strÚapp_descÚbootloader_descÚidxr… ÚsegsÚseg_nameÚ
calc_checksumÚ
digest_msgÚis_validÚAPP_DESC_STRUCT_FMTÚ
magic_wordÚsecure_versionÚreserv1rO Ú project_namer ÚdateÚidf_verÚapp_elf_sha256Úreserv2ÚBOOTLOADER_DESC_STRUCT_FMTÚ
magic_byteÚreservedÚ date_timeÚ reserved2©rƒ r„ rP rQ Úv2° s` ÿı
ÿı
ÿı ÿ
ı ÿşúı ş ÿÿÿşÿÿÿÿ
ÿÿÿ
ÿÿüÿ ş€ÿ
õ
ö
ù
î zimage_info.<locals>.v2z File size: z (bytes)Úrbr¨ r z
File is emptyz7This is not a valid image (invalid magic number: {:#x})Úautor ræ ©r r z Append digest field not 0 or 1r‘ é Úlittlec S s g | ] }|j d kr|‘qS )rI rK rM rP rP rQ rR ‰ s z image_info.<locals>.<listcomp>zUnknown image chip ID (rÑ r« zDetected image type: Ú2r; zEntry point: {:8x}r< z {} segmentsr ú,zSegment {}: {} [{}]zChecksum: {:02x} ({})rG rH rI rJ FrK rM zValidation Hash: {})!rY r rx r– r Ú
IndexErrorr r r¼ r ÚIMAGE_V2_MAGICr® r ÚintÚ
from_bytesr r[ rL rN r rO r€ rz ry r_ r` rb rc rd re rf r rg )rƒ r‡ r› Ú
common_headerrÆ Úextended_headerrq Úromrr r… rs rt ru rv rw rP r† rQ Ú
image_info¯ sš @
ÿşş
şş
ÿ€ Ş$
ÿı
ÿüÿ şúÿr– c C sÌ t d | j¡ƒ tƒ }t| jƒdkrtdƒ‚t| jƒt| jƒkr$tdƒ‚t| j| jƒD ]&\}}t |dƒ�}|
¡ }|j t
||ƒ¡ W d ƒ n1 sLw Y q+| j|_| | j¡ t d | j¡ƒ d S )NúCreating {} image...r zNo segments specifiedzFNumber of specified files does not match number of specified addressesrˆ ú Successfully created {} image.)rY r® r r rz Úsegfiler ÚsegaddrÚzipr– r ry Úappendr r€ ÚsaveÚoutput)rƒ r„ r… r| r› r{ rP rP rQ Ú
make_image¾ s" ÿ ş€ rŸ c C sÊ t | jƒ}| jdkr
d| _td | j¡ƒ | jdkrCt| j ¡ }| jdkr,| jr,d|_| jr2d|_| j |_ | j
|_
| j |_ | j |_ n| j
dkrLtƒ }n | j
dkrUtƒ }ntƒ }|j|_t| j |_| jrm| t| jƒ¡ | jrs|jn|j|_| jr€t| jƒ|_|j | j ¡|_ | j |j | j ¡7 _ | j!r | "¡ |_#| j!|_!t$|jƒ}| %¡ t$|jƒ|krÅ|t$|jƒ }td||dkrÀd nd
f ƒ | &¡ | j'd u rÕ| (| j¡| _'| )| j'¡ td | j¡ƒ d S ) Nr‰ r« r— Úesp32rÓ r� zMerged %d ELF section%sr ÚsrF r˜ )*r Úinputr rY r® r r½ Ú
secure_padÚ
secure_pad_v2rò rñ rğ rd rO r r r r€ rà rº Úflash_mmu_page_sizeÚset_mmu_page_sizer Ú use_segmentsry ÚsectionsÚ pad_to_sizerP rÅ r¢ rÈ rÄ r» Úelf_sha256_offsetÚsha256Ú
elf_sha256rz Úmerge_adjacent_segmentsrÀ r� Údefault_output_namer� )rƒ rt r„ ÚbeforeÚdeltarP rP rQ Ú elf2imageĞ sR
r± c C sX dd„ }| d¡}|r"|d|ƒ |d| d¡ƒ |d| d¡ƒ d S |d| d¡ƒ d S )Nc S s$ t d| d tdd„ |ƒ¡f ƒ d S )Nz%s: %sú:c S s d| S )Nz%02xrP rÚ rP rP rQ rÜ rİ z-read_mac.<locals>.print_mac.<locals>.<lambda>)rY r` Úmap)ÚlabelÚmacrP rP rQ Ú print_mac s $zread_mac.<locals>.print_macÚEUI64ÚMACzBASE MACÚBASE_MACÚMAC_EXT)Úread_mac)r‚ rƒ r¶ Úeui64rP rP rQ r» s
r» c C sH z
| ¡ }td| ƒ W d S ty# td| j ƒ t| |ƒ Y d S w )NzChip ID: 0x%08xz0Warning: %s has no Chip ID. Reading MAC instead.)rq rY r rL r» )r‚ rƒ ÚchipidrP rP rQ rq s şrq c C s^ |j s| jdkr| js| ¡ s| ¡ rtdƒ‚tdƒ t ¡ }| ¡ tdt ¡ | ƒ d S )NrI ú§Active security features detected, erasing flash is disabled as a safety measure. Use --force to override, please use with caution, otherwise it may brick your device!z(Erasing flash (this may take a while)...z*Chip erase completed successfully in %.1fs) rê rL r_ rÿ rë r rY r r ©r‚ rƒ r. rP rP rQ r s ÿr c C sf |j s| jdkr| js| ¡ s| ¡ rtdƒ‚tdƒ t ¡ }| |j |j
¡ tdt ¡ | ƒ d S )NrI r¾ z1Erasing region (may be slow depending on size)...z-Erase completed successfully in %.1f seconds.) rê rL r_ rÿ rë r rY r Ú erase_regionr‰ r† r¿ rP rP rQ rÀ , s ÿrÀ c C s | ¡ d S ©N)ÚrunrŠ rP rP rQ r ; s r c C s† | ¡ }td|d@ ƒ |d? d@ }td|d? d@ |f ƒ tdt |d¡ ƒ | ¡ }dd d
œ}| |¡}|rAtd |› �ƒ d S d S ) NzManufacturer: %02xéÿ r zDevice: %02x%02xr¨ zDetected flash size: %sÚUnknownzquad (4 data lines)zoctal (8 data lines)rŠ zFlash type set in eFuse: )r£ rY r¤ r¥ Ú
flash_type)r‚ rƒ r£ Ú flid_lowbyterÅ Úflash_type_dictÚflash_type_strrP rP rQ r£ ? s ÿ
ÿr£ c C sº |j rd }ndd„ }t ¡ }| |j|j|¡}t ¡ | }|dkr.d t|ƒ| d d ¡nd}td t|ƒ|j||¡d d
� t|j d ƒ�}|
|¡ W d ƒ d S 1 sVw Y d S ) Nc S sJ d| | d | f }dt |ƒ }| |krd}tj || ¡ tj ¡ d S )Nz
%d (%d %%)g Y@úÚ
)rz rd re r˜ rf )ÚprogressÚlengthÚmsgÚpaddingrP rP rQ Úflash_progressS s z"read_flash.<locals>.flash_progressrä z ({:.1f} kbit/s)r¨ rå rF z2Read {:d} bytes at {:#010x} in {:.1f} seconds{}...Tr” r� ) Ú no_progressr Ú
read_flashr‰ r† r® rz r r– rx r˜ )r‚ rƒ rÏ r. r{ r2 r› rP rP rQ rÑ N s &ÿü "ÿrÑ c s. d}|j D ]‰\}}t| ¡ dƒ‰| d¡ t| ||ˆƒ‰tˆƒ}td||||jf ƒ | ||¡}t
ˆ¡ ¡ }||krAtdƒ qd}t |ddƒd krPtd
ƒ q|
||¡‰ ˆ ˆks\J ‚‡ ‡fd d „t|ƒD ƒ}td
t|ƒ||d f ƒ |D ]} ˆ | }
ˆ| } td|| |
| f ƒ qxq|r•tdƒ‚d S )NFr‘ r z9Verifying 0x%x (%d) bytes @ 0x%08x in flash against %s...z -- verify OK (digest matched)TÚdiffÚnoÚyesz"-- verify FAILED (digest mismatch)c s g | ] }ˆ | ˆ| kr|‘qS rP rP )rN rœ ©Úflashr„ rP rQ rR … s z verify_flash.<locals>.<listcomp>z0-- verify FAILED: %d differences, first @ 0x%08xz %08x %02x %02xzVerify failed.)rì r r rî rÏ rz rY rï r r r r r= rÑ r— r ) r‚ rƒ Ú differencesr‰ r Ú
image_sizeÚdigestÚexpected_digestrÒ r� Ú
flash_byteÚ
image_byterP rÕ rQ r i sH
ÿÿ ÿÿıÿr c C s t d| |j¡ ƒ d S )NzStatus value: 0x%04x)rY Ú read_statusÚbytesrŠ rP rP rQ Úread_flash_status’ s rß c C s‚ d|j d }|jd|j d > d @ |_td| | |j ¡ ƒ td| |j ƒ | |j|j |j¡ td| | |j ¡ ƒ d S )Nz0x%%0%dxr= r r¨ zInitial flash status: zSetting flash status: zAfter flash status: )rŞ r� rY rİ Ú write_statusÚ non_volatile)r‚ rƒ ÚfmtrP rP rQ Úwrite_flash_status– s rã r‘ r¨ r é@ é€ rD i r’ ) ÚSECURE_BOOT_ENÚ SECURE_BOOT_AGGRESSIVE_REVOKEÚSECURE_DOWNLOAD_ENABLEÚSECURE_BOOT_KEY_REVOKE0ÚSECURE_BOOT_KEY_REVOKE1ÚSECURE_BOOT_KEY_REVOKE2Ú
SOFT_DIS_JTAGÚ
HARD_DIS_JTAGÚDIS_USBÚDIS_DOWNLOAD_DCACHEÚDIS_DOWNLOAD_ICACHEc C s0 z |t | @ dkW S ty td| › �ƒ‚w )Nr zInvalid flag name: )ÚSECURITY_INFO_FLAG_MAPÚKeyErrorÚ
ValueError)Ú flag_nameÚ flags_valuerP rP rQ Úget_security_flag_status± s
ÿrö c C sì | ¡ }tƒ d}t|ƒ tdt|ƒ ƒ td |d t|d ƒ¡ƒ td |d ¡ƒ |d d urJ|d d urJtd |d ¡ƒ td
|d ¡ƒ |d }td |ƒr�td ƒ td
|ƒr`tdƒ g }tg d¢ƒD ]\}}t||ƒrv| |¡ qht|ƒdkr�tdƒ |D ]
}td|› d�ƒ qƒntdƒ t|d ƒ}| d¡d dkr§tdƒ ntdƒ d} | j dkr´d } t| › d |d d ›�ƒ td |ƒrÉtd ƒ td!|ƒrÒtd"ƒ td#|ƒ}
td$|ƒ} |
rãtd%ƒ n| rétd&ƒ td'|ƒrôtd(ƒ d S d S ))NzSecurity Information:r: zFlags: {:#010x} ({})ÚflagszKey Purposes: {}Ú key_purposesrq Ú api_versionz Chip ID: {}zAPI Version: {}ræ zSecure Boot: Enabledrç z.Secure Boot Aggressive key revocation: Enabled)ré rê rë r z#Secure Boot Key Revocation Status:
z Secure Boot Keyz is Revoked
zSecure Boot: DisabledrÒ rÓ r= zFlash Encryption: EnabledzFlash Encryption: Disabledz)SPI Boot Crypt Count (SPI_BOOT_CRYPT_CNT)r z#Flash Crypt Count (FLASH_CRYPT_CNT)z: r¡ rï z&Dcache in UART download mode: Disabledrğ z&Icache in UART download mode: Disabledrí rì zJTAG: Permenantly Disabledz JTAG: Software Access Disabledrî zUSB Access: Disabled)
rı rY rz r® rü rö r^ rœ rş rL ) r‚ rƒ Úsiri r÷ Ú revoked_keysrœ rß rÒ ÚCRYPT_CNT_STRINGÚ
hard_dis_jtagÚ
soft_dis_jtagrP rP rQ rı ¸ sb
ÿ
€ €
ÿrı c sP zt ˆ j }W n" ty) ˆ jdkrdnd ˆ j¡}|d d t¡¡ }t|ƒ‚w tˆ jdd„ d�}|s9td ƒ‚|d
d
}|ˆ j k rMtd ˆ j |f ƒ‚ˆ jd krVtd
ƒ‚t
ˆ j dƒ�B‰‡ ‡fdd„}|D ]\}}||ƒ | ¡ }t
||ˆ |ƒ}ˆ |¡ qfˆ jr‰|tˆ jƒƒ tdˆ ¡ ˆ j ˆ j f ƒ W d ƒ d S 1 s¡w Y d S )Nr‰ z Please specify the chip argumentzInvalid chip choice: '{}'z (choose from {})rB c S rØ rÙ rP rÚ rP rP rQ rÜ rİ zmerge_bin.<locals>.<lambda>rŞ zNo input files specifiedr zIOutput file target offset is 0x%x. Input file offset 0x%x is before this.Úrawz=This version of esptool only supports the 'raw' output formatr� c s ˆ d| ˆ j ˆ ¡ ¡ d S )Nrã )r˜ Ú
target_offsetrš )Ú
flash_offs©rƒ ÚofrP rQ r s zmerge_bin.<locals>.pad_toz:Wrote 0x%x bytes to file %s, ready to flash to offset 0x%x)r r rò r® r` r r r rì r r– r� r rÏ r˜ Úfill_flash_sizer rY rš ) rƒ Ú
chip_classrÍ Ú input_filesÚ
first_addrr r| r r„ rP r rQ Ú merge_binú sN ÿ
ıù
ÿÿ
ÿ ÿÿ"ór c C s ddl m} t|ƒ d S )Nr )Ú __version__)rF r rY )rƒ r rP rP rQ rO * s rO rÁ )Ar r¾ r ra rd r r
Ú bin_imager r r r r r Úloaderr r
r r r
Útargetsr r r Úutilr r r r r r r r r r r¤ rÃ Ú DEFAULT_PORTÚ ESP_ROM_BAUDrv rˆ r‹ r� r� r§ rÏ r5 r– rŸ r± r» rq r rÀ r r£ rÑ r rß rã rñ rö rı r rO rP rP rP rQ Ú<module> sÌ ÿşıüûúùø ÷
ö õ ô
óòñğïé
û^
T o 7
) õB 0 | 30,980 | Python | .pyt | 223 | 137.650224 | 2,611 | 0.485368 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,696 | __init__.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/__pycache__/__init__.cpython-310.pyc | o
’jÂdÓ� ã @ s| g d ¢Z dZddlZddlZddlZddlZddlZddlZddlZddl m
Z
m Z m Z m
Z
mZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m Z m Z m Z m Z m!Z! ddl"m#Z# ddl$m%Z%m&Z&m'Z' ddl(m)Z)m*Z*m+Z+ ddl,m-Z-m.Z.m/Z/m0Z0 ddl1Z1d d d
„Z2d d „ Z3d
d„ Z4dd„ Z5dd„ Z6 d dd„Z7G dd„ dej8ƒZ9G dd„ dej8ƒZ:d d „ Z;e<d kr¼e;ƒ dS dS )!)Úchip_idÚ detect_chipÚdump_memÚ elf2imageÚ erase_flashÚ erase_regionÚflash_idÚget_security_infoÚ
image_infoÚload_ramÚ
make_imageÚ merge_binÚ
read_flashÚread_flash_statusÚread_macÚread_memÚrunÚ verify_flashÚversionÚ write_flashÚwrite_flash_statusÚ write_memz4.7-devé N)ÚDETECTED_FLASH_SIZESr r Údetect_flash_sizer r r r r r r r
r r r
r r r r r r r r r )Úload_config_file)ÚDEFAULT_CONNECT_ATTEMPTSÚ ESPLoaderÚ
list_ports)Ú CHIP_DEFSÚ CHIP_LISTÚESP32ROM)Ú
FatalErrorÚNotImplementedInROMErrorÚflash_size_bytesÚstrip_chip_namec % sæ ˆdu}t jdt dd�}|jdddtdgt tj d d¡d
� |jd d d
tj dd¡d� |jdddt tj dt
j ¡d� |jddg d¢tj dd¡d� |jdd d g d ¢tj d d ¡d� |jd!d"d#d$� |jd%d&d'd#d$� |jd(d)t j
d*d+� |jd,d-t ttj d.t¡d� |jd/d0d1�}d2d3„ ‰|jd4d5d6�}|jd7d8d6� |jd9d:d6�}|jd;d<t d=� |jd>d?t d=� |jd7d@d6� |jdAdBd6�}|jd;dCt d=� |jdDdEd6�}|jd;dFt d=� |jdGdHt d=� |jdIdJt d*dKdL� ‡fdMdN„} |jdOdPd6�}
|
jdQdRdStdT� |
jdUdVdWd#d$� | |
dXdXdY� |
jdZd d[d#d$� |
jd\d]d#d$� |
jd^d_d#d$� |
jd`dRdatdT� |
jdbdcd#d$� |
jddded#d$� |
jdfdg�} | jdhdidjd#ddk� | jdldmdnd#d$� |jdodpd6� |jdqdrd6�} | jd7dsd6� | jdtdudvdwdxgdwd� |jdydzd6�}
|
jd{d|d6� |
jd}d~dd€d�� |
jd‚d ddƒt d„� |
jd…dVd†t d‡d� |jdˆd‰d6�}|jdŠd‹d6� |jdŒd�d�td=� |jdtdVd�g d�¢dwd� |jd‘d’t jttd“ƒd”d‡d•� |jd–d—ttd˜ƒd™d‡d•� |jdšd›ttd˜ƒd™dœd•� |jd�d#d�d�� |jdŸd#d d�� |jd¡d¢t dd� |jd£d¤d¥d¦dXd§� |jd¨d©d#d$� |jdªd«g d¬¢d� |jd®d¯dd� | |dfdfdY� |jd°d±d6� |jd²d³d6� |jd´dµd6�}ˆ|ƒ |jd¶d·d6�}ˆ|ƒ |jd¸d¹tg dº¢d»d
� |jd¼d½d6�}ˆ|ƒ |jd¾d¿d#d$� |jd¸dÀtg dº¢d»d
� |jdGdÁt d=� |jdÂdÃd6�}ˆ|ƒ |jd;dÄt d=� |jd>dÅtd=� |jd7d@d6� |jdZd d[d#d$� |jdÆdÇd6�}|jdQdÈtd$� |jdÉdÊdËdÌdÍgdÌd� | |dXdXdY� |jdÎdÏd6�}|jdddĞd#d$� ˆ|ƒ |jdÑdÒd6�}|jdddÓd#d$� ˆ|ƒ |jd;dÔt d=� |jd>dÕtd=� |jdÖd×d6�}|jdŒd�dØtdXdÙ� |jdÚd~dÛdÜdÜd� | |dXdfdY� |jdİd&dŞt d‡d� |jdßdàg dá¢d� |jdQdRdStdT� |jdâdãd6� |jdädåd6� |j ¡ D ]}|tƒ v �sxJ dæ| ƒ‚�qjt| �p„t j dçd… ƒ} | | ¡}t dèt ƒ t dXdé� |j!du �r¥| "¡ t #dç¡ |j!dOk�r¹|j$�r¹|j%du�r¹t&dꃂtƒ |j! }t' (|¡j)}|d‡ dëk�rm|j*dìk�rÚt+t
j |j,ƒ}n|j,}|j-du �rït.ƒ } t dít/| ƒ ƒ n|j-g} ˆ�pt0| |j-|j1||j2|j3|j*dî�‰ˆdu �rt&dït/| ƒ ƒ‚ˆj4�r t dğˆj5 ƒ n t dñˆ 6¡ ƒ t dòdó 7ˆ 8¡ ¡ ƒ t dôˆ 9¡ ƒ t:ˆ|ƒ |j;�s€ˆj4�rOt dõƒ dX|_;n1ˆj<�s_ˆj=�r_t döƒ dX|_;n!zˆ >¡ ‰W n t?�y t j@d÷k�r~ˆ A¡ døk�r~t dùƒ ‚ w |jB�rŠˆ B|jB¡ |j,|k�r©zˆ C|j,¡ W n tD�y¨ t dú| ƒ Y nw tE|dûƒ�rÍ|jFdu�r͈j5dük�rÂt&dıˆj5 ƒ‚t dşƒ ˆ G|jF¡ n
|j;�rÚt dÿƒ ˆ Gd‡¡ �d ‰ ‡ ‡f�d�d„‰‡ ‡‡f�d�d„} ˆj4�s zˆ H¡ } | �dv �rt �dƒ W n t&�y } z
t&�d| › �d�ƒ‚d} ~ ww ˆj4�sEz| ƒ W n t&�yD } zˆ 3�d | › �d�¡ W Y d} ~ nd} ~ ww tE|�d
ƒ�r‹t �d ƒ |jI�d k�r^tJˆ|ƒ} n|jI�d
k�rmtJˆd�d�} n|jI} | du�r‹ˆ KtL| ƒ¡ ˆj<�r‹| �dv �r‹t �dƒ tM|d>�dƒ�dk�rĈj4�rŸt&�dƒ‚ˆ H¡ } | �d? }!tN |!¡}"|"du �r·t&�dƒ‚t �d|"› �ƒ tL|"ƒ|_Oˆj<�rãtE|d;ƒ�rãtE|d>ƒ�rã|jP|jO �dk�rãt �dƒ z |ˆ|ƒ W z|jQD ] \}#}$|$ R¡ �qîW n$ tS�y Y nw z|jQD ] \}#}$|$ R¡ �qW w tS�y Y w w |tTk�r)t �dƒ n8|jUd k�r4ˆ V¡ n-|jU�dk�rFt �dƒ ˆ Wdf¡ n|jU�dk�rSt �d ƒ nt �d ƒ ˆj<�raˆ WdX¡ |�skˆjX R¡ dS dS ||ƒ dS ( aš
Main function for esptool
argv - Optional override for default arguments parsing (that uses sys.argv),
can be a list of custom arguments as strings. Arguments and their values
need to be added as individual items to the list
e.g. "-b 115200" thus becomes ['-b', '115200'].
esp - Optional override of the connected device previously
returned by get_default_connected_device()
Nz7esptool.py v%s - Espressif chips ROM Bootloader UtilityÚesptool)Ú descriptionÚprogz--chipz-czTarget chip typeÚautoÚ ESPTOOL_CHIP)ÚhelpÚtypeÚchoicesÚdefaultz--portz-pzSerial port deviceÚ ESPTOOL_PORT)r* r- z--baudz-bz0Serial port baud rate used when flashing/readingÚ ESPTOOL_BAUD)r* r+ r- z--beforez(What to do before connecting to the chip)Ú
default_resetÚ usb_resetÚno_resetÚno_reset_no_syncÚESPTOOL_BEFOREr0 ©r* r, r- z--afterz-az'What to do after esptool.py is finished)Ú
hard_resetÚ
soft_resetr2 Ú
no_reset_stubÚ
ESPTOOL_AFTERr6 z --no-stubzeDisable launching the flasher stub, only talk to ROM bootloader. Some features will not be available.Ú
store_true©r* Úactionz--tracez-tz5Enable trace-level output of esptool.py interactions.z--override-vddsdiozAOverride ESP32 VDDSDIO internal voltage regulator (use with care)ú?)r* r, Únargsz--connect-attemptszGNumber of attempts to connect, negative or 0 for infinite. Default: %d.ÚESPTOOL_CONNECT_ATTEMPTSÚ operationz/Run esptool.py {command} -h for additional help)Údestr* c S s | j dddtd� d S )Nz--spi-connectionz-scz£ESP32-only argument. Override default SPI Flash connection. Value can be SPI, HSPI or a comma-separated list of 5 I/O numbers to use for SPI flash (CLK,Q,D,HD,CS).r; )Ú add_argumentÚSpiConnectionAction)Úparent© rE ú0/home/ceco/Downloads/esptool/esptool/__init__.pyÚadd_spi_connection_arg¯ s
úz$main.<locals>.add_spi_connection_argr
z$Download an image to RAM and execute)r* ÚfilenamezFirmware imager z Dump arbitrary memory to diskÚaddressz Base address)r* r+ ÚsizezSize of region to dumpzName of binary dumpr z Read arbitrary memory locationzAddress to readr z.Read-modify-write to arbitrary memory locationzAddress to writeÚvalueÚValueÚmaskzMask of bits to writeÚ
0xFFFFFFFF)r* r+ r> r- c sæ |rdgng }|r|rd}ddg}n|rd}dg}n |r"d}dg}nd}g }| j ddd |g d
¢ tj d |r8dnd ¡d
� | j ddd|g d¢ tj d|rOdnd¡d
� | j ddd| |g d¢ tj d|rhdnd¡d
� ˆ | ƒ d S )z4Add common parser arguments for SPI flash propertiesÚkeepz, detect, or keepÚdetectz , or detectz , or keepÚ z --flash_freqz-ffzSPI Flash frequency) Ú80mÚ60mÚ48mÚ40mÚ30mÚ26mÚ24mÚ20mÚ16mÚ15mÚ12mÚ
ESPTOOL_FFNr5 z --flash_modez-fmzSPI Flash mode)ÚqioÚqoutÚdioÚdoutÚ
ESPTOOL_FMr^ z --flash_sizez-fszzSPI Flash size in MegaBytes (1MB, 2MB, 4MB, 8MB, 16MB, 32MB, 64MB, 128MB) plus ESP8266-only (256KB, 512KB, 2MB-c1, 4MB-c1)) Ú256KBÚ512KBÚ1MBÚ2MBz2MB-c1Ú4MBz4MB-c1Ú8MBÚ16MBÚ32MBÚ64MBÚ128MBÚ
ESPTOOL_FSre )rB ÚosÚenvironÚget)rD Ú
allow_keepÚ auto_detectÚextra_keep_argsÚextra_fs_messageÚ flash_sizes)rG rE rF Úadd_spi_flash_subparsersÙ sP
ÿî
ûşÿë z&main.<locals>.add_spi_flash_subparsersr z Write a binary blob to flashÚ
addr_filenamez<address> <filename>z7Address followed by binary filename, separated by space)Úmetavarr* r< z --erase-allz-ezDErase all regions of flash (not just write areas) before programmingT)rq rr z
--no-progresszSuppress progress outputz--verifyzYVerify just-written data on flash (mostly superfluous, data is read back during flashing)z --encryptzJApply flash encryption when writing data (required correct efuse settings)z--encrypt-filesz\Files to be encrypted on the flash. Address followed by binary filename, separated by space.z'--ignore-flash-encryption-efuse-settingz'Ignore flash encryption efuse settings z--forcezFForce write, skip security and compatibility checks. Use with caution!F)Úrequiredz
--compressz-zzACompress data in transfer (default unless --no-stub is specified))r* r< r- z
--no-compressz-uzLDisable data compression during transfer (default if --no-stub is specified)r z Run application code in flashr z;Dump headers from a binary file (bootloader or application)zImage file to parsez --versionz-vz0Output format version (1 - legacy, 2 - extended)Ú1Ú2r z-Create an application image from binary filesÚoutputzOutput image filez --segfilez-fÚappendzSegment input file)r< r* z --segaddrzSegment base address)r< r* r+ z --entrypointzAddress of entry pointr r z)Create an application image from ELF fileÚinputzInput ELF filez--outputz-ozVOutput filename prefix (for version 1 image), or filename (for version 2 single image)zOutput image version)rz r{ Ú3z --min-revz-ré z {0, ... 255})r* r+ r, rx r- z--min-rev-fullz6Minimal chip revision (in format: major * 100 + minor)i z{0, ... 65535}z--max-rev-fullz6Maximal chip revision (in format: major * 100 + minor)iÿÿ z --secure-padzXPad image so once signed it will end on a 64KB boundary. For Secure Boot v1 images only.z--secure-pad-v2zwPad image to 64KB, so once signed its signature sector willstart at the next 64K block. For Secure Boot v2 images only.z--elf-sha256-offsetz^If set, insert SHA256 hash (32 bytes) of the input ELF file at specified offset in the binary.z--dont-append-digestÚ
append_digestz|Don't append a SHA256 digest of the entire image after the checksum. This argument is not supported and ignored for ESP8266.Ú store_false)rA r* r< r- z--use_segmentszQIf set, ELF segments will be used instead of ELF sections to genereate the image.z--flash-mmu-page-sizezChange flash MMU page size.)Ú64KBÚ32KBÚ16KBÚ8KB)r* r, z
--pad-to-sizez‰The block size with which the final binary image after padding must be aligned to. Value 0xFF is used for padding, similar to erase_flashr z Read MAC address from OTP ROMr zRead Chip ID from OTP ROMr z)Read SPI flash manufacturer and device IDr z Read SPI flash status registerz--bytesz Number of bytes to read (1-3))é é é rˆ r z Write SPI flash status registerz--non-volatilez*Write non-volatile bits (use with caution)z%Number of status bytes to write (1-3)z New valuer
zRead SPI flash contentz
Start addressz>Size of region to dump. Use `ALL` to read to the end of flash.r z"Verify a binary blob against flashz;Address and binary file to verify there, separated by spacez--diffz-dzShow differencesÚnoÚyesr z Perform Chip Erase on SPI flashzDErase flash even if security features are enabled. Use with caution!r zErase a region of the flashzEErase region even if security features are enabled. Use with caution!z(Start address (must be multiple of 4096)z[Size of region to erase (must be multiple of 4096). Use `ALL` to erase to the end of flash.r zEMerge multiple raw binary files into a single file for later flashingzOutput filename)r* r+ ry z--formatzFormat of the output fileÚrawz--target-offsetz3Target offset where the output file will be flashedz--fill-flash-sizezQIf set, the final binary file will be padded with FF bytes up to this flash size.)
rc rd re rf rg rh ri rj rk rl r z Get some security-related datar zPrint esptool versionz %s should be a module functionr‡ zesptool.py v%s)ÚverbosezMOptions --encrypt and --encrypt-files must not be specified at the same time.Úespr3 zFound %d serial ports)ÚportÚconnect_attemptsÚ initial_baudÚchipÚtraceÚbeforezQCould not connect to an Espressif device on any of the %d available serial ports.z"Chip is %s in Secure Download Modez
Chip is %sz Features: %sz, zCrystal is %dMHzzPWARNING: Stub loader is not supported in Secure Download Mode, setting --no-stubzKWARNING: Stub loader has been disabled for compatibility, setting --no-stubÚdarwiniÔU zL
Note: If issues persist, try installing the WCH USB-to-Serial MacOS driver.zMWARNING: ROM doesn't support changing baud rate. Keeping initial baud rate %dÚspi_connectionÚESP32z1Chip %s does not support --spi-connection option.z Configuring SPI flash mode...z"Enabling default SPI flash mode...é c s¸ ˆ ¡ } | d@ d> | d? d@ B | d@ B }|d? d@ }|d? d@ }|d@ }|ˆ kr*dS d}|dkr<|dkr:|dkr:d }|S |d
krL|d krJ|dkrJd }|S |d krZ|d
krZ|dkrZd }|S )Néÿ é i ÿ é Fé@ é r˜ TéA é éP é é )r )ÚidÚrdidÚ vendor_idÚmfidÚcpidÚmatched)Ú
XMC_VENDOR_IDr� rE rF Úis_xmc_chip_strictó s( úız main.<locals>.is_xmc_chip_strictc sŒ d} | r ˆƒ r d S d}ˆ |d¡}|ˆ krd S tdƒ ˆ d¡ ˆ d¡ ˆ d¡ t d¡ ˆ d ¡ t d
¡ ˆƒ s@td ƒ td ƒ d S )
NTrš r› zQWARNING: XMC flash chip boot-up failure detected! Running XMC25QHxxC startup flowé¹ éy r™ gü©ñÒMb`?é« gñh㈵øô>z&WARNING: XMC flash boot-up fix failed.z&XMC flash chip boot-up fix successful!)Úread_spiflash_sfdpÚprintÚrun_spiflash_commandÚtimeÚsleep)Ú
fast_checkÚsfdp_mfid_addrÚmf_id)r© r� rª rE rF Úflash_xmc_startup
s&
ÿ
z main.<locals>.flash_xmc_startup)iÿÿÿ r z§WARNING: Failed to communicate with the flash chip, read/write operations will fail. Try checking the chip connections or removing any other hardware connected to IOs.z(Unable to verify flash chip connection (z).z3Unable to perform XMC flash chip startup sequence (Ú
flash_sizezConfiguring flash size...rP rO )Úargs)rj rk rl zjWARNING: Flasher stub doesn't fully support flash size larger than 16MB, in case of failure use --no-stub.rQ ÚallzWDetecting flash size is not supported in secure download mode. Set an exact size value.rš z5Detecting flash size failed. Set an exact size value.zDetected flash size: i zExiting immediately.r7 zSoft resetting...r8 zStaying in flasher stub.zStaying in bootloader.)YÚargparseÚArgumentParserÚ __version__rB r$ r rn ro rp Ú arg_auto_intr Ú ESP_ROM_BAUDr ÚOVERRIDE_VDDSDIO_CHOICESr ÚintÚadd_subparsersÚ
add_parserÚAddrFilenamePairActionÚ add_mutually_exclusive_groupÚstrÚSUPPRESSÚrangeÚ
arg_auto_sizer, ÚkeysÚglobalsÚexpand_file_argumentsÚsysÚargvÚ
parse_argsr¯ r r@ Ú
print_helpÚexitÚencryptÚ
encrypt_filesr! ÚinspectÚgetfullargspecr¸ r” ÚminÚbaudr� Ú
get_port_listÚlenÚ get_default_connected_devicer� r’ r“ Úsecure_download_modeÚ CHIP_NAMEÚget_chip_descriptionÚjoinÚget_chip_featuresÚget_crystal_freqr Úno_stubÚIS_STUBÚstub_is_disabledÚrun_stubÚ ExceptionÚplatformÚ_get_pidÚoverride_vddsdioÚ change_baudr" Úhasattrr– Úflash_spi_attachr r· r Úflash_set_parametersr# Úgetattrr rJ rI rw ÚcloseÚAttributeErrorr
Úafterr6 r7 Ú_port)%rÍ r� Ú external_espÚparserÚ
subparsersÚparser_load_ramÚparser_dump_memÚparser_read_memÚparser_write_memrv Úparser_write_flashÚ
compress_argsÚparser_image_infoÚparser_make_imageÚparser_elf2imageÚparser_flash_idÚparser_read_statusÚparser_write_statusÚparser_read_flashÚparser_verify_flashÚparser_erase_flashÚparser_erase_regionÚparser_merge_binr@ r¸ Úoperation_funcÚoperation_argsr‘ Úser_listr¶ r Úer· Úsize_idÚsize_strrI ÚargfilerE )r© rG r� rª rF ÚmainP sr
ÿı ú üû ü ûüüüÿ ù
ÿ
ÿÿÿÿÿû Eÿüüÿüüûıı ûûÿûÿÿûûÿûû÷ úúııûúüıüÿÿûÿıûÿıÿÿıÿÿıÿıÿüş
ÿ
ÿûüü
ÿşıÿ
ÿ ÿ ù
ÿÿ
ÿÿ ÿù ÿÿÿ ÿ
ÿ€€ÿ
"€ÿ
ÿÿ
ÿ
ÿ ÿÿı ÿÿ
ÿ r c C s
t | dƒS ©Nr ©rÀ ©ÚxrE rE rF r½ „ s
r½ c C s | ¡ } | dkr
| S t| ƒS )Nr¹ )Úlowerr½ r rE rE rF rÈ ˆ s rÈ c C s& t d u rtdƒ‚tdd„ t ¡ D ƒƒS )Nz Listing all serial ports is currently not available. Please try to specify the port when running esptool.py or update the pyserial package to the latest versionc s s � | ]}|j V qd S ©N)Údevice)Ú.0ÚportsrE rE rF Ú <genexpr>” s € z get_port_list.<locals>.<genexpr>)r r! ÚsortedÚcomportsrE rE rE rF r× � s
ÿr× c C sš g }d}| D ]6}| d¡r7d}t|dd… dƒ�}| ¡ D ] }|t |¡7 }q W d ƒ n1 s1w Y q| |¡ q|rKtdd |¡› �ƒ |S | S ) zù
Any argument starting with "@" gets replaced with all values read from a text file.
Text file arguments can be split by newline or by space.
Values are added "as-is", as if they were specified in this order
on the command line.
Fú@Tr‡ NÚrz esptool.py ú )Ú
startswithÚopenÚ readlinesÚshlexÚsplitr} r¯ rİ )rÍ Únew_argsÚexpandedÚargÚfÚlinerE rE rF rË — s
ÿ ÿ€ rË r( Fr0 c C sÄ d }t | ƒD ]Y}td| ƒ z$|dkr t|||||ƒ}W |S t| } | |||ƒ}| ||¡ W |S ttfy_ }
z |d urA‚ td||
f ƒ |rS|jrS|j ¡ d }W Y d }
~
qd }
~
ww |S )NzSerial port %sr( z%s failed to connect: %s) Úreversedr¯ r r Úconnectr! ÚOSErrorrğ rí ) Ú serial_listr� r� r‘ r’ r“ r” Ú_espÚ each_portÚ
chip_classÚerrrE rE rF rÙ ® s2
ÿõ ù
€úrÙ c @ s e Zd ZdZddd„ZdS )rC z‰
Custom action to parse 'spi connection' override.
Values are SPI, HSPI, or a sequence of 5 pin numbers separated by commas.
Nc C sü | ¡ dkr d}nl| ¡ dkrd}ncd|v rm| d¡}t|ƒdkr)t | d| ¡‚z tdd „ |D ƒƒ}W n tyC t | d
| ¡‚w td d „ |D ƒƒrSt | d
¡‚|\}}}} }
| d> |
d> B |d> B |d> B |B }nt | d| ¡‚t|| j |ƒ d S )NÚSPIr ÚHSPIr‡ ú,é zX%s is not a valid list of comma-separate pin numbers. Must be 5 numbers - CLK,Q,D,HD,CS.c s s � | ]}t |d ƒV qdS )r Nr ©r ÚvrE rE rF r â s € z/SpiConnectionAction.__call__.<locals>.<genexpr>z;%s is not a valid argument. All pins must be numeric valuesc S s g | ] }|d ks |dk r|‘qS )é! r rE r2 rE rE rF Ú
<listcomp>é s z0SpiConnectionAction.__call__.<locals>.<listcomp>z&Pin numbers must be in the range 0-33.é é é é zl%s is not a valid spi-connection value. Values are SPI, HSPI, or a sequence of 5 pin numbers CLK,Q,D,HD,CS).)
Úupperr rØ rº Ú
ArgumentErrorÚtupleÚ
ValueErrorÚanyÚsetattrrA ) Úselfrò Ú namespacerK Ú
option_stringÚvaluesÚclkÚqÚdÚhdÚcsrE rE rF Ú__call__Ô sH
ÿş ÿşÿÿ&şşz SpiConnectionAction.__call__r )Ú__name__Ú
__module__Ú __qualname__Ú__doc__rI rE rE rE rF rC Î s rC c s, e Zd ZdZd‡ fdd„ Zd dd„Z‡ ZS )
rà zFCustom parser class for the address/filename pairs passed as argumentsú+c s t t| ƒj|||fi |¤� d S r )Úsuperrà Ú__init__)r@ Úoption_stringsrA r> Úkwargs©Ú __class__rE rF rP ÿ s
ÿ
ÿz AddrFilenamePairAction.__init__Nc C sX g }t dt|ƒdƒD ]N}z t|| dƒ}W n ty& t | d|| ¡‚w z t||d dƒ}W n tyD } zt | | ¡‚d } ~ w tyP t | d¡‚w | ||f¡ q
d}
t
|dd„ d �D ]?\}}| dd¡ | ¡ } | d¡ |t
jd @ } || t
j d t
jd @ d }
| |
k r d
||jf }t | |¡‚|
}
qct|| j|ƒ d S ) Nr rˆ z Address "%s" must be a numberr‡ ÚrbzBMust be pairs of an address and the binary filename to write therec S s | d S r
rE r rE rE rF Ú<lambda> s z1AddrFilenamePairAction.__call__.<locals>.<lambda>)Úkeyz.Detected overlap at address: 0x%x for file: %s)rÇ rØ rÀ r= rº r; r ÚIOErrorÚ
IndexErrorr} r ÚseekÚtellr ÚFLASH_SECTOR_SIZEÚnamer? rA )r@ rò rA rC rB ÚpairsÚirI r r ÚendrJ Ú sector_startÚ
sector_endÚmessagerE rE rF rI sP ÿÿ € şÿ
ÿış z AddrFilenamePairAction.__call__)rN r )rJ rK rL rM rP rI Ú
__classcell__rE rE rS rF rà ü s rà c
C sÌ zt ƒ W d S ty% } ztd| › �ƒ t d¡ W Y d } ~ d S d } ~ w tjjyM } ztd| › �ƒ tdƒ tdƒ t d¡ W Y d } ~ d S d } ~ w tye tt
¡ ƒ tdƒ t d¡ Y d S w )Nz
A fatal error occurred: rˆ z$
A serial exception error occurred: z€Note: This error originates from pySerial. It is likely not a problem with esptool, but with the hardware connection or drivers.zkFor troubleshooting steps visit: https://docs.espressif.com/projects/esptool/en/latest/troubleshooting.htmlr‡ z4A fatal error occurred: The chip stopped responding.) r r! r¯ rÌ rĞ ÚserialÚ
serialutilÚSerialExceptionÚ
StopIterationÚ tracebackÚ
format_exc)r rE rE rF Ú_main/ s* €ÿÿ€ ırk Ú__main__)NN)r( Fr0 )=Ú__all__r¼ rº rÓ rn r rÌ r± ri Ú esptool.cmdsr r r r r r r r r r r r
r r r
r r r r r r r r r Úesptool.configr Úesptool.loaderr r r Úesptool.targetsr r r Ú esptool.utilr! r" r# r$ re r r½ rÈ r× rË rÙ ÚActionrC rà rk rJ rE rE rE rF Ú<module> sH h
:
ù .3
ÿ | 23,388 | Python | .pyt | 151 | 153.423841 | 3,241 | 0.563934 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,697 | loader.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/__pycache__/loader.cpython-310.pyc | o
’jÂd
î ã @ s† d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl Z ddl
m Z ddl m
Z
mZmZmZmZmZ ddlmZmZmZ ddlmZmZmZmZmZ zd dl Z W n e yk e dej ƒ ‚ w zde j v r{d e j v r{e d
ƒ‚W n e!y… Y nw z d dl"m# m$Z$ W n# e y£ e d ej%ej f ƒ ‚ e&y´ ej'd kr±dZ$n‚ Y nw e ƒ \Z(Z)e(d
Z(e( *dd¡Z+e( *dd¡Z,e( *de,d ¡Z-e( *dd¡Z.e( *dd¡Z/e( *dd¡Z0e( *dd¡Z1e( *d d ¡Z2e( *d d ¡Z3e( 4d d!¡Z5e( 4d"d¡Z6ej7 8ej7 9e:¡d#d$¡Z;d%d&„ Z<d'd(„ Z=d)d*„ Z>d+d,„ Z?d-d.„ Z@d/d0„ ZAG d1d2„ d2ƒZBG d3d4„ d4eCƒZDd5d6„ ZEG d7d8„ d8eCƒZFdS )9é Né )Úload_config_file)Ú ClassicResetÚ CustomResetÚDEFAULT_RESET_DELAYÚ HardResetÚUSBJTAGSerialResetÚUnixTightReset)Ú
FatalErrorÚNotImplementedInROMErrorÚUnsupportedCommandError)ÚbyteÚhexifyÚ
mask_to_shiftÚpad_toÚstrip_chip_namezQPyserial is not installed for %s. Check the README for installation instructions.Ú
serializationÚdeserializationaà esptool.py depends on pyserial, but there is a conflict with a currently installed package named 'serial'.
You may work around this by 'pip uninstall serial; pip install pyserial' but this may break other installed Python software that depends on 'serial'.
There is no good fix for this right now, apart from configuring virtualenvs. See https://github.com/espressif/esptool/issues/269#issuecomment-385298196 for discussion of the underlying issue(s).z”The installed version (%s) of pyserial appears to be too old for esptool.py (Python interpreter %s). Check the README for installation instructions.ÚdarwinÚesptoolÚtimeouté Úchip_erase_timeoutéx Ú max_timeouté Ú sync_timeoutgš™™™™™¹?Úmd5_timeout_per_mbé Úerase_region_timeout_per_mbé Úerase_write_timeout_per_mbé( Úmem_end_rom_timeoutgš™™™™™É?Úserial_write_timeouté
Úconnect_attemptsé Úwrite_block_attemptsÚtargetsÚ stub_flasherc C s* t | ƒ} | dd¡} tj td| › d�¡S )NÚespÚ Ú
stub_flasher_z.json)r ÚreplaceÚosÚpathÚjoinÚ STUBS_DIR)Ú chip_name© r4 ú./home/ceco/Downloads/esptool/esptool/loader.pyÚget_stub_json_pathg s r6 c C s | |d }|t k r t S |S )z'Scales timeouts which are size-specificç €„.A)ÚDEFAULT_TIMEOUT)Úseconds_per_mbÚ
size_bytesÚresultr4 r4 r5 Útimeout_per_mbm s r< c s ‡ ‡fdd„}|S )at
Decorator implementation that wraps a check around an ESPLoader
bootloader function to check if it's supported.
This is used to capture the multidimensional differences in
functionality between the ESP8266 & ESP32 (and later chips) ROM loaders, and the
software stub that runs on these. Not possible to do this cleanly
via inheritance alone.
c s( | d }ˆ |ƒrˆ| i |¤�S t |ˆƒ‚)Nr )r )ÚargsÚkwargsÚobj©Ú
check_funcÚfuncr4 r5 Úinner€ s
z'check_supported_function.<locals>.innerr4 )rB rA rC r4 r@ r5 Úcheck_supported_functionu s rD c C ó t | dd„ ƒS )zCAttribute for a function only supported in the software stub loaderc S s | j S ©N)ÚIS_STUB©Úor4 r4 r5 Ú<lambda>Œ s z$stub_function_only.<locals>.<lambda>©rD ©rB r4 r4 r5 Ústub_function_onlyŠ s rM c C rE )zMAttribute for a function only supported by stubs or ESP32 and later chips ROMc S s | j p| jdvS )N)ÚESP8266)rG Ú CHIP_NAMErH r4 r4 r5 rJ ’ s z.stub_and_esp32_function_only.<locals>.<lambda>rK rL r4 r4 r5 Ú stub_and_esp32_function_only� ó ÿrP c C rE )zFAttribute for a function only supported by ESP32S3 and later chips ROMc S s
| j dvS )N)rN ÚESP32zESP32-S2)rO rH r4 r4 r5 rJ ™ s
z0esp32s3_or_newer_function_only.<locals>.<lambda>rK rL r4 r4 r5 Ú esp32s3_or_newer_function_only– rQ rS c @ s e Zd Zdd„ ZdS )Ú StubFlasherc C s˜ t |ƒ�
}t |¡}W d ƒ n1 sw Y t |d ¡| _|d | _|d | _zt |d ¡| _|d | _ W d S t
yK d | _d | _ Y d S w )NÚtextÚ
text_startÚentryÚdataÚ
data_start) ÚopenÚjsonÚloadÚbase64Ú b64decoderU rV rW rX rY ÚKeyError)ÚselfÚ json_pathÚ json_fileÚstubr4 r4 r5 Ú__init__� s
ÿ
şzStubFlasher.__init__N)Ú__name__Ú
__module__Ú __qualname__rd r4 r4 r4 r5 rT � s rT c @ s e Zd ZdZdZdZdZdZdZdZ dZ
dZ dZ d Z
d
Zd Zd Zd
ZdZdZdZdZdZdZdZdZdZdZdZ dZ dZ dZ dZ d Z!d Z"d Z#d Z$d Z%d!Z&d"Z'd#Z(d$Z)d%Z*d&Z+dZ,d'Z-dZ.dZ/d(Z0d d)iZ1ee#dfd*d+„Z2e3d,d-„ ƒZ4d.d/„ Z5d0d1„ Z6d2d3„ Z7d4d5„ Z8e9e%fd6d7„ƒZ:d8d9d'd:e;fd;d<„Z<d8d9d'e;fd=d>„Z=d?d@„ Z>dAdB„ Z?dCdD„ Z@d�dFdG„ZAdHdI„ ZBdJdK„ ZCdEeDdd:fdLdM„ZEdNdO„ ZFe;fdPdQ„ZGd�dSdT„ZHdUdV„ ZIdWdX„ ZJdYdZ„ ZKdŸd[d\„ZLd d]d^„ZMe;fd_d`„ZNe;fdadb„ZOd dcdd„ZPd dedf„ZQdgdh„ ZRdidj„ ZSdkdl„ ZTeUdmdn„ ƒZVdodp„ ZWeXdqdr„ ƒZYeXdsdt„ ƒZZd¡dudv„Z[e\dwdx„ ƒZ]e\e;fdydz„ƒZ^e\d d{d|„ƒZ_e\d}d~„ ƒZ`e\dd€„ ƒZaebd�d‚„ ƒZcebdƒd„„ ƒZdd…d†„ Zed¡d‡dˆ„Zfd‰dŠ„ Zgd‹dŒ„ Zh 9 ' 8 ' 'd¢d�d�„Zid�d�„ Zjd£d‘d’„Zkd¤d“d”„Zld•d–„ Zmd—d˜„ Znd™dš„ Zod›dœ„ Zpd8S )¥Ú ESPLoaderaO Base class providing access to ESP ROM & software stub bootloaders.
Subclasses provide ESP8266 & ESP32 Family specific functionality.
Don't instantiate this base class directly, either instantiate a subclass or
call cmds.detect_chip() which will interrogate the chip and return the
appropriate subclass instance.
zEspressif deviceFz /dev/ttyUSB0r r é é é r' r é r% é é
é é é é é é é éĞ éÑ éÒ éÓ éÔ i é i  éé éï é ix `i @iÿÿ i @i 0@r i zESP32-S3(beta 3)c C s¬ d| _ d| _dddddœ| _t|tƒr-zt |¡| _W n tjj y, t
d|› d�ƒ‚w || _t | j| j ƒ| _
| |¡ || _zt| j_W dS tyU d| j_Y dS w )a½ Base constructor for ESPLoader bootloader interaction
Don't call this constructor, either instantiate a specific
ROM class directly, or use cmds.detect_chip().
This base class has all of the instance methods for bootloader
functionality supported across various chips & stub
loaders. Subclasses replace the functions they don't support
with ones which throw NotImplementedInROMError().
FN)Úflash_idÚchip_idÚuart_noÚusb_pidzCould not open z, the port doesn't exist)Úsecure_download_modeÚstub_is_disabledÚcacheÚ
isinstanceÚstrÚserialÚserial_for_urlÚ_portÚ
serialutilÚSerialExceptionr
Ú slip_readerÚtraceÚ _slip_readerÚ_set_port_baudrateÚ_trace_enabledÚ DEFAULT_SERIAL_WRITE_TIMEOUTÚ
write_timeoutÚNotImplementedError)r` ÚportÚbaudÚ
trace_enabledr4 r4 r5 rd s,
ü
ÿ
ızESPLoader.__init__c C s | j jS rF )rŠ r• ©r` r4 r4 r5 Ú serial_portC s zESPLoader.serial_portc C s* z|| j _W d S ty td| ƒ‚w )NzAFailed to set baud rate %d. The driver may not support this rate.)rŠ ÚbaudrateÚIOErrorr
)r` r– r4 r4 r5 r� G s ÿÿÿz ESPLoader._set_port_baudratec C s
t | jƒS )z'Read a SLIP packet from the serial port)Únextr� r˜ r4 r4 r5 ÚreadP s
zESPLoader.readc C sB d| dd¡ dd¡ d }| dt|ƒt|ƒ¡ | j |¡ dS )z=Write bytes to the serial port while performing SLIP escapingó Àó Ûs Ûİs ÛÜzWrite %d bytes: %sN)r. r� ÚlenÚ HexFormatterrŠ Úwrite)r` ÚpacketÚbufr4 r4 r5 r¢ T s ÿşÿzESPLoader.writec G sZ | j r+t ¡ }z|| j }W n ty d}Y nw || _d| }t||| ƒ d S d S )Ng z TRACE +%.3f )r‘ ÚtimeÚ _last_traceÚAttributeErrorÚprint)r` ÚmessageÚ format_argsÚnowÚdeltaÚprefixr4 r4 r5 r� ^ s ÿøzESPLoader.tracec C s | D ]}||N }q|S )z9Calculate checksum of a blob, as it is defined by the ROMr4 )rX ÚstateÚbr4 r4 r5 Úchecksumi s
zESPLoader.checksumNó Tc C st | j j}t|tƒ}||kr|| j _zŸ|dur:| d|t|ƒ|r!dnd|t|ƒ¡ t dd|t|ƒ|¡| }| |¡ |sIW ||krG|| j _dS dS t
dƒD ]V} | ¡ }
t|
ƒdk rZqMt d|
dd… ¡\} } }
}| dkrmqM|
dd… }|du s{| |kr‹||f W ||krŠ|| j _S S t
|dƒdkr£t
|dƒ| jkr£| ¡ t| |ƒ‚qMW ||kr|| j _td ƒ‚||kr¹|| j _w )
z$Send a request and read the responseNzCcommand op=0x%02x data len=%s wait_response=%d timeout=%.3f data=%sr r s <BBHIéd r z<BBHIz Response doesn't match request)rŠ r ÚminÚ MAX_TIMEOUTr� r r¡ ÚstructÚpackr¢ Úranger� Úunpackr
ÚROM_INVALID_RECV_MSGÚ flush_inputr r
)r` ÚoprX ÚchkÚ
wait_responser Ú
saved_timeoutÚ new_timeoutÚpktÚretryÚpÚrespÚop_retÚlen_retÚvalr4 r4 r5 Úcommandq sX
ù
ÿ î
ÿ ù
€ñı
zESPLoader.commandc C sˆ | j ||||d�\}}t|ƒ| jk r td|t|ƒf ƒ‚|| j d… }t|dƒdkr3t d| |¡‚t|ƒ| jkrB|d| j … S |S )z¹
Execute a command with 'command', check the result code and throw an appropriate
FatalError if it fails.
Returns the "result" of a successful command.
©r z/Failed to %s. Only got %d byte status response.Nr z Failed to %s)rÇ r ÚSTATUS_BYTES_LENGTHr
r
Ú
WithResult)r` Úop_descriptionr» rX r¼ r rÆ Ú status_bytesr4 r4 r5 Ú
check_command« s
ÿÿzESPLoader.check_commandc C s | j ¡ t| j | jƒ| _d S rF )rŠ Ú
flushInputr� r� r� r˜ r4 r4 r5 rº Ì s
zESPLoader.flush_inputc C sP | j | jdtd�\}}|dk| _tdƒD ]}| ¡ \}}| j|dkM _qd S )Ns$ UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUrÈ r r' )rÇ ÚESP_SYNCÚ SYNC_TIMEOUTÚsync_stub_detectedr· )r` rÆ Ú_r4 r4 r5 ÚsyncĞ s
ÿ
şzESPLoader.syncc C sà | j d d ur | j d S td u rtdƒ d S | jj}| ¡ d¡s'tdƒ d S | d¡r8tj |¡r8tj
|¡}|g}t j dkrMd|v rM|
| dd¡¡ t ¡ }|D ]}|j|v re|j| j d< |j S qStd |› d
�ƒ d S ) Nr‚ zK
Listing all serial ports is currently not available. Can't get device PID.)Úcomú/dev/zK
Device PID identification is only supported on COM and /dev/ serial ports.rÕ r ÚttyÚcuz"
Failed to get PID of a device on z , using standard reset sequence.)r… Ú
list_portsr¨ rŠ r• ÚlowerÚ
startswithr/ r0 ÚislinkÚrealpathÚsysÚplatformÚappendr. ÚcomportsÚdeviceÚpid)r` Ú active_portÚ active_portsÚportsr r4 r4 r5 Ú_get_pidŞ s6
ÿÿ
ş
ÿzESPLoader._get_pidÚ
default_resetc C s d}d}d}|dkr |S |dkr@| j s| j ¡ |ƒ | j ¡ }| j |¡}t d|tj¡}|dur@d}| d¡} | d¡du}t d ƒD ]7}
z|
¡ | j ¡ | ¡ W dS t
y{ } ztd
d d � tj ¡ t d
¡ | }W Y d} ~ qDd} ~ ww |r�t
d | d¡¡ƒ}|r�t
dƒ}|S )zA single connection attemptNFÚno_reset_no_syncÚno_resets. boot:(0x[0-9a-fA-F]+)(.*waiting for download)?Tr r rj Ú.r, ©Úendçš™™™™™©?zEWrong boot mode detected ({})! The chip needs to be in download mode.úutf-8zdDownload mode successfully detected, but getting no sync reply: The serial TX path seems to be down.)Ú USES_RFC2217rŠ Úreset_input_bufferÚ inWaitingr� ÚreÚsearchÚDOTALLÚgroupr· rº Ú flushOutputrÓ r
r¨ rİ ÚstdoutÚflushr¥ ÚsleepÚformatÚdecode) r` Úreset_strategyÚmodeÚ
last_errorÚboot_log_detectedÚ
download_modeÚwaitingÚ
read_bytesrX Ú boot_moderÒ Úer4 r4 r5 Ú_connect_attempt sV
ÿ
€üÿşÿzESPLoader._connect_attemptc s0 z
‡ fdd„| j D ƒd W S ty Y dS w )zƒ
Returns a tuple of (start, end) for the memory map entry with the given name,
or None if it doesn't exist
c s" g | ]
\}}}|ˆ kr||f‘qS r4 r4 )Ú.0Ústartrì Ún©Únamer4 r5 Ú
<listcomp>A s " z/ESPLoader.get_memory_region.<locals>.<listcomp>r N)Ú
MEMORY_MAPÚ
IndexError)r` r
r4 r r5 Úget_memory_region; s
ÿzESPLoader.get_memory_regionc C sê t d¡}|durt| j|ƒfS t d¡}|dur | }}nt}td }| jr6tj dd¡ ¡ dkr6d }}|d ksA|
¡ | j krGt | jƒfS tj
d
kri| jj
d ¡sit| j|ƒt| j|ƒt| j|ƒt| j|ƒfS t| j|ƒt| j|ƒfS ) zã
Constructs a sequence of reset strategies based on the OS,
used ESP chip, external settings, and environment variables.
Returns a tuple of one or more reset strategies to be tried sequentially.
Úcustom_reset_sequenceNÚ reset_delayg à?ÚESPTOOL_ENV_FPGAr, Ú1r' Ú usb_resetÚntzrfc2217:)ÚcfgÚgetr rŠ Úgetfloatr ÚFPGA_SLOW_BOOTr/ ÚenvironÚstripræ ÚUSB_JTAG_SERIAL_PIDr r
rÚ r r )r` rı Úcfg_custom_reset_sequenceÚcfg_reset_delayÚdelayÚ extra_delayr4 r4 r5 Ú"_construct_reset_strategy_sequenceE s0
ÿş
ü
şz,ESPLoader._construct_reset_strategy_sequencec
C s¢ |r|dv rt d |¡dƒ t ddd� tj ¡ d}| |¡}z)t|dkr*t|ƒnt ¡ t
|¡ƒD ]\}}| ||¡}|du rC nq3W t dƒ nt dƒ w |dur\t d | j
|¡ƒ‚|sÏz=d
d lm} | tj¡}
|
| jvršd} | D ] } |
| jv r| } nqt|r�| du r�t d | j
|
f ƒ n
t d
| j
| j
f ƒ‚W n ty§ d| _Y nw z| ¡ W n tyÈ | jrÅ| ||d ¡ | ¡ n‚ Y nw | ¡ dS dS )z8Try connecting repeatedly until successful, or giving up)ré rè z1WARNING: Pre-connection option "{}" was selected.zJConnection may fail if the chip is not in bootloader or flasher stub mode.z
Connecting...r, rë Nr z‡Failed to connect to {}: {}
For troubleshooting steps visit: https://docs.espressif.com/projects/esptool/en/latest/troubleshooting.htmlr )ÚROM_LISTz~WARNING: This chip doesn't appear to be a %s (chip magic value 0x%08x). Probably it is unsupported by this version of esptool.z.This chip is %s not %s. Wrong --chip argument?T)r¨ rú rİ r÷ rø r Úzipr· Ú itertoolsÚcountÚcycler r
rO r) r! Úread_regrh ÚCHIP_DETECT_MAGIC_REG_ADDRÚCHIP_DETECT_MAGIC_VALUEr rƒ Ú
check_chip_idÚ
_post_connect)
r` rı ÚattemptsÚ detectingÚwarningsrş Úreset_sequencerÒ rü r! Úchip_magic_valueÚactuallyÚclsr4 r4 r5 Úconnecto s€ ş
ş ÿ€ÿı
ş ıÿ
ÿÿ€
ÿ
şü ÜzESPLoader.connectc C ó dS )zœ
Additional initialization hook, may be overridden by the chip-specific class.
Gets called after connect, and after auto-detection.
Nr4 r˜ r4 r4 r5 r* ¼ s zESPLoader._post_connectc C s@ | j | jt d|¡|d�\}}t|dƒdkr t d| |¡‚|S )z Read memory address in targetú<IrÈ r z$Failed to read register address %08x)rÇ Ú ESP_READ_REGrµ r¶ r
r
rÊ )r` Úaddrr rÆ rX r4 r4 r5 r& Ã s
ÿÿzESPLoader.read_regì ÿÿ c C sB t d||||¡}|dkr|t d| jdd|¡7 }| d| j|¡S )z!Write to memory address in targetú<IIIIr zwrite target memory)rµ r¶ ÚUART_DATE_REG_ADDRrÍ Ú
ESP_WRITE_REG)r` r6 ÚvalueÚmaskÚdelay_usÚdelay_after_usrÇ r4 r4 r5 Ú write_regÑ s ÿzESPLoader.write_regc C s< t |ƒ}| |¡}|| M }|||> |@ O }| ||¡ |S )zÌ
Update register at 'addr', replace the bits masked out by 'mask'
with new_val. new_val is shifted left to match the LSB of 'mask'
Returns just-written value of register.
)r r& r? )r` r6 r< Únew_valÚshiftrÆ r4 r4 r5 Ú
update_regÜ s
zESPLoader.update_regc
C s˜ | j r=tt| jƒƒ}|}|| }|j|jt|jƒ f|j|jt|jƒ ffD ]\}} || k r<||kr<t d|| ||f ƒ‚q&|
d| j t
d||||¡¡S )z-Start downloading an application image to RAMzÍSoftware loader is resident at 0x%08x-0x%08x. Can't load binary at overlapping address range 0x%08x-0x%08x. Either change binary loading address, or use the --no-stub option to disable the software loader.zenter RAM download moder8 )rG rT r6 rO rY r rX rV rU r
rÍ Ú
ESP_MEM_BEGINrµ r¶ )
r` ÚsizeÚblocksÚ blocksizeÚoffsetrc Ú
load_startÚload_endr rì r4 r4 r5 Ú mem_beginë s& ş
üÿ€ızESPLoader.mem_beginc C s. | d| jt dt|ƒ|dd¡| | |¡¡S )z Send a block of an image to RAMzwrite to target RAMr8 r )rÍ Ú ESP_MEM_DATArµ r¶ r r° )r` rX Úseqr4 r4 r5 Ú mem_block s üzESPLoader.mem_blockc C sX | j rtnt}t dt|dkƒ|¡}z | jd| j||d�W S ty+ | j r(‚ Y dS w )z+Leave download mode and run the applicationú<IIr zleave RAM download mode)rX r N) rG r8 ÚMEM_END_ROM_TIMEOUTrµ r¶ ÚintrÍ Ú ESP_MEM_ENDr
)r` Ú
entrypointr rX r4 r4 r5 Ú
mem_finish s
ÿ ızESPLoader.mem_finishc C s° || j d | j }| ||¡}t ¡ }| jrt}ntt|ƒ}t d||| j |¡}| j r;| js;|t d|r7dnd¡7 }| j
d| j ||d� |dkrV| jsVt dt ¡ | ƒ |S )zŒ
Start downloading to Flash (performs an erase)
Returns number of blocks (of size self.FLASH_WRITE_SIZE) to write.
r r8 r4 r zenter Flash download moderÈ ú Took %.2fs to erase flash block)
ÚFLASH_WRITE_SIZEÚget_erase_sizer¥ rG r8 r< ÚERASE_REGION_TIMEOUT_PER_MBrµ r¶ ÚSUPPORTS_ENCRYPTED_FLASHrÍ ÚESP_FLASH_BEGINr¨ ) r` rD rG Úbegin_rom_encryptedÚ
num_blocksÚ
erase_sizeÚtr Úparamsr4 r4 r5 Ú flash_begin s& ÿ ÿ
ÿzESPLoader.flash_beginc C ó„ t td ddƒD ]7}z | jd| | jt dt|ƒ|dd¡| | |¡|d� W d S ty? |r<| d|› d�¡ n‚ Y qw d S )
z#Write block to flash, retry if failr éÿÿÿÿz"write to target Flash after seq %dr8 r rÈ z"Block write failed, retrying with ú attempts leftN)
r· ÚWRITE_BLOCK_ATTEMPTSrÍ ÚESP_FLASH_DATArµ r¶ r r° r
r� ©r` rX rL r Ú
attempts_leftr4 r4 r5 Ú flash_block< s* û ÿÿûşözESPLoader.flash_blockc C s� | j r
| js
| |||¡S ttd ddƒD ]7}z | jd| | jt dt |ƒ|dd¡| |
|¡|d� W d S t yL |rI| d|› d�¡ n‚ Y qw d S )
z,Encrypt, write block to flash, retry if failr ra z,Write encrypted to target Flash after seq %dr8 r rÈ z,Encrypted block write failed, retrying with rb N)
rX rG rg r· rc rÍ ÚESP_FLASH_ENCRYPT_DATArµ r¶ r r° r
r� re r4 r4 r5 Úflash_encrypt_blockQ s. û ÿÿûşöz ESPLoader.flash_encrypt_blockc C s& t dt| ƒ¡}| d| j|¡ dS )z Leave flash mode and run/rebootr4 zleave Flash modeN)rµ r¶ rP rÍ Ú
ESP_FLASH_END©r` ÚrebootrÀ r4 r4 r5 Ú flash_finishk s zESPLoader.flash_finishc C s | dd¡ | |¡ dS )z Run application code in flashr N)r_ rm )r` rl r4 r4 r5 Úrunq s z
ESPLoader.runc C s0 | j d du rd}| |dd¡| j d< | j d S )z)Read SPI flash manufacturer and device idr NéŸ r± é )r… Úrun_spiflash_command)r` Ú
SPIFLASH_RDIDr4 r4 r5 r w s
zESPLoader.flash_idc C r3 )zFRead flash type bit field from eFuse. Returns 0, 1, None (not present)Nr4 r˜ r4 r4 r5 Ú
flash_type~ s zESPLoader.flash_typec C st | d| jd¡}t|ƒdkrdnd}t |rdnd|¡}|d |d |d
d … |r+d n|d |r4d d
œS |d d
œS )Núget security infor± é TFz
<IBBBBBBBBz <IBBBBBBBBIIr r r rl r% )ÚflagsÚflash_crypt_cntÚ key_purposesr€ Ú api_version)rÍ ÚESP_GET_SECURITY_INFOr rµ r¸ )r` ÚresÚesp32s2r4 r4 r5 Úget_security_info‚ s
ûûzESPLoader.get_security_infoc C sJ | j d d u r | d| jd¡}t d|d d… ¡}|d | j d< | j d S )Nr€ rt r± z <IBBBBBBBBIrq rl )r… rÍ rz rµ r¸ )r` r{ r4 r4 r5 Ú get_chip_id� s ÿ ÿ
zESPLoader.get_chip_idc C s. | j d du r| | j¡d@ | j d< | j d S )zb
Read the UARTDEV_BUF_NO register to get the number of the currently used console
r� Néÿ )r… r& ÚUARTDEV_BUF_NOr˜ r4 r4 r5 Ú get_uart_noš s
zESPLoader.get_uart_noc
C s8 z| j | W S ty td|d | j ¡ ¡f ƒ‚w )NzGFlash size '%s' is not supported by this chip type. Supported sizes: %sú, )Ú FLASH_SIZESr_ r
r1 Úkeys©r1 Úargr4 r4 r5 Úparse_flash_size_arg¢ s ÿÿÿz ESPLoader.parse_flash_size_argc
C sD |d u rdS z| j | W S ty! td|d | j ¡ ¡f ƒ‚w )Nr zRFlash frequency '%s' is not supported by this chip type. Supported frequencies: %sr‚ )ÚFLASH_FREQUENCYr_ r
r1 r„ r… r4 r4 r5 Úparse_flash_freq_arg¬ s şÿÿz ESPLoader.parse_flash_freq_argc
C s* |d u r t t| jƒƒ}| jrtdƒ | | ¡S tdƒ |j|jfD ]C}|d urd||jkr/|jn|j }t
|ƒ}|| j d | j }| ||| j |¡ t
|ƒD ]}|| j }|| j }| |||… |¡ qMq!tdƒ | |j¡ z| ¡ } W n ty€ tdƒ‚w | dkrŒtd| › �ƒ‚tdƒ | | ¡S ) Nz0Stub is already running. No upload is necessary.zUploading stub...r zRunning stub...zµFailed to start stub. There was no response.
Try increasing timeouts, for more information see: https://docs.espressif.com/projects/esptool/en/latest/esptool/configuration-file.htmls OHAIz+Failed to start stub. Unexpected response: zStub running...)rT r6 rO rÑ r¨ Ú
STUB_CLASSrU rX rV rY r Ú
ESP_RAM_BLOCKrJ r· rM rS rW r� Ú
StopIterationr
)
r` rc ÚfieldÚoffsÚlengthrE rL Ú from_offsÚto_offsr r4 r4 r5 Úrun_stubº s<
€ ÿÿ
zESPLoader.run_stubc
C sÎ || j d | j }|| j d | j }t ¡ }| jr |}t}n
|| j }tt|ƒ}td||f ƒ t d||| j |¡} | j rJ| jsJ| t dd¡7 } | j
d| j | |d� |dkre| jsetdt ¡ | ƒ |S ) z™
Start downloading compressed data to Flash (performs an erase)
Returns number of blocks (size self.FLASH_WRITE_SIZE) to write.
r z Compressed %d bytes to %d...r8 r4 r zenter compressed flash moderÈ rT ) rU r¥ rG r8 r< rW r¨ rµ r¶ rX rÍ ÚESP_FLASH_DEFL_BEGIN)
r` rD ÚcompsizerG r[ Ú erase_blocksr] Ú
write_sizer r^ r4 r4 r5 Úflash_defl_beginŞ s6 ÿÿÿ ÿ üzESPLoader.flash_defl_beginc C r` )
z4Write block to flash, send compressed, retry if failr ra z+write compressed data to flash after seq %dr8 r rÈ z-Compressed block write failed, retrying with rb N)
r· rc rÍ ÚESP_FLASH_DEFL_DATArµ r¶ r r° r
r� re r4 r4 r5 Úflash_defl_block s* û ÿÿûşözESPLoader.flash_defl_blockc C s: |s| j sdS t dt| ƒ¡}| d| j|¡ d| _dS )z*Leave compressed flash mode and run/rebootNr4 zleave compressed flash modeF)rG rµ r¶ rP rÍ ÚESP_FLASH_DEFL_ENDÚ
in_bootloaderrk r4 r4 r5 Úflash_defl_finish s
zESPLoader.flash_defl_finishc
C sf t t|ƒ}| jd| jt d||dd¡|d�}t|ƒdkr!| d¡S t|ƒdkr-t|ƒ ¡ S t
d| ƒ‚) Nzcalculate md5sumr8 r rÈ é rî rq z-MD5Sum command returned unexpected result: %r) r< ÚMD5_TIMEOUT_PER_MBrÍ ÚESP_SPI_FLASH_MD5rµ r¶ r rû r rÙ r
)r` r6 rD r r{ r4 r4 r5 Ú flash_md5sum) s
ü
zESPLoader.flash_md5sumc C s^ t d| ƒ | jr
| jjnd}| | jt d||¡¡ t dƒ | |¡ t
d¡ | ¡ d S )NzChanging baud rate to %dr rN zChanged.rí ) r¨ rG rŠ rš rÇ ÚESP_CHANGE_BAUDRATErµ r¶ r� r¥ rù rº )r` r– Ú
second_argr4 r4 r5 Ú change_baud< s
zESPLoader.change_baudc C s | j d| jtd� d S )Nz erase flashrÈ )rÍ ÚESP_ERASE_FLASHÚCHIP_ERASE_TIMEOUTr˜ r4 r4 r5 Ú erase_flashG s
ÿzESPLoader.erase_flashc C sX || j dkr tdƒ‚|| j dkrtdƒ‚tt|ƒ}| jd| jt d||¡|d� d S )Nr z/Offset to erase from must be a multiple of 4096z0Size of data to erase must be a multiple of 4096z erase regionrN rÈ )ÚFLASH_SECTOR_SIZEr
r< rW rÍ ÚESP_ERASE_REGIONrµ r¶ )r` rG rD r r4 r4 r5 Ú erase_regionN s
üzESPLoader.erase_regionc C s t | | jƒ‚rF )r Úread_flash_slow)r` rG r� Ú progress_fnr4 r4 r5 rª \ s zESPLoader.read_flash_slowc C sX | j s
| |||¡S | d| jt d||| jd¡¡ d}t|ƒ|k rj| ¡ }||7 }t|ƒ|k rBt|ƒ| jk rBt d| jt|ƒf ƒ‚|
t dt|ƒ¡¡ |rdt|ƒd dks]t|ƒ|krd|t|ƒ|ƒ t|ƒ|k s"|rs|t|ƒ|ƒ t|ƒ|kr}t d ƒ‚| ¡ }t|ƒd
kr�t d t |ƒ ƒ‚t |ƒ ¡ }t
|¡ ¡ ¡ }||krªt d ||f ƒ‚|S )
Nz
read flashr8 é@ r± z9Corrupt data, expected 0x%x bytes but received 0x%x bytesr4 r{ r zRead more than expectedrq zExpected digest, got: %sz$Digest mismatch: expected %s, got %s)rG rª rÍ ÚESP_READ_FLASHrµ r¶ r§ r r� r
r¢ r ÚupperÚhashlibÚmd5Ú hexdigest) r` rG r� r« rX rÂ Ú digest_frameÚexpected_digestÚdigestr4 r4 r5 Ú
read_flash_ sF ı ÿÿ ö
ÿzESPLoader.read_flashc C s@ t d|¡}| jsd}|t d|ddd¡7 }| d| j|¡ dS )z¢Send SPI attach command to enable the SPI flash pins
ESP8266 ROM does this when you send flash_begin, ESP32 ROM
has it as a SPI command.
r4 r ÚBBBBzconfigure SPI flash pinsN)rµ r¶ rG rÍ ÚESP_SPI_ATTACH)r` Úhspi_argr† Ú is_legacyr4 r4 r5 Úflash_spi_attach† s
zESPLoader.flash_spi_attachc
C s> d}|}d}d}d}d}| d| jt d||||||¡¡ dS ) a> Tell the ESP bootloader the parameters of the chip
Corresponds to the "flashchip" data structure that the ROM
has in RAM.
'size' is in bytes.
All other flash parameters are currently hardcoded (on ESP8266
these are mostly ignored by ROM code, on ESP32 I'm not sure.)
r i r~ é iÿÿ zset SPI paramsz<IIIIIIN)rÍ ÚESP_SPI_SET_PARAMSrµ r¶ )r` rD Úfl_idÚ
total_sizeÚ
block_sizeÚ sector_sizeÚ page_sizeÚ status_maskr4 r4 r5 Úflash_set_parameters– s& ùız ESPLoader.flash_set_parametersc s d}d}d} d}
d} ˆj ‰ˆd ‰ ˆd } ˆˆj }
ˆˆj ‰ˆˆj }ˆˆj }ˆjdur:‡‡‡‡‡‡fd d
„}n
‡‡‡‡‡fd d
„}d ‰d
}d‰|dkrRtdƒ‚t|ƒdkr\tdƒ‚t|ƒd }ˆ |
¡}ˆ |¡}|}|dkrv||
O }|dkr~|| O }ˆdkr†||O }ˆdkr�|| O }|||ƒ ˆ |
|¡ ˆ |d|> |B ¡ |r¯ˆdkr¯ˆ | |¡ |dkrºˆ |d¡ n#t
|ddƒ}t dt|ƒd |¡}|}|D ] }ˆ ||¡ |d7 }qЈ ˆ ˆ¡ ‡ ‡‡fdd„}|ƒ ˆ |¡}ˆ |
|¡ ˆ ||¡ |S )a¬ Run an arbitrary SPI flash command.
This function uses the "USR_COMMAND" functionality in the ESP
SPI hardware, rather than the precanned commands supported by
hardware. So the value of spiflash_command is an actual command
byte, sent over the wire.
After writing command byte, writes 'data' to MOSI and then
reads back 'read_bits' of reply on MISO. Result is a number.
l i @i i i r ri Nc sŒ ˆˆj }ˆˆj }| dkrˆ || d ¡ |dkr"ˆ ||d ¡ d}ˆdkr.|ˆd O }ˆdkr:|ˆd ˆ> O }|rDˆ ˆ |¡ d S d S )Nr r )ÚSPI_MOSI_DLEN_OFFSÚSPI_MISO_DLEN_OFFSr? )Ú mosi_bitsÚ miso_bitsÚSPI_MOSI_DLEN_REGÚSPI_MISO_DLEN_REGrv )Ú SPI_USR1_REGÚSPI_USR_ADDR_LEN_SHIFTÚaddr_lenÚbaseÚ dummy_lenr` r4 r5 Úset_data_lengthsİ s
ÿz8ESPLoader.run_spiflash_command.<locals>.set_data_lengthsc s€ ˆ }d}d}| dkr dn| d }|dkrdn|d }||> ||> B }ˆdkr,|ˆd O }ˆdkr8|ˆd ˆ> O }ˆ ||¡ d S )Nrr r r r )r? )rÆ rÇ ÚSPI_DATA_LEN_REGÚSPI_MOSI_BITLEN_SÚSPI_MISO_BITLEN_SÚ mosi_maskÚ miso_maskrv )rÊ rË rÌ rÎ r` r4 r5 rÏ î s ÿ i é é r� zHReading more than 32 bits back from a SPI flash operation is unsupportedr¬ zFWriting more than 64 bytes of data with one SPI command is unsupportedr r' ó ÚIc s. t dƒD ]} ˆ ˆ ¡ˆ@ dkr d S qtdƒ‚)Nr% r z$SPI command did not complete in time)r· r& r
)rÒ )Ú SPI_CMD_REGÚ SPI_CMD_USRr` r4 r5 Ú wait_done- s
ÿz1ESPLoader.run_spiflash_command.<locals>.wait_done)
Ú SPI_REG_BASEÚ SPI_USR_OFFSÚ
SPI_USR1_OFFSÚ
SPI_USR2_OFFSÚ SPI_W0_OFFSrÄ r
r r& r? r rµ r¸ )r` Úspiflash_commandrX Ú read_bitsr6 rÌ rÎ ÚSPI_USR_COMMANDÚ SPI_USR_ADDRÚ
SPI_USR_DUMMYÚ SPI_USR_MISOÚ SPI_USR_MOSIÚ SPI_ADDR_REGÚ SPI_USR_REGÚ SPI_USR2_REGÚ
SPI_W0_REGrÏ ÚSPI_USR2_COMMAND_LEN_SHIFTÚ data_bitsÚ old_spi_usrÚ old_spi_usr2rv ÚwordsÚnext_regÚwordrÛ Ústatusr4 )rÙ rÚ rÊ rË rÌ rÍ rÎ r` r5 rq µ sx
ÿ ÿ
ÿ
z ESPLoader.run_spiflash_commandc C s d}| j |||ddd�S )NéZ rp r )râ r6 rÌ rÎ ©rq )r` r6 râ Ú
CMD_RDSFDPr4 r4 r5 Úread_spiflash_sfdp; s
ÿz ESPLoader.read_spiflash_sfdpc C sN d}d}d}d}d}|||gd|… D ]}|| j |dd�|> 7 }|d7 }q|S )zÙRead up to 24 bits (num_bytes) of SPI flash status register contents
via RDSR, RDSR2, RDSR3 commands
Not all SPI flash supports all three commands. The upper 1 or 2
bytes may be 0xFF.
rj é5 é r r )râ rõ )r` Ú num_bytesÚ
SPIFLASH_RDSRÚSPIFLASH_RDSR2ÚSPIFLASH_RDSR3ró rA Úcmdr4 r4 r5 Ú read_statusA s
zESPLoader.read_statusc C sš d}d}d}d}d}d} |r|n|}
|dkr%| |
¡ | |t d|¡¡ |||gd |… D ]} | |
¡ | | t d
|d @ ¡¡ |d L }q.| | ¡ d
S )aì Write up to 24 bits (num_bytes) of new status register
num_bytes can be 1, 2 or 3.
Not all flash supports the additional commands to write the
second and third byte of the status register. When writing 2
bytes, esptool also sends a 16-byte WRSR command (as some
flash types use this instead of WRSR2.)
If the set_non_volatile flag is set, non-volatile bits will
be set as well as volatile ones (WREN used instead of WEVSR).
r é1 rr éP rk ri r z<Hr ÚBr r N)rq rµ r¶ ) r` Ú
new_statusrú Úset_non_volatileÚ
SPIFLASH_WRSRÚSPIFLASH_WRSR2ÚSPIFLASH_WRSR3ÚSPIFLASH_WEVSRÚ
SPIFLASH_WRENÚ
SPIFLASH_WRDIÚ
enable_cmdrş r4 r4 r5 Ú write_statusS s
zESPLoader.write_statusc C s\ | | j¡| j@ }| jj| d | j }|dkrdnd}t|| ƒdkr,td||f ƒ |S )z¦
Figure out the crystal frequency from the UART clock divider
Returns a normalized value in integer MHz (only values 40 or 26 are supported)
r7 é! r" rÖ r zoWARNING: Detected crystal freq %.2fMHz is quite different to normalized freq %dMHz. Unsupported crystal in use?)r& ÚUART_CLKDIV_REGÚUART_CLKDIV_MASKrŠ rš ÚXTAL_CLK_DIVIDERÚabsr¨ )r` Úuart_divÚest_xtalÚ norm_xtalr4 r4 r5 Úget_crystal_freqy s şÿzESPLoader.get_crystal_freqc C s t dƒ t| jƒƒ d S )Nz Hard resetting via RTS pin...)r¨ r rŠ r˜ r4 r4 r5 Ú
hard_reset’ s zESPLoader.hard_resetc C sl | j s|rd S | dd¡ | d¡ d S |r#| dd¡ | d¡ d S | jdkr,tdƒ‚| j| jdd� d S )Nr FTrN z5Soft resetting is currently only supported on ESP8266)r½ )rG r_ rm rO r
rÇ ÚESP_RUN_USER_CODE)r` Ústay_in_bootloaderr4 r4 r5 Ú
soft_reset– s
ÿzESPLoader.soft_resetc C sX z!| ¡ }|| jkr td || j |d¡| j¡ƒ d| _W d S W d S ty+ Y d S w )Nz[WARNING: Chip ID {} ({}) doesn't match expected Chip ID {}. esptool may not work correctly.ÚUnknownT)r~ Ú
IMAGE_CHIP_IDr¨ rú ÚUNSUPPORTED_CHIPSr r„ r )r` r€ r4 r4 r5 r) s
ış ö ÿzESPLoader.check_chip_id)rç )r7 r r )r )FrF )r± r Nr r )r )r F)qre rf rg Ú__doc__rO rG r Ú DEFAULT_PORTrï rY rd rj rC rQ rK rÏ r: r5 r¼ r· ÚESP_READ_FLASH_SLOWr¡ r“ r˜ rš rŸ rz r¤ r¨ r r rh r¹ r‹ rU Ú ESP_ROM_BAUDÚESP_IMAGE_MAGICÚESP_CHECKSUM_MAGICr§ r9 r' r ÚIROM_MAP_STARTÚ IROM_MAP_ENDrÉ ÚBOOTLOADER_FLASH_OFFSETrX rÑ r r rd Úpropertyr™ r� r� r¢ r� Ú staticmethodr° r8 rÇ rÍ rº rÓ ræ r r r ÚDEFAULT_CONNECT_ATTEMPTSr2 r* r& r? rB rJ rM rS r_ rg ri rm rn r rs r} rS r~ r� Ú classmethodr‡ r‰ r’ rP r— r™ rœ r r£ rM r¦ r© rª rµ rº rà rq r÷ rÿ r r r r r) r4 r4 r4 r5 rh ® s /
ú;
ÿ!
&7
,
ûM
$
)
'"
ù
& rh c c s¦ � dd„ }d}d}d} | ¡ }| |dkrdn|¡}|dkr9|du r*|r'd nd
}nd t|ƒ¡}||ƒ t|ƒ‚|d t|ƒt|ƒƒ |D ]Œ} t| gƒ} |du rz| d
krWd}qE|dt|ƒƒ | | ¡ ¡}
|dt|
ƒƒ |||
ƒ tdt| ƒ ƒ‚|r³d}| dkr‡|d
7 }qE| dkr�|d7 }qE|dt|ƒƒ | | ¡ ¡}
|dt|
ƒƒ |||
ƒ tdt| ƒ ƒ‚| dkrºd}qE| d
krÍ|dt|ƒƒ |V d}d}qE|| 7 }qEq )zğGenerator to read SLIP packets from a serial port.
Yields one full SLIP packet at a time, raises exception on timeout or invalid data.
Designed to avoid too many calls to serial.read(1), which can bog
down on slow systems.
c S s~ d}d}t d d|d|dg¡| t j¡}|dur=dd „ | d
¡| d ¡fD ƒ}t|ƒr2d |d
› �nd}d|› �}t|ƒ‚dS )a
Checks the input bytes for panic handler messages.
Raises a FatalError if Guru Meditation or Fatal Exception is found, as both
of these are used between different ROM versions.
Tries to also parse the error cause (e.g. IllegalInstruction).
s> G?uru Meditation Error: (?:Core \d panic'ed \(([a-zA-Z ]*)\))?s1 F?atal exception \(\d+\): (?:([a-zA-Z ]*)?.*epc)?r± s (?:ó |ó )Nc S s$ g | ]}|d urd | d¡¡‘qS )Nz({})rî )rú rû )r Úir4 r4 r5 r Û s ıÿz=slip_reader.<locals>.detect_panic_handler.<locals>.<listcomp>r r ú r r, z Guru Meditation Error detected)rò ró r1 rô rõ r r
)ÚinputÚguru_meditationÚfatal_exceptionrX ÚcauseÚmsgr4 r4 r5 Údetect_panic_handlerÇ s ÿış
øz)slip_reader.<locals>.detect_panic_handlerNFTr r r± z@Serial data stream stopped: Possible serial noise or corruption.zNo serial data received.z3Packet content transfer stopped (received {} bytes)zRead %d bytes: %sr� zRead invalid data: %sz#Remaining data in serial buffer: %szCInvalid head of packet (0x%s): Possible serial noise or corruption.ó Üó İrŸ z Invalid SLIP escape (0xdb, 0x%s)zReceived full packet: %s)rñ r� rú r r
r¡ Úbytesr ) r• Útrace_functionr3 Úpartial_packetÚ in_escapeÚsuccessful_slipr r r2 r¯ Úremaining_datar4 r4 r5 r� ¿ sx € ÿıÿ
ş ÿÿ
ş
Çr� c @ s" e Zd ZdZddd„Zdd„ ZdS ) r¡ aJ
Wrapper class which takes binary data in its constructor
and returns a hex string as it's __str__ method.
This is intended for "lazy formatting" of trace() output
in hex format. Avoids overhead (significant on slow computers)
of generating long hex strings even if tracing is disabled.
Note that this doesn't save any overhead if passed as an
argument to "%", only when passed to trace()
If auto_split is set (default), any long line (> 16 bytes) will be
printed as separately indented lines, with ASCII decoding at the end
of each line.
Tc C s || _ || _d S rF )Ú_sÚ _auto_split)r` Ú
binary_stringÚ
auto_splitr4 r4 r5 rd 4 s
zHexFormatter.__init__c C s¨ | j rNt| jƒdkrNd}| j}t|ƒdkrL|d d… }d dd„ | dd¡D ƒ¡}|dd … }|dt|d d … d
ƒt|d d … d
ƒ|f 7 }t|ƒdks|S t| jd
ƒS ) Nrq r, r c s s4 � | ]}|d ks|t jv r|t jvr|ndV qdS )r- rê N)ÚstringÚ printableÚ
whitespace)r Úcr4 r4 r5 Ú <genexpr>> s € üşıı
úz'HexFormatter.__str__.<locals>.<genexpr>Úasciir. z
%-16s %-16s | %sr F)r= r r< r1 rû r )r` r; ÚsÚlineÚ
ascii_liner4 r4 r5 Ú__str__8 s"
ù ı ô zHexFormatter.__str__N)T)re rf rg r rd rI r4 r4 r4 r5 r¡ # s
r¡ )Gr] r¯ r# r[ r/ rò r@ rµ rİ r¥ Úconfigr Úresetr r r r r r Úutilr
r r r
r r r r rˆ Ú ImportErrorr¨ Ú
executabler Ú TypeErrorÚserial.tools.list_portsÚtoolsrØ ÚVERSIONÚ ExceptionrŞ r rÒ r r8 r¥ r´ rĞ r� rW ÚERASE_WRITE_TIMEOUT_PER_MBrO r’ Úgetintr( rc r0 r1 ÚdirnameÚ__file__r2 r6 r< rD rM rP rS rT Úobjectrh r� r¡ r4 r4 r4 r5 Ú<module> s¤ ÿÿû ÿ€ ÿ
şÿ
şü
d | 40,782 | Python | .pyt | 379 | 104.728232 | 978 | 0.510106 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,698 | reset.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/__pycache__/reset.cpython-310.pyc | o
’jÂdo ã @ sÖ d dl Z d dlZd dlZddlmZ e jdkr7d dlZd dlZeeddƒZ eeddƒZ
eed d
ƒZ eed d ƒZ d
Z
G dd„ deƒZG dd„ deƒZG dd„ deƒZG dd„ deƒZG dd„ deƒZG dd„ deƒZdS )é Né )Ú
FatalErrorÚntÚTIOCMSETiT ÚTIOCMGETiT Ú TIOCM_DTRé Ú TIOCM_RTSé gš™™™™™©?c @ s: e Zd Zefdd„Zdd„ Zdd„ Zdd„ Zd
d
d „Zd S )Ú
ResetStrategyc C s || _ || _d S ©N)ÚportÚ reset_delay)Úselfr
r © r ú-/home/ceco/Downloads/esptool/esptool/reset.pyÚ__init__ s
zResetStrategy.__init__c C s d S r r r r r r Ú__call__! s zResetStrategy.__call__c C s | j |¡ d S r )r
ÚsetDTR©r Ústater r r Ú_setDTR$ s zResetStrategy._setDTRc C s | j |¡ | j | j j¡ d S r )r
ÚsetRTSr Údtrr r r r Ú_setRTS' s zResetStrategy._setRTSFc C sx t dt | j ¡ tt dd¡¡¡d }|r|tO }n|t M }|r'|t O }n|t M }t | j ¡ t
t d|¡¡ d S )NÚIr ) ÚstructÚunpackÚfcntlÚioctlr
Úfilenor Úpackr r r )r r ÚrtsÚstatusr r r Ú
_setDTRandRTS. s ÿş
zResetStrategy._setDTRandRTSN)FF) Ú__name__Ú
__module__Ú __qualname__ÚDEFAULT_RESET_DELAYr r r r r$ r r r r r s r c @ ó e Zd ZdZdd„ ZdS )Ú ClassicResetzF
Classic reset sequence, sets DTR and RTS lines sequentially.
c C sL | d¡ | d¡ t d¡ | d¡ | d¡ t | j¡ | d¡ d S ©NFTçš™™™™™¹?)r r ÚtimeÚsleepr ©r r r r r B s
zClassicReset.__call__N©r% r& r' Ú__doc__r r r r r r* = s r* c @ r) )ÚUnixTightResetz{
UNIX-only reset sequence with custom implementation,
which allows setting DTR and RTS lines at the same time.
c C s` | dd¡ | dd¡ | dd¡ t d¡ | dd¡ t | j¡ | dd¡ | d¡ d S r+ )r$ r- r. r r r/ r r r r R s
zUnixTightReset.__call__Nr0 r r r r r2 L ó r2 c @ r) )ÚUSBJTAGSerialResetzx
Custom reset sequence, which is required when the device
is connecting via its USB-JTAG-Serial peripheral.
c C s| | d¡ | d¡ t d¡ | d¡ | d¡ t d¡ | d¡ | d¡ | d¡ t d¡ | d¡ | d¡ d S )NFr, T)r r r- r. r/ r r r r c s
zUSBJTAGSerialReset.__call__Nr0 r r r r r4 ] r3 r4 c s* e Zd ZdZd‡ fdd„ Zdd„ Z‡ ZS )Ú HardResetz�
Reset sequence for hard resetting the chip.
Can be used to reset out of the bootloader or to restart a running app.
Fc s t ƒ |¡ || _d S r )Úsuperr Ú uses_usb_otg)r r
r7 ©Ú __class__r r r x s
zHardReset.__init__c C sJ | d¡ | jrt d¡ | d¡ t d¡ d S t d¡ | d¡ d S )NTgš™™™™™É?Fr, )r r7 r- r. r/ r r r r | s
zHardReset.__call__)F)r% r& r' r1 r r Ú
__classcell__r r r8 r r5 r s r5 c s> e Zd ZdZdddddœZdd„ Z‡ fd d
„Zd d „ Z‡ ZS )
Ú CustomReseta¥
Custom reset strategy defined with a string.
CustomReset object is created as "rst = CustomReset(port, seq_str)"
and can be later executed simply with "rst()"
The seq_str input string consists of individual commands divided by "|".
Commands (e.g. R0) are defined by a code (R) and an argument (0).
The commands are:
D: setDTR - 1=True / 0=False
R: setRTS - 1=True / 0=False
U: setDTRandRTS (Unix-only) - 0,0 / 0,1 / 1,0 / or 1,1
W: Wait (time delay) - positive float number
e.g.
"D0|R1|W0.1|D1|R0|W0.05|D0" represents the ClassicReset strategy
"U1,1|U0,1|W0.1|U1,0|W0.05|U0,0" represents the UnixTightReset strategy
zself.port.setDTR({})zself.port.setRTS({})ztime.sleep({})zself._setDTRandRTS({}))ÚDÚRÚWÚUc C s t | jƒ d S r )ÚexecÚconstructed_strategyr/ r r r r ¥ s zCustomReset.__call__c s t ƒ |¡ | |¡| _d S r )r6 r Ú_parse_string_to_seqrA )r r
Úseq_strr8 r r r ¨ s zCustomReset.__init__c
sR z| d¡}‡ fdd„|D ƒ}W n ty# } ztd|› �ƒ‚d }~ww d |¡S )Nú|c s( g | ]}ˆ j |d |dd… ¡‘qS )r r N)Ú format_dictÚformat)Ú.0Úcmdr/ r r Ú
<listcomp>¯ s ( z4CustomReset._parse_string_to_seq.<locals>.<listcomp>z/Invalid "custom_reset_sequence" option format: Ú
)ÚsplitÚ Exceptionr Újoin)r rC ÚcmdsÚ
fn_calls_listÚer r/ r rB ¬ s
€ÿ
z CustomReset._parse_string_to_seq) r% r& r' r1 rE r r rB r: r r r8 r r; ‰ s ü r; )Úosr r- Úutilr Únamer ÚtermiosÚgetattrr r r r r( Úobjectr r* r2 r4 r5 r; r r r r Ú<module> s$
! | 5,658 | Python | .pyt | 67 | 81.880597 | 561 | 0.427881 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,699 | esp32c6.cpython-310.pyc | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/targets/__pycache__/esp32c6.cpython-310.pyc | o
’jÂdP ã @ sN d dl Z ddlmZ ddlmZmZ G dd„ deƒZG dd „ d eƒZee_dS )
é Né )Ú
ESP32C3ROMé )Ú
FatalErrorÚNotImplementedInROMErrorc @ sÊ e Zd ZdZdZdZdZdZdZdZ dZ
dgZ d Z d
Z
d Zd Zd
ZdZdZdZdZed Zed Zed Zed Zd
Zed Zd Zed Z dZ ed Z dZ ed Z dZ!ed Z"dZ#eZ$dZ%ed Z&dZ'ed Z(dZ)dZ*dZ+d Z,d Z-d Z.d Z/e/d Z0e/d
Z1e/d Z2d Z3e/d Z4d!Z5ddd"d#œZ6g d$¢g d%¢g d&¢g d'¢g d(¢g d)¢g d*¢g d+¢g d,¢g d-¢g d.¢g Z7d/d0„ Z8d1d2„ Z9d3d4„ Z:d5d6„ Z;d7d8„ Z<d9d:„ Z=d;d<„ Z>dId>d?„Z?d@dA„ Z@dBdC„ ZAdDdE„ ZBdFdG„ ZCdHS )JÚ
ESP32C6ROMzESP32-C6é
Fé Bé €Bé Cr io€à,i 0 `é é é é$ é( éX i| `i `éD é0 é4 é8 é é é i i Té i€õ‡@é i `i i¡:ØPr )Ú80mÚ40mÚ20m)r i ÚPADDING)r
r ÚDROM)é €@é ˆ@ÚDRAM)r r! ÚBYTE_ACCESSIBLE)é ¬@i @Ú DROM_MASK)i @r$ Ú IROM_MASK)r r
ÚIROM)r r! ÚIRAM)é Pé @ PÚRTC_IRAM)r) r* ÚRTC_DRAM)i à`i `Ú
MEM_INTERNAL2c C ó d}| | jd| ¡d? d@ S )Nr r r é ©Úread_regÚEFUSE_BLOCK1_ADDR©ÚselfÚnum_word© r6 ú7/home/ceco/Downloads/esptool/esptool/targets/esp32c6.pyÚget_pkg_versionh ó zESP32C6ROM.get_pkg_versionc C r. )Nr r é é r0 r3 r6 r6 r7 Úget_minor_chip_versionl r9 z!ESP32C6ROM.get_minor_chip_versionc C s d}| | jd| ¡d? d@ S )Nr r é r0 r3 r6 r6 r7 Úget_major_chip_versionp r9 z!ESP32C6ROM.get_major_chip_versionc C s< dddœ | ¡ d¡}| ¡ }| ¡ }|› d|› d|› d�S )NzESP32-C6 (QFN40)zESP32-C6FH4 (QFN32))r r zunknown ESP32-C6z (revision vÚ.ú))Úgetr8 r> r< )r4 Ú chip_nameÚ major_revÚ minor_revr6 r6 r7 Úget_chip_descriptiont s ş ız ESP32C6ROM.get_chip_descriptionc C s g d¢S )N)zWiFi 6zBT 5z IEEE802.15.4r6 ©r4 r6 r6 r7 Úget_chip_features} s z ESP32C6ROM.get_chip_featuresc C s dS )Nr r6 rF r6 r6 r7 Úget_crystal_freq€ s zESP32C6ROM.get_crystal_freqc C s t dƒ‚)Nz1VDD_SDIO overrides are not supported for ESP32-C6)r )r4 Ú new_voltager6 r6 r7 Úoverride_vddsdio„ s ÿzESP32C6ROM.override_vddsdioÚBASE_MACc C s† | | j¡}| | jd ¡}t d||¡dd… }t d|d? d@ ¡}|dd … | |d d
… }t|ƒt|ƒt|ƒd œ}| |d¡S ) zRead MAC from EFUSE regionr z>IIr Nz>Hr iÿÿ r r é )rK ÚEUI64ÚMAC_EXT)r1 Ú
MAC_EFUSE_REGÚstructÚpackÚtuplerA )r4 Úmac_typeÚmac0Úmac1Úbase_macÚext_macÚeui64Úmacsr6 r6 r7 Úread_mac‰ s ı zESP32C6ROM.read_macc C s d S ©Nr6 rF r6 r6 r7 Úget_flash_crypt_configš s z!ESP32C6ROM.get_flash_crypt_configc C s | | j¡| j@ S r[ )r1 ÚEFUSE_SECURE_BOOT_EN_REGÚEFUSE_SECURE_BOOT_EN_MASKrF r6 r6 r7 Úget_secure_boot_enabled� s
ÿÿz"ESP32C6ROM.get_secure_boot_enabledc C sr |dk s|dkr t dƒ‚| j| jf| j| jf| j| jf| j| jf| j | j
f| j | j fg| \}}|
|¡|? d@ S )Nr é z,Valid key block numbers must be in range 0-5r; )r ÚEFUSE_PURPOSE_KEY0_REGÚEFUSE_PURPOSE_KEY0_SHIFTÚEFUSE_PURPOSE_KEY1_REGÚEFUSE_PURPOSE_KEY1_SHIFTÚEFUSE_PURPOSE_KEY2_REGÚEFUSE_PURPOSE_KEY2_SHIFTÚEFUSE_PURPOSE_KEY3_REGÚEFUSE_PURPOSE_KEY3_SHIFTÚEFUSE_PURPOSE_KEY4_REGÚEFUSE_PURPOSE_KEY4_SHIFTÚEFUSE_PURPOSE_KEY5_REGÚEFUSE_PURPOSE_KEY5_SHIFTr1 )r4 Ú key_blockÚregÚshiftr6 r6 r7 Úget_key_block_purpose£ s
úùz ESP32C6ROM.get_key_block_purposec s, ‡ fdd„t dƒD ƒ}t‡ fdd„|D ƒƒS )Nc s g | ]}ˆ |¡‘qS r6 )rp )Ú.0ÚbrF r6 r7 Ú
<listcomp>³ s z<ESP32C6ROM.is_flash_encryption_key_valid.<locals>.<listcomp>rL c 3 s � | ]}|ˆ j kV qd S r[ )ÚPURPOSE_VAL_XTS_AES128_KEY)rq ÚprF r6 r7 Ú <genexpr>µ s € z;ESP32C6ROM.is_flash_encryption_key_valid.<locals>.<genexpr>)ÚrangeÚany)r4 Úpurposesr6 rF r7 Ú is_flash_encryption_key_valid± s z(ESP32C6ROM.is_flash_encryption_key_validN)rK )DÚ__name__Ú
__module__Ú __qualname__Ú CHIP_NAMEÚ
IMAGE_CHIP_IDÚFPGA_SLOW_BOOTÚIROM_MAP_STARTÚ IROM_MAP_ENDÚDROM_MAP_STARTÚ DROM_MAP_ENDÚBOOTLOADER_FLASH_OFFSETÚCHIP_DETECT_MAGIC_VALUEÚ SPI_REG_BASEÚ SPI_USR_OFFSÚ
SPI_USR1_OFFSÚ
SPI_USR2_OFFSÚSPI_MOSI_DLEN_OFFSÚSPI_MISO_DLEN_OFFSÚ SPI_W0_OFFSÚUART_DATE_REG_ADDRÚ
EFUSE_BASEr2 rO ÚEFUSE_RD_REG_BASEra rb rc rd re rf rg rh ri rj rk rl Ú%EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPT_REGÚ!EFUSE_DIS_DOWNLOAD_MANUAL_ENCRYPTÚ EFUSE_SPI_BOOT_CRYPT_CNT_REGÚ EFUSE_SPI_BOOT_CRYPT_CNT_MASKr] r^ rt ÚSUPPORTS_ENCRYPTED_FLASHÚFLASH_ENCRYPTED_WRITE_ALIGNÚUARTDEV_BUF_NOÚ UARTDEV_BUF_NO_USB_JTAG_SERIALÚDR_REG_LP_WDT_BASEÚRTC_CNTL_WDTCONFIG0_REGÚRTC_CNTL_WDTWPROTECT_REGÚRTC_CNTL_SWD_CONF_REGÚRTC_CNTL_SWD_AUTO_FEED_ENÚRTC_CNTL_SWD_WPROTECT_REGÚRTC_CNTL_SWD_WKEYÚFLASH_FREQUENCYÚ
MEMORY_MAPr8 r< r> rE rG rH rJ rZ r\ r_ rp rz r6 r6 r6 r7 r s ıõ
r c @ s$ e Zd ZdZdZdZdZdd„ ZdS )ÚESP32C6StubLoaderzAccess class for ESP32C6 stub loader, runs on top of ROM.
(Basically the same as ESP32StubLoader, but different base class.
Can possibly be made into a mixin.)
i @ r Tc C s, |j | _ |j| _|j| _|j| _| ¡ d S r[ )Úsecure_download_modeÚ_portÚ_trace_enabledÚcacheÚ flush_input)r4 Ú
rom_loaderr6 r6 r7 Ú__init__Ã s
zESP32C6StubLoader.__init__N)r{ r| r} Ú__doc__ÚFLASH_WRITE_SIZEÚSTATUS_BYTES_LENGTHÚIS_STUBr© r6 r6 r6 r7 r¢ ¸ s r¢ ) rP Úesp32c3r Úutilr r r r¢ Ú
STUB_CLASSr6 r6 r6 r7 Ú<module> s -
| 6,447 | Python | .pyt | 33 | 193.939394 | 1,620 | 0.529467 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
Subsets and Splits