Linux 2.6.31-rc6
[linux-2.6] / arch / mips / pmc-sierra / 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/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
44 #include <asm/addrspace.h>
45 #include <asm/bootinfo.h>
46 #include <asm-generic/sections.h>
47 #include <asm/page.h>
48
49 #include <msp_prom.h>
50 #include <msp_regs.h>
51
52 /* global PROM environment variables and pointers */
53 int prom_argc;
54 char **prom_argv, **prom_envp;
55 int *prom_vec;
56
57 /* debug flag */
58 int init_debug = 1;
59
60 /* memory blocks */
61 struct prom_pmemblock mdesc[PROM_MAX_PMEMBLOCKS];
62
63 /* default feature sets */
64 static char msp_default_features[] =
65 #if defined(CONFIG_PMC_MSP4200_EVAL) \
66  || 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 */
76 static 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
85 static 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 }
107 EXPORT_SYMBOL(str2eaddr);
108
109 static 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 */
122 const 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
139 int 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 }
166 EXPORT_SYMBOL(get_ethernet_addr);
167
168 static 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
180 static 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
193 unsigned 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
203 char identify_pci(void)
204 {
205         return test_feature(PCI_KEY);
206 }
207 EXPORT_SYMBOL(identify_pci);
208
209 char identify_pcimux(void)
210 {
211         return test_feature(PCIMUX_KEY);
212 }
213
214 char identify_sec(void)
215 {
216         return test_feature(SEC_KEY);
217 }
218 EXPORT_SYMBOL(identify_sec);
219
220 char identify_spad(void)
221 {
222         return test_feature(SPAD_KEY);
223 }
224 EXPORT_SYMBOL(identify_spad);
225
226 char identify_tdm(void)
227 {
228         return test_feature(TDM_KEY);
229 }
230 EXPORT_SYMBOL(identify_tdm);
231
232 char identify_zsp(void)
233 {
234         return test_feature(ZSP_KEY);
235 }
236 EXPORT_SYMBOL(identify_zsp);
237
238 static 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
251 char identify_enet(unsigned long interface_num)
252 {
253         return identify_enetfeature(ENET_KEY, interface_num);
254 }
255 EXPORT_SYMBOL(identify_enet);
256
257 char identify_enetTxD(unsigned long interface_num)
258 {
259         return identify_enetfeature(ENETTXD_KEY, interface_num);
260 }
261 EXPORT_SYMBOL(identify_enetTxD);
262
263 unsigned long identify_family(void)
264 {
265         unsigned long deviceid;
266
267         deviceid = get_deviceid();
268
269         return deviceid & CPU_DEVID_FAMILY;
270 }
271 EXPORT_SYMBOL(identify_family);
272
273 unsigned long identify_revision(void)
274 {
275         unsigned long deviceid;
276
277         deviceid = get_deviceid();
278
279         return deviceid & CPU_DEVID_REVISION;
280 }
281 EXPORT_SYMBOL(identify_revision);
282
283 /* PROM environment functions */
284 char *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 */
306 char *prom_getcmdline(void)
307 {
308         return &(arcs_cmdline[0]);
309 }
310 EXPORT_SYMBOL(prom_getcmdline);
311
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++;
360         }
361 }
362
363 void __init prom_free_prom_memory(void)
364 {
365         int     argc;
366         char    **argv;
367         char    **envp;
368         char    *ptr;
369         int     len = 0;
370         int     i;
371         unsigned long addr;
372
373         /*
374          * preserve environment variables and command line from pmon/bbload
375          * first preserve the command line
376          */
377         for (argc = 0; argc < prom_argc; argc++) {
378                 len += sizeof(char *);                  /* length of pointer */
379                 len += strlen(prom_argv[argc]) + 1;     /* length of string */
380         }
381         len += sizeof(char *);          /* plus length of null pointer */
382
383         argv = kmalloc(len, GFP_KERNEL);
384         ptr = (char *) &argv[prom_argc + 1];    /* strings follow array */
385
386         for (argc = 0; argc < prom_argc; argc++) {
387                 argv[argc] = ptr;
388                 strcpy(ptr, prom_argv[argc]);
389                 ptr += strlen(prom_argv[argc]) + 1;
390         }
391         argv[prom_argc] = NULL;         /* end array with null pointer */
392         prom_argv = argv;
393
394         /* next preserve the environment variables */
395         len = 0;
396         i = 0;
397         for (envp = prom_envp; *envp != NULL; envp++) {
398                 i++;            /* count number of environment variables */
399                 len += sizeof(char *);          /* length of pointer */
400                 len += strlen(*envp) + 1;       /* length of string */
401         }
402         len += sizeof(char *);          /* plus length of null pointer */
403
404         envp = kmalloc(len, GFP_KERNEL);
405         ptr = (char *) &envp[i+1];
406
407         for (argc = 0; argc < i; argc++) {
408                 envp[argc] = ptr;
409                 strcpy(ptr, prom_envp[argc]);
410                 ptr += strlen(prom_envp[argc]) + 1;
411         }
412         envp[i] = NULL;                 /* end array with null pointer */
413         prom_envp = envp;
414
415         for (i = 0; i < boot_mem_map.nr_map; i++) {
416                 if (boot_mem_map.map[i].type != BOOT_MEM_ROM_DATA)
417                         continue;
418
419                 addr = boot_mem_map.map[i].addr;
420                 free_init_pages("prom memory",
421                                 addr, addr + boot_mem_map.map[i].size);
422         }
423 }
424
425 struct prom_pmemblock *__init prom_getmdesc(void)
426 {
427         static char     memsz_env[] __initdata = "memsize";
428         static char     heaptop_env[] __initdata = "heaptop";
429         char            *str;
430         unsigned int    memsize;
431         unsigned int    heaptop;
432         int i;
433
434         str = prom_getenv(memsz_env);
435         if (!str) {
436                 ppfinit("memsize not set in boot prom, "
437                         "set to default (32Mb)\n");
438                 memsize = 0x02000000;
439         } else {
440                 memsize = simple_strtol(str, NULL, 0);
441
442                 if (memsize == 0) {
443                         /* if memsize is a bad size, use reasonable default */
444                         memsize = 0x02000000;
445                 }
446
447                 /* convert to physical address (removing caching bits, etc) */
448                 memsize = CPHYSADDR(memsize);
449         }
450
451         str = prom_getenv(heaptop_env);
452         if (!str) {
453                 heaptop = CPHYSADDR((u32)&_text);
454                 ppfinit("heaptop not set in boot prom, "
455                         "set to default 0x%08x\n", heaptop);
456         } else {
457                 heaptop = simple_strtol(str, NULL, 16);
458                 if (heaptop == 0) {
459                         /* heaptop conversion bad, might have 0xValue */
460                         heaptop = simple_strtol(str, NULL, 0);
461
462                         if (heaptop == 0) {
463                                 /* heaptop still bad, use reasonable default */
464                                 heaptop = CPHYSADDR((u32)&_text);
465                         }
466                 }
467
468                 /* convert to physical address (removing caching bits, etc) */
469                 heaptop = CPHYSADDR((u32)heaptop);
470         }
471
472         /* the base region */
473         i = 0;
474         mdesc[i].type = BOOT_MEM_RESERVED;
475         mdesc[i].base = 0x00000000;
476         mdesc[i].size = PAGE_ALIGN(0x300 + 0x80);
477                 /* jtag interrupt vector + sizeof vector */
478
479         /* PMON data */
480         if (heaptop > mdesc[i].base + mdesc[i].size) {
481                 i++;                    /* 1 */
482                 mdesc[i].type = BOOT_MEM_ROM_DATA;
483                 mdesc[i].base = mdesc[i-1].base + mdesc[i-1].size;
484                 mdesc[i].size = heaptop - mdesc[i].base;
485         }
486
487         /* end of PMON data to start of kernel -- probably zero .. */
488         if (heaptop != CPHYSADDR((u32)_text)) {
489                 i++;    /* 2 */
490                 mdesc[i].type = BOOT_MEM_RAM;
491                 mdesc[i].base = heaptop;
492                 mdesc[i].size = CPHYSADDR((u32)_text) - mdesc[i].base;
493         }
494
495         /*  kernel proper */
496         i++;                    /* 3 */
497         mdesc[i].type = BOOT_MEM_RESERVED;
498         mdesc[i].base = CPHYSADDR((u32)_text);
499         mdesc[i].size = CPHYSADDR(PAGE_ALIGN((u32)_end)) - mdesc[i].base;
500
501         /* Remainder of RAM -- under memsize */
502         i++;                    /* 5 */
503         mdesc[i].type = yamon_free;
504         mdesc[i].base = mdesc[i-1].base + mdesc[i-1].size;
505         mdesc[i].size = memsize - mdesc[i].base;
506
507         return &mdesc[0];
508 }