[转]NIOS_II的Boot过程分析
1 概述
Nios II 的boot过程要经历两个过程。
1. FPGA器件本身的配置过程。FPGA器件在外部配置控制器或自身携带的配置控制器的控制下配置FPGA的内部逻辑。如果内部逻辑中使用了Nios II，则配置完成的FPGA中包含有Nios II软核CPU。
2. Nios II本身的引导过程。一旦FPGA配置成功后，Nios II 就被逻辑中的复位电路复位，从reset地址开始执行代码。Nios II 的reset地址可以在SOPC builder的“Nios II More‘CPU’setting”页表中设置。
2 几种常见的boot方式
2.1 从EPCS串行存贮器中boot
这种boot方式，FPGA的配置数据和Nios II的程序都存放在EPCS器件中。FPGA配置数据放在最前面，程序放在后面，程序可能有多个段，每个段前面都插有一个“程序记录”。一个“程序记录”由2个32位的数据构成，一个是32位的整数，另一个是32位的地址，分别用于表示程序段本身的长度和程序段的运行时地址。这个“程序记录”用于帮助bootloader把各个程序段搬到程序执行时真正的位置。EPCS是串行存贮器，Nios II 不能直接从EPCS中执行程序，它实际上是执行EPCS控制器的片内ROM的代码（即bootloader），把EPCS中程序的搬到RAM中执行。
2.2 从外部CFI 并行flash中boot
这种boot方式还可以分为2种情况。
1. 程序直接在flash中运行。这种情况程序不需要另外的bootloader，Nios II 复位时reset地址（指向flash内部）开始执行程序，程序必须有启动代码用于搬移.rwdata段（因为.rwdata段是可读写的不能存放在flash中），同时如果.RODATA段和.EXCEPTIONS段连接时没有指定在flash中话（比如在RAM中），也会被搬到RAM中，并对.bss段清零，设置栈的指针。这些工作都在Crt0.s中完成。
2. 程序在RAM（包括On-chip Ram，SDRAM，SSRAM…泛指一般的RAM）中运行。这种情况需要有一个专门的bootloader，它把存放在flash中的各个程序段搬到程序执行时各个段真正的位置。
3 从EPCS中boot
要支持Nios II从EPCS中boot首先要求FPGA器件要支持主动串行配置。Altera的Cyclone，Cyclone II和Stratix II系列的FPGA支持主动串行配置。直到Nios II 5.1版本，Nios II 从EPCS中boot在Stratix II系列的FPGA上实现上仍有问题。所以这种方式主要用于Cyclone和Cyclone II系列的器件。
为了实现这种boot方式，用户必须在SOPC builder中添加一个EPCS控制器，无须给它分配管腿，Quartus II 会自动给它分配到专用管腿上。添完EPCS控制器后，SOPC builder会给它分配一个base address，这个地址是EPCS控制器本身携带的片上ROM在Nios II系统中的基地址，这个ROM存有一小段bootloader代码，用于引导整个过程。所以，必须在SOPC builder的“Nios II More‘CPU’setting”页表中把reset地址设置为这个基地址，使得Nios II 复位后从这个地址开始执行以完成整个引导过程。
3.1 EPCS控制器的bootloader分析
EPCS控制器带有一块片内ROM，内有Bootloader代码，Nios II 就靠这段代码完成boot过程。它把EPCS里的Nios II程序映象复制到RAM中，然后跳转到RAM中运行。由于程序映象是由elf2flash输出的，bootloader对被搬运的程序映象的位置和结构的解读必须和elf2flash工具一致。FPGA的配置数据从EPCS偏移为0的地址开始存放，紧挨着配置数据后面是一个32位的整数，指示程序段的长度，接着是一个32位的地址，指示程序执行时该程序段的地址，我们把这个长度和地址一起称为“程序记录”，“程序记录”随后就是程序段映象。一个程序可能有多个程序段，所以也就有多个“程序记录”和程序段映象。Bootloader必须知道FPGA配置数据的长度以读取配置数据后面的内容，不同型号的FPGA的配置数据长度是不同的，所以必须读取配置数据的头部信息获取配置数据的长度，进而逐个读取程序段映象的长度和运行时地址，然后把程序段映象搬到目的运行时地址。为了存取EPCS，bootloader构造了一些位置无关汇编代码。EPCS的存贮布局如下所示：
|
|
剩余空间 |
|
|
4字节的最后一个 |
|
|
0x00000000，4字节的最后一个 |
|
|
Ln个字节的第n个程序段映象 |
|
|
4字节的第n个程序段的目的地址An |
|
|
4字节的第n个程序段的长度Ln |
|
|
… |
|
|
L2个字节的第2个程序段映象 |
|
|
4字节的第2个程序段的目的地址A2 |
|
|
4字节的第2个程序段的长度L2 |
|
Length+8~length+L+7 |
L1字节的第1个程序段映象 |
|
Length+4~length+7 |
4字节的第1个程序段目的地址A1 |
|
Length~length+3 |
4字节的第1个程序段长度L1 |
|
0~length-1 |
FPGA配置数据，长度为length |
当bootloader读取到L时，L＝0，表示前面所有的程序记录已经处理完毕，这个是最后的程序记录就直接跳到地址A的地方执行。显然A必须是程序的入口地址。如果L＝0xffffffff（即-1），那么就忽略A并停机，这样，即使是一个只有FPGA配置数据而没有程序的EPCS也是安全的。当一个EPCS只有配置数据而没有程序的时候，sof2flash会在配置数据的末尾增加4个字节的0xff使bootloader不会有误动作。Bootloader的工作流程如下：
3.2 EPCS控制器
EPCS控制器手册没有对EPCS进行详细的说明只是建议用户使用Altera的HAL函数来存取。其实EPCS控制器由两个独立的部件构成：
1.Rom。大小是512个字节，也就是128 words。尽管EPCS控制器手册表述了Rom的大小是1K字节，实际上直到Nios II 5.1 EPCS控制器的Rom仍然是512个字节，因此手册中给出的寄存器偏移地址都需要修正。
2.SPI Master控制器。EPCS串行存贮器的接口符合SPI标准。Nios II 可以通过SPI Master来存取EPCS串行存贮器。这两个部件的地址（从Nios II 的角度看，以字节为单位）安排如下：
|
偏移地址 |
寄存器 |
R/W |
位描述 |
||||||||||||||||||
|
31..0 |
|||||||||||||||||||||
|
0x000 |
Boot Rom Memory |
R |
Boot Loader Code |
||||||||||||||||||
|
0x004 |
|||||||||||||||||||||
|
… |
|||||||||||||||||||||
|
0x1FC |
|||||||||||||||||||||
|
0x200 |
Rx Data |
R |
31..8 (Not Implemented) |
Rx Data(7..0) |
|||||||||||||||||
|
0x204 |
Tx Data |
W |
31..8 (Not Implemented) |
Tx Data(7..0) |
|||||||||||||||||
|
0x208 |
Status |
R/W |
31..11 |
10 |
9 |
8 |
7 |
6 |
5 |
4 |
3 |
2 |
1 |
0 |
|||||||
|
|
|
EOP |
E |
RRDY |
TRDY |
TMT |
TOE |
ROE |
|
|
|
||||||||||
|
0x20C |
Cotrol |
R/W |
31..11 |
10 |
9 |
8 |
7 |
6 |
5 |
4 |
3 |
2 |
1 |
0 |
|||||||
|
|
|
IEOP |
IE |
IRRDY |
ITRDY |
|
ITOE |
IROE |
|
|
|
||||||||||
|
0x210 |
Reserved |
- |
|
||||||||||||||||||
|
0x214 |
Slaver Enable |
R/W |
31..16 |
15 |
14 |
13 |
… |
3 |
2 |
1 |
0 |
||||||||||
|
|
SS_15 |
SS_14 |
SS_13 |
… |
SS_3 |
SS_2 |
SS_1 |
SS_0 |
|||||||||||||
|
0x218 |
End of Packet |
R/W |
31..8 (Not Implemented) |
End of character(7..0) |
|||||||||||||||||
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
l Rx Data寄存器
Nios II从Rx Data寄存器中读出从EPCS中接收到的数据。当接收移位寄存器收到满8位的数据，status寄存器的RRDY位被置1，同时数据被传入Rx Data寄存器。读取Rx Data寄存器会把RRDY位清掉，而往Rx Data写则没有影响。
l Tx Data寄存器
Nios II把要发送的数据写到Tx Data寄存器。status寄存器中的TRDY位置1表示Tx Data寄存器准备好接收来自Nios II的新数据。Tx Data被写了之后，TRDY位就被置0，直到数据从Tx Data转移到发送移位寄存器又会被重新置为1。
l Status寄存器
status寄存器包含有指示当前状态的位。几乎每一位都和control寄存器的一个中断允许位相关。Nios II任何时候都可以读取status寄存器，不会影响该寄存器的值。往status寄存器写将清除ROE，TOE和E这些位。下表描述了各个位的含义：
|
位 |
名称 |
含义 |
|
3 |
ROE |
接收溢出错误。当Rx Data寄存器数据满的时候（RRDY为1），接收移位寄存器又往Rx Data寄存器写，那ROE位将被置1。而新的数据会覆盖老的数据。往status寄存器写可以把ROE位清0。 |
|
4 |
TOE |
发送溢出错误。如果Tx Data寄存器数据还没有被转移到发送移位寄存器（TRDY为0），又往Tx Data寄存器写，那TOE就会被置为1。新的数被忽略。往status寄存器写可以清TOE为0。 |
|
5 |
TMT |
发送移位寄存器空。如果一个发送过程正在进行中，那TMT为0；如果发送移位寄存器为空，则TMT为1。 |
|
6 |
TRDY |
发送器准备好接收新的发送数据。当Tx Data寄存器空的时候，TRDY为1。 |
|
7 |
RRDY |
接收器准备好送出接收到的数。当Rx Data寄存器满的时候，RRDY为1。 |
|
8 |
E |
有错误产生。它是TOE和ROE的逻辑或。只要TOE或ROE中有一个为1，那它也为1。它给程序提供了一个判断有错误发生的方便的途径。往status寄存器写可以把E位清0。 |
|
9 |
EOP |
包结束标志。该标志在下列情况下被置1： 2. 一个EOP字节从Rx Data寄存器中读出 |
l
Control寄存器
control寄存器控制SPI Master的操作。Nios II可以在任何时候读取control寄存器而不改变它的值。大部分control寄存器的位（IROE，ITOE，ITRDY，IRRDY和IE）控制status寄存器相应位的中断。比如当IROE设为1，就允许当status中的ROE为1时产生中断。只有当control寄存器和stauts寄存器中的相应位都为1的情况下，SPI
Master才会产生中断。
|
位 |
名称 |
含义 |
|
3 |
IROE |
允许ROE条件满足时产生中断。 |
|
4 |
ITOE |
允许TOE条件满足时产生中断。 |
|
6 |
ITRDY |
允许TRDY条件满足时产生中断。 |
|
7 |
IRRDY |
允许RRDY条件满足时产生中断。 |
|
8 |
IE |
允许E条件满足时产生中断。 |
|
9 |
IEOP |
允许EOP条件满足时产生中断。 |
|
10 |
SSO |
强制slave enable寄存器器中为1的位对应的ss_n有效，即输出电平0。 |
l
Slave enable寄存器
slave enable寄存器中的某一位置1表示相应的ss_n信号可以被驱动有效（即在control寄存器中写SSO位为1，或者有数据写入Tx Data寄存器准备开始传送数据）。Slave enable寄存器可以多位为1，但是需要有其它逻辑来处理多个SPI slave的冲突问题。
l
End of Packet寄存器
End of Packet寄存器包含End of Character，当某一Avalon master读出的Rx Data寄存器字节和End of Character一样，或者写入Tx Data的字节和End
of Character一样时，SPI Master产生EOP标志。如果该Avalon master支持endofpacket信号，则会中断传输。
EPCS控制器在例化SPI Master时使用下列参数：数据位8位；SPI时钟SCLK频率20MHz；MOSI（ASDO）在SCLK的下降沿处输出；MISO（DATA0）在SCLK上升沿处采样；SCLK的初始相位为0；MSB先输出，LSB后输出；目标延迟100us（即ss_n输出为低到SCLK开始驱动输出时钟脉冲的延迟为100us）。
3.3 EPCS串行存贮器件
Altera的器件手册对EPCS器件有完整清楚的表述。在read byte，read status和read silicon ID操作时，发出命令后，所要的数据会马上从EPCS的DATA管腿移出。所以EPCS控制在发出命令后继续发送虚拟数据（比如0或随便什么值），在发送虚拟数据的同时接收EPCS送出的数据，就可以获取所要的数据。SPI接口的发送和接收是同时的，为了接收数据，你必须发送点什么，尽管这些数据是对方不需要的，同样在你发送命令或数据的同时也会收到点什么，尽管这些也不一定是你需要的。
4 从并行flash中boot
4.1 并行flash配置控制器
Nios II应用常常把Nios II 程序和FPGA配置数据都存放在flash中。这就需要一个配置控制器来驱动flash输出配置数据完成FPGA的配置。配置控制器可以用一片CPLD来实现。Flash除了可以存贮FPGA配置数据和Nios II程序外还可以存贮其它数据（比如只读文件系统）。Flash中的配置数据区还可以分为两个区，一个用于用户逻辑，另一个用于出厂逻辑。当用户逻辑配置失败后，就会自动使用出厂逻辑，保证任何时候都有一个配置可以工作。另外，配置控制器还可以接收来自Nios II 的重配置请求，并驱动FPGA重新配置，完成FPGA的现场升级。Stratix开发板的配置控制安排偏移量为0的地方存放Nios II程序，而FPGA用户配置逻辑从偏移量0x600000开始，出厂配置则从偏移量0x700000开始。
Stratix开发板的并行flash配置控制器其实是一个地址序列生成器，地址生成器的输入时钟是板上时钟的4分频（比如，板上的晶振时钟是50MHz，则地址生成器的时钟就是12.5MHz）。上电的时候，由上电复位芯片提供的复位信号复位，地址生成器初始化为用户逻辑的配置数据的偏移量（比如Stratix板是0x600000），然后开始计数并驱动地址由低往高增长，使flash送出对应地址的配置数据。配置控制器监测FPGA的config_done信号，一旦发现FPGA配置完成就停止计数，并置flash的地址和其它控制线为高阻，以免影响Nios II对flash的操作。FPGA配置完成后，内部逻辑开始生效，复位Nios II，Nios II开始从reset地址执行程序。
4.2 直接在Flash中运行程序
嵌入式应用有时希望程序能够直接在flash中运行，以节约RAM空间，降低成本。为了使程序直接在flash中运行，可以在SOPC builder中设置reset地址在flash中，连接程序的时候可以指定程序的.TEXT段和.RODATA段存放在flash中，而让.RWDATA和堆栈放在RAM中（这2个段都是可读写的，不能放在flash中）。同时还可以在SOPC builder中指定exception地址到flash中，也可以节约一点RAM空间。由于最后的flash映象文件.flash文件（.flash文件其实是.srec格式的文件）中没有bss段，所以程序的开始必须在RAM中建立bss段并清0，同时也把.RWDATA段从flash中拷贝到RAM中（.RWDATA段在程序运行的时候必须在RAM中），并设置好栈，建立好C程序的工作环境然后调用C用户入口函数。这些工作都是由Crt0.s来完成的。下面是Crt0.s在flash中运行的工作流程：
4.3 在RAM中运行程序
程序在flash运行通常比在RAM中慢，所以有时也希望程序能够在RAM中运行。Nios II的reset地址仍然指向flash中（reset地址不能指向RAM，RAM在上电复位时还没有被初始化），在连接程序的时候可以把每个段都指定到RAM中，在SOPC builder中也可以把exception部分指定到RAM中。这样连接生成的可执行文件.elf文件就是适合在RAM中运行的程序。但在实际应用中这个程序最终存放在flash中，所以需要有一段bootloader代码，用于把flash中的程序映象拷贝到RAM中运行。工具elf2flash能够根据情况自动给你的程序在生成.flash文件时添加“程序记录”和bootloader。elf2flash判断其后随参数reset地址（就是Nios II的reset地址）和程序的入口地址是不是一样，如果一样就不添加“程序记录”和bootloader，如果不一样就添加。这个bootloader根据各个“程序记录”把程序映象拷贝到到RAM中并从RAM中执行。和EPCS一样，每个“程序记录”由两个32位的数据组成，一个是程序的长度，一个目的执行地址（即程序的运行地址）。Stratix 开发板上flash中的存贮分布如下：
|
0x700000~0x7FFFFF |
出厂逻辑Safe Logic |
|
0x600000~0x6FFFFF |
用户逻辑User Logic |
|
|
剩余空间 |
|
|
4字节的最后一个 |
|
|
0x00000000，4字节的最后一个 |
|
|
Ln个字节的第n个程序段映象 |
|
|
4字节的第n个程序段的目的地址An |
|
|
4字节的第n个程序段的长度Ln |
|
|
… |
|
|
L2个字节的第2个程序段映象 |
|
|
4字节的第2个程序段的目的地址A2 |
|
|
4字节的第2个程序段的长度L2 |
|
Length+8~length+L+7 |
L1字节的第1个程序段映象 |
|
Length+4~length+7 |
4字节的第1个程序段的目的地址A1 |
|
Length~length+3 |
4字节的第1个程序段的长度L1 |
|
0~length-1 |
Bootloader |
Bootloader的工作流程如下：
运行完bootloader后仍然要执行Crt0.s，但此时Crt0.s的流程和程序在flash中直接运行的情况有一些区别：它没有初始化指令cache，也不会企图去装载别的段，这些步骤已经在bootloader中完成。程序映象已经包含这些段，在搬移程序映象的同时也装载了相应的段（.RODATA段，.RWDATA段和.EXCEPTIONS段），程序映象中不包含.bss段和栈，所以仍然需要清.bss段以及设置栈指针和全局指针。Bootloader没有存取存贮器数据，因此没有初始化数据cache，所以Crt0.s仍然要初始化数据cache。
5 Bootloader解读
Altera提供了两个bootloader程序，一个用于从EPCS器件中boot，另一个用于从flash器件中boot。它们的汇编源码和makefile都在C:\altera\kits\nios2_51\components\altera_nios2\sdk\src\boot_loader_sources目录中。其中boot_loader.s是公共部分，而boot_loader_epcs_bits.s则用于从EPCS器件中Boot，boot_loader_cfi_bits.s用于从flash中Boot。
5.1 boot_loader.s解读
View Code
1 #ifdef EPCS 2 #define FIND_PAYLOAD sub_find_payload_epcs // 查找EPCS中数据负荷子程序 3 #define READ_INT sub_read_int_from_flash_epcs // 从EPCS中读取一个32位word 4 #define STREAMING_COPY sub_streaming_copy_epcs // 从EPCS中拷贝流的子程序 5 #define CLOSE_DEVICE sub_epcs_close // 关闭EPCS器件的子程序 6 #else 7 #define FIND_PAYLOAD sub_find_payload_cfi // 查找CFI并行flash中数据负荷的子程序 8 #define READ_INT sub_read_int_from_flash_cfi // 从CFI并行flash中读取一个32位的word 9 #define STREAMING_COPY sub_streaming_copy_cfi // 从CFI并行flash中拷贝流的子程序 10 #endif 11 12 #include "boot_loader.h" 13 .global reset 14 .global _start 15 .global main 16 .global end_of_boot_copier 17 18 reset: 19 _start: 20 main: 21 // 清除CPU的状态寄存器禁止中断，这个动作在硬件复位的时候其实已经自动完成。. 22 wrctl status, r_zero 23 // 冲刷指令cache. 24 // Nios II 最多支持64Kbytes的指令cache，所以只初始化了64Kbytes的指令cache 25 movhi r_flush_counter,%hi(0x10000) 26 cache_loop: 27 initi r_flush_counter 28 // 没有必要初始化数据cache, bootloader不存取存贮器数据 29 addi r_flush_counter, r_flush_counter,-32 30 bne r_flush_counter, r_zero, cache_loop 31 // 冲刷流水线 32 flushp 33 34 // r_flash_ptr = find_payload(); 35 // 调用查找数据负荷子程序寻找数据负荷 36 nextpc return_address_less_4 37 br FIND_PAYLOAD 38 // 拷贝. 39 // 40 // 在循环的开始，寄存器r_flash_ptr 包含“程序记录”的地址。 41 // 42 // 1) 读取“程序记录”的长度域（4-bytes）(r_data_size) 43 // 2) 读取“程序记录”的目的地址域（4-bytes）(r_dest) 44 // 3) 循环: 45 // 拷贝 r_data_size 个字节, 一次一个字节: *r_dest++ = *r_flash_ptr++ 46 47 // 把0xFFFFFFFF装入r_halt_record，用于测试是否要停机。 48 subi r_halt_record, r_zero, 1 49 50 per_record_loop: 51 //读取“程序记录”的长度域，r_data_size = READ_INT(r_flash_ptr++)。 52 nextpc return_address_less_4 53 br READ_INT 54 mov r_data_size, r_read_int_return_value 55 56 // 读取“程序记录”的目的地址域，r_dest = READ_INT(r_flash_ptr++)。 57 nextpc return_address_less_4 58 br READ_INT 59 mov r_dest, r_read_int_return_value 60 61 // 测试长度域是否为0 62 // 如果是就直接运行程序 63 beq r_data_size, r_zero, last_program_record 64 // 如果长度域为-1（0xFFFFFFFF），就停机。 65 halt_record_forever: 66 beq r_data_size, r_halt_record, halt_record_forever 67 // 使用拷贝流子程序搬移数据 68 nextpc return_address_less_4 69 br STREAMING_COPY 70 // 程序运行到这里，表明已经处理了当前的“程序记录”了， 71 // 而且知道这不是最后一个“程序记录”因为它的长度域不为0， 72 // 这就意味着要处理下一个“程序记录”。 73 br per_record_loop 74 last_program_record: 75 // 处理完最后一个程序记录后就要把控制权转给实际的运行程序. 76 // r_dest是实际程序的入口地址 77 // 在中止boot-loader之前要关闭EPCS器件，如果不做这一步， 78 // 会导致HAL的open()调用要花好几秒钟才能打开EPCS器件 79 #ifdef EPCS 80 nextpc return_address_less_4 81 br CLOSE_DEVICE 82 #endif 83 // 跳转到目的地址运行程序 84 callr r_dest 85 afterlife: // 程序跑到这里表明有问题。 86 br afterlife 87 .end
5.2 boot_loader_epcs_bits.s解读
View Code
1 // 从EPCS串行flash设备读取字节的子过程 2 // 通过寄存器和EPCS打交道获取字节数 3 #include "boot_loader.h" 4 .global sub_find_payload_epcs 5 .global sub_read_int_from_flash_epcs 6 .global sub_streaming_copy_epcs 7 .global sub_epcs_close 8 // EPCS控制和状态寄存器的偏移量 9 #define EPCS_RXDATA_OFFSET 0x00 10 #define EPCS_TXDATA_OFFSET 0x04 11 #define EPCS_STATUS_OFFSET 0x08 12 #define EPCS_CONTROL_OFFSET 0x0C 13 // EPCS的位掩码 14 #define EPCS_STATUS_TMT_MASK 0x20 15 #define EPCS_STATUS_TRDY_MASK 0x40 16 #define EPCS_STATUS_RRDY_MASK 0x80 17 #define EPCS_CONTROL_SSO_MASK 0x400 18 // EPCS命令 19 #define EPCS_COMMAND_READ 0x03 20 .text 21 // 22 // 查找EPCS的数据负荷 23 // 24 // 过程： 25 // - 在偏移量为0的地方打开EPCS器件（FPGA配置数据在这里） 26 // - 分析配置数据获取数据负荷开始的地址 27 // - 关闭EPCS 28 // - 在数据负荷的开始的地址再次打开EPCS 29 // 30 sub_find_payload_epcs: 31 // 修正并存贮返回地址 32 addi r_findp_return_address, return_address_less_4, 4 33 // 34 // 计算EPCS控制/状态寄存器块的地址 35 // 它在离本段代码的开头偏移量为512个字节的地方 36 // 因为这段代码必须在512字节边界处， 37 // 我们简单地把当前地址园整到下一个512个地址的边界。 38 // 39 // | 40 // | 为了调试，你可以定义EPCS_REGS_BASE 41 // | 作为EPCS寄存器基地址。否则就假设下一个512字节边界。 42 // | 43 nextpc r_findp_temp 44 #ifdef EPCS_REGS_BASE 45 movhi r_epcs_base_address, %hi(EPCS_REGS_BASE) 46 addi r_epcs_base_address, r_epcs_base_address, %lo(EPCS_REGS_BASE) 47 #else 48 ori r_epcs_base_address, r_findp_temp, 511 49 addi r_epcs_base_address, r_epcs_base_address, 1 50 #endif 51 // 52 // 在偏移量为0的地方打开EPCS器件 53 // 54 movi r_flash_ptr, 0 55 nextpc return_address_less_4 56 br sub_epcs_open_address 57 // 58 // 分析器件配置数据顺序读出字节直到下面任一个条件满足 59 // 1) 我们找到0xA6 （其实应该是0x56，因为我们没有把位序颠倒过来） 60 // 当我们找到它时表示我们找到配置数据，可以接着算出它的长度。 61 // 2) 我们找到不是xFF字节，在这种情况我们根本没有在配置数据里查找 62 // 我们假定我一定是在一个boot loader记录。跳过整个配置数据长度的计算 63 // 开始装载。 64 // 3) 我们在任意长的时间内找到的都是0xFF。我们猜测flash是空的没有其它可利用资源 65 // 66 // 搜索随意的一大块字节 67 movi r_findp_count, 0x400 68 // 我们要找的模板是0x56 69 movi r_findp_pattern, 0x56 70 // 在我们找到0x56之前唯一可以接受的字节是0xFF 71 movi r_findp_temp, 0xFF 72 fp_look_for_56_loop: 73 nextpc return_address_less_4 74 br sub_read_byte_from_flash_epcs 75 // 我们发现模板了吗？ 76 beq r_read_byte_return_value, r_findp_pattern, fp_found_sync 77 // 我们发现非0xFF的字节了吗？ 78 bne r_read_byte_return_value, r_findp_temp, fp_short_circuit 79 // 更新循环计数器开始循环 80 subi r_findp_count, r_findp_count, 1 81 bne r_findp_count, r_zero, fp_look_for_56_loop 82 // 我们没有找到模板或其它匹配的字节，挂起。 83 // 先关闭EPCS器件 84 nextpc return_address_less_4 85 br sub_epcs_close 86 fp_hang: 87 br fp_hang 88 fp_found_sync: 89 // 同步模板后面紧跟着的4个字节是我们感兴趣 90 nextpc return_address_less_4 91 br sub_read_int_from_flash_epcs 92 // 这4个字节是配置的长度，它们的字节顺序是little-endian，但位序是反的。 93 nextpc return_address_less_4 94 br sub_read_int_from_flash_epcs 95 // 把长度放到r_flash_ptr 中 96 mov r_flash_ptr, r_read_int_return_value 97 // 此时我们获得了长度但是在EPCS器件中Quarts 98 // 以相反的位序存贮字节 99 // 100 // 我们先把4位组反过来，再把2位组反过来，然后再把所有的位反过来。 101 // 就象这样： 102 // 103 // 76543210 – 4位组反序--> 32107654 – 两位组反序 --> 10325476 – 位反序 --> 01234567 104 // 105 // 下面是整个循环的进行机制 106 // 你会注意到这个反序过程只展示了一次 107 // 不用担心，所有的字节都会被反序 108 // 109 // ("x" == unknown, "." == zero) 110 // 111 // byte temp mask count 112 // -------- -------- -------- ----- 113 // 初始态 76543210 xxxxxxxx 00001111 4 114 // 115 // 1 temp = byte & mask 76543210 ....3210 00001111 4 116 // 2 temp <<= count 76543210 3210.... 00001111 4 117 // 3 byte >>= count xxxx7654 3210.... 00001111 4 118 // 4 byte &= mask ....7654 3210.... 00001111 4 119 // 5 byte |= temp 32107654 3210.... 00001111 4 120 // 6 count >>= 1 32107654 3210.... 00001111 2 121 // 7 temp = mask << count 32107654 00111100 00001111 2 122 // 8 mask ^= temp 32107654 00111100 00110011 2 123 // 124 // loop on (count != 0) 125 // 126 // temp = byte & mask 32107654 ..10..54 00110011 2 127 // temp <<= count 32107654 10..54.. 00110011 2 128 // byte >>= count xx321076 10..54.. 00110011 2 129 // byte &= mask ..32..76 10..54.. 00110011 2 130 // byte |= temp 10325476 10..54.. 00110011 2 131 // count >>= 1 10325476 10..54.. 00110011 1 132 // temp = mask << count 10325476 01100110 00110011 1 133 // mask ^= temp 10325476 01100110 01010101 1 134 // 135 // loop on (count != 0) 136 // 137 // temp = byte & mask 10325476 .0.2.4.6 01010101 1 138 // temp <<= count 10325476 0.2.4.6. 01010101 1 139 // byte >>= count x1032547 0.2.4.6. 01010101 1 140 // byte &= mask .1.3.5.7 0.2.4.6. 01010101 1 141 // byte |= temp 01234567 0.2.4.6. 01010101 1 142 // count >>= 1 01234567 0.2.4.6. 01010101 0 143 // temp = mask << count 01234567 01010101 01010101 0 144 // mask ^= temp 01234567 01010101 00000000 0 145 // 146 // 初始化mask 147 movhi r_revbyte_mask, 0x0F0F 148 addi r_revbyte_mask, r_revbyte_mask, 0x0F0F 149 // 装入count 150 movi r_findp_count, 4 151 fp_reverse_loop: 152 // 屏蔽高一半的位把结果装入TEMP寄存器 153 and r_findp_temp, r_flash_ptr, r_revbyte_mask // 1 154 // 把TEMP中的位左移4位 155 sll r_findp_temp, r_findp_temp, r_findp_count // 2 156 // 把PTR中字节右移4位 157 srl r_flash_ptr, r_flash_ptr, r_findp_count // 3 158 // 屏蔽掉高4位 159 and r_flash_ptr, r_flash_ptr, r_revbyte_mask // 4 160 // 把PTR和TEMP中的位组合起来 161 or r_flash_ptr, r_flash_ptr, r_findp_temp // 5 162 // 更新移位计数器 163 srli r_findp_count, r_findp_count, 1 // 6 164 // 左移MASK 2位 165 sll r_findp_temp, r_revbyte_mask, r_findp_count // 7 166 // 更新MASK 167 xor r_revbyte_mask, r_revbyte_mask, r_findp_temp // 8 168 // 循环直到移位计数器为0 169 bne r_findp_count, r_zero, fp_reverse_loop 170 // 171 // 这个长度是以位为单位的长度，把它圆整到以字节为单位的长度。 172 // 173 addi r_flash_ptr, r_flash_ptr, 7 // r_flash_ptr += 7 174 srli r_flash_ptr, r_flash_ptr, 3 // r_flash_ptr /= 8; 175 fp_short_circuit: 176 // 关闭EPCS器件 177 nextpc return_address_less_4 178 br sub_epcs_close 179 // 重新打开EPCS器件(at r_flash_ptr) 180 nextpc return_address_less_4 181 br sub_epcs_open_address 182 jmp r_findp_return_address 183 //////// 184 // EPCS_Open_Address 185 // 186 // 打开EPCS器件以便于我们读取给定地址开始的字节流 187 // 地址在r_flash_ptr给出 188 // 189 // 这只是一个sub_tx_rx_int_epcs 子过程的头部 190 // 没有必要修正返回地址，相反它直接跳转到sub_tx_rx_int_epcs 191 // 然后让子过程返回到原来的调用者那里。 192 // 193 // 寄存器用法： 194 // 参数： r_flash_ptr 195 // 临时寄存器： r_eopen_eclose_tmp 196 // 返回值： --none-- 197 // 198 sub_epcs_open_address: 199 // 不需要修正返回地址，这只是一个子过程的头部 200 // 通过控制寄存器使能EPCS器件的片选 201 movi r_eopen_eclose_tmp, EPCS_CONTROL_SSO_MASK 202 stwio r_eopen_eclose_tmp, EPCS_CONTROL_OFFSET (r_epcs_base_address) 203 // 把读命令送入既定的寄存器中 204 movhi r_epcs_tx_value, (EPCS_COMMAND_READ << 8) 205 // 把flash指针送入低24位中 206 or r_epcs_tx_value, r_epcs_tx_value, r_flash_ptr 207 // 跳转到sub_tx_rx_int 子过程 208 br sub_tx_rx_int_epcs 209 // 现在EPCS器件已经在r_flash_ptr处打开 210 211 //////// 212 // 关闭EPCS 213 // 214 // 终止当前的EPCS事务 215 // 216 sub_epcs_close: 217 // 修正返回地址 218 addi return_address_less_4, return_address_less_4, 4 219 // 等待控制器说发送器空 220 close_ready_loop: 221 ldwio r_eopen_eclose_tmp, EPCS_STATUS_OFFSET (r_epcs_base_address) 222 andi r_eopen_eclose_tmp, r_eopen_eclose_tmp, EPCS_STATUS_TMT_MASK 223 beq r_eopen_eclose_tmp, r_zero, close_ready_loop 224 // 清除SSO位释放CS 225 stwio r_zero, EPCS_CONTROL_OFFSET (r_epcs_base_address) 226 // 返回 227 jmp return_address_less_4 // 我们已经修复了返回地址 228 229 //////// 230 // sub_read_int_from_flash_epcs 231 // 232 // epcs_rx_tx的另外一个入口 233 // 234 // 在进入sub_tx_rx_int_epcs先把epcs_tx_value清0 235 // 236 sub_read_int_from_flash_epcs: 237 // 这个子过程读取EPCS器件的下一个32位word， 238 // 假设一个有效的读命令和地址已经发出去，片选也是使能的 239 // 给发送的内容清0。 240 // 241 mov r_epcs_tx_value, r_zero 242 // 243 // 进入sub_tx_rx_int_epcs子过程 244 // 245 //////// 246 // sub_tx_rx_int_epcs 247 // 248 // 这个子过程往flash写4个字节同时也读回4个字节 249 // 这4个字节没有什么地址对齐的限制 250 // 这个子过程写的时候是高位在先，读的时候是低位在先 251 // 因为EPCS处理命令的时候是高位在先，但是SOF文件的 252 // 编码却是低位在先 253 // 254 // 这个子过程和tx_rx_byte共享输入参数 255 // 只要tx_rx_byte 不破坏它的输入参数， 256 // 那这么做就是安全的。 257 // 258 // 寄存器用法： 259 // 入口参数： r_epcs_tx_value 260 // 局部变量： r_trie_count 261 // 局部返回指针： r_riff_return_address 262 // 返回的值： r_read_int_return_value 263 // 264 sub_tx_rx_int_epcs: 265 // 修正返回地址 266 addi r_riff_return_address, return_address_less_4, 4 267 // 268 // 写（高位在先）然后读（低位在先） 269 // 270 // 清楚返回的值 271 mov r_read_int_return_value, r_zero 272 // 发送/接收的字节数 273 movi r_trie_count, 4 274 trie_loop: 275 // 定位发送字节，使符合参数格式要求 276 roli r_epcs_tx_value, r_epcs_tx_value, 8 277 // 发送/接收一个字节 278 nextpc return_address_less_4 279 br sub_tx_rx_byte_epcs 280 // 把它反在结果寄存器的低位字节 281 or r_read_int_return_value, r_read_int_return_value, r_read_byte_return_value 282 // 循环移位结果寄存器以便于最后一个字节在高位字节 283 // 把其它字节移到低位字节 284 roli r_read_int_return_value, r_read_int_return_value, 24 285 // 计数器减1，继续循环。 286 subi r_trie_count, r_trie_count, 1 287 bne r_trie_count, r_zero, trie_loop 288 // 返回 289 jmp r_riff_return_address 290 //////// 291 // sub_read_byte_from_flash_epcs 292 // 293 // epcs_rx_tx.的另一个入口 294 // 295 // 在进入epcs_tx_rx 之前把epcs_tx_value清0 296 // 297 sub_read_byte_from_flash_epcs: 298 // 该过程读取EPCS器件的下一个字节， 299 // 假设一个读命令和地址已经发送，片选也已经使能。 300 // 301 // 只要发送0给器件，我们就能收到下一个字节。 302 // 303 mov r_epcs_tx_value, r_zero 304 // 305 // 进入sub_tx_rx_byte_epcs子过程 306 // 307 308 //////// 309 // sub_tx_rx_byte_epcs 310 // 311 // EPCS器件很有趣，每次你发送一些东西，同时也会收到东西。 312 // 每次你想收到东西，你就必须发送一些东西。 313 // 这个子过程把它的入口参数内容发送给EPCS, and returns whatever was 314 // 然后返回它从EPCS获取的值。 315 // 316 // 寄存器用法： 317 // 输入参数： r_epcs_tx_value 318 // 临时寄存器： rf_temp 319 // 返回值： r_read_byte_return_value 320 // 321 sub_tx_rx_byte_epcs: 322 // 修正返回地址Fix-up return-address (NOTE: LEAF) 323 addi return_address_less_4, return_address_less_4, 4 324 // 等待控制器准备好接收TX字节，然后发送它。 325 tx_ready_loop: 326 ldwio rf_temp, EPCS_STATUS_OFFSET (r_epcs_base_address) 327 andi rf_temp, rf_temp, EPCS_STATUS_TRDY_MASK 328 beq rf_temp, r_zero, tx_ready_loop 329 stwio r_epcs_tx_value, EPCS_TXDATA_OFFSET (r_epcs_base_address) 330 // 等待从EPCS接收的字节有效，然后获取它。 331 rx_ready_loop: 332 ldwio rf_temp, EPCS_STATUS_OFFSET (r_epcs_base_address) 333 andi rf_temp, rf_temp, EPCS_STATUS_RRDY_MASK 334 beq rf_temp, r_zero, rx_ready_loop 335 ldbuio r_read_byte_return_value, EPCS_RXDATA_OFFSET (r_epcs_base_address) 336 // 返回 337 jmp return_address_less_4 // 返回地址已被修正 338 339 //////// 340 // 流拷贝 341 // 342 // 拷贝r_data_size字节，从r_flash_ptr到r_dest。 343 // 344 // 寄存器用法： 345 // 参数：r_data_size – 要拷贝的字节数 346 // 参数：r_dest - 拷贝的目的地址 347 // 隐含条件： r_flash_ptr – 拷贝的源地址 348 // 临时寄存器： rf_temp 349 // 返回值：无 350 // 351 // 所有参数在子过程中都会被破坏 352 // 353 // Note: we don't keep the flash ptr up to date. Instead 354 // we just keep streaming from the EPCS device 355 // 356 sub_streaming_copy_epcs: 357 // 修正返回地址 (NOTE: LEAF) 358 addi return_address_less_4, return_address_less_4, 4 359 // 为了更好的可读性，给r_data_size再定义一个别名 360 #define r_dest_end r_data_size 361 // 通过长度计算结束地址 362 add r_dest_end, r_data_size, r_dest 363 subi r_dest_end, r_dest_end, 1 364 // 等待EPCS控制器准备好接收TX字节 365 epcs_copy_initial_wait: 366 ldwio rf_temp, EPCS_STATUS_OFFSET (r_epcs_base_address) 367 andi rf_temp, rf_temp, EPCS_STATUS_TRDY_MASK 368 beq rf_temp, r_zero, epcs_copy_initial_wait 369 // 给EPCS送0 370 stwio r_zero, EPCS_TXDATA_OFFSET (r_epcs_base_address) 371 // 372 // do { 373 // *r_dest++ = (char*)r_flash_ptr++) 374 // while (r_dest <= r_dest_end); 375 // 376 epcs_copy_loop: 377 // 等待读取的字节有效 378 ldwio rf_temp, EPCS_STATUS_OFFSET (r_epcs_base_address) 379 andi rf_temp, rf_temp, EPCS_STATUS_RRDY_MASK 380 beq rf_temp, r_zero, epcs_copy_loop 381 // 读取EPCS的一个字节，并立即要求下一个字节 382 // 不必等待TX准备好，如果RX准备好了TX也一样。 383 ldwio rf_temp, EPCS_RXDATA_OFFSET (r_epcs_base_address) 384 stwio r_zero, EPCS_TXDATA_OFFSET (r_epcs_base_address) 385 // 存贮读到的字节，并更新目的地址指针 386 stbio rf_temp, 0(r_dest) 387 addi r_dest, r_dest, 1 388 // 循环直到目的地址指针指向结束地址 389 bne r_dest, r_dest_end, epcs_copy_loop 390 epcs_copy_last_wait: 391 // 等待最后读取的字节有效 392 ldwio rf_temp, EPCS_STATUS_OFFSET (r_epcs_base_address) 393 andi rf_temp, rf_temp, EPCS_STATUS_RRDY_MASK 394 beq rf_temp, r_zero, epcs_copy_last_wait 395 // 读取最后一个字节 396 ldwio rf_temp, EPCS_RXDATA_OFFSET (r_epcs_base_address) 397 // 存贮最后一个字节 398 stbio rf_temp, 0(r_dest) 399 // 返回 400 jmp return_address_less_4 // Don't worry--we fixed it. 401 // 文件结束
5.3 boot_loader_cfi_bits.s解读
View Code
1 #include "boot_loader.h" 2 .global sub_find_payload_cfi // 查找数据负荷的子程序 3 .global sub_read_int_from_flash_cfi // 从CFI并行flash中读取32位word的子程序 4 .global sub_streaming_copy_cfi // 从CFI并行flash中拷贝流的子程序 5 //////// 6 // Read_Int_From_Flash_CFI 7 // 8 // 伪子程序，它从flash中读取4个字节并把它们拼起来形成一个整数 9 // 这4个字节没有地址对齐的要求 10 // 寄存器用法: 11 // 内部变量: r_riff_count 12 // 内部指针: r_riff_return_address 13 // 返回值: r_read_int_return_value 14 // 15 sub_read_int_from_flash_cfi: 16 // 修正中断返回地址，即在返回地址寄存器上加4 17 addi r_riff_return_address, return_address_less_4, 4 18 // 19 // 读取字节然后把它们移进返回寄存器中 20 // 21 // 先对返回寄存器清0 22 mov r_read_int_return_value, r_zero 23 // 返回的字节数 24 movi r_riff_count, 4 25 riffc_loop: 26 // 返回一个字节并泵进一下r_flash_ptr 27 ldbuio r_read_byte_return_value, 0(r_flash_ptr) 28 addi r_flash_ptr, r_flash_ptr, 1 29 // 把它以逻辑或运算的方式送入结果寄存器的低位字节 30 or r_read_int_return_value, r_read_int_return_value, r_read_byte_return_value 31 // 循环左移结果寄存器使最后一个字节在高位字节, 32 // 把其它字节移到低位字节 33 roli r_read_int_return_value, r_read_int_return_value, 24 34 // 计数器减1并循环 35 subi r_riff_count, r_riff_count, 1 36 bne r_riff_count, r_zero, riffc_loop 37 // 返回. 38 jmp r_riff_return_address 39 40 //////// 41 // 流拷贝 42 // 43 // 拷贝 r_data_size 字节从r_flash_ptr 到 r_dest 44 // 45 // 寄存器用法: 46 // 参数: r_data_size 要拷贝的字节数 47 // 参数: r_dest 拷贝的目的地址 48 // 隐含的寄存器参数: r_flash_ptr 拷贝的源地址 49 // 临时寄存器: rf_temp 50 // 返回值: 无 51 // 52 // 所有的参数寄存器都会在这个子过程中被破坏 53 // 54 sub_streaming_copy_cfi: 55 // 修正返回地址 (NOTE: LEAF) 56 addi return_address_less_4, return_address_less_4, 4 57 // 为更好的可读性，给同一个寄存器定义了两个别名。 58 #define r_dest_end_plus_one r_data_size 59 // 把长度转化成结束地址加1 60 add r_dest_end_plus_one, r_data_size, r_dest 61 // 62 // do { 63 // *r_dest++ = (char*)r_flash_ptr++) 64 // while (r_dest != r_dest_end_plus_one); 65 // 66 cfi_copy_loop: 67 ldbuio rf_temp, 0(r_flash_ptr) 68 addi r_flash_ptr, r_flash_ptr, 1 69 stbio rf_temp, 0(r_dest) 70 addi r_dest, r_dest, 1 71 // 循环直到目的地址destination == 1 + 结束地址 72 bne r_dest, r_dest_end_plus_one, cfi_copy_loop 73 // Return 74 jmp return_address_less_4 // 不用担心，我们已经修正了它的值。. 75 //////// 76 // 查找数据负荷 77 // 把数据负荷的第一个字节的偏移量送到r_flash_ptr返回。 78 // CFI: 79 // 数据负荷紧挨着boot-copier的后面存放，使用一些nextpc 这些位置无关 80 // 的指令来查找。 81 sub_find_payload_cfi: 82 // 修正并存贮返回地址 83 addi r_findp_return_address, return_address_less_4, 4 84 nextpc r_flash_ptr 85 payload_offset_base: 86 addi r_flash_ptr, r_flash_ptr, (end_of_boot_copier - payload_offset_base) 87 // 找到数据负荷r_flash_ptr现在包含有数据负荷的地址。 88 jmp r_findp_return_address 89 // 90 // 对于一个基于flash的启动代码，我们把它放在 91 // |reset地址，然后把数据紧挨着它存放，end_of_boot_copier 92 // 就是数据负荷的地址。 93 end_of_boot_copier: 94 // 数据在这里。 95 .end
6 Crt0.s解读
Nios II c程序在运行之前需要做一些初始化工作。如果程序直接从falsh中运行则Crt0.s是最先执行的代码，如果程序不是直接从flash中运行则Crt0.s是执行完bootloader后最开始执行的代码。
View Code
1 2 #include "nios2.h" 3 #include "system.h" 4 /* 5 * 宏ALT_LOAD_SECTIONS用于"run from flash"模式。它用于确定 6 * 是否有section（.RODATA段，.RWDATA段或.EXCEPTIONS段） 7 * 需要从flash装到RAM中。如果有的话就调用函数alt_load()加以装载。 8 */ 9 #define __ALT_LOAD_SECTIONS(res, text, rodata, exc) \ 10 ((res##_BASE != rodata##_BASE) || \ // 如果复位地址和.RODATA段，.RWDATA段 11 (res##_BASE != rwdata##_BASE) || \ // 或.EXCEPTIONS段所在存贮器基地址不同， 12 (res##_BASE != exc##_BASE)) // 则表明需要装载。符号“＃＃”用于拼接两个名字。 13 #define _ALT_LOAD_SECTIONS(res, text, rodata, exc) \ 14 __ALT_LOAD_SECTIONS(res, text, rodata, exc) 15 #define ALT_LOAD_SECTIONS _ALT_LOAD_SECTIONS(ALT_RESET_DEVICE, \ 16 ALT_RODATA_DEVICE, \ 17 ALT_RWDATA_DEVICE, \ 18 ALT_EXCEPTIONS_DEVICE) 19 20 /* 21 * 这是Nios II的入口地址 22 * 23 * 复位的时候只有包含有复位向量的cache line是初始化的， 24 * 所以第一个cache line 的代码要初始化其它的指令cache。 25 * 一个指令cache line大小是32个字节，所以代码长度不能超过8个指令。 26 * 注意：自动生成的linker script要求.init section小于0x20个字节 27 */ 28 .section .entry, "xa" // .entry段可执行可分配的 29 .align 5 // 和2^5=32字节边界对齐 30 /* 31 * 用户C代码要么在hosted mode 的mainn中，要么在standalone mode的alt_main中 32 */ 33 .globl main 34 .globl alt_main 35 /* 36 * 生成一个软件multiply/divide中断处理引用 37 * 这样一旦有下面的宏定义，它们就会被连入可执行文件中。 38 */ 39 #ifndef ALT_NO_INSTRUCTION_EMULATION 40 .globl alt_exception_muldiv 41 #endif 42 #ifdef ALT_TRAP_HANDLER 43 .globl alt_exception_trap 44 #endif 45 /* 46 * 有些工具需要知道reset vector在哪里 47 */ 48 .globl __reset 49 /* 50 * 连接器定义的符号，用于初始化.bss 51 */ 52 .globl __bss_start // .bss段的开始地址 53 .globl __bss_end // .bss段的结束地址 54 /* 55 * 明确声明可以使用r1 (汇编临时寄存器at)。 56 * 这个寄存器正常是保留个编译器使用的。 57 */ 58 .set noat 59 .type __reset, @function // 把__reset作为函数符号 60 __reset: 61 #ifdef ALT_RUN_FROM_FLASH 62 /* 63 * 如果我们在"run from flash"模式，那我们必须把代码放在 64 * reset 地址，初始化指令cache后跳转到入口(注意： 65 * 一旦.text段和reset 地址一样的话，"run from flash"就会 66 * 被设置). 如果我们没有在"run from flash"模式，那 67 * boot loader就会初始化指令cache就不需要这段代码了。 68 */ 69 /* 70 * 如果定义了ALT_SIM_OPTIMIZE 那这段代码不会在硬件上运行 71 * 这个定义移去了初始化的指令cache和数据cache。它假设这些在 72 * 仿真模型中已经做了 73 */ 74 #ifndef ALT_SIM_OPTIMIZE 75 /* 初始化指令cache的所有cache line */ 76 #if NIOS2_ICACHE_SIZE > 0 77 /* 78 * 假设指令cache大小是2的幂 79 */ 80 #if NIOS2_ICACHE_SIZE > 0x8000 81 movhi r2, %hi(NIOS2_ICACHE_SIZE) // 2的幂最高位为1，其它都是0，所以只要 82 #else // 给高位字节赋值，低位字节清0就可以了。 83 movui r2, NIOS2_ICACHE_SIZE // 小于32k时位长不超过16位，直接赋值就可以。 84 #endif 85 0: 86 initi r2 // Nios II的cache是直接映射型， 87 addi r2, r2, -NIOS2_ICACHE_LINE_SIZE // 只要对一段和cache大小一样的内存对应的cache， 88 bgt r2, zero, 0b // 初始化即可以达到初始化整个cache的目的。 89 1: 90 /* 91 * 下面的调试信息块告诉仿真器不用运行上面的循环， 92 * 而使用内部的快速代码 93 */ 94 .pushsection .debug_alt_sim_info 95 .int 1, 1, 0b, 1b 96 .popsection 97 #endif /* NIOS2_ICACHE_SIZE > 0 */ 98 /* 99 * 初始化cache后调用.text段的入口 100 */ 101 #endif /* ALT_SIM_OPTIMIZE */ 102 movhi r1, %hiadj(_start) // 装入_start的高16位 103 addi r1, r1, %lo(_start) // 装入_start的低16位 104 jmp r1 // 跳转到.text段入口 105 .size __reset, . - __reset // 给函数符号__reset设置大小=当前位置-__reset开始的位置 106 #endif 107 /* 108 * .text段的开始，当程序用loader装载运行的时候同时也是代码的入口 109 */ 110 .section .text 111 .align 2 // 4字节对齐 112 .globl _start 113 .type _start, @function // 把_start作为函数符号 114 _start: 115 /* 116 * 如果定义了 ALT_SIM_OPTIMIZE那这段代码不会在硬件上运行。 117 * 这个宏定义移去了指令和数据cache的初始化部分，我们假设仿真 118 * 模型已经做了这些工作。 119 */ 120 #ifndef ALT_SIM_OPTIMIZE 121 /* 122 * 在初始化指令cache后我们必须初始化数据cache 123 */ 124 #if NIOS2_DCACHE_SIZE > 0 125 /* 126 * 假设数据cache大小是2的幂 127 */ 128 #if NIOS2_DCACHE_SIZE > 0x8000 129 movhi r2, %hi(NIOS2_DCACHE_SIZE) // 2的幂只有最高位是1，其它位都是0 130 #else // 所以大于32k的数，只要存高位字节就可以 131 movui r2, NIOS2_DCACHE_SIZE // 其它位置为0，小于32k的数，则可以直接 132 #endif // 赋值。 133 0: 134 initd 0(r2) // Nios II的cache是直接映射型的，所以只要 135 addi r2, r2, -NIOS2_DCACHE_LINE_SIZE // 初始化任何一块和cache一样大小的内存相关 136 bgt r2, zero, 0b // cache就可以初始化整个cache。 137 1: 138 /* 139 * 下面的调试信息块告诉仿真器不用执行上面的循环， 140 * 而是执行内部的快速代码。 141 */ 142 .pushsection .debug_alt_sim_info 143 .int 2, 1, 0b, 1b 144 .popsection 145 #endif /* NIOS2_DCACHE_SIZE > 0 */ 146 #endif /* ALT_SIM_OPTIMIZE */ 147 /* 148 * 现在caches已经被初始化，设置栈指针。 149 * 我们假设由连接器提供的值已经4字节对齐了。 150 */ 151 movhi sp, %hiadj(__alt_stack_pointer) // __alt_stack_pointer由连接器脚本定义。 152 addi sp, sp, %lo(__alt_stack_pointer) 153 /* 设置global pointer. */ 154 movhi gp, %hiadj(_gp) // _gp由连接器脚本定义。 155 addi gp, gp, %lo(_gp) 156 #ifdef ALT_STACK_CHECK 157 /* 158 * 如果需要的化就设置栈顶变量。连接器已经在存贮器中设置了该变量的拷贝 159 */ 160 ldw et, %gprel(alt_stack_limit_value)(gp) 161 #endif 162 #ifndef ALT_SIM_OPTIMIZE 163 /* 164 * 给.bss段清0。 165 * 166 * 这里使用了符号：__bss_start and __bss_end,，这些在连接器脚本 167 * 中定义的变量。它们标志了.bss的开始和结束，连接器脚本保证 168 * 这些值都是32位对齐的。 169 */ 170 movhi r2, %hiadj(__bss_start) 171 addi r2, r2, %lo(__bss_start) 172 movhi r3, %hiadj(__bss_end) 173 addi r3, r3, %lo(__bss_end) 174 beq r2, r3, 1f 175 0: // 给.bss段清0。 176 stw zero, (r2) 177 addi r2, r2, 4 178 bltu r2, r3, 0b 179 1: 180 /* 181 * 下面的调试信息块告诉仿真器不用执行上面的循环， 182 * 而执行内部的快速代码。 183 */ 184 .pushsection .debug_alt_sim_info 185 .int 3, 1, 0b, 1b 186 .popsection 187 #endif /* ALT_SIM_OPTIMIZE */ 188 /* 189 * 如果是从flash中运行的就把其它段装入RAM中。 190 */ 191 #ifdef ALT_RUN_FROM_FLASH // 如果没有bootloader即从flash直接执行， 192 #if ALT_LOAD_SECTIONS // 判断是否有段需要从flash中装到RAM中， 193 call alt_load // 有的话就调用alt_load函数装载。 194 #endif /* ALT_LOAD_SECTIONS */ 195 #endif /* ALT_RUN_FROM_FLASH */ 196 /* 调用C入口 */ 197 call alt_main 198 /* alt_main永远都不会返回，所以我们在这里不需要再做任何事情。 199 */ 200 .size _start, . - _start // 给函数符号_start赋值大小=当前位置-_start开始的地址 201 #ifdef ALT_STACK_CHECK 202 /* 203 * 如果我们想检查堆栈溢出那我们需要知道堆栈的基地址 204 */ 205 .globl alt_stack_limit_value 206 .section .sdata,"aws",@progbits 207 .align 2 208 .type alt_stack_limit_value, @object 209 .size alt_stack_limit_value, 4 210 alt_stack_limit_value: 211 .long __alt_stack_limit 212 #endif
