regs.h

Go to the documentation of this file.

#ifndef ZTH_REGS_H
#define ZTH_REGS_H
/*
 * Zth (libzth), a cooperative userspace multitasking library.
 * Copyright (C) 2019-2022  Jochem Rutgers
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */
 
#ifdef __cplusplus
#       include <libzth/macros.h>
#       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