SAM9X60-EK – Boot from QSPI Flash Memory

Introduction

This training explains how to configure and program the SAM9X60-EK evaluation kit to boot the second- and third-stage bootloaders at91bootstrap and u-boot-at91 from QSPI Flash Memory, and the Flattened Image Tree (FIT) (containing the Linux kernel and Device Tree) and Root File System from the SD Memory Card.

You will use the SAM-BA® In-System Programmer to write at91bootstrap and u-boot-at91 to QSPI Flash memory.

Steps:


Prerequisites

Familiar with the features of the SAM9X60-EK evaluation kit:

A working cross-toolchain for ARM-based MPU target

Familiar with the operation of the SAM-BA In-System Programmer (ISP):

Setup Console Serial Communications with the SAM9X60-EK:

Knowledge of the Boot Process:


Hardware

sam9x60-ek.png

For this training, you will be using the SAM9X60-EK Evaluation Kit. You will also need two USB Micro-B cables. One cable will connect the Host PC to the target console to view SAM-BA Monitor log messages. The second cable will connect the Host PC to the target USBA port (J7) so that the SAM-BA Host can communicate with the SAM-BA Monitor.

Bootable Memory

qspi_flash.png

For this training, you will use the Quad Serial I/O™ (QSPI) Flash emory (U8) (64 Mbit Quad Serial I/O™ Flash memory SST26VF064B) to boot the second- and third-stage bootloaders at91bootstrap and u-boot-at91. As the QSPI Flash memory is not large enough to hold all the bootable images, you will boot the kernel image (linux_at91) and root filesystem (RootFS) from the SD Memory Card (J4).

qspi_memory_map_color.png

SAM-BA In-System Programmer

In this section, you will load the SAM-BA Host Application (if you have not already done so) and setup Console and SAM-BA Host to Monitor communications.

1

Setup SAM9X60-EK Console Serial Communications.

To view the SAM-BA Monitor log messages, setup console serial communications following the instructions in the topic: SAM9X60-EK Console Serial Communications.

You have two choices in connecting to a serial port on the SAM9X60-EK:

  • the first is using a USB cable to connect to the J-LINK-OB port (J22), or
  • the second is using a USB-to-TTL converter, connect to the UART Debug port (J24).

You also have two choices in powering the SAM9X60-EK:

  • using an external 5 VDC power supply connected to J1 (coaxial power jack), or
  • using a USB cable connect to the USBA port (J7). As you’ll be connecting a USB cable in Step 3 below (SAM-BA Host to Monitor Communications), this is the easiest method.
j-link-ob-port.png

Operation of the J-Link Debugger will be displayed by a flashing green LED (D9).

serial-uart-debug-port.png

2

If not already installed, install the SAM-BA Host Application.

SAM-BA Host application should be added to the system PATH variable.

$ export PATH=$PATH:<path_to_sam-ba>

This will enable you to access the SAM-BA Host from anywhere on your system.

3

Setup SAM-BA Host to Monitor Serial Communications.

a

To communicate with SAM-BA Monitor on the target, you must have installed the SAM-BA Host on a Linux PC (Step 2 above), and connect a USB Micro-B cable from the host PC to the USBA port (J7) on the SAM9X60-EK as shown in the figure below.

sam9x60-ek-sam-ba-comms-j13-open.png

You may power the SAM9X60-EK one of two ways:

  1. using an external 5 VDC power supply connected to J1 (coaxial power jack), or
  2. using a USB cable connect to the USBA port (J7).

b

Ensure there is no SD Memory Card in slot J4.

c

Open the DISABLE_BOOT (J13).

This will allow booting from the onboard memories (NAND and QSPI Flash).

d

Press both the DIS_BOOT (SW4) and RESET (SW3) push buttons.

Pressing the DIS_BOOT (SW4) push button disables booting from the onboard memories.

e

Continue pressing DIS_BOOT (SW4) while releasing the RESET (SW3) push button.

The SAM9X60-EK will boot to the SAM-BA Monitor and start communications with the SAM-BA Host. Observe ROMBoot on the Console (terminal emulator) indicating the SAM-BA Monitor is running.


Erase QSPI Flash Memory

In this section, you will erase the contents of the QSPI Flash memory located on the SAM9X60-EK. This is a necessary step before writing data to the QSPI Flash memory.

1

Erase the QSPI Flash Memory.

