eLinux.org - User contributions [en]

Android Device

2011-06-10T21:21:12Z

Jkes: Breakdown how a device is specified and how Android is configured for it. Also add a new device specification to Android.

This is a breakdown of the files build/envsetup.sh, Makefile and the files they use, which describes how a device is specified and how Android is configured for it.

For each file there are some comments and code lines from the make files or scripts, which describe what they are doing and which files they are using. Also the files which can be used as an example are presented and the commands how to search for them.

This text is for developers who want to add a new device or change the configuration of an existing device. This gives some indications which files are involved.

== build/envsetup.sh ==

Some functions are defined by calling

<pre>
. build/envsetup.sh
</pre>
in the top directory.

Some environment variables are set by calling
<pre>
lunch
</pre>
in the top directory.

<pre>
export TARGET_PRODUCT=$product
export TARGET_BUILD_VARIANT=$variant
export TARGET_SIMULATOR=false
export TARGET_BUILD_TYPE=release
</pre>

vendorsetup.sh is searched at this places:
<pre>
vendor/*/vendorsetup.sh
vendor/*/*/vendorsetup.sh
device/*/*/vendorsetup.sh
</pre>

== vendorsetup.sh ==

This file is executed by build/envsetup.sh, and can use anything
defined in envsetup.sh.

In particular, you can add lunch options with the add_lunch_combo
function:

<pre>
add_lunch_combo full_crespo-userdebug
</pre>

The values of the macros TARGET_PRODUCT and TARGET_BUILD_VARIANT are derived from the option name: add_lunch_combo $TARGET_PRODUCT-$TARGET_BUILD_VARIANT 
In the above example the resulting values are TARGET_PRODUCT=full_crespo and TARGET_BUILD_VARIANT=userdebug.

These files can be used as an example:
<pre>
find . -name vendorsetup.sh
</pre>

<pre>
./device/samsung/crespo/vendorsetup.sh
./device/samsung/crespo4g/vendorsetup.sh
./device/htc/passion/vendorsetup.sh
</pre>

== Makefile ==

Build process is started by calling

<pre>
make
</pre>

in the top directory.

The Makefile calls build/core/main.mk

== build/core/main.mk ==

Set up various standard variables based on configuration and host information.
<pre>
include $(BUILD_SYSTEM)/config.mk
</pre>

This allows us to force a clean build - included after the config.make
environment setup is done, but before we generate any dependencies. This
file does the rm -rf inline so the deps which are all done below will
be generated correctly

<pre>
include $(BUILD_SYSTEM)/cleanbuild.mk
</pre>

These are the modifier targets that don't do anything themselves, but
change the behavior of the build.
(must be defined before including definitions.make)

<pre>
INTERNAL_MODIFIER_TARGETS := showcommands checkbuild all
</pre>

Bring in standard build system definitions.
<pre>
include $(BUILD_SYSTEM)/definitions.mk
</pre>

== build/core/config.mk ==

Various mappings to avoid hard-coding paths all over the place

<pre>
include $(BUILD_SYSTEM)/pathmap.mk
</pre>

Try to include buildspec.mk, which will try to set stuff up.
If this file doesn't exist, the environemnt variables will
be used, and if that doesn't work, then the default is an
arm build

<pre>
-include $(TOPDIR)buildspec.mk
</pre>

Define most of the global variables. These are the ones that
are specific to the user's build configuration.

<pre>
include $(BUILD_SYSTEM)/envsetup.mk
</pre>

Search for BoardConfig.mk in 
$(SRC_TARGET_DIR)/board/$(TARGET_DEVICE)/BoardConfig.mk 
device/*/$(TARGET_DEVICE)/BoardConfig.mk 
vendor/*/$(TARGET_DEVICE)/BoardConfig.mk 
and load the file

<pre>
include $(board_config_mk)
</pre>

<pre>
include $(BUILD_SYSTEM)/dumpvar.mk
</pre>

