HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorerPlugins Commit - r49:a5ab5a38b3a9

dsu3plugin now support SRCTRLE_0WS and SRCTRLE_1WS....

jeandet -

r49:a5ab5a38b3a9 default

parent child

Context file:

r49:a5ab5a38b3a9

APBUARTPLUGIN/uartpollingthread.cpp +14 -2

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "uartpollingthread.h"
             #include <socexplorerengine.h>
             UARTPollingThread::UARTPollingThread(socexplorerplugin *parent) :
                 QThread((QObject*)parent)
             {
                 this->plugin = parent;
                 uartMutex = new QMutex();
                 uartOpened = false;
                 fifoDebugConfigured = false;
                 p_fifoDebugEnabled = false;
                 this->moveToThread(this);
             }
             UARTPollingThread::~UARTPollingThread()
             {
                 this->requestInterruption();
                 while(isRunning());
             }
             void UARTPollingThread::run()
             {
                 char ch[4097];
                 int timeout =10;
                 SocExplorerEngine::message(this->plugin,"Entering APB UART polling thread",3);
                 while (!this->isInterruptionRequested())
                 {
                     if(p_fifoDebugEnabled)
                     {
                         if(fifoDebugConfigured)
                         {
                             if(this->plugin->baseAddress()!=-1)
                             {
                                 unsigned int status_reg,data;
                                 char ch;
+                                int cnt=0;
                                 QString printdata="";
                                 plugin->parent->Read(&status_reg,1,this->plugin->baseAddress()+APB_UART_STATUS_REG);
-                                while ((status_reg & 4)==0) {
+                                while ((status_reg & 4)==0)
+                                {
                                     plugin->parent->Read(&data,1,this->plugin->baseAddress()+APB_UART_FIFO_DEBUG_REG);
                                     ch = (char)(0xff & data);
                                     printdata+=ch;
                                     plugin->parent->Read(&status_reg,1,this->plugin->baseAddress()+APB_UART_STATUS_REG);
+                                    cnt++;
+                                    if(Q_UNLIKELY(cnt>100))
+                                    {
+                                        break;
                                     }
+                                }
+                                timeout = 100;
                                 if(printdata!="")
                                     emit apbUartTextReceived(printdata);
                             }
                             else
                             {
                                 this->plugin->setBaseAddress(SocExplorerEngine::self()->getEnumDeviceBaseAddress(this->plugin,this->plugin->VID(),this->plugin->PID(),0));
                             }
                         }
                         else
                         {
                             configFifoDebug(true);
                         }
                     }
                     else
                     {
                         int read =0,avail=0;
                         uartMutex->lock();
                         if(uartOpened)
                         {
                             avail = rs232availablebytes(this->uart);
                             SocExplorerEngine::message(this->plugin,QString("%1 available bytes on uart").arg(read),3);
                             if(avail)
                             {
                                 if(avail>=4096)
                                 {
                                     read = rs232read(this->uart,ch,4096);
                                     timeout = 0;
                                 }
                                 else
                                 {
                                     read = rs232read(this->uart,ch,avail);
                                     timeout = 10;
                                 }
                                 SocExplorerEngine::message(this->plugin,QString("Read %1 bytes on uart").arg(read),3);
                                 ch[read]='\0';
                             }
+                            else
+                            {
+                                timeout = 100;
+                            }
                         }
                         uartMutex->unlock();
                         if(read>=1)
                         {
                                 SocExplorerEngine::message(this->plugin,QString("Received %1 char(s) from APBUART").arg(read),3);
                                 emit this->apbUartTextReceived(QString(ch));
                         }
+                    }
                     msleep(timeout);
                 }
             }
             void UARTPollingThread::sendChar(char c)
             {
                 if(p_fifoDebugEnabled)
                 {
                     if(this->plugin->baseAddress()!=-1)
                     {
                         unsigned int i=0x0FF & c;
                         plugin->parent->Write(&i,1,this->plugin->baseAddress()+APB_UART_FIFO_DEBUG_REG);
                     }
                 }
                 else
                 {
                     uartMutex->lock();
                     rs232write(this->uart,&c,1);
                     uartMutex->unlock();
                 }
             }
             bool UARTPollingThread::openUart()
             {
                 uartMutex->lock();
                 if(uartOpened)
                 {
                     closeUart();
                 }
                 SocExplorerEngine::message(this->plugin,"Opening UART "+this->portName,3);
                 this->uart = rs232open((char*)this->portName.toStdString().c_str());
                 if(this->uart!=badPortValue)
                 {
                     SocExplorerEngine::message(this->plugin,QString("Configuring UART, speed =%1").arg(this->uartSpeed),3);
                     rs232setup(this->uart,8,this->uartSpeed,rs232parityNo,rs232OneStop);
                     uartOpened = true;
                 }
                 uartMutex->unlock();
                 return uartOpened;
             }
             void UARTPollingThread::closeUart()
             {
                 uartMutex->lock();
                 rs232close(this->uart);
                 uartOpened = false;
                 uartMutex->unlock();
             }
             void UARTPollingThread::setPortName(QString name)
             {
                 SocExplorerEngine::message(this->plugin,"Changing UART port Name: "+name,3);
                 this->portName = name;
             }
             void UARTPollingThread::setPortSpeedStr(QString speed)
             {
                 SocExplorerEngine::message(this->plugin,"Changing UART speed: "+speed,3);
                 this->uartSpeed = speed.toInt();
             }
             void UARTPollingThread::setPortSpeed(int speed)
             {
                 SocExplorerEngine::message(this->plugin,QString("Changing UART speed: %1").arg(speed),3);
                 this->uartSpeed = speed;
             }
             void UARTPollingThread::setFifoDebugEable(bool enable)
             {
                 if(enable)
                     SocExplorerEngine::message(this->plugin,"Enabling APB UART FIFO debug mode",3);
                 else
                     SocExplorerEngine::message(this->plugin,"Disabling APB UART FIFO debug mode",3);
                 if(uartOpened && enable)
                 {
                     closeUart();
                 }
                 this->fifoDebugConfigured = false;
                 configFifoDebug(enable);
                 this->p_fifoDebugEnabled = enable;
             }
             bool UARTPollingThread::fifoDebugEnabled()
             {
                 return p_fifoDebugEnabled;
             }
             void UARTPollingThread::configFifoDebug(bool enable)
             {
                 SocExplorerEngine::message(this->plugin,"Configuring APB UART in FIFO debug mode",3);
                 if(this->plugin->baseAddress()==-1)
                 {
                     this->plugin->setBaseAddress(SocExplorerEngine::self()->getEnumDeviceBaseAddress(this->plugin,this->plugin->VID(),this->plugin->PID(),0));
                 }
                 if(this->plugin->baseAddress()!=-1)
                 {
                     if(enable)
                     {
                         unsigned int ctrl_reg= 0x843;
                         this->plugin->parent->Write(&ctrl_reg,1,this->plugin->baseAddress()+APB_UART_CONTROL_REG);
                         this->fifoDebugConfigured = true;
                     }
                     else
                     {
                         unsigned int ctrl_reg;
                         /* Firts get Control reg value*/
                         this->plugin->parent->Read(&ctrl_reg,1,this->plugin->baseAddress()+APB_UART_CONTROL_REG);
                         ctrl_reg = ctrl_reg & (~(1<<11));
                         this->plugin->parent->Write(&ctrl_reg,1,this->plugin->baseAddress()+APB_UART_CONTROL_REG);
                         this->fifoDebugConfigured = true;
                     }
                 }
             }

ahbuartplugin/ahbuartplugin.cpp +2 -2

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include <socexplorerengine.h>
             #include "ahbuartplugin.h"
             #include <unistd.h>
             #include <errno.h>
             #include <QApplication>
             #include <QProgressBar>
             #include <stdio.h>
             #include <QThread>
             #include "ahbuartpywrapper.h"
             #include <QCompleter>
             #include <QStringList>
             #include <QLineEdit>
             #include <socexplorerproxy.h>
             ahbuartplugin::ahbuartplugin(QWidget *parent):socexplorerplugin(parent,false)
             {
                 this->port =(rs232port_t)NULL;
                 this->portMutex = new QMutex(QMutex::Recursive);
                 this->UI = new ahbUartPluginUI();
                 this->setWidget((QWidget*)this->UI);
                 QObject::connect(this,SIGNAL(activateSig(bool)),this->UI,SLOT(setConnected(bool)));
                 QObject::connect(this->UI,SIGNAL(connectPortsig(QString,int)),this,SLOT(togglePort(QString,int)));
                 this->pyObject = new ahbuartPywrapper(this);
                 QObject::connect(((ahbuartPywrapper*)this->pyObject),SIGNAL(open(QString,int)),this,SLOT(open(QString,int)));
                 QObject::connect(((ahbuartPywrapper*)this->pyObject),SIGNAL(close()),this,SLOT(close()));
                 QObject::connect(((ahbuartPywrapper*)this->pyObject),SIGNAL(ReadBytes(uint,uint)),this,SLOT(ReadBytes(uint,uint)));
                 QObject::connect(((ahbuartPywrapper*)this->pyObject),SIGNAL(WriteBytes(uint,QList<QVariant>)),this,SLOT(WriteBytes(uint,QList<QVariant>)));
                 QObject::connect(this->UI,SIGNAL(rescanPorts()),this,SLOT(updatePortList()));
                 QObject::connect(this,SIGNAL(addReadBytes(int)),this->UI,SLOT(addReadBytes(int)));
                 QObject::connect(this,SIGNAL(addWritenBytes(int)),this->UI,SLOT(addWritenBytes(int)));
                 this->portListcompleter = NULL;
                 this->scanDone = false;
                 updatePortList();
             }
             ahbuartplugin::~ahbuartplugin()
             {
                 if(this->port!=(rs232port_t)NULL)
                 {
                     rs232close(this->port);
                     this->port = (rs232port_t)NULL;
                 }
                 this->UI->close();
                 this->UI->~ahbUartPluginUI();
             }
             void ahbuartplugin::closeMe()
             {
                 if(this->port!=(rs232port_t)NULL)
                 {
                     rs232close(this->port);
                     this->port = (rs232port_t)NULL;
                 }
                 emit this->closePlugin(this);
             }
             int ahbuartplugin::registermenu(QMainWindow *menuHolder)
             {
                 this->menu = menuHolder->menuBar()->addMenu(tr("&AHB UART"));
                 this->closeAction = this->menu->addAction(tr("Close plugin"));
                 QObject::connect(this->closeAction,SIGNAL(triggered()),this,SLOT(closeMe()));
                 return 1;
             }
             bool ahbuartplugin::checkConnection()
             {
                 QTime timeout;
                 char test[5] ={(char)0x80,(char)0x80,(char)0,(char)0,(char)0};
                 char test2[1024];
                 int writen =0;
                 int read = 0;
                 timeout.start();
                 SocExplorerEngine::message(this,"Check connection",2);
                 QMutexLocker lock(portMutex);
                 while(writen!=5)
                 {
                     writen+=rs232write(this->port,test+writen,5-writen);
                     if(timeout.elapsed()>1000)
                     {
                         SocExplorerEngine::message(this,"Can't write any data on serial port",2);
                         return false;
                     }
                 }
             #ifdef WIN32
                         usleep(1000);
             #endif
                 timeout.restart();
                 int avail = 0;
                 do
                 {
                     avail = rs232availablebytes(this->port);
                     if(timeout.elapsed()>1000)
                     {
                         if(avail)
                             rs232read(this->port,test2,avail);
                         SocExplorerEngine::message(this,"Connection Error",2);
                         return false;
                     }
                 }while(avail<4);
                 read = rs232read(this->port,test2,avail);
                 if(read>0)
                 {
                     SocExplorerEngine::message(this,"Connection Ok",2);
                     return true;
                 }
                 else
                 {
                     SocExplorerEngine::message(this,"Connection Error",2);
                     return false;
                 }
             }
             void ahbuartplugin::connectPort(QString PortName, int baudrate)
             {
                 QTime timeout;
                 SocExplorerEngine::message(this,"Try to connect to port "+PortName,2);
                 timeout.start();
                 QMutexLocker lock(portMutex);
                 if(this->port==(rs232port_t)NULL)
                 {
                     SocExplorerEngine::message(this,"Open port "+PortName,2);
                     this->port=rs232open((char*)PortName.toStdString().c_str());
                 }
                 if(this->port!=badPortValue)
                 {
                     SocExplorerEngine::message(this,"Port opened "+PortName,2);
                     SocExplorerEngine::message(this,"Configure port "+PortName,2);
                     rs232setup(this->port,8,baudrate,rs232parityNo,rs232OneStop);
                     char test[7] ={(char)0x55,(char)0x51,(char)0x80,(char)0x80,(char)0x0,(char)0x0,(char)0x14};
                     char test2[1024];
                     SAFEWRITE(test,1,timeout,2000,return);
                     SAFEWRITE((test+1),1,timeout,2000,return);
                     rs232read(this->port,test2,512);
                     int read = 0;
                     for(int i=0;i<10;i++)
                     {
                         SocExplorerEngine::message(this,"Send test patern :0x55,0x55,0x80,0x80,0x0,0x0,0x14",2);
                         SAFEWRITE(test+2,5,timeout,2000,return);
                         SocExplorerEngine::message(this,"Read Result",2);
                         read=rs232read(this->port,test2+read,16);
                         SocExplorerEngine::message(this,QString("Get ") + QString::number(read) + " bytes",2);
                         if(read>0)
                         {
                             SocExplorerEngine::message(this,"Flush port ",2);
                             while(rs232read(this->port,test2,1)>0);
                             this->Connected = true;
                             SocExplorerEngine::message(this,QString("Connection success on ")+PortName,2);
                             emit this->activate(true);
                             if(this->scanDone==false)
                             {
                                 socexplorerproxy::loadChildSysDriver(this,"AMBA_PLUGIN");
                                 this->scanDone=true;
                             }
                             break;
                         }
                     }
                 }
                 else
                 {
                     SocExplorerEngine::message(this,QString("Port not opened ")+PortName,2);
                     this->port = (rs232port_t)NULL;
                     this->Connected = false;
                     emit this->activateSig(false);
                     return;
                 }
                 if(this->Connected == false)
                 {
                     SocExplorerEngine::message(this,QString("Port not opened ")+PortName,2);
                     rs232close(this->port);
                     this->port = (rs232port_t)NULL;
                     emit this->activateSig(false);
                 }
             }
             bool ahbuartplugin::open(QString PortName,int baudrate)
             {
                 if(this->port!=(rs232port_t)NULL)
                     this->close();
                 this->UI->setconfig(PortName,baudrate);
                 this->connectPort(PortName,baudrate);
                 return (this->port!=(rs232port_t)NULL);
             }
             void ahbuartplugin::close()
             {
                 if(this->port!=(rs232port_t)NULL)
                 {
                     rs232close(this->port);
                     this->port = (rs232port_t)NULL;
                     this->Connected = false;
                     emit this->activateSig(false);
                 }
             }
             void ahbuartplugin::togglePort(QString PortName,int baudrate)
             {
                 if(this->port!=(rs232port_t)NULL)
                 {
                     this->close();
                 }
                 else
                 {
                     this->connectPort(PortName,baudrate);
                 }
             }
             unsigned int ahbuartplugin::Read(unsigned int *Value,unsigned int count,unsigned int address)
             {
                 QTime timeout;
                 timeout.start();
                 unsigned int read=0;
                 unsigned int cnt=count;
-                unsigned int nextUpdateTrig=0,updateStep=512;
+                unsigned int nextUpdateTrig=0,updateStep=1024;
                 SocExplorerEngine::message(this,QString("Read ")+ QString::number(count) + QString(" words @0x")+ QString::number(address,16),2);
                 if((this->port!= badPortValue)||(this->port!=(rs232port_t)NULL))
                 {
                     QMutexLocker lock(portMutex);
                     if(!this->checkConnection())
                     {
                         this->Connected = false;
                         emit this->activateSig(false);
                         this->portMutex->unlock();
                         return 0;
                     }
                     QProgressBar* progress=NULL;
                     if(cnt>128)
                         progress= SocExplorerEngine::getProgressBar("Reading on uart @0x"+QString::number(address,16)+" %v of "+QString::number(count)+" words ",count);
                     char CMD[5];
                     char* result = (char*)malloc(count*4);
                     while(count>32)
                     {
                         CMD[0] = 0x80 |  (32-1);
                         CMD[1] = (char)((address>>24)&0xFF);
                         CMD[2] = (char)((address>>16)&0xFF);
                         CMD[3] = (char)((address>>8)&0xFF);
                         CMD[4] = (char)((address)&0xFF);
                         SAFEWRITE(CMD,5,timeout,1000,return 0);
                         timeout.restart();
                         int avail=0;
                         do{
                             avail=rs232availablebytes(this->port);
                             if(timeout.elapsed()>1000)
                             {
                                 rs232close(this->port);
                                 this->port = (rs232port_t)NULL;
                                 this->Connected = false;
                                 emit this->activateSig(false);
                                 return 0;
                             }
                         }while(avail<(32*4));
                         rs232read(this->port,result+((cnt-count)*4),32*4);
                         count-=32;
                         address+=32*4;
                         if(cnt>128)
                         {
                             if((cnt-count)>=nextUpdateTrig)
                             {
                                 progress->setValue(cnt-count);
                                 qApp->processEvents();
                                 nextUpdateTrig+=updateStep;
                             }
                         }
                     }
                     if(count>0)
                     {
                         CMD[0] = 0x80 |  (count-1);
                         CMD[1] = (char)((address>>24)&0xFF);
                         CMD[2] = (char)((address>>16)&0xFF);
                         CMD[3] = (char)((address>>8)&0xFF);
                         CMD[4] = (char)((address)&0xFF);
                         SAFEWRITE(CMD,5,timeout,1000,return 0);
                         timeout.restart();
                         int avail=0;
                         do{
                             avail=rs232availablebytes(this->port);
                             if(timeout.elapsed()>1000)
                             {
                                 rs232close(this->port);
                                 this->port = (rs232port_t)NULL;
                                 this->Connected = false;
                                 emit this->activateSig(false);
                                 return 0;
                             }
                         }while(avail<(count*4));
                         rs232read(this->port,result+((cnt-count)*4),count*4);
                     }
                     if(cnt>128)
                     {
                         progress->setValue(cnt-count);
                         qApp->processEvents();
                     }
                     for(int i=0;(unsigned int)i<cnt;i++)
                     {
             #if __BYTE_ORDER == __LITTLE_ENDIAN
             //            for(int j =0;j<4;j++)
             //            {
             //                Value[i]= ((unsigned char)(result[i*4+j])) + Value[i]*256;
             //            }
                         Value[i]= socexplorerBswap32(((uint32_t*)result)[i]);
             #elif __BYTE_ORDER == __BIG_ENDIAN
                         Value[i]= ((uint32_t*)result)[i];
             #endif
                     }
                     read = cnt*4;
                     if(cnt>128)
                         SocExplorerEngine::deleteProgressBar(progress);
                     free(result);
                 }
                 emit this->addReadBytes(read);
                 return read/4;
             }
             unsigned int ahbuartplugin::Write(unsigned int *Value,unsigned int count, unsigned int address)
             {
                 QTime timeout;
                 timeout.start();
                 unsigned int writen=0;
-                unsigned int nextUpdateTrig=0,updateStep=512;
+                unsigned int nextUpdateTrig=0,updateStep=1024;
                 SocExplorerEngine::message(this,QString("Write ")+ QString::number(count) + QString(" words @0x")+ QString::number(address,16),2);
                 if((this->port!= badPortValue)||(this->port!=(rs232port_t)NULL))
                 {
                     QMutexLocker lock(portMutex);
                     if(!this->checkConnection())
                     {
                         emit this->activateSig(false);
                         this->Connected = false;
                         this->portMutex->unlock();
                         return 0;
                     }
                     QProgressBar* progress = NULL;
                     if(count>128)
                         progress = SocExplorerEngine::getProgressBar("Writing on uart @0x"+QString::number(address,16)+" %v of "+QString::number(count)+" words ",count);
                     int offset = 0;
                     char* CMD= (char*)malloc((32*4)+5);
                     writen=0;
                     while(count>32)
                     {
                         CMD[0] = 0xC0 |  (32-1);
                         CMD[1] = (char)(((unsigned int)address>>24)&0xFF);
                         CMD[2] = (char)(((unsigned int)address>>16)&0xFF);
                         CMD[3] = (char)(((unsigned int)address>>8)&0xFF);
                         CMD[4] = (char)(((unsigned int)address)&0xFF);
                         for(int i=0;i<32;i++)
                         {
             #if __BYTE_ORDER == __LITTLE_ENDIAN
                             CMD[(i*4)+5] = (char)(((unsigned int)Value[i+offset]>>24)&0xFF);
                             CMD[(i*4)+6] = (char)(((unsigned int)Value[i+offset]>>16)&0xFF);
                             CMD[(i*4)+7] = (char)(((unsigned int)Value[i+offset]>>8)&0xFF);
                             CMD[(i*4)+8] = (char)(((unsigned int)Value[i+offset])&0xFF);
             #elif __BYTE_ORDER == __BIG_ENDIAN
                             CMD[(i*4)+5] = (char)(((unsigned int)Value[i+offset])&0xFF);
                             CMD[(i*4)+6] = (char)(((unsigned int)Value[i+offset]>>8)&0xFF);
                             CMD[(i*4)+7] = (char)(((unsigned int)Value[i+offset]>>16)&0xFF);
                             CMD[(i*4)+8] = (char)(((unsigned int)Value[i+offset]>>24)&0xFF);
             #endif
                         }
                         SAFEWRITE(CMD,((32*4)+5),timeout,1000,return 0);
                         writen+=32;
                         count-=32;
                         offset+=32;
                         address+=32*4;
                         if(offset>=nextUpdateTrig && progress!=NULL)
                         {
                             progress->setValue(offset);
                             qApp->processEvents();
                             nextUpdateTrig +=updateStep;
                         }
                     }
                     if(count>0)
                     {
                         CMD[0] = 0xC0 |  (count-1);
                         CMD[1] = (char)(((unsigned int)address>>24)&0xFF);
                         CMD[2] = (char)(((unsigned int)address>>16)&0xFF);
                         CMD[3] = (char)(((unsigned int)address>>8)&0xFF);
                         CMD[4] = (char)(((unsigned int)address)&0xFF);
                         for(int i=0;(unsigned int) i<(count);i++)
                         {
             #if __BYTE_ORDER == __LITTLE_ENDIAN
                             CMD[(i*4)+5] = (char)(((unsigned int)Value[i+offset]>>24)&0xFF);
                             CMD[(i*4)+6] = (char)(((unsigned int)Value[i+offset]>>16)&0xFF);
                             CMD[(i*4)+7] = (char)(((unsigned int)Value[i+offset]>>8)&0xFF);
                             CMD[(i*4)+8] = (char)(((unsigned int)Value[i+offset])&0xFF);
             #elif __BYTE_ORDER == __BIG_ENDIAN
                             CMD[(i*4)+5] = (char)(((unsigned int)Value[i+offset])&0xFF);
                             CMD[(i*4)+6] = (char)(((unsigned int)Value[i+offset]>>8)&0xFF);
                             CMD[(i*4)+7] = (char)(((unsigned int)Value[i+offset]>>16)&0xFF);
                             CMD[(i*4)+8] = (char)(((unsigned int)Value[i+offset]>>24)&0xFF);
             #endif
                         }
                         SAFEWRITE(CMD,((count*4)+5),timeout,1000,return 0);
                         writen+=count;
                     }
                     if(progress!=NULL)
                     {
                         progress->setValue(writen);
                         qApp->processEvents();
                         SocExplorerEngine::deleteProgressBar(progress);
                     }
                     free(CMD);
                     emit this->addWritenBytes(writen*4);
                     return writen;
                 }
                 return 0;
             }
             void ahbuartplugin::updatePortList()
             {
                 if(this->portListcompleter==(QCompleter*)NULL)
                 {
                     this->portListcompleter=new QCompleter(this);
                     this->portListcompleter->setCaseSensitivity(Qt::CaseInsensitive);
                     this->portListcompleterModel = new QStringListModel(this);
                     this->portListcompleter->setModel(this->portListcompleterModel);
                     this->UI->setCompleter(this->portListcompleter);
                 }
                 rs232portslist_t* portlist = rs232getportlist();
                 rs232portslist_t* portlistenum = portlist;
                 QStringList wordList;
                 while(portlistenum!=NULL)
                 {
                     wordList << portlistenum->name;
                     portlistenum = portlistenum->next;
                 }
                 rs232deleteportlist(portlist);
                 this->portListcompleterModel->setStringList(wordList);
             }
             QVariantList ahbuartplugin::ReadBytes(unsigned int address, unsigned int count)
             {
                 unsigned int data[(count/4)+1];
                 QVariantList result;
                 this->Read(data,(count/4)+1,address);
                 for(unsigned int i = 0;i<count/4;i++)
                 {
                     result.append(QVariant((int)(0x0FF&(data[i]>>24))));
                     result.append(QVariant((int)(0x0FF&(data[i]>>16))));
                     result.append(QVariant((int)(0x0FF&(data[i]>>8))));
                     result.append(QVariant((int)(0x0FF&(data[i]))));
                 }
                 for(int i=0;i<(count%4);i++)
                 {
                     result.append(QVariant((int)(0x0FF&(data[count/4]>>((3-i)*8)))));
                 }
                 return result;
             }
             void ahbuartplugin::WriteBytes(unsigned int address, QList<QVariant> dataList)
             {
                 unsigned int data[dataList.count()/4];
                 for(int i = 0;i<(dataList.count()/4);i++)
                 {
                     data[i] = 0x0FF & ((unsigned int)dataList.at(4*i).toUInt());
                     data[i] =  (data[i]<<8) + (0x0FF & ((unsigned int)dataList.at((4*i)+1).toUInt()));
                     data[i] =  (data[i]<<8) + (0x0FF & ((unsigned int)dataList.at((4*i)+2).toUInt()));
                     data[i] =  (data[i]<<8) + (0x0FF & ((unsigned int)dataList.at((4*i)+3).toUInt()));
                 }
                 this->Write(data,dataList.count()/4,address);
             }

ahbuartplugin/ahbuartpluginui.cpp +14 -3

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "ahbuartpluginui.h"
             #include "ui_ahbuartpluginui.h"
             ahbUartPluginUI::ahbUartPluginUI(QWidget *parent) :
                 QWidget(parent),
                 ui(new Ui::ahbUartPluginUI)
             {
                 ui->setupUi(this);
                 connect(ui->OpenPort,SIGNAL(clicked()),this,SLOT(connectPort()));
-                connect(ui->PortspeedSlider,SIGNAL(valueChanged(int)),ui->baurateLCD,SLOT(display(int)));
+            //    connect(ui->PortspeedSlider,SIGNAL(valueChanged(int)),ui->baurateLCD,SLOT(display(int)));
                 connect(ui->rescanPorts,SIGNAL(clicked()),this,SIGNAL(rescanPorts()));
+                QStringList allowedSpeeds;
+                allowedSpeeds<<"0"<<"50"<<"75"<<"110"<<"134"<<"150"<<
+                            "200"<<"300"<<"600"<<"1200"<<"1800"<<"2400"<<
+                            "4800"<<"9600"<<"19200"<<"38400"<<"57600"<<
+                            "115200"<<"230400"<<"460800"<<"500000"<<"576000"<<
+                            "921600"<<"1000000"<<"1152000"<<"1500000"<<"2000000"<<
+                            "2500000"<<"3000000"<<"3500000"<<"4000000";
+                portSpeedCompleter = new QCompleter(allowedSpeeds);
+                this->ui->portSpeed->setCompleter(portSpeedCompleter);
                 this->writtenBytes = 0;
                 this->readBytes = 0;
             }
             void ahbUartPluginUI::connectPort()
             {
-                emit this->connectPortsig(ui->PortName->text(),ui->PortspeedSlider->value());
+                int baudrate = ui->portSpeed->text().toInt();
+                emit this->connectPortsig(ui->PortName->text(),baudrate);
             }
             void ahbUartPluginUI::setConnected(bool connected)
             {
                 if(connected == true)
                 {
                     ui->OpenPort->setText(tr("Close port"));
                 }
                 else
                     ui->OpenPort->setText(tr("Open port"));
             }
             ahbUartPluginUI::~ahbUartPluginUI()
             {
                 delete ui;
             }
             void ahbUartPluginUI::setconfig(QString PortName, int baudrate)
             {
                 this->ui->PortName->setText(PortName);
-                this->ui->PortspeedSlider->setValue(baudrate);
+                this->ui->portSpeed->setText(QString::number(baudrate));
             }
             void ahbUartPluginUI::addWritenBytes(int count)
             {
                 this->writtenBytes+=count;
                 this->ui->WrBytesLCD->display(this->writtenBytes);
             }
             void ahbUartPluginUI::addReadBytes(int count)
             {
                 this->readBytes+=count;
                 this->ui->RdBytesLCD->display(this->readBytes);
             }
             void ahbUartPluginUI::setCompleter(QCompleter *completer)
             {
                 this->ui->PortName->setCompleter(completer);
             }
             void ahbUartPluginUI::closeEvent(QCloseEvent *event)
             {
                 event->accept();
             }

ahbuartplugin/ahbuartpluginui.h +1 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef AHBUARTPLUGINUI_H
             #define AHBUARTPLUGINUI_H
             #include <QWidget>
             #include <QFile>
             #include <QTextStream>
             #include <QFileDialog>
             #include <QDir>
             #include <QCloseEvent>
             #include <QCompleter>
             namespace Ui {
                 class ahbUartPluginUI;
             }
             class ahbUartPluginUI : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit ahbUartPluginUI(QWidget *parent = 0);
                 ~ahbUartPluginUI();
                 void closeEvent(QCloseEvent *event);
                 void setCompleter(QCompleter* completer);
             public slots:
                 void setConnected(bool connected);
                 void connectPort();
                 void setconfig(QString PortName,int baudrate);
                 void addWritenBytes(int count);
                 void addReadBytes(int count);
             signals:
                 void connectPortsig(QString PortName,int baudrate);
                 void setLogFileName(QString FileName);
                 void rescanPorts();
             private:
                 int writtenBytes;
                 int readBytes;
                 Ui::ahbUartPluginUI *ui;
+                QCompleter* portSpeedCompleter;
             };
             #endif // AHBUARTPLUGINUI_H

