devs/foxbox
1
0
Fork 0
forked from len0rd/rockbox
Code Pull requests Activity

regtools/qeditor: rewrite soc handling

Browse source 
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
This commit is contained in:
Amaury Pouly 2014-02-09 02:13:53 +01:00
parent 8358707d82
commit 3d07706c05
8 changed files with 161 additions and 104 deletions
Download patch file Download diff file Expand all files Collapse all files

2
utils/regtools/qeditor/analyser.cpp
View file

@ -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)
{
}

10
utils/regtools/qeditor/analyser.h
View file

@ -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);
}

73
utils/regtools/qeditor/backend.cpp
View file

@ -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++)
if(m_soc.dev[i].addr[j].name.c_str() == dev)
const soc_dev_t& dev = m_soc.GetSoc().dev[i];
for(size_t j = 0; j < dev.addr.size(); j++)
if(dev.addr[j].name.c_str() == sdev)
{
dev_desc = m_soc.dev[i];
index = j;
ref = SocDevRef(m_soc, i, j);
return true;
}
}
return false;
}
bool BackendHelper::GetRegisterDesc(const soc_dev_t& dev, const QString& reg,
soc_reg_t& reg_desc, size_t& index)
bool BackendHelper::GetRegRef(const SocDevRef& dev, const QString& sreg, SocRegRef& ref)
{
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++)
if(dev.reg[i].addr[j].name.c_str() == reg)
const soc_reg_t& reg = sdev.reg[i];
for(size_t j = 0; j < reg.addr.size(); j++)
{
if(reg.addr[j].name.c_str() == sreg)
{
index = j;
reg_desc = dev.reg[i];
ref = SocRegRef(dev, i, j);
return true;
}
}
}
return false;
}
bool BackendHelper::GetFieldDesc(const soc_reg_t& reg_desc, const QString& field,
soc_reg_field_t& field_desc)
bool BackendHelper::GetFieldRef(const SocRegRef& reg, const QString& sfield, SocFieldRef& ref)
{
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];
for(size_t i = 0; i < reg.GetReg().field.size(); i++)
if(reg.GetReg().field[i].name.c_str() == sfield)
{
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;
soc_dev_t dev_desc;
soc_reg_t reg_desc;
if(!GetDeviceDesc(dev, dev_desc, dev_index))
SocDevRef dev_ref;
SocRegRef reg_ref;
if(!GetDevRef(dev, dev_ref) || !GetRegRef(dev_ref, reg, reg_ref))
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;
addr = dev_ref.GetDevAddr().addr + reg_ref.GetRegAddr().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;
if(!GetFieldDesc(reg_desc, field, field_desc))
SocDevRef dev_ref;
SocRegRef reg_ref;
SocFieldRef field_ref;
if(!GetDevRef(dev, dev_ref) || !GetRegRef(dev_ref, reg, reg_ref) ||
!GetFieldRef(reg_ref, field, field_ref))
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;
}

68
utils/regtools/qeditor/backend.h
View file

@ -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 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 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);
private:
IoBackend *m_io_backend;
soc_t m_soc;
const SocRef& m_soc;
};
#endif /* __BACKEND_H__ */

69
utils/regtools/qeditor/regtab.cpp
View file

@ -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,
soc_reg_t& reg, soc_reg_addr_t& reg_addr)
void RegTab::DisplayRegister(const SocRegRef& ref)
{
(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)
bits_str.sprintf("%d", reg.field[i].first_bit);
if(field.first_bit == field.last_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);
item = new QTableWidgetItem(QString(reg.field[i].name.c_str()));
value_table->setItem(row, 0, item);
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++)
if(v == field.value[j].value)
value_name = field.value[j].name.c_str();
foreach(const soc_reg_field_value_t& rval, field.value)
if(v == rval.value)
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()];
for(size_t i = 0; i < sd.reg.size(); i++)
const soc_dev_t& dev = item->GetRef().GetDev();
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);
reg_item->SetPath(item->GetDevIndex(), item->GetDevAddrIndex(), i, j);
RegTreeItem *reg_item = new RegTreeItem(reg.addr[j].name.c_str(),
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];
for(size_t j = 0; j < sd.addr.size(); j++)
const soc_dev_t& dev = m_cur_soc.GetSoc().dev[i];
for(size_t j = 0; j < dev.addr.size(); j++)
{
RegTreeItem *dev_item = new RegTreeItem(sd.addr[j].name.c_str(), RegTreeDevType);
dev_item->SetPath(i, j);
DevTreeItem *dev_item = new DevTreeItem(dev.addr[j].name.c_str(),
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)

31
utils/regtools/qeditor/regtab.h
View file

@ -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);
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; }
const SocRegRef& GetRef() { return m_ref; }
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,
soc_reg_t& reg, soc_reg_addr_t& reg_addr);
void DisplayRegister(const SocRegRef& ref);
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;

6
utils/regtools/qeditor/std_analysers.cpp
View file

@ -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");

6
utils/regtools/qeditor/std_analysers.h
View file

@ -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();