blob: a771976d98bc6dfd514601328f92db881bcbdbab [file] [log] [blame]
/*
* Copyright (c) 2021 Advanced Micro Devices, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. 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.
*
* 3. Neither the name of the copyright holder 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 HOLDER 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.
*
*/
#include "dev/amdgpu/interrupt_handler.hh"
#include "debug/AMDGPUDevice.hh"
#include "dev/amdgpu/ih_mmio.hh"
#include "mem/packet_access.hh"
// For generating interrupts, the object causing interrupt communicates with
// the Interrupt Handler (IH), which submits a 256-bit Interrupt packet to the
// system memory. The location where the IH submits the packet is the
// IH Ring buffer in the system memory. The IH updates the Write Pointer
// and the host consumes the ring buffer and once done, updates the Read
// Pointer through the doorbell.
// IH_RB_BaseAddr, IH_RB_WptrAddr (Lo/Hi), IH_RB_RptrAddr (Lo/Hi), etc. are
// not GART addresses but system dma addresses and thus don't require
// translations through the GART table.
namespace gem5
{
AMDGPUInterruptHandler::AMDGPUInterruptHandler(
const AMDGPUInterruptHandlerParams &p)
: DmaDevice(p)
{
memset(&regs, 0, sizeof(AMDGPUIHRegs));
}
AddrRangeList
AMDGPUInterruptHandler::getAddrRanges() const
{
AddrRangeList ranges;
return ranges;
}
void
AMDGPUInterruptHandler::intrPost()
{
if (gpuDevice)
gpuDevice->intrPost();
}
void
AMDGPUInterruptHandler::prepareInterruptCookie(ContextID cntxt_id,
uint32_t ring_id,
uint32_t client_id,
uint32_t source_id)
{
assert(client_id == SOC15_IH_CLIENTID_RLC ||
client_id == SOC15_IH_CLIENTID_SDMA0 ||
client_id == SOC15_IH_CLIENTID_SDMA1 ||
client_id == SOC15_IH_CLIENTID_GRBM_CP);
assert(source_id == CP_EOP || source_id == TRAP_ID);
/**
* Setup the fields in the interrupt cookie (see header file for more
* detail on the fields). The timestamp here is a bogus value. It seems
* the driver does not really care what this value is. Additionally the
* model does not currently have anything to keep track of time. It is
* possible that tick/cycle count can be used in the future if this ends
* up being important. The remaining fields are passed from whichever
* block is sending the interrupt.
*/
AMDGPUInterruptCookie *cookie = new AMDGPUInterruptCookie();
memset(cookie, 0, sizeof(AMDGPUInterruptCookie));
// Currently only one process is supported and the first pasid from driver
// is always 0x8000. In the future this can be obtained from the PM4
// MAP_PROCESS packet and may need to be passed to this function.
//
// On a related note, leave vmid fields alone as they are only used for
// memory exceptions. Memory exceptions are not supported on gfx900.
cookie->pasid = 0x8000;
cookie->timestamp_Lo = 0x40;
cookie->clientId = client_id;
cookie->sourceId = source_id;
cookie->ringId = ring_id;
cookie->source_data_dw1 = cntxt_id;
interruptQueue.push(cookie);
}
void
AMDGPUInterruptHandler::DmaEvent::process()
{
if (data == 1) {
DPRINTF(AMDGPUDevice, "Completed interrupt cookie write\n");
deviceIh->submitWritePointer();
} else if (data == 2) {
DPRINTF(AMDGPUDevice, "Completed interrupt write pointer update\n");
deviceIh->intrPost();
} else {
fatal("Interrupt Handler DMA event returned bad value: %d\n", data);
}
}
void
AMDGPUInterruptHandler::submitWritePointer()
{
uint8_t *dataPtr = new uint8_t[sizeof(uint32_t)];
regs.IH_Wptr += sizeof(AMDGPUInterruptCookie);
Addr paddr = regs.WptrAddr;
std::memcpy(dataPtr, &regs.IH_Wptr, sizeof(uint32_t));
dmaEvent = new AMDGPUInterruptHandler::DmaEvent(this, 2);
dmaWrite(paddr, sizeof(uint32_t), dmaEvent, dataPtr);
}
void
AMDGPUInterruptHandler::submitInterruptCookie()
{
assert(!interruptQueue.empty());
auto cookie = interruptQueue.front();
size_t cookieSize = sizeof(AMDGPUInterruptCookie);
uint8_t *dataPtr = new uint8_t[cookieSize];
std::memcpy(dataPtr, cookie, cookieSize);
Addr paddr = regs.baseAddr + regs.IH_Wptr;
DPRINTF(AMDGPUDevice, "InterruptHandler rptr: 0x%x wptr: 0x%x\n",
regs.IH_Rptr, regs.IH_Wptr);
dmaEvent = new AMDGPUInterruptHandler::DmaEvent(this, 1);
dmaWrite(paddr, cookieSize, dmaEvent, dataPtr);
interruptQueue.pop();
}
void
AMDGPUInterruptHandler::writeMMIO(PacketPtr pkt, Addr mmio_offset)
{
switch (mmio_offset) {
case mmIH_RB_CNTL:
setCntl(pkt->getLE<uint32_t>());
break;
case mmIH_RB_BASE:
setBase(pkt->getLE<uint32_t>());
break;
case mmIH_RB_BASE_HI:
setBaseHi(pkt->getLE<uint32_t>());
break;
case mmIH_RB_RPTR:
setRptr(pkt->getLE<uint32_t>());
break;
case mmIH_RB_WPTR:
setWptr(pkt->getLE<uint32_t>());
break;
case mmIH_RB_WPTR_ADDR_LO:
setWptrAddrLo(pkt->getLE<uint32_t>());
break;
case mmIH_RB_WPTR_ADDR_HI:
setWptrAddrHi(pkt->getLE<uint32_t>());
break;
case mmIH_DOORBELL_RPTR:
setDoorbellOffset(pkt->getLE<uint32_t>());
if (bits(pkt->getLE<uint32_t>(), 28, 28)) {
gpuDevice->setDoorbellType(getDoorbellOffset() << 2,
InterruptHandler);
}
break;
default:
DPRINTF(AMDGPUDevice, "IH Unknown MMIO %#x\n", mmio_offset);
break;
}
}
void
AMDGPUInterruptHandler::setCntl(const uint32_t &data)
{
regs.IH_Cntl = data;
}
void
AMDGPUInterruptHandler::setBase(const uint32_t &data)
{
regs.baseAddr = data;
regs.baseAddr <<= 8;
}
void
AMDGPUInterruptHandler::setBaseHi(const uint32_t &data)
{
regs.baseAddr |= static_cast<uint64_t>(data) << 40;
}
void
AMDGPUInterruptHandler::setRptr(const uint32_t &data)
{
regs.IH_Rptr = data;
}
void
AMDGPUInterruptHandler::setWptr(const uint32_t &data)
{
regs.IH_Wptr = data;
}
void
AMDGPUInterruptHandler::setWptrAddrLo(const uint32_t &data)
{
regs.IH_Wptr_Addr_Lo = data;
regs.WptrAddr |= regs.IH_Wptr_Addr_Lo;
}
void
AMDGPUInterruptHandler::setWptrAddrHi(const uint32_t &data)
{
regs.IH_Wptr_Addr_Hi = data;
regs.WptrAddr |= ((uint64_t)regs.IH_Wptr_Addr_Hi) << 32;
}
void
AMDGPUInterruptHandler::setDoorbellOffset(const uint32_t &data)
{
regs.IH_Doorbell = data & 0x3ffffff;
}
void
AMDGPUInterruptHandler::updateRptr(const uint32_t &data)
{
regs.IH_Rptr = data; // update ring buffer rptr offset
}
void
AMDGPUInterruptHandler::serialize(CheckpointOut &cp) const
{
uint32_t ih_cntl = regs.IH_Cntl;
uint32_t ih_base = regs.IH_Base;
uint32_t ih_base_hi = regs.IH_Base_Hi;
Addr ih_baseAddr = regs.baseAddr;
uint32_t ih_rptr = regs.IH_Rptr;
uint32_t ih_wptr = regs.IH_Wptr;
uint32_t ih_wptr_addr_lo = regs.IH_Wptr_Addr_Lo;
uint32_t ih_wptr_addr_hi = regs.IH_Wptr_Addr_Hi;
Addr ih_wptrAddr = regs.WptrAddr;
uint32_t ih_doorbellOffset = regs.IH_Doorbell;
SERIALIZE_SCALAR(ih_cntl);
SERIALIZE_SCALAR(ih_base);
SERIALIZE_SCALAR(ih_base_hi);
SERIALIZE_SCALAR(ih_baseAddr);
SERIALIZE_SCALAR(ih_rptr);
SERIALIZE_SCALAR(ih_wptr);
SERIALIZE_SCALAR(ih_wptr_addr_lo);
SERIALIZE_SCALAR(ih_wptr_addr_hi);
SERIALIZE_SCALAR(ih_wptrAddr);
SERIALIZE_SCALAR(ih_doorbellOffset);
}
void
AMDGPUInterruptHandler::unserialize(CheckpointIn &cp)
{
uint32_t ih_cntl;
uint32_t ih_base;
uint32_t ih_base_hi;
Addr ih_baseAddr;
uint32_t ih_rptr;
uint32_t ih_wptr;
uint32_t ih_wptr_addr_lo;
uint32_t ih_wptr_addr_hi;
Addr ih_wptrAddr;
uint32_t ih_doorbellOffset;
UNSERIALIZE_SCALAR(ih_cntl);
UNSERIALIZE_SCALAR(ih_base);
UNSERIALIZE_SCALAR(ih_base_hi);
UNSERIALIZE_SCALAR(ih_baseAddr);
UNSERIALIZE_SCALAR(ih_rptr);
UNSERIALIZE_SCALAR(ih_wptr);
UNSERIALIZE_SCALAR(ih_wptr_addr_lo);
UNSERIALIZE_SCALAR(ih_wptr_addr_hi);
UNSERIALIZE_SCALAR(ih_wptrAddr);
UNSERIALIZE_SCALAR(ih_doorbellOffset);
regs.IH_Cntl = ih_cntl;
regs.IH_Base = ih_base;
regs.IH_Base_Hi = ih_base_hi;
regs.baseAddr = ih_baseAddr;
regs.IH_Rptr = ih_rptr;
regs.IH_Wptr = ih_wptr;
regs.IH_Wptr_Addr_Lo = ih_wptr_addr_lo;
regs.IH_Wptr_Addr_Hi = ih_wptr_addr_hi;
regs.WptrAddr = ih_wptrAddr;
regs.IH_Doorbell = ih_doorbellOffset;
}
} // namespace gem5