Initial commit of OpenSPARC T2 design and verification files.

[OpenSPARC-T2-DV] / verif / env / fnx / vlib / FNXPCIEXactor / src / FNXPCIEXactorBuilder.vr

// ========== Copyright Header Begin ==========================================
// 
// OpenSPARC T2 Processor File: FNXPCIEXactorBuilder.vr
// Copyright (C) 1995-2007 Sun Microsystems, Inc. All Rights Reserved
// 4150 Network Circle, Santa Clara, California 95054, U.S.A.
//
// * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; version 2 of the License.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY 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; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
// 
// For the avoidance of doubt, and except that if any non-GPL license 
// choice is available it will apply instead, Sun elects to use only 
// the General Public License version 2 (GPLv2) at this time for any 
// software where a choice of GPL license versions is made 
// available with the language indicating that GPLv2 or any later version 
// may be used, or where a choice of which version of the GPL is applied is 
// otherwise unspecified. 
//
// Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, 
// CA 95054 USA or visit www.sun.com if you need additional information or 
// have any questions. 
// 
// ========== Copyright Header End ============================================
#include <vera_defines.vrh>

// XactorFmwork and XactorComponents libraries
#include "XactorBaseBuilder.vrh"
#include "XactorBasePacket.vrh"
#include "XactorBaseSignalInterface.vrh"
#include "XactorBaseManager.vrh"
#include "XactorManager.vrh"
#include "XactorHash.vrh"
#include "XactorBinTree.vrh"
#include "XactorList.vrh"
#include "XactorListWildCard.vrh"
#include "XactorCtrl.vrh"
#include "XactorUtilities.vrh"
#include "XactorDefines.vri"
#include "XactorClk.port.vri"

// DenaliPCIE libary
#include "DenaliPCIE.vri"

// FNXPCIEXactor library
#include "FNXPCIEXactorDefines.vri"
#include "FNXPCIEXactorPorts.vri"

// report library
#include "cReport.vrh"
#include "FNXPCIEXactorReportMacros.vri"

class FNXPCIEXactorBuilder extends XactorBaseBuilder {
  
  // Inherited Members
  // MyReport declared in XactorBaseBuilder

  // Base Class and Method Names For QR Macros
  local string ClassName  = "FNXPCIEXactorBuilder";
  local string MethodName = null;

  local FNXPCIEXactorManager Manager;
  FNXPCIEXactorSignalInterface SignalInterface;

  local string XactorName;  // Name of transactor
  local integer PortNum;    // PCIE Port Number

  local XactorClk                  ClkPort;        // Clock port
  local FNXPCIEXactorDenaliClkPort DenaliClkPort;  // Denali PCIE Clocks
  FNXPCIEXactorMiscPort      MiscPort;       // 3/4/04

  local bit AssertCovEnabled;
  local FNXPCIEXactorAssertCovDatabase AssertCovDatabase;

  // Denali PCIE Device Reference For This Transactor
  FNXPCIEXactorDenaliDevice PCIEDevice;

  // Flow Control Engine
  FNXPCIEXactorFCEngine FCEngine;

  // Utilities
  static FNXPCIEXactorUtilities Util;

  // SelfExpect members
  bit SelfExpectEnable;
  integer MinSelfExpectDly;
  integer MaxSelfExpectDly;

  task new( ReportClass                _Report,
	    XactorClk                  _ClkPort,
	    FNXPCIEXactorDenaliClkPort _DenaliClkPort,
	    FNXPCIEXactorDenaliDevice  _PCIEDevice,
	    FNXPCIEXactorMiscPort      _MiscPort,
	    integer                    _PortNum,
	    string                     _XactorName = FNX_PCIE_XTR_XACTOR_NAME );

  // public methods
  virtual function string CreateName();
  virtual function XactorBasePacket CreatePacket();
  virtual function XactorBaseManager CreateManager();
  virtual function XactorBaseSignalInterface CreateSignalInterface();
  virtual function XactorBaseExpectDataStruct CreateExpectDataStruct();
  virtual function XactorBaseExpectDataStruct CreateXExpectDataStruct();
  virtual function XactorBaseExpectDataStruct CreateHashElement();
  virtual function ReportClass CreateReport();
  virtual function XactorClk CreateClock();
  virtual task AddDenaliCbk( denaliPcieCbReasonT DenCbk );
  virtual task EnableAssertCov();
  virtual function bit GetAssertCovEnabled();
  virtual task ResetAssertCov();
  virtual task AddAssertPt( denaliPcieErrorTypeT covPt );
  virtual function bit IsAssertPtCovered( denaliPcieErrorTypeT covPt );
  virtual function integer GetAssertPtCnt( denaliPcieErrorTypeT covPt );
  virtual task DisplayAssertCov( ReportType rptType );
  virtual task SetUnexpectedTLPErr();
  virtual task SuppressUnexpectedTLPErr();
  virtual task SomaSet( string somaParm, string somaValue );
  virtual task Epilogue( ReportType rptType );

