ra8_system_regs.h

Go to the documentation of this file.

 
#pragma once
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdint.h>
 
/* =============================================================================
 * Base addresses
 * =============================================================================
 */
 
typedef enum : uintptr_t {
  k_ra8_system_base_addr = 0x4001E000UL, 
} ra8_system_addr_t;
 
/* =============================================================================
 * Register offsets (within the SYSTEM block)
 * =============================================================================
 */
 
typedef enum : uint16_t {
  k_ra8_sys_off_vscr         = 0x014U, 
  k_ra8_sys_off_sckdivcr     = 0x020U, 
  k_ra8_sys_off_sckdivcr2    = 0x024U, 
  k_ra8_sys_off_sckscr       = 0x026U, 
  k_ra8_sys_off_pllcr        = 0x02AU, 
  k_ra8_sys_off_moscr        = 0x032U, 
  k_ra8_sys_off_hococr       = 0x036U, 
  k_ra8_sys_off_oscsf        = 0x03CU, 
  k_ra8_sys_off_pll2cr       = 0x04AU, 
  k_ra8_sys_off_pllccr2      = 0x04CU, 
  k_ra8_sys_off_pll2ccr2     = 0x04EU, 
  k_ra8_sys_off_scickdivcr   = 0x054U, 
  k_ra8_sys_off_scickcr      = 0x055U, 
  k_ra8_sys_off_eswckdivcr   = 0x0D5U, 
  k_ra8_sys_off_eswpckdivcr  = 0x0D6U, 
  k_ra8_sys_off_eswckcr      = 0x0DBU, 
  k_ra8_sys_off_eswpckcr     = 0x0DCU, 
  k_ra8_sys_off_usbckdivcr   = 0x06CU, 
  k_ra8_sys_off_octackdivcr  = 0x06DU, 
  k_ra8_sys_off_canfdckdivcr = 0x06EU, 
  k_ra8_sys_off_usb60ckdivcr = 0x06FU, 
  k_ra8_sys_off_usbckcr      = 0x074U, 
  k_ra8_sys_off_octackcr     = 0x075U, 
  k_ra8_sys_off_canfdckcr    = 0x076U, 
  k_ra8_sys_off_usb60ckcr    = 0x077U, 
  k_ra8_sys_off_moscwtcr     = 0x0A2U, 
  k_ra8_sys_off_pdctreswm    = 0x118U, 
  k_ra8_sys_off_pllccr       = 0x0ACU, 
  k_ra8_sys_off_rstsr1       = 0x0C0U, 
  k_ra8_sys_off_pll2ccr      = 0x0C8U, 
  k_ra8_sys_off_prcr         = 0x3FAU, 
  k_ra8_sys_off_rstsr0       = 0xA40U, 
  k_ra8_sys_off_rstsr2       = 0xA44U, 
  k_ra8_sys_off_lococr       = 0x400U, 
  k_ra8_sys_off_sosccr       = 0xC00U, 
  k_ra8_sys_off_somcr        = 0xC01U, 
} ra8_system_offset_t;

typedef enum : uint32_t {
  k_ra8_vscr_bit_vscm    = (1UL << 0U), 
  k_ra8_vscr_bit_vscmtsf = (1UL << 4U), 
} ra8_vscr_bit_t;

typedef enum : uint8_t {
  k_ra8_moscr_mostp_mask = (1U << 0U), 
} ra8_moscr_bit_t;

typedef enum : uint8_t {
  k_ra8_sosccr_sostp_mask = (1U << 0U), 
} ra8_sosccr_bit_t;

typedef enum : uint8_t {
  k_ra8_somcr_drv_standard = 0x0U, 
  k_ra8_somcr_drv_lp1      = 0x1U, 
  k_ra8_somcr_drv_lp2      = 0x2U, 
  k_ra8_somcr_drv_lp3      = 0x3U, 
} ra8_somcr_drv_t;

