regtoosl/qeditor: port to the new description format

This big commit port qeditor from v1 to v2 register file format. Although
the display code was much simplified, the edit code had to be rewritten.
The new code also brings many improvement to the register display widget.

The new code also compiles with both Qt4 and Qt5, although it is recommended
to use Qt5 to get some improvements, especially in the layout of editor.

Change-Id: I24633ac37a144f25d9e705b565654269ec9cfbd3

1 files changed, 73 insertions, 135 deletions

diff --git a/utils/regtools/qeditor/backend.h b/utils/regtools/qeditor/backend.h
index 934c1c359b..17eeb44533 100644
--- a/utils/regtools/qeditor/backend.h
+++ b/utils/regtools/qeditor/backend.h
@@ -26,14 +26,17 @@
 #include <QMap>
 #include <QVector>
 #include <QMetaType>
+#include <QAbstractItemModel>
 #ifdef HAVE_HWSTUB
 #include "hwstub.h"
 #endif
-#include "soc_desc_v1.hpp"
+#include "soc_desc.hpp"
 
 /* we don't want to import the entire soc_desc except for a few selected
  * pieces */
-using namespace soc_desc_v1;
+using soc_desc::soc_word_t;
+using soc_desc::soc_addr_t;
+using soc_desc::soc_id_t;
 
 class IoBackend : public QObject
 {
@@ -47,35 +50,20 @@ public:
         Write, Set, Clear, Toggle
     };
 
-    enum AccessType
-    {
-        ByName,
-        ByAddress,
-    };
-
-    /** Register naming convention: name based access are of the form:
-     * HW.dev.reg
-     * where <dev> is the device name (including index like APPUART1)
-     * and <reg> is the register name (including index like PRIORITY29) */
     /* report whether backend is valid */
     virtual bool IsValid() = 0;
-    /* 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;
+    /* read a register */
+    virtual bool ReadRegister(soc_addr_t addr, soc_word_t& value, unsigned width) = 0;
     /* reload content (if it makes sense) */
     virtual bool Reload() = 0;
     /* check whether backend supports writing */
     virtual bool IsReadOnly() = 0;
     /* write a register by name or address
-     * NOTE: even on a read-only backend, a write is allowed be successful as long
+     * NOTE: even on a read-only backend, a write is allowed to be successful as long
      * as commit fails */
