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

package BACK

import chisel3._
import chisel3.util._


object b4b5Encoder{
  def apply( enq: UInt ): UInt = {
    Mux1H(Seq(
      (enq === "b0000".U) -> "b11110".U(5.W),
      (enq === "b0001".U) -> "b01001".U(5.W),
      (enq === "b0010".U) -> "b10100".U(5.W),
      (enq === "b0011".U) -> "b10101".U(5.W),
      (enq === "b0100".U) -> "b01010".U(5.W),
      (enq === "b0101".U) -> "b01011".U(5.W),
      (enq === "b0110".U) -> "b01110".U(5.W),
      (enq === "b0111".U) -> "b01111".U(5.W),
      (enq === "b1000".U) -> "b10010".U(5.W),
      (enq === "b1001".U) -> "b10011".U(5.W),
      (enq === "b1010".U) -> "b10110".U(5.W),
      (enq === "b1011".U) -> "b10111".U(5.W),
      (enq === "b1100".U) -> "b11010".U(5.W),
      (enq === "b1101".U) -> "b11011".U(5.W),
      (enq === "b1110".U) -> "b11100".U(5.W),
      (enq === "b1111".U) -> "b11101".U(5.W),      
    ))
  }
}

object b4b5Decoder{
  def apply( enq: UInt ): UInt = {
    Mux1H(Seq(
      (enq === "b11110".U) -> "b0000".U(4.W),
      (enq === "b01001".U) -> "b0001".U(4.W),
      (enq === "b10100".U) -> "b0010".U(4.W),
      (enq === "b10101".U) -> "b0011".U(4.W),
      (enq === "b01010".U) -> "b0100".U(4.W),
      (enq === "b01011".U) -> "b0101".U(4.W),
      (enq === "b01110".U) -> "b0110".U(4.W),
      (enq === "b01111".U) -> "b0111".U(4.W),
      (enq === "b10010".U) -> "b1000".U(4.W),
      (enq === "b10011".U) -> "b1001".U(4.W),
      (enq === "b10110".U) -> "b1010".U(4.W),
      (enq === "b10111".U) -> "b1011".U(4.W),
      (enq === "b11010".U) -> "b1100".U(4.W),
      (enq === "b11011".U) -> "b1101".U(4.W),
      (enq === "b11100".U) -> "b1110".U(4.W),
      (enq === "b11101".U) -> "b1111".U(4.W),
    ))
  }
}

object Dualb4b5Encoder{
  def apply( enq: UInt ): UInt = {
    require( enq.getWidth == 8, "Require Failed @ Dualb4b5Encoder!" )
    Cat( b4b5Encoder(enq(7,4)),  b4b5Encoder(enq(3,0)) )
  }
}

object Dualb4b5Decoder{
  def apply( enq: UInt ): UInt = {
    require( enq.getWidth == 10, "Require Failed @ Dualb4b5Decoder!" )
    Cat( b4b5Decoder(enq(9,5)),  b4b5Decoder(enq(4,0)) )
  }
}


class b4b5DualEncode extends Module with RequireAsyncReset{
  val io = IO(new Bundle{
    val dataIn = Input(UInt(8.W))
    val isEnable = Input(Bool())
    val dataOut = Output(UInt(10.W))
  })

  io.dataOut := Dualb4b5Encoder(io.dataIn)
}

class b8b10Decode extends Module with RequireAsyncReset{
  val io = IO(new Bundle{
    val dataIn = Input(UInt(10.W))
    val dataOut = Output(UInt(8.W))
  })

  io.dataOut := Dualb4b5Decoder(io.dataIn)
}