[Tut] Eigene Treiber in den Android-Kernel einbinden, am Beispiel Treiber für USB-LAN

[Kiwi++Soft]

Tutorial: Eigene Treiber in den Android-Kernel einbinden, am Beispiel Treiber für USB-LAN Adapter

Ich habe hier ein Tutorial, das zeigt, wie leicht man eigene Hardware Treiben in einen Android-Kernel einbauen kann. Ich zeige das am Beispiel von einem USB-LAN-Adapter-Treiber, so dass ich anschliessend mit meinem Gerät Netzwerk-Zugriff über LAN habe.

Vorweg möchte ich betonen, dass ich das hier beschriebene Unterfangen bereits in der Praxis durchgeführt habe. Jegliche Diskussionen ob das funktioniert oder nicht sind damit hinfällig.

Das diese Prozedur jedoch hochgradig Geräte-Abhängig ist, kann es sein, dass es im Einzelfall für das eine oder andere Gerät nicht funktioniert, da entweder die Kernel-Sourcen nicht vom Hersteller angeboten werden, oder die Hardware des Gerätes nicht geeignet sein könnte.

Ein Beispiel für einen Custom-Kernel, der USB-LAN-Adapter Support hat, ist der von mir angebotene Kiwi++Kernel

Folgende Schritte sind für die Integration von USB-LAN-Support notwendig:

• [Post=8169840]Notwendige Vorbereitung auf dem PC[/POST].
  • [Post=8282029]Linux installieren[/POST].
  • [Post=8281733]Einrichten der Build-Umgebung[/POST].
• [Post=8282646]Kernel Sourcen und Konfiguration bereitstellen[/POST].
  • [Post=8282190]Herunterladen der Kernel-Sourcen[/POST].
  • [Post=8282647]Kernel-Konfiguration auslesen[/POST].
• [Post=8282132]Geeigneten USB-LAN-Adapter auswählen[/POST].
  • [POST=8282625]Treiber, die bereits im Kernel-Source-Tree enthalten sind, finden[/POST].
  • [POST=8282876]Linux-Treiber für LAN-Adapter in den Kernel integrieren[/POST].
• [POST=8282939]Ein neues Boot-Image erstellen[/POST].
  • [POST=8283030]Das aktuelle Boot-Image entpacken[/POST].
  • [POST=8283112]Neuen Kernel erstellen[/POST].
  • [POST=8283244]Das Boot-Image zusammensetzen[/POST].
• [POST=8283248]Netzwerk-Konfiguration[/POST].
  • ...

Es gibt sicher auch andere Möglichkeiten, das ganze Projekt durchzuführen. Ich habe aber das Projekt auf genau die hier beschriebene Art durchgeführt, und werde keinen Support für andere Variationen bieten.

Insbesondere werde ich keinen Support für andere Umgebungen als die hier beschriebene bieten.

 

[Kiwi++Soft]

Notwendige Vorbereitung auf dem PC:

Eine Grundvoraussetzung ist, dass man einen Kernel kompilieren kann. Dazu benötigt man einen PC mit Linux (Es bestehen eventuell auch andere Möglichkeiten, auf die ich hier allerdings nicht eingehen möchte.)

Dazu hat zwei verschiedene Möglichkeiten:

• Linux in einer eigenen Partition installieren
• Linux in einer virtuellen Maschine installieren

Da man oftmals keine eigene Partition für Linux frei hat, ist die Installation in einer virtuellen Maschine eine gute Alternative. Ich habe mich für die Oracle Virtual Box entschieden. Ich baue damit nicht nur Kernel, sondern auch ganze Android-ROMs. Um einen Kernel zu bauen, ist eine virtuelle Maschine in jedem Fall hinreichend. Ich empfehle, eine Virtuelle Maschine mit einem Plattenplatz von 20 GB anzulegen, mehr ist für unsere Zwecke nicht nötig!

Der nächste Schritt besteht darin, das Linux zu installieren.

 

[Kiwi++Soft]

