Реализация контроллера SDRAM

в 18:13, , рубрики: fpga, MT48LC16M16A2, SDRAM

В статье про VGA интерфейс я написал, что использовал внешнюю память SDRAM  в качестве фрем буфера. Хочу поделиться его реализацией, хотя бы потому что, когда я занимался разработкой этого модуля потратил много времени, ведь стандартные IP-ядра не поддерживают эту микросхему. И, как результат, хочу кому-нибудь помочь в этом вопросе.

Отладочная плата использовалась все та же с ПЛИС семейства Spartan6 xc6slx16. На борту также имеется память SDRAM(MT48LC16M16A2) объёмом 32 Мбайта.

Вот фотография отладочной платы:
Реализация контроллера SDRAM - 1

Вводные данные

И так, из даташита на микросхему MT48LC16M16A2, она имеет структуру из 4 банок по 4 млн ячеек с разрядностью 16 бит (4M ячеек x 16 x 4 банка). В принципе, тут все понятно.

Для понимания адресации этой памяти смотрим в даташит и видим такую таблицу, нас интересует последний столбик:

Реализация контроллера SDRAM - 2

Из него видно, что у нас есть 13 бит — для адресации по строкам, 9 бит — для адресации по столбцам и 2 бита — для адресации по банкам; всего 24 бита для адресации по всему объёму памяти. Используя нехитрую математику, можно получить те самые объёмы памяти, которые обещают в даташите: 16*2^24 = 268435456 бит (33554432 байт).

Если заглянуть в распиновку этой микросхемы, то увидим, что пинов под адресацию всего 13 бит + 2 бита адресации банков. На рисунке видно, что сигналы А0-А12 это шина адреса и ВА0-ВА1 это шина выбора банка, ну и как бы все… Где еще 9 бит адреса?

Реализация контроллера SDRAM - 3

Если лучше изучить вопрос механизма работы SDRAM (либо лучше запоминать материал на парах, как в моем случае[я, разумеется, все забыл]), то выясняется, что шина адреса используется два раза. В первый раз она используется для выбора строки, в нашем случае используются все 13 бит адреса; а во второй раз используется для выбора столбца (только 9 бит адреса), по сути, ячейка внутри этой строки. Еще раз: сначала выбор строки (N такт клока), потом выбор столбца (N+x такт клока) и их пересечение даст нам ячейку памяти, естественно не забываем о выбранном банке.

Реализация контроллера SDRAM - 4

Так же в глаза бросается шина данных DQ0-DQ15. Как видно, она одна и используется — и для записи, и для чтения. Мне, как человеку часто использующего примитивы BRAM в ПЛИС, подобная архитектура показалась крайне неудобной. Но если посмотреть на это с другой стороны, можно сразу понять, что микросхема — это физическое устройство распаиваемое на плате, и если бы все пины пришлось разводить, то это был бы еще тот геморрой, а он никому не нужен. К тому же тут одна шина адреса, а случаи, когда одновременно надо запросить чтение и запись по одному адресу я не знаю.

Алгоритм работы

SDRAM работает на системе команд, которая задает режим и стадии работы. Вот список команд для микросхемы MT48LC16M16A2:

картинка с сайта http://microsin.net/adminstuff/hardware/sdr-sdram-mt48lc16m16a2.html

У самой же микросхемы полно различных режимов работы, например:

  • Различные длины пакетов, которые можно за раз прочитать и записать.

  • Авто перезарядка ячеек памяти.

  • Количество участвующих банков памяти во время обновления заряда.

  • Так же имеются различные варианты перехода от состояния к состоянию.

Для того чтобы упростить себе жизнь, я перешел в режим доступа к одной ячейке за одно обращение. Так же воспользовался свойством, что после команды чтения/записи можно выполнить следующую команду чтения/записи, если новый адрес в пределах активированной строки. В моем случае, я мог писать по 512 слов без остановки, затем начинается процесс  обновления ячеек памяти и автомат контроллера переходит в режим ожидания команды. В итоге у меня получился вот такой модуль:

Реализация контроллера SDRAM - 6

Интерфейс m_* является входным для загрузки команд и данных если команда на запись. По интерфейсу s_* происходит вывод результата чтения из памяти. Данные читаются с задержкой в 3 такта.

Логика модуля проста, команды на чтение или запись захватываются до тех пор, пока адрес меняется во младших 9 разрядах. Так же команды перестают захватываться, если поменялся тип команды(чтение<=>запись). Модуль чувствителен к сигналу m_valid, если он упал, то контроллер памяти переходит к закрытию активированной строки и обновляет заряд в ячейках.

Несмотря на то, что в даташите написано, что максимальная частота для данной микросхемы 133 МГц, на моей отладке модуль работал на частоте 150 МГц. Но я не стал испытывать судьбу и оставил частоту в 100 МГц (мне так удобно для дальнейшего использования).

Вот код модуля:
`timescale 1ns / 1ps

module ctrl_sdram_v2
#(
	parameter [2:0] CL = 'd3
)
(
    input clk,
	 input rst,
	 //user interface)
	 input [15:0] m_data, // valid if m_we==1
	 input [23:0] m_addr, //2bit BANK, 13bit ROW, 9bit COLUMM
	 input		 m_we	  , // 0 - read, 1 - write)
	 input		 m_valid,
	 output      m_ready,
	 output reg[15:0] s_data,
	 output reg    s_valid,
	 input	      s_ready,// invalid ready. only s_valid
	 	 
	 //SDRAM interface
	 output reg sd_cke,
	 output sd_clk,
	 output sd_dqml,
	 output sd_dqmh,
	 output reg  sd_cas_n,
	 output reg sd_ras_n,
	 output reg sd_we_n,
	 output reg sd_cs_n,
	 output reg [14:0] sd_addr,
	 inout  [15:0] sd_data
    );


reg [3:0] state_main = 'd0;
reg [15:0] state_tri ;
reg [15:0] sd_data_o ;
wire [15:0] sd_data_i ;

reg [23:0] m_addr_set = 'd0;
reg flg_first_cmd = 'd1;
wire new_row_addr;
reg [15:0] cnt_wait = 'd0;
reg [15:0] cnt_wait_buf = 'd0;
reg [10:0] cnt_refresh_sdram = 'd0;
always@(posedge clk)
begin
	if(rst) begin
		state_main <= 'd0;
		m_addr_set <= 'd0;
		flg_first_cmd <= 'd1;
	end else begin
		case(state_main)
			0: begin //wait 100 us
				if(cnt_wait >= 8000) state_main<= 'd1;
				else cnt_wait <= cnt_wait + 1;
			end
			1: begin //set NOP
				if(cnt_wait >= 10000) begin 
					state_main<= 'd2;
					cnt_wait <= 'd0;
				end else cnt_wait <= cnt_wait + 1;
			end
			2: begin //cmd PRECHARGE ALL
				if(cnt_wait >= 'd1) begin 
					cnt_wait <= 'd0;
					state_main <= 'd3;
				end else cnt_wait <= cnt_wait + 1'b1;
			end
			3: begin // AUTO REFRESH 0
				if(cnt_wait[14:0] >= 'd6) begin 
					cnt_wait[14:0] <= 'd0;
					if(cnt_wait[15]) begin
					state_main <= 'd4;
					cnt_wait[15] <= 'd0;
					end else cnt_wait[15] <= 'd1;
				end else cnt_wait <= cnt_wait + 1'b1;
			end
			4: begin //cmd LOAD MODE
				if(cnt_wait >= 'd1) begin 
					cnt_wait <= 'd0;
					state_main <= 'd5;
				end else cnt_wait <= cnt_wait + 1'b1;
			end
			5: begin //IDLE state
				if(m_valid) begin
					state_main <= 'd6;
					cnt_refresh_sdram <= 'd0;
				end else begin
					if(&cnt_refresh_sdram) begin
						state_main <= 'd8;
						cnt_refresh_sdram <= 'd0;
					end else cnt_refresh_sdram <= cnt_refresh_sdram + 1;
				end
			end
			6: begin // cmd ACTIVATE row
				if(cnt_wait >= CL) begin 
					cnt_wait <= 'd0;
					if(m_we) begin //cmd WRITE
						state_main <= 'd7;
					end else begin //cmd READ
						state_main <= 'd9;
					end
					m_addr_set <= m_addr;
					flg_first_cmd <= 'd1;
				end else cnt_wait <= cnt_wait + 1'b1;
			end
			7: begin //WRITE
				m_addr_set <= m_addr;
				if(flg_first_cmd) begin					
					flg_first_cmd <= 'd0;
				end else begin
					if(new_row_addr=='d1 || m_valid == 'd0 || m_ready == 'd0) begin//goto precharge
						state_main <= 'd8;
					end
				end
			end
			8: begin //cmd PRECHARGE after write
				if(cnt_wait >= 'd3) begin 
					cnt_wait <= 'd0;
					state_main <= 'd5;
				end else cnt_wait <= cnt_wait + 1'b1;
			end
			9: begin //READ and reading data from SDRAM
				m_addr_set <= m_addr;
				if(flg_first_cmd) begin					
					flg_first_cmd <= 'd0;
				end else begin
					if(new_row_addr=='d1 || m_valid == 'd0 || m_ready == 'd0) begin//
						state_main <= 'd10;
						cnt_wait_buf <= cnt_wait;
					end
				end
				cnt_wait <= cnt_wait + 1'b1;
			end
			10: begin //reading data from SDRAM
				if(cnt_wait == cnt_wait_buf+CL) begin
					state_main <= 'd11;
					cnt_wait <= 'd0;
				end else cnt_wait <= cnt_wait + 1;
			end
			11: begin // cmd AUTO REFRESH after read
				if(cnt_wait >= 'd3) begin 
					cnt_wait <= 'd0;
					state_main <= 'd5;
				end else cnt_wait <= cnt_wait + 1'b1;			
			end
		endcase
	end
end


assign new_row_addr = (m_addr_set[23:9] != m_addr[23:9]) ?  'd1 : 'd0;

assign m_ready = (state_main == 'd7 && m_we == 'd1 && new_row_addr == 'd0) ? 'd1 : 
					  (state_main == 'd9 && m_we == 'd0 && new_row_addr == 'd0) ? 'd1 :
					  'd0;
					  

always@(posedge clk)
begin
	s_data <= sd_data_i;
	s_valid <= ((state_main == 'd9 || state_main == 'd10) && cnt_wait > CL) ? 'd1 : 'd0;
end

assign sd_dqml	=0;
assign sd_dqmh	=0;

always@(posedge clk)
begin

 state_tri <= (state_main == 'd7) ? 16'd0 : 16'hFFFF; 
 sd_data_o <= (state_main == 'd7) ? m_data : 'd0;

 sd_cke	<= (state_main == 'd0) ? 'd0 : 	'd1;

 sd_cas_n<=			(state_main == 'd1) ? 'd1 : // INIT NOP
						(state_main == 'd2 && cnt_wait==0) ? 'd1 : //PRECHARGE
						(state_main == 'd2 && cnt_wait>0)  ? 'd1 :
						(state_main == 'd3 && cnt_wait[14:0]==0)  ? 'd0 : //autorefresh
						(state_main == 'd3 && cnt_wait[14:0]!=0)  ? 'd1 ://nop
						(state_main == 'd4 && cnt_wait==0)  ? 'd0 : //load mode
						(state_main == 'd4 && cnt_wait!=0)  ? 'd1 : //nop
						(state_main == 'd5)  ? 'd1 : //nop
						(state_main == 'd6 && cnt_wait==0)  ? 'd1 : //activate
						(state_main == 'd6 && cnt_wait!=0)  ? 'd1 : //nop
						(state_main == 'd7 && m_valid=='d1 && m_ready=='d1  ) ? 'd0  : //WRITE
						(state_main == 'd7 && (m_valid=='d0 || m_ready=='d0)) ? 'd1  : //nop
						(state_main == 'd8 && cnt_wait==0) ? 'd1 : //precharge after write
						(state_main == 'd8 && cnt_wait!=0) ? 'd1 : //nop
						(state_main == 'd9 && m_valid=='d1 && m_ready=='d1  ) ? 'd0  : //READ
						((state_main == 'd9 || state_main == 'd10) && (m_valid=='d0 || m_ready=='d0)) ? 'd1 : // nop
						(state_main == 'd11 && cnt_wait==0) ? 'd1: //'d0 : //auto REFRESH(1) //precharge after read
						(state_main == 'd11 && cnt_wait!=0) ? 'd1 : // nop
						'd1;
 sd_ras_n<=	(state_main == 'd1) ? 'd1 : 
						(state_main == 'd2 && cnt_wait==0) ? 'd0 :
						(state_main == 'd2 && cnt_wait>0)  ? 'd1 :
						(state_main == 'd3 && cnt_wait[14:0]==0)  ? 'd0 :
						(state_main == 'd3 && cnt_wait[14:0]!=0)  ? 'd1 :
						(state_main == 'd4 && cnt_wait==0)  ? 'd0 :
						(state_main == 'd4 && cnt_wait!=0)  ? 'd1 :
						(state_main == 'd5)  ? 'd1 :
						(state_main == 'd6 && cnt_wait==0)  ? 'd0 :
						(state_main == 'd6 && cnt_wait!=0)  ? 'd1 :
						(state_main == 'd7 && m_valid=='d1 && m_ready=='d1  ) ? 'd1  :
						(state_main == 'd7 && (m_valid=='d0 || m_ready=='d0)) ? 'd1  :
						(state_main == 'd8 && cnt_wait==0) ? 'd0 :
						(state_main == 'd8 && cnt_wait!=0) ? 'd1 :
						(state_main == 'd9 && m_valid=='d1 && m_ready=='d1  ) ? 'd1  :
						((state_main == 'd9 || state_main == 'd10) && (m_valid=='d0 || m_ready=='d0)) ? 'd1 :
						(state_main == 'd11 && cnt_wait==0) ? 'd0: //'d0 :
						(state_main == 'd11 && cnt_wait!=0) ? 'd1 :
						'd1;
 sd_we_n	<=  (state_main == 'd1) ? 'd1 : 
						(state_main == 'd2 && cnt_wait==0) ? 'd0 :
						(state_main == 'd2 && cnt_wait>0)  ? 'd1 :
						(state_main == 'd3 && cnt_wait[14:0]==0)  ? 'd1 :
						(state_main == 'd3 && cnt_wait[14:0]!=0)  ? 'd1 :
						(state_main == 'd4 && cnt_wait==0)  ? 'd0 :
						(state_main == 'd4 && cnt_wait!=0)  ? 'd1 :
						(state_main == 'd5)  ? 'd1 :
						(state_main == 'd6 && cnt_wait==0)  ? 'd1 :
						(state_main == 'd6 && cnt_wait!=0)  ? 'd1 :
						(state_main == 'd7 && m_valid=='d1 && m_ready=='d1  ) ? 'd0  :
						(state_main == 'd7 && (m_valid=='d0 || m_ready=='d0)) ? 'd1  :
						(state_main == 'd8 && cnt_wait==0) ? 'd0 :
						(state_main == 'd8 && cnt_wait!=0) ? 'd1 :
						(state_main == 'd9 && m_valid=='d1 && m_ready=='d1  ) ? 'd1  :
						((state_main == 'd9 || state_main == 'd10) && (m_valid=='d0 || m_ready=='d0)) ? 'd1 :
						(state_main == 'd11 && cnt_wait==0) ? 'd0 ://'d1 :
						(state_main == 'd11 && cnt_wait!=0) ? 'd1 :
						'd1;
 sd_cs_n	<=			(rst == 'd1) ?  'd1 : 
						(state_main == 'd1) ? 'd0 : 
						(state_main == 'd2 && cnt_wait==0) ? 'd0 :
						(state_main == 'd2 && cnt_wait>0)  ? 'd0 :
						(state_main == 'd3 && cnt_wait[14:0]==0)  ? 'd0 :
						(state_main == 'd3 && cnt_wait[14:0]!=0)  ? 'd0 :
						(state_main == 'd4 && cnt_wait==0)  ? 'd0 :
						(state_main == 'd4 && cnt_wait!=0)  ? 'd0 :
						(state_main == 'd5)  ? 'd0 :
						(state_main == 'd6 && cnt_wait==0)  ? 'd0 :
						(state_main == 'd6 && cnt_wait!=0)  ? 'd0 :
						(state_main == 'd7 && m_valid=='d1 && m_ready=='d1  ) ? 'd0  :
						(state_main == 'd7 && (m_valid=='d0 || m_ready=='d0)) ? 'd0  :
						(state_main == 'd8 && cnt_wait==0) ? 'd0 :
						(state_main == 'd8 && cnt_wait!=0) ? 'd0 :
						(state_main == 'd9 && m_valid=='d1 && m_ready=='d1  ) ? 'd0  :
						((state_main == 'd9 || state_main == 'd10) && (m_valid=='d0 || m_ready=='d0)) ? 'd0 :
						(state_main == 'd11 && cnt_wait==0) ? 'd0: //'d0 :
						(state_main == 'd11 && cnt_wait!=0) ? 'd0 :
						'd0; 
 sd_addr[14:13] <= m_addr[23:22];
 sd_addr[12:0]	<=  (state_main == 'd2 && cnt_wait==0) ? {4'b0,1'b1,10'b0} :  //[10] = 1
						(state_main == 'd4 && cnt_wait==0)  ? {2'b00,3'b000,1'b1,2'b00,CL[2:0],1'b0,3'b000} :  //BA[1:0]==0,A[12:10]==0,WRITE_BURST_MODE = 0,OP_MODE = 'd0, CL = 2, TYPE_BURST = 0, BURST_LENGTH = 1
						(state_main == 'd6 && cnt_wait==0)  ? m_addr[21:9] :
						(state_main == 'd7) ? {5'd0,m_addr[8:0]} : 
						(state_main == 'd8 && cnt_wait==0) ? {4'b0,1'b1,10'b0} :  //[10] = 1
						(state_main == 'd9) ? {7'd0,m_addr[8:0]} :
						(state_main == 'd11 && cnt_wait==0) ? {4'b0,1'b1,10'b0} :  //[10] = 1
						'd0;

end



ODDR2 #(
	.DDR_ALIGNMENT("NONE"), // Sets output alignment to "NONE", "C0" or "C1" 
	.INIT(1'b0),    // Sets initial state of the Q output to 1'b0 or 1'b1
	.SRTYPE("SYNC") // Specifies "SYNC" or "ASYNC" set/reset
) ODDR2_inst (
	.Q		(sd_clk),   // 1-bit DDR output data
	.C0	(clk),   // 1-bit clock input
	.C1	(!clk),   // 1-bit clock input
	.CE	(!rst), // 1-bit clock enable input
	.D0	(1), // 1-bit data input (associated with C0)
	.D1	(0), // 1-bit data input (associated with C1)
	.R		(0),   // 1-bit reset input
	.S		(0)    // 1-bit set input
);


genvar i;
generate
	for (i=0; i < 16; i=i+1) 
	begin: tri_state
		OBUFT #(
			.DRIVE(12),   // Specify the output drive strength
			.IOSTANDARD("DEFAULT"), // Specify the output I/O standard
			.SLEW("SLOW") // Specify the output slew rate
		) OBUFT_inst (
			.O(sd_data[i]),     // Buffer output (connect directly to top-level port)
			.I(sd_data_o[i]),     // Buffer input
			.T(state_tri[i])      // 3-state enable input 
		);
		
		
		IBUF #(
			.IOSTANDARD("DEFAULT")    // Specify the input I/O standard
		)IBUF_inst (
			.O(sd_data_i[i]),     // Buffer output
			.I(sd_data[i])      // Buffer input (connect directly to top-level port)
		);
	end
endgenerate

endmodule

Заключение

Статья не получилась всеобъемлющей и всеобъясняющей, но на этом сайте есть русский вариант даташита и с комментариями от автора. Я опирался на нее, когда осваивал материал.

P.S. как я состыковал работу VGA модуля и SDRAM контроллера.
Структурная схема взаимодействия VGA модуля с памятью.

Структурная схема взаимодействия VGA модуля с памятью.

В проекте имелось два клоковых домена, на 100 МГц и на 25 МГц. За счет того что контроллер памяти работал на частоте 100 МГц, он теоретически мог записать в себя 3 новых кадра прежде чем 1 кадр отрисуется на мониторе.

Автомат работает в двух состояниях, либо он загружает новый кадр либо он вычитывает имеющийся кадр для дальнейшей отрисовки. Режим по умолчанию это режим записи нового кадра в память, когда приходит сигнал от ФИФО о том что оно почти пустое, автомат переключается на чтение из памяти и вычитывает необходимый объем. В данном случае сигнал almost_empty поднимается когда в ФИФО осталось 100 значений, это сделано для того чтобы автомат успел переключиться на режим чтения и модуль Ctrl_SDRAM успел закончить предыдущую команду. Автомат вычитывает из памяти следующие 900 значений пикселей и снова переключается на режим записи.

ФИФО является двухклоковым, глубиной порядка 1000 значений. На частоте 100 МГц происходит запись в него, а модуль VGA вычитывает на своей частоте в 25 МГц. Если прикинуть время через которое вновь потребуется переключение автомата на чтение то она следующая: 100 значений + 900 новых значений вчитывается из памяти - четверть значений которые успеют вычитаться за этот период, в конечном счете имеем 750 значений в ФИФО. В итоге модуль VGА будет вычитывать следующие значения 650 тактов, до того как поднимется флаг almost_empty, переведя это на 100МГц получим 2600 тактов записи в память, этого более чем достаточно. Естественно тут нужно понимать что VGA модуль не читает из ФИФО в тех областях где не отрисовывается картинка: порядка 160 тактов в конце каждой строки пикселей и 7200 тактов в конце фрейма на частоте 25 МГц, а это в общей сложности 336000 тактов простоя на частоте 100МГц.

Автор: Михаил

Источник


* - обязательные к заполнению поля


https://ajax.googleapis.com/ajax/libs/jquery/3.4.1/jquery.min.js