[linux-2.6-block.git] / arch / mips / pmcs-msp71xx / msp_prom.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/export.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/interrupt.h>
#include <linux/mm.h>
#include <linux/slab.h>

#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];

#define MAX_PROM_MEM 5
static phys_addr_t prom_mem_base[MAX_PROM_MEM] __initdata;
static phys_addr_t prom_mem_size[MAX_PROM_MEM] __initdata;
static unsigned int nr_prom_mem __initdata;

/* 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 */
}

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 */
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++;

		if (type == BOOT_MEM_ROM_DATA) {
			if (nr_prom_mem >= MAX_PROM_MEM) {
				pr_err("Too many ROM DATA regions");
				continue;
			}
			prom_mem_base[nr_prom_mem] = base;
			prom_mem_size[nr_prom_mem] = size;
			nr_prom_mem++;
		}
	}
}

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 < nr_prom_mem; i++) {
		free_init_pages("prom memory",
			prom_mem_base[i], prom_mem_base[i] + prom_mem_size[i]);
	}
}

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;
	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);
	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];
}
Commit	Line	Data
35832e26 MSJ	1	/*
	2	* BRIEF MODULE DESCRIPTION
	3	* PROM library initialisation code, assuming a version of
	4	* pmon is the boot code.
	5	*
	6	* Copyright 2000,2001 MontaVista Software Inc.
	7	* Author: MontaVista Software, Inc.
	8	* ppopov@mvista.com or source@mvista.com
	9	*
	10	* This file was derived from Carsten Langgaard's
	11	* arch/mips/mips-boards/xx files.
	12	*
	13	* Carsten Langgaard, carstenl@mips.com
	14	* Copyright (C) 1999,2000 MIPS Technologies, Inc. All rights reserved.
	15	*
	16	* This program is free software; you can redistribute it and/or modify it
	17	* under the terms of the GNU General Public License as published by the
	18	* Free Software Foundation; either version 2 of the License, or (at your
	19	* option) any later version.
	20	*
	21	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
	22	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	23	* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
	24	* NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	25	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	26	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
	27	* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
	28	* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	29	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	30	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	31	*
	32	* You should have received a copy of the GNU General Public License along
	33	* with this program; if not, write to the Free Software Foundation, Inc.,
	34	* 675 Mass Ave, Cambridge, MA 02139, USA.
	35	*/
	36
26dd3e4f	37	#include <linux/export.h>
35832e26 MSJ	38	#include <linux/kernel.h>
	39	#include <linux/init.h>
	40	#include <linux/string.h>
	41	#include <linux/interrupt.h>
	42	#include <linux/mm.h>
5a0e3ad6	43	#include <linux/slab.h>
35832e26 MSJ	44
	45	#include <asm/addrspace.h>
	46	#include <asm/bootinfo.h>
	47	#include <asm-generic/sections.h>
	48	#include <asm/page.h>
	49
	50	#include <msp_prom.h>
	51	#include <msp_regs.h>
	52
	53	/* global PROM environment variables and pointers */
	54	int prom_argc;
	55	char prom_argv, prom_envp;
	56	int *prom_vec;
	57
	58	/* debug flag */
	59	int init_debug = 1;
	60
	61	/* memory blocks */
	62	struct prom_pmemblock mdesc[PROM_MAX_PMEMBLOCKS];
	63
101c40ed	64	#define MAX_PROM_MEM 5
b3c948e2 JY	65	static phys_addr_t prom_mem_base[MAX_PROM_MEM] __initdata;
	66	static phys_addr_t prom_mem_size[MAX_PROM_MEM] __initdata;
	67	static unsigned int nr_prom_mem __initdata;
	68
35832e26 MSJ	69	/* default feature sets */
	70	static char msp_default_features[] =
	71	#if defined(CONFIG_PMC_MSP4200_EVAL) \
	72	\|\| defined(CONFIG_PMC_MSP4200_GW)
	73	"ERER";
	74	#elif defined(CONFIG_PMC_MSP7120_EVAL) \
	75	\|\| defined(CONFIG_PMC_MSP7120_GW)
	76	"EMEMSP";
	77	#elif defined(CONFIG_PMC_MSP7120_FPGA)
	78	"EMEM";
	79	#endif
	80
	81	/* conversion functions */
	82	static inline unsigned char str2hexnum(unsigned char c)
	83	{
	84	if (c >= '0' && c <= '9')
	85	return c - '0';
	86	if (c >= 'a' && c <= 'f')
	87	return c - 'a' + 10;
	88	return 0; /* foo */
	89	}
	90
