5AI.1.8 Release Notes

From OMAPpedia

Jump to: navigation, search


[edit] Introduction

This software release has been developed and verified in the following software and hardware environment.

OS Kernel: Linux® 3.1
Android: Android IcecreamSandwich 4.0.3 MR1
Audio Back End (ABE): 09.51
Toolchain: CodeSourcery compiler version Sourcery G++ Lite 2010q1-202 for ARM GNU/Linux
Reference hardware platforms: TI OMAP5 5430 SEVM ES1.0 GP
Build Host OS: Ubuntu
Daily Build OMAP5 SEVM Version: OMAP5_master build 72

[edit] Tools & Dependency packages

Pre-requisite packages for building the Android Filesystem (Note this is with reference to Ubuntu 10.04 64-bit). Ubuntu 64-bit is required by Ice Cream Sandwich.

If you are behind firewall, you will have to set-up firewall using the instructions in [1]

The following commands will install the correct packages to your server:

sudo apt-get install git-core flex bison gperf libesd0-dev zip libwxgtk2.6-dev zlib1g-dev build-essential tofrodos x-dev 
sudo apt-get install lib32readline5-dev libstdc++6 lib32z1 lib32z1-dev ia32-libs g++-multilib libx11-dev libncurses5-dev 

Add the partner repositories and install the JDK:

sudo add-apt-repository "deb http://archive.canonical.com/ lucid partner"
sudo apt-get update
sudo apt-get install sun-java6-jdk

Install latest repo tool:

mkdir ~/bin -p
sudo apt-get install curl
curl https://dl-ssl.google.com/dl/googlesource/git-repo/repo > ~/bin/repo
chmod a+x ~/bin/repo
export PATH=~/bin:$PATH

Command to get repo version:

repo --version
Should be repo version v1.7.8.2 or higer.

If you do not have sudo rights to your machine, contact your System Administrator for assistance.

Tool Chain for building Kernel and Drivers

The Kernel and Driver sources are built using Sourcery G++ Lite 2010q1-202 for ARM GNU/Linux version.

This tool chain can be obtained from


[edit] Downloading Release Software

Android Filesystem Sources


1: You should export a variable "https_proxy" when behind a firewall, since file system build downloads repo tree from Google server over https connection. You can use the format mentioned


export https_proxy=<local_site_proxy_server eg: http://local.proxyserver.com:80>

2: Ensure that you back up .repo folder into another location, otherwise it will take precedence on top of the one you will be creating below. Command below for reference

mv $HOME/.repo $HOME/.repo_old

You can get the Android source for this release by doing:

cd <your work directory>
mkdir -p 5AI.1.8
cd 5AI.1.8
export YOUR_PATH=`pwd`
mkdir -p mydroid; cd mydroid
export MYDROID=`pwd`
repo init -u git://git.omapzoom.org/platform/omapmanifest.git -b 5AI.x -m RLS_5AI.1.8.xml
repo sync

Kernel & Driver Sources

To clone kernel source from scratch do:

mkdir kernel
git clone git://git.omapzoom.org/kernel/omap.git kernel/android-3.1
cd kernel/android-3.1
git checkout 25dc20ff634d866e88839b8c741ff58c0ed8c3a6

If you already have kernel source cloned then just update it:

cd $YOUR_PATH/kernel/android-3.1
git fetch origin
git checkout 25dc20ff634d866e88839b8c741ff58c0ed8c3a6

U-Boot Sources

git clone git://git.omapzoom.org/repo/u-boot.git u-boot
cd u-boot
git checkout a599f1087eac48b6dba2170bd5d2659774f947c7

UsbBoot Sources

git clone git://git.omapzoom.org/repo/omapboot.git usbboot
cd usbboot
git checkout cc4768892a70aab1f3833ede1d6011836d41857a

[edit] Release Content

This release has the below content - Kernel and Drivers tested with OMAP5 5430 SEVM 1.0 GP and verified with Ice Cream Sandwich UI

[edit] Build Instructions

[edit] Setting up build environment

From your work directory (5AI.1.8 folder):

