eb001/src/main/scala/backBoard/ebus/CDRIn.scala

package BACK

import chisel3._
import chisel3.util._


//work in 100MHZ
class CDRInIO extends Bundle{
  val axis = Decoupled(new AXIS_Bundle(8))
  val serDat = Input(Bool())

}


abstract class CDRInBase extends Module{


  val io: CDRInIO = IO(new CDRInIO)


  val syncSerDat = Wire(Bool())
}

trait CDRInOverSample{ this: CDRInBase =>

  val overCLK = IO(Input(Bool()))
  val sampleRate: Int = 4
  require(sampleRate >= 4)

  val sampleReg = withClockAndReset(overCLK.asClock, reset.asBool){ ShiftRegisters( RegNext(io.serDat), sampleRate+3 ) }

  val flitReg = for( i <- 0 until sampleRate ) yield {
    withClockAndReset(overCLK.asClock, reset.asBool){
      RegNext(
        (sampleReg(i) & sampleReg(i+1)) |
        (sampleReg(i) & sampleReg(i+2)) |
        (sampleReg(i+1) & sampleReg(i+2)), false.B
      )
    }
  }

  val arbCnt  = withClockAndReset(overCLK.asClock, reset.asBool){ RegInit("b00000001".U(sampleRate.W)) }
  arbCnt := Cat( arbCnt(sampleRate-2,0), arbCnt.extract(sampleRate-1) )
  val arbLock = withClockAndReset(overCLK.asClock, reset.asBool){ RegInit("b00000001".U(sampleRate.W)) }
  withClockAndReset(overCLK.asClock, reset.asBool){
    when( flitReg(0) ^ flitReg(1) ){
      arbLock := arbCnt
    }


  }

  val asyncSerDat = withClockAndReset(overCLK.asClock, reset.asBool){ RegNext(
    Mux1H(
      (for { i <- 0 until sampleRate; j <- 0 until sampleRate } yield {
        //跳变沿到来锁定的位置        锁定拍当前所在的位置          选择锁定拍后一拍的值认为是正确值
        ((arbLock === (1.U << i)) & (arbCnt === (1.U << j))) -> flitReg((sampleRate + 2 - i + j) % sampleRate)
      })
    )
  )}


  syncSerDat := ShiftRegister( asyncSerDat, 2 )

}

trait CDRInMultiSample{ this: CDRInBase =>
  
  val clkNum: Int = 16


  //multiCLK 需要按照滞后相位接线，即0为最先到达，1次先
  val multiCLK = IO(Input(Vec(16, Bool())))

  // val sampleReg = withClockAndReset(io.overCLK.asClock, reset.asBool){ ShiftRegisters( RegNext(io.serDat), sampleRate ) }
  val sampleReg = for( i <- 0 until 16 ) yield {
    withClockAndReset(multiCLK(i).asClock, reset.asBool){ ShiftRegister( io.serDat, 2 ) }
  }


  val flitReg = for( i <- 0 until 16 ) yield {
    if( i == 0 ) {
      (sampleReg(15) & sampleReg(0)) |
      (sampleReg(15) & sampleReg(1)) |
      (sampleReg(0)  & sampleReg(1))
    } else if ( i > 0 && i < 15 ){
      (sampleReg(i-1) & sampleReg(i))   |
      (sampleReg(i-1) & sampleReg(i+1)) |
      (sampleReg(i)   & sampleReg(i+1))  
    } else// ( i == 15 )
      (sampleReg(14) & sampleReg(15)) |
      (sampleReg(14) & sampleReg(0))  |
      (sampleReg(15) & sampleReg(0)) 
  }

  val arbLock = Reg(UInt( 16.W ))

  //优先级电路，优先选择跳变的后一相进行操作，电路上需要做成可调的
  when( flitReg(0) ^ flitReg(1) ){
    arbLock := "b1".U(16.W) << 2
  } .elsewhen( flitReg(1) ^ flitReg(2) ){
    arbLock := "b1".U(16.W) << 3
  } .elsewhen( flitReg(2) ^ flitReg(3) ){
    arbLock := "b1".U(16.W) << 4
  } .elsewhen( flitReg(3) ^ flitReg(4) ){
    arbLock := "b1".U(16.W) << 5
  } .elsewhen( flitReg(4) ^ flitReg(5) ){
    arbLock := "b1".U(16.W) << 6
  } .elsewhen( flitReg(5) ^ flitReg(6) ){
    arbLock := "b1".U(16.W) << 7
  } .elsewhen( flitReg(6) ^ flitReg(7) ){
    arbLock := "b1".U(16.W) << 8
  } .elsewhen( flitReg(7) ^ flitReg(8) ){
    arbLock := "b1".U(16.W) << 9
  } .elsewhen( flitReg(8) ^ flitReg(9) ){
    arbLock := "b1".U(16.W) << 10
  } .elsewhen( flitReg(9) ^ flitReg(10) ){
    arbLock := "b1".U(16.W) << 11
  } .elsewhen( flitReg(10) ^ flitReg(11) ){
    arbLock := "b1".U(16.W) << 12
  } .elsewhen( flitReg(11) ^ flitReg(12) ){
    arbLock := "b1".U(16.W) << 13
  } .elsewhen( flitReg(12) ^ flitReg(13) ){
    arbLock := "b1".U(16.W) << 14
  } .elsewhen( flitReg(13) ^ flitReg(14) ){
    arbLock := "b1".U(16.W) << 15
  } .elsewhen( flitReg(14) ^ flitReg(15) ){
    arbLock := "b1".U(16.W) << 0
  } .elsewhen( flitReg(15) ^ flitReg(0) ){
    arbLock := "b1".U(16.W) << 1
  } 

