utils/regtools: make qeditor able to poke directly at a hwstub device

This commit add the very handy feature of being able to read registers
directly from a device using hwstub. This is mostly trivial using the hwstub
library and the biggest change here is actually:
- being able to read registers by name and/or addresses
- being able to enumerate devives
The UI code currently doesn't handle hotplug but the backend does so it should
be trivial to add in the future. It also opens up the possibility the write
registers from hwstub or save the register values to a file.
Since it relies on both hwstub and libusb, a switch has been introduced in
qmake to disable it (use -config nohwstub).

Change-Id: I5d7d7a2a7c97ecd7407227357c8553c2773ea6cc

6 files changed, 486 insertions, 41 deletions

diff --git a/utils/regtools/qeditor/backend.cpp b/utils/regtools/qeditor/backend.cpp
index e011965bd2..d2b75be701 100644
--- a/utils/regtools/qeditor/backend.cpp
+++ b/utils/regtools/qeditor/backend.cpp
@@ -3,6 +3,10 @@
 #include <QDebug>
 #include "backend.h"
 
+/**
+ * Backend
+ */
+
 Backend::Backend()
 {
 }
@@ -43,9 +47,16 @@ IoBackend *Backend::CreateDummyIoBackend()
     return new DummyIoBackend();
 }
 
-IoBackend::IoBackend()
+#ifdef HAVE_HWSTUB
+IoBackend *Backend::CreateHWStubIoBackend(HWStubDevice *dev)
 {
+    return new HWStubIoBackend(dev);
 }
+#endif
+
+/**
+ * FileIoBackend
+ */
 
 FileIoBackend::FileIoBackend(const QString& filename)
 {
@@ -91,27 +102,230 @@ bool FileIoBackend::Reload()
     return true;
 }
 
-DummyIoBackend::DummyIoBackend()
+#ifdef HAVE_HWSTUB
+/**
+ * HWStubDevice
+ */
+HWStubDevice::HWStubDevice(struct libusb_device *dev)
 {
+    libusb_ref_device(dev);
+    m_dev = dev;
+    m_handle = 0;
+    m_hwdev = 0;
+    m_valid = Probe();
 }
 
-QString DummyIoBackend::GetSocName()
+HWStubDevice::~HWStubDevice()
 {
-    return "";
+    Close();
+    libusb_unref_device(m_dev);
 }
 
-bool DummyIoBackend::ReadRegister(const QString& name, soc_word_t& value)
+int HWStubDevice::GetBusNumber()
 {
-    (void) name;
-    (void) value;
+    return libusb_get_bus_number(m_dev);
+}
+
+int HWStubDevice::GetDevAddress()
+{
+    return libusb_get_device_address(m_dev);
+}
+
+bool HWStubDevice::Probe()
+{
+    struct libusb_device_descriptor desc;
+    if(libusb_get_device_descriptor(m_dev, &desc))
+        return false;
+    if(desc.idVendor != HWSTUB_USB_VID || desc.idProduct != HWSTUB_USB_PID)
+        return false;
+    if(!Open())
+        return false;
+    int ret = hwstub_get_desc(m_hwdev, HWSTUB_DT_VERSION, &m_hwdev_ver, sizeof(m_hwdev_ver));
+    if(ret != sizeof(m_hwdev_ver))
+        goto Lerr;
+    if(m_hwdev_ver.bMajor != HWSTUB_VERSION_MAJOR || m_hwdev_ver.bMinor < HWSTUB_VERSION_MINOR)
+        goto Lerr;
+    // get target
+    ret = hwstub_get_desc(m_hwdev, HWSTUB_DT_TARGET, &m_hwdev_target, sizeof(m_hwdev_target));
+    if(ret != sizeof(m_hwdev_target))
+        goto Lerr;
+    // get STMP information
+    if(m_hwdev_target.dID == HWSTUB_TARGET_STMP)
+    {
+        ret = hwstub_get_desc(m_hwdev, HWSTUB_DT_STMP, &m_hwdev_stmp, sizeof(m_hwdev_stmp));
+        if(ret != sizeof(m_hwdev_stmp))
+            goto Lerr;
+    }
+    Close();
+    return true;
+
+    Lerr:
+    Close();
     return false;
 }
 