Linux installieren

Nun kann man dann ein Linux installieren. Ich habe mich für Lunbuntu entschieden, denn das hat eine schlanke Oberfläche und ist für den Betrieb in einer virtuellen Maschine gut geeignet. Da es die Leichtversion von Ubuntu ist, gibt es bei der Installation der benötigten Packages keine Probleme.

Wichtig:

• Man muss eine 64-Bit Version wählen, die weiteren Schritte verlassen sich darauf.
• Man sollte eine .04 Version wählen, denn das sind die 'Long-Time-Support' Versionen. Ubuntu 14.04 ist gegenüber Ubuntu 14.10 zu bevorzugen!

Das herruntergeladene CD Image muss man bei Verwendung einer virtuellen Maschine nicht auf eine CD brennen, sondern kann in der Konfigurations-Oberfläche von Virtual-Box das Image als CD einbinden und davon booten. Wenn das geschehen ist, startet der Lubuntu-Installer. Die benötigten Angaben sollten selbsterklärend sein.

Der nächste Schritt besteht darin, die Build-Umgebung aufzusetzen.

 

[Kiwi++Soft]

Einrichten der Build-Umgebung

Installieren der benötigten Software-Komponenten:

Dazu muss man im Linux ein Termal-Fenster öffen und folgendes Kommando eingeben:

sudo apt-get install git gnupg flex bison gperf build-essential \
  zip curl libc6-dev libncurses5-dev:i386 x11proto-core-dev \
  libx11-dev:i386 libreadline6-dev:i386 libgl1-mesa-glx:i386 \
  libgl1-mesa-dev g++-multilib mingw32 tofrodos \
  python-markdown libxml2-utils xsltproc zlib1g-dev:i386 \
  git lib32ncurses5-dev
sudo ln -s /usr/lib/i386-linux-gnu/mesa/libGL.so.1 /usr/lib/i386-linux-gnu/libGL.so

Einrichten eines Arbeitsverzeichnisses:

Dazu gibt man im Kommando-Fenster ein

mkdir ~/mykernel

Damit hat man in seinem 'Home-Vereichnis' ein Unterverzeichnis namens 'mykernel' angelegt.

Ich werde in der weiteren Anleitung dieses immer als 'mykernel' referenzieren, aber man kann auch jeden anderen Name verwenden, muss dann aber die Anweisungen in dieser Anleitung daran anpassen.

cd ~/mykernel
git init
git clone https://android.googlesource.com/platform/prebuilts/gcc/linux-x86/arm/arm-eabi-4.8
ls

Nun sollte als Ausgabe erscheinen:

arm-eabi-4.8

Wenn das erscheint, hat man den Cross-Compiler zum Erstellen eines ARM-Kernels erfolgreich installiert.

Jetzt muss man noch die boot-image tools installieren. Die hänge ich als Zip-File an diesen Post an.

Dieses Zipfile am besten im Linux runterladen und den darin enthalten Ordner 'tools' in das ~/mykernel Verzeichnis speichern. Nun muss man die Zugriffsrechte prüfen:

ls -l ~/mykernel/tools/

Das Ergebnis sollte so aussehen:

-rwxrwxr-x 1 user user 230628 Mai 26  2013 minigzip
-rwxrwxr-x 1 user user  27595 Mai 26  2013 mkbootfs
-rwxr-xr-x 1 user user  33019 Feb  6  2012 mkbootimg
-rwxr-xr-x 1 user user  18153 Feb  6  2012 unpackbootimg

Jetzt muss man noch dafür sorgen, dass der Cross-Compiler und die Tools gefunden werden, wenn man einen Build-Prozess startet.

Hinweis: Das folgende Kommando immer eingeben, wenn man ein Terminal-Fenster geöffnet hat, in dem man am Kernel arbeiten möchte.

export PATH=~/mykernel/arm-eabi-4.8/bin:~/mykernel/tools:$PATH

Damit ist die Buld-Umbegung fertig.

 

