/home/cschwick/hal/generic/include/hal/VME64xCrate.hh

Go to the documentation of this file.

#ifndef __VME64xCrate
#define __VME64xCrate

#include <vector>
#include <functional>

#include "hal/VMEDevice.hh"
#include "hal/VMEBusAdapterInterface.hh"
#include "hal/AddressTableContainerInterface.hh"
#include "hal/StaticVMEConfiguration.hh"
#include "hal/ModuleMapperInterface.hh"
#include "hal/VMEConfigurationSpaceHandler.hh"
#include "hal/VMESlot.hh"
#include "hal/HardwareProblemException.hh"
#include "hal/UnsupportedException.hh"

namespace HAL {

class VME64xCrate {
public:

  VME64xCrate( VMEBusAdapterInterface& busAdapter,
               AddressTableContainerInterface& addressTables,
               ModuleMapperInterface& moduleMapper )
  throw( HardwareProblemException,
         IllegalValueException,
         UnsupportedException );


  VME64xCrate( VMEBusAdapterInterface& busAdapter,
               AddressTableContainerInterface& addressTableContainer,
               ModuleMapperInterface& moduleMapper,
               const StaticVMEConfiguration& staticConfiguration ) 
  throw( HardwareProblemException,
         IllegalValueException,
         UnsupportedException );

  VMEDevice* getVMEDevice( uint32_t slotId ) const
    throw ( IllegalOperationException,
            IllegalValueException,
            UnsupportedException,
            BusAdapterException,
            NoSuchItemException );
 
  VMESlot* getVMESlot( uint32_t slotId ) const
    throw( IllegalValueException );

  void printAddressMap( std::ostream& out ) const;



private:
  struct MappedItem {
    uint32_t startAddress;
    uint32_t endAddress;
    uint32_t baseAddress;
    uint32_t AM;
    VME64xMappedWindow* windowPtr;
    bool configured;
  };

  class MappedItemSorter {
  public:
    bool operator()( const struct MappedItem* x, const struct MappedItem* y ) const {
      return( x->baseAddress > y->baseAddress );
    }
  };

 class WindowSorter {
  public:
    bool operator() ( const VME64xMappedWindow* x, 
                      const VME64xMappedWindow* y) const {
      return ( x->getAddressRank() < y->getAddressRank() );
    }
  };

  void configurePlugAndPlay() throw( IllegalValueException,
                                     UnsupportedException );
  void populateWithStaticConfiguration( const StaticVMEConfiguration& staticConfiguration )
    throw( IllegalValueException );

  void populateWithPlugAndPlay() throw( IllegalValueException,
                                        UnsupportedException );

  void getAllWindows();

  void mapCrate();

  void mapWindow( VME64xMappedWindow* windowPtr, 
                  uint32_t maxAddress, 
                  uint32_t baseMin );

  bool isOccupied( uint32_t base, uint32_t space, bool bit33 );
  
  void makeOccupiedList();

  void enablePlugAndPlayModules() throw ( IllegalOperationException );

  bool mapped_;
  VMEBusAdapterInterface& busAdapter_;
  AddressTableContainerInterface& addressTableContainer_;
  ModuleMapperInterface& moduleMapper_;
  VMEConfigurationSpaceHandler vmeConfigSpaceHandler_;
  std::vector< VMESlot* > slotPtrVector_;
  std::list < struct MappedItem * > occupiedItemList_;
  std::list < VME64xMappedWindow * > windowList_;
  std::list < const VME64xMappedWindow * > notMappedList_;
};

} /* namespace HAL */

#endif /* __VME64xCrate */