基于S3C6410的U-boot启动代码分析（一）

预备知识

可执行文件由许多链接在一起的对象文件组成。对象文件有许多节，如文本、数据、init 数据、bss等。这些对象文件都是由一个称为 链接器脚本（*lds）的文件链接并装入的。这个链接器脚本的功能是将输入对象文件的各节映射到输出文件中；换句话说，它将所有输入对象文件都链接到单一的可执行文件中，将该可执行文件的各节装入到指定地址处。 因此在分析u-boot代码是，首先应关注的是u-boot.lds文件，它位于$(U-BOOT_SRC_ROOT)/board/$(BOARD_NAME)目录下。

U-Boot启动过程分析

     U-Boot的启动过程可以分为两个阶段，两个阶段分别完成如下功能：

     （1）第一阶段的功能

Ø  硬件设备初始化

Ø  加载U-Boot第二阶段代码到RAM空间

Ø  设置好栈

Ø  跳转到第二阶段代码入口

      （2）第二阶段的功能

Ø  初始化本阶段使用的硬件设备

Ø  检测系统内存映射

Ø  将内核从Flash读取到RAM中    

Ø  为内核设置启动参数

    第一阶段对应的文件是start.S和lowlevel_init.S。

    U-Boot启动第一阶段流程如下：

  

 

首先分析u-boot.lds文件

/*
* OUTPUT_FORMAT(default, big, little)，在链接的时候，如果使用了-EB的命令行参数，则使用这里的big
* 参数指定的字节序，如果使用了-EL;的命令行参数，则使用这里的little参数指定的字节序，如果没有使用
* 任何命令行参数，则使用这里的default参数指定的字节序。  
* 由$(SRC_ROOT)/board/samsung/smdk6410/u-boot.lds中的定义可见，不管在链接的时候使用了何种命令行参数，
* 输出的目标文件都是使用elf32-littlearm方式的字节序。 
*/

OUTPUT_FORMAT("elf32-littlearm", "elf32-littlearm", "elf32-littlearm")
/*OUTPUT_FORMAT("elf32-arm", "elf32-arm", "elf32-arm")*/
/*以上语句是指定输出可执行文件是elf格式,32位ARM指令,小端 */

/*指定输出可执行文件的平台为ARM*/
OUTPUT_ARCH(arm) 

/*指定输出可执行文件的起始代码段为_start.*/ 
ENTRY(_start)
SECTIONS
{
 /*定位当前地址为0x0地址*/
 . = 0x00000000;

 /*指定代码以4字节对齐*/
 . = ALIGN(4);

 /*指定代码段  */
 .text      :
 {
   cpu/s3c64xx/start.o (.text)   /*代码的第一个代码部分*/
   cpu/s3c64xx/s3c6410/cpu_init.o (.text)
   cpu/s3c64xx/onenand_cp.o (.text)
   cpu/s3c64xx/nand_cp.o (.text)
   cpu/s3c64xx/movi.o (.text)
   *(.text)
   lib_arm/div0.o
 }

 . = ALIGN(4);
 .rodata : { *(.rodata) } /*指定只读数据段 */

 . = ALIGN(4);
 .data : { *(.data) }   /*指定读写数据段*/

 . = ALIGN(4);
 .got : { *(.got) }  /*指定got段, got段式是uboot自定义的一个段, 非标准段*/

 __u_boot_cmd_start = .;  /*把__u_boot_cmd_start赋值为当前位置, 即起始位置*/
 .u_boot_cmd : { *(.u_boot_cmd) }  /*指定u_boot_cmd段, uboot把所有的uboot命令放在该段.*/
 __u_boot_cmd_end = .;     /*把__u_boot_cmd_end赋值为当前位置,即结束位置*/

 . = ALIGN(4);
 .mmudata : { *(.mmudata) }  

 . = ALIGN(4);
 __bss_start = .;   /*把__bss_start赋值为当前位置,即bss段的开始位置*/
 .bss : { *(.bss) }   /*指定bss段  */
 _end = .;     /*把_end赋值为当前位置,即bss段的结束位置 */
}

        由u-boot.lds文件可知：第一个链接的是start.o文件，因此u-boot.bin的入口代码在start.o中，其源代码为start.S，u-boot.bin执行的入口点为ENTRY(_start)。

       下面就来分析start.s文件：(start.s位于目录$(U-BOOT_SRC_ROOT)/cpu/$(CPU_NAME)/目录下)

 -----------------------------------------------------------------------------------------------------------------------------------------------

#include
#include
#ifdef CONFIG_ENABLE_MMU
#include
#endif
#include

