[deliverable/linux.git] / arch / arm / kernel / atags_parse.c

/*
 * Tag parsing.
 *
 * Copyright (C) 1995-2001 Russell King
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

/*
 * This is the traditional way of passing data to the kernel at boot time.  Rather
 * than passing a fixed inflexible structure to the kernel, we pass a list
 * of variable-sized tags to the kernel.  The first tag must be a ATAG_CORE
 * tag for the list to be recognised (to distinguish the tagged list from
 * a param_struct).  The list is terminated with a zero-length tag (this tag
 * is not parsed in any way).
 */

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/root_dev.h>
#include <linux/screen_info.h>
#include <linux/memblock.h>

#include <asm/setup.h>
#include <asm/system_info.h>
#include <asm/page.h>
#include <asm/mach/arch.h>

#include "atags.h"

static char default_command_line[COMMAND_LINE_SIZE] __initdata = CONFIG_CMDLINE;

#ifndef MEM_SIZE
#define MEM_SIZE	(16*1024*1024)
#endif

static struct {
	struct tag_header hdr1;
	struct tag_core   core;
	struct tag_header hdr2;
	struct tag_mem32  mem;
	struct tag_header hdr3;
} default_tags __initdata = {
	{ tag_size(tag_core), ATAG_CORE },
	{ 1, PAGE_SIZE, 0xff },
	{ tag_size(tag_mem32), ATAG_MEM },
	{ MEM_SIZE },
	{ 0, ATAG_NONE }
};

static int __init parse_tag_core(const struct tag *tag)
{
	if (tag->hdr.size > 2) {
		if ((tag->u.core.flags & 1) == 0)
			root_mountflags &= ~MS_RDONLY;
		ROOT_DEV = old_decode_dev(tag->u.core.rootdev);
	}
	return 0;
}

__tagtable(ATAG_CORE, parse_tag_core);

static int __init parse_tag_mem32(const struct tag *tag)
{
	return arm_add_memory(tag->u.mem.start, tag->u.mem.size);
}

__tagtable(ATAG_MEM, parse_tag_mem32);

#if defined(CONFIG_VGA_CONSOLE) || defined(CONFIG_DUMMY_CONSOLE)
static int __init parse_tag_videotext(const struct tag *tag)
{
	screen_info.orig_x            = tag->u.videotext.x;
	screen_info.orig_y            = tag->u.videotext.y;
	screen_info.orig_video_page   = tag->u.videotext.video_page;
	screen_info.orig_video_mode   = tag->u.videotext.video_mode;
	screen_info.orig_video_cols   = tag->u.videotext.video_cols;
	screen_info.orig_video_ega_bx = tag->u.videotext.video_ega_bx;
	screen_info.orig_video_lines  = tag->u.videotext.video_lines;
	screen_info.orig_video_isVGA  = tag->u.videotext.video_isvga;
	screen_info.orig_video_points = tag->u.videotext.video_points;
	return 0;
}

__tagtable(ATAG_VIDEOTEXT, parse_tag_videotext);
#endif

#ifdef CONFIG_BLK_DEV_RAM
static int __init parse_tag_ramdisk(const struct tag *tag)
{
	extern int rd_size, rd_image_start, rd_prompt, rd_doload;

	rd_image_start = tag->u.ramdisk.start;
	rd_doload = (tag->u.ramdisk.flags & 1) == 0;
	rd_prompt = (tag->u.ramdisk.flags & 2) == 0;

	if (tag->u.ramdisk.size)
		rd_size = tag->u.ramdisk.size;

	return 0;
}

__tagtable(ATAG_RAMDISK, parse_tag_ramdisk);
#endif

static int __init parse_tag_serialnr(const struct tag *tag)
{
	system_serial_low = tag->u.serialnr.low;
	system_serial_high = tag->u.serialnr.high;
	return 0;
}

__tagtable(ATAG_SERIAL, parse_tag_serialnr);

static int __init parse_tag_revision(const struct tag *tag)
{
	system_rev = tag->u.revision.rev;
	return 0;
}

__tagtable(ATAG_REVISION, parse_tag_revision);

