OpenCores
URL https://opencores.org/ocsvn/pcie_ds_dma/pcie_ds_dma/trunk

Subversion Repositories pcie_ds_dma

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /pcie_ds_dma/trunk/soft/linux
    from Rev 5 to Rev 6
    ↔ Reverse comparison
  •

Rev 5 → Rev 6

/application/adm_test/src/work/tf_teststrm.cpp
4,6 → 4,7
#include <fcntl.h>
#include <pthread.h>
#include <unistd.h>
#include <math.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <pthread.h>
10,7 → 11,6
#include "utypes.h"
#include "tf_teststrm.h"
#include "cl_ambpex.h"
//#include "useful.h"
 
#define BUFSIZEPKG 62
 
22,17 → 22,21
#define TRDIND_SPD_DATA 0x206
 
#define TRDIND_TESTSEQ 0x0C
#define TRDIND_CHAN 0x10
#define TRDIND_FSRC 0x13
#define TRDIND_GAIN 0x15
#define TRDIND_CHAN 0x10
#define TRDIND_FSRC 0x13
#define TRDIND_GAIN 0x15
#define TRDIND_CONTROL1 0x17
#define TRDIND_DELAY_CTRL 0x1F
 
//-----------------------------------------------------------------------------
 
int GetTickCount(void)
{
return time( NULL);
}
 
//-----------------------------------------------------------------------------
 
TF_TestStrm::TF_TestStrm( char* fname, CL_AMBPEX *pex )
{
lc_status=0;
53,12 → 57,17
isFirstCallStep=true;
}
 
//-----------------------------------------------------------------------------
 
TF_TestStrm::~TF_TestStrm()
{
pBrd->StreamDestroy( rd0.Strm );
//delete bufIsvi; bufIsvi=NULL;
delete bufIsvi;
bufIsvi=NULL;
}
 
//-----------------------------------------------------------------------------
 
void TF_TestStrm::Prepare( void )
{
PrepareAdm();
66,12 → 75,12
rd0.trd=trdNo;
rd0.Strm=strmNo;
pBrd->StreamInit( rd0.Strm, CntBuffer, SizeBuferOfBytes, rd0.trd, 1, isCycle, isSystem, isAgreeMode );
//pBrd->StreamInit( rd0.Strm, CntBuffer, SizeBuferOfBytes, rd0.trd, 2, isCycle, isSystem, isAgreeMode );
 
bufIsvi = new U32[SizeBlockOfWords*2];
//pBrd->StreamInit( strm, CntBuffer, SizeBuferOfBytes, rd0.trd, 1, 0, 0 );
}
 
//-----------------------------------------------------------------------------
 
void TF_TestStrm::Start( void )
{
int res = pthread_attr_init(&attrThread_);
111,35 → 120,47
}
}
 
//-----------------------------------------------------------------------------
 
void TF_TestStrm::Stop( void )
{
Terminate=1;
lc_status=3;
//BRDC_fprintf( stderr, "TF_TestStrm::Stop(): lc_status = %d\n", lc_status );
}
 
//-----------------------------------------------------------------------------
 
void TF_TestStrm::Step( void )
{
rd0.testBuf.check_result( &rd0.BlockOk , &rd0.BlockError, NULL, NULL, NULL );
 
/*
pkg_in.testBuf.check_result( &pkg_in.BlockOk , &pkg_in.BlockError, NULL, NULL, NULL );
rd0.testBuf.check_result( &rd0.BlockOk , &rd0.BlockError, NULL, NULL, NULL );
rd1.testBuf.check_result( &rd1.BlockOk , &rd1.BlockError, NULL, NULL, NULL );
*/
U32 status = pBrd->RegPeekDir( rd0.trd, 0 ) & 0xFFFF;
 
rd0.testBuf.check_result( &rd0.BlockOk , &rd0.BlockError, NULL, NULL, NULL );
U32 cnt_rd=rd0.BlockRd;
if( isRestart )
cnt_rd = cntRestart;
 
//BRDC_fprintf( stderr, "%10s %10d %10d %10d %10d\n", "PACKAGE :", pkg_out.BlockWr, pkg_in.BlockRd, pkg_in.BlockOk, pkg_in.BlockError );
//BRDC_fprintf( stderr, "%10s %10d %10d %10d %10d\n", "FIFO_0 :", tr0.BlockWr, rd0.BlockRd, rd0.BlockOk, rd0.BlockError );
//BRDC_fprintf( stderr, "%10s %10d %10d %10d %10d\n", "FIFO_1 :", tr1.BlockWr, rd1.BlockRd, rd1.BlockOk, rd1.BlockError );
BRDC_fprintf( stderr, "%6s %3d %10d %10d %10d %10d %9.1f %10.1f 0x%.4X %d %4d\r", "TRD :", rd0.trd, rd0.BlockWr, cnt_rd, rd0.BlockOk, rd0.BlockError, rd0.VelocityCurrent, rd0.VelocityAvarage, status, IsviStatus, IsviCnt );
 
U32 status = pBrd->RegPeekDir( rd0.trd, 0 ) & 0xFFFF;
BRDC_fprintf( stderr, "%6s %3d %10d %10d %10d %10d %9.1f %10.1f 0x%.4X %d %4d\r", "TRD :", rd0.trd, rd0.BlockWr, rd0.BlockRd, rd0.BlockOk, rd0.BlockError, rd0.VelocityCurrent, rd0.VelocityAvarage, status, IsviStatus, IsviCnt );
if( isSystemMonitor )
{
unsigned temp;
float ty;
pBrd->RegPokeInd( 0, 0x210, 0 );
temp = pBrd->RegPeekInd( 0, 0x211 );
 
temp >>=6;
temp &= 0x3FF;
ty = (temp*503.975)/1024-273.15;
 
BRDC_fprintf( stderr, "%6s %3d %10.1f\n", "SYSMON", 0, ty );
 
 
}
}
 
//-----------------------------------------------------------------------------
 
int TF_TestStrm::isComplete( void )
{
if( (lc_status==4) && (IsviStatus==100) )
147,12 → 168,11
return 0;
}
 
//-----------------------------------------------------------------------------
 
void TF_TestStrm::GetResult( void )
{
//if(pkg_in.BlockRd!=0 && pkg_in.BlockError!=0)
// printf("%s\n", pkg_in.testBuf.report_word_error());
 
BRDC_fprintf( stderr, "\n\nResult of receiving data from tetrade %d \n", trdNo );
BRDC_fprintf( stderr, "\n\nResult of receiving data from trd %d \n", trdNo );
if(rd0.BlockRd!=0 && rd0.BlockError!=0)
printf("%s\n", rd0.testBuf.report_word_error());
 
159,6 → 179,8
BRDC_fprintf( stderr, "\n\n" );
}
 
//-----------------------------------------------------------------------------
 
void* TF_TestStrm::ThreadFunc( void* lpvThreadParm )
{
TF_TestStrm *test=(TF_TestStrm*)lpvThreadParm;
169,6 → 191,8
return (void*)ret;
}
 
//-----------------------------------------------------------------------------
 
void* TF_TestStrm::ThreadFuncIsvi( void* lpvThreadParm )
{
TF_TestStrm *test=(TF_TestStrm*)lpvThreadParm;
181,17 → 205,20
return (void*)ret;
}
 
//-----------------------------------------------------------------------------
 
//! Установка параметров по умолчанию
void TF_TestStrm::SetDefault( void )
{
int ii=0;
 
array_cfg[ii++]=STR_CFG( 0, "CntBuffer", "16", (U32*)&CntBuffer, "Stream buffers number" );
array_cfg[ii++]=STR_CFG( 0, "CntBuffer", "16", (U32*)&CntBuffer, "Stream buffers number" );
array_cfg[ii++]=STR_CFG( 0, "CntBlockInBuffer", "512", (U32*)&CntBlockInBuffer, "Blocks in buffer" );
array_cfg[ii++]=STR_CFG( 0, "SizeBlockOfWords", "2048", (U32*)&SizeBlockOfWords, "Block size (in words)" );
array_cfg[ii++]=STR_CFG( 0, "isCycle", "1", (U32*)&isCycle, "1 - Stream working in cycle mode" );
array_cfg[ii++]=STR_CFG( 0, "isSystem", "1", (U32*)&isSystem, "1 - system memory allocation" );
array_cfg[ii++]=STR_CFG( 0, "isAgreeMode", "0", (U32*)&isAgreeMode, "1 - adjust mode" );
array_cfg[ii++]=STR_CFG( 0, "isCycle", "1", (U32*)&isCycle, "1 - Stream working in cycle mode" );
array_cfg[ii++]=STR_CFG( 0, "isSystem", "1", (U32*)&isSystem, "1 - system memory allocation" );
array_cfg[ii++]=STR_CFG( 0, "isAgreeMode", "0", (U32*)&isAgreeMode, "1 - adjust mode" );
array_cfg[ii++]=STR_CFG( 0, "isRestart", "0", (U32*)&isRestart, "1 - Перезапуск АЦП" );
 
array_cfg[ii++]=STR_CFG( 0, "trdNo", "4", (U32*)&trdNo, "Номер тетрады" );
array_cfg[ii++]=STR_CFG( 0, "strmNo", "0", (U32*)&strmNo, "Номер стрма" );
198,18 → 225,13
array_cfg[ii++]=STR_CFG( 0, "isTest", "0", (U32*)&isTest, "0 - нет, 1 - проверка псевдослучайной последовательности, 2 - проверка тестовой последовательности" );
array_cfg[ii++]=STR_CFG( 0, "isMainTest", "0", (U32*)&isMainTest, "1 - включение режима тестирования в тетраде MAIN" );
 
array_cfg[ii++]=STR_CFG( 0, "lowRange", "0", (U32*)&lowRange, "нижний уровень спектра" );
array_cfg[ii++]=STR_CFG( 0, "topRange", "0", (U32*)&topRange, "верхний уровень спектра" );
array_cfg[ii++]=STR_CFG( 0, "fftSize", "2048", (U32*)&fftSize, "размер БПФ" );
 
 
fnameAdmReg=NULL;
array_cfg[ii++]=STR_CFG( 2, "AdmReg", "adcreg.ini", (U32*)&fnameAdmReg, "имя файла регистров" );
array_cfg[ii++]=STR_CFG( 2, "AdmReg", "adcreg.ini", (U32*)&fnameAdmReg, "имя файла регистров" );
 
array_cfg[ii++]=STR_CFG( 0, "isAdmReg", "0", (U32*)&isAdmReg, "1 - разрешение записи регистров из файла AdmReg" );
 
fnameAdmReg2=NULL;
array_cfg[ii++]=STR_CFG( 2, "AdmReg2", "adcreg2.ini", (U32*)&fnameAdmReg2, "имя файла регистров (выполняется после старта стрима)" );
array_cfg[ii++]=STR_CFG( 2, "AdmReg2", "adcreg2.ini", (U32*)&fnameAdmReg2, "имя файла регистров (выполняется после старта стрима)" );
 
array_cfg[ii++]=STR_CFG( 0, "isAdmReg2", "0", (U32*)&isAdmReg2, "1 - разрешение записи регистров из файла AdmReg2" );
 
218,9 → 240,8
 
array_cfg[ii++]=STR_CFG( 0, "ISVI_HEADER", "0", (U32*)&IsviHeaderMode, "режим формирования суффикса ISVI, 0 - нет, 1 - DDC, 2 - ADC" );
 
array_cfg[ii++]=STR_CFG( 0, "FifoRdy", "0", (U32*)&isFifoRdy, "1 - генератор тестовой последовательности анализирует флаг готовности FIFO" );
 
array_cfg[ii++]=STR_CFG( 0, "FifoRdy", "0", (U32*)&isFifoRdy, "1 - генератор тестовой последовательности анализирует флаг готовности FIFO" );
 
array_cfg[ii++]=STR_CFG( 0, "Cnt1", "0", (U32*)&Cnt1, "Число тактов записи в FIFO, 0 - постоянная запись в FIFO" );
 
array_cfg[ii++]=STR_CFG( 0, "Cnt2", "0", (U32*)&Cnt2, "Число тактов паузы при записи в FIFO" );
231,24 → 252,22
 
array_cfg[ii++]=STR_CFG( 0, "isTestCtrl", "0", (U32*)&isTestCtrl, "1 - подготовка тетрады TEST_CTRL" );
 
array_cfg[ii++]=STR_CFG( 0, "TestSeq", "0", (U32*)&TestSeq, "Значение регистра TEST_SEQ" );
 
array_cfg[ii++]=STR_CFG( 0, "TestSeq", "0", (U32*)&TestSeq, "Значение регистра TEST_SEQ" );
 
max_item=ii;
 
{
char str[1024];
char str[1024];
for( unsigned ii=0; ii<max_item; ii++ )
{
{
sprintf( str, "%s %s", array_cfg[ii].name, array_cfg[ii].def );
GetParamFromStr( str );
}
 
 
}
}
 
}
 
//-----------------------------------------------------------------------------
 
//! Расчёт параметров
void TF_TestStrm::CalculateParams( void )
{
259,6 → 278,8
ShowParam();
}
 
//-----------------------------------------------------------------------------
 
//! Отображение параметров
void TF_TestStrm::ShowParam( void )
{
265,26 → 286,14
TF_WorkParam::ShowParam();
 
BRDC_fprintf( stderr, "Total stream buffer size: %d MB\n\n", SizeStreamOfBytes/(1024*1024) );
 
}
 
//-----------------------------------------------------------------------------
 
U32 TF_TestStrm::Execute( void )
{
rd0.testBuf.buf_check_start( 32, 64 );
 
//U32 *buffer = pBrd->StreamGetBufByNum(rd0.Strm,0);
 
//fprintf(stderr, "%s(): buffer = %p\n", __FUNCTION__, buffer);
//getchar();
/*
for(u32 i=0; i<SizeBlockOfWords; i++) {
buffer[i] = 0x1;
}
*/
//Sleep( 100 );
//pBrd->RegPokeInd( 4, 0, 0x2038 );
 
pBrd->RegPokeInd( rd0.trd, 0, 0x2010 );
pBrd->StreamStart( rd0.Strm );
pBrd->RegPokeInd( rd0.trd, 0, 0x2038 );
293,8 → 302,9
StartTestCtrl();
}
 
if( isAdmReg2 )
if( isAdmReg2 ) {
PrepareAdmReg( fnameAdmReg2 );
}
 
pBrd->RegPokeInd( 4, 0, 0x2038 );
 
309,8 → 319,8
}
 
ReceiveData( &rd0 );
//Sleep( 100 );
}
 
pBrd->RegPokeInd( rd0.trd, 0, 2 );
Sleep( 200 );
 
318,12 → 328,14
Sleep( 10 );
 
lc_status=4;
 
//BRDC_fprintf( stderr, "TF_TestStrm::Execute(): lc_status = %d\n", lc_status );
 
return 1;
}
 
//-----------------------------------------------------------------------------
 
 
 
void TF_TestStrm::ReceiveData( ParamExchange *pr )
{
U32 *ptr;
335,10 → 347,6
int ret;
int kk;
 
//pr->BlockRd++;
//Sleep( 10 );
//return;
 
for( kk=0; kk<16; kk++ )
{
ret=pBrd->StreamGetBuf( pr->Strm, &ptr );
345,35 → 353,37
if( ret )
{ // Проверка буфера стрима
 
for( unsigned ii=0; ii<CntBlockInBuffer; ii++ )
{
ptrBlock=ptr+ii*SizeBlockOfWords;
if( isIsvi )
IsviStep( ptrBlock );
for( unsigned ii=0; ii<CntBlockInBuffer; ii++ )
{
ptrBlock=ptr+ii*SizeBlockOfWords;
if( isIsvi )
IsviStep( ptrBlock );
 
if( 1==isTest )
pr->testBuf.buf_check_psd( ptrBlock, SizeBlockOfWords );
//int a=0;
else if( 2==isTest )
pr->testBuf.buf_check( ptrBlock, pr->BlockRd, SizeBlockOfWords, BlockMode );
else if( 4==isTest )
pr->testBuf.buf_check_inv( ptrBlock, SizeBlockOfWords );
if( 1==isTest )
pr->testBuf.buf_check_psd( ptrBlock, SizeBlockOfWords );
//int a=0;
else if( 2==isTest )
pr->testBuf.buf_check( ptrBlock, pr->BlockRd, SizeBlockOfWords, BlockMode );
else if( 4==isTest )
pr->testBuf.buf_check_inv( ptrBlock, SizeBlockOfWords );
 
pr->BlockRd++;
}
//if( isAgreeMode )
//{
// pBrd->StreamGetBufDone( pr->Strm );
//}
pr->BlockRd++;
}
if( isAgreeMode )
{
pBrd->StreamGetBufDone( pr->Strm );
}
if( (1==isRestart) && (pr->BlockRd==(CntBuffer*CntBlockInBuffer) ) )
{
RestartAdc();
}
 
} else
{
//Sleep( 0 );
} else {
 
pr->freeCycle++;
break;
}
}
//Sleep( 0 );
 
U32 currentTime = GetTickCount();
if( (currentTime - pr->time_last)>10 )
391,14 → 401,10
pr->BlockLast = pr->BlockRd;
pr->freeCycleZ=pr->freeCycle;
pr->freeCycle=0;
 
// if(lowRange == 0)
// pr->testBuf.buf_check_sine_show();
//pr->testBuf.buf_check_sine_calc_delta();
}
//Sleep(1);
}
 
//-----------------------------------------------------------------------------
 
void TF_TestStrm::PrepareAdm( void )
{
411,20 → 417,13
id_mod = pBrd->RegPeekInd( trd, 0x101 );
ver = pBrd->RegPeekInd( trd, 0x102 );
 
//pBrd->RegPokeInd( trd, 0, 0x2038 );
 
BRDC_fprintf( stderr, "\nTetrade %d ID: 0x%.2X MOD: %d VER: %d.%d \n\n",
trd, id, id_mod, (ver>>8) & 0xFF, ver&0xFF );
trd, id, id_mod, (ver>>8) & 0xFF, ver&0xFF );
 
 
//if( fnameDDS )
// PrepareDDS();
 
 
if( isMainTest )
PrepareMain();
 
 
BlockMode = DataType <<8;
BlockMode |= DataFix <<7;
 
