Teil 3: Bau eines Mainline Linux-Kernel für RIoTboard

Post von selsinork in RIoTboard, 4. Mai 2014, 15:13:00

In Teil 3 meiner Post-Serie lesen Sie heute, wie man eine aktuelle Linux-Version auf dem RIoTboard zum Laufen bringt.

 

Über die Links können Sie meine anderen Posts aufrufen.

Teil 1: Boot-Schalter am RIoTboard

Teil 2: Bau eines Mainline u-Boot für RIoTboard

Teil 4: Pinmux-Einstellungen für RIoTboard Erweiterungssteckverbinder

Teil 5: Bau eines Debian armhf Root-Dateisystem für RIoTboard

Teil 6: Debian auf RIoTboard. Endmontage.

 

Update vom 14. Juni 2014: Mit der referenzierten Github-Verzweigung (RIoTboard-3.15) ist es möglich, die Größe des ext2-Dateisystems zu ändern, das wir in einem späteren Post bauen werden. Ein Upgrade auf diese Version ist wärmstens zu empfehlen!

 

Diesmal baue ich den Kernel.  Das Meiste, was wir brauchen, ist bereits im Mainline-Kernel. Ein paar Marotten sind aber noch rätselhaft. Das gilt insbesondere für die Videotreiber. Hier müssen einige HDMI-Fixes noch zusammengeführt werden.  Sie wurden akzeptiert, stehen aber noch in einer Warteschlange. Es dauert halt eine Weile, bis alles läuft. Für den Augenblick nehmen wir die Fixes, wie sie sind. Auch wenn dadurch das Zusammenfügen der Einzelteile zusätzliche Arbeit macht.

 

Ich zeige zuerst, woher die Einzelteile kommen und wie Sie sie zusammenstückeln. Danach zeige ich, wie Sie die Versionen schneller verwenden und sich dabei eine Menge Kleinarbeit sparen.  Die Ungeduldigen können die nächsten Zeilen schon mal überspringen!

 

Fangen wir mit den Mainline-Quellen an. Die können Sie hier durchstöbern: https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/

