github.com/wfjm.w11
1
0
Fork 0
mirror of https://github.com/wfjm/w11.git synced 2026-04-27 12:39:59 +00:00
Code Issues Releases Wiki Activity

- interim release w11a_V0.56 (untagged)

Browse Source 
- re-organized handling of board and derived clocks in test benches
- added message filter definitions for some designs (.mfset files)
- added Cypress EZ-USB FX2 controller (USB interface)
- added firmware for EZ-USB FX2 supporting jtag access and data transfer
- FPGA configure over USB now supported directly in make build flow
- added test systems for USB testing and rlink over USB verification
- no functional change of w11a CPU core or any pre-existing test systems
- Note: Carefully read the disclaimer about usage of USB VID/PID numbers
        in the file README_USB-VID-PID.txt. You'll be responsible for any
        misuse of the defaults provided with the project sources !!
This commit is contained in:
Walter F.J. Mueller
2013-01-02 21:06:53 +00:00
parent f6775f7d05
commit cbd8ce3468
218 changed files with 17409 additions and 963 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
tools/src/librlink/Makefile
View File

@@ -1,4 +1,4 @@
# $Id: Makefile 403 2011-08-06 17:36:22Z mueller $
# $Id: Makefile 465 2012-12-27 21:29:38Z mueller $
#
# Revision History:
# Date Rev Version Comment
@@ -16,7 +16,7 @@ SOMINV = 0
# Compile and Link search paths
#
INCLFLAGS = -I${RETROBASE}/tools/src -I${BOOSTINC}
LDLIBS = -lboost_thread -L${RETROBASE}/tools/lib -lrtools
LDLIBS = -lboost_thread -lusb-1.0 -L${RETROBASE}/tools/lib -lrtools
#
# Object files to be included
#
@@ -24,7 +24,8 @@ OBJ_all = RlinkAddrMap.o \
RlinkCommand.o RlinkCommandExpect.o RlinkCommandList.o \
RlinkConnect.o \
RlinkCrc8.o RlinkPacketBuf.o \
RlinkPort.o RlinkPortFactory.o RlinkPortFifo.o RlinkPortTerm.o
RlinkPort.o RlinkPortFactory.o \
RlinkPortFifo.o RlinkPortTerm.o RlinkPortCuff.o
#
DEP_all = $(OBJ_all:.o=.dep)
#

30
tools/src/librlink/RlinkPort.cpp
View File

