123 lines
4.7 KiB
C++
123 lines
4.7 KiB
C++
#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_port_array(type, size, adr) reinterpret_cast<type(&)[size]>(*reinterpret_cast<type*>(adr))
|
|
} |