Zusätzlich dazu arbeiten wir mit der for-next-Verzweigung von Shawn Guo (https://git.kernel.org/cgit/linux/kernel/git/shawnguo/linux.git/). Falls Ihnen der Name neu ist: Shawn ist bei Freescale für das i.MX 6-SoC zuständig, das auf dem RIoTboard verbaut ist.

 

Um unser lokales Repository anzulegen, gehen wir wie folgt vor:

 

git clone git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

cd linux

git remote add sgo git://git.kernel.org/pub/scm/linux/kernel/git/shawnguo/linux.git

git fetch sgo

git checkout -b imx v3.15

git merge sgo/for-next

git remote add riot git://github.com/selsinork/linux.git

git fetch riot

git merge riot/riotboard-3.15

 

Mit diesem Code klonen wir das Repository unseres Mainline-Linux, fügen Shawns imx-for-next-Struktur hinzu und vereinen die beiden. Zum Schluss werden die RIoTboard-Ergänzungen integriert.

 

Wer aufgepasst hat, dem ist aufgefallen, dass ich all das schon früher gemacht und auf Github veröffentlicht habe. Wer genauso weit kommen will, macht einfach Folgendes:

 

git clone -b riotboard-3.15 git://github.com/selsinork/linux.git

Update vom 14. Juni 2014: Verwenden Sie riotboard-3.15. Die neue Version ist jetzt im frei verfügbaren Kernel 3.15 und beinhaltet die Gerätestruktur von RIoTboard, die in den Mainline-Kernel aufgenommen wurde.

 

Die ganz Ungeduldigen, die direkt hierher gesprungen sind, können hier ein tar-Archiv herunterladen: https://github.com/selsinork/linux/archive/riotboard-3.15.tar.gz

Der Download ist ca. 115 MB groß. Wesentlich weniger als beim Github-Download. (Es sei denn, Sie haben bereits einen lokalen Klon des Mainline-Kernel.) Sie extrahieren das tar-Archiv einfach in ein geeignetes Verzeichnis und schon geht's weiter.

 

Wie Sie an diesen Punkt gekommen sind, interessiert nicht. Auf alle Fälle sollten Sie jetzt aber auf dem Linux-Kernel eine gebrauchsbereite Quellstruktur haben.  Ich nenne mein Kernel-Quellverzeichnis linux-imx-org.

 

Ich möchte betonen, dass hier keine Cross-Kompilierung stattfindet. Vielmehr baue ich alles nativ auf einem Sabre-Lite-Board mit i.MX 6 Quad-Core-Prozessor.  Damit soll den Cross-Kompilierungsproblemen aus dem Weg gegangen werden und verhindert werden, dass die Befehle unnötig mit Cross-Kompilierungs-Überbau aufgebläht werden. Außerdem vermeide ich auf diese Weise elegant Probleme mit der Host-Distribution und der Toolkette.

 

Öffnen Sie als Erstes das Quellverzeichnis und richten Sie mit der vorbereiteten Definitionskonfigurierung den Kernel ein:

 

root@sl3:~/riot# cd linux-imx-org/

root@sl3:~/riot/linux-imx-org# make riot_defconfig
  HOSTCC  scripts/basic/fixdep
  HOSTCC  scripts/kconfig/conf.o
  SHIPPED scripts/kconfig/zconf.tab.c
  SHIPPED scripts/kconfig/zconf.lex.c
  SHIPPED scripts/kconfig/zconf.hash.c
  HOSTCC  scripts/kconfig/zconf.tab.o
  HOSTLD  scripts/kconfig/conf
#
# configuration written to .config
#

 

In riot_defconfig ist festgelegt, welche Treiber usw. wir bauen möchten. Außerdem sind die darin enthaltenen Treiber für das RIoTboard geeignet.

Es kann gut sein, dass ich nicht für jedes denkbare Szenario genügend Treiber hinzugefügt habe. Ich habe auf jeden Fall versucht, alle USB-WLAN-Adapter aufzunehmen und die meisten anderen USB-Geräte, die mir aufgefallen sind.

 

Jetzt können Sie sich die Konfiguration ansehen und Treiber/Optionen dazunehmen, die Ihrer Ansicht nach noch fehlen.

make menuconfig

So ist sichergestellt, dass Ihre Änderungen gespeichert werden.

 

Alles bereit. Jetzt beginnt die Kompilierung des Hauptkernels:

root@sl3:~/riot/linux-imx-org# make -j4 bzImage

 

  CHK include/config/kernel.release
  UPD     include/config/kernel.release
  WRAP arch/arm/include/generated/asm/bitsperlong.h
  WRAP arch/arm/include/generated/asm/auxvec.h

 

[...]

 

AS      arch/arm/boot/compressed/piggy.gzip.o
  LD      arch/arm/boot/compressed/vmlinux
  OBJCOPY arch/arm/boot/zImage
   Kernel: arch/arm/boot/zImage is ready

Vielleicht ist Ihnen schon aufgefallen, dass wir ein zImage bauen, kein uImage. uImage ist ein Relikt, das nur noch selten gebraucht wird, z. B. für Raw-NAND. Für unsere Zwecke ist uImage nicht erforderlich. Würde den Kernel nur unnötig kompliziert machen.

 

Der Kernel soll auf diesem Board bzw. auf vielen dieser Boards einfach zu installieren sein. Wenn wir fertig sind und unser eigenes tar-Archiv erstellen, stecken wir deshalb alle Teile in ein Verzeichnis. Wir fangen mit dem eben erstellten Kernel an:

mkdir -p output/boot
cp arch/arm/boot/zImage output/boot/
cp System.map output/boot

  1. System.map ist nicht unbedingt notwendig. Es bewährt sich aber, wenn mal Probleme auftreten und wir um ein Debugging nicht herumkommen.

 

Der Kernel steht jetzt, aber wir sind noch nicht fertig. Wir brauchen eine Liste der Treiber, die als Module gebaut sind. Die bauen wir wie folgt:

root@sl3:~/riot/linux-imx-org# make -j4 modules
  CHK     include/config/kernel.release
  CHK include/generated/uapi/linux/version.h

 

[...]

 

  IHEX2FW firmware/keyspan_pda/keyspan_pda.fw
  IHEX2FW firmware/keyspan_pda/xircom_pgs.fw

 

 

Damit wären die Module fertig. Die sind im Quellcode verteilt. Wir möchten sie aber im Ausgabeverzeichnis haben, das wir zuvor angelegt haben:

root@sl3:~/riot/linux-imx-org# make modules_install INSTALL_MOD_PATH=output
  INSTALL crypto/arc4.ko
  INSTALL crypto/authenc.ko

 

[...]

 

  INSTALL output/lib/firmware/keyspan_pda/xircom_pgs.fw
  DEPMOD  3.15.0

 

Immer noch nicht fertig ... Um für diesen Kernel kompilieren zu können, brauchen wir einen sicheren Kernel-Header:

root@sl3:~/riot/linux-imx-org# make headers_install INSTALL_HDR_PATH=output/usr
  CHK include/generated/uapi/linux/version.h
  HOSTCC  scripts/unifdef
  INSTALL include/asm-generic (35 files)

 

[...]

 

  INSTALL include/uapi (0 file)
  INSTALL include/asm (34 files)

Die meisten Distributionen enthalten bereits ein Paket mit Kernel-Headern. Das ist aber nicht unbedingt von Vorteil. Ein Board wie das RIoTboard möchten wir wahrscheinlich an verschiedene Gerätschaften anschließen. Die Header aus der Distribution sind da nicht unbedingt hilfreich.

 

Jetzt fehlt uns nur noch die Gerätestruktur. Ohne sie ist der gesamte bisherige Code nutzlos:

root@sl3:~/riot/linux-imx-org# make dtbs
  CHK     include/config/kernel.release
  CHK include/generated/uapi/linux/version.h

 

[...]

 

  DTC arch/arm/boot/dts/imx6q-wandboard.dtb
   DTC arch/arm/boot/dts/imx6dl-riotboard.dtb
  DTC arch/arm/boot/dts/imx6sl-evk.dtb
  DTC arch/arm/boot/dts/vf610-colibri.dtb
  DTC arch/arm/boot/dts/vf610-cosmic.dtb
  DTC arch/arm/boot/dts/vf610-twr.dtb

Jetzt ins Ausgabeverzeichnis kopieren:

root@sl3:~/riot/linux-imx-org# cp arch/arm/boot/dts/imx6s-riotboard.dtb output/boot

Damit hätten wir alles beisammen. Jetzt können wir das tar-Verzeichnis für unseren Kernel erstellen:

root@sl3:~/riot/linux-imx-org# cd output
root@sl3:~/riot/linux-imx-org/output# tar Jcf ../linux-kernel-3.15-riot.txz *

 

 

Das wär's.  Dieser Post ist ohnehin schon lang genug.  Ich hoffe, der eine oder andere kann die Teile zusammensetzen und etwas damit anfangen. Wenn nicht, dann nicht den nächsten Post verpassen. Dort richte ich die SD-Karte auf diesem Kernel ein.