	Name	Last modified	Size	License

	Parent Directory

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

About the Linaro OpenEmbedded Release for ARMv8-A

OpenEmbedded is a software framework used for creating Linux distributions aimed for, but not restricted to, embedded devices.

About the Juno ARM Development Platform

The Juno ARM Development Platform (ADP) is a software development platform for ARMv8-A. It includes:

The Juno Versatile Express board
ARMv8-A reference software ports available through Linaro
Optional LogicTile Express FPGA board to extend the Juno system – this adds a large FPGA to Juno that can be used for driver development or prototyping.

The Juno hardware delivers to software developers an open, vendor neutral ARMv8-A development platform with:

Cortex® A57 and A53 MPCore™ for ARMv8-A big.LITTLE
Mali™-T624 for 3D Graphics Acceleration and GP-GPU compute
A SoC architecture aligned with Level 1 (Server) Base System Architecture

The Juno ADP is available from ARM, please visit www.arm.com/juno for details.

About the Linaro Stable Kernel (LSK)

The Linaro Stable Kernel (LSK) is produced, validated and released by Linaro and is based on the Linux stable kernel tree. The LSK focuses on quality and stability and is therefore a great foundation for product development. It also includes backports of commonly desired features, provided they meet the quality requirements, and also any bug fixes.

LSK releases appear monthly. Sources are also made available so you can build your own images (see the ‘Building from Source’ tab).

License

The use of Juno software is subject to the terms of the Juno End User License Agreement.

Support

Please send any ARM support enquiries to juno-support@arm.com. Engineers at Linaro Members can receive support for Juno by sending support requests to support@linaro.org or visiting http://support.linaro.org.

Functionality Listed by Software Component

Linux Kernel

Support for the ARM Juno Development Platform
Enables a limited set of peripherals present on the Juno development board: on-chip USB, non-secure UART, HDMI output, keyboard and mouse functionality over PS/2 connector, ethernet support is provided via on-board SMSC ethernet chip.
Full USB driver support in Linux, for access to mass storage and input devices.
big.LITTLE MP support for all 6 cores.
CPUIdle supported and enabled by default
Unified kernel and kernel config for Android and Linux.
Support for reboot / shutdown.
DVFS stable operating points are enabled for nominal and overdrive

UEFI

Booting an Operating System from NOR Flash or USB mass storage
Support for Ethernet and PXE boot
Support for ACPI 5.1
Version: v3.0

ARM Trusted Firmware

The ARM Trusted Firmware provides an open source framework enabling easy integration of secure OS and run-time services to ARMv8-A platforms
Loads the System Control Processor(SCP) firmware into the SCP
Initializes the Trusted World before transitioning into Normal World.
Services CPU hotplug requests coming from Normal World
Implements “SCPI v1.0 final” protocol for communication between AP and SCP.
Implements all mandatory APIs for Power State Coordintion Interface (PSCI) v1.0.
Support for secure interrupts, secure payload
Prototype implementation of Trusted Board Boot.
Version: v1.1-Juno-0.1

SCP Firmware

System configuration
DDR initialization
Basic power state management for frequency and C-states
Implements “SCPI v1.0 final” protocol for communication between AP and SCP.
“Boot over MHU” protocol.
Thermal protection (shutdown at 85C)
DVFS support
Support for system shutdown / reset
Support for recalibrating the PVT sensors (details here) only with the 0.9.2 board recovery image
Version: 1.7.0

Known Limitations Listed by Software Component

Linux Kernel

No PCI Express support is included
The big.LITTLE support is functional but has not yet been tuned for efficiency and performance.
Continuous soak testing of CPUIdle exposed a lock-up after 8 days of constantly exercising the framework.
HDMI can lose sync with the monitor intermittently, particularly at higher resolutions. If you are affected by this then try adding a kernel command line argument that forces a video mode with reduced blanking, such as the following:

video=DVI-D-1:1920x1080R@60

UEFI

No PCI Express support is included.
No display controller support.
No low speed (OHCI) USB support.
UEFI will only list PXE and TFTP as boot options if a live network cable is connected.
TFTP / PXE boot works only when the boot cpu is a Cortex-A53 and fails if the boot cpu is a Cortex-A57.
It is necessary to restart the platform after updating the Device Tree in the boot menu.

ARM Trusted Firmware

Does not support bringing up secondary cores using PSCI CPU_ON when they have been enabled at boot time by SCP using SCC General Purpose Register 1.

SCP Firmware

If a core requests a warm reset from SCP, it will not be reset and therefore will spin on WFI forever.
Voltage sensors under-read by 9mV.

Known Issues

The following known issues are present in this release. Please contact support@linaro.org if you wish to know more information about these issues or have access problems when attempting to view them.

Bug ID	Bug title	Bug summary
Bug 136	2nd USB Mass storage device fails	When attempting to use a second USB storage device on Juno, both sda and sdb will go r/o and then fail to read from the device.
Bug 137	nfs v4 hangs when creating symlinks	nfs v4 hangs when creating symlinks
ARM JSW-711	Reset failure	Reset fails if button is pressed during NOR flash write
LP:1212126	perf self test does not execute on Linaro openembedded lamp image	please see public bug for details
LP:1212115	phpmysql test fail on Linaro openembedded Lamp image on Lava	please see public bug for details
LP:1235239	level 1 translation fault when extracting bzipped tarball	please see public bug for details

License

The use of Juno software is subject to the terms of the Juno End User License Agreement.

Installation

Linaro OpenEmbedded releases are made up of the following components.

img.gz	pre-built images for minimal and LAMP root filesystems
hwpack_*.tar.gz	hardware pack
linaro-image-*.rootfs.tar.gz	a choice of Root file system (RootFS) images
Image	kernel used by UEFI
juno_bl1.bin	ARM Trused Firmware BL1 binary
juno_fip.bin	ARM Trused Firmware Firmware Image Package (FIP) binary
juno.dtb	Device Tree Binary

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 OpenEmbedded images are made up of two components. The Hardware Pack, which contains the kernel, boot loader and/or Device Tree blob and a Root file system (RootFS) of your choice to generate an image.

Linaro provides two methods for installing Linaro binary builds:

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

Pre-Installation Steps

Before any installation begins, it is important that you ensure your board has the latest firmware installed. Please see Juno Board Recovery Image and MCC firmware update below for the latest updates and installation instructions. We always recommend that users install the latest version available, which at the time of release is 0.11.3.

Using pre-built image

Prerequisites

Ubuntu 12.04 64 bit or newer on your desktop PC (www.ubuntu.com)
4GB USB drive or larger
Latest firmware installed onto the board. Please see Juno Board Recovery Image and MCC firmware update section below
This release pre-built image, which you can download from the above list of artifacts

Installation Steps

Unzip the downloaded pre-built image
Insert USB drive into your PC and note the assigned '/dev/sdX'

dmesg
DRIVE=/dev/sdX # USB drive found from dmesg above

Unmount all partitions on the drive
- If you do not unmount all of the USB drive’s partitions, you run the risk that the image will not be created successfully.
Write the image to the drive

gunzip *minimal*.img.gz
sudo dd if=*minimal*.img of=$DRIVE

Replace *minimal*.img.gz with the full filename of the prebuilt image you are attempting to write to the disk.

After you have created the disk image and before you remove the USB drive from your system, you should make sure you wait for all writes to the USB drive to complete.

The following commands may help with this:

$ sync
$ sudo eject $DRIVE

You should also ensure that you have written the image to the USB drive correctly. To do this, after running the eject command, physically remove the USB drive from the system and re-connect the USB drive again. You must unmount all partitions on the USB drive at this point. Note, due to disconnecting and reconnecting the drive, the device path /dev/sdX may have changed. You should check the dmesg output again to ensure that you know the correct path of your USB drive.

Once you are ready, run the following commands:

$ sudo cmp /dev/sdX *minimal*.img
$ sync
$ sudo eject /dev/sdX

Replace *minimal*.img.gz with the full filename of the prebuilt image you are attempting to write to the disk.

When you are confident that the image was created successfully, 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 your board. Perhaps you wish to use a more recent snapshot of the hardware pack 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.

Prerequisites

Ubuntu 12.04 64 bit or newer on your desktop PC, which you can download from www.ubuntu.com
Download Artifacts from above
Get 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: Building from source

wget http://releases.linaro.org/14.12/components/platform/linaro-image-tools/linaro-image-tools-2014.12.tar.gz

Insert the USB drive and note the assigned '/dev/sdX'

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 >

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

sudo linaro-media-create --mmc /dev/sdX --dev juno --hwpack <hwpack filename> --binary <rootfs filename>

After you have created the disk image and before you remove the USB drive from your system, you should make sure you wait for all writes to the USB drive to complete.

The following commands may help with this:

$ sync
$ sudo eject /dev/sdX

Where /dev/sdX is the device node for the USB drive as discovered in the instructions above.

Booting the image

After the media create tool has finished executing, remove the USB drive from your PC and insert it into the board.

Before you can boot the image you will need to install the latest firmware on the board. The instructions below provide information on how to do this.

Once you have the latest firmware installed, you will need to configure UEFI to boot the kernel from the “boot” partition of the USB stick. See the steps directly below for instructions on how to configure UEFI.

UEFI Configuration

The example below shows how a test system was configured. Please note: some of the menu option numbers may be different on your board. In particular, the menu option used to choose the boot partition may change number over a reboot. In the example below, the partition named “boot” was option 4. Please be careful that you choose the correct option that corresponds to the menu options you see on your board.

Also take care that the USB partitions are showing in the menu before selecting a menu option. There is a known bug in UEFI where the partitions on USB drives may not show the first time the menu is displayed. To overcome this, as shown in the example below, the user should enter the menu option "[1] Add Boot Device Entry", by pressing 1 followed by the enter key. Then, when the list display and the USB partitions are missing, please press the ESC key once. This will exit out of the current menu prompt and leave you back at the Boot Menu again. At this point, please press 1 again to re-enter the menu option "[1] Add Boot Device Entry" and continue by selecting the partition named “boot” on the USB drive.

UEFI outputs to UART0 on the board. UART0 uses 115200 baud with 8 bits and no stop bit. Please see the “UARTs” section on the Getting Started tab for more details on the UART configuration of the board.

Example UEFI Configuration

When booting your system, after a short time, you be presented by a boot countdown from 10, thus:

The default boot selection will start in  10 seconds

When you see this prompt, please press the enter key to interrupt the countdown. You will then be presented with a menu, thus:

[1] Linux from NOR Flash
[2] Shell
[3] Boot Manager
Start:

Depending on the configuration of your board, the menu option called “Boot Manager” may not be option 3. In this example, we can see that the Boot Menu is indeed option “3”, so we choose it by pressing the “3” key and pressing enter. You will then be presented with a boot menu, thus:

[1] Add Boot Device Entry
[2] Update Boot Device Entry
[3] Remove Boot Device Entry
[4] Reorder Boot Device Entries
[5] Update FDT path
[6] Set Boot Timeout
[7] Return to main menu
Choice:

The first thing we need to do is to delete all of the existing Boot Device Entries. Deleting a Boot Device Entry is achieved by pressing the 3 key and pressing enter:

[1] Linux from NOR Flash
Delete entry:

In our example, using the default config from the first time you boot the board, there is only 1 Boot Device Entry: “Linux from NOR Flash”. You must delete this entry by pressing the 1 key and pressing enter. After this, you will be returned to the Boot Menu where you should continue by deleting all Boot Device Entries that are configured.

Once you have done this, you should continue by creating a new Boot Device Entry by selecting option 1 from from the Boot Menu. After selecting the menu option by pressing the 1 key folllowed by enter, you will see a list of available Boot Devices, thus:

[1] Add Boot Device Entry
[2] Update Boot Device Entry
[3] Remove Boot Device Entry
[4] Reorder Boot Device Entries
[5] Update FDT path
[6] Set Boot Timeout
[7] Return to main menu
Choice: 1
[1] Firmware Volume (4068 MB)
[2] Firmware Volume (4068 MB)
[3] NOR Flash (63 MB)
[4] boot (131 MB)
[5] sdcard (13585 MB)
[6] VenHw(E7223039-5836-41E1-B542-D7EC736C5E59)
[7] VenHw(02118005-9DA7-443A-92D5-781F022AEDBB)
[8] PXE on MAC Address: 00:02:F7:00:57:DD
[9] TFTP on MAC Address: 00:02:F7:00:57:DD
Select the Boot Device:

At this point you select the second of the “Firmware Volume” options from the list. In the example above, this is option 2, so press the 2 key and press enter:

File path of the EFI Application or the kernel: Shell.efi
Is your application an OS loader? [y/n] y
Arguments to pass to the EFI Application: 
Description for this new Entry: Run Shell on boot

Once the new entry is saved, you return to the main menu by pressing the 7 key followed by enter:

[1] Add Boot Device Entry
[2] Update Boot Device Entry
[3] Remove Boot Device Entry
[4] Reorder Boot Device Entries
[5] Update FDT path
[6] Set Boot Timeout
[7] Return to main menu
Choice:7

From the main menu, you select option 1 to run the EFI Shell:

[1] Run Shell on boot
[2] Shell
[3] Boot Manager
Choice:1

Once the EFI Shell is running, you will see a countdown. Press the ESC key to abort this countdown. Then, at the “Shell>” prompt, you can launch the kernel from the commandline, by typing the following command:

Image dtb=juno/juno.dtb console=ttyAMA0,115200 rootwait root=/dev/sda2

You should see output similar to the following (where X replaces build specific info):

EFI stub: Booting Linux Kernel...
[    0.000000] Initializing cgroup subsys cpu
[    0.000000] Linux version 3.10.0-1-linaro-lt-vexpress64 (buildslave@x86-64-07) (gcc version X.X.X XXXXXXXX (prerelease) (crosstool-NG linaro-X.XX.X-X.X-XXXX.XX - Linaro GCC X.X-XXXX.XX) ) #1ubuntu1~ci+XXXXXXXXXXXX SMP XXX XXX XX XX:XX:XX UTC XXXX
[    0.000000] CPU: AArch64 Processor [410fd030] revision 0
[    0.000000] Machine: Juno

