Subversion Repositories openarty

////////////////////////////////////////////////////////////////////////////////
//
// Filename: 	fasttop.v
//
// Project:	OpenArty, an entirely open SoC based upon the Arty platform
//
// Purpose:	This is the top level Verilog file.  It is so named as fasttop,
//		because my purpose will be to run the Arty at 200MHz, just to
//	prove that I can get it up to that frequency.
//
// Creator:	Dan Gisselquist, Ph.D.
//		Gisselquist Technology, LLC
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015-2016, Gisselquist Technology, LLC
//
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of  the GNU General Public License as published
// by the Free Software Foundation, either version 3 of the License, or (at
// your option) any later version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY 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.  (It's in the $(ROOT)/doc directory, run make with no
// target there if the PDF file isn't present.)  If not, see
// <http://www.gnu.org/licenses/> for a copy.
//
// License:	GPL, v3, as defined and found on www.gnu.org,
//		http://www.gnu.org/licenses/gpl.html
//
//
////////////////////////////////////////////////////////////////////////////////
//
//
module fasttop(i_clk_100mhz, i_reset_btn,
	i_sw,			// Switches
	i_btn,			// Buttons
	o_led,			// Single color LEDs
	o_clr_led0, o_clr_led1, o_clr_led2, o_clr_led3,	// Color LEDs
	// RS232 UART
	i_uart_rx, o_uart_tx,
	// Quad-SPI Flash control
	o_qspi_sck, o_qspi_cs_n, io_qspi_dat,
	// Missing: Ethernet
	o_eth_mdclk, io_eth_mdio,
	// Memory
	o_ddr_reset_n, o_ddr_cke, o_ddr_ck_p, o_ddr_ck_n,
	o_ddr_cs_n, o_ddr_ras_n, o_ddr_cas_n, o_ddr_we_n,
	io_ddr_dqs_p, io_ddr_dqs_n,
	o_ddr_addr, o_ddr_ba,
	io_ddr_data, o_ddr_dm, o_ddr_odt,
	// SD Card
	o_sd_sck, io_sd_cmd, io_sd, i_sd_cs, i_sd_wp,
	// GPS Pmod
	i_gps_pps, i_gps_3df, i_gps_rx, o_gps_tx,
	// OLED Pmod
	o_oled_sck, o_oled_cs_n, o_oled_mosi, o_oled_dcn, o_oled_reset_n,
		o_oled_vccen, o_oled_pmoden,
	// PMod I/O
	i_aux_rx, i_aux_rts, o_aux_tx, o_aux_cts
	);
	input			i_clk_100mhz, i_reset_btn;
	input		[3:0]	i_sw;	// Switches
	input		[3:0]	i_btn;	// Buttons
	output	wire	[3:0]	o_led;	// LED
	output	wire	[2:0]	o_clr_led0, o_clr_led1, o_clr_led2, o_clr_led3;
	// UARTs
	input			i_uart_rx;
	output	wire		o_uart_tx;
	// Quad SPI flash
	output	wire		o_qspi_sck, o_qspi_cs_n;
	inout	[3:0]		io_qspi_dat;
	// Ethernet // Not yet implemented
	// Ethernet control (MDIO)
	output	wire		o_eth_mdclk;
	inout	wire		io_eth_mdio;
	// DDR3 SDRAM
	output	wire		o_ddr_reset_n;
	output	wire		o_ddr_cke;
	output	wire		o_ddr_ck_p, o_ddr_ck_n;
	output	wire		o_ddr_cs_n, o_ddr_ras_n, o_ddr_cas_n, o_ddr_we_n;
	inout		[1:0]	io_ddr_dqs_p, io_ddr_dqs_n;
	output	wire	[13:0]	o_ddr_addr;
	output	wire	[2:0]	o_ddr_ba;
	inout		[15:0]	io_ddr_data;
	//
	output	wire	[1:0]	o_ddr_dm;
	output	wire		o_ddr_odt;
	// SD Card
	output	wire		o_sd_sck;
	inout			io_sd_cmd;
	inout		[3:0]	io_sd;
	input			i_sd_cs;
	input			i_sd_wp;
	// GPS PMod
	input			i_gps_pps, i_gps_3df, i_gps_rx;
	output	wire		o_gps_tx;
	// OLEDRGB PMod
	output	wire		o_oled_sck, o_oled_cs_n, o_oled_mosi,
				o_oled_dcn, o_oled_reset_n, o_oled_vccen,
				o_oled_pmoden;
	// Aux UART
	input			i_aux_rx, i_aux_rts;
	output	wire		o_aux_tx, o_aux_cts;
 
`define	FULLCLOCK
	// Build our master clock
	wire	i_clk, clk_for_ddr, clk2_unused, enet_clk, clk_analyzer,
		clk_feedback, clk_locked, clk_analyzer_b;
	PLLE2_BASE	#(
		.BANDWIDTH("OPTIMIZED"),	// OPTIMIZED, HIGH, LOW
		.CLKFBOUT_PHASE(0.0),	// Phase offset in degrees of CLKFB, (-360-360)
		.CLKIN1_PERIOD(10.0),	// Input clock period in ns to ps resolution
`ifdef	FULLCLOCK
		// CLKOUT0_DIVIDE - CLKOUT5_DIVIDE: divide amount for each CLKOUT(1-128)
		.CLKFBOUT_MULT(8),	// Multiply value for all CLKOUT (2-64)
		.CLKOUT0_DIVIDE(4),	// 200 MHz
		.CLKOUT1_DIVIDE(4),	// 200 MHz clock for DDR memory
		.CLKOUT2_DIVIDE(8),	// 100 MHz
		.CLKOUT3_DIVIDE(32),	//  25 MHz
		.CLKOUT4_DIVIDE(1),	// 800 MHz
		.CLKOUT5_DIVIDE(1),
`else
		// 100*64/40 = 160 -- the fastest speed where the UART will 
		// still work at 4MBaud.  Others will still support 115200
		// Baud
		// 100*64/36 = 177.78
		// 100*64/34 = 188.24
		// 100*64/33 = 193.94
		.CLKFBOUT_MULT(8),	// Multiply value for all CLKOUT (2-64)
		.CLKOUT0_DIVIDE(5),	// 160 MHz
		.CLKOUT1_DIVIDE(5),	// 160 MHz //Clock too slow for DDR mem
		.CLKOUT2_DIVIDE(10),	//  80 MHz
		.CLKOUT3_DIVIDE(40),	//  20 MHz
		.CLKOUT4_DIVIDE(1),	//  40 MHz
		.CLKOUT5_DIVIDE(1),
`endif
		// CLKOUT0_DUTY_CYCLE -- Duty cycle for each CLKOUT
		.CLKOUT0_DUTY_CYCLE(0.5),
		.CLKOUT1_DUTY_CYCLE(0.5),
		.CLKOUT2_DUTY_CYCLE(0.5),
		.CLKOUT3_DUTY_CYCLE(0.5),
		.CLKOUT4_DUTY_CYCLE(0.5),
		.CLKOUT5_DUTY_CYCLE(0.5),
		// CLKOUT0_PHASE -- phase offset for each CLKOUT
		.CLKOUT0_PHASE(0.0),
		.CLKOUT1_PHASE(270.0),
		.CLKOUT2_PHASE(0.0),
		.CLKOUT3_PHASE(0.0),
		.CLKOUT4_PHASE(0.0),
		.CLKOUT5_PHASE(180.0),
		.DIVCLK_DIVIDE(1),	// Master division value , (1-56)
		.REF_JITTER1(0.0),	// Reference input jitter in UI (0.000-0.999)
		.STARTUP_WAIT("FALSE")	// Delayu DONE until PLL Locks, ("TRUE"/"FALSE")
	) genclock(
		// Clock outputs: 1-bit (each) output
		.CLKOUT0(i_clk),
		.CLKOUT1(clk_for_ddr),
		.CLKOUT2(clk2_unused), // Reserved for flash, should we need it
		.CLKOUT3(enet_clk),
		.CLKOUT4(clk_analyzer),
		.CLKOUT5(clk_analyzer_b),
		.CLKFBOUT(clk_feedback), // 1-bit output, feedback clock
		.LOCKED(clk_locked),
		.CLKIN1(i_clk_100mhz),
		.PWRDWN(1'b0),
		.RST(1'b0),
		.CLKFBIN(clk_feedback)	// 1-bit input, feedback clock
	);
 
	// UART interface
	wire	[29:0]	bus_uart_setup;
`ifdef	FULLCLOCK
	assign		bus_uart_setup = 30'h10000032; // 4MBaud, 7 bits
`else
	assign		bus_uart_setup = 30'h10000028;//4MBaud,7 bits,@160MHzClk
	//assign	bus_uart_setup = 30'h10000019;//4MBaud,7 bits,@100MHzClk
`endif
 
	wire	[7:0]	rx_data, tx_data;
	wire		rx_break, rx_parity_err, rx_frame_err, rx_stb;
	wire		tx_stb, tx_busy;
 
	reg	pwr_reset, pre_reset;
	initial	pwr_reset = 1'b1;
	initial	pre_reset = 1'b0;
	always @(posedge i_clk)
		pre_reset <= ~i_reset_btn;
	always @(posedge i_clk)
		pwr_reset <= pre_reset;
 
	wire	w_ck_uart, w_uart_tx;
	rxuart	rcv(i_clk, pwr_reset, bus_uart_setup, i_uart_rx,
				rx_stb, rx_data, rx_break,
				rx_parity_err, rx_frame_err, w_ck_uart);
	txuart	txv(i_clk, pwr_reset, bus_uart_setup, 1'b0,
				tx_stb, tx_data, o_uart_tx, tx_busy);
 
 
 
 
 
 
	//////
	//
	//
	// The WB bus interconnect, herein called fastmaster, which handles
	// just about ... everything.
	//
	//
	//////
	wire		w_qspi_sck;
	wire	[1:0]	qspi_bmod;
	wire	[3:0]	qspi_dat;
	wire	[3:0]	i_qspi_dat;
 
	//
	wire	[31:0]	wo_ddr_data, wi_ddr_data;
	wire		w_ddr_dqs, w_ddr_dm, w_ddr_bus_oe, w_ddr_odt;
	wire	[2:0]	w_ddr_ba;
	wire		w_ddr_cs_n, w_ddr_ras_n, w_ddr_cas_n, w_ddr_we_n;
	wire	[13:0]	w_ddr_addr;
	reg	[31:0]	r_ddr_data;
 
	//
	wire		w_mdio, w_mdwe;
	//
	wire		w_sd_cmd;
	wire	[3:0]	w_sd_data;
	fastmaster	wbbus(i_clk, pwr_reset,
		// External USB-UART bus control
		rx_stb, rx_data, tx_stb, tx_data, tx_busy,
		// Board lights and switches
		i_sw, i_btn, o_led,
		o_clr_led0, o_clr_led1, o_clr_led2, o_clr_led3,
		// Board level PMod I/O
		i_aux_rx, o_aux_tx, o_aux_cts, i_gps_rx, o_gps_tx,
		// Quad SPI flash
		o_qspi_cs_n, w_qspi_sck, qspi_dat, io_qspi_dat, qspi_bmod,
		// DDR3 SDRAM
		o_ddr_reset_n, o_ddr_cke,
		w_ddr_cs_n, w_ddr_ras_n, w_ddr_cas_n, w_ddr_we_n,
		w_ddr_dqs, w_ddr_dm, w_ddr_odt, w_ddr_bus_oe,
		w_ddr_addr, w_ddr_ba, wo_ddr_data, r_ddr_data,
		// SD Card
		o_sd_sck, w_sd_cmd, w_sd_data, io_sd_cmd, io_sd, i_sd_cs,
		// Ethernet control (MDIO) lines
		o_eth_mdclk, w_mdio, w_mdwe, io_eth_mdio,
		// OLEDRGB PMod wires
		o_oled_sck, o_oled_cs_n, o_oled_mosi, o_oled_dcn,
		o_oled_reset_n, o_oled_vccen, o_oled_pmoden,
		// GPS PMod
		i_gps_pps, i_gps_3df
		);
 
	//////
	//
	//
	// Some wires need special treatment, and so are not quite completely
	// handled by the bus master.  These are handled below.
	//
	//
	//////
 
	//
	//
	// QSPI)BMOD, Quad SPI bus mode, Bus modes are:
	//	0?	Normal serial mode, one bit in one bit out
	//	10	Quad SPI mode, going out
	//	11	Quad SPI mode coming from the device (read mode)
	//
	//	??	Dual mode in  (not yet)
	//	??	Dual mode out (not yet)
	//
	//
`define	QSPI_OUT_VERSION_ONE
`ifdef	QSPI_OUT_VERSION_ONE
	assign io_qspi_dat = (~qspi_bmod[1])?({2'b11,1'bz,qspi_dat[0]})
				:((qspi_bmod[0])?(4'bzzzz):(qspi_dat[3:0]));
	assign	i_qspi_dat = io_qspi_dat;
	assign	o_qspi_sck = w_qspi_sck;
`else
	wire	[3:0]	i_qspi_ignore;
 
	xoddr	xqspi_sck( i_clk, { w_qspi_sck,  w_qspi_sck }, o_qspi_sck);
	//
	xioddr	xqspi_d0(  i_clk, (~qspi_bmod[0])||(~qspi_bmod[1]),
		{ qspi_dat[0], qspi_dat[0] },
		{ i_qspi_ignore[0], i_qspi_dat[0] }, io_qspi_dat[0]);
	xioddr	xqspi_d1(  i_clk, (qspi_bmod==2'b10),
		{ qspi_dat[1], qspi_dat[1] },
		{ i_qspi_ignore[1], i_qspi_dat[1] }, io_qspi_dat[1]);
	xioddr	xqspi_d2(  i_clk, (qspi_bmod!=2'b11),
		(qspi_bmod[1])?{ qspi_dat[2], qspi_dat[2] }:2'b11,
		{ i_qspi_ignore[2], i_qspi_dat[2] }, io_qspi_dat[2]);
	xioddr	xqspi_d3(  i_clk, (qspi_bmod!=2'b11),
		(qspi_bmod[1])?{ qspi_dat[3], qspi_dat[3] }:2'b11,
		{ i_qspi_ignore[3], i_qspi_dat[3] }, io_qspi_dat[3]);
`endif
 
	//
	// Proposed QSPI mode select, to allow dual I/O mode
	//	000	Normal SPI mode
	//	001	Dual mode input
	//	010	Dual mode, output
	//	101	Quad I/O mode input
	//	110	Quad I/O mode output
	//
	//
	// assign io_qspi_dat[3:2] = (~qspi_bmod[2]) ? 2'b11
	//			: (qspi_bmod[0])?2'bzz : qspi_dat[3:2];
	// assign io_qspi_dat[1] = (~qspi_bmod[1])?qspi_dat[1]:1'bz;
	// assign io_qspi_dat[0] = (qspi_bmod[0])?1'bz : qspi_dat[0];
 
	//
	//
	// The following primitive is necessary on other boards in order to
	// gain access to the o_qspi_sck pin.  On the Arty, however, there is
	// a clock PIN, so we don't need this primitive.
	//
	//
/*
	wire	[3:0]	su_nc;	// Startup primitive, no connect
	STARTUPE2 #(
		// Leave PROG_USR false to avoid activating the program
		// event security feature.  Notes state that such a feature
		// requires encrypted bitstreams.
		.PROG_USR("FALSE"),
		// Sets the configuration clock frequency (in ns) for
		// simulation.
		.SIM_CCLK_FREQ(0.0)
	) STARTUPE2_inst (
	// CFGCLK, 1'b output: Configuration main clock output -- no connect
	.CFGCLK(su_nc[0]),
	// CFGMCLK, 1'b output: Configuration internal oscillator clock output
	.CFGMCLK(su_nc[1]),
	// EOS, 1'b output: Active high output indicating the End Of Startup.
	.EOS(su_nc[2]),
	// PREQ, 1'b output: PROGRAM request to fabric output
	//	Only enabled if PROG_USR is set.  This lets the fabric know
	//	that a request has been made (either JTAG or pin pulled low)
	//	to program the device
	.PREQ(su_nc[3]),
	// CLK, 1'b input: User start-up clock input
	.CLK(1'b0),
	// GSR, 1'b input: Global Set/Reset input
	.GSR(1'b0),
	// GTS, 1'b input: Global 3-state input
	.GTS(1'b0),
	// KEYCLEARB, 1'b input: Clear AES Decrypter Key input from BBRAM
	.KEYCLEARB(1'b0),
	// PACK, 1-bit input: PROGRAM acknowledge input
	//	This pin is only enabled if PROG_USR is set.  This allows the
	//	FPGA to acknowledge a request for reprogram to allow the FPGA
	//	to get itself into a reprogrammable state first.
	.PACK(1'b0),
	// USRCLKO, 1-bit input: User CCLK input -- This is why I am using this
	// module at all.
	.USRCCLKO(qspi_sck),
	// USRCCLKTS, 1'b input: User CCLK 3-state enable input
	//	An active high here places the clock into a high impedence
	//	state.  Since we wish to use the clock as an active output
	//	always, we drive this pin low.
	.USRCCLKTS(1'b0),
	// USRDONEO, 1'b input: User DONE pin output control
	//	Set this to "high" to make sure that the DONE LED pin is
	//	high.
	.USRDONEO(1'b1),
	// USRDONETS, 1'b input: User DONE 3-state enable output
	//	This enables the FPGA DONE pin to be active.  Setting this
	//	active high sets the DONE pin to high impedence, setting it
	//	low allows the output of this pin to be as stated above.
	.USRDONETS(1'b1)
	);
*/
 
 
 
	//
	//
	// Wires for setting up the SD Card Controller
	//
	//
	assign io_sd_cmd = w_sd_cmd ? 1'bz:1'b0;
	assign io_sd[0] = w_sd_data[0]? 1'bz:1'b0;
	assign io_sd[1] = w_sd_data[1]? 1'bz:1'b0;
	assign io_sd[2] = w_sd_data[2]? 1'bz:1'b0;
	assign io_sd[3] = w_sd_data[3]? 1'bz:1'b0;
 
 
	//
	//
	// Wire(s) for setting up the MDIO ethernet control structure
	//
	//
	assign	io_eth_mdio = (w_mdwe)?w_mdio : 1'bz;
 
	//
	//
	// Wires for setting up the DDR3 memory
	//
	//
`ifdef	SDRAM_ACCESS
	reg	[15:0]	bottom_half_data;
	always @(posedge i_clk)
		bottom_half_data <= wo_ddr_data[15:0];
	xioddr	p0(i_clk, w_ddr_bus_oe, { wo_ddr_data[16], wo_ddr_data[0] },
		{ wi_ddr_data[16], wi_ddr_data[0] }, io_ddr_data[0]);
 
	xioddr	p1(i_clk, w_ddr_bus_oe, { wo_ddr_data[17], wo_ddr_data[1] },
		{ wi_ddr_data[17], wi_ddr_data[1] }, io_ddr_data[1]);
 
	xioddr	p2(i_clk, w_ddr_bus_oe, { wo_ddr_data[18], wo_ddr_data[2] },
		{ wi_ddr_data[18], wi_ddr_data[2] }, io_ddr_data[2]);
 
	xioddr	p3(i_clk, w_ddr_bus_oe, { wo_ddr_data[19], wo_ddr_data[3] },
		{ wi_ddr_data[19], wi_ddr_data[3] }, io_ddr_data[3]);
 
	xioddr	p4(i_clk, w_ddr_bus_oe, { wo_ddr_data[20], wo_ddr_data[4] },
		{ wi_ddr_data[20], wi_ddr_data[4] }, io_ddr_data[4]);
 
	xioddr	p5(i_clk, w_ddr_bus_oe, { wo_ddr_data[21], wo_ddr_data[5] },
		{ wi_ddr_data[21], wi_ddr_data[5] }, io_ddr_data[5]);
 
	xioddr	p6(i_clk, w_ddr_bus_oe, { wo_ddr_data[22], wo_ddr_data[6] },
		{ wi_ddr_data[22], wi_ddr_data[6] }, io_ddr_data[6]);
 
	xioddr	p7(i_clk, w_ddr_bus_oe, { wo_ddr_data[23], wo_ddr_data[7] },
		{ wi_ddr_data[23], wi_ddr_data[7] }, io_ddr_data[7]);
 
	xioddr	p8(i_clk, w_ddr_bus_oe, { wo_ddr_data[24], wo_ddr_data[8] },
		{ wi_ddr_data[24], wi_ddr_data[8] }, io_ddr_data[8]);
 
	xioddr	p9(i_clk, w_ddr_bus_oe, { wo_ddr_data[25], wo_ddr_data[9] },
		{ wi_ddr_data[25], wi_ddr_data[9] }, io_ddr_data[9]);
 
	xioddr	pa(i_clk, w_ddr_bus_oe, { wo_ddr_data[26], wo_ddr_data[10] },
		{ wi_ddr_data[26], wi_ddr_data[10] }, io_ddr_data[10]);
 
	xioddr	pb(i_clk, w_ddr_bus_oe, { wo_ddr_data[27], wo_ddr_data[11] },
		{ wi_ddr_data[27], wi_ddr_data[11] }, io_ddr_data[11]);
 
	xioddr	pc(i_clk, w_ddr_bus_oe, { wo_ddr_data[28], wo_ddr_data[12] },
		{ wi_ddr_data[28], wi_ddr_data[12] }, io_ddr_data[12]);
 
	xioddr	pd(i_clk, w_ddr_bus_oe, { wo_ddr_data[29], wo_ddr_data[13] },
		{ wi_ddr_data[29], wi_ddr_data[13] }, io_ddr_data[13]);
 
	xioddr	pe(i_clk, w_ddr_bus_oe, { wo_ddr_data[30], wo_ddr_data[14] },
		{ wi_ddr_data[30], wi_ddr_data[14] }, io_ddr_data[14]);
 
	xioddr	pf(i_clk, w_ddr_bus_oe, { wo_ddr_data[31], wo_ddr_data[15] },
		{ wi_ddr_data[31], wi_ddr_data[15] }, io_ddr_data[15]);
	always @(posedge i_clk)
		r_ddr_data <= wi_ddr_data;
 
	wire	[7:0]	w_dqs_ignore;
	xioddrds	dqs0(clk_for_ddr, w_ddr_dqs, { 1'b0, 1'b1 },
		{ w_dqs_ignore[0], w_dqs_ignore[1] },
		io_ddr_dqs_p[0], io_ddr_dqs_n[0]);
	xioddrds	dqs1(clk_for_ddr, w_ddr_dqs, { 1'b0, 1'b1 },
		{ w_dqs_ignore[2], w_dqs_ignore[3] },
		io_ddr_dqs_p[1], io_ddr_dqs_n[1]);
 
	xoddr	xcs_n( i_clk, { w_ddr_cs_n,  w_ddr_cs_n  }, o_ddr_cs_n);
	xoddr	xras_n(i_clk, { w_ddr_ras_n, w_ddr_ras_n }, o_ddr_ras_n);
	xoddr	xcas_n(i_clk, { w_ddr_cas_n, w_ddr_cas_n }, o_ddr_cas_n);
	xoddr	xwe_n( i_clk, { w_ddr_we_n,  w_ddr_we_n  }, o_ddr_we_n);
	xoddr	xba0(  i_clk, { w_ddr_ba[0], w_ddr_ba[0]  }, o_ddr_ba[0]);
	xoddr	xba1(  i_clk, { w_ddr_ba[1], w_ddr_ba[1]  }, o_ddr_ba[1]);
	xoddr	xba2(  i_clk, { w_ddr_ba[2], w_ddr_ba[2]  }, o_ddr_ba[2]);
	xoddr	xaddr0(i_clk, { w_ddr_addr[0], w_ddr_addr[0] }, o_ddr_addr[0]);
	xoddr	xaddr1(i_clk, { w_ddr_addr[1], w_ddr_addr[1] }, o_ddr_addr[1]);
	xoddr	xaddr2(i_clk, { w_ddr_addr[2], w_ddr_addr[2] }, o_ddr_addr[2]);
	xoddr	xaddr3(i_clk, { w_ddr_addr[3], w_ddr_addr[3] }, o_ddr_addr[3]);
	xoddr	xaddr4(i_clk, { w_ddr_addr[4], w_ddr_addr[4] }, o_ddr_addr[4]);
	xoddr	xaddr5(i_clk, { w_ddr_addr[5], w_ddr_addr[5] }, o_ddr_addr[5]);
	xoddr	xaddr6(i_clk, { w_ddr_addr[6], w_ddr_addr[6] }, o_ddr_addr[6]);
	xoddr	xaddr7(i_clk, { w_ddr_addr[7], w_ddr_addr[7] }, o_ddr_addr[7]);
	xoddr	xaddr8(i_clk, { w_ddr_addr[8], w_ddr_addr[8] }, o_ddr_addr[8]);
	xoddr	xaddr9(i_clk, { w_ddr_addr[9], w_ddr_addr[9] }, o_ddr_addr[9]);
	xoddr	xaddr10(i_clk,{ w_ddr_addr[10],w_ddr_addr[10]}, o_ddr_addr[10]);
	xoddr	xaddr11(i_clk,{ w_ddr_addr[11],w_ddr_addr[11]}, o_ddr_addr[11]);
	xoddr	xaddr12(i_clk,{ w_ddr_addr[12],w_ddr_addr[12]}, o_ddr_addr[12]);
	xoddr	xaddr13(i_clk,{ w_ddr_addr[13],w_ddr_addr[13]}, o_ddr_addr[13]);
 
	wire	w_clk_for_ddr;
	ODDR	#(.DDR_CLK_EDGE("SAME_EDGE"))
		memclkddr(.Q(w_clk_for_ddr), .C(clk_for_ddr), .CE(1'b1),
			.D1(1'b0), .D2(1'b1), .R(1'b0), .S(1'b0));
	OBUFDS	#(.IOSTANDARD("DIFF_SSTL135"), .SLEW("FAST"))
		clkbuf(.O(o_ddr_ck_p), .OB(o_ddr_ck_n), .I(w_clk_for_ddr));
 
	// assign	o_ddr_dm[0] = w_ddr_dm;
	// assign	o_ddr_dm[1] = w_ddr_dm;
	xoddr	xdm0(i_clk,{ w_ddr_dm, w_ddr_dm }, o_ddr_dm[0]);
	xoddr	xdm1(i_clk,{ w_ddr_dm, w_ddr_dm }, o_ddr_dm[1]);
 
	assign	o_ddr_odt = (~o_ddr_reset_n)? 1'bz : w_ddr_odt;
 
	// xlogicanalyzer ladata(i_clk, io_ddr_data[0], w_ddr_debug[3:0]);
	// xlogicanalyzer ladclk(clk_analyzer, clk_analyzer_b,
		// i_clk, o_ddr_ck_p, w_ddr_debug[7:4]);
	assign w_ddr_debug[7:4] = 4'h0;
	assign w_ddr_debug[3:0] = 4'h0;
`else
	assign	o_ddr_cs_n = w_ddr_cs_n;
	assign	o_ddr_ras_n = w_ddr_ras_n;
	assign	o_ddr_cas_n = w_ddr_cas_n;
	assign	o_ddr_we_n = w_ddr_we_n;
	//
	assign	o_ddr_ba = w_ddr_ba;
	assign	o_ddr_addr = w_ddr_addr;
	//
	assign	o_ddr_dm[1:0] = 2'b00;
	assign	o_ddr_odt     = 1'b0;
	//
	assign	io_ddr_data = 16'bzzzz_zzzz_zzzz_zzzz;
	always @(posedge i_clk)
		r_ddr_data = 16'h0000;
 
	//wire	w_clk_for_ddr;
	//ODDR	#(.DDR_CLK_EDGE("SAME_EDGE"))
		//memclkddr(.Q(w_clk_for_ddr), .C(clk_for_ddr), .CE(1'b1),
			//.D1(1'b0), .D2(1'b1), .R(1'b0), .S(1'b0));
	OBUFDS	#(.IOSTANDARD("DIFF_SSTL135"), .SLEW("FAST"))
		clkbuf(.O(o_ddr_ck_p), .OB(o_ddr_ck_n), .I(1'b1));
 
	wire	[7:0]	w_dqs_ignore;
	xioddrds	dqs0(clk_for_ddr, w_ddr_dqs, { 1'b0, 1'b1 },
		{ w_dqs_ignore[0], w_dqs_ignore[1] },
		io_ddr_dqs_p[0], io_ddr_dqs_n[0]);
	xioddrds	dqs1(clk_for_ddr, w_ddr_dqs, { 1'b0, 1'b1 },
		{ w_dqs_ignore[2], w_dqs_ignore[3] },
		io_ddr_dqs_p[1], io_ddr_dqs_n[1]);
 
 
`endif
 
endmodule