ra8_usb_regs.h

Go to the documentation of this file.

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

typedef enum : uintptr_t {
#ifdef RA8_PERIPH_NS_ALIAS
  /* TrustZone Non-secure build (two-project NS image, #96): reach the
   * controllers through the IDAU bit[28]=1 Non-secure alias (HUM "PSCU_NS =
   * 0x5020_4000" pattern, +0x1000_0000) so the SAU NS peripheral region
   * (0x5000_0000-0xDFFF_FFFF) permits the access. The Secure side marks USBFS0
   * Non-secure in PSARB (PSARB11) so the alias actually responds. */
  k_ra8_usb_fs0_base_addr = 0x50250000UL, 
  k_ra8_usb_hs0_base_addr = 0x50351000UL, 
#else
  k_ra8_usb_fs0_base_addr = 0x40250000UL, 
  k_ra8_usb_hs0_base_addr = 0x40351000UL, 
#endif 
} ra8_usb_addr_t;

typedef enum : uint8_t {
  k_ra8_usb_pipe_count        = 10U, 
  k_ra8_usb_pipectr_count     = 9U,  
  k_ra8_usb_pad_2             = 2U,  
  k_ra8_usb_pad_3             = 3U,  
  k_ra8_usb_pad_5             = 5U,  
  k_ra8_usb_pad_8             = 8U,  
  k_ra8_usb_dcp_max_packet_fs = 64U, 
} ra8_usb_limits_t;

typedef struct {
  volatile uint16_t SYSCFG;                           
  volatile uint16_t BUSWAIT;                          
  volatile uint16_t SYSSTS0;                          
  volatile uint16_t _r0;                              
  volatile uint16_t DVSTCTR0;                         
  volatile uint16_t _r1[k_ra8_usb_pad_5];             
  volatile uint16_t CFIFO;                            
  volatile uint16_t _r2;                              
  volatile uint16_t D0FIFO;                           
  volatile uint16_t _r3;                              
  volatile uint16_t D1FIFO;                           
  volatile uint16_t _r4;                              
  volatile uint16_t CFIFOSEL;                         
  volatile uint16_t CFIFOCTR;                         
  volatile uint16_t _r5[k_ra8_usb_pad_2];             
  volatile uint16_t D0FIFOSEL;                        
  volatile uint16_t D0FIFOCTR;                        
  volatile uint16_t D1FIFOSEL;                        
  volatile uint16_t D1FIFOCTR;                        
  volatile uint16_t INTENB0;                          
  volatile uint16_t INTENB1;                          
  volatile uint16_t _r6;                              
  volatile uint16_t BRDYENB;                          
  volatile uint16_t NRDYENB;                          
  volatile uint16_t BEMPENB;                          
  volatile uint16_t SOFCFG;                           
  volatile uint16_t _r7;                              
  volatile uint16_t INTSTS0;                          
  volatile uint16_t INTSTS1;                          
  volatile uint16_t _r8;                              
  volatile uint16_t BRDYSTS;                          
  volatile uint16_t NRDYSTS;                          
  volatile uint16_t BEMPSTS;                          
  volatile uint16_t FRMNUM;                           
  volatile uint16_t _r9;                              
  volatile uint16_t USBADDR;                          
  volatile uint16_t _ra;                              
  volatile uint16_t USBREQ;                           
  volatile uint16_t USBVAL;                           
  volatile uint16_t USBINDX;                          
  volatile uint16_t USBLENG;                          
  volatile uint16_t DCPCFG;                           
  volatile uint16_t DCPMAXP;                          
  volatile uint16_t DCPCTR;                           
  volatile uint16_t _rb;                              
  volatile uint16_t PIPESEL;                          
  volatile uint16_t _rc;                              
  volatile uint16_t PIPECFG;                          
  volatile uint16_t PIPEBUF;                          
  volatile uint16_t PIPEMAXP;                         
  volatile uint16_t PIPEPERI;                         
  volatile uint16_t PIPECTR[k_ra8_usb_pipectr_count]; 
} r_usb_regs_t;

