M7350v1_en_gpl

bootable/bootloader/lk/target/mdm9625/include/target/board.h

@@ -0,0 +1,38 @@
+/* Copyright (c) 2012, 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.
+ *
+ */
+
+#ifndef __TARGET_BOARD_H
+#define __TARGET_BOARD_H
+
+
+#define LINUX_MACHTYPE_9625_CDP      0
+#define LINUX_MACHTYPE_9625_MTP      0
+
+#endif
+

bootable/bootloader/lk/target/mdm9625/init.c

@@ -0,0 +1,224 @@
+/* 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.
+ */
+
+#include <debug.h>
+#include <board.h>
+#include <platform.h>
+#include <target.h>
+#include <smem.h>
+#include <baseband.h>
+#include <lib/ptable.h>
+#include <qpic_nand.h>
+#include <ctype.h>
+#include <string.h>
+#include <pm8x41.h>
+#include <reg.h>
+#include <platform/timer.h>
+
+extern void smem_ptable_init(void);
+extern void smem_add_modem_partitions(struct ptable *flash_ptable);
+
+static struct ptable flash_ptable;
+
+/* PMIC config data */
+#define PMIC_ARB_CHANNEL_NUM                          0
+#define PMIC_ARB_OWNER_ID                             0
+
+/* NANDc BAM pipe numbers */
+#define DATA_CONSUMER_PIPE                            0
+#define DATA_PRODUCER_PIPE                            1
+#define CMD_PIPE                                      2
+
+/* NANDc BAM pipe groups */
+#define DATA_PRODUCER_PIPE_GRP                        0
+#define DATA_CONSUMER_PIPE_GRP                        0
+#define CMD_PIPE_GRP                                  1
+
+/* NANDc EE */
+#define QPIC_NAND_EE                                  0
+
+/* NANDc max desc length. */
+#define QPIC_NAND_MAX_DESC_LEN                        0x7FFF
+
+#define LAST_NAND_PTN_LEN_PATTERN                     0xFFFFFFFF
+
+struct qpic_nand_init_config config;
+
+void update_ptable_names(void)
+{
+	uint32_t ptn_index;
+	struct ptentry *ptentry_ptr = flash_ptable.parts;
+	struct ptentry *boot_ptn;
+	unsigned i;
+	uint32_t len;
+
+	/* Change all names to lower case. */
+	for (ptn_index = 0; ptn_index != (uint32_t)flash_ptable.count; ptn_index++)
+	{
+		len = strlen(ptentry_ptr[ptn_index].name);
+
+		for (i = 0; i < len; i++)
+		{
+			if (isupper(ptentry_ptr[ptn_index].name[i]))
+			{
+				ptentry_ptr[ptn_index].name[i] = tolower(ptentry_ptr[ptn_index].name[i]);
+			}
+		}
+
+		/* SBL fills in the last partition length as 0xFFFFFFFF.
+		 * Update the length field based on the number of blocks on the flash.
+		 */
+		if ((uint32_t)(ptentry_ptr[ptn_index].length) == LAST_NAND_PTN_LEN_PATTERN)
+		{
+			ptentry_ptr[ptn_index].length = flash_num_blocks() - ptentry_ptr[ptn_index].start;
+		}
+	}
+
+	/* Rename apps ptn to boot. */
+	boot_ptn = ptable_find(&flash_ptable, "apps");
+	strcpy(boot_ptn->name, "boot");
+
+	/* Rename appsbl ptn to aboot. */
+	boot_ptn = ptable_find(&flash_ptable, "appsbl");
+	strcpy(boot_ptn->name, "aboot");
+}
+
+void target_early_init(void)
+{
+#if WITH_DEBUG_UART
+	uart_dm_init(3, 0, MSM_UART2_BASE);
+#endif
+}
+
+
+/* init */
+void target_init(void)
+{
+	dprintf(INFO, "target_init()\n");
+
+	spmi_init(PMIC_ARB_CHANNEL_NUM, PMIC_ARB_OWNER_ID);
+
+	config.pipes.read_pipe = DATA_PRODUCER_PIPE;
+	config.pipes.write_pipe = DATA_CONSUMER_PIPE;
+	config.pipes.cmd_pipe = CMD_PIPE;
+
+	config.pipes.read_pipe_grp = DATA_PRODUCER_PIPE_GRP;
+	config.pipes.write_pipe_grp = DATA_CONSUMER_PIPE_GRP;
+	config.pipes.cmd_pipe_grp = CMD_PIPE_GRP;
+
+	config.bam_base = MSM_NAND_BAM_BASE;
+	config.nand_base = MSM_NAND_BASE;
+	config.ee = QPIC_NAND_EE;
+	config.max_desc_len = QPIC_NAND_MAX_DESC_LEN;
+
+	qpic_nand_init(&config);
+
+	ptable_init(&flash_ptable);
+
+	smem_ptable_init();
+
+	smem_add_modem_partitions(&flash_ptable);
+
+	update_ptable_names();
+
+	flash_set_ptable(&flash_ptable);
+}
+
+/* reboot */
+void reboot_device(unsigned reboot_reason)
+{
+	uint32_t version = board_soc_version();
+
+	/* Write the reboot reason */
+	if(version >= 0x20000)
+		writel(reboot_reason, RESTART_REASON_ADDR_V2);
+	else
+		writel(reboot_reason, RESTART_REASON_ADDR);
+
+	/* Configure PMIC for warm reset */
+	/* PM 8019 v1 aligns with PM8941 v2.
+	 * This call should be based on the pmic version
+	 * when PM8019 v2 is available.
+	 */
+	pm8x41_v2_reset_configure(PON_PSHOLD_WARM_RESET);
+
+	/* Drop PS_HOLD for MSM */
+	writel(0x00, MPM2_MPM_PS_HOLD);
+
+	mdelay(5000);
+
+	dprintf(CRITICAL, "Rebooting failed\n");
+	return;
+}
+
+/* Identify the current target */
+void target_detect(struct board_data *board)
+{
+	/* Not used. set to unknown */
+	board->target = LINUX_MACHTYPE_UNKNOWN;
+}
+
+unsigned board_machtype(void)
+{
+	return  board_target_id();
+}
+
+/* Identify the baseband being used */
+void target_baseband_detect(struct board_data *board)
+{
+	/* Check for baseband variants. Default to MSM */
+	if (board->platform_subtype == HW_PLATFORM_SUBTYPE_UNKNOWN)
+	{
+			board->baseband = BASEBAND_MSM;
+	}
+	else
+	{
+		dprintf(CRITICAL, "Could not identify baseband id (%d)\n",
+				board->platform_subtype);
+		ASSERT(0);
+	}
+}
+
+unsigned check_reboot_mode(void)
+{
+	unsigned restart_reason = 0;
+	uint32_t version = board_soc_version();
+
+	/* Read reboot reason and scrub it */
+	if(version >= 0x20000) {
+		restart_reason = readl(RESTART_REASON_ADDR_V2);
+		writel(0x00, RESTART_REASON_ADDR_V2);
+	}
+	else {
+		restart_reason = readl(RESTART_REASON_ADDR);
+		writel(0x00, RESTART_REASON_ADDR);
+	}
+
+	return restart_reason;
+}
+

