DIPLOMARBEIT - FG Mikroelektronik, TU Berlin

Aufgabenstellung: 

Prof. Dr. Otto Manck 

Institut für Mikroelektronik 

Technische Universität Berlin 

Lukas Bauer 

DIPLOMARBEIT 

Entwicklung eines TI-34020-kompatiblen Hochleistungs-Grafikprozessors 

unter Verwendung modernster Werkzeuge der Logik-Synthese 

Am Institut für Mikroelektronik soll ein Hochleistungs-Grafikprozessor entwickelt werden, der sich durch 

große Flexibilität und hohe Geschwindigkeiten auszeichnen soll. Er soll in wesentlichen Punkten zum 

TMS 34020 von Texas Instruments kompatibel sein. 

Die Video-Einheit des Grafikprozessors sorgt für die Bilddarstellung. Dabei werden universelle Signale 

zur Synchronisation des Monitors erzeugt. Um auch hochauflösende Monitore mit einem kontinuierlichen 

Bilddatenstrom aus den extern angeschlossenen Video-RAMs zu versorgen, müssen Reload-Zyklen in Echtzeit 

ausgeführt werden. Alle Parameter der Videosignale sind über Register programmierbar. Des weiteren 

werden Zooming, Panning, die Synchronisation auf externe Videosignale sowie Voll- und Halbbildbetrieb 

unterstützt. 

Die Prozessor-Einheit ist in der Lage, selbständig Grafikbefehle auszuführen. Dazu gehören unter anderem 

der Pixel-Block-Transfer, das Füllen von Blöcken mit mehrfarbigen Mustern sowie das Clipping. Dabei 

werden spezielle Fähigkeiten der DRAMs und VRAMs, wie Fast-Page-Mode, Color-Register und Block- 

Write, unterstützt. 

Die Controller-Einheit soll eine universelle Schnittstelle zur Peripherie bilden, die alle gängigen, gemultiplexten 

und nicht gemultiplexten Bussysteme unterstützt. Dabei werden unabhängig voneinander verschiedene 

Breiten von Host- und Speicherbus zugelassen. Das Speicherinterface erlaubt die verschiedensten Konfigurationen 

von DRAMs und VRAMs und führt die Adreßrechnung und Refresh-Zyklen durch. 

Die Entwicklung soll mittels Logik-Synthese erfolgen. Dazu steht Speedchart-VHDL als graphisches Eingabe- 

Werkzeug für VHDL zur Verfügung; zur Synthese kann Silcsyn, zur Simulation VHDL2000 und Cadat 

verwendet werden. Ein wesentlicher Bestandteil der Aufgabe soll dabei die Analyse der Möglichkeiten sein, 

Speedchart-VHDL bei der Entwicklung integrierter Schaltungen einzusetzen. 

Aufgrund der sehr hohen Komplexität kann im Rahmen einer Diplomarbeit nicht der vollständige Grafikprozessor 

entwickelt werden. Daher soll nur die Video-Einheit bis ins Detail entwickelt, synthetisiert und 

auf Gatterebene simuliert werden. Die Prozessor- und Controller-Einheit sollen nur grob modelliert werden, 

wobei es z. B. ausreicht, wenn die Prozessor-Einheit exemplarisch nur einen Befehl beherrscht. 

Zuständiger Professor: Prof. Dr. O. Manck 

Betreuer: Thomas Lorenz 

Bearbeiter: Lukas Bauer, Matr.-Nr. 113 150 

Beginn der Arbeit: ∗ 01.07.1993 

Ende der Arbeit: 01.09.1993 

∗ Beginn der Einarbeitungszeit in Speedchart, Silcsyn und die Simulatoren: 04.01.1993



Lukas Bauer 

Inhaltsverzeichnis 

Diplomarbeit 

Hochleistungs-Grafikprozessor in Speedchart-VHDL 


Seite 2 

1 Moderne Werkzeuge der Logik-Synthese 5 

1.1 Schaltungsentwurf durch Logik-Synthese . . . . . . . . . . . . . . . . . . . . . . . . . 5 

1.2 Speedchart-VHDL als grafisches Eingabe-Werkzeug für VHDL . . . . . . . . . . . . 5 

1.3 Synthese-Werkzeuge und Simulatoren auf VHDL-Basis . . . . . . . . . . . . . . . . . 6 

2 Ein Hochleistungs-Grafikprozessor 7 

2.1 Anforderungen an einen Hochleistungs-Grafikprozessor . . . . . . . . . . . . . . . . . 7 

2.2 Gliederung des Grafikprozessors in funktionale Einheiten . . . . . . . . . . . . . . . . 8 

2.3 Prioritätssteuerung der ablaufenden Prozesse . . . . . . . . . . . . . . . . . . . . . . 9 

3 Die Video-Timing-Einheit 11 

3.1 Aufgaben der Video-Timing-Einheit . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 

3.2 Interne Synchronisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 

3.2.1 Vollbildbetrieb (Non-Interlaced Mode) . . . . . . . . . . . . . . . . . . . . . . 12 

3.2.2 Halbbildbetrieb (Interlaced Mode), NTSC . . . . . . . . . . . . . . . . . . . . 14 

3.2.3 Halbbildbetrieb (Interlaced Mode), PAL . . . . . . . . . . . . . . . . . . . . . 16 

3.3 Externe Synchronisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 

3.4 Realisierung in Speedchart-VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 

3.4.1 Steuerung des horizontalen Timings . . . . . . . . . . . . . . . . . . . . . . . 19 

3.4.2 Steuerung des vertikalen Timings . . . . . . . . . . . . . . . . . . . . . . . . . 20 

3.4.3 Steuerung der externen Synchronisation . . . . . . . . . . . . . . . . . . . . . 21 

4 Die VRAM-Reload-Einheit 23 

4.1 Aufgaben der VRAM-Reload-Einheit . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 

4.2 Reload–Mechanismen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 

4.2.1 

” Newline Reloads“ und Midline Reloads“ . . . . . . . . . . . . . . . . . . . . 

” 

23 

4.2.2 

” Split Reloads“ und Non-Split Reloads“ 

” 

. . . . . . . . . . . . . . . . . . . . 24 

4.3 Taktsignale für Video-RAMs und Video-D/A-Wandler . . . . . . . . . . . . . . . . . 25 

4.4 Timing von Reload-Zyklen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 


4.5.1 Vorausberechnung der Anzahl der notwendigen Reloads . . . . . . . . . . . . 27 

4.5.2 Steuerung des Zeitpunktes von Reloads . . . . . . . . . . . . . . . . . . . . . 30 

4.5.2.1 Zeitpunkt von Newline Reloads . . . . . . . . . . . . . . . . . . . . . 30 

4.5.2.2 Zeitpunkt von Non-Split Midline Reloads . . . . . . . . . . . . . . . 30 

4.5.2.3 Zeitpunkt von Split Midline Reloads . . . . . . . . . . . . . . . . . . 31 

4.5.3 Erzeugung der Taktsignale für die Video-D/A-Wandler . . . . . . . . . . . . . 32 

4.5.4 Refresh von DRAMs und VRAMs . . . . . . . . . . . . . . . . . . . . . . . . 32 

4.5.5 Die Arbitrierungslogik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 

4.5.6 Modellierung eines Video-RAMs . . . . . . . . . . . . . . . . . . . . . . . . . 34



Lukas Bauer 

Diplomarbeit 



Seite 3 

5 Die Controller-Einheit 35 

5.1 Aufgaben der Controller-Einheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 

5.2 Host-Zugriffe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 

5.2.1 Handshake bei Host-Zugriffen . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 

5.2.2 Host-Zugriffe bei gemultiplextem Bus . . . . . . . . . . . . . . . . . . . . . . 35 

5.2.3 Host-Zugriffe bei nicht gemultiplextem Bus . . . . . . . . . . . . . . . . . . . 36 

5.2.4 Beschleunigter Handshake . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 

5.3 Speicherorganisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 

5.4 Adreßrechnung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 

5.5 Externe versus interne Host-Daten-Register bei nicht gemultiplextem Host-Bus . . . 40 


5.6.1 Steuerung von Host-Zugriffen . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 

5.6.2 Modellierung eines Hosts zum Test des Handshakes . . . . . . . . . . . . . . . 43 

5.6.3 Steuerung von Speicherzugriffen . . . . . . . . . . . . . . . . . . . . . . . . . 43 

6 Die Prozessor-Einheit 45 

6.1 Aufgaben der Prozessor-Einheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 

6.2 Funktionsweise der implementierten Befehle . . . . . . . . . . . . . . . . . . . . . . . 46 

6.2.1 Der “Clip”-Befehl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 

6.2.2 Der “Pixel Block Transfer”-Befehl . . . . . . . . . . . . . . . . . . . . . . . . 46 


6.3.1 Befehlsauswahl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 

6.3.2 Realisierung des “Clip”-Befehls . . . . . . . . . . . . . . . . . . . . . . . . . . 47 

6.3.3 Realisierung des “Pixel Block Transfer”-Befehls . . . . . . . . . . . . . . . . . 48 

6.3.3.1 Umwandlung der Bereichsgrenzen in lineare Pixel-Adressen . . . . . 48 

6.3.3.2 Zeilenweise Bearbeitung des Befehls . . . . . . . . . . . . . . . . . . 49 

6.3.3.3 Datenfluß beim Kopieren der Zeilendaten . . . . . . . . . . . . . . . 49 

6.3.3.4 Erweiterte Speicherzugriffs-Möglichkeiten der Controller-Einheit . . 51 

6.3.4 Implementierung weiterer Grafik-Befehle . . . . . . . . . . . . . . . . . . . . . 53 

6.3.5 Timing der Befehle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 

7 Werkzeuge der Logik-Synthese in der Praxis 55 

7.1 Produktivitätssteigerung durch den Einsatz von Speedchart-VHDL . . . . . . . . . . 55 

7.2 Silcsyn als Synthese-Werkzeug auf VHDL-Basis . . . . . . . . . . . . . . . . . . . . . 56 

7.3 Simulation auf VHDL- und Gatterebene . . . . . . . . . . . . . . . . . . . . . . . . . 57 

7.4 Bilanz: grafisch-zustandsorientierte Eingabe mit teilautomatischer Synthese als 

leistungsfähiger Kompromiß . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 

Literaturverzeichnis 59 

Glossar 60



Lukas Bauer 

Diplomarbeit 



Seite 4 

Tabellenverzeichnis 61 

Abbildungsverzeichnis 62 

Anhang 66 

A Übersicht über den Grafikprozessor ” TIM“ . . . . . . . . . . . . . . . . . . . . . . . 66 

A.1 Register . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66 

A.2 Externe Signale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 

B Timing-Diagramme der DRAMs und VRAMs . . . . . . . . . . . . . . . . . . . . . . 71 

C Die Video-Timing- und VRAM-Reload-Einheit (Design ” VIDEO“) . . . . . . . . . . 78 

C.1 Hierarchie und Seitenverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . 78 

C.2 Speedchart-Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 

C.3 Simulationsergebnisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 

D Die Controller- und Prozessor-Einheit (Design ” TIM“) . . . . . . . . . . . . . . . . . 113 

D.1 Hierarchie und Seitenverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . 113 

D.2 Speedchart-Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 

D.3 Simulationsergebnisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145



Lukas Bauer 

Diplomarbeit 


1 Moderne Werkzeuge der Logik-Synthese 

1.1 Schaltungsentwurf durch Logik-Synthese 

Abschnitt 1.2 

Seite 5 

Fünfunddreißig Jahre ist es nun her, daß die ersten integrierten Schaltungen auf den Markt kamen. 

Waren diese noch von so geringer Komplexität (um die 10 Gatter), daß sich die Layouts per Hand 

auf Folien kleben ließen, so werden heute Schaltungen von 100.000 irregulären Gattern und mehr 

benötigt. Es ist sofort ersichtlich, daß der Entwickler hierbei die Unterstützung automatischer 

Werkzeuge benötigt. Da diese aber keine eigene Intelligenz oder Kreativität besitzen können, 

können sie dem Entwickler nur ” stupide“ Arbeiten nach einfachen Regeln (einschließlich Mutation 

und Selektion) abnehmen. 

Für viele Anwendungen akzeptiert werden heute Auto-Router, die das Layout zu einer Schaltung 

erstellen können. Doch auch der Entwurf synchroner Zustandsmaschinen (“finite 

state machine”, FSM) gehorcht so einfachen Regeln, daß er sich automatisieren läßt. Ausgangspunkt 

ist hierbei eine computerlesbare Form der Schaltungsspezifikation mittels einer Hardware- 

Beschreibungssprache wie z. B. VHDL. Ein Syntheseprogramm kann diese Beschreibung dann in 

eine Zustandsmaschine umsetzen, was dem Entwickler nicht nur Arbeit abnimmt, sondern auch Fehler 

bei der Aufstellung von Übergangsgleichungen etc. vermeidet und den Aufwand bei Änderungen, 

wie der Einführung von neuen Zuständen, von einem kompletten Neu-Entwurf des Schaltungsteils 

auf eine kleine Ergänzung im VHDL-Text reduziert. 

Mit modernen Synthese-Werkzeugen auf VHDL-Basis lassen sich heute (zumindest in der Theorie) 

nahezu alle Schaltungen realisieren, die im wesentlichen Synchronschaltwerke darstellen. Ein 

Grafikprozessor, gefertigt als CMOS Gate Array, ist ein typisches Beispiel hierfür. Doch auch angesichts 

der Produktivitätssteigerung, die die Verwendung von Logik-Synthese mit sich bringt, ist die 

Komplexität der benötigten Schaltungen in den letzten Jahren schneller gewachsen als die Effizienz 

der Entwurfsmethoden. 

Versucht man, die immer komplexer werdenden Schaltungen mit herkömmlichen Methoden zu entwerfen, 

so steigen nicht nur Personalaufwand und Entwicklungszeit in Grenzenlose. Die Fehlerwahrscheinlichkeit 

sowie Kommunikations-, Spezifikations- und Schnittstellenprobleme machen weitere 

Komplexitätssteigerungen ohne eine Revolutionierung der Design-Methoden ab einem bestimmten 

Punkt unmöglich [16]. 

So ist auch am Institut für Mikroelektronik der TU Berlin bei der Entwicklung des Grafikprozessors 

zunächst der Versuch unternommen worden, ihn mittels Schaltplan-Eingabe zu realisieren. Nach 

etwa drei Mannjahren Arbeit kamen die Beteiligten zu den im vorigen Absatz dargestellten Erkenntnissen 

und stellten das Projekt ein, das nun im Rahmen dieser Diplomarbeit komplett neu 

begonnen wurde. 

1.2 Speedchart-VHDL als grafisches Eingabe-Werkzeug für VHDL 

Teil der Aufgabenstellung dieser Arbeit war die Untersuchung der Möglichkeiten, den Grafikprozessor 

mit dem neuen Programm ” Speedchart-VHDL“ [3] zu entwickeln, das die Eingabe von VHDL 

mittels einer grafischen Benutzeroberfläche unter Verwendung erweiterter Zustandsmaschinen erlaubt. 

Obwohl der Hersteller das Programm zunächst hauptsächlich als Werkzeug zur Spezifikation 

und Simulation konzipiert hatte, sollte hier die mögliche Bedeutung von Speedchart in Verbindung 

mit Synthese-Werkzeugen untersucht werden. Die zustandsorientierte Eingabe von VHDL 

könnte eine Revolutionierung der Design-Methoden bedeuten.



Lukas Bauer 

Diplomarbeit 


Abschnitt 1.3 

Seite 6 

Ein typisches Beispiel für einen zustandsorientierten Entwurf (“state machine design”) unter Speedchart 

ist im Diagramm auf Seite 120 zu sehen, das das Host-Interface des Grafikprozessors beschreibt. 

Zustände (“states”) werden hier als Kreise dargestellt, Transitionen (“transitions”) als 

Pfeile. Letztere kennzeichnen die möglichen Zustandsübergänge. Dabei kann jede Transition mit 

einer Bedingung (C), einer Priorität (#n, 0=höchste Priorität) und einem beim Zustandsübergang 

auszuführenden Aktionsblock (A) versehen werden. 

Als zusätzliches Hilfsmittel dienen Zustände (“drop-through states”, gestrichelt gezeichnet), bei 

denen die Übergangsbedingungen zum nächsten Zustand sofort ausgewertet werden, so daß bei 

einem erlaubten Austritt aus dem Zustand der Zustand selbst nicht aktiv wird. Dennoch werden 

die Aktionsblöcke in den zugehörigen Transitionen ausgeführt. Der Einsatz dieser Zustände erlaubt 

häufig eine übersichtlichere Gliederung bei Verzweigungen, z. B. beim Zustand AS. 

Zustände und Transitionen bilden zusammen eine synchrone Zustandsmaschine, bei der Zustandsübergänge 

nur mit der aktiven Flanke des Systemtaktes erfolgen können. Gleichzeitig lassen 

sich asynchrone Anweisungen in Form von Befehlsblöcken (“data path blocks”) definieren, von 

denen einer im Beispiel-Diagramm rechts zu sehen ist. 

In den synchronen und asynchronen Aktionsblöcken können Operationen sowie bedingte und unbedingte 

Variablen-Zuweisungen in VHDL-Syntax angegeben werden. An die Stelle von VHDL- 

Konstrukten, die Prozesse definieren, treten jedoch die Zustandsmaschinen. Dabei ist z. B. Konkurrenz 

(Parallelität) durch einfaches Nebeneinandersetzen zweier Diagramme (“subdiagrams”) 

möglich. 

Hierarchie wird in den Diagrammen durch doppelt umrandete Zustände angedeutet (z. B. 

reg read), wobei sich unter einem solchen Zustand ein oder mehrere Diagramme verbergen können, 

die ausgeführt werden, wenn der übergeordnete Zustand aktiv ist. Beim Eintritt in den hierarchischen 

Zustand werden die untergeordneten Zustandsmaschinen zunächst in den initialen Zustand 

entry versetzt. 

Nach der Eingabe eines solchen zustandsorientierten Entwurfs ist Speedchart 

selbsttätig in der Lage, den Entwurf in eine VHDL-Beschreibung umzusetzen, die 

alle zur Prozeßsteuerung notwendigen Konstrukte enthält. Im Idealfall kann die VHDL- 

Beschreibung anschließend von automatisierten Werkzeugen in eine integrierte Schaltung umgesetzt 

werden. 

Die eigentliche Aufgabe bei der Entwicklung des Grafikprozessors bestand daher im Rahmen dieser 

Arbeit darin, die in der Spezifikation [1] des Grafikprozessors grob skizzierten Funktionen in 

konkrete Algorithmen umzusetzen und diese in Form von Zustandsmaschinen einzugeben. 

1.3 Synthese-Werkzeuge und Simulatoren auf VHDL-Basis 

Als Synthese-Werkzeug (“silicon compiler”) konnte bei der Entwicklung das Racal-Redac-Produkt 

Silcsyn [6] eingesetzt werden, das auf Basis der von Speedchart erzeugten VHDL-Dateien Schaltungen 

synthetisiert und diese als Netzlisten von Gattern und Makro-Zellen eines Gate Arrays 

ablegt. 

Für die Simulation der Entwürfe stand der Simulator VHDL2000 [7] zur Verfügung, der ebenfalls auf 

Basis der erzeugten VHDL-Dateien arbeitet. Zur Verifikation der von Silcsyn erzeugten Schaltungen 

auf Gatterebene konnte der Simulator CADAT2000 [8] eingesetzt werden. 

Die Umsetzung der Netzlisten in ein Layout für ein CMOS Gate Array schließlich wird beim 

Hersteller mit Hilfe weiterer automatisierter Programme geschehen.



Lukas Bauer 

Diplomarbeit 


2 Ein Hochleistungs-Grafikprozessor 

2.1 Anforderungen an einen Hochleistungs-Grafikprozessor 

Abschnitt 2.1 

Seite 7 

Ein Grafikprozessor ist ein wesentlicher Bestandteil jedes modernen Computersystems. Er dient 

in erster Linie dazu, vom Computer erzeugte Texte und Grafiken in darstellbare Signale für einen 

Monitor umzusetzen und so einen Dialog zwischen Mensch und Maschine auf alphanumerische oder 

grafische Weise zu ermöglichen. Eine Grafik, die als zweidimensionale Matrix von Bildpunkten auf 

dem Monitor angezeigt werden soll, wird dabei in einem Grafikspeicher (Video RAM) abgelegt. Zur 

Darstellung muß der Grafikprozessor diesen Speicher periodisch auslesen und die Daten seriell an 

den Monitor weiterleiten, zusammen mit Synchronisations-Signalen, welche indirekt die horizontale 

und vertikale Lage der Bildpunkte (Pixel) angeben. 

Moderne Grafikprozessoren sind darüber hinaus in der Lage, selbständig Grafikbefehle zu bearbeiten 

und dadurch den Hauptprozessor des Rechners (Host) zu entlasten. Dies bedeutet neben der 

parallelen Befehlsausführung noch einen zweiten Geschwindigkeitsvorteil: Da der Grafikprozessor 

direkt auf den Grafikspeicher zugreifen kann, müssen die zu verarbeitenden Bilddaten nicht das 

” Nadelöhr“, den Systembus zwischen Host und Grafikprozessor, passieren. Lediglich kurze Befehle 

müssen vom Host zum Grafikprozessor übertragen werden. Typische Befehle sind das Verschieben 

von Bildschirmbereichen oder das Füllen von Blöcken mit mehrfarbigen Mustern. 

An einen Grafikprozessor, der für den Einsatz in den verschiedensten Computersystemen konzipiert 

wird, werden hohe Anforderungen in puncto Flexibilität gestellt. Dies betrifft zum einen die Schnittstelle 

zwischen Host und Grafikprozessor – hier müssen einige grundsätzlich verschiedene Normen 

unterstützt werden –, zum anderen die Parameter des Monitorbildes, zu denen die Bildschirmauflösung, 

die Bildwiederholrate und die Farbtiefe der Pixel gehören. Da sich auf verschiedenen 

Computersystemen eine Unzahl von genormten und nicht genormten Video-Modi entwickelt hat, 

muß beispielsweise die Bildschirmauflösung frei programmierbar sein, nach Möglichkeit in Schritten 

von nur einem Pixel. 

Der Anwender ist in der Regel gleichzeitig an einer hohen Auflösung, also einem hohen Informationsgehalt 

des Bildes, und einer hohen Wiederholrate, also einem flimmerfreien Bild, interessiert. 

Aus diesen Bedürfnissen ergibt sich die Forderung nach einer möglichst hohen Pixelfrequenz, dem 

Takt, in dem jeweils der nächste Bildpunkt ausgegeben wird. 

Da der Auflösung durch die beschränkte Pixelfrequenz der Video-RAMs und durch die Kosten 

des Monitors Grenzen gesetzt sind, unterstützen moderne Grafikprozessoren virtuelle Bildschirmauflösungen, 

die deutlich oberhalb der physikalischen Matrixgröße des Monitors liegen können. 

Dabei befindet sich ein großes Bild im Speicher, von dem ein beliebiger Teilbereich beschränkter 

Größe dargestellt werden kann. 

Um Video-Bilder von hoher vertikaler Auflösung (Zeilenlänge) darstellen zu können, sind spezielle 

Zugriffe auf die Video-RAMs nötig. VRAMs enthalten neben der Speichermatrix Schieberegister, 

aus denen die Video-Daten seriell ausgegeben werden können. Liegt die Zeilenlänge des Monitors 

über der Länge der Schieberegister, so ist während der Darstellung der Bildschirmzeilen ein Nachladen 

der Schieberegister mit neuen Daten in Echtzeit erforderlich. Nur auf diese Weise ist auch 

bei hohen Auflösungen ein kontinuierlicher Bilddatenstrom zu erreichen. 

Auch die Geschwindigkeit, mit der die Grafikbefehle bearbeitet werden, soll möglichst hoch sein. 

Daher sollen verschiedene Möglichkeiten moderner Video-RAMs unterstützt werden, die es ermöglichen, 

mit einer geringen Zahl von Zugriffen auf den Speicher große Datenmengen zu übertragen. 

Speicherinternsive Anwendungen wie digitales Video schließlich machen einen großen Bilddatenspeicher 

erforderlich. Da die Kosten von Video-RAMs deutlich über denen normaler dynamischer



Lukas Bauer 

Diplomarbeit 


Abschnitt 2.2 

Seite 8 

RAMs liegen, soll eine gemischte Bestückung mit VRAMs und DRAMs möglich sein. Zur Darstellung 

müssen die Daten aus den DRAMs in die VRAMs kopiert werden. 

Der im Rahmen dieser Arbeit zu entwickelnde Grafikprozessor ” TIM“ soll gemäß der Spezifikation 

[1] allen Anforderungen an einen modernen Hochleistungs-Grafikprozessor gerecht werden. 

Er soll zum TI-34020 in wesentlichen Punkten kompatibel sein, der Befehlssatz soll jedoch auf 

Befehle beschränkt sein, die auf rechteckigen Bildschirmbereichen arbeiten, da diese bei Desktop- 

Anwendungen fast ausschließlich verwendet werden. So soll z. B. das Ziehen diagonaler Linien 

nicht unterstützt werden. Stattdessen soll eine deutlich höhere Bearbeitungsgeschwindigkeit als 

beim TI-34020 erreicht werden. 

2.2 Gliederung des Grafikprozessors in funktionale Einheiten 

Der Grafikprozessor läßt sich den auszuführenden Funktionen nach in vier Einheiten gliedern: 

• Die Video-Timing-Einheit (Abschnitt 3) erzeugt Synchronisationssignale, die die Bilddarstellung 

auf dem Monitor steuern. 

• Die VRAM-Reload-Einheit (Abschnitt 4) steuert die Video-RAMs so, daß diese gleichzeitig 

einen kontinuierlichen Bilddatenstrom zur Verfügung stellen. 

• Die Controller-Einheit (Abschnitt 5) bildet die Schnittstelle zur Peripherie, die das Hostund 

das Speicherinterface verwaltet und Zugriffe des Hosts auf den Speicher und auf die 

Register des Grafikprozessors erlaubt. 

• Die Prozessor-Einheit (Abschnitt 6) ist in der Lage, selbständig Grafikbefehle zu bearbeiten. 

externe Sync-Signale 

❄ 

Video-Timing-Einheit VRAM-Reload-Einheit 

✛ 

Datenanforderung, 

Datentransfer 

Steuerung des Reload-Timings 

Registerwerte: 

Timing, Auflösung 

❄ ❄ 

✲ Multiplexer 

✛ ✲ 

✻ 

✻ 

Speicherbus 

Arbitrierung 

Speicher- 

Zugriffe 

❄ ❄ 

❄ ❄ ❄ 

Befehle ✛ Re- 

Speicherzugriffs-Einheit 

Prozessor-Einheit gi Controller-Einheit 

Parameter ✛ ster 

✛ ✲ Host-Interface 

lesen 

✻ 

❄ 

schreiben 

✲ 

✲ 

✲ 

✻ 

✻ 

Reload & 

Refresh 

❄ Host-Interface 

Abbildung 1: Das Blockschaltbild des Grafikprozessors ” TIM“ läßt die Gliederung in vier Einheiten erkennen. 

Video- ✲ 

Signale 

Takt✲ 

signale



Lukas Bauer 

Diplomarbeit 


Abschnitt 2.3 

Seite 9 

Die Video-Timing-Einheit und die VRAM-Reload-Einheit gehören dabei eng zusammen, denn die 

erste steuert die Zeitpunkte, zu denen die zweite die Daten bereitstellen muß. Die Einheiten haben 

einen gemeinsamen Systemtakt, den Video-Takt VClk. 

Die Controller-Einheit und die Prozessor-Einheit haben ebenfalls einen gemeinsamen Systemtakt, 

den Host-Takt MClk. Auch sie sind stark verflochten, so laufen z. B. Speicherzugriffe der Prozessor- 

Einheit über die Controller-Einheit ab. 

Im Speedchart-Entwurf wurden die Einheiten daher jeweils zu einem Design zusammengefaßt. Die 

entstehenden zwei Designs ” VIDEO“ und ” TIM“ sind funktional weitgehend unabhängig, so daß 

sich eine einfache Schnittstelle zwischen ihnen definieren läßt. Diese umfaßt hauptsächlich einige 

Registerwerte, die an die Video-Einheit übergeben werden, und einige Signale der Arbitrierungslogik, 

die dafür sorgt, daß die Einheiten zeitlich alternierend auf den gemeinsamen Speicherbus 

zugreifen können. 

Die Aufteilung auf zwei getrennte Designs war in der aktuellen Speedchart-Version zwingend erforderlich, 

da diese keine unterschiedlichen Systemtakte innerhalb eines Designs unterstützt. In 

einer zukünftigen Version wird dies aber möglich sein, so daß ein Gesamtentwurf unter Speedchart 

den kompletten Grafikprozessor beschreiben wird. Lediglich einige zum Teil bidirektionale 

Ausgangstreiber müssen dann noch per Hand angefügt werden. 

2.3 Prioritätssteuerung der ablaufenden Prozesse 

Im Grafikprozessor laufen verschiedene Prozesse ab, einige davon permanent, andere nur bei Bedarf. 

Dabei können die folgenden Prozesse unabhängig voneinander parallel ausgeführt werden: 

• Erzeugung der Video-Timing-Signale 

• Zugriffe des Hosts auf die Register des Grafikprozessors 

• Bearbeitung von Grafikbefehlen ohne Speicherzugriffe 

Bei allen Zugriffen auf den Speicher hingegen muß eine Arbitrierungslogik dafür sorgen, daß die 

Zugriffe zeitlich alternierend erfolgen. Dies gilt für die folgenden Zugriffe: 

• Refresh-Zyklen für die dynamischen RAMs 

• Reload-Zyklen (Laden der VRAM-Schieberegister mit Bilddaten) 

• Zugriffe des Hosts auf den Speicher (lesen, schreiben) 

• Speicherzugriffe bei der Bearbeitung von Grafikbefehlen 

Die Festlegung der Prioritäten dieser Prozesse muß sich nach einer Folgenabschätzung richten: 

Falls Refresh-Zyklen über einen längeren Zeitraum hinweg ausfallen, kann es zu Datenverlusten 

in den dynamischen RAMs kommen. Daher müssen Refresh-Zyklen, die bereits lange überfällig 

sind, die höchste Priorität erhalten. Wie in Abschnitt 4.5.4 noch erläutert wird, spielt der genaue 

Zeitpunkt von Refreshs jedoch keine Rolle; kleine Verzögerungen sind ohne weiteres tolerierbar. 

Daher können Refreshs normalerweise eine etwas niedrigere Priorität erhalten. 

Falls Reload-Zyklen nicht rechtzeitig durchgeführt werden können, werden temporäre 

Störstreifen auf dem Bildschirm sichtbar. Auch dies sollte unbedingt vermieden werden. In 

Abschnitt 4.2 werden verschiedene Arten von Reloads unterschieden, von denen manche zu einem 

exakten Zeitpunkt durchgeführt werden müssen. Solche Echtzeit-Reloads müssen daher ebenfalls



Lukas Bauer 

Diplomarbeit 


Abschnitt 2.3 

Seite 10 

eine sehr hohe Priorität erhalten. Andere Reloads müssen nur innerhalb einer gewissen Zeitspanne 

durchgeführt werden. Dennoch sind sie höher zu priorisieren als z. B. Speicherzugriffe des Hosts. 

Die Speicherzugriffe von Host und Grafikprozessor sind untereinander lediglich so einzustufen, 

daß eine möglichst hohe Geschwindigkeit des Gesamtsystems erreicht wird. Daher 

sollten Host-Zugriffe gegenüber Speicherzugriffen der Prozessor-Einheit bevorzugt behandelt werden, 

damit der Host über die Handshake-Signale des Host-Interfaces nicht komplett ” lahmgelegt“ 

wird, bis ein Grafikbefehl bearbeitet wurde. Die Prozessor-Einheit erhält somit die niedrigste 

Priorität. Sie führt Schreib- und Lesezugriffe in der Reihenfolge aus, in der sie anfallen. 

Für Schreibzugriffe des Hosts auf den Speicher wurde ein Schreib-Puffer implementiert, der es 

ermöglicht, daß der Datentransfer seitens des Hosts häufig schon abgeschlossen werden kann, ohne 

daß auf eine Freigabe des Speicherbusses gewartet werden muß. Das Schreiben der Daten aus dem 

Puffer in den Speicher ist dabei höher zu priorisieren als Lese-Zugriffe des Hosts, da anderenfalls 

Unstimmigkeiten bei Schreib- und Lese-Zugriffen auf die gleichen Daten auftreten könnten. 

Aus diesen Überlegungen ergibt sich die folgende Prioritätsverteilung: 

1) stark überfällige Refresh-Zyklen (theoretisch) 

2) Echtzeit-Reload-Zyklen 

3) sonstige Refresh-Zyklen 

4) sonstige Reload-Zyklen 

5) Schreiben von Host-Daten aus dem Schreib-Puffer 

6) Lese-Zugriffe des Hosts auf den Speicher 

7) Speicherzugriffe der Prozessor-Einheit 

Aus den Ausführungszeiten und den Prioritäten von Reload- und Refresh-Zyklen ergibt sich, daß 

Refresh-Zyklen unter normalen Umständen nie so lange verzögert werden, daß Punkt 1) eintritt. 

Um Datenverluste jedoch mit Sicherheit auszuschließen, wurden stark überfällige Refresh-Zyklen 

dennoch berücksichtigt.



Lukas Bauer 

3 Die Video-Timing-Einheit 

Diplomarbeit 


3.1 Aufgaben der Video-Timing-Einheit 

Abschnitt 3.1 

Seite 11 

Aufgabe der Video-Timing-Einheit ist es, für eine synchrone Bilddarstellung auf dem Monitor zu 

sorgen. Hierfür stehen die folgenden, ’0’-aktiven Signale zur Verfügung: 

• HSYNC, dessen fallende Flanke einen horizontalen Strahlrücklauf des Monitors einleitet, 

• VSYNC, dessen fallende Flanke einen vertikalen Strahlrücklauf einleitet, 

• CSYNC, das beide Sync-Informationen vereint und z. B. bei Fernsehbildern die HSYNCund 

VSYNC-Signale ersetzt, 

• und CBLANK, dessen inaktiver Bereich (CBLANK=’1’) den sichtbaren Bildbereich kennzeichnet. 

Außerdem werden interne Signale erzeugt, die das Laden der Schieberegister in den Video-RAMs 

steuern und so dafür sorgen, daß zur richtigen Zeit gültige Bilddaten ausgegeben werden (s. Abschnitt 

4). Die zeitliche Lage der Signale, aus der sich auch die Bildschirmauflösung ergibt, ist über 

Register programmierbar. Darüber hinaus kennt TIM zwei Synchronisations-Modi: 

• die interne Synchronisation, bei der TIM die oben genannten Signale selbst erzeugt, 

• und die externe Synchronisation, bei der mindestens eines der Sync-Signale als Eingang 

dient, so daß TIM die Bilddarstellung mit einer externen Signalquelle synchronisieren kann. 

So sind z. B. Einblendungen von Texten in externe Videobilder möglich. 

In beiden Synchronisations-Modi werden je zwei Video-Betriebsarten unterstützt: 

• der Vollbildbetrieb (Non-Interlaced Mode), bei dem mit jedem vertikalen Strahldurchlauf 

ein volles Videobild dargestellt wird, 

• und der Halbbildbetrieb (Interlaced Mode), bei dem nach dem Zeilensprung-Verfahren 

abwechselnd zwei Halbbilder aus den geraden bzw. den ungeraden Bildschirmzeilen aufgebaut 

werden, so daß sich die Vertikalfrequenz des Monitors bei gleichem Pixeltakt verdoppelt und 

das Bild scheinbar weniger flimmert. 

Des weiteren wurden zwei Spezialfunktionen realisiert: 

• Beim ZOOMing werden die Pixel aus dem Speicher vergrößert auf dem Monitor wiedergegeben. 

Höhe und Breite der Bildpunkte lassen sich getrennt voneinander um die Faktoren 

1, 2, 4, ... 128 vergrößern. Für die Vergrößerung in Y-Richtung werden dabei die Bildzeilen 

entsprechend häufig wiederholt; für das Zooming in X-Richtung wird der Ladetakt für 

die Schieberegister der VRAMs heruntergeteilt, so daß die Bilddaten langsamer ausgegeben 

werden (s. Abschnitt 4). 

• Beim PANning kann die Adresse, ab der die ersten Daten im Video-Speicher ausgegeben 

werden, frei programmiert werden. Dadurch ist es möglich, den Bildschirminhalt in X- und 

Y-Richtung zu verschieben, wenn der virtuelle Bildschirm (im Speicher) größer ist als der 

physikalische Bildschirm (auf dem Monitor).



Lukas Bauer 

3.2 Interne Synchronisation 

Diplomarbeit 


3.2.1 Vollbildbetrieb (Non-Interlaced Mode) 

Abschnitt 3.2 

Seite 12 

Bei interner Synchronisation im Vollbildbetrieb bestimmen TIM-interne Register auf einfache Weise 

den zeitlichen Verlauf der Synchronisations-Signale. 

Ein Horizontal-Zähler HCOUNT zählt dabei die steigenden Flanken des Videotaktes VClk und 

wird nach Erreichen des Registerwertes HTOTAL auf Null zurückgesetzt. 

Die horizontalen Sync- und Blanking-Signale werden von HCOUNT abgeleitet. So wird HSYNC 

beim Zählerüberlauf aktiv ’0’ und nach Erreichen von HESYNC wieder inaktiv ’1’. HBLANK, 

die Komponente des CBLANK-Signals, die das Bild während der horizontalen Strahlrücklaufphase 

dunkeltastet, wird nach HCOUNT=HSBLNK aktiv ’0’ und nach HCOUNT=HEBLNK inaktiv ’1’. 

Ein Vertikal-Zähler VCOUNT wird mit jedem Überlauf von HCOUNT erhöht und nach Erreichen 

des Registerwertes VTOTAL auf Null zurückgesetzt. Aus VCOUNT leiten sich die vertikalen 

Signale VSYNC und VBLANK in entsprechender Weise ab, nur die Bedingung für das Ende des 

VSYNC-Pulses ist VCOUNT=VESYNC/2 und nicht VCOUNT=VESYNC. 

HCOUNT, VCOUNT Abbildung 2: Der Horizontalzähler HBLANK, VBLANK, CBLANK 

0 

HCOUNT repräsentiert die aktuelle 

VCOUNT= 1 

Bildschirmspalte, der Vertikalzähler 

2 

VCOUNT die Zeile. HCOUNT zählt 

✛ HBLANK=’1’ ✲ 

3 

mit jeder VClk-Flanke und wird nach 

4 

5 

HCOUNT=HTOTAL auf 0 zurück- 

✻ 

6 

gesetzt. In diesem Augenblick wird 

7 

VCOUNT erhöht. 

8 

VBLANK 

9 

CBLANK=’1’ 

=’1’ 

10 

Abbildung 3: Der sichtbare 

11 

12 

Bildschirmbereich ergibt sich aus ❄ 

13 

HBLANK=VBLANK=’1’. Beginn 

14 

und Ende beider Blanking-Signale 

non-interlaced 

sind über Register programmierbar. 


HCOUNT= 

0 1 2 3 4 5 6 9 10 11 12 13 14 15 

Register Funktion 

Beispiel 

Abb. 2-7 

HTOTAL = (Anzahl der VClk-Zyklen pro Zeile) – 1 15 

HEBLNK = (Anzahl der VClk-Zyklen vom Start des HSYNC-Pulses bis zum Ende 

des HBLANK-Pulses) – 1 

3 

HSBLNK = (Anzahl der VClk-Zyklen vom Start des HSYNC-Pulses bis zum Start 


13 

HESYNC = (Länge des HSYNC-Pulses in VClk-Zyklen) – 1 1 

HESERR = (Länge der Serrations-Pulse des CSYNC-Signals in VClk-Zyklen) – 1 13 

VTOTAL = (Anzahl der Zeilen pro Vollbild) – 1 14 

VEBLNK = (Anzahl der Zeilen vom Start des VSYNC-Pulses bis zum Ende des 

VBLANK-Pulses) – 1 

4 

HSBLNK = (Anzahl der Zeilen vom Start des VSYNC-Pulses bis zum Start des 


12 

VESYNC = (2 · Länge des VSYNC-Pulses in Zeilen) – 1 5 

Tabelle 1: Register zur Programmierung der Video-Signale im Vollbildbetrieb 

Das CBLANK-Signal ist die logische ODER-Verknüpfung und somit die physikalische UND- 

Verknüpfung von HBLANK und VBLANK (s. Abb. 3).



Lukas Bauer 

Diplomarbeit 


Abschnitt 3.2 

Seite 13 

Das CSYNC-Signal (Abb. 5) ist die meiste Zeit mit HSYNC identisch; nur in der Phase, in 

der VSYNC=’0’ ist (Serrationsphase), werden Serrationspulse ausgegeben, die länger als die Synchronisationspulse 

sind. Im Monitor leiten die steigenden Flanken von CSYNC einen horizontalen 

Strahlrücklauf ein, während das vertikale Synchronsignal über einen Tiefpaß aus CSYNC gewonnen 

wird. 

HSYNC, VSYNC 

VSYNC=’0’ 

❅ 

❅VSYNC=’0’, HSYNC=’0’ 

Abbildung 4: Die ’0’-aktiven Signale 

HSYNC und VSYNC beginnen 

am Zeilen- bzw. Vollbildanfang. 

Der HSYNC-Puls endet, nachdem 

HCOUNT den Wert HESYNC erreicht 

hat, während der VSYNC-Puls nach 

VCOUNT=VESYNC/2 endet. 

CSYNC 

0 0 0 0 0 0 0 0 0 0 0 0 0 0 

0 0 0 0 0 0 0 0 0 0 0 0 0 0 

0 0 0 0 0 0 0 0 0 0 0 0 0 0 

0 0 

HSYNC=’0’ 


Abbildung 5: Das CSYNC-Signal vereint 

die Informationen von HSYNC 

und VSYNC in einem Signal. In der 

Phase des vertikalen Strahlrücklaufs 

werden Serrationspulse erzeugt, deren 

Länge über das HESERR-Register 

programmiert werden kann. 

0 0 

0 0 

0 0 

0 0 

0 0 

0 0 

0 0 

0 0 

0 0 

0 0 

0 0 


Dafür, daß im sichtbaren Bildschirmbereich gültige Daten aus dem Video-Speicher angezeigt werden, 

sorgt die Reload-Einheit (Abschnitt 4). Da die dabei nötigen VRAM-Zugriffe Zeit benötigen, 

muß die Video-Timing-Einheit schon am Ende der jeweils vorigen Bildschirmzeile ein Signal an die 

Reload-Einheit senden, daß für die folgende Zeile Daten bereitgestellt werden sollen. Außerdem 

muß ihr mitgeteilt werden, welche Zeile ausgegeben werden soll und mit welcher Wort-Adresse im 

Speicher die Zeilendaten beginnen. Hierzu werden in Registern (vgl. Tabelle 16, S. 67) die Wortadresse 

DPYSTRT des ersten Pixels auf dem Bildschirm und die Länge DPYINC einer logischen 

Bildschirmzeile programmiert. 

Die Video-Timing-Einheit setzt zur Steuerung der Reload-Einheit das Register DPYNEXT immer 

auf die Startadresse der kommenden Bildschirmzeile, so daß sich ein Verlauf ähnlich Abbildung 7 

ergibt, nur daß DPYNEXT die Wort-Adressen und nicht die Zeilennummern enthält. In dem 

Augenblick, in dem DPYNEXT seinen Wert ändert, wird außerdem kurzzeitig das interne Signal 

RELOAD gesetzt, um der Reload-Einheit zu signalisieren, daß die Schieberegister geladen werden 

müssen. 

Ist Zooming in Y-Richtung aktiv, so wird mehrfach die gleiche Zeile ausgegeben. In diesem Fall 

wird RELOAD auch dann aktiv, wenn die nächste Zeile eine Wiederholung der vorangegangenen 

ist, damit die VRAMs noch einmal auf den Start der Daten der zu wiederholenden Zeile gesetzt 

werden können. 

IPHASE 

Abbildung 6: Im Vollbildbetrieb gibt 

es nur zwei Videophasen. 

VLINE 

Serration ”000” 

VLINE=0xFFFF 

Bild ”111” 


Abbildung 7: Die Variable VLINE 

gibt die gerade angezeigte physikalische 

Bildschirmzeile an. Damit Reloads 

rechtzeitig möglich sind, wechselt 

VLINE bereits am Ende der letzten 

Videozeile. Im Zoom-Modus wird 

die gleiche Zeile bis zu 128 mal wiederholt. 

0 

1 

2 

3 

4 

5 

6 

7 


0 

1 

2 

3 

4 

5 

6 

7



Lukas Bauer 

Diplomarbeit 


3.2.2 Halbbildbetrieb (Interlaced Mode), NTSC 

Abschnitt 3.2 

Seite 14 

Im Interlaced Mode (Registerbit ILE=’1’) werden abwechselnd zwei Halbbilder erzeugt, die nur aus 

den geraden bzw. den ungeraden Bildschirmzeilen bestehen. Sie überlagern sich gemäß Abbildung 8 

zu einem Vollbild. Im Speicher stehen die Zeilen dabei hintereinander; bei der Ausgabe wird jede 

zweite Zeile übersprungen. 

ungerade Zeilen gerade Zeilen Überlagerung 

❳ ❳❳❳❳ 

❳ ❳❳ 

❳❳❳❳ 

❳❳❳❳ 1 ❳ 

❳❳ 

❳ 

❳❳❳ ❳❳❳ 

❳ ❳❳❳ 

❳❳❳❳ ❳ 

❳❳ 

❳❳❳❳ 3 ❳ ❳ 

❳❳❳❳ ❳❳ 

❳ ❳❳❳ ❳❳❳❳ ❳ 

❳❳ 

❳❳❳❳ 5 

❳ 

❳❳❳❳ ❳❳ 

❳ ❳ 

❳❳❳ 7 

❳❳ 

❳ ❳❳❳❳❳ 

❳ ❳❳ 

❳ 

❳❳❳❳ 

❳❳ 

0 

❳❳❳ 

❳❳ ❳❳❳ 2 ❳❳❳ 

❳ ❳❳❳ 

❳❳❳❳ ❳ 

❳❳ 

❳❳❳❳ ❳ ❳ 

❳❳❳❳ 4 ❳❳ 

❳ ❳❳❳ ❳❳❳❳ ❳ 

❳❳ 

❳❳❳❳ ❳ 

❳❳❳❳ 6 ❳❳ 

❳❳❳❳ ❳ 

❳ 

❳ ❳❳❳❳ ❳ ❳❳❳❳❳ 

❳ ❳❳ 

❳❳❳❳ 0 

❳❳❳❳ 1 ❳ 

❳❳ 

❳ 

❳❳❳ 2 ❳❳❳ 

❳ ❳❳❳ 

❳❳❳❳ ❳ 

❳❳ 

❳❳❳❳ 3 ❳ ❳ 

❳❳❳❳ 4 ❳❳ 

❳ ❳❳❳ ❳❳❳❳ ❳ 

❳❳ 

❳❳❳❳ 5 

❳ 

❳❳❳❳ 6 ❳❳ 

❳ ❳❳❳ 7 ❳❳❳❳ ❳ 

❳❳ ❳ 

Abbildung 8: Im Halbbildbetrieb überlagern sich zwei Halbbilder aus geraden bzw. ungeraden Bildschirmzeilen zu 

einem Vollbild. 

Abbildung 9: Im Speicher stehen gerade 

und ungerade Bildschirmzeilen gemischt 

hintereinander, auf dem Monitor werden 

sie auf zwei Halbbilder aufgeteilt. Die 

Halbbilder bestehen aus einer nicht ganzzahligen 

Anzahl von Zeilen. 

VLINE=0xFFFF 

1 

3 

5 

7 

interlaced NTSC odd filed 

1 

3 

5 

7 

VLINE 

VLINE=0xFFFF 

0 

2 

4 

6 

interlaced NTSC even field 

Der Horizontalzähler HCOUNT verhält sich im Halbbildbetrieb genau wie im Vollbildbetrieb. 

Ebenso ist das Verhalten von HSYNC und HBLANK identisch. 

Abbildung 10: Damit Halbbild-, Signalund 

Phasenwechsel auch in der Zeilenmitte 

möglich sind, wird der Zeilenzähler 

VCOUNT zum Teil auch in der Zeilenmitte 

erhöht. Ein direkter Zusammenhang 

zwischen VTOTAL und der Anzahl 

der Zeilen pro Halbbild besteht im Halbbildbetrieb 

nicht mehr. 

VCOUNT 

0 

2 

4 

6 

8 

10 

17 

19 

21 

23 

12 

13 

14 

15 

16 

1 

3 

5 

7 

9 

11 

18 

20 

22 

1 

3 

5 

7 

9 

13 

18 

20 

22 

11 

12 

15 

16 

17 

0 

2 

4 

6 

8 

10 

14 

19 

21 

23 

interlaced NTSC odd filed interlaced NTSC even field 

Ein Unterschied besteht beim Vertikalzähler VCOUNT. Da im Halbbildbetrieb ein Vollbild eine 

ungerade Zeilenanzahl hat und somit während einer Vertikalperiode (Halbbild) eine nicht ganzzahlige 

Anzahl von Zeilen ausgegeben wird, kann VCOUNT keine ganzen Videozeilen zählen. Der 

0 

2 

4 

6



Lukas Bauer 

Diplomarbeit 


Abschnitt 3.2 

Seite 15 

Vertikalzähler wurde daher beim TI-34020 so beschaltet, daß er in manchen Phasen des vertikalen 

Timings zweimal pro Zeile erhöht wird, was in Abbildung 10 zu sehen ist. Aus Kompatibilitätsgründen 

wurde das Verhalten des Zählers exakt vom TI-34020 übernommen. 

Auch VBLANK (vgl. Abb. 11) zeigt ein ungewöhnliches Verhalten. Die erste angezeigte Bildschirmzeile 

(Zeile 0 im geraden Halbbild) beginnt erst in der horizontalen Bildschirmmitte (hier 

wird VBLANK inaktiv ’1’), und die letzte Zeile des ungeraden Halbbildes endet in der Bildmitte 

(VBLANK wird aktiv ’0’). Aus Abbildung 8 wird jedoch deutlich, daß der sichtbare Bildschirmbereich 

aufgrund der Schräglage der Zeilen anderenfalls schief wirken würde. 

Abbildung 11: Die erste und letzte Zeile 

stehen komplett im Speicher, durch Blanking 

werden sie jedoch nur zur Hälfte angezeigt. 

Das VBLANK-Signal wechselt 

dabei in der Mitte einer Bildschirmzeile 

seinen Zustand. 

✻ 

VBLANK 

=’1’ 

❄ 

✛ ✲ 

HBLANK=’1’ 



CBLANK 

✻ 

VBLANK 

=’1’ 

❄ 

✛ ✲ 

HBLANK=’1’ 



Die Länge des VSYNC-Pulses entspricht bei NTSC einem ganzzahligen Vielfachen der Zeilenlänge, 

jedoch liegen sein Start- und Endpunkt je nach Halbbild abwechselnd in den Zeilenmitten und an 

den Zeilenanfängen. 

Das CSYNC-Signal schließlich macht im Halbbildbetrieb eine Aufteilung einer Vertikalperiode in 

mehrere Phasen nötig. In der Bildphase (vgl. Abb. 12 und 13) ist CSYNC mit HSYNC identisch. 

In der Serrationsphase werden auf CSYNC längere Serrationspulse ausgegeben, die bei richtiger 

Programmierung des HESERR-Registers so lange inaktiv ’1’ sind, wie HSYNC aktiv ’0’ ist. Sie 

werden zweimal pro Zeile ausgegeben, damit sichergestellt ist, daß bei beiden Halbbildern fallende 

Flanken von CSYNC am Zeilenanfang auftreten, die einen horizontalen Strahlrücklauf einleiten 

können. In den Equalisationsphasen schließlich werden zweimal pro Zeile Equalisationspulse erzeugt, 

die die halbe Länge der HSYNC-Pulse haben. Da der Monitor die VSYNC-Information 

aus dem CSYNC-Signal über einen Tiefpaß extrahiert, verbessert die Verkürzung der Pulse die 

Flankensteilheit des gewonnenen VSYNC-Signals. 

Abbildung 12: Im Halbbildbetrieb gibt 

es fünf Phasen vertikalen Timings. Die 

Serrations- und Bildphase sind bereits 

vom Vollbildbetrieb her bekannt. Die 

Länge der Serrationsphase entspricht bei 

NTSC einem ganzzahligen Vielfachen der 

Zeilenlänge. Neu sind die Equalisationsphasen, 

die gleich lang sind. 

Serration ”000” 

Equalis. II ”011” 

Bild I ”110” 

Bild II 

Equalis. I 

”111” 

”010” 


IPHASE 

Serration 

Equalis. II 

Bild I 

Bild II 

”000” 

”011” 

”110” 

”111” 

Equalis. I ”010” 

interlaced NTSC even field



Lukas Bauer 

Abbildung 13: In der Bildphase ist 

CSYNC mit HSYNC identisch. In der 

Serrationsphase, der Phase des vertikalen 

Strahlrücklaufs, werden pro Zeile 

zwei längere Serrationspulse ausgegeben, 

aus denen der Monitor die VSYNC- 

Information extrahiert. In den Equalisationsbereichen 

werden Pulse am Beginn 

und in der Mitte der Zeilen erzeugt, die 

die halbe Länge der HSYNC-Pulse haben. 


Diplomarbeit 


0 

0 

0 

0 

0 

0 

0 

0 

0 

0 0 

0 0 

0 0 

0 0 

0 0 

0 0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 


0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

CSYNC 

0 

0 

0 

0 

0 0 

0 0 

0 0 

0 0 

0 0 

0 

0 

0 

00 

0 0 0 0 0 

0 0 0 0 0 

0 0 0 0 0 

0 

0 

0 

0 

0 

0 

0 

0 

Abschnitt 3.2 

Seite 16 


0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

0 

Beispiel 

Abb. 9-10 




3 



13 



VTOTAL = ((Anzahl der Zeilen pro Vollbild) – 1)/2 

+ (Anzahl der Zeilen in der Serrationsphase (vertikale Sync-Phase)) 

+ (Anzahl der Halbzeilen pro Equalisationsphase) 



+ (Anzahl der Zeilen in der Serrationsphase) 

+ (Anzahl der Zeilen pro Equalisationsphase) 

HSBLNK = VTOTAL – Anzahl der Halbzeilen pro Equalisationsphase 17 

VESYNC = (2 · Länge des VSYNC-Pulses in Halbzeilen) – 1 11 

Tabelle 2: Register zur Programmierung der Video-Signale im Halbbildbetrieb (NTSC) 

3.2.3 Halbbildbetrieb (Interlaced Mode), PAL 

Die PAL-Norm unterscheidet sich von der NTSC-Norm vor allem darin, daß die Länge der vertikalen 

Strahlrücklaufphase (Serrationsphase) kein ganzzahliges Vielfaches der Zeilenlänge ist, sondern ein 

ungeradzahliges Vielfaches der Halbzeilenlänge. 

Dies führt dazu, daß bei PAL-Signalen die geradzahligen Halbbilder mit einem Zeilenwechsel beginnen, 

während sie bei NTSC in der Zeilenmitte anfangen (vgl. Abb. 14). 

Abbildung 14: Bei der PAL-Norm beginnen 

die geradzahligen Halbbilder mit 

einem Zeilenwechsel. 

VLINE=0xFFFF 

1 

3 

5 

7 

interlaced PAL odd field 

1 

3 

5 

7 

VLINE 

0 

2 

4 

6 

23 

13 

VLINE=0xFFFF 

interlaced PAL even filed 

0 

2 

4 

6



Lukas Bauer 

Abbildung 15: Die Länge der Serrationsphase 

ist bei PAL ein ungeradzahliges 

Vielfaches der Halbzeilenlänge. 

Diplomarbeit 


Serration 

Equalis. II 

Bild I 

Bild II 

Equalis. I 

”000” 

”011” 

”110” 

”111” 

”010” 


IPHASE 

Serration 

Equalis. II 

Bild I 

Bild II 

Equalis. I 

Abschnitt 3.3 

Seite 17 

”000” 

”011” 

”110” 

”111” 

”010” 


Außerdem ist das Verhalten des Vertikalzählers VCOUNT, das vom TI-34020 übernommen wurde, 

beim Übergang von der Equalisationsphase II zur Bildphase I etwas ungewöhnlich (vgl. Abb. 16). 

Im Gegensatz zu NTSC-Bildern wird VCOUNT hier nicht erhöht. Daher ist auch die Berechnung 

des Registerwertes VTOTAL gemäß Tabelle 3 anders durchzuführen als bei NTSC. 

Abbildung 16: Werden Signale nach der 

PAL-Norm erzeugt, so wird VCOUNT 

beim Übergang von der Equalisationsphase 

II zur Bildphase I nicht erhöht. 


VCOUNT 

1 

3 

5 

7 

16 

18 

20 

9 

10 

11 

12 

13 

14 

15 

0 

2 

4 

6 

8 

17 

19 

21 

0 

2 

4 

6 

8 

12 

17 

19 

21 

10 

11 

14 

15 

16 

1 

3 

5 

7 

9 

13 

18 

20 



Beispiel 

Abb. 14-16 




3 



13 



VTOTAL = (Anzahl der Zeilen pro Vollbild)/2 – 1 

+ (Anzahl der Zeilen in der Serrationsphase (vertikale Sync-Phase)) 

+ (Anzahl der Halbzeilen pro Equalisationsphase) 


VBLANK-Pulses) – 3/2 

+ (Anzahl der Zeilen in der Serrationsphase) 

+ (Anzahl der Zeilen pro Equalisationsphase) 

HSBLNK = VTOTAL – Anzahl der Halbzeilen pro Equalisationsphase 16 

VESYNC = (2 · Länge des VSYNC-Pulses in Halbzeilen) – 1 9 

Tabelle 3: Register zur Programmierung der Video-Signale im Halbbildbetrieb (PAL) 

3.3 Externe Synchronisation 

Neben der internen Synchronisation, bei der alle Synchronisationssignale von TIM erzeugt werden, 

gibt es gemäß Tabelle 4 drei Modi der externen Synchronisation, in denen TIM das Videobild 

21 

12



Lukas Bauer 

Diplomarbeit 


Abschnitt 3.3 

Seite 18 

synchron zu einem externen Videosignal aufbaut und so das Überlagern und Einblenden von Bildern 

ermöglicht. 

Über die Registerbits VSD, HSD und CSD kann dabei für jedes der Synchronisationssignale 

VSYNC, HSYNC und CSYNC getrennt festgelegt werden, ob es als Ausgang oder als Eingang 

fungieren soll. Da nicht jede Kombination sinnvoll ist, werden unter bestimmten Bedingungen 

redundante Signale ignoriert. Tabelle 5 gibt hierüber Auskunft. 

Wichtig ist, daß im externen Synchronisationsmodus auch die Timing-Register entsprechend 

dem externen Video-Signal programmiert werden. 

Modus 

0 1 

Bedingung(en) 

Sync Direction 

( 0 = Eingang ) 

Interl. 

Enable Beschreibung 

VSD HSD CSD ILE 

1 

0 

1 

0 

1 

1 

1 

1 

X 

X 

1 

VSYNC, HSYNC und CSYNC sind Ausgänge: 

Alle Synchronisationssignale werden intern von TIM erzeugt. 

1 0 1 1 0 VSYNC ist Eingang: 

Eine fallende Flanke an VSYNC lädt den Vertikalzähler; die horizontale 

Synchronisation erfolgt nur über den Videotakt und die Einstellung im 

HTOTAL-Register. 

CSYNC und HSYNC werden als Ausgangssignale erzeugt. 

2 0 

0 

3 1 

1 

0 

0 

0 

1 

0 

1 

1 

0 

0 

0 

0 

X 

X 

X 

X 

X 

HSYNC und VSYNC sind Eingänge: 

Eine fallende Flanke an HSYNC lädt den Horizontalzähler, eine fallende 

Flanke an VSYNC den Vertikalzähler. 

CSYNC wird als Ausgangssignal erzeugt. 

CSYNC ist Eingang: 

Eine fallende Flanke an CSYNC lädt den Horizontalzähler (im Halbbildbetrieb 

aber nicht, wenn sie in der Zeilenmitte auftritt); die VSYNC- 

Information wird ebenfalls aus dem CSYNC-Signal gewonnen, wobei ein 

’0’-Puls erkannt wird, dessen Länge um mindestens zwei Zyklen des Videotaktes 

länger ist als der interne HSYNC-Puls. 

HSYNC und VSYNC werden als Ausgangssignale erzeugt. 

Tabelle 4: Neben der internen Synchronisation kennt TIM drei Modi der externen Synchronisation. 

Sync Direction Interlaced Enable 

( 0 = Eingang ) ILE=’0’ ILE=’1’ 

VSD HSD CSD ( Vollbildbetrieb ) ( Halbbildbetrieb ) 

0 0 0 wie Modus 2; Signal an CSYNC ist redundant und wird ignoriert 

0 0 1 Modus 2 

0 1 0 wie Modus 3; Signal an VSYNC ist redundant und wird ignoriert 

0 1 1 

Modus 1 

wie Modus 0, da aus VSYNC allein nicht erkannt 

werden kann, welches Halbbild dargestellt 

werden muß 

1 0 0 wie Modus 3; Signal an HSYNC ist redundant und wird ignoriert 

1 0 1 wie Modus 0; Signal an HSYNC wird ignoriert, da es keine vertikale Synchronisation erlaubt 

1 1 0 Modus 3 

1 1 1 Modus 0 

Tabelle 5: In manchen, eigentlich nicht sinnvollen Konfigurationen werden redundante oder zur Synchronisation nicht 

ausreichende Signale an Sync-Eingängen ignoriert.



Lukas Bauer 

3.4 Realisierung in Speedchart-VHDL 

Diplomarbeit 


Abschnitt 3.4 

Seite 19 

Im Speedchart-Design besteht die Video-Timing-Einheit aus drei Diagrammen. Das Diagramm 

S HCNT steuert das Horizontaltiming, das Diagramm S VCNT das Vertikaltiming. Das Diagramm 

CSYNC ist nur im externen Synchronisationsmodus wichtig, um aus einem externen 

CSYNC-Signal die VSYNC-Information zu extrahieren. 

3.4.1 Steuerung des horizontalen Timings 

Das Diagramm S HCNT (Seite 82) steuert das Horizontaltiming, also den Zähler HCOUNT, die 

Signale HSYNC, CSYNC und HBLANK, das DPYNEXT-Register, sowie die Reload-Anforderung. 

Bei interner Synchronisation sind neben den Initialisierungen durch Transition T1 nur die Aktionen 

von Transition T2 wichtig. Da es den Rahmen der Arbeit sprengen würde, jede VHDL-Zeile 

einzeln zu erklären, soll hier ein Beispiel die Struktur verdeutlichen. Das folgende VHDL-Listing 

ist vereinfacht in T2 enthalten und steuert den Zähler HCOUNT sowie die Signale HSYNC und 

HBLANK. Es kann als selbsterklärend gelten: 

if HCOUNT=HTOTAL then 

HCOUNT:=0; -- reset counter 

HSYNC out:=’0’; -- start HSYNC 

else 

HCOUNT:=HCOUNT+1; -- count up 

end if; 

if HCOUNT=HESYNC then 

HSYNC out:=’1’; -- end HSYNC 

end if; 

if HCOUNT=HSBLNK then 

HBLANK:=’0’; -- start HBLANK 

elsif HCOUNT=HEBLNK then 

HBLANK:=’1’; -- end HBLANK 

end if; 

Zu beachten ist, daß die Aktionen bei einem synchronen Schaltwerk jeweils mit der nächsten steigenden 

Flanke des Video-Taktes VClk ausgeführt werden. So behält z. B. HCOUNT den Wert 

VTOTAL für eine Taktperiode bei, bevor HCOUNT auf 0 gesetzt wird. 

Um einen beschleunigten Test des Chips zu ermöglichen, wurde das Register-Bit TEST eingeführt. 

Ist es aktiv ’1’, so zählen die obere und untere Hälfte der 16-Bit-Zähler HCOUNT und VCOUNT 

als unabhängige 8-Bit-Zähler. 

Das CSYNC out-Signal wird am Zeilenanfang (nach HCOUNT=HTOTAL) und beim Halbbildbetrieb 

in bestimmten Phasen auch in der Zeilenmitte (nach HCOUNT=HTOTAL/2) auf aktiv ’0’ gesetzt. 

Über der Vektor IPHASE, dessen Verlauf bereits in Abbildung 6, 12 und 15 dargestellt wurde, 

gibt der Vertikal-Steuerprozeß die Information über die aktuelle Video-Phase an den Horizontal- 

Steuerprozeß im Diagramm S HCNT weiter. Nach IPHASE richtet sich dabei auch die Länge 

der auf CSYNC out ausgegebenen Pulse. In der Serrationsphase z. B. endet der Puls, nachdem 

HCOUNT den Wert HESERR (bzw. den Wert ((HTOTAL–1)/2 + HESERR) für den Puls in der 

zweiten Zeilenhälfte) erreicht hat. 

Im Simulationsergebnis auf Seite 102 sind die im Vollbildbetrieb erzeugten Signale dargestellt. Man 

erkennt, daß HSYNC out streng periodisch ist, während auf CSYNC out in der Serrationsphase 

(IPHASE=0) längere Pulse erzeugt werden.



Lukas Bauer 

Diplomarbeit 


Abschnitt 3.4 

Seite 20 

Auf Abbildung 70 (S. 103) ist ein Simulationsergebnis für den Halbbildbetrieb zu sehen. In den 

Serrationsphasen (IPHASE=2 und IPHASE=3) werden an CSYNC out kurze Equalisationspulse 

generiert. 

Das DPYNEXT-Register (vgl. Tabelle 16, S. 67), das die Adresse des ersten Pixels der nächsten 

auszugebenden Zeile enthält, wird ebenfalls von S HCNT kontrolliert. Es ändert sich analog 

zu den Abbildungen 7, 9 und 14 mit dem Beginn der horizontalen Blank-Periode (nach 

HCOUNT=HSBLNK). 

Im Vollbildbetrieb und für gerade Halbbilder wird DPYNEXT auf den Wert von DPYSTRT initialisiert, 

wenn das Ende der vertikalen Blank-Periode bevorsteht. Für ungerade Halbbilder wird 

DPYNEXT zu diesem Zeitpunkt mit (DPYSTRT+DPYINC) geladen, da das Halbbild mit Zeile 

1 beginnt. Falls jedoch Zooming in Y-Richtung aktiv ist, wird auch bei ungeraden Halbbildern 

DPYNEXT=DPYSTRT gesetzt, da dann Zeile 0 in der ersten Zeile beider Halbbilder ausgegeben 

wird. Gleichzeitig mit DPYNEXT wird die Variable VLINE auf 0 bzw. auf 1 gesetzt, und 

RELAREA wird ’1’, was die Bildregion kennzeichnet, in der Reloads durchgeführt werden (noch 

immer T2 im Diagramm S HCNT, Seite 82). 

Beim normalen Vollbild wird DPYNEXT mit jedem Zeilenwechsel um den Wert DPYINC erhöht. 

Bei Halbbildern wird 2·DPYINC hinzugezählt, da jede zweite Zeile übersprungen wird. Ist Zooming 

in Y-Richtung aktiv, so sorgt der Zähler YZOOMCNT dafür, daß jede Zeile bis zu 128 mal 

wiederholt wird und sich DPYNEXT in dieser Zeit nicht ändert. YZOOMCNT wird auf den Wert 

YZOOMST (im Halbbildbetrieb YZOOMST/2) initialisiert, der im Diagramm S VCNT (S. 83 asynchron 

aus dem Zoom-Faktor YZ berechnet wird. Nur bei einem Zählerüberlauf von YZOOMCNT 

wird DPYNEXT um DPYINC erhöht. 

Am Beginn der vertikalen Blank-Periode wird VLINE auf 0xFFFF und RELAREA auf ’0’ gesetzt, 

da keine Reloads mehr nötig sind. 

Schließlich werden noch die Signale RELAT10 und RELAT6 erzeugt, die kennzeichnen, daß ein 

Reload am Ende einer Bildzeile bevorsteht. Gesetzt werden die Signale 10 bzw. 6 VClk-Zyklen vor 

Beginn des Reloads. Dies ist für die Arbitrierungslogik (s. Abschnitt 4.5.5) notwendig. 

Bei externer Synchronisation ist nicht die Bedingung HCOUNT=HTOTAL, sondern ein externer 

Sync-Puls Auslöser für einen Zeilenwechsel. Hierbei werden die Transitionen T3 und T4 

wichtig. Das asynchron erzeugte Signal HS Wait ist aktiv ’1’, wenn die horizontale Synchronisation 

durch ein externes Signal erfolgen soll. Das Signal HS Coming wird kurzzeitig aktiv ’1’, wenn ein 

gültiges externes Sync-Signal kommt, wobei dies je nach Modus ein Signal an CSYNC oder VSYNC 

sein kann. 

Ein gültiges Sync-Signal setzt sofort HCOUNT=SETHCNT und leitet damit die neue Zeile ein. 

Kommt am Zeilenende kein Sync-Signal, so bleibt HCOUNT wegen Transition T4 auf dem Wert 

HTOTAL, bis die externe Synchronisation erfolgt. HCOUNT wird auf den Wert des Registers 

SETHCNT und nicht auf 0 gesetzt, damit leichte Verschiebungen zwischen externen und internen 

Signalen ausgeglichen werden können. 

Ist CSYNC Eingang, so werden nur die fallenden Flanken von CSYNC in am Zeilenanfang akzeptiert. 

CSYNC-Flanken in der Zeilenmitte setzen den Horizontalzähler nicht zurück. Möglich wird 

dies durch das Signal HS Enable, das erst zu Beginn der horizontalen Blank-Periode aktiv ’1’ und 

mit erfolgtem Zeilenwechsel wieder ’0’ wird. Es maskiert das CSYNC in-Signal. 

3.4.2 Steuerung des vertikalen Timings 

Das Diagramm S VCNT (Seite 83) steuert das Vertikaltiming, also VHOUNT, VSYNC und 

VBLANK, sowie im Halbbildbetrieb den Wechsel zwischen geraden und ungeraden Halbbildern 

und den Ablauf der Videophasen (Serration, Equalisation, Bildphase).



Lukas Bauer 

Diplomarbeit 


Abschnitt 3.4 

Seite 21 

Im Vollbildbetrieb ist der Zustand noninter aktiv, und das vertikale Timing entspricht im wesentlichen 

dem horizontalen. Auf eine Erklärung kann verzichtet werden. 

Im Halbbildbetrieb ist während der Anzeige eines geradzahligen Halbbildes der Zustand 

even field, sonst odd field aktiv. Im Vergleich mit dem Diagramm S HCNT des horizontalen 

Timings entsprechen hier die Transitionen T9 und T10 der Transition T2 dort; sie steuern 

die Erhöhung des Vertikalzählers und die damit zusammenhängenden Prozesse. So erfolgt hier die 

Steuerung des Signals für die Videophase IPHASE, von der nicht nur die Art der auf CSYNC out 

erzeugten Synchronpulse abhängt, sondern auch die Art und Weise, in der VCOUNT in der Zeilenmitte 

erhöht wird. Auch VBLANK wird hier erzeugt. 

Im Fall der internen Synchronisation übernehmen T5 und T6 die Funktion von T3 des horizontalen 

Timings; am Ende des Halbbildes (das auch in der Zeilenmitte auftreten kann) wird zum 

anderen Halbbild übergegangen, der Vertikalzähler zurückgesetzt und VSYNC out aktiviert. 

Bei externer Synchronisation darf der Vertikalzähler am Halbbildende erst zurückgesetzt werden, 

wenn ein gültiges externes Sync-Signal erkannt wird. T7 und T12 entsprechen hier T4; sie 

fangen die Erhöhung des Zählers ab. Das Rücksetzen des Zählers geschieht, wenn eines der Signale 

VS Coming oder CS Coming einen externen Sync-Puls anzeigt. Hierbei wird der Zustand 

next field (drop-through state) scheinbar aktiv; in Wirklichkeit erfolgt sofort wieder ein Wechsel 

in einen der Grundzustände. In der Regel wird beim Halbbildwechsel in den zuletzt inaktiven 

Zustand gewechselt; zum Beginn der externen Synchronisation muß aber das richtige Halbbild gefunden 

werden. Daher wird bei jedem Wechsel aus der Lage der externen Signale ermittelt, welches 

Halbbild das nächste ist. 

Falls VSYNC in Eingang ist, wird genau dann ein ungerades Halbbild begonnen (T11), wenn 

zum Zeitpunkt des VSYNC-Pulses HBLANK aktiv war (bei NTSC) bzw. inaktiv war (bei PAL). 

Anderenfalls wird ein gerades Halbbild begonnen (T13). Falls CSYNC in Eingang ist, ist die 

Entscheidung vom Signal Next odd abhängig, dessen Erzeugung im folgenden Abschnitt erläutert 

wird. 

Simulationsergebnisse sind auf Abbildung 69 (S. 102) für ein Vollbild mit sechs dargestellten 

Zeilen und auf Abbildung 70 (S. 103) für ein ungerades Halbbild mit vier dargestellten Zeilen zu 

sehen. 

Abbildung 71 (S. 104) zeigt die Synchronisation auf externe HSYNC- und VSYNC-Signale (Modus 

2) im Vollbildbetrieb. An den Horizontal- und Vertikalzählern ist zu erkennen, daß die Registerwerte 

HTOTAL und VTOTAL hier falsch programmiert wurden, daß die Synchronisation aber dennoch 

funktioniert. Die Zähler verbleiben einfach in ihren Endzuständen, bis das externe SYNC-Signal 

kommt. 

Im Halbbildbetrieb ist auf Abbildung 72 (S. 105) zu sehen, daß im externen Synchronisations- 

Modus 2 in das richtige Halbbild gewechselt wird. Der Puls an VSYNC in kommt hier am Zeilenanfang, 

gleichzeitig mit dem Puls an HSYNC in. Daher muß (bei NTSC) das ungerade Halbbild 

folgen. 

3.4.3 Steuerung der externen Synchronisation 

Das Diagramm CSYNC (Seite 84) ist nur im externen Synchronisationsmodus wichtig, um aus 

einem externen CSYNC-Signal die vertikale Sync-Information zu extrahieren. 

In diesem Modus werden Serrationspulse daran erkannt, daß ihre Länge um mindestens 2 VClk- 

Takte über der Länge der HSYNC-Pulse liegt, die im HESYNC-Register programmiert wurde.



Lukas Bauer 

Diplomarbeit 


Abschnitt 3.4 

Seite 22 

Wird, ausgehend vom Zustand wait sync, ein Puls auf CSYNC in erkannt, so wird in einen der 

Zustände CS nonint, CS midline oder CS newline gewechselt, je nachdem, ob Vollbildbetrieb aktiv 

ist oder ob im Halbbildbetrieb der Serrationspuls in der Zeilenmitte bzw. am Zeilenanfang auftrat. 

Falls der Puls in der Zeilenmitte begann (T4), wird im NTSC-Modus das Signal Next odd auf ’0’ 

gesetzt, denn es soll ein gerades Halbbild folgen. Im PAL-Modus folgt in diesem Fall ein ungerades 

Halbbild, und Next odd wird auf ’1’ gesetzt. Falls der Puls am Zeilenende auftrat, wird Next odd 

bei NTSC auf ’1’ und bei PAL auf ’0’ gesetzt. 

Endet der CSync-Puls schnell, so wird in den Grundzustand zurückgewechselt. Erfüllt seine Dauer 

aber die oben genannte Bedingung, so wird in einen der Zustände start nonint, start even oder 

start odd gewechselt, wobei das Signal CS Coming an das Diagramm S VCNT meldet, daß jetzt 

ein Voll- bzw. Halbbildwechsel ausgeführt werden muß. 

Damit das vertikale Synchronsignal CS Coming nicht bei jedem, sondern nur beim ersten Serrationspuls 

jedes Voll- oder Halbbildes erzeugt wird, wird nach Deaktivierung des Signals auf das 

Ende der Serrationsphase gewartet (T15). Nur in der Serrationsphase treten an CSYNC in Pulse 

auf, die die Zeitbedingung erfüllen. 

Ein Simulationsergebnis für die Synchronisation auf ein externes CSYNC-Signal ist auf Abbildung 

73 (S. 106) dargestellt. Die Gewinnung der VSYNC-Information aus CSYNC in funktioniert, 

weist aber systembedingt eine geringe Verzögerung auf, die sich nicht auf die Bilddarstellung auswirkt.



Lukas Bauer 

4 Die VRAM-Reload-Einheit 

Diplomarbeit 


4.1 Aufgaben der VRAM-Reload-Einheit 

Abschnitt 4.2 

Seite 23 

Aufgabe der VRAM-Relaod-Einheit ist es, den Monitor synchron zu den erzeugten oder extern 

eingespeisten Videosignalen mit einem kontinuierlichen Bilddatenstrom aus den Video-RAMs 

zu versorgen. 

Wie in Abbildung 17 zu sehen ist, werden diese Video-Daten direkt von den VRAMs ausgegeben. 

VRAMs enthalten neben der Speichermatrix ein Schieberegister (SR), das parallel mit den Daten 

einer Speicherzeile geladen werden kann (Reload). Über den seriellen Ausgang des SR’s gelangen 

die Video-Daten an die Video-D/A-Wandler. 

Host ✛ ✲ TIM 

Video-Takt 

(VClk) 

✻ 

✛ ✲ Daten 

relaod ✲ 

control 

Lade-Takt (MSC) 

VRAM 

❄ 

✻ 

✲ Video- 

Daten 

✲ Video- 

Signale 

Abbildung 17: Die Video-Daten für den D/A-Wandler kommen direkt aus den VRAMs. TIM steuert 

das Nachladen (Reload) der Schieberegister. 

Die VRAM-Reload-Einheit sorgt über Steuersignale dafür, daß im richtigen Augenblick die benötigten 

Daten in die SR geladen werden. Außerdem muß TIM am MSC-Eingang der VRAMs den Takt 

vorgeben, in dem die SR ihre Daten seriell ausgeben. Stimmen die Breite eines Video-Datenwortes 

und die Farbtiefe eines Pixels überein, so entspricht der Lade-Takt gerade dem Pixel-Takt. Ist die 

Farbtiefe geringer, so werden mit jedem Lade-Takt parallel die Farbwerte mehrerer Pixel ausgegeben. 

Im diesem Fall muß der Lade-Takt durch Teilung aus dem Video-Takt erzeugt werden, und 

ein externer Multiplexer muß die parallelen Pixeldaten nacheinander an die D/A-Wandler geben. 

4.2 Reload–Mechanismen 

4.2.1 ” Newline Reloads“ und ” Midline Reloads“ 

Ein Laden der SR mit neuen Daten ist zum einen rechtzeitig vor Beginn einer Videozeile 

nötig. Hierbei muß angegeben werden, welche Zeile aus der Speichermatrix ins SR geladen werden 

soll und ab welcher Position (TAP) im SR die serielle Ausgabe beginnen soll. Zeile und Position 

ergeben sich aus der Adresse des Pixels, mit dem die Zeile beginnt. Sicherheitshalber erfolgt dieser 

Reload bereits am Ende der vorigen Bildschirmzeile. Er wird im folgenden als ” Newline Reload“ 

bezeichnet. 

Bei hochauflösenden Bildschirmen, bei denen die Bildzeilen mehr Daten enthalten können als die 

Schieberegister der VRAMs, wird jedoch auch während der Darstellung einer Videozeile ein 

Nachladen der SR nötig, was in Abbildung 18 exemplarisch dargestellt ist. Ein solcher Reload wird 

im folgenden als ” Midline Reload“ bezeichnet. Exakt in dem Augenblick, in dem die Daten aus



Lukas Bauer 

Diplomarbeit 


Abschnitt 4.2 

Seite 24 

der letzten Position der SR ausgegeben werden, müssen die SR mit den Daten der nächsten Speicherzeile 

geladen werden. Der Reload-Zyklus muß dabei vor dem Datenwechsel beginnen, und der 

Zeitpunkt des Wechsels wird den VRAMs im Laufe des Zyklus über eine Steuerleitung signalisiert. 

Nur auf diese Weise ist ein kontinuierlicher Bilddatenstrom zu erreichen. Ohne die Fähigkeit zu 

Midline Reloads wäre die Länge einer Videozeile auf die Schieberegisterlänge beschränkt. 

Abbildung 18: Beispiel für eine Verteilung 

von VRAM-Relaods: Ein Laden des 

Schieberegisters wird z. B. durch 0080 

gekennzeichnet, hier ist 00 die RAM-Zeile 

und 80 der SR-Zeiger (TAP). 

Es ist Panning aktiv (DPYSTRT = 0), 

und die virtuelle Zeilenlänge DPYINC ist 

größer als die physikalische. 

DPYSTRT = 0x0080 Worte 

DPYINC = 0x0220 Worte 

phys. Zeilenläge = 0x0140 Worte 

SRL = 256 Worte 

SRE = ’0’ 

Zeile 0: 0080 0100 

ˆ 

0500 

ˆ 

0300 

ˆ 

0100 

Zeile 1: 02A0 0300 

Zeile 2: 04C0 0500 

4.2.2 ” Split Reloads“ und ” Non-Split Reloads“ 

Zeile 3: 06E0 0700 0800 

ˆ ˆ 

0700 0800 

Zeile 4: 0900 0A00 

0A00 

Zeile 5: 0B20 0C00 

Um das kritische Timing der Midline Reloads zu entschärfen, bieten moderne Video-RAMs die 

Möglichkeit, nur eine Hälfte des Schieberegisters zu laden. Aus der anderen Hälfte können 

dabei gleichzeitig Daten seriell ausgegeben werden. Dies zeigt, daß die VRAMs keine echten Schieberegister, 

sondern zählergesteuerte Multiplexer enthalten. Über das Register-Bit SRE kann programmiert 

werden, ob die angeschlossenen VRAMs solche ” Split Reloads“ unterstützen (SRE=’1’: 

Split-Reload-Modus). 

Auch im Split-Reload-Modus erfolgt für jede Videozeile ein Newline Reload am Ende der vorigen 

Videozeile. Beginnen die Daten dabei in der unteren Hälfte des SR’s (wie in Zeile 4 und 5 in 

Abbildung 19), so enthalten bereits beide SR-Hälften Daten, die in der folgenden Zeile benötigt 

werden. Beginnt die Ausgabe hingegen in der oberen SR-Hälfte, so kann bereits unmittelbar nach 

dem Newline Reload die untere SR-Hälfte mit Daten aus der nächsten VRAM-Zeile geladen werden 

(Zeile 0–3, Abb. 19). 

Abbildung 19: Beispiel für eine Verteilung 

von VRAM-Relaods im Split-Reload- 

Modus: Nur am Ende der jeweils vorigen 

Zeile wird das ganze SR geladen (Non- 

Split Reload). Beim Nachladen wird dann 

nur eine Hälfte geladen (Split Reload). 

Hier kennzeichnet z. B. 01L einen Split 

Reload. Dabei ist 01 die RAM-Zeile, und 

L (low) steht für ein Laden der unteren 

SR-Hälfte. 

DPYSTRT = 0x0080 Worte 

DPYINC = 0x0220 Worte 

phys. Zeilenläge = 0x0140 Worte 

SRL = 256 Worte 

SRE = ’1’ 

ˆ 

0C00 

Zeile 0: 0080 0100 0180 

01H 

Zeile 1: 02A0 0300 0380 

03H 

Zeile 2: 04C0 0500 0580 

05H 

Zeile 3: 06E0 0700 0780 0800 

07H 08L 

Zeile 4: 0900 0980 0A00 

0CL 

0AL 

Zeile 5: 0B20 0B80 0C00 

ˆ 

0080 

02A0 

04C0 

06E0 

0900 

0B20 

0080 01L 

02A0 03L 

04C0 05L 

06E0 07L 

0900 

0B20



Lukas Bauer 

Diplomarbeit 


Abschnitt 4.3 

Seite 25 

Während der Ausgabe jeder Videozeile erfolgen auch im Split-Reload-Modus Midline Reloads. 

Diese sind jedoch nicht mehr an einen exakten Zeitpunkt gebunden. So kann ein Nachladen der 

oberen SR-Hälfte (z. B. Zeile 2, Abb. 19) irgendwann während der Ausgabe der Daten aus der 

unteren SR-Hälfte erfolgen. Bei langen Zeilen müssen, wie in Zeile 3 schon ansatzweise zu erkennen 

ist, abwechselnd Split Midline Reloads der oberen und unteren SR-Hälfte durchgeführt werden. 

4.3 Taktsignale für Video-RAMs und Video-D/A-Wandler 

Neben den Reload-Zyklen, die immer bei Bedarf neue Daten in die SR laden und deren Timing 

im nächsten Abschnitt beschrieben wird, müssen innerhalb des Anzeigebereichs des Bildschirms 

permanent Taktsignale generiert werden, um die Daten aus den Video-RAMs zu takten und sie 

den Video-D/A-Wandlern zuzuführen. 

Im Gesamtsystem sind drei Taktsignale zur Steuerung des Datenstroms der Video-RAMs und der 

D/A-Wandler vorhanden: 

• VClk in ist der extern eingespeiste Video-Takt, aus dem alle Video-Timing-Signale abgeleitet 

werden. 

• LD out ist der Pixel-Takt, mit dem neue Daten an die Video-D/A-Wandler geleitet werden. 

Die Bit-Breite der Daten entspricht dabei der Farbtiefe PSIZE eines Pixels. 

Im Normalbetrieb ist der Pixel-Takt im Anzeigebereich (CBLANK=’1’) mit VClk in identisch; 

bei aktivem Zooming wird er aus VClk in mittels Teilung durch den Zoom-Faktor XZ 

gewonnen. Außerhalb des Anzeigebereichs (CBLANK=’0’) ist LD out nicht aktiv. Es gilt: 

fLD out = fVClk in · 

• MSC out ist der Datenwort-Takt, mit dem die Schieberegister der Video-RAMs neue 

Daten bereitstellen. Die Bit-Breite entspricht dabei der Speicherbusbreite MBW. Der Datenwort-Takt 

ergibt sich aus dem Video-Takt nach der Gleichung 

fMSC out = fVClk in · 

1 

XZ 

1 

XZ 

· PSIZE 

MBW . 

Ist die Speicherbusbreite MBW (z. B. 32 Bit) größer als die Farbtiefe PSIZE eines Pixels 

(z. B. 8 Bit), so werden mit einem MSC-Zyklus Daten zur Verfügung gestellt, die dann in mehreren 

LD-Zyklen an die Video-D/A-Wandler geleitet werden müssen. Im Beispiel muß der LD-Takt dem 

vierfachen MSC-Takt entsprechen, damit 4∗8 Bit an die D/A-Wandler geleitet werden können, 

bevor wieder 32 Datenbits aus den VRAMs kommen. 

Vor den D/A-Wandlern ist dabei eine programmierbare Einheit aus einem Zähler und einem Multiplexer 

notwendig, die für das gegebene Beispiel vereinfacht in Abbildung 20 wiedergegeben ist.



Lukas Bauer 

VRAM 

❄ 

MSC 

CBLANK 

LD 

✻ 

Diplomarbeit 


✄ 

✂✁ 

MBW 

✲ 

✲ 

✲ 

✲ 

✲ 

✲ 

✲ 

✲ 

✲ 

Reset 

Multiplexer 

✏ 

✏ 

Q 2 

✲ 

✲ 

✻ ✻ 

Zähler 

∧ 

 

✏ ✲ Register ✲ 

Q 1 

∧ 

PSIZE 

D/A-Wandler 

✏ 

D 

✏✏✏ A 

✏ 

D 

✏✏✏ A 

✏ 

D 

✏✏✏ A 

Abschnitt 4.4 

Seite 26 

Abbildung 20: Eine externe Einheit aus Zähler und Multiplexer muß aktiv werden, wenn Farbtiefe und Speicherbusbreite 

nicht übereinstimmen (hier: MBW = 32 Bit, PSIZE = 8 Bit). 

Die Funktionsweise der Einheit dürfte allgemein verständlich sein. Aufgrund der Tatsache, daß 

die Daten aus den VRAMs erst mit einer geringen Verzögerung nach der steigenden Flanke von 

MSC out bereitstehen, muß die erste Flanke an MSC out bereits vor Beginn des Anzeigebereichs 

kommen. Die erste Flanke an LD out kommt mit Beginn des Anzeigebereichs, also wenn das 

CBLANK-Signal inaktiv ’1’ wird. Während des Anzeigebereichs eilt MSC out gegenüber LD out 

um eine VClk-Periode vor. 

Die Zählereinheit muß programmierbar sein; so müssen sich z. B. die Werte von PSIZE und MBW 

einstellen lassen. Am Institut für Mikroelektronik der TU Berlin ist bereits eine integrierte Schaltung 

( ” Muxer“) entwickelt worden, die sogar in der Lage ist, mittels einer PLL die Pixelfrequenz zu 

vervierfachen. Durch weitere Parallelschaltung von VRAMs in vier Ebenen können bis zu 128 Bit 

parallel in den Muxer geladen werden, die dann mit der vierfachen Frequenz (bis zu 120 MHz) 

als Worte mit bis zu 32 Bit Farbtiefe ausgegeben werden. Diese zusätzliche Option ist möglich, 

ohne daß TIM dafür ausgelegt sein müßte. TIM unterstützt zwar vier parallele VRAM-Ebenen mit 

Speicherbusbreiten von 32 Bit, bei der Datenausgabe berücksichtigt TIM aber nur eine der Ebenen. 

4.4 Timing von Reload-Zyklen 

Es werden drei Arten von Reload-Zyklen unterschieden: 

• Newline Reloads in der horizontalen Austastlücke werden bei Video-RAMs als “Read 

Transfer Cycle” bezeichnet, ihr Timing ist in Abbildung 38 (S. 74) wiedergegeben. 

• Midline Reloads, die in der Video-Zeile exakt zum Zeitpunkt des SR-Zählerüberlaufs erfolgen 

müssen, heißen “Real Time Read Transfer Cycle” (Abbildung 39, S. 75). 

• Split Midline Reloads, mit denen Timing-unkritisch eine SR-Hälfte geladen werden kann, 

sind als “Split Read Transfer Cycle” in Abbildung 40 (S. 76) dargestellt. 

Die Zeitbeschränkungen bei den Zugriffen unterscheiden sich je nach Hersteller. Für das VRAM 

Toshiba TC 524258 sind sie im Datenbuch [11] auf Seite 143 bis 145 zu finden. 

R 

G 

✲ 

✲ 

B ✲



Lukas Bauer 

Diplomarbeit 


Alle drei Reload-Zyklen lassen sich grob in drei Phasen einteilen: 

Abschnitt 4.5 

Seite 27 

1. Über die RCA-Leitungen wird die Zeile angegeben, aus der die Daten ins SR geladen werden 

sollen. Die fallende Flanke von RAS (RAS) löst die Datenübernahme aus. Zu diesem 

Zeitpunkt bestimmen außerdem die Signale MSF (DSF), MOE (DT/OE) und MWE (WB/WE) 

die Art des RAM-Zugriffs. 

2. Dem RAM wird, ebenfalls über die RCA-Leitungen, die Spaltenposition (TAP) mitgeteilt, 

ab der die Ausgabe von Daten aus dem SR beginnen soll, wenn nach dem Reload-Zyklus 

die erste steigende Flanke von MSC (SC) kommt. Die Übernahme des TAPs erfolgt mit der 

fallenden Flanke von CAS (CAS). 

3. Der Zugriff wird beendet. Dabei wird durch die steigende Flanke von MOE (DT/OE) der 

Zeitpunkt des eigentlichen Reloads, des Ladens des Schieberegisters, bestimmt. 

Die RAS-Adresse (RAM-Zeile) und die CAS-Adresse (SR-Zeiger ” TAP“) werden beim Newline 

Reload gemäß Abbildung 21 aus der Wort-Adresse DPYNEXT des ersten Pixels der nächsten 

Zeile berechnet. Für den TAP werden stets die Bits 0 bis 11 verwendet. Die Lage der Bits von 

DPYNEXT, die für die Zeilenadresse verwendet werden, ergibt sich aus der Adreßlänge der VRAMs 

bzw. der Schieberegisterlänge SRL. Von den RAS- und CAS-Adressen bleiben je nach Adreßlänge 

der RAMs die ein bis vier obersten Adreßbits unberücksichtigt. 

DPYNEXT: 

RAS-Adresse: 

CAS-Adresse: 

26 

11 

18 17 

9 

8 

9 8 

Zeile TAP 

 

 

Abbildung 21: Ermittlung der RAS- und CAS-Adressen beim Newline-Reload, 

hier für SRL = 512, also für 9 Bit breite RAM-Adressen. 


4.5.1 Vorausberechnung der Anzahl der notwendigen Reloads 

Wesentlich für die Ablaufsteuerung und für eine effiziente Reload-Logik ist es, bereits vor Beginn 

einer Bildschirmzeile festzustellen, wieviele Midline-Reload-Zyklen in der Zeile notwendig werden. 

Anderenfalls könnte kurz vor dem Zeilenende ein Reload eingeleitet werden (weil die Daten im 

Schieberegister der Video-RAMs zur Neige gehen), der dann doch nicht nötig wird, da die Zeile 

vorher endet. In der Praxis könnte dieser Fall gehäuft auftreten, da das Ende von Bildschirmzeilen 

oft mit dem Ende von RAM-Zeilen zusammenfällt. 

Die Berechnung geht wie folgt vor sich: 

1) Es wird über CALC RLL := (HSBLNK – HEBLNK – 1) die (um 1 verminderte) Länge 

einer Bildschirmzeile berechnet, angegeben in VClk-Zyklen. CALC RLL berücksichtigt 

dabei nur den dargestellten Teil der Zeile (HBLANK=’1’), in dem Video-Daten ausgegeben 

werden sollen. 

❄ 

Zeile 

11 

0 

9 

8 

❄ 

TAP 

0 

0



Lukas Bauer 

Diplomarbeit 


Abschnitt 4.5 

Seite 28 

2a) CALC RLL wird durch den Zoom-Faktor in X-Richtung, XZ, geteilt. Es ergibt sich die 

(um 1 verminderte) Länge einer Bildschirmzeile in dargestellten Pixeln, dies entspricht der 

(um 1 verminderten) Anzahl der auszugebenden LD-Pulse. 

2b) CALC RLL wird durch MBW/PSIZE geteilt. Dies entspricht der Anzahl von Pixeln pro 

Speicherwort. Es ergibt sich die (um 1 verminderte) Anzahl der Speicherworte pro Zeile, 

CALC ELL, also die (um 1 verminderte) Anzahl der auszugebenden MSC-Pulse, die jeweils 

ein neues Speicherwort aus den Schieberegistern der Video-RAMs zur Verfügung stellen. 

Tatsächlich werden die Schritte 2a und 2b gemeinsam ausgeführt. Dazu wird durch Addition 

und Subtraktion der dual-Logarithmen (MSC SFT := ld XZ + ld MBW – ld PSIZE) 

ermittelt, um wieviele Bits der Wert CALC RLL nach rechts geshiftet werden muß, damit 

sich CALC ELL ergibt. 

Aus den Tabellen 6, 8 und 9 geht die Kodierung der Register PSIZE, XZ und MBW hervor. 

PSIZE LD PSIZE Farbtiefe 

”00000001” 0 1 

”0000001x” 1 2 

”000001xx” 2 4 

”00001xxx” 3 8 

”0001xxxx” 4 16 

”001xxxxx” 5 32 

Tabelle 6: Über das PSIZE-Register kann die 

Farbtiefe eines Pixels in Bits programmiert 

werden. 

SRL SR-Länge VRAM-Adreßlänge 

”00” 256 8 

”01” 512 9 

”10” 1024 10 

”11” 2048 11 

Tabelle 7: Die Registerbits SRL legen die 

Länge der Schieberegister in Worten fest. 

XZ LD XZ X-Zoom-Faktor 

”000” 0 1 

”001” 1 2 

”010” 2 4 

”011” 3 8 

”100” 4 16 

”101” 5 32 

”110” 6 64 

”111” 7 128 

Tabelle 8: Der Zoom-Faktor in X-Richtung 

wird über die Registerbits XZ definiert. 

MWB LD MBW Speicherbusbreite 

”00” 3 8 

”01” 4 16 

”1x” 5 32 

Tabelle 9: Die Registerbits MBW bestimmen 

die Speicherbusbreite in Bits. 

3) Aus der Anzahl der Speicherworte pro Zeile CALC ELL, der Adresse DPYNEXT des ersten 

Speicherwortes der Zeile und der Länge SRL der Schieberegister in Speicherworten kann die 

Anzahl an notwendig werdenden Reloads berechnet werden. Dazu werden von CALC ELL 

und DPYNEXT so viele Bits (von unten) addiert, wie es der Länge der Schieberegister entspricht. 

Der untere Teil der Summe gibt dabei die Position des SR-Zeigers bei Anzeige des 

letzten Pixels der Zeile an. Die weitere Berechnung und die Bezeichnungen sind für eine 

Schieberegisterlänge von SRL=256 den folgenden Abbildungen zu entnehmen. 

3a) Falls keine Split-Reloads zugelassen sind (SRE=’0’, Abbildung 22), entspricht die Anzahl 

der notwendigen (Non-Split) Reloads dem höherwertigen Teil der effektiven Zeilenlänge, 

CALC ELL SFT. Falls am Ende der Zeile noch ein Überlauf des SR-Zeigers auftritt 

(SUM TE A=’1’), wird ein zusätzlicher Reload nötig. 

Der Newline Reload vor Beginn der Zeile wird nicht in CALC NRL mitgezählt.



Lukas Bauer 

Diplomarbeit 


Abschnitt 4.5 

Seite 29 

26 8 7 0 

DPYNEXT: 

CALC ELL: 

15 8 

CALC ELL SFT 

7 

TAP (Start) 

0 

✜ 

SUM TAP ELL: 

11 9 8 7 

TAP (Ende) 

0 

✜ 

❭ + 

❄ 

SUM TE A 

✛ ✑ 

Anzahl der notwendigen Non-Split Reloads: 

CALC NRL := CALC ELL SFT + SUM TE A 

Abbildung 22: Berechnung der Anzahl der notwendigen Reloads für SRE=’0’ am Beispiel SRL=256 

3b) Falls Split-Reloads zugelassen sind (SRE=’1’, Abbildung 23), ergibt sich auf identische Weise 

die Anzahl CALC NRL der notwendigen Reloads der unteren SR-Hälfte, wobei auch hier 

der Newline Reload des ganzen SRs vor Beginn der Zeile nicht mitgerechnet wird. Einer 

der berechneten Split-Reloads der unteren SR-Hälfte kann jedoch auch vor Beginn der Zeile 

erfolgen (vgl. Abb. 18, S. 24), dies entspricht nur einer zeitlichen Verlagerung. 

26 8 7 0 

DPYNEXT: 

CALC ELL: 

15 8 

CALC ELL SFT 

7 

TAP (Start) 

0 

✜ 

SUM TAP ELL: 

11 9 8 7 

TAP (Ende) 

0 

✜ 

❭ + 

❄ ❄ 

✛ ✑ 

SUM TE A SUM TE B 

Anzahl der notwendigen Split Reloads der unteren SR-Hälfte: 

CALC NRL := CALC ELL SFT + SUM TE A 

Anzahl der notwendigen Split Reloads der oberen SR-Hälfte: 

wenn SUM TE A=’0’ und SUM TE B=’0’ −→ CALC NRH := CALC ELL SFT − 1 

wenn SUM TE A=’1’ und SUM TE B=’1’ −→ CALC NRH := CALC ELL SFT + 1 

sonst −→ CALC NRH := CALC ELL SFT 

Abbildung 23: Berechnung der Anzahl der notwendigen Reloads für SRE=’1’ am Beispiel SRL=256 

Um die Anzahl CALC NRH der in der Zeile notwendigen Split-Reloads der oberen SR- 

Hälfte zu bestimmen, wird ebenfalls vom höherwertigen Teil der effektiven Zeilenlänge, 

CALC ELL SFT, ausgegangen. Es muß jedoch 1 addiert werden, falls SUM TE A=’1’ und 

SUM TE B=’1’ ist (Überlauf des SR-Zeigers bis in die obere SR-Hälfte), während 1 subtrahiert 

werden kann, wenn SUM TE A=’0’ und SUM TE B=’0’ ist (kein Überlauf des SR- 

Zeigers, und kein Erreichen der oberen SR-Hälfte am Zeilenende). 

Die Berechnung erfolgt parallel zu den ersten beiden Takten jedes Newline Reloads im Diagramm 

NEWL REL (Seite 95). Mit Transition T1 wird SUM TAP ELL berechnet, mit T2 werden 

CALC NRL und CALC NRH bestimmt. 

Einige zusätzlich nötige Rechenschritte werden im separaten Diagramm RL CALC (Seite 99) 

durchgeführt. Dort werden LD XZ, LD MBW und LD PSIZE aus den Registerwerten bestimmt, 

damit dann MSC SFT gebildet werden kann. Anschließend wird CALC RLL um entsprechend viele 

Stellen nach rechts geshiftet, so daß sich CALC ELL ergibt. Außerdem werden die Komponenten 

SUM TE A, SUM TE B und CALC ELL SFT ermittelt. 

Die Funktionsfähigkeit der Vorausberechnung kann anhand der Simulationsergebnisse auf den Abbildungen 

74 und 75 (S. 107 und 108) nachvollzogen werden. In Abbildung 74 endet die Zeile nach 

dem ersten Pixel einer neuen Speicher-Zeile (zu erkennen an den Signalen HBLANK, SR ROW 

(Zeile) und SR CNT (TAP)), daher muß der Midline Reload kurz vor Zeilenende noch erfolgen. In 

Abbildung 75 hingegen endet die Zeile gerade noch vor dem Wechsel zu einer neuen Speicher-Zeile, 

daher kann der Midline Reload hier entfallen.



Lukas Bauer 

Diplomarbeit 


4.5.2 Steuerung des Zeitpunktes von Reloads 

4.5.2.1 Zeitpunkt von Newline Reloads 

Abschnitt 4.5 

Seite 30 

Newline Reloads erfolgen gemäß Abbildung 18 (S. 24) am Ende der jeweils vorausgehenden Bildschirmzeile. 

Bereits in Abschnitt 3.2.1 wurde beschrieben, daß im Diagramm S HCNT am Ende 

jeder Video-Zeile, auf die eine anzuzeigende Bildschirmzeile folgt, das Signal RELOAD gesetzt 

wird, um einen Newline Reload einzuleiten. 

Im Diagramm RL RAM (S. 93) ist nun in Transition T1 zu erkennen, daß dies, falls Reloads 

freigegeben sind (RLE=’1’), einen Newline Reload auslöst. 

Der eigentliche Reload-Zyklus wird eine Hierarchieebene tiefer, im Diagramm NEWL REL (S. 95) 

ausgeführt. Im Vergleich mit den Simulationsergebnissen (Abb. 75, S. 108) erkennt man deutlich 

den RAS-CAS-Zyklus, in dessen Verlauf Zeile (0x011) und TAP (0x1C9), ermittelt gemäß Abbildung 

21, übergeben werden. Im Anschluß an den eigentlichen Reload wird ein ’0’-Puls an MSC out 

erzeugt (über das mit MSC out verknüpfte Signal MSC reload), damit die ersten SR-Daten ausgegeben 

werden und am Zeilenanfang mit LD out gelatcht werden können. 

4.5.2.2 Zeitpunkt von Non-Split Midline Reloads 

Der Zeitpunkt von Midline Reloads ist exakt einzuhalten, wenn keine Split Reloads zugelassen sind. 

Gemäß Abbildung 18 (S. 24) müssen die Reload-Zyklen 5 VClk-Zyklen vor einem nötigen 

Wechsel der Schieberegister-Daten eingeleitet werden (dies entspricht der Dauer der Reload- 

Zyklen), damit der Zeitpunkt des Ladens am Ende des Zyklus genau dann stattfindet, wenn die 

letzte Position der Schieberegister erreicht ist. 

Um dies zu ermöglichen, ist es erforderlich, daß die momentane Position des SR-Zeigers (TAP) 

bekannt ist, um den Datenwechsel vorhersagen zu können. Der Zähler TAPCNT wird dazu beim 

ersten Schritt eines Newline Reloads (Diagramm NEWL REL, S. 95) auf den aus DPYNEXT 

berechneten TAP (die CAS-Adresse) gesetzt, evtl. angefüllt mit führenden Einsen, da der Zähler 

auf einen festen Endwert geprüft werden wird. Ein zweiter Zähler, ROWCNT, wird entsprechend 

auf die aktuelle RAM-Zeile (die RAS-Adresse) gesetzt. 

Während der Darstellung der Zeile wird der Zähler TAPCNT mit jeder erzeugten MSC-Flanke 

erhöht, mit der der Schieberegister-Zeiger im VRAM um eine Position weiterwandert. Auf diese 

Weise entspricht TAPCNT stets der aktuellen SR-Position. Erreicht der Zähler den Wert 7FA (SR- 

Ende minus 5), so wird ein Midline Reload Zyklus eingeleitet (T9 im Diagramm RL RAM, S. 93), 

falls laut der vorausberechneten Zahl an notwendigen Reloads (CALC NRL) noch mindestens ein 

Reload in der Zeile notwendig wird. 

Da beim Reload die Nummer der Zeile übergeben werden muß, aus der Daten in die SR geladen 

werden, muß mit jedem Midline Reload der Zähler ROWCNT erhöht und sein Wert übergeben 

werden. Dies geschieht mit dem ersten Takt jedes Midline Reloads (Diagramm MIDL REL, S. 94). 

Ist Zooming in X-Richtung aktiv oder die Speicherbusbreite größer als die Farbtiefe, also 

MSC SFT = 0, so beträgt der Abstand zwischen zwei Flanken von MSC ein Vielfaches der Taktperiode 

von VClk. In diesem Fall könnte ein Reload-Zyklus extrem lange dauern (bis zu 128 · 32 · 5 

VClk-Perioden), wenn er fünf MSC-Perioden vor dem nötigen Datenwechsel (bei TAPCNT=0x7FA) 

eingeleitet würde. Um dies zu vermeiden, wird bei MSC SFT = 0 nicht allein der TAP-Zähler 

TAPCNT, sondern ein weiterer Zähler MSCNT herangezogen, um für den Beginn des Reload- 

Zyklus den Zeitpunkt zu ermitteln, der 5 VClk-Perioden vor dem notwendigen Datenwechsel liegt. 

Der Zähler MSCNT wird mit jedem VClk-Zyklus erhöht und über die Modulo-Funktion auf eine 

Periodizität gebracht, die dem Verhältnis von fVClk in zu fMSC out entspricht. Ist z. B. MSC SFT=3,



Lukas Bauer 

Diplomarbeit 


Abschnitt 4.5 

Seite 31 

so ist fVClk in / fMSC out = 2 3 = 8, und MSCNT muß alle 8 VClk-Zyklen seinen Endwert von 0xFFF 

erreichen. In diesem Augenblick wird ein Puls an MSC out generiert und TAPCNT erhöht, da der 

SR-Zeiger um 1 weiterwandert. 

Der Zeitpunkt für den Beginn eines Midline Reloads kann nun aus TAPCNT und MSCNT bestimmt 

werden (Transition T9, Diagramm RL RAM, S. 93). Für MSC SFT=0 wird weiterhin 

die Bedingung TAPCNT=0x7FA verwendet. Für MSC SFT=1 entsprechen 5 VClk-Perioden 2 1 /2 

Perioden von MSC out, also 2 MSC-Zyklen plus 1 VClk-Zyklus. Daher wird der Reload-Zyklus 

eingeleitet, wenn TAPCNT=0xFFD (Endwert minus 2) und MSCNT=0xFFE (Endwert minus 1) 

ist. Entsprechendes gilt für MSC SFT > 1. 

Der Midline Reload Zyklus wird im Diagramm MIDL REL (S. 94) durchgeführt. Sein Verlauf 

ist auf Abbildung 76 (S. 109) als Simulationsergebnis zu sehen, dort wird erst ein Newline Reload 

(Zeile 0x009, TAP 0x1FD) durchgeführt, dann der Midline Reload (Zeile 0x00A, TAP 0x000). 

Beginnt die Bildzeile, kurz bevor das SR-Ende erreicht ist (z. B. TAPCNT=FFE bei MSC SFT=0), 

so liegt der Punkt, zu dem der Reload eingeleitet werden müßte, bereits vor Beginn des Anzeigebereichs. 

Da TAPCNT aber bei 0xFFE beginnt, nimmt der Zähler nie den Wert 0xFFA an, 

und der Reload würde ausbleiben. 

Um auch solche Reloads nach den ersten Pixeln einer Zeile ( ” frühe Reloads“) ausführen zu können, 

wird in solchen Fällen der Horizontalzähler HCOUNT herangezogen, um den richtigen Zeitpunkt 

für den Beginn des Reload-Zyklus bestimmen zu können. Parallel zum zweiten Schritt jedes Newline 

Reloads (Diagramm NEWL REL, S. 95) wird dabei HC MLR auf den Wert gesetzt, den 

HCOUNT zum Zeitpunkt des SR-Überlaufs haben wird. Gleichzeitig wird überprüft, ob überhaupt 

ein früher Reload nötig wird. In diesem Fall wird HC MEN5 auf ’1’ gesetzt. Parallel zum dritten 

Schritt des Newline Reloads wird, falls ein früher Reload erfolgen muß, die Variable HC MLR5 

auf (HC MLR–5) gesetzt, also auf den Stand von HCOUNT, bei dem der frühe Midline Reload 

eingeleitet werden muß. 

Im Diagramm RL RAM (S. 93) kann nun “HCOUNT=HC MLR5 and HC MEN5=’1’ ” als weitere 

Bedingung für den Start eines Midline Reloads verwendet werden. Im Simulationsergebnis 

(Abb. 77, S. 110) erkennt man deutlich, daß der frühe Midline Reload (rechts) zu einem Zeitpunkt 

beginnt, zu dem der Zähler TAPCNT seinen Initialwert 0x7FE hat. Die normale Startbedingung 

(TAPCNT=0xFFA) wird also nicht erfüllt. 

4.5.2.3 Zeitpunkt von Split Midline Reloads 

Das Timing von Split Midline Reloads ist weniger kritisch als das von Non-Split Reloads. Gemäß 

Abbildung 19 (S. 24) können sie in einem recht weiten Zeitbereich innerhalb einer Bildzeile erfolgen. 

Beginnen die Zeilendaten in der oberen SR-Hälfte, so kann, wie schon erwähnt, der Split Midline 

Reload der unteren SR-Hälfte an das Ende der vorigen Zeile vorgezogen werden. Der Split Reload 

erfolgt dann direkt nach dem Newline Reload, was im Diagramm RL RAM (S. 93) zu sehen ist 

(T7). 

Die übrigen Split Midline Reloads können frühestens dann erfolgen, wenn die letzten ” alten“ Daten 

aus der neu zu ladenden SR-Hälfte ausgegeben wurden. Um dies zu signalisieren, wird das Signal 

SMR request im Diagramm RL MSC (S. 98) erzeugt. Es wird auf ’1’ gesetzt, wenn ein Split 

Midline Reload durchgeführt werden soll. Gleichzeitig zeigt das Signal SMR high an, ob die obere 

oder untere SR-Hälfte geladen werden soll. Zur Erzeugung der Signale wird getestet, ob die letzte 

Position der oberen bzw. unteren SR-Hälfte erreicht wurde. 

Das Signal SMR request wird später von der Arbitrierungslogik der Controller-Einheit ausgewertet. 

Wenn der gemeinsam von verschiedenen Einheiten genutzte VRAM-Bus frei ist, wird von dort die



Lukas Bauer 

Diplomarbeit 


Abschnitt 4.5 

Seite 32 

Genehmigung erfolgen, den Refresh durchzuführen, indem das Signal SMR ack auf ’1’ gesetzt wird. 

Zur Zeit wird dieses Signal noch von der lokalen Arbitrierungslogik erzeugt (Diagramm RL ARBIT, 

S. 101, vgl. Abschnitt 4.5.5), um einen getrennten Test der Einheiten zu ermöglichen. 

Ein Beispiel für eine Abfolge von Split Midline Reloads ist als Simulationsergebnis auf Abbildung 78 

(S. 111) zu sehen. Man erkennt, daß nach dem Newline Reload (Zeile 0x00F, TAP 0x1F8) sofort ein 

vorgezogener Split Midline Reload der unteren SR-Hälfte (Zeile 0x010, TAP 0x000) durchgeführt 

wird. Anschließend ist Zeit für die Durchführung eines Refresh-Zyklus (vgl. Abschnitt 4.5.4). 

Nachdem im Anzeigebereich die letzten Daten der oberen SR-Hälfte ausgegeben wurden (SR ROW 

und SR CNT: Wechsel von 0x00F/0x1FF auf 0x010/0x000, SMR request=’1’), wird ein normaler 

Split Midline Reload der oberen SR-Hälfte (Zeile 0x010, TAP 0x000) durchgeführt. Hierbei wird 

zwar der TAP 0x000 übergeben, es wird aber nach Ende der unteren SR-Hälfte auf die TAP- 

Position 0x100 gewechselt. Das oberste Bit der CAS-Adresse wird beim Split Reload ignoriert; 

welche SR-Hälfte geladen werden muß, richtet sich danach, welche SR-Hälfte zum Zeitpunkt des 

Split Reloads aktiv war. 

4.5.3 Erzeugung der Taktsignale für die Video-D/A-Wandler 

Die Taktsignale MSC out und LD out, die bereits in Abschnitt 4.3 beschrieben wurden, werden im 

Diagramm RL MSC (S. 98) erzeugt. 

Bei der Generierung des MSC out-Signals wird ausgenutzt, daß die Periodizität des Zählers 

MSCNT genau der von MSC out entspricht. Daher wird MSC out einmal pro Periode von 

MSCNT auf ’0’ gesetzt. Damit MSC out gegenüber LD out um eine VClk-Periode voreilt, geschieht 

dies nicht beim Zählerendstand von MSCNT=0xFFF, sondern bereits bei MSCNT=0xFFE. 

Ist MSC SFT=0, so ist MSC out mit VClk in identisch. In diesem Fall wird MSC out während des 

Anzeigebereichs asynchron der Wert von VClk in zugewiesen. 

Das LD out-Signal wird ebenfalls aus dem Zähler MSCNT abgeleitet. Da es jedoch hochfrequenter 

als das MSC out-Signal sein kann, müssen pro Periode von MSCNT evtl. mehrere ’0’-Pulse an 

LD out generiert werden. Da fLD out = fVClk in / XZ ist, werden dazu so viele der unteren Bits von 

MSCNT auf ’1’ getestet, wie XZ angibt. 

Charakteristische Simulationsergebnisse sind auf Abbildung 75 (S. 108, MSC SFT=0, XZ=0), Abbildung 

76 (S. 109, MSC SFT=2, XZ=2) und Abbildung 79 (S. 112, MSC SFT=2, XZ=0) zu sehen. 

Zu beachten ist dabei auch der erste Puls an MSC out, der unmittelbar nach dem Newline Reload 

erfolgt. 

4.5.4 Refresh von DRAMs und VRAMs 

Bei dynamischen RAMs müssen in regelmäßigen Abständen Refresh-Zyklen durchgeführt werden, 

um dem stetigen Ladungsverlust der Kondensatoren in der Speichermatrix entgegenzuwirken. Moderne 

DRAMs und VRAMs erzeugen über interne Zähler Refresh-Zeilennummern, so daß automatisch 

eine Speicherzeile aufgefrischt und zur nächsten Zeile übergegangen wird, wenn am Bus des 

RAMs ein einfacher “CAS before RAS”-Refresh-Zyklus stattfindet, wie er in Abbildung 41 (S. 77) 

dargestellt ist. 

Der zeitliche Abstand zwischen zwei Refresh-Zyklen ergibt sich aus der Zeit, die die Ladung einer 

Speicherzelle ohne Refresh ” überlebt“ (8ms beim TC 524258 [11]), und der Anzahl der Zeilen, 

die innerhalb dieser Zeit aufgefrischt werden müssen. Der Abstand zweier Refreshs ist über die 

Registerbits RF (Tabelle 10) in Vielfachen des Video-Taktes VClk programmierbar.



Lukas Bauer 

Diplomarbeit 


Tabelle 10: Die Registerbits RF 

legen die Refresh-Rate in VClk- 

Zyklen fest. 

RF VClk-Zyklen 

”000” 32 

”001” 64 

”010” 128 

”011” 256 

RF VClk-Zyklen 

”100” 512 

”101” 1024 

”110” 2048 

”111” kein Refresh 

Abschnitt 4.5 

Seite 33 

Im Speedchart-Diagramm RL REFRESH (S. 100) wird der Zähler REFCNT so gesteuert, daß 

er in entsprechenden Abständen seinen Endwert 0x7FF erreicht. In diesem Fall muß jedoch nicht 

sofort ein Refresh ausgeführt werden. Zum einen sind Timing-kritische Vorgänge wie Midline 

Reloads vorrangig zu behandeln, zum anderen ist es unkritisch, wenn bei den Refresh-Zyklen eine 

Pause von einigen Zyklen entsteht: Solange diese nachgeholt werden, erhöht sich der Abstand zweier 

Refreshs der gleichen Speicherzeile kaum. Die Refresh-Zyklen können also eine geringe Priorität 

erhalten. 

Um sicherzustellen, daß ausgefallene Zyklen nachgearbeitet werden, wurden im Speedchart-Design 

zwei Zähler implementiert. Der Zähler REF RQNR wird erhöht, wenn der Refresh-Zähler 

REFCNT seinen Endwert erreicht; er zählt somit die Anzahl von angeforderten Refresh-Zyklen. 

Der Zähler REF PFNR wird im Diagramm RL RAM erhöht, wenn ein Refresh-Zyklus durchgeführt 

wurde. Aufgabe der Arbitrierungslogik ist es nun, dafür zu sorgen, daß bei freiem RAM-Bus 

so viele Refresh-Zyklen durchgeführt werden, daß dadurch der Zähler der durchgeführten Zyklen, 

REF PFNR, den Zähler der angeforderten Zyklen, REF RQNR, immer wieder erreicht. 

Der eigentliche Refresh-Zyklus wird vom Diagramm REFRESH (S. 97) gesteuert. Ein zusätzlich 

eingeführtes Registerbit FASTRAM bestimmt dabei, ob die Breite des RAS-Pulses vier oder (bei 

schnellen RAMs, FASTRAM=’1’) drei VClk-Zyklen beträgt. Im Simulationsergebnis (Abb. 79, 

S. 112) ist zu erkennen, daß zwei Refresh-Zyklen durchgeführt werden (bei 14µs und 14,55µs), von 

denen der erste eigentlich früher fällig gewesen wäre, aber wegen des höher priorisierten Newline 

Reloads (bei 13,75µs) aufgeschoben werden mußte. 

4.5.5 Die Arbitrierungslogik 

Aufgabe der Arbitrierungslogik ist es, den Bus der DRAMs und VRAMs so zu verwalten, daß ohne 

zeitliche Konflikte Reload- und Refresh-Zyklen sowie Schreib- und Lesebefehle der Prozessorund 

Controller-Einheit ausgeführt werden können. Das Speedchart-Diagramm RL ARBIT ist 

auf Seite 101 zu sehen. 

Von entscheidender Bedeutung ist bei der Arbitrierung, daß Reload-Zyklen zur richtigen Zeit stattfinden 

können. Daher werden diese (vgl. T1 und T9 im Diagramm RL RAM, S. 93) ohne ” Genehmigung“ 

der Arbitrierungslogik durchgeführt. Stattdessen werden sie vorher angekündigt, so daß die 

Arbitrierungslogik der Controller-Einheit bei angekündigten Reloads nur noch solche RAM-Zugriffe 

freigibt, die mit Sicherheit rechtzeitig vor den Reloads beendet werden können. 

Die Anmeldung erfolgt in zwei Stufen. 10 bzw. 6 VClk-Zyklen vor Beginn des Reloads werden 

Newline Reloads über die Signale RELAT10 bzw. RELAT6 ankündigt, während vor Midline Reloads 

die Signale MLRAT10 bzw. MLRAT6 gesetzt werden. 

Der Zeitpunkt, zu dem die Signale gesetzt werden müssen, ergibt sich bei Newline Reloads aus 

dem Stand des Horizontalzählers HCOUNT und dem Start der horizontalen Austastlücke (siehe 

Seite 20). Bei Midline Reloads werden die Signale im Diagramm RL REFRESH (S. 100) erzeugt, 

wobei die Zähler TAPCNT und MSCNT herangezogen werden. Bei frühen Midline Reloads (analog 

zu Abschnitt 4.5.2.2) werden die Signale vom Horizontalzähler HCOUNT gesteuert.



Lukas Bauer 

Diplomarbeit 


Abschnitt 4.5 

Seite 34 

Unter Verwendung der Signale zur Anmeldung von Reloads können nun kurze Bus-Zugriffe genehmigt 

werden, falls keines der Signale RALAT6 und MLRAT6 gesetzt ist, während lange Zugriffe 

(mit mehr als 6 Zyklen) nur genehmigt werden, wenn auch RELAT10 und MLRAT10 inaktiv sind. 

Zugriffe, die länger als 10 Zyklen dauern, werden für die Durchführung der Reloads und Refreshs 

unterbrochen und danach fortgesetzt, wobei nach der Unterbrechung ein neuer RAS-Zyklus erforderlich 

werden kann. 

Die Freigabe von Refreshs und von Split Midline Reloads erfolgt bisher, ohne daß eine Bus-Freigabe 

durch die Controller-Einheit abgewartet wird (Diagramm RL ARBIT, S. 101, T4, T6 und T2), 

damit ein unabhängiger Test der Einheiten möglich wird. 

4.5.6 Modellierung eines Video-RAMs 

Um bei den Simulationsergebnissen zusätzlich zu den Verläufen der Steuersignale für die RAMs 

konkrete Aussagen über das Verhalten und das Innenleben der RAMs zu erhalten, wurde im 

Speedchart-Design ein an TIM angeschlossenes Video-RAM des Typs Toshiba TC 524258 [11] 

modelliert. 

Dies war nicht nur in der Entwicklungsphase hilfreich, sondern beweist auch anhand der gewonnenen 

Aussagen über die von den Schieberegistern ausgegebenen Daten, daß die Reload-Logik einwandfrei 

funktioniert. So sind beispielsweise in Abbildung 77 (S. 110) die Signale SR ROW und SR CNT 

zu erkennen, die die RAM-Zeile und die SR-Position der gerade ausgegebenen Daten wiedergeben. 

Es ist zu sehen, daß der frühe Midline Reload (rechts) tatsächlich im richtigen Augenblick erfolgt 

(Übergang von Zeile 0x005, TAP 0x1FF auf Zeile 0x006, TAP 0x000). 

Die Zustandssteuerung des VRAM-Modells ist im Speedchart-Diagramm VR RAM (S. 86) zu 

sehen. Ein CAS-vor-RAS-Zyklus wird als Refresh interpretiert, RAS-CAS-Zyklen entsprechen 

Schreib-, Lese- oder Reload-Zugriffen, die in den untergeordneten Diagrammen TRANSFER 

(S. 87) und READ WRITE (S. 88) behandelt werden. Die Art des Zugriffs richtet sich dabei 

nach den Zuständen der Signale MWE, MSF, MSE und MOE bei der fallenden Flanke von 

RAS. 

Im Diagramm READ WRITE werden Schreib- und Lesezugriffe einschließlich der speziellen 

Fähigkeiten des RAMs modelliert. Hierzu zählen der Fast-Page-Mode (Zugriff auf mehrere Worte 

einer Zeile in einem gemeinsamen RAS-Zyklus), Mask Write (maskiertes Schreiben von Bits), Block 

Write (Schreiben von bis zu vier Worten in einem Zugriff) und Flash Write (Schreiben einer gesamten 

Speicherzeile in einem Zugriff). Für die Block-Write- und Flash-Write-Funktionen kommen 

die Daten aus einem Color-Register, in das sie zuvor geschrieben werden müssen. 

Durch die Zustands-Namen und die ausgegebenen Klartext-Meldungen ist das Diagramm weitgehend 

selbsterklärend. Damit auch das synthetisierte Modell noch Informationen liefern kann, 

werden diese nicht nur als Texte, sondern auch als Signale ausgegeben. Die Variable A RAMw 

wird bei Schreibzugriffen, A RAMr bei Lesezugriffen auf einen Wert gesetzt, der codiert die Art 

des durchgeführten Zugriffs kennzeichnet. Gleichzeitig stehen an A ROW, A COL, A WM1 und 

A DATA Informationen über Zeile, Spalte, Schreib-Maske und Daten während des Zugriffs zur 

Verfügung. 

Im Diagramm TRANSFER werden entsprechend die Reload-Zugriffe behandelt. Hier wird über 

die Variable A SAM die Art des Zugriffs codiert ausgegeben; A ROW und A TAP zeigen Zeile und 

Spalte beim Zugriff an. Zusätzlich wurde der SR-Zähler implementiert, der mit jeder steigenden 

Flanke von MSC erhöht wird. Dies wird im Diagramm VR SAM (S. 89) gesteuert. Die Variablen 

SR ROW und SR CNT repräsentieren stets Zeile und Position der Daten, die momentan am 

Ausgang des Schieberegisters ausgegeben werden. Dies erlaubt eine optimale Kontrolle der Funktion 

der VRAM-Reload-Einheit.



Lukas Bauer 

5 Die Controller-Einheit 

5.1 Aufgaben der Controller-Einheit 

Diplomarbeit 


Abschnitt 5.2 

Seite 35 

Aufgabe der Controller-Einheit als Schnittstelle zur Peripherie ist es, das Host- und das Speicherinterface 

so zu verwalten, daß Zugriffe des Hosts auf die TIM-internen Register und auf den extern 

angeschlossenen Speicher möglich sind. Dabei sollen beide Schnittstellen möglichst flexibel gehalten 

werden. Unterstützt werden sollen dabei 

• nicht-gemultiplexte Host-Schnittstellen (mit getrenntem Adreß- und Datenbus) und gemultiplexte 

Host-Schnittstellen (mit gemeinsamem Adreß- und Datenbus), 

• Host-Schnittstellen nach der NUBUS-Konvention (mit vertauschter Byte-Anordnung in der 

Datenphase), 

• unabhängig voneinander einstellbare Breiten von Host- und Speicherbus (8, 16 oder 32 Bit), 

• Speicher-Zugriffe im “Fast Page Mode”, wobei in einem RAS-Zyklus mehrere Zugriffe erfolgen 

können 

• sowie bis zu vier Speicher-Ebenen mit je vier Bänken von DRAMs oder VRAMs, deren 

Adreßlänge (Größe) getrennt einstellbar ist. 

Außerdem muß die Controller-Einheit die Adreßrechnung für die angeschlossenen RAMs 

durchführen, damit der Host in einem linearen Adreßraum auf sie zugreifen kann. 

Der Refresh der RAMs wird entgegen der Aufgabenstellung nicht von der Controller-Einheit, sondern 

von der VRAM-Reload-Einheit durchgeführt (vgl. Abschnitt 4.5.4). 

5.2 Host-Zugriffe 

5.2.1 Handshake bei Host-Zugriffen 

Damit der Host bei seinen Zugriffen auf den Grafikprozessor erkennen kann, wann ein Datentransfer 

abgeschlossen werden kann und wann TIM in der Lage ist, weitere Daten anzunehmen oder 

bereitzustellen, ist ein Handshake notwendig, der über das RDY-Signal erfolgt. 

Während des Resets ermittelt TIM den Pegel der RDY-Leitung, anhand dessen der aktiven Pegel 

des Signals festgelegt wird. Dabei wird davon ausgegangen, daß RDY beim Reset inaktiv ist. 

Die genaue Funktion des RDY-Signals wird in den folgenden Abschnitten für verschiedene Zugriffsarten 

beschrieben. Dabei wird davon ausgegangen, daß ein FIFO-Puffer (first in, first out) für zu 

schreibende Daten vorhanden ist. 

5.2.2 Host-Zugriffe bei gemultiplextem Bus 

Schreibzugriffe verlaufen bei gemultiplexten Bussen gemäß Abbildung 24. 

In der Adreßphase legt der Host zunächst ( ❤ 1 ) die Adresse auf den gemeinsamen Adreß- und 

Daten-Bus AD. Gleichzeitig wird festgelegt, ob der Speicher (RS=’1’) oder ein Register (RS=’0’) 

geschrieben wird, und die Datenbyte-Maske auf BS ausgegeben. Es wird HWE=’0’ gesetzt, was 

einen Schreibzugriff kennzeichnet. Diese Daten werden von TIM mit der fallenden Flanke von AS 

übernommen ( ❤ 2 ).



Lukas Bauer 

Diplomarbeit 


Abschnitt 5.2 

Seite 36 

In der Datenphase gibt der Host die Daten auf dem AD-Bus aus ( ❤ 3 ). Mit der fallenden Flanke 

von DS werden sie von TIM übernommen ( ❤ 4 ). 

Anschließend führt TIM das Schreibkommando aus. Dabei können Registerzugriffe sofort erfolgen, 

während bei Speicherzugriffen nur dann eine sofortige Bearbeitung möglich ist, wenn noch Platz 

im FIFO-Puffer ist. Anderenfalls muß gewartet werden, bis einige Daten aus dem FIFO-Puffer in 

den Speicher übertragen wurden, bevor die aktuellen Daten im Puffer abgelegt werden können. 

Nach Abschluß der Bearbeitung ( ❤ 5 ) setzt TIM die RDY-Leitung auf ihren aktiven Pegel (im Beispiel 

auf ’1’). Der Host schließt daraufhin den Zugriff ab, indem er AS und DS deaktiviert ( ❤ 6 ). Daraufhin 

deaktiviert TIM die RDY-Leitung ( ❤ 7 ). 

AD: \/\/\/\/\/ Adr. \/\/\/\/\/ Schreib-Daten \/\/\/\/\/\/\/\/ 

RS: \/\/\/\/\/ RS \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 

BS: 

\/\/\/\/\/ Maske \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 

HWE: \/\/\/\/\ /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 

AS: \ ✄✲ / 

DS: \ / 

RDY: / ✁ ✂✲ \ 

❤1 ❤ 2 ❤ 3 ❤ 4 ❤ 5 ❤ 6 ❤ 7 

TIM schreibt 

Daten 

AD: \/\/\/\/\/ Adr. 〉 〈Lese-Daten〉 〈\/\/\/ 

RS: \/\/\/\/\/ RS \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 

BS: 

\/\/\/\/\/ Maske \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 

HWE: \/\/\/\// \\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 

AS: \ ✄✲ / 

DS: \ / 

RDY: / ✁ ✂✲ \ 

❤1 ❤ 2 ❤ 3 ❤ 4 ❤ 5 ❤ 6 ❤ 7 ❤ 8 

TIM liest 

Daten 

Abbildung 24: Schreibzugriff bei gemultiplextem Bus. Abbildung 25: Lesezugriff bei gemultiplextem Bus. 

Lesezugriffe verlaufen bei gemultiplexten Bussen gemäß Abbildung 25. 

Die Adreßphase entspricht der von Schreibzugriffen, es ist lediglich HWE=’1’. 

Die Datenphase beginnt damit, daß der Host den Adreß- und Datenbus AD in den hochohmigen 

Zustand versetzt ( ❤ 3 ) und dies durch die fallende Flanke von DS anzeigt ( ❤ 4 ). 

Anschließend führt TIM das Lesekommando aus. Bei Speicherzugriffen muß dabei gewartet werden, 

bis der FIFO-Puffer für zu schreibende Daten leer ist, bevor die notwendigen Lesezyklen auf dem 

Speicherbus durchgeführt werden. Stehen die Daten für den Host bereit ( ❤ 5 ), aktiviert TIM die 

RDY-Leitung ( ❤ 6 ), woraufhin der Host den Zugriff abschließt. Dabei liest er die Daten mit der steigenden 

Flanke von AS ( ❤ 7 ). Wenn TIM diese Flanke erkennt, deaktiviert TIM die RDY-Leitung ( ❤ 8 ) 

und versetzt den Adreß- und Datenbus wieder in den hochohmigen Zustand. 

5.2.3 Host-Zugriffe bei nicht gemultiplextem Bus 

Host-Zugriffe bei nicht gemultiplextem Bus unterscheiden sich nur geringfügig von Zugriffen mit 

gemultiplextem Bus. Da ein getrennter Datenbus vorhanden ist, können die Daten bei Schreibzugriffen 

(Abbildung 26) gemeinsam mit der Adresse ausgegeben ( ❤ 1 ) und von TIM mit der fallenden 

Flanke von AS übernommen werden ( ❤ 2 ). Die getrennte Datenphase und das DS-Signal entfallen 

dabei.



Lukas Bauer 

A: \/\/\/\/\/ Adr. \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 

D: \/\/\/\/\/ Schreib-Daten \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 

RS: \/\/\/\/\/ RS \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 

BS: 

Diplomarbeit 


\/\/\/\/\/ Maske \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 

HWE: \/\/\/\/\ /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 

AS: \ ✄✲ / 

RDY: / ✁ ✂✲ \ 

❤1 ❤ 2 ❤ 3 ❤ 4 ❤ 5 

TIM schreibt 

Daten 

Abbildung 26: Schreibzugriff bei nicht gemultiplextem 

Bus. 

Abschnitt 5.2 

Seite 37 

A: \/\/\/\/\/ Adr. \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 

D: \/\/\/\/〉 〈Lese-Daten〉 〈\/\/\/\/\/\/\/ 

RS: \/\/\/\/\/ RS \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 

BS: 

\/\/\/\/\/ Maske \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 

HWE: \/\/\/\// \\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 

AS: \ ✄✲ / 

RDY: / ✁ ✂✲ \ 

❤1 ❤ 2 ❤ 3 ❤ 4 ❤ 5 ❤ 6 

TIM liest 

Daten 

Abbildung 27: Lesezugriff bei nicht gemultiplextem Bus. 

Auch bei Lesezugriffen (Abbildung 27) kann die DS-Leitung entfallen, wenn der Host bereits zu 

Beginn der Adreßphase ( ❤ 1 ) den Datenbus in den hochohmigen Zustand versetzt. 

5.2.4 Beschleunigter Handshake 

Falls der Host zwischen zwei Bus-Zugriffen darauf wartet, daß RDY wieder inaktiv wird, kann 

bei Schreibzugriffen ein beschleunigter Handshake durchgeführt werden. Dabei aktiviert TIM 

die RDY-Leitung bereits unmittelbar nach der Datenübernahme in die TIM-internen Register, 

bei gemultiplexten Bussen also nach der fallenden Flanke von DS (Abbildung 28, ❤ 4 / ❤ 5 ), bei nicht 

gemultiplexten Bussen nach der fallenden Flanke von AS (Abbildung 29, ❤ 2 / ❤ 3 ). 

Der Vorteil liegt darin, daß der Host den Zugriff daraufhin bereits abschließen und z. B. die nächsten 

Befehle aus dem Cache ausführen kann. Vor einem weiteren Bus-Zugriff allerdings muß er auf 

die Deaktivierung des RDY-Signals durch TIM warten. Dies geschieht, wenn TIM den internen 

Schreibzugriff abgeschlossen hat und bereit ist, neue Daten anzunehmen. 

Doch selbst wenn zwei Bus-Zugriffe unmittelbar aufeinander folgen, bedeutet die verfrühte Aktivierung 

des RDY-Signals einen Geschwindigkeitsvorteil, da der wechselseitige Handshake bei Abschluß 

des Zugriffs gespart wird (RDY und AS, vgl. Abb. 24 und 26). 

Beschleunigte Handshakes werden von TIM durchgeführt, wenn das Registerbit FASTRDY auf ’1’ 

gesetzt ist. 

AD: \/\/\/\/\/ Adr. \/\/\/\/\/ Daten \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 

RS: \/\/\/\/\/ RS \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 

BS: 

\/\/\/\/\/ Maske \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 

HWE: \/\/\/\/\ /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 

AS: \ ✄✲ / 

DS: \ / 

RDY: / ✁ \ 

❤1 ❤ 2 ❤ 3 ❤ 4 ❤ 5 ❤ 6 

TIM schreibt 

Daten 

Abbildung 28: Schreibzugriff bei gemultiplextem Bus mit 

beschleunigtem Handshake. 

A: \/\/\/\/\/ Adr. \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 

D: \/\/\/\/\/ Daten \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 

RS: \/\/\/\/\/ RS \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 

BS: 

\/\/\/\/\/ Maske \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 

HWE: \/\/\/\/\ /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 

AS: \ ✄✲ / 

RDY: / ✁ \ 

❤1 ❤ 2 ❤ 3 ❤ 4 ❤ 5 

TIM schreibt 

Daten 

Abbildung 29: Schreibzugriff bei nicht gemultiplextem 

Bus mit beschleunigtem Handshake. 

Ein beschleunigter Handshake bei Lesezugriffen ist nicht möglich, da der Host einen Lesezugriff 

nicht abschließen kann, bevor die zu lesenden Daten von TIM bereitgestellt wurden.



Lukas Bauer 

5.3 Speicherorganisation 

Diplomarbeit 


Abschnitt 5.4 

Seite 38 

Da in modernen Computersystemen oft Bedarf nach einem sehr großen Video-Speicher besteht, 

Video-RAMs aber deutlich teurer als DRAMs sind, erlaubt TIM die gemischte Bestückung des 

externen Speichers mit VRAMs und DRAMs. Da aber nur die Anzeige von Daten aus Video- 

RAMs möglich ist, müssen die Daten aus den DRAMs bei Bedarf in die VRAMs kopiert werden. 

Die Speicherbusbreite kann 8, 16 oder 32 Bit betragen und wird durch Parallelschaltung von 

Speicherbausteinen erreicht. Zusätzlich können gemäß Abbildung 30 RAMs in einer Matrix von 

bis zu vier Bänken und vier Ebenen angeordnet werden, damit selbst mit kleinen RAMs ein großer 

Speicher realisiert werden kann. Auf der anderen Seite werden auch RAMs mit bis zu 14 Bit 

Adreßbreite unterstützt, so daß bereits mit acht Bausteinen der Organisation 256M∗4 ein Speicher 

von 1 GByte RAM bei 32 Bit Breite erreicht wird. Neben solchen “high-end”-Anwendungen sind 

natürlich auch “low-cost”-Bestückungen gemäß Abbildung 31 möglich. 

Bei der Parallelschaltung von Speicherbausteinen sind viele Kombinationen möglich. Bedingung ist 

jedoch, daß der Speicher eine einheitliche Datenwort-Breite hat, und daß die Speicher-Ebenen mit 

RAMs identischer Größe bestückt sind. Die Bänke hingegen dürfen mit RAMs unterschiedlicher 

Größe bestückt werden. 

Die Video-RAMs müssen immer in Bank 0 liegen. Falls mehrere Ebenen vorhanden sind, wird mit 

jedem Video-Datenwort-Takt MSC (vgl. Abschnitt 4.3) ein Video-Datenwort pro Ebene ausgegeben. 

Auf diese Weise können bis zu 128 Bit an Video-Daten pro Pixel geliefert werden. Der auf Seite 

26 beschriebene externe ” Muxer“ (ähnlich Abbildung 20) kann diese mit erhöhter Pixelfrequenz als 

4∗32 Bit ausgeben, so daß ein Pixeltakt von bis zu 120 MHz erreicht werden kann. 

Bei den Schieberegister-Reloads müssen dazu alle vier Ebenen gleichzeitig ein Freigabesignal über 

ACS3..0 erhalten, damit die Schieberegister der VRAMs in allen Ebenen parallel mit neuen Daten 

geladen werden. Das gleiche gilt für Refreshs. 

5.4 Adreßrechnung 

Aus Abbildung 30 wird deutlich, daß beim Zugriff auf ein Speicherwort nicht nur eine RAS-Adresse 

(Zeile) und eine CAS-Adresse (Spalte) übergeben werden muß, sondern daß auch die RAS-Bank 

und die Ebene ausgewählt werden müssen. 

Um trotz der möglichen Bestückung der RAS-Bänke mit RAMs unterschiedlicher Größe (also unterschiedlicher 

RCA-Adreßbreite) einen möglichst gut zusammenhängenden Adreßraum zu 

erreichen, muß sich getrennt für jede RAS-Bank die Lage der RAS-Adreßbits einstellen lassen. 

Dies ist nötig, da bei verschiedenen RCA-Adreßbreiten der RAMs die CAS-Adresse zwar stets 

beim gleichen Adreßbit (von unten) beginnt, aber verschieden lang sein kann. Somit ergeben sich 

für die RAS-Adresse andere Adreßbits, die stets direkt oberhalb der CAS-Adreßbits liegen sollen. 

Zur Bestimmung der RAS-Adreßbits wird zunächst gemäß Tabelle 11 (S. 40) anhand der Registerbits 

RSL geprüft, welche Adreßbits die aktive RAS-Bank auswählen. In der Regel werden diese 

Adreßbits direkt oberhalb der RAS-Adreßbits der größten Speicherbank liegen. Aus dem Wert 

dieser zwei Adreßbits wird nun nach Tabelle 12 bestimmt, welche RAS-Leitung zur Auswahl der 

Bank aktiviert werden muß und welche Registerbits (MOA bis MOD) die RAS-Adresse bestimmen. 

Aus dem Wert dieser (jeweils drei) Bits läßt sich nun nach Tabelle 13 ablesen, welche Adreßbits die 

RAS-Adresse bilden. 

Die CAS-Adresse ergibt sich unabhängig von der RAS-Bank aus der Speicherbusbreite. Bei 32 Bit 

Busbreite werden z. B. A15..A02 als CAS-Adresse verwendet, die unteren zwei Adreßbits steuern 

die CAS-Signale zur Byte-Auswahl.



Lukas Bauer 

 

 

 

 

 

 

 

 

 

3 2 1 0 

RAS 

3 

2 

1 

✲ 

✲ 

✲ 

✲ 

✲ 

✲ 

✲ 

✲ 

✲ 

✲ 

✲ 

✲ 

✲ 

✲ 

 

 

 

✲ 

✲ 

CS 

CS 

CS ✻ CS 

✻ 

✻ 

✻ 

3 2 1 0 

ACS 

Diplomarbeit 


Ebene 0 

RAS 

RAS 

RAS 

RAS 

Bank 3 

A10..0 Steuerung 

✻ ✻ 

Bank 2 


✻ ✻ 

Bank 1 


✻ ✻ 

Bank 0 


✻ ✻ 

✻ 

RCA13..0 Steuerung 

DRAM VRAM 

DRAM 

4M∗8 

D7..0 CAS 

✻ ✻ 

DRAM 

16M∗8 

D7..0 CAS 

✻ ✻ 

DRAM 

1M∗8 

D7..0 CAS 

✻ ✻ 

VRAM 

256k∗8 

SIO7..0 

D7..0 CAS 

✻ ✻ 

TIM 

DRAM 

4M∗8 

D7..0 CAS 

✻ ✻ 

DRAM 

16M∗8 

D7..0 CAS 

✻ ✻ 

DRAM 

1M∗8 

D7..0 CAS 

✻ ✻ 

VRAM 

256k∗8 

SIO7..0 

D7..0 CAS 

✻ ✻ 

DRAM 

4M∗8 

D7..0 CAS 

✻ ✻ 

DRAM 

16M∗8 

D7..0 CAS 

✻ ✻ 

DRAM 

1M∗8 

D7..0 CAS 

✻ ✻ 

VRAM 

256k∗8 

SIO7..0 

D7..0 CAS 

✻ ✻ 

DRAM 

4M∗8 

D7..0 CAS 

✻ ✻ 

DRAM 

16M∗8 

D7..0 CAS 

✻ ✻ 

DRAM 

1M∗8 

D7..0 CAS 

✻ ✻ 

VRAM 

256k∗8 

SIO7..0 

D7..0 CAS 

✻ ✻ 

Abschnitt 5.4 

Seite 39 

✲ 

✲ 

✲ 

✲ 

⎫⎪ ⎬ 128 

Bit 

Video 

Daten 

⎪⎭ 

❄ ❄ ❄ ❄ 

D31..24 D23..16 D15..8 D7..0 3 2 1 0 

CAS 

Abbildung 30: In vier Ebenen können je vier Bänke von DRAMs und VRAMs unterschiedlicher Größe angeschlossen 

werden. Im Beispiel ergeben sich 336 MByte DRAM und 4 MByte VRAM. Eine externe Einheit mit Multiplexer 

kann die 128 Bit breiten Video-Daten als 4∗32 Bit mit erhöhter Geschwindigkeit ausgeben. 

Abbildung 31: In der einfachsten Konfiguration ist 

nur ein 8 Bit breites VRAM vorhanden. Selbstverständlich 

sind auch fast beliebige Mischformen 

möglich. 

RAS 0 

RAS 

Bank 0 


✻ ✻ 

TIM 

✻ 

RCA11..0 Steuerung 

DRAM VRAM 

VRAM 

256k∗8 

SIO7..0 

D7..0 CAS 

✻ ✻ 

✲ 

❄ 

D7..0 CAS 0 

8 Bit 

Video 

Daten



Lukas Bauer 

Diplomarbeit 


Abschnitt 5.5 

Seite 40 

Die verwendeten RAS- und CAS-Adressen sind stets 14 Bit breit. Ist die Adreßbreite der RAMs 

geringer, so werden die obersten Adreßbits von den RAMs ignoriert. Durch die beschriebene Auswahl 

der RAS-Adresse wird jedoch erreicht, daß innerhalb jeder RAS-Bank ein zusammenhängender 

Adreßraum vorliegt. Falls die RAS-Bänke mit RAMs gleicher Größe bestückt sind, ergibt sich sogar 

ein zusammenhängender Gesamtadreßraum. 

RSL 

Adreßbits zur Auswahl 

der RAS-Bank 

”000” A17..A16 

”001” A19..A18 

”010” A21..A20 

”011” A23..A22 

”100” A25..A24 

”101” A27..A26 

”110” A29..A28 

”111” A31..A30 

Tabelle 11: Die Registerbits RSL legen 

fest, welche Adreßbits der Auswahl 

der RAS-Bank dienen. 

RAS-Bank 

RAS 

3 2 1 0 

MOX 

”00” 1 1 1 0 MOA 

”01” 1 1 0 1 MOB 

”10” 1 0 1 1 MOC 

”11” 0 1 1 1 MOD 

Tabelle 12: Abhängig von der RAS- 

Bank werden die Registerbits MOA bis 

MOD ausgewählt, ..... 

MOX RAS-Adresse 

”000” A21..A08 

”001” A22..A09 

”010” A23..A10 

”011” A24..A11 

”100” A25..A12 

”101” A26..A13 

”110” A27..A14 

”111” A28..A15 

Tabelle 13: ..... die bestimmen, welche 

Adreßbits die RAS-Adresse bilden. 

Die Auswahl der Ebene geschieht analog zur Auswahl der RAS-Bank. Hier bestimmen die 

Registerbits ASL (wie in Tabelle 11) die Adreßbits, die die Ebene auswählen. In Abhängigkeit 

von der Ebene werden analog zu Tabelle 12 die Signale ACS3..0 beim Zugriff gesetzt, um genau 

eine Ebene zu selektieren. Ein Analogon zu MOX existiert nicht, da sich die RAS-Adressen nur 

bei verschiedenen RAS-Bänken und nicht bei verschiedenen Ebenen unterscheiden dürfen. 

Im Beispiel aus Abbildung 30 ergibt sich die günstigste Programmierung der Register RSL und 

ASL aus der Adreßlänge der größten RAS-Bank, Bank 2. Bei 32 Bit Speicherbusbreite dienen A1 

und A0 der Byte-Auswahl. Da die Adreßlänge von Bank 2 12 Bit beträgt, bilden A13 bis A2 die 

CAS-Adresse und A25 bis A14 die RAS-Adresse für Bank 2. Daher sollte RSL so programmiert 

werden, daß A27 und A26 die RAS-Bank auswählen, während ASL festlegen sollte, daß A29 und 

A28 die Ebene bestimmen. A31 und A30 haben in diesem Fall keine Funktion. 

5.5 Externe versus interne Host-Daten-Register bei nicht gemultiplextem Host- 

Bus 

Die Spezifikation [1] des Grafikprozessors sieht vor, daß im Fall eines nicht gemultiplexten Host- 

Interfaces bidirektionale, 32 Bit breite Host-Daten-Register mit Tristate-Ausgängen extern angeschlossen 

werden (s. Abbildung 32), um den Datentransfer zwischen Host und Grafikprozessor über 

den Speicherbus zu ermöglichen und so Datenleitungen zu sparen. 

✲ 

Adressen 

Adressen 

Host ✲ TIM ✲ RAM 

✛ 

Steuerung 

Daten 

✲ 

Register 

✛ 

Steuerung 

Daten 

HBW MBW 

❄ Steuerung 

Abbildung 32: Ursprünglich waren in der Spezifikation [1] des Grafikprozessors externe Register für 

den Datenfluß zwischen Host und TIM vorgesehen. 

✛ 

✲ 

✲



Lukas Bauer 

Diplomarbeit 


Steuerung 

✲ 

Adressen 

Adressen 

Host ✲ TIM ✲ RAM 

Daten ✛ ✲ 

✛ 

Steuerung 

Daten 

HBW MBW 

Abbildung 33: Mit internen Registern werden mehr Pins benötigt, die Gesamtschaltung jedoch 

vereinfacht und der Datentransfer beschleunigt. 

✲ 

✲ 

Abschnitt 5.5 

Seite 41 

Für den Fall beispielsweise, daß der Host-Bus 32 Bit breit und der Datenbus 8 Bit breit ist, sollten 

bei Schreibzugriffen die Daten in die Host-Daten-Register getaktet und anschließend in vier Schritten 

in den Speicher übertragen werden. Bei Lesezugriffen sollten vier Bytes nacheinander aus dem 

Speicher in die Host-Daten-Register gebracht werden, um dann gemeinsam vom Host gelesen zu 

werden. 

Eine solche Vorgehensweise ist bei Host-Speicher-Zugriffen auch dann erforderlich, wenn TIMinterne 

Host-Daten-Register verwendet werden. Zugriffe des Hosts auf die Grafikregister hingegen 

können durch Verwendung TIM-interner Host-Daten-Register stark beschleunigt werden. Sie 

können dann mit vollen 32 Bit Breite ablaufen. In der folgenden Übersicht werden Vor- und Nachteile 

interner Host-Daten-Register gegenübergestellt: 

Vorteile interner Host-Daten-Register 

• Acht externe ICs plus Ansteuerlogik können entfallen. Das Gesamtsystem wird preiswerter 

und zuverlässiger. 

• Die Hostzugriffe werden beschleunigt, da das kritische Timing der externen Register entfällt. 

• Es treten keine Konflikte zwischen Zugriffen des Hosts auf Register des Grafikprozessors 

(Host–Tim) und Speicherzugriffen des Grafikprozessors (TIM–RAM) mehr auf, da diese über 

getrennte Busse laufen. Auch die Arbitrierungslogik wird dadurch stark vereinfacht. 

• Ein Pipelining (mit TIM-internem FIFO-Puffer) von Host-Speicher-Transfers ist möglich. 

• Datentransfers bei unterschiedlichen Breiten von Host- und Speicher-Interface werden vereinfacht. 

Host-Register-Transfers können mit der vollen Host-Busbreite erfolgen, auch wenn die 

Speicherbusbreite kleiner als die Host-Busbreite ist. 

Nachteile interner Host-Daten-Register 

• Es werden 32 zusätzliche Pins benötigt, zuzüglich Versorgungsspannungs-Pins, während nur 

8 Pins (die Steuerleitungen für die Register) entfallen. 

• Durch den zusätzlichen Bedarf an Pins wird ein größeres Gehäuse notwendig, das einen geringeren 

Pin-Abstand hat (0,65mm oder 0,5mm statt 0,8mm), so daß präzisere Lötanlagen 

erforderlich werden. 

Aufgrund der überwiegenden Vorteile wurde TIM mit internen Host-Daten-Registern und einem 

(zunächst nur vier Langworte umfassenden) FIFO-Puffer für die zu schreibenden Daten realisiert.



Lukas Bauer 


5.6.1 Steuerung von Host-Zugriffen 

Diplomarbeit 


Abschnitt 5.6 

Seite 42 

Die Steuerung aller Host-Zugriffe auf den Grafikprozessor – des Lesens und Schreibens von Registern 

oder Speicherinhalten – erfolgt im Diagramm TIM ACCESS (Seite 120). 

Mit der fallenden Flanke von AS werden die Adresse, die Daten (bei nicht-gemultiplextem Bus), 

das Register-Select-Signal RS und die Byte-Select-Signale BS3 bis BS0 in interne Register (in die 

Variablen A lat, D lat, RS lat und BS lat) übernommen (T5). Bei Host-Busbreiten unter 32 Bit 

werden zur Bestimmung der Byte-Select-Signale auch die unteren Adreßleitungen herangezogen, 

da in diesem Fall eine Umsetzung des Zugriffs auf eine interne Datenbreite von 32 Bit 

geschieht, wobei nur die adressierten 1 oder 2 Bytes des Langworts über die BS-Signale freigegeben 

werden. Der weitere Zugriff wird auf diese Weise vereinfacht, da weitere Fallunterscheidungen nicht 

mehr nötig werden. 

Abhängig vom Zustand des HWE-Signals bei der fallenden Flanke von AS wird ein Lese- oder 

Schreibzugriff durchgeführt (T1, T13). Bei gemultiplexten Bussen (RS MUX=’1’) wird vorher auf 

die fallende Flanke von DS gewartet. In Abhängigkeit vom Signal RS lat wird dann ein Registerzugriff 

oder ein Speicherzugriff eingeleitet. 

Registerzugriffe erfolgen in den untergeordneten Diagrammen REG READ (S. 121) und 

REG WRITE (S. 122). Während die Register in REG READ als Langworte gelesen werden, 

aus denen anschließend evtl. die richtigen Bytes ausgewählt werden, dürfen in REG WRITE nur 

die Bytes geschrieben werden, die über die BS-Signale freigegeben wurden. Eine Besonderheit bilden 

einige Register, die nur gelesen werden können, sowie einige Konfigurations-Register, die durch 

eine Verriegelung vor unbefugtem Beschreiben geschützt werden können: Ein Schreiben ist nicht 

möglich, wenn das LOCK-Bit im CONFIG-Register gesetzt ist. Der Schutz kann jedoch durch 

Schreiben einer bestimmten Byte-Folge in das CONFIG-Register aufgehoben werden (T3). 

Bei Schreibzugriffen auf den Speicher werden Daten, Adresse und BS-Signale im FIFO-Puffer 

für zu schreibende Daten abgelegt (T10) und der Host-Zugriff sofort beendet. Das Beschreiben der 

RAMs übernimmt eine andere Einheit (s. Abschnitt 5.6.3). Falls der FIFO-Puffer voll ist, wird so 

lange gewartet, bis wieder Platz zum Ablegen des aktuellen Langworts ist. 

Bei Lesezugriffen auf den Speicher hingegen muß immer gewartet werden, bis der Schreibpuffer 

leer ist, da anderenfalls Unstimmigkeiten bei Schreib- und Lese-Zugriffen auf die gleichen 

Daten auftreten könnten. Zur Anforderung der zu lesenden Daten wird die Adresse in A READ 

abgelegt und MEM READ auf ’1’ gesetzt. Wenn die Daten bereitstehen, erfolgt die Rückmeldung 

(READ DONE=’1’) von der Speicherzugriffs-Einheit (Abschnitt 5.6.3). Daraufhin wird der 

Host-Zugriff abgeschlossen. 

Der Handshake über das RDY-Signal erfolgt in T14, T17 und T15 gemäß der Beschreibung in 

Abschnitt 5.2. 

In einem asynchronen Block (Seite 120 rechts) erfolgt für die oben beschriebenen Zugriffe die Umsetzung 

der Schreib- und Lese-Daten auf die Host-Busbreite. Bei 8 Bit Host-Busbreite 

z. B. werden die Daten vom Host auf allen vier Bytes des TIM-internen Daten-Langworts DATA IN 

wiedergegeben, von denen nur eines über BS zum Schreiben freigegeben wird. Die von TIM auszugebenden 

Daten werden anhand der untersten zwei Adreßbits aus dem internen Langwort DATA OUT 

ausgewählt und auf D7...D0 des Host-Busses ausgegeben. Bei 32 Bit Host-Busbreite erfolgt keine 

Umsetzung. Ist jedoch das NUBUS-Bit gesetzt, erfolgt eine Vertauschung der Bytes in der Datenphase.



Lukas Bauer 

Diplomarbeit 


5.6.2 Modellierung eines Hosts zum Test des Handshakes 

Abschnitt 5.6 

Seite 43 

Da der Handshake ein Vorgang ist, bei dem nicht nur TIM vom Host, sondern auch der Host von 

TIM gesteuert (gebremst) wird, ist ein Test des Host-Interfaces mit normalen (fest definierten) 

Testmustern nicht möglich. Daher wurde der Systembus des Hosts ebenfalls unter Speedchart 

modelliert. 

Im Diagramm HOST ACC (S. 117) ist der Zustandsgraf des Systembusses (für einen gemultiplexten 

Bus) zu sehen; die Testmuster werden im Diagramm HOST CTRL (S. 118) generiert. 

Dort werden verschiedene Register- und Speicherzugriffe auf TIM durchgeführt, wobei Host- und 

Speicherbus auch mit verschiedenen Datenwortbreiten getestet werden. 

Die Kommunikation zwischen den Diagrammen erfolgt über die Variablen HOST A (Adresse), 

HOST D (Schreib-Daten), HOST BS (Byte-Maske), HOST RS (Register Select) und den Wert in 

HOST ACTION, der die Art des Zugriffs (lesen, schreiben) angibt. Ist ein Zugriff beendet, wird 

HOST ACTION im Diagramm HOST ACC auf Null gesetzt. 

5.6.3 Steuerung von Speicherzugriffen 

Die eigentlichen Speicherzugriffe – das Schreiben von Daten aus dem FIFO-Puffer in das RAM sowie 

das Lesen des RAMs – werden im Diagramm MEM CYCLES (S. 124) durchgeführt. Ausgelagert 

wurde jedoch die Verwaltung des FIFO-Puffers; sie erfolgt im Diagramm MEM ADDRESS 

(S. 128) oben. Dabei werden asynchron die Adresse RAM ADDR und die Datenbyte-Maske 

CAS MASK ermittelt. Das zu schreibende Daten-Langwort RAM D W wird aus der aktuellen 

Ausgabeposition FIFO OUT des FIFO-Puffers geholt. Bei einem Lesezugriff wird A READ als 

Adresse und CAS READ als Datenbyte-Maske verwendet. 

Ebenfalls asynchron, jedoch im Diagramm ADDR CALC (S. 125), erfolgt die Adreßrechnung 

gemäß Abschnitt 5.4. Ermittelt werden die Speicher-Zeile RAM ROW, die Speicher-Spalte 

RAM COL, sowie die Masken für die Ebenen- und Bank-Auswahl, ACS MASK und RAS MASK. 

Somit stehen alle Daten in der Form zur Verfügung, in der sie im Rahmen eines Speicherzugriffs 

an die RAMs übergeben werden können. 

Schreib- und Lese-Zugriffe erfolgen bei dynamischen RAMs grundsätzlich über einen RAS-CAS- 

Zyklus, in dessen Verlauf die Speicher-Zeile und die Spalte übergeben werden (vgl. Abb. 35, S. 71). 

Dieser Zyklus entspricht im Diagramm MEM CYCLES (S. 124) dem Weg von cold stb über 

RAS1, RAS2, CAS1, CAS2 und CAS3 zurück zu cold stb. Im Verlauf des Zyklus werden auch die 

Schreibdaten ausgegeben (Eintritt in CAS1) oder die Lesedaten von Speicherbus gelesen (Austritt 

aus CAS3). 

Falls die Host-Busbreite über der Speicherbusbreite liegt, kann es erforderlich werden, daß mehrere 

Speicherzugriffe durchgeführt werden. Die vier Bits der Datenbyte-Maske CAS MASK geben dabei 

grundsätzlich an, auf welche Bytes innerhalb eines Langworts zugegriffen werden soll. Bei kleinen 

Speicherbusbreiten wird stets mit dem Zugriff auf das unterste Speicherwort begonnen. Nach 

dem Zugriff werden die dabei übertragenen Datenbytes in der vier Bit umfassenden Variablen 

CAS DONE markiert und eventuell sofort der nächste Zugriff eingeleitet. 

Da häufig unmittelbar nacheinander auf verschiedene Daten aus einer Speicherzeile eines RAMs 

zugegriffen wird, bieten moderne dynamische RAMs zur Zeiteinsparung die Möglichkeit, Zugriffe 

im “Fast Page Mode” durchzuführen (s. Abb. 37, S. 73), wobei innerhalb eines RAS-Zyklus auf 

mehrere Datenworte zugegriffen werden kann. Zur Adressierung der Daten werden innerhalb des 

RAS-Zyklus lediglich die Spaltenadressen in getrennten CAS-Zyklen übergeben.



Lukas Bauer 

Diplomarbeit 


Abschnitt 5.6 

Seite 44 

Falls Zugriffe im Page Mode freigegeben sind (Registerbit PEN=’1’), hält TIM nach einem Speicherzugriff 

die RAS-Leitung aktiv (Zustand hot stb). Falls der nächste Zugriff auf dieselbe RAS- 

Adresse (LAST ROW) in derselben Bank (LAST RAS) und Ebene (LAST ACS) erfolgt, wird 

lediglich ein neuer CAS-Zyklus eingeleitet (T10). Sobald sich der Zugriff aber in RAS-Adresse, 

Bank oder Ebene vom vorigen Zugriff unterscheidet, wird RAS deaktiviert, zum Zustand cold stb 

zurückgekehrt und ein neuer RAS-Zyklus eingeleitet. 

Erfolgen Schreib- und Lesezugriffe auf die gleiche RAS-Adresse, so werden sie ebenfalls in einem 

gemeinsamen RAS-Zyklus durchgeführt. Diese gemischte Durchführung von Schreib- und 

Lesezugriffen im Page Mode wird für dynamische RAMs von Samsung [10] garantiert. Im 

Datenbuch von Toshiba [9] werden beliebig gemische Zugriffe nicht erwähnt, die prinzipielle Arbeitsweise 

der Ansteuerlogik für die Speichermatrix dürfte die Durchführbarkeit dieser Zugriffe aber 

garantieren. 

Der untere Teil des Diagramms MEM ADDRESS sowie die Diagramme BIT SHIFT, BIT MASK, 

GPU FIFO R, GPU FIFO W und PIXBLT PATH der Controller-Einheit sind nur für die Bearbeitung 

von Grafik-Befehlen von Bedeutung. Sie werden in Abschnitt 6.3.3.4 erläutert. Gleiches 

gilt im Diagramm MEM CYCLES für die Signale GPU READ, GPU WRITE, MEM GREAD und 

MEM GWRITE und für die Zustände RMW1 bis RMW3. 

Einige charakteristische Simulationsergebnisse sind auf den Abbildungen 115 bis 118 (S. 145 

bis 148) zu sehen. Durchgeführt werden hier jeweils ein Schreibzugriff auf ein volles Langwort, 

ein Schreibzugriff auf zwei Bytes des folgenden Langworts, ein Schreibzugriff auf ein Byte eines 

Langworts mit anderer RAS-Adresse sowie ein Lesezugriff auf zwei nicht benachbarte Bytes des 

zuletzt geschriebenen Langworts. 

Abbildung 115 zeigt diese Zugriffe bei 32 Bit Speicherbusbreite. Man erkennt die getrennten RAS- 

CAS-Zyklen und die Maskierung der Bytes über die vier CAS-Signale, deren Werte hier zu einer 

Hexadezimal-Ziffer zusammengefaßt wurden. Der Wert CAS=3 z. B. bedeutet, daß CAS3 und 

CAS2 aktiv ’0’ sind, während CAS1 und CAS0 inaktiv ’1’ sind. 

In Abbildung 116 ist der Fast Page Mode freigegeben. Daher können die ersten und die letzten 

beiden Zugriffe jeweils im gleichen RAS-Zyklus durchgeführt werden, da die RAS-Adressen übereinstimmen. 

Abbildung 117 zeigt die Zugriffe bei 8 Bit Speicherbusbreite. Man erkennt bis zu vier getrennte 

RAS-CAS-Zyklen pro Langwort-Zugriff, bei denen die CAS-Adresse automatisch erhöht wird. Auch 

die Wirkung des FIFO-Puffers für zu schreibende Daten ist deutlich zu sehen. Die Schreibzugriffe 

können Host-seitig (Signale oben) schnell abgeschlossen werden. Vor der Durchführung des Lesezugriffs 

wird jedoch auf den Abschluß der Speichertransfers gewartet. 

In Abbildung 118 schließlich erfolgen die Zugriffe wieder im Fast Page Mode, so daß z. B. die ersten 

4+2 Zugriffe in einem gemeinsamen RAS-Zyklus durchgeführt werden können. 

Im Diagramm MEM CYCLES fehlt zunächst die Kommunikation mit der Arbitrierungslogik 

der Video-Einheit. Wenn die Einheiten später zu einem Design zusammengefaßt werden, dürfen 

Speicherzugriffe hier nur erfolgen, wenn keine Reload- oder Refresh-Zyklen angekündigt oder angefordert 

wurden.



Lukas Bauer 

6 Die Prozessor-Einheit 

6.1 Aufgaben der Prozessor-Einheit 

Diplomarbeit 


Abschnitt 6.1 

Seite 45 

Die Prozessor-Einheit hat die Aufgabe, die folgenden Grafikbefehle selbständig zu bearbeiten: 

• Block Move: Kopieren eines linearen Datenblocks 

• Fill: Einfarbiges Füllen eines zweidimensionalen Bildschirmbereichs 

• Pattern Fill: Füllen eines zweidimensionalen Bildschirmbereichs mit einem mehrfarbigem 

Füllmuster 

• Pattern Fill Transparent: Füllen eines zweidimensionalen Bildschirmbereichs mit einem 

mehrfarbigem Füllmuster, das transparente Bereiche enthalten kann 

• Pixel Block Transfer (PixBlT): Kopieren eines zweidimensionalen Bildschirmbereichs mit 

beliebiger Verknüpfung von Quell- und Zieldaten 

• Pixel Block Transfer with Binary Expansion: Kopieren eines zweidimensionalen Bildschirmbereichs 

mit beliebiger Verknüpfung von Quell- und Zieldaten, wobei ein bzw. zwei 

Quelldaten-Bits eine von zwei bzw. vier Farben zum Beschreiben des Zielbereichs auswählen 

• Clip: Anpassung der Grenzen eines zweidimensionalen Bildschirmbereichs an ein vorgegebenes 

Zielfenster 

• VRAM Copy: Schnelles Kopieren ganzer VRAM-Zeilen unter Verwendung der VRAM- 

Schieberegister 

• VRAM Block Fill: Schnelles Füllen eines linearen Datenblocks im VRAM unter Verwendung 

des Block-Modus der VRAMs 

• VRAM Load Color Register: Laden der Color-Register der VRAMs mit einer Füllfarbe 

für den “VRAM Block Fill”-Befehl 

Bei allen Befehlen werden vom Host zunächst die Parameter des Befehls und dann der Befehls- 

Opcode in die TIM-internen Register geschrieben (vgl. Tabelle 18 auf Seite 68). Daraufhin führt 

TIM den Befehl aus und löscht nach Ende der Bearbeitung das Befehlsregister. 

Alle Befehle, die auf zweidimensionalen Bildschirmbereichen arbeiten, unterstützen zwei Adressierungsarten 

(hier am Beispiel des Zielbereichs): 

• Bei XY-Adressierung werden die Startkoordinaten DXADR und DYADR des Bildschirmbereichs 

angegeben. Abhängig von der Farbtiefe PSIZE eines Pixels und der Bit-Adresse 

DSTART bit des Bildschirmanfangs ergibt sich die physikalische Bit-Adresse des ersten Pixels 

zu 

DADRL L := DSTART bit + (DYADR · DINC + DXADR) · PSIZE . 

• Bei linearer Adressierung wird die lineare Pixel-Adresse DADR des Bildschirmbereichs 

angegeben. In diesem Fall ergibt ich die physikalische Bit-Adresse des ersten Pixels zu 

DADRL L := DSTART bit + DADR · PSIZE . 

Bei beiden Adressierungsarten wird die Größe des zweidimensionalen Bildschirmbereichs in X- und 

Y-Richtung in Pixeln angegeben (DX und DY, vgl. Tabelle 18 auf Seite 68). Bei den Befehlen 

hingegen, die auf linearen Datenblöcken arbeiten, wird die Bereichslänge in Pixeln angegeben.



Lukas Bauer 

Diplomarbeit 


Abschnitt 6.2 

Seite 46 

Bei Kopierbefehlen, die auf zweidimensionalen Bildschirmbereichen arbeiten, kann mit unterschiedlichen 

Startadressen und Zeilenlängen von Quell- und Zielbildschirm gearbeitet werden (vgl. Register 

SSTART, DSTART, SINC und DINC, Tabelle 18). Dadurch wird es möglich, verschiedene 

virtuelle Bildschirme unterschiedlicher Auflösung gleichzeitig im Speicher zu halten. 

Bei allen Kopierbefehlen erfolgen die Speicherzugriffe, falls freigegeben, im Fast Page Mode. Da 

dies beim abwechselnden Lesen und Schreiben von Daten aus unterschiedlichen Speicherbereichen 

nicht möglich wäre, werden die Daten erst in einer Page-Mode-Sequenz in einen internen Puffer 

gelesen, um dann in einer weiteren Page-Mode-Sequenz geschrieben zu werden. Dies bedeutet einen 

erheblichen Geschwindigkeitsvorteil. 

Aus Zeitgründen konnten im Rahmen dieser Arbeit nur zwei Befehle implementiert werden: der 

“Clip”-Befehl und der sehr umfangreiche “Pixel Block Transfer”-Befehl. 

6.2 Funktionsweise der implementierten Befehle 

6.2.1 Der “Clip”-Befehl 

Der Clip-Befehl dient dazu, die kartesischen Koordinaten des Zielbereichs eines Befehls, der auf 

zweidimensionalen Bildschirmbereichen arbeitet, auf ein vorgegebenes Zielfenster zu beschränken. 

Dies ist bei grafischen Benutzeroberflächen häufig erforderlich. 

Vor Ausführung des Befehls müssen in den Registern WSTARTX, WSTARTY, WENDX und 

WENDY die Koordinaten des Zielfensters angegeben werden. 

Bei der Ausführung des Befehls ermittelt TIM aus den Koordinaten des linken oberen Pixels (den 

Startkoordinaten) des Zielbereichs, die in DXADR und DYADR stehen, sowie den Ausdehnungen 

DX und DY des Zielbereichs die Start- und Endkoordinaten des Zielbereichs. 

Anschließend werden alle vier Koordinaten von Zielbereich und Zielfenster verglichen. Liegt eine 

Koordinate des Zielbereichs außerhalb des Zielfensters, so wird das Registerbit WINT gesetzt und, 

falls freigegeben, ein Interrupt ausgelöst. Außerdem wird die Koordinate des Zielbereichs durch 

den Wert der entsprechenden Zielfenster-Koordinate ersetzt. Dabei wird eine Rückrechnung in 

Startkoordinate und Ausdehnung erforderlich. 

Liegt kein Pixel der Zielbereichs innerhalb des Zielfensters, wird das Registerbit CINT gesetzt und 

evtl. ein Interrupt ausgelöst. In diesem Fall kann auf die Ausführung des sonst sofort nachfolgenden 

Grafikbefehls verzichtet werden. 

Nach der Anpassung der Koordinaten werden die kartesischen Startkoordinaten des Zielbereichs in 

eine lineare Pixeladresse umgerechnet, damit im Anschluß an den Clip-Befehl sofort ein Befehl mit 

linearer Adressierung ausgeführt werden kann. 

6.2.2 Der “Pixel Block Transfer”-Befehl 

Der “Pixel Block Transfer”-Befehl ist ein sehr mächtiger Kopierbefehl für zweidimensionale Bildschirmbereiche. 

Er erlaubt neben dem einfachen Kopieren auch vielfältige Möglichkeiten der 

Verknüpfung von Quell- und Zieldaten gemäß Tabelle 14. Zusätzlich kann angegeben werden, 

in welcher horizontalen und vertikalen Richtung die Daten bearbeitet werden sollen (Registerbits 

PBH und PBV, Tabelle 18, S. 68). Dies ist erforderlich, damit bei Überlappungen von Quellund 

Zielbereich in jedem Fall garantiert werden kann, daß keine Daten im Überlappungsbereich 

überschrieben werden, die noch nicht gelesen wurden.



Lukas Bauer 

S 

4 3 2 1 0 

Diplomarbeit 


Datenverknüpfung 

0 0 0 0 0 Ziel = Quelle 

0 0 0 0 1 Ziel = Ziel OR Quelle 

0 0 0 1 0 Ziel = Ziel XOR Quelle 

0 0 0 1 1 Ziel = Ziel + Quelle (8-Bit-weise für 8-Bit-Colormap oder 24-Bit-RGB) 

x x 1 x x zusätzliche Invertierung der Quelldaten 

x 1 x x x zusätzliche Invertierung der ursprünglichen Zieldaten 

1 x x x x zusätzliche Invertierung der Verknüpfung von Quell- und Zieldaten 

Tabelle 14: Die Registerbits S4 bis S0 bestimmen beim PixBlT-Befehl die Verknüpfung von Quellund 

Zieldaten. 


6.3.1 Befehlsauswahl 

Abschnitt 6.3 

Seite 47 

Die Auswahl der von der Prozessor-Einheit auszuführenden Grafik-Befehle erfolgt im Diagramm 

GP CMD (S. 134) anhand des Opcodes im COMMAND-Register. Nach der Befehlsausführung, 

beim Eintritt in den Zustand stdby, wird das COMMAND-Register wieder gelöscht. 

6.3.2 Realisierung des “Clip”-Befehls 

Die Realisierung des Clip-Befehls ist im Diagramm CLIP (S. 135) zu sehen. Dort wird zunächst 

geprüft (T5), ob möglicherweise alle Pixel des Bildschirmbereichs außerhalb des vorgegebenen Fensters 

liegen. Dies ist der Fall, sobald eine Begrenzung des Zielbereichs jenseits der gegenüberliegenden 

Grenze des Zielfensters liegt. In diesem Fall wird ein Interrupt (WINT, Fenster leer) ausgelöst 

und der Befehl abgeschlossen. 

Anderenfalls wird (im asynchronen Block unten rechts) für jede Bereichsgrenze (XS=linke, 

XE=rechte, YS=obere, YE=untere Begrenzung) festgestellt, ob die Grenze des Zielbereichs außerhalb 

des vorgegebenen Zielfensters liegt. Ist dies der Fall, wird das entsprechende Signal, z. B. 

XS viol, gesetzt. 

Die Anpassung der entsprechenden Grenzen an das Zielfenster erfolgt dann in T4. Entgegen dem 

in Abschnitt 6.2.1 beschriebenen Verfahren (Bestimmung der neuen Bereichsgrenzen und Rückrechnung 

in Startkoordinaten und Ausdehnungen) erfolgt hier in einem Schritt die Berechnung der 

angepaßten Startkoordinaten und Ausdehnungen. 

In T2 schließlich erfolgt die Umrechnung der XY-Adresse des Zielbereichs in eine lineare Pixel- 

Adresse. Hierbei wird auf den Wert DADR P aus dem Diagramm DADR SPLIT (S. 108) zurückgegriffen, 

dessen Funktion im folgenden Abschnitt erläutert wird. 

Die eigentliche Auslösung von Interrupts geschieht im Diagramm INTERRUPT (S. 132). Dabei 

wird in Abhängigkeit von der Art des Interrupts ein Bit im STATUS-Register gesetzt. Außerdem 

wird, falls im IMASK-Register der entsprechende Interrupt freigegeben ist, die INT-Leitung 

aktiviert, bei der es sich um ein Open-Drain-Signal handelt. 

Die Simulation konnte beim Clip-Befehl unter Speedchart anhand von numerischen Ergebnissen 

erfolgen. Auf die Wiedergabe der (korrekten) Werte kann verzichtet werden.



Lukas Bauer 

Diplomarbeit 


6.3.3 Realisierung des “Pixel Block Transfer”-Befehls 

6.3.3.1 Umwandlung der Bereichsgrenzen in lineare Pixel-Adressen 

Abschnitt 6.3 

Seite 48 

Als Befehlsparameter beim Pixel Block Transfer wird in den Registern SADR und DADR stets 

die Adresse des linken oberen Pixels des Quell- und Zielbereichs übergeben; beim PIXBLT L als 

lineare Pixeladresse, beim PIXBLT XY als XY-Adresse. Da die Befehlsbearbeitung aber je nach 

Programmierung der Registerbits PBH und PBV evtl. in einer anderen Ecke der Bereiche beginnen 

soll, kann zu Beginn der Befehlsausführung eine Umrechnung notwendig werden. Bei 

linearer Adressierung und bei XY-Adressierung müssen zunächst die linearen Pixeladressen, später 

die Langwort-Adressen der Bildschirmecken berechnet werden, in denen die Befehlsausführung 

beginnen soll. 

Benötigt werden für diese Berechnungen unter anderem die linearen Pixeladressen SADR P 

und DADR P des linken oberen Pixels von Quell- und Zielbereich. Diese sind beim 

PIXBLT L vorgegeben, während sie beim PIXBLT XY ermittelt werden müssen: 

Quellbereich: SADR P := SYADR · SINC + SXADR 

Zielbereich: DADR P := DYADR · DINC + DXADR 

Zu diesen Adressen muß, falls PBH=’1’ ist, der Wert (DX–1), die um 1 verminderte Bereichsbreite, 

addiert werden. Ist PBV=’1’, so ist die um eins verminderte Bereichshöhe zu addieren, die zuvor 

durch Multiplikation mit der Zeilenlänge in Pixel umgerechnet werden muß. Die zu addierenden 

Werte SY P bzw. DY P ergeben sich also wie folgt: 

Im Quellbereich: SY P := (DY − 1) · SINC 

Im Zielbereich: DY P := (DY − 1) · DINC 

Die Berechnung dieser vier Werte macht jeweils eine Multiplikation mit SINC bzw. DINC, den 

Zeilenlängen von Quell- und Zielbildschirm, erforderlich. Da eine volle Multiplikation mit 16·16 Bit 

jedoch sehr aufwendig wäre, wurde entsprechend der Spezifikation [1] eine Einschränkung vorgenommen: 

Die Zeilenlänge muß eine Zweierpotenz oder die Summe zweier Zweierpotenzen sein. Dies 

bedeutet, daß in einem Faktor der Multiplikation höchstens zwei Bits gesetzt sein dürfen, so daß 

sich die Multiplikation auf eine Addition von zwei (statt sechzehn) Summanden reduziert, die durch 

Bit-Schiebefunktionen aus dem zweiten Faktor hervorgehen. 

Die vier Werte SADR P, DADR P, SY P und DY P werden in den Diagrammen SADR SPLIT, 

DADR SPLIT, SY SPLIT und DY SPLIT (Seiten 137 bis 140) unter Verwendung eines so 

reduzierten Multiplikationsalgorithmus berechnet. Dabei werden z. B. zur Berechnung von 

SADR P zunächst die beiden Summanden SADR P HI und SADR P LO ermittelt, indem der 

zweite Faktor der Multiplikation, hier SYADR, um jeweils die Anzahl von Bits nach links geschoben 

wird, die den Positionen der beiden gesetzten Bits im ersten Faktor, hier SINC, entspricht. Die 

gesetzten Bits werden dabei gefunden, indem SINC von oben bzw. von unten nach dem ersten 

gesetzten Bit durchsucht wird. Ist nur ein Bit gesetzt, wird ein Summand auf Null gesetzt. Die 

ermittelten Summanden können nun zum Produkt (SYADR·SINC) addiert werden; wird zusätzlich 

SXADR addiert, ergibt sich der gesuchte Wert für SADR P. 

Im Diagramm AREA TO PIX (S. 141) erfolgt nun die Berechnung der Pixel-Adressen, an denen 

die Befehlsausführung beginnen soll. Sind z. B. PBV=’1’ und PBH=’1’ (Start in der rechten unteren 

Ecke), so ist die Startadresse des Zielbereichs DADR P + DY P + (DX – 1), wie in der 

untersten Zeile des Diagramms zu lesen ist. Abhängig davon, ob ein Befehl in linearer Adressierung 

(COMMAND(0)=’1’) oder XY-Adressierung (COMMAND(0)=’0’) vorliegt, werden oben



Lukas Bauer 

Diplomarbeit 


Abschnitt 6.3 

Seite 49 

im Diagramm die bereits vorliegenden linearen Adressen SADR und DADR oder die errechneten 

linearen Adressen SADR P und DADR P ausgewählt und in der Berechnung unten verwendet. 

Bestimmt werden zunächst unabhängig von PBH die Adressen der linken und rechten Ecken der 

Bereiche, da bei jeder horizontalen Bearbeitungsrichtung die Start- und die Endadresse benötigt 

werden. 

6.3.3.2 Zeilenweise Bearbeitung des Befehls 

Da bei der Ausführung des PixBlT-Befehls mit der ersten Zeile begonnen werden soll, für die die 

Pixel-Adressen der Ränder, SADR L, SADR R, DADR L und DADR R, soeben berechnet wurden, 

werden diese Werte beim Eintritt in das Diagramm PIXBLT (S. 136) in die Variablen CL SADR L, 

CL SADR R, CL DADR L und CL DADR R übertragen, die im folgenden die Adressen des linken 

und rechten Pixels der augenblicklich zu bearbeitenden Zeile angeben. Beim Übergang zur 

nächsten Zeile (T8) werden die Variablen entsprechend der vertikalen Bearbeitungsrichtung PBV 

jeweils um die Zeilenlänge erhöht bzw. erniedrigt. Ein Zähler LINCNT, der zu Beginn auf die 

Anzahl der Zeilen initialisiert wurde, steuert dabei die Wiederholungen. 

Für jede Zeile geschieht im Diagramm PIX TO BIT (S. 142) die Umrechnung der Pixel-Adressen 

in Langwort-Adressen in Abhängigkeit von der Farbtiefe PSIZE eines Pixels. Ermittelt werden 

hier die Langwort-Adressen des linken und des rechten Randes der aktuellen Zeile von Start- und 

Zielbereich, SADRLW L bis DADRLW R. 

Zusätzlich werden für die ersten bzw. letzten Bits, die zu Quell- und Zielzeile gehören, die Bit- 

Positionen innerhalb der Langworte, SBOS L bis DBOS R, bestimmt, damit beim Kopieren auf 

Langwort-Basis ∗ die ungültigen Bits ausmaskiert werden können. 

6.3.3.3 Datenfluß beim Kopieren der Zeilendaten 

Falls die Daten in Quell- und Zielbereich an Langwortgrenzen oder zumindest an der gleichen 

(Bit-)Position innerhalb von Langworten beginnen, ist ein Kopieren der Daten auf einfache Weise 

möglich. Im allgemeinsten Fall aber beginnen die Daten an unterschiedlichen Positionen, so daß 

ein bitweises Verschieben der Daten notwendig wird, wobei sich die Daten eines Langworts im 

Zielbereich aus den Daten zweier Langworte des Quellbereichs zusammensetzen. Ein Beispiel für 

den Datenfluß in diesem Fall ist in Abbildung 34 dargestellt. 

Das Kopieren der Zeilendaten beginnt stets damit, daß die Quelldaten gelesen und in einem Lese- 

Puffer so abgelegt werden, daß die Bit-Positionen bereits denen der Zieldaten entsprechen. Der 

Lese-Puffer umfaßt 9 (in Abbildung 34 nur 4) Langworte. Da ein Bit-genaues Einsetzen der gelesenen 

Daten in eine beliebige Position innerhalb des Lese-Puffers möglich sein muß, wäre hierfür 

ein Multiplexer erforderlich, der die Langworte an jeder von 9 · 32 = 288 Positionen ausgeben 

kann. Um den Aufwand zu verringern, erfolgt das Einsetzen der Daten in den Puffer stattdessen 

in zwei Schritten: Die gelesenen Daten (DATA OUT, Abb. 34) werden zunächst an die richtige 

Bit-Position innerhalb der Langworte S HI LW und S LO LW gebracht, die dann an den richtigen 

Langwort-Positionen in den Lese-Puffer eingefügt werden. 

Die Verschiebung an die korrekte Bit-Position erfolgt asynchron im Diagramm BIT SHIFT 

(S. 126). Dabei bestimmt die Differenz (DBOS L – SBOS L) der Bit-Offsets, die bei Ziel- und 

Quelldaten zwischen der linken Bereichsgrenze und der nächsten Langwortgrenze bestehen, die 

Position, auf der das Langwort DATA OUT in S HI LW und S LO LW eingetragen wird. 

∗ In der Prozessor-Einheit werden alle Kopierbefehle auf Langwort-Basis bearbeitet. Die eigentlichen Speicherzugriffe 

erfolgen jedoch in der Controller-Einheit (vgl. Abschnitt 6.3.3.4), wo eine Umsetzung auf die Speicherbusbreite 

erfolgt.



Lukas Bauer 

Diplomarbeit 


Abschnitt 6.3 

Seite 50 

Da S HI LW und S LO LW mit Nullen aufgefüllt werden, ist ein Zusammenfügen der Langworte 

aus dem Quellbereich im Lese-Puffer einfach möglich, indem die Werte aus S LO LW in den Lese- 

Puffer geschrieben und die Werte aus S HI LW mit dem Inhalt des Lese-Puffers oder-verknüpft 

werden (Abb. 34, Mitte). 

Ist der Bit-Offset SBOS L im Quellbereich größer als der im Zielbereich, tritt wie in der Abbildung 

der Fall ein, daß die Daten aus S HI LW beim ersten Langwort keine gültigen Daten enthalten. 

Somit müssen die Daten aus S LO LW an die erste Position des Lese-Puffers geschrieben werden. 

Anderenfalls müssen die Daten aus beiden Langworten an den ersten beiden Positionen eingetragen 

werden. 

Das Kopieren der Daten aus dem Lese-Puffer in den Zielbereich kann nun auf Langwortbasis 

geschehen. Falls die Bereichsgrenzen mit Byte-Grenzen zusammenfallen, kann auf ein Lesen, 

Ausmaskieren und Zurückschreiben der Randdaten, wie es in Abbildung 34 oben dargestellt ist, 

verzichtet werden, da die Randdaten dann über die CAS-Signale byteweise ausmaskiert werden 

können. 

Zielbereich: 

Lese-Puffer: 

Quellbereich: 

DBOS ✛✲ 

L ✛DBOS ✲R 

0 ... 0 1 ............................... 1 1 ................ 1 0 ................... DBMASK L DBMASK R 

0 

✻ 

❄ 

DATA OUT DATA OUT 

✻ ✻ ✻ ✻ 

 

✻ ✻ ✻ 

✻ 

(or) (or) (or) 

✻ 

( DBOS L – SBOS L ) 

✲ 

✛ SBOS L 

✻ 

✻ ✻ 

Langwort-Multiplexer, 2 Langworte auf 2 aus 9 (hier 2 aus 4) Positionen 

✲ 

 

✻ 

 

 

✻ 

 

0 ....................... 0 0 ........... 0 S HI LW / S LO LW 

✻ 

BIT SHIFT, Bit-Multiplexer, 

32 Bit auf 32 aus 64 Positionen 

✻ 

DATA OUT 

✻RAM-Lese-Daten 

Abbildung 34: Beispiel für den Datenfluß beim Kopieren einer Zeile mit dem PixBlT-Befehl, wobei Quell- und 

Zieldaten an unterschiedlichen Positionen relativ zum Langwort-Anfang beginnen 

✻ 

❄



Lukas Bauer 

Diplomarbeit 


Abschnitt 6.3 

Seite 51 

Die Speicherzugriffe beim Kopieren der Daten sowie die Verknüpfung von Quell- und Zieldaten 

werden von der Controller-Einheit übernommen. Auf diese Weise können die dort vorhandenen 

Einheiten für Adreßrechnung und Speicherzugriffe mit verwendet werden. Die Prozessor- 

Einheit muß der Controller-Einheit lediglich mitteilen, an welchen Adressen die Quell- und Zieldaten 

beginnen. Dies geschieht in T3 im Diagramm PIXBLT (S. 136) über die Variablen SADRLW C 

und DADRLW C, die je nach horizontaler Bearbeitungsrichtung PBH auf die Langwort-Adressen 

der linken oder rechten Zeilengrenzen in Quell- und Zielbereich gesetzt werden. 

Anschließend werden so viele Daten aus dem Quellbereich von der Controller-Einheit angefordert, 

daß 8 Langworte des Lese-Puffers nach dem Lesen vollständig mit gültigen Daten gefüllt sein 

werden. Falls der Bit-Offset SBOS L größer als DBOS L ist, müssen dazu nicht 8, sondern 9 

Langworte angefordert werden. 

Die Anforderung erfolgt in T3 im Diagramm PIXBLT, indem die Variable GPU RNUM auf die Anzahl 

der zu lesenden Langworte und GPU READ auf ’1’ gesetzt wird. Die Daten werden daraufhin 

von der Controller-Einheit (s. nächster Abschnitt) mit automatischer Erhöhung der Langwort- 

Adresse SADRLW C aus dem RAM gelesen und an den richtigen Positionen im Lese-Puffer abgelegt. 

Auch der Schreib-Zeiger GPU FIFO IN für den Lese-Puffer, der in T3 initialisiert wurde, 

wird von der Controller-Einheit automatisch erhöht. 

Falls beim Lesen der Quelldaten das Ende der aktuellen Zeile (Langwort-Adresse SADRLW C = 

SADRLW R) erreicht wird, bricht die Controller-Einheit den Lesevorgang ab und löscht die Variable 

GPU READ. Letzteres geschieht auch, wenn der Vorgang normal abgeschlossen wurde. 

Das Schreiben der Daten in den Zielspeicher wird daraufhin eingeleitet, indem in T6 im Diagramm 

PIXBLT das Signal GPU WRITE auf ’1’ und GPU WNUM auf 8 gesetzt wird. GPU WNUM 

gibt dabei an, daß die Controller-Einheit 8 Langworte in den Zielbereich schreiben soll, wenn 

nicht vorher das Zeilenende erreicht wird. Dabei erfolgt in der Controller-Einheit automatisch 

die korrekte Verknüpfung von Quell- und Zieldaten gemäß Tabelle 14. Falls, wie im Beispiel aus 

Abbildung 34, die Verknüpfung ” Quelle = Ziel“ ausgewählt wurde, werden dabei nur die Randdaten 

des Zielbereichs evtl. vor dem Schreiben gelesen. Anderenfalls werden alle Daten des Zielbereichs 

zunächst gelesen, mit den Quelldaten aus dem Lese-Puffer verknüpft und dann zurückgeschrieben. 

Das Lesen von Quelldaten und das Schreiben wiederholen sich nun so lange, bis beim Schreiben das 

Zeilenende erreicht wird. Dabei wird (Diagramm PIXBLT, S. 136) zwischen den Zuständen read 

und write gewechselt. Als Kennzeichen für ein Erreichen des Zeilenendes wird in der Controller- 

Einheit die Variable GPU WNUM auf den Wert 15 gesetzt. Falls keine weiteren Zeilen folgen (T8), 

wird die Befehlsausführung damit beendet. 

Der Fall, in dem die Daten von rechts nach links bearbeitet werden (PBH=’1’), ergibt sich analog 

(T3). 

6.3.3.4 Erweiterte Speicherzugriffs-Möglichkeiten der Controller-Einheit 

Die Controller-Einheit muß somit zwei neue, komplexe Arten des Speicherzugriffs beherrschen: 

• Wenn GPU READ=’1’ ist, müssen Quelldaten ab der Langwort-Adresse SADRLW C gelesen 

und im Lese-Puffer, um (DBOS L – SBOS L) Bits verschoben, abgelegt werden, damit die 

Bit-Positionen der Daten denen im Zielbereich entsprechen. Dabei müssen die Quelladresse 

SADRLW C und der Pufferzeiger GPU FIFO IN automatisch erhöht werden. Die Anzahl 

der zu lesenden Langworte richtet sich nach GPU RNUM, wenn nicht vorher das Zeilenende 

erreicht wird. Am Ende der Bearbeitung muß GPU READ gelöscht werden.



Lukas Bauer 

Diplomarbeit 


Abschnitt 6.3 

Seite 52 

• Ist GPU WRITE=’1’, müssen die Daten aus dem Puffer mit korrekter Verknüpfung 

von Quell- und Zieldaten in den Zielbereich geschrieben werden, wobei die Zieladresse 

DADRLW C und der Pufferzeiger GPU FIFO OUT automatisch erhöht werden. 

Falls die aktuelle Zieladresse mit der Adresse des linken oder rechten Randes der Zielzeile übereinstimmt, 

müssen evtl. Randdaten, bei Übereinstimmung von linker und rechter Langwort- 

Adresse sogar an beiden Rändern des gleichen Langworts, vor dem Schreiben gelesen, ausmaskiert 

und in die zu schreibenden Daten bitweise eingeblendet werden, wenn nicht ein 

Ausmaskieren auf Byte-Basis über die CAS-Signale möglich ist. 

Die Anzahl der zu schreibenden Langworte richtet sich nach GPU WNUM, wenn nicht vorher 

das Zeilenende erreicht wird. Am Ende der Bearbeitung muß GPU WRITE gelöscht werden. 

Wurde das Zeilenende erreicht, muß GPU WNUM als Kennzeichen hierfür auf 15 gesetzt 

werden. 

Für die Lesezugriffe wird im Diagramm MEM ADDRESS (S. 128, Mitte) die Adresse 

RAM ADR des Zugriffs aus der aktuellen Langwort-Adresse SADRLW C ermittelt. Außerdem wird 

die CAS-Maske bestimmt, damit bei einer Umsetzung auf Byte-Zugriffe keine unnötigen Speicherzyklen 

durchgeführt werden. Herangezogen werden dabei evtl. die CAS-Masken SCMASK L und 

SCMASK R für das linke bzw. rechte Langwort der Zeile, die asynchron im Diagramm BIT MASK 

(S. 127, unten) ermittelt werden. Für Langworte, die nicht am Zeilenrand liegen, wird jedoch der 

Wert ”0000” (alle Bytes selektiert) als CAS-Maske verwendet. 

Im Diagramm MEM CYCLES (S. 124) erfolgen die eigentlichen Speicherzugriffe nun in derselben 

Weise wie bei Lesezugriffen des Hosts. Allerdings wird in T4 das Signal GPU READ DONE gesetzt, 

falls keine weiteren Teile des Langworts gelesen werden müssen. Daraufhin wird die Einheit im 

Diagramm GPU FIFO R (S. 129) aktiv. Dort werden die Adresse des Zugriffs und der Puffer- 

Zeiger erhöht, es wird überprüft, ob das Zeilenende erreicht wurde und die Lesephase beendet 

werden kann, und das gelesene Langwort wird (sobald es bereitsteht) an der richtigen Position im 

Lese-Puffer abgelegt, wobei es zuvor im Diagramm BIT SHIFT (S. 126) gemäß Abbildung 34 an 

die richtige Bit-Position geschoben wird. 

Die Schreibzugriffe der Prozessor-Einheit entsprechen ebenfalls denen bei Host-Zugriffen. Zusätzlich 

können jedoch Read-Modify-Write-Zyklen (RMW) durchgeführt werden, wenn Randdaten des 

Zielbereichs gelesen werden müssen oder eine Verknüpfung von Quell- und Zieldaten ausgewählt 

wurde. 

Auch bei Schreibzugriffen werden im Diagramm MEM ADDRESS (S. 128, unten) die Adresse 

RAM ADR des Zugriffs (aus der Langwort-Adresse DADRLW C) und die CAS-Maske ermittelt. 

Zusätzlich wird jedoch auch eine Bit-Maske PRE MASK bestimmt, in der (vgl. Abbildung 34 ganz 

oben) diejenigen Bits gesetzt sind, die zur Zielzeile gehören. In der Zeilenmitte werden alle Bits der 

Maske gesetzt, während bei Langworten am Zeilenrand die im Diagramm BIT MASK (S. 127) 

asynchron berechneten Masken herangezogen werden, in denen sich die Anordnung der gesetzten 

Bits aus den Bit-Offsets DBOS L und DBOS R ergibt. Fallen das linke und rechte Langwort der 

Zeile zusammen, müssen die entsprechenden Bit-Masken und-verknüpft werden. 

Des weiteren wird im Diagramm MEM ADDRESS bei jedem Schreibzugriff das aktuelle Langwort 

aus dem Lese-Puffer geholt, das in den Zielbereich geschrieben oder mit den Zieldaten verknüpft 

werden muß. Dabei dient GPU FIFO OUT als Puffer-Zeiger. Falls RMW-Zyklen erforderlich 

werden, wird dies erkannt und das Signal PRE READ auf ’1’ gesetzt. 

Die Verknüpfung von Quell- und Zieldaten wird asynchron im Diagramm PIXBLT PATH (S. 131) 

durchgeführt. Gemäß Tabelle 14 werden zunächst evtl. Quell- und/oder Zieldaten invertiert, dann 

wird eine Verknüpfung ausgewählt und schließlich evtl. noch das Ergebnis invertiert. Das Ergebnis



Lukas Bauer 

Diplomarbeit 


Abschnitt 6.3 

Seite 53 

wird im Diagramm MEM ADDRESS (unten) in die Variable RAM D W übertragen, die bei allen 

Schreibzugriffen die zu schreibenden Daten enthält. 

Bei RMW-Zyklen werden die Zieldaten zunächst auf gewohnte Weise im Diagramm 

MEM CYCLES (S. 124) gelesen. Nach dem Zustand CAS3 werden jedoch die Zustände RMW1 

bis RMW3 durchlaufen, die den Lese-Zyklus zum RMW-Zyklus ergänzen. Je nach Speicherbusbreite 

erfolgen bis zu vier derartige Zyklen pro Langwort. 

Wurde der letzte (oder einzige) Schreib- oder RMW-Zyklus des Langworts eingeleitet, so wird in T4 

oder T13 das Signal GPU WRITE DONE auf ’1’ gesetzt. Damit wird die Erhöhung der Adresse 

und des Puffer-Zeigers im Diagramm GPU FIFO W (S. 130) eingeleitet. Dort erfolgt auch die 

Kontrolle, ob das Zeilenende erreicht wurde. 

Einige typische Simulationsergebnisse sind auf den Abbildungen 119 bis 122 (S. 149 bis 152) zu 

sehen. 

Abbildung 119 zeigt die Speicherzugriffe bei einem PixBlT-Befehl, bei dem 3 Zeilen zu 104 Pixeln 

à 1 Bit kopiert werden, wobei die Daten nicht an Langwort-Grenzen beginnen oder enden. 

Abbildung 120 stellt einen Ausschnitt dar. Zu sehen ist der Kopiervorgang der ersten Zeile, die 

von der Länge und der Lage in Quell- und Zielbereich her exakt dem Beispiel aus Abbildung 34 

entspricht. Es ist deutlich zu erkennen, daß zunächst vier Langworte in einer Page-Mode-Sequenz 

gelesen werden. In der folgenden Page-Mode-Sequenz zum Schreiben der Daten werden beim ersten 

und beim letzten der vier Langworte RMW-Zyklen durchgeführt, damit die Randdaten ” gerettet“ 

werden können. 

In diesem Beispiel wurde die Verknüpfung ” Ziel = Quelle“ gewählt. Quell- und Zielbereich enthielten 

vor der Befehlsausführung kontinuierlich den Wert 0x12345678. Aufgrund der unterschiedlichen 

Bit-Offsets (SBOS L=18, DBOS L=6) ergibt sich eine Verschiebung der Daten um 12 Bit 

nach links. Daraus resultiert der Wert 0x45678123, der in die mittleren beiden Langworte des Zielbereichs 

geschrieben werden (vgl. MD out). Die Daten, die in die äußeren Langworte geschrieben 

werden, ergeben sich aus der Mischung von Randdaten und kopierten Daten. 

Abbildung 121 (S. 151) zeigt die Zugriffe bei einem PixBlT-Befehl, bei dem 2 Zeilen zu 13 Pixeln 

à 32 Bit kopiert werden (zu sehen ist der Kopiervorgang der ersten Zeile). Als Verknüpfung wurde 

” Ziel = Quelle + Ziel“ gewählt, und die Pixel werden in der Reihenfolge von unten rechts nach 

oben links bearbeitet (PHV=PBH=’1’). Es werden zunächst 8 Langworte gelesen und dann in einer 

Page-Mode-RMW-Sequenz geschrieben, da der Lese-Puffer auf 8 gültige Langworte beschränkt ist. 

Anschließend wiederholt sich diese Abfolge, wobei allerdings nach jeweils 5 Langworten das (linke) 

Zeilenende erreicht wird. 

Abbildung 120 zeigt die letzte Abfolge als Ausschnitt. Man erkennt, daß die Adressen (RCA out) 

tatsächlich heruntergezählt werden, da die Daten von rechts nach links bearbeitet werden. 

6.3.4 Implementierung weiterer Grafik-Befehle 

Die Implementierung weiterer Grafik-Befehle ist aufgrund der Vorarbeiten, die in der 

Speicherzugriffs-Einheit in Zusammenhang mit dem PixBlT-Befehl geleistet wurden, zum Teil sehr 

einfach. So ist der “Block Move”-Befehl ein Spezialfall des PixBlT, bei dem der lineare Datenblock 

wie eine einzige Zeile eines zweidimensionalen Bildschirmbereichs behandelt werden kann, 

auch wenn diese sich evtl. über mehrere physikalische Bildschirmzeilen erstreckt. Der “Fill”-Befehl 

unterscheidet sich vom PixBlT darin, daß die Quelldaten konstant sind, so daß Speicherzugriffe auf 

diese entfallen können.



Lukas Bauer 

Diplomarbeit 


Abschnitt 6.3 

Seite 54 

Bei den “Pattern Fill”-Befehlen kann das Schreiben der Daten ebenfalls von der vorhandenen 

Speicherzugriffs-Einheit übernommen werden. Das Lesen der Füllmuster aus den Registern hingegen 

ist mit einem hohen Aufwand verbunden, da Silcsyn keine multidimensionalen Felder unterstützt. 

Hier ist zu überlegen, ob vielleicht auf eine Modellierung unter Speedchart verzichtet 

werden und stattdessen eine statische RAM-Zelle in das Design integriert werden sollte. 

Die Füll- und Kopierbefehle schließlich, die spezielle Eigenschaften der VRAMs benutzen, machen 

neue Speicherzugriffs-Zyklen erforderlich, so daß die Controller-Einheit noch erweitert werden muß. 

Die Befehle selbst sind weniger aufwendig als die Befehle auf Pixel-Basis. 

6.3.5 Timing der Befehle 

Was das Timing der Befehle angeht, müssen mit Sicherheit noch Änderungen vorgenommen werden. 

Dies betrifft zum einen die Additionen, die beim Clip-Befehl und bei der Adreßumrechnung für 

den PixBlT-Befehl durchgeführt werden. Es wäre illusorisch anzunehmen, daß diese in einem 

Taktzyklus (bei 60 MHz) ausgeführt werden können. Da aber das Timing durch das Synthese- 

Werkzeug Silcsyn noch nicht ordnungsgemäß beeinflußt werden kann, hat es wenig Sinn, hier jetzt 

schon etwas zu ändern. 

Den zweiten kritischen Punkt stellt die Speicherzugriffs-Einheit dar. Die durchgeführten Schreibund 

Lesezyklen entsprechen zwar den Timing-Anforderungen der RAMs, hierbei wurden jedoch die 

Ausgangstreiber nicht berücksichtigt. Da diese erst nach der Synthese angefügt werden können, 

wird sicher noch eine Anpassung erforderlich werden.



Lukas Bauer 

Diplomarbeit 


7 Werkzeuge der Logik-Synthese in der Praxis 

7.1 Produktivitätssteigerung durch den Einsatz von Speedchart-VHDL 

Abschnitt 7.1 

Seite 55 

Der Umgang mit Speedchart erwies sich aufgrund der sehr gut durchdachten Benutzeroberfläche 

während der gesamten Arbeit als äußerst komfortabel. Der Einstieg fiel insbesondere dadurch 

leicht, daß sich die Verwendung von VHDL-Anweisungen im Speedchart-Entwurf auf Variablen- 

Deklarationen, Zuweisungen, IF- und CASE-Konstrukte beschränkt, die ohnehin jedem Ingenieur 

vertraut sein dürften. Ein Erlernen von VHDL war daher bis auf einige syntaktische Regeln 

nicht notwendig. 

Auch der von Speedchart erzeugte VHDL-Code benutzt nur eine so eingeschränkte Teilmenge von 

VHDL, daß er allgemein verständlich ist. Diese Einschränkungen im Sprachumfang erfolgen im 

Hinblick auf die Synthetisierbarkeit der Schaltungen, die eine harte Anforderung an den VHDL- 

Code bedeutet. Anderenfalls wäre die VHDL-Datei nicht mehr als ein Spezifikationsinterface. 

Nun handelte es sich bei Speedchart-VHDL nicht von vornherein um ein ausgereiftes Programm. 

Anfangs standen nur erste Beta-Versionen zur Verfügung. Vor Beginn der Entwicklung des Grafikprozessors 

mußte Speedchart daher auf Möglichkeiten und Einschränkungen hin untersucht werden. 

Im engen Dialog mit den Herstellern gelang es aber auf sehr erfreuliche Weise, Unzulänglichkeiten 

bald zu beseitigen oder Umgehungsmöglichkeiten [5] zu finden. 

Wenn ein Programm zum Schaltungsentwurf über mehrere Programmversionen hinweg nicht in der 

Lage ist, einen VHDL-Code zu generieren, aus dem ein gewöhnlicher Inverter synthetisiert werden 

kann, so ist das zwar peinlich (it’s not a bug, it’s a feature), kann aber als normales Zwischenstadium 

in der Entwicklung eines komplexen Programms angesehen werden. Auch daß etwa 30% der 

Entwicklungszeit zur Fehlersuche und zum Schreiben kleiner Konvertierungsprogramme zum Patchen 

der fehlerhaft erzeugten VHDL-Files aufgewendet werden mußte, kann für einen Beta-Kunden 

als normal gelten. Bei Betrachtung der neuesten Speedchart-Version und der bisherigen Verbesserungen 

kann man annehmen, daß sich Speedchart-VHDL in naher Zukunft zu einem ” fehlerfreien“ 

Programm entwickeln wird, das die Design-Methoden tatsächlich revolutionieren kann und 

einen erheblichen Produktivitätsfortschritt beim Schaltungsentwurf bedeutet. 

Der neue zentrale Gedanke ist dabei der zustandsorientierte Entwurf einer Schaltung, 

der sich als besonders angenehm erweist, da der Mensch offenbar zustandsorientiert denkt. So 

berichtete ein Diplomand, daß er in VHDL programmiert, indem er seine Entwürfe zunächst als 

Zustandsgrafen auf dem Papier plant, diese in VHDL umsetzt und nach einigen Änderungen die 

endgültige Version zur Dokumentation wieder als Zustandsgrafen darstellt, wobei er ein Zeichenprogramm 

benutzt. Unter Speedchart hingegen erfolgen Entwurf, Simulation ∗ , Änderung und 

Dokumentation von vornherein in der gleichen Darstellungsform. 

Der Anwender von Speedchart entwickelt nach einiger Zeit eine vollkommen andere Design- 

Methodik, bei der er auf vorherige Planungen fast vollständig verzichtet. Dies ist jedoch kein 

Zeichen eines schlechten Programmierstils, sondern darauf zurückzuführen, daß Speedchart gleichzeitig 

ein Spezifikationswerkzeug und ein Eingabewerkzeug für synthetisierbare Designs ist. Es 

ergäbe unter Speedchart auch keinen Sinn, die Struktur einer neuen Einheit vor der Eingabe zu 

skizzieren: Eine Skizze auf Gatterebene wäre kaum umzusetzen, während ein Zustandsgraf unter 

Speedchart nicht vorab skizziert werden muß. 

Auch die Aufteilung des Gesamtentwurfs auf hierarchisch geordnete Seiten, die vollständig auf 

den Bildschirm passen und die sich auch ihrer Komplexität nach im wesentlichen noch mit einem 

∗ Unter Speedchart können bei der Simulation Variablenwerte numerisch und aktive Zustände grafisch angezeigt 

werden. Eine zusätzliche Anzeige von Signalverläufen (“Waveform Output”) ist erst seit der neuesten Version 2.2.0 

möglich; vorher mußte dafür der externe Simulator VHDL2000 (Racal-Redac) auf Basis der von Speedchart erzeugten 

VHDL-Dateien verwendet werden.



Lukas Bauer 

Diplomarbeit 


Abschnitt 7.2 

Seite 56 

Blick erfassen lassen, hat enorme Vorteile gegenüber einer mehrere tausend Zeilen langen VHDL- 

Datei: Das Wiederfinden einzelner Statements wird vereinfacht, denn das menschliche Gedächtnis 

ist offenbar zweidimensional orientiert; so können sich z. B. die meisten Menschen Positionen von 

Figuren auf einem Schachbrett wesentlich leichter merken als Positionen auf einem 64-mal-1–Brett. 

Die gemischte Verwendung von Grafik und Text erlaubt häufig eine Gliederung des Entwurfs 

in der Weise, daß sich die grobe Funktion eines Speedchart-Diagramms anhand der Grafik 

und der Namen der Zustände schnell erfassen läßt, während sich die Details übersichtlich geordnet 

in den VHDL-Befehlssequenzen verbergen, die den Zuständen und Transitionen zugeordnet sind. 

So bleiben selbst komplexe Entwürfe überschaubar. Es entsteht eine gleichermaßen ” maschinenund 

personenlesbare“ [16] Form der Schaltungsbeschreibung anstelle zweier verschiedener Darstellungsformen 

oder eines Kompromisses. 

Quantitativ läßt sich der Produktivitätsfortschritt, den die Verwendung von Speedchart mit sich 

bringt, nur schwer abschätzen. Gegenüber VHDL-Eingabe dürfte er (bezogen auf die Entwicklungszeit) 

zwischen 2:1 und 3:1, gegenüber Schaltplan-Eingabe (vollautomatische Synthetisierbarkeit 

vorausgesetzt) zwischen 10:1 und 30:1 liegen. 

7.2 Silcsyn als Synthese-Werkzeug auf VHDL-Basis 

Der Einsatz von Silcsyn als Synthese-Werkzeug hat sich bei der Entwicklung des Grafikprozessors 

zunächst ebenfalls sehr gut bewährt. Schaltungen, die von Silcsyn funktional falsch synthetisiert 

wurden, konnten nicht beobachtet werden, und die Einschränkungen durch Silcsyn waren gering. 

Bei Beachtung einiger einfacher Regeln [5] und dem Verzicht auf manche Konstrukte konnten die 

von Speedchart erzeugten VHDL-Dateien ohne Änderungen für die Synthese verwendet werden. 

Einen erheblichen Mangel stellte jedoch der Verzicht auf multi-dimensionale Felder dar. Die 

fehlende Möglichkeit, Registerbänke als Felder von Bit-Vektoren oder Integers zu definieren, machte 

bei der Adressierung der Register fünf CASE-Konstrukte mit je 96 Fällen notwendig. Auch variable 

Indizes wären wünschenswert gewesen. 

Eine Kontrolle der synthetisierten Schaltungen war unter Silcsyn nahezu unmöglich. Lediglich 

Simulationen auf Basis der erzeugten Netzlisten konnten belegen, daß die erzeugten Schaltungen 

korrekt arbeiteten. Silcsyn bietet zwar die Möglichkeit, die erzeugten Schaltungen grafisch anzuzeigen; 

es wird jedoch eine stark verschachtelte Hierarchie verwendet, und die Signale an den einzelnen 

Blöcken enthalten nur noch fortlaufende Nummern ohne die Möglichkeit einer Kreuz-Referenz, so 

daß der Anwender den Eindruck erhält, diese Option sei von den Herstellern des Programms nur zu 

Werbezwecken implementiert worden. Die erzeugten Schaltpläne sind einfach unlesbar. Vermutlich 

wäre aber auch eine bessere Darstellungsform bei Schaltungen von über 10.000 Gattern nicht 

mehr zu gebrauchen. Doch aufgrund der Tatsache, daß jede Nichtbeachtung von Einschränkungen 

sofort zu Fehlermeldungen führte, während bei fehlerfreiem VHDL-Code nie eine Abweichung zwischen 

den Simulationen auf Gatterebene und auf VHDL-Ebene beobachtet werden konnte, kann 

der Anwender von Silcsyn auf eine detaillierte Prüfung der Netzlisten wohl verzichten. 

Die Fehlerwahrscheinlichkeit ist im starken Gegensatz zur Hand-Synthese so gering, daß die 

funktionale Korrektheit der Schaltungen vorausgesetzt werden kann. 

Vorsicht ist jedoch geboten, was die Einhaltung der Timing-Anforderungen betrifft. Laut 

Handbuch ist es möglich, Silcsyn die Frequenz des Systemtaktes anzugeben und das Programm 

anzuweisen, die Laufzeiten in der gesamten Schaltung so zu optimieren, daß keine Verletzungen von 

Initialisierungs- und Übernahmezeiten von Flipflops (“set-up / hold violations”) auftreten, indem 

z. B. Addierer mit Ripple-Übertrag (“ripple carry”) durch Strukturen mit Parallelübertrag (“carry 

look-ahead”) ersetzt werden. Auch kann automatisch eine Kontrolle erfolgen, ob dies gelungen ist. 

In der Praxis zeigte sich jedoch, daß diese Optimierung bei Verwendung der Bibliothek zum Gate 

Array TC140G [14] von Toshiba nicht korrekt funktionierte. Bei Tests mit hohen Taktfrequenzen 

kam es sogar vor, daß sich synthetisierte Schaltungen aufgrund eklatanter Verletzungen der



Lukas Bauer 

Diplomarbeit 


Abschnitt 7.3 

Seite 57 

Timing-Anforderungen funktional falsch verhielten, obwohl Silcsyn noch nicht einmal Verletzungen 

der Zeitbedingungen von Flipflops bemerkt hatte. Derartige Fehler traten allerdings erst weit 

oberhalb der Taktfrequenz des Grafikprozessors von 60 MHz auf. Wenn der Prozessor später auf 

dem schnelleren TC160G [15] gefertigt wird, wird vermutlich kein Fehlverhalten auftreten. Es wäre 

jedoch wünschenswert, bis zur Fertigung der Schaltung eine korrigierte Bibliothek zu bekommen, 

damit sich die einwandfreie Funktion der Schaltung nicht nur auf eine vage Vermutung stützt. 

Aus Zeitgründen konnten im Rahmen dieser Arbeit keine weiteren speziellen Fähigkeiten des 

Synthese-Werkzeugs Silcsyn untersucht werden. Dies betrifft z. B. die automatische Berechnung 

der Ausgangslasten (“fan-out”) und deren Treiber, die kapazitiven Belastungen sowie die Gewährleistung 

der Testbarkeit der synthetisierten Schaltung durch die automatische Erzeugung von Teststrukturen 

(“full scan path design”). 

Auch Gespräche mit anderen Anwendern von Silcsyn ließen erkennen, daß die Synthese einer funktional 

korrekten Schaltung nur ein erster, kleiner Schritt auf dem Weg zur Endabgabe einer integrierten 

Schaltung ist. Ein automatisches Werkzeug kann nie auch nur annähernd den Umfang 

an Möglichkeiten ausschöpfen, die bei einem Hand-Design gegeben sind, was sich insbesondere bei 

einer Optimierung auf maximale Geschwindigkeit bemerkbar macht. Daher kann mit Sicherheit 

davon ausgegangen werden, daß die Logik-Synthese in Bezug auf Gatterbedarf und Geschwindigkeit 

immer einen Schritt hinter dem Hand-Design zurückbleiben wird. Auf der anderen Seite stehen 

jedoch die enorme Ersparnis an Entwicklungszeit und die sehr stark reduzierte Fehlerwahrscheinlichkeit 

bei der Verwendung von Logik-Synthese. 

Da die Fehlerwahrscheinlichkeit – das bei integrierten Schaltungen wichtigste Maß – bei der Hand- 

Synthese von immer komplexer werdenden Schaltungen gegen 1 geht, ist die Entwicklung funktionsfähiger 

Schaltungen auf Dauer nur mittels Logik-Synthese möglich. Wenn das Zeitverhalten 

der Schaltungen dabei nicht optimal berücksichtigt wird, können Unzulänglichkeiten immer 

noch dadurch ausgeglichen werden, daß einige zeitkritische Schaltungsteile per Hand optimiert oder 

vollständig neu entworfen und modular in die synthetisierte Schaltung eingefügt werden. Besonders 

bei regulären Strukturen ist dieses Verfahren sinnvoll, während irreguläre Strukturen in der Regel 

von der Maschine besser optimiert werden können. 

Beachtlich war bei der Synthese der einzelnen Einheiten der Bedarf an Rechenleistung und Speicher. 

Für die Synthese der Video-Timing- und VRAM-Reload-Einheit (Design ” VIDEO“, 

2.500 VHDL-Zeilen, ca. 26.000 Gatter) benötigte eine SUN2-Station mit 64 MByte RAM etwa 

16 Stunden, wobei 360 MByte virtueller Speicherplatz auf der Festplatte benötigt wurden. Da 

diese Einheit nur bis zu einer Frequenz von 30 bis 40 MHz arbeiten muß und keine aufwendigen 

Rechenoperationen ausgeführt werden müssen (nur 16-Bit-Additionen), wurde selbst mit der 

fehlerhaften Bibliothek eine Schaltung synthetisiert, die allen Timing-Anforderungen gerecht wird. 

Eine Synthese der Controller- und Prozessor-Einheit (Design ” TIM“) scheiterte bisher am zu 

großen Speicherbedarf. Eine Analyse der VHDL-Datei (4600 Zeilen) unter Silcsyn war jedoch 

möglich; sie lieferte keine Fehlermeldungen. Der Bedarf an Gattern wurde von Silcsyn zu 74.000 

abgeschätzt. Bei diesem Design ist anzunehmen, daß bei einer maximalen Arbeitsfrequenz von 

60 MHz und aufwendigen Rechenoperationen (32-Bit-Additionen mit mehreren Summanden) an 

vielen Stellen Optimierungen per Hand notwendig werden. 

7.3 Simulation auf VHDL- und Gatterebene 

Für den Simulator VHDL2000 konnten die von Speedchart erzeugten VHDL-Dateien ebenfalls 

direkt verwendet werden. Sogar die Testmuster, deren Eingabe unter Speedchart komfortabel 

möglich ist, konnte Speedchart direkt in Dateien mit der korrekten Syntax umsetzen.



Lukas Bauer 

Diplomarbeit 


Abschnitt 7.4 

Seite 58 

Der Umgang mit VHDL2000 war meist unproblematisch, extrem schwierig war jedoch die Ortung 

von Fehlern. Wurden Einschränkungen [5] von VHDL2000 (die nicht im Handbuch stehen) im 

Speedchart-Design nicht beachtet, stellte VHDL2000 die Funktion ein und meldete einen “assertion 

error” ohne Angabe einer Zeilennummer und ohne nähere Erklärung der Art des Fehlers. Insbesondere 

bei der Verwendung von n-Bit-Integer-Variablen, die in VHDL als Untertypen des Typs 

Integer definiert werden, traten Probleme auf. Während z. B. bei einem 8-Bit-Rückwärtszähler auf 

Gatterebene automatisch ein Zählerüberlauf vom Wert 0 auf 255 stattfindet, erwartet VHDL2000 

die Syntax “count:=(count + 255) mod 256”, nicht “count:=(count - 1) mod 256”. Warum 

VHDL2000 bei der Subtraktion, nicht aber bei der Addition eine Überschreitung des Wertebereichs 

feststellt, entzieht sich zwar jeder Logik, das Problem ist damit aber gelöst. Zuweisungen 

und Vergleiche von Integers und Bit-Vektoren sind teilweise ähnlich problematisch. 

Auf Gatterebene konnten die von Silcsyn erzeugten Schaltungen mit CADAT2000 simuliert 

werden. Dabei konnten die Netzlisten von Silcsyn direkt übernommen werden, nicht jedoch die 

von Speedchart erzeugten Testmuster. Testmuster im korrekten Format mußten aus VHDL2000 

heraus erzeugt werden. Anschließend war eine Nachbearbeitung mit selbstgeschriebenen Konvertierungsprogrammen 

nötig, da die Signalnamen unter CADAT auf acht Großbuchstaben beschränkt 

sind. 

Als sehr angenehm erwies sich, daß die Benutzeroberfläche von CADAT mit der von VHDL2000 

übereinstimmt. Dies erleichterte den visuellen Vergleich der Simulationsergebnisse mit den auf 

VHDL-Basis erzeugten. Ein automatisierter Vergleich wäre allerdings wünschenswert. 

Das Zeitverhalten der Schaltung entsprach in der Simulation bei Verwendung der entsprechenden 

Bibliotheken exakt dem der Elemente des Gate-Arrays TC140G [14]. CADAT meldete jedoch bei 

Tests mit zu hohen Arbeitsfrequenzen keine Verletzungen von Initialisierungs- und Übernahmezeiten 

der Flipflops (“set-up / hold violations”). Hierfür müßten bei jedem Flipflop einzeln Anweisungen 

eingefügt werden, die derartige Verletzungen überprüfen. Laut Racal-Redac ist es unter 

CADAT nicht möglich, die Zeiten global für alle Flipflops überprüfen zu lassen. Parallelversuche 

mit Verilog hingegen führten von vornherein zu korrekten Meldungen über Zeitverletzungen. 

7.4 Bilanz: grafisch-zustandsorientierte Eingabe mit teilautomatischer 

Synthese als leistungsfähiger Kompromiß 

Zusammenfassend läßt sich sagen, daß sich Speedchart als grafisch-zustandsorientiertes Eingabewerkzeug 

für VHDL in jeder Hinsicht bestens bewährt hat. Speedchart bietet eine neuartige, 

äußerst komfortable Designmethode für Synchronschaltwerke. 

Aufgrund der Leichtigkeit, mit der auch komplexe Strukturen entworfen werden können, konnten 

im Rahmen dieser Arbeit sogar einige Verbesserungen gegenüber der Spezifikation [1] vorgenommen 

werden. Über die Aufgabenstellung hinausgehend konnte neben der Video-Einheit auch die 

Controller-Einheit bis ins Detail entwickelt werden, ebenso der Teil der Prozessor-Einheit, der den 

Clip- und den PixBlT-Befehl ausführt. 

Als das zur Zeit schwächste Glied in der Kette vom Entwurf bis zum fertigen Chip erwies sich die 

Logik-Synthese. Dies ist nicht nur auf produktspezifische Einschränkungen in Silcsyn, sondern auch 

auf das prinzipielle Problem der mangelnden ” Intelligenz“ derartiger Werkzeuge zurückzuführen. 

Ein stellenweise nicht optimales Zeitverhalten von Schaltungsteilen ist die Folge. Bei integrierten 

Schaltungen aber stellen die Fehlerwahrscheinlichkeit und die Entwicklungszeit wesentlich wichtigere 

Merkmale dar, die bei Verwendung von Logik-Synthese um Größenordnungen besser als bei 

der Hand-Synthese sind. 

Einen zeitgemäßen und äußerst leistungsfähigen Kompromiß stellt daher die Verwendung von 

Speedchart als Eingabewerkzeug bei anschließender, teilweise automatischer, teilweise Handoptimierter 

Synthese dar.



Lukas Bauer 

Literaturverzeichnis 

Diplomarbeit 


Literaturverzeichnis 

Seite 59 

[1] Formac GmbH: ” Spezifikation für das Video-Timing-Generator ASIC (TIM)“, Berlin, 1991 

[2] Texas Instruments: “TMS 34020 User’s Guide”, 1990 

[3] Speed S.A.: “SPeeDCHART 2.2.0 Reference Manual”, CH-Neuchatel, 1993 

[4] Speed S.A.: “SPeeDCHART 2.2.0 First-Time User’s Guide”, CH-Neuchatel, 1993 

[5] Lukas Bauer: “SPeeDCHART Design Rules for Silcsyn Synthesis”, TU Berlin, 1993 

[6] Racal-Redac: “SilcSyn VHDL Synthesis Reference Guide”, Release 3.0 EAP, 1993 

[7] Racal-Redac: “VHDL2000 User’s Manual”, EAP Release, 1991 

[8] Racal-Redac: “CADAT 8.1 Language and Primitives Reference Manual”, 1990 

[9] Toshiba: “MOS Memory (DRAM) Data Book”, 1993, S. 87–104: Datenblatt TC 511000 

[10] Samsung: “MOS Memory Data Book (Vol.1)”, 1991, S. 129–142: Datenblatt KM41C1000B 

[11] Toshiba: “MOS Memory (VRAM) Data Book”, 1993, S. 139–193: Datenblatt TC 524258 

[12] Samsung: “MOS Memory Data Book (Vol.1)”, 1991, S. 723–752: Datenblatt KM424C257 

[13] Toshiba: “Gate Array Design Manual”, 1991 

[14] Toshiba: “TC140G Series Macrocell, ASIC Gate Array Library”, 1991 

[15] Toshiba: “TC160G Series Macrocell, ASIC Gate Array Library”, 1993 

[16] Claus Baumann, Prof. Dr. O. Manck: ” Schneller Einstieg in VHDL-Top-down-Designs“, 

Markt&Technik 28/1993 

Aus der Spezifikation [1] des Grafikprozessors wurden Befehls-, Signal- und Registerbeschreibungen 

zum Teil ohne besondere Kennzeichnung inhaltlich übernommen. 

Eidesstattliche Erklärung 

Hiermit erkläre ich, Lukas Bauer, an Eides Statt, diese Arbeit eigenhändig und selbständig angefertigt 

und keine anderen als die oben angegebenen Quellen verwendet zu haben. 

Berlin, den 01.09.1993



Lukas Bauer 

Glossar 

Begriffe: 

Diplomarbeit 


Glossar 

Seite 60 

Signal: Hardware-Signal oder 1 Bit breite Speedchart-Variable (Typ “logic”) 

(gemeint ist nicht die VHDL-Klasse “signal”) 

Variable: Hardware-Bus oder mehr als 1 Bit breite Speedchart-Variable (Typ 

“logic vector” oder “integer”) 

(gemeint ist nicht die VHDL-Klasse “variable”) 

Diagramm: Speedchart-“subdiagram” (nicht “diagram”), das einen Zustandsgrafen 

und/oder einen asynchronen Anweisungsblock enthält 

Werte: 

’0’, ’1’ Werte Boole’scher Variablen (Typ “logic”) 

0, 256 Dezimal-Werte numerischer Variablen (Typ “integer”) 

”11011000” Binärdarstellung von Bit-Vektoren (Typ “logic vector”) 

0x100, 0x1FF Hexadezimal-Werte von Integer-Variablen und von Bit-Vektoren, die 

Integer-Werte enthalten 

Datenworte: 

Byte: 8 Bit 

Wort: 16 Bit (wegen Mehrdeutigkeit nicht verwendet) 

Langwort: 32 Bit 

Speicherwort: 8, 16 oder 32 Bit, je nach Speicherbusbreite MBW 

Hostdatenwort: 8, 16 oder 32 Bit, je nach Host-Busbreite HBW 

Adressen: 

Byte-Adresse: Zeiger auf ein Byte 

Adresse: s. Byte-Adresse 

Langwort-Adresse: Zeiger auf ein Langwort 

Speicherwort-Adresse: Zeiger auf ein Speicherwort der Speicherbusbreite MBW 

Bit-Adresse: Zeiger auf ein Bit; An...A3 bezeichnen ein Byte, A2...A0 ein Bit innerhalb 

des Bytes nach Motorola-Konvention, Adresse 0 entspricht dabei Bit 7 

Pixel-Adresse: Zeiger auf einen Pixel relativ zum ersten Pixel des Bildschirms: 

Pixel-Adresse = Y-Koordinate · (Zeilenlänge in Pixeln) + X-Koordinate 

Signalnamen: 

XXX in: Eingangssignal 

XXX out: Ausgangssignal 

XXX oe: Richtungsauswahl für bidirektionale Signale (“output enable”), 

’1’=Signal ist Ausgang 

XXX ot: Test-Ausgangssignal zu Simulationszwecken 

XXX ict: Speicherbus-Signal der Controller-Einheit, 

wird später mit XXX itv zu XXX out und-verknüpft 

XXX itv: Speicherbus-Signal der VRAM-Reload-Einheit, 

wird später mit XXX ict zu XXX out und-verknüpft



Lukas Bauer 

Tabellenverzeichnis 

Diplomarbeit 


Tabellenverzeichnis 

Seite 61 

1 Register zur Programmierung der Video-Signale im Vollbildbetrieb . . . . . . . . . . 12 

2 Register zur Programmierung der Video-Signale im Halbbildbetrieb (NTSC) . . . . . 16 

3 Register zur Programmierung der Video-Signale im Halbbildbetrieb (PAL) . . . . . . 17 

4 Externe Synchronisations-Modi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 

5 Behandlung redundanter Signale an den Sync-Eingängen . . . . . . . . . . . . . . . . 18 

6 Register PSIZE zur Programmierung der Farbtiefe eines Pixels . . . . . . . . . . . . 28 

7 Registerbits SRL zur Programmierung der Schieberegisterlänge . . . . . . . . . . . . 28 

8 Registerbits XZ zur Programmierung des Zoom-Faktors in X-Richtung . . . . . . . . 28 

9 Registerbits MBW zur Programmierung der Speicherbusbreite . . . . . . . . . . . . 28 

10 Registerbits RF zur Programmierung der Refresh-Rate . . . . . . . . . . . . . . . . . 33 

11 Registerbits RSL zur Auswahl der Adreßbits, die die RAS-Bank bestimmen . . . . . 40 

12 Auswahl von MOA bis MOD je nach RAS-Bank . . . . . . . . . . . . . . . . . . . . 40 

13 Registerbits MOX zur Bestimmung der RAS-Adresse . . . . . . . . . . . . . . . . . . 40 

14 Registerbits S: Verknüpfung von Quell- und Zieldaten beim PixBlT-Befehl . . . . . . 47 

15 Register der Video-Timing-Einheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66 

16 Register der VRAM-Reload-Einheit . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 

17 Register der Controller-Einheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 

18 Register der Prozessor-Einheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 

19 Signale der Video-Timing-Einheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 

20 Signale der VRAM-Reload-Einheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 

21 Signale der Controller-Einheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70



Lukas Bauer 

Abbildungsverzeichnis 

Diplomarbeit 



Seite 62 

1 Blockschaltbild des Grafikprozessors ” TIM“ . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 

2 Vollbildbetrieb: HCOUNT und VCOUNT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 

3 Vollbildbetrieb: HBLANK, VBLANK und CBLANK . . . . . . . . . . . . . . . . . . . . . . . 12 

4 Vollbildbetrieb: HSYNC und VSYNC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 

5 Vollbildbetrieb: CSYNC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 

6 Vollbildbetrieb: IPHASE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 

7 Vollbildbetrieb: VLINE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 

8 Überlagerung zweier Halbbilder im Halbbildbetrieb . . . . . . . . . . . . . . . . . . . . . . . . 14 

9 Halbbildbetrieb NTSC: VLINE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 

10 Halbbildbetrieb NTSC: VCOUNT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 

11 Halbbildbetrieb NTSC: CBLANK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 

12 Halbbildbetrieb NTSC: IPHASE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 

13 Halbbildbetrieb NTSC: CSYNC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 

14 Halbbildbetrieb PAL: VLINE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 

15 Halbbildbetrieb PAL: IPHASE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 

16 Halbbildbetrieb PAL: VCOUNT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 

17 Blockschaltbild: Datenfluß zwischen TIM und dem Video-RAM . . . . . . . . . . . . . . . . . 23 

18 Beispiel-Verteilung von VRAM-Relaods für SRE=’0’ . . . . . . . . . . . . . . . . . . . . . . . 24 

19 Beispiel-Verteilung von VRAM-Relaods für SRE=’1’ . . . . . . . . . . . . . . . . . . . . . . . 24 

20 Blockschaltbild: externer Multiplexer für die Video-Daten . . . . . . . . . . . . . . . . . . . . 26 

21 Ermittlung der RAS- und CAS-Adressen beim Newline-Reload . . . . . . . . . . . . . . . . . 27 

22 Berechnung der Anzahl der notwendigen Reloads für SRE=’0’ . . . . . . . . . . . . . . . . . . 29 

23 Berechnung der Anzahl der notwendigen Reloads für SRE=’1’ . . . . . . . . . . . . . . . . . . 29 

24 Schreibzugriff bei gemultiplextem Bus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 

25 Lesezugriff bei gemultiplextem Bus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 

26 Schreibzugriff bei nicht gemultiplextem Bus . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 

27 Lesezugriff bei nicht gemultiplextem Bus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 

28 Schreibzugriff bei gemultiplextem Bus mit beschleunigtem Handshake . . . . . . . . . . . . . 37 

29 Schreibzugriff bei nicht gemultiplextem Bus mit beschleunigtem Handshake . . . . . . . . . . 37 

30 Beispiel einer Speicherkonfiguration mit 336 MByte DRAM und 4 MByte VRAM . . . . . . . 39



Lukas Bauer 

Diplomarbeit 



Seite 63 

31 Beispiel einer minimal-Speicherkonfiguration . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 

32 Blockschaltbild: TIM mit externen Registern . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 

33 Blockschaltbild: TIM mit internen Registern . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 

34 Datenfluß beim PixBlT-Befehl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 

35 Timing-Diagramm: Read Cycle, Write Cycle . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 

36 Timing-Diagramm: Fast Page Mode Read Cycle, Fast Page Mode Write Cycle . . . . . . . . 72 

37 Timing-Diagramm: Fast Page Mode Read-Modify-Write Cycle . . . . . . . . . . . . . . . . . 73 

38 Timing-Diagramm: Read Transfer Cycle ( Newline Reload ) . . . . . . . . . . . . . . . . . . . 74 

39 Timing-Diagramm: Real Time Read Transfer Cycle ( Midline Reload ) . . . . . . . . . . . . . 75 

40 Timing-Diagramm: Split Read Transfer Cycle ( Split Midline Reload ) . . . . . . . . . . . . . 76 

41 Timing-Diagramm: CAS Before RAS Refresh Cycle . . . . . . . . . . . . . . . . . . . . . . . 77 

42 Hierarchie der Video-Timing- und VRAM-Reload-Einheit (Design ” VIDEO“) . . . . . . . . . 78 

43 Typen, Konstanten und externe Signale im Design ” VIDEO“ . . . . . . . . . . . . . . . . . . 79 

44 Variablen im Diagramm VIDEO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 

45 Speedchart-Diagramm VIDEO/SYNC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 

46 Variablen im Diagramm VIDEO/SYNC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 

47 Speedchart-Diagramm VIDEO/VRAM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 

48 Speedchart-Diagramm VIDEO/RELOAD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 

49 Speedchart-Diagramm VIDEO/SYNC/S HCNT . . . . . . . . . . . . . . . . . . . . . . . . . . 82 

50 Speedchart-Diagramm VIDEO/SYNC/S VCNT . . . . . . . . . . . . . . . . . . . . . . . . . . 83 

51 Speedchart-Diagramm VIDEO/SYNC/CSYNC . . . . . . . . . . . . . . . . . . . . . . . . . . 84 

52 Variablen im Diagramm VIDEO/VRAM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 

53 Speedchart-Diagramm VIDEO/VRAM/VR RAM . . . . . . . . . . . . . . . . . . . . . . . . . 86 

54 Speedchart-Diagramm VIDEO/VRAM/VR RAM/TRANSFER . . . . . . . . . . . . . . . . . 87 

55 Speedchart-Diagramm VIDEO/VRAM/VR RAM/READ WRITE . . . . . . . . . . . . . . . 88 

56 Speedchart-Diagramm VIDEO/VRAM/VR SAM . . . . . . . . . . . . . . . . . . . . . . . . . 89 

57 Speedchart-Diagramm VIDEO/VRAM/VR ATTR . . . . . . . . . . . . . . . . . . . . . . . . 90 

58 Speedchart-Diagramm VIDEO/INTER . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 

59 Variablen im Diagramm VIDEO/RELOAD . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 

60 Speedchart-Diagramm VIDEO/RELOAD/RL RAM . . . . . . . . . . . . . . . . . . . . . . . 93 

61 Speedchart-Diagramm VIDEO/RELOAD/RL RAM/MIDL REL . . . . . . . . . . . . . . . . 94



Lukas Bauer 

Diplomarbeit 



Seite 64 

62 Speedchart-Diagramm VIDEO/RELOAD/RL RAM/NEWL REL . . . . . . . . . . . . . . . . 95 

63 Speedchart-Diagramm VIDEO/RELOAD/RL RAM/SPLIT MLR . . . . . . . . . . . . . . . 96 

64 Speedchart-Diagramm VIDEO/RELOAD/RL RAM/REFRESH . . . . . . . . . . . . . . . . 97 

65 Speedchart-Diagramm VIDEO/RELOAD/RL MSC . . . . . . . . . . . . . . . . . . . . . . . 98 

66 Speedchart-Diagramm VIDEO/RELOAD/RL CALC . . . . . . . . . . . . . . . . . . . . . . . 99 

67 Speedchart-Diagramm VIDEO/RELOAD/RL REFRESH . . . . . . . . . . . . . . . . . . . . 100 

68 Speedchart-Diagramm VIDEO/RELOAD/RL ARBIT . . . . . . . . . . . . . . . . . . . . . . 101 

69 Video-Timing-Signale im Vollbildbetrieb, interne Synchronisation . . . . . . . . . . . . . . . . 102 

70 Video-Timing-Signale im Halbbildbetrieb (NTSC), interne Synchronisation . . . . . . . . . . 103 

71 Video-Timing-Signale im Vollbildbetrieb, HSYNC und VSYNC sind Eingänge . . . . . . . . . 104 

72 Video-Timing-Signale im Halbbildbetrieb (NTSC), HSYNC und VSYNC sind Eingänge . . . 105 

73 Video-Timing-Signale im Vollbildbetrieb, CSYNC ist Eingang . . . . . . . . . . . . . . . . . . 106 

74 VRAM-Reload-Signale: Midline Reload kurz vor Zeilenende . . . . . . . . . . . . . . . . . . . 107 

75 VRAM-Reload-Signale: Newline Reload . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108 

76 VRAM-Reload-Signale: Newline Reload und Midline Reload, Zoom-Faktor 4 . . . . . . . . . 109 

77 VRAM-Reload-Signale: Midline Reload vor Beginn des Anzeigebereichs . . . . . . . . . . . . 110 

78 VRAM-Reload-Signale: Newline Reload, vorgezogener Split Midline Reload, Split Midline 

Relaod . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 

79 VRAM-Reload-Signale: Newline Reload, Refresh, Midline Reload . . . . . . . . . . . . . . . . 112 

80 Hierarchie der Controller- und Prozessor-Einheit (Design ” TIM“) . . . . . . . . . . . . . . . . 113 

81 Typen, Konstanten und externe Signale im Design ” TIM“ . . . . . . . . . . . . . . . . . . . . 114 

82 Variablen im Diagramm TIM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115 

83 Speedchart-Diagramm TIM/HOST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 

84 Speedchart-Diagramm TIM/CONTROL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 

85 Speedchart-Diagramm TIM/CONTROL/MEM ACCESS . . . . . . . . . . . . . . . . . . . . 116 

86 Speedchart-Diagramm TIM/GR CPU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 

87 Speedchart-Diagramm TIM/HOST/HOST ACC . . . . . . . . . . . . . . . . . . . . . . . . . 117 

88 Speedchart-Diagramm TIM/HOST/HOST CTRL . . . . . . . . . . . . . . . . . . . . . . . . 118 

89 Variablen im Diagramm TIM/CONTROL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119 

90 Speedchart-Diagramm TIM/CONTROL/TIM ACCESS . . . . . . . . . . . . . . . . . . . . . 120 

91 Speedchart-Diagramm TIM/CONTROL/TIM ACCESS/REG READ . . . . . . . . . . . . . 121 

92 Speedchart-Diagramm TIM/CONTROL/TIM ACCESS/REG WRITE . . . . . . . . . . . . . 122



Lukas Bauer 

Diplomarbeit 



Seite 65 

93 Variablen im Diagramm TIM/CONTROL/MEM ACCESS . . . . . . . . . . . . . . . . . . . 123 

94 Speedchart-Diagramm TIM/CONTROL/MEM ACCESS/MEM CYCLES . . . . . . . . . . . 124 

95 Speedchart-Diagramm TIM/CONTROL/MEM ACCESS/ADDR CALC . . . . . . . . . . . . 125 

96 Speedchart-Diagramm TIM/CONTROL/MEM ACCESS/BIT SHIFT . . . . . . . . . . . . . 126 

97 Speedchart-Diagramm TIM/CONTROL/MEM ACCESS/BIT MASK . . . . . . . . . . . . . 127 

98 Speedchart-Diagramm TIM/CONTROL/MEM ACCESS/MEM ADDRESS . . . . . . . . . . 128 

99 Speedchart-Diagramm TIM/CONTROL/MEM ACCESS/GPU FIFO R . . . . . . . . . . . . 129 

100 Speedchart-Diagramm TIM/CONTROL/MEM ACCESS/GPU FIFO W . . . . . . . . . . . . 130 

101 Speedchart-Diagramm TIM/CONTROL/MEM ACCESS/PIXBLT PATH . . . . . . . . . . . 131 

102 Speedchart-Diagramm TIM/CONTROL/INTERRUPT . . . . . . . . . . . . . . . . . . . . . 132 

103 Variablen im Diagramm TIM/GR CPU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 

104 Speedchart-Diagramm TIM/GR CPU/GP CMD . . . . . . . . . . . . . . . . . . . . . . . . . 134 

105 Speedchart-Diagramm TIM/GR CPU/GP CMD/CLIP . . . . . . . . . . . . . . . . . . . . . 135 

106 Speedchart-Diagramm TIM/GR CPU/GP CMD/PIXPLT . . . . . . . . . . . . . . . . . . . . 136 

107 Speedchart-Diagramm TIM/GR CPU/SADR SPLIT . . . . . . . . . . . . . . . . . . . . . . . 137 

108 Speedchart-Diagramm TIM/GR CPU/DADR SPLIT . . . . . . . . . . . . . . . . . . . . . . 138 

109 Speedchart-Diagramm TIM/GR CPU/SY SPLIT . . . . . . . . . . . . . . . . . . . . . . . . . 139 

110 Speedchart-Diagramm TIM/GR CPU/DY SPLIT . . . . . . . . . . . . . . . . . . . . . . . . 140 

111 Speedchart-Diagramm TIM/GR CPU/AREA TO PIX . . . . . . . . . . . . . . . . . . . . . . 141 

112 Speedchart-Diagramm TIM/GR CPU/PIX TO BIT . . . . . . . . . . . . . . . . . . . . . . . 142 

113 Speedchart-Diagramm TIM/REG ALIAS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 

114 Speedchart-Diagramm TIM/ASYNC ACT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144 

115 Schreib- und Lesezugriffe (Host – Speicher) bei 32 Bit Speicherbusbreite . . . . . . . . . . . . 145 

116 Schreib- und Lesezugriffe (Host – Speicher) bei 32 Bit Speicherbusbreite im Fast Page Mode . 146 

117 Schreib- und Lesezugriffe (Host – Speicher) bei 8 Bit Speicherbusbreite . . . . . . . . . . . . . 147 

118 Schreib- und Lesezugriffe (Host – Speicher) bei 8 Bit Speicherbusbreite im Fast Page Mode . 148 

119 Speicherzugriffe beim PixBlT-Befehl, 3 Zeilen zu 104 Pixeln à 1 Bit . . . . . . . . . . . . . . . 149 

120 Speicherzugriffe beim PixBlT-Befehl (Ausschnitt) . . . . . . . . . . . . . . . . . . . . . . . . . 150 

121 Speicherzugriffe beim PixBlT-Befehl, 2 Zeilen zu 13 Pixeln à 32 Bit . . . . . . . . . . . . . . . 151 

122 Speicherzugriffe beim PixBlT-Befehl (Ausschnitt) . . . . . . . . . . . . . . . . . . . . . . . . . 152



Lukas Bauer 

Register-Übersicht 

Diplomarbeit 


Anhang A.1 

Seite 66 

Die Register des Grafikprozessors sind in den Tabellen 15, 16, 17 und 18 auf den folgenden Seiten 

nach Einheiten getrennt zusammengefaßt. 

Die Anordnung der Register im Adreßraum kann dem Diagramm REG READ (S. 121) 

entnommen werden, die Lage der Registerbits dem Diagramm REG ALIAS (S. 143). 

Für die Steuerung der Video-Timing-Einheit und der VRAM-Reload-Einheit werden dabei nicht 

die von der Controller-Einheit verwalteten Register selbst verwendet, sondern Kopien der Registerwerte: 

Im Diagramm INTER (S. 91) werden die Registerwerte einmal gelatcht, um metastabile 

Zustände zu vermeiden, die auftreten könnten, wenn Setup- und Hold-Zeiten unterschritten werden. 

Dies könnte passieren, wenn ein Registerwert vom Host synchron zum Host-Takt MClk in geschrieben 

und von der Video-Timing-Einheit oder der VRAM-Reload-Einheit synchron zum Video-Takt 

VClk in weiterverarbeitet wird. Während die Register-Namen in der Controller-Einheit mit R 

beginnen (R XXX), tragen die Kopien der Register die in den Tabellen angegebenen Namen. 


HTOTAL[15:0], HEBLNK[15:0], HSBLNK[15:0], HESYNC[15:0], HESERR[15:0]: 

horizontale Timing-Register, siehe Tabelle 1, 2 und 3 (S. 12, 16 und 17) 

HCOUNT[15:0]: Horizontalzähler, zählt mit VClk in. Register kann nur gelesen werden. 

SETHCNT[15:0]: Wert, auf den HCOUNT bei externer Synchronisation mit jedem externen horizontalen 

Synchronpuls gesetzt wird 

VTOTAL[15:0], VEBLNK[15:0], VSBLNK[15:0], VESYNC[15:0]: 

vertikale Timing-Register, siehe Tabelle 1, 2 und 3 (S. 12, 16 und 17) 

VCOUNT[15:0]: Vertikalzähler, vgl. Abbildung 2, 10 und 16 (S. 12, 14 und 17). Register kann nur gelesen 

werden. 

SETVCNT[15:0]: Wert, auf den VCOUNT bei externer Synchronisation mit jedem externen vertikalen Synchronpuls 

gesetzt wird 

LINTV[15:0]: Stand des Vertikalzählers VCOUNT, bei dem ein Zeileninterrupt erzeugt werden soll 

ILE: Interlaced Enable: ’1’ = Halbbildbetrieb 

’0’ = Vollbildbetrieb 

VSD: ’1’=VSYNC ist Eingang, vgl. Tabelle 4 und 5 (S. 18) 

HSD: ’1’=HSYNC ist Eingang, vgl. Tabelle 4 und 5 (S. 18) 

CSD: ’1’=CSYNC ist Eingang, vgl. Tabelle 4 und 5 (S. 18) 

TEST: schneller Zähler-Test: ’1’ = 16-Bit-Zähler arbeiten wie zwei 8-Bit-Zähler 

’0’ = Zähler arbeiten normal 

Tabelle 15: Register der Video-Timing-Einheit 

Eine Besonderheit in der VRAM-Reload-Einheit sind die Register DPYSTRT und DPYNEXT. 

Die eigentlichen Register, R DPYSTRT und R DPYNEXT, enthalten aus Gründen der Kompatibilität 

zum TI-34020 Bit-Adressen, von denen die unteren fünf Bits null sein müssen. Da für die 

VRAM-Reload-Einheit aber die Speicherwort-Adressen (bezogen auf die Speicherbusbreite MBW) 

entscheidend sind, wird dort mit diesen gerechnet. Im Diagramm INTER (S. 91) wird dann die 

nötige Umsetzung vorgenommen. Somit sind DPYSTRT und DPYNEXT Speicherwort- 

Adressen und R DPYSTRT und R DPYNEXT Bit-Adressen.



Lukas Bauer 


Diplomarbeit 


Anhang A.1 

Seite 67 

DPYSTRT[26:0] Startadresse (Speicherwort-Adresse, s. einleitende Erläuterung) der Bildschirmdaten im 

Speicher. 

DPYINC[15:0] Länge einer logischen Bildschirmzeile in Speicherworten. Der Wert muß eine Zweierpotenz 

oder die Summe zweier Zweierpotenzen sein. 

DPYNEXT[26:0] Speicherwort-Adresse (s. einleitende Erläuterung) des ersten Pixels der nächsten Bildschirmzeile. 

DPYNEXT wird für Zeile 0 von der Video-Timing-Einheit auf den Wert 

von DPYSTRT gesetzt und bei jedem Zeilenwechsel um den Wert von DPYINC erhöht 

(vgl. Abschnitt 3.4.1). 

DPYNEXT kann nur gelesen werden. 

PSIZE[7:0] Farbtiefe eines Pixels in Bits, s. Tabelle 6 (S. 28) 

MBW[1:0] Speicherbusbreite in Bits, s. Tabelle 9 (S. 28) 

XZ[2:0] Zoom-Faktor für Bildvergrößerung in X-Richtung. Gibt den Teilerfaktor für den Takt an, 

der die Pixeldaten aus den Video-RAMs holt. Siehe Tabelle 8 (S. 28). 

YX[2:0] Zoom-Faktor für Bildvergrößerung in Y-Richtung. Gibt an, wie oft jede Bildschirmzeile 

wiederholt wird. Analog zu Tabelle 8 (S. 28). 

RLE: Reload Enable: ’1’ = es werden Reloads durchgeführt 

’0’ = es werden keine Reloads durchgeführt 

SRE: Split Reload Enable: ’1’ = Split Reloads sind freigegeben 

’0’ = Split Reloads sind gesperrt 

SRL[1:0] Schieberegister-Länge in Worten, s. Tabelle 7 (S. 28) 

RF[2:0] Refresh-Rate in VClk-Zyklen, s. Tabelle 10 (S. 33) 

FASTRAM Fast RAM Option: ’1’ = RAS-Pulse haben die Länge von 3 VClk-Zyklen 

’0’ = RAS-Pulse haben die Länge von 4 VClk-Zyklen 

Tabelle 16: Register der VRAM-Reload-Einheit 


HBW[1:0]: Host Bus Width (Host-Busbreite): ”00”= 8 Bit, ”01”= 16 Bit, ”1x”= 32 Bit 

NUBUS: Byte-Anordnung: ’1’ = NUBUS-Konvention, Bytes in der Datenphase vertauscht 

’0’ = normale Byte-Anordnung 

FASTRDY: schneller Handshake: ’1’ = schnelle Aktivierung des RDY-Signals 

’0’ = normaler Handshake 

LOCK: Schreibschutz: ’1’ = Schreibschutz für Register CONFIG, MUXOFF und RADSEL 

’0’ = kein Schreibschutz 

MBW[1:0]: Memory Bus Width (Speicherbusbreite): ”00”= 8 Bit, ”01”= 16 Bit, ”1x”= 32 Bit 

RSL[2:0]: RAS Bank Select (Auswahl der Adreßbits, die die RAS-Bank bestimmen), 

s. Tabelle 11 (S. 40) 

ASL[2:0]: Auxiliary Bank Select (Auswahl der Adreßbits, die die RAM-Ebene bestimmen), 

analog zu Tabelle 11 (S. 40) 

MOA[2:0]: Lage der RAS-Adreßbits in RAS-Bank 0, vgl. Tabelle 13 (S. 40) 

MOB[2:0]: Lage der RAS-Adreßbits in RAS-Bank 1 

MOC[2:0]: Lage der RAS-Adreßbits in RAS-Bank 2 

MOD[2:0]: Lage der RAS-Adreßbits in RAS-Bank 3 

RTO[1:0]: RAS Timeout, maximale Dauer eines RAS-Zyklus im Page Mode, angegeben in Perioden 

von HCOUNT: 

”00”= 1, ”01”= 2, ”10”= 3, ”11”= 4 Perioden des Horizontalzählers 

PEN: Page Mode Enable: ’1’ = Speicherzugriffe im Page Mode 

’0’ = kein Page Mode 

Tabelle 17: Register der Controller-Einheit



Lukas Bauer 


Diplomarbeit 


Anhang A.1 

Seite 68 

COMMAND[7:0]: Kommando-Register, wird vom Host mit dem OP-Code eines Grafikbefehls beschrieben 

und von TIM nach dessen Bearbeitung auf den Wert 0 zurückgesetzt. 

SSTART[31:0]: Bit-Adresse des ersten Pixels des Quellbildschirms im Speicher. Bit 4...0 müssen null sein. 

DSTART[31:0]: Bit-Adresse des ersten Pixels des Zielbildschirms im Speicher. Bit 4...0 müssen null sein. 

SINC[15:0]: Abstand zweier beim Quellbildschirm vertikal übereinanderliegender Pixel in Speicherworten 

DINC[15:0]: Abstand zweier beim Zielbildschirm vertikal übereinanderliegender Pixel in Speicherworten 

SADR[31:0]: Source Address, Startadresse (Pixel-Adresse relativ zum Bildschirmanfang) der Quelldaten 

(bei linearer Adressierung) 

SYADR[15:0]: Source Address Y, Y-Koordinate der Quelldaten 

(bei XY-Adressierung an Stelle des höherwertigen Teils SADR[31:16]) 

SXADR[15:0]: Source Address X, X-Koordinate der Quelldaten 

(bei XY-Adressierung an Stelle des niederwertigen Teils SADR[15:0]) 

DADR[31:0]: Destination Address, Startadresse (Pixel-Adresse relativ zum Bildschirmanfang) der Zieldaten 

(bei linearer Adressierung) 

DYADR[15:0]: Destination Address Y, Y-Koordinate der Zieldaten 

(bei XY-Adressierung an Stelle des höherwertigen Teils DADR[31:16]) 

DXADR[15:0]: Destination Address X, X-Koordinate der Zieldaten 

(bei XY-Adressierung an Stelle des niederwertigen Teils DADR[15:0]) 

DX[15:0]: horizontale Bereichsgröße in Pixeln 

bei linearen Datenblöcken: niederwertiger Teil der Bereichslänge 

DY[15:0]: vertikale Bereichsgröße in Pixeln 

bei linearen Datenblöcken: höherwertiger Teil der Bereichslänge 

WSTARTX[15:0]: Window Start X, X-Koordinate der linken oberen Ecke eines Fensters für Clip-Befehle 

WSTARTY[15:0]: Window Start Y, Y-Koordinate der linken oberen Ecke eines Fensters für Clip-Befehle 

WENDX[15:0]: Window End X, X-Koordinate der rechten unteren Ecke eines Fensters für Clip-Befehle 

WENDY[15:0]: Window End Y, Y-Koordinate der rechten unteren Ecke eines Fensters für Clip-Befehle 

PBV: PixBlT Vertical Direction: ’0’ = Pixel werden von oben nach unten bearbeitet 

’1’ = Pixel werden von unten nach oben bearbeitet 

PBH: PixBlT Horizontal Direction: ’0’ = Pixel werden von links nach rechts bearbeitet 

’1’ = Pixel werden von rechts nach links bearbeitet 

S[4:0]: Verknüpfung von Quell- und Zieldaten, s. Tabelle 14 (S. 47) 

PATTN000[7:0] bis PATTN1F7[7:0]: 

256 Byte RAM für Füllmuster 

COLOR0[31:0] bis COLOR3[31:0]: 

Farbwerte für die Füllmuster 

BMS: Bit Map Size: ’1’ = Füllmuster haben 2 Bit pro Pixel (4 Farben) 

’0’ = Füllmuster haben 1 Bit pro Pixel (2 Farben) 

PTS[1:0]: Pattern Size, Größe des quadratischen Füllmusters in den PATTN-Registern 

”00”= 8∗8 Pixel, ”01”= 16∗16 Pixel, ”1x”= 32∗32 Pixel 

PSIZE[5:0]: Pixel Size, Farbtiefe eines Pixels in Bit, s. Tabelle 6 (S. 28) 

Tabelle 18: Register der Prozessor-Einheit



Lukas Bauer 

Diplomarbeit 


Übersicht über die externen Signale 

Anhang A.2 

Seite 69 

Die externen Signale des Grafikprozessors werden in der Spezifikation [1] und im Text dieser Arbeit 

ausführlich erläutert. Die Tabellen 19, 20 und 21 enthalten Übersichten, wiederum gegliedert nach 

den funktionalen Einheiten. Die Prozessor-Einheit verfügt nicht über eigene Chip-externe Signale, 

da alle Speicherzugriffe von der Controller-Einheit durchgeführt werden. 

Die Speicherbus-Signale der VRAM-Reload-Einheit (XXX itv) werden mit den entsprechenden 

Signalen der Controller-Einheit (XXX ict) und-verknüpft, bevor sie zum Speicherbus gehen. Auf 

diese Weise können beide Einheiten zeitlich alternierend auf die RAMs zugreifen. Voraussetzung 

hierfür ist, daß die jeweils inaktive Einheit alle Signale auf ’1’ setzt. 

Signal Richtung, aktiver Pegel, Funktion 

HSYNC: i/o – horizontales Synchronisations-Signal 

VSYNC: i/o – vertikales Synchronisations-Signal 

CSYNC: i/o – gemeinsames Synchronisations-Signal 

CBLANK: out – Dunkeltastung des Bildes 

VClk: in + Video Clock (Video-Takt) 

Tabelle 19: Signale der Video-Timing-Einheit 


RCA itv[13:0]: out + Row/Column Address (RAM-Adresse) 

RAS itv[3:0]: out – Row Address Strobe (Zeilenadresse gültig, Auswahl der RAS-Bank) 

CAS itv[3:0]: out – Column Address Strobe (Spaltenadresse gültig, Byte-Auswahl) 

MWE itv: out – Memory Write Enable (Freigabe für Schreibzugriff) 

MOE itv: out – Memory Output Enable (Freigabe für Lesezugriff) 

MSF itv: out + Memory Special Function (Auswahl von Spezialfunktionen) 

ACS itv[3:0]: out – Auxiliary Chip Select (Auswahl der RAM-Ebene) 

VClk: in + Video Clock (Video-Takt, s. Abschnitt 4.3) 

LD: out + Load (Pixel-Takt, s. Abschnitt 4.3) 

MSC: out + Memory Shift Clock (Datenwort-Takt, s. Abschnitt 4.3) 

Tabelle 20: Signale der VRAM-Reload-Einheit



Lukas Bauer 

Diplomarbeit 



AD[31:0]: i/o + Host-Bus, (Adreßbus bzw. gemultiplexter Adreß- und Datenbus) 

HD[31:0]: i/o + Host-Datenbus 

BS[3:0]: in – Byte Select (Datenbyte-Maske) 

RS: in – Register Select (kennzeichnet einen Registerzugriff) 

HWE: in – Host Write Enable (kennzeichnet einen Schreibzugriff) 

AS: in – Address Strobe (Adresse gültig) 

DS: in – Data Strobe (Daten gültig) 

RDY: out +/– Ready (Freigabe für Ende des Host-Zugriffs), Open-Drain-Signal 

Wird während des Resets gelesen, um den inaktiven Pegel zu ermitteln. 

INT: out – Interrupt-Anforderung (Open-Drain-Signal) 

MUX: in – Muxed Bus Select (’0’=gemultiplexter Host-Bus) 

RCA ict[13:0]: out + Row/Column Address (RAM-Adresse) 

MD ict[31:0]: i/o + Speicher-Datenbus 

RAS ict[3:0]: out – Row Address Strobe (Zeilenadresse gültig, Auswahl der RAS-Bank) 

CAS ict[3:0]: out – Column Address Strobe (Spaltenadresse gültig, Byte-Auswahl) 

MWE ict: out – Memory Write Enable (Freigabe für Schreibzugriff) 

MOE ict: out – Memory Output Enable (Freigabe für Lesezugriff) 

MSF ict: out + Memory Special Function (Auswahl von Spezialfunktionen) 

ACS ict[3:0]: out – Auxiliary Chip Select (Auswahl der RAM-Ebene) 

MClk: in + Master Clock (Systemtakt) 

RESET: in – Reset 

Tabelle 21: Signale der Controller-Einheit 

Anhang A.2 

Seite 70



Lukas Bauer 

Diplomarbeit 


Abbildung 35: Beim “Read Cycle” und beim “Write Cycle” [9] (Lese- bzw. Schreib-Zugriff) wird in einem 

RAS-CAS-Zyklus erst die Speicherzeile und dann die Spalte übergeben. 

Anhang B 

Seite 71



Lukas Bauer 

Diplomarbeit 


Abbildung 36: Beim “Fast Page Mode Read Cycle” und beim “Fast Page Mode Write Cycle” [9] erfolgen 

in einem RAS-Zyklus mehrere Zugriffe auf Daten aus einer Speicherzeile. 

Anhang B 

Seite 72



Lukas Bauer 

Diplomarbeit 


Abbildung 37: Beim “Fast Page Mode Read-Modify-Write Cycle” [9] erfolgen in einem RAS-Zyklus gemischte 

Lese- und Schreibzugriffe auf Daten aus einer Speicherzeile. 

Anhang B 

Seite 73



Lukas Bauer 

Diplomarbeit 


Abbildung 38: Der “Read Transfer Cycle” [11] lädt das ganze Schieberegister. Er wird beim Newline Reload 

verwendet. 

Anhang B 

Seite 74



Lukas Bauer 

Diplomarbeit 


Abbildung 39: Der “Real Time Read Transfer Cycle” [11] wird beim Midline Reload nötig. Die steigende 

Flanke des MOE-Signals (DT/OE) bestimmt den Zeitpunkt des Reloads. 

Anhang B 

Seite 75



Lukas Bauer 

Diplomarbeit 


Anhang B 

Seite 76 

Abbildung 40: Der “Split Read Transfer Cycle” [11] lädt nur eine Hälfte des Schieberegisters. Er wird 

beim Split Midline Reload durchgeführt, während gleichzeitig Daten aus der anderen SR-Hälfte ausgegeben 

werden.



Lukas Bauer 

Diplomarbeit 


Abbildung 41: Der “CAS Before RAS Refresh Cycle” [11] löst einen Refresh einer Speicherzeile aus, deren 

Zeilennummer über einen RAM-internen Zähler automatisch erzeugt wird. 

Anhang B 

Seite 77



Lukas Bauer 

VIDEO 

INTER RELOAD 

VRAM 

SYNC 

RELOAD 

VRAM_4_258 

SYNC 

RL_MSC RL_CALC RL_REFRESH RL_ARBIT 

RL_RAM 

VR_SAM VR_ATTR 

VR_RAM 

S_HCNT S_VCNT CSYNC 

Diplomarbeit 


REFRESH 

SPLIT_MLR 

NEWL_REL 

MIDL_REL 

TRANSFER 

READ_WRITE 

REFRESH 

SPLIT_MLR 

NEWL_REL 

MIDL_REL 

TRANSFER 

READ_WRITE 

Anhang C.1 

Seite 78 

Abbildung 42: Hierarchie der Video-Timing- und VRAM-Reload-Einheit (Design ” VIDEO“) mit Seitenangaben



Lukas Bauer 

©¢ 

¢¡¢£¥¤§¦©¨¢£¢¦¥¢¢¢¡ ©¢ 

¢¡¢£¥¤§¦©¨¢£¢¦¢¡©¢¢¢¡ 

©¢ 

¢¡¢£¥¤§¦©¨¢£¢¦¢¡¥¢¡ ©¢ 

¢¡¢£¥¤§¦©¨¢£¢¦¢¡¥¢¡ 

©¢ 

¢¡¢£¥¤§¦©¨¢£¢¦¢¡¥©¢¡ ©¢ 

¢¡¢£¥¤§¦©¨¢£¢¦¥©¢¡ 

©¢ 

¢¡¢£¥¤§¦©¨¢£¢¦¢¡¥©¢¡ ©¢ 

¢¡¢£¥¤§¦©¨¢£¢¦¢¡¢¡ 

©¢ 

¢¡¢£¥¤§¦©¨¢£¢¦¢¡©¥¢¡ 

¦¥£¢¦¤£¢¦©¦©¡§¢¢ 

¦¥£¢¦¥¤£¢¦©¦©¡§¢§¢ 

¦¥£¢¦¤£¢¦©¦©¡§¢§¢ 

¦¥£¢¦¤£¢¦©¦©¡§¢ 

¦¥£¢¦¤£¢¦©¦©¡§¢§¢ 

¦¥£¢¦¤£¢¦©¦©¡§¢ 

¦¥£¢¦¤£¢¦©¦©¡§¢¥¢ 

¦¥£¢¦¤£¢¦©¦©¡§¢ 

¦¥£¢¦¤£¢¦©¦©¡§©¢ 

£¥¤£¨¥£ 

£¨¥¡¦ 

£¨¥¡ ¢¡¡¦¢¦ 

¢¡£¦ 

 

£¨¥¡¦¦©©¤§¦¡¦¢¦ 

£¥¤¡¥¢¡£¢¦©¨ ¢ 

 

¡¦ ¡¦¢¡ ¥ 

¥ ¡¦ ¡¦¢¡ ¥ 

©¥ 

¡¦ ¡¦¢¡ ¥ 

¢©§ ¡¦ ¡¦¢¡ ¥ 

¥ 

¡¦ ¡¦¢¡ ¥ 

©§ ¡¦ ¡¦¢¡ ¥ 

©©§ 

£ £¢¡ ¥ 

¥ £ £¢¡ ¥ 

©¥ 

£ £¢¡ ¥ 

©¥ ¡ ¡¦¢¡ ¥ 

¥ 

¡ ¡¦¢¡ ¥ 

¥ ¡ ¡¦¢¡ ¥ 

¥ 

£¥¤ 

¡¦¢ ¡¦¢¡ ¥ 

¡ ¡¦¢¡ ¥ 

 

£ £¢¡ ¥ 

¢ ¡¦ ¡¦¢¡ ¥ 

 

¢¤§¦©£¦¤ 

¥¥§ £¢¡ ¥ 

 

©¢¥ £¢¡ ¥ 

¢¥¥ £¢¡ ¥ 

 

¢© £¢¡ ¥ 

©© £¢¡ ¥ 

 

¢§ £¢¡ ¥ 

¢¥ £¢¡ ¥ 

 

©§¥ £¢¡ ¥ 

 

©¥¥ £¢¡ ¥ 

©© £¢¡ ¥ 

 

© £¢¡ ¥ 

¢§ £¢¡ ¥ 

 

©¢ ¢£¢¡ ¥ 

¥ £¢¡ ¥ 

 

¥ ¥ £¢¡ ¥ 

¥ ¥ £¢¡ ¥ 

 

¥©¢§ © £¢¡ ¥ 

©¢ £¢¡ ¥ 

 

£¢¡ ¥ 

£¢¡ ¥ 

 

£¢¡ ¥ 

 

£¢¡ ¥ 

©¢ £¢¡ ¥ 

 

¥¢ £¢¡ ¥ 

 

£¢¡ ¥ 

© £¢¡ ¥ 

 

£¢¡ ¥ 

 

¥ £¢¡ ¥ 

¥ ¢ £¢¡ ¥ 

 

¢¤§¦©¡¦¢¦¤ 

¢¢¢¥ ¡¦¢¡ ¥ 

¢¢¢¥ ¡¦¢¡ ¥ 

 

¢¢¢¥ © ¡¦¢¡ ¥ ¤§©¡¦ ¢¡£¢¦©¤ 

¢¢¢¥ © ¡¦¢¡ ¥ 

 

¢¡¦¢¡ ¥ 

¡¦¢¡ ¥ 

 

£¥¤¡¦©§£© ¦¥¢¡¢£¥¤ 

 

¥© £ £¢¡ ¥ 

¡¦ ¡¦¢¡ ¥ 

 

¡¦ ¡¦¢¡ ¥ 

¢£ £¢¡ ¥ 

 

£¥¤¡¦©©¤§¦¤¡¢£© 

 

©¨©¤¡¦¥ ¡¦¢¡ ¥ ¤©¥ ¦¥¢ 

¢ ¡¦ ¡¦¢¡ ¥ 

 

¡¢¢¢ 

¡¦© ¡¦¢¡ ¥ ¤§©¡¦¥¢¡£ 

¥ £¢¡ ¥ 

¥ 

¦©©¤§¦¥¨¦¦©£¤ ¦¥¢¡¢£ 

£¡§£© ¦¥¢¡¢£ 

¦¡¦ ¡¦¢¡ ¥ 

¡¡¦ ¡¦¢¡ ¥ 

 

¡¡¦ ¡¦¢¡ ¥ 

¦¡¦ ¡¦¢¡ ¥ 

 

¡¡¦ ¡¦¢¡ ¥ 

© £¨¡¦ ¡¦¢¡ ¥ 

 

©¢© ¡¦ ¡¦¢¡ ¥ 

 

© ¡¦ ¡¦¢¡ ¥ 

© ¡¦ ¡¦¢¡ ¥ 

 

Diplomarbeit 


¡¦ ¡¦¢¡ ¥ 

 

 

¡¦ ¡¦¢¡ ¥ 

¡¦¥¡¦¢¡ ¥ 

 

¡¦¥¡¦¢¡ ¥ 

 

¡¦ ¡¦¢¡ ¥ 

§ 

§©¢ 

¡¦¡¦¢¡ ¥ 

§©¢ ¡¦ ¡¦¢¡ ¥ 

 

¡¦¡¦¢¡ ¥ 

§ 

©§ ¡¦ ¡¦¢¡ ¥ 

¢ ¡¦ ¡¦¢¡ ¥ 

 

¡¡¦ ¡¦¢¡ ¥ 

¢ 

 

¡¡¦ ¡¦¢¡ ¥ 

 

¡¦ ¡¦¢¡ ¥ 

§© ¡¦ ¡¦¢¡ ¥ 

§© 

¡¦ ¡¦¢¡ ¥ 

¢ ¡¦¥ ¡¦¢¡ ¥ 

§© 

¦©©¤§¦¡¦¢¦¤ 

£¢¦¡¦ ¡¦¢¡ ¥ ¤§¥§¦¢ ¢¡£¢¦© 

 

 

¡¡¦ ¡¦¢¡ ¥ ¤§¥§¦¢¤§¦©¢¡ 

 

¡¦¥ ¡¦¢¡ ©¢ ¤ 

 

 

¡¦¥ ¡¦¢¡ ©¢ ¤ 

¡¦¥ ¡¦¢¡ ¥ ¤ 

 

¡¦¥ ¡¦¢¡ ¥ ¤ 

 

Anhang C.2 

Seite 79 

§© ¡¦ ¡¦¢¡ ¥ §© 

 

 

¡¦ ¡¦¢¡ ¥ ¢¡ ¥¦©¡¥¢¨¦¥¢¡¢£¥¤¥ 

¢ ¡¦ ¡¦¢¡ ¥ ¢¡¢©£ ¥¦©¡¥¢¨¦¥¢¡¢£¥¤¥ 

 

¡¦ ¡¦¢¡ ¥ ¢¡ ¢¨¡¥¢¨¦¥¢¡¢£¥¤¥ 

 

¢ ¡¦ ¡¦¢¡ ¥ ¢¡¢©£¢¨¡¥¢¨¦¥¢¡¢£¥¤¥ 

 

 

¢ ¡¦¢¡¦¢¡ ¥ ¢¡¢©£¤¢ ¦ 

¢ ¡¦¢ ¡¦¢¡ ¥ ¥¦©¥¨©¤ ¢ 

 

§ ¡¦¢¡¦¢¡ ¥ ¥¦©¨¦©¨ 

 

¢¡¢£¢¦¥¢¡¤¢¢¢£¨¤ 

 

¡¦ ¡¦¢¡ ¥ 

¡¦ ¡¦¢¡ ¥ 

¢ 

¡¦¥ ¡¦¢¡ ¥ 

§ ¡¦¥ ¡¦¢¡ ¥ 

 

§ ¡¦ ¡¦¢¡ ¥ ¡©¦¤ 

¡¦ ¡¦¢¡ ¥ 

 

¡¦ ¡¦¢¡ ¥ 

¡¦ ¡¦¢¡ ¥ 

¥¢ 

¢¢¡¨¢¡ ¤¢¢¢£¨¤ 

 

¡¦ ¡¦¢¡ ¥ 

§©©¥ ¡¦©¡¦¢¡ ¥ 

¢¥ 

¥¥ ¡¦¡¦¢¡ ¥ 

§ ¡¦©¡¦¢¡ ¥ 

 

¡¦©¡¦¢¡ ¥ 

 

§ 

¥¥¢¡¦ ¡¦¢¡ ¥ 

 

¢¡¦ ¡¦¢¡ ¥ 

Abbildung 43 (zweispaltig): Typen, Konstanten und externe Signale im Design ” VIDEO“



Lukas Bauer 

Diagram Variables: 

-- Variables of Diagram VIDEO 

-- registers 

HCOUNT: int16:=0; 

VCOUNT: int16:=0; 

HTOTAL: int16:=0; 

HESYNC: int16:=0; 

HSBLNK: int16:=0; 

HEBLNK: int16:=0; 

HESERR: int16:=0; 

VTOTAL: int16:=0; 

VESYNC: int16:=0; 

VSBLNK: int16:=0; 

VEBLNK: int16:=0; 

LINTV: int16:=0; 

SETHCNT:int16:=0; 

SETVCNT:int16:=0; 

DPYSTRT: int27:=0; -- hi 27 bits, lo 5 bits=0 

DPYHELP(27): logic; -- equals DPYSTRT(31 downto 5) 

DPYINC: int27:=0; -- hi 27 bits, lo 5 bits=0 

YZ(3): logic:="000"; -- Y zoom factor 

XZ(3): logic:="000"; -- X zoom factor 

RLE: logic:=’0’; -- reload enable 

SRE: logic:=’0’; -- split reload enable 

SRL(2): logic:="00"; -- shift reg length 

MBW(2): logic:="00"; -- memory bus width 

NTSC: logic:=’0’; -- ’1’=NTSC, ’0’=PAL 

ILE: logic:=’0’; -- interlaced enable 

VEN: logic:=’0’; -- video enable 

TEST: logic:=’0’; -- ’1’: counter test 

CSD: logic:=’0’; -- CSYNC direction 

HSD: logic:=’0’; -- HSYNC direction 

VSD: logic:=’0’; -- VSYNC direction 

RF(3): logic:="000"; -- refresh rate 

FASTRAM:logic:=’0’; -- ’1’=perform fast RAS cycles 

DPYNEXT: int27:=0; -- hi 27 bits, lo 5 bits=0 

DPYNEXTV(27): logic; 

-- reload control interface 

MLRAT10: logic:=’0’; -- attent.: midl. rel. -10 

MLRAT6: logic:=’0’; -- attent.: midl. rel. -6 

HC_MLR10: int16:=0; -- HCOUNT value at rel -10 

HC_MLR6: int16:=0; -- HCOUNT value at rel -6 

HC_MEN10: logic:=’0’; -- ’1’=enable HC_MLR10 


RELOAD: logic:=’0’; -- 1=do line end reload 

RELAT10: logic:=’0’; -- attent.: newl. rel. -10 

RELAT6: logic:=’0’; -- attent.: newl. rel. -6 

RELAREA: logic:=’0’; 

MSC_reload: logic:=’1’; -- ’0’: pulse after reload 

Clk_Div: logic; -- ’0’: MSC = VClk 

-- video components 

HBLANK: logic:=’0’; 

VBLANK: logic:=’0’; 

-- VRAM internal control signals 

RCA_itv(12): logic:=hi12; 

DIN_itv(32): logic:=hi32; 

MOE_itv: logic:=’1’; 

MWE_itv: logic:=’1’; 

MSF_itv: logic:=’0’; 

RAS_itv(4): logic:="1111"; 

CAS_itv(4): logic:="1111"; 

MSC_itv: logic; 

LD_itv: logic; 

-- substitutes for ’changing (for diagram SYNC) 

HSin_old: logic:=’1’; 

HSin_new: logic:=’1’; 

VSin_old: logic:=’1’; 

VSin_new: logic:=’1’; 

CSin_old: logic:=’1’; 

CSin_new: logic:=’1’; 

ILE_last: logic:=’0’; 

CSD_last: logic:=’0’; 

HSD_last: logic:=’0’; 

VSD_last: logic:=’0’; 

HTOTAL_last: int16:=0; 

VTOTAL_last: int16:=0; 

Abbildung 44: Variablen im Diagramm VIDEO 

Diplomarbeit 


Anhang C.2 

Seite 80



Lukas Bauer 

SYNC 

SYNC 

C: RESET_in=’0’ 

T3 

T2 


or ILE/=ILE_last 

or CSD/=CSD_last 

or HSD/=HSD_last 

or VSD/=VSD_last 

or HTOTAL/=HTOTAL_last 

or VTOTAL/=VTOTAL_last 

Diplomarbeit 


entry 

T4 

reset 

Entry of 

A: CSYNC_out:=’1’; 

HSYNC_out:=’1’; 

VSYNC_out:=’1’; 

HBLANK :=’0’; 

VBLANK :=’0’; 

Abbildung 45: Speedchart-Diagramm VIDEO/SYNC 

VRAM 

VRAM 


T3 

T2 


entry 

T4 

reset 

Abbildung 47: Speedchart-Diagramm VIDEO/VRAM 

Anhang C.2 

Seite 81 


-- Variables of Diagram SYNC 

-- video timing control 

VCNEXT: int16; 

ODD: logic:=’0’; 

IPhase(3): logic:="000"; 

YZOOMST: int7; 

YZOOMCNT: int7:=0; 

VLINE: int16:=0xFFFF; 

HS_Wait: logic; 

HS_Coming: logic; 

Line_Change: logic; 

HS_Enable: logic:=’1’; 

VS_Wait: logic; 

CS_Coming: logic:=’0’; 

VS_Coming: logic; 

CS_Start: int16:=0; 

Next_odd: logic:=’0’; 

Abbildung 46: Variablen im Diagramm VIDEO/SYNC 

RELOAD 

RELOAD 


T3 

T2 


entry 

T4 

reset 

Abbildung 48: Speedchart-Diagramm VIDEO/RELOAD



Lukas Bauer 

S_HCNT 

entry 

A: HCOUNT :=0; 


CSYNC_out:=’0’; 

VLINE :=0xFFFF; 

RELAREA :=’0’; 

HS_Enable:=’1’; 


T1 

T4 #1 

T2 #2 

Diplomarbeit 


C: HS_Wait=’1’ and HCOUNT=HTOTAL 

S1 

T3 #0 

C: HS_Coming=’1’ 

A: HCOUNT:=SETHCNT; 


HS_Enable:=’0’; 

CSYNC_out:=’0’; 


A: -- HCOUNT, start HSYNC 

if HCOUNT=HTOTAL then 

HCOUNT:=0; -- reset counter 

HSYNC_out:=’0’; -- start sync 

HS_Enable:=’0’; -- ignore CSYNC_in 

else 

HCOUNT:=(HCOUNT+257) mod 65536 

when TEST=’1’ and HCOUNT mod 256/=255 

else (HCOUNT+1) mod 65536; -- count up 

end if; 

-- end HSYNC 

if HCOUNT=HESYNC then 

HSYNC_out:=’1’; -- end sync 

end if; 

-- start HBLANK 

if HCOUNT=HSBLNK then 

HBLANK:=’0’; -- start blank 

HS_Enable:=’1’; -- accept CSYNC_in 

-- initialize DPYNEXT and YZOOMCNT at start of field 

if (ILE=’0’ and VCOUNT=VEBLNK) -- noninter line 0 

or (ILE=’1’ and ODD=’0’ and VCOUNT=VEBLNK-1) then -- evenfield line 0 

VLINE:=0; 

RELAREA:=’1’; 

DPYNEXT:=DPYSTRT; 

RELOAD:=’1’; 

if ILE=’1’ then 

YZOOMCNT:=YZOOMST shr 1; 

else 

YZOOMCNT:=YZOOMST; 

end if; 

elsif ILE=’1’ and ODD=’1’ and VCOUNT=VEBLNK then -- oddfield line 1 

VLINE:=1; 


if YZ="000" then 

DPYNEXT:=(DPYSTRT+DPYINC) mod 0x8000000; 

else 

DPYNEXT:=DPYSTRT; 

end if; 



-- end of field 

elsif VCOUNT=VSBLNK -- last line 

or (ILE=’1’ and ODD=’1’ and VCOUNT=VSBLNK+1) then -- last line ILE ODD 

VLINE:=0xFFFF; 


-- in the field: increment DPYNEXT 

elsif RELAREA=’1’ then 

VLINE:=(VLINE+1) mod 65536 when ILE=’0’ -- next line noninter 

else (VLINE+2) mod 65536; -- next line interlaced 


if YZOOMCNT=0 then 

if ILE=’1’ then 


if YZ="000" then 

DPYNEXT:=(DPYNEXT+(DPYINC shl 1)) mod 0x8000000;-- line +2 ILE 

else 

DPYNEXT:=(DPYNEXT+DPYINC) mod 0x8000000; -- line +1 ILE zoom 

end if; 

else 

YZOOMCNT:=YZOOMST; 

DPYNEXT:=(DPYNEXT+DPYINC) mod 0x8000000; -- line +1 NI 

end if; 

else 

YZOOMCNT:=(YZOOMCNT+127) mod 128; -- repeat last line 

end if; 

end if; 

-- end HBLANK 

elsif HCOUNT=HEBLNK then 


HBLANK:=’1’; -- end blank 

RELAT10:=’0’; 

RELAT6:=’0’; 

else 


end if; 

-- reload attention 

if (ILE=’0’ 

and (VCOUNT=VEBLNK 

or (RELAREA=’1’ and VCOUNT/=VSBLNK))) -- line preceding reload 

or (ILE=’1’ 

and ((ODD=’0’ and VCOUNT=VEBLNK-1) 

or (ODD=’1’ and VCOUNT=VEBLNK) 

or (RELAREA=’1’ and VCOUNT/=VSBLNK and 

(ODD=’0’ or VCOUNT/=VSBLNK+1)))) then 

if HCOUNT=(HSBLNK+65526) mod 65536 then -- HSBLANK-10 reload att. 

RELAT10:=’1’; 

end if; 

if HCOUNT=(HSBLNK+65530) mod 65536 then -- HSBLANK-6 reload att. 

RELAT6:=’1’; 

end if; 

end if; 

-- start CSYNC 

if HCOUNT=HTOTAL -- start hs/eq/serr 

or (HCOUNT=HTOTAL shr 1 and ILE=’1’ -- midline eq/serr 

and ((IPhase(2)=’0’ and VCOUNT/=(VESYNC shr 1) + VTOTAL - VSBLNK) 

-- midline csync in eq1/serr/eq2 but not when starting posteq. 

or (IPhase="111" and ODD=’1’ and VCOUNT=VSBLNK))) then 

-- midline csync when starting eq1 

CSYNC_out:=’0’; --> start csync 

end if; 

-- end CSYNC 

if (IPhase(2 downto 1)="11" and HCOUNT=HESYNC) -- end hsync 

or (IPhase(2 downto 1)="01" -- end equalization 

and (HCOUNT=HESYNC shr 1 

or (ILE=’1’ and HCOUNT=((HTOTAL+1) shr 1) + (HESYNC shr 1)))) 

or (IPhase(2 downto 1)="00" -- end serration 

and (HCOUNT=HESERR or HCOUNT=(HTOTAL+1) shr 1 + HESERR)) then 

CSYNC_out:=’1’; --> end csync 

end if; 

Abbildung 49: Speedchart-Diagramm VIDEO/SYNC/S HCNT 

Anhang C.2 

Seite 82

Abbildung 50: Speedchart-Diagramm VIDEO/SYNC/S VCNT 

S_VCNT 

C: ILE=’0’ 

A: VCOUNT:=0; 

IPhase:="000"; -- serration 


VBLANK:=’0’; 

C: VS_Coming=’1’ or 

CS_Coming=’1’ 

A: VCOUNT:=SETVCNT; 


IPhase :="000"; 

VBLANK :=’0’; 

T1 #0 

T3 #0 noninter T4 #1 

T2 #2 

C: Line_Change=’1’ 

A: if VCOUNT=VTOTAL then 

VCOUNT:=0; 

else 

VCOUNT:=VCNEXT; 

end if; 

entry 

C: VS_Wait=’1’ and 

VCOUNT=VTOTAL 

if VCOUNT=VTOTAL then 

VSYNC_out:=’0’; -- start sync 

IPhase:="000"; 

elsif VCOUNT=VESYNC shr 1 then 

VSYNC_out:=’1’; -- end sync 

IPhase:="111"; 

end if; 

if VCOUNT=VSBLNK then 

VBLANK:=’0’; -- start blank 

elsif VCOUNT=VEBLNK then 

VBLANK:=’1’; -- end blank 

end if; 

T8 #1 

A: -- C: ILE=’1’ 

VCOUNT:=0; 





VCOUNT=VTOTAL 

Entry of 

A: ODD:=’1’; 

T7 #1 

odd_field 

T9 #3 

T15 #0 



C: Line_Change=’1’ or HCOUNT=HTOTAL shr 1 

A: case IPhase is 

when "000" => -- serration 


if VCOUNT=VESYNC shr 1 then 

IPhase:="011"; -- equaliz. II 


end if; 

when "011" => -- equaliz. II 

if VCOUNT=(VESYNC shr 1) 

+ VTOTAL - VSBLNK then 

IPhase:="110"; -- picture I 

if NTSC=’1’ then 


end if; 

else 


end if; 

when "110" => -- picture I 

if Line_Change=’1’ then 


if VCOUNT=VEBLNK then 

IPhase:="111"; -- picture II 


end if; 

end if; 

when "111" => -- picture II 


IPhase:="010"; -- equaliz. I 



elsif Line_Change=’1’ then 


end if; 

when others => -- equaliz. I 


end case; 

Entry of 

A: VCOUNT:=SETVCNT; 



C: (CS_Coming=’1’ and Next_odd=’1’) or 

A: -- C: (CS_Coming=’1’ and Next_odd=’0’) or 

(VS_Coming=’1’ and 

-- (VS_Coming=’1’ and 

(HBLANK=’0’ xor NTSC=’0’)) 

-- (HBLANK=’1’ xor NTSC=’0’)) 

T11 #0 

next_field 

T13 #1 

T6 #2 

T5 #2 

T14 #0 



C: (Line_Change=’1’ or HCOUNT=HTOTAL shr 1) 

and VCOUNT=VTOTAL 

A: VCOUNT:=0; 



C: (Line_Change=’1’ or HCOUNT=HTOTAL shr 1) 

and VCOUNT=VTOTAL 

A: VCOUNT:=0; 



even_field 

T10 #3 

Entry of 

A: ODD:=’0’; 


VCOUNT=VTOTAL 

T12 #1 

C: Line_Change=’1’ or HCOUNT=HTOTAL shr 1 

A: case IPhase is 

when "000" => -- serration 


if VCOUNT=VESYNC shr 1 then 

IPhase:="011"; -- equaliz. II 


end if; 

when "011" => -- equaliz. II 

if VCOUNT=(VESYNC shr 1) 

+ VTOTAL - VSBLNK then 

IPhase:="110"; -- picture I 

else 


end if; 

when "110" => -- picture I 

if VCOUNT=VEBLNK then 

IPhase:="111"; -- picture II 



elsif Line_Change=’1’ then 


end if; 

when "111" => -- picture II 

if Line_Change=’1’ then 



IPhase:="010"; -- equaliz. I 



end if; 

end if; 

when others => -- equaliz. I 


end case; 

Subdiag Actions of 

A: -- VCNEXT: next VCOUNT value 

VCNEXT:=(VCOUNT+257) mod 65536 

when TEST=’1’ and VCOUNT mod 256/=255 

else (VCOUNT+1) mod 65536; 

-- HS_Coming: 1=SYNC_in coming at line end 

HS_Coming:=’1’ when (HSin_new=’0’ and HSin_old=’1’ 

and VSD=’0’ and HSD=’0’) 

or (VSin_new=’0’ and VSin_old=’1’ 

and VSD=’0’ and HSD=’1’ 

and CSD=’1’ and ILE=’0’) 

or (CSin_new=’0’ and CSin_old=’1’ 

and CSD=’0’ 

and (VSD=’1’ or HSD=’1’) 

and HS_Enable=’1’) 

else ’0’; 

-- HS_Wait: 1=wait for SYNC_in at line end 

HS_Wait:=’1’ when (VSD=’0’ and HSD=’0’) 

or CSD=’0’ 

or (VSD=’0’ and HSD=’1’ and CSD=’1’ 

and ILE=’0’ and VCOUNT=VTOTAL) 

else ’0’; 

-- Line_Change: 1=line change / HSYNC start 

Line_Change:=’1’ when (HCOUNT=HTOTAL and HS_Wait=’0’) 

or HS_Coming=’1’ 

else ’0’; 

-- VS_Wait: 1=wait for SYNC_in at field end 

VS_Wait:=’1’ when (VSD=’0’ and HSD=’0’) 

or CSD=’0’ 

or (VSD=’0’ and HSD=’1’ and CSD=’1’ 

and ILE=’0’) 

else ’0’; 

-- VS_Coming: 1=VSYNC_in coming 

VS_Coming:=’1’ when VSin_new=’0’ and VSin_old=’1’ 

and VSD=’0’ 

and (HSD=’0’ or (CSD=’1’ and ILE=’0’)) 

else ’0’; 

-- YZOOMST: start value for YZOOM countdown counter 

case YZ is 

when "000" => YZOOMST:=000; 

when "001" => YZOOMST:=001; 

when "010" => YZOOMST:=003; 

when "011" => YZOOMST:=007; 

when "100" => YZOOMST:=015; 

when "101" => YZOOMST:=031; 

when "110" => YZOOMST:=063; 

when "111" => YZOOMST:=127; 

end case; 

-- test outputs 

IPhase_ot :=IPhase; 

ODD_ot :=ODD; 

VLINE_ot :=VLINE mod 256; 

VS_Wt_ot :=VS_Wait; 

CS_Com_ot :=CS_Coming; 

VS_Com_ot :=VS_Coming; 

CS_St_ot :=CS_Start mod 65536; 

Nodd_ot :=Next_odd; 

HS_Ena_ot :=HS_Enable; 



Lukas Bauer 

Diplomarbeit 


Anhang C.2 

Seite 83

Abbildung 51: Speedchart-Diagramm VIDEO/SYNC/CSYNC 

CSYNC 

entry 

T1 

wait_sync 

T15 

C: IPHASE/="000" 

T11 C: CSin_new=’1’ 

C: CSin_new=’0’ and 

CSD=’0’ and 

(VSD=’1’ or HSD=’1’) 

T13 

CS_lo 

T2 T3 #0 

T12 

C: CSin_new=’1’ 

C: CSin_new=’1’ 

T4 #1 

C: ILE=’0’ 

A: CS_Start:=SETHCNT; 

T9 #2 

CS_midline 

T6 

T5 

C: HS_Enable=’0’ -- and ILE=’1’ 

A: CS_Start:=HCOUNT; 

Next_odd:=bnot NTSC; 

CS_nonint 

A: -- C: HS_Enable=’1’ and ILE=’1’ 

CS_Start:=SETHCNT; 

Next_odd:=NTSC; 

CS_newline 


HCOUNT=CS_Start+HESYNC+1 

A: CS_Coming:=’1’; 


HCOUNT=CS_Start+HESYNC 



HCOUNT=CS_Start+HESYNC 


T8 

start_even 

start_nonint 

start_odd 

T10 



T14 


T7 

wait_endserr 



Lukas Bauer 

Diplomarbeit 


Anhang C.2 

Seite 84



Lukas Bauer 

Diplomarbeit 



-- Variables of Diagram VRAM_4_258 

RAS_WE: logic:=’0’; -- MWE at falling edge of RAS 

RAS_SF: logic:=’0’; -- MSF at falling edge of RAS 

RAS_SE: logic:=’0’; -- MSE at falling edge of RAS 

RAS_OE: logic:=’0’; -- MOE at falling edge of RAS 

flag: logic:=’0’; 

DIR_input: logic:=’1’; -- 1=input mode, 

-- last transfer was write 

DoLoad: logic:=’0’; -- 0=load SR counter 

MWE_old: logic:=’0’; 

MWE_falling: logic; 

MSC_old: logic:=’1’; 

MSC_rising: logic; 

CAS_old: logic:=’0’; 

CAS_falling: logic; 

Column(9): logic:=lo9; 

Row(9): logic:=lo9; 

WM1(32): logic:=lo32; -- write mask 

Color(32): logic:=lo32; -- color register 

Anhang C.2 

Seite 85 

TAP(9): logic:=lo9; -- TAP 

LTAP(9): logic:="000000000"; -- TAP for low half SR 

HTAP(9): logic:="100000000"; -- TAP for high half SR 

SRCNT: integer(0 to 511):=0; -- SR counter 

SRCNTV(9): logic; -- SR counter as a vector 

CLRow(9): logic:=lo9; -- current SR row low half 

CHRow(9): logic:=lo9; -- current SR row high half 

NRow(9): logic:=lo9; -- next SR row 

dummy2: logic:=’1’; 

Abbildung 52: Variablen im Diagramm VIDEO/VRAM

Abbildung 53: Speedchart-Diagramm VIDEO/VRAM/VR RAM 

VR_RAM 

C: RAS_itv(0)=’0’ 

A: Row:=RCA_itv(8 downto 0); -- Address 

WM1:=DIN_itv; -- Data in W/IO 

RAS_OE:=MOE_itv; -- DT/OE 

RAS_WE:=MWE_itv; -- WB/WE 

RAS_SF:=MSF_itv; -- DSF 

RAS_SE:=MSE_in; -- SE 

entry 

T1 

standby 

T4 #1 

T28 

C: RAS_itv(0)=’1’ and CAS_itv(0)=’1’ 

T3 

T2 #0 

T22 #1 

Entry of 

A: print "standby"; 

C: RAS_itv(0)=’0’ and CAS_itv(0)=’0’ 

C: CAS_itv(0)=’0’ 

T5 #2 

C: RAS_itv(0)=’1’ 

A: print "CAS before RAS refresh"; 

C: RAS_itv(0)=’1’ 

Entry of 

A: print "ERROR"; 

C: CAS_itv(0)=’0’ 

T24 #0 

ref_OK 

T19 #0 

RAS1 

error 

CAS1 

T20 #0 

C: CAS_itv(0)=’0’ and RAS_OE=’0’ 

T7 #1 

T6 #1 

T37 #2 

C: CAS_itv(0)=’0’ 

-- and RAS_OE=’1’ 

C: CAS_itv(0)=’1’ 

T23 #0 

C: RAS_itv(0)=’1’ 

C: RAS_itv(0)=’0’ 

C: CAS_itv(0)=’1’ 

T21 #1 

CAS_RAS_ref 

Transfer 

done 

T8 OC#0 

T9 OC#0 

Read_Write 

C: RAS_itv(0)=’1’ and 

CAS_itv(0)=’1’ 

A: A_SAM_ot :=0x0; 

C: RAS_itv(0)=’1’ and 

CAS_itv(0)=’1’ 

A: A_RAMw_ot:=0x0; 


A: if standby’active then 

A_CTRL_ot:=0x1; 

elsif ref_OK’active then 


elsif error’active then 


else 


end if; 

D_oe:=’0’; 

VRAM test outputs: 

================== 

A_SAM_ot(4): 

-- 1 split write transfer 

-- 2 split read transfer low 

-- 3 split read transfer high 

-- 4 pseudo write transfer 

-- 5 mask write transfer 

-- 6 real time read transfer 

-- 7 read transfer after WT 

A_RAMw_ot(4): 

-- 1 mask flash write 

-- 2 mask block write 

-- 3 page mode mask block write 

-- 4 block write 

-- 5 page mode block write 

-- 6 load color (early) 

-- 7 load color (delayed) 

-- 8 write (early) 

-- 9 page mode link 

-- A write (WE controlled) 

-- B page mode write (early) 

-- C mask write (early) 

-- D mask write (WE controlled) 

-- E page mode mask write (early) 

A_RAMr_ot(4): 

-- 1 read 

-- 2 read_modify_write read 

-- 3 read color 

A_CTRL_ot(4): 

-- 1 standby 

-- 2 CAS before RAS refresh 

-- 3 error 



Lukas Bauer 

Diplomarbeit 


Anhang C.2 

Seite 86

Abbildung 54: Speedchart-Diagramm VIDEO/VRAM/VR RAM/TRANSFER 

TRANSFER 

C: RAS_WE=’0’ and RAS_SF=’1’ 

A: print "Split_Write - not supported"; 

A_SAM_ot:=0x1; 

Split_WT 

T10 


A: if SRCNTV(8)=’1’ then 

print "Load_low_half_SR" 

& " Tap=" & RCA_itv(7 downto 0) 

& " Row=" & Row; 

LTAP(7 downto 0):=RCA_itv(7 downto 0); 

LTAP(8):=’0’; 

CLRow:=Row; 


else 

print "Load_high_half_SR" 


& " Row=" & Row; 

HTAP(7 downto 0):=RCA_itv(7 downto 0); 

HTAP(8):=’1’; 

CHRow:=Row; 


end if; 

A_TAP_ot(8):=’0’; 

A_TAP_ot(7 downto 0):=RCA_itv(7 downto 0); 

A_ROW_ot:=Row; 

entry 

T12 

Split_RT 

T8 


and RAS_SE=’0’ 

A: TAP:=RCA_itv(8 downto 0); 


and RAS_SE=’1’ 


T9 

T11 



wt_RRT 

T4 

RT 

Mask_WT 

Pseu_WT 

T2 

A: DIR_input:=’1’; 

print"Write_Transfer - not supported"; 


T3 

A: DIR_input:=’1’; 

print"Pseudo_Write_Transfer - not supported"; 


T1 

end4 

end3 

C: DIR_input=’0’ and MOE_itv=’1’ 

A: print "Real_time_read_transfer" 

& " Tap=" & TAP 

& " Row=" & Row; 

NRow:=Row; 

HTAP:="100000000"; 

LTAP:="000000000"; 

DIR_input:=’0’; 

DoLoad:=’1’; -- load counter 


A_TAP_ot:=TAP; 


C: DIR_input=’1’ 

A: print "Read_transfer_after_write" 


& " Row=" & Row; 

NRow:=Row; 

HTAP:="100000000"; 

LTAP:="000000000"; 

DIR_input:=’0’; 

DoLoad:=’1’; -- load counter 


A_TAP_ot:=RCA_itv(8 downto 0); 


T6 

end2 

end1 



Lukas Bauer 

Diplomarbeit 


Anhang C.2 

Seite 87

Abbildung 55: Speedchart-Diagramm VIDEO/VRAM/VR RAM/READ WRITE 

READ_WRITE 


A: A_RAMr_ot:=0x0; 

C: CAS_falling=’1’ 

A: print "PageMode_Mask_BW" 

& " Row=" & Row 

& " Col=" & RCA_itv(8 downto 2) 

& " ColSel=" & DIN_itv 

& " Data(Col)=" & Color; 

A_RAMw_ot:=0x3; 


A_COL_ot(8 downto 2):=RCA_itv(8 downto 2); 

A_COL_ot(1 downto 0):="00"; 

A_RCSL_ot:=DIN_itv; 


T31 #1 

T1 #2 

T32 #1 

Mask_BW 

T2 #2 


Mask_FW 


A: print "PageMode_BW" 

& " Row=" & Row 







A_DATA_ot:=Color; 

BW 

C: RAS_WE=’0’ and RAS_SF=’0’ and MSF_itv=’1’ 

A: print "Mask_BW" 

& " Row=" & Row 


& " ColSel=" & DIN_itv 






A_RCSL_ot:=DIN_itv; 



A: print "Mask_FW" 

& " Row=" & Row 

& " Mask=" & WM1 




A_WM1_ot:=WM1; 


T15 

T14 

T17 


A: print "BW" 

& " Row=" & Row 









A: if MWE_itv=’0’ then 

print "Mask_W(early)" 

& " Row=" & Row 

& " Col=" & RCA_itv 

& " Mask=" & WM1 

& " Data=" & DIN_itv; 

A_RAMw_ot:=0xC; 


A_COL_ot:=RCA_itv(8 downto 0); 


A_DATA_ot:=DIN_itv; 

end if; 

Column:=RCA_itv(8 downto 0); 

entry 

T18 

T13 


and MSF_itv=’0’ 


print "Write(early)" 

& " Row=" & Row 







end if; 

Column:=RCA_itv(8 downto 0); 

T16 



Color:=DIN_itv; 

flag:=’1’; 

print "Load_Col(early)" 

& " C=" & DIN_itv; 



else 

flag:=’0’; 

end if; 

T25 

Color 

State_action of 

A: if MOE_itv=’0’ then 

D_out(24 downto 16):=Row; 

D_out( 8 downto 0):=Column; 

D_oe:=’1’; 

print "RMW_perBit_Read" 

& " Row=" & Row 

& " Col=" & Column; 

A_RAMr_ot:=0x2; 

A_RROW_ot:=Row; 

A_RCOL_ot:=Column; 

end if; 


T3 #4 

Mask_W 

T35 #3 

T34 #2 

T33 #1 


-- and MWE_itv=’1’ 

A: Column:=RCA_itv(8 downto 0); 

print "PageMode_Link"; 



A: if MOE_itv=’0’ then 

D_out(24 downto 16):=Row; 

D_out( 8 downto 0):=Column; 

D_oe:=’1’; 

print "Read" 

& " Row=" & Row 

& " Col=" & Column; 


A_RROW_ot:=Row; 

A_RCOL_ot:=Column; 

end if; 

RW 

T38 #2 

C: CAS_falling=’1’ and MWE_itv=’0’ 

A: print "PageMode_Mask_W(early)" 

& " Row=" & Row 


& " Mask=" & WM1 


A_RAMw_ot:=0xE; 





C: MWE_falling=’1’ 

A: print "Mask_W(WE_ctr)" 

& " Row=" & Row 

& " Col=" & Column 

& " Mask=" & WM1 


A_RAMw_ot:=0xD; 


A_COL_ot:=Column; 



C: CAS_falling=’1’ and MWE_itv=’0’ 

A: print "PageMode_Write(early)" 

& " Row=" & Row 



A_RAMw_ot:=0xB; 





T4 #4 

C: MWE_falling=’1’ 

A: print "Write(WE_ctr)" 

T39 #1 

& " Row=" & Row 

& " Col=" & Column 

T40 #3 



A_RAMw_ot:=0xA; 

-- and MWE_itv=’1’ 


A: Column:=RCA_itv(8 downto 0); 

A_COL_ot:=Column; 

print "PageMode_Link"; 



C: MWE_falling=’1’ and MOE_itv=’1’ 

A: Color:=DIN_itv; 

flag:=’1’; 

print "Load_Col(delayed) C=" & DIN_itv; 




A: if flag=’0’ and MOE_itv=’0’then 

D_out:=Color; 

D_oe:=’1’; 

print "Read_Col C=" & Color; 


end if; 



Lukas Bauer 

Diplomarbeit 


Anhang C.2 

Seite 88



Lukas Bauer 

VR_SAM 

entry 

T1 

S1 

T2 

Diplomarbeit 


Anhang C.2 

Seite 89 


A: SR_Cnt_ot:=SRCNT; 

CLRow_ot:=CLRow; 

CHRow_ot:=CHRow; 

HTAP_ot :=HTAP; 

LTAP_ot :=LTAP; 

TAP_ot :=TAP; 

SRCNTV :=SRCNT; -- Int_to_Vec 

C: MSC_rising=’1’ or Clk_Div=’0’ 

A: if DoLoad=’1’ then 

DoLoad:=’0’; 

SRCNT:=TAP; 

CLRow:=NRow; 

CHRow:=NRow; 

SR_Row_ot:=NRow; 

print "Load_tap SRCNT=" & TAP; 

print "SR_Row=" & NRow; 

elsif SRCNT=511 then 

SRCNT:=LTAP; 

SR_Row_ot:=CLRow; 

print "Wrap_to_lo SRCNT=" & LTAP; 

print "SR_Row=" & CLRow; 

elsif SRCNT=255 then 

SRCNT:=HTAP; 

SR_Row_ot:=CHRow; 

print "Wrap_to_hi SRCNT=" & HTAP; 

print "SR_Row=" & CHRow; 

else 

SRCNT:=(SRCNT+1) mod 512; 

print "Count SRCNT=" & SRCNT+1; 

if SRCNTV(8)=’1’ then 

print "SR_Row=" & CHRow; 

dummy2:=bnot dummy2; -- avoid null statement; 

else 

print "SR_Row=" & CLRow; 

dummy2:=bnot dummy2; -- avoid null statement; 

end if; 

end if; 

Abbildung 56: Speedchart-Diagramm VIDEO/VRAM/VR SAM

Abbildung 57: Speedchart-Diagramm VIDEO/VRAM/VR ATTR 

VR_ATTR 

entry 

T1 

S1 

T2 


A: CAS_falling:=’1’ 

when CAS_itv(0)=’0’ and CAS_old=’1’ 

else ’0’; 

MWE_falling:=’1’ 

when MWE_itv=’0’ and MWE_old=’1’ 

else ’0’; 

MSC_rising:=’1’ 

when MSC_itv=’1’ and MSC_old=’0’ 

else ’0’; 

A: CAS_old:=CAS_itv(0); -- replace ’falling 

MWE_old:=MWE_itv; -- replace ’falling 

MSC_old:=MSC_itv; -- replace ’rising 



Lukas Bauer 

Diplomarbeit 


Anhang C.2 

Seite 90



Lukas Bauer 

INTER 

entry 

S1 

T2 

T1 

Diplomarbeit 


Entry of 

A: -- latch register values 

-- with VClk_in 

-- to avoid meta-stable states 

SETHCNT :=R_SETHCNT; 

HTOTAL :=R_HTOTAL; 

HESYNC :=R_HESYNC; 

HSBLNK :=R_HSBLNK; 

HEBLNK :=R_HEBLNK; 

HESERR :=R_HESERR; 

SETVCNT :=R_SETVCNT; 

VTOTAL :=R_VTOTAL; 

VESYNC :=R_VESYNC; 

VSBLNK :=R_VSBLNK; 

VEBLNK :=R_VEBLNK; 

LINTV :=R_LINTV; 

DPYSTRT :=DPYHELP; 

DPYINC :=R_DPYINC; 

YZ :=R_YZ; 

XZ :=R_XZ; 

MBW :=R_MBW; 

SRL :=R_SRL; 

SRE :=R_SRE; 

RLE :=R_RLE; 

NTSC :=R_VESYNC(1); 

ILE :=R_ILE; 

VEN :=R_VEN; 

TEST :=R_TEST; 

CSD :=R_CSD; 

HSD :=R_HSD; 

VSD :=R_VSD; 

RF :=R_RF; 

FASTRAM :=R_FASTRAM; 

-- latch SYNC inputs twice 

-- for detecting SYNC’rising 

-- in asynchronous blocks 

HSin_new:=HSYNC_in; 

HSin_old:=HSin_new; 

VSin_new:=VSYNC_in; 

VSin_old:=VSin_new; 

CSin_new:=CSYNC_in; 

CSin_old:=CSin_new; 

-- latch some signals 

-- to replace XXX’changing 

CSD_last:=CSD; 

VSD_last:=VSD; 

HSD_last:=HSD; 

ILE_last:=ILE; 

HTOTAL_last:=HTOTAL; 

VTOTAL_last:=VTOTAL; 

Abbildung 58: Speedchart-Diagramm VIDEO/INTER 


A: -- video signals 

CBLANK_out :=HBLANK band VBLANK band VEN; 

HBLANK_out :=HBLANK; 

VBLANK_out :=VBLANK; 

CSYNC_oe :=R_CSD; 

HSYNC_oe :=R_HSD; 

VSYNC_oe :=R_VSD; 

-- VRAM signals 

MSC_out :=MSC_itv; 

-- interrupt outputs 

VIRQ_out :=VBLANK; 

HIRQ_out :=’0’ when VCOUNT=LINTV 

else ’1’; 

-- read-only registers 

R_HCOUNT :=HCOUNT mod 65536; 

S_HCOUNT :=HCOUNT mod 256; 

R_VCOUNT :=VCOUNT mod 65536; 

S_VCOUNT :=VCOUNT mod 256; 

Anhang C.2 

Seite 91 

if MBW(1)=’1’ then -- 32 bit MBW 

R_DPYNEXT(31 downto 5):=DPYNEXT mod 0x8000000; 

R_DPYNEXT(4 downto 0):="00000"; 

S_DPYNEXT(11 downto 5):=DPYNEXT mod 128; 

S_DPYNEXT(4 downto 0):="00000"; 

elsif MBW(0)=’1’ then -- 16 bit MBW 

R_DPYNEXT(31):=’0’; 

R_DPYNEXT(30 downto 5):=(DPYNEXT shr 1) mod 0x4000000; 


S_DPYNEXT(11 downto 5):=(DPYNEXT shr 1) mod 128; 


else 


R_DPYNEXT(29 downto 5):=(DPYNEXT shr 2) mod 0x2000000; 


S_DPYNEXT(11 downto 5):=(DPYNEXT shr 2) mod 128; 


end if; 


RELOAD_ot :=RELOAD; 

REL10_ot :=RELAT10; 

REL6_ot :=RELAT6; 

MLR10_ot :=MLRAT10; 

MLR6_ot :=MLRAT6; 

RELAREA_ot :=RELAREA; 

-- convert DPYNEXT to a vector 

DPYNEXTV :=DPYNEXT mod 0x8000000; 

-- determine DPYSTART memory word address 

if MBW(1)=’1’ then -- 32 bit MBW 

DPYHELP:=R_DPYSTRT(31 downto 5); 

elsif MBW(0)=’1’ then -- 16 bit MBW 

DPYHELP(26 downto 1):=R_DPYSTRT(30 downto 5); 

DPYHELP(0):=’0’; 

else 

DPYHELP(26 downto 2):=R_DPYSTRT(29 downto 5); 

DPYHELP(1 downto 0):="00"; 

end if;



Lukas Bauer 


-- Variables of Diagram RELOAD 

-- MSC control 

Diplomarbeit 


DISINC: logic:=’1’; -- ’1’ = disable TAPCNT increment 

DISCLK: logic:=’1’; -- ’1’ = disable MSC output 

MSCNT: int12:=0x0FFF; -- XZoom: counter for MSC/LD divider 

MSCNTV(12): logic; -- MSCNT as a logic vector 

TAPCNT: int11:=0; -- TAP position counter 

TAPCNTV(11): logic; -- TAPCNT as a logic vector 

ROWCNT: int12:=0; -- current row in SR 

-- determine number of VClk cycles per memory word of video data 

LD_XZ: int4; -- ld of XZOOM factor 

LD_MBW: int4; -- ld of memory bus width 

LD_PSIZE: int4; -- ld of bits per pixel 

MSC_SFT: int4:=0; -- ld of (VClk cycles per mem word) 

-- determine the number of reloads necessary in the next line 

Anhang C.2 

Seite 92 

CALC_RLL: int16; -- (Register Line Length) -1 

CALC_ELL: int16:=0; -- (Effective Line Length in VClk cycles)-1 

CALC_NRL: int8 :=0; -- # of low half SR reloads in next line 

CALC_NRH: int8 :=0; -- # of high half SR reloads in next line 

SUM_TAP_ELL: int12:=0; -- sum of TAP and ELL 

SUM_TE_V(12): logic; -- SUM_TAP_ELL as a logic vector 

SUM_TE_A: logic; -- sum of TAP and ELL, carry out bit 

SUM_TE_B: logic; -- sum of TAP and ELL, highest bit 

CALC_ELL_SFT: int8; -- ELL divided by Shift Reg Length 

-- reload control 

SMR_high: logic:=’0’; -- ’1’ = next split rel. of high half SR 

HC_MLR: int16:=0; -- HCOUNT value at point of midline reload 

HC_MLR5: int16:=0; -- HCOUNT value at start of early ml reload 


-- refresh control 

REFCNT: int11:=0x7FF; -- refresh rate counter 

-- arbitration control 

SMR_request: logic:=’0’; -- ’1’ = request split reload 

SMR_ack: logic:=’0’; -- ’1’=acknowledge, perform split midl. rel. 

REF_RQNR: int4:=0; -- number of refresh cycles desired 

REF_PFNR: int4:=0; -- number of refresh cycles performed 

-- n. of r.c. lagging: (REF_RQNR-REF_PFNR) 

REF_ack: logic:=’0’; -- ’1’=acknowledge, perform refresh cycle 

ARB_busy: logic; -- ’1’=reload or refresh unit busy 

Abbildung 59: Variablen im Diagramm VIDEO/RELOAD

Abbildung 60: Speedchart-Diagramm VIDEO/RELOAD/RL RAM 

RL_RAM 

refresh 

C: REF_ack=’1’ 

T14 

C: refresh’complete 

A: REF_PFNR:= 

(REF_PFNR+1) mod 16; 

T15 

entry 

T5 

T2 

C: midl_rel’complete 

A: MLRAT6 :=’0’; 

MLRAT10 :=’0’; 

stdby 

T9 

midl_rel 

C: newl_rel’complete 

A: RELAT10 :=’0’; 

RELAT6 :=’0’; 

T1 

C: RELOAD=’1’ and RLE=’1’ 

C: split_mlr’complete 

A: RELAT10 :=’0’; 

RELAT6 :=’0’; 

C: SMR_ack=’1’ 

T6 

T3 #1 

C: RLE=’1’ and SRE=’0’ and CALC_NRL/=0 and 

(( (MSC_SFT=0 and TAPCNT=0x7FA and MSCNT=0xFFF 

and DISINC=’0’) 

or (MSC_SFT=0 and TAPCNT=0x7FB and DISINC=’1’) 

-- start of midl rel with start of display area 

or (MSC_SFT=1 and TAPCNT=0x7FD and MSCNT=0xFFE) 

or (MSC_SFT=2 and TAPCNT=0x7FE and MSCNT=0xFFE) 

or (MSC_SFT>2 and TAPCNT=0x7FF and MSCNT=0xFFA)) 

or (HCOUNT=HC_MLR5 and HC_MEN5=’1’)) 

T4 

newl_rel 

wait1 

T8 

T7 #0 

split_mlr 

C: newl_rel’complete 

and SRE=’1’ 

and CALC_NRL/=0 

and ((SRL="00" and DPYNEXTV(7)=’1’) 

or (SRL="01" and DPYNEXTV(8)=’1’) 

or (SRL="10" and DPYNEXTV(9)=’1’) 

or (SRL="11" and DPYNEXTV(10)=’1’)) 

-- TAP start in high half of SR 

A: SMR_high:=’0’; -- preload low half SR 


A: ARB_busy:=’0’ when stdby’active 

else ’1’; 



Lukas Bauer 

Diplomarbeit 


Anhang C.2 

Seite 93



Lukas Bauer 

MIDL_REL 

entry 

Diplomarbeit 


T9 

A: -- 1st cycle of midline reload 

RCA_itv:=(ROWCNT + 1) mod 4096; 

ROWCNT:=(ROWCNT + 1) mod 4096; 

CALC_NRL:=CALC_NRL - 1; 

RAS_itv:="1111"; 

CAS_itv:="1111"; 

MWE_itv:=’1’; 

MOE_itv:=’0’; 

MSF_itv:=’0’; 

T10 

T1 

T2 

T13 

Abbildung 61: Speedchart-Diagramm VIDEO/RELOAD/RL RAM/MIDL REL 

T3 

S1 

S2 

S3 

S4 

S5 

exit 

Anhang C.2 

Seite 94 

A: -- 2nd cycle 

RAS_itv:="1110"; 

A: -- 3rd cycle 

RCA_itv:=lo12; 

A: -- 4th cycle 

CAS_itv:="0000"; 


RCA_itv:=0xFFF; 



RAS_itv:="1111"; 

CAS_itv:="1111";

Abbildung 62: Speedchart-Diagramm VIDEO/RELOAD/RL RAM/NEWL REL 

NEWL_REL 

entry 

T1 

S1 

T2 

S2 

T4 

A: -- 1st cycle of newline reload 



RAS_itv:="1111"; 

CAS_itv:="1111"; 

RAS_itv:="1110"; 

RCA_itv:=DPYNEXTV(11 downto 0); 


-- calculate # of reloads necessary in next line 

-- calculate HCOUNT value for start of 


-- CALC_NRL: SRE=’0’: number of non-split reloads 

-- MLRAT6 and MLRAT10 midl. rel. attention signals 


-- SRE=’1’: # of split low half SR rel. 

-- CALC_NRH: SRE=’0’: no function 

-- and MLRAT5 midline reload start signal 

-- and calculation of SUM_TAP_ELL 

-- SRE=’1’: # of split high half SR rel. 

if HC_MEN5=’1’ then 

-- and calculation of TAPCNT (TAP position) 

if HC_MLR>=5 then 

if SUM_TE_A=’1’ then 

HC_MLR5:=HC_MLR-5; 

case SRL is 

CALC_NRL:=(CALC_ELL_SFT + 1) mod 256; 

else 

when "00" => -- SRL: 256 words 

else 

HC_MLR5:=(HC_MLR+HTOTAL-4) mod 65536; 


CALC_NRL:=CALC_ELL_SFT; 

end if; 

ROWCNT:=(DPYNEXT shr 8) mod 4096; 

TAPCNT:=(DPYNEXT mod 256) + 0x700; 

end if; 

end if; 

SUM_TAP_ELL:=(DPYNEXT mod 256) + (CALC_ELL mod 256); 

CALC_NRH:=(CALC_ELL_SFT + 1) mod 256 


when SUM_TE_A=’1’ and SUM_TE_B=’1’ 


when "01" => -- SRL: 512 words 

else (CALC_ELL_SFT - 1) 



when SUM_TE_A=’0’ and SUM_TE_B=’0’ 

else 


and CALC_ELL_SFT/=0 



else CALC_ELL_SFT; 

end if; 


-- calculate HCOUNT value at point of midline reload 

end if; 

when "10" => -- SRL: 1024 words 



case MSC_SFT is 



when 0 => HC_MLR:=(HEBLNK+(0x800-TAPCNT)) mod 65536; 



when 1 => HC_MLR:=(HEBLNK+(0x800-TAPCNT) shl 1) mod 65536; 

else 





end if; 

when "11" => -- SRL: 2048 words 


end if; 




TAPCNT:=DPYNEXT mod 2048; 

end case; 


-- determine if HCOUNT has to be regarded to 

end case; 

-- generate midline reload attention signals 

-- disable HC_MLR6 and HC_MLR10 signals 


when 0 => if TAPCNT>0x7FB then -- 0x800 -5 

HC_MEN5 :=’0’; 

HC_MEN5:=’1’; 

HC_MEN6 :=’0’; 

end if; 

HC_MEN10:=’0’; 

if TAPCNT>0x7F5 then -- 0x800 -11 (5+6) 

HC_MEN6:=’1’; 

end if; 

if TAPCNT>0x7F1 then -- 0x800 -15 (5+10) 

HC_MEN10:=’1’; 

end if; 

when 1 => if TAPCNT>0x7FD then -- 0x800 -(5/2 up) 

HC_MEN5:=’1’; 

end if; 

if TAPCNT>0x7FA then -- 0x800 -(11/2 up) 

HC_MEN6:=’1’; 

end if; 

if TAPCNT>0x7F8 then -- 0x800 -(15/2 up) 

HC_MEN10:=’1’; 

end if; 

when 2 => if TAPCNT=0x7FF then -- 0x800 -(5/4 up) 

HC_MEN5:=’1’; 

end if; 

if TAPCNT>0x7FD then -- 0x800 -(11/4 up) 

HC_MEN6:=’1’; 

end if; 

if TAPCNT>0x7FC then -- 0x800 -(15/4 up) 

HC_MEN10:=’1’; 

end if; 

when 3 => if TAPCNT=0x7FF then -- 0x800 -(11/8 up) 

HC_MEN6:=’1’; 

HC_MEN10:=’1’; -- 0x800 -(15/8 up) 

end if; 

end case; 

T6 

T7 

T3 

T5 

S3 

S4 

S5 

S6 

exit 


CAS_itv:="0000"; 





RAS_itv:="1111"; 

CAS_itv:="1111"; 

MSC_reload:=’0’; -- MSC low pulse 

-- after newline reload 

A: MSC_reload:=’1’; 



Lukas Bauer 

Diplomarbeit 


Anhang C.2 

Seite 95



Lukas Bauer 

SPLIT_MLR 

entry 

Diplomarbeit 


T9 

A: -- 1st cycle of split midl. rel. 

if SMR_high=’1’ then 

RCA_itv:=ROWCNT; 

CALC_NRH:=CALC_NRH - 1; 

else 

RCA_itv:=(ROWCNT + 1) mod 4096; 

ROWCNT:=(ROWCNT + 1) mod 4096; 

CALC_NRL:=CALC_NRL - 1; 

end if; 

RAS_itv:="1111"; 

CAS_itv:="1111"; 




SMR_request:=’0’; 

T10 

T1 

T2 

T13 

Abbildung 63: Speedchart-Diagramm VIDEO/RELOAD/RL RAM/SPLIT MLR 

T3 

S1 

S2 

S3 

S4 

S5 

exit 

Anhang C.2 

Seite 96 


RAS_itv:="1110"; 


RCA_itv:=lo12; 


CAS_itv:="0000"; 






RAS_itv:="1111"; 

CAS_itv:="1111";



Lukas Bauer 

REFRESH 

entry 

Diplomarbeit 


T1 

A: -- 1st cycle of 

-- CAS before RAS 

-- refresh 

RAS_itv:="1111"; 

CAS_itv:="0000"; 

T7 #0 

C: FASTRAM=’1’ 

T2 

T3 

T5 

T6 

S1 

S2 

S3 

S4 

exit 

Abbildung 64: Speedchart-Diagramm VIDEO/RELOAD/RL RAM/REFRESH 

S5 

T4 #1 

Anhang C.2 

Seite 97 


RAS_itv:="0000"; 





RAS_itv:="1111"; 

CAS_itv:="1111";



Lukas Bauer 

RL_MSC 

entry 

T1 

blank 


A: MSCNTV:=MSCNT mod 4096; 

Diplomarbeit 


C: (HCOUNT+1) mod 65536=HSBLNK 

-- HCOUNT=HSBLNK-1 

A: DISCLK:=’1’; 

MSCNT:=0; 

T3 #0 

T2 

C: RELAREA=’1’ and RLE=’1’ and 

(HCOUNT+1) mod 65536=HEBLNK 

-- HCOUNT=HEBLNK-1 

A: DISCLK:=’0’; 

MSCNT:=0xFFF; 

DISINC:=’1’; 

if MSC_SFT=0 then 

MSC_itv:=(DISCLK bor VClk_in) 

band MSC_reload; -- pulse after reload 

else 

MSC_itv:=’0’ 

when ((MSCNT=0xFFE and DISINC=’0’) 

or MSC_reload=’0’) 

else ’1’; 

end if; 

clock 

case XZ is 

when "000" => LD_itv:=DISCLK bor VClk_in; 

when "001" => LD_itv:=’0’ 

when MSCNTV(0)=’1’ else ’1’; 

when "010" => LD_itv:=’0’ 

when MSCNTV(1 downto 0)="11" 

else ’1’; 

when "011" => LD_itv:=’0’ 


else ’1’; 

when "100" => LD_itv:=’0’ 


else ’1’; 

when "101" => LD_itv:=’0’ 


else ’1’; 

when "110" => LD_itv:=’0’ 


else ’1’; 

when "111" => LD_itv:=’0’ 


else ’1’; 

end case; 


DISCLK_ot :=DISCLK; 

MSC_ot :=MSC_itv; 

LD_ot :=LD_itv; 

RAS_ot :=RAS_itv; 

CAS_ot :=CAS_itv; 

MOE_ot :=MOE_itv; 

MWE_ot :=MWE_itv; 

MSF_ot :=MSF_itv; 

RCA_ot :=RCA_itv(8 downto 0); 

MSCNT_ot :=MSCNT mod 4096; 

TAPCNT_ot :=TAPCNT mod 2048; 

ROWCNT_ot :=ROWCNT mod 4096; 

CALC_NRL_ot :=CALC_NRL mod 256; 

CALC_NRH_ot :=CALC_NRH mod 256; 

SMR_req_ot :=SMR_request; 

SMR_high_ot :=SMR_high; 

-- for VRAM model control: 

Clk_Div:=’0’ when MSC_SFT=0 

and DISCLK=’0’ -- MSC = VClk 

and DISINC=’0’ -- disable 1st pulse 

else ’1’; 

T4 #1 

Abbildung 65: Speedchart-Diagramm VIDEO/RELOAD/RL MSC 

Anhang C.2 

Seite 98 

A: case MSC_SFT is 

when 0 => MSCNT:=0xFFF; 

when 1 => MSCNT:=((MSCNT + 1) mod 2) + 0xFFE; 

when 2 => MSCNT:=((MSCNT + 1) mod 4) + 0xFFC; 

when 3 => MSCNT:=((MSCNT + 1) mod 8) + 0xFF8; 

when 4 => MSCNT:=((MSCNT + 1) mod 16) + 0xFF0; 

when 5 => MSCNT:=((MSCNT + 1) mod 32) + 0xFE0; 

when 6 => MSCNT:=((MSCNT + 1) mod 64) + 0xFC0; 

when 7 => MSCNT:=((MSCNT + 1) mod 128) + 0xF80; 

when 8 => MSCNT:=((MSCNT + 1) mod 256) + 0xF00; 

when 9 => MSCNT:=((MSCNT + 1) mod 512) + 0xE00; 

when 10 => MSCNT:=((MSCNT + 1) mod 1024) + 0xC00; 

when 11 => MSCNT:=((MSCNT + 1) mod 2048) + 0x800; 

when others => MSCNT:=(MSCNT + 1) mod 4096; 

end case; 

if MSCNT=0xFFF and DISINC=’0’ then 

TAPCNT:=TAPCNT + 1 when TAPCNT/=0x7FF 

else 0x000 when SRL="11" -- 2048-2048 

else 0x400 when SRL="10" -- 2048-1024 

else 0x600 when SRL="01" -- 2048-512 

else 0x700; -- 2048-256 

end if; 

if MSCNT=0xFFF and DISINC=’0’ and CALC_NRH/=0 

and TAPCNT=0x7FF then 


SMR_high:=’1’; -- high half SR data just finished 

end if; 

if MSCNT=0xFFF and DISINC=’0’ and CALC_NRL/=0 

and ((SRL="00" and TAPCNT=0x77F) 

or (SRL="01" and TAPCNT=0x6FF) 

or (SRL="10" and TAPCNT=0x5FF) 

or (SRL="11" and TAPCNT=0x3FF)) then 


SMR_high:=’0’; -- low half SR data just finished 

end if; 

DISINC:=’0’;



Lukas Bauer 

RL_CALC 

Diplomarbeit 


T5 

entry S1 


A: -- determine number of VClk cycles 

-- per memory word of video data 

LD_XZ:=0 when XZ="000" 

else 1 when XZ="001" 






else 7; 

LD_MBW:=5 when MBW(1)=’1’ 

else 4 when MBW="01" 

else 3; 

LD_PSIZE:=5 when R_PSIZE(5)=’1’ 

else 4 when R_PSIZE(5 downto 4)="01" 




else 0; 

CALC_RLL:=((HSBLNK-HEBLNK) + 65535) mod 65536; 

-- (Register Line Length) -1 

SUM_TE_V:=SUM_TAP_ELL mod 4096; 

case SRL is 

when "00" => -- SRL: 256 bits 

SUM_TE_A:=SUM_TE_V(8); 

SUM_TE_B:=SUM_TE_V(7); 

CALC_ELL_SFT:=(CALC_ELL shr 8) mod 256; 

when "01" => -- SRL: 512 bits 




when "10" => -- SRL: 1024 bits 




when "11" => -- SRL: 2048 bits 




end case; 

-- test output 

MSCSFT_ot :=MSC_SFT mod 16; 

Abbildung 66: Speedchart-Diagramm VIDEO/RELOAD/RL CALC 

T1 

A: -- determine number of VClk cycles 

-- per memory word of video data 

MSC_SFT:=(LD_XZ + LD_MBW) - LD_PSIZE; 

Anhang C.2 

Seite 99 


when 0 => CALC_ELL:=CALC_RLL; 

when 1 => CALC_ELL:=CALC_RLL shr 1; 











when others => CALC_ELL:=CALC_RLL shr 12; 

-- (Effective Line Length in mem words) -1 

end case;



Lukas Bauer 

RL_REFRESH 

T1 

entry S1 

Diplomarbeit 


T2 

A: -- increment refresh counter 

if REFCNT=0x7FF then 

case RF is 

when "000" => REFCNT:=0x7E0; -- cycle 32 

when "001" => REFCNT:=0x7C0; -- cycle 64 

when "010" => REFCNT:=0x780; -- cycle 128 





when "111" => REF_RQNR:=0; -- no refresh 

end case; 

else 

REFCNT:=REFCNT+1; 

end if; 

-- increment number of refresh cycles requested 

if REFCNT=0x7FF and RF/="111" then 

REF_RQNR:=(REF_RQNR+1) mod 16; 

end if; 

-- set MLRAT6 and MLRAT10 attention signals 

-- 6 or 10 VClk cycles before midline reload starts 

-- (11 or 15 VClk cycles before actual reload) 

if RLE=’1’ and SRE=’0’ and CALC_NRL/=0 and 

( (MSC_SFT=0 and TAPCNT=0x7F4 and MSCNT=0xFFF 

and DISINC=’0’ ) -- 11+0 

or (MSC_SFT=0 and TAPCNT=0x7F5 and DISINC=’1’ ) -- 11+0 

or (MSC_SFT=1 and TAPCNT=0x7FA and MSCNT=0xFFE) -- 5*2+1 

or (MSC_SFT=2 and TAPCNT=0x7FD and MSCNT=0xFFC) -- 2*4+3 

or (MSC_SFT=3 and TAPCNT=0x7FE and MSCNT=0xFFC) -- 1*8+3 

or (MSC_SFT>3 and TAPCNT=0x7FF and MSCNT=0xFF4) -- 0*16+11 

or (HC_MEN6=’1’ and HCOUNT=HC_MLR6)) then 

MLRAT6:=’1’; 

end if; 

if RLE=’1’ and SRE=’0’ and CALC_NRL/=0 and 

( (MSC_SFT=0 and TAPCNT=0x7F0 and MSCNT=0xFFF 

and DISINC=’0’ ) -- 15+0 

or (MSC_SFT=0 and TAPCNT=0x7F1 and DISINC=’1’ ) -- 15+0 

or (MSC_SFT=1 and TAPCNT=0x7F8 and MSCNT=0xFFE) -- 7*2+1 

or (MSC_SFT=2 and TAPCNT=0x7FC and MSCNT=0xFFC) -- 3*4+3 

or (MSC_SFT=3 and TAPCNT=0x7FE and MSCNT=0xFF8) -- 1*8+7 

or (MSC_SFT>3 and TAPCNT=0x7FF and MSCNT=0xFF0) -- 0*16+15 

or (HC_MEN10=’1’ and HCOUNT=HC_MLR10)) then 

MLRAT10:=’1’; 

end if; 

Abbildung 67: Speedchart-Diagramm VIDEO/RELOAD/RL REFRESH 

Anhang C.2 

Seite 100

Abbildung 68: Speedchart-Diagramm VIDEO/RELOAD/RL ARBIT 

RL_ARBIT 

REF 


A: REFPFNR_ot :=REF_PFNR; 

REFRQNR_ot :=REF_RQNR; 

HCMEN6_ot :=HC_MEN6; 

HCMLR6_ot :=HC_MLR6 mod 65536; 

HCMEN10_ot :=HC_MEN10; 

HCMLR10_ot :=HC_MLR10 mod 65536; 

A: REF_ack:=’0’; 

T4 #2 

T6 #0 

T5 

C: REF_PFNR/=REF_RQNR 

and RELAT6=’0’ 

and MLRAT6=’0’ 

and ARB_busy=’0’ 


C: ((REF_RQNR +16 -REF_PFNR) mod 16) > 12 

-- more than 12 refresh cycles lagging 



entry 

T1 

stdby 

A: SMR_ack:=’0’; 

T3 

T2 #1 

C: SRE=’1’ and RLE=’1’ 

and SMR_request=’1’ 


A: SMR_ack:=’1’; 

SMR 



Lukas Bauer 

Diplomarbeit 


Anhang C.2 

Seite 101

Abbildung 69: Video-Timing-Signale im Vollbildbetrieb, interne Synchronisation 

0s 

0s 

/pattn /pattnhex 

/s_hcount 

/s_hcounthex 

/s_vcount 

/s_vcounthex 

/hsync_in 

/hsync_ina1 

a1 

/hsync_out 

/hsync_outiX 

iX 

/hblank_out 

/hblank_outa0 

a0 

/csync_in 

/csync_ina1 

a1 

/csync_out 

/csync_outiX 

iX 

/vline_ot 

/vline_othex 

/cblank_out 

/cblank_outa0 

a0 

/vsync_in 

/vsync_ina1 

a1 

/vsync_out 

/vsync_outiX 

iX 

/vblank_out 

/vblank_outa0 

a0 

/iphase_ot 

/iphase_othex 

/odd_ot /odd_ota0 

a0 

VHDL 2000 

0 

07 08 09 00 01 02 03 04 05 06 07 08 09 00 01 

05 ff 00 01 02 03 04 05 ff 

7 0 7 0 

2.5us 3us 3.5us 4us 4.5us 5us 5.5us 6us 6.5us 



Lukas Bauer 

Diplomarbeit 


Anhang C.3 

Seite 102

Abbildung 70: Video-Timing-Signale im Halbbildbetrieb (NTSC), interne Synchronisation 

0s 

0s 


/s_hcount 

/s_hcounthex 

/s_vcount 

/s_vcounthex 

/hsync_in 

/hsync_ina1 

a1 

/hsync_out 

/hsync_outiX 

iX 

/hblank_out 

/hblank_outa0 

a0 

/csync_in 

/csync_ina1 

a1 

/csync_out 

/csync_outiX 

iX 

/vline_ot 

/vline_othex 

/cblank_out 

/cblank_outa0 

a0 

/vsync_in 

/vsync_ina1 

a1 

/vsync_out 

/vsync_outiX 

iX 

/vblank_out 

/vblank_outa0 

a0 

/iphase_ot 

/iphase_othex 


a0 

VHDL 2000 

1 

0d 0e 0f 10 11 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 00 01 

06 ff 01 03 05 07 ff 

7 2 0 3 6 7 2 0 

13.5us 14us 14.5us 15us 15.5us 16us 16.5us 17us 17.5us 18us 



Lukas Bauer 

Diplomarbeit 


Anhang C.3 

Seite 103

Abbildung 71: Video-Timing-Signale im Vollbildbetrieb, HSYNC und VSYNC sind Eingänge 

0s 

0s 


/s_hcount 

/s_hcounthex 

/s_vcount 

/s_vcounthex 

/hsync_in 

/hsync_ina1 

a1 

/hsync_out 

/hsync_outiX 

iX 

/hblank_out 

/hblank_outa0 

a0 

/csync_in 

/csync_ina1 

a1 

/csync_out 

/csync_outiX 

iX 

/vline_ot 

/vline_othex 

/cblank_out 

/cblank_outa0 

a0 

/vsync_in 

/vsync_ina1 

a1 

/vsync_out 

/vsync_outiX 

iX 

/vblank_out 

/vblank_outa0 

a0 

/iphase_ot 

/iphase_othex 


a0 

VHDL 2000 

6 

07 08 09 00 01 02 03 

05 ff 00 

7 0 7 

78.5us 79us 79.5us 80us 80.5us 81us 81.5us 



Lukas Bauer 

Diplomarbeit 


Anhang C.3 

Seite 104

Abbildung 72: Video-Timing-Signale im Halbbildbetrieb (NTSC), HSYNC und VSYNC sind Eingänge 

0s 

0s 


/s_hcount 

/s_hcounthex 

/s_vcount 

/s_vcounthex 

/hsync_in 

/hsync_ina1 

a1 

/hsync_out 

/hsync_outiX 

iX 

/hblank_out 

/hblank_outa0 

a0 

/csync_in 

/csync_ina1 

a1 

/csync_out 

/csync_outiX 

iX 

/vline_ot 

/vline_othex 

/cblank_out 

/cblank_outa0 

a0 

/vsync_in 

/vsync_ina1 

a1 

/vsync_out 

/vsync_outiX 

iX 

/vblank_out 

/vblank_outa0 

a0 

/iphase_ot 

/iphase_othex 


a0 

VHDL 2000 

1f 0c 0d 0e 0f 10 11 12 13 14 15 16 17 18 1f 

c 

ff 01 03 05 07 09 0b 0d 0f 11 13 15 17 ff 

2 0 3 6 7 2 0 

186us 188us 190us 192us 194us 196us 198us 200us 202us 204us 



Lukas Bauer 

Diplomarbeit 


Anhang C.3 

Seite 105

Abbildung 73: Video-Timing-Signale im Vollbildbetrieb, CSYNC ist Eingang 

0s 

0s 


/s_hcount 

/s_hcounthex 

/s_vcount 

/s_vcounthex 

/hsync_in 

/hsync_ina1 

a1 

/hsync_out 

/hsync_outiX 

iX 

/hblank_out 

/hblank_outa0 

a0 

/csync_in 

/csync_ina1 

a1 

/csync_out 

/csync_outiX 

iX 

/vline_ot 

/vline_othex 

/cblank_out 

/cblank_outa0 

a0 

/vsync_in 

/vsync_ina1 

a1 

/vsync_out 

/vsync_outiX 

iX 

/vblank_out 

/vblank_outa0 

a0 

/iphase_ot 

/iphase_othex 


a0 

VHDL 2000 

a 

0f 0f 0f 0f 0f 0f 

07 08 09 00 01 02 

04 05 ff 

7 0 7 

134us 134.5us 135us 135.5us 136us 136.5us 137us 137.5us 



Lukas Bauer 

Diplomarbeit 


Anhang C.3 

Seite 106

Midline Reload kurz vor Zeilenende (Zeile 012, TAP 000) und Newline Reload (Zeile 013, TAP 1CA) 

Abbildung 74: VRAM-Reload-Signale für XZ=0, MSC SFT=0: 

0s 

0s 


/rowcnt_ot 

/rowcnt_othex 

/tapcnt_ot 

/tapcnt_othex 

/mscnt_ot 

/mscnt_othex 

/cas_ot(0) a1 a1 

/ras_ot(0) a1 a1 

/rca_ot /rca_othex 

/mwe_ot /mwe_ota1 

a1 

/moe_ot /moe_ota1 

a1 

/msf_ot /msf_ota0 

a0 

/ld_ot /ld_ota1 

a1 

/msc_ot /msc_ota1 

a1 

/hblank_out 

/hblank_outa0 

a0 

/sr_row_ot 

/sr_row_othex 

/sr_cnt_ot 

/sr_cnt_othex 

/vclk_in /vclk_ina1 

a1 

/calc_nrh_ot 

/calc_nrh_othex 

/calc_nrl_ot 

/calc_nrl_othex 

/smr_req_ot 

/smr_req_ota0 

a0 

/refrqnr_ot 

/refrqnr_othex 

/refpfnr_ot 

/refpfnr_othex 

/a_sam_ot 

/a_sam_othex 

/a_ctrl_ot 

/a_ctrl_othex 

/rel6_ot /rel6_ota0 

a0 

/mlr6_ot /mlr6_ota0 

a0 

VHDL 2000 

011 012 013 

7f7 7f8 7f9 7fa 7fb 7fc 7fd 7fe 7ff 7ca 

fff 000 

1ff 012 000 1ff 013 1ca 1ff 

011 012 013 

1f7 1f8 1f9 1fa 1fb 1fc 1fd 1fe 1ff 000 001 1ca 

00 

01 00 01 

5 6 

5 

3 

0 6 0 6 0 

1 0 1 0 1 0 

21.1us 21.15us 21.2us 21.25us 21.3us 21.35us 21.4us 21.45us 21.5us 21.55us 21.6us 21.65us 21.7us 



Lukas Bauer 

Diplomarbeit 


Anhang C.3 

Seite 107


Newline Reload (Zeile 011, TAP 1C9) und Refresh 

0s 

0s 


/rowcnt_ot 

/rowcnt_othex 

/tapcnt_ot 

/tapcnt_othex 

/mscnt_ot 

/mscnt_othex 





a1 


a1 


a0 


a1 


a1 

/hblank_out 

/hblank_outa0 

a0 

/sr_row_ot 

/sr_row_othex 

/sr_cnt_ot 

/sr_cnt_othex 


a1 

/calc_nrh_ot 


/calc_nrl_ot 


/smr_req_ot 

/smr_req_ota0 

a0 

/refrqnr_ot 


/refpfnr_ot 


/a_sam_ot 

/a_sam_othex 

/a_ctrl_ot 

/a_ctrl_othex 


a0 


a0 

VHDL 2000 

3 

00f 011 

7fa 7fb 7fc 7fd 7fe 7c9 7ca 7cb 

fff 000 fff 

1ff 011 1c9 1ff 

00f 011 

1fa 1fb 1fc 1fd 1fe 1ff 000 1c9 1ca 1cb 

00 

00 01 

3 4 

3 4 

0 6 0 

1 0 1 0 

19.15us 19.2us 19.25us 19.3us 19.35us 19.4us 19.45us 19.5us 19.55us 19.6us 19.65us 19.7us 19.75us 19.8us 



Lukas Bauer 

Diplomarbeit 


Anhang C.3 

Seite 108


Newline Reload (Zeile 009, TAP 1FD) und Midline Reload (Zeile 00A, TAP 000) 

0s 

0s 


/rowcnt_ot 

/rowcnt_othex 

/tapcnt_ot 

/tapcnt_othex 

/mscnt_ot 

/mscnt_othex 





a1 


a1 


a0 


a1 


a1 

/hblank_out 

/hblank_outa0 

a0 

/sr_row_ot 

/sr_row_othex 

/sr_cnt_ot 

/sr_cnt_othex 


a1 

/calc_nrh_ot 


/calc_nrl_ot 


/smr_req_ot 

/smr_req_ota0 

a0 

/refrqnr_ot 


/refpfnr_ot 


/a_sam_ot 

/a_sam_othex 

/a_ctrl_ot 

/a_ctrl_othex 


a0 


a0 

VHDL 2000 

1 

008 009 00a 

606 7fd 7fe 7ff 600 601 

000 

1ff 009 1fd 1ff 00a 000 1ff 

008 009 00a 

006 007 1fd 1fe 1ff 000 001 

00 

00 01 00 

3 4 

3 

0 6 0 6 0 

0 3 1 0 1 0 1 0 

8.6us 8.7us 8.8us 8.9us 9us 9.1us 9.2us 9.3us 9.4us 9.5us 9.6us 



Lukas Bauer 

Diplomarbeit 


Anhang C.3 

Seite 109

Newline Reload (Zeile 005, TAP 1FE) und Midline Reload vor Beginn des Anzeigebereichs (Zeile 006, TAP 000) 


0s 

0s 


/rowcnt_ot 

/rowcnt_othex 

/tapcnt_ot 

/tapcnt_othex 

/mscnt_ot 

/mscnt_othex 





a1 


a1 


a0 


a1 


a1 

/hblank_out 

/hblank_outa0 

a0 

/sr_row_ot 

/sr_row_othex 

/sr_cnt_ot 

/sr_cnt_othex 


a1 

/calc_nrh_ot 


/calc_nrl_ot 


/smr_req_ot 

/smr_req_ota0 

a0 

/refrqnr_ot 


/refpfnr_ot 


/a_sam_ot 

/a_sam_othex 

/a_ctrl_ot 

/a_ctrl_othex 


a0 


a0 

VHDL 2000 

004 005 006 

61d 61e 7fe 7ff 600 601 602 

fff 000 fff 

1ff 005 1fe 1ff 006 000 1ff 

004 005 006 

01d 01e 01f 020 1fe 1ff 000 001 002 

00 

00 01 00 

0 

0 

0 

0 6 0 6 0 

1 0 1 0 1 

2.8us 2.9us 3us 3.1us 3.2us 3.3us 3.4us 3.5us 3.6us 



Lukas Bauer 

Diplomarbeit 


Anhang C.3 

Seite 110

Newline Reload (Zeile 00F, TAP 1F8), vorgezogener Split Midline Reload (Zeile 010, TAP 000), Refresh und Split 

Midline Relaod (Zeile 010, TAP 000) 


0s 

0s 


/rowcnt_ot 

/rowcnt_othex 

/tapcnt_ot 

/tapcnt_othex 

/mscnt_ot 

/mscnt_othex 





a1 


a1 


a0 


a1 


a1 

/hblank_out 

/hblank_outa0 

a0 

/sr_row_ot 

/sr_row_othex 

/sr_cnt_ot 

/sr_cnt_othex 


a1 

/calc_nrh_ot 


/calc_nrl_ot 


/smr_req_ot 

/smr_req_ota0 

a0 

/refrqnr_ot 


/refpfnr_ot 


/a_sam_ot 

/a_sam_othex 

/a_ctrl_ot 

/a_ctrl_othex 


a0 


a0 

VHDL 2000 

000 00f 010 

000 7f8 

fff 

4 

1ff 00f 1f8 1ff 010 000 1ff 010 000 1ff 

013 00f 010 

000 1f8 

00 01 00 

00 02 01 

5 6 

5 6 

0 7 0 2 0 3 0 

1 0 1 0 1 0 3 1 0 1 

43.8us 43.9us 44us 44.1us 44.2us 44.3us 44.4us 44.5us 44.6us 44.7us 44.8us 44.9us 



Lukas Bauer 

Diplomarbeit 


Anhang C.3 

Seite 111

Newline Reload (Zeile 005, TAP 1FF), Refresh, Midline Reload (Zeile 006, TAP 000) und Refresh 


0s 

0s 


/rowcnt_ot 

/rowcnt_othex 

/tapcnt_ot 

/tapcnt_othex 

/mscnt_ot 

/mscnt_othex 





a1 


a1 


a0 


a1 


a1 

/hblank_out 

/hblank_outa0 

a0 

/sr_row_ot 

/sr_row_othex 

/sr_cnt_ot 

/sr_cnt_othex 


a1 

/calc_nrh_ot 


/calc_nrl_ot 


/smr_req_ot 

/smr_req_ota0 

a0 

/refrqnr_ot 


/refpfnr_ot 


/a_sam_ot 

/a_sam_othex 

/a_ctrl_ot 

/a_ctrl_othex 


a0 


a0 

VHDL 2000 

2 

004 005 006 

603 7ff 600 601 

000 

1ff 005 1ff 006 000 1ff 

004 005 006 

003 1ff 000 001 

00 

00 01 00 

1 2 

0 1 

0 6 0 6 0 

1 0 1 0 3 1 0 1 0 

13.5us 13.6us 13.7us 13.8us 13.9us 14us 14.1us 14.2us 14.3us 14.4us 14.5us 14.6us 



Lukas Bauer 

Diplomarbeit 


Anhang C.3 

Seite 112

Abbildung 80: Hierarchie der Controller- und Prozessor-Einheit (Design ” TIM“) mit Seitenangaben 

TIM 

HOST 

HOST 

HOST_ACC HOST_CTRL 

CONTROL 

CONTROL 

TIM_ACCESS 

REG_WRITE 

REG_WRITE 

REG_READ 

REG_READ 

MEM_ACCESS 

MEM_ACCESS 

MEM_CYCLES ADDR_CALC BIT_SHIFT BIT_MASK MEM_ADDRES.. GPU_FIFO_R GPU_FIFO_W PIXBLT_PAT.. 

INTERRUPT 

GR_CPU 

GR_CPU 

GP_CMD 

CLIP 

CLIP 

PIXBLT 

PIXBLT 

DADR_SPLIT DY_SPLIT SADR_SPLIT SY_SPLIT PIX_TO_BIT AREA_TO_PI.. 

REG_ALIAS ASYNC_ACT 



Lukas Bauer 

Diplomarbeit 


Anhang D.1 

Seite 113



Lukas Bauer 

Current setting: 

Synchronous mode: Synthesis Silcsyn 

External clock: MClk_in 

Rising edge 

Period: 1 ns 

External reset: RESET_in 

Active level high 

Asynchronous reset 

Resolution scale: ps 

Time scale: ns 

Language: VHDL-like 

Design Variable: 

-- constants 

constant lo32(32): logic :="00000000000000000000000000000000"; 

constant hi32(32): logic :="11111111111111111111111111111111"; 











type int27 is integer(0 to 0x07FFFFFF); 

type int16 is integer(0 to 0xFFFF); 

type int8 is integer(0 to 0x00FF); 

type int5 is integer(0 to 0x001F); 

type int4 is integer(0 to 0x000F); 

type int3 is integer(0 to 0x0007); 

type int2 is integer(0 to 0x0003); 

-- pins: name_in 

-- name_out 

-- name_oe ’1’ for output 

-- ’0’ for input 

-- pins for host interface 

-- AD_in(32): in logic; 

AD_out(32): out logic; 

AD_oe(32): out logic :=lo32; 

-- D_in(32): in logic; 

D_out(32): out logic; 

D_oe(32): out logic :=lo32; 

-- AS_in: in logic; 

-- DS_in: in logic; 

DS_out: out logic; 

DS_oe: out logic :=’0’; 

-- BS_in(4): in logic; 

CS_in: in logic; 

-- RS_in: in logic; 

-- HWE_in: in logic; 

INT_out: out logic :=’0’; 

INT_oe: out logic :=’0’; 

Rdy_in: in logic; 

-- Rdy_out: out logic; 

Rdy_oe: out logic :=’0’; 

MUX_in: in logic; 

-- pins for memory interface 

RCA_out(14): out logic; 

RAS_out(4): out logic; 

CAS_out(4): out logic; 

ACS_out(4): out logic; 

MWE_out: out logic; 

MOE_out: out logic; 

MSF_out: out logic; 

MSC_out: out logic; 

MD_in(32): in logic; 

MD_out(32): out logic; 

MD_oe(32): out logic; 

-- pins for asynchronous delay control 

MSC_del0: out logic; 




MTR_del0: out logic; 




LD_del0: out logic; 




-- pins / other functions 

RESET_in: in logic; 

MClk_in: in logic; 

DWE_out: out logic :=’1’; 

-- pins for tests only 

R_CONF_out(32): out logic; 

R_4_out(32): out logic; 

-- PATTN(4): in logic; -- test pattern section 

-- (no function) 

MBW_ot(2): out logic; 

HBW_ot(2): out logic; 

PATTN_ot(4): out logic; 

ADin_ot(32): out logic; 

ASin_ot: out logic; 

DSin_ot: out logic; 

BSin_ot(4): out logic; 

RSin_ot: out logic; 

HWEin_ot: out logic; 

Rdyout_ot: out logic; 

FIFOIN_ot(3): out logic; 

FIFOOUT_ot(3): out logic; 

CAS_MASK_ot(4): out logic; 

ANY_CYCLE_ot: out logic; 

MEM_GWRITE_ot: out logic; 

GPU_WNUM_ot(4): out logic; 

MEM_GREAD_ot: out logic; 

GPU_RNUM_ot(4): out logic; 

PRE_READ_ot: out logic; 

PRE_MASK_ot(32):out logic; 

Diplomarbeit 


Abbildung 81: Typen, Konstanten und externe Signale im Design ” TIM“ 

Anhang D.2 

Seite 114



Lukas Bauer 

¨¢¨¢©¤¡© ¢¨¢¨ ¥ 

 

£¤§¦©¨¦©©¤¨¦¤¢£ 

¦¥¢¨¢£¥¤¢¦¥¢¡¢£¡© ¥© £ 

 

© ¢¡ ¢ 

¢ ¢¡ ¢ 

 

£©¢¡ ¢¦ ¡ ¢ ¡ 

 

¢ ¢¡ ¢ 

£©¢¡ 

¢¤§¦©¤ 

¢§¥ © ¢¡ ©¢¡¥ 

© ¢¡ ©¢¡¥ 

 

¥¥§ ¢¡ ©¢¡¥ 

¢ ¡ ¢¢¡ ©¢¡©¢¥ 

 

© ¢¡ ©¢¡¥ 

©¥© © ¢¡ ©¢¡¥ 

 

¥ ¥ © ¢¡ ©¢¡¥ 

©¥ ¢¡ ©¢¡¥ 

 

¥ ¢¡ ©¢¡¥ 

¢ ¢¡ ©¢¡©¢¥ 

 

£¢¢ ¢¡ ©¢¡©¢¥ 

¢§ ¢¢¡ ©¢¡©¢¥ 

 

¥¢§ ¢¢¡ ©¢¡©¢¥ 

©¢ ¢ ¢¡ ©¢¡©¢¥ 

 

¢¢¡ ©¢¡©¢¥ 

¥ ¢¡ ©¢¡¥ 

 

¢¡ ©¢¡¥ 

© ¢ ¢¡ ©¢¡©¢¥ 

 

© ¢ ¢¡ ©¢¡©¢¥ 

¢¡ ©¢¡¥ 

 

¢¡ ©¢¡¥ 

¥©¢§ © ¢¡ ©¢¡¥ 

 

©¢§ ©¢¡ ©¢¡¥ 

¢ ¢¡ ©¢¡¥ 

 

© ¡ © ¢¡ ©¢¡¥ 

¢ ¡ © ¢¡ ©¢¡¥ 

 

¢ ©¢¡ ©¢¡¥ 

¢ ©¢¡ ©¢¡¥ 

 

¢¢ ¢¢¡ ©¢¡©¢¥ 

¢¢ ¢¢¡ ©¢¡©¢¥ 

 

¢¢ ¢¢¡ ©¢¡©¢¥ 

¢¢ ¢¢¡ ©¢¡©¢¥ 

 

¢§ ¢¡ ©¢¡¥ 

¢ ¢¡ ©¢¡¥ 

 

¢§ ¢ ¢¡ ©¢¡¥ 

¢ ¢¡ ©¢¡¥ 

 

©¢¥ ¢¡ ©¢¡¥ 

©§¥ ¢¡ ©¢¡¥ 

 

¢ ¢¡ ©¢¡©¢¥ 

¢¢¢¥ ¢¡ ©¢¡¥ 

 

¢¥¥ ¢¡ ©¢¡¥ 

¢© ¢¡ ©¢¡¥ 

 

©© ¢¡ ©¢¡¥ 

¢§ ¢¡ ©¢¡¥ 

 

¢¥ ¢¡ ©¢¡¥ 

¢¢¢¥ ¢¡ ©¢¡¥ 

 

©¥¥ ¢¡ ©¢¡¥ 

©© ¢¡ ©¢¡¥ 

 

© ¢¡ ©¢¡¥ 

¢§ ¢¡ ©¢¡¥ 

 

¥ ¢¡ ©¢¡¥ 

¢ ¢¡ ©¢¡©¢¥ 

 

¢ ¢¡ ©¢¡©¢¥ 

© ¢¡ ©¢¡¥ 

 

© ¢¡ ©¢¡¥ 

© ¢¡ ©¢¡¥ 

 

¢© ¢¡ ©¢¡¥ 

¢© ¢¡ ©¢¡¥ 

 

¤¢© ¢¡ ©¢¡¥ 

© ¢¡ ©¢¡¥ 

 

¢© ¢¡ ©¢¡¥ 

 

¢¤§¦©¦¤¨¢¨©¤©¤ 

 

©¢ ¢¡ ¥ 

¢¡ ¥ 

 

¢¡ ¥ 

¢¡ ¥ 

 

¢¡ ¥ 

¢¡ ¥ 

 

© ¢¡ ¥ 

¢¡ ¥ 

 

¥¢ ¢¡ ¥ 

¢ ¢¡ ¥ 

 

¢¡ ¥ 

©¦¥ 

¢¡ ¥ 

§©¦¥ 

¢¡ ¥ 

¢ ¢¡ ¥ 

©¦¥ 

¥ ¢¡ ¥ 

¢¡ ¥ 

 

¢¡ ¥ 

¥ ¢¡ ¥ 

©¢ 

¢ ¢¡ ¥ 

¢¡ ¥ 

 

§©¦¥ ¢¡ ¥ 

¢¢ ¢¡ ¥ 

 

¥ ¢¡ ¥ 

¥ ¥ ¢¡ ¥ 

¥ 

¥ ¢¡ ¥ 

¥ ¥ ¢¡ ¥ 

¥ 

¢ ¢¡ ¥ 

¥ ¢¡ ¥ 

 

¥ ¢¡ ¥ 

¢ ¥ ¢¡ ¥ 

© 

¢¡ ¥ 

¢ 

¢ ¥ ¢¡ ¥ 

¢¡ ¥ 

 

¢¡ ¥ 

© 

¥ ¥ ¢¡ ¥ 

¥ ¥ ¢¡ ¥ 

 

¢¡ ¥ 

¢¡ ¥ 

 

§¢¥ ¢¡ ¥ 

 

© ¢¡ ¥ 

© ¢¡ ¥ 

 

© ¢¡ ¥ 

 

Diplomarbeit 


Abbildung 82 (zweispaltig): Variablen im Diagramm TIM 

© ¢¡ ¥ 

© © ¢¡ ©¢¡© 

 

¥© © ¢¡ ©¢¡© 

© £¢¦©¥ 

 

£¢¦ 

© 

© 

£¢¦ 

© £¢¦©¥ 

£¢¦ 

© 

© £¢¦ 

©¥ £¢¦ 

 

£¢¦ 

¢§ 

¥ 

£¢¦ 

£¢¦ 

¢§ 

¢ 

¢ £¢¦ 

¢ £¢¦ 

£¢¦ 

 

£¢¦ 

 

¢ ¥ ¢¡ ©¢¡© 

¢ £¢¦¥ 

 

¥¢ ¥ ¢¡ ©¢¡© 

 

¥¢ £¢¦¥ 

¥¡¦ 

§ ¦¢¥ ¢¡ ¢¥©¢© 

§ ¦¥ ¢¡ ¢¥© 

 

¦¥ ¢¡ ¢¥© 

¦¥ ¢¡ ¢¥© 

 

¦ ¢¡ ¢ 

¥¢ ¦ ¢¡ ¢ 

 

¦¢ ¢¡ ¢¥¢¥ 

¢ ¦¢ ¢¡ ©¢¡©¢¥ 

 

¡£¢¦©£¨ ©¢ ¤¢§¥¢¨¦¥¢¡¢£ 

 

£ ¢ ¢¡ ©¢¡©¢¥ 

¥ £ ¥ ¢¡ ¢¥© 

© 

£ ¢¡ ¢ 

£ ¢¡ ¢ 

¥ 

£ ¢¡ ¢ 

£ ¢¡ ¢ 

 

¡¦ ¢¡ ¢ 

 

¢ ¢¡ ©¢¡©¢¥ 

©¢ ¢ ¢¡ ©¢¡©¢¥ 

©¢ 

¥ ¥ ¢¡ ©¢¡©© 

©¢ 

©¢ 

¢¡ ¢ 

©¢ ¥§ £¢¦ 

¢ £¢¦ 

©¢ 

¥ ¢¡ ©¢¡©© 

 

¦¡©¤¦¤¢¢¡ ¨¢¢£¥¢£¢¦ 

 

£¢¦¨¢ ¤¡¥ ¢¢©§¦ 

© 

© 

£¢¦¨¢ ¤¡¥ ¢¢¦ 

© £¢¦¨¢ ©¤§¦¢©§¦ 

 

£¢¦¨¢ ©¤§¦¢¦ 

© 

¢¡¢£¢¦¥¢¡© §£¢¦©¢¨ ¦¥¢¡¢£ 

 

© ¢¡ ¢ 

¡ 

¢¡ ¢ 

¡ 

£¢¦ 

¡ 

£¢¦ 

¡ 

© £¢¦© ¥¢¢£¢¦£ © 

 

© £¢¦© ¥¢¢£¢¦£ © 

© 

 

£¢¦© ¥¢¢£¢¦£ © 

© £¢¦© ¥¢¢£¢¦£ © 

 

£¢¦©¥ £¨ ¨¢©¤¤ © 

© 

£¢¦©¥ £¨ ¨¢©¤¤ © 

© 

© 

£¢¦©¥ £¨ ¨¢©¤¤ © 

© £¢¦©¥ £¨ ¨¢©¤¤ © 

 

£¢¦© ¥£ ¥ ¤¡¥ ¥¡©¤ 

© 

£¢¦© ¥£ ¥ ©¤§¦ ¥¡©¤ 

© 

¥ ¢© £¢¦ ¡ ¢¡¡¦¢¦¥¡©¤¢¦¥¢¡¢£ 

¡ 

¥ £¢¦ ¡ ¢¡£¦¥¡©¤¢¦¥¢¡¢£ 

¡ 

¡ ¥ ¢¢¡ ©¢¡©¢¥ 

¡ ¥ ¢¢¡ ©¢¡©¢¥ 

 

¡ ¥ ¢¢¡ ©¢¡©¢¥ 

¡ ¥ ¢¢¡ ©¢¡©¢¥ 

 

¡ ¥ ¢¢¡ ©¢¡©¢¥ ¡ ¥¦©¨¦©¨¢¡ 

¡ ¥ ¢¢¢¡ ©¢¡©¢¥ 

¡ ¥ ¢¢¡ ©¢¡©¢¥ 

 

¡ ¥ ¢¢¡ ©¢¡©¢¥ 

¡ ¥ ¢¢¡ ©¢¡©¢¥ 

 

£¢¦©¢¦¢©©¤§¦£©¤ 

 

¢¡ ¢ ¢¨¦© ¢¢¡ ¤ ¦¥¢¡¢£ 

¥ 

¥ 

¢¡ ¢ ¢¨¦© ¢¢¡ ¤ ¦¥¢¡¢£ 

 

¥ ¢¡ ¢ ¢¨¦© ¢¢¡ ¤ ¦¥¢¡¢£ 

¥¥ ¢¡ ¢ 

 

¢¡ ¢ 

¥ 

¥ ¢¡ ¢ ¢¨¦© ¢¢¡ ¤ ¦¥¢¡¢£ 

 

Anhang D.2 

Seite 115



Lukas Bauer 

HOST 

T1 

entry host 

Abbildung 83: Speedchart-Diagramm TIM/HOST 

MEM_ACCESS 

T1 

entry mem_access 

Abbildung 85: TIM/CONTROL/MEM ACCESS 

Diplomarbeit 


CONTROL 

entry 

T1 

A: RS_MUX :=MUX_in; 

RS_Rdy :=Rdy_in; 

R_CONFIG(1) :=AS_in; 

R_CONFIG(0) :=DS_in; 

Anhang D.2 

Seite 116 

control 

Abbildung 84: Speedchart-Diagramm TIM/CONTROL 

GR_CPU 

T1 

entry gr_cpu 

Abbildung 86: Speedchart-Diagramm TIM/GR CPU



Lukas Bauer 

HOST_ACC 

entry 

T2 

T3 

T4 

T8 

stdby 

Diplomarbeit 


T1 

C: HOST_ACTION=1 

A: RS_in:=HOST_RS; 

AD_in:=HOST_A; 

HWE_in:=’0’; 

BS_in:=HOST_BS; 

T9 

write 

S2 

S3 

S4 

A: AS_in:=’0’; 

A: AD_in:=HOST_D 

after 1ns; 

-- spdch only 

A: DS_in:=’0’; 

T6 

T10 

T12 

T11 

read 

S6 

S7 

wait_rdy 

Abbildung 87: Speedchart-Diagramm TIM/HOST/HOST ACC 


A: RS_in:=HOST_RS; 

AD_in:=HOST_A; 

HWE_in:=’1’; 

BS_in:=HOST_BS; 

A: AS_in:=’0’; 

A: DS_in:=’0’; 

T7 

C: RDY_OUT=’0’ 

A: AS_in:=’1’; 

DS_in:=’1’; 

HWE_in:=’1’; 

AD_in:=hi32; 

HOST_ACTION:=0; 

Anhang D.2 

Seite 117 

T5 

C: RDY_out=’1’ 

done

Abbildung 88: Speedchart-Diagramm TIM/HOST/HOST CTRL 

HOST_CTRL 

entry 

T1 T20 #0 

T3 #0 

S10 

S1 

A: HOST_STEP:=0; 


PATTN:=15; 


A: -- 

-- set registers 

-- (HBW32) 

T19 

case HOST_STEP is 

when 0 => -- write $____0303 

-- to reg. 1 

-- MBW32, HBW32 

HOST_A:=0x00000004; 

HOST_D:=0x00000303; 

HOST_BS:="1100"; 

HOST_RS:=’0’; 


when 1 => -- write $3E3F7E__ 

-- to reg. 2 

-- MOD:="111" 13:11 

-- MOC:="110" 10:8 

-- RTO:="00" 7:6 

-- MOB:="111" 5:3 

-- MOA:="111" 2:0 

-- ASL:="111" 6:4 ACS=31:30 

-- PEN:=’1’ 3 

-- RSL:="110" 2:0 RAS=29:28 

HOST_A:=0x00000008; 

HOST_D:=0x3E3F7E00; 

HOST_BS:="0001"; 


when 2 => -- SSTART:=1MB 

HOST_A:=0x00000018; -- R6 

HOST_D:=0x00100000; 

HOST_BS:="0000"; 


when 3 => -- DSTART:=2MB 

HOST_A:=0x0000001C; -- R7 

HOST_D:=0x00200000; 

HOST_BS:="0000"; 


when 4 => -- SINC:=260 Pix 

-- DINC:=520 Pix 

HOST_A:=0x0000000C; -- R3 

HOST_D:=0x01040208; 


when 5 => -- SADR: Y=24, X=18 

HOST_A:=0x0000002C; -- R11 

HOST_D:=0x00180012; 


when 6 => -- DADR: Y=36, X=6 

HOST_A:=0x00000030; -- R12 

HOST_D:=0x00240006; 


when 7 => -- DX=104, DY=3 

HOST_A:=0x00000034; -- R13 

HOST_D:=0x00680003; 


when 8 => -- COMMAND PixBLT 

HOST_A:=0x0000003C; -- R15 

HOST_D:=0x00000032; 

HOST_BS:="1110"; 


end case; 

HOST_STEP:=HOST_STEP+1; 

C: HOST_STEP=200 


PATTN:=0; 


A: -- 

-- set registers 

-- (HBW32) 

T2 


when 0 => -- SADR: Y=24, X=18 

HOST_A:=0x0000002C; -- R11 

HOST_D:=0x00180012; 

HOST_BS:="0000"; 


when 1 => -- DADR: Y=36, X=6 

HOST_A:=0x00000030; -- R12 

HOST_D:=0x00240006; 


when 2 => -- DX=13, DY=2 

HOST_A:=0x00000034; -- R13 

HOST_D:=0x000D0002; 


when 3 => -- PSIZE 32bit/pix 

HOST_A:=0x00000038; -- R14 

HOST_D:=0x20000000; 


when 5 => -- COMMAND PixBLT 

-- start bot right 

-- des:=des + sou 

HOST_A:=0x0000003C; -- R15 

HOST_D:=0x0000E332; 

HOST_BS:="1100"; 


end case; 




PATTN:=1; 


A: -- 

-- memory write & read 

-- (no page mode) 

-- (MBW8, HBW32) 

S2 

T4 


when 0 => -- write $____0003 

-- to reg. 1 

-- MBW8, HBW32 

HOST_A:=0x00000004; 

HOST_D:=0x00000003; 

HOST_BS:="1100"; 



when 1 => -- write $____76__ 

-- to reg. 2 

-- PEN=’0’ 

HOST_A:=0x00000008; 

HOST_D:=0x00007600; 

HOST_BS:="1101"; 


when 2 => -- write $23456789 

-- to mem 00918454 

HOST_A:=0x00918454; 

HOST_D:=0x23456789; 

HOST_BS:="0000"; 



when 3 => -- write $1BCD____ 

-- to mem 00918458 

HOST_A:=0x00918458; 

HOST_D:=0x1BCDEF01; 

HOST_BS:="0011"; 


when 4 => -- write $__45____ 

-- to mem 77775680 

HOST_A:=0x77775680; 

HOST_D:=0x23456789; 

HOST_BS:="1011"; 


when 5 => -- read mem 77775680 

HOST_A:=0x77775680; 

HOST_BS:="0101"; 


end case; 


T5 #0 



PATTN:=2; 


A: -- 


-- (page mode) 

-- (MBW8, HBW32) 

S3 

T6 


when 0 => -- write $____7E__ 

-- to reg. 2 

-- PEN=’1’ 

HOST_A:=0x00000008; 

HOST_D:=0x00007E00; 

HOST_BS:="1101"; 



when 1 => -- write $23456789 

-- to mem 00918454 

HOST_A:=0x00918454; 

HOST_D:=0x23456789; 

HOST_BS:="0000"; 




-- to mem 00918458 

HOST_A:=0x00918458; 


HOST_BS:="0011"; 


when 3 => -- write $__45____ 

-- to mem 77775680 

HOST_A:=0x77775680; 

HOST_D:=0x23456789; 

HOST_BS:="1011"; 


when 7 => -- read mem 77775680 

HOST_A:=0x77775680; 

HOST_BS:="0101"; 


end case; 


T7 #0 



PATTN:=3; 


A: -- 



-- (MBW16, HBW32) 

S4 

T8 


when 0 => -- write $____0103 

-- to reg. 1 

-- MBW16, HBW32 

HOST_A:=0x00000004; 

HOST_D:=0x00000103; 

HOST_BS:="1100"; 



when 1 => -- write $____7E__ 

-- to reg. 2 

-- PEN=’1’ 

HOST_A:=0x00000008; 

HOST_D:=0x00007E00; 

HOST_BS:="1101"; 


when 2 => -- write $2345__89 

-- to mem 009188AC 

HOST_A:=0x009188AC; 

HOST_D:=0x23456789; 

HOST_BS:="0010"; 



when 3 => -- write $2345__89 

-- to mem 009188B0 

HOST_A:=0x009188B0; 

HOST_D:=0x23456789; 

HOST_BS:="0010"; 


when 4 => -- write $2345__89 

-- to mem 77775680 

HOST_A:=0x77775680; 

HOST_D:=0x23456789; 

HOST_BS:="0010"; 


when 5 => -- write $2345__89 

-- to mem 77700680 

HOST_A:=0x77700680; 

HOST_D:=0x23456789; 

HOST_BS:="0010"; 


when 6 => -- read mem 77775680 

HOST_A:=0x77775680; 


end case; 


T9 #0 



PATTN:=4; 


A: -- 



-- (MBW32, HBW32) 

S5 

T10 


when 0 => -- write $____0303 

-- to reg. 1 

-- MBW32, HBW32 

HOST_A:=0x00000004; 

HOST_D:=0x00000303; 

HOST_BS:="1100"; 



when 1 => -- write $____76__ 

-- to reg. 2 

-- PEN=’0’ 

HOST_A:=0x00000008; 

HOST_D:=0x00007600; 

HOST_BS:="1101"; 


when 2 => -- write $23456789 

-- to mem 00918454 

HOST_A:=0x00918454; 

HOST_D:=0x23456789; 

HOST_BS:="0000"; 




-- to mem 00918458 

HOST_A:=0x00918458; 


HOST_BS:="0011"; 


when 4 => -- write $__45____ 

-- to mem 77775680 

HOST_A:=0x77775680; 

HOST_D:=0x23456789; 

HOST_BS:="1011"; 


when 5 => -- read mem 77775680 

HOST_A:=0x77775680; 

HOST_BS:="0101"; 


end case; 


T11 #0 



PATTN:=5; 


A: -- 



-- (MBW32, HBW32) 

S6 

T12 


when 0 => -- write $____7E__ 

-- to reg. 2 

-- PEN=’1’ 

HOST_A:=0x00000008; 

HOST_D:=0x00007E00; 

HOST_BS:="1101"; 



when 1 => -- write $23456789 

-- to mem 00918454 

HOST_A:=0x00918454; 

HOST_D:=0x23456789; 

HOST_BS:="0000"; 




-- to mem 00918458 

HOST_A:=0x00918458; 


HOST_BS:="0011"; 


when 3 => -- write $__45____ 

-- to mem 77775680 

HOST_A:=0x77775680; 

HOST_D:=0x23456789; 

HOST_BS:="1011"; 


when 7 => -- read mem 77775680 

HOST_A:=0x77775680; 

HOST_BS:="0101"; 


end case; 


T13 #0 



PATTN:=6; 


A: -- 



-- (MBW32, HBW16) 

S7 

T14 


when 0 => -- 16B-write $0301 

-- to reg. 1 (lo) 

-- MBW32, HBW16 

HOST_A:=0x00000004; 

HOST_D:=0x00000301; 

HOST_BS:="1100"; 



when 1 => -- 16B-write $7E__ 

-- to reg. 2 (lo) 

-- PEN=’1’ 

HOST_A:=0x00000008; 

HOST_D:=0x00007E00; 

HOST_BS:="1101"; 


when 2 => -- 16B-write $__89 

-- to 12345678 

HOST_A:=0x00919158; 

HOST_D:=0x23456789; 

HOST_BS:="1110"; 



when 3 => -- 16B-write $2345 

-- to mem 12345682 

HOST_A:=0x12345682; 

HOST_D:=0x00002345; 

HOST_BS:="1100"; 


when 4 => -- 16B-write $45__ 

-- to mem 77775680 

HOST_A:=0x77775680; 

HOST_D:=0x00004500; 

HOST_BS:="1101"; 


when 5 => -- read mem 77775680 

HOST_A:=0x77775680; 


end case; 


T15 #0 



PATTN:=7; 

S8 

T16 


A: -- 



-- (MBW32, HBW16) 


when 0 => -- 16B-write $0301 

-- to reg. 1 (lo) 

-- MBW32, HBW16 

HOST_A:=0x00000004; 

HOST_D:=0x00000301; 

HOST_BS:="1100"; 



when 1 => -- 16B-write $76__ 

-- to reg. 2 (lo) 

-- PEN=’0’ 

HOST_A:=0x00000008; 

HOST_D:=0x00007600; 

HOST_BS:="1101"; 


when 2 => -- 16B-write $__89 

-- to 12345678 

HOST_A:=0x00919158; 

HOST_D:=0x23456789; 

HOST_BS:="1110"; 



when 3 => -- 16B-write $2345 

-- to mem 12345682 

HOST_A:=0x12345682; 

HOST_D:=0x00002345; 

HOST_BS:="1100"; 


when 4 => -- 16B-write $45__ 

-- to mem 77775680 

HOST_A:=0x77775680; 

HOST_D:=0x00004500; 

HOST_BS:="1101"; 


when 5 => -- read mem 77775680 

HOST_A:=0x77775680; 


end case; 


T17 #0 



PATTN:=8; 

S9 

T18 


A: -- 

-- register write & read 

-- and test of LOCK bit 

-- (HBW32) 


when 0 => -- 16B-write $0303 

-- to reg. 1 (lo) 

-- MBW32, HBW32 

HOST_A:=0x00000004; 

HOST_D:=0x00000303; 

HOST_BS:="1100"; 



when 1 => -- write $000000FF 

-- to reg. 1 

HOST_D:=0x000000FF; 

HOST_BS:="0000"; 


when 2 => -- (LOCK) 



when 3 => -- (test LOCK) 

HOST_D:=0x12308045; 


when 4 => -- (1st step unlk) 

HOST_D:=0x12307FFF; 



HOST_D:=0x12300045; 



HOST_D:=0x12300045; 


when 7 => -- (1st step unlk) 

HOST_D:=0x12307FFF; 


when 8 => -- (2nd step unlk) 









end case; 




Lukas Bauer 

Diplomarbeit 


Anhang D.2 

Seite 118



Lukas Bauer 


-- Variables of Diagram CONTROL 

-- address, data & control for RAM access 

AD_lat(32): logic; 

D_lat(32): logic; 

ADS_lat(7): logic; 

RS_lat: logic; 

BS_lat(4): logic; 

CAS_lat(4): logic; 

STAT_CLR: logic:=’0’; 

-- host input / output data 

Diplomarbeit 


DATA_IN(32): logic; -- host write data 

DATA_OUT(32): logic:=lo32; -- read data from TIM 

-- ram write data FIFO buffer, 4*32 bits 

-- XXX_FIFO0 = position 0 

D_FIFO0(32): logic; -- write data 

D_FIFO1(32): logic; 



RAM_D_W(32): logic; -- write data of output position 

A_FIFO0(32): logic; -- address 

A_FIFO1(32): logic; 



RAM_ADDR(32): logic; -- address of output position 

CAS_FIFO0(4): logic; -- CAS mask (BS byte select) 

CAS_FIFO1(4): logic; 



CAS_MASK(4): logic; -- CAS mask of output position 

-- FIFO control 

signal FIFO_IN: int3:=0; -- FIFO input position (low 2 bits) 

--^^^^ SIGNAL makes the design behave FSM-like 

FIFO_OUT: int3:=0; -- FIFO output position (low 2 bits) 

CAS_DONE(4): logic:="0000"; -- ’1’=byte already written 

LAST_ROW(14): logic; -- page mode last RAM row 

LAST_RAS(4): logic; -- page mode last RAS select signals 

LAST_ACS(4): logic; -- page mode last ACS select signals 

-- RAM read control 

A_READ(32): logic; -- read address 

CAS_READ(4): logic; -- read byte mask 

READ_DONE: logic; 

MEM_READ: logic:=’0’; -- ’1’=perform RAM read 

-- RAS address calculation 

RS_A(2): logic; -- value of "RAS bank select" address bits 

RAS_MASK(4): logic; -- decoded RS_A bits 

MOX(3): logic; -- RAS address selector of selected bank 

RAM_ROW(14): logic; -- accessed RAM row 

RAM_COL(14): logic; -- accessed (1st) RAM column 

-- ACS bank calculation 

AS_A(2): logic; -- value of "ACS bank select" address bits 

ACS_MASK(4): logic; -- decoded AS_A bits 

-- source read data FIFO buffer and barrel shifter 

S_HI_LW(32): logic; -- high longword of shifted source data 

S_LO_LW(32): logic; -- low longword of shifted source data 

DBMASK_L(32): logic; -- data bit mask at line start 

DBMASK_R(32): logic; -- data bit mask at line end 

Abbildung 89: Variablen im Diagramm TIM/CONTROL 

Anhang D.2 

Seite 119

Abbildung 90: Speedchart-Diagramm TIM/CONTROL/TIM ACCESS 

TIM_ACCESS 

C: FIFO_IN=FIFO_OUT 

A: MEM_READ:=’1’; 

-- start read when 

-- FIFO is empty 

T12 #1 

C: RS_lat=’1’ and 

(DS_in=’0’ or RS_MUX=’0’) 

A: AD_oe:=hi32; -- oe enable 

A_READ :=AD_lat; 

CAS_READ:=BS_lat; 

READ_DONE:=’0’; 

if FIFO_IN=FIFO_OUT then 

MEM_READ:=’1’; 

end if; 

-- wait if FIFO not empty 

C: AS_in=’0’ 

A: -- latch input lines 

A: RDY_out:=bnot RS_Rdy; 

-- ready active 

C: READ_DONE=’1’ 

mem_read 

T11 

T9 #0 

read 

T7 

RDY 

T8 

reg_read 

T14 

ADS_lat :=AD_in(8 downto 2); -- register address 

AD_lat :=AD_in; -- full address 

D_lat :=AD_in; -- write data if nonmux 

RS_lat :=RS_in; -- register select 

-- get or calculate BS3..BS0 byte select signals 


(DS_in=’0’ or 

RS_MUX=’0’) 

A: AD_oe:=hi32; 

-- output enable 

T1 

C: HWE_in=’1’ 

wt_end 

if HBW="00" then -- convert 8 -> 32 bit 

case AD_in(1 downto 0) is 

when "00" => BS_lat:="0111"; 

when "01" => BS_lat:="1011"; 

when "10" => BS_lat:="1101"; 

when "11" => BS_lat:="1110"; 

end case; 

elsif HBW="01" then -- convert 16 -> 32 bit 

case AD_in(0) is 

when ’0’ => BS_lat(3 downto 2):=BS_in(1 downto 0); 

BS_lat(1 downto 0):="11"; 

when ’1’ => BS_lat(3 downto 2):="11"; 

BS_lat(1 downto 0):=BS_in(1 downto 0); 

end case; 

else -- 32 bit 

BS_lat:=BS_in; 

end if; 

T5 

AS 

wait_AS 

A: if FASTRDY=’0’ then 

RDY_out:=bnot RS_Rdy; 


end if; 

T17 

T15 

w_done 

T4 

T6 

T13 

entry 

reg_write 

T3 

C: RS_lat=’0’ 

DS 

write 

C: HWE_in=’0’ 

T2 

T10 

C: AS_in=’1’ 

A: RDY_out:=RS_Rdy; 

-- ready inactive 

-- enable next access 


FIFO_IN/= 

(FIFO_OUT+4) mod 8 

A: -- write RAM data 

-- into FIFO buffer 

case (FIFO_IN mod 4) is 

when 0 => 

CAS_FIFO0:=BS_lat; 

A_FIFO0 :=AD_lat; 

D_FIFO0 :=DATA_IN; 

when 1 => 




when 2 => 




when 3 => 




end case; 

FIFO_IN:=(FIFO_IN+1) mod 8; 

C: DS_in=’0’ or RS_MUX=’0’ 

A: if FASTRDY=’1’ then 

RDY_out:=bnot RS_Rdy; 


end if; 


A: -- convert read/write data from HBW bus size to 32 bit 

if HBW="00" then -- 32 -> 8 bit 

if RS_MUX=’1’ then 

DATA_IN(31 downto 24):=AD_in(7 downto 0); -- upper byte 

DATA_IN(23 downto 16):=AD_in(7 downto 0); -- higher byte 

DATA_IN(15 downto 08):=AD_in(7 downto 0); -- middle byte 

DATA_IN(07 downto 00):=AD_in(7 downto 0); -- lower byte 

else 

DATA_IN(31 downto 24):=D_lat(7 downto 0); -- upper byte 

DATA_IN(23 downto 16):=D_lat(7 downto 0); -- higher byte 

DATA_IN(15 downto 08):=D_lat(7 downto 0); -- middle byte 

DATA_IN(07 downto 00):=D_lat(7 downto 0); -- lower byte 

end if; 

-- 8 -> 32 bit 

case AD_lat(1 downto 0) is 

when "00" => AD_out(7 downto 0):=DATA_OUT(31 downto 24); 

D_out(7 downto 0) :=DATA_OUT(31 downto 24); 







end case; 

elsif HBW="01" then -- 32 -> 16 bit 


DATA_IN(31 downto 16):=AD_in(15 downto 0); -- high 2 bytes 

DATA_IN(15 downto 00):=AD_in(15 downto 0); -- low 2 bytes 

else 

DATA_IN(31 downto 16):=D_lat(15 downto 0); -- high 2 bytes 

DATA_IN(15 downto 00):=D_lat(15 downto 0); -- low 2 bytes 

end if; 

-- 16 -> 32 bit 

case AD_lat(0) is 

when ’0’ => AD_out(15 downto 0):=DATA_OUT(31 downto 16); 


when ’1’ => AD_out(15 downto 0):=DATA_OUT(15 downto 00); 


end case; 

else 


if NUBUS=’1’ then 

DATA_IN(07 downto 00):=AD_in(31 downto 24); -- reverse 

DATA_IN(15 downto 08):=AD_in(23 downto 16); -- byte 

DATA_IN(23 downto 16):=AD_in(15 downto 08); -- order 

DATA_IN(31 downto 24):=AD_in(07 downto 00); -- for data 

else 

DATA_IN:=AD_in; -- 32 bit 

end if; 

else 

DATA_IN:=D_lat; -- 32 bit 

end if; 

if NUBUS=’1’ then 

AD_out(07 downto 00):=DATA_OUT(31 downto 24); -- reverse 

AD_out(15 downto 08):=DATA_OUT(23 downto 16); -- byte 

AD_out(23 downto 16):=DATA_OUT(15 downto 08); -- order 

AD_out(31 downto 24):=DATA_OUT(07 downto 00); -- for data 

else 

AD_out:=DATA_OUT; -- 32 bit 

end if; 

D_out:=DATA_OUT; -- 32 bit 

end if; 



Lukas Bauer 

Diplomarbeit 


Anhang D.2 

Seite 120



Lukas Bauer 

REG_READ 

entry 

Diplomarbeit 


T1 

A: case ADS_lat is 

when 0 => DATA_OUT(31 downto 24):=R_STATUS; 

if BS_lat(3)=’0’ then 

STAT_CLR:=’1’; -- clear R_STATUS 

end if; 

DATA_OUT(23 downto 16):=R_IMASK; 

DATA_OUT(15 downto 00):=R_LINTV; 

when 1 => DATA_OUT :=R_CONFIG; 

when 2 => DATA_OUT(31 downto 16):=R_MUXOFF; 

DATA_OUT(15 downto 08):=R_RADSEL; 

DATA_OUT(07 downto 00):=R_XYZOOM; 

when 3 => DATA_OUT(31 downto 16):=R_SINC; 

DATA_OUT(15 downto 00):=R_DINC; 

when 4 => DATA_OUT :=R_4; 


when 6 => DATA_OUT :=R_SSTART; 

when 7 => DATA_OUT :=R_DSTART; 

when 8 => DATA_OUT :=R_DPYSTRT; 

when 9 => DATA_OUT :=R_DPYNXT; 

when 10 => DATA_OUT(31 downto 16):=R_DPYINC; 

DATA_OUT(15 downto 00):=R_DPYMASK; 

when 11 => DATA_OUT :=R_SADR; 

when 12 => DATA_OUT :=R_DADR; 

when 13 => DATA_OUT(31 downto 16):=R_DX; 

DATA_OUT(15 downto 00):=R_DY; 

when 14 => DATA_OUT(31 downto 24):=R_PSIZE; 

DATA_OUT(23 downto 16):=R_PATTNSIZE; 

DATA_OUT(15 downto 00):=R_14; 

when 15 => DATA_OUT(31 downto 24):=R_AUXREG; 

DATA_OUT(23 downto 16):=R_HDREG; 

DATA_OUT(15 downto 08):=R_COMCTRL; 

DATA_OUT(07 downto 00):=R_COMMAND; 

when 16 => DATA_OUT :=R_COLOR0; 




when 20 => DATA_OUT(31 downto 16):=R_WSTARTX; 

DATA_OUT(15 downto 00):=R_WENDX; 

when 21 => DATA_OUT(31 downto 16):=R_WSTARTY; 

DATA_OUT(15 downto 00):=R_WENDY; 

when 22 => DATA_OUT(31 downto 16):=R_SETHCNT; 

DATA_OUT(15 downto 00):=R_SETVCNT; 


when 24 => DATA_OUT(31 downto 16):=R_HCOUNT; 

DATA_OUT(15 downto 00):=R_HESYNC; 

when 25 => DATA_OUT(31 downto 16):=R_HEBLNK; 

DATA_OUT(15 downto 00):=R_HSBLNK; 

when 26 => DATA_OUT(31 downto 16):=R_HTOTAL; 

DATA_OUT(15 downto 00):=R_HESERR; 

when 27 => DATA_OUT(31 downto 16):=R_VCOUNT; 

DATA_OUT(15 downto 00):=R_VESYNC; 

when 28 => DATA_OUT(31 downto 16):=R_VEBLNK; 

DATA_OUT(15 downto 00):=R_VSBLNK; 

when 29 => DATA_OUT(31 downto 16):=R_VTOTAL; 

DATA_OUT(15 downto 00):=R_29; 



when 32 => DATA_OUT(31 downto 24):=R_PATTN000; 

DATA_OUT(23 downto 16):=R_PATTN001; 



when 33 => DATA_OUT(31 downto 24):=R_PATTN004; 




-- etc... 

when others => DATA_OUT :=lo32; 

end case; 

print "read R#" & ADS_lat & " bytes " & BS_lat; 

T1 

exit 

Abbildung 91: Speedchart-Diagramm TIM/CONTROL/TIM ACCESS/REG READ 

T2 

Anhang D.2 

Seite 121

Abbildung 92: Speedchart-Diagramm TIM/CONTROL/TIM ACCESS/REG WRITE 

REG_WRITE 

entry 

T1 T2 T3 T4 T5 

S1 

S2 

S3 

S4 

A: -- write upper byte of register 

A: -- write higher byte of register 

A: -- write middle byte of register 

A: -- write lower byte of register 





case ADS_lat is 




-- when 0 => null; -- R_STATUS is read only 

when 1 => if LOCK=’0’ then 

when 0 => R_IMASK := DATA_IN(23 downto 16); 

when 0 => R_LINTV (15 downto 08) := DATA_IN(15 downto 8); 

when 0 => R_LINTV (07 downto 00) := DATA_IN(7 downto 0); 

R_CONFIG (31 downto 24) := DATA_IN(31 downto 24); 




end if; 





end if; 

elsif (DATA_IN(15 downto 8)=0x7F) then 

end if; 

R_MUXOFF (15 downto 08) := DATA_IN(31 downto 24); 


unlock:=’1’; -- ready for 7F-unlock 

end if; 

R_MUXOFF (07 downto 00) := DATA_IN(23 downto 16); 

elsif (DATA_IN(15 downto 8)=0x55 and unlock=’1’) then when 2 => R_XYZOOM := DATA_IN(7 downto 0); 

end if; 

R_CONFIG (15):=’0’; -- 55 after 7F clears LOCK ! 

when 3 => R_DINC (07 downto 00) := DATA_IN(7 downto 0); 

when 3 => R_SINC (15 downto 08) := DATA_IN(31 downto 24); 

unlock:=’0’; 

when 4 => R_4 (07 downto 00) := DATA_IN(7 downto 0); 


when 3 => R_SINC (07 downto 00) := DATA_IN(23 downto 16); 

else 




unlock:=’0’; -- other value, 7F will not unlock. 

when 6 => R_SSTART (07 downto 00) := DATA_IN(7 downto 0); 



end if; 

when 7 => R_DSTART (07 downto 00) := DATA_IN(7 downto 0); 




when 8 => R_DPYSTRT (07 downto 00) := DATA_IN(7 downto 0); 



R_RADSEL := DATA_IN(15 downto 8); 

when 9 => R_DPYNXT (07 downto 00) := DATA_IN(7 downto 0); 



end if; 

when 10 => R_DPYMASK (07 downto 00) := DATA_IN(7 downto 0); 

when 10 => R_DPYINC (15 downto 08) := DATA_IN(31 downto 24); 


when 11 => R_SADR (07 downto 00) := DATA_IN(7 downto 0); 


when 10 => R_DPYINC (07 downto 00) := DATA_IN(23 downto 16); 

when 3 => R_DINC (15 downto 08) := DATA_IN(15 downto 8); 

when 12 => R_DADR (07 downto 00) := DATA_IN(7 downto 0); 




when 13 => R_DY (07 downto 00) := DATA_IN(7 downto 0); 

when 13 => R_DX (15 downto 08) := DATA_IN(31 downto 24); 




when 14 => R_PSIZE := DATA_IN(31 downto 24); 

when 13 => R_DX (07 downto 00) := DATA_IN(23 downto 16); 


when 15 => R_COMMAND := DATA_IN(7 downto 0); 

when 15 => R_AUXREG := DATA_IN(31 downto 24); 

when 14 => R_PATTNSIZE := DATA_IN(23 downto 16); 


when 16 => R_COLOR0 (07 downto 00) := DATA_IN(7 downto 0); 


when 15 => R_HDREG := DATA_IN(23 downto 16); 









when 10 => R_DPYMASK (15 downto 08) := DATA_IN(15 downto 8); 





when 20 => R_WENDX (07 downto 00) := DATA_IN(7 downto 0); 

when 20 => R_WSTARTX (15 downto 08) := DATA_IN(31 downto 24); 



when 21 => R_WENDY (07 downto 00) := DATA_IN(7 downto 0); 

when 21 => R_WSTARTY (15 downto 08) := DATA_IN(31 downto 24); 

when 20 => R_WSTARTX (07 downto 00) := DATA_IN(23 downto 16); 

when 13 => R_DY (15 downto 08) := DATA_IN(15 downto 8); 

when 22 => R_SETVCNT (07 downto 00) := DATA_IN(7 downto 0); 

when 22 => R_SETHCNT (15 downto 08) := DATA_IN(31 downto 24); 

when 21 => R_WSTARTY (07 downto 00) := DATA_IN(23 downto 16); 




when 22 => R_SETHCNT (07 downto 00) := DATA_IN(23 downto 16); 

when 15 => R_COMCTRL := DATA_IN(15 downto 8); 

when 24 => R_HESYNC (07 downto 00) := DATA_IN(7 downto 0); 

when 24 => R_HCOUNT (15 downto 08) := DATA_IN(31 downto 24); 



when 25 => R_HSBLNK (07 downto 00) := DATA_IN(7 downto 0); 

when 25 => R_HEBLNK (15 downto 08) := DATA_IN(31 downto 24); 

when 24 => R_HCOUNT (07 downto 00) := DATA_IN(23 downto 16); 


when 26 => R_HESERR (07 downto 00) := DATA_IN(7 downto 0); 

when 26 => R_HTOTAL (15 downto 08) := DATA_IN(31 downto 24); 

when 25 => R_HEBLNK (07 downto 00) := DATA_IN(23 downto 16); 


when 27 => R_VESYNC (07 downto 00) := DATA_IN(7 downto 0); 

when 27 => R_VCOUNT (15 downto 08) := DATA_IN(31 downto 24); 

when 26 => R_HTOTAL (07 downto 00) := DATA_IN(23 downto 16); 


when 28 => R_VSBLNK (07 downto 00) := DATA_IN(7 downto 0); 

when 28 => R_VEBLNK (15 downto 08) := DATA_IN(31 downto 24); 

when 27 => R_VCOUNT (07 downto 00) := DATA_IN(23 downto 16); 

when 20 => R_WENDX (15 downto 08) := DATA_IN(15 downto 8); 


when 29 => R_VTOTAL (15 downto 08) := DATA_IN(31 downto 24); 

when 28 => R_VEBLNK (07 downto 00) := DATA_IN(23 downto 16); 

when 21 => R_WENDY (15 downto 08) := DATA_IN(15 downto 8); 



when 29 => R_VTOTAL (07 downto 00) := DATA_IN(23 downto 16); 

when 22 => R_SETVCNT (15 downto 08) := DATA_IN(15 downto 8); 





when 32 => R_PATTN003 := DATA_IN(7 downto 0); 



when 24 => R_HESYNC (15 downto 08) := DATA_IN(15 downto 8); 




when 25 => R_HSBLNK (15 downto 08) := DATA_IN(15 downto 8); 

-- etc... 

-- etc... 


when 26 => R_HESERR (15 downto 08) := DATA_IN(15 downto 8); 

end case; 

end case; 

-- etc... 

when 27 => R_VESYNC (15 downto 08) := DATA_IN(15 downto 8); 

print "write R L#" & ADS_lat & " data " & DATA_IN(7 downto 0); 

print "write R U#" & ADS_lat & " data " & DATA_IN(31 downto 24); end case; 

when 28 => R_VSBLNK (15 downto 08) := DATA_IN(15 downto 8); end if; 

end if; 

print "write R H#" & ADS_lat & " data " & DATA_IN(23 downto 16); 


end if; 





-- etc... 

end case; 

print "write R M#" & ADS_lat & " data " & DATA_IN(15 downto 8); 

end if; 

exit 



Lukas Bauer 

Diplomarbeit 


Anhang D.2 

Seite 122



Lukas Bauer 

Diplomarbeit 



-- Variables of Diagram MEM_ACCESS 

Anhang D.2 

Seite 123 

DCMASK_L(4): logic:=lo4; -- CAS mask left-hand side dest. 

DCMASK_R(4): logic:=lo4; -- CAS mask right-hand side dest. 

SCMASK_L(4): logic:=lo4; -- CAS mask left-hand side source 

SCMASK_R(4): logic:=lo4; -- CAS mask right-hand side source 

PRE_READ: logic:=’0’; -- ’1’: read dest. bef. write 

PRE_MASK(32): logic:=hi32; -- ’1’s mark valid destination bits 

GPU_READ_DONE: logic:=’0’; -- ’1’: write DATA_OUT into GPU fifo 

GPU_WRITE_DONE: logic:=’0’; -- ’1’: increment GPU fifo write ptr 

ANY_CYCLE: logic; -- ’1’: perform memory access 

MEM_GREAD: logic; -- ’1’: GPU read access 

MEM_GWRITE: logic; -- ’1’: GPU write/rmw access 

GREAD_END: logic:=’0’; -- ’1’: get RAM data after GPU read 

MEM_RMW: logic:=’0’; -- ’1’: perform rmw cycle 

WRITE_DATA(32): logic; -- write data for PixBlT destination 

D_GPU_FIFO(32): logic; -- data from GPU fifo current pos. 

-- 

Abbildung 93: Variablen im Diagramm TIM/CONTROL/MEM ACCESS

Abbildung 94: Speedchart-Diagramm TIM/CONTROL/MEM ACCESS/MEM CYCLES 

MEM_CYCLES 

Entry of 

A: -- MWE_ict:=’0’ when write access 

-- D_ict :=(write data) & (activate D_oe when write) 

-- RCA_ict:=(CAS address) 

-- CAS_lat:=(CAS mask) (not applied to RAM port yet) 

-- mark written bytes in CAS_DONE 

if MEM_READ=’1’ or MEM_GREAD=’1’ then 

MOE_ict:=’0’; -- memory read 

MWE_ict:=’1’; 

elsif MEM_GWRITE=’1’ and PRE_READ=’1’ then 

MEM_RMW:=’1’; -- memory read-modify-write cycle 

MOE_ict:=’0’; 


else 

MWE_ict:=’0’; -- memory write 

DOE_ict:=hi32; -- data lines as outputs 

end if; 

case MBW is 

when "00" => 

CAS_lat:="1110"; 

RCA_ict(13 downto 2):=RAM_COL(13 downto 2); 

if CAS_MASK(3)=’0’ then 

RCA_ict(1 downto 0):="00"; -- byte U 

CAS_DONE(3):=’1’; -- done 

D_ict(7 downto 0):=RAM_D_W(31 downto 24); 

end if; 

if CAS_MASK(3 downto 2)="10" then 

RCA_ict(1 downto 0):="01"; -- byte H 



end if; 

if CAS_MASK(3 downto 1)="110" then 

RCA_ict(1 downto 0):="10"; -- byte M 



end if; 

if CAS_MASK="1110" then 

RCA_ict(1 downto 0):="11"; -- byte L 



end if; 

when "01" => 


CAS_lat(3 downto 2):="11"; 

if CAS_MASK(3 downto 2)/="11" then 

CAS_lat(1 downto 0):=CAS_MASK(3 downto 2); 

RCA_ict(0):=’0’; -- byte U+H 

CAS_DONE(3 downto 2):="11"; -- done 


else 

CAS_lat(1 downto 0):=CAS_MASK(1 downto 0); 

RCA_ict(0):=’1’; -- byte M+L 

CAS_DONE(1 downto 0):="11"; -- done 


end if; 

when others => 


CAS_lat:=CAS_MASK; 

CAS_DONE:="1111"; -- all bytes done 

D_ict:=RAM_D_W; 

end case; 

-- address: | 0 1 2 3 | 4 5 6... 

-- bytes: | U H M L | U H M... 

-- CAS: | 3 2 1 0 | 3 2 1... 

-- data bits:| 31-24 23-16 15-08 07-00 | ... 

Subdiagram MEM_CYCLES: read or write RAM data 

RAM_ADDR: address of read/write access 

CAS_MASK: CAS mask 

RAM_D_W: write data from current FIFO buffer pos., 

if necessary, up to 4 write cycles 

are performed (HBW=32, MBW=8). 

DATA_OUT: data read from the RAM 

read: when RAM_READ=’1’ (HOST) or RAM_GREAD=’1’ (GPU) 

write: when FIFO_IN/=FIFO_OUT (HOST) 

or (RAM_GWRITE=’1’ and PRE_READ=’0’) (GPU) 

rmw: when (RAM_GWRITE=’1’ and PRE_READ=’1’) (GPU) 

Entry of 

A: RCA_ict:=RAM_ROW; 

T2 

A: RAS_ict :=RAS_MASK; 

LAST_RAS:=RAS_MASK; 

ACS_ict :=ACS_MASK; 

LAST_ACS:=ACS_MASK; 

LAST_ROW:=RAM_ROW; 

C: ANY_CYCLE=’1’ 

RAS1 

T11 

RAS2 CAS1 

T3 

T10 #0 

entry 


and LAST_ROW=RAM_ROW 

and LAST_RAS=RAS_MASK 

and LAST_ACS=ACS_MASK 

T4 

T1 

T6 #1 

A: CAS_ict:=CAS_lat; 

if CAS_MASK="1111" then 

if MEM_GWRITE=’1’ and 

PRE_READ=’0’then 

GPU_WRITE_DONE:=’1’; 

-- request addr inc 

-- (diagr. GPU_FIFO_W) 

elsif MEM_GREAD=’1’ then 

GREAD_END:=’1’; 

-- read last data 

GPU_READ_DONE:=’1’; 

-- request addr inc 

-- (diagr. GPU_FIFO_R) 

end if; 

end if; 

Entry of 

A: RAS_ict:="1111"; 



RCA_ict:=hi14; 

DOE_ict:=lo32; -- input mode 

cold_stb 


-- if different ROW/RAS/ACS 

or PEN=’0’ 

-- or timeout 

T7 

T12 

hot_stb 

T8 

C: ANY_CYCLE=’0’ and PEN=’1’ 

A: MWE_ict:=’1’; 

DOE_ict:=lo32; -- input mode 


RCA_ict:=hi14; 

if MEM_READ=’1’ and READ_DONE=’1’ then 


end if; 

C: ANY_CYCLE=’1’ and LAST_ROW=RAM_ROW 

and LAST_RAS=RAS_MASK 

and LAST_ACS=ACS_MASK 

-- access same RAS address 

and PEN=’1’ 

CAS2 

T5 

A: if CAS_MASK="1111" then 

CAS_DONE:="0000"; 

if MEM_READ=’1’ then 

READ_DONE:=’1’; 

elsif FIFO_IN/=FIFO_OUT then 

FIFO_OUT:=(FIFO_OUT+1) mod 8; 

end if; 

end if; 

C: (ANY_CYCLE=’1’ 

and (LAST_ROW/=RAM_ROW 

or LAST_RAS/=RAS_MASK 

or LAST_ACS/=ACS_MASK)) 

-- access different RAS address 

or PEN=’0’ 

A: if MEM_READ=’1’ and READ_DONE=’1’ then 


end if; 

CAS3 

RMW1 

T9 #0 

T15 

CAS_END Exit of 

A: CAS_ict:="1111"; 

T13 

T16 

C: MEM_RMW=’1’ 

A: MOE_ict:=’1’; 

-- and exit action of CAS3 

-- (read RAM data into DATA_OUT) 


A: -- test only 

FIFOIN_ot :=FIFO_IN mod 8; 

FIFOOUT_ot :=FIFO_OUT mod 8; 

CAS_MASK_ot :=CAS_MASK; 

ANY_CYCLE_ot :=ANY_CYCLE; 

MEM_GWRITE_ot :=MEM_GWRITE; 

GPU_WNUM_ot :=GPU_WNUM mod 16; 

MEM_GREAD_ot :=MEM_GREAD; 

GPU_RNUM_ot :=GPU_RNUM mod 16; 

PRE_READ_ot :=PRE_READ; 

PRE_MASK_ot :=PRE_MASK; 

Exit of 

A: if MEM_READ=’1’ or MEM_GREAD=’1’ 

or (MEM_GWRITE=’1’ and PRE_READ=’1’) then 

case MBW is 

when "00" => 

case RCA_ict(1 downto 0) is 

when "00" => DATA_OUT(31 downto 24) 

:=MD_in(7 downto 0); 





when "11" => DATA_OUT( 7 downto 0) 


end case; 

when "01" => 

case RCA_ict(0) is 

when ’0’ => DATA_OUT(31 downto 16) 


when ’1’ => DATA_OUT(15 downto 0) 


end case; 


DATA_OUT:=MD_in; 

end case; 

end if; 

GREAD_END:=’0’; 

A: GPU_WRITE_DONE:=’1’; 

-- output modified data: 

case MBW is 

when "00" => 

case RCA_ict(1 downto 0) is 

when "00" => D_ict(7 downto 0):=RAM_D_W(31 downto 24); 




end case; 

when "01" => 

case RCA_ict(0) is 

when ’0’ => D_ict(15 downto 00):=RAM_D_W(31 downto 16); 

when ’1’ => D_ict(15 downto 00):=RAM_D_W(15 downto 00); 

end case; 


D_ict:=RAM_D_W; 

end case; 

T14 

RMW3 

RMW2 

A: MWE_ict:=’0’; 

-- write enable 

MEM_RMW:=’0’; 



Lukas Bauer 

Diplomarbeit 


Anhang D.2 

Seite 124



Lukas Bauer 

ADDR_CALC 


A: -- address calculation: 

-- RAM_ADDR(32): accessed address 

-- 

-- MO_A(3),MO_B(3),MO_C(3),MO_D(3), 

-- RSL(3),ASL(3): registers 

-- 

-- RAS_MASK(4): decoded RAS signals 

-- ACS_MASK(4): decoded ACS signals 

-- RAM_ROW(14): row address 

-- RAM_COL(14): column address 

-- get ACS bank 

Diplomarbeit 


case ASL is -- address bits for ACS bank selection 

when "000" => AS_A:=RAM_ADDR(17 downto 16); 








end case; 

case AS_A is -- value of "ACS bank select" address bits 

when "00" => ACS_MASK:="1110"; 

when "01" => ACS_MASK:="1101"; 

when "10" => ACS_MASK:="1011"; 

when "11" => ACS_MASK:="0111"; 

end case; 

-- get RAS address / RAM row 

case RSL is -- address bits for RAS bank selection 

when "000" => RS_A:=RAM_ADDR(17 downto 16); 








end case; 

case RS_A is -- value of "RAS bank select" address bits 

when "00" => MOX:=MO_A; 

RAS_MASK:="1110"; 

when "01" => MOX:=MO_B; 

RAS_MASK:="1101"; 

when "10" => MOX:=MO_C; 

RAS_MASK:="1011"; 

when "11" => MOX:=MO_D; 

RAS_MASK:="0111"; 

end case; 

case MOX is -- RAS address selector of selected bank 

when "000" => RAM_ROW:=RAM_ADDR(21 downto 8); 








end case; 

-- get BS(0) CAS address / RAM column 

case MBW is 

when "00" => -- 8 bit memory bus 

RAM_COL(13 downto 2):=RAM_ADDR(13 downto 2); 

RAM_COL(1 downto 0):="00"; 

-- bits 1+0 of col. addr. determined by BS3..BS0 

when "01" => -- 16 bit memory bus 


RAM_COL(0):=’0’; 

-- bit 0 of col. addr. determined by BS1..BS0 

when others => -- 32 bit memory bus 


end case; 

Abbildung 95: Speedchart-Diagramm TIM/CONTROL/MEM ACCESS/ADDR CALC 

Anhang D.2 

Seite 125



Lukas Bauer 

BIT_SHIFT 


V: BOTH_LW(64): logic; 

A: -- fit DATA_OUT longword into (S_HI_LW / S_LO_LW) 

-- starting at bit number (DBOS_L-SBOS_L) 

Diplomarbeit 


case ((DBOS_L+32)-SBOS_L) mod 32 is -- +32 for speedchart 

when 0 => BOTH_LW(63 downto 32):=DATA_OUT; 

BOTH_LW(31 downto 00):=lo32; 

when 1 => BOTH_LW(63):=’0’; 

BOTH_LW(62 downto 31):=DATA_OUT; 

BOTH_LW(30 downto 00):="0000000000000000000000000000000"; 

when 2 => BOTH_LW(63 downto 62):="00"; 


BOTH_LW(29 downto 00):="000000000000000000000000000000"; 



BOTH_LW(28 downto 00):="00000000000000000000000000000"; 



BOTH_LW(27 downto 00):="0000000000000000000000000000"; 



BOTH_LW(26 downto 00):="000000000000000000000000000"; 



BOTH_LW(25 downto 00):="00000000000000000000000000"; 



BOTH_LW(24 downto 00):="0000000000000000000000000"; 



BOTH_LW(23 downto 00):="000000000000000000000000"; 



BOTH_LW(22 downto 00):="00000000000000000000000"; 



BOTH_LW(21 downto 00):="0000000000000000000000"; 



BOTH_LW(20 downto 00):="000000000000000000000"; 



BOTH_LW(19 downto 00):="00000000000000000000"; 



BOTH_LW(18 downto 00):="0000000000000000000"; 



BOTH_LW(17 downto 00):="000000000000000000"; 



BOTH_LW(16 downto 00):="00000000000000000"; 



BOTH_LW(15 downto 00):="0000000000000000"; 



BOTH_LW(14 downto 00):="000000000000000"; 



BOTH_LW(13 downto 00):="00000000000000"; 



BOTH_LW(12 downto 00):="0000000000000"; 



BOTH_LW(11 downto 00):="000000000000"; 



BOTH_LW(10 downto 00):="00000000000"; 



BOTH_LW(09 downto 00):="0000000000"; 



BOTH_LW(08 downto 00):="000000000"; 



BOTH_LW(07 downto 00):="00000000"; 



BOTH_LW(06 downto 00):="0000000"; 



BOTH_LW(05 downto 00):="000000"; 



BOTH_LW(04 downto 00):="00000"; 



BOTH_LW(03 downto 00):="0000"; 



BOTH_LW(02 downto 00):="000"; 



BOTH_LW(01 downto 00):="00"; 



BOTH_LW(0):=’0’; 

end case; 

S_HI_LW:=BOTH_LW(63 downto 32); 

S_LO_LW:=BOTH_LW(31 downto 00); 

Abbildung 96: Speedchart-Diagramm TIM/CONTROL/MEM ACCESS/BIT SHIFT 

Anhang D.2 

Seite 126



Lukas Bauer 

BIT_MASK 


A: -- DBMASK_L: bit mask: valid bits in leftmost LW of line 

-- DBMASK_R: bit mask: valid bits in rightmost LW of line 

-- DCMASK_L: CAS mask: valid bytes in leftmost LW of line 

-- DCMASK_R: CAS mask: valid bytes in rightmost LW of line 

-- SCMASK_L: same as DCMASK_L, but for source 

-- SCMASK_R: same as DCMASK_R, but for source 

case DBOS_L is -- first valid bit 

when 0 => DBMASK_L:="11111111111111111111111111111111"; 

when 1 => DBMASK_L:="01111111111111111111111111111111"; 

when 2 => DBMASK_L:="00111111111111111111111111111111"; 

when 3 => DBMASK_L:="00011111111111111111111111111111"; 

when 4 => DBMASK_L:="00001111111111111111111111111111"; 

when 5 => DBMASK_L:="00000111111111111111111111111111"; 

when 6 => DBMASK_L:="00000011111111111111111111111111"; 

when 7 => DBMASK_L:="00000001111111111111111111111111"; 

when 8 => DBMASK_L:="00000000111111111111111111111111"; 

when 9 => DBMASK_L:="00000000011111111111111111111111"; 

when 10 => DBMASK_L:="00000000001111111111111111111111"; 

when 11 => DBMASK_L:="00000000000111111111111111111111"; 

when 12 => DBMASK_L:="00000000000011111111111111111111"; 

when 13 => DBMASK_L:="00000000000001111111111111111111"; 

when 14 => DBMASK_L:="00000000000000111111111111111111"; 

when 15 => DBMASK_L:="00000000000000011111111111111111"; 

when 16 => DBMASK_L:="00000000000000001111111111111111"; 

when 17 => DBMASK_L:="00000000000000000111111111111111"; 

when 18 => DBMASK_L:="00000000000000000011111111111111"; 

when 19 => DBMASK_L:="00000000000000000001111111111111"; 

when 20 => DBMASK_L:="00000000000000000000111111111111"; 

when 21 => DBMASK_L:="00000000000000000000011111111111"; 

when 22 => DBMASK_L:="00000000000000000000001111111111"; 

when 23 => DBMASK_L:="00000000000000000000000111111111"; 

when 24 => DBMASK_L:="00000000000000000000000011111111"; 

when 25 => DBMASK_L:="00000000000000000000000001111111"; 

when 26 => DBMASK_L:="00000000000000000000000000111111"; 

when 27 => DBMASK_L:="00000000000000000000000000011111"; 

when 28 => DBMASK_L:="00000000000000000000000000001111"; 

when 29 => DBMASK_L:="00000000000000000000000000000111"; 

when 30 => DBMASK_L:="00000000000000000000000000000011"; 

when 31 => DBMASK_L:="00000000000000000000000000000001"; 

end case; 

case DBOS_R is -- last valid bit 

when 0 => DBMASK_R:="10000000000000000000000000000000"; 

when 1 => DBMASK_R:="11000000000000000000000000000000"; 

when 2 => DBMASK_R:="11100000000000000000000000000000"; 

when 3 => DBMASK_R:="11110000000000000000000000000000"; 

when 4 => DBMASK_R:="11111000000000000000000000000000"; 

when 5 => DBMASK_R:="11111100000000000000000000000000"; 

when 6 => DBMASK_R:="11111110000000000000000000000000"; 

when 7 => DBMASK_R:="11111111000000000000000000000000"; 

when 8 => DBMASK_R:="11111111100000000000000000000000"; 

when 9 => DBMASK_R:="11111111110000000000000000000000"; 

when 10 => DBMASK_R:="11111111111000000000000000000000"; 

when 11 => DBMASK_R:="11111111111100000000000000000000"; 

when 12 => DBMASK_R:="11111111111110000000000000000000"; 

when 13 => DBMASK_R:="11111111111111000000000000000000"; 

when 14 => DBMASK_R:="11111111111111100000000000000000"; 

when 15 => DBMASK_R:="11111111111111110000000000000000"; 

when 16 => DBMASK_R:="11111111111111111000000000000000"; 

when 17 => DBMASK_R:="11111111111111111100000000000000"; 

when 18 => DBMASK_R:="11111111111111111110000000000000"; 

when 19 => DBMASK_R:="11111111111111111111000000000000"; 

when 20 => DBMASK_R:="11111111111111111111100000000000"; 

when 21 => DBMASK_R:="11111111111111111111110000000000"; 

when 22 => DBMASK_R:="11111111111111111111111000000000"; 

when 23 => DBMASK_R:="11111111111111111111111100000000"; 

when 24 => DBMASK_R:="11111111111111111111111110000000"; 

when 25 => DBMASK_R:="11111111111111111111111111000000"; 

when 26 => DBMASK_R:="11111111111111111111111111100000"; 

when 27 => DBMASK_R:="11111111111111111111111111110000"; 

when 28 => DBMASK_R:="11111111111111111111111111111000"; 

when 29 => DBMASK_R:="11111111111111111111111111111100"; 

when 30 => DBMASK_R:="11111111111111111111111111111110"; 

when 31 => DBMASK_R:="11111111111111111111111111111111"; 

end case; 

DCMASK_L:="0000" when DBOS_L



Lukas Bauer 

MEM_ADDRESS 


V: CAS_M(4): logic:=lo4; -- CAS mask 

-- 

A: RAM_ADDR:=lo32; -- no memory access 

CAS_MASK:=hi4; ------------------- 

RAM_D_W:=lo32; 

ANY_CYCLE:=’0’; 

MEM_GREAD:=’0’; 

MEM_GWRITE:=’0’; 

if MEM_READ=’1’ then -- host data read 

----------------- 

ANY_CYCLE:=bnot READ_DONE; -- perform memory access 

RAM_ADDR:=A_READ; -- read address 

CAS_M:=CAS_READ; -- CAS mask 

elsif FIFO_IN/=FIFO_OUT then -- host data write 

------------------ 

ANY_CYCLE:=’1’; -- perform memory access 

case (FIFO_OUT mod 4) is -- get from write fifo: 

when 0 => 

RAM_ADDR:=A_FIFO0; -- write address 

RAM_D_W :=D_FIFO0; -- write data 

CAS_M:=CAS_FIFO0; -- CAS mask 

when 1 => 

RAM_ADDR:=A_FIFO1; 

RAM_D_W :=D_FIFO1; 

CAS_M:=CAS_FIFO1; 

when 2 => 




when 3 => 




end case; 

Diplomarbeit 


elsif GPU_READ=’1’ or GREAD_END=’1’ then -- gr-command data read 

----------------------if 

GPU_READ=’1’ then 


end if; 

MEM_GREAD:=’1’; 

RAM_ADDR:=SADRLW_C shl 2; -- current read address (LW->byte) 

if SADRLW_C=SADRLW_L then 

if SADRLW_C/=SADRLW_R then -- leftmost longword ? 

CAS_M:=SCMASK_L; -- only read relevant bytes (l) 

else -- one longword only ? 

CAS_M:=SCMASK_L bor SCMASK_R; -- only read relevant bytes (m) 

end if; 

elsif SADRLW_C=SADRLW_R then -- rightmost longword ? 

CAS_M:=SCMASK_R; -- only read relevant bytes (r) 

else -- in between 

CAS_M:="0000"; -- read all 4 bytes 

end if; 

elsif GPU_WRITE=’1’ then -- gr-command data write 

------------------------ 


MEM_GWRITE:=’1’; 

RAM_ADDR:=DADRLW_C shl 2; -- current write address (LW->byte) 

if DADRLW_C=DADRLW_L then 

if DADRLW_C/=DADRLW_R then -- leftmost longword ? 

CAS_M:=DCMASK_L; -- only write relev. bytes (l) 

PRE_MASK:=DBMASK_L; -- use left-hand side bit mask 

PRE_READ:=’1’ -- read dest. before writing 

when ((DBOS_L mod 8)/=0 -- if dest. isn’t byte-aligned 

or S(1 downto 0)/="00") -- or source and dest. are comb. 

else ’0’; 

else -- one longword only ? 

CAS_M:=DCMASK_L bor DCMASK_R; -- only write relev. bytes (m) 

PRE_MASK:=DBMASK_L band DBMASK_R; -- "and" bit masks 


when ((DBOS_L mod 8)/=0 -- if source or destination 

or (DBOS_R mod 8)/=7 -- isn’t byte-aligned 


else ’0’; 

end if; 

elsif DADRLW_C=DADRLW_R then -- rightmost longword ? 

CAS_M:=DCMASK_R; -- only write relev. bytes (r) 

PRE_MASK:=DBMASK_R; -- use right-hand side bit mask 


when ((DBOS_R mod 8)/=7 -- if dest. isn’t byte-aligned 


else ’0’; 

else -- in between 

CAS_M:="0000"; -- write all 4 bytes 

PRE_READ:=’1’ -- only read destination 

when S(1 downto 0)/="00" -- if source and dest. are comb. 

else ’0’; 

PRE_MASK:=hi32; -- all GPU FIFO data bits valid 

end if; 

case GPU_FIFO_OUT is -- get data from GPU fifo buffer 

when 0 => D_GPU_FIFO:=D_GPU_FIFO0; 









end case; 

RAM_D_W:=WRITE_DATA; -- from diagram PIXBLT_PATH 

end if; 

CAS_MASK:=CAS_M bor CAS_DONE; -- don’t read the same bytes again 

Abbildung 98: Speedchart-Diagramm TIM/CONTROL/MEM ACCESS/MEM ADDRESS 

Anhang D.2 

Seite 128



Lukas Bauer 

GPU_FIFO_R 

entry 

T3 

T1 

S1 

S2 

T4 

T2 

A: -- write data read from memory into GPU fifo buffer 

-- (write DATA_OUT via BIT_SHIFT, S_HI_LW/S_LO_LW) 

-- and increment LW address & buffer position 

if PBV=’0’ then -- left to right 

case GPU_FIFO_IN is 

when 0 => D_GPU_FIFO8:=D_GPU_FIFO8 bor S_HI_LW; 

D_GPU_FIFO0:=S_LO_LW; 

















end case; 

Diplomarbeit 


GPU_FIFO_IN:=GPU_FIFO_IN+1 when GPU_FIFO_IN/=8 else 0; 

else -- right to left 

case GPU_FIFO_IN is 

when 8 => D_GPU_FIFO0:=D_GPU_FIFO0 bor S_LO_LW; 

D_GPU_FIFO8:=S_HI_LW; 

















end case; 

GPU_FIFO_IN:=GPU_FIFO_IN-1 when GPU_FIFO_IN/=0 else 8; 

end if; 

S3 

C: GPU_READ_DONE=’1’ 

A: -- decrement RNUM (number of longwords to go) 

-- and check for end of line 

GPU_READ_DONE:=’0’; 


if SADRLW_C=SADRLW_R then 

GPU_RNUM:=15; -- end of line, abort read-in phase 

GPU_READ:=’0’; 

else 

if GPU_RNUM=1 then 

GPU_READ:=’0’; -- all LW’s done 

end if; 

GPU_RNUM:=GPU_RNUM-1; 

end if; 

SADRLW_C:=SADRLW_C+1; -- next source LW address 


if SADRLW_C=SADRLW_L then 

GPU_RNUM:=15; -- end of line, abort read-in phase 


else 

if GPU_RNUM=1 then 

GPU_READ:=’0’; -- all LW’s done 

end if; 

GPU_RNUM:=GPU_RNUM-1; 

end if; 

SADRLW_C:=SADRLW_C-1; -- next (prev.) source LW address 

end if; 

Abbildung 99: Speedchart-Diagramm TIM/CONTROL/MEM ACCESS/GPU FIFO R 

Anhang D.2 

Seite 129



Lukas Bauer 

GPU_FIFO_W 

entry 

T1 

S1 

T2 

Diplomarbeit 


C: GPU_WRITE_DONE=’1’ 

A: -- increment LW address & buffer position 

-- after writing data from GPU fifo buffer 

-- to the destination address 

GPU_WRITE_DONE:=’0’; 


Anhang D.2 

Seite 130 

GPU_FIFO_OUT:=GPU_FIFO_OUT+1 when GPU_FIFO_OUT/=8 else 0; 

DADRLW_C:=DADRLW_C+1; 

if DADRLW_C=DADRLW_R then 

GPU_WNUM:=15; -- end of line, abort write phase 

GPU_WRITE:=’0’; 

else 

if GPU_WNUM=1 then 


end if; 

GPU_WNUM:=GPU_WNUM-1; 

end if; 


GPU_FIFO_OUT:=GPU_FIFO_OUT-1 when GPU_FIFO_OUT/=0 else 8; 

DADRLW_C:=DADRLW_C-1; 

if DADRLW_C=DADRLW_L then 

GPU_WNUM:=15; -- end of line, abort write phase 


else 

if GPU_WNUM=1 then 


end if; 

GPU_WNUM:=GPU_WNUM-1; 

end if; 

end if; 

Abbildung 100: Speedchart-Diagramm TIM/CONTROL/MEM ACCESS/GPU FIFO W



Lukas Bauer 

PIXBLT_PATH 

Diplomarbeit 



V: INV_S_DATA(32): logic:=lo32; -- orig source data, inv. if S(2)=’1’ 

INV_D_DATA(32): logic:=lo32; -- orig dest. data, inv. if S(3)=’1’ 

FST_D_DATA(32): logic:=lo32; -- dest. data before inversion 

DEST_DATA(32): logic:=lo32; -- dest. data before PRE_MASK 

VEC_S_U(8): logic:=lo8; -- upper byte INV_S_DATA 

VEC_S_H(8): logic:=lo8; -- higher byte INV_S_DATA 

VEC_S_M(8): logic:=lo8; -- middle byte INV_S_DATA 

VEC_S_L(8): logic:=lo8; -- lower byte INV_S_DATA 

INT_S_U: int8:=0; -- upper byte INV_S_DATA as an INT 

INT_S_H: int8:=0; -- higher byte INV_S_DATA as an INT 

INT_S_M: int8:=0; -- middle byte INV_S_DATA as an INT 

INT_S_L: int8:=0; -- lower byte INV_S_DATA as an INT 

VEC_D_U(8): logic:=lo8; -- upper byte INV_D_DATA 

VEC_D_H(8): logic:=lo8; -- higher byte INV_D_DATA 

VEC_D_M(8): logic:=lo8; -- middle byte INV_D_DATA 

VEC_D_L(8): logic:=lo8; -- lower byte INV_D_DATA 

INT_D_U: int8:=0; -- upper byte INV_D_DATA as an INT 

INT_D_H: int8:=0; -- higher byte INV_D_DATA as an INT 

INT_D_M: int8:=0; -- middle byte INV_D_DATA as an INT 

INT_D_L: int8:=0; -- lower byte INV_D_DATA as an INT 

INT_SUM_U: int8:=0; -- upper byte of the sum as an INT 

INT_SUM_H: int8:=0; -- higher byte of the sum as an INT 

INT_SUM_M: int8:=0; -- middle byte of the sum as an INT 

INT_SUM_L: int8:=0; -- lower byte of the sum as an INT 

VEC_SUM_U(8): logic:=lo8; -- upper byte of the sum 

VEC_SUM_H(8): logic:=lo8; -- higher byte of the sum 

VEC_SUM_M(8): logic:=lo8; -- middle byte of the sum 

VEC_SUM_L(8): logic:=lo8; -- lower byte of the sum 

A: -- 

-- D_GPU_FIFO: (in) source data (from FIFO buffer) 

-- DATA_OUT: (in) pre-read destination data 

-- PRE_MASK: (in) bit mask: ’1’= use source data 

-- ’0’= use pre-read data 

-- WRITE_DATA: (out) write data for PIXBLT destination 

INV_S_DATA:=D_GPU_FIFO when S(2)=’0’ else bnot D_GPU_FIFO; 

INV_D_DATA:=DATA_OUT when S(3)=’0’ else bnot DATA_OUT; 

VEC_S_U:=INV_S_DATA(31 downto 24); -- all this is 

VEC_S_H:=INV_S_DATA(23 downto 16); -- necessary 

VEC_S_M:=INV_S_DATA(15 downto 08); -- because 

VEC_S_L:=INV_S_DATA(07 downto 00); -- speedchart 

VEC_D_U:=INV_D_DATA(31 downto 24); -- doesn’t 

VEC_D_H:=INV_D_DATA(23 downto 16); -- support the 

VEC_D_M:=INV_D_DATA(15 downto 08); -- addition 

VEC_D_L:=INV_D_DATA(07 downto 00); -- of vectors !! 

INT_S_U:=VEC_S_U; 

INT_S_H:=VEC_S_H; -- so: get the 4 vectors 

INT_S_M:=VEC_S_M; -- (VHDL2000 doesn’t permit 

INT_S_L:=VEC_S_L; -- "int:=vec(subrange)") 

INT_D_U:=VEC_D_U; 

INT_D_H:=VEC_D_H; -- assign vectors to integers 

INT_D_M:=VEC_D_M; 

INT_D_L:=VEC_D_L; 

INT_SUM_U:=(INT_S_U + INT_D_U) mod 256; -- then add the 

INT_SUM_H:=(INT_S_H + INT_D_H) mod 256; -- integers !! 

INT_SUM_M:=(INT_S_M + INT_D_M) mod 256; 

INT_SUM_L:=(INT_S_L + INT_D_L) mod 256; 

VEC_SUM_U:=INT_SUM_U mod 256; -- and back to 

VEC_SUM_H:=INT_SUM_H mod 256; -- vectors !! 

VEC_SUM_M:=INT_SUM_M mod 256; 

VEC_SUM_L:=INT_SUM_L mod 256; -- how silly !! 

case S(1 downto 0) is 

when "00" => -- dest:= source 

FST_D_DATA:=INV_S_DATA; 

when "01" => -- dest:= source OR dest. 

FST_D_DATA:=INV_S_DATA bor INV_D_DATA; 

when "10" => -- dest:= source XOR dest. 

FST_D_DATA:=INV_S_DATA bxor INV_D_DATA; 

when "11" => -- dest:= source PLUS dest. 

-- (4 times 8+8 bits for 

-- 8-bit-colormap or 24-bit RGB) 

FST_D_DATA(31 downto 24):=VEC_SUM_U; 

FST_D_DATA(23 downto 16):=VEC_SUM_H; 

FST_D_DATA(15 downto 08):=VEC_SUM_M; 

FST_D_DATA(07 downto 00):=VEC_SUM_L; 

end case; 

DEST_DATA:=FST_D_DATA when S(4)=’0’ else bnot FST_D_DATA; 

WRITE_DATA:=(DEST_DATA band PRE_MASK) 

-- relevant bits from buffer 

bor (DATA_OUT band (bnot PRE_MASK)); 

-- or relevant pre-read bits 

Abbildung 101: Speedchart-Diagramm TIM/CONTROL/MEM ACCESS/PIXBLT PATH 

Anhang D.2 

Seite 131



Lukas Bauer 

INTERRUPT 

T1 

entry 

S1 

T2 

Diplomarbeit 


A: if STAT_CLR=’1’ then 

R_STATUS:=lo8; -- clear R_STATUS 

-- after register read 

STAT_CLR:=’0’; 

INT_oe:=’0’; -- end INT pulse 

else 

if VINT_RQ=’1’ then -- vertical int.rq. 

R_STATUS(0):=’1’; 

if R_IMASK(0)=’1’ and R_IMASK(7)=’1’ then 

INT_oe:=’1’; 

end if; 

VINT_RQ:=’0’; 

end if; 

if HINT_RQ=’1’ then -- horizontal int.rq. 



INT_oe:=’1’; 

end if; 

HINT_RQ:=’0’; 

end if; 

if REFINT_RQ=’1’ then -- refresh int.rq. 



INT_oe:=’1’; 

end if; 

REFINT_RQ:=’0’; 

end if; 

if CINT_RQ=’1’ then -- clipping int.rq. 



INT_oe:=’1’; 

end if; 

CINT_RQ:=’0’; 

end if; 

if WINT_RQ=’1’ then -- window viol. int.rq. 



INT_oe:=’1’; 

end if; 

WINT_RQ:=’0’; 

end if; 

if RLEINT_RQ=’1’ then -- reload error int.rq. 



INT_oe:=’1’; 

end if; 

RLEINT_RQ:=’0’; 

end if; 

end if; 

Abbildung 102: Speedchart-Diagramm TIM/CONTROL/INTERRUPT 

Anhang D.2 

Seite 132



Lukas Bauer 

Diplomarbeit 



-- Variables of Diagram GR_CPU 

SADR_P_HI: integer:=0; -- 1st comp. of SYADR * R_SINC 

SADR_P_LO: integer:=0; -- 2nd comp. of SYADR * R_SINC 

SADR_P: integer:=0; -- (SYADR * R_SINC) + SXADR 

SY_P_HI: integer:=0; -- 1st comp. of (DY-1) * R_SINC 

SY_P_LO: integer:=0; -- 2nd comp. of (DY-1) * R_SINC 

SY_P: integer:=0; -- (DY-1) * R_SINC 

DADR_P_HI: integer:=0; -- 1st comp. of DYADR * R_DINC 

DADR_P_LO: integer:=0; -- 2nd comp. of DYADR * R_DINC 

DADR_P: integer:=0; -- (DYADR * R_DINC) + DXADR 

DY_P_HI: integer:=0; -- 1st comp. of (DY-1) * R_DINC 

DY_P_LO: integer:=0; -- 2nd comp. of (DY-1) * R_DINC 

DY_P: integer:=0; -- (DY-1) * R_DINC 

Anhang D.2 

Seite 133 

SADRL_L: integer:=0; -- source first line leftmost pixel 

SADRL_R: integer:=0; -- source first line rightmost pixel 

DADRL_L: integer:=0; -- dest. first line leftmost pixel 

DADRL_R: integer:=0; -- dest. first line rightmost pixel 

XS_viol: logic; -- window area violation X start 

XE_viol: logic; -- window area violation X end 

YS_viol: logic; -- window area violation Y start 

YE_viol: logic; -- window area violation Y end 

LINCNT: int16:=0; -- "lines left" counter for PixBLT 

constant C_FILL_L(8): logic:=0x21; 

constant C_FILL_XY(8): logic:=0x22; 

constant C_PixBLT_L(8): logic:=0x31; 

constant C_PixBLT_XY(8): logic:=0x32; 

constant C_CLIP(8): logic:=0x40; 

Abbildung 103: Variablen im Diagramm TIM/GR CPU



Lukas Bauer 

GP_CMD 

Entry of 

A: R_COMMAND:=0x00; 

C: CLIP’complete 

T3 

T2 

entry stdby 

CLIP 

T1 

Diplomarbeit 


C: R_COMMAND=C_CLIP 

C: PixBLT’complete 

T6 T8 

C: R_COMMAND=C_PixBLT_XY or 

R_COMMAND=C_PixBLT_L 

Abbildung 104: Speedchart-Diagramm TIM/GR CPU/GP CMD 

PixBLT 

Anhang D.2 

Seite 134

Abbildung 105: Speedchart-Diagramm TIM/GR CPU/GP CMD/CLIP 

CLIP 

entry 

T1 

S1 

T4 #1 

A: -- clip coordinates if necessary 

-- set WINT:=1 if coord’s were clipped 

if YS_viol=’1’ then 

R_DADR(31 downto 16):=R_WSTARTY; 

-- clip Y start 

if YE_viol=’1’ then 

R_DY:=(WENDY-WSTARTY+1) mod 65536; 

-- two side clip, new area height 

else 

R_DY:=(DY+DYADR-WSTARTY) mod 65536; 

-- Y start clip, adapt DY 

end if; 

WINT_RQ:=’1’; -- interrupt: wind. viol. 

elsif YE_viol=’1’ then 

R_DY:=(WENDY-DYADR) mod 65536; 

-- clip Y end only, new area height 


end if; 

if XS_viol=’1’ then 

R_DADR(15 downto 00):=R_WSTARTX; 

-- clip X start 

if XE_viol=’1’ then 

R_DX:=(WENDX-WSTARTX+1) mod 65536; 

-- two side clip, new area width 

else 

R_DX:=(DX+DXADR-WSTARTX) mod 65536; 

-- X start clip, adapt DX 

end if; 


elsif XE_viol=’1’ then 

R_DX:=(WENDX-DXADR) mod 65536; 

-- clip X end only, new area width 


end if; 

C: (DXADR > WENDX) or 

((DXADR+DX-1) < WSTARTX) or 

(DYADR > WENDY) or 

((DYADR+DY-1) < WSTARTY) 

A: CINT_RQ:=’1’; 

-- interrupt: window empty 

T5 #0 

S2 

T2 

A: -- convert DXADR/DYADR 

-- (X/Y dest. address) 

-- to R_DYADR 

-- (linear destination pixel address) 

R_DADR:=DADR_P; 

exit 


A: XS_viol:=’1’ when DXADR < WSTARTX else ’0’; 

XE_viol:=’1’ when (DXADR+DX-1) < WENDX else ’0’; 

YS_viol:=’1’ when DYADR < WSTARTY else ’0’; 

YE_viol:=’1’ when (DYADR+DY-1) < WENDY else ’0’; 



Lukas Bauer 

Diplomarbeit 


Anhang D.2 

Seite 135



Lukas Bauer 

PIXBLT 

C: LINCNT/=1 

A: LINCNT:=LINCNT-1; -- next line 

if PBV=’0’ then 

CL_SADRL_L:=CL_SADRL_L + SINC; 

CL_SADRL_R:=CL_SADRL_R + SINC; 

CL_DADRL_L:=CL_DADRL_L + DINC; 

CL_DADRL_R:=CL_DADRL_R + DINC; 

else 

CL_SADRL_L:=CL_SADRL_L - SINC; 

CL_SADRL_R:=CL_SADRL_R - SINC; 

CL_DADRL_L:=CL_DADRL_L - DINC; 

CL_DADRL_R:=CL_DADRL_R - DINC; 

end if; 

Diplomarbeit 


T8 #0 

C: GPU_READ=’0’ 

A: GPU_WRITE:=’1’; 

GPU_WNUM:=8; 

T1 

T3 

T6 

T2 

entry 

LINE 

read 

write 

Abbildung 106: Speedchart-Diagramm TIM/GR CPU/GP CMD/PIXBLT 

S1 

A: -- first line pixel addresses 

CL_SADRL_L:=SADRL_L; 

CL_SADRL_R:=SADRL_R; 

CL_DADRL_L:=DADRL_L; 

CL_DADRL_R:=DADRL_R; 

T4 

-- "lines left" counter 

LINCNT:=DY; 

A: if PBH=’0’ then 

SADRLW_C:=SADRLW_L; 

DADRLW_C:=DADRLW_L; 

T9 #1 

Anhang D.2 

Seite 136 

-- left to right 

GPU_FIFO_IN:=0 when SBOS_L>DBOS_L else 1; 

GPU_FIFO_OUT:=0; 

D_GPU_FIFO0:=lo32; 


GPU_RNUM:=9 when SBOS_L>DBOS_L else 8; 

else 

-- right to left 

SADRLW_C:=SADRLW_R; 

DADRLW_C:=DADRLW_R; 

GPU_FIFO_IN:=7 when SBOS_L>DBOS_L else 8; 

GPU_FIFO_OUT:=8; 

D_GPU_FIFO8:=lo32; 


GPU_RNUM:=9 when DBOS_L>SBOS_L else 8; 

end if; 

C: GPU_WNUM=0 

A: GPU_READ:=’1’; 

GPU_RNUM:=8; 

C: GPU_WNUM=15 -- end of line 

exit



Lukas Bauer 

SADR_SPLIT 


A: -- multiplication of SYADR and R_SINC: 

-- assume the bits a and b are set in R_SINC, 

-- then SADR_P_HI:= SYADR shl a; 

-- and SADR_P_LO:= SYADR shl b; 

-- 

-- SADR_P:= (SYADR * R_SINC) + SXADR; 

if R_SINC(15)=’1’ then 

SADR_P_HI:=SYADR shl 15; 

elsif R_SINC(14)=’1’ then 




























else 

SADR_P_HI:=SYADR; 

end if; 

Diplomarbeit 


if R_SINC(0)=’1’ and R_SINC/="0000000000000001" then 

SADR_P_LO:=SYADR; 

elsif R_SINC(1)=’1’ and R_SINC(15 downto 1)/="000000000000001" then 

SADR_P_LO:=SYADR shl 1; 



























else 

SADR_P_LO:=0; 

end if; 

SADR_P:=SADR_P_HI + SADR_P_LO + SXADR; 

Abbildung 107: Speedchart-Diagramm TIM/GR CPU/SADR SPLIT 

Anhang D.2 

Seite 137



Lukas Bauer 

DADR_SPLIT 


A: -- multiplication of DYADR and R_DINC: 

-- assume the bits a and b are set in R_DINC, 

-- then DADR_P_HI:= DYADR shl a; 

-- and DADR_P_LO:= DYADR shl b; 

-- 

-- DADR_P:= (DYADR * R_DINC) + DXADR; 

if R_DINC(15)=’1’ then 

DADR_P_HI:=DYADR shl 15; 

elsif R_DINC(14)=’1’ then 




























else 

DADR_P_HI:=DYADR; 

end if; 

Diplomarbeit 


if R_DINC(0)=’1’ and R_DINC/="0000000000000001" then 

DADR_P_LO:=DYADR; 

elsif R_DINC(1)=’1’ and R_DINC(15 downto 1)/="000000000000001" then 

DADR_P_LO:=DYADR shl 1; 



























else 

DADR_P_LO:=0; 

end if; 

DADR_P:=DADR_P_HI + DADR_P_LO + DXADR; 

Abbildung 108: Speedchart-Diagramm TIM/GR CPU/DADR SPLIT 

Anhang D.2 

Seite 138



Lukas Bauer 

SY_SPLIT 


A: -- multiplication of (DY-1) and R_SINC: 

-- assume the bits a and b are set in R_SINC, 

-- then SY_P_HI:= (DY-1) shl a; 

-- and SY_P_LO:= (DY-1) shl b; 

-- 

-- SY_P:=(DY-1) * R_SINC; 

if R_SINC(15)=’1’ then 

SY_P_HI:=(DY-1) shl 15; 





























else 

SY_P_HI:=(DY-1); 

end if; 

Diplomarbeit 


if R_SINC(0)=’1’ and R_SINC/="0000000000000001" then 

SY_P_LO:=(DY-1); 


SY_P_LO:=(DY-1) shl 1; 



























else 

SY_P_LO:=0; 

end if; 

SY_P:=SY_P_LO + SY_P_HI; 

Abbildung 109: Speedchart-Diagramm TIM/GR CPU/SY SPLIT 

Anhang D.2 

Seite 139



Lukas Bauer 

DY_SPLIT 


A: -- multiplication of (DY-1) and R_DINC: 

-- assume the bits a and b are set in R_DINC, 

-- then DY_P_HI:= (DY-1) shl a; 

-- and DY_P_LO:= (DY-1) shl b; 

-- 

-- DY_P:=(DY-1) * R_DINC; 

if R_DINC(15)=’1’ then 

DY_P_HI:=(DY-1) shl 15; 





























else 

DY_P_HI:=(DY-1); 

end if; 

Diplomarbeit 


if R_DINC(0)=’1’ and R_DINC/="0000000000000001" then 

DY_P_LO:=(DY-1); 


DY_P_LO:=(DY-1) shl 1; 



























else 

DY_P_LO:=0; 

end if; 

DY_P:=DY_P_LO + DY_P_HI; 

Abbildung 110: Speedchart-Diagramm TIM/GR CPU/DY SPLIT 

Anhang D.2 

Seite 140



Lukas Bauer 

AREA_TO_PIX 

Diplomarbeit 



V: THE_SADR: integer:=0; -- SADR or SADR_P 

THE_DADR: integer:=0; -- DADR or DADR_P 

A: if R_COMMAND(0)=’0’ then 

-- XY-addr. SXADR/SYADR and DXADR/DYADR 

-- to linear SADRL and DADRL 

-- (source/dest. pixel address) 

THE_SADR:=SADR_P; 

THE_DADR:=DADR_P; 

else 

-- linear addr. SADR and DADR (top left) 

-- to linear SADRL/DADRL (dep. on PBV) 

THE_SADR:=SADR; 

THE_DADR:=DADR; 

end if; 

-- SADRL_L/DADRL_L: first line, leftmost pixel 

-- SADRL_R/DADRL_R: first line, rightmost pixel 

-- (dependent on PBV: top line/bottom line) 

Anhang D.2 

Seite 141 

if PBV=’0’ then -- top 

SADRL_L:=THE_SADR; 

DADRL_L:=THE_DADR; -- left top 

SADRL_R:=THE_SADR + DX -1; 

DADRL_R:=THE_DADR + DX -1; -- right top 

else -- bottom 

SADRL_L:=THE_SADR + SY_P; 

DADRL_L:=THE_DADR + DY_P; -- left bottom 

SADRL_R:=THE_SADR + SY_P + DX -1; 

DADRL_R:=THE_DADR + DY_P + DX -1; -- right bottom 

end if; 

Abbildung 111: Speedchart-Diagramm TIM/GR CPU/AREA TO PIX



Lukas Bauer 

PIX_TO_BIT 


A: -- convert pixel addresses 

-- to longword addresses 

-- and bit offsets 

Diplomarbeit 


if R_PSIZE(5)=’1’ then -- 32 bit/pix 

SADRLW_L:=CL_SADRL_L + SSTLW; 

SADRLW_R:=CL_SADRL_R + SSTLW; 

DADRLW_L:=CL_DADRL_L + DSTLW; 

DADRLW_R:=CL_DADRL_R + DSTLW; 

SBOS_L:=0; 

SBOS_R:=31; 

DBOS_L:=0; 

DBOS_R:=31; 

elsif R_PSIZE(4)=’1’ then -- 16 bit/pix 

SADRLW_L:=(CL_SADRL_L shr 1) + SSTLW; 

SADRLW_R:=(CL_SADRL_R shr 1) + SSTLW; 

DADRLW_L:=(CL_DADRL_L shr 1) + DSTLW; 

DADRLW_R:=(CL_DADRL_R shr 1) + DSTLW; 

SBOS_L:=(CL_SADRL_L shl 4) mod 32; 

SBOS_R:=((CL_SADRL_R shl 4) mod 32) + 15; 

DBOS_L:=(CL_DADRL_L shl 4) mod 32; 

DBOS_R:=((CL_DADRL_R shl 4) mod 32) + 15; 




























else -- 1 bit/pix 





SBOS_L:=CL_SADRL_L mod 32; 

SBOS_R:=CL_SADRL_R mod 32; 

DBOS_L:=CL_DADRL_L mod 32; 

DBOS_R:=CL_DADRL_R mod 32; 

end if; 

Abbildung 112: Speedchart-Diagramm TIM/GR CPU/PIX TO BIT 

Anhang D.2 

Seite 142



Lukas Bauer 

REG_ALIAS 

entry 

S1 

T2 

T1 

A: SYADR :=R_SYADR; -- INT source addr. Y 

SXADR :=R_SXADR; -- INT source addr. X 

DYADR :=R_DYADR; -- INT dest. addr. Y 

DXADR :=R_DXADR; -- INT dest. addr. X 

SINC :=R_SINC; -- INT source increment 

DINC :=R_DINC; -- INT dest. increment 

SADR :=R_SSADR; -- INT source addr. 

DADR :=R_DSADR; -- INT dest. addr. 

WSTARTX :=R_WSTARTX; -- INT window start X 

WENDX :=R_WENDX; -- INT window end X 

WSTARTY :=R_WSTARTY; -- INT window start Y 

WENDY :=R_WENDY; -- INT window end Y 

DX :=R_DX; -- INT area width 

DY :=R_DY; -- INT area height 

SSTLW :=R_SSTLW; -- INT SSTART LW addr 

DSTLW :=R_DSTLW; -- INT DSTART LW addr 

-- Latching these signals is silly, they could 

-- be assigned in the asynchronous DP block, 

-- but it seems to be the only way of 

-- avoiding ASSERTION ERRORS using VHDL2000 

-- and of avoiding abortions of the Speedchart 

-- simulation. 

Diplomarbeit 


Abbildung 113: Speedchart-Diagramm TIM/REG ALIAS 


A: -- aliases for register bits 

Anhang D.2 

Seite 143 

R_VEN :=R_CONFIG(31); -- video enable 

R_ILE :=R_CONFIG(30); -- interlaced enable 

R_RLE :=R_CONFIG(29); -- reload enable 

R_SRE :=R_CONFIG(28); -- split reload enable 

R_VCE :=R_CONFIG(27); -- video capture enable 

R_CSD :=R_CONFIG(26); -- composite sync direction 

R_HSD :=R_CONFIG(25); -- horizontal sync direction 

R_VSD :=R_CONFIG(24); -- vertical sync direction 

R_TEST :=R_CONFIG(23); -- test 16 bit counters 

CWAIT :=R_CONFIG(22); -- CAS delay 1/2 MClk 

SADJ :=R_CONFIG(21 downto 20); -- MSC adjust 

TADJ :=R_CONFIG(19 downto 18); -- MTR adjust 

LDADJ :=R_CONFIG(17 downto 16); -- LD adjust 

LOCK :=R_CONFIG(15); -- lock configuration 

R_RF :=R_CONFIG(14 downto 12); -- refresh rate 

R_SRL :=R_CONFIG(11 downto 10); -- shift register length 

MBW :=R_CONFIG(09 downto 08); -- memory bus width 

NUBUS :=R_CONFIG(07); -- NUBUS byte order 

FASTRDY :=R_CONFIG(06); -- fast handshake mode 

RMMX :=R_CONFIG(03); -- A1,A0 mapping (RCA13,12/1,0) 

RCAADJ :=R_CONFIG(02); -- RCA delay 1/2 MClk 

HBW :=R_CONFIG(01 downto 00); -- host bus width 

MO_D :=R_MUXOFF(13 downto 11); -- RAS address skew RAS(3) 

MO_C :=R_MUXOFF(10 downto 08); -- RAS address skew RAS(2) 

RTO :=R_MUXOFF(07 downto 06); -- RAS timeout 

MO_B :=R_MUXOFF(05 downto 03); -- RAS address skew RAS(1) 

MO_A :=R_MUXOFF(02 downto 00); -- RAS address skew RAS(0) 

ACS :=R_AUXREG(7 downto 4); -- AUX port/cs select 

AUX :=R_AUXREG(3 downto 0); -- AUX port data 

ASL :=R_RADSEL(6 downto 4); -- ACS address bits 

PEN :=R_RADSEL(3); -- page mode enable 

RSL :=R_RADSEL(2 downto 0); -- RAS bank select address bits 

BMS :=R_PATTNSIZE(4); -- bit map size 

PTS :=R_PATTNSIZE(1 downto 0); -- pattern size 

R_YZ :=R_XYZOOM(6 downto 4); -- zoom factor Y 

R_XZ :=R_XYZOOM(2 downto 0); -- zoom factor X 

PBV :=R_COMCTRL(6); -- PixBlt vertical direction 

PBH :=R_COMCTRL(5); -- PixBlt horizontal direction 

S :=R_COMCTRL(4 downto 0); -- PixBlt control bits 

R_SYADR :=R_SADR(31 downto 16); -- source address Y component 

R_SXADR :=R_SADR(15 downto 00); -- source address X component 

R_SSADR :=R_SADR(30 downto 00); -- source address 31 bit 

R_DYADR :=R_DADR(31 downto 16); -- dest. address Y component 

R_DXADR :=R_DADR(15 downto 00); -- dest. address X component 

R_DSADR :=R_DADR(30 downto 00); -- dest. address 31 bit 

R_SSTLW :=R_SSTART(31 downto 5); -- SSTART LW address 

R_DSTLW :=R_DSTART(31 downto 5); -- DSTART LW address



Lukas Bauer 

ASYNC_ACT 


A: -- asynchronous delays 

Diplomarbeit 


MSC_del0:=’1’ when SADJ="00" else ’0’; 




MTR_del0:=’1’ when TADJ="00" else ’0’; 




LD_del0 :=’1’ when LDADJ="00" else ’0’; 





R_CONF_out :=R_CONFIG; 

R_4_out :=R_4; 

MBW_ot :=MBW; 

HBW_ot :=HBW; 

PATTN_ot :=PATTN; 

ADin_ot :=AD_in; 

ASin_ot :=AS_in; 

DSin_ot :=DS_in; 

BSin_ot :=BS_in; 

RSin_ot :=RS_in; 

HWEin_ot :=HWE_in; 

Rdyout_ot :=Rdy_out; 

-- RAM interface 

RCA_out :=RCA_ict; 

RAS_out :=RAS_ict; 

CAS_out :=CAS_ict; 

MD_out :=D_ict; 

MWE_out :=MWE_ict; 

MOE_out :=MOE_ict; 

MD_oe :=DOE_ict; 

ACS_out(3):=AUX(3) when ACS(3)=’1’ -- out port 

else ACS_ict(3); -- aux. CS 







Abbildung 114: Speedchart-Diagramm TIM/ASYNC ACT 

Anhang D.2 

Seite 144

Abbildung 115: Schreib- und Lesezugriffe (Host – Speicher) bei 32 Bit Speicherbusbreite 

0s 

0s 

/pattn_ot 

/pattn_othex 

/hbw_ot /hbw_othex 

/mbw_ot /mbw_othex 

/adin_ot /adin_othex 

/bsin_ot /bsin_othex 

/rsin_ot /rsin_ota0 

a0 

/hwein_ot 

/hwein_ota1 

a1 

/asin_ot /asin_ota1 

a1 

/dsin_ot /dsin_ota1 

a1 

/rdyout_ot 

/rdyout_ota1 

a1 

/ad_oe(0) a0 a0 

/ad_out /ad_outhex 

/rca_out /rca_outhex 

/ras_out /ras_outhex 

/cas_out /cas_outhex 

/mwe_out /mwe_outa1 

a1 

/moe_out /moe_outa1 

a1 

/md_oe(0) a0 a0 

/md_out /md_outhex 

/md_in /md_inhex 

/mclk_in /mclk_ina1 

a1 

/fifoin_ot 

/fifoin_othex 

/fifoout_ot 

/fifoout_othex 

VHDL 2000 

23456789 ffffffff 1bcdef01 ffffffff 23456789 ffffffff 77775680 

0 3 b 5 

4 

3 

3 

56785678 12345678 

3fff 0123 2115 3fff 0123 2116 3fff 2eee 15a0 3fff 2eee 15a0 3fff 

f e f e f 7 f 7 f 

f 0 f 3 f b f 5 f 

24680000 23456789 1bcdef01 23456789 00000000 

12345678 

2 3 4 5 

2 3 4 5 

23.6us 23.65us 23.7us 23.75us 23.8us 23.85us 23.9us 23.95us 24us 24.05us 24.1us 24.15us 24.2us 24.25us 24.3us 



Lukas Bauer 

Diplomarbeit 


Anhang D.3 

Seite 145

Abbildung 116: Schreib- und Lesezugriffe (Host – Speicher) bei 32 Bit Speicherbusbreite im Fast Page Mode 

0s 

0s 

/pattn_ot 

/pattn_othex 






a0 

/hwein_ot 

/hwein_ota1 

a1 


a1 


a1 

/rdyout_ot 

/rdyout_ota1 

a1 

/ad_oe(0) a0 a0 






a1 


a1 

/md_oe(0) a0 a0 




a1 

/fifoin_ot 

/fifoin_othex 

/fifoout_ot 


VHDL 2000 

23456789 ffffffff 1bcdef01 ffffffff 23456789 ffffffff 77775680 

0 3 b 5 

5 

3 

3 

12345678 

3fff 0123 2115 3fff 2116 3fff 2eee 15a0 3fff 15a0 3fff 

f e f 7 

f 0 f 3 f b f 5 f 

00000000 23456789 1bcdef01 23456789 00000000 

12345678 

5 6 7 0 

5 6 7 0 

26.4us 26.45us 26.5us 26.55us 26.6us 26.65us 26.7us 26.75us 26.8us 26.85us 26.9us 26.95us 27us 27.05us 27.1us 



Lukas Bauer 

Diplomarbeit 


Anhang D.3 

Seite 146

Abbildung 117: Schreib- und Lesezugriffe (Host – Speicher) bei 8 Bit Speicherbusbreite 

0s 

0s 

/pattn_ot 

/pattn_othex 






a0 

/hwein_ot 

/hwein_ota1 

a1 


a1 


a1 

/rdyout_ot 

/rdyout_ota1 

a1 

/ad_oe(0) a0 a0 






a1 


a1 

/md_oe(0) a0 a0 




a1 

/fifoin_ot 

/fifoin_othex 

/fifoout_ot 


VHDL 2000 

77775680 

0 3 b 5 

1 

3 

0 

12345678 78345678 

3fff 0454 0455 0456 0457 0458 0459 1681 1680 1682 3fff 

f e f e f e f e f e f e f 7 f 7 f 7 f 

f e f e f e f e f e f e f e f e f e f 

2468acf0 2468ac23 2468ac45 2468ac67 2468ac89 2468ac1b 2468accd 2468ac45 2468ac00 

12345678 

0 1 2 3 

0 1 2 3 

13.9us 14us 14.1us 14.2us 14.3us 14.4us 14.5us 14.6us 14.7us 14.8us 14.9us 15us 15.1us 15.2us 



Lukas Bauer 

Diplomarbeit 


Anhang D.3 

Seite 147

Abbildung 118: Schreib- und Lesezugriffe (Host – Speicher) bei 8 Bit Speicherbusbreite im Fast Page Mode 

0s 

0s 

/pattn_ot 

/pattn_othex 






a0 

/hwein_ot 

/hwein_ota1 

a1 


a1 


a1 

/rdyout_ot 

/rdyout_ota1 

a1 

/ad_oe(0) a0 a0 






a1 


a1 

/md_oe(0) a0 a0 




a1 

/fifoin_ot 

/fifoin_othex 

/fifoout_ot 


VHDL 2000 

ffffffff 77775680 

0 3 b 5 

2 

3 

0 

78347878 

3fff 0123 0454 0455 0456 0457 0458 0459 2eee 1681 1680 1682 3fff 

f e f 7 

f e f e f e f e f e f e f e f e f e f 

2468ac00 2468accd 2468ac45 2468ac00 

12345678 

3 4 5 6 

3 4 5 6 

17.2us 17.3us 17.4us 17.5us 17.6us 17.7us 17.8us 17.9us 18us 18.1us 



Lukas Bauer 

Diplomarbeit 


Anhang D.3 

Seite 148

Abbildung 119: Speicherzugriffe beim PixBlT-Befehl, 3 Zeilen zu 104 Pixeln à 1 Bit, ” Ziel=Quelle“, PBH=PBV=’0’ 

0s 

0s 

/pattn_ot 

/pattn_othex 






a0 

/hwein_ot 

/hwein_ota1 

a1 


a1 


a1 

/rdyout_ot 

/rdyout_ota1 

a1 

/ad_oe(0) a0 a0 






a1 


a1 

/md_oe(0) a0 a0 



/any_cycle_ot 

/any_cycle_ota0 

a0 

/mem_gread_ot 

/mem_gread_ota0 

a0 

/gpu_rnum_ot 

/gpu_rnum_othex 

/mem_gwrite_ot 

/mem_gwrite_ota0 

a0 

/gpu_wnum_ot 

/gpu_wnum_othex 

/pre_read_ot 

/pre_read_ota0 

a0 

/cas_mask_ot 

/cas_mask_othex 

/pre_mask_ot 

/pre_mask_othex 


a1 

VHDL 2000 

f 

3 

3 

ffffffff 

e 

00000000 12345678 

3fff 0249 024c 0259 0269 026c 3fff 

f e f e f e f e f e f e 

f c 0 0 0 f 0 0 0 3 f c 0 0 0 f 8 0 0 1 f e 0 0 0 7 f c 0 0 0 f 

00000000 45645678 00000000 00000000 23456780 

12345678 

0 9 8 7 6 f 9 8 7 6 f 9 8 7 6 5 f 

0 8 7 6 5 f 8 7 6 5 f 8 7 6 5 f 

0 c f f f f 0 f 0 f f f 3 c f f f f 8 f 8 f f f 1 e f f f f f c f c f f f 0 

ffffffff fffc0000 fffffc00 fffffffc 

1.6us 1.8us 2us 2.2us 2.4us 2.6us 2.8us 3us 3.2us 3.4us 3.6us 3.8us 4us 4.2us 



Lukas Bauer 

Diplomarbeit 


Anhang D.3 

Seite 149

Abbildung 120: Speicherzugriffe beim PixBlT-Befehl, 3 Zeilen zu 104 Pixeln à 1 Bit, Ziel=Quelle“, PBH=PBV=’0’, 

” 

Ausschnitt: erste Zeile gemäß Abbildung 34 (S. 50) 

0s 

0s 

/pattn_ot 

/pattn_othex 






a0 

/hwein_ot 

/hwein_ota1 

a1 


a1 


a1 

/rdyout_ot 

/rdyout_ota1 

a1 

/ad_oe(0) a0 a0 






a1 


a1 

/md_oe(0) a0 a0 



/any_cycle_ot 


a0 

/mem_gread_ot 


a0 

/gpu_rnum_ot 




a0 

/gpu_wnum_ot 


/pre_read_ot 


a0 

/cas_mask_ot 


/pre_mask_ot 



a1 

VHDL 2000 

00000032 ffffffff 

0 e 

00000000 12345678 

f 

3 

3 

3fff 0004 00c3 00c4 00c5 00c6 3fff 0008 0249 024a 024b 024c 3fff 

f e f e f 

f c f 0 f 0 f 0 f 0 f 0 f 0 f 3 f 

ffffffff 00000000 11678123 45678123 45645678 

12345678 

0 9 8 7 6 f 9 

0 8 7 6 5 f 

0 c f 0 f 0 f 0 f 0 f 0 f 0 f 3 f 3 c 

ffffffff 03ffffff ffffffff fffc0000 

1.6us 1.7us 1.8us 1.9us 2us 2.1us 2.2us 2.3us 2.4us 2.5us 



Lukas Bauer 

Diplomarbeit 


Anhang D.3 

Seite 150

Abbildung 121: Speicherzugriffe beim PixBlT-Befehl, 

2 Zeilen zu 13 Pixeln à 32 Bit, Ziel=Quelle + Ziel“, PBH=PBV=’1’ 

” 

Ausschnitt: Kopiervorgang bei der ersten Zeile 

0s 

0s 

/pattn_ot 

/pattn_othex 






a0 

/hwein_ot 

/hwein_ota1 

a1 


a1 


a1 

/rdyout_ot 

/rdyout_ota1 

a1 

/ad_oe(0) a0 a0 






a1 


a1 

/md_oe(0) a0 a0 



/any_cycle_ot 


a0 

/mem_gread_ot 


a0 

/gpu_rnum_ot 




a0 

/gpu_wnum_ot 


/pre_read_ot 


a0 

/cas_mask_ot 


/pre_mask_ot 



a1 

VHDL 2000 

0 

3 

3 

ffffffff 

c 

12345678 

3fff 0b3a 0b39 0b38 0b37 0b36 0b35 0b34 0b33 0b32 0b31 0b30 0b2f 0b2e 

e e e e f e 

f 0 0 0 0 0 0 f 0 0 0 0 0 0 0 0 f 0 0 0 0 f 0 0 0 0 0 f 

00000000 2468acf0 00000000 2468acf0 

12345678 

f 8 7 6 5 4 3 2 1 0 8 7 6 5 4 f 8 

f 8 7 6 5 4 3 2 1 0 8 7 6 5 4 f 

0 f f f f f f 0 f 0 f 0 f 0 f 0 f 0 f 0 f 0 0 f f f 0 0 0 0 0 0 

fffffffc ffffffff 

6.2us 6.4us 6.6us 6.8us 7us 7.2us 7.4us 7.6us 7.8us 8us 8.2us 8.4us 8.6us 8.8us 9us 



Lukas Bauer 

Diplomarbeit 


Anhang D.3 

Seite 151

Ausschnitt: Lese- und RMW-Sequenz am Ende der ersten Zeile 

Abbildung 122: Speicherzugriffe beim PixBlT-Befehl, 

2 Zeilen zu 13 Pixeln à 32 Bit, ” Ziel=Quelle + Ziel“, PBH=PBV=’1’ 

0s 

0s 

/pattn_ot 

/pattn_othex 






a0 

/hwein_ot 

/hwein_ota1 

a1 


a1 


a1 

/rdyout_ot 

/rdyout_ota1 

a1 

/ad_oe(0) a0 a0 






a1 


a1 

/md_oe(0) a0 a0 



/any_cycle_ot 


a0 

/mem_gread_ot 


a0 

/gpu_rnum_ot 




a0 

/gpu_wnum_ot 


/pre_read_ot 


a0 

/cas_mask_ot 


/pre_mask_ot 



a1 

VHDL 2000 

0 

3 

3 

ffffffff 

c 

12345678 

197a 1979 1978 1977 1976 0b32 0b31 0b30 0b2f 0b2e 3fff 

e f e f e f 

0 f 0 f 0 f 0 f 0 f 0 f 0 f 0 f 0 f 0 f 0 f 

2468acf0 00000000 2468acf0 

12345678 

0 8 7 6 5 4 f 8 

0 8 7 6 5 4 f 

0 f 0 f 0 f 0 f 0 f 0 f 0 f 0 f 0 f 0 f 0 

ffffffff 

8us 8.1us 8.2us 8.3us 8.4us 8.5us 8.6us 8.7us 8.8us 8.9us 9us 9.1us 



Lukas Bauer 

Diplomarbeit 


Anhang D.3 

Seite 152

DIPLOMARBEIT - FG Mikroelektronik, TU Berlin

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?