Linux-2.6.12-rc2
Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.
Let it rip!
diff --git a/arch/v850/kernel/setup.c b/arch/v850/kernel/setup.c
new file mode 100644
index 0000000..c41d72b
--- /dev/null
+++ b/arch/v850/kernel/setup.c
@@ -0,0 +1,286 @@
+/*
+ * arch/v850/kernel/setup.c -- Arch-dependent initialization functions
+ *
+ * Copyright (C) 2001,02,03 NEC Electronics Corporation
+ * Copyright (C) 2001,02,03 Miles Bader <miles@gnu.org>
+ *
+ * This file is subject to the terms and conditions of the GNU General
+ * Public License. See the file COPYING in the main directory of this
+ * archive for more details.
+ *
+ * Written by Miles Bader <miles@gnu.org>
+ */
+
+#include <linux/mm.h>
+#include <linux/bootmem.h>
+#include <linux/swap.h> /* we don't have swap, but for nr_free_pages */
+#include <linux/irq.h>
+#include <linux/reboot.h>
+#include <linux/personality.h>
+#include <linux/major.h>
+#include <linux/root_dev.h>
+#include <linux/mtd/mtd.h>
+#include <linux/init.h>
+
+#include <asm/irq.h>
+#include <asm/setup.h>
+
+#include "mach.h"
+
+/* These symbols are all defined in the linker map to delineate various
+ statically allocated regions of memory. */
+
+extern char _intv_start, _intv_end;
+/* `kram' is only used if the kernel uses part of normal user RAM. */
+extern char _kram_start __attribute__ ((__weak__));
+extern char _kram_end __attribute__ ((__weak__));
+extern char _init_start, _init_end;
+extern char _bootmap;
+extern char _stext, _etext, _sdata, _edata, _sbss, _ebss;
+/* Many platforms use an embedded root image. */
+extern char _root_fs_image_start __attribute__ ((__weak__));
+extern char _root_fs_image_end __attribute__ ((__weak__));
+
+
+char command_line[COMMAND_LINE_SIZE];
+
+/* Memory not used by the kernel. */
+static unsigned long total_ram_pages;
+
+/* System RAM. */
+static unsigned long ram_start = 0, ram_len = 0;
+
+
+#define ADDR_TO_PAGE_UP(x) ((((unsigned long)x) + PAGE_SIZE-1) >> PAGE_SHIFT)
+#define ADDR_TO_PAGE(x) (((unsigned long)x) >> PAGE_SHIFT)
+#define PAGE_TO_ADDR(x) (((unsigned long)x) << PAGE_SHIFT)
+
+static void init_mem_alloc (unsigned long ram_start, unsigned long ram_len);
+
+void set_mem_root (void *addr, size_t len, char *cmd_line);
+
+
+void __init setup_arch (char **cmdline)
+{
+ /* Keep a copy of command line */
+ *cmdline = command_line;
+ memcpy (saved_command_line, command_line, COMMAND_LINE_SIZE);
+ saved_command_line[COMMAND_LINE_SIZE - 1] = '\0';
+
+ console_verbose ();
+
+ init_mm.start_code = (unsigned long) &_stext;
+ init_mm.end_code = (unsigned long) &_etext;
+ init_mm.end_data = (unsigned long) &_edata;
+ init_mm.brk = (unsigned long) &_kram_end;
+
+ /* Find out what mem this machine has. */
+ mach_get_physical_ram (&ram_start, &ram_len);
+ /* ... and tell the kernel about it. */
+ init_mem_alloc (ram_start, ram_len);
+
+ printk (KERN_INFO "CPU: %s\nPlatform: %s\n",
+ CPU_MODEL_LONG, PLATFORM_LONG);
+
+ /* do machine-specific setups. */
+ mach_setup (cmdline);
+
+#ifdef CONFIG_MTD
+ if (!ROOT_DEV && &_root_fs_image_end > &_root_fs_image_start)
+ set_mem_root (&_root_fs_image_start,
+ &_root_fs_image_end - &_root_fs_image_start,
+ *cmdline);
+#endif
+}
+
+void __init trap_init (void)
+{
+}
+
+#ifdef CONFIG_MTD
+/* Set the root filesystem to be the given memory region.
+ Some parameter may be appended to CMD_LINE. */
+void set_mem_root (void *addr, size_t len, char *cmd_line)
+{
+ /* The only way to pass info to the MTD slram driver is via
+ the command line. */
+ if (*cmd_line) {
+ cmd_line += strlen (cmd_line);
+ *cmd_line++ = ' ';
+ }
+ sprintf (cmd_line, "slram=root,0x%x,+0x%x", (u32)addr, (u32)len);
+
+ ROOT_DEV = MKDEV (MTD_BLOCK_MAJOR, 0);
+}
+#endif
+
+
+static void irq_nop (unsigned irq) { }
+static unsigned irq_zero (unsigned irq) { return 0; }
+
+static void nmi_end (unsigned irq)
+{
+ if (irq != IRQ_NMI (0)) {
+ printk (KERN_CRIT "NMI %d is unrecoverable; restarting...",
+ irq - IRQ_NMI (0));
+ machine_restart (0);
+ }
+}
+
+static struct hw_interrupt_type nmi_irq_type = {
+ "NMI",
+ irq_zero, /* startup */
+ irq_nop, /* shutdown */
+ irq_nop, /* enable */
+ irq_nop, /* disable */
+ irq_nop, /* ack */
+ nmi_end, /* end */
+};
+
+void __init init_IRQ (void)
+{
+ init_irq_handlers (0, NUM_MACH_IRQS, 1, 0);
+ init_irq_handlers (IRQ_NMI (0), NUM_NMIS, 1, &nmi_irq_type);
+ mach_init_irqs ();
+}
+
+
+void __init mem_init (void)
+{
+ max_mapnr = MAP_NR (ram_start + ram_len);
+
+ num_physpages = ADDR_TO_PAGE (ram_len);
+
+ total_ram_pages = free_all_bootmem ();
+
+ printk (KERN_INFO
+ "Memory: %luK/%luK available"
+ " (%luK kernel code, %luK data)\n",
+ PAGE_TO_ADDR (nr_free_pages()) / 1024,
+ ram_len / 1024,
+ ((unsigned long)&_etext - (unsigned long)&_stext) / 1024,
+ ((unsigned long)&_ebss - (unsigned long)&_sdata) / 1024);
+}
+
+void free_initmem (void)
+{
+ unsigned long ram_end = ram_start + ram_len;
+ unsigned long start = PAGE_ALIGN ((unsigned long)(&_init_start));
+
+ if (start >= ram_start && start < ram_end) {
+ unsigned long addr;
+ unsigned long end = PAGE_ALIGN ((unsigned long)(&_init_end));
+
+ if (end > ram_end)
+ end = ram_end;
+
+ printk("Freeing unused kernel memory: %ldK freed\n",
+ (end - start) / 1024);
+
+ for (addr = start; addr < end; addr += PAGE_SIZE) {
+ struct page *page = virt_to_page (addr);
+ ClearPageReserved (page);
+ set_page_count (page, 1);
+ __free_page (page);
+ total_ram_pages++;
+ }
+ }
+}
+
+
+/* Initialize the `bootmem allocator'. RAM_START and RAM_LEN identify
+ what RAM may be used. */
+static void __init
+init_bootmem_alloc (unsigned long ram_start, unsigned long ram_len)
+{
+ /* The part of the kernel that's in the same managed RAM space
+ used for general allocation. */
+ unsigned long kram_start = (unsigned long)&_kram_start;
+ unsigned long kram_end = (unsigned long)&_kram_end;
+ /* End of the managed RAM space. */
+ unsigned long ram_end = ram_start + ram_len;
+ /* Address range of the interrupt vector table. */
+ unsigned long intv_start = (unsigned long)&_intv_start;
+ unsigned long intv_end = (unsigned long)&_intv_end;
+ /* True if the interrupt vectors are in the managed RAM area. */
+ int intv_in_ram = (intv_end > ram_start && intv_start < ram_end);
+ /* True if the interrupt vectors are inside the kernel's RAM. */
+ int intv_in_kram = (intv_end > kram_start && intv_start < kram_end);
+ /* A pointer to an optional function that reserves platform-specific
+ memory regions. We declare the pointer `volatile' to avoid gcc
+ turning the call into a static call (the problem is that since
+ it's a weak symbol, a static call may end up trying to reference
+ the location 0x0, which is not always reachable). */
+ void (*volatile mrb) (void) = mach_reserve_bootmem;
+ /* The bootmem allocator's allocation bitmap. */
+ unsigned long bootmap = (unsigned long)&_bootmap;
+ unsigned long bootmap_len;
+
+ /* Round bootmap location up to next page. */
+ bootmap = PAGE_TO_ADDR (ADDR_TO_PAGE_UP (bootmap));
+
+ /* Initialize bootmem allocator. */
+ bootmap_len = init_bootmem_node (NODE_DATA (0),
+ ADDR_TO_PAGE (bootmap),
+ ADDR_TO_PAGE (PAGE_OFFSET),
+ ADDR_TO_PAGE (ram_end));
+
+ /* Now make the RAM actually allocatable (it starts out `reserved'). */
+ free_bootmem (ram_start, ram_len);
+
+ if (kram_end > kram_start)
+ /* Reserve the RAM part of the kernel's address space, so it
+ doesn't get allocated. */
+ reserve_bootmem (kram_start, kram_end - kram_start);
+
+ if (intv_in_ram && !intv_in_kram)
+ /* Reserve the interrupt vector space. */
+ reserve_bootmem (intv_start, intv_end - intv_start);
+
+ if (bootmap >= ram_start && bootmap < ram_end)
+ /* Reserve the bootmap space. */
+ reserve_bootmem (bootmap, bootmap_len);
+
+ /* Reserve the memory used by the root filesystem image if it's
+ in RAM. */
+ if (&_root_fs_image_end > &_root_fs_image_start
+ && (unsigned long)&_root_fs_image_start >= ram_start
+ && (unsigned long)&_root_fs_image_start < ram_end)
+ reserve_bootmem ((unsigned long)&_root_fs_image_start,
+ &_root_fs_image_end - &_root_fs_image_start);
+
+ /* Let the platform-dependent code reserve some too. */
+ if (mrb)
+ (*mrb) ();
+}
+
+/* Tell the kernel about what RAM it may use for memory allocation. */
+static void __init
+init_mem_alloc (unsigned long ram_start, unsigned long ram_len)
+{
+ unsigned i;
+ unsigned long zones_size[MAX_NR_ZONES];
+
+ init_bootmem_alloc (ram_start, ram_len);
+
+ for (i = 0; i < MAX_NR_ZONES; i++)
+ zones_size[i] = 0;
+
+ /* We stuff all the memory into one area, which includes the
+ initial gap from PAGE_OFFSET to ram_start. */
+ zones_size[ZONE_DMA]
+ = ADDR_TO_PAGE (ram_len + (ram_start - PAGE_OFFSET));
+
+ /* The allocator is very picky about the address of the first
+ allocatable page -- it must be at least as aligned as the
+ maximum allocation -- so try to detect cases where it will get
+ confused and signal them at compile time (this is a common
+ problem when porting to a new platform with ). There is a
+ similar runtime check in free_area_init_core. */
+#if ((PAGE_OFFSET >> PAGE_SHIFT) & ((1UL << (MAX_ORDER - 1)) - 1))
+#error MAX_ORDER is too large for given PAGE_OFFSET (use CONFIG_FORCE_MAX_ZONEORDER to change it)
+#endif
+ NODE_DATA(0)->node_mem_map = NULL;
+ free_area_init_node (0, NODE_DATA(0), zones_size,
+ ADDR_TO_PAGE (PAGE_OFFSET), 0);
+}