mirror of
https://github.com/Atmosphere-NX/Atmosphere.git
synced 2025-06-22 19:22:40 +02:00
109 lines
4.2 KiB
C++
109 lines
4.2 KiB
C++
/*
|
|
* Copyright (c) 2019-2020 Atmosphère-NX
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms and conditions of the GNU General Public License,
|
|
* version 2, as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
* more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "hvisor_gicv2.hpp"
|
|
#include "hvisor_synchronization.hpp"
|
|
#include "memory_map.h"
|
|
|
|
#include "exceptions.h" // TODO
|
|
|
|
namespace ams::hvisor {
|
|
|
|
class IrqManager final {
|
|
NON_COPYABLE(IrqManager);
|
|
NON_MOVEABLE(IrqManager);
|
|
friend class VirtualGic;
|
|
private:
|
|
static IrqManager instance;
|
|
static constexpr u8 hostPriority = 0;
|
|
static constexpr u8 guestPriority = 1;
|
|
|
|
static inline volatile auto *const gicd = (volatile GicV2Distributor *)MEMORY_MAP_VA_GICD;
|
|
static inline volatile auto *const gicc = (volatile GicV2Controller *)MEMORY_MAP_VA_GICC;
|
|
static inline volatile auto *const gich = (volatile GicV2VirtualInterfaceController *)MEMORY_MAP_VA_GICH;
|
|
|
|
static bool IsGuestInterrupt(u32 id);
|
|
|
|
static void SetInterruptEnabled(u32 id) { gicd->isenabler[id / 32] = BIT(id % 32); }
|
|
static void ClearInterruptEnabled(u32 id) { gicd->icenabler[id / 32] = BIT(id % 32); }
|
|
static void ClearInterruptPending(u32 id) { gicd->icpendr[id / 32] = BIT(id % 32); }
|
|
static void SetInterruptShiftedPriority(u32 id, u8 prio) { gicd->ipriorityr[id] = prio; }
|
|
static void DoSetInterruptAffinity(u32 id, u8 targetList) { gicd->itargetsr[id] = targetList; }
|
|
static bool IsInterruptLevelSensitive(u32 id)
|
|
{
|
|
return ((gicd->icfgr[id / 16] >> GicV2Distributor::GetCfgrShift(id)) & 2) != 0;
|
|
}
|
|
static void SetInterruptMode(u32 id, bool isLevelSensitive)
|
|
{
|
|
u32 cfgw = gicd->icfgr[id / 16];
|
|
cfgw &= ~(2 << GicV2Distributor::GetCfgrShift(id));
|
|
cfgw |= (isLevelSensitive ? 2 : 0) << GicV2Distributor::GetCfgrShift(id);
|
|
gicd->icfgr[id / 16] = cfgw;
|
|
}
|
|
|
|
static u32 AcknowledgeIrq() { return gicc->iar; }
|
|
static void DropCurrentInterruptPriority(u32 iar) { gicc->eoir = iar; }
|
|
static void DeactivateCurrentInterrupt(u32 iar) { gicc->dir = iar; }
|
|
|
|
private:
|
|
mutable RecursiveSpinlock m_lock{};
|
|
u32 m_numSharedInterrupts = 0;
|
|
u8 m_priorityShift = 0;
|
|
u8 m_numPriorityLevels = 0;
|
|
u8 m_numCpuInterfaces = 0;
|
|
u8 m_numListRegisters = 0;
|
|
|
|
private:
|
|
void InitializeGic();
|
|
void DoConfigureInterrupt(u32 id, u8 prio, bool isLevelSensitive);
|
|
|
|
public:
|
|
enum ThermosphereSgi : u32 {
|
|
ExecuteFunctionSgi = 0,
|
|
VgicUpdateSgi,
|
|
DebugPauseSgi,
|
|
ReportDebuggerBreakSgi,
|
|
DebuggerContinueSgi,
|
|
|
|
MaxSgi,
|
|
};
|
|
|
|
static void GenerateSgiForList(ThermosphereSgi id, u32 coreList)
|
|
{
|
|
gicd->sgir = GicV2Distributor::ForwardToTargetList << 24 | coreList << 16 | id;
|
|
}
|
|
static void GenerateSgiForAllOthers(ThermosphereSgi id)
|
|
{
|
|
gicd->sgir = GicV2Distributor::ForwardToAllOthers << 24 | id;
|
|
}
|
|
|
|
static IrqManager &GetInstance() { return instance; }
|
|
|
|
static void HandleInterrupt(ExceptionStackFrame *frame);
|
|
|
|
public:
|
|
void Initialize();
|
|
void ConfigureInterrupt(u32 id, u8 prio, bool isLevelSensitive);
|
|
void SetInterruptAffinity(u32 id, u8 affinityMask);
|
|
|
|
public:
|
|
constexpr IrqManager() = default;
|
|
};
|
|
|
|
}
|