NameLast modifiedSizeLicense

Parent Directory Parent Directory
application/octet-stream BL2_AP_Trusted_RAM.bin 12-Jan-2018 10:22 52.0K open
application/octet-stream BL31_AP_Trusted_RAM.bin 12-Jan-2018 10:22 72.0K open
other Image 26-Feb-2018 17:24 8.2M open
application/octet-stream bl1.bin 12-Jan-2018 10:22 44.0K open
other fvp-base-gicv2-psci.dtb 12-Jan-2018 10:22 8.6K open
other fvp-base-gicv2legacy-psci.dtb 12-Jan-2018 10:22 8.6K open
other fvp-base-gicv3-psci.dtb 12-Jan-2018 10:22 8.6K open
text hwpack_linaro-vexpress64-rtsm_20131023-504_arm64_supported.manifest.txt 12-Jan-2018 10:22 512 open
application/x-tar hwpack_linaro-vexpress64-rtsm_20131023-504_arm64_supported.tar.gz 26-Feb-2018 17:24 45.2M open
other img-foundation.axf 26-Feb-2018 17:24 8.4M open
other img.axf 26-Feb-2018 17:24 8.4M open
application/x-tar java-8-openjdk.tar.gz 26-Feb-2018 17:24 47.1M open
other linaro-image-lamp-genericarmv8-20131023-540.manifest 12-Jan-2018 10:22 133.6K open
application/x-tar linaro-image-lamp-genericarmv8-20131023-540.rootfs.tar.gz 26-Feb-2018 17:24 261.9M open
application/octet-stream uefi_fvp-base.bin 12-Jan-2018 10:22 2.5M open
text vexpress64-openembedded_lamp-armv8-gcc-4.8_20131023-504.html 12-Jan-2018 10:22 3.5K open
other vexpress64-openembedded_lamp-armv8-gcc-4.8_20131023-504.img.gz 26-Feb-2018 17:24 315.5M open
other vexpress64-openembedded_lamp-armv8-gcc-4.8_20131023-504.img.gz.zsync 26-Feb-2018 17:25 19.5M open
text vexpress64-openembedded_leg-java-armv8-gcc-4.8_20131023-504.html 12-Jan-2018 10:22 3.5K open
other vexpress64-openembedded_leg-java-armv8-gcc-4.8_20131023-504.img.gz 26-Feb-2018 17:25 570.9M open
other vexpress64-openembedded_leg-java-armv8-gcc-4.8_20131023-504.img.gz.zsync 26-Feb-2018 17:25 19.5M open
text vexpress64-openembedded_minimal-armv8-gcc-4.8_20131023-504.html 12-Jan-2018 10:22 3.5K open
other vexpress64-openembedded_minimal-armv8-gcc-4.8_20131023-504.img.gz 26-Feb-2018 17:25 72.8M open
other vexpress64-openembedded_minimal-armv8-gcc-4.8_20131023-504.img.gz.zsync 26-Feb-2018 17:25 19.5M open

AArch64 OpenEmbedded ARM Fast Models 13.10 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 Foundation, Versatile Express and FVP Base fast models from ARM. Sources are also made available so you can build your own images.

About the AArch64 OpenEmbedded Engineering Build

This release now supports the new (as of September 2013) FVP Base fast model platforms from ARM, in addition to the existing Foundation (Foundation_v8) and Versatile Express (FVP_VE_ARMv8A/RTSM_VE_AEMv8A) model platforms.

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 larger numbers of cores. 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 platform models. New Device trees for these models are included in this release.