One important part of the output is the Linux version, shown above as 3.10. It is critical that you ensure you are booting Linux version 3.10 and not 3.15 that comes installed with the ARM Firmware images. If you are not, it may be that you have mis-configured your system and you should revise your configuration by repeating the steps above.

Automating the EFI Shell boot command

You can automate EFI Shell to boot the kernel on your USB stick.

To do this, you create a file in the boot partition of your disk image called /boot/EFI/startup.nsh. This is an EFI Shell script where you can place the command you use to launch the kernel. For example, I inserted my USB stick into my host Ubuntu maching, mounted the boot partition and did the following:

 mkdir -p <mount point of boot partition>/EFI/boot
echo "Image dtb=juno/juno.dtb console=ttyAMA0,115200 rootwait root=/dev/sda2" > <mount point of boot partition>/EFI/boot/startup.nsh

Then I unmounted the boot partition and inserted the USB drive into the Juno board. From this point on, the board will boot directly into the kernel without intervention from the user.

Restoring the default UEFI configuration

If you wish to restore UEFI to a clean default configuration:

1. Start the board into the “ARM V2M-Juno Boot loader”. Either:

Turn on the power.
If the board was already powered on, press the black HW RESET button.

The bootloader is accessible on the UART0 port (the top UART port on the back panel). The UART settings are 115200 bauds, 8 bits data, no parity, 1 bit for stop.

2. Run the following commands:

Cmd> flash
Flash> areas
Base      Area Size Blocks Block Size
----      --------- ------ ----------
0x08000000    65280K    255      256K
0x0BFC0000      256K      4        64K
Flash> eraserange 0x0BFC0000
Erasing Flash

DS-5 Configuration Files for Juno

As an optional step, you may wish to install DS-5 configuration files that will allow you to debug Juno. The procedure is as follows:

1. Extract the DS-5 config files anywhere on your host PC.

2. Start DS-5 and select "Preferences" from the "Window" menu.

3. In the window that opens, expand the "DS-5" heading and select "Configuration Database"

4. In the dialogue that opens, fill in:

a. Name, which can be any string you like e.g. "Juno".

b. Location, which must be the directory that you extracted the DS-5 config files to. Note this is not the "boards" directory, but the parent directory that now contains "boards".

5. Click Ok to close the dialogue

6. Back in the "Configuration Database" screen, click on "Rebuild database" then click Ok.

Firmware update

This section describes how to update the firmware on the Juno board.

The configuration of the Juno Development Platform board is determined by a set of files stored on a flash memory device on the board. The flash memory can be accessed via a USB-B socket on the rear panel of the board. When connected to a host computer, the flash memory will appear as a USB mass storage device with a FAT16 filesystem. The files in this filesystem are edited to control the configuration of the board.

The configuration of the Juno Development Platform board can be returned to factory default by extracting the Juno board recovery image onto the flash memory device, replacing any files already in the flash memory.

To install firmware images that you have built yourself, the procedure is the same except that you will overwrite the contents of the /SOFTWARE/ directory with your own images.

To update the MCC firmware only, the procedure is the same except that the MCC firmware update bundle will contain only a subset of the files contained in the full recovery image.

To carry out a system recovery, update the MCC firmware, or install your own custom firmware images, follow these steps:

1. Connect a serial terminal to the top 9-pin UART0 connector on the rear panel (115200 baud, 8, n, 1).

2. Connect a USB cable between the USB-B connector on the rear panel and a USB port of your host computer.

3. Connect the 12 volt power supply to the board.

The serial terminal will show the command prompt Cmd>

4. At the Cmd> prompt on the serial terminal, issue the command usb_on

Cmd> usb_on

The configuration flash memory should now be visible on the host computer as a mass storage device.

5. Save to the host PC any of the existing files in the configuration flash memory that you wish to retain for future use.

6. If you wish to update one or more of the firmware components then skip to step 7. Otherwise, for a full system recovery, format the configuration flash memory (FAT16).

7. Extract the board recovery image (board_recovery_image.tar.bz2) to the root directory of the configuration flash memory, preserving the directory structure.

8. If you are performing a system recovery or installing an update from ARM then skip to step 9. Otherwise if you wish to install firmware images that you have built yourself then delete the bl1.bin and fip.bin from the /SOFTWARE/ directory in the configuration flash memory, and copy your own bl1.bin and fip.bin images into that directory to replace them.

9. Safely eject the mass storage device, giving it time to write the files to the internal storage.

10. Press the red ON/OFF button on the rear panel of the board and wait for reprogramming to complete.

The board will load the default configuration and boot up.

License

The use of Juno software is subject to the terms of the Juno End User License Agreement.

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 https://git.linaro.org/landing-teams/working/arm/kernel-release.git
cd kernel
git checkout lsk-3.10-armlt-juno-20150608

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

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

Build the kernel

To build the kernel Image and juno.dtb files, use the following command:

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

Install your kernel

Copy the kernel Image and the juno.dtb files to the BOOT partition on the USB drive created in the Binary Installation tab.

