From 0fd50c896e4bc1556ae18e5b9ced879d4648d4e7 Mon Sep 17 00:00:00 2001 From: Vachounet Date: Sun, 20 Aug 2017 16:26:52 +0200 Subject: [PATCH] potter: switch to oss dtbTool Change-Id: Iac9a00d6d446eeb689f331e77adbf616e9dea79e --- BoardConfig.mk | 2 +- dtbtool/Android.mk | 18 +- dtbtool/dtbTool_moto | Bin 35864 -> 0 bytes dtbtool/dtbtool.c | 1110 ++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 1125 insertions(+), 5 deletions(-) delete mode 100644 dtbtool/dtbTool_moto create mode 100644 dtbtool/dtbtool.c diff --git a/BoardConfig.mk b/BoardConfig.mk index 299684e..f825a9b 100644 --- a/BoardConfig.mk +++ b/BoardConfig.mk @@ -50,7 +50,7 @@ BOARD_KERNEL_CMDLINE += ehci-hcd.park=3 androidboot.bootdevice=7824900.sdhci lpm BOARD_KERNEL_BASE := 0x80000000 BOARD_KERNEL_PAGESIZE := 2048 BOARD_KERNEL_SEPARATED_DT := true -TARGET_CUSTOM_DTBTOOL := dtbTool_moto +TARGET_CUSTOM_DTBTOOL := dtbTool_custom BOARD_MKBOOTIMG_ARGS := --ramdisk_offset 0x01000000 --tags_offset 0x00000100 TARGET_KERNEL_ARCH := arm TARGET_KERNEL_CONFIG := potter_defconfig diff --git a/dtbtool/Android.mk b/dtbtool/Android.mk index e873245..c83105f 100644 --- a/dtbtool/Android.mk +++ b/dtbtool/Android.mk @@ -1,7 +1,17 @@ +ifeq ($(BOARD_KERNEL_SEPARATED_DT),true) LOCAL_PATH := $(call my-dir) + include $(CLEAR_VARS) -LOCAL_MODULE := dtbTool_moto -LOCAL_PREBUILT_MODULE_FILE := $(LOCAL_PATH)/$(LOCAL_MODULE) -LOCAL_MODULE_CLASS := EXECUTABLES -LOCAL_MODULE_SUFFIX := $(HOST_EXECUTABLE_SUFFIX) + +LOCAL_SRC_FILES := \ + dtbtool.c + +LOCAL_CFLAGS += \ + -Wall + +## Hybrid v1/v2 dtbTool. Use a different name to avoid conflicts with copies in device repos +LOCAL_MODULE := dtbTool_custom +LOCAL_MODULE_TAGS := optional + include $(BUILD_HOST_EXECUTABLE) +endif diff --git a/dtbtool/dtbTool_moto b/dtbtool/dtbTool_moto deleted file mode 100644 index 30be9b8cdced71f6e1de509685b39f4f639dd978..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 35864 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 Z+h1QlIllE({+^A +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define QCDT_MAGIC "QCDT" /* Master DTB magic */ +#define QCDT_VERSION 3 /* QCDT version */ + +#define QCDT_DT_TAG "qcom,msm-id = <" +#define QCDT_BOARD_TAG "qcom,board-id = <" +#define QCDT_PMIC_TAG "qcom,pmic-id = <" +#define QCDT_MODEL_TAG "model = \"" +#define QCDT_QCOM_MODEL_TAG "qcom,model = \"" + + +#define PAGE_SIZE_DEF 2048 +#define PAGE_SIZE_MAX (1024*1024) + +#define log_err(x...) printf(x) +#define log_info(x...) printf(x) +#define log_dbg(x...) { if (verbose) printf(x); } + +#define COPY_BLK 1024 /* File copy block size */ + +#define RC_SUCCESS 0 +#define RC_ERROR -1 + +struct chipInfo_t { + uint32_t chipset; + uint32_t platform; + uint32_t subtype; + uint32_t revNum; + uint32_t pmic_model[4]; + char model[32]; + uint32_t dtb_size; + char *dtb_file; + struct chipInfo_t *prev; + struct chipInfo_t *next; + struct chipInfo_t *master; + int wroteDtb; + uint32_t master_offset; + struct chipInfo_t *t_next; +}; + +struct chipInfo_t *chip_list; + +struct chipId_t { + uint32_t chipset; + uint32_t revNum; + struct chipId_t *next; + struct chipId_t *t_next; +}; + +struct chipSt_t { + uint32_t platform; + uint32_t subtype; + struct chipSt_t *next; + struct chipSt_t *t_next; +}; + +struct chipPt_t { + uint32_t pmic0; + uint32_t pmic1; + uint32_t pmic2; + uint32_t pmic3; + struct chipPt_t *next; + struct chipPt_t *t_next; +}; + +char *input_dir; +char *output_file; +char *dtc_path; +char *dt_tag = QCDT_DT_TAG; +int verbose; +int page_size = PAGE_SIZE_DEF; +int version_override = 0; +int motorola_version = 1; + +void print_help() +{ + log_info("dtbTool version %d (kinda :) )\n", QCDT_VERSION); + log_info("dtbTool [options] -o \n"); + log_info(" options:\n"); + log_info(" --output-file/-o output file\n"); + log_info(" --dtc-path/-p path to dtc\n"); + log_info(" --page-size/-s page size in bytes\n"); + log_info(" --dt-tag/-d alternate QCDT_DT_TAG\n"); + log_info(" --verbose/-v verbose\n"); + log_info(" --force-v2/-2 output dtb v2 format\n"); + log_info(" --force-v3/-3 output dtb v3 format\n"); + log_info(" --motorola/m Motorola dtb version\n"); + log_info(" --help/-h this help screen\n"); +} + +int parse_commandline(int argc, char *const argv[]) +{ + int c; + + struct option long_options[] = { + {"output-file", 1, 0, 'o'}, + {"dtc-path", 1, 0, 'p'}, + {"page-size", 1, 0, 's'}, + {"dt-tag", 1, 0, 'd'}, + {"force-v2", 0, 0, '2'}, + {"force-v3", 0, 0, '3'}, + {"motorola", 1, 0, 'm'}, + {"verbose", 0, 0, 'v'}, + {"help", 0, 0, 'h'}, + {0, 0, 0, 0} + }; + + while ((c = getopt_long(argc, argv, "-o:p:s:d:23m:vh", long_options, NULL)) + != -1) { + switch (c) { + case 1: + if (!input_dir) + input_dir = optarg; + break; + case 'o': + output_file = optarg; + break; + case 'p': + dtc_path = optarg; + break; + case 's': + page_size = atoi(optarg); + if ((page_size <= 0) || (page_size > (PAGE_SIZE_MAX))) { + log_err("Invalid page size (> 0 and <=1MB\n"); + return RC_ERROR; + } + break; + case 'd': + dt_tag = optarg; + break; + case '2': + case '3': + if (version_override != 0) { + log_err("A version output argument may only be passed once\n"); + return RC_ERROR; + } + version_override = c - '0'; + break; + case 'm': + motorola_version = atoi(optarg); + break; + case 'v': + verbose = 1; + break; + case 'h': + default: + return RC_ERROR; + } + } + + if (!output_file) { + log_err("Output file must be specified\n"); + return RC_ERROR; + } + + if (!input_dir) + input_dir = "./"; + + if (!dtc_path) + dtc_path = ""; + + return RC_SUCCESS; +} + +/* Unique entry sorted list add (by chipset->platform->rev) */ +int chip_add(struct chipInfo_t *c) +{ + struct chipInfo_t *x = chip_list; + + if (!chip_list) { + chip_list = c; + c->next = NULL; + c->prev = NULL; + return RC_SUCCESS; + } + + while (1) { + if ((c->chipset < x->chipset) || + ((c->chipset == x->chipset) && + ((c->platform < x->platform) || + ((c->platform == x->platform) && + ((c->subtype < x->subtype) || + ((c->subtype == x->subtype) && + (c->revNum < x->revNum))))))) { + if (!x->prev) { + c->next = x; + c->prev = NULL; + x->prev = c; + chip_list = c; + break; + } else { + c->next = x; + c->prev = x->prev; + x->prev->next = c; + x->prev = c; + break; + } + } + if ((c->chipset == x->chipset) && + (c->platform == x->platform) && + (c->subtype == x->subtype) && + (c->revNum == x->revNum) && + (c->pmic_model[0] == x->pmic_model[0]) && + (c->pmic_model[1] == x->pmic_model[1]) && + (c->pmic_model[2] == x->pmic_model[2]) && + (c->pmic_model[3] == x->pmic_model[3])) { + return RC_ERROR; /* duplicate */ + } + if (!x->next) { + c->prev = x; + c->next = NULL; + x->next = c; + break; + } + x = x->next; + } + return RC_SUCCESS; +} + +void chip_deleteall() +{ + struct chipInfo_t *c = chip_list, *t; + + while (c) { + t = c; + c = c->next; + if (t->dtb_file) + free(t->dtb_file); + free(t); + } +} + +/* + For v1 Extract 'qcom,msm-id' parameter triplet from DTB + qcom,msm-id = ; + + For v2 Extract 'qcom,msm-id', 'qcom,board-id' parameter double from DTB + qcom,msm-id = i.e chipset, revision number; + qcom,board-id = i.e platform and sub-type; + */ + +struct chipInfo_t *getChipInfo(const char *filename, int *num, uint32_t msmversion) +{ + + const char str1[] = "dtc -I dtb -O dts \""; + const char str2[] = "\" 2>&1"; + char *buf, *pos; + char *line = NULL; + char *model = NULL; + size_t line_size; + FILE *pfile; + int llen; + struct chipInfo_t *chip = NULL, *tmp, *chip_t; + uint32_t data[3] = {0, 0, 0}; + uint32_t data_st[2] = {0, 0}; + uint32_t data_pt[4] = {0, 0, 0, 0}; + char *tok, *sptr = NULL; + int i, entryValid, entryEnded; + int count = 0, count1 = 0, count2 = 0, count3 = 0; + int entryValidST, entryEndedST, entryValidDT, entryEndedDT, entryValidPT, entryEndedPT; + struct chipId_t *chipId = NULL, *cId = NULL, *tmp_id = NULL; + struct chipSt_t *chipSt = NULL, *cSt = NULL, *tmp_st = NULL; + struct chipPt_t *chipPt = NULL, *cPt = NULL, *tmp_pt = NULL; + struct chipId_t *chipId_tmp = NULL; + struct chipSt_t *chipSt_tmp = NULL; + struct chipPt_t *chipPt_tmp = NULL; + + line_size = 1024; + line = (char *)malloc(line_size); + if (!line) { + log_err("Out of memory\n"); + return NULL; + } + + llen = sizeof(char) * (strlen(dtc_path) + + strlen(str1) + + strlen(str2) + + strlen(filename) + 1); + buf = (char *)malloc(llen); + if (!buf) { + log_err("Out of memory\n"); + free(line); + return NULL; + } + + strncpy(buf, dtc_path, llen); + strncat(buf, str1, llen); + strncat(buf, filename, llen); + strncat(buf, str2, llen); + + pfile = popen(buf, "r"); + free(buf); + + if (pfile == NULL) { + log_err("... skip, fail to decompile dtb\n"); + } else { + /* Find "qcom,msm-id" */ + while ((llen = getline(&line, &line_size, pfile)) != -1) { + if (msmversion == 1) { + if ((pos = strstr(line, dt_tag)) != NULL) { + pos += strlen(dt_tag); + + entryEnded = 0; + while (1) { + entryValid = 1; + for (i = 0; i < 3; i++) { + tok = strtok_r(pos, " \t", &sptr); + pos = NULL; + if (tok != NULL) { + if (*tok == '>') { + entryEnded = 1; + entryValid = 0; + break; + } + data[i] = strtoul(tok, NULL, 0); + } else { + data[i] = 0; + entryValid = 0; + entryEnded = 1; + } + } + if (entryEnded) { + free(line); + pclose(pfile); + *num = count; + return chip; + } + if (entryValid) { + tmp = (struct chipInfo_t *) + malloc(sizeof(struct chipInfo_t)); + if (!tmp) { + log_err("Out of memory\n"); + break; + } + if (!chip) { + chip = tmp; + chip->t_next = NULL; + } else { + tmp->t_next = chip->t_next; + chip->t_next = tmp; + } + tmp->chipset = data[0]; + tmp->platform = data[1]; + tmp->subtype = 0; + tmp->revNum = data[2]; + tmp->pmic_model[0] = 0; + tmp->pmic_model[1] = 0; + tmp->pmic_model[2] = 0; + tmp->pmic_model[3] = 0; + tmp->dtb_size = 0; + tmp->dtb_file = NULL; + tmp->master = chip; + tmp->wroteDtb = 0; + tmp->master_offset = 0; + count++; + } + } + + log_err("... skip, incorrect '%s' format\n", dt_tag); + break; + } + } else if (msmversion == 2 || msmversion == 3) { + if ((pos = strstr(line, dt_tag)) != NULL) { + pos += strlen(dt_tag); + + entryEndedDT = 0; + for (;entryEndedDT < 1;) { + entryValidDT = 1; + for (i = 0; i < 2; i++) { + tok = strtok_r(pos, " \t", &sptr); + pos = NULL; + if (tok != NULL) { + if (*tok == '>') { + entryEndedDT = 1; + entryValidDT = 0; + break; + } + data_st[i] = strtoul(tok, NULL, 0); + } else { + data_st[i] = 0; + entryValidDT = 0; + entryEndedDT = 1; + } + } + + if (entryValidDT) { + tmp_id = (struct chipId_t *) + malloc(sizeof(struct chipId_t)); + if (!tmp_id) { + log_err("Out of memory\n"); + break; + } + if (!chipId) { + chipId = tmp_id; + cId = tmp_id; + chipId->t_next = NULL; + } else { + tmp_id->t_next = chipId->t_next; + chipId->t_next = tmp_id; + } + tmp_id->chipset = data_st[0]; + tmp_id->revNum= data_st[1]; + count1++; + } + } + } + + if ((pos = strstr(line,QCDT_BOARD_TAG)) != NULL) { + pos += strlen(QCDT_BOARD_TAG); + entryEndedST = 0; + for (;entryEndedST < 1;) { + entryValidST = 1; + for (i = 0; i < 2; i++) { + tok = strtok_r(pos, " \t", &sptr); + pos = NULL; + if (tok != NULL) { + if (*tok == '>') { + entryEndedST = 1; + entryValidST = 0; + break; + } + data_st[i] = strtoul(tok, NULL, 0); + } else { + data_st[i] = 0; + entryValidST = 0; + entryEndedST = 1; + } + } + if (entryValidST) { + tmp_st = (struct chipSt_t *) + malloc(sizeof(struct chipSt_t)); + if (!tmp_st) { + log_err("Out of memory\n"); + break; + } + + if (!chipSt) { + chipSt = tmp_st; + cSt = tmp_st; + chipSt->t_next = NULL; + } else { + tmp_st->t_next = chipSt->t_next; + chipSt->t_next = tmp_st; + } + + tmp_st->platform = data_st[0]; + tmp_st->subtype= data_st[1]; + count2++; + } + } + } + + if ((pos = strstr(line,QCDT_PMIC_TAG)) != NULL) { + pos += strlen(QCDT_PMIC_TAG); + entryEndedPT = 0; + for (;entryEndedPT < 1;) { + entryValidPT = 1; + for (i = 0; i < 4; i++) { + tok = strtok_r(pos, " \t", &sptr); + pos = NULL; + if (tok != NULL) { + if (*tok == '>') { + entryEndedPT = 1; + entryValidPT = 0; + break; + } + data_pt[i] = strtoul(tok, NULL, 0); + } else { + data_pt[i] = 0; + entryValidPT = 0; + entryEndedPT = 1; + } + } + if (entryValidPT) { + tmp_pt = (struct chipPt_t *) + malloc(sizeof(struct chipPt_t)); + if (!tmp_pt) { + log_err("Out of memory\n"); + break; + } + + if (!chipPt) { + chipPt = tmp_pt; + cPt = tmp_pt; + chipPt->t_next = NULL; + } else { + tmp_pt->t_next = chipPt->t_next; + chipPt->t_next = tmp_pt; + } + + tmp_pt->pmic0 = data_pt[0]; + tmp_pt->pmic1 = data_pt[1]; + tmp_pt->pmic2 = data_pt[2]; + tmp_pt->pmic3 = data_pt[3]; + count3++; + } + } + } + + if (motorola_version && (pos = strstr(line,QCDT_MODEL_TAG)) != NULL && strstr(line,QCDT_QCOM_MODEL_TAG) == NULL) { + char *model_end; + int model_len; + + pos += strlen(QCDT_MODEL_TAG); + + if ((model_end=strchr(pos, '"')) != NULL && (model_len=model_end-pos)<32) { + model = malloc(model_len+1); + if (!model) { + log_err("Out of memory\n"); + break; + } + + memset(model, 0, model_len+1); + strncat(model, pos, model_len); + printf("Found model %s\n", model); + } + } + } + } + } + + if (line) + free(line); + + if (count1 == 0) { + log_err("... skip, incorrect '%s' format\n", dt_tag); + return NULL; + } + if (count2 == 0) { + log_err("... skip, incorrect '%s' format\n", QCDT_BOARD_TAG); + return NULL; + } + if (count3 == 0 && msmversion == 3) { + log_err("... skip, incorrect '%s' format\n", QCDT_PMIC_TAG); + return NULL; + } + if (motorola_version && model == NULL) { + log_err("... skip, property '%s' not found\n", QCDT_MODEL_TAG); + return NULL; + } + + tmp_st = cSt; + tmp_pt = cPt; + while (cId != NULL) { + while (cSt != NULL) { + if (msmversion == 3) { + while (cPt != NULL) { + tmp = (struct chipInfo_t *) + malloc(sizeof(struct chipInfo_t)); + if (!tmp) { + log_err("Out of memory\n"); + break; + } + if (!chip) { + chip = tmp; + chip->t_next = NULL; + } else { + tmp->t_next = chip->t_next; + chip->t_next = tmp; + } + + if (motorola_version) { + memset(tmp->model, 0, sizeof(tmp->model)); + strncpy(tmp->model, model, strlen(model)); + } + + tmp->chipset = cId->chipset; + tmp->platform = cSt->platform; + tmp->revNum = cId->revNum; + tmp->subtype = cSt->subtype; + tmp->pmic_model[0] = cPt->pmic0; + tmp->pmic_model[1] = cPt->pmic1; + tmp->pmic_model[2] = cPt->pmic2; + tmp->pmic_model[3] = cPt->pmic3; + tmp->dtb_size = 0; + tmp->dtb_file = NULL; + tmp->master = chip; + tmp->wroteDtb = 0; + tmp->master_offset = 0; + cPt = cPt->t_next; + } + cPt = tmp_pt; + } else { + tmp = (struct chipInfo_t *) + malloc(sizeof(struct chipInfo_t)); + if (!tmp) { + log_err("Out of memory\n"); + break; + } + if (!chip) { + chip = tmp; + chip->t_next = NULL; + } else { + tmp->t_next = chip->t_next; + chip->t_next = tmp; + } + + if (motorola_version) { + memset(tmp->model, 0, sizeof(tmp->model)); + strncpy(tmp->model, model, strlen(model)); + } + + tmp->chipset = cId->chipset; + tmp->platform = cSt->platform; + tmp->revNum = cId->revNum; + tmp->subtype = cSt->subtype; + tmp->pmic_model[0] = 0; + tmp->pmic_model[1] = 0; + tmp->pmic_model[2] = 0; + tmp->pmic_model[3] = 0; + tmp->dtb_size = 0; + tmp->dtb_file = NULL; + tmp->master = chip; + tmp->wroteDtb = 0; + tmp->master_offset = 0; + } + cSt = cSt->t_next; + } + cSt = tmp_st; + cId = cId->t_next; + } + + if (msmversion == 2) + entryEndedPT = 1; + + /* clear memory*/ + pclose(pfile); + while (chipId) { + chipId_tmp = chipId; + chipId = chipId->t_next; + free(chipId_tmp); + } + while (chipSt) { + chipSt_tmp= chipSt; + chipSt = chipSt->t_next; + free(chipSt_tmp); + } + + while (chipPt) { + chipPt_tmp= chipPt; + chipPt = chipPt->t_next; + free(chipPt_tmp); + } + + if (model) + free(model); + + if (entryEndedST == 1 && entryEndedDT == 1 && entryEndedPT == 1) { + *num = count1; + return chip; + } + + /* clear memory*/ + while (chip) { + chip_t = chip; + chip = chip->next; + if (chip_t->dtb_file) + free(chip_t->dtb_file); + free(chip_t); + } + return NULL; +} + +/* Get the version-id based on dtb files */ +uint32_t GetVersionInfo(const char *filename) +{ + const char str1[] = "dtc -I dtb -O dts \""; + const char str2[] = "\" 2>&1"; + char *buf, *pos; + char *line = NULL; + size_t line_size; + FILE *pfile; + int llen; + uint32_t v = 1; + + line_size = 1024; + line = (char *)malloc(line_size); + if (!line) { + log_err("Out of memory\n"); + return 0; + } + + llen = sizeof(char) * (strlen(dtc_path) + + strlen(str1) + + strlen(str2) + + strlen(filename) + 1); + buf = (char *)malloc(llen); + if (!buf) { + log_err("Out of memory\n"); + free(line); + return 0; + } + + strncpy(buf, dtc_path, llen); + strncat(buf, str1, llen); + strncat(buf, filename, llen); + strncat(buf, str2, llen); + + pfile = popen(buf, "r"); + free(buf); + + if (pfile == NULL) { + log_err("... skip, fail to decompile dtb\n"); + } else { + /* Find the type of version */ + while ((llen = getline(&line, &line_size, pfile)) != -1) { + if ((pos = strstr(line,QCDT_BOARD_TAG)) != NULL) { + v = 2; + } + if ((pos = strstr(line,QCDT_PMIC_TAG)) != NULL) { + v = 3; + break; + } + } + } + + free(line); + log_info("Version:%d\n", v); + + return v; +} + +static int find_dtb(const char *path, uint32_t *version) +{ + struct dirent *dp; + int flen; + char *filename; + struct chipInfo_t *chip, *t_chip; + struct stat st; + int num; + int rc = RC_SUCCESS; + uint32_t msmversion = 0; + int dtb_count = 0; + + DIR *dir = opendir(path); + if (!dir) { + log_err("Failed to open input directory '%s'\n", path); + return RC_ERROR; + } + + /* Open the .dtb files in the specified path, decompile and + extract "qcom,msm-id" parameter + */ + while ((dp = readdir(dir)) != NULL) { + if (dp->d_type == DT_UNKNOWN) { + struct stat statbuf; + char name[PATH_MAX]; + snprintf(name, sizeof(name), "%s%s%s", + path, + (path[strlen(path) - 1] == '/' ? "" : "/"), + dp->d_name); + if (!stat(name, &statbuf)) { + if (S_ISREG(statbuf.st_mode)) { + dp->d_type = DT_REG; + } else if (S_ISDIR(statbuf.st_mode)) { + dp->d_type = DT_DIR; + } + } + } + + if (dp->d_type == DT_DIR) { + char name[PATH_MAX]; + if (dp->d_name[0] == '.') { + continue; + } + snprintf(name, sizeof(name), "%s%s%s%s", + path, + (path[strlen(path) - 1] == '/' ? "" : "/"), + dp->d_name, + "/"); + log_info("Searching subdir: %s ... \n", name); + dtb_count += find_dtb(name, version); + } else if (dp->d_type == DT_REG) { + flen = strlen(dp->d_name); + if ((flen > 4) && + (strncmp(&dp->d_name[flen-4], ".dtb", 4) == 0)) { + log_info("Found file: %s ... \n", dp->d_name); + + flen = strlen(path) + strlen(dp->d_name) + 1; + filename = (char *)malloc(flen); + if (!filename) { + log_err("Out of memory\n"); + rc = RC_ERROR; + break; + } + strncpy(filename, path, flen); + strncat(filename, dp->d_name, flen); + + /* To identify the version number */ + msmversion = GetVersionInfo(filename); + if (*version < msmversion) { + *version = msmversion; + } + + num = 1; + chip = getChipInfo(filename, &num, msmversion); + + if (msmversion == 1) { + if (!chip) { + log_err("skip, failed to scan for '%s' tag\n", dt_tag); + free(filename); + continue; + } + } + if (msmversion == 2) { + if (!chip) { + log_err("skip, failed to scan for '%s' or '%s' tag\n", + dt_tag, QCDT_BOARD_TAG); + free(filename); + continue; + } + } + if (msmversion == 3) { + if (!chip) { + log_err("skip, failed to scan for '%s', '%s' or '%s' tag\n", + dt_tag, QCDT_BOARD_TAG, QCDT_PMIC_TAG); + free(filename); + continue; + } + } + + if ((stat(filename, &st) != 0) || + (st.st_size == 0)) { + log_err("skip, failed to get DTB size\n"); + free(filename); + continue; + } + + log_info("chipset: %u, rev: %u, platform: %u, subtype: %u, pmic0: %u, pmic1: %u, pmic2: %u, pmic3: %u\n", + chip->chipset, chip->revNum, chip->platform, chip->subtype, + chip->pmic_model[0], chip->pmic_model[1], chip->pmic_model[2], chip->pmic_model[3]); + + for (t_chip = chip->t_next; t_chip; t_chip = t_chip->t_next) { + log_info("additional chipset: %u, rev: %u, platform: %u, subtype: %u, pmic0: %u, pmic1: %u, pmic2: %u, pmic3: %u\n", + t_chip->chipset, t_chip->revNum, t_chip->platform, t_chip->subtype, + t_chip->pmic_model[0], t_chip->pmic_model[1], t_chip->pmic_model[2], t_chip->pmic_model[3]); + } + + rc = chip_add(chip); + if (rc != RC_SUCCESS) { + log_err("... duplicate info, skipped\n"); + free(filename); + continue; + } + + dtb_count++; + + chip->dtb_size = st.st_size + + (page_size - (st.st_size % page_size)); + chip->dtb_file = filename; + + for (t_chip = chip->t_next; t_chip; t_chip = t_chip->t_next) { + rc = chip_add(t_chip); + if (rc != RC_SUCCESS) { + log_err("... duplicate info, skipped (chipset %u, rev: %u, platform: %u, subtype: %u\n", + t_chip->chipset, t_chip->revNum, t_chip->platform, t_chip->subtype); + continue; + } + dtb_count++; + } + } + } + } + closedir(dir); + return dtb_count; +} + +/* Extract 'qcom,msm-id' 'qcom,board-id' parameter from DTB + v1 format: + qcom,msm-id = [, ...]; + v2 format: + qcom,msm-id = [, ...; + qcom,board-id = [, ...; + Fields: + x = chipset + y = platform + y' = subtype + z = soc rev + */ +int main(int argc, char **argv) +{ + char buf[COPY_BLK]; + struct chipInfo_t *chip; + FILE *pInputFile; + int padding; + uint8_t *filler = NULL; + int numBytesRead = 0; + int totBytesRead = 0; + int out_fd; + int rc = RC_SUCCESS; + int dtb_count = 0, dtb_offset = 0, entry_size; + size_t wrote = 0, expected = 0; + uint32_t dtb_size; + uint32_t version = 0; + uint32_t hdr_version; + char *filename; + + log_info("DTB combiner:\n"); + + if (parse_commandline(argc, argv) != RC_SUCCESS) { + print_help(); + return RC_ERROR; + } + + log_info(" Input directory: '%s'\n", input_dir); + log_info(" Output file: '%s'\n", output_file); + + + filler = (uint8_t *)malloc(page_size); + if (!filler) { + log_err("Out of memory\n"); + return RC_ERROR; + } + memset(filler, 0, page_size); + + dtb_count = find_dtb(input_dir, &version); + + log_info("=> Found %d unique DTB(s)\n", dtb_count); + + if (!dtb_count) + goto cleanup; + + + /* Generate the master DTB file: + + Simplify write error handling by just checking for actual vs + expected bytes written at the end. + */ + + log_info("\nGenerating master DTB... "); + + out_fd = open(output_file, O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR); + if (out_fd == -1) { + log_err("Cannot create '%s'\n", output_file); + rc = RC_ERROR; + goto cleanup; + } + + if (version_override != 0) { + version = version_override; + } + + if (version == 1) { + entry_size = 20; + } else if (version == 2) { + entry_size = 24; + } else { + entry_size = 40; + } + + hdr_version = (motorola_version<<8) | version; + + if (motorola_version) + entry_size += 32; + + /* Write header info */ + wrote += write(out_fd, QCDT_MAGIC, sizeof(uint8_t) * 4); /* magic */ + wrote += write(out_fd, &hdr_version, sizeof(uint32_t)); /* version */ + wrote += write(out_fd, (uint32_t *)&dtb_count, sizeof(uint32_t)); + /* #DTB */ + + /* Calculate offset of first DTB block */ + dtb_offset = 12 + /* header */ + (entry_size * dtb_count) + /* DTB table entries */ + 4; /* end of table indicator */ + + /* Round up to page size */ + padding = page_size - (dtb_offset % page_size); + dtb_offset += padding; + expected = dtb_offset; + + /* Write index table: + chipset + platform + subtype (v2/v3 only) + soc rev + pmic model0 (v3 only) + pmic model1 (v3 only) + pmic model2 (v3 only) + pmic model3 (v3 only) + dtb offset + dtb size + */ + for (chip = chip_list; chip; chip = chip->next) { + wrote += write(out_fd, &chip->chipset, sizeof(uint32_t)); + wrote += write(out_fd, &chip->platform, sizeof(uint32_t)); + if (version >= 2) { + wrote += write(out_fd, &chip->subtype, sizeof(uint32_t)); + } + wrote += write(out_fd, &chip->revNum, sizeof(uint32_t)); + if (version >= 3) { + wrote += write(out_fd, &chip->pmic_model[0], sizeof(uint32_t)); + wrote += write(out_fd, &chip->pmic_model[1], sizeof(uint32_t)); + wrote += write(out_fd, &chip->pmic_model[2], sizeof(uint32_t)); + wrote += write(out_fd, &chip->pmic_model[3], sizeof(uint32_t)); + } + if (chip->master->master_offset != 0) { + wrote += write(out_fd, &chip->master->master_offset, sizeof(uint32_t)); + } else { + wrote += write(out_fd, &expected, sizeof(uint32_t)); + chip->master->master_offset = expected; + expected += chip->master->dtb_size; + } + wrote += write(out_fd, &chip->master->dtb_size, sizeof(uint32_t)); + if (motorola_version) + wrote += write(out_fd, &chip->model, sizeof(chip->model)); + } + + rc = RC_SUCCESS; + wrote += write(out_fd, &rc, sizeof(uint32_t)); /* end of table indicator */ + if (padding > 0) + wrote += write(out_fd, filler, padding); + + /* Write DTB's */ + for (chip = chip_list; chip; chip = chip->next) { + if (chip->master->wroteDtb) { + continue; + } + + chip->master->wroteDtb = 1; + filename = chip->master->dtb_file; + dtb_size = chip->master->dtb_size; + + log_dbg("\n (writing '%s' - %u bytes) ", filename, dtb_size); + pInputFile = fopen(filename, "r"); + if (pInputFile != NULL) { + totBytesRead = 0; + while ((numBytesRead = fread(buf, 1, COPY_BLK, pInputFile)) > 0) { + wrote += write(out_fd, buf, numBytesRead); + totBytesRead += numBytesRead; + } + fclose(pInputFile); + padding = page_size - (totBytesRead % page_size); + if ((uint32_t)(totBytesRead + padding) != dtb_size) { + log_err("DTB size mismatch, please re-run: expected %d vs actual %d (%s)\n", + dtb_size, totBytesRead + padding, + filename); + rc = RC_ERROR; + break; + } + if (padding > 0) + wrote += write(out_fd, filler, padding); + } else { + log_err("failed to open DTB '%s'\n", filename); + rc = RC_ERROR; + break; + } + } + close(out_fd); + + if (expected != wrote) { + log_err("error writing output file, please rerun: size mismatch %zu vs %zu\n", + expected, wrote); + rc = RC_ERROR; + } else + log_dbg("Total wrote %zu bytes\n", wrote); + + if (rc != RC_SUCCESS) + unlink(output_file); + else + log_info("completed\n"); + +cleanup: + free(filler); + chip_deleteall(); + return rc; +} +