usb_ocp_test.cpp

USB 1.1 PHY的代码

				wait(clk2.posedge_event());

				while (s_flag.read()[0]) {
					m_cmd.write(0x0);
					wait(clk2.posedge_event());
					wait(clk2.posedge_event());
				}

				if (buffer1[n + (pl_sz * no_pack)] != s_data.read()) {
					cout << "ERROR: DATA mismatch. Expected: " << buffer1[n + (pl_sz * no_pack)] << ", Got: " << s_data.read() <<
						" (" << sc_simulation_time() << ")" << endl << endl;
					error_cnt++;
				}

				m_cmd.write(0x2);
				wait(clk2.posedge_event());
				wait(clk2.negedge_event());
			}
			m_cmd.write(0x0);
			wait(clk2.posedge_event());

			no_pack++;
			if (no_pack == no_pack_max)
				break;
		}
		wait(clk.posedge_event());
	}

	m_cmd.write(0x4);
	m_addr.write(0x00000000);

	cout << endl;

	show_errors();

	cout << "**************************************************" << endl;
	cout << "*** TEST DONE ...                              ***" << endl;
	cout << "**************************************************" << endl << endl;
}

// INT IN Test -> Endpoint 5
void in5(void) {
	sc_uint<7> my_fa;
	int rlen, fc;
	sc_uint<8> fd;
	int pack_cnt, pack_cnt_max, pack_sz, pack_sz_max;
	sc_uint<8> x;
	sc_uint<4> pid, expect_pid;
	sc_uint<32> data;
	bool pid_cnt;

	cout << endl;

	cout << "**************************************************" << endl;
	cout << "*** INTERRUPT IN EP TEST 5                     ***" << endl;
	cout << "**************************************************" << endl << endl;

	send_sof(0x000);

	pack_sz_max = 64;
	pack_cnt_max = 4;

	pid_cnt = false;
	my_fa = 0x12;

	m_addr.write(0x00000005);
		m_cmd.write(0x0);

	for (pack_sz = 0; pack_sz <= pack_sz_max; pack_sz += 8) {
		cout << "PL Size: " << pack_sz << endl;

		for (pack_cnt = 0; pack_cnt < pack_cnt_max; pack_cnt++) {
			buffer1_last = 0;
			for (fc = 0; fc < pack_sz; fc++) {
				while (s_flag.read()[1])
					wait(clk.posedge_event());

				x = (sc_uint<8>)(255.0 * rand() / (RAND_MAX + 1.0));
				m_data.write(x);
				buffer0[fc] = x;
				m_cmd.write(0x1);
				wait(clk.posedge_event());
				m_cmd.write(0x0);
				wait(clk.posedge_event());
			}
			m_cmd.write(0x0);
			wait(clk.posedge_event());

			// Send Data
			wait(clk.posedge_event());
			send_sof(0x000);
			wait(clk.posedge_event());
			send_token(my_fa, 5, USBF_T_PID_IN);
			wait(clk.posedge_event());

			recv_packet(&pid, &rlen);

			if (pack_sz == 0)
				expect_pid = 0xa;
			else if (pid_cnt)
				expect_pid = 0xb;
			else
				expect_pid = 0x3;
//			expect_pid = 0x3;

			if (pid != expect_pid) {
				cout << "ERROR: PID mismatch. Expected: " << expect_pid << ", Got: " << pid <<
						" (" << sc_simulation_time() << ")" << endl << endl;
				error_cnt++;
			}
			pid_cnt = !pid_cnt;

			if (rlen != pack_sz) {
				cout << "ERROR: Size mismatch. Expected: " << pack_sz << ", Got: " << rlen <<
						" (" << sc_simulation_time() << ")" << endl << endl;
				error_cnt++;
			}

			for (i = 0; i < 4; i++)
				wait(clk.posedge_event());

			if (pack_sz != 0) {
				send_token(my_fa, 5, USBF_T_PID_ACK);

				for (i = 0; i < 5; i++)
					wait(clk.posedge_event());
			}

			// Verify Data
			for (fc = 0; fc < pack_sz; fc++) {
				x = buffer0[fc];
				if (buffer1[fc] != x) {
					cout << "ERROR: Data (" << fc << ") mismatch. Expected: " << x << ", Got: " << buffer1[fc] <<
							" (" << sc_simulation_time() << ")" << endl << endl;
					error_cnt++;
				}
			}
		}
		for (i = 0; i < 50; i++)
			wait(clk.posedge_event());
	}
	m_cmd.write(0x4);
	m_addr.write(0x00000000);

	cout << endl;

	show_errors();

	cout << "**************************************************" << endl;
	cout << "*** TEST DONE ...                              ***" << endl;
	cout << "**************************************************" << endl << endl;
}