  val asyncSerDat = 
    Mux1H(
      (for { i <- 0 until clkNum } yield {
        (arbLock === (1.U << i)) -> flitReg(i)
      })
    )

  syncSerDat := ShiftRegister( asyncSerDat, 2 )

}



trait CDRInAxis{ this: CDRInBase =>

  def HeaderByte: Int = 4

  val ETH_PRE = "b1100010001".U(10.W)
  val ETH_SFD = "b0110100111".U(10.W)

  val STATE_IDLE = 0.U
  val STATE_HEADER = 1.U
  val STATE_PAYLOAD = 2.U

  val stateNext = Wire(UInt(2.W))
  val stateCurr = RegNext( stateNext, STATE_IDLE )

  val bitCnt = Reg(UInt(4.W))
  val byteCnt = RegInit(0.U((12+1).W))

  val checkSFD = RegInit( 0.U(20.W) ); checkSFD := Cat( checkSFD(18,0), syncSerDat )

  val shiftData = Dualb4b5Decoder(checkSFD(9,0))

  val payloadLen = RegInit(0.U(12.W))
  when( byteCnt === 0.U & bitCnt === 9.U & stateCurr === STATE_HEADER ){
    payloadLen := Cat( shiftData, 0.U(4.W) )
  } .elsewhen( byteCnt === 1.U & bitCnt === 9.U & stateCurr === STATE_HEADER ){
    payloadLen := Cat( payloadLen(11,4), shiftData(7,4) )
  }
  
  stateNext := 
    Mux1H(Seq(
      (stateCurr === STATE_IDLE)    -> ( Mux( checkSFD === Cat(ETH_PRE , ETH_SFD), STATE_HEADER, STATE_IDLE )), //IDLE
      (stateCurr === STATE_HEADER)  -> ( Mux( (byteCnt === (HeaderByte-1).U)   & (bitCnt === 9.U), STATE_PAYLOAD, STATE_HEADER ) ),
      (stateCurr === STATE_PAYLOAD) -> ( Mux( (byteCnt === (payloadLen + (4 - 1).U)  ) & (bitCnt === 9.U), STATE_IDLE, STATE_PAYLOAD  )), // PAYLOAD
    ))                                                                  //crc





  when( stateCurr === STATE_IDLE & ( checkSFD === Cat(ETH_PRE, ETH_SFD) ) ){ //first align
    bitCnt := 0.U
  } .otherwise{
    when( bitCnt === 9.U ){
      bitCnt := 0.U
    } .otherwise{
      bitCnt := bitCnt + 1.U
    }
  }

  when( stateCurr === STATE_IDLE & ( checkSFD === Cat(ETH_PRE, ETH_SFD) ) ){ //first align
    byteCnt := 0.U
  } .elsewhen( bitCnt === 9.U ){
    when( stateCurr === STATE_HEADER ){
      byteCnt := Mux( byteCnt =/= (HeaderByte-1).U, byteCnt + 1.U, 0.U )
      assert( byteCnt <= (HeaderByte-1).U )
    } .elsewhen( stateCurr === STATE_PAYLOAD ){
      byteCnt := Mux( byteCnt =/= (payloadLen+ (4-1).U), byteCnt + 1.U, 0.U )
      assert( byteCnt <= ( payloadLen+ (4-1).U ) )
    }
  }





  val axis_valid = RegInit(false.B)
  val axis_tdata = RegEnable( shiftData, bitCnt === 9.U & ( stateCurr === STATE_HEADER | stateCurr === STATE_PAYLOAD ) )
  val axis_tuser = false.B
  val axis_tlast = RegNext( stateCurr === STATE_PAYLOAD & stateNext === STATE_IDLE, false.B )

  io.axis.valid := axis_valid
  io.axis.bits.tdata := axis_tdata
  io.axis.bits.tuser := axis_tuser
  io.axis.bits.tlast := axis_tlast


  when( io.axis.fire ){
    axis_valid := false.B
  } .elsewhen( bitCnt === 9.U & ( stateCurr === STATE_HEADER | stateCurr === STATE_PAYLOAD ) ){
    axis_valid := true.B
  }

}

class CDRIn extends CDRInBase 
with CDRInAxis
with CDRInOverSample

class MPCDRIn extends CDRInBase 
with CDRInAxis
with CDRInMultiSample