regtools/qeditor: rewrite soc handling

The code was a mess with respect to soc handling: some code just plain copied
the SoC descriptor which are big objects, some was using indexes. The new soc
factor out everything in a few classes which hide these ugly details so that
descriptors are never copied.

Change-Id: I17af8b47f997a528b58221621389d42d24fded93

utils/regtools/qeditor/analyser.cpp

@@ -1,6 +1,6 @@
 #include "analyser.h"
 
-Analyser::Analyser(const soc_t& soc, IoBackend *backend)
+Analyser::Analyser(const SocRef& soc, IoBackend *backend)
     :m_soc(soc), m_io_backend(backend)
 {
 }

utils/regtools/qeditor/analyser.h

@@ -10,12 +10,12 @@ class Analyser : public QObject
 {
     Q_OBJECT
 public:
-    Analyser(const soc_t& soc, IoBackend *backend);
+    Analyser(const SocRef& soc, IoBackend *backend);
     virtual ~Analyser();
     virtual QWidget *GetWidget() = 0;
 
 protected:
-    soc_t m_soc;
+    const SocRef& m_soc;
     IoBackend *m_io_backend;
 };
 
@@ -28,7 +28,7 @@ public:
     virtual QString GetName() = 0;
     virtual bool SupportSoc(const QString& soc_name) = 0;
     // return NULL of soc is not handled by the analyser
-    virtual Analyser *Create(const soc_t& soc, IoBackend *backend) = 0;
+    virtual Analyser *Create(const SocRef& soc, IoBackend *backend) = 0;
 private:
     QString m_name;
 
@@ -51,9 +51,9 @@ public:
     virtual QString GetName() { return m_name; }
     virtual bool SupportSoc(const QString& soc_name) { return T::SupportSoc(soc_name); }
     // return NULL of soc is not handled by the analyser
-    virtual T *Create(const soc_t& soc, IoBackend *backend)
+    virtual T *Create(const SocRef& soc, IoBackend *backend)
     {
-        if(!T::SupportSoc(soc.name.c_str()))
+        if(!T::SupportSoc(soc.GetSoc().name.c_str()))
             return 0;
         return new T(soc, backend);
     }

utils/regtools/qeditor/backend.cpp

@@ -19,12 +19,12 @@ QStringList Backend::GetSocNameList()
     return sl;
 }
 
