usb_ocp.h

USB 1.1 PHY的代码

/////////////////////////////////////////////////////////////////////
////                                                             ////
////  USB 1.1 Top Module                                         ////
////  Function Interface                                         ////
////  OCP Interface                                              ////
////                                                             ////
////  SystemC Version: usb_ocp.h                                 ////
////  Author: Alfredo Luiz Foltran Fialho                        ////
////          [e-mail]                                ////
////                                                             ////
////                                                             ////
/////////////////////////////////////////////////////////////////////
////                                                             ////
//// Verilog Version: usb_ocp_if.v                               ////
//// Copyright (C) 2004      Alfredo Luiz Foltran Fialho         ////
////                         [e-mail]                 ////
////                                                             ////
//// This source file may be used and distributed without        ////
//// restriction provided that this copyright statement is not   ////
//// removed from the file and that any derivative work contains ////
//// the original copyright notice and the associated disclaimer.////
////                                                             ////
////     THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY     ////
//// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED   ////
//// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS   ////
//// FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL THE AUTHOR      ////
//// OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,         ////
//// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES    ////
//// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE   ////
//// GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR        ////
//// BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF  ////
//// LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT  ////
//// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT  ////
//// OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE         ////
//// POSSIBILITY OF SUCH DAMAGE.                                 ////
////                                                             ////
/////////////////////////////////////////////////////////////////////

#ifndef USB_OCP_H
#define USB_OCP_H

#include "usb.h"

// Command Encoding -> MCmd[2:0]
enum COMMAND {	OCP_IDLE = 0,
				OCP_WR = 1,
				OCP_RD = 2,
				OCP_RDEX = 3,
				// 100..110 -> Reserved,
				OCP_BCST = 7};

// Response Encoding -> SResp[1:0]
enum RESPONSE {	OCP_NULL = 0,
				OCP_DVA = 1,
				// 10 -> Reserved
				OCP_ERR = 3};

SC_MODULE(usb_ocp) {

  private:

	sc_signal<bool>	vcc;
	sc_signal<bool>	usb_rst_nc;

  public:

	sc_in<bool>			Clk;					// Basic Signal -> Clock signal
	sc_in<bool>			Reset_n;				// Sideband Signal -> Reset signal

	// PHY Interface
	sc_out<bool>		tx_dp, tx_dn, tx_oe;
	sc_in<bool>			rx_dp, rx_dn, rx_d;

	// Sideband Interface
	sc_out<bool>		SInterrupt;				// Interrupt
	sc_out<sc_uint<8> >	SFlag;					// Flags
	sc_out<bool>		SError;					// Error Indicator

	// Basic Interface
	sc_in<sc_uint<32> >	MAddr;
	sc_in<sc_uint<3> >	MCmd;
	sc_in<sc_uint<8> >	MData;
	sc_out<bool>		SCmdAccept;
	sc_out<sc_uint<8> >	SData;
	sc_out<sc_uint<2> >	SResp;

	// Local Signals

	sc_signal<bool>			empty;
	sc_signal<bool>			full;

	// Vendor Signals
	sc_signal<sc_uint<16> >	wValue;
	sc_signal<sc_uint<16> >	wIndex;
	sc_signal<sc_uint<16> >	vendor_data;

	// SFlag Signals
	sc_signal<bool>			SF_busy;
	sc_signal<sc_uint<4> >	SF_sel;
	sc_signal<bool>			SF_feature;

	// Endpoint Interface
	// EP1
	sc_signal<sc_uint<8> >	ep1_f_din;
	sc_signal<bool>			ep1_f_we;
	sc_signal<bool>			ep1_f_full;

	// EP2
	sc_signal<sc_uint<8> >	ep2_f_dout;
	sc_signal<bool>			ep2_f_re;
	sc_signal<bool>			ep2_f_empty;

	// EP3
	sc_signal<sc_uint<8> >	ep3_f_din;
	sc_signal<bool>			ep3_f_we;
	sc_signal<bool>			ep3_f_full;

	// EP4
	sc_signal<sc_uint<8> >	ep4_f_dout;
	sc_signal<bool>			ep4_f_re;
	sc_signal<bool>			ep4_f_empty;

	// EP5
	sc_signal<sc_uint<8> >	ep5_f_din;
	sc_signal<bool>			ep5_f_we;
	sc_signal<bool>			ep5_f_full;

	// EP6
	sc_signal<sc_uint<8> >	ep6_f_dout;
	sc_signal<bool>			ep6_f_re;
	sc_signal<bool>			ep6_f_empty;

	usb						*i_usb;			// USB

	// Mux Function
	void mux(void);
	void sflag_up(void);
	void sresp_up(void);

	// Destructor
//	~usb_ocp(void);

	SC_CTOR(usb_ocp) {
		vcc.write(true);

		SC_METHOD(mux);
		sensitive << MAddr << MCmd << MData;
		sensitive << ep1_f_full << ep2_f_dout << ep2_f_empty;
		sensitive << ep3_f_full << ep4_f_dout << ep4_f_empty;
		sensitive << ep5_f_full << ep6_f_dout << ep6_f_empty;
		sensitive << wValue << wIndex;
		SC_METHOD(sflag_up);
		sensitive << empty << full << SF_busy << SF_sel << SF_feature;
		SC_METHOD(sresp_up);
		sensitive << Clk.pos();

		// USB Instantiation and Binding
		i_usb = new usb("USB");
		i_usb->clk_i(Clk);
		i_usb->rst_i(Reset_n);
		i_usb->tx_dp(tx_dp);
		i_usb->tx_dn(tx_dn);
		i_usb->tx_oe(tx_oe);
		i_usb->rx_dp(rx_dp);
		i_usb->rx_dn(rx_dn);
		i_usb->rx_d(rx_d);
		i_usb->phy_tx_mode(vcc);
		i_usb->usb_rst(usb_rst_nc);
		i_usb->crc16_err(SError);
		i_usb->v_set_int(SInterrupt);
		i_usb->v_set_feature(SF_feature);
		i_usb->wValue(wValue);
		i_usb->wIndex(wIndex);
		i_usb->vendor_data(vendor_data);
		i_usb->usb_busy(SF_busy);
		i_usb->ep_sel(SF_sel);
		i_usb->ep1_f_din(ep1_f_din);
		i_usb->ep1_f_we(ep1_f_we);
		i_usb->ep1_f_full(ep1_f_full);
		i_usb->ep2_f_dout(ep2_f_dout);
		i_usb->ep2_f_re(ep2_f_re);
		i_usb->ep2_f_empty(ep2_f_empty);
		i_usb->ep3_f_din(ep3_f_din);
		i_usb->ep3_f_we(ep3_f_we);
		i_usb->ep3_f_full(ep3_f_full);
		i_usb->ep4_f_dout(ep4_f_dout);
		i_usb->ep4_f_re(ep4_f_re);
		i_usb->ep4_f_empty(ep4_f_empty);
		i_usb->ep5_f_din(ep5_f_din);
		i_usb->ep5_f_we(ep5_f_we);
		i_usb->ep5_f_full(ep5_f_full);
		i_usb->ep6_f_dout(ep6_f_dout);
		i_usb->ep6_f_re(ep6_f_re);
		i_usb->ep6_f_empty(ep6_f_empty);
	}

};

#endif