[people/ms/u-boot.git] / arch / powerpc / lib / bootm.c

/*
 * (C) Copyright 2008 Semihalf
 *
 * (C) Copyright 2000-2006
 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */


#include <common.h>
#include <watchdog.h>
#include <command.h>
#include <image.h>
#include <malloc.h>
#include <u-boot/zlib.h>
#include <bzlib.h>
#include <environment.h>
#include <asm/byteorder.h>
#include <asm/mp.h>
#include <bootm.h>
#include <vxworks.h>

#if defined(CONFIG_OF_LIBFDT)
#include <libfdt.h>
#include <fdt_support.h>
#endif

#ifdef CONFIG_SYS_INIT_RAM_LOCK
#include <asm/cache.h>
#endif

DECLARE_GLOBAL_DATA_PTR;

static ulong get_sp (void);
extern void ft_fixup_num_cores(void *blob);
static void set_clocks_in_mhz (bd_t *kbd);

#ifndef CONFIG_SYS_LINUX_LOWMEM_MAX_SIZE
#define CONFIG_SYS_LINUX_LOWMEM_MAX_SIZE	(768*1024*1024)
#endif

int arch_fixup_fdt(void *blob)
{
	return 0;
}

static void boot_jump_linux(bootm_headers_t *images)
{
	void	(*kernel)(bd_t *, ulong r4, ulong r5, ulong r6,
			  ulong r7, ulong r8, ulong r9);
#ifdef CONFIG_OF_LIBFDT
	char *of_flat_tree = images->ft_addr;
#endif

	kernel = (void (*)(bd_t *, ulong, ulong, ulong,
			   ulong, ulong, ulong))images->ep;
	debug ("## Transferring control to Linux (at address %08lx) ...\n",
		(ulong)kernel);

	bootstage_mark(BOOTSTAGE_ID_RUN_OS);

#ifdef CONFIG_BOOTSTAGE_FDT
	bootstage_fdt_add_report();
#endif
#ifdef CONFIG_BOOTSTAGE_REPORT
	bootstage_report();
#endif

#if defined(CONFIG_SYS_INIT_RAM_LOCK) && !defined(CONFIG_E500)
	unlock_ram_in_cache();
#endif

#if defined(CONFIG_OF_LIBFDT)
	if (of_flat_tree) {	/* device tree; boot new style */
		/*
		 * Linux Kernel Parameters (passing device tree):
		 *   r3: pointer to the fdt
		 *   r4: 0
		 *   r5: 0
		 *   r6: epapr magic
		 *   r7: size of IMA in bytes
		 *   r8: 0
		 *   r9: 0
		 */
		debug ("   Booting using OF flat tree...\n");
		WATCHDOG_RESET ();
		(*kernel) ((bd_t *)of_flat_tree, 0, 0, EPAPR_MAGIC,
			   env_get_bootm_mapsize(), 0, 0);
		/* does not return */
	} else
#endif
	{
		/*
		 * Linux Kernel Parameters (passing board info data):
		 *   r3: ptr to board info data
		 *   r4: initrd_start or 0 if no initrd
		 *   r5: initrd_end - unused if r4 is 0
		 *   r6: Start of command line string
		 *   r7: End   of command line string
		 *   r8: 0
		 *   r9: 0
		 */
		ulong cmd_start = images->cmdline_start;
		ulong cmd_end = images->cmdline_end;
		ulong initrd_start = images->initrd_start;
		ulong initrd_end = images->initrd_end;
		bd_t *kbd = images->kbd;

		debug ("   Booting using board info...\n");
		WATCHDOG_RESET ();
		(*kernel) (kbd, initrd_start, initrd_end,
			   cmd_start, cmd_end, 0, 0);
		/* does not return */
	}
	return ;
}

