PAK68/2 Platinen Projekt ...

[Lukas Frank]

So geschafft, die FPU läuft jetzt. Ich hatte doch die Datenleitungen nicht genau genug nachgemessen. D23 fehlte an der FPU ...

[1ST1]

Mach auf jeden Fall für eine weitere Auflage der PAK68/2 noch ein korrigiertes Platinenlayout.

[Lukas Frank]

neogain muss normal umziehen, ab Juli wahrscheinlich ...

[Lukas Frank]

Hier jetzt mal die allgemeinen Aufbauhinweise ...

Jeder sollte sich mal den/die c´t Artikel von Heise besorgen ->   https://shop.heise.de/archiv/search/result?query=tausch+mit+turbo

Leserliche Schaltpläne als PDF kann ich per Anfrage via eMail verschicken ...

Die Bauteile sind so benannt wie im original von neogain, also kann man nach der original Bestückungsliste gehen. Die wichtigsten Bauteile bei Kessler sind ...

- M0204 560R (Widerstand 3mm 1%)
- M0204 1k
- M0204 4,7k
- M0204 10k
- QOS 32,000Mhz (optionaler Quarz FPU)
- PGA114 (Sockel 68020
- PLCC68Z (Sockel FPU)
- PZF64 (IC Fassung 68000)
- PZF20, PZF24, PZF14, PZF32
- TAN 10/16
- KER 22P R2,5
- VS 100N Z5U 2,5 (100nF Kondensator)
- JUMPER2,54-SW
- SA32SIL (68000 Pfostenleiste)
- STL1x50G (Jumper Pfostenleisten)
- 27C512 (Eprom 64kB 4 Stk. für TOS 2.06)
- GAL 20V8-15ns
- GAL 16V8-15ns
- MC68020RC20E (knapp 30,- Euro)

FPU ->   http://www.vesalia.de/d_68882.htm

Durch die Patches wird die Platine schon mit dem FPU Sockel und den 68000 Sockeln+Pfostenleiste und 2Stk. 24pol. GAL Sockeln geliefert. Da ich in einer Versandtasche als Brief versende ist zum Schutz der 68000 Pfostenleiste ein 64pol. Sockel der wahrscheinlich beim Transport kaputt geht aber das macht nichts. Die goldene 68000 Pfostenleiste ist sehr empfindlich also Vorsicht beim Handieren damit. Später beim Einbau muss sowiesso ein Türmchen aus 64pol. IC Sockeln gebaut werden, also genügend bestellen.

Alle Bauteile werden normal auf der Bauteilseite bestückt bis auf den Kondensator für die FPU. Anbei auch zwei Bilder an denen man sich orientieren kann.





Hier das Splitfile um aus dem normalen TOS 2.06 Image die vier Eprom Files für das 32-bit breite TOS für die PAK zu erzeugen. Benutzt wird das Romslit Paket aus dem Pinatubo Programm Paket. Es gibt ja auch noch das TOSPatch von Markus Heiden um Anpassungen am TOS umzusetzen ...

Code: [Auswählen]

# Kommandodatei fr ROMMIX:
# erstellen von 4 Eprom-Files fr 27C512
# 1 TOS-IMG wird auf 4 Eproms aufgeteilt
# von Udo Overath @ KR
# (das geht auch direkt mit Pinatubo --- ms)

# Puffergr”že setzen
bufsize 256k
# Directory setzen
chdir a:\pinatu24\rommix\

load tos206.img 0 256k all -> 0 all
save ee.u11 64k <- 0 ee
save oe.u10 64k <- 0 oe
save eo.u9 64k <- 0 eo
save oo.u8 64k <- 0 oo

Wer den GAL Satz selber macht sollte beim programmieren Nullbytes = 00 setzen. Hier im Anhang sind die JED Files zu den GAL Bausteinen.

Die PAK68/2 läuft wunderbar zusammen mit der MonSTer Erweiterung von Alan. Auf der MonSTer muss nur ein TOS 1.04 oder KAOS TOS eingestellt sein, damit die PAK mit Ihrem TOS 2.06 booten kann. Die PAK68/2 braucht ein kleines TOS unter/gleich 1.04 auf dem Mainboard.

[joejoe]

Zum Thema FastRAM auf der PAK/2. Ich hatte das damals mit einem guten Freund gemeinsam in etwa folgendermassen umgesetzt:
je zwei (oder waren es vier?) 128KByte statisches RAM (70ns) huckepack auf den EPROMs der PAK, ein weiteres GAL huckepack auf einem passenden GAL. Hier wurden die Chipselect und DTACK Signale für die zusätzlichen RAMs erzeugt. Damit das TOS 3.06 das FastRAM schon beim Booten findet, muss dieses physikalisch oberhalb der ersten 16MB liegen. Dazu kam dann eine zusätzliche Adresse ans GAL die Dekodierung kann sehr simpel bleiben, da TOS auf gespiegeltes RAM checkt  und entsprechend verwaltet.
Ich habe meine damalige PAK/2damals auf ebay verkauft, vermutlich an einen von Euch? Daher wundert es mich, zum Thema FastRAM mit statischen RAMS noch nichts weiter gelesen zu haben. Bei den heutzutage verfügbaren SRAM-Größen sollte das eine _wirklich_ schnelle Alternative sein.
Gruß
Jörg

[Lukas Frank]

Das hatte ich auch im Kopf allerdings ist das viel zu wenig Fastram. Ich dachte eher in die Richtung Atari TT/PAK68/3 mit FRAK also an minimal 16MB Fastram mit der MC68020 CPU ...

Habe 2048kx8 und 8192kx8 welches eigentlich 16bit ist aber auch als 8bit SRAM laufen kann gefunden. Das ergäbe 8MB oder 32MB SRAM. Das Problem ist das sind alles 3,3V Typen, also braucht es einen Regler was kein Problem wäre aber ich weiss nicht ob es mit der 5V Logic klappt. Und der Bereich über 12MB im ST Ram muss frei bleiben für die Grafikkarte und andere Sachen. Der 020 ist ja eine 32bit CPU also sollte das Fastram wie im Atari TT liegen. Und ein Problem wäre noch das man wahrscheinlich TOS 3.06 mit den PAK Patches braucht und dann IDE nicht mehr funktioniert. Aber Holger Zimmermann hat ja das TOS schon gepatcht wegen IDE.

Man könnte eine Magnum TT anpassen. Holger Zimmermann schrieb mir das es mit DSACK0 und 1 geht, problem ist das ich alleine das nicht umsetzen kann.

[joejoe]

ja, die DSACK0 und 1 Geschichte musste ich damals auch ändern im Decoder GAL für die EPROMS, das war in original PAK2 gleube ich einfach auf 32bittigen Zugriff ausgelegt. Habe mich damals an den Gleichungen für den  Amiga orientiert. Wir hatten das gepatchte TOS 3.06 genutzt. Mit einer eigenen Initialisierungsroutine kann FastRAM auch unterhalb 16MB liegen, was dann das AlternateRAM wäre.

[Lukas Frank]

Wenn das im ST Ram Bereich liegt bringt es das nicht.

[joejoe]

Das ist nicht ganz richtig,
Der Unterschied zu normalem ST-(D)RAM liegt in der Zugriffszeit mit 0-Wait States, da das SRAM einfach schnell genug ist. Diese Geschwindigkeit ändert sich nicht, egal ob das SRAM als Alternate-Ram (zwischen 12MB und 16MB) oder als FastRAM (oberhalb 16MB)  angesprochen wird. Der Austausch zum "normalen" ST-RAM erfolgt über einen Puffer im ST-RAM, da die ST-I/O-Chips das Fast-/AlternateRam nicht selbst adressieren können.
Habe mal geschaut was es bei Reichelt so gibt:
AS-6C4008-55PCN für 5,70€ das Stück
https://www.reichelt.de/DRAM-FRAM-SRAM/AS-6C4008-55PCN/3/index.html?ACTION=3&GROUPID=2954&ARTICLE=146553
mit 4 Bausteinen, also einer zusätzlichen Ebene über (oder unter) den EPROMS hat man dann schon 'mal 2 MB FastRAM. Z.B. in einem Mega-ST4 eingepflanzt heißt das 50% mehr RAM.
4 zusätzliche Lagen ergeben schon 8 MB FastRAM  Der Vorteil liegt im recht einfachen, reversiblen Einbau in eine bestehende PAK/2.

[Lukas Frank]

Das ist richtig. Aber bei mir zum Beispiel arbeitet zusammen mit der PAK68/2 eine MonSTer mit Flash TOS und 8MB Alternate Ram plus Dual IDE und ein VOFA ET4000 Grafikkarten Adapter. Was mir da fehlt wäre echtes Fastram oberhalb der 68k ST Ram Grenze, je mehr desto besser. Genau so wie im Atari TT möglich, da sind mit einer Magnum TT 256MB Fastram möglich ...

[joejoe]

Okay, die MonSTer kannte ich noch nicht,
...aber das ist ja beinahe derselbe Ansatz, nur das hier mangels fehlender Adressleitung (war's A20?) einer 68000-CPU eben nur Alternate-Ram bei (vermutlich) 8MHz und 16Bit Zugriff möglich sind. SRAM auf der PAK/2 würde 16MHz und 32-bittigen Zugriff bedeuten (natürlich nur bei Longword-Zugriffen) das bringt schon ein wenig Speed.
Aber das sollte auch nur ein kleiner Hinweis sein.
Gruß Jörg

[czietz]

Hier geht's aber ein bisschen durcheinander.

Also, richtig ist: Der 68000er hat nur einen 16-Bit-Datenbus, folglich sind alle Zugriffe natürlich maximal 16 Bit breit. Wenn die CPU nur bei 8 MHz läuft, sind die Zugriffe (selbst ohne Waitstates) natürlich auch nicht schneller. Die Anzahl der Adressleitungen, beim 68000er nur A23-A1, hat nichts mit 8 MHz oder 16 Bit zu tun, bestimmt aber die mögliche Lage des RAMs im Adressraum, mehr als 16 MiB kann der 68000er halt nicht adressieren. (Die Adressleitung A20 ist übrigens eher beim PC relevant...)

Ein 68020er hat einen vollen 32-Bit-Datenbus und einen Adressbus, der theoretisch 4 GiB adressieren kann. Somit kann dort -- wie auch im TT -- (Fast-)RAM oberhalb von 16 MiB eingebaut werden, auf den dann allerdings nur von der CPU (dafür aber 32-bittig und mit CPU-Takt) zugegriffen werden kann, nicht von der Peripherie.

[joejoe]

Danke für die Korrektur der Adressleitung
Was sonst "falsch" an meinen Aussagen gewesen sein sollte, kann ich nicht nachvollziehen. Deine Aussage trifft es ebenfalls: Es gibt durchaus einen nennenswerten Geschwindigkeitsvorteil von Fast (oder auch Alternate-) RAM auf einer PAK (32-bit, voller CPU-Takt) gegenüber AlternateRam am ST-Bus (16bit, 8MHz).
Auf einer PAK ist es relativ simpel SRAM im DIP32-Gehäuse zusätzlich zu integrieren, ohne zusätzliche FRAK oder ähnliches.  Mehr wollte ich nicht sagen. 
>edit> Da hier von einem Re-Design der alten PAK/2 die Rede ist, wäre es durchaus naheliegend, den Turmbau mit gestapelten RAM/ROM Bausteinen, wie ich ihn beschrieben habe, durch zusätzliche (SMD-) Sockel auf der "neuen PAK/2" vor zusehen. Die Glue-Logic ist eher simple.

[Lukas Frank]

So kleines Fastram ist uninteressant ...

Magnum TT Quell MACH210 Datei (musste ich Einkürzen wegen der 10000 Zeichen)->

Code: [Auswählen]

NODE  ?    Div[0]              REG
NODE  ?    Div[1]              REG
NODE  ?    Div[2]              REG
NODE  ?    Div[3]              REG
NODE  ?    Div[4]              REG
NODE  ?    Div[5]              REG
NODE  ?    Div[6]              REG
NODE  ?    Div[7]              REG
NODE  ?    StrRef            REG
NODE  ?    StartHidden       REG
NODE  ?    C_AS              REG
NODE  ?    ClearRef          REG
NODE  ?    DoCAS             COMB
NODE  ?    RightAdr          COMB
NODE  ?    UmDel1            COMB
NODE  ?    UmDel2            COMB
NODE  ?    MemStart          REG
NODE  ?    R95               REG
NODE  ?    StartRefresh      REG
NODE  ?    STermBankOK       COMB
NODE  ?    STermInt          REG
NODE  ?    STerm1            COMB
NODE  ?    R103              REG
NODE  ?    Bank_0A           COMB
NODE  ?    Bank_1A           COMB
NODE  ?    Bank_0B           COMB
NODE  ?    Bank_1B           COMB
NODE  ?    DelCAS            COMB
NODE  ?    DelCAS2           COMB

;----------------------------------- Group Statements --------------
;group mach_seg_d Div[6..0]

;----------------------------------- Diverse Gleichungen -----------
String BankOK '(Bank_0A + Bank_0B + Bank_1A + Bank_1B)'

;----------------------------------- Boolean Equation Segment ------
EQUATIONS
; ******* Bank Decodierung
Bank_0A =   A24 * /A25 * /A26 * /A27 * /A28 * /A29 * /A30 * /A31
         + /A24 * /A25 *  A26 * /A27 * /A28 * /A29 * /A30 * /A31 *  PD0_0 *  PD1_0
         + /A24 * /A25 *  A26 * /A27 * /A28 * /A29 * /A30 * /A31 * /PD0_0 * /PD1_0
         +         A25 * /A26 * /A27 * /A28 * /A29 * /A30 * /A31 *  PD0_0 *  PD1_0
         +         A25 * /A26 * /A27 * /A28 * /A29 * /A30 * /A31 * /PD0_0 * /PD1_0

Bank_0B =  /A24 *  A25 * /A26 * /A27 * /A28 * /A29 * /A30 * /A31 *  PD0_0 * /PD1_0
         + /A24 * /A25 * /A26 *  A27 * /A28 * /A29 * /A30 * /A31 *  PD0_0 *  PD1_0
          + A24 *         A26 * /A27 * /A28 * /A29 * /A30 * /A31 *  PD0_0 *  PD1_0
          +        A25 *  A26 * /A27 * /A28 * /A29 * /A30 * /A31 *  PD0_0 *  PD1_0

Bank_1A =  /A24 * /A25 *  A26 *  A27 * /A28 * /A29 * /A30 * /A31 *  PD0_0 *  PD0_1 *  PD1_0 *  PD1_1
         + /A24 * /A25 *  A26 *  A27 * /A28 * /A29 * /A30 * /A31 *  PD0_0 * /PD0_1 *  PD1_0 * /PD1_1
         +         A25 * /A26 *  A27 * /A28 * /A29 * /A30 * /A31 *  PD0_0 *  PD0_1 *  PD1_0 *  PD1_1
         +         A25 * /A26 *  A27 * /A28 * /A29 * /A30 * /A31 *  PD0_0 * /PD0_1 *  PD1_0 * /PD1_1
         + /A24 * /A25 * /A26 *  A27 * /A28 * /A29 * /A30 * /A31 * /PD0_0 * /PD0_1 * /PD1_0 * /PD1_1
         +         A25 *  A26 * /A27 * /A28 * /A29 * /A30 * /A31 * /PD0_0 * /PD0_1 * /PD1_0 * /PD1_1
         +  A24 * /A25 * /A26 *  A27 * /A28 * /A29 * /A30 * /A31 *  PD0_0 *           PD1_0
         +  A24 * /A25 *  A26 * /A27 * /A28 * /A29 * /A30 * /A31 * /PD0_0 *          /PD1_0 * /PD1_1
         +  A24 * /A25 *  A26 * /A27 * /A28 * /A29 * /A30 * /A31 * /PD0_0 * /PD0_1 * /PD1_0
         +  A24 *  A25 * /A26 * /A27 * /A28 * /A29 * /A30 * /A31 *  PD0_0 *  PD0_1 * /PD1_0 * /PD1_1
         +  A24 *  A25 * /A26 * /A27 * /A28 * /A29 * /A30 * /A31 *  PD0_0 * /PD0_1 * /PD1_0 *  PD1_1
         + /A24 *  A25 * /A26 * /A27 * /A28 * /A29 * /A30 * /A31 * /PD0_0 * /PD0_1 *  PD1_0 *  PD1_1

Bank_1B =  /A24 * /A25 * /A26 * /A27 *  A28 * /A29 * /A30 * /A31 *  PD0_0 * PD0_1 *  PD1_0 *  PD1_1
         +  A24 *         A26 *  A27 * /A28 * /A29 * /A30 * /A31 *  PD0_0 * PD0_1 *  PD1_0 *  PD1_1
         +         A25 *  A26 *  A27 * /A28 * /A29 * /A30 * /A31 *  PD0_0 * PD0_1 *  PD1_0 *  PD1_1
         + /A24 *  A25 * /A26 *  A27 * /A28 * /A29 * /A30 * /A31 *  PD0_0 * PD0_1 *  PD1_0 * /PD1_1
         + /A24 *  A25 *  A26 * /A27 * /A28 * /A29 * /A30 * /A31 * /PD0_0 * PD0_1 * /PD1_0 * /PD1_1
         + /A24 * /A25 *  A26 * /A27 * /A28 * /A29 * /A30 * /A31 *  PD0_0 * PD0_1 * /PD1_0 * /PD1_1

; ******* Refresh Counter
Div[0]   := /ClearRef* /Div[0]

Div[1]  := /ClearRef* /Div[0]*  Div[1]
       + /ClearRef*  Div[0]* /Div[1]

Div[2]  := /ClearRef*  Div[2]* /Div[1]
       + /ClearRef*  Div[2]* /Div[0]
       + /ClearRef* /Div[2]*  Div[1]* Div[0]

Div[3]  := /ClearRef*  Div[3]* /Div[2] 
       + /ClearRef*  Div[3]* /Div[1]
       + /ClearRef*  Div[3]* /Div[0]
       + /ClearRef* /Div[3]* Div[2]* Div[1]* Div[0]

Div[4].T   :=  ClearRef* Div[4] 
          + /ClearRef* Div[3]* Div[2]* Div[1]* Div[0]

Div[5].T   :=  ClearRef* Div[5]
          + /ClearRef* Div[4]* Div[3]* Div[2]* Div[1]* Div[0]

Div[6].T   :=  ClearRef* Div[6] 
          + /ClearRef* Div[5]* Div[4]* Div[3]* Div[2]* Div[1]* Div[0] 

Div[7].T   :=  ClearRef* Div[7] 
          + /ClearRef* Div[6]* Div[5]* Div[4]* Div[3]* Div[2]* Div[1]* Div[0]

StrRef   := /ClearRef* StrRef
          + /ClearRef* Div[7]* Div[6]* Div[5]* Div[4]

StartHidden := /ClearRef* StartHidden
             + /ClearRef* AS*  Div[7]

R103  := /ClearRef*  R103
       + /ClearRef* /AS* /RightAdr* StartHidden
       + /ClearRef* /AS* /BankOK*  StartHidden

StartRefresh   :=  R103
       +  StrRef
       + /AS* StartHidden* /(RightAdr * BankOK)

R95   :=  StartRefresh*  ClearRef* /MemStart

ClearRef   := /R95*  /MemStart*  StartRefresh

;******* CAS Selection
/CAS_UU = MemStart* /AS* DoCAS* (RW
       + /A1* /A0)
       + /R95*  /MemStart*  ClearRef*  StartRefresh

/CAS_UM = MemStart* /AS* DoCAS* ( RW
       + /A1*  SIZ1
       + /A1* /SIZ0
       + /A1*  A0)
       + /R95*  /MemStart*  ClearRef*  StartRefresh

/CAS_LM = MemStart* /AS* DoCAS*( RW
       +  A1* /A0
       + /A1*  SIZ0*  SIZ1
       + /A1* /SIZ0* /SIZ1
       + /A1*  SIZ1*  A0)
       + /R95*  /MemStart*  ClearRef*  StartRefresh

/CAS_LL = MemStart* /AS* DoCAS* ( RW
       +  A1*  SIZ1
       + /SIZ0* /SIZ1
       +  A1*   A0
       +  SIZ0*  SIZ1* A0)
       + /R95*  /MemStart*  ClearRef*  StartRefresh

; Async Set fuer RAS verzoegern
DelCAS2 = /CAS_UU * ClearRef * /R95
DelCAS  = DelCAS2

;******* RAS Selection fuer 4 Baenke
/RAS_0A:=  StartRefresh*  /MemStart*  ClearRef* /R95
       + /StartRefresh* /AS*  RightAdr*  BANK_0A
       + MemStart* /AS*  /RAS_0A*  RightAdr*  BANK_0A
;RAS_0A.SETF =   /CAS_UU*  ClearRef* /R95
RAS_0A.SETF =  DelCAS

/RAS_0B:=  StartRefresh*  /MemStart*  ClearRef* /R95
        + /StartRefresh*  BANK_0B* /AS*  RightAdr
        +  BANK_0B* MemStart* /AS*  RightAdr*  /RAS_0B
;RAS_0B.SETF =   /CAS_UU*  ClearRef* /R95
RAS_0B.SETF =  DelCAS

/RAS_1A:=  StartRefresh*  /MemStart*  ClearRef* /R95
       +  BANK_1A* /StartRefresh* /AS*  RightAdr
       +  BANK_1A*  /RAS_1A* MemStart* /AS*  RightAdr
;RAS_1A.SETF =   /CAS_UU*  ClearRef* /R95
RAS_1A.SETF =  DelCAS

/RAS_1B:=  StartRefresh*  /MemStart*  ClearRef* /R95
         + /StartRefresh* /AS*  BANK_1B*  RightAdr
         + /RAS_1B* MemStart* /AS*  BANK_1B*  RightAdr
;RAS_1B.SETF =   /CAS_UU*  ClearRef* /R95
RAS_1B.SETF =  DelCAS

/WE_1  = /RW* MemStart
/WE_0  = /RW* MemStart

;******* Andere Adressen
RightAdr    =  FC0* /FC1
            + /FC0*  FC1

;******* Handshake
MemStart :=   BankOK * RightAdr * /AS * /StartRefresh
            + BankOK * RightAdr * /AS * MemStart

C_AS   := /AS* MemStart

STermBankOK    = /BankOK
STERM.TRST =   /AS*  RightAdr* /STermBankOK
STERM      =  STerm1
STerm1     =  STermInt
/STermInt  := BankOK* RightAdr * /AS* (/0WS* /MemStart* /StartRefresh
                                      +  0WS*  MemStart* /C_AS)

UmDel1    =  /MemStart
       +  UmDel1* RAS_1B* RAS_1A* RAS_0A* RAS_0B

UmDel2    = /UmDel1

/Row =       0WS*  UmDel2
          + /0WS* /UmDel1

DoCAS    = /Row

;----------------------------------- Reset, Preset etc. ------------
Div[7..0].RSTF = GND;
Div[7..0].SETF = GND;
Div[7..0].CLKF = CLK16;
StrRef.CLKF = CLK16
StrRef.SETF = GND;
StrRef.RSTF = GND;
StartHidden.CLKF = CLK16
StartHidden.SETF = GND;
StartHidden.RSTF = GND;
R103.CLKF = CLK16
R103.SETF = GND;
R103.RSTF = GND;
StartRefresh.CLKF = CLK16
StartRefresh.SETF = GND;
StartRefresh.RSTF = GND;
R95.CLKF = CLK16
R95.SETF = GND;
R95.RSTF = GND;
ClearRef.CLKF = CLK16
ClearRef.SETF = GND;
ClearRef.RSTF = GND;
RAS_0A.CLKF = CLK16
RAS_0A.RSTF = GND;
RAS_0B.CLKF = CLK16
RAS_0B.RSTF = GND;
RAS_0B.RSTF = GND;
RAS_1A.CLKF =  CLK16
RAS_1A.RSTF = GND;
RAS_1B.CLKF =  CLK16
RAS_1B.RSTF = GND;
MemStart.CLKF = CLK16
MemStart.SETF = GND;
MemStart.RSTF = GND;
C_AS.CLKF = CLK16
C_AS.SETF = GND;
C_AS.RSTF = GND;
STermInt.CLKF = CLK16
STermInt.SETF = GND;
STermInt.RSTF = GND;

Es geht wohl darum dieses anzupassen ->

Code: [Auswählen]

STermBankOK    = /BankOK
STERM.TRST =   /AS*  RightAdr* /STermBankOK
STERM      =  STerm1
STerm1     =  STermInt
/STermInt  := BankOK* RightAdr * /AS* (/0WS* /MemStart* /StartRefresh
                                      +  0WS*  MemStart* /C_AS)

Der MC68020 hat kein STERM Signal und müßte mit Warteschleifen mit DSACK0 und 1 umgesetzt werden ?

[joejoe]

Mit simpler GLUE-Lösung meinte ich die wenigen zusätzlichen GAL-Gleichungen für meine uninteressante Lösung. Mit den MACH210-Quellen für die Magnum TT habe ich mich nicht beschäftigt, da muss ich passen. SRAM ist eben einfacher anzuspechen als DRAM    

[Lukas Frank]

Das war mir Klar ...

Wenn man minimal 16MB Fastram so eingebunden wie beim Atari TT mit SRAM recht einfach umsetzen könnte warum nicht.

Die Magnum TT ist halt da, funktioniert und ist freigegeben. Ein neues Layout der PAK68/2 mit Magnum TT zusammen auf einer großen Platine wäre ja machbar. Die Magnum TT besteht aus recht wenigen Teilen als da wären einige Widerstände, F157, ein MACH210 und eben die beiden PS/2 Simm Sockel. STERM ist ein Ausgang auf der Magnum TT hin zur CPU, vielleicht wäre es ja möglich die Magnum TT so zu lassen wie sie ist und mit einem zusätzlichen GAL die DSACK Umsetzung für die MC68020 CPU zu machen, keine Ahnung ...

Für mich wäre sowas sehr Interessant da es etwas neues wäre, Fastram mit einer 020 CPU. Immer schneller und so, davon halte ich nichts. Ist eh selbst wenn es 10x schneller wäre im Grunde immer noch zu langsam. Selbst die Firebee ist eine Schnecke. Langsamkeit macht mir nichts aus ;-)))

[czietz]

DSACK ist einfach. Wenn Du das RAM 32-Bit-breit anbindest und es schnell genug ist, dass keine Waitstates nötig sind, musst Du nur /DSACK0 und /DSACK1 low ziehen, um der CPU einen erfolgreichen 32-Bit-Buszyklus anzuzeigen.

Davon abgesehen hat joejoe vollkommen recht und die Logik wird viel, viel einfacher, wenn es um SRAM geht und nicht um DRAM.

[Lukas Frank]

Laut Holger Zimmermann sind aber Warteschleifen nötig. DSACK0 und 1 haben doch mehrere Funktionen ?

SRAM wäre ja gut wenn man damit eine ansprechende Menge/Größe bewerkstelligen kann. So minimum 16MB sollte schon sein, meine ich.

[joejoe]

Holger Zimmermann sollte es wissen, 
allerdings meine ich mich erinnern zu können, das in dem Artikel zur PAK/2 in der c't damals von dem großen Geschwindigkeitsvorteil von 32-bit ROM mit, wie ich meine 0- wait-states, die Rede war. Die verbreiteten SRAMS waren mit 55-70ns damals schon schneller als die empfohlenen 100ns EPROMs sollten also ebenso fix angesprochen werden können.

btw.
Ich habe zum RAM-Baustein der mir bis gestern unbekannten MonSTer keine Doku im Netz finden können, ist aber vermutlich ein DRAM? Ansonsten wären zwei Stück davon schon einmal die geforderte Minmal-FastRAM-Größe.

[Lukas Frank]

MonSTer Anleitung ->   http://www.atarikit.co.uk/monster/monster.html

Da ist auch SRAM drauf wahrscheinlich ein 4096kBx16 Baustein, keine Ahnung.

Also 4MB ST Ram plus 16MB TT Ram sind schon brauchbar. Je mehr desto besser ...