Annotation of sys/arch/jornada/jornada/jornada_machdep.c, Revision 1.2
1.1 nbrk 1: /* $OpenBSD: armish_machdep.c,v 1.10 2007/05/19 15:49:05 miod Exp $ */
2: /* $NetBSD: lubbock_machdep.c,v 1.2 2003/07/15 00:25:06 lukem Exp $ */
3:
4: /*
5: * Copyright (c) 2001, 2002, 2003 Wasabi Systems, Inc.
6: * All rights reserved.
7: *
8: * Written by Jason R. Thorpe for Wasabi Systems, Inc.
9: *
10: * Redistribution and use in source and binary forms, with or without
11: * modification, are permitted provided that the following conditions
12: * are met:
13: * 1. Redistributions of source code must retain the above copyright
14: * notice, this list of conditions and the following disclaimer.
15: * 2. Redistributions in binary form must reproduce the above copyright
16: * notice, this list of conditions and the following disclaimer in the
17: * documentation and/or other materials provided with the distribution.
18: * 3. All advertising materials mentioning features or use of this software
19: * must display the following acknowledgement:
20: * This product includes software developed for the NetBSD Project by
21: * Wasabi Systems, Inc.
22: * 4. The name of Wasabi Systems, Inc. may not be used to endorse
23: * or promote products derived from this software without specific prior
24: * written permission.
25: *
26: * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
27: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
28: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL WASABI SYSTEMS, INC
30: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36: * POSSIBILITY OF SUCH DAMAGE.
37: */
38:
39: /*
40: * Copyright (c) 1997,1998 Mark Brinicombe.
41: * Copyright (c) 1997,1998 Causality Limited.
42: * All rights reserved.
43: *
44: * Redistribution and use in source and binary forms, with or without
45: * modification, are permitted provided that the following conditions
46: * are met:
47: * 1. Redistributions of source code must retain the above copyright
48: * notice, this list of conditions and the following disclaimer.
49: * 2. Redistributions in binary form must reproduce the above copyright
50: * notice, this list of conditions and the following disclaimer in the
51: * documentation and/or other materials provided with the distribution.
52: * 3. All advertising materials mentioning features or use of this software
53: * must display the following acknowledgement:
54: * This product includes software developed by Mark Brinicombe
55: * for the NetBSD Project.
56: * 4. The name of the company nor the name of the author may be used to
57: * endorse or promote products derived from this software without specific
58: * prior written permission.
59: *
60: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
61: * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
62: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
63: * IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
64: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
65: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
66: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
67: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
68: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
69: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
70: * SUCH DAMAGE.
71: *
72: * Machine dependant functions for kernel setup for Intel IQ80321 evaluation
73: * boards using RedBoot firmware.
74: */
75:
76: /*
77: * DIP switches:
78: *
79: * S19: no-dot: set RB_KDB. enter kgdb session.
80: * S20: no-dot: set RB_SINGLE. don't go multi user mode.
81: */
82:
83: #include <sys/param.h>
84: #include <sys/device.h>
85: #include <sys/systm.h>
86: #include <sys/kernel.h>
87: #include <sys/exec.h>
88: #include <sys/proc.h>
89: #include <sys/msgbuf.h>
90: #include <sys/reboot.h>
91: #include <sys/termios.h>
92: #include <sys/kcore.h>
93:
94: #include <uvm/uvm_extern.h>
95:
96: #include <sys/conf.h>
97: #include <sys/queue.h>
98: #include <sys/device.h>
99: #include <dev/cons.h>
100:
101: #include <machine/db_machdep.h>
102: #include <ddb/db_sym.h>
103: #include <ddb/db_extern.h>
104:
105: #include <machine/bootconfig.h>
106: #include <machine/bus.h>
107: #include <machine/cpu.h>
108: #include <machine/frame.h>
109: #include <arm/kcore.h>
110: #include <arm/undefined.h>
111: #include <arm/machdep.h>
112:
113: #include <arm/sa11x0/sa11x0_reg.h>
114: #include <arm/sa11x0/sa11x0_var.h>
115: #include <machine/jornada_reg.h>
116:
117: /* Kernel text starts 2MB in from the bottom of the kernel address space. */
118: #define KERNEL_TEXT_BASE (KERNEL_BASE + 0x00200000)
119: #define KERNEL_VM_BASE (KERNEL_BASE + 0x10000000)
120:
121: /*
122: * The range 0xc1000000 - 0xcfffffff is available for kernel VM space
123: * Core-logic registers and I/O mappings occupy 0xfd000000 - 0xffffffff
124: */
125: #define KERNEL_VM_SIZE 0x20000000
126:
127:
128: /*
129: * Address to call from cpu_reset() to reset the machine.
130: * This is machine architecture dependant as it varies depending
131: * on where the ROM appears when you turn the MMU off.
132: */
133:
134: u_int cpu_reset_address = 0;
135:
136: /* Define various stack sizes in pages */
137: #define IRQ_STACK_SIZE 1
138: #define ABT_STACK_SIZE 1
139: #ifdef IPKDB
140: #define UND_STACK_SIZE 2
141: #else
142: #define UND_STACK_SIZE 1
143: #endif
144:
145: BootConfig bootconfig; /* Boot config storage */
146: char *boot_args = NULL;
147: char *boot_file = NULL;
148:
149: paddr_t physical_start;
150: paddr_t physical_freestart;
151: paddr_t physical_freeend;
152: paddr_t physical_end;
153: u_int free_pages;
154: paddr_t pagetables_start;
155: int physmem = 0;
156:
157: /*int debug_flags;*/
158: #ifndef PMAP_STATIC_L1S
159: int max_processes = 64; /* Default number */
160: #endif /* !PMAP_STATIC_L1S */
161:
162: /* Physical and virtual addresses for some global pages */
163: pv_addr_t systempage;
164: pv_addr_t irqstack;
165: pv_addr_t undstack;
166: pv_addr_t abtstack;
167: extern pv_addr_t kernelstack;
168: pv_addr_t minidataclean;
169:
170: #define CPU_SA110_CACHE_CLEAN_SIZE (0x4000 * 2)
171: extern unsigned int sa1_cache_clean_addr;
172: extern unsigned int sa1_cache_clean_size;
173: static vaddr_t sa1_cc_base;
174:
175: paddr_t msgbufphys;
176:
177: extern u_int data_abort_handler_address;
178: extern u_int prefetch_abort_handler_address;
179: extern u_int undefined_handler_address;
180:
181: #ifdef PMAP_DEBUG
182: extern int pmap_debug_level;
183: #endif
184:
185: #define KERNEL_PT_SYS 0 /* L2 table for mapping zero page */
186: #define KERNEL_PT_KERNEL 1 /* L2 table for mapping kernel */
187: #define KERNEL_PT_KERNEL_NUM 8
188: /* L2 table for mapping peripherals */
189: #define KERNEL_PT_IO (KERNEL_PT_KERNEL + KERNEL_PT_KERNEL_NUM)
190: /* L2 tables for mapping kernel VM */
191: #define KERNEL_PT_VMDATA (KERNEL_PT_IO + 1)
192: #define KERNEL_PT_VMDATA_NUM 4 /* start with 16MB of KVM */
193: #define NUM_KERNEL_PTS (KERNEL_PT_VMDATA + KERNEL_PT_VMDATA_NUM)
194:
195: pv_addr_t kernel_pt_table[NUM_KERNEL_PTS];
196:
197: extern struct user *proc0paddr;
198:
199: /* Prototypes */
200:
201: #define BOOT_STRING_MAGIC 0x4f425344
202:
203: char bootargs[MAX_BOOT_STRING];
204: void process_kernel_args(char *);
205:
206: void consinit(void);
207: void fakecninit(bus_addr_t paddr);
208:
209: #ifdef BOOTCONSOLE_COM
210: int sacomcnattach(bus_space_tag_t bust, bus_addr_t busa, int speed);
211: void sacomfakecnattach(bus_addr_t addr);
212: #else /* !BOOTCONSOLE_COM */
213: #include <arch/jornada/dev/jfbreg.h>
214: void jfbfakecnattach(bus_addr_t addr);
215: int jfbcnattach(bus_space_tag_t bust, bus_addr_t busa);
216: #endif /* BOOTCONSOLE_COM */
217:
218: #ifndef CONSPEED
219: #define CONSPEED 115200
220: #endif
221:
222: int comcnspeed = CONSPEED;
223:
224:
225: /*
226: * void boot(int howto, char *bootstr)
227: *
228: * Reboots the system
229: *
230: * Deal with any syncing, unmounting, dumping and shutdown hooks,
231: * then reset the CPU.
232: */
233: void board_reset(void);
234: void board_powerdown(void);
235: void
236: boot(int howto)
237: {
238: /*
239: * If we are still cold then hit the air brakes
240: * and crash to earth fast
241: */
242: if (cold) {
243: doshutdownhooks();
244: if ((howto & (RB_HALT | RB_USERREQ)) != RB_USERREQ) {
245: printf("The operating system has halted.\n");
246: printf("Please press any key to reboot.\n\n");
247: cngetc();
248: }
249: #ifndef DO_NOT_RESET_SA1
250: printf("rebooting...\n");
251: delay(60000);
252: cpu_reset();
253: printf("reboot failed; spinning\n");
254: #else /* DO_NOT_RESET_SA1 */
255: printf("will not reset CPU; spinning\n");
256: #endif /* !DO_NOT_RESET_SA1 */
257: while(1);
258: /*NOTREACHED*/
259: }
260:
261: /* Disable console buffering */
262: /* cnpollc(1);*/
263:
264: /*
265: * If RB_NOSYNC was not specified sync the discs.
266: * Note: Unless cold is set to 1 here, syslogd will die during the
267: * unmount. It looks like syslogd is getting woken up only to find
268: * that it cannot page part of the binary in as the filesystem has
269: * been unmounted.
270: */
271: if (!(howto & RB_NOSYNC))
272: bootsync(howto);
273:
274: /* Say NO to interrupts */
275: splhigh();
276:
277: /* Do a dump if requested. */
278: if ((howto & (RB_DUMP | RB_HALT)) == RB_DUMP)
279: dumpsys();
280:
281: /* Run any shutdown hooks */
282: doshutdownhooks();
283:
284: /* Make sure IRQ's are disabled */
285: IRQdisable;
286:
287: if (howto & RB_HALT) {
288: if (howto & RB_POWERDOWN) {
289: /* TODO */
290: //board_powerdown();
291: printf("WARNING: powerdown failed!\n");
292: }
293:
294: printf("The operating system has halted.\n");
295: printf("Please press any key to reboot.\n\n");
296: cngetc();
297: }
298:
299: #ifndef DO_NOT_RESET_SA1
300: printf("rebooting...\n");
301:
302: /* TODO board_reset */
303: cpu_reset();
304: printf("reboot failed; spinning\n");
305: #else /* DO_NOT_RESET_SA1 */
306: printf("will not reset CPU; spinning\n");
307: #endif /* !DO_NOT_RESET_SA1 */
308: while(1)
309: ;
310: /*NOTREACHED*/
311: }
312:
313: /*
314: * Mapping table for core kernel memory. These areas are mapped in
315: * init time at fixed virtual address with section mappings.
316: */
317: const struct pmap_devmap jornada_devmap[] = {
318: /*
319: * Map the on-board devices VA == PA so that we can access them
320: * with the MMU on or off.
321: */
322: {
323: SACOM3_BASE,
324: SACOM3_HW_BASE,
325: 0x24 /* SACOM3_SIZE, */,
326: VM_PROT_READ|VM_PROT_WRITE,
327: PTE_NOCACHE,
328: },
329: {
330: SAIPIC_VBASE,
331: SAIPIC_BASE,
332: 0x24 /* SAIPIC_SIZE, */,
333: VM_PROT_READ|VM_PROT_WRITE,
334: PTE_NOCACHE,
335: },
336: #ifndef BOOTCONSOLE_COM
337: {
338: JFB_VBASE,
339: JFB_BASE,
340: JFB_SIZE,
341: VM_PROT_READ|VM_PROT_WRITE,
342: PTE_NOCACHE,
343: },
344: #endif /* !BOOTCONSOLE_COM */
345: {0, 0, 0, 0, 0}
346: };
347:
348:
349: /*
350: * u_int initarm(...)
351: *
352: * Initial entry point on startup. This gets called before main() is
353: * entered.
354: * It should be responsible for setting up everything that must be
355: * in place when main is called.
356: * This includes
357: * Taking a copy of the boot configuration structure.
358: * Initialising the physical console so characters can be printed.
359: * Setting up page tables for the kernel
360: * Relocating the kernel to the bottom of physical memory
361: */
362: u_int
363: initarm(void *arg)
364: {
365: extern cpu_kcore_hdr_t cpu_kcore_hdr;
366: int loop;
367: int loop1;
368: u_int l1pagetable;
369: pv_addr_t kernel_l1pt;
370: paddr_t memstart;
371: psize_t memsize;
372: extern u_int32_t esym; /* &_end if no symbols are loaded */
373:
374: /* get ready for splfoo() */
375: sa11x0_intr_bootstrap(SAIPIC_BASE);
376:
377: pmap_devmap_register(jornada_devmap);
378:
379: /* setup a serial console for very early boot */
380: #ifdef BOOTCONSOLE_COM
381: fakecninit(SACOM3_HW_BASE);
382: #else
383: fakecninit(JFB_BASE);
384: #endif
385:
386: /*
387: * Heads up ... Setup the CPU / MMU / TLB functions
388: */
389: if (set_cpufuncs())
390: panic("cpu not recognized!");
391:
392: /*
393: * Examine the boot args string for options we need to know about
394: * now.
395: */
396: /* XXX should really be done after setting up the console, but we
397: * XXX need to parse the console selection flags right now. */
398: process_kernel_args((char *)0xc0200000 - MAX_BOOT_STRING - 1);
399: #ifdef RAMDISK_HOOKS
400: boothowto |= RB_DFLTROOT;
401: #endif /* RAMDISK_HOOKS */
402:
403: /* Talk to the user */
404: printf("\nOpenBSD/jornada booting ...\n");
405:
406: #define VERBOSE_INIT_ARM
407:
408: /* Ugly hardcode DRAM bounds */
409: /* TODO */
410: memstart = (paddr_t)0xc0000000;
1.2 ! nbrk 411: memsize = (psize_t)(32 * 1024 * 1024);
1.1 nbrk 412:
413: //#define DEBUG
414: #ifdef DEBUG
415: printf("initarm: Configuring system ...\n");
416: #endif
417:
418: /* Fake bootconfig structure for the benefit of pmap.c */
419: /* XXX must make the memory description h/w independant */
420: bootconfig.dramblocks = 1;
421: bootconfig.dram[0].address = memstart;
422: bootconfig.dram[0].pages = memsize / PAGE_SIZE;
423:
424: /*
425: * Set up the variables that define the availablilty of
426: * physical memory. For now, we're going to set
427: * physical_freestart to 0xc0200000 (where the kernel
428: * was loaded), and allocate the memory we need downwards.
429: * We will update physical_freestart and physical_freeend
430: * later to reflect what pmap_bootstrap() wants to see.
431: *
432: * XXX pmap_bootstrap() needs an enema.
433: */
434: physical_start = bootconfig.dram[0].address;
435: physical_end = physical_start + (bootconfig.dram[0].pages * PAGE_SIZE);
436:
437: physical_freestart = 0xc0200000UL;
438: physical_freeend = physical_end;
439:
440: physmem = (physical_end - physical_start) / PAGE_SIZE;
441:
442: #if defined(DEBUG) || defined(VERBOSE_INIT_ARM)
443: /* Tell the user about the memory */
444: printf("physmemory: %d pages at 0x%08lx -> 0x%08lx\n", physmem,
445: physical_start, physical_end - 1);
446: #endif
447:
448: /*
449: * Okay, the kernel starts 2MB in from the bottom of physical
450: * memory. We are going to allocate our bootstrap pages downwards
451: * from there.
452: *
453: * We need to allocate some fixed page tables to get the kernel
454: * going. We allocate one page directory and a number of page
455: * tables and store the physical addresses in the kernel_pt_table
456: * array.
457: *
458: * The kernel page directory must be on a 16K boundary. The page
459: * tables must be on 4K boundaries. What we do is allocate the
460: * page directory on the first 16K boundary that we encounter, and
461: * the page tables on 4K boundaries otherwise. Since we allocate
462: * at least 3 L2 page tables, we are guaranteed to encounter at
463: * least one 16K aligned region.
464: */
465:
466: #ifdef VERBOSE_INIT_ARM
467: printf("Allocating page tables\n");
468: #endif
469:
470: free_pages = (physical_freeend - physical_freestart) / PAGE_SIZE;
471:
472: #ifdef VERBOSE_INIT_ARM
473: printf("freestart = 0x%08lx, free_pages = %d (0x%08x)\n",
474: physical_freestart, free_pages, free_pages);
475: #endif
476:
477: /* Define a macro to simplify memory allocation */
478: #define valloc_pages(var, np) \
479: alloc_pages((var).pv_pa, (np)); \
480: (var).pv_va = KERNEL_BASE + (var).pv_pa - physical_start;
481:
482: #define alloc_pages(var, np) \
483: physical_freeend -= ((np) * PAGE_SIZE); \
484: if (physical_freeend < physical_freestart) \
485: panic("initarm: out of memory"); \
486: (var) = physical_freeend; \
487: free_pages -= (np); \
488: memset((char *)(var), 0, ((np) * PAGE_SIZE));
489:
490: loop1 = 0;
491: kernel_l1pt.pv_pa = 0;
492: for (loop = 0; loop <= NUM_KERNEL_PTS; ++loop) {
493: /* Are we 16KB aligned for an L1 ? */
494: if (((physical_freeend - L1_TABLE_SIZE) & (L1_TABLE_SIZE - 1)) == 0
495: && kernel_l1pt.pv_pa == 0) {
496: valloc_pages(kernel_l1pt, L1_TABLE_SIZE / PAGE_SIZE);
497: } else {
498: valloc_pages(kernel_pt_table[loop1],
499: L2_TABLE_SIZE / PAGE_SIZE);
500: ++loop1;
501: }
502: }
503:
504: /* This should never be able to happen but better confirm that. */
505: if (!kernel_l1pt.pv_pa || (kernel_l1pt.pv_pa & (L1_TABLE_SIZE-1)) != 0)
506: panic("initarm: Failed to align the kernel page directory");
507:
508: /*
509: * Allocate a page for the system page mapped to V0x00000000
510: * This page will just contain the system vectors and can be
511: * shared by all processes.
512: */
513: alloc_pages(systempage.pv_pa, 1);
514:
515: /* Allocate stacks for all modes */
516: valloc_pages(irqstack, IRQ_STACK_SIZE);
517: valloc_pages(abtstack, ABT_STACK_SIZE);
518: valloc_pages(undstack, UND_STACK_SIZE);
519: valloc_pages(kernelstack, UPAGES);
520:
521: #ifdef VERBOSE_INIT_ARM
522: printf("IRQ stack: p0x%08lx v0x%08lx\n", irqstack.pv_pa,
523: irqstack.pv_va);
524: printf("ABT stack: p0x%08lx v0x%08lx\n", abtstack.pv_pa,
525: abtstack.pv_va);
526: printf("UND stack: p0x%08lx v0x%08lx\n", undstack.pv_pa,
527: undstack.pv_va);
528: printf("SVC stack: p0x%08lx v0x%08lx\n", kernelstack.pv_pa,
529: kernelstack.pv_va);
530: #endif
531:
532: /*
533: * XXX Defer this to later so that we can reclaim the memory
534: * XXX used by the RedBoot page tables.
535: */
536: alloc_pages(msgbufphys, round_page(MSGBUFSIZE) / PAGE_SIZE);
537:
538: /*
539: * XXX Actually, we only need virtual space and don't need
540: * XXX physical memory for sa110_cc_base and sa11x0_idle_mem.
541: */
542: /*
543: * XXX totally stuffed hack to work round problems introduced
544: * in recent versions of the pmap code. Due to the calls used there
545: * we cannot allocate virtual memory during bootstrap.
546: */
547: for (;;) {
548: alloc_pages(sa1_cc_base, 1);
549: if (!(sa1_cc_base & (CPU_SA110_CACHE_CLEAN_SIZE - 1)))
550: break;
551: }
552: {
553: vaddr_t dummy;
554: alloc_pages(dummy, CPU_SA110_CACHE_CLEAN_SIZE / PAGE_SIZE - 1);
555: }
556: sa1_cache_clean_addr = sa1_cc_base;
557: sa1_cache_clean_size = CPU_SA110_CACHE_CLEAN_SIZE / 2;
558:
559:
560: /*
561: * Ok we have allocated physical pages for the primary kernel
562: * page tables
563: */
564:
565: #ifdef VERBOSE_INIT_ARM
566: printf("Creating L1 page table at 0x%08lx\n", kernel_l1pt.pv_pa);
567: #endif
568:
569: /*
570: * Now we start construction of the L1 page table
571: * We start by mapping the L2 page tables into the L1.
572: * This means that we can replace L1 mappings later on if necessary
573: */
574: l1pagetable = kernel_l1pt.pv_pa;
575:
576: #ifdef HIGH_VECT
577: /* Map the L2 pages tables in the L1 page table */
578: pmap_link_l2pt(l1pagetable, ARM_VECTORS_HIGH & ~(0x00400000 - 1),
579: &kernel_pt_table[KERNEL_PT_SYS]);
580: #else
581: /* Map the L2 pages tables in the L1 page table */
582: pmap_link_l2pt(l1pagetable, 0x00000000,
583: &kernel_pt_table[KERNEL_PT_SYS]);
584: #endif
585: for (loop = 0; loop < KERNEL_PT_KERNEL_NUM; loop++)
586: pmap_link_l2pt(l1pagetable, KERNEL_BASE + loop * 0x00400000,
587: &kernel_pt_table[KERNEL_PT_KERNEL + loop]);
588:
589: for (loop = 0; loop < KERNEL_PT_VMDATA_NUM; loop++)
590: pmap_link_l2pt(l1pagetable, KERNEL_VM_BASE + loop * 0x00400000,
591: &kernel_pt_table[KERNEL_PT_VMDATA + loop]);
592:
593: /* link devices */
594: pmap_link_l2pt(l1pagetable, 0xfd000000/* XXX XXX */,
595: &kernel_pt_table[KERNEL_PT_IO]);
596:
597: /* update the top of the kernel VM */
598: pmap_curmaxkvaddr =
599: KERNEL_VM_BASE + (KERNEL_PT_VMDATA_NUM * 0x00400000);
600:
601: #ifdef VERBOSE_INIT_ARM
602: printf("Mapping kernel\n");
603: #endif
604:
605: /* Now we fill in the L2 pagetable for the kernel static code/data
606: * and the symbol table. */
607: {
608: extern char etext[];
609: #ifdef VERBOSE_INIT_ARM
610: extern char _end[];
611: #endif
612: size_t textsize = (u_int32_t) etext - KERNEL_TEXT_BASE;
613: size_t totalsize = esym - KERNEL_TEXT_BASE;
614: u_int logical;
615:
616: #ifdef VERBOSE_INIT_ARM
617: printf("kernelsize text %x total %x end %x esym %x\n",
618: textsize, totalsize, _end, esym);
619: #endif
620:
621: textsize = round_page(textsize);
622: totalsize = round_page(totalsize);
623:
624: logical = 0x00200000; /* offset of kernel in RAM */
625:
626: /* Update dump information */
627: cpu_kcore_hdr.kernelbase = KERNEL_BASE;
628: cpu_kcore_hdr.kerneloffs = logical;
629: cpu_kcore_hdr.staticsize = totalsize;
630:
631: logical += pmap_map_chunk(l1pagetable, KERNEL_BASE + logical,
632: physical_start + logical, textsize,
633: VM_PROT_READ|VM_PROT_WRITE, PTE_CACHE);
634: pmap_map_chunk(l1pagetable, KERNEL_BASE + logical,
635: physical_start + logical, totalsize - textsize,
636: VM_PROT_READ|VM_PROT_WRITE, PTE_CACHE);
637: }
638:
639: #ifdef VERBOSE_INIT_ARM
640: printf("Constructing L2 page tables\n");
641: #endif
642:
643: /* Map the stack pages */
644: pmap_map_chunk(l1pagetable, irqstack.pv_va, irqstack.pv_pa,
645: IRQ_STACK_SIZE * PAGE_SIZE, VM_PROT_READ|VM_PROT_WRITE, PTE_CACHE);
646: pmap_map_chunk(l1pagetable, abtstack.pv_va, abtstack.pv_pa,
647: ABT_STACK_SIZE * PAGE_SIZE, VM_PROT_READ|VM_PROT_WRITE, PTE_CACHE);
648: pmap_map_chunk(l1pagetable, undstack.pv_va, undstack.pv_pa,
649: UND_STACK_SIZE * PAGE_SIZE, VM_PROT_READ|VM_PROT_WRITE, PTE_CACHE);
650: pmap_map_chunk(l1pagetable, kernelstack.pv_va, kernelstack.pv_pa,
651: UPAGES * PAGE_SIZE, VM_PROT_READ | VM_PROT_WRITE, PTE_CACHE);
652:
653: pmap_map_chunk(l1pagetable, kernel_l1pt.pv_va, kernel_l1pt.pv_pa,
654: L1_TABLE_SIZE, VM_PROT_READ | VM_PROT_WRITE, PTE_PAGETABLE);
655:
656: for (loop = 0; loop < NUM_KERNEL_PTS; ++loop) {
657: pmap_map_chunk(l1pagetable, kernel_pt_table[loop].pv_va,
658: kernel_pt_table[loop].pv_pa, L2_TABLE_SIZE,
659: VM_PROT_READ|VM_PROT_WRITE, PTE_PAGETABLE);
660: }
661:
662: pmap_map_chunk(l1pagetable, sa1_cache_clean_addr, 0xe0000000,
663: CPU_SA110_CACHE_CLEAN_SIZE, VM_PROT_READ|VM_PROT_WRITE, PTE_CACHE);
664:
665: /* Map the vector page. */
666: #ifdef HIGH_VECT
667: pmap_map_entry(l1pagetable, ARM_VECTORS_HIGH, systempage.pv_pa,
668: VM_PROT_READ|VM_PROT_WRITE, PTE_CACHE);
669: #else
670: pmap_map_entry(l1pagetable, vector_page, systempage.pv_pa,
671: VM_PROT_READ|VM_PROT_WRITE, PTE_CACHE);
672: #endif
673:
674: /* XXX XXX */
675: pmap_devmap_bootstrap(l1pagetable, jornada_devmap);
676:
677: /*
678: * Now we have the real page tables in place so we can switch to them.
679: * Once this is done we will be running with the REAL kernel page
680: * tables.
681: */
682:
683: /*
684: * Update the physical_freestart/physical_freeend/free_pages
685: * variables.
686: */
687: {
688: physical_freestart = physical_start - KERNEL_BASE +
689: round_page(esym);
690: physical_freeend = physical_end;
691: free_pages =
692: (physical_freeend - physical_freestart) / PAGE_SIZE;
693: }
694: #ifdef VERBOSE_INIT_ARM
695: printf("physical_freestart %x end %x\n", physical_freestart,
696: physical_freeend);
697: #endif
698:
699: /* be a client to all domains */
700: cpu_domains(0x55555555);
701: /* Switch tables */
702: #ifdef VERBOSE_INIT_ARM
703: printf("freestart = 0x%08lx, free_pages = %d (0x%x)\n",
704: physical_freestart, free_pages, free_pages);
705: printf("switching to new L1 page table @%#lx...", kernel_l1pt.pv_pa);
706: #endif
707:
708: /* set new intc register address so that splfoo() doesn't
709: touch illegal address. */
710: sa11x0_intr_bootstrap(SAIPIC_VBASE);
711:
712: cpu_domains((DOMAIN_CLIENT << (PMAP_DOMAIN_KERNEL*2)) | DOMAIN_CLIENT);
713: setttb(kernel_l1pt.pv_pa);
714: cpu_tlb_flushID();
715: cpu_domains(DOMAIN_CLIENT << (PMAP_DOMAIN_KERNEL*2));
716:
717: /* update with our virtual address */
718: #ifdef BOOTCONSOLE_COM
719: fakecninit(SACOM3_BASE);
720: #else
721: fakecninit(JFB_VBASE);
722: #endif /* BOOTCONSOLE_COM */
723: /*
724: * Moved from cpu_startup() as data_abort_handler() references
725: * this during uvm init
726: */
727: proc0paddr = (struct user *)kernelstack.pv_va;
728: proc0.p_addr = proc0paddr;
729:
730: #ifdef VERBOSE_INIT_ARM
731: printf("bootstrap done.\n");
732: #endif
733:
734: #ifdef HIGH_VECT
735: arm32_vector_init(ARM_VECTORS_HIGH, ARM_VEC_ALL);
736: #else
737: arm32_vector_init(ARM_VECTORS_LOW, ARM_VEC_ALL);
738: #endif
739:
740: /*
741: * Pages were allocated during the secondary bootstrap for the
742: * stacks for different CPU modes.
743: * We must now set the r13 registers in the different CPU modes to
744: * point to these stacks.
745: * Since the ARM stacks use STMFD etc. we must set r13 to the top end
746: * of the stack memory.
747: */
748: #ifdef VERBOSE_INIT_ARM
749: printf("init subsystems: stacks ");
750: #endif
751:
752: set_stackptr(PSR_IRQ32_MODE,
753: irqstack.pv_va + IRQ_STACK_SIZE * PAGE_SIZE);
754: set_stackptr(PSR_ABT32_MODE,
755: abtstack.pv_va + ABT_STACK_SIZE * PAGE_SIZE);
756: set_stackptr(PSR_UND32_MODE,
757: undstack.pv_va + UND_STACK_SIZE * PAGE_SIZE);
758:
759: /*
760: * Well we should set a data abort handler.
761: * Once things get going this will change as we will need a proper
762: * handler.
763: * Until then we will use a handler that just panics but tells us
764: * why.
765: * Initialisation of the vectors will just panic on a data abort.
766: * This just fills in a slightly better one.
767: */
768: #ifdef VERBOSE_INIT_ARM
769: printf("vectors ");
770: #endif
771: data_abort_handler_address = (u_int)data_abort_handler;
772: prefetch_abort_handler_address = (u_int)prefetch_abort_handler;
773: undefined_handler_address = (u_int)undefinedinstruction_bounce;
774:
775: /* Initialise the undefined instruction handlers */
776: #ifdef VERBOSE_INIT_ARM
777: printf("undefined ");
778: #endif
779: undefined_init();
780:
781: /* Load memory into UVM. */
782: #ifdef VERBOSE_INIT_ARM
783: printf("page ");
784: #endif
785: uvm_setpagesize(); /* initialize PAGE_SIZE-dependent variables */
786: uvm_page_physload(atop(physical_freestart), atop(physical_freeend),
787: atop(physical_freestart), atop(physical_freeend),
788: VM_FREELIST_DEFAULT);
789:
790: /* Boot strap pmap telling it where the kernel page table is */
791: #ifdef VERBOSE_INIT_ARM
792: printf("pmap ");
793: #endif
794: pmap_bootstrap((pd_entry_t *)kernel_l1pt.pv_va, KERNEL_VM_BASE,
795: KERNEL_VM_BASE + KERNEL_VM_SIZE);
796:
797: /* Update dump information */
798: cpu_kcore_hdr.pmap_kernel_l1 = (u_int32_t)pmap_kernel()->pm_l1;
799: cpu_kcore_hdr.pmap_kernel_l2 = (u_int32_t)&(pmap_kernel()->pm_l2);
800:
801: /* Setup the IRQ system */
802: #ifdef VERBOSE_INIT_ARM
803: printf("irq ");
804: #endif
805: sa11x0_init_interrupt_masks();
806:
807: #ifdef VERBOSE_INIT_ARM
808: printf("done.\n");
809: #endif
810:
811: #ifdef DDB
812: db_machine_init();
813:
814: /* Firmware doesn't load symbols. */
815: ddb_init();
816:
817: if (boothowto & RB_KDB)
818: Debugger();
819: #endif
820:
821: /* We return the new stack pointer address */
822: return(kernelstack.pv_va + USPACE_SVC_STACK_TOP);
823: }
824:
825: void
826: process_kernel_args(char *args)
827: {
828: char *cp = args;
829:
830: if (cp == NULL || *(int *)cp != BOOT_STRING_MAGIC) {
831: boothowto = RB_AUTOBOOT;
832: return;
833: }
834:
835: /* Eat the cookie */
836: *(int *)cp = 0;
837: cp += sizeof(int);
838:
839: boothowto = 0;
840:
841: /* Make a local copy of the bootargs */
842: strncpy(bootargs, cp, MAX_BOOT_STRING - sizeof(int));
843:
844: cp = bootargs;
845: boot_file = bootargs;
846:
847: /* Skip the kernel image filename */
848: while (*cp != ' ' && *cp != 0)
849: ++cp;
850:
851: if (*cp != 0)
852: *cp++ = 0;
853:
854: while (*cp == ' ')
855: ++cp;
856:
857: boot_args = cp;
858:
859: #if 0
860: printf("bootfile: %s\n", boot_file);
861: printf("bootargs: %s\n", boot_args);
862: #endif
863:
864: /* Setup pointer to boot flags */
865: while (*cp != '-')
866: if (*cp++ == '\0')
867: return;
868:
869: for (;*++cp;) {
870: int fl;
871:
872: fl = 0;
873: switch(*cp) {
874: case 'a':
875: fl |= RB_ASKNAME;
876: break;
877: case 'c':
878: fl |= RB_CONFIG;
879: break;
880: case 'd':
881: fl |= RB_KDB;
882: break;
883: case 's':
884: fl |= RB_SINGLE;
885: break;
886: default:
887: printf("unknown option `%c'\n", *cp);
888: break;
889: }
890: boothowto |= fl;
891: }
892: }
893:
894:
895: void
896: consinit(void)
897: {
898: /* XXX defer console attachment to autoconf */
899: return;
900: }
901:
902: void
903: fakecninit(bus_addr_t addr)
904: {
905: /*
906: * Early console initialization.
907: * XXX cn_getc stuff
908: */
909: switch(addr) {
910: #ifdef BOOTCONSOLE_COM
911: case SACOM3_HW_BASE:
912: case SACOM3_BASE:
913: sacomfakecnattach(addr);
914: break;
915: #else
916: case JFB_BASE:
917: case JFB_VBASE:
918: jfbfakecnattach(addr);
919: break;
920: #endif /* BOOTCONSOLE_COM */
921: default:
922: panic("serial console not configured");
923: }
924: }
925:
926: void
927: board_startup(void)
928: {
929: if (boothowto & RB_CONFIG) {
930: #ifdef BOOT_CONFIG
931: user_config();
932: #else
933: printf("kernel does not support -c; continuing..\n");
934: #endif
935: }
936: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to jornada_machdep.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / jornada / jornada