void arch_lmb_reserve(struct lmb *lmb)
{
	phys_size_t bootm_size;
	ulong size, sp, bootmap_base;

	bootmap_base = env_get_bootm_low();
	bootm_size = env_get_bootm_size();

#ifdef DEBUG
	if (((u64)bootmap_base + bootm_size) >
	    (CONFIG_SYS_SDRAM_BASE + (u64)gd->ram_size))
		puts("WARNING: bootm_low + bootm_size exceed total memory\n");
	if ((bootmap_base + bootm_size) > get_effective_memsize())
		puts("WARNING: bootm_low + bootm_size exceed eff. memory\n");
#endif

	size = min(bootm_size, get_effective_memsize());
	size = min(size, (ulong)CONFIG_SYS_LINUX_LOWMEM_MAX_SIZE);

	if (size < bootm_size) {
		ulong base = bootmap_base + size;
		printf("WARNING: adjusting available memory to %lx\n", size);
		lmb_reserve(lmb, base, bootm_size - size);
	}

	/*
	 * 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\n", sp);

	/* adjust sp by 4K to be safe */
	sp -= 4096;
	lmb_reserve(lmb, sp, (CONFIG_SYS_SDRAM_BASE + get_effective_memsize() - sp));

#ifdef CONFIG_MP
	cpu_mp_lmb_reserve(lmb);
#endif

	return ;
}

static void boot_prep_linux(bootm_headers_t *images)
{
#ifdef CONFIG_MP
	/*
	 * if we are MP make sure to flush the device tree so any changes are
	 * made visibile to all other cores.  In AMP boot scenarios the cores
	 * might not be HW cache coherent with each other.
	 */
	flush_cache((unsigned long)images->ft_addr, images->ft_len);
#endif
}

static int boot_cmdline_linux(bootm_headers_t *images)
{
	ulong of_size = images->ft_len;
	struct lmb *lmb = &images->lmb;
	ulong *cmd_start = &images->cmdline_start;
	ulong *cmd_end = &images->cmdline_end;

	int ret = 0;

	if (!of_size) {
		/* allocate space and init command line */
		ret = boot_get_cmdline (lmb, cmd_start, cmd_end);
		if (ret) {
			puts("ERROR with allocation of cmdline\n");
			return ret;
		}
	}

	return ret;
}

static int boot_bd_t_linux(bootm_headers_t *images)
{
	ulong of_size = images->ft_len;
	struct lmb *lmb = &images->lmb;
	bd_t **kbd = &images->kbd;

	int ret = 0;

	if (!of_size) {
		/* allocate space for kernel copy of board info */
		ret = boot_get_kbd (lmb, kbd);
		if (ret) {
			puts("ERROR with allocation of kernel bd\n");
			return ret;
		}
		set_clocks_in_mhz(*kbd);
	}

	return ret;
}

static int boot_body_linux(bootm_headers_t *images)
{
	int ret;

	/* allocate space for kernel copy of board info */
	ret = boot_bd_t_linux(images);
	if (ret)
		return ret;

	ret = image_setup_linux(images);
	if (ret)
		return ret;

	return 0;
}

noinline
int do_bootm_linux(int flag, int argc, char * const argv[], bootm_headers_t *images)
{
	int	ret;

	if (flag & BOOTM_STATE_OS_CMDLINE) {
		boot_cmdline_linux(images);
		return 0;
	}

	if (flag & BOOTM_STATE_OS_BD_T) {
		boot_bd_t_linux(images);
		return 0;
	}

	if (flag & BOOTM_STATE_OS_PREP) {
		boot_prep_linux(images);
		return 0;
	}

	boot_prep_linux(images);
	ret = boot_body_linux(images);
	if (ret)
		return ret;
	boot_jump_linux(images);

	return 0;
}

static ulong get_sp (void)
{
	ulong sp;

	asm( "mr %0,1": "=r"(sp) : );
	return sp;
}

static void set_clocks_in_mhz (bd_t *kbd)
{
	char	*s;

	s = env_get("clocks_in_mhz");
	if (s) {
		/* convert all clock information to MHz */
		kbd->bi_intfreq /= 1000000L;
		kbd->bi_busfreq /= 1000000L;
#if defined(CONFIG_CPM2)
		kbd->bi_cpmfreq /= 1000000L;
		kbd->bi_brgfreq /= 1000000L;
		kbd->bi_sccfreq /= 1000000L;
		kbd->bi_vco	/= 1000000L;
#endif
	}
}

