sdk/include/platform/generic-riscv/platform-plic.hh

// Copyright Microsoft and CHERIoT Contributors.
// SPDX-License-Identifier: MIT

#pragma once
#include <cheri.hh>
#include <compartment-macros.h>
#include <optional>
#include <stdint.h>
#include <utils.hh>

/**
 * Driver for the standard RISC-V Platform-Local Interrupt Controller (PLIC).
 *
 * `MaxIntrID` is the largest interrupt number that is used.  `SourceID` and
 * `Priority` are the types used for interrupt source numbers and priorities,
 * respectively.
 */
template<size_t MaxIntrID, typename SourceID, typename Priority>
class StandardPlic : private utils::NoCopyNoMove
{
	public:
	/**
	 * Constructor.  Initialises the interrupt controller with all interrupts
	 * disabled.
	 */
	StandardPlic()
	{
		volatile uint32_t *range    = MMIO_CAPABILITY(uint32_t, plic);
		size_t             nSources = (MaxIntrID + 32U) & ~0x1f;
		// We program the enable bits in groups of 32.
		size_t nSourcesGroups = nSources >> 5;

		auto setField = [&](auto &field, size_t offset, size_t size) {
			CHERI::Capability capability{range};
			capability.address() += offset;
			capability.bounds() = size;
			field               = capability;
		};
		setField(plicPrios, PriorityOffset, nSources * sizeof(uint32_t));
		setField(plicPendings, PendingOffset, nSources / 8);
		setField(plicEnables, EnableOffset, nSources / 8);
		setField(plicThres, ThresholdOffset, sizeof(uint32_t));
		setField(plicClaim, ClaimOffset, sizeof(uint32_t));

		for (size_t i = 0; i < nSourcesGroups; i++)
		{
			plicEnables[i] = 0U;
		}
		for (size_t i = 1; i <= MaxIntrID; i++)
		{
			plicPrios[i] = 0U;
		}
		// We don't make use of threshold control. Leave it at 0 so all
		// configured interrupts can fire.
		*plicThres = 0U;
	}

	/**
	 * Enable the specified interrupt.
	 */
	void interrupt_enable(SourceID src)
	{
		size_t idx    = src >> 5;
		size_t bitPos = src & 0x1f;

		uint32_t enables = plicEnables[idx] | (1U << bitPos);
		plicEnables[idx] = enables;
	}

	/**
	 * Disable the specified interrupt.
	 */
	void interrupt_disable(SourceID src)
	{
		size_t idx    = src >> 5;
		size_t bitPos = src & 0x1f;

		uint32_t enables = plicEnables[idx] & ~(1U << bitPos);
		plicEnables[idx] = enables;
	}

	/**
	 * Set the priority of the specified interrupt.
	 */
	void priority_set(SourceID src, Priority prio)
	{
		plicPrios[src] = prio;
	}

	/**
	 * Fetch the interrupt number that fired and prevent it from firing.  If
	 * two or more interrupts have fired then this will return the
	 * highest-priority one.
	 *
	 * If no interrupt has fired (for example, because the interrupt line on
	 * the core was raised spuriously) then this returns `stdd:nullopt`.
	 */
	std::optional<SourceID> interrupt_claim()
	{
		uint32_t claim = *plicClaim;
		// PLIC reserves source ID 0, which means no interrupts.
		return claim == 0 ? std::nullopt : std::optional{claim};
	}

	/**
	 * Tell the interrupt controller we've handled a specified interrupt ID.
	 */
	void interrupt_complete(SourceID src)
	{
		*plicClaim = src;
	}

	private:
	// generic offsets according to spec
	static constexpr size_t PriorityOffset  = 0x0U;
	static constexpr size_t PendingOffset   = 0x1000U;
	static constexpr size_t EnableOffset    = 0x2000U;
	static constexpr size_t ThresholdOffset = 0x200000U;
	static constexpr size_t ClaimOffset     = 0x200004U;

	// Bounded capabilities to the individual structure fields.
	// Ideally these should be contained in one volatile struct, but
	// they are so far apart (and this lets us apply the bounds once).
	volatile uint32_t *plicPrios;
	volatile uint32_t *plicPendings;
	volatile uint32_t *plicEnables;
	volatile uint32_t *plicThres;
	volatile uint32_t *plicClaim;
};

/**
 * Type representing no interrupt controller.
 *
 * Contains stub implementations of all of the methods.
 */
template<size_t MaxIntrID, typename SourceID, typename Priority>
class NoPlic : private utils::NoCopyNoMove
{
	public:
	void interrupt_enable(SourceID) {}
	void interrupt_disable(SourceID) {}

	void priority_set(SourceID, Priority) {}

	std::optional<SourceID> interrupt_claim()
	{
		return std::nullopt;
	}
	void interrupt_complete(SourceID) {}
};

/**
 * The type for the Programmable Local Interrupt Controller (PLIC) to use.
 *
 * If there is no plic device then this provides a stub version.
 */
template<size_t MaxIntrID, typename SourceID, typename Priority>
using Plic =
#if DEVICE_EXISTS(plic)
  StandardPlic
#else
  NoPlic
#endif
  <MaxIntrID, SourceID, Priority>;