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

Go to the documentation of this file.

#ifndef __PCIDevice
#define __PCIDevice

#include <string>
#include <vector>

#include "hal/IllegalValueException.hh"
#include "hal/PCIAddressTable.hh"
#include "hal/HardwareDevice.hh"
#include "hal/PCIDeviceIdentifier.hh"
#include "hal/PCIBusAdapterInterface.hh"

namespace HAL {

class PCIDevice : public HardwareDevice {

public:

  typedef struct PCILocationIdentifier_s {
    uint32_t busID;
    uint32_t slotID;
    uint32_t functionID;
  } PCILocationIdentifier;
      
  PCIDevice( PCIAddressTable & addressTable,
             PCIBusAdapterInterface & pciBusAdapter,
             uint32_t vendorID,
             uint32_t deviceID,
             uint32_t index,
             bool swapFlag = false);

  PCIDevice( PCIAddressTable & addressTable,
             PCIBusAdapterInterface & pciBusAdapter,
             uint32_t vendorID,
             uint32_t deviceID,
             uint32_t index,
             std::vector<uint32_t>& baseAddresses,
             uint32_t command );


  PCIDevice( PCIAddressTable & addressTable,
             PCIBusAdapterInterface & pciBusAdapter,
             const PCILocationIdentifier& location,
             bool swapFlag );

  virtual ~PCIDevice();

  void hardwareWrite( const GeneralHardwareAddress& pciAddress, 
                      uint32_t data,
                      uint32_t offset = 0 ) const
    throw (IllegalValueException,
           BusAdapterException);
  void hardwareRead( const GeneralHardwareAddress& pciAddress, 
                     uint32_t* result,
                     uint32_t offset = 0 ) const
    throw (IllegalValueException,
           BusAdapterException);

  void memoryWrite( uint32_t address,
                    uint32_t barId,
                    uint32_t data ) const
    throw (IllegalValueException,
           BusAdapterException);
  
  void memoryRead( uint32_t address,
                   uint32_t barId,
                   uint32_t* result ) const
    throw (IllegalValueException,
           BusAdapterException);

  void configWrite( uint32_t address,
                    uint32_t data ) const
    throw (BusAdapterException);
  
  void configRead( uint32_t address,
                   uint32_t* result ) const
    throw (BusAdapterException);


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

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

  uint32_t getItemAddress( std::string ) const
    throw ( NoSuchItemException,
            IllegalOperationException );

  uint32_t getPCIBusAddress( uint32_t iBar )
    throw (BusAdapterException);



private:
  PCIAddressTable& pciAddressTable;
  PCIBusAdapterInterface& pciBusAdapter;
  PCIDeviceIdentifier* deviceIdentifierPtr;
  std::vector<uint32_t> baseRegisters;
};

} /* namespace HAL */

#endif /* __PCIDevice */