Neue Kernel-Module für den Raspberry Pi mit Crosscompiler erstellen

Nicht jede Hard­ware wird unter Linux von Haus aus unter­stützt. Bei neu­en Gerä­ten sind die erfor­der­li­chen Ker­nel-Modu­le (Trei­ber) noch nicht im Ker­nel ent­hal­ten. Wenn man den Quell­text des gewünsch­ten Trei­bers im Inter­net fin­det, kann man sich die Ker­nel-Modu­le jedoch selbst erstel­len.

Für neue Ker­nel-Modu­le sind meh­re­re Vor­aus­set­zun­gen zu erfül­len: Sie benö­ti­gen den Quell­code des Ker­nels, eini­ge Ent­wick­lungs-Tools, wie den Com­pi­ler gcc, und natür­lich den Quell­code des Trei­bers. Pro­gram­mier­kennt­nis­se sind dafür nicht erfor­der­lich, ledig­lich der sou­ve­rä­ne Umgang mit der Kom­man­do­zei­le.

Update 06.01.2019: Der Raspber­ry Pi 3 ist inzwi­schen schnell genug, um ein Ker­nel-Modul direkt auf dem Gerät zu erstel­len. Ein zusätz­li­ches Tool erleich­tert außer­dem den Down­load der Ker­nel-Quel­len. Die nöti­gen Schrit­te las­sen sich damit redu­zie­ren. Außer­dem gibt es eine neue Ver­si­on des mt76x0-Trei­bers, der für neue­re Ker­nel-Ver­sio­nen ange­passt ist. Bei die­sem ent­fällt die Kon­fi­gu­ra­ti­on über die Datei /etc/Wireless/RT2870STA.dat. Die Kon­fi­gu­ra­ti­on ist jetzt im Trei­ber selbst ent­hal­ten.

Eine gute Nach­richt für alle Eigen­tü­mer der genann­ten Hard­ware: Ab Ker­nel-Ver­si­on 4.19 ist der mt76x0-Trei­ber im Linux-Stan­dard-Ker­nel ent­hal­ten. Es wird jedoch noch eini­ge Zeit dau­ern, bis die­se Ver­si­on in den Linux-Dis­tri­bu­tio­nen ankommt. Ubun­tu 18.04 bei­spiels­wei­se ver­wen­det die Ker­nel-Ver­si­on 4.15 bei Raspbi­an ist es 4.14 (Stand Janu­ar 2019).

Update 04.04.2016: Ich habe den Trei­ber-Quell­code bei Git­hub aktua­li­siert und Ände­run­gen aus ver­schie­de­nen Quel­len ein­flie­ßen las­sen. Das erzeug­te Ker­nel-Modul heißt jetzt mt7610u_sta.ko. Die Kon­fi­gu­ra­ti­ons­da­tei /etc/Wireless/RT2870STA.dat wird jetzt auch unter neue­ren Ker­neln kor­rekt ein­ge­le­sen. Hier ist jetzt „WirelessMode=13“ kon­fi­gu­riert. Nach mei­nen Tests funk­tio­nie­ren damit jetzt 2,4 und 5 GHz. Bei 5 GHz wird jedoch die erwar­te­te Geschwin­dig­keit nicht erreicht (sie­he „Netz­werk­leis­tung mit iperf mes­sen“)

Erstellung von Kernel-Modulen am Beispiel mt76x0 (Ralink/Mediatek)

Ich erläu­te­re das Ver­fah­ren am Bei­spiel des Ker­nel Moduls für den WLAN-USB-Stick TP-Link AC900. Wie sich das Ker­nel-Modul dafür unter und für Ubun­tu erstel­len lässt, habe ich im Arti­kel TP-Link Archer T2U AC600 unter Linux nut­zen beschrie­ben.

Im Prin­zip funk­tio­niert es so oder ähn­lich für jeden Trei­ber, des­sen Quell­code ver­füg­bar ist.

Der Bei­spiel-Trei­ber eig­net sich (theo­re­tisch) für fol­gen­de Hard­ware:

USB_DEVICE (0x148F:0x7610) MT7610U
USB_DEVICE (0x13B1:0x003E) Link­sys AE6000
USB_DEVICE (0x0E8D:0x7610) Sab­rent NTWLAC
USB_DEVICE (0x7392:0xa711) Edi­max 7711mac
USB_DEVICE (0x7392:0xb711) Edi­max / Ele­com
USB_DEVICE (0x148f:0x761a) TP-Link TL-WDN5200
USB_DEVICE (0x148f:0x760a) TP-Link unknown
USB_DEVICE (0x0b05:0x17d1) Asus USB-AC51
USB_DEVICE (0x0b05:0x17db) Asus USB-AC50
USB_DEVICE (0x0df6:0x0075) Site­com WLA-3100
USB_DEVICE (0x2019:0xab31) Planex GW-450D
USB_DEVICE (0x2001:0x3d02) D‑LINK DWA-171 rev B1
USB_DEVICE (0x0586:0x3425) Zyxel NWD6505
USB_DEVICE (0x07b8:0x7610) Abo­Com AU7212
USB_DEVICE (0x04bb:0x0951) I‑O DATA WN-AC433UK
USB_DEVICE (0x057c:0x8502) AVM FRITZ!WLAN USB Stick AC 430 (not working)
USB_DEVICE (0x293c:0x5702) Com­cast Xfi­ni­ty KXW02AAA
USB_DEVICE (0x20f4:0x806b) TREND­net TEW-806UBH
USB_DEVICE (0x7392:0xc711) Devo­lo Wifi ac Stick
USB_DEVICE (0x0df6:0x0079) Site­com Euro­pe B.V. ac Stick
USB_DEVICE (0x2357:0x0105) TP-LINK Archer T1U

