====== Cross-Compilieren für das Zoom-Board ===================
Hier wird gezeigt, wie auf dem Host Applikationen und Kernel-Module für das [[https://wiki.bu.ost.ch/inf/zoomboard/start|ZOOM-Board]] übersetzt werden können. 
<box 97% | Buildroot-Toolchain>

Workspace-Verzeichnis erstellen:
<code="bash">
mkdir -p ~/workspace/zoom
</code>
<box 95% | Buildroot-Toolchain installieren>
<code="bash">
$ sudo mkdir -p /opt/zoom
$ cd /opt/zoom
$ sudo wget -c ftp://inf004.ost.ch/zoom/buildroot-toolchain.tar.bz2
$ sudo tar xjf buildroot-toolchain.tar.bz2
$ sudo rm -rf ./buildroot-toolchain.tar.bz2
$ ./buildroot-toolchain/bin/arm-buildroot-linux-gnueabi-gcc -v
</code>
Der letzte Befehl sollte folgende Version ausgeben:
\\ ''gcc version 4.7.3 (Buildroot 2014.05)''
</box>

<box 95% | Wichtige Pfade für die Bash-Kommandozeile global verfügbar machen>
<code="bash">
$ sudo nano ~/.bashrc
</code>
Am Ende der Datei folgenden Inhalt einfügen:
<code>
# sources $PATH
export PATH=$PATH:/opt/zoom/buildroot-toolchain/
export PATH=$PATH:/opt/zoom/buildroot-toolchain/bin/
export PATH=$PATH:/opt/zoom/buildroot-toolchain/lib/
</code>
Speichern, Editor verlassen und **Terminal schliessen(!)**.

<box 95% | Zum Testen der Buildroot-Toolchain (Lokaler Compiler & Cross-Compiler):>
<code="bash">
$ mkdir -p ~/workspace/zoom/test
$ cd ~/workspace/zoom/test
$ nano hello.c
</code>
Folgenden Inhalt einfügen:
<code>
#include <stdio.h>
void main () {
        printf("Hello world\n");
}
</code>
Speichern und Editor verlassen.

Nun das File für den lokalen Rechner kompilieren:
<code="bash">
$ gcc hello.c -o hello
$ ./hello
</code>
Der letzte Befehl sollte nun auf der Kommandozeile des lokalen Rechners ein
\\ ''**Hello world**''
\\ ausgeben. Falls ja, funktioniert der Compiler für den lokalen Rechner.
\\
\\ Jetzt noch einen symbolischen Link erstellen, um eine Fehlermeldung zu vermeiden:
<code="bash">
$ sudo ln -s /usr/lib/x86_64-linux-gnu/libmpfr.so.6 /usr/lib/x86_64-linux-gnu/libmpfr.so.4
</code>
<box 97% | Hinweis>
Falls der letzte Befehl folgende Fehlermeldung ausgibt...
\\ \\ ''ln: failed to create symbolic link '/usr/lib/x86_64-linux-gnu/libmpfr.so.4': File exists''
\\ \\ ..., dann wurde der symbolische Link bereits erstellt. Die Fehlermeldung kann somit ignoriert und es kann weitergemacht werden.
</box>
\\ Nun dasselbe File für das Zoom-Board crosskompilieren, danach auf das Zoom-Board übertragen und danach das kompilierte File direkt auf dem Zoom-Board ausführen:
<code="bash">
$ /opt/zoom/buildroot-toolchain/bin/arm-buildroot-linux-gnueabi-gcc-4.7.3 hello.c -o hello
$ scp hello root@<meinZoomBoardHostName>:/media/ram
$ ssh root@<meinZoomBoardHostName>
</code>
Passwort: **toor**
\\
\\ Wir befinden uns nun auf dem Zoom-Board und führen folgende Befehle aus:
<code="bash>
$ cd /media/ram
$ ./hello
</code>
Der letzte Befehl sollte nun auf der Kommandozeile des Zoom-Boards ein
\\ ''**Hello world**''
\\ ausgeben. Falls ja, funktioniert der Cross-Compiler für das Zoom-Board.
</box>
</box>

<box 97% | Userspace Anwendungen mit CMake>
<code="bash">
$ mkdir -p ~/workspace/zoom/test/application
$ cd ~/workspace/zoom/test/application
$ nano hello.c
</code>
Folgenden Inhalt einfügen:
<code>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

int main(void) {
        printf("Hello world\n");
        return EXIT_FAILURE;
}
</code>
Speichern und Editor verlassen.
\\
\\
Folgendes File erstellen:
<code="bash">
$ nano  CMakeLists.txt
</code>
Folgenden Inhalt einfügen:
<code>
project(random)
cmake_minimum_required (VERSION 2.8)

add_executable(hello hello.c)
</code>
Speichern und Editor verlassen.

<code="bash">
$ mkdir -p ~/workspace/zoom/test/application/build
$ cd ~/workspace/zoom/test/application/build
$ cmake -DCMAKE_TOOLCHAIN_FILE=/opt/zoom/buildroot-toolchain/share/buildroot/toolchainfile.cmake ..
$ make
$ scp hello root@<meinZoomBoardHostName>:/media/ram
$ ssh root@<meinZoomBoardHostName>
</code>
Passwort: **toor**
\\
\\ Wir befinden uns nun auf dem Zoom-Board und führen folgende Befehle aus:
<code="bash>
$ cd /media/ram
$ ./hello
</code>
Der letzte Befehl sollte nun auf der Kommandozeile des Zoom-Boards ein
\\ ''**Hello world**''
\\ ausgeben. Falls ja, funktioniert die Applikationserstellung für das Zoom-Board.
</box>

<box 97% | Kernelmodule>
<box 95% | Linux Kernel Quellcode herunterladen und vorbereiten>
<code>
$ cd /opt/zoom
$ sudo wget -c ftp://inf004.ost.ch/zoom/linux.tar.gz
$ sudo tar xzf linux.tar.gz
$ sudo rm -rf linux.tar.gz
$ cd linux
$ export ARCH=arm
$ export CROSS_COMPILE=arm-buildroot-linux-gnueabi-
$ make da850_omapl138_defconfig
$ sudo ln -s /usr/lib/x86_64-linux-gnu/libmpfr.so.6 /usr/lib/x86_64-linux-gnu/libmpfr.so.4
</code>
<box 97% | Hinweis>
Falls der letzte Befehl folgende Fehlermeldung ausgibt...
\\ \\ ''ln: failed to create symbolic link '/usr/lib/x86_64-linux-gnu/libmpfr.so.4': File exists''
\\ \\ ..., dann wurde der symbolische Link bereits erstellt. Die Fehlermeldung kann somit ignoriert und es kann weitergemacht werden.
</box>
<code>
$ make modules_prepare
</code>
</box>


<box 95% | Kernelmodul erstellen>
<code="bash">
$ mkdir -p ~/workspace/zoom/test/kernelModule
$ cd ~/workspace/zoom/test/kernelModule
$ nano helloMod.c
</code>
Folgenden Inhalt einfügen:
<code>
#include <linux/init.h>
#include <linux/module.h>

MODULE_DESCRIPTION("test module");
MODULE_SUPPORTED_DEVICE("none");
MODULE_LICENSE("GPL");
MODULE_AUTHOR("urs.graf@ost.ch");

static int hello_init(void) {
  printk(KERN_ALERT "Hello world\n");
  return 0;
}

static void hello_exit(void) {
  printk(KERN_ALERT "Goodbye\n");
}

module_init(hello_init);
module_exit(hello_exit);
</code>
Speichern und Editor verlassen.
<code="bash">
$ nano Makefile
</code>
Folgenden Inhalt einfügen:
<code>
ifeq ($(KERNELRELEASE),)
KERNELDIR ?= /opt/zoom/linux
PWD := $(shell pwd)
modules: 
        $(MAKE) ARCH=arm CROSS_COMPILE=/opt/zoom/buildroot-toolchain/bin/arm-buildroot-linux-gnueabi- -C $(KERNELDIR) M=$(PWD) modules
clean: 
        rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions
.PHONY:
        modules clean
else
obj-m := helloMod.o
endif
</code>
Speichern und Editor verlassen.
<code="bash">
$ make modules
</code>
<box 90% | Hinweis>
Wenn der Inhalt von **Makefile** per //Copy-Paste// eingefügt wurde, wird vermutlich folgende Fehlermeldung ausgegeben:
\\ ''Makefile:<Zeilen-Nr.>: <nowiki>***</nowiki> missing separator (did you mean TAB instead of 8 spaces?).  Stop.''
\\ Falls dies der Fall ist, das **Makefile** nochmals editieren und in der entsprechenden Zeilen-Nr. die entsprechenden Abstände durch einen Tabulator (TAB) ersetzen, danach speichern und Editor verlassen und dann den Befehl 
<code="bash">$ make modules</code> nochmals ausführen.
</box>
<code="bash">
$ ls
</code>
Es sollte nun -nebst diversen anderen Files- ein File mit der Bezeichnung
\\ ''**helloMod.ko**''
\\ aufgelistet werden. Falls ja, hat das Erstellen des Kernelmoduls für das Zoom-Board geklappt. Nun wird dieses Modul auf das Zoom-Board kopiert und dort getestet:
<code="bash">
$ scp helloMod.ko root@<meinZoomBoardHostName>:/media/ram
$ ssh root@<meinZoomBoardHostName>
</code>
Passwort: **toor**
\\
\\ Wir befinden uns nun auf dem Zoom-Board und führen folgende Befehle aus (Kernelmodul laden, wieder entladen und Ausgaben anzeigen):
<code="bash>
$ cd /media/ram
$ sudo insmod helloMod.ko
$ sudo rmmod helloMod.ko
$ dmesg | tail
</code>
Der letzte Befehl sollte nun auf der Kommandozeile des Zoom-Boards ein
\\ ''**Hello world
\\ Goodbye**''
\\ ausgeben. Falls ja, funktioniert das erstellte Kernelmodul für das Zoom-Board.
</box>
</box>