Program Listing for File pio_sm.h

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

#pragma once
#ifndef RP2040_STRUCTS_PIO_SM_H
#define RP2040_STRUCTS_PIO_SM_H

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

namespace RP2040
{

struct pio_sm
{
    /* Constant attributes. */
    static constexpr struct_id_t id = 13;
    static constexpr std::size_t size = 24;
    /* Fields. */
    uint32_t CLKDIV;
    uint32_t EXECCTRL;
    uint32_t SHIFTCTRL;
    const uint32_t ADDR =
        {};
    uint32_t INSTR;
    uint32_t PINCTRL;
    /* Methods. */

    inline uint8_t get_CLKDIV_FRAC() volatile
    {
        return (CLKDIV >> 8u) & 0xffu;
    }

    inline void set_CLKDIV_FRAC(uint8_t value) volatile
    {
        uint32_t curr = CLKDIV;

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

        CLKDIV = curr;
    }

    inline uint16_t get_CLKDIV_INT() volatile
    {
        return (CLKDIV >> 16u) & 0xffffu;
    }

    inline void set_CLKDIV_INT(uint16_t value) volatile
    {
        uint32_t curr = CLKDIV;

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

        CLKDIV = curr;
    }

    inline void get_CLKDIV(uint8_t &FRAC, uint16_t &INT) volatile
    {
        uint32_t curr = CLKDIV;

        FRAC = (curr >> 8u) & 0xffu;
        INT = (curr >> 16u) & 0xffffu;
    }

    inline void set_CLKDIV(uint8_t FRAC, uint16_t INT) volatile
    {
        uint32_t curr = CLKDIV;

        curr &= ~(0xffu << 8u);
        curr |= (FRAC & 0xffu) << 8u;
        curr &= ~(0xffffu << 16u);
        curr |= (INT & 0xffffu) << 16u;

        CLKDIV = curr;
    }

    inline uint8_t get_EXECCTRL_STATUS_N() volatile
    {
        return EXECCTRL & 0xfu;
    }

    inline void set_EXECCTRL_STATUS_N(uint8_t value) volatile
    {
        uint32_t curr = EXECCTRL;

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

        EXECCTRL = curr;
    }

    inline bool get_EXECCTRL_STATUS_SEL() volatile
    {
        return EXECCTRL & (1u << 4u);
    }

    inline void set_EXECCTRL_STATUS_SEL() volatile
    {
        EXECCTRL |= 1u << 4u;
    }

    inline void clear_EXECCTRL_STATUS_SEL() volatile
    {
        EXECCTRL &= ~(1u << 4u);
    }

    inline void toggle_EXECCTRL_STATUS_SEL() volatile
    {
        EXECCTRL ^= 1u << 4u;
    }

    inline uint8_t get_EXECCTRL_WRAP_BOTTOM() volatile
    {
        return (EXECCTRL >> 7u) & 0b11111u;
    }

    inline void set_EXECCTRL_WRAP_BOTTOM(uint8_t value) volatile
    {
        uint32_t curr = EXECCTRL;

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

        EXECCTRL = curr;
    }

    inline uint8_t get_EXECCTRL_WRAP_TOP() volatile
    {
        return (EXECCTRL >> 12u) & 0b11111u;
    }

    inline void set_EXECCTRL_WRAP_TOP(uint8_t value) volatile
    {
        uint32_t curr = EXECCTRL;

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

        EXECCTRL = curr;
    }

    inline bool get_EXECCTRL_OUT_STICKY() volatile
    {
        return EXECCTRL & (1u << 17u);
    }

    inline void set_EXECCTRL_OUT_STICKY() volatile
    {
        EXECCTRL |= 1u << 17u;
    }

    inline void clear_EXECCTRL_OUT_STICKY() volatile
    {
        EXECCTRL &= ~(1u << 17u);
    }

    inline void toggle_EXECCTRL_OUT_STICKY() volatile
    {
        EXECCTRL ^= 1u << 17u;
    }

    inline bool get_EXECCTRL_INLINE_OUT_EN() volatile
    {
        return EXECCTRL & (1u << 18u);
    }