Die Funk­ti­on ist bei jedem der genann­ten USB-Wifi-Adap­ter garan­tiert. Ich selbst habe nur den WLAN-Adap­ter TP-Link TL-WDN5200 T2U aus­pro­biert (USB-ID 0x148f:0x761a). Der AVM FRITZ!WLAN USB Stick AC 430 ver­wen­det den glei­chen Chip­satz, funk­tio­niert jedoch mit die­sem Trei­ber nicht und auch sonst mit kei­nem bekann­ten Trei­ber. Die Ursa­che dafür ist bis­her nicht bekannt.

Variante 1: Module auf dem Raspberry Pi kompilieren

Ich gehe davon aus, dass auf dem Raspber­ry Pi die aktu­el­le Ver­si­on von Ras­pian instal­liert ist. Zur­zeit (Janu­ar 2019) ist das Ras­pian Stretch mit Ker­nel 4.14.

Sie benö­ti­gen zuerst den Quell­code des lau­fen­den Ker­nels. Aller erfor­der­li­chen Schrit­te füh­ren Sie in einem Ter­mi­nal­fens­ter durch.

Aktua­li­sie­ren Sie das Sys­tem mit

sudo apt update -y
sudo apt upgrade -y

Optio­nal lässt sich der Ker­nel auf die aktu­ells­te Ver­si­on brin­gen. Dazu ver­wen­den Sie im Ter­mi­nal­fens­ter die Befehls­zei­le

sudo rpi-update

Star­ten Sie den Raspber­ry Pi danach neu. Instal­lie­ren Sie vier erfor­der­li­che Pake­te:

sudo apt install git bc bison flex libproc-processtable-perl

Füh­ren Sie fol­gen­de vier Befehls­zei­len im Home-Ver­zeich­nis /home/pi aus:

cd ~
sudo wget https://raw.githubusercontent.com/notro/rpi-source/master/rpi-source -O /usr/bin/rpi-source
sudo chmod +x /usr/bin/rpi-source
/usr/bin/rpi-source -q --tag-update
rpi-source

Der zum lau­fen­den Ker­nel pas­sen­de Ker­nel-Quell­code liegt jetzt bei­spiels­wei­se im Ord­ner „/ho­me/pi/­li­nux-36612­d5­d7a88672a3e7d­d6c­b458dbbb­ca0­d75e­fe“. Der Hash-Wert entspicht dem vom Script in „Vari­an­te 2“ ermit­tel­ten Wert für den Ker­nel-Hash. Es gibt außer­dem den Sym­link „/home/pi/linux“ der auf den Ord­ner mit den Ker­nel-Quel­len ver­weist.

rpi-source hat die Ker­nel-Quel­len bereits für die Verr­wen­dung vor­be­rei­tet. Das ist dar­an zu erken­nen, dass die Datei­en „.con­fig“ und „Module.symvers“ vor­han­den sind. Es gibt außer­dem die Sym­links „/lib/modules/4.14.79-v7+/build“ und „/lib/modules/4.14.79-v7+/source“, die jeweils auf das Ver­zeich­nis „/home/pi/linux“ ver­wei­sen.

Trei­ber-Quell­code her­un­ter­la­den und kom­pi­lie­ren: Erstel­len Sie ein Arbeits­ver­zeich­nis, laden Sie den Quell­code des Trei­bers her­un­ter und kom­pi­lie­ren Sie ihn:

mkdir ~/src
cd ~/src
git clone https://github.com/Myria-de/mt7610u.git
cd mt7610u
ARCH=arm make -j4

Bit­te beach­ten Sie, dass die­se Arbei­ten ohne root-Rech­te durch­ge­führt wer­den, also ohne vor­an­ge­stell­tes „sudo“. Das ist siche­rer, falls ein Build-Script ver­su­chen soll­te, Sys­tem­da­tei­en  zu erset­zen.

Das Ker­nel-Modul „mt7610u.ko“ liegt danach im Ord­ner „/home/pi/src/mt7610u“. Instal­lie­ren Sie die Firm­ware-Datei „mt7610u.bin“ und laden Sie das Modul mit die­sen zwei Befehls­zei­len:

sudo ARCH=arm make installfw
sudo insmod mt7610u.ko

Ver­bin­den Sie den WLAN-Stick mit dem Raspber­ry Pi. Mit dem Befehl

dmesg

sehen Sie sich die Log-Aus­ga­ben an. Es erschei­nen Ein­trä­ge, die auf die kor­rek­te Funk­ti­on des Gerä­tes hin­wei­se. Auch ein paar Feh­ler­mel­dun­gen sind dabei, die sind aber unkri­tisch.

Wenn alles zufrie­den­stel­lend läuft instal­lie­ren Sie das neue Ker­nel-Modul mit

sudo ARCH=arm make install

Star­ten Sie den Raspber­ry Pi neu. Das Modul „mt7610u.ko“ wird jetzt auto­ma­tisch gela­den.