434,7 → 433,6
if( isAdmReg )
PrepareAdmReg( fnameAdmReg );
 
 
IsviStatus=0;
IsviCnt=0;
isIsvi=0;
443,23 → 441,9
IsviStatus=1;
isIsvi=1;
}
/*
pBrd->RegPokeInd( trd, 25, 3 );
pBrd->RegPokeInd( trd, 16, 3 );
pBrd->RegPokeInd( trd, 0x13, 0);
pBrd->RegPokeInd( trd, 28, 0 );
*/
//pBrd->RegPokeInd( trd, 0x1B, 0x100 );
 
// pBrd->RegPokeInd( trdSdram, 0, 1 );
 
 
 
}
 
 
 
 
//-----------------------------------------------------------------------------
//! Подготовка MAIN
void TF_TestStrm::PrepareMain( void )
{
466,10 → 450,10
 
if( 4==isTest )
{
BRDC_fprintf( stderr, "В тетраде MAIN установлен режим формирования двоично-инверсной последовательности\n" );
BRDC_fprintf( stderr, "In tetrade MAIN set mode of binary-inversion sequence\n" );
} else
{
BRDC_fprintf( stderr, "В тетраде MAIN установлен режим формирования псевдослучайной последовательности\n" );
BRDC_fprintf( stderr, "In tetrade MAIN set of pseudo-random mode sequence\n" );
pBrd->RegPokeInd( 0, 12, 1 ); // Регистр TEST_MODE[0]=1 - режим формирования псевдослучайной последовательности
}
pBrd->RegPokeInd( 0, 0, 2 ); // Сброс FIFO - перевод в начальное состояние
478,6 → 462,8
Sleep( 1 );
}
 
//-----------------------------------------------------------------------------
 
void TF_TestStrm::IsviStep( U32* ptr )
{
unsigned ii;
488,6 → 474,8
}
}
 
//-----------------------------------------------------------------------------
 
void TF_TestStrm::WriteFlagSinc(int flg, int isNewParam)
{
int fs = -1;
503,10 → 491,15
}
val[0] = flg;
val[1] = isNewParam;
write( fs, val, 8 );
int res = write( fs, val, 8 );
if(res < 0) {
BRDC_fprintf( stderr, "Error write flag sync\r\n" );
}
close( fs );
}
 
//-----------------------------------------------------------------------------
 
int TF_TestStrm::ReadFlagSinc(void)
{
int fs = -1;
520,12 → 513,17
fs = open( fname, O_RDWR|O_CREAT, 0666 );
Sleep( 10 );
}
read( fs, &flg, 4 );
int res = read( fs, &flg, 4 );
if(res < 0) {
BRDC_fprintf( stderr, "Error read flag sync\r\n" );
}
close( fs );
 
return flg;
}
 
//-----------------------------------------------------------------------------
 
void TF_TestStrm::WriteDataFile( U32 *pBuf, U32 sizew )
{
char fname[256];
538,13 → 536,20
}
 
write( fl, pBuf, sizew*4 );
int res = write( fl, pBuf, sizew*4 );
if(res < 0) {
BRDC_fprintf( stderr, "Error write ISVI data\r\n" );
}
 
write( fl, IsviHeaderStr, IsviHeaderLen );
res = write( fl, IsviHeaderStr, IsviHeaderLen );
if(res < 0) {
BRDC_fprintf( stderr, "Error write ISVI header\r\n" );
}
 
close( fl );
}
 
//-----------------------------------------------------------------------------
 
U32 TF_TestStrm::ExecuteIsvi( void )
{
559,32 → 564,32
switch( IsviStatus )
{
case 2: // Подготовка суффикса
{
IsviHeaderStr[0]=0;
/*
switch( IsviHeaderMode )
{
case 1: SetFileHeaderDdc( SizeBlockOfWords, IsviHeaderStr ); break;
case 2: SetFileHeaderAdc( SizeBlockOfWords, IsviHeaderStr ); break;
}
*/
IsviHeaderLen = 0; //strlen( IsviHeaderStr );
WriteFlagSinc(0,0);
WriteDataFile( bufIsvi, SizeBlockOfWords );
WriteFlagSinc(0xffffffff,0xffffffff);
{
IsviHeaderStr[0]=0;
/*
switch( IsviHeaderMode )
{
case 1: SetFileHeaderDdc( SizeBlockOfWords, IsviHeaderStr ); break;
case 2: SetFileHeaderAdc( SizeBlockOfWords, IsviHeaderStr ); break;
}
*/
IsviHeaderLen = 0; //strlen( IsviHeaderStr );
WriteFlagSinc(0,0);
WriteDataFile( bufIsvi, SizeBlockOfWords );
WriteFlagSinc(0xffffffff,0xffffffff);
 
IsviCnt++;
IsviStatus=3;
}
IsviCnt++;
IsviStatus=3;
}
break;
 
case 3:
{
rr=ReadFlagSinc();
if( 0==rr )
IsviStatus=4;
{
rr=ReadFlagSinc();
if( 0==rr )
IsviStatus=4;
 
}
}
break;
 
case 4:
593,12 → 598,12
break;
 
case 5:
{
WriteDataFile( bufIsvi, SizeBlockOfWords );
WriteFlagSinc(0xffffffff,0 );
IsviStatus=3;
IsviCnt++;
}
{
WriteDataFile( bufIsvi, SizeBlockOfWords );
WriteFlagSinc(0xffffffff,0 );
IsviStatus=3;
IsviCnt++;
}
break;
 
}
609,9 → 614,9
return 0;
}
 
//-----------------------------------------------------------------------------
 
#define TRD_CTRL 1
 
#define REG_MUX_CTRL 0x0F
#define REG_GEN_CNT1 0x1A
#define REG_GEN_CNT2 0x1B
619,9 → 624,9
#define REG_GEN_SIZE 0x1F
#define TRD_DIO_IN 6
#define TRD_CTRL 1
//#define TRD_DIO_IN
 
//-----------------------------------------------------------------------------
//! Подготовка TEST_CTRL
 
void TF_TestStrm::PrepareTestCtrl( void )
{
BRDC_fprintf( stderr, "\nПодготовка тетрады TEST_CTRL\n" );
666,7 → 671,7
pBrd->RegPokeInd( TRD_CTRL, REG_GEN_CNT2, Cnt2 );
float sp=1907.348632812 * (Cnt1-1)/(Cnt1+Cnt2-2);
BRDC_fprintf( stderr, "Установлено ограничение скорости формирования потока: %6.1f МБайт/с \r\n"
"REG_CNT1=%d REGH_CNT2=%d \r\n", sp, Cnt1, Cnt2 );
"REG_CNT1=%d REGH_CNT2=%d \r\n", sp, Cnt1, Cnt2 );
if( block_mode&0x1000 )
{
BRDC_fprintf( stderr, "Установлен режим без ожидания готовности FIFO\r\n\r\n" );
679,12 → 684,11
pBrd->RegPokeInd( TRD_CTRL, REG_GEN_CNT1, 0 );
pBrd->RegPokeInd( TRD_CTRL, REG_GEN_CNT2, 0 );
BRDC_fprintf( stderr, "Установлено формирование потока на максимальной скорости: 1907 МБайт/с \r\n"
"Установлено ожидание готовности FIFO \r\n\r\n" );
"Установлено ожидание готовности FIFO \r\n\r\n" );
}
 
 
}
 
//-----------------------------------------------------------------------------
//! Запуск TestCtrl
void TF_TestStrm::StartTestCtrl( void )
{
708,16 → 712,16
 
}
 
 
//-----------------------------------------------------------------------------
//! Запись регистров из файла
void TF_TestStrm::PrepareAdmReg( char* fname )
{
BRDC_fprintf( stderr, "\nУстановка регистров из файла %s\r\n\n", fname );
BRDC_fprintf( stderr, "\nSetting up ADM registers from file: %s\r\n\n", fname );
 
FILE *in = fopen( fname, "rt" );
if( in==NULL )
{
throw( "Ошибка доступа к файлу " );
throw( "Error file access" );
}
 
char str[256];
742,3 → 746,47
BRDC_fprintf( stderr, "\n\n" );
}
 
//-----------------------------------------------------------------------------
 
void TF_TestStrm::RestartAdc( void )
{
pBrd->RegPokeInd( rd0.trd, 0, 2 );
Sleep( 100 );
 
pBrd->StreamStop( rd0.Strm );
Sleep( 100 );
 
pBrd->RegPokeInd( rd0.trd, 0, 0x2000 );
 
pBrd->StreamStart( rd0.Strm );
Sleep( 100 );
 
rd0.BlockRd=0;
cntRestart++;
 
pBrd->RegPokeInd( rd0.trd, 0, 0x2038 );
}
 
//-----------------------------------------------------------------------------
 
void TF_TestStrm::RestartDac( void )
{
U32 trdDac = 5;
 
pBrd->RegPokeInd( trdDac, 0, 2 );
Sleep( 100 );
}
 
//-----------------------------------------------------------------------------
 
void TF_TestStrm::PrepareDac( void )
{
U32 trdDac = 5;
 
fprintf(stderr,"%s(): Start DAC\n", __FUNCTION__);
pBrd->RegPokeInd( trdDac, 0x0, 0x0010 );
Sleep( 1 );
pBrd->RegPokeInd( trdDac, 0x0, 0x0030 );
}
 
//-----------------------------------------------------------------------------
/application/adm_test/src/work/tf_teststrm.h
5,8 → 5,8
 
class CL_AMBPEX;
class TF_TestDDS;
class TF_Emac;
 
 
class TF_TestStrm : public TF_WorkParam, public TF_Test
{
 
96,7 → 96,6
//! Отображение параметров
virtual void ShowParam( void );
 
 
U32 Terminate;
U32 BlockRd;
U32 BlockOk;
103,14 → 102,14
U32 BlockError;
U32 TotalError;
 
U32 CntBuffer; // Число буферов стрима
U32 CntBuffer; // Число буферов стрима
U32 CntBlockInBuffer; // Число блоков в буфере
U32 SizeBlockOfWords; // Размер блока в словах
U32 SizeBlockOfBytes; // Размер блока в байтах
U32 SizeBuferOfBytes; // Размер буфера в байтах
U32 SizeStreamOfBytes; // Общий размер буфера стрима
U32 isCycle; // 1 - циклический режим работы стрима
U32 isSystem; // 1 - системная память
U32 isCycle; // 1 - циклический режим работы стрима
U32 isSystem; // 1 - системная память
U32 isAgreeMode; // 1 - согласованный режим
 
U32 trdNo; // номер тетрады
118,10 → 117,6
U32 isTest; // 1 - проверка псевдослучайной последовательности, 2 - проверка тестовой последовательности
U32 isMainTest; // 1 - включение режима тестирования в тетараде MAIN
 
U32 lowRange;
U32 topRange;
U32 fftSize;
 
U32 isFifoRdy; // 1 - генератор тестовой последовательности анализирует флаг готовности FIFO
U32 Cnt1; // Число тактов записи в FIFO, 0 - постоянная запись в FIFO
U32 Cnt2; // Число тактов паузы при записи в FIFO
158,35 → 153,29
U32 lc_status;
float cpuFreq;
 
ParamExchange rd0;
ParamExchange rd0;
 
 
 
//void SendPkg( ParamExchange *pr );
//void ReceivePkg( ParamExchange *pr );
//void SendData( ParamExchange *pr );
void ReceiveData( ParamExchange *pr );
 
U32 TestSeq; // Региср управления режимом формирования тестовой последовательности
 
void RestartAdc( void );
 
U32 isRestart; // 1 - перезапуск сбора после завершения заполнения буфера стрима
U32 cntRestart; // число перезапусков
 
U32 isSystemMonitor; //!< 1 - чтение данных системного монитора
 
private :
 
bool isFirstCallStep;
 
void PrepareAdm( void );
 
void PrepareAdmReg( char* fname );
 
 
//! Подготовка MAIN
void PrepareAdc( void );
void PrepareDac( void );
void RestartDac(void);
void PrepareMain( void );
 
//! Подготовка TEST_CTRL
void PrepareTestCtrl( void );
 
//! Запуск TestCtrl
void StartTestCtrl( void );
 
 
};
/application/adm_test/src/work/main.cpp
31,10 → 31,9
#include "tf_test.h"
#include "tf_teststrm.h"
#include "tf_teststrmout.h"
//#include "useful.h"
 
#define DEVICE_NAME "/dev/AMBPEXARM_DEVID0"
//#define DEVICE_NAME "/dev/AMBPEX50"
#define DEVICE_NAME "/dev/pexdrv0"
 
