NOTE: This release location is to be deprecated – please use ARM Development Platform Software

AArch64 OpenEmbedded ARM Fast Models 15.07 Release

The AArch64 Open Embedded Engineering Build for ARM Fast Models for ARMv8 is produced, validated and released by Linaro, based on the latest AArch64 open source software from Tianocore EDK2 (UEFI), the Linux kernel, ARM Trusted Firmware and OpenEmbedded. It is produced to enable software development for AArch64 prior to hardware availability, and facilitates development of software that is independent of the specific CPU implementation. This build focuses on availability of new features in order to provide a basis for ongoing and dependent software development.

Linaro releases monthly binary images of this engineering build. This release includes Linaro OpenEmbedded images for Versatile Express, Base and Foundation Fixed Virtual Platform (FVP) models from ARM. Sources are also made available so you can build your own images.

About the AArch64 OpenEmbedded Engineering Build

This release has been tested on the Base FVPs from ARM (since September 2013), in addition to the updated Foundation FVP (since November 2013) and Versatile Express FVP.

The ‘Base’ platform is an evolution from the Versatile Express (VE) platform that is better able to support new system IP, larger memory maps and multiple CPU clusters. The changes in the Base platform memory map require that software or device trees which specify peripheral addresses may need to be modified for the Base FVPs. Device trees for these FVPs are included in this release.

This build has been tested to work on the following FVPs:

• Foundation_v8
• FVP_VE_AEMv8A (previously called RTSM_VE_AEMv8A before v5.0)
• FVP_Base_AEMv8A-AEMv8A
• FVP_Base_Cortex-A57×4-A53×4
• FVP_Base_Cortex-A57×1-A53×1

