AK: Generalize ByteReader

Also use it instead of CPU.h's possibly_unaligned_data interface

3 files changed, 10 insertions, 64 deletions

diff --git a/Kernel/Arch/x86/CPU.h b/Kernel/Arch/x86/CPU.h
index cd21abeaff..77312bfbb9 100644
--- a/Kernel/Arch/x86/CPU.h
+++ b/Kernel/Arch/x86/CPU.h
@@ -30,62 +30,6 @@ inline u32 get_iopl_from_eflags(u32 eflags)
     return (eflags & iopl_mask) >> 12;
 }
 
-template<Integral T>
-void read_possibly_unaligned_data(u8* where, T& data) requires(sizeof(T) == 8 || sizeof(T) == 4 || sizeof(T) == 2)
-{
-    if (((FlatPtr)where % alignof(T)) == 0) {
-        data = *(T*)where;
-        return;
-    }
-    if constexpr (sizeof(T) == 2) {
-        data = *where | ((u16)(*(where + 1)) << 8);
-        return;
-    }
-    if constexpr (sizeof(T) == 4) {
-        data = *where | (((u32) * (where + 1)) << 8) | (((u32) * (where + 2)) << 16) | (((u32) * (where + 3)) << 24);
-        return;
-    }
-    if constexpr (sizeof(T) == 8) {
-        data = *where | (((u32) * (where + 1)) << 8) | (((u64) * (where + 2)) << 16) | (((u64) * (where + 3)) << 24)
-            | (((u64) * (where + 4)) << 32) | (((u64) * (where + 5)) << 40) | (((u64) * (where + 6)) << 48) | (((u64) * (where + 7)) << 56);
-        return;
-    }
-    VERIFY_NOT_REACHED();
-}
-
-template<Integral T>
-void write_possibly_unaligned_data(u8* where, T data) requires(sizeof(T) == 8 || sizeof(T) == 4 || sizeof(T) == 2)
-{
-    if (((FlatPtr)where % alignof(T)) == 0) {
-        *(T*)where = data;
-        return;
-    }
-    if constexpr (sizeof(T) == 2) {
-        where[0] = (u8)(data & 0xFF);
-        where[1] = (u8)((data >> 8) & 0xFF);
-        return;
-    }
-    if constexpr (sizeof(T) == 4) {
-        where[0] = (u8)(data & 0xFF);
-        where[1] = (u8)((data >> 8) & 0xFF);
-        where[2] = (u8)((data >> 16) & 0xFF);
-        where[3] = (u8)((data >> 24) & 0xFF);
-        return;
-    }
-    if constexpr (sizeof(T) == 8) {
-        where[0] = (u8)(data & 0xFF);
-        where[1] = (u8)((data >> 8) & 0xFF);
-        where[2] = (u8)((data >> 16) & 0xFF);
-        where[3] = (u8)((data >> 24) & 0xFF);
-        where[5] = (u8)(data >> 32 & 0xFF);
-        where[5] = (u8)((data >> 40) & 0xFF);
-        where[6] = (u8)((data >> 48) & 0xFF);
-        where[7] = (u8)((data >> 52) & 0xFF);
-        return;
-    }
-    VERIFY_NOT_REACHED();
-}
-
 const DescriptorTablePointer& get_gdtr();
 const DescriptorTablePointer& get_idtr();
 
diff --git a/Kernel/Bus/PCI/MMIOAccess.cpp b/Kernel/Bus/PCI/MMIOAccess.cpp
index d807cf71fb..f8d0945a1c 100644
--- a/Kernel/Bus/PCI/MMIOAccess.cpp
+++ b/Kernel/Bus/PCI/MMIOAccess.cpp
@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
+#include <AK/ByteReader.h>
 #include <AK/Optional.h>
 #include <Kernel/Arch/x86/InterruptDisabler.h>
 #include <Kernel/Bus/PCI/MMIOAccess.h>
@@ -128,7 +129,7 @@ u16 MMIOAccess::read16_field(Address address, u32 field)
     VERIFY(field < 0xfff);
     dbgln_if(PCI_DEBUG, "PCI: MMIO Reading 16-bit field {:#08x} for {}", field, address);
     u16 data = 0;
-    read_possibly_unaligned_data<u16>(get_device_configuration_space(address).offset(field & 0xfff).as_ptr(), data);
+    ByteReader::load<u16>(get_device_configuration_space(address).offset(field & 0xfff).as_ptr(), data);
     return data;
 }
 
@@ -138,7 +139,7 @@ u32 MMIOAccess::read32_field(Address address, u32 field)
     VERIFY(field <= 0xffc);
     dbgln_if(PCI_DEBUG, "PCI: MMIO Reading 32-bit field {:#08x} for {}", field, address);
     u32 data = 0;
