From c9fabe117947a82e05bf08cbf4f69365c2334304 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Wed, 4 Sep 2019 17:10:02 -0700 Subject: [PATCH] dev: Generalize the x86 int source/sink pins. Sink pins are now templated based on the underlying device types, and the pins themselves are based on the new, generalized Port mechanism. Change-Id: I09c678c56f6eb6b4a167c12f221ae0241fe99c2d Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/20700 Reviewed-by: Andreas Sandberg Maintainer: Gabe Black Tested-by: kokoro --- src/dev/IntPin.py | 52 ++++++++++++++++++++ src/dev/SConscript | 3 ++ src/dev/intpin.cc | 69 ++++++++++++++++++++++++++ src/dev/intpin.hh | 120 +++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 244 insertions(+) create mode 100644 src/dev/IntPin.py create mode 100644 src/dev/intpin.cc create mode 100644 src/dev/intpin.hh diff --git a/src/dev/IntPin.py b/src/dev/IntPin.py new file mode 100644 index 000000000..8fe3b2363 --- /dev/null +++ b/src/dev/IntPin.py @@ -0,0 +1,52 @@ +# Copyright 2019 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +# Authors: Gabe Black + +from m5.params import Port, VectorPort + +INT_SOURCE_ROLE = 'Int Source Pin' +INT_SINK_ROLE = 'Int Sink Pin' +Port.compat(INT_SOURCE_ROLE, INT_SINK_ROLE) + +# A source pin generally represents a single pin which might connect to +# multiple sinks. +class IntSourcePin(VectorPort): + def __init__(self, desc): + super(IntSourcePin, self).__init__( + INT_SOURCE_ROLE, desc, is_source=True) + +# Each "physical" pin can be driven by a single source pin since there are no +# provisions for resolving competing signals running to the same pin. +class IntSinkPin(Port): + def __init__(self, desc): + super(IntSinkPin, self).__init__(INT_SINK_ROLE, desc) + +# A vector of sink pins represents a bank of physical pins. For instance, an +# interrupt controller with many numbered input interrupts could represent them +# as a VectorIntSinkPin. +class VectorIntSinkPin(VectorPort): + def __init__(self, desc): + super(VectorIntSinkPin, self).__init__(INT_SINK_ROLE, desc) diff --git a/src/dev/SConscript b/src/dev/SConscript index ecb6dccbb..69c30a693 100644 --- a/src/dev/SConscript +++ b/src/dev/SConscript @@ -36,6 +36,9 @@ Source('io_device.cc') Source('isa_fake.cc') Source('dma_device.cc') +SimObject('IntPin.py') +Source('intpin.cc') + DebugFlag('IsaFake') DebugFlag('DMA') diff --git a/src/dev/intpin.cc b/src/dev/intpin.cc new file mode 100644 index 000000000..dfb03aa8d --- /dev/null +++ b/src/dev/intpin.cc @@ -0,0 +1,69 @@ +/* + * Copyright 2019 Google, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Gabe Black + */ + +#include "dev/intpin.hh" + +#include "base/logging.hh" + +void +IntSinkPinBase::bind(Port &peer) +{ + source = dynamic_cast(&peer); + fatal_if(!source, "Attempt to bind interrupt sink pin %s to " + "incompatible port %s.", name(), peer.name()); + Port::bind(peer); +} + +void +IntSinkPinBase::unbind() +{ + source = nullptr; + Port::unbind(); +} + +void +IntSourcePinBase::bind(Port &peer) +{ + sink = dynamic_cast(&peer); + fatal_if(!sink, "Attempt to bind interrupt source pin %s to " + "incompatible port %s.", name(), peer.name()); + Port::bind(peer); + + if (_state) + raise(); + else + lower(); +} + +void +IntSourcePinBase::unbind() +{ + sink = nullptr; + Port::unbind(); +} diff --git a/src/dev/intpin.hh b/src/dev/intpin.hh new file mode 100644 index 000000000..e00aa625d --- /dev/null +++ b/src/dev/intpin.hh @@ -0,0 +1,120 @@ +/* + * Copyright 2019 Google, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Gabe Black + */ + +#ifndef __DEV_INTPIN_HH__ +#define __DEV_INTPIN_HH__ + +#include "sim/port.hh" + +class IntSourcePinBase; + +class IntSinkPinBase : public Port +{ + protected: + friend IntSourcePinBase; + + IntSourcePinBase *source = nullptr; + + int _number = 0; + bool _state = false; + + IntSinkPinBase(const std::string &_name, PortID _id, int num) : + Port(_name, _id), _number(num) + {} + + virtual void raiseOnDevice() = 0; + virtual void lowerOnDevice() = 0; + + void + raise() + { + _state = true; + raiseOnDevice(); + } + + void + lower() + { + _state = false; + lowerOnDevice(); + } + + public: + int number() { return _number; } + bool state() { return _state; } + + void bind(Port &peer) override; + void unbind() override; +}; + +template +class IntSinkPin : public IntSinkPinBase +{ + private: + Device *device = nullptr; + + void raiseOnDevice() override { device->raiseInterruptPin(number()); } + void lowerOnDevice() override { device->lowerInterruptPin(number()); } + + public: + IntSinkPin(const std::string &_name, PortID _id, Device *dev, int num) : + IntSinkPinBase(_name, _id, num), device(dev) {} + IntSinkPin(const std::string &_name, PortID _id, Device *dev) : + IntSinkPin(_name, _id, dev, _id) {} +}; + +class IntSourcePinBase : public Port +{ + private: + IntSinkPinBase *sink = nullptr; + bool _state = false; + + public: + IntSourcePinBase(const std::string &_name, PortID _id, bool def_state) : + Port(_name, _id), _state(def_state) + {} + + void raise() { sink->raise(); } + void lower() { sink->lower(); } + + void bind(Port &peer) override; + void unbind() override; +}; + +template +class IntSourcePin : public IntSourcePinBase +{ + public: + IntSourcePin(const std::string &_name, PortID _id, Device *owner, + bool def_state=false) : + IntSourcePinBase(_name, _id, def_state) + {} +}; + +#endif //__DEV_INTPIN_HH__ -- 2.30.2