ROM Android: Compile Kernel untuk ROM Android
Building Kernels In this document
Figuring out which kernel to build Identifying kernel version Downloading sources Downloading a prebuilt gcc Building
Jika anda hanya tertarik pada kernel, anda dapat menggunakan panduan ini untuk membuat kernel.
The following instructions assume that you have not downloaded all of AOSP. If you have downloaded all of AOSP, you may skip the git clone steps other than the step to download the actual kernel sources.
We will use the Pandaboard kernel in all the following examples. Figuring out which kernel to build
This table lists the name and locations of the kernel sources and binaries: Device Binary location Source location Build configuration
hammerhead device/lge/hammerhead-kernel kernel/msm hammerhead_defconfig flo device/asus/flo-kernel/kernel kernel/msm flo_defconfig deb device/asus/flo-kernel/kernel kernel/msm flo_defconfig manta device/samsung/manta/kernel kernel/exynos manta_defconfig mako device/lge/mako-kernel/kernel kernel/msm mako_defconfig grouper device/asus/grouper/kernel kernel/tegra tegra3_android_defconfig tilapia device/asus/grouper/kernel kernel/tegra tegra3_android_defconfig maguro device/samsung/tuna/kernel kernel/omap tuna_defconfig toro device/samsung/tuna/kernel kernel/omap tuna_defconfig panda device/ti/panda/kernel kernel/omap panda_defconfig stingray device/moto/wingray/kernel kernel/tegra stingray_defconfig wingray device/moto/wingray/kernel kernel/tegra stingray_defconfig crespo device/samsung/crespo/kernel kernel/samsung herring_defconfig crespo4g device/samsung/crespo/kernel kernel/samsung herring_defconfig
You will want to look at the git log for the kernel binary in the device project that you are interested in.
Device projects are of the form device/<vendor>/<name>.
$ git clone https://android.googlesource.com/device/ti/panda $ cd panda $ git log --max-count=1 kernel
The commit message for the kernel binary contains a partial git log of the kernel sources that were used to build the binary in question. The first entry in the log is the most recent, i.e. the one used to build that kernel. You will need it at a later step. Identifying kernel version
To determine the kernel version used in a particular system image, run the following command against the kernel file:
$ dd if=kernel bs=1 skip=$(LC_ALL=C grep -a -b -o $'\x1f\x8b\x08\x00\x00\x00\x00\x00' kernel | cut -d ':' -f 1) | zgrep -a 'Linux version'
For Nexus 5 (hammerhead), this can be accomplished with:
$ bzgrep -a 'Linux version' vmlinux.bz2
Downloading sources
Depending on which kernel you want,
$ git clone https://android.googlesource.com/kernel/common.git $ git clone https://android.googlesource.com/kernel/exynos.git $ git clone https://android.googlesource.com/kernel/goldfish.git $ git clone https://android.googlesource.com/kernel/msm.git $ git clone https://android.googlesource.com/kernel/omap.git $ git clone https://android.googlesource.com/kernel/samsung.git $ git clone https://android.googlesource.com/kernel/tegra.git
The goldfish project contains the kernel sources for the emulated platforms. The msm project has the sources for ADP1, ADP2, Nexus One, Nexus 4, and can be used as a starting point for work on Qualcomm MSM chipsets. The omap project is used for PandaBoard and Galaxy Nexus, and can be used as a starting point for work on TI OMAP chipsets. The samsung project is used for Nexus S, and can be used as a starting point for work on Samsung Hummingbird chipsets. The tegra project is for Xoom and Nexus 7, and can be used as a starting point for work on NVIDIA Tegra chipsets. The exynos project has the kernel sources for Nexus 10, and can be used as a starting point for work on Samsung Exynos chipsets.
Downloading a prebuilt gcc
Ensure that the prebuilt toolchain is in your path.
$ export PATH=$(pwd)/prebuilts/gcc/linux-x86/arm/arm-eabi-4.6/bin:$PATH
or
$ export PATH=$(pwd)/prebuilts/gcc/darwin-x86/arm/arm-eabi-4.6/bin:$PATH
On a linux host, if you don't have an Android source tree, you can download the prebuilt toolchain from:
$ git clone https://android.googlesource.com/platform/prebuilts/gcc/linux-x86/arm/arm-eabi-4.6
Building
As an example, we would build the panda kernel using the following commands:
$ export ARCH=arm $ export SUBARCH=arm $ export CROSS_COMPILE=arm-eabi- $ cd omap $ git checkout <commit_from_first_step> $ make panda_defconfig $ make
To build the tuna kernel, you may run the previous commands replacing all instances of "panda" with "tuna".
The kernel binary is output as: `arch/arm/boot/zImage` It can be copied into the Android source tree in order to build the matching boot image.
Or you can include the TARGET_PREBUILT_KERNEL variable while using make bootimage or any other make command line that builds a boot image.
$ export TARGET_PREBUILT_KERNEL=$your_kernel_path/arch/arm/boot/zImage
That variable is supported by all devices as it is set up via device/common/populate-new-device.sh
Hello everyone, want to compile an Android kernel on your own? Than why not begin doing it so by following the simple guide below?
Lingkungan yang dibutuhkan
Kita akan membutuhkan,
- Sebuah PC Linux (32 bit dapat digunakan untuk compile kernel).
- Pengetahuan tentang penggunaan terminal di Sistem Operasi Unix
- Compile beberapa paket.
- Compile Tool chain untuk melakukan cross compile.
- Source code kernel.
- Kesabaran:)
Mari kita mulai, pertama kali buka terminal di PC Linux anda. Anda dapat menggunakan Ubuntu / Mint / Fedora / Arch Linux dll. prosedur akan kira-kira mirip satu sama lain. Untuk distribusi yang berbasis debian, seperti Ubuntu / Mint, dapat mengetik:
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 git
Ini akan menginstalasi berbagai paket yang dibutuhkan untuk compile kernel. Selanjutnya, kita membutuhkan tool chain untuk compile kernel. Kita dapat memperolehnya dari
https://github.com/crossfire77/Android_Toolchains https://github.com/crossfire77/Android_Toolchains/archive/master.zip
Download dan extrak di salah satu folder. Selanjutnya, kita dapat mensetup path dari tool chain dengan cara mengedit
gedit .bashrc
It will open one document, then put this codes at the end of it.
export PATH=${PATH}:path/to/toolchain/folder/arm-eabi-4.4.3/bin
2
Now we are done with downloading and setting up things. Let’s move to next step!
2) Download Source Code:
Kernel source codes are under GNU GPL open source license so vendors (ex. Sony, HTC, Samsung, LG) have to release it. You can find your appropriate kernel source code from mentioned websites:
For Sony: http://developer.sonymobile.com/
For Samsung: http://opensource.samsung.com/
For HTC: http://www.htcdev.com/
For LG: http://www.lg.com/global/support/opensource/index
Just download it from mentioned websites as per your device and extract it somewhere in your computer.
3) Getting Config file:
Now this is where you should put your focus. For building a kernel you need config file. There is two ways for it:
You can either get it from your phone with help of ADB (Android Debug Bridge) or You can get it from your kernel source code.
I will show you both the ways of doing it so.
1) Getting config file from your phone with the help of ADB:
First of all connect your phone to your computer. Then type the mentioned code below:
adb pull proc/config.gz ~/home/crossfire77/kernel
This will pull your existing config file from your phone and put it in kernel folder. Now extract it,
zcat config.gz > .config
So we have directly config for building our kernel.
NOTE: Many times users’ faces errors while connecting phone with computer via ADB, it’s mostly issue of a permission. There is two solutions for it.
1.) Using ADB as root user:
$sudo -s $ adb kill-server $ adb start-server $ adb devices
And you will see your device now in terminal, it is a temporary solution meaning you have to do every time you connect your phone.
2.) Solve permission problem permanently:
Open terminal and type this:
$ sudo gedit /etc/udev/rules.d/51-android.rules
and copy content from this file, http://goo.gl/bldQS9 In this file, please replace “crossfire77” with your username.
Now last thing to do is, giving executing permission to file, and we are good to go.
$ sudo chmod a+r /etc/udev/rules.d/51-android.rules $ sudo service udev restart
This will solve your problem with ADB and FASTBOOT while connecting through them your phone with computer.
2) Getting config file from kernel source code:
This part is little tricky. For this you have to have little knowledge about your device chipset number. In kernel source code there are lots of config files so from your chipset number you can find your config file. As example, My device is HTC Wildfire S and it has MSM7227 chipset so I can find its config in mentioned path: arch/arm/configs/msm7227_defconfig3
So now just type this code in terminal:
make ARCH=arm CROSS_COMPILE=arm-eabi- msm7227_defconfig
4
It will create .config file from your existing chipset config and then we are good to go. As I told you before you need to have little knowledge about your device chipset then you can able to tell what is your correct config file, so be careful while doing this step. Everything is done now so shall we start building?
4) Building:
Type this in your terminal,
make ARCH=arm CROSS_COMPILE=arm-eabi- -jX
5 It is main command for compilation and here X can be replaced by maximum numbers of jobs your computer can handle simultaneously. For ease just enter the twice number of your cores. Ex. If your computer has two cores enter four.
NOTE: Please do not enter high number or your computer will explode due to overheating.
It will take around ~15-1 hour as per your computer hardware specs.so keep sit down and keep patience. After completing this procedure we will have our zImage (kernel)! afafaLet’s create one working directory:
mkdir kernell
Now, we will copy our zImage to our working directory:
cp arch/arm/boot/zImage kernell
Next step, modules (modules builds with kernel and we need it for Wi-Fi and etc. as per your device requirement)
find . -name '*ko' -exec cp '{}' kernell \;
7 So we are done with the main part, now last step to make flash able zip out of this to flash our kernel.
5) Making Flashable Zip: We are done with compiling and building task and at the end we have our zImage (kernel) and modules. Screenshot from 2014-03-05 14:22:03 Now time to flash it to your phone, for it we have one very easy method, “any kernel updater” by koush. So download this file from here: http://goo.gl/mQpHhC ffafa
So, this was all about compiling an Android Kernel. Share me your any doubts or acknowledgements if you have.
Have fun compiling Android Kernel.
This is the quickest and easiest way to build your own Kernel using the Android NDK
Note:I will be reffering to the following Quote:
yourusername=the username that you are logged in to devicecode=The codename for the device you are building a kernel for(Google it on what is the code name Note:I am only showing you how to make it to be flashed via CWM. If you wan't a tuttorial on how to make a boot.img comment and i will make it.
What you will need Quote:
Ubuntu 12.04 or newer A lot of patience Step 1:Installing the required files
Open a terminal and type the following (copy-paste) Code:
sudo apt-get install -y build-essential kernel-package libncurses5-dev bzip2
This will install the packages you need
Download the kernel source code for your device (This is important. We are going to build the kernel from this) Quote:
For HTC http://htcdev.com For Samsung http://opensource.samsung.com/ Find your device and click Download
Download The NDK
Move the NDK and your device Kernel source code in your home folder Extract both the NDK and your kernel source code Rename the folder were you have the NDK installed to NDK. And rename the folder where you have the kernel installed to Kernel
Now we are ready to build.
Step 2:Tweaking the kernel
Navigate to the kernel folder Code:
cd /home/yourusername/Kernel
Next we need to point the NDK tools to the kernel folder Code:
export CROSS_COMPILE=/home/yourusername/NDK/toolchains/arm-linux-androideabi-4.4.3/prebuilt/linux-x86/bin/arm-linux-androideabi-
We've pointed the NDK tolls and now we can use the NDK to tweak the kernel
Next we need to clean the previous work just incase: Code:
make clean && make mrproper
If everything goes well you are good to go. If you have an Error(s) then something is wrong.
Now we are ready. Next we need to add the kernel features to the NDK so we can modife them Firs open your kernel source code folder go to arch/arm/configs Here you will all the configs. We need only one. Find that. It is called:Yourdevicecode_somethingbalblabla.defconfig Rename it to maker.defconfig Now type this in your terminal Code:
make maker.defconfig
Now we need to tweak those configs. Code:
make menuconfig
A user interface will pop out showing you all the tweaks you can do. I am not going to show you whow to use it. Google it(Sorry don't have that enough space) When you are ready close the UI and click SAVE
Step 3 Building So we tweaked the Kernel and we are ready to build. Quote:
make -j# ARCH=arm
Note:The # means the number of CPU cores +1. For example my device has a quad core CPU and I will type Code:
make -j5 ARCH=arm
This will build the Kernel. It will take about 10 minutes.
Step 4: Finalizing Now that kernel is ready you will need to find a kernel flashable zip for your device(Just google it) Download the zip file and leave it in your home folder.
Now got to your kernel source and go to arch/arm/boot and copy zImage Paste your Zimage to the zip file and replace it.
Now we need the WI-FI modules otherwise your WI-FI will not be working Go to the Kernel source code folder and go to driver/net/wireless/bcm4329_204 and copy bcm4329.ko Got the zip file go to the System folder and replace it's bcm4329.ko with your bcm4329.ko
You are ready all you need to do is flash it.
Mengapa CM menginginkan kernel built bersama dengan Android?
Sebelum CM9, CM tergantung pada prebuilt kernel di setiap repository device. Ini di compile terpisah dari framework dan membutuhkan device maintainer untuk secara manual mengupdate image dan module kernel setiap kali terjadi perubahan. Masalah lainnya, kernel tidak menggunakan scheme konvensi nama yang konsistan, dan kebanyakan tidak di manage oleh CyanogenMod Gerrit, dan sering kali menggunakan compiler yang lain dari yang ada di Android toolchain. Ini menyebabkan ketidak konsisten-an, dan kesulitan bagi maintainer. [More info here]
Catatan: Cek The CyanogenMod Learning Center untuk belajar lebih dalam tentang cara membuat CyanogenMod, terutama Envsetup help dan daftar dari perintah build.
Bagaimana cara (mengedit dan) build sebuah official kernel?
Pilihan A: Build full ROM (Kernel + Android) dari full CyanogenMod source
Ikuti CM Build Guides untuk device kita.
Kernel source akan secara automatis di download jika device kita di dukung oleh CyanogenMod. ROM akan di built untuk file zip yang dapat di flash menggunakan ClockworkMod Recovery.
Catatan: full CM Android dan Kernel source akan di download (beberapa GB) dan dengan build file kita akan membutuhkan sekitar ~40-50GB (untuk CM11.0, tergantung dari kernel kita) dan disk space yang ada.
Pilihan B: Build hanya Kernel dari full CyanogenMod source
Ikuti panduan CM Build Guides untuk device kita dengan perbedaan sedikit yang akan di jelaskan di bawah ini. Kernel device kita akan di download saat dijalankan perintah breakfast atau lunch seperti yang di jelaskan di panduan build. Perhatikan bahwa full CM Android dan Kernel source akan di download (beberapa GB) dan dengan build file-nya kita akan membutuhkan sekitar ~20GB (untuk CM11.0, tergantung dari kernel)
Ikuti panduan build dari device kita, tidak menggunakan:
$ brunch
jalankan (juga dari directory root CM Android (croot), bukan dari directory kernel):
$ mka bootimage
Ini akan mengompile kernel source ke boot.img. Oleh karenanya kita akan menghemat banyak waktu compile.
File boot.img dapat di flash dengan fastboot atau secara langsung menggunakan command line. Catatan untuk menjamin compatibilitas kernal - ROM, telepon kita harus menjalakan ROM yang berbasis sama dengan versi kernel yang di flash, atau dia tidak akan jalan.
$ adb root
$ adb remount
$ installboot
$ adb reboot
Catatan: Jika device kita mendukung fastboot (Samsung tidak mendukung), kita dapat men-test kernel tanpa perlu memflash-nya:
$ adb reboot bootloader
$ fastboot boot "$OUT/boot.img"
Ubah konfigurasi kernel
The kernel configuration file used during the build process is referenced in TARGET_KERNEL_CONFIG variable in device/vendor-name/device-name/BoardConfig.mk. It generally points to kernel/vendor-name/kernel-name/arch/arm/configs/cyanogenmod_device-name_deconfig.
To make a custom kernel configuration file, you can use the configuration build tools from the kernel dir, e.g. make menuconfig, and save the resulting hidden .config file to the location specified in TARGET_KERNEL_CONFIG. Then run make mrproper from the kernel dir and go back to the CM android source root dir (croot) before building.
Re-build
To re-build the kernel after you've made some changes to the source files or config file, just run mka bootimage again. The build will be much faster due to caching, and selective build of modified files. Beware the errors during the re-build process: the building system may use previously built object/modules if some objects fail to build, leading to inconsistencies. In case of doubt, run mka clean.
Note that you can't use mm's command for kernel modules. These commands are made for modules that use an Android.mk file and not a standard Makefile, like system (not kernel) modules.
TO AVOID: Building only the kernel from the kernel source
As of