How to build kernel for Android

This article explains how to build the Android^® kernel binaries (including the kernel image, the modules and the device trees) for a selected STM32 device. It is intended for Distribution Package users.

The Android^TM Linux^® Common kernel is used in the distribution package.

1. Prerequisites[edit source]

The environment must be installed using the Distribution Package adapted to the selected microprocessor device. See the list of Android^TM Distribution Package.

To be able to execute the following instructions work from the distribution root directory and initialize the environment:

 source build/envsetup.sh
 bspsetup
 lunch aosp_<BoardId>-userdebug

Information

The bspsetup instruction only needs to be run once for the each distribution

The distribution includes prebuilt kernel binaries used to generate the partition images (boot, dt and vendor). These binaries are available in the device/stm/<STM32Series>-kernel/prebuilt directory.

2. Partition layout[edit source]

The Linux^® kernel binary is part of the boot partition.

The Linux^® kernel drivers built as loadable modules (.ko files) are part of the vendor partition.

The device tree binary file is part of the dt partition.

For information on the complete partition layout for the selected development platform, refer to the corresponding Flash mapping article named Your_development_platform Flash mapping for Android. Example: STM32MP15 Flash mapping for Android for the STM32MP15 boards.

All Flash mapping for Android^TM articles belong to the Category:Flash mapping for Android.

3. Load the kernel sources[edit source]

By default, the kernel sources are not part of the STM32MPU distribution for Android^TM. To load the sources, execute the following instruction:

 load_kernel

This will load the Android™ common Linux^® kernel sources. These are located in the device/stm/<STM32Series>-kernel/linux-<STM32Series> directory.

Information

The load_kernel script uses the configuration file available in the /device/stm/<STM32Series>-kernel/source/patch/<kernel version>/ directory.

4. Build the kernel[edit source]

After retrieving the kernel sources, it is built using:

 build_kernel

Information

By default, kernel debug configuration is used for userdebug or eng build variant

The output is located in: out-bsp/<STM32Series>/KERNEL_OBJ

This instruction generates the kernel image, the device tree blobs and the modules (including the specific GPU driver module). It is possible to generate them separately from one another:

 build_kernel vmlinux
 build_kernel modules
 build_kernel dtb
 build_kernel gpu

To get back more details on available options, run:

 build_kernel -h

Here after, see the result for the version 1.4:

Usage: build_kernel [Options] [Command]

  This script allows building the Linux kernel source

Options:
  -h/--help: print this message and exit
  -v/--version: print script version and exit
  -i/--install: update prebuilt images
  -d <val>/--debug=<val>: if <val>=1; integrate debug kernel configuration (default for userdebug or eng build variant)
                          if <val>=0; remove debug kernel configuration (default for user build variant)
  -g/--gdb: generate vmlinux (kernel incl. symbols) and don't strip generated modules (keep symbols)
  --gcc: use gcc toolchain instead of clang (bspsetup shall be executed before)
  --verbose=<level>: enable verbosity (1 or 2 depending on level of verbosity required)
Command: only one command at a time supported
  dtb: build only device-tree binaries
  gpu: build only gpu module (kernel is build if not already performed)
  defaultconfig: build only .config based on default defconfig files and fragments
  menuconfig: display standard Linux kernel menuconfig interface
  modules: build only kernel modules binaries (kernel is build if not already performed)
  modules_install: build kernel modules binaries (kernel is built if not already performed) and install them (also update the module.dep file)
  mrproper: execute make mrproper on targeted kernel
  vmlinux: build only kernel vmlinux binary

5. Integrate the kernel[edit source]

To integrate the new kernel, modules or/and device tree in the distribution, the prebuilt images have to be update first:

 build_kernel -i

Information

It's highly recommended to use the -d (debug) option, if you want to build the Linux kernel adapted to a userdebug or eng Android build variant.

or

 build_kernel -i vmlinux
 build_kernel -i modules
 build_kernel -i gpu
 build_kernel -i dtb

And then build the distribution to generate output images.

 make -j

Finally, update the associated device partitions. Refer to How to populate boards for Android

6. Customize the kernel[edit source]

If the kernel configuration has to be changed, refer to How to customize kernel for Android page.