#if defined(CONFIG_BOOTM_VXWORKS)
void boot_prep_vxworks(bootm_headers_t *images)
{
#if defined(CONFIG_OF_LIBFDT)
	int off;
	u64 base, size;

	if (!images->ft_addr)
		return;

	base = (u64)gd->bd->bi_memstart;
	size = (u64)gd->bd->bi_memsize;

	off = fdt_path_offset(images->ft_addr, "/memory");
	if (off < 0)
		fdt_fixup_memory(images->ft_addr, base, size);

#if defined(CONFIG_MP)
#if defined(CONFIG_MPC85xx)
	ft_fixup_cpu(images->ft_addr, base + size);
	ft_fixup_num_cores(images->ft_addr);
#elif defined(CONFIG_MPC86xx)
	off = fdt_add_mem_rsv(images->ft_addr,
			determine_mp_bootpg(NULL), (u64)4096);
	if (off < 0)
		printf("## WARNING %s: %s\n", __func__, fdt_strerror(off));
	ft_fixup_num_cores(images->ft_addr);
#endif
	flush_cache((unsigned long)images->ft_addr, images->ft_len);
#endif
#endif
}

void boot_jump_vxworks(bootm_headers_t *images)
{
	/* PowerPC VxWorks boot interface conforms to the ePAPR standard
	 * general purpuse registers:
	 *
	 *	r3: Effective address of the device tree image
	 *	r4: 0
	 *	r5: 0
	 *	r6: ePAPR magic value
	 *	r7: shall be the size of the boot IMA in bytes
	 *	r8: 0
	 *	r9: 0
	 *	TCR: WRC = 0, no watchdog timer reset will occur
	 */
	WATCHDOG_RESET();

	((void (*)(void *, ulong, ulong, ulong,
		ulong, ulong, ulong))images->ep)(images->ft_addr,
		0, 0, EPAPR_MAGIC, env_get_bootm_mapsize(), 0, 0);
}
#endif
Commit	Line	Data
5d3cc55e MB	1	/*
	2	* (C) Copyright 2008 Semihalf
	3	*
	4	* (C) Copyright 2000-2006
	5	* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
	6	*
1a459660	7	* SPDX-License-Identifier: GPL-2.0+
5d3cc55e MB	8	*/
5d3cc55e MB	9
7582438c	10
5d3cc55e MB	11	#include <common.h>
	12	#include <watchdog.h>
	13	#include <command.h>
	14	#include <image.h>
	15	#include <malloc.h>
a31e091a	16	#include <u-boot/zlib.h>
5d3cc55e MB	17	#include <bzlib.h>
	18	#include <environment.h>
	19	#include <asm/byteorder.h>
561e710a	20	#include <asm/mp.h>
08dd988b CL	21	#include <bootm.h>
08dd988b CL	22	#include <vxworks.h>
5d3cc55e MB	23
5d3cc55e MB	24	#if defined(CONFIG_OF_LIBFDT)
5d3cc55e MB	25	#include <libfdt.h>
5d3cc55e MB	26	#include <fdt_support.h>
9c67352f WD	27	#endif
	28
	29	#ifdef CONFIG_SYS_INIT_RAM_LOCK
	30	#include <asm/cache.h>
5d3cc55e MB	31	#endif
5d3cc55e MB	32
5d3cc55e	33	DECLARE_GLOBAL_DATA_PTR;
5d3cc55e	34
ceaed2b1	35	static ulong get_sp (void);
871a57bb	36	extern void ft_fixup_num_cores(void *blob);
b6b0fe64	37	static void set_clocks_in_mhz (bd_t *kbd);
5d3cc55e	38
6d0f6bcf JCPV	39	#ifndef CONFIG_SYS_LINUX_LOWMEM_MAX_SIZE
6d0f6bcf JCPV	40	#define CONFIG_SYS_LINUX_LOWMEM_MAX_SIZE (76810241024)
d3f2fa0d KG	41	#endif
d3f2fa0d KG	42
63c09417 MY	43	int arch_fixup_fdt(void *blob)
	44	{
	45	return 0;
	46	}
	47
