Program Listing for File timer.h

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

#pragma once

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

namespace RP2040
{

struct [[gnu::packed]] timer
{
    /* Constant attributes. */
    static constexpr std::size_t size = 68;
    /* Fields. */
    uint32_t TIMEHW;
    uint32_t TIMELW;
    uint32_t TIMEHR;
    uint32_t TIMELR;
    uint32_t
        ALARM0;
    uint32_t
        ALARM1;
    uint32_t
        ALARM2;
    uint32_t
        ALARM3;
    uint32_t ARMED;
    uint32_t TIMERAWH;
    uint32_t TIMERAWL;
    uint32_t DBGPAUSE;
    uint32_t PAUSE;
    uint32_t INTR;
    uint32_t INTE;
    uint32_t INTF;
    const uint32_t INTS =
        {};
    /* Methods. */

    inline uint8_t get_ARMED_ARMED() volatile
    {
        return (ARMED >> 0u) & 0b1111u;
    }

    inline void set_ARMED_ARMED(uint8_t value) volatile
    {
        uint32_t curr = ARMED;

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

        ARMED = curr;
    }

    inline bool get_DBGPAUSE_DBG0() volatile
    {
        return DBGPAUSE & (1u << 1u);
    }

    inline void set_DBGPAUSE_DBG0() volatile
    {
        DBGPAUSE |= 1u << 1u;
    }

    inline void clear_DBGPAUSE_DBG0() volatile
    {
        DBGPAUSE &= ~(1u << 1u);
    }

    inline void toggle_DBGPAUSE_DBG0() volatile
    {
        DBGPAUSE ^= 1u << 1u;
    }

    inline bool get_DBGPAUSE_DBG1() volatile
    {
        return DBGPAUSE & (1u << 2u);
    }

    inline void set_DBGPAUSE_DBG1() volatile
    {
        DBGPAUSE |= 1u << 2u;
    }

    inline void clear_DBGPAUSE_DBG1() volatile
    {
        DBGPAUSE &= ~(1u << 2u);
    }

    inline void toggle_DBGPAUSE_DBG1() volatile
    {
        DBGPAUSE ^= 1u << 2u;
    }

    inline void get_DBGPAUSE(bool &DBG0, bool &DBG1) volatile
    {
        uint32_t curr = DBGPAUSE;

        DBG0 = curr & (1u << 1u);
        DBG1 = curr & (1u << 2u);
    }

    inline void set_DBGPAUSE(bool DBG0, bool DBG1) volatile
    {
        uint32_t curr = DBGPAUSE;

        curr &= ~(0b1u << 1u);
        curr |= (DBG0 & 0b1u) << 1u;
        curr &= ~(0b1u << 2u);
        curr |= (DBG1 & 0b1u) << 2u;

        DBGPAUSE = curr;
    }

    inline bool get_PAUSE_PAUSE() volatile
    {
        return PAUSE & (1u << 0u);
    }

    inline void set_PAUSE_PAUSE() volatile
    {
        PAUSE |= 1u << 0u;
    }

    inline void clear_PAUSE_PAUSE() volatile
    {
        PAUSE &= ~(1u << 0u);
    }

    inline void toggle_PAUSE_PAUSE() volatile
    {
        PAUSE ^= 1u << 0u;
    }

    inline bool get_INTR_ALARM_0() volatile
    {
        return INTR & (1u << 0u);
    }

    inline void set_INTR_ALARM_0() volatile
    {
        INTR |= 1u << 0u;
    }

    inline void clear_INTR_ALARM_0() volatile
    {
        INTR &= ~(1u << 0u);
    }

    inline void toggle_INTR_ALARM_0() volatile
    {
        INTR ^= 1u << 0u;
    }

    inline bool get_INTR_ALARM_1() volatile
    {
        return INTR & (1u << 1u);
    }

    inline void set_INTR_ALARM_1() volatile
    {
        INTR |= 1u << 1u;
    }

    inline void clear_INTR_ALARM_1() volatile
    {
        INTR &= ~(1u << 1u);
    }

    inline void toggle_INTR_ALARM_1() volatile
    {
        INTR ^= 1u << 1u;
    }

    inline bool get_INTR_ALARM_2() volatile
    {
        return INTR & (1u << 2u);
    }