Die WLAN-Ver­bin­dung lässt sich über das Netz­werk-Icon in der Leis­te am obe­ren Bild­schirm­rand her­stel­len.

Variante 2: Cross-Compile-Script zum Erstellen der Kernel-Module verwenden

Ker­nel-Modu­le für den Raspber­ry Pi las­sen sich auch auf einem ande­ren Linux-PC erstel­len. Am ein­fachs­ten ist es, Ubun­tu 14.04 oder 18.04 (nur 64-Bit) zu ver­wen­den. Die Ent­wick­lung ist auch in einer vir­tu­el­len Maschi­ne mög­lich, etwa in Vir­tu­al­box. Alle nöti­gen Down­loads und Schrit­te habe ich in einem Script zusam­men­ge­fasst. Das Script eig­net sich für den Raspber­ry Pi 2/3 (armv71).

Beim Cross-kom­pi­lie­ren ist ein gewis­ser Auf­wand nötig, denn der etwa bei Ubun­tu instal­lier­te Com­pi­ler kann stan­dard­mä­ßig kei­ne Pro­gram­me oder Trei­ber für die ARM-Plat­form des Raspber­ry Pi erzeu­gen. Es ist daher zusätz­lich Soft­ware nötig. Dafür läuft der Build-Vor­gang auf einen durch­schnitt­li­chen PC unter Linux aber deut­lich schnel­ler ab, als direkt auf dem Raspber­ry Pi.

Ich erläu­te­re das Ver­fah­ren am Bei­spiel des Ker­nel Moduls für den WLAN-USB-Stick TP-Link AC900. Wie sich das Ker­nel-Modul dafür unter und für Ubun­tu erstel­len lässt, habe ich im Arti­kel TP-Link Archer T2U AC600 unter Linux nut­zen beschrie­ben.

Im Prin­zip funk­tio­niert es so oder ähn­lich für jeden Trei­ber, des­sen Quell­code ver­füg­bar ist.

Ker­nel und GCC-Ver­si­on ermit­teln: Ker­nel-Quell­code und gcc-Ver­si­on soll­ten für das ver­wen­de­te Script zur Ver­si­on des auf dem Raspber­ry Pi lau­fen­den Linux-Ker­nels pas­sen. Infor­ma­tio­nen dazu fin­den Sie über die bei­den Befehls­zei­len

cat /proc/version
gcc --version

Die ers­te Zei­le gibt bei­spiels­wei­se fol­gen­des aus:

Linux ver­si­on 4.14.79-v7+ (dc4@dc4-XPS13-9333) (gcc ver­si­on 4.9.3 (cross­tool-NG crosstool-ng‑1.22.0–88-g8460611)) #1159 SMP Sun Nov 4 17:50:20 GMT 2018

Die Ker­nel-Ver­si­on ist hier „4.14.79-v7+“. Außer­dem sehen Sie, dass der Ker­nel mit dem Com­pi­ler GCC Ver­si­on 4.9.3 und cross­tool-NG crosstool-ng‑1.22.0–88-g8460611 erstellt wur­de. Die Aus­ga­be von „gcc –ver­si­on“ lau­tet bei­spiels­wei­se „gcc‑7.3.0“, was dann nicht zum instal­lier­ten Ker­nel pas­sen wür­de.

Die Aus­ga­be „cross­tool-NG“ weist dar­auf hin, dass der Ker­nel nicht auf einem Raspber­ry Pi kom­pi­liert wur­de. Statt­des­sen kam eine Cross­com­pi­le-Umge­bung zum Ein­satz, die sich auf jedem belie­bi­gen Linux-PC ein­rich­ten lässt.

Wel­cher Ker­nel genau instal­liert ist, lässt sich über die Datei „/usr/share/doc/raspberrypi-bootloader/changelog.Debian.gz“ ermit­teln. Dar­in steht ein Firm­ware-Hash-Wert aus dem sich der Ker­nel-Hash und damit die Down­load-URL bei https://github.com/raspberrypi/linux.git für die­sen Ker­nel ergibt.

SSH-Ver­bin­dung tes­ten: Stel­len Sie sicher, dass Sie Ihren Raspber­ry Pi über ssh errei­chen kön­nen:

ssh pi@192.168.0.17

Erset­zen Sie die IP-Num­mer durch die IP Ihres Raspber­ry Pi. Bestä­ti­gen Sie den Schlüs­sel mit yes und geben Sie das Pass­wort ein. Prü­fen Sie bei der Gele­gen­heit, ob die Datei „/proc/config.gz“ vor­han­den ist:

zcat /proc/config.gz

Wenn Sie die Feh­ler­mel­dun­gen „gzip: /proc/config.gz: No such file or direc­to­ry“ erhal­ten. Star­ten Sie

sudo modprobe configs

Danach ist „/proc/config.gz“ vor­han­den. Been­den Sie die SSH-Ver­bin­dung mit exit.

Script vor­be­rei­ten: Laden Sie „raspi_crosstools.sh“ her­un­ter (sie­he unten auf die­ser Sei­te) und spei­chern bezie­hungs­wei­se ent­pa­cken Sie die Datei in Ihr Home-Ver­zeich­nis auf dem (Ubuntu-)PC. Machen Sie die Datei mit fol­gen­dem Befehl aus­führ­bar:

chmod 755 raspi_crosstools.sh

Öff­nen Sie raspi_crosstools.sh in einem Edi­tor. Pas­sen Sie den Abschnitt unter­halb von „Kon­fi­gu­ra­ti­on“ an. Tra­gen Sie hin­ter die Varia­blen den Benut­zer­na­men („RASPI_USER=“), das Pass­wort („RASPI_PWD=“) und die IP-Adres­se ein („RASPI_IP=“).

Der hin­ter „USE_THREADS=“ ein­ge­tra­ge­ne Wert „-j4“ bestimmt die Anzahl der Threads, die der Com­pi­ler ver­wen­den soll. Bei einem Intel Core i7 kön­nen Sie auch „-j8“ ein­tra­gen. Das Com­pi­lie­ren geht dann schnel­ler. Bei lang­sa­me­ren CPUs las­sen Sie den Wert leer
Star­ten Sie das Script dann mit

./raspi_crosstools.sh

So arbei­tet das Script: Das Bash-Script prüft zunächst, ob die nöti­gen Ent­wick­ler­pa­ke­te auf dem Linux-Sys­tem instal­liert sind und instal­liert sie bei Bedarf. Danach haben Sie die Wahl, ob Sie eine mini­ma­le (schnel­ler) oder vol­le (lang­sa­mer) Kom­pi­la­ti­on des Ker­nels wün­schen. In der Regel soll­te eigent­lich eine mini­ma­le Kon­fi­gu­ra­ti­on des Ker­nels genü­gen. Als Cross-Com­pi­ler kommt die glei­che Ver­si­on zum Ein­satz, die die Ent­wick­ler des Raspbi­an-Ker­nels ver­wen­det haben (https://github.com/raspberrypi/tools).

Das Pro­blem dabei: Sie benö­ti­gen die Datei „Module.symvers“ von github.com/raspberrypi/firmware. Als ich das Script geschrie­ben habe, lag hier für den Ker­nel 4.1.6‑v7+ noch eine ver­al­te­te Ver­si­on. In die­sem Fall müs­sen Sie „Voll“ wäh­len. Dabei wird die Datei „Module.symvers“ neu erstellt. Das ist also der siche­re­re Weg. Mit der fal­schen „Module.symvers“ ver­wei­gert der Ker­nel des Raspber­ry Pi spä­ter das Modul zu laden. Es erscheint dann eine Feh­ler­mel­dung wie „mt7650u_sta: dis­agrees about ver­si­on of sym­bol module_layout“.

Im nächs­ten Schritt ermit­telt das Script, wel­cher Ker­nel auf dem Raspber­ry Pi instal­liert ist und lädt dann den Quell­code des Ker­nels her­un­ter. Außer­dem wer­den die Tools für den Cross-Com­pi­ler und die Quel­len des Trei­bers her­un­ter­ge­la­den. Alle Datei­en lan­den im Ver­zeich­nis „~/raspi_cross“.

Ker­nel-Modul auf dem Raspber­ry Pi instal­lie­ren: Der Ker­nel und die Modu­le wer­den dann kom­pi­liert. Nach Abschluss kopiert das Script das Modul und zwei Bash-Scrip­te in das Home-Ver­zeich­nis „/home/pi“ auf den Raspber­ry Pi. Machen Sie „install_driver.sh“ und „un-install_driver.sh“ jeweils mit chmod 755 aus­führ­bar. Mit

sudo ./install_driver.sh

instal­lie­ren Sie das Modul und mit sudo ./un-install_driver.sh ent­fer­nen Sie es wie­der. Mit dmesg prü­fen Sie, ob der Ker­nel das Modul kor­rekt gela­den hat.

Script anpas­sen: Wenn Sie ein ande­res Ker­nel-Modul für den Raspber­ry Pi erstel­len möch­ten, sind eini­ge Anpas­sun­gen im Script nötig. Ändern Sie die Down­load-Adres­se unter dem Kom­men­tar „Trei­ber her­un­ter­la­den“ und die Anwei­sun­gen unter „Ker­nel-Modul com­pi­lie­ren“. Pas­sen Sie außer­dem den Abschnitt „Datei­en auf den Raspi kopie­ren“ an.

Hin­wei­se: Das Script fragt nicht ab, ober Ker­nel oder Modul bereits zuvor com­pi­liert wur­den. Es star­tet immer mit einer fri­schen Kon­fi­gu­ra­ti­on („make clean“). So ist es siche­rer aber es kos­tet mehr Zeit. Wenn Sie das nicht wün­schen, kom­men­tie­ren Sie bei­spiels­wei­se den Block unter „Ker­nel vorbereiten/compilieren“ aus. Dann wird nur das Modul neu erstellt.

Soll­te nach einem Update einer neu­er Ker­nel auf dem Raspber­ry Pi instal­liert wer­den, müs­sen Sie den kom­plet­ten Vor­gang wie­der­ho­len. In die­sem Fall löschen Sie das Ver­zeich­nis „raspi_cross“ und star­ten wie­der das Script raspi_crosstools.sh. Es lädt dann die aktu­el­len, bezie­hungs­wei­se pas­sen­den, Ker­nel-Quel­len her­un­ter und erzeugt ein neu­es Ker­nel-Modul.

WLAN auf dem Raspberry Pi manuell einrichten (optional)

Prü­fen Sie nach erfolg­ter Modu­l­in­stal­la­ti­on auf dem Raspber­ry Pi mit dem Befehl ap addr in einem Ter­mi­nal­fens­ter, ob das Netz­werk­ge­rät vor­han­den ist. Im der Aus­ga­be soll­te das Gerät wlan0 oder ra0 auf­tau­chen (je nach Trei­ber). Suchen Sie nach WLAN-Netz­wer­ken mit fol­gen­der Befehls­zei­le:

sudo iwlist wlan0 scan

Tau­chen hier Netz­wer­ke mit der Anga­be etwa von „Frequency:5.22 GHz“ auf, funk­tio­niert auch 5 GHz.

Die WLAN-Kon­fi­gu­ra­ti­on erfolgt am ein­fachs­ten und zuver­läs­sigs­ten auf der Kom­man­do­zei­le in einem Ter­mi­nal­fens­ter. Ändern sie zunächst mit sudo nano /etc/network/interfaces die Kon­fi­gu­ra­ti­on der Netz­werk-Gerä­te. Die Datei kann danach so aus­se­hen:

auto lo
iface lo inet loopback
iface eth0 inet manual
allow-hotplug wlan0
iface ra0 inet manual
wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf

Ver­wen­den Sie den Befehl

sudo nano /etc/wpa_supplicant/wpa_supplicant.conf

Hier tra­gen Sie zusätz­lich bei­spiels­wei­se fol­gen­des ein:

network={
        ssid="Meine_SSID"
        psk="1234567890"
        key_mgmt=WPA-PSK
}

Die Anga­ben hin­ter „ssid=“ und „psk=“ ändern Sie pas­send für Ihr Netz­werk.

Star­ten Sie den Raspber­ry Pi neu (sudo reboot). Die Ver­bin­dung zum WLAN-Netz­werk erfolgt jetzt auto­ma­tisch.

Crosscompile-Script für Raspberry-Pi-Module

Und hier das Script. Fah­ren Sie mit der Maus in den Script-Block und kli­cken Sie auf das ers­te Icon, um das Script im Text­mo­dus zu sehen. Oder laden Sie das Script raspi_crosstools.sh als ZIP-Datei her­un­ter.

#!/bin/bash

#########################
##    Konfiguration    ##
#########################
#
# IP-Adresse, Benutzername und Passwort des Raspberry Pi
# Das Gerät muss über ssh erreichbar sein
# Testen Sie das zuerst mit ssh pi@IP-Adresse
#
RASPI_USER=pi
RASPI_PWD=geheim
RASPI_IP=192.168.178.XX
# beispielsweise 192.168.0.17

# USE_THREADS= #langsame/ältere CPUs
# Beschleunigt das Compilieren bei Multicore-CPUs deutlich
USE_THREADS=-j4 # schnelle/neuere CPUs oder -j8 (mehr threads, schneller)
#
#DRIVERDIR=mt7610u-linksys-ae6000-wifi-fixes
#  Kernel 4.1
#DRIVERDIR=mt7610u_wifi_sta_v3002_dpo_20130916
#DRIVERFILE=mt7610u_sta.ko
#DRIVERNAME=mt7610u_sta
#GITCLONE=" -b raspberry https://github.com/Myria-de/$DRIVERDIR.git"
#NEWCONFIG=0

#Kernel 4.14
DRIVERDIR=mt7610u
DRIVERFILE=mt7610u.ko
DRIVERNAME=mt7610u
NEWCONFIG=1
GITCLONE=" -b raspberry https://github.com/Myria-de/$DRIVERDIR.git"
#GCCDIR="/home/te/raspi_cross/tools/arm-bcm2708/arm-linux-gnueabihf/bin/arm-linux-gnueabihf-"
#GCCDIR="/home/te/raspi_cross/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian-x64/#bin/arm-linux-gnueabihf- bcm2709_defconfig"

#########################
## Konfiguration Ende ##
#########################

KERNEL_HASH=
FIRMWARE_HASH=

HOMEDIR=`pwd`
WORKDIR=$HOMEDIR/raspi_cross
DRIVERBIN=$WORKDIR/$DRIVERDIR/$DRIVERFILE

# Pfad zum 64-Bit-Cross-Compiler, 32 Bit wird nicht unterstützt
export PATH=$WORKDIR/tools/arm-bcm2708/arm-linux-gnueabihf/bin:$PATH

if [ `getconf LONG_BIT` = "64" ]
then
    HOSTARCH=64
else
    HOSTARCH=32
fi

if [ $HOSTARCH = 32 ]
then
echo
echo "Das Script funktioniert nur unter einem 64-Bit-System"
echo "Abbruch."
echo
exit 1
fi


#####################################
## Dateien auf den Raspi kopieren ###
#####################################
put_file_to_raspi() {
#cd $WORKDIR/$DRIVERDIR/os/linux
if [ -e $DRIVERBIN ]
then
echo Kopiere Datei auf den Raspberry Pi
lftp sftp://$RASPI_USER:$RASPI_PWD@$RASPI_IP -e "put $DRIVERBIN; bye"
cd $WORKDIR/$DRIVERDIR
lftp sftp://$RASPI_USER:$RASPI_PWD@$RASPI_IP -e "put RT2870STA.dat; bye"
else
echo Fehler. Nicht gefunden: $DRIVERBIN
exit 1 
fi
cd $WORKDIR
cat<<EOF>${WORKDIR}/un-install_driver.sh
#!/bin/bash
[ \$UID -ne 0 ] && { 
    echo "Fehler: Das Script benötigt root-Rechte."
    echo "Aufruf mit mit sudo $0"
    exit 1
}
OSVERSION=\`uname -r\`
echo Entlade Modul $DRIVERFILE
rmmod $DRIVERNAME
echo Lösche Modul /lib/modules/\${OSVERSION}/extra/$DRIVERFILE
rm /lib/modules/\${OSVERSION}/extra/$DRIVERFILE
echo Lösche Konfiguration /etc/Wireless/RT2870STA/RT2870STA.dat
rm /etc/Wireless/RT2870STA/RT2870STA.dat
echo Aktualisiere Module...
depmod -a
echo Sie können das Verzeichnis /etc/Wireless jetzt komplett löschen
echo Fertig!
EOF

cat<<EOF>${WORKDIR}/install_driver.sh
#!/bin/bash
[ \$UID -ne 0 ] && { 
    echo "Fehler: Das Script benötigt root-Rechte."
    echo "Aufruf mit mit sudo \$0"
    exit 1
}
OSVERSION=\`uname -r\`
NEWCONFIG=$NEWCONFIG

mkdir -p /etc/Wireless/RT2870STA
mkdir -p /lib/modules/\$OSVERSION/extra
echo Kopiere Modul nach /lib/modules/\${OSVERSION}/extra/$DRIVERFILE
cp $DRIVERFILE /lib/modules/\${OSVERSION}/extra/$DRIVERFILE
if [ \$NEWCONFIG = 0 ]
then
echo Kopiere Konfigration nach /etc/Wireless/RT2870STA/RT2870STA.dat
cp RT2870STA.dat /etc/Wireless/RT2870STA/RT2870STA.dat
fi
echo Aktualisiere Module...
depmod -a
echo lade Modul $DRIVERFILE
modprobe $DRIVERNAME
echo Fertig!
EOF
chmod 755 install_driver.sh
chmod 755 un-install_driver.sh

# Datei uebertragen
echo Kopiere Datei install_driver.sh auf $RASPI_IP
lftp sftp://$RASPI_USER:$RASPI_PWD@$RASPI_IP -e "put install_driver.sh; bye"
lftp sftp://$RASPI_USER:$RASPI_PWD@$RASPI_IP -e "put un-install_driver.sh; bye"
}

# Konfigurations-Dateien vom Raspberry Pi holen
get_files_from_raspi() {
cd $WORKDIR

# Alte Dateien löschen
if [ -e changelog.Debian.gz ]
then
rm changelog.Debian.gz
fi

if [ -e config.gz ]
then
rm config.gz
fi

if [ -e Module.symvers ]
then
rm Module.symvers
fi

echo Download changelog.Debian.gz vom Raspberry Pi $RASPI_IP
lftp sftp://$RASPI_USER:$RASPI_PWD@$RASPI_IP -e "get -e /usr/share/doc/raspberrypi-bootloader/changelog.Debian.gz; bye"
FIRMWARE_HASH=$(zgrep "* firmware as of" changelog.Debian.gz | head -1 | awk '{ print $5 }')
echo Firmware-Hash: $FIRMWARE_HASH
#
# hier bei Bedarf einen eigenen Hash-Wert eintragen
# wenn nicht der Standard-Kernel, wie in raspberrypi-bootloader/changelog.Debian.gz
# abgelegt, zum Einsatz kommmt.
# die Hash-Werte sind unter https://github.com/raspberrypi/firmware/commits/ zu finden
# Beispielsweise "kernel: Bump to 4.1.15" unter
# https://github.com/raspberrypi/firmware/commit/22d8c910f4c53118f9cf85c038d7d8e307efc110 
# 
#4.1.15
#FIRMWARE_HASH=c22d8c910f4c53118f9cf85c038d7d8e307efc110
#4.1.20
#FIRMWARE_HASH=37f187cd887f67235f3b84e0a2cd67807196c70f
#7f30737678023b5becaf0e2e012665f71b886a7d

#c37f187cd887f67235f3b84e0a2cd67807196c70f
#FIRMWARE_HASH=4bf906cdd221c4f6815d0da7dda0cd59d25d945b

#3.18.13
#FIRMWARE_HASH=9354845ea5a961f267bcf440f92c9bd21be29b35
#git hash
#3.18.11
#8362c08dfc8dd9e54745b3f1e5e4ff0a1fb30614

echo Hole $FIRMWARE_HASH/
KERNEL_HASH=$(wget https://raw.github.com/raspberrypi/firmware/$FIRMWARE_HASH/extra/git_hash -O -)
echo Kernel-Hash ist: $KERNEL_HASH

echo Download config.gz vom Raspberry Pi $RASPI_IP
lftp sftp://$RASPI_USER:$RASPI_PWD@$RASPI_IP -e "get -e /proc/config.gz; bye"

# Version des Kernels ermittlen (für PI/PI2)
STR=$(zgrep "CONFIG_LOCALVERSION" config.gz | head -1)
LOCALVERSION=${STR#*=} #string part after =
LOCALVERSION="${LOCALVERSION//\"}" #remove quotes
if [ "$LOCALVERSION" == "-v7" ]
then
echo "Raspberry PI 2 gefunden (armv71)"
RASPI_MODEL=armv71
else
echo "Raspberry PI gefunden (armv61)"
RASPI_MODEL=armv61
fi

# hier sollte die Datei Module.symvers für den aktuellen Kernel liegen 
if [ $RASPI_MODEL = armv71 ]
then
echo Download Module7.symvers
wget https://raw.github.com/raspberrypi/firmware/$FIRMWARE_HASH/extra/Module7.symvers -O Module.symvers 
else
echo Download Module.symvers
wget https://raw.github.com/raspberrypi/firmware/$FIRMWARE_HASH/extra/Module.symvers -O Module.symvers 
fi

if [ ! -e changelog.Debian.gz ]
then
echo "Fehler: changelog.Debian.gz nicht gefunden"
return 0
fi

if [ ! -e config.gz ]
then
echo "Fehler: config.gz nicht gefunden"
return 0
fi

return 1
}

##############################
## Das Script startet hier ###
##############################

echo "Prüfe Voraussetzungen..."
if [ ! -d /usr/share/build-essential ]
then
sudo apt-get update
sudo apt-get build-essential
echo "OK" > prep_ok
fi 

#git ?
if [ -z $(which git) ]
then
echo "Installiere git"
sudo apt-get -y install git
fi

# dialog?
if [ -z $(which dialog) ]
then
echo "Installiere dialog"
sudo apt-get -y install dialog
fi

# lftp?
if [ -z $(which lftp) ]
then
echo "Installiere lftp"
sudo apt-get -y install lftp
fi

if [ -z ${RASPI_IP} ]
then
MSG="Die IP-Adresse des Raspberry Pi ist nicht konfiguriert.\n"\
"Bitte öffnen Sie dieses Script zuerste in einem Editor"\
" und passen Sie die Konfiguration an.\n"\
"Abbruch!"

dialog --title "Konfiguration" --msgbox "${MSG}" 10 50
exit 1
fi	

MSG="Dises Script erstellt ein Kernel Modul für den Raspberry Pi.\n"\
"Als Beispiel wird ein Modul für den USB-WLAN-Stick TP-Link AC900 erstellt."\
" Passen Sie zuerst im Script den Abschitt Konfiguration an."\
" Wenn das noch nicht erledigt ist, gehen Sie auf 'Abbrechen'\n"\
"Bei 'Weiter' lädt das Script den zu Ihrem Raspberry Pi passenden Kernel,"\
"einige Tools und den Treiber-Quellcode herunter. Das kann einige Zeit dauern..."

dialog --title "Module erstellen" --yes-label "Weiter" --no-label "Abbrechen" --yesno "${MSG}" 13 60

if [ "$?" != "0" ]
then
echo "Abbruch!"
exit 0
fi	

MSG="Für die Kernel-Module ist die Datei 'Module.symvers' nötig.\n"\
"Die Datei ist auf 'raw.github.com/raspberrypi/firmware' verfügbar."\
" Wenn die Datei heruntergeladen werden soll, wählen Sie 'Minimal'.\n"\
"Manchmal liegt hier aber nicht die aktuelle Datei."\
" Dann schlägt das Laden des Moduls auf dem Rapberry Pi fehl."\
" In diesem Fall müssen Sie Kernel und Module komplett erstellen, wobei die Datei erzeugt wird."\
" Das dauert länger, sollte aber in jedem Fall ein passendes Modul erzeugen."

dialog --title "Modus wählen" --yes-label "Minimal" --no-label "Voll" --yesno "${MSG}" 15 60
if [ "$?" != "0" ]
then
MODE=full
else
MODE=min
fi	

if [ ! -d $WORKDIR ]
then
mkdir $WORKDIR
fi
cd $WORKDIR

# Konfigurations-Dateien vom Raspberry Pi holen
get_files_from_raspi

if [ ! -e config.gz ]
then
MSG="config.gz nicht auf dem Rapberry Pi gefunden\n"\
"oder es konnte keine SSH-Verbindung hergestellt werden.\n"\
"Testen Sie ssh pi@$RASPI_IP.\n"\
"Führen Sie aßerdem auf dem Gerät zuerst 'sudo modeprobe configs' aus.\n"\
"Prüfen Sie, ob zcat /proc/config.gz den Inhalt der Datei ausgibt.\n"\
"Abbruch!"

dialog --title "config.gz" --msgbox "${MSG}" 10 50
exit 1
fi
echo Kernel-Hash: $KERNEL_HASH

if [ ! -d $WORKDIR/kernel ]
then
echo "Lade Kernel herunter"
git clone https://github.com/raspberrypi/linux.git kernel
echo Checkout Kernel ${KERNEL_HASH}
cd $WORKDIR/kernel
git checkout $KERNEL_HASH
fi
cd $WORKDIR
if [ ! -e kernel/.config ]
then
echo Kopiere .config
gunzip -c config.gz > kernel/.config
fi

if [ ! -d $WORKDIR/tools ]
then
echo "Lade Tools herunter"
git clone https://github.com/raspberrypi/tools
fi 
#########################
# Treiber herunterladen #
#########################
if [ ! -d $WORKDIR/$DRIVERDIR ]
then
echo "Lade Treiber herunter"
git clone $GITCLONE
#git clone -b raspberry https://github.com/Myria-de/$DRIVERDIR.git
fi 

# Crosscompile-Umgebung vorbereiten
if [ $HOSTARCH = 64 ]
then
export CCPREFIX=arm-linux-gnueabihf- bcm2709_defconfig
else
# nicht mehr unterstützt
export CCPREFIX=$WORKDIR/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin/arm-linux-gnueabihf-
fi
echo
echo "Verwende Compiler $CCPREFIX"
echo
 
export ARCH=arm
export CROSS_COMPILE=${CCPREFIX}
export KERNEL_SRC=$WORKDIR/kernel
echo "Erstelle Kernel..."
cd $WORKDIR/kernel

if [ -e $WORKDIR/config.gz ]
then
if [ ! -e $WORKDIR/config.gz ] 
then
zcat $WORKDIR/config.gz > $WORKDIR/kernel/.config
fi
else
echo $WORKDIR/config.gz ist nicht vorhanden. Abbruch.
exit 1
fi

if [ -e $WORKDIR/Module.symvers ]
then
cp $WORKDIR/Module.symvers $WORKDIR/kernel/Module.symvers
else
echo $WORKDIR/Module.symvers ist nicht vorhanden. Abbruch.
exit 1
fi

####################################
## Kernel vorbereiten/compilieren ##
####################################
if [ $MODE = "min" ]
then
make oldconfig
make prepare
make scripts
else
make clean
make oldconfig
make prepare
make $USE_THREADS
fi

##############################
## Kernel-Modul compilieren ##
##############################
echo Erstelle Treiber
cd $WORKDIR/$DRIVERDIR
make clean
make $USE_THREADS

if [ -e $DRIVERBIN ]
then
put_file_to_raspi
else
echo
echo $DRIVERBIN
echo ist nicht vorhanden.
echo Die Compilation ist fehlgeschlagen.
echo Bitte prüfen Sie Ihre Konfiguration.
fi
echo
echo Fertig!
echo
echo Zusammenfassung/Summary
echo Firmware-Hash: $FIRMWARE_HASH
echo Kernel-Hash: $KERNEL_HASH
echo Raspberry-Modell:$RASPI_MODEL
echo Modul: $DRIVERFILE

Netzwerkleistung mit iperf messen

Zuver­läs­sig­keit und Geschwin­dig­keit Ihres Netz­wer­kes ermit­teln Sie mit Tool iperf. Instal­lie­ren Sie es auf dem Raspber­ry Pi und einem ande­ren PC im Netz­werk in einem Ter­mi­nal­fens­ter mit

 sudo apt-get install iperf

Star­ten Sie auf dem Raspber­ry Pi

iperf -s

Das Tool lauscht nun auf dem TCP-Port 5001. Star­ten Sie auf einem ande­ren PC den Test mit die­ser Befehls­zei­le:

iperf -c Server-IP -d 

Erset­zen Sie Ser­ver-IP durch die tat­säch­li­che IP-Adres­se des Ser­vers. Iperf sen­det und emp­fängt nun zehn Sekun­den lang Daten und zeigt anschlie­ßend das Ergeb­nis im Ter­mi­nal. Der Para­me­ter „-d“ tes­tet simul­tan den Daten­durch­satz in bei­den Rich­tun­gen. In der Aus­wer­tung zeigt der ers­te Wert die Ver­bin­dung vom Cli­ent zum Ser­ver (Uplink), der zwei­te den Durch­satz vom Ser­ver zum Cli­ent.

Die Bedie­nung von Iperf wird durch das gra­fi­sche Front­end Jperf erleich­tert. Es zeigt die Mess­ergeb­nis­se in einem Dia­gramm und ver­mit­telt so einen bes­se­ren Ein­druck von der Trans­fer­ra­te. Jperf benö­tigt eine Java-Lauf­zeit­um­ge­bung. Instal­lie­ren Sie die­se bei­spiels­wei­se unter Ubun­tu mit fol­gen­der Befehls­zei­le:

sudo apt install default-jre

Laden Sie Jperf über https://www.pcwelt.de/1735757 her­un­ter. Ent­pa­cken Sie das ZIP-Archiv und wech­seln Sie im Ter­mi­nal­fens­ter mit cd in das Ver­zeich­nis, in das Sie Jperf ent­packt haben. Star­ten Sie das Tool mit

sh jperf.sh

Wäh­len Sie die Opti­on „Ser­ver“, und kli­cken Sie auf „Run Iperf!“. Auf einem ande­ren PC im Netz­werk rich­ten Sie Jperf eben­falls ein. Hier wäh­len Sie die Opti­on „Cli­ent“ und geben dahin­ter die IP-Adres­se des Ser­vers ein. Hin­ter „Out­put For­mat“ stel­len Sie „MBits“ ein. Kli­cken Sie auf „Run Iperf!“. Das Tool zeigt Ihnen die Text-Aus­ga­be von iperf an und stellt die Daten in einem Dia­gramm dar.

Die fol­gen­den Mes­sun­gen stam­men aus einen 2,4- und 5 GHz-WLAN (802.11n), also nicht aus einem Netz­werk mit 802.11ac-Router (zur­zeit ist kei­ner ver­füg­bar).