Kernel: Introduce the IOWindow class

This class is intended to replace all IOAddress usages in the Kernel
codebase altogether. The idea is to ensure IO can be done in
arch-specific manner that is determined mostly in compile-time, but to
still be able to use most of the Kernel code in non-x86 builds. Specific
devices that rely on x86-specific IO instructions are already placed in
the Arch/x86 directory and are omitted for non-x86 builds.

The reason this works so well is the fact that x86 IO space acts in a
similar fashion to the traditional memory space being available in most
CPU architectures - the x86 IO space is essentially just an array of
bytes like the physical memory address space, but requires x86 IO
instructions to load and store data. Therefore, many devices allow host
software to interact with the hardware registers in both ways, with a
noticeable trend even in the modern x86 hardware to move away from the
old x86 IO space to exclusively using memory-mapped IO.

Therefore, the IOWindow class encapsulates both methods for x86 builds.
The idea is to allow PCI devices to be used in either way in x86 builds,
so when trying to map an IOWindow on a PCI BAR, the Kernel will try to
find the proper method being declared with the PCI BAR flags.
For old PCI hardware on non-x86 builds this might turn into a problem as
we can't use port mapped IO, so the Kernel will gracefully fail with
ENOTSUP error code if that's the case, as there's really nothing we can
do within such case.

For general IO, the read{8,16,32} and write{8,16,32} methods are
available as a convenient API for other places in the Kernel. There are
simply no direct 64-bit IO API methods yet, as it's not needed right now
and is not considered to be Arch-agnostic too - the x86 IO space doesn't
support generating 64 bit cycle on IO bus and instead requires two 2
32-bit accesses. If for whatever reason it appears to be necessary to do
IO in such manner, it could probably be added with some neat tricks to
do so. It is recommended to use Memory::TypedMapping struct if direct 64
bit IO is actually needed.

2 files changed, 71 insertions, 63 deletions

diff --git a/Kernel/Devices/Audio/AC97.cpp b/Kernel/Devices/Audio/AC97.cpp
index 7b7346979a..5ba2a33bba 100644
--- a/Kernel/Devices/Audio/AC97.cpp
+++ b/Kernel/Devices/Audio/AC97.cpp
@@ -23,18 +23,24 @@ static constexpr u16 pcm_sample_rate_maximum = 48000;
 
 UNMAP_AFTER_INIT ErrorOr<NonnullLockRefPtr<AC97>> AC97::try_create(PCI::DeviceIdentifier const& pci_device_identifier)
 {
-    auto ac97 = adopt_nonnull_lock_ref_or_enomem(new (nothrow) AC97(pci_device_identifier));
+    auto mixer_io_window = TRY(IOWindow::create_for_pci_device_bar(pci_device_identifier, PCI::HeaderType0BaseRegister::BAR0));
+    auto bus_io_window = TRY(IOWindow::create_for_pci_device_bar(pci_device_identifier, PCI::HeaderType0BaseRegister::BAR1));
+
+    auto pcm_out_channel_io_window = TRY(bus_io_window->create_from_io_window_with_offset(NativeAudioBusChannel::PCMOutChannel));
+    auto pcm_out_channel = TRY(AC97Channel::create_with_parent_pci_device(pci_device_identifier.address(), "PCMOut"sv, move(pcm_out_channel_io_window)));
+
+    auto ac97 = adopt_nonnull_lock_ref_or_enomem(new (nothrow) AC97(pci_device_identifier, move(pcm_out_channel), move(mixer_io_window), move(bus_io_window)));
     if (!ac97.is_error())
         TRY(ac97.value()->initialize());
     return ac97;
 }
 
-UNMAP_AFTER_INIT AC97::AC97(PCI::DeviceIdentifier const& pci_device_identifier)
+UNMAP_AFTER_INIT AC97::AC97(PCI::DeviceIdentifier const& pci_device_identifier, NonnullOwnPtr<AC97Channel> pcm_out_channel, NonnullOwnPtr<IOWindow> mixer_io_window, NonnullOwnPtr<IOWindow> bus_io_window)
     : PCI::Device(pci_device_identifier.address())
     , IRQHandler(pci_device_identifier.interrupt_line().value())
