/*
 * (C) Copyright 2008 Semihalf
 *
 * (C) Copyright 2000-2009
 * DENX Software Engineering
 * Wolfgang Denk, wd@denx.de
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307 USA
 */

#include "mkimage.h"
#include <image.h>

static void copy_file(int, const char *, int);
static void usage(void);

/* image_type_params link list to maintain registered image type supports */
struct image_type_params *mkimage_tparams = NULL;

/* parameters initialized by core will be used by the image type code */
struct mkimage_params params = {
        .os = IH_OS_LINUX,
        .arch = IH_ARCH_PPC,
        .type = IH_TYPE_KERNEL,
        .comp = IH_COMP_GZIP,
        .dtc = MKIMAGE_DEFAULT_DTC_OPTIONS,
        .imagename = "",
};

/*
 * mkimage_register -
 *
 * It is used to register respective image generation/list support to the
 * mkimage core
 *
 * the input struct image_type_params is checked and appended to the link
 * list, if the input structure is already registered, error
 */
void mkimage_register (struct image_type_params *tparams)
{
        struct image_type_params **tp;

        if (!tparams) {
                fprintf (stderr, "%s: %s: Null input\n",
                        params.cmdname, __FUNCTION__);
                exit (EXIT_FAILURE);
        }

        /* scan the linked list, check for registry and point the last one */
        for (tp = &mkimage_tparams; *tp != NULL; tp = &(*tp)->next) {
                if (!strcmp((*tp)->name, tparams->name)) {
                        fprintf (stderr, "%s: %s already registered\n",
                                params.cmdname, tparams->name);
                        return;
                }
        }

        /* add input struct entry at the end of link list */
        *tp = tparams;
        /* mark input entry as last entry in the link list */
        tparams->next = NULL;

        debug ("Registered %s\n", tparams->name);
}

/*
 * mkimage_get_type -
 *
 * It scans all registers image type supports
 * checks the input type_id for each supported image type
 *
 * if successful,
 *      returns respective image_type_params pointer if success
 * if input type_id is not supported by any of image_type_support
 *      returns NULL
 */
struct image_type_params *mkimage_get_type(int type)
{
        struct image_type_params *curr;

        for (curr = mkimage_tparams; curr != NULL; curr = curr->next) {
                if (curr->check_image_type) {
                        if (!curr->check_image_type (type))
                                return curr;
                }
        }
        return NULL;
}

/*
 * mkimage_verify_print_header -
 *
 * It scans mkimage_tparams link list,
 * verifies image_header for each supported image type
 * if verification is successful, prints respective header
 *
 * returns negative if input image format does not match with any of
 * supported image types
 */
int mkimage_verify_print_header (void *ptr, struct stat *sbuf)
{
        int retval = -1;
        struct image_type_params *curr;

        for (curr = mkimage_tparams; curr != NULL; curr = curr->next ) {
                if (curr->verify_header) {
                        retval = curr->verify_header (
                                (unsigned char *)ptr, sbuf->st_size,
                                &params);

                        if (retval == 0) {
                                /*
                                 * Print the image information
                                 * if verify is successful
                                 */
                                if (curr->print_header)
                                        curr->print_header (ptr);
                                else {
                                        fprintf (stderr,
                                        "%s: print_header undefined for %s\n",
                                        params.cmdname, curr->name);
                                }
                                break;
                        }
                }
        }
        return retval;
}

