Subversion Repositories neorv32

-- #################################################################################################

-- # << NEORV32 - CPU Operations Control Unit >>                                                   #

-- # ********************************************************************************************* #

-- # CPU operations are controlled by several "engines" (modules). These engines operate in        #

-- # parallel to implement a simple pipeline:                                                      #

-- #  + Fetch engine:   Fetches 32-bit chunks of instruction words                                 #

-- #  + Issue engine:   Decodes compressed instructions, aligns and queues instruction words       #

-- #  + Execute engine: Multi-cycle execution of instructions (generate control signals)           #

-- #  + Trap engine:    Handles interrupts and exceptions                                          #

-- #  + CSR module:     Read/write access to control and status registers                          #

-- #  + Debug module:   CPU debug mode handling (on-chip debugger)                                 #

-- #  + Trigger module: Hardware-assisted breakpoints (on-chip debugger)                           #

-- #                                                                                               #

-- # NOTE: If <dedicated_reset_c> = true then <def_rst_val_c> evaluates to '-'. Registers that     #

-- #       reset to <def_rst_val_c> do NOT actually have a real reset by default and have to be    #

-- #       explicitly initialized by software! This is only used for "uncritical" registers. Many  #

-- #       of them will be initialized by the default crt0 start-up code.                          #

-- # ********************************************************************************************* #

-- # BSD 3-Clause License                                                                          #

-- #                                                                                               #

-- # Copyright (c) 2022, Stephan Nolting. All rights reserved.                                     #

-- #                                                                                               #

-- # Redistribution and use in source and binary forms, with or without modification, are          #

-- # permitted provided that the following conditions are met:                                     #

-- #                                                                                               #

-- # 1. Redistributions of source code must retain the above copyright notice, this list of        #

-- #    conditions and the following disclaimer.                                                   #

-- #                                                                                               #

-- # 2. Redistributions in binary form must reproduce the above copyright notice, this list of     #

-- #    conditions and the following disclaimer in the documentation and/or other materials        #

-- #    provided with the distribution.                                                            #

-- #                                                                                               #

-- # 3. Neither the name of the copyright holder nor the names of its contributors may be used to  #

-- #    endorse or promote products derived from this software without specific prior written      #

-- #    permission.                                                                                #

-- #                                                                                               #

-- # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS   #

-- # OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF               #

-- # MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE    #

-- # COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,     #

-- # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE #

-- # GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED    #

-- # AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING     #

-- # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED  #

-- # OF THE POSSIBILITY OF SUCH DAMAGE.                                                            #

-- # ********************************************************************************************* #

-- # The NEORV32 Processor - https://github.com/stnolting/neorv32              (c) Stephan Nolting #

-- #################################################################################################

library ieee;

use ieee.std_logic_1164.all;

use ieee.numeric_std.all;

library neorv32;

use neorv32.neorv32_package.all;