[Kiwi++Soft]

Kernel Sourcen und Konfiguration bereitstellen

Um einen Kernel mit erweiterten Treibern erstellen zu können, müssen die Sourcen und die bisherige Konfiguration in der Build-Umgebung vorhanden sein.

Dafür ist das Verzeichnis ~/mykernel/src vorgesehen. Man kann natürlich auch ein anderes Verzeichnis wählen, muss dann aber die Namen aus den Anweisungen dieser Anleitung entsprechend anpassen.

 

[Kiwi++Soft]

Herunterladen der Kernel-Sourcen

Die Sourcen des Kernels seines Gerätes bekommt man im Normalfall vom Hersteller des Gerätes.

Wenn man die Sourcen als Zip bekommt:

Viele Hersteller bieten diese Zip File an. Dieses sollte man dann in ein Verzeichnis namens src im Arbeitsverzeichnis ~/mykernel entpacken, so dass die Sourcen dann unter ~/mykernel/src liegen. Dabei muss man darauf achten, dass keine weiteren 'Verzeichnisebenen' entstehen, sondern in dem Verzeichnis src direkt eine Datei names 'Makefile' zu finden ist!

Wenn man die Sourcen über Git bekommt:

Wenn der Hersteller die Sourcen über git anbietet, findet man irgendwo ein 'Git-Url'. Für das Google Nexus 7 (2012) lautet dieses Git-Url beispielsweise:

https://android.googlesource.com/kernel/tegra.git

Ich werde in der weiteren Beschreibung dieses URL verwenden, man muss es dann durch das URL des Kernels seines Herstellers ersetzen.

git clone https://android.googlesource.com/kernel/tegra.git

Git hat nun die Sourcen in ein Unterverzeichnis von ~/mykernel kopiert, das tegra heißt.

nun lassen wir und den Inhalt dieses Verzeichnisse anzeigen:

cd tegra
ls -al

Es kann sein, dass dieses Verzeichnis bis auf ein Unterverzeichnis '.git' leer ist:

drwxrwxr-x   8 user user   4096 Nov 11 13:40 .git

Dann muss man sich jetzt für einen Branch (Entwicklungsstand) entscheiden:

git branch -a

Zeigt die Branches an:

* master
  remotes/origin/HEAD -> origin/master
  remotes/origin/android-3.10
  remotes/origin/android-tegra-3.10
  remotes/origin/android-tegra-flounder-3.10-lollipop-release
  remotes/origin/android-tegra-molly-3.4-l-preview
  remotes/origin/android-tegra-moto-2.6.36
  remotes/origin/android-tegra-moto-2.6.39
  remotes/origin/android-tegra-moto-2.6.39-ics-mr1
  remotes/origin/android-tegra-moto-2.6.39-jb-mr0
  remotes/origin/android-tegra3-grouper-3.1-jb-fr1
  remotes/origin/android-tegra3-grouper-3.1-jb-fr2
  remotes/origin/android-tegra3-grouper-3.1-jb-mr0
  remotes/origin/android-tegra3-grouper-3.1-jb-mr1
  remotes/origin/android-tegra3-grouper-3.1-jb-mr1-fr
  remotes/origin/android-tegra3-grouper-3.1-jb-mr1.1
  remotes/origin/android-tegra3-grouper-3.1-jb-mr2
  remotes/origin/android-tegra3-grouper-3.1-kitkat-mr0
  remotes/origin/android-tegra3-grouper-3.1-kitkat-mr1
  remotes/origin/android-tegra3-grouper-3.1-kitkat-mr2
  remotes/origin/master

Wir entscheiden uns für remotes/origin/android-3.10

git checkout remotes/origin/android-3.10

Nun muss man nur noch den Namen des Verzeichnisses der Kernel-Sourcen umbenennen.

cd ..
mv tegra src

 

[Kiwi++Soft]

Kernel-Konfiguration auslesen