Erase the contents of the QSPI Flash memory on the SAM9X60-EK with the following command:

$ sam-ba -p serial -b sam9x60-ek -a qspiflash -c erase
Opening serial port 'ttyACM0'
Connection opened.
Detected memory size is 8388608 bytes.
Page size is 256 bytes.
Buffer is 112644 bytes (44 pages) at address 0x0030a3e0.
Supported erase block size: 4K
Executing command 'erase'
Erased 4096 bytes at address 0x00000000 (0.05%)
Erased 4096 bytes at address 0x00010000 (0.10%)
..
..
Erased 4096 bytes at address 0x003e0000 (99.95%)
Erased 4096 bytes at address 0x003f0000 (100.00%)
Connection closed.


Build at91bootstrap and Write to QSPI Flash Memory

In this section, you will configure and build the second-stage bootloader, at91bootstrap, from source code to boot from QSPI Flash memory and write it to QSPI Flash memory.

For more information, including how to download, see the training: "at91bootstrap: A Second Stage Bootloader for Microchip Microprocessors"

1

Change directory into the at91bootstrap directory:

$ cd ~/at91bootstrap

2

Using a default configuration file, configure at91bootstrap to boot u-boot from QSPI Flash Memory:

$ make mrproper
# CLEAN obj and miss files!
# CLEAN configuration files!
# CLEAN binary files!

$ make sam9x60ekdf_qspi_uboot_defconfig
#
# configuration written to .config
#
#
# make dependencies written to .auto.deps
# See top of this file before playing with these auto-prerequisites!
#

What is the difference between make clean and make mrproper?

make clean - Remove most generated files but keep the config and enough build support to build external modules.
make mrproper - Remove all generated files + config + various backup files.

Anytime the configuration is changed, you should execute make mrproper.

Default configuration (defconfig) files are provided for the many evaluation kits sold by Microchip. They are located in the ~/at91bootstrap/board/ directory.

3

Optional: If you would like to verify the QSPI Flash Memory settings or make any customizations:

$ make menuconfig

at91bootstrap_config.png

a

Observe that Board Type (sam9X60ek) has been selected.

b

Highlight Memory selection ---> and press ENTER.

c

Highlight QSPI configuration ---> and press ENTER.

You can see QSPI Bus Select is QSPI Bus 0.

You may exit menuconfig by repeatedly typing ESC-ESC until it closes. Do not save any changes.

4

Build at91bootstrap:

$ make

A working cross-toolchain for ARM-based MPU target is required to build at91bootstrap.

Ensure you set the CROSS_COMPILE=<cross_compiler> and ARCH=arm environment variables.

For example, if your cross-compiler executable is arm-linux-gcc then CROSS_COMPILE=<path_to>/arm-linux-

A second method is you may include these as command variables. For example:

$ make ARCH=arm CROSS_COMPILE=<path_to>/<cross_compiler>

Once the build is complete, the resulting binary files are in the ~/at91bootstrap/binaries/ directory:

$ cd ~/at91bootstrap/binaries
$ ls
at91bootstrap.bin
boot.bin
sam9x60ek-dataflashboot—uboot-3.9.2.bin
sam9x60ek-dataflashboot-uboot—3.9.2.elf
sam9x60ek-dataflashboot-uboot—3.9.2.map

5

From the SAM-BA Host command line, write at91bootstrap.bin to QSPI Flash Memory starting at location 0x0 using the qspiflash applet writeboot command:

$ sam-ba -p serial -b sam9x60-ek -a qspiflash -c writeboot:at91bootstrap.bin
Opening serial port 'ttyACM0'
Connection opened.
Detected memory size is 8388608 bytes.
Page size is 256 bytes.
Buffer is 112644 bytes (44 pages) at address 0x0030a3e0.
Supported erase block sizes: 4K
Executing command 'writeboot:at91bootstrap.bin'
Appending 8 bytes of padding to fill the last written page
Wrote 11264 bytes at address 0x00000000 (65.676%)
Wrote 5888 bytes at address 0x00002c00 (100%)
Connection closed.

The writeboot command should only be used when programming a bootstrap file into an external QSPI Flash memory boot partition.

The writeboot command modifies the relevant unused ARM exception vector to store the size of the bootstrap binary as required by the ROM Boot code during the boot process.

For more information on the SAM-BA ISP Applet qspiflash command, see "SAM-BA® ISP - Applets: Program External QSPI NOR Flash Memory".

