Converting.srec Files to.flash Files for Nios Embedded Processor Applications

Transcription

1 White Paper Converting.srec Files to.flash Files for Nios Embedded Processor Applications Introduction The Excalibur Development Kit, featuring the Nios embedded processor, includes the software, hardware, accessories, and documentation necessary to create embedded processor designs and complete system projects. In a typical development flow, the designer creates an embedded software application and then uses the nios-build utility to create a Motorola s-record (.srec) file format of the application. Next, the designer downloads the.srec file to the Nios development board using the GERMS monitor. The application code usually runs from the on-board SRAM. When developing applications, the designer may want to store the embedded software application and the PLD image in the flash memory in the Nios development board. In this case, the PLD image and the embedded application load each time the power is cycled or the system is reset. You can convert the.srec file into a flash boot image (.flash) file, which can be downloaded into the flash memory on the Nios development board. The.flash file includes the GERMS monitor commands to erase the flash memory and relocate s-records to the erased location. This file also contains initialization code that copies your embedded application code from the flash to the SRAM. When copying is complete, the embedded application executes. If your design has the same memory map as the Nios 32-bit reference design provided in the Excalibur Development Kit, featuring the Nios embedded processor, you can create.flash files by using the Altera-provided srec2flash utility. For applications that are not designed for the Nios development board or for systems that have a custom memory map, you can create the.flash file using the procedure described in Creating.flash Files for Custom memory Maps on page 5. This white paper describes the srec2flash utility, how to create.flash files from.srec files, and how to create a.flash file using a custom memory map. Before You Begin The instructions in this document assume that you are familiar with: Designing Nios-based systems Compiling embedded software applications for Nios-based systems Using the GERMS monitor 1 To use the srec2flash utility or to use a custom.flash file, your Nios system design must include the GERMS monitor. f Refer to the Nios documentationfor more information about the hardware and software elements of the Excalibur Development Kit, featuring the Nios embedded processor. The documentation is installed into the \Altera\Excalibur\nios_documentation directory. A-WP-NIOSFLASH-1.0 OCtober 2001, ver

2 The srec2flash Utility The srec2flash utility converts.srec files to.flash files. This section describes the utility. When to Use the srec2flash Utility Use srec2flash if you want to: Store your application code in the flash memory on the Nios development board so that the application executes when the board is powered up or after a hardware or software reset. Execute the application code from the SRAM not from the flash. Use the same memory map as the defined by the 32-bit reference design included with the kit. How the srec2flash Utility Works The srec2flash utility adds the GERMS monitor commands and initialization code in s-record format (see Figure 1) to the beginning of the specified.srec file, <my program>.srec. In Figure 1, comment lines begin with a character. Figure 1. GERMS Monitor Commands in the srec2flash Utility Reset the relocation offset to 0 r0 Erase flash sector This address is checked by the GERMS monitor at startup e S DC07F00304E696F E1165 S F524A005A E E27EF F9 S A CC07F00302E Main program Ser the relocation offset for ro (flash) r End of GERMS monitor commands Begin user.srec file Table 1 describes the functionality of the code. Table 1. srec2flash GERMS Monitor Commands r0 e Command Code Description This command resets the relocation offset to zero. The GERMS monitor treats all addresses as absolute addresses. This command directs the GERMS monitor to erase the block of flash starting at address 0x Each block in the code section of the flash is 64 KBytes. If your program is larger than 64 KBytes, you must erase more than one block of flash. S2xxx The 3 lines beginning with S2 are the s-records that copy the application code from the flash to the SRAM. Altera created these s-records by compiling the file flashcopy.s (see Generating S-Records for Use with the srec2flash Utility on page 3). r This command instructs the GERMS monitor to relocate any s-records that follow this command by an offset of 0x (from to ). During normal compilation of Nios embedded applications, the nios-build utility maps the resultant binary code into SRAM memory space with the first instruction of the application above the interrupt vector table. The default address for this action is 0x The relocate command adjusts the s-record addresses such that the GERMS monitor stores the data in flash starting at address 0x

3 The command syntax for the srec2flash utility is: srec2flash <my program>.srec The utility outputs the file <my program>.flash, which you can download into the Nios development board using the command: nios-run <my program>.flash Generating S-Records for Use with the srec2flash Utility The s-records in the srec2flash utility copy the application from the flash to the SRAM and start execution of the application from the SRAM. The s-records included with the srec2flash utility were generated by compiling an assembly language program named flash_copy.s (see Figure 2). The flash_copy.s program uses the registers %l0, %l1, %l2, and %g0: %l0 Source memory start address. %l1 Source memory end address. %l2 Destination memory start address. %g0 Temporary register for holding the memory contents you want to copy. 1 In the following code, comment lines begin with the ; character. Figure 2. flash_copy.s Assembly Language Program ; file: flash_copy.s.include "nios.s".global _start _start: MOVIP %l0,0x ; flash (source) starting adddress MOVIP %l1,0x ; flash (source) ending address MOVIP %l2,na_ext_ram ; SRAM (destination) address start ; location, which is defined in ; nios_macros.s flash_copier_loop: LD %g0,[%l0] ; get current word ADDI %l0,4 ; bump source to next word ST [%l2],%g0 ; store word ADDI %l2,4 ; bump destination to next word CMP %l0,%l1 ; are we there yet? IFS cc_ne BR flash_copier_loop NOP ; Jump to the program stored at nasys_program_mem, which is defined in nios_map.s. The divides by 2 so that the address is a valid one for a subroutine. MOVIA %g0,nasys_program_mem@h JMP %g0 NOP ; End of file 3