  //Made Public since all errors need to be supressed if a Denali reset is asserted
  task DenaliMemoryModelInit();
  // protected methods
  local task EnableDefaultDenaliCbks();
  
} // end of builder sub-class

// constructor
task FNXPCIEXactorBuilder::new( ReportClass                _Report,
				XactorClk                  _ClkPort,
				FNXPCIEXactorDenaliClkPort _DenaliClkPort,
				FNXPCIEXactorDenaliDevice  _PCIEDevice,
                                FNXPCIEXactorMiscPort      _MiscPort,
				integer                    _PortNum,
				string                     _XactorName = FNX_PCIE_XTR_XACTOR_NAME )
{
  sprintf( XactorName, "%s_%0d", _XactorName, _PortNum );
  ClkPort       = _ClkPort;
  DenaliClkPort = _DenaliClkPort;
  MyReport      = _Report;
  PCIEDevice    = _PCIEDevice;
  PortNum       = _PortNum;
  MiscPort      = _MiscPort;

  if ( Util == null )
    Util = new( MyReport, XactorName );

  // Create Xactor Manager
  Manager = new( this, 
		 ClkPort );

  // Create Assertion Coverage Database and Default Assertion Coverage to Disabled
  AssertCovDatabase = new( MyReport, XactorName );
  AssertCovEnabled = 0;

  // Create Signal Interface
  SignalInterface = new( Manager.ExpectFifo,      // incoming TLP transactions Fifo
			 Manager.DllpExpectFifo,  // incoming DLLP transactions Fifo
			 Manager.DriveFifo,       // outgoing TLP/DLLP transactions Fifo
			 Manager.RetryPktFifo,    // retried TLP transactions Fifo
			 MyReport,                // Report reference
			 XactorName,              // Name of transactor
			 Manager._XactorCtrl,     // control (Enable/Disable xactor)
			 ClkPort,                 // Transactor clock port
			 DenaliClkPort,           // Denali PCIE Clock Port
			 PCIEDevice,              // Denali PCIE Device reference
			 MiscPort,                // Port for Denali reset and Receive Detect signals 
			 Util,                    // Xactor Utilities
			 AssertCovDatabase,       // Assertion Coverage Database
			 PortNum,                 // PCIE Port Number (only used for reporting)
                         Manager.Bluntend_TX_fifo         // EP blunt end data transmit fifo
			 );

  // Flow Control Engine
  FCEngine = new( MyReport, SignalInterface, DenaliClkPort, Util, XactorName );

  // Default Self-Expect Members
  SelfExpectEnable = 1'b0;
  MinSelfExpectDly = 0;
  MaxSelfExpectDly = 50;

  // Register Default Denali Callbacks For This PCIE Device
  EnableDefaultDenaliCbks();

  // Initialize ReqID and BAR Setup of Denali Memory Model
  DenaliMemoryModelInit();
}

function string FNXPCIEXactorBuilder::CreateName()
{
  CreateName = XactorName;
}

function XactorBasePacket FNXPCIEXactorBuilder::CreatePacket()
{
  FNXPCIEXactorPacket Packet = new( MyReport, 
				    XactorName,
				    Util,
				    PortNum );
  CreatePacket = Packet;
}

function XactorBaseManager FNXPCIEXactorBuilder::CreateManager()
{
  CreateManager = Manager;
}

function XactorBaseSignalInterface FNXPCIEXactorBuilder::CreateSignalInterface()
{
  CreateSignalInterface = SignalInterface;
}

function XactorBaseExpectDataStruct FNXPCIEXactorBuilder::CreateExpectDataStruct()
{
  XactorList DataStruct = new;
  CreateExpectDataStruct = DataStruct;
}

function XactorBaseExpectDataStruct FNXPCIEXactorBuilder::CreateXExpectDataStruct()
{
  XactorListWildCard XDataStruct = new;
  CreateXExpectDataStruct = XDataStruct;
}

function XactorBaseExpectDataStruct FNXPCIEXactorBuilder::CreateHashElement()
{
  XactorList HashElement = new;
  CreateHashElement = HashElement;
}

function ReportClass FNXPCIEXactorBuilder::CreateReport()
{
  CreateReport = MyReport;
}