The result is at91bootstrap.bin is stored in the QSPI Flash memory starting at address 0x0.

qspi_memory_map_at91bootstrap.png

Build u-boot-at91 and Write to QSPI Flash Memory

In this section, you will configure and build the third-stage bootloader, u-boot-at91, from source code to boot from QSPI Flash memory and write it to QSPI Flash memory.

u-boot-at91 is maintained by Microchip Technology and hosted on GitHub.

For more information about the third-stage bootloader see: Das U-Boot – The Universal Boot Loader.

1

Change directory to your working directory containing the u-boot-at91:

$ cd ~/u-boot-at91

2

Using a default configuration file, configure u-boot-at91 for QSPI Flash Memory:

$ make sam9x60ek_qspiflash_defconfig
HOSTCC scripts/basic/fixdep
HOSTCC scripts/kconfig/conf.o
HOSTCC scripts/kconfig/zconf.tab.o
HOSTLD scripts/kconfig/conf
#
# configuration written .config
#

3

Optional: If you would like to verify settings for booting from QSPI Flash memory or make any customizations, type:

$ make menuconfig

uboot_config.png

a

Highlight Boot media ---> and press ENTER.

uboot_boot_media.png

b

Observe that [*] Support for booting from QSPI flash ---> has been selected.

You may exit menuconfig by typing "ESC-ESC" repeatedly until it closes. Do not save changes.

4

Build u-boot-at91:

$ make

A working cross-toolchain for ARM-based MPU target is required to build u-boot-at91.

Ensure you set the CROSS_COMPILE=<cross_compiler> and ARCH=arm environment variables.

For example, if your cross-compiler executable is arm-linux-gcc then CROSS_COMPILE=<path_to>/arm-linux-

A second method is you may include these as command variables. For example:

$ make ARCH=arm CROSS_COMPILE=<path_to>/<cross_compiler>

Once the build is complete, the resulting binary file u-boot.bin is in the u-boot-at91 directory.

5

From the SAM-BA ISP command line, write u-boot.bin to QSPI Flash memory starting at location 0x40000 using the applet -a qspiflash -c write command:

$ sam-ba -p serial -b sam9x60-ek -a qspiflash -c write:u-boot.bin:0x40000
Opening serial port 'ttyACM0'
Connection opened.
Detected memory size is 8388608 bytes.
Page size is 256 bytes.
Buffer is 112644 bytes (44 pages) at address 0x0030a3e0.
Supported erase block sizes: 4K
Executing command 'write:u-boot.bin:0x40000'
Appending 210 bytes of padding to fill the last written page
Wrote 11264 bytes at address 0x00040000 (1.87%)
Wrote 11264 bytes at address 0x00042c00 (3.73%)

Wrote 11264 bytes at address 0x000cf000 (98.86%)
Wrote 11264 bytes at address 0x00d1cc00 (100.00%)
Connection closed.

The result is u-boot.bin is stored on the QSPI Flash memory starting at address 0x40000.

qspi_memory_map_uboot.png

Create u-boot-env.bin and Write to QSPI Flash memory

Configuration of U-Boot is performed using Environment Variables. They are stored in binary format, generally, on the same boot memory (mass storage) that U-Boot is stored.

In this section, you will create a U-Boot environment binary file by first creating a text file. The text file is then converted to binary format using a utility program mkenvimage. Finally, you will write the file to QSPI Flash memory using the SAM-BA In-System Programmer.

More information on U-Boot Environment Variables can be found in the U-Boot Manual Section 5.10.

1

Using your favorite text editor, create a text file with the following information. Name the text file u-boot-env.txt.

bootargs=console=ttyS0,115200 root=/dev/mmcblk0p2 rw rootwait rootfstype=ext4 
bootcmd=ext4load mmc 0:2 0x24000000 boot/sam9x60ek.itb; bootm 0x24000000#kernel_dtb
bootdelay=1
ethact=gmac0
stderr=serial
stdin=serial
stdout=serial

The bootargs line tells U-Boot:

  • The console= device and baud
  • The root= location of the root filesystem and permissions
  • The rootfstype= root filesystem type

The bootcmd= line tells U-Boot to load the sam9x60ek.itb file (Flattened Image Tree (FIT)) from the EXT4 formatted partition 2 on the SD Memory Card (which you will prepare in future sections) to external DDR2 SDRAM starting at address 0x24000000.

qspi_memory_map_full_w_sd.png

2

Convert the text file u-boot-env.txt into a binary file u-boot-env.bin using the utility program mkenvimage.

The mkenvimage utility program generates a valid binary environment image from a text file. It is part of the U-Boot software package. See directory ../u-boot-at91/tools/

The -s option allows specifying the size of the image to create. It must match the size of the flash area reserved for the U-Boot environment.

$ mkenvimage -s 0x20000 -o u-boot-env.bin u-boot-env.txt

3

From the SAM-BA ISP command line, write u-boot-env.bin to QSPI Flash memory starting at location 0x140000 using the applet -a qspiflash -c write command:

$ sam-ba -p serial -b sam9x60-ek -a qspiflash -c write:u-boot-env.bin:0x140000
Opening serial port 'ttyACM0'
Connection opened.
Detected memory size is 8388608 bytes.
Page size is 256 bytes.
Buffer is 112644 bytes (44 pages) at address 0x0030a3e0.
Supported erase block sizes: 4K
Executing command 'write:u-boot-env.bin:0x140000'
Appending 210 bytes of padding to fill the last written page
Wrote 11264 bytes at address 0x00140000 (8.59%)
Wrote 11264 bytes at address 0x00142c00 (17.19%)

Wrote 11264 bytes at address 0x00015b800 (94.53%)
Wrote 11264 bytes at address 0x0015e400 (100.00%)
Connection closed.

The result is u-boot is stored in the QSPI Flash memory starting at address 0x140000.

qspi_memory_map_full.png

Build the Linux Kernel Image and Device Tree Blob (DTB)

In this section, you will configure the Linux kernel and Device Tree for the SAM9X60-EK using default configuration files and build the files. In the next section, you use these files to create a Flattened Image Tree (FIT) image to write to the SD Memory Card.

linux-at91 is maintained by Microchip Technology and hosted on GitHub.

1

Change directory to your working directory containing the linux-at91:

$ cd ~/linux-at91

2

Using default configuration files, configure the Linux kernel using the following command:

$ make ARCH=arm at91_dt_defconfig

HOSTCC scripts/basic/fixdep
HOSTCC scripts/kconfig/conf.o
HOSTCC scripts/kconfig/confdata.o
HOSTCC scripts/kconfig/expr.o
LEX scripts/kconfig/lexer.lex.c
YACC scripts/kconfig/parser.tab.[ch]
HOSTCC scripts/kconfig/lexer/lex.o
HOSTCC scripts/kconfig/parser.tab.o
HOSTCC scripts/kconfig/preprocess.o
HOSTCC scripts/kconfig/symbol.o
HOSTLD scripts/kconfig/conf
#
# configuration written to .config
#

3

Optional: If you would like to verify settings or make customization changes type:

$ make menuconfig

linux_config.png

You may exit menuconfig by repeatedly typing "ESC-ESC" until it closes. Do not save any changes.

4

Build linux-at91:

$ make ARCH=arm

A working cross-toolchain for ARM-based MPU target is required to build linux-at91.

Ensure you set the CROSS_COMPILE=<cross_compiler> and ARCH=arm environment variables.

For example, if your cross-compiler executable is arm-linux-gcc then CROSS_COMPILE=<path_to>/arm-linux-

A second method is you may include these as command variables. For example:

$ make ARCH=arm CROSS_COMPILE=<path_to>/<cross_compiler>

Once the build is complete, the resulting binary files are created:

/arch/arm/boot/zImage
/arch/arm/boot/dts/at91-sam9x60ek.dtb


Create Flattened Image Tree (FIT) and Write to QSPI Flash Memory

In this section, you will create a Flattened Image Tree (FIT). The FIT image allows for more flexibility in handling images of various types and enhances the integrity protection of images with stronger checksums. An Image Source (*.its) file and a set of data files are used as an input. An Image Tree Blob (*.itb) file is generated as the output. Finally, you will write the FIT image to QSPI Flash memory.

1

Git clone the Device Tree Overlay files from the Linux4SAM repository:

2

Change directory to your working directory containing the dt-overlay-at91:

$ cd ~/dt-overlay-at91

3

Open Makefile with your favorite editor and verify the KERNEL_DIR is pointing to your linux-at91 directory:

CC?=$(CROSS_COMPILE)gcc
DTC_OPTIONS?=-@
DTC_OPTIONS += -Wno-unit_address_vs_reg -Wno-graph_child_address -Wno_pwms_property
KERNEL_DIR?=../linux-at91 <--- Ensure pointing to your linux-at91 directory
KERNEL_BUILD_DIR?=$(KERNEL_DIR)
DTC?=$(KERNEL_BUILD_DIR)/scripts/dtc/dtc

Or you can set the KERNEL_DIR environment variable:

$ export KERNEL_DIR=path
$ echo $KERNEL_DIR

4

Build the *.itb image file:

$ make sam9x60ek.itb

Once the build is complete, the resulting image file sam9x60ek.itb is in the dt-overlay-at91 directory.

Remember this directory location as you will be copying the sam9x60ek.itb image to the SD Memory Card.

In the next section, you will prepare an SD Memory Card.


Prepare a Root File System (ROOTFS) for SD Memory Card

In this section, you will download a demonstration image from the Linux4SAM website to use the Root File System on the image. You will flash the image to an SD Memory Card and delete the files in the BOOT partition. Finally, you will copy the Flattened Image Tree (FIT) file that you created in the previous section to the ROOTFS/boot directory.

1

Download SAM9X60-EK demonstration image from the Linux4SAM website.

The latest demonstration images for the SAM9X60-EK are available on the Linux4SAM website. There you will find the demonstration package for NAND Flash memory.

There you will find three sets of images created from one of three Build Systems:

  • The Yocto Project
  • Buildroot
  • OpenWRT

Any one of the images can be used for this step. If you are undecided, choose the linux4sam-buildroot-sam9x60ek-headless file.

2

Flash the demo image to SD Memory Card.

Follow the steps in the "Flash Image with Etcher" training.

3

Insert the SD Memory Card into a Linux desktop computer.

4

Delete the files in the BOOT(FAT32) partition.


Write Image Tree Blob (ITB) to SD Memory Card

1

Copy the sam9x60ek.itb file to the ROOTFS/boot directory.

$ cd ~/dt-overlay-at91
$ cp sam9x60ek.itb /media/<username>/ROOTFS/boot


Boot from QSPI Flash Memory

1

Check that you have Console Serial Communications established.

Review STEP 1 of the SAM-BA In-System Programmer section above.

2

Check that jumper the DIS_BOOT (J13) is open.

This will allow booting from the onboard memories (NAND and QSPI Flash).

3

Insert the SD Memory Card into J4.

4

Press the Reset button SW3 (nRST).

The boot log will display in the terminal emulator. In the end, the command line will prompt the user to log in. Login as ‘root’. There is no password required for login.

qspi_flash_login.png

Proper operation of the image will be indicated by a flashing blue RGB LED (LD1).

If Console Serial Communications is connected to J22, operation of the on-board J-Link Debugger will be indicated by a flashing green LED (D9).

Congratulations! You have created an embedded Linux system that boots from QSPI Flash memory.


Summary

In this training, you configured and built the second-stage bootloader at91bootstap and the third-stage bootloader u-boot-at91 from source code. You wrote the second- and third-stage bootloaders into QSPI Flash memory. You also prepared an SD Memory Card with Flattened Image Tree (FIT) (containing the Linux kernel and Device Tree) and Root File System. The result is an embedded Linux system that boots from QSPI Flash memory.


What’s Next?

© 2021 Microchip Technology, Inc.
Notice: ARM and Cortex are the registered trademarks of ARM Limited in the EU and other countries.
Information contained on this site regarding device applications and the like is provided only for your convenience and may be superseded by updates. It is your responsibility to ensure that your application meets with your specifications. MICROCHIP MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND WHETHER EXPRESS OR IMPLIED, WRITTEN OR ORAL, STATUTORY OR OTHERWISE, RELATED TO THE INFORMATION, INCLUDING BUT NOT LIMITED TO ITS CONDITION, QUALITY, PERFORMANCE, MERCHANTABILITY OR FITNESS FOR PURPOSE. Microchip disclaims all liability arising from this information and its use. Use of Microchip devices in life support and/or safety applications is entirely at the buyer's risk, and the buyer agrees to defend, indemnify and hold harmless Microchip from any and all damages, claims, suits, or expenses resulting from such use. No licenses are conveyed, implicitly or otherwise, under any Microchip intellectual property rights.