diff options
author | Sandeep Patil <sspatil@google.com> | 2018-02-07 03:52:38 +0000 |
---|---|---|
committer | android-build-merger <android-build-merger@google.com> | 2018-02-07 03:52:38 +0000 |
commit | 930a7502e4fc4d87e0d46fe91b652df7d66aad8e (patch) | |
tree | 7e5f52e5228657c09c9ac84c48c60ec5b51f4870 | |
parent | e5b1a0c8a076186226ec9c8da68c1a25f0e20d03 (diff) | |
parent | 8491f7086164218f394e4c5ac9802b598013e5f1 (diff) | |
download | libufdt-930a7502e4fc4d87e0d46fe91b652df7d66aad8e.tar.gz |
Add mkdtboimg am: 9bde0c43d9 am: 6fb1bf0116
am: 8491f70861
Change-Id: Ia9391219618bc8fe32c00bdfe371f1b6f834e303
-rw-r--r-- | utils/src/Android.mk | 11 | ||||
-rwxr-xr-x | utils/src/mkdtboimg.py | 898 | ||||
-rw-r--r-- | utils/tests/data/mkdtboimg.cfg | 18 | ||||
-rwxr-xr-x | utils/tests/mkdtboimg_testdata.sh | 108 |
4 files changed, 1034 insertions, 1 deletions
diff --git a/utils/src/Android.mk b/utils/src/Android.mk index 21d4279..2345ac9 100644 --- a/utils/src/Android.mk +++ b/utils/src/Android.mk @@ -38,6 +38,15 @@ LOCAL_CXX_STL := none include $(BUILD_HOST_EXECUTABLE) +$(call dist-for-goals, dist_files, $(ALL_MODULES.mkdtimg.BUILT):libufdt/mkdtimg) ################################################### +include $(CLEAR_VARS) + +LOCAL_MODULE := mkdtboimg.py +LOCAL_SRC_FILES := mkdtboimg.py +LOCAL_MODULE_CLASS := EXECUTABLES +LOCAL_IS_HOST_MODULE := true +LOCAL_MODULE_TAGS := optional + +include $(BUILD_PREBUILT) -$(call dist-for-goals, dist_files, $(ALL_MODULES.mkdtimg.BUILT):libufdt/mkdtimg) diff --git a/utils/src/mkdtboimg.py b/utils/src/mkdtboimg.py new file mode 100755 index 0000000..5f7e40f --- /dev/null +++ b/utils/src/mkdtboimg.py @@ -0,0 +1,898 @@ +#! /usr/bin/env python +# Copyright 2017, The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import print_function + +"""Tool for packing multiple DTB/DTBO files into a single image""" + +import argparse +import os +from array import array +from collections import namedtuple +import struct +from sys import stdout + + +class DtEntry(object): + """Provides individual DT image file arguments to be added to a DTBO. + + Attributes: + _REQUIRED_KEYS: 'keys' needed to be present in the dictionary passed to instantiate + an object of this class. + """ + + REQUIRED_KEYS = ('dt_file', 'dt_size', 'dt_offset', 'id', 'rev', 'custom0', + 'custom1', 'custom2', 'custom3') + @staticmethod + def __get_number_or_prop(arg): + """Converts string to integer or reads the property from DT image. + + Args: + arg: String containing the argument provided on the command line. + + Returns: + An integer property read from DT file or argument string + converted to integer + """ + + if not arg or arg[0] == '+' or arg[0] == '-': + raise ValueError('Invalid argument passed to DTImage') + if arg[0] == '/': + # TODO(b/XXX): Use pylibfdt to get property value from DT + raise ValueError('Invalid argument passed to DTImage') + else: + base = 10 + if arg.startswith('0x') or arg.startswith('0X'): + base = 16 + elif arg.startswith('0'): + base = 8 + return int(arg, base) + + def __init__(self, **kwargs): + """Constructor for DtEntry object. + + Initializes attributes from dictionary object that contains + values keyed with names equivalent to the class's attributes. + + Args: + kwargs: Dictionary object containing values to instantiate + class members with. Expected keys in dictionary are from + the tuple (_REQUIRED_KEYS) + """ + + missing_keys = set(self.REQUIRED_KEYS) - set(kwargs) + if missing_keys: + raise ValueError('Missing keys in DtEntry constructor: %r' % + sorted(missing_keys)) + + self.__dt_file = kwargs['dt_file'] + self.__dt_offset = kwargs['dt_offset'] + self.__dt_size = kwargs['dt_size'] + self.__id = self.__get_number_or_prop(kwargs['id']) + self.__rev = self.__get_number_or_prop(kwargs['rev']) + self.__custom0 = self.__get_number_or_prop(kwargs['custom0']) + self.__custom1 = self.__get_number_or_prop(kwargs['custom1']) + self.__custom2 = self.__get_number_or_prop(kwargs['custom2']) + self.__custom3 = self.__get_number_or_prop(kwargs['custom3']) + + def __str__(self): + sb = [] + sb.append('{key:>20} = {value:d}'.format(key='dt_size', + value=self.__dt_size)) + sb.append('{key:>20} = {value:d}'.format(key='dt_offset', + value=self.__dt_offset)) + sb.append('{key:>20} = {value:08x}'.format(key='id', + value=self.__id)) + sb.append('{key:>20} = {value:08x}'.format(key='rev', + value=self.__rev)) + sb.append('{key:>20} = {value:08x}'.format(key='custom[0]', + value=self.__custom0)) + sb.append('{key:>20} = {value:08x}'.format(key='custom[1]', + value=self.__custom1)) + sb.append('{key:>20} = {value:08x}'.format(key='custom[2]', + value=self.__custom2)) + sb.append('{key:>20} = {value:08x}'.format(key='custom[3]', + value=self.__custom3)) + return '\n'.join(sb) + + @property + def dt_file(self): + """file: File handle to the DT image file.""" + return self.__dt_file + + @property + def size(self): + """int: size in bytes of the DT image file.""" + return self.__dt_size + + @property + def dt_offset(self): + """int: offset in DTBO file for this DT image.""" + return self.__dt_offset + + @dt_offset.setter + def dt_offset(self, value): + self.__dt_offset = value + + @property + def image_id(self): + """int: DT entry _id for this DT image.""" + return self.__id + + @property + def rev(self): + """int: DT entry _rev for this DT image.""" + return self.__rev + + @property + def custom0(self): + """int: DT entry _custom0 for this DT image.""" + return self.__custom0 + + @property + def custom1(self): + """int: DT entry _custom1 for this DT image.""" + return self.__custom1 + + @property + def custom2(self): + """int: DT entry _custom2 for this DT image.""" + return self.__custom2 + + @property + def custom3(self): + """int: DT entry custom3 for this DT image.""" + return self.__custom3 + + +class Dtbo(object): + """ + Provides parser, reader, writer for dumping and creating Device Tree Blob + Overlay (DTBO) images. + + Attributes: + _DTBO_MAGIC: Device tree table header magic. + _DT_TABLE_HEADER_SIZE: Size of Device tree table header. + _DT_TABLE_HEADER_INTS: Number of integers in DT table header. + _DT_ENTRY_HEADER_SIZE: Size of Device tree entry header within a DTBO. + _DT_ENTRY_HEADER_INTS: Number of integers in DT entry header. + """ + + _DTBO_MAGIC = 0xd7b7ab1e + _DT_TABLE_HEADER_SIZE = struct.calcsize('>8I') + _DT_TABLE_HEADER_INTS = 8 + _DT_ENTRY_HEADER_SIZE = struct.calcsize('>8I') + _DT_ENTRY_HEADER_INTS = 8 + + def _update_dt_table_header(self): + """Converts header entries into binary data for DTBO header. + + Packs the current Device tree table header attribute values in + metadata buffer. + """ + struct.pack_into('>8I', self.__metadata, 0, self.magic, + self.total_size, self.header_size, + self.dt_entry_size, self.dt_entry_count, + self.dt_entries_offset, self.page_size, + self.reserved) + + def _update_dt_entry_header(self, dt_entry, metadata_offset): + """Converts each DT entry header entry into binary data for DTBO file. + + Packs the current device tree table entry attribute into + metadata buffer as device tree entry header. + + Args: + dt_entry: DtEntry object for the header to be packed. + metadata_offset: Offset into metadata buffer to begin writing. + dtbo_offset: Offset where the DT image file for this dt_entry can + be found in the resulting DTBO image. + """ + struct.pack_into('>8I', self.__metadata, metadata_offset, dt_entry.size, + dt_entry.dt_offset, dt_entry.image_id, dt_entry.rev, + dt_entry.custom0, dt_entry.custom1, dt_entry.custom2, + dt_entry.custom3) + + def _update_metadata(self): + """Updates the DTBO metadata. + + Initialize the internal metadata buffer and fill it with all Device + Tree table entries and update the DTBO header. + """ + + self.__metadata = array('c', ' ' * self.__metadata_size) + metadata_offset = self.header_size + for dt_entry in self.__dt_entries: + self._update_dt_entry_header(dt_entry, metadata_offset) + metadata_offset += self.dt_entry_size + self._update_dt_table_header() + + def _read_dtbo_header(self, buf): + """Reads DTBO file header into metadata buffer. + + Unpack and read the DTBO table header from given buffer. The + buffer size must exactly be equal to _DT_TABLE_HEADER_SIZE. + + Args: + buf: Bytebuffer read directly from the file of size + _DT_TABLE_HEADER_SIZE. + """ + (self.magic, self.total_size, self.header_size, + self.dt_entry_size, self.dt_entry_count, self.dt_entries_offset, + self.page_size, self.reserved) = struct.unpack_from('>8I', buf, 0) + + # verify the header + if self.magic != self._DTBO_MAGIC: + raise ValueError('Invalid magic number 0x%x in DTBO file' % + (self.magic)) + + if self.header_size != self._DT_TABLE_HEADER_SIZE: + raise ValueError('Invalid header size (%d) in DTBO file' % + (self.header_size)) + + if self.dt_entry_size != self._DT_ENTRY_HEADER_SIZE: + raise ValueError('Invalid DT entry header size (%d) in DTBO file' % + (self.dt_entry_size)) + + if self.reserved: + raise ValueError('Invalid reserved field (%d) in DTBO header' % + (self.reserved)) + + def _read_dt_entries_from_metadata(self): + """Reads individual DT entry headers from metadata buffer. + + Unpack and read the DTBO DT entry headers from the internal buffer. + The buffer size must exactly be equal to _DT_TABLE_HEADER_SIZE + + (_DT_ENTRY_HEADER_SIZE * dt_entry_count). The method raises exception + if DT entries have already been set for this object. + """ + + if self.__dt_entries: + raise ValueError('DTBO DT entries can be added only once') + + offset = self.dt_entries_offset / 4 + params = {} + params['dt_file'] = None + for i in range(0, self.dt_entry_count): + dt_table_entry = self.__metadata[offset:offset + self._DT_ENTRY_HEADER_INTS] + params['dt_size'] = dt_table_entry[0] + params['dt_offset'] = dt_table_entry[1] + for j in range(2, self._DT_ENTRY_HEADER_INTS): + params[DtEntry.REQUIRED_KEYS[j + 1]] = str(dt_table_entry[j]) + dt_entry = DtEntry(**params) + self.__dt_entries.append(dt_entry) + offset += self._DT_ENTRY_HEADER_INTS + + def _read_dtbo_image(self): + """Parse the input file and instantiate this object.""" + + # First check if we have enough to read the header + file_size = os.fstat(self.__file.fileno()).st_size + if file_size < self._DT_TABLE_HEADER_SIZE: + raise ValueError('Invalid DTBO file') + + self.__file.seek(0) + buf = self.__file.read(self._DT_TABLE_HEADER_SIZE) + self._read_dtbo_header(buf) + + self.__metadata_size = (self.header_size + + self.dt_entry_count * self.dt_entry_size) + if file_size < self.__metadata_size: + raise ValueError('Invalid or truncated DTBO file of size %d expected %d' % + file_size, self.__metadata_size) + + num_ints = (self._DT_TABLE_HEADER_INTS + + self.dt_entry_count * self._DT_ENTRY_HEADER_INTS) + if self.dt_entries_offset > self._DT_TABLE_HEADER_SIZE: + num_ints += (self.dt_entries_offset - self._DT_TABLE_HEADER_SIZE) / 4 + format_str = '>' + str(num_ints) + 'I' + self.__file.seek(0) + self.__metadata = struct.unpack(format_str, + self.__file.read(self.__metadata_size)) + self._read_dt_entries_from_metadata() + + def _find_dt_entry_with_same_file(self, dt_entry): + """Finds DT Entry that has identical backing DT file. + + Args: + dt_entry: DtEntry object whose 'dtfile' we find for existence in the + current 'dt_entries'. + Returns: + If a match by file path is found, the corresponding DtEntry object + from internal list is returned. If not, 'None' is returned. + """ + + dt_entry_path = os.path.realpath(dt_entry.dt_file.name) + for entry in self.__dt_entries: + entry_path = os.path.realpath(entry.dt_file.name) + if entry_path == dt_entry_path: + return entry + return None + + def __init__(self, file_handle, page_size=None): + """Constructor for Dtbo Object + + Args: + file_handle: The Dtbo File handle corresponding to this object. + The file handle can be used to write to (in case of 'create') + or read from (in case of 'dump') + """ + + self.__file = file_handle + self.__dt_entries = [] + self.__metadata = None + self.__metadata_size = 0 + + # if page_size is given, assume the object is being instantiated to + # create a DTBO file + if page_size: + self.magic = self._DTBO_MAGIC + self.total_size = self._DT_TABLE_HEADER_SIZE + self.header_size = self._DT_TABLE_HEADER_SIZE + self.dt_entry_size = self._DT_ENTRY_HEADER_SIZE + self.dt_entry_count = 0 + self.dt_entries_offset = self._DT_TABLE_HEADER_SIZE + self.page_size = page_size + self.reserved = 0 + self.__metadata_size = self._DT_TABLE_HEADER_SIZE + else: + self._read_dtbo_image() + + def __str__(self): + sb = [] + sb.append('dt_table_header:') + _keys = ('magic', 'total_size', 'header_size', 'dt_entry_size', + 'dt_entry_count', 'dt_entries_offset', 'page_size') + for key in _keys: + if key == 'magic': + sb.append('{key:>20} = {value:08x}'.format(key=key, + value=self.__dict__[key])) + else: + sb.append('{key:>20} = {value:d}'.format(key=key, + value=self.__dict__[key])) + sb.append('{key:>20} = {value:08d}'.format(key='reserved[0]', + value=self.reserved)) + count = 0 + for dt_entry in self.__dt_entries: + sb.append('dt_table_entry[{0:d}]:'.format(count)) + sb.append(str(dt_entry)) + count = count + 1 + return '\n'.join(sb) + + @property + def dt_entries(self): + """Returns a list of DtEntry objects found in DTBO file.""" + return self.__dt_entries + + def add_dt_entries(self, dt_entries): + """Adds DT image files to the DTBO object. + + Adds a list of Dtentry Objects to the DTBO image. The changes are not + committed to the output file until commit() is called. + + Args: + dt_entries: List of DtEntry object to be added. + + """ + if not dt_entries: + raise ValueError('Attempted to add empty list of DT entries') + + if self.__dt_entries: + raise ValueError('DTBO DT entries can be added only once') + + dt_entry_count = len(dt_entries) + dt_offset = (self.header_size + + dt_entry_count * self.dt_entry_size) + + for dt_entry in dt_entries: + if not isinstance(dt_entry, DtEntry): + raise ValueError('Adding invalid DT entry object to DTBO') + entry = self._find_dt_entry_with_same_file(dt_entry) + if entry: + dt_entry.dt_offset = entry.dt_offset + else: + dt_entry.dt_offset = dt_offset + dt_offset += dt_entry.size + self.total_size += dt_entry.size + self.__dt_entries.append(dt_entry) + self.dt_entry_count += 1 + self.__metadata_size += self.dt_entry_size + self.total_size += self.dt_entry_size + + def extract_dt_file(self, idx, fout): + """Extract DT Image files embedded in the DTBO file. + + Extracts Device Tree blob image file at given index into a file handle. + + Args: + idx: Index of the DT entry in the DTBO file. + fout: File handle where the DTB at index idx to be extracted into. + """ + if idx > self.dt_entry_count: + raise ValueError('Invalid index %d of DtEntry' % idx) + + size = self.dt_entries[idx].size + offset = self.dt_entries[idx].dt_offset + self.__file.seek(offset, 0) + fout.seek(0) + fout.write(self.__file.read(size)) + + def commit(self): + """Write out staged changes to the DTBO object to create a DTBO file. + + Writes a fully instantiated Dtbo Object into the output file using the + file handle present in '_file'. No checks are performed on the object + except for existence of output file handle on the object before writing + out the file. + """ + if not self.__file: + raise ValueError('No file given to write to.') + + if not self.__dt_entries: + raise ValueError('No DT image files to embed into DTBO image given.') + + self._update_metadata() + self.__file.seek(0) + self.__file.write(self.__metadata) + for dt_entry in self.__dt_entries: + self.__file.write(dt_entry.dt_file.read()) + self.__file.flush() + + +def parse_dt_entry(global_args, arglist): + """Parse arguments for single DT entry file. + + Parses command line arguments for single DT image file while + creating a Device tree blob overlay (DTBO). + + Args: + global_args: Dtbo object containing global default values + for DtEntry attributes. + arglist: Command line argument list for this DtEntry. + + Returns: + A Namespace object containing all values to instantiate DtEntry object. + """ + + parser = argparse.ArgumentParser(add_help=False) + parser.add_argument('dt_file', nargs='?', + type=argparse.FileType('rb'), + default=None) + parser.add_argument('--id', type=str, dest='id', action='store', + default=global_args.global_id) + parser.add_argument('--rev', type=str, dest='rev', + action='store', default=global_args.global_rev) + parser.add_argument('--custom0', type=str, dest='custom0', + action='store', + default=global_args.global_custom0) + parser.add_argument('--custom1', type=str, dest='custom1', + action='store', + default=global_args.global_custom1) + parser.add_argument('--custom2', type=str, dest='custom2', + action='store', + default=global_args.global_custom2) + parser.add_argument('--custom3', type=str, dest='custom3', + action='store', + default=global_args.global_custom3) + return parser.parse_args(arglist) + + +def parse_dt_entries(global_args, arg_list): + """Parse all DT entries from command line. + + Parse all DT image files and their corresponding attribute from + command line + + Args: + global_args: Argument containing default global values for _id, + _rev and customX. + arg_list: The remainder of the command line after global options + DTBO creation have been parsed. + + Returns: + A List of DtEntry objects created after parsing the command line + given in argument. + """ + dt_entries = [] + img_file_idx = [] + idx = 0 + # find all positional arguments (i.e. DT image file paths) + for arg in arg_list: + if not arg.startswith("--"): + img_file_idx.append(idx) + idx = idx + 1 + + if not img_file_idx: + raise ValueError('Input DT images must be provided') + + total_images = len(img_file_idx) + for idx in xrange(total_images): + start_idx = img_file_idx[idx] + if idx == total_images - 1: + argv = arg_list[start_idx:] + else: + end_idx = img_file_idx[idx + 1] + argv = arg_list[start_idx:end_idx] + args = parse_dt_entry(global_args, argv) + params = vars(args) + params['dt_offset'] = 0 + params['dt_size'] = os.fstat(params['dt_file'].fileno()).st_size + dt_entries.append(DtEntry(**params)) + + return dt_entries + +def parse_config_option(line, is_global, dt_keys, global_keys): + """Parses a single line from the configuration file. + + Args: + line: String containing the key=value line from the file. + is_global: Boolean indicating if we should parse global or DT entry + specific option. + dt_keys: Tuple containing all valid DT entry and global option strings + in configuration file. + global_keys: Tuple containing all exclusive valid global option strings + in configuration file that are not repeated in dt entry options. + + Returns: + Returns a tuple for parsed key and value for the option. Also, checks + the key to make sure its valid. + """ + + if line.find('=') == -1: + raise ValueError('Invalid line (%s) in configuration file' % line) + + key, value = (x.strip() for x in line.split('=')) + if key not in dt_keys: + if is_global and key in global_keys: + value = int(value) + else: + raise ValueError('Invalid option (%s) in configuration file' % key) + + return key, value + +def parse_config_file(fin, dt_keys, global_keys): + """Parses the configuration file for creating DTBO image. + + Args: + fin: File handle for configuration file + is_global: Boolean indicating if we should parse global or DT entry + specific option. + dt_keys: Tuple containing all valid DT entry and global option strings + in configuration file. + global_keys: Tuple containing all exclusive valid global option strings + in configuration file that are not repeated in dt entry options. + + Returns: + global_args, dt_args: Tuple of a dictionary with global arguments + and a list of dictionaries for all DT entry specific arguments the + following format. + global_args: + {'id' : <value>, 'rev' : <value> ...} + dt_args: + [{'filename' : 'dt_file_name', 'id' : <value>, + 'rev' : <value> ...}, + {'filename' : 'dt_file_name2', 'id' : <value2>, + 'rev' : <value2> ...}, ... + ] + """ + + # set all global defaults + global_args = dict((k, '0') for k in dt_keys) + global_args['page_size'] = 2048 + + dt_args = [] + found_dt_entry = False + count = -1 + for line in fin: + line = line.rstrip() + if line.lstrip().startswith('#'): + continue + comment_idx = line.find('#') + line = line if comment_idx == -1 else line[0:comment_idx] + if not line or line.isspace(): + continue + if line.startswith(' ') and not found_dt_entry: + # This is a global argument + key, value = parse_config_option(line, True, dt_keys, global_keys) + global_args[key] = value + elif line.find('=') != -1: + key, value = parse_config_option(line, False, dt_keys, global_keys) + dt_args[-1][key] = value + else: + found_dt_entry = True + count += 1 + dt_args.append({}) + dt_args[-1]['filename'] = line.strip() + return global_args, dt_args + +def parse_create_args(arg_list): + """Parse command line arguments for 'create' sub-command. + + Args: + arg_list: All command line arguments except the outfile file name. + + Returns: + The list of remainder of the command line arguments after parsing + for 'create'. + """ + + image_arg_index = 0 + for arg in arg_list: + if not arg.startswith("--"): + break + image_arg_index = image_arg_index + 1 + + argv = arg_list[0:image_arg_index] + remainder = arg_list[image_arg_index:] + parser = argparse.ArgumentParser(prog='create', add_help=False) + parser.add_argument('--page_size', type=int, dest='page_size', + action='store', default=2048) + parser.add_argument('--id', type=str, dest='global_id', + action='store', default='0') + parser.add_argument('--rev', type=str, dest='global_rev', + action='store', default='0') + parser.add_argument('--custom0', type=str, dest='global_custom0', + action='store', default='0') + parser.add_argument('--custom1', type=str, dest='global_custom1', + action='store', default='0') + parser.add_argument('--custom2', type=str, dest='global_custom2', + action='store', default='0') + parser.add_argument('--custom3', type=str, dest='global_custom3', + action='store', default='0') + args = parser.parse_args(argv) + return args, remainder + +def parse_dump_cmd_args(arglist): + """Parse command line arguments for 'dump' sub-command. + + Args: + arglist: List of all command line arguments including the outfile + file name if exists. + + Returns: + A namespace object of parsed arguments. + """ + + parser = argparse.ArgumentParser(prog='dump') + parser.add_argument('--output', '-o', nargs='?', + type=argparse.FileType('wb'), + dest='outfile', + default=stdout) + parser.add_argument('--dtb', '-b', nargs='?', type=str, + dest='dtfilename') + return parser.parse_args(arglist) + +def parse_config_create_cmd_args(arglist): + """Parse command line arguments for 'cfg_create subcommand. + + Args: + arglist: A list of all command line arguments including the + mandatory input configuration file name. + + Returns: + A Namespace object of parsed arguments. + """ + parser = argparse.ArgumentParser(prog='cfg_create') + parser.add_argument('conf_file', nargs='?', + type=argparse.FileType('rb'), + default=None) + cwd = os.getcwd() + parser.add_argument('--dtb-dir', '-d', nargs='?', type=str, + dest='dtbdir', default=cwd) + return parser.parse_args(arglist) + +def create_dtbo_image(fout, argv): + """Create Device Tree Blob Overlay image using provided arguments. + + Args: + fout: Output file handle to write to. + argv: list of command line arguments. + """ + + global_args, remainder = parse_create_args(argv) + if not remainder: + raise ValueError('List of dtimages to add to DTBO not provided') + dt_entries = parse_dt_entries(global_args, remainder) + dtbo = Dtbo(fout, global_args.page_size) + dtbo.add_dt_entries(dt_entries) + dtbo.commit() + fout.close() + +def dump_dtbo_image(fin, argv): + """Dump DTBO file. + + Dump Device Tree Blob Overlay metadata as output and the device + tree image files embedded in the DTBO image into file(s) provided + as arguments + + Args: + fin: Input DTBO image files. + argv: list of command line arguments. + """ + dtbo = Dtbo(fin) + args = parse_dump_cmd_args(argv) + if args.dtfilename: + num_entries = len(dtbo.dt_entries) + for idx in range(0, num_entries): + with open(args.dtfilename + '.{:d}'.format(idx), 'wb') as fout: + dtbo.extract_dt_file(idx, fout) + args.outfile.write(str(dtbo) + '\n') + args.outfile.close() + +def create_dtbo_image_from_config(fout, argv): + """Create DTBO file from a configuration file. + + Args: + fout: Output file handle to write to. + argv: list of command line arguments. + """ + args = parse_config_create_cmd_args(argv) + if not args.conf_file: + raise ValueError('Configuration file must be provided') + + _DT_KEYS = ('id', 'rev', 'custom0', 'custom1', 'custom2', 'custom3') + _GLOBAL_KEYS = ('page_size') + + global_args, dt_args = parse_config_file(args.conf_file, + _DT_KEYS, _GLOBAL_KEYS) + params = {} + dt_entries = [] + for dt_arg in dt_args: + filepath = args.dtbdir + os.sep + dt_arg['filename'] + params['dt_file'] = open(filepath, 'rb') + params['dt_offset'] = 0 + params['dt_size'] = os.fstat(params['dt_file'].fileno()).st_size + for key in _DT_KEYS: + if key not in dt_arg: + params[key] = global_args[key] + else: + params[key] = dt_arg[key] + dt_entries.append(DtEntry(**params)) + + # Create and write DTBO file + dtbo = Dtbo(fout, global_args['page_size']) + dtbo.add_dt_entries(dt_entries) + dtbo.commit() + fout.close() + +def print_default_usage(progname): + """Prints program's default help string. + + Args: + progname: This program's name. + """ + sb = [] + sb.append(' ' + progname + ' help all') + sb.append(' ' + progname + ' help <command>\n') + sb.append(' commands:') + sb.append(' help, dump, create, cfg_create') + print('\n'.join(sb)) + +def print_dump_usage(progname): + """Prints usage for 'dump' sub-command. + + Args: + progname: This program's name. + """ + sb = [] + sb.append(' ' + progname + ' dump <image_file> (<option>...)\n') + sb.append(' options:') + sb.append(' -o, --output <filename> Output file name.') + sb.append(' Default is output to stdout.') + sb.append(' -b, --dtb <filename> Dump dtb/dtbo files from image.') + sb.append(' Will output to <filename>.0, <filename>.1, etc.') + print('\n'.join(sb)) + +def print_create_usage(progname): + """Prints usage for 'create' subcommand. + + Args: + progname: This program's name. + """ + sb = [] + sb.append(' ' + progname + ' create <image_file> (<global_option>...) (<dtb_file> (<entry_option>...) ...)\n') + sb.append(' global_options:') + sb.append(' --page_size <number> Output file name. Default: 2048') + sb.append(' --id <number> The default value to set property id in dt_table_entry. Default: 0') + sb.append(' --rev <number>') + sb.append(' --custom0=<number>') + sb.append(' --custom2=<number>') + sb.append(' --custom3=<number>') + sb.append(' --custom4=<number>\n') + + sb.append(' The value could be a number or a DT node path.') + sb.append(' <number> could be a 32-bits digit or hex value, ex. 68000, 0x6800.') + sb.append(' <path> format is <full_node_path>:<property_name>, ex. /board/:id,') + sb.append(' will read the value in given FTB file with the path.') + print('\n'.join(sb)) + +def print_cfg_create_usage(progname): + """Prints usage for 'cfg_create' sub-command. + + Args: + progname: This program's name. + """ + sb = [] + sb.append(' ' + progname + ' cfg_create <image_file> <config_file> (<option>...)\n') + sb.append(' options:') + sb.append(' -d, --dtb-dir <dir> The path to load dtb files.') + sb.append(' Default is load from the current path.') + print('\n'.join(sb)) + +def print_usage(cmd, _): + """Prints usage for this program. + + Args: + cmd: The string sub-command for which help (usage) is requested. + """ + prog_name = os.path.basename(__file__) + if not cmd: + print_default_usage(prog_name) + return + + HelpCommand = namedtuple('HelpCommand', 'help_cmd, help_func') + help_commands = (HelpCommand('dump', print_dump_usage), + HelpCommand('create', print_create_usage), + HelpCommand('cfg_create', print_cfg_create_usage), + ) + + if cmd == 'all': + print_default_usage(prog_name) + + for help_cmd, help_func in help_commands: + if cmd == 'all' or cmd == help_cmd: + help_func(prog_name) + if cmd != 'all': + return + + print('Unsupported help command: %s' % cmd, end='\n\n') + print_default_usage(prog_name) + return + +def main(): + """Main entry point for mkdtboimg.""" + + parser = argparse.ArgumentParser(prog='mkdtboimg.py') + + subparser = parser.add_subparsers(title='subcommand', + description='Valid subcommands') + + create_parser = subparser.add_parser('create', add_help=False) + create_parser.add_argument('argfile', nargs='?', + action='store', help='Output File', + type=argparse.FileType('wb')) + create_parser.set_defaults(func=create_dtbo_image) + + config_parser = subparser.add_parser('cfg_create', add_help=False) + config_parser.add_argument('argfile', nargs='?', + action='store', + type=argparse.FileType('wb')) + config_parser.set_defaults(func=create_dtbo_image_from_config) + + dump_parser = subparser.add_parser('dump', add_help=False) + dump_parser.add_argument('argfile', nargs='?', + action='store', + type=argparse.FileType('rb')) + dump_parser.set_defaults(func=dump_dtbo_image) + + help_parser = subparser.add_parser('help', add_help=False) + help_parser.add_argument('argfile', nargs='?', action='store') + help_parser.set_defaults(func=print_usage) + + (subcmd, subcmd_args) = parser.parse_known_args() + subcmd.func(subcmd.argfile, subcmd_args) + +if __name__ == '__main__': + main() diff --git a/utils/tests/data/mkdtboimg.cfg b/utils/tests/data/mkdtboimg.cfg new file mode 100644 index 0000000..a5e8c2d --- /dev/null +++ b/utils/tests/data/mkdtboimg.cfg @@ -0,0 +1,18 @@ +# Global options + page_size=4096 + id=0x100 # Read the value form the path in dtb + rev=0x100 # Read the value form the path in dtb + custom0=0xabc # default value + +board1v1.dts.dtb + +board1v1_1.dts.dtb + id=0xddccbbaa # override with another path + rev=0x01000100 # override default rev + +board2v1.dts.dtb + id=0x200 + rev=0x201 # override with another value + +board1v1.dts.dtb + custom0=0xdef # override with another value diff --git a/utils/tests/mkdtboimg_testdata.sh b/utils/tests/mkdtboimg_testdata.sh new file mode 100755 index 0000000..50cafe2 --- /dev/null +++ b/utils/tests/mkdtboimg_testdata.sh @@ -0,0 +1,108 @@ +#! /bin/bash +# Copyright (C) 2017 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +SRCDIR="data" +DTS_LIST=" + board1v1.dts + board1v1_1.dts + board2v1.dts +" +DTB_LIST=( + "board1v1.dts.dtb" + "board1v1_1.dts.dtb" + "board2v1.dts.dtb" + "board1v1.dts.dtb" +) +CONFIG="${SRCDIR}/mkdtimg.cfg" +PYCONFIG="${SRCDIR}/mkdtboimg.cfg" + +ALIGN=4 + +OUTDIR="out" +MKDTIMG_OUT="${OUTDIR}/mkdtimg_out" +MKDTIMG_DUMP="${MKDTIMG_OUT}"/dump.dtb + +MKDTBOIMG_OUT="${OUTDIR}/mkdtboimg_out" +MKDTBOIMG_OUTCREATE="${MKDTBOIMG_OUT}/create" +MKDTBOIMG_OUTCFG="${MKDTBOIMG_OUT}/cfg_create" +MKDTBOIMG_CREATEDUMP="${MKDTBOIMG_OUTCREATE}"/dump.dtb +MKDTBOIMG_CFGDUMP="${MKDTBOIMG_OUTCFG}"/dump.dtb + +mkdir -p "$MKDTIMG_OUT" +mkdir -p "$MKDTBOIMG_OUTCREATE" +mkdir -p "$MKDTBOIMG_OUTCFG" + +for dts in ${DTS_LIST}; do + echo "Building $dts..." + src_dts="${SRCDIR}/${dts}" + out_dtb="${OUTDIR}/${dts}.dtb" + dtc -O dtb -@ -qq -a "$ALIGN" -o "$out_dtb" "$src_dts" +done + +echo "Creating dtbo image with mkdtbimg" +mkdtimg create ${MKDTIMG_OUT}/create.img --page_size=4096 --id=0x100 \ + --rev=0x100 --custom0=0xabc "${OUTDIR}/board1v1.dts.dtb" "${OUTDIR}/board1v1_1.dts.dtb" \ + --id=0xddccbbaa --rev=0x01000100 "${OUTDIR}/board2v1.dts.dtb" --id=0x200 \ + --rev=0x201 "${OUTDIR}/board1v1.dts.dtb" --custom0=0xdef > /dev/null + +echo "Creating dtbo image with mkdtboimg" +../src/mkdtboimg.py create ${MKDTBOIMG_OUTCREATE}/create.img --page_size=4096 \ + --id=0x100 --rev=0x100 --custom0=0xabc "${OUTDIR}/board1v1.dts.dtb" \ + "${OUTDIR}/board1v1_1.dts.dtb" --id=0xddccbbaa --rev=0x01000100 \ + "${OUTDIR}/board2v1.dts.dtb" --id=0x200 --rev=0x201 \ + "${OUTDIR}/board1v1.dts.dtb" --custom0=0xdef > /dev/null + +echo "Creating dtbo image with ${PYCONFIG} config file" +../src/mkdtboimg.py cfg_create ${MKDTBOIMG_OUTCFG}/create.img ${PYCONFIG} --dtb-dir "${OUTDIR}" + +echo "Dumping fragments from mkdtimg tool image" +mkdtimg dump ${MKDTIMG_OUT}/create.img -b "${MKDTIMG_DUMP}"| grep -v 'FDT' > ${MKDTIMG_OUT}/create.dump + +echo "Dumping fragments from mkdtboimg.py tool for image generated with 'create'" +../src/mkdtboimg.py dump ${MKDTBOIMG_OUTCREATE}/create.img --output ${MKDTBOIMG_OUTCREATE}/create.dump -b "${MKDTBOIMG_CREATEDUMP}" + +echo "Dumping fragments from mkdtboimg.py tool for image generated with 'cfg_create'" +../src/mkdtboimg.py dump ${MKDTBOIMG_OUTCFG}/create.img --output ${MKDTBOIMG_OUTCFG}/create.dump -b "${MKDTBOIMG_CFGDUMP}" + +echo "======================================================================================" +echo "Testing differences between image created by 'create' for 'mkdtimg' and 'mkdtboimg.py'" +echo "======================================================================================" +for x in `ls -1 ${MKDTIMG_DUMP}.*` +do + file=`basename $x` + if [ ! -e ${MKDTBOIMG_OUTCREATE}/$file ] + then + continue + fi + echo "diff $x vs ${MKDTBOIMG_OUTCREATE}/$file" + diff $x ${MKDTBOIMG_OUTCREATE}/$file +done +echo "diff ${MKDTIMG_OUT}/create.dump vs ${MKDTBOIMG_OUTCREATE}/create.dump"; +diff ${MKDTIMG_OUT}/create.dump ${MKDTBOIMG_OUTCREATE}/create.dump +echo "==========================================================================================" +echo "Testing differences between image created by 'cfg_create' for 'mkdtimg' and 'mkdtboimg.py'" +echo "==========================================================================================" +for x in `ls -1 ${MKDTIMG_DUMP}.*` +do + file=`basename $x` + if [ ! -e ${MKDTBOIMG_OUTCFG}/$file ] + then + continue + fi + echo "diff $x vs ${MKDTBOIMG_OUTCFG}/$file" + diff $x ${MKDTBOIMG_OUTCFG}/$file +done +echo "diff ${MKDTIMG_OUT}/create.dump vs ${MKDTBOIMG_OUTCFG}/create.dump"; +diff ${MKDTIMG_OUT}/create.dump ${MKDTBOIMG_OUTCFG}/create.dump |