-bool Backend::GetSocByName(const QString& name, soc_t& s)
+bool Backend::GetSocByName(const QString& name, SocRef& s)
 {
     for(std::list< soc_t >::iterator it = m_socs.begin(); it != m_socs.end(); ++it)
         if(it->name == name.toStdString())
         {
-            s = *it;
+            s = SocRef(&(*it));
             return true;
         }
     return false;
@@ -326,7 +326,7 @@ bool HWStubBackendHelper::HasHotPlugSupport()
  * BackendHelper
  */
 
-BackendHelper::BackendHelper(IoBackend *io_backend, const soc_t& soc)
+BackendHelper::BackendHelper(IoBackend *io_backend, const SocRef& soc)
     :m_io_backend(io_backend), m_soc(soc)
 {
 }
@@ -345,75 +345,72 @@ bool BackendHelper::ReadRegister(const QString& dev, const QString& reg, soc_wor
 }
 
 
-bool BackendHelper::GetDeviceDesc(const QString& dev, soc_dev_t& dev_desc, size_t& index)
+bool BackendHelper::GetDevRef(const QString& sdev, SocDevRef& ref)
 {
-    for(size_t i = 0; i < m_soc.dev.size(); i++)
+    for(size_t i = 0; i < m_soc.GetSoc().dev.size(); i++)
     {
-        for(size_t j = 0; j < m_soc.dev[i].addr.size(); j++)
+        const soc_dev_t& dev = m_soc.GetSoc().dev[i];
-            if(m_soc.dev[i].addr[j].name.c_str() == dev)
+        for(size_t j = 0; j < dev.addr.size(); j++)
+            if(dev.addr[j].name.c_str() == sdev)
             {
-                dev_desc = m_soc.dev[i];
+                ref = SocDevRef(m_soc, i, j);
-                index = j;
                 return true;
             }
     }
     return false;
 }
 
-bool BackendHelper::GetRegisterDesc(const soc_dev_t& dev, const QString& reg,
+bool BackendHelper::GetRegRef(const SocDevRef& dev, const QString& sreg, SocRegRef& ref)
-    soc_reg_t& reg_desc, size_t& index)
 {
-    for(size_t i = 0; i < dev.reg.size(); i++)
+    const soc_dev_t& sdev = dev.GetDev();
+    for(size_t i = 0; i < sdev.reg.size(); i++)
     {
-        for(size_t j = 0; j < dev.reg[i].addr.size(); j++)
+        const soc_reg_t& reg = sdev.reg[i];
-            if(dev.reg[i].addr[j].name.c_str() == reg)
+        for(size_t j = 0; j < reg.addr.size(); j++)
+        {
+            if(reg.addr[j].name.c_str() == sreg)
             {
-                index = j;
+                ref = SocRegRef(dev, i, j);
-                reg_desc = dev.reg[i];
                 return true;
             }
+        }
     }
     return false;
 }
 
-bool BackendHelper::GetFieldDesc(const soc_reg_t& reg_desc, const QString& field,
+bool BackendHelper::GetFieldRef(const SocRegRef& reg, const QString& sfield, SocFieldRef& ref)
-    soc_reg_field_t& field_desc)
 {
-    for(size_t i = 0; i < reg_desc.field.size(); i++)
+    for(size_t i = 0; i < reg.GetReg().field.size(); i++)
-        if(reg_desc.field[i].name.c_str() == field)
+        if(reg.GetReg().field[i].name.c_str() == sfield)
-            field_desc = reg_desc.field[i];
+        {
+            ref = SocFieldRef(reg, i);
+            return true;
+        }
     return false;
 }
 
 bool BackendHelper::GetRegisterAddress(const QString& dev, const QString& reg,
     soc_addr_t& addr)
 {
-    size_t dev_index, reg_index;
+    SocDevRef dev_ref;
-    soc_dev_t dev_desc;
+    SocRegRef reg_ref;
-    soc_reg_t reg_desc;
+    if(!GetDevRef(dev, dev_ref) || !GetRegRef(dev_ref, reg, reg_ref))
-    if(!GetDeviceDesc(dev, dev_desc, dev_index))
         return false;
-    if(!GetRegisterDesc(dev_desc, reg, reg_desc, reg_index))
+    addr = dev_ref.GetDevAddr().addr + reg_ref.GetRegAddr().addr;
-        return false;
-    addr = dev_desc.addr[dev_index].addr + reg_desc.addr[reg_index].addr;
     return true;
 }
 
 bool BackendHelper::ReadRegisterField(const QString& dev, const QString& reg,
     const QString& field, soc_word_t& v)
 {
-    size_t dev_index, reg_index;
+    SocDevRef dev_ref;
-    soc_dev_t dev_desc;
+    SocRegRef reg_ref;
-    soc_reg_t reg_desc;
+    SocFieldRef field_ref;
-    soc_reg_field_t field_desc;
+    if(!GetDevRef(dev, dev_ref) || !GetRegRef(dev_ref, reg, reg_ref) || 
-    if(!GetDeviceDesc(dev, dev_desc, dev_index))
+            !GetFieldRef(reg_ref, field, field_ref))
-        return false;
-    if(!GetRegisterDesc(dev_desc, reg, reg_desc, reg_index))
-        return false;
-    if(!GetFieldDesc(reg_desc, field, field_desc))
         return false;
     if(!ReadRegister(dev, reg, v))
         return false;
-    v = (v & field_desc.bitmask()) >> field_desc.first_bit;
+    v = (v & field_ref.GetField().bitmask()) >> field_ref.GetField().first_bit;
     return true;
 }

utils/regtools/qeditor/backend.h

@@ -23,10 +23,14 @@ public:
         ByAddress,
     };
 
+    /* report whether backend supports register access type */
     virtual bool SupportAccess(AccessType type) = 0;
+    /* get SoC name */
     virtual QString GetSocName() = 0;
+    /* read a register by name or address */
     virtual bool ReadRegister(const QString& name, soc_word_t& value) = 0;
     virtual bool ReadRegister(soc_addr_t addr, soc_word_t& value) = 0;