CL_AMBPEX *pBrd = NULL;
U32 isTwoTest=0;
static volatile int exit_flag = 0;
74,6 → 73,7
{
BRDC_fprintf( stderr, _BRDC("Module "DEVICE_NAME" successfuly opened\n") );
 
 
for( int trd=0; trd<8; trd++ )
pBrd->RegPokeInd( trd, 0, 1 );
 
85,6 → 85,7
pBrd->RegPokeInd( trd, 0, 0 );
 
 
 
} else
{
BRDC_fprintf( stderr, _BRDC("Error open module "DEVICE_NAME": ret=0x%.8X\n"), ret );
119,51 → 120,37
 
//int key;
int isFirstCallStep=1;
int isStopped = 0;
for( ; ; )
{
//if( kbhit() )
//{
//int key=getch();
if( exit_flag )
{
if( exit_flag )
{
if(!isStopped) {
pTest->Stop();
if( pTest2 )
if( pTest2 ) {
pTest2->Stop();
}
BRDC_fprintf( stderr, _BRDC("\n\nCancel\n") );
isStopped = 1;
}
/*
if( key=='i' )
{
pBrd->RegPokeInd( 4, TRDIND_DELAY_CTRL, 0x12 );
pBrd->RegPokeInd( 4, TRDIND_DELAY_CTRL, 0x10 );
g_DelayCnt--; BRDC_fprintf( stderr, "\n\ng_DelayCnt = %d ", g_DelayCnt );
}
}
 
if( key=='o' )
{
pBrd->RegPokeInd( 4, TRDIND_DELAY_CTRL, 0x13 );
pBrd->RegPokeInd( 4, TRDIND_DELAY_CTRL, 0x11 );
g_DelayCnt++; BRDC_fprintf( stderr, "\n\ng_DelayCnt = %d ", g_DelayCnt );
}
*/
//}
if( exit_flag )
{
if(isStopped) {
 
ret=pTest->isComplete();
if( ret )
{
if( pTest2 )
{
ret=pTest2->isComplete();
if( ret )
break;
} else
{
break;
if( pTest->isComplete() ) {
 
if( pTest2 ) {
if( pTest2->isComplete() )
break;
} else {
break;
}
}
}
 
}
 
//SetConsoleCursorPosition(hConsoleOut, rCursorPosition);
if( isFirstCallStep || isTwoTest )
{
 
184,18 → 171,14
if( isTwoTest )
BRDC_fprintf( stderr, "\n\n" );
 
Sleep( 400 );
Sleep( 1400 );
 
fflush( stdout );
 
if(exit_flag)
break;
}
pTest->GetResult();
if( pTest2 )
pTest2->GetResult();
 
 
delete pTest; pTest=NULL;
delete pTest2; pTest2=NULL;
 
209,7 → 192,7
BRDC_fprintf( stderr, _BRDC("Неизвестная ошибка выполнения программы\n") );
}
 
BRDC_fprintf( stderr, "\n Press any key\n" );
BRDC_fprintf( stderr, "Exit program\n" );
 
return 0;
}
/application/adm_test/src/Makefile
12,14 → 12,28
CC = $(CROSS_COMPILE)g++
LD = $(CROSS_COMPILE)g++
 
CFLAGS := -D__LINUX__ -O2 -Wall -I../../../driver/pexdrv -I../../../common/board -I../../../common/pex -I./work -I./utils
LFLAGS := -Wl -ldl -lrt -lpthread
SRCDIR := board pex work utils
INCDIR := . \
../../../driver/pexdrv \
../../../common/board \
../../../common/pex \
../../../common/utils \
../../../common/dac \
../../../common/adc \
../../../common/dma
INCLUDE := $(addprefix -I, $(INCDIR))
 
CFLAGS := -D__LINUX__ -O2 -Wall $(INCLUDE)
LFLAGS := -Wl -ldl -lrt -lpthread -lm
 
SRCFILE := $(wildcard *.cpp)
SRCFILE += $(wildcard ../../../common/board/*.cpp)
SRCFILE += $(wildcard ../../../common/pex/*.cpp)
SRCFILE += $(wildcard ../../../common/board/*.cpp)
SRCFILE += $(wildcard ./work/*.cpp)
SRCFILE += $(wildcard ./utils/*.cpp)
SRCFILE += $(wildcard ../../../common/utils/*.cpp)
#SRCFILE += $(wildcard ../../../common/dma/*.cpp)
#SRCFILE += $(wildcard ../../../common/adc/*.cpp)
#SRCFILE += $(wildcard ../../../common/dac/*.cpp)
SRCFILE += $(wildcard ./work/*.cpp)
OBJFILE := $(patsubst %.cpp,%.o, $(SRCFILE))
 
$(TARGET_NAME): $(OBJFILE)
/application/adm_test/bin/test_main.cfg
0,0 → 1,59
 
CntBuffer 8 ; число буферов стрима
 
CntBlockInBuffer 1 ; Число блоков в буфере
 
;SizeBlockOfWords 4096 ; Размер блока в словах 4KB
SizeBlockOfWords 262144 ; Размер блока в словах 1MB
;SizeBlockOfWords 1048576 ; Размер блока в словах 1MB
;SizeBlockOfWords 4194304 ; Размер блока в словах 4MB
 
isCycle 1 ; 1 - циклический режим работы стрима
 
isAgreeMode 1 ; 1 - согласованный режим работы
 
isSystem 1 ; 1 - системная память
 
 
isMainTest 1 ; 1 - включение режима тестирования в тетраде MAIN
 
isSdram 0 ; 1 - инициализация SDRAM
 
trdNo 0 ; Номер тетрады
 
strmNo 1 ; Номер стрима
 
isDDC 0 ; 2 - АЦП, 1 - DDC
 
ISVI_FILE data_main ; имя файла данных ISVI
 
;ISVI_HEADER 2 ; 2 - установка параметров для АЦП, 1 - для DDC
 
 
isTest 1 ; 0 - нет проверки
; 1 - проверка псевдослучайной последовательности
; 2 - проверка тестовой последовательности
; 4 - проверка двоично-инверсной последовательности
; 5 - проверка синусоидального сигнала с использованием БПФ и библиотеки IPP от Intel
 
FifoRdy 1 ; 1 - генератор тестовой последовательности анализирует флаг готовности FIFO
 
Cnt1 0 ; Число тактов записи в FIFO, 0 - постоянная запись в FIFO
 
Cnt2 0 ; Число тактов паузы при записи в FIFO
 
DataType 6 ; Тип данных при фиксированном типе блока, 6 - счётчик, 8 - псевдослучайная последовательность
 
DataFix 1 ; 1 - фиксированный тип блока, 0 - данные в блоке записят от номера блока
 
isTestCtrl 0 ; 1 - подготовка тетрады TEST_CTRL
 
isCheckLvds 1 ; 1 - проверка LVDS_FPGA
 
isEmac0 3 ; 1 - приём через EMAC0, 2 - передача через EMAC0, 3 - приём и передача через EMAC0
 
isEmac1 3 ; 1 - приём через EMAC1, 2 - передача через EMAC1, 3 - приём и передача через EMAC1
 
isSystemMonitor 1 ; 1 - чтение данных системного монитора
 
isCheckInOutControl 1 ; 1 - проверка сигналов in_control, out_control
/application/board_exam/main.cpp
1,6 → 1,6
 
#ifndef __PEX_H__
#include "pex_board.h"
#ifndef __BOARD_H__
#include "board.h"
#endif
 
#include <cassert>
10,6 → 10,7
#include <iomanip>
#include <climits>
#include <cstdio>
#include <dlfcn.h>
 
//-----------------------------------------------------------------------------
 
16,58 → 17,136
using namespace std;
 
//-----------------------------------------------------------------------------
#define NUM_BLOCK 4
#define BLOCK_SIZE 0x1000
#define NUM_BLOCK 8
#define BLOCK_SIZE 0x10000
//-----------------------------------------------------------------------------
 
int main(int argc, char *argv[])
{
if(argc == 1) {
std::cerr << "usage: %s <device name>" << argv[0] << endl;
if(argc != 3) {
std::cerr << "usage: " << argv[0] << " <libname.so> </dev/devname>" << endl;
return -1;
}
 
std ::cout << "Start testing device " << argv[1] << endl;
 
char *libname = argv[1];
char *devname = argv[2];
int dmaChan = 0;
void* pBuffers[NUM_BLOCK] = {NULL};
void* pBuffers[NUM_BLOCK] = {NULL,NULL,NULL,NULL};
void *hlib = NULL;
board_factory factory = NULL;
board *brd = NULL;
u32 *buffer = NULL;
 
board *brd = new pex_board();
brd->brd_open(argv[1]);
std ::cout << "Loading library: " << libname << endl;
 
hlib = dlopen(libname, RTLD_LAZY);
if(!hlib) {
fprintf(stderr, "%s\n", dlerror());
return -1;
}
 
factory = (board_factory)dlsym(hlib, "create_board");
if(!factory) {
fprintf(stderr, "%s\n", dlerror());
dlclose(hlib);
return -1;
}
 
std ::cout << "Start testing device " << devname << endl;
 
brd = factory();
if(!brd) {
dlclose(hlib);
return -1;
}
 
if(brd->brd_open(devname) < 0) {
 
delete brd;
 
if(hlib) {
int res = dlclose(hlib);
if(res < 0) {
fprintf(stderr, "%s\n", dlerror());
return -1;
}
}
 
return -1;
}
 
brd->brd_init();
brd->brd_pld_info();
 
std::cout << "Reset FPGA..." << std::endl;
brd->brd_reg_poke_ind(0,0,1);
brd->brd_delay(100);
brd->brd_reg_poke_ind(0,0,0);
brd->brd_delay(100);
 
std::cout << "Init FPGA..." << std::endl;
for( int trd=0; trd<8; trd++ ) {
brd->brd_reg_poke_ind( trd, 0, 1 );
}
for( int trd=0; trd<8; trd++ ) {
for( int ii=1; ii<32; ii++ ) {
brd->brd_reg_poke_ind( trd, ii, 0 );
}
}
for( int trd=0; trd<8; trd++ ) {
brd->brd_reg_poke_ind( trd, 0, 0 );
}
 
std ::cout << "Press enter to allocate DMA memory..." << endl;
getchar();
 
int DmaChan = 1;
 
// Check BRDSHELL DMA interface
BRDctrl_StreamCBufAlloc sSCA = {
1, //dir
1,
1,
NUM_BLOCK,
BLOCK_SIZE,
&pBuffers[0],
pBuffers,
NULL,
};
 
brd->dma_alloc(dmaChan, &sSCA);
 
brd->dma_set_local_addr(DmaChan, 0x1000);
brd->dma_stop(DmaChan);
brd->dma_reset_fifo(DmaChan);
brd->dma_reset_fifo(DmaChan);
 
std ::cout << "Press enter to start DMA channel..." << endl;
getchar();
 
// fill data buffers
for(int j=0; j<NUM_BLOCK; j++) {
buffer = (u32*)pBuffers[j];
for(unsigned i=0; i<32; i++) {
buffer[i] = 0xAA556677;
}
}
 
brd->dma_start(dmaChan, 0);
 
std ::cout << "Press enter to stop DMA channel..." << endl;
getchar();
 
 
brd->dma_stop(dmaChan);
 
std ::cout << "Press enter to view DMA data (buffer 0)..." << endl;
getchar();
// show data buffers
for(int j=0; j<NUM_BLOCK; j++) {
 
u32 *buffer = (u32*)pBuffers[0];
for(unsigned i=0; i<BLOCK_SIZE/4; i+=128) {
std::cout << hex << buffer[i] << " ";
std ::cout << "DMA data buffer " << j << ":" << endl;
buffer = (u32*)pBuffers[j];
for(unsigned i=0; i<32; i++) {
std::cout << hex << buffer[i] << " ";
}
std ::cout << endl;
}
std::cout << dec << endl;
 
75,19 → 154,18
getchar();
 
brd->dma_free_memory(dmaChan);
/*
for(int i=0; i<16; i++)
std ::cout << "BAR0[" << i << "] = 0x" << hex << brd->brd_bar0_read(i) << dec << endl;
 
fprintf(stderr, "Press enter to read BAR1...\n");
getchar();
 
for(int i=0; i<16; i++)
std ::cout << "BAR1[" << i << "] = 0x" << hex << brd->brd_bar1_read(i) << dec << endl;
*/
brd->brd_close();
 
delete brd;
 
if(hlib) {
int res = dlclose(hlib);
if(res < 0) {
fprintf(stderr, "%s\n", dlerror());
return -1;
}
}
 
return 0;
}
/application/board_exam/Makefile
1,6 → 1,3
#
#change this makefile for your target...
#
 
PHONY = clean
TARGET_NAME = pex_board_test
7,21 → 4,31
 
all: $(TARGET_NAME)
 
ROOT_DIR = $(shell pwd)
BINPATH := ../..
BINDIR := $(BINPATH)/bin
LIBPATH := ../..
LIBDIR := $(LIBPATH)/lib
 
CC = $(CROSS_COMPILE)g++
LD = $(CROSS_COMPILE)g++
CC := $(CROSS_COMPILE)g++
LD := $(CROSS_COMPILE)g++
 
CFLAGS := -D__LINUX__ -g -Wall -I../../driver/pexdrv -I../../common/board -I../../common/pex -I../adm_test/src/utils
LFLAGS := -Wl
SRCDIR := ../../common/board ../../common/pex
#SRCFILE := $(wildcard *.cpp) $(wildcard $(SRCDIR)/*.cpp)
SRCFILE := $(wildcard *.cpp) $(wildcard ../../common/board/*.cpp)
SRCFILE += $(wildcard *.cpp) $(wildcard ../../common/pex/*.cpp)
OBJFILE := $(patsubst %.cpp,%.o, $(SRCFILE))
INCDIR := . \
../../driver/pexdrv \
../../common/board \
../../common/utils
 
$(TARGET_NAME): $(OBJFILE)
$(LD) $(LFLAGS) $(notdir $^) -o $(TARGET_NAME)
INCLUDE := $(addprefix -I, $(INCDIR))
 
#CFLAGS := -D__linux__ -D__VERBOSE__ -g -Wall $(INCLUDE)
CFLAGS := -D__linux__ -O2 -Wall $(INCLUDE)
LFLAGS := -Wl,-rpath $(LIBDIR) -L"$(LIBDIR)" -lboard -ldl -lpthread
 
#EXTFILES := ../common/net/net_board.cpp
#EXTFILES := ../common/net/netcmn.cpp
 
$(TARGET_NAME): $(patsubst %.cpp,%.o, $(wildcard *.cpp)) $(EXTFILES)
$(LD) -o $(TARGET_NAME) $(notdir $^) $(LFLAGS)
cp $(TARGET_NAME) $(BINDIR)
rm -f *.o *~ core
 
%.o: %.cpp
30,6 → 37,9
include $(wildcard *.d)
 
 
test:
@echo $(SRC)
 
clean:
rm -f *.o *~ core
rm -f *.d *~ core
39,7 → 49,3
rm -f *.o *~ core
rm -f *.d *~ core
rm -f $(TARGET_NAME)
 
src:
@echo $(SRCFILE)
@echo $(OBJFILE)
/application/wb_test/src/Makefile
12,12 → 12,28
CC = $(CROSS_COMPILE)g++
LD = $(CROSS_COMPILE)g++
 
CFLAGS := -D__LINUX__ -g -Wall -I./board -I./pex -I./work -I./utils
LFLAGS := -Wl -ldl -lrt -lpthread
SRCDIR := board pex work utils
#SRCFILE := $(wildcard *.cpp) $(wildcard $(SRCDIR)/*.cpp)
INCDIR := . \
../../../driver/pexdrv \
../../../common/board \
../../../common/pex \
../../../common/utils \
../../../common/dac \
../../../common/adc \
../../../common/dma
INCLUDE := $(addprefix -I, $(INCDIR))
 
CFLAGS := -D__LINUX__ -O2 -Wall $(INCLUDE)
LFLAGS := -Wl -ldl -lrt -lpthread -lm
 
SRCFILE := $(wildcard *.cpp)
SRCFILE += $(wildcard pex/*.cpp) $(wildcard board/*.cpp) $(wildcard work/*.cpp) $(wildcard utils/*.cpp)
SRCFILE += $(wildcard ../../../common/board/*.cpp)
SRCFILE += $(wildcard ../../../common/pex/*.cpp)
SRCFILE += $(wildcard ../../../common/utils/*.cpp)
#SRCFILE += $(wildcard ../../../common/dma/*.cpp)
#SRCFILE += $(wildcard ../../../common/adc/*.cpp)
#SRCFILE += $(wildcard ../../../common/dac/*.cpp)
SRCFILE += $(wildcard ./work/*.cpp)
OBJFILE := $(patsubst %.cpp,%.o, $(SRCFILE))
 
$(TARGET_NAME): $(OBJFILE)
/common/utils/utypes.h
1,351 → 1,351
/***************************************************
*
* UTYPES.H - define usefull types.
*
* (C) Instrumental Systems Corp. Ekkore, Dec. 1997-2001
*
****************************************************/
 
 
#ifndef _UTYPES_H_
#define _UTYPES_H_
 
#include "utypes_linux.h"
 
 
 
/*************************************
*
* Types for MSDOS
*/
 
 
#ifdef __MSDOS__
 
typedef unsigned char UINT08;
typedef signed char SINT08;
typedef unsigned short UINT16;
typedef signed short SINT16;
typedef unsigned long UINT32;
typedef signed long SINT32;
 
typedef unsigned char U08, *PU08;
typedef signed char S08, *PS08;
typedef unsigned short U16, *PU16;
typedef signed short S16, *PS16;
typedef unsigned long U32, *PU32;
typedef signed long S32, *PS32;
 
typedef float REAL32, *PREAL32;
typedef double REAL64, *PREAL64;
 
//typedef enum{ FALSE=0, TRUE=1} BOOL;
typedef unsigned char UCHAR;
typedef unsigned short USHORT;
typedef unsigned long ULONG;
typedef unsigned long HANDLE;
 
#endif /* __MSDOS__ */
 
 
/*************************************
*
* Types for Windows
*/
 
 
#ifdef _WIN32
 
typedef unsigned char UINT08;
typedef signed char SINT08;
typedef unsigned short UINT16;
typedef signed short SINT16;
typedef unsigned int UINT32;
typedef signed int SINT32;
 
typedef unsigned char U08, *PU08;
typedef signed char S08, *PS08;
typedef unsigned short U16, *PU16;
typedef signed short S16, *PS16;
typedef unsigned int U32, *PU32;
typedef signed int S32, *PS32;
 
#if _MSC_VER == 1200
#else
typedef unsigned long long int U64, *PU64;
typedef signed long long int S64, *PS64;
#endif
 
typedef float REAL32, *PREAL32;
typedef double REAL64, *PREAL64;
 
#ifdef _WIN64
typedef wchar_t BRDCHAR;
#define _BRDC(x) L ## x
#define BRDC_strlen wcslen
#define BRDC_strcpy wcscpy
#define BRDC_strncpy wcsncpy
#define BRDC_strcmp wcscmp
#define BRDC_stricmp _wcsicmp
#define BRDC_strnicmp wcsnicmp
#define BRDC_strcat wcscat
#define BRDC_strchr wcschr
#define BRDC_strstr wcsstr
#define BRDC_strtol wcstol
#define BRDC_strtoul wcstoul
#define BRDC_strtod wcstod
#define BRDC_atol _wtol
#define BRDC_atoi _wtoi
#define BRDC_atoi64 _wtoi64
#define BRDC_atof _wtof
#define BRDC_printf wprintf
#define BRDC_fprintf fwprintf
#define BRDC_sprintf swprintf
#define BRDC_vsprintf vswprintf
#define BRDC_sscanf swscanf
#define BRDC_fopen _wfopen
#define BRDC_sopen _wsopen
#define BRDC_fgets fgetws
#define BRDC_fputs fputws
#define BRDC_getenv _wgetenv
#define BRDC_main wmain
#else
typedef char BRDCHAR;
#define _BRDC(x) x
#define BRDC_strlen strlen
#define BRDC_strcpy strcpy
#define BRDC_strncpy strncpy
#define BRDC_strcmp strcmp
#define BRDC_stricmp _stricmp
#define BRDC_strnicmp _strnicmp
#define BRDC_strcat strcat
#define BRDC_strchr strchr
#define BRDC_strstr strstr
#define BRDC_strtol strtol
#define BRDC_strtoul strtoul
#define BRDC_strtod strtod
#define BRDC_atol atol
#define BRDC_atoi atoi
#define BRDC_atoi64 _atoi64
#define BRDC_atof atof
#define BRDC_printf printf
#define BRDC_fprintf fprintf
#define BRDC_sprintf sprintf
#define BRDC_vsprintf vsprintf
#define BRDC_sscanf sscanf
#define BRDC_fopen fopen
#define BRDC_sopen sopen
#define BRDC_fgets fgets
#define BRDC_fputs fputs
#define BRDC_getenv getenv
#define BRDC_main main
#endif
 
#endif /* _WIN32 */
 
 
/*************************************
*
* Types for TMS320C3x/C4x
*/
 
 
#if defined(_TMS320C30) || defined(_TMS320C40 )
 
/*
typedef unsigned char UINT08;
typedef signed char SINT08;
typedef unsigned short UINT16;
typedef signed short SINT16;
*/
typedef unsigned int UINT32;
typedef signed int SINT32;
 
typedef unsigned int U32, *PU32;
typedef signed int S32, *PS32;
 
typedef float REAL32, *PREAL32;
typedef double REAL64, *PREAL64;
 
typedef UINT32 ULONG;
typedef UINT32 USHORT;
typedef UINT32 UCHAR;
 
#endif /* _TMS320C30 || _TMS320C40 */
 
 
/*************************************
*
* Types for TMS320C6x
*/
 
 
#ifdef _TMS320C6X
 
typedef unsigned char UINT08;
typedef signed char SINT08;
typedef unsigned short UINT16;
typedef signed short SINT16;
typedef unsigned int UINT32;
typedef signed int SINT32;
 
typedef unsigned char U08, *PU08;
typedef signed char S08, *PS08;
typedef unsigned short U16, *PU16;
typedef signed short S16, *PS16;
typedef unsigned int U32, *PU32;
typedef signed int S32, *PS32;
 
typedef unsigned long long int U64, *PU64;
typedef signed long long int S64, *PS64;
 
typedef float REAL32, *PREAL32;
typedef double REAL64, *PREAL64;
 
typedef UINT32 ULONG;
typedef UINT16 USHORT;
typedef UINT08 UCHAR;
 
#endif /* _TMS320C6X */
 
 
/*************************************
*
* Types for ADSP2106x
*/
 
 
#if defined(__ADSP21060__) || defined(__ADSP21061__) || defined(__ADSP21062__)|| defined(__ADSP21065L__)
 
typedef unsigned int UINT32;
typedef signed int SINT32;
 
typedef unsigned int U32, *PU32;
typedef signed int S32, *PS32;
 
typedef float REAL32, *PREAL32;
typedef double REAL64, *PREAL64;
 
typedef UINT32 ULONG;
typedef UINT32 USHORT;
typedef UINT32 UCHAR;
 
#endif /* __ADSP2106x__ */
 
/*************************************
*
* Types for ADSP2116x
*/
 
 
#if defined(__ADSP21160__) || defined(__ADSP21161__)
 
typedef unsigned int UINT32;
typedef signed int SINT32;
 
typedef unsigned int U32, *PU32;
typedef signed int S32, *PS32;
 
typedef float REAL32, *PREAL32;
typedef double REAL64, *PREAL64;
 
typedef UINT32 ULONG;
typedef UINT32 USHORT;
typedef UINT32 UCHAR;
 
#endif /* __ADSP2116x__ */
 
/*************************************
*
* Types for ADSP-TS101
*/
 
 
#if defined(__ADSPTS__)
 
typedef unsigned int UINT32;
typedef signed int SINT32;
 
typedef unsigned int U32, *PU32;
typedef signed int S32, *PS32;
 
typedef unsigned long long int U64, *PU64;
typedef signed long long int S64, *PS64;
 
typedef float REAL32, *PREAL32;
typedef long double REAL64, *PREAL64;
 
typedef UINT32 ULONG;
typedef UINT32 USHORT;
typedef UINT32 UCHAR;
 
#endif /* __ADSPTS__ */
 
/*************************************
*
* Types for MC24
*/
 
#if defined(__GNUC__) && !defined(__linux__)
 
typedef unsigned char UINT08;
typedef signed char SINT08;
typedef unsigned short UINT16;
typedef signed short SINT16;
typedef unsigned long UINT32;
typedef signed long SINT32;
 
typedef unsigned char U08, *PU08;
typedef signed char S08, *PS08;
typedef unsigned short U16, *PU16;
typedef signed short S16, *PS16;
typedef unsigned long U32, *PU32;
typedef signed long S32, *PS32;
 
typedef unsigned long long int U64, *PU64;
typedef signed long long int S64, *PS64;
 
typedef float REAL32, *PREAL32;
typedef double REAL64, *PREAL64;
 
typedef unsigned char UCHAR;
typedef unsigned short USHORT;
typedef unsigned long ULONG;
typedef unsigned long HANDLE;
 
#endif /* __GNUC__ */
 
/*************************************
*
* Type Aliasing
*/
 
typedef UINT32 Uns;
 
/*************************************************
*
* Entry Point types
*
*/
#if !defined(WIN32) && !defined(__WIN32__)
//#ifndef WIN32
#define FENTRY
#define STDCALL
#else
#include <windows.h>
#define DllImport __declspec( dllimport )
#define DllExport __declspec( dllexport )
#define FENTRY DllExport
#define STDCALL __stdcall
#define huge
#endif // WIN32
 
 
#endif /* _UTYPES_H_ */
 
/*
* End of File
*/
 
 
 
/***************************************************
*
* UTYPES.H - define usefull types.
*
* (C) Instrumental Systems Corp. Ekkore, Dec. 1997-2001
*
****************************************************/
 
 
#ifndef _UTYPES_H_
#define _UTYPES_H_
 
#include "utypes_linux.h"
 
 
 
/*************************************
*
* Types for MSDOS
*/
 
 
#ifdef __MSDOS__
 
typedef unsigned char UINT08;
typedef signed char SINT08;
typedef unsigned short UINT16;
typedef signed short SINT16;
typedef unsigned long UINT32;
typedef signed long SINT32;
 
typedef unsigned char U08, *PU08;
typedef signed char S08, *PS08;
typedef unsigned short U16, *PU16;
typedef signed short S16, *PS16;
typedef unsigned long U32, *PU32;
typedef signed long S32, *PS32;
 
typedef float REAL32, *PREAL32;
typedef double REAL64, *PREAL64;
 
//typedef enum{ FALSE=0, TRUE=1} BOOL;
typedef unsigned char UCHAR;
typedef unsigned short USHORT;
typedef unsigned long ULONG;
typedef unsigned long HANDLE;
 
#endif /* __MSDOS__ */
 
 
/*************************************
*
* Types for Windows
*/
 
 
#ifdef _WIN32
 
typedef unsigned char UINT08;
typedef signed char SINT08;
typedef unsigned short UINT16;
typedef signed short SINT16;
typedef unsigned int UINT32;
typedef signed int SINT32;
 
typedef unsigned char U08, *PU08;
typedef signed char S08, *PS08;
typedef unsigned short U16, *PU16;
typedef signed short S16, *PS16;
typedef unsigned int U32, *PU32;
typedef signed int S32, *PS32;
 
#if _MSC_VER == 1200
#else
typedef unsigned long long int U64, *PU64;
typedef signed long long int S64, *PS64;
#endif
 
typedef float REAL32, *PREAL32;
typedef double REAL64, *PREAL64;
 
#ifdef _WIN64
typedef wchar_t BRDCHAR;
#define _BRDC(x) L ## x
#define BRDC_strlen wcslen
#define BRDC_strcpy wcscpy
#define BRDC_strncpy wcsncpy
#define BRDC_strcmp wcscmp
#define BRDC_stricmp _wcsicmp
#define BRDC_strnicmp wcsnicmp
#define BRDC_strcat wcscat
#define BRDC_strchr wcschr
#define BRDC_strstr wcsstr
#define BRDC_strtol wcstol
#define BRDC_strtoul wcstoul
#define BRDC_strtod wcstod
#define BRDC_atol _wtol
#define BRDC_atoi _wtoi
#define BRDC_atoi64 _wtoi64
#define BRDC_atof _wtof
#define BRDC_printf wprintf
#define BRDC_fprintf fwprintf
#define BRDC_sprintf swprintf
#define BRDC_vsprintf vswprintf
#define BRDC_sscanf swscanf
#define BRDC_fopen _wfopen
#define BRDC_sopen _wsopen
#define BRDC_fgets fgetws
#define BRDC_fputs fputws
#define BRDC_getenv _wgetenv
#define BRDC_main wmain
#else
typedef char BRDCHAR;
#define _BRDC(x) x
#define BRDC_strlen strlen
#define BRDC_strcpy strcpy
#define BRDC_strncpy strncpy
#define BRDC_strcmp strcmp
#define BRDC_stricmp _stricmp
#define BRDC_strnicmp _strnicmp
#define BRDC_strcat strcat
#define BRDC_strchr strchr
#define BRDC_strstr strstr
#define BRDC_strtol strtol
#define BRDC_strtoul strtoul
#define BRDC_strtod strtod
#define BRDC_atol atol
#define BRDC_atoi atoi
#define BRDC_atoi64 _atoi64
#define BRDC_atof atof
#define BRDC_printf printf
#define BRDC_fprintf fprintf
#define BRDC_sprintf sprintf
#define BRDC_vsprintf vsprintf
#define BRDC_sscanf sscanf
#define BRDC_fopen fopen
#define BRDC_sopen sopen
#define BRDC_fgets fgets
#define BRDC_fputs fputs
#define BRDC_getenv getenv
#define BRDC_main main
#endif
 
#endif /* _WIN32 */
 
 
/*************************************
*
* Types for TMS320C3x/C4x
*/
 
 
#if defined(_TMS320C30) || defined(_TMS320C40 )
 
/*
typedef unsigned char UINT08;
typedef signed char SINT08;
typedef unsigned short UINT16;
typedef signed short SINT16;
*/
typedef unsigned int UINT32;
typedef signed int SINT32;
 
typedef unsigned int U32, *PU32;
typedef signed int S32, *PS32;
 
typedef float REAL32, *PREAL32;
typedef double REAL64, *PREAL64;
 
typedef UINT32 ULONG;
typedef UINT32 USHORT;
typedef UINT32 UCHAR;
 
#endif /* _TMS320C30 || _TMS320C40 */
 
 
/*************************************
*
* Types for TMS320C6x
*/
 
 
#ifdef _TMS320C6X
 
typedef unsigned char UINT08;
typedef signed char SINT08;
typedef unsigned short UINT16;
typedef signed short SINT16;
typedef unsigned int UINT32;
typedef signed int SINT32;
 
typedef unsigned char U08, *PU08;
typedef signed char S08, *PS08;
typedef unsigned short U16, *PU16;
typedef signed short S16, *PS16;
typedef unsigned int U32, *PU32;
typedef signed int S32, *PS32;
 
typedef unsigned long long int U64, *PU64;
typedef signed long long int S64, *PS64;
 
typedef float REAL32, *PREAL32;
typedef double REAL64, *PREAL64;
 
typedef UINT32 ULONG;
typedef UINT16 USHORT;
typedef UINT08 UCHAR;
 
#endif /* _TMS320C6X */
 
 
/*************************************
*
* Types for ADSP2106x
*/
 
 
#if defined(__ADSP21060__) || defined(__ADSP21061__) || defined(__ADSP21062__)|| defined(__ADSP21065L__)
 
typedef unsigned int UINT32;
typedef signed int SINT32;
 
typedef unsigned int U32, *PU32;
typedef signed int S32, *PS32;
 
typedef float REAL32, *PREAL32;
typedef double REAL64, *PREAL64;
 
typedef UINT32 ULONG;
typedef UINT32 USHORT;
typedef UINT32 UCHAR;
 
#endif /* __ADSP2106x__ */
 
/*************************************
*
* Types for ADSP2116x
*/
 
 
#if defined(__ADSP21160__) || defined(__ADSP21161__)
 
typedef unsigned int UINT32;
typedef signed int SINT32;
 
typedef unsigned int U32, *PU32;
typedef signed int S32, *PS32;
 
typedef float REAL32, *PREAL32;
typedef double REAL64, *PREAL64;
 
typedef UINT32 ULONG;
typedef UINT32 USHORT;
typedef UINT32 UCHAR;
 
#endif /* __ADSP2116x__ */
 
/*************************************
*
* Types for ADSP-TS101
*/
 
 
#if defined(__ADSPTS__)
 
typedef unsigned int UINT32;
typedef signed int SINT32;
 
typedef unsigned int U32, *PU32;
typedef signed int S32, *PS32;
 
typedef unsigned long long int U64, *PU64;
typedef signed long long int S64, *PS64;
 
typedef float REAL32, *PREAL32;
typedef long double REAL64, *PREAL64;
 
typedef UINT32 ULONG;
typedef UINT32 USHORT;
typedef UINT32 UCHAR;
 
#endif /* __ADSPTS__ */
 
/*************************************
*
* Types for MC24
*/
 
#if defined(__GNUC__) && !defined(__linux__)
 
typedef unsigned char UINT08;
typedef signed char SINT08;
typedef unsigned short UINT16;
typedef signed short SINT16;
typedef unsigned long UINT32;
typedef signed long SINT32;
 
typedef unsigned char U08, *PU08;
typedef signed char S08, *PS08;
typedef unsigned short U16, *PU16;
typedef signed short S16, *PS16;
typedef unsigned long U32, *PU32;
typedef signed long S32, *PS32;
 
typedef unsigned long long int U64, *PU64;
typedef signed long long int S64, *PS64;
 
typedef float REAL32, *PREAL32;
typedef double REAL64, *PREAL64;
 
typedef unsigned char UCHAR;
typedef unsigned short USHORT;
typedef unsigned long ULONG;
typedef unsigned long HANDLE;
 
#endif /* __GNUC__ */
 
/*************************************
*
* Type Aliasing
*/
 
typedef UINT32 Uns;
 
/*************************************************
*
* Entry Point types
*
*/
#if !defined(WIN32) && !defined(__WIN32__)
//#ifndef WIN32
#define FENTRY
#define STDCALL
#else
#include <windows.h>
#define DllImport __declspec( dllimport )
#define DllExport __declspec( dllexport )
#define FENTRY DllExport
#define STDCALL __stdcall
#define huge
#endif // WIN32
 
 
#endif /* _UTYPES_H_ */
 
/*
* End of File
*/
 
 
 
/common/utils/cl_ambpex.h
4,19 → 4,16
#define TF_CheckItem_CL_AMBPEXH
 
#include "utypes.h"
//#include "brd.h"
//#include "time.h"
#include "board.h"
#include "time.h"
#include "ctrlstrm.h"
 
//#include <string.h>
 
class board;
 
class CL_AMBPEX
{
 
 
public:
// virtual char* GetName( void ); //!< Возвращает название класса
 
//! Инициализация модуля
virtual U32 init( void );
57,14 → 54,16
//! Чтение из прямого регистра
U32 RegPeekDir( S32 trdNo, S32 rgnum );
 
CL_AMBPEX(const char* dev_name = NULL);
 
CL_AMBPEX(const char *devname);
virtual ~CL_AMBPEX();
 
 
private:
 
//! Указатель на модуль
board *m_pBoard;
 
 
struct StreamParam
{
U32 status;
95,6 → 94,8
 
};
 
void Sleep( int ms );
void Sleep(int ms);
 
//---------------------------------------------------------------------------
 
#endif
/common/utils/ctrlstrm.h
171,7 → 171,7
BRDstrm_STAT_STOP = 2,
BRDstrm_STAT_DESTROY = 3,
BRDstrm_STAT_BREAK = 4
};
};
 
//
// Constants: Direction of CBUF
193,6 → 193,6
BRDstrm_DRQ_ALMOST = 0x0, // Almost empty = 1 for input FIFO, Almost full = 1 for output FIFO
BRDstrm_DRQ_READY = 0x1, // Ready = 1
BRDstrm_DRQ_HALF = 0x2 // Half full = 0 for input FIFO, Half full = 1 for output FIFO
};
};
 
#endif // _CTRL_STREAM_H
/common/utils/tf_workparam.h
1,18 → 1,7
/**
\file
\brief Объявление класса TF_WorkParam
 
\version 1
#ifndef __TF_WORK_PARAM_H__
#define __TF_WORK_PARAM_H__
 
 
*/
 
#pragma once
 
 
 
 
 
//! Класс хранения параметров обработки
/**
 
38,8 → 27,8
struct STR_CFG {
 
U32 is_float; //!< 1 - число с плавающей точкой; 0 - целое.
const char *name; //!< Название параметра
const char *def; //!< Значение по умолчанию
const char *name; //!< Название параметра
const char *def; //!< Значение по умолчанию
U32 *ptr; //!< Указатель на переменную
const char *cmt; //!< Комментарий для параметра
 
101,3 → 90,5
//! Функция отображения параметров
void log_out( const char* fmt, ... );
};
 
#endif //__TF_WORK_PARAM_H__
/common/utils/cl_wbpex.cpp
24,8 → 24,8
//! Инициализация модуля
U32 CL_WBPEX::init( void )
{
S32 err;
S32 num;
//S32 err;
//S32 num;
 
/*
if( g_hBrd<=0)
41,7 → 41,7
board *brd = new pex_board();
m_pBoard = brd;
 
brd->brd_open( "/dev/AMBPEX50" );
brd->brd_open( "/dev/pexdrv0" );
brd->brd_init();
brd->brd_board_info();
//brd->brd_pld_info();
53,7 → 53,7
//! Завершение работы с модулем
void CL_WBPEX::cleanup( void )
{
S32 ret;
//S32 ret;
//ret=BRD_cleanup();
 
}
195,8 → 195,8
if( pStrm->status!=1 )
return;
 
S32 err;
U32 val;
//S32 err;
//U32 val;
 
//val=RegPeekInd( pStrm->trd, 0 );
//err = BRD_ctrl( pStrm->hStream, 0, BRDctrl_STREAM_CBUF_STOP, NULL);
205,7 → 205,7
pStrm->indexDma=-1;
pStrm->indexPc=-1;
 
val=pStrm->cycle; // 0 - однократный режим, 1 - циклический
//val=pStrm->cycle; // 0 - однократный режим, 1 - циклический
//err = BRD_ctrl( pStrm->hStream, 0, BRDctrl_STREAM_CBUF_START, &val );
}
 
214,9 → 214,9
if( strm>1 )
return;
 
StreamParam *pStrm= m_streamParam+strm;
//StreamParam *pStrm= m_streamParam+strm;
 
S32 err;
//S32 err;
 
//RegPokeInd( pStrm->trd, 0, 2 );
 
259,7 → 259,7
if( strm>1 )
return -1;
 
StreamParam *pStrm= m_streamParam+strm;
//StreamParam *pStrm= m_streamParam+strm;
 
 
 
273,8 → 273,8
return;
 
StreamParam *pStrm= m_streamParam+strm;
S32 err;
static U32 err_code=0;
//S32 err;
//static U32 err_code=0;
 
if( pStrm->agree_mode )
{
/common/utils/tf_testbufm2.cpp
1,10 → 1,16
/** \file
\brief Функции формирования и проверки массива данных
 
В файле содержится реализация класса TF_TestBufM2 - формирование и проверка массива данных.
 
\author Dmitry Smekhov
\version 1.0
 
 
*/
 
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
#include "utypes.h"
#include "tf_testbufm2.h"
33,16 → 39,13
{
// n%100 - тип блока
U32 ii;
//U32 di0, di1;
//U32 cnt_err=0;
 
__int64 *ptr=(__int64*)buf;
U32 size64 = size/2;
__int64 data_ex;
//__int64 data_in;
__int64 data_sig;
__int64 data_ex1;
__int64 data_ex2;
__int64 data_ex = 0ULL;
__int64 data_sig = 0ULL;
__int64 data_ex1 = 0ULL;
__int64 data_ex2 = 0ULL;
 
data_sig = n;
if( mode & 0x80 )
62,7 → 65,7
case 2: data_ex = 1; break;
case 3: data_ex = ~1; break;
case 4: data_ex = 1; data_ex2=0; break;
case 5: data_ex = ~1; data_ex2=0xFFFFFFFFFFFFFFFFLL; break;
case 5: data_ex = ~1; data_ex2=0xFFFFFFFFFFFFFFFFULL; break;
case 6:
case 7: data_ex = data_ex_cnt; break;
case 8:
79,7 → 82,7
//data_in=*ptr++;
*ptr++=data_ex;
{
U32 f= (data_ex & 0x8000000000000000LL) ? 1:0;
U32 f= (data_ex & 0x8000000000000000ULL) ? 1:0;
data_ex <<= 1;
data_ex &=~1;
data_ex |=f;
93,7 → 96,7
//data_in=*ptr++;
*ptr++=(~data_ex);
{
U32 f= (data_ex & 0x8000000000000000LL) ? 1:0;
U32 f= (data_ex & 0x8000000000000000ULL) ? 1:0;
data_ex <<= 1;
data_ex &=~1;
data_ex |=f;
106,7 → 109,7
*ptr++=~data_ex;
 
{
U32 f= (data_ex & 0x8000000000000000LL) ? 1:0;
U32 f= (data_ex & 0x8000000000000000ULL) ? 1:0;
data_ex <<= 1;
data_ex &=~1;
data_ex |=f;
128,7 → 131,7
*ptr++=data_ex1;
if( flag )
{
U32 f= (data_ex & 0x8000000000000000LL) ? 1:0;
U32 f= (data_ex & 0x8000000000000000ULL) ? 1:0;
data_ex <<= 1;
data_ex &=~1;
data_ex |=f;
325,11 → 328,11
 
__int64 *ptr=(__int64*)buf;
U32 size64 = size/2;
__int64 data_ex;
__int64 data_in;
__int64 data_sig;
__int64 data_ex1;
__int64 data_ex2;
__int64 data_ex = 0ULL;
__int64 data_in = 0ULL;
__int64 data_sig = 0ULL;
__int64 data_ex1 = 0ULL;
__int64 data_ex2 = 0ULL;
 
data_sig = n;
if( mode & 0x80 )
369,7 → 372,7
case 2: data_ex = 1; break;
case 3: data_ex = ~1; break;
case 4: data_ex = 1; data_ex2=0; break;
case 5: data_ex = ~1; data_ex2=0xFFFFFFFFFFFFFFFFLL; break;
case 5: data_ex = ~1; data_ex2=0xFFFFFFFFFFFFFFFFULL; break;
case 6:
case 7: data_ex = data_ex_cnt; break;
case 8:
390,7 → 393,7
//cnt_err=0;
}
{
U32 f= (data_ex & 0x8000000000000000LL) ? 1:0;
U32 f= (data_ex & 0x8000000000000000ULL) ? 1:0;
data_ex <<= 1;
data_ex &=~1;
data_ex |=f;
407,7 → 410,7
cnt_err+=check( 1, ~data_ex, data_in );
}
{
U32 f= (data_ex & 0x8000000000000000LL) ? 1:0;
U32 f= (data_ex & 0x8000000000000000ULL) ? 1:0;
data_ex <<= 1;
data_ex &=~1;
data_ex |=f;
431,7 → 434,7
 
 
{
U32 f= (data_ex & 0x8000000000000000LL) ? 1:0;
U32 f= (data_ex & 0x8000000000000000ULL) ? 1:0;
data_ex <<= 1;
data_ex &=~1;
data_ex |=f;
457,7 → 460,7
}
if( flag )
{
U32 f= (data_ex & 0x8000000000000000LL) ? 1:0;
U32 f= (data_ex & 0x8000000000000000ULL) ? 1:0;
data_ex <<= 1;
data_ex &=~1;
data_ex |=f;
590,7 → 593,7
Массив должен быть сформирован функцией buf_set или аналогичной
При обнаружении ошибки в массив word_error записываются четыре числа:
- номер массива
- индекс в массиве
- индекс в массивк
- ожидаемые данные
- полученные данные
В массивы bit_error0 и bit_error1 заносится распределение ошибок по битам.
616,7 → 619,6
__int64 data_ex;
__int64 data_in;
 
 
data_ex = data_ex_psd ;
 
 
626,7 → 628,16
 
if( data_ex!=data_in )
{
cnt_err+=check( ii, data_ex, data_in );
if( word_cnt_error<max_cnt_error )
{
word_error[ word_cnt_error*4+0 ]=buf_current;
word_error[ word_cnt_error*4+1 ]=ii;
word_error[ word_cnt_error*4+2 ]=data_ex;
word_error[ word_cnt_error*4+3 ]=data_in;
}
word_cnt_error++;
cnt_err++;
//cnt_err+=check( ii, data_ex, data_in );
data_ex=data_in;
}
 
637,6 → 648,7
f59 = data_ex >> 59;
f0 = (f63 ^ f62 ^ f60 ^ f59)&1;
*/
 
U32 data_h=data_ex>>32;
U32 f63 = data_h >> 31;
U32 f62 = data_h >> 30;
643,6 → 655,7
U32 f60 = data_h >> 28;
U32 f59 = data_h >> 27;
U32 f0 = (f63 ^ f62 ^ f60 ^ f59)&1;
 
//U32 data_l=data_ex;
//U32 f31 = (data_l>>31) & 1;
//data_l<<=1;
680,7 → 693,59
 
}
 
//! Проверка двоично-инверсной последовательности
U32 TF_TestBufM2::buf_check_inv( U32 *buf, U32 size )
{
 
// n%100 - тип блока
U32 ii;
U32 cnt_err=0;
 
__int64 *ptr=(__int64*)buf;
U32 size64 = size/2;
__int64 data_ex;
__int64 data_in;
 
register unsigned f0;
 
 
data_ex = data_ex_inv ;
 
 
for( ii=0; ii<size64; ii++ )
{
data_in=*ptr++;
 
if( data_ex!=data_in )
{
cnt_err+=check( ii, data_ex, data_in );
//data_ex=data_in;
}
 
//data_h=data_ex>>32; f63 = data_h >> 31; f0 = f63^1; data_ex <<= 1; data_ex &= ~1; data_ex |=f0;
f0 = ((data_ex >>63) & 1) ^1; data_ex <<= 1; data_ex &= ~1; data_ex |=f0;
 
 
 
 
}
 
data_ex_inv = data_ex;
 
block_mode++;
if( block_mode==10 )
block_mode=0;
 
buf_current++;
if (cnt_err==0)
buf_cnt_ok++;
else
buf_cnt_error++;
 
return cnt_err;
 
}
 
//! Начало проверки группы массивов
/** Функция подготавливает параметры для проверки нескольких массивов.
Обнуляются счётчики ошибок.
764,10 → 829,11
 
char *ptr=str;
int len;
char bit[64], *ptr_bit;
//char bit[64], *ptr_bit;
U32 nb, na;
__int64 dout, din;
int size=0;
//U32 mask;
*ptr=0;
int cnt=max_cnt_error;
if( word_cnt_error<max_cnt_error )
777,7 → 843,7
na=word_error[ii*4+1];
dout=word_error[ii*4+2];
din=word_error[ii*4+3];
ptr_bit=bit;
//ptr_bit=bit;
/*
mask=0x80000000;
for( int jj=0; jj<32; jj++ ) {
816,63 → 882,14
char* TF_TestBufM2::report_bit_error( void ) {
 
char *ptr=str;
//int len;
//char bit[64], *ptr_bit;
//U32 mask;
*ptr=0;
 
return str;
}
 
//! Проверка двоично-инверсной последовательности
U32 TF_TestBufM2::buf_check_inv( U32 *buf, U32 size )
{
 
// n%100 - тип блока
U32 ii;
U32 cnt_err=0;
//---------------------------------------------------------------------------
 
__int64 *ptr=(__int64*)buf;
U32 size64 = size/2;
__int64 data_ex;
__int64 data_in;
 
register unsigned f0;
 
 
data_ex = data_ex_inv ;
 
 
for( ii=0; ii<size64; ii++ )
{
data_in=*ptr++;
 
if( data_ex!=data_in )
{
cnt_err+=check( ii, data_ex, data_in );
//data_ex=data_in;
}
 
//data_h=data_ex>>32; f63 = data_h >> 31; f0 = f63^1; data_ex <<= 1; data_ex &= ~1; data_ex |=f0;
f0 = ((data_ex >>63) & 1) ^1; data_ex <<= 1; data_ex &= ~1; data_ex |=f0;
 
 
 
 
}
 
data_ex_inv = data_ex;
 
block_mode++;
if( block_mode==10 )
block_mode=0;
 
buf_current++;
if (cnt_err==0)
buf_cnt_ok++;
else
buf_cnt_error++;
 
return cnt_err;
 
}
 
 
//---------------------------------------------------------------------------
/common/utils/tf_testbufm2.h
12,7 → 12,6
#ifndef TF_TestBufM2H
#define TF_TestBufM2H
 
 
//! Проверка массива данных
/** Класс содержит функции для проверки произвольных
массивов.
51,8 → 50,8
Начальное значение - 1
Слово формируется сдвигом на один разряд вправо.
В младший разряд слова записывается значение x[63] xor x[62] xor x[60] xor x[59]
 
 
Для режима счётчика и псевдослучайной последовательности начальное значение
формируется при инициализации тестовой последовательности.
Для остальных режимов - при инициализации проверки блока
74,75 → 73,55
*/
class TF_TestBufM2 {
 
U32 bit_error0[64]; //!< Число ошибок типа принят 0
U32 bit_error1[64]; //!< Число ошибок типа принят 1
U32 bit_error0[64]; //!< Число ошибок типа принят 0
U32 bit_error1[64]; //!< Число ошибок типа принят 1
 
U32 max_cnt_error; //!< Заданное максимальное число ошибок
U32 max_bit_cnt; //!< Число бит в слове
U32 buf_cnt_ok; //!< Число правильных массивов.
U32 buf_cnt_error; //!< Число неправильных массивов.
U32 word_cnt_error; //!< Число неправильных слов.
U32 buf_current; //!< Номер текущего массива.
__int64 word_error[4*32]; //!< Список ошибок
U32 max_cnt_error; //!< Заданное максимальное число ошибок
U32 max_bit_cnt; //!< Число бит в слове
U32 buf_cnt_ok; //!< Число правильных массивов.
U32 buf_cnt_error; //!< Число неправильных массивов.
U32 word_cnt_error; //!< Число неправильных слов.
U32 buf_current; //!< Номер текущего массива.
__int64 word_error[4*32]; //!< Список ошибок
 
char str[10240]; //!< Буфер сообщений
U32 block_mode; //!< Тип блока
__int64 data_ex_cnt;
__int64 data_ex_noise;
__int64 data_ex_psd;
__int64 data_ex_inv;
char str[10240]; //!< Буфер сообщений
U32 block_mode; //!< Тип блока
__int64 data_ex_cnt;
__int64 data_ex_noise;
__int64 data_ex_psd;
__int64 data_ex_inv;
 
public:
 
TF_TestBufM2(); //!< Конструктор
~TF_TestBufM2(); //!< Деструктор
 
float *resData;
int FFT_size;
int numberOfSteps;
int numberOfFFTSizeSteps;
int m_chanMask;
 
U32 lowRange;
U32 topRange;
U32 fftSize;
//! Формирование массива
void buf_set( U32 *buf, U32 n, U32 size, U32 mode ) ;
 
inline U32 check( U32 index, __int64 d0, __int64 di0 );
 
public:
//! Проверка массива
U32 buf_check( U32 *buf, U32 n, U32 size, U32 mode );//, U32 *err, U32 size_err, U32 *bit_err, U32 bit_cnt );
 
TF_TestBufM2(); //!< Конструктор
~TF_TestBufM2(); //!< Деструктор
//! Начало проверки группы массивов
void buf_check_start( U32 n_error, U32 bit_cnt );
 
//! Результаты проверки группы массивов
U32 check_result( U32 *cnt_ok, U32 *cnt_error, U32 **error, U32 **bit0, U32 **bit1 );
 
//! Формирование массива
void buf_set( U32 *buf, U32 n, U32 size, U32 mode ) ;
//! Формирование отчёта по ошибкам
char* report_word_error( void );
 
inline U32 check( U32 index, __int64 d0, __int64 di0 );
//! Формирование отчёта распределения ошибок по битам
char* report_bit_error( void );
 
//! Проверка массива
U32 buf_check( U32 *buf, U32 n, U32 size, U32 mode );//, U32 *err, U32 size_err, U32 *bit_err, U32 bit_cnt );
//! Проверка псевдослучайной последовательности
U32 buf_check_psd( U32 *buf, U32 size );
 
//! Начало проверки группы массивов
void buf_check_start( U32 n_error, U32 bit_cnt );
 
//! Результаты проверки группы массивов
U32 check_result( U32 *cnt_ok, U32 *cnt_error, U32 **error, U32 **bit0, U32 **bit1 );
 
//! Формирование отчёта по ошибкам
char* report_word_error( void );
 
//! Формирование отчёта распределения ошибок по битам
char* report_bit_error( void );
 
//! Проверка псевдослучайной последовательности
U32 buf_check_psd( U32 *buf, U32 size );
 
//! Проверка двоично-инверсной последовательности
U32 buf_check_inv( U32 *buf, U32 size );
 
 
//! Проверка двоично-инверсной последовательности
U32 buf_check_inv( U32 *buf, U32 size );
};
 
 
 
 
 
//---------------------------------------------------------------------------
#endif
/common/utils/cl_ambpex.cpp
1,29 → 1,28
//---------------------------------------------------------------------------
 
#include <stdio.h>
#include <stdint.h>
#include <sys/select.h>
 
#include "board.h"
//#include "brderr.h"
#include "ctrlstrm.h"
//#include "ctrlreg.h"
//#include "useful.h"
//#include "CL_AMBPEX.h"
 
#ifndef __PEX_BOARD_H__
#include "pex_board.h"
#endif
 
#ifndef __BOARD_H__
#include "board.h"
#endif
 
#include "cl_ambpex.h"
#include "sys/select.h"
//BRD_Handle g_hBrd=0;
#include "ctrlstrm.h"
#include "cl_ambpex.h"
 
//---------------------------------------------------------------------------
 
void Sleep( int ms );
 
//-----------------------------------------------------------------------------
//! Инициализация модуля
U32 CL_AMBPEX::init( void )
{
DEBUG_PRINT("CL_AMBPEX::%s()\n", __FUNCTION__);
// сброс прошивки ПЛИС
RegPokeInd( 0, 0, 1 );
Sleep( 100 );
33,21 → 32,25
return 0;
}
 
//-----------------------------------------------------------------------------
//! Завершение работы с модулем
void CL_AMBPEX::cleanup( void )
{
DEBUG_PRINT("CL_AMBPEX::%s()\n", __FUNCTION__);
}
 
//-----------------------------------------------------------------------------
//! Открываем модуль
CL_AMBPEX::CL_AMBPEX(const char *devname)
{
DEBUG_PRINT("CL_AMBPEX::%s()\n", __FUNCTION__);
 
// Доступ к регистрам
CL_AMBPEX::CL_AMBPEX(const char* dev_name)
{
m_pBoard = new pex_board();
 
if(dev_name) {
m_pBoard->brd_open(dev_name);
if(devname) {
m_pBoard->brd_open(devname);
} else {
m_pBoard->brd_open("/dev/AMBPEX50");
m_pBoard->brd_open("/dev/pexdrv0");
}
 
m_pBoard->brd_init();
55,64 → 58,67
m_pBoard->brd_pld_info();
}
 
//-----------------------------------------------------------------------------
 
CL_AMBPEX::~CL_AMBPEX()
{
if(m_pBoard) delete m_pBoard;
DEBUG_PRINT("CL_AMBPEX::%s()\n", __FUNCTION__);
}
 
//-----------------------------------------------------------------------------
 
 
 
//=********************* RegPokeInd *******************
//=****************************************************
void CL_AMBPEX::RegPokeInd( S32 trdNo, S32 rgnum, U32 val )
{
DEBUG_PRINT("CL_AMBPEX::%s()\n", __FUNCTION__);
m_pBoard->brd_reg_poke_ind( trdNo, rgnum, val );
 
}
 
//=********************* RegPeekInd *******************
//=****************************************************
//-----------------------------------------------------------------------------
 
U32 CL_AMBPEX::RegPeekInd( S32 trdNo, S32 rgnum )
{
DEBUG_PRINT("CL_AMBPEX::%s()\n", __FUNCTION__);
U32 ret;
ret=m_pBoard->brd_reg_peek_ind( trdNo, rgnum );
return ret;
}
 
//=********************* RegPokeDir *******************
//=****************************************************
//-----------------------------------------------------------------------------
 
void CL_AMBPEX::RegPokeDir( S32 trdNo, S32 rgnum, U32 val )
{
DEBUG_PRINT("CL_AMBPEX::%s()\n", __FUNCTION__);
m_pBoard->brd_reg_poke_dir( trdNo, rgnum, val );
}
 
//=********************* RegPeekDir *******************
//=****************************************************
//-----------------------------------------------------------------------------
 
U32 CL_AMBPEX::RegPeekDir( S32 trdNo, S32 rgnum )
{
DEBUG_PRINT("CL_AMBPEX::%s()\n", __FUNCTION__);
U32 ret;
ret=m_pBoard->brd_reg_peek_dir( trdNo, rgnum );
return ret;
}
 
//-----------------------------------------------------------------------------
 
 
 
int CL_AMBPEX::StreamInit( U32 strm, U32 cnt_buf, U32 size_one_buf_of_bytes, U32 trd, U32 dir, U32 cycle, U32 system, U32 agree_mode )
{
if( strm>1 )
return 1;
 
DEBUG_PRINT("CL_AMBPEX::%s()\n", __FUNCTION__);
 
StreamParam *pStrm= m_streamParam+strm;
if( pStrm->status!=0 )
return 1;
 
pStrm->cnt_buf = cnt_buf;
pStrm->size_one_buf_of_bytes = size_one_buf_of_bytes;
pStrm->trd = trd;
pStrm->cycle = cycle;
pStrm->system = system;
pStrm->cnt_buf = cnt_buf;
pStrm->size_one_buf_of_bytes = size_one_buf_of_bytes;
pStrm->trd = trd;
pStrm->cycle = cycle;
pStrm->system = system;
 
pStrm->indexDma=-1;
pStrm->indexPc=-1;
120,16 → 126,15
 
StreamDestroy( strm );
 
 
__int64 size=cnt_buf*(__int64)size_one_buf_of_bytes/(1024*1024);
 
if( system )
{
if( system ) {
 
BRDC_fprintf( stderr, _BRDC("Allocation memory: \r\n")
_BRDC(" Type of block: system memory\r\n")
_BRDC(" Block size: %lld MB\r\n"), size );
} else
{
} else {
 
BRDC_fprintf( stderr, _BRDC("Allocation memory: \r\n")
_BRDC(" Type of block: userspace memory\r\n")
_BRDC(" Block size: %lld MB (%dx%d MB)\r\n"), size, cnt_buf, size_one_buf_of_bytes/(1024*1024) );
145,6 → 150,11
};
 
u32 err = m_pBoard->dma_alloc( strm, &sSCA );
if(err != 0) {
throw( "Error allocate stream memory\n" );
return -1;
}
 
pStrm->pStub=sSCA.pStub;
if(!pStrm->pStub) {
throw( "Error allocate stream memory\n" );
162,8 → 172,6
*/
m_pBoard->dma_set_local_addr( strm, trd );
 
//agree_mode = 1;
 
// Перевод на согласованный режим работы
if( agree_mode ) {
 
175,9 → 183,9
BRDC_fprintf( stderr, _BRDC("Stream working in regular mode\n"));
}
 
m_pBoard->dma_stop(strm);//err = BRD_ctrl( pStrm->hStream, 0, BRDctrl_STREAM_CBUF_STOP, NULL);
m_pBoard->dma_reset_fifo(strm);//err = BRD_ctrl( pStrm->hStream, 0, BRDctrl_STREAM_RESETFIFO, NULL );
m_pBoard->dma_reset_fifo(strm);//err = BRD_ctrl( pStrm->hStream, 0, BRDctrl_STREAM_RESETFIFO, NULL );
m_pBoard->dma_stop(strm);
m_pBoard->dma_reset_fifo(strm);
m_pBoard->dma_reset_fifo(strm);
 
pStrm->status=1;
 
184,26 → 192,31
return 0;
}
 
//-----------------------------------------------------------------------------
 
int CL_AMBPEX::StreamGetNextIndex( U32 strm, U32 index )
{
if( strm>1 )
return 0;
 
DEBUG_PRINT("CL_AMBPEX::%s()\n", __FUNCTION__);
 
StreamParam *pStrm= m_streamParam+strm;
int n=index+1;
if( (U32)n>=pStrm->cnt_buf )
n=0;
return n;
 
}
 
//-----------------------------------------------------------------------------
 
void CL_AMBPEX::StreamDestroy( U32 strm )
{
S32 err;
 
if( strm>1 )
return;
 
DEBUG_PRINT("CL_AMBPEX::%s()\n", __FUNCTION__);
 
StreamParam *pStrm= m_streamParam+strm;
if( pStrm->status==0 )
return;
210,21 → 223,20
 
StreamStop( strm );
 
if( 1 )
{
BRDC_fprintf( stderr, _BRDC("\r\nStream free %.8X\r\n"), err );
// pStrm->hStream=0;
}
m_pBoard->dma_free_memory( strm );
 
pStrm->status=0;
 
}
 
//-----------------------------------------------------------------------------
 
U32* CL_AMBPEX::StreamGetBufByNum( U32 strm, U32 numBuf )
{
if( strm>1 )
return NULL;
 
DEBUG_PRINT("CL_AMBPEX::%s()\n", __FUNCTION__);
 
StreamParam *pStrm= m_streamParam+strm;
if( pStrm->status!=1 )
return NULL;
236,17 → 248,19
return ptr;
}
 
//-----------------------------------------------------------------------------
 
void CL_AMBPEX::StreamStart( U32 strm )
{
 
if( strm>1 )
return;
 
DEBUG_PRINT("CL_AMBPEX::%s()\n", __FUNCTION__);
 
StreamParam *pStrm= m_streamParam+strm;
if( pStrm->status!=1 )
return;
 
//S32 err;
U32 val;
 
val=RegPeekInd( pStrm->trd, 0 );
257,27 → 271,31
pStrm->indexPc=-1;
 
val=pStrm->cycle; // 0 - однократный режим, 1 - циклический
 
m_pBoard->dma_start(strm, val);
}
 
//-----------------------------------------------------------------------------
 
void CL_AMBPEX::StreamStop( U32 strm )
{
if( strm>1 )
return;
 
DEBUG_PRINT("CL_AMBPEX::%s()\n", __FUNCTION__);
 
StreamParam *pStrm= m_streamParam+strm;
 
S32 err;
 
RegPokeInd( pStrm->trd, 0, 2 );
 
m_pBoard->dma_stop(strm);//err = BRD_ctrl( pStrm->hStream, 0, BRDctrl_STREAM_CBUF_STOP, NULL);
m_pBoard->dma_reset_fifo(strm);//err = BRD_ctrl( pStrm->hStream, 0, BRDctrl_STREAM_RESETFIFO, NULL );
m_pBoard->dma_stop(strm);
m_pBoard->dma_reset_fifo(strm);
 
RegPokeInd( pStrm->trd, 0, 0 );
 
}
 
//-----------------------------------------------------------------------------
 
int CL_AMBPEX::StreamGetBuf( U32 strm, U32** ptr )
{
U32 *buf;
288,6 → 306,7
 
StreamParam *pStrm= m_streamParam+strm;
 
DEBUG_PRINT("CL_AMBPEX::%s()\n", __FUNCTION__);
 
if( pStrm->indexPc==pStrm->indexDma )
{
304,11 → 323,15
return ret;
}
 
//-----------------------------------------------------------------------------
 
int CL_AMBPEX::StreamGetIndexDma( U32 strm )
{
if( strm>1 )
return -1;
 
DEBUG_PRINT("CL_AMBPEX::%s()\n", __FUNCTION__);
 
StreamParam *pStrm= m_streamParam+strm;
 
if(!pStrm->pStub) {
323,9 → 346,11
return lastBlock;
}
 
//-----------------------------------------------------------------------------
 
void CL_AMBPEX::StreamGetBufDone( U32 strm )
{
//fprintf(stderr, "%s()\n", __FUNCTION__);
DEBUG_PRINT("CL_AMBPEX::%s()\n", __FUNCTION__);
 
if( strm>1 )
return;
344,6 → 369,7
}
}
 
//-----------------------------------------------------------------------------
 
void Sleep( int ms )
{
353,7 → 379,4
select(0,NULL,NULL,NULL,&tv);
}
 
 
 
 
 
//-----------------------------------------------------------------------------
/common/utils/tf_workparam.cpp
1,10 → 1,9
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stdarg.h>
 
#include "utypes.h"
//#include "useful.h"
#include "tf_workparam.h"
 
#ifdef _DEBUG
13,10 → 12,8
static char THIS_FILE[] = __FILE__;
#endif
 
 
//
 
 
TF_WorkParam::TF_WorkParam(void)
{
 
24,8 → 21,6
memset( this, 0, sizeof( TF_WorkParam ) );
 
SetDefault();
 
 
}
 
TF_WorkParam::~TF_WorkParam(void)
68,55 → 63,13
}
 
 
//ZeroMemory( this, sizeof( TF_WorkParam ) );
 
 
 
 
 
ii=0;
/*
array_cfg[ii++]=STR_CFG( 0, "RGG_SideObservation", "1", (U32*)&st.Nav_LR_Side, "борт наблюдения (правый +1, левый -1)" );
array_cfg[ii++]=STR_CFG( 1, "lambda", "0.0032", (U32*)&st.lambda, "длина волны (м)" );
array_cfg[ii++]=STR_CFG( 2, "RliFileName", "..\\gol\\bmp\\_A_4Kx16k.bmp", (U32*)&pRliFileName, "имя файла с изображением для режима иммитации РЛИ " );
array_cfg[ii++]=STR_CFG( 3, "SYNTH_OBZOR_cutDoppler", "1", (U32*)(&st.cutDoppler), "cutDoppler" );
*/
 
max_item=ii;
 
 
/*
 
{
if( pPathVega==NULL )
{
pPathVega = (char*)malloc( 1024 );
}
 
int ret=GetEnvironmentVariableA(
"VEGA",
pPathVega,
1020
);
char buf[1024];
if( ret==0 )
sprintf( pPathVega, "c:\\vega" );
 
sprintf( buf, "%s\\temp\\obzor\\", pPathVega );
 
 
strcpy( st.output_dir, buf ); // директория файлов вычислений(server)
strcpy( st.output_dir_loc, buf ); // директория файлов вычислений(client)
 
strcpy( sk.output_dir, buf ); // директория файлов вычислений(server)
strcpy( sk.output_dir_loc, buf ); // директория файлов вычислений(client)
 
//free( pPathVega );
};
*/
{
char str[1024];
for( unsigned ii=0; ii<max_item; ii++ )
for( U32 ii=0; ii<max_item; ii++ )
{
sprintf( str, "%s %s", array_cfg[ii].name, array_cfg[ii].def );
GetParamFromStr( str );
137,12 → 90,10
 
in=BRDC_fopen( fname, _BRDC("rt") );
if( in==NULL ) {
//log_out( "Не могу открыть файл конфигурации %s\r\n", fname );
BRDC_fprintf( stderr, _BRDC("Can't open configuration file: %s\r\n"), fname );
BRDC_printf( _BRDC("Can't open configuration file: %s\r\n"), fname );
return;
}
//log_out( "\r\nЧтение параметров из файла %s\r\n\r\n", fname );
BRDC_fprintf( stderr, _BRDC("\r\nReading parameters from file: %s\r\n\r\n"), fname );
BRDC_printf( _BRDC("\r\nRead parameters from file: %s\r\n\r\n"), fname );
 
char str[512];
 
155,7 → 106,6
}
log_out( "\r\n" );
fclose( in );
 
}
 
//! Получение параметра из строки
171,12 → 121,10
if( strcmp( array_cfg[ii].name, name )==0 ) {
if( array_cfg[ii].is_float==0 ) {
sscanf( val, "%i", array_cfg[ii].ptr );
// scr.log_out( "%-20s %d\r\n", array_cfg[ii].name, *(array_cfg[ii].ptr) );
} else if( array_cfg[ii].is_float==1 ) {
sscanf( val, "%g", (float*)array_cfg[ii].ptr );
// scr.log_out( "%-20s %g\r\n", array_cfg[ii].name, *((float*)(array_cfg[ii].ptr)) );
} else if( array_cfg[ii].is_float==2 ) {
//*((CString*)array_cfg[ii].ptr)=val;
 
{
 
STR_CFG *cfg=array_cfg+ii;
186,9 → 134,8
if( ps!=NULL )
free( ps );
ps = (char*)malloc( 128 );
*(cfg->ptr)=((size_t)ps);
*(cfg->ptr)=(U32)ps;
sprintf( ps, "%s", val );
//scr.log_out("%-20s %s\r\n", array_cfg[ii].name, ps );
 
}
} else if( array_cfg[ii].is_float==3 ) {
197,10 → 144,8
sscanf( val, "%d", &v );
if( v ) {
*p=true;
//scr.log_out( "%-20s true\r\n", array_cfg[ii].name );
} else {
*p=false;
//scr.log_out( "%-20s false\r\n", array_cfg[ii].name );
}
}
break;
224,7 → 169,7
char str[256];
int len;
int total=0;
unsigned ii;
U32 ii;
STR_CFG *cfg;
 
*((U32*)ptr)=max_item;
258,7 → 203,7
 
}
len=strlen( str )+1;
if( (total+len)<(int)max_size )
if( (total+len)<(S32)max_size )
{
strcpy( ptr+total, str );
total+=len;
274,7 → 219,7
U32 len;
U32 n;
n=*((U32*)ptr);
unsigned ii;
U32 ii;
int total=4;
 
for( ii=0; ii<n; ii++ )
290,34 → 235,34
//! Отображение параметров
void TF_WorkParam::ShowParam( void )
{
U32 ii;
STR_CFG *item;
log_out( "\r\n\r\n\r\nParameters value:\r\n\r\n" );
for( ii=0; ii<max_item; ii++ )
{
item=array_cfg+ii;
if( item->is_float==2 )
{
U32 ii;
STR_CFG *item;
log_out( "\r\n\r\n\r\nParameters:\r\n\r\n" );
for( ii=0; ii<max_item; ii++ )
{
item=array_cfg+ii;
if( item->is_float==2 )
{
 
char **ptr=(char**)item->ptr;
char *ps=*ptr;
log_out( "%s %s\r\n", item->name, ps );
} else if( item->is_float==0 )
{
U32 ps=*((U32*)item->ptr);
log_out( "%s %d\r\n", item->name, ps );
} else if( item->is_float==1 )
{
float ps=*((float*)item->ptr);
log_out( "%s %g\r\n", item->name, ps );
} else if( item->is_float==3 )
{
U32 ps=*((U32*)item->ptr);
if( ps ) log_out( "%s %s\r\n", item->name, "true" );
else log_out( "%s %s\r\n", item->name, "false" );
}
}
log_out( "\r\n\r\n\r\n" );
char **ptr=(char**)item->ptr;
char *ps=*ptr;
log_out( "%s %s\r\n", item->name, ps );
} else if( item->is_float==0 )
{
U32 ps=*((U32*)item->ptr);
log_out( "%s %d\r\n", item->name, ps );
} else if( item->is_float==1 )
{
float ps=*((float*)item->ptr);
log_out( "%s %g\r\n", item->name, ps );
} else if( item->is_float==3 )
{
U32 ps=*((U32*)item->ptr);
if( ps ) log_out( "%s %s\r\n", item->name, "true" );
else log_out( "%s %s\r\n", item->name, "false" );
}
}
log_out( "\r\n\r\n\r\n" );
 
}
 
325,13 → 270,13
void TF_WorkParam::log_out( const char* format, ... )
{
 
char buffer[2048];
char buffer[2048];
 
va_list marker;
va_start( marker, format );
vsprintf( buffer, format, marker );
va_end( marker );
va_list marker;
va_start( marker, format );
vsprintf( buffer, format, marker );
va_end( marker );
 
BRDC_fprintf( stderr, "%s", buffer );
printf( "%s", buffer );
 
}
/common/Mk.Rules
0,0 → 1,55
 
#
# Detect operation system
#
 
#GPROF := -pg
 
#
# Setup common Makefile rules and defines
#
 
CC := $(CSTOOL_PREFIX)g++
LD := $(CSTOOL_PREFIX)g++
 
CFLAGS += -fPIC -Wall -g $(GPROF)
 
%.o: %.cpp
$(CC) $(CFLAGS) -c -MD $<
%.o: %.c
$(CC) $(CFLAGS) -c -MD $<
 
include $(wildcard *.d)
 
distclean:
rm -f *.o *~ core
rm -f *.d *~ core
rm -f *.so
rm -f *.0
 
clean:
rm -f *.o *~ core
rm -f *.d *~ core
rm -f *.so
rm -f *.0
 
SYSLIBDIR := /usr/local/lib/board
 
#
# в каталоге /etc/ld.so.conf.d/
# создать файл board.conf
# в котором прописать путь к библиотекам
# /usr/local/lib/board
# и выполнить ldconfig -v -n
#
 
install:
mkdir -p $(SYSLIBDIR)
chmod 777 $(SYSLIBDIR)
cp -af $(LIBNAME) $(SYSLIBDIR)
ln -sf $(SYSLIBDIR)/$(LIBNAME) $(SYSLIBDIR)/$(SONAME)
ln -sf $(SYSLIBDIR)/$(SONAME) $(SYSLIBDIR)/$(BASENAME)
echo '/usr/local/lib/board' > /etc/ld.so.conf.d/board.conf
/sbin/ldconfig
 
/common/board/board.cpp
1,6 → 1,6
 
#ifndef __BOARD_H__
#include "board.h"
#include "board.h"
#endif
 
//-----------------------------------------------------------------------------
32,6 → 32,7
 
int board::brd_open(const char *name)
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_open(name);
}
 
39,6 → 40,7
 
int board::brd_init()
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_init();
}
 
46,6 → 48,7
 
int board::brd_reset()
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_reset();
}
 
53,6 → 56,7
 
int board::brd_close()
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_close();
}
 
60,6 → 64,7
 
int board::brd_load_dsp()
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_load_dsp();
}
 
67,6 → 72,7
 
int board::brd_load_pld()
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_load_pld();
}
 
74,6 → 80,7
 
int board::brd_board_info()
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_board_info();
}
 
81,6 → 88,7
 
int board::brd_pld_info()
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_pld_info();
}
 
88,10 → 96,18
 
int board::brd_resource()
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_resource();
}
 
//-----------------------------------------------------------------------------
 
void board::brd_delay(int ms)
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
core_delay(ms);
}
 
/*
std::vector<struct memory_block>* board::dma_alloc(u32 dmaChannel, u32 blockNumber, u32 blockSize)
{
144,6 → 160,7
 
u32 board::brd_reg_peek_dir( u32 trd, u32 reg )
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_reg_peek_dir( trd, reg );
}
 
151,6 → 168,7
 
u32 board::brd_reg_peek_ind( u32 trd, u32 reg )
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_reg_peek_ind( trd, reg );
}
 
158,6 → 176,7
 
void board::brd_reg_poke_dir( u32 trd, u32 reg, u32 val )
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_reg_poke_dir( trd, reg, val );
}
 
165,6 → 184,7
 
void board::brd_reg_poke_ind( u32 trd, u32 reg, u32 val )
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_reg_poke_ind( trd, reg, val );
}
 
172,6 → 192,7
 
u32 board::brd_bar0_read( u32 offset )
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_bar0_read( offset );
}
 
179,6 → 200,7
 
void board::brd_bar0_write( u32 offset, u32 val )
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_bar0_write( offset, val );
}
 
186,6 → 208,7
 
u32 board::brd_bar1_read( u32 offset )
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_bar1_read( offset );
}
 
193,6 → 216,7
 
void board::brd_bar1_write( u32 offset, u32 val )
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_bar1_write(offset, val);
}
 
200,14 → 224,19
 
u32 board::dma_alloc(int DmaChan, BRDctrl_StreamCBufAlloc* sSCA)
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_alloc(DmaChan, sSCA);
}
 
//-----------------------------------------------------------------------------
 
u32 board::dma_allocate_memory(int DmaChan, void** pBuf, u32 blkSize, u32 blkNum, u32 isSysMem, u32 dir, u32 addr)
u32 board::dma_allocate_memory(int DmaChan, void** pBuf, u32 blkSize,
u32 blkNum, u32 isSysMem, u32 dir,
u32 addr, BRDstrm_Stub **pStub)
{
return core_allocate_memory(DmaChan, pBuf, blkSize, blkNum, isSysMem, dir, addr);
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_allocate_memory(DmaChan, pBuf, blkSize,
blkNum, isSysMem, dir, addr, pStub);
}
 
//-----------------------------------------------------------------------------
214,6 → 243,7
 
u32 board::dma_free_memory(int DmaChan)
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_free_memory(DmaChan);
}
 
221,6 → 251,7
 
u32 board::dma_start(int DmaChan, int IsCycling)
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_start_dma(DmaChan, IsCycling);
}
 
228,6 → 259,7
 
u32 board::dma_stop(int DmaChan)
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_stop_dma(DmaChan);
}
 
235,6 → 267,7
 
u32 board::dma_state(int DmaChan, u32 msTimeout, int& state, u32& blkNum)
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_state_dma(DmaChan, msTimeout, state, blkNum);
}
 
242,6 → 275,7
 
u32 board::dma_wait_buffer(int DmaChan, u32 msTimeout)
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_wait_buffer(DmaChan, msTimeout);
}
 
249,6 → 283,7
 
u32 board::dma_wait_block(int DmaChan, u32 msTimeout)
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_wait_block(DmaChan, msTimeout);
}
 
256,6 → 291,7
 
u32 board::dma_reset_fifo(int DmaChan)
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_reset_fifo(DmaChan);
}
 
263,6 → 299,7
 
u32 board::dma_set_local_addr(int DmaChan, u32 addr)
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_set_local_addr(DmaChan, addr);
}
 
270,6 → 307,7
 
u32 board::dma_adjust(int DmaChan, u32 mode)
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_adjust(DmaChan, mode);
}
 
277,6 → 315,7
 
u32 board::dma_done(int DmaChan, u32 blockNumber)
{
DEBUG_PRINT("%s()\n", __FUNCTION__);
return core_done(DmaChan, blockNumber);
}
 
/common/board/brd_info.h
1,11 → 1,40
#ifndef _BRD_INFO_H_
#define _BRD_INFO_H_
 
#ifndef __BRD_INFO_H__
#define __BRD_INFO_H__
//-----------------------------------------------------------------------------
// board configuration data structure
 
#include <string>
struct board_info {
size_t PhysAddress[6];
void* VirtAddress[6];
size_t Size[6];
size_t InterruptLevel;
size_t InterruptVector;
unsigned short vendor_id;
unsigned short device_id;
};
/*
//-----------------------------------------------------------------------------
// memory block structure
struct memory_block {
size_t phys;
void* virt;
size_t size;
};
 
struct board_info_t {
std::string name;
//-----------------------------------------------------------------------------
// memory block structure
struct memory_descriptor {
size_t dma_channel;
size_t total_blocks;
struct memory_block *blocks;
};
 
#endif //__BRD_INFO_H__
//-----------------------------------------------------------------------------
// stub memory structure
struct stub_descriptor {
size_t dma_channel;
struct memory_block stub;
};
*/
#endif
/common/board/board.h
23,6 → 23,13
#include "ctrlstrm.h"
#endif
 
#ifdef __VERBOSE__
#include <stdio.h>
#define DEBUG_PRINT(fmt, args...) fprintf(stderr, fmt, ## args)
#else
#define DEBUG_PRINT(fmt, args...)
#endif
 
class board {
 
private:
36,9 → 43,12
virtual int core_board_info() = 0;
virtual int core_pld_info() = 0;
virtual int core_resource() = 0;
virtual void core_delay(int ms) = 0;
 
virtual u32 core_alloc(int DmaChan, BRDctrl_StreamCBufAlloc* sSCA) = 0;
virtual u32 core_allocate_memory(int DmaChan, void** pBuf, u32 blkSize, u32 blkNum, u32 isSysMem, u32 dir, u32 addr) = 0;
virtual u32 core_allocate_memory(int DmaChan, void** pBuf, u32 blkSize,
u32 blkNum, u32 isSysMem, u32 dir,
u32 addr, BRDstrm_Stub **pStub ) = 0;
virtual u32 core_free_memory(int DmaChan) = 0;
virtual u32 core_start_dma(int DmaChan, int IsCycling) = 0;
virtual u32 core_stop_dma(int DmaChan) = 0;
69,6 → 79,7
int brd_close();
int brd_load_dsp();
int brd_load_pld();
void brd_delay(int ms);
 
int brd_board_info();
int brd_pld_info();
76,7 → 87,9
 
//! Методы управления каналами DMA BRDSHELL
u32 dma_alloc(int DmaChan, BRDctrl_StreamCBufAlloc* sSCA);
u32 dma_allocate_memory(int DmaChan, void** pBuf, u32 blkSize, u32 blkNum, u32 isSysMem, u32 dir, u32 addr);
u32 dma_allocate_memory(int DmaChan, void** pBuf, u32 blkSize,
u32 blkNum, u32 isSysMem,
u32 dir, u32 addr, BRDstrm_Stub **pStub);
u32 dma_free_memory(int DmaChan);
u32 dma_start(int DmaChan, int IsCycling);
u32 dma_stop(int DmaChan);
100,9 → 113,7
void brd_bar1_write( u32 offset, u32 val );
};
 
//#define RegPeekDir(trd, reg) brd_reg_peek_dir((trd), (reg))
//#define RegPeekInd(trd, reg) brd_reg_peek_ind((trd), (reg));
//#define RegPokeDir(trd, reg, val) brd_reg_poke_dir((trd), (reg), (val));
//#define RegPokeOnd(trd, reg, val) brd_reg_poke_ind((trd), (reg), (val));
//! Тип конструктора объектов
typedef board* (*board_factory)(void);
 
#endif //__BOARD_H__
/common/board/Makefile
0,0 → 1,29
#
#change this makefile for your target...
#
 
BASENAME = libboard.so
SONAME = $(BASENAME).0
LIBNAME = $(BASENAME).0.0
 
ROOT_DIR := $(shell pwd)
LIBDIR := ../../lib
 
SRC := $(wildcard *.cpp)
SOURCE := $(SRC)
OBJ_FILES := $(SOURCE:.cpp=.o)
 
all: $(LIBNAME)
 
CFLAGS += -I. -I../utils
 
$(LIBNAME): $(OBJ_FILES)
$(LD) -g -shared -rdynamic -Wl,-soname,$(SONAME) \
-o $(LIBNAME) $(notdir $(OBJ_FILES)) -ldl -lrt -lc -lpthread
chmod 666 $(LIBNAME)
ln -sf $(LIBNAME) $(SONAME)
ln -sf $(SONAME) $(BASENAME)
cp -vfa $(BASENAME) $(SONAME) $(LIBNAME) $(LIBDIR)
rm *.o *.d
 
include ../Mk.Rules
/common/pex/dma_memory.cpp File deleted
/common/pex/dma_memory.h File deleted
/common/pex/pex_board.cpp
2,9 → 2,6
#ifndef __PEX_BOARD_H__
#include "pex_board.h"
#endif
#ifndef __DMA_MEMORY__H__
#include "dma_memory.h"
#endif
 
//-----------------------------------------------------------------------------
 
33,7 → 30,7
fd = -1;
bar0 = bar1 = NULL;
memset(&bi, 0, sizeof(bi));
m_dma = new dma_memory();
//m_dma = new dma_memory();
}
 
//-----------------------------------------------------------------------------
40,7 → 37,7
 
pex_board::~pex_board()
{
if(m_dma) delete m_dma;
//if(m_dma) delete m_dma;
core_close();
}
 
161,21 → 158,21
// подготовим к работе ПЛИС ADM
fprintf(stderr,"%s(): Prepare ADM PLD.\n", __FUNCTION__);
core_block_write( 0, 8, 0);
core_pause(100); // pause ~ 100 msec
core_delay(100); // pause ~ 100 msec
for(i = 0; i < 10; i++)
{
core_block_write( 0, 8, 1);
core_pause(100); // pause ~ 100 msec
core_delay(100); // pause ~ 100 msec
core_block_write( 0, 8, 3);
core_pause(100); // pause ~ 100 msec
core_delay(100); // pause ~ 100 msec
core_block_write( 0, 8, 7);
core_pause(100); // pause ~ 100 msec
core_delay(100); // pause ~ 100 msec
temp = core_block_read( 0, 010 ) & 0x01;
if(temp)
break;
}
core_block_write( 0, 8, 0xF );
core_pause(100); // pause ~ 100 msec
core_delay(100); // pause ~ 100 msec
 
return 0;
}
293,9 → 290,9
d5=core_reg_peek_ind( ii, 0x105 );
 