== BoardConfig.mk ==

These files can be used as an example:
<pre>
find . -name BoardConfig.mk
</pre>

<pre>
./device/samsung/crespo/BoardConfig.mk
./device/samsung/crespo4g/BoardConfig.mk
./device/htc/passion/BoardConfig.mk
./build/target/board/generic/BoardConfig.mk
./build/target/board/generic_x86/BoardConfig.mk
./build/target/board/emulator/BoardConfig.mk
./build/target/board/sim/BoardConfig.mk
</pre>

== build/buildspec.mk.default ==

This is a do-nothing template file. To use it, copy it to a file
named "buildspec.mk" in the root directory, and uncomment or change
the variables necessary for your desired configuration. The file
"buildspec.mk" should never be checked in to source control.

Choose a product to build for. Look in the products directory for ones
that work. 
TARGET_PRODUCT

Choose a variant to build. If you don't pick one, the default is eng. 
User is what we ship. 
Userdebug is that, with a few flags turned on
for debugging. 
Eng has lots of extra tools for development. 
TARGET_BUILD_VARIANT

CUSTOM_MODULES 
TARGET_SIMULATOR

Set this to debug or release if you care. Otherwise, it defaults to
release for arm and debug for the simulator. 
TARGET_BUILD_TYPE 

HOST_BUILD_TYPE 
DEBUG_MODULE_ModuleName 
TARGET_TOOLS_PREFIX 
HOST_CUSTOM_DEBUG_CFLAGS 
TARGET_CUSTOM_DEBUG_CFLAGS 
CUSTOM_LOCALES 
OUT_DIR 
ADDITIONAL_BUILD_PROPERTIES 
NO_FALLBACK_FONT 
WEBCORE_INSTRUMENTATION 
ENABLE_SVG 
BUILD_ENV_SEQUENCE_NUMBER

== build/envsetup.mk ==

Set up version information.
<pre>
include $(BUILD_SYSTEM)/version_defaults.mk
</pre>

If you update the build system such that the environment setup
or buildspec.mk need to be updated, increment this number, and
people who haven't re-run those will have to do so before they
can build. Make sure to also update the corresponding value in
buildspec.mk.default and envsetup.sh.

<pre>
CORRECT_BUILD_ENV_SEQUENCE_NUMBER := 10
</pre>

<pre>
include $(BUILD_SYSTEM)/product_config.mk
</pre>

TARGET_PRODUCT: sim full 
TARGET_BUILD_VARIANT: eng user userdebug tests

== build/core/version_defaults.mk ==

Handle various build version information.

Guarantees that the following are defined: 
PLATFORM_VERSION 
PLATFORM_SDK_VERSION 
PLATFORM_VERSION_CODENAME 
DEFAULT_APP_TARGET_SDK 
BUILD_ID 
BUILD_NUMBER

Look for an optional file $(BUILD_SYSTEM)/build_id.mk containing overrides of the defaults 
INTERNAL_BUILD_ID_MAKEFILE
<pre>
include $(BUILD_SYSTEM)/build_id.mk
</pre>

== build/core/build_id.mk ==

BUILD_ID is usually used to specify the branch name 
BUILD_ID

DISPLAY_BUILD_NUMBER

== build/product_config.mk ==

Provide "PRODUCT-<prodname>-<goal>" targets, which lets you build
a particular configuration without needing to set up the environment.

<pre>
TARGET_PRODUCT := $(word 1,$(product_goals))
TARGET_BUILD_VARIANT := $(word 2,$(product_goals))
</pre>

Provide "APP-<appname>" targets, which lets you build
an unbundled app.

Include the product definitions.
We need to do this to translate TARGET_PRODUCT into its
underlying TARGET_DEVICE before we start defining any rules.

