Warning: NAND is not officially supported by SoC EDS v16.0 and GSRD v16.0. Official release is planned for v16.1. The instructions presented in this page are intended to enable early development, and are not intended for production systems, as the amount of testing was minimal.

Overview

This page presents complete instructions on how to boot the A10 from NAND, using the GSRD and SoC EDS v16.0. Binaries are also included.

The following are covered:

• GHRD - Hardware Project
• Bootloader - UBoot
• Linux Device Tree
• Linux Kernel
• Linux rootfilesystem

Support for NAND is not officially included in 16.0, and the following activities were done to add it:

• Port the hardware design to use NAND instead of the default SDMMC
• Update the board XML files (used to generate the Linux Device Rree) to support NAND and Linux kernel 4.1-ltsi
• Enable NAND support in U-Boot source code (since bsp-editor does not support it in 16.0)
• Enable U-Boot support for "nand write.trimffs" command, to enable proper writing of rootfs to NAND
• Add Yocto recipes that
  • Enable using Linux Kernel 4.1-ltsi (required for NAND operation, as 3.10-ltsi does not support it)
  • Add another rootfs target called console-image-nand.jffs2

Prerequisites

You will need the following items:

• Arria 10 SoCDevelopment Kit, rev. C including:
  • DDR4 Memory Card
  • NAND Boot Card
