Annotation of sys/arch/armish/armish/armish_machdep.c, Revision 1.1
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: #include <dev/ic/smc91cxxreg.h>
! 101:
! 102: #include <machine/db_machdep.h>
! 103: #include <ddb/db_sym.h>
! 104: #include <ddb/db_extern.h>
! 105:
! 106: #include <machine/bootconfig.h>
! 107: #include <machine/bus.h>
! 108: #include <machine/cpu.h>
! 109: #include <machine/frame.h>
! 110: #include <arm/kcore.h>
! 111: #include <arm/undefined.h>
! 112: #include <arm/machdep.h>
! 113:
! 114: #include <arm/xscale/i80321reg.h>
! 115: #include <arm/xscale/i80321var.h>
! 116:
! 117: #include <armish/dev/iq80321reg.h>
! 118: #include <armish/dev/iq80321var.h>
! 119: #include <armish/dev/obiovar.h>
! 120:
! 121:
! 122:
! 123: /* Kernel text starts 2MB in from the bottom of the kernel address space. */
! 124: #define KERNEL_TEXT_BASE (KERNEL_BASE + 0x00200000)
! 125: #define KERNEL_VM_BASE (KERNEL_BASE + 0x10000000)
! 126:
! 127: /*
! 128: * The range 0xc1000000 - 0xcfffffff is available for kernel VM space
! 129: * Core-logic registers and I/O mappings occupy 0xfd000000 - 0xffffffff
! 130: */
! 131: #define KERNEL_VM_SIZE 0x20000000
! 132:
! 133:
! 134: /*
! 135: * Address to call from cpu_reset() to reset the machine.
! 136: * This is machine architecture dependant as it varies depending
! 137: * on where the ROM appears when you turn the MMU off.
! 138: */
! 139:
! 140: u_int cpu_reset_address = 0;
! 141:
! 142: /* Define various stack sizes in pages */
! 143: #define IRQ_STACK_SIZE 1
! 144: #define ABT_STACK_SIZE 1
! 145: #ifdef IPKDB
! 146: #define UND_STACK_SIZE 2
! 147: #else
! 148: #define UND_STACK_SIZE 1
! 149: #endif
! 150:
! 151: BootConfig bootconfig; /* Boot config storage */
! 152: char *boot_args = NULL;
! 153: char *boot_file = NULL;
! 154:
! 155: paddr_t physical_start;
! 156: paddr_t physical_freestart;
! 157: paddr_t physical_freeend;
! 158: paddr_t physical_end;
! 159: u_int free_pages;
! 160: paddr_t pagetables_start;
! 161: int physmem = 0;
! 162:
! 163: /*int debug_flags;*/
! 164: #ifndef PMAP_STATIC_L1S
! 165: int max_processes = 64; /* Default number */
! 166: #endif /* !PMAP_STATIC_L1S */
! 167:
! 168: /* Physical and virtual addresses for some global pages */
! 169: pv_addr_t systempage;
! 170: pv_addr_t irqstack;
! 171: pv_addr_t undstack;
! 172: pv_addr_t abtstack;
! 173: extern pv_addr_t kernelstack;
! 174: pv_addr_t minidataclean;
! 175:
! 176: paddr_t msgbufphys;
! 177:
! 178: extern u_int data_abort_handler_address;
! 179: extern u_int prefetch_abort_handler_address;
! 180: extern u_int undefined_handler_address;
! 181:
! 182: #ifdef PMAP_DEBUG
! 183: extern int pmap_debug_level;
! 184: #endif
! 185:
! 186: #define KERNEL_PT_SYS 0 /* L2 table for mapping zero page */
! 187:
! 188: #define KERNEL_PT_KERNEL 1 /* L2 table for mapping kernel */
! 189: #define KERNEL_PT_KERNEL_NUM 32
! 190:
! 191: /* L2 table for mapping i80312 */
! 192: //#define KERNEL_PT_IOPXS (KERNEL_PT_KERNEL + KERNEL_PT_KERNEL_NUM)
! 193:
! 194: /* L2 tables for mapping kernel VM */
! 195: //#define KERNEL_PT_VMDATA (KERNEL_PT_IOPXS + 1)
! 196: #define KERNEL_PT_VMDATA (KERNEL_PT_KERNEL + KERNEL_PT_KERNEL_NUM)
! 197: #define KERNEL_PT_VMDATA_NUM 8 /* start with 16MB of KVM */
! 198: #define NUM_KERNEL_PTS (KERNEL_PT_VMDATA + KERNEL_PT_VMDATA_NUM)
! 199:
! 200: pv_addr_t kernel_pt_table[NUM_KERNEL_PTS];
! 201:
! 202: extern struct user *proc0paddr;
! 203:
! 204: /* Prototypes */
! 205:
! 206: #define BOOT_STRING_MAGIC 0x4f425344
! 207:
! 208: char bootargs[MAX_BOOT_STRING];
! 209: void process_kernel_args(char *);
! 210:
! 211: void consinit(void);
! 212:
! 213: #include "com.h"
! 214: #if NCOM > 0
! 215: #include <dev/ic/comreg.h>
! 216: #include <dev/ic/comvar.h>
! 217: #endif
! 218:
! 219: #ifndef CONSPEED
! 220: #define CONSPEED B115200 /* What RedBoot uses */
! 221: #endif
! 222: #ifndef CONMODE
! 223: #define CONMODE ((TTYDEF_CFLAG & ~(CSIZE | CSTOPB | PARENB)) | CS8 | CLOCAL) /* 8N1 */
! 224: #endif
! 225:
! 226: int comcnspeed = CONSPEED;
! 227: int comcnmode = CONMODE;
! 228:
! 229:
! 230: /*
! 231: * void boot(int howto, char *bootstr)
! 232: *
! 233: * Reboots the system
! 234: *
! 235: * Deal with any syncing, unmounting, dumping and shutdown hooks,
! 236: * then reset the CPU.
! 237: */
! 238: void board_reset(void);
! 239: void board_powerdown(void);
! 240: void
! 241: boot(int howto)
! 242: {
! 243: /*
! 244: * If we are still cold then hit the air brakes
! 245: * and crash to earth fast
! 246: */
! 247: if (cold) {
! 248: doshutdownhooks();
! 249: if ((howto & (RB_HALT | RB_USERREQ)) != RB_USERREQ) {
! 250: printf("The operating system has halted.\n");
! 251: printf("Please press any key to reboot.\n\n");
! 252: cngetc();
! 253: }
! 254: printf("rebooting...\n");
! 255: delay(60000);
! 256: cpu_reset();
! 257: printf("reboot failed; spinning\n");
! 258: while(1);
! 259: /*NOTREACHED*/
! 260: }
! 261:
! 262: /* Disable console buffering */
! 263: /* cnpollc(1);*/
! 264:
! 265: /*
! 266: * If RB_NOSYNC was not specified sync the discs.
! 267: * Note: Unless cold is set to 1 here, syslogd will die during the
! 268: * unmount. It looks like syslogd is getting woken up only to find
! 269: * that it cannot page part of the binary in as the filesystem has
! 270: * been unmounted.
! 271: */
! 272: if (!(howto & RB_NOSYNC))
! 273: bootsync(howto);
! 274:
! 275: /* Say NO to interrupts */
! 276: splhigh();
! 277:
! 278: /* Do a dump if requested. */
! 279: if ((howto & (RB_DUMP | RB_HALT)) == RB_DUMP)
! 280: dumpsys();
! 281:
! 282: /* Run any shutdown hooks */
! 283: doshutdownhooks();
! 284:
! 285: /* Make sure IRQ's are disabled */
! 286: IRQdisable;
! 287:
! 288: if (howto & RB_HALT) {
! 289: if (howto & RB_POWERDOWN) {
! 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: printf("rebooting...\n");
! 300:
! 301: board_reset();
! 302: cpu_reset();
! 303: printf("reboot failed; spinning\n");
! 304: while(1);
! 305: /*NOTREACHED*/
! 306: }
! 307:
! 308: /*
! 309: * Mapping table for core kernel memory. These areas are mapped in
! 310: * init time at fixed virtual address with section mappings.
! 311: */
! 312: const struct pmap_devmap iq80321_devmap[] = {
! 313: /*
! 314: * Map the on-board devices VA == PA so that we can access them
! 315: * with the MMU on or off.
! 316: */
! 317: {
! 318: IQ80321_OBIO_BASE,
! 319: IQ80321_OBIO_BASE,
! 320: 0x00100000 /* IQ80321_OBIO_SIZE, */,
! 321: VM_PROT_READ|VM_PROT_WRITE,
! 322: PTE_NOCACHE,
! 323: },
! 324: {0, 0, 0, 0, 0}
! 325: };
! 326:
! 327:
! 328: /*
! 329: * u_int initarm(...)
! 330: *
! 331: * Initial entry point on startup. This gets called before main() is
! 332: * entered.
! 333: * It should be responsible for setting up everything that must be
! 334: * in place when main is called.
! 335: * This includes
! 336: * Taking a copy of the boot configuration structure.
! 337: * Initialising the physical console so characters can be printed.
! 338: * Setting up page tables for the kernel
! 339: * Relocating the kernel to the bottom of physical memory
! 340: */
! 341: u_int
! 342: initarm(void *arg)
! 343: {
! 344: extern vaddr_t xscale_cache_clean_addr;
! 345: extern cpu_kcore_hdr_t cpu_kcore_hdr;
! 346: int loop;
! 347: int loop1;
! 348: u_int l1pagetable;
! 349: pv_addr_t kernel_l1pt;
! 350: paddr_t memstart;
! 351: psize_t memsize;
! 352: extern u_int32_t esym; /* &_end if no symbols are loaded */
! 353:
! 354: #ifdef DIAGNOSTIC
! 355: extern vsize_t xscale_minidata_clean_size; /* used in KASSERT */
! 356: #endif
! 357:
! 358: /* setup a serial console for very early boot */
! 359: consinit();
! 360:
! 361: /*
! 362: * Heads up ... Setup the CPU / MMU / TLB functions
! 363: */
! 364: if (set_cpufuncs())
! 365: panic("cpu not recognized!");
! 366:
! 367: /*
! 368: * Examine the boot args string for options we need to know about
! 369: * now.
! 370: */
! 371: /* XXX should really be done after setting up the console, but we
! 372: * XXX need to parse the console selection flags right now. */
! 373: process_kernel_args((char *)0xa0200000 - MAX_BOOT_STRING - 1);
! 374: #ifdef RAMDISK_HOOKS
! 375: boothowto |= RB_DFLTROOT;
! 376: #endif /* RAMDISK_HOOKS */
! 377:
! 378:
! 379: /* Calibrate the delay loop. */
! 380: #if 1
! 381: i80321_calibrate_delay();
! 382: #endif
! 383:
! 384: /* Talk to the user */
! 385: printf("\nOpenBSD/armish booting ...\n");
! 386:
! 387: /*
! 388: * Reset the secondary PCI bus. RedBoot doesn't stop devices
! 389: * on the PCI bus before handing us control, so we have to
! 390: * do this.
! 391: *
! 392: * XXX This is arguably a bug in RedBoot, and doing this reset
! 393: * XXX could be problematic in the future if we encounter an
! 394: * XXX application where the PPB in the i80312 is used as a
! 395: * XXX PPB.
! 396: */
! 397: //#define VERBOSE_INIT_ARM
! 398:
! 399: /*
! 400: * Fetch the SDRAM start/size from the i80312 SDRAM configuration
! 401: * registers.
! 402: */
! 403: i80321_sdram_bounds(&obio_bs_tag, VERDE_PMMR_BASE + VERDE_MCU_BASE,
! 404: &memstart, &memsize);
! 405:
! 406: #define DEBUG
! 407: #ifdef DEBUG
! 408: printf("initarm: Configuring system ...\n");
! 409: #endif
! 410:
! 411: /* Fake bootconfig structure for the benefit of pmap.c */
! 412: /* XXX must make the memory description h/w independant */
! 413: bootconfig.dramblocks = 1;
! 414: bootconfig.dram[0].address = memstart;
! 415: bootconfig.dram[0].pages = memsize / PAGE_SIZE;
! 416:
! 417: /*
! 418: * Set up the variables that define the availablilty of
! 419: * physical memory. For now, we're going to set
! 420: * physical_freestart to 0xa0200000 (where the kernel
! 421: * was loaded), and allocate the memory we need downwards.
! 422: * If we get too close to the page tables that RedBoot
! 423: * set up, we will panic. We will update physical_freestart
! 424: * and physical_freeend later to reflect what pmap_bootstrap()
! 425: * wants to see.
! 426: *
! 427: * XXX pmap_bootstrap() needs an enema.
! 428: */
! 429: physical_start = bootconfig.dram[0].address;
! 430: physical_end = physical_start + (bootconfig.dram[0].pages * PAGE_SIZE);
! 431:
! 432: physical_freestart = 0xa0009000UL;
! 433: physical_freeend = 0xa0200000UL;
! 434:
! 435: physmem = (physical_end - physical_start) / PAGE_SIZE;
! 436:
! 437: #ifdef DEBUG
! 438: /* Tell the user about the memory */
! 439: printf("physmemory: %d pages at 0x%08lx -> 0x%08lx\n", physmem,
! 440: physical_start, physical_end - 1);
! 441: #endif
! 442:
! 443: /*
! 444: * Okay, the kernel starts 2MB in from the bottom of physical
! 445: * memory. We are going to allocate our bootstrap pages downwards
! 446: * from there.
! 447: *
! 448: * We need to allocate some fixed page tables to get the kernel
! 449: * going. We allocate one page directory and a number of page
! 450: * tables and store the physical addresses in the kernel_pt_table
! 451: * array.
! 452: *
! 453: * The kernel page directory must be on a 16K boundary. The page
! 454: * tables must be on 4K boundaries. What we do is allocate the
! 455: * page directory on the first 16K boundary that we encounter, and
! 456: * the page tables on 4K boundaries otherwise. Since we allocate
! 457: * at least 3 L2 page tables, we are guaranteed to encounter at
! 458: * least one 16K aligned region.
! 459: */
! 460:
! 461: #ifdef VERBOSE_INIT_ARM
! 462: printf("Allocating page tables\n");
! 463: #endif
! 464:
! 465: free_pages = (physical_freeend - physical_freestart) / PAGE_SIZE;
! 466:
! 467: #ifdef VERBOSE_INIT_ARM
! 468: printf("freestart = 0x%08lx, free_pages = %d (0x%08x)\n",
! 469: physical_freestart, free_pages, free_pages);
! 470: #endif
! 471:
! 472: /* Define a macro to simplify memory allocation */
! 473: #define valloc_pages(var, np) \
! 474: alloc_pages((var).pv_pa, (np)); \
! 475: (var).pv_va = KERNEL_BASE + (var).pv_pa - physical_start;
! 476:
! 477: #define alloc_pages(var, np) \
! 478: physical_freeend -= ((np) * PAGE_SIZE); \
! 479: if (physical_freeend < physical_freestart) \
! 480: panic("initarm: out of memory"); \
! 481: (var) = physical_freeend; \
! 482: free_pages -= (np); \
! 483: memset((char *)(var), 0, ((np) * PAGE_SIZE));
! 484:
! 485: loop1 = 0;
! 486: kernel_l1pt.pv_pa = 0;
! 487: for (loop = 0; loop <= NUM_KERNEL_PTS; ++loop) {
! 488: /* Are we 16KB aligned for an L1 ? */
! 489: if (((physical_freeend - L1_TABLE_SIZE) & (L1_TABLE_SIZE - 1)) == 0
! 490: && kernel_l1pt.pv_pa == 0) {
! 491: valloc_pages(kernel_l1pt, L1_TABLE_SIZE / PAGE_SIZE);
! 492: } else {
! 493: valloc_pages(kernel_pt_table[loop1],
! 494: L2_TABLE_SIZE / PAGE_SIZE);
! 495: ++loop1;
! 496: }
! 497: }
! 498:
! 499: /* This should never be able to happen but better confirm that. */
! 500: if (!kernel_l1pt.pv_pa || (kernel_l1pt.pv_pa & (L1_TABLE_SIZE-1)) != 0)
! 501: panic("initarm: Failed to align the kernel page directory");
! 502:
! 503: /*
! 504: * Allocate a page for the system page mapped to V0x00000000
! 505: * This page will just contain the system vectors and can be
! 506: * shared by all processes.
! 507: */
! 508: alloc_pages(systempage.pv_pa, 1);
! 509:
! 510: /* Allocate stacks for all modes */
! 511: valloc_pages(irqstack, IRQ_STACK_SIZE);
! 512: valloc_pages(abtstack, ABT_STACK_SIZE);
! 513: valloc_pages(undstack, UND_STACK_SIZE);
! 514: valloc_pages(kernelstack, UPAGES);
! 515:
! 516: /* Allocate enough pages for cleaning the Mini-Data cache. */
! 517: KASSERT(xscale_minidata_clean_size <= PAGE_SIZE);
! 518: valloc_pages(minidataclean, 1);
! 519:
! 520: #ifdef VERBOSE_INIT_ARM
! 521: printf("IRQ stack: p0x%08lx v0x%08lx\n", irqstack.pv_pa,
! 522: irqstack.pv_va);
! 523: printf("ABT stack: p0x%08lx v0x%08lx\n", abtstack.pv_pa,
! 524: abtstack.pv_va);
! 525: printf("UND stack: p0x%08lx v0x%08lx\n", undstack.pv_pa,
! 526: undstack.pv_va);
! 527: printf("SVC stack: p0x%08lx v0x%08lx\n", kernelstack.pv_pa,
! 528: kernelstack.pv_va);
! 529: #endif
! 530:
! 531: /*
! 532: * XXX Defer this to later so that we can reclaim the memory
! 533: * XXX used by the RedBoot page tables.
! 534: */
! 535: alloc_pages(msgbufphys, round_page(MSGBUFSIZE) / PAGE_SIZE);
! 536:
! 537: /*
! 538: * Ok we have allocated physical pages for the primary kernel
! 539: * page tables
! 540: */
! 541:
! 542: #ifdef VERBOSE_INIT_ARM
! 543: printf("Creating L1 page table at 0x%08lx\n", kernel_l1pt.pv_pa);
! 544: #endif
! 545:
! 546: /*
! 547: * Now we start construction of the L1 page table
! 548: * We start by mapping the L2 page tables into the L1.
! 549: * This means that we can replace L1 mappings later on if necessary
! 550: */
! 551: l1pagetable = kernel_l1pt.pv_pa;
! 552:
! 553: #ifdef HIGH_VECT
! 554: /* Map the L2 pages tables in the L1 page table */
! 555: pmap_link_l2pt(l1pagetable, ARM_VECTORS_HIGH & ~(0x00400000 - 1),
! 556: &kernel_pt_table[KERNEL_PT_SYS]);
! 557: #else
! 558: /* Map the L2 pages tables in the L1 page table */
! 559: pmap_link_l2pt(l1pagetable, 0x00000000,
! 560: &kernel_pt_table[KERNEL_PT_SYS]);
! 561: #endif
! 562: for (loop = 0; loop < KERNEL_PT_KERNEL_NUM; loop++)
! 563: pmap_link_l2pt(l1pagetable, KERNEL_BASE + loop * 0x00400000,
! 564: &kernel_pt_table[KERNEL_PT_KERNEL + loop]);
! 565: for (loop = 0; loop < KERNEL_PT_VMDATA_NUM; loop++)
! 566: pmap_link_l2pt(l1pagetable, KERNEL_VM_BASE + loop * 0x00400000,
! 567: &kernel_pt_table[KERNEL_PT_VMDATA + loop]);
! 568: #if 0
! 569: pmap_link_l2pt(l1pagetable, IQ80321_IOPXS_VBASE,
! 570: &kernel_pt_table[KERNEL_PT_IOPXS]);
! 571: #endif
! 572:
! 573: /* update the top of the kernel VM */
! 574: pmap_curmaxkvaddr =
! 575: KERNEL_VM_BASE + (KERNEL_PT_VMDATA_NUM * 0x00400000);
! 576:
! 577: #ifdef VERBOSE_INIT_ARM
! 578: printf("Mapping kernel\n");
! 579: #endif
! 580:
! 581: /* Now we fill in the L2 pagetable for the kernel static code/data
! 582: * and the symbol table. */
! 583: {
! 584: extern char etext[];
! 585: #ifdef VERBOSE_INIT_ARM
! 586: extern char _end[];
! 587: #endif
! 588: size_t textsize = (u_int32_t) etext - KERNEL_TEXT_BASE;
! 589: size_t totalsize = esym - KERNEL_TEXT_BASE;
! 590: u_int logical;
! 591:
! 592: #ifdef VERBOSE_INIT_ARM
! 593: printf("kernelsize text %x total %x end %xesym %x\n",
! 594: textsize, totalsize, _end, esym);
! 595: #endif
! 596:
! 597: textsize = round_page(textsize);
! 598: totalsize = round_page(totalsize);
! 599:
! 600: logical = 0x00200000; /* offset of kernel in RAM */
! 601:
! 602: /* Update dump information */
! 603: cpu_kcore_hdr.kernelbase = KERNEL_BASE;
! 604: cpu_kcore_hdr.kerneloffs = logical;
! 605: cpu_kcore_hdr.staticsize = totalsize;
! 606:
! 607: logical += pmap_map_chunk(l1pagetable, KERNEL_BASE + logical,
! 608: physical_start + logical, textsize,
! 609: VM_PROT_READ|VM_PROT_WRITE, PTE_CACHE);
! 610: pmap_map_chunk(l1pagetable, KERNEL_BASE + logical,
! 611: physical_start + logical, totalsize - textsize,
! 612: VM_PROT_READ|VM_PROT_WRITE, PTE_CACHE);
! 613: }
! 614:
! 615: #ifdef VERBOSE_INIT_ARM
! 616: printf("Constructing L2 page tables\n");
! 617: #endif
! 618:
! 619: /* Map the stack pages */
! 620: pmap_map_chunk(l1pagetable, irqstack.pv_va, irqstack.pv_pa,
! 621: IRQ_STACK_SIZE * PAGE_SIZE, VM_PROT_READ|VM_PROT_WRITE, PTE_CACHE);
! 622: pmap_map_chunk(l1pagetable, abtstack.pv_va, abtstack.pv_pa,
! 623: ABT_STACK_SIZE * PAGE_SIZE, VM_PROT_READ|VM_PROT_WRITE, PTE_CACHE);
! 624: pmap_map_chunk(l1pagetable, undstack.pv_va, undstack.pv_pa,
! 625: UND_STACK_SIZE * PAGE_SIZE, VM_PROT_READ|VM_PROT_WRITE, PTE_CACHE);
! 626: pmap_map_chunk(l1pagetable, kernelstack.pv_va, kernelstack.pv_pa,
! 627: UPAGES * PAGE_SIZE, VM_PROT_READ | VM_PROT_WRITE, PTE_CACHE);
! 628:
! 629: pmap_map_chunk(l1pagetable, kernel_l1pt.pv_va, kernel_l1pt.pv_pa,
! 630: L1_TABLE_SIZE, VM_PROT_READ | VM_PROT_WRITE, PTE_PAGETABLE);
! 631:
! 632: for (loop = 0; loop < NUM_KERNEL_PTS; ++loop) {
! 633: pmap_map_chunk(l1pagetable, kernel_pt_table[loop].pv_va,
! 634: kernel_pt_table[loop].pv_pa, L2_TABLE_SIZE,
! 635: VM_PROT_READ|VM_PROT_WRITE, PTE_PAGETABLE);
! 636: }
! 637:
! 638: /* Map the Mini-Data cache clean area. */
! 639: xscale_setup_minidata(l1pagetable, minidataclean.pv_va,
! 640: minidataclean.pv_pa);
! 641:
! 642: /* Map the vector page. */
! 643: #ifdef HIGH_VECT
! 644: pmap_map_entry(l1pagetable, ARM_VECTORS_HIGH, systempage.pv_pa,
! 645: VM_PROT_READ|VM_PROT_WRITE, PTE_CACHE);
! 646: #else
! 647: pmap_map_entry(l1pagetable, vector_page, systempage.pv_pa,
! 648: VM_PROT_READ|VM_PROT_WRITE, PTE_CACHE);
! 649: #endif
! 650:
! 651: pmap_devmap_bootstrap(l1pagetable, iq80321_devmap);
! 652:
! 653: /*
! 654: * Give the XScale global cache clean code an appropriately
! 655: * sized chunk of unmapped VA space starting at 0xff000000
! 656: * (our device mappings end before this address).
! 657: */
! 658: xscale_cache_clean_addr = 0xff000000U;
! 659:
! 660: /*
! 661: * Now we have the real page tables in place so we can switch to them.
! 662: * Once this is done we will be running with the REAL kernel page
! 663: * tables.
! 664: */
! 665:
! 666: /*
! 667: * Update the physical_freestart/physical_freeend/free_pages
! 668: * variables.
! 669: */
! 670: {
! 671: physical_freestart = physical_start - KERNEL_BASE +
! 672: round_page(esym);
! 673: physical_freeend = physical_end;
! 674: free_pages =
! 675: (physical_freeend - physical_freestart) / PAGE_SIZE;
! 676: }
! 677: #ifdef VERBOSE_INIT_ARM
! 678: printf("physical_freestart %x end %x\n", physical_freestart,
! 679: physical_freeend);
! 680: #endif
! 681:
! 682: /* be a client to all domains */
! 683: cpu_domains(0x55555555);
! 684: /* Switch tables */
! 685: #ifdef VERBOSE_INIT_ARM
! 686: printf("freestart = 0x%08lx, free_pages = %d (0x%x)\n",
! 687: physical_freestart, free_pages, free_pages);
! 688: printf("switching to new L1 page table @%#lx...", kernel_l1pt.pv_pa);
! 689: #endif
! 690:
! 691:
! 692: cpu_domains((DOMAIN_CLIENT << (PMAP_DOMAIN_KERNEL*2)) | DOMAIN_CLIENT);
! 693: setttb(kernel_l1pt.pv_pa);
! 694: cpu_tlb_flushID();
! 695: cpu_domains(DOMAIN_CLIENT << (PMAP_DOMAIN_KERNEL*2));
! 696:
! 697: /*
! 698: * Moved from cpu_startup() as data_abort_handler() references
! 699: * this during uvm init
! 700: */
! 701: proc0paddr = (struct user *)kernelstack.pv_va;
! 702: proc0.p_addr = proc0paddr;
! 703:
! 704: #ifdef VERBOSE_INIT_ARM
! 705: printf("bootstrap done.\n");
! 706: #endif
! 707:
! 708: #ifdef HIGH_VECT
! 709: arm32_vector_init(ARM_VECTORS_HIGH, ARM_VEC_ALL);
! 710: #else
! 711: arm32_vector_init(ARM_VECTORS_LOW, ARM_VEC_ALL);
! 712: #endif
! 713:
! 714: /*
! 715: * Pages were allocated during the secondary bootstrap for the
! 716: * stacks for different CPU modes.
! 717: * We must now set the r13 registers in the different CPU modes to
! 718: * point to these stacks.
! 719: * Since the ARM stacks use STMFD etc. we must set r13 to the top end
! 720: * of the stack memory.
! 721: */
! 722: #ifdef VERBOSE_INIT_ARM
! 723: printf("init subsystems: stacks ");
! 724: #endif
! 725:
! 726: set_stackptr(PSR_IRQ32_MODE,
! 727: irqstack.pv_va + IRQ_STACK_SIZE * PAGE_SIZE);
! 728: set_stackptr(PSR_ABT32_MODE,
! 729: abtstack.pv_va + ABT_STACK_SIZE * PAGE_SIZE);
! 730: set_stackptr(PSR_UND32_MODE,
! 731: undstack.pv_va + UND_STACK_SIZE * PAGE_SIZE);
! 732:
! 733: /*
! 734: * Well we should set a data abort handler.
! 735: * Once things get going this will change as we will need a proper
! 736: * handler.
! 737: * Until then we will use a handler that just panics but tells us
! 738: * why.
! 739: * Initialisation of the vectors will just panic on a data abort.
! 740: * This just fills in a slightly better one.
! 741: */
! 742: #ifdef VERBOSE_INIT_ARM
! 743: printf("vectors ");
! 744: #endif
! 745: data_abort_handler_address = (u_int)data_abort_handler;
! 746: prefetch_abort_handler_address = (u_int)prefetch_abort_handler;
! 747: undefined_handler_address = (u_int)undefinedinstruction_bounce;
! 748:
! 749: /* Initialise the undefined instruction handlers */
! 750: #ifdef VERBOSE_INIT_ARM
! 751: printf("undefined ");
! 752: #endif
! 753: undefined_init();
! 754:
! 755: /* Load memory into UVM. */
! 756: #ifdef VERBOSE_INIT_ARM
! 757: printf("page ");
! 758: #endif
! 759: uvm_setpagesize(); /* initialize PAGE_SIZE-dependent variables */
! 760: uvm_page_physload(atop(physical_freestart), atop(physical_freeend),
! 761: atop(physical_freestart), atop(physical_freeend),
! 762: VM_FREELIST_DEFAULT);
! 763:
! 764: /* Boot strap pmap telling it where the kernel page table is */
! 765: #ifdef VERBOSE_INIT_ARM
! 766: printf("pmap ");
! 767: #endif
! 768: pmap_bootstrap((pd_entry_t *)kernel_l1pt.pv_va, KERNEL_VM_BASE,
! 769: KERNEL_VM_BASE + KERNEL_VM_SIZE);
! 770:
! 771: /* Update dump information */
! 772: cpu_kcore_hdr.pmap_kernel_l1 = (u_int32_t)pmap_kernel()->pm_l1;
! 773: cpu_kcore_hdr.pmap_kernel_l2 = (u_int32_t)&(pmap_kernel()->pm_l2);
! 774:
! 775: /* Setup the IRQ system */
! 776: #ifdef VERBOSE_INIT_ARM
! 777: printf("irq ");
! 778: #endif
! 779: i80321intc_intr_init();
! 780:
! 781: #ifdef VERBOSE_INIT_ARM
! 782: printf("done.\n");
! 783: #endif
! 784:
! 785: #ifdef DDB
! 786: db_machine_init();
! 787:
! 788: /* Firmware doesn't load symbols. */
! 789: ddb_init();
! 790:
! 791: if (boothowto & RB_KDB)
! 792: Debugger();
! 793: #endif
! 794:
! 795: /* We return the new stack pointer address */
! 796: return(kernelstack.pv_va + USPACE_SVC_STACK_TOP);
! 797: }
! 798:
! 799: void
! 800: process_kernel_args(char *args)
! 801: {
! 802: char *cp = args;
! 803:
! 804: if (cp == NULL || *(int *)cp != BOOT_STRING_MAGIC) {
! 805: boothowto = RB_AUTOBOOT;
! 806: return;
! 807: }
! 808:
! 809: /* Eat the cookie */
! 810: *(int *)cp = 0;
! 811: cp += sizeof(int);
! 812:
! 813: boothowto = 0;
! 814:
! 815: /* Make a local copy of the bootargs */
! 816: strncpy(bootargs, cp, MAX_BOOT_STRING - sizeof(int));
! 817:
! 818: cp = bootargs;
! 819: boot_file = bootargs;
! 820:
! 821: /* Skip the kernel image filename */
! 822: while (*cp != ' ' && *cp != 0)
! 823: ++cp;
! 824:
! 825: if (*cp != 0)
! 826: *cp++ = 0;
! 827:
! 828: while (*cp == ' ')
! 829: ++cp;
! 830:
! 831: boot_args = cp;
! 832:
! 833: #if 0
! 834: printf("bootfile: %s\n", boot_file);
! 835: printf("bootargs: %s\n", boot_args);
! 836: #endif
! 837:
! 838: /* Setup pointer to boot flags */
! 839: while (*cp != '-')
! 840: if (*cp++ == '\0')
! 841: return;
! 842:
! 843: for (;*++cp;) {
! 844: int fl;
! 845:
! 846: fl = 0;
! 847: switch(*cp) {
! 848: case 'a':
! 849: fl |= RB_ASKNAME;
! 850: break;
! 851: case 'c':
! 852: fl |= RB_CONFIG;
! 853: break;
! 854: case 'd':
! 855: fl |= RB_KDB;
! 856: break;
! 857: case 's':
! 858: fl |= RB_SINGLE;
! 859: break;
! 860: default:
! 861: printf("unknown option `%c'\n", *cp);
! 862: break;
! 863: }
! 864: boothowto |= fl;
! 865: }
! 866: }
! 867:
! 868:
! 869: void
! 870: consinit(void)
! 871: {
! 872: static const bus_addr_t comcnaddrs[] = {
! 873: IQ80321_UART1 /* com0 */
! 874: };
! 875: static int consinit_called;
! 876:
! 877: if (consinit_called != 0)
! 878: return;
! 879:
! 880: consinit_called = 1;
! 881:
! 882: /*
! 883: * Console devices are mapped VA==PA. Our devmap reflects
! 884: * this, so register it now so drivers can map the console
! 885: * device.
! 886: */
! 887: pmap_devmap_register(iq80321_devmap);
! 888:
! 889: #if NCOM > 0
! 890: if (comcnattach(&obio_bs_tag, comcnaddrs[0], comcnspeed,
! 891: COM_FREQ, comcnmode))
! 892: panic("can't init serial console @%lx", comcnaddrs[0]);
! 893: comdefaultrate = comcnspeed;
! 894: #else
! 895: panic("serial console @%lx not configured", comcnaddrs[0]);
! 896: #endif
! 897: }
! 898:
! 899: void
! 900: board_startup(void)
! 901: {
! 902: if (boothowto & RB_CONFIG) {
! 903: #ifdef BOOT_CONFIG
! 904: user_config();
! 905: #else
! 906: printf("kernel does not support -c; continuing..\n");
! 907: #endif
! 908: }
! 909: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to armish_machdep.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / armish / armish