Program Listing for File pads_qspi.h

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

#pragma once

#include "../enums/PADS_QSPI_GPIO_QSPI_SCLK_DRIVE.h"
#include "../enums/PADS_QSPI_GPIO_QSPI_SD0_DRIVE.h"
#include "../enums/PADS_QSPI_GPIO_QSPI_SD1_DRIVE.h"
#include "../enums/PADS_QSPI_GPIO_QSPI_SD2_DRIVE.h"
#include "../enums/PADS_QSPI_GPIO_QSPI_SD3_DRIVE.h"
#include "../enums/PADS_QSPI_GPIO_QSPI_SS_DRIVE.h"
#include "../ifgen/common.h"

namespace RP2040
{

struct [[gnu::packed]] pads_qspi
{
    /* Constant attributes. */
    static constexpr std::size_t size = 28;
    /* Fields. */
    uint32_t
        VOLTAGE_SELECT;
    uint32_t GPIO_QSPI_SCLK;
    uint32_t GPIO_QSPI_SD0;
    uint32_t GPIO_QSPI_SD1;
    uint32_t GPIO_QSPI_SD2;
    uint32_t GPIO_QSPI_SD3;
    uint32_t GPIO_QSPI_SS;
    /* Methods. */

    inline bool get_VOLTAGE_SELECT_VOLTAGE_SELECT() volatile
    {
        return VOLTAGE_SELECT & (1u << 0u);
    }

    inline void set_VOLTAGE_SELECT_VOLTAGE_SELECT() volatile
    {
        VOLTAGE_SELECT |= 1u << 0u;
    }

    inline void clear_VOLTAGE_SELECT_VOLTAGE_SELECT() volatile
    {
        VOLTAGE_SELECT &= ~(1u << 0u);
    }

    inline void toggle_VOLTAGE_SELECT_VOLTAGE_SELECT() volatile
    {
        VOLTAGE_SELECT ^= 1u << 0u;
    }

    inline bool get_GPIO_QSPI_SCLK_SLEWFAST() volatile
    {
        return GPIO_QSPI_SCLK & (1u << 0u);
    }

    inline void set_GPIO_QSPI_SCLK_SLEWFAST() volatile
    {
        GPIO_QSPI_SCLK |= 1u << 0u;
    }

    inline void clear_GPIO_QSPI_SCLK_SLEWFAST() volatile
    {
        GPIO_QSPI_SCLK &= ~(1u << 0u);
    }

    inline void toggle_GPIO_QSPI_SCLK_SLEWFAST() volatile
    {
        GPIO_QSPI_SCLK ^= 1u << 0u;
    }

    inline bool get_GPIO_QSPI_SCLK_SCHMITT() volatile
    {
        return GPIO_QSPI_SCLK & (1u << 1u);
    }

    inline void set_GPIO_QSPI_SCLK_SCHMITT() volatile
    {
        GPIO_QSPI_SCLK |= 1u << 1u;
    }

    inline void clear_GPIO_QSPI_SCLK_SCHMITT() volatile
    {
        GPIO_QSPI_SCLK &= ~(1u << 1u);
    }

    inline void toggle_GPIO_QSPI_SCLK_SCHMITT() volatile
    {
        GPIO_QSPI_SCLK ^= 1u << 1u;
    }

    inline bool get_GPIO_QSPI_SCLK_PDE() volatile
    {
        return GPIO_QSPI_SCLK & (1u << 2u);
    }

    inline void set_GPIO_QSPI_SCLK_PDE() volatile
    {
        GPIO_QSPI_SCLK |= 1u << 2u;
    }

    inline void clear_GPIO_QSPI_SCLK_PDE() volatile
    {
        GPIO_QSPI_SCLK &= ~(1u << 2u);
    }

    inline void toggle_GPIO_QSPI_SCLK_PDE() volatile
    {
        GPIO_QSPI_SCLK ^= 1u << 2u;
    }

    inline bool get_GPIO_QSPI_SCLK_PUE() volatile
    {
        return GPIO_QSPI_SCLK & (1u << 3u);
    }

    inline void set_GPIO_QSPI_SCLK_PUE() volatile
    {
        GPIO_QSPI_SCLK |= 1u << 3u;
    }

    inline void clear_GPIO_QSPI_SCLK_PUE() volatile
    {
        GPIO_QSPI_SCLK &= ~(1u << 3u);
    }

    inline void toggle_GPIO_QSPI_SCLK_PUE() volatile
    {
        GPIO_QSPI_SCLK ^= 1u << 3u;
    }

    inline PADS_QSPI_GPIO_QSPI_SCLK_DRIVE get_GPIO_QSPI_SCLK_DRIVE() volatile
    {
        return PADS_QSPI_GPIO_QSPI_SCLK_DRIVE((GPIO_QSPI_SCLK >> 4u) & 0b11u);
    }