// INT OUT Test -> Endpoint 6
void out6(void) {
	sc_uint<7> my_fa;
	sc_uint<32> data;
	int n, len, no_pack, no_pack_max, pl_sz, pl_sz_max;
	bool pid;
	sc_uint<8> x;

	cout << endl;

	cout << "**************************************************" << endl;
	cout << "*** INTERRUPT OUT EP TEST 6                    ***" << endl;
	cout << "**************************************************" << endl << endl;

	no_pack_max = 4;
	pl_sz_max = 64;

	my_fa = 0x12;

	m_addr.write(0x00000006);
	m_cmd.write(0x0);

	for (pl_sz = 0; pl_sz <= pl_sz_max; pl_sz += 8) {
		pid = false;

		cout << "PL Size: " << pl_sz << endl;

		for (n = 0; n < 4096; n++)
			buffer1[n] = n;

		buffer1_last = 0;

		no_pack = 0;
		while (true) {
			wait(clk.posedge_event());
			send_sof(0x000);
			wait(clk.posedge_event());

			send_token(my_fa, 6, USBF_T_PID_OUT);
			wait(clk.posedge_event());

			if (!pid)
				send_data(USBF_T_PID_DATA0, pl_sz, 1);
			else
				send_data(USBF_T_PID_DATA1, pl_sz, 1);
			pid = !pid;

			utmi_recv_pack(&len);

			if (txmem[0] != 0xd2) {
				cout << "ERROR: ACK mismatch. Expected: 0xd2, Got: " << txmem[0] <<
						" (" << sc_simulation_time() << ")" << endl << endl;
				error_cnt++;
			}

			if (len != 1) {
				cout << "ERROR: Size mismatch. Expected: 1, Got: " << len <<
						" (" << sc_simulation_time() << ")" << endl << endl;
				error_cnt++;
			}

			wait(clk.posedge_event());

			for (i = 0; i < 10; i++)
				wait(clk2.posedge_event());
			for (n = 0; n < pl_sz; n++) {
				m_cmd.write(0x0);
				wait(clk2.posedge_event());
				wait(clk2.posedge_event());

				while (s_flag.read()[0]) {
					m_cmd.write(0x0);
					wait(clk2.posedge_event());
					wait(clk2.posedge_event());
				}

				if (buffer1[n + (pl_sz * no_pack)] != s_data.read()) {
					cout << "ERROR: DATA mismatch. Expected: " << buffer1[n + (pl_sz * no_pack)] << ", Got: " << s_data.read() <<
						" (" << sc_simulation_time() << ")" << endl << endl;
					error_cnt++;
				}

				m_cmd.write(0x2);
				wait(clk2.posedge_event());
				wait(clk2.negedge_event());
			}
			m_cmd.write(0x0);
			wait(clk2.posedge_event());

			no_pack++;
			if (no_pack == no_pack_max)
				break;
		}
		wait(clk.posedge_event());
	}

	m_cmd.write(0x4);
	m_addr.write(0x00000000);

	cout << endl;

	show_errors();

	cout << "**************************************************" << endl;
	cout << "*** TEST DONE ...                              ***" << endl;
	cout << "**************************************************" << endl << endl;
}