bootable/bootloader/lk/target/mdm9625/keypad.c

@@ -0,0 +1,64 @@
+/* Copyright (c) 2012, 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.
+*/
+
+#include <reg.h>
+#include <platform/gpio.h>
+#include <platform/iomap.h>
+
+/* GPIO that controls the button
+ * for FASTBOOT.
+ */
+#define FASTBOOT_KEY_GPIO_ID        58
+
+/*
+ * Returns fastboot button state.
+ * Returns 0 if button is not pressed, 1 when pressed.
+ */
+int get_fastboot_key_state(void)
+{
+	int ret;
+
+	gpio_tlmm_config(FASTBOOT_KEY_GPIO_ID, 0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA, GPIO_ENABLE);
+
+	ret = gpio_get_state(FASTBOOT_KEY_GPIO_ID);
+
+	return ret;
+}
+
+/*
+* Return 1 to trigger to fastboot
+*/
+int fastboot_trigger(void)
+{
+	int ret;
+
+	ret = get_fastboot_key_state();
+
+	return (ret);
+}
+

bootable/bootloader/lk/target/mdm9625/meminfo.c

@@ -0,0 +1,109 @@
+/* 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.
+ */
+
+#include <reg.h>
+#include <debug.h>
+#include <malloc.h>
+#include <smem.h>
+#include <stdint.h>
+#include <libfdt.h>
+#include <platform.h>
+#include <platform/iomap.h>
+#include <dev_tree.h>
+
+#define SIZE_1M             (1024 * 1024)
+
+static struct smem_ram_ptable ram_ptable;
+
+struct smem_ram_ptable* target_smem_ram_ptable_init()
+{
+   /* Make sure RAM partition table is initialized */
+   ASSERT(smem_ram_ptable_init(&ram_ptable));
+
+   return &ram_ptable;
+}
+
+/* Funtion to add the ram partition entries into device tree.
+ * The function assumes that all the entire fixed memory regions should
+ * be listed in the first bank of the passed in ddr regions.
+ */
+uint32_t target_dev_tree_mem(void *fdt, uint32_t memory_node_offset)
+{
+    unsigned int i;
+	int ret;
+
+     for (i = 0; i < ram_ptable.len; i++)
+    {
+        if ((ram_ptable.parts[i].category == SDRAM) &&
+		   (ram_ptable.parts[i].type == SYS_MEMORY))
+        {
+		if (ram_ptable.parts[i].start == 0)
+			{
+				/* Pass along all other usable memory regions to Linux */
+				/* Any memory not accessible by the kernel which is below the
+				 * kernel start address must *not* be given to the kernel.
+				 */
+				ret = dev_tree_add_mem_info(fdt,
+											memory_node_offset,
+											ram_ptable.parts[i].start + 3*SIZE_1M,
+											ram_ptable.parts[i].size  - 3*SIZE_1M);
+
+			}
+			else
+			{
+					/* Pass along all other usable memory regions to Linux */
+					ret = dev_tree_add_mem_info(fdt,
+												memory_node_offset,
+												ram_ptable.parts[i].start,
+												ram_ptable.parts[i].size);
+
+			}
+
+
+			if (ret)
+			{
+				dprintf(CRITICAL, "Failed to add memory bank addresses to device tree\n");
+				goto target_dev_tree_mem_err;
+			}
+        }
+    }
+
+target_dev_tree_mem_err:
+
+    return ret;
+}
+
+void *target_get_scratch_address(void)
+{
+	return ((void *) VA((addr_t)SCRATCH_REGION1));
+}
+
+unsigned target_get_max_flash_size(void)
+{
+	return (SCRATCH_REGION1_SIZE + SCRATCH_REGION2_SIZE);
+}