-    virtual bool WriteRegister(const QString& name, soc_word_t value,
-        WriteMode mode = Write) = 0;
-    virtual bool WriteRegister(soc_addr_t addr, soc_word_t value,
+    virtual bool WriteRegister(soc_addr_t addr, soc_word_t value, unsigned width,
         WriteMode mode = Write) = 0;
     /* check whether backend contains uncommitted (ie cached) writes */
     virtual bool IsDirty() = 0;
@@ -87,23 +75,17 @@ class DummyIoBackend : public IoBackend
 {
     Q_OBJECT
 public:
-    DummyIoBackend() {}
-
-    virtual bool IsValid() { return false; }
-    virtual bool SupportAccess(AccessType type) { Q_UNUSED(type); return false; }
-    virtual QString GetSocName() { return ""; }
-    virtual bool ReadRegister(const QString& name, soc_word_t& value) 
-        { Q_UNUSED(name); Q_UNUSED(value); return false; }
-    virtual bool ReadRegister(soc_addr_t addr, soc_word_t& value) 
-        { Q_UNUSED(addr); Q_UNUSED(value); return false; }
-    virtual bool Reload() { return false; }
-    virtual bool IsReadOnly() { return true; }
-    virtual bool WriteRegister(const QString& name, soc_word_t value, WriteMode mode)
-        { Q_UNUSED(name); Q_UNUSED(value); Q_UNUSED(mode); return false; }
-    virtual bool WriteRegister(soc_addr_t addr, soc_word_t value, WriteMode mode)
-        { Q_UNUSED(addr); Q_UNUSED(value); Q_UNUSED(mode); return false; }
-    virtual bool IsDirty() { return false; }
-    virtual bool Commit() { return false; }
+    DummyIoBackend();
+
+    virtual bool IsValid();
+    virtual QString GetSocName();
+    virtual bool ReadRegister(soc_addr_t addr, soc_word_t& value, unsigned width);
+    virtual bool Reload();
+    virtual bool IsReadOnly();
+    virtual bool WriteRegister(soc_addr_t addr, soc_word_t value, unsigned width,
+        WriteMode mode);
+    virtual bool IsDirty();
+    virtual bool Commit();
 };
 
 /** The RAM backend doesn't have any backend storage and stores all values in
@@ -114,26 +96,22 @@ class RamIoBackend : public IoBackend
 public:
     RamIoBackend(const QString& soc_name = "");
 
-    virtual bool IsValid() { return m_soc != ""; }
-    virtual bool SupportAccess(AccessType type) { return type == ByName; }
-    virtual QString GetSocName() { return m_soc; }
-    virtual void SetSocName(const QString& soc_name) { m_soc = soc_name; }
-    virtual bool ReadRegister(const QString& name, soc_word_t& value);
-    virtual bool ReadRegister(soc_addr_t addr, soc_word_t& value)
-        { Q_UNUSED(addr); Q_UNUSED(value); return false; }
-    virtual bool Reload() { return false; }
-    virtual bool IsReadOnly() { return false; }
-    virtual bool WriteRegister(const QString& name, soc_word_t value, WriteMode mode);
-    virtual bool WriteRegister(soc_addr_t addr, soc_word_t value, WriteMode mode)
-        { Q_UNUSED(addr); Q_UNUSED(value); Q_UNUSED(mode); return false; }
-    virtual bool IsDirty() { return false; }
-    virtual bool Commit() { return false; }
+    virtual bool IsValid();
+    virtual QString GetSocName();
+    virtual void SetSocName(const QString& soc_name);
+    virtual bool ReadRegister(soc_addr_t addr, soc_word_t& value, unsigned width);
+    virtual bool Reload();
+    virtual bool IsReadOnly();
+    virtual bool WriteRegister(soc_addr_t addr, soc_word_t value, unsigned width,
+        WriteMode mode);
+    virtual bool IsDirty();
+    virtual bool Commit();
     /* clear all entries of the backend */
     virtual void DeleteAll();
 
 protected:
     QString m_soc;
-    QMap< QString, soc_word_t > m_map;
+    QMap< soc_addr_t, soc_word_t > m_map;
 };
 
 /** NOTE the File backend makes a difference between writes and commits:
@@ -144,14 +122,14 @@ class FileIoBackend : public RamIoBackend
 public:
     FileIoBackend(const QString& filename, const QString& soc_name = "");
 
-    virtual bool IsValid() { return m_valid; }
-    virtual bool SupportAccess(AccessType type) { return type == ByName; }
+    virtual bool IsValid();
     virtual bool Reload();
-    virtual bool IsReadOnly() { return m_readonly; }
-    virtual bool WriteRegister(const QString& name, soc_word_t value, WriteMode mode);
-    virtual bool IsDirty() { return m_dirty; }
+    virtual bool IsReadOnly();
+    virtual bool WriteRegister(soc_addr_t addr, soc_word_t value, unsigned width,
+        WriteMode mode);
+    virtual bool IsDirty();
     virtual bool Commit();
-    QString GetFileName() { return m_filename; }
+    QString GetFileName();
 
 protected:
     QString m_filename;
@@ -204,20 +182,16 @@ public:
     HWStubIoBackend(HWStubDevice *dev);
     virtual ~HWStubIoBackend();
 
-    virtual bool IsValid() { return m_dev->IsValid(); }
-    virtual bool SupportAccess(AccessType type) { return type == ByAddress; }
+    virtual bool IsValid();
     virtual QString GetSocName();
-    virtual bool ReadRegister(const QString& name, soc_word_t& value)
-        { Q_UNUSED(name); Q_UNUSED(value); return false; }
-    virtual bool ReadRegister(soc_addr_t addr, soc_word_t& value);
+    virtual bool ReadRegister(soc_addr_t addr, soc_word_t& value, unsigned width);
     virtual bool Reload();
-    virtual bool IsReadOnly() { return false; }
-    virtual bool WriteRegister(const QString& name, soc_word_t value, WriteMode mode)
-        { Q_UNUSED(name); Q_UNUSED(value); Q_UNUSED(mode); return false; }
-    virtual bool WriteRegister(soc_addr_t addr, soc_word_t value, WriteMode mode);
-    virtual bool IsDirty() { return false; }
-    virtual bool Commit() { return true; }
-    HWStubDevice *GetDevice() { return m_dev; }
+    virtual bool IsReadOnly();
+    virtual bool WriteRegister(soc_addr_t addr, soc_word_t value, unsigned width,
+        WriteMode mode);
+    virtual bool IsDirty();
+    virtual bool Commit();
+    HWStubDevice *GetDevice();
 
 protected:
     QString m_soc;
@@ -251,8 +225,6 @@ protected:
 };
 #endif
 
-class SocRef;
-
 class SocFile
 {
 public:
@@ -260,14 +232,14 @@ public:
     SocFile(const QString& filename);
     bool IsValid();
 
-    SocRef GetSocRef();
+    soc_desc::soc_ref_t GetSocRef();
     QString GetFilename();
-    soc_t& GetSoc() { return m_soc; }
+    soc_desc::soc_t& GetSoc() { return m_soc; }
 
 protected:
     bool m_valid;
     QString m_filename;
-    soc_t m_soc;
+    soc_desc::soc_t m_soc;
 };
 
 class SocFileRef
@@ -283,56 +255,17 @@ protected:
 
 Q_DECLARE_METATYPE(SocFileRef)
 
-class SocRef : public SocFileRef
-{
-public:
-    SocRef() {}
-    SocRef(SocFile *file):SocFileRef(file) {}
-    soc_t& GetSoc() const { return GetSocFile()->GetSoc(); }
-};
-
-Q_DECLARE_METATYPE(SocRef)
+Q_DECLARE_METATYPE(soc_desc::instance_t::type_t)
+Q_DECLARE_METATYPE(soc_desc::range_t::type_t)
 
-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; }
-    soc_dev_t& GetDev() const { return GetSoc().dev[GetDevIndex()]; }
-    int GetDevAddrIndex() const { return m_dev_addr_idx; }
-    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; }
-    soc_reg_t& GetReg() const { return GetDev().reg[GetRegIndex()]; }
-    int GetRegAddrIndex() const { return m_reg_addr_idx; }
-    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; }
-    soc_reg_field_t& GetField() const { return GetReg().field[GetFieldIndex()]; }
-protected:
-    int m_field_idx;
-};
+Q_DECLARE_METATYPE(soc_desc::soc_ref_t)
+Q_DECLARE_METATYPE(soc_desc::node_ref_t)
+Q_DECLARE_METATYPE(soc_desc::register_ref_t)
+Q_DECLARE_METATYPE(soc_desc::field_ref_t)
+Q_DECLARE_METATYPE(soc_desc::node_inst_t)
 
+/** NOTE the Backend stores soc descriptions in a way that pointers are never
+ * invalidated */
 class Backend : public QObject
 {
     Q_OBJECT
@@ -340,7 +273,7 @@ public:
     Backend();
 
     QList< SocFileRef > GetSocFileList();
-    QList< SocRef > GetSocList();
+    QList< soc_desc::soc_ref_t > GetSocList();
     bool LoadSocDesc(const QString& filename);
     IoBackend *CreateDummyIoBackend();
     IoBackend *CreateFileIoBackend(const QString& filename);
@@ -349,33 +282,38 @@ public:
 #endif
 
 signals:
-    void OnSocListChanged();
+    void OnSocAdded(const SocFileRef& ref);
+
 private:
+    /* store them as a list so that pointers are never invalidated */
     std::list< SocFile > m_socs;
 };
 
 class BackendHelper
 {
 public:
-    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,
+    BackendHelper(IoBackend *io_backend, const soc_desc::soc_ref_t& soc);
+    QString GetPath(const soc_desc::node_inst_t& inst);
+    soc_desc::node_inst_t ParsePath(const QString& path);
+    bool ReadRegister(const soc_desc::node_inst_t& inst, soc_word_t& v);
+    bool ReadRegisterField(const soc_desc::node_inst_t& inst,
         const QString& field, soc_word_t& v);
-    bool WriteRegister(const QString& dev, const QString& reg, soc_word_t v,
+    bool WriteRegister(const soc_desc::node_inst_t& inst, soc_word_t v,
         IoBackend::WriteMode mode = IoBackend::Write);
-    bool GetDevRef(const QString& dev, SocDevRef& ref);
-    bool GetRegRef(const SocDevRef& dev, const QString& reg, SocRegRef& ref);
-    bool GetFieldRef(const SocRegRef& reg, const QString& field, SocFieldRef& ref);
-    bool GetRegisterAddress(const QString& dev, const QString& reg, soc_addr_t& addr);
+    bool GetRegisterAddress(const soc_desc::node_inst_t& inst, soc_addr_t& addr);
     /* NOTE: does not commit writes to the backend
      * if ignore_errors is true, the dump will continue even on errors, and the
      * function will return false if one or more errors occured */
     bool DumpAllRegisters(IoBackend *backend, bool ignore_errors = true);
     bool DumpAllRegisters(const QString& filename, bool ignore_errors = true);
 
+protected:
+    bool DumpAllRegisters(BackendHelper *bh, const soc_desc::node_inst_t& inst,
+        bool ignore_errors);
+
 private:
     IoBackend *m_io_backend;
-    const SocRef& m_soc;
+    const soc_desc::soc_ref_t& m_soc;
 };
 
 #endif /* __BACKEND_H__ */