Compiling a kernel module for the raspberry pi 2

Normally compiling a kernel module for a linux distribution is rather straight forward, but on the raspberry pi however it's a little more involved. That's why in this article I am going to show how I build kernel modules for the raspbian wheezy distro.

There are a couple of infos on the web about how to do it, but piecing them together for a working solution took some effort. That's why I am writing them down for future use. Following these steps I successfully build kernel modules for raspberry pi 2 raspbian release 2015-02-16.


Building your kernel module for the raspberry pi is a two step process. The first step is to build the complete kernel for the raspberry pi on the ubuntu machine. This will take a long time, but you'll need to do it only once. After the build is complete, you can build your kernel module fast and easy and just copy the resulting binary to the raspberry pi.


  • Raspberry Pi flashed with a raspbian wheezy distribution

    Get the latest raspbian image from the raspberrypi foundations website.

  • Ubuntu for cross-compiling

    Both time and space constrains make building the raspberry pi kernel on the raspberry pi itself rather challenging. That's why I went to road of cross-compiling from ubuntu to raspberry pi.

    If you don't have a ubuntu machine, grab a ubuntu image from their download page and spin it up in a virtual machine of your choice. Myself, I use virtualbox on a windows machine.

  • Patience

Getting the correct source

The normal way

Getting the correct source to build the kernel is trickier than one would guess. As explained on kernelnewbies.org you need the exact version of the headers from the kernel that the modules are built for.

Normally you'd simply install the kernel header package for the specific kernel version that you get when you execute uname -r, but while raspbian provides header packages, the raspberry pi foundation, who modifies them does not, as you'll find out if you read through raspberry pi orgs forums.

The raspberry way

What they do however, is keep the complete source in their github linux repository. When they build a raspberry pi firmware, which is proprietery, closed source btw, those binaries are checked-in in the firmware repository including a file that contains the git hash that points to the commit in the linux repo that they used to build it.

So luckily for us there is a link that you can follow to get the exact source code and the steps are as follows:

  1. Get the Firmware Hash from the raspberry pi
  2. Get the Linux Kernel Hash from the 'Firmware' github repo
  3. Get the Linux Kernel Source from the 'Linux' github repo

Thanks to the raspberry pi forms user 'Zeta' who put a script together and posted it in this thread to perform those steps:

# Get the Firmware Hash from the Raspberry Pi
FIRMWARE_HASH=$(zgrep "* firmware as of" /usr/share/doc/raspberrypi-bootloader/changelog.Debian.gz | head -1 | awk '{ print $5 }')
# Get the git hash for this kernel
KERNEL_HASH=$(wget https://raw.github.com/raspberrypi/firmware/$FIRMWARE_HASH/extra/git_hash -O -)
# Checkout the files on ubuntu
git checkout $KERNEL_HASH

Building the kernel

Armed with this knowledge we can now finally execute a step by step plan:

  1. Start up ubuntu
  2. Get the tools from https://github.com/raspberrypi/tools e.g.: git clone https://github.com/raspberrypi/tools
  3. Set the environment variable CCPREFIX to point to the master tools like so: export CCPREFIX=/home/INSERT YOUR USER NAME HERE/tools-master/arm-bcm2708/arm-bcm2708-linux-gnueabi/bin/arm-bcm2708-linux-gnueabi-
  4. Get the source from https://github.com/raspberrypi/linux e.g.: git clone https://github.com/raspberrypi/linux
  5. Set the environment variable KERNEL_SRC to point to the kernel source: export KERNEL_SRC=/home/INSERT YOUR USER NAME HERE/linux
  6. on the raspberry pi execute FIRMWARE_HASH=$(zgrep "* firmware as of" /usr/share/doc/raspberrypi-bootloader/changelog.Debian.gz | head -1 | awk '{ print $5 }') to retrieve the firmware hash.
  7. execute KERNEL_HASH=$(wget https://raw.github.com/raspberrypi/firmware/$FIRMWARE_HASH/extra/git_hash -O -) to retrieve the kernel hash.
  8. back on ubuntu checkout the correct version of the kernel source code inside the KERNEL_SRC directory using git: git checkout INSERT_KERNEL_HASH_HERE
  9. execute make mrproper in the KERNEL_SRC directory.
  10. copy /proc/config.gz from the raspberry pi to the KERNEL_SRC directory.

    e.g. scp pi@ipaddress:/proc/config.gz ./ and unpack it: zcat config.gz > .config

  11. execute make ARCH=arm CROSS_COMPILE=${CCPREFIX} oldconfig
  12. execute make ARCH=arm CROSS_COMPILE=${CCPREFIX}
  13. ...and wait.

  14. ...keep waiting.

If everything worked out ok, the kernel should be successfully rebuilt. Now the source directory can be used to built kernel modules for your raspberry pi.

Building Kernel modules

Now that the kernel has been successfully built, a new MOdule.symvers has been created. You can now use a make file that references the kernel source directory to built the kernel module only. E.g. use a line like:

PREFIX = /home/[USER]/tools-master/arm-bcm2708/arm-bcm2708-linux-gnueabi/bin/arm-bcm2708-linux-gnueabi-
    make ARCH=arm CROSS_COMPILE=$(PREFIX) -C /home/[USER]/linux M=$(SRC) modules

As I need to continually build kernel modules for more than one kernel version, I copy the source directory and rename it to match the kernel version. If a new kernel version comes out, I just checkout the source in a new folder. In the makefile I reference the different source folders to build the kernel module for different kernel versions.For an example of a makefile you can take a look here.


[Update 10/7/2015 - Fixed copy/paste error in git clone url.]

Last updated 11/24/2015 05:31:51
blog comments powered by Disqus
Ask Martin