1cada1f833
Fix qeditor to use the old soc_desc_v1. Port hwstub_shell to the new description format. Change-Id: I9fefbff534bfaa5c3603bb3dd8307a2b76e88cfc
381 lines
12 KiB
C++
381 lines
12 KiB
C++
/***************************************************************************
|
|
* __________ __ ___.
|
|
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
|
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
|
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
|
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
|
* \/ \/ \/ \/ \/
|
|
* $Id$
|
|
*
|
|
* Copyright (C) 2014 by Amaury Pouly
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
* KIND, either express or implied.
|
|
*
|
|
****************************************************************************/
|
|
#ifndef __BACKEND_H__
|
|
#define __BACKEND_H__
|
|
|
|
#include <QObject>
|
|
#include <QStringList>
|
|
#include <QMap>
|
|
#include <QVector>
|
|
#include <QMetaType>
|
|
#ifdef HAVE_HWSTUB
|
|
#include "hwstub.h"
|
|
#endif
|
|
#include "soc_desc_v1.hpp"
|
|
|
|
/* we don't want to import the entire soc_desc except for a few selected
|
|
* pieces */
|
|
using namespace soc_desc_v1;
|
|
|
|
class IoBackend : public QObject
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
IoBackend() {}
|
|
virtual ~IoBackend() {}
|
|
|
|
enum WriteMode
|
|
{
|
|
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;
|
|
/* 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
|
|
* 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,
|
|
WriteMode mode = Write) = 0;
|
|
/* check whether backend contains uncommitted (ie cached) writes */
|
|
virtual bool IsDirty() = 0;
|
|
/* commit all writes */
|
|
virtual bool Commit() = 0;
|
|
};
|
|
|
|
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; }
|
|
};
|
|
|
|
/** The RAM backend doesn't have any backend storage and stores all values in
|
|
* an associative map */
|
|
class RamIoBackend : public IoBackend
|
|
{
|
|
Q_OBJECT
|
|
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; }
|
|
/* clear all entries of the backend */
|
|
virtual void DeleteAll();
|
|
|
|
protected:
|
|
QString m_soc;
|
|
QMap< QString, soc_word_t > m_map;
|
|
};
|
|
|
|
/** NOTE the File backend makes a difference between writes and commits:
|
|
* a write will *never* touch the underlying file unless it was committed. */
|
|
class FileIoBackend : public RamIoBackend
|
|
{
|
|
Q_OBJECT
|
|
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 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 Commit();
|
|
QString GetFileName() { return m_filename; }
|
|
|
|
protected:
|
|
QString m_filename;
|
|
bool m_readonly;
|
|
bool m_dirty;
|
|
bool m_valid;
|
|
};
|
|
|
|
#ifdef HAVE_HWSTUB
|
|
class HWStubDevice
|
|
{
|
|
public:
|
|
HWStubDevice(struct libusb_device *dev);
|
|
HWStubDevice(const HWStubDevice *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; }
|
|
inline struct hwstub_pp_desc_t GetPPInfo() { return m_hwdev_pp; }
|
|
/* Calls below require the device to be opened */
|
|
bool ReadMem(soc_addr_t addr, size_t length, void *buffer);
|
|
bool WriteMem(soc_addr_t addr, size_t length, void *buffer);
|
|
|
|
protected:
|
|
bool Probe();
|
|
void Init(struct libusb_device *dev);
|
|
|
|
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;
|
|
struct hwstub_pp_desc_t m_hwdev_pp;
|
|
};
|
|
|
|
/** NOTE the HWStub backend is never dirty: all writes are immediately committed */
|
|
class HWStubIoBackend : public IoBackend
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
// NOTE: HWStubIoBackend takes ownership of the device and will delete it
|
|
HWStubIoBackend(HWStubDevice *dev);
|
|
virtual ~HWStubIoBackend();
|
|
|
|
virtual bool IsValid() { return m_dev->IsValid(); }
|
|
virtual bool SupportAccess(AccessType type) { return type == ByAddress; }
|
|
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 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; }
|
|
|
|
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 SocRef;
|
|
|
|
class SocFile
|
|
{
|
|
public:
|
|
SocFile();
|
|
SocFile(const QString& filename);
|
|
bool IsValid();
|
|
|
|
SocRef GetSocRef();
|
|
QString GetFilename();
|
|
soc_t& GetSoc() { return m_soc; }
|
|
|
|
protected:
|
|
bool m_valid;
|
|
QString m_filename;
|
|
soc_t m_soc;
|
|
};
|
|
|
|
class SocFileRef
|
|
{
|
|
public:
|
|
SocFileRef():m_socfile(0) {}
|
|
SocFileRef(SocFile *file):m_socfile(file) {}
|
|
SocFile *GetSocFile() const { return m_socfile; }
|
|
|
|
protected:
|
|
SocFile *m_socfile;
|
|
};
|
|
|
|
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)
|
|
|
|
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;
|
|
};
|
|
|
|
class Backend : public QObject
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
Backend();
|
|
|
|
QList< SocFileRef > GetSocFileList();
|
|
QList< SocRef > GetSocList();
|
|
bool LoadSocDesc(const QString& filename);
|
|
IoBackend *CreateDummyIoBackend();
|
|
IoBackend *CreateFileIoBackend(const QString& filename);
|
|
#ifdef HAVE_HWSTUB
|
|
IoBackend *CreateHWStubIoBackend(HWStubDevice *dev);
|
|
#endif
|
|
|
|
signals:
|
|
void OnSocListChanged();
|
|
private:
|
|
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,
|
|
const QString& field, soc_word_t& v);
|
|
bool WriteRegister(const QString& dev, const QString& reg, 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);
|
|
/* 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);
|
|
|
|
private:
|
|
IoBackend *m_io_backend;
|
|
const SocRef& m_soc;
|
|
};
|
|
|
|
#endif /* __BACKEND_H__ */
|