-    , m_io_mixer_base(PCI::get_BAR0(pci_address()) & ~1)
-    , m_io_bus_base(PCI::get_BAR1(pci_address()) & ~1)
-    , m_pcm_out_channel(channel("PCMOut"sv, NativeAudioBusChannel::PCMOutChannel))
+    , m_mixer_io_window(move(mixer_io_window))
+    , m_bus_io_window(move(bus_io_window))
+    , m_pcm_out_channel(move(pcm_out_channel))
 {
 }
 
@@ -42,8 +48,7 @@ UNMAP_AFTER_INIT AC97::~AC97() = default;
 
 bool AC97::handle_irq(RegisterState const&)
 {
-    auto pcm_out_status_register = m_pcm_out_channel.reg(AC97Channel::Register::Status);
-    auto pcm_out_status = pcm_out_status_register.in<u16>();
+    auto pcm_out_status = m_pcm_out_channel->io_window().read16(AC97Channel::Register::Status);
     dbgln_if(AC97_DEBUG, "AC97 @ {}: interrupt received - status: {:#05b}", pci_address(), pcm_out_status);
 
     bool is_dma_halted = (pcm_out_status & AudioStatusRegisterFlag::DMAControllerHalted) > 0;
@@ -60,11 +65,11 @@ bool AC97::handle_irq(RegisterState const&)
     pcm_out_status = AudioStatusRegisterFlag::LastValidBufferCompletionInterrupt
         | AudioStatusRegisterFlag::BufferCompletionInterruptStatus
         | AudioStatusRegisterFlag::FIFOError;
-    pcm_out_status_register.out(pcm_out_status);
+    m_pcm_out_channel->io_window().write16(AC97Channel::Register::Status, pcm_out_status);
 
     if (is_dma_halted) {
         VERIFY(current_equals_last_valid);
-        m_pcm_out_channel.handle_dma_stopped();
+        m_pcm_out_channel->handle_dma_stopped();
     }
 
     if (!m_irq_queue.is_empty())
@@ -75,34 +80,33 @@ bool AC97::handle_irq(RegisterState const&)
 
 UNMAP_AFTER_INIT ErrorOr<void> AC97::initialize()
 {
-    dbgln_if(AC97_DEBUG, "AC97 @ {}: mixer base: {:#04x}", pci_address(), m_io_mixer_base.get());
-    dbgln_if(AC97_DEBUG, "AC97 @ {}: bus base: {:#04x}", pci_address(), m_io_bus_base.get());
+    dbgln_if(AC97_DEBUG, "AC97 @ {}: mixer base: {:#04x}", pci_address(), m_mixer_io_window);
+    dbgln_if(AC97_DEBUG, "AC97 @ {}: bus base: {:#04x}", pci_address(), m_bus_io_window);
 
     // Read out AC'97 codec revision and vendor
-    auto extended_audio_id = m_io_mixer_base.offset(NativeAudioMixerRegister::ExtendedAudioID).in<u16>();
+    auto extended_audio_id = m_mixer_io_window->read16(NativeAudioMixerRegister::ExtendedAudioID);
     m_codec_revision = static_cast<AC97Revision>(((extended_audio_id & ExtendedAudioMask::Revision) >> 10) & 0b11);
     dbgln_if(AC97_DEBUG, "AC97 @ {}: codec revision {:#02b}", pci_address(), to_underlying(m_codec_revision));
     if (m_codec_revision == AC97Revision::Reserved)
         return ENOTSUP;
 
     // Report vendor / device ID
-    u32 vendor_id = m_io_mixer_base.offset(NativeAudioMixerRegister::VendorID1).in<u16>() << 16 | m_io_mixer_base.offset(NativeAudioMixerRegister::VendorID2).in<u16>();
+    u32 vendor_id = m_mixer_io_window->read16(NativeAudioMixerRegister::VendorID1) << 16 | m_mixer_io_window->read16(NativeAudioMixerRegister::VendorID2);
     dbgln("AC97 @ {}: Vendor ID: {:#8x}", pci_address(), vendor_id);
 
     // Bus cold reset, enable interrupts
     enable_pin_based_interrupts();
     PCI::enable_bus_mastering(pci_address());
-    auto control = m_io_bus_base.offset(NativeAudioBusRegister::GlobalControl).in<u32>();
+    auto control = m_bus_io_window->read32(NativeAudioBusRegister::GlobalControl);
     control |= GlobalControlFlag::GPIInterruptEnable;
     control |= GlobalControlFlag::AC97ColdReset;
-    m_io_bus_base.offset(NativeAudioBusRegister::GlobalControl).out(control);
+    m_bus_io_window->write32(NativeAudioBusRegister::GlobalControl, control);
 
     // Reset mixer
-    m_io_mixer_base.offset(NativeAudioMixerRegister::Reset).out<u16>(1);
+    m_mixer_io_window->write16(NativeAudioMixerRegister::Reset, 1);
 
     // Enable variable and double rate PCM audio if supported
-    auto extended_audio_status_control_register = m_io_mixer_base.offset(NativeAudioMixerRegister::ExtendedAudioStatusControl);
-    auto extended_audio_status = extended_audio_status_control_register.in<u16>();
+    auto extended_audio_status = m_mixer_io_window->read16(NativeAudioMixerRegister::ExtendedAudioStatusControl);
     if ((extended_audio_id & ExtendedAudioMask::VariableRatePCMAudio) > 0) {
         extended_audio_status |= ExtendedAudioStatusControlFlag::VariableRateAudio;
         m_variable_rate_pcm_supported = true;
@@ -113,7 +117,7 @@ UNMAP_AFTER_INIT ErrorOr<void> AC97::initialize()
         extended_audio_status |= ExtendedAudioStatusControlFlag::DoubleRateAudio;
         m_double_rate_pcm_enabled = true;
     }
-    extended_audio_status_control_register.out(extended_audio_status);
+    m_mixer_io_window->write16(NativeAudioMixerRegister::ExtendedAudioStatusControl, extended_audio_status);
 
     TRY(set_pcm_output_sample_rate(m_variable_rate_pcm_supported ? pcm_default_sample_rate : pcm_fixed_sample_rate));
 
@@ -121,7 +125,7 @@ UNMAP_AFTER_INIT ErrorOr<void> AC97::initialize()
     set_master_output_volume(0, 0, Muted::No);
     set_pcm_output_volume(0, 0, Muted::No);
 
-    m_pcm_out_channel.reset();
+    m_pcm_out_channel->reset();
     enable_irq();
     return {};
 }
@@ -131,7 +135,7 @@ void AC97::set_master_output_volume(u8 left_channel, u8 right_channel, Muted mut
     u16 volume_value = ((right_channel & 63) << 0)
         | ((left_channel & 63) << 8)
         | ((mute == Muted::Yes ? 1 : 0) << 15);
-    m_io_mixer_base.offset(NativeAudioMixerRegister::SetMasterOutputVolume).out(volume_value);
+    m_mixer_io_window->write16(NativeAudioMixerRegister::SetMasterOutputVolume, volume_value);
 }
 
 ErrorOr<void> AC97::set_pcm_output_sample_rate(u32 sample_rate)
@@ -146,15 +150,14 @@ ErrorOr<void> AC97::set_pcm_output_sample_rate(u32 sample_rate)
     if (shifted_sample_rate < pcm_sample_rate_minimum || shifted_sample_rate > pcm_sample_rate_maximum)
         return ENOTSUP;
 
-    auto pcm_front_dac_rate_register = m_io_mixer_base.offset(NativeAudioMixerRegister::PCMFrontDACRate);
-    pcm_front_dac_rate_register.out<u16>(shifted_sample_rate);
-    m_sample_rate = static_cast<u32>(pcm_front_dac_rate_register.in<u16>()) << double_rate_shift;
+    m_mixer_io_window->write16(NativeAudioMixerRegister::PCMFrontDACRate, shifted_sample_rate);
+    m_sample_rate = static_cast<u32>(m_mixer_io_window->read16(NativeAudioMixerRegister::PCMFrontDACRate)) << double_rate_shift;
 
     dbgln("AC97 @ {}: PCM front DAC rate set to {} Hz", pci_address(), m_sample_rate);
 
     // Setting the sample rate stops a running DMA engine, so restart it
-    if (m_pcm_out_channel.dma_running())
-        m_pcm_out_channel.start_dma();
+    if (m_pcm_out_channel->dma_running())
+        m_pcm_out_channel->start_dma();
 
     return {};
 }
