Building Kernel from source

Contents

[hide]

• 1 Install CyanogenMod on the device
• 2 Install development support packages
  • 2.1 Debian based Linux distributions
  • 2.2 Red Hat based Linux distributions
• 3 Setup Repo
• 4 Download ROM Source Code
• 5 Download ARM EABI Toolchain (Optional)
• 6 Download Kernel Source Code
• 7 Configure the Build
• 8 Make the build
• 9 Merge the build
• 10 Compiling wifi kernel module
• 11 Installing kernel modules for debian chroot installation
• 12 Sources

Install CyanogenMod on the device

First, you will need to get a working install on the device: Installing CyanogenMod on the device.

Install development support packages

Install the following packages using your favorite package manager:

Debian based Linux distributions

32bit and 64bit systems:

git-core gnupg sun-java6-jdk flex bison gperf libsdl-dev libesd0-dev libwxgtk2.6-dev build-essential zip curl libncurses5-dev zlib1g-dev

64bit only:

ia32-libs lib32z1-dev lib32ncurses5-dev gcc-multilib g++-multilib

Red Hat based Linux distributions

32bit and 64bit systems:

git gnupg java-1.6.0-openjdk-devel flex bison gperf SDL-devel esound-devel wxGTK-devel zip curl ncurses-devel zlib-devel gcc-c++

64bit only:

glibc-devel.i686 libstdc++.i686 zlib-devel.i686 ncurses-devel.i686

Setup Repo

Make sure you have a ~/bin directory, and setup repo.

mkdir -p ~/bin

curl https://dl-ssl.google.com/dl/googlesource/git-repo/repo > ~/bin/repo

chmod a+x ~/bin/repo

echo $PATH|grep ~/bin>/dev/null||export PATH="${PATH}":~/bin

To validate the repo command is in your path, type 'which repo'.

To add ~/bin to your $PATH edit ~/.bashrc and add:

export PATH = ~/bin:$PATH

Download ROM Source Code

mkdir -p ~/android/system

cd ~/android/system

For CyanogenMod 7 (Gingerbread):

repo init -u git://github.com/CyanogenMod/android.git -b gingerbread

For CyanogenMod 9 (Ice Cream Sandwich):

repo init -u git://github.com/CyanogenMod/android.git -b ics

repo sync -j16

This may take 1.5 hours, more or less, depending on your connection.

Create an environment variable denoting the location of the android toolchain as follows:

export CCOMPILER=${HOME}/android/system/prebuilt/linux-x86/toolchain/arm-eabi-4.4.0/bin/arm-eabi-

Download ARM EABI Toolchain (Optional)

If you're just building the kernel and don't need the whole ROM source try using the Code Sourcery ARM EABI Toolchain.

Download and extract then, create an environment variable denoting the location of the toolchain as follows:

export CCOMPILER=[extraction directory]/bin/arm-eabi-

Download Kernel Source Code

mkdir -p ~/android/kernel

cd ~/android/kernel

git clone git://github.com/CyanogenMod/cm-kernel.git

cd cm-kernel

Configure the Build

Retrieve a working kernel config from the device, and unzip it:

adb pull /proc/config.gz ~/android/kernel/cm-kernel/config.gz

cat config.gz | gunzip > .config

Alternatively, you can pull the .config from the newest boot.img

scripts/extract-ikconfig boot.img > .config

Configure the build. Just enter to accept defaults, or customize as needed:

make ARCH=arm CROSS_COMPILE=$CCOMPILER oldconfig

make ARCH=arm CROSS_COMPILE=$CCOMPILER menuconfig

Make the build

make ARCH=arm CROSS_COMPILE=$CCOMPILER -j`grep 'processor' /proc/cpuinfo | wc -l`

This step may take a while, depending on your computer.

At this point you should have a kernel stored in ~/android/kernel/cm-kernel/arch/arm/boot/zImageand kernel modules, if any were built, in the module sub-directories.

Merge the build

You will need to merge this file with a working cyanogen ramdisk in order to create a boot image suitable for flashing. Follow these instructions here.

If all goes well, you should now be running your own custom CyanogenMod kernel on the device.

Note: If you are building for Nexus One, you should use --base 0x20000000 when running mkbootimg.

An alternate method is to use an existing kernel update zip for your device. Unzip the update, replace the kernel zImage and kernel modules with your new ones, rezip, and flash on your device.

Compiling wifi kernel module

After installing a custom kernel, the wifi module may be unstable or unusable. The solution is to recompile the module, linking it to the new kernel build.

cd ~/android/system/system/wlan/ti/sta_dk_4_0_4_32

KERNEL_DIR=~/android/kernel/cm-kernel CROSS_COMPILE=$CCOMPILER ARCH=arm make -j`grep 'processor' /proc/cpuinfo | wc -l`

A file named wlan.ko will be produced in the current directory. You must install the new module to the device.

adb shell mount -o remount,rw /system

adb shell cp /system/lib/modules/wlan.ko /system/lib/modules/wlan.ko.backup

adb push wlan.ko /system/lib/modules/wlan.ko

Reboot the device. If all goes well, you should be using the newly compiled 'wlan.ko'.

For devices which may be utilizing wifi module from vendors other than TI, you may choose other appropriate drivers.

Installing kernel modules for debian chroot installation

If you have a debian chroot install on the device, you will want to add to it the loadable modules that were built along with the kernel. This is necessary to use things like fuse, cifs, etc.

First tar up and transfer over the modules

cd ~/android/kernel

tar -czf modules.tgz `find . | grep ko$`

adb push modules.tgz /sdcard/

Then, Copy the modules to your debian install (Replace <debian_root> with the root of your debian installation)

adb shell

mkdir <debian_root>/lib/modules/`uname -r`

cd <debian_root/lib/modules/`uname -r`

tar -zxf /sdcard/modules.tgz

Last, Install the modules from debian (must be done as root). Log in to your debian installation using your method of choice, then:

depmod -a

If all goes well, depmod should produce no output. At this point you may load a kernel module from within debian by typing (as root):

modprobe <module_name>

where <module_name> is the name of the kernel module without the .ko extension.

You may remove a module by typing:

modprobe -r <module_name>