entity neorv32_cpu_control is

  generic (

    -- General --

    HW_THREAD_ID                 : natural; -- hardware thread id (32-bit)

    CPU_BOOT_ADDR                : std_ulogic_vector(31 downto 0); -- cpu boot address

    CPU_DEBUG_ADDR               : std_ulogic_vector(31 downto 0); -- cpu debug mode start address

    -- RISC-V CPU Extensions --

    CPU_EXTENSION_RISCV_A        : boolean; -- implement atomic extension?

    CPU_EXTENSION_RISCV_B        : boolean; -- implement bit-manipulation extension?

    CPU_EXTENSION_RISCV_C        : boolean; -- implement compressed extension?

    CPU_EXTENSION_RISCV_E        : boolean; -- implement embedded RF extension?

    CPU_EXTENSION_RISCV_M        : boolean; -- implement mul/div extension?

    CPU_EXTENSION_RISCV_U        : boolean; -- implement user mode extension?

    CPU_EXTENSION_RISCV_Zfinx    : boolean; -- implement 32-bit floating-point extension (using INT reg!)

    CPU_EXTENSION_RISCV_Zicsr    : boolean; -- implement CSR system?

    CPU_EXTENSION_RISCV_Zicntr   : boolean; -- implement base counters?

    CPU_EXTENSION_RISCV_Zihpm    : boolean; -- implement hardware performance monitors?

    CPU_EXTENSION_RISCV_Zifencei : boolean; -- implement instruction stream sync.?

    CPU_EXTENSION_RISCV_Zmmul    : boolean; -- implement multiply-only M sub-extension?

    CPU_EXTENSION_RISCV_Zxcfu    : boolean; -- implement custom (instr.) functions unit?

    CPU_EXTENSION_RISCV_DEBUG    : boolean; -- implement CPU debug mode?

    -- Tuning Options --

    FAST_MUL_EN                  : boolean; -- use DSPs for M extension's multiplier

    FAST_SHIFT_EN                : boolean; -- use barrel shifter for shift operations

    CPU_CNT_WIDTH                : natural; -- total width of CPU cycle and instret counters (0..64)

    CPU_IPB_ENTRIES              : natural; -- entries is instruction prefetch buffer, has to be a power of 2

    -- Physical memory protection (PMP) --

    PMP_NUM_REGIONS              : natural; -- number of regions (0..16)

    PMP_MIN_GRANULARITY          : natural; -- minimal region granularity in bytes, has to be a power of 2, min 4 bytes

    -- Hardware Performance Monitors (HPM) --

    HPM_NUM_CNTS                 : natural; -- number of implemented HPM counters (0..29)

    HPM_CNT_WIDTH                : natural  -- total size of HPM counters (0..64)

  );

  port (

    -- global control --

    clk_i         : in  std_ulogic; -- global clock, rising edge

    rstn_i        : in  std_ulogic; -- global reset, low-active, async

    ctrl_o        : out std_ulogic_vector(ctrl_width_c-1 downto 0); -- main control bus

    -- status input --

    alu_idone_i   : in  std_ulogic; -- ALU iterative operation done

    bus_i_wait_i  : in  std_ulogic; -- wait for bus

    bus_d_wait_i  : in  std_ulogic; -- wait for bus

    excl_state_i  : in  std_ulogic; -- atomic/exclusive access lock status

    -- data input --

    instr_i       : in  std_ulogic_vector(data_width_c-1 downto 0); -- instruction

    cmp_i         : in  std_ulogic_vector(1 downto 0); -- comparator status

    alu_add_i     : in  std_ulogic_vector(data_width_c-1 downto 0); -- ALU address result

    rs1_i         : in  std_ulogic_vector(data_width_c-1 downto 0); -- rf source 1

    -- data output --

    imm_o         : out std_ulogic_vector(data_width_c-1 downto 0); -- immediate

    fetch_pc_o    : out std_ulogic_vector(data_width_c-1 downto 0); -- PC for instruction fetch

    curr_pc_o     : out std_ulogic_vector(data_width_c-1 downto 0); -- current PC (corresponding to current instruction)

    next_pc_o     : out std_ulogic_vector(data_width_c-1 downto 0); -- next PC (corresponding to next instruction)

    csr_rdata_o   : out std_ulogic_vector(data_width_c-1 downto 0); -- CSR read data

    -- FPU interface --

    fpu_flags_i   : in  std_ulogic_vector(04 downto 0); -- exception flags

    -- debug mode (halt) request --

    db_halt_req_i : in  std_ulogic;

    -- interrupts (risc-v compliant) --

    msw_irq_i     : in  std_ulogic; -- machine software interrupt

    mext_irq_i    : in  std_ulogic; -- machine external interrupt

    mtime_irq_i   : in  std_ulogic; -- machine timer interrupt

    -- fast interrupts (custom) --

    firq_i        : in  std_ulogic_vector(15 downto 0);

    -- system time input from MTIME --

    time_i        : in  std_ulogic_vector(63 downto 0); -- current system time

    -- physical memory protection --

    pmp_addr_o    : out pmp_addr_if_t; -- addresses

    pmp_ctrl_o    : out pmp_ctrl_if_t; -- configs

    -- bus access exceptions --

    mar_i         : in  std_ulogic_vector(data_width_c-1 downto 0); -- memory address register

    ma_instr_i    : in  std_ulogic; -- misaligned instruction address

    ma_load_i     : in  std_ulogic; -- misaligned load data address

    ma_store_i    : in  std_ulogic; -- misaligned store data address

    be_instr_i    : in  std_ulogic; -- bus error on instruction access

    be_load_i     : in  std_ulogic; -- bus error on load data access

    be_store_i    : in  std_ulogic  -- bus error on store data access

  );

end neorv32_cpu_control;

architecture neorv32_cpu_control_rtl of neorv32_cpu_control is

  -- CPU core counter ([m]cycle, [m]instret) width - high/low parts --

  constant cpu_cnt_lo_width_c : natural := natural(cond_sel_int_f(boolean(CPU_CNT_WIDTH < 32), CPU_CNT_WIDTH, 32));

  constant cpu_cnt_hi_width_c : natural := natural(cond_sel_int_f(boolean(CPU_CNT_WIDTH > 32), CPU_CNT_WIDTH-32, 0));

  -- HPM counter width - high/low parts --

  constant hpm_cnt_lo_width_c : natural := natural(cond_sel_int_f(boolean(HPM_CNT_WIDTH < 32), HPM_CNT_WIDTH, 32));

  constant hpm_cnt_hi_width_c : natural := natural(cond_sel_int_f(boolean(HPM_CNT_WIDTH > 32), HPM_CNT_WIDTH-32, 0));

  -- instruction fetch engine --

  type fetch_engine_state_t is (IFETCH_REQUEST, IFETCH_ISSUE);

  type fetch_engine_t is record

    state       : fetch_engine_state_t;

    state_nxt   : fetch_engine_state_t;

    state_prev  : fetch_engine_state_t;

    restart     : std_ulogic;

    restart_nxt : std_ulogic;

    align       : std_ulogic;

    align_nxt   : std_ulogic;

    pc          : std_ulogic_vector(data_width_c-1 downto 0);

    pc_nxt      : std_ulogic_vector(data_width_c-1 downto 0);

    reset       : std_ulogic;

    bus_if      : std_ulogic;

  end record;

  signal fetch_engine : fetch_engine_t;

  -- instruction prefetch buffer (FIFO) interface --

  type ipb_data_t is array (0 to 1) of std_ulogic_vector((2+16)-1 downto 0); -- status (bus_error, align_error) + 16-bit instruction

  type ipb_t is record

    wdata : ipb_data_t;

    we    : std_ulogic_vector(1 downto 0); -- trigger write

    free  : std_ulogic_vector(1 downto 0); -- free entry available?

    rdata : ipb_data_t;

    re    : std_ulogic_vector(1 downto 0); -- read enable

    avail : std_ulogic_vector(1 downto 0); -- data available?

  end record;

  signal ipb : ipb_t;

  -- instruction issue engine --

  type issue_engine_t is record

    align     : std_ulogic;

    align_set : std_ulogic;

    align_clr : std_ulogic;

    ci_i16    : std_ulogic_vector(15 downto 0);

    ci_i32    : std_ulogic_vector(31 downto 0);

    ci_ill    : std_ulogic;

    data      : std_ulogic_vector((4+32)-1 downto 0); -- 4-bit status + 32-bit instruction

    valid     : std_ulogic_vector(1 downto 0); -- data word is valid when != 0

  end record;

  signal issue_engine : issue_engine_t;

  -- instruction decoding helper logic --

  type decode_aux_t is record

    is_a_lr  : std_ulogic;

    is_a_sc  : std_ulogic;

    is_f_op  : std_ulogic;

    is_m_mul : std_ulogic;

    is_m_div : std_ulogic;

    is_b_imm : std_ulogic;

    is_b_reg : std_ulogic;

    rs1_zero : std_ulogic;

    rd_zero  : std_ulogic;

  end record;

  signal decode_aux : decode_aux_t;

  -- instruction execution engine --

  type execute_engine_state_t is (DISPATCH, TRAP_ENTER, TRAP_EXIT, TRAP_EXECUTE, EXECUTE, ALU_WAIT,

                                  BRANCH, BRANCHED, LOADSTORE_0, LOADSTORE_1, LOADSTORE_2, SYSTEM);

  type execute_engine_t is record

    state        : execute_engine_state_t;

    state_nxt    : execute_engine_state_t;

    state_prev   : execute_engine_state_t;

    --

    i_reg        : std_ulogic_vector(31 downto 0);

    i_reg_nxt    : std_ulogic_vector(31 downto 0);

    i_reg_last   : std_ulogic_vector(31 downto 0); -- last executed instruction

    --

    is_ci        : std_ulogic; -- current instruction is de-compressed instruction

    is_ci_nxt    : std_ulogic;

    is_ici       : std_ulogic; -- current instruction is illegal de-compressed instruction

    is_ici_nxt   : std_ulogic;

    --

    branch_taken : std_ulogic; -- branch condition fulfilled

    pc           : std_ulogic_vector(data_width_c-1 downto 0); -- actual PC, corresponding to current executed instruction

    pc_mux_sel   : std_ulogic; -- source select for PC update

    pc_we        : std_ulogic; -- PC update enabled

    next_pc      : std_ulogic_vector(data_width_c-1 downto 0); -- next PC, corresponding to next instruction to be executed

    next_pc_inc  : std_ulogic_vector(data_width_c-1 downto 0); -- increment to get next PC

    pc_last      : std_ulogic_vector(data_width_c-1 downto 0); -- PC of last executed instruction

    --

    sleep        : std_ulogic; -- CPU in sleep mode

    sleep_nxt    : std_ulogic;

    branched     : std_ulogic; -- instruction fetch was reset

    branched_nxt : std_ulogic;

  end record;

  signal execute_engine : execute_engine_t;

  -- trap controller --

  type trap_ctrl_t is record

    exc_buf       : std_ulogic_vector(exc_width_c-1 downto 0);

    exc_fire      : std_ulogic; -- set if there is a valid source in the exception buffer

    irq_buf       : std_ulogic_vector(irq_width_c-1 downto 0);

    irq_fire      : std_ulogic; -- set if there is a valid source in the interrupt buffer

    cause         : std_ulogic_vector(6 downto 0); -- trap ID for mcause CSR

    cause_nxt     : std_ulogic_vector(6 downto 0);

    db_irq_fire   : std_ulogic; -- set if there is a valid IRQ source in the "enter debug mode" trap buffer

    db_irq_en     : std_ulogic; -- set if IRQs are allowed in debug mode

    --

    env_start     : std_ulogic; -- start trap handler env

    env_start_ack : std_ulogic; -- start of trap handler acknowledged

    env_end       : std_ulogic; -- end trap handler env

    --

    instr_be      : std_ulogic; -- instruction fetch bus error

    instr_ma      : std_ulogic; -- instruction fetch misaligned address

    instr_il      : std_ulogic; -- illegal instruction

    env_call      : std_ulogic; -- ecall instruction

    break_point   : std_ulogic; -- ebreak instruction

  end record;

  signal trap_ctrl : trap_ctrl_t;

  -- CPU main control bus --

  signal ctrl_nxt, ctrl : std_ulogic_vector(ctrl_width_c-1 downto 0);

  -- RISC-V control and status registers (CSRs) --

  type pmpcfg_t       is array (0 to 15) of std_ulogic_vector(7 downto 0);

  type pmpaddr_t      is array (0 to PMP_NUM_REGIONS-1) of std_ulogic_vector(data_width_c-3 downto index_size_f(PMP_MIN_GRANULARITY)-2);

  type mhpmevent_t    is array (0 to HPM_NUM_CNTS-1) of std_ulogic_vector(hpmcnt_event_size_c-1 downto 0);

  type mhpmevent_rd_t is array (0 to 28) of std_ulogic_vector(data_width_c-1 downto 0);

  type mhpmcnt_t      is array (0 to HPM_NUM_CNTS-1) of std_ulogic_vector(data_width_c-1 downto 0);

  type mhpmcnt_nxt_t  is array (0 to HPM_NUM_CNTS-1) of std_ulogic_vector(data_width_c downto 0);

  type mhpmcnt_ovfl_t is array (0 to HPM_NUM_CNTS-1) of std_ulogic_vector(0 downto 0);

  type mhpmcnt_rd_t   is array (0 to 29) of std_ulogic_vector(data_width_c-1 downto 0);

  type csr_t is record

    addr              : std_ulogic_vector(11 downto 0); -- csr address

    we                : std_ulogic; -- csr write enable

    we_nxt            : std_ulogic;

    re                : std_ulogic; -- csr read enable

    re_nxt            : std_ulogic;

    wdata             : std_ulogic_vector(data_width_c-1 downto 0); -- csr write data

    rdata             : std_ulogic_vector(data_width_c-1 downto 0); -- csr read data

    --

    mstatus_mie       : std_ulogic; -- mstatus.MIE: global IRQ enable (R/W)

    mstatus_mpie      : std_ulogic; -- mstatus.MPIE: previous global IRQ enable (R/W)

    mstatus_mpp       : std_ulogic; -- mstatus.MPP: machine previous privilege mode

    mstatus_tw        : std_ulogic; -- mstatus.TW: do not allow user mode to execute WFI instruction when set

    --

    mie_msie          : std_ulogic; -- mie.MSIE: machine software interrupt enable (R/W)

    mie_meie          : std_ulogic; -- mie.MEIE: machine external interrupt enable (R/W)

    mie_mtie          : std_ulogic; -- mie.MEIE: machine timer interrupt enable (R/W)

    mie_firqe         : std_ulogic_vector(15 downto 0); -- mie.firq*e: fast interrupt enabled (R/W)

    --

    mip_firq_nclr     : std_ulogic_vector(15 downto 0); -- clear pending FIRQ (active-low)

    --

    mcounteren_cy     : std_ulogic; -- mcounteren.cy: allow cycle[h] access from user-mode

    mcounteren_tm     : std_ulogic; -- mcounteren.tm: allow time[h] access from user-mode

    mcounteren_ir     : std_ulogic; -- mcounteren.ir: allow instret[h] access from user-mode

    --

    mcountinhibit_cy  : std_ulogic; -- mcounterinhibit.cy: enable auto-increment for [m]cycle[h]

    mcountinhibit_ir  : std_ulogic; -- mcounterinhibit.ir: enable auto-increment for [m]instret[h]

    mcountinhibit_hpm : std_ulogic_vector(HPM_NUM_CNTS-1 downto 0); -- mcounterinhibit.hpm3: enable auto-increment for mhpmcounterx[h]

    --

    privilege         : std_ulogic; -- current privilege mode

    privilege_eff     : std_ulogic; -- current *effective* privilege mode

    --

    mepc              : std_ulogic_vector(data_width_c-1 downto 0); -- mepc: machine exception pc (R/W)

    mcause            : std_ulogic_vector(5 downto 0); -- mcause: machine trap cause (R/W)

    mtvec             : std_ulogic_vector(data_width_c-1 downto 0); -- mtvec: machine trap-handler base address (R/W), bit 1:0 == 00

    mtval             : std_ulogic_vector(data_width_c-1 downto 0); -- mtval: machine bad address or instruction (R/W)

    --

    mhpmevent         : mhpmevent_t; -- mhpmevent*: machine performance-monitoring event selector (R/W)

    mhpmevent_rd      : mhpmevent_rd_t; -- read data

    --

    mscratch          : std_ulogic_vector(data_width_c-1 downto 0); -- mscratch: scratch register (R/W)

    --

    mcycle            : std_ulogic_vector(data_width_c-1 downto 0); -- mcycle (R/W)

    mcycle_nxt        : std_ulogic_vector(data_width_c downto 0);

    mcycle_ovfl       : std_ulogic_vector(00 downto 0); -- counter low-to-high-word overflow

    mcycleh           : std_ulogic_vector(data_width_c-1 downto 0); -- mcycleh (R/W)

    minstret          : std_ulogic_vector(data_width_c-1 downto 0); -- minstret (R/W)

    minstret_nxt      : std_ulogic_vector(data_width_c downto 0);

    minstret_ovfl     : std_ulogic_vector(00 downto 0); -- counter low-to-high-word overflow

    minstreth         : std_ulogic_vector(data_width_c-1 downto 0); -- minstreth (R/W)

    --

    mhpmcounter       : mhpmcnt_t; -- mhpmcounter* (R/W), plus carry bit

    mhpmcounter_nxt   : mhpmcnt_nxt_t;

    mhpmcounter_ovfl  : mhpmcnt_ovfl_t; -- counter low-to-high-word overflow

    mhpmcounterh      : mhpmcnt_t; -- mhpmcounter*h (R/W)

    mhpmcounter_rd    : mhpmcnt_rd_t; -- mhpmcounter* (R/W): actual read data

    mhpmcounterh_rd   : mhpmcnt_rd_t; -- mhpmcounter*h (R/W): actual read data

    --

    pmpcfg            : pmpcfg_t; -- physical memory protection - configuration registers

    pmpaddr           : pmpaddr_t; -- physical memory protection - address registers (bits 33:2 of PHYSICAL address)

    --

    frm               : std_ulogic_vector(02 downto 0); -- frm (R/W): FPU rounding mode

    fflags            : std_ulogic_vector(04 downto 0); -- fflags (R/W): FPU exception flags

    --

    dcsr_ebreakm      : std_ulogic; -- dcsr.ebreakm (R/W): behavior of ebreak instruction on m-mode

    dcsr_ebreaku      : std_ulogic; -- dcsr.ebreaku (R/W): behavior of ebreak instruction on u-mode

    dcsr_step         : std_ulogic; -- dcsr.step (R/W): single-step mode

    dcsr_prv          : std_ulogic; -- dcsr.prv (R/W): current privilege level when entering debug mode

    dcsr_cause        : std_ulogic_vector(02 downto 0); -- dcsr.cause (R/-): why was debug mode entered

    dcsr_rd           : std_ulogic_vector(data_width_c-1 downto 0); -- dcsr (R/(W)): debug mode control and status register

    dpc               : std_ulogic_vector(data_width_c-1 downto 0); -- dpc (R/W): debug mode program counter

    dscratch0         : std_ulogic_vector(data_width_c-1 downto 0); -- dscratch0 (R/W): debug mode scratch register 0

    --

    tdata1_exe        : std_ulogic; -- enable (match) trigger

    tdata1_rd         : std_ulogic_vector(data_width_c-1 downto 0); -- tdata1 (R/(W)): trigger register read-back

    tdata2            : std_ulogic_vector(data_width_c-1 downto 0); -- tdata2 (R/W): address-match register

  end record;

  signal csr : csr_t;

  -- debug mode controller --

  type debug_ctrl_state_t is (DEBUG_OFFLINE, DEBUG_PENDING, DEBUG_ONLINE, DEBUG_EXIT);

  type debug_ctrl_t is record

    state        : debug_ctrl_state_t;

    -- decoded state --

    running      : std_ulogic; -- debug mode active

    pending      : std_ulogic; -- waiting to start debug mode

    -- entering triggers --

    trig_hw      : std_ulogic; -- hardware trigger

    trig_break   : std_ulogic; -- ebreak instruction

    trig_halt    : std_ulogic; -- external request

    trig_step    : std_ulogic; -- single-stepping mode

    -- leave debug mode --

    dret         : std_ulogic; -- executed DRET instruction

    -- misc --

    ext_halt_req : std_ulogic;

  end record;

  signal debug_ctrl : debug_ctrl_t;

  -- (hpm) counter events --

  signal cnt_event      : std_ulogic_vector(hpmcnt_event_size_c-1 downto 0);

  signal hpmcnt_trigger : std_ulogic_vector(HPM_NUM_CNTS-1 downto 0);

  -- illegal instruction check --

  signal illegal_cmd : std_ulogic;

  signal illegal_reg : std_ulogic; -- illegal register (>x15) - E-extension

  -- access (privilege) check --

  signal csr_acc_valid : std_ulogic; -- valid CSR access (implemented and valid access rights)

  -- hardware trigger module --

  signal hw_trigger_fire : std_ulogic;

begin

-- ****************************************************************************************************************************

-- Instruction Fetch (always fetch 32-bit-aligned 32-bit chunks of data)

-- ****************************************************************************************************************************

  -- Fetch Engine FSM Sync ------------------------------------------------------------------

  -- -------------------------------------------------------------------------------------------

  fetch_engine_fsm_sync: process(rstn_i, clk_i)

  begin

    if (rstn_i = '0') then

      fetch_engine.state      <= IFETCH_REQUEST;

      fetch_engine.state_prev <= IFETCH_REQUEST;

      fetch_engine.restart    <= '1';

      fetch_engine.align      <= '0'; -- always start at aligned address after reset

      fetch_engine.pc         <= (others => def_rst_val_c);

    elsif rising_edge(clk_i) then

      fetch_engine.state      <= fetch_engine.state_nxt;

      fetch_engine.state_prev <= fetch_engine.state;

      fetch_engine.restart    <= fetch_engine.restart_nxt or fetch_engine.reset;

      fetch_engine.align      <= fetch_engine.align_nxt and bool_to_ulogic_f(CPU_EXTENSION_RISCV_C);

      fetch_engine.pc         <= fetch_engine.pc_nxt;

    end if;

  end process fetch_engine_fsm_sync;

  -- PC output --

  fetch_pc_o <= fetch_engine.pc(data_width_c-1 downto 1) & '0'; -- half-word aligned

  -- Fetch Engine FSM Comb ------------------------------------------------------------------

  -- -------------------------------------------------------------------------------------------

  fetch_engine_fsm_comb: process(fetch_engine, execute_engine, ipb, instr_i, bus_i_wait_i, be_instr_i, ma_instr_i)

  begin

    -- arbiter defaults --

    fetch_engine.bus_if      <= '0';

    fetch_engine.state_nxt   <= fetch_engine.state;

    fetch_engine.pc_nxt      <= fetch_engine.pc;

    fetch_engine.restart_nxt <= fetch_engine.restart;

    fetch_engine.align_nxt   <= fetch_engine.align;

    -- instruction prefetch buffer defaults --

    ipb.we       <= "00";

    ipb.wdata(0) <= be_instr_i & ma_instr_i & instr_i(15 downto 00);

    ipb.wdata(1) <= be_instr_i & ma_instr_i & instr_i(31 downto 16);

    -- state machine --

    if (fetch_engine.state = IFETCH_REQUEST) then -- REQUEST: request new 32-bit-aligned instruction word

    -- ------------------------------------------------------------

      if (fetch_engine.restart = '1') then -- reset request

        fetch_engine.pc_nxt    <= execute_engine.pc(data_width_c-1 downto 1) & '0'; -- initialize with "real" application PC

        fetch_engine.align_nxt <= execute_engine.pc(1);

      elsif (ipb.free = "11") then -- free entries in both buffers

        fetch_engine.bus_if    <= '1'; -- instruction fetch request

        fetch_engine.state_nxt <= IFETCH_ISSUE;

      end if;

      fetch_engine.restart_nxt <= '0'; -- restart done

    else -- ISSUE: store instruction data to prefetch buffer

    -- ------------------------------------------------------------

      if (bus_i_wait_i = '0') or (be_instr_i = '1') or (ma_instr_i = '1') then -- wait for bus response

        fetch_engine.pc_nxt    <= std_ulogic_vector(unsigned(fetch_engine.pc) + 4);

        fetch_engine.align_nxt <= '0';

        fetch_engine.state_nxt <= IFETCH_REQUEST;

        if (fetch_engine.restart = '0') then -- write to IPB if not being reset

          ipb.we(0) <= not fetch_engine.align; -- not start at unaligned address

          ipb.we(1) <= '1';

        end if;

      end if;

    end if;

  end process fetch_engine_fsm_comb;

-- ****************************************************************************************************************************

-- Instruction Prefetch Buffer

-- ****************************************************************************************************************************

  -- Instruction Prefetch Buffer (FIFO) -----------------------------------------------------

  -- -------------------------------------------------------------------------------------------

  prefetch_buffer:

  for i in 0 to 1 generate -- high half-word and low half-word

    prefetch_buffer_inst: neorv32_fifo

    generic map (

      FIFO_DEPTH => CPU_IPB_ENTRIES,     -- number of fifo entries; has to be a power of two; min 1

      FIFO_WIDTH => ipb.wdata(i)'length, -- size of data elements in fifo

      FIFO_RSYNC => false,               -- we NEED to read data asynchronously

      FIFO_SAFE  => false                -- no safe access required (ensured by FIFO-external control)

    )

    port map (

      -- control --

      clk_i   => clk_i,                -- clock, rising edge

      rstn_i  => '1',                  -- async reset, low-active

      clear_i => fetch_engine.restart, -- sync reset, high-active

      level_o => open,

      half_o  => open,

      -- write port --

      wdata_i => ipb.wdata(i),         -- write data

      we_i    => ipb.we(i),            -- write enable

      free_o  => ipb.free(i),          -- at least one entry is free when set

      -- read port --

      re_i    => ipb.re(i),            -- read enable

      rdata_o => ipb.rdata(i),         -- read data

      avail_o => ipb.avail(i)          -- data available when set

    );

  end generate;

