sdk/include/platform/arty-a7/platform-ethernet.hh

#pragma once
#include <array>
#include <cheri.hh>
#include <cstddef>
#include <cstdint>
#include <debug.hh>
#include <futex.h>
#include <interrupt.h>
#include <optional>
#include <platform/concepts/ethernet.hh>
#include <thread.h>
#include <type_traits>

DECLARE_AND_DEFINE_INTERRUPT_CAPABILITY(EthernetReceive,
                                        EthernetReceiveInterrupt,
                                        true,
                                        true);

/**
 * The driver for Kunyan Liu's custom Ethernet MAC for the Arty A7.  This is
 * intended to run at 10Mb/s.  It provides two send and two receive buffers in
 * shared SRAM.
 *
 * WARNING: This is currently evolving and is not yet stable.
 */
class KunyanEthernet
{
	/**
	 * Flag set when we're debugging this driver.
	 */
	static constexpr bool DebugEthernet = false;

	/**
	 * Flag set to log messages when frames are dropped.
	 */
	static constexpr bool DebugDroppedFrames = false;

	/**
	 * Helper for conditional debug logs and assertions.
	 */
	using Debug = ConditionalDebug<DebugEthernet, "Ethernet driver">;

	/**
	 * Import the Capability helper from the CHERI namespace.
	 */
	template<typename T>
	using Capability = CHERI::Capability<T>;

	/**
	 * The location of registers
	 */
	enum class RegisterOffset : size_t
	{
		/**
		 * MAC control register.  Higher bits control filtering modes:
		 *
		 * 12: Drop frames with invalid CRC.
		 * 11: Allow incoming IPv6 multicast filtering
		 * 10: Allow incoming IPv4 multicast filtering
		 * 9: Allow incoming broadcast filtering
		 * 8: Allow incoming unicast filtering
		 *
		 *
		 * Write a 1 to reset the PHY.  This takes 167 ms.
		 */
		MACControl = 0,
		/**
		 * High 4 bytes of the MAC address.  Byte 2 is in bits 31:24, byte 5 is
		 * in 7:0.
		 */
		MACAddressHigh = 4,
		/**
		 * Low 2 bytes of the MAC address.  Byte 1 in bits 15:8, byte 0 in 7:0.
		 */
		MACAddressLow = 8,
		/**
		 * Scratch register, unused.
		 */
		Scratch = 12,
		/**
		 * MDIO address, controls which PHY register will be read or written.
		 */
		MDIOAddress = 0x10,
		/**
		 * MDIO Write, written to set the value to write to a PHY register.
		 */
		MDIODataWrite = 0x14,
		/**
		 * MDIO Read, set by the device to the value of a PHY register in
		 * response to an MDIO read.
		 */
		MDIODataRead = 0x18,
		/**
		 * MDIO control.  Used to control and report status of MDIO
		 * transactions.
		 */
		MDIOControl = 0x1c,
		/**
		 * Length of the frame written to the ping buffer for sending.
		 */
		TransmitFrameLengthPing = 0x20,
		/**
		 * Transmit control for the ping buffer.
		 */
		TransmitControlPing = 0x24,
		/**
		 * Length of the frame written to the pong buffer for sending.
		 */
		TransmitFrameLengthPong = 0x28,
		/**
		 * Transmit control for the pong buffer.
		 */
		TransmitControlPong = 0x2c,
		/**
		 * Receive control for the ping buffer.
		 */
		ReceiveControlPing = 0x30,
		/**
		 * Receive control for the pong buffer.
		 */
		ReceiveControlPong = 0x34,
		/**
		 * Interrupt enable.  Write 1 to enable, 0 to disable interrupts for
		 * each direction.  Bit 0 is transmit, bit 1 is receive.
		 */
		GlobalInterruptEnable = 0x38,
		/**
		 * Current interrupt status.  Bit 0 is transmit, bit 1 is receive.
		 *
		 * Write a 1 to each bit to clear.  The device will keep the interrupt
		 * asserted until it is explicitly cleared.
		 */
		InterruptStatus = 0x3c,
		/**
		 * Length of the frames in the ping and pong buffer, in the low and
		 * high 16 bits respectively.
		 */
		ReceiveFrameLength = 0x40,
		/**
		 * Saturating counter of the number of frames received.
		 */
		ReceivedFramesCount = 0x44,
		/**
		 * Saturating counter of the number of frames passed to software.
		 */
		ReceivedFramesPassedToSoftware = 0x48,
		/**
		 * Saturating counter of the number of frames dropped because the
		 * receive buffers were both full.
		 */
		ReceiveDroppedFramesBuffersFull = 0x4c,
		/**
		 * Saturating counter of the number of frames dropped because they had
		 * failed FCS checks.
		 */
		ReceiveDroppedFramesFCSFailed = 0x50,
		/**
		 * Saturating counter of the number of frames dropped because the
		 * target address was invalid.
		 */
		ReceiveDroppedFramesInvalidAddress = 0x54,
	};

