Skip to content
Snippets Groups Projects
bootm.c 7.6 KiB
Newer Older
  • Learn to ignore specific revisions
  • /* Copyright (C) 2011
     * Corscience GmbH & Co. KG - Simon Schwarz <schwarz@corscience.de>
     *  - Added prep subcommand support
     *  - Reorganized source - modeled after powerpc version
     *
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
     * (C) Copyright 2002
     * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
     * Marius Groeger <mgroeger@sysgo.de>
     *
     * Copyright (C) 2001  Erik Mouw (J.A.K.Mouw@its.tudelft.nl)
     *
     * 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
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
     * 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
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
     */
    
    #include <common.h>
    #include <command.h>
    #include <image.h>
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    #include <asm/byteorder.h>
    
    #include <libfdt.h>
    #include <fdt_support.h>
    
    #include <asm/bootm.h>
    
    #include <linux/compiler.h>
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    static struct tag *params;
    
    static ulong get_sp(void)
    {
    	ulong ret;
    
    	asm("mov %0, sp" : "=r"(ret) : );
    	return ret;
    }
    
    
    void arch_lmb_reserve(struct lmb *lmb)
    {
    	ulong sp;
    
    	/*
    	 * Booting a (Linux) kernel image
    	 *
    	 * Allocate space for command line and board info - the
    	 * address should be as high as possible within the reach of
    	 * the kernel (see CONFIG_SYS_BOOTMAPSZ settings), but in unused
    	 * memory, which means far enough below the current stack
    	 * pointer.
    	 */
    	sp = get_sp();
    	debug("## Current stack ends at 0x%08lx ", sp);
    
    
    	/* adjust sp by 4K to be safe */
    	sp -= 4096;
    
    	lmb_reserve(lmb, sp,
    		    gd->bd->bi_dram[0].start + gd->bd->bi_dram[0].size - sp);
    }
    
    
    /**
     * announce_and_cleanup() - Print message and prepare for kernel boot
     *
     * @fake: non-zero to do everything except actually boot
     */
    static void announce_and_cleanup(int fake)
    
    	printf("\nStarting kernel ...%s\n\n", fake ?
    		"(fake run for tracing)" : "");
    
    	bootstage_mark_name(BOOTSTAGE_ID_BOOTM_HANDOFF, "start_kernel");
    
    #ifdef CONFIG_BOOTSTAGE_FDT
    
    	if (flag == BOOTM_STATE_OS_FAKE_GO)
    		bootstage_fdt_add_report();
    
    #ifdef CONFIG_BOOTSTAGE_REPORT
    	bootstage_report();
    #endif
    
    #ifdef CONFIG_USB_DEVICE
    	udc_disconnect();
    
    #endif
    
    	cleanup_before_linux();
    }
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    
    
    static void setup_start_tag (bd_t *bd)
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    {
    
    	params = (struct tag *)bd->bi_boot_params;
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    
    
    	params->hdr.tag = ATAG_CORE;
    	params->hdr.size = tag_size (tag_core);
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    
    
    	params->u.core.flags = 0;
    	params->u.core.pagesize = 0;
    	params->u.core.rootdev = 0;
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    
    
    	params = tag_next (params);
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    }
    
    
    static void setup_memory_tags(bd_t *bd)
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    {
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    
    
    	for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) {
    		params->hdr.tag = ATAG_MEM;
    		params->hdr.size = tag_size (tag_mem32);
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    
    
    		params->u.mem.start = bd->bi_dram[i].start;
    		params->u.mem.size = bd->bi_dram[i].size;
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    
    
    		params = tag_next (params);
    	}
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    }
    
    
    static void setup_commandline_tag(bd_t *bd, char *commandline)
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    {
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    
    
    	if (!commandline)
    		return;
    
    
    	/* eat leading white space */
    	for (p = commandline; *p == ' '; p++);
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    
    
    	/* skip non-existent command lines so the kernel will still
    	 * use its default command line.
    	 */
    	if (*p == '\0')
    		return;
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    
    
    	params->hdr.tag = ATAG_CMDLINE;
    	params->hdr.size =
    		(sizeof (struct tag_header) + strlen (p) + 1 + 4) >> 2;
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    
    
    	strcpy (params->u.cmdline.cmdline, p);
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    
    
    	params = tag_next (params);
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    }
    
    
    static void setup_initrd_tag(bd_t *bd, ulong initrd_start, ulong initrd_end)
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    {
    
    	/* an ATAG_INITRD node tells the kernel where the compressed
    	 * ramdisk can be found. ATAG_RDIMG is a better name, actually.
    	 */
    
    	params->hdr.tag = ATAG_INITRD2;
    
    	params->hdr.size = tag_size (tag_initrd);
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    
    
    	params->u.initrd.start = initrd_start;
    	params->u.initrd.size = initrd_end - initrd_start;
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    
    
    	params = tag_next (params);
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    }
    
    
    static void setup_serial_tag(struct tag **tmp)
    
    {
    	struct tag *params = *tmp;
    	struct tag_serialnr serialnr;
    
    	get_board_serial(&serialnr);
    	params->hdr.tag = ATAG_SERIAL;
    	params->hdr.size = tag_size (tag_serialnr);
    	params->u.serialnr.low = serialnr.low;
    	params->u.serialnr.high= serialnr.high;
    	params = tag_next (params);
    	*tmp = params;
    }
    
    
    static void setup_revision_tag(struct tag **in_params)
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    {
    	u32 rev = 0;
    
    	rev = get_board_rev();
    	params->hdr.tag = ATAG_REVISION;
    	params->hdr.size = tag_size (tag_revision);
    	params->u.revision.rev = rev;
    	params = tag_next (params);
    }
    
    
    static void setup_end_tag(bd_t *bd)
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    {
    
    	params->hdr.tag = ATAG_NONE;
    	params->hdr.size = 0;
    
    Wolfgang Denk's avatar
    Wolfgang Denk committed
    }
    
    
    __weak void setup_board_tags(struct tag **in_params) {}
    
    
    /* Subcommand: PREP */
    static void boot_prep_linux(bootm_headers_t *images)
    {
    	char *commandline = getenv("bootargs");
    
    
    	if (IMAGE_ENABLE_OF_LIBFDT && images->ft_len) {
    
    #ifdef CONFIG_OF_LIBFDT
    		debug("using: FDT\n");
    
    		if (image_setup_linux(images)) {
    
    			printf("FDT creation failed! hanging...");
    			hang();
    		}
    #endif
    
    	} else if (BOOTM_ENABLE_TAGS) {
    
    		debug("using: ATAGS\n");
    		setup_start_tag(gd->bd);
    
    		if (BOOTM_ENABLE_SERIAL_TAG)
    			setup_serial_tag(&params);
    		if (BOOTM_ENABLE_CMDLINE_TAG)
    			setup_commandline_tag(gd->bd, commandline);
    		if (BOOTM_ENABLE_REVISION_TAG)
    			setup_revision_tag(&params);
    		if (BOOTM_ENABLE_MEMORY_TAGS)
    			setup_memory_tags(gd->bd);
    		if (BOOTM_ENABLE_INITRD_TAG) {
    			if (images->rd_start && images->rd_end) {
    				setup_initrd_tag(gd->bd, images->rd_start,
    						 images->rd_end);
    			}
    		}
    
    		setup_board_tags(&params);
    
    		setup_end_tag(gd->bd);
    
    		printf("FDT and ATAGS support not compiled in - hanging\n");
    		hang();
    	}
    }
    
    /* Subcommand: GO */
    
    static void boot_jump_linux(bootm_headers_t *images, int flag)
    
    {
    	unsigned long machid = gd->bd->bi_arch_number;
    	char *s;
    	void (*kernel_entry)(int zero, int arch, uint params);
    
    	unsigned long r2;
    
    	int fake = (flag & BOOTM_STATE_OS_FAKE_GO);
    
    
    	kernel_entry = (void (*)(int, int, uint))images->ep;
    
    	s = getenv("machid");
    	if (s) {
    		strict_strtoul(s, 16, &machid);
    		printf("Using machid 0x%lx from environment\n", machid);
    	}
    
    	debug("## Transferring control to Linux (at address %08lx)" \
    		"...\n", (ulong) kernel_entry);
    	bootstage_mark(BOOTSTAGE_ID_RUN_OS);
    
    	announce_and_cleanup(fake);
    
    	if (IMAGE_ENABLE_OF_LIBFDT && images->ft_len)
    
    		r2 = (unsigned long)images->ft_addr;
    	else
    		r2 = gd->bd->bi_boot_params;
    
    
    	if (!fake)
    		kernel_entry(0, machid, r2);
    
    }
    
    /* Main Entry point for arm bootm implementation
     *
     * Modeled after the powerpc implementation
     * DIFFERENCE: Instead of calling prep and go at the end
     * they are called if subcommand is equal 0.
     */
    int do_bootm_linux(int flag, int argc, char *argv[], bootm_headers_t *images)
    {
    	/* No need for those on ARM */
    	if (flag & BOOTM_STATE_OS_BD_T || flag & BOOTM_STATE_OS_CMDLINE)
    		return -1;
    
    	if (flag & BOOTM_STATE_OS_PREP) {
    		boot_prep_linux(images);
    		return 0;
    	}
    
    
    	if (flag & (BOOTM_STATE_OS_GO | BOOTM_STATE_OS_FAKE_GO)) {
    		boot_jump_linux(images, flag);
    
    		return 0;
    	}
    
    	boot_prep_linux(images);
    
    	boot_jump_linux(images, flag);
    
    
    #ifdef CONFIG_CMD_BOOTZ
    
    struct zimage_header {
    	uint32_t	code[9];
    	uint32_t	zi_magic;
    	uint32_t	zi_start;
    	uint32_t	zi_end;
    };
    
    #define	LINUX_ARM_ZIMAGE_MAGIC	0x016f2818
    
    
    int bootz_setup(ulong image, ulong *start, ulong *end)
    
    	struct zimage_header *zi;
    
    	zi = (struct zimage_header *)map_sysmem(image, 0);
    
    	if (zi->zi_magic != LINUX_ARM_ZIMAGE_MAGIC) {
    		puts("Bad Linux ARM zImage magic!\n");
    		return 1;
    	}
    
    
    	*start = zi->zi_start;
    	*end = zi->zi_end;
    
    	printf("Kernel image @ %#08lx [ %#08lx - %#08lx ]\n", image, *start,
    	      *end);
    
    #endif	/* CONFIG_CMD_BOOTZ */