function XactorClk FNXPCIEXactorBuilder::CreateClock()
{
  CreateClock = ClkPort;
}

task FNXPCIEXactorBuilder::AddDenaliCbk( denaliPcieCbReasonT DenCbk )
{
  string MethodName = "AddDenaliCbk";
  integer status;
  status = PCIEDevice.addCb( DenCbk );
  if (status < 0)
    PCIEX_QR_ERR( "%s-> Failed to Add Callback=%s",
		  XactorName, DenCbk );
  else {
    PCIEX_QR_I( "AC: %s-> Add Callback=%s",
		  XactorName, DenCbk );
  }
}

// This task should enabled all Denali callback points for which
// this Xactor has handlers for in the Signal Interface
task FNXPCIEXactorBuilder::EnableDefaultDenaliCbks()
{
  // User Queue Callbacks (Packets Generated By Model)
  AddDenaliCbk( PCIE_CB_TL_user_queue_enter );
  AddDenaliCbk( PCIE_CB_TL_user_queue_exit );
  
  // Transaction Layer Xmit Callbacks
  // AddDenaliCbk( PCIE_CB_TL_transmit_queue_enter );
  // AddDenaliCbk( PCIE_CB_TL_transmit_queue_exit );
  AddDenaliCbk( PCIE_CB_TL_to_DL );
  
  // DLL Xmit Callbacks
  // AddDenaliCbk( PCIE_CB_DL_TX_queue_enter );
  // AddDenaliCbk( PCIE_CB_DL_TX_queue_exit );
  AddDenaliCbk( PCIE_CB_DL_to_PL );
  
  // Physical Layer Xmit Callbacks
  AddDenaliCbk( PCIE_CB_PL_TX_start_packet ); // Drive Start
  AddDenaliCbk( PCIE_CB_PL_TX_end_packet );   // Drive End
  
  // Transmission Related Callbacks
  // AddDenaliCbk( PCIE_CB_TX_trans_done );

  // DLL Replay Callbacks
  // AddDenaliCbk( PCIE_CB_DL_TX_retry_buffer_enter );
  AddDenaliCbk( PCIE_CB_DL_TX_retry_buffer_exit );
  // AddDenaliCbk( PCIE_CB_DL_TX_retry_buffer_purge );
  
  // Physical Layer Recv Callbacks
  AddDenaliCbk( PCIE_CB_PL_RX_start_packet );
  AddDenaliCbk( PCIE_CB_PL_RX_end_packet );
  AddDenaliCbk( PCIE_CB_PL_to_DL );
  
  // DLL Recv Callbacks
  AddDenaliCbk( PCIE_CB_DL_RX_queue_enter );
  AddDenaliCbk( PCIE_CB_DL_RX_queue_exit );
  // AddDenaliCbk( PCIE_CB_DL_to_TL );
  
  // Transaction Layer Recv Callbacks
  // AddDenaliCbk( PCIE_CB_TL_RX_packet );
  
  // Reception Related Callbacks
  // AddDenaliCbk( PCIE_CB_RX_trans_done );

  // Completion Related Callbacks
  // AddDenaliCbk( PCIE_CB_TL_TX_completion_queue_enter );
  // AddDenaliCbk( PCIE_CB_TL_TX_completion_queue_exit );
  // AddDenaliCbk( PCIE_CB_TL_RX_completion_queue_enter );
  // AddDenaliCbk( PCIE_CB_TL_RX_completion_queue_exit );

  // Error Related Callbacks
  AddDenaliCbk( PCIE_CB_TX_error );
  AddDenaliCbk( PCIE_CB_RX_error );
  AddDenaliCbk( PCIE_CB_error );
  AddDenaliCbk( PCIE_CB_unknown );
}

task FNXPCIEXactorBuilder::EnableAssertCov()
{
  string MethodName = "EnableAssertCov";
  AssertCovEnabled = 1;
  AddDenaliCbk( PCIE_CB_assert_pass );
  PCIEX_QR_I( "%s-> Denali Assertion Coverage Enabled.", XactorName );
}

function bit FNXPCIEXactorBuilder::GetAssertCovEnabled()
{
  GetAssertCovEnabled = AssertCovEnabled;
}

