Rockchip DDR-Entwicklerleitfaden: Frequenz, Kapazität, Validierung, Augendiagramme und ECC

Dies ist eine Plattformreferenz auf Grundlage von Rockchip DDR V2.7.2, kein ArmSoM-Testbericht und keine Zusage, dass jedes Board alle Funktionen unterstützt. Die Quelle umfasst mehrere SoC-Generationen, Linux 3.0/3.10/4.4 und spätere Kernel, Android, U-Boot, Loader, Trust/ATF und HAL. Prüfen Sie die konkrete Kombination aus Board, DRAM-Baustein und Leiterbahnführung, SoC, SDK-/BSP-Zweig, DDR-Binärdatei, Trust und Kernel. Eine boardspezifische ArmSoM-Anpassung wurde nicht auf Hardware validiert.

Der chinesische Artikel folgt dem 110-seitigen chinesischen PDF, der englische dem 115-seitigen englischen PDF. Die russische und deutsche Fassung übersetzen den vollständigen englischen Text. Beide Quellen tragen V2.7.2. Die englische Fassung enthält zusätzlich §6.2.1 zur englischen Werkzeugoberfläche, wodurch sich die folgenden Abschnittsnummern in Kapitel 6 verschieben. Weitere Unterschiede betreffen Kapazitätsberechnungen, Augenmarkierungen, Versionsangaben und Pfade. Sie bleiben ausdrücklich im Text und in den Redaktionsnotizen dokumentiert und werden nicht stillschweigend vereinheitlicht.

Betriebsrisiko: Firmwareprogrammierung, Änderungen von Spannung, Frequenz oder Kapazität, Entfernen von RZQ, ECC-Fehlerinjektion und Speicherbelastungstests können Hardware oder Daten beschädigen und Resets verursachen. Quellbefehle und Debugwerte wie 1.6V sind Beispiele, keine Empfehlungen für beliebige ArmSoM-Boards. Prüfen Sie DRAM-Spezifikationen, Schaltpläne, elektrische Grenzwerte und das passende SDK; sichern Sie Daten und verwenden Sie kontrollierte Testhardware. Es wurden keine Hardwarebefehle ausgeführt. Alle beschriebenen Beobachtungen und Messwerte stammen aus Quellbeispielen. Genannte Werkzeug- und Ressourcenpfade bedeuten nicht, dass die Binärdateien mit dieser Website verteilt werden.

Offizielle Ressourcen: ArmSoM-Dokumentation, Rockchip Linux, rkbin.

Das Quellvorwort beschreibt die DDR-SDRAM-Entwicklung für alle Rockchip-Chips. Die Produktversionstabelle nennt alle Chipsätze und alle Kernelversionen. Dies ist der von der Quelle beanspruchte Umfang, keine geprüfte Kompatibilität jeder Kombination.

1. Kapitel 1: Häufige Fragen zur DDR-Entwicklung

1.1 Bedeutung der DDR-Protokolle

DDR-Protokolle werden im Loader und im Kernel ausgegeben. Das Loader-Protokoll wird wie folgt erläutert:

DDR Version 1.05 20170712//Version information of the DDR initialization code used to check
the version. From this line, you have entered the DDR initialization code.
In
SRX //If it prints SRX, means hot restart; without SRX, it means that it is cold boot. While
some chipset does not have this feature, there will not show SRX.
Channel a: DDR3 400MHz //The following log are the details of the DDR capacity. For more
explanation,please see the chapter"How to Check the Capacity of DDR".
Bus Width=32 Col=10 Bank=8 Row=15 CS=1 Die Bus-Width=16 Size=1024MB
Channel b: DDR3 400MHz
Bus Width=32 Col=10 Bank=8 Row=15 CS=1 Die Bus-Width=16 Size=1024MB
Memory OK //This is the result of DDR self-test, the first "Memroy OK" is the self-test
result of Channel a.
Memory OK //It is the self-test result of Channel b.If Channel a or b shows an error,
turning out that something wrong with the welding; no error, indicating that the current
self-test is good.But whether the entire DDR can work stably or not,also depends on the
subsequent stages of operation results.
OUT //After this line, the DDR initialization code is exited.

Nachfolgend das DDR-Protokoll von Kernel 3.0 und 3.10:

[ 0.528564] DDR DEBUG: version 1.00 20150126 //Version information
[ 0.528690] DDR DEBUG: Channel a: //The details of the DDR capacity
[ 0.528701] DDR DEBUG: DDR3 Device
[ 0.528716] DDR DEBUG: Bus Width=32 Col=10 Bank=8 Row=15 CS=1 Total Capability=1024MB
[ 0.528727] DDR DEBUG: Channel b:
[ 0.528736] DDR DEBUG: DDR3 Device
[ 0.528750] DDR DEBUG: Bus Width=32 Col=10 Bank=8 Row=15 CS=1 Total Capability=1024MB
//The following information about DDR specialize for DDR engineer debug, please ignore it.
//After "DDR DEBUG" print end, which means DDR initialization finishes in kernel.

Kernel 3.10 gibt außerdem das folgende Protokoll des DDR-Frequenzskalierungsmoduls aus.

[ 1.473637] ddrfreq: verion 1.2 20140526 //DDR frequency scaling module version
[ 1.473653] ddrfreq: normal 396MHz video_1080p 240MHz video_4k 396MHz dualview 396MHz
idle 0MHz suspend 200MHz reboot 396MHz //The frequencies which read from dts table are
corresponding to the different scenarios.
[ 1.473661] ddrfreq: auto-freq=1 //This line reflects load scaling functon is enable or
not,"1" means on,"0" means off.
[ 1.473667] ddrfreq: auto-freq-table[0] 240MHz //the table of the load scaling
[ 1.473673] ddrfreq: auto-freq-table[1] 324MHz
[ 1.473678] ddrfreq: auto-freq-table[2] 396MHz
[ 1.473683] ddrfreq: auto-freq-table[3] 528MHz
//If crash or block in this print porcedure,it is most likely DDR frequency scaling bug.

In Versionen nach Kernel 3.10 werden keine DDR-Kapazitätsinformationen mehr im Kernel ausgegeben.

1.2 Rockchip-DDR-Binärdateien in einen vollständigen nutzbaren Loader integrieren

1. Legen Sie die DDR-Binärdatei im passenden Unterverzeichnis von rk\rkbin\bin\ des U-Boot-Projekts ab.

2. Löschen Sie die ursprüngliche DDR-Binärdatei.

3. Benennen Sie die neue DDR-Binärdatei auf den Namen der gelöschten Datei um.

4. Kompilieren Sie U-Boot, siehe „Rockchip-Developer-Guide-UBoot-nextdev.pdf“. Dadurch wird die passende Loader-Datei erzeugt.

5. Prüfen Sie anhand des Loader-Protokolls, ob der Loader korrekt aktualisiert wurde.

Übersicht der DDR-Binärdateipfade aller Plattformen:

Hinweis 1: Die Frequenz wird in rk\rkbin\RKBOOT\RK3036_ECHOMINIALL.ini oder RK3036MINIALL.ini festgelegt. RK3036_ECHOMINIALL.ini ist speziell für ECHO-Produkte bestimmt; andere RK3036-Produkte verwenden RK3036MINIALL.ini. Zur Identifikation eines ECHO-Geräts verweist die Quelle auf die Rockchip-Systemproduktabteilung.

Hinweis 2: Die Frequenz wird in rk\rkbin\RKBOOT\RK3399MINIALL.ini festgelegt.

Hinweis 3: Die angegebene RK3528-Hardwarekonfiguration gilt für nicht zweilagige Leiterplatten und DDR mit anderer Breite als 4BIT. Für zweilagige Leiterplatten oder 4BIT-DDR siehe die folgenden besonderen Hinweise zu DDR-Binärdateien.

Hinweis 4: Neue Plattformen werden nach ähnlichen Namensregeln unter rk\rkbin\bin\ abgelegt und können dort gesucht werden.

1.3 Plattformen mit vier Frequenzpunkten in der DDR-Binärdatei

Die DDR-Binärdateien der folgenden Plattformen enthalten jeweils vier DDR-Frequenzen. Die höchste ist im Dateinamen angegeben: Bei rv1126_ddr_924MHz_v1.05.bin beträgt der letzte Frequenzpunkt beispielsweise 924M.

Im Kernel können nur diese vier Frequenzen verwendet werden. Zur Änderung siehe das Kapitel zur Bearbeitung der DDR-Binärdatei.

Die vier Standardfrequenzen sind üblicherweise:

Die vier Frequenzpunkte lassen sich im seriellen Loader-Protokoll anzeigen, beispielsweise:

DDR ... v1.14
LPDDR4X, 2112MHz
channel[0] BW=16 Col=10 Bk=8 CS0 Row=16/0 CS1 Row=16/0 CS=2 Die BW=16 Size=2048MB
channel[1] BW=16 Col=10 Bk=8 CS0 Row=16/0 CS1 Row=16/0 CS=2 Die BW=16 Size=2048MB
channel[2] BW=16 Col=10 Bk=8 CS0 Row=16/0 CS1 Row=16/0 CS=2 Die BW=16 Size=2048MB
channel[3] BW=16 Col=10 Bk=8 CS0 Row=16/0 CS1 Row=16/0 CS=2 Die BW=16 Size=2048MB
...
change to F1: 528MHz /* 4 DDR frequencies */
change to F2: 1068MHz
change to F3: 1560MHz
change to F0: 2112MHz
out

Sie können die aktuellen vier Frequenzen auch mit rkbin/tools/ddrbin_tool auslesen, beispielsweise:

./ddrbin_tool px30 -g gen_param.txt px30_ddr_333MHz_v1.15.bin

Weitere Informationen enthält die ausführliche Anleitung zu ddrbin_tool.

1.4 Besondere Hinweise zu DDR-Binärdateien

Für einige DDR-Binärdateien unter rk\rkbin\bin gelten besondere Hinweise.

RK3399

RK3399 unterstützt je nach DDR-Typ unterschiedliche Frequenzen. Da der Dateiname die Frequenz nicht nach Speichertyp unterscheidet, kann dies zu Verwechslungen führen. Die folgende Tabelle erläutert die Zuordnung.

Binärdateien mit Suffix „eyescan“

DDR-Binärdateien mit eyescan-Suffix erzeugen einen Loader, mit dem sich zweidimensionale Augendiagramme der DDR-Signale erfassen lassen, beispielsweise:

rk\rkbin\bin\rk35\rk3566_ddr_1056MHz_eyescan_v1.16.bin

rk\rkbin\bin\rk35\rk3588_ddr_lp4_2112MHz_lp5_2736MHz_eyescan_v1.11.bin

rk\rkbin\bin\rk35\rk3562_ddr_1332MHz_eyescan_v1.04.bin

rk\rkbin\bin\rk35\rk3568_ddr_1560MHz_eyescan_v1.16.bin

Binärdateien mit Suffix „ultra“

Für besonders stromsparenden E-Book-Betrieb mit entsprechender E-Book-Hardware, beispielsweise:

rk\rkbin\bin\rk35\rk3566_ddr_XXXMHz_ultra_v1.10.bin

rk\rkbin\bin\rk35\rk3562_ddr_XXXMHz_ultra_v1.05.bin

Binärdateien mit Suffix „tb“

Für Schnellstart. Wählen Sie die zum DDR-Typ passende Binärdatei, beispielsweise:

rk\rkbin\bin\rv11\rv1126_tpl_XXXMHz_ddr4_tb_v1.08.bin

rk\rkbin\bin\rv11\rv1126_tpl_XXXMHz_ddr3_tb_v1.08.bin

rk\rkbin\bin\rv11\rv1126_tpl_XXXMHz_lp3_tb_v1.08.bin

rk\rkbin\bin\rv11\rv1126_tpl_XXXMHz_lp4_tb_v1.08.bin

Für RV1106-Schnellstart mit DDR3

rk\rkbin\bin\rv11\rv1106_ddr_924MHz_tb_v1.13.bin

3528-Dateien mit „PCB“

Für Designs mit 4BIT-DDR

rk\rkbin\bin\rk35\rk3528_ddr_1056MHz_4BIT_PCB_v1.07.bin

Für Designs mit zweilagiger Leiterplatte

rk\rkbin\bin\rk35\rk3528_ddr_1056MHz_2L_PCB_v1.07.bin

1.5 DDR-Binärdatei bearbeiten

Die zuvor beschriebenen DDR-Binärdateien initialisieren DDR beim Start. Mit Rockchip-Werkzeugen lassen sich darin Initialisierungsparameter, DDR-Frequenz, serielle Ausgabe, Baudrate und weitere Einstellungen verändern.

rk_ddrBin_tool_windows

Empfohlen wird rk_ddrBin_tool_windows, ein einfach bedienbares Werkzeug mit grafischer Oberfläche.

Die Werkzeuge sind unter folgendem Pfad verfügbar:

https://redmine.rock-chips.com/documents/49 -> rk_ddrBin_tool_windows_Vx.xx.7z

Üblicherweise gibt es mehrere Archivteile. Laden Sie alle herunter und entpacken Sie sie anschließend.

Unter Help enthält das Werkzeug eine Bedienungsanleitung.

rkbin/tools/ddrbin_tool

Die Kommandozeilenvariante befindet sich im rkbin-Projekt unter rkbin/tools/ddrbin_tool.

Die Dokumentation liegt unter rkbin/tools/ddrbin_tool_user_guide.txt.

Häufige Anpassungen:

DDR-Frequenz ändern

Für SoCs mit nur vier unterstützten DDR-Frequenzen siehe den Abschnitt über Plattformen mit vier Frequenzpunkten.

Die vier Frequenzen können entsprechend dem DDR-Typ geändert werden. Das folgende Beispiel zeigt die vier LPDDR4-Frequenzen.

Editierbare Screenshot-Abschrift mit Originalfeldern und -werten:

Seriellen Anschluss ändern

Editierbare Screenshot-Abschrift mit Originalfeldern und -werten:

Serielle Baudrate ändern

Editierbare Screenshot-Abschrift mit Originalfeldern und -werten:

1.6 DDR-Frequenz in U-Boot ändern

RK322x

Die folgende Methode wird nur von RK322x unterstützt. Ändern Sie dazu arch/arm/boot/dts/rk322x.dtsi im Kernel-3.10-Code.

dram: dram {
    compatible = "rockchip,rk322x-dram";
    status = "okay";
    dram_freq = <786000000>;
    rockchip,dram_timing = <&dram_timing>;
};

Ändern Sie lediglich „dram_freq“ im obigen Codeblock; die Einheit ist Hz. Die Frequenz kann frei gewählt werden.

U-Boot wertet diese DTS automatisch aus und schaltet auf die entsprechende Frequenz um.

RK3576/RK3588

Die folgende Methode wird nur von RK3576 und RK3588 unterstützt. Bei der DDR-Initialisierung legt der Loader auf diesen Plattformen vier DDR-Frequenzen für die spätere Kernelverwendung an. Standardmäßig verlässt er den Loader mit der höchsten Frequenz und setzt den Start fort.

F1, F2, F3 und F0 bezeichnen diese vier Frequenzen. Standardmäßig wird der Loader mit F0 verlassen.

DDR ... v1.14
LPDDR4X, 2112MHz
channel[0] BW=16 Col=10 Bk=8 CS0 Row=16/0 CS1 Row=16/0 CS=2 Die BW=16 Size=2048MB
channel[1] BW=16 Col=10 Bk=8 CS0 Row=16/0 CS1 Row=16/0 CS=2 Die BW=16 Size=2048MB
channel[2] BW=16 Col=10 Bk=8 CS0 Row=16/0 CS1 Row=16/0 CS=2 Die BW=16 Size=2048MB
channel[3] BW=16 Col=10 Bk=8 CS0 Row=16/0 CS1 Row=16/0 CS=2 Die BW=16 Size=2048MB
...
change to F1: 528MHz /* 4 DDR frequencies */
change to F2: 1068MHz
change to F3: 1560MHz
change to F0: 2112MHz
out

Um die DDR-Frequenz unter U-Boot zu ändern, ändern Sie lediglich die Frequenz beim Verlassen des Loaders.

Suchen Sie im Werkzeug aus dem Abschnitt zur Bearbeitung der DDR-Binärdatei den Parameter boot_fsp. Damit wählen Sie F0/F1/F2/F3 als Frequenz beim Verlassen des Loaders und ändern so die DDR-Frequenz in U-Boot.

Editierbare Screenshot-Abschrift mit Originalfeldern und -werten:

1.7 DDR-Frequenzskalierung im Kernel aktivieren oder deaktivieren

Prüfen Sie zunächst, ob der Chip DDR-Frequenzskalierung im Kernel unterstützt. Danach lässt sich die Funktion wie folgt aktivieren oder deaktivieren:

Ab Kernel 4.4 suchen Sie den letztlich wirksamen dmc-Knoten in DTS. status = “disabled” deaktiviert die DDR-Frequenzskalierung, status = “okay” aktiviert sie.

Hinweis 1: Prüfen Sie bei RK3576 und RK3588 nach Aktivierung über den DTS-dmc-Knoten die Eigenschaften “center-supply” und “mem-supply” anhand der tatsächlichen Stromversorgungsverdrahtung. Die Werte nennen die Regulatorknoten zur Versorgung des DDR-Moduls auf der

SoC-Seite sowie von LOGIC.

Standard für RK3576: center-supply = <&vdd_ddr_s0>, mem-supply = <&vdd_logic_s0>.

Standard für RK3588: center-supply = <&vdd_ddr_s0>, mem-supply = <&vdd_log_s0>.

Fehlt diese Eigenschaft im dmc-Knoten, kann der dmc-Treiber nicht geladen werden. Das Kernelprotokoll lautet:

rockchip-dmc dmc: Cannot get the regulator "center"

Hinweis 2: Prüfen Sie bei anderen Plattformen nach Aktivierung über den DTS-dmc-Knoten die Eigenschaft “center-supply” anhand der tatsächlichen Stromversorgungsverdrahtung. Ihr Wert nennt den Regulatorknoten zur Versorgung des DDR-Moduls auf der SoC-Seite.

Standard für RK3399: center-supply = <&vdd_center>.

Für andere Plattformen wie PX30/RK3568/RV1126 ist der Standard center-supply=<&vdd_logic>.

Fehlt diese Eigenschaft im dmc-Knoten, kann der dmc-Treiber nicht geladen werden. Das Kernelprotokoll lautet:

rockchip-dmc dmc: Cannot get the regulator "center"

Hinweis 3: Halten Sie den Status des dfi-Knotens möglichst konsistent mit dmc. In älterem Code hängt dmc von dfi ab; ein auf “disabled” gesetzter dfi-Knoten macht dmc unwirksam.

Beim RK3399-EVB befindet sich der letztlich wirksame dmc-Knoten beispielsweise in arch/arm64/boot/dts/rockchip/rk3399-evb.dtsi.

&dfi {
    status = "okay";
};
&dmc {
    center-supply = <&vdd_center>; /* This requires the customer to configure it according
to the actual hardware circuit*/
    status = "okay"; /* enable kernel DDR scaling function */
    ...
};

&dfi {
    status = "disabled";
};
&dmc {
    status = "disabled"; /* disable kernel DDR scaling function */
    ...
};

Bei Kernel 3.10 suchen Sie den wirksamen clk_ddr_dvfs_table-Knoten in DTS. status = “disabled” deaktiviert die DDR-Frequenzskalierung im Kernel, status = “okay” aktiviert sie.

Beim RK3288-SDK-Board liegt clk_ddr_dvfs_table beispielsweise in arch/arm/boot/dts/rk3288-tb_8846.dts.

&clk_ddr_dvfs_table {
    ...
    status="okay"; /* enable kernel DDR scaling function */
};

&clk_ddr_dvfs_table {
    ...
    status="disabled"; /* disable kernel DDR scaling function */
};

Bei Kernel 3.0 ändern Sie dvfs_ddr_table in der boardspezifischen Datei borad-**.c. Lassen Sie nur eine DDR_FREQ_NORMAL-Frequenz in der Tabelle stehen, sodass DDR die Frequenz nicht wechseln kann.

Die Boarddatei des RK3066-SDK-Boards liegt beispielsweise unter arch/arm/mach-rk30/board-rk30-sdk.c:

/* This table enable DDR scaling function */
static struct cpufreq_frequency_table dvfs_ddr_table[] = {
    {.frequency = 200 * 1000 + DDR_FREQ_SUSPEND, .index = 1050 * 1000},
    {.frequency = 300 * 1000 + DDR_FREQ_VIDEO, .index = 1050 * 1000},
    {.frequency = 400 * 1000 + DDR_FREQ_NORMAL, .index = 1125 * 1000},
    {.frequency = CPUFREQ_TABLE_END},
};
/* This table disable DDR scaling function */
static struct cpufreq_frequency_table dvfs_ddr_table[] = {
    //{.frequency = 200 * 1000 + DDR_FREQ_SUSPEND, .index = 1050 * 1000},
    //{.frequency = 300 * 1000 + DDR_FREQ_VIDEO, .index = 1050 * 1000},
    {.frequency = 400 * 1000 + DDR_FREQ_NORMAL, .index = 1125 * 1000},
    {.frequency = CPUFREQ_TABLE_END},
};

1.8 DDR-Frequenzwechsel einschließlich Initialisierung verhindern

Der vorherige Abschnitt beschreibt das Aktivieren und Deaktivieren der Frequenzskalierung im laufenden Betrieb. Während der Initialisierung gibt es jedoch eine Ausnahme: Beim Einschalten kann ddr_init einmal die Frequenz ändern, um das DDR-Timing für höhere Leistung zu aktualisieren. Soll auch dies unterbleiben, führen Sie sowohl die Änderungen aus dem Abschnitt zur Kernel-Frequenzskalierung als auch die folgenden aus:

Für Kernel 4.4 und spätere Versionen:

Die Änderungen aus dem Abschnitt zum Aktivieren/Deaktivieren der DDR-Frequenzskalierung im Kernel genügen. Damit wird auch die Skalierung in ddr_init unterbunden.

Für Kernel 3.10:

Chiptyp: RK322X

Codeposition: kein entsprechender Code im Kernel

Vorgehen: Nur den dram-Knoten auf “disabled” setzen.

dram: dram {
    compatible = "rockchip,rk322x-dram";
    status = "disabled"; /* Please,modify here! */
    dram_freq = <786000000>;
    rockchip,dram_timing = <&dram_timing>;
};

Chiptyp: RK3188

Codeposition: Funktion ddr_init() in arch/arm/mach-rockchip/ddr_rk30.c

Chiptyp: RK3288

Codeposition: Funktion ddr_init() in arch/arm/mach-rockchip/ddr_rk32.c

Chiptypen: RK3126B und RK3126C mit Firmware ohne trust.img

Codeposition: Funktion ddr_init() in arch/arm/mach-rockchip/ddr_rk3126b.c

Chiptypen: RK3126/RK3128

Codeposition: Funktion ddr_init() in ./arch/arm/mach-rockchip/ddr_rk3126.c

Vorgehen: Kommentieren Sie die folgenden Zeilen in ddr_init() aus:

if(freq != 0)
    value = clk_set_rate(clk, 1000*1000*freq);
else
    value = clk_set_rate(clk, clk_get_rate(clk));

Chiptyp: RV1108

Codeposition: Funktion ddr_init() in arch/arm/mach-rockchip/ddr_rv1108.c

Vorgehen: Kommentieren Sie die folgenden Zeilen in ddr_init() aus:

if (freq == 0)
_ddr_change_freq(ddr_freq_current);
else
_ddr_change_freq(freq);

Bei anderen Chips, einschließlich RK3126B und RK3126C mit trust.img, genügen die Änderungen aus dem Abschnitt zum Aktivieren/Deaktivieren der DDR-Frequenzskalierung im Kernel. Damit wird auch ddr_init erfasst. Für Kernel 3.0 gilt:

Code Path

arch/arm/mach-rk2928/ddr.c, ddr_init() function

Vorgehen: Kommentieren Sie die folgenden Zeilen in ddr_init() aus:

if(freq != 0)
    value=ddr_change_freq(freq);
else
    value=ddr_change_freq(clk_get_rate(clk_get(NULL, "ddr"))/1000000);

1.9 DDR-Kapazität überprüfen

Für eine grobe Kapazitätsprüfung lesen Sie MemTotal mit dem folgenden Befehl aus. Dieser Wert ist etwas kleiner als die tatsächliche Kapazität und sollte auf eine übliche Kapazitätsstufe aufgerundet werden.

root@rk3399:/ # cat /proc/meminfo
MemTotal: 3969804 kB

Für detaillierte Kapazitätsangaben gehen Sie wie folgt vor:

DDR-Kapazitätsangaben werden bei der Initialisierung im Loader und teilweise im Kernel ausgegeben. Ab Kernel 4.4 gibt es keine Kernel-Ausgabe mehr; bei Kernel 3.10 besitzen einige Chips entsprechende Angaben, siehe Tabelle. Im Loader sind Details für alle Chips verfügbar. Diese Ausgabe muss über die serielle Schnittstelle erfasst werden; mit ADB wird sie verpasst.

√ bedeutet: Kapazitätsausgabe vorhanden.

× bedeutet: keine Kapazitätsausgabe.

Die DDR-Details umfassen Typ, Frequenz, Kanal (channel a/channel b), Busbreite BW, Zeilen row, Spalten col, Bänke BK, CS, Die-Busbreite die BW und Gesamtkapazität size.

Bei einem SoC mit einem DDR-Kanal entspricht die Gesamtkapazität “Size” bzw. “Total capacity”. Bei zwei Kanälen ist sie die Summe dieser Werte beider Kanäle.

Die detaillierte Loader-Kapazitätsausgabe lautet:

DDR Version 1.05 20170712
In
Channel a: DDR3 400MHz
Bus Width=32 Col=10 Bank=8 Row=15 CS=1 Die Bus-Width=16 Size=1024MB
Channel b: DDR3 400MHz
Bus Width=32 Col=10 Bank=8 Row=15 CS=1 Die Bus-Width=16 Size=1024MB
Memory OK
Memory OK
OUT

Die detaillierte Kapazitätsausgabe im Kernel lautet:

[ 0.528564] DDR DEBUG: version 1.00 20150126
[ 0.528690] DDR DEBUG: Channel a:
[ 0.528701] DDR DEBUG: DDR3 Device
[ 0.528716] DDR DEBUG: Bus Width=32 Col=10 Bank=8 Row=15 CS=1 Total Capability=1024MB
[ 0.528727] DDR DEBUG: Channel b:
[ 0.528736] DDR DEBUG: DDR3 Device
[ 0.528750] DDR DEBUG: Bus Width=32 Col=10 Bank=8 Row=15 CS=1 Total Capability=1024MB
[ 0.528762] DDR DEBUG: addr=0xd40000

1.10 DDR-Kapazität ändern

Die DDR-Kapazität wird derzeit auf allen Rockchip-Plattformen automatisch erkannt und muss nicht manuell konfiguriert werden. Die hier beschriebenen Änderungen dienen hauptsächlich zur Leistungsbewertung oder zur Untersuchung der Auswirkungen einer geringeren Kapazität.

Eine weitere Methode ist in Rockchip_Developer_Guide_UBoot_Nextdev_CN unter „CH08 Debugging Methods“ → „Modify DDR Capacity“ beschrieben.

Beim Start übergibt der DDR-Initialisierungscode die Kapazität an U-Boot. U-Boot zieht reservierten Sicherheitsspeicher ab und reicht die Angaben an den Kernel weiter. Die an den Kernel übergebene Kapazität kann während der U-Boot-Phase geändert werden.

Codeposition:

./arch/arm/mach-rockchip/param.c

Änderungsschritte:

1. Ergänzen Sie eine Ausgabe der aktuellen DDR-Kapazitätsinformationen.

struct memblock *param_parse_ddr_mem(int *out_count)
{
    ...
    for (i = 0, n = 0; i < count; i++, n++) {
        base = t->u.ddr_mem.bank[i];
        size = t->u.ddr_mem.bank[i + count];
        printf("base:0x%llx, size:0x%llx\n", base, size); //Add this line to print
        /* 0~4GB */
        if (base < SZ_4GB) {
            mem[n].base = base;
            mem[n].size = ddr_mem_get_usable_size(base, size);
    ...
}

Kompilieren und programmieren Sie U-Boot nach dieser Änderung erneut. Das neue Startprotokoll enthält folgende Ausgabe:

U-Boot 2017.09-g0236dc3682-220712-dirty #hcy (Aug 04 2022 - 10:46:07 +0800)
Model: Rockchip RK3568 Evaluation Board
PreSerial: 2, raw, 0xfe660000
DRAM: base:0x0, size:0x40000000 //This line is the output we added

Dabei gilt:

base:0x0, size:0x40000000

Wie unten dargestellt, gibt es einen DRAM-Bereich mit Basisadresse 0x0 und Größe 0x40000000.

Vor dem Kernelstart zieht U-Boot reservierten Sicherheitsspeicher ab und übergibt die DDR-Kapazität wie folgt an den Kernel.

Adding bank: 0x00200000 - 0x08400000 (size: 0x08200000) //After removing the secure memory
block
Adding bank: 0x09400000 - 0x40000000 (size: 0x36c00000) //After removing the secure memory
block
Total: 1182.666 ms
Starting kernel ...
[ 0.000000] Booting Linux on physical CPU 0x0000000000 [0x412fd050]

2. Nachdem Sie diese Darstellung verstanden haben, können Sie die Angaben ändern.

Angenommen, ein weiterer DRAM-Bereich wird an der in der folgenden Abbildung als Region 1 bezeichneten Position hinzugefügt. Dafür sind folgende Änderungen möglich:

struct memblock *param_parse_ddr_mem(int *out_count)
{
    ...
    /* extend top ram size */
    if (t->u.ddr_mem.flags & DDR_MEM_FLG_EXT_TOP)
        gd->ram_top_ext_size = t->u.ddr_mem.data[0];
    //Modify DDR capacity information,starting here
    count = 2;
    t->u.ddr_mem.count = count;
    t->u.ddr_mem.bank[0] = 0x0; //Region 0 base address
    t->u.ddr_mem.bank[0 + count] = 0x40000000 - 0x0; //Region 0 size
    t->u.ddr_mem.bank[1] = 0x70000000; //Region 1 base address
    t->u.ddr_mem.bank[1 + count] = 0x80000000 - 0x70000000; //Region 1 size
    t->u.ddr_mem.hash = 0;
    ///Modify DDR capacity information, end here
    /* normal ram size */
    count = t->u.ddr_mem.count;
    mem = calloc(count + MEM_RESV_COUNT, sizeof(*mem));
    if (!mem) {
        printf("Calloc ddr memory failed\n");
        return 0;
    }
    ...
    for (i = 0, n = 0; i < count; i++, n++) {
        base = t->u.ddr_mem.bank[i];
        size = t->u.ddr_mem.bank[i + count];
        printf("base:0x%llx, size:0x%llx\n", base, size);
        /* 0~4GB */
        if (base < SZ_4GB) {
            mem[n].base = base;
            mem[n].size = ddr_mem_get_usable_size(base, size);
    ...
}

Betrachten wir insbesondere den folgenden Code:

    count = 2; //Indicates that there are 2 blocks of DRAM space
    t->u.ddr_mem.count = count; //Must be written like this
    t->u.ddr_mem.bank[0] = 0x0;
    t->u.ddr_mem.bank[0 + count] = 0x40000000 - 0x0; //The array index must have "+count"
    //Region base address plus Region size is One group, how many groups there are, must be
the same as the "count" above
    t->u.ddr_mem.bank[1] = 0x70000000;
    t->u.ddr_mem.bank[1 + count] = 0x80000000 - 0x70000000; //The array index must have
"+count"
    t->u.ddr_mem.hash = 0; //Must be written like this

Kompilieren und programmieren Sie U-Boot erneut. Im neuen Startprotokoll lässt sich erkennen, dass die Änderungen wirksam sind.

...
U-Boot 2017.09-g0236dc3682-220712-dirty #hcy (Aug 04 2022 - 10:46:07 +0800)
Model: Rockchip RK3568 Evaluation Board
PreSerial: 2, raw, 0xfe660000
DRAM: base:0x0, size:0x40000000
base:0x70000000, size:0x10000000 //this is what we have added
...
Adding bank: 0x00200000 - 0x08400000 (size: 0x08200000)
Adding bank: 0x09400000 - 0x40000000 (size: 0x36c00000)
Adding bank: 0x70000000 - 0x80000000 (size: 0x10000000) //this is what we have added
Total: 1182.666 ms
Starting kernel ...
[ 0.000000] Booting Linux on physical CPU 0x0000000000 [0x412fd050]

Wenn weiterhin nur ein DRAM-Bereich vorhanden ist, dessen Größe aber auf 0x80000000 geändert werden soll, kann folgender Code ergänzt werden.

count = 1; //Indicates that there is 1 block
t->u.ddr_mem.count = count; //Must be written like this
t->u.ddr_mem.bank[0] = 0x0;
t->u.ddr_mem.bank[0 + count] = 0x80000000 - 0x0; //The array index must have "+count"
t->u.ddr_mem.hash = 0; //Must be written like this

==Hinweis: Die DRAM-Kapazität darf nicht beliebig erhöht werden. Ohne tatsächlich vorhandenen Speicher arbeitet das System fehlerhaft. Üblicherweise wird die Größe für Tests reduziert. Region1 wird hier nur zur Veranschaulichung hinzugefügt.==

1.11 DDR-Frequenz überprüfen

Über devfreq:

Bei aktivierter DDR-Frequenzskalierung lässt sich die aktuelle Frequenz über folgende Knoten auslesen:

cat /sys/class/devfreq/dmc/cur_freq

console:/ # cat /sys/class/devfreq/dmc/cur_freq
780000000

Über clk_summary:

cat /sys/kernel/debug/clk/clk_summary | grep scmi_clk_ddr

oder

cat /sys/kernel/debug/clk/clk_summary | grep sclk_ddrc

oder

cat /sys/kernel/debug/clk/clk_summary | grep sclk_ddr

Je nach Kernelversion.

console:/ # cat /sys/kernel/debug/clk/clk_summary | grep scmi_clk_ddr
scmi_clk_ddr 0 0 0 2736000000 0 0 50000
/*2736000000 is the DDR frequency in Hz, that is, 2736MHz*/

1.12 DDR-Frequenz ändern

Der Kernel bietet zwei Strategien: szenarioabhängige und lastabhängige Frequenzskalierung. Kernel 4.4 und spätere Versionen unterscheiden sich dabei von Kernel 3.10.

Kernel 4.4 und spätere Versionen:

Szenarioabhängige Skalierung: Beim Eintritt in ein definiertes Szenario wird die durch SYS_STATUS_XXX festgelegte Frequenz verwendet, sofern die lastabhängige Skalierung deaktiviert ist. Ist sie aktiviert, wird die Frequenz anhand des tatsächlichen DDR-Zustands und der Werte upthreshold/downdifferential erhöht oder gesenkt, jedoch nicht unter SYS_STATUS_XXX.

Lastabhängige Skalierung: In allen Szenarien richtet sich die Frequenz nach der Last, bleibt jedoch oberhalb der durch SYS_STATUS_XXX festgelegten Untergrenze. Nur SYS_STATUS_NORMAL wird vollständig durch die Lastregelung ersetzt; dessen Mindestfrequenz wird durch auto-min-freq statt SYS_STATUS_NORMAL bestimmt.

Kernel 3.10:

Szenarioabhängige Skalierung: Beim Eintritt in ein definiertes Szenario wird die Frequenz auf SYS_STATUS_XXX gesetzt und bleibt dort, auch wenn die lastabhängige Funktion aktiviert ist.

Lastabhängige Skalierung: Ersetzt ausschließlich SYS_STATUS_NORMAL. Nur in diesem Szenario richtet sich die DDR-Frequenz nach der Last.

Die Änderung der DDR-Frequenz muss daher je nach Kernelzweig getrennt behandelt werden.

Für PX30S/RK3326S siehe den späteren Abschnitt zur DDR-Frequenzauswahl dieser Plattformen.

Für Plattformen mit vier Frequenzpunkten in der DDR-Binärdatei siehe den späteren entsprechenden Abschnitt zur Frequenzauswahl.

Bei Kernel 4.4 suchen Sie den dmc-Knoten in DTS. Beim RK3399-EVB befindet er sich beispielsweise in arch/arm64/boot/dts/rockchip/rk3399-evb.dtsi und arch/arm64/boot/dts/rockchip/rk3399.dtsi.

&dmc {
    status = "okay";
    center-supply = <&vdd_center>;
    upthreshold = <40>;
    downdifferential = <20>;
    system-status-freq = <
        /*system status freq(KHz)*/
        SYS_STATUS_NORMAL 800000
        SYS_STATUS_REBOOT 528000
        SYS_STATUS_SUSPEND 200000
        SYS_STATUS_VIDEO_1080P 200000
        SYS_STATUS_VIDEO_4K 600000
        SYS_STATUS_VIDEO_4K_10B 800000
        SYS_STATUS_PERFORMANCE 800000
        SYS_STATUS_BOOST 400000
        SYS_STATUS_DUALVIEW 600000
        SYS_STATUS_ISP 600000
    >;
    /* Each line is used as a group of data, "min_bw "and "max_bw" represent the bandwidth
requirement corresponded by vop.When the requirement value fallling between the range of
"min_bw" and "max_bw", the DDR frequency needs to increase the frequency specified by
"freq", and is valid at "auto-freq-en=1" */
    vop-bw-dmc-freq = <
    /* min_bw(MB/s) max_bw(MB/s) freq(KHz) */
        0 577 200000
        578 1701 300000
        1702 99999 400000
    >;
    auto-min-freq = <200000>;
};

dmc: dmc {
    compatible = "rockchip,rk3399-dmc";
    devfreq-events = <&dfi>;
    interrupts = <GIC_SPI 1 IRQ_TYPE_LEVEL_HIGH 0>;
    clocks = <&cru SCLK_DDRCLK>;
    clock-names = "dmc_clk";
    ddr_timing = <&ddr_timing>;
    /* DDR utilization exceeds 40%, starts to increase frequency when "auto-freq-en=1 " */
    upthreshold = <40>;
    /* DDR utilization less than 20%, start to reduce frequency when "auto-freq-en=1 " */
    downdifferential = <20>;
    system-status-freq = <
    /*system status freq(KHz)*/
    /* It is valid when "auto-freq-en=0". It indicates that this scene is in common use
except for the following scenes */
    SYS_STATUS_NORMAL 800000
    /* It means the DDR frequency before reboot. When auto-freq-en=1, this frequency will be
used as the min value and increased according to the load status */
    SYS_STATUS_REBOOT 528000
    /* It means the DDR frequency at early suspend. When auto-freq-en=1, this frequency will
be used as the min value and increased according to the load status */
    SYS_STATUS_SUSPEND 200000
    /* It means the DDR frequency at playing 1080P video.When auto-freq-en=1, this frequency
will be used as the min value and increased according to the load status */
    SYS_STATUS_VIDEO_1080P 300000
    /* It means the DDR frequency at playing 4K video When auto-freq-en=1, this frequency
will be used as the min value and increased according to the load status */
    SYS_STATUS_VIDEO_4K 600000
    /* It means the DDR frequency at playing 4K 10bit video. When auto-freq-en=1, this
frequency will be used as the min value and increased according to the load status */
    SYS_STATUS_VIDEO_4K_10B 800000
    /* It means the DDR frequency at performance mode.When auto-freq-en=1, this frequency
will be used as the min value and increased according to the load status */
    SYS_STATUS_PERFORMANCE 800000
    /* It means the DDR frequency at touching,getting higher frequency from low in order to
improve touching respond.When auto-freq-en=1, this frequency will be used as the min value
and increased according to the load status */
    SYS_STATUS_BOOST 400000
    /* It means the DDR frequency at dual display mode.When auto-freq-en=1, this frequency
will be used as the min value and increased according to the load status */
    SYS_STATUS_DUALVIEW 600000
    /* It means the DDR frequency at ISP mode.When auto-freq-en=1, this frequency will be
used as the min value and increased according to the load status */
    SYS_STATUS_ISP 600000
    >;
    /* When auto-freq-en=1, this frequency will be used as the min value of
SYS_STATUS_NORMAL scenario */
    auto-min-freq = <400000>;
    /* The value equals to 1,which indicates this function is on, to 0,which means off.If it
is on, "SYS_STATUS_NORMAL" will be taken by the load frequency completely and the lowest
frequency is" auto-min-freq" instead of "SYS_STATUS_NORMAL".That means,it takes the
frequency defined by this scene as the lowest frequency and the system will increase or
reduece DDR frequency through "upthreshold/downdifferential" according to DDR utilization */
    auto-freq-en = <1>;
    status = "disabled";
};

==Hinweis 1==: Die Frequenz-/Spannungsbehandlung von Kernel 4.4 unterscheidet sich von Kernel 3.10. Exakt wird nur eine in dmc_opp_table als opp-hz aufgeführte Frequenz verwendet. Zwischenwerte werden auf die passende höhere Stufe gerundet; Werte oberhalb der maximalen Stufe werden auf diese begrenzt. Beachten Sie daher dmc_opp_table, wenn diese Begrenzung unerwünscht ist.

dmc_opp_table: opp-table3 {
    opp-200000000 {
        /* When the DDR frequency equals to 200MHz,this voltage is effective;less than
200MHz,running at 200MHz */
        opp-hz = /bits/ 64 <200000000>;
        opp-microvolt = <825000>; //vdd_center voltage
    };
    ...
    opp-800000000 {
        opp-hz = /bits/ 64 <800000000>;
        opp-microvolt = <900000>;
    };
};

Nachdem Sie die Konfiguration verstanden haben, ändern Sie die Frequenzdefinition des gewünschten Szenarios. Bei auto-freq-en=1 lässt sich die Frequenz nicht direkt festhalten. Zur Fehlersuche durch Frequenzsenkung setzen Sie auto-freq-en auf 0 und passen anschließend die Frequenzen der einzelnen Szenarien an.

==Hinweis 2==: Bei RK3399 mit LPDDR4 und RV1126 werden die unterstützten Skalierungsfrequenzen bereits im Loader festgelegt und während der DDR-Initialisierung seriell ausgegeben. Die Frequenzen in dmc_opp_table müssen damit übereinstimmen.

Beim RV1126-Beispiel gibt der Loader 328MHz, 528MHz, 784MHz und 924MHz aus. dmc_opp_table darf daher nur diese vier Frequenzen enthalten.

change to: 328MHz
change to: 528MHz
change to: 784MHz
change to: 924MHz(final freq)

dmc_opp_table: dmc-opp-table {
    compatible = "operating-points-v2";
    opp-328000000 {
        opp-hz = /bits/ 64 <328000000>;
        opp-microvolt = <800000>;
    };
    opp-528000000 {
        opp-hz = /bits/ 64 <528000000>;
        opp-microvolt = <800000>;
    };
    opp-784000000 {
        opp-hz = /bits/ 64 <784000000>;
        opp-microvolt = <800000>;
    };
    opp-924000000 {
        opp-hz = /bits/ 64 <924000000>;
        opp-microvolt = <800000>;
    };
};

Stimmen dmc_opp_table und Loader nicht überein, tritt beim Frequenzwechsel durch den Kernel-dmc-Treiber ein Frequenzzuordnungsfehler auf. Das Protokoll lautet:

rockchip-dmc dmc: Get wrong frequency, Request 1056000000, Current 924000000

Bei Kernel 3.10 suchen Sie clk_ddr_dvfs_table in DTS. Beim RK3288-SDK liegt der letztlich wirksame Knoten beispielsweise in arch/arm/boot/dts/rk3288-tb_8846.dts.

&clk_ddr_dvfs_table {
    /* The logic voltage corresponding to the DDR frequency, if the frequency in "freq-
table" or "bd-freq-table" is larger than the maximum frequency here, the corresponding
voltage cannot be found and can not switched to the corresponding frequency. At this time,
you need to add frequency voltage table here */
    operating-points = <
        /* KHz uV */
        200000 1050000
        300000 1050000
        400000 1100000
        533000 1150000
        >;
    freq-table = <
        /*status freq(KHz)*/
        /* It is valid only when "auto-freq-en=0".And it indicates that this scene is common
use scene except for the following scenes */
        SYS_STATUS_NORMAL 400000
        /* DDR frequency at the early suspend */
        SYS_STATUS_SUSPEND 200000
        /* DDR frequency at playing 1080P video */
        SYS_STATUS_VIDEO_1080P 240000
        /* DDR frequency at playing 4K video */
        SYS_STATUS_VIDEO_4K 400000
        /* DDR frequency at playing 60FPS video */
        SYS_STATUS_VIDEO_4K_60FPS 400000
        /* DDR frequency at performance mode */
        SYS_STATUS_PERFORMANCE 528000
        /* DDR frequency at dual display */
        SYS_STATUS_DUALVIEW 400000
        /* DDR frequency at touching,getting higher frequency from low in order to improve
touching respond */
        SYS_STATUS_BOOST 324000
        /* DDR frequency at ISP */
        SYS_STATUS_ISP 400000
        >;
    bd-freq-table = <
        /* bandwidth freq */
        5000 800000
        3500 456000
        2600 396000
        2000 324000
    >;
    /* After the load frequency scaling turned on,where the "SYS_STATUS_NORMAL" scenario, it
will switch between several frequencies listed by this table according to the DDR bandwidth
utilization */
    auto-freq-table = <
        240000
        324000
        396000
        528000
        >;
    /* The value equals to "1", indicating that the load frequency conversion function is
enabled; equals to 0, means disabled. After the load frequency conversion function turning
on, the "SYS_STATUS_NORMAL" scene frequency scaling will be completely replaced by the load
scaling frequency */
    auto-freq=<1>;
    /*
     * 0: use standard flow
     * 1: vop dclk never divided
     * 2: vop dclk always divided
     */
    vop-dclk-mode = <0>;
    status="okay";
};

Nachdem Sie die Konfiguration verstanden haben, ändern Sie die Frequenzdefinition des gewünschten Szenarios. Bei auto-freq-en=1 lässt sich die Frequenz nicht direkt festhalten. Zur Fehlersuche durch Frequenzsenkung setzen Sie auto-freq-en auf 0 und passen anschließend die Frequenzen der einzelnen Szenarien an.

==Hinweis: Stellen Sie sicher, dass die Spannung für die gewählte Frequenz geeignet ist.== Zur Spannungsänderung siehe den Abschnitt zur Spannung einer bestimmten DDR-Frequenz.

Laut dieser Quellzeile ist bei kernel3.10 dvfs_ddr_table in der Boarddatei borad-**.c zu suchen. Beim RK3066-SDK liegt es beispielsweise in arch/arm/mach-rk30/board-rk30-sdk.c.

static struct cpufreq_frequency_table dvfs_ddr_table[] = {
    /* DDR frequency at the early suspend */
    {.frequency = 200 * 1000 + DDR_FREQ_SUSPEND, .index = 1050 * 1000},
    /* DDR frequency at playing video */
    {.frequency = 300 * 1000 + DDR_FREQ_VIDEO, .index = 1050 * 1000},
    /* it indicates that this scene is common use scene except for above two scenes */
    {.frequency = 400 * 1000 + DDR_FREQ_NORMAL, .index = 1125 * 1000},
    {.frequency = CPUFREQ_TABLE_END},
};

Kernel 3.0 besitzt nur drei Szenarien. Ändern Sie den Wert “200 * 1000” von .frequency; die Einheit ist KHz. Der Zusatz “+ DDR_FREQ_SUSPEND” kann dabei ignoriert werden.

==Hinweis: Stellen Sie sicher, dass die Spannung für die gewählte Frequenz geeignet ist.== Zur Spannungsänderung siehe den Abschnitt zur Spannung einer bestimmten DDR-Frequenz.

1.12.1 RK3399 mit LPDDR4 für 928MHz konfigurieren

1. Ändern Sie RKBOOT/RK3399MINIALL.ini im rkbin-Verzeichnis, wählen Sie die 933MHz-DDR-Binärdatei und packen Sie den Loader.

diff --git a/RKBOOT/RK3399MINIALL.ini b/RKBOOT/RK3399MINIALL.ini
index d8e71dd7..3e20f255 100755
--- a/RKBOOT/RK3399MINIALL.ini
+++ b/RKBOOT/RK3399MINIALL.ini
@@ -5,7 +5,7 @@ MAJOR=1
 MINOR=26
 [CODE471_OPTION]
 NUM=1
-Path1=bin/rk33/rk3399_ddr_800MHz_v1.27.bin
+Path1=bin/rk33/rk3399_ddr_933MHz_v1.27.bin
 Sleep=1
 [CODE472_OPTION]
 NUM=1
@@ -14,7 +14,7 @@ Path1=bin/rk33/rk3399_usbplug_v1.26.bin
 NUM=2
 LOADER1=FlashData
 LOADER2=FlashBoot
-FlashData=bin/rk33/rk3399_ddr_800MHz_v1.27.bin
+FlashData=bin/rk33/rk3399_ddr_933MHz_v1.27.bin
 FlashBoot=bin/rk33/rk3399_miniloader_v1.26.bin
 [OUTPUT]
 PATH=rk3399_loader_v1.27.126.bin

Nach Programmierung des gepackten Loaders zeigt das serielle Protokoll fünf unterstützte Frequenzen: 416MHz, 856MHz, 328MHz, 666MHz und 928MHz. Die aktuell laufende DDR-Frequenz beträgt 856MHz.

DDR Version 1.27 20211018
In
...
support 416 856 328 666 928 MHz, current 856MHz
OUT

2. Ändern Sie im Kernel-DTS-Knoten dmc_opp_table die Eigenschaft status = “disabled” von opp-928000000 auf status = “okay”, oder entfernen Sie die status-Eigenschaft.

                opp-928000000 {
                        opp-hz = /bits/ 64 <928000000>;
                        opp-microvolt = <900000>;
- status = "disabled";
                };

3. Ersetzen Sie im Kernel-DTS-dmc-Knoten alle “856000” der Tabelle system-status-freq durch “928000”. Alternativ passen Sie die SYS_STATUS_XXX-Szenarien gemäß dem Abschnitt zur DDR-Frequenzänderung gezielt an den Bandbreitenbedarf des Projekts an.

1.12.2 DDR-Frequenzauswahl für PX30S/RK3326S

RK3326S/PX30S unterstützt nur vier Frequenzpunkte. Diese werden im Knoten ddrx_params von arch/arm64/boot/dts/rockchip/px30s-dram-default-timing.dtsi und im Knoten px30s_dmc_opp_table von arch/arm64/boot/dts/rockchip/px30.dtsi konfiguriert.

Bei DDR3 konfigurieren Sie freq_0, freq_1, freq_2 und freq_3 in ddr3_params; bei DDR4 entsprechend in ddr4_params.

Alle DDR-Typen teilen sich die Frequenzliste in px30s_dmc_opp_table. Aktivierte Frequenzen müssen zu freq_0, freq_1, freq_2 und freq_3 des jeweiligen ddrx_params-Knotens passen. Bei LPDDR4 müssen sie also den Werten in lpddr4_params entsprechen. Beispiel:

px30s_dmc_opp_table: px30s-dmc-opp-table {
    compatible = "operating-points-v2";
    opp-328000000 {
        opp-hz = /bits/ 64 <328000000>;
        opp-microvolt = <1000000>;
    };
    opp-666000000 {
        opp-hz = /bits/ 64 <666000000>;
        opp-microvolt = <1000000>;
    };
    opp-786000000 {
        opp-hz = /bits/ 64 <786000000>;
        opp-microvolt = <1000000>;
    };
    opp-924000000 {
        opp-hz = /bits/ 64 <924000000>;
        opp-microvolt = <1000000>;
    };
    /* 1056M only for LP4 */
    opp-1056000000 {
        opp-hz = /bits/ 64 <1056000000>;
        opp-microvolt = <1000000>;
        status = "disabled";
    };
};

/ {
    ...
    lpddr4_params: lpddr4-params {
        ...
        /* freq info, freq_0 is final frequency, unit: MHz */
        freq_0 = <924>;
        freq_1 = <328>;
        freq_2 = <666>;
        freq_3 = <786>;
        ...
    };
};

Soll LPDDR4 mit 1056 MHz laufen, ändern Sie einen der Werte freq_0, freq_1, freq_2 oder freq_3 in lpddr4_params auf 1056. Deaktivieren Sie außerdem den alten Frequenzpunkt in px30s_dmc_opp_table und ergänzen Sie 1056000000.

Die neue Konfiguration lautet:

px30s_dmc_opp_table: px30s-dmc-opp-table {
    compatible = "operating-points-v2";
    opp-328000000 {
        opp-hz = /bits/ 64 <328000000>;
        opp-microvolt = <1000000>;
    };
    opp-666000000 {
        opp-hz = /bits/ 64 <666000000>;
        opp-microvolt = <1000000>;
    };
    opp-786000000 {
        opp-hz = /bits/ 64 <786000000>;
        opp-microvolt = <1000000>;
    };
    opp-924000000 {
        opp-hz = /bits/ 64 <924000000>;
        opp-microvolt = <1000000>;
        status = "disabled";
    };
    /* 1056M only for LP4 */
    opp-1056000000 {
        opp-hz = /bits/ 64 <1056000000>;
        opp-microvolt = <1000000>;
    };
};

/ {
    ...
    lpddr4_params: lpddr4-params {
        ...
        /* freq info, freq_0 is final frequency, unit: MHz */
        freq_0 = <1056>;
        freq_1 = <328>;
        freq_2 = <666>;
        freq_3 = <786>;
        ...
    };
};

1.12.3 Frequenzauswahl bei DDR-Binärdateien mit vier Frequenzpunkten

Dieser Abschnitt gilt für die zuvor aufgeführten Plattformen mit vier Frequenzpunkten, mit Ausnahme von RV1126.

Der Loader dieser Plattformen führt vier Frequenzwechsel aus und speichert die zugehörigen Trainingsergebnisse.

F1, F2, F3 und F0 bezeichnen diese vier Frequenzen. Standardmäßig wird der Loader mit F0 verlassen.

DDR ... v1.14
LPDDR4X, 2112MHz
channel[0] BW=16 Col=10 Bk=8 CS0 Row=16/0 CS1 Row=16/0 CS=2 Die BW=16 Size=2048MB
channel[1] BW=16 Col=10 Bk=8 CS0 Row=16/0 CS1 Row=16/0 CS=2 Die BW=16 Size=2048MB
channel[2] BW=16 Col=10 Bk=8 CS0 Row=16/0 CS1 Row=16/0 CS=2 Die BW=16 Size=2048MB
channel[3] BW=16 Col=10 Bk=8 CS0 Row=16/0 CS1 Row=16/0 CS=2 Die BW=16 Size=2048MB
...
change to F1: 528MHz /* 4 DDR frequencies*/
change to F2: 1068MHz
change to F3: 1560MHz
change to F0: 2112MHz
out

Obwohl die unterstützten Frequenzen bereits im Loader festgelegt werden, liest der Kernel-dmc-Treiber sie automatisch aus. Deshalb besteht kein Zuordnungsproblem mit dmc_opp_table. Die Kernel-dmc-Knoten lauten:

dmc: dmc {
    ...
    system-status-freq = <
    /*system status freq(KHz)*/
    SYS_STATUS_NORMAL DMC_FREQ_LEVEL_MID_HIGH
    SYS_STATUS_REBOOT DMC_FREQ_LEVEL_MID_LOW
    ...
    SYS_STATUS_SUSPEND DMC_FREQ_LEVEL_LOW
    ...
    SYS_STATUS_PERFORMANCE DMC_FREQ_LEVEL_HIGH
    ...
    >;
    ...
};

Die Frequenzen der Szenarien werden nicht mehr direkt angegeben, sondern durch Makros wie DMC_FREQ_LEVEL_HIGH. Diese ordnen sich automatisch den vier Loader-Frequenzen zu. Werden diese mit dem Werkzeug zur DDR-Binärdateibearbeitung geändert, folgen die Makros automatisch den neuen Werten. Für das obige Loader-Beispiel gilt:

Zur Änderung der Frequenzwerte F0, F1, F2 und F3 siehe den Abschnitt zur Bearbeitung der DDR-Binärdatei.

Um die Frequenz eines Szenarios wie SYS_STATUS_NORMAL oder SYS_STATUS_REBOOT zu ändern, ersetzen Sie dessen Frequenzdefinition durch DMC_FREQ_LEVEL_HIGH, DMC_FREQ_LEVEL_MID_HIGH, DMC_FREQ_LEVEL_MID_LOW oder DMC_FREQ_LEVEL_LOW.

1.13 Spannung einer bestimmten DDR-Frequenz ändern

Zur Fehlersuche durch befehlsbasierte Spannungsänderung gilt: Nach Kernel 4.4 kann die Spannung eines Regulators direkt über /sys/kernel/debug/regulator/ angepasst werden. Fixieren Sie zuvor die DDR-Frequenz, da sonst Konflikte mit der Spannungsregelung der Frequenzskalierung entstehen. Siehe den Abschnitt zum Fixieren der DDR-Frequenz.

Beispiel für die Spannungsanpassung auf RK3588:

cat /sys/kernel/debug/regulator/vdd_ddr_s0/voltage
echo 700000 > /sys/kernel/debug/regulator/vdd_ddr_s0/voltage

Je nach Plattform müssen folgende Regulatoren angepasst werden:

Kernel 4.4: Kompilieren Sie den Kernel mit aktivierter Option “pm_tests”: make ARCH=arm64 menuconfig → Device Drivers → SOC (System On Chip) specific Drivers → Rockchip pm_test support.

Kernel 3.10: Kompilieren Sie den Kernel mit aktivierter Option “pm_tests”: make menuconfig → System Type → /sys/pm_tests/ support.

Befehl zur Änderung der DDR-Spannung:

RK3399

echo set vdd_center 900000 > /sys/pm_tests/clk_volt

Andere Chips

echo set vdd_logic 1200000 > /sys/pm_tests/clk_volt

Fehlt “pm_tests” oder genügt der Befehl nicht, muss die Kernel-Firmware wie folgt geändert werden:

Bei Kernel 4.4 suchen Sie dmc_opp_table in DTS. Beim RK3399-EVB liegt der Knoten in arch/arm64/boot/dts/rockchip/rk3399-opp.dtsi, beim RK3368 in arch/arm64/boot/dts/rockchip/rk3368.dtsi.

Beispiel RK3399:

/* it runs in this frequency only when frequency equals to "opp-hz"listed by
"dmc_opp_table".If the frequency less than "opp-hz", the frequency will getting
higher,otherwise, it exceeds "opp-hz" the upper limited,it will restricted by "opp-hz".It is
different from kernel 3.10 */
dmc_opp_table: opp-table3 {
    compatible = "operating-points-v2";
    opp-200000000 {
        /* When the DDR frequency equals to 200MHz,this voltage is effective;less than
200MHz,running at 200MHz */
        opp-hz = /bits/ 64 <200000000>;
        opp-microvolt = <825000>; //vdd_center voltage
    };
    opp-300000000 {
        opp-hz = /bits/ 64 <300000000>;
        opp-microvolt = <850000>;
    };
    opp-400000000 {
        opp-hz = /bits/ 64 <400000000>;
        opp-microvolt = <850000>;
    };
    opp-528000000 {
        opp-hz = /bits/ 64 <528000000>;
        opp-microvolt = <900000>;
    };
    opp-600000000 {
        opp-hz = /bits/ 64 <600000000>;
        opp-microvolt = <900000>;
    };
    opp-800000000 {
        opp-hz = /bits/ 64 <800000000>;
        opp-microvolt = <900000>;
    };
};

Beispiel RK3368:

/* it runs in this frequency only when frequency equals to "opp-hz"listed by
"dmc_opp_table".If the frequency less than "opp-hz", the frequency will getting
higher,otherwise, it exceeds "opp-hz" the upper limited,it will restricted by "opp-hz".It is
different from kernel 3.10 */
dmc_opp_table: opp_table2 {
    compatible = "operating-points-v2";
    opp-192000000 {
        /* When the DDR frequency equals to 200MHz,this voltage is effective;less than
200MHz,running at 200MHz */
        opp-hz = /bits/ 64 <192000000>;
        opp-microvolt = <1100000>; //vdd_logic voltage
    };
    opp-300000000 {
        opp-hz = /bits/ 64 <300000000>;
        opp-microvolt = <1100000>;
    };
    opp-396000000 {
        opp-hz = /bits/ 64 <396000000>;
        opp-microvolt = <1100000>;
    };
    opp-528000000 {
        opp-hz = /bits/ 64 <528000000>;
        opp-microvolt = <1100000>;
    };
    opp-600000000 {
        opp-hz = /bits/ 64 <600000000>;
        opp-microvolt = <1100000>;
    };
};

Die zur Frequenz gehörende Spannung kann geändert werden. Die Frequenz-/Spannungstabelle liefert nur Zuordnungen innerhalb ihres definierten Frequenzbereichs. Für eine neue Frequenz oberhalb der Tabellengrenze fehlt eine passende Spannung, sodass der DDR-Wechsel scheitert. Ergänzen Sie in diesem Fall einen entsprechenden Frequenz-/Spannungseintrag.

Bei Kernel 3.10 suchen Sie clk_ddr_dvfs_table in DTS. Beim RK3288-SDK liegt der wirksame Knoten beispielsweise in arch/arm/boot/dts/rk3288-tb_8846.dts.

&clk_ddr_dvfs_table {
    /* This is Frequency-voltage table */
    operating-points = <
        /* KHz uV */
        /* it is show when DDR frequency less than or equals to 200MHz,logic voltage uses
1050mV.Other lines mean the same here */
        200000 1050000
        300000 1050000
        400000 1100000
        533000 1150000
        >;
    ...
    status="okay";
};

Die zur Frequenz gehörende Spannung kann geändert werden. Die Frequenz-/Spannungstabelle liefert nur Zuordnungen innerhalb ihres definierten Frequenzbereichs. Für eine neue Frequenz oberhalb der Tabellengrenze fehlt eine passende Spannung, sodass der DDR-Wechsel scheitert. Ergänzen Sie in diesem Fall einen entsprechenden Frequenz-/Spannungseintrag.

Bei Kernel 3.0 ändern Sie dvfs_ddr_table in borad-**.c. Beim RK3066-SDK

liegt diese Boarddatei unter arch/arm/mach-rk30/board-rk30-sdk.c.

static struct cpufreq_frequency_table dvfs_ddr_table[] = {
    {.frequency = 200 * 1000 + DDR_FREQ_SUSPEND, .index = 1050 * 1000},
    {.frequency = 300 * 1000 + DDR_FREQ_VIDEO, .index = 1050 * 1000},
    {.frequency = 400 * 1000 + DDR_FREQ_NORMAL, .index = 1125 * 1000},
    {.frequency = CPUFREQ_TABLE_END},
};

“.index” in dvfs_ddr_table bezeichnet die zugehörige Spannung in uV.

1.14 Lastabhängige Skalierung deaktivieren und nur Szenarioskalierung beibehalten

Ab Kernel 4.4 suchen Sie auto-freq-en im DTS-dmc-Knoten. Beim RK3399-EVB liegt es beispielsweise in arch/arm64/boot/dts/rockchip/rk3399.dtsi.

dmc: dmc {
    compatible = "rockchip,rk3399-dmc";
    ...
    auto-min-freq = <400000>;
    /* Set this value to 0 to close the load DDR Frequency scaling with leaving only the
scene frequency scaling */
    auto-freq-en = <0>;
    ...
};

Bei Kernel 3.10 suchen Sie clk_ddr_dvfs_table in DTS. Beim RK3288-EVB liegt es beispielsweise in arch/arm/boot/dts/rk3288-tb_8846.dts.

&clk_ddr_dvfs_table {
    ...
    /* Set this value to 0 to close the load DDR Frequency scaling with leaving only the
scene frequency scaling */
    auto-freq=<0>;
    ...
    status="okay";
};

Kernel 3.0 unterstützt keine lastabhängige Frequenzskalierung; sie muss daher nicht deaktiviert werden.

1.15 DDR-Frequenz fixieren

Zur Fehlersuche können Sie die DDR-Frequenz mit folgenden Befehlen fixieren:

Kernel 4.4 und spätere Versionen:

Verfügbare DDR-Frequenzen abfragen: cat /sys/class/devfreq/dmc/available_frequencies

Frequenz setzen:

echo userspace > /sys/class/devfreq/dmc/governor
echo 300000000 > /sys/class/devfreq/dmc/min_freq //This line purposes to prevent the frequency to be set lower than "min_freq", cause operation failed.
echo 300000000 > /sys/class/devfreq/dmc/userspace/set_freq

Kernel 3.10:

Kompilieren Sie den Kernel mit aktivierter Option “pm_tests”: make menuconfig → System Type → /sys/pm_tests/ support. Der Befehl zum Fixieren der DDR-Frequenz lautet:

echo set clk_ddr 300000000 > /sys/pm_tests/clk_rate

Die Frequenzeinheit ist Hz; der Befehlsparameter kann nach Bedarf geändert werden.

Ist diese Methode nicht möglich, müssen Code oder DTS angepasst werden.

Ab Kernel 4.4 liegt ein Fehlschlag meist daran, dass die Zielfrequenz nicht in der Ausgabe von cat /sys/class/devfreq/dmc/available_frequencies enthalten ist.

Ergänzen Sie die Zielfrequenz in dmc_opp_table der boardspezifischen DTS-Datei. Beim RK3399-EVB liegt diese in arch/arm64/boot/dts/rockchip/rk3399-opp.dtsi. Beispiel für 666MHz:

dmc_opp_table: opp-table3 {
compatible = "operating-points-v2";
opp-200000000 {
    opp-hz = /bits/ 64 <200000000>;
    opp-microvolt = <825000>;
};
...
opp-666000000 {
    /* When DDR frequency equals to 666MHz,use this voltage */
    opp-hz = /bits/ 64 <666000000>;
    opp-microvolt = <900000>; //vdd_center voltage
};
opp-800000000 {
    opp-hz = /bits/ 64 <800000000>;
    opp-microvolt = <900000>;
};
};

Anschließend kann die Frequenz mit dem vorherigen Befehl fixiert werden.

Soll das Gerät ohne manuelle Befehlseingabe bereits mit einer festen Frequenz starten, ändern Sie DTS wie folgt:

Angenommen, die Zielfrequenz beträgt 666MHz. Der dmc-Knoten des RK3399-EVB liegt beispielsweise in arch/arm64/boot/dts/rockchip/rk3399-evb.dtsi.

/* Here "dfi" status must be "okay", it is due to lagacy code, the dmc node is
restriced by the dfi node. If the "dfi" node is disabled, it will also invalidate the
dmc node. So it is best to keep the status of the "dfi" node consistent with dmc */
&dfi {
    status = "okay";
};
&dmc {
status = "okay";
...
system-status-freq = <
    /*system status freq(KHz)*/
    SYS_STATUS_NORMAL 666000
    /* Remove the rest scenario */
    /*
    SYS_STATUS_REBOOT 528000
    SYS_STATUS_SUSPEND 200000
    SYS_STATUS_VIDEO_1080P 200000
    SYS_STATUS_VIDEO_4K 600000
    SYS_STATUS_VIDEO_4K_10B 800000
    SYS_STATUS_PERFORMANCE 800000
    SYS_STATUS_BOOST 400000
    SYS_STATUS_DUALVIEW 600000
    SYS_STATUS_ISP 600000
    */
>;
...
auto-min-freq = <666000>;
/* The value of "auto-freq-en" shall be 0 to disable load DDR Frequency scaling */
auto-freq-en = <0>;
};

Bei Kernel 3.10 suchen Sie clk_ddr_dvfs_table. Beim RK3288-SDK liegt es beispielsweise in arch/arm/boot/dts/rk3288-tb_8846.dts.

&clk_ddr_dvfs_table {
    operating-points = <
        /* KHz uV */
        /* step 3,if the target frequency exceeds the maximun of this table,you shall add
the voltage table corresponding to the target frequency */
        200000 1050000
        300000 1050000
        400000 1100000
        533000 1150000
        >;
    freq-table = <
        /*status freq(KHz)*/
        /* step 2, Comment out the other scenario,keep "SYS_STATUS_NORMAL" and define it to
you target frequency, for example you need 400MHz as below */
        SYS_STATUS_NORMAL 400000
        /*
        SYS_STATUS_SUSPEND 200000
        SYS_STATUS_VIDEO_1080P 240000
        SYS_STATUS_VIDEO_4K 400000
        SYS_STATUS_VIDEO_4K_60FPS 400000
        SYS_STATUS_PERFORMANCE 528000
        SYS_STATUS_DUALVIEW 400000
        SYS_STATUS_BOOST 324000
        SYS_STATUS_ISP 400000
        */
        >;
    bd-freq-table = <
        /* bandwidth freq */
        5000 800000
        3500 456000
        2600 396000
        2000 324000
    >;
    auto-freq-table = <
        240000
        324000
        396000
        528000
        >;
    /* setp 1，set 0 to disable load DDR Frequency scaling */
    auto-freq=<0>;
    /*
     * 0: use standard flow
     * 1: vop dclk never divided
     * 2: vop dclk always divided
     */
    vop-dclk-mode = <0>;
    status="okay";
};

Drei Schritte ergeben eine Firmware mit fester Frequenz:

1. Setzen Sie die lastabhängige Frequenzregelung auf 0.

2. Kommentieren Sie die anderen Szenarien aus; behalten Sie nur “SYS_STATUS_NORMAL” und setzen Sie es auf die Zielfrequenz.

3. Überschreitet die Zielfrequenz das Tabellenmaximum, ergänzen Sie den passenden Spannungseintrag.

Bei Kernel 3.0 ändern Sie dvfs_ddr_table in borad-**.c. Beim RK3066-SDK liegt die Boarddatei unter arch/arm/mach-rk30/board-rk30-sdk.c.

static struct cpufreq_frequency_table dvfs_ddr_table[] = {
    /* */
    /* step 1. Comment out the other scene with leaving "DDR_FREQ_NORMAL" only */
    //{.frequency = 200 * 1000 + DDR_FREQ_SUSPEND, .index = 1050 * 1000},
    //{.frequency = 300 * 1000 + DDR_FREQ_VIDEO, .index = 1050 * 1000},
    /* step 2, Define "DDR_FREQ_NORMAL" to your target frequency,meanwhile pay attention to
whether the voltage match the frequency or not */
    {.frequency = 400 * 1000 + DDR_FREQ_NORMAL, .index = 1125 * 1000},
    {.frequency = CPUFREQ_TABLE_END},
};

Zwei Schritte ergeben eine Firmware mit fester Frequenz:

1. Kommentieren Sie alle anderen Szenarien aus und behalten Sie nur “DDR_FREQ_NORMAL”.

2. Setzen Sie “DDR_FREQ_NORMAL” auf die Zielfrequenz und prüfen Sie, ob die Spannung dazu passt.

1.16 DDR-Bandbreitenauslastung ermitteln

Kernel 4.4 und spätere Versionen bieten einen Befehl zur Anzeige der gesamten DDR-Bandbreitenauslastung.

rk3288:/sys/class/devfreq/dmc # cat load
11@396000000Hz

“11” bedeutet eine aktuelle Auslastung von 11%.

Rockchip stellt außerdem ein spezielles Programm zur Beobachtung der DDR-Bandbreite bereit. Einzelheiten siehe das Kapitel zum DDR-Bandbreitenwerkzeug.

1.17 DDR-Zuverlässigkeit testen

Siehe das Dokument “DDR-Verification-Process”.

1.18 Maximale DDR-Betriebsfrequenz bestimmen

1. Ergänzen Sie zunächst die passende Frequenz-/Spannungszuordnung. Siehe die Abschnitte zur Änderung der DDR-Frequenz und der zugehörigen Spannung.

2. Prüfen Sie auf Plattformen mit Augendiagrammwerkzeug das Augendiagramm gemäß dem entsprechenden Kapitel.

3. Führen Sie Google stressapptest von hohen zu niedrigeren Frequenzen aus. Bei einem Fehler senken Sie die Frequenz und wiederholen den Test. Ohne Fehler verlängern Sie die Testdauer; bleibt der Betrieb stabil, fahren Sie mit dem nächsten Schritt fort.

Google stressapptest befindet sich unter https://redmine.rock-chips.com/documents/49 → DDR related information_VerX.XX.7z → DDR particle verification_DDR test resource file → static_stressapptest. Zur Verwendung siehe das Kapitel Guide_DDR_Verification_Process.

4. Die vorherigen Schritte grenzen die höchste Frequenz grob ein. Führen Sie nun memtester aus. Bei einem Fehler senken Sie die Frequenz und wiederholen den Test. Ohne Fehler verlängern Sie die Testdauer; bleibt der Betrieb stabil, kann dieser höchste Frequenzpunkt bestätigt werden.

memtester befindet sich unter https://redmine.rock-chips.com/documents/49 → DDR related information_VerX.XX.7z → DDR particle verification_DDR test resource file → static_memtester. Zur Verwendung siehe das Kapitel Guide_DDR_Verification_Process.

Google stressapptest prüft grob und meldet Fehler oft schnell. memtester arbeitet gründlicher und benötigt für Fehlermeldungen entsprechend länger. Es dient vor allem der Signalprüfung und deckt Bereiche ab, die stressapptest möglicherweise nicht erfasst.

Diese softwarebasierten Verfahren dienen der schnellen Ermittlung einer Maximalfrequenz. Sie garantieren nicht, dass die tatsächliche DDR-Signalintegrität dort den JEDEC-Anforderungen genügt. Dafür sind Signalmessungen und Belastungstests erforderlich.

1.19 DDR-Self-Refresh erkennen

Der Zustand lässt sich durch Messen von CKE erkennen. Dafür ist kein Oszilloskop mit besonders hoher Bandbreite erforderlich.

Wechselt CKE zwischen längeren Low- und High-Phasen, gilt dieselbe Zuordnung: DDR tritt in Self-Refresh ein und kehrt später in den Normalzustand zurück.

Hinweis: CKE muss länger als 7.8 us Low sein, um Self-Refresh anzuzeigen. Auch Power-Down hat einen Low-Pegel, jedoch kürzer als 7.8 us. Verwechseln Sie diese Zustände nicht.

1.20 Automatischen DDR-Power-Down erkennen

Der Zustand lässt sich durch Messen von CKE erkennen. Dafür ist kein Oszilloskop mit besonders hoher Bandbreite erforderlich.

Im automatischen Power-Down bleibt CKE knapp 7.8us bei DDR3/DDR4 bzw. 3.9us bei LPDDR2/LPDDR3/LPDDR4 Low, wird kurz High und kehrt wieder für diese Zeitspanne auf Low zurück.

Hinweis: Für automatischen Power-Down muss die Low-Dauer unter 7.8us bei DDR3/DDR4 bzw. unter 3.9us bei LPDDR2/LPDDR3/LPDDR4 liegen.

1.21 Self-Refresh und Power-Down deaktivieren

Alle DDR-Bausteine besitzen grundlegende Stromsparfunktionen wie Self-Refresh und Power-Down. Diese sind auch softwareseitig aktiviert. Je nach Leerlaufdauer tritt DDR in einen dieser Zustände ein.

Wenn Stromsparfunktionen nicht benötigt werden, allein die Leistung zählt oder die DDR-Bausteine Probleme mit diesen Zuständen haben, können sie wie folgt deaktiviert werden.

Setzen Sie sr_idle in der folgenden Abbildung auf 0, um den leerlaufabhängigen Eintritt in Self-Refresh zu deaktivieren.

Editierbare Screenshot-Abschrift mit Originalfeldern und -werten:

Setzen Sie pd_idle in der folgenden Abbildung auf 0, um den leerlaufabhängigen Eintritt

in Power-Down zu deaktivieren.

Editierbare Screenshot-Abschrift mit Originalfeldern und -werten:

1.22 De-Skew von DQ/DQS/CA/CLK anpassen

Unterschiedliche DDR-Leiterbahnlängen auf der Leiterplatte können durch Skew-Anpassung ähnlich wie durch Längenabgleich kompensiert werden. Dazu enthält die DDR-PHY seriell geschaltete Verzögerungselemente in den Signalleitungen. Über Skew-Register wird deren Anzahl und damit die Verzögerung jeder Leitung gesteuert.

1.22.1 De-Skew im Kernel anpassen

Nur RK322Xh/RK3328 unterstützen die Änderung von De-Skew im Kernel. Dazu wird DTS angepasst.

Chiptypen: RK322xh, RK3328

Codeposition:

arch/arm64/boot/dts/rk322xh-dram-default-timing.dtsi

arch/arm64/boot/dts/rk322xh-dram-2layer-timing.dtsi

Falls eine neue Datei die genannte ersetzt, ändern Sie stattdessen diese neue Datei.

Vorgehen:

Wählen Sie anhand des Ergebnisses des bereitgestellten „deskew automatic scanning tool“ den Wert “mid” und tragen Sie ihn in die entsprechende DTS-Definition ein.

Zur Verwendung siehe “3228H deskew automatic scanning tool instruction.pdf”.

1.22.2 De-Skew im Loader anpassen

Nur RK3308 unterstützt die De-Skew-Anpassung im Loader.

Chiptyp: RK3308

Benötigte Dateien:

deskew automatic scanning tool, 3308_deskew.exe, RK3308_DDRXPXXXXXX_Template_VXX_de-skew.txt, rk3308_ddr_XXXMHz_uartX_mX_vX.XX.bin

Vorgehen:

Wählen Sie anhand des Ergebnisses des „deskew automatic scanning tool“ den Wert “mid” und tragen Sie ihn in die passende Definition in RK3308_DDRXPXXXXXX_Template_VXX_de-skew.txt ein. Übertragen Sie anschließend mit 3308_deskew.exe die De-Skew-Definitionen aus rk3308_ddrxpxxxxxx_template_vxx_de-skew.txt in rk3308_ddr_xxxmhz_uartx_mx_vx.xx.bin.

Zur Verwendung des Werkzeugs siehe “deskew automatic scanning tool instruction.pdf”.

1.23 DDR-Belastungstests unter U-Boot ausführen

Die verbreiteten DDR-Belastungstests stressapptest und memtester wurden auf U-Boot portiert.

Haupteinsatzfälle:

Wenn der Kernel nicht startet, kann ein DDR-Test unter U-Boot Speicherprobleme ausschließen.

Der Kernel bietet keine geeigneten Bedingungen für stressapptest oder memtester.

Beispielsweise können unvollständige Kernelmodule Instabilität verursachen und verhindern, dass die Tests lange genug laufen.

Größeren DDR-Bereich testen

Im Kernel ist nur der vom System nicht belegte Speicher testbar. U-Boot belegt wesentlich weniger Speicher und erlaubt daher größere Testbereiche.

Gezielte physische Adressen testen

1.23.1 stressapptest

Aktivieren Sie:

make ARCH=arm64 menuconfig ->Command line interface -> DDR Tool -> Enable DDR Tool

und zusätzlich:

make ARCH=arm64 menuconfig ->Command line interface -> DDR Tool -> Enable DDR Tool -> Enable stressapptest for ddr

Kompilieren Sie U-Boot und programmieren Sie uboot.img.

Starten Sie das Gerät neu und drücken Sie im seriellen PC-Terminal wiederholt CTRL+C, bis U-Boot in den Kommandozeilenmodus wechselt:

  pclk_top_root 100000 KHz
  aclk_low_top_root 396000 KHz
Net: No ethernet found.
Hit key to stop autoboot('CTRL+C'): 0
=> <INTERRUPT>
=> <INTERRUPT>

Geben Sie stressapptest -h ein und führen Sie den Test gemäß den Parameterhinweisen aus.

1.23.2 memtester

Aktivieren Sie:

make ARCH=arm64 menuconfig ->Command line interface -> DDR Tool -> Enable DDR Tool

und zusätzlich:

make ARCH=arm64 menuconfig ->Command line interface -> DDR Tool -> Enable DDR Tool -> Enable memtester for ddr

Kompilieren Sie U-Boot und programmieren Sie uboot.img.

Starten Sie das Gerät neu und drücken Sie im seriellen PC-Terminal wiederholt CTRL+C, bis U-Boot in den Kommandozeilenmodus wechselt:

  pclk_top_root 100000 KHz
  aclk_low_top_root 396000 KHz
Net: No ethernet found.
Hit key to stop autoboot('CTRL+C'): 0
=> <INTERRUPT>
=> <INTERRUPT>

Geben Sie memtester -h ein und führen Sie den Test gemäß den Parameterhinweisen aus.

1.24 ECC auf RK3568 aktivieren

ECC steht für Error Correcting Code. DDR-ECC prüft DDR-Daten auf Fehler und korrigiert sie.

RK3568 unterstützt Sideband-ECC: Neben dem DDR-Datenkanal wird ein zusätzlicher DDR-Baustein ausschließlich für ECC-Daten verwendet.

Es korrigiert Einbitfehler und erkennt Zweibitfehler, also SEC/DED-ECC (Single Error Correction/Double Error Detection).

1. ECC aktivieren: Sobald an DDR_ECC_DQ0-7 ein DDR-Baustein angeschlossen ist, wird ECC automatisch aktiviert.

2. Funktion von DDR_ECC_DQ0-7: Die Implementierung verwendet 32 Bit DQ-Daten plus 7 Bit ECC-Daten.

DDR_ECC_DQ0-7 speichert die aus DQ0–DQ31 berechneten ECC-Daten. Dafür muss dort ein zusätzlicher DDR-Baustein angeschlossen werden.

3. Anforderungen an den zusätzlichen Baustein: DRAM-Typ sowie Anzahl von Zeilen, Spalten und Bänken müssen mit den Bausteinen an DQ0–31 übereinstimmen.

4. Unterstützte DRAM-Typen: Alle DRAM-Typen unterstützen ECC.

1.25 DDR-ECC-Informationen im Kernel abrufen

DDR-ECC-Informationen werden über die EDAC-Architektur des Kernels bereitgestellt. Bei unterstützten Plattformen wie RK3568 muss die Hardware-ECC-Funktion aktiviert sein, siehe vorherigen Abschnitt. Aktivieren Sie anschließend das edac-Modul in DTSI. Fehlt dort ein edac-Knoten, unterstützt die Plattform diese Funktion nicht.

edac: edac {
    ...
    status = "okay";
};

RK EDAC wird an folgender Stelle im System registriert:

sys/devices/system/edac/mc/mc0
or
sys/bus/edac/devices/mc/mc0/

RK-EDAC-Namen abrufen:

# cat sys/devices/system/edac/mc/mc0/mc_name
rk_edac_ecc

Anzahl der seit diesem Start aufgelaufenen korrigierbaren Einbitfehler (ce) abrufen:

# cat sys/devices/system/edac/mc/mc0/ce_count
0

Anzahl der seit diesem Start aufgelaufenen unkorrigierbaren Mehrbitfehler (ue) abrufen:

# cat sys/devices/system/edac/mc/mc0/ue_count
0

Beim Neustart initialisiert der Kernel die EDAC-Module und Zähler erneut. Zuvor erfasste Fehlerzahlen werden gelöscht; die Zählung beginnt wieder bei null.

1.26 DDR-ECC-Fehler im Kernel injizieren

Zur ECC-Fehlerinjektion muss der “edac”-Knoten in der plattformspezifischen DTS-Datei aktiviert sein; außerdem muss die Hardware DDR-ECC unterstützen.

edac: edac {
        ...
        status = "okay";
    };

Nach dem Start wählen Sie den zu injizierenden Fehlertyp über folgenden Knoten:

echo ce > /sys/module/rockchip_edac/parameters/edac_poison_mode
echo ue > /sys/module/rockchip_edac/parameters/edac_poison_mode

edac_poison_mode unterstützt zwei Werte:

1. ce: Injiziert korrigierbare Einbitfehler.

2. ue: Injiziert unkorrigierbare Mehrbitfehler.

Lösen Sie die Fehler über folgenden Knoten aus. Die mit echo geschriebene Zahl bestimmt die Anzahl auszulösender DDR-ECC-Fehler.

echo 10 > /sys/module/rockchip_edac/parameters/rockchip_edac_trigger

Hinweise:

1. Bei folgender Fehlermeldung prüfen Sie, ob EDAC im Kernel aktiviert ist und die Hardware DDR-ECC unterstützt:

echo 1 > /sys/module/rockchip_edac/parameters/rockchip_edac_trigger
sh: echo: write error: Operation not permitted

2. Unkorrigierbare Mehrbitfehler ue führen standardmäßig zum Neustart. Bei korrigierbaren Einbitfehlern ce protokolliert der Kernel eine Warnung und erhöht den Zähler in /sys/devices/system/edac/mc/mc0/ce_count.

Zur ECC-Fehlerinjektion über HAL siehe den Abschnitt Rockchip_Developer_Guide_HAL_DDR_ECC.

1.27 DDR-Herstellerkennung auslesen

Nur LPDDR-Typen wie LPDDR2, LPDDR3, LPDDR4, LPDDR4X, LPDDR5 und LPDDR5X besitzen Herstellerkennungen. DDR-Typen wie DDR2, DDR3 und DDR4 besitzen keine.

1.27.1 Über den dmcdbg-Kernelknoten

Folgende Plattformen unterstützen das Auslesen der DDR-Herstellerkennung über proc/dmcdbg/dmcinfo:

RK3566

RK3568

RK3326

RK3326S

Aktivieren Sie zunächst dmcdbg in der jeweiligen Plattform-DTSI. Fehlt der Knoten, wird die Funktion nicht unterstützt. Für RK356X aktivieren Sie ihn beispielsweise in arch/arm64/boot/dts/rockchip/rk3568.dtsi:

dmcdbg: dmcdbg {
    compatible = "rockchip,rk3568-dmcdbg";
    status = "okay";
};

Kompilieren und aktualisieren Sie die Kernel-Firmware und starten Sie das Gerät. Mit cat proc/dmcdbg/dmcinfo lassen sich die Herstellerkennung und weitere DDR-Informationen auslesen.

console:/ # cat proc/dmcdbg/dmcinfo
DramType: LPDDR4
Dram ID: MR5=0x1,MR6=0x0,MR7=0x1 /* The MR5 is the manufacturer ID, and MR6 and MR7
are the version IDs reserved for the manufacturer definition */
DramCapacity:
CS Count: 1
Bus Width: 32 bit
Column: 10
Bank: 8
CS0_Row: 16
CS1_Row: 0
DieBusWidth: 16 bit
TotalSize: 2048 MB
devfreq/dmc: Enable
governor: dmc_ondemand
cur_freq: 780000000
NOTE:
more information about dmc can get from /sys/class/devfreq/dmc.

1.27.2 Über die Loader-Ausgabe

Die Loader-Ausgabe von RK3576/RK3588 enthält die Herstellerkennung.

DDR ... v1.14
LPDDR5, 2736MHz
channel[0] BW=16 Col=10 Bk=16 CS0 Row=15 CS1 Row=15 CS=2 Die BW=16 Size=2048MB
channel[1] BW=16 Col=10 Bk=16 CS0 Row=15 CS1 Row=15 CS=2 Die BW=16 Size=2048MB
channel[2] BW=16 Col=10 Bk=16 CS0 Row=15 CS1 Row=15 CS=2 Die BW=16 Size=2048MB
channel[3] BW=16 Col=10 Bk=16 CS0 Row=15 CS1 Row=15 CS=2 Die BW=16 Size=2048MB
Manufacturer ID:0xff /* This is the manufacturer ID */
...
change to F0: 2736MHz
out

Die Loader-Ausgabe von RK3399 enthält die Herstellerkennung.

DDR Version ...
In
channel 0
...
MR5=0xFF /* This is the manufacturer ID */
...
change freq to 416MHz 0,1
Channel 0: LPDDR4,416MHz
Bus Width=32 Col=10 Bank=8 Row=16 CS=1 Die Bus-Width=16 Size=2048MB
Channel 1: LPDDR4,416MHz
Bus Width=32 Col=10 Bank=8 Row=16 CS=1 Die Bus-Width=16 Size=2048MB
...
OUT

1.27.3 Wichtige Hinweise

Beachten Sie Folgendes:

1. Nur LPDDR-Typen wie LPDDR2, LPDDR3, LPDDR4, LPDDR4X, LPDDR5 und LPDDR5X besitzen Herstellerkennungen. DDR2, DDR3 und DDR4 besitzen keine.

2. Die Kennung bezeichnet den Waferhersteller, nicht die Marke des verpackten DDR-Bausteins. Viele DDR-Anbieter stellen selbst keine Wafer her.

3. Bei allen LPDDR-Typen lässt sich die auf dem Gehäuse aufgedruckte Modellnummer nicht auslesen. Dies unterscheidet sie von NAND-Flash und eMMC.

4. Die Zuordnung der Waferherstellerkennung folgt dem JEDEC-Standard JEP166.

1.27.4 Herstellerkennungstabellen

Die folgenden Tabellen entsprechen dem Stand bei Fertigstellung des Quelldokuments.

Künftige Aktualisierungen sind möglich. Suchen Sie auf https://www.jedec.org nach JEP166, um die aktuelle Tabelle zu finden.

Herstellerkennungen für LPDDR2 und LPDDR3:

Herstellerkennungen für LPDDR4:

Herstellerkennungen für LPDDR5:

1.28 Häufige Fragen zu Signalen

1.28.1 tINIT3 erfüllt die Protokollanforderung nicht

Ursache: Während der DDR-Initialisierung setzt die Rockchip-Plattform RESET mehrfach. Wird irrtümlich die erste steigende RESET-Flanke als Ausgangspunkt für tINIT3 verwendet, erscheint die gemessene Zeit protokollwidrig.

Korrekt ist die letzte steigende RESET-Flanke als Messpunkt für tINIT3, wie unten dargestellt.

Verwenden Sie nicht M2, sondern M3 als Messpunkt.

1.28.2 Hinweise zur Aktivierung von DDR-ODT

Nach den in der Quelle genannten JEDEC-Anforderungen darf ODT bei LPDDR4/LPDDR4X unterhalb von 800MHz nicht aktiviert werden.

Nach den in der Quelle genannten JEDEC-Anforderungen darf ODT bei DDR4 unterhalb von 625MHz nicht aktiviert werden.

1.29 Refresh-Rate bei hoher Temperatur

Oberhalb von 85°C benötigt DDR die doppelte Refresh-Rate.

Dies ist insbesondere bei Industrie- und Automotive-Produkten zu beachten.

Rockchip-Plattformen bieten folgende Verfahren zur Verdoppelung der Refresh-Rate:

LPDDR4, LPDDR4X, LPDDR5 und LPDDR5X besitzen eigene Temperatursensoren und melden die temperaturabhängig erforderliche Refresh-Rate über MR4. Einige Rockchip-Plattformen implementieren Automatic Temperature Derating, kurz derate. Damit wird die Refresh-Rate anhand der MR4-Angaben des DRAM-Bausteins automatisch an die Temperatur angepasst.

LPDDR3 unterstützt derate aus Hardwaregründen nicht; dort wird die doppelte Refresh-Rate erzwungen.

DDR3 und DDR4 besitzen weder Temperatursensoren noch die MR4-Meldung der erforderlichen Refresh-Rate. Daher kann derate nicht verwendet werden; die doppelte Refresh-Rate muss erzwungen werden.

Über ext_temp_ref in der DDR-Binärdatei lässt sich die Refresh-Rate verdoppeln.

Editierbare Screenshot-Abschrift mit Originalfeldern und -werten:

Zur Änderung siehe den Abschnitt zur Bearbeitung der DDR-Binärdatei.

Hinweis: Bei Rockchip-Industrie-, Automotive- und erweiterten Temperaturvarianten ist die Refresh-Rate bereits angepasst. Eine zusätzliche Verdoppelung mit diesem Werkzeug ist nicht erforderlich.

Im Werkzeug gelten für festes 2x/4x/1x-Refresh folgende Zuordnungen:

Normale Plattformen außerhalb der Industrie-, Automotive- und erweiterten Temperaturvarianten verwenden standardmäßig 1x-Refresh, außer bei DRAM mit aktiviertem derate.

Für die genannten Spezialvarianten gelten folgende Verfahren und DDR-Binärversionen:

Folgende Plattformen aktivieren derate standardmäßig in ihrer DDR-Binärdatei:

2. Kapitel 2: DDR-Fehlersuche

2.1 Feststellen, ob ein DDR-Problem vorliegt

1. UART-Protokoll prüfen

1. Meldet der DDR-Initialisierungsabschnitt des Loaders einen Fehler, liegt ein DDR-Problem vor.

2. Prüfen Sie im Loader-Protokoll DDR-Kapazität, Zeilen, Spalten, Bänke, DRAM-Typ und Busbreite. Falsche Angaben können DDR-Probleme verursachen.

3. Bei einem System-Panic wiederholen Sie den Versuch und vergleichen die Panic-Adressen. Sind sie gleich, ist DDR normalerweise nicht die Ursache. Unterschiedliche Adressen können auf DDR oder Versorgungsintegrität hinweisen.

2. Prüfen Sie die Bildausgabe. Bei fehlerhafter Darstellung ist ein DDR-Problem wahrscheinlich.

3. Eingrenzungstests durchführen:

1. Senken Sie ARM-/GPU-Frequenzen und erhöhen Sie bei fester Frequenz die Spannung angemessen. Hilft dies, liegt wahrscheinlich kein DDR-, sondern ein Versorgungsproblem vor.

2. Deaktivieren Sie die DDR-Frequenzskalierung. Hilft dies, ist sie wahrscheinlich die Ursache.

3. Senken Sie DDR auf eine sichere Frequenz, beispielsweise 324M. Hilft dies, liegt mit hoher Wahrscheinlichkeit ein Problem der DDR-Signalqualität vor.

2.2 Hauptursachen von DDR-Problemen

1. Stromversorgungsprobleme:

1. Zu wenige Kondensatoren im Layout, zu großer Abstand zum Chip oder ungeeignete Verteilung.

2. Die Versorgungsrückkopplung wird nicht wie gefordert vom Lastende zur PMU bzw. zum DC/DC-Wandler zurückgeführt.

3. Prüfen Sie die Kupferflächen auf Einhaltung der RK-Layoutregeln.

4. Die Massefläche direkt unter einem LQFP-Chip muss verlötet sein, um eine gute Masseverbindung sicherzustellen. Andernfalls leiden interne Versorgungsqualität und Wärmeabfuhr.

2. Signalintegritätsprobleme:

1. Unterschiedliche Leiterbahnlängen. Einige RK-Plattformen verfügen nicht über sämtliche Lese-/Schreibtrainings; Längenunterschiede verringern dort direkt die Setup-/Hold-Reserve.

2. Zu geringe Leiterbahnabstände verursachen starkes Übersprechen.

3. Ungleich lange Äste einer T-Topologie

verschlechtern die Signalflanken und können nichtmonotone Verläufe erzeugen.

4. Unterbrochene Rückstrompfade der Referenzlage. Zu große Freistellungen beim Kupferaufbau können durch Vias die Referenzlage unterbrechen und die Signalintegrität beeinträchtigen.

3. Fehlerhafte DRAM-Bausteine:

1. Manche nicht eindeutig spezifizierten Handelsbausteine wurden nicht geprüft oder stammen sogar aus Ausschuss; ihre Ausbeute ist nicht gewährleistet.

2. Bei solchen Bausteinen kann die Treiberimpedanz ungeeignet bzw. die Treiberstärke zu gering sein.

3. Hynix-4Gb-C-Die-DDR3, beispielsweise H5TQ4G63CFR, benötigt bei frühem Kernel-3.10-Code einen Patch.

2.3 Verfahren zur Behebung von DDR-Problemen

Suchen Sie zunächst nach Mustern: Tritt der Stillstand bei einer bestimmten Frequenz auf? Hängt ein Absturz nach dem Aufwachen von der Schlafdauer ab? Prüfen Sie systematisch feste und unterschiedliche Frequenzen, Spannungsänderungen sowie Treiberstärken, um die Ursache schrittweise einzugrenzen.

1. Fehlermeldungen während der DDR-Initialisierung

1. Meldungen wie “rd addr 0x… = 0x…”, “16bit error!!!” oder “unknow device” weisen meist auf Lötprobleme hin. Das Rockchip-DDR-Testwerkzeug kann diese gezielt prüfen.

2. Besondere Kapazitäten, die keine Zweierpotenz sind, etwa 768MB, 1.5GB oder 3GB, werden von manchen Codeversionen nicht unterstützt. Aktualisieren Sie den Loader. Bleiben Fehler bestehen, sollte die DDR-Entwicklung sie analysieren.

3. Die meisten DDR-Loaderfehler sind Lötprobleme. Verwenden Sie die Lötprüfoption des DDR-Testwerkzeugs und wählen Sie die zur Kapazität passenden Tests.

2. Prüfen Sie im Loader-Initialisierungsprotokoll Kapazität, Zeilen, Spalten, Bänke, Busbreite und DRAM-Typ.

Im folgenden Beispiel enthält die erste Zeile die DDR-Codeversion, die dritte die Frequenz und die vierte den Typ. Die fünfte nennt von links nach rechts DRAM-Busbreite, Spalten, Bänke, Zeilen, Chip-Select-Anzahl, Die-Busbreite und Gesamtkapazität. “OUT” in Zeile sieben zeigt den erfolgreichen Abschluss der Initialisierung; danach folgt die Ausgabe von usbplug oder miniloader. Eine erkannte Die-Busbreite oberhalb der tatsächlichen ist laut Quelle unproblematisch, eine kleinere führt zum Absturz.

Editierbare Screenshot-Abschrift mit Originalfeldern und -werten:

DDR Version V1.06 20171026
In
300MHz
DDR3
Bus Width=32 Col=10 Bank=8 Row=15 CS=2 Die Bus-Width=16 Size=2048MB
mach:14
OUT
Boot1 Release Time: 2017-06-12, version: 2.37

3. Prüfen Sie die Bildausgabe.

Bei einem Systemabsturz stoppt die CPU, während VOP weiterhin wiederholt Daten aus DDR liest

und anzeigt. Deshalb kann die Bildausgabe einen ersten Hinweis auf den DDR-Zustand liefern.

1. Normale Bildausgabe bedeutet, dass DDR weiterhin zugänglich ist. Sie schließt DDR als Ursache des Absturzes jedoch nicht aus.

2. Fehlerhafte Bildausgabe:

Das folgende Beispiel kann durch einen Absturz während des DDR-Frequenzwechsels entstehen, wodurch DDR unzugänglich wird. Versuchen Sie eine feste Frequenz. Auch Versorgungsprobleme können die DDR-Controllerlogik stören.

Im folgenden Beispiel führen PCB-Layoutfehler zu Problemen der Versorgungs- und Signalintegrität, wodurch die DDR3-DLL ihre Verriegelung verliert. Die Quelle nennt als Debugversuch eine Erhöhung von VCC_DDR auf 1.6V oder DLL-Bypass; dies ist keine allgemeine Spannungsempfehlung.

4. Stromversorgungsprobleme prüfen

1. Fixieren Sie CPU/GPU auf eine niedrigere Frequenz und erhöhen Sie arm/logic-Spannungen. Eine Verbesserung deutet auf ein Versorgungsproblem hin.

2. Prüfen Sie das Layout auf Versorgungsprobleme.

3. Messen Sie die Versorgungswelligkeit.

5. Signalintegrität prüfen

1. Senken Sie die DDR-Frequenz. Eine Verbesserung deutet auf ein Signalintegritätsproblem hin.

2. Prüfen Sie Layout und Gerberdateien auf sinnvolle Leiterbahnführung und durchgehende Referenzlagen.

3. Erhöhen oder verringern Sie Treiberstärke/ODT angemessen und prüfen Sie die Wirkung.

4. Ändern Sie den RZQ-Widerstand und prüfen Sie die Wirkung. Die Quelle beschreibt einzelne 220-Ball-LPDDR3-Bausteine, bei denen RZQ verkleinert oder entfernt werden musste, um die Treiberstärke zu erhöhen.

6. Nicht eindeutig spezifizierte Handelsbausteine

Sind Versorgungs- und Signalintegrität unauffällig, kommen DRAM-Speicherzellen als Ursache infrage. Folgende Versuche können helfen:

1. Deaktivieren Sie pd_idle und sr_idle und prüfen Sie die Wirkung.

2. Verwenden Sie bei DDR3 DRAM-DLL-Bypass.

3. Manche Speicherzellenfehler lassen sich mit DDR-Testwerkzeugen erkennen. Diese sind jedoch nur Hilfsmittel: Ein bestandener Test beweist weder Fehlerfreiheit des DRAM noch Boardstabilität.

3. Kapitel 3: DDR-Verifikationsablauf

HINWEISE

1. Für Android mit Linux 4.19, 5.10, 6.1 oder später siehe den Android-Verifikationsablauf. Für Systeme wie Buildroot, Yocto und Debian siehe den Linux-Verifikationsablauf.

2. Für Kernel Linux 3.10 siehe den entsprechenden Linux-3.10-Verifikationsablauf.

3. RV1108 und RK3308 verwenden abweichende Abläufe. Siehe die jeweiligen Abschnitte in diesem Dokument.

4. Die im Dokument beschriebenen Testdateien werden für die Verifikation benötigt und laut Quelle zusammen mit dem Originaldokument bereitgestellt.

3.1 DDR-Verifikation unter Android

3.1.1 Android-Testfirmware kompilieren

Aktivieren Sie zunächst die DDR-Frequenzskalierung. Setzen Sie in der boardspezifischen DTS-Datei die Knoten dfi und dmc auf status = “okay”.

&dfi {
    status = "okay";
};
&dmc {
    status = "okay";
    ...
};

Dies ist nur eine kurze Einführung zur Testfirmware. Einzelheiten siehe den Abschnitt zum Aktivieren/Deaktivieren der DDR-Frequenzskalierung in Rockchip_Developer_Guide_DDR_EN.

3.1.2 Android-Testumgebung einrichten

3.1.2.1 Firmware programmieren

Ermitteln Sie vor dem Test:

1. 32-Bit- oder 64-Bit-Betriebssystem

2. Gesamte DDR-Kapazität des Testgeräts, beispielsweise 512MB, 1GB oder 2GB

3. Maximale DDR-Frequenz für den Festfrequenztest, beispielsweise 533MHz, 1560MHz oder 2112MHz

3.1.2.2 Umgebung automatisch einrichten

1. Öffnen Sie das Verzeichnis “android_ddr_test_files” der Testdateien und starten Sie push_files.bat per Doppelklick. Wählen Sie gemäß Skripthinweis und Firmwaretyp 1 oder 2 und warten Sie auf den automatischen Abschluss.

Hinweis: Prüfen Sie danach anhand der Protokollausgabe, ob alle Schritte normal ausgeführt wurden und keine Fehlermeldungen vorliegen.

2. Bei fehlerfreier automatischer Einrichtung können Sie den Abschnitt zur manuellen Einrichtung überspringen.

3.1.2.3 Umgebung manuell einrichten

Wenn die automatische Einrichtung scheitert, richten Sie die Umgebung manuell ein. Wählen und installieren Sie die folgenden Dateien aus “android_ddr_test_files”.

1. Installieren Sie fishingjoy.

Hinweis: fishingjoy ist eine Drittanbieter-APK und muss separat beschafft werden. Alternativ können Sie eine andere während des Tests automatisch laufende APK oder eine Videoschleife verwenden.

<adb_tool> adb.exe install fishingjoy1.apk

2. Übertragen Sie stressapptest.

Wählen Sie aus “static_stressapptest” die zur 32- oder 64-Bit-Linux-Firmware des Testgeräts passende Version.

Beispiel:

Für Linux 32 Bit übertragen Sie stressapptest_32bit.

<adb_tool> adb.exe push stressapptest_32bit /data/stressapptest
<adb_tool> adb.exe shell chmod 0777 /data/stressapptest

Für Linux 64 Bit übertragen Sie stressapptest_64bit.

<adb_tool> adb.exe push stressapptest_64bit /data/stressapptest
<adb_tool> adb.exe shell chmod 0777 /data/stressapptest

3. Übertragen Sie memtester.

Wählen Sie aus “static_memtester” die zur 32- oder 64-Bit-Linux-Firmware des Testgeräts passende Version.

Beispiel:

Für Linux 32 Bit übertragen Sie memtester_32bit.

<adb_tool> adb.exe push memtester_32bit /data/memtester
<adb_tool> adb.exe shell chmod 0777 /data/memtester

Für Linux 64 Bit übertragen Sie memtester_64bit.

<adb_tool> adb.exe push memtester_64bit /data/memtester
<adb_tool> adb.exe shell chmod 0777 /data/memtester

4. Übertragen Sie ddr_freq_scan.sh.

<adb_tool> adb.exe push ddr_freq_scan.sh /data/ddr_freq_scan.sh
<adb_tool> adb.exe shell chmod 0777 /data/ddr_freq_scan.sh

5. Schreiben Sie gepufferte Dateisystemdaten aus dem Arbeitsspeicher auf den Datenträger.

<adb_tool> adb.exe shell sync

3.1.2.4 Testumgebung über USB-Stick und serielle Schnittstelle einrichten

Wenn ADB nicht verbunden werden kann, kopieren Sie die Testdateien über einen USB-Stick auf das Board und richten die Umgebung über die serielle Schnittstelle ein.

1. Vorbereitung

Verhindern Sie nach dem Einschalten den Suspend durch echo 1 > /sys/power/wake_lock. Alternativ wählen Sie Setting → Display → Sleep → Never sleep.

Verbinden Sie den USB-Stick mit dem Computer und kopieren Sie “android_ddr_test_files” darauf.

Wechseln Sie zum Benutzer root, um die erforderlichen Rechte zu erhalten.

<rk3399:/ $> su

Verbinden Sie den USB-Stick mit dem Testboard und kopieren Sie die Dateien aus “android_ddr_test_files”, “static_memtester” und “static_stressapptest” nach /data. Der Stick wird üblicherweise unter /mnt/media_rw/*** eingehängt. Der konkrete Knotenname variiert; verwenden Sie TAB zur Vervollständigung.

Beispiel:

Bei Einhängepunkt /mnt/media_rw/B4FE-5315 führen Sie folgenden Befehl aus:

<rk3399:/ #> cp -rf /mnt/media_rw/B4FE-5315/android_ddr_test_files /data/
<rk3399:/ #> cp -rf /mnt/media_rw/B4FE-5315/static_memtester /data/
<rk3399:/ #> cp -rf /mnt/media_rw/B4FE-5315/static_stressapptest /data/

2. Testumgebung automatisch einrichten

Für Linux 32 Bit wählen Sie test_files_install_32bit.sh.

<rk3399:/ #> chmod 0777 /data/android_ddr_test_files/test_files_install_32bit.sh
<rk3399:/ #> /data/android_ddr_test_files/test_files_install_32bit.sh

Für Linux 64 Bit wählen Sie test_files_install_64bit.sh.

<rk3399:/ #> chmod 0777 /data/android_ddr_test_files/test_files_install_64bit.sh
<rk3399:/ #> /data/android_ddr_test_files/test_files_install_64bit.sh

Prüfen Sie anhand der Protokolle jeden Schritt auf erfolgreiche Ausführung. Bei fehlerfreier automatischer Einrichtung können Sie den Abschnitt zur manuellen Einrichtung überspringen.

3. Testumgebung manuell einrichten

Wenn die automatische Einrichtung scheitert, führen Sie sie manuell aus.

Kopieren Sie für Linux 32 Bit die entsprechenden Testdateien.

<rk3399:/ #> cp /data/static_stressapptest/stressapptest_32bit /data/stressapptest
<rk3399:/ #> cp /data/static_memtester/memtester_32bit /data/memtester
<rk3399:/ #> cp /data/android_ddr_test_files/ddr_freq_scan.sh /data/ddr_freq_scan.sh

Kopieren Sie für Linux 64 Bit die entsprechenden Testdateien.

<rk3399:/ #> cp /data/static_stressapptest/stressapptest_64bit /data/stressapptest
<rk3399:/ #> cp /data/static_memtester/memtester_64bit /data/memtester
<rk3399:/ #> cp /data/android_ddr_test_files/ddr_freq_scan.sh /data/ddr_freq_scan.sh

Ändern Sie die Dateiberechtigungen.

<rk3399:/ #> chmod 777 /data/memtester /data/stressapptest /data/ddr_freq_scan.sh

Installieren Sie fishingjoy.

Hinweis: fishingjoy ist eine Drittanbieter-APK und muss separat beschafft werden. Alternativ können Sie eine andere während des Tests automatisch laufende APK oder eine Videoschleife verwenden.

<rk3399:/ #> pm install /data/fishingjoy1.apk

Schreiben Sie gepufferte Dateisystemdaten aus dem Arbeitsspeicher auf den Datenträger.

<rk3399:/ #> sync

3.1.3 DDR-Kapazität unter Android überprüfen

Prüfen Sie mit <rkxxxx:/ #> cat /proc/meminfo, ob MemTotal zur tatsächlichen Kapazität des Testgeräts passt.

Protokollbeispiel:

rkxxxx:/ # cat /proc/meminfo
MemTotal: 2038904 kB

512MB entsprechen näherungsweise 533504kB.

1GB entspricht näherungsweise 1048576kB.

1.5GB entsprechen näherungsweise 1582080kB.

2GB entsprechen näherungsweise 2097152kB.

3GB entsprechen näherungsweise 3145728kB.

4GB entsprechen näherungsweise 4194304kB.

Kleine Abweichungen sind aufgrund unterschiedlicher Speicherverwaltung normal.

3.1.4 Android-Test bei fester DDR-Frequenz

1. Starten Sie fishingjoy.

2. Wechseln Sie zu root.

<rkxxxx:/ $> su

3. Fixieren Sie die DDR-Frequenz.

Verwenden Sie die höchste vom Testgerät unterstützte DDR-Frequenz.

Beispiel:

Für 2112MHz:

<rkxxxx:/ #> /data/ddr_freq_scan.sh 2112000000

Für 1056MHz:

<rkxxxx:/ #> /data/ddr_freq_scan.sh 1056000000

Für 600MHz:

<rkxxxx:/ #> /data/ddr_freq_scan.sh 600000000

4. Prüfen Sie anhand des Protokolls die korrekte Frequenz.

Protokollbeispiel:

<rkxxxx:/ #> /data/ddr_freq_scan.sh 1560000000
already change to 1560000000 done.
change frequency to available max frequency done.

5. Ermitteln Sie den für den DDR-Test verfügbaren freien Speicher.

Prüfen Sie die Speichernutzung mit free -m. Üblicherweise werden 90% des für neue Anwendungen verfügbaren Speichers, also des Werts “available”, getestet.

Protokollbeispiel:

<rkxxxx:/ #> free -m
               total used free shared buff/cache available
Mem: 3909 433 3294 9 181 3427
Swap: 0 0 0

Beträgt “available” 3427MB, werden 3427MB * 0.9 = 3084MB für den DDR-Test gewählt.

Quellenvergleich: Der chinesische Absatz nennt 3427MB verfügbar, rechnet jedoch mit 3294MB0.9=3084MB. Die englische Quelle verwendet 3427MB0.9. Die Abweichung wird dokumentiert, nicht stillschweigend vereinheitlicht.

6. Führen Sie stressapptest länger als 12 Stunden aus.

stressapptest ausführen:

Wichtige stressapptest-Parameter:

-M mbytes: Größe des für den Test zuzuweisenden Speichers in MB.

-s seconds: Testdauer in Sekunden. Für 12 Stunden verwenden Sie 43200 Sekunden.

Beispiel:

Bei 3084MB verfügbarem Testspeicher und einer Dauer von 12 Stunden (43200 Sekunden) führen Sie folgenden Befehl aus:

<rkxxxx:/ #> /data/stressapptest -s 43200 -i 4 -C 4 -W --stop_on_errors -M 3084

Testergebnis prüfen

Prüfen Sie nach dem Test den normalen Gerätebetrieb, fishingjoy und das PASS-/FAIL-Ergebnis von stressapptest. Das Programm gibt alle 10 Sekunden die verbleibende Testzeit aus. Abschließend lautet die Erfolgsmeldung “Status: PASS - please verify no corrected errors”, die Fehlermeldung “Status: FAIL - test discovered HW problems”.

7. Führen Sie memtester länger als 12 Stunden aus.

memtester ausführen:

Wichtiger memtester-Parameter:

<mem>m: Größe des für den Test zuzuweisenden Speichers in MB.

Beispiel:

Bei 3084MB verfügbarem Testspeicher führen Sie folgenden Befehl aus:

<rkxxxx:/ #> /data/memtester 3084m

Testergebnis prüfen.

Prüfen Sie nach dem Test den normalen Gerätebetrieb, fishingjoy und mögliche memtester-Fehler. Die mit den Testdateien bereitgestellte Version wurde so geändert, dass sie bei einem Fehler automatisch stoppt. Läuft sie länger als 12 Stunden weiter, wurde während dieser Zeit kein Fehler erkannt.

Ohne Fehler gibt memtester fortlaufend folgende Meldungen aus:

Loop 10:
    Stuck Address : ok
    Random Value : ok
    Compare XOR : ok
    Compare SUB : ok
    Compare MUL : ok
    Compare DIV : ok
    Compare OR : ok
    Compare AND : ok
    Sequential Increment: ok
    Solid Bits : ok
    Block Sequential : ok
    Checkerboard : ok
    Bit Spread : ok
    Bit Flip : ok
    Walking Ones : ok
    Walking Zeroes : ok

Bei einem Fehler stoppt memtester automatisch und beendet den Test. Die Ausgabe lautet dann:

FAILURE: 0xffffffff != 0xffffbfff at offset 0x03b7d9e4.
EXIT_FAIL_OTHERTEST

3.1.5 DDR-Frequenzwechseltest unter Android

1. Starten Sie fishingjoy.

2. Wechseln Sie zu root.

<rkxxxx:/$> su

3. Starten Sie memtester im Hintergrund.

Wichtiger memtester-Parameter:

<mem>m: Größe des für den Test zuzuweisenden Speichers in MB.

Beispiel:

Zur Ermittlung des verfügbaren Testspeichers siehe den vorherigen Abschnitt zum Festfrequenztest.

Bei 3084MB verfügbarem Testspeicher führen Sie folgenden Befehl aus:

<rkxxxx:/ #> /data/memtester 3084m

4. Führen Sie die Testskripte aus.

<rkxxxx9:/ #> /data/ddr_freq_scan.sh

Hinweis: Erzwungene Frequenzwechsel können beispielsweise wegen zeitweise unzureichender Bandbreite Bildschirmflackern verursachen. Dies ist während dieses Tests normal.

5. Prüfen Sie das Ergebnis nach mehr als 12 Stunden Testdauer.

Prüfen Sie den normalen Betrieb von fishingjoy und des Geräts.

Prüfen Sie, ob das Frequenzwechselprogramm läuft und seine Protokolle normal ausgibt.

Protokollbeispiel:

DDR freq will change to 600000000 8786
already change to 600000000 done
DDR freq will change to 800000000 8787
already change to 800000000 done
DDR freq will change to 200000000 8788
already change to 200000000 done

Prüfen Sie, ob memtester weiterhin normal läuft.

Mit <rkxxxx:/ #> ps | grep memtester prüfen Sie, ob der Prozess noch aktiv ist.

Beispiel:

<rkxxxx:/ #> ps | grep memtester
root 14309 1730 74332 68156 0 5e980bf564 R /data/memtester

3.1.6 Android-Neustarttest

Neustarttest über Calculator

==Verhindern Sie den Schlafmodus: Wählen Sie Settings → Security → Set screen lock → None, damit das Gerät direkt zur Hauptansicht wechselt. Wählen Sie außerdem Settings → Display → Sleep → Never sleep.==

Öffnen Sie Calculator, geben Sie “83991906=” ein und wählen Sie “RebootTest”. Testen Sie länger als 12 Stunden.

3.1.7 Android-Suspend-Test

Für RK3399 mit LPDDR4 ist dieser Test erforderlich; für andere DDR-Typen und Plattformen ist er optional.

Suspend-Test über Calculator

Trennen Sie das für ADB angeschlossene USB-Kabel. Öffnen Sie Calculator, geben Sie “83991906=” ein und wählen Sie “SleepTest”. Testen Sie länger als 12 Stunden.

3.2 DDR-Verifikation unter Linux

3.2.1 Linux-Testfirmware kompilieren

Aktivieren Sie zunächst die DDR-Frequenzskalierung. Setzen Sie in der boardspezifischen DTS-Datei die Knoten dfi und dmc auf status = “okay”.

&dfi {
    status = "okay";
};
&dmc {
    status = "okay";
    ...
};

Dies ist nur eine kurze Einführung zur Testfirmware. Einzelheiten siehe den Abschnitt zum Aktivieren/Deaktivieren der DDR-Frequenzskalierung in Rockchip_Developer_Guide_DDR_EN.

3.2.2 Linux-Testumgebung einrichten

3.2.2.1 Firmware programmieren

Ermitteln Sie vor dem Test:

1. 32-Bit- oder 64-Bit-Betriebssystem

2. Gesamte DDR-Kapazität des Testgeräts, beispielsweise 512MB, 1GB oder 2GB

3. Maximale DDR-Frequenz für den Festfrequenztest, beispielsweise 533MHz, 1560MHz oder 2112MHz

3.2.2.2 Umgebung einrichten

Die SDK-Firmware enthält “ROCKCHIPS TEST TOOLS” im Verzeichnis /rockchip-test.

Fehlen diese Werkzeuge bei einem portierten Drittanbieterbetriebssystem, also insbesondere /rockchip-test, kopieren Sie die folgenden Dateien aus den DDR-Testressourcen manuell auf das Gerät. Einige Skripte müssen gegebenenfalls portiert und angepasst werden.

1. linux_ddr_test_files/ddr_freq_scaling.sh

2. linux_ddr_test_files/test_stress_glmark2.sh

3. linux_ddr_test_files/auto_reboot.sh

4. linux_ddr_test_files/suspend_resume.sh

5. Für Linux 64 Bit wählen Sie static_stressapptest/stressapptest_64bit und static_stressapptest/memtester_64bit. Für Linux 32 Bit wählen Sie static_stressapptest/stressapptest_32bit und static_stressapptest/memtester_32bit.

3.2.3 DDR-Kapazität unter Linux überprüfen

Prüfen Sie mit root@rkxxxx:/# cat /proc/meminfo, ob MemTotal zur tatsächlichen Kapazität passt.

Protokollbeispiel:

root@rkxxxx:/# cat /proc/meminfo
MemTotal: 2038904 kB

512MB entsprechen näherungsweise 533504kB.

1GB entspricht näherungsweise 1048576kB.

1.5GB entsprechen näherungsweise 1582080kB.

2GB entsprechen näherungsweise 2097152kB.

3GB entsprechen näherungsweise 3145728kB.

4GB entsprechen näherungsweise 4194304kB.

Kleine Abweichungen sind aufgrund unterschiedlicher Speicherverwaltung normal.

3.2.4 Linux-Test bei fester DDR-Frequenz

1. Starten Sie glmark2 oder eine andere dauerhaft laufende Anwendung, die GPU oder NPU belastet.

root@rkxxxx:/# /rockchip-test/gpu/test_stress_glmark2.sh > /dev/null &

2. Fixieren Sie die DDR-Frequenz.

Verwenden Sie die höchste vom Testgerät unterstützte DDR-Frequenz.

Beispiel:

Für 1332MHz:

root@rkxxxx:/# /rockchip-test/ddr/ddr_freq_scaling.sh 1332000000

Für 1056MHz:

root@rkxxxx:/# /rockchip-test/ddr/ddr_freq_scaling.sh 1056000000

3. Prüfen Sie die korrekte Frequenz.

Protokollbeispiel:

root@rkxxxx:/# cat /sys/class/devfreq/dmc/cur_freq
1332000000

4. Ermitteln Sie den für den DDR-Test verfügbaren freien Speicher.

Prüfen Sie die Speichernutzung mit free -m. Üblicherweise werden 90% des für neue Anwendungen verfügbaren Speichers, also des Werts “available”, getestet.

Protokollbeispiel:

root@rkxxxx:/# free -m
               total used free shared buff/cache available
Mem: 3909 433 3294 9 181 3427
Swap: 0 0 0

Beträgt “available” 3427MB, werden 3427MB * 0.9 = 3084MB für den DDR-Test gewählt.

Quellenvergleich: Der chinesische Absatz nennt 3427MB verfügbar, rechnet jedoch mit 3294MB0.9=3084MB. Die englische Quelle verwendet 3427MB0.9. Die Abweichung wird dokumentiert, nicht stillschweigend vereinheitlicht.

5. Führen Sie stressapptest länger als 12 Stunden aus.

stressapptest ausführen:

Wichtige stressapptest-Parameter:

-M mbytes: Größe des für den Test zuzuweisenden Speichers in MB.

-s seconds: Testdauer in Sekunden. Für 12 Stunden verwenden Sie 43200 Sekunden.

Beispiel:

Bei 3084MB verfügbarem Testspeicher und einer Dauer von 12 Stunden (43200 Sekunden) führen Sie folgenden Befehl aus:

root@rkxxxx:/# stressapptest -s 43200 -i 4 -C 4 -W --stop_on_errors -M 3084

Testergebnis prüfen

Prüfen Sie nach dem Test den normalen Gerätebetrieb, glmark2 und das PASS-/FAIL-Ergebnis von stressapptest. Das Programm gibt alle 10 Sekunden die verbleibende Testzeit aus. Abschließend lautet die Erfolgsmeldung “Status: PASS - please verify no corrected errors”, die Fehlermeldung “Status: FAIL - test discovered HW problems”.

6. Führen Sie memtester länger als 12 Stunden aus.

memtester ausführen:

Wichtiger memtester-Parameter:

<mem>m: Größe des für den Test zuzuweisenden Speichers in MB.

Beispiel:

Bei 3084MB verfügbarem Testspeicher führen Sie folgenden Befehl aus:

root@rkxxxx:/# memtester 3084m

Testergebnis prüfen.

Prüfen Sie nach dem Test den normalen Gerätebetrieb, glmark2 und mögliche memtester-Fehler. Die mit den Testdateien bereitgestellte Version wurde so geändert, dass sie bei einem Fehler automatisch stoppt. Läuft sie länger als 12 Stunden weiter, wurde während dieser Zeit kein Fehler erkannt.

Ohne Fehler gibt memtester fortlaufend folgende Meldungen aus:

Loop 10:
    Stuck Address : ok
    Random Value : ok
    Compare XOR : ok
    Compare SUB : ok
    Compare MUL : ok
    Compare DIV : ok
    Compare OR : ok
    Compare AND : ok
    Sequential Increment: ok
    Solid Bits : ok
    Block Sequential : ok
    Checkerboard : ok
    Bit Spread : ok
    Bit Flip : ok
    Walking Ones : ok
    Walking Zeroes : ok

Bei einem Fehler stoppt memtester automatisch und beendet den Test. Die Ausgabe lautet dann:

FAILURE: 0xffffffff != 0xffffbfff at offset 0x03b7d9e4.
EXIT_FAIL_OTHERTEST

3.2.5 DDR-Frequenzwechseltest unter Linux

1. Starten Sie glmark2 oder eine andere dauerhaft laufende Anwendung, die GPU oder NPU belastet.

root@rkxxxx:/# /rockchip-test/gpu/test_stress_glmark2.sh > /dev/null &

2. Starten Sie memtester im Hintergrund.

Wichtiger memtester-Parameter:

<mem>m: Größe des für den Test zuzuweisenden Speichers in MB.

Beispiel:

Zur Ermittlung des verfügbaren Testspeichers siehe den vorherigen Abschnitt zum Festfrequenztest.

Bei 3084MB verfügbarem Testspeicher führen Sie folgenden Befehl aus:

root@rkxxxx:/# memtester 3084m > /data/memtester_log.txt &

3. Führen Sie die Testskripte aus.

root@rkxxxx:/# /rockchip-test/ddr/ddr_freq_scaling.sh

Hinweis: Erzwungene Frequenzwechsel können beispielsweise wegen zeitweise unzureichender Bandbreite Bildschirmflackern verursachen. Dies ist während dieses Tests normal.

4. Prüfen Sie das Ergebnis nach mehr als 12 Stunden Testdauer.

Prüfen Sie den normalen Betrieb von glmark2 und des Geräts.

Prüfen Sie, ob das Frequenzwechselprogramm läuft und seine Protokolle normal ausgibt.

Protokollbeispiel:

cnt: 2315, ddr freq: success change to 528000000 Hz
cnt: 2316, ddr freq: success change to 528000000 Hz
cnt: 2317, ddr freq: success change to 1332000000 Hz

Prüfen Sie, ob memtester weiterhin normal läuft.

Mit root@rkxxxx:/# ps | grep memtester prüfen Sie, ob der Prozess noch aktiv ist.

Beispiel:

root@rkxxxx:/# ps | grep memtester
root 14309 1730 74332 68156 0 5e980bf564 R /data/memtester

3.2.6 Linux-Neustarttest

1. Führen Sie die Testskripte aus.

root@rkxxxx:/# /rockchip-test/auto_reboot/auto_reboot.sh

2. Testen Sie länger als 12 Stunden und prüfen Sie den normalen Gerätebetrieb. Mit folgendem Befehl lässt sich der Test beenden.

root@rkxxxx:/# echo off > /userdata/rockchip-test/reboot_cnt

3.2.7 Linux-Suspend-Test

1. Führen Sie die Testskripte aus.

root@rkxxxx:/# /rockchip-test/suspend_resume/suspend_resume.sh

2. Testen Sie länger als 12 Stunden und prüfen Sie den normalen Gerätebetrieb.

3.3 DDR-Verifikation mit Linux 3.10

3.3.1 Linux-3.10-Testfirmware kompilieren

Öffnen Sie menuconfig des Kernels, wechseln Sie zu System Type und aktivieren Sie DDR Test sowie pm_tests.

menuconfig
System Type --->
  [*] /sys/pm_tests/ support
  [*] DDR Test

Fehlt die Option [] /sys/pm_tests/ support in menuconfig, kompilieren Sie eine Firmware mit fester oder skalierter DDR-Frequenz gemäß den entsprechenden Abschnitten in Rockchip_Developer_Guide_DDR_EN.

3.3.2 Linux-3.10-Testumgebung einrichten

3.3.2.1 Firmware programmieren

Ermitteln Sie vor dem Test:

1. Android-Version der Testfirmware, beispielsweise android4.4, android5.0, android6.0 oder android7.1

2. 32-Bit- oder 64-Bit-Betriebssystem

3. Gesamte DDR-Kapazität, beispielsweise 512MB, 1GB oder 2GB

4. Maximale DDR-Frequenz für den Festfrequenztest, beispielsweise 456MHz oder 533MHz

5. Frequenzbereich für den Wechseltest, beispielsweise 200MHz–456MHz oder 200MHz–533MHz

3.3.2.2 Testumgebung automatisch einrichten

Öffnen Sie “linux3.10_ddr_test_files”, starten Sie push_files.bat per Doppelklick und wählen Sie gemäß Skripthinweis und Firmwaretyp 1 oder 2. Warten Sie auf die automatische Einrichtung. Ohne Fehlermeldung können Sie die manuelle Einrichtung überspringen.

3.3.2.3 Testumgebung manuell einrichten

Wenn die automatische Einrichtung scheitert, wählen und installieren Sie die folgenden Dateien aus “linux3.10_ddr_test_files” manuell.

1. Installieren Sie fishingjoy.

<adb_tool> adb.exe install fishingjoy1.apk

2. Übertragen Sie Google stressapptest.

Wählen Sie die zur Firmwareversion passende stressapptest-Variante.

<adb_tool> adb.exe root
<adb_tool> adb.exe remount
<adb_tool> adb.exe push libstlport.so /system/lib/libstlport.so
<adb_tool> adb.exe shell chmod 644 /system/lib/libstlport.so

Für android4.4 übertragen Sie stressapptest_android4.4.

<adb_tool> adb.exe push stressapptest_android4.4 /data/stressapptest
<adb_tool> adb.exe shell chmod 0777 /data/stressapptest

Für andere Android-Versionen übertragen Sie stressapptest.

<adb_tool> adb.exe push stressapptest /data/stressapptest
<adb_tool> adb.exe shell chmod 0777 /data/stressapptest

3. Übertragen Sie memtester.

Wählen Sie die zur Firmwareversion passende memtester-Variante.

Beispiel:

Für Linux 32 Bit übertragen Sie memtester_32bit.

<adb_tool> adb.exe push memtester_32bit /data/memtester
<adb_tool> adb.exe shell chmod 644 /data/memtester

Für Linux 64 Bit übertragen Sie memtester_64bit.

<adb_tool> adb.exe push memtester_64bit /data/memtester
<adb_tool> adb.exe shell chmod 644 /data/memtester

4. Synchronisieren Sie die Dateisystempuffer.

<adb_tool> adb.exe shell sync

3.3.3 DDR-Kapazität mit Linux 3.10 überprüfen

Prüfen Sie mit <rkxxxx:/ $> cat /proc/meminfo, ob MemTotal zur tatsächlichen Kapazität passt.

Protokollbeispiel:

<rkxxxx:/ $> cat /proc/meminfo
MemTotal: 2038904 kB

512MB entsprechen näherungsweise 533504kB.

1GB entspricht näherungsweise 1048576kB.

1.5GB entsprechen näherungsweise 1582080kB.

2GB entsprechen näherungsweise 2097152kB.

3GB entsprechen näherungsweise 3145728kB.

4GB entsprechen näherungsweise 4194304kB.

Kleine Abweichungen sind aufgrund unterschiedlicher Speicherverwaltung normal.

3.3.4 Festfrequenztest mit Linux 3.10

1. Starten Sie fishingjoy.

2. Geben Sie su in der seriellen Konsole ein.

<rkxxxx:/ $> su

3. Fixieren Sie die DDR-Frequenz.

Verwenden Sie die höchste vom Testgerät unterstützte DDR-Frequenz.

Beispiel:

Bei maximaler DDR-Frequenz von 533MHz:

<rkxxxx:/ #> echo set clk_ddr 533000000 > /sys/pm_tests/clk_rate

4. Führen Sie Google stressapptest länger als 12 Stunden aus.

Bei 512MB Gesamtkapazität weisen Sie stressapptest 64MB zu.

<rkxxxx:/ #> /data/stressapptest -s 43200 -i 4 -C 4 -W --stop_on_errors -M 64

Bei 1GB Gesamtkapazität weisen Sie stressapptest 128MB zu.

<rkxxxx:/ #> /data/stressapptest -s 43200 -i 4 -C 4 -W --stop_on_errors -M 128

Bei 2GB Gesamtkapazität weisen Sie stressapptest 256MB zu.

<rkxxxx:/ #> /data/stressapptest -s 43200 -i 4 -C 4 -W --stop_on_errors -M 256

Bei laut Quelle 4MB Gesamtkapazität weisen Sie stressapptest 512MB zu.

<rkxxxx:/ #> /data/stressapptest -s 43200 -i 4 -C 4 -W --stop_on_errors -M 512

5. Prüfen Sie das Testergebnis.

Prüfen Sie nach dem Test Gerätebetrieb, fishingjoy und das PASS-/FAIL-Ergebnis von stressapptest. Alle 10 Sekunden wird die verbleibende Testzeit ausgegeben. Abschließend erscheint Status: PASS bei Erfolg oder Status: FAIL bei Fehlern.

6. Führen Sie memtester länger als 12 Stunden aus.

Bei 512MB Gesamtkapazität weisen Sie memtester 64MB zu.

<rkxxxx:/ #> /data/memtester 64m

Bei 1GB Gesamtkapazität weisen Sie memtester 128MB zu.

<rkxxxx:/ #> /data/memtester 128m

Bei 2GB Gesamtkapazität weisen Sie memtester 256MB zu.

<rkxxxx:/ #> /data/memtester 256m

Bei 4GB Gesamtkapazität weisen Sie memtester 512MB zu.

<rkxxxx:/ #> /data/memtester 512m

7. Prüfen Sie das Testergebnis.

Prüfen Sie nach dem Test Gerätebetrieb, fishingjoy und mögliche memtester-Fehler. Die bereitgestellte Version stoppt automatisch beim ersten erkannten Fehler. Läuft sie länger als 12 Stunden weiter, wurde während dieser Zeit kein Fehler erkannt.

Ohne Fehler gibt memtester fortlaufend folgende Meldungen aus:

Loop 10:
    Stuck Address : ok
    Random Value : ok
    Compare XOR : ok
    Compare SUB : ok
    Compare MUL : ok
    Compare DIV : ok
    Compare OR : ok
    Compare AND : ok
    Sequential Increment: ok
    Solid Bits : ok
    Block Sequential : ok
    Checkerboard : ok
    Bit Spread : ok
    Bit Flip : ok
    Walking Ones : ok
    Walking Zeroes : ok

Bei einem Fehler stoppt memtester automatisch und beendet den Test. Die Ausgabe lautet dann:

FAILURE: 0xffffffff != 0xffffbfff at offset 0x03b7d9e4.
EXIT_FAIL_OTHERTEST

3.3.5 Frequenzwechseltest mit Linux 3.10

Starten Sie das Gerät nach einem zuvor ausgeführten Festfrequenztest neu. Andernfalls kann der folgende Frequenzwechselbefehl nicht ausgeführt werden.

1. Starten Sie fishingjoy.

2. Geben Sie su in der seriellen Konsole ein.

<rkxxxx:/ $> su

3. Starten Sie memtester im Hintergrund.

Bei 512MB Gesamtkapazität weisen Sie memtester 64MB zu.

<rkxxxx:/ #> /data/memtester 64m > /data/_log.txt &

Bei 1GB Gesamtkapazität weisen Sie memtester 128MB zu.

<rkxxxx:/ #> /data/memtester 128m > /data/memtester_log.txt &

Bei 2GB Gesamtkapazität weisen Sie memtester 256MB zu.

<rkxxxx:/ #> /data/memtester 256m > /data/memtester_log.txt &

Bei 4GB Gesamtkapazität weisen Sie memtester 512MB zu.

<rkxxxx:/ #> /data/memtester 512m > /data/memtester_log.txt &

4. Führen Sie den Frequenzwechselbefehl aus.

Wählen Sie den vom Testgerät unterstützten DDR-Frequenzbereich.

Beispiel:

Beispiel für 200MHz bis 533MHz:

<rkxxxx:/ #> echo 'a:200M-533M-1000000T' > proc/driver/ddr_ts

5. Prüfen Sie das Ergebnis nach mehr als 12 Stunden Testdauer.

Prüfen Sie den normalen Betrieb von fishingjoy und des Geräts.

Prüfen Sie, ob das Frequenzwechselprogramm läuft und seine Protokolle normal ausgibt.

Prüfen Sie den normalen memtester-Betrieb. Mit <rkxxxx:/ #> ps | grep memtester stellen Sie fest, ob der Prozess noch aktiv ist.

Beispiel:

<rkxxxx:/ #> ps | grep memtester
root 14309 1730 74332 68156 0 5e980bf564 R /data/memtester

3.3.6 Neustarttest mit Linux 3.10

Öffnen Sie Calculator, geben Sie “83991906=” ein und wählen Sie “RebootTest”. Testen Sie länger als 12 Stunden.

3.4 DDR-Verifikation auf RV1108

3.4.1 RV1108-Testfirmware kompilieren

Öffnen Sie menuconfig des Kernels, wechseln Sie zu System Type und aktivieren Sie DDR Test sowie pm_tests.

menuconfig
System Type --->
  [*] /sys/pm_tests/ support
  [*] DDR Test

Fehlt die Option [] /sys/pm_tests/ support in menuconfig, kompilieren Sie eine Firmware mit fester oder skalierter DDR-Frequenz gemäß den entsprechenden Abschnitten in Rockchip_Developer_Guide_DDR.

3.4.2 RV1108-Testumgebung einrichten

Kopieren Sie stressapptest und memtester_32bit aus “rv1108_ddr_test_files” in das Stammverzeichnis der SD-Karte und stecken Sie diese in das Testboard.

3.4.3 DDR-Kapazität auf RV1108 überprüfen

Prüfen Sie mit <rv1108:/ #> cat /proc/meminfo, ob MemTotal zur tatsächlichen Kapazität passt.

Protokollbeispiel:

<rv1108:/ #> cat /proc/meminfo
MemTotal: 133376 kB

64MB entsprechen näherungsweise 66688kB.

128MB entsprechen näherungsweise 133376kB.

256MB entsprechen näherungsweise 266752kB.

512MB entsprechen näherungsweise 533504kB.

Kleine Abweichungen sind aufgrund unterschiedlicher Speicherverwaltung normal.

3.4.4 Festfrequenztest auf RV1108

1. Fixieren Sie die DDR-Frequenz.

Verwenden Sie die höchste vom Testgerät unterstützte DDR-Frequenz.

Beispiel:

Bei maximal unterstützter DDR-Frequenz von 800MHz:

<rv1108:/ #> echo set clk_ddr 800000000 > /sys/pm_tests/clk_rate

2. Führen Sie Google stressapptest länger als 12 Stunden aus.

Bei 128MB Gesamtkapazität weisen Sie stressapptest 16MB zu, üblicherweise ein Achtel der Gesamtkapazität.

<rv1108:/ #> /mnt/sdcard/stressapptest -s 500 -i 1 -C 1 -W --stop_on_errors -M 16

3. Prüfen Sie das Testergebnis.

Prüfen Sie nach dem Test den Gerätebetrieb und das PASS-/FAIL-Ergebnis von stressapptest. Alle 10 Sekunden wird die verbleibende Testzeit ausgegeben. Abschließend erscheint Status: PASS bei Erfolg oder Status: FAIL bei Fehlern.

4. Führen Sie memtester länger als 12 Stunden aus.

Bei 128MB Gesamtkapazität weisen Sie stressapptest 16MB zu, üblicherweise ein Achtel der Gesamtkapazität.

<rv1108:/ #> /mnt/sdcard/memtester_32bit 16m

5. Prüfen Sie das Testergebnis.

Prüfen Sie nach dem Test Gerätebetrieb und memtester-Fehler. Die bereitgestellte Version stoppt automatisch beim ersten erkannten Fehler. Läuft sie länger als 12 Stunden weiter, wurde während dieser Zeit kein Fehler erkannt.

Ohne Fehler gibt memtester fortlaufend folgende Meldungen aus:

Loop 10:
     Stuck Address : ok
     Random Value : ok
     Compare XOR : ok
     Compare SUB : ok
     Compare MUL : ok
     Compare DIV : ok
     Compare OR : ok
     Compare AND : ok
     Sequential Increment: ok
     Solid Bits : ok
     Block Sequential : ok
     Checkerboard : ok
     Bit Spread : ok
     Bit Flip : ok
     Walking Ones : ok
     Walking Zeroes : ok

Bei einem Fehler stoppt memtester automatisch und beendet den Test. Die Ausgabe lautet dann:

FAILURE: 0xffffffff != 0xffffbfff at offset 0x03b7d9e4.
EXIT_FAIL_OTHERTEST

3.4.5 Frequenzwechseltest auf RV1108

Starten Sie das Gerät nach einem zuvor ausgeführten Festfrequenztest neu. Andernfalls kann der folgende Frequenzwechselbefehl nicht ausgeführt werden.

1. Starten Sie memtester im Hintergrund.

Bei 128MB Gesamtkapazität weisen Sie memtester 16MB zu, üblicherweise ein Achtel der Gesamtkapazität.

<rv1108:/ #> /mnt/sdcard/memtester_32bit 16m > /data/memtester_log.txt &

2. Führen Sie den Frequenzwechselbefehl aus.

Der Testbereich reicht von 400MHz bis zur maximalen Gerätefrequenz.

Beispiel:

Bei maximaler DDR-Frequenz von 800MHz:

<rv1108:/ #> echo 'a:400M-800M-1000000T' > proc/driver/ddr_ts

3. Prüfen Sie das Ergebnis nach mehr als 12 Stunden Testdauer.

Prüfen Sie den normalen Gerätebetrieb.

Prüfen Sie, ob das DDR-Frequenzwechselprogramm läuft und seine Protokolle normal ausgibt.

Prüfen Sie den normalen memtester-Betrieb. Mit <rkxxxx:/ #> ps | grep memtester stellen Sie fest, ob der Prozess noch aktiv ist.

Beispiel:

<rkxxxx:/ #> ps | grep memtester
root 14309 1730 74332 68156 0 5e980bf564 R /data/memtester

3.4.6 Neustarttest auf RV1108

Verwenden Sie die integrierte Funktion: menu → debug → reboot test.

3.5 DDR-Verifikation auf RK3308

3.5.1 DDR-Kapazität auf RK3308 überprüfen

Prüfen Sie mit <rk3308:/ #> cat /proc/meminfo, ob MemTotal zur tatsächlichen Kapazität passt.

Protokollbeispiel:

<rk3308:/ #> cat /proc/meminfo
MemTotal: 246832 kB
MemFree: 201800 kB

64MB entsprechen näherungsweise 66688kB.

128MB entsprechen näherungsweise 133376kB.

256MB entsprechen näherungsweise 266752kB.

512MB entsprechen näherungsweise 533504kB.

Kleine Abweichungen sind aufgrund unterschiedlicher Speicherverwaltung normal.

3.5.2 Festfrequenztest auf RK3308

RK3308 unterstützt keine DDR-Frequenzskalierung. Die bei der Initialisierung vom Loader gesetzte Frequenz bleibt unverändert. Verwenden Sie den Loader mit maximaler Frequenz: 800MHz für DDR3, 533MHz für DDR2 und LPDDR2.

1. Führen Sie memtester länger als 12 Stunden aus.

Prüfen Sie zunächst, ob die Testdatei vorhanden ist:

<rk3308:/ #> ls usr/bin/memtester
usr/bin/memtester

Ist memtester vorhanden, verwenden Sie folgenden Befehl. Bei 128MB Gesamtkapazität werden 16MB getestet, üblicherweise ein Achtel.

<rk3308:/ #> memtester 16m > /data/memtester_log.txt &

Fehlt die Datei, übertragen Sie memtester_32bit.32bit bzw. memtester_64bit.64bit mit ADB nach /data/. Linux-32 verwendet die 32-Bit-, Linux-64 die 64-Bit-Datei.

Befehl für Linux-32:

adb push \*file path*\memtester_32bit.32bit data/memtester

Befehl für Linux-64:

adb push \*file path*\memtester_64bit.64bit data/memtester

Berechtigungen ändern:

<rk3308:/ #> chmod 777 /data/memtester

memtester-Befehl: Bei 128MB Gesamtkapazität werden 16MB getestet, üblicherweise ein Achtel.

<rk3308:/ #> /data/memtester 16m > /data/memtester_log.txt &

2. Prüfen Sie das Testergebnis.

Prüfen Sie nach dem Test den normalen Gerätebetrieb.

Prüfen Sie memtester auf Fehlermeldungen. Hinweis: Diese Variante stoppt bei Fehlern ==nicht automatisch==; kontrollieren Sie die gesamte Ausgabe.

Ohne Fehler gibt memtester fortlaufend folgende Meldungen aus:

Loop 1:
  Stuck Address : ok
  Random Value : ok
  Compare XOR : ok
  Compare SUB : ok
  Compare MUL : ok
  Compare DIV : ok
  Compare OR : ok
  Compare AND : ok
  Sequential Increment: ok
  Solid Bits : ok
  Block Sequential : ok
  Checkerboard : ok
  Bit Spread : ok
  Bit Flip : ok
  Walking Ones : ok
  Walking Zeroes : ok
  8-bit Writes : ok
  16-bit Writes : ok

Bei Fehlern stoppt memtester nicht automatisch. Die Ausgabe lautet:

Loop 92:
  Stuck Address : ok
  Random Value : FAILURE: 0x37fe0f4190f6b999 != 0x37fe0f4196f6b999 at offset
0x0027a958.
FAILURE: 0x2823d0d6f62a4b01 != 0x2823d0d6f02a4b01 at offset 0x0027a958.
  Compare XOR : FAILURE: 0x4c4f418e764340e8 != 0x4c4f418e704340e8 at offset
0x0027a958.
  Compare SUB : FAILURE: 0x2856fb8ee22bd230 != 0xfe5ee503ee2bd230 at offset
0x0027a958.
  Compare MUL : FAILURE: 0x00000000 != 0x00000001 at offset 0x0027a958.
  Compare DIV : FAILURE: 0xefb2eceaffbf9604 != 0xefb2eceaffbf9605 at offset
0x0027a958.
  Compare OR : FAILURE: 0xcbb2a0e8cfbb8200 != 0xcbb2a0e8cfbb8201 at offset
0x0027a958.
  Compare AND : Sequential Increment: ok
  Solid Bits : ok
  Block Sequential : ok
  Checkerboard : ok
  Bit Spread : ok
  Bit Flip : ok
Walking Ones : ok
Walking Zeroes : ok
8-bit Writes : ok
16-bit Writes : ok

3. Führen Sie Google stressapptest länger als 12 Stunden aus.

Prüfen Sie zunächst, ob die Testdatei vorhanden ist:

<rk3308:/ #> ls usr/bin/stressapptest
usr/bin/stressapptest

Ist stressapptest vorhanden, verwenden Sie folgenden Befehl. Bei 256MB Gesamtkapazität werden 32MB getestet, üblicherweise ein Achtel. Der Parameter nach -s bestimmt die Dauer in Sekunden; das folgende Beispiel läuft 24 Stunden.

<rk3308:/ #> stressapptest -s 86400 -i 4 -C 4 -W --stop_on_errors -M 32

Fehlt die Datei, übertragen Sie stressapptest_32bit bzw. stressapptest_64bit mit ADB nach /data/. Linux-32 verwendet die 32-Bit-, Linux-64 die 64-Bit-Datei.

Befehl für Linux-32:

adb push \*file path*\stressapptest_32bit data/stressapptest

Befehl für Linux-64:

adb push \*file path*\stressapptest_64bit data/stressapptest

Berechtigungen ändern:

<rk3308:/ #> chmod 777 /data/stressapptest

stressapptest-Befehl: Bei 256MB Gesamtkapazität werden 32MB getestet, üblicherweise ein Achtel. Das folgende Beispiel läuft 24 Stunden.

<rk3308:/ #> /data/stressapptest -s 86400 -i 4 -C 4 -W --stop_on_errors -M 32

4. Prüfen Sie das Testergebnis.

Prüfen Sie nach dem Test den normalen Gerätebetrieb.

Prüfen Sie das PASS-/FAIL-Ergebnis von stressapptest. Alle 10 Sekunden wird die verbleibende Testzeit ausgegeben. Abschließend erscheint Status: PASS bei Erfolg oder Status: FAIL bei Fehlern.

3.5.3 Suspend-Test auf RK3308

Aktivieren Sie für diesen Test die automatische Aufweckfunktion im Kernel. Öffnen Sie rk3308.dtsi, suchen Sie rockchip_suspend und verknüpfen Sie RKPM_TIMEOUT_WAKEUP_EN bitweise per ODER wie folgt:

rockchip_suspend: rockchip-suspend {
                ...
                rockchip,wakeup-config = <
                        (0
                        | RKPM_GPIO0_WAKEUP_EN
                        | RKPM_TIMEOUT_WAKEUP_EN
                        )
                >;
        };

Nach Kompilierung der Firmware wird die Verwendung des Testskripts empfohlen. Prüfen Sie zunächst dessen Vorhandensein:

<rk3308:/ #> ls rockchip_test/rockchip_test.sh
rockchip_test/rockchip_test.sh

Ist die Datei vorhanden, lautet der Testbefehl:

<rk3308:/ #> /rockchip_test/rockchip_test.sh
...
please input your test moudle: //the serial console first input 8<enter>, then 1<enter>
8
1

Andernfalls können Sie den Suspend-Test direkt über die serielle Konsole starten:

<rk3308:/ #> while true; do echo mem > /sys/power/state; sleep 5; done

Testen Sie länger als 12 Stunden und prüfen Sie anschließend den normalen Gerätebetrieb.

3.5.4 Neustarttest auf RK3308

Empfohlen wird das RK3308-Testskript. Prüfen Sie zunächst dessen Vorhandensein:

<rk3308:/ #> ls rockchip_test/rockchip_test.sh
rockchip_test/rockchip_test.sh

Ist die Datei vorhanden, lautet der Neustartbefehl:

<rk3308:/ #> /rockchip_test/rockchip_test.sh
...
please input your test moudle: //the serial console input 13<enter>
13

Andernfalls übertragen Sie auto_reboot_test.sh nach /data/:

adb push \*file path*\auto_reboot_test.sh data/.

Berechtigungen ändern:

<rk3308:/ #> chmod 777 /data/auto_reboot_test.sh

Neustartbefehl:

<rk3308:/ #> /data/auto_reboot_test.sh

Testen Sie länger als 12 Stunden und prüfen Sie anschließend den normalen Gerätebetrieb.

4. Kapitel 4: Rockchip-DDR-DQ-Augendiagrammwerkzeug

4.1 Zweidimensionale Augendiagramme scannen

4.1.1 Unterstützte Plattformen

RK3528, RK3562, RK3566, RK3568, RK3588，RK3576

4.1.2 Verwendung

Der Loader muss mit einer eye_scan-DDR-Binärdatei erzeugt werden. Diese enthält “eyescan” im Namen und liegt wie normale DDR-Dateien unter rkbin/bin/rkxx, beispielsweise rkbin/bin/rk35/rk3568_ddr_1560MHz_eyescan_v1.16.bin. Zur Loader-Erzeugung siehe den DDR-Entwicklerleitfaden.

Für andere Frequenzen ändern Sie die eye_scan-DDR-Datei mit rkbin/tools/ddrbin_tool und erzeugen anschließend den Loader. Einzelheiten enthält rkbin/tools/ddrbin_tool_user_guide.txt.

Wechseln Sie in Maskrom-Modus und laden Sie den Loader mit RKDevTool. Ergebnisse werden seriell ausgegeben. Nach dem 2D-Augenscan stoppt der Loader automatisch; das Werkzeug meldet deshalb einen Fehlschlag.

Im Loader-Modus kann der Loader erfolgreich programmiert werden. Danach scannt er bei jedem Start das 2D-Auge, gibt das Ergebnis seriell aus und stoppt. Ein normaler Systemstart ist dann nicht möglich. Zur Wiederherstellung wechseln Sie in Maskrom-Modus und programmieren einen normalen Loader.

4.1.2.1 Ergebnisauswertung

Am Anfang des 2D-Augenprotokolls wird die Verzögerung pro Schritt in fs (0.001ps) angegeben. “Unit: 1913 fs” in der ersten Zeile des folgenden Beispiels bedeutet 1.913 ps pro Schritt.

Die zweite Zeile ‘margin: rx:22-8,tx:26-32’ bedeutet, dass beim Lesen mindestens 22 Schritte Setup- und 8 Schritte Hold-Reserve, beim Schreiben mindestens 26 bzw. 32 Schritte erforderlich sind. Diese frequenzabhängigen Werte wurden von ps in die Schrittweite des Software-Augendiagramms umgerechnet. Im folgenden RX-DQ0-Diagramm markieren ‘|’ die Mindestanforderungen von 22 Setup- und 8 Hold-Schritten. ‘[33 ~ -1 ~-35]’ rechts bedeutet bei diesem Vref 33 Setup- und 35 Hold-Schritte. Gegenüber der Mindestanforderung bleiben somit zusätzlich 33-22=11 Schritte Setup- und 35-8=27 Schritte Hold-Reserve.

Die obige Abbildung zeigt das Augendiagramm einer einzelnen DQ-Leitung.

Links bezeichnet “vref” die zur Referenzspannung gehörende Augenbreite. “*” vor vref markiert die Referenzspannung mit maximaler Augenbreite, “+” die von der aktuellen Firmware verwendete Spannung. Der angegebene vref-Wert ist nicht exakt; intern wird der nächstliegende verfügbare Wert verwendet. Bei angezeigten 30.4% und nächstem internem Wert 30.2% sind tatsächlich 30.2% wirksam.

In der Mitte bezeichnet “-“ einen ungültigen Phasenpunkt, “” einen gültigen Phasenpunkt und “+” den Standardabtastpunkt. Der Bereich zwischen “|” ist die erforderliche Mindestreserve für Setup/Hold. Von “+” bis zum äußersten linken “” reicht die Setup-Reserve, bis zum äußersten rechten “*” die Hold-Reserve. Dringt die tatsächliche Augengrenze in den Mindestbereich ein, wird der Punkt durch “o” ersetzt. Ein “o” zeigt unzureichende Signalreserve an, wie folgt:

Quelltypografie: Im PDF stehen in diesem Absatz zwei leere Anführungszeichen. Der letzte Satz und der entsprechende chinesische Absatz verwenden *. Die russische Übersetzung deutet die beiden leeren Markierungen mit ausdrücklichem redaktionellem Hinweis als *; diese deutsche Fassung bewahrt die leeren Quellmarkierungen. Prüfen Sie sie anhand der Werkzeugausgabe.

Rechts stehen in “[]” von links nach rechts die linke Augengrenze, der Mittelwert, die rechte Augengrenze und die gesamte Augenbreite.

Die obige Abbildung zeigt das zusammengefasste Auge aller DQ-Leitungen.

Editierbare Screenshot-Abschrift mit Originalfeldern und -werten:

Zur Prüfung aller einzelnen DQ-Leitungen fasst die obige Tabelle deren Ergebnisse zusammen.

“max eye” listet linke Grenze, Mitte, rechte Grenze und Gesamtbreite des breitesten Auges aller DQ-Leitungen auf. Laut dieser Quellbeschreibung ist dessen Vref mit “+” markiert. Von links nach rechts folgen DQ0, DQ1 usw.

“current eye” listet die Augenbreite beim aktuell verwendeten Vref auf, laut dieser Quellbeschreibung mit “*” markiert. Das Format entspricht “max eye”.

Quellenwiderspruch: Zuvor wird * dem Vref mit maximaler Augenbreite und + dem aktuellen Vref zugeordnet; die Erklärung von max/current vertauscht dies. Beide Aussagen bleiben erhalten. Prüfen Sie Werkzeugversion und tatsächliche Ausgabe.

Endergebnis: “all result: pass” am Protokollende bedeutet, dass alle DQ-Reserven genügen. Andernfalls erscheint “all result: err”.

4.2 Eindimensionale Augendiagramme scannen

Verwenden Sie auf unterstützten Plattformen vorzugsweise den 2D-Scan, da er zusätzlich Vref berücksichtigt. 1D-Scans dienen besonderen Anforderungen.

4.2.1 Unterstützte Plattformen

RV1109, RV1126, RK3566, RK3568, RK3528, RK3562

4.2.2 Verwendung

4.2.2.1 Vorbereitung

1. Prüfen Sie die DDR-Binärversion: RV1126 benötigt V1.09 oder neuer, RK3568/RK3566 V1.07 oder neuer. Aktualisieren Sie bei älteren Versionen das rkbin-Projekt.

2. Öffnen Sie vor dem U-Boot-Build menuconfig im Projektstamm. Aktivieren Sie unter “Command line interface” die Option “Enable ddr test tool” und speichern Sie die Konfiguration. Das DQ-Augendiagrammwerkzeug ist Bestandteil des DDR-Testwerkzeugs.

Editierbare Screenshot-Abschrift mit Originalfeldern und -werten:

[ ] Enable memtester for ddr
[*] Enable ddr test tool
    Misc commands --->

3. Kompilieren Sie U-Boot und programmieren Sie Loader und uboot; Einzelheiten siehe die U-Boot-Dokumentation.

4. Verbinden Sie die serielle Schnittstelle des Boards mit dem Host und prüfen Sie die Kommunikation. Drücken Sie beim Einschalten länger Ctrl+C, damit das Board in U-Boot bleibt. “<INTERRUPT>” zeigt diesen Zustand an.

Editierbare Screenshot-Abschrift mit Originalfeldern und -werten:

hclk_top 150000 KHz
pclk_top 100000 KHz
aclk_perimid 300000 KHz
hclk_perimid 150000 KHz
pclk_pmu 100000 KHz
Net: eth0: ethernet@fe010000
Hit key to stop autoboot('CTRL+C'): 0
=> <INTERRUPT>
=> <INTERRUPT>
=> <INTERRUPT>

4.2.2.2 DDR-DQ-Lese- und Schreibaugen in U-Boot anzeigen

Geben Sie in U-Boot folgenden Befehl ein:

ddr_dq_eye <DDR frequency in MHz>

Der Parameter <DDR frequency in MHz> legt die DDR-Taktfrequenz für die DQ-Augenanzeige in MHz fest. Ohne Angabe wird die höchste Frequenz verwendet.

Beispiel für DQ-Augendiagramme bei 1056MHz:

ddr_dq_eye 1056

Beispiel für DQ-Augendiagramme bei maximaler Frequenz:

ddr_dq_eye

4.2.2.3 Ergebnisauswertung

Das Werkzeug zeigt zunächst Version, DDR-Typ und Frequenz an.

Anschließend werden Lese- und Schreibaugen für jedes CS angezeigt.

Im Augendiagramm liegt “-“ außerhalb, “*” innerhalb des Auges. “|” markiert den Abtastpunkt.

Rechts werden linke und rechte Reserve (Margin_L, Margin_R), Abtastposition und Augenbreite angezeigt. Eckige Klammern markieren Breiten unterhalb des Mindestwerts, wie bei Lese-DQ0 im Beispiel.

Am Ende zeigt das Werkzeug die kleinsten Lese- und Schreibaugenbreiten sowie die Mindestanforderungen für eine ähnliche Frequenz.

4.2.3 Mindestbreiten der DDR-DQ-Augen

Die Grenzwerte beruhen auf Demo-Tests und Projekterfahrung. Unterschreitet die minimale Lese- oder Schreibaugenbreite den Grenzwert, kann DDR instabil arbeiten.

Das Einhalten dieser Grenze zeigt lediglich, dass die DQ-Augenbreite im aktuellen Design vergleichsweise zuverlässig ist. Es schließt andere DDR-Designprobleme nicht aus. Führen Sie weitere Zuverlässigkeitstests entsprechend den Einsatzanforderungen durch.

4.2.3.1 RV1126

4.2.3.2 RK3568/RK3566

5. Kapitel 5: Rockchip-DDR-Bandbreitenwerkzeug

5.1 Begriffe

Die wichtigsten Begriffe werden wie folgt verwendet:

monitor: Funktion zur Überwachung und statistischen Erfassung verschiedener DDR-Befehle.

5.2 Werkzeug beziehen

https://redmine.rock-chips.com/documents/49 -> DDR Related Materials_VerX.XX.7z -> Tools ->DDR Bandwidth Tool

5.3 Unterstützte Plattformen

Die unterstützten Plattformen lassen sich mit folgendem Befehl anzeigen:

# rk-msch-probe_vx.xx -h

Folgende Informationen werden ausgegeben. Welche Plattformen tatsächlich unterstützt werden, hängt von der Werkzeugversion ab.

Usage: [-c chip_name -d msecs -f freq -h help]
-c <chip_name>:
'rk312x' include rk3126,rk3128 and px3se
'rk322x' include rk3128h,rk3228a,rk3228b and rk3229
...
[option] -d <msecs>: Sets the sampling interval in milliseconds.
[option] -f <freq>: Specifies the mean current DDR frequency in MHz.
[option] -h: Displays help information.

5.4 Parameter

Das DDR-Bandbreitenwerkzeug rk_msch_probe_vx.xx unterstützt folgende Parameter:

-c: Chipname. Geben Sie nach Prüfung der Plattformunterstützung den Namen ein, beispielsweise rk3326.

-d: Überwachungsintervall in ms, optional. Standard ist 1000ms.

-f: Aktuelle DDR-Frequenz in MHz, optional. Das Werkzeug versucht in jedem Messintervall, die Frequenz selbst zu ermitteln. Schlägt dies fehl, muss sie angegeben werden.

Fixieren Sie die DDR-Frequenz vorher, da Änderungen

zu ungenauen Ergebnissen führen. -t test_loop: Anzahl der Testschleifen; anschließend beendet sich das Werkzeug. Standardmäßig läuft es unbegrenzt.

-h: Hilfe.

5.5 Voraussetzungen

Der DMC-devfreq-Governor darf nicht dmc_ondemand sein. Empfohlen wird der Wechsel zu userspace mit folgendem Befehl:

# echo userspace > /sys/class/devfreq/dmc/governor

Fixieren Sie anschließend die DDR-Frequenz, beispielsweise auf 780MHz:

# echo 780000000 > /sys/class/devfreq/dmc/userspace/set_freq

Die folgende Ausgabe bedeutet, dass diese Voraussetzungen nicht erfüllt sind:

Error: The DDR monitor time gets error!!!
Please check the devfreq governor is not 'dmc_ondemand'!!!
For example:
# cat sys/class/devfreq/dmc/governor
# dmc_ondemand
Please switch the devfreq governor to others, such as 'userspace'.
For example:
# echo userspace > /sys/class/devfreq/dmc/governor
Delete the result of this time!

5.6 Ausgabe erläutern

rk_msch_probe_vx.xx überwacht und protokolliert DDR-Bandbreite und -Auslastung.

Ausgabe allgemeiner Plattformen:

V1.06_20200629
ddr freq: 928Mhz
CH0:
ddr monitor statistics:
ddr load = 3251.23MB/s(43.76%) [RD:1859.93MB/s(25.03%), WR:1391.30MB/s(18.72%), ACT(access :
active): 3.34, srex:0.54%, pdex:1.27%, clkstp:0.00%, lp:1.81%]

Ausgabe für RK3588:

ddr freq: 2133Mhz
===========ALL=============CH0===============CH1==============CH2===============CH3========
LOAD: 4.51MB/s(0.03%), 1.23MB/s(0.04%), 1.13MB/s(0.03%), 1.16MB/s(0.04%),
 1.00MB/s(0.03%)
RD: 2.57MB/s(0.02%), 0.74MB/s(0.02%), 0.65MB/s(0.02%), 0.67MB/s(0.02%),
 0.51MB/s(0.02%)
WR: 1.94MB/s(0.01%), 0.49MB/s(0.02%), 0.48MB/s(0.01%), 0.49MB/s(0.02%),
 0.48MB/s(0.01%)
===========================================================================================

Bedeutung der Statistikfelder:

5.7 Häufige Fragen

1) Bei fehlendem “/dev/mem” erscheint folgende Fehlermeldung:

rk3568:/ # rk-msch-probe_vx.xx -c rk356x
open /dev/mem error: No such file or directory

Ursache ist die deaktivierte Kerneloption CONFIG_DEVMEM. Dadurch kann das Werkzeug nicht auf Geräteregister zugreifen.

Lösung 1: Ergänzen Sie CONFIG_DEVMEM=y in der passenden Kernel-Konfigurationsdatei, beispielsweise android-11.config, und kompilieren Sie die Firmware erneut.

Lösung 2: Führen Sie make menuconfig aus, suchen und aktivieren Sie DEVMEM und kompilieren Sie den Kernel erneut. Achten Sie darauf, die Konfiguration nicht zu überschreiben.

Symbol: DEVMEM [=y]
Type : bool
Prompt: /dev/mem virtual device support
Location:
    -> Device Drivers
(1) -> Character devices
  Defined at drivers/char/Kconfig:10
...
[*] /dev/mem virtual device support
...

6. Kapitel 6: DDR_UserTool zur DDR-Lötstellenprüfung

6.1 Übersicht

DDR_UserTool prüft DDR-Lötverbindungen.

Das Werkzeug wird unter https://redmine.rock-chips.com/documents/49 bereitgestellt: DDR相关资料_Verx.xx.7z → 工具 → DDR_UserTool_vx.xx.

Die Versionsnummer von DDR_UserTool kann lange unverändert bleiben, während interne Konfigurationsdateien etwa für neue Plattformen aktualisiert werden. Laden Sie deshalb für jedes neue Projekt die aktuelle Version aus Redmine.

6.2 Testschritte

6.2.1 DDR_UserTool auf Englisch umstellen

Öffnen Sie resource/config.ini und ändern Sie “Selected=1” auf “Selected=2”, um Englisch einzustellen.

Editierbare Screenshot-Abschrift mit Originalfeldern und -werten:

[Language]
Kinds=2
Selected=2
LangPath=Language\
Lang1File=Chinese.ini
Lang1FontName=宋体
Lang1FontSize=9
Lang1Tag=CHN
Lang1CHNTitle=中文
Lang1ENGTitle=Chinese
Lang2File=English.ini
Lang2FontName=Arial
Lang2FontSize=9
Lang2Tag=ENG
Lang2CHNTitle=英文
Lang2ENGTitle=English
[System]

6.2.2 DDR_UserTool.exe öffnen

Hinweis für Windows 7: Rechtsklick und „Als Administrator ausführen“ wählen.

6.2.3 TestFile auswählen

TestFiles liegen als .cfg-Dateien im Unterordner “TestFile” des Werkzeugs. Wählen Sie die Datei passend zu Plattform und DDR-Kapazitätsaufbau.

Beachten Sie:

DDR4-x16-DDP-Bausteine (Dual Die Package) sind wie zwei x8-Bausteine zu behandeln. Verwendet ein nominell als “4GB DDR4(1CS x 2pcs x 1Gb×16bit)” beschriebenes Gerät x16-DDP-Bausteine, wählen Sie die TestFile für “4GB DDR4(1CS x 4pcs x 1Gb×8bit)”. Zur Erkennung siehe den entsprechenden Abschnitt.

TestFiles für LPDDR4 und LPDDR4X sind nicht austauschbar.

Für DDR3L verwenden Sie die DDR3-TestFile.

6.2.4 TestFile signieren

Nur für Geräte mit Secure Boot erforderlich; andere Geräte überspringen diesen Schritt.

Signieren Sie die TestFile mit SecureBootTool, ebenfalls verfügbar unter https://redmine.rock-chips.com/documents/49. Konfigurieren Sie Chip, Key und weitere Optionen und klicken Sie auf “Sign DDR File”. Einzelheiten siehe SecureBootTool_UserManual.

6.2.5 Zielgerät in den Testzustand versetzen

Verbinden Sie den OTG-Anschluss des Zielgeräts. Wenn möglich, verbinden Sie zusätzlich die serielle Schnittstelle.

Es gibt mehrere Wege in den Testzustand:

Geräte ohne programmierte Firmware

Diese befinden sich bereits im Maskrom-Zustand und können direkt getestet werden.

Gerät in Maskrom-Zustand versetzen

Beim Einschalten werden CLK und GND des Speichergeräts kurzgeschlossen. Welche Pins dafür vorgesehen sind, entnehmen Sie dem RK-Schaltplan. Üblicherweise gibt es eine reservierte Taste oder Testpunkte für Maskrom.

Gerät in Loader-Modus versetzen

Nach Eintritt in den Testzustand zeigt das Werkzeug “Found one device”.

6.2.6 Test starten

Klicken Sie auf “StartTest”. Der Fortschrittsbalken läuft an, und das Protokoll wird gleichzeitig angezeigt. Der Test dauert üblicherweise weniger als zwei Minuten.

Bei aktivierter Option “AutoTest” startet der Test automatisch beim Anschluss eines Geräts.

6.2.7 Testergebnis auswerten

6.2.7.1 Test bestanden

6.2.7.2 Test fehlgeschlagen

Löten Sie entsprechend den Fehlermeldungen die betroffenen DDR-Bausteine und den SoC nach. Zur Zuordnung der konkreten Leitungen siehe den Abschnitt über Fehlermeldungen und Hardwaresignale.

Nach Reparatur eines fehlgeschlagenen Geräts muss erneut getestet werden, bis es den Test besteht.

6.2.7.3 Test unterbrochen

Zur Fehlersuche siehe den Abschnitt über Ursachen eines Testabbruchs.

6.3 Häufige Fragen

6.3.1 Kann DDR_UserTool die DDR-Stabilität prüfen?

Nein. DDR_UserTool bietet derzeit nur eine Lötstellenprüfung. Zur Stabilitätsprüfung siehe den DDR-Verifikationsablauf.

6.3.2 Erkennt DDR_UserTool Lötprobleme an allen Pins?

Nein. Die softwarebasierte Prüfung ist schnell und bequem, hat aber Grenzen. Sie erfasst weder alle DDR-Pins noch Pins anderer Module.

Üblicherweise lassen sich Lötprobleme an DQ und den meisten CA-Pins erkennen. Versorgungspins sowie CKE und ODT werden nicht erfasst.

6.3.3 DDR4-x16-DDP-Bausteine erkennen

1. Prüfen Sie den Schaltplan: Ist M9 des DDR4-Bausteins mit BG1 auf SoC-Seite verbunden, handelt es sich um x16 DDP. Bei Verbindung mit VSS nicht.

2. Prüfen Sie das Loader-Protokoll eines normal startenden Geräts. “Die BW=8” in den Kapazitätsangaben bestätigt x16 DDP.

3. Prüfen Sie das Datenblatt auf eine ausdrückliche DDP-Kennzeichnung (Dual Die Package). Alternativ gilt: M9 = BG1 bedeutet x16 DDP, M9 = VSS bedeutet kein x16 DDP.

6.3.4 Keine passende TestFile gefunden

Prüfen Sie auf Aktualisierungen.

Fehlt für eine neue Plattform noch eine TestFile, warten Sie auf ein Werkzeugupdate.

Für bereits unterstützte Plattformen sind die üblichen DDR-Konfigurationen normalerweise abgedeckt. Prüfen Sie die zahlreichen Dateien sorgfältig. Bei einer besonderen Konfiguration ohne passende Datei stellen Sie eine Anfrage auf Redmine.

6.3.5 Ursachen eines Testabbruchs

1. Unter Windows 7 nicht als Administrator gestartet

2. Falsche TestFile, etwa unpassende Plattform, DDR-Typ oder Kapazitätskonfiguration

3. Wiederholung des Tests ohne erneuten Eintritt in den Testzustand

4. Nicht signierte TestFile bei Secure-Boot-Geräten

5. Veraltetes Werkzeug oder veraltete TestFile

6. Versorgungsproblem, beispielsweise unzureichende USB-Stromversorgung

7. USB-Verbindungsproblem; anderes Kabel oder anderen Computer versuchen

8. Bei Loader-Modus stattdessen Maskrom-Modus versuchen

6.3.6 Fehlermeldungen den Hardwareleitungen zuordnen

CA-Leitungen dürfen nicht vertauscht werden; ihre Zuordnung ist daher normalerweise eindeutig.

DQ-Fehler beziehen sich auf die Pinnamen der SoC-Seite. Maßgeblich ist der gemeinsame Namensteil, nicht der DDR-typabhängige Teil. Im folgenden RK3528-DDR4-Schaltplanausschnitt ist der gemeinsame Teil grün markiert. DQ1_B bezeichnet ein Problem an DDRPHY_B_DQ1 des SoC, also an der Leitung DDR4_DQU0_B.

6.3.7 Test fehlgeschlagen, aber Röntgenprüfung unauffällig

Röntgenaufnahmen erkennen nicht alle Lötprobleme. Ein Nachlöten von DDR-Bausteinen und SoC wird weiterhin empfohlen.

6.3.8 Trotz Nachlöten weiterhin Testfehler

1. Falsche TestFile oder veraltetes Werkzeug bzw. TestFile

2. Kalte Lötstellen sowohl am DDR-Baustein als auch am SoC; beide Seiten nachlöten

3. Leiterplattenfertigungsfehler, beispielsweise unterbrochene Leiterbahnen

4. Andere Ursachen als DDR-Lötstellen: Bausteinfehler, Hardwaredesign oder Versorgung

6.3.9 Viele Geräte bestehen den Test nicht

1. Falsche TestFile oder veraltetes Werkzeug bzw. TestFile

2. Probleme beim Bestücker oder im Leiterplattenfertigungsprozess

3. Andere Ursachen als DDR-Lötstellen: Bausteinfehler, Hardwaredesign oder Versorgung

6.3.10 Weitere Fragen auf Redmine stellen

Beschreiben Sie das Problem eindeutig und stellen Sie zur effizienten Analyse folgende Informationen bereit:

1. DDR-Teilenummer und Datenblatt

2. Anzahl der DDR-Bausteine auf dem Board, möglichst mit Schaltplan

3. Verwendete TestFile

4. Anteil fehlerhafter Geräte

5. DDR_Test_Log.txt aus dem Werkzeugverzeichnis, zugehörige Datei in resource\Log und serielles Testprotokoll. Falls funktionsfähige Geräte vorhanden sind, auch deren Protokolle bereitstellen.

6. Serielles Einschaltprotokoll; nach Möglichkeit ebenfalls von funktionsfähigen Vergleichsgeräten

7. Kapitel 7: Rockchip-HAL-DDR-ECC

7.1 Geltungsbereich

Dieser Abschnitt gilt ausschließlich für Systeme mit HAL, nicht für Linux-Systeme.

7.2 Begriffe

7.3 Einführung

ECC steht für Error Correcting Code und dient der Erkennung und Korrektur von DDR-Datenfehlern. RK3568 unterstützt Sideband-ECC mit einem zusätzlichen Kanal zur Speicherung der ECC-Daten neben dem Nutzdatenkanal. Es korrigiert Einbitfehler und erkennt Zweibitfehler: SEC/DED-ECC (Single Error Correction/Double Error Detection).

7.4 DDR-ECC aktivieren

1. ECC wird automatisch aktiviert, wenn ein Baustein an DDR_ECC_DQ0-7 angeschlossen ist.

2. DDR_ECC_DQ0-7: ECC verwendet 32 Bit DQ-Daten plus 7 Bit ECC-Daten. Die aus DQ0–DQ31 berechneten ECC-Daten werden über DDR_ECC_DQ0-7 in einem zusätzlichen Baustein gespeichert.

3. Der zusätzliche ECC-Baustein muss hinsichtlich Typ, Zeilen, Spalten und Bänken mit den Bausteinen an DQ0–31 übereinstimmen.

4. Alle DDR-Typen unterstützen ECC.

7.5 DDR-ECC-Informationen über HAL abrufen

Die eigentliche Fehlererkennung und -korrektur erfolgt durch die IP-Hardware. Software kann die zugehörigen Informationen auslesen.

7.5.1 Konfiguration

Aktivieren Sie das DDR-ECC-Modul in hal_conf.h des Projekts. Für RK3568 ergänzen Sie beispielsweise folgenden Code in project/rk3568/src/hal_conf.h.

#define HAL_DDR_ECC_MODULE_ENABLED

7.5.2 Code und API

lib/hal/src/hal_ddr_ecc.c

lib/hal/inc/hal_ddr_ecc.h

/* Initialize DDR ECC related information */
HAL_Status HAL_DDR_ECC_Init(struct DDR_ECC_CNT *p);
/*
 * Get cumulative statistical information of DDR ECC, including the number of single-bit
 * correctable errors and double-bit detectable but uncorrectable errors
 */
HAL_Status HAL_DDR_ECC_GetInfo(struct DDR_ECC_CNT *p);

7.5.3 Anwendungsbeispiele

Übergeordnete Software kann ECC-Informationen durch Software-Polling oder Hardware-Interrupts abrufen.

Software-Polling

Beispiel:

struct DDR_ECC_CNT eccInfo;
void HAL_DDR_ECC_TEST_POLL(void)
{
    uint32_t cpuID;
    cpuID = HAL_CPU_TOPOLOGY_GetCurrentCpuId();
    if (cpuID == 0) { /* Use a CPU, thread, or other method to
initialize and poll DDR ECC status */
        HAL_DDR_ECC_Init(&eccInfo);
        while (1) { /* After initializing DDR ECC information,
poll to get DDR ECC information */
            HAL_DDR_ECC_GetInfo(&eccInfo); /* Cumulative CE and UE counts are stored
in the eccInfo structure */
            HAL_DelayMs(50);/* Polling interval, or other APIs to let the CPU idle */
        }
    }
}

Hardware-Interrupts

Beispiel:

struct DDR_ECC_CNT eccInfo;
void HAL_DDR_ECC_IRQHandler(uint32_t irq)
{
    HAL_DDR_ECC_GetInfo(&eccInfo);
}
void HAL_DDR_ECC_TEST_INT(void)
{
    uint32_t cpuID;
    cpuID = HAL_CPU_TOPOLOGY_GetCurrentCpuId();
    if (cpuID == 0) { /* Use a CPU, thread, or other method to initialize DDR ECC
related */
        HAL_DDR_ECC_Init(&eccInfo);
        HAL_GIC_SetHandler(DDR_ECC_CE_IRQn, HAL_DDR_ECC_IRQHandler); /* Attach CE
interrupt service routine */
        HAL_GIC_SetHandler(DDR_ECC_UE_IRQn, HAL_DDR_ECC_IRQHandler); /* Attach UE
interrupt service routine */
        HAL_GIC_Enable(DDR_ECC_CE_IRQn); /* Enable CE interrupt
service */
        HAL_GIC_Enable(DDR_ECC_UE_IRQn); /* Enable UE interrupt
service */
    }
}

Bei erkanntem ECC-Fehler werden die erfassten Informationen ausgegeben.

# 2 CE (correctable errors) detected
[HAL WARNING] DDR ECC error: CE, 2 errors, the last is in DDR cs 0, Row 0xa0, ChipID
0x0, BankGroup 0x0, Bank 0x5, Col 0x318, Bit position 0x10000000
# 1 UE (uncorrectable error) detected
[HAL ERROR] DDR ECC error: UE, 1 errors, the last is in DDR cs 0, Row 0xa0, ChipID
0x0, bankGroup 0x0, Bank 0x5, Col 0x354

7.6 DDR-ECC-Fehlerinjektion (Data Poison)

Zur Funktionsprüfung kann DDR-ECC-Data-Poison aktiviert werden. Schreiben und Lesen einer bestimmten physischen Adresse lösen anschließend DDR-ECC-CE/UE aus.

7.6.1 Code und API

lib/hal/src/hal_ddr_ecc.c

lib/hal/inc/hal_ddr_ecc.h

/* Enable DDR ECC error injection */
HAL_Status HAL_DDR_ECC_PoisonEnable(struct DDR_ECC_CNT *p);
/* Disable DDR ECC error injection */
HAL_Status HAL_DDR_ECC_PoisonDisable(struct DDR_ECC_CNT *p);

Standardmäßig erzeugt Data Poison erkennbare und korrigierbare Einbitfehler (CE). Zur Umstellung auf

erkennbare, aber nicht korrigierbare Doppelbitfehler (UE) ändern Sie Folgendes:

static HAL_Status DDR_ECC_SMCPoison(uint32_t eccPoisonEn,
                                    struct DDR_ECC_CNT *priv)
{
    ...
    pShareMemCfg->eccPoisonMode = DDR_ECC_UE_DATA_POISON;
    ...
}

7.6.2 Anwendungsbeispiel

struct DDR_ECC_CNT eccInfo;
void DDR_ECC_PoisonTriger(struct DDR_ECC_CNT *priv)
{
    uint32_t volatile *p = NULL;
    printf("DDR_ECC debug: eccPoisonAddr = 0x%llx\n", priv->eccPoisonAddr);
    if (priv->eccPoisonAddr) {
        p = (uint32_t volatile *)priv->eccPoisonAddr;
        *p = 0x5aa5f00f; /* Write to the DDR ECC data poison physical address */
        HAL_DCACHE_CleanInvalidate(); /* If the address attribute is cacheable, flush Dcache
to ensure the write is successful */
        printf("DDR_ECC debug: %p = 0x%x, reread = 0x%x\n", p, *p, *p);
    }
}
void DDR_ECC_GetInfo(void)
{
    HAL_DDR_ECC_GetInfo(&eccInfo);
}
void HAL_DDR_ECC_TEST_POLL(void)
{
    uint32_t cpuID;
    uint32_t i = 10;
    cpuID = HAL_CPU_TOPOLOGY_GetCurrentCpuId();
    if (cpuID == 0) {
        HAL_DDR_ECC_Init(&eccInfo);
        HAL_DDR_ECC_PoisonEnable(&eccInfo);/* Enable DDR ECC data poison, the physical
address for data poison will be saved in eccInfo.eccPoisonAddr */
        while (i) {
            DDR_ECC_GetInfo();
            HAL_DelayMs(50);
            i--;
            if (i == 5) {
                DDR_ECC_PoisonTriger(&eccInfo); /* Trigger DDR ECC error */
            }
        }
        HAL_DDR_ECC_PoisonDisable(&eccInfo);
    }
}

7.7 Hinweise

1. DDR-ECC verwendet den Speicherbereich [0x100000, 0x1F0000]. Fehlt seine MMU-Abbildung, muss sie ergänzt werden.

--- a/lib/CMSIS/Device/RK3568/Source/Templates/mmu_rk3568.c
+++ b/lib/CMSIS/Device/RK3568/Source/Templates/mmu_rk3568.c
@@ -41,6 +41,8 @@ void MMU_CreateTranslationTable(void)
     // Define dram address space
    ...
+ MMU_TTSection(MMUTable, 0x100000, 0x100000 >> 20, Sect_Normal);
    ...

2. Auch der physische Data-Poison-Adressbereich ist möglicherweise nicht in HAL abgebildet. Ergänzen Sie die Abbildung, beispielsweise für 0x13576c20 wie folgt.

--- a/lib/CMSIS/Device/RK3568/Source/Templates/mmu_rk3568.c
+++ b/lib/CMSIS/Device/RK3568/Source/Templates/mmu_rk3568.c
@@ -41,6 +41,8 @@ void MMU_CreateTranslationTable(void)
     // Define dram address space
    ...
+ MMU_TTSection(MMUTable, 0x13500000, 0x100000 >> 20, Sect_Normal);
    ...

3. DED-ECC löst eine CPU-Data-Abort-Ausnahme aus. HAL behandelt diese standardmäßig nicht. Ergänzen Sie folgende Änderung, wenn DDR-ECC-UE-Informationen ausgegeben werden sollen.

--- a/lib/CMSIS/Device/RK3568/Source/Templates/GCC/startup_rk3568.c
+++ b/lib/CMSIS/Device/RK3568/Source/Templates/GCC/startup_rk3568.c
@@ -237,6 +237,7 @@ void Reset_Handler(void)
  *----------------------------------------------------------------------------*/
 void Default_Handler(void)
 {
+ DDR_ECC_GetInfo();
     while(1);
 }