STM32MP1 Distribution Package for Android

This message will disappear after all relevant tasks have been resolved.

Semantic MediaWiki

There are 1 incomplete or pending task to finish installation of Semantic MediaWiki. An administrator or user with sufficient rights can complete it. This should be done before adding new data to avoid inconsistencies.

This article describes how to obtain and use the Distribution Package for Android of the STM32MPU Embedded Software for any STM32MP1 family (STM32MP15 boards) development platform, in order to modify or add pieces of software, and to create the right Android distribution for the targeted product.

It lists some prerequisites in terms of knowledge and development environment, and gives step-by-step instructions to download and install the STM32MPU Embedded Software packages for this Package.

1. Distribution Package content[edit source]

If you are not familiar with the STM32MPU Embedded Software for Android distribution and its Packages, please read the following articles:

Which STM32MPU Embedded Software Package for Android better suits your needs (and especially the Distribution Package chapter)
STM32MPU Embedded Software distribution for Android

In summary, this Distribution Package provides:

an Android build framework (aka distribution builder)
for the STM32MPU distribution for Android (development on Arm Cortex-A processor):
- the BSP (Linux kernel, U-Boot, TF-A, optionally OP-TEE) pieces in binary (prebuilt). Several scripts are provided to load source code and re-build them.
- the application frameworks (including hardware abstraction code) pieces in source code.
for the STM32Cube MPU Package (development on Arm Cortex-M processor), all pieces of software in source code: BSP, HAL, middlewares and applications
a toolset to tune the system for your needs, and to handle the built image (for example STM32CubeProgrammer to install the built image on the board)

2. Checking the prerequisites[edit source]

2.1. Knowledges[edit source]

The STM32MP1 Distribution Package aims at creating an Android distribution for the targeted product: solid knowledge of Linux and Android are recommended to make the most of this Package.

The STM32MPU distribution for Android is an Android distribution based on the Android build framework: a short introduction about Android is available in AOSP^[1].

Reading the STM32MPU Embedded Software for Android architecture overview is also highly recommended.

2.2. Development setup[edit source]

The recommended setup for the development PC (host) is specified in the following article: PC prerequisites.

Whatever the development platform (board) and development PC (host) used, the range of possible development setups is illustrated by the picture below.

Development setup for Developer and Distribution Packages

The following components are mandatory:

Host PC for cross-compilation and cross-debugging, installed as specified above
Board assembled and configured as specified in the associated Starter Package article
Mass storage device (for example, microSD card) to load and update the software images (binaries)

The following components are optional, but recommended:

A serial link between the host PC (through Terminal program) and the board for traces (even early boot traces), and access to the board from the remote PC (command lines)
An Ethernet link between the host PC and the board for cross-development and cross-debugging through a local network. This is an alternative or a complement to the serial (or USB) link
A display connected to the board, depending on the technologies available on the board: DSI LCD display, HDMI monitor (or TV) and so on
A mouse and a keyboard connected through USB ports

Additional optional components can be added by means of the connectivity capabilities of the board: cameras, displays, JTAG, sensors, actuators, and much more.

3. Installing the STM32MPU distribution for Android[edit source]

Delivery for Android coming soon (Q4 2019)

In order to install the STM32MPU distribution for Android you need to have access to the ST git.

First you need to install the repo tool^[2].

 mkdir ~/bin
 PATH=~/bin:$PATH
 curl https://storage.googleapis.com/git-repo-downloads/repo > ~/bin/repo
 chmod a+x ~/bin/repo

This tool looks like a git but it is able to manage multiple git at the same time, more information available in the repo documentation^[3].

Initialize your local reposirtory. To do so create a folder:

 mkdir myDistribution
 cd myDistribution

Then launch repo:

 repo init -u <git_url>

This will automaticaly download the default.xml file located in the git project given by the option -u.

This file is the manifest containing all projects reference.

Now you need to download all sources attach to each projects:

 repo sync

This may take several hours.

3.1. Use ccache[edit source]

In order to reduce compilation time for next times you can enable ccache.

 source /device/stm/<SocId>/scripts/ccache/ccachesetup.sh <PATH_TO_CCACHE_FOLDER>
 source build/envsetup.sh
 cachesetup --new

Then you can update specific cache or create new one.

For more information on how to use the command look at the cachesetup usage:

Usage: cachesetup [Options] <cache option>
Setup (create or update) Git cache based on configuration file android_cache.config

Options:
  -h/--help: get current help
  -v/--version: get script version
  or
  -u/--update: update cache (default)
  or
  -f/--force: create cache (force)
  -n/--new: create cache (only create non-existing cache)