PRODUCT_DEVICE is defined in the product file $(TARGET_PRODUCT).mk. 
The product file $(TARGET_PRODUCT).mk is searched in the list of product make files $(PRODUCT_MAKEFILES). 
PRODUCT_MAKEFILES is set in AndroidProducts.mk files.

<pre>
$(call import-products,$(call get-product-makefiles,
$(SRC_TARGET_DIR)/product/AndroidProducts.mk))
</pre>

Convert a short name like "sooner" into the path to the product
file defining that product.

<pre>
INTERNAL_PRODUCT := $(call resolve-short-product-name, $(TARGET_PRODUCT))
</pre>

<pre>
TARGET_DEVICE := $(PRODUCTS.$(INTERNAL_PRODUCT).PRODUCT_DEVICE)
PRODUCT_LOCALES := $(strip $(PRODUCTS.$(INTERNAL_PRODUCT).PRODUCT_LOCALES))
PRODUCT_BRAND
PRODUCT_MODEL
PRODUCT_MANUFACTURER
</pre>

<pre>
PRODUCT_OTA_PUBLIC_KEYS
</pre>

== AndroidProducts.mk ==

This file should set PRODUCT_MAKEFILES to a list of product makefiles
to expose to the build system. LOCAL_DIR will already be set to
the directory containing this file.

This file may not rely on the value of any variable other than
LOCAL_DIR; do not use any conditionals, and do not look up the
value of any variable that isn't set in this file or in a file that
it includes.

File device/samsung/crespo/AndroidProducts.mk
<pre>
PRODUCT_MAKEFILES := \
$(LOCAL_DIR)/full_crespo.mk
</pre>

These files can be used as an example:
<pre>
find . -name AndroidProducts.mk
</pre>

<pre>
./device/sample/products/AndroidProducts.mk
./device/samsung/crespo/AndroidProducts.mk
./device/samsung/crespo4g/AndroidProducts.mk
./device/htc/passion/AndroidProducts.mk
./build/target/product/AndroidProducts.mk
</pre>

The command which returns the list of all AndroidProducts.mk files is defined in build/core/product.mk :
<pre>
define _find-android-products-files
$(shell test -d device && find device -maxdepth 6 -name AndroidProducts.mk) \
$(shell test -d vendor && find vendor -maxdepth 6 -name AndroidProducts.mk) \
$(SRC_TARGET_DIR)/product/AndroidProducts.mk
endef
</pre>

== Product Files ==

Search for the files which can be used as an example:
<pre>
grep -R PRODUCT_DEVICE device build
</pre>

<pre>
device/samsung/crespo/full_crespo.mk:PRODUCT_DEVICE := crespo
device/samsung/crespo4g/full_crespo4g.mk:PRODUCT_DEVICE := crespo4g
device/htc/passion/full_passion.mk:PRODUCT_DEVICE := passion
build/target/product/sdk.mk:PRODUCT_DEVICE := generic
build/target/product/generic.mk:PRODUCT_DEVICE := generic
build/target/product/generic_x86.mk:PRODUCT_DEVICE := generic_x86
build/target/product/core.mk:PRODUCT_DEVICE := generic
build/target/product/full_x86.mk:PRODUCT_DEVICE := generic_x86
build/target/product/full.mk:PRODUCT_DEVICE := generic
build/target/product/sim.mk:PRODUCT_DEVICE := sim
</pre>

PRODUCT_DEVICE is used in these files
<pre>
build/core/product.mk: PRODUCT_DEVICE \
build/core/product_config.mk:TARGET_DEVICE := $(PRODUCTS.$(INTERNAL_PRODUCT).PRODUCT_DEVICE)
</pre>

== Add new device ==

Add the configuration files for the new device mydevice of the company mycompany.

Create AndroidProducts.mk
<pre>
mkdir -p device/mycompany/mydevice
nano device/mycompany/mydevice/AndroidProducts.mk
</pre>

<pre>
PRODUCT_MAKEFILES := \
$(LOCAL_DIR)/full_mydevice.mk
</pre>

