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

Subversion Repositories dvb_s2_ldpc_decoder

[/] [dvb_s2_ldpc_decoder/] [trunk/] [rtl/] [ldpc_top.v] - Blame information for rev 2

Details | Compare with Previous | View Log


//-------------------------------------------------------------------------
//
// File name    :  ldp_top.v
// Title        :
//              :
// Purpose      : Top-level of LDPC decoder, structural verilog only
//
// ----------------------------------------------------------------------
// Revision History :
// ----------------------------------------------------------------------
//   Ver  :| Author   :| Mod. Date   :| Changes Made:
//   v1.0  | JTC      :| 2008/07/02  :|
// ----------------------------------------------------------------------
`timescale 1ns/10ps
 
module ldp_top #(
  parameter FOLDFACTOR     = 4,
  parameter LOG2FOLDFACTOR = 2,
  parameter NUMINSTANCES   = 360,
  parameter LLRWIDTH       = 6
)(
  input clk,
  input rst,
 
  // LLR I/O
  input                             llr_access,
  input[7+FOLDFACTOR-1:0]           llr_addr,
  input                             llr_din_we,
  input[NUMINSTANCES*LLRWIDTH-1:0]  llr_din,
  output[NUMINSTANCES*LLRWIDTH-1:0] llr_dout,
 
  // start command, completion indicator
  input      start,
  input[4:0] mode,
  input[5:0] iter_limit,
  output     done
);
 
////////////////
// PARAMETERS //
////////////////
localparam NUMVNS       = 3;
localparam LASTSHIFTDIST = (FOLDFACTOR==1) ? 11 :
                           (FOLDFACTOR==2) ? 5  :
                           (FOLDFACTOR==3) ? 3  :
                           /* 4 */           2;
localparam LASTSHIFTWIDTH  = (FOLDFACTOR==1) ? 4 :
                             (FOLDFACTOR==2) ? 3 :
                             (FOLDFACTOR==3) ? 2 :
                             /* 4 */           2;
 
//////////////////////
// INTERNAL SIGNALS //
//////////////////////
wire   zero;
assign zero = 0;
 
// iocontrol common control outputs
wire iteration;
wire first_iteration;
wire disable_vn;
wire disable_cn;
 
// iocontrol VN controls
wire                   we_vnmsg;
wire[7+FOLDFACTOR-1:0] addr_vn;
 
// iocontrol shuffler controls
wire                     first_half;
wire[1:0]                shift0;
wire[2:0]                shift1;
wire[LASTSHIFTWIDTH-1:0] shift2;
 
// iocontrol CN controls
wire                   cn_we;
wire                   cn_rd;
wire[7+FOLDFACTOR-1:0] addr_cn;
 
// iocontrol ROM
wire[12:0]                   romaddr;
wire[8+5+LASTSHIFTWIDTH-1:0] romdata;
 
////////////////////
// Control module //
////////////////////
ldpc_iocontrol #(
  .FOLDFACTOR(FOLDFACTOR),
  .LASTSHIFTWIDTH(LASTSHIFTWIDTH),
  .NUMINSTANCES(NUMINSTANCES)
)
ldpc_iocontroli(
  .clk              (clk),
  .rst              (rst),
 
  .start            (start),
  .mode             (mode),
  .iter_limit       (iter_limit),
  .done             (done),
 
  .iteration        (iteration),
  .first_iteration  (first_iteration),
  .disable_vn       (disable_vn),
  .disable_cn       (disable_cn),
 
  .we_vnmsg         (we_vnmsg),
  .addr_vn          (addr_vn),
  .addr_vn_lo       (),
 
  .first_half       (first_half),
  .shift0           (shift0),
  .shift1           (shift1),
  .shift2           (shift2),
 
  .cn_we            (cn_we),
  .cn_rd            (cn_rd),
  .addr_cn          (addr_cn),
  .addr_cn_lo       (),
 
  .romaddr          (romaddr),
  .romdata          (romdata)
);
 
// asynchronous ROM, attached to control module
ldpc_edgetable ldpc_edgetable_i(
  .clk     ( clk ),
  .rst     ( rst ),
  .romaddr ( romaddr ),
  .romdata ( romdata )
);
 
////////////////////////
// 2-d/1-d conversion //
////////////////////////
wire[NUMINSTANCES*LLRWIDTH-1:0] cn_concat;
wire[LLRWIDTH-1:0] cn_msg[0:NUMINSTANCES-1];
wire[NUMINSTANCES*LLRWIDTH-1:0] sh_concat;
wire[LLRWIDTH-1:0] sh_msg[0:NUMINSTANCES-1];
 
 
generate
  genvar j;
 
  for( j=0; j<NUMINSTANCES; j=j+1 )
  begin: convert1d2d
    assign cn_concat[LLRWIDTH*j+LLRWIDTH-1 -: LLRWIDTH] = cn_msg[j];
    assign sh_msg[j] = sh_concat[LLRWIDTH*j+LLRWIDTH-1 -: LLRWIDTH];
  end
endgenerate
 
wire[NUMVNS*LLRWIDTH-1:0]       vn_cluster_msg[0:NUMINSTANCES/NUMVNS-1];
wire[NUMINSTANCES*LLRWIDTH-1:0] vn_concat;
wire[NUMVNS*LLRWIDTH-1:0]       sh_cluster_msg[0:NUMINSTANCES/NUMVNS-1];
 
wire[NUMVNS*LLRWIDTH-1:0] llr_din_2d[0:NUMINSTANCES/NUMVNS-1];
wire[NUMVNS*LLRWIDTH-1:0] llr_dout_2d[0:NUMINSTANCES/NUMVNS-1];
 
generate
  genvar m;
 
  for( m=0; m<NUMINSTANCES/NUMVNS; m=m+1 )
  begin: convert1d2d2
    assign vn_concat[NUMVNS*LLRWIDTH*m+NUMVNS*LLRWIDTH-1 -: NUMVNS*LLRWIDTH] = vn_cluster_msg[m];
    assign sh_cluster_msg[m] = sh_concat[NUMVNS*LLRWIDTH*m+NUMVNS*LLRWIDTH-1 -: NUMVNS*LLRWIDTH];
 
    assign llr_din_2d[m] = llr_din[NUMVNS*LLRWIDTH*m+NUMVNS*LLRWIDTH-1 -: NUMVNS*LLRWIDTH];
    assign llr_dout[NUMVNS*LLRWIDTH*m+NUMVNS*LLRWIDTH-1 -: NUMVNS*LLRWIDTH] = llr_dout_2d[m];
  end
endgenerate
 
//////////
// VN's //
//////////
generate
  genvar i;
 
  for( i=0; i<NUMINSTANCES/NUMVNS; i=i+1 )
  begin: varnodes
    // first
    if( i==0 )
    begin
      ldpc_vncluster #(
        .NUMVNS         (NUMVNS),
        .ENABLE_DISABLE (0),
        .FOLDFACTOR     (FOLDFACTOR),
        .LASTSHIFTWIDTH (LASTSHIFTWIDTH),
        .LLRWIDTH       (LLRWIDTH)
      ) ldpc_vncluster_firsti(
        .clk              (clk),
        .rst              (rst),
        .llr_access       (llr_access),
        .llr_addr         (llr_addr),
        .llr_din_we       (llr_din_we),
        .llr_din          (llr_din_2d[i]),
        .llr_dout         (llr_dout_2d[i]),
        .iteration        (iteration),
        .first_half       (first_half),
        .first_iteration  (first_iteration),
        .we_vnmsg         (we_vnmsg),
        .disable_vn       (zero),
        .addr_vn          (addr_vn),
        .sh_cluster_msg     (sh_cluster_msg[i]),
        .vn_cluster_msg     (vn_cluster_msg[i])
      );
    end
 
    // last
    if( i==NUMINSTANCES/NUMVNS-1 )
    begin
      ldpc_vncluster #(
        .NUMVNS         (NUMVNS),
        .ENABLE_DISABLE (1),
        .FOLDFACTOR     (FOLDFACTOR),
        .LASTSHIFTWIDTH (LASTSHIFTWIDTH),
        .LLRWIDTH       (LLRWIDTH)
      ) ldpc_vncluster_lasti(
        .clk              (clk),
        .rst              (rst),
        .llr_access       (llr_access),
        .llr_addr         (llr_addr),
        .llr_din_we       (llr_din_we),
        .llr_din          (llr_din_2d[i]),
        .llr_dout         (llr_dout_2d[i]),
        .iteration        (iteration),
        .first_half       (first_half),
        .first_iteration  (first_iteration),
        .we_vnmsg         (we_vnmsg),
        .disable_vn       (disable_vn),
        .addr_vn          (addr_vn),
        .sh_cluster_msg   (sh_cluster_msg[i]),
        .vn_cluster_msg   (vn_cluster_msg[i])
      );
    end
 
    if( (i!=0) && (i!=NUMINSTANCES/NUMVNS-1) )
    begin
      ldpc_vncluster #(
        .NUMVNS         (NUMVNS),
        .ENABLE_DISABLE (0),
        .FOLDFACTOR     (FOLDFACTOR),
        .LASTSHIFTWIDTH (LASTSHIFTWIDTH),
        .LLRWIDTH       (LLRWIDTH)
      ) ldpc_vnclusteri(
        .clk              (clk),
        .rst              (rst),
        .llr_access       (llr_access),
        .llr_addr         (llr_addr),
        .llr_din_we       (llr_din_we),
        .llr_din          (llr_din_2d[i]),
        .llr_dout         (llr_dout_2d[i]),
        .iteration        (iteration),
        .first_half       (first_half),
        .first_iteration  (first_iteration),
        .we_vnmsg         (we_vnmsg),
        .disable_vn       (zero),
        .addr_vn          (addr_vn),
        .sh_cluster_msg   (sh_cluster_msg[i]),
        .vn_cluster_msg   (vn_cluster_msg[i])
      );
    end
  end
endgenerate
 
//////////////
// SHUFFLER //
//////////////
ldpc_shuffle #( .FOLDFACTOR(FOLDFACTOR),
                .NUMINSTANCES(NUMINSTANCES),
                .LLRWIDTH(LLRWIDTH),
                .LASTSHIFTWIDTH(LASTSHIFTWIDTH),
                .LASTSHIFTDIST(LASTSHIFTDIST)
 ) ldpc_shufflei(
  .clk          (clk),
  .rst          (rst),
  .first_half   (first_half),
  .shift0       (shift0),
  .shift1       (shift1),
  .shift2       (shift2),
  .vn_concat    (vn_concat),
  .cn_concat    (cn_concat),
  .sh_concat    (sh_concat)
);
 
//////////
// CN's //
//////////
wire                         dnmsg_we;
wire                         dnmsg_we_gated;
wire[7+FOLDFACTOR-1:0]       dnmsg_wraddr[0:NUMINSTANCES-1];
wire[7+FOLDFACTOR-1:0]       dnmsg_rdaddr[0:NUMINSTANCES-1];
wire[17+4*(LLRWIDTH-1)+31:0] dnmsg_din[0:NUMINSTANCES-1];
wire[17+4*(LLRWIDTH-1)+31:0] dnmsg_dout[0:NUMINSTANCES-1];
 
// first
ldpc_cn #( .FOLDFACTOR(FOLDFACTOR),
           .LLRWIDTH(LLRWIDTH)
) ldpc_cn0i(
  .clk              (clk),
  .rst              (rst),
  .llr_access       (llr_access),
  .llr_addr         (llr_addr),
  .llr_din_we       (llr_din_we),
  .iteration        (iteration),
  .first_half       (first_half),
  .first_iteration  (first_iteration),
  .cn_we            (cn_we),
  .cn_rd            (cn_rd),
  .disable_cn       (disable_cn),
  .addr_cn          (addr_cn),
  .sh_msg           (sh_msg[0]),
  .cn_msg           (cn_msg[0]),
  .dnmsg_we         (dnmsg_we_gated),
  .dnmsg_wraddr     (dnmsg_wraddr[0]),
  .dnmsg_rdaddr     (dnmsg_rdaddr[0]),
  .dnmsg_din        (dnmsg_din[0]),
  .dnmsg_dout       (dnmsg_dout[0])
);
 
ldpc_ram_behav #(
  .WIDTH    (17+4*(LLRWIDTH-1)+32),
  .LOG2DEPTH(7+FOLDFACTOR)
) ldpc_cnholder_0i (
  .clk(clk),
  .we(dnmsg_we_gated),
  .din(dnmsg_din[0]),
  .wraddr(dnmsg_wraddr[0]),
  .rdaddr(dnmsg_rdaddr[0]),
  .dout(dnmsg_dout[0])
);
 
// second - same as entire array, but is the source of the signal "we"
  ldpc_cn #( .FOLDFACTOR(FOLDFACTOR),
             .LLRWIDTH(LLRWIDTH)
  ) ldpc_cn1i(
    .clk              (clk),
    .rst              (rst),
    .llr_access       (llr_access),
    .llr_addr         (llr_addr),
    .llr_din_we       (llr_din_we),
    .iteration        (iteration),
    .first_half       (first_half),
    .first_iteration  (first_iteration),
    .cn_we            (cn_we),
    .cn_rd            (cn_rd),
    .disable_cn       (zero),
    .addr_cn          (addr_cn),
    .sh_msg           (sh_msg[1]),
    .cn_msg           (cn_msg[1]),
    .dnmsg_we         (dnmsg_we),
    .dnmsg_wraddr     (dnmsg_wraddr[1]),
    .dnmsg_rdaddr     (dnmsg_rdaddr[1]),
    .dnmsg_din        (dnmsg_din[1]),
    .dnmsg_dout       (dnmsg_dout[1])
);
 
  ldpc_ram_behav #(
    .WIDTH    (17+4*(LLRWIDTH-1)+32),
    .LOG2DEPTH(7+FOLDFACTOR)
  ) ldpc_cnholder_1i (
    .clk(clk),
    .we(dnmsg_we),
    .din(dnmsg_din[1]),
    .wraddr(dnmsg_wraddr[1]),
    .rdaddr(dnmsg_rdaddr[1]),
    .dout(dnmsg_dout[1])
  );
 
generate
  genvar k;
 
  for( k=2; k<NUMINSTANCES; k=k+1 )
  begin: checknodes
    ldpc_cn #( .FOLDFACTOR(FOLDFACTOR),
               .LLRWIDTH(LLRWIDTH)
    ) ldpc_cni(
      .clk              (clk),
      .rst              (rst),
      .llr_access       (llr_access),
      .llr_addr         (llr_addr),
      .llr_din_we       (llr_din_we),
      .iteration        (iteration),
      .first_half       (first_half),
      .first_iteration  (first_iteration),
      .cn_we            (cn_we),
      .cn_rd            (cn_rd),
      .disable_cn       (zero),
      .addr_cn          (addr_cn),
      .sh_msg           (sh_msg[k]),
      .cn_msg           (cn_msg[k]),
      .dnmsg_we         (),
      .dnmsg_wraddr     (dnmsg_wraddr[k]),
      .dnmsg_rdaddr     (dnmsg_rdaddr[k]),
      .dnmsg_din        (dnmsg_din[k]),
      .dnmsg_dout       (dnmsg_dout[k])
  );
 
    ldpc_ram_behav #(
      .WIDTH    (17+4*(LLRWIDTH-1)+32),
      .LOG2DEPTH(7+FOLDFACTOR)
    ) ldpc_cnholder_i (
      .clk(clk),
      .we(dnmsg_we),
      .din(dnmsg_din[k]),
      .wraddr(dnmsg_wraddr[k]),
      .rdaddr(dnmsg_rdaddr[k]),
      .dout(dnmsg_dout[k])
    );
  end
endgenerate
 
endmodule

Browse

Tools

Subversion Repositories dvb_s2_ldpc_decoder

[/] [dvb_s2_ldpc_decoder/] [trunk/] [rtl/] [ldpc_top.v] - Blame information for rev 2

Line No.	Rev	Author	Line
1	2	jcorley	`//-------------------------------------------------------------------------`
2			`//`
3			`// File name : ldp_top.v`
4			`// Title :`
5			`// :`
6			`// Purpose : Top-level of LDPC decoder, structural verilog only`
7			`//`
8			`// ----------------------------------------------------------------------`
9			`// Revision History :`
10			`// ----------------------------------------------------------------------`
11			`// Ver :\| Author :\| Mod. Date :\| Changes Made:`
12			`// v1.0 \| JTC :\| 2008/07/02 :\|`
13			`// ----------------------------------------------------------------------`
14			`timescale 1ns/10ps
15
16			`module ldp_top #(`
17			`parameter FOLDFACTOR = 4,`
18			`parameter LOG2FOLDFACTOR = 2,`
19			`parameter NUMINSTANCES = 360,`
20			`parameter LLRWIDTH = 6`
21			`)(`
22			`input clk,`
23			`input rst,`
24
25			`// LLR I/O`
26			`input llr_access,`
27			`input[7+FOLDFACTOR-1:0] llr_addr,`
28			`input llr_din_we,`
29			`input[NUMINSTANCES*LLRWIDTH-1:0] llr_din,`
30			`output[NUMINSTANCES*LLRWIDTH-1:0] llr_dout,`
31
32			`// start command, completion indicator`
33			`input start,`
34			`input[4:0] mode,`
35			`input[5:0] iter_limit,`
36			`output done`
37			`);`
38
39			`////////////////`
40			`// PARAMETERS //`
41			`////////////////`
42			`localparam NUMVNS = 3;`
43			`localparam LASTSHIFTDIST = (FOLDFACTOR==1) ? 11 :`
44			`(FOLDFACTOR==2) ? 5 :`
45			`(FOLDFACTOR==3) ? 3 :`
46			`/* 4 */ 2;`
47			`localparam LASTSHIFTWIDTH = (FOLDFACTOR==1) ? 4 :`
48			`(FOLDFACTOR==2) ? 3 :`
49			`(FOLDFACTOR==3) ? 2 :`
50			`/* 4 */ 2;`
51
52			`//////////////////////`
53			`// INTERNAL SIGNALS //`
54			`//////////////////////`
55			`wire zero;`
56			`assign zero = 0;`
57
58			`// iocontrol common control outputs`
59			`wire iteration;`
60			`wire first_iteration;`
61			`wire disable_vn;`
62			`wire disable_cn;`
63
64			`// iocontrol VN controls`
65			`wire we_vnmsg;`
66			`wire[7+FOLDFACTOR-1:0] addr_vn;`
67
68			`// iocontrol shuffler controls`
69			`wire first_half;`
70			`wire[1:0] shift0;`
71			`wire[2:0] shift1;`
72			`wire[LASTSHIFTWIDTH-1:0] shift2;`
73
74			`// iocontrol CN controls`
75			`wire cn_we;`
76			`wire cn_rd;`
77			`wire[7+FOLDFACTOR-1:0] addr_cn;`
78
79			`// iocontrol ROM`
80			`wire[12:0] romaddr;`
81			`wire[8+5+LASTSHIFTWIDTH-1:0] romdata;`
82
83			`////////////////////`
84			`// Control module //`
85			`////////////////////`
86			`ldpc_iocontrol #(`
87			`.FOLDFACTOR(FOLDFACTOR),`
88			`.LASTSHIFTWIDTH(LASTSHIFTWIDTH),`
89			`.NUMINSTANCES(NUMINSTANCES)`
90			`)`
91			`ldpc_iocontroli(`
92			`.clk (clk),`
93			`.rst (rst),`
94
95			`.start (start),`
96			`.mode (mode),`
97			`.iter_limit (iter_limit),`
98			`.done (done),`
99
100			`.iteration (iteration),`
101			`.first_iteration (first_iteration),`
102			`.disable_vn (disable_vn),`
103			`.disable_cn (disable_cn),`
104
105			`.we_vnmsg (we_vnmsg),`
106			`.addr_vn (addr_vn),`
107			`.addr_vn_lo (),`
108
109			`.first_half (first_half),`
110			`.shift0 (shift0),`
111			`.shift1 (shift1),`
112			`.shift2 (shift2),`
113
114			`.cn_we (cn_we),`
115			`.cn_rd (cn_rd),`
116			`.addr_cn (addr_cn),`
117			`.addr_cn_lo (),`
118
119			`.romaddr (romaddr),`
120			`.romdata (romdata)`
121			`);`
122
123			`// asynchronous ROM, attached to control module`
124			`ldpc_edgetable ldpc_edgetable_i(`
125			`.clk ( clk ),`
126			`.rst ( rst ),`
127			`.romaddr ( romaddr ),`
128			`.romdata ( romdata )`
129			`);`
130
131			`////////////////////////`
132			`// 2-d/1-d conversion //`
133			`////////////////////////`
134			`wire[NUMINSTANCES*LLRWIDTH-1:0] cn_concat;`
135			`wire[LLRWIDTH-1:0] cn_msg[0:NUMINSTANCES-1];`
136			`wire[NUMINSTANCES*LLRWIDTH-1:0] sh_concat;`
137			`wire[LLRWIDTH-1:0] sh_msg[0:NUMINSTANCES-1];`
138
139
140			`generate`
141			`genvar j;`
142
143			`for( j=0; j<NUMINSTANCES; j=j+1 )`
144			`begin: convert1d2d`
145			`assign cn_concat[LLRWIDTH*j+LLRWIDTH-1 -: LLRWIDTH] = cn_msg[j];`
146			`assign sh_msg[j] = sh_concat[LLRWIDTH*j+LLRWIDTH-1 -: LLRWIDTH];`
147			`end`
148			`endgenerate`
149
150			`wire[NUMVNS*LLRWIDTH-1:0] vn_cluster_msg[0:NUMINSTANCES/NUMVNS-1];`
151			`wire[NUMINSTANCES*LLRWIDTH-1:0] vn_concat;`
152			`wire[NUMVNS*LLRWIDTH-1:0] sh_cluster_msg[0:NUMINSTANCES/NUMVNS-1];`
153
154			`wire[NUMVNS*LLRWIDTH-1:0] llr_din_2d[0:NUMINSTANCES/NUMVNS-1];`
155			`wire[NUMVNS*LLRWIDTH-1:0] llr_dout_2d[0:NUMINSTANCES/NUMVNS-1];`
156
157			`generate`
158			`genvar m;`
159
160			`for( m=0; m<NUMINSTANCES/NUMVNS; m=m+1 )`
161			`begin: convert1d2d2`
162			`assign vn_concat[NUMVNSLLRWIDTHm+NUMVNSLLRWIDTH-1 -: NUMVNSLLRWIDTH] = vn_cluster_msg[m];`
163			`assign sh_cluster_msg[m] = sh_concat[NUMVNSLLRWIDTHm+NUMVNSLLRWIDTH-1 -: NUMVNSLLRWIDTH];`
164
165			`assign llr_din_2d[m] = llr_din[NUMVNSLLRWIDTHm+NUMVNSLLRWIDTH-1 -: NUMVNSLLRWIDTH];`
166			`assign llr_dout[NUMVNSLLRWIDTHm+NUMVNSLLRWIDTH-1 -: NUMVNSLLRWIDTH] = llr_dout_2d[m];`
167			`end`
168			`endgenerate`
169
170			`//////////`
171			`// VN's //`
172			`//////////`
173			`generate`
174			`genvar i;`
175
176			`for( i=0; i<NUMINSTANCES/NUMVNS; i=i+1 )`
177			`begin: varnodes`
178			`// first`
179			`if( i==0 )`
180			`begin`
181			`ldpc_vncluster #(`
182			`.NUMVNS (NUMVNS),`
183			`.ENABLE_DISABLE (0),`
184			`.FOLDFACTOR (FOLDFACTOR),`
185			`.LASTSHIFTWIDTH (LASTSHIFTWIDTH),`
186			`.LLRWIDTH (LLRWIDTH)`
187			`) ldpc_vncluster_firsti(`
188			`.clk (clk),`
189			`.rst (rst),`
190			`.llr_access (llr_access),`
191			`.llr_addr (llr_addr),`
192			`.llr_din_we (llr_din_we),`
193			`.llr_din (llr_din_2d[i]),`
194			`.llr_dout (llr_dout_2d[i]),`
195			`.iteration (iteration),`
196			`.first_half (first_half),`
197			`.first_iteration (first_iteration),`
198			`.we_vnmsg (we_vnmsg),`
199			`.disable_vn (zero),`
200			`.addr_vn (addr_vn),`
201			`.sh_cluster_msg (sh_cluster_msg[i]),`
202			`.vn_cluster_msg (vn_cluster_msg[i])`
203			`);`
204			`end`
205
206			`// last`
207			`if( i==NUMINSTANCES/NUMVNS-1 )`
208			`begin`
209			`ldpc_vncluster #(`
210			`.NUMVNS (NUMVNS),`
211			`.ENABLE_DISABLE (1),`
212			`.FOLDFACTOR (FOLDFACTOR),`
213			`.LASTSHIFTWIDTH (LASTSHIFTWIDTH),`
214			`.LLRWIDTH (LLRWIDTH)`
215			`) ldpc_vncluster_lasti(`
216			`.clk (clk),`
217			`.rst (rst),`
218			`.llr_access (llr_access),`
219			`.llr_addr (llr_addr),`
220			`.llr_din_we (llr_din_we),`
221			`.llr_din (llr_din_2d[i]),`
222			`.llr_dout (llr_dout_2d[i]),`
223			`.iteration (iteration),`
224			`.first_half (first_half),`
225			`.first_iteration (first_iteration),`
226			`.we_vnmsg (we_vnmsg),`
227			`.disable_vn (disable_vn),`
228			`.addr_vn (addr_vn),`
229			`.sh_cluster_msg (sh_cluster_msg[i]),`
230			`.vn_cluster_msg (vn_cluster_msg[i])`
231			`);`
232			`end`
233
234			`if( (i!=0) && (i!=NUMINSTANCES/NUMVNS-1) )`
235			`begin`
236			`ldpc_vncluster #(`
237			`.NUMVNS (NUMVNS),`
238			`.ENABLE_DISABLE (0),`
239			`.FOLDFACTOR (FOLDFACTOR),`
240			`.LASTSHIFTWIDTH (LASTSHIFTWIDTH),`
241			`.LLRWIDTH (LLRWIDTH)`
242			`) ldpc_vnclusteri(`
243			`.clk (clk),`
244			`.rst (rst),`
245			`.llr_access (llr_access),`
246			`.llr_addr (llr_addr),`
247			`.llr_din_we (llr_din_we),`
248			`.llr_din (llr_din_2d[i]),`
249			`.llr_dout (llr_dout_2d[i]),`
250			`.iteration (iteration),`
251			`.first_half (first_half),`
252			`.first_iteration (first_iteration),`
253			`.we_vnmsg (we_vnmsg),`
254			`.disable_vn (zero),`
255			`.addr_vn (addr_vn),`
256			`.sh_cluster_msg (sh_cluster_msg[i]),`
257			`.vn_cluster_msg (vn_cluster_msg[i])`
258			`);`
259			`end`
260			`end`
261			`endgenerate`
262
263			`//////////////`
264			`// SHUFFLER //`
265			`//////////////`
266			`ldpc_shuffle #( .FOLDFACTOR(FOLDFACTOR),`
267			`.NUMINSTANCES(NUMINSTANCES),`
268			`.LLRWIDTH(LLRWIDTH),`
269			`.LASTSHIFTWIDTH(LASTSHIFTWIDTH),`
270			`.LASTSHIFTDIST(LASTSHIFTDIST)`
271			`) ldpc_shufflei(`
272			`.clk (clk),`
273			`.rst (rst),`
274			`.first_half (first_half),`
275			`.shift0 (shift0),`
276			`.shift1 (shift1),`
277			`.shift2 (shift2),`
278			`.vn_concat (vn_concat),`
279			`.cn_concat (cn_concat),`
280			`.sh_concat (sh_concat)`
281			`);`
282
283			`//////////`
284			`// CN's //`
285			`//////////`
286			`wire dnmsg_we;`
287			`wire dnmsg_we_gated;`
288			`wire[7+FOLDFACTOR-1:0] dnmsg_wraddr[0:NUMINSTANCES-1];`
289			`wire[7+FOLDFACTOR-1:0] dnmsg_rdaddr[0:NUMINSTANCES-1];`
290			`wire[17+4*(LLRWIDTH-1)+31:0] dnmsg_din[0:NUMINSTANCES-1];`
291			`wire[17+4*(LLRWIDTH-1)+31:0] dnmsg_dout[0:NUMINSTANCES-1];`
292
293			`// first`
294			`ldpc_cn #( .FOLDFACTOR(FOLDFACTOR),`
295			`.LLRWIDTH(LLRWIDTH)`
296			`) ldpc_cn0i(`
297			`.clk (clk),`
298			`.rst (rst),`
299			`.llr_access (llr_access),`
300			`.llr_addr (llr_addr),`
301			`.llr_din_we (llr_din_we),`
302			`.iteration (iteration),`
303			`.first_half (first_half),`
304			`.first_iteration (first_iteration),`
305			`.cn_we (cn_we),`
306			`.cn_rd (cn_rd),`
307			`.disable_cn (disable_cn),`
308			`.addr_cn (addr_cn),`
309			`.sh_msg (sh_msg[0]),`
310			`.cn_msg (cn_msg[0]),`
311			`.dnmsg_we (dnmsg_we_gated),`
312			`.dnmsg_wraddr (dnmsg_wraddr[0]),`
313			`.dnmsg_rdaddr (dnmsg_rdaddr[0]),`
314			`.dnmsg_din (dnmsg_din[0]),`
315			`.dnmsg_dout (dnmsg_dout[0])`
316			`);`
317
318			`ldpc_ram_behav #(`
319			`.WIDTH (17+4*(LLRWIDTH-1)+32),`
320			`.LOG2DEPTH(7+FOLDFACTOR)`
321			`) ldpc_cnholder_0i (`
322			`.clk(clk),`
323			`.we(dnmsg_we_gated),`
324			`.din(dnmsg_din[0]),`
325			`.wraddr(dnmsg_wraddr[0]),`
326			`.rdaddr(dnmsg_rdaddr[0]),`
327			`.dout(dnmsg_dout[0])`
328			`);`
329
330			`// second - same as entire array, but is the source of the signal "we"`
331			`ldpc_cn #( .FOLDFACTOR(FOLDFACTOR),`
332			`.LLRWIDTH(LLRWIDTH)`
333			`) ldpc_cn1i(`
334			`.clk (clk),`
335			`.rst (rst),`
336			`.llr_access (llr_access),`
337			`.llr_addr (llr_addr),`
338			`.llr_din_we (llr_din_we),`
339			`.iteration (iteration),`
340			`.first_half (first_half),`
341			`.first_iteration (first_iteration),`
342			`.cn_we (cn_we),`
343			`.cn_rd (cn_rd),`
344			`.disable_cn (zero),`
345			`.addr_cn (addr_cn),`
346			`.sh_msg (sh_msg[1]),`
347			`.cn_msg (cn_msg[1]),`
348			`.dnmsg_we (dnmsg_we),`
349			`.dnmsg_wraddr (dnmsg_wraddr[1]),`
350			`.dnmsg_rdaddr (dnmsg_rdaddr[1]),`
351			`.dnmsg_din (dnmsg_din[1]),`
352			`.dnmsg_dout (dnmsg_dout[1])`
353			`);`
354
355			`ldpc_ram_behav #(`
356			`.WIDTH (17+4*(LLRWIDTH-1)+32),`
357			`.LOG2DEPTH(7+FOLDFACTOR)`
358			`) ldpc_cnholder_1i (`
359			`.clk(clk),`
360			`.we(dnmsg_we),`
361			`.din(dnmsg_din[1]),`
362			`.wraddr(dnmsg_wraddr[1]),`
363			`.rdaddr(dnmsg_rdaddr[1]),`
364			`.dout(dnmsg_dout[1])`
365			`);`
366
367			`generate`
368			`genvar k;`
369
370			`for( k=2; k<NUMINSTANCES; k=k+1 )`
371			`begin: checknodes`
372			`ldpc_cn #( .FOLDFACTOR(FOLDFACTOR),`
373			`.LLRWIDTH(LLRWIDTH)`
374			`) ldpc_cni(`
375			`.clk (clk),`
376			`.rst (rst),`
377			`.llr_access (llr_access),`
378			`.llr_addr (llr_addr),`
379			`.llr_din_we (llr_din_we),`
380			`.iteration (iteration),`
381			`.first_half (first_half),`
382			`.first_iteration (first_iteration),`
383			`.cn_we (cn_we),`
384			`.cn_rd (cn_rd),`
385			`.disable_cn (zero),`
386			`.addr_cn (addr_cn),`
387			`.sh_msg (sh_msg[k]),`
388			`.cn_msg (cn_msg[k]),`
389			`.dnmsg_we (),`
390			`.dnmsg_wraddr (dnmsg_wraddr[k]),`
391			`.dnmsg_rdaddr (dnmsg_rdaddr[k]),`
392			`.dnmsg_din (dnmsg_din[k]),`
393			`.dnmsg_dout (dnmsg_dout[k])`
394			`);`
395
396			`ldpc_ram_behav #(`
397			`.WIDTH (17+4*(LLRWIDTH-1)+32),`
398			`.LOG2DEPTH(7+FOLDFACTOR)`
399			`) ldpc_cnholder_i (`
400			`.clk(clk),`
401			`.we(dnmsg_we),`
402			`.din(dnmsg_din[k]),`
403			`.wraddr(dnmsg_wraddr[k]),`
404			`.rdaddr(dnmsg_rdaddr[k]),`
405			`.dout(dnmsg_dout[k])`
406			`);`
407			`end`
408			`endgenerate`
409
410			`endmodule`