URL https://opencores.org/ocsvn/gcm-aes/gcm-aes/trunk

Subversion Repositories gcm-aes

[/] [gcm-aes/] [trunk/] [rtl/] [gcm_aes_v0.v] - Blame information for rev 2

Details | Compare with Previous | View Log


/////////////////////////////////////////////////////////////////////
////                                                             ////
////                            GCM-AES Top Module                           ////
////                                                             ////
////                                                             ////
////  Author: Tariq Bashir Ahmad and Guy Hutchison               ////
////          tariq.bashir@gmail.com                             ////
////          ghutchis@gmail.com                                 ////
////                                                             ////
////  Downloaded from: http://www.opencores.org/                                  ////
////                                                             ////
/////////////////////////////////////////////////////////////////////
////                                                             ////
//// Copyright (C) 2010          Tariq Bashir Ahmad and                          ////   
////                         Guy Hutchison                                               ////
////                         http://www.ecs.umass.edu/~tbashir   ////
////                                                                     ////
////                                                             ////
//// 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 SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY     ////
//// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED   ////
//// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS   ////
//// FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL THE AUTHOR      ////
//// 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.                                 ////
////                                                             ////
/////////////////////////////////////////////////////////////////////
 
 
`timescale 1ns / 1ps
 
`define SIZE 128
 
module gcm_aes_v0(
                  input clk,
                  input rst,
 
                  /* DATA Input Interface (dii) */
                  input [`SIZE-1:0] dii_data,
                  input dii_data_vld,
                  input dii_data_type,
                  output reg dii_data_not_ready,
                  input dii_last_word,
                  input [3:0] dii_data_size,
 
                  /* Control Input Interface */
                  input cii_ctl_vld,                    //acts as start signal
                  input cii_IV_vld,
                  input [`SIZE-1:0] cii_K,
 
 
                  /* Data Output Interface */
                  output reg [`SIZE-1:0] Out_data,
                  output reg Out_vld,
                  output reg [3:0] Out_data_size,
                  output reg Out_last_word,
 
                  /* Tag output Interface */
                  output reg  Tag_vld
 
                  );
 
 
 
 
 
  //actual registers
  reg [`SIZE-1:0]             H, nxt_H, EkY0, nxt_EkY0, Yi, Yi_init;
  reg [`SIZE-1:0]             gfm_result;
  reg [63:0]                  enc_byte_cnt, aad_byte_cnt;
 
  reg                         nxt_Out_vld, nxt_Tag_vld;
 
  reg [`SIZE-1:0]             dii_data_star, nxt_Out_data_star;
 
  //wires
  reg [`SIZE-1:0]             nxt_Out_data, nxt_Tag_data;
 
  //aes signals
  reg [`SIZE-1:0]             aes_text_in;
  reg                         aes_kld;
  wire                        aes_done;
  wire [`SIZE-1:0]            aes_text_out;
 
  //control signals
  reg                         mux_aes_text_in_sel, mux_yi_sel;
 
  //gfm signals
  reg  [`SIZE-1:0]             v_in, z_in,b_in, gfm_input1;
  wire [`SIZE-1:0]             z_out, v_out;
  reg [3:0]                    gfm_cnt;
 
  //write enables
  reg                          we_y, we_lenA, we_lenC, start_gfm_cnt;
 
 
  //FSM signals
  reg [9:0]                   state, nxt_state;
 
  parameter          IDLE          = 10'd1,
                     ENCRYPT_0     = 10'd2,
                     INIT_COUNTER  = 10'd4,
                     ENCRYPT_Y0    = 10'd8,
                     DATA_ACCEPT   = 10'd16,
                     GFM_MULT      = 10'd32,
                     INC_COUNTER   = 10'd64,
                     M_ENCRYPT     = 10'd128,
                     PRE_TAG_CALC  = 10'd256,
                     TAG_CALC      = 10'd512;
 
 
 
 
 
 
 
  always @*
    begin
      dii_data_star = 0;
      case(dii_data_size)
        0:  // 1 valid byte
          begin
            dii_data_star = ({dii_data[7:0],120'b0});
          end
        1: //2 valid bytes
          begin
            dii_data_star = {dii_data[15:0],112'b0};
          end
        2: //3 valid bytes
          begin
            dii_data_star = {dii_data[23:0],104'b0};
          end
        3: //4 valid bytes
          begin
            dii_data_star = {dii_data[31:0],96'b0};
          end
        4: //5 valid bytes
          begin
            dii_data_star = {dii_data[39:0],88'b0};
          end
        5: //6 valid bytes
          begin
            dii_data_star = {dii_data[47:0],80'b0};
          end
        6: //7 valid bytes
          begin
            dii_data_star = {dii_data[55:0],72'b0};
          end
        7: //8 valid bytes
          begin
            dii_data_star = {dii_data[63:0],64'b0};
          end
        8:
          begin
            dii_data_star = {dii_data[71:0],56'b0};
          end
        9:
          begin
            dii_data_star = {dii_data[79:0],48'b0};
          end
        10:
          begin
            dii_data_star = {dii_data[87:0],40'b0};
          end
        11:
          begin
            dii_data_star = {dii_data[95:0],32'b0};
          end
        12:
          begin
            dii_data_star = {dii_data[103:0],24'b0};
          end
        13:     //14 valid bytes
          begin
            dii_data_star = ({dii_data[111:0],16'b0});
          end
        14: //15 valid bytes
          begin
            dii_data_star = {dii_data[119:0],8'b0};
          end
      endcase
 
    end
 
  always @*
    begin
      nxt_Out_data_star = 0;
      case(dii_data_size)
        0:  //1 valid byte
          begin
            nxt_Out_data_star = {nxt_Out_data[127:120],120'b0};
          end
        1:// 2 valid bytes
          begin
            nxt_Out_data_star = {nxt_Out_data[127:112],112'b0};
          end
        2:// 3 valid bytes
          begin
            nxt_Out_data_star = {nxt_Out_data[127:104],104'b0};
          end
        3:// 4 valid bytes
          begin
            nxt_Out_data_star = {nxt_Out_data[127:96],96'b0};
          end
        4:// 5 valid bytes
          begin
            nxt_Out_data_star = {nxt_Out_data[127:88],88'b0};
          end
        5:// 6 valid bytes
          begin
            nxt_Out_data_star = {nxt_Out_data[127:80],80'b0};
          end
        6:// 7 valid bytes
          begin
            nxt_Out_data_star = {nxt_Out_data[127:72],72'b0};
          end
        7:// 8 valid bytes
          begin
            nxt_Out_data_star = {nxt_Out_data[127:64],64'b0};
          end
        8:// 9 valid bytes
          begin
            nxt_Out_data_star = {nxt_Out_data[127:56],56'b0};
          end
        9:// 10 valid bytes
          begin
            nxt_Out_data_star = {nxt_Out_data[127:48],48'b0};
          end
        10:// 11 valid bytes
          begin
            nxt_Out_data_star = {nxt_Out_data[127:40],40'b0};
          end
        11:  // 12 valid byte
          begin
            nxt_Out_data_star = {nxt_Out_data[127:32],32'b0};
          end
        12:// 13 valid bytes
          begin
            nxt_Out_data_star = {nxt_Out_data[127:24],24'b0};
          end
        13:// 14 valid bytes
          begin
            nxt_Out_data_star = {nxt_Out_data[127:16],16'b0};
          end
        14:  // 15 valid byte
          begin
            nxt_Out_data_star = {nxt_Out_data[127:8],8'b0};
          end
 
      endcase // case (dii_data_size)
    end
 
 
  always @(posedge clk or posedge rst)
    if(rst)
      begin
        state  <= #1 IDLE;
        H       <= #1 0;
        EkY0    <= #1 0;
      end
    else
      begin
        H     <= #1 nxt_H;
        EkY0  <= #1 nxt_EkY0;
        state <= #1 nxt_state;
      end
 
 
  //out data
   always @(posedge clk)
    begin
      if(nxt_Out_vld & ~nxt_Tag_vld)
        begin
          Out_data              <= #1 nxt_Out_data;
          Out_data_size <= #1 dii_data_size;
          Out_last_word <= #1 dii_last_word;
        end
      else if(nxt_Tag_vld)
        Out_data <= #1 nxt_Tag_data;
 
      Tag_vld <= #1 nxt_Tag_vld;
      Out_vld <= #1 nxt_Out_vld;
   end
 
 /* always @(posedge clk)
    begin
      if(nxt_Out_vld)
        begin
          Out_data <= #1 nxt_Out_data;
          Out_data_size <= #1 dii_data_size;
          Out_last_word    <= #1 dii_last_word;
        end
      Out_vld <= #1 nxt_Out_vld;
 
    end
 
 
  always @(posedge clk)
    begin
      if(nxt_Tag_vld)
        Out_data <= #1 nxt_Tag_data;
 
      Tag_vld <= #1 nxt_Tag_vld;
    end
  */
 
 //aes text_in
  always @*
    begin
      aes_text_in = 0;
      case(mux_aes_text_in_sel)
        0: aes_text_in = 0;
 
        1: aes_text_in = Yi;
 
      endcase
    end
 
 
  //initializing Yi_init
  always @*
    begin
      Yi_init = 0;
      if(cii_IV_vld)
        begin
          Yi_init = dii_data;
        end
    end
 
 
  //FSM
  always @*
    begin
      //list of defaults
      nxt_state = state;
      we_y = 0;
      we_lenA = 0;
      we_lenC = 0;
      dii_data_not_ready = 1;
      aes_kld = 0;
      mux_aes_text_in_sel = 0;
      mux_yi_sel = 0;
      start_gfm_cnt = 0;
      nxt_H = H;
      nxt_EkY0 = EkY0;
      nxt_Out_vld           = 0;
      nxt_Tag_vld           = 0;
      gfm_input1 = 0;
      nxt_Out_data = 0;
      nxt_Tag_data = 0;
 
      case(state)
        IDLE:
          begin
        //  $display($time,": In IDLE\n");
            if(cii_ctl_vld)
              begin
                aes_kld = 1;
                mux_aes_text_in_sel = 0;
                nxt_state = ENCRYPT_0;
              end
          end
 
        ENCRYPT_0:
          begin
            if(aes_done)
              begin
                nxt_H = aes_text_out;
                if(cii_IV_vld)
                  begin
                    we_y = 1;
                    nxt_state = INIT_COUNTER;
                  end
              end
          end // case: ENCRYPT_0
 
        INIT_COUNTER:
          begin
                           // figure out how to launch a GCM op here,
                                // or go to next state which launches GCM op
            mux_aes_text_in_sel = 1;
            aes_kld = 1;
            nxt_state = ENCRYPT_Y0;
          end
 
 
        ENCRYPT_Y0:
          begin
            if(aes_done)
              begin
                nxt_EkY0 = aes_text_out;
                nxt_state = DATA_ACCEPT;
              end
          end
 
        DATA_ACCEPT:
          begin
            dii_data_not_ready = 0;
            if(dii_data_vld & dii_data_type)   //AAD
              begin
                if(dii_data_size == 4'd15)
                  begin
                    we_lenA      = 1;
                    gfm_input1    = dii_data;
                    start_gfm_cnt = 1;
                    nxt_state     = GFM_MULT;
                  end
                else
                  begin
                    we_lenA      = 1;
                    gfm_input1    = dii_data_star; //note star
                    start_gfm_cnt = 1;
                    nxt_state     = GFM_MULT;
                  end
              end
            else if(dii_data_vld & ~dii_data_type) //ENC
              begin
                mux_yi_sel = 1;
                we_y = 1;
                nxt_state = INC_COUNTER;
              end
          end // case: AAD_ACCEPT
 
        INC_COUNTER:
          begin
            we_lenC = 1;
            mux_aes_text_in_sel = 1;
            aes_kld = 1;
            nxt_state = M_ENCRYPT;
          end
 
        GFM_MULT:
          begin
            if(gfm_cnt == 4'd7)
              begin
                start_gfm_cnt = 0;
                if(~dii_last_word)
                  nxt_state = DATA_ACCEPT;
                else
                  nxt_state = PRE_TAG_CALC;
              end
          end
 
        M_ENCRYPT:
          begin
            if(aes_done)
              begin
                if(dii_data_size == 4'd15)
                  begin
                    nxt_Out_data = aes_text_out ^ dii_data;
                    nxt_Out_vld  = 1;
                    gfm_input1 = nxt_Out_data;
                  end
                else
                  begin
                    nxt_Out_data = aes_text_out ^ dii_data_star;
                    nxt_Out_vld  = 1;
                    gfm_input1 = nxt_Out_data_star;
                  end
                start_gfm_cnt = 1;
                nxt_state = GFM_MULT;
              end
          end // case: M_ACCEPT
 
        PRE_TAG_CALC:
          begin
            gfm_input1 = {(aad_byte_cnt << 3),(enc_byte_cnt << 3)};
            start_gfm_cnt = 1;
            nxt_state = TAG_CALC;
          end
 
        TAG_CALC:
          begin
            if(gfm_cnt == 4'd7)
              begin
                start_gfm_cnt = 0;
                nxt_Tag_data = EkY0 ^ z_out;
                nxt_Tag_vld  = 1'b1;
                nxt_state = IDLE;
              end
          end
 
      endcase
 
    end
 
 
 
 
 
  always @(posedge clk)
    if(we_y)
      case(mux_yi_sel)
        0: Yi <= #1 Yi_init;
        1: Yi <= #1 Yi + 1;
      endcase
 
  always @(posedge clk or posedge rst)
    if(rst)
      enc_byte_cnt <= #1 0;
    else if(we_lenC)
      enc_byte_cnt <= #1 enc_byte_cnt + dii_data_size + 1;
 
  always @(posedge clk or posedge rst)
    if(rst)
      aad_byte_cnt <= #1 0;
    else if(we_lenA)
      aad_byte_cnt <= #1 aad_byte_cnt + dii_data_size + 1;
 
  always @(posedge clk)
    if(start_gfm_cnt)
      gfm_cnt <= #1 4'd0;
    else if(gfm_cnt != 4'd7)
      gfm_cnt <= #1 gfm_cnt + 1;
 
 
  always @(posedge clk)
    if(cii_ctl_vld)
      gfm_result <= #1 0;
    else if(gfm_cnt == 4'd7)
      gfm_result <= #1 z_out;
 
 
 
  always @(posedge clk)
    if(start_gfm_cnt)
      begin
        v_in     <= #1 H;
        z_in     <= #1 {`SIZE{1'b0}};
        b_in     <= #1 gfm_input1 ^ gfm_result;
      end
 
    else
      begin
        v_in <= #1 v_out;
        z_in <= #1 z_out;
        b_in <= #1 b_in << 16;
      end
 
 
 
 
   /*
    gfm128_16 AUTO_TEMPLATE
    (
    .v_out             (v_out[127:0]),
    .z_out             (z_out[127:0]),
    .v_in              (v_in[127:0]),
    .z_in              (z_in[127:0]),
    .b_in              (b_in[127:112]),
    );
    */
 
 
  gfm128_16      GFM(/*AUTOINST*/
                     // Outputs
                     .v_out             (v_out[127:0]),          // Templated
                     .z_out             (z_out[127:0]),          // Templated
                     // Inputs
                     .v_in              (v_in[127:0]),           // Templated
                     .z_in              (z_in[127:0]),           // Templated
                     .b_in              (b_in[127:112]));         // Templated
 
 
   /*
    aes_cipher_top AUTO_TEMPLATE
    (
    .done                (aes_done),
    .text_out            (aes_text_out[127:0]),
    .clk                 (clk),
    .rst                 (rst),
    .ld                  (aes_kld),
    .key                 (cii_K),
    .text_in             (aes_text_in[127:0]),
    );
    */
 
  aes_cipher_top  AES_ENC (/*AUTOINST*/
                           // Outputs
                           .done                (aes_done),      // Templated
                           .text_out            (aes_text_out[127:0]), // Templated
                           // Inputs
                           .clk                 (clk),           // Templated
                           .rst                 (rst),           // Templated
                           .ld                  (aes_kld),       // Templated
                           .key                 (cii_K),         // Templated
                           .text_in             (aes_text_in[127:0])); // Templated
 
 
 
 
endmodule

Browse

Tools

Subversion Repositories gcm-aes

[/] [gcm-aes/] [trunk/] [rtl/] [gcm_aes_v0.v] - Blame information for rev 2

Line No.	Rev	Author	Line
1	2	tariq786	`/////////////////////////////////////////////////////////////////////`
2			`//// ////`
3			`//// GCM-AES Top Module ////`
4			`//// ////`
5			`//// ////`
6			`//// Author: Tariq Bashir Ahmad and Guy Hutchison ////`
7			`//// tariq.bashir@gmail.com ////`
8			`//// ghutchis@gmail.com ////`
9			`//// ////`
10			`//// Downloaded from: http://www.opencores.org/ ////`
11			`//// ////`
12			`/////////////////////////////////////////////////////////////////////`
13			`//// ////`
14			`//// Copyright (C) 2010 Tariq Bashir Ahmad and ////`
15			`//// Guy Hutchison ////`
16			`//// http://www.ecs.umass.edu/~tbashir ////`
17			`//// ////`
18			`//// ////`
19			`//// This source file may be used and distributed without ////`
20			`//// restriction provided that this copyright statement is not ////`
21			`//// removed from the file and that any derivative work contains ////`
22			`//// the original copyright notice and the associated disclaimer.////`
23			`//// ////`
24			//// THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY ////
25			`//// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED ////`
26			`//// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS ////`
27			`//// FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL THE AUTHOR ////`
28			`//// OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, ////`
29			`//// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ////`
30			`//// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE ////`
31			`//// GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR ////`
32			`//// BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF ////`
33			`//// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ////`
34			`//// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT ////`
35			`//// OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ////`
36			`//// POSSIBILITY OF SUCH DAMAGE. ////`
37			`//// ////`
38			`/////////////////////////////////////////////////////////////////////`
39
40
41			`timescale 1ns / 1ps
42
43			`define SIZE 128
44
45			`module gcm_aes_v0(`
46			`input clk,`
47			`input rst,`
48
49			`/* DATA Input Interface (dii) */`
50			input [`SIZE-1:0] dii_data,
51			`input dii_data_vld,`
52			`input dii_data_type,`
53			`output reg dii_data_not_ready,`
54			`input dii_last_word,`
55			`input [3:0] dii_data_size,`
56
57			`/* Control Input Interface */`
58			`input cii_ctl_vld, //acts as start signal`
59			`input cii_IV_vld,`
60			input [`SIZE-1:0] cii_K,
61
62
63			`/* Data Output Interface */`
64			output reg [`SIZE-1:0] Out_data,
65			`output reg Out_vld,`
66			`output reg [3:0] Out_data_size,`
67			`output reg Out_last_word,`
68
69			`/* Tag output Interface */`
70			`output reg Tag_vld`
71
72			`);`
73
74
75
76
77
78			`//actual registers`
79			reg [`SIZE-1:0] H, nxt_H, EkY0, nxt_EkY0, Yi, Yi_init;
80			reg [`SIZE-1:0] gfm_result;
81			`reg [63:0] enc_byte_cnt, aad_byte_cnt;`
82
83			`reg nxt_Out_vld, nxt_Tag_vld;`
84
85			reg [`SIZE-1:0] dii_data_star, nxt_Out_data_star;
86
87			`//wires`
88			reg [`SIZE-1:0] nxt_Out_data, nxt_Tag_data;
89
90			`//aes signals`
91			reg [`SIZE-1:0] aes_text_in;
92			`reg aes_kld;`
93			`wire aes_done;`
94			wire [`SIZE-1:0] aes_text_out;
95
96			`//control signals`
97			`reg mux_aes_text_in_sel, mux_yi_sel;`
98
99			`//gfm signals`
100			reg [`SIZE-1:0] v_in, z_in,b_in, gfm_input1;
101			wire [`SIZE-1:0] z_out, v_out;
102			`reg [3:0] gfm_cnt;`
103
104			`//write enables`
105			`reg we_y, we_lenA, we_lenC, start_gfm_cnt;`
106
107
108			`//FSM signals`
109			`reg [9:0] state, nxt_state;`
110
111			`parameter IDLE = 10'd1,`
112			`ENCRYPT_0 = 10'd2,`
113			`INIT_COUNTER = 10'd4,`
114			`ENCRYPT_Y0 = 10'd8,`
115			`DATA_ACCEPT = 10'd16,`
116			`GFM_MULT = 10'd32,`
117			`INC_COUNTER = 10'd64,`
118			`M_ENCRYPT = 10'd128,`
119			`PRE_TAG_CALC = 10'd256,`
120			`TAG_CALC = 10'd512;`
121
122
123
124
125
126
127
128			`always @*`
129			`begin`
130			`dii_data_star = 0;`
131			`case(dii_data_size)`
132			`0: // 1 valid byte`
133			`begin`
134			`dii_data_star = ({dii_data[7:0],120'b0});`
135			`end`
136			`1: //2 valid bytes`
137			`begin`
138			`dii_data_star = {dii_data[15:0],112'b0};`
139			`end`
140			`2: //3 valid bytes`
141			`begin`
142			`dii_data_star = {dii_data[23:0],104'b0};`
143			`end`
144			`3: //4 valid bytes`
145			`begin`
146			`dii_data_star = {dii_data[31:0],96'b0};`
147			`end`
148			`4: //5 valid bytes`
149			`begin`
150			`dii_data_star = {dii_data[39:0],88'b0};`
151			`end`
152			`5: //6 valid bytes`
153			`begin`
154			`dii_data_star = {dii_data[47:0],80'b0};`
155			`end`
156			`6: //7 valid bytes`
157			`begin`
158			`dii_data_star = {dii_data[55:0],72'b0};`
159			`end`
160			`7: //8 valid bytes`
161			`begin`
162			`dii_data_star = {dii_data[63:0],64'b0};`
163			`end`
164			`8:`
165			`begin`
166			`dii_data_star = {dii_data[71:0],56'b0};`
167			`end`
168			`9:`
169			`begin`
170			`dii_data_star = {dii_data[79:0],48'b0};`
171			`end`
172			`10:`
173			`begin`
174			`dii_data_star = {dii_data[87:0],40'b0};`
175			`end`
176			`11:`
177			`begin`
178			`dii_data_star = {dii_data[95:0],32'b0};`
179			`end`
180			`12:`
181			`begin`
182			`dii_data_star = {dii_data[103:0],24'b0};`
183			`end`
184			`13: //14 valid bytes`
185			`begin`
186			`dii_data_star = ({dii_data[111:0],16'b0});`
187			`end`
188			`14: //15 valid bytes`
189			`begin`
190			`dii_data_star = {dii_data[119:0],8'b0};`
191			`end`
192			`endcase`
193
194			`end`
195
196			`always @*`
197			`begin`
198			`nxt_Out_data_star = 0;`
199			`case(dii_data_size)`
200			`0: //1 valid byte`
201			`begin`
202			`nxt_Out_data_star = {nxt_Out_data[127:120],120'b0};`
203			`end`
204			`1:// 2 valid bytes`
205			`begin`
206			`nxt_Out_data_star = {nxt_Out_data[127:112],112'b0};`
207			`end`
208			`2:// 3 valid bytes`
209			`begin`
210			`nxt_Out_data_star = {nxt_Out_data[127:104],104'b0};`
211			`end`
212			`3:// 4 valid bytes`
213			`begin`
214			`nxt_Out_data_star = {nxt_Out_data[127:96],96'b0};`
215			`end`
216			`4:// 5 valid bytes`
217			`begin`
218			`nxt_Out_data_star = {nxt_Out_data[127:88],88'b0};`
219			`end`
220			`5:// 6 valid bytes`
221			`begin`
222			`nxt_Out_data_star = {nxt_Out_data[127:80],80'b0};`
223			`end`
224			`6:// 7 valid bytes`
225			`begin`
226			`nxt_Out_data_star = {nxt_Out_data[127:72],72'b0};`
227			`end`
228			`7:// 8 valid bytes`
229			`begin`
230			`nxt_Out_data_star = {nxt_Out_data[127:64],64'b0};`
231			`end`
232			`8:// 9 valid bytes`
233			`begin`
234			`nxt_Out_data_star = {nxt_Out_data[127:56],56'b0};`
235			`end`
236			`9:// 10 valid bytes`
237			`begin`
238			`nxt_Out_data_star = {nxt_Out_data[127:48],48'b0};`
239			`end`
240			`10:// 11 valid bytes`
241			`begin`
242			`nxt_Out_data_star = {nxt_Out_data[127:40],40'b0};`
243			`end`
244			`11: // 12 valid byte`
245			`begin`
246			`nxt_Out_data_star = {nxt_Out_data[127:32],32'b0};`
247			`end`
248			`12:// 13 valid bytes`
249			`begin`
250			`nxt_Out_data_star = {nxt_Out_data[127:24],24'b0};`
251			`end`
252			`13:// 14 valid bytes`
253			`begin`
254			`nxt_Out_data_star = {nxt_Out_data[127:16],16'b0};`
255			`end`
256			`14: // 15 valid byte`
257			`begin`
258			`nxt_Out_data_star = {nxt_Out_data[127:8],8'b0};`
259			`end`
260
261			`endcase // case (dii_data_size)`
262			`end`
263
264
265			`always @(posedge clk or posedge rst)`
266			`if(rst)`
267			`begin`
268			`state <= #1 IDLE;`
269			`H <= #1 0;`
270			`EkY0 <= #1 0;`
271			`end`
272			`else`
273			`begin`
274			`H <= #1 nxt_H;`
275			`EkY0 <= #1 nxt_EkY0;`
276			`state <= #1 nxt_state;`
277			`end`
278
279
280			`//out data`
281			`always @(posedge clk)`
282			`begin`
283			`if(nxt_Out_vld & ~nxt_Tag_vld)`
284			`begin`
285			`Out_data <= #1 nxt_Out_data;`
286			`Out_data_size <= #1 dii_data_size;`
287			`Out_last_word <= #1 dii_last_word;`
288			`end`
289			`else if(nxt_Tag_vld)`
290			`Out_data <= #1 nxt_Tag_data;`
291
292			`Tag_vld <= #1 nxt_Tag_vld;`
293			`Out_vld <= #1 nxt_Out_vld;`
294			`end`
295
296			`/* always @(posedge clk)`
297			`begin`
298			`if(nxt_Out_vld)`
299			`begin`
300			`Out_data <= #1 nxt_Out_data;`
301			`Out_data_size <= #1 dii_data_size;`
302			`Out_last_word <= #1 dii_last_word;`
303			`end`
304			`Out_vld <= #1 nxt_Out_vld;`
305
306			`end`
307
308
309			`always @(posedge clk)`
310			`begin`
311			`if(nxt_Tag_vld)`
312			`Out_data <= #1 nxt_Tag_data;`
313
314			`Tag_vld <= #1 nxt_Tag_vld;`
315			`end`
316			`*/`
317
318			`//aes text_in`
319			`always @*`
320			`begin`
321			`aes_text_in = 0;`
322			`case(mux_aes_text_in_sel)`
323			`0: aes_text_in = 0;`
324
325			`1: aes_text_in = Yi;`
326
327			`endcase`
328			`end`
329
330
331			`//initializing Yi_init`
332			`always @*`
333			`begin`
334			`Yi_init = 0;`
335			`if(cii_IV_vld)`
336			`begin`
337			`Yi_init = dii_data;`
338			`end`
339			`end`
340
341
342			`//FSM`
343			`always @*`
344			`begin`
345			`//list of defaults`
346			`nxt_state = state;`
347			`we_y = 0;`
348			`we_lenA = 0;`
349			`we_lenC = 0;`
350			`dii_data_not_ready = 1;`
351			`aes_kld = 0;`
352			`mux_aes_text_in_sel = 0;`
353			`mux_yi_sel = 0;`
354			`start_gfm_cnt = 0;`
355			`nxt_H = H;`
356			`nxt_EkY0 = EkY0;`
357			`nxt_Out_vld = 0;`
358			`nxt_Tag_vld = 0;`
359			`gfm_input1 = 0;`
360			`nxt_Out_data = 0;`
361			`nxt_Tag_data = 0;`
362
363			`case(state)`
364			`IDLE:`
365			`begin`
366			`// $display($time,": In IDLE\n");`
367			`if(cii_ctl_vld)`
368			`begin`
369			`aes_kld = 1;`
370			`mux_aes_text_in_sel = 0;`
371			`nxt_state = ENCRYPT_0;`
372			`end`
373			`end`
374
375			`ENCRYPT_0:`
376			`begin`
377			`if(aes_done)`
378			`begin`
379			`nxt_H = aes_text_out;`
380			`if(cii_IV_vld)`
381			`begin`
382			`we_y = 1;`
383			`nxt_state = INIT_COUNTER;`
384			`end`
385			`end`
386			`end // case: ENCRYPT_0`
387
388			`INIT_COUNTER:`
389			`begin`
390			`// figure out how to launch a GCM op here,`
391			`// or go to next state which launches GCM op`
392			`mux_aes_text_in_sel = 1;`
393			`aes_kld = 1;`
394			`nxt_state = ENCRYPT_Y0;`
395			`end`
396
397
398			`ENCRYPT_Y0:`
399			`begin`
400			`if(aes_done)`
401			`begin`
402			`nxt_EkY0 = aes_text_out;`
403			`nxt_state = DATA_ACCEPT;`
404			`end`
405			`end`
406
407			`DATA_ACCEPT:`
408			`begin`
409			`dii_data_not_ready = 0;`
410			`if(dii_data_vld & dii_data_type) //AAD`
411			`begin`
412			`if(dii_data_size == 4'd15)`
413			`begin`
414			`we_lenA = 1;`
415			`gfm_input1 = dii_data;`
416			`start_gfm_cnt = 1;`
417			`nxt_state = GFM_MULT;`
418			`end`
419			`else`
420			`begin`
421			`we_lenA = 1;`
422			`gfm_input1 = dii_data_star; //note star`
423			`start_gfm_cnt = 1;`
424			`nxt_state = GFM_MULT;`
425			`end`
426			`end`
427			`else if(dii_data_vld & ~dii_data_type) //ENC`
428			`begin`
429			`mux_yi_sel = 1;`
430			`we_y = 1;`
431			`nxt_state = INC_COUNTER;`
432			`end`
433			`end // case: AAD_ACCEPT`
434
435			`INC_COUNTER:`
436			`begin`
437			`we_lenC = 1;`
438			`mux_aes_text_in_sel = 1;`
439			`aes_kld = 1;`
440			`nxt_state = M_ENCRYPT;`
441			`end`
442
443			`GFM_MULT:`
444			`begin`
445			`if(gfm_cnt == 4'd7)`
446			`begin`
447			`start_gfm_cnt = 0;`
448			`if(~dii_last_word)`
449			`nxt_state = DATA_ACCEPT;`
450			`else`
451			`nxt_state = PRE_TAG_CALC;`
452			`end`
453			`end`
454
455			`M_ENCRYPT:`
456			`begin`
457			`if(aes_done)`
458			`begin`
459			`if(dii_data_size == 4'd15)`
460			`begin`
461			`nxt_Out_data = aes_text_out ^ dii_data;`
462			`nxt_Out_vld = 1;`
463			`gfm_input1 = nxt_Out_data;`
464			`end`
465			`else`
466			`begin`
467			`nxt_Out_data = aes_text_out ^ dii_data_star;`
468			`nxt_Out_vld = 1;`
469			`gfm_input1 = nxt_Out_data_star;`
470			`end`
471			`start_gfm_cnt = 1;`
472			`nxt_state = GFM_MULT;`
473			`end`
474			`end // case: M_ACCEPT`
475
476			`PRE_TAG_CALC:`
477			`begin`
478			`gfm_input1 = {(aad_byte_cnt << 3),(enc_byte_cnt << 3)};`
479			`start_gfm_cnt = 1;`
480			`nxt_state = TAG_CALC;`
481			`end`
482
483			`TAG_CALC:`
484			`begin`
485			`if(gfm_cnt == 4'd7)`
486			`begin`
487			`start_gfm_cnt = 0;`
488			`nxt_Tag_data = EkY0 ^ z_out;`
489			`nxt_Tag_vld = 1'b1;`
490			`nxt_state = IDLE;`
491			`end`
492			`end`
493
494			`endcase`
495
496			`end`
497
498
499
500
501
502			`always @(posedge clk)`
503			`if(we_y)`
504			`case(mux_yi_sel)`
505			`0: Yi <= #1 Yi_init;`
506			`1: Yi <= #1 Yi + 1;`
507			`endcase`
508
509			`always @(posedge clk or posedge rst)`
510			`if(rst)`
511			`enc_byte_cnt <= #1 0;`
512			`else if(we_lenC)`
513			`enc_byte_cnt <= #1 enc_byte_cnt + dii_data_size + 1;`
514
515			`always @(posedge clk or posedge rst)`
516			`if(rst)`
517			`aad_byte_cnt <= #1 0;`
518			`else if(we_lenA)`
519			`aad_byte_cnt <= #1 aad_byte_cnt + dii_data_size + 1;`
520
521			`always @(posedge clk)`
522			`if(start_gfm_cnt)`
523			`gfm_cnt <= #1 4'd0;`
524			`else if(gfm_cnt != 4'd7)`
525			`gfm_cnt <= #1 gfm_cnt + 1;`
526
527
528			`always @(posedge clk)`
529			`if(cii_ctl_vld)`
530			`gfm_result <= #1 0;`
531			`else if(gfm_cnt == 4'd7)`
532			`gfm_result <= #1 z_out;`
533
534
535
536			`always @(posedge clk)`
537			`if(start_gfm_cnt)`
538			`begin`
539			`v_in <= #1 H;`
540			z_in <= #1 {`SIZE{1'b0}};
541			`b_in <= #1 gfm_input1 ^ gfm_result;`
542			`end`
543
544			`else`
545			`begin`
546			`v_in <= #1 v_out;`
547			`z_in <= #1 z_out;`
548			`b_in <= #1 b_in << 16;`
549			`end`
550
551
552
553
554			`/*`
555			`gfm128_16 AUTO_TEMPLATE`
556			`(`
557			`.v_out (v_out[127:0]),`
558			`.z_out (z_out[127:0]),`
559			`.v_in (v_in[127:0]),`
560			`.z_in (z_in[127:0]),`
561			`.b_in (b_in[127:112]),`
562			`);`
563			`*/`
564
565
566			`gfm128_16 GFM(/AUTOINST/`
567			`// Outputs`
568			`.v_out (v_out[127:0]), // Templated`
569			`.z_out (z_out[127:0]), // Templated`
570			`// Inputs`
571			`.v_in (v_in[127:0]), // Templated`
572			`.z_in (z_in[127:0]), // Templated`
573			`.b_in (b_in[127:112])); // Templated`
574
575
576			`/*`
577			`aes_cipher_top AUTO_TEMPLATE`
578			`(`
579			`.done (aes_done),`
580			`.text_out (aes_text_out[127:0]),`
581			`.clk (clk),`
582			`.rst (rst),`
583			`.ld (aes_kld),`
584			`.key (cii_K),`
585			`.text_in (aes_text_in[127:0]),`
586			`);`
587			`*/`
588
589			`aes_cipher_top AES_ENC (/AUTOINST/`
590			`// Outputs`
591			`.done (aes_done), // Templated`
592			`.text_out (aes_text_out[127:0]), // Templated`
593			`// Inputs`
594			`.clk (clk), // Templated`
595			`.rst (rst), // Templated`
596			`.ld (aes_kld), // Templated`
597			`.key (cii_K), // Templated`
598			`.text_in (aes_text_in[127:0])); // Templated`
599
600
601
602
603			`endmodule`