projects / OpenSPARC-T2-DV / blame
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Initial commit of OpenSPARC T2 design and verification files.
[OpenSPARC-T2-DV] / verif / env / fnx / vlib / FNXPCIEXactor / src / FNXPCIEXactorTransaction.vr
CommitLineData
86530b38
AT		 1// ========== Copyright Header Begin ==========================================
2//
3// OpenSPARC T2 Processor File: FNXPCIEXactorTransaction.vr
4// Copyright (C) 1995-2007 Sun Microsystems, Inc. All Rights Reserved
5// 4150 Network Circle, Santa Clara, California 95054, U.S.A.
6//
7// * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
8//
9// This program is free software; you can redistribute it and/or modify
10// it under the terms of the GNU General Public License as published by
11// the Free Software Foundation; version 2 of the License.
12//
13// This program is distributed in the hope that it will be useful,
14// but WITHOUT ANY WARRANTY; without even the implied warranty of
15// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16// GNU General Public License for more details.
17//
18// You should have received a copy of the GNU General Public License
19// along with this program; if not, write to the Free Software
20// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21//
22// For the avoidance of doubt, and except that if any non-GPL license
23// choice is available it will apply instead, Sun elects to use only
24// the General Public License version 2 (GPLv2) at this time for any
25// software where a choice of GPL license versions is made
26// available with the language indicating that GPLv2 or any later version
27// may be used, or where a choice of which version of the GPL is applied is
28// otherwise unspecified.
29//
30// Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
31// CA 95054 USA or visit www.sun.com if you need additional information or
32// have any questions.
33//
34// ========== Copyright Header End ============================================
35#include <vera_defines.vrh>
36#include "XactorUtilities.vrh"
37#include "XactorBaseTransaction.vrh"
38#include "XactorBaseBuilder.vrh"
39#include "XactorClk.port.vri"
40
41class FNXPCIEXactorTransaction extends XactorBaseTransaction {
42
43 // inherited members
44 // string XactorName
45 // XactorBasePacket Packet
46 // XactorBaseManager Manager
47 // XactorBaseSignalInterface SignalInterface
48 // ReportClass MyReport
49
50 // Base Class and Method Names For QR Macros
51 local string ClassName = "FNXPCIEXactorTransaction";
52 local string MethodName = null;
53
54 FNXPCIEXactorPacket MyPacket;
55
56 protected FNXPCIEXactorSignalInterface MySignalInterface;
57 protected FNXPCIEXactorManager MyManager;
58 protected FNXPCIEXactorUtilities Util;
59 protected FNXPCIEXactorFCEngine FCEngine;
60 protected XactorClk clock;
61
62 // SelfExpect members
63 bit SelfExpectEnable = 1'b0;
64 integer MinSelfExpectDly = 0;
65 integer MaxSelfExpectDly = 50;
66
67
68 // constructor
69 task new( FNXPCIEXactorBuilder Builder );
70
71 virtual task SetID( CTTransactionID XactionID );
72 virtual function CTTransactionID GetID();
73 virtual task SetPacket( string FieldType, bit [ XACT_FIELD_WIDTH-1:0 ] FieldValue );
74 virtual task EnableExpects();
75 virtual task DisableExpects();
76 virtual task DisableExpectsTimeout();
77 virtual task EnableExpectsTimeout();
78 virtual task EnableTlpDiscard();
79 virtual task DisableTlpDiscard();
80 virtual task EnableReplayMonitor();
81 virtual task DisableReplayMonitor();
82 virtual function bit [ XACT_FIELD_WIDTH-1:0 ] GetPacket( string FieldType );
83 virtual task ResetPacket();
84 virtual task ZeroPacket();
85 virtual task CopyPacket( FNXPCIEXactorTransaction PktTrans );
86 virtual task Display( string msg = "" );
87 virtual function string Name();
88 virtual task DumpExpectList();
89 virtual function bit IsExpectPending();
90 virtual function integer ExpectCount();
91 virtual function integer TlpExpectCount();
92 virtual function integer DllpExpectCount();
93 virtual function bit ExpectExpire( integer Window );
94 virtual function bit Expect( integer Window );
95 virtual task Sample( XactorBasePacket Pkt, integer Window = 50000 );
96 virtual task SampleTlp( XactorBasePacket Pkt, integer Window = 50000 );
97 virtual task SampleDllp( XactorBasePacket Pkt, integer Window = 50000 );
98 virtual function bit Remove();
99 virtual task Drive( integer D = 0 );
100 virtual task Enable();
101 virtual task Disable();
102 virtual task Reset();
103 virtual task WriteDenaliReg( integer iDenReg, bit [FNX_PCIE_XTR_REG_DEN_WIDTH-1:0] data );
104 virtual function bit [FNX_PCIE_XTR_REG_DEN_WIDTH-1:0] ReadDenaliReg( integer iDenReg );
105 virtual task SuppressDenaliErr( denaliPcieErrorTypeT denErr );
106 virtual task tempSuppressDenaliErr( denaliPcieErrorTypeT denErr );
107 virtual task unSuppressDenaliErr( denaliPcieErrorTypeT denErr );
108 virtual task SetPyld( bit [7:0] pyld[ * ] );
109 virtual task GetPyld( var bit [7:0] pyld[ * ] );
110 virtual task SetupBAR32( integer denReg,
111 integer addrWidth,
112 bit [FNX_PCIE_XTR_PCI_BAR_WIDTH-1:0] baseAddr );
113 virtual task SetupBAR64( integer denRegLower,
114 integer denRegUpper,
115 integer addrWidth,
116 bit [FNX_PCIE_XTR_PCI_BAR_WIDTH*2-1:0] baseAddr );
117 virtual task SetReqID( bit [FNX_PCIE_XTR_REQ_BUS_NUM_WIDTH-1:0] busNum,
118 bit [FNX_PCIE_XTR_REQ_DEVICE_NUM_WIDTH-1:0] devNum,
119 bit [FNX_PCIE_XTR_REQ_FUNC_NUM_WIDTH-1:0] funcNum,
120 integer regOffset = 0 );
121 virtual task SetFCUpdateFreq( denaliPcieFcTypeT denFcType,
122 integer fcTimerVal );
123 virtual function integer GetFCUpdateFreq( denaliPcieFcTypeT denFcType );
124 virtual task SetFCData( denaliPcieFcTypeT denFcType,
125 denaliPcieFcIdT denFcId,
126 bit [FNX_PCIE_XTR_REG_DEN_FC_CTRL_DATA_VAL_WIDTH-1:0] fcData );
127 virtual function bit[FNX_PCIE_XTR_REG_DEN_FC_CTRL_DATA_VAL_WIDTH-1:0] GetFCData( denaliPcieFcTypeT denFcType,
128 denaliPcieFcIdT denFcId );
129 virtual task SetAckNakUpdateFreq( integer ackNakTimerVal );
130 virtual function integer GetAckNakUpdateFreq();
131 virtual task SetReplayTimer( integer replayTimerVal );
132 virtual function integer GetReplayTimer();
133 virtual task SetFCCredit( denaliPcieFcTypeT denFcType,
134 integer fcCredit );
135 virtual task SetFCUpdateRange( denaliPcieFcTypeT denFcType,
136 integer fcUpdateMin,
137 integer fcUpdateMax );
138 virtual task WaitLinkUp();
139 virtual task WaitDLLActive();
140 virtual task SyncDriveStart();
141 virtual task SyncDriveEnd();
142
143 // Added to allow Vera 6.1 to compile
144 task SetSignalInterface(string FieldType, bit [XACT_FIELD_WIDTH-1:0] FieldValue) {}
145 function bit [XACT_FIELD_WIDTH-1:0] GetSignalInterface(string FieldType) {}
146
147 // 3/4/04
148 virtual task SetRcvDetMode( bit _rcvDetMode );
149 virtual task SetRcvDetLanes( bit[FNX_PCIE_XTR_RCV_DET_LANES_WIDTH-1:0] _rcvDetLanes );
150 virtual task SetElecIdleLanes( bit[FNX_PCIE_XTR_RCV_DET_LANES_WIDTH-1:0] _elecIdleLanes );
151 virtual task SetDenaliReset( bit _denaliReset );
152 virtual task ResetReplayMonitor();
153 virtual task EnableSampleIngressDllp();
154 virtual task DisableSampleIngressDllp();
155 virtual task SampleIngressDllp( XactorBasePacket Pkt, integer Window = 50000 );
156 virtual task EnableAckDiscard();
157 virtual task DisableAckDiscard();
158
159 virtual task EnableFCDiscard();
160 virtual task EnableFCPostDiscard();
161 virtual task EnableFCNonPostDiscard();
162 virtual task EnableFCCplDiscard();
163 virtual task DisableFCDiscard();
164 virtual task DisableFCPostDiscard();
165 virtual task DisableFCNonPostDiscard();
166 virtual task DisableFCCplDiscard();
167 virtual task SetLinkNumberTS1( bit[8:0] linkNumber );
168 virtual task SetLinkNumberTS2( bit[8:0] linkNumber );
169 virtual task SetLaneNumberTS1( bit[8:0] laneNumber );
170 virtual task SetLaneNumberTS2( bit[8:0] laneNumber );
171 virtual task TransmitFTSToLink( integer nmbrFts );
172 virtual task TransmitSKPToLink( integer nmbrSkp );
173 virtual task ExpectNullPkt(); //Set expect for a Null packet(EDB & inverted CRC)
174 virtual task Transmit_symbol_ToLink( integer nmbrSymbol, bit [8:0] symbol );
175// virtual task TransmitOrdersetToLink( integer nmbrFts, bit [31:0] orderset );
176// virtual task TransmitOrdersetToLink( integer nmbrFts, denaliPcieOrderedSet orderset );
177 virtual task TransmitTS1ToLink( integer nmbrTS1 );
178 virtual task Enable_count_4096FTS_1SKP();
179 virtual task Disable_count_4096FTS_1SKP();
180 virtual task Enable_blunt_end();
181
182
183}
184
185task FNXPCIEXactorTransaction::new( FNXPCIEXactorBuilder Builder )
186{
187 Util = Builder.Util;
188 XactorName = Builder.CreateName();
189 MyReport = Builder.CreateReport();
190 SelfExpectEnable = Builder.SelfExpectEnable;
191 MinSelfExpectDly = Builder.MinSelfExpectDly;
192 MaxSelfExpectDly = Builder.MaxSelfExpectDly;
193 cast_assign( MyPacket, Builder.CreatePacket() );
194 cast_assign( MyManager, Builder.CreateManager() );
195 cast_assign( MySignalInterface, Builder.CreateSignalInterface() );
196 FCEngine = Builder.FCEngine;
197 clock = Builder.CreateClock();
198}
199
200task FNXPCIEXactorTransaction::SetID( CTTransactionID XactionID )
201{
202 MyPacket.SetID( XactionID );
203}
204
205function CTTransactionID FNXPCIEXactorTransaction::GetID()
206{
207 GetID = MyPacket.GetID();
208}
209
210task FNXPCIEXactorTransaction::SetPacket( string FieldType,
211 bit [ XACT_FIELD_WIDTH-1:0 ] FieldValue )
212{
213 MyPacket.Set( FieldType, FieldValue );
214}
215
216function bit [ XACT_FIELD_WIDTH-1:0 ] FNXPCIEXactorTransaction::GetPacket( string FieldType )
217{
218 GetPacket = MyPacket.Get( FieldType );
219}
220
221task FNXPCIEXactorTransaction::ResetPacket()
222{
223 MyPacket.PktReset();
224}
225
226task FNXPCIEXactorTransaction::ZeroPacket()
227{
228 MyPacket.PktZero();
229}
230
231task FNXPCIEXactorTransaction::CopyPacket( FNXPCIEXactorTransaction PktTrans )
232{
233 MyPacket.PktCopy( PktTrans.MyPacket );
234}
235
236task FNXPCIEXactorTransaction::Display( string msg = "" )
237{
238 MyPacket.PktDisplay( RTYP_FNX_PCIE_XTR_INFO, msg );
239}
240
241function string FNXPCIEXactorTransaction::Name()
242{
243 Name = XactorName;
244}
245
246task FNXPCIEXactorTransaction::DumpExpectList()
247{
248 string MethodName = "DumpExpectList";
249
250 PCIEX_QR_D1( "%s -> Dumping Expects", XactorName );
251 MyManager.DumpExpects();
252}
253
254function bit FNXPCIEXactorTransaction::IsExpectPending()
255{
256 IsExpectPending = MyManager.ExpectPending( MyPacket );
257}
258
259function integer FNXPCIEXactorTransaction::ExpectCount()
260{
261 ExpectCount = MyManager.NumExpects();
262}
263
264function integer FNXPCIEXactorTransaction::TlpExpectCount()
265{
266 TlpExpectCount = MyManager.NumTlpExpects();
267}
268
269function integer FNXPCIEXactorTransaction::DllpExpectCount()
270{
271 DllpExpectCount = MyManager.NumDllpExpects();
272}
273
274function bit FNXPCIEXactorTransaction::ExpectExpire( integer Window )
275{
276 // Status[1] = 1'b0 Expect not removed
277 // Status[1] = 1'b1 Expect removed
278 // Status[0] = 1'b0 Expect removed by transactor
279 // Status[0] = 1'b1 Expect removed by user
280 bit [1:0] TransactionRemovedStatus = 2'b00;
281 bit success;
282 string MethodName = "ExpectExpire";
283
284 if (!SelfExpectEnable) {
285 MyPacket.PktDisplay( RTYP_FNX_PCIE_XTR_DEBUG_1, psprintf("%s %s -> Launching Expect Expire", PCIEX_QR_PREFIX, XactorName ) );
286 MyManager.ExpectPkt( MyPacket, Window, TransactionRemovedStatus );
287
288 if( TransactionRemovedStatus === 2'b10 ) {
289 // Expect Expire removed by transactor
290 success = 1'b1;
291 MyPacket.PktDisplay( RTYP_FNX_PCIE_XTR_INFO, psprintf("%s %s -> Expect Expire Satisfied", PCIEX_QR_PREFIX, XactorName ) );
292 }
293 else {
294 if( TransactionRemovedStatus === 2'b11 ) {
295 // Expect Expire removed by user
296 success = 1'b0;
297 MyPacket.PktDisplay( RTYP_XACTOR_FMWORK_EXPECT_REMOVED_BY_USER,
298 psprintf("%s %s -> Expect Expire Removed by User", PCIEX_QR_PREFIX, XactorName ) );
299 }
300 else {
301 // Expect Expire expired
302 success = 1'b0;
303 MyPacket.PktDisplay( RTYP_XACTOR_FMWORK_EXPECT_TIMEOUT_ERR,
304 psprintf("%s %s -> Expect Expire Expired", PCIEX_QR_PREFIX, XactorName ) );
305 }
306 }
307 } else {
308 MyPacket.PktDisplay( RTYP_FNX_PCIE_XTR_INFO, psprintf("%s %s -> Launching SelfExpectExpire", PCIEX_QR_PREFIX, XactorName ) );
309 repeat((urandom() % (MaxSelfExpectDly-MinSelfExpectDly+1)) + MinSelfExpectDly) @(posedge clock.$XClk);
310 MyPacket.PktDisplay(RTYP_FNX_PCIE_XTR_INFO, "SelfExpectExpire satisfied");
311 success = 1'b1;
312 }
313
314 ExpectExpire = success;
315}
316
317function bit FNXPCIEXactorTransaction::Expect( integer Window )
318{
319 bit [1:0] TransactionRemovedStatus;
320 bit success;
321 string MethodName = "Expect";
322
323 if (!SelfExpectEnable) {
324 MyPacket.PktDisplay( RTYP_FNX_PCIE_XTR_INFO, psprintf("at time %d, %s %s -> Launching Expect", get_time(LO), PCIEX_QR_PREFIX, XactorName ) );
325 MyManager.ExpectPkt( MyPacket, Window, TransactionRemovedStatus );
326 if( TransactionRemovedStatus === 2'b10 ) {
327 // Expect removed by transactor
328 success = 1'b1;
329 MyPacket.PktDisplay( RTYP_FNX_PCIE_XTR_INFO, psprintf("at time %d, %s %s -> Expect Satisfied", get_time(LO), PCIEX_QR_PREFIX, XactorName ) );
330 }
331 else {
332 if( TransactionRemovedStatus === 2'b11 ) {
333 // Expect removed by user
334 success = 1'b0;
335 MyPacket.PktDisplay( RTYP_XACTOR_FMWORK_EXPECT_REMOVED_BY_USER,
336 psprintf("at time %d, %s %s -> Expect Removed by User", get_time(LO), PCIEX_QR_PREFIX, XactorName ) );
337
338 }
339 else {
340 // Expect timeout
341 success = 1'b0;
342 MyPacket.PktDisplay( RTYP_XACTOR_FMWORK_EXPECT_TIMEOUT_ERR,
343 psprintf("%d, %s %s -> Expect Expired", get_time(LO), PCIEX_QR_PREFIX, XactorName ) );
344
345 }
346 }
347 } else {
348 MyPacket.PktDisplay( RTYP_FNX_PCIE_XTR_INFO, psprintf("%s %s -> Launching SelfExpect", PCIEX_QR_PREFIX, XactorName ) );
349 repeat((urandom() % (MaxSelfExpectDly-MinSelfExpectDly+1)) + MinSelfExpectDly) @(posedge clock.$XClk);
350 MyPacket.PktDisplay(RTYP_FNX_PCIE_XTR_INFO, "SelfExpect satisfied");
351 success = 1'b1;
352 }
353
354 Expect = success;
355}
356
357task FNXPCIEXactorTransaction::Sample( XactorBasePacket Pkt, integer Window = 50000 )
358{
359 string MethodName = "Sample";
360 PCIEX_QR_I( "%s-> Waiting to Receive Next Packet", XactorName );
361 MyManager.SamplePkt( Pkt, Window );
362}
363
364task FNXPCIEXactorTransaction::SampleTlp( XactorBasePacket Pkt, integer Window = 50000 )
365{
366 string MethodName = "SampleTlp";
367 PCIEX_QR_I( "%s-> Waiting to Receive Next TLP Packet", XactorName );
368 MyManager.SampleTlpPkt( Pkt, Window );
369}
370
371task FNXPCIEXactorTransaction::SampleDllp( XactorBasePacket Pkt, integer Window = 50000 )
372{
373 string MethodName = "SampleDllp";
374 PCIEX_QR_I( "%s-> Waiting to Receive Next DLLP Packet", XactorName );
375 MyManager.SampleDllpPkt( Pkt, Window );
376}
377
378function bit FNXPCIEXactorTransaction::Remove()
379{
380 string MethodName = "Remove";
381
382 Remove = MyManager.Remove( MyPacket );
383 if ( Remove )
384 MyPacket.PktDisplay( RTYP_FNX_PCIE_XTR_INFO, psprintf("%s %s -> Packet Successfully Removed", PCIEX_QR_PREFIX, XactorName ) );
385 else
386 MyPacket.PktDisplay( RTYP_FNX_PCIE_XTR_INFO, psprintf("%s %s -> Failed to Remove Packet", PCIEX_QR_PREFIX, XactorName ) );
387}
388
389task FNXPCIEXactorTransaction::Drive( integer D = 0 )
390{
391 if (!SelfExpectEnable) {
392 MyManager.DrivePkt( MyPacket.FormDriven(), D );
393 } else {
394 MyPacket.PktDisplay(RTYP_FNX_PCIE_XTR_INFO, "SelfDrive issued");
395 repeat(D) @(posedge clock.$XClk);
396 MyPacket.PktDisplay(RTYP_FNX_PCIE_XTR_INFO, "SelfDrive completed");
397 }
398}
399
400task FNXPCIEXactorTransaction::Enable()
401{
402 string MethodName = "Enable";
403
404 MyManager.EnableManager();
405 PCIEX_QR_I( "%s -> Manager Enabled", XactorName );
406}
407
408task FNXPCIEXactorTransaction::Disable()
409{
410 string MethodName = "Disable";
411
412 MyManager.DisableManager();
413 PCIEX_QR_I( "%s -> Manager Disabled", XactorName );
414}
415
416task FNXPCIEXactorTransaction::Reset()
417{
418 string MethodName = "Reset";
419
420 PCIEX_QR_I( "%s -> Resetting Manager", XactorName );
421 MyPacket.PktReset();
422 MyManager.ResetManager();
423}
424
425task FNXPCIEXactorTransaction::SetPyld( bit [7:0] pyld[ * ] )
426{
427 MyPacket.SetPyld( pyld );
428}
429
430task FNXPCIEXactorTransaction::GetPyld( var bit [7:0] pyld[ * ] )
431{
432 MyPacket.GetPyld( pyld );
433}
434
435task FNXPCIEXactorTransaction::EnableExpects()
436{
437 string MethodName = "EnableExpects";
438
439 MyManager.ExpectsOn = 1;
440 PCIEX_QR_I( "%s -> Expects Enabled.", XactorName );
441}
442
443task FNXPCIEXactorTransaction::DisableExpects()
444{
445 string MethodName = "DisableExpects";
446
447 MyManager.ExpectsOn = 0;
448 PCIEX_QR_I( "%s -> Expects Disabled. Sampling Only", XactorName );
449}
450
451task FNXPCIEXactorTransaction::EnableTlpDiscard()
452{
453 string MethodName = "EnableTlpDiscard";
454
455 MySignalInterface.TlpDiscardOn = 1;
456 PCIEX_QR_I( psprintf("%s -> TLP Discard Enabled. TLPs Generated By Denali Memory Model Will NOT Be Transmitted.", XactorName) );
457}
458
459task FNXPCIEXactorTransaction::DisableTlpDiscard()
460{
461 string MethodName = "DisableTlpDiscard";
462
463 MySignalInterface.TlpDiscardOn = 0;
464 PCIEX_QR_I( psprintf("%s -> TLP Discard Disabled. TLPs Generated By Denali Memory Model Will Be Transmitted.", XactorName) );
465}
466
467task FNXPCIEXactorTransaction::EnableReplayMonitor()
468{
469 string MethodName = "EnableReplayMonitor";
470
471 MySignalInterface.ReplayMonitorOn = 1;
472 PCIEX_QR_I( psprintf("%s -> Replayed TLP Checking Enabled.", XactorName) );
473}
474
475task FNXPCIEXactorTransaction::DisableReplayMonitor()
476{
477 string MethodName = "DisableReplayMonitor";
478
479 MySignalInterface.ReplayMonitorOn = 0;
480 PCIEX_QR_I( psprintf("%s -> Replayed TLP Checking Disabled.", XactorName) );
481}
482
483task FNXPCIEXactorTransaction::WriteDenaliReg( integer iDenReg, bit [FNX_PCIE_XTR_REG_DEN_WIDTH-1:0] data )
484{
485 MySignalInterface.WriteDenaliReg( iDenReg, data );
486}
487
488function bit [FNX_PCIE_XTR_REG_DEN_WIDTH-1:0] FNXPCIEXactorTransaction::ReadDenaliReg( integer iDenReg )
489{
490 ReadDenaliReg = MySignalInterface.ReadDenaliReg( iDenReg );
491}
492
493task FNXPCIEXactorTransaction::SuppressDenaliErr( denaliPcieErrorTypeT denErr )
494{
495 MySignalInterface.SuppressDenaliErr( denErr );
496}
497
498task FNXPCIEXactorTransaction::tempSuppressDenaliErr( denaliPcieErrorTypeT denErr )
499{
500 MySignalInterface.tempSuppressDenaliErr( denErr );
501}
502
503task FNXPCIEXactorTransaction::unSuppressDenaliErr( denaliPcieErrorTypeT denErr )
504{
505// MySignalInterface.unSuppressDenaliErr( denErr );
506}
507
508task FNXPCIEXactorTransaction::SetupBAR32( integer denReg,
509 integer addrWidth,
510 bit [FNX_PCIE_XTR_PCI_BAR_WIDTH-1:0] baseAddr )
511{
512 MySignalInterface.SetupBAR32( denReg, addrWidth, baseAddr );
513}
514
515task FNXPCIEXactorTransaction::SetupBAR64( integer denRegLower,
516 integer denRegUpper,
517 integer addrWidth,
518 bit [FNX_PCIE_XTR_PCI_BAR_WIDTH*2-1:0] baseAddr )
519{
520 MySignalInterface.SetupBAR64( denRegLower, denRegUpper, addrWidth, baseAddr );
521}
522
523task FNXPCIEXactorTransaction::SetReqID( bit [FNX_PCIE_XTR_REQ_BUS_NUM_WIDTH-1:0] busNum,
524 bit [FNX_PCIE_XTR_REQ_DEVICE_NUM_WIDTH-1:0] devNum,
525 bit [FNX_PCIE_XTR_REQ_FUNC_NUM_WIDTH-1:0] funcNum,
526 integer regOffset = 0 )
527{
528 MySignalInterface.SetReqID( busNum, devNum, funcNum, regOffset );
529}
530
531task FNXPCIEXactorTransaction::SetFCUpdateFreq( denaliPcieFcTypeT denFcType,
532 integer fcTimerVal )
533{
534 bit [FNX_PCIE_XTR_REG_DEN_WIDTH-1:0] fcRegVal;
535 integer idenFcType, iFcOp, iVc;
536
537 // Disable Generation of Denali FC Updates For This Credit Type
538 SetFCCredit( denFcType, 0 );
539
540 // Set Denali FC Update Timer
541 idenFcType = denFcType;
542 iFcOp = PCIE_FCCTRL_set_timer;
543 iVc = PCIE_VCID_VC0; // FNX Only Implements VC 0
544 fcRegVal = 0;
545 fcRegVal[FNX_PCIE_XTR_REG_DEN_FC_CTRL_TIMER_VAL_SLC] = fcTimerVal;
546 fcRegVal[FNX_PCIE_XTR_REG_DEN_FC_CTRL_FC_TYPE_SLC] = idenFcType;
547 fcRegVal[FNX_PCIE_XTR_REG_DEN_FC_CTRL_VC_SLC] = iVc;
548 fcRegVal[FNX_PCIE_XTR_REG_DEN_FC_CTRL_FC_CMD_SLC] = iFcOp;
549 WriteDenaliReg( PCIE_REG_DEN_FC_CTRL, fcRegVal );
550
551 // Enable FC Timer Updates in FC Engine
552 FCEngine.EnableFCTimer( denFcType );
553 FCEngine.SetFCTimerMax( denFcType, fcTimerVal );
554}
555
556function integer FNXPCIEXactorTransaction::GetFCUpdateFreq( denaliPcieFcTypeT denFcType )
557{
558 bit [FNX_PCIE_XTR_REG_DEN_WIDTH-1:0] fcRegVal;
559 integer idenFcType, iFcOp, iVc;
560
561 idenFcType = denFcType;
562 iFcOp = PCIE_FCCTRL_get_timer_limit;
563 iVc = PCIE_VCID_VC0; // FNX Only Implements VC 0
564 fcRegVal = 0;
565 fcRegVal[FNX_PCIE_XTR_REG_DEN_FC_CTRL_FC_TYPE_SLC] = idenFcType;
566 fcRegVal[FNX_PCIE_XTR_REG_DEN_FC_CTRL_VC_SLC] = iVc;
567 fcRegVal[FNX_PCIE_XTR_REG_DEN_FC_CTRL_FC_CMD_SLC] = iFcOp;
568 WriteDenaliReg( PCIE_REG_DEN_FC_CTRL, fcRegVal );
569
570 fcRegVal = ReadDenaliReg( PCIE_REG_DEN_FC_CTRL );
571 GetFCUpdateFreq = fcRegVal[FNX_PCIE_XTR_REG_DEN_FC_CTRL_TIMER_VAL_SLC];
572}
573
574task FNXPCIEXactorTransaction::SetFCUpdateRange( denaliPcieFcTypeT denFcType,
575 integer fcUpdateMin,
576 integer fcUpdateMax ) {
577 FCEngine.SetFCUpdateRange( denFcType, fcUpdateMin, fcUpdateMax );
578}
579
580task FNXPCIEXactorTransaction::SetFCData( denaliPcieFcTypeT denFcType,
581 denaliPcieFcIdT denFcId,
582 bit [FNX_PCIE_XTR_REG_DEN_FC_CTRL_DATA_VAL_WIDTH-1:0] fcData )
583{
584 FCEngine.SetFCData( denFcType, denFcId, fcData );
585}
586
587function bit[FNX_PCIE_XTR_REG_DEN_FC_CTRL_DATA_VAL_WIDTH-1:0] FNXPCIEXactorTransaction::GetFCData( denaliPcieFcTypeT denFcType,
588 denaliPcieFcIdT denFcId )
589{
590 GetFCData = FCEngine.GetFCData( denFcType, denFcId );
591}
592
593task FNXPCIEXactorTransaction::SetAckNakUpdateFreq( integer ackNakTimerVal )
594{
595 WriteDenaliReg( PCIE_REG_DEN_ACK_NAK_FREQ_TIMER, ackNakTimerVal );
596}
597
598function integer FNXPCIEXactorTransaction::GetAckNakUpdateFreq()
599{
600 GetAckNakUpdateFreq = ReadDenaliReg( PCIE_REG_DEN_ACK_NAK_FREQ_TIMER );
601}
602
603task FNXPCIEXactorTransaction::SetReplayTimer( integer replayTimerVal )
604{
605 WriteDenaliReg( PCIE_REG_DEN_REPLAY_TIMER, replayTimerVal );
606}
607
608function integer FNXPCIEXactorTransaction::GetReplayTimer()
609{
610 GetReplayTimer = ReadDenaliReg( PCIE_REG_DEN_REPLAY_TIMER );
611}
612
613task FNXPCIEXactorTransaction::SetFCCredit( denaliPcieFcTypeT denFcType,
614 integer fcCredit )
615{
616 bit [FNX_PCIE_XTR_REG_DEN_WIDTH-1:0] fcRegVal;
617
618 // Negative fcCredit Interpreted as Infinite, Postive as Actual Value
619 if (fcCredit < 0)
620 fcRegVal = { FNX_PCIE_XTR_REG_DEN_WIDTH {1'b1} }; // Denali Defines Infinite as 32'hfffffff
621 else
622 fcRegVal = fcCredit;
623
624 case (denFcType) {
625 PCIE_FCTYPE_PH : WriteDenaliReg( PCIE_REG_DEN_FC0_PH, fcRegVal );
626 PCIE_FCTYPE_PD : WriteDenaliReg( PCIE_REG_DEN_FC0_PD, fcRegVal );
627 PCIE_FCTYPE_NPH : WriteDenaliReg( PCIE_REG_DEN_FC0_NPH, fcRegVal );
628 PCIE_FCTYPE_NPD : WriteDenaliReg( PCIE_REG_DEN_FC0_NPD, fcRegVal );
629 PCIE_FCTYPE_CPLH : WriteDenaliReg( PCIE_REG_DEN_FC0_CPLH, fcRegVal );
630 PCIE_FCTYPE_CPLD : WriteDenaliReg( PCIE_REG_DEN_FC0_CPLD, fcRegVal );
631 PCIE_FCTYPE_TOTAL : {
632 WriteDenaliReg( PCIE_REG_DEN_FC0_PH, fcRegVal );
633 WriteDenaliReg( PCIE_REG_DEN_FC0_PD, fcRegVal );
634 WriteDenaliReg( PCIE_REG_DEN_FC0_NPH, fcRegVal );
635 WriteDenaliReg( PCIE_REG_DEN_FC0_NPD, fcRegVal );
636 WriteDenaliReg( PCIE_REG_DEN_FC0_CPLH, fcRegVal );
637 WriteDenaliReg( PCIE_REG_DEN_FC0_CPLD, fcRegVal );
638 }
639 default : PCIEX_QR_ERR( "%s-> Hit Default Case Element denFcType=%0d",
640 XactorName, denFcType );
641 }
642}
643
644task FNXPCIEXactorTransaction::WaitLinkUp()
645{
646 MySignalInterface.WaitLinkUp();
647}
648
649task FNXPCIEXactorTransaction::WaitDLLActive()
650{
651 MySignalInterface.WaitDLLActive();
652}
653
654task FNXPCIEXactorTransaction::SyncDriveStart()
655{
656 MyPacket.SyncDriveStart();
657}
658
659task FNXPCIEXactorTransaction::SyncDriveEnd()
660{
661 MyPacket.SyncDriveEnd();
662}
663
664task FNXPCIEXactorTransaction::SetRcvDetMode( bit _rcvDetMode )
665{
666 string MethodName = "SetRcvDetMode";
667
668 MySignalInterface.SetRcvDetMode( _rcvDetMode );
669 PCIEX_QR_I( psprintf("%s -> Drive rcvDetMode = %b : 0=fast receive detect 1=slow receive detect", XactorName,_rcvDetMode) );
670}
671
672task FNXPCIEXactorTransaction::SetRcvDetLanes( bit[FNX_PCIE_XTR_RCV_DET_LANES_WIDTH-1:0] _rcvDetLanes )
673{
674 string MethodName = "SetRcvDetLanes";
675
676 MySignalInterface.SetRcvDetLanes( _rcvDetLanes );
677 PCIEX_QR_I( psprintf("%s -> Drive rcvDetLanes = %b ", XactorName,_rcvDetLanes) );
678}
679
680task FNXPCIEXactorTransaction::SetElecIdleLanes( bit[FNX_PCIE_XTR_RCV_DET_LANES_WIDTH-1:0] _elecIdleLanes )
681{
682 string MethodName = "SetElecIdleLanes";
683
684 MySignalInterface.SetElecIdleLanes( _elecIdleLanes );
685 PCIEX_QR_I( psprintf("%s -> Drive elecIdleLanes = %b ", XactorName,_elecIdleLanes) );
686}
687
688task FNXPCIEXactorTransaction::SetDenaliReset( bit _denaliReset )
689{
690 string MethodName = "SetDenaliReset";
691
692 MySignalInterface.SetDenaliReset( _denaliReset );
693 PCIEX_QR_I( psprintf("%s -> Drive denaliReset = %b ", XactorName,_denaliReset) );
694}
695
696task FNXPCIEXactorTransaction::ResetReplayMonitor()
697{
698 string MethodName = "ResetReplayMonitor";
699
700 MySignalInterface.ResetReplayMonitor();
701 PCIEX_QR_I( psprintf("%s -> Reset FNXPCIEXtr Replay Monitor ", XactorName) );
702}
703
704
705task FNXPCIEXactorTransaction::EnableSampleIngressDllp()
706{
707 string MethodName = "EnableSampleIngressDllp";
708
709 MySignalInterface.EnableSampleDllpToLink();
710 PCIEX_QR_I( psprintf("%s -> EnableSampleIngressDllp allows Ingress(xtr to dut) DLLPs to be passed to the testbench.", XactorName) );
711}
712
713task FNXPCIEXactorTransaction::DisableSampleIngressDllp()
714{
715 string MethodName = "DisableSampleIngressDllp";
716
717 MySignalInterface.DisableSampleDllpToLink();
718 PCIEX_QR_I( psprintf("%s -> DisableSampleIngressDllp will NOT pass Ingress(xtr to dut) DLLPs to the testbench.", XactorName) );
719}
720
721task FNXPCIEXactorTransaction::SampleIngressDllp( XactorBasePacket Pkt, integer Window = 50000 )
722{
723 string MethodName = "SampleIngressDllp";
724 PCIEX_QR_D3( "%s-> Waiting to Receive Next Ingress DLLP Packet", XactorName );
725 MySignalInterface.SampleDllpPktToLink( Pkt, Window );
726}
727
728task FNXPCIEXactorTransaction::EnableAckDiscard()
729{
730 string MethodName = "EnableAckDiscard";
731
732 MySignalInterface.AckDiscardOn = 1;
733 PCIEX_QR_I( psprintf("%s -> ACK Discard Enabled. DLLP ACKs Generated By Denali Model Will NOT Be Transmitted.", XactorName) );
734}
735
736task FNXPCIEXactorTransaction::DisableAckDiscard()
737{
738 string MethodName = "DisableAckDiscard";
739
740 MySignalInterface.AckDiscardOn = 0;
741 PCIEX_QR_I( psprintf("%s -> ACK Discard Disabled. DLLP ACKs Generated By Denali Model Will Be Transmitted.", XactorName) );
742}
743
744task FNXPCIEXactorTransaction::EnableFCDiscard()
745{
746 string MethodName = "EnableFCDiscard";
747
748 MySignalInterface.FCDiscardOn = 1;
749 PCIEX_QR_I( psprintf("%s -> Denali FC Discard Enabled. DLLP FCs Generated By Denali Model Will NOT Be Transmitted.", XactorName) );
750}
751
752task FNXPCIEXactorTransaction::EnableFCPostDiscard()
753{
754 string MethodName = "EnableFCPostDiscard";
755
756 MySignalInterface.FCPostDiscardOn = 1;
757 PCIEX_QR_I( psprintf("%s -> Denali FC Post Discard Enabled. DLLP Posted FCs Generated By Denali Model Will NOT Be Transmitted.", XactorName) );
758}
759
760task FNXPCIEXactorTransaction::EnableFCNonPostDiscard()
761{
762 string MethodName = "EnableFCNonPostDiscard";
763
764 MySignalInterface.FCNonPostDiscardOn = 1;
765 PCIEX_QR_I( psprintf("%s -> Denali FC Non-Post Discard Enabled. DLLP Non-Posted FCs Generated By Denali Model Will NOT Be Transmitted.", XactorName) );
766}
767
768task FNXPCIEXactorTransaction::EnableFCCplDiscard()
769{
770 string MethodName = "EnableFCCplDiscard";
771
772 MySignalInterface.FCCplDiscardOn = 1;
773 PCIEX_QR_I( psprintf("%s -> Denali FC Completion Discard Enabled. DLLP COmpletion FCs Generated By Denali Model Will NOT Be Transmitted.", XactorName) );
774}
775
776task FNXPCIEXactorTransaction::DisableFCDiscard()
777{
778 string MethodName = "DisableFCDiscard";
779
780 MySignalInterface.FCDiscardOn = 0;
781 PCIEX_QR_I( psprintf("%s -> Denali FC Discard Disabled. DLLP FCs Generated By Denali Model Will Be Transmitted.", XactorName) );
782}
783
784task FNXPCIEXactorTransaction::DisableFCPostDiscard()
785{
786 string MethodName = "DisableFCPostDiscard";
787
788 MySignalInterface.FCPostDiscardOn = 0;
789 PCIEX_QR_I( psprintf("%s -> Denali FC Post Discard Disabled. DLLP Posted FCs Generated By Denali Model Will Be Transmitted.", XactorName) );
790}
791
792task FNXPCIEXactorTransaction::DisableFCNonPostDiscard()
793{
794 string MethodName = "DisableFCNonPostDiscard";
795
796 MySignalInterface.FCNonPostDiscardOn = 0;
797 PCIEX_QR_I( psprintf("%s -> Denali FC Non-Post Discard Disabled. DLLP NonPosted FCs Generated By Denali Model Will Be Transmitted.", XactorName) );
798}
799
800task FNXPCIEXactorTransaction::DisableFCCplDiscard()
801{
802 string MethodName = "DisableFCCplDiscard";
803
804 MySignalInterface.FCCplDiscardOn = 0;
805 PCIEX_QR_I( psprintf("%s -> Denali FC Completion Discard Disabled. DLLP Completion FCs Generated By Denali Model Will Be Transmitted.", XactorName) );
806}
807
808task FNXPCIEXactorTransaction::SetLinkNumberTS1( bit[8:0] linkNumber )
809{
810 string MethodName = "SetLinkNumberTS1";
811
812 MySignalInterface.linkNmbrTS1 = linkNumber;
813 PCIEX_QR_I( psprintf("%s:%s -> Link Number for TS1s will be set to %0h.", XactorName,MethodName,linkNumber) );
814}
815
816task FNXPCIEXactorTransaction::SetLinkNumberTS2( bit[8:0] linkNumber )
817{
818 string MethodName = "SetLinkNumberTS2";
819
820 MySignalInterface.linkNmbrTS2 = linkNumber;
821 PCIEX_QR_I( psprintf("%s:%s -> Link Number for TS2s will be set to %0h.", XactorName,MethodName,linkNumber) );
822}
823
824task FNXPCIEXactorTransaction::SetLaneNumberTS1( bit[8:0] laneNumber )
825{
826 string MethodName = "SetLaneNumberTS1";
827
828 MySignalInterface.laneNmbrTS1 = laneNumber;
829 PCIEX_QR_I( psprintf("%s:%s -> Lane Number for TS1s will be set to %0h.", XactorName,MethodName,laneNumber) );
830}
831
832task FNXPCIEXactorTransaction::SetLaneNumberTS2( bit[8:0] laneNumber )
833{
834 string MethodName = "SetLaneNumberTS2";
835
836 MySignalInterface.laneNmbrTS2 = laneNumber;
837 PCIEX_QR_I( psprintf("%s:%s -> Lane Number for TS2s will be set to %0h.", XactorName,MethodName,laneNumber) );
838}
839
840task FNXPCIEXactorTransaction::TransmitFTSToLink( integer nmbrFts )
841{
842 string MethodName = "TransmitFTSToLink";
843
844 MySignalInterface.TransmitFTSToLink( nmbrFts );
845 PCIEX_QR_I( psprintf("%s:%s -> Transmit %0d FTS Ordered Sets to Link.", XactorName,MethodName,nmbrFts) );
846}
847
848task FNXPCIEXactorTransaction::TransmitSKPToLink( integer nmbrSkp )
849{
850 string MethodName = "TransmitSKPToLink";
851
852 MySignalInterface.TransmitSKPToLink( nmbrSkp );
853 PCIEX_QR_I( psprintf("%s:%s -> Transmit %0d SKP Ordered Sets to Link.", XactorName,MethodName,nmbrSkp) );
854}
855
856task FNXPCIEXactorTransaction::ExpectNullPkt( )
857{
858 string MethodName = "ExpectNullPkt";
859
860 MySignalInterface.expectNullPkt += 1;
861 PCIEX_QR_I( psprintf("%s:%s -> %0d total NULL Packets expected", XactorName,MethodName,MySignalInterface.expectNullPkt) );
862}
863
864task FNXPCIEXactorTransaction::Transmit_symbol_ToLink( integer nmbrSymbol, bit [8:0] symbol )
865{
866 string MethodName = "Transmit_symbol_ToLink";
867
868 MySignalInterface.Transmit_symbol_ToLink( nmbrSymbol, symbol );
869 PCIEX_QR_I( psprintf("AC: %s:%s -> Transmit %0d %x sympbol to Link.", XactorName,MethodName,nmbrSymbol, symbol) );
870}
871
872// task FNXPCIEXactorTransaction::TransmitOrdersetToLink( integer nmbrFts, bit [31:0] orderset )
873// task FNXPCIEXactorTransaction::TransmitTS1ToLink( integer nmbrTS1, denaliPcieOrderedSet orderset )
874task FNXPCIEXactorTransaction::TransmitTS1ToLink( integer nmbrTS1)
875{
876 string MethodName = "TransmitOrdersetToLink";
877
878// MySignalInterface.TransmitOrdersetToLink( nmbrTS1, orderset );
879 MySignalInterface.TransmitTS1ToLink( nmbrTS1 );
880 PCIEX_QR_I( psprintf("%s:%s -> Transmit %0d Ordered Sets to Link.", XactorName,MethodName,nmbrTS1) );
881}
882
883// For extended sync
884task FNXPCIEXactorTransaction::Enable_blunt_end()
885{
886 string MethodName = "Enable_blunt_end";
887
888 MySignalInterface.blunt_end = 1;
889 PCIEX_QR_I( psprintf("%s:%s -> blunt end Enabled. blunt_end = %d", XactorName,MethodName,
890 MySignalInterface.blunt_end ) );
891}
892
893// For extended sync
894task FNXPCIEXactorTransaction::Enable_count_4096FTS_1SKP()
895{
896 string MethodName = "Enable_count_4096FTS_1SKP";
897
898 MySignalInterface.count_4096FTS_1SKP = 1;
899 PCIEX_QR_I( psprintf("%s:%s -> count_4096FTS_1SKP Enabled. count_4096FTS_1SKP = %d", XactorName,MethodName,
900 MySignalInterface.count_4096FTS_1SKP ) );
901}
902
903task FNXPCIEXactorTransaction::Disable_count_4096FTS_1SKP()
904{
905 string MethodName = "Disable_count_4096FTS_1SKP";
906
907 MySignalInterface.count_4096FTS_1SKP = 0;
908 PCIEX_QR_I( psprintf("%s:%s -> count_4096FTS_1SKP Disabled. count_4096FTS_1SKP = %d", XactorName,MethodName,
909 MySignalInterface.count_4096FTS_1SKP ) );
910}
911
912task FNXPCIEXactorTransaction::DisableExpectsTimeout()
913{
914 string MethodName = "DisableExpectsTimeout";
915
916 MyManager.disablteTlpExpectTimeout = 1;
917 PCIEX_QR_I( "%s -> Expects Timeouts Disabled.", XactorName );
918}
919
920task FNXPCIEXactorTransaction::EnableExpectsTimeout()
921{
922 string MethodName = "EnableExpectsTimeout";
923
924 MyManager.disablteTlpExpectTimeout = 0;
925 PCIEX_QR_I( "%s -> Expects Timeouts Enabled.", XactorName );
926}
927
Full OpenSPARC design & verification tarball including full HDL.