Lines Matching refs:self
223 def __init__(self, name, ftype, data, cbfs_offset, compress=COMPRESS_NONE): argument
224 self.name = name
225 self.offset = None
226 self.cbfs_offset = cbfs_offset
227 self.data = data
228 self.orig_data = data
229 self.ftype = ftype
230 self.compress = compress
231 self.memlen = None
232 self.load = None
233 self.entry = None
234 self.base_address = None
235 self.data_len = len(data)
236 self.erase_byte = None
237 self.size = None
239 def decompress(self): argument
241 indata = self.data
242 if self.compress == COMPRESS_LZ4:
244 elif self.compress == COMPRESS_LZMA:
248 self.memlen = len(data)
249 self.data = data
250 self.data_len = len(indata)
306 def calc_start_offset(self): argument
313 if self.cbfs_offset is None:
315 return self.cbfs_offset - self.get_header_len()
317 def get_header_len(self): argument
326 name = _pack_string(self.name)
328 if self.ftype == TYPE_STAGE:
330 elif self.ftype == TYPE_RAW:
332 elif self.ftype == TYPE_EMPTY:
335 raise ValueError('Unknown file type %#x\n' % self.ftype)
338 def get_data_and_offset(self, offset=None, pad_byte=None): argument
348 name = _pack_string(self.name)
354 data = self.data
355 if self.ftype == TYPE_STAGE:
356 elf_data = elf.DecodeElf(data, self.base_address)
357 content = struct.pack(STAGE_FORMAT, self.compress,
361 elif self.ftype == TYPE_RAW:
363 if self.compress == COMPRESS_LZ4:
365 elif self.compress == COMPRESS_LZMA:
367 self.memlen = len(orig_data)
368 self.data_len = len(data)
371 self.compress, self.memlen)
372 elif self.ftype == TYPE_EMPTY:
373 data = tools.GetBytes(self.erase_byte, self.size)
375 raise ValueError('Unknown type %#x when writing\n' % self.ftype)
379 if self.cbfs_offset is not None:
380 pad_len = self.cbfs_offset - offset - hdr_len
389 (self.name, self.cbfs_offset, offset))
396 self.ftype, attr_pos, hdr_len)
400 expected_len = self.get_header_len()
406 (self.name, expected_len, actual_len))
437 def __init__(self, size, arch=ARCHITECTURE_X86): argument
447 self._master_name = 'cbfs master header'
448 self._size = size
449 self._files = OrderedDict()
450 self._arch = arch
451 self._bootblock_size = 0
452 self._erase_byte = 0xff
453 self._align = ENTRY_ALIGN
454 self._add_fileheader = False
455 if self._arch == ARCHITECTURE_X86:
459 self._base_address = self._size - max(self._bootblock_size,
461 self._header_offset = self._base_address - HEADER_LEN
462 self._contents_offset = 0
463 self._hdr_at_start = False
466 self._base_address = 0
467 self._header_offset = align_int(self._base_address +
468 self._bootblock_size, 4)
469 self._contents_offset = align_int(self._header_offset +
471 self._bootblock_size, self._align)
472 self._hdr_at_start = True
474 def _skip_to(self, fd, offset): argument
484 fd.write(tools.GetBytes(self._erase_byte, offset - fd.tell()))
486 def _pad_to(self, fd, offset): argument
493 self._align_to(fd, self._align)
498 todo = align_int_down(offset - upto, self._align)
500 cbf = CbfsFile.empty(todo, self._erase_byte)
502 self._skip_to(fd, offset)
504 def _align_to(self, fd, align): argument
517 if offset < self._size:
518 self._skip_to(fd, offset)
520 def add_file_stage(self, name, data, cbfs_offset=None): argument
533 cfile = CbfsFile.stage(self._base_address, name, data, cbfs_offset)
534 self._files[name] = cfile
537 def add_file_raw(self, name, data, cbfs_offset=None, argument
553 self._files[name] = cfile
556 def _write_header(self, fd, add_fileheader): argument
564 if fd.tell() > self._header_offset:
566 (self._header_offset, fd.tell()))
568 self._pad_to(fd, self._header_offset)
570 self._size, self._bootblock_size, self._align,
571 self._contents_offset, self._arch, 0xffffffff)
573 name = _pack_string(self._master_name)
578 self._header_offset = fd.tell()
580 self._align_to(fd, self._align)
584 def get_data(self): argument
595 if self._hdr_at_start:
596 self._write_header(fd, add_fileheader=self._add_fileheader)
597 self._skip_to(fd, self._contents_offset)
600 for cbf in self._files.values():
604 self._pad_to(fd, align_int_down(offset, self._align))
606 data, data_offset = cbf.get_data_and_offset(pos, self._erase_byte)
608 self._align_to(fd, self._align)
610 if not self._hdr_at_start:
611 self._write_header(fd, add_fileheader=self._add_fileheader)
614 self._pad_to(fd, self._base_address or self._size - 4)
615 rel_offset = self._header_offset - self._size
644 def __init__(self, data, read=True): argument
645 self.align = ENTRY_ALIGN
646 self.arch = None
647 self.boot_block_size = None
648 self.cbfs_offset = None
649 self.files = OrderedDict()
650 self.magic = None
651 self.rom_size = None
652 self.stage_base_address = 0
653 self.version = None
654 self.data = data
656 self.read()
658 def read(self): argument
660 with io.BytesIO(self.data) as fd:
662 if not self._find_and_read_header(fd, len(self.data)):
664 fd.seek(self.cbfs_offset)
668 cfile = self._read_next_file(fd)
670 self.files[cfile.name] = cfile
674 def _find_and_read_header(self, fd, size): argument
693 found = self._read_header(fd)
698 found = self._read_header(fd)
704 def _read_next_file(self, fd): argument
725 name = self._read_string(fd)
734 compress = self._read_attr(fd, file_pos, attr, offset)
743 self._read_header(fd)
746 cfile = CbfsFile.stage(self.stage_base_address, name, b'',
768 pad = (self.align - fd.tell() % self.align) % self.align
814 def _read_header(self, fd): argument
832 (self.magic, self.version, self.rom_size, self.boot_block_size,
833 self.align, self.cbfs_offset, self.arch, _) = struct.unpack(
835 return self.magic == HEADER_MAGIC and (
836 self.version == HEADER_VERSION1 or
837 self.version == HEADER_VERSION2)