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 37#include <linux/module.h> 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> 43#include <linux/slab.h> 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 */ 54int prom_argc; 55char **prom_argv, **prom_envp; 56int *prom_vec; 57 58/* debug flag */ 59int init_debug = 1; 60 61/* memory blocks */ 62struct prom_pmemblock mdesc[PROM_MAX_PMEMBLOCKS]; 63 64/* default feature sets */ 65static char msp_default_features[] = 66#if defined(CONFIG_PMC_MSP4200_EVAL) || defined(CONFIG_PMC_MSP4200_GW) 67 "ERER"; 68#elif defined(CONFIG_PMC_MSP7120_EVAL) \ 69 || defined(CONFIG_PMC_MSP7120_GW) 70 "EMEMSP"; 71#elif defined(CONFIG_PMC_MSP7120_FPGA) 72 "EMEM"; 73#endif 74 75/* conversion functions */ 76static inline unsigned char str2hexnum(unsigned char c) 77{ 78 if (c >= '0' && c <= '9') 79 return c - '0'; 80 if (c >= 'a' && c <= 'f') 81 return c - 'a' + 10; 82 return 0; /* foo */ 83} 84 85static inline int str2eaddr(unsigned char *ea, unsigned char *str) 86{ 87 int index = 0; 88 unsigned char num = 0; 89 90 while (*str != '\0') { 91 if ((*str == '.') || (*str == ':')) { 92 ea[index++] = num; 93 num = 0; 94 str++; 95 } else { 96 num = num << 4; 97 num |= str2hexnum(*str++); 98 } 99 } 100 101 if (index == 5) { 102 ea[index++] = num; 103 return 0; 104 } else 105 return -1; 106} 107EXPORT_SYMBOL(str2eaddr); 108 109static inline unsigned long str2hex(unsigned char *str) 110{ 111 int value = 0; 112 113 while (*str) { 114 value = value << 4; 115 value |= str2hexnum(*str++); 116 } 117 118 return value; 119} 120 121/* function to query the system information */ 122const char *get_system_type(void) 123{ 124#if defined(CONFIG_PMC_MSP4200_EVAL) 125 return "PMC-Sierra MSP4200 Eval Board"; 126#elif defined(CONFIG_PMC_MSP4200_GW) 127 return "PMC-Sierra MSP4200 VoIP Gateway"; 128#elif defined(CONFIG_PMC_MSP7120_EVAL) 129 return "PMC-Sierra MSP7120 Eval Board"; 130#elif defined(CONFIG_PMC_MSP7120_GW) 131 return "PMC-Sierra MSP7120 Residential Gateway"; 132#elif defined(CONFIG_PMC_MSP7120_FPGA) 133 return "PMC-Sierra MSP7120 FPGA"; 134#else 135 #error "What is the type of *your* MSP?" 136#endif 137} 138 139int get_ethernet_addr(char *ethaddr_name, char *ethernet_addr) 140{ 141 char *ethaddr_str; 142 143 ethaddr_str = prom_getenv(ethaddr_name); 144 if (!ethaddr_str) { 145 printk(KERN_WARNING "%s not set in boot prom\n", ethaddr_name); 146 return -1; 147 } 148 149 if (str2eaddr(ethernet_addr, ethaddr_str) == -1) { 150 printk(KERN_WARNING "%s badly formatted-<%s>\n", 151 ethaddr_name, ethaddr_str); 152 return -1; 153 } 154 155 if (init_debug > 1) { 156 int i; 157 printk(KERN_DEBUG "get_ethernet_addr: for %s ", ethaddr_name); 158 for (i = 0; i < 5; i++) 159 printk(KERN_DEBUG "%02x:", 160 (unsigned char)*(ethernet_addr+i)); 161 printk(KERN_DEBUG "%02x\n", *(ethernet_addr+i)); 162 } 163 164 return 0; 165} 166EXPORT_SYMBOL(get_ethernet_addr); 167 168static char *get_features(void) 169{ 170 char *feature = prom_getenv(FEATURES); 171 172 if (feature == NULL) { 173 /* default features based on MACHINE_TYPE */ 174 feature = msp_default_features; 175 } 176 177 return feature; 178} 179 180static char test_feature(char c) 181{ 182 char *feature = get_features(); 183 184 while (*feature) { 185 if (*feature++ == c) 186 return *feature; 187 feature++; 188 } 189 190 return FEATURE_NOEXIST; 191} 192 193unsigned long get_deviceid(void) 194{ 195 char *deviceid = prom_getenv(DEVICEID); 196 197 if (deviceid == NULL) 198 return *DEV_ID_REG; 199 else 200 return str2hex(deviceid); 201} 202 203char identify_pci(void) 204{ 205 return test_feature(PCI_KEY); 206} 207EXPORT_SYMBOL(identify_pci); 208 209char identify_pcimux(void) 210{ 211 return test_feature(PCIMUX_KEY); 212} 213 214char identify_sec(void) 215{ 216 return test_feature(SEC_KEY); 217} 218EXPORT_SYMBOL(identify_sec); 219 220char identify_spad(void) 221{ 222 return test_feature(SPAD_KEY); 223} 224EXPORT_SYMBOL(identify_spad); 225 226char identify_tdm(void) 227{ 228 return test_feature(TDM_KEY); 229} 230EXPORT_SYMBOL(identify_tdm); 231 232char identify_zsp(void) 233{ 234 return test_feature(ZSP_KEY); 235} 236EXPORT_SYMBOL(identify_zsp); 237 238static char identify_enetfeature(char key, unsigned long interface_num) 239{ 240 char *feature = get_features(); 241 242 while (*feature) { 243 if (*feature++ == key && interface_num-- == 0) 244 return *feature; 245 feature++; 246 } 247 248 return FEATURE_NOEXIST; 249} 250 251char identify_enet(unsigned long interface_num) 252{ 253 return identify_enetfeature(ENET_KEY, interface_num); 254} 255EXPORT_SYMBOL(identify_enet); 256 257char identify_enetTxD(unsigned long interface_num) 258{ 259 return identify_enetfeature(ENETTXD_KEY, interface_num); 260} 261EXPORT_SYMBOL(identify_enetTxD); 262 263unsigned long identify_family(void) 264{ 265 unsigned long deviceid; 266 267 deviceid = get_deviceid(); 268 269 return deviceid & CPU_DEVID_FAMILY; 270} 271EXPORT_SYMBOL(identify_family); 272 273unsigned long identify_revision(void) 274{ 275 unsigned long deviceid; 276 277 deviceid = get_deviceid(); 278 279 return deviceid & CPU_DEVID_REVISION; 280} 281EXPORT_SYMBOL(identify_revision); 282 283/* PROM environment functions */ 284char *prom_getenv(char *env_name) 285{ 286 /* 287 * Return a pointer to the given environment variable. prom_envp 288 * points to a null terminated array of pointers to variables. 289 * Environment variables are stored in the form of "memsize=64" 290 */ 291 292 char **var = prom_envp; 293 int i = strlen(env_name); 294 295 while (*var) { 296 if (strncmp(env_name, *var, i) == 0) { 297 return (*var + strlen(env_name) + 1); 298 } 299 var++; 300 } 301 302 return NULL; 303} 304 305/* PROM commandline functions */ 306void __init prom_init_cmdline(void) 307{ 308 char *cp; 309 int actr; 310 311 actr = 1; /* Always ignore argv[0] */ 312 313 cp = &(arcs_cmdline[0]); 314 while (actr < prom_argc) { 315 strcpy(cp, prom_argv[actr]); 316 cp += strlen(prom_argv[actr]); 317 *cp++ = ' '; 318 actr++; 319 } 320 if (cp != &(arcs_cmdline[0])) /* get rid of trailing space */ 321 --cp; 322 *cp = '\0'; 323} 324 325/* memory allocation functions */ 326static int __init prom_memtype_classify(unsigned int type) 327{ 328 switch (type) { 329 case yamon_free: 330 return BOOT_MEM_RAM; 331 case yamon_prom: 332 return BOOT_MEM_ROM_DATA; 333 default: 334 return BOOT_MEM_RESERVED; 335 } 336} 337 338void __init prom_meminit(void) 339{ 340 struct prom_pmemblock *p; 341 342 p = prom_getmdesc(); 343 344 while (p->size) { 345 long type; 346 unsigned long base, size; 347 348 type = prom_memtype_classify(p->type); 349 base = p->base; 350 size = p->size; 351 352 add_memory_region(base, size, type); 353 p++; 354 } 355} 356 357void __init prom_free_prom_memory(void) 358{ 359 int argc; 360 char **argv; 361 char **envp; 362 char *ptr; 363 int len = 0; 364 int i; 365 unsigned long addr; 366 367 /* 368 * preserve environment variables and command line from pmon/bbload 369 * first preserve the command line 370 */ 371 for (argc = 0; argc < prom_argc; argc++) { 372 len += sizeof(char *); /* length of pointer */ 373 len += strlen(prom_argv[argc]) + 1; /* length of string */ 374 } 375 len += sizeof(char *); /* plus length of null pointer */ 376 377 argv = kmalloc(len, GFP_KERNEL); 378 ptr = (char *) &argv[prom_argc + 1]; /* strings follow array */ 379 380 for (argc = 0; argc < prom_argc; argc++) { 381 argv[argc] = ptr; 382 strcpy(ptr, prom_argv[argc]); 383 ptr += strlen(prom_argv[argc]) + 1; 384 } 385 argv[prom_argc] = NULL; /* end array with null pointer */ 386 prom_argv = argv; 387 388 /* next preserve the environment variables */ 389 len = 0; 390 i = 0; 391 for (envp = prom_envp; *envp != NULL; envp++) { 392 i++; /* count number of environment variables */ 393 len += sizeof(char *); /* length of pointer */ 394 len += strlen(*envp) + 1; /* length of string */ 395 } 396 len += sizeof(char *); /* plus length of null pointer */ 397 398 envp = kmalloc(len, GFP_KERNEL); 399 ptr = (char *) &envp[i+1]; 400 401 for (argc = 0; argc < i; argc++) { 402 envp[argc] = ptr; 403 strcpy(ptr, prom_envp[argc]); 404 ptr += strlen(prom_envp[argc]) + 1; 405 } 406 envp[i] = NULL; /* end array with null pointer */ 407 prom_envp = envp; 408 409 for (i = 0; i < boot_mem_map.nr_map; i++) { 410 if (boot_mem_map.map[i].type != BOOT_MEM_ROM_DATA) 411 continue; 412 413 addr = boot_mem_map.map[i].addr; 414 free_init_pages("prom memory", 415 addr, addr + boot_mem_map.map[i].size); 416 } 417} 418 419struct prom_pmemblock *__init prom_getmdesc(void) 420{ 421 static char memsz_env[] __initdata = "memsize"; 422 static char heaptop_env[] __initdata = "heaptop"; 423 char *str; 424 unsigned int memsize; 425 unsigned int heaptop; 426 int i; 427 428 str = prom_getenv(memsz_env); 429 if (!str) { 430 ppfinit("memsize not set in boot prom, " 431 "set to default (32Mb)\n"); 432 memsize = 0x02000000; 433 } else { 434 memsize = simple_strtol(str, NULL, 0); 435 436 if (memsize == 0) { 437 /* if memsize is a bad size, use reasonable default */ 438 memsize = 0x02000000; 439 } 440 441 /* convert to physical address (removing caching bits, etc) */ 442 memsize = CPHYSADDR(memsize); 443 } 444 445 str = prom_getenv(heaptop_env); 446 if (!str) { 447 heaptop = CPHYSADDR((u32)&_text); 448 ppfinit("heaptop not set in boot prom, " 449 "set to default 0x%08x\n", heaptop); 450 } else { 451 heaptop = simple_strtol(str, NULL, 16); 452 if (heaptop == 0) { 453 /* heaptop conversion bad, might have 0xValue */ 454 heaptop = simple_strtol(str, NULL, 0); 455 456 if (heaptop == 0) { 457 /* heaptop still bad, use reasonable default */ 458 heaptop = CPHYSADDR((u32)&_text); 459 } 460 } 461 462 /* convert to physical address (removing caching bits, etc) */ 463 heaptop = CPHYSADDR((u32)heaptop); 464 } 465 466 /* the base region */ 467 i = 0; 468 mdesc[i].type = BOOT_MEM_RESERVED; 469 mdesc[i].base = 0x00000000; 470 mdesc[i].size = PAGE_ALIGN(0x300 + 0x80); 471 /* jtag interrupt vector + sizeof vector */ 472 473 /* PMON data */ 474 if (heaptop > mdesc[i].base + mdesc[i].size) { 475 i++; /* 1 */ 476 mdesc[i].type = BOOT_MEM_ROM_DATA; 477 mdesc[i].base = mdesc[i-1].base + mdesc[i-1].size; 478 mdesc[i].size = heaptop - mdesc[i].base; 479 } 480 481 /* end of PMON data to start of kernel -- probably zero .. */ 482 if (heaptop != CPHYSADDR((u32)_text)) { 483 i++; /* 2 */ 484 mdesc[i].type = BOOT_MEM_RAM; 485 mdesc[i].base = heaptop; 486 mdesc[i].size = CPHYSADDR((u32)_text) - mdesc[i].base; 487 } 488 489 /* kernel proper */ 490 i++; /* 3 */ 491 mdesc[i].type = BOOT_MEM_RESERVED; 492 mdesc[i].base = CPHYSADDR((u32)_text); 493 mdesc[i].size = CPHYSADDR(PAGE_ALIGN((u32)_end)) - mdesc[i].base; 494 495 /* Remainder of RAM -- under memsize */ 496 i++; /* 5 */ 497 mdesc[i].type = yamon_free; 498 mdesc[i].base = mdesc[i-1].base + mdesc[i-1].size; 499 mdesc[i].size = memsize - mdesc[i].base; 500 501 return &mdesc[0]; 502} 503