#ifndef CONFIG_ENABLE_MMU
#ifndef CFG_PHY_UBOOT_BASE
#define CFG_PHY_UBOOT_BASE CFG_UBOOT_BASE
#endif
#endif
/*
* ARM处理器为特殊的任务或者专门的功能指定了3个寄存器:r13,r14,r15.
* 寄存器r13通常用作堆栈指针(sp)，保存当前处理器模式的堆栈的栈顶。
* 寄存器r14又被称为连接寄存器(lr),保存调用子程序的返回地址。
* 寄存器r15是程序计数器(pc)，其内容是处理器要取的下一条指令的地址。
* 两个状态寄存器:cpsr和spsr，分别是当前和备份的程序状态寄存器。
*/

/*
 *************************************************************************
 *
 * Jump vector table as in table 3.1 in [1]
 *
 *************************************************************************
 */

/*指定输出可执行文件的起始代码段为_start.*/ 
/*在board/u-boot.lds 中定义ENTRY(_start) */

.globl _start   /*全局变量_start,U-Boot启动入口*/

/*
* ARM分支指令可以改变程序的执行流程或者调用子程序。这种指令使得一个程序可以使用子程序、if-then-else
* 结构及循环。执行流程的改变迫使程序计数器PC指向一个新的地址。
* B{}     lable     跳转  pc=lable
* BL{}    lable   带返回的跳转  pc=lable，lr=BL后面的第一条指令地址
* BX{}    Rm   跳转并切换状态 PC = Rm & 0xfffffffe，T=Rm&1
* BLX{}   lable | Rm 带返回的跳转并切换状态  pc = lable, T =1 pc =Rm & 0xfffffffe,T=Rm&1 lr=BLX后面的第一条指令地址
* 地址lable以一个有符号的相对于pc的偏移量保存在指令中，必须被限制在分支指令的约32MB范围内。T对应于cpsr中的Thumb位，如果指令设
* 置了T，那么ARM切换到Thumb状态。
*/
_start: b reset

/*
* ldr属于load-store指令，它用于在存储器和处理器寄存器之间传输数据。load-store指令有三种类型:单寄存器传输指令
* 多寄存器传输指令和交换指令；
* 单寄存器传输指令用于把单个的数据传入或者传出一个寄存器。
* ldr/str  {B} Rd, addressing1 其中ldr是把一个字装入一个寄存器: Rd <--mem32[address]；str是从一个寄存器保存一个字或者一个字节 Rd -->mem32[address]
*/
 /*该部分为处理器的异常处理向量表。*/
 ldr pc, _undefined_instruction
 ldr pc, _software_interrupt
 ldr pc, _prefetch_abort
 ldr pc, _data_abort
 ldr pc, _not_used
 ldr pc, _irq
 ldr pc, _fiq

/*
* 在当前标号_undefined_instruction所在的地址处放入四字节的数据,这个数据就是undefined_instruction标号
* 的地址.意思就是说在当前_undefined_instruction对应的地址中放的是undefined_instruction的地址
*/  
_undefined_instruction:
 .word undefined_instruction
_software_interrupt:
 .word software_interrupt
_prefetch_abort:
 .word prefetch_abort
_data_abort:
 .word data_abort
_not_used:
 .word not_used
_irq:
 .word irq
_fiq:
 .word fiq
_pad:
 .word 0x12345678 /* now 16*4=64 */
.global _end_vect
_end_vect:

 .balignl 16,0xdeadbeef
/*
 *************************************************************************
 *
 * Startup Code (reset vector)
 *
 * do important init only if we don't start from memory!
 * setup Memory and board specific bits prior to relocation.
 * relocate armboot to ram
 * setup stack
 *
 *************************************************************************
 */

/* 
* TEXT_BASE 在/board/config.mk文档中定义, 他定义了代码在运行时所在的地址, _TEXT_BASE中保存了这个地址
*/

_TEXT_BASE:
 .word TEXT_BASE

/*
 * Below variable is very important because we use MMU in U-Boot.
 * Without it, we cannot run code correctly before MMU is ON.
 * by scsuh.
 */
_TEXT_PHY_BASE:
 .word CFG_PHY_UBOOT_BASE

/*
* 声明 _armboot_start 并用 _start 来进行初始化.
*/
.globl _armboot_start  /*声明全局标志. 声明的该标号_armboot_start可以被外部使用*/  
_armboot_start:
 .word _start    /*在当前标号_armboot_start所在的地址处放入_start标号的地址*/ 

