DS560DF810EVM: loopback test failed can't meet my expectation

//devinit.py
import gc
import globalDefs as Globals
from mDevice import Device
from RetimerEngines import RetimerEngine
from RetimerProcesses import RetimerProcess
from mConnect import Connect

import mds560DeviceWrapper
reload(mds560DeviceWrapper)

device=mds560DeviceWrapper.ds560DeviceWrapper(fileName=Globals.libFolderPath+"//"+"resourceFiles//"+DS560Libraries.folderDirDict[folderName]['dmlName'],regProgDevice=ds560RegProg)

process=RetimerProcess()
engine=RetimerEngine(device=device,process=process);
if simulationMode==True:
	device.delay=0
else:
	device.delay=1e-6	

from mSetupParams import setupParams
from resourceFiles.mSetupParams import setupParams

setupParams.simulationMode=simulationMode
setupParams.process=process
setupParams.engine=engine

import resourceFiles.mFuncDecorator
reload(resourceFiles.mFuncDecorator)
from resourceFiles.mFuncDecorator import *

def loadLibs(quadCount=2,dutNo=0):
	
	import mDs56Constants
	reload(mDs56Constants)
	from mDs56Constants import *
	
	import mDs56Parameters
	reload(mDs56Parameters)
	from mDs56Parameters import systemParams
	from mDs56Parameters import systemStatus
	
	import  mDs56Library
	reload(mDs56Library)
	from mDs56Library import ds56xxLibrary
	
	device1Refs=deviceRefs()
	sysParams=systemParams()
	sysStatus=systemStatus()
	
	device1Refs.device=device
	device1Refs.process=process
	device1Refs.engine=engine
	device1Refs.systemParams=sysParams
	device1Refs.systemStatus=sysStatus
	device1Refs.gpioProg=ds560GpioProg
		
	ds56Inst=ds56xxLibrary(device1Refs,0,quadCount)
	setupParams.dutInstances=[ds56Inst,]
	
	return (sysParams,sysStatus,ds56Inst)
(sysParams,sysStatus,ds560)=loadLibs(quadCount=devIdentifier)


class captureDevice:
	def __init__(self,libInstAct):
		self.capDevice = libInstAct.deviceRefs.device
		self.lib=libInstAct
	def capture(self):
		if(latteLibVersion==0.2):
			quadToCapture=self.lib.deviceRefs.engine.quadNo;
		else:
			quadToCapture=0;
		channelToCapture=self.lib.deviceRefs.engine.channelNo;
		return self.lib.QUAD[quadToCapture].verteyeMacroCall(channelToCapture)
engine.device=captureDevice(ds560);
		
ds560RegProg.clockDivider=49;
device.delay_time=1e-6; 
device.slaveAddr=0x22;

systemStatus=ds560.systemStatus
sysParams=ds560.systemParams

//setup.py
setupInfo = 0; #0-DS560xx_EVM, 1-I2C_DONGLE
devIdentifier = 2; #1-DF410,2-DF810
from USBHSCProgrammer import USBQPort
from basicPlots import BasicPlot
import numpy as np
import time
from logPlots import Log

latteLibVersion=5.0;

import sys,os
chipId=0x20
chipVersion=0xA
guiFormat=0x0
import DS560Libraries
reload(DS560Libraries)
folderName=DS560Libraries.getFolderName(chipId,chipVersion,guiFormat)
info(folderName)

import mpsseI2CLib
reload(mpsseI2CLib)

if(setupInfo==1):
	try:
		ds560RegProg = mpsseI2CLib.i2c(addr="FT4232H MiniModule A")
		simulationMode=False
	except:
		error("Got an error Connecting to hardware. Running in Simulation Mode.")
		ds560RegProg = ""
		simulationMode=True
	ds560GpioProg = ""
else:
	try:
		ds560RegProg = mpsseI2CLib.i2c(addr="Quad RS232-HS A")
		simulationMode=False
	except:
		error("Got an error Connecting to hardware. Running in Simulation Mode.")
		ds560RegProg = ""
		simulationMode=True
		
	try:
		ds560GpioProg = USBQPort(name="Gpio Programmer",addr="Quad RS232-HS B")
		readEnsimulationMode=False
	except:
		error("Got an error Connecting to hardware. Running in Simulation Mode.")
		ds560GpioProg = ""
		readEnsimulationMode=True

//1_bringupParams.py
device.hardReadAlways=1;

'''###------------BRINGUP PARAMETERS-------------###'''

# sysParams.channelsDataRate=[26.5625]*8; #(in GBaudps)
sysParams.channelsDataRate=[2.5]*8; #(in GBaudps)

### Channels to be enabled : [Q0CH0,Q0CH1,Q0CH2,Q0CH3,Q1CH0,Q1CH1,Q1CH2,Q1CH3]
sysParams.channelsEnabled=[1,0,0,0,0,0,0,0]; 
# sysParams.channelsEnabled=[1]*8;

### PAM4/NRZ mode : 1->PAM4, 0->NRZ
# sysParams.pam4Mode=[1]*8; #1->PAM4, 0->NRZ
sysParams.pam4Mode=[0]*8; #1->PAM4, 0->NRZ
	
### Tx PRBS generator polarity : 0-> Not inverted 1->Inverted, for channels [Q0CH0,Q0CH1,Q0CH2,Q0CH3,Q1CH0,Q1CH1,Q1CH2,Q1CH3]
sysParams.txPolarityInv=[0]*8;

### Rx PRBS checker polarity :  0-> Not inverted 1->Inverted, for channels [Q0CH0,Q0CH1,Q0CH2,Q0CH3,Q1CH0,Q1CH1,Q1CH2,Q1CH3]
sysParams.rxPolarityInv=[0]*8;

### Rx PRBS selection : 0->7,1->9,3->15,4->23,5->31,8->13   [Q0CH0,Q0CH1,Q0CH2,Q0CH3,Q1CH0,Q1CH1,Q1CH2,Q1CH3]
sysParams.rxPrbsSel=[5]*8;
# sysParams.rxPrbsSel=[0]*8;

### Tx PRBS selection : 0->7,1->9,3->15,4->23,5->31 (for use in PRBS generator mode) 
sysParams.txPrbsSel=[5]*8; 

### Grey code : 1->enable  0->disable         [Q0CH0,Q0CH1,Q0CH2,Q0CH3,Q1CH0,Q1CH1,Q1CH2,Q1CH3]
sysParams.grayCodeEn=[1]*8;

### Gearboxmode:
### 0x00 Straight Mode		
### 0x01 Crosspoint mode		
### 0x02 Broadcast from RX A		
### 0x03 Broadcast from RX B		
### 0x04 Gearbox MUX to TX A		
### 0x05 Gearbox MUX to TX B.
### 0x06 Gearbox DEMUX from RX A		
### 0x07 Gearbox DEMUX from RX B		
### 0x08 Up-convert MUX to TX A		
### 0x09 Up-convert MUX to TX B		
### 0x0a Down-convert DEMUX from RX A.
### 0x0b Down-convert DEMUX from RX B		
### 0x0c GPIO control of Crosspoint		
### 0x80 Analog low latency path.
### [Q0CH0,Q0CH1,Q0CH2,Q0CH3,Q1CH0,Q1CH1,Q1CH2,Q1CH3]
# sysParams.gearboxmode=[0x80]*8
sysParams.gearboxmode=[0x00]*8

### AlarmEvent : each bit represent different event
# 1-Signal detected on channel  
# 2-Signal loss detected on channel          
# 4-Channel initialization started.  
# 8-Channel initialization complete
# 16- Reserved Bit-0            
# 32- Eye offset measurement complete        
# 64- Channel ready
### [Q0CH0,Q0CH1,Q0CH2,Q0CH3,Q1CH0,Q1CH1,Q1CH2,Q1CH3]
# sysParams.alarmEventSel=[0xF]*8;
sysParams.alarmEventSel=[0xF]*8;
'''-------------------------'''

def bercheck(quad,chRx,polySel,sample_count=2048):
	returnArr=[];
	vemList=[];
	berArr=[];
	
	### Rx PRBS selection : 0->7,1->9,3->15,4->23,5->31,8->13
	sysParams.rxPrbsSel[quad*4+chRx]=polySel; 

	
	### Check channel init status
	[done,resultArr]=ds560.QUAD[quad].chInitStat(chRx);
	if(device.chInitComplete[quad*4+chRx]==1):
		log("Channel initialization completed successfully",'Debug');
		
		### Vertical eye logging
		vemList=ds560.QUAD[quad].verteyeMacroCall(chIdx=chRx); 
		log("VemList ="+str(vemList[1]));
		
		### RX BER check 
		berArr=ds560.QUAD[quad].prbsBERCheck(chRx,sysParams.rxPrbsSel[quad*4+chRx],sysParams.rxPolarityInv[quad*4+chRx],symbolWindow=sample_count,serEn=0);
		
		delay(0.2);
	else:
		error("Channel initialization is in progress / lock not achieved. Please ensure input signal is connected");
		
	returnArr.append(berArr);
	returnArr.append(vemList);
	returnArr.append(resultArr);
	return returnArr;
	
'''-------------------------'''

'''-----To change CTLE settings-----'''
#0-default and 1-for DAC cable
sysParams.channelType=[0]*8  ;
#sysParams.channelType=[1]*8  ;

#0-default 1-10dB PAM4  2-25dB PAM4  3-35dB NRZ
# sysParams.channelPerformanceOptimize=[1]*8;
sysParams.channelPerformanceOptimize=[3]*8;

//2_bringupLib.py
### Hardware reset
if(setupInfo==0):
	ds560.hardReset();
delay(0.5);

### Software reset and I2C check
resetStat=ds560.softReset();
	
### Device bringup Call

[quadToOn,channelToInitArr]=ds560.getChannelArr();

if(resetStat):
	bringupStat=ds560.deviceBringup();

if(bringupStat):
	for chArr in channelToInitArr:
		quad=chArr[0];
		ch=chArr[1];
		'''###------------CHANNEL INIT-------------###'''
		log("----QUAD : "+str(quad)+"-----CH : "+str(ch)+"-----");
		dual=(ch)>>1;
		laneEn = device.laneEnable_dict[ch+(4*quad)];
		
		ds560.channelInit(quad,ch); #Clear and enable alarm + set CTLE settings based on sysParams.channelType
		
		ds560.QUAD[quad].autoinitMultiConfig(ch,laneEn,q_lane_rate_KHz=[sysParams.channelsDataRate[ch+(4*quad)]*1e6, 28e6, 28e6, 28e6, 28e6],unumConfigs=1,umodulationBitMap=sysParams.pam4Mode[ch+(4*quad)]&0x1,ugearBoxCpMode=sysParams.gearboxmode[ch+(4*quad)]&0xFF);
		#Default feature enable setting used : uautolaneInitEn=1,uanBypassEn=0,uwaitForSigEn=1,ubgndEn=1,usigLossCheckEn=1,upufailAction=0,usigLossAction=0
		#By default analog low latency mode is enabled :  ugearBoxCpMode=0x80
		#By default reference clock frequency is set to 25MHz (input in kHz) : q_cal_clk_freq_KHz=25e3
	
	delay(0.5);

//usefulFunctions.py
'''###------------READBACK CHANNEL INIT STATUS /LOCK STATUS-------------###'''
for chArr in channelToInitArr:
	quad=chArr[0];
	ch=chArr[1];	
	log("------------READBACK CHANNEL INIT STATUS----QUAD : "+str(quad)+"-----CH : "+str(ch)+"-----");		
	[done,resultArr]=ds560.QUAD[quad].chInitStat(ch);
	if(resultArr[0]==8) or (resultArr[0]==7):
		log("CDR locked and channel initialization completed successfully",'Debug');
	else:
		error("Channel initialization is in progress / lock not achieved. ");
		
'''###------------GET TEMPSENSE RESULT-------------###'''
log("------------GET TEMPSENSE RESULT------------");
tempSenseVal=ds560.QUAD[quad].CD.coarseTempSenseRead();
log("TempSenseRead (in C) : "+str(tempSenseVal));

'''###------------READBACK CHANNEL INIT INFO-------------###'''
for chArr in channelToInitArr:
	quad=chArr[0];
	ch=chArr[1];
	log("------------READBACK CHANNEL INIT INFO----QUAD : "+str(quad)+"-----CH : "+str(ch)+"-----");	
	[done,alarm,statusStg,dataArr]=ds560.getChannelInitInfo(quad,ch);
	
