Jelly Bean on Beagleboard xM

Prerequisites

Ubuntu 12.04 LTS – AMD64

A 64-bit OS is needed in order to build Android 4.x from source code

Dual- or Quad-core (recommended) CPU
At least 4GB of RAM
45GB of free disk space
Internet connection

Installing utils and libs

From a Terminal console execute
sudo aptitude install ia32-libs
sudo apt-get install git-core gnupg flex bison gperf build-essential zip curl libc6-dev libncurses5-dev:i386 x11proto-core-dev libx11-dev:i386 libreadline6-dev:i386 libgl1-mesa-glx:i386 libgl1-mesa-dev g++-multilib mingw32 openjdk-6-jdk tofrodos python-markdown libxml2-utils xsltproc zlib1g-dev:i386
and then
sudo ln -s /usr/lib/i386-linux-gnu/mesa/libGL.so.1 /usr/lib/i386-linux-gnu/libGL.so

Installing Oracle Java JDK

Download Oracle Java6 JDK from here (file: jdk-6u34-linux-x86.bin) to ~/Downloads
In a Terminal cnosole execute

cd ~/Downloads
cp jdk-6u43-linux-x64.bin ~/
cd ~/
chmod +x jdk-6u43-linux-x64.bin
./jdk-6u43-linux-x64.bin
sudo mv jdk1.6.0_43/ /usr/lib/jvm/

Add Oracle Java6 JDK to Ubuntu JVM list

sudo update-alternatives –install /usr/bin/javac javac /usr/lib/jvm/jdk1.6.0_43/bin/javac 1
sudo update-alternatives –install /usr/bin/java java /usr/lib/jvm/jdk1.6.0_43/bin/java 1
sudo update-alternatives –install /usr/bin/javaws javaws /usr/lib/jvm/jdk1.6.0_43/bin/javaws 1

Select Oracle Java6 JDK as default JVM

sudo update-alternatives –config javac
sudo update-alternatives –config java
sudo update-alternatives –config javaws

In this three last commands, select Oracle Java6 JDK as default, like in the example below
kimi@X-Server:~$ sudo update-alternatives --config java There are 2 choices for the alternative java (providing /usr/bin/java).
Selection Path Priority Status
————————————————————
0 /usr/lib/jvm/java-6-openjdk-amd64/jre/bin/java 1061 auto mode
1 /usr/lib/jvm/java-6-openjdk-amd64/jre/bin/java 1061 manual mode
* 2 /usr/lib/jvm/jdk1.6.0_34/bin/java 1 manual mode
Press enter to keep the current choice[*], or type selection number: 2

Installing REPO

Repo is a tool created by Google in order to admin git repositories easyly.
In a Terminal console execute

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

Initialize the repository

mkdir ~/rowboat-android
cd ~/rowboat-android
repo init -u git://gitorious.org/rowboat/manifest.git -m rowboat-jb-am37x.xml (JB for Beagleboard)
repo sync

If a warning telling you that there is a new REPO version appears. Stop the sync process and update

cp ~/rowboat-android/.repo/repo/repo ~/bin/repo
chmod a+x ~/bin/repo
repo sync

Once the repo is successfully synced, you will see a message like this:
* [new branch] rowboat-froyo -> rowboat/rowboat-froyo * [new branch] rowboat-gingerbread -> rowboat/rowboat-gingerbread * [new branch] rowboat-ics -> rowboat/rowboat-ics * [new branch] rowboat-jb -> rowboat/rowboat-jb * [new branch] ti-dsp -> rowboat/ti-dsp Fetching projects: 100% (261/261), done. Checking out files: 100% (8843/8843), done.out files: 10% (949/8843) Checking out files: 100% (24601/24601), done.ut files: 50% (12308/24601) Checking out files: 100% (18021/18021), done.ut files: 3% (616/18021) Checking out files: 100% (35638/35638), done.ut files: 1% (663/35638) Checking out files: 100% (2088/2088), done. out files: 6% (134/2088) Checking out files: 100% (974/974), done.ng out files: 34% (336/974) Checking out files: 100% (667/667), done.ng out files: 18% (123/667) Checking out files: 100% (2412/2412), done. out files: 4% (106/2412) Checking out files: 100% (26958/26958), done.ut files: 24% (6516/26958) Checking out files: 100% (81/81), done. Checking out files: 100% (441/441), done.ng out files: 43% (194/441) Checking out files: 100% (6505/6505), done. out files: 1% (108/6505) Syncing work tree: 100% (261/261), done.
kimi@X-Server:~/rowboat-android$

Cross compiling Jelly Bean for Beagleboard

Now we are going to modify the PATH variable in order to include the binary directory of the GCC compiler. The following command should be executed every time you open a new Terminal console and want to compile the code. Unless, you include the new PATH into your ‘.bashrc’ or ‘.bash_profile’ file.
export PATH=~/rowboat-android/prebuilts/gcc/linux-x86/arm/arm-eabi-4.6/bin:$PATH

X-loader

X-loader is a small first stage boot loader derived from the u-boot base code to be loaded into the internal static ram by the OMAP ROM code. Because the internal static ram is very small (64k-32k), x-loader is stripped down to the essentials and is used to initialize memory and enough of the peripheral devices to access and load the second stage loader (U-boot) into main memory.
In order to build X-loader we will follow these steps
cd ~/rowboat-android/x-loader/ make CROSS_COMPILE=arm-eabi- distclean make CROSS_COMPILE=arm-eabi- omap3beagle_config make CROSS_COMPILE=arm-eabi- -j4
the parameter ‘-j4’ will tell the make to use up to 4 threads to build the code. If you have a dual-core/two-threads CPU, use ‘-j2’. Omitting this parameter will also compile the code, but using just a single thread (which for x-loader or u-boot is not a big problem, but the Android source code can take many hours).
The result of this process is a file named ‘x-load.bin’ on the current directory. This file should be signed with a tool called ‘signGP’ before x-loader gets into the MMC card.

