Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

/*

 *  linux/arch/or32/kernel/setup.c

 *

 *  or32 version

 *    author(s): Matjaz Breskvar (phoenix@bsemi.com)

 *

 *  derived from cris, i386, m68k, ppc, sh ports.

 *

 *  changes:

 *  18. 11. 2003: Matjaz Breskvar (phoenix@bsemi.com)

 *    initial port to or32 architecture

 *

 */

/*

 * This file handles the architecture-dependent parts of initialization

 */

#include <linux/errno.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/tty.h>

#include <linux/ioport.h>

#include <linux/delay.h>

#include <linux/console.h>

#include <linux/init.h>

#include <linux/bootmem.h>

#include <linux/seq_file.h>

#include <linux/serial.h>

#include <asm/board.h>

#include <asm/segment.h>

#include <asm/system.h>

#include <asm/smp.h>

#include <asm/pgtable.h>

#include <asm/types.h>

#include <asm/setup.h>

#include <asm/io.h>

/*

 * Debugging stuff

 */

int __phx_mmu__ = 0;

int __phx_warn__ = 0;

int __phx_debug__ = 0;

int __phx_signal__ = 0;

/*

 * Setup options

 */

extern int root_mountflags;

extern char _stext, _etext, _edata, _end;

extern int __init setup_early_serial8250_console(char *cmdline);

#ifdef CONFIG_BLK_DEV_INITRD

extern unsigned long initrd_start, initrd_end;

extern char __initrd_start, __initrd_end;

extern char __initramfs_start, __initramfs_end;

#endif

#include <asm/machdep.h>

extern void config_BSP(char *command, int len);

void (*mach_tick)(void) = NULL;

int (*mach_set_clock_mmss) (unsigned long) = NULL;

void (*mach_sched_init) (void) = NULL;

unsigned long (*mach_gettimeoffset)(void) = NULL;

void (*mach_gettod)(int *year, int *mon, int *day, int *hour, int *min, int *sec) = NULL;

int (*mach_hwclk)(int, struct hwclk_time*) = NULL;

void (*mach_mksound)( unsigned int count, unsigned int ticks) = NULL;

void (*mach_reset)( void ) = NULL;

void (*mach_debug_init)(void) = NULL;

unsigned long fb_mem_start;

static char command_line[COMMAND_LINE_SIZE] = "root=/dev/ram console=uart,mmio,0x30000000";

/*static char command_line[COMMAND_LINE_SIZE] = "root=/dev/ram console=ttyS0";*/

extern const unsigned long text_start, edata; /* set by the linker script */

static unsigned long __init setup_memory(void)

{

        unsigned long bootmap_size, start_pfn, max_low_pfn;

#define PFN_UP(x)       (((x) + PAGE_SIZE-1) >> PAGE_SHIFT)

#define PFN_DOWN(x)     ((x) >> PAGE_SHIFT)

#define PFN_PHYS(x)     ((x) << PAGE_SHIFT)

#ifndef CONFIG_FB_OC_SHMEM_SIZE

#define CONFIG_FB_OC_SHMEM_SIZE 0

#endif /* CONFIG_FB_OC_SHMEM_SIZE */

        /* min_low_pfn points to the start of DRAM, start_pfn points

         * to the first DRAM pages after the kernel, and max_low_pfn

         * to the end of DRAM. Partial pages are not useful, so round it

         * down.

         */

        start_pfn   = PFN_UP(__pa(&_end));

        max_low_pfn = PFN_DOWN(CONFIG_OR32_MEMORY_SIZE

                               -CONFIG_FB_OC_SHMEM_SIZE

                               -CONFIG_OR32_RESERVED_MEM_SIZE);

        min_low_pfn = PAGE_OFFSET >> PAGE_SHIFT;

#undef CONFIG_FB_OC_SHMEM_SIZE

        /*

         * set the beginning of frame buffer

         */

        fb_mem_start = PFN_PHYS(max_low_pfn);

        /*

         * initialize the boot-time allocator (with low memory only)

         */

        bootmap_size = init_bootmem(start_pfn, max_low_pfn);

        free_bootmem(PFN_PHYS(start_pfn), PFN_PHYS(max_low_pfn - start_pfn));

        reserve_bootmem(PFN_PHYS(start_pfn), bootmap_size);

        return(max_low_pfn);

}

static inline unsigned long extract_value_bits(unsigned long reg,

                                               short bit_nr, short width)

{

        return((reg >> bit_nr) & (0 << width));

}

static inline unsigned long extract_value(unsigned long reg,

                                          unsigned long mask)

{

        while (!(mask & 0x1)) {

                reg  = reg  >> 1;

                mask = mask >> 1;

        }

        return(mask & reg);

}

void __init detect_timer(void)

{

        unsigned long cfg;

        cfg = mfspr(SPR_TTMR);

        printk("period 0x%x\n", SPR_TTMR & SPR_TTMR_PERIOD);

}

void __init detect_unit_config(unsigned long upr, unsigned long mask,

                               char *text, void (*func)(void))

{

        if (text != NULL)

                printk("%s", text);

        if ( upr & mask ) {

                if (func != NULL)

                        func();

                else

                        printk("present\n");

        }

        else

                printk("N/A\n");

}

void __init detect_soc_generic(unsigned long upr)

{

        detect_unit_config(upr, SPR_UPR_DCP,  "  dCACHE: ", NULL);

        detect_unit_config(upr, SPR_UPR_ICP,  "  iCACHE: ", NULL);

        detect_unit_config(upr, SPR_UPR_DMP,  "  dMMU\t: ", NULL);

        detect_unit_config(upr, SPR_UPR_IMP,  "  iMMU\t: ", NULL);

        detect_unit_config(upr, SPR_UPR_DUP,  "  debug : ", NULL);

        detect_unit_config(upr, SPR_UPR_PCUP, "  PerfC : ", NULL);

        detect_unit_config(upr, SPR_UPR_PMP,  "  PM    : ", NULL);

        detect_unit_config(upr, SPR_UPR_PICP, "  PIC   : ", NULL);

        detect_unit_config(upr, SPR_UPR_TTP,  "  TIMER : ", detect_timer);

        detect_unit_config(upr, SPR_UPR_CUST, "  CUs   : ", NULL);

/* add amount configured memory

 */

}

void __init detect_soc_rev_0(unsigned long upr)

{

        printk("  WARNING, using default values !\n"

               "           (some early revision 0 processors don't have unit present register\n"

               "            populated with all avaliable units)\n");

        printk("  dCACHE: assumed %4d Kb size, %2d bytes/line, %d way(s)",

               CONFIG_OR32_DC_SIZE, CONFIG_OR32_DC_LINE, 1);

        detect_unit_config(upr, SPR_UPR_DCP,  ", detected: ", NULL);

        printk("  iCACHE: assumed %4d Kb size, %2d bytes/line, %d way(s)",

               CONFIG_OR32_IC_SIZE, CONFIG_OR32_IC_LINE, 1);

        detect_unit_config(upr, SPR_UPR_ICP,  ", detected: ", NULL);

        printk("  dMMU\t: assumed %4d entries, %d way(s)",

               CONFIG_OR32_DTLB_ENTRIES, 1);

        detect_unit_config(upr, SPR_UPR_DMP,  ", detected: ", NULL);

        printk("  iMMU\t: assumed %4d entries, %d way(s)",

               CONFIG_OR32_ITLB_ENTRIES, 1);

        detect_unit_config(upr, SPR_UPR_IMP,  ", detected: ", NULL);

        detect_unit_config(upr, SPR_UPR_DUP,  "  debug : unknown (guess yes), detected: ", NULL);

        detect_unit_config(upr, SPR_UPR_PCUP, "  PerfC : unknown (guess no ), detected: ", NULL);

        detect_unit_config(upr, SPR_UPR_PMP,  "  PM    : unknown (guess yes), detected: ", NULL);

        detect_unit_config(upr, SPR_UPR_PICP, "  PIC   : unknown (guess yes), detected: ", NULL);

        detect_unit_config(upr, SPR_UPR_TTP,  "  TIMER : unknown (guess yes), detected: ", NULL);

        detect_unit_config(upr, SPR_UPR_CUST, "  CUs   : unknown (guess no ), detected: ", NULL);

/* add amount configured memory

 */

}

unsigned long su_asm(void);

void __init detect_soc(void)

{

        unsigned long upr, cfg, version, revision;

        upr = mfspr(SPR_UPR);

        if (upr &  SPR_UPR_UP)

                printk("Detecting Processor units:\n");

        else {

                printk("Unit Present Register not avaliable\n");

                return;

        }

        cfg = mfspr(SPR_VR);

        version=extract_value(cfg, SPR_VR_VER);

        revision=extract_value(cfg, SPR_VR_REV);

#ifndef CONFIG_OR32_ANONYMOUS

        printk("  CPU\t: or32/OpenRISC-%lx, revision %lx, @%d MHz, %s\n",

               version, revision,

               CONFIG_OR32_SYS_CLK,

               (upr & (unsigned long)SPR_UPR_SRP) ?

               "with shadow registers" : "with no shadow registers");

        if ((version == 0x1200) & (revision == 0)) {

                detect_soc_rev_0(upr);

        } else {

                detect_soc_generic(upr);

        }

#endif /* CONFIG_OR32_ANONYMOUS */

        printk("  Signed 0x%lx\n", su_asm());

}

void __init setup_arch(char **cmdline_p)

{

        unsigned long max_low_pfn;

        config_BSP(&command_line[0], COMMAND_LINE_SIZE);

        /* detect System on Chip parameters */

        detect_soc();

        /* process 1's initial memory region is the kernel code/data */

        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) &_end;

#ifdef CONFIG_BLK_DEV_INITRD

        initrd_start = (unsigned long)&__initrd_start;

        initrd_end = (unsigned long)&__initrd_end;

#endif

        /* setup bootmem allocator */

        max_low_pfn = setup_memory();

        /* paging_init() sets up the MMU and marks all pages as reserved */

        paging_init();

#ifdef CONFIG_SERIAL_8250_CONSOLE

        //      early_serial_console_init(command_line); RGD

        setup_early_serial8250_console(command_line);

#endif

#if defined(CONFIG_VT) && defined(CONFIG_DUMMY_CONSOLE)

        if(!conswitchp)

                conswitchp = &dummy_con;

#endif

        *cmdline_p = command_line;

        /* Save command line copy for /proc/cmdline RGD removed 2.6.21*/

        //memcpy(saved_command_line, command_line, COMMAND_LINE_SIZE);

        //saved_command_line[COMMAND_LINE_SIZE-1] = '\0';

        /* fire up 8051 */

//      printk("Starting 8051...\n");

//      oc8051_init();

#ifdef CONFIG_OR32_ANONYMOUS

        printk("Linux/or32 port 2003-2005 OpenCores <phoenix@bsemi.com>\n");

#endif /* CONFIG_OR32_ANONYMOUS */

}

static int show_cpuinfo(struct seq_file *m, void *v)

{

#ifndef CONFIG_OR32_ANONYMOUS

        return seq_printf(m,

                          "cpu\t\t: or32\n"

                          "cpu revision\t: %lu\n"

                          "cpu model\t: %s\n"

                          "icache size\t: %d kB\n"

                          "dcache size\t: %d kB\n"

                          "immu\t\t: %s\n"

                          "dmmu\t\t: %s\n"

                          "fpu\t\t: %s\n"

                          "ethernet\t: %s Mbps\n"

                          "bogomips\t: %lu.%02lu\n",

                          0UL,

                          "Marvin",

                          8,

                          8,

                          "64 entries, 1 way",

                          "64 entries, 1 way",

                          "no",

                          "10/100",

                          (loops_per_jiffy * HZ) / 500000,

                          ((loops_per_jiffy * HZ) / 5000) % 100);

#else /* CONFIG_OR32_ANONYMOUS */

        return seq_printf(m,

                          "cpu revision\t: %lu\n"

                          "icache size\t: %d kB\n"

                          "dcache size\t: %d kB\n"

                          "immu\t\t: %s\n"

                          "dmmu\t\t: %s\n"

                          "ethernet\t: %s Mbps\n",

                          0UL,

                          8,

                          8,

                          "64 entries, 1 way",

                          "64 entries, 1 way",

                          "10/100");

#endif /* CONFIG_OR32_ANONYMOUS */

}

static void *c_start(struct seq_file *m, loff_t *pos)

{

        /* We only got one CPU... */

        return *pos < 1 ? (void *)1 : NULL;

}

static void *c_next(struct seq_file *m, void *v, loff_t *pos)

{

        ++*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,

};

void arch_gettod(int *year, int *mon, int *day, int *hour,

                                  int *min, int *sec)

{

        if (mach_gettod)

                mach_gettod(year, mon, day, hour, min, sec);

        else

                *year = *mon = *day = *hour = *min = *sec = 0;

}

/*RGD this awful hack is because our compiler does

 *support the "weak" attribute correctly at this time

 *once we do (support weak) this should be removed!!

 */

extern const void __start_notes(){}

extern const void __stop_notes(){}