// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
# AES register template
{
  name: "aes",
  clock_primary: "clk_i",
  bus_device: "tlul",
  param_list: [
    { name:    "AES192Enable",
      type:    "bit",
      default: "1'b1",
      desc:    '''
        Disable (0) or enable (1) support for 192-bit key lengths (AES-192).
      '''
      local:   "false",
      expose:  "false"
    },
    { name:    "Masking",
      type:    "bit",
      default: "1'b1",
      desc:    '''
        Disable (0) or enable (1) first-order masking of the AES cipher core.
        Masking requires the use of a masked S-Box, see SBoxImpl parameter.
      '''
      local:   "false",
      expose:  "true"
    },
    { name:    "SBoxImpl",
      type:    "aes_pkg::sbox_impl_e",
      default: "aes_pkg::SBoxImplCanrightMaskedNoreuse",
      desc:    '''
        Selection of the S-Box implementation. See aes_pkg.sv.
      '''
      local:   "false",
      expose:  "true"
    },
    { name:    "SecStartTriggerDelay",
      type:    "int unsigned",
      default: "0",
      desc:    '''
        Manual start trigger delay, useful for SCA measurements.
        A value of e.g. 40 allows the processor to go into sleep before AES starts operation.
      '''
      local:   "false",
      expose:  "true"
    },
    { name:    "SecAllowForcingMasks",
      type:    "bit",
      default: "1'b0",
      desc:    '''
        Forbid (0) or allow (1) forcing the mask to zero via FORCE_ZERO_MASK bit in the Control Register.
        Useful for SCA measurements.
        Meaningful only if masking is enabled.
      '''
      local:   "false",
      expose:  "true"
    },
    { name:    "AlertAsyncOn",
      type:    "logic [aes_reg_pkg::NumAlerts-1:0]",
      default: "{aes_reg_pkg::NumAlerts{1'b1}}",
      desc:    '''
        One bit per alert specifying whether the corresponding sender in the AES module and the receiver in the alert handler are in the same clock domain (0) or whether there is an asynchronous boundary in between (1).
      '''
      local:   "false",
      expose:  "false"
    },
    { name:    "RndCnstClearingLfsrSeed",
      type:    "aes_pkg::clearing_lfsr_seed_t",
      default: "aes_pkg::RndCnstClearingLfsrSeedDefault",
      desc:    '''
        Default seed of the PRNG used for register clearing.
      '''
      local:   "false",
      expose:  "false"
    },
    { name:    "RndCnstClearingLfsrPerm",
      type:    "aes_pkg::clearing_lfsr_perm_t",
      default: "aes_pkg::RndCnstClearingLfsrPermDefault",
      desc:    '''
        Permutation applied to the LFSR of the PRNG used for clearing.
      '''
      local:   "false",
      expose:  "false"
    },
    { name:    "RndCnstMaskingLfsrSeed",
      type:    "aes_pkg::masking_lfsr_seed_t",
      default: "aes_pkg::RndCnstMaskingLfsrSeedDefault",
      desc:    '''
        Default seed of the PRNG used for masking.
      '''
      local:   "false",
      expose:  "false"
    },
    { name:    "RndCnstMskgChunkLfsrPerm",
      type:    "aes_pkg::mskg_chunk_lfsr_perm_t",
      default: "aes_pkg::RndCnstMskgChunkLfsrPermDefault",
      desc:    '''
        Permutation applied to the LFSR chunks of the PRNG used for masking.
      '''
      local:   "false",
      expose:  "false"
    },
    # Note: All parameters below are local, they are not actually configurable.
    # Selecting values different from the default values below might cause undefined behavior.
    { name:    "NumRegsKey",
      type:    "int",
      default: "8",
      desc:    "Number registers for key",
      local:   "true"
    },
    { name:    "NumRegsIv",
      type:    "int",
      default: "4",
      desc:    "Number registers for initialization vector",
      local:   "true"
    },
    { name:    "NumRegsData",
      type:    "int",
      default: "4",
      desc:    "Number registers for input and output data",
      local:   "true"
    }
  ],
  inter_signal_list: [
    { name:    "idle",
      type:    "uni",
      act:     "req",
      package: "",
      struct:  "logic",
      width:   "1"
    }
  ],
  alert_list: [
    //{ name: "informative",
    //  desc: '''
    //    The informative alert can currently not be triggered.
    //    The AES unit recovers from such a condition automatically.
    //    No further action needs to be taken but this should be monitored by the system.
    //  '''
    //}
    { name: "recoverable",
      desc: '''
        The recoverable alert is triggered upon detecting an update error in the Control Register.
        The content of the Control Register is not modified (See Control Register).
        The AES unit can be recovered from such a condition by restarting the AES operation, i.e., by successfully updating the Control Register.
        This should be monitored by the system.
      '''
    }
    { name: "fatal",
      desc: '''
        The fatal alert is triggered i) upon detecting a storage error in the Control Register, or ii) if any internal FSM enters an invalid state.
        The AES unit cannot recover from such an error and needs to be reset.
      '''
    }
  ],
  regwidth: "32",
  registers: [
##############################################################################
# initial key registers
    { multireg: {
      name: "KEY_SHARE0",
      desc: '''
        Initial Key Registers Share 0.
        The actual initial key corresponds to Initial Key Registers Share 0 XORed with Initial Key Registers Share 1.
        Loaded into the internal Full Key register upon starting encryption/decryption of the next block.
        All key registers (Share 0 and Share 1) must be written at least once when the key is changed, regardless of key length (write random data for unused bits).
        The order in which the registers are updated does not matter.
        Can only be updated when the AES unit is idle.
        If the AES unit is non-idle, writes to these registers are ignored.
      '''
      count: "NumRegsKey",
      cname: "KEY_SHARE0",
      swaccess: "wo",
      hwaccess: "hrw",
      hwext:    "true",
      hwqe:     "true",
      fields: [
        { bits: "31:0", name: "key_share0", desc: "Initial Key Share 0" }
      ],
      }
    },
    { multireg: {
      name: "KEY_SHARE1",
      desc: '''
        Initial Key Registers Share 1.
        The actual initial key corresponds to Initial Key Registers Share 0 XORed with Initial Key Registers Share 1.
        Loaded into the internal Full Key register upon starting encryption/decryption of the next block.
        All key registers (Share 0 and Share 1) must be written at least once when the key is changed, regardless of key length (write random data for unused bits).
        The order in which the registers are updated does not matter.
        Can only be updated when the AES unit is idle.
        If the AES unit is non-idle, writes to these registers are ignored.
      '''
      count: "NumRegsKey",
      cname: "KEY_SHARE1",
      swaccess: "wo",
      hwaccess: "hrw",
      hwext:    "true",
      hwqe:     "true",
      fields: [
        { bits: "31:0", name: "key_share1", desc: "Initial Key Share 1" }
      ],
      }
    },
##############################################################################
# initialization vector registers
    { multireg: {
      name: "IV",
      desc: '''
        Initialization Vector Registers.
        The initialization vector (IV) or initial counter value must be written to these registers when starting a new message in CBC or CTR mode (see Control Register), respectively.
        In CBC and CTR modes, the AES unit does not start encryption/decryption with a partially updated IV.
        Each register has to be written at least once.
        The order in which the registers are written does not matter.
        If the AES unit is non-idle, writes to these registers are ignored.
        Whenever starting a new message, the corresponding IV value must be provided by the processor.
        Once started, the AES unit automatically updates the contents of these registers.
        In ECB mode, the IV registers are not used and do not need to be configured.
      '''
      count: "NumRegsIv",
      cname: "IV",
      swaccess: "wo",
      hwaccess: "hrw",
      hwext:    "true",
      hwqe:     "true",
      fields: [
        { bits: "31:0", name: "iv", desc: "Initialization Vector" }
      ],
      }
    },
##############################################################################
# input data registers
    { multireg: {
      name: "DATA_IN",
      desc: '''
        Input Data Registers.
        If MANUAL_OPERATION=0 (see Control Register), the AES unit automatically starts encryption/decryption after these register have been written.
        Each register has to be written at least once.
        The order in which the registers are written does not matter.
        Loaded into the internal State register upon starting encryption/decryption of the next block.
        After that, the processor can update the Input Data Register.
      '''
      count: "NumRegsData",
      cname: "DATA_IN",
      swaccess: "wo",
      hwaccess: "hrw",
      hwqe:     "true",
      fields: [
        { bits: "31:0", name: "data_in", desc: "Input Data" }
      ],
      }
    },
##############################################################################
# output data registers
    { multireg: {
      name: "DATA_OUT",
      desc: '''
        Output Data Register.
        Holds the output data produced by the AES unit during the last encryption/decryption operation.
        If MANUAL_OPERATION=0 (see Control Register), the AES unit is stalled when the previous output data has not yet been read and is about to be overwritten.
        Each register has to be read at least once.
        The order in which the registers are read does not matter.
      '''
      count: "NumRegsData",
      cname: "DATA_OUT",
      swaccess: "ro",
      hwaccess: "hrw",
      hwext:    "true",
      hwre:     "true",
      fields: [
        { bits: "31:0", name: "data_out", desc: "Output Data" }
      ]
      tags: [// Updated by the HW.
             // Updates based on writes to other regs.
             // These registers are reset to 0, but the reset also triggers internal operations that clear these registers with pseudo-random data shortly afterwards (See Trigger Register).
             // Exclude from init and write-read checks.
             "excl:CsrAllTests:CsrExclCheck"]
      }
    },
##############################################################################
# control and status registers
  { name: "CTRL_SHADOWED",
    desc: '''
      Control Register. Can only be updated when the AES unit is idle. If the
      AES unit is non-idle, writes to this register are ignored.
      This register is shadowed, meaning two subsequent write operations are required to change its content.
      If the two write operations try to set a different value, a recoverable alert is triggered (See Status Register).
      A read operation clears the internal phase tracking: The next write operation is always considered a first write operation of an update sequence. 
      Any write operation to this register will clear the status tracking required for automatic mode (See MANUAL_OPERATION field).
      A write to the Control Register is considered the start of a new message.
      Hence, software needs to provide new key, IV and input data afterwards.
    '''
    swaccess: "rw",
    hwaccess: "hrw",
    hwext:    "true",
    hwqe:     "true",
    shadowed: "true",
    fields: [
      { bits: "0",
        name: "OPERATION",
        desc:  '''
          Select encryption(0) or decryption(1) operation of AES unit.
        '''
      }
      { bits: "6:1",
        name: "MODE",
        resval: "0x20",
        hwaccess: "hrw",
        desc:  '''
          6-bit one-hot field to select AES block cipher mode.
          Invalid input values, i.e., values with multiple bits set and value 6'b00_0000, are mapped to AES_NONE (6'b10_0000).
        '''
        enum: [
          { value: "1",
            name: "AES_ECB",
            desc: '''
              6'b00_0001: Electronic Codebook (ECB) mode.
            '''
          },
          { value: "2",
            name: "AES_CBC",
            desc: '''
              6'b00_0010: Cipher Block Chaining (CBC) mode.
            '''
          },
          { value: "4",
            name: "AES_CFB",
            desc: '''
              6'b00_0100: Cipher Feedback (CFB) mode.
            '''
          },
          { value: "8",
            name: "AES_OFB",
            desc: '''
              6'b00_1000: Output Feedback (OFB) mode.
            '''
          },
          { value: "16",
            name: "AES_CTR",
            desc: '''
              6'b01_0000: Counter (CTR) mode.
            '''
          },
          { value: "32",
            name: "AES_NONE",
            desc: '''
              6'b10_0000: Invalid input values, i.e., value with multiple bits set and value 6'b00_0000, are mapped to AES_NONE.
            '''
          }
        ]
      }
      { bits: "9:7",
        name: "KEY_LEN",
        resval: "1",
        hwaccess: "hrw",
        desc: '''
          3-bit one-hot field to select AES key length.
          Invalid input values, i.e., values with multiple bits set, value 3'b000, and value 3'b010 in case 192-bit keys are not supported (because disabled at compile time) are mapped to AES_256 (3'b100).
        '''
        enum: [
          { value: "1",
            name: "AES_128",
            desc: '''
              3'b001: 128-bit key length.
            '''
          },
          { value: "2",
            name: "AES_192",
            desc: '''
              3'b010: 192-bit key length.
              In case support for 192-bit keys has been disabled at compile time, setting this value results in configuring AES_256 (3'b100).
            '''
          },
          { value: "4",
            name: "AES_256",
            desc: '''
              3'b100: 256-bit key length.
              Invalid input values, i.e., values with multiple bits set, value 3'b000, and value 3'b010 in case 192-bit keys are not supported (because disabled at compile time) are mapped to AES_256.
            '''
          }
        ]
      }
      { bits: "10",
        name: "MANUAL_OPERATION",
        desc:  '''
          Controls whether the AES unit is operated in normal/automatic mode (0) or fully manual mode (1).
          In automatic mode (0), the AES unit automatically i) starts to encrypt/decrypt when it receives new input data, and ii) stalls during the last encryption/decryption cycle if the previous output data has not yet been read.
          This is the most efficient mode to operate in.
          Note that the corresponding status tracking is automatically cleared upon a write to the Control Register.
          In manual mode (1), the AES unit i) only starts to encrypt/decrypt after receiving a start trigger (see Trigger Register), and ii) overwrites previous output data irrespective of whether it has been read out or not.
          This mode is useful if software needs full control over the AES unit.
        '''
      }
      { bits: "11",
        name: "FORCE_ZERO_MASKS",
        resval: "0"
        desc:  '''
          Use masks generated by internal masking PRNG (0) or force all masks constantly to zero (1).
          Setting all masks to constant zero can be useful when performing SCA.
          To completely disable the masking, the second key share (KEY_SHARE1_0 - KEY_SHARE1_7) must be zero as well.
          Only applicable if both the Masking parameter and the SecAllowForcingMasks parameter are set to one.
        '''
      }
    ]
    tags: [// Updated by the HW.
           // Updates based on writes to this reg (reset test possible).
           // Exclude from write-read checks.
           "excl:CsrNonInitTests:CsrExclWriteCheck",
           "shadowed_reg_path:u_aes_core.u_ctrl_reg_shadowed"]
  },
  { name: "TRIGGER",
    desc: '''
      Trigger Register.
      Each bit is individually cleared to zero when executing the corresponding trigger.
      While executing any of the triggered operations, the AES unit will set the IDLE bit in the Status Register to zero.
      The processor must check the Status Register before triggering further actions.
      For example, writes to Initial Key and IV Registers are ignored while the AES unit is busy.
      Writes to the Input Data Registers are not ignored but the data will be cleared if a DATA_IN_CLEAR operation is pending.
    '''
    swaccess: "wo",
    hwaccess: "hrw",
    # Tag info (CSR test exclusions):
    #  Updated by the HW.
    #  Updates based on writes to this reg.
    #  -> Exclude all fields from write-read checks.
    #  Upon reset, the non-zero values trigger internal operations that clear this reg to zero.
    #  -> Exclude fields with non-zero reset value from init and write-read checks (also in reset test).
    fields: [
      { bits: "0",
        name: "START",
        desc:  '''
          Keep AES unit paused (0) or trigger the encryption/decryption of one data block (1).
          This trigger is ignored if MANUAL_OPERATION=0 (see Control Register).
        '''
        tags: ["excl:CsrNonInitTests:CsrExclWriteCheck"]
      }
      { bits: "1",
        name: "KEY_CLEAR",
        resval: "1"
        desc:  '''
          Keep current values in Initial Key, internal Full Key and Decryption Key registers (0)
          or clear those registers with pseudo-random data (1).
        '''
        tags: ["excl:CsrAllTests:CsrExclCheck"]
      }
      { bits: "2",
        name: "IV_CLEAR",
        resval: "1"
        desc:  '''
          Keep current values in IV registers (0) or clear those registers with pseudo-random data (1).
        '''
        tags: ["excl:CsrAllTests:CsrExclCheck"]
      }
      { bits: "3",
        name: "DATA_IN_CLEAR",
        resval: "1"
        desc:  '''
          Keep current values in input registers (0) or clear those registers with pseudo-random data (1).
        '''
        tags: ["excl:CsrAllTests:CsrExclCheck"]
      }
      { bits: "4",
        name: "DATA_OUT_CLEAR",
        resval: "1"
        desc:  '''
          Keep current values in output registers (0) or clear those registers with pseudo-random data (1).
        '''
        tags: ["excl:CsrAllTests:CsrExclCheck"]
      }
      { bits: "5",
        name: "PRNG_RESEED",
        resval: "1"
        desc:  '''
          Keep continuing with the current internal state of the internal pseudo-random number generator used for register clearing (0) or perform a reseed of the internal state from the connected entropy source (1).
        '''
        tags: ["excl:CsrAllTests:CsrExclCheck"]
      }
    ]
  },
  { name: "STATUS",
    desc: "Status Register",
    swaccess: "ro",
    hwaccess: "hwo",
    # Tag info (CSR test exclusions):
    #  Updated by the HW.
    #  Updates based on writes to other regs.
    #  -> Exclude all fields (except CTRL_STORAGE_ERROR) from init and write-read checks.
    #  Upon reset, internal operations are triggered that temporarily change the IDLE field.
    #  -> Exclude IDLE field from init and write-read checks (also in reset test).
    fields: [
      { bits: "0",
        name: "IDLE",
        resval: "1",
        desc:  '''
          The AES unit is idle (1) or busy (0).
          This flag is `0` if one of the following operations is currently running: i) encryption/decryption, ii) register clearing or iii) PRNG reseeding.
          This flag is also `0` if an encryption/decryption is running but the AES unit is stalled.
        '''
        tags: ["excl:CsrAllTests:CsrExclCheck"]
      }
      { bits: "1",
        name: "STALL",
        desc:  '''
          The AES unit is not stalled (0) or stalled (1) because there is previous
          output data that must be read by the processor before the AES unit can
          overwrite this data.
          This flag not meaningful if MANUAL_OPERATION=1 (see Control Register).
        '''
        tags: ["excl:CsrNonInitTests:CsrExclCheck"]
      }
      { bits: "2",
        name: "OUTPUT_VALID",
        desc:  '''
          The AES unit has no valid output (0) or has valid output data (1).
        '''
        tags: ["excl:CsrNonInitTests:CsrExclCheck"]
      }
      { bits: "3",
        name: "INPUT_READY",
        resval: "1",
        desc:  '''
          The AES unit is ready (1) to receive new data input via the DATA_IN registers or
          the present values in the DATA_IN registers have not yet been loaded into the
          module (0).
        '''
        tags: ["excl:CsrNonInitTests:CsrExclCheck"]
      }
      { bits: "4",
        name: "ALERT_RECOVERABLE",
        resval: "0",
        desc:  '''
          No recoverable alert condition has occurred (0).
          A recoverable alert condition has occurred and AES operation needs to be restarted by successfully updating the Control Register (1).
          Examples for recoverable alert conditions include update errors in the Control Register.
        '''
      }
      { bits: "5",
        name: "ALERT_FATAL",
        resval: "0",
        desc:  '''
          No fatal alert condition has occurred (0).
          A fatal alert condition has occurred and the AES unit needs to be reset (1).
          Examples for fatal alert conditions include i) storage errors in the Control Register, and ii) if any internal FSM enters an invalid state.
        '''
      }
    ]
  },
  ],
}