648 lines
16 KiB
Scala
648 lines
16 KiB
Scala
package BACK
|
|
|
|
import chisel3._
|
|
import chisel3.util._
|
|
|
|
|
|
|
|
|
|
class FSMC_Port_Bundle extends Bundle{
|
|
|
|
val ADIn = Input(UInt(16.W))
|
|
val ADOut = Output(UInt(16.W))
|
|
val ADOEn = Output(Bool())
|
|
val csn = Input(Bool())
|
|
val rdn = Input(Bool())
|
|
val wrn = Input(Bool())
|
|
val advn = Input(Bool())
|
|
}
|
|
|
|
class LVDS_MST_Bundle extends Bundle{
|
|
val frame_info_update_en = Output(Bool())
|
|
val slave_type_num = Output(UInt(8.W))
|
|
val slave_data_length = Output(UInt(8.W))
|
|
val tx_start = Output(Bool())
|
|
|
|
val slave_link_num_valid = Input(Bool())
|
|
val slave_link_num = Input(UInt(7.W))
|
|
|
|
val downstream_busy = Input(Bool())
|
|
val upstream_crc_valid = Input(Bool())
|
|
|
|
val closed_loop_err = Input(Bool())
|
|
val link_err_location = Input(UInt(7.W))
|
|
|
|
val upstream_cdr_err = Input(Bool())
|
|
val upstream_crc_err = Input(Bool())
|
|
|
|
val tx_data_ready = Input(Bool())
|
|
val tx_data_in = Output(UInt(8.W))
|
|
val rx_data_valid = Input(Bool())
|
|
val rx_data_out = Input(UInt(8.W))
|
|
}
|
|
|
|
|
|
|
|
class BackBoardMstIO extends Bundle{
|
|
val FSMC = new FSMC_Port_Bundle
|
|
|
|
val oser_pclk = Input(Bool()) //10M
|
|
val oser_fclk = Input(Bool()) //50M
|
|
val ides_pclk = Input(Bool()) //100M
|
|
val ides_fclk = Input(Bool()) //400M
|
|
|
|
|
|
val interrupt = Output(Bool())
|
|
|
|
val testIO = Input(Bool())
|
|
|
|
val lvdsMst = new LVDS_MST_Bundle
|
|
|
|
}
|
|
|
|
class BackBoardMstBase extends Module{ //10M
|
|
|
|
def OPERATORADDR = 0.U
|
|
def STATUSINITADDR = 1.U
|
|
def STATUSSYNCHADDR = 2.U
|
|
def STATUSTRANSADDR = 3.U
|
|
def STATUSUNICASTADDR = 4.U
|
|
def SLVNUMADDR = 5.U
|
|
def SLVDATALENADDR = 6.U
|
|
def SLVLINKNUMADDR = 7.U
|
|
def LINKERRLOCADDR = 8.U
|
|
def STATUSLINKERRADDR = 9.U
|
|
def STATUSCDRERRADDR = 10.U
|
|
def STATUSCRCERRADDR = 11.U
|
|
|
|
|
|
val io: BackBoardMstIO = IO(new BackBoardMstIO)
|
|
|
|
val mirrorDown = Module(new MirrorSRAMDP())
|
|
val mirrorUp = Module(new MirrorSRAMDP())
|
|
val mirrorReg = Module(new MirrorSRAMDP())
|
|
|
|
mirrorReg.io.addrB := DontCare
|
|
mirrorReg.io.datawB := DontCare
|
|
mirrorReg.io.enwB := false.B
|
|
mirrorReg.io.enrB := false.B
|
|
|
|
assert( ~(mirrorReg.io.enwA & mirrorReg.io.enrA) )
|
|
assert( ~(mirrorReg.io.enwB & mirrorReg.io.enrB) )
|
|
|
|
val ctrlTransmit = RegInit( false.B )
|
|
val ctrlUnicast = RegInit( false.B )
|
|
val ctrlSynch = RegInit( false.B )
|
|
val ctrlInit = RegInit( false.B )
|
|
|
|
val slvNum = RegInit(0.U(6.W))
|
|
val interrupt = RegInit(false.B); io.interrupt := interrupt
|
|
val slaveDataLength = Reg(UInt(8.W)) //(8/8)*32-1
|
|
|
|
|
|
|
|
|
|
|
|
mirrorDown.io.clockA := io.ides_pclk.asBool //100M
|
|
mirrorDown.io.clockB := io.oser_pclk.asBool
|
|
|
|
mirrorUp.io.clockA := io.ides_pclk.asBool //100M
|
|
mirrorUp.io.clockB := io.oser_pclk.asBool
|
|
|
|
mirrorReg.io.clockA := io.ides_pclk.asBool //100M
|
|
mirrorReg.io.clockB := io.oser_pclk.asBool //10M
|
|
|
|
when(interrupt === true.B){
|
|
interrupt := false.B
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
trait BackBoardMstFSMC{ this: BackBoardMstBase =>
|
|
|
|
withClockAndReset( io.ides_pclk.asClock, reset ){//100M
|
|
|
|
io.FSMC.ADOEn := ~io.FSMC.rdn & ~io.FSMC.csn & io.FSMC.advn
|
|
|
|
val latchAddr = RegEnable( io.FSMC.ADIn, ~io.FSMC.advn & ~io.FSMC.csn)
|
|
|
|
val isAccessSRAM = ~latchAddr.extract(11)
|
|
val isAccessReg = latchAddr.extract(11)
|
|
val isAccessDown = ~latchAddr.extract(10)
|
|
val activeAddr = latchAddr(9,0)
|
|
|
|
mirrorDown.io.addrA := activeAddr
|
|
mirrorDown.io.datawA := io.FSMC.ADIn
|
|
mirrorDown.io.enwA := isAccessSRAM & ~io.FSMC.csn & ~io.FSMC.wrn & isAccessDown
|
|
mirrorDown.io.enrA := isAccessSRAM & ~io.FSMC.csn & ~io.FSMC.rdn & isAccessDown
|
|
|
|
mirrorUp.io.addrA := activeAddr
|
|
mirrorUp.io.datawA := io.FSMC.ADIn
|
|
mirrorUp.io.enwA := isAccessSRAM & ~io.FSMC.csn & ~io.FSMC.wrn & ~isAccessDown
|
|
mirrorUp.io.enrA := isAccessSRAM & ~io.FSMC.csn & ~io.FSMC.rdn & ~isAccessDown
|
|
|
|
mirrorReg.io.addrA := activeAddr
|
|
mirrorReg.io.datawA := io.FSMC.ADIn
|
|
mirrorReg.io.enwA := isAccessReg & ~io.FSMC.csn & ~io.FSMC.wrn
|
|
mirrorReg.io.enrA := isAccessReg & ~io.FSMC.csn & ~io.FSMC.rdn
|
|
|
|
io.FSMC.ADOut := Mux( isAccessReg, mirrorReg.io.datarA, Mux( isAccessDown, mirrorDown.io.datarA, mirrorUp.io.datarA) )
|
|
|
|
|
|
}
|
|
|
|
//10M
|
|
val testIOShift = ShiftRegisters(io.testIO, 3, false.B, true.B)
|
|
when(~testIOShift(0) & io.testIO){
|
|
|
|
mirrorReg.io.addrB := OPERATORADDR
|
|
mirrorReg.io.enrB := true.B
|
|
} .elsewhen( ~testIOShift(1) & testIOShift(0)){
|
|
when( mirrorReg.io.datarB === 0.U ){
|
|
ctrlInit := true.B
|
|
}
|
|
|
|
when( mirrorReg.io.datarB === 1.U ){
|
|
ctrlSynch := true.B
|
|
}
|
|
|
|
when( mirrorReg.io.datarB === 5.U ){
|
|
ctrlTransmit := true.B
|
|
}
|
|
|
|
when( mirrorReg.io.datarB === 6.U ){
|
|
ctrlUnicast := true.B
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
abstract class BackBoardMstLVDSBase extends BackBoardMstBase
|
|
with BackBoardMstFSMC
|
|
{
|
|
|
|
|
|
val frame_info_update_en = RegInit(false.B)
|
|
val slave_type_num = RegInit(0.U(8.W))
|
|
|
|
val tx_start = RegInit(false.B)
|
|
|
|
io.lvdsMst.frame_info_update_en := frame_info_update_en
|
|
io.lvdsMst.slave_type_num := slave_type_num
|
|
io.lvdsMst.slave_data_length := slaveDataLength
|
|
io.lvdsMst.tx_start := tx_start
|
|
|
|
val stateCur = RegInit(15.U(4.W))
|
|
|
|
|
|
}
|
|
|
|
|
|
trait BackBoardMstLVDSInit{ this: BackBoardMstLVDSBase =>
|
|
|
|
val isInitStart = ~RegNext(ctrlInit, false.B) & ctrlInit
|
|
val timeoutCnt = Reg(UInt(13.W))
|
|
|
|
when(ctrlInit){
|
|
when( isInitStart ){
|
|
|
|
stateCur := 0.U
|
|
frame_info_update_en := false.B
|
|
slave_type_num := 0.U
|
|
tx_start := false.B
|
|
|
|
} .elsewhen( stateCur === 0.U ){
|
|
stateCur := 1.U
|
|
|
|
// write statusInit
|
|
mirrorReg.io.addrB := STATUSINITADDR
|
|
mirrorReg.io.datawB := 0.U
|
|
mirrorReg.io.enwB := true.B
|
|
} .elsewhen( stateCur === 1.U ){
|
|
stateCur := 2.U
|
|
|
|
//req slvnum
|
|
mirrorReg.io.addrB := SLVNUMADDR
|
|
mirrorReg.io.enrB := true.B
|
|
|
|
} .elsewhen( stateCur === 2.U ){
|
|
stateCur := 3.U
|
|
|
|
//lock slvNum
|
|
slvNum := mirrorReg.io.datarB
|
|
|
|
//req slaveDataLength
|
|
mirrorReg.io.addrB := SLVDATALENADDR
|
|
mirrorReg.io.enrB := true.B
|
|
|
|
}
|
|
.elsewhen( stateCur === 3.U ){
|
|
stateCur := 4.U
|
|
|
|
//lock slaveDataLength
|
|
slaveDataLength := mirrorReg.io.datarB
|
|
|
|
frame_info_update_en := true.B
|
|
slave_type_num := Cat( "b00".U(2.W), slvNum )
|
|
|
|
tx_start := false.B
|
|
} .elsewhen( stateCur === 4.U ){ // tx start
|
|
stateCur := 5.U
|
|
timeoutCnt := 0.U
|
|
|
|
frame_info_update_en := false.B
|
|
tx_start := true.B
|
|
|
|
} .elsewhen( stateCur === 5.U ){
|
|
tx_start := false.B
|
|
timeoutCnt := timeoutCnt + 1.U
|
|
|
|
when( io.lvdsMst.slave_link_num_valid ){
|
|
stateCur := 6.U
|
|
|
|
//linkNum
|
|
mirrorReg.io.addrB := SLVLINKNUMADDR
|
|
mirrorReg.io.datawB := io.lvdsMst.slave_link_num
|
|
mirrorReg.io.enwB := true.B
|
|
|
|
}
|
|
|
|
when( timeoutCnt === 6000.U ){
|
|
stateCur := 6.U
|
|
|
|
//linkNum
|
|
mirrorReg.io.addrB := SLVLINKNUMADDR
|
|
mirrorReg.io.datawB := 0.U
|
|
mirrorReg.io.enwB := true.B
|
|
|
|
}
|
|
|
|
|
|
|
|
} .elsewhen( stateCur === 6.U ){
|
|
stateCur := 7.U
|
|
|
|
//statusInit
|
|
mirrorReg.io.addrB := STATUSINITADDR
|
|
mirrorReg.io.datawB := 1.U
|
|
mirrorReg.io.enwB := true.B
|
|
|
|
ctrlInit := false.B
|
|
ctrlSynch := false.B
|
|
ctrlTransmit := false.B
|
|
ctrlUnicast := false.B
|
|
interrupt := true.B
|
|
|
|
} .elsewhen( stateCur === 7.U ){
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
trait BackBoardMstLVDSSync{ this: BackBoardMstLVDSBase =>
|
|
val isSyncStart = ~RegNext( ctrlSynch, false.B) & ctrlSynch
|
|
|
|
when( ctrlSynch ){
|
|
when( isSyncStart ){
|
|
stateCur := 0.U
|
|
frame_info_update_en := false.B
|
|
slave_type_num := 0.U
|
|
tx_start := false.B
|
|
|
|
} .elsewhen( stateCur === 0.U ){ //statusSynch
|
|
stateCur := 1.U
|
|
|
|
mirrorReg.io.addrB := STATUSSYNCHADDR
|
|
mirrorReg.io.datawB := 0.U
|
|
mirrorReg.io.enwB := true.B
|
|
} .elsewhen( stateCur === 1.U ){
|
|
stateCur := 2.U
|
|
|
|
//req slvnum
|
|
mirrorReg.io.addrB := SLVNUMADDR
|
|
mirrorReg.io.enrB := true.B
|
|
|
|
|
|
} .elsewhen( stateCur === 2.U ){ //slaveDataLength
|
|
stateCur := 3.U
|
|
|
|
//lock slvNum
|
|
slvNum := mirrorReg.io.datarB
|
|
|
|
//slaveDataLength
|
|
mirrorReg.io.addrB := SLVDATALENADDR
|
|
mirrorReg.io.enrB := true.B
|
|
|
|
|
|
} .elsewhen( stateCur === 3.U ){
|
|
stateCur := 4.U
|
|
|
|
//lock slaveDataLength
|
|
slaveDataLength := mirrorReg.io.datarB
|
|
|
|
frame_info_update_en := true.B
|
|
slave_type_num := Cat( "b01".U(2.W), slvNum )
|
|
|
|
tx_start := false.B
|
|
} .elsewhen( stateCur === 4.U ){ // tx start
|
|
stateCur := 5.U
|
|
|
|
frame_info_update_en := false.B
|
|
tx_start := true.B
|
|
|
|
} .elsewhen( stateCur === 5.U ){
|
|
|
|
tx_start := false.B
|
|
|
|
when( RegNext(io.lvdsMst.downstream_busy, false.B) & ~io.lvdsMst.downstream_busy ){
|
|
stateCur := 6.U
|
|
|
|
//statusSync
|
|
mirrorReg.io.addrB := STATUSSYNCHADDR
|
|
mirrorReg.io.datawB := 1.U
|
|
mirrorReg.io.enwB := true.B
|
|
|
|
ctrlSynch := false.B
|
|
interrupt := true.B
|
|
}
|
|
|
|
} .otherwise{
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
trait BackBoardMstLVDSTransmit{ this: BackBoardMstLVDSBase =>
|
|
|
|
val isTransStart = ctrlTransmit & ~RegNext(ctrlTransmit, false.B)
|
|
|
|
when(ctrlTransmit){
|
|
when( isTransStart ){ //reset
|
|
stateCur := 0.U
|
|
|
|
frame_info_update_en := false.B
|
|
slave_type_num := 0.U
|
|
|
|
tx_start := false.B
|
|
|
|
|
|
} .elsewhen( stateCur === 0.U ){ //statusTransmit
|
|
stateCur := 1.U
|
|
|
|
mirrorReg.io.addrB := STATUSTRANSADDR
|
|
mirrorReg.io.datawB := 0.U
|
|
mirrorReg.io.enwB := true.B
|
|
} .elsewhen( stateCur === 1.U ){ //slvnum
|
|
stateCur := 2.U
|
|
|
|
mirrorReg.io.addrB := SLVNUMADDR
|
|
mirrorReg.io.enrB := true.B
|
|
|
|
} .elsewhen( stateCur === 2.U ){ //slaveDataLength
|
|
stateCur := 3.U
|
|
|
|
//lock slvNum
|
|
slvNum := mirrorReg.io.datarB
|
|
|
|
mirrorReg.io.addrB := SLVDATALENADDR
|
|
mirrorReg.io.enrB := true.B
|
|
|
|
} .elsewhen( stateCur === 3.U ){ //setting
|
|
stateCur := 4.U
|
|
|
|
//lock slaveDataLength
|
|
slaveDataLength := mirrorReg.io.datarB
|
|
|
|
frame_info_update_en := true.B
|
|
slave_type_num := Cat( "b10".U(2.W), slvNum )
|
|
|
|
tx_start := false.B
|
|
} .elsewhen( stateCur === 4.U ){ // tx start
|
|
stateCur := 5.U
|
|
|
|
frame_info_update_en := false.B
|
|
tx_start := true.B
|
|
|
|
} .elsewhen( stateCur === 5.U ){ //waiting for busy drop
|
|
|
|
tx_start := false.B
|
|
|
|
when( RegNext(io.lvdsMst.downstream_busy, false.B) & ~io.lvdsMst.downstream_busy ){
|
|
stateCur := 6.U
|
|
}
|
|
|
|
} .elsewhen( stateCur === 6.U ){
|
|
when( io.lvdsMst.upstream_crc_valid ){
|
|
stateCur := 7.U
|
|
|
|
when( io.lvdsMst.upstream_crc_err ){
|
|
mirrorReg.io.addrB := STATUSCRCERRADDR
|
|
mirrorReg.io.datawB := 1.U
|
|
mirrorReg.io.enwB := true.B
|
|
}
|
|
}
|
|
} .elsewhen( stateCur === 7.U ){
|
|
stateCur := 8.U
|
|
|
|
//statusTransmit
|
|
mirrorReg.io.addrB := STATUSTRANSADDR
|
|
mirrorReg.io.datawB := 1.U
|
|
mirrorReg.io.enwB := true.B
|
|
|
|
ctrlTransmit := false.B
|
|
interrupt := true.B
|
|
}.elsewhen( stateCur === 8.U ){
|
|
|
|
} .otherwise{
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
trait BackBoardMstLVDSUnicast{ this: BackBoardMstLVDSBase =>
|
|
|
|
val isUnicast = ctrlUnicast & ~RegNext(ctrlUnicast, false.B)
|
|
|
|
when(ctrlUnicast){
|
|
when( isUnicast ){ //reset
|
|
stateCur := 0.U
|
|
|
|
frame_info_update_en := false.B
|
|
slave_type_num := 0.U
|
|
|
|
tx_start := false.B
|
|
|
|
|
|
} .elsewhen( stateCur === 0.U ){ //statusUnicast
|
|
stateCur := 1.U
|
|
|
|
mirrorReg.io.addrB := STATUSUNICASTADDR
|
|
mirrorReg.io.datawB := 0.U
|
|
mirrorReg.io.enwB := true.B
|
|
} .elsewhen( stateCur === 1.U ){ //slvnum
|
|
stateCur := 2.U
|
|
|
|
mirrorReg.io.addrB := SLVNUMADDR
|
|
mirrorReg.io.enrB := true.B
|
|
|
|
} .elsewhen( stateCur === 2.U ){ //slaveDataLength
|
|
stateCur := 3.U
|
|
|
|
//lock slvNum
|
|
slvNum := mirrorReg.io.datarB
|
|
|
|
mirrorReg.io.addrB := SLVDATALENADDR
|
|
mirrorReg.io.enrB := true.B
|
|
|
|
} .elsewhen( stateCur === 3.U ){ //setting
|
|
stateCur := 4.U
|
|
|
|
//lock slaveDataLength
|
|
slaveDataLength := mirrorReg.io.datarB
|
|
|
|
frame_info_update_en := true.B
|
|
slave_type_num := Cat( "b11".U(2.W), slvNum )
|
|
|
|
tx_start := false.B
|
|
} .elsewhen( stateCur === 4.U ){ // tx start
|
|
stateCur := 5.U
|
|
|
|
frame_info_update_en := false.B
|
|
tx_start := true.B
|
|
|
|
} .elsewhen( stateCur === 5.U ){ //waiting for busy drop
|
|
|
|
tx_start := false.B
|
|
|
|
when( RegNext(io.lvdsMst.downstream_busy, false.B) & ~io.lvdsMst.downstream_busy ){
|
|
stateCur := 6.U
|
|
}
|
|
|
|
} .elsewhen( stateCur === 6.U ){
|
|
when( io.lvdsMst.upstream_crc_valid ){
|
|
stateCur := 7.U
|
|
|
|
when( io.lvdsMst.upstream_crc_err ){
|
|
mirrorReg.io.addrB := STATUSCRCERRADDR
|
|
mirrorReg.io.datawB := 1.U
|
|
mirrorReg.io.enwB := true.B
|
|
}
|
|
|
|
}
|
|
} .elsewhen( stateCur === 7.U ){
|
|
stateCur := 8.U
|
|
|
|
//statusUnicast
|
|
mirrorReg.io.addrB := STATUSUNICASTADDR
|
|
mirrorReg.io.datawB := 1.U
|
|
mirrorReg.io.enwB := true.B
|
|
|
|
ctrlUnicast := false.B
|
|
interrupt := true.B
|
|
|
|
} .elsewhen( stateCur === 8.U ){
|
|
|
|
} .otherwise{
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
trait BackBoardMstLVDSError{ this: BackBoardMstLVDSBase =>
|
|
val shiftClosedLoopErr = ShiftRegisters( io.lvdsMst.closed_loop_err, 6, false.B, true.B )
|
|
when( ~shiftClosedLoopErr(0) & io.lvdsMst.closed_loop_err ){
|
|
mirrorReg.io.addrB := LINKERRLOCADDR
|
|
mirrorReg.io.datawB := io.lvdsMst.link_err_location(5,0)
|
|
mirrorReg.io.enwB := true.B
|
|
|
|
} .elsewhen( ~shiftClosedLoopErr(1) & shiftClosedLoopErr(0) ){
|
|
mirrorReg.io.addrB := STATUSLINKERRADDR
|
|
mirrorReg.io.datawB := 1.U
|
|
mirrorReg.io.enwB := true.B
|
|
|
|
} .elsewhen( ~shiftClosedLoopErr(2) & shiftClosedLoopErr(1) ){
|
|
mirrorReg.io.addrB := STATUSSYNCHADDR
|
|
mirrorReg.io.datawB := 1.U
|
|
mirrorReg.io.enwB := true.B
|
|
|
|
ctrlSynch := false.B
|
|
|
|
} .elsewhen( ~shiftClosedLoopErr(3) & shiftClosedLoopErr(2) ){
|
|
mirrorReg.io.addrB := STATUSTRANSADDR
|
|
mirrorReg.io.datawB := 1.U
|
|
mirrorReg.io.enwB := true.B
|
|
|
|
ctrlTransmit := false.B
|
|
|
|
} .elsewhen( ~shiftClosedLoopErr(4) & shiftClosedLoopErr(3) ){
|
|
mirrorReg.io.addrB := STATUSUNICASTADDR
|
|
mirrorReg.io.datawB := 1.U
|
|
mirrorReg.io.enwB := true.B
|
|
|
|
ctrlUnicast := false.B
|
|
} .elsewhen( ~shiftClosedLoopErr(5) & shiftClosedLoopErr(4) ){
|
|
interrupt := true.B
|
|
}
|
|
|
|
|
|
|
|
val shiftCDRErr = ShiftRegisters( io.lvdsMst.upstream_cdr_err, 2, false.B, true.B )
|
|
when( ~shiftCDRErr(0) & io.lvdsMst.upstream_cdr_err ){
|
|
mirrorReg.io.addrB := STATUSCDRERRADDR
|
|
mirrorReg.io.datawB := 1.U
|
|
mirrorReg.io.enwB := true.B
|
|
interrupt := true.B
|
|
}
|
|
|
|
}
|
|
|
|
class BackBoardMst extends BackBoardMstLVDSBase
|
|
with BackBoardMstLVDSInit
|
|
with BackBoardMstLVDSSync
|
|
with BackBoardMstLVDSTransmit
|
|
with BackBoardMstLVDSUnicast
|
|
with BackBoardMstLVDSError{
|
|
|
|
val addrr = RegInit(0.U(11.W))
|
|
val addrw = RegInit(0.U(11.W))
|
|
|
|
when( isTransStart | isUnicast ){
|
|
addrw := 0.U
|
|
} .elsewhen( io.lvdsMst.rx_data_valid & (ctrlTransmit | ctrlUnicast) ){
|
|
assert( (stateCur === 5.U) || (stateCur === 6.U) )
|
|
addrw := addrw + 1.U
|
|
}
|
|
|
|
when( isTransStart | isUnicast ){
|
|
addrr := 0.U
|
|
} .elsewhen( io.lvdsMst.tx_data_ready & (ctrlTransmit | ctrlUnicast) ){
|
|
addrr := addrr + 1.U
|
|
}
|
|
|
|
mirrorDown.io.enwB := false.B
|
|
mirrorDown.io.datawB := 0.U
|
|
mirrorDown.io.enrB := (stateCur === 4.U || stateCur === 5.U) & (ctrlTransmit | ctrlUnicast)
|
|
io.lvdsMst.tx_data_in := Mux( addrr.extract(0), mirrorDown.io.datarB(7,0), mirrorDown.io.datarB(15,8) )
|
|
mirrorDown.io.addrB := addrr >> 1
|
|
|
|
|
|
val rxData_lsb = RegEnable( io.lvdsMst.rx_data_out, io.lvdsMst.rx_data_valid & (ctrlTransmit | ctrlUnicast) & ~addrw.extract(0) )
|
|
mirrorUp.io.enrB := false.B
|
|
mirrorUp.io.enwB := io.lvdsMst.rx_data_valid & (ctrlTransmit | ctrlUnicast) & addrw.extract(0)
|
|
mirrorUp.io.datawB := Cat( io.lvdsMst.rx_data_out, rxData_lsb )
|
|
mirrorUp.io.addrB := addrw >> 1
|
|
|
|
}
|