4 The flash_copier_loop routine copies a block of memory from flash into SRAM. The flash block that is copied has starting and ending addresses stored in registers %10 and %11, respectively. This block is copied to SRAM starting at the address stored in %12. The program then jumps to the starting program memory address stored in the variable nasys_program_mem. The variable is offset from the beginning of the SRAM by the size of the interrupt vector table 0x100 bytes for the 32-bit reference design. Compiling the flash_copy.s program using the nios-build utility generates the s-records. The command to compile is: nios-build b 0x flash_copy.s This command generated the file flash_copy.srec, which contains the lines: S C F636F E S DC07F00304E696F E1165 S F524A005A E E27EF F9 S A CC07F00302E S D7 The srec2flash utility only uses the middle three s-record lines. The first line, which starts with S0, is optional. It contains no executable code; therefore, it was not included. The next 3 lines, which start with S2, are the SREC format of the actual executable code. These lines are 24-bit address records with 0x19, 0x19, and 0x10 bytes of information, respectively, with the first line starting at address 0x The last line, which starts with S8, contains the s-record with the executable address for this program. Because the srec2flash utility is designed to execute the designer s application after copying to the SRAM, this line is not included. On power-up, the GERMS monitor checks address xC for the characters Nios. If these characters are found, the application jumps to and begins execution. The GERMS monitor also checks the state of SW4 on the development board. If you press the button during this startup period, the GERMS monitor does not jump to 0x14010C; instead, it terminates to a command prompt. f Refer to S-Record File Format on page 6 for additional information on the s-record format. 4

5 Creating.flash Files for Custom memory Maps If your Nios design does not use the memory map of the 32-bit reference design, you should not use the srec2flash utility to convert your.srec file to a.flash file. Instead, follow the instructions in this section to create the.flash file. 1 Read How the srec2flash Utility Works on page 2 and Generating S-Records for Use with the srec2flash Utility on page 3 to become familiar with the basic concepts before creating your own.flash file. To create a.flash file, perform the following steps: 1. Compile the embedded application source code, <my program>.c using the normal Nios build process to output the file <my program>.srec. Note the start and end addresses for the executable code in the custom memory map. 2. Create a custom flash_copy.s program, using Figure 2 on page 3 as a template. Change the flash source memory start and end addresses and set the SRAM memory start address. a. Change the first two MOVIP commands in the flash_copy.s program to the flash start and end addresses in which the executable code that will be copied to the SRAM resides. The end address is determined by the size of the code that is stored in the flash. In the flash_copy.s example, the start and end addresses span the full 256K of SRAM (less the first 0x100 bytes that are used for the interrupt vector table). b. Change the third MOVIP command in the flash_copy.s program to point to the SRAM start address location. 3. Compile the flash_copy.s program using the nios-build utility to output the file flash_copy.srec. Use the -b option to specify a base address in the flash in which to store the application code. For example, the srec2flash utility is compiled to begin at 0x To compile flash_copy.s for a specified address, use the command: nios-build -b <base address> flash_copy.s 4. Open the <my program>.srec file in a text editor and save it as <my program>.flash. 5. Add the following lines to the beginning of the <my program>.flash file (refer back to Figure 1 on page 2 for an example): r0 e<flash block in which your application will reside> <3 middle lines (s-records) from the flash_copy.srec file you created in step 3> r<executable memory address> - <flash memory address> 1 Typically, flash memory must be erased in blocks and the block size varies according to the flash device used. Include enough erase commands in the.flash file so that sufficient flash space is erased before the application code is downloaded. 6. Save <my program>.flash. The <my program>.flash is now set to use a custom system memory map. Send the.flash file to the GERMS monitor running on the Nios development board using the following command: nios-run <my program>.flash The command stores your program, combined with the flash copy routine, into the flash location you designated. 5

6 S-Record File Format S-records are an industry-standard format for transmitting binary files to target systems and PROM programmers. The S-record format is as follows: S<type><length><address><data><checksum> where: <type> is a number from 0 to 9 where: 0 starting record (optional) 1 data record with 16-bit address 2 data record with 24-bit address 3 data record with 32-bit address 4 (special extension for symbol records) 5 number of data records in preceding block 6 unused 7 ending record for S3 records giving executable address 8 ending record for S2 records giving executable address 9 ending record for S1 records giving executable address <length> is two hex characters. <length> defines the length of the record in bytes and includes the address, data, and checksum fields. <address> is 4, 6, or 8 characters corresponding to a 16-, 24-, or 32-bit address. The address field for S4 records is always 32 bits. <data> are the data bytes. Each pair of hex characters represents one byte in memory. <checksum> is the one s complement of the 8-bit checksum. 101 Innovation Drive San Jose, CA (408) Copyright Altera, The Programmable Solutions Company, the stylized Altera logo, specific device designations, and all other words and logos that are identified as trademarks and/or service marks are, unless noted otherwise, the trademarks and service marks of in the U.S. and other countries. All other product or service names are the property of their respective holders. Altera products are protected under numerous U.S. and foreign patents and pending applications, maskwork rights, and copyrights. Altera warrants performance of its semiconductor products to current specifications in accordance with Altera s standard warranty, but reserves the right to make changes to any products and services at any time without notice. Altera assumes no responsibility or liability arising out of the application or use of any information, product, or service described herein except as expressly agreed to in writing by. Altera customers are advised to obtain the latest version of device specifications before relying on any published information and before placing orders for products or services. All rights reserved. 6