int
main (int argc, char **argv)
{
        int ifd = -1;
        struct stat sbuf;
        char *ptr;
        int retval = 0;
        struct image_type_params *tparams = NULL;

        /* Init Kirkwood Boot image generation/list support */
        init_kwb_image_type ();
        /* Init Freescale imx Boot image generation/list support */
        init_imx_image_type ();
        /* Init FIT image generation/list support */
        init_fit_image_type ();
        /* Init Default image generation/list support */
        init_default_image_type ();

        params.cmdname = *argv;
        params.addr = params.ep = 0;

        while (--argc > 0 && **++argv == '-') {
                while (*++*argv) {
                        switch (**argv) {
                        case 'l':
                                params.lflag = 1;
                                break;
                        case 'A':
                                if ((--argc <= 0) ||
                                        (params.arch =
                                        genimg_get_arch_id (*++argv)) < 0)
                                        usage ();
                                goto NXTARG;
                        case 'C':
                                if ((--argc <= 0) ||
                                        (params.comp =
                                        genimg_get_comp_id (*++argv)) < 0)
                                        usage ();
                                goto NXTARG;
                        case 'D':
                                if (--argc <= 0)
                                        usage ();
                                params.dtc = *++argv;
                                goto NXTARG;

                        case 'O':
                                if ((--argc <= 0) ||
                                        (params.os =
                                        genimg_get_os_id (*++argv)) < 0)
                                        usage ();
                                goto NXTARG;
                        case 'T':
                                if ((--argc <= 0) ||
                                        (params.type =
                                        genimg_get_type_id (*++argv)) < 0)
                                        usage ();
                                goto NXTARG;

                        case 'a':
                                if (--argc <= 0)
                                        usage ();
                                params.addr = strtoul (*++argv, &ptr, 16);
                                if (*ptr) {
                                        fprintf (stderr,
                                                "%s: invalid load address %s\n",
                                                params.cmdname, *argv);
                                        exit (EXIT_FAILURE);
                                }
                                goto NXTARG;
                        case 'd':
                                if (--argc <= 0)
                                        usage ();
                                params.datafile = *++argv;
                                params.dflag = 1;
                                goto NXTARG;
                        case 'e':
                                if (--argc <= 0)
                                        usage ();
                                params.ep = strtoul (*++argv, &ptr, 16);
                                if (*ptr) {
                                        fprintf (stderr,
                                                "%s: invalid entry point %s\n",
                                                params.cmdname, *argv);
                                        exit (EXIT_FAILURE);
                                }
                                params.eflag = 1;
                                goto NXTARG;
                        case 'f':
                                if (--argc <= 0)
                                        usage ();
                                /*
                                 * The flattened image tree (FIT) format
                                 * requires a flattened device tree image type
                                 */
                                params.type = IH_TYPE_FLATDT;
                                params.datafile = *++argv;
                                params.fflag = 1;
                                goto NXTARG;
                        case 'n':
                                if (--argc <= 0)
                                        usage ();
                                params.imagename = *++argv;
                                goto NXTARG;
                        case 'v':
                                params.vflag++;
                                break;
                        case 'x':
                                params.xflag++;
                                break;
                        default:
                                usage ();
                        }
                }
NXTARG:         ;
        }

        if (argc != 1)
                usage ();

        /* set tparams as per input type_id */
        tparams = mkimage_get_type(params.type);
        if (tparams == NULL) {
                fprintf (stderr, "%s: unsupported type %s\n",
                        params.cmdname, genimg_get_type_name(params.type));
                exit (EXIT_FAILURE);
        }

        /*
         * check the passed arguments parameters meets the requirements
         * as per image type to be generated/listed
         */
        if (tparams->check_params)
                if (tparams->check_params (&params))
                        usage ();

        if (!params.eflag) {
                params.ep = params.addr;
                /* If XIP, entry point must be after the U-Boot header */
                if (params.xflag)
                        params.ep += tparams->header_size;
        }

        params.imagefile = *argv;

        if (params.fflag){
                if (tparams->fflag_handle)
                        /*
                         * in some cases, some additional processing needs
                         * to be done if fflag is defined
                         *
                         * For ex. fit_handle_file for Fit file support
                         */
                        retval = tparams->fflag_handle(&params);

                if (retval != EXIT_SUCCESS)
                        exit (retval);
        }

        if (params.lflag || params.fflag) {
                ifd = open (params.imagefile, O_RDONLY|O_BINARY);
        } else {
                ifd = open (params.imagefile,
                        O_RDWR|O_CREAT|O_TRUNC|O_BINARY, 0666);
        }

        if (ifd < 0) {
                fprintf (stderr, "%s: Can't open %s: %s\n",
                        params.cmdname, params.imagefile,
                        strerror(errno));
                exit (EXIT_FAILURE);
        }

        if (params.lflag || params.fflag) {
                /*
                 * list header information of existing image
                 */
                if (fstat(ifd, &sbuf) < 0) {
                        fprintf (stderr, "%s: Can't stat %s: %s\n",
                                params.cmdname, params.imagefile,
                                strerror(errno));
                        exit (EXIT_FAILURE);
                }

                if ((unsigned)sbuf.st_size < tparams->header_size) {
                        fprintf (stderr,
                                "%s: Bad size: \"%s\" is not valid image\n",
                                params.cmdname, params.imagefile);
                        exit (EXIT_FAILURE);
                }

                ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_SHARED, ifd, 0);
                if (ptr == MAP_FAILED) {
                        fprintf (stderr, "%s: Can't read %s: %s\n",
                                params.cmdname, params.imagefile,
                                strerror(errno));
                        exit (EXIT_FAILURE);
                }

                /*
                 * scan through mkimage registry for all supported image types
                 * and verify the input image file header for match
                 * Print the image information for matched image type
                 * Returns the error code if not matched
                 */
                retval = mkimage_verify_print_header (ptr, &sbuf);

                (void) munmap((void *)ptr, sbuf.st_size);
                (void) close (ifd);

                exit (retval);
        }

        /*
         * Must be -w then:
         *
         * write dummy header, to be fixed later
         */
        memset (tparams->hdr, 0, tparams->header_size);

        if (write(ifd, tparams->hdr, tparams->header_size)
                                        != tparams->header_size) {
                fprintf (stderr, "%s: Write error on %s: %s\n",
                        params.cmdname, params.imagefile, strerror(errno));
                exit (EXIT_FAILURE);
        }

        if (params.type == IH_TYPE_MULTI || params.type == IH_TYPE_SCRIPT) {
                char *file = params.datafile;
                uint32_t size;

                for (;;) {
                        char *sep = NULL;

                        if (file) {
                                if ((sep = strchr(file, ':')) != NULL) {
                                        *sep = '\0';
                                }

                                if (stat (file, &sbuf) < 0) {
                                        fprintf (stderr, "%s: Can't stat %s: %s\n",
                                                params.cmdname, file, strerror(errno));
                                        exit (EXIT_FAILURE);
                                }
                                size = cpu_to_uimage (sbuf.st_size);
                        } else {
                                size = 0;
                        }

                        if (write(ifd, (char *)&size, sizeof(size)) != sizeof(size)) {
                                fprintf (stderr, "%s: Write error on %s: %s\n",
                                        params.cmdname, params.imagefile,
                                        strerror(errno));
                                exit (EXIT_FAILURE);
                        }

                        if (!file) {
                                break;
                        }

                        if (sep) {
                                *sep = ':';
                                file = sep + 1;
                        } else {
                                file = NULL;
                        }
                }

                file = params.datafile;

                for (;;) {
                        char *sep = strchr(file, ':');
                        if (sep) {
                                *sep = '\0';
                                copy_file (ifd, file, 1);
                                *sep++ = ':';
                                file = sep;
                        } else {
                                copy_file (ifd, file, 0);
                                break;
                        }
                }
        } else {
                copy_file (ifd, params.datafile, 0);
        }

        /* We're a bit of paranoid */