ahbuartplugin/ahbuartpluginui.ui +12 -37

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>ahbUartPluginUI</class>
              <widget class="QWidget" name="ahbUartPluginUI">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
-                <width>768</width>
+                <width>884</width>
-                <height>196</height>
+                <height>221</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>Form</string>
               </property>
               <layout class="QGridLayout" name="gridLayout_2">
                <item row="4" column="0" colspan="3">
                 <widget class="QGroupBox" name="Statistiques">
                  <property name="title">
                   <string>Statistics</string>
                  </property>
                  <layout class="QGridLayout" name="gridLayout">
                   <item row="0" column="2">
                    <widget class="QLCDNumber" name="WrBytesLCD">
                     <property name="digitCount">
                      <number>8</number>
                     </property>
                     <property name="segmentStyle">
                      <enum>QLCDNumber::Flat</enum>
                     </property>
                    </widget>
                   </item>
                   <item row="1" column="2">
                    <widget class="QLCDNumber" name="RdBytesLCD">
                     <property name="digitCount">
                      <number>8</number>
                     </property>
                     <property name="segmentStyle">
                      <enum>QLCDNumber::Flat</enum>
                     </property>
                    </widget>
                   </item>
                   <item row="1" column="0">
                    <widget class="QLabel" name="RdBytesLbl">
                     <property name="text">
                      <string>Read Bytes</string>
                     </property>
                    </widget>
                   </item>
                   <item row="0" column="0">
                    <widget class="QLabel" name="WrBytesLbl">
                     <property name="text">
                      <string>Writen Bytes</string>
                     </property>
                    </widget>
                   </item>
                  </layout>
                 </widget>
                </item>
