Subversion Repositories w11

// $Id: RlinkPortCuff.hpp 502 2013-04-02 19:29:30Z 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 502 2013-04-02 19:29:30Z mueller $

  \brief   Declaration of class RlinkPortCuff.

*/

#ifndef included_Retro_RlinkPortCuff

#define included_Retro_RlinkPortCuff 1

#include "RlinkPort.hpp"

#include <poll.h>

#include <libusb-1.0/libusb.h>

#include <vector>

#include <deque>

#include "boost/thread/thread.hpp"

namespace Retro {

  class RlinkPortCuff : public RlinkPort {

    public:

                    RlinkPortCuff();

      virtual       ~RlinkPortCuff();

      virtual bool  Open(const std::string& url, RerrMsg& emsg);

      virtual void  Close();

    // some constants (also defined in cpp)

      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

//#include "RlinkPortCuff.ipp"

#endif