task FNXPCIEXactorBuilder::DenaliMemoryModelInit()
{
  // Setup Default ReqID for Denali Model in DEV_CTRL Register
  // NOTE: The FNX PCIE Xactor Does Not Make Use of the Denali Memory Model So The Value 
  //       Set For a Xactor's ReqID is Unimportant Other Than to Make The Model Happy
  SignalInterface.SetReqID( FNX_PCIE_XTR_DEFAULT_BUS_NUM,
			    PCIEDevice.getId(), // uniquify across Xactor instances
			    FNX_PCIE_XTR_DEFAULT_FUNC_NUM );
  
  // Setup Default 64-bit BAR for Denali Model in REG0_BASE_0 and REG0_BASE_1 Registers
  SignalInterface.SetupBAR64( PCIE_REG0_BASE_0,
			      PCIE_REG0_BASE_1,
			      FNX_PCIE_XTR_DEFAULT_BAR_64_SIZE, // NOTE: Should match width in default SOMA file
			      FNX_PCIE_XTR_DEFAULT_BAR_64_OFFSET );


  /////////////////////////////////////////////////////////
  // Begin -> Suppress Denali Error Checks
  //
  // Disable Self-Addressing TLP Check
  SignalInterface.SuppressDenaliErr( PCIE_TL_COR_TLP_ADDRSELF_2);
    
  // Disable Device Number Matches Stored Device Number Check
  SignalInterface.SuppressDenaliErr( PCIE_TL_NONFATAL_TLP_MF_vlRidDev );

  // Disable Bus Number Matches Stored Bus Number Check
  SignalInterface.SuppressDenaliErr( PCIE_TL_NONFATAL_TLP_MF_vlRidBus );

  // Disable Function Number Matches Stored Function Number Check
  SignalInterface.SuppressDenaliErr( PCIE_TL_NONFATAL_TLP_MF_vlRidFunc );

  // Disable Completion's BCM must not be set by PCI Express completer.
  SignalInterface.SuppressDenaliErr( PCIE_TL_NONFATAL_TLP_MF_vlCplBCM0 );
    
  // Disable BAR Address Check For a Device in Specified Memory/IO Range
  SignalInterface.SuppressDenaliErr( PCIE_TL_NONFATAL_TLP_ADNON_1 );

  // Disable Check For a Device with Specified ID
  SignalInterface.SuppressDenaliErr( PCIE_TL_NONFATAL_TLP_IDNON_2 );

  // Disable  Check For 64-bit Addresses That Are Below 4GB
  //SignalInterface.SuppressDenaliErr( PCIE_TL_NONFATAL_TLP_MF_vlAddr4GB ); // somePerson

  // Disable Check That Received Cpl/CplD Packets Have a Matching Request
  SignalInterface.SuppressDenaliErr( PCIE_TL_NONFATAL_TLP_CPLQ0_1 );

  // Disable Check That Request Is Not Supported By Device
  SignalInterface.SuppressDenaliErr( PCIE_TL_COR_TLP_UR_1 );

  // Disable Check That Request Address/Length Combination Crosses 4K Boundary
  SignalInterface.SuppressDenaliErr( PCIE_TL_NONFATAL_TLP_MF_vlLen4KB );

  // Discard the data embedded in CplD for an earlier CfgRd, because the RequesterID 
  // was changed unexpectedly after the request packet [transId=0x%06x] was sent. 
  SignalInterface.SuppressDenaliErr( PCIE_TL_NONFATAL_TLP_CPLUDN ); 

  // Disable Check That Completer ID Is Not Same As Requester ID
  SignalInterface.SuppressDenaliErr( PCIE_TL_COR_TLP_IDSELF_2 );

  // Disable Check That Port Function is defined as Configuration 0.
  SignalInterface.SuppressDenaliErr( PCIE_TL_NONFATAL_TLP_MF_vlCfg1 ); 

  // Disable Check That Completion is Supplied For Every Driven Request
  SignalInterface.SuppressDenaliErr( PCIE_TL_COR_TLP_CPLTO_2 );

  // Disable Check two different devices write the same data to a config. register
  SignalInterface.SuppressDenaliErr(  PCIE_TL_NONFATAL_TLP_CPLUN );

  // Allow FNXPCIEXtr to send any ReqID in Cfg requests. Added by RFT. Approved by JCB. 
  SignalInterface.SuppressDenaliErr( PCIE_TL_NONFATAL_TLP_MF_vlCfgBus);
  SignalInterface.SuppressDenaliErr( PCIE_TL_NONFATAL_TLP_MF_vlCfgDev);
  SignalInterface.SuppressDenaliErr( PCIE_TL_NONFATAL_TLP_MF_vlCfgFun);

  // Allow usage of any requester ID by Xactor regardless of pending
  // requests in Denali's User/TX Queues
  SignalInterface.SuppressDenaliErr( PCIE_TL_FATAL_CFG_DID_TXQ);
  SignalInterface.SuppressDenaliErr( PCIE_TL_FATAL_CFG_DID_USERQ);
  SignalInterface.SuppressDenaliErr( PCIE_TL_FATAL_CFG_DID_RXCPLQ);

  // Transactions pending in various Denali Q's need not conform to the BAR 
  // configuration associated with new requests since the Xactor is being 
  // used as a traffic generator
  SignalInterface.SuppressDenaliErr( PCIE_TL_FATAL_CFG_MID_TXCPLQ);
  SignalInterface.SuppressDenaliErr( PCIE_TL_FATAL_CFG_MID_TXCPLQ0);
  SignalInterface.SuppressDenaliErr( PCIE_TL_FATAL_CFG_MID_RXCPLQ);
  SignalInterface.SuppressDenaliErr( PCIE_TL_FATAL_CFG_MID_RXCPLQ0);
  SignalInterface.SuppressDenaliErr( PCIE_TL_FATAL_CFG_MID_TXQ );
  SignalInterface.SuppressDenaliErr( PCIE_TL_FATAL_CFG_MID_TXQ0);
  SignalInterface.SuppressDenaliErr( PCIE_TL_FATAL_CFG_MID_USERQ);
  SignalInterface.SuppressDenaliErr( PCIE_TL_FATAL_CFG_MID_USERQ0);

  // [review jcb 2/9/04] [DEN #17235] Workaround For Issue w/ Denali v1.000-14, Denali Claims CplH/CplD
  //                                 Credits Advertised During FC Init by an EP Must be Infinite
  SignalInterface.SuppressDenaliErr( PCIE_TL_FATAL_FCPE_INI_CPLH );
  SignalInterface.SuppressDenaliErr( PCIE_TL_FATAL_FCPE_INI_CPLD );

  // Request size is greater than Max_Read_Request_Size in Device Control Register.
  SignalInterface.SuppressDenaliErr( PCIE_TL_NONFATAL_TLP_MF_vlLenMRR);
  //
  // End -> Suppress Denali Error Checks
  /////////////////////////////////////////////////////////
}