export YOUR_PATH=`pwd`
export PATH=$PATH:<toolchain_parent_dir>/arm-2010q1/bin
export MYDROID=${YOUR_PATH}/mydroid
mkdir $MYDROID/logs
export CROSS_COMPILE=arm-none-linux-gnueabi-
export PATH=${YOUR_PATH}/u-boot/tools:${PATH}

[edit] Building U-BOOT

cd ${YOUR_PATH}/u-boot
git clean -fdx
make CROSS_COMPILE=" arm-none-linux-gnueabi-" clean
make CROSS_COMPILE=" arm-none-linux-gnueabi-" omap5_evm5430_android_config
make CROSS_COMPILE=" arm-none-linux-gnueabi-" all

[edit] Generating boot.scr to boot from SD

NOTE: This is done automatically, and is based on the information in "boot.scr.omap.txt". This information is provided for information purposes only.

cd ${YOUR_PATH}/u-boot
echo "i2c mw 0x48 0xd9 0x15" > boot.cmd
echo "i2c mw 0x48 0xd4 0x05" >> boot.cmd
echo "mmc part" >> boot.cmd
echo "fatload mmc 0:1 0x80300000 uImage" >> boot.cmd
echo "bootm 0x80300000" >> boot.cmd
mkimage -A arm -O linux -T script -C none -a 0 -e 0 -n 'OMAP5 Integration' -d boot.cmd boot.scr

[edit] Building usbboot

This is for creating the emmc boot

cd ${YOUR_PATH}/usbboot
git clean -fdx
export TOOLCHAIN=${MYDROID}/prebuilt/linux-x86/toolchain/arm-eabi-4.4.3/bin/arm-eabi-
make ARCH=omap5 BOARD=omap5evm clean
make ARCH=omap5 BOARD=omap5evm

[edit] Building Kernel

To create kernel uImage you need to add "mkimage" directory path to your "PATH" environment variable:

cd ${YOUR_PATH}/kernel/android-3.1
make -j$(cat /proc/cpuinfo |grep ^proc|wc -l) ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabi- mrproper
make -j$(cat /proc/cpuinfo |grep ^proc|wc -l) ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabi- android_omap5sevm_defconfig
make -j$(cat /proc/cpuinfo |grep ^proc|wc -l) ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabi- uImage modules

[edit] Patching Android Filesystem (AFS) with TI Codecs enabled

This build requires 1 userspace patches to be applied and is attached to this wiki page. These instructions assume you have downloaded the attached patch into ${MYDROID}.

cd ${MYDROID}/hardware/ti/omap4xxx
git fetch http://review.omapzoom.org/p/platform/hardware/ti/omap4xxx refs/changes/07/19107/1 && git cherry-pick FETCH_HEAD

[edit] Building Android Filesystem (AFS)

. build/envsetup.sh
lunch 15
make -j $(egrep '^processor' /proc/cpuinfo | wc -l) clean
make -j $(egrep '^processor' /proc/cpuinfo | wc -l)

[edit] Building SGX

The SGX package is based on the following internal repository:

tar zxf <PATH TO>/SGX_5AI.1.8.tgz
cd sgx_2012-03-07_13-53-56
export KERNELDIR=${YOUR_PATH}/kernel/android-3.1
export DISCIMAGE=${PWD}/discimage
if [ -d ${DISCIMAGE} ]; then
  rm -rf ${DISCIMAGE}
mkdir ${DISCIMAGE}
./build_DDK.sh --build omap5 release clobber
./build_DDK.sh --build omap5 release
fakeroot ./build_DDK.sh --install omap5 release

[edit] Building Ducati

The Ducati MM package "Ducati_5AI.1.8.tgz" will need to be downloaded from CDDS.

The tools need to be downloaded and installed in a common tools directory that would then be used during the build.
A complete Tools package is available from CDDS at the following link: ICS_Ducati_Tools
A more detailed set of instructions for setting up the tools is available in the OPBU_Linux_5AI_1_8_Release_Notes document that can be downloaded from CDDS.
This package will install the tools together in one specific directory called dsptools.

[edit] Setup

tar zxf <PATH TO>/Ducati_5AI.1.8.tgz

[edit] Build Steps for RPMSG

