[PATCH 3/3] arm: export arm_add_memory

[PATCH 3/3] arm: export arm_add_memory

[Jeremy Kerr]

We'd like to add memory from the device tree, so make arm_add_memory
non-static and add a prototype in setup.h

Signed-off-by: Jeremy Kerr <jeremy.kerr@canonical.com>

---
 arch/arm/include/asm/setup.h |    2 ++
 arch/arm/kernel/setup.c      |    2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/arch/arm/include/asm/setup.h b/arch/arm/include/asm/setup.h
index 3b6f461..3fa2555 100644
--- a/arch/arm/include/asm/setup.h
+++ b/arch/arm/include/asm/setup.h
@@ -225,6 +225,8 @@ extern struct meminfo meminfo;
 
 extern char cmd_line[COMMAND_LINE_SIZE];
 
+extern int arm_add_memory(unsigned long start, unsigned long size);
+
 #endif  /*  __KERNEL__  */
 
 #endif
diff --git a/arch/arm/kernel/setup.c b/arch/arm/kernel/setup.c
index 4206286..84fd876 100644
--- a/arch/arm/kernel/setup.c
+++ b/arch/arm/kernel/setup.c
@@ -383,7 +383,7 @@ static struct machine_desc * __init setup_machine(unsigned int nr)
 	return list;
 }
 