    inline void set_EXECCTRL_INLINE_OUT_EN() volatile
    {
        EXECCTRL |= 1u << 18u;
    }

    inline void clear_EXECCTRL_INLINE_OUT_EN() volatile
    {
        EXECCTRL &= ~(1u << 18u);
    }

    inline void toggle_EXECCTRL_INLINE_OUT_EN() volatile
    {
        EXECCTRL ^= 1u << 18u;
    }

    inline uint8_t get_EXECCTRL_OUT_EN_SEL() volatile
    {
        return (EXECCTRL >> 19u) & 0b11111u;
    }

    inline void set_EXECCTRL_OUT_EN_SEL(uint8_t value) volatile
    {
        uint32_t curr = EXECCTRL;

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

        EXECCTRL = curr;
    }

    inline uint8_t get_EXECCTRL_JMP_PIN() volatile
    {
        return (EXECCTRL >> 24u) & 0b11111u;
    }

    inline void set_EXECCTRL_JMP_PIN(uint8_t value) volatile
    {
        uint32_t curr = EXECCTRL;

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

        EXECCTRL = curr;
    }

    inline bool get_EXECCTRL_SIDE_PINDIR() volatile
    {
        return EXECCTRL & (1u << 29u);
    }

    inline void set_EXECCTRL_SIDE_PINDIR() volatile
    {
        EXECCTRL |= 1u << 29u;
    }

    inline void clear_EXECCTRL_SIDE_PINDIR() volatile
    {
        EXECCTRL &= ~(1u << 29u);
    }

    inline void toggle_EXECCTRL_SIDE_PINDIR() volatile
    {
        EXECCTRL ^= 1u << 29u;
    }

    inline bool get_EXECCTRL_SIDE_EN() volatile
    {
        return EXECCTRL & (1u << 30u);
    }

    inline void set_EXECCTRL_SIDE_EN() volatile
    {
        EXECCTRL |= 1u << 30u;
    }

    inline void clear_EXECCTRL_SIDE_EN() volatile
    {
        EXECCTRL &= ~(1u << 30u);
    }

    inline void toggle_EXECCTRL_SIDE_EN() volatile
    {
        EXECCTRL ^= 1u << 30u;
    }

    inline bool get_EXECCTRL_EXEC_STALLED() volatile
    {
        return EXECCTRL & (1u << 31u);
    }

    inline void get_EXECCTRL(uint8_t &STATUS_N, bool &STATUS_SEL,
                             uint8_t &WRAP_BOTTOM, uint8_t &WRAP_TOP,
                             bool &OUT_STICKY, bool &INLINE_OUT_EN,
                             uint8_t &OUT_EN_SEL, uint8_t &JMP_PIN,
                             bool &SIDE_PINDIR, bool &SIDE_EN,
                             bool &EXEC_STALLED) volatile
    {
        uint32_t curr = EXECCTRL;

        STATUS_N = curr & 0xfu;
        STATUS_SEL = curr & (1u << 4u);
        WRAP_BOTTOM = (curr >> 7u) & 0b11111u;
        WRAP_TOP = (curr >> 12u) & 0b11111u;
        OUT_STICKY = curr & (1u << 17u);
        INLINE_OUT_EN = curr & (1u << 18u);
        OUT_EN_SEL = (curr >> 19u) & 0b11111u;
        JMP_PIN = (curr >> 24u) & 0b11111u;
        SIDE_PINDIR = curr & (1u << 29u);
        SIDE_EN = curr & (1u << 30u);
        EXEC_STALLED = curr & (1u << 31u);
    }

