This blog post describes how to use vanilla AOSP Jelly Bean 4.3 source to build and run Android on the BeagleBone Black development board. All components are built from source (well, nearly all: the GPU drivers contain some binary blobs).
*Edit:there is an alternative version of this tutorial which uses fastboot to install Android into the internal eMMC flash memory rather than on external micro SD cards: Building Jelly Bean 4.3 AOSP for BeagleBone Black v2.0 - with fastboot*
Some of the components are taken from the excellent Rowboat project (http://arowboat.org). In fact, I have just re-packaged Rowboat to be more compliant with the Android way of life. Amongst other things, that means
My main motivation was to make it more suitable to use in the Android internals training classes I run.
Overall, the steps are
For those of you in a hurry, you can get the pre-built image and write it to a micro SD card of at least 2 GiB. Plug the SD card into your card reader: it will show up as something like /dev/mmcblk0 or /dev/sdc. Make absolutely sure that you know which it is before continuing because hard drives also show up as /dev/sd* and writing this image to your hard drive will make your computer unbootable!. Assuming that the card reader is mmcblk0, write the image using a command like this:
$ sudo sh -c "unzip -p BBB-aosp-4.3_r2-sd-img.zip | dd of=/dev/mmcblk0 bs=4M"
Then skip to the section Boot it!
For everyone else, make sure that you have a system capable to building AOSP in a reasonable amount of time as described here http://source.android.com/source/building.html. Then follow these steps to set it up http://source.android.com/source/initializing.html. For reference, I tested on two machines: one a laptop with dual core i7 and 4 GiB RAM running Ubuntu 12.04 64 bit (AOSP build takes more than 2 hours), and the other an octo core AMD FX-8150 with 16 GiB RAM running Ubuntu 10.04 64 bit (takes 35 minutes).
You will need in addition the U-Boot mkimage tool:
Ubuntu 10.04: sudo apt-get install uboot-mkimage
Ubuntu 12.04: sudo apt-get install u-boot-tools
Note: in the following I am installing and building everything in the home directory (“~”). You may use whichever directory you wish but you will have to modify the paths used below accordingly.
Begin by getting the repo tool and using it to download the AOSP:
$ curl http://commondatastorage.googleapis.com/git-repo-downloads/repo > ~/bin/repo $ chmod a+x ~/bin/repo $ mkdir ~/aosp-4.3_r2.1 $ cd aosp-4.3_r2.1 $ repo init -u https://android.googlesource.com/platform/manifest -b android-4.3_r2.1 $ repo sync
This takes several hours because there is 17 GiB to download. When complete you will have all the Android source in ~/aosp-4.3_r2.1.
Get my device files for the BeagleBone Black into device/ti/beagleboneblack
$ cd ~/aosp-4.3_r2.1/device/ti $ git clone https://github.com/csimmonds/bbb-android-device-files.git beagleboneblack $ cd ~/aosp-4.3_r2.1 $ . build/envsetup.sh $ lunch beagleboneblack-eng
The kernel comes from the Rowboat project. It is version 3.2, without device tree support, but it works well enough for me.
$ cd ~/aosp-4.3_r2.1 $ git clone git://gitorious.org/rowboat/kernel.git $ cd kernel $ git checkout rowboat-am335x-kernel-3.2
You can use the Android ARM cross compiler, arm-eabi-gcc, to build. Assuming that you have already sourced build/envsetup.sh and run lunch then you can:
$ cd ~/aosp-4.3_r2.1/kernel $ make ARCH=arm CROSS_COMPILE=arm-eabi- am335x_evm_android_defconfig $ make ARCH=arm CROSS_COMPILE=arm-eabi- -j4 uImage $ croot $ cp kernel/arch/arm/boot/zImage device/ti/beagleboneblack/kernel
Now you are ready to run the first AOSP build. Note: the -j option to "make" determines the number of parallel jobs to run. My rule of thumb is to use the number of CPU cores plus 2
$ cd ~/aosp-4.3_r2.1 $ make -j10
This takes an hour or so. When complete you will find the compiled Android system in ~/aosp-4.3_r2.1/out/target/product/beagleboneblack/
U-Boot also comes from Rowboat:
$ cd ~/aosp-4.3_r2.1 $ git clone git://gitorious.org/rowboat/u-boot $ cd u-boot $ git checkout am335x-v2013.01.01
Building is similar to the kernel, using the Android ARM cross compiler:
$ make CROSS_COMPILE=arm-eabi- distclean $ make CROSS_COMPILE=arm-eabi- am335x_evm_config $ make CROSS_COMPILE=arm-eabi-
This will create the first stage boot loader, MLO, and the second stage bootloader, u-boot.bin.
Once again I am getting these from Rowboat. This is messy because they are not very well integrated with the AOSP code. One issue is that the makefile has some paths hard coded which is why it has to be put into hardware/ti/sgx, and also why the kernel has to be in directory kernel/.
$ cd ~/aosp-4.3_r2.1/hardware/ti $ git clone git://git.gitorious.org/rowboat/hardware-ti-sgx.git sgx $ cd sgx $ git checkout ti_sgx_sdk-ddk_1.10-jb-4.3
With Rowboat, the binaries are copied into out/target/product/beagleboneblack/system after the AOSP build is complete and then post-processed into the install tar ball. I want to have them built as part of the AOSP build, so I edit one of the makefiles to put the binaries into my device directory. Then they get sucked into the final images by the rules in my device.mk. So, edit Rules.make: line 23 and change
This next bit has to be run in a completely new shell. I'm sorry, but for some reason it won't build in a shell that has been set up for an AOSP build (i.e. has ". build/emvsetup.sh").
Note: W=1 is needed to avoid turning warnings into errors...
$ cd ~/aosp-4.3_r2.1/hardware/ti/sgx $ PATH=$HOME/aosp-4.3_r2.1/prebuilts/gcc/linux-x86/arm/arm-eabi-4.6/bin:$PATH $ make TARGET_PRODUCT=beagleboneblack OMAPES=4.x ANDROID_ROOT_DIR=$HOME/aosp-4.3_r2.1 W=1 $ make TARGET_PRODUCT=beagleboneblack OMAPES=4.x ANDROID_ROOT_DIR=$HOME/aosp-4.3_r2.1 W=1 install
That will result in populating device/ti/beagleboneblack/sgx
The droid VNC server is useful if you want to test Android on your BeagleBone but don't have a screen:
$ cd ~/aosp-4.3_r2.1/external $ git clone git://gitorious.org/rowboat/droid-vnc-server
Now you need to regenerate the Android image files to include the sgx binaries. This should only take a few minutes.
$ cd ~/aosp-4.3_r2.1 $ . build/envsetup.sh $ lunch beagleboneblack-eng $ make installclean $ make -j10
If something goes wrong, go back through the steps and try to identify the problem. For reference here is a copy of the image files I created.
You need a micro SD card of at least 2 GiB capacity. Insert your SD card into your SD card reader. It will appear as either /dev/sd? Or as /dev/mmcblk? Use fdisk or similar to create partitions like this:
Partition type bootable? Size (MB) ID and file system 1 primary * 64 c W95 FAT32 (LBA) 2 primary 32 83 Linux 3 primary 32 83 Linux 4 extended 1718955 5 logical 270 83 Linux 6 logical 270 83 Linux 7 logical 270 83 Linux
I am going to leave the details up to you: that way you can't blame me if it goes wrong, but as mentioned at the start, please do be aware that accidentally formatting the wrong device, for example your hard drive, is a distinct possibility. It has happened to me. So, please, double check everything.
Then format the first partition, the boot partition, giving the correct device node:
$ sudo mkfs -t vfat -n "boot" /dev/mmcblk0
Of course, you only need to do these steps once, to initialise the SD card
1. The boot partition
Create the ramdisk:
$ cd ~/aosp-4.3_r2.1 $ mkimage -A arm -O linux -T ramdisk -d out/target/product/beagleboneblack/ramdisk.img uRamdisk
Mount the first partition and copy these files to it
2. System, userdata and cache
The remaining image files are already in ext4 format so they can be copied directly to partitions 5, 6 and 7. For example if the SD card is /dev/mmcblk0 then
$ cd ~/aosp-4.3_r2.1/out/target/product/beagleboneblack $ sudo dd if=system.img of=/dev/mmcblk0p5 bs=4M $ sudo dd if=userdata.img of=/dev/mmcblk0p6 bs=4M $ sudo dd if=cache.img of=/dev/mmcblk0p7 bs=4M
Now put the SD card in your BeagleBone. Depending on what is in your on-board eMMC flash, you may need to hold down the boot button while powering on to get it to load U-Boot from the SD card. All being well, you should see the "Android" boot animation after about 30 seconds and the launcher screen after 90 to 120 seconds. The second time the boot should be faster, I find it to be about 30 seconds.
You have three options
There is a 720p output (1280 x 720) on the HDMI port. Plug this into a suitable display, plug a mouse in to the USB and you have a usable system. This is your best bet.
I have tried it with the LCD7 cape (800 x 480). The display is fine but the resistive touch screen is a dead loss. OK for demos.
If all else fails...
Run "androidvncserver" on the Beagleboard. Now you can connect to it either over USB or Ethernet. For USB you need to use adb to forward the VNC port and run a VNC client such as vinagre like so:
$ adb forward tcp:5901 tcp:5901 $ vinagre localhost:5901
To use Ethernet, you need to know what the IP address of the Beagleboard:
# netcfg lo UP 127.0.0.1/8 0x00000049 00:00:00:00:00:00 sit0 DOWN 0.0.0.0/0 0x00000080 00:00:00:00:00:00 eth0 UP 192.168.1.19/24 0x00001043 90:59:af:5d:85:78
Then on the PC
$ vinagre 192.168.1.19:5901
There is an irritating quirk you should know about: any keys you press in vinagre will not be transmitted to the device until you click the left mouse button.
After this fairly lengthy set of instructions you should have JB 4.3 running on your BeagleBone, and more importantly you will have experienced the stages of putting together an AOSP build. There are a few things that would make it easier including better packaged SGX drivers and fully working fastboot support in U-Boot. One of these days I will look at both. But my next challenge is to get KitKat up and running...