XX XX XXXXXX XXXXXX XXXXX XXXXX XXXXX XX XXX XXX XX XX XX XX XX XX XX XX XXX XX XX XX XX XX XX XX XX XX XX XX XXXX XX XX XX XXXXXXX XXXXX XXXXX XXXXX XX   XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XXXXXX XXXXXX XXXXX XXXXX XXXXX XX Eine kurze Einführung in Aufbau und Funktion der FPU MC68881/2 Inhalt: Einführung ~~~~~~~ Hardware-Überblick Interface zum MC68020/030 Interface zum MC68000/010 Register-Map des MC68881 Standard-Coprozessor Interface Unterstützte Floating Point Formate FPU-Befehle Ablauf einer FPU-Operation Die MathIEEE.resource Mathematische Operationen Beispiele Copyrights _ _ _ _ _ _ _ _ _ // // // // // // // // // _ // _ // _ // _ // _ // _ // _ // _ // _ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\// \\// \\// \\// \\// \\// \\// \\// \\// ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ Einführung: ~~~~~~~~~~~ Für die Angaben in diesem Text, übernehme ich keinerlei Garantie für Richtigkeit, Vollständigkeit oder Brauchbarkeit. Weiterhin lehne ich jede Verantwortung für Schäden jedwelcher Art ab, die auf fehlerhafte Angaben oder auf falsche Interpretation dieses Textes zurückzuführen sind. Dieser Text stellt lediglich eine oberflächliche Beschreibung des MC68881 dar, wobei aber weniger die Oberfläche des Chips, sondern die Software das Thema sein soll. Dabei gehe ich nur kurz auf die Kombination der FPU mit einem 68020/030 ein. Im wesentlichen soll dargestellt werden, wie die FPU mit einem 68000/010 genutzt werden kann. Diese Kombination erreicht natürlich nicht die gleiche Leistungsfähigkeit, allerdings macht sich der Einsatz der FPU bei rechenintensiven Programmen trotzdem stark bemerkbar. Die FPU wird von den MathIEEE.libraries automatisch unterstützt. Der größte Geschwindigkeitszuwachs läßt sich allerdings bei direkter Program- mierung der Hardware erzielen. Ein MC68881 hat eine Rechenleistung von 0.044 (Minimum) bis 0.5 MFLOPS (Maximum) bei 25 MHz Taktfrequenz. Für den MC68882 kann bei geschickter Programmierung, etwa die doppelte Rechenleistung angenommen werden. Diese Zahlen halten sicherlich keinem Vergleich mit (wesentlich teureren) Work- stations stand. Im Vergleich mit FPUs, die man 'inside' anderer Computer findet, sieht der 68881/2 aber nicht schlecht aus. Die Berechnung eines Arcus-Sin beispielsweise, benötigt mit dem 68881 ca. 22.56 µSec. Andere FPUs bringen es dabei leicht auf mehr als 250 µSec bei gleicher Takt- frequenz ! _ _ _ _ _ _ _ _ _ // // // // // // // // // _ // _ // _ // _ // _ // _ // _ // _ // _ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\// \\// \\// \\// \\// \\// \\// \\// \\// ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ Hardware-Überblick: ~~~~~~~~~~~~~~~~~~~ Ich bin sicher, daß niemand wissen will, welcher Pin an diesem Baustein welche Funktion hat. Das interessiert sicherlich nur die Hardwarefreaks. Aber die brauchen dieses Dok eh nicht lesen. Wie ich schon sagte, will ich nur einen kurzen Überblick über die grundsätzlichen Aufbau geben. Daher habe ich die Leitungen in Funktionsgruppen zusammengefaßt. Der Schrägstrich "/" deutet an, daß die entsprechenden Leitungen 'Low-Active' sind. Adressleitungen : A0-A4 Datenleitungen : D0-D31 Steuerleitungen : /CS (in: Chip-Select) /AS (in: Address-strobe) /DS (in: Data-strobe) R-/W (in: Read-Write) SIZE (in:) /DSACK0 (out: Data-Strobe-Acknowledge 0) /DSACK1 (out: Data-Strobe-Acknowledge 1) /RESET (in:) Wie an dieser Aufstellung zu erkennen ist, besitzt die FPU alle An- schlüsse, die jeder Periferie-Baustein besitzen muß. Daher ist es auch möglich, die FPU mit allen MPUs der 68k-Line zu kombinieren. _ _ _ _ _ _ _ _ _ // // // // // // // // // _ // _ // _ // _ // _ // _ // _ // _ // _ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\// \\// \\// \\// \\// \\// \\// \\// \\// ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ Interface zum 68020/68030: ~~~~~~~~~~~~~~~~~~~~~~~~~~ Die Schnittstelle zur FPU ist nicht, wie man vielleicht vermuten könnte, hardware-mäßig, sondern durch Software realisiert. Der 020/030 hat die notwendige Software als Microcode 'on-chip', braucht also kein externes Steuerprogramm, um die FPU anzusprechen. Jeder FPU-Befehl ist ein 16 Bit Wort. Daran anschließend folgen weitere Parameter, falls diese für die Operation benötigt werden. Ein FPU-Befehl beginnt immer mit $F ($Fxxx). Bei einem MC68000/010 führt dieses zu einer Line-F-exeption (Guru-Meditation). Bei den 020/030-CPUs wird zunächst ein Erkennungszyklus eingeleitet : - die Function-Code Leitungen werden auf '1' gesetzt. - die Adressleitungen A5-A12 sowie A20-A31 werden auf '0' gesetzt. - die Adressleitungen A16-A19 bestimmen den Typ des Zugriffs - die Adressleitungen A13-A15 bestimmen den angesprochenen Coprozessor. Auf die gleiche Weise wird auch auf eine MMU zugegriffen, wobei dann die Adressleitungen A13-A15 ein anderes Bitmuster haben. Für den Zugriff auf die FPU, sieht der Adressbus etwa folgendermaßen aus: A31 -------------------- A19 - A16 A15 - A13 A12 ----------- A4 -- A1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 x x x x ------- ------- ------- Die Adressen A4-A1 sind direkt mit der FPU verbunden, und bestimmen das FPU-Register. Mit Hilfe des Function-Codes, den Adressen A19-A16 und A15-A13, kann eine externe Decoderschaltung erkennen, daß die FPU angesprochen werden soll. Daraufhin wird die Chip-Select-Leitung aktiviert. Falls von der FPU keine Antwort erfolgt, bricht der 020/030 den Zugriff ab und springt über den 'Line-F-Trap' Vektor. _ _ _ _ _ _ _ _ _ // // // // // // // // // _ // _ // _ // _ // _ // _ // _ // _ // _ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\// \\// \\// \\// \\// \\// \\// \\// \\// ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ Interface zum 68000/68010: ~~~~~~~~~~~~~~~~~~~~~~~~~~ Der 68000 besitzt keine 'on-chip'-Software, um einen Coprozessor zu steuern. Daher benötigt der 68000 ein externes Steuerprogramm, um die FPU anzusprechen. Weiterhin muß die FPU jetzt an einer Speicheradresse einge- belendet werden, damit die CPU überhaupt auf den Chip zugreifen kann. Wie schon beschrieben, erfüllt die FPU alle Forderungen, um als Periferie- Baustein eingesetzt zu werden. Die CPU kann den Chip dann genauso adres- sieren, wie z.B. die CIAs. Die IEEE.libs enthalten bereits die notwendigen Maschinenprogramme, für das Interface-Protokol. Eine weitere Möglichkeit besteht in der direkten Programmierung der FPU, wofür man allerdings auf Assembler zurückgreifen sollte. Weiterhin kann man die Steuerung über eine Line-F Emulation implementieren. Diese Möglichkeit bedeutet allerdings einen erheblichen Overhead, der mit einem gewissem Geschwindigkeitsverlust verbunden ist. _ _ _ _ _ _ _ _ _ // // // // // // // // // _ // _ // _ // _ // _ // _ // _ // _ // _ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\// \\// \\// \\// \\// \\// \\// \\// \\// ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ Register-Map des 68881: ~~~~~~~~~~~~~~~~~~~~~~~ Die FPU besitzt ebenso wie die CPU verschiedene Register. Bits 79 --------------------------------------------------- 0 1. --------------------- fpr 0 ----------------------- 2. --------------------- fpr 1 ----------------------- 3. --------------------- fpr 2 ----------------------- 4. --------------------- fpr 3 ----------------------- 5. --------------------- fpr 4 ----------------------- 6. --------------------- fpr 5 ----------------------- 7. --------------------- fpr 6 ----------------------- 8. --------------------- fpr 7 ----------------------- 31 ------ 23 ------ 15 ------ 7 ------ 0 FP-Status FCCR ** (1) (2) FP-Control ** ** (3) (3) FP-IAddr -------- Instruction-addr. -------- (1) Exeption-Mask (nicht mit 68000) (2) Accured Exeption (nicht mit 68000) (3) Weiß ich nicht (*) Unbelegt Mnemonic : Beschreibung : Datenbreite ---------:-------------------------:------------ FP0 : Fließkomma-Register 0 : 80 Bit FP1 : Fließkomma-Register 1 : 80 Bit FP2 : Fließkomma-Register 2 : 80 Bit FP3 : Fließkomma-Register 3 : 80 Bit FP4 : Fließkomma-Register 4 : 80 Bit FP5 : Fließkomma-Register 5 : 80 Bit FP6 : Fließkomma-Register 6 : 80 Bit FP7 : Fließkomma-Register 7 : 80 Bit FPSTATUS : Status-Register : 32 Bit FPCONTROL: Control-Register : 16 Bit FPIADDR : Fp-Befehlsadresse : 32 Bit Die letzten drei Register sind nur in Verbindung mit einem 020/030 inter- essant, da ihre Auswertung keine Informationen ergibt, die mit einem 000/ 010 sinnvoll wären (hier kann ich mich aber gewaltig irren !) Wie erkennbar ist, besitzen die FPx-Register eine Datenbreite von 80 Bit. Bei jeder Berechnung werden alle Bits benutzt, um ein möglichst genaues Ergebnis zu erzielen. Die Auflösung beträgt 19 Dezimalstellen ! _ _ _ _ _ _ _ _ _ // // // // // // // // // _ // _ // _ // _ // _ // _ // _ // _ // _ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\// \\// \\// \\// \\// \\// \\// \\// \\// ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ Standard Coprocessor-Interface: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Motorola hat ein Standard-Interface für Coprozessoren der 68K-Serie festgelegt. Dieses Interface wird momentan für FPUs und MMUs benutzt. Daher erscheinen die zuvor beschriebenen Register leider nicht auf dem CPU-Bus. Um die Register lesen oder beschreiben zu können, muß man zunächst einen Umweg über ein sogenanntes Coprozessor-Interface gehen. Für die CPU sieht der Coprozessor folgendermaßen aus: Adresse : Name : Datenbreite $00 : Control : 16 Bit $02 : Response : 16 Bit $04 : Restore : 16 Bit $06 : Save : 16 Bit $08 : Command : 16 Bit $0A : Operation : 16 Bit $0C : Condition : 16 Bit $0E : reserved : $10 : Operand : 32 Bit $14 : reserved : $16 : Register-Select : 16 Bit $18 : Instruction-Addr: 32 Bit $1C : Operand-Addr. : 32 Bit baseaddr. bits 31------------16 15------------0 +$00 .--- Control --. .-- Response -. +$04 .--- Restore --. .---- Save ---. +$08 .--- Command --. .- Operation -. +$0C .-- Condition -. .- (reserved) . +$10 .------------ Operand ----------. +$14 .- (reserved) -. . Reg. Select . +$18 .------ Instruction Address ----. +$1C .-------- Operand Address ------. Leider kann ich nicht für jedes Register angeben, welche Funktionen damit verbunden sind. Im wesentlichen werden jedoch nur drei (vier) Register für eine Emulation mit einem 68000 benötigt: (Control), Response, Operation, Operand. _ _ _ _ _ _ _ _ _ // // // // // // // // // _ // _ // _ // _ // _ // _ // _ // _ // _ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\// \\// \\// \\// \\// \\// \\// \\// \\// ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ Unterstützte Floating-Point Formate ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Intern rechnet die FPU immer mit 80 Bit IEEE-floating point Zahlen nach dem IEEE-Standard V 10.0. Beim Schreiben oder Lesen sind jedoch auch andere Eingabe-/Ausgabeformate möglich. Weiterhin kann jede Operation mit gemischten Datentypen ausgeführt werden. Die FPU untersützt folgende Formate: SIZE | FORMAT | SIGN | EXPONENT | MANTISSE | TOTAL --------+----------+------+----------+----------+------ Byte | INT | 1 | -- | (7) | 8 Word | INT | 1 | -- | (15) | 16 Long | INT | 1 | -- | (31) | 32 Single | FLOAT | 1 | 8 | 23 | 32 Double | FLOAT | 1 | 11 | 52 | 64 Extended| FLOAT | 1 | 15 | 64 | 80 Pack BCD| BCD | * | * | * | 96 Format der Packed BCD Zahlen: ---+---------+---------+---------+---------- |0 | m s y y | E X P 2 | E X P 1 | E X P 0 | |1 | x x x x | x x x x | x x x x | M A 1 6 |.(angenommener Dez.-Punkt) |2 | M A 1 5 | M A 1 4 | M A 1 3 | M A 1 2 | |3 | M A 1 1 | M A 1 0 | M A 0 9 | M A 0 8 | |4 | M A 0 7 | M A 0 6 | M A 0 5 | M A 0 4 | |5 | M A 0 3 | M A 0 2 | M A 0 1 | M A 0 0 | ---+---------+---------+---------+---------- m -> Vorzeichen der Mantisse s -> Vorzeichen des Exponenten y -> unbenutzt EXPx -> Exponent x -> unbenutzt (wird bei der Eingabe ignoriert, bei Ausgabe immer 0) MAxx -> Mantisse, jede Stelle repräsentiert eine Zahl von 0-9. _ _ _ _ _ _ _ _ _ // // // // // // // // // _ // _ // _ // _ // _ // _ // _ // _ // _ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\// \\// \\// \\// \\// \\// \\// \\// \\// ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ FPU-Befehle: ~~~~~~~~~~~~ Die Beschreibung der FPU-Befehle bezieht sich nur auf den Betrieb mit einem 68000. FPU-Opcodes, wie sie mit einem 68020 zu finden sind, haben einen teilweise grundlegend anderen Aufbau. Die hier beschriebenen Befehle werden von der CPU (020) natürlich in gleicher Weise gebildet, was für den Anwender allerdings transparent ist. Die FPU-Operationen kann man in zwei Gruppen einteilen: 1. Operationen mit externen Operanden (Mode 1). Wie angedeutet, MUSS das Ziel (Operand 2) immer ein FPU-Register sein. Der erste Operand kann aber in einem beliebig festlegbaren Datenformat extern bereitgestellt werden. Dieser externe Operand ist (beim 68000) immer ein CPU-Register. 2. Interne Operationen (Mode 2). Darunter verstehe ich Operationen, die vollständig in der FPU ablaufen, wie beispielsweise, das Addieren zweier Register. Die Befehlsworte sind 16 Bit breit und sind in Bitfelder eingeteilt. bit | 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00 -------+------------------------------------------------------ mode 1 | ?? 01 io f2 f1 f0 d2 d1 d0 ?? o5 o4 o3 o2 o1 o0 mode 2 | ?? 00 00 s2 s1 s0 d2 d1 d0 ?? o5 o4 o3 o2 o1 o0 Mode 1: Der erste Operand wird extern angefordert Der zweite Operand ist ein FPU-Register io = 0 -> die Quelle ist extern, das Ziel ist intern 1 -> die Quelle ist intern, das Ziel ist extern (nur für FMOVE !) f2 - f0 : Format des externen Operanden f2 f1 f0 Type Bits --+--+--+-----------------+---- 0 0 0 long integer 32 0 0 1 single float 32 0 1 0 extended float 80 0 1 1 BCD 96 1 0 0 word integer 16 1 0 1 double float 64 1 1 0 byte integer 8 1 1 1 ??? d2 - d0 : Ziel FP-Register Der Wert in diesen Bits (0-7) ist die Nummer des gewünschten FP-Registers, mit dem die Operation ausgeführt werden soll. Für FMOVE bezeichnet dieser Wert, die Nummer des FP- Registers, dessen Inhalt ausgelesen werden soll. o5 - o0 : Operation Das Bitmuster steht für die gewünschte Berechnung (+,-,*...) (siehe unten) Mode 2: Beide Operanden sind bereits in den FP-Registern enthalten. io = 0 -> Das io-Bit ist immer NULL. s2 - s0 : Quell FP-Register Der Wert dieser Bits (0-7) bestimmt den Quelloperanden der Berechnung. d2 - d0 : Ziel FP-Register Der Wert dieser Bits (0-7) bestimmt den Zieloperanden der Berechnung. o5 - o0 : Operation Das Bitmuster steht für die gewünschte Berechnung (+,-,*...) (siehe unten) ?? : Die Funktion der so gekennzeichneten Bits ist mir leider nicht bekannt _ _ _ _ _ _ _ _ _ // // // // // // // // // _ // _ // _ // _ // _ // _ // _ // _ // _ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\// \\// \\// \\// \\// \\// \\// \\// \\// ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ Ablauf einer FPU-Operation: ~~~~~~~~~~~~~~~~~~~~~~~~~~~ Eine Operation läuft grundsätzlich so ab: 1. Das Befehlswort wird in das Operation-Register der FPU geschrieben 2. Der Status der FPU wird im Respond-Register getestet, bis die FPU 'Bereitschaft' signalisiert. 3. Falls es sich um eine interne Berechnung handelt, ist die Operation beendet 3a.Wenn ein Operand in die FPU transferiert werden muß, dann wird der Operand in das Operand-Register geschrieben. Je nach Wortbreite des Operanden sind ein Byte-, ein Wort- oder bis zu drei Langwort-Zugriffe erforderlich. Falls mehr als ein Zugriff notwendig sind, muß zwischen den Schreibzugriffen der Status der FPU nicht abgefragt werden. 4. Nachdem ein Operand übergeben wurde, muß wieder der Status abgefragt werden. Hier nocheinmal zur Übersicht: WRITE Command TEST Respond (until Ready) WRITE Operand WRITE Operand TEST Respond (until Ready) Falls der Operand mehr als 32 Bit hat, muß er in mehrern 32-Bit Lang- worten übergeben werden. Dazu wird zuerst der höherwertige Teil des Operanden geschrieben und zuletzt der niederwertigste Teil. Operand 1 wird mit Operand 2 berechnet, und das Ergebnis in Operand 2 abgelegt: Op2 = Op1 + Op2 oder Op2 += Op1 (for all you C-freaks out there !) Daraus folgt, daß der zweite Operand immer ein FPU-Register sein muß. Der erste Operand kann ebenfalls ein FPU-Register oder aber ein extern zuzu- führender Wert sein. Eine Ausnahme bildet der FMOVE-Befehl. In diesem Fall muß natürlich auch das Ziel extern sein dürfen, da man ja sonst niemals ein Ergebnis aus der FPU herausbekäme. :-) _ _ _ _ _ _ _ _ _ // // // // // // // // // _ // _ // _ // _ // _ // _ // _ // _ // _ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\// \\// \\// \\// \\// \\// \\// \\// \\// ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ Die MathIEEE.resource: ~~~~~~~~~~~~~~~~~~~~~~ Ab Kickstart/Workbench 1.3 unterstützen die MathIEEE.libraries eine FPU, die nur mit einem 68000 angesteuert wird. Dazu muß dem System mitge- teilt werden, daß A.) eine FPU installiert ist, und B.) an welcher physikalischen Adresse sich die Interface-Register befinden. Zu diesem Zweck wurde die MathIEEE.resource eingerichtet. Die resource ist allerdings nicht auf einer der original-Commodore Disks zu finden, da es keine offizielle Adresse für eine FPU gibt. Die FPU kann an einer (fast) beliebigen Adresse eingeblendet werden, was aber jedem Hersteller selber überlassen bleibt. Die Resource muß vor dem Laden, also vor dem ersten Zugriff auf eine IEEE.lib installiert werden, da die libraries nur einmal, eben beim Laden, für den FPU-Betrieb konfiguriert werden. Die Schreibweise (groß/klein) ist hierbei unbedingt einzuhalten, da die Resource sonst nicht gefunden werden kann. STRUCTURE MathIEEE.resource,LN_SIZE UWORD MathIEEE_Flags ULONG MathIEEE_BaseAddr ULONG MathIEEE_DblBasInit ULONG MathIEEE_DblTransInit ULONG MathIEEE_SngBasInit ULONG MathIEEE_SngTransInit LABEL MathIEEE_SIZE Außer der Node-Struktur und der MathIEEE_BaseAddr sollten alle anderen Einträge auf NULL gesetzt werden. In MathIEEE_BaseAddr muß die Basis- adresse der FPU eingetragen werden. Diese Adresse kann je nach Hersteller des FPU-Boards unterschiedlich sein. Beispiele : Rossmöller Mach-II: $00EF0000 Alphatron : $00F00000 Anmerkung: Beide Hersteller haben eine illegale Adresse belegt. Besonders gravierend ist $00EF0000, da diese Adresse den letzten Auto-Config-Slot darstellt. Falls also acht Autoconfig-devices am Rechner angeschlossen sind, kommt es zu einem Konflikt. _ _ _ _ _ _ _ _ _ // // // // // // // // // _ // _ // _ // _ // _ // _ // _ // _ // _ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\// \\// \\// \\// \\// \\// \\// \\// \\// ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ Mathematische Operationen: ~~~~~~~~~~~~~~~~~~~~~~~~~~ Die erste Tabelle zeigt alle Operationen, die der MC68881/2 beherrscht. Neben dem Mnemonic und der kurzen Funktionsbeschreibung, ist die Anzahl der Argumente angegeben. Bei der Addition sind immer zwei Werte notwen- dig. Dabei kann es sich aber durchaus um das gleiche Register handeln. Daher ist "FADD FP1,FP1" durchaus korrekt; es wird der Wert in FP1 ver- doppelt und das Ergebnis wieder in FP1 abgelegt. Wenn eine Operation nur ein Argument erfordert, können Quell- und Zielregister unterschiedlich sein. Der Befehl "FNEG FP2,FP0" bewirkt, daß das Komplement der Zahl in FP2, in das Register FP0 geschrieben wird, während FP2 unverändert bleibt. Mnemonic : Funktion : # Argumente FMOVE Schreiben/Lesen von FPU-Registern : 2 FABS Absolutwert berechnen : 1 FINT Integerwert bilden : 1 FNEG Negation : 1 FSCALE Skalierung 2^n : 1 FSQRT Quadratwurzel : 1 FTST Test auf Plus/Minus/Null : 1 FADD Addition : 2 FCOM Vergleich : 2 FDIV Division : 2 FMOD Modulo-Division : 2 FMUL Multiplikation : 2 FREM IEEE-Rest : 2 FSUB Subtraktion : 2 FACOS arcus-cosinus : 1 FASIN arcus-sinus : 1 FATAN arcus-tangens : 1 FATANH arcus-tangens hyperbolicus : 1 FCOS cosinus : 1 FCOSH cosinus hyperbolicus : 1 FETOX e^x : 1 FETOXM1 e^x-1 : 1 FLOG10 log10 : 1 FLOG2 log2 : 1 FLOGN ln : 1 FLOGNP1 log(e^x-1) : 1 FSIN sinus : 1 FSINCOS sinus und cosinus eines Wertes : 1 FSINH sinus hyperbolicus : 1 FTAN tangens : 1 FTANH tangens hyperbolicus : 1 FTENTOX 10^x : 1 FTWOTOX 2^x : 1 Mit einer 020/030 CPU stehen noch weitere Funktionen zur Verfügung: FBcc Branch on floating point condition FDBcc Decrement and branch on folating point condition FScc Set on floating point condition FTcc Trap on floating point condition FTPcc Test and trap on floating point condition FMOVECR Laden einer Konstanten FMOVEM Transfer mehrerer FP-Register von und zur CPU FSGLMUL Multiplikation mit einfacher Genauigkeit FSGLDIV Division mit einfacher Genauigkeit FSAVE Kompletten Inhalt der FPU auf dem Stack ablegen FRESTORE Den geretteten Inhalt der FPU zurückladen Die zweite Tabelle zeigt den Hexadezimalwert, der für die betreffende Operation als o5 - o0 angegeben werden muß. (siehe auch oben: FPU-Befehle) FINT $01 FSINH $02 FSQRT $04 FLOGNP1 $06 FETOXM1 $08 FTANH $0A FASIN $0C FATANH $0D FSIN $0E FTAN $0F FETOX $10 F2TOX $11 F10TOX $12 FLOGN $14 FLOG10 $15 FLOG2 $16 FABS $18 FCOSH $19 FNEG $1A FACOS $1C FCOS $1D FEXP $1E FMANT $1F FDIV $20 FMOD $21 FADD $22 FMUL $23 FSCALE $26 FSUB $28 FMOVE $00 Diese Tabelle ist leider keineswegs vollständig. Es fehlen zum Beispiel die Opcodes für FTST und FCMP, sowie für alle 68020 spezifischen Befehle. _ _ _ _ _ _ _ _ _ // // // // // // // // // _ // _ // _ // _ // _ // _ // _ // _ // _ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\// \\// \\// \\// \\// \\// \\// \\// \\// ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ Beispiele: ~~~~~~~~~~ Initialisierung der FPU nach einem Fehler (z.B. Division by Zero) MOVE.W #2,FPU.Response MOVE.W FPU.Control,-(SP) ADDQ.W #2,SP ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Test, ob die FPU den letzten Befehl beendet hat 1$ TST.B FPU.Control+1 BEQ.S 1$ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Befehl an die FPU übergeben MOVE.W #BEFEHL,FPU.Command 1$ TST.B FPU.Control+1 BEQ.S 1$ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ FPU-Status auslesen und in das CPU-Condition-Code-Register kopieren MOVE.W #$A800,FPU.Command 1$ TST.B FPU.Control+1 BEQ.S 1$ MOVE.L FPU.Operand,-(SP) MOVE.B (SP)+,CCR ; <- ließt ein WORD vom Stack !! ADDQ.W #2,SP ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ FPU-Command-Word für "FADD FP1,FP3" bilden bit | 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00 -------+------------------------------------------------------ mode 2 | ?? 00 00 s2 s1 s0 d2 d1 d0 ?? o5 o4 o3 o2 o1 o0 Unbenutzt 0 0 0 0 Quelle FP1 0 0 1 Ziel FP3 0 1 1 Operation ($22) 1 0 0 0 1 0 ------------------------------------------------------ CommandWord : % 0 0 0 0 0 1 0 1 1 0 1 0 0 0 1 0 oder $ 05A2 _ _ _ _ _ _ _ _ _ // // // // // // // // // _ // _ // _ // _ // _ // _ // _ // _ // _ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\// \\// \\// \\// \\// \\// \\// \\// \\// ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ Copyrights: ~~~~~~~~~~~ Motorola ist ein eingetragenes Warenzeichen der Firma MOTOROLA INC. MC68881 ist ein eingetragenes Warenzeichen der Firma MOTOROLA INC. MC68882 ist ein eingetragenes Warenzeichen der Firma MOTOROLA INC. MC68000 ist ein eingetragenes Warenzeichen der Firma MOTOROLA INC. MC68010 ist ein eingetragenes Warenzeichen der Firma MOTOROLA INC. MC68020 ist ein eingetragenes Warenzeichen der Firma MOTOROLA INC. MC68030 ist ein eingetragenes Warenzeichen der Firma MOTOROLA INC. Alphatron ist ein eingetragenes Warenzeichen der Alphatron GmbH Rossmöller ist ein eingetragenes Warenzeichen der Rossmöller Handshake GmbH Mach-II ist ein eingetragenes Warenzeichen der Rossmöller Handshake GmbH Commodore ist ein eingetragenes Warenzeichen der Commodore Buisiness Machines Inc. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Kontaktadresse für weitere Fragen, Fehlerberichte, Ergänzungen u.s.w.: holdenb1@ibm.gwdg.de holdenb1@dgogwdg1 Carsten Drücke Lilienthalstr. 12 3400 Göttingen -- EOF --