[MIPS] PMC MSP71xx core platform

Patch to add core platform support for the PMC-Sierra MSP71xx devices.

Signed-off-by: Marc St-Jean <Marc_St-Jean@pmc-sierra.com>
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>

1 files changed, 566 insertions, 0 deletions

diff --git a/arch/mips/pmc-sierra/msp71xx/msp_prom.c b/arch/mips/pmc-sierra/msp71xx/msp_prom.c
new file mode 100644
index 000000000000..e5bd5481d8db
--- /dev/null
+++ b/arch/mips/pmc-sierra/msp71xx/msp_prom.c
@@ -0,0 +1,566 @@
+/*
+ * 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