cp arch/arm64/boot/Image /media/BOOT/Image
cp arch/arm64/boot/dts/juno.dtb /media/BOOT/juno/juno.dtb

Building Firmware From Source

Prerequisites

The following tools and environment are required:

Ubuntu desktop OS and the following packages. ARM have only tested with Ubuntu 12.04.02 (64-bit).
- `git` package to obtain source code
- `ia32-libs` package
- `build-essential` and `uuid-dev` packages for building the UEFI and Firmware Image Package (FIP) tool
- bison and flex packages are required for building the IASL compiler which is used in the UEFI build process.

Baremetal GNU GCC tools. Can be downloaded from Linaro
- http://releases.linaro.org/14.07/components/toolchain/binaries/gcc-linaro-aarch64-none-elf-4.9-2014.07_linux.tar.xz

The instructions on this page below assume that the environment variable $JUNO_ROOT_DIR has been initialised to a working directory.

$ export JUNO_ROOT_DIR=<path-to-working-dir>/<name-of-working-dir>

SCP Firmware

The SCP Firmware is only available as a pre-built binary, and consists of the following images:

Filename	Image Type	Image Name
bl0.bin	BL0	SCP ROM image
bl30.bin	BL3-0	SCP runtime image

The bl30.bin image is an input to the process of creating a Firmware Image Package.

ARM Trusted Firmware

The ARM trusted firmware consists of the following images:

Filename	Image Type	Image Name
bl1.bin	BL1	ARM Trusted ROM image
bl2.bin	BL2	ARM Trusted Firmware
bl31.bin	BL3-1	EL3 runtime
bl32.bin (optional)	BL3-2	Test Secure Payload

The bl2.bin, bl31.bin and bl32.bin images are inputs to the process of creating a Firmware Image Package.

Obtaining sources

Clone the ARM Trusted Firmware repository from GitHub:

$ cd $JUNO_ROOT_DIR
$ git clone https://github.com/ARM-software/arm-trusted-firmware.git
$ cd arm-trusted-firmware
$ git checkout v1.1-Juno-0.1

Configuration

Set the compiler path

$ export CROSS_COMPILE=<path-to-aarch64-gcc>/bin/aarch64-none-elf-

Building

1. Change to the trusted firmware directory:

$ cd $JUNO_ROOT_DIR/arm-trusted-firmware

2. Build the different firmware images:

$ make PLAT=juno all

To build the optional bl3-2 Test Secure Payload component, use the following commands instead (the ‘make realclean’ is important):

$ make realclean
$ make PLAT=juno SPD=tspd all

By default the preceding commands produce a release version of the build. To produce a debug version instead and make the build more verbose use:

$ make PLAT=juno DEBUG=1 V=1 all

The build process creates products in a `build` directory tree, building the objects for each boot loader stage in separate sub-directories. The following boot loader binary files are created:

build/juno/<build-type>/bl1.bin
build/juno/<build-type>/bl2.bin
build/juno/<build-type>/bl31.bin
build/juno/<build-type>/bl32.bin (if the ‘SPD=tspd’ flag is used)

… where <build-type> is either `debug` or `release`.

To clean the ARM Trusted Firmware source tree (warning, this will remove the binaries too):

$ make realclean

UEFI

UEFI is a single bl33.bin image that is an input to the process of creating a Firmware Image Package.

Obtaining sources

Clone the Juno UEFI Github repository:

$ cd $JUNO_ROOT_DIR
$ git clone https://github.com/ARM-software/edk2.git -b juno
$ cd edk2
$ git checkout v3.0

Configuration

1. Define the AArch64 GCC toolchain:

$ export EDK2_TOOLCHAIN=GCC49
$ export GCC49_AARCH64_PREFIX=<path-to-aarch64-gcc>/bin/aarch64-none-elf-

2. Clone and Build IASL compiler

Note that this step requires the bison and flex packages to be present on the host build machine.

$ git clone https://github.com/acpica/acpica.git
$ cd acpica
$ git checkout R07_24_14
$ make
$ export IASL_PREFIX=<path-to-acpica>/generate/unix/bin/

3. Configure Tianocore environment:

$ cd $JUNO_ROOT_DIR/edk2
$ . edksetup.sh
$ make -C BaseTools

Building

1. Change to the EDK2 directory:

$ cd $JUNO_ROOT_DIR/edk2

2. To build DEBUG version of UEFI firmware:

$ make -f ArmPlatformPkg/ArmJunoPkg/Makefile

The build produces the binary $JUNO_ROOT_DIR/edk2/Build/ArmJuno/DEBUG_GCC49/FV/BL33_AP_UEFI.fd that should be used as ‘bl33.bin’ when generating the Firmware Image Package binary.

To build RELEASE version of UEFI firmware:

$ make -f ArmPlatformPkg/ArmJunoPkg/Makefile EDK2_BUILD=RELEASE

Use the release binary $JUNO_ROOT_DIR/edk2/Build/ArmJuno/RELEASE_GCC49/FV/BL33_AP_UEFI.fd as bl33.bin when generating the Firmware Image Package binary.

To clean EDK2 source tree:

$ make -f ArmPlatformPkg/ArmJunoPkg/Makefile clean

Packaging the binaries

ARM Trusted Firmware uses the Firmware Image Package (FIP) binary blob to load images into the system, so that the firmware can avoid managing lots of smaller images. The FIP will contain:

BL2 and BL3-1 boot loader images
Test Secure Payload (BL3-2 image – optional)
UEFI firmware (BL3-3 image)
SCP firmware (BL3-0 image)

Note: BL1 image is NOT part of the FIP.

Building a FIP binary

The steps to create a FIP are as follows:

1. Build the ‘fip_create’ tool.

$ cd $JUNO_ROOT_DIR/arm-trusted-firmware
$ make fiptool

2. Define the FIP environment. Specifically, include the FIP tool in the path.

$ export PATH=$JUNO_ROOT_DIR/arm-trusted-firmware/tools/fip_create:$PATH

3. Download the firmware image artefacts and extract to a working directory (hereafter referred to as "<path to prebuilt binary>").

4. Gather the binary files (the following example is for release builds only).

$ cd $JUNO_ROOT_DIR
$ mkdir fip
$ cd fip
$ cp <path to prebuilt binary>/bl30.bin .
$ cp $JUNO_ROOT_DIR/arm-trusted-firmware/build/juno/release/bl2.bin .
$ cp $JUNO_ROOT_DIR/arm-trusted-firmware/build/juno/release/bl31.bin .
$ cp $JUNO_ROOT_DIR/arm-trusted-firmware/build/juno/release/bl32.bin .
$ cp $JUNO_ROOT_DIR/edk2/Build/ArmJuno/RELEASE_GCC48/FV/BL33_AP_UEFI.fd  bl33.bin

If you wish to use the pre-built ARM trusted firmware and UEFI EDK2 images instead of building them from source, then the last four lines of the above block can independently be replaced with the following:

$ cp <path to prebuilt binary>/bl2.bin .
$ cp <path to prebuilt binary>/bl31.bin .
$ cp <path to prebuilt binary>/bl32.bin .
$ cp <path to prebuilt binary>/bl33.bin .

5. Create the FIP file:

$ fip_create --dump          \
             --bl2 bl2.bin   \
             --bl30 bl30.bin \
             --bl31 bl31.bin \
             --bl32 bl32.bin \    (if the optional bl32 image is present)
             --bl33 bl33.bin \
             fip.bin

The previous command will display the FIP layout:

Firmware Image Package ToC:
---------------------------
- Trusted Boot Firmware BL2: offset=0xD8, size=0x5268
- SCP Firmware BL3-0: offset=0x5340, size=0x9C64
- EL3 Runtime Firmware BL3-1: offset=0xEFA4, size=0x82A0
- Non-Trusted Firmware BL3-3: offset=0x17244, size=0xF0000
---------------------------
Creating "fip.bin";

6. Optional: the `fip_create` tool can be used in the exact same way to update individual images inside an existing FIP file. For example, to update the SCP Firmware BL3-0 image:

$ fip_create --dump --bl30 new_bl30.bin fip.bin

The previous command will again display the FIP layout:

Firmware Image Package ToC:
---------------------------
- Trusted Boot Firmware BL2: offset=0xD8, size=0x5268
- SCP Firmware BL3-0: offset=0x5340, size=0x9C64
file: 'new_bl30.bin'
- EL3 Runtime Firmware BL3-1: offset=0xEFA4, size=0x82A0
- Non-Trusted Firmware BL3-3: offset=0x17244, size=0xF0000
---------------------------
Updating "fip.bin"

For more details and options about the `fip_create` tool:

$ fip_create --help

Installing the binaries

Please refer to the section titled “Firmware update” on the Binary Image Installation tab.

License

The use of Juno software is subject to the terms of the Juno End User License Agreement.

Juno ports

Back panel

Front panel

UARTs

There are 4 UARTs on the Juno board:

UART	Location	Used by	Baud	Data bits	Stop bits	*Parity
SoC UART0	back panel	The motherboard, UEFI and the Linux kernel.	115200	8	1	None
SoC UART1	back panel	SCP firmware	115200	8	1	None
FPGA UART0	Corresponds to the J55 header on the board. Please contact ARM for more information about this type of header.	AP Trusted Firmware	115200	8	1	None
FPGA UART1	Corresponds to the J56 header on the board. Please contact ARM for more information about this type of header	Unused at the moment	-	-	-	-

Quick Start

If you have just unpacked a new Juno board and would like to get it booting straight away, you may wish to skip ahead to the Set up and boot the Juno board section.

