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

Subversion Repositories apbtoaes128

[/] [apbtoaes128/] [trunk/] [rtl/] [host_interface.v] - Blame information for rev 12

Details | Compare with Previous | View Log


//////////////////////////////////////////////////////////////////
////
////
////    AES CORE BLOCK
////
////
////
//// This file is part of the APB to I2C project
////
//// http://www.opencores.org/cores/apbi2c/
////
////
////
//// Description
////
//// Implementation of APB IP core according to
////
//// aes128_spec IP core specification document.
////
////
////
//// To Do: Things are right here but always all block can suffer changes
////
////
////
////
////
//// Author(s): - Felipe Fernandes Da Costa, fefe2560@gmail.com
////              Julio Cesar 
////
///////////////////////////////////////////////////////////////// 
////
////
//// Copyright (C) 2009 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
////
////
///////////////////////////////////////////////////////////////////
module host_interface
(
        // OUTPUTS
        output [3:0] key_en,
        output [1:0] col_addr,
        output [1:0] chmod,
        output [1:0] mode,
        output [1:0] data_type,
        output col_wr_en,
        output col_rd_en,
        output [1:0] key_sel,
        output [3:0] iv_en,
        output [3:0] iv_sel,
        output int_ccf,
        output int_err,
        output disable_core,
        output reg first_block,
        output dma_req_wr,
        output dma_req_rd,
        output reg start_core,
        output [31:0] PRDATA,
        //INPUTS
        input [3:0] PADDR,
        input [12:0] PWDATA,
        input PWRITE,
        input PENABLE,
        input PSEL,
        input PCLK,
        input PRESETn,
        input [31:0] key_bus,
        input [31:0] col_bus,
        input [31:0] iv_bus,
        input ccf_set
);
 
//`include "include/host_interface.vh"
 
//=====================================================================================
// Memory Mapped Registers Address
//=====================================================================================
localparam AES_CR    = 4'd00;
localparam AES_SR    = 4'd01;
localparam AES_DINR  = 4'd02;
localparam AES_DOUTR = 4'd03;
localparam AES_KEYR0 = 4'd04;
localparam AES_KEYR1 = 4'd05;
localparam AES_KEYR2 = 4'd06;
localparam AES_KEYR3 = 4'd07;
localparam AES_IVR0  = 4'd08;
localparam AES_IVR1  = 4'd09;
localparam AES_IVR2  = 4'd10;
localparam AES_IVR3  = 4'd11;
 
//=============================================================================
// Operation Modes
//=============================================================================
localparam ENCRYPTION     = 2'b00;
localparam KEY_DERIVATION = 2'b01;
localparam DECRYPTION     = 2'b10;
localparam DECRYP_W_DERIV = 2'b11;
 
//=============================================================================
// AES Modes
//=============================================================================
localparam ECB = 2'b00;
localparam CBC = 2'b01;
localparam CTR = 2'b10;
 
//=============================================================================
// Resets Values
//=============================================================================
localparam AES_CR_RESET = 13'd0;
localparam AES_SR_RESET =  3'd0;
 
//=============================================================================
// Enable Value (Active High)
//=============================================================================
localparam ENABLE  = 1'b1;
localparam DISABLE = 1'b0;
 
//=============================================================================
// FSM STATES
//=============================================================================
localparam IDLE   = 3'd0;
localparam INPUT  = 3'd1;
localparam START  = 3'd2;
localparam WAIT   = 3'd3;
localparam OUTPUT = 3'd4;
 
wire [31:0] bus_out;
reg [31:0] bus_out_mux;
reg cnt_en;
reg enable_clear;
reg access_permission;
reg first_block_set;
reg first_block_clear;
wire [1:0] mode_in;
wire [1:0] chmod_in;
wire write_en;
wire read_en;
wire dma_out_en;
wire dma_in_en;
wire err_ie;
wire ccf_ie;
wire errc;
wire ccfc;
wire aes_cr_wr_en;
//wire aes_sr_wr_en;
wire wr_err_en;
wire rd_err_en;
wire write_completed;
wire read_completed;
wire key_deriv;
 
 
reg [10:0] aes_cr;
reg wr_err;
reg rd_err;
reg ccf;
reg [2:0] state, next_state;
reg [1:0] cnt;
reg dma_req;
wire enable;
 
// Write and read enable signals
assign write_en = PSEL & PENABLE & PWRITE;
assign read_en  = (PSEL & ~PWRITE)?1'b1:1'b0;
 
// Configuration Register Logic
assign dma_out_en = aes_cr[10];
assign dma_in_en  = aes_cr[9];
assign err_ie     = aes_cr[8];
assign ccf_ie     = aes_cr[7];
assign errc       = PWDATA[8];
assign ccfc       = PWDATA[7];
assign chmod      = aes_cr[6:5];
assign mode       = aes_cr[4:3];
assign data_type  = aes_cr[2:1];
assign enable     = aes_cr[0];
 
assign aes_cr_wr_en = (PADDR == AES_CR) & write_en;
assign mode_in  = PWDATA[4:3];
assign chmod_in = PWDATA[6:5];
 
always @(posedge PCLK, negedge PRESETn)
        begin
                if(!PRESETn)
                        aes_cr <= AES_CR_RESET[10:0];
                else
                        begin
                                if(enable_clear)
                                        aes_cr[0] <= 1'b0;
                                else
                                        if(aes_cr_wr_en)
                                                aes_cr[0] <= PWDATA[0];
 
                                if(aes_cr_wr_en && access_permission)
                                        begin
                                                aes_cr[2:1] <= PWDATA[2:1];
                                                if(mode_in == DECRYP_W_DERIV && chmod_in == CTR)
                                                        aes_cr[4:3] <= DECRYPTION;
                                                else
                                                        aes_cr[4:3] <= mode_in;
                                                aes_cr[ 6:5] <= PWDATA[6:5];
                                                aes_cr[10:7] <= PWDATA[12:9];
                                        end
                        end
        end
 
// Status Register Logic
//assign aes_sr_wr_en = (PADDR == AES_SR) & write_en & access_permission;
 
always @(posedge PCLK, negedge PRESETn)
        begin
                if(!PRESETn)
                begin
                        {wr_err, rd_err, ccf} <= AES_SR_RESET;
 
                end
                else
                        begin
                                // Write Error Flag
                                if(wr_err_en)
                                        wr_err <= 1'b1;
                                else
                                        if(errc && aes_cr_wr_en && access_permission)
                                                wr_err <= 1'b0;
 
                                //Read Error Flag
                                if(rd_err_en)
                                        rd_err <= 1'b1;
                                else
                                        if(errc && aes_cr_wr_en && access_permission)
                                                rd_err <= 1'b0;
 
                                // Computation Complete Flag
                                if(ccf_set)
                                        ccf <= 1'b1;
                                else
                                        if(ccfc && aes_cr_wr_en )//&& access_permission)
                                                ccf <= 1'b0;
                        end
        end
// Interruption on erros Signals
assign int_ccf = ccf_ie & ccf_set;
assign int_err = (wr_err_en | rd_err_en) & err_ie;
 
// Key Signals Decoding
assign key_en = (4'b1000 >> PADDR[1:0]) & {4{(~PADDR[3] & PADDR[2] & access_permission & write_en)}};
assign key_sel = ~PADDR[1:0] & {2{(PADDR[2] & access_permission)}};
 
// IV Signals Decoding
assign iv_sel = (4'b1000 >> PADDR[1:0]) & {4{(PADDR[3] & ~PADDR[2] & access_permission)}};
assign iv_en = iv_sel & {4{write_en}};
 
// State Register
always @(posedge PCLK, negedge PRESETn)
        begin
                if(!PRESETn)
                        state <= IDLE;
                else
                        if(!enable)
                                state <= IDLE;
                        else
                                state <= next_state;
        end
 
assign write_completed = (cnt == 2'b11);
assign read_completed  = (cnt == 2'b11);
assign key_deriv = (mode == KEY_DERIVATION);
 
// Next State Logic
always @(*)
        begin
                next_state = state;
                case(state)
                IDLE  :
                        begin
                                if(enable)
                                        next_state = (key_deriv) ? START : INPUT;
                        end
                INPUT :
                        next_state = (write_completed && cnt_en) ? START : INPUT;
                START :
                        next_state = WAIT;
                WAIT  :
                        begin
                                if(ccf_set)
                                        next_state = (key_deriv) ? IDLE : OUTPUT;
                        end
                OUTPUT:
                        next_state = (read_completed && cnt_en) ? INPUT : OUTPUT;
                endcase
        end
 
// Output Logic
assign disable_core = ~enable;
 
always @(*)
        begin
                access_permission = DISABLE;
                start_core = DISABLE;
                cnt_en = DISABLE;
                enable_clear = DISABLE;
                first_block_set = DISABLE;
                first_block_clear = DISABLE;
                case(state)
                        IDLE:
                                begin
                                        access_permission = ENABLE;
                                        first_block_set = ENABLE;
                                        if(enable && !key_deriv)
                                                cnt_en = ENABLE;
                                end
                        INPUT:
                                begin
                                        if(PADDR == AES_DINR && write_en)
                                                cnt_en = ENABLE;
                                end
                        START:
                                begin
                                        start_core = ENABLE;
                                end
                        WAIT:
                                begin
                                        if(ccf_set)
                                                cnt_en = ENABLE;
                                        if(ccf_set && key_deriv)
                                                enable_clear = ENABLE;
                                end
                        OUTPUT:
                                begin
                                        first_block_clear = ENABLE;
                                        if(PADDR == AES_DOUTR && read_en && PENABLE )//|| write_completed)
                                                cnt_en = ENABLE;
                                end
                endcase
        end
 
// First Block Signal indicates when IV register is used
always @(posedge PCLK, negedge PRESETn)
        begin
                if(!PRESETn)
                        first_block <= 1'b1;
                else
                        if(first_block_set)
                                first_block <= 1'b1;
                        else
                                if(first_block_clear)
                                        first_block <= 1'b0;
        end
 
always @(posedge PCLK, negedge PRESETn)
        begin
                if(!PRESETn)
                        cnt <= 2'b11;
                else
                        begin
                                if(!enable || state == START)
                                        cnt <= 2'b11;
                                else
                                        if(cnt_en)
                                                cnt <= cnt + 1'b1;
                        end
        end
 
assign col_addr = cnt;
assign col_wr_en = (PADDR == AES_DINR  && write_en && state == INPUT);
assign col_rd_en = (PADDR == AES_DOUTR && read_en  && state == OUTPUT);
assign wr_err_en = (PADDR == AES_DINR  && write_en && (state != INPUT  && state != IDLE));
assign rd_err_en = (PADDR == AES_DOUTR && read_en  && (state != OUTPUT && state != IDLE));
 
// DMA Requests Logic
always @(posedge PCLK, negedge PRESETn)
        begin
                if(!PRESETn)
                        dma_req <= 1'b0;
                else
                        dma_req <= cnt[0];
        end
 
assign dma_req_wr = (dma_req ^ cnt[0]) & dma_in_en  & enable & (state == INPUT  || state == IDLE);
assign dma_req_rd = (dma_req ^ cnt[0]) & dma_out_en & enable & (state == OUTPUT);
 
// APB Read Signal
assign PRDATA = bus_out;
 
// Output Mux
always @(*)
        begin
                bus_out_mux = 32'd0;
                case(PADDR)
                        AES_CR:
                                bus_out_mux = {{19{1'b0}}, aes_cr[10:7], 2'b00, aes_cr[6:0]};
                        AES_SR:
                                bus_out_mux = {{29{1'b0}}, wr_err, rd_err, (ccf_set && ~PENABLE)? 1'b1:(ccfc && aes_cr_wr_en)?1'b0:ccf};
                        AES_DINR, AES_DOUTR:
                        begin
                                if(~PWRITE && PADDR == AES_DOUTR && (ccf_set || ccf ))
                                        bus_out_mux = col_bus;
                        end
                        AES_KEYR0, AES_KEYR1, AES_KEYR2, AES_KEYR3:
                                if(!enable)
                                        bus_out_mux = key_bus;
                        AES_IVR0, AES_IVR1, AES_IVR2, AES_IVR3:
                                if(!enable)
                                        bus_out_mux = iv_bus;
 
                endcase
        end
 
// The output Bus is registered
 
assign bus_out =(read_en)? bus_out_mux:32'd0;
 
/*
always @(posedge PCLK, negedge PRESETn)
        begin
                if(!PRESETn)
                        bus_out <= 32'd0;
                else
                        if(read_en)
                                bus_out <= bus_out_mux;
        end
*/
 
endmodule

Line No.	Rev	Author	Line
1	2	redbear	`//////////////////////////////////////////////////////////////////`
2			`////`
3			`////`
4			`//// AES CORE BLOCK`
5			`////`
6			`////`
7			`////`
8	7	redbear	`//// This file is part of the APB to I2C project`
9	2	redbear	`////`
10	7	redbear	`//// http://www.opencores.org/cores/apbi2c/`
11	2	redbear	`////`
12			`////`
13			`////`
14			`//// Description`
15			`////`
16			`//// Implementation of APB IP core according to`
17			`////`
18			`//// aes128_spec IP core specification document.`
19			`////`
20			`////`
21			`////`
22			`//// To Do: Things are right here but always all block can suffer changes`
23			`////`
24			`////`
25			`////`
26			`////`
27			`////`
28			`//// Author(s): - Felipe Fernandes Da Costa, fefe2560@gmail.com`
29			`//// Julio Cesar`
30			`////`
31			`/////////////////////////////////////////////////////////////////`
32			`////`
33			`////`
34			`//// Copyright (C) 2009 Authors and OPENCORES.ORG`
35			`////`
36			`////`
37			`////`
38			`//// This source file may be used and distributed without`
39			`////`
40			`//// restriction provided that this copyright statement is not`
41			`////`
42			`//// removed from the file and that any derivative work contains`
43			`//// the original copyright notice and the associated disclaimer.`
44			`////`
45			`////`
46			`//// This source file is free software; you can redistribute it`
47			`////`
48			`//// and/or modify it under the terms of the GNU Lesser General`
49			`////`
50			`//// Public License as published by the Free Software Foundation;`
51			`//// either version 2.1 of the License, or (at your option) any`
52			`////`
53			`//// later version.`
54			`////`
55			`////`
56			`////`
57			`//// This source is distributed in the hope that it will be`
58			`////`
59			`//// useful, but WITHOUT ANY WARRANTY; without even the implied`
60			`////`
61			`//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR`
62			`////`
63			`//// PURPOSE. See the GNU Lesser General Public License for more`
64			`//// details.`
65			`////`
66			`////`
67			`////`
68			`//// You should have received a copy of the GNU Lesser General`
69			`////`
70			`//// Public License along with this source; if not, download it`
71			`////`
72			`//// from http://www.opencores.org/lgpl.shtml`
73			`////`
74			`////`
75			`///////////////////////////////////////////////////////////////////`
76			`module host_interface`
77			`(`
78			`// OUTPUTS`
79			`output [3:0] key_en,`
80			`output [1:0] col_addr,`
81			`output [1:0] chmod,`
82			`output [1:0] mode,`
83			`output [1:0] data_type,`
84			`output col_wr_en,`
85			`output col_rd_en,`
86			`output [1:0] key_sel,`
87			`output [3:0] iv_en,`
88			`output [3:0] iv_sel,`
89			`output int_ccf,`
90			`output int_err,`
91			`output disable_core,`
92			`output reg first_block,`
93			`output dma_req_wr,`
94			`output dma_req_rd,`
95			`output reg start_core,`
96			`output [31:0] PRDATA,`
97			`//INPUTS`
98			`input [3:0] PADDR,`
99	7	redbear	`input [12:0] PWDATA,`
100	2	redbear	`input PWRITE,`
101			`input PENABLE,`
102			`input PSEL,`
103			`input PCLK,`
104			`input PRESETn,`
105			`input [31:0] key_bus,`
106			`input [31:0] col_bus,`
107			`input [31:0] iv_bus,`
108			`input ccf_set`
109			`);`
110
111			//`include "include/host_interface.vh"
112
113			`//=====================================================================================`
114			`// Memory Mapped Registers Address`
115			`//=====================================================================================`
116			`localparam AES_CR = 4'd00;`
117			`localparam AES_SR = 4'd01;`
118			`localparam AES_DINR = 4'd02;`
119			`localparam AES_DOUTR = 4'd03;`
120			`localparam AES_KEYR0 = 4'd04;`
121			`localparam AES_KEYR1 = 4'd05;`
122			`localparam AES_KEYR2 = 4'd06;`
123			`localparam AES_KEYR3 = 4'd07;`
124			`localparam AES_IVR0 = 4'd08;`
125			`localparam AES_IVR1 = 4'd09;`
126			`localparam AES_IVR2 = 4'd10;`
127			`localparam AES_IVR3 = 4'd11;`
128
129			`//=============================================================================`
130			`// Operation Modes`
131			`//=============================================================================`
132			`localparam ENCRYPTION = 2'b00;`
133			`localparam KEY_DERIVATION = 2'b01;`
134			`localparam DECRYPTION = 2'b10;`
135			`localparam DECRYP_W_DERIV = 2'b11;`
136
137			`//=============================================================================`
138			`// AES Modes`
139			`//=============================================================================`
140			`localparam ECB = 2'b00;`
141			`localparam CBC = 2'b01;`
142			`localparam CTR = 2'b10;`
143
144			`//=============================================================================`
145			`// Resets Values`
146			`//=============================================================================`
147			`localparam AES_CR_RESET = 13'd0;`
148			`localparam AES_SR_RESET = 3'd0;`
149
150			`//=============================================================================`
151			`// Enable Value (Active High)`
152			`//=============================================================================`
153			`localparam ENABLE = 1'b1;`
154			`localparam DISABLE = 1'b0;`
155
156			`//=============================================================================`
157			`// FSM STATES`
158			`//=============================================================================`
159			`localparam IDLE = 3'd0;`
160			`localparam INPUT = 3'd1;`
161			`localparam START = 3'd2;`
162			`localparam WAIT = 3'd3;`
163			`localparam OUTPUT = 3'd4;`
164
165	7	redbear	`wire [31:0] bus_out;`
166	2	redbear	`reg [31:0] bus_out_mux;`
167			`reg cnt_en;`
168			`reg enable_clear;`
169			`reg access_permission;`
170			`reg first_block_set;`
171			`reg first_block_clear;`
172			`wire [1:0] mode_in;`
173			`wire [1:0] chmod_in;`
174			`wire write_en;`
175			`wire read_en;`
176			`wire dma_out_en;`
177			`wire dma_in_en;`
178			`wire err_ie;`
179			`wire ccf_ie;`
180			`wire errc;`
181			`wire ccfc;`
182			`wire aes_cr_wr_en;`
183	7	redbear	`//wire aes_sr_wr_en;`
184	2	redbear	`wire wr_err_en;`
185			`wire rd_err_en;`
186			`wire write_completed;`
187			`wire read_completed;`
188			`wire key_deriv;`
189
190
191			`reg [10:0] aes_cr;`
192			`reg wr_err;`
193			`reg rd_err;`
194			`reg ccf;`
195			`reg [2:0] state, next_state;`
196			`reg [1:0] cnt;`
197			`reg dma_req;`
198	7	redbear	`wire enable;`
199	2	redbear
200			`// Write and read enable signals`
201			`assign write_en = PSEL & PENABLE & PWRITE;`
202	10	redbear	`assign read_en = (PSEL & ~PWRITE)?1'b1:1'b0;`
203	2	redbear
204			`// Configuration Register Logic`
205			`assign dma_out_en = aes_cr[10];`
206			`assign dma_in_en = aes_cr[9];`
207			`assign err_ie = aes_cr[8];`
208			`assign ccf_ie = aes_cr[7];`
209			`assign errc = PWDATA[8];`
210			`assign ccfc = PWDATA[7];`
211			`assign chmod = aes_cr[6:5];`
212			`assign mode = aes_cr[4:3];`
213			`assign data_type = aes_cr[2:1];`
214			`assign enable = aes_cr[0];`
215
216			`assign aes_cr_wr_en = (PADDR == AES_CR) & write_en;`
217			`assign mode_in = PWDATA[4:3];`
218			`assign chmod_in = PWDATA[6:5];`
219
220			`always @(posedge PCLK, negedge PRESETn)`
221			`begin`
222			`if(!PRESETn)`
223	7	redbear	`aes_cr <= AES_CR_RESET[10:0];`
224	2	redbear	`else`
225			`begin`
226			`if(enable_clear)`
227			`aes_cr[0] <= 1'b0;`
228			`else`
229			`if(aes_cr_wr_en)`
230			`aes_cr[0] <= PWDATA[0];`
231
232			`if(aes_cr_wr_en && access_permission)`
233			`begin`
234			`aes_cr[2:1] <= PWDATA[2:1];`
235			`if(mode_in == DECRYP_W_DERIV && chmod_in == CTR)`
236			`aes_cr[4:3] <= DECRYPTION;`
237			`else`
238			`aes_cr[4:3] <= mode_in;`
239			`aes_cr[ 6:5] <= PWDATA[6:5];`
240			`aes_cr[10:7] <= PWDATA[12:9];`
241			`end`
242			`end`
243			`end`
244
245			`// Status Register Logic`
246	7	redbear	`//assign aes_sr_wr_en = (PADDR == AES_SR) & write_en & access_permission;`
247	2	redbear
248			`always @(posedge PCLK, negedge PRESETn)`
249			`begin`
250			`if(!PRESETn)`
251	7	redbear	`begin`
252	2	redbear	`{wr_err, rd_err, ccf} <= AES_SR_RESET;`
253	7	redbear
254			`end`
255	2	redbear	`else`
256			`begin`
257			`// Write Error Flag`
258			`if(wr_err_en)`
259			`wr_err <= 1'b1;`
260			`else`
261			`if(errc && aes_cr_wr_en && access_permission)`
262			`wr_err <= 1'b0;`
263
264			`//Read Error Flag`
265			`if(rd_err_en)`
266			`rd_err <= 1'b1;`
267			`else`
268			`if(errc && aes_cr_wr_en && access_permission)`
269			`rd_err <= 1'b0;`
270
271			`// Computation Complete Flag`
272			`if(ccf_set)`
273	7	redbear	`ccf <= 1'b1;`
274	2	redbear	`else`
275	11	redbear	`if(ccfc && aes_cr_wr_en )//&& access_permission)`
276	2	redbear	`ccf <= 1'b0;`
277			`end`
278			`end`
279			`// Interruption on erros Signals`
280			`assign int_ccf = ccf_ie & ccf_set;`
281			`assign int_err = (wr_err_en \| rd_err_en) & err_ie;`
282
283			`// Key Signals Decoding`
284			`assign key_en = (4'b1000 >> PADDR[1:0]) & {4{(~PADDR[3] & PADDR[2] & access_permission & write_en)}};`
285			`assign key_sel = ~PADDR[1:0] & {2{(PADDR[2] & access_permission)}};`
286
287			`// IV Signals Decoding`
288			`assign iv_sel = (4'b1000 >> PADDR[1:0]) & {4{(PADDR[3] & ~PADDR[2] & access_permission)}};`
289			`assign iv_en = iv_sel & {4{write_en}};`
290
291			`// State Register`
292			`always @(posedge PCLK, negedge PRESETn)`
293			`begin`
294			`if(!PRESETn)`
295			`state <= IDLE;`
296			`else`
297			`if(!enable)`
298			`state <= IDLE;`
299			`else`
300			`state <= next_state;`
301			`end`
302
303			`assign write_completed = (cnt == 2'b11);`
304			`assign read_completed = (cnt == 2'b11);`
305			`assign key_deriv = (mode == KEY_DERIVATION);`
306
307			`// Next State Logic`
308			`always @(*)`
309			`begin`
310			`next_state = state;`
311			`case(state)`
312			`IDLE :`
313			`begin`
314			`if(enable)`
315			`next_state = (key_deriv) ? START : INPUT;`
316			`end`
317			`INPUT :`
318			`next_state = (write_completed && cnt_en) ? START : INPUT;`
319			`START :`
320			`next_state = WAIT;`
321			`WAIT :`
322			`begin`
323			`if(ccf_set)`
324			`next_state = (key_deriv) ? IDLE : OUTPUT;`
325			`end`
326			`OUTPUT:`
327			`next_state = (read_completed && cnt_en) ? INPUT : OUTPUT;`
328			`endcase`
329			`end`
330
331			`// Output Logic`
332			`assign disable_core = ~enable;`
333
334			`always @(*)`
335			`begin`
336			`access_permission = DISABLE;`
337			`start_core = DISABLE;`
338			`cnt_en = DISABLE;`
339			`enable_clear = DISABLE;`
340			`first_block_set = DISABLE;`
341			`first_block_clear = DISABLE;`
342			`case(state)`
343			`IDLE:`
344			`begin`
345			`access_permission = ENABLE;`
346			`first_block_set = ENABLE;`
347			`if(enable && !key_deriv)`
348			`cnt_en = ENABLE;`
349			`end`
350			`INPUT:`
351			`begin`
352			`if(PADDR == AES_DINR && write_en)`
353			`cnt_en = ENABLE;`
354			`end`
355			`START:`
356			`begin`
357			`start_core = ENABLE;`
358			`end`
359			`WAIT:`
360			`begin`
361			`if(ccf_set)`
362			`cnt_en = ENABLE;`
363			`if(ccf_set && key_deriv)`
364			`enable_clear = ENABLE;`
365			`end`
366			`OUTPUT:`
367			`begin`
368			`first_block_clear = ENABLE;`
369			`if(PADDR == AES_DOUTR && read_en && PENABLE )//\|\| write_completed)`
370			`cnt_en = ENABLE;`
371			`end`
372			`endcase`
373			`end`
374
375			`// First Block Signal indicates when IV register is used`
376			`always @(posedge PCLK, negedge PRESETn)`
377			`begin`
378			`if(!PRESETn)`
379			`first_block <= 1'b1;`
380			`else`
381			`if(first_block_set)`
382			`first_block <= 1'b1;`
383			`else`
384			`if(first_block_clear)`
385			`first_block <= 1'b0;`
386			`end`
387
388			`always @(posedge PCLK, negedge PRESETn)`
389			`begin`
390			`if(!PRESETn)`
391			`cnt <= 2'b11;`
392			`else`
393			`begin`
394			`if(!enable \|\| state == START)`
395			`cnt <= 2'b11;`
396			`else`
397			`if(cnt_en)`
398			`cnt <= cnt + 1'b1;`
399			`end`
400			`end`
401
402			`assign col_addr = cnt;`
403			`assign col_wr_en = (PADDR == AES_DINR && write_en && state == INPUT);`
404			`assign col_rd_en = (PADDR == AES_DOUTR && read_en && state == OUTPUT);`
405	12	redbear	`assign wr_err_en = (PADDR == AES_DINR && write_en && (state != INPUT && state != IDLE));`
406			`assign rd_err_en = (PADDR == AES_DOUTR && read_en && (state != OUTPUT && state != IDLE));`
407	2	redbear
408			`// DMA Requests Logic`
409			`always @(posedge PCLK, negedge PRESETn)`
410			`begin`
411			`if(!PRESETn)`
412	7	redbear	`dma_req <= 1'b0;`
413	2	redbear	`else`
414			`dma_req <= cnt[0];`
415			`end`
416
417			`assign dma_req_wr = (dma_req ^ cnt[0]) & dma_in_en & enable & (state == INPUT \|\| state == IDLE);`
418			`assign dma_req_rd = (dma_req ^ cnt[0]) & dma_out_en & enable & (state == OUTPUT);`
419
420			`// APB Read Signal`
421			`assign PRDATA = bus_out;`
422
423			`// Output Mux`
424			`always @(*)`
425			`begin`
426			`bus_out_mux = 32'd0;`
427			`case(PADDR)`
428			`AES_CR:`
429			`bus_out_mux = {{19{1'b0}}, aes_cr[10:7], 2'b00, aes_cr[6:0]};`
430			`AES_SR:`
431	10	redbear	`bus_out_mux = {{29{1'b0}}, wr_err, rd_err, (ccf_set && ~PENABLE)? 1'b1:(ccfc && aes_cr_wr_en)?1'b0:ccf};`
432	2	redbear	`AES_DINR, AES_DOUTR:`
433	10	redbear	`begin`
434			`if(~PWRITE && PADDR == AES_DOUTR && (ccf_set \|\| ccf ))`
435			`bus_out_mux = col_bus;`
436			`end`
437	2	redbear	`AES_KEYR0, AES_KEYR1, AES_KEYR2, AES_KEYR3:`
438	7	redbear	`if(!enable)`
439			`bus_out_mux = key_bus;`
440	2	redbear	`AES_IVR0, AES_IVR1, AES_IVR2, AES_IVR3:`
441			`if(!enable)`
442			`bus_out_mux = iv_bus;`
443	7	redbear
444	2	redbear	`endcase`
445			`end`
446
447			`// The output Bus is registered`
448	7	redbear
449			`assign bus_out =(read_en)? bus_out_mux:32'd0;`
450
451			`/*`
452	2	redbear	`always @(posedge PCLK, negedge PRESETn)`
453			`begin`
454			`if(!PRESETn)`
455			`bus_out <= 32'd0;`
456			`else`
457			`if(read_en)`
458			`bus_out <= bus_out_mux;`
459			`end`
460	7	redbear	`*/`
461	2	redbear
462			`endmodule`

Browse

Tools

Subversion Repositories apbtoaes128

[/] [apbtoaes128/] [trunk/] [rtl/] [host_interface.v] - Blame information for rev 12