-               <item row="1" column="1">
-                <widget class="QSlider" name="PortspeedSlider">
-                 <property name="maximum">
-                  <number>3000000</number>
-                 </property>
-                 <property name="singleStep">
-                  <number>9600</number>
-                 </property>
-                 <property name="pageStep">
-                  <number>1</number>
-                 </property>
-                 <property name="value">
-                  <number>921600</number>
-                 </property>
-                 <property name="orientation">
-                  <enum>Qt::Horizontal</enum>
-                 </property>
-                </widget>
-               </item>
                <item row="1" column="0">
                 <widget class="QLabel" name="label_2">
                  <property name="text">
                   <string>Port Speed</string>
                  </property>
                 </widget>
                </item>
                <item row="0" column="0">
                 <widget class="QLabel" name="label">
                  <property name="text">
                   <string>Port Name</string>
                  </property>
                 </widget>
                </item>
                <item row="0" column="2">
                 <widget class="QPushButton" name="rescanPorts">
                  <property name="text">
                   <string>SCAN</string>
                  </property>
                 </widget>
                </item>
                <item row="0" column="1">
                 <widget class="QLineEdit" name="PortName"/>
                </item>
-               <item row="1" column="2">
-                <widget class="QLCDNumber" name="baurateLCD">
-                 <property name="font">
-                  <font>
-                   <weight>75</weight>
-                   <bold>true</bold>
-                  </font>
-                 </property>
-                 <property name="digitCount">
-                  <number>7</number>
-                 </property>
-                 <property name="segmentStyle">
-                  <enum>QLCDNumber::Flat</enum>
-                 </property>
-                </widget>
-               </item>
                <item row="3" column="0">
                 <spacer name="verticalSpacer">
                  <property name="orientation">
                   <enum>Qt::Vertical</enum>
                  </property>
                  <property name="sizeHint" stdset="0">
                   <size>
                    <width>20</width>
                    <height>40</height>
                   </size>
                  </property>
                 </spacer>
                </item>
                <item row="3" column="1" colspan="2">
                 <widget class="QPushButton" name="OpenPort">
                  <property name="text">
                   <string>Open Port</string>
                  </property>
                 </widget>
                </item>