-bool DummyIoBackend::Reload()
+bool HWStubDevice::Open()
+{
+    if(libusb_open(m_dev, &m_handle))
+        return false;
+    m_hwdev = hwstub_open(m_handle);
+    if(m_hwdev == 0)
+    {
+        libusb_close(m_handle);
+        return false;
+    }
+    return true;
+}
+
+void HWStubDevice::Close()
+{
+    if(m_hwdev)
+        hwstub_release(m_hwdev);
+    m_hwdev = 0;
+    if(m_handle)
+        libusb_close(m_handle);
+    m_handle = 0;
+}
+
+bool HWStubDevice::ReadMem(soc_addr_t addr, size_t length, void *buffer)
+{
+    if(!m_hwdev)
+        return false;
+    int ret = hwstub_rw_mem(m_hwdev, 1, addr, buffer, length);
+    return ret >= 0 && (size_t)ret == length;
+}
+
+bool HWStubDevice::IsValid()
+{
+    return m_valid;
+}
+
+
+/**
+ * HWStubIoBackend
+ */
+
+HWStubIoBackend::HWStubIoBackend(HWStubDevice *dev)
+{
+    m_dev = dev;
+    m_dev->Open();
+    struct hwstub_target_desc_t target = m_dev->GetTargetInfo();
+    if(target.dID == HWSTUB_TARGET_STMP)
+    {
+        struct hwstub_stmp_desc_t stmp = m_dev->GetSTMPInfo();
+        if(stmp.wChipID == 0x3780)
+            m_soc = "imx233";
+        else if(stmp.wChipID >= 0x3700 && stmp.wChipID < 0x3780)
+            m_soc = "stmp3700";
+        else if(stmp.wChipID >= 0x3600 && stmp.wChipID < 0x3700)
+            m_soc = "stmp3600";
+        else
+            m_soc = QString("stmp%1").arg(stmp.wChipID, 4, 16, QChar('0'));
+    }
+    else if(target.dID == HWSTUB_TARGET_RK27)
+        m_soc = "rk27x";
+    else
+        m_soc = target.bName;
+}
+
+QString HWStubIoBackend::GetSocName()
+{
+    return m_soc;
+}
+
+HWStubIoBackend::~HWStubIoBackend()
+{
+    m_dev->Close();
+}
+
+bool HWStubIoBackend::ReadRegister(soc_addr_t addr, soc_word_t& value)
+{
+    return m_dev->ReadMem(addr, sizeof(value), &value);
+}
+
+bool HWStubIoBackend::Reload()
 {
     return true;
 }
 
+/**
+ * HWStubBackendHelper
+ */
+HWStubBackendHelper::HWStubBackendHelper()
+{
+    libusb_init(NULL);
+#ifdef LIBUSB_NO_HOTPLUG
+    m_hotplug = false;
+#else
+    m_hotplug = libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG);
+    if(m_hotplug)
+    {
+        m_hotplug = LIBUSB_SUCCESS == libusb_hotplug_register_callback(
+            NULL, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT,
+            LIBUSB_HOTPLUG_ENUMERATE, HWSTUB_USB_VID, HWSTUB_USB_PID, HWSTUB_CLASS,
+            &HWStubBackendHelper::HotPlugCallback, reinterpret_cast< void* >(this), &m_hotplug_handle);
+    }
+#endif
+}
+
+HWStubBackendHelper::~HWStubBackendHelper()
+{
+#ifndef LIBUSB_NO_HOTPLUG
+    if(m_hotplug)
+        libusb_hotplug_deregister_callback(NULL, m_hotplug_handle);
+#endif
+}
+
+QList< HWStubDevice* > HWStubBackendHelper::GetDevList()
+{
+    QList< HWStubDevice* > list;
+    libusb_device **dev_list;
+    ssize_t cnt = libusb_get_device_list(NULL, &dev_list);
+    for(int i = 0; i < cnt; i++)
+    {
+        HWStubDevice *dev = new HWStubDevice(dev_list[i]);
+        /* filter out non-hwstub devices */
+        if(dev->IsValid())
+            list.push_back(dev);
+        else
+            delete dev;
+    }
+    libusb_free_device_list(dev_list, 1);
+    return list;
+}
+
+#ifndef LIBUSB_NO_HOTPLUG
+void HWStubBackendHelper::OnHotPlug(bool arrived, struct libusb_device *dev)
+{
+    /* signal it */
+    emit OnDevListChanged(arrived, dev);
+}
+
+int HWStubBackendHelper::HotPlugCallback(struct libusb_context *ctx, struct libusb_device *dev,
+    libusb_hotplug_event event, void *user_data)
+{
+    HWStubBackendHelper *helper = reinterpret_cast< HWStubBackendHelper* >(user_data);
+    switch(event)
+    {
+        case LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED: helper->OnHotPlug(true, dev); break;
+        case LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT: helper->OnHotPlug(false, dev); break;
+        default: break;
+    }
+    return 0;
+}
+#endif
+
+bool HWStubBackendHelper::HasHotPlugSupport()
+{
+    return m_hotplug;
+}
+
+#endif
+
+/**
+ * BackendHelper
+ */
+
 BackendHelper::BackendHelper(IoBackend *io_backend, const soc_t& soc)
     :m_io_backend(io_backend), m_soc(soc)
 {
@@ -119,38 +333,87 @@ BackendHelper::BackendHelper(IoBackend *io_backend, const soc_t& soc)
 
 bool BackendHelper::ReadRegister(const QString& dev, const QString& reg, soc_word_t& v)
 {
-    return m_io_backend->ReadRegister("HW." + dev + "." + reg, v);
+    if(m_io_backend->SupportAccess(IoBackend::ByName))
+        return m_io_backend->ReadRegister("HW." + dev + "." + reg, v);
+    if(m_io_backend->SupportAccess(IoBackend::ByAddress))
+    {
+        soc_addr_t addr;
+        if(GetRegisterAddress(dev, reg, addr))
+            return m_io_backend->ReadRegister(addr, v);
+    }
+    return false;
 }
 
-bool BackendHelper::ReadRegisterField(const QString& dev, const QString& reg,
-    const QString& field, soc_word_t& v)
+
+bool BackendHelper::GetDeviceDesc(const QString& dev, soc_dev_t& dev_desc, size_t& index)
 {
-    soc_dev_t *sdev = 0;
     for(size_t i = 0; i < m_soc.dev.size(); i++)
     {
         for(size_t j = 0; j < m_soc.dev[i].addr.size(); j++)
             if(m_soc.dev[i].addr[j].name.c_str() == dev)
-                sdev = &m_soc.dev[i];
+            {
+                dev_desc = m_soc.dev[i];
+                index = j;
+                return true;
+            }
     }
-    if(sdev == 0)
-        return false;
-    soc_reg_t *sreg = 0;
-    for(size_t i = 0; i < sdev->reg.size(); i++)
+    return false;
+}
+
+bool BackendHelper::GetRegisterDesc(const soc_dev_t& dev, const QString& reg,
+    soc_reg_t& reg_desc, size_t& index)
+{
+    for(size_t i = 0; i < dev.reg.size(); i++)
     {
-        for(size_t j = 0; j < sdev->reg[i].addr.size(); j++)
-            if(sdev->reg[i].addr[j].name.c_str() == reg)
-                sreg = &sdev->reg[i];
+        for(size_t j = 0; j < dev.reg[i].addr.size(); j++)
+            if(dev.reg[i].addr[j].name.c_str() == reg)
+            {
+                index = j;
+                reg_desc = dev.reg[i];
+                return true;
+            }
     }
-    if(sreg == 0)
+    return false;
+}
+
+bool BackendHelper::GetFieldDesc(const soc_reg_t& reg_desc, const QString& field,
+    soc_reg_field_t& field_desc)
+{
+    for(size_t i = 0; i < reg_desc.field.size(); i++)
+        if(reg_desc.field[i].name.c_str() == field)
+            field_desc = reg_desc.field[i];
+    return false;
+}
+
+bool BackendHelper::GetRegisterAddress(const QString& dev, const QString& reg,
+    soc_addr_t& addr)
+{
+    size_t dev_index, reg_index;
+    soc_dev_t dev_desc;
+    soc_reg_t reg_desc;
+    if(!GetDeviceDesc(dev, dev_desc, dev_index))
+        return false;
+    if(!GetRegisterDesc(dev_desc, reg, reg_desc, reg_index))
+        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;
+    soc_dev_t dev_desc;
+    soc_reg_t reg_desc;
+    soc_reg_field_t field_desc;
+    if(!GetDeviceDesc(dev, dev_desc, dev_index))
+        return false;
+    if(!GetRegisterDesc(dev_desc, reg, reg_desc, reg_index))
         return false;
-    soc_reg_field_t *sfield = 0;
-    for(size_t i = 0; i < sreg->field.size(); i++)
-        if(sreg->field[i].name.c_str() == field)
-            sfield = &sreg->field[i];
-    if(sfield == 0)
+    if(!GetFieldDesc(reg_desc, field, field_desc))
         return false;
     if(!ReadRegister(dev, reg, v))
         return false;
-    v = (v & sfield->bitmask()) >> sfield->first_bit;
+    v = (v & field_desc.bitmask()) >> field_desc.first_bit;
     return true;
 }
\ No newline at end of file
diff --git a/utils/regtools/qeditor/backend.h b/utils/regtools/qeditor/backend.h
index 536eb8cec5..55f31cce52 100644
--- a/utils/regtools/qeditor/backend.h
+++ b/utils/regtools/qeditor/backend.h
@@ -4,16 +4,29 @@
 #include <QObject>
 #include <QStringList>
 #include <QMap>
+#include <QVector>
 #include "soc_desc.hpp"
+#ifdef HAVE_HWSTUB
+#include "hwstub.h"
+#endif
 
 class IoBackend : public QObject
 {
     Q_OBJECT
 public:
-    IoBackend();
+    IoBackend() {}
+    virtual ~IoBackend() {}
 
+    enum AccessType
+    {
+        ByName,
+        ByAddress,
+    };
+
+    virtual bool SupportAccess(AccessType type) = 0;
     virtual QString GetSocName() = 0;
     virtual bool ReadRegister(const QString& name, soc_word_t& value) = 0;
+    virtual bool ReadRegister(soc_addr_t addr, soc_word_t& value) = 0;
     virtual bool Reload() = 0;
 };
 
@@ -21,11 +34,15 @@ class DummyIoBackend : public IoBackend
 {
     Q_OBJECT
 public:
-    DummyIoBackend();
+    DummyIoBackend() {}
 
-    virtual QString GetSocName();
-    virtual bool ReadRegister(const QString& name, soc_word_t& value);
-    virtual bool Reload();
+    virtual bool SupportAccess(AccessType type) { (void) type; return false; }
+    virtual QString GetSocName() { return ""; }
+    virtual bool ReadRegister(const QString& name, soc_word_t& value) 
+        { (void) name; (void) value; return false; }
+    virtual bool ReadRegister(soc_addr_t addr, soc_word_t& value) 
+        { (void) addr; (void) value; return false; }
+    virtual bool Reload() { return false; }
 };
 
 class FileIoBackend : public IoBackend
@@ -34,8 +51,11 @@ class FileIoBackend : public IoBackend
 public:
     FileIoBackend(const QString& filename);
 
+    virtual bool SupportAccess(AccessType type) { return type == ByName; }
     virtual QString GetSocName();
     virtual bool ReadRegister(const QString& name, soc_word_t& value);
+    virtual bool ReadRegister(soc_addr_t addr, soc_word_t& value)
+        { (void) addr; (void) value; return false; }
     virtual bool Reload();
 
 protected:
@@ -44,6 +64,82 @@ protected:
     QMap< QString, soc_word_t > m_map;
 };
 
+#ifdef HAVE_HWSTUB
+class HWStubDevice
+{
+public:
+    HWStubDevice(struct libusb_device *dev);
+    ~HWStubDevice();
+    bool IsValid();
+    bool Open();
+    void Close();
+    int GetBusNumber();
+    int GetDevAddress();
+    /* Calls below are cached and do not require the device to be opened */
+    inline struct hwstub_version_desc_t GetVersionInfo() { return m_hwdev_ver; }
+    inline struct hwstub_target_desc_t GetTargetInfo() { return m_hwdev_target; }
+    inline struct hwstub_stmp_desc_t GetSTMPInfo() { return m_hwdev_stmp; }
+    /* Calls below require the device to be opened */
+    bool ReadMem(soc_addr_t addr, size_t length, void *buffer);
+
+protected:
+    bool Probe();
+
+    bool m_valid;
+    struct libusb_device *m_dev;
+    libusb_device_handle *m_handle;
+    struct hwstub_device_t *m_hwdev;
+    struct hwstub_version_desc_t m_hwdev_ver;
+    struct hwstub_target_desc_t m_hwdev_target;
+    struct hwstub_stmp_desc_t m_hwdev_stmp;
+};
+
+class HWStubIoBackend : public IoBackend
+{
+    Q_OBJECT
+public:
+    HWStubIoBackend(HWStubDevice *dev);
+    virtual ~HWStubIoBackend();
+
+    virtual bool SupportAccess(AccessType type) { return type == ByAddress; }
+    virtual QString GetSocName();
+    virtual bool ReadRegister(const QString& name, soc_word_t& value)
+        { (void) name; (void) value; return false; }
+    virtual bool ReadRegister(soc_addr_t addr, soc_word_t& value);
+    virtual bool Reload();
+
+protected:
+    QString m_soc;
+    HWStubDevice *m_dev;
+};
+
+#if LIBUSB_API_VERSION < 0x01000102
+#define LIBUSB_NO_HOTPLUG
+#endif
+
+class HWStubBackendHelper : public QObject
+{
+    Q_OBJECT
+public:
+    HWStubBackendHelper();
+    ~HWStubBackendHelper();
+    bool HasHotPlugSupport();
+    QList< HWStubDevice* > GetDevList();
+
+signals:
+    void OnDevListChanged(bool arrived, struct libusb_device *dev);
+
+protected:
+#ifndef LIBUSB_NO_HOTPLUG
+    void OnHotPlug(bool arrived, struct libusb_device *dev);
+    static int HotPlugCallback(struct libusb_context *ctx, struct libusb_device *dev,
+        libusb_hotplug_event event, void *user_data);
+    libusb_hotplug_callback_handle m_hotplug_handle;
+#endif
+    bool m_hotplug;
+};
+#endif
+
 class Backend : public QObject
 {
     Q_OBJECT
@@ -55,6 +151,9 @@ public:
     bool GetSocByName(const QString& name, soc_t& s);
     IoBackend *CreateDummyIoBackend();
     IoBackend *CreateFileIoBackend(const QString& filename);
+#ifdef HAVE_HWSTUB
+    IoBackend *CreateHWStubIoBackend(HWStubDevice *dev);
+#endif
 
 signals:
     void OnSocListChanged();
@@ -69,6 +168,10 @@ public:
     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 GetRegisterDesc(const soc_dev_t& dev, const QString& reg, soc_reg_t& reg_desc, size_t& index);
+    bool GetFieldDesc(const soc_reg_t& reg_desc, const QString& field, soc_reg_field_t& field_desc);
+    bool GetRegisterAddress(const QString& dev, const QString& reg, soc_addr_t& addr);
 private:
     IoBackend *m_io_backend;
     soc_t m_soc;
diff --git a/utils/regtools/qeditor/main.cpp b/utils/regtools/qeditor/main.cpp
index 0e4e67bfb7..576d3a16fc 100644
--- a/utils/regtools/qeditor/main.cpp
+++ b/utils/regtools/qeditor/main.cpp
@@ -6,25 +6,24 @@ int main(int argc, char *argv[])
 {
     QApplication app(argc, argv);
 
-    Backend *backend = new Backend;
+    Backend backend;;
     QDir dir(QCoreApplication::applicationDirPath());
     dir.cdUp();
     dir.cd("desc");
     dir.setFilter(QDir::Files);
-    printf("%s\n", dir.absolutePath().toStdString().c_str());
     QFileInfoList list = dir.entryInfoList();
     for(int i = 0; i < list.size(); i++)
     {
         QFileInfo fileInfo = list.at(i);
         if(fileInfo.fileName().right(4) != ".xml" || fileInfo.fileName().left(5) != "regs-")
             continue;
-        backend->LoadSocDesc(fileInfo.absoluteFilePath());
+        backend.LoadSocDesc(fileInfo.absoluteFilePath());
     }
 
     QCoreApplication::setOrganizationName("Rockbox");
     QCoreApplication::setApplicationName("Register Editor");
     QCoreApplication::setOrganizationDomain("rockbox.org");
-    MainWindow win(backend);
+    MainWindow win(&backend);
     win.show();
     return app.exec();
 } 
diff --git a/utils/regtools/qeditor/qeditor.pro b/utils/regtools/qeditor/qeditor.pro
index 4e25a48d89..5604fe9d41 100644
--- a/utils/regtools/qeditor/qeditor.pro
+++ b/utils/regtools/qeditor/qeditor.pro
@@ -3,6 +3,16 @@ QT += widgets
 HEADERS += mainwindow.h backend.h regtab.h analyser.h settings.h std_analysers.h
 SOURCES += main.cpp mainwindow.cpp regtab.cpp backend.cpp analyser.cpp std_analysers.cpp settings.cpp 
 LIBS += -L../lib/ -lsocdesc -lxml2
-INCLUDEPATH += ../lib/
+INCLUDEPATH += ../lib/ ../../hwstub/lib
 
-CONFIG += debug
\ No newline at end of file
+unix {
+    !nohwstub {
+        message("Use 'qmake -config nohwstub' if you want to disable hwstub support")
+        LIBS += -L../../hwstub/lib -lhwstub
+        DEFINES += HAVE_HWSTUB
+        CONFIG += link_pkgconfig
+        PKGCONFIG += libusb-1.0
+    }
+}
+
+CONFIG += debug
diff --git a/utils/regtools/qeditor/regtab.cpp b/utils/regtools/qeditor/regtab.cpp
index 4f7a73cffc..8f64bbf48a 100644
--- a/utils/regtools/qeditor/regtab.cpp
+++ b/utils/regtools/qeditor/regtab.cpp
@@ -13,6 +13,7 @@
 #include <QTableWidget>
 #include <QHeaderView>
 #include <QFileDialog>
+#include <QDebug>
 #include "backend.h"
 #include "analyser.h"
 
@@ -65,6 +66,9 @@ RegTab::RegTab(Backend *backend, QTabWidget *parent)
     m_data_selector = new QComboBox;
     m_data_selector->addItem(QIcon::fromTheme("face-sad"), "None", QVariant(DataSelNothing));
     m_data_selector->addItem(QIcon::fromTheme("document-open"), "File...", QVariant(DataSelFile));
+#ifdef HAVE_HWSTUB
+    m_data_selector->addItem(QIcon::fromTheme("multimedia-player"), "Device...", QVariant(DataSelDevice));
+#endif
     m_data_sel_edit = new QLineEdit;
     m_data_sel_edit->setReadOnly(true);
     m_data_soc_label = new QLabel;
@@ -72,6 +76,10 @@ RegTab::RegTab(Backend *backend, QTabWidget *parent)
     data_sel_reload->setIcon(QIcon::fromTheme("view-refresh"));
     data_sel_layout->addWidget(m_data_selector);
     data_sel_layout->addWidget(m_data_sel_edit);
+#ifdef HAVE_HWSTUB
+    m_dev_selector = new QComboBox;
+    data_sel_layout->addWidget(m_dev_selector, 1);
+#endif
     data_sel_layout->addWidget(m_data_soc_label);
     data_sel_layout->addWidget(data_sel_reload);
     data_sel_group->setLayout(data_sel_layout);
@@ -107,6 +115,10 @@ RegTab::RegTab(Backend *backend, QTabWidget *parent)
         this, SLOT(OnAnalyserChanged(QListWidgetItem *, QListWidgetItem *)));
     connect(m_analysers_list, SIGNAL(itemClicked(QListWidgetItem *)), this,
         SLOT(OnAnalyserClicked(QListWidgetItem *)));
