/*
 * Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
       * Redistributions of source code must retain the above copyright
         notice, this list of conditions and the following disclaimer.
       * Redistributions in binary form must reproduce the above
         copyright notice, this list of conditions and the following
         disclaimer in the documentation and/or other materials provided
         with the distribution.
       * Neither the name of The Linux Foundation nor the names of its
         contributors may be used to endorse or promote products derived
         from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#define _GNU_SOURCE
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <getopt.h>
#include <errno.h>
#include <unistd.h>
#include <limits.h>

#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 <output file> <input DTB path>\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 = <x y z>;

  For v2 Extract 'qcom,msm-id', 'qcom,board-id' parameter double from DTB
      qcom,msm-id = <x z> i.e chipset, revision number;
      qcom,board-id = <y y'> 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 = <x y z> [, <x2 y2 z2> ...];
   v2 format:
      qcom,msm-id = <x z> [, <x2 z2> ...;
      qcom,board-id = <y y'> [, <y2 y2'> ...;
   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;
}

