Program Listing for File xosc.h

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

#pragma once

#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 [[gnu::packed]] xosc
{
    /* Constant attributes. */
    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 >> 0u) & 0b111111111111u);
    }

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

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

        CTRL = curr;
    }

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

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

        curr &= ~(0b111111111111u << 12u);
        curr |= (std::to_underlying(value) & 0b111111111111u) << 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 >> 0u) & 0b111111111111u);
        ENABLE = XOSC_CTRL_ENABLE((curr >> 12u) & 0b111111111111u);
    }

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

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

        CTRL = curr;
    }

    inline XOSC_STATUS_FREQ_RANGE get_STATUS_FREQ_RANGE() volatile
    {
        return XOSC_STATUS_FREQ_RANGE((STATUS >> 0u) & 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 >> 0u) & 0b11u);
        ENABLED = curr & (1u << 12u);
        BADWRITE = curr & (1u << 24u);
        STABLE = curr & (1u << 31u);
    }

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

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

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

        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 >> 0u) & 0b11111111111111u;
        X4 = curr & (1u << 20u);
    }

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

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

        STARTUP = curr;
    }

    inline uint8_t get_COUNT_COUNT() volatile
    {
        return (COUNT >> 0u) & 0b11111111u;
    }

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

        curr &= ~(0b11111111u << 0u);
        curr |= (value & 0b11111111u) << 0u;

        COUNT = curr;
    }
};

static_assert(sizeof(xosc) == xosc::size);

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

}; // namespace RP2040