coding help

Discussion in 'VHDL' started by chinmay shah, May 28, 2006.

  1. chinmay shah

    chinmay shah

    Joined:
    May 15, 2006
    Messages:
    2
    hi
    i m trying to implment blowfish encryption algorithm . and i m trying to implement the below code and when i check syntex of this code it perfect and no problme with this but whn i tried to implement the test bench it gives error for the 'unsigned' data type.
    so can any one suggest whts wrong in this code it whould be great help for me
    thanx


    library ieee;
    use ieee.std_logic_1164.all;
    use ieee.numeric_std.all;


    entity parray_control is
    port (
    clk : in std_logic;

    init_parray : in bit; -- tells us to initialize the parray
    sub_parray : in bit; -- tells us to run the zero_block through

    sub_parray_done : out bit;

    sboxes_zero_block : out unsigned(63 downto 0); -- to sboxes_control

    parray_init_addr : buffer unsigned(4 downto 0);
    parray_init_chunk : out unsigned(31 downto 0);
    parray_init_data : in unsigned(31 downto 0);
    parray_addr : out unsigned(4 downto 0);
    parray_data_in : out unsigned(31 downto 0);
    parray_data_out : in unsigned(31 downto 0);
    parray_we : out bit;
    parray_crypt_go : out bit;
    parray_crypt_ptext : out unsigned(63 downto 0);

    crypt_ctext : in unsigned(63 downto 0);
    crypt_parray_addr : in unsigned(4 downto 0);
    crypt_parray_data : out unsigned(31 downto 0);
    crypt_done : in bit;

    keychunk_blob : in unsigned(447 downto 0)

    );
    end parray_control;

    architecture fishy of parray_control is

    type PARRAY_STATES is (PASS, INIT, SUB, SUB_WRITE1, SUB_WRITE2);
    signal parray_state : PARRAY_STATES;

    type KEYCHUNK_TYPE is array (0 to 13) of unsigned(31 downto 0);
    signal keychunk : KEYCHUNK_TYPE;

    signal zero_block : unsigned(63 downto 0);

    begin

    -- split up the blob into the chunks we just selected
    keychunk(0) <= keychunk_blob(31 downto 0);
    keychunk(1) <= keychunk_blob(63 downto 32);
    keychunk(2) <= keychunk_blob(95 downto 64);
    keychunk(3) <= keychunk_blob(127 downto 96);
    keychunk(4) <= keychunk_blob(159 downto 128);
    keychunk(5) <= keychunk_blob(191 downto 160);
    keychunk(6) <= keychunk_blob(223 downto 192);
    keychunk(7) <= keychunk_blob(255 downto 224);
    keychunk(8) <= keychunk_blob(287 downto 256);
    keychunk(9) <= keychunk_blob(319 downto 288);
    keychunk(10) <= keychunk_blob(351 downto 320);
    keychunk(11) <= keychunk_blob(383 downto 352);
    keychunk(12) <= keychunk_blob(415 downto 384);
    keychunk(13) <= keychunk_blob(447 downto 416);

    -- process to control parray initialization
    process(clk, parray_state, init_parray, crypt_done, parray_init_addr,
    sub_parray, keychunk)
    variable just_started : std_logic;
    begin
    if (clk'event AND clk = '1') then
    sub_parray_done <= '0';
    if (parray_state = SUB) then
    if (crypt_done = '1' AND just_started = '0') then
    parray_state <= SUB_WRITE1;
    --parray_init_addr - don't modify it
    parray_init_chunk <= (others => '0');
    parray_crypt_go <= '0';
    else
    just_started := '0';
    parray_state <= SUB;
    --parray_init_addr - don't modify it
    parray_init_chunk <= (others => '0');
    parray_crypt_go <= '0';
    end if;
    elsif (parray_state = SUB_WRITE1) then
    parray_state <= SUB_WRITE2;
    parray_init_addr <= parray_init_addr + 1;
    parray_init_chunk <= (others => '0');
    parray_crypt_go <= '0';
    elsif (parray_state = SUB_WRITE2) then
    if (parray_init_addr = 17) then
    parray_state <= PASS;
    parray_crypt_go <= '0';
    else
    parray_state <= SUB;
    parray_crypt_go <= '1';
    end if;
    parray_init_addr <= parray_init_addr + 1;
    parray_init_chunk <= (others => '0');
    just_started := '1'; -- so we don't write two in a row!
    elsif (sub_parray = '1') then
    parray_state <= SUB;
    parray_init_addr <= (others => '0');
    parray_init_chunk <= (others => '0');
    parray_crypt_go <= '1';
    just_started := '1';
    elsif (parray_state = INIT) then
    if (parray_init_addr = 17) then
    parray_state <= PASS;
    else
    parray_state <= INIT;
    end if;
    parray_init_addr <= parray_init_addr + 1;
    case parray_init_addr is
    when "00000" => parray_init_chunk <= keychunk(1);
    when "00001" => parray_init_chunk <= keychunk(2);
    when "00010" => parray_init_chunk <= keychunk(3);
    when "00011" => parray_init_chunk <= keychunk(4);
    when "00100" => parray_init_chunk <= keychunk(5);
    when "00101" => parray_init_chunk <= keychunk(6);
    when "00110" => parray_init_chunk <= keychunk(7);
    when "00111" => parray_init_chunk <= keychunk(8);
    when "01000" => parray_init_chunk <= keychunk(9);
    when "01001" => parray_init_chunk <= keychunk(10);
    when "01010" => parray_init_chunk <= keychunk(11);
    when "01011" => parray_init_chunk <= keychunk(12);
    when "01100" => parray_init_chunk <= keychunk(13);
    when "01101" => parray_init_chunk <= keychunk(0);
    when "01110" => parray_init_chunk <= keychunk(1);
    when "01111" => parray_init_chunk <= keychunk(2);
    when others => parray_init_chunk <= keychunk(3);
    end case;
    parray_crypt_go <= '0';
    elsif (init_parray = '1') then
    parray_state <= INIT;
    parray_init_addr <= (others => '0');
    parray_init_chunk <= keychunk(0);
    parray_crypt_go <= '0';
    else -- if we're not initializing, just pass-through
    parray_state <= PASS;
    parray_init_addr <= (others => '0');
    parray_init_chunk <= (others => '0');
    parray_crypt_go <= '0';
    sub_parray_done <= '1';
    end if;
    end if;
    end process;

    -- process to control the zero_block used in initalizations
    process(clk, parray_state, zero_block, crypt_ctext, sub_parray)
    begin
    if (clk'event AND clk = '1') then
    if (parray_state = SUB_WRITE1) then
    zero_block <= crypt_ctext;
    sboxes_zero_block <= crypt_ctext;
    elsif (sub_parray = '1') then
    zero_block <= (others => '0');
    end if;
    end if;
    parray_crypt_ptext <= zero_block;
    end process;


    crypt_parray_data <= parray_data_out;

    -- process to allow parray init or passthrough to crypt
    process(parray_state, parray_init_addr, parray_init_data, crypt_parray_addr,
    crypt_ctext)
    begin
    if (parray_state = SUB_WRITE1) then
    parray_we <= '1';
    parray_addr <= parray_init_addr;
    parray_data_in <= crypt_ctext(63 downto 32);
    elsif (parray_state = SUB_WRITE2) then
    parray_we <= '1';
    parray_addr <= parray_init_addr;
    parray_data_in <= crypt_ctext(31 downto 0);
    elsif (parray_state = INIT) then
    parray_we <= '1';
    parray_addr <= parray_init_addr;
    parray_data_in <= parray_init_data;
    else
    parray_we <= '0';
    parray_addr <= crypt_parray_addr;
    parray_data_in <= (others => '0');
    end if;
    end process;

    end;
    chinmay shah, May 28, 2006
    #1
    1. Advertising

  2. chinmay shah

    shobhit24

    Joined:
    Jun 28, 2006
    Messages:
    5
    Hi

    can u plz write me code for SRT Division(Sweeney,Robertson and Tocher)

    I would be very thankfull to u,

    Plz reply fast
    shobhit24, Jun 28, 2006
    #2
    1. Advertising

  3. chinmay shah

    molson

    Joined:
    Aug 29, 2006
    Messages:
    1
    Hi, Chinmay
    Do you still have the VCOM-1137 problem?

    If you have solution, could you let me know?

    -molson
    molson, Aug 30, 2006
    #3
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. msd
    Replies:
    1
    Views:
    564
    Mike Treseler
    Feb 22, 2005
  2. apssingh
    Replies:
    1
    Views:
    648
    Ajeetha
    Jan 11, 2006
  3. John Cosmas
    Replies:
    2
    Views:
    594
    Curt_C [MVP]
    Aug 30, 2004
  4. Milsnips

    need some help with coding

    Milsnips, Oct 17, 2005, in forum: ASP .Net
    Replies:
    1
    Views:
    406
    Milsnips
    Oct 17, 2005
  5. calmar
    Replies:
    11
    Views:
    847
    calmar
    Feb 21, 2006
Loading...

Share This Page