Downloading Rowboat-tools for Jelly Bean

cd ~ curl http://rowboat.googlecode.com/files/RowboatTools.tar.gz > RowboatTools.tar.gz tar -zxvf RowboatTools.tar.gz

Signing x-load.bin

cp ~/RowboatTools/signGP/signGP ~/rowboat-android/x-loader/signGP cd ~/rowboat-android/x-loader ./signGP x-load.bin cp x-load.bin.ift MLO
Now we have a ‘MLO’ file which is a signed version of the binary x-loader, and this file can be used in the board.

Uboot

Uboot is a universal bootloader program that developed for the loading and starting of embedded Linux systems. Uboot essentially can load a (linux) kernel from one of several locations, and start it with corresponding arguments.
cd ~/rowboat-android/u-boot/ make CROSS_COMPILE=arm-eabi- distclean make CROSS_COMPILE=arm-eabi- omap3_beagle_config make CROSS_COMPILE=arm-eabi- -j4
The result of this process is ‘u-boot.bin’ file. And a successful build generates an output like this:
api/libapi.a post/libpost.a board/ti/beagle/libbeagle.a --end-group /home/kimi/rowboat-android/u-boot/arch/arm/lib/eabi_compat.o -L /home/kimi/rowboat-android/prebuilts/gcc/linux-x86/arm/arm-eabi-4.6/bin/../lib/gcc/arm-eabi/4.6.x-google -lgcc -Map u-boot.map -o u-boot arm-eabi-objcopy -O srec u-boot u-boot.srec arm-eabi-objcopy --gap-fill=0xff -O binary u-boot u-boot.bin kimi@X-Server:~/rowboat-android/u-boot$

Building Android, Kernel and SGX

In order to build Android, its kernel and SGX (which provides the Hardware Acceleration needed by Android 3.x+)
cd ~/rowboat-android make TARGET_PRODUCT=beagleboard OMAPES=5.x -j4
(This step takes aprox. 1 hour)
If this commad successed you will see something like this on the console
Installation complete!
cat install.sh >install
chmod a+x install
make[1]: Leaving directory `/home/kimi/rowboat-android/hardware/ti/sgx’
If you don’t see an output like this, try running the command without “-j4”.
If everything is Ok, then it’s time to create the root filesystem and compress it into a tar.gz file. (20 minutes. aprox)
cd ~/rowboat-android make TARGET_PRODUCT=beagleboard fs_tarball -j4

Building Kernel and Android separately

It is possible to build the kernel and Android separately, and this is recommended once you have done a full build and you have modified only a small part of the code.

Builing the Kernel

cd ~/rowboat-android/kernel make ARCH=arm CROSS_COMPILE=arm-eabi- distclean make ARCH=arm CROSS_COMPILE=arm-eabi- omap3_beagle_android_defconfig make ARCH=arm CROSS_COMPILE=arm-eabi- uImage -j4
This will generate ‘uImage’ (kernel image) in “~/rowboat-android/kernel/arch/arm/boot”

Builing Android

cd ~/rowboat-android make TARGET_PRODUCT=beagleboard droid -j4
Again, in order to create the root filesystem, run
cd ~/rowboat-android make TARGET_PRODUCT=beagleboard fs_tarball

Creating a bootable SD-Card

Once x-load, Uboot, kernel and Android are built, it’s time to create a bootable SD-Card with all this files.

Boot arguments

Edit boot arguments for am37x.
cd ~/RowboatTools/am37x/mk-bootscr gedit boot.scr
Change mem=256M with mem=448M. This will increase the amount of RAM available in Android for applications.
Generate boot script
./mkbootscr

Putting all together

Format the SD Card into a single FAT32 partition. A +4GB SD Card is recommended, while the minimum amount of memory is 2GB.
mkdir ~/rowboat-image cp ~/rowboat-android/kernel/arch/arm/boot/uImage ~/rowboat-image cp ~/rowboat-android/u-boot/u-boot.bin ~/rowboat-image cp ~/rowboat-android/x-loader/MLO ~/rowboat-image cp ~/RowboatTools/am37x/mk-bootscr/boot.scr ~/rowboat-image cp ~/rowboat-android/out/target/product/beagleboard/rootfs.tar.bz2 ~/rowboat-image cp ~/RowboatTools/am37x/mk-mmc/mkmmc-android.sh ~/rowboat-image
Execute the script
cd ~/rowboat-image sudo ./mkmmc-android.sh /dev/sdb MLO u-boot.bin uImage boot.scr rootfs.tar.bz2
Change /dev/sdb with the path for your SD Card
If you don’t see anything executed on the console, may be mkmmc-android.sh has a hidden char that generates problem. Try opening the file with gEdit and copying the content to another file, for example mkmmc.sh. Then make that file executable and try again.

Ready!

Now you are ready to extract the SD Card, insert it into the Beagleboard and run Android. Be patience, the first start up can take several minutes. The second time you start up Android it takes minutes more or less.

Performance

Some SD Cards show a very poor performance. Most Kingston micro SDHC cards have this performance issue. San Disk micro SDHC or Sony micro SDHC are recommended.

Known issues

mmc0: error -110 whilst initializing SD card

Your are using a SDHC Card affected by preemption model in Kernel 2.6. Look to this post about loading “rootfs” from USB . This avoids the bug, and gives more performance & storage space.