switch( d ) {
case 1: str="TRD_MAIN "; break;
case 2: str="TRD_BASE_DAC "; break;
case 3: str="TRD_PIO_STD "; break;
case 1: str="TRD_MAIN "; break;
case 2: str="TRD_BASE_DAC "; break;
case 3: str="TRD_PIO_STD "; break;
case 0: str=" - "; break;
case 0x47: str="SBSRAM_IN "; break;
case 0x48: str="SBSRAM_OUT "; break;
319,6 → 316,9
case 0x72: str="TRD_TS201 "; break;
case 0x73: str="TRD_STREAM_IN "; break;
case 0x74: str="TRD_STREAM_OUT"; break;
case 0xA0: str="TRD_ADC "; break;
case 0xA1: str="TRD_DAC "; break;
case 0x91: str="TRD_EMAC "; break;
 
 
default: str="UNKNOWN"; break;
351,7 → 351,7
 
//-----------------------------------------------------------------------------
 
void pex_board::core_pause(int ms)
void pex_board::core_delay(int ms)
{
struct timeval tv = {0, 0};
tv.tv_usec = 1000*ms;
394,7 → 394,7
break;
 
if( ii>10000 )
core_pause( 1 );
core_delay( 1 );
if( ii>20000 ) {
return 0xFFFF;
}
439,7 → 439,7
break;
 
if( ii>10000 )
core_pause( 1 );
core_delay( 1 );
if( ii>20000 ) {
return;
}
452,7 → 452,7
 
u32 pex_board::core_bar0_read( u32 offset )
{
return bar0[offset];
return bar0[2*offset];
}
 
//-----------------------------------------------------------------------------
459,7 → 459,7
 
void pex_board::core_bar0_write( u32 offset, u32 val )
{
bar0[offset] = val;
bar0[2*offset] = val;
}
 
//-----------------------------------------------------------------------------
466,7 → 466,7
 
u32 pex_board::core_bar1_read( u32 offset )
{
return bar1[offset];
return bar1[2*offset];
}
 
//-----------------------------------------------------------------------------
582,7 → 582,14
 
//-----------------------------------------------------------------------------
 
u32 pex_board::core_allocate_memory(int DmaChan, void** pBuf, u32 blkSize, u32 blkNum, u32 isSysMem, u32 dir, u32 addr)
u32 pex_board::core_allocate_memory(int DmaChan,
void** pBuf,
u32 blkSize,
u32 blkNum,
u32 isSysMem,
u32 dir,
u32 addr,
BRDstrm_Stub **pStub )
{
m_DescrSize[DmaChan] = sizeof(AMB_MEM_DMA_CHANNEL) + (blkNum - 1) * sizeof(void*);
m_Descr[DmaChan] = (AMB_MEM_DMA_CHANNEL*) new u8[m_DescrSize[DmaChan]];
644,6 → 651,7
}
 
*pBuf = &m_Descr[DmaChan]->pBlock[0];
*pStub = (BRDstrm_Stub*)m_Descr[DmaChan]->pStub;
 
return 0;
}
/common/pex/factory.cpp
0,0 → 1,14
 
#include <iostream>
#include <string>
#include <istream>
#include <fstream>
#include <iomanip>
 
#include "pex_board.h"
#include "factory.h"
 
BRD_API board* create_board()
{
return new pex_board();
}
/common/pex/pex_board.h
21,7 → 21,7
 
//-----------------------------------------------------------------------------
 
class dma_memory;
//class dma_memory;
 
//-----------------------------------------------------------------------------
#define MAX_NUMBER_OF_DMACHANNELS 4
36,7 → 36,7
struct board_info bi;
void core_pause(int ms);
 
dma_memory *m_dma;
//dma_memory *m_dma;
 
AMB_MEM_DMA_CHANNEL *m_Descr[MAX_NUMBER_OF_DMACHANNELS];
u32 m_DescrSize[MAX_NUMBER_OF_DMACHANNELS];
54,9 → 54,12
int core_board_info();
int core_pld_info();
int core_resource();
void core_delay(int ms);
 
u32 core_alloc(int DmaChan, BRDctrl_StreamCBufAlloc* sSCA);
u32 core_allocate_memory(int DmaChan, void** pBuf, u32 blkSize, u32 blkNum, u32 isSysMem, u32 dir, u32 addr);
u32 core_allocate_memory(int DmaChan, void** pBuf, u32 blkSize,
u32 blkNum, u32 isSysMem, u32 dir,
u32 addr, BRDstrm_Stub **pStub);
u32 core_free_memory(int DmaChan);
u32 core_start_dma(int DmaChan, int IsCycling);
u32 core_stop_dma(int DmaChan);
/common/pex/factory.h
0,0 → 1,23
#ifndef FACTORY_H
#define FACTORY_H
 
#include "board.h"
 
#ifdef WINDOWS
#define BRD_API __declspec( dllexport )
#else
#define BRD_API
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
BRD_API board* create_board();
 
#ifdef __cplusplus
};
#endif
 
 
#endif // FACTORY_H
/common/pex/Makefile
0,0 → 1,45
#
#change this makefile for your target...
#
 