@@ -1,4 +1,4 @@
// $Id: RlinkPort.cpp 375 2011-04-02 07:56:47Z mueller $
// $Id: RlinkPort.cpp 466 2012-12-30 13:26:55Z mueller $
//
// Copyright 2011- by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>
//
@@ -13,13 +13,15 @@
//
// Revision History:
// Date Rev Version Comment
// 2012-12-28 466 1.0.2 allow Close() even when not open
// 2012-12-26 465 1.0.1 add CloseFd() method
// 2011-03-27 375 1.0 Initial version
// 2011-01-15 356 0.1 First draft
// ---------------------------------------------------------------------------
/*!
\file
\version $Id: RlinkPort.cpp 375 2011-04-02 07:56:47Z mueller $
\version $Id: RlinkPort.cpp 466 2012-12-30 13:26:55Z mueller $
\brief Implemenation of RlinkPort.
*/
@@ -78,14 +80,12 @@ RlinkPort::~RlinkPort()
void RlinkPort::Close()
{
if (! IsOpen())
throw logic_error("RlinkPort::Close(): port not open");
if (!IsOpen()) return;
close(fFdRead);
if (fFdWrite != fFdRead) close(fFdWrite);
if (fFdWrite == fFdRead) fFdWrite = -1;
CloseFd(fFdWrite);
CloseFd(fFdRead);
fFdRead = -1;
fFdWrite = -1;
fIsOpen = false;
fUrl.clear();
fScheme.clear();
@@ -338,7 +338,7 @@ bool RlinkPort::ParseUrl(const std::string& url, const std::string& optlist,
return true;
}
//
//------------------------------------------+-----------------------------------
//! FIXME_docs
@@ -358,6 +358,18 @@ bool RlinkPort::AddOpt(const std::string& key, const std::string& val,
return true;
}
//------------------------------------------+-----------------------------------
//! FIXME_docs
void RlinkPort::CloseFd(int& fd)
{
if (fd >= 0) {
close(fd);
fd = -1;
}
return;
}
//------------------------------------------+-----------------------------------
#if (defined(Retro_NoInline) || defined(Retro_RlinkPort_NoInline))
#define inline

6
tools/src/librlink/RlinkPort.hpp
View File

@@ -1,4 +1,4 @@
// $Id: RlinkPort.hpp 380 2011-04-25 18:14:52Z mueller $
// $Id: RlinkPort.hpp 465 2012-12-27 21:29:38Z mueller $
//
// Copyright 2011- by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>
//
@@ -13,6 +13,7 @@
//
// Revision History:
// Date Rev Version Comment
// 2012-12-26 465 1.0.2 add CloseFd() method
// 2011-04-24 380 1.0.1 use boost::noncopyable (instead of private dcl's)
// 2011-03-27 375 1.0 Initial version
// 2011-01-15 356 0.1 First draft
@@ -21,7 +22,7 @@
/*!
\file
\version $Id: RlinkPort.hpp 380 2011-04-25 18:14:52Z mueller $
\version $Id: RlinkPort.hpp 465 2012-12-27 21:29:38Z mueller $
\brief Declaration of class RlinkPort.
*/
@@ -97,6 +98,7 @@ namespace Retro {
bool AddOpt(const std::string& key, const std::string& val,
bool hasval, const std::string& optlist,
RerrMsg& emsg);
void CloseFd(int& fd);
protected:
bool fIsOpen; //!< is open flag

701
tools/src/librlink/RlinkPortCuff.cpp Normal file
View File

@@ -0,0 +1,701 @@
// $Id: RlinkPortCuff.cpp 467 2013-01-02 19:49:05Z mueller $
//
// Copyright 2012-2013 by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>
//
// This program is free software; you may redistribute and/or modify it under
// the terms of the GNU General Public License as published by the Free
// Software Foundation, either version 2, or at your option any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY, without even the implied warranty of MERCHANTABILITY
// or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
// for complete details.
//
// Revision History:
// Date Rev Version Comment
// 2013-01-02 467 1.0.1 get cleanup code right; add USBErrorName()
// 2012-12-26 465 1.0 Initial version
// ---------------------------------------------------------------------------
/*!
\file
\version $Id: RlinkPortCuff.cpp 467 2013-01-02 19:49:05Z mueller $
\brief Implemenation of RlinkPortCuff.
*/
#include <errno.h>
#include <unistd.h>
#include <sys/time.h>
#include <time.h>
#include <stdio.h>
#include <stdexcept>
#include "RlinkPortCuff.hpp"
using namespace std;
using namespace Retro;
/*!
\class Retro::RlinkPortCuff
\brief FIXME_text
*/
//------------------------------------------+-----------------------------------
//! Default constructor
RlinkPortCuff::RlinkPortCuff()
: RlinkPort(),
fFdReadDriver(-1),
fFdWriteDriver(-1),
fpUsbContext(0),
fpUsbDevList(0),
fUsbDevCount(0),
fpUsbDevHdl(0),
fLoopState(kLoopStateStopped)
{
fStats.Define(kStatNPollAddCB, "kStatNPollAddCB", "USB poll add cb");
fStats.Define(kStatNPollRemoveCB, "kStatNPollRemoveCB", "USB poll remove cb");
fStats.Define(kStatNUSBWrite, "kStatNUSBWrite", "USB write done");
fStats.Define(kStatNUSBRead, "kStatNUSBRead", "USB read done");
}
//------------------------------------------+-----------------------------------
//! Destructor
RlinkPortCuff::~RlinkPortCuff()
{
if (IsOpen()) RlinkPortCuff::Close();
}
//------------------------------------------+-----------------------------------
//! FIXME_text
bool RlinkPortCuff::Open(const std::string& url, RerrMsg& emsg)
{
int irc;
if (IsOpen()) Close();
if (!ParseUrl(url, "|trace|", emsg)) return false;
// initialize USB context
irc = libusb_init(&fpUsbContext);
if (irc != 0) {
emsg.Init("RlinkPortCuff::Open()",
string("libusb_init() failed: ") +
string(USBErrorName(irc)));
Cleanup();
return false;
}
// setup libusb level debug
libusb_set_debug(fpUsbContext, 3); // info->stdout, warn+err->stderr
// check for internal timeout handling support
if (libusb_pollfds_handle_timeouts(fpUsbContext) == 0) {
emsg.Init("RlinkPortCuff::Open()",
string("libusb_pollfds_handle_timeouts == 0 : "
"this program will not run on this legacy system"));
Cleanup();
return false;
}
// get USB device list
fUsbDevCount = libusb_get_device_list(fpUsbContext, &fpUsbDevList);
// determine USB path name
if (fPath.length() == 0) {
char* env_vid = getenv("RETRO_FX2_VID");
char* env_pid = getenv("RETRO_FX2_PID");
if (env_vid && strlen(env_vid) == 4 &&
env_pid && strlen(env_pid) == 4) {
fPath = env_vid;
fPath += ":";
fPath += env_pid;
} else {
emsg.Init("RlinkPortCuff::Open()",
string("RETRO_FX2_VID/PID not or ill defined"));
Cleanup();
return false;
}
}
// connect to USB device
libusb_device* mydev = 0;
// path syntax: /bus/dev
if (fPath.length()==8 && fPath[0]=='/' && fPath[4]=='/') {
string busnam = fPath.substr(1,3);
string devnam = fPath.substr(5,3);
char* endptr;
uint8_t busnum = strtol(busnam.c_str(), &endptr, 10);
uint8_t devnum = strtol(devnam.c_str(), &endptr, 10);
for (ssize_t idev=0; idev<fUsbDevCount; idev++) {
libusb_device* udev = fpUsbDevList[idev];
if (libusb_get_bus_number(udev) == busnum &&
libusb_get_device_address(udev) == devnum) {
mydev = udev;
}
}
// path syntax: vend:prod
} else if (fPath.length()==9 && fPath[4]==':') {
string vennam = fPath.substr(0,4);
string pronam = fPath.substr(5,4);
char* endptr;
uint16_t vennum = strtol(vennam.c_str(), &endptr, 16);
uint16_t pronum = strtol(pronam.c_str(), &endptr, 16);
for (ssize_t idev=0; idev<fUsbDevCount; idev++) {
libusb_device* udev = fpUsbDevList[idev];
libusb_device_descriptor devdsc;
libusb_get_device_descriptor(udev, &devdsc);
if (devdsc.idVendor==vennum && devdsc.idProduct==pronum) {
mydev = udev;
}
}
} else {
emsg.Init("RlinkPortCuff::Open()",
string("invalid usb path '") + fPath +
"', not '/bus/dev' or 'vend:prod'");
Cleanup();
return false;
}
if (mydev == 0) {
emsg.Init("RlinkPortCuff::Open()",
string("no usb device '") + fPath + "', found'");
Cleanup();
return false;
}
irc = libusb_open(mydev, &fpUsbDevHdl);
if (irc) {
fpUsbDevHdl = 0;
emsg.Init("RlinkPortCuff::Open()",
string("opening usb device '") + fPath + "', failed: " +
string(USBErrorName(irc)));
Cleanup();
return false;
}
if (TraceOn()) cout << "libusb_open ok for '" << fPath << "'" << endl;
// claim USB device
irc = libusb_claim_interface(fpUsbDevHdl, 0);
if (irc) {
emsg.Init("RlinkPortCuff::Open()",
string("failed to claim '") + fPath + "': " +
string(USBErrorName(irc)));
Cleanup();
return false;
}
// setup write pipe
if (!OpenPipe(fFdWriteDriver, fFdWrite, emsg)) {
Cleanup();
return false;
}
// setup read pipe
if (!OpenPipe(fFdRead, fFdReadDriver, emsg)) {
Cleanup();
return false;
}
// setup pollfd list
fPollFds.clear();
// 1. write pipe allert (is always 1st in list)
PollfdAdd(fFdWriteDriver, POLLIN);
// 2. libusb callbacks
const libusb_pollfd** plist = libusb_get_pollfds(fpUsbContext);
for (const libusb_pollfd** p = plist; *p !=0; p++) {
PollfdAdd((*p)->fd, (*p)->events);
}
free(plist);
libusb_set_pollfd_notifiers(fpUsbContext, ThunkPollfdAdd,
ThunkPollfdRemove, this);
fDriverThread = boost::thread(boost::bind(&RlinkPortCuff::Driver, this));
fIsOpen = true;
return true;
}
//------------------------------------------+-----------------------------------
//! FIXME_text
void RlinkPortCuff::Close()
{
if (!IsOpen()) return;
if (TraceOn()) cout << "Close() started" << endl;
Cleanup();
RlinkPort::Close();
if (TraceOn()) cout << "Close() ended" << endl;
return;
}
//------------------------------------------+-----------------------------------
//! FIXME_text
void RlinkPortCuff::Cleanup()
{
// close write pipe from user side -> causes event in driver and driver stop
CloseFd(fFdWrite);
// wait till driver thread terminates
// use timed join, throw in case driver doesn't stop
if (fDriverThread.get_id() != boost::thread::id()) {
if (!fDriverThread.timed_join(boost::posix_time::milliseconds(500))) {
throw runtime_error("RlinkPortCuff::Cleanup(): "
"driver thread failed to stop");
}
}
// cleanup pipes
CloseFd(fFdRead);
CloseFd(fFdReadDriver);
CloseFd(fFdWriteDriver);
// cleanup USB context
if (fpUsbContext) {
if (fpUsbDevHdl) {
libusb_release_interface(fpUsbDevHdl, 0);
libusb_close(fpUsbDevHdl);
fpUsbDevHdl = 0;
}
if (fpUsbDevList) {
libusb_free_device_list(fpUsbDevList, 1);
fpUsbDevList = 0;
}
libusb_set_pollfd_notifiers(fpUsbContext, NULL, NULL, NULL);
libusb_exit(fpUsbContext);
fpUsbContext = 0;
}
fPollFds.clear();
return;
}
//------------------------------------------+-----------------------------------
//! FIXME_text
bool RlinkPortCuff::OpenPipe(int& fdread, int& fdwrite, RerrMsg& emsg)
{
int irc;
int pipefd[2];
irc = pipe(pipefd);
if (irc < 0) {
emsg.InitErrno("RlinkPortCuff::OpenPipe()",
string("pipe() failed: "),
errno);
return false;
}
fdread = pipefd[0];
fdwrite = pipefd[1];
return true;
}
//------------------------------------------+-----------------------------------
//! FIXME_text
// executed in separate boost thread !!
void RlinkPortCuff::Driver()
{
try {
// setup USB read-ahead queue
for (size_t nr=0; nr<kUSBReadQueue; nr++) {
libusb_transfer* t = libusb_alloc_transfer(0);
t->dev_handle = fpUsbDevHdl;
t->flags = LIBUSB_TRANSFER_FREE_BUFFER;
t->endpoint = (unsigned char) (kUSBReadEP|0x80);
t->type = LIBUSB_TRANSFER_TYPE_BULK;
t->timeout = 0;
t->status = LIBUSB_TRANSFER_COMPLETED;
t->buffer = (unsigned char*) malloc(kUSBBufferSize);
t->length = kUSBBufferSize;
t->actual_length = 0;
t->callback = ThunkUSBReadDone;
t->user_data = this;
int irc = libusb_submit_transfer(t);
if (irc) BadUSBCall("RlinkPortCuff::Driver()",
"libusb_submit_transfer()", irc);
fReadQueuePending.push_back(t);
}
// event loop
if (TraceOn()) cout << "event loop started" << endl;
fLoopState = kLoopStateRunning;
while(fLoopState == kLoopStateRunning) {
int irc = poll(fPollFds.data(), fPollFds.size(), 1000);
if (irc==-1 && errno==EINTR) continue;
if (irc!=0 && TraceOn()) {
cout << "poll() -> " << irc << " :";
for (size_t i=0; i<fPollFds.size(); i++)
if (fPollFds[i].revents) cout << " (" << fPollFds[i].fd << ","
<< fPollFds[i].events << ","
<< fPollFds[i].revents << ")";
cout << endl;
}
if (irc < 0) BadSysCall("RlinkPortCuff::Driver()", "poll()", irc);
if (fPollFds[0].revents & POLLHUP) { // write pipe close event
fLoopState = kLoopStateStopping;
} else if (fPollFds[0].revents & POLLIN) { // write pipe data event
DriverEventWritePipe();
} else { // assume USB timeout events
DriverEventUSB();
}
}
if (TraceOn()) cout << "event loop ended, cleanup started" << endl;
for (size_t i=0; i<fWriteQueuePending.size(); i++) {
libusb_cancel_transfer(fWriteQueuePending[i]);
}
for (size_t i=0; i<fReadQueuePending.size(); i++) {
libusb_cancel_transfer(fReadQueuePending[i]);
}
while(fLoopState == kLoopStateStopping &&
fWriteQueuePending.size() + fReadQueuePending.size() > 0) {
int irc = poll(fPollFds.data()+1, fPollFds.size()-1, 1000);
if (irc==-1 && errno==EINTR) continue;
if (irc==0) break;
if (irc < 0) BadSysCall("RlinkPortCuff::Driver()", "poll()", irc);
DriverEventUSB();
}
if (fWriteQueuePending.size() + fReadQueuePending.size())
throw runtime_error("RlinkPortCuff::Driver(): cleanup timeout");
fLoopState = kLoopStateStopped;
if (TraceOn()) cout << "cleanup ended" << endl;
} catch (exception& e) {
cout << "exception caught in RlinkPortCuff::Driver(): '" << e.what()
<< "'" << endl;
// close read pipe at driver end -> that causes main thread to respond
close(fFdReadDriver);
fFdReadDriver = -1;
}
return;
}
//------------------------------------------+-----------------------------------
//! FIXME_text
void RlinkPortCuff::DriverEventWritePipe()
{
libusb_transfer* t = NewWriteTransfer();
ssize_t ircs = read(fFdWriteDriver, t->buffer, kUSBBufferSize);
if (TraceOn()) cout << "write pipe read() -> " << ircs << endl;
if (ircs < 0) BadSysCall("RlinkPortCuff::DriverEventWritePipe()",
"read()", ircs);
// pipe closed... end driver event loop
if (ircs == 0) {
fLoopState = kLoopStateStopping;
return;
}
t->length = (int) ircs;
int irc = libusb_submit_transfer(t);
if (irc) BadUSBCall("RlinkPortCuff::DriverEventWritePipe()",
"libusb_submit_transfer()", irc);
fWriteQueuePending.push_back(t);
return;
}
//------------------------------------------+-----------------------------------
//! FIXME_text
void RlinkPortCuff::DriverEventUSB()
{
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 0;
int irc = libusb_handle_events_timeout(fpUsbContext, &tv);
//setting the timeval pointer to NULL should work, but doesn't (in 1.0.6)
//rc = libusb_handle_events_timeout(pUsbContext, 0);
if (irc) BadUSBCall("RlinkPortCuff::DriverEventUSB()",
"libusb_handle_events_timeout()", irc);
return;
}
//------------------------------------------+-----------------------------------
//! FIXME_text
libusb_transfer* RlinkPortCuff::NewWriteTransfer()
{
libusb_transfer* t = 0;
if (!fWriteQueueFree.empty()) {
t = fWriteQueueFree.front();
fWriteQueueFree.pop_front();
} else {
t = libusb_alloc_transfer(0);
t->dev_handle = fpUsbDevHdl;
t->flags = LIBUSB_TRANSFER_FREE_BUFFER;
t->endpoint = (unsigned char) (kUSBWriteEP);
t->type = LIBUSB_TRANSFER_TYPE_BULK;
t->timeout = 1000;
t->buffer = (unsigned char*) malloc(kUSBBufferSize);
t->callback = ThunkUSBWriteDone;
t->user_data = this;
}
t->status = LIBUSB_TRANSFER_COMPLETED;
t->length = 0;
t->actual_length = 0;
return t;
}
//------------------------------------------+-----------------------------------
//! FIXME_text
bool RlinkPortCuff::TraceOn()
{
if (!UrlFindOpt("trace")) return false;
struct timeval tv;
struct timezone tz;
struct tm tmval;
gettimeofday(&tv, &tz);
localtime_r(&tv.tv_sec, &tmval);
char buf[20];
snprintf(buf, 20, "%02d:%02d:%02d.%06d: ",
tmval.tm_hour, tmval.tm_min, tmval.tm_sec, (int) tv.tv_usec);
cout << buf;
return true;
}
//------------------------------------------+-----------------------------------
//! FIXME_text
void RlinkPortCuff::BadSysCall(const char* meth, const char* text, int rc)
{
char buf[1024];
snprintf(buf, 1024, "%s : %s failed with rc=%d errno=%d: %s",
meth, text, rc, errno, strerror(errno));
throw runtime_error(buf);
}
//------------------------------------------+-----------------------------------
//! FIXME_text
void RlinkPortCuff::BadUSBCall(const char* meth, const char* text, int rc)
{
char buf[1024];
snprintf(buf, 1024, "%s : %s failed with rc=%d: %s",
meth, text, rc, USBErrorName(rc));
throw runtime_error(buf);
}
//------------------------------------------+-----------------------------------
//! FIXME_text
void RlinkPortCuff::CheckUSBTransfer(const char* meth, libusb_transfer *t)
{
const char* etext = 0;
if (t->status == LIBUSB_TRANSFER_ERROR) etext = "ERROR";
if (t->status == LIBUSB_TRANSFER_STALL) etext = "STALL";
if (t->status == LIBUSB_TRANSFER_NO_DEVICE) etext = "NO_DEVICE";
if (t->status == LIBUSB_TRANSFER_OVERFLOW) etext = "OVERFLOW";
if (etext == 0) return;
char buf[1024];
snprintf(buf, 1024, "%s : transfer failure on ep=%d: %s",
meth, (int)(t->endpoint&(~0x80)), etext);
throw runtime_error(buf);
}
//------------------------------------------+-----------------------------------
//! FIXME_text
const char* RlinkPortCuff::USBErrorName(int rc)
{
// Code taken verbatim from libusb-1.0.9.tar.bz2 function libusb_error_name
// The libusb_error_name() function was added rather late in V1.0.9.
// To allow usage with V1.0.8 and earlier this function is include here
switch (rc) {
case LIBUSB_SUCCESS:
return "LIBUSB_SUCCESS";
case LIBUSB_ERROR_IO:
return "LIBUSB_ERROR_IO";
case LIBUSB_ERROR_INVALID_PARAM:
return "LIBUSB_ERROR_INVALID_PARAM";
case LIBUSB_ERROR_ACCESS:
return "LIBUSB_ERROR_ACCESS";
case LIBUSB_ERROR_NO_DEVICE:
return "LIBUSB_ERROR_NO_DEVICE";
case LIBUSB_ERROR_NOT_FOUND:
return "LIBUSB_ERROR_NOT_FOUND";
case LIBUSB_ERROR_BUSY:
return "LIBUSB_ERROR_BUSY";
case LIBUSB_ERROR_TIMEOUT:
return "LIBUSB_ERROR_TIMEOUT";
case LIBUSB_ERROR_OVERFLOW:
return "LIBUSB_ERROR_OVERFLOW";
case LIBUSB_ERROR_PIPE:
return "LIBUSB_ERROR_PIPE";
case LIBUSB_ERROR_INTERRUPTED:
return "LIBUSB_ERROR_INTERRUPTED";
case LIBUSB_ERROR_NO_MEM:
return "LIBUSB_ERROR_NO_MEM";
case LIBUSB_ERROR_NOT_SUPPORTED:
return "LIBUSB_ERROR_NOT_SUPPORTED";
case LIBUSB_ERROR_OTHER:
return "LIBUSB_ERROR_OTHER";
}
return "**UNKNOWN**";
}
//------------------------------------------+-----------------------------------
//! FIXME_text
void RlinkPortCuff::PollfdAdd(int fd, short events)
{
fStats.Inc(kStatNPollAddCB);
pollfd pfd;
pfd.fd = fd;
pfd.events = events;
pfd.revents = 0;
fPollFds.push_back(pfd);
return;
}
//------------------------------------------+-----------------------------------
//! FIXME_text
void RlinkPortCuff::PollfdRemove(int fd)
{
fStats.Inc(kStatNPollRemoveCB);
for (size_t i=0; i<fPollFds.size(); ) {
if (fPollFds[i].fd == fd) {
fPollFds.erase(fPollFds.begin()+i);
} else {
i++;
}
}
return;
}
//------------------------------------------+-----------------------------------
//! FIXME_text
void RlinkPortCuff::USBWriteDone(libusb_transfer* t)
{
if (TraceOn()) cout << "USB write done -> " << t->actual_length << endl;
if (fWriteQueuePending.size() && t == fWriteQueuePending.front())
fWriteQueuePending.pop_front();
else
throw logic_error("RlinkPortCuff::USBWriteDone: "
"fWriteQueuePending disordered");
if (fLoopState == kLoopStateRunning) {
CheckUSBTransfer("RlinkPortCuff::USBWriteDone()", t);
fStats.Inc(kStatNUSBWrite);
fWriteQueueFree.push_back(t);
} else {
libusb_free_transfer(t);
}
return;
}
//------------------------------------------+-----------------------------------
//! FIXME_text
void RlinkPortCuff::USBReadDone(libusb_transfer* t)
{
if (TraceOn()) cout << "USB read done -> " << t->actual_length << endl;
if (fReadQueuePending.size() && t == fReadQueuePending.front())
fReadQueuePending.pop_front();
else
throw logic_error("RlinkPortCuff::USBReadDone: "
"fReadQueuePending disordered");
if (fLoopState == kLoopStateRunning) {
CheckUSBTransfer("RlinkPortCuff::USBReadDone()", t);
fStats.Inc(kStatNUSBRead);
if (t->actual_length>0) {
ssize_t ircs = write(fFdReadDriver, t->buffer, (size_t) t->actual_length);
if (ircs < 0) BadSysCall("RlinkPortCuff::USBReadDone()",
"write()", ircs);
}
t->status = LIBUSB_TRANSFER_COMPLETED;
t->actual_length = 0;
int irc = libusb_submit_transfer(t);
if (irc) BadUSBCall("RlinkPortCuff::USBReadDone()",
"libusb_submit_transfer()", irc);
fReadQueuePending.push_back(t);
} else {
libusb_free_transfer(t);
}
return;
}
//------------------------------------------+-----------------------------------
//! FIXME_text
void RlinkPortCuff::ThunkPollfdAdd(int fd, short events, void* udata)
{
RlinkPortCuff* pcntx = (RlinkPortCuff*) udata;
pcntx->PollfdAdd(fd, events);
return;
}
//------------------------------------------+-----------------------------------
//! FIXME_text
void RlinkPortCuff::ThunkPollfdRemove(int fd, void* udata)
{
RlinkPortCuff* pcntx = (RlinkPortCuff*) udata;
pcntx->PollfdRemove(fd);
return;
}
//------------------------------------------+-----------------------------------
//! FIXME_text
void RlinkPortCuff::ThunkUSBWriteDone(libusb_transfer* t)
{
RlinkPortCuff* pcntx = (RlinkPortCuff*) t->user_data;
pcntx->USBWriteDone(t);
return;
}
//------------------------------------------+-----------------------------------
//! FIXME_text
void RlinkPortCuff::ThunkUSBReadDone(libusb_transfer* t)
{
RlinkPortCuff* pcntx = (RlinkPortCuff*) t->user_data;
pcntx->USBReadDone(t);
return;
}
//------------------------------------------+-----------------------------------
#if (defined(Retro_NoInline) || defined(Retro_RlinkPortCuff_NoInline))
#define inline
//#include "RlinkPortCuff.ipp"
#undef inline
#endif

116
tools/src/librlink/RlinkPortCuff.hpp Normal file
View File

@@ -0,0 +1,116 @@
// $Id: RlinkPortCuff.hpp 467 2013-01-02 19:49:05Z mueller $
//
// Copyright 2012-2013 by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>
//
// This program is free software; you may redistribute and/or modify it under
// the terms of the GNU General Public License as published by the Free
// Software Foundation, either version 2, or at your option any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY, without even the implied warranty of MERCHANTABILITY
// or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
// for complete details.
//
// Revision History:
// Date Rev Version Comment
// 2013-01-02 467 1.0.1 get cleanup code right; add USBErrorName()
// 2012-12-26 465 1.0 Initial version
// ---------------------------------------------------------------------------
/*!
\file
\version $Id: RlinkPortCuff.hpp 467 2013-01-02 19:49:05Z mueller $
\brief Declaration of class RlinkPortCuff.
*/
#ifndef included_Retro_RlinkPortCuff
#define included_Retro_RlinkPortCuff 1
#include "RlinkPort.hpp"
#include <poll.h>
#include <vector>
#include "boost/thread.hpp"
#include <libusb-1.0/libusb.h>
namespace Retro {
class RlinkPortCuff : public RlinkPort {
public:
RlinkPortCuff();
virtual ~RlinkPortCuff();
virtual bool Open(const std::string& url, RerrMsg& emsg);
virtual void Close();
// some constants
static const size_t kUSBBufferSize = 4096; //!< USB buffer size
static const int kUSBWriteEP = 4 ; //!< USB write endpoint
static const int kUSBReadEP = 6 ; //!< USB read endpoint
static const size_t kUSBReadQueue = 2 ; //!< USB read queue length
// statistics counter indices
enum stats {
kStatNPollAddCB = RlinkPort::kDimStat,
kStatNPollRemoveCB,
kStatNUSBWrite,
kStatNUSBRead,
kDimStat
};
// event loop states
enum loopState {
kLoopStateStopped,
kLoopStateRunning,
kLoopStateStopping
};
protected:
int fFdReadDriver; //!< fd for read (driver end)
int fFdWriteDriver; //!< fd for write (driver end)
boost::thread fDriverThread; //!< driver thread
libusb_context* fpUsbContext;
libusb_device** fpUsbDevList;
ssize_t fUsbDevCount;
libusb_device_handle* fpUsbDevHdl;
loopState fLoopState;
std::vector<pollfd> fPollFds;
std::deque<libusb_transfer*> fWriteQueueFree;
std::deque<libusb_transfer*> fWriteQueuePending;
std::deque<libusb_transfer*> fReadQueuePending;
private:
void Cleanup();
bool OpenPipe(int& fdread, int& fdwrite, RerrMsg& emsg);
void Driver();
void DriverEventWritePipe();
void DriverEventUSB();
libusb_transfer* NewWriteTransfer();
bool TraceOn();
void BadSysCall(const char* meth, const char* text, int rc);
void BadUSBCall(const char* meth, const char* text, int rc);
void CheckUSBTransfer(const char* meth, libusb_transfer *t);
const char* USBErrorName(int rc);
void PollfdAdd(int fd, short events);
void PollfdRemove(int fd);
void USBWriteDone(libusb_transfer* t);
void USBReadDone(libusb_transfer* t);
static void ThunkPollfdAdd(int fd, short events, void* udata);
static void ThunkPollfdRemove(int fd, void* udata);
static void ThunkUSBWriteDone(libusb_transfer* t);
static void ThunkUSBReadDone(libusb_transfer* t);
};
} // end namespace Retro
#if !(defined(Retro_NoInline) || defined(Retro_RlinkPortCuff_NoInline))
//#include "RlinkPortCuff.ipp"
#endif
#endif

10
tools/src/librlink/RlinkPortFactory.cpp
View File

@@ -1,6 +1,6 @@
// $Id: RlinkPortFactory.cpp 375 2011-04-02 07:56:47Z mueller $
// $Id: RlinkPortFactory.cpp 465 2012-12-27 21:29:38Z mueller $
//
// Copyright 2011- by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>
// Copyright 2011-2012 by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>
//
// This program is free software; you may redistribute and/or modify it under
// the terms of the GNU General Public License as published by the Free
@@ -13,19 +13,21 @@
//
// Revision History:
// Date Rev Version Comment
// 2012-12-26 465 1.1 add cuff: support
// 2011-03-27 374 1.0 Initial version
// 2011-01-15 356 0.1 First draft
// ---------------------------------------------------------------------------
/*!
\file
\version $Id: RlinkPortFactory.cpp 375 2011-04-02 07:56:47Z mueller $
\version $Id: RlinkPortFactory.cpp 465 2012-12-27 21:29:38Z mueller $
\brief Implemenation of RlinkPortFactory.
*/
#include "RlinkPortFactory.hpp"
#include "RlinkPortFifo.hpp"
#include "RlinkPortTerm.hpp"
#include "RlinkPortCuff.hpp"
using namespace std;
using namespace Retro;
@@ -53,6 +55,8 @@ RlinkPort* Retro::RlinkPortFactory::New(const std::string& url, RerrMsg& emsg)
return new RlinkPortFifo();
} else if (scheme == "term") {
return new RlinkPortTerm();
} else if (scheme == "cuff") {
return new RlinkPortCuff();
}
emsg.Init("RlinkPortFactory::New()", string("unknown scheme: ") + scheme);

9
tools/src/librlink/RlinkPortFifo.cpp
View File

@@ -1,4 +1,4 @@
// $Id: RlinkPortFifo.cpp 375 2011-04-02 07:56:47Z mueller $
// $Id: RlinkPortFifo.cpp 466 2012-12-30 13:26:55Z mueller $
//
// Copyright 2011- by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>
//
@@ -19,7 +19,7 @@
/*!
\file
\version $Id: RlinkPortFifo.cpp 375 2011-04-02 07:56:47Z mueller $
\version $Id: RlinkPortFifo.cpp 466 2012-12-30 13:26:55Z mueller $
\brief Implemenation of RlinkPortFifo.
*/
@@ -49,7 +49,10 @@ RlinkPortFifo::RlinkPortFifo()
//! Destructor
RlinkPortFifo::~RlinkPortFifo()
{}
{
// no need to call Close() here, no RlinkPortFifo::Close()
// cleanup will be done by ~RlinkPort()
}
//------------------------------------------+-----------------------------------
//! FIXME_text

19
tools/src/librlink/RlinkPortTerm.cpp
View File

@@ -1,4 +1,4 @@
// $Id: RlinkPortTerm.cpp 440 2011-12-18 20:08:09Z mueller $
// $Id: RlinkPortTerm.cpp 466 2012-12-30 13:26:55Z mueller $
//
// Copyright 2011- by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>
//
@@ -24,7 +24,7 @@
/*!
\file
\version $Id: RlinkPortTerm.cpp 440 2011-12-18 20:08:09Z mueller $
\version $Id: RlinkPortTerm.cpp 466 2012-12-30 13:26:55Z mueller $
\brief Implemenation of RlinkPortTerm.
*/
@@ -263,13 +263,14 @@ bool RlinkPortTerm::Open(const std::string& url, RerrMsg& emsg)
void RlinkPortTerm::Close()
{
if (fIsOpen) {
if (fFdWrite >= 0) {
tcflush(fFdWrite, TCIOFLUSH);
tcsetattr(fFdWrite, TCSANOW, &fTiosOld);
}
RlinkPort::Close();
if (!IsOpen()) return;
if (fFdWrite >= 0) {
tcflush(fFdWrite, TCIOFLUSH);
tcsetattr(fFdWrite, TCSANOW, &fTiosOld);
}
RlinkPort::Close();
return;
}
@@ -284,7 +285,7 @@ int RlinkPortTerm::Read(uint8_t* buf, size_t size, double timeout,
uint8_t* po = buf;
if (fRxBuf.size() < size) fRxBuf.resize(size);
// repeat read untill at least one byte returned (or an error occurs)
// repeat read until at least one byte returned (or an error occurs)
// this avoids that the Read() returns with 0 in case only one byte is
// seen and this is a kc_xesc. At most two iterations possible because
// in 2nd iteration fPendXesc must be set and thus po pushed.

5
tools/src/librlinktpp/Makefile
View File

@@ -1,7 +1,8 @@
# $Id: Makefile 401 2011-07-31 21:02:33Z mueller $
# $Id: Makefile 464 2012-12-26 10:14:15Z mueller $
#
# Revision History:
# Date Rev Version Comment
# 2012-12-24 464 1.1.1 add TCLINC
# 2011-07-31 401 1.1 rename realclean->distclean
# 2011-07-01 386 1.0.2 add BOOSTINC
# 2011-03-20 372 1.0.1 renamed ..tcl -> ..tpp
@@ -16,7 +17,7 @@ SOMINV = 0
#
# Compile and Link search paths
#
INCLFLAGS = -I/usr/include/tcl8.4 -I${RETROBASE}/tools/src -I${BOOSTINC}
INCLFLAGS = -I${RETROBASE}/tools/src -I${TCLINC} -I${BOOSTINC}
LDLIBS = -L${RETROBASE}/tools/lib -lrtools -lrtcltools -lrlink
#
# Object files to be included

5
tools/src/librtcltools/Makefile
View File

@@ -1,7 +1,8 @@
# $Id: Makefile 401 2011-07-31 21:02:33Z mueller $
# $Id: Makefile 464 2012-12-26 10:14:15Z mueller $
#
# Revision History:
# Date Rev Version Comment
# 2012-12-24 464 1.1.1 add TCLINC
# 2011-07-31 401 1.1 rename realclean->distclean
# 2011-07-01 386 1.0.1 add BOOSTINC
# 2011-02-11 360 1.0 Initial version
@@ -15,7 +16,7 @@ SOMINV = 0
#
# Compile and Link search paths
#
INCLFLAGS = -I/usr/include/tcl8.4 -I${RETROBASE}/tools/src -I${BOOSTINC}
INCLFLAGS = -I${RETROBASE}/tools/src -I${TCLINC} -I${BOOSTINC}
LDLIBS = -L${RETROBASE}/tools/lib -lrtools
#
# Object files to be included

5
tools/src/librutiltpp/Makefile
View File

@@ -1,7 +1,8 @@
# $Id: Makefile 401 2011-07-31 21:02:33Z mueller $
# $Id: Makefile 464 2012-12-26 10:14:15Z mueller $
#
# Revision History:
# Date Rev Version Comment
# 2012-12-24 464 1.1.1 add TCLINC
# 2011-07-31 401 1.1 rename realclean->distclean
# 2011-07-01 386 1.0.2 add BOOSTINC
# 2011-03-20 372 1.0.1 renamed ..tcl -> ..tpp
@@ -16,7 +17,7 @@ SOMINV = 0
#
# Compile and Link search paths
#
INCLFLAGS = -I/usr/include/tcl8.4 -I${RETROBASE}/tools/src -I${BOOSTINC}
INCLFLAGS = -I${RETROBASE}/tools/src -I${TCLINC} -I${BOOSTINC}
LDLIBS = -L${RETROBASE}/tools/lib -lrtcltools
#
# Object files to be included