Juno software stack overview

There are several pieces of software that make up the complete Juno software stack, and a description of each one follows below.

Juno MCC Microcontroller Firmware

The MCC is a microcontroller on the motherboard that takes care of early setup before the SCP or applications processors are powered on. The MCC is also responsible for managing firmware upgrades.

System Control Processor (SCP) Firmware

The Juno System Control Processor (SCP) is an on-chip Cortex-M3 that provides low level power management and system control for the Juno platform.

Application Processor (AP) Trusted Firmware

The Juno AP Trusted Firmware provides low-level Trusted World support for the Juno platform.

Unified Extensible Firmware Interface (UEFI)

The Juno UEFI implementation provides Linux loader support for the Juno platform. It is based on the open source EFI Development Kit 2 (EDK2) implementation from the Tianocore sourceforge project.

Linux Kernel

The Linaro Stable Kernel (LSK) for Juno.

Linux filesystem

An Openembedded filesystem from Linaro can be mounted via USB (recommended) or NFS over Ethernet.

Android kernel and AOSP

The LSK image contains Android patches and has a unified defconfig, so the same kernel binary will work with a Linux filesystem or an AOSP filesystem (available from Linaro).

Software preloaded on new Juno boards

New Juno boards arrive preloaded with MCC firmware, SCP firmware, AP trusted firmware, UEFI, and a Linux kernel. The Juno board does not contain a Linux filesystem or Android AOSP filesystem anywhere in onboard storage.

Please note that early batches of Juno boards contained an SCP firmware image that limits the CPU clock to 50 MHz. ARM strongly recommends that you immediately upgrade to the latest firmware image hosted on this website by following the instructions in the section titled “Firmware update” on the Binary Image Installation tab.

When the power is first turned on, it should boot straight through to Linux. UEFI offers a 10 second window during which you can interrupt the boot sequence by pressing a key on the serial terminal, otherwise the Linux kernel will be launched. In order to reach the Linux shell you must attach a Linux filesystem via USB. If no filesystem is attached then Linux will boot as far as it can and then announce that it is waiting for a filesystem to be attached.

New Juno boards do not contain any Android software pre-installed.

Set up and boot the Juno board

You are strongly recommended to update to the latest firmware before doing anything productive with your Juno board.

The steps to set up and boot the board are:

Connect a serial terminal to the UART0 connector (settings).
Connect the 12 volt power, then press the red ON/OFF button on the back panel.

Getting Juno to boot to the Linux shell

If you have just received a new board and powered it on for the first time, you will not reach the Linux shell. Juno will boot Linux to the point where it looks for a filesystem, and when it can’t find one it will sit and wait for one to be attached. To boot all the way to the Linux shell you will need to attach a root filesystem.

Setting the Real Time Clock (required for Android)

New Juno boards do not have the correct time programmed into the real time clock. Some software (notably Android) will not operate correctly until a sensible time is programmed. To set the time, start a terminal session with UART0 connector (settings). Ensure there is power to the board, but the SoC must be powered off (if it is not, then press the black “Hardware Reset” button).

Execute the following:

ARM V2M-Juno Boot loader v1.0.0
HBI0262 build 596
ARM V2M_Juno Firmware v1.1.7
Build Date: May 27 2014
Time :  11:52:35 
Date :  09:07:2060 
Cmd> debug
Debug> date
09/07/2060
Change Date? Y\N >y
D:>23
M:>6
Y:>2014
Debug> time
15 : 51 : 58
Change Time? Y\N >y
s:>0 
m:>08
h:>14
Debug>

Enabling Texture Compression Formats

The Mali GPU in Juno is able to use a variety of texture compression formats, many of which are subject to license from third parties. It is the responsibility of the end user to obtain a license for each texture that will be used on Juno. Once such licenses are obtained, the textures can be enabled by the following procedure:

1. Connect a serial terminal to the top 9-pin UART0 connector on the rear panel (115200 baud, 8, n, 1).

2. Connect a USB cable between the USB Configuration Port on the rear panel and a USB port of your host computer.

3. Connect the 12 volt power supply to the board.

The serial terminal will show the command prompt Cmd>

4. At the Cmd> prompt on the serial terminal, issue the command usb_on

Cmd> usb_on

The configuration flash memory should now be visible on the host computer as a mass storage device.

5. Open the file SITE1/HBI0262B/board.txt for editing.

6. Consult table 1 below to determine the correct value that should be programmed into the GPU texture format register to enable only the registers that you have licensed for use with Juno. To reset to factory settings, the value to program should be 0×00FE001E.

7. In the [SCC REGISTERS] section, below the “TOTALSCCS” line, insert the following line:

SCC: 0x05C <value from step 6 above>         ;Optional comment to explain which texture you have enabled

8. Update the TOTALSCCS count (increment it by one) so that it now reflects the total number of SCC registers that are programmed.

