Overview

In addition to the SD/MMC flash memory used by the GSRD, the Cyclone V SoC Development Kit board also has a QSPI flash memory chip.

The QSPI flash memory can be used to store any of the items that are stored on SD/MMC, potentially eliminating the need for SD/MMC in some applications.

This page presents various methods of programming the QSPI Memory:

• With HPS Flash Programmer
• From U-boot console
• From Linux console

Programming QSPI Flash with HPS Flash Programmer

The HPS Flash Programmer is part of the Quartus II Programmer package that is installed by default with the SoC EDS installation.

The HPS Flash Programmer uses the USB Blaster II to connect to the board and program QSPI and NAND Flash devices. It can be used to program the QSPI Flash memory device from the Cyclone V Development Kit.

Because it uses the USB Blaster II to send commands and data to the flash, the HPS Flash programmer is rather slow, and is usually used when there are no other means of writing to QSPI. For example for writing the Preloader on a custom board, that does not have SD/MMC boot capability.

The basic usage of the HPS Flash Programmer is as follows:

1. Configure board as described in Booting Linux

2. Configure the board to boot from QSPI

Jumper	Setting
J28	right shorted
J29	left shorted
J30	left shorted

3. Connect the mini USB cable from board USB Blaster II connector J37 to host PC.

4. Power on the board.

5. Make sure that the file that needs to be programmed has the .bin extension. If necessary, rename the file. This is a requirement of the HPS Flash Programmer.

6. Start an Embedded Command Shell

$ ~/altera/13.1/embedded/embedded_command_shell.sh

7. Invoke the programmer with the following options

$ quartus_hps -c 1 -o PV -a <qspi_flash_address> <binary_file_name>

where

• -c 1 instructs the programmer to use the 1st available USB Blaster II cable
• -0 PV instructs the programmer to program and verify a binary file
• <qspi_flash_address> is the address in QSPI flash where to write the file
• <binary_file_name> is the name of the binary file to be programmed to flash

For example the following programs the Preloader image to QSPI Flash at address 0, where it is expected to be by BootROM:

$ quartus_hps -c 1 -o PV -a 0x0000 ~/cv_soc_devkit_ghrd/software/spl_bsp/preloader-mkpimage.bin

For more details about how to use the HPS Flash Programmer, see Altera SoC Embedded Design Suite User Guide.

Programming QSPI Flash from U-boot Console

U-boot offers a complete set of commands for programming the QSPI Flash, of which the most used are:

Command	Usage	Description
Probe	sf probe [[bus:]cs] [hz] [mode]	Init flash device on given SPI bus and chip select
Read	sf read addr offset len	Read 'len' bytes starting at 'offset' to memory at 'addr'
Write	sf write addr offset len	Write 'len' bytes from memory at 'addr' to flash at 'offset'
Erase	sf erase offset [+]len	Erase 'len' bytes from 'offset' '+len' round up 'len' to block size
Update	sf update addr offset len	Erase and write 'len' bytes from memory 'addr' to flash at 'offset'

The following sample procedure demonstrates how to write a Preloader image on the QSPI Flash, using U-boot.

1. Create bootable SD card as described in Booting Linux

2. On host PC, copy the updated Preloader image to the DOS partition of the SD card:

$ sudo mkdir sdcard
$ sudo mount /dev/sdx1 sdcard/
$ sudo cp ~/cv_soc_devkit_ghrd/software/spl-bsp/preloader-mkpimage.bin  sdcard/
$ sudo umount sdcard 
$ sudo rm -f sdcard

Notes:

• Replace sdx with the corresponding SD card on your host system.
• No need to create the sdcard folder if it is already created. Just a place to mount the SD card.
• The above assumes the GHRD was stored in the user home folder
• On some Linux systems, the DOS partition is automatically mounted, and files can also be copied by copy-paste.

3. Use SD card to boot Linux as described in Booting Linux, and press any button while the U-boot countdown is running, to stop the boot process and access the U-boot console.

.

4. Load the Preloader image from FAT partition into memory, then write it to the QSPI flash

# fatload mmc 0:1 0x2000000 preloader-mkpimage.bin
# sf probe 
# sf update 0x2000000 0x00000 $filesize

Notes:

• 0x2000000 is an address where U-boot does not keep anything else, so it can be used as a scratch space. U-boot defines actually the environment variable $fpgadata located at that address, that can be used to temporarily store an FPGA image (or anything else) in memory if needed.
• $filesize is a variable maintained by U-boot that conveniently stores the size of the last file loaded into memory.

Programming QSPI Flash from Linux Console

Linux offers a complete set of utilities to manage the QSPI Flash.

Linux sees the QSPI flash as a set of partitions that are defined in the Device Tree. If necessary, the partitioning can be changed by editing the board XML file, generating the DTS and then compiling to DTB.

Refer to the following materials:

• Booting from QSPI for an example on how to update partitions
• Generating the Device Tree for more details about Device Tree Generator
• Device Tree Generator User Guide for the Device Tree Generator reference information

Once the partitions are defined in the Device Tree, they can be listed in Linux using the command 'cat /proc/mtd':

# cat /proc/mtd
dev:    size   erasesize  name
mtd0: 00800000 00010000 "Flash 0 Raw Data"
mtd1: 00800000 00010000 "Flash 1 jffs2 Filesystem" 

The following commands are available to manipulate QSPI Flash:

Command	Description	Usage
flash_erase	Erase flash partition	flash_erase >flash_partition< 0 0
flashcp	Copy file to flash partition	flashcp >file_name< >flash_partition<
mtdinfo	Display flash info	mtdinfo
mtd_debug info	Display flash info	mtd_debug info <device>
mtd_debug read	Read flash	mtd_debug read <device> <offset> <len> <dest-filename>
mtd_debug write	Write flash	mtd_debug write <device> <offset> <len> <source-filename>
mtd_debug erase	Erase flash	mtd_debug erase <device> <offset> <len>

See Booting from QSPI for an example on how to program files to QSPI Flash from Linux.