-static int __init arm_add_memory(unsigned long start, unsigned long size)
+int __init arm_add_memory(unsigned long start, unsigned long size)
 {
 	struct membank *bank = &meminfo.bank[meminfo.nr_banks];
 

[PATCH 1/3] arm: use generic infrastructure for early params

[Jeremy Kerr]

The ARM setup code includes its own parser for early params, there's
also one in the generic init code.

This patch removes __early_init (and related code) from
arch/arm/kernel/setup.c, and changes users to the generic early_init
macro instead.

The generic macro takes a char * argument, rather than char **, so we
need to update the parser functions a little.

Signed-off-by: Jeremy Kerr <jeremy.kerr@canonical.com>

---
 arch/arm/include/asm/setup.h      |   12 -----
 arch/arm/kernel/setup.c           |   62 +++++++-----------------------
 arch/arm/kernel/vmlinux.lds.S     |    4 -
 arch/arm/mach-footbridge/common.c |    7 +--
 arch/arm/mm/init.c                |   12 +++--
 arch/arm/mm/mmu.c                 |   41 ++++++++++---------
 6 files changed, 48 insertions(+), 90 deletions(-)

diff --git a/arch/arm/include/asm/setup.h b/arch/arm/include/asm/setup.h
index 5ccce0a..f392fb4 100644
--- a/arch/arm/include/asm/setup.h
+++ b/arch/arm/include/asm/setup.h
@@ -223,18 +223,6 @@ extern struct meminfo meminfo;
 #define bank_phys_end(bank)	((bank)->start + (bank)->size)
 #define bank_phys_size(bank)	(bank)->size
 
-/*
- * Early command line parameters.
- */
-struct early_params {
-	const char *arg;
-	void (*fn)(char **p);
-};
-
-#define __early_param(name,fn)					\
-static struct early_params __early_##fn __used			\
-__attribute__((__section__(".early_param.init"))) = { name, fn }
-
 #endif  /*  __KERNEL__  */
 
 #endif
diff --git a/arch/arm/kernel/setup.c b/arch/arm/kernel/setup.c
index c6c57b6..4aa67cd 100644
--- a/arch/arm/kernel/setup.c
+++ b/arch/arm/kernel/setup.c
@@ -417,10 +417,11 @@ static int __init arm_add_memory(unsigned long start, unsigned long size)
  * Pick out the memory size.  We look for mem=size at start,
  * where start and size are "size[KkMm]"
  */
-static void __init early_mem(char **p)
+static int __init early_mem(char *p)
 {
 	static int usermem __initdata = 0;
 	unsigned long size, start;
+	char *endp;
 
 	/*
 	 * If the user specifies memory size, we
@@ -433,52 +434,15 @@ static void __init early_mem(char **p)
 	}
 
 	start = PHYS_OFFSET;
-	size  = memparse(*p, p);
-	if (**p == '@')
-		start = memparse(*p + 1, p);
+	size  = memparse(p, &endp);
+	if (*endp == '@')
+		start = memparse(endp + 1, NULL);
 
 	arm_add_memory(start, size);
-}
-__early_param("mem=", early_mem);
 
-/*
- * Initial parsing of the command line.
- */
-static void __init parse_cmdline(char **cmdline_p, char *from)
-{
-	char c = ' ', *to = command_line;
-	int len = 0;
-
-	for (;;) {
-		if (c == ' ') {
-			extern struct early_params __early_begin, __early_end;
-			struct early_params *p;
-
-			for (p = &__early_begin; p < &__early_end; p++) {
-				int arglen = strlen(p->arg);
-
-				if (memcmp(from, p->arg, arglen) == 0) {
-					if (to != command_line)
-						to -= 1;
-					from += arglen;
-					p->fn(&from);
-
-					while (*from != ' ' && *from != '\0')
-						from++;
-					break;
-				}
-			}
-		}
-		c = *from++;
-		if (!c)
-			break;
-		if (COMMAND_LINE_SIZE <= ++len)
-			break;
-		*to++ = c;
-	}
-	*to = '\0';
-	*cmdline_p = command_line;
+	return 0;
 }
+early_param("mem", early_mem);
 
 static void __init
 setup_ramdisk(int doload, int prompt, int image_start, unsigned int rd_sz)
@@ -739,9 +703,15 @@ void __init setup_arch(char **cmdline_p)
 	init_mm.end_data   = (unsigned long) _edata;
 	init_mm.brk	   = (unsigned long) _end;
 
-	memcpy(boot_command_line, from, COMMAND_LINE_SIZE);
-	boot_command_line[COMMAND_LINE_SIZE-1] = '\0';
-	parse_cmdline(cmdline_p, from);
+	/* parse_early_param needs a boot_command_line */
+	strlcpy(boot_command_line, from, COMMAND_LINE_SIZE);
+
+	/* populate command_line too for later use, preserving boot_command_line */
+	strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
+	*cmdline_p = command_line;
+
+	parse_early_param();
+
 	paging_init(mdesc);
 	request_standard_resources(&meminfo, mdesc);
 
diff --git a/arch/arm/kernel/vmlinux.lds.S b/arch/arm/kernel/vmlinux.lds.S
index 4957e13..b16c079 100644
--- a/arch/arm/kernel/vmlinux.lds.S
+++ b/arch/arm/kernel/vmlinux.lds.S
@@ -43,10 +43,6 @@ SECTIONS
 
 		INIT_SETUP(16)
 
-		__early_begin = .;
-			*(.early_param.init)
-		__early_end = .;
-
 		INIT_CALLS
 		CON_INITCALL
 		SECURITY_INITCALL
diff --git a/arch/arm/mach-footbridge/common.c b/arch/arm/mach-footbridge/common.c
index 41febc7..e3bc3f6 100644
--- a/arch/arm/mach-footbridge/common.c
+++ b/arch/arm/mach-footbridge/common.c
@@ -32,12 +32,13 @@ unsigned int mem_fclk_21285 = 50000000;
 
 EXPORT_SYMBOL(mem_fclk_21285);
 
-static void __init early_fclk(char **arg)
+static int __init early_fclk(char *arg)
 {
-	mem_fclk_21285 = simple_strtoul(*arg, arg, 0);
+	mem_fclk_21285 = simple_strtoul(arg, NULL, 0);
+	return 0;
 }
 
-__early_param("mem_fclk_21285=", early_fclk);
+early_param("mem_fclk_21285", early_fclk);
 
 static int __init parse_tag_memclk(const struct tag *tag)
 {
diff --git a/arch/arm/mm/init.c b/arch/arm/mm/init.c
index 52c40d1..4d3c90f 100644
--- a/arch/arm/mm/init.c
+++ b/arch/arm/mm/init.c
@@ -32,19 +32,21 @@
 static unsigned long phys_initrd_start __initdata = 0;
 static unsigned long phys_initrd_size __initdata = 0;
 
-static void __init early_initrd(char **p)
+static int __init early_initrd(char *p)
 {
 	unsigned long start, size;
+	char *endp;
 
-	start = memparse(*p, p);
-	if (**p == ',') {
-		size = memparse((*p) + 1, p);
+	start = memparse(p, &endp);
+	if (*endp == ',') {
+		size = memparse(endp + 1, NULL);
 
 		phys_initrd_start = start;
 		phys_initrd_size = size;
 	}
+	return 0;
 }
-__early_param("initrd=", early_initrd);
+early_param("initrd", early_initrd);
 
 static int __init parse_tag_initrd(const struct tag *tag)
 {
diff --git a/arch/arm/mm/mmu.c b/arch/arm/mm/mmu.c
index 1708da8..88f5d71 100644
--- a/arch/arm/mm/mmu.c
+++ b/arch/arm/mm/mmu.c
@@ -100,18 +100,17 @@ static struct cachepolicy cache_policies[] __initdata = {
  * writebuffer to be turned off.  (Note: the write
  * buffer should not be on and the cache off).
  */
-static void __init early_cachepolicy(char **p)
+static int __init early_cachepolicy(char *p)
 {
 	int i;
 
 	for (i = 0; i < ARRAY_SIZE(cache_policies); i++) {
 		int len = strlen(cache_policies[i].policy);
 
-		if (memcmp(*p, cache_policies[i].policy, len) == 0) {
+		if (memcmp(p, cache_policies[i].policy, len) == 0) {
 			cachepolicy = i;
 			cr_alignment &= ~cache_policies[i].cr_mask;
 			cr_no_alignment &= ~cache_policies[i].cr_mask;
-			*p += len;
 			break;
 		}
 	}
@@ -130,36 +129,37 @@ static void __init early_cachepolicy(char **p)
 	}
 	flush_cache_all();
 	set_cr(cr_alignment);
+	return 0;
 }
-__early_param("cachepolicy=", early_cachepolicy);
+early_param("cachepolicy", early_cachepolicy);
 
-static void __init early_nocache(char **__unused)
+static int __init early_nocache(char *__unused)
 {
 	char *p = "buffered";
 	printk(KERN_WARNING "nocache is deprecated; use cachepolicy=%s\n", p);
-	early_cachepolicy(&p);
+	early_cachepolicy(p);
+	return 0;
 }
-__early_param("nocache", early_nocache);
+early_param("nocache", early_nocache);
 
-static void __init early_nowrite(char **__unused)
+static int __init early_nowrite(char *__unused)
 {
 	char *p = "uncached";
 	printk(KERN_WARNING "nowb is deprecated; use cachepolicy=%s\n", p);
-	early_cachepolicy(&p);
+	early_cachepolicy(p);
+	return 0;
 }
-__early_param("nowb", early_nowrite);
+early_param("nowb", early_nowrite);
 
-static void __init early_ecc(char **p)
+static int __init early_ecc(char *p)
 {
-	if (memcmp(*p, "on", 2) == 0) {
+	if (memcmp(p, "on", 2) == 0)
 		ecc_mask = PMD_PROTECTION;
-		*p += 2;
-	} else if (memcmp(*p, "off", 3) == 0) {
+	else if (memcmp(p, "off", 3) == 0)
 		ecc_mask = 0;
-		*p += 3;
-	}
+	return 0;
 }
-__early_param("ecc=", early_ecc);
+early_param("ecc", early_ecc);
 
 static int __init noalign_setup(char *__unused)
 {
@@ -670,9 +670,9 @@ static unsigned long __initdata vmalloc_reserve = SZ_128M;
  * bytes. This can be used to increase (or decrease) the vmalloc
  * area - the default is 128m.
  */
-static void __init early_vmalloc(char **arg)
+static int __init early_vmalloc(char *arg)
 {
-	vmalloc_reserve = memparse(*arg, arg);
+	vmalloc_reserve = memparse(arg, NULL);
 
 	if (vmalloc_reserve < SZ_16M) {
 		vmalloc_reserve = SZ_16M;
@@ -687,8 +687,9 @@ static void __init early_vmalloc(char **arg)
 			"vmalloc area is too big, limiting to %luMB\n",
 			vmalloc_reserve >> 20);
 	}
+	return 0;
 }
-__early_param("vmalloc=", early_vmalloc);
+early_param("vmalloc", early_vmalloc);
 
 #define VMALLOC_MIN	(void *)(VMALLOC_END - vmalloc_reserve)
 

[PATCH 0/3] Base patches for ARM devicetree groundwork

[Jeremy Kerr]

Hi all,

As requested, these are the non-DT-specific patches from my DT series,
rebased onto the current branch. The first patch may be useful on its
own, the other two are only really needed for the DT work.

Cheers,


Jeremy

---
Jeremy Kerr (3):
      arm: use generic infrastructure for early params
      arm: change command_line to cmd_line, and export it
      arm: export arm_add_memory

[PATCH 2/3] arm: change command_line to cmd_line, and export it

[Jeremy Kerr]

drivers/of/fdt expects a cmd_line symbol, while arm uses command_line.
Change to the former and make accessible from setup.h, so that we can
share with the fdt code.

This means a change in section from .init.data to .data

Signed-off-by: Jeremy Kerr <jeremy.kerr@canonical.com>

---
 arch/arm/include/asm/setup.h |    6 ++++--
 arch/arm/kernel/setup.c      |    8 ++++----
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/arch/arm/include/asm/setup.h b/arch/arm/include/asm/setup.h
index f392fb4..3b6f461 100644
--- a/arch/arm/include/asm/setup.h
+++ b/arch/arm/include/asm/setup.h
@@ -16,8 +16,6 @@
 
 #include <linux/types.h>
 
-#define COMMAND_LINE_SIZE 1024
-
 /* The list ends with an ATAG_NONE node. */
 #define ATAG_NONE	0x00000000
 
@@ -223,6 +221,10 @@ extern struct meminfo meminfo;
 #define bank_phys_end(bank)	((bank)->start + (bank)->size)
 #define bank_phys_size(bank)	(bank)->size
 
+#define COMMAND_LINE_SIZE 1024
+
+extern char cmd_line[COMMAND_LINE_SIZE];
+
 #endif  /*  __KERNEL__  */
 
 #endif
diff --git a/arch/arm/kernel/setup.c b/arch/arm/kernel/setup.c
index 4aa67cd..4206286 100644
--- a/arch/arm/kernel/setup.c
+++ b/arch/arm/kernel/setup.c
@@ -117,7 +117,7 @@ EXPORT_SYMBOL(elf_platform);
 
 static const char *cpu_name;
 static const char *machine_name;
-static char __initdata command_line[COMMAND_LINE_SIZE];
+char cmd_line[COMMAND_LINE_SIZE];
 
 static char default_command_line[COMMAND_LINE_SIZE] __initdata = CONFIG_CMDLINE;
 static union { char c[4]; unsigned long l; } endian_test __initdata = { { 'l', '?', '?', 'b' } };
@@ -706,9 +706,9 @@ void __init setup_arch(char **cmdline_p)
 	/* parse_early_param needs a boot_command_line */
 	strlcpy(boot_command_line, from, COMMAND_LINE_SIZE);
 
-	/* populate command_line too for later use, preserving boot_command_line */
-	strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
-	*cmdline_p = command_line;
+	/* populate cmd_line too for later use, preserving boot_command_line */
+	strlcpy(cmd_line, boot_command_line, COMMAND_LINE_SIZE);
+	*cmdline_p = cmd_line;
 
 	parse_early_param();
 

[PATCH 1/3] arm: use generic infrastructure for early params

[Russell King - ARM Linux]

On Thu, Jan 07, 2010 at 02:39:21PM +1100, Jeremy Kerr wrote:
> The ARM setup code includes its own parser for early params, there's
> also one in the generic init code.
> 
> This patch removes __early_init (and related code) from
> arch/arm/kernel/setup.c, and changes users to the generic early_init
> macro instead.
> 
> The generic macro takes a char * argument, rather than char **, so we
> need to update the parser functions a little.
> 
> Signed-off-by: Jeremy Kerr <jeremy.kerr@canonical.com>

Any chance of having this in the patch system please?

Thanks.

[PATCH 2/3] arm: change command_line to cmd_line, and export it

[Russell King - ARM Linux]

On Thu, Jan 07, 2010 at 02:39:21PM +1100, Jeremy Kerr wrote:
> drivers/of/fdt expects a cmd_line symbol, while arm uses command_line.
> Change to the former and make accessible from setup.h, so that we can
> share with the fdt code.

Until the dt code gets merged, I'd prefer to keep the 'command_line'
or 'cmd_line' static.  Also, please leave 'COMMAND_LINE_SIZE' visible
to stuff outside kernel-space (it could be used by boot loaders, which
borrow this file.)

In other words, can I have a patch in the patch system which just does
the renaming?

[PATCH 3/3] arm: export arm_add_memory

[Russell King - ARM Linux]

On Thu, Jan 07, 2010 at 02:39:21PM +1100, Jeremy Kerr wrote:
> We'd like to add memory from the device tree, so make arm_add_memory
> non-static and add a prototype in setup.h
> 
> Signed-off-by: Jeremy Kerr <jeremy.kerr@canonical.com>

I've been thinking about this a bit, and rather than indirecting the
DT stuff through an inline function, I think we should rename the
function instead to something that's compatible with DT.  Yes, that
means changing the arguments, but in the longer term, we're likely
to need to pass more than 32-bits of memory start/size to the kernel.

[PATCH 3/3] arm: export arm_add_memory

[Jeremy Kerr]

Russell,
 
> I've been thinking about this a bit, and rather than indirecting the
> DT stuff through an inline function, I think we should rename the
> function instead to something that's compatible with DT.  Yes, that
> means changing the arguments, but in the longer term, we're likely
> to need to pass more than 32-bits of memory start/size to the kernel.

Any thoughts on using the generic LMB infrastructure to manage this instead?

The DT code is written for arches that have LMB support, so the main reason 
for this patch is to provide a hook into non-LMB arches.

Cheers,


Jeremy 

[PATCH 3/3] arm: export arm_add_memory

[Russell King - ARM Linux]

On Mon, Jan 11, 2010 at 08:32:44AM +1100, Jeremy Kerr wrote:
> Russell,
>  
> > I've been thinking about this a bit, and rather than indirecting the
> > DT stuff through an inline function, I think we should rename the
> > function instead to something that's compatible with DT.  Yes, that
> > means changing the arguments, but in the longer term, we're likely
> > to need to pass more than 32-bits of memory start/size to the kernel.
> 
> Any thoughts on using the generic LMB infrastructure to manage this instead?
> 
> The DT code is written for arches that have LMB support, so the main reason 
> for this patch is to provide a hook into non-LMB arches.

Maybe when we go to 64-bit memory; until that time it looks like it
doesn't meet our needs and would be additional bloat.

It certainly would need some modification - the auto-coalescing which
it currently does would be a problem - we explicitly split our memory
information if it overlaps a lowmem/highmem boundary, and where it
splits sparsemem/discontig zones.  We also sort our memory information
into ascending address, which LMB also doesn't do.

We certainly don't need the lmb allocation stuff, and I don't understand
why LMB is trying to implement this functionality.  Bootmem was supposed
to get around the problem of early kernel allocations (before the main
page allocator and therefore kmalloc) were up and running - and it does
this fairly well.  The only down-side to it is you need to find some way
of placing its bitmap for registering the allocated/free areas.  That's
fairly easy to do (and we've done it on ARM with no problems.)

So why do we need an early-early allocator?  (Should we expect to see in
a few years an early-early-early allocator and an early-early-early-early
allocator as well? :P)