Der nächste wichtige Schritt besteht darin, die aktuelle Konfiguration des Kernels auszulesen. Diese wird benötigt, um beim Erstellen des neuen Kernels genau die gleichen Einstellungen und Treiber zu verwenden , wie beim bisherigen Kernel (außer dass man ein paar zusätzliche Treiber eingefügt hat).

Diese sollte man von seinem Gerät bekommen können, in dem Verzeichnis /proc/config.gz sollte eine gezippte Version davon liegen. Wenn diese nicht vorhanden ist, muss man sich die Kernel-Konfiguration vom Hersteller besorgen.

Hat man eine config.gz Datei, muss man nun in das ~/mykernel/src Verzeichnis kopieren und dort entzippen:

cd ~/mykernel/src
zcat config.gz > .config

Ansonsten muss man die Kernel-Konfiguration vom Hersteller in das ~/mykernel/src legen und als '.config' benennen (Ohne irgendwelche Buchstaben vor dem Punkt!).

 

[Kiwi++Soft]

Geeigneten USB-LAN-Adapter auswählen

Nun muss man den zu unterstützenden USB-LAN Adapter auswählen.

Prinzipiell kann man jeden Adapter verwenden, für den einen Linux-Treiber gibt. Aber es hat Vorteile, einen Adapter zu verwenden, für den schon ein Treiber in den Kernel-Sourcen des Gerätes vorhanden ist.

Notfalls kann aber auch versuchen, einen Treiber, den der Adapter-Hersteller bereit stellt, in die Sourcen zu integrieren. Wenn der Treiber zur Kernel-Version passt, geht das relativ problemlos. Daher werde ich diesen Prozess zwar beschreiben, aber empfehle ihn nur Erfahrenen Usern.

Wenn der Treiber nicht zu der Kernel Version passt, müsste er angepasst werden. Da das aber die Erfahrung eines Software-Entwicklers erfordert, kann ich einem User, der nicht der Sprache C mächtig ist und kleinere Fehler selbst lösen kann, keinen Support bieten. Das wird einfach zu umfangreich.

 

[Kiwi++Soft]

Treiber, die bereits im Kernel-Source-Tree enthalten sind, finden

Dazu benötigen wir ein Terminal-Fenster.

Hinweis: Wenn das Terminal neu geöffnet wird, müssen wir die PfadVariable wieder setzten:

export PATH=~/mykernel/arm-eabi-4.8/bin:~/mykernel/tools:$PATH

Wenn wir ein vorhandenes Fenster verwenden, ist dieser Punkt nicht nötig.

Jetzt schauen wir uns an, welche Treiber in den Kernel-Sourcen vorhanden sind:

cd ~/mykernel/src/
make ARCH=arm CROSS_COMPILE=arm-eabi- menuconfig

Jetzt dauert es ein paar Sekunden, dann sollte sich ein Config-Menu im Terminal aufbauen:

 .config - Linux/arm 3.10.0 Kernel Configuration
 ──────────────────────────────────────────────────────────────────────────────
  ┌───────────────── Linux/arm 3.10.0 Kernel Configuration ─────────────────┐
  │  Arrow keys navigate the menu.  <Enter> selects submenus --->.          │  
  │  Highlighted letters are hotkeys.  Pressing <Y> includes, <N> excludes, │  
  │  <M> modularizes features.  Press <Esc><Esc> to exit, <?> for Help, </> │  
  │  for Search.  Legend: [*] built-in  [ ] excluded  <M> module  < >        │  
  │ ┌─────────────────────────────────────────────────────────────────────┐ │  
  │ │        General setup  --->                                          │ │  
  │ │    [*] Enable loadable module support  --->                             │ │  
  │ │    [*] Enable the block layer  --->                                     │ │  
  │ │        System Type  --->                                            │ │  
  │ │        Bus support  --->                                            │ │  
  │ │        Kernel Features  --->                                        │ │  
  │ │        Boot options  --->                                           │ │  
  │ │        CPU Power Management  --->                                   │ │  
  │ └────┴(+)─────────────────────────────────────────────────────────────┘ │  
  ├─────────────────────────────────────────────────────────────────────────┤  
  │        <Select>    < Exit >    < Help >    < Save >    < Load >         │  
  └─────────────────────────────────────────────────────────────────────────┘

