[Desire Android Development] Droidzone:
I havent yet found a simple guide for compiling kernels. Some of them assume too much, and some are just outdated. So I thought I'd write my own for devs/budding devs. Here you go!

Note:

This is not a guide for newbies. It's a dev guide for devs.

Research before asking questions, please

For The Menu driven interactive kernel build script, see Post #31

I will be developing this guide as I go, so it will be incomplete initially, or lacking in detailed explanations.

Essentials:

Ubuntu Box (By this I mean a PC with a Ubuntu installation, not a live CD)

A toolchain-Either the Android NDK, or your own toolchain

HTC Desire GB/Froyo source from htcdevs.com, or sources from github

Familiarity with the linux shell and basic linux commands.

The will to learn ;)

First things first,

1. Getting the sources

The HTC Desire source is available from two kinds of resources-you can either get it from htcdevs.com (official HTC Dev site), or from source code uploaded from someone else. For the purpose of this tutorial, I'll assume we're working on the official HTC GB source code. So download bravo_2.6.35_gb-mr.tar.gz from htcdevs.com.

2. Setting up the compilation box and preparing source code

2.1 Install some essential linux packages from the Linux terminal:

sudo apt-get install libncurses5-dev

2.2 Extract the source code

The file you downloaded is a tar archive (like a zip file), so you need to extract it to a convenient location. Let's hit the linux shell-open a terminal window in linux (Accessories->Terminal)

Type:

Let's go to our home directory:

cd ~/

Now, create the directories for our kernel compilation box.

mkdir -p ~/android/kernel

Now you need to copy the tar.gz file from wherever you downloaded it to, to this dir.

Extract the archive:

tar -xvf ~/android/kernel/bravo_2.6.35_gb-mr.tar.gz

cd ~/android/kernel/bravo_2.6.35_gb-mr

Now we can view the extracted files within the directory ~/android/kernel/bravo_2.6.35_gb-mr/

2.3 Set up the toolchain

A toolchain is a set of programs which allow you to compile source code (any source code, not just kernels). The toolchain is specific for the processor and hardware, so we need a toolchain specific for Android and especially the Desire. If you're a semiadvanced-pro user, you may consider compiling your own toolchain (See theGanymedes' guide for doing so). If compilation of kernels is all that you require, fortunately for you, there is an easy way-the Android NDK - v7 (latest as of now) is available here

Get the NDK for Linux - android-ndk-r7-linux-x86.tar.bz2

mkdir -p ~/android/ndk

Now copy the NDK file to ~/android/ndk

Whenever I say copy, you have to manually copy the file with any file manager. Nautilus comes with Ubuntu, and Dolphin with Kubuntu. You may also use the shell of course with

cp [sourcefile] [destination]

Extract it:

tar -jvxf android-ndk-r7-linux-x86.tar.bz2

Now add the path for your toolchain to the env variable:

gedit ~/.bashrc

At the end of the file, add this line:

PATH=$PATH:~/android/ndk/android-ndk-r7-linux-x86/toolchains/arm-linux-androideabi-4.4.3/prebuilt/linux-x86/bin

3. Setting up kernel parameters

Kernels are compiled with a program called gnu make, and use a set of configuration options specified within a file called Makefile.

A vital point to note is that kernels are compiled with a program called gcc (basically the gnu C compiler), and our NDK itself has its own optimized version of gcc. While compiling, we're actually cross compiling it (meaning compiling a binary package on a system which is different from the actual system which is meant to run it- you're compiling it on your PC while it's actually meant to run on your Desire)

This means that when you compile it, you have to make sure that you compile it with the NDK's version of gcc instead of the system version. Otherwise you end up with a kernel meant to run on your pc, duh! Specifying which gcc to use is by the CROSS_COMPILE variable. You can set it up with this command:

CROSS_COMPILE=arm-linux-androideabi-

Note the hyphen (-) at the end, and do not forget to include it! At compilation time, system will actually use this variable to find all the programs it needs. Eg: The path for gcc will become arm-linux-androideabi-gcc

We can compile kernels with many different options, like with ext4 support, or without; ext4 support as part of the kernel zImage (in which case it makes the kernel larger), or as a loadable module (of the form somename.ko, which is loaded at init.d/init.rc with the command insmod modulename.ko)

We specify the exact options we require with the help of a useful configuration program called menuconfig (which as the name suggests, is a menu for configuration of make options).

An important thing to note is that as far as kernel compilation is concerned, there are a vast amount of options to setup, and unless you're thorough with kernel compilation, you wont be able to set up the options correctly and get your kernel to boot. Fortunately for us, the kernel source already comes with a default set of parameters which can be easily set up.

Note that all make commands must be executed within the directory bravo_2.6.35_gb-mr. Let's go there now:

cd ~/android/kernel/bravo_2.6.35_gb-mr
make ARCH=arm CROSS_COMPILE=arm-linux-androideabi- bravo_defconfig

This produces a .config file (used by the menuconfig) containing essential parameters to produce a booting kernel for the Desire.

Note: There is a simpler way to get the basic .config file, and this is to get it from a running kernel built by someone else. You can extract the .config from a running kernel with these commands:

cd ~/android/kernel/bravo_2.6.35_gb-mr
adb pull /proc/config.gz
zcat config.gz > .config

Now we can open menuconfig and add anything we need in addition.

make ARCH=arm CROSS_COMPILE=arm-linux-androideabi- menuconfig

You can view the huge amount of options available in menuconfig.

You can add ext4 support for example (See image above)

Once you're done choosing options, you can exit menuconfig.

4. Compiling it

This is simple. The basic command is:

make ARCH=arm CROSS_COMPILE=arm-linux-androideabi- -j10

The -j10 specifies the number of jobs to execute per operation. I can usually go upto 50 on my Quad core CPU. Beware, this can bring a slow CPU to a crawl and freeze up linux itself.

During compilation, you will see all sorts of messages, which may include warnings too. In most cases, its safe to ignore warnings. If there are errors, the compilation will stop, and you will have to fix the issues.

5. Distributing your kernel to users

At the end of compilation, it generates files named zImage, and various .ko files.

You have to copy them from their default location to a zip file. The best way is to use my variant of koush's Anykernel, and copy the files to it. Then, you can zip the whole folder and lo and behold-you have your flashable kernel zip which you can distribute to others.

You can also remove the zImage and the modules from /system/lib/modules of any kernel zip available with you, and copy over your files to it, at the correct location.

So, let's say that you have extracted an existing kernel zip to the location ~/flashable

The file structure should be like this:

|-- kernel
| |-- dump_image
| |-- mkbootimg
| |-- mkbootimg.sh
| |-- unpackbootimg
| `-- zImage
|-- META-INF
| |-- CERT.RSA
| |-- CERT.SF
| |-- com
| | `-- google
| | `-- android
| | |-- update-binary
| | `-- updater-script
| `-- MANIFEST.MF
`-- system
`-- lib
`-- modules
`-- bcm4329.ko

8 directories, 11 files

I've included my flashable zip directory along with this post. Download file kernel_flashable.tar.bz2.zip to ~/

cd ~/
tar -jvxf kernel_flashable.tar.bz2.zip

This will create the directory structure outlined above.

Now after every compilation of the kernel, execute these commands from where you executed make:

cp arch/arm/boot/zImage ~/kernel_flashable
find . -name '*ko' -exec cp '{}' ~/kernel_flashable/system/lib/modules/ \;
cd ~/kernel_flashable
zip -r mykernel ./

This will create mykernel.zip at ~/kernel_flashable. You can distribute this to your users to flash. Make sure you edit updater-script before though :)