/*
 * These are defined in the board-specific linker script. board/samsung/smdk6410/u-boot.dls中有定义.
 */
/*预处理标号  目的:让_bss_start指向__bss_start标号所在的地址*/

.globl _bss_start     /*全局声明标志. 声明的该标号_bss_starts可以被外部使用*/  
_bss_start:
 .word __bss_start   /*在当前标号_bss_start所在的地址处放入__bss_start标号的地址*/ 

/*预处理标号 目的:让_bss_end指向_end标号所在的地址*/
.globl _bss_end
_bss_end:
 .word _end

#ifdef CONFIG_USE_IRQ
/* IRQ stack memory (calculated at run-time) */
.globl IRQ_STACK_START   /*预处理标号 目的:让IRQ_STACK_START指向地址0x0badc0de(这个需要根据硬件更改)*/  
IRQ_STACK_START:
 .word 0x0badc0de

/* IRQ stack memory (calculated at run-time) */
.globl FIQ_STACK_START
FIQ_STACK_START:
 .word 0x0badc0de
#endif

 

/*
 * the actual reset code
 */

/*
* 复位向量是处理器上电后执行的第一条指令的位置。这条指令使处理器跳转到初始化代码处。
*/
/*
* 处理器模式决定了哪些寄存器是活动的以及对cpsr的访问权。处理器复位时则进入到管理模式（Supervisor，SVC）
*/

reset:

 /*
  * set the cpu to SVC32 mode (设置CPU的工作模式为SVC32模式.)
  */
 /*
 * ARM指令集提供了2条指令，可以直接控制程序状态寄存器(psr)。MRS指令用于把cpsr或者spsr的值传送到一个寄存器。
 * MSR与MRS相反，把一个寄存器的内容传送到cpsr或者spsr。这两条指令可用于对cpsr和spsr进行读/写操作。
 */
 mrs r0,cpsr   /*mrs指令将cpsr寄存器的值复制到r0寄存器中*/
 bic r0,r0,#0x1f /*bic是位清零(Bit Clear)指令，本语句是把r0的Bit[4:0]位清零(由0x1F指示)，然后把结果写入r0中。*/
 orr r0,r0,#0xd3 /*orr指令是按位求或，本语句是r0的 Bit7,Bit6,Bit4,Bit1,Bit0 置为1，其它位保持不变。*/
 msr cpsr,r0  /*把寄存器r0的值传送到cpsr(当前程序状态寄存器)*/

/*执行完上述操作后，cpsr中的 I=1, F=1, T保持不变(默认为0)，M[4:0]=10011，意思是禁止IRQ，禁止FIQ，工作在ARM状态，工作在SVC32模式。*/

/*
 *************************************************************************
 *
 * CPU_init_critical registers
 *
 * setup important registers
 * setup memory timing
 *
 *************************************************************************
 */
         /*
         * we do sys-critical inits only at reboot,
         * not when booting from ram!
         */
cpu_init_crit:
 /*
  * flush v4 I/D caches
  */
 /*数据处理指令对于存放在寄存器中的数据进行操作。*/
 mov r0, #0  /*把立即数0送到寄存器r0中*/
 
 /*协处理器指令用于扩展指令集Ｐ??协处理器指令可用于提供附加的计算能力，有可用于控制包括cache和内存
 * 管理的存储子系统。协处理器指令包括数据处理指令，寄存器传输指令及内存传输指令。协处理器指令只用于带
 * 有协处理器的ARM内核。
 * CDP {} cp, opcode1, Cd, Cn{,opcode2}  /*协处理器数据处理 -- 在协处理器内部执行一个数据处理操作*/
 * {} cp, opcode1, Rd, Cn, Cm{,opcode2} /*协处理器寄存器传输 -- 把数据送入/取出协处理器寄存器*/
 * {} cp, Cd, addressing  /*协处理器内存比较 -- 从协处理器装载/存储一个内存数据块*/
 * 其中:cp域代表协处理器的编号，为p0~P15. opcode域描述要在协处理器中进行的操作。Cn, Cm及Cd描述在协处理器中的寄存器。
 * 协处理器15(CP15)是为系统控制预留的，如内存管理，写缓冲控制，cache控制及寄存器识别等。
 * MRC p15,0,r10,c0,c0,0 //把协处理器15寄存器c0的内容拷贝到r10中，cp15寄存器c0中包含处理器标识，其内容拷贝到通用寄存器r10
 */
 mcr p15, 0, r0, c7, c7, 0 /* flush v3/v4 cache */
 mcr p15, 0, r0, c8, c7, 0 /* flush v4 TLB */

 

 /*
  * disable MMU stuff and caches
  */
 mrc p15, 0, r0, c1, c0, 0
 bic r0, r0, #0x00002300 @ clear bits 13, 9:8 (--V- --RS)
 bic r0, r0, #0x00000087 @ clear bits 7, 2:0 (B--- -CAM)
 orr r0, r0, #0x00000002 @ set bit 2 (A) Align
 orr r0, r0, #0x00001000 @ set bit 12 (I) I-Cache
 mcr p15, 0, r0, c1, c0, 0

 /* Peri port setup */
 ldr r0, =0x70000000
 orr r0, r0, #0x13 
     mcr p15,0,r0,c15,c2,4       @ 256M(0x70000000-0x7fffffff)