In diesem Menü navigiert man zu

• Device Drivers
  • Network device support
    • USB Network Adapters

Dort findet man die Treiber für USB-Netzwerk-Adapter.

Wenn man Glück hat, sind unter Umständen sogar schon einige Treiber in den Kernel Einkompiliert. Wenn man sich einen USB-Netzwerk-Adapter besorgt, für den die Treiber schon vorhanden sind, muss man sich natürlich keinen neuen Kernel bauen.

Ansonsten kann man hier die Treiber in der Konfiguaration aktivieren, an denen man interessiert ist.

 

[Kiwi++Soft]

Linux-Treiber für LAN-Adapter in den Kernel integrieren

Findet man einen USB-LAN-Adapter, zu dem es einen Linux-Treiber gibt, der jedoch nicht im Kernel-Source enthalten ist, kann man versuchen diesen in die Kernel-Sourcen zu integrieren.

Ich beschreibe das am Beispiel eines Treibers für einen ASIX AX88179 basierten USB Ethernet Adapter.

Die Source für den Treiber habe ich auf der Webseite des Herstellers des Adapters gefunden. Da der Treiber unter der GPL steht, darf ich die Treiber-Source weiter verteilen und hänge sie hier an.

• Das Verzeichnis ~/mykernel/src/drivers/net/usb öffnen.
• Die angehängte Datei AX88179.zip runterladen.
• Die Datei ax88179_178a.c aus dem zip in das o.a Verzeichnis kopieren
• Die Datei Makefile in dem o.a. Verzeichnis öffnen.
• Die folgende Zeile zufügen und die Datei speichern:

obj-$(CONFIG_USB_NET_AX88179)	+= ax88179_178a.o

• Die Datei Kconfig in dem o.a. Verzeichnis öffnen.
• Die folgenden Zeilen zufügen und die Datei speichern:

config USB_NET_AX88179
	tristate "ASIX AX88179 Based USB 3.0 Ethernet Adapters"
	depends on USB_USBNET
	select CRC32
	default n
	help
	  This option adds support for ASIX AX88179 based USB 3.0
	  10/100/1000 Ethernet adapters.

Wenn man nun erneut das Konfig-Menu öffnet, sollte der AX88179 Treiber auswählbar sein.

 

[Kiwi++Soft]

Ein neues Boot-Image erstellen

Der nächste Schritt ist nun ein neues Boot-Image zu erstellen.

Dazu benötigt man das aktuelle Boot-Image, um dessen RAM-Disk zu extrahieren und die 'Adressen' auszulesen. Anschließend baut man einen neuen Kernel, und setzt den mit der Ramdisk zu einem neuen Boot-Image zusammen.

 

[Kiwi++Soft]

Das aktuelle Boot-Image entpacken

Um das aktuelle Boot-Image zu entpacken benötigen wir ein Arbeitsverzeichnis. Das erstellen wir mit Hilfe des Terminal-Fensters.

Hinweis: Wenn das Terminal neu geöffnet wird, müssen wir die PfadVariable wieder setzten:

export PATH=~/mykernel/arm-eabi-4.8/bin:~/mykernel/tools:$PATH

Jetzt legen wir das Arbeitsverzeichnis für das Boot-Image an:

cd ~/mykernel
mkdir boot
cd boot
mkdir old

In das Verzeichnis ~/mykernel/boot/old hinein muss man das aktuelle Boot-Image seines Gerätes kopieren. Man sollte das aktuelle Boot-Image als boot.img benennen.

Jetzt kann man das boot.img extrahieren:

unpackbootimg -i old/boot.img

Jetzt muss man sich die Ausgabe genau angucken, die Werte benötigt man noch, wenn man später das neue Boot-Image erzeugt.