-    read_possibly_unaligned_data<u32>(get_device_configuration_space(address).offset(field & 0xfff).as_ptr(), data);
+    ByteReader::load<u32>(get_device_configuration_space(address).offset(field & 0xfff).as_ptr(), data);
     return data;
 }
 
@@ -154,14 +155,14 @@ void MMIOAccess::write16_field(Address address, u32 field, u16 value)
     ScopedSpinLock lock(m_access_lock);
     VERIFY(field < 0xfff);
     dbgln_if(PCI_DEBUG, "PCI: MMIO Writing 16-bit field {:#08x}, value={:#02x} for {}", field, value, address);
-    write_possibly_unaligned_data<u16>(get_device_configuration_space(address).offset(field & 0xfff).as_ptr(), value);
+    ByteReader::store<u16>(get_device_configuration_space(address).offset(field & 0xfff).as_ptr(), value);
 }
 void MMIOAccess::write32_field(Address address, u32 field, u32 value)
 {
     ScopedSpinLock lock(m_access_lock);
     VERIFY(field <= 0xffc);
     dbgln_if(PCI_DEBUG, "PCI: MMIO Writing 32-bit field {:#08x}, value={:#02x} for {}", field, value, address);
-    write_possibly_unaligned_data<u32>(get_device_configuration_space(address).offset(field & 0xfff).as_ptr(), value);
+    ByteReader::store<u32>(get_device_configuration_space(address).offset(field & 0xfff).as_ptr(), value);
 }
 
 void MMIOAccess::enumerate_hardware(Function<void(Address, ID)> callback)
diff --git a/Kernel/Bus/PCI/WindowedMMIOAccess.cpp b/Kernel/Bus/PCI/WindowedMMIOAccess.cpp
index 181d8e9920..ef1503553f 100644
--- a/Kernel/Bus/PCI/WindowedMMIOAccess.cpp
+++ b/Kernel/Bus/PCI/WindowedMMIOAccess.cpp
@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
+#include <AK/ByteReader.h>
 #include <AK/Optional.h>
 #include <AK/StringView.h>
 #include <Kernel/Arch/x86/InterruptDisabler.h>
@@ -79,7 +80,7 @@ u16 WindowedMMIOAccess::read16_field(Address address, u32 field)
     VERIFY(field < 0xfff);
     dbgln_if(PCI_DEBUG, "PCI: MMIO Reading 16-bit field {:#08x} for {}", field, address);
     u16 data = 0;
-    read_possibly_unaligned_data<u16>(get_device_configuration_space(address).value().offset(field & 0xfff).as_ptr(), data);
+    ByteReader::load<u16>(get_device_configuration_space(address).value().offset(field & 0xfff).as_ptr(), data);
     return data;
 }
 
@@ -89,7 +90,7 @@ u32 WindowedMMIOAccess::read32_field(Address address, u32 field)
     VERIFY(field <= 0xffc);
     dbgln_if(PCI_DEBUG, "PCI: MMIO Reading 32-bit field {:#08x} for {}", field, address);
     u32 data = 0;
-    read_possibly_unaligned_data<u32>(get_device_configuration_space(address).value().offset(field & 0xfff).as_ptr(), data);
+    ByteReader::load<u32>(get_device_configuration_space(address).value().offset(field & 0xfff).as_ptr(), data);
     return data;
 }
 
@@ -105,14 +106,14 @@ void WindowedMMIOAccess::write16_field(Address address, u32 field, u16 value)
     InterruptDisabler disabler;
     VERIFY(field < 0xfff);
     dbgln_if(PCI_DEBUG, "PCI: MMIO Writing 16-bit field {:#08x}, value={:#02x} for {}", field, value, address);
-    write_possibly_unaligned_data<u16>(get_device_configuration_space(address).value().offset(field & 0xfff).as_ptr(), value);
+    ByteReader::store<u16>(get_device_configuration_space(address).value().offset(field & 0xfff).as_ptr(), value);
 }
 void WindowedMMIOAccess::write32_field(Address address, u32 field, u32 value)
 {
     InterruptDisabler disabler;
     VERIFY(field <= 0xffc);
     dbgln_if(PCI_DEBUG, "PCI: MMIO Writing 32-bit field {:#08x}, value={:#02x} for {}", field, value, address);
-    write_possibly_unaligned_data<u32>(get_device_configuration_space(address).value().offset(field & 0xfff).as_ptr(), value);
+    ByteReader::store<u32>(get_device_configuration_space(address).value().offset(field & 0xfff).as_ptr(), value);
 }
 
 }