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

Subversion Repositories csa

[/] [csa/] [trunk/] [rtl/] [decrypt.v] - Blame information for rev 40

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


 
`include "../bench/timescale.v"
// this module will do csa decrypt work
 
module decrypt(clk,rst,ck,key_en,even_odd,en,encrypted,decrypted,invalid);
input             clk;
input             rst;
input             key_en;    // signal high valid,
input             even_odd;  // indiate the input ck is even or odd, 0 --- even odd ---odd
input             en;        // decrypted
input  [8*8-1:0]  ck;        // input ck
input  [  8-1:0]  encrypted; // input ts stream
output [  8-1:0]  decrypted; // decrypt ts stream
output            invalid;   // thsi output data is invalid
 
 
// key register 
reg  [56*8-1 : 0] even_kk;
reg  [56*8-1 : 0] odd_kk;
reg  [ 8*8-1 : 0] even_ck;
reg  [ 8*8-1 : 0] odd_ck;
reg               even_odd_d;
 
wire [56*8-1 : 0] kk;
wire              ks_busy;
wire              ks_done;
 
key_schedule ks(
                        .clk  (clk)
                      , .rst  (rst)
                      , .start(key_en)
                      , .busy (ks_busy)
                      , .done (ks_done)
                      , .i_ck (ck)
                      , .o_kk (kk)
               );
 
always @(posedge clk)
begin
        if(rst)
        begin
                even_kk <=  448'h0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000;
                odd_kk <=  448'h0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000;
                even_ck <=  64'h0000000000000000;
                odd_ck <=  64'h0000000000000000;
        end
        else
        begin
                if(key_en & ~ks_busy)
                begin
                        even_odd_d <= even_odd;
                        if(even_odd)
                        begin
                                odd_ck <= ck;
                        end
                        else
                        begin
                                even_ck <= ck;
                        end
                end
                else if (ks_done)
                        if(even_odd_d)
                                odd_kk <= kk;
                        else
                                even_kk <= kk;
        end
end
 
// word grouper
reg  [8*8-1:0] group;    // 32bits
reg            sync;     // find sync
reg  [8-1:0]   ts_cnt;   // ts packet count
reg            using_even_odd_key; // 0 --- using even key; 1 --- using odd key
reg            need_dec;
reg            group_valid;
reg            group_valid_d;
reg            head;
reg   [5:0]    group_id;
reg [4*8-1:0] group_d;
 
 
always @(posedge clk)
        if (rst)
        begin
                group  <= 64'h00000000;
                sync   <= 1'h0;
                ts_cnt <= 8'h00;
                using_even_odd_key <= 1'h0;
                need_dec <= 1'h0;
                group_valid_d <=1'h0;
                head <= 1'h0;
        end
        else
        begin
                group_valid <=1'h0;
                group_valid_d <= group_valid;
                head <= 1'h0;
                group_d <= group;
                if(sync)
                begin
                        if(en)
                                ts_cnt <= ts_cnt + 8'h01;
                        if(ts_cnt == 8'hb7 ) // 0xb8=188-4
                        begin
                                sync <= 1'h0;
                                ts_cnt<=8'h0;
                                group_valid<=1'h1;
                                group_id<=ts_cnt[7:3];
                        end
                        if(ts_cnt[2:0]==3'h7 && en )
                        begin
                                group_valid<=1'h1;
                                group_id<=ts_cnt[7:3];
                        end
                end
                if(en)
                begin
                        group  <= {  encrypted, group [8*8-1:1*8] };
                        if(group[5*8-1:4*8]==8'h47)
                        begin
                                sync   <= 1;
                                ts_cnt <= 8'h00;
                                using_even_odd_key <= group[62];
                                head  <= 1'h1;
                                group_d <= {1'h0,group[62:32]};
                        end
                end
        end
 
// decrypt
reg  [8*8-1:0] db;
reg            db_valid;
 
wire [56*8-1:0]kk_decrypt;
wire [ 8*8-1:0]ck_decrypt;
 
assign   kk_decrypt = (using_even_odd_key) ? odd_kk : even_kk ;
assign   ck_decrypt = (using_even_odd_key) ? odd_ck : even_ck ;
 
wire [8*8-1:0] sc_sb;
wire [8*8-1:0] sc_cb;
wire           init;
wire           sc_en;
wire           last;
 
assign sc_sb = group;
assign init  = group_id == 5'h00;
assign last  = group_id == 5'd22;
reg     [2:0] last_cnt;
reg     last_run;
assign sc_en = group_valid;
 
stream_cypher sc(
                    .clk   (clk)
                  , .rst   (rst)
                  , .en    (sc_en)
                  , .init  (init)
                  , .ck    (ck_decrypt)
                  , .sb    (sc_sb)
                  , .cb    (sc_cb)
                  );
 
wire [ 8*8-1:0]   bco;
reg  [ 8*8-1:0]   bc;
reg  [ 8*8-1:0]   ib;
block_decypher bcm(
                          .kk (kk_decrypt)
                        , .ib (ib[8*8-1:0])
                        , .bd (bco)
                        );
 
 
always @(posedge clk)
if(rst)
begin
        db <= 64'h00;
        ib <= 128'h00000000000000000000000000000000;
        bc <= 64'hffffffffffffffff;
        last_cnt<=3'h0;
        last_run<=1'h0;
end
else
begin
        db_valid<=1'h0;
        if(group_valid_d)
        begin
                bc<=bco;
                if(init)
                begin
                        ib<={ ib[8*8-1:0],sc_cb };
                        db<=bco^sc_cb;
                end
                else
                begin
                        ib<={ ib[8*8-1:0],sc_cb^sc_sb };
                        db<=bco^sc_cb^sc_sb;
                end
                if(group_id>1'h0)
                begin
                        db_valid<=1'h1;
                end
 
                if(last)
                        last_run<=1'h1;
 
        end
        if(last_run)
        begin
                last_cnt<=last_cnt+3'h1;
                if(last_cnt==3'h7)
                begin
                        db_valid<=1'h1;
                        db<=bco;
                        last_run<=1'h0;
                end
 
        end
end
 
// degrouper
reg [2:0]     cnt;
reg           invalid;
reg [7:0]     decrypted;
reg [7*8-1:0] dec_group_ouput;
 
always @(posedge clk)
        if(rst)
        begin
                dec_group_ouput <= 32'h00000000;
                cnt <= 2'h0;
        end
        else
        begin
                invalid <= 1'h0;
                if(db_valid)
                begin
                        dec_group_ouput <= db[8*8-1:1*8];
                        decrypted <= db[7:0];
                        cnt <= 3'h7;
                        invalid <= 1'h1;
                end
                if(cnt)
                begin
                        invalid <= 1'h1;
                        dec_group_ouput <= {dec_group_ouput [7:0],dec_group_ouput[7*8-1:1*8]};
                        decrypted <= dec_group_ouput [ 7:0 ];
                        cnt <= cnt - 2'h1;
                end
                if(head)
                begin
                        dec_group_ouput <= group_d[4*8-1:1*8];
                        decrypted <= group_d[7:0];
                        cnt <= 2'h3;
                        invalid <= 1'h1;
                end
        end
 
 
 
endmodule

Line No.	Rev	Author	Line
1	18	simon111
2	40	simon111	`include "../bench/timescale.v"
3	18	simon111	`// this module will do csa decrypt work`
4
5	21	simon111	`module decrypt(clk,rst,ck,key_en,even_odd,en,encrypted,decrypted,invalid);`
6			`input clk;`
7			`input rst;`
8			`input key_en; // signal high valid,`
9			`input even_odd; // indiate the input ck is even or odd, 0 --- even odd ---odd`
10			`input en; // decrypted`
11			`input [8*8-1:0] ck; // input ck`
12			`input [ 8-1:0] encrypted; // input ts stream`
13			`output [ 8-1:0] decrypted; // decrypt ts stream`
14			`output invalid; // thsi output data is invalid`
15	20	simon111
16
17	21	simon111	`// key register`
18			`reg [56*8-1 : 0] even_kk;`
19			`reg [56*8-1 : 0] odd_kk;`
20			`reg [ 8*8-1 : 0] even_ck;`
21			`reg [ 8*8-1 : 0] odd_ck;`
22			`reg even_odd_d;`
23	20	simon111
24	21	simon111	`wire [56*8-1 : 0] kk;`
25			`wire ks_busy;`
26			`wire ks_done;`
27	20	simon111
28	21	simon111	`key_schedule ks(`
29			`.clk (clk)`
30			`, .rst (rst)`
31			`, .start(key_en)`
32			`, .busy (ks_busy)`
33			`, .done (ks_done)`
34			`, .i_ck (ck)`
35			`, .o_kk (kk)`
36			`);`
37	20	simon111
38	21	simon111	`always @(posedge clk)`
39			`begin`
40			`if(rst)`
41			`begin`
42			`even_kk <= 448'h0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000;`
43			`odd_kk <= 448'h0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000;`
44			`even_ck <= 64'h0000000000000000;`
45			`odd_ck <= 64'h0000000000000000;`
46			`end`
47			`else`
48			`begin`
49			`if(key_en & ~ks_busy)`
50			`begin`
51			`even_odd_d <= even_odd;`
52			`if(even_odd)`
53			`begin`
54			`odd_ck <= ck;`
55			`end`
56			`else`
57			`begin`
58			`even_ck <= ck;`
59			`end`
60			`end`
61			`else if (ks_done)`
62			`if(even_odd_d)`
63			`odd_kk <= kk;`
64			`else`
65			`even_kk <= kk;`
66			`end`
67			`end`
68	20	simon111
69	21	simon111	`// word grouper`
70			`reg [8*8-1:0] group; // 32bits`
71			`reg sync; // find sync`
72			`reg [8-1:0] ts_cnt; // ts packet count`
73			`reg using_even_odd_key; // 0 --- using even key; 1 --- using odd key`
74			`reg need_dec;`
75			`reg group_valid;`
76			`reg group_valid_d;`
77			`reg head;`
78			`reg [5:0] group_id;`
79			`reg [4*8-1:0] group_d;`
80	20	simon111
81	21	simon111
82			`always @(posedge clk)`
83			`if (rst)`
84			`begin`
85			`group <= 64'h00000000;`
86			`sync <= 1'h0;`
87			`ts_cnt <= 8'h00;`
88			`using_even_odd_key <= 1'h0;`
89			`need_dec <= 1'h0;`
90			`group_valid_d <=1'h0;`
91			`head <= 1'h0;`
92			`end`
93			`else`
94			`begin`
95			`group_valid <=1'h0;`
96			`group_valid_d <= group_valid;`
97			`head <= 1'h0;`
98			`group_d <= group;`
99			`if(sync)`
100			`begin`
101			`if(en)`
102			`ts_cnt <= ts_cnt + 8'h01;`
103			`if(ts_cnt == 8'hb7 ) // 0xb8=188-4`
104			`begin`
105			`sync <= 1'h0;`
106			`ts_cnt<=8'h0;`
107			`group_valid<=1'h1;`
108			`group_id<=ts_cnt[7:3];`
109			`end`
110			`if(ts_cnt[2:0]==3'h7 && en )`
111			`begin`
112			`group_valid<=1'h1;`
113			`group_id<=ts_cnt[7:3];`
114			`end`
115			`end`
116			`if(en)`
117			`begin`
118			`group <= { encrypted, group [88-1:18] };`
119			`if(group[58-1:48]==8'h47)`
120			`begin`
121			`sync <= 1;`
122			`ts_cnt <= 8'h00;`
123			`using_even_odd_key <= group[62];`
124			`head <= 1'h1;`
125			`group_d <= {1'h0,group[62:32]};`
126			`end`
127			`end`
128			`end`
129
130			`// decrypt`
131			`reg [8*8-1:0] db;`
132			`reg db_valid;`
133
134			`wire [56*8-1:0]kk_decrypt;`
135			`wire [ 8*8-1:0]ck_decrypt;`
136
137			`assign kk_decrypt = (using_even_odd_key) ? odd_kk : even_kk ;`
138			`assign ck_decrypt = (using_even_odd_key) ? odd_ck : even_ck ;`
139
140			`wire [8*8-1:0] sc_sb;`
141			`wire [8*8-1:0] sc_cb;`
142			`wire init;`
143			`wire sc_en;`
144			`wire last;`
145
146			`assign sc_sb = group;`
147			`assign init = group_id == 5'h00;`
148			`assign last = group_id == 5'd22;`
149			`reg [2:0] last_cnt;`
150			`reg last_run;`
151			`assign sc_en = group_valid;`
152
153			`stream_cypher sc(`
154			`.clk (clk)`
155			`, .rst (rst)`
156			`, .en (sc_en)`
157			`, .init (init)`
158			`, .ck (ck_decrypt)`
159			`, .sb (sc_sb)`
160			`, .cb (sc_cb)`
161			`);`
162
163			`wire [ 8*8-1:0] bco;`
164			`reg [ 8*8-1:0] bc;`
165			`reg [ 8*8-1:0] ib;`
166			`block_decypher bcm(`
167			`.kk (kk_decrypt)`
168			`, .ib (ib[8*8-1:0])`
169			`, .bd (bco)`
170			`);`
171
172
173			`always @(posedge clk)`
174			`if(rst)`
175			`begin`
176			`db <= 64'h00;`
177			`ib <= 128'h00000000000000000000000000000000;`
178			`bc <= 64'hffffffffffffffff;`
179			`last_cnt<=3'h0;`
180			`last_run<=1'h0;`
181			`end`
182			`else`
183			`begin`
184			`db_valid<=1'h0;`
185			`if(group_valid_d)`
186			`begin`
187			`bc<=bco;`
188			`if(init)`
189			`begin`
190			`ib<={ ib[8*8-1:0],sc_cb };`
191			`db<=bco^sc_cb;`
192			`end`
193			`else`
194			`begin`
195			`ib<={ ib[8*8-1:0],sc_cb^sc_sb };`
196			`db<=bco^sc_cb^sc_sb;`
197			`end`
198			`if(group_id>1'h0)`
199			`begin`
200			`db_valid<=1'h1;`
201			`end`
202
203			`if(last)`
204			`last_run<=1'h1;`
205
206			`end`
207			`if(last_run)`
208			`begin`
209			`last_cnt<=last_cnt+3'h1;`
210			`if(last_cnt==3'h7)`
211			`begin`
212			`db_valid<=1'h1;`
213			`db<=bco;`
214			`last_run<=1'h0;`
215			`end`
216
217			`end`
218			`end`
219
220			`// degrouper`
221			`reg [2:0] cnt;`
222			`reg invalid;`
223			`reg [7:0] decrypted;`
224			`reg [7*8-1:0] dec_group_ouput;`
225
226			`always @(posedge clk)`
227			`if(rst)`
228			`begin`
229			`dec_group_ouput <= 32'h00000000;`
230			`cnt <= 2'h0;`
231			`end`
232			`else`
233			`begin`
234			`invalid <= 1'h0;`
235			`if(db_valid)`
236			`begin`
237			`dec_group_ouput <= db[88-1:18];`
238			`decrypted <= db[7:0];`
239			`cnt <= 3'h7;`
240			`invalid <= 1'h1;`
241			`end`
242			`if(cnt)`
243			`begin`
244			`invalid <= 1'h1;`
245			`dec_group_ouput <= {dec_group_ouput [7:0],dec_group_ouput[78-1:18]};`
246			`decrypted <= dec_group_ouput [ 7:0 ];`
247			`cnt <= cnt - 2'h1;`
248			`end`
249			`if(head)`
250			`begin`
251			`dec_group_ouput <= group_d[48-1:18];`
252			`decrypted <= group_d[7:0];`
253			`cnt <= 2'h3;`
254			`invalid <= 1'h1;`
255			`end`
256			`end`
257
258
259
260	18	simon111	`endmodule`

Browse

Tools

Subversion Repositories csa

[/] [csa/] [trunk/] [rtl/] [decrypt.v] - Blame information for rev 40