BOARD_KERNEL_CMDLINE kiwi_oc=1
BOARD_KERNEL_BASE 00000800
BOARD_PAGE_SIZE 2048

Aber zur Not kann man diese Werte auch aus dem Verzeichnis auslesen, denn dor sollten Dateien entstanden sein, in denen die Werte auch drin stehen. Daher jetzt das Verzeichnis auslesen:

ls -l

Das sollte so aussehen:

-rw-rw-r-- 1 user user       9 Nov 11 15:53 boot.img-base
-rw-rw-r-- 1 user user      10 Nov 11 15:53 boot.img-cmdline
-rw-rw-r-- 1 user user       5 Nov 11 15:53 boot.img-pagesize
-rw-rw-r-- 1 user user 2321701 Nov 11 15:53 boot.img-ramdisk.gz
-rw-rw-r-- 1 user user 3215016 Nov 11 15:53 boot.img-zImage

Die Datei boot.img-ramdik.gz enthält das Root-Filesystem des aktuellen Boot-Images, das man auch für das neue Boot-Image verwendet.

 

[Kiwi++Soft]

Neuen Kernel erstellen

Jetzt kann man den neuen Kernel erstellen

Dazu startet man erst noch mal das Konfig-Menü, um die gewünschten Treiber in in den Kernel zu integrieren.

Daher wieder zum Terminal-Fenster.

Hinweis: Wenn das Terminal neu geöffnet wird, muß man die Pfad-Variable wieder setzten:

export PATH=~/mykernel/arm-eabi-4.8/bin:~/mykernel/tools:$PATH

Zum Starten des Konfig-Menüs:

cd ~/mykernel/src
make ARCH=arm CROSS_COMPILE=arm-eabi- menuconfig

Jetzt alle Treiber aktivieren, die man haben möchte. Dann das Konfig-Menü beenden und die Konfiguration speichern.

Jetzt kann man den neuen Kernel bauen:

make ARCH=arm CROSS_COMPILE=arm-eabi- -j4

Dieser Prozess wird einige Zeit dauern...

Wenn alles klappt, dann kommt irgendwann die Zeile:

  Kernel: arch/arm/boot/zImage is ready

 

[Kiwi++Soft]

Das Boot-Image zusammensetzen

Jetzt kann man das neue Boot-Image zusammen setzen. Auch das geschieht wieder im Terminal-Fenster.

Hinweis: Wenn das Terminal neu geöffnet wird, müssen wir die PfadVariable wieder setzten:

export PATH=~/mykernel/arm-eabi-4.8/bin:~/mykernel/tools:$PATH

Dazu benötigen wir die vorhin ausgelesen Werte für CMDLINE, BASE und PAGESIZE.

Wichtig: Ich gebe hier das Kommando mit den Werten meines Gerätes vor, bitte die roten Werte durch die entsprechenden Werte von dem eigenen Boot-Image ersetzen!

cd ~/mykernel/boot
mkbootimg --kernel ../src/arch/arm/boot/zImage \
 --ramdisk boot.img-ramdisk.gz \
  --cmdline [B][COLOR="Red"]kiwi_oc=1[/COLOR][/B] \
  --base [B][COLOR="Red"]00000800[/COLOR][/B] \
  --pagesize [B][COLOR="Red"]2048[/COLOR][/B] \
  -o boot.img

Nun hat man im Verzeichnis ~/mykernel/boot ein neu erzeugtes Boot-Image mit dem Namen boot.img erzeugt.

Wichtig: Dieses Boot-Image sollte man erst testen, bevor man es flasht!

Wichtig: Man sollte ein Nadroid-Backup erstellen, bevor man etwas flasht!

Wenn man adb bzw fastboot Zugriff auf sein Gerät hat, und einen geöffneten Bootloader, kann man ein Boot-Image testen, ohne es direkt zu flashen.

Das Gerät per USB an den PC anschließen. Wenn es noch nicht im Bootloader-Modus ist, dorthin booten:

adb reboot bootloader

