datacnl_raw.v

详细介绍SDRAM原理的中文电子书籍

module datacnl_raw(	
	clk,
	rst,

	r_ram_rdb,	
	r_ram_rab,
	
	r_req_in,

	s_ram_wdb,
	s_ram_wab,
	s_ram_wen,
	
	s_req_in,

	cmd,
	cmdack,
	addr,
	datain,
	dataout,

	start_send,
	start_read,
				
	vsync,
	send_cmd
                );

//--------------------ports--------------------
input	clk,rst;
input	[7:0]	r_ram_rdb;
input	cmdack;
input	[7:0]	dataout;
input	r_req_in,s_req_in;
input	start_read,vsync;
input	send_cmd;

output	[7:0]	r_ram_rab;
output	s_ram_wen;
output	[8:0]	s_ram_wab;

output	[2:0]	cmd;
output	[20:0]	addr;
output	[7:0]	datain,s_ram_wdb;

output	start_send;

//---------port variables declaration-----------
wire	clk,rst;
wire	cmdack;
wire	[7:0]	dataout;
wire	r_req_in,s_req_in;
reg	[2:0]	cmd;
reg	[20:0]	addr;
reg	[7:0]	s_ram_wdb;
wire	[7:0]	datain;
wire	s_ram_wen;
reg	start_send;

// State parameters used in MAIN  STATE MACHINE
parameter 
	IDLE		=22'b00_0000_0000_0000_0000_0001,
	PRECHARGE	=22'b00_0000_0000_0000_0000_0010,
	PRECHARGE_ACK	=22'b00_0000_0000_0000_0000_0100,    
	LOAD_MR		=22'b00_0000_0000_0000_0000_1000,
	LOAD_MR_ACK	=22'b00_0000_0000_0000_0001_0000,
	LOAD_R2		=22'b00_0000_0000_0000_0010_0000,
	LOAD_R2_ACK	=22'b00_0000_0000_0000_0100_0000,
	LOAD_R1		=22'b00_0000_0000_0000_1000_0000,
                          
	IDLE_WR		=22'b00_0000_0000_0001_0000_0000,    
	PAGE_WRITE	=22'b00_0000_0000_0010_0000_0000,
	BURST_WRITE	=22'b00_0000_0000_0100_0000_0000,
	BT_W		=22'b00_0000_0000_1000_0000_0000,
	WAIT_ACK_W_T	=22'b00_0000_0001_0000_0000_0000,
                         
	PAGE_READ	=22'b00_0000_0010_0000_0000_0000,
	BURST_READ	=22'b00_0000_0100_0000_0000_0000,
	BT		=22'b00_0000_1000_0000_0000_0000,
	LAST_DATA	=22'b00_0001_0000_0000_0000_0000,
	CLOSE_PAGE_W	=22'b00_0010_0000_0000_0000_0000,
	REFRESH_W       =22'b00_0100_0000_0000_0000_0000,
	CLOSE_PAGE_R    =22'b00_1000_0000_0000_0000_0000,
	REFRESH_R       =22'b01_0000_0000_0000_0000_0000,
	IDLE_R		=22'b10_0000_0000_0001_0000_0000;
	
parameter RCD='D3,CL='D3,BL='d240;//H_PIXELS>>2;

reg	s_enable;
reg	[21:0]	STATE;
reg	[10:0]	w_page;
reg	[7:0]	Burst_cnt;
reg	[1:0]	RCDCL_CNT;
reg	[8*10:0]	cmd_name;
reg	[8*12:0]	state_name;

reg	s_req,r_req,mode_vga;
reg	vsync_reg;

always @ (posedge clk)
begin
	s_req <= s_req_in;
	r_req <= r_req_in;
	vsync_reg <= vsync;
end

always @ cmd
case (cmd)
  'b000: cmd_name="NOP";
  'b001: cmd_name="READA";
  'b010: cmd_name="WRITEA";
  'b011: cmd_name="REFRESH";
  'b100: cmd_name="PRECHARGE";
  'b101: cmd_name="LOAD_MODE";
  'b110: cmd_name="LOAD_REG1";
  'b111: cmd_name="LOAD_REG2";
  endcase
  
always @ STATE
case(STATE)
 	PRECHARGE:	state_name="PRECHARGE";
	PRECHARGE_ACK:	state_name="PRECHARGE_ACK";
	LOAD_MR:	state_name="LOAD_MR";
	LOAD_MR_ACK:	state_name="LOAD_MR_ACK";
	LOAD_R2:	state_name="LOAD_R2";
	LOAD_R2_ACK:	state_name="LOAD_R2_ACK";
	LOAD_R1:	state_name="LOAD_R1";
	IDLE_WR:	state_name="IDLE_WR";
 	PAGE_WRITE:	state_name="PAGE_WRITE";
	BURST_WRITE:	state_name="BURST_WRITE";
	BT_W:		state_name="BT_W";
	CLOSE_PAGE_W:	state_name="CLOSE_PAGE_W";
	CLOSE_PAGE_R:	state_name="CLOSE_PAGE_R";
	PAGE_READ:	state_name="PAGE_READ";
	BURST_READ:	state_name="BURST_READ";
	BT:		state_name="BT";
	LAST_DATA:	state_name="LAST_DATA";
	REFRESH_R:	state_name="REFRESH_R";
	REFRESH_W:	state_name="REFRESH_W";
	default:	state_name="default";
	endcase
 


//transfer the data bus
always @ (posedge clk) begin	
	s_ram_wdb <= dataout;
	end
assign	datain = r_ram_rdb;

reg	[7:0]	r_ram_rab;
reg	STATE12_reg,STATE16_reg,STATE8_reg,STATE19_reg;

always @ (posedge clk) begin
	STATE12_reg <= STATE[12];
	STATE16_reg <= STATE[16];
	STATE8_reg  <= STATE[8];
	STATE19_reg <= STATE[19];
end

always @ (posedge clk or negedge rst)
if(!rst)
	r_ram_rab <= 0;
else if((STATE[9]&cmdack)|STATE[10])
	r_ram_rab <= r_ram_rab + 1;
else if(STATE12_reg)
	r_ram_rab<=0;
	    
//generate the write address bus data
reg	[7:0]	s_ram_wab_reg;
reg	s_ram_wab_hbit;
wire	[8:0]	s_ram_wab = {s_ram_wab_hbit,s_ram_wab_reg};

always @ (posedge clk or negedge rst)
if(!rst) begin
	s_ram_wab_reg<='d0;
	end
else if(vsync_reg) begin
	if(s_enable)
		s_ram_wab_reg<=s_ram_wab_reg+1;
	else
		s_ram_wab_reg<=0;
	end
else begin
	s_ram_wab_reg <= 0;
	end
	
always @ (posedge clk or negedge rst)
if(!rst) begin
	s_ram_wab_hbit<=0;
	end
else if(vsync_reg) begin
	if(STATE19_reg & cmdack)
		s_ram_wab_hbit <= ~s_ram_wab_hbit;
	end
else begin
	s_ram_wab_hbit<=0;
	end	

	
//generate the send wen signal 
assign s_ram_wen = s_enable;



parameter	NOP       ='b000,
		READA     ='b001,
		WRITEA    ='b010,
		ARF       ='b011,
		PRECHRG   ='b100,
		LOAD_MODE ='b101,
		LOAD_REG1 ='b110,
		LOAD_REG2 ='b111;
		
//generate the cmd to the sdr_sdram_controller
always @ (STATE)
case(STATE)    
	PRECHARGE:	cmd = PRECHRG;
	LOAD_MR:	cmd = LOAD_MODE;
	LOAD_R2:	cmd = LOAD_REG2;
	LOAD_R1:	cmd = LOAD_REG1;
	PAGE_WRITE:	cmd = WRITEA;
	BT_W:		cmd = PRECHRG;
	CLOSE_PAGE_W:	cmd = PRECHRG;
	CLOSE_PAGE_R:	cmd = PRECHRG;
	PAGE_READ:	cmd = READA;
	BT:		cmd = PRECHRG;
	REFRESH_W:	cmd = ARF;
	REFRESH_R:	cmd = ARF;
	default:	cmd = NOP;
endcase
//*****************************************************************************//
//*****************************************************************************//
always @ (posedge clk or negedge rst)
if(!rst)
	w_page <= 0;
else if(STATE12_reg)
	w_page <= w_page + 1;
else if(STATE8_reg&(!vsync_reg))
	w_page <= 0;

//****************************************************************************//
//****************************************************************************//
reg	[10:0]	r_page_video;
	
always @ (posedge clk or negedge rst)
if(!rst)
	r_page_video <= 0;
else if(STATE16_reg)
	r_page_video <= r_page_video + 1;
else if(STATE8_reg & (!vsync_reg))
	r_page_video <= 0;				          				 


wire	[10:0]	r_page = r_page_video;

//********************************************************************************//
//********************************************************************************//
reg	send_raw;
always @ (posedge clk or negedge rst)
if(!rst)
	send_raw <= 0;
else if(send_cmd)
	send_raw <= 1;
else if(r_page=='d1728)
	send_raw <= 0;
//*********************************************************************************//
//*********************************************************************************//

				
//the state machine
always @(posedge clk or negedge rst)
begin
if(!rst) begin
        STATE<=IDLE;
	s_enable<=0;
        RCDCL_CNT<=0;
        Burst_cnt<=0;
	end
else
     case(STATE)
	IDLE:
	if(start_read)
		STATE<=PRECHARGE;
	else
		STATE<=IDLE;
		
	PRECHARGE:
	if(cmdack)
		STATE<=PRECHARGE_ACK;
	else
		STATE<=PRECHARGE;
		
	PRECHARGE_ACK:
		STATE<=LOAD_MR;
		
	LOAD_MR:
	if(cmdack)  
		STATE<=LOAD_MR_ACK;
	else
		STATE<=LOAD_MR;
		
	LOAD_MR_ACK:
		STATE<=LOAD_R2;
		
	LOAD_R2:
	if(cmdack)
 		STATE<=LOAD_R2_ACK;
	else
		STATE<=LOAD_R2;
		
	LOAD_R2_ACK:
		STATE<=LOAD_R1;
	LOAD_R1:
	if(cmdack)
		STATE<=IDLE_WR;
	else
		STATE<=LOAD_R1;

//page write burst
	IDLE_WR: 
	if(r_req)
		STATE<=PAGE_WRITE;
	else
		STATE<=IDLE_WR;

	PAGE_WRITE: //10
	if(cmdack) begin
		STATE<=BURST_WRITE; 
		Burst_cnt<=0;
		end
	else
		STATE<=PAGE_WRITE;  
		
	BURST_WRITE: begin
	if(Burst_cnt==(8'd237))//256-BL
		STATE<=BT_W;
	else
		STATE<=BURST_WRITE;
	Burst_cnt<=Burst_cnt+1;
	end  
	
	BT_W:begin          //12
	if(cmdack)
		STATE<=WAIT_ACK_W_T;
	else
		STATE<=BT_W;
	end

	WAIT_ACK_W_T:begin
	STATE<=CLOSE_PAGE_W;
	end        
	 
//CLOSE CURRENT PAGE                       
	CLOSE_PAGE_W:begin
	if(cmdack)
		STATE<=REFRESH_W;
	else
		STATE<=CLOSE_PAGE_W;
	end
	REFRESH_W: begin
	if(cmdack) begin 
		if(w_page=='d1727) 
			STATE <= IDLE_R;
		else      
			STATE <= IDLE_WR;
		end
	else
		STATE<=REFRESH_W;
	end
	
//PAGE READ BURST TEST
	IDLE_R: begin                
	if( s_req ) begin
		STATE<=PAGE_READ;
		end  
	else if(send_raw)
		STATE<=IDLE_R;
	else
		STATE<=IDLE_WR;
	end    
	PAGE_READ:begin
		if(cmdack)    
			STATE<=BURST_READ;
		else 
			STATE<=PAGE_READ;
		Burst_cnt<=0;
		RCDCL_CNT<=0;
                end
                
	BURST_READ:begin
	if(Burst_cnt==('d6))
		s_enable <= 1; 
	else if(Burst_cnt==('d240-3))//BL+RCD+CL
		STATE<=BT;
	else
		STATE<=BURST_READ;
	Burst_cnt<=Burst_cnt+1;
	end
	
	BT:
	if(cmdack)
		STATE<=LAST_DATA;                       
	else
		STATE<=BT;                            
	LAST_DATA:
	STATE<=CLOSE_PAGE_R;

	CLOSE_PAGE_R:begin
	if(cmdack)
		STATE<=REFRESH_R;
	else
		STATE<=CLOSE_PAGE_R;
		
	if(RCDCL_CNT=='d2)
		s_enable<=0;
	else
		RCDCL_CNT<=RCDCL_CNT+1;	
	end
	
	REFRESH_R:begin
	if(cmdack)begin              
		STATE<=IDLE_R;
		end
	else
		STATE<=REFRESH_R;
	end
	
	default:
	STATE<=IDLE;

	endcase
end

//generate the addr to the sdr_sdram_controller
always @ (STATE or w_page or r_page)
case(STATE)
	PRECHARGE:	addr = 'h1f0000;
	LOAD_MR:	addr = 'h37;
	LOAD_R2:	addr = 'h5F6;
	LOAD_R1:	addr = 'h12F; //'h10f
	PAGE_WRITE:	addr = {2'b0,w_page,8'b0};//PAGE_WRITE
	PAGE_READ:	addr = {2'b0,r_page,8'b0};
	BT_W:		addr = {2'b0,19'b0};    
	CLOSE_PAGE_W:	addr = {2'b0,19'b0};
	CLOSE_PAGE_R:	addr = {2'b0,19'b0};
	BT:		addr = {2'b0,19'b0};
	default:	addr = 'h0;
endcase
endmodule