HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorerPlugins Commit - r44:0935da2bcc7f

Added cache enable/disable on dsu3plugin....

jeandet -

r44:0935da2bcc7f default

parent child

Context file:

r44:0935da2bcc7f

APBUARTPLUGIN/APBUARTPLUGIN.pro +6 -6

             #
             # Project created by QtCreator 2011-09-20T08:15:30
             #
             #-------------------------------------------------
             CONFIG += socexplorerplugin
             win32:CONFIG += dll
             win32:CONFIG -= static
-            CONFIG(debug, debug|release) {
+            #CONFIG(debug, debug|release) {
-              DEBUG_EXT = _d
+            #  DEBUG_EXT = _d
-            } else {
+            #} else {
-              DEBUG_EXT =
+            #  DEBUG_EXT =
+            #}
-            TARGET = ApbUartPlugin$${DEBUG_EXT}
+            TARGET = ApbUartPlugin  #$${DEBUG_EXT}
             DEFINES += PLUGIN=ApbUartPlugin
             DEFINES += PLUGINHEADER="\"\\\"APBUARTPLUGIN.h"\\\"\"
             DEFINES += driver_Name="\"\\\"APB_UART_PLUGIN"\\\"\"
             DEFINES += driver_Author="\"\\\"Alexis Jeandet alexis.jeandet@member.fsf.org"\\\"\"
             DEFINES += driver_Version="\"\\\"0.0.1"\\\"\"
             DEFINES += driver_Description="\"\\\"This plugin provides a terminal widget connected to Gaisler\'s APBUART with or without loop-back mode."\\\"\"
             DEFINES += driver_can_be_root=0
             DEFINES += driver_can_be_child=1
             DEFINES += driver_VID=1
             DEFINES += driver_PID=0x0c
             INCLUDEPATH += \
                     $${PWD}
             HEADERS += \
                 APBUARTPLUGIN.h \
                 apbuartterminal.h \
                 apbuart_plugin_ui.h \
                 uartpollingthread.h \
                 apbuartpywrapper.h
             SOURCES += \
                 APBUARTPLUGIN.cpp \
                 apbuartterminal.cpp \
                 apbuart_plugin_ui.cpp \
                 uartpollingthread.cpp \
                 apbuartpywrapper.cpp
             FORMS += \
                 apbuart_plugin_ui.ui

ahbuartplugin/ahbuartplugin.pro +6 -6

             #
             # Project created by QtCreator 2011-09-20T08:15:30
             #
             #-------------------------------------------------
             CONFIG += socexplorerplugin
             TEMPLATE = lib
             CONFIG += dll
             CONFIG -= static
-            CONFIG(debug, debug|release) {
+            #CONFIG(debug, debug|release) {
-              DEBUG_EXT = _d
+            #  DEBUG_EXT = _d
-            } else {
+            #} else {
-              DEBUG_EXT =
+            #  DEBUG_EXT =
+            #}
-            TARGET = ahbuartplugin$${DEBUG_EXT}
+            TARGET = ahbuartplugin #$${DEBUG_EXT}
             DEFINES += PLUGIN=ahbuartplugin
             DEFINES += PLUGINHEADER="\"\\\"ahbuartplugin.h"\\\"\"
             DEFINES += driver_Name="\"\\\"AHBUARTplugin"\\\"\"
             DEFINES += driver_Author="\"\\\"Alexis Jeandet alexis.jeandet@lpp.polytechnique.fr"\\\"\"
             DEFINES += driver_Version="\"\\\"1.3.2"\\\"\"
             DEFINES += driver_Description="\"\\\"Gaisler's AHBUART driver, gives master access to AHB bus."\\\"\"
             DEFINES += driver_can_be_root=1
             DEFINES += driver_can_be_child=0
             DEFINES += driver_VID=0
             DEFINES += driver_PID=0
             INCLUDEPATH += \
                     $${PWD}
             HEADERS += \
                 ahbuartplugin.h \
                 ahbuartpluginui.h \
                 ahbuartpywrapper.h \
                 ahbuartpywrapper.h
             SOURCES += \
                 ahbuartplugin.cpp \
                 ahbuartpluginui.cpp \
                 ahbuartpywrapper.cpp
             FORMS += \
                 ahbuartpluginui.ui

ambaplugin/ambaplugin.pro +6 -6

             #
             # Project created by QtCreator 2011-09-20T08:15:30
             #
             #-------------------------------------------------
             CONFIG += socexplorerplugin
             CONFIG += dll
             CONFIG -= static
-            CONFIG(debug, debug|release) {
+            #CONFIG(debug, debug|release) {
-              DEBUG_EXT = _d
+            #  DEBUG_EXT = _d
-            } else {
+            #} else {
-              DEBUG_EXT =
+            #  DEBUG_EXT =
+            #}
-            TARGET = ambaplugin$${DEBUG_EXT}
+            TARGET = ambaplugin #$${DEBUG_EXT}
             DEFINES += PLUGIN=ambaplugin
             DEFINES += PLUGINHEADER="\"\\\"ambaplugin.h"\\\"\"
             DEFINES += driver_Name="\"\\\"AMBA_PLUGIN"\\\"\"
             DEFINES += driver_Author="\"\\\"Alexis Jeandet alexis.jeandet@lpp.polytechnique.fr"\\\"\"
             DEFINES += driver_Version="\"\\\"0.0.1"\\\"\"
             DEFINES += driver_Description="\"\\\"This driver handles the Gaisler AMBA plugn' play system."\\\"\"
             DEFINES += driver_can_be_root=0
             DEFINES += driver_can_be_child=1
             DEFINES += driver_VID=0
             DEFINES += driver_PID=0
             INCLUDEPATH += \
                     $${PWD}
             HEADERS += \
                 ambaplugin.h \
                 AHB/ahbpluginui.h \
                 AHB/ahbdevicelist.h \
                 APB/apbpluginui.h \
                 APB/apbdevicelist.h \
                 ambapluginui.h
             SOURCES += \
                 ambaplugin.cpp \
                 AHB/ahbpluginui.cpp \
                 AHB/ahbdevicelist.cpp \
                 APB/apbpluginui.cpp \
                 APB/apbdevicelist.cpp \
                 ambapluginui.cpp

dsu3plugin/dsu3plugin.cpp +64 -8

             /*------------------------------------------------------------------------------
             --  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[]=
+            {
+            {0x01,0x04,"MCTRL"},
+            {0x01,0x51,"FTSRCTRL"},
+            {0x20,0x01,"SRCTRLE_0WS" },
+            {0x20,0x02,"SRCTRLE_1WS" }
+            };
+            #define acceptedMemctrlrCnt sizeof acceptedMemctrlr
             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()
             {
               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 = SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,0x04 , 0x00F,0);
+              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) break;
+                }
               if(MCTRLBASEADDRESS == (unsigned int)-1)
                 {
-                    SocExplorerEngine::message(this,"Can't find MemCtrlr",1);
+                  //SocExplorerEngine::message(this,"Can't find FTMemCtrlr",1);
-                    MCTRLBASEADDRESS = SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,0x01 , 0x051,0);
-                    if(MCTRLBASEADDRESS == (unsigned int)-1)
-                        SocExplorerEngine::message(this,"Can't find FTMemCtrlr",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);
               WriteRegs(uIntlist()<<0x2FF<<0xE60<<0,(unsigned int)MCTRLBASEADDRESS);
               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);
+              if(enabled)
+                {
+                  WriteRegs(uIntlist()<<0x0001000F,DSUBASEADDRESS+0x700000);
+                  //flushes cache.
+                  WriteRegs(uIntlist()<<0x0061000F,DSUBASEADDRESS+0x700000);
+                }
+              else
+                {
+                  WriteRegs(uIntlist()<<0x00000000,DSUBASEADDRESS+0x700000);
+                  WriteRegs(uIntlist()<<0x00600000,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);
             }
             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;
             }

dsu3plugin/dsu3plugin.h +3 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2012, 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 DSU3PLUGIN_H
             #define DSU3PLUGIN_H
             #include "dsu3pluginui.h"
             #include <QMenuBar>
             #include <QMenu>
             #include <QAction>
             #include <QMainWindow>
             #include <QList>
             #include "elfparser.h"
             #include <socexplorerplugin.h>
             #include <socexplorerengine.h>
             typedef QList<unsigned int> uIntlist;
             class dsu3plugin : public socexplorerplugin
             {
                 Q_OBJECT
             public:
                 explicit dsu3plugin(QWidget *parent = 0);
                 ~dsu3plugin();
                 bool memSet(unsigned int address, int value, unsigned int count);
             public slots:
                 unsigned int Write(unsigned int *Value,unsigned int count,unsigned  int address=0);
                 unsigned int Read(unsigned int *Value,unsigned int count, unsigned int address=0);
                 void openFile();
                 void openFile(QString fileName);
                 bool configureTarget();
+                bool cacheDisable();
+                bool cacheEnable();
+                bool setCacheEnable(bool enabled);
                 bool flashTarget();
                 void run();
                 void stop();
                 void toggleRun();
             signals:
                 void updateInfo(elfparser* parser);
             private:
                 void WriteRegs(uIntlist Values, unsigned int address);
                 void writeSection(int index);
                 void writeSection(const QString& name);
                 dsu3pluginui* UI;
                 elfparser* elfparserInst;
                 bool running;
             };
             #endif // DSU3PLUGIN_H

dsu3plugin/dsu3plugin.pro +6 -6

             #
             # Project created by QtCreator 2011-09-20T08:15:30
             #
             #-------------------------------------------------
             CONFIG += socexplorerplugin
             TEMPLATE = lib
-            CONFIG(debug, debug|release) {
+            #CONFIG(debug, debug|release) {
-              DEBUG_EXT = _d
+            #  DEBUG_EXT = _d
-            } else {
+            #} else {
-              DEBUG_EXT =
+            #  DEBUG_EXT =
+            #}
             QMAKE_LFLAGS_RELEASE += --enable-auto-import -mstackrealign
             QMAKE_LFLAGS_DEBUG += --enable-auto-import -mstackrealign
-            TARGET = dsu3plugin$${DEBUG_EXT}
+            TARGET = dsu3plugin #$${DEBUG_EXT}
             DEFINES += PLUGIN=dsu3plugin
             DEFINES += PLUGINHEADER="\"\\\"dsu3plugin.h"\\\"\"
             DEFINES += driver_Name="\"\\\"dsu3plugin"\\\"\"
             DEFINES += driver_Author="\"\\\"Alexis Jeandet alexis.jeandet@lpp.polytechnique.fr"\\\"\"
             DEFINES += driver_Version="\"\\\"0.0.1"\\\"\"
             DEFINES += driver_Description="\"\\\"DSU driver, works with GAISLER's DSU3 unit."\\\"\"
             DEFINES += driver_can_be_root=0
             DEFINES += driver_can_be_child=1
             DEFINES += driver_VID=0x00
             DEFINES += driver_PID=0x00
             INCLUDEPATH += \
                     $${PWD}
             HEADERS += \
                 dsu3plugin.h \
                 dsu3pluginui.h \
                 dsu3pluginpywrapper.h
             SOURCES += \
                 dsu3plugin.cpp \
                 dsu3pluginui.cpp \
                 dsu3pluginpywrapper.cpp

dsu3plugin/dsu3pluginpywrapper.h +3 0

             #ifndef DSU3PLUGINPYWRAPPER_H
             #define DSU3PLUGINPYWRAPPER_H
             #include <genericPySysdriver.h>
             class dsu3pluginPywrapper : public genericPySysdriver
             {
                 Q_OBJECT
             public:
                 explicit dsu3pluginPywrapper(socexplorerplugin *parent = 0);
             signals:
                 bool openFile(QString fileName);
                 bool loadFile();
                 bool run();
                 bool stop();
+                bool cacheDisable();
+                bool cacheEnable();
+                bool setCacheEnable(bool enabled);
             public slots:
             };
             #endif // DSU3PLUGINPYWRAPPER_H

genericrwplugin/genericrwplugin.pro +6 -6

             #
             # Project created by QtCreator 2011-09-20T08:15:30
             #
             #-------------------------------------------------
             CONFIG += socexplorerplugin
             CONFIG += dll
             CONFIG -= static
-            CONFIG(debug, debug|release) {
+            #CONFIG(debug, debug|release) {
-              DEBUG_EXT = _d
+            #  DEBUG_EXT = _d
-            } else {
+            #} else {
-              DEBUG_EXT =
+            #  DEBUG_EXT =
+            #}
-            TARGET = genericrwplugin$${DEBUG_EXT}
+            TARGET = genericrwplugin   #$${DEBUG_EXT}
             DEFINES += PLUGIN=genericrwplugin
             DEFINES += PLUGINHEADER="\"\\\"genericrwplugin.h"\\\"\"
             DEFINES += driver_Name="\"\\\"GenericRWplugin"\\\"\"
             DEFINES += driver_Author="\"\\\"Alexis Jeandet alexis.jeandet@lpp.polytechnique.fr"\\\"\"
             DEFINES += driver_Version="\"\\\"1.1.0"\\\"\"
             DEFINES += driver_Description="\"\\\"Generic plugin, gives you R/W access to any memory area."\\\"\"
             DEFINES += driver_can_be_root=0
             DEFINES += driver_can_be_child=1
             DEFINES += driver_VID=0
             DEFINES += driver_PID=0
             INCLUDEPATH += \
                     $${PWD}
             #LIBS +=-llppmoncommon$${DEBUG_EXT}
             HEADERS += \
                 genericrwplugin.h \
                 genericrwpluginui.h \
                 memeditor.h \
                 genericrwpluginpywrapper.h
             SOURCES += \
                 genericrwplugin.cpp \
                 genericrwpluginui.cpp \
                 memeditor.cpp \
                 genericrwpluginpywrapper.cpp

memcheckplugin/memchecker.cpp +55 0

             /*------------------------------------------------------------------------------
             --  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 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 "memchecker.h"
             memchecker::memchecker(socexplorerplugin* plugin)
             {
               this->plugin = plugin;
             }
             QString memchecker::checkmemory(unsigned int address, unsigned int size, bool *success)
             {
               *success = true;
               QString repport;
               unsigned int* dataLocal = (unsigned int*)malloc(size);
               unsigned int* dataOnBoard = (unsigned int*)malloc(size);
               for(int i=0;(unsigned int)i<(size>>2);i++)
                 {
                   dataLocal[i]= (0xFFFF&rand())+(rand()<<16);
                 }
               plugin->Write(dataLocal,size>>2,address);
               plugin->Read(dataOnBoard,size>>2,address);
               for(int i=0;(unsigned int)i<(size>>2);i++)
                 {
                   if(dataLocal[i]!=dataOnBoard[i])
                     *success=false;
                 }
               free(dataLocal);
               free(dataOnBoard);
               return repport;
             }
             QString memchecker::checkdatabits(unsigned int address,unsigned int size,bool* success)
             {
               *success = true;
               QString repport;
               return repport;
             }
+            unsigned int p_pow2(unsigned int v)
+            {
+              static const char LogTable256[256] =
+              {
+              #define LT(n) n, n, n, n, n, n, n, n, n, n, n, n, n, n, n, n
+                  -1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
+                  LT(4), LT(5), LT(5), LT(6), LT(6), LT(6), LT(6),
+                  LT(7), LT(7), LT(7), LT(7), LT(7), LT(7), LT(7), LT(7)
+              };
+              unsigned int r;     // r will be lg(v)
+              register unsigned int t, tt; // temporaries
+              if (tt = v >> 16)
+              {
+                r = (t = tt >> 8) ? 24 + LogTable256[t] : 16 + LogTable256[tt];
+              }
+              else
+              {
+                r = (t = v >> 8) ? 8 + LogTable256[t] : LogTable256[v];
+              }
+              return r;
+            }
+            unsigned int memchecker::measureMemSize(unsigned int address, unsigned int maxSize)
+            {
+              unsigned int curVal=1,testAddress=address;
+              unsigned int size=0;
+              this->plugin->Write(&curVal,1,testAddress);
+              this->plugin->Read(&curVal,1,testAddress);
+              if(curVal!=1)
+                return size;
+              unsigned int max= p_pow2((0xFFFFFFFFFFFFFFFF - address))+1;
+              register unsigned int maxSizeLg=p_pow2(maxSize)-1;
+              if(max>maxSizeLg)
+                max=maxSizeLg;
+              if(max>32)max=32;
+              for(size=2;size<max;size++) //check each address bit
+                {
+                  testAddress = (unsigned int)(address+(1<<size));
+                  curVal = (unsigned int)(1<<size);
+                  this->plugin->Write(&curVal,1,testAddress);
+                  this->plugin->Read(&curVal,1,testAddress);
+                  if((unsigned int)curVal!=(unsigned int)(1<<size))
+                    return (1<<(size));
+                  this->plugin->Read(&curVal,1,address);
+                  if((curVal==(unsigned int)(1<<size)) && (size!=0))
+                    return (1<<(size));
+                }
+              return (1<<(size+1));
+            }

memcheckplugin/memchecker.h +1 0

             /*------------------------------------------------------------------------------
             --  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 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 MEMCHECKER_H
             #define MEMCHECKER_H
             #include <socexplorerplugin.h>
             class memchecker
             {
             public:
                 memchecker(socexplorerplugin* plugin);
                 QString checkmemory(unsigned int address,unsigned int size,bool* success);
                 QString checkdatabits(unsigned int address,unsigned int size,bool* success);
+                unsigned int measureMemSize(unsigned int address,unsigned int maxSize=0xFFFFFFFF);
             private:
                 socexplorerplugin* plugin;
             };
             #endif // MEMCHECKER_H

memcheckplugin/memcheckplugin.cpp +17 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
             ----------------------------------------------------------------------------*/
             #include "memcheckplugin.h"
             memcheckplugin::memcheckplugin(QWidget *parent):socexplorerplugin(parent,true)
             {
                 this->UI = new memcheckplugin_ui();
                 this->setWidget(this->UI);
                 this->checker = new memchecker(this);
                 QObject::connect(this->UI,SIGNAL(checkdatabits(uint,uint)),this,SLOT(checkdatabits(uint,uint)));
                 QObject::connect(this->UI,SIGNAL(checkmemory(uint,uint)),this,SLOT(checkmemory(uint,uint)));
+                QObject::connect(this->UI,SIGNAL(checkmemorySize(uint,uint)),this,SLOT(checkmemorySize(uint,uint)));
             }
             memcheckplugin::~memcheckplugin()
             {}
             void memcheckplugin::checkmemory(unsigned int address, unsigned int size)
             {
                 bool success;
                 QString repport=this->checker->checkmemory(address,size,&success);
                 this->UI->setResult(success,repport);
             }
+            void memcheckplugin::checkmemorySize(unsigned int address, unsigned int size)
+            {
+              bool success=true;
+              unsigned int _size = this->checker->measureMemSize(address,size);
+              int prefix=0;
+              QStringList list;
+              list <<"B" << "KB" << "MB" << "GB";
+              while (_size>=(unsigned int)1024)
+                {
+                  _size/=1024;
+                  prefix++;
+                }
+              QString repport=QString::number(_size)+list.at(prefix);
+              this->UI->setResult(success,repport);
+            }
             void memcheckplugin::checkdatabits(unsigned int address, unsigned int size)
             {
                 bool success;
                 QString repport=this->checker->checkdatabits(address,size,&success);
                 this->UI->setResult(success,repport);
             }

memcheckplugin/memcheckplugin.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 MEMCTRLRPLUGIN_H
             /*------------------------------------------------------------------------------
             --  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 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
             ----------------------------------------------------------------------------*/
             #define MEMCTRLRPLUGIN_H
             #include "memcheckplugin_ui.h"
             #include <QMenuBar>
             #include <QMenu>
             #include <QAction>
             #include <QMainWindow>
             #include <socexplorerplugin.h>
             #include <memchecker.h>
             #include <socexplorerplugin.h>
             class memcheckplugin : public socexplorerplugin
             {
                 Q_OBJECT
             public:
                 explicit memcheckplugin(QWidget *parent = 0);
                 ~memcheckplugin();
             public slots:
                 void checkmemory(unsigned int address,unsigned int size);
+                void checkmemorySize(unsigned int address,unsigned int size);
                 void checkdatabits(unsigned int address,unsigned int size);
             signals:
             private:
                 memcheckplugin_ui* UI;
                 memchecker* checker;
             };
             #endif // MEMCTRLRPLUGIN_H

memcheckplugin/memcheckplugin.pro +7 -6

             #
             # Project created by QtCreator 2011-09-20T08:15:30
             #
             #-------------------------------------------------
             CONFIG += socexplorerplugin
             CONFIG += dll
             CONFIG -= static
-            CONFIG(debug, debug|release) {
+            #CONFIG(debug, debug|release) {
-              DEBUG_EXT = _d
+            #  DEBUG_EXT = _d
-            } else {
+            #} else {
-              DEBUG_EXT =
+            #  DEBUG_EXT =
+            #}
-            TARGET = memcheckplugin$${DEBUG_EXT}
+            TARGET = memcheckplugin #$${DEBUG_EXT}
             DEFINES += PLUGIN=memcheckplugin
             DEFINES += PLUGINHEADER="\"\\\"memcheckplugin.h"\\\"\"
             DEFINES += driver_Name="\"\\\"MemChecker"\\\"\"
             DEFINES += driver_Author="\"\\\"Alexis Jeandet alexis.jeandet@lpp.polytechnique.fr"\\\"\"
             DEFINES += driver_Version="\"\\\"1.0.1"\\\"\"
             DEFINES += driver_Description="\"\\\"Memory controler driver, works with ESA's LEON2 memory controler."\\\"\"
             DEFINES += driver_can_be_root=0
             DEFINES += driver_can_be_child=1
             DEFINES += driver_VID=0x04
             DEFINES += driver_PID=0x0f
             #LIBS +=-llppmoncommon
             INCLUDEPATH += \
                     $${PWD}
             HEADERS += \
                 memcheckplugin.h \
                 memcheckplugin_ui.h \
                 memchecker.h
             SOURCES += \
                 memcheckplugin.cpp \
                 memcheckplugin_ui.cpp \
                 memchecker.cpp
             FORMS += \
                 memcheckplugin_ui.ui

memcheckplugin/memcheckplugin_ui.cpp +2 -1

             /*------------------------------------------------------------------------------
             --  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 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 "memcheckplugin_ui.h"
             #include "ui_memcheckplugin_ui.h"
             #include <memsizewdgt.h>
             #include <qhexspinbox.h>
             memcheckplugin_ui::memcheckplugin_ui(QWidget *parent) :
                 QWidget(parent),
                 ui(new Ui::memcheckplugin_ui)
             {
                 ui->setupUi(this);
                 connect(this->ui->StartTestQpb,SIGNAL(clicked()),this,SLOT(startCheck()));
             }
             memcheckplugin_ui::~memcheckplugin_ui()
             {
                 delete ui;
             }
             void memcheckplugin_ui::startCheck()
             {
                 if(this->ui->testTypeQchkBx->currentText()=="Check data bits")
                 {
                     emit checkdatabits(this->ui->StartAddress->value(),this->ui->MemSize->getsize());
                 }
                 if(this->ui->testTypeQchkBx->currentText()=="Check memory size")
                 {
-                    emit checkmemory(this->ui->StartAddress->value(),this->ui->MemSize->getsize());
+                    //emit checkmemory(this->ui->StartAddress->value(),this->ui->MemSize->getsize());
+                    emit checkmemorySize(this->ui->StartAddress->value(),this->ui->MemSize->getsize());
                 }
                 if(this->ui->testTypeQchkBx->currentText()=="Full test")
                 {
                 }
             }
             void memcheckplugin_ui::setResult(bool success, QString repport)
             {
                 this->ui->testDetails->setText(repport);
                 if(success)
                 {
                     this->ui->TestResult->setText("Success");
                 }
                 else
                 {
                     this->ui->TestResult->setText("Failed");
                 }
             }

memcheckplugin/memcheckplugin_ui.h +1 0

             /*------------------------------------------------------------------------------
             --  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 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 MEMCHECKPLUGIN_UI_H
             #define MEMCHECKPLUGIN_UI_H
             #include <QWidget>
             namespace Ui {
             class memcheckplugin_ui;
             }
             class memcheckplugin_ui : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit memcheckplugin_ui(QWidget *parent = 0);
                 ~memcheckplugin_ui();
             public slots:
                 void startCheck();
                 void setResult(bool success,QString repport);
             signals:
                 void checkmemory(unsigned int address,unsigned int size);
+                void checkmemorySize(unsigned int address,unsigned int size);
                 void checkdatabits(unsigned int address,unsigned int size);
             private:
                 Ui::memcheckplugin_ui *ui;
             };
             #endif // MEMCHECKPLUGIN_UI_H

memctrlrplugin/memctrlrplugin.pro +6 -6

             #
             # Project created by QtCreator 2011-09-20T08:15:30
             #
             #-------------------------------------------------
             CONFIG += socexplorerplugin
             CONFIG += dll
             CONFIG -= static
-            CONFIG(debug, debug|release) {
+            #CONFIG(debug, debug|release) {
-              DEBUG_EXT = _d
+            #  DEBUG_EXT = _d
-            } else {
+            #} else {
-              DEBUG_EXT =
+            #  DEBUG_EXT =
+            #}
-            TARGET = memctrlrplugin$${DEBUG_EXT}
+            TARGET = memctrlrplugin #$${DEBUG_EXT}
             DEFINES += PLUGIN=memctrlrplugin
             DEFINES += PLUGINHEADER="\"\\\"memctrlrplugin.h"\\\"\"
             DEFINES += driver_Name="\"\\\"MemControler"\\\"\"
             DEFINES += driver_Author="\"\\\"Alexis Jeandet alexis.jeandet@lpp.polytechnique.fr"\\\"\"
             DEFINES += driver_Version="\"\\\"1.0.1"\\\"\"
             DEFINES += driver_Description="\"\\\"Memory controler driver, works with ESA's LEON2 memory controler."\\\"\"
             DEFINES += driver_can_be_root=0
             DEFINES += driver_can_be_child=1
             DEFINES += driver_VID=0x04
             DEFINES += driver_PID=0x0f
             #LIBS +=-llppmoncommon
             INCLUDEPATH += \
                     $${PWD}
             HEADERS += \
                 memctrlrplugin.h \
                 memctrlrpluginui.h \
                 memorycheck.h \
                 genericmemoryspacecheck.h \
                 memctrlrpywrapper.h
             SOURCES += \
                 memctrlrplugin.cpp \
                 memctrlrpluginui.cpp \
                 memorycheck.cpp \
                 genericmemoryspacecheck.cpp \
                 memctrlrpywrapper.cpp

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