'''###------------READBACK FOM-------------###'''
for chArr in channelToInitArr:
	quad=chArr[0];
	ch=chArr[1];			
	log("------------READBACK FOM----QUAD : "+str(quad)+"-----CH : "+str(ch)+"-----");	
	ds560.QUAD[quad].getFOMnormalized(ch);


'''###------------CHANGE RX-LUT-MAP-------------###'''
ch=0;
polarity=sysParams.rxPolarityInv[quad*4+ch];
ds560.QUAD[quad].setRxLutMap(ch,polarity,prbsQEn=1,levelMapChange=1,levelMapArr=[0,1,3,2]);


'''###------------READBACK BER-------------###'''
for chArr in channelToInitArr:
	quad=chArr[0];
	ch=chArr[1];
	log("------------READBACK BER----QUAD : "+str(quad)+"-----CH : "+str(ch)+"-----");		
	bercheck(quad,ch,sysParams.rxPrbsSel[quad*4+ch]);

'''###------------CUMULATIVE BER------------###'''
quad=0
ch=0
sample_count = 2048;
### Start BER counter
ds560.QUAD[quad].prbsBERCheckCumulative(ch,sysParams.rxPrbsSel[quad*4+ch],sysParams.rxPolarityInv[quad*4+ch],symbolWindow=sample_count,serEn=0,prbsQEn=1,levelMapChange=1,levelMapArr=[0,2,1,3],enable=1,disable=0)
### Read BER till sample count reached
ds560.QUAD[quad].prbsBERCheckCumulative(ch,sysParams.rxPrbsSel[quad*4+ch],sysParams.rxPolarityInv[quad*4+ch],symbolWindow=sample_count,serEn=0,prbsQEn=1,levelMapChange=1,levelMapArr=[0,2,1,3],enable=0,disable=0)
### Disable BER module at last
ds560.QUAD[quad].prbsBERCheckCumulative(ch,sysParams.rxPrbsSel[quad*4+ch],sysParams.rxPolarityInv[quad*4+ch],symbolWindow=sample_count,serEn=0,prbsQEn=1,levelMapChange=1,levelMapArr=[0,2,1,3],enable=0,disable=1)	


'''###------------READBACK RX COEFFICIENTS-------------###'''
for chArr in channelToInitArr:
	quad=chArr[0];
	ch=chArr[1];		
	log("------------READBACK RX COEFFICIENTS----QUAD : "+str(quad)+"-----CH : "+str(ch)+"-----");	
	arr=ds560.QUAD[quad].readRxCoeff(ch);
	log(str(arr));
	
'''###------------CHECK RX INPUT LEVEL (for use after channelinit is started) -------------###'''
for chArr in channelToInitArr:
	quad=chArr[0];
	ch=chArr[1];		
	log("------------SIGNAL DETECT STAT----QUAD : "+str(quad)+"-----CH : "+str(ch)+"-----");	
	ds560.signalDetect(quad,ch);

'''###------------CHANGE TX-FFE-------------###'''
quad=0; ch=0;
ds560.setTxParams(quad,ch,swing=0,pre2=0,pre=0,post=0);

'''###------------CHANGE TX-LUT-MAP-------------###'''
quad=0; ch=0;
polarity=sysParams.txPolarityInv[quad*4+ch];
ds560.QUAD[quad].setTxLutMap(ch,polarity,prbsQEn=1,levelMapChange=1,levelMapArr=[0,1,3,2]);

'''###------------CONFIGURE TRANSMITTER TO ENTER/EXIT PRBS GENERATOR MODE-------------###'''
quad=0; ch=0;
### MODE 0-> Retimer mode (enabled by default) 1->transmit clockPattern 2->transmit PRBS pattern 
# mode=0; 
mode=2;
### PATTERN (for MODE 1 and 2)
### clockPattern 	0->14GHz, 1->7GHZ, 2->3.5GHZ (for MODE=1)
### PRBS 			0->7, 1->9, 3->15, 4->23, 5->31, 8->13 (for MODE=2)
pattern=5;
### modulation
### 1 -> PAM4     0 -> NRZ
modulation=0;