bootable/bootloader/lk/target/mdm9625/rules.mk

@@ -0,0 +1,36 @@
+LOCAL_DIR := $(GET_LOCAL_DIR)
+
+INCLUDES += -I$(LOCAL_DIR)/include -I$(LK_TOP_DIR)/platform/msm_shared
+
+PLATFORM := mdm9x25
+
+MEMBASE                             := 0x07E00000
+MEMSIZE                             := 0x00100000 # 1MB
+SCRATCH_ADDR                        := 0x00300000
+SCRATCH_REGION1                     := 0x00300000
+SCRATCH_REGION1_SIZE                := 0x01000000 #16 MB
+SCRATCH_REGION2                     := 0x06800000
+SCRATCH_REGION2_SIZE                := 0x01600000 #22 MB
+
+DEFINES += NO_KEYPAD_DRIVER=1
+DEFINES += PERIPH_BLK_BLSP=1
+
+MODULES += \
+	dev/keys \
+	lib/ptable \
+    dev/pmic/pm8x41 \
+	lib/libfdt
+
+DEFINES += \
+	MEMBASE=$(MEMBASE) \
+	SCRATCH_ADDR=$(SCRATCH_ADDR) \
+	SCRATCH_REGION1=$(SCRATCH_REGION1) \
+	SCRATCH_REGION2=$(SCRATCH_REGION2) \
+	MEMSIZE=$(MEMSIZE) \
+	SCRATCH_REGION1_SIZE=$(SCRATCH_REGION1_SIZE) \
+	SCRATCH_REGION2_SIZE=$(SCRATCH_REGION2_SIZE) \
+
+OBJS += \
+	$(LOCAL_DIR)/init.o \
+	$(LOCAL_DIR)/meminfo.o \
+	$(LOCAL_DIR)/keypad.o

bootable/bootloader/lk/target/mdm9625/tools/makefile

