regs.h

Go to the documentation of this file.

#ifndef ZTH_REGS_H
#define ZTH_REGS_H
/*
 * SPDX-FileCopyrightText: 2019-2026 Jochem Rutgers
 *
 * SPDX-License-Identifier: MPL-2.0
 */
 
#include <libzth/macros.h>
 
#ifdef __cplusplus
#  include <libzth/util.h>
 
namespace zth {
 
template <typename T, uintptr_t Addr, typename Fields>
struct Register {
        typedef T type;
 
        Register() noexcept
        {
                static_assert(sizeof(Fields) == sizeof(type), "");
                read();
        }
 
        constexpr explicit Register(type v) noexcept
                : value(v)
        {}
 
        union {
                type value;
                Fields field;
        };
 
        static type volatile* r() noexcept
        {
                return (type volatile*)Addr;
        }
 
        type read() const noexcept
        {
                return *r();
        }
 
        type read() noexcept
        {
                return value = *r();
        }
 
        void write() const noexcept
        {
                *r() = value;
        }
 
        void write(type v) const noexcept
        {
                *r() = v;
        }
 
        void write(type v) noexcept
        {
                *r() = value = v;
        }
 
        operator type() const noexcept
        {
                return value;
        }
};
 
#  if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
// In case of little-endian, gcc puts the last field at the highest bits.
// This is counter intuitive for registers. Reverse them.
#    define ZTH_REG_BITFIELDS(...) REVERSE(__VA_ARGS__)
#  else
#    define ZTH_REG_BITFIELDS(...) __VA_ARGS__
#  endif
 
#  define ZTH_REG_DEFINE(T, name, addr, fields...)                    \
          struct name##__type {                                       \
                  T ZTH_REG_BITFIELDS(fields);                        \
          } __attribute__((packed));                                  \
          struct name : public zth::Register<T, addr, name##__type> { \
                  typedef zth::Register<T, addr, name##__type> base;  \
                  using typename base::type;                          \
                  name() noexcept                                     \
                          : base()                                    \
                  {}                                                  \
                  constexpr explicit name(type v) noexcept            \
                          : base(v)                                   \
                  {}                                                  \
          };
 
} // namespace zth
#endif // __cplusplus
#endif // ZTH_REGS_H