How to manually build the Linux kernel for 32 bit devices

1. Unlock the boot loader

All the work on building and compiling a kernel is based on you having unlocked the boot loader of your device. Instructions on how to do this can be found in our new and improved unlocking boot loader pages. Please remember that this is only for advanced kernel developers. We recommend standard users not to unlock the boot loader, as it is not needed.

Note: There is no turning back after unlocking the boot loader. You may void the warranty of your device, and you will not be able to revert it back to a locked and original state again.

2. Download a cross compiler

A cross compiler is used to build ARM binaries on a different architecture, such as x86. This allows you to compile the kernel into a format that the device can run. We recommend the use of the GCC 4.8 cross compiler provided in the Android Open Source Project. Download the GCC 4.8 cross compiler using the following commands:

mkdir /android && cd /android
git clone https://android.googlesource.com/platform/prebuilts/gcc/linux-x86/arm/arm-eabi-4.8/

Note: Any ARM cross compiler capable of compiling Linux kernels can be used, such as CodeSourcery Lite, and Linaro.

3. Export the cross compiler

The cross compiler needs to be exported to specify which compiler to be used by the build system.Export the GCC 4.8 cross compiler using the following command:

</pre>
<pre>export CROSS_COMPILE=/android/prebuilts/gcc/linux-x86/arm/arm-eabi-4.8/bin/arm-eabi-

Note: In case of using another cross compiler than GCC 4.8, replace /android/prebuilts/gcc/linux-x86/arm/arm-eabi-4.8/bin/arm-eabi- with the correct search path of the cross compiler of your choice.

4. Download the kernel source from GitHub

The Sony kernel sources for flagship devices are available on the SonyXperiaDev GitHub. More sources for other devices will be added over time. Download by entering:

git clone https://github.com/sonyxperiadev/kernel
cd kernel
git branch -r
git checkout

5. Identify your device’s config file name

In order to configure the kernel, you need first to identify your device’s config file name. Please note that only devices featured in the Sony GitHub release and Sony GitHub unified kernels are shown here.

Device	Config file name
Device Xperia Z3	Config file name aosp_shinano_leo_defconfig
Device Xperia Z3 Compact	Config file name aosp_shinano_aries_defconfig
Device Xperia Z3 Tablet Compact	Config file name aosp_shinano_scorpion_defconfig
Device Xperia Z2	Config file name aosp_shinano_sirius_defconfig
Device Xperia Z2 Tablet	Config file name aosp_shinano_castor_defconfig
Device Xperia Z Ultra	Config file name aosp_rhine_togari_defconfig
Device Xperia Z1	Config file name aosp_rhine_honami_defconfig
Device Xperia Z1 Compact	Config file name aosp_rhine_amami_defconfig
Device Xperia E3	Config file name aosp_yukon_flamingo_defconfig
Device Xperia M2	Config file name aosp_yukon_eagle_defconfig
Device Xperia T2 Ultra	Config file name aosp_yukon_tianchi_defconfig
Device Xperia T3	Config file name aosp_yukon_seagull_defconfig

6. Configure the kernel

Configure the kernel is a required step before building it. Kernel drivers can be turned on or off, or be built as modules. This has to be configured in order for the kernel to function as desired. Configure the kernel by entering:

make ARCH=arm CROSS_COMPILE=$CROSS_COMPILE <device_defconfig>

Note: Replace with the device config file name identified in Step 5.

7. Build the kernel and needed modules

When building the kernel a compressed kernel image file is created and placed in the default target arch/arm/boot/zImage on your computer. To start the build, enter:

make ARCH=arm CROSS_COMPILE=$CROSS_COMPILE -j <cpu_thread_number>

Note: The should correspond to your host architecture. In case of errors, replace with the numeral 1 for easy debugging.

8. Copy needed binaries to your Android repository

For building a new boot image with the compiled kernel, the kernel binary “arch/arm64/boot/Image.gz-dtb” has to be renamed “kernel-” and placed in the device/sony/common-kernel folder.

Note: Please note that this is a kernel binary with an appended dtb and there is no need to copy the .dtb separately. Wireless drivers are built into the kernel and there is no kernel module for them.

For environment setup instructions, see the AOSP build instructions. To generate the images enter the following commands:

source build/envsetup.sh && lunch

When prompted, pick the number corresponding to your device in the list displayed and press enter. To start the build, type:

make -j <insert the cpu thread number of your computer> bootimage

Note: The build will take some minutes to complete.

9. Download the Fastboot protocol

Fastboot is a diagnostic protocol included in the Android SDK. Make sure you have the Android SDK installed before proceeding. Fastboot will be used to modify the flash file system on your device via a USB connection from the computer. If you unlocked your boot loader in Step 1, you will already have Fastbootinstalled.

10. Flash the boot image file

Use the Fastboot protocol to flash the boot image file to your phone or tablet. Enter the following command:

fastboot flash boot out/target/product/<device>/boot.img

When prompted to connect your device, first make sure that your device is turned off. Then, hold down the Volume Up button and connect the device to your computer with a USB cable. Your device’s notification light should shine blue to confirm it’s in Fastboot mode.

When the flashing is completed, reboot your device by entering:

fastboot reboot

You have now gone through the process of how to download a Sony kernel source, and then how to build and flash the kernel to your device. However, we have not gone into detail on how to modify the kernel itself. For more details, we recommend you to deep dive into forums and websites such as XDA Developers and XDA University, where there are many skilled people sharing their knowledge.