@@ -0,0 +1,43 @@
+#Makefile to generate appsboot.mbn
+
+ifeq ($(BOOTLOADER_OUT),.)
+APPSBOOTHEADER_DIR  := $(BUILDDIR)
+else
+APPSBOOTHEADER_DIR  := $(BOOTLOADER_OUT)/../..
+endif
+
+SRC_DIR  := target/$(TARGET)/tools
+COMPILER := gcc
+
+ifeq ($(EMMC_BOOT), 1)
+  APPSBOOTHDR_FILES := EMMCBOOT.MBN
+else
+  ifeq ($(BUILD_NANDWRITE), 1)
+    APPSBOOTHDR_FILES :=
+  else
+    APPSBOOTHDR_FILES := appsboot.mbn
+  endif
+endif
+
+APPSBOOTHEADER: $(APPSBOOTHDR_FILES)
+
+
+appsboot.mbn: appsboothd.mbn $(OUTBIN)
+	cp $(OUTBIN) $(APPSBOOTHEADER_DIR)/appsboot.raw
+	cat $(APPSBOOTHEADER_DIR)/appsboothd.mbn $(OUTBIN) > $(APPSBOOTHEADER_DIR)/appsboot.mbn
+	rm -f $(APPSBOOTHEADER_DIR)/appsboothd.mbn
+
+appsboothd.mbn: mkheader $(OUTBIN)
+	$(SRC_DIR)/mkheader $(OUTBIN) $(APPSBOOTHEADER_DIR)/appsboothd.mbn
+
+EMMCBOOT.MBN: emmc_appsboothd.mbn $(OUTBIN)
+	cp $(OUTBIN) $(APPSBOOTHEADER_DIR)/emmc_appsboot.raw
+	cat $(APPSBOOTHEADER_DIR)/emmc_appsboothd.mbn $(OUTBIN) > $(APPSBOOTHEADER_DIR)/EMMCBOOT.MBN
+	cat $(APPSBOOTHEADER_DIR)/emmc_appsboothd.mbn $(OUTBIN) > $(APPSBOOTHEADER_DIR)/emmc_appsboot.mbn
+	rm -f $(APPSBOOTHEADER_DIR)/emmc_appsboothd.mbn
+
+emmc_appsboothd.mbn: mkheader $(OUTBIN)
+	$(SRC_DIR)/mkheader $(OUTBIN) $(APPSBOOTHEADER_DIR)/emmc_appsboothd.mbn
+
+mkheader: $(SRC_DIR)/mkheader.c
+	${COMPILER} -DMEMBASE=$(MEMBASE) $(SRC_DIR)/mkheader.c -o $(SRC_DIR)/mkheader

bootable/bootloader/lk/target/mdm9625/tools/mkheader.c