Jetzt nehmen wir an, dass der PC ein Windows-PC, man das Boot-Image aus dem Linux in den Windows PC kopiert hat und das Boot-Image unter C:\Temp\boot.img zu funden ist. Dann kann man das Boot-Image mit diesem Kommando testen:

fastboot boot C:\Temp\boot.img

Wenn das Boot-Image erfolgreich gebootet hat, kann man die Prozedur wiederholen und es installieren:

Erst in den Bootloader booten:

adb reboot bootloader

Dann das Boot-Image flashen:

fastboot flash boot C:\Temp\boot.img

Wenn alles soweit geklappt hat:

Glückwunsch, jetzt hat man seinen ersten selbst erstellten Kernel!

 

[Kiwi++Soft]

Netzwerk-Konfiguration

Dieses Kapitel muss noch erstellt werden...

 

[MultiWirth]

Hallo,

Ich hab mal eine große Frage was Kernel usw angeht:

Eigentlich geht es da ja eher um mein Tablet...

Das Tablet "Archos 97 Carbon" ist so unverbreitet, dass es dafür nicht wirklich Entwickler gibt...

Ich laufe auf gerootetem Stock Rom bzw. ich habe das Update auf 2 GB interner Speicher installiert, welches ich aber nicht über den Pc geflasht sondern übers Recovery nur installiert hab und ich somit nur Root habe von dem ganzen...

Doch leider ist das Rom im Vergleich zu einem deutlich schwächeren Gerät mit CyanogenMod 9.1 echt langsam !

