//
// Create a loop of rx descriptors.
// Return the address of the first one.
//
int LinkRxLoopCreate(int many)
{
int it;
unsigned int dr[MDESCRIPTOR];
unsigned int descriptorNext;
many=LinkRxLoopMany; // we ignore the suggested queue size
// MemoryLayout(1024);
/*
* create a few descriptors linked in a loop
* OSPREY requires that the memory buffer directly follow the descriptor. Older chip sets
* include a pointer to the buffer in the descriptor. This code does both.
*/
for(it=0; it<many; it++)
{
LinkRxLoopDescriptor[it] = MemoryLayout(RxDescriptorSize()+MPACKETSIZEBUFFER);
if(LinkRxLoopDescriptor[it]==0)
{
UserPrint( "Device Number %d:rxDataSetup: unable to allocate memory for %d descriptors\n", 0, many);
return -1;
}
LinkRxLoopBuffer[it]=LinkRxLoopDescriptor[it]+RxDescriptorSize();
}
//
// fill in the descriptors
//
for (it = 0; it < many; it++)
{
//
// figure out next pointer, last one loops back to first
//
if (it == many - 1)
{
descriptorNext = LinkRxLoopDescriptor[0];
}
else
{
descriptorNext = LinkRxLoopDescriptor[it+1]; //descriptor + RxDescriptorSize();
}
//
// make the descriptor
//
// UserPrint("%2d: %8x %8x %8x\n",it,LinkRxLoopDescriptor[it],LinkRxLoopBuffer[it],descriptorNext);
RxDescriptorSetup(dr,descriptorNext,LinkRxLoopBuffer[it],MPACKETSIZE);
//
// copy it to the shared memory
//
MyMemoryWrite(LinkRxLoopDescriptor[it],dr,RxDescriptorSize());
// memset(dr, 0x55, RxDescriptorSize());
// MyMemoryWrite(LinkRxLoopDescriptor[it]+48,dr,RxDescriptorSize());
}
// LinkRxLoopMany=many;
return 0;
}
void LinkRxComplete(int timeout,
int ndump, unsigned char *dataPattern, int dataPatternLength, int (*done)())
{
unsigned int startTime, endTime, ctime;
int it;
int notdone;
int stop;
int behind;
int scount;
unsigned int mDescriptor; // address of descriptor in shared memory
#ifdef MEMORYREAD
unsigned int descriptor[MDESCRIPTOR+30]; // private copy of current descriptor
#else
unsigned int *descriptor;
#endif
int pass;
int dsize;
int isdone;
pass=0;
dataPatternLength=0;
dataPattern=0;
scount=0;
dsize=RxDescriptorSize();
//
// Loop timeout condition.
// This number can be large since it is only used for
// catastrophic failure of cart. The normal terminating
// condition is a message from cart saying STOP.
//
startTime=TimeMillisecond();
ctime=startTime;
// if(timeout<=0)
// {
// timeout=60*60*1000; // one hour
// }
endTime=startTime+timeout;
//
// set pointer to first descriptor
//
// mDescriptor = LinkRxLoopFirst(0);
//
// keep track of how many times we look and the descriptor is not done
// this is used to control the sleep interval
//
notdone=0;
stop=0;
behind=0;
//
// loop looking for descriptors with received packets.
//
for(it = 0; ; it++)
{
mDescriptor=LinkRxLoopDescriptor[it%LinkRxLoopMany];
#ifdef MEMORYREAD
//
// read the next descriptor
//
MyMemoryRead(mDescriptor, descriptor, dsize);
#else
descriptor=(unsigned int *)MyMemoryPtr(mDescriptor);
#endif
//
// descriptor is ready, we have a new packet
//
if(RxDescriptorDone(descriptor))
{
#ifdef MEMORYREAD
//
// read the next descriptor
//
MyMemoryRead(mDescriptor, descriptor, dsize);
#endif
notdone=0;
behind++;
scount=0;
#ifdef FASTER
if((it%100)==0)
{
UserPrint(" %d",it);
}
#endif
//
// dump packet contents
//
if(ndump>0)
{
UserPrint("\n");
LinkRxDump(descriptor, ndump, it%LinkRxLoopMany);
}
//
// extract stats
//
LinkRxStatExtract(descriptor,it);
//
// reset the descriptor so that we can use it again
//
RxDescriptorReset(descriptor);
#ifdef MEMORYREAD
//
// copy it back to the shared memory
//
MyMemoryWrite(mDescriptor,descriptor,dsize);
#endif
//
// need to queue the descriptor with the hardware
//
if(LinkRxDescriptorFifo)
{
DeviceReceiveDescriptorPointer(mDescriptor);
}
}
//
// descriptor not ready
//
else
{
if(stop)
{
scount++;
if(scount>200)
{
break;
}
}
it--;
//
// sleep every other time, need to keep up with fast rates
//
if(notdone>100)
{
UserPrint(".");
// MyDelay(1);
notdone=0;
}
else
{
notdone=1; // this makes sure we never sleep
}
}
//
// check for message from cart telling us to stop
// this is the normal terminating condition
//
pass++;
if(pass>100)
{
if(done!=0)
{
isdone=(*done)();
if(isdone!=0)
{
UserPrint(" %d Stop",it);
if(stop==0)
{
stop=1;
scount=0;
behind=0;
}
//
// immediate stop
//
if(isdone==2)
{
break;
}
// break;
}
}
pass=0;
//
// check for timeout
// rare terminating condition when cart crashes or disconnects
//
ctime=TimeMillisecond();
if(timeout>0 && ((endTime>startTime && (ctime>endTime || ctime<startTime)) || (endTime<startTime && ctime>endTime && ctime<startTime)))
{
UserPrint("%d Timeout",it);
break;
}
}
}
//
// cleanup
//
DeviceReceiveDisable();
LinkRxLoopDestroy(0);
//
// do data verify if requested
//
UserPrint(" %d\n",it);
LinkRxStatFinish();
return;
}
// Added VSG sync detection
void LinkRxComplete_vsgSync(int timeout,
int ndump, unsigned char *dataPattern, int dataPatternLength, int (*done)(), int chainMask)
{
unsigned int startTime, endTime, ctime;
int it, ii;
int notdone;
int stop;
int behind;
int scount;
unsigned int mDescriptor; // address of descriptor in shared memory
#ifdef MEMORYREAD
unsigned int descriptor[MDESCRIPTOR+30]; // private copy of current descriptor
#else
unsigned int *descriptor;
#endif
int pass;
int dsize;
int isdone;
int ss;
int rssic[MCHAIN], rssie[MCHAIN], rssi;
#define MSPECTRUM 1024
int nspectrum,spectrum[MSPECTRUM];
int ndata;
unsigned char data[MBUFFER];
int sscount=0;
unsigned int vsgSync = 0;
pass=0;
dataPatternLength=0;
dataPattern=0;
scount=0;
dsize=RxDescriptorSize();
//
// Loop timeout condition.
// This number can be large since it is only used for
// catastrophic failure of cart. The normal terminating
// condition is a message from cart saying STOP.
//
startTime=TimeMillisecond();
ctime=startTime;
if(timeout<=0)
{
timeout=2*60*1000; // 2 mins
}
endTime=startTime+timeout;
//
// set pointer to first descriptor
//
// mDescriptor = LinkRxLoopFirst(0);
//
// keep track of how many times we look and the descriptor is not done
// this is used to control the sleep interval
//
notdone=0;
stop=0;
behind=0;
//
// loop looking for descriptors with received packets.
//
for(it = 0; ; it++)
{
mDescriptor=LinkRxLoopDescriptor[it%LinkRxLoopMany];
#ifdef MEMORYREAD
//
// read the next descriptor
//
MyMemoryRead(mDescriptor, descriptor, dsize);
#else
descriptor=(unsigned int *)MyMemoryPtr(mDescriptor);
#endif
//
// descriptor is ready, we have a new packet
//
if(RxDescriptorDone(descriptor))
{
#ifdef MEMORYREAD
//
// read the next descriptor
//
MyMemoryRead(mDescriptor, descriptor, dsize);
#endif
notdone=0;
behind++;
scount=0;
#ifdef FASTER
if((it%SASAMPLINGS)==0)
{
UserPrint(" %d",it);
}
#endif
if(_LinkRxSpectralScan)
{
ss=Ar9300RxDescriptorSpectralScan(descriptor);
if(ss)
{
//
// extract rssi and evm measurements. we need these for both good and bad packets
//
rssi=RxDescriptorRssiCombined(descriptor);
if(rssi&0x80)
{
rssi|=0xffffff00;
}
rssic[0]=RxDescriptorRssiAnt00(descriptor);
rssic[1]=RxDescriptorRssiAnt01(descriptor);
rssic[2]=RxDescriptorRssiAnt02(descriptor);
rssie[0]=RxDescriptorRssiAnt10(descriptor);
rssie[1]=RxDescriptorRssiAnt11(descriptor);
rssie[2]=RxDescriptorRssiAnt12(descriptor);
for(ii=0; ii<3; ii++)
{
if(rssic[ii]&0x80)
{
rssic[ii]|=0xffffff00;
}
if(rssie[ii]&0x80)
{
rssie[ii]|=0xffffff00;
}
}
ndata=RxDescriptorDataLen(descriptor);
MyMemoryRead(LinkRxLoopBuffer[it%LinkRxLoopMany], (unsigned int *)data, ndata);
nspectrum=Ar9300SpectralScanProcess(data,ndata,spectrum,MSPECTRUM);
if(_LinkRxSpectralScanFunction!=0)
{
(*_LinkRxSpectralScanFunction)(rssi,rssic,rssie,MCHAIN,spectrum,nspectrum);
}
//
// extract stats
if (!vsgSync)
{
vsgSync = ((rssic[0] >= ISSM80DBM_THRESHOLD) && (chainMask & (1 << 0)) ||
(rssic[1] >= ISSM80DBM_THRESHOLD) && (chainMask & (1 << 1)) ||
(rssic[2] >= ISSM80DBM_THRESHOLD) && (chainMask & (1 << 2)) );
}
else
{
LinkRxStatSpectralScanExtract(descriptor,it);
sscount++;
//UserPrint("ss_cnt:rssic:mask %d, %d, %d, %d\n",sscount, rssic[0], rssic[1], chainMask);
}
if(sscount >= SASAMPLINGS)
{
break;
}
}
}
else
{
// dump packet contents
//
if(ndump>0)
{
UserPrint("\n");
LinkRxDump(descriptor, ndump, it%LinkRxLoopMany);
}
//
// extract stats
//
LinkRxStatExtract(descriptor,it);
}
//
// reset the descriptor so that we can use it again
//
RxDescriptorReset(descriptor);
#ifdef MEMORYREAD
//
// copy it back to the shared memory
//
MyMemoryWrite(mDescriptor,descriptor,dsize);
#endif
//
// need to queue the descriptor with the hardware
//
if(LinkRxDescriptorFifo)
{
DeviceReceiveDescriptorPointer(mDescriptor);
}
}
//
// descriptor not ready
//
else
{
if(stop)
{
scount++;
if(scount>200)
{
break;
}
}
it--;
//
// sleep every other time, need to keep up with fast rates
//
if(notdone>100)
{
UserPrint(".");
// MyDelay(1);
notdone=0;
}
else
{
notdone=1; // this makes sure we never sleep
}
}
//
// check for message from cart telling us to stop
// this is the normal terminating condition
//
pass++;
if(pass>100)
{
if(done!=0)
{
isdone=(*done)();
if(isdone!=0)
{
UserPrint(" %d Stop",it);
if(stop==0)
{
stop=1;
scount=0;
behind=0;
}
//
// immediate stop
//
if(isdone==2)
{
break;
}
// break;
}
}
pass=0;
//
// check for timeout
// rare terminating condition when cart crashes or disconnects
//
ctime=TimeMillisecond();
#if 1
if( timeout>0 && ((endTime>startTime && (ctime>endTime || ctime<startTime)) || (endTime<startTime && ctime>endTime && ctime<startTime)))
{
UserPrint("%d Timeout",it);
break;
}
#endif
}
}
//
// cleanup
//
if(_LinkRxSpectralScan)
{
//DeviceSpectralScanDisable();
Ar9300SpectralScanDisable();
}
DeviceReceiveDisable();
LinkRxLoopDestroy(0);
//
// do data verify if requested
//
UserPrint(" %d\n",it);
LinkRxStatFinish();
return;
}
