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