+    /* reload content (if it makes sense) */
     virtual bool Reload() = 0;
 };
 
@@ -140,6 +144,56 @@ protected:
 };
 #endif
 
+class SocRef
+{
+public:
+    SocRef():m_soc(0) {}
+    SocRef(const soc_t *soc):m_soc(soc) {}
+    const soc_t& GetSoc() const { return *m_soc; }
+protected:
+    const soc_t *m_soc;
+};
+
+class SocDevRef : public SocRef
+{
+public:
+    SocDevRef() {}
+    SocDevRef(const SocRef& soc, int dev_idx, int dev_addr_idx)
+        :SocRef(soc), m_dev_idx(dev_idx), m_dev_addr_idx(dev_addr_idx) {}
+    int GetDevIndex() const { return m_dev_idx; }
+    const soc_dev_t& GetDev() const { return GetSoc().dev[GetDevIndex()]; }
+    int GetDevAddrIndex() const { return m_dev_addr_idx; }
+    const soc_dev_addr_t& GetDevAddr() const { return GetDev().addr[GetDevAddrIndex()]; }
+protected:
+    int m_dev_idx, m_dev_addr_idx;
+};
+
+class SocRegRef : public SocDevRef
+{
+public:
+    SocRegRef() {}
+    SocRegRef(const SocDevRef& dev, int reg_idx, int reg_addr_idx)
+        :SocDevRef(dev), m_reg_idx(reg_idx), m_reg_addr_idx(reg_addr_idx) {}
+    int GetRegIndex() const { return m_reg_idx; }
+    const soc_reg_t& GetReg() const { return GetDev().reg[GetRegIndex()]; }
+    int GetRegAddrIndex() const { return m_reg_addr_idx; }
+    const soc_reg_addr_t& GetRegAddr() const { return GetReg().addr[GetRegAddrIndex()]; }
+protected:
+    int m_reg_idx, m_reg_addr_idx;
+};
+
+class SocFieldRef : public SocRegRef
+{
+public:
+    SocFieldRef(){}
+    SocFieldRef(const SocRegRef& reg, int field_idx)
+        :SocRegRef(reg), m_field_idx(field_idx) {}
+    int GetFieldIndex() const { return m_field_idx; }
+    const soc_reg_field_t& GetField() const { return GetReg().field[GetFieldIndex()]; }
+protected:
+    int m_field_idx;
+};
+
 class Backend : public QObject
 {
     Q_OBJECT
@@ -148,7 +202,7 @@ public:
 
     QStringList GetSocNameList();
     bool LoadSocDesc(const QString& filename);
-    bool GetSocByName(const QString& name, soc_t& s);
+    bool GetSocByName(const QString& name, SocRef& s);
     IoBackend *CreateDummyIoBackend();
     IoBackend *CreateFileIoBackend(const QString& filename);
 #ifdef HAVE_HWSTUB
@@ -158,23 +212,23 @@ public:
 signals:
     void OnSocListChanged();
 private:
-    std::vector< soc_t > m_socs;
+    std::list< soc_t > m_socs;
 };
 
 class BackendHelper
 {
 public:
-    BackendHelper(IoBackend *io_backend, const soc_t& soc);
+    BackendHelper(IoBackend *io_backend, const SocRef& soc);
     bool ReadRegister(const QString& dev, const QString& reg, soc_word_t& v);
     bool ReadRegisterField(const QString& dev, const QString& reg,
         const QString& field, soc_word_t& v);
-    bool GetDeviceDesc(const QString& dev, soc_dev_t& dev_desc, size_t& index);
+    bool GetDevRef(const QString& dev, SocDevRef& ref);
-    bool GetRegisterDesc(const soc_dev_t& dev, const QString& reg, soc_reg_t& reg_desc, size_t& index);
+    bool GetRegRef(const SocDevRef& dev, const QString& reg, SocRegRef& ref);
-    bool GetFieldDesc(const soc_reg_t& reg_desc, const QString& field, soc_reg_field_t& field_desc);
+    bool GetFieldRef(const SocRegRef& reg, const QString& field, SocFieldRef& ref);
     bool GetRegisterAddress(const QString& dev, const QString& reg, soc_addr_t& addr);
 private:
     IoBackend *m_io_backend;
-    soc_t m_soc;
+    const SocRef& m_soc;
 };
 
 #endif /* __BACKEND_H__ */

