arch/mips/pmcs-msp71xx/msp_prom.c

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