827 lines
38 KiB
Python
827 lines
38 KiB
Python
from migen import *
|
|
from migen.genlib.fifo import *
|
|
from migen.genlib.cdc import *
|
|
from migen.fhdl.specials import Tristate
|
|
|
|
import litex
|
|
from litex.soc.interconnect import wishbone
|
|
|
|
class NuBus(Module):
|
|
def __init__(self, soc, version,
|
|
burst_size, tosbus_fifo, fromsbus_fifo, fromsbus_req_fifo,
|
|
wb_read, wb_write, wb_dma,
|
|
usesampling=False,
|
|
cd_nubus="nubus", cd_nubus90="nubus90"):
|
|
|
|
platform = soc.platform
|
|
self.add_sources(platform, version)
|
|
|
|
#led0 = platform.request("user_led", 0)
|
|
#led1 = platform.request("user_led", 1)
|
|
|
|
if (usesampling):
|
|
# when using 'sampling', the NuBus clock is sampled at sys_clk frequency instead of used directly
|
|
# the other signals are still sampled synchronously, and the buffer used from sysclk afterwards
|
|
# I'm not completely sure about timings, but in practice it seems to work...
|
|
# The major benefit is that when a read is detected, it is sent to the Wishbone synchronously as the signals are already in sys_clk
|
|
# And when Wishbone answers, we just wait for the next detected NuBus edge to answer
|
|
# It significantly improves read latency
|
|
# Writes don't see the same improvement, as they always are fire-and-forget in a FIFO anyway
|
|
nub_clk = ClockSignal(cd_nubus)
|
|
nub_resetn = ~ResetSignal(cd_nubus)
|
|
nub_clk_prev_bits = 4 # how many cycles after posedge do we still dare set some signals (i.e. still before setup time before negedge)
|
|
nub_clk_prev = Signal(nub_clk_prev_bits)
|
|
nub_clk_negedge = Signal()
|
|
nub_clk_posedge = Signal()
|
|
nub_clk_insetup = Signal()
|
|
self.sync += [
|
|
nub_clk_prev[0].eq(nub_clk),
|
|
]
|
|
self.sync += [
|
|
nub_clk_prev[i].eq(nub_clk_prev[i-1]) for i in range(1, nub_clk_prev_bits)
|
|
]
|
|
#self.sync += [
|
|
# nub_clk_negedge.eq(~nub_clk & nub_clk_prev[0]),
|
|
# nub_clk_posedge.eq( nub_clk & ~nub_clk_prev[0]),
|
|
# nub_clk_insetup.eq( nub_clk & (nub_clk_prev != ((2**nub_clk_prev_bits)-1))), # if one of the previous X cycles is zero, we're early enough to set up signals
|
|
#]
|
|
# this should use double sampling; however using [1] and [2] break, perhaps the detection is too late?
|
|
self.comb += [
|
|
nub_clk_negedge.eq(~nub_clk_prev[0] & nub_clk_prev[1]),
|
|
nub_clk_posedge.eq( nub_clk_prev[0] & ~nub_clk_prev[1]),
|
|
nub_clk_insetup.eq( nub_clk_prev[0] & (nub_clk_prev[1:nub_clk_prev_bits] != ((2**(nub_clk_prev_bits-1))-1))), # if one of the previous X cycles is zero, we're early enough to set up signals
|
|
]
|
|
|
|
# Signals for tri-stated nubus access
|
|
# slave
|
|
tmo_oe = Signal() # output enable
|
|
tm0_i_n = Signal()
|
|
tm0_o_n = Signal(reset = 1)
|
|
tm1_i_n = Signal()
|
|
tm1_o_n = Signal(reset = 1)
|
|
ack_i_n = Signal()
|
|
ack_o_n = Signal(reset = 1)
|
|
|
|
ad_oe = Signal()
|
|
ad_i_n = Signal(32)
|
|
ad_o_n = Signal(32)
|
|
|
|
id_i_n = Signal(4)
|
|
|
|
start_i_n = Signal()
|
|
start_o_n = Signal(reset = 1) # master via master_oe
|
|
|
|
# master
|
|
rqst_oe = Signal()
|
|
rqst_i_n = Signal()
|
|
rqst_o_n = Signal(reset = 1)
|
|
|
|
# sampled signals, exposing the value of the register acquired on the falling edge
|
|
# they can change every cycle *on falling edge*
|
|
# slave
|
|
sampled_tm0 = Signal() # high is byte (which byte is in ad0/ad1); low is halfword/word/block depending on ad0/ad1
|
|
sampled_tm1 = Signal() # high is write
|
|
sampled_start = Signal()
|
|
sampled_ack = Signal()
|
|
sampled_ad = Signal(32)
|
|
sampled_ad_byterev = Signal(32)
|
|
|
|
# master
|
|
sampled_rqst = Signal()
|
|
|
|
# address rewriting
|
|
# can change every cycle *on falling edge*
|
|
processed_ad = Signal(32)
|
|
processed_super_ad = Signal(32)
|
|
self.comb += [
|
|
processed_ad[0:23].eq(sampled_ad[0:23]),
|
|
If(~sampled_ad[23], # first 8 MiB of slot space: remap to last 8 Mib of SDRAM
|
|
processed_ad[23:32].eq(Cat(Signal(1, reset=1), Signal(8, reset = 0x8f))), # 0x8f8...
|
|
).Else( # second 8 MiB: direct access
|
|
processed_ad[23:32].eq(Cat(sampled_ad[23], Signal(8, reset = 0xf0)))), # 24 bits, a.k.a 22 bits of words
|
|
processed_super_ad[0:28].eq(sampled_ad[0:28]),
|
|
processed_super_ad[28:32].eq(Signal(4, reset = 0x8)),
|
|
sampled_ad_byterev[ 0: 8].eq(sampled_ad[24:32]),
|
|
sampled_ad_byterev[ 8:16].eq(sampled_ad[16:24]),
|
|
sampled_ad_byterev[16:24].eq(sampled_ad[ 8:16]),
|
|
sampled_ad_byterev[24:32].eq(sampled_ad[ 0: 8]),
|
|
]
|
|
|
|
# decoded signals, exposing decoded results from the sampled signals
|
|
# they can change every cycle *on falling edge*
|
|
# from sampling (fixme?)
|
|
decoded_sel = Signal(4)
|
|
decoded_block = Signal()
|
|
decoded_busy = Signal()
|
|
# locally evaluated
|
|
decoded_myslot = Signal()
|
|
decoded_mysuperslot = Signal()
|
|
self.comb += [
|
|
decoded_myslot.eq(
|
|
(sampled_ad[28:32] == 0xF) &
|
|
(sampled_ad[27] == ~id_i_n[3]) &
|
|
(sampled_ad[26] == ~id_i_n[2]) &
|
|
(sampled_ad[25] == ~id_i_n[1]) &
|
|
(sampled_ad[24] == ~id_i_n[0])),
|
|
decoded_mysuperslot.eq(
|
|
(sampled_ad[31] == ~id_i_n[3]) &
|
|
(sampled_ad[30] == ~id_i_n[2]) &
|
|
(sampled_ad[29] == ~id_i_n[1]) &
|
|
(sampled_ad[28] == ~id_i_n[0])),
|
|
#led0.eq(decoded_block),
|
|
]
|
|
|
|
# current value, registered from the sampled/processed/decoded signals
|
|
# change is controlled by the FSM
|
|
current_adr = Signal(32)
|
|
#current_tm0 = Signal()
|
|
#current_tm1 = Signal()
|
|
current_sel = Signal(4)
|
|
#current_block = Signal()
|
|
current_data = Signal(32)
|
|
|
|
# write FIFO to speed up bus turnaround on NuBus side
|
|
write_fifo_layout = [
|
|
("adr", 32),
|
|
("data", 32),
|
|
("sel", 4),
|
|
]
|
|
if (usesampling):
|
|
self.submodules.write_fifo = write_fifo = SyncFIFOBuffered(width=layout_len(write_fifo_layout), depth=16)
|
|
else:
|
|
self.submodules.write_fifo = write_fifo = ClockDomainsRenamer({"read": "sys", "write": "nubus"})(AsyncFIFOBuffered(width=layout_len(write_fifo_layout), depth=16))
|
|
write_fifo_dout = Record(write_fifo_layout)
|
|
self.comb += write_fifo_dout.raw_bits().eq(write_fifo.dout)
|
|
write_fifo_din = Record(write_fifo_layout)
|
|
self.comb += write_fifo.din.eq(write_fifo_din.raw_bits())
|
|
|
|
# nubus-synchronous sampling (in Verilog for negedge)
|
|
self.specials += Instance("nubus_sampling",
|
|
i_nub_clkn = ClockSignal(cd_nubus),
|
|
i_nub_resetn = ~ResetSignal(cd_nubus),
|
|
i_nub_tm0n = tm0_i_n,
|
|
i_nub_tm1n = tm1_i_n,
|
|
i_nub_startn = start_i_n,
|
|
i_nub_rqstn = rqst_i_n,
|
|
i_nub_ackn = ack_i_n,
|
|
i_nub_adn = ad_i_n,
|
|
|
|
o_tm0 = sampled_tm0,
|
|
o_tm1 = sampled_tm1,
|
|
o_start = sampled_start,
|
|
o_rqst = sampled_rqst,
|
|
o_ack = sampled_ack,
|
|
o_ad = sampled_ad,
|
|
|
|
o_sel = decoded_sel,
|
|
o_block = decoded_block,
|
|
o_busy = decoded_busy,
|
|
)
|
|
|
|
self.read_ctr = read_ctr = Signal(32)
|
|
self.writ_ctr = writ_ctr = Signal(32)
|
|
|
|
if (usesampling):
|
|
# ############# usesampling FSM
|
|
self.submodules.slave_fsm = slave_fsm = FSM(reset_state="Reset")
|
|
slave_fsm.act("Reset",
|
|
NextState("Idle")
|
|
)
|
|
slave_fsm.act("Idle",
|
|
# only react to transaction start at posedge
|
|
If(nub_clk_posedge & (decoded_myslot | decoded_mysuperslot) & sampled_start & ~sampled_ack & ~sampled_tm1,# & ~decoded_block, # regular read (we always send back 32 bits, so don't worry about byte/word)
|
|
If(decoded_myslot,
|
|
NextValue(current_adr, processed_ad),
|
|
).Else( # decoded_mysuperslot,
|
|
NextValue(current_adr, processed_super_ad),
|
|
),
|
|
NextValue(read_ctr, read_ctr + 1),
|
|
NextState("WaitWBRead"),
|
|
).Elif(nub_clk_posedge & (decoded_myslot | decoded_mysuperslot) & sampled_start & ~sampled_ack & sampled_tm1,# & ~decoded_block, # regular write
|
|
If(decoded_myslot,
|
|
NextValue(current_adr, processed_ad),
|
|
).Else( # decoded_mysuperslot,
|
|
NextValue(current_adr, processed_super_ad),
|
|
),
|
|
NextValue(current_sel, decoded_sel),
|
|
NextValue(writ_ctr, writ_ctr + 1),
|
|
If(write_fifo.writable,
|
|
NextState("NubusWriteDataToFIFO"),
|
|
).Else(
|
|
NextState("NubusWaitForFIFO"),
|
|
)
|
|
)
|
|
)
|
|
slave_fsm.act("WaitWBRead",
|
|
wb_read.cyc.eq(1),
|
|
wb_read.stb.eq(1),
|
|
wb_read.we.eq(0),
|
|
wb_read.sel.eq(0xf),
|
|
wb_read.adr.eq(current_adr[2:32]),
|
|
tmo_oe.eq(1),
|
|
tm0_o_n.eq(1),
|
|
tm1_o_n.eq(1),
|
|
ack_o_n.eq(1),
|
|
If(wb_read.ack,
|
|
NextValue(current_data, wb_read.dat_r),
|
|
If(nub_clk_insetup,
|
|
ad_oe.eq(1),
|
|
ad_o_n.eq(~wb_read.dat_r),
|
|
tm0_o_n.eq(0),
|
|
tm1_o_n.eq(0),
|
|
ack_o_n.eq(0),
|
|
NextState("FinishRead"),
|
|
).Else(
|
|
NextState("WaitBeforeFinishRead"),
|
|
)
|
|
)
|
|
)
|
|
slave_fsm.act("WaitBeforeFinishRead",
|
|
tmo_oe.eq(1),
|
|
tm0_o_n.eq(1),
|
|
tm1_o_n.eq(1),
|
|
ack_o_n.eq(1),
|
|
If(nub_clk_insetup,
|
|
ad_oe.eq(1),
|
|
ad_o_n.eq(~current_data),
|
|
tm0_o_n.eq(0),
|
|
tm1_o_n.eq(0),
|
|
ack_o_n.eq(0),
|
|
NextState("FinishRead"),
|
|
),
|
|
)
|
|
slave_fsm.act("FinishRead",
|
|
tmo_oe.eq(1),
|
|
ad_oe.eq(1),
|
|
ad_o_n.eq(~current_data),
|
|
tm0_o_n.eq(0),
|
|
tm1_o_n.eq(0),
|
|
ack_o_n.eq(0),
|
|
#If((~nub_clk & nub_clk_prev[0]), # simultaneous with setting negedge
|
|
If(nub_clk_negedge,
|
|
NextState("ReadCleanup"),
|
|
)
|
|
)
|
|
slave_fsm.act("ReadCleanup",
|
|
tmo_oe.eq(1),
|
|
ad_oe.eq(1),
|
|
ad_o_n.eq(~current_data),
|
|
tm0_o_n.eq(0),
|
|
tm1_o_n.eq(0),
|
|
ack_o_n.eq(0),
|
|
NextState("Idle"),
|
|
),
|
|
|
|
slave_fsm.act("NubusWriteDataToFIFO",
|
|
tmo_oe.eq(1),
|
|
tm0_o_n.eq(0),
|
|
tm1_o_n.eq(0),
|
|
ack_o_n.eq(0),
|
|
#If((~nub_clk & nub_clk_prev[0]), # simultaneous with setting negedge
|
|
If(nub_clk_negedge,
|
|
write_fifo.we.eq(1),
|
|
NextState("WriteCleanup"),
|
|
)
|
|
)
|
|
slave_fsm.act("NubusWaitForFIFO",
|
|
tmo_oe.eq(1),
|
|
tm0_o_n.eq(1),
|
|
tm1_o_n.eq(1),
|
|
ack_o_n.eq(1),
|
|
If(nub_clk_posedge & write_fifo.writable,
|
|
NextState("NubusWriteDataToFIFO"),
|
|
)
|
|
)
|
|
slave_fsm.act("WriteCleanup", # extra sysclk cycle after negedge
|
|
tmo_oe.eq(1),
|
|
tm0_o_n.eq(0),
|
|
tm1_o_n.eq(0),
|
|
ack_o_n.eq(0),
|
|
NextState("Idle"),
|
|
)
|
|
# ############# end of usesampling FSM
|
|
else:
|
|
# ############# non-usesampling FSM
|
|
self.submodules.slave_fsm = slave_fsm = ClockDomainsRenamer(cd_nubus)(FSM(reset_state="Reset"))
|
|
slave_fsm.act("Reset",
|
|
NextState("Idle")
|
|
)
|
|
slave_fsm.act("Idle",
|
|
If((decoded_myslot | decoded_mysuperslot) & sampled_start & ~sampled_ack & ~sampled_tm1,# & ~decoded_block, # regular read (we always send back 32 bits, so don't worry about byte/word)
|
|
If(decoded_myslot,
|
|
NextValue(current_adr, processed_ad),
|
|
).Else( # decoded_mysuperslot,
|
|
NextValue(current_adr, processed_super_ad),
|
|
),
|
|
NextValue(read_ctr, read_ctr + 1),
|
|
NextState("WaitWBRead"),
|
|
).Elif((decoded_myslot | decoded_mysuperslot) & sampled_start & ~sampled_ack & sampled_tm1,# & ~decoded_block, # regular write
|
|
If(decoded_myslot,
|
|
NextValue(current_adr, processed_ad),
|
|
).Else( # decoded_mysuperslot,
|
|
NextValue(current_adr, processed_super_ad),
|
|
),
|
|
NextValue(current_sel, decoded_sel),
|
|
NextValue(writ_ctr, writ_ctr + 1),
|
|
NextState("NubusWriteDataToFIFO"),
|
|
)
|
|
)
|
|
slave_fsm.act("WaitWBRead",
|
|
wb_read.cyc.eq(1),
|
|
wb_read.stb.eq(1),
|
|
wb_read.we.eq(0),
|
|
wb_read.sel.eq(0xf),
|
|
wb_read.adr.eq(current_adr[2:32]),
|
|
tmo_oe.eq(1),
|
|
tm0_o_n.eq(1),
|
|
tm1_o_n.eq(1),
|
|
ack_o_n.eq(1),
|
|
If(wb_read.ack,
|
|
ad_oe.eq(1),
|
|
ad_o_n.eq(~wb_read.dat_r),
|
|
tm0_o_n.eq(0),
|
|
tm1_o_n.eq(0),
|
|
ack_o_n.eq(0),
|
|
NextState("Idle"),
|
|
)
|
|
)
|
|
slave_fsm.act("NubusWriteDataToFIFO",
|
|
tmo_oe.eq(1),
|
|
tm0_o_n.eq(1),
|
|
tm1_o_n.eq(1),
|
|
ack_o_n.eq(1),
|
|
If(write_fifo.writable,
|
|
write_fifo.we.eq(1),
|
|
tm0_o_n.eq(0),
|
|
tm1_o_n.eq(0),
|
|
ack_o_n.eq(0),
|
|
NextState("Idle"),
|
|
)
|
|
)
|
|
# ############# end of non-usesampling FSM
|
|
|
|
# connect the write FIFO inputs
|
|
self.comb += [ write_fifo_din.adr.eq(current_adr), # recorded
|
|
write_fifo_din.data.eq(~ad_i_n if usesampling else sampled_ad),
|
|
write_fifo_din.sel.eq(current_sel), # recorded
|
|
]
|
|
# deal with emptying the Write FIFO to the write WB
|
|
self.comb += [ wb_write.cyc.eq(write_fifo.readable),
|
|
wb_write.stb.eq(write_fifo.readable),
|
|
wb_write.we.eq(1),
|
|
wb_write.adr.eq(write_fifo_dout.adr[2:32]),
|
|
wb_write.dat_w.eq(write_fifo_dout.data),
|
|
wb_write.sel.eq(write_fifo_dout.sel),
|
|
write_fifo.re.eq(wb_write.ack),
|
|
]
|
|
|
|
owning_bus = Signal(reset = 0) # fixme ; theoretically one can bypass arbitration when owning the bus
|
|
|
|
start_arbitration = Signal()
|
|
grant = Signal()
|
|
master_oe = Signal()
|
|
|
|
nubus_sync = getattr(self.sync, cd_nubus)
|
|
nubus_sync += [
|
|
If(sampled_rqst & ~start_arbitration,
|
|
owning_bus.eq(0),
|
|
)
|
|
]
|
|
|
|
self.submodules.dma_fsm = dma_fsm = ClockDomainsRenamer(cd_nubus)(FSM(reset_state="Reset"))
|
|
ctr = Signal(log2_int(burst_size)) # burst counter
|
|
burst = Signal()
|
|
burst_we = Signal()
|
|
|
|
data_width = burst_size * 4
|
|
data_width_bits = burst_size * 32
|
|
blk_addr_width = 32 - log2_int(data_width) # 27 for burst_size == 8, 28 for burst_size == 4
|
|
fifo_addr = Signal(blk_addr_width)
|
|
fifo_blk_addr = Signal(blk_addr_width)
|
|
fifo_buffer = Signal(data_width_bits)
|
|
|
|
tosbus_fifo_dout = Record(soc.tosbus_layout)
|
|
self.comb += tosbus_fifo_dout.raw_bits().eq(tosbus_fifo.dout)
|
|
tosbus_fifo_dout_data_byterev = Signal(data_width_bits)
|
|
tosbus_fifo_dout_bytereversal_stmts = [ tosbus_fifo_dout_data_byterev[k*32+j*8:k*32+j*8+8].eq(tosbus_fifo_dout.data[k*32+32-j*8-8:k*32+32-j*8]) for k in range(burst_size) for j in range(4) ]
|
|
self.comb += tosbus_fifo_dout_bytereversal_stmts
|
|
|
|
fromsbus_req_fifo_dout = Record(soc.fromsbus_req_layout)
|
|
self.comb += fromsbus_req_fifo_dout.raw_bits().eq(fromsbus_req_fifo.dout)
|
|
|
|
fromsbus_fifo_din = Record(soc.fromsbus_layout)
|
|
self.comb += fromsbus_fifo.din.eq(fromsbus_fifo_din.raw_bits())
|
|
|
|
#self.comb += led0.eq(~dma_fsm.ongoing("Idle"))
|
|
#self.comb += led1.eq(burst)
|
|
|
|
dma_fsm.act("Reset",
|
|
NextState("Idle")
|
|
)
|
|
dma_fsm.act("Idle",
|
|
If(wb_dma.cyc & wb_dma.stb & ~sampled_rqst, # we need the bus and it's not being requested
|
|
NextValue(burst, 0),
|
|
If(owning_bus, # we own the bus, skip arbitration
|
|
NextState("AdrCycle"),
|
|
).Else( # go for arbitration
|
|
NextState("Arbitration"),
|
|
),
|
|
).Elif(tosbus_fifo.readable & ~sampled_rqst,
|
|
NextValue(burst, 1),
|
|
NextValue(burst_we, 1),
|
|
NextValue(fifo_addr, tosbus_fifo_dout.address[(32-blk_addr_width):32]),
|
|
If(owning_bus, # we own the bus, skip arbitration
|
|
NextState("Burst4AdrCycle"),
|
|
).Else( # go for arbitration
|
|
NextState("Arbitration"),
|
|
)
|
|
).Elif(fromsbus_req_fifo.readable & fromsbus_fifo.writable & ~sampled_rqst,
|
|
NextValue(burst, 1),
|
|
NextValue(burst_we, 0),
|
|
NextValue(fifo_addr, fromsbus_req_fifo_dout.dmaaddress[(32-blk_addr_width):32]),
|
|
NextValue(fifo_blk_addr, fromsbus_req_fifo_dout.blkaddress),
|
|
If(owning_bus, # we own the bus, skip arbitration
|
|
NextState("Burst4AdrCycle"),
|
|
).Else( # go for arbitration
|
|
NextState("Arbitration"),
|
|
)
|
|
)
|
|
)
|
|
dma_fsm.act("Arbitration",
|
|
start_arbitration.eq(1),
|
|
rqst_oe.eq(1),
|
|
rqst_o_n.eq(0),
|
|
NextState("WaitForGrant"),
|
|
)
|
|
dma_fsm.act("WaitForGrant",
|
|
start_arbitration.eq(1),
|
|
rqst_oe.eq(1),
|
|
rqst_o_n.eq(0),
|
|
If(grant & ~decoded_busy, # I'm now 'owner'
|
|
NextValue(owning_bus, 1),
|
|
If(burst,
|
|
NextState("Burst4AdrCycle"),
|
|
).Else(
|
|
NextState("AdrCycle"),
|
|
),
|
|
)
|
|
)
|
|
dma_fsm.act("AdrCycle",
|
|
start_arbitration.eq(0),
|
|
master_oe.eq(1), # for start
|
|
tmo_oe.eq(1), # for tm0, tm1, ack
|
|
ad_oe.eq(1), # for write address
|
|
start_o_n.eq(0),
|
|
tm0_o_n.eq(~((wb_dma.sel == 0x1) | (wb_dma.sel == 0x2) | (wb_dma.sel == 0x4) | (wb_dma.sel == 0x8))), # byte only
|
|
tm1_o_n.eq(~wb_dma.we),
|
|
ad_o_n[0].eq(~((wb_dma.sel == 0x2) | (wb_dma.sel == 0x3) | (wb_dma.sel == 0x8) | (wb_dma.sel == 0xc))), # odd bytes, both half-words
|
|
ad_o_n[1].eq(~((wb_dma.sel == 0x4) | (wb_dma.sel == 0x8) | (wb_dma.sel == 0xc))), # upper bytes and half-word
|
|
ad_o_n[2:32].eq(~wb_dma.adr),
|
|
ack_o_n.eq(1),
|
|
If(wb_dma.we,
|
|
NextState("DatCycle"),
|
|
).Else(
|
|
NextState("ReadWaitForAck"),
|
|
)
|
|
)
|
|
dma_fsm.act("DatCycle",
|
|
master_oe.eq(1), # for start
|
|
ad_oe.eq(1), # for write data
|
|
start_o_n.eq(1), # start finished, but still need to be driven
|
|
ad_o_n.eq(~wb_dma.dat_w),
|
|
If(sampled_ack,
|
|
wb_dma.ack.eq(1),
|
|
# fixme: check status ??? (tm0 and tm1 should be active for no-error)
|
|
NextState("FinishCycle"),
|
|
)
|
|
)
|
|
dma_fsm.act("FinishCycle",
|
|
NextValue(burst, 0),
|
|
master_oe.eq(1), # for start
|
|
start_o_n.eq(1), # start finished, but still need to be driven
|
|
tmo_oe.eq(1), # for tm0, tm1, ack, need to be driven to inactive
|
|
tm0_o_n.eq(1),
|
|
tm1_o_n.eq(1),
|
|
ack_o_n.eq(1),
|
|
NextState("Idle"),
|
|
)
|
|
dma_fsm.act("ReadWaitForAck",
|
|
master_oe.eq(1), # for start
|
|
start_o_n.eq(1), # start finished, but still need to be driven
|
|
wb_dma.dat_r.eq(sampled_ad),
|
|
If(sampled_ack,
|
|
wb_dma.ack.eq(1),
|
|
# fixme: check status ??? (tm0 and tm1 should be active for no-error)
|
|
NextState("FinishCycle"),
|
|
)
|
|
)
|
|
|
|
if (burst_size == 4):
|
|
handle_ad_for_burst = [
|
|
ad_o_n[0].eq(1), # burst
|
|
ad_o_n[1].eq(0), # burst
|
|
ad_o_n[2].eq(0), # burst == 4
|
|
ad_o_n[3].eq(1), # burst == 4
|
|
ad_o_n[4:32].eq(~fifo_addr), # adr
|
|
]
|
|
elif (burst_size == 8):
|
|
handle_ad_for_burst = [
|
|
ad_o_n[0].eq(1), # burst
|
|
ad_o_n[1].eq(0), # burst
|
|
ad_o_n[2].eq(0), # burst == 8
|
|
ad_o_n[3].eq(0), # burst == 8
|
|
ad_o_n[4].eq(1), # burst == 8
|
|
ad_o_n[5:32].eq(~fifo_addr), # adr
|
|
]
|
|
else:
|
|
raise ValueError(f"Unsupported burst_size {burst_size}")
|
|
|
|
dma_fsm.act("Burst4AdrCycle",
|
|
start_arbitration.eq(0),
|
|
master_oe.eq(1), # for start
|
|
tmo_oe.eq(1), # for tm0, tm1, ack
|
|
ad_oe.eq(1), # for write address
|
|
start_o_n.eq(0),
|
|
tm0_o_n.eq(1), # burst
|
|
tm1_o_n.eq(~burst_we),
|
|
*handle_ad_for_burst,
|
|
ack_o_n.eq(1),
|
|
NextValue(ctr, 0),
|
|
If(burst_we,
|
|
NextState("Burst4DatCycleTM0"),
|
|
).Else(
|
|
NextState("Burst4ReadWaitForTM0"),
|
|
)
|
|
)
|
|
|
|
if (burst_size == 4):
|
|
handle_buffer_read_for_burst = [
|
|
Case(ctr, {
|
|
0x0: NextValue(fifo_buffer[ 0: 32], sampled_ad),
|
|
0x1: NextValue(fifo_buffer[32: 64], sampled_ad),
|
|
0x2: NextValue(fifo_buffer[64: 96], sampled_ad),
|
|
#0x3: NextValue(fifo_buffer[96:128], sampled_ad),
|
|
#0x0: NextValue(fifo_buffer[ 0: 32], sampled_ad_byterev),
|
|
#0x1: NextValue(fifo_buffer[32: 64], sampled_ad_byterev),
|
|
#0x2: NextValue(fifo_buffer[64: 96], sampled_ad_byterev),
|
|
##0x3: NextValue(fifo_buffer[96:128], sampled_ad_byterev),
|
|
}),
|
|
]
|
|
handle_final_buffer_read_for_burst = [
|
|
fromsbus_fifo_din.data.eq(Cat(fifo_buffer[0:96], sampled_ad)), # we use sampled_ad directly for 96:128
|
|
]
|
|
elif (burst_size == 8):
|
|
handle_buffer_read_for_burst = [
|
|
Case(ctr, {
|
|
0x0: NextValue(fifo_buffer[ 0: 32], sampled_ad),
|
|
0x1: NextValue(fifo_buffer[ 32: 64], sampled_ad),
|
|
0x2: NextValue(fifo_buffer[ 64: 96], sampled_ad),
|
|
0x3: NextValue(fifo_buffer[ 96:128], sampled_ad),
|
|
0x4: NextValue(fifo_buffer[128:160], sampled_ad),
|
|
0x5: NextValue(fifo_buffer[160:192], sampled_ad),
|
|
0x6: NextValue(fifo_buffer[192:224], sampled_ad),
|
|
#0x7: NextValue(fifo_buffer[224:256], sampled_ad),
|
|
}),
|
|
]
|
|
handle_final_buffer_read_for_burst = [
|
|
fromsbus_fifo_din.data.eq(Cat(fifo_buffer[0:224], sampled_ad)), # we use sampled_ad directly for 224:256
|
|
]
|
|
else:
|
|
raise ValueError(f"Unsupported burst_size {burst_size}")
|
|
|
|
dma_fsm.act("Burst4ReadWaitForTM0",
|
|
master_oe.eq(1), # for start
|
|
start_o_n.eq(1), # start finished, but still need to be driven
|
|
If(sampled_ack, # oups
|
|
fromsbus_req_fifo.re.eq(1), # remove request to avoid infinite repeat
|
|
#NextValue(led0, 1),
|
|
#NextValue(led1, 1),
|
|
NextState("FinishCycle"),
|
|
).Elif(sampled_tm0,
|
|
*handle_buffer_read_for_burst,
|
|
NextValue(ctr, ctr + 1),
|
|
If(ctr == (burst_size - 2), # burst next-to-last
|
|
NextState("Burst4ReadWaitForAck"),
|
|
).Else(
|
|
NextState("Burst4ReadWaitForTM0"),
|
|
)
|
|
)
|
|
)
|
|
dma_fsm.act("Burst4ReadWaitForAck",
|
|
master_oe.eq(1), # for start
|
|
start_o_n.eq(1), # start finished, but still need to be driven
|
|
If(sampled_ack,
|
|
fromsbus_req_fifo.re.eq(1), # remove request
|
|
fromsbus_fifo.we.eq(1),
|
|
fromsbus_fifo_din.blkaddress.eq(fifo_blk_addr),
|
|
*handle_final_buffer_read_for_burst,
|
|
# fixme: check status ??? (tm0 and tm1 should be active for no-error)
|
|
#NextValue(led0, (~sampled_tm0 | ~sampled_tm1)),
|
|
NextState("FinishCycle"),
|
|
)
|
|
)
|
|
|
|
|
|
if (burst_size == 4):
|
|
handle_buffer_write_for_burst = [
|
|
Case(ctr, {
|
|
0x0: ad_o_n.eq(~tosbus_fifo_dout.data[ 0: 32]),
|
|
0x1: ad_o_n.eq(~tosbus_fifo_dout.data[32: 64]),
|
|
0x2: ad_o_n.eq(~tosbus_fifo_dout.data[64: 96]),
|
|
##0x3: ad_o_n.eq(~tosbus_fifo_dout.data[96:128]),
|
|
#0x0: ad_o_n.eq(~tosbus_fifo_dout_data_byterev[ 0: 32]),
|
|
#0x1: ad_o_n.eq(~tosbus_fifo_dout_data_byterev[32: 64]),
|
|
#0x2: ad_o_n.eq(~tosbus_fifo_dout_data_byterev[64: 96]),
|
|
##0x3: ad_o_n.eq(~tosbus_fifo_dout_data_byterev[96:128]),
|
|
}),
|
|
]
|
|
handle_last_buffer_write_for_burst = [
|
|
ad_o_n.eq(~tosbus_fifo_dout.data[96:128]), # last word
|
|
]
|
|
elif (burst_size == 8):
|
|
handle_buffer_write_for_burst = [
|
|
Case(ctr, {
|
|
0x0: ad_o_n.eq(~tosbus_fifo_dout.data[ 0: 32]),
|
|
0x1: ad_o_n.eq(~tosbus_fifo_dout.data[ 32: 64]),
|
|
0x2: ad_o_n.eq(~tosbus_fifo_dout.data[ 64: 96]),
|
|
0x3: ad_o_n.eq(~tosbus_fifo_dout.data[ 96:128]),
|
|
0x4: ad_o_n.eq(~tosbus_fifo_dout.data[128:160]),
|
|
0x5: ad_o_n.eq(~tosbus_fifo_dout.data[160:192]),
|
|
0x6: ad_o_n.eq(~tosbus_fifo_dout.data[192:224]),
|
|
#0x7: ad_o_n.eq(~tosbus_fifo_dout.data[224:256]),
|
|
}),
|
|
]
|
|
handle_last_buffer_write_for_burst = [
|
|
ad_o_n.eq(~tosbus_fifo_dout.data[224:256]), # last word
|
|
]
|
|
else:
|
|
raise ValueError(f"Unsupported burst_size {burst_size}")
|
|
|
|
dma_fsm.act("Burst4DatCycleTM0",
|
|
master_oe.eq(1), # for start
|
|
ad_oe.eq(1), # for write data
|
|
start_o_n.eq(1), # start finished, but still need to be driven
|
|
*handle_buffer_write_for_burst,
|
|
If(sampled_ack, # oups
|
|
#NextValue(led0, 1),
|
|
#NextValue(led1, 1),
|
|
tosbus_fifo.re.eq(1), # remove FIFO entry to avoid infinite repeat
|
|
NextState("FinishCycle"),
|
|
).Elif(sampled_tm0,
|
|
NextValue(ctr, ctr + 1),
|
|
If(ctr == (burst_size - 2), # burst next-to-last
|
|
NextState("Burst4DatCycleAck"),
|
|
).Else(
|
|
NextState("Burst4DatCycleTM0"),
|
|
)
|
|
)
|
|
)
|
|
dma_fsm.act("Burst4DatCycleAck",
|
|
master_oe.eq(1), # for start
|
|
ad_oe.eq(1), # for write data
|
|
start_o_n.eq(1), # start finished, but still need to be driven
|
|
*handle_last_buffer_write_for_burst,
|
|
If(sampled_ack,
|
|
tosbus_fifo.re.eq(1), # remove FIFO entry at last
|
|
# fixme: check status ??? (tm0 and tm1 should be active for no-error)
|
|
#NextValue(led0, (~sampled_tm0 | ~sampled_tm1)),
|
|
NextState("FinishCycle"),
|
|
)
|
|
)
|
|
|
|
# stuff at this end so we don't use the signals inadvertantly
|
|
|
|
# real NuBus signals
|
|
nub_tm0n = platform.request("tm0_3v3_n") # V1.0: from CPLD ; V1.2: from shifters
|
|
nub_tm1n = platform.request("tm1_3v3_n") # V1.0: from CPLD ; V1.2: from shifters
|
|
nub_startn = platform.request("start_3v3_n") # V1.0: from CPLD ; V1.2: from shifters
|
|
nub_ackn = platform.request("ack_3v3_n") # V1.0: from CPLD ; V1.2: from shifters
|
|
nub_adn = platform.request("ad_3v3_n") # V1.0: from CPLD ; V1.2: from shifters
|
|
nub_idn = platform.request("id_3v3_n") # V1.0: from CPLD (4 bits) ; V1.2: from shifters (3 bits, /ID3 is always 0)
|
|
|
|
# idem between V1.0 and V1.2
|
|
self.specials += Tristate(nub_adn, ad_o_n, ad_oe, ad_i_n)
|
|
|
|
# Tri-state
|
|
if (version == "V1.0"):
|
|
# tri-state communication with CPLD
|
|
self.specials += Tristate(nub_tm0n, tm0_o_n, tmo_oe, tm0_i_n)
|
|
self.specials += Tristate(nub_tm1n, tm1_o_n, tmo_oe, tm1_i_n)
|
|
self.specials += Tristate(nub_ackn, ack_o_n, tmo_oe, ack_i_n)
|
|
self.specials += Tristate(nub_startn, start_o_n, master_oe, start_i_n)
|
|
elif (version == "V1.2"):
|
|
# input only
|
|
self.comb += [
|
|
tm0_i_n.eq(nub_tm0n),
|
|
tm1_i_n.eq(nub_tm1n),
|
|
ack_i_n.eq(nub_ackn),
|
|
start_i_n.eq(nub_startn),
|
|
]
|
|
else:
|
|
raise ValueError(f"Unsupported version {version}")
|
|
|
|
# input only
|
|
if (version == "V1.0"):
|
|
self.comb += [
|
|
id_i_n.eq(nub_idn),
|
|
]
|
|
elif (version == "V1.2"):
|
|
self.comb += [
|
|
id_i_n.eq(Cat(nub_idn, Signal(1, reset = 0))),
|
|
]
|
|
else:
|
|
raise ValueError(f"Unsupported version {version}")
|
|
|
|
|
|
# NubusFPGA-only signals
|
|
nf_nubus_ad_dir = platform.request("nubus_ad_dir") # to drivers
|
|
self.comb += [
|
|
nf_nubus_ad_dir.eq(~ad_oe),
|
|
]
|
|
|
|
if (version == "V1.0"):
|
|
nf_tmoen = platform.request("tmoen") # to cpld
|
|
self.comb += [
|
|
nf_tmoen.eq(~tmo_oe),
|
|
]
|
|
|
|
# real Nubus signal, for master
|
|
nub_rqstn = platform.request("rqst_3v3_n") # V1.0: from CPLD ; V1.2: from shifters
|
|
|
|
# Tri-state
|
|
if (version == "V1.0"):
|
|
# tri-state communication with CPLD
|
|
self.specials += Tristate(nub_rqstn, rqst_o_n, rqst_oe, rqst_i_n)
|
|
elif (version == "V1.2"):
|
|
# input only
|
|
self.comb += [
|
|
rqst_i_n.eq(nub_rqstn),
|
|
]
|
|
else:
|
|
raise ValueError(f"Unsupported version {version}")
|
|
|
|
# NubusFPGA-only signals, for master
|
|
if (version == "V1.0"):
|
|
nub_arbcy_n = platform.request("arbcy_n") # V1.0: from cpld
|
|
nf_grant = platform.request("grant") # V1.0: from cpld
|
|
nf_nubus_master_dir = platform.request("nubus_master_dir") # V1.0: to cpld
|
|
nf_fpga_to_cpld_signal = platform.request("fpga_to_cpld_signal") # V1.0: to cpld, 'rqstoen'
|
|
|
|
|
|
# NuBus90 signals, , for completeness
|
|
nub_clk2xn = ClockSignal(cd_nubus90)
|
|
nub_tm2n = platform.request("tm2_3v3_n") # V1.0: from CPLD ; V1.2: from shifters
|
|
|
|
if (version == "V1.0"):
|
|
self.comb += [
|
|
nf_nubus_master_dir.eq(master_oe),
|
|
nub_arbcy_n.eq(~start_arbitration),
|
|
grant.eq(nf_grant),
|
|
nf_fpga_to_cpld_signal.eq(~rqst_oe),
|
|
]
|
|
|
|
if (version == "V1.2"):
|
|
self.specials += Instance("nubus_cpldinfpga",
|
|
i_nubus_oe = soc.hold_reset, # improveme, handled in SoC
|
|
i_tmoen = ~tmo_oe,
|
|
i_nubus_master_dir = master_oe,
|
|
i_rqst_oe_n = ~rqst_oe,
|
|
|
|
i_id_n_3v3 = id_i_n, # input only
|
|
|
|
i_arbcy_n = ~start_arbitration,
|
|
i_arb_n_3v3 = platform.request("arb_3v3_n"), # arb only seen by cpld
|
|
o_arb_o_n = platform.request("arb_o_n"),
|
|
o_grant = grant,
|
|
|
|
i_tm0_n_3v3 = tm0_o_n, # tm0 driving controlled by tmoen
|
|
o_tm0_o_n = platform.request("tm0_o_n"),
|
|
|
|
i_tm1_n_3v3 = tm1_o_n, # tm1 driving controlled by tmoen
|
|
o_tm1_o_n = platform.request("tm1_o_n"),
|
|
o_tmx_oe_n = platform.request("tmx_oe_n"),
|
|
|
|
i_tm2_n_3v3 = nub_tm2n, # tm2 currently never driven
|
|
o_tm2_o_n = platform.request("tm2_o_n"),
|
|
o_tm2_oe_n = platform.request("tm2_oe_n"),
|
|
|
|
i_start_n_3v3 = start_o_n, # start driving enabled by nubus_master_dir
|
|
o_start_o_n = platform.request("start_o_n"),
|
|
o_start_oe_n = platform.request("start_oe_n"),
|
|
|
|
i_ack_n_3v3 = ack_o_n, # ack driving controlled by tmoen
|
|
o_ack_o_n = platform.request("ack_o_n"),
|
|
o_ack_oe_n = platform.request("ack_oe_n"),
|
|
|
|
i_rqst_n_3v3 = rqst_o_n, # rqst driving controller by rqst_oe_n
|
|
o_rqst_o_n = platform.request("rqst_o_n")
|
|
)
|
|
|
|
def add_sources(self, platform, version):
|
|
# sampling of data on falling edge of clock, done in verilog
|
|
platform.add_source("nubus_sampling.v", "verilog")
|
|
if (version == "V1.2"):
|
|
platform.add_source("nubus_arbiter.v", "verilog") # for CPLDinfpga
|
|
platform.add_source("nubus_cpldinfpga.v", "verilog") # internal now
|
|
|