cd ${YOUR_PATH}/Ducati_2012-03-08_04-01-05/
export DUCATI=`pwd`
git clone git://git.omapzoom.org/repo/sysbios-rpmsg.git ducati-
cd ducati-
git checkout
chmod +w Makefile
export DSPTOOLS=<Ducati_tools_install_path>
Edit the Makefile - REPO - else echo - put the path to the dsptools.  Example using sed command below:
sed -i -e "s#/usr/local#${DSPTOOLS}#g" Makefile 
export PATH=${PATH}:<location_cgtarm>
export XDCPATH="<sysbios-rpmsg>/src; <BIOSPATH>/bios_6_32_01_38/packages"
export TMS470CGTOOLPATH=<location of cgtarm-4.9.0>
export C6000CGTOOLPATH=<location of cgt6x-7.2.0>
make clean
make -j4

[edit] Build Steps for Ducati

More details on the Ducati build steps are given in the release document: OPBU_Linux_5AI_1_8_Release_Notes.doc available on CDDS.
The paths below need to be defined and for each export commands are one line.

Environment Settings:
export XDCPATH="<sysbios-rpmsg>/src;<BIOSPATH>/bios_6_32_01_38/packages; <IPCPATH>/ipc_1_23_01_26/packages;<CEPATH>/codec_engine_3_21_00_19/packages;

export TMS470CGTOOLPATH=<location of cgtarm-4.9.0>
export XDCROOT=<location of tools/XDC/xdctools_3_22_03_41
export XDCBUILDCFG=../../build/config.bld
export XDCARGS= Use eith Without or Without Instrumentation settings

For OMAP5 XDCARGS options:

Without Instrumentation: 
export XDCARGS="profile=release core=app_m3 target_build=BUILD_OMAP4 SenPosition=TABLET board_config=BOARD_CONFIG_TI_SEVM_S3D hw_type=OMAP5"
With Instrumentation: 
export XDCARGS="profile=release core=app_m3 target_build=BUILD_OMAP4 SenPosition=TABLET board_config=BOARD_CONFIG_TI_SEVM_S3D hw_type=OMAP5 prof_type=ENABLE"

Specific Build Steps:

cd ${DUCATI}/WTSD_DucatiMMSW/platform/base_image
Clean: xdc clean -PD .
Build: xdc --jobs=4 -PD .  (the jobs depends on your build machine - more cores the larger the number)

Building the ducati-m3.bin: After the build is complete, invoke below command from "sysbios-rpmsg/src/utils/" location in bios syslink tree:

cd ${DUCATI}/ducati-
./genrprc ../ti/examples/srvmgr/ti_platform_omap4430_core0/release/test_omx_sysm3.xem3 \
               <PATH TO DUCATI APP_M3 BASE IMAGE>/out/app_m3/release/base_image_app_m3.xem3 \

The ducati-m3.bin would be generated and then this binary will be copied into the Android File System as instructed below.

[edit] Preparing Android binaries

This release supports both emmc boot and sd card boot. For the emmc the system image file must have the sgx and ducati binary included.

[edit] Rebuild Android Filesystem (AFS) including the Ducati & SGX binaries