    inline void set_EXECCTRL(uint8_t STATUS_N, bool STATUS_SEL,
                             uint8_t WRAP_BOTTOM, uint8_t WRAP_TOP,
                             bool OUT_STICKY, bool INLINE_OUT_EN,
                             uint8_t OUT_EN_SEL, uint8_t JMP_PIN,
                             bool SIDE_PINDIR, bool SIDE_EN) volatile
    {
        uint32_t curr = EXECCTRL;

        curr &= ~(0xfu);
        curr |= (STATUS_N & 0xfu);
        curr &= ~(0b1u << 4u);
        curr |= (STATUS_SEL & 0b1u) << 4u;
        curr &= ~(0b11111u << 7u);
        curr |= (WRAP_BOTTOM & 0b11111u) << 7u;
        curr &= ~(0b11111u << 12u);
        curr |= (WRAP_TOP & 0b11111u) << 12u;
        curr &= ~(0b1u << 17u);
        curr |= (OUT_STICKY & 0b1u) << 17u;
        curr &= ~(0b1u << 18u);
        curr |= (INLINE_OUT_EN & 0b1u) << 18u;
        curr &= ~(0b11111u << 19u);
        curr |= (OUT_EN_SEL & 0b11111u) << 19u;
        curr &= ~(0b11111u << 24u);
        curr |= (JMP_PIN & 0b11111u) << 24u;
        curr &= ~(0b1u << 29u);
        curr |= (SIDE_PINDIR & 0b1u) << 29u;
        curr &= ~(0b1u << 30u);
        curr |= (SIDE_EN & 0b1u) << 30u;

        EXECCTRL = curr;
    }

    inline bool get_SHIFTCTRL_AUTOPUSH() volatile
    {
        return SHIFTCTRL & (1u << 16u);
    }

    inline void set_SHIFTCTRL_AUTOPUSH() volatile
    {
        SHIFTCTRL |= 1u << 16u;
    }

    inline void clear_SHIFTCTRL_AUTOPUSH() volatile
    {
        SHIFTCTRL &= ~(1u << 16u);
    }

    inline void toggle_SHIFTCTRL_AUTOPUSH() volatile
    {
        SHIFTCTRL ^= 1u << 16u;
    }

    inline bool get_SHIFTCTRL_AUTOPULL() volatile
    {
        return SHIFTCTRL & (1u << 17u);
    }

    inline void set_SHIFTCTRL_AUTOPULL() volatile
    {
        SHIFTCTRL |= 1u << 17u;
    }

    inline void clear_SHIFTCTRL_AUTOPULL() volatile
    {
        SHIFTCTRL &= ~(1u << 17u);
    }

    inline void toggle_SHIFTCTRL_AUTOPULL() volatile
    {
        SHIFTCTRL ^= 1u << 17u;
    }

    inline bool get_SHIFTCTRL_IN_SHIFTDIR() volatile
    {
        return SHIFTCTRL & (1u << 18u);
    }

    inline void set_SHIFTCTRL_IN_SHIFTDIR() volatile
    {
        SHIFTCTRL |= 1u << 18u;
    }

    inline void clear_SHIFTCTRL_IN_SHIFTDIR() volatile
    {
        SHIFTCTRL &= ~(1u << 18u);
    }

    inline void toggle_SHIFTCTRL_IN_SHIFTDIR() volatile
    {
        SHIFTCTRL ^= 1u << 18u;
    }

    inline bool get_SHIFTCTRL_OUT_SHIFTDIR() volatile
    {
        return SHIFTCTRL & (1u << 19u);
    }

    inline void set_SHIFTCTRL_OUT_SHIFTDIR() volatile
    {
        SHIFTCTRL |= 1u << 19u;
    }

    inline void clear_SHIFTCTRL_OUT_SHIFTDIR() volatile
    {
        SHIFTCTRL &= ~(1u << 19u);
    }

    inline void toggle_SHIFTCTRL_OUT_SHIFTDIR() volatile
    {
        SHIFTCTRL ^= 1u << 19u;
    }

    inline uint8_t get_SHIFTCTRL_PUSH_THRESH() volatile
    {
        return (SHIFTCTRL >> 20u) & 0b11111u;
    }

    inline void set_SHIFTCTRL_PUSH_THRESH(uint8_t value) volatile
    {
        uint32_t curr = SHIFTCTRL;

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

        SHIFTCTRL = curr;
    }

    inline uint8_t get_SHIFTCTRL_PULL_THRESH() volatile
    {
        return (SHIFTCTRL >> 25u) & 0b11111u;
    }

    inline void set_SHIFTCTRL_PULL_THRESH(uint8_t value) volatile
    {
        uint32_t curr = SHIFTCTRL;

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

        SHIFTCTRL = curr;
    }