/////////////////////////////////////////////////////////////////////

	void rx1_update(void) {
		rxdp.write(!usb_reset.read() && txdp2.read());
		rxdn.write(!usb_reset.read() && txdn2.read());
	}

	void rx2_update(void) {
		rxdp2.write(!usb_reset.read() && txdp.read());
		rxdn2.write(!usb_reset.read() && txdn.read());
	}

	void watchdog(void) {
		if (txdp.read() || txdp2.read())
			wd_cnt.write(0);
		else
			wd_cnt.write(wd_cnt.read() + 1);
	}

	void wd_cnt_mon(void) {
		if (wd_cnt.read() > 5000) {
			cout << "**********************************" << endl;
			cout << "ERROR: Watch Dog Counter Expired" << endl;
			cout << "**********************************" << endl << endl;
			sc_stop();
		}
	}

	void init(void) {
		usb_reset.write(false);
		tx_valid.write(false);
		error_cnt = 0;
		wd_cnt.write(0);
		rst.write(false);
		m_cmd.write(0x4);
		m_addr.write(0x00000000);

		for (i = 0; i < 10; i++) wait(clk.posedge_event());
		rst.write(true);

		for (i = 0; i < 50; i++) wait(clk.posedge_event());
		usb_reset.write(true);

		for (i = 0; i < 300; i++) wait(clk.posedge_event());
		usb_reset.write(false);

		for (i = 0; i < 10; i++) wait(clk.posedge_event());

		setup0();
		in1();
		out2();
		in3();
		out4();
		in5();
		out6();

		for (i = 0; i < 500; i++) wait(clk.posedge_event());
		sc_stop();
	}

	SC_CTOR(test) {
		SC_METHOD(rx1_update);
		sensitive << usb_reset << txdp2 << txdn2;
		SC_METHOD(rx2_update);
		sensitive << usb_reset << txdp << txdn;
		SC_METHOD(watchdog);
		sensitive << clk.pos();
		SC_METHOD(wd_cnt_mon);
		sensitive << wd_cnt;
		SC_THREAD(init);
		sensitive << clk.pos();
	}
};

