RodModule.h

//File: RodModule.h

#ifndef SCTPIXELROD_RODMODULE_H 
#define SCTPIXELROD_RODMODULE_H

#include <fstream> 
#include <iostream>
#include <string>
#include <ctime>     // Pick up clock() function and clock_t typedef
#include <new>

#include "BaseException.h"
#include "RodPrimitive.h" 
#include "RodPrimList.h"
#include "VmeInterface.h" 
#include "VmePort.h"
#include "VmeModule.h"
#include "processor.h"
#include "RodRegisterBits.h"
#include "smSendTxtBuff.h"
#include "RodDspAddresses.h"
#include "RodVmeAddresses.h"
#include "RodOutList.h"
#include "txtBuffer.h"

namespace SctPixelRod {

// Forward definition
class BocCard;

enum TextBuffState {TEXT_IDLE, TEXT_RQ_SET, TEXT_READOUT, TEXT_ERROR};
enum PrimState {PRIM_IDLE, PRIM_LOADED, PRIM_EXECUTING, PRIM_WAITING, PRIM_PAUSED}; 
enum TEXT_BUFFER_TYPE {TEXT_ERR, TEXT_INFO, TEXT_DIAG, TEXT_XFER, TEXT_UNDEF};
enum HpidMode {DYNAMIC, AUTO, NO_AUTO};

//------------------------------NoImageFile--------------------------------- 

class NoImageFile : public BaseException {
public:
  NoImageFile( std::string descriptor, std::string fileName);
  std::string getFileName() {return m_fileName;};
  virtual void what(std::ostream&);

private:
  std::string m_fileName;
};                                                                             

//------------------------------HpiException--------------------------------- 

class HpiException : public BaseException {
public:
  HpiException( std::string descriptor, unsigned long calcAddr, unsigned long readAddr);
  unsigned long getCalcAddr() {return m_calcAddr;};
  unsigned long getReadAddr() {return m_readAddr;};
  virtual void what(std::ostream&);

private:
  unsigned long m_calcAddr;    // The calculated (expected) address
  unsigned long m_readAddr;    // The address actually read
};                                                                            

//------------------------------RodException------------------------------ 

class RodException : public BaseException {
public:
  RodException( std::string descriptor);
  RodException( std::string descriptor, unsigned long data1);
  RodException( std::string descriptor, unsigned long data1, unsigned long data2);
  unsigned long getData1() {return m_data1;};
  unsigned long getData2() {return m_data2;};
  unsigned long getNumData() {return m_numData;};
  virtual void what(std::ostream&);
  
private:
  unsigned long m_numData;  // Number of data values returned
  unsigned long m_data1;    // First data value returned
  unsigned long m_data2;    // Second data value returned
};                                                                            

//------------------------------------------------------------------------------              

class RodModule : public VmeModule {
  RodModule(const RodModule& rhs);
  RodModule &operator=(const RodModule & rhs);

public:

  // Constructors, destructor, and assignment
  RodModule( unsigned long baseAddr, unsigned long mapSize, VmeInterface & ourInterface, 
             long numSlaves) throw (RodException&, VmeException &);
  virtual ~RodModule();                                  // Destructor
  
  // Accessor functions

  unsigned long getBaseAddress() {return m_baseAddress; }
  long getSlot() const { return m_slot; }
  unsigned long getSerialNumber() {return m_serialNumber;};
  unsigned long getRevision() {return m_revision;};
  void setNumSlaves( long numSlaves) { m_numSlaves = numSlaves; }
  long getNumSlaves() const { return m_numSlaves; }
  void setFinBufferSize( long finBufferSize) { m_finBufferSize = finBufferSize;}
  long getFinBufferSize() const { return m_finBufferSize; }
  std::string getMasterImageName() {return m_masterImageName; }
  std::string getslaveIpramName(long slaveNum) {return m_slaveIpramName[slaveNum];}
  std::string getslaveIdramName(long slaveNum) {return m_slaveIdramName[slaveNum];}
  std::string getslaveExtName(long slaveNum) {return m_slaveExtName[slaveNum];}
  unsigned long getVmeCommandRegVal(long regNum) {
    return m_vmeCommandReg[regNum];
  };
  VmePort* getVmePort() {return m_myVmePort; };
  void setBoc(BocCard* myBoc);
  BocCard* getBocCard();
  void setOutList(RodOutList* outList) {m_myOutList = outList;};
  RodOutList* getOutList() {return m_myOutList;};
  PrimState getPrimState() {return m_myPrimState;};
  TextBuffState getTextState() {return m_myTextState;};
  
  long getMode() { return long(m_txtBuffer.mode);};
  long getOverwrite() {return long(m_txtBuffer.overwrite);};
  long getOverflow() {return long(m_txtBuffer.overflow);};
  long getWrap() {return long(m_txtBuffer.wrap);};
  TEXT_BUFFER_TYPE getTextBufferType() {return m_textType;};
    
  void initialize();
  void initialize(bool resetFlag) throw (RodException &, VmeException &);
  
  void reset() throw (RodException&, VmeException &);

  void status() throw();

  bool verify() throw();
  
  void initSlaveDsp(const std::string & ipramFile,
     const std::string & idramFile,const std::string & extFile, 
     const long slaveNumber, char opt='n') throw(RodException&, NoImageFile&, VmeException &);
     
  void loadSlaveImage(const std::string & filename, const unsigned long address,
        const long slaveNumber, char opt='n') 
        throw (NoImageFile &, RodException &, VmeException &);
                      
  void startSlave(const long slaveNumber, char mode='s') throw(RodException &, VmeException &);
  
  void synchSendPrim(RodPrimitive & prim) throw (RodException &, VmeException &) ;

  void sendPrimList(RodPrimList *l) throw(PrimListException &, VmeException &) ;
  
  PrimState primHandler() throw (RodException &, VmeException &);
  
  inline bool getDspAck() {return readRodStatusBit(0, DSPACK);};
  
  inline void setInListReady(){setVmeCommandRegBit(INLISTRDY); return;};
  
  void deleteOutList() throw() ;

  inline long getAllTextBuffBits() {   
    unsigned long regValue;
    regValue = readRodStatusReg(0);
    return (regValue>>TEXT_BUFF_NOT_EMPTY[0] & 0xF);
  };
  
  TextBuffState textHandler() throw(VmeException &) ;
  
  void getTextBuffer(char * buffer, long & length, TEXT_BUFFER_TYPE & type)
      throw();
  
  void clearTextBuffer() throw();

  inline unsigned long readRodStatusReg(long regNumber) {
    unsigned long regValue;
    regValue = mdspSingleRead(STATUS_REG[regNumber]);
    return regValue;
  };
  
  inline unsigned long readRodCommandReg(long regNumber) {
    unsigned long regValue;
    regValue = mdspSingleRead(COMMAND_REG[regNumber]);
    return regValue;
  };
  
  inline bool readRodStatusBit(long regNumber, long bitNumber) {
    unsigned long rodStatusReg;
    rodStatusReg = readRodStatusReg(regNumber);
    return (0x1) & (readRodStatusReg(regNumber)>>bitNumber);
  };
  
  inline void setVmeCommandRegBit(const long bitNumber) {
    setBit(&m_vmeCommandReg[0], bitNumber);
    mdspSingleWrite(COMMAND_REG[0], m_vmeCommandReg[0]);
    return;
  };
  
  inline void clearVmeCommandRegBit(const long bitNumber) {
    clearBit(&m_vmeCommandReg[0], bitNumber);
    mdspSingleWrite(COMMAND_REG[0], m_vmeCommandReg[0]);
    return;
  };
  
  void hpiLoad(const unsigned long hpiReg, const unsigned long hpiValue) 
       throw(VmeException &);

  unsigned long hpiFetch(const unsigned long hpiReg) throw(VmeException &);

  unsigned long mdspSingleRead(const unsigned long dspAddr) throw(VmeException &);

  void mdspSingleWrite(unsigned long dspAddr, unsigned long buffer) 
    throw(VmeException &);

  void mdspBlockRead(const unsigned long dspAddr, unsigned long *buffer, 
       long wordCount, HpidMode mode=DYNAMIC) 
       throw (HpiException &, VmeException &);

  void mdspBlockWrite(const unsigned long dspAddr, unsigned long *buffer, 
       long wordCount, HpidMode mode=DYNAMIC) 
       throw (HpiException &, VmeException &);

  void mdspBlockDump(const unsigned long firstAddress, 
       const unsigned long lastAddress, const std::string & fileName) 
       throw(RodException &, VmeException &);
                     
  void slvHpiLoad(unsigned long hpiReg, unsigned long hpiValue,
                           long slaveNum) throw(VmeException &);
                           
  unsigned long slvHpiFetch(unsigned long hpiReg, long slaveNum) 
                throw(VmeException &);

  unsigned long slvSingleRead(unsigned long dspAddr, long slaveNum ) 
                throw(VmeException &);
                                          
  void slvSingleWrite(unsigned long dspAddr, unsigned long buffer, 
       long slaveNum) throw(VmeException &);

  void slvBlockRead(const unsigned long dspAddr, unsigned long buffer[],
       const long wordCount, long slaveNum, HpidMode mode=DYNAMIC) 
       throw (HpiException &, VmeException &);
                
  void slvBlockWrite(unsigned long dspAddr, unsigned long buffer[], 
       const long wordCount, long slaveNum, HpidMode mode=DYNAMIC) 
        throw (HpiException &, VmeException &);
         
  void resetMasterDsp() throw(RodException &, VmeException &);
  
  void resetSlaveDsp(long slaveNumber) throw(RodException &, VmeException &);
  
  void resetAllDsps() throw(RodException &, VmeException &);
  
  void chipEraseHpi() throw(VmeException &);
  
  void sectorErase(unsigned long sectorBaseAddress) 
       throw(RodException &, VmeException &) ;
  
  void writeByteToFlash(unsigned long address, UINT8 data) 
       throw (RodException &, VmeException &);
  
  void writeBlockToFlash(unsigned long address, UINT8 *data, 
                      unsigned long numBytes) throw(RodException &, VmeException &);
                      
  void writeBlockToFlashHpi(unsigned long address, UINT8 *data, unsigned long numBytes)
                            throw (RodException &, VmeException &);
                            
  UINT8 readByteFromFlash(unsigned long address, long updateAddress) 
                            throw (RodException &, VmeException &);
                            
  void vmeWriteElementFlash(UINT8 value, unsigned long address, 
                 long handshakeBit) throw (RodException &, VmeException &);
                 
  void readBlockFromFlash(unsigned long address, UINT8 *buffer, unsigned long
                          numBytes) throw(RodException &, VmeException &) ;
                          
  void commonEraseCommands(unsigned long flashBaseAddr) throw(RodException &, VmeException &);
  
  void commonEraseCommandsHpi(unsigned long flashBaseAddr) throw(VmeException &);
   
  unsigned long getFlashSectorSize();
  
  void sleep(const double milliSecs);

  unsigned long checkSum(const unsigned long *sourceArray, const long wordCount);
  
  unsigned long endianReverse32(const unsigned long inVal);
  

private:
  inline void setBit(unsigned long *var, long bitNumber) {
    *var = *var | (1<<bitNumber);
    return;
  }
  
  inline void clearBit(unsigned long *var, long bitNumber) {
    *var&=(~(1<<bitNumber));
    return;
  }
  
  inline bool readBit(unsigned long var, long bitNumber) 
    {return ((var>>bitNumber)&1);}
  
  long m_slot;
  
  unsigned long m_serialNumber;
  
  unsigned long m_revision;
  
  VmePort* m_myVmePort;

  long m_numSlaves;

  long m_finBufferSize;

  std::string m_masterImageName;

  std::string m_slaveIpramName[4];

  std::string m_slaveIdramName[4];

  std::string m_slaveExtName[4];

  unsigned long m_vmeCommandReg[2];
  unsigned long m_rodStatusReg[3];
  
  RodOutList* m_myOutList;
  
  PrimState m_myPrimState;
      
  TextBuffState m_myTextState;
  
  TEXT_BUFFER_TYPE m_textType;
  
  struct TXTBUFFER m_txtBuffer;
  
  char m_textData[TEXT_BUFF_SIZE];
  
  unsigned long* m_textBuff[N_TXT_BUFFS];
  
  BocCard* m_myBoc;
  
}; // End of class RodModule declaration

}; //  End namespace SctPixelRod

//---------------------------- Overload operator<< -----------------------------
/* This overloaded operator lets us use cout to print the status of the ROD
 * and exception information.
*/
  std::ostream& operator<<(std::ostream& os, SctPixelRod::RodModule& rod);
/*   std::ostream& operator<<(std::ostream& os, SctPixelRod::RodException& rodExcept); */
/*   std::ostream& operator<<(std::ostream& os, SctPixelRod::HpiException& hpiExcept); */
/*   std::ostream& operator<<(std::ostream& os, SctPixelRod::NoImageFile& noImageExcept); */

#endif // SCTPIXELROD_RODMODULE_H

---