typedef enum : uint16_t {
  k_ra8_usb_off_syscfg    = 0x000U, 
  k_ra8_usb_off_buswait   = 0x002U, 
  k_ra8_usb_off_syssts0   = 0x004U, 
  k_ra8_usb_off_dvstctr0  = 0x008U, 
  k_ra8_usb_off_cfifo     = 0x014U, 
  k_ra8_usb_off_d0fifo    = 0x018U, 
  k_ra8_usb_off_d1fifo    = 0x01CU, 
  k_ra8_usb_off_cfifosel  = 0x020U, 
  k_ra8_usb_off_cfifoctr  = 0x022U, 
  k_ra8_usb_off_d0fifosel = 0x028U, 
  k_ra8_usb_off_d0fifoctr = 0x02AU, 
  k_ra8_usb_off_d1fifosel = 0x02CU, 
  k_ra8_usb_off_d1fifoctr = 0x02EU, 
  k_ra8_usb_off_intenb0   = 0x030U, 
  k_ra8_usb_off_intenb1   = 0x032U, 
  k_ra8_usb_off_brdyenb   = 0x036U, 
  k_ra8_usb_off_nrdyenb   = 0x038U, 
  k_ra8_usb_off_bempenb   = 0x03AU, 
  k_ra8_usb_off_sofcfg    = 0x03CU, 
  k_ra8_usb_off_intsts0   = 0x040U, 
  k_ra8_usb_off_intsts1   = 0x042U, 
  k_ra8_usb_off_brdysts   = 0x046U, 
  k_ra8_usb_off_nrdysts   = 0x048U, 
  k_ra8_usb_off_bempsts   = 0x04AU, 
  k_ra8_usb_off_frmnum    = 0x04CU, 
  k_ra8_usb_off_usbaddr   = 0x050U, 
  k_ra8_usb_off_usbreq    = 0x054U, 
  k_ra8_usb_off_usbval    = 0x056U, 
  k_ra8_usb_off_usbindx   = 0x058U, 
  k_ra8_usb_off_usbleng   = 0x05AU, 
  k_ra8_usb_off_dcpcfg    = 0x05CU, 
  k_ra8_usb_off_dcpmaxp   = 0x05EU, 
  k_ra8_usb_off_dcpctr    = 0x060U, 
  k_ra8_usb_off_pipesel   = 0x064U, 
  k_ra8_usb_off_pipecfg   = 0x068U, 
  k_ra8_usb_off_pipebuf   = 0x06AU, 
  k_ra8_usb_off_pipemaxp  = 0x06CU, 
  k_ra8_usb_off_pipeperi  = 0x06EU, 
  k_ra8_usb_off_pipectr   = 0x070U, 
} ra8_usb_offset_t;

typedef enum : uint16_t {
  k_ra8_usb_window_bytes = 0x082U, 
} ra8_usb_size_t;

static_assert(sizeof(r_usb_regs_t) == (size_t)k_ra8_usb_window_bytes,
              "r_usb_regs_t window size must be 0x082 bytes (PIPECTR[9] end)");
 
static_assert(offsetof(r_usb_regs_t, SYSCFG) == (size_t)k_ra8_usb_off_syscfg, "SYSCFG offset");
static_assert(offsetof(r_usb_regs_t, BUSWAIT) == (size_t)k_ra8_usb_off_buswait, "BUSWAIT offset");
static_assert(offsetof(r_usb_regs_t, SYSSTS0) == (size_t)k_ra8_usb_off_syssts0, "SYSSTS0 offset");
static_assert(offsetof(r_usb_regs_t, DVSTCTR0) == (size_t)k_ra8_usb_off_dvstctr0,
              "DVSTCTR0 offset");
static_assert(offsetof(r_usb_regs_t, CFIFO) == (size_t)k_ra8_usb_off_cfifo, "CFIFO offset");
static_assert(offsetof(r_usb_regs_t, D0FIFO) == (size_t)k_ra8_usb_off_d0fifo, "D0FIFO offset");
static_assert(offsetof(r_usb_regs_t, D1FIFO) == (size_t)k_ra8_usb_off_d1fifo, "D1FIFO offset");
static_assert(offsetof(r_usb_regs_t, CFIFOSEL) == (size_t)k_ra8_usb_off_cfifosel,
              "CFIFOSEL offset");
static_assert(offsetof(r_usb_regs_t, CFIFOCTR) == (size_t)k_ra8_usb_off_cfifoctr,
              "CFIFOCTR offset");
static_assert(offsetof(r_usb_regs_t, D0FIFOSEL) == (size_t)k_ra8_usb_off_d0fifosel,
              "D0FIFOSEL offset");
static_assert(offsetof(r_usb_regs_t, D0FIFOCTR) == (size_t)k_ra8_usb_off_d0fifoctr,
              "D0FIFOCTR offset");
static_assert(offsetof(r_usb_regs_t, D1FIFOSEL) == (size_t)k_ra8_usb_off_d1fifosel,
              "D1FIFOSEL offset");
static_assert(offsetof(r_usb_regs_t, D1FIFOCTR) == (size_t)k_ra8_usb_off_d1fifoctr,
              "D1FIFOCTR offset");
static_assert(offsetof(r_usb_regs_t, INTENB0) == (size_t)k_ra8_usb_off_intenb0, "INTENB0 offset");
static_assert(offsetof(r_usb_regs_t, INTENB1) == (size_t)k_ra8_usb_off_intenb1, "INTENB1 offset");
static_assert(offsetof(r_usb_regs_t, BRDYENB) == (size_t)k_ra8_usb_off_brdyenb, "BRDYENB offset");
static_assert(offsetof(r_usb_regs_t, NRDYENB) == (size_t)k_ra8_usb_off_nrdyenb, "NRDYENB offset");
static_assert(offsetof(r_usb_regs_t, BEMPENB) == (size_t)k_ra8_usb_off_bempenb, "BEMPENB offset");
static_assert(offsetof(r_usb_regs_t, SOFCFG) == (size_t)k_ra8_usb_off_sofcfg, "SOFCFG offset");
static_assert(offsetof(r_usb_regs_t, INTSTS0) == (size_t)k_ra8_usb_off_intsts0, "INTSTS0 offset");
static_assert(offsetof(r_usb_regs_t, INTSTS1) == (size_t)k_ra8_usb_off_intsts1, "INTSTS1 offset");
static_assert(offsetof(r_usb_regs_t, BRDYSTS) == (size_t)k_ra8_usb_off_brdysts, "BRDYSTS offset");
static_assert(offsetof(r_usb_regs_t, NRDYSTS) == (size_t)k_ra8_usb_off_nrdysts, "NRDYSTS offset");
static_assert(offsetof(r_usb_regs_t, BEMPSTS) == (size_t)k_ra8_usb_off_bempsts, "BEMPSTS offset");
static_assert(offsetof(r_usb_regs_t, FRMNUM) == (size_t)k_ra8_usb_off_frmnum, "FRMNUM offset");
static_assert(offsetof(r_usb_regs_t, USBADDR) == (size_t)k_ra8_usb_off_usbaddr, "USBADDR offset");
static_assert(offsetof(r_usb_regs_t, USBREQ) == (size_t)k_ra8_usb_off_usbreq, "USBREQ offset");
static_assert(offsetof(r_usb_regs_t, USBVAL) == (size_t)k_ra8_usb_off_usbval, "USBVAL offset");
static_assert(offsetof(r_usb_regs_t, USBINDX) == (size_t)k_ra8_usb_off_usbindx, "USBINDX offset");
static_assert(offsetof(r_usb_regs_t, USBLENG) == (size_t)k_ra8_usb_off_usbleng, "USBLENG offset");
static_assert(offsetof(r_usb_regs_t, DCPCFG) == (size_t)k_ra8_usb_off_dcpcfg, "DCPCFG offset");
static_assert(offsetof(r_usb_regs_t, DCPMAXP) == (size_t)k_ra8_usb_off_dcpmaxp, "DCPMAXP offset");
static_assert(offsetof(r_usb_regs_t, DCPCTR) == (size_t)k_ra8_usb_off_dcpctr, "DCPCTR offset");
static_assert(offsetof(r_usb_regs_t, PIPESEL) == (size_t)k_ra8_usb_off_pipesel, "PIPESEL offset");
static_assert(offsetof(r_usb_regs_t, PIPECFG) == (size_t)k_ra8_usb_off_pipecfg, "PIPECFG offset");
static_assert(offsetof(r_usb_regs_t, PIPEBUF) == (size_t)k_ra8_usb_off_pipebuf, "PIPEBUF offset");
static_assert(offsetof(r_usb_regs_t, PIPEMAXP) == (size_t)k_ra8_usb_off_pipemaxp,
              "PIPEMAXP offset");
static_assert(offsetof(r_usb_regs_t, PIPEPERI) == (size_t)k_ra8_usb_off_pipeperi,
              "PIPEPERI offset");
static_assert(offsetof(r_usb_regs_t, PIPECTR) == (size_t)k_ra8_usb_off_pipectr,
              "PIPECTR base offset");
static_assert(sizeof(((r_usb_regs_t*)0)->PIPECTR) ==
                ((size_t)k_ra8_usb_pipectr_count * sizeof(uint16_t)),
              "PIPECTR array spans PIPE1..PIPE9 (9 * 2 bytes)");

RA8_HW_REGISTER_ACCESS
static inline volatile r_usb_regs_t* ra8_usb_fs(void)
{
  return (volatile r_usb_regs_t*)k_ra8_usb_fs0_base_addr;
}

RA8_HW_REGISTER_ACCESS
static inline volatile r_usb_regs_t* ra8_usb_hs(void)
{
  return (volatile r_usb_regs_t*)k_ra8_usb_hs0_base_addr;
}
 
/* =============================================================================
 * USBHS-only register offsets (HUM Ch 37 "USB 2.0 High-Speed Module")
 * =============================================================================
 */

typedef enum : uint16_t {
  k_ra8_usbhs_off_pllsta = 0x006U, 
  k_ra8_usbhs_off_physet = 0x03EU, 
  k_ra8_usbhs_off_lpsts  = 0x102U, 
} ra8_usbhs_offset_t;

RA8_HW_REGISTER_ACCESS
static inline volatile uint16_t* ra8_usbhs_pllsta(void)
{
  return (volatile uint16_t*)(k_ra8_usb_hs0_base_addr + (uintptr_t)k_ra8_usbhs_off_pllsta);
}

RA8_HW_REGISTER_ACCESS
static inline volatile uint16_t* ra8_usbhs_physet(void)
{
  return (volatile uint16_t*)(k_ra8_usb_hs0_base_addr + (uintptr_t)k_ra8_usbhs_off_physet);
}

RA8_HW_REGISTER_ACCESS
static inline volatile uint16_t* ra8_usbhs_lpsts(void)
{
  return (volatile uint16_t*)(k_ra8_usb_hs0_base_addr + (uintptr_t)k_ra8_usbhs_off_lpsts);
}

typedef enum : uint16_t {
  k_ra8_physet_dirpd     = 0x0001U, 
  k_ra8_physet_pllreset  = 0x0002U, 
  k_ra8_physet_clksel    = 0x0030U, 
  k_ra8_physet_clksel_12 = 0x0000U, 
  k_ra8_physet_clksel_48 = 0x0010U, 
  k_ra8_physet_clksel_20 = 0x0020U, 
  k_ra8_physet_clksel_24 = 0x0030U, 
  k_ra8_physet_repsel_16 = 0x0100U, 
  k_ra8_physet_hseb      = 0x8000U, 
} ra8_usbhs_physet_bit_t;

typedef enum : uint16_t {
  k_ra8_lpsts_suspendm = 0x4000U, 
} ra8_usbhs_lpsts_bit_t;

typedef enum : uint16_t {
  k_ra8_pllsta_plllock = 0x0001U, 
} ra8_usbhs_pllsta_bit_t;

typedef enum : uint16_t {
  k_ra8_buswait_default = 0x0F04U, 
} ra8_usbhs_buswait_t;
 
/* =============================================================================
 * SYSCFG bit positions (HUM Ch 36.2.1 / Ch 37.2.1)
 * =============================================================================
 */

typedef enum : uint8_t {
  k_ra8_syscfg_bit_usbe  = 0U,  
  k_ra8_syscfg_bit_dprpu = 4U,  
  k_ra8_syscfg_bit_drpd  = 5U,  
  k_ra8_syscfg_bit_dcfm  = 6U,  
  k_ra8_syscfg_bit_hse   = 7U,  
  k_ra8_syscfg_bit_cnen  = 8U,  
  k_ra8_syscfg_bit_scke  = 10U, 
} ra8_usb_syscfg_bit_t;
 