Create file full_mydevice.mk 
Example is build/target/product/full.mk
<pre>
nano device/mycompany/mydevice/full_mydevice.mk
</pre>

<pre>
$(call inherit-product, $(SRC_TARGET_DIR)/product/full_base.mk)
$(call inherit-product, $(SRC_TARGET_DIR)/board/generic/device.mk)

# Overrides
PRODUCT_NAME := full_mydevice
PRODUCT_DEVICE := mydevice
PRODUCT_BRAND := Android
PRODUCT_MODEL := Full Android on mydevice
</pre>

Create file vendorsetup.sh
<pre>
nano device/mycompany/mydevice/vendorsetup.sh
</pre>

<pre>
add_lunch_combo full_mydevice-eng
</pre>

Create file BoardConfig.mk

Examples are 
build/target/board/generic/BoardConfig.mk 
device/samsung/crespo/BoardConfig.mk 
device/samsung/crespo/BoardConfigCommon.mk

<pre>
mkdir -p device/mycompany/mydevice
nano device/mycompany/mydevice/BoardConfig.mk
</pre>

<pre>
# config.mk
#
# Product-specific compile-time definitions.
#

# The generic product target doesn't have any hardware-specific pieces.
TARGET_NO_BOOTLOADER := true
TARGET_NO_KERNEL := true
TARGET_CPU_ABI := armeabi
HAVE_HTC_AUDIO_DRIVER := true
BOARD_USES_GENERIC_AUDIO := true

# no hardware camera
USE_CAMERA_STUB := true

# Set /system/bin/sh to mksh, not ash, to test the transition.
TARGET_SHELL := mksh

# CPU
TARGET_ARCH_VARIANT := armv7-a-neon
ARCH_ARM_HAVE_TLS_REGISTER := true
</pre>

Configure Android for mydevice
<pre>
. build/envsetup.sh
</pre>

<pre>
including device/htc/passion/vendorsetup.sh
including device/mycompany/mydevice/vendorsetup.sh
including device/samsung/crespo4g/vendorsetup.sh
including device/samsung/crespo/vendorsetup.sh
</pre>

<pre>
lunch
</pre>

<pre>
You're building on Linux

Lunch menu... pick a combo:
1. full-eng
2. full_x86-eng
3. simulator
4. full_passion-userdebug
5. full_mydevice-eng
6. full_crespo4g-userdebug
7. full_crespo-userdebug

Which would you like? [full-eng] 5

============================================
PLATFORM_VERSION_CODENAME=AOSP
PLATFORM_VERSION=AOSP
TARGET_PRODUCT=full_mydevice
TARGET_BUILD_VARIANT=eng
TARGET_SIMULATOR=false
TARGET_BUILD_TYPE=release
TARGET_BUILD_APPS=
TARGET_ARCH=arm
TARGET_ARCH_VARIANT=armv7-a-neon
HOST_ARCH=x86
HOST_OS=linux
HOST_BUILD_TYPE=release
BUILD_ID=OPENMASTER
============================================
</pre>

Build Android for mydevice
<pre>
make -j4
</pre>

<pre>
Combining NOTICE files: out/target/product/mydevice/obj/NOTICE.html
Target system fs image: out/target/product/mydevice/obj/PACKAGING/systemimage_intermediates/system.img
Install system fs image: out/target/product/mydevice/system.img
Installed file list: out/target/product/mydevice/installed-files.txt
</pre>

[[Category:Android]]

Android Porting

2011-06-10T20:17:14Z

Jkes: /* Porting Tutorials */

This page describes various effort to port Android to new boards and new processors

== Porting Overview ==
This overview of porting steps was seen on the android-porting list: 
See http://www.mail-archive.com/android-porting@googlegroups.com/msg06721.html

This glosses over all the kernel work for a new board, and the android-specific
kernel patches, but has some good discussion about the flash partitioning and file
system bringup process.

