PAK68/2 Platinen Projekt ...

Hardware > Hardware (Classic 16-/32-Bit)

<< < (11/48) > >>

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. 8)
>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: ---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;

--- Ende Code ---

Es geht wohl darum dieses anzupassen ->

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

--- Ende Code ---

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 ;)

Navigation

[0] Themen-Index

[#] Nächste Seite

[*] Vorherige Sete

Zur normalen Ansicht wechseln