Downloading Android kernel code
If you download Android 2.1 platform you will not get the source code of the kernel. This is due to that there is quite a huge amount of code needed to be downloaded, it takes time to build the kernel and not many application developers are interested in the kernel code. Below is a description of how to download the Android source code and compile it for ARM, using Linux as your OS. Note that porting to hardware is not in the scope of this description.
First go to your home directory and create a directory where you wish to work in, e.g. myAndroid and step into that directory. Note that '$' is not part of a command but illustrates in this document the commands.
$ cd ~
$ mkdir myAndroid
$ cd myAndroid
To clone the common Android kernel and get the kernel code use the command:
$ git clone git://android.git.kernel.org/kernel/common.git android-kernel
The command creates a new folder called 'android-kernel' (you can choose another name if you wish) in your 'myAndroid' folder and downloads the kernel code.
Go to that folder:
$ cd android-kernel
Building the Android kernel code
Android relies on Linux version 2.6. When building the kernel you will do these commands:
$ make menuconfig
The command 'make menuconfig' configures the kernel. This process involves specifying what functionality to put into the kernel. Additionally, decisions have to be made (when possible) whether kernel code should be statically or dynamically linked. Statically linking means that all modules are built and linked into the kernel. Optimized static kernels execute much faster, since there are no shared object lookups and their binary size is smaller.
With dynamic loading you can choose to manually load the modulus to the kernel by using insmod or modprobe tool/command. Loadable kernel modules allow changing code during runtime. Loadable modules are pieces of kernel code which are not linked (included) directly in the kernel. One compiles them separately, and can insert and remove them into the running kernel at almost any time. If you want a module to be dynamically loaded give it the option <M> during 'make config' procedure.
If you want to make an own module you should enable the module support after doing 'make menuconfig'
Loadable module support ---> [*] Enable loadable module support
When building for another processor architecture than the one that your host processor uses you must use a crosscompiler and set the architecture parameter. This will show you how to compile the code for an ARM processor architecture. Before doing 'make menuconfig' set the architecture parameter:
$ export ARCH=arm
Now start the configuration of the kernel:
$ make menuconfig
Picture 1 shows the menu when configuring the kernel.
After having modified the configuration you will at the exit be prompted by a question, whether you wish to save the changes. Choose Yes if you want to do so. You can check the generated .config file by:
$ nano .config
To set the crosscompiler use do the command:
$ export CROSS_COMPILE=arm-unknown-linux-gnueabi-
Note! I am using a compiler that you may not have. If you have downloaded the whole Android 2.1 platform (perhaps you have it in another folder) you could use
In that case the command to set the cross-compiler as the one delivered and precompiled in the Android platform is:
$ export CROSS_COMPILE=~/your_android_platform_folder/prebuilt/linux-x86/toolchain/arm-eabi-4.4.0/bin/arm-eabi-
Make starts the build process and builds the kernel according to the configuration file. To start the build process do:
The image is generated in the folder: arch/arm/boot/zImage
If you wish to search for the zImage use the find command:
$ find -name 'zImage'
When configuring the kernel in the menu (see figure 1) there may be some flags that you cannot remove. However you can still modify the '.config'-file directly if you wish to. You should on the other hand be sure of what you are doing. When building again, i.e. make you will be prompted by a question if you wish to keep that flag. Press 'n' to exclude the module. If this question does not appear it is most likely that the module has not been removed.
When working with building of the kernel, the best approach is to remove modules that are not necessary in your kernel, and when adding new modules add them step by step. This will give you a fair chance to fix errors such as build failures, but also track down crashes when running on target.
When you have build errors and keep removing flags (i.e. modules) it is good to remove the object files and make a new build. Removing the objectfiles and rebuilding the kernel is done accordingly:
$ make clean