git.sur5r.net Git - u-boot/blob - arch/mips/cpu/mips32/start.S

   1 /*
   2  *  Startup Code for MIPS32 CPU-core
   3  *
   4  *  Copyright (c) 2003  Wolfgang Denk <wd@denx.de>
   5  *
   6  * SPDX-License-Identifier:     GPL-2.0+
   7  */
   8
   9 #include <asm-offsets.h>
  10 #include <config.h>
  11 #include <asm/regdef.h>
  12 #include <asm/mipsregs.h>
  13
  14 #ifndef CONFIG_SYS_MIPS_CACHE_MODE
  15 #define CONFIG_SYS_MIPS_CACHE_MODE CONF_CM_CACHABLE_NONCOHERENT
  16 #endif
  17
  18 #ifndef CONFIG_SYS_INIT_SP_ADDR
  19 #define CONFIG_SYS_INIT_SP_ADDR (CONFIG_SYS_SDRAM_BASE + \
  20                                 CONFIG_SYS_INIT_SP_OFFSET)
  21 #endif
  22
  23         /*
  24          * For the moment disable interrupts, mark the kernel mode and
  25          * set ST0_KX so that the CPU does not spit fire when using
  26          * 64-bit addresses.
  27          */
  28         .macro  setup_c0_status set clr
  29         .set    push
  30         mfc0    t0, CP0_STATUS
  31         or      t0, ST0_CU0 | \set | 0x1f | \clr
  32         xor     t0, 0x1f | \clr
  33         mtc0    t0, CP0_STATUS
  34         .set    noreorder
  35         sll     zero, 3                         # ehb
  36         .set    pop
  37         .endm
  38
  39         .set noreorder
  40
  41         .globl _start
  42         .text
  43 _start:
  44         /* U-boot entry point */
  45         b       reset
  46          nop
  47
  48         .org 0x10
  49 #if defined(CONFIG_SYS_XWAY_EBU_BOOTCFG)
  50         /*
  51          * Almost all Lantiq XWAY SoC devices have an external bus unit (EBU) to
  52          * access external NOR flashes. If the board boots from NOR flash the
  53          * internal BootROM does a blind read at address 0xB0000010 to read the
  54          * initial configuration for that EBU in order to access the flash
  55          * device with correct parameters. This config option is board-specific.
  56          */
  57         .word CONFIG_SYS_XWAY_EBU_BOOTCFG
  58         .word 0x0
  59 #elif defined(CONFIG_MALTA)
  60         /*
  61          * Linux expects the Board ID here.
  62          */
  63         .word 0x00000420        # 0x420 (Malta Board with CoreLV)
  64         .word 0x00000000
  65 #endif
  66
  67         .org 0x200
  68         /* TLB refill, 32 bit task */
  69 1:      b       1b
  70          nop
  71
  72         .org 0x280
  73         /* XTLB refill, 64 bit task */
  74 1:      b       1b
  75          nop
  76
  77         .org 0x300
  78         /* Cache error exception */
  79 1:      b       1b
  80          nop
  81
  82         .org 0x380
  83         /* General exception */
  84 1:      b       1b
  85          nop
  86
  87         .org 0x400
  88         /* Catch interrupt exceptions */
  89 1:      b       1b
  90          nop
  91
  92         .org 0x480
  93         /* EJTAG debug exception */
  94 1:      b       1b
  95          nop
  96
  97         .align 4
  98 reset:
  99
 100         /* Clear watch registers */
 101         mtc0    zero, CP0_WATCHLO
 102         mtc0    zero, CP0_WATCHHI
 103
 104         /* WP(Watch Pending), SW0/1 should be cleared */
 105         mtc0    zero, CP0_CAUSE
 106
 107         setup_c0_status 0 0
 108
 109         /* Init Timer */
 110         mtc0    zero, CP0_COUNT
 111         mtc0    zero, CP0_COMPARE
 112
 113 #ifndef CONFIG_SKIP_LOWLEVEL_INIT
 114         /* CONFIG0 register */
 115         li      t0, CONF_CM_UNCACHED
 116         mtc0    t0, CP0_CONFIG
 117 #endif
 118
 119         /* Initialize $gp */
 120         bal     1f
 121          nop
 122         .word   _gp
 123 1:
 124         lw      gp, 0(ra)
 125
 126 #ifndef CONFIG_SKIP_LOWLEVEL_INIT
 127         /* Initialize any external memory */
 128         la      t9, lowlevel_init
 129         jalr    t9
 130          nop
 131
 132         /* Initialize caches... */
 133         la      t9, mips_cache_reset
 134         jalr    t9
 135          nop
 136
 137         /* ... and enable them */
 138         li      t0, CONFIG_SYS_MIPS_CACHE_MODE
 139         mtc0    t0, CP0_CONFIG
 140 #endif
 141
 142         /* Set up temporary stack */
 143         li      t0, -16
 144         li      t1, CONFIG_SYS_INIT_SP_ADDR
 145         and     sp, t1, t0              # force 16 byte alignment
 146         sub     sp, sp, GD_SIZE         # reserve space for gd
 147         and     sp, sp, t0              # force 16 byte alignment
 148         move    k0, sp                  # save gd pointer
 149 #ifdef CONFIG_SYS_MALLOC_F_LEN
 150         li      t2, CONFIG_SYS_MALLOC_F_LEN
 151         sub     sp, sp, t2              # reserve space for early malloc
 152         and     sp, sp, t0              # force 16 byte alignment
 153 #endif
 154         move    fp, sp
 155
 156         /* Clear gd */
 157         move    t0, k0
 158 1:
 159         sw      zero, 0(t0)
 160         blt     t0, t1, 1b
 161          addi   t0, 4
 162
 163 #ifdef CONFIG_SYS_MALLOC_F_LEN
 164         addu    t0, k0, GD_MALLOC_BASE  # gd->malloc_base offset
 165         sw      sp, 0(t0)
 166 #endif
 167
 168         la      t9, board_init_f
 169         jr      t9
 170          move   ra, zero
 171
 172 /*
 173  * void relocate_code (addr_sp, gd, addr_moni)
 174  *
 175  * This "function" does not return, instead it continues in RAM
 176  * after relocating the monitor code.
 177  *
 178  * a0 = addr_sp
 179  * a1 = gd
 180  * a2 = destination address
 181  */
 182         .globl  relocate_code
 183         .ent    relocate_code
 184 relocate_code:
 185         move    sp, a0                  # set new stack pointer
 186         move    fp, sp
 187
 188         move    s0, a1                  # save gd in s0
 189         move    s2, a2                  # save destination address in s2
 190
 191         li      t0, CONFIG_SYS_MONITOR_BASE
 192         sub     s1, s2, t0              # s1 <-- relocation offset
 193
 194         la      t3, in_ram
 195         lw      t2, -12(t3)             # t2 <-- __image_copy_end
 196         move    t1, a2
 197
 198         add     gp, s1                  # adjust gp
 199
 200         /*
 201          * t0 = source address
 202          * t1 = target address
 203          * t2 = source end address
 204          */
 205 1:
 206         lw      t3, 0(t0)
 207         sw      t3, 0(t1)
 208         addu    t0, 4
 209         blt     t0, t2, 1b
 210          addu   t1, 4
 211
 212         /* If caches were enabled, we would have to flush them here. */
 213         sub     a1, t1, s2              # a1 <-- size
 214         la      t9, flush_cache
 215         jalr    t9
 216          move   a0, s2                  # a0 <-- destination address
 217
 218         /* Jump to where we've relocated ourselves */
 219         addi    t0, s2, in_ram - _start
 220         jr      t0
 221          nop
 222
 223         .word   __rel_dyn_end
 224         .word   __rel_dyn_start
 225         .word   __image_copy_end
 226         .word   _GLOBAL_OFFSET_TABLE_
 227         .word   num_got_entries
 228
 229 in_ram:
 230         /*
 231          * Now we want to update GOT.
 232          *
 233          * GOT[0] is reserved. GOT[1] is also reserved for the dynamic object
 234          * generated by GNU ld. Skip these reserved entries from relocation.
 235          */
 236         lw      t3, -4(t0)              # t3 <-- num_got_entries
 237         lw      t8, -8(t0)              # t8 <-- _GLOBAL_OFFSET_TABLE_
 238         add     t8, s1                  # t8 now holds relocated _G_O_T_
 239         addi    t8, t8, 8               # skipping first two entries
 240         li      t2, 2
 241 1:
 242         lw      t1, 0(t8)
 243         beqz    t1, 2f
 244          add    t1, s1
 245         sw      t1, 0(t8)
 246 2:
 247         addi    t2, 1
 248         blt     t2, t3, 1b
 249          addi   t8, 4
 250
 251         /* Update dynamic relocations */
 252         lw      t1, -16(t0)             # t1 <-- __rel_dyn_start
 253         lw      t2, -20(t0)             # t2 <-- __rel_dyn_end
 254
 255         b       2f                      # skip first reserved entry
 256          addi   t1, 8
 257
 258 1:
 259         lw      t8, -4(t1)              # t8 <-- relocation info
 260
 261         li      t3, 3
 262         bne     t8, t3, 2f              # skip non R_MIPS_REL32 entries
 263          nop
 264
 265         lw      t3, -8(t1)              # t3 <-- location to fix up in FLASH
 266
 267         lw      t8, 0(t3)               # t8 <-- original pointer
 268         add     t8, s1                  # t8 <-- adjusted pointer
 269
 270         add     t3, s1                  # t3 <-- location to fix up in RAM
 271         sw      t8, 0(t3)
 272
 273 2:
 274         blt     t1, t2, 1b
 275          addi   t1, 8                   # each rel.dyn entry is 8 bytes
 276
 277         /*
 278          * Clear BSS
 279          *
 280          * GOT is now relocated. Thus __bss_start and __bss_end can be
 281          * accessed directly via $gp.
 282          */
 283         la      t1, __bss_start         # t1 <-- __bss_start
 284         la      t2, __bss_end           # t2 <-- __bss_end
 285
 286 1:
 287         sw      zero, 0(t1)
 288         blt     t1, t2, 1b
 289          addi   t1, 4
 290
 291         move    a0, s0                  # a0 <-- gd
 292         move    a1, s2
 293         la      t9, board_init_r
 294         jr      t9
 295          move   ra, zero
 296
 297         .end    relocate_code