type = 'PioDevice'
cxx_header = "dev/io_device.hh"
abstract = True
- pio = SlavePort("Programmed I/O port")
+ pio = ResponsePort("Programmed I/O port")
system = Param.System(Parent.any, "System this device is part of")
def generateBasicPioDeviceNode(self, state, name, pio_addr,
type = 'DmaDevice'
cxx_header = "dev/dma_device.hh"
abstract = True
- dma = MasterPort("DMA port")
+ dma = RequestPort("DMA port")
_iommu = None
type = 'Gicv3Its'
cxx_header = "dev/arm/gic_v3_its.hh"
- dma = MasterPort("DMA port")
+ dma = RequestPort("DMA port")
pio_size = Param.Unsigned(0x20000, "Gicv3Its pio size")
# CIL [36] = 0: ITS supports 16-bit CollectionID
type = 'SMMUv3SlaveInterface'
cxx_header = 'dev/arm/smmu_v3_slaveifc.hh'
- slave = SlavePort('Device port')
- ats_master = MasterPort('ATS master port')
- ats_slave = SlavePort('ATS slave port')
+ slave = ResponsePort('Device port')
+ ats_master = RequestPort('ATS master port')
+ ats_slave = ResponsePort('ATS slave port')
port_width = Param.Unsigned(16, 'Port width in bytes (= 1 beat)')
wrbuf_slots = Param.Unsigned(16, 'Write buffer size (in beats)')
type = 'SMMUv3'
cxx_header = 'dev/arm/smmu_v3.hh'
- master = MasterPort('Master port')
- master_walker = MasterPort(
+ master = RequestPort('Master port')
+ master_walker = RequestPort(
'Master port for SMMU initiated HWTW requests (optional)')
- control = SlavePort('Control port for accessing memory-mapped registers')
+ control = ResponsePort(
+ 'Control port for accessing memory-mapped registers')
sample_period = Param.Clock('10us', 'Stats sample period')
reg_map = Param.AddrRange('Address range for control registers')
system = Param.System(Parent.any, "System this device is part of")
friend class ::ItsTranslation;
friend class ::ItsCommand;
public:
- class DataPort : public MasterPort
+ class DataPort : public RequestPort
{
protected:
Gicv3Its &its;
public:
DataPort(const std::string &_name, Gicv3Its &_its) :
- MasterPort(_name, &_its),
+ RequestPort(_name, &_its),
its(_its)
{}
#include "dev/arm/smmu_v3_slaveifc.hh"
SMMUMasterPort::SMMUMasterPort(const std::string &_name, SMMUv3 &_smmu) :
- MasterPort(_name, &_smmu),
+ RequestPort(_name, &_smmu),
smmu(_smmu)
{}
SMMUMasterTableWalkPort::SMMUMasterTableWalkPort(const std::string &_name,
SMMUv3 &_smmu) :
- MasterPort(_name, &_smmu),
+ RequestPort(_name, &_smmu),
smmu(_smmu)
{}
class SMMUv3;
class SMMUv3SlaveInterface;
-class SMMUMasterPort : public MasterPort
+class SMMUMasterPort : public RequestPort
{
protected:
SMMUv3 &smmu;
};
// Separate master port to send MMU initiated requests on
-class SMMUMasterTableWalkPort : public MasterPort
+class SMMUMasterTableWalkPort : public RequestPort
{
protected:
SMMUv3 &smmu;
DmaPort::DmaPort(ClockedObject *dev, System *s,
uint32_t sid, uint32_t ssid)
- : MasterPort(dev->name() + ".dma", dev),
+ : RequestPort(dev->name() + ".dma", dev),
device(dev), sys(s), masterId(s->getMasterId(dev)),
sendEvent([this]{ sendDma(); }, dev->name()),
pendingCount(0), inRetry(false),
class ClockedObject;
-class DmaPort : public MasterPort, public Drainable
+class DmaPort : public RequestPort, public Drainable
{
private:
cxx_class = 'X86ISA::I82094AA'
cxx_header = "dev/x86/i82094aa.hh"
apic_id = Param.Int(1, 'APIC id for this IO APIC')
- int_master = MasterPort("Port for sending interrupt messages")
+ int_master = RequestPort("Port for sending interrupt messages")
int_latency = Param.Latency('1ns', \
"Latency for an interrupt to propagate through this device.")
external_int_pic = Param.I8259(NULL, "External PIC, if any")