Move ioport header

include/PSX/System/IOPorts/IOValues/ioport.hpp

@@ -0,0 +1,124 @@
+#pragma once
+#include "../../../Auxiliary/types.hpp"
+#include "../../../Auxiliary/bits.hpp"
+
+namespace JabyEngine {
+    namespace IOAdress {
+        constexpr uintptr_t patch_adr(uintptr_t adr) {
+            constexpr uintptr_t Mask = 0xF0000000;
+            constexpr uintptr_t Base = 0x10000000; // We might want to change this later to 0xB0000000 for caching and stuff (More research needed)
+
+            return (Base + (adr & ~Mask));
+        }
+    }
+
+    namespace internal {
+        template<typename T, typename S>
+        struct IOValue {
+            typedef S UnderlyingType;
+
+            UnderlyingType raw;
+
+            template<typename...ARGS>
+            static constexpr T from(const ARGS&...args) {
+                return T{0}.set(args...);
+            }
+            
+            constexpr T& set(Bit bit) {
+                this->raw = bit::set(this->raw, bit);
+                return static_cast<T&>(*this);
+            }
+            
+            constexpr T& set(ClearBit bit) {
+                this->raw = bit::set(this->raw, bit);
+                return static_cast<T&>(*this);
+            }
+            
+            constexpr T& set_range(const BitRange& bits, UnderlyingType value) {
+                this->raw = bit::value::set_normalized(this->raw, bits, value);
+                return static_cast<T&>(*this);
+            }
+            
+            template<typename U>
+            constexpr T& set(const BitRange::RangeValuePair<U>& value) {
+                this->raw = bit::value::set_normalized(this->raw, value);
+                return static_cast<T&>(*this);
+            }
+            
+            template<typename U, typename...ARGS>
+            constexpr T& set(const U& head, const ARGS&...tail) {
+                return this->set(head).set(tail...);
+            }
+            
+            constexpr IOValue<T, S>::UnderlyingType get(BitRange bits) const {
+                return bit::value::get_normalized(this->raw, bits.pos, bits.length);
+            }
+            
+            constexpr T& clear(Bit bit) {          
+                this->raw = bit::clear(this->raw, bit);
+                return static_cast<T&>(*this);
+            }
+            
+            constexpr bool is_set(Bit bit) const {      
+                return bit::is_set(this->raw, bit);
+            }
+        };
+    }
+
+    template<typename T>
+    struct IOPort {
+        using Value = T;
+        T value;
+
+        T read() const {
+            return {const_cast<const volatile IOPort<T>*>(this)->value.raw};
+        }
+
+        void write(T value) {
+            const_cast<volatile IOPort<T>*>(this)->value.raw = value.raw;
+        }
+    };
+
+    template<>
+    struct IOPort<uint32_t>;
+
+    template<typename T>
+    struct IOPort32 {
+        union ValueHelper {
+            struct {
+                uint16_t low;
+                uint16_t high;               
+            };
+            T value;
+        };
+        using Value = T;
+        T value;
+
+        T read() const {
+            const auto*          cast_this = reinterpret_cast<const IOPort32<ValueHelper>*>(this);
+            const volatile auto* cv_this   = const_cast<volatile decltype(cast_this)>(cast_this);
+
+            return ValueHelper{.low = cv_this->value.low, .high = cv_this->value.high}.value;
+        }
+
+        void write(T value) {
+            const auto     new_value = ValueHelper{.value = value};
+            auto*          cast_this = reinterpret_cast<IOPort32<ValueHelper>*>(this);
+            volatile auto* v_this    = const_cast<volatile decltype(cast_this)>(cast_this);
+
+            v_this->value.low  = new_value.low;
+            v_this->value.high = new_value.high;
+        }
+    };
+
+    #define __declare_io_value(name, type)                struct name : public ::JabyEngine::internal::IOValue<struct name, type>
+    #define __declare_value_at(cv, type, name, adr)       static cv auto& name = *reinterpret_cast<type*>(::JabyEngine::IOAdress::patch_adr(adr))
+    #define __declare_array_at(cv, type, name, size, adr) static cv auto& name = reinterpret_cast<type(&)[size]>(*reinterpret_cast<type*>(IOAdress::patch_adr(adr)))
+    #define __declare_io_port_w_type(cv, type, name, adr) __declare_value_at(cv, ::JabyEngine::IOPort<type>, name, adr)
+    #define __declare_io_port(cv, name, adr)              __declare_io_port_w_type(cv, struct name, name, adr)        
+    #define __declare_io_port_array(cv, name, size, adr)  __declare_array_at(cv, struct name, name, size, adr)
+
+    #define __new_declare_io_port(type, adr)             *reinterpret_cast<type*>(adr)
+    #define __new_declare_io_value(type, adr)            __new_declare_io_port(type, adr)             
+    #define __new_declare_io_port_array(type, size, adr) reinterpret_cast<type(&)[size]>(*reinterpret_cast<type*>(adr))
+}