6 files changed, 486 insertions, 41 deletions

diff --git a/utils/regtools/qeditor/backend.cpp b/utils/regtools/qeditor/backend.cpp
index e011965..d2b75be 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 536eb8c..55f31cc 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 0e4e67b..576d3a1 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 4e25a48..5604fe9 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 4f7a73c..8f64bbf 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 7ec8c90..d570eb6 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);