int sc_main(int argc, char *argv[]) {

	sc_set_time_resolution(1.0, SC_NS);

	sc_clock clk("clock", 20.84, SC_NS);
	sc_clock clk2("clock2", 20.84, SC_NS);

	sc_signal<bool>	rst, vcc;

	sc_signal<bool>	rx_dp1, rx_dn1, tx_dp1, tx_dn1;
	sc_signal<bool>	tb_rx_valid, tb_rx_active, tb_rx_error;
	sc_signal<bool>	tb_tx_valid, tb_tx_ready;
	sc_signal<sc_uint<8> > tb_rx_data, tb_tx_data;

	sc_signal<bool>	rx_dp2, rx_dn2, tx_dp2, tx_dn2;
	sc_signal<sc_uint<8> >	SData, MData, SFlag;
	sc_signal<sc_uint<32> > MAddr;
	sc_signal<sc_uint<3> > MCmd;
	sc_signal<sc_uint<2> > SResp;
	sc_signal<bool> SInterrupt, SError, SCmdAccept;

	sc_signal<bool> usb_rst_nc, txoe_nc, tx_oe_nc;
	sc_signal<sc_uint<2> > line_nc;

	usb_phy			i_phy("HOST_PHY");
	usb_ocp			i_ocp("USB_OCP");
	test			i_test("TEST");

	i_phy.clk(clk);
	i_phy.rst(rst);
	i_phy.phy_tx_mode(vcc);
	i_phy.usb_rst(usb_rst_nc);
	i_phy.txdp(tx_dp1);
	i_phy.txdn(tx_dn1);
	i_phy.txoe(txoe_nc);
	i_phy.rxd(rx_dp1);
	i_phy.rxdp(rx_dp1);
	i_phy.rxdn(rx_dn1);
	i_phy.DataOut_i(tb_tx_data);
	i_phy.TxValid_i(tb_tx_valid);
	i_phy.TxReady_o(tb_tx_ready);
	i_phy.DataIn_o(tb_rx_data);
	i_phy.RxValid_o(tb_rx_valid);
	i_phy.RxActive_o(tb_rx_active);
	i_phy.RxError_o(tb_rx_error);
	i_phy.LineState_o(line_nc);

	i_ocp.Clk(clk2);
	i_ocp.Reset_n(rst);
	i_ocp.tx_dp(tx_dp2);
	i_ocp.tx_dn(tx_dn2);
	i_ocp.tx_oe(tx_oe_nc);
	i_ocp.rx_dp(rx_dp2);
	i_ocp.rx_dn(rx_dn2);
	i_ocp.rx_d(rx_dp2);
	i_ocp.SInterrupt(SInterrupt);
	i_ocp.SFlag(SFlag);
	i_ocp.SError(SError);
	i_ocp.MAddr(MAddr);
	i_ocp.MCmd(MCmd);
	i_ocp.MData(MData);
	i_ocp.SCmdAccept(SCmdAccept);
	i_ocp.SData(SData);
	i_ocp.SResp(SResp);

	i_test.clk(clk);
	i_test.rst(rst);
	i_test.txdp(tx_dp1);
	i_test.txdn(tx_dn1);
	i_test.rxdp(rx_dp1);
	i_test.rxdn(rx_dn1);
	i_test.dout(tb_tx_data);
	i_test.tx_valid(tb_tx_valid);
	i_test.tx_ready(tb_tx_ready);
	i_test.din(tb_rx_data);
	i_test.rx_valid(tb_rx_valid);
	i_test.rx_active(tb_rx_active);
	i_test.rx_error(tb_rx_error);

	i_test.clk2(clk2);
	i_test.txdp2(tx_dp2);
	i_test.txdn2(tx_dn2);
	i_test.rxdp2(rx_dp2);
	i_test.rxdn2(rx_dn2);
	i_test.s_int(SInterrupt);
	i_test.s_flag(SFlag);
	i_test.s_error(SError);
	i_test.m_addr(MAddr);
	i_test.m_cmd(MCmd);
	i_test.m_data(MData);
	i_test.s_cmd_accept(SCmdAccept);
	i_test.s_data(SData);
	i_test.s_resp(SResp);

	vcc.write(true);

#ifdef VCD_OUTPUT_ENABLE
	sc_trace_file *vcd_log = sc_create_vcd_trace_file("USB_TEST");
	sc_trace(vcd_log, clk2, "Clk");
	sc_trace(vcd_log, rst, "Reset_n");
	sc_trace(vcd_log, MAddr, "MAddr");
	sc_trace(vcd_log, MCmd, "MCmd");
	sc_trace(vcd_log, MData, "MData");
	sc_trace(vcd_log, SData, "SData");
	sc_trace(vcd_log, SCmdAccept, "SCmdAccept");
	sc_trace(vcd_log, SResp, "SResp");
#endif

#ifdef WIF_OUTPUT_ENABLE
	sc_trace_file *wif_log = sc_create_wif_trace_file("USB_TEST");
	sc_trace(wif_log, clk2, "Clk");
	sc_trace(wif_log, rst, "Reset_n");
	sc_trace(wif_log, MAddr, "MAddr");
	sc_trace(wif_log, MCmd, "MCmd");
	sc_trace(wif_log, MData, "MData");
	sc_trace(wif_log, SData, "SData");
	sc_trace(wif_log, SCmdAccept, "SCmdAccept");
	sc_trace(wif_log, SResp, "SResp");
#endif

	srand((unsigned int)(time(NULL) & 0xffffffff));
	sc_start();

#ifdef VCD_OUTPUT_ENABLE
	sc_close_vcd_trace_file(vcd_log);
#endif

#ifdef WIF_OUTPUT_ENABLE
	sc_close_wif_trace_file(wif_log);
#endif

	return 0;
}