Program Listing for File xip_ctrl.h

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

#pragma once

#include "../ifgen/common.h"

namespace RP2040
{

struct [[gnu::packed]] xip_ctrl
{
    /* Constant attributes. */
    static constexpr std::size_t size = 32;
    /* Fields. */
    uint32_t CTRL;
    uint32_t FLUSH;
    const uint32_t STAT = {};
    uint32_t CTR_HIT;
    uint32_t CTR_ACC;
    uint32_t STREAM_ADDR;
    uint32_t STREAM_CTR;
    uint32_t
        STREAM_FIFO;
    /* Methods. */

    inline bool get_CTRL_EN() volatile
    {
        return CTRL & (1u << 0u);
    }

    inline void set_CTRL_EN() volatile
    {
        CTRL |= 1u << 0u;
    }

    inline void clear_CTRL_EN() volatile
    {
        CTRL &= ~(1u << 0u);
    }

    inline void toggle_CTRL_EN() volatile
    {
        CTRL ^= 1u << 0u;
    }

    inline bool get_CTRL_ERR_BADWRITE() volatile
    {
        return CTRL & (1u << 1u);
    }

    inline void set_CTRL_ERR_BADWRITE() volatile
    {
        CTRL |= 1u << 1u;
    }

    inline void clear_CTRL_ERR_BADWRITE() volatile
    {
        CTRL &= ~(1u << 1u);
    }

    inline void toggle_CTRL_ERR_BADWRITE() volatile
    {
        CTRL ^= 1u << 1u;
    }

    inline bool get_CTRL_POWER_DOWN() volatile
    {
        return CTRL & (1u << 3u);
    }

    inline void set_CTRL_POWER_DOWN() volatile
    {
        CTRL |= 1u << 3u;
    }

    inline void clear_CTRL_POWER_DOWN() volatile
    {
        CTRL &= ~(1u << 3u);
    }

    inline void toggle_CTRL_POWER_DOWN() volatile
    {
        CTRL ^= 1u << 3u;
    }

    inline void get_CTRL(bool &EN, bool &ERR_BADWRITE,
                         bool &POWER_DOWN) volatile
    {
        uint32_t curr = CTRL;

        EN = curr & (1u << 0u);
        ERR_BADWRITE = curr & (1u << 1u);
        POWER_DOWN = curr & (1u << 3u);
    }

    inline void set_CTRL(bool EN, bool ERR_BADWRITE, bool POWER_DOWN) volatile
    {
        uint32_t curr = CTRL;

        curr &= ~(0b1u << 0u);
        curr |= (EN & 0b1u) << 0u;
        curr &= ~(0b1u << 1u);
        curr |= (ERR_BADWRITE & 0b1u) << 1u;
        curr &= ~(0b1u << 3u);
        curr |= (POWER_DOWN & 0b1u) << 3u;

        CTRL = curr;
    }

    inline bool get_FLUSH_FLUSH() volatile
    {
        return FLUSH & (1u << 0u);
    }

    inline void set_FLUSH_FLUSH() volatile
    {
        FLUSH |= 1u << 0u;
    }

    inline void clear_FLUSH_FLUSH() volatile
    {
        FLUSH &= ~(1u << 0u);
    }

    inline void toggle_FLUSH_FLUSH() volatile
    {
        FLUSH ^= 1u << 0u;
    }

    inline bool get_STAT_FLUSH_READY() volatile
    {
        return STAT & (1u << 0u);
    }

    inline bool get_STAT_FIFO_EMPTY() volatile
    {
        return STAT & (1u << 1u);
    }

    inline bool get_STAT_FIFO_FULL() volatile
    {
        return STAT & (1u << 2u);
    }

    inline void get_STAT(bool &FLUSH_READY, bool &FIFO_EMPTY,
                         bool &FIFO_FULL) volatile
    {
        uint32_t curr = STAT;

        FLUSH_READY = curr & (1u << 0u);
        FIFO_EMPTY = curr & (1u << 1u);
        FIFO_FULL = curr & (1u << 2u);
    }

    inline uint32_t get_STREAM_ADDR_STREAM_ADDR() volatile
    {
        return (STREAM_ADDR >> 2u) & 0b111111111111111111111111111111u;
    }

    inline void set_STREAM_ADDR_STREAM_ADDR(uint32_t value) volatile
    {
        uint32_t curr = STREAM_ADDR;

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

        STREAM_ADDR = curr;
    }

    inline uint32_t get_STREAM_CTR_STREAM_CTR() volatile
    {
        return (STREAM_CTR >> 0u) & 0b1111111111111111111111u;
    }

    inline void set_STREAM_CTR_STREAM_CTR(uint32_t value) volatile
    {
        uint32_t curr = STREAM_CTR;

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

        STREAM_CTR = curr;
    }
};

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

static volatile xip_ctrl *const XIP_CTRL =
    reinterpret_cast<xip_ctrl *>(0x14000000);

}; // namespace RP2040