• Host PC with:
  • Linux OS - required for compiling U-Boot, which is not supported on Windows
  • Minimum 16GB or RAM - required for building the hardware design
  • Serial terminal (for example minicom
  • TFTP Server - for getting Linux binaries to U-Boot to be written to QSPI
  • SoC EDS 16.0b211 - for generating and building U-Boot
  • ACDS 16.0b211 - for compiling the hardware design
• DS-5 License - for using debugger to load U-Boot and use it to write to NAND flash

NAND Layout

The following layout was chosen for the NAND:

Item	Start Address (Hex)	Size (Hex)	Size (Bytes)
4 x U-Boot Images	0x00000000	0x00100000	1,048,576
Linux Device Tree	0x00100000	0x00020000	131,072
Linux Kernel	0x00120000	0x00600000	6,291,456
FPGA Configuration (compressed RBF)	0x00720000	0x02900000	42,991,616
Root Filesystem (JFFS2)	0x03020000	0x04fe0000	83,755,008

Notes:

• Location of the Bootloader at offset 0x0 in NAND is required by BootROM.
• The FPGA configuration file needs to have the U-Boot (mkimage) wrapper.
• Location of RBF file, Linux kernel and Linux Device Tree are hardcoded in U-Boot source code as U-Boot environment variables (nandrbfaddr, nandbootimageaddr, nandfdtaddr). Their default values can be changed by editing the U-Boot source code file include/configs/socfpga_arria10.h.
• Location and size of root file system is defined in the Linux Device Tree.

Deliverables

The associated files are available at https://releases.rocketboards.org/2016.05/a10nandboot and consist of the following:

File	Description
linux-socfpga-gsrd-16.0-a10-nand-bin.tar.gz	Precompiled binaries
a10_soc_devkit_ghrd_nand.tar.gz	Hardware project
angstrom-socfpga-nand-boot.tar.gz	Angstrom Yocto recipes

The precompiled binaries archive contains the following:

File	Description
console-image-nand-arria10.jffs2.gz	Compressed JFFS2 rootfs partition image
console-image-nand-arria10.tar.xz	Compressed root file system archive
ghrd_10as066n2.rbf.mkimage	FPGA Configuration RBF wrapped with mkimage header
ghrd_10as066n2.sof	FPGA Configuration File SOF
ghrd_10as066n2.dtb	Linux Device Tree Binary
ghrd_10as066n2.dts	Linux Device Tree Source
uboot_w_dtb-mkpimage.bin	Precompiled U-Boot and U-Boot Device Tree Image
vmlinux	Linux kernel executable
zImage	Linux kernel compressed image

The prebuilt binaries are provided for reference, and can enable the user to skip some or all of the steps from the flow.

Building the NAND GSRD

This section describes how to build the NAND version of the A10 GSRD. The build process is very similar with the SD card version of the GSRD.

Notes:

• Prebuilt binary files are included with this release, so the QSPI GSRD can also be used without being rebuilt.
• In order to make this page shorter, the command line tools are used for the whole build process.

Building Hardware Design

1. Download the hardware design archive and extract it:

cd ~
wget https://releases.rocketboards.org/2016.05/a10nandboot/hw/a10_soc_devkit_ghrd_nand.tar.gz
tar xvzf a10_soc_devkit_ghrd_nand.tar.gz

2. Build hardware design, U-Boot and Linux device tree from Embedded Command Shell:

~/altera/16.0/embedded/embedded_command_shell.sh
cd ~/a10_soc_devkit_ghrd_nand/
make sof rbf_mkimage

This will create the following files in the ~/a10_soc_devkit_ghrd_nand folder:

File	Description
output_files/ghrd_10as066n2.sof	FPGA Configuration File in SOF format
output_files/ghrd_10as066n2.rbf	FPGA Configuration File in RBF format
output_files/ghrd_10as066n2.rbf.mkimage	FPGA Configuration File in RBF format, with the mkimage header

Note that the hardware design can also be built from the Quartus II GUI. The process is identical as for the SD card version: Compiling Hardware Design.

Generating and Building U-Boot and U-Boot Device Tree

Build U-Boot from Embedded Command Shell:

~/altera/16.0/embedded/embedded_command_shell.sh
cd ~/a10_soc_devkit_ghrd_nand/
mkdir -p software/bootloader
bsp-create-settings --type uboot --bsp-dir software/bootloader --preloader-settings-dir "hps_isw_handoff" --settings software/bootloader/settings.bsp
sed -i 's/BOOT_DEVICE := SDMMC/BOOT_DEVICE :=NAND/g' software/bootloader/config.mk
make -C software/bootloader
make -C software/bootloader clean
sed -i 's/#define CONFIG_CMD_NAND/#define CONFIG_CMD_NAND\n#define CONFIG_CMD_NAND_TRIMFFS/g' software/bootloader/uboot-socfpga/include/configs/socfpga_arria10.h
make -C software/bootloader

This will create the following in the ~/a10_soc_devkit_ghrd_nand folder:

File	Description
software/bootloader/uboot_w_dtb-mkpimage.bin	U-Boot Binary and Device Tree, wrapped with mkpimage header

Notes

• The instructions above work around the fact that the Bootloader Generator does not support NAND in 16.0
• The U-Boot configuration is ammended to add the CONFIG_CMD_NAND_TRIMFFS option
• The Bootloader Generator can also be invoked as a GUI application, not only from the command line. The flow is documented here: Generating U-Boot and U-Boot Device Tree

Building Linux Device Tree

Build Linux Device Tree from Embedded Command Shell:

~/altera/15.1/embedded/embedded_command_shell.sh
cd ~/a10_soc_devkit_ghrd_nand/
make dtb

This will create the following in the ~/a10_soc_devkit_ghrd_nand folder:

File	Description
ghrd_10as066n2.dts	Linux Device Tree Source
ghrd_10as066n2.dtb	Linux Device Tree Blob

Building Linux Kernel and Root Filesystem

The build process relies on an additional Yocto layer called meta-nand-boot that was added on top of the A10 GSRD 16.0 release and which contains the definition of two new recipes:

• a new image recipe (console-image-nand.bb) that adds a rootfs target called console-image-nand:

require recipes-images/angstrom/console-image.bb
DESCRIPTION = "Small image suitable for NAND boot"
IMAGE_INSTALL += "mtd-utils openssh"
export IMAGE_BASENAME = "console-image-nand"
export EXTRA_IMAGECMD_jffs2 = "--squash --pagesize=256 --little-endian --eraseblock=128KiB --no-cleanmarkers"
export IMAGE_FSTYPES = "jffs2"

• a new kernel recipe (linux-altera-ltsi_4.1.bb) that instructs to use Linux kernel 4.1-ltsi:

require recipes-kernel/linux/linux-altera-ltsi.inc

Note that the updated recipes are available for download as shown below, and the user does not have to manually type the information above, which is provided for reference.

The complete instructions on how to build the binaries required to boot Linux from QSPI are:

1. Please follow the steps described in Compiling Linux Kernel and Root Filesystem section Host Setup for Yocto to configure your host with the necessary packages to run Yocto.

2. Run the following commands to get and build the updated Angstrom Yocto recipes:

cd ~
wget https://releases.rocketboards.org/2016.05/a10nandboot/src/angstrom-socfpga-nand-boot.tar.gz
tar xvzf angstrom-socfpga-nand-boot.tar.gz
cd angstrom-socfpga-nand-boot/
MACHINE=arria10 ./oebb.sh config arria10
source ./environment-angstrom-v2014.12
MACHINE=arria10 bitbake virtual/kernel console-image-nand

This will create the following in the folder ~/angstrom-socfpga-nand-boot/deploy/glibc/images/arria10/:

File	Description
zImage	Linux kernel
console-image-nand-arria10.jffs2	Root Filesystem Image
console-image-nand-arria10.tar.xz	Root Filesystem Archive

Programming NAND and Running GSRD

This section explains how to program the NAND flash, and boot Linux.

Note that the utility from Arria 10 Flash Programming Alternative was used to program the NAND flash. A DS-5 license is required.

Download and extract the flash programming utility:

cd ~
wget https://rocketboards.org/foswiki/pub/Documentation/Arria10NANDFlashProgramming/flash_programmer.tgz
tar xzf flash_programmer.tgz

Download and extract the binaries (or you can use your own rebuilt binaries instead):

cd ~
wget https://releases.rocketboards.org/2016.05/a10nandboot/bin/linux-socfpga-gsrd-16.0-a10-nand-bin.tar.gz
tar xvzf linux-socfpga-gsrd-16.0-a10-nand-bin.tar.gz

Program flash using the utilities:

~/altera/16.0/embedded/embedded_command_shell.sh
cd ~flash_programmer
./flash_programmer.py --operation=epv --address=0x00100000 --size=0x00020000 --file=~/linux-socfpga-gsrd-16.0-a10-nand-bin/ghrd_10as066n2.dtb
./flash_programmer.py --operation=epv --address=0x00120000 --size=0x00600000 --file=~/linux-socfpga-gsrd-16.0-a10-nand-bin/zImage
./flash_programmer.py --operation=epv --address=0x00720000 --size=0x01000000 --file=~/linux-socfpga-gsrd-16.0-a10-nand-bin/ghrd_10as066n2.rbf.mkimage
./flash_programmer.py --operation=E --address=0x03020000 --size=0x04FE0000
./flash_programmer.py --operation=Pv --address=0x03020000 --size=0x04000000 --file=~/linux-socfpga-gsrd-16.0-a10-nand-bin/console-image-nand-arria10.jffs2
./flash_programmer.py --operation=epv --address=0x00000000 --size=0x00100000 --file=~/linux-socfpga-gsrd-16.0-a10-nand-bin/uboot_w_dtb-mkpimage.bin

Notes:

• The space for the rootfs is erased using 'E' operation, which instructs U-Boot to issue "nand erase clean" command, which inserts the required JFFS2 cklean markers.
• The rootfs is programmed using 'P' operation which instructs U-Booot to issue "nand write.trimffs" command, which does not write pages that have only 0xff inside, as required for JFFS2.
• The verify 'v' operation for rootfs will issue a 'nand read' command which will show failure (because of the above options). But the actual operation actually succeeded - you can see in the log that the number of bytes that were the same is greater or equal than the actual image size.
• Use parameter '--board=devkit_revb' when targeting a rev B board

Connect to the board serial port using 115,200-8-N-1 then power cycle the board. The serial terminal will show Linux booting up. Enter 'root' as username and you will be logged in: