arch/v850/kernel/head.S

   1 /*
   2  * arch/v850/kernel/head.S -- Lowest-level startup code
   3  *
   4  *  Copyright (C) 2001,02,03  NEC Electronics Corporation
   5  *  Copyright (C) 2001,02,03  Miles Bader <miles@gnu.org>
   6  *
   7  * This file is subject to the terms and conditions of the GNU General
   8  * Public License.  See the file COPYING in the main directory of this
   9  * archive for more details.
  10  *
  11  * Written by Miles Bader <miles@gnu.org>
  12  */
  13
  14 #include <asm/clinkage.h>
  15 #include <asm/current.h>
  16 #include <asm/entry.h>
  17 #include <asm/thread_info.h>
  18 #include <asm/irq.h>
  19
  20
  21 /* Make a slightly more convenient alias for C_SYMBOL_NAME.  */
  22 #define CSYM    C_SYMBOL_NAME
  23
  24
  25         .text
  26
  27         // Define `mach_early_init' as a weak symbol
  28         .global CSYM(mach_early_init)
  29         .weak   CSYM(mach_early_init)
  30
  31 C_ENTRY(start):
  32         // Make sure interrupts are turned off, just in case
  33         di
  34
  35 #ifdef CONFIG_RESET_GUARD
  36         // See if we got here via an unexpected reset
  37         ld.w    RESET_GUARD, r19        // Check current value of reset guard
  38         mov     RESET_GUARD_ACTIVE, r20
  39         cmp     r19, r20
  40         bne     1f                      // Guard was not active
  41
  42         // If we get here, the reset guard was active.  Load up some
  43         // interesting values as arguments, and jump to the handler.
  44         st.w    r0, RESET_GUARD         // Allow further resets to succeed
  45         mov     lp, r6                  // Arg 0: return address
  46         ld.b    KM, r7                  // Arg 1: kernel mode
  47         mov     sp, r9                  // Arg 3: stack pointer
  48         ld.w    KSP, r19                // maybe switch to kernel stack
  49         cmp     r7, r0                  // see if already in kernel mode
  50         cmov    z, r19, sp, sp          //  and switch to kernel stack if not
  51         GET_CURRENT_TASK(r8)            // Arg 2: task pointer
  52         jr      CSYM(unexpected_reset)
  53
  54 1:      st.w    r20, RESET_GUARD        // Turn on reset guard
  55 #endif /* CONFIG_RESET_GUARD */
  56
  57         // Setup a temporary stack for doing pre-initialization function calls.
  58         //
  59         // We can't use the initial kernel stack, because (1) it may be
  60         // located in memory we're not allowed to touch, and (2) since
  61         // it's in the data segment, calling memcpy to initialize that
  62         // area from ROM will overwrite memcpy's return address.
  63         mov     hilo(CSYM(_init_stack_end) - 4), sp
  64
  65         // See if there's a platform-specific early-initialization routine
  66         // defined; it's a weak symbol, so it will have an address of zero if
  67         // there's not.
  68         mov     hilo(CSYM(mach_early_init)), r6
  69         cmp     r6, r0
  70         bz      3f
  71
  72         // There is one, so call it.  If this function is written in C, it
  73         // should be very careful -- the stack pointer is valid, but very
  74         // little else is (e.g., bss is not zeroed yet, and initialized data
  75         // hasn't been).
  76         jarl    2f, lp                  // first figure out return address
  77 2:      add     3f - ., lp
  78         jmp     [r6]                    // do call
  79 3:
  80
  81 #ifdef CONFIG_ROM_KERNEL
  82         // Copy the data area from ROM to RAM
  83         mov     hilo(CSYM(_rom_copy_dst_start)), r6
  84         mov     hilo(CSYM(_rom_copy_src_start)), r7
  85         mov     hilo(CSYM(_rom_copy_dst_end)), r8
  86         sub     r6, r8
  87         jarl    CSYM(memcpy), lp
  88 #endif
  89
  90         // Load the initial thread's stack, and current task pointer (in r16)
  91         mov     hilo(CSYM(init_thread_union)), r19
  92         movea   THREAD_SIZE, r19, sp
  93         ld.w    TI_TASK[r19], CURRENT_TASK
  94
  95 #ifdef CONFIG_TIME_BOOTUP
  96         /* This stuff must come after mach_early_init, because interrupts may
  97            not work until after its been called.  */
  98         jarl    CSYM(highres_timer_reset), lp
  99         jarl    CSYM(highres_timer_start), lp
 100 #endif
 101
 102         // Kernel stack pointer save location
 103         st.w    sp, KSP
 104
 105         // Assert that we're in `kernel mode'
 106         mov     1, r19
 107         st.w    r19, KM
 108
 109 #ifdef CONFIG_ZERO_BSS
 110         // Zero bss area, since we can't rely upon any loader to do so
 111         mov     hilo(CSYM(_sbss)), r6
 112         mov     r0, r7
 113         mov     hilo(CSYM(_ebss)), r8
 114         sub     r6, r8
 115         jarl    CSYM(memset), lp
 116 #endif
 117
 118         // What happens if the main kernel function returns (it shouldn't)
 119         mov     hilo(CSYM(machine_halt)), lp
 120
 121         // Start the linux kernel.  We use an indirect jump to get extra
 122         // range, because on some platforms this initial startup code
 123         // (and the associated platform-specific code in mach_early_init)
 124         // are located far away from the main kernel, e.g. so that they
 125         // can initialize RAM first and copy the kernel or something.
 126         mov     hilo(CSYM(start_kernel)), r12
 127         jmp     [r12]
 128 C_END(start)