export BOARD_TYPE="omap5sevm"
. build/envsetup.sh
lunch 15
cp -v ${YOUR_PATH}/kernel/android-3.1/arch/arm/boot/zImage device/ti/${BOARD_TYPE}/boot/zImage
cp -v ${YOUR_PATH}/u-boot/u-boot.bin device/ti/${BOARD_TYPE}/boot/u-boot.bin
cp -v ${DUCATI}/ducati-m3.bin out/target/product/${BOARD_TYPE}/system/vendor/firmware/
cp -avf ${YOUR_PATH}/sgx_2012-03-07_13-53-56/discimage/system/vendor/* out/target/product/${BOARD_TYPE}/system/vendor/
for i in $(ls out/target/product/omap5sevm/*img); do rm -vf $i; done
make -j $(egrep '^processor' /proc/cpuinfo | wc -l)

[edit] Preparing eMMC binaries/images

mkdir emmc_files
cp -v ${MYDROID}/out/target/product/omap5sevm/*img emmc_files
cp -v ${MYDROID}/out/target/product/omap5sevm/fastboot.sh emmc_files
cp -v  ${MYDROID}/out/host/linux-x86/bin/{simg2img,make_ext4fs,mkbootimg,fastboot} emmc_files
cp -v ${YOUR_PATH}/kernel/android-3.1/arch/arm/boot/zImage emmc_files
cp -v ${YOUR_PATH}/u-boot/u-boot.img emmc_files
cp -v ${YOUR_PATH}/u-boot/MLO emmc_files/omap5evm_GP_ES1.0_MLO
cp -v ${YOUR_PATH}/usbboot/out/omap5evm/usbboot emmc_files
cp -v ${YOUR_PATH}/usbboot/out/omap5evm/iboot.ift emmc_files

It is required to modify the fastboot.sh script for the OMAP5 flashing process so make the following changes as listed below:

Modify the lines:
  export FASTBOOT=${FASTBOOT-"./../../../../out/host/linux-x86/bin/fastboot"} ==>   export FASTBOOT=./fastboot
  export PRODUCT_OUT=${PRODUCT_OUT-"./"} ==>   export PRODUCT_OUT=./
  ./../../../../out/host/linux-x86/bin/make_ext4fs -s -l 256M -a cache ${cacheimg} /tmp/fastboot-cache/
==>   ./make_ext4fs -s -l 256M -a cache ${cacheimg} /tmp/fastboot-cache/

Move the 2 lines below so they are above the line: echo "Flashing bootloader....."
  echo "Create GPT partition table"
  ${FASTBOOT} oem format

Remove all of the function that starts with the given line (it is at the end):
  -if [ $resizefail -eq 1 ]; then

[edit] Flashing eMMC images

This is done using usbboot to put the OMAP5 board in fastboot mode with the steps given below:

Required dip switch settings
Set the boot order to be USB first and eMMC second (on the back of the board)
 3  2  1  0

Connect your micro usb cable (USB3 cable can also be used) from the
target to your flashing station, power supply, usb cable using a terminal or screen
(for screen the command is: screen /dev/ttyUSB0 115200)

1. Make sure the board is powered OFF

2. Start usbbboot in fastboot mode:
sudo ./usbboot -f

3. Power up your board

4. Run your fastboot.sh script
sudo ./fastboot.sh

This will flash the binaries to the eMMC. 
6. Now reset the board.

[edit] Preparing For SD Card Boot

The following binaries are required by the OMAP5 SEVM board. This step will prepare a directory, called myfs, containing all necessary Android files that you must include within your SD card.

[edit] Create the filesystem

mkdir myfs
cd myfs
cp -Rfp $MYDROID/out/target/product/$BOARD_TYPE/root/* .
cp -Rfp $MYDROID/out/target/product/$BOARD_TYPE/system/ .
cp -Rfp $MYDROID/out/target/product/$BOARD_TYPE/data/ .

[edit] Create the boot partition

mkdir boot
cd boot
cp ${YOUR_PATH}/kernel/android-3.1/arch/arm/boot/uImage .
cp ${YOUR_PATH}/u-boot/MLO .
cp ${YOUR_PATH}/u-boot/u-boot.img .
cp ${YOUR_PATH}/u-boot/boot.scr .

[edit] Formatting SD Card

You will need to format your SD for the Linux file system. Connect your micro SD memory card reader with memory card inserted to a USB port on your Linux Ubuntu PC. There is a shell script that

performs all of the formatting required. Download it with:

$ wget http://cgit.openembedded.org/cgit.cgi/openembedded/plain/contrib/angstrom/omap3-mkcard.sh

Add execution permission:

$ chmod +x omap3-mkcard.sh

And you are ready to use it by just typing:

$sudo ./omap3-mkcard.sh <your_device (e.g. /dev/sdb)>

Once it has finished, remove and reinsert the micro SD card. If you are logged in graphically, "/media/boot" and "/media/Angstrom" will be automatically mounted. Otherwise you will need to mount them


[edit] Installing the required files to micro SD

Assuming your micro SD card is mounted on "/media/boot" and "/media/Angstrom", use the following commands to populate the card:

sudo  cp -a ${YOUR_PATH}/boot/* /media/boot/
sudo  cp -a ${YOUR_PATH}/myfs/* /media/Angstrom/
sudo sync
sudo eject /media/boot
Personal tools