This build has been tested to work on the following Fast Model platforms:

  • 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 model is free to use (download from ARM, while the others are licensed from ARM. More information on these specific model platforms is included with this release documentation.

The introduction of the Base platform models sees the introduction of additional software in this engineering build:

  • ARM Trusted Firmware which provides secure boot and runtime firmware
  • Tianocore EDK2 which provides a UEFI based boot environment for the non-secure operating system or hypervisor (in this case, Linux)
    The Foundation_v8 and FVP_VE_AEMv8A models continue to be booted using the AArch64 Linux boot-wrapper.

The ARM Trusted Firmware is a prototype implementation, currently providing a partial implementation of ARM’s Power State Coordination Interface (PSCI) specification. It also provides configuration of the prototype GICv3 interrupt controller (present in the FVP_Base_AEMv8A-AEMv8A) to enable OS and hypervisor driver development for GICv3.

ARM intends to make its 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. More details on the Trusted Firmware can be found elsewhere in this documentation.

The same kernel image is used for all of these models, though the Foundation_v8 and FVP_VE_AEMv8A images are encapsulated as previously by the kernel boot-wrapper.

Where To Find More Information

More information on Linaro can be found on our website.

More information on ARM Fast Models can be found on ARM’s website:

More information on ARM Trusted Firmware and Platform Design Documents (PDDs) can be found elsewhere in this documentation.

More information on building UEFI for AArch64 can be found on Linaro’s wiki:

Feedback and Support

For support matters related to ARMv8 fast models downloaded from ARM sites, please contact ARM Support.

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

Changes in this release

  • Update to Linaro GCC 4.8-2013.10 release
  • Update to Linaro Binutils 2.23.2-2013.10-4 release
  • Add Linaro EGLIBC 2.18-2013.10 release
  • Very minimal and initial introduction of genericarmv8b machine
  • Remove meta-java layer
  • Now tracking git HEAD for QEMU builds
  • Added opengl to DISTRO features
  • LEG: remove openjdk-7
  • LEG: openjdk-8 now builds both client and server hotspot compilers
  • LNG: enable QEMU
  • Add gator to LAMP image
  • Add openssh-sftp-server to lamp/alip images (LP: #1239283)
  • Fix auto-getty hardcodes device names (LP: #1233786)

Known Issues

Linaro OpenEmbedded releases are made up of the following components.

  • a hardware pack supporting Foundation, VE and FVP Base Models
  • a choice of Root file system (RootFS) images
  • The Linux kernel file with and without boot wrapper shims, depending on the version of the model you are using

Using pre-built image


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

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>
tar zxvf linaro-image-tools-2013.10.tar.gz
  • Method 3: Building from the BZR repository
cd <working direcory>
bzr branch lp:linaro-image-tools

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>

Booting the image on the FVP Base AEMv8 model

cd fastmodel
<path to model installation>/models/Linux64_GCC-4.1/FVP_Base_AEMv8A-AEMv8A \
-C pctl.startup= \
-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=bl1.bin \
-C bp.flashloader0.fname=uefi_fvp-base.bin \
-C bp.virtioblockdevice.image_path=sd.img

Booting the image on the FVP Base Cortex model

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

cd fastmodel
<path to model installation>/models/Linux64_GCC-4.1/FVP_Base_Cortex-A57x1-A53x1 \
-C pctl.startup= \
-C bp.secure_memory=0 \
-C cache_state_modelled=1 \
-C bp.pl011_uart0.untimed_fifos=1 \
-C bp.secureflashloader.fname=bl1.bin \
-C bp.flashloader0.fname=uefi_fvp-base.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:

cd fastmodel
<path to model installation>/models/Linux64_GCC-4.1/FVP_Base_Cortex-A57x4-A53x4 \
-C pctl.startup= \
-C bp.secure_memory=0 \
-C cache_state_modelled=1 \
-C bp.pl011_uart0.untimed_fifos=1 \
-C bp.secureflashloader.fname=bl1.bin \
-C bp.flashloader0.fname=uefi_fvp-base.bin \
-C bp.virtioblockdevice.image_path=sd.img

Using Ethernet networking with the FVP Base Models

To enable networking in the 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

If you are using the Foundation Model 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 \
  --network nat

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 fastmodel/sd.img \
  --network nat

Building locally using Jenkins scripts

Initial setup

mkdir openembedded
cd openembedded
git clone git://
cd jenkins-setup
git checkout release-13.10
cd ..
sudo bash jenkins-setup/
bash jenkins-setup/

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


  • Ubuntu 12.04 64 bit system. You can download Ubuntu from
  • git
sudo apt-get install build-essential git
  • toolchain
mkdir -p ~/bin
cd ~/bin
tar xf gcc-linaro-aarch64-linux-gnu-4.8-2013.10_linux.tar.xz

Get the Linaro Kernel Source

git clone git://
cd linux-linaro-tracking
git checkout ll_20130918.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/ \
linaro/configs/linaro-base.conf \
linaro/configs/linaro-base64.conf \
linaro/configs/distribution.conf \
linaro/configs/vexpress64.conf \
linaro/configs/kvm-host.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.


About ARM Trusted Firmware

The Trusted Firmware implements a subset of the Trusted Board Boot Requirements (TBBR) Platform Design Document (PDD1) 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) PDD2 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 PDD3.

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.
  • There is no support for trusted world interrupt handling or switching context between trusted and non-trusted worlds in EL3.
  • The PSCI api calls `AFFINITY_INFO` & `PSCI_VERSION` are implemented but have not been tested.
  • The “psci” nodes in the Flattened Device Trees (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.

Further Information

More details on how the ARM Trusted Firmware in this release is structured and operates can be found in the readme file

This includes a description of the firmware files bl1.bin, BL2_AP_Trusted_RAM.bin and BL31_AP_Trusted_RAM.bin.

References: ARM Platform Design Documents (PDDs)

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

Available under NDA from ARM.

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

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

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, multi-cluster and some new standard peripherals

The Foundation models use a small subset of the platform peripherals in the VE and Base platforms.

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

Model Platform Processors GIC Block device ARM TF support1
virtio mmc
Foundation_v8 Foundation AEMv8×1-42 GICv2 y (y3)
FVP_VE_AEMv8A VE AEMv8×1-42 GICv2 y
FVP_Base_AEMv8Ax4-AEMv8Ax4 Base AEMv8×1-4 + AEMv8×1-42 GICv34 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 v4.8 of the Foundation_v8 model, v5.1 and v5.2 of the other FVP models.

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

2 The number of CPU cores in each cluster can be configured when running the AEMv8 models

3 The next update to the Foundation_v8 model, which is coming soon, will be supported by ARM Trusted Firmware

4 The default Device Tree (fvp-base-gicv2-psci.dtb) only presents a GICv2 interrupt controller node. However, there is an alternative Device Tree (fvp-base-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 this model.

The Foundation_v8 model is free to use and can be downloaded from ARM, the other models are licensed from ARM. More information on the ARM FVP models and download links can be found on the ARM website

OpenJDK 8 snapshot for AArch64

This is a client (C1) and server (C2) release of OpenJDK 8 for
AArch64. This release is based on tag ‘jdk8-b110’ of the OpenJDK
source tree.

The AArch64 branch of this tree is found at:

and the release is based on the ‘preview_rc2’ tag in that tree.

The release may be obtained either as part of the Linaro OpenEmbedded
13.10 leg-java image, as a standalone binary tarball or as a Fedora 19

The OpenEmbedded 13.10 image may be found at:

The binary tarball may be found at:

The Fedora 19 RPM may be found at:

Running OpenJDK 8

By default this build of OpenJDK 8 will run the client (C1)
compiler. To run the server (C2) compiler invoke as ‘java -server’.

Release Status

The client (C1) version of this release represents a fully functional
stable release with no known critical faults. However, there are
corner cases in the test suites that currently fail but they are being

The server (C2) version should be considered a preview release
only. It is believed to be fully functional but there are known
critical faults.

Testing and Continuous Integration

Testing of OpenJDK 8 is done by running the
Mauve and
JTREG test suites on a daily basis.

The tests are executed via the
LAVA test environment and are
run on the ARM FastModels.

Only the hotspot tests are being run from the JTREG test suite as the
current focus is on the AArch64 client (C1) and server (C2) compilers.

Test Results

Tests run on the FastModels are captured in the daily image reports.

Known Problems

When invoking java with -server (C2) occasional SIGSEGVs have been
seen in the parallel garbage collector. This tends to occur in highly
multi-threaded applications. The workaround is to use
-XX:-UseParallelGC when invoking java.

Known Problems when running on OpenEmbedded 13.10

The following bugs currently affect the installation of OpenJDK 8 in
the 13.10 release but there are workarounds which are documented in
the bug descriptions: