1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
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
53int prom_argc;
54char **prom_argv, **prom_envp;
55int *prom_vec;
56
57
58int init_debug = 1;
59
60
61struct prom_pmemblock mdesc[PROM_MAX_PMEMBLOCKS];
62
63
64static 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
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;
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
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
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
284char *prom_getenv(char *env_name)
285{
286
287
288
289
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
306char *prom_getcmdline(void)
307{
308 return &(arcs_cmdline[0]);
309}
310EXPORT_SYMBOL(prom_getcmdline);
311
312void __init prom_init_cmdline(void)
313{
314 char *cp;
315 int actr;
316
317 actr = 1;
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]))
327 --cp;
328 *cp = '\0';
329}
330
331
332static 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
344void __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
363void __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
375
376
377 for (argc = 0; argc < prom_argc; argc++) {
378 len += sizeof(char *);
379 len += strlen(prom_argv[argc]) + 1;
380 }
381 len += sizeof(char *);
382
383 argv = kmalloc(len, GFP_KERNEL);
384 ptr = (char *) &argv[prom_argc + 1];
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;
392 prom_argv = argv;
393
394
395 len = 0;
396 i = 0;
397 for (envp = prom_envp; *envp != NULL; envp++) {
398 i++;
399 len += sizeof(char *);
400 len += strlen(*envp) + 1;
401 }
402 len += sizeof(char *);
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;
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
425struct 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
444 memsize = 0x02000000;
445 }
446
447
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
460 heaptop = simple_strtol(str, NULL, 0);
461
462 if (heaptop == 0) {
463
464 heaptop = CPHYSADDR((u32)&_text);
465 }
466 }
467
468
469 heaptop = CPHYSADDR((u32)heaptop);
470 }
471
472
473 i = 0;
474 mdesc[i].type = BOOT_MEM_RESERVED;
475 mdesc[i].base = 0x00000000;
476 mdesc[i].size = PAGE_ALIGN(0x300 + 0x80);
477
478
479
480 if (heaptop > mdesc[i].base + mdesc[i].size) {
481 i++;
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
488 if (heaptop != CPHYSADDR((u32)_text)) {
489 i++;
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
496 i++;
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
502 i++;
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}
509