1116 lines
32 KiB
C++
1116 lines
32 KiB
C++
#include "fgpaprogrammer.h"
|
|
|
|
#include <QTimer>
|
|
#include <QTimerEvent>
|
|
#include <QThread>
|
|
#include <QEventLoop>
|
|
#include <QEvent>
|
|
#include <QQueue>
|
|
#include <QApplication>
|
|
#include <QElapsedTimer>
|
|
#include <QMessageBox>
|
|
#include <QTimer>
|
|
|
|
#include "mydebug.h"
|
|
|
|
#include <QAbstractEventDispatcher>
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <exception>
|
|
|
|
#include "fpgaflashengine.h"
|
|
|
|
#include "FpgaBridgeTftp.h"
|
|
|
|
#include "fileutils.h"
|
|
|
|
#include "fpgabeammeupstring.h"
|
|
|
|
static unsigned char dummy_buffer[1024];
|
|
|
|
class my_exception: public std::exception
|
|
{
|
|
public:
|
|
int code;
|
|
my_exception(int c): code(c) {}
|
|
};
|
|
|
|
enum UserEventId
|
|
{
|
|
evn_start=QEvent::User+100,
|
|
|
|
evn_timeout,
|
|
evn_write_completed,
|
|
evn_read_completed,
|
|
|
|
evn_break,
|
|
evn_abort,
|
|
evn_error,
|
|
|
|
evn_erase,
|
|
evn_reset,
|
|
evn_readFlashID,
|
|
evn_readStatusSPI,
|
|
evn_terminate
|
|
};
|
|
|
|
struct event_data_t
|
|
{
|
|
int type;
|
|
unsigned int len;
|
|
char data[256];
|
|
|
|
event_data_t(QEvent::Type type_=QEvent::User, const void* data_=0, unsigned int len_=0):
|
|
type(type_), len(len_)
|
|
{
|
|
(void)data_;
|
|
}
|
|
};
|
|
|
|
|
|
|
|
class MyEvent: public QEvent
|
|
{
|
|
public:
|
|
MyEvent(int type): QEvent(QEvent::Type(type)), data(QEvent::Type(type))
|
|
{
|
|
}
|
|
event_data_t data;
|
|
};
|
|
|
|
|
|
|
|
class FgpaProgrammer::FpgaProgrammerImplementation: public QThread, public FpgaFlashInterface
|
|
{
|
|
public:
|
|
//int tId;
|
|
QTimer* pTimer;
|
|
|
|
FgpaProgrammer* tFpgaProg;
|
|
|
|
FpgaBridgeTftp* tftp;
|
|
bool simulate;
|
|
bool SRIOMemory; //0 for address BASE_ADDRESS_IF
|
|
//=!0 for address BASE_ADDRESS_MEM
|
|
|
|
FpgaFlashEngine engine;
|
|
|
|
FpgaFlashProfile profile;
|
|
|
|
QElapsedTimer elapsedTimer;
|
|
//FpgaFlashInterface
|
|
virtual unsigned long timeNowMs() override
|
|
{
|
|
return elapsedTimer.elapsed();
|
|
}
|
|
|
|
//***********************************************************************
|
|
// rtgWrite
|
|
// Input parameters: address = address to write
|
|
// data = buffer to write
|
|
// len = buffer's length
|
|
// mess = message to write into debug log
|
|
// Returns: true, no error, operation completed
|
|
// false, generic error into write function
|
|
//***********************************************************************
|
|
virtual bool rtgWrite(uint32_t address, const void* data, unsigned int len=256) override
|
|
{
|
|
if (tftp && !simulate)
|
|
{
|
|
QString remoteFile = "";
|
|
if (SRIOMemory)
|
|
{
|
|
remoteFile =QString("$SRIO:%1/0x%2+%3").arg(profile.slotAddress).arg(BASE_ADDRESS_MEM+address, 0, 16).arg(len);
|
|
}
|
|
else
|
|
{
|
|
remoteFile =QString("$SRIO:%1/0x%2+%3").arg(profile.slotAddress).arg(BASE_ADDRESS_IF+address, 0, 16).arg(len);
|
|
}
|
|
|
|
MyDebug.logMsg( type_log_info,
|
|
origin_msg_srio ,
|
|
QString(STR_COMMAND_WRITE).arg(remoteFile));
|
|
|
|
Q_EMIT tFpgaProg->writeRequest(remoteFile, data, len);
|
|
bool ok=waitTxEvent();
|
|
int countRepeat = NUM_REPEAT_WRITE;
|
|
|
|
//repeatwrite until is ok or error
|
|
while ((!ok) && (countRepeat>0))
|
|
{
|
|
MyDebug.logMsg( type_log_error,
|
|
origin_msg_tftp ,
|
|
STR_TRY_TO_REPEAT_WRITE);
|
|
|
|
Q_EMIT tFpgaProg->writeRequest(remoteFile, data, len);
|
|
ok=waitTxEvent();
|
|
if (WAIT_TIME_AFTER_WR>0)
|
|
waitEventTimeout(WAIT_TIME_AFTER_WR);
|
|
|
|
countRepeat--;
|
|
}
|
|
|
|
if (countRepeat==0)
|
|
{
|
|
MyDebug.logMsg( type_log_error,
|
|
origin_msg_tftp ,
|
|
STR_TRY_TOO_WRITE);
|
|
return false;
|
|
}
|
|
|
|
if (WAIT_TIME_AFTER_WR>0)
|
|
waitEventTimeout(WAIT_TIME_AFTER_WR);
|
|
|
|
return ok;
|
|
}
|
|
if (simulate)
|
|
{
|
|
engine.simulateWrite(address, data, len);
|
|
}
|
|
if (WAIT_TIME_AFTER_WR>0)
|
|
waitEventTimeout(WAIT_TIME_AFTER_WR);
|
|
return true;
|
|
}
|
|
|
|
//***********************************************************************
|
|
// rtgRead
|
|
// Input parameters: address = address to read
|
|
// data = ouput buffer
|
|
// len = buffer's length
|
|
//
|
|
// Returns: true, no error, operation completed
|
|
// false, generic error into read function
|
|
//***********************************************************************
|
|
virtual bool rtgRead(uint32_t address, void* data, unsigned int len=256) override
|
|
{
|
|
if (tftp && !simulate)
|
|
{
|
|
QString remoteFile= "";
|
|
if (SRIOMemory)
|
|
{
|
|
remoteFile=QString("$SRIO:%1/0x%2+%3").arg(profile.slotAddress).arg(BASE_ADDRESS_MEM+address, 0, 16).arg(len);
|
|
}
|
|
else
|
|
{
|
|
remoteFile=QString("$SRIO:%1/0x%2+%3").arg(profile.slotAddress).arg(BASE_ADDRESS_IF+address, 0, 16).arg(len);
|
|
}
|
|
|
|
MyDebug.logMsg( type_log_info,
|
|
origin_msg_srio ,
|
|
QString(STR_COMMAND_READ).arg(remoteFile));
|
|
|
|
Q_EMIT tFpgaProg->readRequest(remoteFile, data, len);
|
|
bool ok=waitRxEvent();
|
|
|
|
int countRepeat = NUM_REPEAT_READ;
|
|
|
|
//repeatwrite until is ok or error
|
|
while ((!ok) && (countRepeat>0))
|
|
{
|
|
MyDebug.logMsg( type_log_error,
|
|
origin_msg_tftp ,
|
|
STR_TRY_TO_REPEAT_READ);
|
|
|
|
Q_EMIT tFpgaProg->readRequest(remoteFile, data, len);
|
|
ok=waitTxEvent();
|
|
if (WAIT_TIME_AFTER_RD>0)
|
|
waitEventTimeout(WAIT_TIME_AFTER_RD);
|
|
|
|
countRepeat--;
|
|
}
|
|
|
|
if (countRepeat==0)
|
|
{
|
|
MyDebug.logMsg( type_log_error,
|
|
origin_msg_tftp ,
|
|
STR_TRY_TOO_READ );
|
|
return false;
|
|
}
|
|
|
|
if (WAIT_TIME_AFTER_RD>0)
|
|
waitEventTimeout(WAIT_TIME_AFTER_RD);
|
|
return ok;
|
|
}
|
|
if (simulate)
|
|
{
|
|
engine.simulateRead(address, data, len);
|
|
}
|
|
if (WAIT_TIME_AFTER_RD>0)
|
|
waitEventTimeout(WAIT_TIME_AFTER_RD);
|
|
return true;
|
|
}
|
|
|
|
//***********************************************************************
|
|
// rtgRead Direct
|
|
// Input parameters: address = address to read
|
|
// data = ouput buffer
|
|
// len = buffer's length
|
|
//
|
|
// Returns: true, no error, operation completed
|
|
// false, generic error into read function
|
|
//***********************************************************************
|
|
virtual bool rtgReadDirect(uint32_t address, void* data, unsigned int len=256) override
|
|
{
|
|
if (tftp && !simulate)
|
|
{
|
|
QString remoteFile= "";
|
|
|
|
remoteFile=QString("$SRIO:%1/0x%2+%3").arg(profile.slotAddress).arg(address, 0, 16).arg(len);
|
|
|
|
if (LOG_LEVEL>log_level_min)
|
|
{
|
|
|
|
MyDebug.logMsg( type_log_info,
|
|
origin_msg_srio ,
|
|
QString(STR_COMMAND_READ_DIRECT).arg(remoteFile));
|
|
}
|
|
|
|
Q_EMIT tFpgaProg->readRequest(remoteFile, data, len);
|
|
return waitRxEvent();
|
|
}
|
|
waitEventTimeout(100);
|
|
return true;
|
|
}
|
|
#if 0
|
|
virtual bool rtgErase(uint32_t address, void* data, unsigned int len=256) override
|
|
{
|
|
engine.simulateErase(address, data, len);
|
|
waitEventTimeout(100);
|
|
return true;
|
|
}
|
|
#endif
|
|
virtual bool rtgWaitEvent(unsigned int timeout_ms=5000)
|
|
{
|
|
if (timeout_ms==0)
|
|
return true;
|
|
/*event_data_t tmp=*/waitEvent(timeout_ms);
|
|
return true;
|
|
}
|
|
|
|
virtual void notify(FpgaFlashInterface::step_t sts, int progress, const char* msg, ...) override
|
|
{
|
|
va_list args;
|
|
va_start(args, msg);
|
|
notifyStatus(sts, progress, QString::vasprintf(msg, args));
|
|
MyDebug.logMsg( type_log_info,
|
|
origin_msg_engine ,
|
|
QString::vasprintf(msg, args));
|
|
va_end(args);
|
|
}
|
|
|
|
virtual void log(type_log_t level, const char* msg, ...) override //level<0: error, ==0: info, >0: success
|
|
{
|
|
va_list args;
|
|
va_start(args, msg);
|
|
|
|
MyDebug.logMsg(level,
|
|
origin_msg_engine,
|
|
QString::vasprintf(msg, args));
|
|
|
|
va_end(args);
|
|
}
|
|
|
|
struct state_t
|
|
{
|
|
FpgaProgrammerDriver* driver;
|
|
int timer_pending;
|
|
|
|
int state;
|
|
};
|
|
|
|
state_t s;
|
|
volatile unsigned sectorSize;
|
|
volatile unsigned int baseAddress;
|
|
|
|
FpgaProgrammerImplementation():
|
|
//tId(0),
|
|
tFpgaProg(0),
|
|
tftp(0),
|
|
simulate(false)
|
|
{
|
|
//pTimer.setSingleShot(true);
|
|
}
|
|
|
|
//***********************************************************************
|
|
// Set profile of the selected FPGA-flash
|
|
// Input parameters: _profile = parameters of selected fpga/flash
|
|
//
|
|
// Returns:
|
|
//***********************************************************************
|
|
void setProfile(const FpgaFlashProfile& _profile)
|
|
{
|
|
profile = _profile;
|
|
profile.BaseOffset = profile.address_start_area;
|
|
|
|
//
|
|
profile.SectorSize_KBytes = FLASH_SECTOR_DIM;
|
|
sectorSize = FLASH_SECTOR_DIM;
|
|
}
|
|
|
|
//***********************************************************************
|
|
// Inizialize programmer with default parameters
|
|
// Input parameters: _profile = parameters of selected fpga/flash
|
|
//
|
|
// Returns:
|
|
//***********************************************************************
|
|
void initialize(unsigned int /*write_size*/, int sector_size, int base_address)
|
|
{
|
|
sectorSize=sector_size;
|
|
baseAddress=base_address;
|
|
profile.reset();
|
|
profile.SectorSize_KBytes = sectorSize;
|
|
profile.BaseAddress = baseAddress;
|
|
profile.BaseOffset = 0;
|
|
}
|
|
|
|
void waitTxCompleted()
|
|
{
|
|
waitEventTimeout();
|
|
}
|
|
|
|
void waitSpiBusy()
|
|
{
|
|
event_data_t evn=waitEventTimeout();
|
|
if (evn.type!=evn_read_completed)
|
|
throw my_exception(1);
|
|
}
|
|
|
|
void waitSpiRdy()
|
|
{
|
|
event_data_t evn=waitEventTimeout();
|
|
if (evn.type!=evn_read_completed)
|
|
throw my_exception(1);
|
|
}
|
|
|
|
enum states_t
|
|
{
|
|
s_reset_wait=1,
|
|
s_id_request,
|
|
s_progr_enable,
|
|
s_erase_block,
|
|
s_program_block
|
|
};
|
|
|
|
void stateReset()
|
|
{
|
|
}
|
|
|
|
void state_RequestId()
|
|
{
|
|
}
|
|
|
|
void timerExpired()
|
|
{
|
|
//QCoreApplication::postEvent(this, new MyEvent(evn_timeout));
|
|
}
|
|
|
|
QQueue<event_data_t> qevn;
|
|
|
|
bool waitTxEvent(unsigned int tm_ms=0)
|
|
{
|
|
event_data_t e=waitEvent(tm_ms);
|
|
return e.type==evn_write_completed;
|
|
}
|
|
|
|
bool waitRxEvent(unsigned int tm_ms=0)
|
|
{
|
|
event_data_t e=waitEvent(tm_ms);
|
|
return e.type==evn_read_completed;
|
|
}
|
|
|
|
event_data_t waitEventTimeout(unsigned int tm_ms=5000)
|
|
{
|
|
if (tm_ms==0)
|
|
{
|
|
static event_data_t myeven;
|
|
myeven.type=evn_timeout;
|
|
return myeven;
|
|
}
|
|
return waitEvent(tm_ms);
|
|
}
|
|
|
|
event_data_t waitEvent(unsigned int tm_ms=0)
|
|
{
|
|
if (pTimer->isActive())
|
|
{
|
|
pTimer->stop();
|
|
}
|
|
#if 0
|
|
if (tId)
|
|
{
|
|
killTimer(tId);
|
|
tId=0;
|
|
}
|
|
#endif
|
|
#if 0
|
|
if (!qevn.isEmpty())
|
|
{
|
|
event_data_t evn=qevn.takeFirst();
|
|
//if (evn.type==evn_abort)
|
|
// throw(std::system_error(1));
|
|
|
|
MyDebug()<<"Event pending:"<<evn.type;
|
|
return evn;
|
|
}
|
|
#endif
|
|
|
|
if (tm_ms)
|
|
{
|
|
//tId=startTimer(tm_ms); //w->waitStart(tm_ms);
|
|
pTimer->start(tm_ms);
|
|
}
|
|
retry_:
|
|
QEventLoop::ProcessEventsFlags flags=QEventLoop::WaitForMoreEvents;
|
|
bool processed=this->eventDispatcher()->processEvents(flags);
|
|
int count_event = 0;
|
|
if (processed)
|
|
{
|
|
if (!qevn.isEmpty())
|
|
{
|
|
count_event = qevn.count();
|
|
#if 0
|
|
if (tId)
|
|
{
|
|
killTimer(tId);
|
|
tId=0;
|
|
}
|
|
#endif
|
|
pTimer->stop();
|
|
|
|
event_data_t evn=qevn.takeFirst();
|
|
if (evn.type==evn_break)
|
|
{
|
|
MyDebug.logMsg(type_log_error,
|
|
origin_msg_generic,
|
|
STR_EXCP_BREAK);
|
|
throw my_exception(3);
|
|
}
|
|
|
|
switch (evn.type)
|
|
{
|
|
case evn_timeout:
|
|
MyDebug.logMsg(type_log_info,
|
|
origin_msg_event,
|
|
QString(STR_TIMEOUT_QUEUE).arg(count_event));
|
|
|
|
break;
|
|
case evn_write_completed:
|
|
MyDebug.logMsg(type_log_info,
|
|
origin_msg_event,
|
|
QString(STR_WRITE_COMPLETED_QUEUE).arg(count_event));
|
|
break;
|
|
case evn_read_completed:
|
|
MyDebug.logMsg(type_log_info,
|
|
origin_msg_event,
|
|
QString(STR_READ_COMPLETED_QUEUE).arg(count_event));
|
|
break;
|
|
default:
|
|
MyDebug.logMsg(type_log_info,
|
|
origin_msg_event,
|
|
QString(STR_QUEUE_EVENT).arg(evn.type).arg(count_event));
|
|
break;
|
|
}
|
|
|
|
return evn;
|
|
}
|
|
else
|
|
{
|
|
MyDebug.logMsg(type_log_info,
|
|
origin_msg_event,
|
|
STR_QUEUE_EVENT_EMPTY);
|
|
}
|
|
}
|
|
goto retry_;
|
|
return event_data_t(QEvent::User, 0, 0);
|
|
}
|
|
|
|
void customEvent(QEvent* evn) override
|
|
{
|
|
if (evn->type()>=QEvent::User)
|
|
{
|
|
MyEvent* me=reinterpret_cast<MyEvent*>(evn);
|
|
if (me)
|
|
qevn.append(me->data);
|
|
}
|
|
}
|
|
void timerEvent(QTimerEvent* evn)
|
|
{
|
|
if (evn->timerId()==pTimer->timerId()) //tId)
|
|
{
|
|
//tId=0;
|
|
//killTimer(tId);
|
|
pTimer->stop();
|
|
static event_data_t data;
|
|
data.type=evn_timeout;
|
|
qevn.append(data);
|
|
}
|
|
else
|
|
QThread::timerEvent(evn);
|
|
}
|
|
|
|
void run()
|
|
{
|
|
pTimer=new QTimer(this);
|
|
pTimer->setSingleShot(true);
|
|
pTimer->moveToThread(this);
|
|
connect(pTimer, &QTimer::timeout, this, [this]()
|
|
{
|
|
QCoreApplication::postEvent(this, new MyEvent(evn_timeout), Qt::HighEventPriority);
|
|
});
|
|
execute();
|
|
}
|
|
|
|
void notifyStatus(int sts, int progress, const QString& msg)
|
|
{
|
|
|
|
Q_EMIT tFpgaProg->statusChanged(sts, progress, msg);
|
|
}
|
|
|
|
//***********************************************************************
|
|
// Start program flash with erase first
|
|
// Input parameters:
|
|
//
|
|
// Returns:
|
|
//***********************************************************************
|
|
void startProgram()
|
|
{
|
|
//setto il profilo di fpga da processare
|
|
engine.setProfile(profile);
|
|
|
|
event_data_t evn;
|
|
|
|
//reset dummy_buffer
|
|
for(unsigned int i=0; i<sizeof dummy_buffer; ++i)
|
|
dummy_buffer[i]=0;
|
|
|
|
if (profile.writeRamp)
|
|
{
|
|
//notifico lo stato di start
|
|
notifyStatus(0, -1, STR_WRITE_RAMP);
|
|
elapsedTimer.start();
|
|
|
|
for(unsigned int i=0; i<sizeof dummy_buffer; ++i)
|
|
dummy_buffer[i]=i;
|
|
|
|
//inizio la programmazione
|
|
engine.fpgaProgram(dummy_buffer, sizeof dummy_buffer);
|
|
}
|
|
else
|
|
{
|
|
if (profile.FileToSend=="")
|
|
{
|
|
QCoreApplication::postEvent(this, new MyEvent(evn_error), Qt::HighEventPriority);
|
|
return;
|
|
}
|
|
|
|
//read binary file to write into flash
|
|
//notifico lo stato di start
|
|
QString msg = QString(STR_WRITE_FILE).arg(profile.FileToSend);
|
|
notifyStatus(0, -1, msg);
|
|
elapsedTimer.start();
|
|
|
|
binary_data_t *binary_data = read_file(profile.FileToSend.toStdString().c_str());
|
|
|
|
if (binary_data == NULL )
|
|
{
|
|
msg = QString(STR_ERROR_LOAD_FILE).arg(profile.FileToSend);
|
|
notifyStatus(0, -1, msg);
|
|
QCoreApplication::postEvent(this, new MyEvent(evn_error), Qt::HighEventPriority);
|
|
return;
|
|
}
|
|
|
|
bool ok_fpgaProgram = false;
|
|
|
|
#ifdef DIM_FILE_WRITE
|
|
engine.fpgaProgram(binary_data->data, DIM_FILE_WRITE);
|
|
#else
|
|
ok_fpgaProgram = engine.fpgaProgram(binary_data->data, binary_data->size);
|
|
#endif
|
|
|
|
}
|
|
|
|
for(;;)
|
|
{
|
|
evn=waitEvent(5000);
|
|
if (evn.type==evn_break)
|
|
{
|
|
//se l'evento è break, vuol dire che ha finito di processare
|
|
notifyStatus(0, -1, STR_STOP_PROGRAM);
|
|
break;
|
|
}
|
|
|
|
if (evn.type==evn_timeout)
|
|
{
|
|
QString msg = QString("%1").arg(MyDebug.getLastError());
|
|
notifyStatus(0, -1, msg);
|
|
break;
|
|
}
|
|
//verifico se è stato richiesto un interrupt
|
|
if (isInterruptionRequested())
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
//***********************************************************************
|
|
// Start esare flash
|
|
// Input parameters:
|
|
//
|
|
// Returns:
|
|
//***********************************************************************
|
|
void startErase()
|
|
{
|
|
//setto il profilo di fpga da processare
|
|
//FpgaFlashProfile profile={sectorSize, 0, baseAddress, 1};
|
|
engine.setProfile(profile);
|
|
//notifico lo stato di start
|
|
notifyStatus(s_erase, -1, STR_START_ERASE);
|
|
elapsedTimer.start();
|
|
|
|
//inizio la cancellazione
|
|
engine.fpgaErase(sizeof dummy_buffer);
|
|
|
|
event_data_t evn;
|
|
|
|
for(;;)
|
|
{
|
|
evn=waitEvent(5000);
|
|
if (evn.type==evn_break)
|
|
{
|
|
//se l'evento è break, vuol dire che ha finito di processare
|
|
notifyStatus(s_erase, -1, STR_STOP_ERASE);
|
|
break;
|
|
}
|
|
//verifico se è stato richiesto un interrupt
|
|
if (isInterruptionRequested())
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
//***********************************************************************
|
|
// Start reset flash communication with erase first
|
|
// Input parameters:
|
|
//
|
|
// Returns:
|
|
//***********************************************************************
|
|
void startReset()
|
|
{
|
|
//setto il profilo di fpga da processare
|
|
//FpgaFlashProfile profile={sectorSize, 0, baseAddress, 1};
|
|
engine.setProfile(profile);
|
|
//notifico lo stato di start
|
|
notifyStatus(s_reset, -1, STR_START_RESET);
|
|
elapsedTimer.start();
|
|
|
|
//inizio la cancellazione
|
|
engine.fpgaReset();
|
|
|
|
event_data_t evn;
|
|
|
|
for(;;)
|
|
{
|
|
evn=waitEvent(5000);
|
|
if (evn.type==evn_break)
|
|
{
|
|
//se l'evento è break, vuol dire che ha finito di processare
|
|
notifyStatus(s_reset, -1, STR_STOP_RESET);
|
|
break;
|
|
}
|
|
//verifico se è stato richiesto un interrupt
|
|
if (isInterruptionRequested())
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
//***********************************************************************
|
|
// Start read flash ID
|
|
// Input parameters:
|
|
//
|
|
// Returns:
|
|
//***********************************************************************
|
|
void startReadFlashID()
|
|
{
|
|
//setto il profilo di fpga da processare
|
|
//FpgaFlashProfile profile={sectorSize, 0, baseAddress, 1};
|
|
engine.setProfile(profile);
|
|
//notifico lo stato di start
|
|
notifyStatus(s_read_id, -1, STR_START_READ_FLASH_ID);
|
|
elapsedTimer.start();
|
|
|
|
//inizio la cancellazione
|
|
engine.readFlashID();
|
|
|
|
event_data_t evn;
|
|
|
|
for(;;)
|
|
{
|
|
evn=waitEvent(5000);
|
|
if (evn.type==evn_break)
|
|
{
|
|
//se l'evento è break, vuol dire che ha finito di processare
|
|
notifyStatus(s_read_id, -1, STR_STOP_READ_FLASH_ID);
|
|
break;
|
|
}
|
|
//verifico se è stato richiesto un interrupt
|
|
if (isInterruptionRequested())
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
//***********************************************************************
|
|
// Return spi status
|
|
// Input parameters:
|
|
//
|
|
// Returns:
|
|
//***********************************************************************
|
|
void startStatusSPI()
|
|
{
|
|
//setto il profilo di fpga da processare
|
|
//FpgaFlashProfile profile={sectorSize, 0, baseAddress, 1};
|
|
engine.setProfile(profile);
|
|
//notifico lo stato di start
|
|
notifyStatus(s_status, -1, STR_START_READ_SPI_STATUS);
|
|
elapsedTimer.start();
|
|
|
|
//inizio la cancellazione
|
|
engine.readStatusSPI();
|
|
|
|
event_data_t evn;
|
|
|
|
for(;;)
|
|
{
|
|
evn=waitEvent(5000);
|
|
if (evn.type==evn_break)
|
|
{
|
|
//se l'evento è break, vuol dire che ha finito di processare
|
|
notifyStatus(s_status, -1, STR_STOP_READ_SPI_STATUS);
|
|
break;
|
|
}
|
|
//verifico se è stato richiesto un interrupt
|
|
if (isInterruptionRequested())
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
//***********************************************************************
|
|
// terminate connection
|
|
// Input parameters:
|
|
//
|
|
// Returns:
|
|
//***********************************************************************
|
|
/*void startTerminate()
|
|
{
|
|
//setto il profilo di fpga da processare
|
|
//FpgaFlashProfile profile={sectorSize, 0, baseAddress, 1};
|
|
engine.setProfile(profile);
|
|
//notifico lo stato di start
|
|
notifyStatus(s_end, -1, STR_START_TERMINATE);
|
|
elapsedTimer.start();
|
|
|
|
//inizio la cancellazione
|
|
engine.fpgaTerminate();
|
|
|
|
event_data_t evn;
|
|
|
|
for(;;)
|
|
{
|
|
evn=waitEvent(5000);
|
|
if (evn.type==evn_break)
|
|
{
|
|
//se l'evento è break, vuol dire che ha finito di processare
|
|
notifyStatus(s_end, -1, STR_STOP_TERMINATE);
|
|
break;
|
|
}
|
|
//verifico se è stato richiesto un interrupt
|
|
if (isInterruptionRequested())
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}*/
|
|
|
|
//***********************************************************************
|
|
// main control for all operations
|
|
// Input parameters:
|
|
//
|
|
// Returns:
|
|
//***********************************************************************
|
|
void execute()
|
|
{
|
|
engine.setInterface(this);
|
|
|
|
for(;;)
|
|
{
|
|
try
|
|
{
|
|
//attendo il prossimo evento, verificare il funzionamento
|
|
event_data_t evn=waitEvent(); //5000);
|
|
|
|
//se l'evento da processare non è l'evento di start, allora rimango in stato di idle.
|
|
if (evn.type!=evn_start &&
|
|
evn.type!=evn_erase &&
|
|
evn.type!=evn_reset &&
|
|
evn.type!=evn_readFlashID &&
|
|
evn.type!=evn_readStatusSPI &&
|
|
evn.type!=evn_terminate )
|
|
{
|
|
notifyStatus(0, -1, "idle");
|
|
|
|
if (evn.type==evn_error)
|
|
{
|
|
notifyStatus(0, -1, QString(STR_ENGINE_ERROR).arg(MyDebug.getLastError()));
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
try
|
|
{
|
|
if (evn.type==evn_start)
|
|
{
|
|
startProgram();
|
|
}
|
|
else
|
|
if (evn.type==evn_erase)
|
|
{
|
|
startErase();
|
|
}
|
|
else
|
|
if (evn.type==evn_reset)
|
|
{
|
|
startReset();
|
|
}
|
|
else
|
|
if (evn.type==evn_readFlashID)
|
|
{
|
|
startReadFlashID();
|
|
}
|
|
else
|
|
if (evn.type==evn_readStatusSPI)
|
|
{
|
|
startStatusSPI();
|
|
}
|
|
}
|
|
catch(my_exception& e)
|
|
{
|
|
//notifico eccezione durante la programmazione
|
|
notifyStatus(0, -1, QString(STR_EXCEPTION).arg(e.code));
|
|
}
|
|
}
|
|
catch(my_exception& e)
|
|
{
|
|
notifyStatus(0, -1, QString(STR_EXCEPTION).arg(e.code));
|
|
}
|
|
}
|
|
}
|
|
|
|
void pushEvent(QEvent* evn)
|
|
{
|
|
QApplication::sendEvent(this, evn);
|
|
}
|
|
};
|
|
|
|
FgpaProgrammer::FgpaProgrammer(QObject *parent) : QObject(parent), p_(*new FpgaProgrammerImplementation)
|
|
{
|
|
p_.tFpgaProg=this;
|
|
p_.initialize(0, 1, 0);
|
|
|
|
p_.moveToThread(&p_);
|
|
p_.start();
|
|
|
|
connect(this, &FgpaProgrammer::writeRequest, this, &FgpaProgrammer::onWriteRequest, Qt::QueuedConnection);
|
|
connect(this, &FgpaProgrammer::readRequest, this, &FgpaProgrammer::onReadRequest, Qt::QueuedConnection);
|
|
}
|
|
|
|
//***********************************************************************
|
|
// Set simulate flag for simulate write/read info
|
|
// Input parameters:
|
|
//
|
|
// Returns:
|
|
//***********************************************************************
|
|
void FgpaProgrammer::setSimulate(bool enable)
|
|
{
|
|
p_.simulate=enable;
|
|
}
|
|
|
|
//***********************************************************************
|
|
// Set SRIOMemory flag for select BASE_ADDRESS_IF(0x47000000) or BASE_ADDRESS_MEM(0xA0000000)
|
|
// Input parameters:
|
|
//
|
|
// Returns:
|
|
//***********************************************************************
|
|
void FgpaProgrammer::setSRIOMemory(bool enable)
|
|
{
|
|
p_.SRIOMemory=enable;
|
|
}
|
|
|
|
//***********************************************************************
|
|
// Connect programmer with tftp instance
|
|
// Input parameters:
|
|
//
|
|
// Returns:
|
|
//***********************************************************************
|
|
void FgpaProgrammer::setTftp(FpgaBridgeTftp *tftp)
|
|
{
|
|
if (tftp!=p_.tftp)
|
|
{
|
|
p_.tftp=tftp;
|
|
connect(p_.tftp, &FpgaBridgeTftp::sendTerminated, this, [this]()
|
|
{
|
|
if (p_.engine.getEnableMsgBlk())
|
|
QMessageBox::information(0, STR_TFTP_WRITE_COMPLETED, STR_TFTP_WRITE_COMPLETED);
|
|
this->writeCompleted(true);
|
|
});
|
|
|
|
connect(p_.tftp, &FpgaBridgeTftp::sendError, this, [this]()
|
|
{
|
|
MyDebug.logMsg(type_log_error,
|
|
origin_msg_tftp,
|
|
STR_TFTP_SEND_ERROR);
|
|
QCoreApplication::postEvent(&p_, new MyEvent(evn_break), Qt::HighEventPriority);
|
|
});
|
|
|
|
connect(p_.tftp, &FpgaBridgeTftp::transferError, this, [this](int, const QString&)
|
|
{
|
|
MyDebug.logMsg(type_log_error,
|
|
origin_msg_tftp,
|
|
STR_TFTP_TRANFER_ERROR);
|
|
QCoreApplication::postEvent(&p_, new MyEvent(evn_break), Qt::HighEventPriority);
|
|
});
|
|
connect(p_.tftp, &FpgaBridgeTftp::receiveTerminated, this, [this](int, const QHostAddress)
|
|
{
|
|
MyDebug.logMsg(type_log_info,
|
|
origin_msg_tftp,
|
|
STR_TFTP_RECEIVE_COMPLETED);
|
|
QCoreApplication::postEvent(&p_, new MyEvent(evn_read_completed), Qt::HighEventPriority);
|
|
});
|
|
|
|
}
|
|
}
|
|
|
|
void FgpaProgrammer::setDriver(FpgaProgrammerDriver* driver)
|
|
{
|
|
p_.s.driver=driver;
|
|
}
|
|
|
|
void FgpaProgrammer::start(unsigned long write_size, unsigned int sectorSize, unsigned int baseOffset)
|
|
{
|
|
MyDebug.logMsg(type_log_info,
|
|
origin_msg_generic,
|
|
QString(STR_START_REQUEST_SIZE).arg(write_size));
|
|
|
|
p_.initialize(write_size, sectorSize, baseOffset);
|
|
if (write_size==0)
|
|
QCoreApplication::postEvent(&p_, new MyEvent(evn_break), Qt::HighEventPriority);
|
|
else
|
|
QCoreApplication::postEvent(&p_, new MyEvent(evn_start), Qt::HighEventPriority);
|
|
}
|
|
|
|
void FgpaProgrammer::start(const FpgaFlashProfile& _profile)
|
|
{
|
|
MyDebug.logMsg(type_log_info,
|
|
origin_msg_generic,
|
|
QString(STR_START_REQUEST_FROM).arg(_profile.address_start_area));
|
|
|
|
p_.setProfile(_profile);
|
|
QCoreApplication::postEvent(&p_, new MyEvent(evn_start), Qt::HighEventPriority);
|
|
}
|
|
|
|
void FgpaProgrammer::erase(unsigned long erase_size, unsigned int sectorSize, unsigned int baseOffset)
|
|
{
|
|
MyDebug.logMsg(type_log_info,
|
|
origin_msg_generic,
|
|
QString(STR_START_ERASE_SIZE).arg(erase_size));
|
|
|
|
p_.initialize(erase_size, sectorSize, baseOffset);
|
|
|
|
//TODO: agigungere la parte di codice per chiamare la funzione erase
|
|
QCoreApplication::postEvent(&p_, new MyEvent(evn_erase), Qt::HighEventPriority);
|
|
|
|
}
|
|
|
|
void FgpaProgrammer::reset(const FpgaFlashProfile& _profile)
|
|
{
|
|
MyDebug.logMsg(type_log_info,
|
|
origin_msg_generic,
|
|
STR_START_RESET);
|
|
p_.setProfile(_profile);
|
|
QCoreApplication::postEvent(&p_, new MyEvent(evn_reset), Qt::HighEventPriority);
|
|
}
|
|
|
|
void FgpaProgrammer::readFlashID(const FpgaFlashProfile& _profile)
|
|
{
|
|
MyDebug.logMsg(type_log_info,
|
|
origin_msg_generic,
|
|
STR_START_READ_FLASH_ID);
|
|
p_.setProfile(_profile);
|
|
QCoreApplication::postEvent(&p_, new MyEvent(evn_readFlashID), Qt::HighEventPriority);
|
|
}
|
|
|
|
void FgpaProgrammer::readStatusSPI(const FpgaFlashProfile& _profile)
|
|
{
|
|
MyDebug.logMsg(type_log_info,
|
|
origin_msg_generic,
|
|
STR_START_READ_SPI_STATUS);
|
|
p_.setProfile(_profile);
|
|
QCoreApplication::postEvent(&p_, new MyEvent(evn_readStatusSPI), Qt::HighEventPriority);
|
|
}
|
|
|
|
|
|
void FgpaProgrammer::terminate(const FpgaFlashProfile& _profile)
|
|
{
|
|
MyDebug.logMsg(type_log_info,
|
|
origin_msg_generic,
|
|
STR_START_TERMINATE);
|
|
p_.setProfile(_profile);
|
|
QCoreApplication::postEvent(&p_, new MyEvent(evn_terminate), Qt::HighEventPriority);
|
|
}
|
|
|
|
void FgpaProgrammer::abort(const FpgaFlashProfile& _profile)
|
|
{
|
|
p_.setProfile(_profile);
|
|
}
|
|
|
|
void FgpaProgrammer::writeCompleted(bool ok)
|
|
{
|
|
if (!ok)
|
|
QCoreApplication::postEvent(&p_, new MyEvent(evn_break), Qt::HighEventPriority);
|
|
else
|
|
QCoreApplication::postEvent(&p_, new MyEvent(evn_write_completed), Qt::HighEventPriority);
|
|
}
|
|
|
|
void FgpaProgrammer::readCompleted(bool ok)
|
|
{
|
|
if (!ok)
|
|
QCoreApplication::postEvent(&p_, new MyEvent(evn_break), Qt::HighEventPriority);
|
|
else
|
|
QCoreApplication::postEvent(&p_, new MyEvent(evn_read_completed), Qt::HighEventPriority);
|
|
}
|
|
|
|
#if 0
|
|
void FgpaProgrammer::eraseCompleted(bool ok, const void* data, unsigned int len)
|
|
{
|
|
QCoreApplication::postEvent(&p_, new MyEvent(evn_break), Qt::HighEventPriority);
|
|
}
|
|
#endif
|
|
|
|
void FgpaProgrammer::onWriteRequest(const QString& a, const void* src, unsigned int len)
|
|
{
|
|
p_.tftp->sendMemory((void*)src, len, a);
|
|
}
|
|
|
|
void FgpaProgrammer::onReadRequest(const QString& a, void* dst, unsigned int len)
|
|
{
|
|
p_.tftp->receiveMemory(dst, len, a);
|
|
}
|
|
|