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 BackBoardMstIO extends Bundle{
  val FSMC = new FSMC_Port_Bundle

val reset_calib = Input(Bool())
  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 lvds_down_dout = Output(Bool())
  val lvds_up_din    = Input(Bool())

  val interrupt = Output(Bool())

}

class BackBoardMstBase extends Module{ //10M
  val io: BackBoardMstIO = IO(new BackBoardMstIO)

  val lvdsMst = Module(new Lvds_Bus_Master)
  val mirrorDown = Module(new MirrorSRAMDown())
  val mirrorUp   = Module(new MirrorSRAMUp())

  val statusCDRErr  = RegInit( false.B )
  val statusCRCErr  = RegInit( false.B )
  val statusLinkErr = RegInit( false.B )
  val statusSynch   = RegInit( false.B )
  val statusInit    = RegInit( false.B )

  val ctrlTransmit = RegInit( false.B )
  val ctrlCDRErr   = RegInit( false.B )
  val ctrlCRCErr   = RegInit( false.B )
  val ctrlLinkErr  = RegInit( false.B )
  val ctrlSynch    = RegInit( false.B )
  val ctrlInit     = RegInit( false.B )

  val slvNum  = RegInit(0.U(6.W))
  val slvOffLine = RegInit(0.U(6.W))
  val linkNum = RegInit(0.U(7.W))
  val testReg = RegInit("haa55".U(16.W))
  val interrupt = RegInit(false.B); io.interrupt := interrupt
  val slaveDataLength    = RegInit(((8/8)*32-1).U(8.W))

  lvdsMst.io.rst_n       := ~reset.asBool
  lvdsMst.io.reset_calib := io.reset_calib
  lvdsMst.io.oser_pclk   := io.oser_pclk
  lvdsMst.io.oser_fclk   := io.oser_fclk
  lvdsMst.io.ides_pclk   := io.ides_pclk
  lvdsMst.io.ides_fclk   := io.ides_fclk

  io.lvds_down_dout      := lvdsMst.io.lvds_down_dout
  lvdsMst.io.lvds_up_din := io.lvds_up_din





  mirrorDown.io.clockr := io.oser_pclk.asBool
  mirrorDown.io.clockw := io.ides_pclk.asBool //100M  

  mirrorUp.io.clockw := io.oser_pclk.asBool
  mirrorUp.io.clockr := io.ides_pclk.asBool   //100M


  when(interrupt === true.B){
    interrupt := false.B
  }


}




trait BackBoardMstFSMC{ this: BackBoardMstBase =>

  val isReqValid       = withClockAndReset( io.ides_pclk.asClock, reset ){ RegInit(false.B) } //100M
  val isAckReady       = RegInit(false.B)
  val wrRegAddr        = withClockAndReset( io.ides_pclk.asClock, reset ){ Reg(UInt(10.W)) }  //100M
  val wrRegData        = withClockAndReset( io.ides_pclk.asClock, reset ){ Reg(UInt(16.W)) }  //100M

  withClockAndReset( io.ides_pclk.asClock, reset ){//100M


    // val fsmcCSSync  = ShiftRegisters( ~io.FSMC.csn,  3, false.B, true.B )
    // val fsmcRDSync  = ShiftRegisters( ~io.FSMC.rdn,  3, false.B, true.B )
    // val fsmcWRSync  = ShiftRegisters( ~io.FSMC.wrn,  3, false.B, true.B )
    // val fsmcADVSync = ShiftRegisters( ~io.FSMC.advn, 3, false.B, true.B )  

    io.FSMC.ADOEn := ~io.FSMC.rdn & ~io.FSMC.csn & io.FSMC.advn //fsmcRDSync(0) & fsmcCSSync(0) & ~fsmcADVSync(0)

    val latchAddr = RegEnable( io.FSMC.ADIn, ~io.FSMC.advn & ~io.FSMC.csn)//(~fsmcADVSync(1) & fsmcADVSync(0) & fsmcCSSync(0)) | (fsmcADVSync(0) & ~fsmcCSSync(1) & fsmcCSSync(0)) )

    val isAccessSRAM = ~latchAddr.extract(10) 
    val isAccessReg  =  latchAddr.extract(10)
    val activeAddr   =  latchAddr(9,0)
    val regOut = Wire(UInt(16.W))




    mirrorDown.io.enw    := isAccessSRAM & ~io.FSMC.csn & ~io.FSMC.wrn //isAccessSRAM & fsmcCSSync(0) & ~fsmcWRSync(1) & fsmcWRSync(0)
    mirrorDown.io.addrw  := activeAddr
    mirrorDown.io.dataw  := io.FSMC.ADIn

    mirrorUp.io.enr    := isAccessSRAM & ~io.FSMC.csn & ~io.FSMC.rdn//isAccessSRAM & fsmcCSSync(0) & ~fsmcRDSync(1) & fsmcRDSync(0)
    mirrorUp.io.addrr  := activeAddr

    io.FSMC.ADOut   := Mux( isAccessReg, regOut, mirrorUp.io.datar)

    regOut := Mux1H(Seq(
      ( activeAddr === 0.U) -> 
        Cat(
          statusCDRErr ,
          statusCRCErr ,
          statusLinkErr,
          statusSynch  ,
          statusInit
        ),
      ( activeAddr === 1.U) -> 
        Cat(
          ctrlTransmit,
          0.U(1.W),
          0.U(1.W),
          0.U(1.W),
          ctrlSynch,
          ctrlInit
        ),
      ( activeAddr === 2.U) -> slvNum,
      ( activeAddr === 3.U) -> slvOffLine,
      ( activeAddr === 4.U) -> testReg,
      ( activeAddr === 5.U) -> linkNum,
      ( activeAddr === 6.U) -> slaveDataLength,
    ))



    when( isAccessReg & ~io.FSMC.csn & ~io.FSMC.wrn ){ //fsmcCSSync(0) & ~fsmcWRSync(1) & fsmcWRSync(0) ){ //~fsmcCSWRSync(2) & fsmcCSWRSync(1) ){
      isReqValid := true.B
      wrRegAddr        := activeAddr
      wrRegData        := io.FSMC.ADIn
    }

    when( isReqValid & isAckReady ){
      isReqValid := false.B
    }



  }

  //10M
  when( isAckReady ){
    isAckReady := false.B
  }

  when( isReqValid ){
    isAckReady := true.B

    when( wrRegAddr === 0.U ){
      when( wrRegData.extract(4) ){
        statusCDRErr := false.B
      }
      when( wrRegData.extract(3) ){
        statusCRCErr := false.B
      }
      when( wrRegData.extract(2) ){
        statusLinkErr := false.B
      }
    }


    when( wrRegAddr === 1.U ){
      ctrlTransmit := wrRegData.extract(5)

      ctrlSynch    := wrRegData.extract(1)

      when( wrRegData.extract(0) ){
        ctrlInit     := true.B
        statusSynch   := false.B
        statusInit    := false.B        
      }

    }

    when( wrRegAddr === 2.U ){
      slvNum := wrRegData
    }

    when( wrRegAddr === 4.U ){
      testReg := wrRegData
    }

    when( wrRegAddr === 6.U ){
      slaveDataLength := wrRegData
    }

  }

}

trait BackBoardMstSim{ this: BackBoardMstLVDSBase =>
  io.FSMC.ADOut := DontCare
  io.FSMC.ADOEn := DontCare

  val ( powerUpCnt, isPowerUpTimeout ) = Counter(Range( 0,5200), ~ctrlInit & ~statusInit, false.B)
  when( powerUpCnt === 500.U ){
    ctrlInit := true.B
  }

  val ( _, isTransmitTimeout ) = Counter(Range( 0,520), statusInit, false.B)
  when(isTransmitTimeout){
    ctrlTransmit := true.B
  }


  mirrorDown.io.enw    := true.B
  mirrorDown.io.addrw  := powerUpCnt
  mirrorDown.io.dataw  := "h5555".U

  
  mirrorUp.io.enr    := false.B
  mirrorUp.io.addrr  := 0.U

}



abstract class BackBoardMstLVDSBase extends BackBoardMstBase 
with BackBoardMstFSMC
// with BackBoardMstSim
{


  val frame_info_update_en = RegInit(false.B)
  val slave_type_num       = RegInit(0.U(8.W))

  val tx_start             = RegInit(false.B)

  lvdsMst.io.frame_info_update_en := frame_info_update_en
  lvdsMst.io.slave_type_num       := slave_type_num
  lvdsMst.io.slave_data_length    := slaveDataLength
  lvdsMst.io.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

      frame_info_update_en := true.B
      slave_type_num       := Cat( "b00".U(2.W), slvNum )
      slaveDataLength      := slaveDataLength

      tx_start := false.B
    } .elsewhen( stateCur === 1.U ){ // tx start
      stateCur := 2.U
      timeoutCnt := 0.U

      frame_info_update_en := false.B
      tx_start := true.B

    } .elsewhen( stateCur === 2.U ){

      tx_start := false.B
      timeoutCnt := timeoutCnt + 1.U

      when( lvdsMst.io.slave_link_num_valid ){
        linkNum := lvdsMst.io.slave_link_num
        stateCur := 3.U
        statusInit  := true.B
        ctrlInit    := false.B
        interrupt   := true.B
      }

      when( timeoutCnt === 6000.U ){
        linkNum := 0.U
        stateCur := 3.U
        statusInit  := true.B
        ctrlInit    := false.B
        interrupt   := true.B
      }



    } .elsewhen( stateCur === 3.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 ){
      stateCur := 1.U

      frame_info_update_en := true.B
      slave_type_num       := Cat( "b01".U(2.W), slvNum )
      slaveDataLength      := slaveDataLength

      tx_start := false.B
    } .elsewhen( stateCur === 1.U ){ // tx start
      stateCur := 2.U

      frame_info_update_en := false.B
      tx_start := true.B

    } .elsewhen( stateCur === 2.U ){

      tx_start := false.B

      when( RegNext(lvdsMst.io.downstream_busy, false.B) & ~lvdsMst.io.downstream_busy ){
        stateCur := 3.U
        statusSynch := true.B
        ctrlSynch   := false.B
        interrupt   := true.B
      }

    } .elsewhen( stateCur === 3.U ){

    }
    .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  ){ //setting
      stateCur := 1.U

      frame_info_update_en := true.B
      slave_type_num       := Cat( "b10".U(2.W), slvNum )
      slaveDataLength      := slaveDataLength

      tx_start := false.B
    } .elsewhen( stateCur === 1.U ){ // tx start
      stateCur := 2.U

      frame_info_update_en := false.B
      tx_start := true.B

    } .elsewhen( stateCur === 2.U ){ //waiting  for busy drop

      tx_start := false.B

      when( RegNext(lvdsMst.io.downstream_busy, false.B) & ~lvdsMst.io.downstream_busy ){
        stateCur := 3.U
      }

    } .elsewhen( stateCur === 3.U ){
      when( lvdsMst.io.upstream_crc_valid ){
        stateCur := 4.U
        ctrlTransmit := false.B
        interrupt    := true.B
      }

    } .otherwise{

    }
  }


  val addrr = RegInit(0.U(11.W))
  val addrw = RegInit(0.U(11.W))

  when( isTransStart ){
    addrw := 0.U
  } .elsewhen( lvdsMst.io.rx_data_valid & ctrlTransmit){
    assert( (stateCur === 2.U) || (stateCur === 3.U) )
    addrw := addrw + 1.U
  }

  when( isTransStart ){
    addrr := 0.U
  } .elsewhen( lvdsMst.io.tx_data_ready & ctrlTransmit){
    addrr := addrr + 1.U
  }

  mirrorDown.io.enr := (stateCur === 1.U || stateCur === 2.U) & ctrlTransmit
  lvdsMst.io.tx_data_in := mirrorDown.io.datar
  mirrorDown.io.addrr := addrr
  
  mirrorUp.io.enw    := lvdsMst.io.rx_data_valid & ctrlTransmit
  mirrorUp.io.dataw := lvdsMst.io.rx_data_out
  mirrorUp.io.addrw := addrw

}

trait BackBoardMstLVDSError{ this: BackBoardMstLVDSBase =>
  when( lvdsMst.io.closed_loop_err ){
    slvOffLine    := lvdsMst.io.link_err_location(5,0)
    statusLinkErr := true.B
    interrupt     := true.B
  }

  when( lvdsMst.io.upstream_cdr_err ){
    statusCDRErr := true.B
    interrupt     := true.B
  }

  when( lvdsMst.io.upstream_crc_valid & lvdsMst.io.upstream_crc_err ){
    statusCRCErr := true.B
    interrupt     := true.B
  }

}

class BackBoardMst extends BackBoardMstLVDSBase
with BackBoardMstLVDSInit
with BackBoardMstLVDSSync
with BackBoardMstLVDSTransmit
with BackBoardMstLVDSError