Subversion Repositories csa

 
`include "../bench/timescale.v"
// this module will do csa decrypt work
 
module decrypt(clk,rst,ck,key_en,even_odd,en,encrypted,decrypted,valid);
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            valid;     // output data is valid
 
wire [ 8*8-1:0] odd_ck;
wire [ 8*8-1:0] even_ck;
wire [56*8-1:0] odd_kk;
wire [56*8-1:0] even_kk;
 
 
// key register 
key_cnt key_cnt(
                  .clk        (clk)
                , .rst        (rst)
                , .en         (key_en)
                , .evenodd    (even_odd)
                , .ck_in      (ck)
                , .busy       ()
                , .odd_ck     (odd_ck)
                , .odd_kk     (odd_kk)
                , .even_ck    (even_ck)
                , .even_kk    (even_kk)
                );
 
wire  ts_valid;
wire  ts_init;
wire  ts_head;
wire  ts_dec;
wire  ts_evenodd;
wire [8*8-1:0]group;
wire [3:0] bytes;
 
 
ts_sync ts_sync(
               . clk      (clk)
             , . rst      (rst)
             , . en       (en) 
             , . datain   (encrypted)
             , . valid    (ts_valid)
             , . head     (ts_head)
             , . dec      (ts_dec)
             , . init     (ts_init)
             , . evenodd  (ts_evenodd)
             , . group    (group)
             , . bytes    (bytes)
        );
 
wire dec_valid;
wire [8*8-1:0]ogroup;
wire [  4-1:0]obytes;
group_decrypt group_decrypt(
                          .clk     (clk)
                        , .rst     (rst)
                        , .en      (ts_valid)
                        , .dec     (ts_dec)
                        , .init    (ts_init)
                        , .ck      (ts_evenodd?even_ck:odd_ck)
                        , .kk      (ts_evenodd?even_kk:odd_kk)
                        , .group   (group)
                        , .bytes   (bytes)
                        , .valid   (dec_valid)
                        , .ogroup  (ogroup)
                        , .obytes  (obytes)
                );
 
//
//// 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
//
 
 
ts_serial_out ts_serial_out(
                          .clk      (clk)
                        , .rst      (rst)
                        , .group    (ogroup)
                        , .bytes    (obytes)
                        , .en       (dec_valid)
                        , .dec      (decrypted)
                        , .valid    (valid)
                        );
 
 
endmodule