+               <item row="1" column="1" colspan="2">
+                <widget class="QLineEdit" name="portSpeed">
+                 <property name="inputMask">
+                  <string>00000000</string>
+                 </property>
+                 <property name="text">
+                  <string>115200</string>
+                 </property>
+                </widget>
+               </item>
               </layout>
              </widget>
              <resources/>
              <connections/>
             </ui>

dsu3plugin/dsu3plugin.cpp +17 -7

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "dsu3plugin.h"
             #include <QFileDialog>
             #include <QDir>
             #include "dsu3pluginpywrapper.h"
             #include <socexplorerengine.h>
             struct acceptedMemctrlr_str
             {
                 int vid;
                 int pid;
                 const char* name;
             };
             const struct acceptedMemctrlr_str acceptedMemctrlr[]=
             {
             {0x04,0x0f,"MCTRL"},
             {0x01,0x51,"FTSRCTRL"},
             {0x20,0x01,"SRCTRLE_0WS" },
             {0x20,0x02,"SRCTRLE_1WS" }
             };
             #define acceptedMemctrlrCnt 4
             dsu3plugin::dsu3plugin(QWidget *parent):socexplorerplugin(parent,false)
             {
                 this->UI = new dsu3pluginui();
                 this->setWidget((QWidget*)this->UI);
                 this->elfparserInst = new elfparser();
                 this->pyObject = new dsu3pluginPywrapper(this);
                 QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(openFile(QString)),this,SLOT(openFile(QString)));
                 QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(loadFile()),this,SLOT(flashTarget()));
                 QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(run()),this,SLOT(run()));
                 QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(stop()),this,SLOT(stop()));
                 QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(cacheEnable()),this,SLOT(cacheEnable()));
                 QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(cacheDisable()),this,SLOT(cacheDisable()));
                 QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(setCacheEnable(bool)),this,SLOT(setCacheEnable(bool)));
                 connect(this->UI,SIGNAL(openFile()),this,SLOT(openFile()));
                 connect(this->UI,SIGNAL(flashTarget()),this,SLOT(flashTarget()));
                 connect(this->UI,SIGNAL(run()),this,SLOT(toggleRun()));
                 connect(this,SIGNAL(updateInfo(elfparser*)),this->UI,SIGNAL(updateInfo(elfparser*)));
                 this->running = false;
             }
             dsu3plugin::~dsu3plugin()
             {
             }
             void dsu3plugin::openFile()
             {
                 QString filename = QFileDialog::getOpenFileName(this,tr("Open elf File"), QDir::homePath(), tr("Elf Files (*)"));
                 if(filename!="")
                 {
                     this->openFile(filename);
                 }
             }
             void dsu3plugin::openFile(QString fileName)
             {
                 this->elfparserInst->setFilename(fileName);
                 emit this->updateInfo(this->elfparserInst);
             }
             bool dsu3plugin::configureTarget()
             {
+                int detectedMctrlr=-1;
                 if(parent==NULL)
                     return false;
                 unsigned int DSUBASEADDRESS = SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,0x01 , 0x004,0);
                 if(DSUBASEADDRESS == (unsigned int)-1)
                     DSUBASEADDRESS = 0x90000000;
                 unsigned int MCTRLBASEADDRESS =-1;
                 for(int i=0; i<acceptedMemctrlrCnt;i++)
                 {
                     MCTRLBASEADDRESS = SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,acceptedMemctrlr[i].vid , acceptedMemctrlr[i].pid,0);
                     if(MCTRLBASEADDRESS != (unsigned int)-1)
                     {
                         SocExplorerEngine::message(this,QString("Found %1 @%2").arg(acceptedMemctrlr[i].name).arg(MCTRLBASEADDRESS,8,16),1);
+                        detectedMctrlr=i;
                         break;
                     }
                 }
                 if(MCTRLBASEADDRESS == (unsigned int)-1)
                 {
                     SocExplorerEngine::message(this,"Can't any compatible memory controller",1);
                     return false;
                 }
                 //Force a debug break
                 WriteRegs(uIntlist()<<0x0000002f,(unsigned int)DSUBASEADDRESS);
                 WriteRegs(uIntlist()<<0x0000ffff,(unsigned int)DSUBASEADDRESS+0x20);
                 //Clear time tag counter
                 WriteRegs(uIntlist()<<0,(unsigned int)DSUBASEADDRESS+0x8);
                 //Clear ASR registers
                 WriteRegs(uIntlist()<<0<<0<<0,(unsigned int)DSUBASEADDRESS+0x400040);
                 WriteRegs(uIntlist()<<0x2,(unsigned int)DSUBASEADDRESS+0x400024);
                 WriteRegs(uIntlist()<<0<<0<<0<<0<<0<<0<<0<<0,(unsigned int)DSUBASEADDRESS+0x400060);
                 WriteRegs(uIntlist()<<0,(unsigned int)DSUBASEADDRESS+0x48);
                 WriteRegs(uIntlist()<<0,(unsigned int)DSUBASEADDRESS+0x000004C);
                 WriteRegs(uIntlist()<<0,(unsigned int)DSUBASEADDRESS+0x400040);