If there was already an “SCC: 0×05C” line present in SITE1/HBI0262B/board.txt then you should edit that line rather than inserting a new one, and there is no need to increment TOTALSCCS.

9. Press the red ON/OFF button on the rear panel of the board and wait for reprogramming to complete.

The board will load the default configuration and boot up.

Table 1. Bit mappings for the CONFIG_TEX_COMPRESSED_FORMAT_ENABLE register.

Please ensure you have obtained the appropriate license(s) before enabling these texture compression formats

Bit	Texture compression format	Direct X 9	DirectX 10	DirectX 11	OpenGL ES 1.1	OpenGL ES 2.0	OpenGL ES 3.0	OpenGL 2.0 – 2.1	OpenGL 3.0 – 3.1	OpenGL 3.2 – 4.1	OpenGL 4.2
0	Invalid format
1	ETC2				x^[a]	x^[a]	x
2	EAC, 1 component						x
3	ETC2 + EAC						x
4	EAC, 2 components						x
5	Reserved
6	NXR
7	BC1_UNORM (DXT1)	x	x	x	x^[b]	x^[b]	x^[b]	x^[f]	x^[f]	x^[f]	x^[f]
8	BC2_UNORM (DXT3)	x	x	x		x^[c]	x^[c]	x^[f]	x^[f]	x^[f]	x^[f]
9	BC3_UNORM (DXT5)	x	x	x		x^[d]	x^[d]	x^[f]	x^[f]	x^[f]	x^[f]
10	BC4_UNORM (RGTC1_UNORM)		x	x				x^[g]	x	x	x
11	BC4_SNORM (RGTC1_SNORM)		x	x				x^[g]	x	x	x
12	BC5_UNORM (RGTC2_UNORM)		x	x				x^[g]	x	x	x
13	BC5_SNORM (RGTC2_SNORM)		x	x				x^[g]	x	x	x
14	BC6H_UF16			x						x^[h]	x
15	BC6H_SF16			x						x^[h]	x
16	BC7_UNORM			x						x^[h]	x
17	EAC_SNORM, 1 component						x
18	EAC_SNORM, 2 components						x
19	ETC2 + punch-through alpha						x
20	ASTC 3D LDR
21	ASTC 3D HDR
22	ASTC 2D LDR				x^[e]	x^[e]	x^[e]
23	ASTC 2D HDR
24 – 31	Reserved

Key
   [a]   Enable for GL_OES_compressed_ETC1_RGB8_texture
   [b]   Enable for GL_EXT_texture_compression_dxt1
   [c]   Enable for GL_ANGLE_texture_compression_dxt3
   [d]   Enable for GL_ANGLE_texture_compression_dxt5
   [e]   Enable for GL_KHR_texture_compression_astc_ldr
   [f]   Enable for GL_EXT_texture_compression_s3tc
   [g]   Enable for GL_EXT_texture_compression_rgtc
   [h]   Enable for GL_ARB_texture_compression_bptc

Additional documentation

For further details, please see the following documents.

Linaro Releases

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

About the Linaro OpenEmbedded Release for ARMv8-A

About the Juno ARM Development Platform

About the Linaro Stable Kernel (LSK)

License

Support

Functionality Listed by Software Component

Linux Kernel

UEFI

ARM Trusted Firmware

SCP Firmware

Known Limitations Listed by Software Component

Linux Kernel

UEFI

ARM Trusted Firmware

SCP Firmware

Known Issues

License

Installation

Pre-Installation Steps

Using pre-built image

Prerequisites

Installation Steps

Building a custom image using pre-built components

Prerequisites

Booting the image

UEFI Configuration

Example UEFI Configuration

Automating the EFI Shell boot command

Restoring the default UEFI configuration

DS-5 Configuration Files for Juno

Firmware update

License

Building the Linaro Kernel

Prerequisites

Get the Linaro Kernel Source

Create a kernel config

Build the kernel

Install your kernel

Building Firmware From Source

Prerequisites

SCP Firmware

ARM Trusted Firmware

Obtaining sources

Configuration

Building

UEFI

Obtaining sources

Configuration

Building

Packaging the binaries

Building a FIP binary

Installing the binaries

License

Juno ports

Back panel

Front panel

UARTs

Quick Start

Juno software stack overview

Juno MCC Microcontroller Firmware

System Control Processor (SCP) Firmware

Application Processor (AP) Trusted Firmware

Unified Extensible Firmware Interface (UEFI)

Linux Kernel

Linux filesystem

Android kernel and AOSP

Software preloaded on new Juno boards

Set up and boot the Juno board

Getting Juno to boot to the Linux shell

Setting the Real Time Clock (required for Android)

Enabling Texture Compression Formats

Table 1. Bit mappings for the CONFIG_TEX_COMPRESSED_FORMAT_ENABLE register.

Additional documentation