d552b233	91	int str2eaddr(unsigned char ea, unsigned char str)
35832e26 MSJ	92	{
	93	int index = 0;
	94	unsigned char num = 0;
	95
	96	while (*str != '\0') {
	97	if ((str == '.') \|\| (str == ':')) {
	98	ea[index++] = num;
	99	num = 0;
	100	str++;
	101	} else {
	102	num = num << 4;
	103	num \|= str2hexnum(*str++);
	104	}
	105	}
	106
70342287	107	if (index == 5) {
35832e26 MSJ	108	ea[index++] = num;
	109	return 0;
	110	} else
	111	return -1;
	112	}
	113	EXPORT_SYMBOL(str2eaddr);
	114
	115	static inline unsigned long str2hex(unsigned char *str)
	116	{
	117	int value = 0;
	118
	119	while (*str) {
	120	value = value << 4;
	121	value \|= str2hexnum(*str++);
	122	}
	123
	124	return value;
	125	}
	126
	127	/* function to query the system information */
	128	const char *get_system_type(void)
	129	{
	130	#if defined(CONFIG_PMC_MSP4200_EVAL)
	131	return "PMC-Sierra MSP4200 Eval Board";
	132	#elif defined(CONFIG_PMC_MSP4200_GW)
	133	return "PMC-Sierra MSP4200 VoIP Gateway";
	134	#elif defined(CONFIG_PMC_MSP7120_EVAL)
	135	return "PMC-Sierra MSP7120 Eval Board";
	136	#elif defined(CONFIG_PMC_MSP7120_GW)
	137	return "PMC-Sierra MSP7120 Residential Gateway";
	138	#elif defined(CONFIG_PMC_MSP7120_FPGA)
	139	return "PMC-Sierra MSP7120 FPGA";
	140	#else
	141	#error "What is the type of your MSP?"
	142	#endif
	143	}
	144
	145	int get_ethernet_addr(char ethaddr_name, char ethernet_addr)
	146	{
	147	char *ethaddr_str;
	148
	149	ethaddr_str = prom_getenv(ethaddr_name);
	150	if (!ethaddr_str) {
	151	printk(KERN_WARNING "%s not set in boot prom\n", ethaddr_name);
	152	return -1;
	153	}
	154
	155	if (str2eaddr(ethernet_addr, ethaddr_str) == -1) {
	156	printk(KERN_WARNING "%s badly formatted-<%s>\n",
	157	ethaddr_name, ethaddr_str);
	158	return -1;
	159	}
	160
	161	if (init_debug > 1) {
	162	int i;
	163	printk(KERN_DEBUG "get_ethernet_addr: for %s ", ethaddr_name);
	164	for (i = 0; i < 5; i++)
	165	printk(KERN_DEBUG "%02x:",
	166	(unsigned char)*(ethernet_addr+i));
	167	printk(KERN_DEBUG "%02x\n", *(ethernet_addr+i));
	168	}
	169
	170	return 0;
	171	}
172	EXPORT_SYMBOL(get_ethernet_addr);
173
174	static char *get_features(void)
175	{
176	char *feature = prom_getenv(FEATURES);
177
178	if (feature == NULL) {
179	/* default features based on MACHINE_TYPE */
180	feature = msp_default_features;
181	}
182
183	return feature;
184	}
185
186	static char test_feature(char c)
187	{
188	char *feature = get_features();
189
190	while (*feature) {
191	if (*feature++ == c)
192	return *feature;
193	feature++;
194	}
195
196	return FEATURE_NOEXIST;
197	}
198
199	unsigned long get_deviceid(void)
200	{
201	char *deviceid = prom_getenv(DEVICEID);
202
203	if (deviceid == NULL)
204	return *DEV_ID_REG;
205	else
206	return str2hex(deviceid);
207	}
208
209	char identify_pci(void)
210	{
211	return test_feature(PCI_KEY);
212	}
213	EXPORT_SYMBOL(identify_pci);
214
215	char identify_pcimux(void)
216	{
217	return test_feature(PCIMUX_KEY);
218	}
219
220	char identify_sec(void)
221	{
222	return test_feature(SEC_KEY);
223	}
224	EXPORT_SYMBOL(identify_sec);
225
226	char identify_spad(void)
227	{
228	return test_feature(SPAD_KEY);
229	}
230	EXPORT_SYMBOL(identify_spad);
231
232	char identify_tdm(void)
233	{
234	return test_feature(TDM_KEY);
235	}
236	EXPORT_SYMBOL(identify_tdm);
237
238	char identify_zsp(void)
239	{
240	return test_feature(ZSP_KEY);
241	}
242	EXPORT_SYMBOL(identify_zsp);
243
244	static char identify_enetfeature(char key, unsigned long interface_num)
245	{
246	char *feature = get_features();
247
248	while (*feature) {
249	if (*feature++ == key && interface_num-- == 0)
250	return *feature;
251	feature++;
252	}
253
254	return FEATURE_NOEXIST;
255	}
256
257	char identify_enet(unsigned long interface_num)
258	{
259	return identify_enetfeature(ENET_KEY, interface_num);
260	}
261	EXPORT_SYMBOL(identify_enet);
262
263	char identify_enetTxD(unsigned long interface_num)
264	{
265	return identify_enetfeature(ENETTXD_KEY, interface_num);
266	}
267	EXPORT_SYMBOL(identify_enetTxD);
268
269	unsigned long identify_family(void)
270	{
271	unsigned long deviceid;
272
273	deviceid = get_deviceid();
274
275	return deviceid & CPU_DEVID_FAMILY;
276	}
277	EXPORT_SYMBOL(identify_family);
278
279	unsigned long identify_revision(void)
280	{
281	unsigned long deviceid;
282
283	deviceid = get_deviceid();
284
285	return deviceid & CPU_DEVID_REVISION;
286	}
287	EXPORT_SYMBOL(identify_revision);
288
289	/* PROM environment functions */
290	char prom_getenv(char env_name)
291	{
292	/*
70342287	293	* Return a pointer to the given environment variable. prom_envp
35832e26 MSJ	294	* points to a null terminated array of pointers to variables.
	295	* Environment variables are stored in the form of "memsize=64"
	296	*/
	297
	298	char **var = prom_envp;
	299	int i = strlen(env_name);
	300
	301	while (*var) {
	302	if (strncmp(env_name, *var, i) == 0) {
635c9907	303	return *var + strlen(env_name) + 1;
35832e26 MSJ	304	}
	305	var++;
	306	}
	307
	308	return NULL;
	309	}
	310
	311	/* PROM commandline functions */
35832e26 MSJ	312	void __init prom_init_cmdline(void)
	313	{
	314	char *cp;
	315	int actr;
	316
	317	actr = 1; /* Always ignore argv[0] */
	318
	319	cp = &(arcs_cmdline[0]);
	320	while (actr < prom_argc) {
	321	strcpy(cp, prom_argv[actr]);
	322	cp += strlen(prom_argv[actr]);
	323	*cp++ = ' ';
	324	actr++;
	325	}
	326	if (cp != &(arcs_cmdline[0])) /* get rid of trailing space */
	327	--cp;
	328	*cp = '\0';
	329	}
	330
	331	/* memory allocation functions */
	332	static int __init prom_memtype_classify(unsigned int type)
	333	{
	334	switch (type) {
	335	case yamon_free:
	336	return BOOT_MEM_RAM;
	337	case yamon_prom:
	338	return BOOT_MEM_ROM_DATA;
	339	default:
	340	return BOOT_MEM_RESERVED;
	341	}
	342	}
	343
	344	void __init prom_meminit(void)
	345	{
	346	struct prom_pmemblock *p;
	347
	348	p = prom_getmdesc();
	349
	350	while (p->size) {
	351	long type;
	352	unsigned long base, size;
	353
	354	type = prom_memtype_classify(p->type);
	355	base = p->base;
	356	size = p->size;
	357
	358	add_memory_region(base, size, type);
	359	p++;
b3c948e2 JY	360
b3c948e2 JY	361	if (type == BOOT_MEM_ROM_DATA) {
101c40ed	362	if (nr_prom_mem >= MAX_PROM_MEM) {
b3c948e2 JY	363	pr_err("Too many ROM DATA regions");
	364	continue;
	365	}
	366	prom_mem_base[nr_prom_mem] = base;
	367	prom_mem_size[nr_prom_mem] = size;
	368	nr_prom_mem++;
	369	}
35832e26 MSJ	370	}
	371	}
	372
	373	void __init prom_free_prom_memory(void)
	374	{
	375	int argc;
	376	char **argv;
	377	char **envp;
	378	char *ptr;
	379	int len = 0;
	380	int i;
	381	unsigned long addr;
	382
	383	/*
	384	* preserve environment variables and command line from pmon/bbload
	385	* first preserve the command line
	386	*/
	387	for (argc = 0; argc < prom_argc; argc++) {
	388	len += sizeof(char ); / length of pointer */
	389	len += strlen(prom_argv[argc]) + 1; /* length of string */
	390	}
	391	len += sizeof(char ); / plus length of null pointer */
	392
	393	argv = kmalloc(len, GFP_KERNEL);
	394	ptr = (char ) &argv[prom_argc + 1]; / strings follow array */
	395
	396	for (argc = 0; argc < prom_argc; argc++) {
	397	argv[argc] = ptr;
	398	strcpy(ptr, prom_argv[argc]);
	399	ptr += strlen(prom_argv[argc]) + 1;
	400	}
	401	argv[prom_argc] = NULL; /* end array with null pointer */
	402	prom_argv = argv;
	403
	404	/* next preserve the environment variables */
	405	len = 0;
	406	i = 0;
	407	for (envp = prom_envp; *envp != NULL; envp++) {
	408	i++; /* count number of environment variables */
	409	len += sizeof(char ); / length of pointer */
	410	len += strlen(envp) + 1; / length of string */
	411	}
	412	len += sizeof(char ); / plus length of null pointer */
	413
	414	envp = kmalloc(len, GFP_KERNEL);
	415	ptr = (char *) &envp[i+1];
	416
	417	for (argc = 0; argc < i; argc++) {
	418	envp[argc] = ptr;
	419	strcpy(ptr, prom_envp[argc]);
	420	ptr += strlen(prom_envp[argc]) + 1;
	421	}
	422	envp[i] = NULL; /* end array with null pointer */
	423	prom_envp = envp;
	424
b3c948e2	425	for (i = 0; i < nr_prom_mem; i++) {
35832e26	426	free_init_pages("prom memory",
b3c948e2	427	prom_mem_base[i], prom_mem_base[i] + prom_mem_size[i]);
35832e26 MSJ	428	}
	429	}
	430
	431	struct prom_pmemblock *__init prom_getmdesc(void)
	432	{
	433	static char memsz_env[] __initdata = "memsize";
	434	static char heaptop_env[] __initdata = "heaptop";
	435	char *str;
	436	unsigned int memsize;
	437	unsigned int heaptop;
35832e26 MSJ	438	int i;
	439
	440	str = prom_getenv(memsz_env);
	441	if (!str) {
	442	ppfinit("memsize not set in boot prom, "
	443	"set to default (32Mb)\n");
	444	memsize = 0x02000000;
	445	} else {
	446	memsize = simple_strtol(str, NULL, 0);
	447
	448	if (memsize == 0) {
	449	/* if memsize is a bad size, use reasonable default */
	450	memsize = 0x02000000;
	451	}
	452
	453	/* convert to physical address (removing caching bits, etc) */
	454	memsize = CPHYSADDR(memsize);
	455	}
	456
	457	str = prom_getenv(heaptop_env);
	458	if (!str) {
	459	heaptop = CPHYSADDR((u32)&_text);
	460	ppfinit("heaptop not set in boot prom, "
	461	"set to default 0x%08x\n", heaptop);
	462	} else {
	463	heaptop = simple_strtol(str, NULL, 16);
	464	if (heaptop == 0) {
	465	/* heaptop conversion bad, might have 0xValue */
	466	heaptop = simple_strtol(str, NULL, 0);
	467
	468	if (heaptop == 0) {
	469	/* heaptop still bad, use reasonable default */
	470	heaptop = CPHYSADDR((u32)&_text);
	471	}
	472	}
	473
	474	/* convert to physical address (removing caching bits, etc) */
	475	heaptop = CPHYSADDR((u32)heaptop);
	476	}
	477
	478	/* the base region */
	479	i = 0;
	480	mdesc[i].type = BOOT_MEM_RESERVED;
	481	mdesc[i].base = 0x00000000;
	482	mdesc[i].size = PAGE_ALIGN(0x300 + 0x80);
	483	/* jtag interrupt vector + sizeof vector */
	484
	485	/* PMON data */
	486	if (heaptop > mdesc[i].base + mdesc[i].size) {
	487	i++; /* 1 */
	488	mdesc[i].type = BOOT_MEM_ROM_DATA;
	489	mdesc[i].base = mdesc[i-1].base + mdesc[i-1].size;
	490	mdesc[i].size = heaptop - mdesc[i].base;
	491	}
	492
	493	/* end of PMON data to start of kernel -- probably zero .. */
	494	if (heaptop != CPHYSADDR((u32)_text)) {
	495	i++; /* 2 */
	496	mdesc[i].type = BOOT_MEM_RAM;
	497	mdesc[i].base = heaptop;
	498	mdesc[i].size = CPHYSADDR((u32)_text) - mdesc[i].base;
	499	}
	500
	501	/* kernel proper */
502	i++; /* 3 */
503	mdesc[i].type = BOOT_MEM_RESERVED;
504	mdesc[i].base = CPHYSADDR((u32)_text);
5c5dd1d2	505	mdesc[i].size = CPHYSADDR(PAGE_ALIGN((u32)_end)) - mdesc[i].base;
35832e26 MSJ	506
	507	/* Remainder of RAM -- under memsize */
	508	i++; /* 5 */
	509	mdesc[i].type = yamon_free;
	510	mdesc[i].base = mdesc[i-1].base + mdesc[i-1].size;
	511	mdesc[i].size = memsize - mdesc[i].base;
	512
	513	return &mdesc[0];
	514	}