    inline void set_GPIO_QSPI_SCLK_DRIVE(
        PADS_QSPI_GPIO_QSPI_SCLK_DRIVE value) volatile
    {
        uint32_t curr = GPIO_QSPI_SCLK;

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

        GPIO_QSPI_SCLK = curr;
    }

    inline bool get_GPIO_QSPI_SCLK_IE() volatile
    {
        return GPIO_QSPI_SCLK & (1u << 6u);
    }

    inline void set_GPIO_QSPI_SCLK_IE() volatile
    {
        GPIO_QSPI_SCLK |= 1u << 6u;
    }

    inline void clear_GPIO_QSPI_SCLK_IE() volatile
    {
        GPIO_QSPI_SCLK &= ~(1u << 6u);
    }

    inline void toggle_GPIO_QSPI_SCLK_IE() volatile
    {
        GPIO_QSPI_SCLK ^= 1u << 6u;
    }

    inline bool get_GPIO_QSPI_SCLK_OD() volatile
    {
        return GPIO_QSPI_SCLK & (1u << 7u);
    }

    inline void set_GPIO_QSPI_SCLK_OD() volatile
    {
        GPIO_QSPI_SCLK |= 1u << 7u;
    }

    inline void clear_GPIO_QSPI_SCLK_OD() volatile
    {
        GPIO_QSPI_SCLK &= ~(1u << 7u);
    }

    inline void toggle_GPIO_QSPI_SCLK_OD() volatile
    {
        GPIO_QSPI_SCLK ^= 1u << 7u;
    }

    inline void get_GPIO_QSPI_SCLK(bool &SLEWFAST, bool &SCHMITT, bool &PDE,
                                   bool &PUE,
                                   PADS_QSPI_GPIO_QSPI_SCLK_DRIVE &DRIVE,
                                   bool &IE, bool &OD) volatile
    {
        uint32_t curr = GPIO_QSPI_SCLK;

        SLEWFAST = curr & (1u << 0u);
        SCHMITT = curr & (1u << 1u);
        PDE = curr & (1u << 2u);
        PUE = curr & (1u << 3u);
        DRIVE = PADS_QSPI_GPIO_QSPI_SCLK_DRIVE((curr >> 4u) & 0b11u);
        IE = curr & (1u << 6u);
        OD = curr & (1u << 7u);
    }

    inline void set_GPIO_QSPI_SCLK(bool SLEWFAST, bool SCHMITT, bool PDE,
                                   bool PUE,
                                   PADS_QSPI_GPIO_QSPI_SCLK_DRIVE DRIVE,
                                   bool IE, bool OD) volatile
    {
        uint32_t curr = GPIO_QSPI_SCLK;

        curr &= ~(0b1u << 0u);
        curr |= (SLEWFAST & 0b1u) << 0u;
        curr &= ~(0b1u << 1u);
        curr |= (SCHMITT & 0b1u) << 1u;
        curr &= ~(0b1u << 2u);
        curr |= (PDE & 0b1u) << 2u;
        curr &= ~(0b1u << 3u);
        curr |= (PUE & 0b1u) << 3u;
        curr &= ~(0b11u << 4u);
        curr |= (std::to_underlying(DRIVE) & 0b11u) << 4u;
        curr &= ~(0b1u << 6u);
        curr |= (IE & 0b1u) << 6u;
        curr &= ~(0b1u << 7u);
        curr |= (OD & 0b1u) << 7u;

        GPIO_QSPI_SCLK = curr;
    }

    inline bool get_GPIO_QSPI_SD0_SLEWFAST() volatile
    {
        return GPIO_QSPI_SD0 & (1u << 0u);
    }

    inline void set_GPIO_QSPI_SD0_SLEWFAST() volatile
    {
        GPIO_QSPI_SD0 |= 1u << 0u;
    }

    inline void clear_GPIO_QSPI_SD0_SLEWFAST() volatile
    {
        GPIO_QSPI_SD0 &= ~(1u << 0u);
    }

    inline void toggle_GPIO_QSPI_SD0_SLEWFAST() volatile
    {
        GPIO_QSPI_SD0 ^= 1u << 0u;
    }

    inline bool get_GPIO_QSPI_SD0_SCHMITT() volatile
    {
        return GPIO_QSPI_SD0 & (1u << 1u);
    }

    inline void set_GPIO_QSPI_SD0_SCHMITT() volatile
    {
        GPIO_QSPI_SD0 |= 1u << 1u;
    }

    inline void clear_GPIO_QSPI_SD0_SCHMITT() volatile
    {
        GPIO_QSPI_SD0 &= ~(1u << 1u);
    }

    inline void toggle_GPIO_QSPI_SD0_SCHMITT() volatile
    {
        GPIO_QSPI_SD0 ^= 1u << 1u;
    }

    inline bool get_GPIO_QSPI_SD0_PDE() volatile
    {
        return GPIO_QSPI_SD0 & (1u << 2u);
    }

    inline void set_GPIO_QSPI_SD0_PDE() volatile
    {
        GPIO_QSPI_SD0 |= 1u << 2u;
    }