static int __init parse_tag_cmdline(const struct tag *tag)
{
#if defined(CONFIG_CMDLINE_EXTEND)
	strlcat(default_command_line, " ", COMMAND_LINE_SIZE);
	strlcat(default_command_line, tag->u.cmdline.cmdline,
		COMMAND_LINE_SIZE);
#elif defined(CONFIG_CMDLINE_FORCE)
	pr_warn("Ignoring tag cmdline (using the default kernel command line)\n");
#else
	strlcpy(default_command_line, tag->u.cmdline.cmdline,
		COMMAND_LINE_SIZE);
#endif
	return 0;
}

__tagtable(ATAG_CMDLINE, parse_tag_cmdline);

/*
 * Scan the tag table for this tag, and call its parse function.
 * The tag table is built by the linker from all the __tagtable
 * declarations.
 */
static int __init parse_tag(const struct tag *tag)
{
	extern struct tagtable __tagtable_begin, __tagtable_end;
	struct tagtable *t;

	for (t = &__tagtable_begin; t < &__tagtable_end; t++)
		if (tag->hdr.tag == t->tag) {
			t->parse(tag);
			break;
		}

	return t < &__tagtable_end;
}

/*
 * Parse all tags in the list, checking both the global and architecture
 * specific tag tables.
 */
static void __init parse_tags(const struct tag *t)
{
	for (; t->hdr.size; t = tag_next(t))
		if (!parse_tag(t))
			printk(KERN_WARNING
				"Ignoring unrecognised tag 0x%08x\n",
				t->hdr.tag);
}

static void __init squash_mem_tags(struct tag *tag)
{
	for (; tag->hdr.size; tag = tag_next(tag))
		if (tag->hdr.tag == ATAG_MEM)
			tag->hdr.tag = ATAG_NONE;
}

const struct machine_desc * __init
setup_machine_tags(phys_addr_t __atags_pointer, unsigned int machine_nr)
{
	struct tag *tags = (struct tag *)&default_tags;
	const struct machine_desc *mdesc = NULL, *p;
	char *from = default_command_line;

	default_tags.mem.start = PHYS_OFFSET;

	/*
	 * locate machine in the list of supported machines.
	 */
	for_each_machine_desc(p)
		if (machine_nr == p->nr) {
			printk("Machine: %s\n", p->name);
			mdesc = p;
			break;
		}

	if (!mdesc) {
		early_print("\nError: unrecognized/unsupported machine ID"
			    " (r1 = 0x%08x).\n\n", machine_nr);
		dump_machine_table(); /* does not return */
	}

	if (__atags_pointer)
		tags = phys_to_virt(__atags_pointer);
	else if (mdesc->atag_offset)
		tags = (void *)(PAGE_OFFSET + mdesc->atag_offset);

#if defined(CONFIG_DEPRECATED_PARAM_STRUCT)
	/*
	 * If we have the old style parameters, convert them to
	 * a tag list.
	 */
	if (tags->hdr.tag != ATAG_CORE)
		convert_to_tag_list(tags);
#endif
	if (tags->hdr.tag != ATAG_CORE) {
		early_print("Warning: Neither atags nor dtb found\n");
		tags = (struct tag *)&default_tags;
	}

	if (mdesc->fixup)
		mdesc->fixup(tags, &from);

	if (tags->hdr.tag == ATAG_CORE) {
		if (memblock_phys_mem_size())
			squash_mem_tags(tags);
		save_atags(tags);
		parse_tags(tags);
	}

	/* parse_early_param needs a boot_command_line */
	strlcpy(boot_command_line, from, COMMAND_LINE_SIZE);

	return mdesc;
}
Commit	Line	Data
aa783b6f NP	1	/*
	2	* Tag parsing.
	3	*
	4	* Copyright (C) 1995-2001 Russell King
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2 as
	8	* published by the Free Software Foundation.
	9	*/
	10
	11	/*
	12	* This is the traditional way of passing data to the kernel at boot time. Rather
	13	* than passing a fixed inflexible structure to the kernel, we pass a list
	14	* of variable-sized tags to the kernel. The first tag must be a ATAG_CORE
	15	* tag for the list to be recognised (to distinguish the tagged list from
	16	* a param_struct). The list is terminated with a zero-length tag (this tag
	17	* is not parsed in any way).
	18	*/
	19
	20	#include <linux/init.h>
	21	#include <linux/kernel.h>
	22	#include <linux/fs.h>
	23	#include <linux/root_dev.h>
	24	#include <linux/screen_info.h>