    inline bool get_SHIFTCTRL_FJOIN_TX() volatile
    {
        return SHIFTCTRL & (1u << 30u);
    }

    inline void set_SHIFTCTRL_FJOIN_TX() volatile
    {
        SHIFTCTRL |= 1u << 30u;
    }

    inline void clear_SHIFTCTRL_FJOIN_TX() volatile
    {
        SHIFTCTRL &= ~(1u << 30u);
    }

    inline void toggle_SHIFTCTRL_FJOIN_TX() volatile
    {
        SHIFTCTRL ^= 1u << 30u;
    }

    inline bool get_SHIFTCTRL_FJOIN_RX() volatile
    {
        return SHIFTCTRL & (1u << 31u);
    }

    inline void set_SHIFTCTRL_FJOIN_RX() volatile
    {
        SHIFTCTRL |= 1u << 31u;
    }

    inline void clear_SHIFTCTRL_FJOIN_RX() volatile
    {
        SHIFTCTRL &= ~(1u << 31u);
    }

    inline void toggle_SHIFTCTRL_FJOIN_RX() volatile
    {
        SHIFTCTRL ^= 1u << 31u;
    }

    inline void get_SHIFTCTRL(bool &AUTOPUSH, bool &AUTOPULL,
                              bool &IN_SHIFTDIR, bool &OUT_SHIFTDIR,
                              uint8_t &PUSH_THRESH, uint8_t &PULL_THRESH,
                              bool &FJOIN_TX, bool &FJOIN_RX) volatile
    {
        uint32_t curr = SHIFTCTRL;

        AUTOPUSH = curr & (1u << 16u);
        AUTOPULL = curr & (1u << 17u);
        IN_SHIFTDIR = curr & (1u << 18u);
        OUT_SHIFTDIR = curr & (1u << 19u);
        PUSH_THRESH = (curr >> 20u) & 0b11111u;
        PULL_THRESH = (curr >> 25u) & 0b11111u;
        FJOIN_TX = curr & (1u << 30u);
        FJOIN_RX = curr & (1u << 31u);
    }

    inline void set_SHIFTCTRL(bool AUTOPUSH, bool AUTOPULL, bool IN_SHIFTDIR,
                              bool OUT_SHIFTDIR, uint8_t PUSH_THRESH,
                              uint8_t PULL_THRESH, bool FJOIN_TX,
                              bool FJOIN_RX) volatile
    {
        uint32_t curr = SHIFTCTRL;

        curr &= ~(0b1u << 16u);
        curr |= (AUTOPUSH & 0b1u) << 16u;
        curr &= ~(0b1u << 17u);
        curr |= (AUTOPULL & 0b1u) << 17u;
        curr &= ~(0b1u << 18u);
        curr |= (IN_SHIFTDIR & 0b1u) << 18u;
        curr &= ~(0b1u << 19u);
        curr |= (OUT_SHIFTDIR & 0b1u) << 19u;
        curr &= ~(0b11111u << 20u);
        curr |= (PUSH_THRESH & 0b11111u) << 20u;
        curr &= ~(0b11111u << 25u);
        curr |= (PULL_THRESH & 0b11111u) << 25u;
        curr &= ~(0b1u << 30u);
        curr |= (FJOIN_TX & 0b1u) << 30u;
        curr &= ~(0b1u << 31u);
        curr |= (FJOIN_RX & 0b1u) << 31u;

        SHIFTCTRL = curr;
    }

    inline uint8_t get_ADDR() volatile
    {
        return ADDR & 0b11111u;
    }

    inline uint16_t get_INSTR() volatile
    {
        return INSTR & 0xffffu;
    }

    inline void set_INSTR(uint16_t value) volatile
    {
        uint32_t curr = INSTR;

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

        INSTR = curr;
    }

    inline uint8_t get_PINCTRL_OUT_BASE() volatile
    {
        return PINCTRL & 0b11111u;
    }

    inline void set_PINCTRL_OUT_BASE(uint8_t value) volatile
    {
        uint32_t curr = PINCTRL;

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

        PINCTRL = curr;
    }

