NameLast modifiedSizeLicense

Parent Directory Parent Directory
other MANIFEST 12-Jan-2018 08:21 265 open
other MD5SUMS 12-Jan-2018 08:21 147 open
application/x-tar boot.tar.bz2 26-Feb-2018 16:40 10.9M open
other kernel_config 12-Jan-2018 08:21 56.2K open
other lava-job-info 12-Jan-2018 08:21 74 open
application/x-sh 12-Jan-2018 08:22 7.1K open
application/x-sh 12-Jan-2018 08:22 1.8K open
text pinned-manifest.xml 12-Jan-2018 08:22 51.5K open
text source-manifest.xml 12-Jan-2018 08:22 64.1K open
application/x-tar system.tar.bz2 26-Feb-2018 16:40 163.1M open
application/x-tar userdata.tar.bz2 12-Jan-2018 08:22 707.7K open
other vexpress.img.bz2 26-Feb-2018 16:40 174.6M open

Versatile Express 13.07 Release

Linaro releases monthly binary images for the ARM Versatile Express including support for Cortex-A9, Cortex-A5, TC2 (big.LITTLE) CoreTiles and RTSM.

For support matters related to ARM hardware or firmware images downloaded from ARM sites, please contact ARM support

This release includes Linaro Android Jelly Bean and Ubuntu Raring for both Versatile Express and Real-Time System Model (RTSM). The images are able to boot A5 (using U-Boot), A9 (ATAGS) and TC2 using UEFI. Sources are also made available so you can build your own images.

About the TC2 Engineering Build

This release is based on the Linux v3.10 kernel. As a consequence, almost all of the patches in the ARM Landing Team tree have been rebased and refactored to account for the latest upstream content.

The TC2 CoreTile is the first example of a big.LITTLE system shipped by ARM and serves as a platform for development and test of big.LITTLE software. TC2 contains a tri-core Cortex-A7 cluster and a dual-core Cortex-A15 cluster linked using the CCI–400 coherent interconnect.

The release contains the big.LITTLE MP patchset developed by ARM. This patchset is hosted by Linaro and can be found in the linked git repository. These patches have been developed and rigorously tested in order to enable the ARM Versatile Express V2P-CA15_A7 CoreTile (TC2) to run in full MP mode. This functionality has been optimised for energy and performance bringing it close to the Cortex-A7 (LITTLE) in energy consumption with near Cortex-A15 (big) performance. The patchset also includes optimizations that provide a considerable performance uplift across a wide range of benchmarks. The functionality introduced by this patchset is stable and ready for use on other platforms. Note that at present this LEB release is the reference point for big.LITTLE MP functionality. In future, an LSK (Linaro Stable Kernel) release shall become this reference point and we will clearly advertise this when the change happens.

The patches in the big.LITTLE MP patchset are generic and applicable to big.LITTLE systems with minimal porting effort. To ease porting, the patches are also available as an isolated package located here. This package may be used directly by partners interested in porting the big.LITTLE MP scheduler functionality to their custom platform. Please contact with ‘Query about ARM big.LITTLE MP patchset package’ in the subject line in case of any queries related to this package.

Also provided is optional configurable kernel support for an implementation of ARM’s Power State Co-ordination Interface (PSCI). This support is disabled by default. To use PSCI support you will require secure firmware that is currently available to ARM licensees upon request to ARM. Please contact with the subject line “Access to PSCI” to get access to the firmware code.

Scheduler modifications to support big.LITTLE

The following patches make up the big.LITTLE MP patchset.

  • sched: Implement usage tracking
  • sched: Entity load tracking load_avg_ratio
  • sched: Task placement for heterogeneous systems based
  • sched: Forced task migration on heterogeneous systems
  • sched: Introduce priority based task migration filter
  • sched: Add HMP scheduling support for ARM architecture
  • sched: Use device tree to provide fast slow CPU
  • sched: Setup SCHED_HMP domains
  • sched: Add ftrace events for entity load tracking
  • sched: Add HMP task migration ftrace event
  • sched: SCHED_HMP multi domain task migration control
  • sched: Enable HMP priority filter by default
  • sched: Avoid empty slow HMP domain
  • sched: Only down migrate low priority tasks if allowe
  • sched: Fix arch_get_fast_and_slow_cpus to get logical
  • sched: Do not ignore grouped tasks during HMP forced
  • sched: Ignore offline CPUs in HMP migration load stat
  • sched: Change load tracking scale using sysfs
  • sched: Experimental Frequency Invariant Load Scaling Pa
  • sched: Fix build breakage when big.LITTLE.conf is not u
  • sched: Basic global balancing support for HMP
  • sched: cfs.nr_running does not contain the intended m
  • sched: Revert sched Enable HMP priority filter by default
  • sched: Use unweighted load for hmp migration decisions
  • sched: Select least loaded CPU when performing HMP Migr
  • sched: Avoid multiple calls to hmp_domain_min_load in f
  • sched: Force new non kernel tasks onto big CPUs until l
  • sched: Restrict nohz balance kicks to stay in the HMP
  • sched: Experimental Force all rt tasks to start on litt