#if defined(_POSIX_SYNCHRONIZED_IO) && \
   !defined(__sun__) && \
   !defined(__FreeBSD__) && \
   !defined(__APPLE__)
        (void) fdatasync (ifd);
#else
        (void) fsync (ifd);
#endif

        if (fstat(ifd, &sbuf) < 0) {
                fprintf (stderr, "%s: Can't stat %s: %s\n",
                        params.cmdname, params.imagefile, strerror(errno));
                exit (EXIT_FAILURE);
        }

        ptr = mmap(0, sbuf.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, ifd, 0);
        if (ptr == MAP_FAILED) {
                fprintf (stderr, "%s: Can't map %s: %s\n",
                        params.cmdname, params.imagefile, strerror(errno));
                exit (EXIT_FAILURE);
        }

        /* Setup the image header as per input image type*/
        if (tparams->set_header)
                tparams->set_header (ptr, &sbuf, ifd, &params);
        else {
                fprintf (stderr, "%s: Can't set header for %s: %s\n",
                        params.cmdname, tparams->name, strerror(errno));
                exit (EXIT_FAILURE);
        }

        /* Print the image information by processing image header */
        if (tparams->print_header)
                tparams->print_header (ptr);
        else {
                fprintf (stderr, "%s: Can't print header for %s: %s\n",
                        params.cmdname, tparams->name, strerror(errno));
                exit (EXIT_FAILURE);
        }

        (void) munmap((void *)ptr, sbuf.st_size);

        /* We're a bit of paranoid */
#if defined(_POSIX_SYNCHRONIZED_IO) && \
   !defined(__sun__) && \
   !defined(__FreeBSD__) && \
   !defined(__APPLE__)
        (void) fdatasync (ifd);
#else
        (void) fsync (ifd);
#endif

        if (close(ifd)) {
                fprintf (stderr, "%s: Write error on %s: %s\n",
                        params.cmdname, params.imagefile, strerror(errno));
                exit (EXIT_FAILURE);
        }

        exit (EXIT_SUCCESS);
}

static void
copy_file (int ifd, const char *datafile, int pad)
{
        int dfd;
        struct stat sbuf;
        unsigned char *ptr;
        int tail;
        int zero = 0;
        int offset = 0;
        int size;
        struct image_type_params *tparams = mkimage_get_type (params.type);

        if (params.vflag) {
                fprintf (stderr, "Adding Image %s\n", datafile);
        }

        if ((dfd = open(datafile, O_RDONLY|O_BINARY)) < 0) {
                fprintf (stderr, "%s: Can't open %s: %s\n",
                        params.cmdname, datafile, strerror(errno));
                exit (EXIT_FAILURE);
        }

        if (fstat(dfd, &sbuf) < 0) {
                fprintf (stderr, "%s: Can't stat %s: %s\n",
                        params.cmdname, datafile, strerror(errno));
                exit (EXIT_FAILURE);
        }

        ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_SHARED, dfd, 0);
        if (ptr == MAP_FAILED) {
                fprintf (stderr, "%s: Can't read %s: %s\n",
                        params.cmdname, datafile, strerror(errno));
                exit (EXIT_FAILURE);
        }

        if (params.xflag) {
                unsigned char *p = NULL;
                /*
                 * XIP: do not append the image_header_t at the
                 * beginning of the file, but consume the space
                 * reserved for it.
                 */

                if ((unsigned)sbuf.st_size < tparams->header_size) {
                        fprintf (stderr,
                                "%s: Bad size: \"%s\" is too small for XIP\n",
                                params.cmdname, datafile);
                        exit (EXIT_FAILURE);
                }

                for (p = ptr; p < ptr + tparams->header_size; p++) {
                        if ( *p != 0xff ) {
                                fprintf (stderr,
                                        "%s: Bad file: \"%s\" has invalid buffer for XIP\n",
                                        params.cmdname, datafile);
                                exit (EXIT_FAILURE);
                        }
                }

                offset = tparams->header_size;
        }

        size = sbuf.st_size - offset;
        if (write(ifd, ptr + offset, size) != size) {
                fprintf (stderr, "%s: Write error on %s: %s\n",
                        params.cmdname, params.imagefile, strerror(errno));
                exit (EXIT_FAILURE);
        }

        if (pad && ((tail = size % 4) != 0)) {

                if (write(ifd, (char *)&zero, 4-tail) != 4-tail) {
                        fprintf (stderr, "%s: Write error on %s: %s\n",
                                params.cmdname, params.imagefile,
                                strerror(errno));
                        exit (EXIT_FAILURE);
                }
        }

        (void) munmap((void *)ptr, sbuf.st_size);
        (void) close (dfd);
}

void
usage ()
{
        fprintf (stderr, "Usage: %s -l image\n"
                         "          -l ==> list image header information\n",
                params.cmdname);
        fprintf (stderr, "       %s [-x] -A arch -O os -T type -C comp "
                         "-a addr -e ep -n name -d data_file[:data_file...] image\n"
                         "          -A ==> set architecture to 'arch'\n"
                         "          -O ==> set operating system to 'os'\n"
                         "          -T ==> set image type to 'type'\n"
                         "          -C ==> set compression type 'comp'\n"
                         "          -a ==> set load address to 'addr' (hex)\n"
                         "          -e ==> set entry point to 'ep' (hex)\n"
                         "          -n ==> set image name to 'name'\n"
                         "          -d ==> use image data from 'datafile'\n"
                         "          -x ==> set XIP (execute in place)\n",
                params.cmdname);
        fprintf (stderr, "       %s [-D dtc_options] -f fit-image.its fit-image\n",
                params.cmdname);

        exit (EXIT_FAILURE);
}