567 lines
13 KiB
C
567 lines
13 KiB
C
|
/*
|
||
|
|
* 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
|