Platform Support.

In addition to the big.LITTLE MP work the TC2 platform support includes:

  • TC2: reset CPUs spuriously woken up on cluster power up
  • vexpress: add shim layer for psci backend on TC2
  • vexpress: allow native pm ops backends to probe for psci suppport
  • psci: add cmdline option to enable use of psci
  • psci: add probe function to discover presence of a psci implementation
  • psci: convert psci ‘-EALREADYON’ error code to linux ‘-EAGAIN
  • vexpress: add psci support in TC2 device tree
  • psci: add constants to specify affinity levels
  • TC2: replace hard coded cluster and cpu values with constants
  • TC2: use generic accessors to extract cpu and cluster ids
  • CPUidle & CPUfreq support
  • hwmon driver allowing, amongst other things, TC2’s power, current and energy measurements to be read through standard sysfs interfaces
  • Common clocks implementation
  • Regulator driver
  • Drivers for previously hard-coded configuration interfaces
  • Support self-hosted debugging through idle
  • In addition to the CPU PMUs the perf framework supports the CCI-400 PMUs
  • A patch from Thomas Gliexner which supports a IRQ affinity mask being specified in the command line. This can be used to reduce unnecessary IRQ wakeups on Cortex-A15. For instructions see the irqaffinity entry in Documentation/kernel-parameters.txt
  • arm-multi_pmu_v2 – enables the use of multiple PMU types or sources, for example profiling across both Cortex-A15 and Cortex-A7 clusters and getting results for CCI.

Where To Find More Information

More information on Linaro can be found on our website.

Feedback and Support

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

  • Linaro Android Development mailing list
  • Linaro Android IRC channel on at #linaro-android

  • Landing Team bug reports should be filed in JIRA by clicking on the “Create issue” button on the top menu bar.
    • You will need to login to your JIRA account. If you do not have an account or are having problems, email for help.
  • More general bug reports should be filed in Launchpad against the individual packages that are affected. If a suitable package cannot be identified, feel free to assign them to Linaro project.
  • Questions? ask Linaro.
  • Interested in commercial support? inquire at Linaro support

Resolved in this release

  • ARM-32 VE firmware from Linaro 1304 patch seemingly breaks the debugger connection to TC2 (A15×2, A7×3)

Known Issues

General Issues

  • ARM-16 LP:1097309 – serial console doesn’t received characters on TC2
  • ARM-24 LP:1172350 – Audio playback under Android JellyBean stops sporadically on TC2 with release 13.03
  • ARM-29 Unplugging and reconnecting HDMI cable hangs vexpress Android
  • ARM-30 Intermittent rcu_sched messages reporting CPU stall observed, which keep on repeating
  • ARM-35 Warning in kmalloc_slab when running Android on RTSM

Known Issues due to lack of video acceleration

  • LP: #987155 vexpress: Angrybirds display severely truncated
  • LP: #987172 vexpress: YouTube video playback fails

Known Issues due to lack of software implementation

  • LP: #1042755 TC2: powertop doesn’t show correct frequency stats

Known Issues due to generic Android features


Known Issues due to generic Ubuntu features

  • LP: #966411 vexpress: ubuntu: Network manager doesn’t manage ethernet connection
  • ARM-23 LP:1129005 – Intermittent failure of LTP shmat01 testcase

Known Issues due to u-boot not being supported by ARMLT

U-Boot is not supported by the ARM Landing Team. Therefore any u-boot bugs are marked as Won’t Fix.

  • LP: #912595 l-m-c fails on vexpress due to a change in u-boot name
  • LP: #880859 U-Boot boot script doesn’t work on Versatile Express

Known Issues due to hardware configuration in LAVA

Hardware configuration in LAVA is not under Landing Team control. Therefore any issues arising due to such hardware configuration are marked as Won’t Fix by the Landing Team.

  • LP: #1009326 e2eaudio test failed on Origen, Snowball & vexpress ubuntu image.

