Difference between revisions of "ROM Android: Compile Kernel untuk ROM Android"

From OnnoWiki
Jump to navigation Jump to search
Line 351: Line 351:
  
 
You are ready all you need to do is flash it.  
 
You are ready all you need to do is flash it.  
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
==Why does CM want the kernel built together with Android?==
 +
Before CM9, we depended on having prebuilt kernels in every device repository. These were compiled separately from the framework and required the device maintainer to manually update the kernel image and modules any time a change is done. In addition, kernels were not using a consistent naming scheme, many were not managed by the CyanogenMod Gerrit, and were often compiled using compilers other than the one found in the Android toolchain. This has lead to major inconsistencies, and difficulty for others to match the maintainers build. [[https://plus.google.com/+CyanogenMod/posts/LYxRnjoGhnP More info here]]
 +
 +
{{note|note=Check the [[Development|The CyanogenMod Learning Center]] to learn more about CyanogenMod building, and especially the [[Envsetup_help|Envsetup help]] for a list of build commands.}}
 +
 +
 +
==How to (edit and) build an officially supported kernel?==
 +
 +
====Option A: Building the full ROM (Kernel + Android) from the full CyanogenMod source====
 +
Follow the CM [[Build Guides]] for your device.
 +
The kernel sources will be automatically downloaded if your device is supported. The ROM will be built into a ClockworkMod Recovery flashable zip file.
 +
Note that the full CM Android and Kernel source will be downloaded (several GB) and along with the build files you will need ~40-50GB (for CM11.0, depends on your kernel) of disk space.
 +
 +
====Option B: Building only the Kernel from the full CyanogenMod source====
 +
Follow the CM [[Build Guides]] for your device with the change explained below.
 +
Your device kernel will be downloaded during the launch of the <code>breakfast</code> or <code>lunch</code> command as described in the build guide. Note that the full CM Android and Kernel source will be downloaded (several GB) and along with the build files you will need ~20GB (for CM11.0, depends on your kernel) of disk space.
 +
 +
So follow your device build guide but <u>'''instead of'''</u>:
 +
 +
<code>
 +
<s>$ brunch</s>
 +
</code>
 +
 +
run (also from the CM Android source root directory (<code>croot</code>), not from the kernel directory):
 +
 +
<code>
 +
$ mka bootimage
 +
</code>
 +
 +
This will only compile the kernel source into a boot.img. You will therefore save a lot of compilation time.
 +
The boot.img file can be then flashed with fastboot or directly from the command line.
 +
Note that to ensure kernel - ROM compatibility, your phone should run a ROM based on the same kernel version that you're flashing, or things may break.
 +
 +
<code>
 +
$ adb root<br>
 +
$ adb remount<br>
 +
$ installboot<br>
 +
$ adb reboot
 +
</code>
 +
 +
Note: If your device supports fastboot (Samsung doesn't), you can test the kernel instead of flashing it:
 +
 +
<code>
 +
$ adb reboot bootloader<br>
 +
$ fastboot boot "$OUT/boot.img"
 +
</code>
 +
 +
=====Changing the kernel configuration=====
 +
The kernel configuration file used during the build process is referenced in <code>TARGET_KERNEL_CONFIG</code> 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. <code>make menuconfig</code>, and save the resulting hidden ''.config'' file to the location specified in <code>TARGET_KERNEL_CONFIG</code>. Then run <code>make mrproper</code> from the kernel dir and go back to the CM android source root dir (<code>croot</code>) before building.
 +
 +
=====Re-building=====
 +
To re-build the kernel after you've made some changes to the source files or config file, just run <code>mka bootimage</code> 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 <code>mka clean</code>.
 +
 +
Note that you can't use <code>mm</code>'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.
 +
 +
{{tip|tip='''Escaping a bootloop:''' If your device is stuck in a bootloop after flashing, flash again the device with a working kernel (or in the worst case with a full ROM / nandroid backup).
 +
 +
In your build directory, you can find the kernel zImage in ''$OUT/obj/KERNEL_OBJ/arch/arm/boot''. This file can be flashed on supported devices with [http://glassechidna.com.au/heimdall/ Heimdall] (for some Samsung devices) or [[Doc:_fastboot_intro|fastboot]] (for devices supporting fastboot mode).
 +
 +
Note that however, <code>mka bootimage</code> doesn't generate a ClockWordMod or TWRP flashable zip file, you will have to build it yourself if you can't use the zImage directly.}}
 +
 +
====TO AVOID: Building only the kernel from the kernel source====
 +
As of CyanogenMod 9, we are deprecating the usage of prebuilt kernel images. The build system has been modified to ask for (and build) the kernel source. So don't follow CM oldwiki kernel build guide.
 +
 +
Building an official kernel from the CyanogenMod build system will ensure your are using the proper Android toolchain. It will also bring more guarantee of compatibility between the kernel and the userspace (system calls, like ioctl, should be consistent between the kernel and userspace).
 +
 +
Moreover, the kernel Makefile generally doesn't take care of creating the device-specific ramdisk, embedding the kernel image (zImage) and ramdisk into a boot.img (which structure is sometimes device specific) and pushing everything, including the loadable kernel modules, to the device. Whereas by building from the full CM source, the CM build tools will automate these steps.
 +
 +
====TO AVOID: Building only a kernel module and importing it on a different kernel version====
 +
Kernel modules (e.g. a Wi-Fi driver) are built for a specific kernel version. Indeed, the kernel module (.ko file) embed the version of the kernel it is built for (check <code>modinfo module-name.ko</code>). The module will not load if its version is different than the running kernel version (check <code>uname -a</code> from the device terminal prompt). One reason behind this version interdependency is that internal interfaces within the kernel (the interfaces used in your module to access other kernel resources/modules) can and do change between versions. [source: [http://tldp.org/LDP/lkmpg/2.6/html/x569.html#AEN691 LKMPG]]
 +
 +
Therefore you should build and flash a full kernel if you need to change a module.
 +
 +
Otherwise, and if you make no kernel configuration change, you can build a kernel module from the same exact kernel source version (i.e. ''Github commit'') that you're planning to import the module into. If you've not built the kernel yourself, this becomes highly complicated and deprecated: you may need to rebase your CM repository to the exact Github commit that your kernel was built from, extract and use the .config from your device, and eventually trick the source files that take care of defining the magic version of the built kernel module.
 +
 +
 +
==How to reference a custom kernel for building?==
 +
This chapter is intended for people that want to use a totally different kernel than the officially supported ones.
 +
If you only need to modify an officially supported firmware, go back to the previous chapter and play with the kernel files in ''kernel/vendor-name/kernel-name'' (the official kernel files for your device will be downloaded after running the <code>breakfast</code> or <code>lunch</code> commands as described in the [[Build Guides]]).
 +
 +
====Step 0. Preparing the build environment====
 +
Depending on whether your device is supported or not, follow the [[Build Guides]] or [[Doc:_porting_intro|Porting Guide]] to prepare the Build Environment and get CM Android source code, prebuilt apps, device-specific code and proprietary blobs.
 +
 +
====Step 1. Deploying the kernel source at the proper location====
 +
 +
The minimal requirement is that the kernel's source tree for that device be present at kernel/''vendor-name''/''device-name'' of the CM Android source.
 +
 +
* Officially supported devices:
 +
** For devices which are part of mainline CyanogenMod and have their kernels in CM's github, this can be accomplished by usage of CyanogenMod's ''roomservice'' feature. Create a ''device/vendor-name/device-name/cm.dependencies'' file ('''if it doesn't exist yet'''), with the following syntax. This will take care of downloading the source automatically into the right location.
 +
 +
<pre>
 +
 +
[
 +
{
 +
  "repository": "name-of-repository-in-the-CyanogenMod-github",
 +
  "target_path": "kernel/vendor-name/device-name",
 +
  "branch": "name-of-branch"
 +
}
 +
]
 +
 +
 +
</pre>
 +
 +
* Work-in-progress, unofficial, or otherwise non-integrated devices:
 +
** For devices which don't have their kernel source at the CM github, usage of ''local_manifest.xml'' is recommended in order to deploy the source at the right location, and keeping it synchronized.
 +
 +
* Devices using shared kernel repositories:
 +
** If your device shares a kernel with others, the default ''kernel/vendor-name/device-name'' path will lead to unnecessary duplication of source trees, so usage of the '''TARGET_KERNEL_SOURCE''' configuration variable in ''device/vendor-name/device-name/BoardConfig.mk'' is advised. All devices sharing that source should have the following line in their ''BoardConfig.mk'' files:
 +
 +
<code>
 +
TARGET_KERNEL_SOURCE := kernel/''vendor-name''/''unique-shared-source-name''
 +
</code>
 +
 +
==== Step 2. Configuring the device to build the kernel ====
 +
 +
After the source is in place, configuration of the device to build the kernel is trivial. Just add the '''TARGET_KERNEL_CONFIG''' variable to your ''device/vendor-name/device-name/BoardConfig.mk'' file, pointing to the configuration file name for your device (as present in ''kernal/vendor-name/kernel-name/arch/arm/configs''). For example:
 +
 +
<code>
 +
TARGET_KERNEL_CONFIG := cyanogenmod_device-name_defconfig
 +
</code>
 +
 +
This will trigger the full kernel build, including the modules (if present) as specified in that configuration. Any modules built will be deployed at ''/system/lib/modules/'' in the final image
 +
 +
If your device requires uImage, also ensure the following is present in your 'BoardConfig.mk'
 +
 +
<code>
 +
BOARD_USES_UBOOT := true
 +
</code>
 +
 +
==== Step 3. Configuring the build of out-of-tree kernel modules ====
 +
 +
If your device needs modules that aren't part of the kernel source tree, those can also be built automatically. Some hardware (Texas Instruments' TIWLAN adapters, Broadcom's BCM adapters) is directly supported by CM repositories, but if that isn't your case we suggest you add your module's source to either your device repository, or an isolated path in your kernel source.
 +
 +
To build these modules, the '''TARGET_KERNEL_MODULES''' variable can be used, pointing to a ''make target'' that will build and install such modules. Definition of such a target is the device author's responsibility, the only restriction is that it is a normal makefile recipe. To include, for example, the TI WLAN modules, this can be used:
 +
 +
<pre>
 +
TIWLAN_MODULES:
 +
      make -C hardware/ti/wlan/wl1283/platforms/os/linux/ KERNEL_DIR=$(KERNEL_OUT) ARCH="arm" CROSS_COMPILE="arm-eabi-" TNETW=1273 RANDOM_MAC=n REPORT_LOG=n
 +
      mv hardware/ti/wlan/wl1283/platforms/os/linux/tiwlan_drv.ko $(KERNEL_MODULES_OUT)
 +
      make -C hardware/ti/wlan/wl1283_softAP/platforms/os/linux/ KERNEL_DIR=$(KERNEL_OUT) ARCH="arm" CROSS_COMPILE="arm-eabi-" TNETW=1273 REPORT_LOG=n
 +
      mv hardware/ti/wlan/wl1283_softAP/platforms/os/linux/tiap_drv.ko $(KERNEL_MODULES_OUT)
 +
   
 +
TARGET_KERNEL_MODULES := TIWLAN_MODULES
 +
</pre>
 +
 +
As a rule of thumb, you can just paste your current standalone build commands into a make recipe, replacing the kernel source path with the ''$(KERNEL_OUT)'' variable.
 +
 +
==== Step 4. Configuring the fallback to prebuilts ====
 +
 +
If for some reason the kernel source can't be present, you can still fall back to prebuilt binaries, by defining the '''TARGET_PREBUILT_KERNEL''' variable, like this:
 +
 +
<code>
 +
TARGET_PREBUILT_KERNEL := device/vendor-name/device-name/kernel
 +
</code>
 +
 +
==== Step 5. Building the kernel or full ROM ====
 +
 +
Now that your custom kernel is linked to your device, you can build the device kernel or the device full ROM as you would do with an official kernel, as described in the first part of this page.
 +
 +
==== Full configuration example ====
 +
 +
The following is the p920's configuration (''device/vendor-name/device-name/BoardConfig.mk''), which attempts to build the kernel, uses external modules, and has a prebuilt fallback:
 +
 +
<pre>
 +
# Try to build the kernel
 +
TARGET_KERNEL_CONFIG := cyanogenmod_cosmo_defconfig
 +
# Keep this as a fallback
 +
TARGET_PREBUILT_KERNEL := device/lge/p920/kernel
 +
 +
KERNEL_EXTERNAL_MODULES:
 +
make -C hardware/ti/wlan/wl1283/platforms/os/linux/ KERNEL_DIR=$(KERNEL_OUT) ARCH="arm" CROSS_COMPILE="arm-eabi-" TNETW=1273 RANDOM_MAC=n REPORT_LOG=n
 +
mv hardware/ti/wlan/wl1283/platforms/os/linux/tiwlan_drv.ko $(KERNEL_MODULES_OUT)
 +
make -C hardware/ti/wlan/wl1283_softAP/platforms/os/linux/ KERNEL_DIR=$(KERNEL_OUT) ARCH="arm" CROSS_COMPILE="arm-eabi-" TNETW=1273 REPORT_LOG=n
 +
mv hardware/ti/wlan/wl1283_softAP/platforms/os/linux/tiap_drv.ko $(KERNEL_MODULES_OUT)
 +
 +
TARGET_KERNEL_MODULES := KERNEL_EXTERNAL_MODULES
 +
</pre>
 +
  
  
Line 362: Line 553:
 
* http://www.movzio.com/howto/compile-android-kernel-source-beginners-guide-2/
 
* http://www.movzio.com/howto/compile-android-kernel-source-beginners-guide-2/
 
* http://forum.xda-developers.com/showthread.php?t=2152819
 
* http://forum.xda-developers.com/showthread.php?t=2152819
 +
* http://wiki.cyanogenmod.org/w/Doc:_integrated_kernel_building

Revision as of 09:10, 10 November 2014

Building Kernels In this document 

   Figuring out which kernel to build
   Identifying kernel version
   Downloading sources
   Downloading a prebuilt gcc
   Building

If you are only interested in the kernel, you may use this guide to download and build the appropriate 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? 1) Setup Environment:

First you will need these things, 

   A Linux PC (32 bit will work for compilation of kernel)
   Basic knowledge of using terminal in Unix based operating system
   Few packages for compilation
   Tool chains for compilation
   Kernel source code
   Patience :p

So now we begin, First of all open terminal in your Linux PC. I am using here Linux Mint 16, a Debian based Linux Distribution. You can use any Linux distro for it such as Ubuntu, fedora, Arch Linux, etc. procedure will be same just you need to use different commands with terminal as per your distro. Now type this code in your terminal:

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


1

This will install required packages for kernel compilation. Now last thing, we need tool chains for compiling kernel. You can get it from here: https://github.com/crossfire77/Android_Toolchains Download it and extract it somewhere. Then, We have to setup path of our tool chains, so type this in terminal:

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.






Why does CM want the kernel built together with Android?

Before CM9, we depended on having prebuilt kernels in every device repository. These were compiled separately from the framework and required the device maintainer to manually update the kernel image and modules any time a change is done. In addition, kernels were not using a consistent naming scheme, many were not managed by the CyanogenMod Gerrit, and were often compiled using compilers other than the one found in the Android toolchain. This has lead to major inconsistencies, and difficulty for others to match the maintainers build. [More info here]

Template:Note


How to (edit and) build an officially supported kernel?

Option A: Building the full ROM (Kernel + Android) from the full CyanogenMod source

Follow the CM Build Guides for your device. The kernel sources will be automatically downloaded if your device is supported. The ROM will be built into a ClockworkMod Recovery flashable zip file. Note that the full CM Android and Kernel source will be downloaded (several GB) and along with the build files you will need ~40-50GB (for CM11.0, depends on your kernel) of disk space.

Option B: Building only the Kernel from the full CyanogenMod source

Follow the CM Build Guides for your device with the change explained below. Your device kernel will be downloaded during the launch of the breakfast or lunch command as described in the build guide. Note that the full CM Android and Kernel source will be downloaded (several GB) and along with the build files you will need ~20GB (for CM11.0, depends on your kernel) of disk space.

So follow your device build guide but instead of:

$ brunch

run (also from the CM Android source root directory (croot), not from the kernel directory):

$ mka bootimage

This will only compile the kernel source into a boot.img. You will therefore save a lot of compilation time. The boot.img file can be then flashed with fastboot or directly from the command line. Note that to ensure kernel - ROM compatibility, your phone should run a ROM based on the same kernel version that you're flashing, or things may break.

$ adb root
$ adb remount
$ installboot
$ adb reboot

Note: If your device supports fastboot (Samsung doesn't), you can test the kernel instead of flashing it:

$ adb reboot bootloader
$ fastboot boot "$OUT/boot.img"

Changing the kernel configuration

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-building

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.

Template:Tip

TO AVOID: Building only the kernel from the kernel source

As of CyanogenMod 9, we are deprecating the usage of prebuilt kernel images. The build system has been modified to ask for (and build) the kernel source. So don't follow CM oldwiki kernel build guide.

Building an official kernel from the CyanogenMod build system will ensure your are using the proper Android toolchain. It will also bring more guarantee of compatibility between the kernel and the userspace (system calls, like ioctl, should be consistent between the kernel and userspace).

Moreover, the kernel Makefile generally doesn't take care of creating the device-specific ramdisk, embedding the kernel image (zImage) and ramdisk into a boot.img (which structure is sometimes device specific) and pushing everything, including the loadable kernel modules, to the device. Whereas by building from the full CM source, the CM build tools will automate these steps.

TO AVOID: Building only a kernel module and importing it on a different kernel version

Kernel modules (e.g. a Wi-Fi driver) are built for a specific kernel version. Indeed, the kernel module (.ko file) embed the version of the kernel it is built for (check modinfo module-name.ko). The module will not load if its version is different than the running kernel version (check uname -a from the device terminal prompt). One reason behind this version interdependency is that internal interfaces within the kernel (the interfaces used in your module to access other kernel resources/modules) can and do change between versions. [source: LKMPG]

Therefore you should build and flash a full kernel if you need to change a module.

Otherwise, and if you make no kernel configuration change, you can build a kernel module from the same exact kernel source version (i.e. Github commit) that you're planning to import the module into. If you've not built the kernel yourself, this becomes highly complicated and deprecated: you may need to rebase your CM repository to the exact Github commit that your kernel was built from, extract and use the .config from your device, and eventually trick the source files that take care of defining the magic version of the built kernel module.


How to reference a custom kernel for building?

This chapter is intended for people that want to use a totally different kernel than the officially supported ones. If you only need to modify an officially supported firmware, go back to the previous chapter and play with the kernel files in kernel/vendor-name/kernel-name (the official kernel files for your device will be downloaded after running the breakfast or lunch commands as described in the Build Guides).

Step 0. Preparing the build environment

Depending on whether your device is supported or not, follow the Build Guides or Porting Guide to prepare the Build Environment and get CM Android source code, prebuilt apps, device-specific code and proprietary blobs.

Step 1. Deploying the kernel source at the proper location

The minimal requirement is that the kernel's source tree for that device be present at kernel/vendor-name/device-name of the CM Android source.

  • Officially supported devices:
    • For devices which are part of mainline CyanogenMod and have their kernels in CM's github, this can be accomplished by usage of CyanogenMod's roomservice feature. Create a device/vendor-name/device-name/cm.dependencies file (if it doesn't exist yet), with the following syntax. This will take care of downloading the source automatically into the right location.

[
 {
   "repository": "name-of-repository-in-the-CyanogenMod-github",
   "target_path": "kernel/vendor-name/device-name",
   "branch": "name-of-branch"
 }
]
  • Work-in-progress, unofficial, or otherwise non-integrated devices:
    • For devices which don't have their kernel source at the CM github, usage of local_manifest.xml is recommended in order to deploy the source at the right location, and keeping it synchronized.
  • Devices using shared kernel repositories:
    • If your device shares a kernel with others, the default kernel/vendor-name/device-name path will lead to unnecessary duplication of source trees, so usage of the TARGET_KERNEL_SOURCE configuration variable in device/vendor-name/device-name/BoardConfig.mk is advised. All devices sharing that source should have the following line in their BoardConfig.mk files:

TARGET_KERNEL_SOURCE := kernel/vendor-name/unique-shared-source-name

Step 2. Configuring the device to build the kernel

After the source is in place, configuration of the device to build the kernel is trivial. Just add the TARGET_KERNEL_CONFIG variable to your device/vendor-name/device-name/BoardConfig.mk file, pointing to the configuration file name for your device (as present in kernal/vendor-name/kernel-name/arch/arm/configs). For example:

TARGET_KERNEL_CONFIG := cyanogenmod_device-name_defconfig

This will trigger the full kernel build, including the modules (if present) as specified in that configuration. Any modules built will be deployed at /system/lib/modules/ in the final image

If your device requires uImage, also ensure the following is present in your 'BoardConfig.mk'

BOARD_USES_UBOOT := true

Step 3. Configuring the build of out-of-tree kernel modules

If your device needs modules that aren't part of the kernel source tree, those can also be built automatically. Some hardware (Texas Instruments' TIWLAN adapters, Broadcom's BCM adapters) is directly supported by CM repositories, but if that isn't your case we suggest you add your module's source to either your device repository, or an isolated path in your kernel source.

To build these modules, the TARGET_KERNEL_MODULES variable can be used, pointing to a make target that will build and install such modules. Definition of such a target is the device author's responsibility, the only restriction is that it is a normal makefile recipe. To include, for example, the TI WLAN modules, this can be used: 

TIWLAN_MODULES:
       make -C hardware/ti/wlan/wl1283/platforms/os/linux/ KERNEL_DIR=$(KERNEL_OUT) ARCH="arm" CROSS_COMPILE="arm-eabi-" TNETW=1273 RANDOM_MAC=n REPORT_LOG=n
       mv hardware/ti/wlan/wl1283/platforms/os/linux/tiwlan_drv.ko $(KERNEL_MODULES_OUT)
       make -C hardware/ti/wlan/wl1283_softAP/platforms/os/linux/ KERNEL_DIR=$(KERNEL_OUT) ARCH="arm" CROSS_COMPILE="arm-eabi-" TNETW=1273 REPORT_LOG=n
       mv hardware/ti/wlan/wl1283_softAP/platforms/os/linux/tiap_drv.ko $(KERNEL_MODULES_OUT)
    
TARGET_KERNEL_MODULES := TIWLAN_MODULES

As a rule of thumb, you can just paste your current standalone build commands into a make recipe, replacing the kernel source path with the $(KERNEL_OUT) variable.

Step 4. Configuring the fallback to prebuilts

If for some reason the kernel source can't be present, you can still fall back to prebuilt binaries, by defining the TARGET_PREBUILT_KERNEL variable, like this:

TARGET_PREBUILT_KERNEL := device/vendor-name/device-name/kernel

Step 5. Building the kernel or full ROM

Now that your custom kernel is linked to your device, you can build the device kernel or the device full ROM as you would do with an official kernel, as described in the first part of this page.

Full configuration example

The following is the p920's configuration (device/vendor-name/device-name/BoardConfig.mk), which attempts to build the kernel, uses external modules, and has a prebuilt fallback: 

# Try to build the kernel
TARGET_KERNEL_CONFIG := cyanogenmod_cosmo_defconfig
# Keep this as a fallback
TARGET_PREBUILT_KERNEL := device/lge/p920/kernel

KERNEL_EXTERNAL_MODULES:
	make -C hardware/ti/wlan/wl1283/platforms/os/linux/ KERNEL_DIR=$(KERNEL_OUT) ARCH="arm" CROSS_COMPILE="arm-eabi-" TNETW=1273 RANDOM_MAC=n REPORT_LOG=n
	mv hardware/ti/wlan/wl1283/platforms/os/linux/tiwlan_drv.ko $(KERNEL_MODULES_OUT)
	make -C hardware/ti/wlan/wl1283_softAP/platforms/os/linux/ KERNEL_DIR=$(KERNEL_OUT) ARCH="arm" CROSS_COMPILE="arm-eabi-" TNETW=1273 REPORT_LOG=n
	mv hardware/ti/wlan/wl1283_softAP/platforms/os/linux/tiap_drv.ko $(KERNEL_MODULES_OUT)

TARGET_KERNEL_MODULES := KERNEL_EXTERNAL_MODULES




Referensi

Retrieved from "https://onnocenter.or.id/wiki/index.php?title=ROM_Android:_Compile_Kernel_untuk_ROM_Android&oldid=41273"