typedef enum : uint8_t {
  k_ra8_lococr_lcstp_mask = (1U << 0U), 
} ra8_lococr_bit_t;

typedef enum : uint8_t {
  k_ra8_oscsf_bit_hocosf = 0U, 
  k_ra8_oscsf_bit_moscsf = 3U, 
  k_ra8_oscsf_bit_pll1sf = 5U, 
  k_ra8_oscsf_bit_pll2sf = 6U, 
} ra8_oscsf_bit_t;
 
/* =============================================================================
 * PRCR protection key and group masks
 * =============================================================================
 */

typedef enum : uint16_t {
  k_ra8_prcr_key      = 0xA500U, 
  k_ra8_prcr_grp0_cgc = 0x0001U, 
  k_ra8_prcr_grp1_lpm = 0x0002U, 
  k_ra8_prcr_grp3_pvd = 0x0008U, 
  k_ra8_prcr_grp4_sar = 0x0010U, 
  k_ra8_prcr_grp5_rst = 0x0020U, 
  k_ra8_prcr_unlock_cgc =
    (uint16_t)(k_ra8_prcr_key | k_ra8_prcr_grp0_cgc), 
  k_ra8_prcr_unlock_lpm =
    (uint16_t)(k_ra8_prcr_key | k_ra8_prcr_grp1_lpm), 
  k_ra8_prcr_unlock_pvd =
    (uint16_t)(k_ra8_prcr_key | k_ra8_prcr_grp3_pvd), 
  k_ra8_prcr_unlock_sar =
    (uint16_t)(k_ra8_prcr_key | k_ra8_prcr_grp4_sar), 
  k_ra8_prcr_unlock_rst =
    (uint16_t)(k_ra8_prcr_key | k_ra8_prcr_grp5_rst), 
  k_ra8_prcr_lock_all = k_ra8_prcr_key,               
} ra8_prcr_t;
 
/* =============================================================================
 * Reset-cause bits (subset -- add as needed)
 * =============================================================================
 */

typedef enum : uint8_t {
  k_ra8_rstsr0_bit_porf = 0U, 
  k_ra8_rstsr0_bit_lvd0 = 1U, 
  k_ra8_rstsr0_bit_lvd1 = 2U, 
  k_ra8_rstsr0_bit_lvd2 = 3U, 
} ra8_rstsr0_bit_t;

typedef enum : uint8_t {
  k_ra8_rstsr2_bit_cwsf   = 0U, 
  k_ra8_rstsr2_bit_iwdtrf = 1U, 
  k_ra8_rstsr2_bit_wdtrf  = 2U, 
  k_ra8_rstsr2_bit_swrf   = 3U, 
} ra8_rstsr2_bit_t;
 
/* =============================================================================
 * Direct register accessors
 * =============================================================================
 *
 * Rather than define a single bloated R_SYSTEM struct (3456 bytes of
 * bitfields), we expose a tiny set of typed accessors that each return
 * a pointer to one register. The caller reads / writes whole 8/16/32-bit
 * values and masks bits using the named constants above. This is
 * exactly how the rx72n project handled its SYSTEM block and keeps the
 * header under 200 lines.
 */

static inline volatile uint32_t* ra8_sys_vscr(void)
{
  return (volatile uint32_t*)((uintptr_t)k_ra8_system_base_addr + (uintptr_t)k_ra8_sys_off_vscr);
}

static inline volatile uint32_t* ra8_sys_sckdivcr(void)
{
  return (volatile uint32_t*)((uintptr_t)k_ra8_system_base_addr +
                              (uintptr_t)k_ra8_sys_off_sckdivcr);
}

static inline volatile uint8_t* ra8_sys_scickdivcr(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr +
                             (uintptr_t)k_ra8_sys_off_scickdivcr);
}

static inline volatile uint8_t* ra8_sys_scickcr(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr + (uintptr_t)k_ra8_sys_off_scickcr);
}

