/* * arch/v850/kernel/setup.c -- Arch-dependent initialization functions * * Copyright (C) 2001,02,03,05,06 NEC Electronics Corporation * Copyright (C) 2001,02,03,05,06 Miles Bader * * 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 */ #include #include #include /* we don't have swap, but for nr_free_pages */ #include #include #include #include #include #include #include #include #include #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 /* From drivers/mtd/devices/slram.c */ #define SLRAM_BLK_SZ 0x4000 /* 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) { /* Some sort of idiocy in MTD means we must supply a length that's a multiple of SLRAM_BLK_SZ. We just round up the real length, as the file system shouldn't attempt to access anything beyond the end of the image anyway. */ len = (((len - 1) + SLRAM_BLK_SZ) / SLRAM_BLK_SZ) * SLRAM_BLK_SZ; /* 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 = { .typename = "NMI", .startup = irq_zero, /* startup */ .shutdown = irq_nop, /* shutdown */ .enable = irq_nop, /* enable */ .disable = irq_nop, /* disable */ .ack = irq_nop, /* ack */ .end = 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); init_page_count (page); __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); } /* Taken from m68knommu */ void show_mem(void) { unsigned long i; int free = 0, total = 0, reserved = 0, shared = 0; int cached = 0; printk(KERN_INFO "\nMem-info:\n"); show_free_areas(); i = max_mapnr; while (i-- > 0) { total++; if (PageReserved(mem_map+i)) reserved++; else if (PageSwapCache(mem_map+i)) cached++; else if (!page_count(mem_map+i)) free++; else shared += page_count(mem_map+i) - 1; } printk(KERN_INFO "%d pages of RAM\n",total); printk(KERN_INFO "%d free pages\n",free); printk(KERN_INFO "%d reserved pages\n",reserved); printk(KERN_INFO "%d pages shared\n",shared); printk(KERN_INFO "%d pages swap cached\n",cached); }