You are currently reviewing an older revision of this page.
Welcome to the Arm Development Platforms Community wiki and thank you for purchasing a Juno board.
We recommend all new users install the latest Arm Platforms software deliverables on their board, which will give you a full software stack including board firmware, system control processor (SCP) firmware, Arm Trusted Firmware, OP-TEE trusted execution environment, and either an EDK2-based UEFI environment or a Linux kernel plus filesystem booted via U-Boot.
Please follow the instructions below to install the latest deliverables.
The current Arm Platforms release is 18.04; see here for release notes and binary artefact direct download links.
The Arm software images contained in this release are distributed according to the EULA.
This software release supports a number of different software stacks, each of which have been validated on the Juno platform. These software stacks include
This document describes how to:
A set of prebuilt binaries are also available for a limited subset of configurations.
For any problems with your Juno system please contact email@example.com.
These instructions assume your host PC is running Ubuntu Linux 16.04.1 LTS.Windows users may also follow these instructions but will only be able to use prebuilt configurations.
A number of prerequisite packages will need to be installed. The workspace initialization script will automatically detect and list any missing prerequisite packages.
If building from source you will need to configure git's `user.name' and `user.email' attributes:
$ git config --global user.name "John Doe"
$ git config --global user.email "firstname.lastname@example.org"
Create and enter a new directory that will be your workspace. The path to this directory will be referred to as `<workspace>' in these instructions.
Next download the workspace initialization script to your workspace and run it:
$ python3 armplat_1804.py
The script will guide you through the process of initialising your workspace, automatically downloading all relevant source files and required binaries.
You can skip this section if you chose to use a prebuilt configuration when running the script.
To clean, build, and package the software:
$ ./build-scripts/build-all.sh all
You can also individually perform each of these steps:
$ ./build-scripts/build-all.sh clean
$ ./build-scripts/build-all.sh build
$ ./build-scripts/build-all.sh package
You can invoke a particular component's build script in the same way in order to build just that component rather than the whole software stack, for example `./build-scripts/build-linux.sh' targets just the Linux kernel.
If you chose to use Android or one of the OpenEmbedded filesystems, the workspace initialisation script will have placed the filesystem image in the root of `<workspace>'. You will need to write this image to a USB stick with a minimum capacity of 4GB.
Linux users can do this like so:
$ sudo dd if=<workspace>/<filesystem>.img of=/dev/sdX bs=64M
Note: Replace `/dev/sdX' with the handle corresponding to your USB stick as identified by the `lsblk' command.
Windows users will instead need to use third party software to burn the filesystem image to a USB stick, for example UNetbootin.
Next connect both a serial cable and a USB-B cable between your host PC and the Juno board (the top UART port on the back of the board), then configure a serial monitor such as `PuTTy' or `minicom' with the following settings:
Power on the board and (if prompted) press Enter to stop auto-boot. Enter the following commands on the Juno's boot monitor console:
This will delete any binaries and UEFI settings currently stored in the Juno's Flash, then mount the Juno's MMC card as an external storage device on your host PC.
From your host PC, delete all files on your Juno's mounted MMC card. How you then proceed will depend on whether you built from source or are using a prebuilt configuration.
Copy the contents of the resulting subdirectory in your workspace onto the Juno's mounted MMc card (for example `<workspace>/juno-latest-busybox-uboot/*' for a Juno `latest-armlt' + BusyBox prebuilt configuration), then skip to "Booting the board".
Copy the contents of `<workspace>/recovery/' directory onto the Juno's mounted MMC card.
Next, navigate to the subdirectory in `<workspace>/output/' corresponding to your chosen configuration.
For example for an EDK2-based UEFI environment this will be `<workspace>/output/juno/juno-uefi/' whereas for an Android environment it will be `<workspace>/output/juno/juno-android/uboot/'.
Copy all files from that folder into the `/SOFTWARE/' folder on your Juno's mounted MMC card, overwriting any duplicate files.
Be sure to issue a `sync' command on your host PC after copying any files in the previous step, which will guarantee that the copy has completed.
If you chose to use Android or one of the OpenEmbedded filesystems, insert the USB stick created earlier into one of the Juno's rear USB ports (not needed for BusyBox or if booting into an EDK2-based UEFI environment).
Finally, power cycle the Juno. After it has finished copying the contents of the MMC card into Flash, the board will boot up and run the new software images.
If booting a Linux kernel you should eventually reach a prompt, at which point can start using the system.
If booting into an EDK2-based UEFI environment you can launch an EFI application or manually boot a kernel, see here.
These instructions are intended for users wishing to build/modify the Android filesystem from source. These instructions are based on a specific year/month (YY.MM) release of the Juno Android filesystem here.
Download the following binary artefacts from your chosen YY.MM release page:
Run the Linaro Android build script:
$ chmod a+x linaro_android_build_cmds.sh
$ ./linaro_android_build_cmds.sh -m pinned-manifest.xml
The results of the build process can be found in `./out/target/product/juno/'.
This tool is used to create a filesystem disk image on a USB stick.
To obtain the latest version of the `linaro-image-tools':
$ git clone http://git.linaro.org/ci/linaro-image-tools.git
$ git checkout 2016.10
This repository provides the python script `linaro-android-media-create'
Write the filesystem image to a USB stick with a minimum capacity of 4GB:
$ cd android/out/target/product/juno/
$ sudo linaro-android-media-create --image_size 2000M --image-file juno.img --dev vexpress --boot boot.tar.bz2 --system system.tar.bz2 --userdata userdata.tar.bz2
$ sudo dd if=juno.img of=/dev/sdX bs=64M
Note: The contents of the resulting `/boot' partition on the USB stick are not used. These components are instead provided as part of the Juno deliverables from the main instructions above and are resident in NOR Flash.
These instructions are intended for users wishing the build/modify the OpenEmbedded filesystem from source. These instructions are based on a specific year/month (YY.MM) release of the Juno OpenEmbedded deliverables here.
Ensure the repo tool is on your PATH. If necessary, install the Repo tool as per the "Installing Repo" section here Note: Do not initialize the Repo client
In this section replace `YY.MM' with your chosen release, for example `15.09'.
Clone the required repositories and perform initial setup:
/* Create workspace */
/* WARNING: Do *not* create this as a subdirectory of the main Linaro Arm Platforms workspace created by `workspace_yy.mm' above */
$ mkdir openembedded
$ cd openembedded
$ export OE_HOME=`pwd`
$ git clone git://git.linaro.org/openembedded/jenkins-setup.git
$ cd $OE_HOME/jenkins-setup
$ git checkout release-YY.MM
$ cd $OE_HOME
$ sudo jenkins-setup/pre-build-root-install-dependencies.sh
$ cd $OE_HOME/openembedded-core
/* Add bitbake to your $PATH */
$ export PATH=$OE_HOME/openembedded-core/bitbake/bin:$PATH
The following `bitbake' recipes are available:
You can list all recipes like so:
$ cd $OE_HOME/build
$ bitbake-layers show-recipes
To build a recipe:
$ cd $OE_HOME/build
$ bitbake linaro-image-minimal
Images are written to `$OE_HOME/build/tmp-glibc/deploy/images'.