static inline volatile uint8_t* ra8_sys_sckscr(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr + (uintptr_t)k_ra8_sys_off_sckscr);
}

static inline volatile uint8_t* ra8_sys_hococr(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr + (uintptr_t)k_ra8_sys_off_hococr);
}

static inline volatile uint8_t* ra8_sys_sosccr(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr + (uintptr_t)k_ra8_sys_off_sosccr);
}

static inline volatile uint8_t* ra8_sys_somcr(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr + (uintptr_t)k_ra8_sys_off_somcr);
}

static inline volatile uint8_t* ra8_sys_lococr(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr + (uintptr_t)k_ra8_sys_off_lococr);
}

static inline volatile uint8_t* ra8_sys_moscwtcr(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr + (uintptr_t)k_ra8_sys_off_moscwtcr);
}

static inline volatile uint32_t* ra8_sys_pllccr(void)
{
  return (volatile uint32_t*)((uintptr_t)k_ra8_system_base_addr + (uintptr_t)k_ra8_sys_off_pllccr);
}

static inline volatile uint16_t* ra8_sys_pllccr2(void)
{
  return (volatile uint16_t*)((uintptr_t)k_ra8_system_base_addr + (uintptr_t)k_ra8_sys_off_pllccr2);
}

static inline volatile uint32_t* ra8_sys_pll2ccr(void)
{
  return (volatile uint32_t*)((uintptr_t)k_ra8_system_base_addr + (uintptr_t)k_ra8_sys_off_pll2ccr);
}

static inline volatile uint8_t* ra8_sys_pll2cr(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr + (uintptr_t)k_ra8_sys_off_pll2cr);
}

static inline volatile uint16_t* ra8_sys_pll2ccr2(void)
{
  return (volatile uint16_t*)((uintptr_t)k_ra8_system_base_addr +
                              (uintptr_t)k_ra8_sys_off_pll2ccr2);
}

static inline volatile uint8_t* ra8_sys_oscsf(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr + (uintptr_t)k_ra8_sys_off_oscsf);
}

static inline volatile uint8_t* ra8_sys_pllcr(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr + (uintptr_t)k_ra8_sys_off_pllcr);
}

static inline volatile uint16_t* ra8_sys_sckdivcr2(void)
{
  return (volatile uint16_t*)((uintptr_t)k_ra8_system_base_addr +
                              (uintptr_t)k_ra8_sys_off_sckdivcr2);
}

static inline volatile uint32_t* ra8_sys_rstsr1(void)
{
  return (volatile uint32_t*)((uintptr_t)k_ra8_system_base_addr + (uintptr_t)k_ra8_sys_off_rstsr1);
}

static inline volatile uint16_t* ra8_sys_prcr(void)
{
  return (volatile uint16_t*)((uintptr_t)k_ra8_system_base_addr + (uintptr_t)k_ra8_sys_off_prcr);
}

static inline volatile uint8_t* ra8_sys_rstsr0(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr + (uintptr_t)k_ra8_sys_off_rstsr0);
}

static inline volatile uint8_t* ra8_sys_rstsr2(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr + (uintptr_t)k_ra8_sys_off_rstsr2);
}

typedef enum : uint8_t {
  k_ra8_usbckcr_shift_sel = 0U,    
  k_ra8_usbckcr_mask_sel  = 0x0FU, 
  k_ra8_usbckcr_bit_sreq  = 6U,    
  k_ra8_usbckcr_bit_srdy  = 7U,    
} ra8_usbckcr_bit_t;

typedef enum : uint8_t {
  k_ra8_usbcksel_hoco  = 0U,  
  k_ra8_usbcksel_main  = 3U,  
  k_ra8_usbcksel_pll1p = 5U,  
  k_ra8_usbcksel_pll2p = 6U,  
  k_ra8_usbcksel_pll1q = 7U,  
  k_ra8_usbcksel_pll1r = 8U,  
  k_ra8_usbcksel_pll2q = 9U,  
  k_ra8_usbcksel_pll2r = 10U, 
} ra8_usbcksel_t;

