Program Listing for File dma.h

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

#pragma once
#ifndef RP2040_STRUCTS_DMA_H
#define RP2040_STRUCTS_DMA_H

#include "../enums/DMA_SNIFF_CTRL_CALC.h"
#include "../ifgen/common.h"
#include "dma_control.h"
#include "dma_debug.h"

namespace RP2040
{

struct dma
{
    /* Constant attributes. */
    static constexpr struct_id_t id = 6;
    static constexpr std::size_t size = 3072;
    /* Fields. */
    static constexpr std::size_t CONTROL_length = 16;
    dma_control CONTROL[CONTROL_length];
    uint32_t INTR;
    uint32_t INTE0;
    uint32_t INTF0;
    uint32_t INTS0;
    const uint32_t reserved_padding0 = {};
    uint32_t INTE1;
    uint32_t INTF1;
    uint32_t INTS1;
    uint32_t TIMER0;
    uint32_t TIMER1;
    uint32_t TIMER2;
    uint32_t TIMER3;
    uint32_t MULTI_CHAN_TRIGGER;
    uint32_t SNIFF_CTRL;
    uint32_t SNIFF_DATA;
    const uint32_t reserved_padding1 = {};
    const uint32_t FIFO_LEVELS =
        {};
    uint32_t CHAN_ABORT;
    const uint32_t N_CHANNELS =
        {};
    static constexpr std::size_t reserved_padding2_length = 237;
    const uint32_t reserved_padding2[reserved_padding2_length] = {};
    static constexpr std::size_t DEBUG_length = 16;
    dma_debug DEBUG[DEBUG_length];

    /* Methods. */

    inline uint16_t get_INTR() volatile
    {
        return INTR & 0xffffu;
    }

    inline void set_INTR(uint16_t value) volatile
    {
        uint32_t curr = INTR;

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

        INTR = curr;
    }

    inline uint16_t get_INTE0() volatile
    {
        return INTE0 & 0xffffu;
    }

    inline void set_INTE0(uint16_t value) volatile
    {
        uint32_t curr = INTE0;

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

        INTE0 = curr;
    }

    inline uint16_t get_INTF0() volatile
    {
        return INTF0 & 0xffffu;
    }

    inline void set_INTF0(uint16_t value) volatile
    {
        uint32_t curr = INTF0;

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

        INTF0 = curr;
    }

    inline uint16_t get_INTS0() volatile
    {
        return INTS0 & 0xffffu;
    }

    inline void set_INTS0(uint16_t value) volatile
    {
        uint32_t curr = INTS0;

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

        INTS0 = curr;
    }

    inline uint16_t get_INTE1() volatile
    {
        return INTE1 & 0xffffu;
    }

    inline void set_INTE1(uint16_t value) volatile
    {
        uint32_t curr = INTE1;

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

        INTE1 = curr;
    }

    inline uint16_t get_INTF1() volatile
    {
        return INTF1 & 0xffffu;
    }

    inline void set_INTF1(uint16_t value) volatile
    {
        uint32_t curr = INTF1;

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

        INTF1 = curr;
    }

    inline uint16_t get_INTS1() volatile
    {
        return INTS1 & 0xffffu;
    }

    inline void set_INTS1(uint16_t value) volatile
    {
        uint32_t curr = INTS1;

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

        INTS1 = curr;
    }

    inline uint16_t get_TIMER0_Y() volatile
    {
        return TIMER0 & 0xffffu;
    }

    inline void set_TIMER0_Y(uint16_t value) volatile
    {
        uint32_t curr = TIMER0;

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

        TIMER0 = curr;
    }

    inline uint16_t get_TIMER0_X() volatile
    {
        return (TIMER0 >> 16u) & 0xffffu;
    }

    inline void set_TIMER0_X(uint16_t value) volatile
    {
        uint32_t curr = TIMER0;

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

        TIMER0 = curr;
    }

    inline void get_TIMER0(uint16_t &Y, uint16_t &X) volatile
    {
        uint32_t curr = TIMER0;

        Y = curr & 0xffffu;
        X = (curr >> 16u) & 0xffffu;
    }

    inline void set_TIMER0(uint16_t Y, uint16_t X) volatile
    {
        uint32_t curr = TIMER0;

        curr &= ~(0xffffu);
        curr |= (Y & 0xffffu);
        curr &= ~(0xffffu << 16u);
        curr |= (X & 0xffffu) << 16u;

        TIMER0 = curr;
    }

    inline uint16_t get_TIMER1_Y() volatile
    {
        return TIMER1 & 0xffffu;
    }

    inline void set_TIMER1_Y(uint16_t value) volatile
    {
        uint32_t curr = TIMER1;

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

        TIMER1 = curr;
    }