@@ -164,7 +167,7 @@ void AC97::set_pcm_output_volume(u8 left_channel, u8 right_channel, Muted mute)
     u16 volume_value = ((right_channel & 31) << 0)
         | ((left_channel & 31) << 8)
         | ((mute == Muted::Yes ? 1 : 0) << 15);
-    m_io_mixer_base.offset(NativeAudioMixerRegister::SetPCMOutputVolume).out(volume_value);
+    m_mixer_io_window->write16(NativeAudioMixerRegister::SetPCMOutputVolume, volume_value);
 }
 
 LockRefPtr<AudioChannel> AC97::audio_channel(u32 index) const
@@ -226,14 +229,14 @@ ErrorOr<void> AC97::write_single_buffer(UserOrKernelBuffer const& data, size_t o
     // Block until we can write into an unused buffer
     cli();
     do {
-        auto pcm_out_status = m_pcm_out_channel.reg(AC97Channel::Register::Status).in<u16>();
-        auto current_index = m_pcm_out_channel.reg(AC97Channel::Register::CurrentIndexValue).in<u8>();
-        int last_valid_index = m_pcm_out_channel.reg(AC97Channel::Register::LastValidIndex).in<u8>();
+        auto pcm_out_status = m_pcm_out_channel->io_window().read16(AC97Channel::Register::Status);
+        auto current_index = m_pcm_out_channel->io_window().read8(AC97Channel::Register::CurrentIndexValue);
+        int last_valid_index = m_pcm_out_channel->io_window().read8(AC97Channel::Register::LastValidIndex);
 
         auto head_distance = last_valid_index - current_index;
         if (head_distance < 0)
             head_distance += buffer_descriptor_list_max_entries;
-        if (m_pcm_out_channel.dma_running())
+        if (m_pcm_out_channel->dma_running())
             ++head_distance;
 
         // Current index has _passed_ last valid index - move our list index up
@@ -248,7 +251,7 @@ ErrorOr<void> AC97::write_single_buffer(UserOrKernelBuffer const& data, size_t o
 
         dbgln_if(AC97_DEBUG, "AC97 @ {}: waiting on interrupt - status: {:#05b} CI: {} LVI: {}", pci_address(), pcm_out_status, current_index, last_valid_index);
         m_irq_queue.wait_forever("AC97"sv);
-    } while (m_pcm_out_channel.dma_running());
+    } while (m_pcm_out_channel->dma_running());
     sti();
 
     // Copy data from userspace into one of our buffers
@@ -262,10 +265,10 @@ ErrorOr<void> AC97::write_single_buffer(UserOrKernelBuffer const& data, size_t o
     list_entry->control_and_length = number_of_samples | BufferDescriptorListEntryFlags::InterruptOnCompletion;
 
     auto buffer_address = static_cast<u32>(m_buffer_descriptor_list->physical_page(0)->paddr().get());
-    m_pcm_out_channel.set_last_valid_index(buffer_address, m_buffer_descriptor_list_index);
+    m_pcm_out_channel->set_last_valid_index(buffer_address, m_buffer_descriptor_list_index);
 
-    if (!m_pcm_out_channel.dma_running())
-        m_pcm_out_channel.start_dma();
+    if (!m_pcm_out_channel->dma_running())
+        m_pcm_out_channel->start_dma();
 
     m_output_buffer_page_index = (m_output_buffer_page_index + 1) % m_output_buffer_page_count;
     m_buffer_descriptor_list_index = (m_buffer_descriptor_list_index + 1) % buffer_descriptor_list_max_entries;
@@ -273,25 +276,29 @@ ErrorOr<void> AC97::write_single_buffer(UserOrKernelBuffer const& data, size_t o
     return {};
 }
 
+ErrorOr<NonnullOwnPtr<AC97::AC97Channel>> AC97::AC97Channel::create_with_parent_pci_device(PCI::Address pci_device_address, StringView name, NonnullOwnPtr<IOWindow> channel_io_base)
+{
+    return adopt_nonnull_own_or_enomem(new (nothrow) AC97::AC97Channel(pci_device_address, name, move(channel_io_base)));
+}
+
 void AC97::AC97Channel::handle_dma_stopped()
 {
-    dbgln_if(AC97_DEBUG, "AC97 @ {}: channel {}: DMA engine has stopped", m_device.pci_address(), name());
+    dbgln_if(AC97_DEBUG, "AC97 @ {}: channel {}: DMA engine has stopped", m_device_pci_address, name());
     m_dma_running.with([this](auto& dma_running) {
         // NOTE: QEMU might send spurious interrupts while we're not running, so we don't want to panic here.
         if (!dma_running)
-            dbgln("AC97 @ {}: received DMA interrupt while it wasn't running", m_device.pci_address());
+            dbgln("AC97 @ {}: received DMA interrupt while it wasn't running", m_device_pci_address);
         dma_running = false;
     });
 }
 
 void AC97::AC97Channel::reset()
 {
-    dbgln_if(AC97_DEBUG, "AC97 @ {}: channel {}: resetting", m_device.pci_address(), name());
+    dbgln_if(AC97_DEBUG, "AC97 @ {}: channel {}: resetting", m_device_pci_address, name());
 
-    auto control_register = reg(Register::Control);
-    control_register.out(AudioControlRegisterFlag::ResetRegisters);
+    m_channel_io_window->write8(Register::Control, AudioControlRegisterFlag::ResetRegisters);
 
-    while ((control_register.in<u8>() & AudioControlRegisterFlag::ResetRegisters) > 0)
+    while ((m_channel_io_window->read8(Register::Control) & AudioControlRegisterFlag::ResetRegisters) > 0)
         microseconds_delay(50);
 
     m_dma_running.with([](auto& dma_running) {
@@ -301,22 +308,21 @@ void AC97::AC97Channel::reset()
 
 void AC97::AC97Channel::set_last_valid_index(u32 buffer_address, u8 last_valid_index)
 {
-    dbgln_if(AC97_DEBUG, "AC97 @ {}: channel {}: setting buffer address: {:#x} LVI: {}", m_device.pci_address(), name(), buffer_address, last_valid_index);
+    dbgln_if(AC97_DEBUG, "AC97 @ {}: channel {}: setting buffer address: {:#x} LVI: {}", m_device_pci_address, name(), buffer_address, last_valid_index);
 
-    reg(Register::BufferDescriptorListBaseAddress).out(buffer_address);
-    reg(Register::LastValidIndex).out(last_valid_index);
+    m_channel_io_window->write32(Register::BufferDescriptorListBaseAddress, buffer_address);
+    m_channel_io_window->write8(Register::LastValidIndex, last_valid_index);
 }
 
 void AC97::AC97Channel::start_dma()
 {
-    dbgln_if(AC97_DEBUG, "AC97 @ {}: channel {}: starting DMA engine", m_device.pci_address(), name());
+    dbgln_if(AC97_DEBUG, "AC97 @ {}: channel {}: starting DMA engine", m_device_pci_address, name());
 
-    auto control_register = reg(Register::Control);
-    auto control = control_register.in<u8>();
+    auto control = m_channel_io_window->read8(Register::Control);
     control |= AudioControlRegisterFlag::RunPauseBusMaster;
     control |= AudioControlRegisterFlag::FIFOErrorInterruptEnable;
     control |= AudioControlRegisterFlag::InterruptOnCompletionEnable;
-    control_register.out(control);
+    m_channel_io_window->write8(Register::Control, control);
 
     m_dma_running.with([](auto& dma_running) {
         dma_running = true;
diff --git a/Kernel/Devices/Audio/AC97.h b/Kernel/Devices/Audio/AC97.h
index 31655ecd45..9ad53a8d18 100644
--- a/Kernel/Devices/Audio/AC97.h
+++ b/Kernel/Devices/Audio/AC97.h
@@ -7,11 +7,11 @@
 #pragma once
 
 #include <AK/Error.h>
-#include <Kernel/Arch/x86/IO.h>
 #include <Kernel/Bus/PCI/API.h>
 #include <Kernel/Bus/PCI/Device.h>
 #include <Kernel/Devices/Audio/Controller.h>
 #include <Kernel/Devices/CharacterDevice.h>
+#include <Kernel/IOWindow.h>
 #include <Kernel/Interrupts/IRQHandler.h>
 #include <Kernel/Locking/SpinlockProtected.h>
 
@@ -123,12 +123,7 @@ private:
             Control = 0x0b,
         };
 
-        AC97Channel(AC97& device, StringView name, IOAddress channel_base)
-            : m_channel_base(channel_base)
-            , m_device(device)
-            , m_name(name)
-        {
-        }
+        static ErrorOr<NonnullOwnPtr<AC97Channel>> create_with_parent_pci_device(PCI::Address pci_device_address, StringView name, NonnullOwnPtr<IOWindow> channel_io_base);
 
         bool dma_running() const
         {
@@ -136,24 +131,31 @@ private:
         }
         void handle_dma_stopped();
         StringView name() const { return m_name; }
-        IOAddress reg(Register reg) const { return m_channel_base.offset(reg); }
         void reset();
         void set_last_valid_index(u32 buffer_address, u8 last_valid_index);
         void start_dma();
 
+        IOWindow& io_window() { return *m_channel_io_window; }
+
     private:
-        IOAddress m_channel_base;
-        AC97& m_device;
+        AC97Channel(PCI::Address pci_device_address, StringView name, NonnullOwnPtr<IOWindow> channel_io_base)
+            : m_channel_io_window(move(channel_io_base))
+            , m_device_pci_address(pci_device_address)
+            , m_name(name)
+        {
+        }
+
+        NonnullOwnPtr<IOWindow> m_channel_io_window;
+        PCI::Address m_device_pci_address;
         SpinlockProtected<bool> m_dma_running { LockRank::None, false };
         StringView m_name;
     };
 
-    explicit AC97(PCI::DeviceIdentifier const&);
+    AC97(PCI::DeviceIdentifier const&, NonnullOwnPtr<AC97Channel> pcm_out_channel, NonnullOwnPtr<IOWindow> mixer_io_window, NonnullOwnPtr<IOWindow> bus_io_window);
 
     // ^IRQHandler
     virtual bool handle_irq(RegisterState const&) override;
 
-    AC97Channel channel(StringView name, NativeAudioBusChannel channel) { return AC97Channel(*this, name, m_io_bus_base.offset(channel)); }
     ErrorOr<void> initialize();
     void set_master_output_volume(u8, u8, Muted);
     ErrorOr<void> set_pcm_output_sample_rate(u32);
@@ -171,13 +173,13 @@ private:
     u8 m_buffer_descriptor_list_index { 0 };
     AC97Revision m_codec_revision { AC97Revision::Revision21OrEarlier };
     bool m_double_rate_pcm_enabled { false };
-    IOAddress m_io_mixer_base;
-    IOAddress m_io_bus_base;
+    NonnullOwnPtr<IOWindow> m_mixer_io_window;
+    NonnullOwnPtr<IOWindow> m_bus_io_window;
     WaitQueue m_irq_queue;
     OwnPtr<Memory::Region> m_output_buffer;
     u8 m_output_buffer_page_count { 4 };
     u8 m_output_buffer_page_index { 0 };
-    AC97Channel m_pcm_out_channel;
+    NonnullOwnPtr<AC97Channel> m_pcm_out_channel;
     u32 m_sample_rate { 0 };
     bool m_variable_rate_pcm_supported { false };
     LockRefPtr<AudioChannel> m_audio_channel;