@@ -0,0 +1,344 @@
+/*
+ * Copyright (c) 2007, Google Inc.
+ * All rights reserved.
+ *
+ * Copyright (c) 2012, 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 Google, Inc. 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 BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE 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.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+
+#include <sys/stat.h>
+
+int print_usage(){
+	fprintf(stderr,"usage: mkheader <bin> <hdr> <none|unified-boot>\n");
+	fprintf(stderr,"       mkheader <bin> <hdr> <unsecure-boot>"
+		       " <outbin>\n");
+	fprintf(stderr,"       mkheader <bin> <hdr> <secure-boot> <outbin>"
+		       " <maxsize>\n");
+	fprintf(stderr,"       mkheader <bin> <hdr> <secure-boot> <outbin>"
+		       " <maxsize> <certchain> <files...>\n\n");
+	fprintf(stderr,"bin:               Input raw appsbl binary\n");
+	fprintf(stderr,"hdr:               Output of appsbl header location\n");
+	fprintf(stderr,"outbin:            Output of the signed or unsigned"
+		       " apps boot location\n");
+	fprintf(stderr,"maxsize:           Maximum size for certificate"
+		       " chain\n");
+	fprintf(stderr,"certchain:         Output of the certchain location\n");
+	fprintf(stderr,"files:             Input format <bin signature>"
+		       " <certifcate file(s) for certificate chain>...\n");
+	fprintf(stderr,"certificate chain: Files will be concatenated in order"
+		       " to create the certificate chain\n\n");
+	return -1;
+}
+
+int cat(FILE * in, FILE * out, unsigned size, unsigned buff_size){
+	unsigned bytes_left = size;
+	char buf[buff_size];
+	int ret = 0;
+
+	while(bytes_left){
+		fread(buf, sizeof(char), buff_size, in);
+		if(!feof(in)){
+			bytes_left -= fwrite(buf, sizeof(char), buff_size, out);
+		}
+		else
+			bytes_left = 0;
+	}
+	ret = ferror(in) | ferror(out);
+	if(ret)
+		fprintf(stderr, "ERROR: Occured during file concatenation\n");
+	return ret;
+}
+
+int main(int argc, char *argv[])
+{
+	struct stat s;
+	unsigned size, base;
+	int unified_boot = 0;
+	unsigned unified_boot_magic[20];
+	unsigned non_unified_boot_magic[10];
+	unsigned magic_len = 0;
+	unsigned *magic;
+	unsigned cert_chain_size = 0;
+	unsigned signature_size = 0;
+	int secure_boot = 0;
+	int fd;
+
+	if(argc < 3) {
+		return print_usage();
+	}
+
+	if(argc == 4) {
+		if(!strcmp("unified-boot",argv[3])) {
+			unified_boot = 1;
+		}
+		else if(!strcmp("secure-boot",argv[3])){
+			fprintf(stderr,
+				"ERROR: Missing arguments: [outbin maxsize] |"
+				" [outbin, maxsize, certchain,"
+				" signature + certifcate(s)]\n");
+			return print_usage();
+		}
+		else if(!strcmp("unsecure-boot",argv[3])){
+			fprintf(stderr,"ERROR: Missing arguments:"
+				       " outbin directory\n");
+			return print_usage();
+		}
+	}
+
+	if(argc > 4) {
+		if(!strcmp("secure-boot",argv[3])) {
+			if(argc < 9 && argc != 6){
+				fprintf(stderr,
+					"ERROR: Missing argument(s):"
+					" [outbin maxsize] | [outbin, maxsize,"
+					" certchain,"
+					" signature + certifcate(s)]\n");
+				return print_usage();
+			}
+			secure_boot = 1;
+			signature_size = 256; //Support SHA 256
+			cert_chain_size = atoi(argv[5]);
+		}
+	}
+
+	if(stat(argv[1], &s)) {
+		perror("cannot stat binary");
+		return -1;
+	}
+
+	if(unified_boot) {
+		magic = unified_boot_magic;
+		magic_len = sizeof(unified_boot_magic);
+	}
+	else {
+		magic = non_unified_boot_magic;
+		magic_len = sizeof(non_unified_boot_magic);
+	}
+
+	size = s.st_size;
+#if MEMBASE
+	base = MEMBASE;
+#else
+	base = 0;
+#endif
+
+	printf("Image Destination Pointer: 0x%x\n", base);
+
+	magic[0] = 0x00000005; /* appsbl */
+	magic[1] = 0x00000003; //Flash_partition_version /* nand */
+	magic[2] = 0x00000000; //image source pointer
+	magic[3] = base;       //image destination pointer
+	magic[4] = size + cert_chain_size + signature_size; //image size
+	magic[5] = size;       //code size
+	magic[6] = base + size;
+	magic[7] = signature_size;
+	magic[8] = size + base + signature_size;
+	magic[9] = cert_chain_size;
+
+	if(unified_boot == 1)
+	{
+		magic[10] = 0x33836685;	/* cookie magic number */
+		magic[11] = 0x00000001;	/* cookie version */
+		magic[12] = 0x00000002;	/* file formats */
+		magic[13] = 0x00000000;
+		magic[14] = 0x00000000;	/* not setting size for boot.img */
+		magic[15] = 0x00000000;
+		magic[16] = 0x00000000;
+		magic[17] = 0x00000000;
+		magic[18] = 0x00000000;
+		magic[19] = 0x00000000;
+	}
+
+	fd = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0644);
+	if(fd < 0) {
+		perror("cannot open header for writing");
+		return -1;
+	}
+	if(write(fd, magic, magic_len) != magic_len) {
+		perror("cannot write header");
+		close(fd);
+		unlink(argv[2]);
+		return -1;
+	}
+	close(fd);
+
+	if(secure_boot && argc > 6){
+		FILE * input_file;
+		FILE * output_file;
+		unsigned buff_size = 1;
+		char buf[buff_size];
+		unsigned bytes_left;
+		unsigned current_cert_chain_size = 0;
+		int padding_size = 0;
+		int i;
+
+		if((output_file = fopen(argv[6], "wb"))==NULL){
+			perror("ERROR: Occured during fopen");
+			return -1;
+		}
+		printf("Certificate Chain Output File: %s\n", argv[6]);
+
+		for(i = 8; i < argc; i++){
+			if((input_file = fopen(argv[i], "rb"))==NULL){
+				perror("ERROR: Occured during fopen");
+				return -1;
+			}
+			stat(argv[i], &s);
+			bytes_left = s.st_size;
+			current_cert_chain_size += bytes_left;
+			if(cat(input_file, output_file, bytes_left, buff_size))
+				return -1;
+			fclose(input_file);
+		}
+
+		//Pad certifcate chain to the max expected size from input
+		memset(buf, 0xFF, sizeof(buf));
+		padding_size = cert_chain_size - current_cert_chain_size;
+
+		if(padding_size <0){
+			fprintf(stderr, "ERROR: Input certificate chain"
+					" (Size=%d) is larger than the maximum"
+					" specified (Size=%d)\n",
+				current_cert_chain_size, cert_chain_size);
+			return -1;
+		}
+
+		bytes_left = (padding_size > 0) ? padding_size : 0;
+		while(bytes_left){
+			if(!ferror(output_file))
+				bytes_left -= fwrite(buf,
+						     sizeof(buf),
+						     buff_size,
+						     output_file);
+			else{
+				fprintf(stderr, "ERROR: Occured during"
+						" certifcate chain padding\n");
+				return -1;
+			}
+		}
+		fclose(output_file);
+
+		/* Concat and combine to signed image.
+		 * Format [HDR][RAW APPSBOOT][PADDED CERT CHAIN]
+		 */
+		if((output_file = fopen(argv[4], "wb"))==NULL){
+			perror("ERROR: Occured during fopen");
+			return -1;
+		}
+		printf("Image Output File: %s\n", argv[4]);
+
+		//Header
+		if((input_file = fopen(argv[2], "rb"))==NULL){
+			perror("ERROR: Occured during fopen");
+			return -1;
+		}
+		stat(argv[2], &s);
+		if(cat(input_file, output_file, s.st_size, buff_size))
+			return -1;
+		fclose(input_file);
+
+		//Raw Appsbl
+		if((input_file = fopen(argv[1], "rb"))==NULL){
+			perror("ERROR: Occured during fopen");
+			return -1;
+		}
+		stat(argv[1], &s);
+		if(cat(input_file, output_file, s.st_size, buff_size))
+			return -1;
+		fclose(input_file);
+
+		//Signature
+		if((input_file = fopen(argv[7], "rb"))==NULL){
+			perror("ERROR: Occured during fopen");
+			return -1;
+		}
+		stat(argv[7], &s);
+		if(cat(input_file, output_file, s.st_size, buff_size))
+			return -1;
+		fclose(input_file);
+
+		//Certifcate Chain
+		if((input_file = fopen(argv[6], "rb"))==NULL){
+			perror("ERROR: Occured during fopen");
+			return -1;
+		}
+		if(cat(input_file, output_file,
+		       (current_cert_chain_size + padding_size), buff_size))
+			return -1;
+		fclose(input_file);
+
+		fclose(output_file);
+
+	}
+	else if(argc == 5 || argc == 6){
+		FILE * input_file;
+		FILE * output_file;
+		unsigned buff_size = 1;
+		char buf[buff_size];
+
+		/* Concat and combine to unsigned image.
+		 * Format [HDR][RAW APPSBOOT]
+		 */
+		if((output_file = fopen(argv[4], "wb"))==NULL){
+			perror("ERROR: Occured during fopen");
+			return -1;
+		}
+		printf("Image Output File: %s\n", argv[4]);
+
+		//Header
+		if((input_file = fopen(argv[2], "rb"))==NULL){
+			perror("ERROR: Occured during fopen");
+			return -1;
+		}
+		stat(argv[2], &s);
+		if(cat(input_file, output_file, s.st_size, buff_size))
+			return -1;
+		fclose(input_file);
+
+		//Raw Appsbl
+		if((input_file = fopen(argv[1], "rb"))==NULL){
+			perror("ERROR: Occured during fopen");
+			return -1;
+		}
+		stat(argv[1], &s);
+		if(cat(input_file, output_file, s.st_size, buff_size))
+			return -1;
+		fclose(input_file);
+		fclose(output_file);
+	}
+
+	printf("Done execution\n");
+
+	return 0;
+}