task FNXPCIEXactorBuilder::ResetAssertCov()
{
  AssertCovDatabase.Reset();  
}

task FNXPCIEXactorBuilder::AddAssertPt( denaliPcieErrorTypeT covPt )
{
  AssertCovDatabase.Add( covPt );
}

function bit FNXPCIEXactorBuilder::IsAssertPtCovered( denaliPcieErrorTypeT covPt )
{
  IsAssertPtCovered = AssertCovDatabase.Covered( covPt );
}

function integer FNXPCIEXactorBuilder::GetAssertPtCnt( denaliPcieErrorTypeT covPt )
{
  GetAssertPtCnt = AssertCovDatabase.Count( covPt );
}

task FNXPCIEXactorBuilder::DisplayAssertCov( ReportType rptType )
{
  AssertCovDatabase.Display( rptType );
}

task FNXPCIEXactorBuilder::Epilogue( ReportType rptType )
{
  string MethodName = "Epilogue";
  
  PCIEX_QR_Type( rptType, "%s -> Begin\n%s", XactorName, SignalInterface.GetEpilogueStr() );
  PCIEX_QR_Type( rptType, "%s -> End", XactorName );
}

task FNXPCIEXactorBuilder::SetUnexpectedTLPErr()
{
  string MethodName = "SetUnexpectedTLPErr";
  
  Manager.UnexpectedTLPIsErr = 1;
  PCIEX_QR_I( "%s -> Unexpected TLP Errors Enabled.", XactorName );
}

task FNXPCIEXactorBuilder::SuppressUnexpectedTLPErr()
{
  string MethodName = "SuppressUnexpectedTLPErr";
  
  Manager.UnexpectedTLPIsErr = 0;
  PCIEX_QR_I("%s -> Unexpected TLP Errors Suppressed.", XactorName );
}

task FNXPCIEXactorBuilder::SomaSet( string somaParm, string somaValue )
{
  string MethodName = "SomaSet";
  string somaSetStr;
  integer status;
  
  status = DenaliDDVTclEval( { "mmsomaset", " ", PCIEDevice.GetInstanceName(), " ", somaParm, " ", somaValue } );
  if (status >= 0)
    PCIEX_QR_I( "Inst=%s  Parm=%s  Val=%s",
		PCIEDevice.GetInstanceName(), somaParm, somaValue );
  else
    PCIEX_QR_ERR( "mmsomaset Failed. Inst=%s  Parm=%s  Val=%s",
		  PCIEDevice.GetInstanceName(), somaParm, somaValue );
}