Das Browsen mit dem Stock Android 4.0 Browser macht nicht wirklich spaß ;(

Mein erstes Ziel ist es, den Kernel anzupassen um die CPU zu übertakten.
Im Netz gibt es für Archos Geräte wohl einen Kernel, mit dem man einen 1 Ghz Prozessor auf 1,2 Ghz bringt, einen 1,2 Ghz Prozessor aber sogar auf 1,5 Ghz...
Bin mir nicht sicher, aber ich glaub die 1 Ghz Variante könnte auch bis 1,5 Ghz gehen...


Hier mal nochmal der Thread: [OC Kernel] Overclock Kernel linux 3.0.21 | … | Archos Gen8, Gen9, Gen10 | XDA Forums

Zum einen versteh ich nichtmal, wie ich diesen Kernel am ende überhaupt auf mein Gerät bekomme, zum anderen weiß ich auch nicht ob der überhaupt funktionieren wird !

Ich hab noch nie einen eigenen Kernel oder sogar ein Rom gebastelt, aber diese Sache ist ein Anreiz dazu es anzufangen !

Leider werde ich das ohne Hilfe und erklärungen wohl nicht schaffen ;(


Ich könnte mir aber gut vorstellen, dass es auf dem Archos 97 Carbon nicht all zu schwer sein dürfte... Hat keine besondere Hardware und läuft fast auf Stock Android 4.0.3, es wurden nur ein paar wenige Funktionen des Herstellers integriert.

Wie z.b. einen Video Player oder ein Einrichtungsassisten,
Unter anderem ein Touchscreen kalibierungsdings
Das sich nach jedem Absturz oder fremdes Neustarten einer App meldet bevor irgendwas anderes passiert...

Vieleicht kann mir jemand das mal etwas erklären wie ich sowas zu machen hab...

Ich hab sowohl Windows 7 als auch Ubuntu 14.10 auf meinem Rechner...
...aber noch nie so tief ins Android System gegriffen

Wer kann mir helfen ?!

 

[Thomasmueller85]

Ich gebe dir einen sehr guten Rat: Lass es erstmal sein mit OC. Dein Link von Kernel Link von xda hat kein Github Link drin. Du hast keine Ahnung (noch nicht) wie du die Changes machen musst. Wenn du Kernel erstellen willst, lerne C und was überhaupt Github, eine Ramdisk und was ein Toolchain ist. Bevor du erstmal den ersten Kernel fertig hast, werden 1 bis 4 Monate vergehen.

Du musst viel lesen auf englisch.
Du musst die Kernel Dokumentation verstehen, die sich in Sourcecode befindet.
Du musst mit Github arbeiten können und zwar perfekt.
Du musst den Sourcecode verstehen können, ein kleiner Fehler und das Device kann Schrott sein.

Diese hier ist eine super Anleitung, aber leider nur zum modden.

 

[MultiWirth]

hmm okay... also ist das doch einiges mehr arbeit, wie ich es mir dachte ;(

Kennst du denn ein paar Links, wo diese Dinge gut erklärt sind ?

Wenn ich das mit meinem Billig Tablet vieleicht mal hinbekommen hab, möchte ich versuchen das Android Rom des HTC HD Mini zu verbessern bzw. die vorhandenen Bugs beseitigen.
Das Projekt wurde zuletzt 2012 aktualisiert um auf diesem Windows Mobile Gerät Android zum laufen zu bringen... Leider hat keiner mehr Bock dazu.

Aber mir ist es erstmal wichtig mir was anständiges auf das Tablet zu zaubern, da selbst der Stock Browser nicht flüssig läuft :/


Aber ich glaube ich muss da in Zukunft wohl erstmal einiges lesen.

Ist wohl auch eine gute gelegenheit Englisch etwas besser zu lernen bin da nur durchschnittlich drin

Aber Danke für den Tipp oder "Rat" wie man es jetzt auch nennen mag...

 

[Thomasmueller85]

Ja das ist etwas schwierig dir da Lesestoff zu besorgen. Jedes Gerät hat andere Configs, eine andere Ramdisk usw.

Du solltest erstmal lernen wie du einen Kernel "builden" kannst. Das wird hier in der Anleitung gut beschrieben. Wenn du mal aus einen Sourcecode ohne Veränderungen einen Kernel "gebuildet" hast, musst du den Sourcecode verstehen.

Ein Sourcecode besteht aus etwa 40000 - 50000 "Textdateien". Hier musst du wissen wo und wie die Changes gemacht werden.

Hier mal eine gute Anleitung:

http://forum.xda-developers.com/showthread.php?t=1748297

Aber Achtung: Die Anleitung ist ca 3 Jahre alt. Die Patches usw würde ich nicht bei neuen Geräten verwenden.

 

[Kiwi++Soft]

Es ist letztlich davon abhängig, ob Du einen Sinn für das Coden hast oder nicht.

Wenn Du in der Lage bist, fremden Source-Code zu lesen und zu verstehen, was passiert, und wenn Du auch fähig bist, dort so Änderungen vorzunehmen, dass es hinterher noch genau tut, was es vorher getan hat, bis auch das was Du möchtest, dann ist es keine große Sache, OC in einen Kernel einzubauen.

Meinen ersten Kernel, in dem ich nur einen zusätzlichen Treiber für Cifs-Laufwerke eingeschaltet und den Acer Secure-Mount ausgeschaltet habe, hatte ich am 15.01.2013 veröffentlicht.

OC in den Kernel einzubauen habe ich 5 Tage später geschafft und am 20.01.2013 veröffentlicht.

Das waren zwar meine ersten Erfahrungen mit dem Linux-Kernel, allerdings entwickle ich Software schon ein paar Jährchen länger.

Es hängt, wie gesagt, nur davon ab, ob man Code lesen und schreiben kann. Wer das nicht kann, hat kaum eine Chance selbst was zu machen.Und wer bei der ersten Fehlermeldung gleich um Hilfe rufen muss, meistens auch nicht...

Noch ein Wort zu GIT: Mit GIT umgehen zu können, ist keineswegs eine Voraussetzung (vielleicht um sich die Sourcen zu ziehen, wenn die im GIT liegen), das wird erst nötig, wenn Du Deine Sourcen mit anderen teilen willst. Versionen speichern kann man auch mit anderen Versionsverwaltungen, oder durch 'manuelle Lösungen'