    inline uint16_t get_TIMER1_X() volatile
    {
        return (TIMER1 >> 16u) & 0xffffu;
    }

    inline void set_TIMER1_X(uint16_t value) volatile
    {
        uint32_t curr = TIMER1;

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

        TIMER1 = curr;
    }

    inline void get_TIMER1(uint16_t &Y, uint16_t &X) volatile
    {
        uint32_t curr = TIMER1;

        Y = curr & 0xffffu;
        X = (curr >> 16u) & 0xffffu;
    }

    inline void set_TIMER1(uint16_t Y, uint16_t X) volatile
    {
        uint32_t curr = TIMER1;

        curr &= ~(0xffffu);
        curr |= (Y & 0xffffu);
        curr &= ~(0xffffu << 16u);
        curr |= (X & 0xffffu) << 16u;

        TIMER1 = curr;
    }

    inline uint16_t get_TIMER2_Y() volatile
    {
        return TIMER2 & 0xffffu;
    }

    inline void set_TIMER2_Y(uint16_t value) volatile
    {
        uint32_t curr = TIMER2;

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

        TIMER2 = curr;
    }

    inline uint16_t get_TIMER2_X() volatile
    {
        return (TIMER2 >> 16u) & 0xffffu;
    }

    inline void set_TIMER2_X(uint16_t value) volatile
    {
        uint32_t curr = TIMER2;

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

        TIMER2 = curr;
    }

    inline void get_TIMER2(uint16_t &Y, uint16_t &X) volatile
    {
        uint32_t curr = TIMER2;

        Y = curr & 0xffffu;
        X = (curr >> 16u) & 0xffffu;
    }

    inline void set_TIMER2(uint16_t Y, uint16_t X) volatile
    {
        uint32_t curr = TIMER2;

        curr &= ~(0xffffu);
        curr |= (Y & 0xffffu);
        curr &= ~(0xffffu << 16u);
        curr |= (X & 0xffffu) << 16u;

        TIMER2 = curr;
    }

    inline uint16_t get_TIMER3_Y() volatile
    {
        return TIMER3 & 0xffffu;
    }

    inline void set_TIMER3_Y(uint16_t value) volatile
    {
        uint32_t curr = TIMER3;

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

        TIMER3 = curr;
    }

    inline uint16_t get_TIMER3_X() volatile
    {
        return (TIMER3 >> 16u) & 0xffffu;
    }

    inline void set_TIMER3_X(uint16_t value) volatile
    {
        uint32_t curr = TIMER3;

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

        TIMER3 = curr;
    }

    inline void get_TIMER3(uint16_t &Y, uint16_t &X) volatile
    {
        uint32_t curr = TIMER3;

        Y = curr & 0xffffu;
        X = (curr >> 16u) & 0xffffu;
    }

    inline void set_TIMER3(uint16_t Y, uint16_t X) volatile
    {
        uint32_t curr = TIMER3;

        curr &= ~(0xffffu);
        curr |= (Y & 0xffffu);
        curr &= ~(0xffffu << 16u);
        curr |= (X & 0xffffu) << 16u;

        TIMER3 = curr;
    }

    inline uint16_t get_MULTI_CHAN_TRIGGER() volatile
    {
        return MULTI_CHAN_TRIGGER & 0xffffu;
    }

    inline void set_MULTI_CHAN_TRIGGER(uint16_t value) volatile
    {
        uint32_t curr = MULTI_CHAN_TRIGGER;

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

        MULTI_CHAN_TRIGGER = curr;
    }

    inline bool get_SNIFF_CTRL_EN() volatile
    {
        return SNIFF_CTRL & 1u;
    }

    inline void set_SNIFF_CTRL_EN() volatile
    {
        SNIFF_CTRL |= 1u;
    }

    inline void clear_SNIFF_CTRL_EN() volatile
    {
        SNIFF_CTRL &= ~(1u);
    }

    inline void toggle_SNIFF_CTRL_EN() volatile
    {
        SNIFF_CTRL ^= 1u;
    }

    inline uint8_t get_SNIFF_CTRL_DMACH() volatile
    {
        return (SNIFF_CTRL >> 1u) & 0xfu;
    }

    inline void set_SNIFF_CTRL_DMACH(uint8_t value) volatile
    {
        uint32_t curr = SNIFF_CTRL;

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

        SNIFF_CTRL = curr;
    }

    inline DMA_SNIFF_CTRL_CALC get_SNIFF_CTRL_CALC() volatile
    {
        return DMA_SNIFF_CTRL_CALC((SNIFF_CTRL >> 5u) & 0xfu);
    }

    inline void set_SNIFF_CTRL_CALC(DMA_SNIFF_CTRL_CALC value) volatile
    {
        uint32_t curr = SNIFF_CTRL;

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

        SNIFF_CTRL = curr;
    }

