max80_fw/fpga/spirom.sv

//
// Fast data download from 2-bit SPI flash.
//
// Feed a FIFO that then writes to SDRAM.
// This unit is designed to write 8-byte chunks.
//
// This unit does *not* require a 2x SPI clock;
// it uses a DDR buffer for clock out.
//

module spirom (
	       input rst_n,
	       input rom_clk,
	       input ram_clk,

	       output spi_sck,
	       inout [1:0] spi_io,
	       output reg spi_cs_n,

	       output [15:0] wd,	// Data to RAM
	       output reg [24:1] waddr,	// RAM address
	       output [1:0] wrq,	// Write request (min 8/16 bytes)
	       input wacc,		// Data accepted (ready for next data)

	       output reg done
	       );

   //
   // XXX: make these CPU programmable
   //
   parameter [24:0] ramstart = 25'h000_0000;
   parameter [23:0] romstart = 24'h10_0000; // 1 MB
   parameter [23:0] datalen  = 24'h08_0000; // 512K

   reg [1:0] 		  spi_in_q;
   reg 			  spi_in_req;
   wire [11:0] 		  wrusedw;
   wire [8:0] 		  rdusedw;

   //
   // FIFO
   //
   wire [15:0] 		  fifo_out;

   ddufifo spirom_fifo (
			.aclr ( ~rst_n ),

			.wrclk ( rom_clk ),
			.data ( spi_in_q ),
			.wrreq ( spi_in_req ),
			.wrfull ( ),
			.wrusedw ( wrusedw ),

			.rdclk ( ram_clk ),
			.q ( fifo_out ),
			.rdreq ( wacc ),
			.rdempty ( ),
			.rdusedw ( rdusedw )
			);

   //
   // Interfacing between FIFO and output signals
   //
   // Shuffle fifo_out because SPI brings in data in bigendian bit
   // order within bytes, but the FIFO IP assumes littleendian
   //
   assign wd[ 7: 6] = fifo_out[ 1: 0];
   assign wd[ 5: 4] = fifo_out[ 3: 2];
   assign wd[ 3: 2] = fifo_out[ 5: 4];
   assign wd[ 1: 0] = fifo_out[ 7: 6];

   assign wd[15:14] = fifo_out[ 9: 8];
   assign wd[13:12] = fifo_out[11:10];
   assign wd[11:10] = fifo_out[13:12];
   assign wd[ 9: 8] = fifo_out[15:14];

   assign wrq[0] = rdusedw >= 9'd4; // 4*2 = 8 bytes min available
   assign wrq[1] = rdusedw >= 9'd8; // 4*2 = 8 bytes min available

   always @(negedge rst_n or posedge ram_clk)
     if (~rst_n)
       begin
	  waddr  <= ramstart >> 1;
	  done   <= 1'b0;
       end
     else
       begin
	  if ( wacc )
	    begin
	       waddr <= waddr + 1'b1;
	       done  <= waddr == (((ramstart + datalen) >> 1) - 1'b1);
	    end
       end // else: !if(~rst_n)

   reg [5:0]  spi_cmd_ctr;
   reg [26:0] spi_data_ctr;
   reg 	      spi_clk_en    = 1'b0;
   reg 	      spi_mosi_en = 1'b1;

   ddio_out spi_clk_buf (
			 .aclr ( ~rst_n ),
			 .datain_h ( spi_clk_en ),
			 .datain_l ( 1'b0 ),
			 .outclock ( rom_clk ),
			 .dataout ( spi_sck )
			 );

   always @(negedge rst_n or posedge rom_clk)
     if (~rst_n)
       begin
	  spi_cmd_ctr  <= 6'b0;
	  spi_clk_en   <= 1'b0;
	  spi_data_ctr <= datalen << 2;
	  spi_cs_n     <= 1'b1;
       end
     else
       begin
	  spi_in_q   <= spi_io;
	  spi_in_req <= 1'b0;
	  spi_clk_en <= 1'b0;

	  if ( ~|spi_data_ctr )
	    begin
	       spi_cs_n   <= 1'b1;
	       spi_clk_en <= 1'b0;
	    end
	  else
	    begin
	       spi_cs_n   <= 1'b0;
	       if ( ~spi_cs_n )
		 begin
		    // 32/4 = 8 bytes min space
		    spi_clk_en <= (~wrusedw) >= 12'd32;
		    if ( spi_clk_en )
		      begin
			 if ( spi_cmd_ctr[5] & spi_cmd_ctr[3] & spi_cmd_ctr[0] )
			   begin
			      spi_in_req <= 1'b1;
			      spi_data_ctr <= spi_data_ctr - 1'b1;
			   end
			 else
			   begin
			      spi_cmd_ctr <= spi_cmd_ctr + 1'b1;
			   end
		      end // if ( spi_clk_en )
		 end // if ( ~spi_cs_n )
	    end // else: !if( ~|spi_data_ctr )
       end // else: !if(~rst_n)

   // SPI output data is shifted on the negative edge
   reg [31:0] spi_cmd;
   reg 	      spi_clk_en_q;

   assign spi_io[0] = spi_mosi_en ? spi_cmd[31] : 1'bz;
   assign spi_io[1] = 1'bz;

   always @(negedge rst_n or negedge rom_clk)
     if (~rst_n)
       begin
	  spi_cmd      <= { 8'h3b, romstart }; // Fast Read Dual Output
	  spi_mosi_en  <= 1'b1;
	  spi_clk_en_q <= 1'b0;
       end
     else
       begin
	  spi_clk_en_q <= spi_clk_en;
	  if ( spi_clk_en_q )
	    spi_cmd <= (spi_cmd << 1) | 1'b1;

	  spi_mosi_en <= spi_cs_n | (spi_cmd_ctr < 6'd36);
       end

endmodule // spirom