386 lines
9.7 KiB
C
386 lines
9.7 KiB
C
/*
|
|
* 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.
|
|
*
|
|
* arch/sh64/kernel/setup.c
|
|
*
|
|
* sh64 Arch Support
|
|
*
|
|
* This file handles the architecture-dependent parts of initialization
|
|
*
|
|
* Copyright (C) 2000, 2001 Paolo Alberelli
|
|
* Copyright (C) 2003, 2004 Paul Mundt
|
|
*
|
|
* benedict.gaster@superh.com: 2nd May 2002
|
|
* Modified to use the empty_zero_page to pass command line arguments.
|
|
*
|
|
* benedict.gaster@superh.com: 3rd May 2002
|
|
* Added support for ramdisk, removing statically linked romfs at the same time.
|
|
*
|
|
* lethal@linux-sh.org: 15th May 2003
|
|
* Added generic procfs cpuinfo reporting. Make boards just export their name.
|
|
*
|
|
* lethal@linux-sh.org: 25th May 2003
|
|
* Added generic get_cpu_subtype() for subtype reporting from cpu_data->type.
|
|
*
|
|
*/
|
|
#include <linux/errno.h>
|
|
#include <linux/rwsem.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/stddef.h>
|
|
#include <linux/unistd.h>
|
|
#include <linux/ptrace.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/user.h>
|
|
#include <linux/a.out.h>
|
|
#include <linux/screen_info.h>
|
|
#include <linux/ioport.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/init.h>
|
|
#include <linux/seq_file.h>
|
|
#include <linux/blkdev.h>
|
|
#include <linux/bootmem.h>
|
|
#include <linux/console.h>
|
|
#include <linux/root_dev.h>
|
|
#include <linux/cpu.h>
|
|
#include <linux/initrd.h>
|
|
#include <linux/pfn.h>
|
|
#include <asm/processor.h>
|
|
#include <asm/page.h>
|
|
#include <asm/pgtable.h>
|
|
#include <asm/platform.h>
|
|
#include <asm/uaccess.h>
|
|
#include <asm/system.h>
|
|
#include <asm/io.h>
|
|
#include <asm/sections.h>
|
|
#include <asm/setup.h>
|
|
#include <asm/smp.h>
|
|
|
|
#ifdef CONFIG_VT
|
|
#include <linux/console.h>
|
|
#endif
|
|
|
|
struct screen_info screen_info;
|
|
|
|
#ifdef CONFIG_BLK_DEV_RAM
|
|
extern int rd_doload; /* 1 = load ramdisk, 0 = don't load */
|
|
extern int rd_prompt; /* 1 = prompt for ramdisk, 0 = don't prompt */
|
|
extern int rd_image_start; /* starting block # of image */
|
|
#endif
|
|
|
|
extern int root_mountflags;
|
|
extern char *get_system_type(void);
|
|
extern void platform_setup(void);
|
|
extern void platform_monitor(void);
|
|
extern void platform_reserve(void);
|
|
extern int sh64_cache_init(void);
|
|
extern int sh64_tlb_init(void);
|
|
|
|
#define RAMDISK_IMAGE_START_MASK 0x07FF
|
|
#define RAMDISK_PROMPT_FLAG 0x8000
|
|
#define RAMDISK_LOAD_FLAG 0x4000
|
|
|
|
static char command_line[COMMAND_LINE_SIZE] = { 0, };
|
|
unsigned long long memory_start = CONFIG_MEMORY_START;
|
|
unsigned long long memory_end = CONFIG_MEMORY_START + (CONFIG_MEMORY_SIZE_IN_MB * 1024 * 1024);
|
|
|
|
struct sh_cpuinfo boot_cpu_data;
|
|
|
|
static inline void parse_mem_cmdline (char ** cmdline_p)
|
|
{
|
|
char c = ' ', *to = command_line, *from = COMMAND_LINE;
|
|
int len = 0;
|
|
|
|
/* Save unparsed command line copy for /proc/cmdline */
|
|
memcpy(saved_command_line, COMMAND_LINE, COMMAND_LINE_SIZE);
|
|
saved_command_line[COMMAND_LINE_SIZE-1] = '\0';
|
|
|
|
for (;;) {
|
|
/*
|
|
* "mem=XXX[kKmM]" defines a size of memory.
|
|
*/
|
|
if (c == ' ' && !memcmp(from, "mem=", 4)) {
|
|
if (to != command_line)
|
|
to--;
|
|
{
|
|
unsigned long mem_size;
|
|
|
|
mem_size = memparse(from+4, &from);
|
|
memory_end = memory_start + mem_size;
|
|
}
|
|
}
|
|
c = *(from++);
|
|
if (!c)
|
|
break;
|
|
if (COMMAND_LINE_SIZE <= ++len)
|
|
break;
|
|
*(to++) = c;
|
|
}
|
|
*to = '\0';
|
|
|
|
*cmdline_p = command_line;
|
|
}
|
|
|
|
static void __init sh64_cpu_type_detect(void)
|
|
{
|
|
extern unsigned long long peek_real_address_q(unsigned long long addr);
|
|
unsigned long long cir;
|
|
/* Do peeks in real mode to avoid having to set up a mapping for the
|
|
WPC registers. On SH5-101 cut2, such a mapping would be exposed to
|
|
an address translation erratum which would make it hard to set up
|
|
correctly. */
|
|
cir = peek_real_address_q(0x0d000008);
|
|
|
|
if ((cir & 0xffff) == 0x5103) {
|
|
boot_cpu_data.type = CPU_SH5_103;
|
|
} else if (((cir >> 32) & 0xffff) == 0x51e2) {
|
|
/* CPU.VCR aliased at CIR address on SH5-101 */
|
|
boot_cpu_data.type = CPU_SH5_101;
|
|
} else {
|
|
boot_cpu_data.type = CPU_SH_NONE;
|
|
}
|
|
}
|
|
|
|
void __init setup_arch(char **cmdline_p)
|
|
{
|
|
unsigned long bootmap_size, i;
|
|
unsigned long first_pfn, start_pfn, last_pfn, pages;
|
|
|
|
#ifdef CONFIG_EARLY_PRINTK
|
|
extern void enable_early_printk(void);
|
|
|
|
/*
|
|
* Setup Early SCIF console
|
|
*/
|
|
enable_early_printk();
|
|
#endif
|
|
|
|
/*
|
|
* Setup TLB mappings
|
|
*/
|
|
sh64_tlb_init();
|
|
|
|
/*
|
|
* Caches are already initialized by the time we get here, so we just
|
|
* fill in cpu_data info for the caches.
|
|
*/
|
|
sh64_cache_init();
|
|
|
|
platform_setup();
|
|
platform_monitor();
|
|
|
|
sh64_cpu_type_detect();
|
|
|
|
ROOT_DEV = old_decode_dev(ORIG_ROOT_DEV);
|
|
|
|
#ifdef CONFIG_BLK_DEV_RAM
|
|
rd_image_start = RAMDISK_FLAGS & RAMDISK_IMAGE_START_MASK;
|
|
rd_prompt = ((RAMDISK_FLAGS & RAMDISK_PROMPT_FLAG) != 0);
|
|
rd_doload = ((RAMDISK_FLAGS & RAMDISK_LOAD_FLAG) != 0);
|
|
#endif
|
|
|
|
if (!MOUNT_ROOT_RDONLY)
|
|
root_mountflags &= ~MS_RDONLY;
|
|
init_mm.start_code = (unsigned long) _text;
|
|
init_mm.end_code = (unsigned long) _etext;
|
|
init_mm.end_data = (unsigned long) _edata;
|
|
init_mm.brk = (unsigned long) _end;
|
|
|
|
code_resource.start = __pa(_text);
|
|
code_resource.end = __pa(_etext)-1;
|
|
data_resource.start = __pa(_etext);
|
|
data_resource.end = __pa(_edata)-1;
|
|
|
|
parse_mem_cmdline(cmdline_p);
|
|
|
|
/*
|
|
* Find the lowest and highest page frame numbers we have available
|
|
*/
|
|
first_pfn = PFN_DOWN(memory_start);
|
|
last_pfn = PFN_DOWN(memory_end);
|
|
pages = last_pfn - first_pfn;
|
|
|
|
/*
|
|
* Partially used pages are not usable - thus
|
|
* we are rounding upwards:
|
|
*/
|
|
start_pfn = PFN_UP(__pa(_end));
|
|
|
|
/*
|
|
* Find a proper area for the bootmem bitmap. After this
|
|
* bootstrap step all allocations (until the page allocator
|
|
* is intact) must be done via bootmem_alloc().
|
|
*/
|
|
bootmap_size = init_bootmem_node(NODE_DATA(0), start_pfn,
|
|
first_pfn,
|
|
last_pfn);
|
|
/*
|
|
* Round it up.
|
|
*/
|
|
bootmap_size = PFN_PHYS(PFN_UP(bootmap_size));
|
|
|
|
/*
|
|
* Register fully available RAM pages with the bootmem allocator.
|
|
*/
|
|
free_bootmem_node(NODE_DATA(0), PFN_PHYS(first_pfn), PFN_PHYS(pages));
|
|
|
|
/*
|
|
* Reserve all kernel sections + bootmem bitmap + a guard page.
|
|
*/
|
|
reserve_bootmem_node(NODE_DATA(0), PFN_PHYS(first_pfn),
|
|
(PFN_PHYS(start_pfn) + bootmap_size + PAGE_SIZE) - PFN_PHYS(first_pfn));
|
|
|
|
/*
|
|
* Reserve platform dependent sections
|
|
*/
|
|
platform_reserve();
|
|
|
|
#ifdef CONFIG_BLK_DEV_INITRD
|
|
if (LOADER_TYPE && INITRD_START) {
|
|
if (INITRD_START + INITRD_SIZE <= (PFN_PHYS(last_pfn))) {
|
|
reserve_bootmem_node(NODE_DATA(0), INITRD_START + __MEMORY_START, INITRD_SIZE);
|
|
|
|
initrd_start =
|
|
(long) INITRD_START ? INITRD_START + PAGE_OFFSET + __MEMORY_START : 0;
|
|
|
|
initrd_end = initrd_start + INITRD_SIZE;
|
|
} else {
|
|
printk("initrd extends beyond end of memory "
|
|
"(0x%08lx > 0x%08lx)\ndisabling initrd\n",
|
|
(long) INITRD_START + INITRD_SIZE,
|
|
PFN_PHYS(last_pfn));
|
|
initrd_start = 0;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Claim all RAM, ROM, and I/O resources.
|
|
*/
|
|
|
|
/* Kernel RAM */
|
|
request_resource(&iomem_resource, &code_resource);
|
|
request_resource(&iomem_resource, &data_resource);
|
|
|
|
/* Other KRAM space */
|
|
for (i = 0; i < STANDARD_KRAM_RESOURCES - 2; i++)
|
|
request_resource(&iomem_resource,
|
|
&platform_parms.kram_res_p[i]);
|
|
|
|
/* XRAM space */
|
|
for (i = 0; i < STANDARD_XRAM_RESOURCES; i++)
|
|
request_resource(&iomem_resource,
|
|
&platform_parms.xram_res_p[i]);
|
|
|
|
/* ROM space */
|
|
for (i = 0; i < STANDARD_ROM_RESOURCES; i++)
|
|
request_resource(&iomem_resource,
|
|
&platform_parms.rom_res_p[i]);
|
|
|
|
/* I/O space */
|
|
for (i = 0; i < STANDARD_IO_RESOURCES; i++)
|
|
request_resource(&ioport_resource,
|
|
&platform_parms.io_res_p[i]);
|
|
|
|
|
|
#ifdef CONFIG_VT
|
|
#if defined(CONFIG_VGA_CONSOLE)
|
|
conswitchp = &vga_con;
|
|
#elif defined(CONFIG_DUMMY_CONSOLE)
|
|
conswitchp = &dummy_con;
|
|
#endif
|
|
#endif
|
|
|
|
printk("Hardware FPU: %s\n", fpu_in_use ? "enabled" : "disabled");
|
|
|
|
paging_init();
|
|
}
|
|
|
|
void __xchg_called_with_bad_pointer(void)
|
|
{
|
|
printk(KERN_EMERG "xchg() called with bad pointer !\n");
|
|
}
|
|
|
|
static struct cpu cpu[1];
|
|
|
|
static int __init topology_init(void)
|
|
{
|
|
return register_cpu(cpu, 0);
|
|
}
|
|
|
|
subsys_initcall(topology_init);
|
|
|
|
/*
|
|
* Get CPU information
|
|
*/
|
|
static const char *cpu_name[] = {
|
|
[CPU_SH5_101] = "SH5-101",
|
|
[CPU_SH5_103] = "SH5-103",
|
|
[CPU_SH_NONE] = "Unknown",
|
|
};
|
|
|
|
const char *get_cpu_subtype(void)
|
|
{
|
|
return cpu_name[boot_cpu_data.type];
|
|
}
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
static int show_cpuinfo(struct seq_file *m,void *v)
|
|
{
|
|
unsigned int cpu = smp_processor_id();
|
|
|
|
if (!cpu)
|
|
seq_printf(m, "machine\t\t: %s\n", get_system_type());
|
|
|
|
seq_printf(m, "processor\t: %d\n", cpu);
|
|
seq_printf(m, "cpu family\t: SH-5\n");
|
|
seq_printf(m, "cpu type\t: %s\n", get_cpu_subtype());
|
|
|
|
seq_printf(m, "icache size\t: %dK-bytes\n",
|
|
(boot_cpu_data.icache.ways *
|
|
boot_cpu_data.icache.sets *
|
|
boot_cpu_data.icache.linesz) >> 10);
|
|
seq_printf(m, "dcache size\t: %dK-bytes\n",
|
|
(boot_cpu_data.dcache.ways *
|
|
boot_cpu_data.dcache.sets *
|
|
boot_cpu_data.dcache.linesz) >> 10);
|
|
seq_printf(m, "itlb entries\t: %d\n", boot_cpu_data.itlb.entries);
|
|
seq_printf(m, "dtlb entries\t: %d\n", boot_cpu_data.dtlb.entries);
|
|
|
|
#define PRINT_CLOCK(name, value) \
|
|
seq_printf(m, name " clock\t: %d.%02dMHz\n", \
|
|
((value) / 1000000), ((value) % 1000000)/10000)
|
|
|
|
PRINT_CLOCK("cpu", boot_cpu_data.cpu_clock);
|
|
PRINT_CLOCK("bus", boot_cpu_data.bus_clock);
|
|
PRINT_CLOCK("module", boot_cpu_data.module_clock);
|
|
|
|
seq_printf(m, "bogomips\t: %lu.%02lu\n\n",
|
|
(loops_per_jiffy*HZ+2500)/500000,
|
|
((loops_per_jiffy*HZ+2500)/5000) % 100);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void *c_start(struct seq_file *m, loff_t *pos)
|
|
{
|
|
return (void*)(*pos == 0);
|
|
}
|
|
static void *c_next(struct seq_file *m, void *v, loff_t *pos)
|
|
{
|
|
return NULL;
|
|
}
|
|
static void c_stop(struct seq_file *m, void *v)
|
|
{
|
|
}
|
|
struct seq_operations cpuinfo_op = {
|
|
.start = c_start,
|
|
.next = c_next,
|
|
.stop = c_stop,
|
|
.show = show_cpuinfo,
|
|
};
|
|
#endif /* CONFIG_PROC_FS */
|