Lines Matching refs:self
118 def __init__(self, addr, data, file_offs=None, flags=0, align=4): argument
119 self.addr = addr
120 self.data = data
121 self.file_offs = file_offs
122 self.flags = flags
123 self.align = align
124 self.include_in_checksum = True
125 if self.addr != 0:
126 self.pad_to_alignment(
130 def copy_with_new_addr(self, new_addr): argument
133 return ImageSegment(new_addr, self.data, 0)
135 def split_image(self, split_len): argument
139 result = copy.copy(self)
140 result.data = self.data[:split_len]
141 self.data = self.data[split_len:]
142 self.addr += split_len
143 self.file_offs = None
147 def __repr__(self): argument
148 r = "len 0x%05x load 0x%08x" % (len(self.data), self.addr)
149 if self.file_offs is not None:
150 r += " file_offs 0x%08x" % (self.file_offs)
153 def get_memory_type(self, image): argument
161 if map_range[0] <= self.addr < map_range[1]
164 def pad_to_alignment(self, alignment): argument
165 self.data = pad_to(self.data, alignment, b"\x00")
167 def addr_align(self, alignment): argument
168 end_addr = self.addr + len(self.data)
174 def pad_to_addr(self, addr): argument
175 pad = addr - (self.addr + len(self.data))
177 self.data += b"\x00" * pad
184 def __init__(self, name, addr, data, flags, align=4): argument
185 super(ELFSection, self).__init__(addr, data, flags=flags, align=align)
186 self.name = name.decode("utf-8")
188 def __repr__(self): argument
189 return "%s %s" % (self.name, super(ELFSection, self).__repr__())
201 def __init__(self): argument
202 self.segments = []
203 self.entrypoint = 0
204 self.elf_sha256 = None
205 self.elf_sha256_offset = 0
206 self.pad_to_size = 0
208 def load_common_header(self, load_file, expected_magic): argument
212 self.flash_mode,
213 self.flash_size_freq,
214 self.entrypoint,
221 def verify(self): argument
222 if len(self.segments) > 16:
225 "Usually this indicates a linker script problem." % len(self.segments)
228 def load_segment(self, f, is_irom_segment=False): argument
232 self.warn_if_unusual_segment(offset, size, is_irom_segment)
240 self.segments.append(segment)
243 def warn_if_unusual_segment(self, offset, size, is_irom_segment): argument
248 def maybe_patch_segment_data(self, f, segment_data): argument
256 self.elf_sha256_offset >= file_pos
257 and self.elf_sha256_offset < file_pos + segment_len
261 patch_offset = self.elf_sha256_offset - file_pos
264 patch_offset < self.SEG_HEADER_LEN
265 or patch_offset + self.SHA256_DIGEST_LEN > segment_len
270 % (self.elf_sha256_offset, file_pos, segment_len)
273 patch_offset -= self.SEG_HEADER_LEN
275 segment_data[patch_offset : patch_offset + self.SHA256_DIGEST_LEN]
276 != b"\x00" * self.SHA256_DIGEST_LEN
280 " Refusing to overwrite." % self.elf_sha256_offset
282 assert len(self.elf_sha256) == self.SHA256_DIGEST_LEN
285 + self.elf_sha256
286 + segment_data[patch_offset + self.SHA256_DIGEST_LEN :]
290 def save_segment(self, f, segment, checksum=None): argument
295 segment_data = self.maybe_patch_segment_data(f, segment.data)
301 def save_flash_segment(self, f, segment, checksum=None): argument
305 if self.ROM_LOADER.CHIP_NAME == "ESP32":
309 segment_end_pos = f.tell() + len(segment.data) + self.SEG_HEADER_LEN
310 segment_len_remainder = segment_end_pos % self.IROM_ALIGN
313 return self.save_segment(f, segment, checksum)
315 def read_checksum(self, f): argument
322 def calculate_checksum(self): argument
328 for seg in self.segments:
333 def append_checksum(self, f, checksum): argument
338 def write_common_header(self, f, segments): argument
344 self.flash_mode,
345 self.flash_size_freq,
346 self.entrypoint,
350 def is_irom_addr(self, addr): argument
357 def get_irom_segment(self): argument
358 irom_segments = [s for s in self.segments if self.is_irom_addr(s.addr)]
368 def get_non_irom_segments(self): argument
369 irom_segment = self.get_irom_segment()
370 return [s for s in self.segments if s != irom_segment]
372 def sort_segments(self): argument
373 if not self.segments:
375 self.segments = sorted(self.segments, key=lambda s: s.addr)
377 def merge_adjacent_segments(self): argument
378 if not self.segments:
383 for i in range(len(self.segments) - 1, 0, -1):
386 elem = self.segments[i - 1]
387 next_elem = self.segments[i]
394 if self.ROM_LOADER != ESP8266ROM and self.ram_only_header:
410 elem.get_memory_type(self) == next_elem.get_memory_type(self),
413 next_elem.flags & self.ELF_FLAG_EXEC
414 == elem.flags & self.ELF_FLAG_EXEC,
432 segments.insert(0, self.segments[0])
438 self.segments = segments
440 def set_mmu_page_size(self, size): argument
447 "Defaulting to 64KB.".format(self.ROM_LOADER.CHIP_NAME)
456 def __init__(self, load_file=None): argument
457 super(ESP8266ROMFirmwareImage, self).__init__()
458 self.flash_mode = 0
459 self.flash_size_freq = 0
460 self.version = 1
463 segments = self.load_common_header(load_file, ESPLoader.ESP_IMAGE_MAGIC)
466 self.load_segment(load_file)
467 self.checksum = self.read_checksum(load_file)
469 self.verify()
471 def default_output_name(self, input_file): argument
475 def save(self, basename): argument
478 irom_segment = self.get_irom_segment()
488 normal_segments = self.get_non_irom_segments()
490 self.write_common_header(f, normal_segments)
493 checksum = self.save_segment(f, segment, checksum)
494 self.append_checksum(f, checksum)
513 def __init__(self, load_file=None): argument
514 super(ESP8266V2FirmwareImage, self).__init__()
515 self.version = 2
517 segments = self.load_common_header(load_file, self.IMAGE_V2_MAGIC)
518 if segments != self.IMAGE_V2_SEGMENT:
530 irom_segment = self.load_segment(load_file, True)
535 first_flash_mode = self.flash_mode
536 first_flash_size_freq = self.flash_size_freq
537 first_entrypoint = self.entrypoint
540 segments = self.load_common_header(load_file, ESPLoader.ESP_IMAGE_MAGIC)
542 if first_flash_mode != self.flash_mode:
546 % (first_flash_mode, self.flash_mode)
548 if first_flash_size_freq != self.flash_size_freq:
552 % (first_flash_size_freq, self.flash_size_freq)
554 if first_entrypoint != self.entrypoint:
558 % (first_entrypoint, self.entrypoint)
563 self.load_segment(load_file)
564 self.checksum = self.read_checksum(load_file)
566 self.verify()
568 def default_output_name(self, input_file): argument
570 irom_segment = self.get_irom_segment()
580 def save(self, filename): argument
586 self.IMAGE_V2_MAGIC,
587 self.IMAGE_V2_SEGMENT,
588 self.flash_mode,
589 self.flash_size_freq,
590 self.entrypoint,
594 irom_segment = self.get_irom_segment()
601 self.save_segment(f, irom_segment)
604 normal_segments = self.get_non_irom_segments()
605 self.write_common_header(f, normal_segments)
608 checksum = self.save_segment(f, segment, checksum)
609 self.append_checksum(f, checksum)
649 def __init__(self, load_file=None, append_digest=True, ram_only_header=False): argument
650 super(ESP32FirmwareImage, self).__init__()
651 self.secure_pad = None
652 self.flash_mode = 0
653 self.flash_size_freq = 0
654 self.version = 1
655 self.wp_pin = self.WP_PIN_DISABLED
657 self.clk_drv = 0
658 self.q_drv = 0
659 self.d_drv = 0
660 self.cs_drv = 0
661 self.hd_drv = 0
662 self.wp_drv = 0
663 self.chip_id = 0
664 self.min_rev = 0
665 self.min_rev_full = 0
666 self.max_rev_full = 0
667 self.ram_only_header = ram_only_header
669 self.append_digest = append_digest
670 self.data_length = None
675 segments = self.load_common_header(load_file, ESPLoader.ESP_IMAGE_MAGIC)
676 self.load_extended_header(load_file)
679 self.load_segment(load_file)
680 self.checksum = self.read_checksum(load_file)
682 if self.append_digest:
684 self.stored_digest = load_file.read(32)
688 self.calc_digest = calc_digest.digest() # TODO: decide what to do here?
689 self.data_length = end - start
691 self.verify()
693 def is_flash_addr(self, addr): argument
695 self.ROM_LOADER.IROM_MAP_START <= addr < self.ROM_LOADER.IROM_MAP_END
696 ) or (self.ROM_LOADER.DROM_MAP_START <= addr < self.ROM_LOADER.DROM_MAP_END)
698 def default_output_name(self, input_file): argument
702 def warn_if_unusual_segment(self, offset, size, is_irom_segment): argument
705 def save(self, filename): argument
708 self.write_common_header(f, self.segments)
712 self.save_extended_header(f)
720 for s in sorted(self.segments, key=lambda s: s.addr)
721 if self.is_flash_addr(s.addr)
725 for s in sorted(self.segments, key=lambda s: s.addr)
726 if not self.is_flash_addr(s.addr)
756 if segment.addr // self.IROM_ALIGN == last_addr // self.IROM_ALIGN:
773 align_past = (segment.addr % self.IROM_ALIGN) - self.SEG_HEADER_LEN
774 pad_len = (self.IROM_ALIGN - (f.tell() % self.IROM_ALIGN)) + align_past
775 if pad_len == 0 or pad_len == self.IROM_ALIGN:
780 pad_len -= self.SEG_HEADER_LEN
782 pad_len += self.IROM_ALIGN
785 if self.ram_only_header:
790 checksum = self.save_segment(f, segment, checksum)
792 self.append_checksum(f, checksum)
801 if pad_len < self.ROM_LOADER.BOOTLOADER_FLASH_OFFSET:
804 pad_len += self.IROM_ALIGN
806 pad_len -= self.ROM_LOADER.BOOTLOADER_FLASH_OFFSET
808 self.save_segment(f, pad_segment)
811 assert (f.tell() + 8 + self.ROM_LOADER.BOOTLOADER_FLASH_OFFSET) % (
812 self.IROM_ALIGN
813 ) == segment.addr % self.IROM_ALIGN
817 self.save_flash_segment(f, segment)
826 if len(ram_segments) > 0 and pad_len > self.SEG_HEADER_LEN:
832 checksum = self.save_segment(f, pad_segment, checksum)
838 ) % self.IROM_ALIGN == segment.addr % self.IROM_ALIGN
839 checksum = self.save_flash_segment(f, segment, checksum)
845 checksum = self.save_segment(f, segment, checksum)
848 if self.secure_pad:
851 if not self.append_digest:
856 align_past = (f.tell() + self.SEG_HEADER_LEN) % self.IROM_ALIGN
860 if self.secure_pad == "1":
865 elif self.secure_pad == "2": # Secure Boot V2
871 self.IROM_ALIGN - align_past - checksum_space - space_after_checksum
872 ) % self.IROM_ALIGN
875 checksum = self.save_segment(f, pad_segment, checksum)
878 if not self.ram_only_header:
880 self.append_checksum(f, checksum)
883 if self.secure_pad:
884 assert ((image_length + space_after_checksum) % self.IROM_ALIGN) == 0
889 if self.ram_only_header:
896 if self.append_digest:
903 if self.pad_to_size:
905 if image_length % self.pad_to_size != 0:
906 pad_by = self.pad_to_size - (image_length % self.pad_to_size)
912 def load_extended_header(self, load_file): argument
917 struct.unpack(self.EXTENDED_HEADER_STRUCT_FMT, load_file.read(16))
920 self.wp_pin = fields[0]
923 self.clk_drv, self.q_drv = split_byte(fields[1])
924 self.d_drv, self.cs_drv = split_byte(fields[2])
925 self.hd_drv, self.wp_drv = split_byte(fields[3])
927 self.chip_id = fields[4]
928 if self.chip_id != self.ROM_LOADER.IMAGE_CHIP_ID:
934 % (self.ROM_LOADER.IMAGE_CHIP_ID, self.chip_id)
937 self.min_rev = fields[5]
938 self.min_rev_full = fields[6]
939 self.max_rev_full = fields[7]
943 self.append_digest = append_digest == 1
950 def save_extended_header(self, save_file): argument
954 append_digest = 1 if self.append_digest else 0
957 self.wp_pin,
958 join_byte(self.clk_drv, self.q_drv),
959 join_byte(self.d_drv, self.cs_drv),
960 join_byte(self.hd_drv, self.wp_drv),
961 self.ROM_LOADER.IMAGE_CHIP_ID,
962 self.min_rev,
963 self.min_rev_full,
964 self.max_rev_full,
969 packed = struct.pack(self.EXTENDED_HEADER_STRUCT_FMT, *fields)
978 def is_flash_addr(self, addr): argument
981 def save(self, filename): argument
984 self.write_common_header(f, self.segments)
992 for s in sorted(self.segments, key=lambda s: s.addr)
993 if self.is_flash_addr(s.addr) and len(s.data)
997 for s in sorted(self.segments, key=lambda s: s.addr)
998 if not self.is_flash_addr(s.addr) and len(s.data)
1007 if segment.addr // self.IROM_ALIGN == last_addr // self.IROM_ALIGN:
1024 checksum = self.save_segment(f, segment, checksum)
1030 checksum = self.save_segment(f, segment, checksum)
1034 self.append_checksum(f, checksum)
1042 if self.append_digest:
1052 def load_extended_header(self, load_file): argument
1057 struct.unpack(self.EXTENDED_HEADER_STRUCT_FMT, load_file.read(16))
1060 self.wp_pin = fields[0]
1063 self.clk_drv, self.q_drv = split_byte(fields[1])
1064 self.d_drv, self.cs_drv = split_byte(fields[2])
1065 self.hd_drv, self.wp_drv = split_byte(fields[3])
1068 self.append_digest = fields[15] == 1
1154 def set_mmu_page_size(self, size): argument
1160 self.IROM_ALIGN = size
1171 def set_mmu_page_size(self, size): argument
1177 self.IROM_ALIGN = size
1242 def __init__(self, name): argument
1244 self.name = name
1245 with open(self.name, "rb") as f:
1246 self._read_elf_file(f)
1248 def get_section(self, section_name): argument
1249 for s in self.sections:
1254 def _read_elf_file(self, f): argument
1263 self.entrypoint,
1276 "Failed to read a valid ELF header from %s: %s" % (self.name, e)
1280 raise FatalError("%s has invalid ELF magic header" % self.name)
1284 "e_machine=%04x" % (self.name, machine)
1286 if shentsize != self.LEN_SEC_HEADER:
1289 % (self.name, shentsize, self.LEN_SEC_HEADER)
1292 raise FatalError("%s has 0 section headers" % (self.name))
1293 self._read_sections(f, shoff, shnum, shstrndx)
1294 self._read_segments(f, _phoff, _phnum, shstrndx)
1296 def _read_sections(self, f, section_header_offs, section_header_count, shstrndx): argument
1298 len_bytes = section_header_count * self.LEN_SEC_HEADER
1312 section_header_offsets = range(0, len(section_header), self.LEN_SEC_HEADER)
1333 if (shstrndx * self.LEN_SEC_HEADER) not in section_header_offsets:
1336 shstrndx * self.LEN_SEC_HEADER
1367 self.sections = prog_sections
1368 self.nobits_sections = [
1374 def _read_segments(self, f, segment_header_offs, segment_header_count, shstrndx): argument
1376 len_bytes = segment_header_count * self.LEN_SEG_HEADER
1390 segment_header_offsets = range(0, len(segment_header), self.LEN_SEG_HEADER)
1417 self.segments = prog_segments
1419 def sha256(self): argument
1422 with open(self.name, "rb") as f: