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

Subversion Repositories csa

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

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


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

Browse

Tools

Subversion Repositories csa

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