### SWING - ValuesRange=0 to 11 (0-> 1Vpp and 11-> 700mVpp), 
### PRE2 - 	ValuesRange=0 to 7 (0 to 13%), 
### PRE - 	ValuesRange=0 to 15 (0 to 28%), 
### POST - 	ValuesRange=0 to 15 (0 to 28%), 
# ds560.setTxOut(quad,ch,mode,pattern,modulation,prbsQEn=1);
ds560.setTxOut(quad,ch,mode,pattern,prbsQEn=1);
# ds560.setTxOut(quad,ch,mode,pattern,modulation);
ds560.setTxParams(quad,ch,swing=0,pre2=0,pre=0,post=0);
'''###------------dynamic Gearbox configuration-------------###'''
### mode:
### 0x00 Straight Mode		0x01 Crosspoint mode		0x02 Broadcast from RX A		0x03 Broadcast from RX B		0x04 Gearbox MUX to TX A		0x05 Gearbox MUX to TX B.
### 0x06 Gearbox DEMUX from RX A		0x07 Gearbox DEMUX from RX B		0x08 Up-convert MUX to TX A		0x09 Up-convert MUX to TX B		0x0a Down-convert DEMUX from RX A.
### 0x0b Down-convert DEMUX from RX B		0x0c GPIO control of Crosspoint		0x80 Analog low latency path.
quad=0; ch=0;
# mode=0x1;
mode=0x00;
ds560.cpGbConfiguration(quad,ch,mode);


'''###------------2DEye-------------###'''

def plot2Deye(phList,Full2Deye,TwoDEyePathOrig,TwoDEyePath,hits_th):
	log('Skeleton 2D eye:', 'Warning')
	k = 0
	eyeFile  = open(TwoDEyePath,"w") 
	wr 	   		= csv.writer(eyeFile,delimiter=',',lineterminator='\n')
	
	for line in Full2Deye:
		binary_2D_eye = []
		for i in range(len(line)):
			if(line[i]<=hits_th):
				binary_2D_eye.append(1)
			else:
				binary_2D_eye.append(0)
		log('Ph '+str(phList[k]).zfill(3)+': '+str(binary_2D_eye))
		wr.writerow(binary_2D_eye)
		k = k+1
	eyeFile.close()
	
	j = 0
	eyeFile  = open(TwoDEyePathOrig,"w") 
	wr 	   		= csv.writer(eyeFile,delimiter=',',lineterminator='\n')
	
	for line in Eye:
		binary_2D_eye = []
		for i in range(len(line)):
			binary_2D_eye=Eye[j]
		wr.writerow(binary_2D_eye)
		j = j+1
	eyeFile.close()

quad=0; ch=0;
### PRBS selection : 0->7,1->9,3->15,4->23,5->31,8->13 
# polySel=0x1;
polySel=0x5;
levelMapChange=1;
levelMapArr=[0,2,1,3]

phList, Eye = ds560.QUAD[quad].get2DEye(ch,polySel,levelMapChange,levelMapArr);
import csv
### location of 2D eye saved
TwoDEyePathOrig= r"C:\VisionEyePlotOutput\EyePlot_raw.csv";
TwoDEyePath= r"C:\VisionEyePlotOutput\EyePlot.csv";
### Threshold used to discretize data to 0/1 depending on hit count
hits_th = 15
plot2Deye(phList,Eye,TwoDEyePathOrig,TwoDEyePath,hits_th);

Hi Louis,

It appears you are looping back TXn to RXn on all channels.  If my understanding is correct, this is not a valid test condition.

Is it possible to input highspeed data to one of the receiving channels?

Thanks,

Drew

Hi Drew,

According to the EVM datasheet article, does this mean it can generate PRBS at the TX side and perform the following tests?

I think we should focus on the following log.

Channel initialization is in progress / lock not achieved

Is there any suggestion for debugging?

In the TX channel we config as PRBS generator, I can measure the signal via oscilloscope,  despite the signal quality is bad.

Therefore, I infer the problem is at RX.

Hi Louis,

You need CDR lock in order to use the PRBS generator.  What signal are you locking to?

Thanks,
Drew

As datasheet mentioned in this section. Can you provide the topology what datasheet means? The sample code in the library doesn't mention what is the HW topology.