Linaro provides two methods for installing Linaro binary builds:

  1. Using a pre-built image, which you can download
  2. Assembling your own image using provided components

Pre-Installation Steps

Before any installation begins, it is important that you ensure your Versatile Express board has the latest firmware and boot loader installed. Please check the “Firmware Update” tab on this page for the latest updates and installation instructions.

Using pre-built image


  • Ubuntu 12.04 64 bit or newer on your desktop PC, which you can download from
  • 4GB SD card or larger
  • Latest firmware installed onto the Versatile Express. Please see “Firmware Update” tab
  • This release pre-built image (vexpress.img.bz2), which you can downloaded from the above list of artifacts or just click here

Installation Steps

  • Unzip the downloaded pre-built image
  • Insert SD card into your PC and note the assigned '/dev/sdX'
SDCARD=/dev/sdX # sdcard found from dmesg above
bzcat vexpress.img.bz2 | sudo dd bs=64k of=$SDCARD

When the image is created, skip down to the section “Booting the image”.

Note: Windows users may use the Image Writer for Windows

Building a custom image using pre-built components.

Sometimes, you may wish to build your own custom image for a Versatile Express. Perhaps you wish to use a more recent snapshot of the hardware pack for Ubuntu or take the latest Android build. Whatever the reason, you will want to use the Linaro Image Tools to create a custom image.

Using components to generate the image will yield the same functionality found in the pre-built image of the same release.


  • Ubuntu 12.04 64 bit or newer on your desktop PC, which you can download from
  • Download Artifacts from above or use the following command in your terminal

  • 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: Building from source

  • Insert SD card and note the assigned '/dev/sdX' or '/dev/mmcblk0'
dmesg | less

Look for a line that looks like the following at the end of the log

[288582.790722] sdc: sdc1 sdc2 sdc3 sdc4 <sdc5 sdc6 >

Or, if your machine uses '/dev/mmcblkX', you may see a line line this:

[10770.938042] mmcblk0: p1 p2 p3 p4 < p5 p6 >

WARNING: In the next step, make sure you use /dev/"whatever you see above". You can erase your hard drive with the wrong parameter.

  • Create media
linaro-android-media-create --mmc /dev/sdX --dev vexpress --boot boot.tar.bz2 --system system.tar.bz2 --userdata userdata.tar.bz2

Booting the image

After the media create tool has finished executing, remove the SD card from your PC and insert it into the Versatile Express board.

Before you can boot the image you will need to install the UEFI boot loader into NOR flash and update the Versatile MMC card configuration files. The instructions on the Firmware Update tab provide information on how to do this and how to configure UEFI to specify the SD card as a boot device.

Advanced Setup for Benchmarking

Advanced users of Versatile Express may wish to perform benchmarking tests on the board.

Booting with the root filesystem on a USB mass storage device is more efficient both in terms of electrical power and processing speed. Unfortunately, UEFI does not support booting the kernel from USB. In order to achieve this, we recommend that you install the kernel onto SD card and the root filesystem to USB mass storage.

The instructions below will create two identical images: one on SD card and one on USB mass storage. The user is able to choose which device the kernel uses for the root filesystem by adding a command line parameter. By default, the android kernel will expect the root filesystem to be read from the SD card. Adding the parameter “androidboot.hardware=arm-versatileexpress-usb” to the command line will over-ride this behaviour and instruct the kernel to read the root filesystem from USB.

Before following these instructions, ensure that you have both an SD card and a USB mass storage device of at least 4GB inserted into your Linux machine.

Using a pre-built image

Follow the instructions above for creating an image on an SD card. Then repeat the instructions using the device path for your USB device. For example:

SDCARD=/dev/sdX # sdcard found from dmesg above
USBMS=/dev/sdY # USB device found from dmesg above
bzcat vexpress.img.bz2 | sudo dd bs=64k of=$SDCARD
bzcat vexpress.img.bz2 | sudo dd bs=64k of=$USBMS

Using linaro-android-media-create

First the user should run linaro-android-media-create as described above. Then run it again with a USB mass storage device. This will create two release images: one on the SD card and the other on the USB device.

For example:

SDCARD=/dev/sdX # sdcard found from dmesg above
USBMS=/dev/sdY # USB device found from dmesg above
linaro-android-media-create --mmc $SDCARD --dev vexpress --boot boot.tar.bz2 --system system.tar.bz2 --userdata userdata.tar.bz2
linaro-android-media-create --mmc $USBMS  --dev vexpress --boot boot.tar.bz2 --system system.tar.bz2 --userdata userdata.tar.bz2

