Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

/*

 * BRIEF MODULE DESCRIPTION

 *    PROM library initialisation code, assuming a version of

 *    pmon is the boot code.

 *

 * Copyright 2000,2001 MontaVista Software Inc.

 * Author: MontaVista Software, Inc.

 *              ppopov@mvista.com or source@mvista.com

 *

 * This file was derived from Carsten Langgaard's

 * arch/mips/mips-boards/xx files.

 *

 * Carsten Langgaard, carstenl@mips.com

 * Copyright (C) 1999,2000 MIPS Technologies, Inc.  All rights reserved.

 *

 *  This program is free software; you can redistribute  it and/or modify it

 *  under  the terms of  the GNU General  Public License as published by the

 *  Free Software Foundation;  either version 2 of the  License, or (at your

 *  option) any later version.

 *

 *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED

 *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF

 *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN

 *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,

 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF

 *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON

 *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT

 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 *  You should have received a copy of the  GNU General Public License along

 *  with this program; if not, write  to the Free Software Foundation, Inc.,

 *  675 Mass Ave, Cambridge, MA 02139, USA.

 */

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/init.h>

#include <linux/string.h>

#include <linux/interrupt.h>

#include <linux/mm.h>

#ifdef CONFIG_CRAMFS

#include <linux/cramfs_fs.h>

#endif

#ifdef CONFIG_SQUASHFS

#include <linux/squashfs_fs.h>

#endif

#include <asm/addrspace.h>

#include <asm/bootinfo.h>

#include <asm-generic/sections.h>

#include <asm/page.h>

#include <msp_prom.h>

#include <msp_regs.h>

/* global PROM environment variables and pointers */

int prom_argc;

char **prom_argv, **prom_envp;

int *prom_vec;

/* debug flag */

int init_debug = 1;

/* memory blocks */

struct prom_pmemblock mdesc[PROM_MAX_PMEMBLOCKS];

/* default feature sets */

static char msp_default_features[] =

#if defined(CONFIG_PMC_MSP4200_EVAL) \

 || defined(CONFIG_PMC_MSP4200_GW)

        "ERER";

#elif defined(CONFIG_PMC_MSP7120_EVAL) \

 || defined(CONFIG_PMC_MSP7120_GW)

        "EMEMSP";

#elif defined(CONFIG_PMC_MSP7120_FPGA)

        "EMEM";

#endif

/* conversion functions */

static inline unsigned char str2hexnum(unsigned char c)

{

        if (c >= '0' && c <= '9')

                return c - '0';

        if (c >= 'a' && c <= 'f')

                return c - 'a' + 10;

        return 0; /* foo */

}

static inline int str2eaddr(unsigned char *ea, unsigned char *str)

{

        int index = 0;

        unsigned char num = 0;

        while (*str != '\0') {

                if ((*str == '.') || (*str == ':')) {

                        ea[index++] = num;

                        num = 0;

                        str++;

                } else {

                        num = num << 4;

                        num |= str2hexnum(*str++);

                }

        }

        if (index == 5) {

                ea[index++] = num;

                return 0;

        } else

                return -1;

}

EXPORT_SYMBOL(str2eaddr);

static inline unsigned long str2hex(unsigned char *str)

{

        int value = 0;

        while (*str) {

                value = value << 4;

                value |= str2hexnum(*str++);

        }

        return value;

}

/* function to query the system information */

const char *get_system_type(void)

{

#if defined(CONFIG_PMC_MSP4200_EVAL)

        return "PMC-Sierra MSP4200 Eval Board";

#elif defined(CONFIG_PMC_MSP4200_GW)

        return "PMC-Sierra MSP4200 VoIP Gateway";

#elif defined(CONFIG_PMC_MSP7120_EVAL)

        return "PMC-Sierra MSP7120 Eval Board";

#elif defined(CONFIG_PMC_MSP7120_GW)

        return "PMC-Sierra MSP7120 Residential Gateway";

#elif defined(CONFIG_PMC_MSP7120_FPGA)

        return "PMC-Sierra MSP7120 FPGA";

#else

        #error "What is the type of *your* MSP?"

#endif

}

int get_ethernet_addr(char *ethaddr_name, char *ethernet_addr)

{

        char *ethaddr_str;

        ethaddr_str = prom_getenv(ethaddr_name);

        if (!ethaddr_str) {

                printk(KERN_WARNING "%s not set in boot prom\n", ethaddr_name);

                return -1;

        }

        if (str2eaddr(ethernet_addr, ethaddr_str) == -1) {

                printk(KERN_WARNING "%s badly formatted-<%s>\n",

                        ethaddr_name, ethaddr_str);

                return -1;

        }

        if (init_debug > 1) {

                int i;

                printk(KERN_DEBUG "get_ethernet_addr: for %s ", ethaddr_name);

                for (i = 0; i < 5; i++)

                        printk(KERN_DEBUG "%02x:",

                                (unsigned char)*(ethernet_addr+i));

                printk(KERN_DEBUG "%02x\n", *(ethernet_addr+i));

        }

        return 0;

}

EXPORT_SYMBOL(get_ethernet_addr);

static char *get_features(void)

{

        char *feature = prom_getenv(FEATURES);

        if (feature == NULL) {

                /* default features based on MACHINE_TYPE */

                feature = msp_default_features;

        }

        return feature;

}

static char test_feature(char c)

{

        char *feature = get_features();

        while (*feature) {

                if (*feature++ == c)

                        return *feature;

                feature++;

        }

        return FEATURE_NOEXIST;

}

unsigned long get_deviceid(void)

{

        char *deviceid = prom_getenv(DEVICEID);

        if (deviceid == NULL)

                return *DEV_ID_REG;

        else

                return str2hex(deviceid);

}

char identify_pci(void)

{

        return test_feature(PCI_KEY);

}

EXPORT_SYMBOL(identify_pci);

char identify_pcimux(void)

{

        return test_feature(PCIMUX_KEY);

}

char identify_sec(void)

{

        return test_feature(SEC_KEY);

}

EXPORT_SYMBOL(identify_sec);

char identify_spad(void)

{

        return test_feature(SPAD_KEY);

}

EXPORT_SYMBOL(identify_spad);

char identify_tdm(void)

{

        return test_feature(TDM_KEY);

}

EXPORT_SYMBOL(identify_tdm);

char identify_zsp(void)

{

        return test_feature(ZSP_KEY);

}

EXPORT_SYMBOL(identify_zsp);

static char identify_enetfeature(char key, unsigned long interface_num)

{

        char *feature = get_features();

        while (*feature) {

                if (*feature++ == key && interface_num-- == 0)

                        return *feature;

                feature++;

        }

        return FEATURE_NOEXIST;

}

char identify_enet(unsigned long interface_num)

{

        return identify_enetfeature(ENET_KEY, interface_num);

}

EXPORT_SYMBOL(identify_enet);

char identify_enetTxD(unsigned long interface_num)

{

        return identify_enetfeature(ENETTXD_KEY, interface_num);

}

EXPORT_SYMBOL(identify_enetTxD);

unsigned long identify_family(void)

{

        unsigned long deviceid;

        deviceid = get_deviceid();

        return deviceid & CPU_DEVID_FAMILY;

}

EXPORT_SYMBOL(identify_family);

unsigned long identify_revision(void)

{

        unsigned long deviceid;

        deviceid = get_deviceid();

        return deviceid & CPU_DEVID_REVISION;

}

EXPORT_SYMBOL(identify_revision);

/* PROM environment functions */

char *prom_getenv(char *env_name)

{

        /*

         * Return a pointer to the given environment variable.  prom_envp

         * points to a null terminated array of pointers to variables.

         * Environment variables are stored in the form of "memsize=64"

         */

        char **var = prom_envp;

        int i = strlen(env_name);

        while (*var) {

                if (strncmp(env_name, *var, i) == 0) {

                        return (*var + strlen(env_name) + 1);

                }

                var++;

        }

        return NULL;

}

/* PROM commandline functions */

char *prom_getcmdline(void)

{

        return &(arcs_cmdline[0]);

}

EXPORT_SYMBOL(prom_getcmdline);

void  __init prom_init_cmdline(void)

{

        char *cp;

        int actr;

        actr = 1; /* Always ignore argv[0] */

        cp = &(arcs_cmdline[0]);

        while (actr < prom_argc) {

                strcpy(cp, prom_argv[actr]);

                cp += strlen(prom_argv[actr]);

                *cp++ = ' ';

                actr++;

        }

        if (cp != &(arcs_cmdline[0])) /* get rid of trailing space */

                --cp;

        *cp = '\0';

}

/* memory allocation functions */

static int __init prom_memtype_classify(unsigned int type)

{

        switch (type) {

        case yamon_free:

                return BOOT_MEM_RAM;

        case yamon_prom:

                return BOOT_MEM_ROM_DATA;

        default:

                return BOOT_MEM_RESERVED;

        }

}

void __init prom_meminit(void)

{

        struct prom_pmemblock *p;

        p = prom_getmdesc();

        while (p->size) {

                long type;

                unsigned long base, size;

                type = prom_memtype_classify(p->type);

                base = p->base;

                size = p->size;

                add_memory_region(base, size, type);

                p++;

        }

}

void __init prom_free_prom_memory(void)

{

        int     argc;

        char    **argv;

        char    **envp;

        char    *ptr;

        int     len = 0;

        int     i;

        unsigned long addr;

        /*

         * preserve environment variables and command line from pmon/bbload

         * first preserve the command line

         */

        for (argc = 0; argc < prom_argc; argc++) {

                len += sizeof(char *);                  /* length of pointer */

                len += strlen(prom_argv[argc]) + 1;     /* length of string */

        }

        len += sizeof(char *);          /* plus length of null pointer */

        argv = kmalloc(len, GFP_KERNEL);

        ptr = (char *) &argv[prom_argc + 1];    /* strings follow array */

        for (argc = 0; argc < prom_argc; argc++) {

                argv[argc] = ptr;

                strcpy(ptr, prom_argv[argc]);

                ptr += strlen(prom_argv[argc]) + 1;

        }

        argv[prom_argc] = NULL;         /* end array with null pointer */

        prom_argv = argv;

        /* next preserve the environment variables */

        len = 0;

        i = 0;

        for (envp = prom_envp; *envp != NULL; envp++) {

                i++;            /* count number of environment variables */

                len += sizeof(char *);          /* length of pointer */

                len += strlen(*envp) + 1;       /* length of string */

        }

        len += sizeof(char *);          /* plus length of null pointer */

        envp = kmalloc(len, GFP_KERNEL);

        ptr = (char *) &envp[i+1];

        for (argc = 0; argc < i; argc++) {

                envp[argc] = ptr;

                strcpy(ptr, prom_envp[argc]);

                ptr += strlen(prom_envp[argc]) + 1;

        }

        envp[i] = NULL;                 /* end array with null pointer */

        prom_envp = envp;

        for (i = 0; i < boot_mem_map.nr_map; i++) {

                if (boot_mem_map.map[i].type != BOOT_MEM_ROM_DATA)

                        continue;

                addr = boot_mem_map.map[i].addr;

                free_init_pages("prom memory",

                                addr, addr + boot_mem_map.map[i].size);

        }

}

struct prom_pmemblock *__init prom_getmdesc(void)

{

        static char     memsz_env[] __initdata = "memsize";

        static char     heaptop_env[] __initdata = "heaptop";

        char            *str;

        unsigned int    memsize;

        unsigned int    heaptop;

#ifdef CONFIG_MTD_PMC_MSP_RAMROOT

        void            *ramroot_start;

        unsigned long   ramroot_size;

#endif

        int i;

        str = prom_getenv(memsz_env);

        if (!str) {

                ppfinit("memsize not set in boot prom, "

                        "set to default (32Mb)\n");

                memsize = 0x02000000;

        } else {

                memsize = simple_strtol(str, NULL, 0);

                if (memsize == 0) {

                        /* if memsize is a bad size, use reasonable default */

                        memsize = 0x02000000;

                }

                /* convert to physical address (removing caching bits, etc) */

                memsize = CPHYSADDR(memsize);

        }

        str = prom_getenv(heaptop_env);

        if (!str) {

                heaptop = CPHYSADDR((u32)&_text);

                ppfinit("heaptop not set in boot prom, "

                        "set to default 0x%08x\n", heaptop);

        } else {

                heaptop = simple_strtol(str, NULL, 16);

                if (heaptop == 0) {

                        /* heaptop conversion bad, might have 0xValue */

                        heaptop = simple_strtol(str, NULL, 0);

                        if (heaptop == 0) {

                                /* heaptop still bad, use reasonable default */

                                heaptop = CPHYSADDR((u32)&_text);

                        }

                }

                /* convert to physical address (removing caching bits, etc) */

                heaptop = CPHYSADDR((u32)heaptop);

        }

        /* the base region */

        i = 0;

        mdesc[i].type = BOOT_MEM_RESERVED;

        mdesc[i].base = 0x00000000;

        mdesc[i].size = PAGE_ALIGN(0x300 + 0x80);

                /* jtag interrupt vector + sizeof vector */

        /* PMON data */

        if (heaptop > mdesc[i].base + mdesc[i].size) {

                i++;                    /* 1 */

                mdesc[i].type = BOOT_MEM_ROM_DATA;

                mdesc[i].base = mdesc[i-1].base + mdesc[i-1].size;

                mdesc[i].size = heaptop - mdesc[i].base;

        }

        /* end of PMON data to start of kernel -- probably zero .. */

        if (heaptop != CPHYSADDR((u32)_text)) {

                i++;    /* 2 */

                mdesc[i].type = BOOT_MEM_RAM;

                mdesc[i].base = heaptop;

                mdesc[i].size = CPHYSADDR((u32)_text) - mdesc[i].base;

        }

        /*  kernel proper */

        i++;                    /* 3 */

        mdesc[i].type = BOOT_MEM_RESERVED;

        mdesc[i].base = CPHYSADDR((u32)_text);

#ifdef CONFIG_MTD_PMC_MSP_RAMROOT

        if (get_ramroot(&ramroot_start, &ramroot_size)) {

                /*

                 * Rootfs in RAM -- follows kernel

                 * Combine rootfs image with kernel block so a

                 * page (4k) isn't wasted between memory blocks

                 */

                mdesc[i].size = CPHYSADDR(PAGE_ALIGN(

                        (u32)ramroot_start + ramroot_size)) - mdesc[i].base;

        } else

#endif

                mdesc[i].size = CPHYSADDR(PAGE_ALIGN(

                        (u32)_end)) - mdesc[i].base;

        /* Remainder of RAM -- under memsize */

        i++;                    /* 5 */

        mdesc[i].type = yamon_free;

        mdesc[i].base = mdesc[i-1].base + mdesc[i-1].size;

        mdesc[i].size = memsize - mdesc[i].base;

        return &mdesc[0];

}

/* rootfs functions */

#ifdef CONFIG_MTD_PMC_MSP_RAMROOT

bool get_ramroot(void **start, unsigned long *size)

{

        extern char _end[];

        /* Check for start following the end of the kernel */

        void *check_start = (void *)_end;

        /* Check for supported rootfs types */

#ifdef CONFIG_CRAMFS

        if (*(__u32 *)check_start == CRAMFS_MAGIC) {

                /* Get CRAMFS size */

                *start = check_start;

                *size = PAGE_ALIGN(((struct cramfs_super *)

                                   check_start)->size);

                return true;

        }

#endif

#ifdef CONFIG_SQUASHFS

        if (*((unsigned int *)check_start) == SQUASHFS_MAGIC) {

                /* Get SQUASHFS size */

                *start = check_start;

                *size = PAGE_ALIGN(((struct squashfs_super_block *)

                                   check_start)->bytes_used);

                return true;

        }

#endif

        return false;

}

EXPORT_SYMBOL(get_ramroot);

#endif