from misoclib.mem.litesata.common import * from misoclib.mem.litesata.frontend.common import * class LiteSATAStripingTX(Module): """SATA Striping TX Split cmds and writes data on N different controllers. This module provides a mirroring_mode that is used by the mirroring module to dispatch identicals writes to the controllers. This avoid code duplication in between striping and mirroring modules. In this special case, port's data width is dw (same as controllers) """ def __init__(self, n, dw, mirroring_mode=False): self.sink = sink = Sink(command_tx_description(dw*n if not mirroring_mode else dw)) self.sources = sources = [Source(command_tx_description(dw)) for i in range(n)] # # # split = Signal() already_acked = Signal(n) self.sync += If(split & sink.stb, already_acked.eq(already_acked | Cat(*[s.ack for s in sources])), If(sink.ack, already_acked.eq(0)) ) self.fsm = fsm = FSM(reset_state="IDLE") self.submodules += fsm fsm.act("IDLE", sink.ack.eq(0), If(sink.stb & sink.sop, NextState("SPLIT") ).Else( sink.ack.eq(1) ) ) # split data and ctrl signals (except stb & ack managed in fsm) for i, s in enumerate(sources): self.comb += Record.connect(sink, s, leave_out=set(["stb", "ack", "data"])) if mirroring_mode: self.comb += s.data.eq(sink.data) else: self.comb += s.data.eq(sink.data[i*dw:(i+1)*dw]) fsm.act("SPLIT", split.eq(1), [s.stb.eq(sink.stb & ~already_acked[i]) for i, s in enumerate(sources)], sink.ack.eq(optree("&", [s.ack | already_acked[i] for i, s in enumerate(sources)])), If(sink.stb & sink.eop & sink.ack, NextState("IDLE") ) ) class LiteSATAStripingRX(Module): """SATA Striping RX Combine acknowledges and reads data from N different controllers. This module provides a mirroring_mode that is used by the mirroring module to dispatch identicals writes to the controllers. This avoid code duplication in between striping and mirroring modules. In this special case, port's data width is dw (same as controllers) """ def __init__(self, n, dw, mirroring_mode=False): self.sinks = sinks = [Sink(command_rx_description(dw)) for i in range(n)] self.source = source = Source(command_rx_description(dw*n if not mirroring_mode else dw)) # # # sop = Signal() self.comb += sop.eq(optree("&", [s.stb & s.sop for s in sinks])) self.fsm = fsm = FSM(reset_state="IDLE") self.submodules += fsm fsm.act("IDLE", If(sop, NextState("COMBINE") ) ) # use first sink for ctrl signals (except for stb, ack & failed) self.comb += Record.connect(sinks[0], source, leave_out=set(["stb", "ack", "failed", "data"])) # combine datas if mirroring_mode: self.comb += source.data.eq(0) # mirroring only used for writes else: for i, s in enumerate(sinks): self.comb += source.data[i*dw:(i+1)*dw].eq(s.data) fsm.act("COMBINE", source.failed.eq(optree("|", [s.failed for s in sinks])), # XXX verify this is enough source.stb.eq(optree("&", [s.stb for s in sinks])), [s.ack.eq(source.stb & source.ack) for s in sinks], If(source.stb & source.eop & source.ack, NextState("IDLE") ) ) class LiteSATAStriping(Module): """SATA Striping Segment data so that data is stored on N different controllers. +----> controller0 (dw) port (N*dw) <----+----> controllerX (dw) +----> controllerN (dw) Characteristics: - port's visible capacity = N x controller's visible capacity - port's throughput = N x (slowest) controller's throughput Can be used to increase capacity and writes/reads throughput. """ def __init__(self, controllers): # # # n = len(controllers) dw = flen(controllers[0].sink.data) self.submodules.tx = LiteSATAStripingTX(n, dw) self.submodules.rx = LiteSATAStripingRX(n, dw) for i in range(n): self.comb += [ Record.connect(self.tx.sources[i], controllers[i].sink), Record.connect(controllers[i].source, self.rx.sinks[i]) ] self.sink, self.source = self.tx.sink, self.rx.source