[转]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 并行flashboot

这种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字节的最后一个
“程序记录”的目的地址域A

 

0x00000000,4字节的最后一个
“程序记录”的长度域L

 

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
epcs_controller_boot_rom.hex
or epcs_controller_boot_rom.dat

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:
1. 一个EOP字节被写入Tx Data寄存器

2. 一个EOP字节从Rx Data寄存器中读出
EOP字节就是End of Packet寄存器中的End of Character字节。往status寄存器写可以把EOP位清0。

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          从并行flashboot

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字节的最后一个
“程序记录”的目的地址域A

 

0x00000000,4字节的最后一个
“程序记录”长度域L

 

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

 

 

posted on 2013-05-05 19:31  超群天晴  阅读(1575)  评论(0编辑  收藏  举报

导航