# Compiling Linux Kernel 5.4.x LTS for Arietta

<abstract>
	This article illustrates how to generate a bootable Linux Kernel image for Arietta SOM
</abstract>

##Step-by-step Kernel cross-compilation procedure:

* It is advisable to have a [Debug Port Interface](/DPI) or [similar](/USB-3V-SER) during the kernel bootstrap

This article has been tested on a __Linux Ubuntu 18.04.4 PC Intel/64bit__ and on a __Raspberry Pi 4 Raspbian Buster Lite__,

<div class="panel panel-default">
	<div class="panel-heading">
		<h3 class="panel-title">Ubuntu</h3>
	</div>
	<div class="panel-body">
		Install <a href="/arm9_toolchain">these packages</a>
	</div>
</div>	

<div class="panel panel-default">
	<div class="panel-heading">
		<h3 class="panel-title">Raspberry Pi</h3>
	</div>
	<div class="panel-body">
	
		The toolchain (gcc, g++, etc) required to compile the Linux Kernel is already installed by default on Raspbian Buster.
		Install just these few packages:
		
		<pre>
		sudo apt update
		sudo apt install bc bison libssl-dev
		</pre>
		
		It is possible to use the Raspberry Pi native gcc compiler so remove:
		
		<code>
		CROSS_COMPILE=arm-linux-gnueabi-
		</code>
		
		from the command provided below
	</div>
</div>	

Open this web page <https://www.kernel.org> and check which is the latest Linux Kernel 5.4.x version available. In this article we will
use the version 5.4.89. Change the last version number with the version you found.

Open a terminal on your Linux PC and download the Linux Kernel sources from the main stream repository:

	wget https://www.kernel.org/pub/linux/kernel/v5.x/linux-5.4.89.tar.xz

Extract the Kernel sources from the compressed file by typing:

	tar xvfJ linux-5.4.89.tar.xz

Move inside the new folder:

	cd linux-5.4.89

Create a your own personal branch of Linux Kernel sources using [git](https://git-scm.com/) to keep a trace of any changes from the
Kernel mainline.

Install git on your PC:

	sudo apt update
	sudo apt install git

Create a local git repository and a new branch called "acme": 

	git init; git add .; git commit -m "Linux vanilla"; git branch acme; git checkout acme

Download the Acme Systems patch for this Kernel version. It add just the Acme boards defconfig, device trees and
small fewbug fixes (don't change the version number in this case):

	wget https://raw.githubusercontent.com/AcmeSystems/acmepatches/master/linux-5.4.x.patch

and apply it by typing:

	patch -p1 < linux-5.4.x.patch

Then select from the following list the right Linux configuration for your board by typing one of these commands:

	make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- acme-arietta_defconfig

### Customize the default Linux Kernel configuration:

If you need to customize the Kernel configuration or you just want to take a look
around the Kernel setup type:

	make ARCH=arm menuconfig

and navigate inside the Kernel configuration using the arrow keys and 
following the help provided by the menuconfig interface.

### Create a defconfig of your own Kernel configuration

	make ARCH=arm savedefconfig

The file <code>defconfig</code> contains your configuration. You could rename and copy it in <code>arch/arm/configs/</code>

	cp defconfig arch/arm/configs/my_defconfig

### Generate the Device Tree Blob file (.dtb)

Now compile the device tree file requested by your board by selecting one of the following commands:

	make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- acme-arietta.dtb

### Compile the Kernel image

Compile the Linux Kernel sources and generate the binary compressed 
image file to save in the first partition of microSD card.

	make -j8 ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- zImage
	...
	Image arch/arm/boot/zImage is ready

### Compile the Kernel modules

The image generated contains the Linux Kernel and all the built-in 
device drivers (option <b>[*]</b> in menuconfig) compiled with it.

Al the drivers compiled as external modules (option <b>[M]</b> in menuconfig)
need to be compiled and saved in the rootfs <code>/lib</code> directory on the second 
partition of the microSD. We didn't use any [M] flag in our defconfig so this procedure 
is not requested but. in case you add something. these are the commands to use
to compile them:

	make modules -j8 ARCH=arm CROSS_COMPILE=arm-linux-gnueabi-
	make modules_install INSTALL_MOD_PATH=./modules ARCH=arm

### Copy the boot files into the first microSD partition

Insert a [formatted microSD](/microsd_format) with the boot loader ([at91bootstrap](/at91bootstrap))
and the rootfs contents already created in your Linux PC and copy on it these files:

Write the Linux Kernel image and the device tree blob in the first microSD partition:
	
	sudo cp arch/arm/boot/zImage /media/$USER/boot
	sudo cp arch/arm/boot/dts/acme-arietta.dtb /media/$USER/boot/acme-arietta.dtb

Write the Linux Kernel modules inside the second microSD partition:
	
	sudo rsync -avc modules/lib/. /media/$USER/rootfs/lib/.

### After the first boot

At the first access to the board command line update the module dependencies by typing this command:

	depmod -a

## Links

* [The Linux Kernel Archives](https://www.kernel.org)
* [Linux versions changelog](https://kernelnewbies.org/LinuxVersions)

## Usefull command

If you want to create a patch with the changes you have made on the vanilla Linux kernel
use these commands:

	git checkout acme
	git diff master > acme.patch

To revert a patch applied type:

	patch -p1 -R < ../acme.patch