#ifdef CONFIG_BOOT_ONENAND
 ldr r0, =0x70000000  @ onenand controller setup
 orr r0, r0, #0x100000
 ldr r1, =0x4000
 orr r1, r1, #0xe0
 str r1, [r0] /*把r1的值写入寄存器r0所指向的地址中*/

#if defined(CONFIG_S3C6410) || defined(CONFIG_S3C6430)
 orr r0, r0, #300  @ disable watchdog
 mov r1, #1   /*把立即数1送到寄存器r1中*/
 str r1, [r0]  /*把r1的值写入寄存器r0所指向的地址中*/

 mov r1, #0x23000000  @ start buffer register  /*把立即数0x23000000送到寄存器r1中*/
 orr r1, r1, #0x30000 /*orr指令是按位求或，本语句是r1的 Bit17,Bit16 置为1，其它位保持不变。*/
 orr r1, r1, #0xc800  /*orr指令是按位求或*/
#else
 mov r1, =0x20000000  @ start buffer register
 orr r1, r1, #0xc30000
 orr r1, r1, #0xc800
#endif
 /*算术指令SUB
 * sub {} {S} Rd, Rn, N  //32位减法 Rd = Rn -N
 */
 sub r0, r1, #0x0400  @ start address1 register //r0 = r1 -0x0400

 /*ldr {B} Rd, addressing1 其中ldr是把一个字装入一个寄存器: Rd <--mem32[address]*/
 ldr r2, [r1, #0x84]  @ ecc bypass  // equals to ldr r2 r1+0x84
 orr r2, r2, #0x100  @ 按位求或，将r2寄存器的Bit8置1，其他位保持不变。
 str r2, [r1, #0x84]

 mov r3, #0x0  @ DFS, FBA
 str r3, [r0, #0x00] 
 str r3, [r0, #0x04]  @ select dataram for DDP as 0

 mov r4, #0x104  @ interrupt register
 mov r5, #0x0002  @ FPA, FSA
 mov r6, #0x0800  @ BSA

onenand_bl1_load:
 str r5, [r0, #0x1c]  @ save FPA, FSA
 orr r6, r6, #0x02  @ BSC
 str r6, [r1, #0x00]  @ save BSA, BSC
 str r3, [r1, r4]  @ clear interrupt
 str r3, [r1, #0x80]  @ write load command

 mov r7, #0x100  @ need small delay

onenand_wait_loop1:
 subs r7, r7, #0x1
 bne onenand_wait_loop1

 add r5, r5, #0x2  @ next FPA, FSA
 sub r6, r6, #0x2
 add r6, r6, #0x200  @ next BSA
 cmp r5, #0x8
 bne onenand_bl1_load
#endif

 /*
  * Go setup Memory and board specific bits prior to relocation.
  */
 /*跳转到board/samsung/smdk6410/lowlevel_init.S文件的lowlevel_init执行*/
 bl lowlevel_init /* go setup pll,mux,memory */

 /* when we already run in ram, we don't need to relocate U-Boot.
  * and actually, memory controller must be configured before U-Boot
  * is running in ram.
  */
 ldr r0, =0xff000fff
 bic r1, pc, r0  /* r0 <- current base addr of code */
 ldr r2, _TEXT_BASE  /* r1 <- original base addr in ram */
 bic r2, r2, r0  /* r0 <- current base addr of code */
 cmp     r1, r2                  /* compare r0, r1                  */
 beq     after_copy  /* r0 == r1 then skip flash copy   */

#ifdef CONFIG_BOOT_NOR   /* relocate U-Boot to RAM */
 adr r0, _start  /* r0 <- current position of code   */
 ldr r1, _TEXT_PHY_BASE /* r1 <- destination                */
 ldr r2, _armboot_start
 ldr r3, _bss_start
 sub r2, r3, r2  /* r2 <- size of armboot            */
 add r2, r0, r2  /* r2 <- source end address         */

nor_copy_loop:
 ldmia r0!, {r3-r10}  /* copy from source address [r0]    */
 stmia r1!, {r3-r10}  /* copy to   target address [r1]    */
 cmp r0, r2   /* until source end addreee [r2]    */
 ble nor_copy_loop
 b after_copy
#endif

#ifdef CONFIG_BOOT_NAND
 mov r0, #0x1000
 bl copy_from_nand
#endif

#ifdef CONFIG_BOOT_MOVINAND
 ldr sp, _TEXT_PHY_BASE
 bl movi_bl2_copy
 b after_copy
#endif

#ifdef CONFIG_BOOT_ONENAND
 ldr sp, =0x50000000  @ temporary stack

#ifdef CONFIG_S3C6400
 mov r1, =0x20000000  @ start buffer register
 orr r1, r1, #0xc30000
 orr r1, r1, #0xc800
#else
 mov r1, #0x23000000  @ start buffer register
 orr r1, r1, #0x30000
 orr r1, r1, #0xc800
#endif

 ldr r2, [r1, #0x84]  @ ecc bypass
 orr r2, r2, #0x100
 str r2, [r1, #0x84]

 sub r0, r1, #0x0400  @ start address1 register

 str r3, [r0, #0x00]
 str r3, [r0, #0x04]  @ select dataram for DDP as 0

 mov r4, #0x104  @ interrupt register

 mov r6, #0x0c00  @ fixed dataram1 sector number
 str r6, [r1, #0x00]

 mov r3, #0x0  @ DFS, FBA
 mov r5, #0x0000  @ FPA, FSA
 ldr r9, =CFG_PHY_UBOOT_BASE @ destination

onenand_bl2_load:
 str r3, [r0, #0x00]  @ save DFS, FBA
 str r5, [r0, #0x1c]  @ save FPA, FSA

 mov r7, #0x0  @ clear interrupt
 str r7, [r1, r4]
 str r7, [r1, #0x80]  @ write load command

 mov r8, #0x1000
onenand_wait_loop2:
 subs r8, r8, #0x1
 bne onenand_wait_loop2

onenand_wait_int:   @ wait INT and RI
 ldr r7, [r1, r4]
 mov r8, #0x8000
 orr r8, r8, #0x80
 tst r7, r8
 beq onenand_wait_int

 mov r7, #0x0  @ clear interrupt
 str r7, [r1, r4]

 mov r8, #0xc00  @ source address (dataram1)
 mov r10, #0x40  @ copy loop count (64 = 2048 / 32)

 stmia sp, {r0-r7}  @ backup

onenand_copy_to_ram:
 ldmia r8!, {r0-r7}
 stmia r9!, {r0-r7}
 subs r10, r10, #0x1
 bne onenand_copy_to_ram

 ldmia sp, {r0-r7}  @ restore

 add r5, r5, #0x4  @ next FPA
 cmp r5, #0x100  @ last FPA?
 bne onenand_bl2_load

 /* next block */
 mov r5, #0x0  @ reset FPA
 add r3, r3, #0x1  @ next FBA
 cmp r3, #0x2  @ last FBA?
 bne onenand_bl2_load
 b after_copy
#endif

#ifdef CONFIG_BOOT_ONENAND_IROM
 ldr sp, _TEXT_PHY_BASE
 bl onenand_bl2_copy
 b after_copy
#endif

after_copy:
 ldr r0, =ELFIN_GPIO_BASE
 ldr r1, =0xC00
 str r1, [r0, #GPPDAT_OFFSET]
 
#ifdef CONFIG_ENABLE_MMU
enable_mmu:
 /* enable domain access */
 ldr r5, =0x0000ffff
 mcr p15, 0, r5, c3, c0, 0  @ load domain access register

 /* Set the TTB register */
 ldr r0, _mmu_table_base
 ldr r1, =CFG_PHY_UBOOT_BASE
 ldr r2, =0xfff00000
 bic r0, r0, r2
 orr r1, r0, r1
 mcr p15, 0, r1, c2, c0, 0

 /* Enable the MMU */
mmu_on:
 mrc p15, 0, r0, c1, c0, 0
 orr r0, r0, #1   /* Set CR_M to enable MMU */
 mcr p15, 0, r0, c1, c0, 0
 nop
 nop
 nop
 nop
#endif

skip_hw_init:

/* Set up the stack          */
stack_setup:
#ifdef CONFIG_MEMORY_UPPER_CODE
 ldr sp, =(CFG_UBOOT_BASE + CFG_UBOOT_SIZE - 0xc)
#else
 ldr r0, _TEXT_BASE  /* upper 128 KiB: relocated uboot   */
 sub r0, r0, #CFG_MALLOC_LEN /* malloc area                      */
 sub r0, r0, #CFG_GBL_DATA_SIZE /* bdinfo                        */
#ifdef CONFIG_USE_IRQ
 sub r0, r0, #(CONFIG_STACKSIZE_IRQ+CONFIG_STACKSIZE_FIQ)
#endif
 sub sp, r0, #12  /* leave 3 words for abort-stack    */

#endif

clear_bss:
 ldr r0, _bss_start  /* find start of bss segment        */
 ldr r1, _bss_end  /* stop here                        */
 mov  r2, #0x00000000  /* clear                            */

clbss_l:
 str r2, [r0]  /* clear loop...                    */
 add r0, r0, #4
 cmp r0, r1
 ble clbss_l

 ldr pc, _start_armboot

_start_armboot:
 .word start_armboot

#ifdef CONFIG_ENABLE_MMU
_mmu_table_base:
 .word mmu_table
#endif

/*
 * copy U-Boot to SDRAM and jump to ram (from NAND or OneNAND)
 * r0: size to be compared
 * Load 1'st 2blocks to RAM because U-boot's size is larger than 1block(128k) size
 */
 .globl copy_from_nand
copy_from_nand:
 mov r10, lr  /* save return address */

 mov r9, r0
 /* get ready to call C functions */
 ldr sp, _TEXT_PHY_BASE /* setup temp stack pointer */
 sub sp, sp, #12
 mov fp, #0   /* no previous frame, so fp=0 */
 mov r9, #0x1000
 bl copy_uboot_to_ram

3: tst  r0, #0x0
 bne copy_failed

 ldr r0, =0x0c000000
 ldr r1, _TEXT_PHY_BASE
1: ldr r3, [r0], #4
 ldr r4, [r1], #4
 teq r3, r4
 bne compare_failed /* not matched */
 subs r9, r9, #4
 bne 1b

4: mov lr, r10  /* all is OK */
 mov pc, lr

copy_failed:
 nop   /* copy from nand failed */
 b copy_failed

compare_failed:
 nop   /* compare failed */
 b compare_failed

/*
 * we assume that cache operation is done before. (eg. cleanup_before_linux())
 * actually, we don't need to do anything about cache if not use d-cache in U-Boot
 * So, in this function we clean only MMU. by scsuh
 *
 * void theLastJump(void *kernel, int arch_num, uint boot_params);
 */
#ifdef CONFIG_ENABLE_MMU
 .globl theLastJump
theLastJump:
 mov r9, r0
 ldr r3, =0xfff00000
 ldr r4, _TEXT_PHY_BASE
 adr r5, phy_last_jump
 bic r5, r5, r3
 orr r5, r5, r4
 mov pc, r5
phy_last_jump:
 /*
  * disable MMU stuff
  */
 mrc p15, 0, r0, c1, c0, 0
 bic r0, r0, #0x00002300 /* clear bits 13, 9:8 (--V- --RS) */
 bic r0, r0, #0x00000087 /* clear bits 7, 2:0 (B--- -CAM) */
 orr r0, r0, #0x00000002 /* set bit 2 (A) Align */
 orr r0, r0, #0x00001000 /* set bit 12 (I) I-Cache */
 mcr p15, 0, r0, c1, c0, 0

 mcr p15, 0, r0, c8, c7, 0 /* flush v4 TLB */

 mov r0, #0
 mov pc, r9
#endif
/*
 *************************************************************************
 *
 * Interrupt handling
 *
 *************************************************************************
 */
@
@ IRQ stack frame.
@
#define S_FRAME_SIZE 72

#define S_OLD_R0 68
#define S_PSR  64
#define S_PC  60
#define S_LR  56
#define S_SP  52

#define S_IP  48
#define S_FP  44
#define S_R10  40
#define S_R9  36
#define S_R8  32
#define S_R7  28
#define S_R6  24
#define S_R5  20
#define S_R4  16
#define S_R3  12
#define S_R2  8
#define S_R1  4
#define S_R0  0

#define MODE_SVC 0x13
#define I_BIT  0x80

/*
 * use bad_save_user_regs for abort/prefetch/undef/swi ...
 * use irq_save_user_regs / irq_restore_user_regs for IRQ/FIQ handling
 */

 .macro bad_save_user_regs   /* 将sp指向地址-72,然后再给sp. 也就是就空出72个字节. 72=4*13 */  
 sub sp, sp, #S_FRAME_SIZE  @ carve out a frame on current user stack
 
 /* 
 * 将r0~r12共13个寄存器的数据都转到sp上句空出的空间里面.具体过程是:先将r0中断数据转到sp指向的地
 * 址处,然后将sp调整到sp+4位置处,再将r1中的数据转过去,以此类推...
 */  
 stmia sp, {r0 - r12}   @ Save user registers (now in svc mode) r0-r12

 /*将_arboot_start标号对应的地址放入r2中 */  
 ldr r2, _armboot_start
 /*将r2的值减去CFG_MALLOC_LEN，再放入r2*/
 sub r2, r2, #(CFG_MALLOC_LEN)

 /* 将r2中的值减去CFG_GBL_DATA_SIZE+8,再放入r2*/  
 sub r2, r2, #(CFG_GBL_DATA_SIZE+8) @ set base 2 words into abort stack

 /* 将r2中的值(表示的地址)对应的开始的2个地址数据转给r2,r3中 */  
 ldmia r2, {r2 - r3}   @ get values for "aborted" pc and cpsr (into parm regs)

 /* 将sp+(S_FRAME_SIZE的值)放入r0中 */  
 add r0, sp, #S_FRAME_SIZE  @ grab pointer to old stack

 /* 将sp+(S_SP的值)放入r5中 */  
 add r5, sp, #S_SP

 /* 将lr所代表的值放入r1中 */  
 mov r1, lr

 /* 将r0~r3中的数据放入r5所表示的地址处 */  
 stmia r5, {r0 - r3}   @ save sp_SVC, lr_SVC, pc, cpsr

 /* 将sp中的值放入r0中 */  
 mov r0, sp      @ save current stack into r0 (param register)
 .endm

 .macro irq_save_user_regs

 /* 将sp指向地址减去72,然后再给sp. 也就是就空出72个字节. 72=4*13 */
 sub sp, sp, #S_FRAME_SIZE

 /* 
 * 将r0~r12共13个寄存器的数据都转到sp上句空出的空间里面.具体过程是:先将r0中断数据转到sp指向的
 * 地址处,然后将sp调整到sp+4位置处,再将r1中的数据转过去,以此类推... 
 */  
 stmia sp, {r0 - r12}   @ Calling r0-r12

 /* 将sp+S_PC的值放入r8中 */  
 add r8, sp, #S_PC   @ !!!! R8 NEEDS to be saved !!!! a reserved stack spot would be good.

 stmdb r8, {sp, lr}^   @ Calling SP, LR

 /* 将lr中的数据存入r8所表示的地址中. 实际上是r8中的值+0,还是r8中的数 */
 str lr, [r8, #0]   @ Save calling PC

 /* 将spsr中数据放入r6中 */  
 mrs r6, spsr

 /*将r6中的数据澹(cpsr)存入(r8中的值+4)所表示的地址中 注意:这里可没有改变r8中原有的值*/
 str r6, [r8, #4]   @ Save CPSR

 /* 将r0中的数据存入(r8中的值+8)所表示的地址中 */  
 str r0, [r8, #8]   @ Save OLD_R0

 /* 将sp中的值放入r0中*/  
 mov r0, sp
 .endm

 .macro irq_restore_user_regs

 /*
 * 将sp所对应的堆栈的数据送到r0~r14个寄存器中,因为lr就是r14. IA:表示先传送,再递增地址
 * (4字节递增) ^:这里不涉及R15,所以只是想告诉CPU使用的是用户模式下的寄存器r0~r14
 */  
 ldmia sp, {r0 - lr}^   @ Calling r0 - lr
 
 mov r0, r0

 /* 将sp的值(就是堆栈里面的地址)+S_PC后的新地址(当然还是堆栈里面)的数据放入lr中*/  
 ldr lr, [sp, #S_PC]   @ Get PC

 /* 将sp的值加上S_FRAME_SIZE后,再放入sp里面 */  
 add sp, sp, #S_FRAME_SIZE

  /*
  * 将lr中的值-4后,放入pc里面。 S:决定本条指令是否影响CPSR的条件标志位,这里放上s就是说该指令会
  * 影响更新CPSR的条件标志位,如没有s就不更新CPSR的条件标志位了
  */  
 subs pc, lr, #4   @ return & move spsr_svc into cpsr
 .endm

 .macro get_bad_stack   

 /* 将标号_armboot_start的对应的地址放入r13中 */  
 ldr r13, _armboot_start  @ setup our mode stack (enter in banked mode)

 /* 将r13中的值-(CFG_MALLOC_LEN)后,再放入r13中 */  
 sub r13, r13, #(CFG_MALLOC_LEN) @ move past malloc pool

 /*将r13中的值 - (CFG_GBL_DATA_SIZE+8)后，再放入r13中 */
 sub r13, r13, #(CFG_GBL_DATA_SIZE+8) @ move to reserved a couple spots for abort stack

 /* 将lr中的数据存入此时r13中所表示的地址中 */  
 str lr, [r13]   @ save caller lr in position 0 of saved stack

 /* 将spsr中的数据放入lr中 */  
 mrs lr, spsr   @ get the spsr
 
 /*将lr中的数据放入(r13中值+4)所表示的地址中*/
 str lr, [r13, #4]   @ save spsr in position 1 of saved stack

 /*将MODE_SVC放入r13寄存器*/
 mov r13, #MODE_SVC   @ prepare SVC-Mode
 @ msr spsr_c, r13

 /* 将r13中的数据放入spsr中 */  
 msr spsr, r13   @ switch modes, make sure moves will execute

 /* 将pc中的值放入lr寄存器中 */  
 mov lr, pc    @ capture return pc

 /* 将lr中的值放入pc中 s:决定指令的操作将会影响CPSR中条件标志位的值.*/
 movs pc, lr    @ jump to next instruction & switch modes.
 .endm

 .macro get_bad_stack_swi
 sub r13, r13, #4   @ space on current stack for scratch reg.
 str r0, [r13]   @ save R0's value.
 ldr r0, _armboot_start  @ get data regions start
 sub r0, r0, #(CFG_MALLOC_LEN) @ move past malloc pool
 sub r0, r0, #(CFG_GBL_DATA_SIZE+8) @ move past gbl and a couple spots for abort stack
 str lr, [r0]   @ save caller lr in position 0 of saved stack
 mrs r0, spsr   @ get the spsr
 str lr, [r0, #4]   @ save spsr in position 1 of saved stack
 ldr r0, [r13]   @ restore r0
 add r13, r13, #4   @ pop stack entry
 .endm

 .macro get_irq_stack   @ setup IRQ stack
 ldr sp, IRQ_STACK_START
 .endm

 .macro get_fiq_stack   @ setup FIQ stack
 ldr sp, FIQ_STACK_START
 .endm

/*
 * exception handlers
 */
 .align 5
undefined_instruction:
 get_bad_stack
 bad_save_user_regs
 bl do_undefined_instruction

 .align 5
software_interrupt:
 get_bad_stack_swi
 bad_save_user_regs
 bl do_software_interrupt

 .align 5
prefetch_abort:
 get_bad_stack
 bad_save_user_regs
 bl do_prefetch_abort

 .align 5
data_abort:
 get_bad_stack
 bad_save_user_regs
 bl do_data_abort

 .align 5
not_used:
 get_bad_stack
 bad_save_user_regs
 bl do_not_used

#ifdef CONFIG_USE_IRQ

 .align 5
irq:
 get_irq_stack
 irq_save_user_regs
 bl do_irq
 irq_restore_user_regs

 .align 5
fiq:
 get_fiq_stack
 /* someone ought to write a more effiction fiq_save_user_regs */
 irq_save_user_regs
 bl do_fiq
 irq_restore_user_regs

#else

 .align 5
irq:
 get_bad_stack
 bad_save_user_regs
 bl do_irq

 .align 5
fiq:
 get_bad_stack
 bad_save_user_regs
 bl do_fiq

#endif
 .align 5
.global arm1136_cache_flush
arm1136_cache_flush:
  mcr p15, 0, r1, c7, c5, 0 @ invalidate I cache
  mov pc, lr   @ back to caller

#if defined(CONFIG_INTEGRATOR) && defined(CONFIG_ARCH_CINTEGRATOR)
/* Use the IntegratorCP function from board/integratorcp/platform.S */
#elif defined(CONFIG_S3C64XX)
/* For future usage of S3C64XX*/
#else
 .align 5
.globl reset_cpu
reset_cpu:
 ldr r1, rstctl /* get addr for global reset reg */
 mov r3, #0x2 /* full reset pll+mpu */
 str r3, [r1] /* force reset */
 mov r0, r0
_loop_forever:
 b _loop_forever
rstctl:
 .word PM_RSTCTRL_WKUP

#endif

在start.s中还调用到lowlevel_init.S的 lowlevel_init,等看完芯片手册的相关部分在继续分析吧！