/* =============================================================================
 * INTENB0 / INTSTS0 bit positions (HUM Ch 36.2.10 / Ch 36.2.14)
 * =============================================================================
 */

typedef enum : uint8_t {
  k_ra8_int0_bit_brdy = 8U,  
  k_ra8_int0_bit_nrdy = 9U,  
  k_ra8_int0_bit_bemp = 10U, 
  k_ra8_int0_bit_ctrt = 11U, 
  k_ra8_int0_bit_dvst = 12U, 
  k_ra8_int0_bit_sofr = 13U, 
  k_ra8_int0_bit_rsme = 14U, 
  k_ra8_int0_bit_vbse = 15U, 
} ra8_usb_intenb0_bit_t;

typedef enum : uint8_t {
  k_ra8_int1_bit_sack   = 4U,  
  k_ra8_int1_bit_sign   = 5U,  
  k_ra8_int1_bit_eoferr = 6U,  
  k_ra8_int1_bit_attch  = 11U, 
  k_ra8_int1_bit_dtch   = 12U, 
  k_ra8_int1_bit_bchg   = 14U, 
  k_ra8_int1_bit_ovrcr  = 15U, 
} ra8_usb_intsts1_bit_t;

typedef enum : uint16_t {
  k_ra8_int0_full_mask = 0x9F00U,
} ra8_usb_intenb0_mask_t;

typedef enum : uint16_t {
  k_ra8_intsts0_mask_ctsq  = 0x0007U, 
  k_ra8_intsts0_mask_valid = 0x0008U, 
  k_ra8_intsts0_mask_dvsq  = 0x0070U, 
  k_ra8_intsts0_mask_vbsts = 0x0080U, 
} ra8_usb_intsts0_mask_t;

typedef enum : uint16_t {
  k_ra8_dvsq_powered    = 0x0000U, 
  k_ra8_dvsq_default    = 0x0010U, 
  k_ra8_dvsq_address    = 0x0020U, 
  k_ra8_dvsq_configured = 0x0030U, 
  /* Suspend flag is bit 6 on BOTH controllers. USBHS additionally
   * reports VBUS presence in INTSTS0 bit 7 -- strip it before
   * comparing DVSQ values (observed live: bit 7 tracks the cable). */
  k_ra8_dvsq_suspend = 0x0040U, 
} ra8_usb_dvsq_t;

typedef enum : uint16_t {
  k_ra8_ctsq_idle = 0x0000U, 
  k_ra8_ctsq_rdds = 0x0001U, 
  k_ra8_ctsq_rdss = 0x0002U, 
  k_ra8_ctsq_wrds = 0x0003U, 
  k_ra8_ctsq_wrss = 0x0004U, 
  k_ra8_ctsq_wrnd = 0x0005U, 
  k_ra8_ctsq_sqer = 0x0006U, 
} ra8_usb_ctsq_t;
 
/* =============================================================================
 * DCPCTR bit positions (HUM Ch 36.2.21)
 * =============================================================================
 */

typedef enum : uint8_t {
  k_ra8_dcpctr_bit_pid_lo   = 0U,  
  k_ra8_dcpctr_bit_pid_hi   = 1U,  
  k_ra8_dcpctr_bit_ccpl     = 2U,  
  k_ra8_dcpctr_bit_pbusy    = 5U,  
  k_ra8_dcpctr_bit_sqmon    = 6U,  
  k_ra8_dcpctr_bit_sqset    = 7U,  
  k_ra8_dcpctr_bit_sqclr    = 8U,  
  k_ra8_dcpctr_bit_sureqclr = 11U, 
  k_ra8_dcpctr_bit_sureq    = 14U, 
  k_ra8_dcpctr_bit_bsts     = 15U, 
} ra8_usb_dcpctr_bit_t;

typedef enum : uint8_t {
  k_ra8_dcpcfg_bit_dir = 4U, 
} ra8_usb_dcpcfg_bit_t;

