gem5/ext/nomali/lib/gpublock.hh

222 lines
6.2 KiB
C++
Raw Normal View History

/*
* Copyright (c) 2014-2015 ARM Limited
* All rights reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Authors: Andreas Sandberg
*/
#ifndef _LIBNOMALIMODEL_GPUBLOCK_HH
#define _LIBNOMALIMODEL_GPUBLOCK_HH
#include "types.hh"
namespace NoMali {
class GPU;
/**
* Base class for GPU function blocks providing common access
* functions.
*/
class GPUBlock
{
public:
GPUBlock(GPU &_gpu);
GPUBlock(GPU &_gpu, RegVector::size_type no_regs);
GPUBlock(GPUBlock &&rhs);
virtual ~GPUBlock() = 0;
/**
* Reset the function block.
*
* This method is called to simulated a hard reset of the GPU. It
* resets all registers to their default state and resets any
* block-specific state. The default implementation resets all
* registers to 0.
*/
virtual void reset();
/**
* @{
* @name Register Interface
*/
/**
* Read a register within a function block.
*
* @param addr Function-block relative address.
* @return Register value (32-bits)
*/
virtual uint32_t readReg(RegAddr addr);
/**
* Write to a register within a function block.
*
* @param addr Function-block relative address.
* @param value New value (32-bits)
*/
virtual void writeReg(RegAddr addr, uint32_t value);
/**
* Read a register within a function block without side effects.
*
* Unlike a normal read (readReg()), this method does not include
* any side effects and reads straight from the register file. It
* is primarily intended for things checkpointing.
*
* @param addr Function-block relative address.
* @return Register value (32-bits)
*/
virtual uint32_t readRegRaw(RegAddr addr);
/**
* Write to a register within a function block without side
* effects.
*
* Unlike a normal write (writeReg()), this method does not
* include any side effects and writes straight into the register
* file. It is primarily intended for things checkpointing.
*
* @param addr Function-block relative address.
* @param value New value (32-bits)
*/
virtual void writeRegRaw(RegAddr addr, uint32_t value);
/** @} */
protected:
/** Reference to the top-level GPU component */
GPU &gpu;
/** GPU block register file */
RegVector regs;
private:
/** Disable the default constructor */
GPUBlock();
/** Disable the copy constructor */
GPUBlock(GPUBlock &_rhs);
/** Disable the assignment operator */
GPUBlock &operator=(GPUBlock &_rhs);
};
/**
* Base class for interrupt enabled GPU function blocks.
*
* Function blocks with interrupt functionality implement four
* different registers controlling interrupts:
* <ul>
* <li>XX_IRQ_RAWSTAT -- Raw interrupt state bit mask. (RW)
* <li>XX_IRQ_CLEAR -- Interrupt clear register. (WO)
* <li>XX_IRQ_MASK -- Bitmaks of enabled interrupts. (RW)
* <li>XX_IRQ_STATUS -- Currently pending unmasked interrupts. (RO)
* </ul>
*
* This class provides implements the handling of the registers above
* and utility functions to raise interrupts from the function block
* models.
*/
class GPUBlockInt
: public GPUBlock
{
public:
GPUBlockInt(GPU &_gpu,
const RegAddr &irq_raw_stat,
const RegAddr &irq_clear,
const RegAddr &irq_mask,
const RegAddr &irq_stat);
virtual ~GPUBlockInt() = 0;
uint32_t readReg(RegAddr addr) override;
void writeReg(RegAddr addr, uint32_t value) override;
/**
* Raise an interrupt from this function block.
*
* Calling this method flags the interrupts in ints as pending in
* the raw interrupt status register. If this operation asserts a
* new unmasked interrupt (i.e., the state of the interrupt status
* register changes), the onInterrupt() callback is called to
* signal an interrupt state change.
*
* @param ints Bitfield representing interrupts to raise.
*/
void raiseInterrupt(uint32_t ints);
/**
* Clear an interrupt from this function block.
*
* Calling this method clears the interrupts in ints in the raw
* interrupt status register. If this operation clears a an
* existing interrupt (i.e., the state of the interrupt status
* register changes), the onInterrupt() callback is called to
* signal an interrupt state change.
*
* @param ints Bitfield representing interrupts to raise.
*/
void clearInterrupt(uint32_t ints);
/**
* Current interrupt status
*
* @return The value of the raw interrupt status register
* logically anded with the interrupt mask register.
*/
uint32_t irqStatus() const;
/**
* Are there unmasked interrupts pending?
*
* @return true if the interrupt status register is non-zero,
* false otherwise.
*/
bool intAsserted() const { return !!irqStatus(); }
protected:
/**
* Callback method for interrupt status change.
*
* This method is called whenever the interrupt signal going out
* of this GPU block changes. The new state of the signal can be
* determined from the 'set' parameter which is non-zero if the
* inerrupt is raised and zero if it is cleared. The state of the
* interrupt signal can also be queried using the irqStatus()
* method.
*
* @see raiseInterrupt()
* @see clearInterrupt()
* @see irqStatus()
*
* @param set Non-zero to raise interrupt, zero to clear
* interrupt.
*/
virtual void onInterrupt(int set) = 0;
private:
const RegAddr addrIrqRawStat;
const RegAddr addrIrqClear;
const RegAddr addrIrqMask;
const RegAddr addrIrqStat;
};
}
#endif // _LIBNOMALIMODEL_GPUBLOCK_HH