Booting your system with the advanced setup

Insert the SD card into the card slot on the Versatile Express board and insert the USB device into one of the USB device slots on the board. The USB slots are located below the ethernet port on the rear panel.

Boot the board using the standard UEFI firmware setup as described in the Firmware Update tab.

When UEFI starts, you will need to interrupt the boot countdown and edit the configuration to add the following text to the end of the kernel commandline:


Instructions for updating the UEFI configuration can be found on the UEFI wiki

Accessing Source Code

Linaro Android JB Source Code

Run the, it will download the entire source code for both Android JB and the kernel and attempt to build it.

The pinned and source manifests can be found here:

Kernel Source Code

Obtain the exact kernel source code for this cycle by using the script to download the source and build it. You can get the kernel configuration from here (listed above)

Compiling Linaro Android RootFS+Kernel

The following simple steps download, install and compile a complete Linaro Android distribution

  • Download and install Ubuntu 12.04 64 bit or newer (download)
  • Install the following packages:
sudo apt-get install zip curl flex bison build-essential git-core gnupg gperf zlib1g-dev libx11-dev x11proto-core-dev \
gcc-multilib g++-multilib libc6-dev-i386 ia32-libs lib32z-dev gcc-4.5 g++-4.5 cpp-4.5 gcc-4.5-multilib g++-4.5-multilib \
uboot-mkimage uuid-dev openjdk-6-jdk ant lib32ncurses5-dev xsltproc
  • Download the Android building script for this release from here or from the list of artifacts listed above.
  • Run the script
chmod a+x

Installing Android JB on your board

  • Insert SD card and note the assigned '/dev/sdX' or '/dev/mmcblk0'
dmesg | less

Look for a line that looks like the following at the end of the log

[288582.790722] sdc: sdc1 sdc2 sdc3 sdc4 <sdc5 sdc6 >

Or, if your machine uses ‘/dev/mmcblkX’, you may see a line line this:

[10770.938042] mmcblk0: p1 p2 p3 p4 < p5 p6 >

WARNING: In the next step, make sure you use /dev/“whatever you see above”. You can erase your hard drive with the wrong parameter.

  • Create media
cd android/out/target/product/
sudo linaro-android-media-create --mmc /dev/sdX --dev vexpress --boot boot.tar.bz2 --system system.tar.bz2 --userdata userdata.tar.bz2
  • Insert the SD card into your Versatile Express board and reboot it

If UEFI is already configured to boot a Linaro Android image, it will boot from the SD card. If not, follow the instructions in the section: Configure UEFI found on the Linaro wiki.

Compiling and installing your Kernel


  • Download and install Ubuntu 12.04 64 bit or newer (download)
  • Install the following packages by typing:
sudo apt-get install gcc-arm-linux-gnueabi curl git u-boot-tools libncurses5-dev
  • Create a working subdirectory
  • Download the auto build script for this release from the list of artifacts above (the kernel configuration will be automatically downloaded).
  • Run the build script
chmod a+x

Note: When you run menuconfig, make sure you go to System Type -> Versatile Express platform type and make sure that both options are enabled.

[*] Versatile Express Cortex-A9x4 tile
[*] Device Tree support for Versatile Express platforms

This will mean that the same kernel will run on A5, A9, A15-TC1, A15-TC2 and various RTSM models.

Installing your kernel

This section is common for both Android and Ubuntu

  • Create the Device Tree blob if you don’t have one in your Linaro image (note, the A9 Core Tile boots using an ATAGS kernel):
make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- dtbs
  • Insert the SD card containing the Linaro disk image
  • Copy the kernel onto the memory card
cp arch/arm/boot/uImage /media/boot/
  • Copy the device tree blob
    • For A9 CoreTile: no device tree blob is needed
    • For A5 CoreTile: cp arch/arm/boot/vexpress-v2p-ca5s.dtb /media/boot/v2p-ca5s.dtb
    • For A15 CoreTile (TC1): cp arch/arm/boot/vexpress-v2p-ca15-tc1.dtb /media/boot/v2p-ca15-tc1.dtb
    • For A15_A7 CoreTile: (TC2): cp arch/arm/boot/vexpress-v2p-ca15_a7.dtb /media/boot/v2p-ca15-tc2.dtb
  • Eject the memory card eject /media/boot
  • Insert the memory card into the Versatile Express board and power it on

