Program Listing for File watchdog.h

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

#pragma once

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

namespace RP2040
{

struct [[gnu::packed]] watchdog
{
    /* Constant attributes. */
    static constexpr std::size_t size = 48;
    /* Fields. */
    uint32_t CTRL;
    uint32_t
        LOAD;
    const uint32_t REASON =
        {};
    uint32_t SCRATCH0;
    uint32_t SCRATCH1;
    uint32_t SCRATCH2;
    uint32_t SCRATCH3;
    uint32_t SCRATCH4;
    uint32_t SCRATCH5;
    uint32_t SCRATCH6;
    uint32_t SCRATCH7;
    uint32_t TICK;
    /* Methods. */

    inline uint32_t get_CTRL_TIME() volatile
    {
        return (CTRL >> 0u) & 0b111111111111111111111111u;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    inline void get_CTRL(uint32_t &TIME, bool &PAUSE_JTAG, bool &PAUSE_DBG0,
                         bool &PAUSE_DBG1, bool &ENABLE,
                         bool &TRIGGER) volatile
    {
        uint32_t curr = CTRL;

        TIME = (curr >> 0u) & 0b111111111111111111111111u;
        PAUSE_JTAG = curr & (1u << 24u);
        PAUSE_DBG0 = curr & (1u << 25u);
        PAUSE_DBG1 = curr & (1u << 26u);
        ENABLE = curr & (1u << 30u);
        TRIGGER = curr & (1u << 31u);
    }

    inline void set_CTRL(bool PAUSE_JTAG, bool PAUSE_DBG0, bool PAUSE_DBG1,
                         bool ENABLE, bool TRIGGER) volatile
    {
        uint32_t curr = CTRL;

        curr &= ~(0b1u << 24u);
        curr |= (PAUSE_JTAG & 0b1u) << 24u;
        curr &= ~(0b1u << 25u);
        curr |= (PAUSE_DBG0 & 0b1u) << 25u;
        curr &= ~(0b1u << 26u);
        curr |= (PAUSE_DBG1 & 0b1u) << 26u;
        curr &= ~(0b1u << 30u);
        curr |= (ENABLE & 0b1u) << 30u;
        curr &= ~(0b1u << 31u);
        curr |= (TRIGGER & 0b1u) << 31u;

        CTRL = curr;
    }

    inline void set_LOAD_LOAD(uint32_t value) volatile
    {
        uint32_t curr = LOAD;

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

        LOAD = curr;
    }

    inline bool get_REASON_TIMER() volatile
    {
        return REASON & (1u << 0u);
    }

    inline bool get_REASON_FORCE() volatile
    {
        return REASON & (1u << 1u);
    }

    inline void get_REASON(bool &TIMER, bool &FORCE) volatile
    {
        uint32_t curr = REASON;

        TIMER = curr & (1u << 0u);
        FORCE = curr & (1u << 1u);
    }

    inline uint16_t get_TICK_CYCLES() volatile
    {
        return (TICK >> 0u) & 0b111111111u;
    }

    inline void set_TICK_CYCLES(uint16_t value) volatile
    {
        uint32_t curr = TICK;

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

        TICK = curr;
    }

    inline bool get_TICK_ENABLE() volatile
    {
        return TICK & (1u << 9u);
    }

    inline void set_TICK_ENABLE() volatile
    {
        TICK |= 1u << 9u;
    }

    inline void clear_TICK_ENABLE() volatile
    {
        TICK &= ~(1u << 9u);
    }

    inline void toggle_TICK_ENABLE() volatile
    {
        TICK ^= 1u << 9u;
    }

    inline bool get_TICK_RUNNING() volatile
    {
        return TICK & (1u << 10u);
    }

    inline uint16_t get_TICK_COUNT() volatile
    {
        return (TICK >> 11u) & 0b111111111u;
    }

    inline void get_TICK(uint16_t &CYCLES, bool &ENABLE, bool &RUNNING,
                         uint16_t &COUNT) volatile
    {
        uint32_t curr = TICK;

        CYCLES = (curr >> 0u) & 0b111111111u;
        ENABLE = curr & (1u << 9u);
        RUNNING = curr & (1u << 10u);
        COUNT = (curr >> 11u) & 0b111111111u;
    }

    inline void set_TICK(uint16_t CYCLES, bool ENABLE) volatile
    {
        uint32_t curr = TICK;

        curr &= ~(0b111111111u << 0u);
        curr |= (CYCLES & 0b111111111u) << 0u;
        curr &= ~(0b1u << 9u);
        curr |= (ENABLE & 0b1u) << 9u;

        TICK = curr;
    }
};

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

static volatile watchdog *const WATCHDOG =
    reinterpret_cast<watchdog *>(0x40058000);

}; // namespace RP2040