    inline void clear_GPIO_QSPI_SD0_PDE() volatile
    {
        GPIO_QSPI_SD0 &= ~(1u << 2u);
    }

    inline void toggle_GPIO_QSPI_SD0_PDE() volatile
    {
        GPIO_QSPI_SD0 ^= 1u << 2u;
    }

    inline bool get_GPIO_QSPI_SD0_PUE() volatile
    {
        return GPIO_QSPI_SD0 & (1u << 3u);
    }

    inline void set_GPIO_QSPI_SD0_PUE() volatile
    {
        GPIO_QSPI_SD0 |= 1u << 3u;
    }

    inline void clear_GPIO_QSPI_SD0_PUE() volatile
    {
        GPIO_QSPI_SD0 &= ~(1u << 3u);
    }

    inline void toggle_GPIO_QSPI_SD0_PUE() volatile
    {
        GPIO_QSPI_SD0 ^= 1u << 3u;
    }

    inline PADS_QSPI_GPIO_QSPI_SD0_DRIVE get_GPIO_QSPI_SD0_DRIVE() volatile
    {
        return PADS_QSPI_GPIO_QSPI_SD0_DRIVE((GPIO_QSPI_SD0 >> 4u) & 0b11u);
    }

    inline void set_GPIO_QSPI_SD0_DRIVE(
        PADS_QSPI_GPIO_QSPI_SD0_DRIVE value) volatile
    {
        uint32_t curr = GPIO_QSPI_SD0;

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

        GPIO_QSPI_SD0 = curr;
    }

    inline bool get_GPIO_QSPI_SD0_IE() volatile
    {
        return GPIO_QSPI_SD0 & (1u << 6u);
    }

    inline void set_GPIO_QSPI_SD0_IE() volatile
    {
        GPIO_QSPI_SD0 |= 1u << 6u;
    }

    inline void clear_GPIO_QSPI_SD0_IE() volatile
    {
        GPIO_QSPI_SD0 &= ~(1u << 6u);
    }

    inline void toggle_GPIO_QSPI_SD0_IE() volatile
    {
        GPIO_QSPI_SD0 ^= 1u << 6u;
    }

    inline bool get_GPIO_QSPI_SD0_OD() volatile
    {
        return GPIO_QSPI_SD0 & (1u << 7u);
    }

    inline void set_GPIO_QSPI_SD0_OD() volatile
    {
        GPIO_QSPI_SD0 |= 1u << 7u;
    }

    inline void clear_GPIO_QSPI_SD0_OD() volatile
    {
        GPIO_QSPI_SD0 &= ~(1u << 7u);
    }

    inline void toggle_GPIO_QSPI_SD0_OD() volatile
    {
        GPIO_QSPI_SD0 ^= 1u << 7u;
    }

    inline void get_GPIO_QSPI_SD0(bool &SLEWFAST, bool &SCHMITT, bool &PDE,
                                  bool &PUE,
                                  PADS_QSPI_GPIO_QSPI_SD0_DRIVE &DRIVE,
                                  bool &IE, bool &OD) volatile
    {
        uint32_t curr = GPIO_QSPI_SD0;

        SLEWFAST = curr & (1u << 0u);
        SCHMITT = curr & (1u << 1u);
        PDE = curr & (1u << 2u);
        PUE = curr & (1u << 3u);
        DRIVE = PADS_QSPI_GPIO_QSPI_SD0_DRIVE((curr >> 4u) & 0b11u);
        IE = curr & (1u << 6u);
        OD = curr & (1u << 7u);
    }

    inline void set_GPIO_QSPI_SD0(bool SLEWFAST, bool SCHMITT, bool PDE,
                                  bool PUE,
                                  PADS_QSPI_GPIO_QSPI_SD0_DRIVE DRIVE, bool IE,
                                  bool OD) volatile
    {
        uint32_t curr = GPIO_QSPI_SD0;

        curr &= ~(0b1u << 0u);
        curr |= (SLEWFAST & 0b1u) << 0u;
        curr &= ~(0b1u << 1u);
        curr |= (SCHMITT & 0b1u) << 1u;
        curr &= ~(0b1u << 2u);
        curr |= (PDE & 0b1u) << 2u;
        curr &= ~(0b1u << 3u);
        curr |= (PUE & 0b1u) << 3u;
        curr &= ~(0b11u << 4u);
        curr |= (std::to_underlying(DRIVE) & 0b11u) << 4u;
        curr &= ~(0b1u << 6u);
        curr |= (IE & 0b1u) << 6u;
        curr &= ~(0b1u << 7u);
        curr |= (OD & 0b1u) << 7u;

        GPIO_QSPI_SD0 = curr;
    }

    inline bool get_GPIO_QSPI_SD1_SLEWFAST() volatile
    {
        return GPIO_QSPI_SD1 & (1u << 0u);
    }

    inline void set_GPIO_QSPI_SD1_SLEWFAST() volatile
    {
        GPIO_QSPI_SD1 |= 1u << 0u;
    }

    inline void clear_GPIO_QSPI_SD1_SLEWFAST() volatile
    {
        GPIO_QSPI_SD1 &= ~(1u << 0u);
    }

    inline void toggle_GPIO_QSPI_SD1_SLEWFAST() volatile
    {
        GPIO_QSPI_SD1 ^= 1u << 0u;
    }

    inline bool get_GPIO_QSPI_SD1_SCHMITT() volatile
    {
        return GPIO_QSPI_SD1 & (1u << 1u);
    }

    inline void set_GPIO_QSPI_SD1_SCHMITT() volatile
    {
        GPIO_QSPI_SD1 |= 1u << 1u;
    }

    inline void clear_GPIO_QSPI_SD1_SCHMITT() volatile
    {
        GPIO_QSPI_SD1 &= ~(1u << 1u);
    }

    inline void toggle_GPIO_QSPI_SD1_SCHMITT() volatile
    {
        GPIO_QSPI_SD1 ^= 1u << 1u;
    }

    inline bool get_GPIO_QSPI_SD1_PDE() volatile
    {
        return GPIO_QSPI_SD1 & (1u << 2u);
    }

    inline void set_GPIO_QSPI_SD1_PDE() volatile
    {
        GPIO_QSPI_SD1 |= 1u << 2u;
    }

    inline void clear_GPIO_QSPI_SD1_PDE() volatile
    {
        GPIO_QSPI_SD1 &= ~(1u << 2u);
    }

    inline void toggle_GPIO_QSPI_SD1_PDE() volatile
    {
        GPIO_QSPI_SD1 ^= 1u << 2u;
    }

    inline bool get_GPIO_QSPI_SD1_PUE() volatile
    {
        return GPIO_QSPI_SD1 & (1u << 3u);
    }

    inline void set_GPIO_QSPI_SD1_PUE() volatile
    {
        GPIO_QSPI_SD1 |= 1u << 3u;
    }

    inline void clear_GPIO_QSPI_SD1_PUE() volatile
    {
        GPIO_QSPI_SD1 &= ~(1u << 3u);
    }

    inline void toggle_GPIO_QSPI_SD1_PUE() volatile
    {
        GPIO_QSPI_SD1 ^= 1u << 3u;
    }

    inline PADS_QSPI_GPIO_QSPI_SD1_DRIVE get_GPIO_QSPI_SD1_DRIVE() volatile
    {
        return PADS_QSPI_GPIO_QSPI_SD1_DRIVE((GPIO_QSPI_SD1 >> 4u) & 0b11u);
    }

    inline void set_GPIO_QSPI_SD1_DRIVE(
        PADS_QSPI_GPIO_QSPI_SD1_DRIVE value) volatile
    {
        uint32_t curr = GPIO_QSPI_SD1;

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

        GPIO_QSPI_SD1 = curr;
    }

    inline bool get_GPIO_QSPI_SD1_IE() volatile
    {
        return GPIO_QSPI_SD1 & (1u << 6u);
    }

    inline void set_GPIO_QSPI_SD1_IE() volatile
    {
        GPIO_QSPI_SD1 |= 1u << 6u;
    }

    inline void clear_GPIO_QSPI_SD1_IE() volatile
    {
        GPIO_QSPI_SD1 &= ~(1u << 6u);
    }

    inline void toggle_GPIO_QSPI_SD1_IE() volatile
    {
        GPIO_QSPI_SD1 ^= 1u << 6u;
    }

    inline bool get_GPIO_QSPI_SD1_OD() volatile
    {
        return GPIO_QSPI_SD1 & (1u << 7u);
    }

    inline void set_GPIO_QSPI_SD1_OD() volatile
    {
        GPIO_QSPI_SD1 |= 1u << 7u;
    }

    inline void clear_GPIO_QSPI_SD1_OD() volatile
    {
        GPIO_QSPI_SD1 &= ~(1u << 7u);
    }

    inline void toggle_GPIO_QSPI_SD1_OD() volatile
    {
        GPIO_QSPI_SD1 ^= 1u << 7u;
    }

    inline void get_GPIO_QSPI_SD1(bool &SLEWFAST, bool &SCHMITT, bool &PDE,
                                  bool &PUE,
                                  PADS_QSPI_GPIO_QSPI_SD1_DRIVE &DRIVE,
                                  bool &IE, bool &OD) volatile
    {
        uint32_t curr = GPIO_QSPI_SD1;

        SLEWFAST = curr & (1u << 0u);
        SCHMITT = curr & (1u << 1u);
        PDE = curr & (1u << 2u);
        PUE = curr & (1u << 3u);
        DRIVE = PADS_QSPI_GPIO_QSPI_SD1_DRIVE((curr >> 4u) & 0b11u);
        IE = curr & (1u << 6u);
        OD = curr & (1u << 7u);
    }