Ensure that you update your Versatile Express board firmware to the latest version. To update your VE board firmware, please follow the instructions below:

  • Connect and mount your Versatile Express motherboard USB mass storage device to your PC
  • Install the Recovery firmware from the v5.0 VE DVD onto your board.
  • Download ARM’s CPU Migration patch for version 5.0 from
    • Unzip the firmware zip to the root of the motherboard mounted drive
    • Please contact for any issues related this firmware update
  • Unmount the Versatile Express motherboard
  • Reboot the Versatile Express board
  • At the “Cmd> “ prompt, type the following commands:
    Cmd> flash
    Cmd> eraseall
    Cmd> exit
    Cmd> reboot
    • You may need to configure UEFI to boot from the image that you’ve created. See the UEFI page on the Linaro Wiki for more details on configuring UEFI.

You may want to set /media/VEMSD/config.txt AUTORUN to TRUE to be make the CoreTile boot from power on.

For TC2, you should set the DIP swich closest to the black reset button is down so that the Boot Monitor runs the boot script on power on.

Using TC2 as an A7 or A15 only board

Configure the Firmware

It is possible to configure a TC2 development board as an A7 or A15 only board. To do this, the developer should modify the /SITE1/HBI0249A/board.txt file on the Versatile Express firmware drive, usually mounted at /media/VEMSD.

The relevant register is CFGREG6 on pages 78-81 of the following TRM:

You should add the following setting in board.txt:

SCC: 0x018 0x1FFFFFFF     ; CFGRW6 - Reset register default (both clusters active)
- or -
SCC: 0x018 0x00001FFF     ; CFGRW6 - A15-only config
- or -
SCC: 0x018 0x1FFFF000     ; CFGRW6 - A7-only config

Remember to update TOTALSCCS, eg, if it was 32 and you’ve added one register, it becomes 33:

TOTALSCCS: 33                   ;Total Number of SCC registers

Configure the Device Tree

Once the hardware is booting as an A7 or A15 only board, next you need to remove the unused CPU nodes from the device tree.