The Foundation_v8 FVP is free to use (download from ARM http://www.arm.com/fvp), while the others are licensed from ARM. More information on these specific FVPs is included with this release documentation.

The Base and Foundation FVPs use the following software for boot and runtime firmware services in this engineering build:

• ARM Trusted Firmware provides a reference implementation of secure world software for ARMv8-A, including Exception Level 3 (EL3) software
• Tianocore EDK2 which provides a UEFI based boot environment for the normal world operating system or hypervisor (in this case, Linux)
  The VE FVP continues to be booted using the AArch64 Linux boot-wrapper.

The same kernel image is used for all of these models, though the FVP_VE_AEMv8A image is encapsulated by the kernel boot-wrapper as in previous releases.

Where To Find More Information

More information on Linaro can be found on our website.

More information on ARM FVPs can be found on ARM’s website: http://www.arm.com/fvp.

More information on ARM Trusted Firmware and Platform Design Documents (PDDs) can be found on the project’s GitHub repository: http://github.com/ARM-software/arm-trusted-firmware.

More information on building UEFI for AArch64 can be found on Linaro’s wiki: https://wiki.linaro.org/LEG/Engineering/Kernel/UEFI/build.

Feedback and Support

Relating to the ARM Fixed Virtual Platforms:

• For technical support on the Foundation_v8 FVP use the ARM support forums, http://forums.arm.com
• For technical support on the Base and VE FVPs contact ARM Fast Models Support, support-esl@arm.com
• To provide feedback to ARM relating to any of the FVPs, please refer to the respective product documentation

To provide feedback or ask questions about the ARM Trusted Firmware, please create a new Issue at GitHub.

Subscribe to the important Linaro mailing lists and join our IRC channels to stay on top of Linaro development.

• Linaro Development mailing list
• Linaro IRC channel on irc.freenode.net at #linaro
• Bug reports should be filed in Launchpad to Linaro OpenEmbedded project.
• Questions? ask Linaro.
• Interested in commercial support? Inquire at Linaro support

Changes in this release

• OpenDataPlane recipe added
• Linaro PowerDebug recipe added
• ACPICA updated to 20131115
• Add initscript for gator

Known Issues

• HTTP downloads get cut short in Foundation model
• perf self test does not execute on Linaro openembedded lamp image
• phpmysql test fail on Linaro openembedded Lamp image on Lava
• level 1 translation fault when extracting bzipped tarball

Linaro OpenEmbedded releases are made up of the following components.

img.gz	pre-built images for minimal, LAMP and LEG root filesystems
hwpack_*.tar.gz	a single hardware pack for the Foundation, Versatile Express [1] and Base platform models
linaro-image-*.rootfs.tar.gz	a choice of Root file system (RootFS) images
Image	kernel used by UEFI
foundation.axf	kernel binary wrapped for the Foundation model
img.axf	kernel binary wrapped for the Versatile Express model
*_bl1.bin	ARM Trused Firmware BL1 binaries
*_fip.bin	ARM Trused Firmware Firmware Image Package (FIP) binaries
dtb files	Device Tree Binaries

Other files such as *.manifest, *.txt and *.html provide information such as package contents or MD5SUMs about the files they share a common filename with.

¹ Linaro does not provide support for running the Versatile Express models.

Using pre-built image

Prerequisites

• Ubuntu 12.04 64 bit or newer on your desktop PC (www.ubuntu.com)
• Foundation, Versatile Express or Base platform fast model (Linaro ARMv8 Engineering)
• All artifacts for this release downloaded from the above list.
• 14.04 linaro-image-tools or later

Installation Steps

• Unzip the downloaded pre-built image

gunzip vexpress64-openembedded_*-armv8*.img.gz

• Skip to the section below showing how to Boot the image.
  Replace sd.img with the filename of the image unzipped above.

Build Your Own Image

Installing Linaro Image Tools

There are multiple ways you can get the latest Linaro Image Tools:

• Method 1: Install them from the Linaro Image Tools PPA

sudo add-apt-repository ppa:linaro-maintainers/tools
sudo apt-get update
sudo apt-get install linaro-image-tools

• Method 2: Install from release tarball

cd <installation directory>
wget http://releases.linaro.org/14.12/components/platform/linaro-image-tools/linaro-image-tools-2014.12.tar.gz
tar zxvf linaro-image-tools-2014.12.tar.gz
PATH=`pwd`/linaro-image-tools-2014.12:$PATH

• Method 3: Building from the GIT repository

cd <working direcory>
git clone git://git.linaro.org/infrastructure/linaro-image-tools.git
PATH=`pwd`/linaro-image-tools:$PATH

Creating a disk image

• Download the hardware pack (hwpack-*.tar.gz) from the above list
• Download the rootfs (linaro-*.tar.gz) of your choice from the above list, LAMP is usually a good selection for a more fully featured disk image
• Create the image

linaro-media-create --dev fastmodel --output-directory fastmodel --image_size 2000M --hwpack <hwpack filename> --binary <rootfs filename>
cd fastmodel

Boot the image

Using the FVP Base AEMv8 model

ln -sf fvp-base-gicv2-psci.dtb fdt.dtb
<path to model installation>/models/Linux64_GCC-4.1/FVP_Base_AEMv8A-AEMv8A \
-C pctl.startup=0.0.0.0 \
-C bp.secure_memory=0 \
-C cluster0.NUM_CORES=4 \
-C cluster1.NUM_CORES=4 \
-C cache_state_modelled=1 \
-C bp.pl011_uart0.untimed_fifos=1 \
-C bp.secureflashloader.fname=fvp_bl1.bin \
-C bp.flashloader0.fname=fvp_fip.bin \
-C bp.virtioblockdevice.image_path=sd.img

Using the FVP Base Cortex model

To boot the A57×1 + A53×1 model:

ln -sf fvp-base-gicv2-psci.dtb fdt.dtb
<path to model installation>/models/Linux64_GCC-4.1/FVP_Base_Cortex-A57x1-A53x1 \
-C pctl.startup=0.0.0.0 \
-C bp.secure_memory=0 \
-C cache_state_modelled=1 \
-C bp.pl011_uart0.untimed_fifos=1 \
-C bp.secureflashloader.fname=fvp_bl1.bin \
-C bp.flashloader0.fname=fvp_fip.bin \
-C bp.virtioblockdevice.image_path=sd.img

To boot the A57×4 + A53×4 model, use the same command, only specify a different model binary:

ln -sf fvp-base-gicv2-psci.dtb fdt.dtb
<path to model installation>/models/Linux64_GCC-4.1/FVP_Base_Cortex-A57x4-A53x4 \
-C pctl.startup=0.0.0.0 \
-C bp.secure_memory=0 \
-C cache_state_modelled=1 \
-C bp.pl011_uart0.untimed_fifos=1 \
-C bp.secureflashloader.fname=fvp_bl1.bin \
-C bp.flashloader0.fname=fvp_fip.bin \
-C bp.virtioblockdevice.image_path=sd.img

Using Ethernet networking with the FVP Base Platform Models

To enable networking in the Base FVP models, you should install a network TAP on your local machine. See the Fast Models User Guide for more information on setting up a TAP for use with the models.

Then, with the network TAP enabled, run with model as above, but with these additional parameters

-C bp.hostbridge.interfaceName=ARM$USER \
-C bp.smsc_91c111.enabled=true \
-C bp.smsc_91c111.mac_address=<MAC address, eg, 00:11:22:33:44:55>

Booting the image on the Foundation Model

The latest version of the Foundation Model (version 0.8.5206, as of November 2013) is compatible with the ARM Trusted Firmware and UEFI. To launch the Foundation Model, use the following command:

ln -sf fvp-foundation-gicv2-psci.dtb fdt.dtb
<path to model installation>/Foundation_v8 \
--cores=4 \
--no-secure-memory \
--visualization \
--gicv3 \
--data=fvp_bl1.bin@0x0 \
--data=fvp_fip.bin@0x8000000 \
--block-device=sd.img

note: it is intentional that we suggest using the GICv2 DTB file, whilst specifying GICv3 on the model command line. In this mode, you are using the GICv3 controller in GICv2 compatibility mode, which is the default recommended by ARM.

Booting the image on the Foundation Model using the AXF file

If you are using an older version of Foundation Model (i.e. older than version 0.8.5206) and wish to use a pre-built image, you can simply unzip the downloaded pre-built image and the img-foundation.axf file and run the following command:

<path to model installation>/Foundation_v8 --image img-foundation.axf \
  --block-device vexpress64-openembedded_IMAGENAME-armv8_IMAGEDATE-XYZ.img

To use the image you built with linaro-media-create in the steps above, run this command:

<path to model installation>/Foundation_v8 --image img-foundation.axf \
  --block-device sd.img

Using Ethernet networking on the Foundation Models

The Foundation Models can be configured to use either NAT or Bridged mode.

For the basic NAT confgiuration, add the following option to the command used to launch the model:

--network nat

For Bridged networking, you will need to set up a network TAP as per the FastModels user guide. Then, the following options may work:

--network bridged --network-bridge=ARM$USER

Details of the Foundation Model’s command line options can be found in the Foundation model documentation on ARM’s website.

Building locally

Initial setup

mkdir openembedded
cd openembedded
git clone http://git.linaro.org/openembedded/jenkins-setup.git
cd jenkins-setup
git checkout master
cd ..
sudo bash jenkins-setup/pre-build-root-install-dependencies.sh
bash jenkins-setup/init-and-build.sh

This will clone all required repositories and does initial setup.

Do a build

cd openembedded-core
. oe-init-build-env ../build
bitbake bash

Of course you can use other targets instead of “bash”. Use “linaro-image-minimal” to build a simple rootfs.

Usable build targets

• linaro-image-minimal – very minimal rootfs
• linaro-image-lamp – LAMP stack and toolchain
• linaro-image-leg-java – Same as LAMP image but also includes OpenJDK-7 and OpenJDK-8

Building the Linaro Kernel

Prerequisites

• Ubuntu 12.04 64 bit system. You can download Ubuntu from ubuntu.com
• git

sudo apt-get install build-essential git

• toolchain

mkdir -p ~/bin
cd ~/bin
wget http://releases.linaro.org/14.11/components/toolchain/binaries/aarch64-linux-gnu/gcc-linaro-4.9-2014.11-x86_64_aarch64-linux-gnu.tar.xz
tar xf gcc-linaro-4.9-2014.11-x86_64_aarch64-linux-gnu.tar.xz
PATH=$PATH:~/bin/gcc-linaro-4.9-2014.11-x86_64_aarch64-linux-gnu.tar.xz

Get the Linaro Kernel Source

git clone git://git.linaro.org/kernel/linux-linaro-tracking.git
cd linux-linaro-tracking
git checkout ll_20150619.0

Create a kernel config

Do not use the arm64 defconfig, instead, build a config from the config fragments that Linaro provides:

ARCH=arm64 scripts/kconfig/merge_config.sh \
linaro/configs/linaro-base.conf \
linaro/configs/distribution.conf \
linaro/configs/vexpress64.conf \
linaro/configs/kvm-host.conf \
linaro/configs/kvm-guest.conf

Note: the config fragments are part of the git repository and the source tarball.

Build the kernel

To build the kernel uImage, use the following command:

make ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- Image

Install your kernel

Create the Device Tree blob if you don’t have one in your Linaro image:

make ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- dtbs

Copy the kernel and the DTB file for your model to your fastmodel directory created in the Binary Installation tab.

cp arch/arm64/boot/Image <fastmodel dir>
cp arch/arm64/boot/dts/*.dtb <fastmodel dir>

Building UEFI

To rebuild the UEFI binaries, see the UEFI Wiki and specifically the UEFI build page.

ARM Trusted Firmware

The ARM Trusted Firmware is designed to implement the trusted (or secure) boot and runtime firmware needed for ARMv8 Base platform models, and provide a reference implementation of various ARM interface standards, such as the Power State Coordination Interface (PSCI) and Trusted Board Boot Requirements (TBBR). It executes entirely in the ARMv8 secure states (aka ARM TrustZone): EL3 and Secure-EL1.

This release includes a binary, prototype implementation of ARM Trusted Firmware. Only limited functionality is provided at this time. It has not been optimized or subjected to extended robustness or stress testing.

ARM intends to make the Trusted Firmware open source and continue development to provide a full reference implementation of PSCI and an example of Trusted Board Boot for ARMv8 platforms

License Details

Copyright © 2013, ARM Limited. All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

• Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
• Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
• Neither the name of ARM nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

About ARM Trusted Firmware

The Trusted Firmware implements a subset of the Trusted Board Boot Requirements (TBBR) Platform Design Document (PDD¹) for ARM reference platforms. The TBB sequence starts when the platform is powered on and runs up to the stage where it hands-off control to firmware running in the non-trusted world in non-trusted DRAM. This is the cold boot path.

The ARM Trusted Firmware also implements the Power State Coordination Interface (PSCI) PDD² as a runtime service. PSCI is the interface from non-trusted world software to firmware implementing power management use-cases (for example, secondary CPU boot, hotplug and idle). Non-trusted world software can access ARM Trusted Firmware runtime services via the ARM `SMC` (Secure Monitor Call) instruction. The `SMC` instruction must be used as mandated by the SMC Calling Convention PDD³.

Functionality Included

• Initial implementation of a subset of the Trusted Board Boot Requirements (TBBR) Platform Design Document (PDD).
• Initializes the trusted world (for example, exception vectors, control registers, GIC and interrupts for the platform), before transitioning into the non-trusted world.
• Supports both GICv2 and GICv3 initialization for use by non-trusted world software.
• Handles SMCs (Secure Monitor Calls) conforming to the SMC Calling Convention Platform Design Document (PDD).
• Handles SMCs relating to the Power State Coordination Interface (PSCI) PDD for the Secondary CPU Boot and hotplug use-cases only.

Known Issues

The following is a list of issues which are expected to be fixed in the future
releases of the ARM Trusted Firmware.

• ARM Trusted Firmware does not have support for the TrustZone Address Space Controller (TZC-400). Use of `-C bp.secure_memory=1` is not supported.
• No support for trusted world interrupt handling or switching context between trusted and non-trusted worlds in EL3.
• PSCI api calls `AFFINITY_INFO` & `PSCI_VERSION` are implemented but have not been tested.
• The “psci” nodes in the FDTs provided in this release do not fully comply with the recommendations made in the PSCI specification. There are minor mistakes in the FDT definitions that do not match the functionality provided by the ARM Trusted Firmware.

References: ARM Platform Design Documents (PDDs)

¹ Trusted Board Boot Requirements CLIENT PDD (ARM DEN 0006B-5):

Available under NDA from ARM.

² Power State Coordination Interface PDD (ARM DEN 0022B.b):

http://infocenter.arm.com/help/topic/com.arm.doc.den0022b/index.html

³ SMC Calling Convention PDD (ARM DEN 0028A):

http://infocenter.arm.com/help/topic/com.arm.doc.den0028a/index.html

ARM Fast Models

Built from ARM’s Fast Model toolkit, ARM provides a number of ready-to-use simulation models of platforms containing ARM processors, referred to as Fixed Virtual Platforms. This OpenEmbedded Engineering Build is designed to work with a number of those FVPs which contain ARMv8 processors:

• Foundation_v8
• FVP_VE_AEMv8A (previously called RTSM_VE_AEMv8A before v5.0)
• FVP_Base_AEMv8A-AEMv8A
• FVP_Base_Cortex-A57×4-A53×4
• FVP_Base_Cortex-A57×1-A53×1

There are two primary platform definitions used by the FVPs:

• VE – a replica of the ARM Versatile Express hardware development boards
• Base – an evolution of Versatile Express that can support larger memory maps, multiple clusters and some new standard peripherals

The Foundation platform is a subset of the platform peripherals in the Base platform.

The following table describes the essential differences between these ARMv8 models:

Model	Platform	Processors	GIC	Block device		ARM TF support1
				virtio	mmc
FVP_VE_AEMv8A	VE	AEMv8×1-42	GICv2		y
Foundation_v8	Foundation	AEMv8×1-42	GICv2/v34	y		y3
FVP_Base_AEMv8Ax4-AEMv8Ax4	Base	AEMv8×1-4 + AEMv8×1-42	GICv2/v34	y	y	y
FVP_Base_Cortex-A57×4-A53×4	Base	A57×4 + A53×4	GICv2	y	y	y
FVP_Base_Cortex-A57×1-A53×1	Base	A57×1 + A53×1	GICv2	y	y	y

The platform support in each of these models does evolve gradually over time, this information is correct with respect to builds 0.8.5206 and 9.0.26 of the Foundation_v8 FVP (released as v2.0 and v2.1), and builds from 0.8.5108 to 0.8.5802 of the VE and Base FVPs.

¹ Platforms that do not support the ARM Trusted Firmware need to use a bootwrapper for the kernel image

² The number of CPU cores in each cluster can be configured when running the AEMv8 FVPs

³ ARM Trusted Firmware requires a v2.0 or v2.1 Foundation_v8 FVP (build numbers 0.8.5206 and 9.0.26 respectively)

⁴ The default Device Trees (fvp-base-gicv2-psci.dtb and fvp-foundation-gicv2-psci.dtb) only present a GICv2 interrupt controller node to Linux. However, there are alternative Device Trees (fvp-base-gicv3-psci.dtb and fvp-foundation-gicv3-psci.dtb) provided in this Engineering Build that includes the GICv3 node, which is needed for development of OS and hypervisor GICv3 support. It is also possible to configure the GIC to be GICv2 when running these FVPs.

The Foundation_v8 FVP is free to use and can be downloaded from ARM, the other FVPs are licensed from ARM. More information on the ARM FVPs and download links can be found on the ARM website http://www.arm.com/fvp.