ra8_wdt.h

Go to the documentation of this file.

 
#pragma once
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdint.h>
 
#include "ra8_err.h"
#include "ra8_wdt_regs.h"

typedef enum : uint8_t {
  k_ra8_wdt_clkdiv_4    = 0x1U, 
  k_ra8_wdt_clkdiv_64   = 0x4U, 
  k_ra8_wdt_clkdiv_128  = 0xFU, 
  k_ra8_wdt_clkdiv_512  = 0x6U, 
  k_ra8_wdt_clkdiv_2048 = 0x7U, 
  k_ra8_wdt_clkdiv_8192 = 0x8U, 
} ra8_wdt_clock_div_t;

typedef enum : uint8_t {
  k_ra8_wdt_timeout_1024  = 0x0U, 
  k_ra8_wdt_timeout_4096  = 0x1U, 
  k_ra8_wdt_timeout_8192  = 0x2U, 
  k_ra8_wdt_timeout_16384 = 0x3U, 
} ra8_wdt_timeout_sel_t;

typedef enum : uint8_t {
  k_ra8_wdt_window_start_25  = 0x0U, 
  k_ra8_wdt_window_start_50  = 0x1U, 
  k_ra8_wdt_window_start_75  = 0x2U, 
  k_ra8_wdt_window_start_100 = 0x3U, 
} ra8_wdt_window_start_t;

typedef enum : uint8_t {
  k_ra8_wdt_window_end_75 = 0x0U, 
  k_ra8_wdt_window_end_50 = 0x1U, 
  k_ra8_wdt_window_end_25 = 0x2U, 
  k_ra8_wdt_window_end_0  = 0x3U, 
} ra8_wdt_window_end_t;

typedef enum : uint8_t {
  k_ra8_wdt_on_expiry_nmi   = 0U, 
  k_ra8_wdt_on_expiry_reset = 1U, 
} ra8_wdt_reset_ctrl_t;

typedef enum : uint8_t {
  k_ra8_wdt_sleep_keep_count = 0U, 
  k_ra8_wdt_sleep_stop_count = 1U, 
} ra8_wdt_stop_ctrl_t;

typedef enum : uint8_t {
  k_ra8_wdt_ofs_strt_auto     = 0U, 
  k_ra8_wdt_ofs_strt_register = 1U, 
} ra8_wdt_ofs_strt_t;

typedef enum : uint16_t {
  k_ra8_wdt_status_none      = 0x0000U,            
  k_ra8_wdt_status_underflow = k_ra8_wdt_sr_undff, 
  k_ra8_wdt_status_refresh   = k_ra8_wdt_sr_refef, 
} ra8_wdt_status_mask_t;

typedef enum : uint8_t {
  k_ra8_wdt_max_subs = 6U, 
} ra8_wdt_subs_count_t;

typedef enum : uint32_t {
  k_ra8_wdt_clear_max_polls = 0x4000UL, 
} ra8_wdt_clear_timeout_t;

typedef struct {
  ra8_wdt_timeout_sel_t  timeout;       
  ra8_wdt_clock_div_t    clock_div;     
  ra8_wdt_window_start_t window_start;  
  ra8_wdt_window_end_t   window_end;    
  ra8_wdt_reset_ctrl_t   on_expiry;     
  ra8_wdt_stop_ctrl_t    stop_in_sleep; 
} ra8_wdt_cfg_t;

typedef struct {
  ra8_wdt_cfg_t      cfg;        
  ra8_wdt_ofs_strt_t start_mode; 
  bool               auto_start; 
} ra8_wdt_ofs_decoded_t;

typedef void (*ra8_wdt_event_fn_t)(void* ctx, uint16_t status_mask);
 
/* =============================================================================
 * Lifecycle
 * =============================================================================
 */

[[nodiscard]] ra8_err_t ra8_wdt_init(const ra8_wdt_cfg_t* cfg);

[[nodiscard]] ra8_err_t ra8_wdt_deinit(void);
 
/* =============================================================================
 * Refresh
 * =============================================================================
 */

void ra8_wdt_refresh_deferred(void);

[[nodiscard]] ra8_err_t ra8_wdt_refresh_for(ra8_wdt_instance_t which);
 
/* =============================================================================
 * Status read / clear / counter
 * =============================================================================
 */

[[nodiscard]] ra8_err_t ra8_wdt_get_status(uint16_t* out_mask);

[[nodiscard]] ra8_err_t ra8_wdt_clear_status(void);

[[nodiscard]] ra8_err_t ra8_wdt_clear_status_blocking(uint16_t mask);

[[nodiscard]] ra8_err_t ra8_wdt_get_counter(uint16_t* out_count);
 
/* =============================================================================
 * Timeout decoding (FSP timeoutGet analogue)
 * =============================================================================
 */

[[nodiscard]] ra8_err_t ra8_wdt_timeout_cycles_get(ra8_wdt_timeout_sel_t sel, uint16_t* out_cycles);

[[nodiscard]] ra8_err_t ra8_wdt_pclkb_divisor(ra8_wdt_clock_div_t div, uint16_t* out_divisor);

[[nodiscard]] ra8_err_t ra8_wdt_total_pclkb_cycles(ra8_wdt_timeout_sel_t sel,
                                                   ra8_wdt_clock_div_t   div,
                                                   uint32_t*             out_pclkb_cycles);
 
/* =============================================================================
 * Single-callback API (kept for backward compatibility with the existing
 * ICU shim and the original tests; new code should use subscribe / unsubscribe)
 * =============================================================================
 */

[[nodiscard]] ra8_err_t ra8_wdt_attach_handler(ra8_wdt_event_fn_t fn, void* ctx);
 
/* =============================================================================
 * Multi-subscriber API (.x) -- hot-pluggable underflow listeners
 * =============================================================================
 */

[[nodiscard]] ra8_err_t ra8_wdt_subscribe(ra8_wdt_event_fn_t fn, void* ctx, uint8_t* out_slot);

[[nodiscard]] ra8_err_t ra8_wdt_unsubscribe(uint8_t slot);

uint8_t ra8_wdt_subscriber_count(void);

void ra8_wdt_dispatch(void);
 
/* =============================================================================
 * NMI vector wiring (HUM Ch 14.2.14 p 542)
 * =============================================================================
 */

[[nodiscard]] ra8_err_t ra8_wdt_install_nmi(void);

[[nodiscard]] ra8_err_t ra8_wdt_uninstall_nmi(void);
 
/* =============================================================================
 * Sleep-mode stop control
 * =============================================================================
 */

[[nodiscard]] ra8_err_t ra8_wdt_enter_stop(void);

[[nodiscard]] ra8_err_t ra8_wdt_exit_stop(void);
 
/* =============================================================================
 * OFS0 / OFS3 read-only decode (HUM Ch 27.2.6 p 1263, Table 27.5 p 1269)
 * =============================================================================
 */

typedef ra8_err_t (*ra8_wdt_ofs_reader_fn_t)(uintptr_t ofs_addr, uint32_t* out_word);

[[nodiscard]] ra8_err_t ra8_wdt_ofs_reader_set(ra8_wdt_ofs_reader_fn_t reader);

[[nodiscard]] ra8_err_t ra8_wdt_ofs_get(ra8_wdt_instance_t which, ra8_wdt_ofs_decoded_t* out);
 
#ifdef __cplusplus
}
#endif