+            //    {0x04,0x0f,"MCTRL"},
+            //    {0x01,0x51,"FTSRCTRL"},
+            //    {0x20,0x01,"SRCTRLE_0WS" },
+            //    {0x20,0x02,"SRCTRLE_1WS" }
+                if(QString(acceptedMemctrlr[detectedMctrlr].name)=="MCTRL" || QString(acceptedMemctrlr[detectedMctrlr].name)=="FTSRCTRL" )
+                {
                     WriteRegs(uIntlist()<<0x2FF<<0xE60<<0,(unsigned int)MCTRLBASEADDRESS);
+                }
+                if(QString(acceptedMemctrlr[detectedMctrlr].name)=="SRCTRLE_0WS" || QString(acceptedMemctrlr[detectedMctrlr].name)=="SRCTRLE_1WS" )
+                {
+                    //let's perform a mem Wash
+                    unsigned int val = ReadReg(MCTRLBASEADDRESS);
+                    val |=1<<31;
+                    WriteRegs(uIntlist()<<val,(unsigned int)MCTRLBASEADDRESS);
+                    usleep(1000*1000);
+                }
                 WriteRegs(uIntlist()<<0<<0<<0<<0,(unsigned int)DSUBASEADDRESS+0x400060);
                 WriteRegs(uIntlist()<<0x0000FFFF,(unsigned int)DSUBASEADDRESS+0x24);