-- ****************************************************************************************************************************

-- Instruction Issue (decompress 16-bit instructions and assemble 32-bit instruction word)

-- ****************************************************************************************************************************

  -- Issue Engine FSM Sync ------------------------------------------------------------------

  -- -------------------------------------------------------------------------------------------

  issue_engine_fsm_sync: process(rstn_i, clk_i)

  begin

    if (rstn_i = '0') then

      issue_engine.align <= '0'; -- always start aligned after reset

    elsif rising_edge(clk_i) then

      if (CPU_EXTENSION_RISCV_C = true) then

        if (fetch_engine.restart = '1') then

          issue_engine.align <= execute_engine.pc(1); -- branch to unaligned address?

        elsif (execute_engine.state = DISPATCH) then

          issue_engine.align <= (issue_engine.align and (not issue_engine.align_clr)) or issue_engine.align_set;

        end if;

      else

        issue_engine.align <= '0'; -- always aligned

      end if;

    end if;

  end process issue_engine_fsm_sync;

  -- Issue Engine FSM Comb ------------------------------------------------------------------

  -- -------------------------------------------------------------------------------------------

  issue_engine_fsm_comb: process(issue_engine.align, ipb)

  begin

    -- defaults --

    issue_engine.align_set <= '0';

    issue_engine.align_clr <= '0';

    issue_engine.valid     <= "00";

    -- start with LOW half-word --

    if (issue_engine.align = '0') or (CPU_EXTENSION_RISCV_C = false) then

      if (CPU_EXTENSION_RISCV_C = true) and (ipb.rdata(0)(1 downto 0) /= "11") then -- compressed

        issue_engine.align_set <= ipb.avail(0); -- start of next instruction word is not 32-bit aligned

        issue_engine.valid(0)  <= ipb.avail(0);

        issue_engine.data      <= issue_engine.ci_ill & ipb.rdata(0)(17 downto 16) & '1' & issue_engine.ci_i32;

      else -- aligned uncompressed

        issue_engine.valid <= (others => (ipb.avail(0) and ipb.avail(1)));

        issue_engine.data  <= '0' & (ipb.rdata(1)(17 downto 16) or ipb.rdata(0)(17 downto 16)) &

                              '0' & (ipb.rdata(1)(15 downto 00)  & ipb.rdata(0)(15 downto 00));

      end if;

    -- start with HIGH half-word --

    else

      if (CPU_EXTENSION_RISCV_C = true) and (ipb.rdata(1)(1 downto 0) /= "11") then -- compressed

        issue_engine.align_clr <= ipb.avail(1); -- start of next instruction word is 32-bit aligned again

        issue_engine.valid(1)  <= ipb.avail(1);

        issue_engine.data      <= issue_engine.ci_ill & ipb.rdata(1)(17 downto 16) & '1' & issue_engine.ci_i32;

      else -- unaligned uncompressed

        issue_engine.valid <= (others => (ipb.avail(0) and ipb.avail(1)));

        issue_engine.data  <= '0' & (ipb.rdata(0)(17 downto 16) or ipb.rdata(1)(17 downto 16)) &

                              '0' & (ipb.rdata(0)(15 downto 00)  & ipb.rdata(1)(15 downto 00));

      end if;

    end if;

  end process issue_engine_fsm_comb;

  -- update IPB FIFOs (read-for-next)? --

  ipb.re <= issue_engine.valid when (execute_engine.state = DISPATCH) else "00";

  -- Compressed Instructions Decoding -------------------------------------------------------

  -- -------------------------------------------------------------------------------------------

  neorv32_cpu_decompressor_inst_true:

  if (CPU_EXTENSION_RISCV_C = true) generate

    neorv32_cpu_decompressor_inst: neorv32_cpu_decompressor

    generic map (

      FPU_ENABLE => CPU_EXTENSION_RISCV_Zfinx -- floating-point instructions enabled

    )

    port map (

      -- instruction input --

      ci_instr16_i => issue_engine.ci_i16, -- compressed instruction input

      -- instruction output --

      ci_illegal_o => issue_engine.ci_ill, -- illegal compressed instruction

      ci_instr32_o => issue_engine.ci_i32  -- 32-bit decompressed instruction

    );

  end generate;

  neorv32_cpu_decompressor_inst_false:

  if (CPU_EXTENSION_RISCV_C = false) generate

    issue_engine.ci_i32 <= (others => '0');

    issue_engine.ci_ill <= '0';

  end generate;

  -- 16-bit instructions: half-word select --

  issue_engine.ci_i16 <= ipb.rdata(0)(15 downto 0) when (issue_engine.align = '0') else ipb.rdata(1)(15 downto 0);

-- ****************************************************************************************************************************

-- Instruction Execution

-- ****************************************************************************************************************************