    inline uint8_t get_PINCTRL_SET_BASE() volatile
    {
        return (PINCTRL >> 5u) & 0b11111u;
    }

    inline void set_PINCTRL_SET_BASE(uint8_t value) volatile
    {
        uint32_t curr = PINCTRL;

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

        PINCTRL = curr;
    }

    inline uint8_t get_PINCTRL_SIDESET_BASE() volatile
    {
        return (PINCTRL >> 10u) & 0b11111u;
    }

    inline void set_PINCTRL_SIDESET_BASE(uint8_t value) volatile
    {
        uint32_t curr = PINCTRL;

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

        PINCTRL = curr;
    }

    inline uint8_t get_PINCTRL_IN_BASE() volatile
    {
        return (PINCTRL >> 15u) & 0b11111u;
    }

    inline void set_PINCTRL_IN_BASE(uint8_t value) volatile
    {
        uint32_t curr = PINCTRL;

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

        PINCTRL = curr;
    }

    inline uint8_t get_PINCTRL_OUT_COUNT() volatile
    {
        return (PINCTRL >> 20u) & 0b111111u;
    }

    inline void set_PINCTRL_OUT_COUNT(uint8_t value) volatile
    {
        uint32_t curr = PINCTRL;

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

        PINCTRL = curr;
    }

    inline uint8_t get_PINCTRL_SET_COUNT() volatile
    {
        return (PINCTRL >> 26u) & 0b111u;
    }

    inline void set_PINCTRL_SET_COUNT(uint8_t value) volatile
    {
        uint32_t curr = PINCTRL;

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

        PINCTRL = curr;
    }

    inline uint8_t get_PINCTRL_SIDESET_COUNT() volatile
    {
        return (PINCTRL >> 29u) & 0b111u;
    }

    inline void set_PINCTRL_SIDESET_COUNT(uint8_t value) volatile
    {
        uint32_t curr = PINCTRL;

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

        PINCTRL = curr;
    }

    inline void get_PINCTRL(uint8_t &OUT_BASE, uint8_t &SET_BASE,
                            uint8_t &SIDESET_BASE, uint8_t &IN_BASE,
                            uint8_t &OUT_COUNT, uint8_t &SET_COUNT,
                            uint8_t &SIDESET_COUNT) volatile
    {
        uint32_t curr = PINCTRL;

        OUT_BASE = curr & 0b11111u;
        SET_BASE = (curr >> 5u) & 0b11111u;
        SIDESET_BASE = (curr >> 10u) & 0b11111u;
        IN_BASE = (curr >> 15u) & 0b11111u;
        OUT_COUNT = (curr >> 20u) & 0b111111u;
        SET_COUNT = (curr >> 26u) & 0b111u;
        SIDESET_COUNT = (curr >> 29u) & 0b111u;
    }

    inline void set_PINCTRL(uint8_t OUT_BASE, uint8_t SET_BASE,
                            uint8_t SIDESET_BASE, uint8_t IN_BASE,
                            uint8_t OUT_COUNT, uint8_t SET_COUNT,
                            uint8_t SIDESET_COUNT) volatile
    {
        uint32_t curr = PINCTRL;

        curr &= ~(0b11111u);
        curr |= (OUT_BASE & 0b11111u);
        curr &= ~(0b11111u << 5u);
        curr |= (SET_BASE & 0b11111u) << 5u;
        curr &= ~(0b11111u << 10u);
        curr |= (SIDESET_BASE & 0b11111u) << 10u;
        curr &= ~(0b11111u << 15u);
        curr |= (IN_BASE & 0b11111u) << 15u;
        curr &= ~(0b111111u << 20u);
        curr |= (OUT_COUNT & 0b111111u) << 20u;
        curr &= ~(0b111u << 26u);
        curr |= (SET_COUNT & 0b111u) << 26u;
        curr &= ~(0b111u << 29u);
        curr |= (SIDESET_COUNT & 0b111u) << 29u;

        PINCTRL = curr;
    }
};

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

static volatile pio_sm *const PIO_SM_NULL =
    reinterpret_cast<pio_sm *>(0x00000000);

}; // namespace RP2040

#endif