	using MACAddress = std::array<uint8_t, 6>;

	/**
	 * MAC filtering modes.
	 */
	enum class FilterMode : uint32_t
	{
		/**
		 * Allow incoming frames without doing any address filtering.
		 */
		EnableAddressFiltering = 1 << 13,
		/**
		 * Drop frames with invalid CRC.
		 */
		DropInvalidCRC = 1 << 12,
		/**
		 * Allow incoming IPv6 multicast filtering
		 */
		AllowIPv6Multicast = 1 << 11,
		/**
		 * Allow incoming IPv4 multicast filtering
		 */
		AllowIPv4Multicast = 1 << 10,
		/**
		 * Allow incoming broadcast filtering
		 */
		AllowBroadcast = 1 << 9,
		/**
		 * Allow incoming unicast filtering
		 */
		AllowUnicast = 1 << 8,
	};

	/**
	 * The futex used to wait for interrupts when packets are available to
	 * receive.
	 */
	const uint32_t *receiveInterruptFutex;

	/**
	 * Counter for dropped frames, intended to be extensible to support
	 * different debugging registers.
	 */
	struct DroppedFrameCount
	{
		/**
		 * The old value of the counter.
		 */
		uint32_t droppedFrameCount[3];
		/**
		 * Get a reference to one of the recorded counters.
		 */
		template<RegisterOffset Reg>
		uint32_t &get();
		template<>
		uint32_t &get<RegisterOffset::ReceiveDroppedFramesBuffersFull>()
		{
			return droppedFrameCount[0];
		}

		template<>
		uint32_t &get<RegisterOffset::ReceiveDroppedFramesFCSFailed>()
		{
			return droppedFrameCount[1];
		}

		template<>
		uint32_t &get<RegisterOffset::ReceiveDroppedFramesInvalidAddress>()
		{
			return droppedFrameCount[2];
		}
	};

	/**
	 * Empty class, for use with `std::conditional_t` to conditionally add a
	 * field.
	 */
	struct Empty
	{
	};

	/**
	 * If we're building with debugging support for dropped-frame counters,
	 * reserve space for them.
	 */
	[[no_unique_address]] std::
	  conditional_t<DebugDroppedFrames, DroppedFrameCount, Empty>
	    droppedFrames;

	/**
	 * Log a message if the dropped-frame counter identified by `Reg` has
	 * changed.
	 */
	template<RegisterOffset Reg, typename T = decltype(droppedFrames)>
	void dropped_frames_log_if_changed(T &droppedFrames)
	{
		if constexpr (std::is_same_v<T, DroppedFrameCount>)
		{
			auto &lastCount = droppedFrames.template get<Reg>();
			auto  count     = mmio_register<Reg>();
			if (count != lastCount)
			{
				ConditionalDebug<true, "Ethernet driver">::log(
				  "Dropped frames in counter {}: {}", Reg, count);
				lastCount = count;
			}
		}
	}

