/* * Copyright (c) 2000, 2001, 2002, 2003, 2004, 2005, 2008, 2009 * The President and Fellows of Harvard College. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include .set noreorder .text .globl __start .type __start,@function .ent __start __start: /* * Stack frame. We save the return address register, even though * it contains nothing useful. This is for gdb's benefit when it * comes disassembling. We also need 16 bytes for making a call, * and we have to align to an 8-byte (64-bit) boundary, so the * total frame size is 24. * * Note that the frame here must match the frame we set up below * when we switch off the bootup stack. Otherwise, gdb gets very * confused. */ .frame sp, 24, $0 /* 24-byte sp-relative frame; return addr on stack */ .mask 0x80000000, -4 /* register 31 (ra) saved at (sp+24)-4 */ addiu sp, sp, -24 sw ra, 20(sp) /* * The System/161 loader sets up a boot stack for the first * processor at the top of physical memory, and passes us a single * string argument. The string lives on the very top of the stack. * We get its address in a0. * * The kernel loads at virtual address 0x80000200, which is * physical address 0x00000200. The space immediately below this * is reserved for the exception vector code. * * The symbol _end is generated by the linker. It's the address of * the end of the kernel. It's not a variable; the *value* of the * _end symbol itself is this address. In C you'd use "&_end". * * We set up the memory map like this: * * top of memory * free memory * P + 0x1000 * first thread's stack (1 page) * P * wasted space (< 1 page) * copy of the boot string * _end * kernel * 0x80000200 * exception handlers * 0x80000000 * * where P is the next whole page after copying the argument string. */ la s0, _end /* stash _end in a saved register */ move a1, a0 /* move bootstring to the second argument */ move a0, s0 /* make _end the first argument */ jal strcpy /* call strcpy(_end, bootstring) */ nop /* delay slot */ move a0, s0 /* make _end the first argument again */ jal strlen /* call strlen(_end) */ nop add t0, s0, v0 /* add in the length of the string */ addi t0, t0, 1 /* and the null terminator */ addi t0, t0, 4095 /* round up to next page boundary */ li t1, 0xfffff000 and t0, t0, t1 addi t0, t0, 4096 /* add one page to hold the stack */ move sp, t0 /* start the kernel stack for the first thread here */ sw t0, firstfree /* remember the first free page for later */ /* * At this point, s0 contains the boot argument string, and no other * registers contain anything interesting (except the stack pointer). */ /* * Now set up a stack frame on the real kernel stack: a dummy saved * return address and four argument slots for making function calls, * plus a wasted slot for alignment. * * (This needs to match the stack frame set up at the top of the * function, or the debugger gets confused.) */ addiu sp, sp, -24 sw $0, 20(sp) /* * Now, copy the exception handler code onto the first page of memory. */ li a0, EXADDR_UTLB la a1, mips_utlb_handler la a2, mips_utlb_end sub a2, a2, a1 jal memmove nop li a0, EXADDR_GENERAL la a1, mips_general_handler la a2, mips_general_end sub a2, a2, a1 jal memmove nop /* * Flush the instruction cache to make sure the above changes show * through to instruction fetch. */ jal mips_flushicache nop /* * Initialize the TLB. */ jal tlb_reset nop /* * Load NULL into the register we use for curthread. */ li s7, 0 /* * Set up the status register. * * The MIPS has six hardware interrupt lines and two software interrupts. * These are individually maskable in the status register. However, we * don't use this feature (for simplicity) - we only use the master * interrupt enable/disable flag in bit 0. So enable all of those bits * now and forget about them. * * The BEV bit in the status register, if set, causes the processor to * jump to a different set of hardwired exception handling addresses. * This is so that the kernel's exception handling code can be loaded * into RAM and that the boot ROM's exception handling code can be ROM. * This flag is normally set at boot time, and we need to be sure to * clear it. * * The KUo/IEo/KUp/IEp/KUc/IEc bits should all start at zero. * * We also want all the other random control bits (mostly for cache * stuff) set to zero. * * Thus, the actual value we write is CST_IRQMASK. */ li t0, CST_IRQMASK /* get value */ mtc0 t0, c0_status /* set status register */ /* * Load the CPU number into the PTBASE field of the CONTEXT * register. This is necessary to read from cpustacks[] and * cputhreads[] on trap entry from user mode. See further * discussions elsewhere. * * Because the boot CPU is CPU 0, we can just send 0. */ mtc0 $0, c0_context /* * Load the GP register. This is a MIPS ABI feature; the GP * register points to an address in the middle of the data segment, * so data can be accessed relative to GP using one instruction * instead of the two it takes to set up a full 32-bit address. */ la gp, _gp /* * We're all set up! * Fetch the copy of the bootstring as the argument, and call main. */ jal kmain move a0, s0 /* in delay slot */ /* * kmain shouldn't return. panic. * Loop back just in case panic returns too. */ 1: la a0, panicstr jal panic nop /* delay slot */ j 1b nop /* delay slot */ .end __start .rdata panicstr: .asciz "kmain returned\n" /* * CPUs started after the boot CPU come here. */ .text .globl cpu_start_secondary .type cpu_start_secondary,@function .ent cpu_start_secondary cpu_start_secondary: /* * When we get here our stack points to the CRAM area of the bus * controller per-CPU space. This means we can, with a bit of * caution, call C functions, but nothing very deeply nesting. * However, we don't need to. * * The a0 register contains the value that was put in the second * word of the CRAM area, which is the (software) cpu number for * indexing cpustacks[]. None of the other registers contain * anything useful. */ /* * Stack frame. We save the return address register, even though * it contains nothing useful. This is for gdb's benefit when it * comes disassembling. We also need 16 bytes for making a call, * and 4 bytes for alignment, so the total frame size is 24. * * Note that the frame here must match the frame we set up below * when we switch stacks. Otherwise, gdb gets very confused. */ .frame sp, 24, $0 /* 24-byte sp-relative frame; return addr on stack */ .mask 0x80000000, -4 /* register 31 (ra) saved at (sp+24)-4 */ addiu sp, sp, -24 sw ra, 20(sp) /* * Fetch the stack out of cpustacks[]. */ lui t0, %hi(cpustacks) /* load upper half of cpustacks base addr */ sll v0, a0, 2 /* get byte index for array (multiply by 4) */ addu t0, t0, v0 /* add it in */ lw sp, %lo(cpustacks)(t0) /* get the stack pointer */ /* * Now fetch curthread out of cputhreads[]. */ lui t0, %hi(cputhreads) /* load upper half of cpustacks base addr */ sll v0, a0, 2 /* get byte index for array (multiply by 4) */ addu t0, t0, v0 /* add it in */ lw s7, %lo(cputhreads)(t0) /* load curthread register */ /* * Initialize the TLB. */ jal tlb_reset nop /* * Set up the status register, as described above. */ li t0, CST_IRQMASK /* get value */ mtc0 t0, c0_status /* set status register */ /* * Load the CPU number into the PTBASE field of the CONTEXT * register, as described above. */ sll v0, a0, CTX_PTBASESHIFT mtc0 v0, c0_context /* * Initialize the on-chip timer interrupt. * * This should be set to CPU_FREQUENCY/HZ, but we don't have either * of those values here, so we'll arbitrarily set it to 100,000. It * will get reset to the right thing after it first fires. */ li v0, 100000 mtc0 v0, c0_compare /* * Load the GP register. */ la gp, _gp /* * Set up a stack frame. Store zero into the return address slot so * we show as the top of the stack. */ addiu sp, sp, -24 sw z0, 20(sp) /* * Off to MI code. Pass the cpu number as the argument; it's already * in the a0 register. */ j cpu_hatch nop /* delay slot for jump */ .end cpu_start_secondary