    inline bool get_SNIFF_CTRL_BSWAP() volatile
    {
        return SNIFF_CTRL & (1u << 9u);
    }

    inline void set_SNIFF_CTRL_BSWAP() volatile
    {
        SNIFF_CTRL |= 1u << 9u;
    }

    inline void clear_SNIFF_CTRL_BSWAP() volatile
    {
        SNIFF_CTRL &= ~(1u << 9u);
    }

    inline void toggle_SNIFF_CTRL_BSWAP() volatile
    {
        SNIFF_CTRL ^= 1u << 9u;
    }

    inline bool get_SNIFF_CTRL_OUT_REV() volatile
    {
        return SNIFF_CTRL & (1u << 10u);
    }

    inline void set_SNIFF_CTRL_OUT_REV() volatile
    {
        SNIFF_CTRL |= 1u << 10u;
    }

    inline void clear_SNIFF_CTRL_OUT_REV() volatile
    {
        SNIFF_CTRL &= ~(1u << 10u);
    }

    inline void toggle_SNIFF_CTRL_OUT_REV() volatile
    {
        SNIFF_CTRL ^= 1u << 10u;
    }

    inline bool get_SNIFF_CTRL_OUT_INV() volatile
    {
        return SNIFF_CTRL & (1u << 11u);
    }

    inline void set_SNIFF_CTRL_OUT_INV() volatile
    {
        SNIFF_CTRL |= 1u << 11u;
    }

    inline void clear_SNIFF_CTRL_OUT_INV() volatile
    {
        SNIFF_CTRL &= ~(1u << 11u);
    }

    inline void toggle_SNIFF_CTRL_OUT_INV() volatile
    {
        SNIFF_CTRL ^= 1u << 11u;
    }

    inline void get_SNIFF_CTRL(bool &EN, uint8_t &DMACH,
                               DMA_SNIFF_CTRL_CALC &CALC, bool &BSWAP,
                               bool &OUT_REV, bool &OUT_INV) volatile
    {
        uint32_t curr = SNIFF_CTRL;

        EN = curr & 1u;
        DMACH = (curr >> 1u) & 0xfu;
        CALC = DMA_SNIFF_CTRL_CALC((curr >> 5u) & 0xfu);
        BSWAP = curr & (1u << 9u);
        OUT_REV = curr & (1u << 10u);
        OUT_INV = curr & (1u << 11u);
    }

    inline void set_SNIFF_CTRL(bool EN, uint8_t DMACH,
                               DMA_SNIFF_CTRL_CALC CALC, bool BSWAP,
                               bool OUT_REV, bool OUT_INV) volatile
    {
        uint32_t curr = SNIFF_CTRL;

        curr &= ~(0b1u);
        curr |= (EN & 0b1u);
        curr &= ~(0xfu << 1u);
        curr |= (DMACH & 0xfu) << 1u;
        curr &= ~(0xfu << 5u);
        curr |= (std::to_underlying(CALC) & 0xfu) << 5u;
        curr &= ~(0b1u << 9u);
        curr |= (BSWAP & 0b1u) << 9u;
        curr &= ~(0b1u << 10u);
        curr |= (OUT_REV & 0b1u) << 10u;
        curr &= ~(0b1u << 11u);
        curr |= (OUT_INV & 0b1u) << 11u;

        SNIFF_CTRL = curr;
    }

    inline uint8_t get_FIFO_LEVELS_TDF_LVL() volatile
    {
        return FIFO_LEVELS & 0xffu;
    }

    inline uint8_t get_FIFO_LEVELS_WAF_LVL() volatile
    {
        return (FIFO_LEVELS >> 8u) & 0xffu;
    }

    inline uint8_t get_FIFO_LEVELS_RAF_LVL() volatile
    {
        return (FIFO_LEVELS >> 16u) & 0xffu;
    }

    inline void get_FIFO_LEVELS(uint8_t &TDF_LVL, uint8_t &WAF_LVL,
                                uint8_t &RAF_LVL) volatile
    {
        uint32_t curr = FIFO_LEVELS;

        TDF_LVL = curr & 0xffu;
        WAF_LVL = (curr >> 8u) & 0xffu;
        RAF_LVL = (curr >> 16u) & 0xffu;
    }

    inline uint16_t get_CHAN_ABORT() volatile
    {
        return CHAN_ABORT & 0xffffu;
    }

    inline void set_CHAN_ABORT(uint16_t value) volatile
    {
        uint32_t curr = CHAN_ABORT;

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

        CHAN_ABORT = curr;
    }

    inline uint8_t get_N_CHANNELS() volatile
    {
        return N_CHANNELS & 0b11111u;
    }
};

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

static volatile dma *const DMA = reinterpret_cast<dma *>(0x50000000);

}; // namespace RP2040

#endif