registers.hpp

Go to the documentation of this file.

 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  *  _____.___.                 .___                    .__.__      *
  *  \__  |   | ____   ____   __| _/___________    _____|__|  |     *
  *   /   |   |/ ___\ / ___\ / __ |\_  __ \__  \  /  ___/  |  |     *
  *   \____   / /_/  > /_/  > /_/ | |  | \// __ \_\___ \|  |  |__   *
  *   / ______\___  /\___  /\____ | |__|  (____  /____  >__|____/   *
  *   \/     /_____//_____/      \/            \/     \/            *
  *                          - Common -                             *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  * This software can be used by students and other personal of the *
  * Bern University of Applied Sciences under the terms of the MIT  *
  * license.                                                        *
  * For other persons this software is under the terms of the GNU   *
  * General Public License version 2.                               *
  *                                                                 *
  * Copyright © 2021, Bern University of Applied Sciences.     *
  * All rights reserved.                                            *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#pragma once
 
#include <cpp/common/types.hpp>
#include <cpp/common/attributes.hpp>
 
#include <type_traits>  // Type traits
 
namespace bsp {
 
    template<u32 BaseAddress, typename SizeType, u8 From, u8 To>
    struct BitField {
        static constexpr SizeType Mask = ((1ULL << u64(To - From + 1)) - 1) << From;
 
        BitField() = default;
 
        [[nodiscard]] ALWAYS_INLINE constexpr operator SizeType() const {
            return (*reinterpret_cast<IO<SizeType>*>(BaseAddress) & Mask) >> From;
        }
 
        template<typename T>
        ALWAYS_INLINE constexpr T operator=(T value) const {
 
            IO<SizeType>& registerRef = *reinterpret_cast<IO<SizeType>*>(BaseAddress);
            SizeType bitfieldValue = (registerRef & ~Mask) | ((static_cast<SizeType>(value) << From) & Mask);
 
            registerRef = bitfieldValue;
 
            return bitfieldValue;
        }
 
        static_assert(From <= To, "Start bit needs to be lower than end bit");
    };
 
    template<addr_t BaseAddress, auto Offset, typename SizeType = reg_t>
    struct Register {
        static inline auto& Value = *reinterpret_cast<IO<SizeType>*>(BaseAddress + static_cast<addr_t>(Offset));
 
        template<u8 From, u8 To>
        using Field = BitField<BaseAddress + static_cast<addr_t>(Offset), SizeType, From, To>;
 
        static_assert((BaseAddress % sizeof(SizeType)) == 0, "MMIO Register address is not correctly aligned");
    };
 
}