Introduction to Android Kernel Customization

Integrating new hardware into an Android device often requires custom kernel modifications, particularly when existing drivers are unavailable or require specific optimizations. This process, known as integrating ‘out-of-tree’ drivers, involves patching the Android kernel source and building a custom kernel image. This expert-level guide will walk you through the intricate steps of setting up your build environment, understanding kernel patching, integrating a hypothetical driver, and finally, compiling and preparing your custom Android kernel for deployment.

Why Out-of-Tree Drivers?

Out-of-tree drivers are essential in several scenarios, especially within the Android ecosystem:

• New Hardware Support: For components not yet supported by the upstream Linux kernel or the device manufacturer’s provided kernel source.
• Proprietary Hardware: Integrating custom peripherals or sensors that come with their own vendor-supplied drivers.
• Performance Optimizations: Applying specialized drivers or patches to enhance the performance or power efficiency of specific hardware components beyond standard configurations.
• Legacy Device Support: Porting older hardware drivers to newer kernel versions or vice versa, especially in embedded systems.

The goal is to seamlessly incorporate these drivers into the kernel’s build system so they are compiled alongside the rest of the kernel, becoming an integral part of the boot image.

Prerequisites and Environment Setup

Before diving in, ensure you have a robust development environment. You will need:

• A Linux-based workstation (Ubuntu/Debian recommended).
• Sufficient disk space (100GB+ for Android source and toolchains).
• Git for version control.
• The Android NDK/SDK (specifically, the prebuilt toolchains).
• The device-specific Android kernel source code (usually from AOSP or the device manufacturer’s GitHub/downloads).
• Basic understanding of Linux kernel compilation and C programming.

Obtaining the Kernel Source

The first step is to get the exact kernel source matching your device and Android version. For AOSP-based devices, you can usually find it in the AOSP project. For vendor-specific kernels, you might need to check the manufacturer’s open-source release pages.

git clone https://android.googlesource.com/kernel/common.git common_kernel
cd common_kernel
git checkout android-12.0.0_r0.1 # Or your specific branch/tag

For a device-specific kernel, the path might look like:

git clone https://github.com/YourDeviceVendor/android_kernel_yourdevice.git -b your_android_version kernel_source
cd kernel_source

Setting up the Cross-Compilation Toolchain

Android kernels are cross-compiled. You’ll need the appropriate GNU ARM or AArch64 toolchain. These are often included within the Android NDK or can be downloaded separately.

# Example for AOSP prebuilts
export PATH="$PATH:/path/to/android-ndk-r23b/toolchains/llvm/prebuilt/linux-x86_64/bin"
export CROSS_COMPILE=aarch64-linux-android-
export ARCH=arm64

# Or for older ARM 32-bit kernels
export CROSS_COMPILE=arm-linux-androideabi-
export ARCH=arm

Verify your toolchain:

aarch64-linux-android-gcc -v

Understanding Kernel Patches

Kernel patches are text files describing changes between two versions of source code. They are typically generated using diff or git diff and applied using the patch utility. A typical patch file looks like this:

diff --git a/path/to/file.c b/path/to/file.c
index 1234567..abcdef0 100644
--- a/path/to/file.c
+++ b/path/to/file.c
@@ -10,6 +10,7 @@
 #include <linux/module.h>
 #include <linux/kernel.h>