BASENAME = libpex_board.so
SONAME = $(BASENAME).0
LIBNAME = $(BASENAME).0.0
 
ROOT_DIR := $(shell pwd)
LIBDIR := ../../lib
 
CC := $(CROSS_COMPILE)g++
LD := $(CROSS_COMPILE)g++
 
INCDIR := . \
../../driver/pexdrv \
../board \
../utils \
../dma
 
INCLUDE := $(addprefix -I, $(INCDIR))
 
CFLAGS := -D__LINUX__ -O2 -Wall $(INCLUDE)
LFLAGS := -ldl -lrt -lpthread -lm
 
SRCFILE := $(wildcard *.cpp)
SRCFILE += $(wildcard ../board/*.cpp)
#SRCFILE += $(wildcard ../dma/*.cpp)
OBJFILE := $(patsubst %.cpp,%.o, $(SRCFILE))
 
all: $(LIBNAME)
 
$(LIBNAME): $(OBJFILE)
$(LD) -shared -rdynamic -Wl,-soname,$(SONAME) \
-o $(LIBNAME) $(notdir $(OBJFILE)) $(LFLAGS)
chmod 666 $(LIBNAME)
ln -sf $(LIBNAME) $(SONAME)
ln -sf $(SONAME) $(BASENAME)
cp -fa $(BASENAME) $(SONAME) $(LIBNAME) $(LIBDIR)
rm *.o *.d
 
include ../Mk.Rules
 
src:
echo $(SRCFILE)
/exam/pex_test.cpp
15,6 → 15,8
#include <sys/mman.h>
#include <fcntl.h>
 
#include "utypes_linux.h"
#include "brd_info.h"
#include "pexioctl.h"
#include "ambpexregs.h"
 
/exam/Makefile
12,11 → 12,11
CC = $(CROSS_COMPILE)g++
LD = $(CROSS_COMPILE)g++
 
CFLAGS := -D__LINUX__ -g -Wall -I../driver/pexdrv -I../common/board
CFLAGS := -D__LINUX__ -g -Wall -I../driver/pexdrv -I../common/board -I../common/utils
LFLAGS = -Wl
 
$(TARGET_NAME): $(patsubst %.cpp,%.o, $(wildcard *.cpp))
$(LD) $(LFLAGS) $(notdir $^) -o $(TARGET_NAME)
$(LD) -o $(TARGET_NAME) $(notdir $^) $(LFLAGS)
rm -f *.o *~ core
 
%.o: %.cpp
/driver/pexdrv/hardware.h
11,6 → 11,8
#define AMBPEX5_DEVID 0x5507
#define AMBPEXARM_DEVID 0x5702
#define AMBFMC106P_DEVID 0x550A
#define AMBFMC114V_DEVID 0x550C
#define AMBKU_SSCOS_DEVID 0x5703
 
//-----------------------------------------------------------------------------
 
26,8 → 28,6
void WriteOperationReg(struct pex_device *brd, u32 RelativePort, u32 Value);
u16 ReadOperationWordReg(struct pex_device *brd, u32 RelativePort);
void WriteOperationWordReg(struct pex_device *brd, u32 RelativePort, u16 Value);
u8 ReadOperationByteReg(struct pex_device *brd, u32 RelativePort);
void WriteOperationByteReg(struct pex_device *brd, u32 RelativePort, u8 Value);
u32 ReadAmbReg(struct pex_device *brd, u32 AdmNumber, u32 RelativePort);
u32 ReadAmbMainReg(struct pex_device *brd, u32 RelativePort);
void WriteAmbReg(struct pex_device *brd, u32 AdmNumber, u32 RelativePort, u32 Value);
/driver/pexdrv/pexmodule.c
39,7 → 39,7
static LIST_HEAD(device_list);
static int boards_count = 0;
static struct mutex pex_mutex;
int dbg_trace = 0;
int dbg_trace = 1;
int err_trace = 1;
 
//-----------------------------------------------------------------------------
473,6 → 473,18
.subvendor = PCI_ANY_ID,
.subdevice = PCI_ANY_ID,
},
{
.vendor = INSYS_VENDOR_ID,
.device = AMBFMC114V_DEVID,
.subvendor = PCI_ANY_ID,
.subdevice = PCI_ANY_ID,
},
{
.vendor = INSYS_VENDOR_ID,
.device = AMBKU_SSCOS_DEVID,
.subvendor = PCI_ANY_ID,
.subdevice = PCI_ANY_ID,
},
{ },
};
 
573,9 → 585,9
dbg_msg(dbg_trace, "%s(): Add cdev %d\n", __FUNCTION__, boards_count);
 
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)
brd->m_device = device_create(pex_class, NULL, brd->m_devno, "%s", brd->m_name);
brd->m_device = device_create(pex_class, NULL, brd->m_devno, "%s%d", "pexdrv", boards_count);
#else
brd->m_device = device_create(pex_class, NULL, brd->m_devno, NULL, "%s", brd->m_name);
brd->m_device = device_create(pex_class, NULL, brd->m_devno, NULL, "%s%d", "pexdrv", boards_count);
#endif
if(!brd->m_device ) {
err_msg(err_trace, "%s(): Error create device for board: %s\n", __FUNCTION__, brd->m_name);
643,6 → 655,7
{
struct list_head *pos, *n;
struct pex_device *brd = NULL;
int i = 0;
 
dbg_msg(dbg_trace, "%s(): device_id = %x, vendor_id = %x\n", __FUNCTION__, dev->device, dev->vendor);
 
658,6 → 671,12
dbg_msg(dbg_trace, "%s(): free_irq() - complete\n", __FUNCTION__);
pex_remove_proc(brd->m_name);
dbg_msg(dbg_trace, "%s(): pex_remove_proc() - complete\n", __FUNCTION__);
for(i = 0; i < MAX_NUMBER_OF_DMACHANNELS; i++) {
if(brd->m_DmaChannel[i]) {
CDmaChannelDelete(brd->m_DmaChannel[i]);
dbg_msg(dbg_trace, "%s(): free DMA channel %d - complete\n", __FUNCTION__, i);
}
}
free_memory(brd);
dbg_msg(dbg_trace, "%s(): free_memory() - complete\n", __FUNCTION__);
device_destroy(pex_class, brd->m_devno);
/driver/pexdrv/exam/pex_test.cpp
15,6 → 15,8
#include <sys/mman.h>
#include <fcntl.h>
 
#include "utypes_linux.h"
#include "brd_info.h"
#include "pexioctl.h"
#include "ambpexregs.h"
 
/driver/pexdrv/exam/Makefile
12,7 → 12,7
CC = $(CROSS_COMPILE)g++
LD = $(CROSS_COMPILE)g++
 
CFLAGS := -D__LINUX__ -g -Wall -I..
CFLAGS := -D__LINUX__ -g -Wall -I.. -I../../../common/utils -I../../../common/board
LFLAGS = -Wl
 
$(TARGET_NAME): $(patsubst %.cpp,%.o, $(wildcard *.cpp))
/driver/pexdrv/pexproc.c
19,7 → 19,7
 
void pex_register_proc( char *name, void *fptr, void *data )
{
create_proc_read_entry( name, 0, NULL, fptr, data );
create_proc_read_entry( name, 0, NULL, fptr, data );
}
 
//--------------------------------------------------------------------
26,11 → 26,74
 
void pex_remove_proc( char *name )
{
remove_proc_entry( name, NULL );
remove_proc_entry( name, NULL );
}
 
//--------------------------------------------------------------------
 
int pex_show_capabilities( char *buf, struct pex_device *brd )
{
int i = 0, res = -1;
char *p = buf;
u8 cap;
u8 cap_id;
 
p += sprintf(p,"\n" );
p += sprintf(p," Device capabilities\n" );
p += sprintf(p,"\n" );
 
res = pci_read_config_byte(brd->m_pci, 0x34, &cap);
if(res < 0) {
p += sprintf(p, " Error read capabilities pointer\n");
goto err_exit;
}
res = pci_read_config_byte(brd->m_pci, cap, &cap_id);
if(res < 0) {
p += sprintf(p, " Error read capabilities id\n");
goto err_exit;
}
if(cap_id != 0x10) { //not PCI Express capabilities
 
res = pci_read_config_byte(brd->m_pci, cap+1, &cap);
if(res < 0) {
p += sprintf(p, " Error read capabilities id\n");
goto err_exit;
}
}
res = pci_read_config_byte(brd->m_pci, cap, &cap_id);
if(res < 0) {
p += sprintf(p, " Error read capabilities id\n");
goto err_exit;
} else {
p += sprintf(p, " CAP_ID = 0x%X\n", cap_id);
}
 
if(cap_id != 0x10) {
p += sprintf(p, " Can't find PCI Express capabilities\n");
goto err_exit;
}
 
for(i=0; i<9; i++) {
u32 reg = 0;
int j = cap + 4*i;
res = pci_read_config_dword(brd->m_pci, j, &reg);
if(res < 0) {
p += sprintf(p, " Error read capabilities sructure: offset %x\n", j);
goto err_exit;
}
p += sprintf(p, " %x: = 0x%X\n", j, reg);
}
 
err_exit:
 
return (p-buf);
}
 
//--------------------------------------------------------------------
 
int pex_proc_info( char *buf,
char **start,
off_t off,
38,63 → 101,68
int *eof,
void *data )
{
int iBlock = 0;
char *p = buf;
struct pex_device *brd = (struct pex_device*)data;
int iBlock = 0;
char *p = buf;
struct pex_device *brd = (struct pex_device*)data;
 
if(!brd) {
p += sprintf(p," Invalid device pointer\n" );
*eof = 1;
return p - buf;
}
if(!brd) {
p += sprintf(p," Invalid device pointer\n" );
*eof = 1;
return p - buf;
}
 
p += sprintf(p," Device information\n" );
p += pex_show_capabilities(p, brd);
 
p += sprintf(p, " m_TotalIRQ = %d\n", atomic_read(&brd->m_TotalIRQ));
p += sprintf(p,"\n" );
p += sprintf(p," Device information\n" );
 
for(iBlock = 0; iBlock < brd->m_BlockCnt; iBlock++)
{
u32 FifoAddr = 0;
u16 val = 0;
p += sprintf(p, " m_TotalIRQ = %d\n", atomic_read(&brd->m_TotalIRQ));
 
FifoAddr = (iBlock + 1) * PE_FIFO_ADDR;
val = ReadOperationWordReg(brd, PEFIFOadr_BLOCK_ID + FifoAddr);
 
if((val & 0x0FFF) != PE_EXT_FIFO_ID)
continue;
 
p += sprintf(p,"\n" );
p += sprintf(p," PE_EXT_FIFO %d\n", iBlock+1 );
p += sprintf(p,"\n" );
for(iBlock = 0; iBlock < brd->m_BlockCnt; iBlock++)
{
u32 FifoAddr = 0;
u16 val = 0;
 
p += sprintf(p," BLOCK_ID = %x\n", (val & 0x0FFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_BLOCK_VER + FifoAddr);
p += sprintf(p," BLOCK_VER = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_FIFO_ID + FifoAddr);
p += sprintf(p," FIFO_ID = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_FIFO_NUM + FifoAddr);
p += sprintf(p," FIFO_NUMBER = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_DMA_SIZE + FifoAddr);
p += sprintf(p," RESOURCE = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_FIFO_CTRL + FifoAddr);
p += sprintf(p," DMA_MODE = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_DMA_CTRL + FifoAddr);
p += sprintf(p," DMA_CTRL = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_FIFO_STATUS + FifoAddr);
p += sprintf(p," FIFO_STATUS = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_FLAG_CLR + FifoAddr);
p += sprintf(p," FLAG_CLR = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_PCI_ADDRL + FifoAddr);
p += sprintf(p," PCI_ADRL = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_PCI_ADDRH + FifoAddr);
p += sprintf(p," PCI_ADRH = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_LOCAL_ADR + FifoAddr);
p += sprintf(p," LOCAL_ADR = %x\n", (val & 0xFFFF) );
}
FifoAddr = (iBlock + 1) * PE_FIFO_ADDR;
val = ReadOperationWordReg(brd, PEFIFOadr_BLOCK_ID + FifoAddr);
 
*eof = 1;
if((val & 0x0FFF) != PE_EXT_FIFO_ID)
continue;
 
return p - buf;
p += sprintf(p,"\n" );
p += sprintf(p," PE_EXT_FIFO %d\n", iBlock+1 );
p += sprintf(p,"\n" );
 
p += sprintf(p," BLOCK_ID = %x\n", (val & 0x0FFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_BLOCK_VER + FifoAddr);
p += sprintf(p," BLOCK_VER = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_FIFO_ID + FifoAddr);
p += sprintf(p," FIFO_ID = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_FIFO_NUM + FifoAddr);
p += sprintf(p," FIFO_NUMBER = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_DMA_SIZE + FifoAddr);
p += sprintf(p," RESOURCE = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_FIFO_CTRL + FifoAddr);
p += sprintf(p," DMA_MODE = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_DMA_CTRL + FifoAddr);
p += sprintf(p," DMA_CTRL = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_FIFO_STATUS + FifoAddr);
p += sprintf(p," FIFO_STATUS = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_FLAG_CLR + FifoAddr);
p += sprintf(p," FLAG_CLR = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_PCI_ADDRL + FifoAddr);
p += sprintf(p," PCI_ADRL = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_PCI_ADDRH + FifoAddr);
p += sprintf(p," PCI_ADRH = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_LOCAL_ADR + FifoAddr);
p += sprintf(p," LOCAL_ADR = %x\n", (val & 0xFFFF) );
}
 
*eof = 1;
 
return p - buf;
}
 
//--------------------------------------------------------------------
/driver/pexdrv/insert
4,32 → 4,69
# This script is loading modules in the kernel.
#
 
kernel=`uname -r | grep 2.6`
status ()
{
if [ $1 -eq 0 ] ; then
echo "[SUCCESS]"
else
echo "[FAILED]"
 
if [ ${kernel} = "" ]
if [ $2 -eq 1 ] ; then
echo "... loading aborted."
exit 1
fi
fi
}
 
echo
 
kernel=`uname -r | grep 2.4`
 
if [ $kernel ]
then
module=ambpex.o
module=pexdrv.o
mname=${module%.o}
else
module=`find *.ko`
mname=${module%.ko}
fi
module="pexdrv.ko"
 
if [ ${module} = "" ]
device=pexdrv
mode="666"
 
chmod 777 /dev/shm
 
if [ ${module} ]
then
echo No kernel module found. ${module}
exit
echo -n " Find ${module} module : "
status $? 0
else
echo Find ${module} - kernel module.
echo -n " Kernel module not found : "
status 1 0
exit
fi
 
/sbin/insmod ./$module $* || exit 1
was_loaded=`/sbin/lsmod | cut -c 1-6 | grep $device`
 
sleep 1
if [ ${was_loaded} ]
then
echo -n " Remove loaded module : "
/sbin/rmmod $device
status $? 0
else
echo Loading module: ${module}
fi
 
devfiles=`ls /dev/* | grep AMB`
echo -n " Loading pexdrv module : "
insmod ./${module}
 
#echo ${devfiles}
until [ -e /dev/pexdrv0 ]
do
sleep 1.5
done
 
chmod -v 666 ${devfiles}
chmod 666 /dev/pexdrv*
 
status $? 0
 
echo
/driver/pexdrv/ioctlrw.c
15,6 → 15,7
#include "pexioctl.h"
#include "hardware.h"
#include "ambpexregs.h"
#include "brd_info.h"
 
//--------------------------------------------------------------------
 
/driver/pexdrv/dmachan.c
79,6 → 79,8
// а при повторных только отображаем выделенную память на пользовательское пространство
if(!dma->m_UseCount)
{
dma_addr_t pa = (dma_addr_t)0;
 
dma->m_MemType = bMemType;
dma->m_BlockCount = *pCount;
dma->m_BlockSize = size;
86,7 → 88,7
// выделяем память под описатели блоков (системный, и логический адрес для каждого блока)
dma->m_pBufDscr.SystemAddress = (void*)dma_alloc_coherent( dma->m_dev,
dma->m_BlockCount * sizeof(SHARED_MEMORY_DESCRIPTION),
&dma->m_pBufDscr.LogicalAddress, GFP_KERNEL);
&pa, GFP_KERNEL);
if(!dma->m_pBufDscr.SystemAddress)
{
printk("<0>%s(): Not memory for buffer descriptions\n", __FUNCTION__);
93,6 → 95,7
return -ENOMEM;
}
 
dma->m_pBufDscr.LogicalAddress = (size_t)pa;
dma->m_ScatterGatherTableEntryCnt = 0;
}
 
/driver/pexdrv/pexioctl.h
93,18 → 93,6
PEX_MAKE_IOCTL(PEX_DEVICE_TYPE, PEX_ADJUST)
 
//-----------------------------------------------------------------------------
// board configuration data structure
struct board_info {
size_t PhysAddress[6]; // OUT
void* VirtAddress[6]; // OUT
size_t Size[6]; // OUT
size_t InterruptLevel; // OUT
size_t InterruptVector;// OUT
unsigned short vendor_id; // OUT
unsigned short device_id; // OUT
};
 
//-----------------------------------------------------------------------------
// memory block structure
struct memory_block {
size_t phys;
/driver/pexdrv/Makefile
1,6 → 1,7
 
KERNELVER := $(shell uname -r)
EXTRA_CFLAGS += -O2
EXTRA_CFLAGS += -I $(PWD)/../../common/board
 
ifneq ($(KERNELRELEASE),)
 
14,7 → 15,7
PWD := $(shell pwd)
 
modules:
$(MAKE) -C $(KERNELDIR) M=$(PWD) $(DIRS)
$(MAKE) -C $(KERNELDIR) M=$(PWD) EXTRA_CFLAGS="$(EXTRA_CFLAGS)"
 
endif
 
29,3 → 30,6
ifeq (.depend, $(wildcard .depend))
include .depend
endif
 
install:
./insert
/driver/pexdrv/hardware.c
27,8 → 27,10
case AMBPEX8_DEVID: snprintf(brd->m_name, 128, "%s%d", "AMBPEX8", index); break;
case ADP201X1AMB_DEVID: snprintf(brd->m_name, 128, "%s%d", "ADP201X1AMB", index); break;
case ADP201X1DSP_DEVID: snprintf(brd->m_name, 128, "%s%d", "ADP201X1DSP", index); break;
case AMBPEXARM_DEVID: snprintf(brd->m_name, 128, "%s%d", "AMBPEXARM_DEVID", index); break;
case AMBFMC106P_DEVID: snprintf(brd->m_name, 128, "%s%d", "AMBFMC106P_DEVID", index); break;
case AMBPEXARM_DEVID: snprintf(brd->m_name, 128, "%s%d", "D2XT005", index); break;
case AMBFMC106P_DEVID: snprintf(brd->m_name, 128, "%s%d", "AMBFMC106P", index); break;
case AMBFMC114V_DEVID: snprintf(brd->m_name, 128, "%s%d", "AMBFMC114V", index); break;
case AMBKU_SSCOS_DEVID: snprintf(brd->m_name, 128, "%s%d", "AMBKU_SSCOS", index); break;
default:
snprintf(brd->m_name, sizeof(brd->m_name), "%s%d", "Unknown", index); break;
}
113,8 → 115,12
if((AMBPEX8_DEVID != deviceID) &&
(ADP201X1AMB_DEVID != deviceID) &&
(AMBPEX5_DEVID != deviceID) &&
(AMBPEXARM_DEVID != deviceID))
(AMBPEXARM_DEVID != deviceID) &&
(AMBFMC114V_DEVID != deviceID)) {
 
dbg_msg(dbg_trace, "%s(): Unsupported device id: 0x%X.\n", __FUNCTION__, deviceID);
return -ENODEV;
}
 
temp = ReadOperationWordReg(brd, PEMAINadr_PLD_VER);
 
265,7 → 271,9
 
u16 ReadOperationWordReg(struct pex_device *brd, u32 RelativePort)
{
return readw((u16*)((u8*)brd->m_BAR0.virtual_address + RelativePort));
u32 tmpVal = readl((u32*)((u8*)brd->m_BAR0.virtual_address + RelativePort));
return (tmpVal & 0xFFFF);
//return readw((u16*)((u8*)brd->m_BAR0.virtual_address + RelativePort));
}
 
//--------------------------------------------------------------------
272,25 → 280,13
 
void WriteOperationWordReg(struct pex_device *brd, u32 RelativePort, u16 Value)
{
writew( Value, (u16*)((u8*)brd->m_BAR0.virtual_address + RelativePort));
u32 tmpVal = Value;
//writew( Value, (u16*)((u8*)brd->m_BAR0.virtual_address + RelativePort));
writel( tmpVal, (u32*)((u8*)brd->m_BAR0.virtual_address + RelativePort));
}
 
//--------------------------------------------------------------------
 
u8 ReadOperationByteReg(struct pex_device *brd, u32 RelativePort)
{
return readb((u8*)((u8*)brd->m_BAR0.virtual_address + RelativePort));
}
 
//--------------------------------------------------------------------
 
void WriteOperationByteReg(struct pex_device *brd, u32 RelativePort, u8 Value)
{
writeb( Value, (u8*)((u8*)brd->m_BAR0.virtual_address + RelativePort));
}
 
//--------------------------------------------------------------------
 
u32 ReadAmbReg(struct pex_device *brd, u32 AdmNumber, u32 RelativePort)
{
u8* pBaseAddress = (u8*)brd->m_BAR1.virtual_address + AdmNumber * ADM_SIZE;

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.