Subversion Repositories usb11

/////////////////////////////////////////////////////////////////////
////                                                             ////
////  USB Packet Disassembler                                    ////
////                                                             ////
////  SystemC Version: usb_pd_sie.h                              ////
////  Author: Alfredo Luiz Foltran Fialho                        ////
////          alfoltran@ig.com.br                                ////
////                                                             ////
////                                                             ////
/////////////////////////////////////////////////////////////////////
////                                                             ////
//// Verilog Version: usb1_pd.v                                  ////
//// Copyright (C) 2000-2002 Rudolf Usselmann                    ////
////                         www.asics.ws                        ////
////                         rudi@asics.ws                       ////
////                                                             ////
//// 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_PD_SIE_H
#define USB_PD_SIE_H
 
#include "usb_defines.h"
#include "usb_crc5.h"
#include "usb_crc16.h"
 
enum PD_STATE {	PD_IDLE = 1,
				PD_ACTIVE = 2,
				PD_TOKEN = 4,
				PD_DATA = 8};
 
SC_MODULE(usb_pd_sie) {
 
  public:
 
	sc_in<bool>			clk;
	sc_in<bool>			rst;
 
	// RX Interface
	sc_in<sc_uint<8> >	rx_data;
	sc_in<bool>			rx_valid, rx_active, rx_err;
 
	// PID Information
	// Decoded PIDs (used when token_valid is asserted)
	sc_out<bool>		pid_OUT, pid_IN, pid_SOF, pid_SETUP;
	sc_out<bool>		pid_DATA0, pid_DATA1, pid_DATA2, pid_MDATA;
	sc_out<bool>		pid_ACK, pid_NACK, pid_STALL, pid_NYET;
	sc_out<bool>		pid_PRE, pid_ERR, pid_SPLIT, pid_PING;
	sc_out<bool>		pid_cks_err;								// Indicates a PID checksum error
 
	// Token Information
	sc_out<sc_uint<7> >	token_fadr;									// Function address from token
	sc_out<sc_uint<4> >	token_endp;									// Endpoint number from token
	sc_out<bool>		token_valid;								// Token is valid
	sc_out<bool>		crc5_err;									// Token CRC5 error
	sc_out<sc_uint<11> >frame_no;									// Frame number for SOF tokens
 
	// Receive Data Output
	sc_out<sc_uint<8> >	rx_data_st;									// Data to memory store unit
	sc_out<bool>		rx_data_valid;								// Data on rx_data_st is valid
	sc_out<bool>		rx_data_done;								// Indicates end of a transfer
	sc_out<bool>		crc16_err;									// Data packet CRC16 error
 
	// Misc
	sc_out<bool>		seq_err;									// State Machine Sequence Error
	sc_out<bool>		rx_busy;									// Receiving Data Packet
 
	// Local Signals
	sc_signal<sc_uint<4> >	state, next_state;// synopsys state_vector state
	sc_signal<sc_uint<8> >	pid;									// Packet PID
	sc_signal<bool>			pid_le_sm;								// PID load enable from State Machine
	sc_signal<bool>			pid_ld_en;								// Enable loading of PID (all conditions)
	sc_signal<bool>			pid_RES;
	sc_signal<bool>			pid_TOKEN;								// All TOKEN packet that we recognize
	sc_signal<bool>			pid_DATA;								// All DATA packet that we recognize
	sc_signal<sc_uint<8> >	token0, token1;							// Token registers
	sc_signal<bool>			token_le_1, token_le_2;					// Latch enables for token storage registers
	sc_signal<sc_uint<5> >	token_crc5;
	sc_signal<sc_uint<8> >	d0, d1, d2;								// Data path delay line (used to filter out crcs)
	sc_signal<bool>			data_valid_d;							// Data valid output from State Machine
	sc_signal<bool>			data_done;								// Data cycle complete output from State Machine
	sc_signal<bool>			data_valid0;							// Data valid delay line
	sc_signal<bool>			rxv1, rxv2;
	sc_signal<bool>			pid_ack;
	sc_signal<bool>			token_valid_r1;
	sc_signal<bool>			token_valid_str1;
	sc_signal<bool>			rx_active_r;
	sc_signal<bool>			rx_busy_d;
	sc_signal<sc_uint<5> >	crc5_out, crc5_out2;
	sc_signal<sc_uint<5> >	crc5_pol;
	sc_signal<sc_uint<11> >	crc5_din;
	sc_signal<bool>			crc16_clr;
	sc_signal<sc_uint<16> >	crc16_sum, crc16_out;
	sc_signal<sc_uint<8> >	crc16_din;
 
	usb_crc5				*i_crc5;								// CRC5 Calculator
	usb_crc16				*i_crc16;								// CRC16 Calculator
 
	// Busy Logic Functions
	void rx_busy_up1(void);
	void rx_busy_up2(void);
 
	// PID Decoding Logic Functions
	void pid_ld_up(void);
	void pid_up(void);
	void pid_cks_err_up(void);
	void pid_decoder(void);
	void pid_token_up(void);
	void pid_data_up(void);
 
	// Token Decoding Logic Functions
	void token_decoder(void);
	void token_valid_up1(void);
	void token_valid_up2(void);
	void token_valid_up3(void);
	void token_up(void);
 
	// CRC5 Logic Functions
	void crc5_din_up(void);
	void crc5_err_up(void);
	void crc5_out2_up(void);
 
	// Data Receiving Logic Functions
	void rxv1_up(void);
	void rxv2_up(void);
	void data_valid0_up(void);
	void d_up(void);
	void rx_data_st_up(void);
	void rx_data_valid_up(void);
	void rx_data_done_up(void);
 
	// CRC16 Logic Functions
	void rx_active_r_up(void);
	void crc16_din_up(void);
	void crc16_clr_up(void);
	void crc16_sum_up(void);
	void crc16_err_up(void);
 
	// Receive/Decode State Machine Functions
	void state_up(void);
	void pd_statemachine(void);
 
	// Destructor
//	~usb_pd_sie(void);
 
	SC_CTOR(usb_pd_sie) {
		crc5_pol.write(31);
 
		SC_METHOD(rx_busy_up1);
		sensitive << clk.pos() << rst.neg();
		SC_METHOD(rx_busy_up2);
		sensitive << clk.pos();
 
		SC_METHOD(pid_ld_up);
		sensitive << pid_le_sm << rx_active << rx_valid;
		SC_METHOD(pid_up);
		sensitive << clk.pos() << rst.neg();
		SC_METHOD(pid_cks_err_up);
		sensitive << pid;
		SC_METHOD(pid_decoder);
		sensitive << pid;
		SC_METHOD(pid_token_up);
		sensitive << pid_OUT << pid_IN << pid_SOF << pid_SETUP << pid_PING;
		SC_METHOD(pid_data_up);
		sensitive << pid_DATA0 << pid_DATA1 << pid_DATA2 << pid_MDATA;
 
		SC_METHOD(token_decoder);
		sensitive << clk.pos();
		SC_METHOD(token_valid_up1);
		sensitive << clk.pos();
		SC_METHOD(token_valid_up2);
		sensitive << clk.pos();
		SC_METHOD(token_valid_up3);
		sensitive << token_valid_str1;
		SC_METHOD(token_up);
		sensitive << token0 << token1;
 
		SC_METHOD(crc5_din_up);
		sensitive << token_fadr << token_endp;
		SC_METHOD(crc5_err_up);
		sensitive << token_valid << crc5_out2 << token_crc5;
		SC_METHOD(crc5_out2_up);
		sensitive << crc5_out;
 
		SC_METHOD(rxv1_up);
		sensitive << clk.pos() << rst.neg();
		SC_METHOD(rxv2_up);
		sensitive << clk.pos() << rst.neg();
		SC_METHOD(data_valid0_up);
		sensitive << clk.pos();
		SC_METHOD(d_up);
		sensitive << clk.pos();
		SC_METHOD(rx_data_st_up);
		sensitive << d2;
		SC_METHOD(rx_data_valid_up);
		sensitive << data_valid0;
		SC_METHOD(rx_data_done_up);
		sensitive << data_done;
 
		SC_METHOD(rx_active_r_up);
		sensitive << clk.pos();
		SC_METHOD(crc16_din_up);
		sensitive << rx_data;
		SC_METHOD(crc16_clr_up);
		sensitive << rx_active << rx_active_r;
		SC_METHOD(crc16_sum_up);
		sensitive << clk.pos();
		SC_METHOD(crc16_err_up);
		sensitive << data_done << crc16_sum;
 
		SC_METHOD(state_up);
		sensitive << clk.pos() << rst.neg();
		SC_METHOD(pd_statemachine);
		sensitive << state << rx_valid << rx_active << rx_err << pid_ACK << pid_TOKEN << pid_DATA;
 
		// CRC5 Calculator Instantiation and Binding
		i_crc5 = new usb_crc5("CRC5");
		i_crc5->crc_in(crc5_pol);
		i_crc5->din(crc5_din);
		i_crc5->crc_out(crc5_out);
 
		// CRC16 Calculator Instantiation and Binding
		i_crc16 = new usb_crc16("CRC16");
		i_crc16->crc_in(crc16_sum);
		i_crc16->din(crc16_din);
		i_crc16->crc_out(crc16_out);
	}
 
};
 
#endif