VmePort.h

// 25/03/2002  V 1.0 TM - Data types unsigned, addr_mod->AddrMod, 
//                        namespace added            
//  3/04/2002  V 1.1 PM - Few modifications in the block transfer
//                        methods 
// 18/04/2002  V 1.2 PM - Modification in the interrupt handling
//                        and in the error reporting methods
// 22/04/2002  V 1.3 PM - New methods for blocking and resuming 
//                        interrupt notification and for reading
//                        and setting an interrupt data word           
// 19/02/2004  V 1.4 PM - Safe single word R/W methods added            
//

#ifndef SCTPIXELROD_VMEPORT_H
#define SCTPIXELROD_VMEPORT_H

#include <string>

#include "VmeInterface.h"

namespace SctPixelRod {

class VmePort {
public:

  VmePort(unsigned long base, unsigned long size, VmeInterface::AddrMod mod,
          VmeInterface &interf) : 
          m_baseAddress(base), m_mapSize(size), m_addrMod(mod),
          m_interface(interf) {
     m_handle = m_interface.registerPort(*this);
     m_exceptionTrapping = true;
   };
  ~VmePort() {
    m_interface.deletePort(*this);
  };                                                                  

  inline VmeInterface &getInterface() { return m_interface; };         
  inline unsigned long getHandle() { return m_handle; };         
  inline void *getMap() { return m_interface.getPortMap(m_handle); };         
  inline unsigned long getBaseAddress() { return m_baseAddress; };         
  inline unsigned long getMapSize() { return m_mapSize; };
  inline VmeInterface::AddrMod getAddrMod() { return m_addrMod; };
  inline void setExceptionTrapping(bool act) { m_exceptionTrapping = act; };         
  inline bool getExceptionTrapping() { return m_exceptionTrapping; };                
  inline long getLastErrcode() { return m_interface.getLastErrcode(); };
  inline std::string getErrorMessage(const long errcode) { return m_interface.getErrorMessage(errcode); };

  inline long getBusErrors() { return m_interface.getBusErrors(); };
  void busErrorReport() { m_interface.busErrorReport(*this); };

  inline unsigned char read8(const unsigned long offset) { 
    return m_interface.read8(m_handle, offset);
  };  
  inline unsigned char readS8(const unsigned long offset) { 
    return m_interface.readS8(m_handle, offset);
  };  
  
  // Word read (automatic mapping)
  inline unsigned short read16(const unsigned long offset){ 
    return m_interface.read16(m_handle, offset);
  };  
  inline unsigned short readS16(const unsigned long offset){ 
    return m_interface.readS16(m_handle, offset);
  };  
  
  inline unsigned long read32(const unsigned long offset){
    return m_interface.read32(m_handle, offset);
  };  
  inline unsigned long readS32(const unsigned long offset){
    return m_interface.readS32(m_handle, offset);
  };  
  
  inline void write8(const unsigned long offset, const unsigned char value) {
    m_interface.write8(m_handle, offset, value);
  };   
  inline void writeS8(const unsigned long offset, const unsigned char value) {
    m_interface.writeS8(m_handle, offset, value);
  };   
  
  inline void write16(const unsigned long offset, const unsigned short value) {
    m_interface.write16(m_handle, offset, value);
  };    
  inline void writeS16(const unsigned long offset, const unsigned short value) {
    m_interface.writeS16(m_handle, offset, value);
  };    
  
  inline void write32(const unsigned long offset, const unsigned long value) {
    m_interface.write32(m_handle, offset, value);
  };   
  inline void writeS32(const unsigned long offset, const unsigned long value) {
    m_interface.writeS32(m_handle, offset, value);
  };   

  inline void blockRead32(const unsigned long offset, unsigned long *buf, const long len) {
    m_interface.blockRead32(*this, offset, buf, len);
  };  
  inline void blockRead64(const unsigned long offset, unsigned long *buf, const long len) {
    m_interface.blockRead64(*this, offset, buf, len);
  };   
  inline void blockWrite32(const unsigned long offset, const unsigned long *buf, const long len) {
    m_interface.blockWrite32(*this, offset, buf, len);
  };  
  inline void blockWrite64(const unsigned long offset, const unsigned long *buf, const long len) {
    m_interface.blockWrite64(*this, offset, buf, len);
  };   
  
  // Interrupt handling
  inline void declareInterruptHandler(VmeInterruptHandler &ih) {
    m_interface.declareInterruptHandler(ih);
  };
  inline void cleanInterruptHandlers() {
    m_interface.cleanInterruptHandlers();
  };
  inline void removeInterruptHandler(VmeInterruptHandler &ih) {
    m_interface.removeInterruptHandler(ih);
  };
  inline void reEnableInterrupt() { 
    m_interface.reEnableInterrupt();
  }; 
  void blockInterruptNotification() {
    m_interface.blockInterruptNotification();
  };
  void resumeInterruptNotification() {
    m_interface.resumeInterruptNotification();
  };
  
private:
  unsigned long m_handle;
  unsigned long m_baseAddress;
  unsigned long m_mapSize;
  VmeInterface::AddrMod m_addrMod;
  VmeInterface &m_interface;
  bool m_exceptionTrapping;
};                                             // End of VmePort declaration

class VmeInterruptHandler {
public:
  VmeInterruptHandler(VmePort &port, char vect, int level) : 
      m_port(port), m_interruptLevel(level) {
    if (level == -1) {
      m_interruptVector = 0;
      m_interruptSoftVect = vect;
    } else {
      m_interruptVector = vect;
      m_interruptSoftVect = 0;
    } 
    m_port.declareInterruptHandler(*this); 
    m_active = true;
  };
  virtual ~VmeInterruptHandler() {
    m_active = false;
    m_port.removeInterruptHandler(*this);
  };
  virtual void interruptHandler(unsigned char vect, unsigned char softvect, int count) = 0;
  inline void activateSoftVector(unsigned char softvect) { 
    if (m_interruptSoftVect == 0) m_port.getInterface().activateSoftVector(m_interruptVector, softvect);
  };
  inline void setInterruptData(long data) {
    if (m_interruptSoftVect == 0) m_port.getInterface().setInterruptData(data);
  }
  inline long getInterruptData() {
    return m_port.getInterface().getInterruptData();
  }
  inline void reEnableInterrupt() { m_port.reEnableInterrupt(); }; 
  inline char getInterruptVector() { return m_interruptVector; }
  inline char getInterruptSoftVect() { return m_interruptSoftVect; }
  inline int getInterruptLevel() { return m_interruptLevel; }
  inline void setActive(bool active) { m_active = active; };
  inline bool getActive() { return m_active; };
  
protected:
  VmePort &m_port;
  unsigned char m_interruptVector;
  unsigned char m_interruptSoftVect;
  unsigned int m_interruptLevel;
  bool m_active;
};

} // End namespace SctPixelRod

#endif // SCTPIXELROD_VMEPORT_H

---