Program Listing for File xosc.h

↰ Return to documentation for file (src/generated/structs/xosc.h)

#pragma once
#ifndef RP2040_STRUCTS_XOSC_H
#define RP2040_STRUCTS_XOSC_H

#include "../enums/XOSC_CTRL_ENABLE.h"
#include "../enums/XOSC_CTRL_FREQ_RANGE.h"
#include "../enums/XOSC_STATUS_FREQ_RANGE.h"
#include "../ifgen/common.h"

namespace RP2040
{

struct xosc
{
    /* Constant attributes. */
    static constexpr struct_id_t id = 35;
    static constexpr std::size_t size = 32;
    /* Fields. */
    uint32_t CTRL;
    uint32_t STATUS;
    uint32_t DORMANT;
    uint32_t STARTUP;
    static constexpr std::size_t reserved_padding0_length = 3;
    const uint32_t reserved_padding0[reserved_padding0_length] = {};
    uint32_t COUNT;
    /* Methods. */

    inline XOSC_CTRL_FREQ_RANGE get_CTRL_FREQ_RANGE() volatile
    {
        return XOSC_CTRL_FREQ_RANGE(CTRL & 0xfffu);
    }

    inline void set_CTRL_FREQ_RANGE(XOSC_CTRL_FREQ_RANGE value) volatile
    {
        uint32_t curr = CTRL;

        curr &= ~(0xfffu);
        curr |= (std::to_underlying(value) & 0xfffu);

        CTRL = curr;
    }

    inline XOSC_CTRL_ENABLE get_CTRL_ENABLE() volatile
    {
        return XOSC_CTRL_ENABLE((CTRL >> 12u) & 0xfffu);
    }

    inline void set_CTRL_ENABLE(XOSC_CTRL_ENABLE value) volatile
    {
        uint32_t curr = CTRL;

        curr &= ~(0xfffu << 12u);
        curr |= (std::to_underlying(value) & 0xfffu) << 12u;

        CTRL = curr;
    }

    inline void get_CTRL(XOSC_CTRL_FREQ_RANGE &FREQ_RANGE,
                         XOSC_CTRL_ENABLE &ENABLE) volatile
    {
        uint32_t curr = CTRL;

        FREQ_RANGE = XOSC_CTRL_FREQ_RANGE(curr & 0xfffu);
        ENABLE = XOSC_CTRL_ENABLE((curr >> 12u) & 0xfffu);
    }

    inline void set_CTRL(XOSC_CTRL_FREQ_RANGE FREQ_RANGE,
                         XOSC_CTRL_ENABLE ENABLE) volatile
    {
        uint32_t curr = CTRL;

        curr &= ~(0xfffu);
        curr |= (std::to_underlying(FREQ_RANGE) & 0xfffu);
        curr &= ~(0xfffu << 12u);
        curr |= (std::to_underlying(ENABLE) & 0xfffu) << 12u;

        CTRL = curr;
    }

    inline XOSC_STATUS_FREQ_RANGE get_STATUS_FREQ_RANGE() volatile
    {
        return XOSC_STATUS_FREQ_RANGE(STATUS & 0b11u);
    }

    inline bool get_STATUS_ENABLED() volatile
    {
        return STATUS & (1u << 12u);
    }

    inline bool get_STATUS_BADWRITE() volatile
    {
        return STATUS & (1u << 24u);
    }

    inline void set_STATUS_BADWRITE() volatile
    {
        STATUS |= 1u << 24u;
    }

    inline void clear_STATUS_BADWRITE() volatile
    {
        STATUS &= ~(1u << 24u);
    }

    inline void toggle_STATUS_BADWRITE() volatile
    {
        STATUS ^= 1u << 24u;
    }

    inline bool get_STATUS_STABLE() volatile
    {
        return STATUS & (1u << 31u);
    }

    inline void get_STATUS(XOSC_STATUS_FREQ_RANGE &FREQ_RANGE, bool &ENABLED,
                           bool &BADWRITE, bool &STABLE) volatile
    {
        uint32_t curr = STATUS;

        FREQ_RANGE = XOSC_STATUS_FREQ_RANGE(curr & 0b11u);
        ENABLED = curr & (1u << 12u);
        BADWRITE = curr & (1u << 24u);
        STABLE = curr & (1u << 31u);
    }

    inline uint16_t get_STARTUP_DELAY() volatile
    {
        return STARTUP & 0b11111111111111u;
    }

    inline void set_STARTUP_DELAY(uint16_t value) volatile
    {
        uint32_t curr = STARTUP;

        curr &= ~(0b11111111111111u);
        curr |= (value & 0b11111111111111u);

        STARTUP = curr;
    }

    inline bool get_STARTUP_X4() volatile
    {
        return STARTUP & (1u << 20u);
    }

    inline void set_STARTUP_X4() volatile
    {
        STARTUP |= 1u << 20u;
    }

    inline void clear_STARTUP_X4() volatile
    {
        STARTUP &= ~(1u << 20u);
    }

    inline void toggle_STARTUP_X4() volatile
    {
        STARTUP ^= 1u << 20u;
    }

    inline void get_STARTUP(uint16_t &DELAY, bool &X4) volatile
    {
        uint32_t curr = STARTUP;

        DELAY = curr & 0b11111111111111u;
        X4 = curr & (1u << 20u);
    }

    inline void set_STARTUP(uint16_t DELAY, bool X4) volatile
    {
        uint32_t curr = STARTUP;

        curr &= ~(0b11111111111111u);
        curr |= (DELAY & 0b11111111111111u);
        curr &= ~(0b1u << 20u);
        curr |= (X4 & 0b1u) << 20u;

        STARTUP = curr;
    }

    inline uint8_t get_COUNT() volatile
    {
        return COUNT & 0xffu;
    }

    inline void set_COUNT(uint8_t value) volatile
    {
        uint32_t curr = COUNT;

        curr &= ~(0xffu);
        curr |= (value & 0xffu);

        COUNT = curr;
    }
};

static_assert(sizeof(xosc) == xosc::size);
static_assert(ifgen_struct<xosc>);

static volatile xosc *const XOSC = reinterpret_cast<xosc *>(0x40024000);

}; // namespace RP2040

#endif