mirror of
https://github.com/rdolbeau/VexRiscvBPluginGenerator.git
synced 2025-04-18 18:44:42 -04:00
192 lines
9.5 KiB
Scala
192 lines
9.5 KiB
Scala
// WARNING: this is auto-generated code!
|
|
// See https://github.com/rdolbeau/VexRiscvBPluginGenerator/
|
|
package vexriscv.plugin
|
|
import spinal.core._
|
|
import vexriscv.{Stageable, DecoderService, VexRiscv}
|
|
object CryptoZknhPlugin {
|
|
object CryptoZknhCtrlsha256sigEnum extends SpinalEnum(binarySequential) {
|
|
val CTRL_sha256sig0, CTRL_sha256sig1 = newElement()
|
|
}
|
|
object CryptoZknhCtrlsha256sumEnum extends SpinalEnum(binarySequential) {
|
|
val CTRL_sha256sum0, CTRL_sha256sum1 = newElement()
|
|
}
|
|
object CryptoZknhCtrlsha512sigEnum extends SpinalEnum(binarySequential) {
|
|
val CTRL_sha512sig0h, CTRL_sha512sig0l, CTRL_sha512sig1h, CTRL_sha512sig1l = newElement()
|
|
}
|
|
object CryptoZknhCtrlsha512sumEnum extends SpinalEnum(binarySequential) {
|
|
val CTRL_sha512sum0r, CTRL_sha512sum1r = newElement()
|
|
}
|
|
object CryptoZknhCtrlEnum extends SpinalEnum(binarySequential) {
|
|
val CTRL_sha256sig, CTRL_sha256sum, CTRL_sha512sig, CTRL_sha512sum = newElement()
|
|
}
|
|
object CryptoZknhCtrlsha256sig extends Stageable(CryptoZknhCtrlsha256sigEnum())
|
|
object CryptoZknhCtrlsha256sum extends Stageable(CryptoZknhCtrlsha256sumEnum())
|
|
object CryptoZknhCtrlsha512sig extends Stageable(CryptoZknhCtrlsha512sigEnum())
|
|
object CryptoZknhCtrlsha512sum extends Stageable(CryptoZknhCtrlsha512sumEnum())
|
|
object CryptoZknhCtrl extends Stageable(CryptoZknhCtrlEnum())
|
|
// Prologue
|
|
|
|
def fun_sha256sig0(rs1:Bits) : Bits = {
|
|
val r = rs1.rotateRight(7) ^ rs1.rotateRight(18) ^ (rs1 |>> 3)
|
|
r // return value
|
|
}
|
|
def fun_sha256sig1(rs1:Bits) : Bits = {
|
|
val r = rs1.rotateRight(17) ^ rs1.rotateRight(19) ^ (rs1 |>> 10)
|
|
r // return value
|
|
}
|
|
def fun_sha256sum0(rs1:Bits) : Bits = {
|
|
val r = rs1.rotateRight(2) ^ rs1.rotateRight(13) ^ rs1.rotateRight(22)
|
|
r // return value
|
|
}
|
|
def fun_sha256sum1(rs1:Bits) : Bits = {
|
|
val r = rs1.rotateRight(6) ^ rs1.rotateRight(11) ^ rs1.rotateRight(25)
|
|
r // return value
|
|
}
|
|
|
|
def fun_sha512sig0l(rs1:Bits, rs2:Bits) : Bits = {
|
|
val r = (rs1 |>> 1) ^ (rs1 |>> 7) ^ (rs1 |>> 8) ^ (rs2 |<< 31) ^ (rs2 |<< 25) ^ (rs2 |<< 24)
|
|
r // return value
|
|
}
|
|
def fun_sha512sig0h(rs1:Bits, rs2:Bits) : Bits = {
|
|
val r = (rs1 |>> 1) ^ (rs1 |>> 7) ^ (rs1 |>> 8) ^ (rs2 |<< 31) ^ (rs2 |<< 24)
|
|
r // return value
|
|
}
|
|
def fun_sha512sig1l(rs1:Bits, rs2:Bits) : Bits = {
|
|
val r = (rs1 |<< 3) ^ (rs1 |>> 6) ^ (rs1 |>> 19) ^ (rs2 |>> 29) ^ (rs2 |<< 26) ^ (rs2 |<< 13)
|
|
r // return value
|
|
}
|
|
def fun_sha512sig1h(rs1:Bits, rs2:Bits) : Bits = {
|
|
val r = (rs1 |<< 3) ^ (rs1 |>> 6) ^ (rs1 |>> 19) ^ (rs2 |>> 29) ^ (rs2 |<< 13)
|
|
r // return value
|
|
}
|
|
def fun_sha512sum0r(rs1:Bits, rs2:Bits) : Bits = {
|
|
val r = (rs1 |<< 25) ^ (rs1 |<< 30) ^ (rs1 |>> 28) ^ (rs2 |>> 7) ^ (rs2 |>> 2) ^ (rs2 |<< 4)
|
|
r // return value
|
|
}
|
|
def fun_sha512sum1r(rs1:Bits, rs2:Bits) : Bits = {
|
|
val r = (rs1 |<< 23) ^ (rs1 |>> 14) ^ (rs1 |>> 18) ^ (rs2 |>> 9) ^ (rs2 |<< 18) ^ (rs2 |<< 14)
|
|
r // return value
|
|
}
|
|
|
|
// End prologue
|
|
} // object Plugin
|
|
class CryptoZknhPlugin(earlyInjection : Boolean = true) extends Plugin[VexRiscv] {
|
|
import CryptoZknhPlugin._
|
|
object IS_CryptoZknh extends Stageable(Bool)
|
|
object CryptoZknh_FINAL_OUTPUT extends Stageable(Bits(32 bits))
|
|
override def setup(pipeline: VexRiscv): Unit = {
|
|
import pipeline.config._
|
|
val immediateActions = List[(Stageable[_ <: BaseType],Any)](
|
|
SRC1_CTRL -> Src1CtrlEnum.RS,
|
|
SRC2_CTRL -> Src2CtrlEnum.IMI,
|
|
REGFILE_WRITE_VALID -> True,
|
|
BYPASSABLE_EXECUTE_STAGE -> Bool(earlyInjection),
|
|
BYPASSABLE_MEMORY_STAGE -> True,
|
|
RS1_USE -> True,
|
|
IS_CryptoZknh -> True
|
|
)
|
|
val binaryActions = List[(Stageable[_ <: BaseType],Any)](
|
|
SRC1_CTRL -> Src1CtrlEnum.RS,
|
|
SRC2_CTRL -> Src2CtrlEnum.RS,
|
|
REGFILE_WRITE_VALID -> True,
|
|
BYPASSABLE_EXECUTE_STAGE -> Bool(earlyInjection),
|
|
BYPASSABLE_MEMORY_STAGE -> True,
|
|
RS1_USE -> True,
|
|
RS2_USE -> True,
|
|
IS_CryptoZknh -> True
|
|
)
|
|
val unaryActions = List[(Stageable[_ <: BaseType],Any)](
|
|
SRC1_CTRL -> Src1CtrlEnum.RS,
|
|
REGFILE_WRITE_VALID -> True,
|
|
BYPASSABLE_EXECUTE_STAGE -> Bool(earlyInjection),
|
|
BYPASSABLE_MEMORY_STAGE -> True,
|
|
RS1_USE -> True,
|
|
IS_CryptoZknh -> True
|
|
)
|
|
val ternaryActions = List[(Stageable[_ <: BaseType],Any)](
|
|
SRC1_CTRL -> Src1CtrlEnum.RS,
|
|
SRC2_CTRL -> Src2CtrlEnum.RS,
|
|
SRC3_CTRL -> Src3CtrlEnum.RS,
|
|
REGFILE_WRITE_VALID -> True,
|
|
BYPASSABLE_EXECUTE_STAGE -> Bool(earlyInjection),
|
|
BYPASSABLE_MEMORY_STAGE -> True,
|
|
RS1_USE -> True,
|
|
RS2_USE -> True,
|
|
RS3_USE -> True,
|
|
IS_CryptoZknh -> True
|
|
)
|
|
val immTernaryActions = List[(Stageable[_ <: BaseType],Any)](
|
|
SRC1_CTRL -> Src1CtrlEnum.RS,
|
|
SRC2_CTRL -> Src2CtrlEnum.IMI,
|
|
SRC3_CTRL -> Src3CtrlEnum.RS,
|
|
REGFILE_WRITE_VALID -> True,
|
|
BYPASSABLE_EXECUTE_STAGE -> Bool(earlyInjection),
|
|
BYPASSABLE_MEMORY_STAGE -> True,
|
|
RS1_USE -> True,
|
|
RS3_USE -> True,
|
|
IS_CryptoZknh -> True
|
|
)
|
|
def sha256sig0_KEY = M"000100000010-----001-----0010011"
|
|
def sha256sig1_KEY = M"000100000011-----001-----0010011"
|
|
def sha256sum0_KEY = M"000100000000-----001-----0010011"
|
|
def sha256sum1_KEY = M"000100000001-----001-----0010011"
|
|
def sha512sig0l_KEY = M"0101010----------000-----0110011"
|
|
def sha512sig0h_KEY = M"0101110----------000-----0110011"
|
|
def sha512sig1l_KEY = M"0101011----------000-----0110011"
|
|
def sha512sig1h_KEY = M"0101111----------000-----0110011"
|
|
def sha512sum0r_KEY = M"0101000----------000-----0110011"
|
|
def sha512sum1r_KEY = M"0101001----------000-----0110011"
|
|
val decoderService = pipeline.service(classOf[DecoderService])
|
|
decoderService.addDefault(IS_CryptoZknh, False)
|
|
decoderService.add(List(
|
|
sha256sig0_KEY -> (unaryActions ++ List(CryptoZknhCtrl -> CryptoZknhCtrlEnum.CTRL_sha256sig, CryptoZknhCtrlsha256sig -> CryptoZknhCtrlsha256sigEnum.CTRL_sha256sig0)),
|
|
sha256sig1_KEY -> (unaryActions ++ List(CryptoZknhCtrl -> CryptoZknhCtrlEnum.CTRL_sha256sig, CryptoZknhCtrlsha256sig -> CryptoZknhCtrlsha256sigEnum.CTRL_sha256sig1)),
|
|
sha256sum0_KEY -> (unaryActions ++ List(CryptoZknhCtrl -> CryptoZknhCtrlEnum.CTRL_sha256sum, CryptoZknhCtrlsha256sum -> CryptoZknhCtrlsha256sumEnum.CTRL_sha256sum0)),
|
|
sha256sum1_KEY -> (unaryActions ++ List(CryptoZknhCtrl -> CryptoZknhCtrlEnum.CTRL_sha256sum, CryptoZknhCtrlsha256sum -> CryptoZknhCtrlsha256sumEnum.CTRL_sha256sum1)),
|
|
sha512sig0l_KEY -> (binaryActions ++ List(CryptoZknhCtrl -> CryptoZknhCtrlEnum.CTRL_sha512sig, CryptoZknhCtrlsha512sig -> CryptoZknhCtrlsha512sigEnum.CTRL_sha512sig0l)),
|
|
sha512sig0h_KEY -> (binaryActions ++ List(CryptoZknhCtrl -> CryptoZknhCtrlEnum.CTRL_sha512sig, CryptoZknhCtrlsha512sig -> CryptoZknhCtrlsha512sigEnum.CTRL_sha512sig0h)),
|
|
sha512sig1l_KEY -> (binaryActions ++ List(CryptoZknhCtrl -> CryptoZknhCtrlEnum.CTRL_sha512sig, CryptoZknhCtrlsha512sig -> CryptoZknhCtrlsha512sigEnum.CTRL_sha512sig1l)),
|
|
sha512sig1h_KEY -> (binaryActions ++ List(CryptoZknhCtrl -> CryptoZknhCtrlEnum.CTRL_sha512sig, CryptoZknhCtrlsha512sig -> CryptoZknhCtrlsha512sigEnum.CTRL_sha512sig1h)),
|
|
sha512sum0r_KEY -> (binaryActions ++ List(CryptoZknhCtrl -> CryptoZknhCtrlEnum.CTRL_sha512sum, CryptoZknhCtrlsha512sum -> CryptoZknhCtrlsha512sumEnum.CTRL_sha512sum0r)),
|
|
sha512sum1r_KEY -> (binaryActions ++ List(CryptoZknhCtrl -> CryptoZknhCtrlEnum.CTRL_sha512sum, CryptoZknhCtrlsha512sum -> CryptoZknhCtrlsha512sumEnum.CTRL_sha512sum1r))
|
|
))
|
|
} // override def setup
|
|
override def build(pipeline: VexRiscv): Unit = {
|
|
import pipeline._
|
|
import pipeline.config._
|
|
execute plug new Area{
|
|
import execute._
|
|
val val_sha256sig = input(CryptoZknhCtrlsha256sig).mux(
|
|
CryptoZknhCtrlsha256sigEnum.CTRL_sha256sig0 -> fun_sha256sig0(input(SRC1)).asBits,
|
|
CryptoZknhCtrlsha256sigEnum.CTRL_sha256sig1 -> fun_sha256sig1(input(SRC1)).asBits
|
|
) // mux sha256sig
|
|
val val_sha256sum = input(CryptoZknhCtrlsha256sum).mux(
|
|
CryptoZknhCtrlsha256sumEnum.CTRL_sha256sum0 -> fun_sha256sum0(input(SRC1)).asBits,
|
|
CryptoZknhCtrlsha256sumEnum.CTRL_sha256sum1 -> fun_sha256sum1(input(SRC1)).asBits
|
|
) // mux sha256sum
|
|
val val_sha512sig = input(CryptoZknhCtrlsha512sig).mux(
|
|
CryptoZknhCtrlsha512sigEnum.CTRL_sha512sig0h -> fun_sha512sig0h(input(SRC1),input(SRC2)).asBits,
|
|
CryptoZknhCtrlsha512sigEnum.CTRL_sha512sig0l -> fun_sha512sig0l(input(SRC1),input(SRC2)).asBits,
|
|
CryptoZknhCtrlsha512sigEnum.CTRL_sha512sig1h -> fun_sha512sig1h(input(SRC1),input(SRC2)).asBits,
|
|
CryptoZknhCtrlsha512sigEnum.CTRL_sha512sig1l -> fun_sha512sig1l(input(SRC1),input(SRC2)).asBits
|
|
) // mux sha512sig
|
|
val val_sha512sum = input(CryptoZknhCtrlsha512sum).mux(
|
|
CryptoZknhCtrlsha512sumEnum.CTRL_sha512sum0r -> fun_sha512sum0r(input(SRC1),input(SRC2)).asBits,
|
|
CryptoZknhCtrlsha512sumEnum.CTRL_sha512sum1r -> fun_sha512sum1r(input(SRC1),input(SRC2)).asBits
|
|
) // mux sha512sum
|
|
insert(CryptoZknh_FINAL_OUTPUT) := input(CryptoZknhCtrl).mux(
|
|
CryptoZknhCtrlEnum.CTRL_sha256sig -> val_sha256sig.asBits,
|
|
CryptoZknhCtrlEnum.CTRL_sha256sum -> val_sha256sum.asBits,
|
|
CryptoZknhCtrlEnum.CTRL_sha512sig -> val_sha512sig.asBits,
|
|
CryptoZknhCtrlEnum.CTRL_sha512sum -> val_sha512sum.asBits
|
|
) // primary mux
|
|
} // execute plug newArea
|
|
val injectionStage = if(earlyInjection) execute else memory
|
|
injectionStage plug new Area {
|
|
import injectionStage._
|
|
when (arbitration.isValid && input(IS_CryptoZknh)) {
|
|
output(REGFILE_WRITE_DATA) := input(CryptoZknh_FINAL_OUTPUT)
|
|
} // when input is
|
|
} // injectionStage plug newArea
|
|
} // override def build
|
|
} // class Plugin
|