reed_sol.cpp

本電子檔為 verilog cookbook,包含了通訊,影像,DSP等重要常用之verilog編碼,可作為工程師與初學者的參考手冊

	
	fprintf (stdout,"wire [%d:0] elp_in_hi, elp_in_lo, correction_in_hi, correction_in_lo;\n",symbol_size*t-1);
	fprintf (stdout,"wire [%d:0] step_syndrome_hi, step_syndrome_lo;\n",symbol_size*t-1);
	fprintf (stdout,"assign {step_syndrome_hi,step_syndrome_lo} = step_syndrome;\n");
	fprintf (stdout,"assign {elp_in_hi,elp_in_lo} = elp_in;\n");
	fprintf (stdout,"assign {correction_in_hi,correction_in_lo} = correction_in;\n\n");

	fprintf (stdout,"assign mult_in_a = (wait_state[0] | wait_state[4]) ? elp_in_hi :\n");
	fprintf (stdout,"                   (wait_state[1] | wait_state[5]) ? elp_in_lo :\n");
	fprintf (stdout,"                   (wait_state[2]) ? correction_in_hi :\n");
	fprintf (stdout,"                   correction_in_lo;\n");
	fprintf (stdout,"assign mult_in_b = (wait_state[0]) ? step_syndrome_hi :\n");
	fprintf (stdout,"                   (wait_state[1]) ? step_syndrome_lo :\n");
	fprintf (stdout,"                   disc_inv_repeat;\n\n");

	for (i=0; i<t; i=i+1)
	{
		fprintf (stdout,"gf_mult m%d (.a(mult_in_a[%d:%d]),.b(mult_in_b[%d:%d]),.o(mult_o[%d:%d]));\n",
			mult_num,
			(i+1)*symbol_size-1,i*symbol_size,
			(i+1)*symbol_size-1,i*symbol_size,
			(i+1)*symbol_size-1,i*symbol_size
		);
		mult_num++;
	}
	fprintf (stdout,"\n");

	fprintf (stdout,"// XOR the mult output words together for the discrepancy\n");
	fprintf (stdout,"assign discrepancy = \n");
	for (i=0; i<t; i=i+1)
	{
		fprintf (stdout,"    mult_o [%d:%d]",
			(i+1)*symbol_size-1,i*symbol_size);
		if (i != t-1) 
		{
			fprintf (stdout," ^");
		}			
		fprintf (stdout,"\n");
	}
	fprintf (stdout,";\n\n");

	fprintf (stdout,"reg [%d:0] discrepancy_reg;\n",symbol_size-1);
	fprintf (stdout,"always @(posedge clk or posedge rst) begin\n");
	fprintf (stdout,"  if (rst) discrepancy_reg <= 0;\n");
	fprintf (stdout,"  else begin\n");
	fprintf (stdout,"    if (wait_state[0]) discrepancy_reg <= discrepancy;\n");
	fprintf (stdout,"    else if (wait_state[1]) discrepancy_reg <= discrepancy ^ discrepancy_reg;\n");
	fprintf (stdout,"  end\n");
	fprintf (stdout,"end\n\n");
	
	fprintf (stdout,"\n// XOR the mult output words with ELP in for ELP out\n");
	fprintf (stdout,"reg [%d:0] disc_cor_reg;\n",2*t*symbol_size-1);
	fprintf (stdout,"always @(posedge clk or posedge rst) begin\n");
	fprintf (stdout,"  if (rst) disc_cor_reg <= 0;\n");
	fprintf (stdout,"  else begin\n");
	fprintf (stdout,"     if (wait_state[2]) disc_cor_reg[%d:%d] <= mult_o;\n",
							2*t*symbol_size-1,
							t*symbol_size);
	fprintf (stdout,"     else if (wait_state[3]) disc_cor_reg[%d:0] <= mult_o;\n",
							t*symbol_size);
	fprintf (stdout,"  end\n");
	fprintf (stdout,"end\n\n");
	fprintf (stdout,"assign elp_out = elp_in ^ disc_cor_reg;\n\n");

	fprintf (stdout,"// Capture the mult out directly for ELP divided by discrepancy\n");
	fprintf (stdout,"reg [%d:0] elp_div_disc_reg;\n",symbol_size*2*t-1);
	fprintf (stdout,"always @(posedge clk or posedge rst) begin\n");
	fprintf (stdout,"  if (rst) elp_div_disc_reg <= 0;\n");
	fprintf (stdout,"  else begin\n");
	fprintf (stdout,"     if (wait_state[4]) elp_div_disc_reg[%d:%d] <= mult_o;\n",
							2*t*symbol_size-1,
							t*symbol_size);
	fprintf (stdout,"     else if (wait_state[5]) elp_div_disc_reg[%d:0] <= mult_o;\n",
							t*symbol_size);
	fprintf (stdout,"  end\n");
	fprintf (stdout,"end\n\n");
	
	fprintf (stdout,"// build the mult inverse of the discrepancy\n");
	fprintf (stdout,"wire [%d:0] inv_discrepancy_wire;\n",symbol_size-1);
	fprintf (stdout,"reg [%d:0] inv_discrepancy;\n",symbol_size-1);
	fprintf (stdout,"gf_inverse id (.i(discrepancy_reg),.o(inv_discrepancy_wire));\n\n");
	
	fprintf (stdout,"always @(posedge clk or posedge rst) begin\n");
	fprintf (stdout,"  if (rst) inv_discrepancy <= %d'b0;\n",symbol_size);
	fprintf (stdout,"  else inv_discrepancy <= inv_discrepancy_wire;\n");
	fprintf (stdout,"end\n\n");
	
	fprintf (stdout,"// offer the discrepancy or inverse to the multiplier\n");
	fprintf (stdout,"assign disc_inv_mux = ((wait_state[4] || wait_state[5]) ? inv_discrepancy : discrepancy_reg);\n");
		
	fprintf (stdout,"// update the order and correction poly\n");
	fprintf (stdout,"always @(*) begin\n");
	fprintf (stdout,"  if ((|discrepancy_reg) && ((order_in << 1) < step)) begin\n");
	fprintf (stdout,"    order_out = step - order_in;\n");
	fprintf (stdout,"    correction_out = {elp_div_disc_reg[%d:%d],%d'b0};\n",
			symbol_size*2*t-1-symbol_size,
			0,
			symbol_size);
	fprintf (stdout,"  end\n");
	fprintf (stdout,"  else begin\n");
	fprintf (stdout,"    order_out = order_in;\n");
	fprintf (stdout,"    correction_out = {correction_in[%d:%d],%d'b0} ;\n",
			symbol_size*2*t-1-symbol_size,
			0,
			symbol_size);
	fprintf (stdout,"  end\n");
	fprintf (stdout,"end\n\n");
	
	fprintf (stdout,"endmodule\n");
}

///////////////////////////////////////////

void build_error_loc_poly_roots (
	int symbol_size,
	int data_symbols,
	int mod_poly
)
{
	int n = (1 << symbol_size) - 1;
	int k = data_symbols;
	int t = (n - k) / 2;
	int powers = 0;

	int i = 0;

	fprintf (stdout,"\n///////////////////////////////////////////\n");
	fprintf (stdout,"// Error location poly root finder\n");
	fprintf (stdout,"///////////////////////////////////////////\n\n");
	
	fprintf (stdout,"// Fixable problems will have the degree of the ELP\n");
	fprintf (stdout,"// less than or equal to t (%d)\n",t);
	fprintf (stdout,"// This is using the Chien search method\n");
	fprintf (stdout,"module error_loc_poly_roots (elp_in,elp_out,match);\n");
	fprintf (stdout,"input [%d:0] elp_in;\n",symbol_size*(t+1)-1);
	fprintf (stdout,"output [%d:0] elp_out;\n",symbol_size*(t+1)-1);
	fprintf (stdout,"output match;\n\n");

	fprintf (stdout,"wire [%d:0] q;\n",symbol_size-1);
	
	powers = 1;
	for (i=0; i<=t; i++)
	{
		fprintf (stdout,"  gf_mult_by_%02x rp%d (.i(elp_in[%d:%d]),.o(elp_out[%d:%d]));\n",
			powers,
			i,
			(i+1)*symbol_size-1,i*symbol_size,
			(i+1)*symbol_size-1,i*symbol_size);

		powers = gf_mult (symbol_size,powers,2,mod_poly);
	}
	fprintf (stdout,"\n");
	
	fprintf (stdout,"  assign q = \n");
	for (i=0; i<=t; i=i+1)
	{
		fprintf (stdout,"   elp_out [%d:%d]",
			(i+1)*symbol_size-1,i*symbol_size);
		if (i != t) 
		{
			fprintf (stdout," ^");
		}			
		fprintf (stdout,"\n");
	}
	fprintf (stdout,";\n\n");

	fprintf (stdout,"assign match = ~|q;\n\n");

	fprintf (stdout,"endmodule\n");
	
}

///////////////////////////////////////////

void build_error_mag_poly (
	int symbol_size,
	int data_symbols,
	int mod_poly
)
{
	int n = (1 << symbol_size) - 1;
	int k = data_symbols;
	int t = (n - k) / 2;
	
	int i = 0;
	int mult_num = 0;

	fprintf (stdout,"\n///////////////////////////////////////////\n");
	fprintf (stdout,"// Error magnitude poly computation\n");
	fprintf (stdout,"///////////////////////////////////////////\n\n");
	
	fprintf (stdout,"module error_mag_poly_round (step_elp,syndrome,emp_term);\n");
	fprintf (stdout,"input [%d:0] step_elp;\n",symbol_size*(t+1)-1);
	fprintf (stdout,"input [%d:0] syndrome;\n",symbol_size*(t+1)-1);
	fprintf (stdout,"output [%d:0] emp_term;\n",symbol_size-1);
	
	fprintf (stdout,"wire [%d:0] mag_mult;\n",symbol_size*(t+1)-1);
	for (i=0; i<=t; i=i+1)
	{
		fprintf (stdout,"gf_mult m%d (.a(step_elp[%d:%d]),.b(syndrome[%d:%d]),.o(mag_mult[%d:%d]));\n",
			mult_num,
			(i+1)*symbol_size-1,i*symbol_size,
			(i+1)*symbol_size-1,i*symbol_size,
			(i+1)*symbol_size-1,i*symbol_size
		);
		mult_num++;
	}

	fprintf (stdout,"\nassign emp_term = \n");
	for (i=0; i<=t; i=i+1)
	{
		fprintf (stdout,"    mag_mult [%d:%d]",
			(i+1)*symbol_size-1,i*symbol_size);
		if (i != t) 
		{
			fprintf (stdout," ^");
		}			
		fprintf (stdout,"\n");
	}
	fprintf (stdout,";\n\n");

	fprintf (stdout,"endmodule\n\n");
}

///////////////////////////////////////////

void build_error_value (
	int symbol_size,
	int data_symbols,
	int mod_poly
)
{
	int n = (1 << symbol_size) - 1;
	int k = data_symbols;
	int t = (n - k) / 2;
	int powers = 0;

	int i = 0;

	fprintf (stdout,"\n///////////////////////////////////////////\n");
	fprintf (stdout,"// Error Value computation\n");
	fprintf (stdout,"///////////////////////////////////////////\n\n");
	
	fprintf (stdout,"// deriv_term is ELP'(alpha^-j) / alpha^j\n");
	fprintf (stdout,"// error position indicates symbols with actual errors\n");
	fprintf (stdout,"// error_value will have the invert pattern to correct bad symbols\n");
	fprintf (stdout,"module error_value_round (emp_in,emp_out,deriv_term,error_pos,error_val);\n");
	fprintf (stdout,"input [%d:0] emp_in;\n",symbol_size*(t+1)-1);
	fprintf (stdout,"output [%d:0] emp_out;\n",symbol_size*(t+1)-1);
	fprintf (stdout,"input [%d:0] deriv_term;\n",symbol_size-1);
	fprintf (stdout,"input error_pos;\n");
	fprintf (stdout,"output [%d:0] error_val;\n\n",symbol_size-1);

	fprintf (stdout,"wire [%d:0] q,r;\n",symbol_size-1);
	
	powers = 1;
	for (i=0; i<=t; i++)
	{
		fprintf (stdout,"  gf_mult_by_%02x rp%d (.i(emp_in[%d:%d]),.o(emp_out[%d:%d]));\n",
			powers,
			i,
			(i+1)*symbol_size-1,i*symbol_size,
			(i+1)*symbol_size-1,i*symbol_size);

		powers = gf_mult (symbol_size,powers,2,mod_poly);
	}
	fprintf (stdout,"\n");
	
	fprintf (stdout,"  assign q = \n");
	for (i=0; i<=t; i=i+1)
	{
		fprintf (stdout,"   emp_out [%d:%d]",
			(i+1)*symbol_size-1,i*symbol_size);
		if (i != t) 
		{
			fprintf (stdout," ^");
		}			
		fprintf (stdout,"\n");
	}
	fprintf (stdout,";\n\n");

	fprintf (stdout,"// r will be the correction if the symbol is actually\n");
	fprintf (stdout,"// wrong, and garbage if it's correct.  Apply as appro\n");
	fprintf (stdout,"gf_divide evd (.n(q),.d(deriv_term),.o(r));\n\n");

	fprintf (stdout,"assign error_val = {%d{error_pos}} & r;\n\n",symbol_size);

	fprintf (stdout,"endmodule\n");
	
}

///////////////////////////////////////////

void build_flat_decoder (
	int symbol_size,
	int data_symbols
)
{
	int n = (1 << symbol_size) - 1;
	int k = data_symbols;
	int t = (n - k) / 2;

	int i=0;
	int h = 0; 
	bool first = true;

	fprintf (stdout,"\n//////////////////////////////////////////////\n");
	fprintf (stdout,"// Complete decoder - no latency version\n");
	fprintf (stdout,"\n//////////////////////////////////////////////\n");
	fprintf (stdout,"module flat_decoder(rx_data,rx_data_corrected);\n\n");
	
	fprintf (stdout,"input [%d:0] rx_data;\n",symbol_size*n-1);
	fprintf (stdout,"output [%d:0] rx_data_corrected;\n\n",symbol_size*n-1);
	
	fprintf (stdout,"wire [%d:0] syndrome;\n",symbol_size*2*t-1);
	fprintf (stdout,"syndrome_flat syn (.rx_data(rx_data),.syndrome(syndrome));\n\n");
	
	fprintf (stdout,"//////////////////////////////\n");
	fprintf (stdout,"// build error location poly\n");
	fprintf (stdout,"//////////////////////////////\n");

	for (i=0; i<=2*t; i++)
	{
		fprintf (stdout,"wire [%d:0] order_%d;\n",log_2(2*t-1)-1,i);
		fprintf (stdout,"wire [%d:0] elp_%d;\n",2*t*symbol_size-1,i);
		fprintf (stdout,"wire [%d:0] step_syn_%d;\n",2*t*symbol_size-1,i);
		fprintf (stdout,"wire [%d:0] correction_%d;\n",2*t*symbol_size-1,i);
	}
	
	fprintf (stdout,"\nassign order_0 = 0;\n");
	fprintf (stdout,"assign correction_0 = 1 << %d;\n",symbol_size);
	fprintf (stdout,"assign step_syn_0 = syndrome[%d:0];\n",symbol_size-1);
	fprintf (stdout,"assign elp_0 = 1;\n\n");

	for (i=0; i<2*t; i++)
	{
		if (i!=0)
		{
			fprintf (stdout,"assign step_syn_%d = {step_syn_%d,syndrome[%d:%d]};\n",
				i,i-1,(i+1)*symbol_size-1,i*symbol_size);
		}

		fprintf (stdout,"error_loc_poly_round r%d (.step(%d),.order_in(order_%d),\n",i,i+1,i);
		fprintf (stdout,"   .order_out(order_%d),.elp_in(elp_%d),.elp_out(elp_%d),\n",
				i+1,i,i+1);
		fprintf (stdout,"   .step_syndrome(step_syn_%d),\n",i);
		fprintf (stdout,"   .correction_in(correction_%d),.correction_out(correction_%d));\n\n",
				i,i+1);
	}

	fprintf (stdout,"wire [%d:0] elp;\n",2*t*symbol_size-1);
	fprintf (stdout,"assign elp = elp_%d;\n\n",2*t);
	
	for (i=0; i<=t+1; i++)
	{
		fprintf (stdout,"wire [%d:0] step_elp_%d;\n",(t+1)*symbol_size-1,i);
	}

	fprintf (stdout,"//////////////////////////////\n");
	fprintf (stdout,"// build error mag poly\n");
	fprintf (stdout,"//////////////////////////////\n");

	fprintf (stdout,"wire [%d:0] emp;\n\n",(t+1)*symbol_size-1);
	fprintf (stdout,"assign step_elp_0 = elp[%d:0];\n",symbol_size-1);
	
	for (i=0; i<=t; i++)
	{
		if (i!=0)
		{
			fprintf (stdout,"assign step_elp_%d = {step_elp_%d,elp[%d:%d]};\n",
				i,i-1,(i+1)*symbol_size-1,i*symbol_size);
		}

		fprintf (stdout,"error_mag_poly_round m%d (.step_elp(step_elp_%d),\n",i,i);
		fprintf (stdout,"    .syndrome(syndrome),.emp_term(emp[%d:%d]));\n\n",
			(i+1)*symbol_size-1,i*symbol_size);		
	}

	fprintf (stdout,"//////////////////////////////\n");
	fprintf (stdout,"// Find roots of ELP\n");