5a98127d KG	48	static void boot_jump_linux(bootm_headers_t *images)
	49	{
	50	void (kernel)(bd_t , ulong r4, ulong r5, ulong r6,
	51	ulong r7, ulong r8, ulong r9);
	52	#ifdef CONFIG_OF_LIBFDT
	53	char *of_flat_tree = images->ft_addr;
	54	#endif
	55
	56	kernel = (void ()(bd_t , ulong, ulong, ulong,
	57	ulong, ulong, ulong))images->ep;
	58	debug ("## Transferring control to Linux (at address %08lx) ...\n",
	59	(ulong)kernel);
	60
770605e4	61	bootstage_mark(BOOTSTAGE_ID_RUN_OS);
5a98127d	62
b892465d MC	63	#ifdef CONFIG_BOOTSTAGE_FDT
	64	bootstage_fdt_add_report();
	65	#endif
	66	#ifdef CONFIG_BOOTSTAGE_REPORT
	67	bootstage_report();
	68	#endif
	69
9c67352f WD	70	#if defined(CONFIG_SYS_INIT_RAM_LOCK) && !defined(CONFIG_E500)
	71	unlock_ram_in_cache();
	72	#endif
	73
5a98127d KG	74	#if defined(CONFIG_OF_LIBFDT)
	75	if (of_flat_tree) { /* device tree; boot new style */
	76	/*
	77	* Linux Kernel Parameters (passing device tree):
	78	* r3: pointer to the fdt
	79	* r4: 0
	80	* r5: 0
	81	* r6: epapr magic
	82	* r7: size of IMA in bytes
	83	* r8: 0
	84	* r9: 0
	85	*/
5a98127d	86	debug (" Booting using OF flat tree...\n");
7ff66bb0	87	WATCHDOG_RESET ();
5a98127d	88	(kernel) ((bd_t )of_flat_tree, 0, 0, EPAPR_MAGIC,
723806cc	89	env_get_bootm_mapsize(), 0, 0);
5a98127d KG	90	/* does not return */
	91	} else
	92	#endif
	93	{
	94	/*
	95	* Linux Kernel Parameters (passing board info data):
	96	* r3: ptr to board info data
	97	* r4: initrd_start or 0 if no initrd
	98	* r5: initrd_end - unused if r4 is 0
	99	* r6: Start of command line string
	100	* r7: End of command line string
	101	* r8: 0
	102	* r9: 0
	103	*/
	104	ulong cmd_start = images->cmdline_start;
	105	ulong cmd_end = images->cmdline_end;
	106	ulong initrd_start = images->initrd_start;
	107	ulong initrd_end = images->initrd_end;
	108	bd_t *kbd = images->kbd;
	109
	110	debug (" Booting using board info...\n");
7ff66bb0	111	WATCHDOG_RESET ();
5a98127d KG	112	(*kernel) (kbd, initrd_start, initrd_end,
	113	cmd_start, cmd_end, 0, 0);
	114	/* does not return */
	115	}
	116	return ;
	117	}
	118
76da19df	119	void arch_lmb_reserve(struct lmb *lmb)
5d3cc55e	120	{
391fd93a	121	phys_size_t bootm_size;
76da19df	122	ulong size, sp, bootmap_base;
c160a954	123
723806cc SG	124	bootmap_base = env_get_bootm_low();
723806cc SG	125	bootm_size = env_get_bootm_size();
d3f2fa0d KG	126
d3f2fa0d KG	127	#ifdef DEBUG
391fd93a	128	if (((u64)bootmap_base + bootm_size) >
6d0f6bcf	129	(CONFIG_SYS_SDRAM_BASE + (u64)gd->ram_size))
d3f2fa0d	130	puts("WARNING: bootm_low + bootm_size exceed total memory\n");
391fd93a	131	if ((bootmap_base + bootm_size) > get_effective_memsize())
d3f2fa0d KG	132	puts("WARNING: bootm_low + bootm_size exceed eff. memory\n");
	133	#endif
	134
391fd93a	135	size = min(bootm_size, get_effective_memsize());
b4141195	136	size = min(size, (ulong)CONFIG_SYS_LINUX_LOWMEM_MAX_SIZE);
d3f2fa0d	137
391fd93a	138	if (size < bootm_size) {
d3f2fa0d	139	ulong base = bootmap_base + size;
dc4b0b38	140	printf("WARNING: adjusting available memory to %lx\n", size);
391fd93a	141	lmb_reserve(lmb, base, bootm_size - size);
d3f2fa0d	142	}
e822d7fc	143
5d3cc55e MB	144	/*
	145	* Booting a (Linux) kernel image
	146	*
	147	* Allocate space for command line and board info - the
	148	* address should be as high as possible within the reach of
6d0f6bcf	149	* the kernel (see CONFIG_SYS_BOOTMAPSZ settings), but in unused
5d3cc55e MB	150	* memory, which means far enough below the current stack
	151	* pointer.
	152	*/
b6b0fe64	153	sp = get_sp();
d3f2fa0d	154	debug ("## Current stack ends at 0x%08lx\n", sp);
5d3cc55e	155
3882d7a5 NB	156	/* adjust sp by 4K to be safe */
3882d7a5 NB	157	sp -= 4096;
6d0f6bcf	158	lmb_reserve(lmb, sp, (CONFIG_SYS_SDRAM_BASE + get_effective_memsize() - sp));
5d3cc55e	159
561e710a KG	160	#ifdef CONFIG_MP
	161	cpu_mp_lmb_reserve(lmb);
	162	#endif
	163
76da19df KG	164	return ;
	165	}
	166