    inline void set_INTR_ALARM_2() volatile
    {
        INTR |= 1u << 2u;
    }

    inline void clear_INTR_ALARM_2() volatile
    {
        INTR &= ~(1u << 2u);
    }

    inline void toggle_INTR_ALARM_2() volatile
    {
        INTR ^= 1u << 2u;
    }

    inline bool get_INTR_ALARM_3() volatile
    {
        return INTR & (1u << 3u);
    }

    inline void set_INTR_ALARM_3() volatile
    {
        INTR |= 1u << 3u;
    }

    inline void clear_INTR_ALARM_3() volatile
    {
        INTR &= ~(1u << 3u);
    }

    inline void toggle_INTR_ALARM_3() volatile
    {
        INTR ^= 1u << 3u;
    }

    inline void get_INTR(bool &ALARM_0, bool &ALARM_1, bool &ALARM_2,
                         bool &ALARM_3) volatile
    {
        uint32_t curr = INTR;

        ALARM_0 = curr & (1u << 0u);
        ALARM_1 = curr & (1u << 1u);
        ALARM_2 = curr & (1u << 2u);
        ALARM_3 = curr & (1u << 3u);
    }

    inline void set_INTR(bool ALARM_0, bool ALARM_1, bool ALARM_2,
                         bool ALARM_3) volatile
    {
        uint32_t curr = INTR;

        curr &= ~(0b1u << 0u);
        curr |= (ALARM_0 & 0b1u) << 0u;
        curr &= ~(0b1u << 1u);
        curr |= (ALARM_1 & 0b1u) << 1u;
        curr &= ~(0b1u << 2u);
        curr |= (ALARM_2 & 0b1u) << 2u;
        curr &= ~(0b1u << 3u);
        curr |= (ALARM_3 & 0b1u) << 3u;

        INTR = curr;
    }

    inline bool get_INTE_ALARM_0() volatile
    {
        return INTE & (1u << 0u);
    }

    inline void set_INTE_ALARM_0() volatile
    {
        INTE |= 1u << 0u;
    }

    inline void clear_INTE_ALARM_0() volatile
    {
        INTE &= ~(1u << 0u);
    }

    inline void toggle_INTE_ALARM_0() volatile
    {
        INTE ^= 1u << 0u;
    }

    inline bool get_INTE_ALARM_1() volatile
    {
        return INTE & (1u << 1u);
    }

    inline void set_INTE_ALARM_1() volatile
    {
        INTE |= 1u << 1u;
    }

    inline void clear_INTE_ALARM_1() volatile
    {
        INTE &= ~(1u << 1u);
    }

    inline void toggle_INTE_ALARM_1() volatile
    {
        INTE ^= 1u << 1u;
    }

    inline bool get_INTE_ALARM_2() volatile
    {
        return INTE & (1u << 2u);
    }

    inline void set_INTE_ALARM_2() volatile
    {
        INTE |= 1u << 2u;
    }

    inline void clear_INTE_ALARM_2() volatile
    {
        INTE &= ~(1u << 2u);
    }

    inline void toggle_INTE_ALARM_2() volatile
    {
        INTE ^= 1u << 2u;
    }

    inline bool get_INTE_ALARM_3() volatile
    {
        return INTE & (1u << 3u);
    }

    inline void set_INTE_ALARM_3() volatile
    {
        INTE |= 1u << 3u;
    }

    inline void clear_INTE_ALARM_3() volatile
    {
        INTE &= ~(1u << 3u);
    }

    inline void toggle_INTE_ALARM_3() volatile
    {
        INTE ^= 1u << 3u;
    }

    inline void get_INTE(bool &ALARM_0, bool &ALARM_1, bool &ALARM_2,
                         bool &ALARM_3) volatile
    {
        uint32_t curr = INTE;

        ALARM_0 = curr & (1u << 0u);
        ALARM_1 = curr & (1u << 1u);
        ALARM_2 = curr & (1u << 2u);
        ALARM_3 = curr & (1u << 3u);
    }