-                unsigned int buff=0;
-                //    for(int i=0;i<1567;i++)
-                //    {
-                //        parent->Write(&buff,(unsigned int)1,DSUBASEADDRESS+0x300000+(4*i));
-                //    }
                 memSet(DSUBASEADDRESS+0x300000,0,1567);
                 WriteRegs(uIntlist()<<0<<0xF30000E0<<0x00000002<<0x40000000<<0x40000000<<0x40000004<<0x1000000,(unsigned int)DSUBASEADDRESS+0x400000);
                 WriteRegs(uIntlist()<<0<<0<<0<<0<<0<<0<<0x403ffff0<<0<<0<<0<<0<<0<<0<<0<<0<<0<<0<<0<<0<<0<<0<<0<<0<<0,(unsigned int)DSUBASEADDRESS+0x300020);
                 WriteRegs(uIntlist()<<0x000002EF,(unsigned int)DSUBASEADDRESS);
                 //Disable interrupts
                 unsigned int APBIRQCTRLRBASEADD = (unsigned int)SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,1,0x0d,0);
                 if(APBIRQCTRLRBASEADD == (unsigned int)-1)
                     return false;
                 WriteRegs(uIntlist()<<0x00000000,APBIRQCTRLRBASEADD+0x040);
                 WriteRegs(uIntlist()<<0xFFFE0000,APBIRQCTRLRBASEADD+0x080);
                 WriteRegs(uIntlist()<<0<<0,APBIRQCTRLRBASEADD);
                 //Set up timer
                 unsigned int APBTIMERBASEADD = (unsigned int)SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,1,0x11,0);
                 if(APBTIMERBASEADD == (unsigned int)-1)
                     return false;
                 WriteRegs(uIntlist()<<0xffffffff,APBTIMERBASEADD+0x014);
                 WriteRegs(uIntlist()<<0x00000018,APBTIMERBASEADD+0x04);
                 WriteRegs(uIntlist()<<0x00000007,APBTIMERBASEADD+0x018);
                 return true;
             }
             bool dsu3plugin::cacheDisable()
             {
                 return setCacheEnable(false);
             }
             bool dsu3plugin::cacheEnable()
             {
                 return setCacheEnable(true);
             }
             bool dsu3plugin::setCacheEnable(bool enabled)
             {
                 if(parent==NULL)
                     return false;
                 unsigned int DSUBASEADDRESS = SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,0x01 , 0x004,0);
                 if(DSUBASEADDRESS == (unsigned int)-1)
                     DSUBASEADDRESS = 0x90000000;
                 WriteRegs(uIntlist()<<2,DSUBASEADDRESS+0x400024);
                 unsigned int reg = ReadReg(DSUBASEADDRESS+0x700000);
                 if(enabled)
                 {
                     WriteRegs(uIntlist()<<(0x0001000F|reg),DSUBASEADDRESS+0x700000);
                     //flushes cache.
                     WriteRegs(uIntlist()<<(0x0061000F|reg),DSUBASEADDRESS+0x700000);
                 }
                 else
                 {
                     WriteRegs(uIntlist()<<((!0x0001000F)&reg),DSUBASEADDRESS+0x700000);
                     WriteRegs(uIntlist()<<(0x00600000|reg),DSUBASEADDRESS+0x700000);
                 }
                 return true;
             }
             bool dsu3plugin::flashTarget()
             {
                 stop();
                 cacheDisable();
                 configureTarget();
                 /*Write .text*/
                 this->writeSection(".text");
                 /*Write .data*/
                 this->writeSection(".data");
                 return true;
             }
             void dsu3plugin::run()
             {
                 unsigned int DSUBASEADDRESS = SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,0x01 , 0x004,0);
                 if(DSUBASEADDRESS == (unsigned int)-1)
                     DSUBASEADDRESS = 0x90000000;
                 WriteRegs(uIntlist()<<0,DSUBASEADDRESS+0x020);
                 this->running = true;
                 this->UI->setRunning(true);
             }
             void dsu3plugin::stop()
             {
                 unsigned int DSUBASEADDRESS = SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,0x01 , 0x004,0);
                 if(DSUBASEADDRESS == (unsigned int)-1)
                     DSUBASEADDRESS = 0x90000000;
                 WriteRegs(uIntlist()<<0xFFFF,DSUBASEADDRESS+0x020);
                 this->running = false;
                 this->UI->setRunning(false);
             }
             void dsu3plugin::toggleRun()
             {
                 if(this->running)
                     this->stop();
                 else
                     this->run();
             }
             void dsu3plugin::WriteRegs(uIntlist Values, unsigned int address)
             {
                 unsigned int* buff;
                 buff = (unsigned int*)malloc(Values.count()*sizeof(unsigned int));
                 for(int i=0;i<Values.count();i++)
                 {
                     buff[i]=Values.at(i);
                 }
                 parent->Write(buff,(unsigned int)Values.count(),address);
                 free(buff);
             }
             unsigned int dsu3plugin::ReadReg(unsigned int address)
             {
                 unsigned int buff;
                 parent->Read(&buff,1,address);
                 return buff;
             }
             void dsu3plugin::writeSection(int index)
             {
                 char* buffch=NULL;
                 unsigned int* buff;
                 int size = this->elfparserInst->getSectionDatasz(index);
                 int sizeInt = size/4;
                 if(parent==NULL)
                     return;
                 this->elfparserInst->getSectionData(index,&buffch);
                 buff = (unsigned int*)malloc(((size/4)+1)*sizeof(unsigned int));
                 for(int i=0;i<sizeInt;i++)
                 {
                     buff[i] = 0x0FF & ((unsigned int)buffch[4*i]);
                     buff[i] =  (buff[i]<<8) + (0x0FF & ((unsigned int)buffch[(4*i)+1]));
                     buff[i] =  (buff[i]<<8) + (0x0FF & ((unsigned int)buffch[(4*i)+2]));
                     buff[i] =  (buff[i]<<8) + (0x0FF & ((unsigned int)buffch[(4*i)+3]));
                 }
                 if(size%4)
                 {
                     buff[sizeInt]=0;
                     for(int i=(size%4);i>0;i--)
                     {
                         buff[sizeInt] =  (buff[sizeInt]<<8) + (0x0FF & ((unsigned int)buffch[size-i]));
                     }
                     sizeInt++;
                 }
                 parent->Write(buff,(unsigned int)sizeInt,(unsigned int)this->elfparserInst->getSectionPaddr(index));
                 free(buff);
             }
             void dsu3plugin::writeSection(const QString &name)
             {
                 for(int i=0;i<this->elfparserInst->getSectioncount();i++)
                 {
                     if(!this->elfparserInst->getSectionName(i).compare(name))
                     {
                         printf("about to write section %s @ 0x%x size = %d\n",elfparserInst->getSectionName(i).toStdString().c_str(),elfparserInst->getSectionPaddr(i),elfparserInst->getSectionMemsz(i));
                         writeSection(i);
                     }
                 }
             }
             unsigned int dsu3plugin::Write(unsigned int *Value,unsigned int count,unsigned  int address)
             {
                 if(parent!=NULL)
                     return parent->Write(Value,count,address);
                 return 0;
             }
             bool dsu3plugin::memSet(unsigned int address,int value, unsigned int count)
             {
                 unsigned int* buffer = (unsigned int*)malloc(count*sizeof(unsigned int));
                 if(buffer!=NULL)
                 {
                     memset((void*)buffer,value,count*sizeof(unsigned int));
                     parent->Write(buffer,count,address);
                     free(buffer );
                     return true;
                 }
                 return false;
             }
             unsigned int dsu3plugin::Read(unsigned int *Value,unsigned int count, unsigned int address)
             {
                 if(parent!=NULL)
                     return parent->Read(Value,count,address);
                 return 0;
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages