Arm 2440 - Detailed explanation of Nand flash boot mode (taking LED program as an example)

I have been studying arm on and off for 2 months. Now I feel that I understand the boot process of arm in Nand flash mode. Now I come here to record it to express my extremely happy mood. Without further ado, while I still remember the feelings during the learning process, I will go straight to the point.

As we all know, when ARM starts in Nand flash boot mode, the system will copy the first 4KB code in Nand flash to SRAM (that is, Steppingstone), and SRAM will configure the interrupt vector table and complete the necessary initialization of Nand flash access, and then copy all the program codes in Nand flash to SDRAM, and finally jump from SRAM to SDRAM, and then the program will execute normally. This process looks simple, but it is not easy to really understand this process. Despite this, I still want to tell you that it is relatively easy to understand this process if you understand it carefully. If you are an ADS user, you have saved a lot of trouble, but I am not sure whether the trouble you have saved is worth it. Here is a troublesome way, the LED program under Linux.

Code Head.s

 

I think the most important thing to understand is this code. Let me explain it briefly.

(1) Since the pc will be cleared to zero after the arm executes reset, that is, the interrupt entry address of the reset interrupt, the first instruction is b reset, which jumps to the reset interrupt processing function.

(2) Since the hardware configuration here is all done in C language, and our initial code is relatively small and will not exceed 4KB at all, we can use the stack in SRAM, so we set SP to 4096 to provide a C running environment

(3) The next three bls respectively complete the tasks of disabling the watchdog timer, configuring the clock signal and memory configuration. The fourth bl copies the code in the 4KB space of SRAM to SDRAM.

(4) The following ldr statement assigns pc to the address of on_sdram, thus implementing a jump from SRAM to SDRAM (the reason will be explained below).

(5) on_sdram switches to system mode and allocates the system mode stack, sets the link register to halt_loop and then jumps to Main in SDRAM

The above explanation only roughly explains the meaning of the code, but beginners always have a question: why does ldr pc,=on_sdram implement the jump from SRAM to SDRAM? I was troubled by this question for a long time, and I finally figured it out today. The key to the problem is the issue of relative jump and absolute jump. To explain this problem, I will first explain the difference between the bl instruction and the ldr instruction in the execution process.

The B instruction is a relative jump instruction. The B instruction is the simplest jump instruction. Once a B instruction is encountered, the ARM processor will immediately jump to the given target address and continue execution from there. Note that the actual value stored in the jump instruction is an offset relative to the current PC value, not an absolute address. Its value is calculated by the assembler (refer to the relative addressing in the addressing mode). It is a 24-bit signed number, which is extended to 32 bits after being shifted left by two bits. The effective offset represented is 26 bits (32MB of address space before and after). Similarly, BL and BX are relative jumps.

The LDR pseudo-instruction directly assigns the second operation to the first operand. When ldr pc,=Main is executed, the absolute address of Main is assigned to PC.

OK, now that we know the difference between these two instructions, let's see how the code implements the jump from SRAM to SDRAM. First of all, it should be pointed out that the 2440 development board has SRAM and SDRAM. SRAM is a 4KB memory space starting at address 0x00000000, and SDRAM is a 64M space starting at 0x30000000.

Whether compiled with ADS or arm-linux-gcc, the code will be linked to after 0x30000000 (that is, in SDRAM). ADS users can check the ADS project configuration, where one configuration is that the RO starting address is 0x30000000. Linux users need to use -T to specify that the actual address of the code is 0x30000000 when linking.

According to the compilation principle, the address of the function in the program has been determined during the linking phase, that is, the actual address of the function is after 0x30000000, and the address of the program's entry function, which is _start here, is 0x300000000, and other functions will be greater than this number.

However, after the arm is powered on, the system will copy the first 4KB code of the Nand flash to the SRAM, that is, the 4KB instructions starting with the _start function will be copied to the SRAM for execution. According to the above example, the instruction executed at 0x00000000 is "b reset". Since b is a relative jump, it is based on the current pc value plus or minus a certain number to jump to the code to be executed. Therefore, after the pc is added or subtracted by the number, it will reach the position of the reset function. Therefore, the reset function cannot be written to the space outside 4KB, otherwise the arm startup will fail. Similarly, the next few bl are relative jumps, so they are all jumps relative to the current pc. Since the Nand flash has only 64M of space in total, it is impossible for a relative jump to jump to SDRAM, because jumping to SDRAM requires at least a jump of 0x30000000, and this relative displacement is much larger than 64M.

And ldr pc,=Main assigns the actual address of the Main function to pc, and the actual address of Main is after 0x30000000, so it jumps from SRAM to SDRAM.

Since this process involves the hardware structure and compilation principle, it is difficult for ordinary people to understand. In addition, due to my own level, many places can only be understood by heart and not by words. Please forgive me if I mislead you. Of course, if you still don't understand the arm startup process after reading this, you can leave a message to discuss this issue. The following are other related codes. I attach them here. 2440addr.h is not posted because I also use the code in the sample program that comes with arm, and the code has more than 4,000 lines, and most of the addresses are not used. The other codes are as follows

Code Init.s Note: Since our code is relatively small, much smaller than 4KB, the 4KB code automatically copied to SRAM when ARM starts up contains all our code. Therefore, in the copy operation, I copied the 4KB code in stepingstone to SDRAM. In actual applications, most of the code is more than 4KB, so the copy function should copy all the code in Nand flash to SDRAM, so that ARM can run successfully.

 

Code Main.c:

The link file led.lds is as follows:
The makefile is as follows:
As above, except for 2440addr.h, all are complete. In addition, it should be pointed out that Option.h is referenced in 2440addr.h. In order to simplify the code, this sentence can be commented out. The functions related to this file are not used in our code at all. Otherwise, you need to modify the makefile file to complete the compilation and linking work related to Option.h.

 

Okay, I have wasted so much of your time again, so I won't say much here. If you have any questions, please let experts know.