    inline void set_INTE(bool ALARM_0, bool ALARM_1, bool ALARM_2,
                         bool ALARM_3) volatile
    {
        uint32_t curr = INTE;

        curr &= ~(0b1u << 0u);
        curr |= (ALARM_0 & 0b1u) << 0u;
        curr &= ~(0b1u << 1u);
        curr |= (ALARM_1 & 0b1u) << 1u;
        curr &= ~(0b1u << 2u);
        curr |= (ALARM_2 & 0b1u) << 2u;
        curr &= ~(0b1u << 3u);
        curr |= (ALARM_3 & 0b1u) << 3u;

        INTE = curr;
    }

    inline bool get_INTF_ALARM_0() volatile
    {
        return INTF & (1u << 0u);
    }

    inline void set_INTF_ALARM_0() volatile
    {
        INTF |= 1u << 0u;
    }

    inline void clear_INTF_ALARM_0() volatile
    {
        INTF &= ~(1u << 0u);
    }

    inline void toggle_INTF_ALARM_0() volatile
    {
        INTF ^= 1u << 0u;
    }

    inline bool get_INTF_ALARM_1() volatile
    {
        return INTF & (1u << 1u);
    }

    inline void set_INTF_ALARM_1() volatile
    {
        INTF |= 1u << 1u;
    }

    inline void clear_INTF_ALARM_1() volatile
    {
        INTF &= ~(1u << 1u);
    }

    inline void toggle_INTF_ALARM_1() volatile
    {
        INTF ^= 1u << 1u;
    }

    inline bool get_INTF_ALARM_2() volatile
    {
        return INTF & (1u << 2u);
    }

    inline void set_INTF_ALARM_2() volatile
    {
        INTF |= 1u << 2u;
    }

    inline void clear_INTF_ALARM_2() volatile
    {
        INTF &= ~(1u << 2u);
    }

    inline void toggle_INTF_ALARM_2() volatile
    {
        INTF ^= 1u << 2u;
    }

    inline bool get_INTF_ALARM_3() volatile
    {
        return INTF & (1u << 3u);
    }

    inline void set_INTF_ALARM_3() volatile
    {
        INTF |= 1u << 3u;
    }

    inline void clear_INTF_ALARM_3() volatile
    {
        INTF &= ~(1u << 3u);
    }

    inline void toggle_INTF_ALARM_3() volatile
    {
        INTF ^= 1u << 3u;
    }

    inline void get_INTF(bool &ALARM_0, bool &ALARM_1, bool &ALARM_2,
                         bool &ALARM_3) volatile
    {
        uint32_t curr = INTF;

        ALARM_0 = curr & (1u << 0u);
        ALARM_1 = curr & (1u << 1u);
        ALARM_2 = curr & (1u << 2u);
        ALARM_3 = curr & (1u << 3u);
    }

    inline void set_INTF(bool ALARM_0, bool ALARM_1, bool ALARM_2,
                         bool ALARM_3) volatile
    {
        uint32_t curr = INTF;

        curr &= ~(0b1u << 0u);
        curr |= (ALARM_0 & 0b1u) << 0u;
        curr &= ~(0b1u << 1u);
        curr |= (ALARM_1 & 0b1u) << 1u;
        curr &= ~(0b1u << 2u);
        curr |= (ALARM_2 & 0b1u) << 2u;
        curr &= ~(0b1u << 3u);
        curr |= (ALARM_3 & 0b1u) << 3u;

        INTF = curr;
    }

    inline bool get_INTS_ALARM_0() volatile
    {
        return INTS & (1u << 0u);
    }

    inline bool get_INTS_ALARM_1() volatile
    {
        return INTS & (1u << 1u);
    }

    inline bool get_INTS_ALARM_2() volatile
    {
        return INTS & (1u << 2u);
    }

    inline bool get_INTS_ALARM_3() volatile
    {
        return INTS & (1u << 3u);
    }

    inline void get_INTS(bool &ALARM_0, bool &ALARM_1, bool &ALARM_2,
                         bool &ALARM_3) volatile
    {
        uint32_t curr = INTS;

        ALARM_0 = curr & (1u << 0u);
        ALARM_1 = curr & (1u << 1u);
        ALARM_2 = curr & (1u << 2u);
        ALARM_3 = curr & (1u << 3u);
    }
};

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

static volatile timer *const TIMER = reinterpret_cast<timer *>(0x40054000);

}; // namespace RP2040