<cache option>:
    all (default)
  or select list of required cache within the following options:
    aosp
    android
    kernel
    tf-a
    u-boot

3.2. Use repo mirror[edit source]

In order to reduce repo sync time and bandwidth usage you can create a mirror of the reposirtory.

 mkdir aosp_mirror
 cd aosp_mirror
 repo init -u <repo_url> -b <version> --mirror
 repo sync

With repo_url the url of the ST git or the official AOSP.

The init of your working repo will change a little bit:

 mkdir myDistribution
 cd myDistribution
 repo init --reference=<path>/aosp_mirror -u <repo_url> -b <version>
 repo sync

This will copy all necessary files define by the manifest from the mirror instead of downloading it.

Then you can use it like a standard reposirtory.

3.3. Use packages[edit source]

If you have been provided with an archive, for example stm32mpuDistribution.tar.gz you need to follow those steps:

Download the official AOSP version compatible with the archive (with or without mirror):

 mdkir myDistribution
 cd myDistribution
 repo init -u https://android.googlesource.com/platform/manifest -b android-<version>
 repo sync

For more info on available version please have a look in the official page^[4].

Extract the archive inside myDistribution:

 tar -xzf stm32mpuDistribution.tar.gz

This will put all custom ST files at the right location.

4. Building the STM32MPU distribution for Android[edit source]

When the installation is completed, please refer to the How to build STM32MPU distribution for Android page to learn how to build it.

5. Flashing the built image[edit source]

The ${ANDROID_PRODUCT_OUT}> directory receives complete file system images built for board selected un lunch step.

Build directory structure: images

Information

This is an example: the files seen in your build directory, might slightly differ

${ANDROID_PRODUCT_OUT}
├── boot.img                  Binary for boofs partition
├── dt.img                    Linux kernel device tree image for bootfs partition
├── fsbl-optee.img            TF-A binary for FSBL partition (OP-TEE)
├── fsbl-programmer.img       TF-A binary for FSBL partition (trusted boot chain for programmer)
├── fsbl-trusted.img          TF-A binary for FSBL partition (trusted boot chain)
├── misc.img                  Binary for misc partition
├── ramdisk.img               Binary for ramdisk partition
├── ramdisk-recovery.img      Binary for ramdisk recovery partition
├── splash.img                Binary for splashscreen
├── ssbl-optee-fbsd.img       U-Boot binary for SSBL partition (OP-TEE)
├── ssbl-programmer.img       U-Boot binary for SSBL partition (trusted boot chain for programmer)
├── ssbl-trusted-fbsd.img     U-Boot binary for SSBL partition (trusted boot chain)
├── system.img                Binary for system partition
├── teed.img                  Binary for OP-TEE OS paged data
├── teeh.img                  Binary for OP-TEE OS header image
├── teex.img                  Binary for OP-TEE OS resident core
├── userdata.img              Binary for userdata partition
├── vendor.img                Binary for vendor partition
└── [...]

The STM32CubeProgrammer tool is used to flash the 1st stages of images to the STM32MP15 board. It is assumed that this tool has been installed through the Starter Package associated with your board. The fastboot is also used to flash Android images.

Depending on the board, several Flash devices (microSD, eMMC and so on) might be available. The microSD card is considered as the Flash device in the rest of this article.

Go to the Distribution Package directory, and run flash-device:

 flash-device

Select the flashlayout you want to use (ex:FlashLayout_sd_optee.tsv to flash optee build for microSD card)

1) FlashLayout_emmc_optee.tsv	 3) FlashLayout_sd_optee.tsv
2) FlashLayout_sd_trusted.tsv	 4) FlashLayout_emmc_trusted.tsv
Which layout do you want to flash ?

Once the DFU flashing is terminated, the boot switches must be configured so that the Flash device (e.g. microSD card) on which the image has been flashed, is selected as the boot source:

The figures below show the boot-switch configurations for a boot from microSD card on different boards:


Boot from microSD card on STM32MP157x-EV1 Evaluation board	Boot from microSD card on STM32MP157x-DKx Discovery kit

Press the reset button, and a long press on the button associated with fastboot (USER2 for Disco board and PA13 for Eval board). This causes the image download to continue.

This operation takes several minutes.

When the download is finished, press the reset button to reset the board. The Android software then starts.

6. References[edit source]

[1] ttps://source.android.com/devices/architecture

[2] ttps://source.android.com/setup/build/downloading

[3] ttps://source.android.com/setup/develop/repo

[4] ttps://source.android.com/setup/start/build-numbers#source-code-tags-and-builds

[1]

[2]

[3]

[4]