+#ifdef HAVE_HWSTUB
+    connect(m_dev_selector, SIGNAL(currentIndexChanged(int)),
+        this, SLOT(OnDevChanged(int)));
+#endif
 
     OnSocListChanged();
     OnDataSelChanged(DataSelNothing);
@@ -141,6 +153,10 @@ void RegTab::OnDataSelChanged(int index)
     QVariant var = m_data_selector->itemData(index);
     if(var == DataSelFile)
     {
+        m_data_sel_edit->show();
+#ifdef HAVE_HWSTUB
+        m_dev_selector->hide();
+#endif
         QFileDialog *fd = new QFileDialog(m_data_selector);
         fd->setFilter("Textual files (*.txt);;All files (*)");
         fd->setDirectory(Settings::Get()->value("regtab/loaddatadir", QDir::currentPath()).toString());
@@ -155,8 +171,20 @@ void RegTab::OnDataSelChanged(int index)
         }
         Settings::Get()->setValue("regtab/loaddatadir", fd->directory().absolutePath());
     }
+#ifdef HAVE_HWSTUB
+    else if(var == DataSelDevice)
+    {
+        m_data_sel_edit->hide();
+        m_dev_selector->show();
+        OnDevListChanged();
+    }
+#endif
     else
     {
+        m_data_sel_edit->show();
+#ifdef HAVE_HWSTUB
+        m_dev_selector->hide();
+#endif
         delete m_io_backend;
         m_io_backend = m_backend->CreateDummyIoBackend();
         SetDataSocName("");
@@ -204,7 +232,7 @@ void RegTab::OnAnalyserClicked(QListWidgetItem *current)
     delete m_right_content;
     AnalyserFactory *ana = AnalyserFactory::GetAnalyserByName(current->text());
     m_right_content = ana->Create(m_cur_soc, m_io_backend)->GetWidget();
-    m_right_panel->addWidget(m_right_content);
+    m_right_panel->addWidget(m_right_content, 1);
 }
 
 void RegTab::DisplayRegister(soc_dev_t& dev, soc_dev_addr_t& dev_addr,
@@ -256,8 +284,8 @@ void RegTab::DisplayRegister(soc_dev_t& dev, soc_dev_addr_t& dev_addr,
     top_layout->addStretch();
 
     soc_word_t value;
-    bool has_value = m_io_backend->ReadRegister(QString().sprintf("HW.%s.%s",
-        dev_addr.name.c_str(), reg_addr.name.c_str()), value);
+    BackendHelper helper(m_io_backend, m_cur_soc);
+    bool has_value = helper.ReadRegister(dev_addr.name.c_str(), reg_addr.name.c_str(), value);
 
     QHBoxLayout *raw_val_layout = 0;
     if(has_value)
@@ -348,6 +376,37 @@ void RegTab::OnSocListChanged()
         m_soc_selector->addItem(socs[i]);
 }
 
+#ifdef HAVE_HWSTUB
+void RegTab::OnDevListChanged()
+{
+    m_dev_selector->clear();
+    QList< HWStubDevice* > list = m_hwstub_helper.GetDevList();
+    foreach(HWStubDevice *dev, list)
+    {
+        QString name = QString("Bus %1 Device %2: %3").arg(dev->GetBusNumber())
+            .arg(dev->GetDevAddress()).arg(dev->GetTargetInfo().bName);
+        m_dev_selector->addItem(QIcon::fromTheme("multimedia-player"), name,
+            QVariant::fromValue((void *)dev));
+    }
+    if(list.size() > 0)
+        m_dev_selector->setCurrentIndex(0);
+    else
+        SetDataSocName("");
+}
+
+void RegTab::OnDevChanged(int index)
+{
+    if(index == -1)
+        return;
+    HWStubDevice *dev = reinterpret_cast< HWStubDevice* >(m_dev_selector->itemData(index).value< void* >());
+    delete m_io_backend;
+    m_io_backend = m_backend->CreateHWStubIoBackend(dev);
+    SetDataSocName(m_io_backend->GetSocName());
+    OnDataSocActivated(m_io_backend->GetSocName());
+    OnDataChanged();
+}
+#endif
+
 void RegTab::FillDevSubTree(RegTreeItem *item)
 {
     soc_dev_t& sd = m_cur_soc.dev[item->GetDevIndex()];
diff --git a/utils/regtools/qeditor/regtab.h b/utils/regtools/qeditor/regtab.h
index 7ec8c9009f..d570eb6f90 100644
--- a/utils/regtools/qeditor/regtab.h
+++ b/utils/regtools/qeditor/regtab.h
@@ -25,6 +25,9 @@ enum
 {
     DataSelNothing,
     DataSelFile,
+#ifdef HAVE_HWSTUB
+    DataSelDevice,
+#endif
 };
 
 class RegTreeItem : public QTreeWidgetItem
@@ -56,6 +59,10 @@ protected:
         soc_reg_t& reg, soc_reg_addr_t& reg_addr);
     void SetDataSocName(const QString& socname);
     QComboBox *m_soc_selector;
+#ifdef HAVE_HWSTUB
+    QComboBox *m_dev_selector;
+    HWStubBackendHelper m_hwstub_helper;
+#endif
     Backend *m_backend;
     QTreeWidget *m_reg_tree;
     soc_t m_cur_soc;
@@ -71,6 +78,10 @@ protected:
     QListWidget *m_analysers_list;
 
 private slots:
+#ifdef HAVE_HWSTUB
+    void OnDevListChanged();
+    void OnDevChanged(int index);
+#endif
     void OnSocChanged(const QString& text);
     void OnSocListChanged();
     void OnRegItemChanged(QTreeWidgetItem *current, QTreeWidgetItem *previous);