typedef enum : uint16_t {
  k_ra8_pid_nak   = 0x0000U, 
  k_ra8_pid_buf   = 0x0001U, 
  k_ra8_pid_stall = 0x0002U, 
  k_ra8_pid_mask  = 0x0003U, 
} ra8_usb_pid_t;
 
/* =============================================================================
 * CFIFOSEL / DnFIFOSEL bit positions (HUM Ch 36.2.7)
 * =============================================================================
 */

typedef enum : uint16_t {
  k_ra8_fifosel_curpipe = 0x000FU, 
  k_ra8_fifosel_isel    = 0x0020U, 
  k_ra8_fifosel_bigend  = 0x0100U, 
  k_ra8_fifosel_mbw_8   = 0x0000U, 
  k_ra8_fifosel_mbw_16  = 0x0400U, 
  k_ra8_fifosel_mbw_32  = 0x0800U, 
  k_ra8_fifosel_mbw_msk = 0x0C00U, 
  k_ra8_fifosel_dreqe   = 0x1000U, 
  k_ra8_fifosel_dclrm   = 0x2000U, 
  k_ra8_fifosel_rew     = 0x4000U, 
  k_ra8_fifosel_rcnt    = 0x8000U, 
} ra8_usb_fifosel_field_t;
 
/* =============================================================================
 * CFIFOCTR / DnFIFOCTR bit positions (HUM Ch 36.2.8)
 * =============================================================================
 */

typedef enum : uint16_t {
  k_ra8_fifoctr_dtln = 0x0FFFU, 
  k_ra8_fifoctr_frdy = 0x2000U, 
  k_ra8_fifoctr_bclr = 0x4000U, 
  k_ra8_fifoctr_bval = 0x8000U, 
} ra8_usb_fifoctr_field_t;
 
/* =============================================================================
 * USBADDR field (HUM Ch 36.2.16)
 * =============================================================================
 */

typedef enum : uint16_t {
  k_ra8_usbaddr_addr_mask = 0x007FU, 
} ra8_usb_addr_field_t;
 
/* =============================================================================
 * PIPECFG fields (HUM Ch 36.2.24)
 * =============================================================================
 */

typedef enum : uint16_t {
  k_ra8_pipecfg_epnum_mask = 0x000FU, 
  k_ra8_pipecfg_dir_in     = 0x0010U, 
  k_ra8_pipecfg_shtnak     = 0x0080U, 
  k_ra8_pipecfg_dblb       = 0x0200U, 
  k_ra8_pipecfg_bfre       = 0x0400U, 
  k_ra8_pipecfg_type_bulk  = 0x4000U, 
  k_ra8_pipecfg_type_intr  = 0x8000U, 
  k_ra8_pipecfg_type_iso   = 0xC000U, 
  k_ra8_pipecfg_type_mask  = 0xC000U, 
} ra8_usb_pipecfg_field_t;
 
/* =============================================================================
 * PIPEBUF fields (HUM Ch 37.2.35)
 * =============================================================================
 */

typedef enum : uint16_t {
  k_ra8_pipebuf_bufnmb_mask   = 0x00FFU, 
  k_ra8_pipebuf_bufsize_mask  = 0x7C00U, 
  k_ra8_pipebuf_bufsize_shift = 10U,     
  k_ra8_pipebuf_block_bytes   = 64U,     
} ra8_usb_pipebuf_field_t;
 
/* =============================================================================
 * PIPECTR bit positions (HUM Ch 36.2.27)
 * =============================================================================
 */

typedef enum : uint16_t {
  k_ra8_pipectr_pid_mask = 0x0003U, 
  k_ra8_pipectr_pbusy    = 0x0020U, 
  k_ra8_pipectr_sqmon    = 0x0040U, 
  k_ra8_pipectr_sqset    = 0x0080U, 
  k_ra8_pipectr_sqclr    = 0x0100U, 
  k_ra8_pipectr_aclrm    = 0x0200U, 
  k_ra8_pipectr_atrepm   = 0x0400U, 
  k_ra8_pipectr_inbufm   = 0x4000U, 
  k_ra8_pipectr_bsts     = 0x8000U, 
} ra8_usb_pipectr_bit_t;
 
#ifdef __cplusplus
}
#endif