URL https://opencores.org/ocsvn/present/present/trunk

Subversion Repositories present

[/] [present/] [trunk/] [PureTesting/] [rtl/] [vhdl/] [PresentCommSM.vhd] - Blame information for rev 4

Go to most recent revision | Details | Compare with Previous | View Log


-----------------------------------------------------------------------
----                                                               ----
---- Present - a lightweight block cipher project                  ----
----                                                               ----
---- This file is part of the Present - a lightweight block        ----
---- cipher project                                                ----
---- http://www.http://opencores.org/project,present               ----
----                                                               ----
---- Description:                                                  ----
----     State machine of 'pure' Present cipher with RS-232        ----
---- communication with PC. For more informations see below.       ----
---- To Do:                                                        ----
----                                                               ----
---- Author(s):                                                    ----
---- - Krzysztof Gajewski, gajos@opencores.org                     ----
----                       k.gajewski@gmail.com                    ----
----                                                               ----
-----------------------------------------------------------------------
----                                                               ----
---- Copyright (C) 2013 Authors and OPENCORES.ORG                  ----
----                                                               ----
---- This source file may be used and distributed without          ----
---- restriction provided that this copyright statement is not     ----
---- removed from the file and that any derivative work contains   ----
---- the original copyright notice and the associated disclaimer.  ----
----                                                               ----
---- This source file is free software; you can redistribute it    ----
---- and-or modify it under the terms of the GNU Lesser General    ----
---- Public License as published by the Free Software Foundation;  ----
---- either version 2.1 of the License, or (at your option) any    ----
---- later version.                                                ----
----                                                               ----
---- This source is distributed in the hope that it will be        ----
---- useful, but WITHOUT ANY WARRANTY; without even the implied    ----
---- warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR       ----
---- PURPOSE. See the GNU Lesser General Public License for more   ----
---- details.                                                      ----
----                                                               ----
---- You should have received a copy of the GNU Lesser General     ----
---- Public License along with this source; if not, download it    ----
---- from http://www.opencores.org/lgpl.shtml                      ----
----                                                               ----
-----------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use work.kody.ALL;
 
-- Uncomment the following library declaration if using
-- arithmetic functions with Signed or Unsigned values
--use IEEE.NUMERIC_STD.ALL;
 
-- Uncomment the following library declaration if instantiating
-- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
 
entity PresentCommSM is
        port (
                clk                             : in STD_LOGIC;
                reset                           : in STD_LOGIC;
                RDAsig                  : in STD_LOGIC;
                TBEsig                  : in STD_LOGIC;
                RDsig                           : out STD_LOGIC;
                WRsig                           : out STD_LOGIC;
                textDataEn     : out STD_LOGIC;
                textDataShift   : out STD_LOGIC;
                keyDataEn               : out STD_LOGIC;
                keyDataShift    : out STD_LOGIC;
                ciphDataEn     : out STD_LOGIC;
                ciphDataShift  : out STD_LOGIC;
                startSig                        : out STD_LOGIC;
                readySig                        : in STD_LOGIC
        );
end PresentCommSM;
 
architecture Behavioral of PresentCommSM is
 
-- counter used for determine number of readed/sended data (key, text, result)
component counter is
        generic (
                w_5 : integer := 5
        );
        port (
                clk, reset, cnt_res : in std_logic;
                num : out std_logic_vector (w_5-1 downto 0)
        );
end component counter;
 
-- signals
 
signal state      : stany_comm := NOP;
signal next_state : stany_comm := NOP;
 
-- modify for variable key size
signal serialDataCtrCt    : STD_LOGIC;
signal serialDataCtrOut   : STD_LOGIC_VECTOR(3 downto 0);
signal serialDataCtrReset : STD_LOGIC;
signal ctrReset                   : STD_LOGIC;
-- DO NOT MODIFY!!!
signal shiftDataCtrCt    : STD_LOGIC;
signal shiftDataCtrOut   : STD_LOGIC_VECTOR(2 downto 0);
 
begin
    -- In this state machine is determined, that firs data should be 64 bit text
        -- after text, key should appear. After receiving last byte of key, ciphertext
        -- is counted. And later it is sended back to PC.
        ctrReset <= serialDataCtrReset or reset;
        SM : process(state, RDAsig, TBEsig, shiftDataCtrOut, serialDataCtrOut, readySig)
                begin
                        case state is
                            -- No operation - waiting for incoming data
                                when NOP =>
                                        RDsig                                    <= '0';
                                        WRsig                                    <= '0';
                                        textDataEn                       <= '0';
                                        textDataShift            <= '0';
                                        keyDataEn                        <= '0';
                                        keyDataShift             <= '0';
                                        ciphDataEn                       <= '0';
                                        ciphDataShift            <= '0';
                                        startSig                                 <= '0';
                                        serialDataCtrCt  <= '0';
                                        shiftDataCtrCt           <= '0';
                                        serialDataCtrReset <= '0';
                                        -- data has come
                                        if (RDAsig = '1') then
                                                next_state <= READ_DATA_TEXT;
                                        else
                                                next_state <= NOP;
                                        end if;
                                -- Text data enable and read data
                                when READ_DATA_TEXT =>
                                        RDsig                                    <= '1';
                                        WRsig                                    <= '0';
                                        textDataEn                       <= '1';
                                        textDataShift            <= '0';
                                        keyDataEn                        <= '0';
                                        keyDataShift             <= '0';
                                        ciphDataEn                       <= '0';
                                        ciphDataShift            <= '0';
                                        startSig                                 <= '0';
                                        -- counter of retrieved bytes
                                        serialDataCtrCt  <= '1';
                                        shiftDataCtrCt           <= '0';
                                        serialDataCtrReset <= '0';
                                        next_state <= DECODE_READ_TEXT;
                                -- Data readed, stop counter and check if proper number of byte
                                -- was readed
                                when DECODE_READ_TEXT =>
                                        RDsig                                    <= '0';
                                        WRsig                                    <= '0';
                                        textDataEn                       <= '0';
                                        textDataShift            <= '0';
                                        keyDataEn                        <= '0';
                                        keyDataShift             <= '0';
                                        ciphDataEn                       <= '0';
                                        ciphDataShift            <= '0';
                                        startSig                                 <= '0';
                                        serialDataCtrCt  <= '0';
                                        shiftDataCtrCt           <= '0';
                                        -- 8 bytes should be readed
                                        if (serialDataCtrOut(3 downto 0) = "1000") then
                                            -- 8 bytes was readed
                                                next_state <= TEMP_STATE;
                                        else
                                            -- 8 bytes was not readed
                                                next_state <= MOVE_TEXT;
                                        end if;
                                -- Reset counter for next reading
                                when TEMP_STATE =>
                                        RDsig                                    <= '0';
                                        WRsig                                    <= '0';
                                        textDataEn                       <= '0';
                                        textDataShift            <= '0';
                                        keyDataEn                        <= '0';
                                        keyDataShift             <= '0';
                                        ciphDataEn                       <= '0';
                                        ciphDataShift            <= '0';
                                        startSig                                 <= '0';
                                        serialDataCtrCt  <= '0';
                                        shiftDataCtrCt           <= '0';
                                        serialDataCtrReset <= '1';
                                        next_state <= NOP_FOR_KEY;
                                -- Here data are shfted in shift register - another shift counter are used
                                when MOVE_TEXT =>
                                        RDsig                                    <= '0';
                                        WRsig                                    <= '0';
                                        textDataEn                       <= '0';
                                        textDataShift            <= '1';
                                        keyDataEn                        <= '0';
                                        keyDataShift             <= '0';
                                        ciphDataEn                       <= '0';
                                        ciphDataShift            <= '0';
                                        startSig                                 <= '0';
                                        serialDataCtrCt  <= '0';
                                        shiftDataCtrCt   <= '1';
                                        serialDataCtrReset <= '0';
                                        if (shiftDataCtrOut(2 downto 0) = "111") then
                                                next_state <= NOP;
                                        else
                                                next_state <= MOVE_TEXT;
                                        end if;
                                -- "No operation 2" waiting for data - it could be optimized in way,
                                -- that waiting for key and text could be the same state, but it was
                                -- intentionally separated.
                                when NOP_FOR_KEY        =>
                                        RDsig                                    <= '0';
                                        WRsig                                    <= '0';
                                        textDataEn                       <= '0';
                                        textDataShift            <= '0';
                                        keyDataEn                        <= '0';
                                        keyDataShift             <= '0';
                                        ciphDataEn                       <= '0';
                                        ciphDataShift            <= '0';
                                        startSig                                 <= '0';
                                        serialDataCtrCt  <= '0';
                                        shiftDataCtrCt           <= '0';
                                        serialDataCtrReset <= '0';
                                        if (RDAsig = '1') then
                                            -- data has come
                                                next_state <= READ_DATA_KEY;
                                        else
                                                next_state <= NOP_FOR_KEY;
                                        end if;
                            -- Key data enable and read data
                                when READ_DATA_KEY =>
                                        RDsig                                    <= '1';
                                        WRsig                                    <= '0';
                                        textDataEn                       <= '0';
                                        textDataShift            <= '0';
                                        keyDataEn                        <= '1';
                                        keyDataShift             <= '0';
                                        ciphDataEn                       <= '0';
                                        ciphDataShift            <= '0';
                                        startSig                                 <= '0';
                                        -- counter of retrieved bytes
                                        serialDataCtrCt  <= '1';
                                        shiftDataCtrCt           <= '0';
                                        serialDataCtrReset <= '0';
                                        next_state <= DECODE_READ_KEY;
                                -- Data readed, stop counter and check if proper number of byte
                                -- was readed
                                when DECODE_READ_KEY =>
                                        RDsig                                    <= '0';
                                        WRsig                                    <= '0';
                                        textDataEn                       <= '0';
                                        textDataShift            <= '0';
                                        keyDataEn                        <= '0';
                                        keyDataShift             <= '0';
                                        ciphDataEn                       <= '0';
                                        ciphDataShift            <= '0';
                                        startSig                                 <= '0';
                                        serialDataCtrCt  <= '0';
                                        shiftDataCtrCt           <= '0';
                                        serialDataCtrReset <= '0';
                                        -- 10 bytes should be readed
                                        if (serialDataCtrOut(3 downto 0) = "1010") then
                                            -- 10 bytes was readed
                                                next_state <= TEMP2_STATE;
                                        else
                                            -- 10 bytes was not readed
                                                next_state <= MOVE_KEY;
                                        end if;
                                -- Reset counter for next reading
                                when TEMP2_STATE =>
                                        RDsig                                    <= '0';
                                        WRsig                                    <= '0';
                                        textDataEn                       <= '0';
                                        textDataShift            <= '0';
                                        keyDataEn                        <= '0';
                                        keyDataShift             <= '0';
                                        ciphDataEn                       <= '0';
                                        ciphDataShift            <= '0';
                                        startSig                                 <= '0';
                                        serialDataCtrCt  <= '0';
                                        shiftDataCtrCt           <= '0';
                                        serialDataCtrReset <= '1';
                                        next_state <= PRESENT_ENCODE;
                                -- Here data are shfted in shift register - another shift counter are used
                                when MOVE_KEY =>
                                        RDsig                                    <= '0';
                                        WRsig                                    <= '0';
                                        textDataEn                       <= '0';
                                        textDataShift            <= '0';
                                        keyDataEn                        <= '0';
                                        keyDataShift             <= '1';
                                        ciphDataEn                       <= '0';
                                        ciphDataShift            <= '0';
                                        startSig                                 <= '0';
                                        serialDataCtrCt  <= '0';
                                        shiftDataCtrCt           <= '1';
                                        serialDataCtrReset <= '0';
                                        if (shiftDataCtrOut(2 downto 0) = "111") then
                                                next_state <= NOP_FOR_KEY;
                                        else
                                                next_state <= MOVE_KEY;
                                        end if;
                                -- All suitable data was readed Present encode start
                                when PRESENT_ENCODE =>
                                        RDsig                                    <= '0';
                                        WRsig                                    <= '0';
                                        textDataEn                       <= '0';
                                        textDataShift            <= '0';
                                        keyDataEn                        <= '0';
                                        keyDataShift             <= '0';
                                        ciphDataShift            <= '0';
                                        startSig                                 <= '1';
                                        serialDataCtrCt  <= '0';
                                        shiftDataCtrCt           <= '0';
                                        serialDataCtrReset <= '0';
                                        -- change state if Present result ready
                                        if (readySig = '1') then
                                                ciphDataEn                       <= '1';
                                                next_state <= WRITE_OUT;
                                        else
                                                ciphDataEn                       <= '0';
                                                next_state <= PRESENT_ENCODE;
                                        end if;
                                -- similar control of writing result as during reading
                                when WRITE_OUT =>
                                        RDsig                                    <= '0';
                                        textDataEn                       <= '0';
                                        textDataShift            <= '0';
                                        keyDataEn                        <= '0';
                                        keyDataShift             <= '0';
                                        ciphDataEn                       <= '0';
                                        ciphDataShift            <= '0';
                                        startSig                                 <= '1';
                                        serialDataCtrCt  <= '1';
                                        shiftDataCtrCt           <= '0';
                                        serialDataCtrReset <= '0';
                                        if (serialDataCtrOut = "1000") then
                                                WRsig                                    <= '0';
                                                next_state <= TEMP_OUT;
                                        else
                                                WRsig                                    <= '1';
                                                next_state <= MOVE_OUT;
                                        end if;
                                -- all data was sended - start new Present encode cycle
                                when TEMP_OUT =>
                                        RDsig                                    <= '0';
                                        WRsig                                    <= '0';
                                        textDataEn                       <= '0';
                                        textDataShift            <= '0';
                                        keyDataEn                        <= '0';
                                        keyDataShift             <= '0';
                                        ciphDataEn                       <= '0';
                                        ciphDataShift            <= '0';
                                        startSig                                 <= '1';
                                        serialDataCtrCt  <= '0';
                                        shiftDataCtrCt           <= '0';
                                        serialDataCtrReset <= '1';
                                        next_state <= NOP;
                                when MOVE_OUT =>
                                        if (TBEsig = '0') then
                                                RDsig                                    <= '0';
                                                WRsig                                    <= '0';
                                                textDataEn                       <= '0';
                                                textDataShift            <= '0';
                                                keyDataEn                        <= '0';
                                                keyDataShift             <= '0';
                                                ciphDataEn                       <= '0';
                                                ciphDataShift            <= '0';
                                                startSig                                 <= '1';
                                                serialDataCtrCt  <= '0';
                                                shiftDataCtrCt           <= '0';
                                                serialDataCtrReset <= '0';
                                                next_state <= MOVE_OUT;
                                        else
                                                RDsig                                    <= '0';
                                                WRsig                                    <= '0';
                                                textDataEn                       <= '0';
                                                textDataShift            <= '0';
                                                keyDataEn                        <= '0';
                                                keyDataShift             <= '0';
                                                ciphDataEn                       <= '0';
                                                ciphDataShift            <= '1';
                                                startSig                                 <= '1';
                                                serialDataCtrCt  <= '0';
                                                shiftDataCtrCt           <= '1';
                                                serialDataCtrReset <= '0';
                                                if (shiftDataCtrOut = "111") then
                                                        next_state <= WRITE_OUT;
                                                else
                                                        next_state <= MOVE_OUT;
                                                end if;
                                        end if;
                        end case;
                end process SM;
 
        state_modifier : process (clk, reset)
                begin
                        if (clk = '1' and clk'Event) then
                                if (reset = '1') then
                                        state <= NOP;
                                else
                                        state <= next_state;
                                end if;
                        end if;
                end process state_modifier;
 
    -- counter for controling number of bytes of readed data
        dataCounter : counter
                generic map(
                        w_5 => 4
                )
                port map (
                        cnt_res  => serialDataCtrCt,
                        num => serialDataCtrOut,
                        clk    => clk,
                        reset  => ctrReset
                );
 
        -- counter for controling number of shifted bits of readed data
        shiftCounter : counter
                generic map(
                        w_5 => 3
                )
                port map (
                        cnt_res  => shiftDataCtrCt,
                        num => shiftDataCtrOut,
                        clk    => clk,
                        reset  => reset
                );
 
end Behavioral;
 

Line No.	Rev	Author	Line
1	4	gajos	`-----------------------------------------------------------------------`
2			`---- ----`
3			`---- Present - a lightweight block cipher project ----`
4			`---- ----`
5			`---- This file is part of the Present - a lightweight block ----`
6			`---- cipher project ----`
7			`---- http://www.http://opencores.org/project,present ----`
8			`---- ----`
9			`---- Description: ----`
10			`---- State machine of 'pure' Present cipher with RS-232 ----`
11			`---- communication with PC. For more informations see below. ----`
12			`---- To Do: ----`
13			`---- ----`
14			`---- Author(s): ----`
15			`---- - Krzysztof Gajewski, gajos@opencores.org ----`
16			`---- k.gajewski@gmail.com ----`
17			`---- ----`
18			`-----------------------------------------------------------------------`
19			`---- ----`
20			`---- Copyright (C) 2013 Authors and OPENCORES.ORG ----`
21			`---- ----`
22			`---- This source file may be used and distributed without ----`
23			`---- restriction provided that this copyright statement is not ----`
24			`---- removed from the file and that any derivative work contains ----`
25			`---- the original copyright notice and the associated disclaimer. ----`
26			`---- ----`
27			`---- This source file is free software; you can redistribute it ----`
28			`---- and-or modify it under the terms of the GNU Lesser General ----`
29			`---- Public License as published by the Free Software Foundation; ----`
30			`---- either version 2.1 of the License, or (at your option) any ----`
31			`---- later version. ----`
32			`---- ----`
33			`---- This source is distributed in the hope that it will be ----`
34			`---- useful, but WITHOUT ANY WARRANTY; without even the implied ----`
35			`---- warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR ----`
36			`---- PURPOSE. See the GNU Lesser General Public License for more ----`
37			`---- details. ----`
38			`---- ----`
39			`---- You should have received a copy of the GNU Lesser General ----`
40			`---- Public License along with this source; if not, download it ----`
41			`---- from http://www.opencores.org/lgpl.shtml ----`
42			`---- ----`
43			`-----------------------------------------------------------------------`
44	3	gajos	`library IEEE;`
45			`use IEEE.STD_LOGIC_1164.ALL;`
46			`use work.kody.ALL;`
47
48			`-- Uncomment the following library declaration if using`
49			`-- arithmetic functions with Signed or Unsigned values`
50			`--use IEEE.NUMERIC_STD.ALL;`
51
52			`-- Uncomment the following library declaration if instantiating`
53			`-- any Xilinx primitives in this code.`
54			`--library UNISIM;`
55			`--use UNISIM.VComponents.all;`
56
57			`entity PresentCommSM is`
58			`port (`
59			`clk : in STD_LOGIC;`
60			`reset : in STD_LOGIC;`
61			`RDAsig : in STD_LOGIC;`
62			`TBEsig : in STD_LOGIC;`
63			`RDsig : out STD_LOGIC;`
64			`WRsig : out STD_LOGIC;`
65			`textDataEn : out STD_LOGIC;`
66			`textDataShift : out STD_LOGIC;`
67			`keyDataEn : out STD_LOGIC;`
68			`keyDataShift : out STD_LOGIC;`
69			`ciphDataEn : out STD_LOGIC;`
70			`ciphDataShift : out STD_LOGIC;`
71			`startSig : out STD_LOGIC;`
72			`readySig : in STD_LOGIC`
73			`);`
74			`end PresentCommSM;`
75
76			`architecture Behavioral of PresentCommSM is`
77
78	4	gajos	`-- counter used for determine number of readed/sended data (key, text, result)`
79	3	gajos	`component counter is`
80			`generic (`
81			`w_5 : integer := 5`
82			`);`
83			`port (`
84			`clk, reset, cnt_res : in std_logic;`
85			`num : out std_logic_vector (w_5-1 downto 0)`
86			`);`
87			`end component counter;`
88
89	4	gajos	`-- signals`
90
91	3	gajos	`signal state : stany_comm := NOP;`
92			`signal next_state : stany_comm := NOP;`
93
94			`-- modify for variable key size`
95			`signal serialDataCtrCt : STD_LOGIC;`
96			`signal serialDataCtrOut : STD_LOGIC_VECTOR(3 downto 0);`
97			`signal serialDataCtrReset : STD_LOGIC;`
98			`signal ctrReset : STD_LOGIC;`
99			`-- DO NOT MODIFY!!!`
100			`signal shiftDataCtrCt : STD_LOGIC;`
101			`signal shiftDataCtrOut : STD_LOGIC_VECTOR(2 downto 0);`
102
103			`begin`
104	4	gajos	`-- In this state machine is determined, that firs data should be 64 bit text`
105			`-- after text, key should appear. After receiving last byte of key, ciphertext`
106			`-- is counted. And later it is sended back to PC.`
107	3	gajos	`ctrReset <= serialDataCtrReset or reset;`
108			`SM : process(state, RDAsig, TBEsig, shiftDataCtrOut, serialDataCtrOut, readySig)`
109			`begin`
110	4	gajos	`case state is`
111			`-- No operation - waiting for incoming data`
112	3	gajos	`when NOP =>`
113			`RDsig <= '0';`
114			`WRsig <= '0';`
115			`textDataEn <= '0';`
116			`textDataShift <= '0';`
117			`keyDataEn <= '0';`
118			`keyDataShift <= '0';`
119			`ciphDataEn <= '0';`
120			`ciphDataShift <= '0';`
121			`startSig <= '0';`
122			`serialDataCtrCt <= '0';`
123			`shiftDataCtrCt <= '0';`
124			`serialDataCtrReset <= '0';`
125	4	gajos	`-- data has come`
126	3	gajos	`if (RDAsig = '1') then`
127			`next_state <= READ_DATA_TEXT;`
128			`else`
129			`next_state <= NOP;`
130			`end if;`
131	4	gajos	`-- Text data enable and read data`
132	3	gajos	`when READ_DATA_TEXT =>`
133			`RDsig <= '1';`
134			`WRsig <= '0';`
135			`textDataEn <= '1';`
136			`textDataShift <= '0';`
137			`keyDataEn <= '0';`
138			`keyDataShift <= '0';`
139			`ciphDataEn <= '0';`
140			`ciphDataShift <= '0';`
141			`startSig <= '0';`
142	4	gajos	`-- counter of retrieved bytes`
143	3	gajos	`serialDataCtrCt <= '1';`
144			`shiftDataCtrCt <= '0';`
145			`serialDataCtrReset <= '0';`
146			`next_state <= DECODE_READ_TEXT;`
147	4	gajos	`-- Data readed, stop counter and check if proper number of byte`
148			`-- was readed`
149	3	gajos	`when DECODE_READ_TEXT =>`
150			`RDsig <= '0';`
151			`WRsig <= '0';`
152			`textDataEn <= '0';`
153			`textDataShift <= '0';`
154			`keyDataEn <= '0';`
155			`keyDataShift <= '0';`
156			`ciphDataEn <= '0';`
157			`ciphDataShift <= '0';`
158			`startSig <= '0';`
159			`serialDataCtrCt <= '0';`
160			`shiftDataCtrCt <= '0';`
161	4	gajos	`-- 8 bytes should be readed`
162			`if (serialDataCtrOut(3 downto 0) = "1000") then`
163			`-- 8 bytes was readed`
164	3	gajos	`next_state <= TEMP_STATE;`
165	4	gajos	`else`
166			`-- 8 bytes was not readed`
167	3	gajos	`next_state <= MOVE_TEXT;`
168			`end if;`
169	4	gajos	`-- Reset counter for next reading`
170	3	gajos	`when TEMP_STATE =>`
171			`RDsig <= '0';`
172			`WRsig <= '0';`
173			`textDataEn <= '0';`
174			`textDataShift <= '0';`
175			`keyDataEn <= '0';`
176			`keyDataShift <= '0';`
177			`ciphDataEn <= '0';`
178			`ciphDataShift <= '0';`
179			`startSig <= '0';`
180			`serialDataCtrCt <= '0';`
181			`shiftDataCtrCt <= '0';`
182			`serialDataCtrReset <= '1';`
183			`next_state <= NOP_FOR_KEY;`
184	4	gajos	`-- Here data are shfted in shift register - another shift counter are used`
185	3	gajos	`when MOVE_TEXT =>`
186			`RDsig <= '0';`
187			`WRsig <= '0';`
188			`textDataEn <= '0';`
189			`textDataShift <= '1';`
190			`keyDataEn <= '0';`
191			`keyDataShift <= '0';`
192			`ciphDataEn <= '0';`
193			`ciphDataShift <= '0';`
194			`startSig <= '0';`
195			`serialDataCtrCt <= '0';`
196			`shiftDataCtrCt <= '1';`
197			`serialDataCtrReset <= '0';`
198			`if (shiftDataCtrOut(2 downto 0) = "111") then`
199			`next_state <= NOP;`
200			`else`
201			`next_state <= MOVE_TEXT;`
202			`end if;`
203	4	gajos	`-- "No operation 2" waiting for data - it could be optimized in way,`
204			`-- that waiting for key and text could be the same state, but it was`
205			`-- intentionally separated.`
206	3	gajos	`when NOP_FOR_KEY =>`
207			`RDsig <= '0';`
208			`WRsig <= '0';`
209			`textDataEn <= '0';`
210			`textDataShift <= '0';`
211			`keyDataEn <= '0';`
212			`keyDataShift <= '0';`
213			`ciphDataEn <= '0';`
214			`ciphDataShift <= '0';`
215			`startSig <= '0';`
216			`serialDataCtrCt <= '0';`
217			`shiftDataCtrCt <= '0';`
218			`serialDataCtrReset <= '0';`
219	4	gajos	`if (RDAsig = '1') then`
220			`-- data has come`
221	3	gajos	`next_state <= READ_DATA_KEY;`
222			`else`
223			`next_state <= NOP_FOR_KEY;`
224			`end if;`
225	4	gajos	`-- Key data enable and read data`
226	3	gajos	`when READ_DATA_KEY =>`
227			`RDsig <= '1';`
228			`WRsig <= '0';`
229			`textDataEn <= '0';`
230			`textDataShift <= '0';`
231			`keyDataEn <= '1';`
232			`keyDataShift <= '0';`
233			`ciphDataEn <= '0';`
234			`ciphDataShift <= '0';`
235			`startSig <= '0';`
236	4	gajos	`-- counter of retrieved bytes`
237	3	gajos	`serialDataCtrCt <= '1';`
238			`shiftDataCtrCt <= '0';`
239			`serialDataCtrReset <= '0';`
240			`next_state <= DECODE_READ_KEY;`
241	4	gajos	`-- Data readed, stop counter and check if proper number of byte`
242			`-- was readed`
243	3	gajos	`when DECODE_READ_KEY =>`
244			`RDsig <= '0';`
245			`WRsig <= '0';`
246			`textDataEn <= '0';`
247			`textDataShift <= '0';`
248			`keyDataEn <= '0';`
249			`keyDataShift <= '0';`
250			`ciphDataEn <= '0';`
251			`ciphDataShift <= '0';`
252			`startSig <= '0';`
253			`serialDataCtrCt <= '0';`
254			`shiftDataCtrCt <= '0';`
255			`serialDataCtrReset <= '0';`
256	4	gajos	`-- 10 bytes should be readed`
257			`if (serialDataCtrOut(3 downto 0) = "1010") then`
258			`-- 10 bytes was readed`
259	3	gajos	`next_state <= TEMP2_STATE;`
260	4	gajos	`else`
261			`-- 10 bytes was not readed`
262	3	gajos	`next_state <= MOVE_KEY;`
263			`end if;`
264	4	gajos	`-- Reset counter for next reading`
265	3	gajos	`when TEMP2_STATE =>`
266			`RDsig <= '0';`
267			`WRsig <= '0';`
268			`textDataEn <= '0';`
269			`textDataShift <= '0';`
270			`keyDataEn <= '0';`
271			`keyDataShift <= '0';`
272			`ciphDataEn <= '0';`
273			`ciphDataShift <= '0';`
274			`startSig <= '0';`
275			`serialDataCtrCt <= '0';`
276			`shiftDataCtrCt <= '0';`
277			`serialDataCtrReset <= '1';`
278			`next_state <= PRESENT_ENCODE;`
279	4	gajos	`-- Here data are shfted in shift register - another shift counter are used`
280	3	gajos	`when MOVE_KEY =>`
281			`RDsig <= '0';`
282			`WRsig <= '0';`
283			`textDataEn <= '0';`
284			`textDataShift <= '0';`
285			`keyDataEn <= '0';`
286			`keyDataShift <= '1';`
287			`ciphDataEn <= '0';`
288			`ciphDataShift <= '0';`
289			`startSig <= '0';`
290			`serialDataCtrCt <= '0';`
291			`shiftDataCtrCt <= '1';`
292			`serialDataCtrReset <= '0';`
293			`if (shiftDataCtrOut(2 downto 0) = "111") then`
294			`next_state <= NOP_FOR_KEY;`
295			`else`
296			`next_state <= MOVE_KEY;`
297			`end if;`
298	4	gajos	`-- All suitable data was readed Present encode start`
299	3	gajos	`when PRESENT_ENCODE =>`
300			`RDsig <= '0';`
301			`WRsig <= '0';`
302			`textDataEn <= '0';`
303			`textDataShift <= '0';`
304			`keyDataEn <= '0';`
305			`keyDataShift <= '0';`
306			`ciphDataShift <= '0';`
307			`startSig <= '1';`
308			`serialDataCtrCt <= '0';`
309			`shiftDataCtrCt <= '0';`
310			`serialDataCtrReset <= '0';`
311	4	gajos	`-- change state if Present result ready`
312	3	gajos	`if (readySig = '1') then`
313			`ciphDataEn <= '1';`
314			`next_state <= WRITE_OUT;`
315			`else`
316			`ciphDataEn <= '0';`
317			`next_state <= PRESENT_ENCODE;`
318			`end if;`
319	4	gajos	`-- similar control of writing result as during reading`
320	3	gajos	`when WRITE_OUT =>`
321			`RDsig <= '0';`
322			`textDataEn <= '0';`
323			`textDataShift <= '0';`
324			`keyDataEn <= '0';`
325			`keyDataShift <= '0';`
326			`ciphDataEn <= '0';`
327			`ciphDataShift <= '0';`
328			`startSig <= '1';`
329			`serialDataCtrCt <= '1';`
330			`shiftDataCtrCt <= '0';`
331			`serialDataCtrReset <= '0';`
332			`if (serialDataCtrOut = "1000") then`
333			`WRsig <= '0';`
334			`next_state <= TEMP_OUT;`
335			`else`
336			`WRsig <= '1';`
337			`next_state <= MOVE_OUT;`
338			`end if;`
339	4	gajos	`-- all data was sended - start new Present encode cycle`
340	3	gajos	`when TEMP_OUT =>`
341			`RDsig <= '0';`
342			`WRsig <= '0';`
343			`textDataEn <= '0';`
344			`textDataShift <= '0';`
345			`keyDataEn <= '0';`
346			`keyDataShift <= '0';`
347			`ciphDataEn <= '0';`
348			`ciphDataShift <= '0';`
349			`startSig <= '1';`
350			`serialDataCtrCt <= '0';`
351			`shiftDataCtrCt <= '0';`
352			`serialDataCtrReset <= '1';`
353			`next_state <= NOP;`
354			`when MOVE_OUT =>`
355			`if (TBEsig = '0') then`
356			`RDsig <= '0';`
357			`WRsig <= '0';`
358			`textDataEn <= '0';`
359			`textDataShift <= '0';`
360			`keyDataEn <= '0';`
361			`keyDataShift <= '0';`
362			`ciphDataEn <= '0';`
363			`ciphDataShift <= '0';`
364			`startSig <= '1';`
365			`serialDataCtrCt <= '0';`
366			`shiftDataCtrCt <= '0';`
367			`serialDataCtrReset <= '0';`
368			`next_state <= MOVE_OUT;`
369			`else`
370			`RDsig <= '0';`
371			`WRsig <= '0';`
372			`textDataEn <= '0';`
373			`textDataShift <= '0';`
374			`keyDataEn <= '0';`
375			`keyDataShift <= '0';`
376			`ciphDataEn <= '0';`
377			`ciphDataShift <= '1';`
378			`startSig <= '1';`
379			`serialDataCtrCt <= '0';`
380			`shiftDataCtrCt <= '1';`
381			`serialDataCtrReset <= '0';`
382			`if (shiftDataCtrOut = "111") then`
383			`next_state <= WRITE_OUT;`
384			`else`
385			`next_state <= MOVE_OUT;`
386			`end if;`
387			`end if;`
388			`end case;`
389			`end process SM;`
390
391			`state_modifier : process (clk, reset)`
392			`begin`
393			`if (clk = '1' and clk'Event) then`
394			`if (reset = '1') then`
395			`state <= NOP;`
396			`else`
397			`state <= next_state;`
398			`end if;`
399			`end if;`
400			`end process state_modifier;`
401	4	gajos
402			`-- counter for controling number of bytes of readed data`
403	3	gajos	`dataCounter : counter`
404			`generic map(`
405			`w_5 => 4`
406			`)`
407			`port map (`
408			`cnt_res => serialDataCtrCt,`
409			`num => serialDataCtrOut,`
410			`clk => clk,`
411			`reset => ctrReset`
412			`);`
413	4	gajos
414			`-- counter for controling number of shifted bits of readed data`
415	3	gajos	`shiftCounter : counter`
416			`generic map(`
417			`w_5 => 3`
418			`)`
419			`port map (`
420			`cnt_res => shiftDataCtrCt,`
421			`num => shiftDataCtrOut,`
422			`clk => clk,`
423			`reset => reset`
424			`);`
425
426			`end Behavioral;`
427

Browse

Tools

Subversion Repositories present

[/] [present/] [trunk/] [PureTesting/] [rtl/] [vhdl/] [PresentCommSM.vhd] - Blame information for rev 4