Subversion Repositories w11

// $Id: Rw11Rdma.hpp 648 2015-02-20 20:16:21Z mueller $
//
// Copyright 2015- 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
// 2015-02-17   647   1.1    PreExecCB with nwdone and nwnext
// 2015-01-04   627   1.0    Initial version
// ---------------------------------------------------------------------------
 
 
/*!
  \file
  \version $Id: Rw11Rdma.hpp 648 2015-02-20 20:16:21Z mueller $
  \brief   Declaration of class Rw11Rdma.
*/
 
#ifndef included_Retro_Rw11Rdma
#define included_Retro_Rw11Rdma 1
 
#include "boost/utility.hpp"
#include "boost/function.hpp"
 
#include "librtools/Rstats.hpp"
#include "librtools/RerrMsg.hpp"
 
#include "librtools/Rbits.hpp"
#include "Rw11Cntl.hpp"
 
namespace Retro {
 
  class Rw11Rdma : public Rbits, private boost::noncopyable {
    public:
 
      typedef boost::function<void(int,size_t,size_t,
                                   RlinkCommandList&)>  precb_t;
      typedef boost::function<void(int,size_t,
                                   RlinkCommandList&,size_t)>  postcb_t;
 
                    Rw11Rdma(Rw11Cntl* pcntl, const precb_t& precb, 
                             const postcb_t& postcb);
      virtual      ~Rw11Rdma();
 
      Rw11Cntl&     CntlBase() const;
      Rw11Cpu&      Cpu() const;
      Rw11&         W11() const;
      RlinkServer&  Server() const;
      RlinkConnect& Connect() const;
      RlogFile&     LogFile() const;
 
      void          SetChunkSize(size_t chunk);
      size_t        ChunkSize() const;
 
      bool          IsActive() const;
 
      void          QueueRMem(uint32_t addr, uint16_t* block, size_t size,
                              uint16_t mode);
      void          QueueWMem(uint32_t addr, const uint16_t* block, size_t size,
                              uint16_t mode);
 
      const Rstats& Stats() const;
      virtual void  Dump(std::ostream& os, int ind=0, const char* text=0) const;
 
    // statistics counter indices
      enum stats {
        kStatNQueRMem,                      //!< RMem chains queued
        kStatNQueWMem,                      //!< WMem chains queued
        kStatNRdmaRMem,                     //!< RMem chunks done
        kStatNRdmaWMem,                     //!< WMem chunks done
        kStatNExtClist,                     //!< clist extended
        kStatNFailRdma,                     //!< Rdma failures
        kDimStat
      };    
 
    // status values
      enum status {
        kStatusDone,                        //!< all chunks done and ok
        kStatusBusy,                        //!< more chunks to come
        kStatusBusyLast,                    //!< last chunk to come
        kStatusFailRdma                     //!< last rdma transfer failed
      };
 
    protected:
      void          SetupRdma(bool iswmem, uint32_t addr, uint16_t* block,
                              size_t size, uint16_t mode);
      int           RdmaHandler();
      virtual void  PreRdmaHook();
      virtual void  PostRdmaHook(size_t nwdone);
 
    protected:
      Rw11Cntl*     fpCntlBase;             //!< plain Rw11Cntl ptr
      precb_t       fPreExecCB;             //!< pre Exec callback
      postcb_t      fPostExecCB;            //!< post Exec callback
      size_t        fChunksize;             //!< channel chunk size
      enum status   fStatus;                //!< dma status
      bool          fIsWMem;                //!< is memory write
      uint32_t      fAddr;                  //!< current mem address
      uint16_t      fMode;                  //!< current mode
      size_t        fNWordMax;              //!< transfer chunk size
      size_t        fNWordRest;             //!< words to be done
      size_t        fNWordDone;             //!< words transfered
      uint16_t*     fpBlock;                //!< current buffer pointer
      Rstats        fStats;                 //!< statistics
  };
 
} // end namespace Retro
 
#include "Rw11Rdma.ipp"
 
#endif