    inline void set_GPIO_QSPI_SD1(bool SLEWFAST, bool SCHMITT, bool PDE,
                                  bool PUE,
                                  PADS_QSPI_GPIO_QSPI_SD1_DRIVE DRIVE, bool IE,
                                  bool OD) volatile
    {
        uint32_t curr = GPIO_QSPI_SD1;

        curr &= ~(0b1u << 0u);
        curr |= (SLEWFAST & 0b1u) << 0u;
        curr &= ~(0b1u << 1u);
        curr |= (SCHMITT & 0b1u) << 1u;
        curr &= ~(0b1u << 2u);
        curr |= (PDE & 0b1u) << 2u;
        curr &= ~(0b1u << 3u);
        curr |= (PUE & 0b1u) << 3u;
        curr &= ~(0b11u << 4u);
        curr |= (std::to_underlying(DRIVE) & 0b11u) << 4u;
        curr &= ~(0b1u << 6u);
        curr |= (IE & 0b1u) << 6u;
        curr &= ~(0b1u << 7u);
        curr |= (OD & 0b1u) << 7u;

        GPIO_QSPI_SD1 = curr;
    }

    inline bool get_GPIO_QSPI_SD2_SLEWFAST() volatile
    {
        return GPIO_QSPI_SD2 & (1u << 0u);
    }

    inline void set_GPIO_QSPI_SD2_SLEWFAST() volatile
    {
        GPIO_QSPI_SD2 |= 1u << 0u;
    }

    inline void clear_GPIO_QSPI_SD2_SLEWFAST() volatile
    {
        GPIO_QSPI_SD2 &= ~(1u << 0u);
    }

    inline void toggle_GPIO_QSPI_SD2_SLEWFAST() volatile
    {
        GPIO_QSPI_SD2 ^= 1u << 0u;
    }

    inline bool get_GPIO_QSPI_SD2_SCHMITT() volatile
    {
        return GPIO_QSPI_SD2 & (1u << 1u);
    }

    inline void set_GPIO_QSPI_SD2_SCHMITT() volatile
    {
        GPIO_QSPI_SD2 |= 1u << 1u;
    }

    inline void clear_GPIO_QSPI_SD2_SCHMITT() volatile
    {
        GPIO_QSPI_SD2 &= ~(1u << 1u);
    }

    inline void toggle_GPIO_QSPI_SD2_SCHMITT() volatile
    {
        GPIO_QSPI_SD2 ^= 1u << 1u;
    }

    inline bool get_GPIO_QSPI_SD2_PDE() volatile
    {
        return GPIO_QSPI_SD2 & (1u << 2u);
    }

    inline void set_GPIO_QSPI_SD2_PDE() volatile
    {
        GPIO_QSPI_SD2 |= 1u << 2u;
    }

    inline void clear_GPIO_QSPI_SD2_PDE() volatile
    {
        GPIO_QSPI_SD2 &= ~(1u << 2u);
    }

    inline void toggle_GPIO_QSPI_SD2_PDE() volatile
    {
        GPIO_QSPI_SD2 ^= 1u << 2u;
    }

    inline bool get_GPIO_QSPI_SD2_PUE() volatile
    {
        return GPIO_QSPI_SD2 & (1u << 3u);
    }

    inline void set_GPIO_QSPI_SD2_PUE() volatile
    {
        GPIO_QSPI_SD2 |= 1u << 3u;
    }

    inline void clear_GPIO_QSPI_SD2_PUE() volatile
    {
        GPIO_QSPI_SD2 &= ~(1u << 3u);
    }

    inline void toggle_GPIO_QSPI_SD2_PUE() volatile
    {
        GPIO_QSPI_SD2 ^= 1u << 3u;
    }

    inline PADS_QSPI_GPIO_QSPI_SD2_DRIVE get_GPIO_QSPI_SD2_DRIVE() volatile
    {
        return PADS_QSPI_GPIO_QSPI_SD2_DRIVE((GPIO_QSPI_SD2 >> 4u) & 0b11u);
    }

    inline void set_GPIO_QSPI_SD2_DRIVE(
        PADS_QSPI_GPIO_QSPI_SD2_DRIVE value) volatile
    {
        uint32_t curr = GPIO_QSPI_SD2;

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

        GPIO_QSPI_SD2 = curr;
    }

    inline bool get_GPIO_QSPI_SD2_IE() volatile
    {
        return GPIO_QSPI_SD2 & (1u << 6u);
    }

    inline void set_GPIO_QSPI_SD2_IE() volatile
    {
        GPIO_QSPI_SD2 |= 1u << 6u;
    }

    inline void clear_GPIO_QSPI_SD2_IE() volatile
    {
        GPIO_QSPI_SD2 &= ~(1u << 6u);
    }

    inline void toggle_GPIO_QSPI_SD2_IE() volatile
    {
        GPIO_QSPI_SD2 ^= 1u << 6u;
    }

    inline bool get_GPIO_QSPI_SD2_OD() volatile
    {
        return GPIO_QSPI_SD2 & (1u << 7u);
    }

    inline void set_GPIO_QSPI_SD2_OD() volatile
    {
        GPIO_QSPI_SD2 |= 1u << 7u;
    }

    inline void clear_GPIO_QSPI_SD2_OD() volatile
    {
        GPIO_QSPI_SD2 &= ~(1u << 7u);
    }

    inline void toggle_GPIO_QSPI_SD2_OD() volatile
    {
        GPIO_QSPI_SD2 ^= 1u << 7u;
    }

    inline void get_GPIO_QSPI_SD2(bool &SLEWFAST, bool &SCHMITT, bool &PDE,
                                  bool &PUE,
                                  PADS_QSPI_GPIO_QSPI_SD2_DRIVE &DRIVE,
                                  bool &IE, bool &OD) volatile
    {
        uint32_t curr = GPIO_QSPI_SD2;

        SLEWFAST = curr & (1u << 0u);
        SCHMITT = curr & (1u << 1u);
        PDE = curr & (1u << 2u);
        PUE = curr & (1u << 3u);
        DRIVE = PADS_QSPI_GPIO_QSPI_SD2_DRIVE((curr >> 4u) & 0b11u);
        IE = curr & (1u << 6u);
        OD = curr & (1u << 7u);
    }

    inline void set_GPIO_QSPI_SD2(bool SLEWFAST, bool SCHMITT, bool PDE,
                                  bool PUE,
                                  PADS_QSPI_GPIO_QSPI_SD2_DRIVE DRIVE, bool IE,
                                  bool OD) volatile
    {
        uint32_t curr = GPIO_QSPI_SD2;

        curr &= ~(0b1u << 0u);
        curr |= (SLEWFAST & 0b1u) << 0u;
        curr &= ~(0b1u << 1u);
        curr |= (SCHMITT & 0b1u) << 1u;
        curr &= ~(0b1u << 2u);
        curr |= (PDE & 0b1u) << 2u;
        curr &= ~(0b1u << 3u);
        curr |= (PUE & 0b1u) << 3u;
        curr &= ~(0b11u << 4u);
        curr |= (std::to_underlying(DRIVE) & 0b11u) << 4u;
        curr &= ~(0b1u << 6u);
        curr |= (IE & 0b1u) << 6u;
        curr &= ~(0b1u << 7u);
        curr |= (OD & 0b1u) << 7u;

        GPIO_QSPI_SD2 = curr;
    }

    inline bool get_GPIO_QSPI_SD3_SLEWFAST() volatile
    {
        return GPIO_QSPI_SD3 & (1u << 0u);
    }

    inline void set_GPIO_QSPI_SD3_SLEWFAST() volatile
    {
        GPIO_QSPI_SD3 |= 1u << 0u;
    }

    inline void clear_GPIO_QSPI_SD3_SLEWFAST() volatile
    {
        GPIO_QSPI_SD3 &= ~(1u << 0u);
    }

    inline void toggle_GPIO_QSPI_SD3_SLEWFAST() volatile
    {
        GPIO_QSPI_SD3 ^= 1u << 0u;
    }

    inline bool get_GPIO_QSPI_SD3_SCHMITT() volatile
    {
        return GPIO_QSPI_SD3 & (1u << 1u);
    }

    inline void set_GPIO_QSPI_SD3_SCHMITT() volatile
    {
        GPIO_QSPI_SD3 |= 1u << 1u;
    }

    inline void clear_GPIO_QSPI_SD3_SCHMITT() volatile
    {
        GPIO_QSPI_SD3 &= ~(1u << 1u);
    }

    inline void toggle_GPIO_QSPI_SD3_SCHMITT() volatile
    {
        GPIO_QSPI_SD3 ^= 1u << 1u;
    }

    inline bool get_GPIO_QSPI_SD3_PDE() volatile
    {
        return GPIO_QSPI_SD3 & (1u << 2u);
    }

    inline void set_GPIO_QSPI_SD3_PDE() volatile
    {
        GPIO_QSPI_SD3 |= 1u << 2u;
    }

    inline void clear_GPIO_QSPI_SD3_PDE() volatile
    {
        GPIO_QSPI_SD3 &= ~(1u << 2u);
    }

    inline void toggle_GPIO_QSPI_SD3_PDE() volatile
    {
        GPIO_QSPI_SD3 ^= 1u << 2u;
    }

    inline bool get_GPIO_QSPI_SD3_PUE() volatile
    {
        return GPIO_QSPI_SD3 & (1u << 3u);
    }

    inline void set_GPIO_QSPI_SD3_PUE() volatile
    {
        GPIO_QSPI_SD3 |= 1u << 3u;
    }

    inline void clear_GPIO_QSPI_SD3_PUE() volatile
    {
        GPIO_QSPI_SD3 &= ~(1u << 3u);
    }

    inline void toggle_GPIO_QSPI_SD3_PUE() volatile
    {
        GPIO_QSPI_SD3 ^= 1u << 3u;
    }