static inline volatile uint8_t* ra8_sys_usbckdivcr(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr +
                             (uintptr_t)k_ra8_sys_off_usbckdivcr);
}

static inline volatile uint8_t* ra8_sys_usbckcr(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr + (uintptr_t)k_ra8_sys_off_usbckcr);
}

static inline volatile uint8_t* ra8_sys_usb60ckcr(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr +
                             (uintptr_t)k_ra8_sys_off_usb60ckcr);
}

static inline volatile uint8_t* ra8_sys_usb60ckdivcr(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr +
                             (uintptr_t)k_ra8_sys_off_usb60ckdivcr);
}

static inline volatile uint8_t* ra8_sys_canfdckcr(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr +
                             (uintptr_t)k_ra8_sys_off_canfdckcr);
}

static inline volatile uint8_t* ra8_sys_canfdckdivcr(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr +
                             (uintptr_t)k_ra8_sys_off_canfdckdivcr);
}

static inline volatile uint8_t* ra8_sys_octackcr(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr + (uintptr_t)k_ra8_sys_off_octackcr);
}

static inline volatile uint8_t* ra8_sys_octackdivcr(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr +
                             (uintptr_t)k_ra8_sys_off_octackdivcr);
}

typedef enum : uint8_t {
  k_ra8_eswcksel_hoco  = 0U,  
  k_ra8_eswcksel_moco  = 1U,  
  k_ra8_eswcksel_loco  = 2U,  
  k_ra8_eswcksel_main  = 3U,  
  k_ra8_eswcksel_pll1p = 5U,  
  k_ra8_eswcksel_pll2p = 6U,  
  k_ra8_eswcksel_pll1q = 7U,  
  k_ra8_eswcksel_pll1r = 8U,  
  k_ra8_eswcksel_pll2q = 9U,  
  k_ra8_eswcksel_pll2r = 10U, 
} ra8_eswcksel_t;

typedef enum : uint8_t {
  k_ra8_eswckcr_shift_sel = 0U,    
  k_ra8_eswckcr_mask_sel  = 0x0FU, 
  k_ra8_eswckcr_bit_sreq  = 6U,    
  k_ra8_eswckcr_bit_srdy  = 7U,    
} ra8_eswckcr_bit_t;

static inline volatile uint8_t* ra8_sys_eswckcr(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr + (uintptr_t)k_ra8_sys_off_eswckcr);
}

static inline volatile uint8_t* ra8_sys_eswckdivcr(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr +
                             (uintptr_t)k_ra8_sys_off_eswckdivcr);
}

static inline volatile uint8_t* ra8_sys_eswpckcr(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr + (uintptr_t)k_ra8_sys_off_eswpckcr);
}

static inline volatile uint8_t* ra8_sys_eswpckdivcr(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr +
                             (uintptr_t)k_ra8_sys_off_eswpckdivcr);
}

typedef enum : uint8_t {
  k_ra8_pdctr_bit_pdde   = 0U, 
  k_ra8_pdctr_bit_pdcsf  = 6U, 
  k_ra8_pdctr_bit_pdpgsf = 7U, 
} ra8_pdctreswm_bit_t;

static inline volatile uint8_t* ra8_sys_pdctreswm(void)
{
  return (volatile uint8_t*)((uintptr_t)k_ra8_system_base_addr +
                             (uintptr_t)k_ra8_sys_off_pdctreswm);
}
 
/* =============================================================================
 * PRCR unlock helpers
 * =============================================================================
 */

static inline void ra8_sys_prcr_unlock_cgc(void)
{
  *ra8_sys_prcr() = k_ra8_prcr_unlock_cgc;
}

static inline void ra8_sys_prcr_lock_all(void)
{
  *ra8_sys_prcr() = k_ra8_prcr_lock_all;
}
 
#ifdef __cplusplus
}
#endif