+
 static int __init my_module_init(void)
 {
  printk(KERN_INFO "Hello, world!");

The - lines are removed, and + lines are added. The @@ line indicates the chunk header, showing line numbers and counts.

Integrating the Out-of-Tree Driver

Let’s assume we have a new character device driver named my_device.c that we want to integrate. For simplicity, it will be a basic ‘hello world’ driver.

1. Create the Driver Source File

Inside your kernel source tree, create a new directory (e.g., drivers/misc/my_driver/) and place your my_device.c file there.

// drivers/misc/my_driver/my_device.c
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/printk.h>

#define MY_DEVICE_NAME "my_device"

static int my_device_open(struct inode *inode, struct file *file) {
    pr_info("my_device: openedn");
    return 0;
}

static int my_device_release(struct inode *inode, struct file *file) {
    pr_info("my_device: releasedn");
    return 0;
}

static ssize_t my_device_read(struct file *file, char __user *buf, size_t count, loff_t *pos) {
    pr_info("my_device: read attemptn");
    return 0;
}

static const struct file_operations my_device_fops = {
    .owner = THIS_MODULE,
    .open = my_device_open,
    .release = my_device_release,
    .read = my_device_read,
};

static dev_t my_device_dev_num;
static struct cdev my_device_cdev;
static struct class *my_device_class;

static int __init my_device_init(void) {
    int ret;

    pr_info("my_device: initializingn");

    ret = alloc_chrdev_region(&my_device_dev_num, 0, 1, MY_DEVICE_NAME);
    if (ret < 0) {
        pr_err("my_device: failed to allocate char device regionn");
        return ret;
    }

    cdev_init(&my_device_cdev, &my_device_fops);
    my_device_cdev.owner = THIS_MODULE;

    ret = cdev_add(&my_device_cdev, my_device_dev_num, 1);
    if (ret < 0) {
        pr_err("my_device: failed to add cdevn");
        unregister_chrdev_region(my_device_dev_num, 1);
        return ret;
    }

    my_device_class = class_create(THIS_MODULE, MY_DEVICE_NAME);
    if (IS_ERR(my_device_class)) {
        pr_err("my_device: failed to create device classn");
        cdev_del(&my_device_cdev);
        unregister_chrdev_region(my_device_dev_num, 1);
        return PTR_ERR(my_device_class);
    }

    device_create(my_device_class, NULL, my_device_dev_num, NULL, MY_DEVICE_NAME);

    pr_info("my_device: module loaded (Major: %d, Minor: %d)n", MAJOR(my_device_dev_num), MINOR(my_device_dev_num));
    return 0;
}

static void __exit my_device_exit(void) {
    pr_info("my_device: exitingn");
    device_destroy(my_device_class, my_device_dev_num);
    class_destroy(my_device_class);
    cdev_del(&my_device_cdev);
    unregister_chrdev_region(my_device_dev_num, 1);
}

module_init(my_device_init);
module_exit(my_device_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("A simple out-of-tree character device driver for Android kernel");

2. Modify Kconfig

To make our driver selectable during kernel configuration, we need to add an entry to the appropriate Kconfig file (e.g., drivers/misc/Kconfig).

--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -20,6 +20,13 @@
 source "drivers/misc/KXTJ9/Kconfig"
 endif
 
+config MY_DEVICE_DRIVER
+	tristate "My Custom Device Driver"
+	depends on ANDROID
+	help
+	  This option enables support for My Custom Device.
+	  If you have this device, say Y or M.
+
 config PHANTOM_TEK_LM832X
 	tristate "Phantom Tek LM832X series driver"
 	depends on I2C

3. Modify Makefile

Next, we need to instruct the kernel’s build system to compile our driver. Add an entry to the relevant Makefile (e.g., drivers/misc/Makefile).

--- a/drivers/misc/Makefile
+++ b/drivers/misc/Makefile
@@ -38,3 +38,6 @@
 obj-$(CONFIG_SRAM)             += sram.o
 obj-$(CONFIG_QSEECOM)          += qseecom.o
 obj-$(CONFIG_QSEE_SPCOM)       += qsee_spcom.o
+
+obj-$(CONFIG_MY_DEVICE_DRIVER) += my_driver/
+obj-$(CONFIG_MY_DEVICE_DRIVER) += my_driver/my_device.o

Then, create a `Makefile` inside `drivers/misc/my_driver/`:

# drivers/misc/my_driver/Makefile
obj-$(CONFIG_MY_DEVICE_DRIVER) += my_device.o

Creating the Patch File

Once you’ve made all your changes, navigate to the root of your kernel source directory. Assuming you started from a clean Git repository, you can generate a patch file like so:

git add .
git commit -m "feat: Add my_device out-of-tree driver"
git format-patch HEAD~1 -o ../patches/

This will create a .patch file in the ../patches/ directory containing all your changes.

Alternatively, if you didn’t use Git to track your changes from a clean state:

# Assuming you have a clean kernel source in 'kernel_original' and modified in 'kernel_modified'
diff -rupN kernel_original kernel_modified > my_driver_integration.patch

Applying the Patch

If you’re applying a patch generated by someone else (or your own to a fresh kernel tree), navigate to the root of the target kernel source and use the patch utility:

patch -p1 < /path/to/my_driver_integration.patch

The -p1 option tells patch to strip one directory component from the file paths in the patch file.

Building the Custom Kernel

Now, it’s time to build the kernel with your integrated driver. Navigate to the root of your kernel source.

1. Configure the Kernel

Start with your device’s default configuration:

make YOUR_DEVICE_DEFCONFIG

For example:

make msm_pixel_defconfig # For some Pixel devices
make goldfish_defconfig   # For Android Emulator

Then, open the kernel configuration menu to enable your driver:

make menuconfig

Navigate through the menus (e.g., Device Drivers -> Misc devices) and find