NOTICE: The Processors Wiki will End-of-Life in December of 2020. It is recommended to download any files or other content you may need that are hosted on The site is now set to read only.

TI-Android-Éclair-DevKit-V1 UserGuide

From Texas Instruments Wiki
Jump to: navigation, search


TI Android Eclair DevKit V1 User Guide

User Guide - July 30, 2010

About this manual

This document describes how to install and work with Texas Instruments' Android Éclair DevKit release for OMAP35x, AM37x, AM35x platforms running Android. This release package provides a stable Android distribution with integrated SGX (3D graphics) drivers, TI hardware abstraction for video overlay and standard applications from Android. The package also includes Linux Android kernel, tools and documentation to ease development, deployment and execution of Android based systems. The product forms the basis for all Android application development on OMAP35x, AM37x, AM35x platforms. In this context, the document contains instructions to:

  • Install the release
  • Setting up the hardware
  • Steps to use pre-built binaries in the package
  • Running Android on the supported platforms
  • Setting up the Android debugger “adb” with the hardware platform
  • Installing and executing Android (out of market) applications hardware platforms


This section describes the list of Software and Hardware requirements to evaluate the DevKit release.

Hardware Requirements

This release of Android DevKit V1 is evaluated on the below given list of platforms. This package should be easily portable on other platforms on similar TI devices.

TI Device Platform Supported Version Other Accessories

OMAP35x EVM Rev G DVI Monitor, USB HUB, USB Keyboard, USB Mouse, Ethernet, UART Cable, Audio Speakers, MMC/SD Card (2GB min)

Beagleboard Rev Cx DVI Monitor, USB HUB, USB Keyboard, USB Mouse, Ethernet, UART Cable, Audio Speakers, MMC/SD Card (2GB min)

AM3517 Evaluation Module Rev C DVI Monitor, USB HUB, USB Keyboard, USB Mouse, Ethernet, UART Cable, Audio Speakers, MMC/SD Card (2GB min)

AM37x Evaluation Module Rev C DVI Monitor, USB HUB, USB Keyboard, USB Mouse, Ethernet, UART Cable, Audio Speakers, MMC/SD Card (2GB min)

BeagleBoard XM DVI Monitor, USB HUB, USB Keyboard, USB Mouse, Ethernet, UART Cable, Audio Speakers, MMC/SD Card (2GB min)

Software Host Requirements

If you are a Android application developer or would like to use Android SDK Tools then refer to for Host PC requirements.

To evaluate this release we recommend you to have a Linux "Ubuntu 8.04 or above" Host machine, See Ubuntu Linux installation notes

Package Content

       |-- Android_Source_Manifest
       |   `-- TI-Android-Eclair-DevKit-V1.xml
       |-- Docs
       |   |-- CTS_Report.tar.gz
       |   |-- TI-Android-DevKit-FS-Manifest.doc
       |   |-- TI-Android-DevKit-Software-Manifest.doc
       |   `-- TI-Android-Eclair-DevKit-V1_UserGuide.pdf
       |-- Filesystem
       |   |-- rootfs_am35x.tar.bz2
       |   |-- rootfs_am37x.tar.bz2
       |   `-- rootfs_omap35x.tar.bz2
       |-- OMAP35x_Android_SGX_SDK.tar.gz
       |-- Prebuilt_Images
       |   |-- AM35x_EVM
       |   |   |-- MLO
       |   |   |-- boot.scr
       |   |   |-- u-boot.bin
       |   |   |-- uImage
       |   |   `-- x-load.bin.ift
       |   |-- OMAP35x_AM37x_EVM
       |   |   |-- MLO
       |   |   |-- boot.scr
       |   |   |-- u-boot.bin
       |   |   |-- uImage
       |   |   `-- x-load.bin.ift
       |   `-- beagleboard
       |       |-- MLO
       |       |-- boot.scr
       |       |-- u-boot.bin
       |       |-- uImage
       |       `-- x-load.bin.ift
       |-- Sources
       |   |-- Android_Linux_Kernel_2_6_32.tar.gz
       |   |-- boot-strap
       |   |   `-- x-loader-
       |   `-- u-boot
       |       `-- u-boot-
       |-- TI-Android-Eclair-DevKit-V1_ReleaseNotes.pdf
       `-- Tools
            |-- flash-utility.tar.gz
            |-- mk-bootscr
            |   |-- README
            |   |-- mkbootscr
            |   `-- mkimage
            |-- mk-mmc
            |   |-- README
            |   `--
            |-- pinmux-utility.tar.gz
            `-- signGP
                |-- signGP
                `-- signGP.c

Android Booting Procedure

Booting Android on any TI platform requires following software components

  • Kernel Image (uImage)
  • Bootloader (u-boot.bin)
  • Bootstrapping (x-load.bin.ift for NAND or MLO for MMC)
  • Filesystem (rootfs)

The above listed software components or images can be populated by

  • Building sources from this package
  • Using the pre-built images in this package
- To build software components using sources require "ARM cross compiler tool chain". - The ARM tool chain can be downloaded from Android pre-built repository. Tool Chain

Software Integration

This section describes the procedure to compile and integrate all the required software components to boot Android on TI platforms.


Download the tool chain and export it in the default Linux Path.

#> export PATH=<tool chain install path>/linux-x86/toolchain/arm-eabi-4.4.0/bin/:$PATH


Untar the kernel source located in the sources directory

  #> tar -xzvf Android_Linux_Kernel_2_6_32.tar.gz

Execute the following commands to the kernel sources

  #> make CROSS_COMPILE=arm-eabi- distclean
  #> make CROSS_COMPILE=arm-eabi- <default config> 
Where default config is
omap3_evm_android_defconfig  : For OMAP35x, AM37x EVM am3517_evm_android_defconfig  : For AM35x EVM omap3_beagle_android_defconfig  : For Beagleboard Rev Cx, XM
  #> make CROSS_COMPILE=arm-eabi- uImage 
This command will build the Linux Kernel Image in arch/arm/boot "uImage"


Untar the u-boot sources located in the sources directory

  #> tar -xzvf u-boot-

Execute the following commands to the kernel sources

  #> make CROSS_COMPILE=arm-eabi- distclean
  #> make CROSS_COMPILE=arm-eabi- <default config> 
Where default config is
omap3_evm_config  : For OMAP35x, AM37x EVM am3517_evm_config  : For AM35x EVM omap3_beagle_config  : For Beagleboard Rev Cx, XM
  #> make CROSS_COMPILE=arm-eabi- 
This command will build the u-boot Image "u-boot.bin"


Untar the x-loader sources located in the sources directory

  #> tar -xzvf x-loader-

Execute the following commands to the kernel sources

  #> make CROSS_COMPILE=arm-eabi- distclean
  #> make CROSS_COMPILE=arm-eabi- <default config> 
Where default config is
omap3evm_config  : For OMAP35x, AM37x EVM am3517evm_config  : For AM35x EVM omap3beagle_config  : For Beagleboard Rev Cx, XM
  #> make CROSS_COMPILE=arm-eabi- 
This command will build the x-loader Image "x-load.bin"

To create the MLO file used for booting from a MMC/SD card, sign the x-loader image using the signGP tool found in the Tools directory of the Devkit.

  #> ./signGP ./x-load.bin

The signGP tool will create a .ift file, that can be renamed to MLO.

- The Pre-built images are provided in this package to help users boot android without building the sources

Setting up Hardware

This DevKit release supports five different platforms, OMAP35x EVM, AM37x EVM, AM35x EVM, Beagleboard Rev Cx, Beagleboard XM. While they are different devices the hardware setup will almost remain the same.

  • Connect the UART port of the platform to the Host PC and have a Terminal software like TeraTerm, Minicom or Hyperterminal.
  • Connect the Ethernet (on Beagle Rev C4 we don't have an Ethernet port)
  • Connect Audio Speakers
  • For Beagle boards you need to connect DVI Monitor through HDMI connector.
  • Use self powered USB port and connect it to USB Host port of the platform, mainly for Beagle and AM35x EVM. For AM37x and OMAP35x EVM the onboard keypad can be used
    • Connect a USB keyboard and USB Mouse to the USB HUB
- The AM35x EVM and Beagleboard have no keypad mappings, user is recommended to use USB Keyboard over a - Self powered USB HUB connected to the Host port of AM35x EVM or Beagleboard.
  • Select Appropriate DIP Switch settings on EVM(s) to boot over MMC/SD

For MMC/SD boot - On OMAP35x and AM37x EVM the DIP switch SW4 should be set as shown below


For MMC/SD boot - On AM35x EVM the DIP switch S7 should be set as shown below

1 2 3 4 5 6 7 8

Booting Android

TI platforms (Beagle or EVM) can be booted over MMC or NAND or UART. We follow and prefer MMC based booting of platforms.

Procedure to populate MMC/SD Card

Use the mk-mmc utility provided in the tools folder of this package to populate the SD Card. This utility helps users create a MMC/SD Card with required Images to boot Android on any given TI platform.

Execute the following command

   #>./mkmmc-android /dev/sdc MLO u-boot.bin uImage boot.scr rootfs.tar.bz2

  This populates the SD/MMC card with all the images.
    To create the boot.scr boot script use the mkbootscr tool found in the Tools 
directory provided in the DevKit.

If you want to use the pre built images in the SDK you have to adjust the above mentioned command to take them into account, as a more direct example the commands below will generate a SD card for an OMAP3 EVM. Ensure you have your SD card connected to the Linux machine you are using and that it is in /dev/sdb for this command otherwise adjust the command accordingly (WARNING: if you get this wrong it can wipe your HDD). Note that this assumes you installed the SDK in your home (~) directory and that the command is run with sudo (or your preferred way of getting super user privelages) to allow for the reformatting of the SD card.

HOST $ cd ~/TI_Android_Eclair_DevKit-V1/Prebuilt_Images/OMAP35x_AM37x_EVM
HOST $ sudo ../../Tools/mk-mmc/ /dev/sdb MLO u-boot.bin uImage boot.scr ../../Filesystem/rootfs_omap35x.tar.bz2

Procedure to add Video, Audio and other media

To play media after booting Android on any platform, the content must be included in the MMC/SD card's FAT32 partition.


  #> sudo mount /dev/sdd1 /mnt
  #> sudo cp <all media files> /mnt
  #> sudo umount /mnt

  - This release supports all the standard Android media formats, listed here

Booting the platform

Booting over MMC using boot.scr


  - If the board has bootargs configured already, then the board will not boot for Android automatically, 
  - It is suggested to either delete the bootargs or use the following commands on u-boot prompt through UART console. 
   #> mmc init
   #> fatload mmc 0 0x82000000 boot.scr
   #> source 0x82000000

If the board is not configured for bootargs, then it automatically boots.

Keypad mappings

The below table lists the keypad and USB Keyboard mappings to Android UI functionality.

USB Keyboard/Mouse
Keypad on EVM
Home Screen
Left Arrow
Right Arrow
Up Arrow
Down Arrow
Volume Up
Volume Up
Volume Down
Volume Down

Mouse right

Using DVI Monitor

On OMAP35x, AM37x and AM35x EVMs the on board LCD is used as output device by default. User is allowed to configure DVI port as output device, by changing the boot arguments as shown below.

Append the boot arguments with following text

   omapfb.mode=dvi:1280x720MR-16 omapdss.def_disp="dvi"
To boot over MMC and use DVI at resolution 1024x768 on OMAP35x EVM, the complete bootargs would be, setenv bootargs init=/init console=ttyS0,115200n8 ip=dhcp rw root=/dev/mmcblk0p2 rw init=/init rootwait mem=256M androidboot.console=ttyS0 omapfb.mode=dvi:1024x768MR-16 omapdss.def_disp="dvi"
- On beagleboard the DVI port is configured as default output device.

Using Network Filesystem

Android filesystem can be mounted over network, the bootargs for doing the same should include below text instead of MMC

   ip=dhcp rw root=/dev/nfs nfsroot=<your NFS server ipaddr>:/home/USER/FILESYSTEM_DIR,nolock noinitrd
   Example: Complete bootargs for OMAP35x board using NFS and LCD output
   setenv bootargs init=/init console=ttyS0,115200n8 ip=dhcp rw root=/dev/nfs nfsroot=,nolock mem=256M noinitrd androidboot.console=ttyS0

Building Android Sources

Android sources (filesystem) can be built by following the instructions documented here

- The "TI-Android-Eclair-DevKit-V1.xml" manifest file should be used to clone/pull the sources of the rootfs provided in this package.

Few Important steps are given below

  • Clone the Sources:
   #> mkdir rowboat-android
   #> cd rowboat-android
   #> repo init -u git:// -m TI-Android-Eclair-DevKit-V1.xml
   #> repo sync
  • Build the root file system for OMAP35x and AM37x
   #> make TARGET_PRODUCT=omap3evm TARGET_BUILD_VARIANT=tests -j8 
TARGET_PRODUCT should be am3517evm for AM35x.
  • Install the SGX (Open GL drivers) libraries and package into filesystem
   Follow the instructions provided here to install SGX (OpenGL) package into the filesystem
  • Prepare the root filesystem
   Follow the steps below to populate the Android filesystem.

   #> sudo ../../../../build/tools/ ../../../host/linux-x86/bin/fs_get_stats android_rootfs . rootfs rootfs.tar.bz2

   The rootfs.tar.bz2 is the android filesystem, it can be put on a SD/MMC Card or used our NFS.

ADB Android Debugger & Downloader

Android Debug Bridge (adb) is a versatile tool lets you manage the state of the Android-powered device. For more information about what is possible with adb, see Android Debug Bridge page at The ADB tool can be used to

  • Download an application from a host machine, install & run it on the target board.
  • Start a remote shell in the target instance.
  • Debug applications running on the device using the debugging tool DDMS ( Dalvik Debug Monitor Server) which runs on top of adb connection.
  • Copy files to and from the board to host machine

Downloading "ADB" & Host setup

The adb tool is a part of Android SDK package located at For an overview of how to install and set up the Android SDK, follow download & setup instructions from Once you install Android SDK, the directory contents look like this.

  SDK Readme.txt

The adb tool is located in tools/ directory under the Android SDK installation. Export the tools directory path as shown below.

  $> export PATH=${PATH}:<your_sdk_dir>/tools

Connecting Host machine & board through adb

This release of DevKit has been tested for three different methods of connecting a given board with host machine

  • adb over USB
  • adb over USB Ethernet
  • adb over Ethernet

The below sections describe each of these methods and provides necessary instructions for the same.

adb over USB

  • Make sure that the mini-usb cable is connected between the host usb port and the target’s USB OTG port
  • Turn on "USB Debugging" on your board. On the board (UI screen)-
    • Go to home screen, press MENU,
    • Select Applications, select Development, then enable USB debugging.
    • Alternatively, you can navigate to Settings->Applications->Development and then enable the "USB debugging" option.
  • Setup host machine to detect the board. On Ubuntu Linux host machines this is done by adding a rules file to configure device vendor ID of on-board OMAP device.
  • For the EVMs and Boards covered here, the vendor ID is "18d1".
    • Log in as root and create this file: /etc/udev/rules.d/51-android.rules
    For Gusty/Hardy, edit the file to read:
    SUBSYSTEM=="usb", SYSFS{idVendor}=="18d1", MODE="0666"
    For Dapper, edit the file to read:
    SUBSYSTEM=="usb_device", SYSFS{idVendor}=="18d1", MODE="0666"
    • Execute the following to change the user mode for the rules file.
    $> chmod a+r /etc/udev/rules.d/51-android.rules
    • Verify the adb connectivity between host and target board
    $> adb devices 
    If device is connected, then output on screen should list the device, example:
       List of devices attached
       20100720    device

adb over USB Ethernet (Ethernet over USB)

  • Make sure that the mini-usb cable is connected between the host usb port and the target's USB OTG port.
  • Configure the Linux kernel to use Ethernet gadget. Enable USB support, configure the Inventra controller, and add USB gadget support.

IMPORTANT NOTE: Inventra configuration must occur in two places as shown in non-highlighted lines of the screen shots below.

    #> make ARCH=arm CROSS_COMPILE=arm-eabi- menuconfig

Device Drivers --- USB Support


Device Drivers --- USB Support --- USB Gadget Support

Android USBGadget ADB.JPG

Device Drivers --- USB Support --- USB Gadget Support --- Enable Gadget Ethernet support

Android USBEthernet ADB.JPG

  • Build the Kernel with the above configuration changes and use the uImage to boot the board. Refer to Kernel compiling instructions above.
  • Establish network connection
    • Assign an IP address to the usb ethernet adapter.

The USB network gadget g_ether is named usb0 (instead of eth0 or other network interface names). The normal set of Ethernet configuration tools should work, such as ifconfig, netstat, and route.

For example, the following commands will assign the network address to the target. Run this on the target:

    $> ifconfig usb0 netmask up

On Host machine, run the following commands to establish the connection to the target:

    $> sudo ifconfig usb0 netmask up
    $> sudo route add dev usb0

The target and the host machine should be connected, run ping command to test the same:

    $ ping -c 3
    PING ( 56(84) bytes of data.
    64 bytes from icmp_seq=1 ttl=64 time=6.08 ms
    64 bytes from icmp_seq=2 ttl=64 time=0.511 ms
    64 bytes from icmp_seq=3 ttl=64 time=0.485 ms
    --- ping statistics ---
    3 packets transmitted, 3 received, 0% packet loss, time 2000ms
    rtt min/avg/max/mdev = 0.485/2.361/6.089/2.636 ms

  • Establish ADB connection

On the host machine execute following commands to establish adb connection

    $ export ADBHOST=<target's ip address>
    $ adb kill-server
    $ adb start-server

Verify the connection by executing

    $ adb devices 

If connected, device name should be listed as a "emulator"

    $ adb devices
    List of devices attached
    emulator-5554    device
    $ adb shell

adb over Ethernet

  • Make sure Ethernet port on board and host machine are connected to the network
  • Check Ethernet configuration for the board
    target #> netcfg                                                                        
       lo       UP       0x00000049                       
       eth0     UP   0x00001043                       
  • If Ethernet was not configured, configure Ethernet of the board using ifconfig/netcfg as shown below.
    target #> netcfg eth0 dhcp
  • Configure the ADB Daemon to use an ethernet connection using setprop as shown below.
    target #> setprop service.adb.tcp.port 5555

  • If network is configured successfully (above steps) then Restart service adbd on the target,
    target #> stop adbd
    target #> start adbd
  • On the host machine use following commands to establish adb connection
    $> export ADBHOST=<target's ip address>
    $> adb kill-server
    $> adb start-server
  • Verify for device connectivity, by executing the following commands
    $> adb devices If connected, you'll see the device name listed as a "emulator"
    $> adb devices
    If connected, find the device name listed as a "emulator"
    List of devices attached
    emulator-5554    device
    $ adb shell 

For more information about adb commands, see Android Debug Bridge page at

adb over USB on Windows Machine

Follow the below instructions to get ADB over USB work on a Windows PC

  • Download latest Android SDK

( and uncompress it in a local folder (i.e. c:\android_sdk).

  • Optionally, you may want to add the location of the SDK's primary tools directory to your system PATH. Right-click on My Computer, and select Properties. Under the Advanced tab, hit the Environment Variables button, and in the dialog that comes up, double-click on Path (under System Variables). Add the full path to the tools\ directory to the path.
  • Download Android USB Driver

( and uncompress it in a local folder (i.e. c:\android_sdk\usb_driver)

  • Edit (or create and then edit if it doesn't already exist) file in


  echo 0x18D1 > "%USERPROFILE%\.android\adb_usb.ini"
  • Edit android_winusb.inf to match EVM/Beagle vendor and product ids:

Under [Google.NTx86] section add:

  %SingleAdbInterface%        = USB_Install, USB\VID_18D1&PID_9018
  %CompositeAdbInterface%     = USB_Install, USB\VID_18D1&PID_9018&MI_01

Note: Be careful to add it under Google.NTx86 and not under Google.NTamd64 unless your machine is AMD 64 bits. If you skip this step you won't be able to later install the driver as windows will reject it.

  • Boot the board as normal and wait until shell prompt is available (micro-B USB cable must be disconnected).
  • Connect micro-B USB cable between board and Windows PC.
  • If it is proceeding as planned, Windows will tell you it found a new hardware asks you to install the driver. Install driver that was downloaded as described in step 3 above:

Answer "No, not this time" to the question about running Windows Update to search for software.

    • Choose "Install the hardware that I manually select from a list (Advanced)" this is the 2nd option, then click "Next"
    • Select "Show All Devices", then click "Next"
    • You are going to see a grayed-out text box with "(Retrieving a list of all devices)", click the "Have Disk..." button
    • Browse" to your driver folder (c:\android_sdk\usb_driver). It will be looking of a .inf file so select "android_winusb.inf" and click "Open" then "OK". It's the only file there so you shouldn't go wrong.
    • Select "Android ADB Interface" then click the "Next" button.
    • A warning will appear, answer "Yes" but read the warning anyway.
    • Click the "Close" when the wizard is completed.
  • Disconnect and reconnect micro-B USB cable from Board(probably reboot it as well).
  • Open command prompt and restart adb server just to make sure it is in a proper state:
  adb kill-server
  adb start-server
  • List the attached devices with "adb devices". It should show your board/device with a random number.
  • Type "adb shell". You should see the "#" indicating it works.

Running Applications

The root File System provided in this DevKit releases contains only standard Android components and applications. User might be interested to download & run android applications (.apk) available in the market. The below procedure gives the steps to be followed to download any .apk file to the board and run it on the platform.

Installing (.apk files) application on Target Platform

  • From the host: You can use adb tool for package installation.
    $> adb install <package>.apk. 

NOTE: Use -s option with the adb tool, to install the package on external storage.

On successful installation adb tool will report SUCCESS on host terminal, and the application would be listed on the android main menu.

Un-installing applications (.apk) using adb

  • To un-install non-default components (that were installed later)
    • Method 1: On the host machine execute the following
    $> adb uninstall <package>.apk
    • Method 2: On target:
    Main menu -> Menu -> Settings -> Applications -> Manage applications -> Find the package 
    Tap on it -> Uninstall -> OK -> OK
    • On successful removal, the application would have been removed from the android main menu. All the short-cuts to the application also removed.
  • To un-install default components, use the following commands from abd on host machine
    $ adb shell
    #rm /system/app/app.apk

On successful removal, the application would have been removed from the android main menu.

Setup ADB for application Debugging

ADB and Eclipse, with ADT( Android Development Tools plug-in) allow users to create and debug Android applications. Follow Developing In Eclipse, with ADT at

Steps to connect Eclipse to the board.

  • Setup the adb connection with the board by following the instructions given above in connecting board ...
    Verify the connectivity by executing 
    $ adb devices
  • Open Eclipse IDE. Eclipse, with ADT plugin enable users to
    • Create an android project.
    • Build and Run the project on a connected board.
    • Debug the project using the Debug perspective.
    • Use DDMS (Dalvik Debug Monitor Server) to monitor the connected board.

For more detailed and complete information on the above follow Developing In Eclipse, with ADT at

  • Open DDMS(Dalvik Debug Monitor Server) perspective. This DDMS perspective can be opened from the eclipse menu via:
    Window -> Open Perspective -> Other -> DDMS; 
    Click on OK
  • DDMS provides port-forwarding services, screen capture on the device, thread and heap information on the device, logcat, process, and radio state information,incoming call and SMS spoofing, location data spoofing, and more.

Copy any files to and from the board

  • Using the adb commands "pull" and "push" user can copy files to and from the board.
  • Unlike the install command, which only copies an .apk file to a specific location, the pull and push commands let you copy arbitrary directories and files to any location on the board.
  • To copy a file or directory (recursively) from the board, use
    adb pull <remote> <local>
  • To copy a file or directory (recursively) to the board, use
    adb push <local> <remote>

In the commands, <local> and <remote> refer to the paths to the file or directory on your development host (local) and on the target instance (remote).

    Here's an example: 
    adb push foo.txt /sdcard/foo.txt

Configuring Android Applications

Browser Configuration

To browse web pages user should configure the Internet connection as given below.

    #> netcfg eth0 dhcp
    #> setprop net.dns1 <your_dns_server_ip>

NOTE: If network is behind a proxy, in this DevKit release, we have NOT found a method to set the proxy server. We tried using "setprop net.eth0.http-proxy hostname:port" and "setprop net.gprs.http-proxy hostname:port", but neither could get us through the proxy. Also, the option of adding an entry of (99,'http_proxy','hostname:port") to the 'system' and 'secure' tables in the /data/data/ database has also been tried, but failed.


This is Release DevKit-V1

Technical Support and Product Updates

For further information or to report any problems, contact "Android" or
For community support join
For IRC #rowboat on