JtagDriver.h

Go to the documentation of this file.

 
#ifndef __ROGUE_PROTOCOLS_XILINX_JTAG_DRIVER_H__
#define __ROGUE_PROTOCOLS_XILINX_JTAG_DRIVER_H__
 
#include "rogue/Directives.h"
 
#include <inttypes.h>
#include <stdint.h>
#include <unistd.h>
 
#include <cerrno>
#include <cstdio>
#include <cstring>
#include <exception>
#include <memory>
#include <stdexcept>
#include <vector>
 
#include "rogue/GeneralError.h"
#include "rogue/Logging.h"
 
using std::vector;
 
namespace rogue {
namespace protocols {
namespace xilinx {
class JtagDriver {
  protected:
    // Remote port number
    uint16_t port_;
 
    // occasionally drop a packet for testing (when enabled)
    bool drEn_;
    bool done_;
    unsigned drop_;
 
    typedef uint32_t Header;
    typedef uint8_t Xid;
 
    static const Xid XID_ANY = 0;
 
    // Log
    std::shared_ptr<rogue::Logging> log_;
 
  private:
    unsigned wordSize_;
    unsigned memDepth_;
 
    vector<uint8_t> txBuf_;
    vector<uint8_t> hdBuf_;
 
    unsigned bufSz_;
    unsigned retry_;
 
    Xid xid_;
 
    uint32_t periodNs_;
 
    Header newXid();
 
    Header mkQuery();
    Header mkShift(unsigned len);
 
    virtual void setHdr(uint8_t* buf, Header hdr);
 
  protected:
    static Header getHdr(uint8_t* buf);
 
    static const Header PVERS = 0x00000000;
    static const Header CMD_Q = 0x00000000;
    static const Header CMD_S = 0x10000000;
    static const Header CMD_E = 0x20000000;
 
    static const Header CMD_MASK    = 0x30000000;
    static const unsigned ERR_SHIFT = 0;
    static const Header ERR_MASK    = 0x000000ff;
 
    static const unsigned XID_SHIFT = 20;
    static const unsigned LEN_SHIFT = 0;
    static const Header LEN_MASK    = 0x000fffff;
 
    static const unsigned ERR_BAD_VERSION = 1;
    static const unsigned ERR_BAD_COMMAND = 2;
    static const unsigned ERR_TRUNCATED   = 3;
    static const unsigned ERR_NOT_PRESENT = 4;
 
    static Xid getXid(Header x);
    static uint32_t getCmd(Header x);
    static unsigned getErr(Header x);
    static uint64_t getLen(Header x);
 
    // returns error message or NULL (unknown error)
    static const char* getMsg(unsigned error);
 
    // extract from message header
    unsigned wordSize(Header reply);
    unsigned memDepth(Header reply);
    uint32_t cvtPerNs(Header reply);
 
    static int isLE() {
        static const union {
            uint8_t c[2];
            uint16_t s;
        } u = {.s = 1};
        return !!u.c[0];
    }
 
    static const uint32_t UNKNOWN_PERIOD = 0;
 
    static double REF_FREQ_HZ() {
        return 200.0E6;
    }
 
    // obtain (current/cached) parameters; these may
    // depend on values provided by the transport-level driver
    virtual unsigned getWordSize();
    virtual unsigned getMemDepth();
    virtual uint32_t getPeriodNs();
 
  public:
    static std::shared_ptr<rogue::protocols::xilinx::JtagDriver> create(uint16_t port);
 
    static void setup_python();
 
    explicit JtagDriver(uint16_t port);
 
    virtual void init();
 
    virtual int xfer(uint8_t* txb, unsigned txBytes, uint8_t* hdbuf, unsigned hsize, uint8_t* rxb, unsigned size) {
        return 0;
    }
 
    virtual int xferRel(uint8_t* txb, unsigned txBytes, Header* phdr, uint8_t* rxb, unsigned sizeBytes);
 
    virtual uint64_t query();
 
    virtual uint64_t getMaxVectorSize() {
        return 0;
    }
 
    virtual uint32_t setPeriodNs(uint32_t newPeriod);
 
    virtual void sendVectors(uint64_t numBits, uint8_t* tms, uint8_t* tdi, uint8_t* tdo);
 
    virtual void dumpInfo(FILE* f = stdout);
 
    bool isDone() {
        return this->done_;
    }
};
 
static unsigned hdBufMax() {
    return 16;
}
 
// Convenience
typedef std::shared_ptr<rogue::protocols::xilinx::JtagDriver> JtagDriverPtr;
}  // namespace xilinx
}  // namespace protocols
}  // namespace rogue
 
#endif