utils/regtools/qeditor/regtab.cpp

@@ -203,17 +203,11 @@ void RegTab::OnRegItemChanged(QTreeWidgetItem *current, QTreeWidgetItem *previou
 void RegTab::OnRegItemClicked(QTreeWidgetItem *current, int col)
 {
     (void) col;
-    if(current == 0)
+    if(current == 0 || current->type() != RegTreeRegType)
         return;
     RegTreeItem *item = dynamic_cast< RegTreeItem * >(current);
-    if(item->type() != RegTreeRegType)
-        return;
-    soc_dev_t& dev = m_cur_soc.dev[item->GetDevIndex()];
-    soc_dev_addr_t& dev_addr = dev.addr[item->GetDevAddrIndex()];
-    soc_reg_t& reg = dev.reg[item->GetRegIndex()];
-    soc_reg_addr_t& reg_addr = reg.addr[item->GetRegAddrIndex()];
 
-    DisplayRegister(dev, dev_addr, reg, reg_addr);
+    DisplayRegister(item->GetRef());
 }
 
 void RegTab::OnAnalyserChanged(QListWidgetItem *current, QListWidgetItem *previous)
@@ -232,14 +226,16 @@ void RegTab::OnAnalyserClicked(QListWidgetItem *current)
     m_right_panel->addWidget(m_right_content, 1);
 }
 
