From 7e73d2e9aeb63a0420a96b8ac86f6aca1a084846 Mon Sep 17 00:00:00 2001 From: "Christopher N. Hesse" Date: Fri, 30 Dec 2016 00:11:33 +0100 Subject: [PATCH] dtbhtool: Split out dtimg components Factor out DT image creation code into a small host library. Create a new host binary which allows us to create device tree blob (DTB) images. Change-Id: I5424684ad467b952df8b2ccf3afbacdec03e88c9 --- dtbhtool/Android.mk | 26 +++- dtbhtool/dtbimg.c | 295 ++++++++++++++++++++++++++++++++++++ dtbhtool/libdtbimg/dtbimg.h | 30 ++++ dtbhtool/mkbootimg.c | 229 +--------------------------- dtbhtool/mkdtbimg.c | 126 +++++++++++++++ 5 files changed, 474 insertions(+), 232 deletions(-) create mode 100644 dtbhtool/dtbimg.c create mode 100644 dtbhtool/libdtbimg/dtbimg.h create mode 100644 dtbhtool/mkdtbimg.c diff --git a/dtbhtool/Android.mk b/dtbhtool/Android.mk index 03d63c01..c60b2c5b 100644 --- a/dtbhtool/Android.mk +++ b/dtbhtool/Android.mk @@ -1,9 +1,19 @@ LOCAL_PATH:= $(call my-dir) include $(CLEAR_VARS) -LOCAL_SRC_FILES := mkbootimg.c -LOCAL_STATIC_LIBRARIES := libfdt libmincrypt +LOCAL_SRC_FILES := dtbimg.c +LOCAL_STATIC_LIBRARIES := libfdt LOCAL_C_INCLUDES := $(LOCAL_PATH)/libfdt +LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/libdtbimg + +LOCAL_MODULE := libdtbimg + +include $(BUILD_HOST_STATIC_LIBRARY) + +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := mkbootimg.c +LOCAL_STATIC_LIBRARIES := libdtbimg libfdt libmincrypt LOCAL_MODULE := mkdtbhbootimg @@ -14,10 +24,18 @@ LOCAL_SRC_FILES := unpackbootimg.c LOCAL_MODULE := unpackbootimg include $(BUILD_HOST_EXECUTABLE) +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := mkdtbimg.c +LOCAL_STATIC_LIBRARIES := libdtbimg libfdt + +LOCAL_MODULE := dtbhtoolExynos + +include $(BUILD_HOST_EXECUTABLE) + include $(CLEAR_VARS) LOCAL_SRC_FILES := mkbootimg.c -LOCAL_STATIC_LIBRARIES := libfdt libmincrypt libcutils libc -LOCAL_C_INCLUDES := $(LOCAL_PATH)/libfdt +LOCAL_STATIC_LIBRARIES := libdtbimg libfdt libmincrypt libcutils libc LOCAL_MODULE := utility_mkdtbhbootimg LOCAL_MODULE_TAGS := eng LOCAL_MODULE_STEM := mkdtbhbootimg diff --git a/dtbhtool/dtbimg.c b/dtbhtool/dtbimg.c new file mode 100644 index 00000000..a85c9016 --- /dev/null +++ b/dtbhtool/dtbimg.c @@ -0,0 +1,295 @@ +/* tools/mkbootimg/dtbimg.c +** +** Copyright 2007, The Android Open Source Project +** Copyright 2013, Sony Mobile Communications +** +** 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. +** +** December 2016, Christopher N. Hesse +** Separate dt creation from mkbootimg program. +*/ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +/* must be provided by the device tree */ +#include + +#include "libfdt.h" + +struct dt_blob; + +struct dt_entry { + uint32_t chip; + uint32_t platform; + uint32_t subtype; + uint32_t hw_rev; + uint32_t hw_rev_end; + uint32_t offset; + uint32_t size; /* including padding */ + uint32_t space; + + struct dt_blob *blob; +}; + +/* + * Comparator for sorting dt_entries + */ +static int dt_entry_cmp(const void *ap, const void *bp) +{ + struct dt_entry *a = (struct dt_entry*)ap; + struct dt_entry *b = (struct dt_entry*)bp; + + if (a->chip != b->chip) + return a->chip - b->chip; + return a->hw_rev - b->hw_rev; +} + +/* + * In memory representation of a dtb blob + */ +struct dt_blob { + uint32_t size; + uint32_t offset; + + void *payload; + struct dt_blob *next; +}; + +static void *load_file(const char *fn, unsigned *_sz) +{ + char *data; + int sz; + int fd; + + data = 0; + fd = open(fn, O_RDONLY); + if(fd < 0) return 0; + + sz = lseek(fd, 0, SEEK_END); + if(sz < 0) goto oops; + + if(lseek(fd, 0, SEEK_SET) != 0) goto oops; + + data = (char*) malloc(sz); + if(data == 0) goto oops; + + if(read(fd, data, sz) != sz) goto oops; + close(fd); + + if(_sz) *_sz = sz; + return data; + +oops: + close(fd); + if(data != 0) free(data); + return 0; +} + +void *load_dtbh_block(const char *dtb_path, unsigned pagesize, unsigned *_sz) +{ + const unsigned pagemask = pagesize - 1; + struct dt_entry *new_entries; + struct dt_entry *entries = NULL; + struct dt_entry *entry; + struct dt_blob *blob; + struct dt_blob *blob_list = NULL; + struct dt_blob *last_blob = NULL; + struct dirent *de; + unsigned new_count; + unsigned entry_count = 0; + unsigned offset; + unsigned dtb_sz; + unsigned hdr_sz = DT_HEADER_PHYS_SIZE; + uint32_t version = DTBH_VERSION; + unsigned blob_sz = 0; + char fname[PATH_MAX]; + const unsigned *prop_chip; + const unsigned *prop_platform; + const unsigned *prop_subtype; + const unsigned *prop_hw_rev; + const unsigned *prop_hw_rev_end; + int namlen; + int len; + void *dtb; + char *dtbh; + DIR *dir; + unsigned c; + + dir = opendir(dtb_path); + + if (dir == NULL) + err(1, "failed to open '%s'", dtb_path); + + while ((de = readdir(dir)) != NULL) { + namlen = strlen(de->d_name); + if (namlen < 4 || strcmp(&de->d_name[namlen - 4], ".dtb")) + continue; + + snprintf(fname, sizeof(fname), "%s/%s", dtb_path, de->d_name); + + dtb = load_file(fname, &dtb_sz); + if (dtb == NULL) + err(1, "failed to read dtb '%s'", fname); + + if (fdt_check_header(dtb) != 0) { + warnx("'%s' is not a valid dtb, skipping", fname); + free(dtb); + continue; + } + + offset = fdt_path_offset(dtb, "/"); + prop_chip = fdt_getprop(dtb, offset, "model_info-chip", &len); + if (len % (sizeof(uint32_t)) != 0) { + warnx("model_info-chip of %s is of invalid size, skipping", fname); + free(dtb); + continue; + } + + prop_platform = fdt_getprop(dtb, offset, "model_info-platform", &len); + if (strcmp((char *)&prop_platform[0], DTBH_PLATFORM)) { + warnx("model_info-platform of %s is invalid, skipping", fname); + free(dtb); + continue; + } + + prop_subtype = fdt_getprop(dtb, offset, "model_info-subtype", &len); + if (strcmp((char *)&prop_subtype[0], DTBH_SUBTYPE)) { + warnx("model_info-subtype of %s is invalid, skipping", fname); + free(dtb); + continue; + } + + prop_hw_rev = fdt_getprop(dtb, offset, "model_info-hw_rev", &len); + if (len % (sizeof(uint32_t)) != 0) { + warnx("model_info-hw_rev of %s is of invalid size, skipping", fname); + free(dtb); + continue; + } + + prop_hw_rev_end = fdt_getprop(dtb, offset, "model_info-hw_rev_end", &len); + if (len % (sizeof(uint32_t)) != 0) { + warnx("model_info-hw_rev_end of %s is of invalid size, skipping", fname); + free(dtb); + continue; + } + + blob = calloc(1, sizeof(struct dt_blob)); + if (blob == NULL) + err(1, "failed to allocate memory"); + + blob->payload = dtb; + blob->size = dtb_sz; + if (blob_list == NULL) { + blob_list = blob; + last_blob = blob; + } else { + last_blob->next = blob; + last_blob = blob; + } + + blob_sz += (blob->size + pagemask) & ~pagemask; + new_count = entry_count + 1; + new_entries = realloc(entries, new_count * sizeof(struct dt_entry)); + if (new_entries == NULL) + err(1, "failed to allocate memory"); + + entries = new_entries; + entry = &entries[entry_count]; + memset(entry, 0, sizeof(*entry)); + entry->chip = ntohl(prop_chip[0]); + entry->platform = DTBH_PLATFORM_CODE; + entry->subtype = DTBH_SUBTYPE_CODE; + entry->hw_rev = ntohl(prop_hw_rev[0]); + entry->hw_rev_end = ntohl(prop_hw_rev_end[0]); + entry->space = 0x20; /* space delimiter */ + entry->blob = blob; + + entry_count++; + + hdr_sz += entry_count * DT_ENTRY_PHYS_SIZE; + } + + closedir(dir); + + if (entry_count == 0) { + warnx("unable to locate any dtbs in the given path"); + return NULL; + } + + hdr_sz += sizeof(uint32_t); /* eot marker */ + hdr_sz = (hdr_sz + pagemask) & ~pagemask; + + qsort(entries, entry_count, sizeof(struct dt_entry), dt_entry_cmp); + + /* The size of the dt header is now known, calculate the blob offsets... */ + offset = hdr_sz; + for (blob = blob_list; blob; blob = blob->next) { + blob->offset = offset; + offset += (blob->size + pagemask) & ~pagemask; + } + + /* ...and update the entries */ + for (c = 0; c < entry_count; c++) { + entry = &entries[c]; + + entry->offset = entry->blob->offset; + entry->size = (entry->blob->size + pagemask) & ~pagemask; + } + + /* + * All parts are now gathered, so build the dt block + */ + dtbh = calloc(hdr_sz + blob_sz, 1); + if (dtbh == NULL) + err(1, "failed to allocate memory"); + + offset = 0; + + memcpy(dtbh, DTBH_MAGIC, sizeof(uint32_t)); + memcpy(dtbh + sizeof(uint32_t), &version, sizeof(uint32_t)); + memcpy(dtbh + (sizeof(uint32_t) * 2), &entry_count, sizeof(uint32_t)); + + offset += DT_HEADER_PHYS_SIZE; + + /* add dtbh entries */ + for (c = 0; c < entry_count; c++) { + entry = &entries[c]; + memcpy(dtbh + offset, entry, DT_ENTRY_PHYS_SIZE); + offset += DT_ENTRY_PHYS_SIZE; + } + + /* add padding after dt header */ + offset += pagesize - (offset & pagemask); + + for (blob = blob_list; blob; blob = blob->next) { + memcpy(dtbh + offset, blob->payload, blob->size); + offset += (blob->size + pagemask) & ~pagemask; + } + + *_sz = hdr_sz + blob_sz; + + return dtbh; +} diff --git a/dtbhtool/libdtbimg/dtbimg.h b/dtbhtool/libdtbimg/dtbimg.h new file mode 100644 index 00000000..4bf9db82 --- /dev/null +++ b/dtbhtool/libdtbimg/dtbimg.h @@ -0,0 +1,30 @@ +/* tools/libdtbimg/dtbimg.h +** +** Copyright 2017, The LineageOS 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. +*/ + +#ifndef _DTBIMG_H_ +#define _DTBIMG_H_ + +/* + * Returns dt image data. + * + * dtb_path: path to the compiled device tree blobs + * pagesize: board pagesize + * _sz: size of the resulting dt image + */ +void *load_dtbh_block(const char *dtb_path, unsigned pagesize, unsigned *_sz); + +#endif // _DTBIMG_H_ diff --git a/dtbhtool/mkbootimg.c b/dtbhtool/mkbootimg.c index 0efe4ac6..bb1528e1 100644 --- a/dtbhtool/mkbootimg.c +++ b/dtbhtool/mkbootimg.c @@ -34,52 +34,11 @@ #include #include -/* must be provided by the device tree */ -#include +#include -#include "libfdt.h" #include "mincrypt/sha.h" #include "bootimg.h" -struct dt_blob; - -struct dt_entry { - uint32_t chip; - uint32_t platform; - uint32_t subtype; - uint32_t hw_rev; - uint32_t hw_rev_end; - uint32_t offset; - uint32_t size; /* including padding */ - uint32_t space; - - struct dt_blob *blob; -}; - -/* - * Comparator for sorting dt_entries - */ -static int dt_entry_cmp(const void *ap, const void *bp) -{ - struct dt_entry *a = (struct dt_entry*)ap; - struct dt_entry *b = (struct dt_entry*)bp; - - if (a->chip != b->chip) - return a->chip - b->chip; - return a->hw_rev - b->hw_rev; -} - -/* - * In memory representation of a dtb blob - */ -struct dt_blob { - uint32_t size; - uint32_t offset; - - void *payload; - struct dt_blob *next; -}; - static void *load_file(const char *fn, unsigned *_sz) { char *data; @@ -110,192 +69,6 @@ oops: return 0; } -static void *load_dtbh_block(const char *dtb_path, unsigned pagesize, unsigned *_sz) -{ - const unsigned pagemask = pagesize - 1; - struct dt_entry *new_entries; - struct dt_entry *entries = NULL; - struct dt_entry *entry; - struct dt_blob *blob; - struct dt_blob *blob_list = NULL; - struct dt_blob *last_blob = NULL; - struct dirent *de; - unsigned new_count; - unsigned entry_count = 0; - unsigned offset; - unsigned dtb_sz; - unsigned hdr_sz = DT_HEADER_PHYS_SIZE; - uint32_t version = DTBH_VERSION; - unsigned blob_sz = 0; - char fname[PATH_MAX]; - const unsigned *prop_chip; - const unsigned *prop_platform; - const unsigned *prop_subtype; - const unsigned *prop_hw_rev; - const unsigned *prop_hw_rev_end; - int namlen; - int len; - void *dtb; - char *dtbh; - DIR *dir; - unsigned c; - - dir = opendir(dtb_path); - - if (dir == NULL) - err(1, "failed to open '%s'", dtb_path); - - while ((de = readdir(dir)) != NULL) { - namlen = strlen(de->d_name); - if (namlen < 4 || strcmp(&de->d_name[namlen - 4], ".dtb")) - continue; - - snprintf(fname, sizeof(fname), "%s/%s", dtb_path, de->d_name); - - dtb = load_file(fname, &dtb_sz); - if (dtb == NULL) - err(1, "failed to read dtb '%s'", fname); - - if (fdt_check_header(dtb) != 0) { - warnx("'%s' is not a valid dtb, skipping", fname); - free(dtb); - continue; - } - - offset = fdt_path_offset(dtb, "/"); - prop_chip = fdt_getprop(dtb, offset, "model_info-chip", &len); - if (len % (sizeof(uint32_t)) != 0) { - warnx("model_info-chip of %s is of invalid size, skipping", fname); - free(dtb); - continue; - } - - prop_platform = fdt_getprop(dtb, offset, "model_info-platform", &len); - if (strcmp((char *)&prop_platform[0], DTBH_PLATFORM)) { - warnx("model_info-platform of %s is invalid, skipping", fname); - free(dtb); - continue; - } - - prop_subtype = fdt_getprop(dtb, offset, "model_info-subtype", &len); - if (strcmp((char *)&prop_subtype[0], DTBH_SUBTYPE)) { - warnx("model_info-subtype of %s is invalid, skipping", fname); - free(dtb); - continue; - } - - prop_hw_rev = fdt_getprop(dtb, offset, "model_info-hw_rev", &len); - if (len % (sizeof(uint32_t)) != 0) { - warnx("model_info-hw_rev of %s is of invalid size, skipping", fname); - free(dtb); - continue; - } - - prop_hw_rev_end = fdt_getprop(dtb, offset, "model_info-hw_rev_end", &len); - if (len % (sizeof(uint32_t)) != 0) { - warnx("model_info-hw_rev_end of %s is of invalid size, skipping", fname); - free(dtb); - continue; - } - - blob = calloc(1, sizeof(struct dt_blob)); - if (blob == NULL) - err(1, "failed to allocate memory"); - - blob->payload = dtb; - blob->size = dtb_sz; - if (blob_list == NULL) { - blob_list = blob; - last_blob = blob; - } else { - last_blob->next = blob; - last_blob = blob; - } - - blob_sz += (blob->size + pagemask) & ~pagemask; - new_count = entry_count + 1; - new_entries = realloc(entries, new_count * sizeof(struct dt_entry)); - if (new_entries == NULL) - err(1, "failed to allocate memory"); - - entries = new_entries; - entry = &entries[entry_count]; - memset(entry, 0, sizeof(*entry)); - entry->chip = ntohl(prop_chip[0]); - entry->platform = DTBH_PLATFORM_CODE; - entry->subtype = DTBH_SUBTYPE_CODE; - entry->hw_rev = ntohl(prop_hw_rev[0]); - entry->hw_rev_end = ntohl(prop_hw_rev_end[0]); - entry->space = 0x20; /* space delimiter */ - entry->blob = blob; - - entry_count++; - - hdr_sz += entry_count * DT_ENTRY_PHYS_SIZE; - } - - closedir(dir); - - if (entry_count == 0) { - warnx("unable to locate any dtbs in the given path"); - return NULL; - } - - hdr_sz += sizeof(uint32_t); /* eot marker */ - hdr_sz = (hdr_sz + pagemask) & ~pagemask; - - qsort(entries, entry_count, sizeof(struct dt_entry), dt_entry_cmp); - - /* The size of the dt header is now known, calculate the blob offsets... */ - offset = hdr_sz; - for (blob = blob_list; blob; blob = blob->next) { - blob->offset = offset; - offset += (blob->size + pagemask) & ~pagemask; - } - - /* ...and update the entries */ - for (c = 0; c < entry_count; c++) { - entry = &entries[c]; - - entry->offset = entry->blob->offset; - entry->size = (entry->blob->size + pagemask) & ~pagemask; - } - - /* - * All parts are now gathered, so build the dt block - */ - dtbh = calloc(hdr_sz + blob_sz, 1); - if (dtbh == NULL) - err(1, "failed to allocate memory"); - - offset = 0; - - memcpy(dtbh, DTBH_MAGIC, sizeof(uint32_t)); - memcpy(dtbh + sizeof(uint32_t), &version, sizeof(uint32_t)); - memcpy(dtbh + (sizeof(uint32_t) * 2), &entry_count, sizeof(uint32_t)); - - offset += DT_HEADER_PHYS_SIZE; - - /* add dtbh entries */ - for (c = 0; c < entry_count; c++) { - entry = &entries[c]; - memcpy(dtbh + offset, entry, DT_ENTRY_PHYS_SIZE); - offset += DT_ENTRY_PHYS_SIZE; - } - - /* add padding after dt header */ - offset += pagesize - (offset & pagemask); - - for (blob = blob_list; blob; blob = blob->next) { - memcpy(dtbh + offset, blob->payload, blob->size); - offset += (blob->size + pagemask) & ~pagemask; - } - - *_sz = hdr_sz + blob_sz; - - return dtbh; -} - int usage(void) { fprintf(stderr,"usage: mkbootimg\n" diff --git a/dtbhtool/mkdtbimg.c b/dtbhtool/mkdtbimg.c new file mode 100644 index 00000000..d5fda12d --- /dev/null +++ b/dtbhtool/mkdtbimg.c @@ -0,0 +1,126 @@ +/* tools/mkbootimg/mkdtbimg.c +** +** Copyright 2016-2017, The LineageOS 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. +** +** December 2016, Christopher N. Hesse +** Separate dt creation from mkbootimg program. +** +** January 2017, Christopher N. Hesse +** Adjust to dtbToolCM call syntax. +*/ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include + +int usage(void) +{ + fprintf(stderr,"usage: mkdtimg\n" + " --dt_dir \n" + " -o|--output \n" + ); + return 1; +} + + + +int main(int argc, char **argv) +{ + char *dtimg = 0; + char *dt_dir = 0; + void *dt_data = 0; + unsigned pagesize = 0; + unsigned default_pagesize = 2048; + uint32_t dt_size; + int fd; + struct stat sbuf; + + argc--; + argv++; + + while(argc > 0){ + char *arg = argv[0]; + char *val = argv[1]; + if(argc < 1) { + return usage(); + } + argc -= 2; + argv += 2; + if(!strcmp(arg, "--output") || !strcmp(arg, "-o")) { + dtimg = val; + } else if (!strcmp(arg, "--dt_dir")) { + dt_dir = val; + } else if (!strcmp(arg, "-p")) { + // Ignore this parameter + } else if (!strcmp(arg, "-s")) { + pagesize = strtol(val, NULL, 10); + if (pagesize == 0) + pagesize = default_pagesize; + } else { + // Check if this is the dtb path + int err = stat(arg, &sbuf); + if (err != 0 || !S_ISDIR(sbuf.st_mode)) + return usage(); + dt_dir = arg; + } + } + + if(dtimg == 0) { + fprintf(stderr,"error: no output filename specified\n"); + return usage(); + } + + if(dt_dir == 0) { + fprintf(stderr,"error: no dtb path specified\n"); + return usage(); + } + + dt_data = load_dtbh_block(dt_dir, pagesize, &dt_size); + if (dt_data == 0) { + fprintf(stderr, "error: could not load device tree blobs '%s'\n", dt_dir); + return 1; + } + + fd = open(dtimg, O_CREAT | O_TRUNC | O_WRONLY, 0644); + if(fd < 0) { + fprintf(stderr,"error: could not create '%s'\n", dtimg); + return 1; + } + + if(write(fd, dt_data, dt_size) != dt_size) goto fail; + + return 0; + +fail: + unlink(dtimg); + close(fd); + fprintf(stderr,"error: failed writing '%s': %s\n", dtimg, + strerror(errno)); + return 1; +}