2 * BRIEF MODULE DESCRIPTION
3 * PROM library initialisation code, assuming a version of
4 * pmon is the boot code.
6 * Copyright 2000,2001 MontaVista Software Inc.
7 * Author: MontaVista Software, Inc.
8 * ppopov@mvista.com or source@mvista.com
10 * This file was derived from Carsten Langgaard's
11 * arch/mips/mips-boards/xx files.
13 * Carsten Langgaard, carstenl@mips.com
14 * Copyright (C) 1999,2000 MIPS Technologies, Inc. All rights reserved.
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.
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.
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.
37 #include <linux/export.h>
38 #include <linux/kernel.h>
39 #include <linux/init.h>
40 #include <linux/string.h>
41 #include <linux/interrupt.h>
43 #include <linux/slab.h>
45 #include <asm/addrspace.h>
46 #include <asm/bootinfo.h>
47 #include <asm-generic/sections.h>
53 /* global PROM environment variables and pointers */
55 char **prom_argv, **prom_envp;
62 struct prom_pmemblock mdesc[PROM_MAX_PMEMBLOCKS];
64 static phys_addr_t prom_mem_base[MAX_PROM_MEM] __initdata;
65 static phys_addr_t prom_mem_size[MAX_PROM_MEM] __initdata;
66 static unsigned int nr_prom_mem __initdata;
68 /* default feature sets */
69 static char msp_default_features[] =
70 #if defined(CONFIG_PMC_MSP4200_EVAL) \
71 || defined(CONFIG_PMC_MSP4200_GW)
73 #elif defined(CONFIG_PMC_MSP7120_EVAL) \
74 || defined(CONFIG_PMC_MSP7120_GW)
76 #elif defined(CONFIG_PMC_MSP7120_FPGA)
80 /* conversion functions */
81 static inline unsigned char str2hexnum(unsigned char c)
83 if (c >= '0' && c <= '9')
85 if (c >= 'a' && c <= 'f')
90 int str2eaddr(unsigned char *ea, unsigned char *str)
93 unsigned char num = 0;
95 while (*str != '\0') {
96 if ((*str == '.') || (*str == ':')) {
102 num |= str2hexnum(*str++);
112 EXPORT_SYMBOL(str2eaddr);
114 static inline unsigned long str2hex(unsigned char *str)
120 value |= str2hexnum(*str++);
126 /* function to query the system information */
127 const char *get_system_type(void)
129 #if defined(CONFIG_PMC_MSP4200_EVAL)
130 return "PMC-Sierra MSP4200 Eval Board";
131 #elif defined(CONFIG_PMC_MSP4200_GW)
132 return "PMC-Sierra MSP4200 VoIP Gateway";
133 #elif defined(CONFIG_PMC_MSP7120_EVAL)
134 return "PMC-Sierra MSP7120 Eval Board";
135 #elif defined(CONFIG_PMC_MSP7120_GW)
136 return "PMC-Sierra MSP7120 Residential Gateway";
137 #elif defined(CONFIG_PMC_MSP7120_FPGA)
138 return "PMC-Sierra MSP7120 FPGA";
140 #error "What is the type of *your* MSP?"
144 int get_ethernet_addr(char *ethaddr_name, char *ethernet_addr)
148 ethaddr_str = prom_getenv(ethaddr_name);
150 printk(KERN_WARNING "%s not set in boot prom\n", ethaddr_name);
154 if (str2eaddr(ethernet_addr, ethaddr_str) == -1) {
155 printk(KERN_WARNING "%s badly formatted-<%s>\n",
156 ethaddr_name, ethaddr_str);
160 if (init_debug > 1) {
162 printk(KERN_DEBUG "get_ethernet_addr: for %s ", ethaddr_name);
163 for (i = 0; i < 5; i++)
164 printk(KERN_DEBUG "%02x:",
165 (unsigned char)*(ethernet_addr+i));
166 printk(KERN_DEBUG "%02x\n", *(ethernet_addr+i));
171 EXPORT_SYMBOL(get_ethernet_addr);
173 static char *get_features(void)
175 char *feature = prom_getenv(FEATURES);
177 if (feature == NULL) {
178 /* default features based on MACHINE_TYPE */
179 feature = msp_default_features;
185 static char test_feature(char c)
187 char *feature = get_features();
195 return FEATURE_NOEXIST;
198 unsigned long get_deviceid(void)
200 char *deviceid = prom_getenv(DEVICEID);
202 if (deviceid == NULL)
205 return str2hex(deviceid);
208 char identify_pci(void)
210 return test_feature(PCI_KEY);
212 EXPORT_SYMBOL(identify_pci);
214 char identify_pcimux(void)
216 return test_feature(PCIMUX_KEY);
219 char identify_sec(void)
221 return test_feature(SEC_KEY);
223 EXPORT_SYMBOL(identify_sec);
225 char identify_spad(void)
227 return test_feature(SPAD_KEY);
229 EXPORT_SYMBOL(identify_spad);
231 char identify_tdm(void)
233 return test_feature(TDM_KEY);
235 EXPORT_SYMBOL(identify_tdm);
237 char identify_zsp(void)
239 return test_feature(ZSP_KEY);
241 EXPORT_SYMBOL(identify_zsp);
243 static char identify_enetfeature(char key, unsigned long interface_num)
245 char *feature = get_features();
248 if (*feature++ == key && interface_num-- == 0)
253 return FEATURE_NOEXIST;
256 char identify_enet(unsigned long interface_num)
258 return identify_enetfeature(ENET_KEY, interface_num);
260 EXPORT_SYMBOL(identify_enet);
262 char identify_enetTxD(unsigned long interface_num)
264 return identify_enetfeature(ENETTXD_KEY, interface_num);
266 EXPORT_SYMBOL(identify_enetTxD);
268 unsigned long identify_family(void)
270 unsigned long deviceid;
272 deviceid = get_deviceid();
274 return deviceid & CPU_DEVID_FAMILY;
276 EXPORT_SYMBOL(identify_family);
278 unsigned long identify_revision(void)
280 unsigned long deviceid;
282 deviceid = get_deviceid();
284 return deviceid & CPU_DEVID_REVISION;
286 EXPORT_SYMBOL(identify_revision);
288 /* PROM environment functions */
289 char *prom_getenv(char *env_name)
292 * Return a pointer to the given environment variable. prom_envp
293 * points to a null terminated array of pointers to variables.
294 * Environment variables are stored in the form of "memsize=64"
297 char **var = prom_envp;
298 int i = strlen(env_name);
301 if (strncmp(env_name, *var, i) == 0) {
302 return *var + strlen(env_name) + 1;
310 /* PROM commandline functions */
311 void __init prom_init_cmdline(void)
316 actr = 1; /* Always ignore argv[0] */
318 cp = &(arcs_cmdline[0]);
319 while (actr < prom_argc) {
320 strcpy(cp, prom_argv[actr]);
321 cp += strlen(prom_argv[actr]);
325 if (cp != &(arcs_cmdline[0])) /* get rid of trailing space */
330 /* memory allocation functions */
331 static int __init prom_memtype_classify(unsigned int type)
337 return BOOT_MEM_ROM_DATA;
339 return BOOT_MEM_RESERVED;
343 void __init prom_meminit(void)
345 struct prom_pmemblock *p;
351 unsigned long base, size;
353 type = prom_memtype_classify(p->type);
357 add_memory_region(base, size, type);
360 if (type == BOOT_MEM_ROM_DATA) {
361 if (nr_prom_mem >= 5) {
362 pr_err("Too many ROM DATA regions");
365 prom_mem_base[nr_prom_mem] = base;
366 prom_mem_size[nr_prom_mem] = size;
372 void __init prom_free_prom_memory(void)
383 * preserve environment variables and command line from pmon/bbload
384 * first preserve the command line
386 for (argc = 0; argc < prom_argc; argc++) {
387 len += sizeof(char *); /* length of pointer */
388 len += strlen(prom_argv[argc]) + 1; /* length of string */
390 len += sizeof(char *); /* plus length of null pointer */
392 argv = kmalloc(len, GFP_KERNEL);
393 ptr = (char *) &argv[prom_argc + 1]; /* strings follow array */
395 for (argc = 0; argc < prom_argc; argc++) {
397 strcpy(ptr, prom_argv[argc]);
398 ptr += strlen(prom_argv[argc]) + 1;
400 argv[prom_argc] = NULL; /* end array with null pointer */
403 /* next preserve the environment variables */
406 for (envp = prom_envp; *envp != NULL; envp++) {
407 i++; /* count number of environment variables */
408 len += sizeof(char *); /* length of pointer */
409 len += strlen(*envp) + 1; /* length of string */
411 len += sizeof(char *); /* plus length of null pointer */
413 envp = kmalloc(len, GFP_KERNEL);
414 ptr = (char *) &envp[i+1];
416 for (argc = 0; argc < i; argc++) {
418 strcpy(ptr, prom_envp[argc]);
419 ptr += strlen(prom_envp[argc]) + 1;
421 envp[i] = NULL; /* end array with null pointer */
424 for (i = 0; i < nr_prom_mem; i++) {
425 free_init_pages("prom memory",
426 prom_mem_base[i], prom_mem_base[i] + prom_mem_size[i]);
430 struct prom_pmemblock *__init prom_getmdesc(void)
432 static char memsz_env[] __initdata = "memsize";
433 static char heaptop_env[] __initdata = "heaptop";
435 unsigned int memsize;
436 unsigned int heaptop;
439 str = prom_getenv(memsz_env);
441 ppfinit("memsize not set in boot prom, "
442 "set to default (32Mb)\n");
443 memsize = 0x02000000;
445 memsize = simple_strtol(str, NULL, 0);
448 /* if memsize is a bad size, use reasonable default */
449 memsize = 0x02000000;
452 /* convert to physical address (removing caching bits, etc) */
453 memsize = CPHYSADDR(memsize);
456 str = prom_getenv(heaptop_env);
458 heaptop = CPHYSADDR((u32)&_text);
459 ppfinit("heaptop not set in boot prom, "
460 "set to default 0x%08x\n", heaptop);
462 heaptop = simple_strtol(str, NULL, 16);
464 /* heaptop conversion bad, might have 0xValue */
465 heaptop = simple_strtol(str, NULL, 0);
468 /* heaptop still bad, use reasonable default */
469 heaptop = CPHYSADDR((u32)&_text);
473 /* convert to physical address (removing caching bits, etc) */
474 heaptop = CPHYSADDR((u32)heaptop);
477 /* the base region */
479 mdesc[i].type = BOOT_MEM_RESERVED;
480 mdesc[i].base = 0x00000000;
481 mdesc[i].size = PAGE_ALIGN(0x300 + 0x80);
482 /* jtag interrupt vector + sizeof vector */
485 if (heaptop > mdesc[i].base + mdesc[i].size) {
487 mdesc[i].type = BOOT_MEM_ROM_DATA;
488 mdesc[i].base = mdesc[i-1].base + mdesc[i-1].size;
489 mdesc[i].size = heaptop - mdesc[i].base;
492 /* end of PMON data to start of kernel -- probably zero .. */
493 if (heaptop != CPHYSADDR((u32)_text)) {
495 mdesc[i].type = BOOT_MEM_RAM;
496 mdesc[i].base = heaptop;
497 mdesc[i].size = CPHYSADDR((u32)_text) - mdesc[i].base;
502 mdesc[i].type = BOOT_MEM_RESERVED;
503 mdesc[i].base = CPHYSADDR((u32)_text);
504 mdesc[i].size = CPHYSADDR(PAGE_ALIGN((u32)_end)) - mdesc[i].base;
506 /* Remainder of RAM -- under memsize */
508 mdesc[i].type = yamon_free;
509 mdesc[i].base = mdesc[i-1].base + mdesc[i-1].size;
510 mdesc[i].size = memsize - mdesc[i].base;