1c2f87c2	25	#include <linux/memblock.h>
aa783b6f NP	26
	27	#include <asm/setup.h>
	28	#include <asm/system_info.h>
	29	#include <asm/page.h>
	30	#include <asm/mach/arch.h>
	31
	32	#include "atags.h"
	33
	34	static char default_command_line[COMMAND_LINE_SIZE] __initdata = CONFIG_CMDLINE;
	35
	36	#ifndef MEM_SIZE
	37	#define MEM_SIZE (1610241024)
	38	#endif
	39
	40	static struct {
	41	struct tag_header hdr1;
	42	struct tag_core core;
	43	struct tag_header hdr2;
	44	struct tag_mem32 mem;
	45	struct tag_header hdr3;
	46	} default_tags __initdata = {
	47	{ tag_size(tag_core), ATAG_CORE },
	48	{ 1, PAGE_SIZE, 0xff },
	49	{ tag_size(tag_mem32), ATAG_MEM },
	50	{ MEM_SIZE },
	51	{ 0, ATAG_NONE }
	52	};
	53
	54	static int __init parse_tag_core(const struct tag *tag)
	55	{
	56	if (tag->hdr.size > 2) {
	57	if ((tag->u.core.flags & 1) == 0)
	58	root_mountflags &= ~MS_RDONLY;
	59	ROOT_DEV = old_decode_dev(tag->u.core.rootdev);
	60	}
	61	return 0;
	62	}
	63
	64	__tagtable(ATAG_CORE, parse_tag_core);
	65
	66	static int __init parse_tag_mem32(const struct tag *tag)
	67	{
	68	return arm_add_memory(tag->u.mem.start, tag->u.mem.size);
	69	}
	70
	71	__tagtable(ATAG_MEM, parse_tag_mem32);
	72
	73	#if defined(CONFIG_VGA_CONSOLE) \|\| defined(CONFIG_DUMMY_CONSOLE)
	74	static int __init parse_tag_videotext(const struct tag *tag)
	75	{
	76	screen_info.orig_x = tag->u.videotext.x;
	77	screen_info.orig_y = tag->u.videotext.y;
	78	screen_info.orig_video_page = tag->u.videotext.video_page;
	79	screen_info.orig_video_mode = tag->u.videotext.video_mode;
	80	screen_info.orig_video_cols = tag->u.videotext.video_cols;
	81	screen_info.orig_video_ega_bx = tag->u.videotext.video_ega_bx;
	82	screen_info.orig_video_lines = tag->u.videotext.video_lines;
	83	screen_info.orig_video_isVGA = tag->u.videotext.video_isvga;
	84	screen_info.orig_video_points = tag->u.videotext.video_points;
	85	return 0;
	86	}
	87
	88	__tagtable(ATAG_VIDEOTEXT, parse_tag_videotext);
	89	#endif
90
91	#ifdef CONFIG_BLK_DEV_RAM
92	static int __init parse_tag_ramdisk(const struct tag *tag)
93	{
94	extern int rd_size, rd_image_start, rd_prompt, rd_doload;
95
96	rd_image_start = tag->u.ramdisk.start;
97	rd_doload = (tag->u.ramdisk.flags & 1) == 0;
98	rd_prompt = (tag->u.ramdisk.flags & 2) == 0;
99
100	if (tag->u.ramdisk.size)
101	rd_size = tag->u.ramdisk.size;
102
103	return 0;
104	}
105
106	__tagtable(ATAG_RAMDISK, parse_tag_ramdisk);
107	#endif
108
109	static int __init parse_tag_serialnr(const struct tag *tag)
110	{
111	system_serial_low = tag->u.serialnr.low;
112	system_serial_high = tag->u.serialnr.high;
113	return 0;
114	}
115
116	__tagtable(ATAG_SERIAL, parse_tag_serialnr);
117
118	static int __init parse_tag_revision(const struct tag *tag)
119	{
120	system_rev = tag->u.revision.rev;
121	return 0;
122	}
123
124	__tagtable(ATAG_REVISION, parse_tag_revision);
125
126	static int __init parse_tag_cmdline(const struct tag *tag)
127	{
128	#if defined(CONFIG_CMDLINE_EXTEND)
129	strlcat(default_command_line, " ", COMMAND_LINE_SIZE);
130	strlcat(default_command_line, tag->u.cmdline.cmdline,
131	COMMAND_LINE_SIZE);
132	#elif defined(CONFIG_CMDLINE_FORCE)
8b521cb2	133	pr_warn("Ignoring tag cmdline (using the default kernel command line)\n");
aa783b6f NP	134	#else
	135	strlcpy(default_command_line, tag->u.cmdline.cmdline,
	136	COMMAND_LINE_SIZE);
	137	#endif
	138	return 0;
	139	}
	140
	141	__tagtable(ATAG_CMDLINE, parse_tag_cmdline);
	142
	143	/*
	144	* Scan the tag table for this tag, and call its parse function.
	145	* The tag table is built by the linker from all the __tagtable
	146	* declarations.
	147	*/
	148	static int __init parse_tag(const struct tag *tag)
	149	{
	150	extern struct tagtable __tagtable_begin, __tagtable_end;
	151	struct tagtable *t;
	152
	153	for (t = &__tagtable_begin; t < &__tagtable_end; t++)
	154	if (tag->hdr.tag == t->tag) {
	155	t->parse(tag);
	156	break;
	157	}
	158
	159	return t < &__tagtable_end;
	160	}
	161
	162	/*
	163	* Parse all tags in the list, checking both the global and architecture
	164	* specific tag tables.
	165	*/
	166	static void __init parse_tags(const struct tag *t)
	167	{
	168	for (; t->hdr.size; t = tag_next(t))
	169	if (!parse_tag(t))
	170	printk(KERN_WARNING
	171	"Ignoring unrecognised tag 0x%08x\n",
	172	t->hdr.tag);
	173	}
	174
	175	static void __init squash_mem_tags(struct tag *tag)
	176	{
	177	for (; tag->hdr.size; tag = tag_next(tag))
	178	if (tag->hdr.tag == ATAG_MEM)
	179	tag->hdr.tag = ATAG_NONE;
	180	}
	181
ff69a4c8 RK	182	const struct machine_desc * __init
ff69a4c8 RK	183	setup_machine_tags(phys_addr_t __atags_pointer, unsigned int machine_nr)
aa783b6f NP	184	{
aa783b6f NP	185	struct tag tags = (struct tag )&default_tags;
ff69a4c8	186	const struct machine_desc mdesc = NULL, p;
aa783b6f NP	187	char *from = default_command_line;
	188
	189	default_tags.mem.start = PHYS_OFFSET;
	190
	191	/*
	192	* locate machine in the list of supported machines.
	193	*/
	194	for_each_machine_desc(p)
	195	if (machine_nr == p->nr) {
	196	printk("Machine: %s\n", p->name);
	197	mdesc = p;
	198	break;
	199	}
	200
	201	if (!mdesc) {
	202	early_print("\nError: unrecognized/unsupported machine ID"
	203	" (r1 = 0x%08x).\n\n", machine_nr);
	204	dump_machine_table(); /* does not return */
	205	}
	206
	207	if (__atags_pointer)
	208	tags = phys_to_virt(__atags_pointer);
	209	else if (mdesc->atag_offset)
	210	tags = (void *)(PAGE_OFFSET + mdesc->atag_offset);
	211
	212	#if defined(CONFIG_DEPRECATED_PARAM_STRUCT)
	213	/*
	214	* If we have the old style parameters, convert them to
	215	* a tag list.
	216	*/
	217	if (tags->hdr.tag != ATAG_CORE)
	218	convert_to_tag_list(tags);
	219	#endif
	220	if (tags->hdr.tag != ATAG_CORE) {
	221	early_print("Warning: Neither atags nor dtb found\n");
	222	tags = (struct tag *)&default_tags;
	223	}
	224
	225	if (mdesc->fixup)
1c2f87c2	226	mdesc->fixup(tags, &from);
aa783b6f NP	227
aa783b6f NP	228	if (tags->hdr.tag == ATAG_CORE) {
1c2f87c2	229	if (memblock_phys_mem_size())
aa783b6f NP	230	squash_mem_tags(tags);
	231	save_atags(tags);
	232	parse_tags(tags);
	233	}
	234
	235	/* parse_early_param needs a boot_command_line */
	236	strlcpy(boot_command_line, from, COMMAND_LINE_SIZE);
	237
	238	return mdesc;
	239	}