library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.numeric_std.all;
use IEEE.MATH_REAL.all;
library ganimede;
use ganimede.io_types.all;


package socbridge_driver_tb_pkg is
  subtype command_size_t is integer range 0 to 128;

  type command_t is 
    (NO_OP, WRITE_ADD, WRITE, READ_ADD, READ, P_ERR);

  type response_t is 
    (NO_OP, WRITE_ACK, READ_RESPONSE);

  type rx_state_t is
    (IDLE, ADDR1, ADDR2, ADDR3, ADDR4, 
     CMD, RESPONSE, READ, WRITE, PAYLOAD,
     RX_HEADER, RX_RESPONSE, RX_BODY);

  type tx_state_t is
    (IDLE, ADDR1, ADDR2, ADDR3, ADDR4,
    CMD, RESPONSE, READ, WRITE, PAYLOAD,
     TX_HEADER, TX_BODY, TX_ACK);
  --- TRANSLATOR ---
  type translator_state_t is (IDLE, SEND, SEND_ACCEPTED, AWAIT);

  type translator_state_rec_t is record
    curr_inst : controller_to_socbridge_driver_t;
    curr_state : translator_state_t;
    is_first_word : std_logic;
  end record translator_state_rec_t;

  type ext_protocol_t is record
    data   : std_logic_vector(interface_inst.socbridge.payload_width - 1 downto 0);
    clk    : std_logic;
    parity : std_logic;
  end record ext_protocol_t;

  type state_rec_t is record
    curr_rx_state: rx_state_t;
    curr_tx_state: tx_state_t;
    ext_to_socbridge_driver_reg, socbridge_driver_to_ext_reg : ext_protocol_t; 
    write_stage, read_stage : NATURAL;
    curr_cmd : command_t;
    curr_cmd_size: integer;
    curr_addr : std_logic_vector(31 downto 0);
  end record state_rec_t;
  impure function calc_parity(
    d : STD_LOGIC_VECTOR(interface_inst.socbridge.payload_width - 1 downto 0)
  ) return std_logic;
  pure function create_io_type_out_from_ext_protocol(
  input: ext_protocol_t
  ) return socbridge_driver_to_ext_t;
  function to_string ( a: std_logic_vector) return string;
  pure function get_cmd_bits(command : command_t) return std_logic_vector;
  pure function get_size_bits(size : command_size_t) return std_logic_vector;
  pure function get_size_bits_sim(size : command_size_t) return std_logic_vector;
  --- DEBUG GLOBAL SIGNALS ---
  -- synthesis translate_off 
  signal G_next_parity_out : std_logic;
  signal G_ext_to_socbridge_driver_rec : ext_protocol_t;
  signal G_socbridge_driver_to_ext_data_cmd : std_logic_vector(interface_inst.socbridge.payload_width - 1 downto 0);
  signal G_next_rx_state : rx_state_t;
  signal G_next_tx_state : tx_state_t;
  signal G_curr_command : command_t;
  signal G_curr_command_bits : std_logic_vector(4 downto 0);
  signal G_curr_response : response_t;
  signal G_curr_response_bits : std_logic_vector(4 downto 0);
  signal G_st : state_rec_t;
  signal G_trans_st : translator_state_rec_t;
  -- synthesis translate_on 
  
end package socbridge_driver_tb_pkg;

package body socbridge_driver_tb_pkg is
  function to_string ( a: std_logic_vector) return string is
  variable b : string (1 to a'length) := (others => NUL);
  variable stri : integer := 1; 
  begin
      for i in a'range loop
          b(stri) := std_logic'image(a((i)))(2);
      stri := stri+1;
      end loop;
  return b;
  end function;
  
  impure function calc_parity(
    d : STD_LOGIC_VECTOR(interface_inst.socbridge.payload_width - 1 downto 0)
  ) return std_logic is
  variable parity : std_logic;
  begin
    parity := d(0);
    for x in integer'(1) to d'length - 1 loop
      parity := parity xor d(x);
    end loop;
    return not parity;
  end function;

  
  
  pure function create_io_type_out_from_ext_protocol(
    input : ext_protocol_t
  ) return socbridge_driver_to_ext_t is
  variable val : socbridge_driver_to_ext_t;
  begin
    val.payload:= input.data;
    val.control(1) := input.clk;
    val.control(0) := input.parity;
    return val;
  end function;
  pure function get_cmd_bits(command : command_t) 
    return std_logic_vector is
  variable val : std_logic_vector(4 downto 0);
  begin
    with command select
      val := "00000" when NO_OP,
             "10000" when WRITE_ADD,
             "10100" when WRITE,
             "11000" when READ_ADD,
             "11100" when READ,
             "01001" when P_ERR,      
             "11111" when others;   
    return val;
  end function;
  
  
  pure function get_size_bits(size: command_size_t) 
    return std_logic_vector is
  variable val : std_logic_vector(2 downto 0);
  begin
    if size > 2**6 then
      val := "111";
    elsif size > 2**5 then
      val := "110";
    elsif size > 2**4 then
      val := "101";
    elsif size > 2**3 then
      val := "100";
    elsif size > 2**2 then
      val := "011";
    elsif size > 2**1 then
      val := "010";
    elsif size > 2**0 then
      val := "001";
    elsif size >= 0 then
      val := "000";
    end if;
    return val;
  end function;
  pure function get_size_bits_sim(size: command_size_t) 
    return std_logic_vector is
  variable pow : integer;
  variable val : std_logic_vector(2 downto 0);
  begin
    pow := integer(CEIL(sqrt(Real(size))));
    val := std_logic_vector(TO_UNSIGNED(size - 1, 3));
    return val;
  end function;
end package body socbridge_driver_tb_pkg;