Xvc.h

Go to the documentation of this file.

 
#ifndef __ROGUE_PROTOCOLS_XILINX_XVC_H__
#define __ROGUE_PROTOCOLS_XILINX_XVC_H__
#include "rogue/Directives.h"
 
#include <atomic>
#include <cstdint>
#include <memory>
#include <thread>
 
#include "rogue/GeneralError.h"
#include "rogue/Logging.h"
#include "rogue/Queue.h"
#include "rogue/interfaces/stream/Master.h"
#include "rogue/interfaces/stream/Slave.h"
#include "rogue/protocols/xilinx/JtagDriver.h"
#include "rogue/protocols/xilinx/XvcServer.h"
 
namespace rogue {
namespace protocols {
namespace xilinx {
 
class Xvc : public rogue::interfaces::stream::Master,
            public rogue::interfaces::stream::Slave,
            public rogue::protocols::xilinx::JtagDriver {
  protected:
    unsigned mtu_;
 
    // Use rogue frames to exchange data with other rogue objects
    rogue::Queue<std::shared_ptr<rogue::interfaces::stream::Frame>> queue_;
 
    // Log (named xvcLog_ to avoid shadowing JtagDriver::log_)
    std::shared_ptr<rogue::Logging> xvcLog_;
 
    // Background server thread.
    std::unique_ptr<std::thread> thread_;
    std::atomic<bool> threadEn_;
 
    // One-shot start guard.  rogue::Queue::stop() is irreversible (see
    // rogue/Queue.h: stop() sets run_=false with no restart API), so a
    // restarted Xvc would have a permanently-non-blocking queue and a
    // dirty wake-fd.  start() asserts this flag is false; once set, it
    // stays set for the lifetime of the instance.
    std::atomic<bool> started_;
 
    // Lock
    std::mutex mtx_;
 
    // Shutdown wake-fd (self-pipe). wakeFd_[0]=read end (consumed by
    // XvcServer/XvcConnection select()); wakeFd_[1]=write end (one byte
    // written in Xvc::stop()).
    int wakeFd_[2] = {-1, -1};
 
    // Cached bound port (atomic so getPort() is safe during stop()).
    std::atomic<uint32_t> boundPort_{0};
 
    // Owned XvcServer: constructed in start() so port is synchronously
    // known before the server thread races.
    std::unique_ptr<rogue::protocols::xilinx::XvcServer> server_;
 
    // TCP server thread entry point for Vivado clients.
    void runThread();
 
  public:
    static std::shared_ptr<rogue::protocols::xilinx::Xvc> create(uint16_t port);
 
    static void setup_python();
 
    explicit Xvc(uint16_t port);
 
    ~Xvc();
 
    void start();
 
    void stop();
 
    void acceptFrame(std::shared_ptr<rogue::interfaces::stream::Frame> frame);
 
    uint64_t getMaxVectorSize() final;
 
    int xfer(uint8_t* txBuffer,
             unsigned txBytes,
             uint8_t* hdBuffer,
             unsigned hdBytes,
             uint8_t* rxBuffer,
             unsigned rxBytes) final;
 
    uint32_t getPort() const;
};
 
// Convenience
typedef std::shared_ptr<rogue::protocols::xilinx::Xvc> XvcPtr;
}  // namespace xilinx
}  // namespace protocols
}  // namespace rogue
 
#endif