    inline PADS_QSPI_GPIO_QSPI_SD3_DRIVE get_GPIO_QSPI_SD3_DRIVE() volatile
    {
        return PADS_QSPI_GPIO_QSPI_SD3_DRIVE((GPIO_QSPI_SD3 >> 4u) & 0b11u);
    }

    inline void set_GPIO_QSPI_SD3_DRIVE(
        PADS_QSPI_GPIO_QSPI_SD3_DRIVE value) volatile
    {
        uint32_t curr = GPIO_QSPI_SD3;

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

        GPIO_QSPI_SD3 = curr;
    }

    inline bool get_GPIO_QSPI_SD3_IE() volatile
    {
        return GPIO_QSPI_SD3 & (1u << 6u);
    }

    inline void set_GPIO_QSPI_SD3_IE() volatile
    {
        GPIO_QSPI_SD3 |= 1u << 6u;
    }

    inline void clear_GPIO_QSPI_SD3_IE() volatile
    {
        GPIO_QSPI_SD3 &= ~(1u << 6u);
    }

    inline void toggle_GPIO_QSPI_SD3_IE() volatile
    {
        GPIO_QSPI_SD3 ^= 1u << 6u;
    }

    inline bool get_GPIO_QSPI_SD3_OD() volatile
    {
        return GPIO_QSPI_SD3 & (1u << 7u);
    }

    inline void set_GPIO_QSPI_SD3_OD() volatile
    {
        GPIO_QSPI_SD3 |= 1u << 7u;
    }

    inline void clear_GPIO_QSPI_SD3_OD() volatile
    {
        GPIO_QSPI_SD3 &= ~(1u << 7u);
    }

    inline void toggle_GPIO_QSPI_SD3_OD() volatile
    {
        GPIO_QSPI_SD3 ^= 1u << 7u;
    }

    inline void get_GPIO_QSPI_SD3(bool &SLEWFAST, bool &SCHMITT, bool &PDE,
                                  bool &PUE,
                                  PADS_QSPI_GPIO_QSPI_SD3_DRIVE &DRIVE,
                                  bool &IE, bool &OD) volatile
    {
        uint32_t curr = GPIO_QSPI_SD3;

        SLEWFAST = curr & (1u << 0u);
        SCHMITT = curr & (1u << 1u);
        PDE = curr & (1u << 2u);
        PUE = curr & (1u << 3u);
        DRIVE = PADS_QSPI_GPIO_QSPI_SD3_DRIVE((curr >> 4u) & 0b11u);
        IE = curr & (1u << 6u);
        OD = curr & (1u << 7u);
    }

    inline void set_GPIO_QSPI_SD3(bool SLEWFAST, bool SCHMITT, bool PDE,
                                  bool PUE,
                                  PADS_QSPI_GPIO_QSPI_SD3_DRIVE DRIVE, bool IE,
                                  bool OD) volatile
    {
        uint32_t curr = GPIO_QSPI_SD3;

        curr &= ~(0b1u << 0u);
        curr |= (SLEWFAST & 0b1u) << 0u;
        curr &= ~(0b1u << 1u);
        curr |= (SCHMITT & 0b1u) << 1u;
        curr &= ~(0b1u << 2u);
        curr |= (PDE & 0b1u) << 2u;
        curr &= ~(0b1u << 3u);
        curr |= (PUE & 0b1u) << 3u;
        curr &= ~(0b11u << 4u);
        curr |= (std::to_underlying(DRIVE) & 0b11u) << 4u;
        curr &= ~(0b1u << 6u);
        curr |= (IE & 0b1u) << 6u;
        curr &= ~(0b1u << 7u);
        curr |= (OD & 0b1u) << 7u;

        GPIO_QSPI_SD3 = curr;
    }

    inline bool get_GPIO_QSPI_SS_SLEWFAST() volatile
    {
        return GPIO_QSPI_SS & (1u << 0u);
    }

    inline void set_GPIO_QSPI_SS_SLEWFAST() volatile
    {
        GPIO_QSPI_SS |= 1u << 0u;
    }

    inline void clear_GPIO_QSPI_SS_SLEWFAST() volatile
    {
        GPIO_QSPI_SS &= ~(1u << 0u);
    }

    inline void toggle_GPIO_QSPI_SS_SLEWFAST() volatile
    {
        GPIO_QSPI_SS ^= 1u << 0u;
    }

    inline bool get_GPIO_QSPI_SS_SCHMITT() volatile
    {
        return GPIO_QSPI_SS & (1u << 1u);
    }

    inline void set_GPIO_QSPI_SS_SCHMITT() volatile
    {
        GPIO_QSPI_SS |= 1u << 1u;
    }

    inline void clear_GPIO_QSPI_SS_SCHMITT() volatile
    {
        GPIO_QSPI_SS &= ~(1u << 1u);
    }

    inline void toggle_GPIO_QSPI_SS_SCHMITT() volatile
    {
        GPIO_QSPI_SS ^= 1u << 1u;
    }

    inline bool get_GPIO_QSPI_SS_PDE() volatile
    {
        return GPIO_QSPI_SS & (1u << 2u);
    }

    inline void set_GPIO_QSPI_SS_PDE() volatile
    {
        GPIO_QSPI_SS |= 1u << 2u;
    }

    inline void clear_GPIO_QSPI_SS_PDE() volatile
    {
        GPIO_QSPI_SS &= ~(1u << 2u);
    }

    inline void toggle_GPIO_QSPI_SS_PDE() volatile
    {
        GPIO_QSPI_SS ^= 1u << 2u;
    }

    inline bool get_GPIO_QSPI_SS_PUE() volatile
    {
        return GPIO_QSPI_SS & (1u << 3u);
    }

    inline void set_GPIO_QSPI_SS_PUE() volatile
    {
        GPIO_QSPI_SS |= 1u << 3u;
    }

    inline void clear_GPIO_QSPI_SS_PUE() volatile
    {
        GPIO_QSPI_SS &= ~(1u << 3u);
    }

    inline void toggle_GPIO_QSPI_SS_PUE() volatile
    {
        GPIO_QSPI_SS ^= 1u << 3u;
    }

    inline PADS_QSPI_GPIO_QSPI_SS_DRIVE get_GPIO_QSPI_SS_DRIVE() volatile
    {
        return PADS_QSPI_GPIO_QSPI_SS_DRIVE((GPIO_QSPI_SS >> 4u) & 0b11u);
    }

    inline void set_GPIO_QSPI_SS_DRIVE(
        PADS_QSPI_GPIO_QSPI_SS_DRIVE value) volatile
    {
        uint32_t curr = GPIO_QSPI_SS;

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

        GPIO_QSPI_SS = curr;
    }

    inline bool get_GPIO_QSPI_SS_IE() volatile
    {
        return GPIO_QSPI_SS & (1u << 6u);
    }

    inline void set_GPIO_QSPI_SS_IE() volatile
    {
        GPIO_QSPI_SS |= 1u << 6u;
    }

    inline void clear_GPIO_QSPI_SS_IE() volatile
    {
        GPIO_QSPI_SS &= ~(1u << 6u);
    }

    inline void toggle_GPIO_QSPI_SS_IE() volatile
    {
        GPIO_QSPI_SS ^= 1u << 6u;
    }

    inline bool get_GPIO_QSPI_SS_OD() volatile
    {
        return GPIO_QSPI_SS & (1u << 7u);
    }

    inline void set_GPIO_QSPI_SS_OD() volatile
    {
        GPIO_QSPI_SS |= 1u << 7u;
    }

    inline void clear_GPIO_QSPI_SS_OD() volatile
    {
        GPIO_QSPI_SS &= ~(1u << 7u);
    }

    inline void toggle_GPIO_QSPI_SS_OD() volatile
    {
        GPIO_QSPI_SS ^= 1u << 7u;
    }

    inline void get_GPIO_QSPI_SS(bool &SLEWFAST, bool &SCHMITT, bool &PDE,
                                 bool &PUE,
                                 PADS_QSPI_GPIO_QSPI_SS_DRIVE &DRIVE, bool &IE,
                                 bool &OD) volatile
    {
        uint32_t curr = GPIO_QSPI_SS;

        SLEWFAST = curr & (1u << 0u);
        SCHMITT = curr & (1u << 1u);
        PDE = curr & (1u << 2u);
        PUE = curr & (1u << 3u);
        DRIVE = PADS_QSPI_GPIO_QSPI_SS_DRIVE((curr >> 4u) & 0b11u);
        IE = curr & (1u << 6u);
        OD = curr & (1u << 7u);
    }

    inline void set_GPIO_QSPI_SS(bool SLEWFAST, bool SCHMITT, bool PDE,
                                 bool PUE, PADS_QSPI_GPIO_QSPI_SS_DRIVE DRIVE,
                                 bool IE, bool OD) volatile
    {
        uint32_t curr = GPIO_QSPI_SS;

        curr &= ~(0b1u << 0u);
        curr |= (SLEWFAST & 0b1u) << 0u;
        curr &= ~(0b1u << 1u);
        curr |= (SCHMITT & 0b1u) << 1u;
        curr &= ~(0b1u << 2u);
        curr |= (PDE & 0b1u) << 2u;
        curr &= ~(0b1u << 3u);
        curr |= (PUE & 0b1u) << 3u;
        curr &= ~(0b11u << 4u);
        curr |= (std::to_underlying(DRIVE) & 0b11u) << 4u;
        curr &= ~(0b1u << 6u);
        curr |= (IE & 0b1u) << 6u;
        curr &= ~(0b1u << 7u);
        curr |= (OD & 0b1u) << 7u;

        GPIO_QSPI_SS = curr;
    }
};

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

static volatile pads_qspi *const PADS_QSPI =
    reinterpret_cast<pads_qspi *>(0x40020000);

}; // namespace RP2040