In the kernel source tree, edit arch/arm/boot/dts/vexpress-v2p-ca15_a7.dts and remove the unused CPUs from this section:

   cpus {
        #address-cells = <1>;
        #size-cells = <0>;
       cpu2: cpu@2 {
            device_type = "cpu";
            compatible = "arm,cortex-a7";
            reg = <0x100>;
            cluster = <&cluster1>;
            core = <&core2>;
            clock-frequency = <800000000>;
            cci-control-port = <&cci_control2>;
       cpu3: cpu@3 {
            device_type = "cpu";
            compatible = "arm,cortex-a7";
            reg = <0x101>;
            cluster = <&cluster1>;
            core = <&core3>;
            clock-frequency = <800000000>;
            cci-control-port = <&cci_control2>;
       cpu4: cpu@4 {
            device_type = "cpu";
            compatible = "arm,cortex-a7";
            reg = <0x102>;
            cluster = <&cluster1>;
            core = <&core4>;
            clock-frequency = <800000000>;
            cci-control-port = <&cci_control2>;
       cpu0: cpu@0 {
            device_type = "cpu";
            compatible = "arm,cortex-a15";
            reg = <0>;
            cluster = <&cluster0>;
            core = <&core0>;
            clock-frequency = <1000000000>;
            cci-control-port = <&cci_control1>;
       cpu1: cpu@1 {
            device_type = "cpu";
            compatible = "arm,cortex-a15";
            reg = <1>;
            cluster = <&cluster0>;
            core = <&core1>;
            clock-frequency = <1000000000>;
            cci-control-port = <&cci_control1>;

Next, you need to remove the GIC entries that are associated with the removed CPUs, eg:

   gic: interrupt-controller@2c001000 {
        compatible = "arm,cortex-a15-gic", "arm,cortex-a9-gic";
        #interrupt-cells = <3>;
        #address-cells = <0>;
        reg = <0 0x2c001000 0 0x1000>,
              <0 0x2c002000 0 0x1000>,
              <0 0x2c004000 0 0x2000>,
              <0 0x2c006000 0 0x2000>;
        interrupts = <1 9 0xf04>;
       gic-cpuif@0 {
            compatible = "arm,gic-cpuif";
            cpuif-id = <0>;
            cpu = <&cpu0>;
       gic-cpuif@1 {
            compatible = "arm,gic-cpuif";
            cpuif-id = <1>;
            cpu = <&cpu1>;
       gic-cpuif@2 {
            compatible = "arm,gic-cpuif";
            cpuif-id = <2>;
            cpu = <&cpu2>;
       gic-cpuif@3 {
            compatible = "arm,gic-cpuif";
            cpuif-id = <3>;
            cpu = <&cpu3>;
       gic-cpuif@4 {
            compatible = "arm,gic-cpuif";
            cpuif-id = <4>;
            cpu = <&cpu4>;

Finally, you need to re-compile the DTS file and copy it to the SD card used to boot the system, eg:

make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- dtbs
cp arch/arm/boot/dts/vexpress-v2p-ca15_a7.dtb /media/boot/v2p-ca15-tc2.dtb

This release was boot tested on RTSM A15×4 and A15×4-A7×4 models. No rigorous testing was carried out. This build is expected to run on other RTSM models.


  • Install the RTSM model(s) you wish to run. You must have a valid license and the environment set up to run models
  • Install Linaro image tools

Install Linaro Image Tools

Linaro Image Tools contain scripts that allow you to combine multiple components into a single Android image. The components are:

  • boot.tar.bz2 – contains the kernel and boot loaders
  • system.tar.bz2 – contains the entire system files and general OS
  • userdata.tar.bz2 – contains sample data and tests

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: Build from source


Create a 2GB image file

RTSM will only deal with file systems up to 2GB in size, however the Linaro pre-built image for Android requires a 4GB filesystem. Therefore, we will build our own image using the pre-built artifacts (displayed above)

The following command downloads all the Android OS components necessary to make up a complete Android image.


Using the linaro-android-media-create, which is part of the linaro-image-tools, you can combine all the components into a single image.

linaro-android-media-create --image-file linaro.img --image-size 2000M --dev vexpress --boot boot.tar.bz2 --system system.tar.bz2 --userdata userdata.tar.bz2
tar jxvf boot.tar.bz2

Run RTSM with UEFI

The instructions for running UEFI on the various models are very similar. The two differences are the UEFI binary and the model used. Follow the model specific instruction below, then proceed to the generic instructions in the section “Run the model with UEFI”.

Run A9×4 model with UEFI


Run A15×1 model with UEFI


Run A15×2 model with UEFI


Run A15×4 model with UEFI


Run the model with UEFI

-C motherboard.flashloader0.fname=$RTSM_UEFI \
-C motherboard.flashloader1.fname=$RTSM_UEFI_VARS \
-C motherboard.flashloader1.fnameWrite=$RTSM_UEFI_VARS \
-C motherboard.mmc.p_mmc_file=$RTSM_MMC \
-C motherboard.pl011_uart0.unbuffered_output=true \
-C motherboard.smsc_91c111.enabled=1 \
-C motherboard.hostbridge.userNetworking=1

Run A15×4 model with the Boot Wrapper

This example shows how to run the Linaro kernel on a quad core A15 RTSM model:

RTSM_CMDLINE=" console=tty0 console=ttyAMA0,38400n8 rootwait ro init=/init androidboot.console=ttyAMA0"
-C motherboard.smsc_91c111.enabled=1 \
-C motherboard.hostbridge.userNetworking=1 \
-C motherboard.mmc.p_mmc_file="$RTSM_MMC" \
-C cluster.cpu0.semihosting-cmd_line="--kernel $RTSM_KERNEL --dtb $RTSM_DTB --initrd $RTSM_INITRD -- $RTSM_CMDLINE"

Run A15×4-A7×4 model with the Boot Wrapper

This example shows how to run the Linaro kernel on a big.LITTLE RTSM model. There is no UEFI binary for the big.LITTLE model, so we only use the boot wrapper for this model.

RTSM_CMDLINE=" console=tty0 console=ttyAMA0,38400n8 rootwait ro init=/init androidboot.console=ttyAMA0"
-a coretile.cluster0.*=$RTSM_BOOTWRAPPER \
-a coretile.cluster1.*=$RTSM_BOOTWRAPPER \
-C motherboard.smsc_91c111.enabled=1 \
-C motherboard.hostbridge.userNetworking=1 \
-C motherboard.mmc.p_mmc_file=$RTSM_MMC \
-C coretile.dualclustersystemconfigurationblock.CFG_ACTIVECLUSTER=0x3 \
-C coretile.cluster0.cpu0.semihosting-enable=1 \
-C coretile.cluster0.cpu0.semihosting-cmd_line="--kernel $RTSM_KERNEL --dtb $RTSM_DTB --initrd $RTSM_INITRD -- $RTSM_CMDLINE"