<pre>
If the linux kernel is up and running with all drivers in.
(particularly touchscreen and display) it shouldn't be too bad.

IHMO, the easiest way to get you running is to aggregate the initial
ramfs built into the kernel with the Android build, the root Android
root filesystem (system), and the user data section (mounted as /data
I believe) into one root filesystem.

You can then take that root filesystem as one tarball.

Modify the NAND partitioning of the kernel to set aside space for the
whole Android rootfs, and of course rebuild the kernel. (Be sure yaffs
support is in the kernel) Also no need for a ramfs at this point, just
have the kernel look to mtd2 for it's root filesystem, which will be
jffs2

Create yourself a busybox root filesystem too. Make that into a jffs2
image.

So your partitioning would look something similar to this (you'll have
to decide on the sizes of course):
mtd0: bootloader
mtd1: kernel
mtd2: rootfs (jffs2)
mtd3: Android rootfs.

Erase everything on the NAND.
Burn the normal Chumby bootloader to mtd0.
Burn the the new kernel into mtd1.
Burn the jffs2 rootfs image to mtd2.

Boot the device. Hopefully you get yourself to a prompt.

Once you have that prompt mount mtd3 to /mnt/android as a yaffs2
partition.
Untar your Android rootfs into /mnt/android.
Chown and chgrp everything under /mnt/android to "root"
chroot to that mount point "chroot /mnt/android /init"

At this point you should see Android trying to run.

I know that's a bit to chomp on, but it's more of an outline of what
you will need to do. Of course it's assuming you have the ability to
erase the whole nand and put down images amongst other assumptions,
but it should help get your mind around a little bit of the
requirements to get Android running on your device.

Regarding your bootloader question, I'd just stick with the current
one. You'll only need to modify that if/when you go into having
everything compatible with the recovery system. Which is a completely
different discussion.
</pre>

