Compiling CHDK under Linux

565pages on
this wiki
Revision as of 13:32, September 24, 2013 by Andyhull (Talk | contribs)

This is the procedure I used to compile CHDK (April 2007). Look for the shorter alternative procedure at the end of this page.

June 2007. I have modified the procedure to use gcc-3.4.6 and Vitaly's patch in place of gcc-4.1.2. The reason for the change is that there is an issue with 'endianness' and floating point numbers that is addressed by Vitaly's patch.

I compiled the CHDK with gcc-4.1.2, both 'trunk' and 'grand' branches, with success since April until I met a problem using the 'pow' function under 'trunk'. The 'grand' branch addresses the issue differently and the floating point code worked fine under the 'grand' branch when compiled with gcc-4.1.2.

There is a 'minor' difference of behavior between the two compilers. With gcc-4.1.2, the variable __arm__ is defined even when the compiler is called with option -mtumb; with gcc-3.4.6 and the patch and option -mthumb, the variable __arm__ is not defined but variable __thumb__ is. The CHDK file 'include/lowlevel.h' is sensitive to that difference of behavior.

The reason I used gcc-4.1.2 in the first place is that I was not aware of Vitaly's patch.

Getting the source


CHDK source was split into two main streams effective Dec 26,2011. A stable stream was created as a branch and the main trunk became the development or unstable stream. References on this page are to the development or unstable stream. Change to to use the stable stream.

  • Create a directory where to load the CHDK source code.
 > mkdir ~/chdk && cd ~/chdk
  • Get the CHDK source code.
 > svn co chdk
  • and update the source code every now and then:
 > cd chdk && svn up

Installing the cross compiler


There are alternate guides for setting up newer cross compilers here: gcc433 and here gcc452

Get the sources of gcc and binutils from a GNU repository. Decide where the cross compiler will be on your computer.

 > mkdir ~/arm-elf
Tell your computer you are going to run programs from that location.
 > export PATH=${HOME}/arm-elf/bin:$PATH
Create a working area and build binutils and gcc.
 > mkdir ~/wa
 > cd ~/wa
 > tar xvfj ~/src/binutils-2.17.tar.bz2
 > tar xvfj ~/src/gcc-3.4.6.tar.bz2

Note: About using the latest Gcc-4.3.3 take a look at this article.

 > cd binutils-2.17
 > ./configure --srcdir=../binutils-2.17 --target=arm-elf \
     --prefix=${HOME}/arm-elf --disable-werror
 > make
 > make install
 > cd ..
Apply Vitaly's patch to the compiler.
 > (cd gcc-3.4.6 && patch -p0 <~/chdk/tools/patches/gcc-3.4-arm.diff)
 > mkdir gcc-3.4.6-arm-elf && cd gcc-3.4.6-arm-elf
 > ../gcc-3.4.6/configure --srcdir=../gcc-3.4.6 --target=arm-elf \
    --enable-multilib --enable-languages=c --enable-clocale=gnu \
    --disable-libm --disable-libc --disable-threads \
    --disable-nls --disable-libssp --disable-intl --disable-libiberty \
    --with-cpu=arm9 --with-newlib --prefix=${HOME}/arm-elf
 > (unset LIBRARY_PATH; unset CFLAGS; make && make install)
That's it for the installation of the cross-compiler.

Compiling the CHDK.

Go to either 'trunk' or 'grand'.

 > cd ~/chdk/grand
Manually edit file <> to select PLATFORM and PLATFORMSUB for your camera: just remove the "#" comment characters. Also, add the following line at the beginning of file <> to tell CHDK where the arm cross compiler is,
 export PATH=${HOME}/arm-elf/bin:${PATH}
You should be ready to compile everything.
 > make fir
The results are left in the "bin" directory.
If you want to compile firmware for an another camera, just execute make with PLATFORM and PLATFORMSUB arguments. For example:
 > make PLATFORM=a620 PLATFORMSUB=100f fir
Before compiling firmware for a different camera, the build directory may need to be cleaned. For example:
 > make PLATFORM=a620 PLATFORMSUB=100f clean
To compile firmware for all cameras just type:
 > make batch-zip

Alternative cross compilers.

Compiling CHDK on Ubuntu

See this forum thread : Compiling CHDK on Ubuntu 11.10

An alternative method with gcc-3.4.6

There is a patch included in CHDK for building with gcc-3.4.6. It's a simpler install if you want to use this version of gcc. This method uses a global install of the arm-elf tools.

Remember to clear any CFLAGS you've got set:

 > export CFLAGS=""

Compile and install binutils

Extract the source, change to its directory, and

 > mkdir binutils-2.17-arm-elf
 > cd binutils-2.17-arm-elf/
 > ../configure --srcdir=../ --target=arm-elf && make && sudo make install

Compile and install GCC-3.4.6

Download gcc-3.4.6, extract it and change to that directory. Patch the GCC source with the toolkit patch:

 > patch -p0 < [path_to_chdk]/tools/patches/gcc-3.4-arm.diff
Build the source:
 > mkdir gcc-arm-elf
 > cd gcc-arm-elf/ 
 > ../configure --srcdir=../ --target=arm-elf --with-cpu=arm9 \
   --with-newlib --enable-multilib  --enable-languages=c \
   && make && sudo make install

You can now build the CHDK source as directed above

Compile and install GCC-4.5.2

Here is a script to build the tool chain needed for building CHDK based on GCC 4.5.2.

You will need to change the following line...


to MPFR=mpfr-3.1.2

... as mpfr-3.0.0 is no longer available.

After building the tool chain you can now download and build CHDK:

> export PATH=${HOME}/build-dir/arm/toolchain/bin:${PATH}
> svn co chdk
> cd chdk
> make PLATFORM=sx200is PLATFORMSUB=100c fir

You may need to adjust the platform variable in last line to the model of your camera. The ./bin/DISKBOOT.BIN need to be copied to your SD card. If you want a PS.FI2 for auto booting, you need to follow ./platform/ to get ./bin/PS.FI2 after building CHDK.

The Gentoo way

Gentoo Linux contains a nice utility to automate this process. Emerge sys-devel/crossdev and run

crossdev -t arm-elf -s1 --without-headers --binutils 2.18-r4

This commands should compile and merge the latest gcc and binutils 2.18 (the latest binutils-2.19.1 doesn't work with chdk). Look at the versions at $PORTDIR_OVERLAY/cross-arm-elf/binutils/
The first line in should look then like this:

PATH := /usr/i686-pc-linux-gnu/arm-elf/binutils-bin/2.18/:/usr/i686-pc-linux-gnu/arm-elf/gcc-bin/4.4.1/:${PATH}

GCC 4.x


A gcc 4.3.1-binutils 2.18 environment kit for Linux was available from here: chdhdev drop but the link is dead
This is the environment running on the CHDK autobuild server (19-Jan-2009), it's compiled under debian etch

Well, this works fine on Ubuntu 8.04.2. About using the latest Gcc-4.3.3 take a look at this article.

Success reports

- binutils-2.22 and gcc-4.5.3 on Gentoo ~amd64 (using sys-devel/crossdev)

- binutils-2.23 and gcc-4.5.4 gcc-4.6.3 gcc-4.7.2 (latest needs --enable-obsolete to allow arm-elf binary format) OpenSUSE amd64

Python GUI


An GUI written in python is available here for download

cd directory/where/compiler/is

The rest schould be self-explaining.

Mor info can be found in the german forum:

Use google translate if you can't read german.

Advertisement | Your ad here

Around Wikia's network

Random Wiki