	/**
	 * Set the state of one of the MAC filtering modes.  Returns the previous
	 * value of the mode.
	 */
	bool filter_mode_update(FilterMode mode, bool enable)
	{
		auto    &macControl = mmio_register<RegisterOffset::MACControl>();
		uint32_t modeBit    = static_cast<uint32_t>(mode);
		uint32_t oldMode    = macControl;
		Debug::log("Old filter mode {}: {}", mode, oldMode);
		if (enable)
		{
			macControl = oldMode | modeBit;
		}
		else
		{
			macControl = oldMode & ~modeBit;
		}
		return oldMode | modeBit;
	}

	/**
	 * The PHY registers are accessed through the MDIO interface.
	 */
	enum class PHYRegister
	{
		BasicControlRegister              = 0,
		BasicStatusRegister               = 1,
		Identifier1                       = 2,
		Identifier2                       = 3,
		AutoNegotiationAdvertisement      = 4,
		AutoNegotiationLinkPartnerAbility = 5,
	};

	enum BufferID
	{
		Ping = 0,
		Pong = 1,
	};

	bool receiveBufferInUse[2] = {false, false};
	bool sendBufferInUse[2]    = {false, false};

	BufferID nextReceiveBuffer = BufferID::Ping;

	constexpr static BufferID next_buffer_id(BufferID current)
	{
		return current == BufferID::Ping ? BufferID::Pong : BufferID::Ping;
	}

	/**
	 * Reset the PHY.  This must be done on initialisation.
	 */
	void phy_reset()
	{
		auto &macControl = mmio_register<RegisterOffset::MACControl>();
		macControl       = 1;
		// Wait for the PHY to reset.
		thread_millisecond_wait(167);
		// Initialise MDIO again after the PHY has been reset.
		mmio_register<RegisterOffset::MDIOControl>() = 0x10;
		// Wait to make sure MDIO initialisation has completed.
		thread_microsecond_spin(1);
	}

	/**
	 * Helper.  Returns a pointer to the device.
	 */
	[[nodiscard]] __always_inline Capability<volatile uint32_t>
	                              mmio_region() const
	{
		return MMIO_CAPABILITY(uint32_t, kunyan_ethernet);
	}

	/**
	 * Helper.  Returns a reference to a register in this device's MMIO region.
	 * The register is identified by a `RegisterOffset` value.
	 */
	template<RegisterOffset Offset>
	[[nodiscard]] volatile uint32_t &mmio_register() const
	{
		auto reg = mmio_region();
		reg.address() += static_cast<size_t>(Offset);
		reg.bounds() = sizeof(uint32_t);
		return *reg;
	}

	/**
	 * Poll the MDIO control register until a transaction is done.
	 *
	 * NOTE: This does no error handling.  It can infinite loop if the device
	 * is broken.  Normally, MDIO operations complete in fewer cycles than it
	 * takes to call this method and so it will return almost instantly.
	 */
	void mdio_wait_for_ready()
	{
		auto &mdioControl = mmio_register<RegisterOffset::MDIOControl>();
		while (mdioControl & 1) {}
	}

	/**
	 * Start an MDIO transaction.  This assumes that the MDIO control register
	 * and, for write operations, the MDIO data write register have been set up.
	 * A call to `mdio_wait_for_ready` is required for read transactions to
	 * ensure that the operation has completed before reading the MIDO data read
	 * register.
	 */
	void mdio_start_transaction()
	{
		auto &mdioControl = mmio_register<RegisterOffset::MDIOControl>();
		Debug::Assert(((mdioControl & ((1 << 3) | 1)) == 0), "MDIO is busy");
		// Write the MDIO enable bit and the start bit.
		mdioControl = (1 << 3) | 1;
	}

	/**
	 * Returns a pointer to one of the receive buffers, identified by the buffer
	 * identifier (ping or pong).
	 */
	uint8_t *receive_buffer_pointer(BufferID index = BufferID::Ping)
	{
		auto buffer = mmio_region();
		buffer.address() +=
		  static_cast<size_t>(index == BufferID::Ping ? 0x2000 : 0x2800);
		buffer.bounds() = 0x800;
		return const_cast<uint8_t *>(
		  reinterpret_cast<volatile uint8_t *>((buffer.get())));
	}

	/**
	 * Returns a pointer to one of the receive buffers, identified by the buffer
	 * identifier (ping or pong).
	 */
	uint8_t *transmit_buffer_pointer(BufferID index = BufferID::Ping)
	{
		auto buffer = mmio_region();
		buffer.address() +=
		  static_cast<size_t>(index == BufferID::Ping ? 0x1000 : 0x1800);
		buffer.bounds() = 0x800;
		return const_cast<uint8_t *>(
		  reinterpret_cast<volatile uint8_t *>((buffer.get())));
	}

	/**
	 * Write a value to a PHY register via MDIO.
	 */
	void
	mdio_write(uint8_t phyAddress, PHYRegister registerAddress, uint16_t data)
	{
		mdio_wait_for_ready();
		auto    &mdioAddress = mmio_register<RegisterOffset::MDIOAddress>();
		auto    &mdioWrite   = mmio_register<RegisterOffset::MDIODataWrite>();
		uint32_t writeCommand =
		  (0 << 10) | (phyAddress << 5) | uint32_t(registerAddress);
		mdioAddress = writeCommand;
		mdioWrite   = data;
		mdio_start_transaction();
	}

	/**
	 * Read a value from a PHY register via MDIO.
	 */
	uint16_t mdio_read(uint8_t phyAddress, PHYRegister registerAddress)
	{
		mdio_wait_for_ready();
		auto    &mdioAddress = mmio_register<RegisterOffset::MDIOAddress>();
		uint32_t readCommand =
		  (1 << 10) | (phyAddress << 5) | uint8_t(registerAddress);
		mdioAddress = readCommand;
		mdio_start_transaction();
		mdio_wait_for_ready();
		return mmio_register<RegisterOffset::MDIODataRead>();
	}

	public:
	/**
	 * Initialise a reference to the Ethernet device.  This will check the ID
	 * registers to make sure that this is the kind of device that we're
	 * expecting.
	 */
	KunyanEthernet()
	{
		phy_reset();
		// Check that this is the device that we're looking for
		Debug::Assert(
		  [&]() { return mdio_read(1, PHYRegister::Identifier1) == 0x2000; },
		  "PHY identifier 1 is not 0x2000");
		Debug::Assert(
		  [&]() {
			  return (mdio_read(1, PHYRegister::Identifier2) & 0xFFF0) ==
			         0x5c90;
		  },
		  "PHY identifier 1 is not 0x5c9x");
		autonegotiation_enable();
		filter_mode_update(FilterMode::DropInvalidCRC, true);
		filter_mode_update(FilterMode::EnableAddressFiltering, false);
		filter_mode_update(FilterMode::AllowUnicast, false);
		filter_mode_update(FilterMode::AllowIPv4Multicast, false);
		filter_mode_update(FilterMode::AllowIPv6Multicast, false);
		receiveInterruptFutex =
		  interrupt_futex_get(STATIC_SEALED_VALUE(EthernetReceive));
		// Enable receive interrupts
		mmio_register<RegisterOffset::GlobalInterruptEnable>() = 0b10;
		// Clear pending receive interrupts.
		mmio_register<RegisterOffset::InterruptStatus>() = 0b10;
	}

	KunyanEthernet(const KunyanEthernet &) = delete;
	KunyanEthernet(KunyanEthernet &&)      = delete;

	/**
	 * This device does not have a unique MAC address and so users must provide
	 * a locally administered MAC address if more than one device is present on
	 * the same network.
	 */
	static constexpr bool has_unique_mac_address()
	{
		return false;
	}

	static constexpr MACAddress mac_address_default()
	{
		return {0x60, 0x6A, 0x6A, 0x37, 0x47, 0x88};
	}

	void mac_address_set(MACAddress address = mac_address_default())
	{
		auto &macAddressHigh = mmio_register<RegisterOffset::MACAddressHigh>();
		auto &macAddressLow  = mmio_register<RegisterOffset::MACAddressLow>();
		macAddressHigh       = (address[2] << 24) | (address[3] << 16) |
		                 (address[4] << 8) | address[5];
		macAddressLow = (address[1] << 8) | address[0];
	}

	uint32_t receive_interrupt_value()
	{
		return *receiveInterruptFutex;
	}

	int receive_interrupt_complete(Timeout *timeout,
	                               uint32_t lastInterruptValue)
	{
		// Clear the interrupt on the device.
		auto &interruptStatus =
		  mmio_register<RegisterOffset::InterruptStatus>();
		interruptStatus = 0b10;
		// There's a small window in between finishing checking the receive
		// buffers and clearing the interrupt where we could miss the
		// interrupt.  Check that the receive buffers are empty *after*
		// reenabling the interrupt to ensure that we don't sleep in this
		// period.
		if (check_frame(BufferID::Ping) || check_frame(BufferID::Pong))
		{
			Debug::log("Packets already ready, not waiting for interrupt");
			return 0;
		}
		// Acknowledge the interrupt in the scheduler.
		interrupt_complete(STATIC_SEALED_VALUE(EthernetReceive));
		if (*receiveInterruptFutex == lastInterruptValue)
		{
			Debug::log("Acknowledged interrupt, sleeping on futex {}",
			           receiveInterruptFutex);
			return futex_timed_wait(
			  timeout, receiveInterruptFutex, lastInterruptValue);
		}
		Debug::log("Scheduler announces interrupt has fired");
		return 0;
	}

	/**
	 * Enable autonegotiation on the PHY.
	 *
	 * FIXME: This blocks forever if the cable is disconnected!
	 */
	void autonegotiation_enable(uint8_t phyAddress = 1)
	{
		Debug::log("Starting autonegotiation");
		// Advertise 802.3, 10Base-T full and half duplex
		mdio_write(phyAddress,
		           PHYRegister::AutoNegotiationAdvertisement,
		           (1 << 5) | (1 << 6) | 1);
		// Enable and restart autonegitiation
		mdio_write(
		  phyAddress, PHYRegister::BasicControlRegister, (1 << 12) | (1 << 9));
		Debug::log("Waiting for autonegotiation to complete");
		uint32_t loops = 0;
		while ((mdio_read(phyAddress, PHYRegister::BasicStatusRegister) &
		        (1 << 5)) == 0)
		{
			if ((loops++ & 0xfffff) == 0)
			{
				Debug::log(
				  "Waiting for autonegotiation to complete ({} loops): status: "
				  "{}",
				  loops,
				  mdio_read(phyAddress, PHYRegister::BasicStatusRegister));
			}
			yield();
		}
		Debug::Assert(
		  [&]() {
			  return (mdio_read(phyAddress, PHYRegister::BasicStatusRegister) &
			          (1 << 2)) != 0;
		  },
		  "Autonegotiation completed but link is down");
		Debug::log("Autonegotiation complete, status: {}",
		           mdio_read(phyAddress, PHYRegister::BasicStatusRegister));
		// Write 1 to clear the receive status.
		mmio_register<RegisterOffset::ReceiveControlPing>() = 1;
		mmio_register<RegisterOffset::ReceiveControlPong>() = 1;
	}

	/**
	 * Check the link status of the PHY.
	 */
	bool phy_link_status()
	{
		return (mdio_read(1, PHYRegister::BasicStatusRegister) & (1 << 2)) != 0;
	}

	std::optional<uint16_t> check_frame(BufferID index = BufferID::Ping)
	{
		// Debug::log("Checking for frame in buffer {}", index);
		auto receiveControl =
		  index == BufferID::Ping
		    ? mmio_register<RegisterOffset::ReceiveControlPing>()
		    : mmio_register<RegisterOffset::ReceiveControlPong>();
		if ((receiveControl & 1) == 0)
		{
			return std::nullopt;
		}
		Debug::log("Buffer has a frame.  Error? {}", receiveControl & 2);
		Debug::log("Buffer length: {}", receiveControl >> 16);
		return {receiveControl >> 16};
	}

	void complete_receive(BufferID index = BufferID::Ping)
	{
		Debug::log("Completing receive in buffer {}", index);
		// This buffer is now free to receive another frame.
		receiveBufferInUse[index] = false;
		if (index == BufferID::Ping)
		{
			mmio_register<RegisterOffset::ReceiveControlPing>() = 1;
		}
		else
		{
			mmio_register<RegisterOffset::ReceiveControlPong>() = 1;
		}
	}

	/**
	 * Class encapsulating a frame that has been received.  This holds a
	 * reference to the internal state of the buffer and will mark the buffer
	 * as free when it is destroyed.
	 */
	class BufferedFrame
	{
		friend class KunyanEthernet;
		KunyanEthernet &ethernetAdaptor;
		BufferID        owningBuffer;

		private:
		BufferedFrame(KunyanEthernet     &ethernetAdaptor,
		              BufferID            owningBuffer,
		              Capability<uint8_t> buffer,
		              uint16_t            length)

		  : ethernetAdaptor(ethernetAdaptor),
		    owningBuffer(owningBuffer),
		    buffer(buffer),
		    length(length)
		{
			// Mark this buffer as in use and try to advance the next buffer
			ethernetAdaptor.receiveBufferInUse[owningBuffer] = true;
			if (!ethernetAdaptor.receiveBufferInUse[next_buffer_id(
			      ethernetAdaptor.nextReceiveBuffer)])
			{
				ethernetAdaptor.nextReceiveBuffer =
				  next_buffer_id(ethernetAdaptor.nextReceiveBuffer);
			}
		}

		public:
		uint16_t            length;
		Capability<uint8_t> buffer;
		BufferedFrame(const BufferedFrame &) = delete;
		BufferedFrame(BufferedFrame &&other)
		  : ethernetAdaptor(other.ethernetAdaptor),
		    owningBuffer(other.owningBuffer),
		    buffer(other.buffer),
		    length(other.length)
		{
			other.buffer = nullptr;
			other.length = 0;
		}
		~BufferedFrame()
		{
			if (buffer != nullptr)
			{
				ethernetAdaptor.complete_receive(owningBuffer);
			}
		}
	};

	std::optional<BufferedFrame> receive_frame()
	{
		// To avoid processing the same packet twice, we must not use
		// the current receive buffer if it is already in use. In that
		// case, check the next receive buffer. If it is not in use,
		// rotate the buffers.  Otherwise, abandon.
		if (receiveBufferInUse[nextReceiveBuffer])
		{
			if (!receiveBufferInUse[next_buffer_id(nextReceiveBuffer)])
			{
				// The next receive buffer is not in use. Rotate.
				nextReceiveBuffer = next_buffer_id(nextReceiveBuffer);
			}
			else
			{
				// The next receive buffer is in use too. Abandon.
				return std::nullopt;
			}
		}

		auto maybeLength = check_frame(nextReceiveBuffer);

		if (!maybeLength)
		{
			// The current receive buffer is empty. However, the next
			// receive buffer, if not in use, may have a packet ready for
			// us. Check that one as well.

			if (!receiveBufferInUse[next_buffer_id(nextReceiveBuffer)])
			{
				// The next receive buffer is not in use. Check
				// for packets there as well.
				nextReceiveBuffer = next_buffer_id(nextReceiveBuffer);
				maybeLength       = check_frame(nextReceiveBuffer);
			}

			if (!maybeLength)
			{
				// None of the buffers has packets that we can
				// process. Abandon.
				return std::nullopt;
			}
		}

		auto length = *maybeLength;
		// Strip the FCS from the length.
		length -= 4;
		auto                buffer = receive_buffer_pointer(nextReceiveBuffer);
		Capability<uint8_t> boundedBuffer{buffer};
		boundedBuffer.bounds() = length;
		// Remove all permissions except load.  This also removes global, so
		// that this cannot be captured.
		boundedBuffer.permissions() &=
		  CHERI::PermissionSet{CHERI::Permission::Load};
		Debug::log("Received frame from buffer {}", nextReceiveBuffer);
		return {{*this, nextReceiveBuffer, buffer, length}};
	}

	/**
	 * Send a packet.  This is synchronous and will block until the packet has
	 * been sent.  A better version would use the next available ping or pong
	 * buffer and return as soon as the send operation had been enqueued.
	 *
	 * The third argument is a callback that allows the caller to check the
	 * frame before it's sent but after it's copied into memory that isn't
	 * shared with other compartments.
	 */
	bool send_frame(const uint8_t *buffer, uint16_t length, auto &&check)
	{
		auto &transmitControl =
		  mmio_register<RegisterOffset::TransmitControlPing>();
		// Spin waiting for the transmit buffer to be free.
		while (transmitControl & 1) {}
		// Write the frame to the transmit buffer.
		auto transmitBuffer = transmit_buffer_pointer();
		// We must check the frame pointer and its length. Although it
		// is supplied by the firewall which is trusted, the firewall
		// does not check the pointer which is coming from external
		// untrusted components.
		Timeout t{10};
		if ((heap_claim_fast(&t, buffer) < 0) ||
		    (!CHERI::check_pointer<CHERI::PermissionSet{
		       CHERI::Permission::Load}>(buffer, length)))
		{
			return false;
		}
		memcpy(transmitBuffer, buffer, length);
		if (!check(transmitBuffer, length))
		{
			return false;
		}
		// The Ethernet standard requires frames to be at least 60 bytes long.
		// If we're asked to send anything shorter, pad it with zeroes.
		// (It would be nice if the MAC did this automatically).
		if (length < 60)
		{
			memset(transmitBuffer + length, 0, 60 - length);
			length = 60;
		}
		// Write the length of the frame to the transmit length register.
		mmio_register<RegisterOffset::TransmitFrameLengthPing>() = length;
		// Start the transmit.
		transmitControl = 1;
		Debug::log("Sent frame, waiting for completion");
		while (transmitControl & 1) {}
		// Return if the frame was sent successfully.
		Debug::log("Transmit control register: {}", transmitControl);
		if ((transmitControl & 2) != 0)
		{
			Debug::log("Error sending frame");
		}
		return (transmitControl & 2) == 0;
	}

	/**
	 * If debugging dropped frames is enabled, log any counter values that have
	 * changed since the last call to this function.
	 */
	void dropped_frames_log_all_if_changed()
	{
		if constexpr (DebugDroppedFrames)
		{
			dropped_frames_log_if_changed<
			  RegisterOffset::ReceiveDroppedFramesBuffersFull>(droppedFrames);
			dropped_frames_log_if_changed<
			  RegisterOffset::ReceiveDroppedFramesFCSFailed>(droppedFrames);
			dropped_frames_log_if_changed<
			  RegisterOffset::ReceiveDroppedFramesInvalidAddress>(
			  droppedFrames);
		}
	}

	void received_frames_log()
	{
		auto count = mmio_register<RegisterOffset::ReceivedFramesCount>();
		ConditionalDebug<true, "Ethernet driver">::log("Received frames: {}",
		                                               count);
	}
};

using EthernetDevice = KunyanEthernet;

static_assert(EthernetAdaptor<EthernetDevice>);