3b200110 KG	167	static void boot_prep_linux(bootm_headers_t *images)
	168	{
	169	#ifdef CONFIG_MP
	170	/*
	171	* if we are MP make sure to flush the device tree so any changes are
	172	* made visibile to all other cores. In AMP boot scenarios the cores
	173	* might not be HW cache coherent with each other.
	174	*/
	175	flush_cache((unsigned long)images->ft_addr, images->ft_len);
	176	#endif
	177	}
	178
5a98127d KG	179	static int boot_cmdline_linux(bootm_headers_t *images)
5a98127d KG	180	{
5a98127d KG	181	ulong of_size = images->ft_len;
	182	struct lmb *lmb = &images->lmb;
	183	ulong *cmd_start = &images->cmdline_start;
	184	ulong *cmd_end = &images->cmdline_end;
76da19df	185
5a98127d	186	int ret = 0;
76da19df	187
27953493 KG	188	if (!of_size) {
27953493 KG	189	/* allocate space and init command line */
590d3cac	190	ret = boot_get_cmdline (lmb, cmd_start, cmd_end);
e822d7fc KG	191	if (ret) {
e822d7fc KG	192	puts("ERROR with allocation of cmdline\n");
5a98127d	193	return ret;
e822d7fc	194	}
5a98127d KG	195	}
	196
	197	return ret;
	198	}
	199
	200	static int boot_bd_t_linux(bootm_headers_t *images)
	201	{
5a98127d KG	202	ulong of_size = images->ft_len;
	203	struct lmb *lmb = &images->lmb;
	204	bd_t **kbd = &images->kbd;
	205
	206	int ret = 0;
27953493	207
5a98127d	208	if (!of_size) {
27953493	209	/* allocate space for kernel copy of board info */
590d3cac	210	ret = boot_get_kbd (lmb, kbd);
e822d7fc KG	211	if (ret) {
e822d7fc KG	212	puts("ERROR with allocation of kernel bd\n");
5a98127d	213	return ret;
e822d7fc	214	}
5a98127d	215	set_clocks_in_mhz(*kbd);
27953493	216	}
5d3cc55e	217
5a98127d KG	218	return ret;
	219	}
	220
	221	static int boot_body_linux(bootm_headers_t *images)
	222	{
5a98127d KG	223	int ret;
5a98127d KG	224
5a98127d KG	225	/* allocate space for kernel copy of board info */
	226	ret = boot_bd_t_linux(images);
	227	if (ret)
	228	return ret;
	229
3e51266a	230	ret = image_setup_linux(images);
06a09918	231	if (ret)
5a98127d	232	return ret;
5d3cc55e	233
5a98127d KG	234	return 0;
5a98127d KG	235	}
d45d5a18	236
eef1cf2d	237	noinline
54841ab5	238	int do_bootm_linux(int flag, int argc, char * const argv[], bootm_headers_t *images)
5a98127d KG	239	{
5a98127d KG	240	int ret;
5d3cc55e	241
5a98127d KG	242	if (flag & BOOTM_STATE_OS_CMDLINE) {
	243	boot_cmdline_linux(images);
	244	return 0;
	245	}
5d3cc55e	246
5a98127d KG	247	if (flag & BOOTM_STATE_OS_BD_T) {
	248	boot_bd_t_linux(images);
	249	return 0;
	250	}
5d3cc55e	251
3b200110 KG	252	if (flag & BOOTM_STATE_OS_PREP) {
3b200110 KG	253	boot_prep_linux(images);
5a98127d	254	return 0;
3b200110	255	}
a15b0710	256
3b200110	257	boot_prep_linux(images);
5a98127d KG	258	ret = boot_body_linux(images);
	259	if (ret)
	260	return ret;
	261	boot_jump_linux(images);
	262
	263	return 0;
5d3cc55e	264	}
d3c5eb6d	265
ceaed2b1 MB	266	static ulong get_sp (void)
	267	{
	268	ulong sp;
	269
	270	asm( "mr %0,1": "=r"(sp) : );
	271	return sp;
	272	}
	273
b6b0fe64 MB	274	static void set_clocks_in_mhz (bd_t *kbd)
	275	{
	276	char *s;
	277
00caae6d SG	278	s = env_get("clocks_in_mhz");
00caae6d SG	279	if (s) {
b6b0fe64 MB	280	/* convert all clock information to MHz */
	281	kbd->bi_intfreq /= 1000000L;
	282	kbd->bi_busfreq /= 1000000L;
b6b0fe64 MB	283	#if defined(CONFIG_CPM2)
	284	kbd->bi_cpmfreq /= 1000000L;
	285	kbd->bi_brgfreq /= 1000000L;
	286	kbd->bi_sccfreq /= 1000000L;
438a4c11	287	kbd->bi_vco /= 1000000L;
b6b0fe64	288	#endif
b6b0fe64 MB	289	}
b6b0fe64 MB	290	}
871a57bb MY	291
	292	#if defined(CONFIG_BOOTM_VXWORKS)
	293	void boot_prep_vxworks(bootm_headers_t *images)
	294	{
	295	#if defined(CONFIG_OF_LIBFDT)
	296	int off;
	297	u64 base, size;
	298
	299	if (!images->ft_addr)
	300	return;
	301
	302	base = (u64)gd->bd->bi_memstart;
	303	size = (u64)gd->bd->bi_memsize;
	304
	305	off = fdt_path_offset(images->ft_addr, "/memory");
	306	if (off < 0)
	307	fdt_fixup_memory(images->ft_addr, base, size);
	308
	309	#if defined(CONFIG_MP)
	310	#if defined(CONFIG_MPC85xx)
	311	ft_fixup_cpu(images->ft_addr, base + size);
	312	ft_fixup_num_cores(images->ft_addr);
	313	#elif defined(CONFIG_MPC86xx)
	314	off = fdt_add_mem_rsv(images->ft_addr,
	315	determine_mp_bootpg(NULL), (u64)4096);
	316	if (off < 0)
	317	printf("## WARNING %s: %s\n", __func__, fdt_strerror(off));
	318	ft_fixup_num_cores(images->ft_addr);
	319	#endif
	320	flush_cache((unsigned long)images->ft_addr, images->ft_len);
	321	#endif
	322	#endif
	323	}
	324
	325	void boot_jump_vxworks(bootm_headers_t *images)
	326	{
	327	/* PowerPC VxWorks boot interface conforms to the ePAPR standard
	328	* general purpuse registers:
	329	*
	330	* r3: Effective address of the device tree image
	331	* r4: 0
	332	* r5: 0
	333	* r6: ePAPR magic value
	334	* r7: shall be the size of the boot IMA in bytes
	335	* r8: 0
	336	* r9: 0
	337	* TCR: WRC = 0, no watchdog timer reset will occur
	338	*/
	339	WATCHDOG_RESET();
	340
	341	((void ()(void , ulong, ulong, ulong,
	342	ulong, ulong, ulong))images->ep)(images->ft_addr,
723806cc	343	0, 0, EPAPR_MAGIC, env_get_bootm_mapsize(), 0, 0);
871a57bb MY	344	}
871a57bb MY	345	#endif