~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/mips/pmcs-msp71xx/msp_prom.c

Version: ~ [ linux-5.17-rc1 ] ~ [ linux-5.16.2 ] ~ [ linux-5.15.16 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.93 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.173 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.225 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.262 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.297 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.299 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp