Subversion Repositories thor

// ============================================================================
//        __
//   \\__/ o\    (C) 2006-2018  Robert Finch, Waterloo
//    \  __ /    All rights reserved.
//     \/_//     robfinch<remove>@finitron.ca
//       ||
//
//	fpdivr16.v
//    Radix 16 floating point divider primitive
//
//
// This source file is free software: you can redistribute it and/or modify 
// it under the terms of the GNU Lesser General Public License as published 
// by the Free Software Foundation, either version 3 of the License, or     
// (at your option) any later version.                                      
//                                                                          
// This source file is distributed in the hope that it will be useful,      
// but WITHOUT ANY WARRANTY; without even the implied warranty of           
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            
// GNU General Public License for more details.                             
//                                                                          
// You should have received a copy of the GNU General Public License        
// along with this program.  If not, see <http://www.gnu.org/licenses/>.    
//                                                                          
// ============================================================================
 
module fpdivr16(clk, ld, a, b, q, r, done, lzcnt);
parameter WID1 = 112;
localparam REM = WID1 % 4;
localparam WID = ((WID1*4)+3)/4;
localparam DMSB = WID-1;
input clk;
input ld;
input [WID-1:0] a;
input [WID-1:0] b;
output reg [WID*2-1:0] q;
output reg [WID-1:0] r;
output reg done;
output reg [7:0] lzcnt;
 
initial begin
	if (WID % 4) begin
		$display("fpdvir16: Width must be a multiple of four.");
		$finish;
	end
end
 
reg [DMSB:0] rxx;
reg [8:0] cnt;				// iteration count
reg [DMSB+1:0] ri = 0; 
wire b0,b1,b2,b3;
wire [DMSB+1:0] r1,r2,r3,r4;
reg gotnz;
 
wire [7:0] maxcnt;
wire [2:0] n1;
assign maxcnt = WID*2/4-1;
assign b0 = b <= {rxx,q[WID*2-1]};
assign r1 = b0 ? {rxx,q[WID*2-1]} - b : {rxx,q[WID*2-1]};
assign b1 = b <= {r1,q[WID*2-2]};
assign r2 = b1 ? {r1,q[WID*2-2]} - b : {r1,q[WID*2-2]};
assign b2 = b <= {r2,q[WID*2-3]};
assign r3 = b2 ? {r2,q[WID*2-3]} - b : {r2,q[WID*2-3]};
assign b3 = b <= {r3,q[WID*2-4]};
assign r4 = b3 ? {r3,q[WID*2-4]} - b : {r3,q[WID*2-4]};
 
reg [2:0] state = 0;
 
always @(posedge clk)
begin
done <= 1'b0;
case(state)
3'd0:
	if (ld) begin
		lzcnt <= 0;
		gotnz <= 0;
		cnt <= maxcnt;
		q <= {(a << REM),{WID{1'b0}}};
        rxx <= {WID{1'b0}};
		state <= 1;
	end
3'd1:
	if (!cnt[8]) begin
		q[WID*2-1:4] <= q[WID*2-5:0];
		q[3] <= b0;
		q[2] <= b1;
		q[1] <= b2;
		q[0] <= b3;
		if (!gotnz)
			casez({b0,b1,b2,b3})
			4'b1???:	;
			4'b01??:	lzcnt <= lzcnt + 8'd1;
			4'b001?:	lzcnt <= lzcnt + 8'd2;
			4'b0001:	lzcnt <= lzcnt + 8'd3;
			4'b0000:	lzcnt <= lzcnt + 8'd4;
			endcase
		if ({b0,b1,b2,b3} != 4'h0 && !gotnz) begin
			gotnz <= 1;
		end
        rxx <= r4;
		cnt <= cnt - 1;
	end
	else
		state <= 2;
3'd2:
	begin
    	r <= r4;
    	done <= 1'b1;
    	state <= 0;
    end
default:	state <= 0;
endcase
end
 
endmodule