== Porting Tutorials ==
* [http://www.linuxfordevices.com/c/a/Linux-For-Devices-Articles/Porting-Android-to-a-new-device/ Porting Android to a new Device] - excellent and thorough paper on porting Android to the Nokia N810.
** Has a detailed list of kernel changes and annotated diffs.
* http://wiki.kldp.org/wiki.php/AndroidPortingOnRealTarget
* [[Android on OMAP]] - excellent tutorial covering lots of different issues for porting Android to platforms based on the TI OMAP (ARM) processor
* Some cursory notes on a port to a PXA board are at: http://letsgoustc.spaces.live.com/blog/cns!89AD27DFB5E249BA!320.entry
* Adding a new device or changing the configuration of an existing device [[Android Device]]

== Porting Issues ==
* Matt Porter (Mentor Graphics) gave a presentation on difficulties encountered while they were porting Android to MIPS and PPC processors at [http://www.embeddedlinuxconference.com/elc_europe09/index.html ELC Europe 2009]. His talk was called "Mythbusters: Android" and has lots of good information.
** See [[Media:Mythbusters_Android.pdf|Mythbusters_Android.pdf]]

* [http://android.git.kernel.org/?p=platform/dalvik.git;a=blob_plain;f=docs/porting-guide.html;hb=HEAD Dalvik porting guide]

== Porting to New Processors ==
* Mentor Graphics has ported Android to MIPS and PPC
* Power.Org supported the work to port Android to PPC
** Nina Wilner talked about this work, and gave a demo at ELC Europe 2009
** see [[Media:Android_On_Power.pdf|Android_On_Power.pdf]]

[[Category:Android]]

Android Porting

2011-06-10T20:14:10Z

Jkes: /* Porting Tutorials */ device configuration

This page describes various effort to port Android to new boards and new processors

== Porting Overview ==
This overview of porting steps was seen on the android-porting list: 
See http://www.mail-archive.com/android-porting@googlegroups.com/msg06721.html

This glosses over all the kernel work for a new board, and the android-specific
kernel patches, but has some good discussion about the flash partitioning and file
system bringup process.

<pre>
If the linux kernel is up and running with all drivers in.
(particularly touchscreen and display) it shouldn't be too bad.

IHMO, the easiest way to get you running is to aggregate the initial
ramfs built into the kernel with the Android build, the root Android
root filesystem (system), and the user data section (mounted as /data
I believe) into one root filesystem.

You can then take that root filesystem as one tarball.

Modify the NAND partitioning of the kernel to set aside space for the
whole Android rootfs, and of course rebuild the kernel. (Be sure yaffs
support is in the kernel) Also no need for a ramfs at this point, just
have the kernel look to mtd2 for it's root filesystem, which will be
jffs2

Create yourself a busybox root filesystem too. Make that into a jffs2
image.

So your partitioning would look something similar to this (you'll have
to decide on the sizes of course):
mtd0: bootloader
mtd1: kernel
mtd2: rootfs (jffs2)
mtd3: Android rootfs.

Erase everything on the NAND.
Burn the normal Chumby bootloader to mtd0.
Burn the the new kernel into mtd1.
Burn the jffs2 rootfs image to mtd2.

Boot the device. Hopefully you get yourself to a prompt.

Once you have that prompt mount mtd3 to /mnt/android as a yaffs2
partition.
Untar your Android rootfs into /mnt/android.
Chown and chgrp everything under /mnt/android to "root"
chroot to that mount point "chroot /mnt/android /init"

At this point you should see Android trying to run.

I know that's a bit to chomp on, but it's more of an outline of what
you will need to do. Of course it's assuming you have the ability to
erase the whole nand and put down images amongst other assumptions,
but it should help get your mind around a little bit of the
requirements to get Android running on your device.

Regarding your bootloader question, I'd just stick with the current
one. You'll only need to modify that if/when you go into having
everything compatible with the recovery system. Which is a completely
different discussion.
</pre>

== Porting Tutorials ==
* [http://www.linuxfordevices.com/c/a/Linux-For-Devices-Articles/Porting-Android-to-a-new-device/ Porting Android to a new Device] - excellent and thorough paper on porting Android to the Nokia N810.
** Has a detailed list of kernel changes and annotated diffs.
* http://wiki.kldp.org/wiki.php/AndroidPortingOnRealTarget
* [[Android on OMAP]] - excellent tutorial covering lots of different issues for porting Android to platforms based on the TI OMAP (ARM) processor
* Some cursory notes on a port to a PXA board are at: http://letsgoustc.spaces.live.com/blog/cns!89AD27DFB5E249BA!320.entry
* Adding a new device or changing the configuration of an existing device [[/Android Device]]

== Porting Issues ==
* Matt Porter (Mentor Graphics) gave a presentation on difficulties encountered while they were porting Android to MIPS and PPC processors at [http://www.embeddedlinuxconference.com/elc_europe09/index.html ELC Europe 2009]. His talk was called "Mythbusters: Android" and has lots of good information.
** See [[Media:Mythbusters_Android.pdf|Mythbusters_Android.pdf]]

* [http://android.git.kernel.org/?p=platform/dalvik.git;a=blob_plain;f=docs/porting-guide.html;hb=HEAD Dalvik porting guide]

== Porting to New Processors ==
* Mentor Graphics has ported Android to MIPS and PPC
* Power.Org supported the work to port Android to PPC
** Nina Wilner talked about this work, and gave a demo at ELC Europe 2009
** see [[Media:Android_On_Power.pdf|Android_On_Power.pdf]]

[[Category:Android]]

User:Jkes

2011-06-10T12:21:56Z

Jkes: Created page with "Software development for embedded systems: * Ti OMAP4430 * Freescale i.MX35 * Freescale MPC5125 * Freescale MPC5200B"

Software development for embedded systems:
* Ti OMAP4430
* Freescale i.MX35
* Freescale MPC5125
* Freescale MPC5200B