-void RegTab::DisplayRegister(soc_dev_t& dev, soc_dev_addr_t& dev_addr,
+void RegTab::DisplayRegister(const SocRegRef& ref)
-    soc_reg_t& reg, soc_reg_addr_t& reg_addr)
 {
-    (void) dev;
     delete m_right_content;
 
     QVBoxLayout *right_layout = new QVBoxLayout;
 
+    const soc_dev_addr_t& dev_addr = ref.GetDevAddr();
+    const soc_reg_t& reg = ref.GetReg();
+    const soc_reg_addr_t& reg_addr = ref.GetRegAddr();
+
     QString reg_name;
     reg_name.sprintf("HW_%s_%s", dev_addr.name.c_str(), reg_addr.name.c_str());
     QStringList names;
@@ -303,29 +299,29 @@ void RegTab::DisplayRegister(soc_dev_t& dev, soc_dev_addr_t& dev_addr,
     QTableWidget *value_table = new QTableWidget;
     value_table->setRowCount(reg.field.size());
     value_table->setColumnCount(4);
-    for(size_t i = 0; i < reg.field.size(); i++)
+    int row = 0;
+    foreach(const soc_reg_field_t& field, reg.field)
     {
         QString bits_str;
-        if(reg.field[i].first_bit == reg.field[i].last_bit)
+        if(field.first_bit == field.last_bit)
-            bits_str.sprintf("%d", reg.field[i].first_bit);
+            bits_str.sprintf("%d", field.first_bit);
         else
-            bits_str.sprintf("%d:%d", reg.field[i].last_bit, reg.field[i].first_bit);
+            bits_str.sprintf("%d:%d", field.last_bit, field.first_bit);
         QTableWidgetItem *item = new QTableWidgetItem(bits_str);
         item->setTextAlignment(Qt::AlignVCenter | Qt::AlignHCenter);
         item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-        value_table->setItem(i, 0, item);
+        value_table->setItem(row, 0, item);
-        item = new QTableWidgetItem(QString(reg.field[i].name.c_str()));
+        item = new QTableWidgetItem(QString(field.name.c_str()));
         item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-        value_table->setItem(i, 1, item);
+        value_table->setItem(row, 1, item);
         item = new QTableWidgetItem();
         if(has_value)
         {
-            const soc_reg_field_t& field = reg.field[i];
             soc_word_t v = (value & field.bitmask()) >> field.first_bit;
             QString value_name;
-            for(size_t j = 0; j < field.value.size(); j++)
+            foreach(const soc_reg_field_value_t& rval, field.value)
-                if(v == field.value[j].value)
+                if(v == rval.value)
-                    value_name = field.value[j].name.c_str();
+                    value_name = rval.name.c_str();
             const char *fmt = "%lu";
             // heuristic
             if((field.last_bit - field.first_bit + 1) > 16)
@@ -338,11 +334,12 @@ void RegTab::DisplayRegister(soc_dev_t& dev, soc_dev_addr_t& dev_addr,
                 QTableWidgetItem *t = new QTableWidgetItem(value_name);
                 t->setTextAlignment(Qt::AlignVCenter | Qt::AlignHCenter);
                 t->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-                value_table->setItem(i, 3, t);
+                value_table->setItem(row, 3, t);
             }
         }
         item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-        value_table->setItem(i, 2, item);
+        value_table->setItem(row, 2, item);
+        row++;
     }
     value_table->setHorizontalHeaderItem(0, new QTableWidgetItem("Bits"));
     value_table->setHorizontalHeaderItem(1, new QTableWidgetItem("Name"));
@@ -404,16 +401,16 @@ void RegTab::OnDevChanged(int index)
 }
 #endif
 
-void RegTab::FillDevSubTree(RegTreeItem *item)
+void RegTab::FillDevSubTree(DevTreeItem *item)
 {
-    soc_dev_t& sd = m_cur_soc.dev[item->GetDevIndex()];
+    const soc_dev_t& dev = item->GetRef().GetDev();
-    for(size_t i = 0; i < sd.reg.size(); i++)
+    for(size_t i = 0; i < dev.reg.size(); i++)
     {
-        soc_reg_t& reg = sd.reg[i];
+        const soc_reg_t& reg = dev.reg[i];
         for(size_t j = 0; j < reg.addr.size(); j++)
         {
-            RegTreeItem *reg_item = new RegTreeItem(reg.addr[j].name.c_str(), RegTreeRegType);
+            RegTreeItem *reg_item = new RegTreeItem(reg.addr[j].name.c_str(),
-            reg_item->SetPath(item->GetDevIndex(), item->GetDevAddrIndex(), i, j);
+                SocRegRef(item->GetRef(), i, j));
             item->addChild(reg_item);
         }
     }
@@ -421,13 +418,13 @@ void RegTab::FillDevSubTree(RegTreeItem *item)
 
 void RegTab::FillRegTree()
 {
-    for(size_t i = 0; i < m_cur_soc.dev.size(); i++)
+    for(size_t i = 0; i < m_cur_soc.GetSoc().dev.size(); i++)
     {
-        soc_dev_t& sd = m_cur_soc.dev[i];
+        const soc_dev_t& dev = m_cur_soc.GetSoc().dev[i];
-        for(size_t j = 0; j < sd.addr.size(); j++)
+        for(size_t j = 0; j < dev.addr.size(); j++)
         {
-            RegTreeItem *dev_item = new RegTreeItem(sd.addr[j].name.c_str(), RegTreeDevType);
+            DevTreeItem *dev_item = new DevTreeItem(dev.addr[j].name.c_str(),
-            dev_item->SetPath(i, j);
+                SocDevRef(m_cur_soc, i, j));
             FillDevSubTree(dev_item);
             m_reg_tree->addTopLevelItem(dev_item);
         }
@@ -437,7 +434,7 @@ void RegTab::FillRegTree()
 void RegTab::FillAnalyserList()
 {
     m_analysers_list->clear();
-    m_analysers_list->addItems(AnalyserFactory::GetAnalysersForSoc(m_cur_soc.name.c_str()));
+    m_analysers_list->addItems(AnalyserFactory::GetAnalysersForSoc(m_cur_soc.GetSoc().name.c_str()));
 }
 
 void RegTab::OnSocChanged(const QString& soc)

utils/regtools/qeditor/regtab.h

@@ -30,18 +30,28 @@ enum
 #endif
 };
 
+class DevTreeItem : public QTreeWidgetItem
+{
+public:
+    DevTreeItem(const QString& string, const SocDevRef& ref)
+        :QTreeWidgetItem(QStringList(string), RegTreeDevType), m_ref(ref) {}
+
+    const SocDevRef& GetRef() { return m_ref; }
+private:
+    SocDevRef m_ref;
+};
+
 class RegTreeItem : public QTreeWidgetItem
 {
 public:
-    RegTreeItem(const QString& string, int type);
+    RegTreeItem(const QString& string, const SocRegRef& ref)
+        :QTreeWidgetItem(QStringList(string), RegTreeRegType), m_ref(ref) {}
 
-    void SetPath(int dev_idx, int dev_addr_idx, int reg_idx = -1, int reg_addr_idx = -1);
+    const SocRegRef& GetRef() { return m_ref; }
-    int GetDevIndex() const { return m_dev_idx; }
-    int GetDevAddrIndex() const { return m_dev_addr_idx; }
-    int GetRegIndex() const { return m_reg_idx; }
-    int GetRegAddrIndex() const { return m_reg_addr_idx; }
 private:
-    int m_dev_idx, m_dev_addr_idx, m_reg_idx, m_reg_addr_idx;
+    SocRegRef m_ref;
+};
+
 };
 
 class RegTab : public QSplitter
@@ -51,12 +61,11 @@ public:
     RegTab(Backend *backend);
 
 protected:
-    void FillDevSubTree(RegTreeItem *item);
+    void FillDevSubTree(DevTreeItem *item);
     void FillRegTree();
     void FillAnalyserList();
     void UpdateSocList();
-    void DisplayRegister(soc_dev_t& dev, soc_dev_addr_t& dev_addr,
+    void DisplayRegister(const SocRegRef& ref);
-        soc_reg_t& reg, soc_reg_addr_t& reg_addr);
     void SetDataSocName(const QString& socname);
     QComboBox *m_soc_selector;
 #ifdef HAVE_HWSTUB
@@ -65,7 +74,7 @@ protected:
 #endif
     Backend *m_backend;
     QTreeWidget *m_reg_tree;
-    soc_t m_cur_soc;
+    SocRef m_cur_soc;
     QVBoxLayout *m_right_panel;
     QWidget *m_right_content;
     QLineEdit *m_data_sel_edit;

utils/regtools/qeditor/std_analysers.cpp

@@ -4,7 +4,7 @@
  * Clock analyser
  */
 
-ClockAnalyser::ClockAnalyser(const soc_t& soc, IoBackend *backend)
+ClockAnalyser::ClockAnalyser(const SocRef& soc, IoBackend *backend)
         :Analyser(soc, backend)
 {
     m_group = new QGroupBox("Clock Analyser");
@@ -300,7 +300,7 @@ static TmplAnalyserFactory< ClockAnalyser > g_clock_factory(true, "Clock Analyse
 /**
  * EMI analyser
  */
-EmiAnalyser::EmiAnalyser(const soc_t& soc, IoBackend *backend)
+EmiAnalyser::EmiAnalyser(const SocRef& soc, IoBackend *backend)
     :Analyser(soc, backend)
 {
     m_display_mode = DisplayCycles;
@@ -647,7 +647,7 @@ namespace pin_desc
 #include "../../imxtools/misc/map.h"
 }
 
-PinAnalyser::PinAnalyser(const soc_t& soc, IoBackend *backend)
+PinAnalyser::PinAnalyser(const SocRef& soc, IoBackend *backend)
         :Analyser(soc, backend)
 {
     m_group = new QGroupBox("Pin Analyser");

utils/regtools/qeditor/std_analysers.h

@@ -23,7 +23,7 @@ class ClockAnalyser : public Analyser
 {
     Q_OBJECT
 public:
-    ClockAnalyser(const soc_t& soc, IoBackend *backend);
+    ClockAnalyser(const SocRef& soc, IoBackend *backend);
     virtual ~ClockAnalyser();
     virtual QWidget *GetWidget();
     static bool SupportSoc(const QString& soc_name);
@@ -54,7 +54,7 @@ class EmiAnalyser : public Analyser
 {
     Q_OBJECT
 public:
-    EmiAnalyser(const soc_t& soc, IoBackend *backend);
+    EmiAnalyser(const SocRef& soc, IoBackend *backend);
     virtual ~EmiAnalyser();
     virtual QWidget *GetWidget();
 
@@ -98,7 +98,7 @@ class PinAnalyser : public Analyser
 {
     Q_OBJECT
 public:
-    PinAnalyser(const soc_t& soc, IoBackend *backend);
+    PinAnalyser(const SocRef& soc, IoBackend *backend);
     virtual ~PinAnalyser();
     virtual QWidget *GetWidget();