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

Go to the documentation of this file.

#ifndef __HardwareDevice
#define __HardwareDevice

#include <string>
#include <iostream>

#include "hal/IllegalOperationException.hh"
#include "hal/NoSuchItemException.hh"
#include "hal/VerifyException.hh"
#include "hal/UnsupportedException.hh"
#include "hal/GeneralHardwareAddress.hh"
#include "hal/AddressTableInterface.hh"
#include "hal/AddressTableItem.hh"
#include "hal/HardwareDeviceInterface.hh"
#include "hal/MaskBoundaryException.hh"
#include "hal/linux/StopWatch.hh"
#include "hal/AddressOutOfLimitsException.hh"

namespace HAL {

class HardwareDevice : public HardwareDeviceInterface {

public:
  HardwareDevice( AddressTableInterface & AddressTable );

  virtual ~HardwareDevice();

  void unmaskedWrite( std::string item, 
                      uint32_t data, 
                      HalVerifyOption verifyFlag = HAL_NO_VERIFY,
                      uint32_t offset = 0 ) const
    throw (NoSuchItemException, 
           IllegalOperationException, 
           BusAdapterException,
           VerifyException,
           AddressOutOfLimitsException);

  void write( std::string item, 
              uint32_t data, 
              HalVerifyOption verifyFlag = HAL_NO_VERIFY,
              uint32_t offset = 0 ) const
    throw (NoSuchItemException,
           BusAdapterException,
           IllegalOperationException, 
           VerifyException,
           MaskBoundaryException,
           AddressOutOfLimitsException);

  void writePulse( std::string item, 
                   uint32_t offset = 0 ) const
    throw (NoSuchItemException, 
           BusAdapterException,
           IllegalOperationException,
           AddressOutOfLimitsException);

  void readPulse( std::string item, 
                  uint32_t offset = 0 ) const
    throw (NoSuchItemException,
           BusAdapterException,
           IllegalOperationException,
           AddressOutOfLimitsException);

  void unmaskedRead( std::string item, 
                     uint32_t* result, 
                     uint32_t offset = 0 ) const
    throw (NoSuchItemException,
           BusAdapterException,
           IllegalOperationException,
           AddressOutOfLimitsException);

  void read( std::string item, 
             uint32_t* result, 
             uint32_t offset = 0 ) const
    throw (NoSuchItemException,
           BusAdapterException,
           IllegalOperationException,
           MaskBoundaryException,
           AddressOutOfLimitsException );

  bool check( std::string item,
              uint32_t expected,
              std::string faultMessage = "",
              uint32_t offset = 0,
              std::ostream& os = std::cout ) const
    throw( NoSuchItemException,
           IllegalOperationException,
           BusAdapterException,
           AddressOutOfLimitsException);

  void setBit( std::string item, 
               HalVerifyOption verifyFlag = HAL_NO_VERIFY,
               uint32_t offset = 0 ) const
    throw (NoSuchItemException, 
           IllegalOperationException, 
           BusAdapterException,
           VerifyException,
           AddressOutOfLimitsException);

  void resetBit( std::string item, 
                 HalVerifyOption verifyFlag = HAL_NO_VERIFY,
                 uint32_t offset = 0 ) const
    throw (NoSuchItemException, 
           IllegalOperationException, 
           BusAdapterException,
           VerifyException,
           AddressOutOfLimitsException);

  bool isSet( std::string item, 
              uint32_t offset = 0 ) const 
    throw (NoSuchItemException,
           BusAdapterException,
           IllegalOperationException,
           AddressOutOfLimitsException);

  void writeBlock( std::string startItem, 
                   uint32_t length,
                   char *buffer,
                   HalVerifyOption verifyFlag = HAL_NO_VERIFY,
                   HalAddressIncrement addressBehaviour = HAL_DO_INCREMENT,
                   uint32_t offset = 0 ) const
    throw ( NoSuchItemException,
            IllegalValueException, 
            UnsupportedException, 
            VerifyException,
            BusAdapterException,
            IllegalOperationException,
            AddressOutOfLimitsException );

  void readBlock( std::string startItem, 
                  uint32_t length,
                  char *buffer,
                  HalAddressIncrement addressBehaviour = HAL_DO_INCREMENT,
                  uint32_t offset = 0 ) const
    throw ( NoSuchItemException,
            IllegalValueException, 
            UnsupportedException,
            BusAdapterException,
            IllegalOperationException,
            AddressOutOfLimitsException );

  void pollItem( std::string item,
                 uint32_t referenceValue,
                 uint32_t timeout,
                 uint32_t *result,
                 HalPollMethod pollMethod = HAL_POLL_UNTIL_EQUAL,
                 uint32_t offset = 0 ) const
    throw ( NoSuchItemException,
            IllegalOperationException,
            BusAdapterException,
            MaskBoundaryException,
            TimeoutException,
            AddressOutOfLimitsException );

  const AddressTableInterface&  getAddressTableInterface() const; 

  void printAddressTable() const;


  virtual void hardwareRead( const GeneralHardwareAddress& address, 
                             uint32_t* result,
                             uint32_t offset = 0 ) const
    throw (IllegalValueException,
           BusAdapterException) = 0;


  virtual void hardwareWrite( const GeneralHardwareAddress& address, 
                              uint32_t data,
                              uint32_t offset = 0 ) const
    throw (IllegalValueException,
           BusAdapterException) = 0;

  virtual void hardwareReadBlock( const GeneralHardwareAddress& address,
                                  uint32_t length,
                                  char *buffer,
                                  HalAddressIncrement addressBehaviour = HAL_DO_INCREMENT,
                                  uint32_t offset = 0 ) const
    throw (IllegalValueException, 
           UnsupportedException,
           IllegalOperationException,
           BusAdapterException) = 0;

  virtual void hardwareWriteBlock( const GeneralHardwareAddress& address,
                                   uint32_t length,
                                   char *buffer,
                                   HalAddressIncrement addressBehaviour = HAL_DO_INCREMENT,
                                   uint32_t offset = 0 ) const
    throw (IllegalValueException, 
           UnsupportedException, 
           IllegalOperationException,
           BusAdapterException) = 0;

private:
  void verify( uint32_t readBack,
               uint32_t data,
               std::string methodName ) const
    throw( VerifyException );
  
  void writeAddressItem( const AddressTableItem& addressItem,
                         uint32_t data,
                         uint32_t offset,
                         HalVerifyOption verify) const
    throw( MaskBoundaryException,
           IllegalValueException,
           BusAdapterException,
           VerifyException,
           AddressOutOfLimitsException );

  AddressTableInterface& addressTable;
};

} /* namespace HAL */

#endif /* __HardwareDevice */