Linux/Unix编程

开发平台：

Unix_Linux

hubpi.h：源码内容

/* $Id$
*
* This file is subject to the terms and conditions of the GNU General Public
* License. See the file "COPYING" in the main directory of this archive
* for more details.
*
*/
#ifndef _ASM_IA64_SN_SN1_HUBPI_H
#define _ASM_IA64_SN_SN1_HUBPI_H
/************************************************************************
* *
* WARNING!!! WARNING!!! WARNING!!! WARNING!!! WARNING!!! *
* *
* This file is created by an automated script. Any (minimal) changes *
* made manually to this file should be made with care. *
* *
* MAKE ALL ADDITIONS TO THE END OF THIS FILE *
* *
************************************************************************/
#define PI_CPU_PROTECT 0x00000000 /* CPU Protection */
#define PI_PROT_OVRRD 0x00000008 /*
* Clear CPU
* Protection bit in
* CPU_PROTECT
*/
#define PI_IO_PROTECT 0x00000010 /*
* Interrupt Pending
* Protection for IO
* access
*/
#define PI_REGION_PRESENT 0x00000018 /* Region present */
#define PI_CPU_NUM 0x00000020 /* CPU Number ID */
#define PI_CALIAS_SIZE 0x00000028 /* Cached Alias Size */
#define PI_MAX_CRB_TIMEOUT 0x00000030 /*
* Maximum Timeout for
* CRB
*/
#define PI_CRB_SFACTOR 0x00000038 /*
* Scale Factor for
* CRB Timeout
*/
#define PI_CPU_PRESENT_A 0x00000040 /*
* CPU Present for
* CPU_A
*/
#define PI_CPU_PRESENT_B 0x00000048 /*
* CPU Present for
* CPU_B
*/
#define PI_CPU_ENABLE_A 0x00000050 /*
* CPU Enable for
* CPU_A
*/
#define PI_CPU_ENABLE_B 0x00000058 /*
* CPU Enable for
* CPU_B
*/
#define PI_REPLY_LEVEL 0x00010060 /*
* Reply FIFO Priority
* Control
*/
#define PI_GFX_CREDIT_MODE 0x00020068 /*
* Graphics Credit
* Mode
*/
#define PI_NMI_A 0x00000070 /*
* Non-maskable
* Interrupt to CPU A
*/
#define PI_NMI_B 0x00000078 /*
* Non-maskable
* Interrupt to CPU B
*/
#define PI_INT_PEND_MOD 0x00000090 /*
* Interrupt Pending
* Modify
*/
#define PI_INT_PEND0 0x00000098 /* Interrupt Pending 0 */
#define PI_INT_PEND1 0x000000A0 /* Interrupt Pending 1 */
#define PI_INT_MASK0_A 0x000000A8 /*
* Interrupt Mask 0
* for CPU A
*/
#define PI_INT_MASK1_A 0x000000B0 /*
* Interrupt Mask 1
* for CPU A
*/
#define PI_INT_MASK0_B 0x000000B8 /*
* Interrupt Mask 0
* for CPU B
*/
#define PI_INT_MASK1_B 0x000000C0 /*
* Interrupt Mask 1
* for CPU B
*/
#define PI_CC_PEND_SET_A 0x000000C8 /*
* CC Interrupt
* Pending for CPU A
*/
#define PI_CC_PEND_SET_B 0x000000D0 /*
* CC Interrupt
* Pending for CPU B
*/
#define PI_CC_PEND_CLR_A 0x000000D8 /*
* CPU to CPU
* Interrupt Pending
* Clear for CPU A
*/
#define PI_CC_PEND_CLR_B 0x000000E0 /*
* CPU to CPU
* Interrupt Pending
* Clear for CPU B
*/
#define PI_CC_MASK 0x000000E8 /*
* Mask of both
* CC_PENDs
*/
#define PI_INT_PEND1_REMAP 0x000000F0 /*
* Remap Interrupt
* Pending
*/
#define PI_RT_COUNTER 0x00030100 /* Real Time Counter */
#define PI_RT_COMPARE_A 0x00000108 /* Real Time Compare A */
#define PI_RT_COMPARE_B 0x00000110 /* Real Time Compare B */
#define PI_PROFILE_COMPARE 0x00000118 /* Profiling Compare */
#define PI_RT_INT_PEND_A 0x00000120 /*
* RT interrupt
* pending
*/
#define PI_RT_INT_PEND_B 0x00000128 /*
* RT interrupt
* pending
*/
#define PI_PROF_INT_PEND_A 0x00000130 /*
* Profiling interrupt
* pending
*/
#define PI_PROF_INT_PEND_B 0x00000138 /*
* Profiling interrupt
* pending
*/
#define PI_RT_INT_EN_A 0x00000140 /* RT Interrupt Enable */
#define PI_RT_INT_EN_B 0x00000148 /* RT Interrupt Enable */
#define PI_PROF_INT_EN_A 0x00000150 /*
* Profiling Interrupt
* Enable
*/
#define PI_PROF_INT_EN_B 0x00000158 /*
* Profiling Interrupt
* Enable
*/
#define PI_DEBUG_SEL 0x00000160 /* PI Debug Select */
#define PI_INT_PEND_MOD_ALIAS 0x00000180 /*
* Interrupt Pending
* Modify
*/
#define PI_PERF_CNTL_A 0x00040200 /*
* Performance Counter
* Control A
*/
#define PI_PERF_CNTR0_A 0x00040208 /*
* Performance Counter
* 0 A
*/
#define PI_PERF_CNTR1_A 0x00040210 /*
* Performance Counter
* 1 A
*/
#define PI_PERF_CNTL_B 0x00050200 /*
* Performance Counter
* Control B
*/
#define PI_PERF_CNTR0_B 0x00050208 /*
* Performance Counter
* 0 B
*/
#define PI_PERF_CNTR1_B 0x00050210 /*
* Performance Counter
* 1 B
*/
#define PI_GFX_PAGE_A 0x00000300 /* Graphics Page */
#define PI_GFX_CREDIT_CNTR_A 0x00000308 /*
* Graphics Credit
* Counter
*/
#define PI_GFX_BIAS_A 0x00000310 /* TRex+ BIAS */
#define PI_GFX_INT_CNTR_A 0x00000318 /*
* Graphics Interrupt
* Counter
*/
#define PI_GFX_INT_CMP_A 0x00000320 /*
* Graphics Interrupt
* Compare
*/
#define PI_GFX_PAGE_B 0x00000328 /* Graphics Page */
#define PI_GFX_CREDIT_CNTR_B 0x00000330 /*
* Graphics Credit
* Counter
*/
#define PI_GFX_BIAS_B 0x00000338 /* TRex+ BIAS */
#define PI_GFX_INT_CNTR_B 0x00000340 /*
* Graphics Interrupt
* Counter
*/
#define PI_GFX_INT_CMP_B 0x00000348 /*
* Graphics Interrupt
* Compare
*/
#define PI_ERR_INT_PEND_WR 0x000003F8 /*
* Error Interrupt
* Pending (Writable)
*/
#define PI_ERR_INT_PEND 0x00000400 /*
* Error Interrupt
* Pending
*/
#define PI_ERR_INT_MASK_A 0x00000408 /*
* Error Interrupt
* Mask CPU_A
*/
#define PI_ERR_INT_MASK_B 0x00000410 /*
* Error Interrupt
* Mask CPU_B
*/
#define PI_ERR_STACK_ADDR_A 0x00000418 /*
* Error Stack Address
* Pointer
*/
#define PI_ERR_STACK_ADDR_B 0x00000420 /*
* Error Stack Address
* Pointer
*/
#define PI_ERR_STACK_SIZE 0x00000428 /* Error Stack Size */
#define PI_ERR_STATUS0_A 0x00000430 /* Error Status 0 */
#define PI_ERR_STATUS0_A_CLR 0x00000438 /* Error Status 0 */
#define PI_ERR_STATUS1_A 0x00000440 /* Error Status 1 */
#define PI_ERR_STATUS1_A_CLR 0x00000448 /* Error Status 1 */
#define PI_ERR_STATUS0_B 0x00000450 /* Error Status 0 */
#define PI_ERR_STATUS0_B_CLR 0x00000458 /* Error Status 0 */
#define PI_ERR_STATUS1_B 0x00000460 /* Error Status 1 */
#define PI_ERR_STATUS1_B_CLR 0x00000468 /* Error Status 1 */
#define PI_SPOOL_CMP_A 0x00000470 /* Spool Compare */
#define PI_SPOOL_CMP_B 0x00000478 /* Spool Compare */
#define PI_CRB_TIMEOUT_A 0x00000480 /*
* CRB entries which
* have timed out but
* are still valid
*/
#define PI_CRB_TIMEOUT_B 0x00000488 /*
* CRB entries which
* have timed out but
* are still valid
*/
#define PI_SYSAD_ERRCHK_EN 0x00000490 /*
* enables
* sysad/cmd/state
* error checking
*/
#define PI_FORCE_BAD_CHECK_BIT_A 0x00000498 /*
* force SysAD Check
* Bit error
*/
#define PI_FORCE_BAD_CHECK_BIT_B 0x000004A0 /*
* force SysAD Check
* Bit error
*/
#define PI_NACK_CNT_A 0x000004A8 /*
* consecutive NACK
* counter
*/
#define PI_NACK_CNT_B 0x000004B0 /*
* consecutive NACK
* counter
*/
#define PI_NACK_CMP 0x000004B8 /* NACK count compare */
#define PI_SPOOL_MASK 0x000004C0 /* Spool error mask */
#define PI_SPURIOUS_HDR_0 0x000004C8 /* Spurious Error 0 */
#define PI_SPURIOUS_HDR_1 0x000004D0 /* Spurious Error 1 */
#define PI_ERR_INJECT 0x000004D8 /*
* SysAD bus error
* injection
*/
#ifndef __ASSEMBLY__
/************************************************************************
* *
* Description: This read/write register determines on a *
* bit-per-region basis whether incoming CPU-initiated PIO Read and *
* Write to local PI registers are allowed. If access is allowed, the *
* PI's response to a partial read is a PRPLY message, and the *
* response to a partial write is a PACK message. If access is not *
* allowed, the PI's response to a partial read is a PRERR message, *
* and the response to a partial write is a PWERR message. *
* This register is not reset by a soft reset. *
* *
************************************************************************/
typedef union pi_cpu_protect_u {
bdrkreg_t pi_cpu_protect_regval;
struct {
bdrkreg_t cp_cpu_protect : 64;
} pi_cpu_protect_fld_s;
} pi_cpu_protect_u_t;
/************************************************************************
* *
* A write with a special data pattern allows any CPU to set its *
* region's bit in CPU_PROTECT. This register has data pattern *
* protection. *
* *
************************************************************************/
typedef union pi_prot_ovrrd_u {
bdrkreg_t pi_prot_ovrrd_regval;
struct {
bdrkreg_t po_prot_ovrrd : 64;
} pi_prot_ovrrd_fld_s;
} pi_prot_ovrrd_u_t;
/************************************************************************
* *
* Description: This read/write register determines on a *
* bit-per-region basis whether incoming IO-initiated interrupts are *
* allowed to set bits in INT_PEND0 and INT_PEND1. If access is *
* allowed, the PI's response to a partial read is a PRPLY message, *
* and the response to a partial write is a PACK message. If access *
* is not allowed, the PI's response to a partial read is a PRERR *
* message, and the response to a partial write is a PWERR message. *
* This register is not reset by a soft reset. *
* *
************************************************************************/
typedef union pi_io_protect_u {
bdrkreg_t pi_io_protect_regval;
struct {
bdrkreg_t ip_io_protect : 64;
} pi_io_protect_fld_s;
} pi_io_protect_u_t;
/************************************************************************
* *
* Description: This read/write register determines on a *
* bit-per-region basis whether read access from a local processor to *
* the region is permissible. For example, setting a bit to 0 *
* prevents speculative reads to that non-existent node. If a read *
* request to a non-present region occurs, an ERR response is issued *
* to the TRex+ (no PI error registers are modified). It is up to *
* software to load this register with the proper contents. *
* Region-present checking is only done for coherent read requests - *
* partial reads/writes will be issued to a non-present region. The *
* setting of these bits does not affect a node's access to its *
* CALIAS space. *
* This register is not reset by a soft reset. *
* *
************************************************************************/
typedef union pi_region_present_u {
bdrkreg_t pi_region_present_regval;
struct {
bdrkreg_t rp_region_present : 64;
} pi_region_present_fld_s;
} pi_region_present_u_t;
/************************************************************************
* *
* A read to the location will allow a CPU to identify itself as *
* either CPU_A or CPU_B, and will indicate whether the CPU is *
* connected to PI 0 or PI 1. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_cpu_num_u {
bdrkreg_t pi_cpu_num_regval;
struct {
bdrkreg_t cn_cpu_num : 1;
bdrkreg_t cn_pi_id : 1;
bdrkreg_t cn_rsvd : 62;
} pi_cpu_num_fld_s;
} pi_cpu_num_u_t;
#else
typedef union pi_cpu_num_u {
bdrkreg_t pi_cpu_num_regval;
struct {
bdrkreg_t cn_rsvd : 62;
bdrkreg_t cn_pi_id : 1;
bdrkreg_t cn_cpu_num : 1;
} pi_cpu_num_fld_s;
} pi_cpu_num_u_t;
#endif
/************************************************************************
* *
* Description: This read/write location determines the size of the *
* Calias Space. *
* This register is not reset by a soft reset. *
* NOTE: For predictable behavior, all Calias spaces in a system must *
* be set to the same size. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_calias_size_u {
bdrkreg_t pi_calias_size_regval;
struct {
bdrkreg_t cs_calias_size : 4;
bdrkreg_t cs_rsvd : 60;
} pi_calias_size_fld_s;
} pi_calias_size_u_t;
#else
typedef union pi_calias_size_u {
bdrkreg_t pi_calias_size_regval;
struct {
bdrkreg_t cs_rsvd : 60;
bdrkreg_t cs_calias_size : 4;
} pi_calias_size_fld_s;
} pi_calias_size_u_t;
#endif
/************************************************************************
* *
* This Read/Write location determines at which value (increment) *
* the CRB Timeout Counters cause a timeout error to occur. See *
* Section 3.4.2.2, "Time-outs in RRB and WRB" in the *
* Processor Interface chapter, volume 1 of this document for more *
* details. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_max_crb_timeout_u {
bdrkreg_t pi_max_crb_timeout_regval;
struct {
bdrkreg_t mct_max_timeout : 8;
bdrkreg_t mct_rsvd : 56;
} pi_max_crb_timeout_fld_s;
} pi_max_crb_timeout_u_t;
#else
typedef union pi_max_crb_timeout_u {
bdrkreg_t pi_max_crb_timeout_regval;
struct {
bdrkreg_t mct_rsvd : 56;
bdrkreg_t mct_max_timeout : 8;
} pi_max_crb_timeout_fld_s;
} pi_max_crb_timeout_u_t;
#endif
/************************************************************************
* *
* This Read/Write location determines how often a valid CRB's *
* Timeout Counter is incremented. See Section 3.4.2.2, *
* "Time-outs in RRB and WRB" in the Processor Interface *
* chapter, volume 1 of this document for more details. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_crb_sfactor_u {
bdrkreg_t pi_crb_sfactor_regval;
struct {
bdrkreg_t cs_sfactor : 24;
bdrkreg_t cs_rsvd : 40;
} pi_crb_sfactor_fld_s;
} pi_crb_sfactor_u_t;
#else
typedef union pi_crb_sfactor_u {
bdrkreg_t pi_crb_sfactor_regval;
struct {
bdrkreg_t cs_rsvd : 40;
bdrkreg_t cs_sfactor : 24;
} pi_crb_sfactor_fld_s;
} pi_crb_sfactor_u_t;
#endif
/************************************************************************
* *
* There is one of these registers for each CPU. The PI sets this *
* bit when it sees the first transaction initiated by the associated *
* CPU. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_cpu_present_a_u {
bdrkreg_t pi_cpu_present_a_regval;
struct {
bdrkreg_t cpa_cpu_present : 1;
bdrkreg_t cpa_rsvd : 63;
} pi_cpu_present_a_fld_s;
} pi_cpu_present_a_u_t;
#else
typedef union pi_cpu_present_a_u {
bdrkreg_t pi_cpu_present_a_regval;
struct {
bdrkreg_t cpa_rsvd : 63;
bdrkreg_t cpa_cpu_present : 1;
} pi_cpu_present_a_fld_s;
} pi_cpu_present_a_u_t;
#endif
/************************************************************************
* *
* There is one of these registers for each CPU. The PI sets this *
* bit when it sees the first transaction initiated by the associated *
* CPU. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_cpu_present_b_u {
bdrkreg_t pi_cpu_present_b_regval;
struct {
bdrkreg_t cpb_cpu_present : 1;
bdrkreg_t cpb_rsvd : 63;
} pi_cpu_present_b_fld_s;
} pi_cpu_present_b_u_t;
#else
typedef union pi_cpu_present_b_u {
bdrkreg_t pi_cpu_present_b_regval;
struct {
bdrkreg_t cpb_rsvd : 63;
bdrkreg_t cpb_cpu_present : 1;
} pi_cpu_present_b_fld_s;
} pi_cpu_present_b_u_t;
#endif
/************************************************************************
* *
* Description: There is one of these registers for each CPU. This *
* Read/Write location determines whether the associated CPU is *
* enabled to issue external requests. When this bit is zero for a *
* processor, the PI ignores SysReq_L from that processor, and so *
* never grants it the bus. *
* This register is not reset by a soft reset. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_cpu_enable_a_u {
bdrkreg_t pi_cpu_enable_a_regval;
struct {
bdrkreg_t cea_cpu_enable : 1;
bdrkreg_t cea_rsvd : 63;
} pi_cpu_enable_a_fld_s;
} pi_cpu_enable_a_u_t;
#else
typedef union pi_cpu_enable_a_u {
bdrkreg_t pi_cpu_enable_a_regval;
struct {
bdrkreg_t cea_rsvd : 63;
bdrkreg_t cea_cpu_enable : 1;
} pi_cpu_enable_a_fld_s;
} pi_cpu_enable_a_u_t;
#endif
/************************************************************************
* *
* Description: There is one of these registers for each CPU. This *
* Read/Write location determines whether the associated CPU is *
* enabled to issue external requests. When this bit is zero for a *
* processor, the PI ignores SysReq_L from that processor, and so *
* never grants it the bus. *
* This register is not reset by a soft reset. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_cpu_enable_b_u {
bdrkreg_t pi_cpu_enable_b_regval;
struct {
bdrkreg_t ceb_cpu_enable : 1;
bdrkreg_t ceb_rsvd : 63;
} pi_cpu_enable_b_fld_s;
} pi_cpu_enable_b_u_t;
#else
typedef union pi_cpu_enable_b_u {
bdrkreg_t pi_cpu_enable_b_regval;
struct {
bdrkreg_t ceb_rsvd : 63;
bdrkreg_t ceb_cpu_enable : 1;
} pi_cpu_enable_b_fld_s;
} pi_cpu_enable_b_u_t;
#endif
/************************************************************************
* *
* There is one of these registers for each CPU. A write to this *
* location will cause an NMI to be issued to the CPU. *
* *
************************************************************************/
typedef union pi_nmi_a_u {
bdrkreg_t pi_nmi_a_regval;
struct {
bdrkreg_t na_nmi_cpu : 64;
} pi_nmi_a_fld_s;
} pi_nmi_a_u_t;
/************************************************************************
* *
* There is one of these registers for each CPU. A write to this *
* location will cause an NMI to be issued to the CPU. *
* *
************************************************************************/
typedef union pi_nmi_b_u {
bdrkreg_t pi_nmi_b_regval;
struct {
bdrkreg_t nb_nmi_cpu : 64;
} pi_nmi_b_fld_s;
} pi_nmi_b_u_t;
/************************************************************************
* *
* A write to this register allows a single bit in the INT_PEND0 or *
* INT_PEND1 registers to be set or cleared. If 6 is clear, a bit is *
* modified in INT_PEND0, while if 6 is set, a bit is modified in *
* INT_PEND1. The value in 5:0 (ranging from 63 to 0) will determine *
* which bit in the register is effected. The value of 8 will *
* determine whether the desired bit is set (8=1) or cleared (8=0). *
* This is the only register which is accessible by IO issued PWRI *
* command and is protected through the IO_PROTECT register. If the *
* region bit in the IO_PROTECT is not set then a WERR reply is *
* issued. CPU access is controlled through CPU_PROTECT. The contents *
* of this register are masked with the contents of INT_MASK_A *
* (INT_MASK_B) to determine whether an L2 interrupt is issued to *
* CPU_A (CPU_B). *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_int_pend_mod_u {
bdrkreg_t pi_int_pend_mod_regval;
struct {
bdrkreg_t ipm_bit_select : 6;
bdrkreg_t ipm_reg_select : 1;
bdrkreg_t ipm_rsvd_1 : 1;
bdrkreg_t ipm_value : 1;
bdrkreg_t ipm_rsvd : 55;
} pi_int_pend_mod_fld_s;
} pi_int_pend_mod_u_t;
#else
typedef union pi_int_pend_mod_u {
bdrkreg_t pi_int_pend_mod_regval;
struct {
bdrkreg_t ipm_rsvd : 55;
bdrkreg_t ipm_value : 1;
bdrkreg_t ipm_rsvd_1 : 1;
bdrkreg_t ipm_reg_select : 1;
bdrkreg_t ipm_bit_select : 6;
} pi_int_pend_mod_fld_s;
} pi_int_pend_mod_u_t;
#endif
/************************************************************************
* *
* This read-only register provides information about interrupts *
* that are currently pending. The interrupts in this register map to *
* interrupt level 2 (L2). The GFX_INT_A/B bits are set by hardware *
* but must be cleared by software. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_int_pend0_u {
bdrkreg_t pi_int_pend0_regval;
struct {
bdrkreg_t ip_int_pend0_lo : 1;
bdrkreg_t ip_gfx_int_a : 1;
bdrkreg_t ip_gfx_int_b : 1;
bdrkreg_t ip_page_migration : 1;
bdrkreg_t ip_uart_ucntrl : 1;
bdrkreg_t ip_or_cc_pend_a : 1;
bdrkreg_t ip_or_cc_pend_b : 1;
bdrkreg_t ip_int_pend0_hi : 57;
} pi_int_pend0_fld_s;
} pi_int_pend0_u_t;
#else
typedef union pi_int_pend0_u {
bdrkreg_t pi_int_pend0_regval;
struct {
bdrkreg_t ip_int_pend0_hi : 57;
bdrkreg_t ip_or_cc_pend_b : 1;
bdrkreg_t ip_or_cc_pend_a : 1;
bdrkreg_t ip_uart_ucntrl : 1;
bdrkreg_t ip_page_migration : 1;
bdrkreg_t ip_gfx_int_b : 1;
bdrkreg_t ip_gfx_int_a : 1;
bdrkreg_t ip_int_pend0_lo : 1;
} pi_int_pend0_fld_s;
} pi_int_pend0_u_t;
#endif
/************************************************************************
* *
* This read-only register provides information about interrupts *
* that are currently pending. The interrupts in this register map to *
* interrupt level 3 (L3), unless remapped by the INT_PEND1_REMAP *
* register. The SYS_COR_ERR_A/B, RTC_DROP_OUT, and NACK_INT_A/B bits *
* are set by hardware but must be cleared by software. The *
* SYSTEM_SHUTDOWN, NI_ERROR, LB_ERROR and XB_ERROR bits just reflect *
* the value of other logic, and cannot be changed by PI register *
* writes. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_int_pend1_u {
bdrkreg_t pi_int_pend1_regval;
struct {
bdrkreg_t ip_int_pend1 : 54;
bdrkreg_t ip_xb_error : 1;
bdrkreg_t ip_lb_error : 1;
bdrkreg_t ip_nack_int_a : 1;
bdrkreg_t ip_nack_int_b : 1;
bdrkreg_t ip_perf_cntr_oflow : 1;
bdrkreg_t ip_sys_cor_err_b : 1;
bdrkreg_t ip_sys_cor_err_a : 1;
bdrkreg_t ip_md_corr_error : 1;
bdrkreg_t ip_ni_error : 1;
bdrkreg_t ip_system_shutdown : 1;
} pi_int_pend1_fld_s;
} pi_int_pend1_u_t;
#else
typedef union pi_int_pend1_u {
bdrkreg_t pi_int_pend1_regval;
struct {
bdrkreg_t ip_system_shutdown : 1;
bdrkreg_t ip_ni_error : 1;
bdrkreg_t ip_md_corr_error : 1;
bdrkreg_t ip_sys_cor_err_a : 1;
bdrkreg_t ip_sys_cor_err_b : 1;
bdrkreg_t ip_perf_cntr_oflow : 1;
bdrkreg_t ip_nack_int_b : 1;
bdrkreg_t ip_nack_int_a : 1;
bdrkreg_t ip_lb_error : 1;
bdrkreg_t ip_xb_error : 1;
bdrkreg_t ip_int_pend1 : 54;
} pi_int_pend1_fld_s;
} pi_int_pend1_u_t;
#endif
/************************************************************************
* *
* This read/write register masks the contents of INT_PEND0 to *
* determine whether an L2 interrupt (bit 10 of the processor's Cause *
* register) is sent to CPU_A if the same bit in the INT_PEND0 *
* register is also set. Only one processor in a Bedrock should *
* enable the PAGE_MIGRATION bit/interrupt. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_int_mask0_a_u {
bdrkreg_t pi_int_mask0_a_regval;
struct {
bdrkreg_t ima_int_mask0_lo : 1;
bdrkreg_t ima_gfx_int_a : 1;
bdrkreg_t ima_gfx_int_b : 1;
bdrkreg_t ima_page_migration : 1;
bdrkreg_t ima_uart_ucntrl : 1;
bdrkreg_t ima_or_ccp_mask_a : 1;
bdrkreg_t ima_or_ccp_mask_b : 1;
bdrkreg_t ima_int_mask0_hi : 57;
} pi_int_mask0_a_fld_s;
} pi_int_mask0_a_u_t;
#else
typedef union pi_int_mask0_a_u {
bdrkreg_t pi_int_mask0_a_regval;
struct {
bdrkreg_t ima_int_mask0_hi : 57;
bdrkreg_t ima_or_ccp_mask_b : 1;
bdrkreg_t ima_or_ccp_mask_a : 1;
bdrkreg_t ima_uart_ucntrl : 1;
bdrkreg_t ima_page_migration : 1;
bdrkreg_t ima_gfx_int_b : 1;
bdrkreg_t ima_gfx_int_a : 1;
bdrkreg_t ima_int_mask0_lo : 1;
} pi_int_mask0_a_fld_s;
} pi_int_mask0_a_u_t;
#endif
/************************************************************************
* *
* This read/write register masks the contents of INT_PEND1 to *
* determine whether an interrupt should be sent. Bits 63:32 always *
* generate an L3 interrupt (bit 11 of the processor's Cause *
* register) is sent to CPU_A if the same bit in the INT_PEND1 *
* register is set. Bits 31:0 can generate either an L3 or L2 *
* interrupt, depending on the value of INT_PEND1_REMAP[3:0]. Only *
* one processor in a Bedrock should enable the NI_ERROR, LB_ERROR, *
* XB_ERROR and MD_CORR_ERROR bits. *
* *
************************************************************************/
typedef union pi_int_mask1_a_u {
bdrkreg_t pi_int_mask1_a_regval;
struct {
bdrkreg_t ima_int_mask1 : 64;
} pi_int_mask1_a_fld_s;
} pi_int_mask1_a_u_t;
/************************************************************************
* *
* This read/write register masks the contents of INT_PEND0 to *
* determine whether an L2 interrupt (bit 10 of the processor's Cause *
* register) is sent to CPU_B if the same bit in the INT_PEND0 *
* register is also set. Only one processor in a Bedrock should *
* enable the PAGE_MIGRATION bit/interrupt. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_int_mask0_b_u {
bdrkreg_t pi_int_mask0_b_regval;
struct {
bdrkreg_t imb_int_mask0_lo : 1;
bdrkreg_t imb_gfx_int_a : 1;
bdrkreg_t imb_gfx_int_b : 1;
bdrkreg_t imb_page_migration : 1;
bdrkreg_t imb_uart_ucntrl : 1;
bdrkreg_t imb_or_ccp_mask_a : 1;
bdrkreg_t imb_or_ccp_mask_b : 1;
bdrkreg_t imb_int_mask0_hi : 57;
} pi_int_mask0_b_fld_s;
} pi_int_mask0_b_u_t;
#else
typedef union pi_int_mask0_b_u {
bdrkreg_t pi_int_mask0_b_regval;
struct {
bdrkreg_t imb_int_mask0_hi : 57;
bdrkreg_t imb_or_ccp_mask_b : 1;
bdrkreg_t imb_or_ccp_mask_a : 1;
bdrkreg_t imb_uart_ucntrl : 1;
bdrkreg_t imb_page_migration : 1;
bdrkreg_t imb_gfx_int_b : 1;
bdrkreg_t imb_gfx_int_a : 1;
bdrkreg_t imb_int_mask0_lo : 1;
} pi_int_mask0_b_fld_s;
} pi_int_mask0_b_u_t;
#endif
/************************************************************************
* *
* This read/write register masks the contents of INT_PEND1 to *
* determine whether an interrupt should be sent. Bits 63:32 always *
* generate an L3 interrupt (bit 11 of the processor's Cause *
* register) is sent to CPU_B if the same bit in the INT_PEND1 *
* register is set. Bits 31:0 can generate either an L3 or L2 *
* interrupt, depending on the value of INT_PEND1_REMAP[3:0]. Only *
* one processor in a Bedrock should enable the NI_ERROR, LB_ERROR, *
* XB_ERROR and MD_CORR_ERROR bits. *
* *
************************************************************************/
typedef union pi_int_mask1_b_u {
bdrkreg_t pi_int_mask1_b_regval;
struct {
bdrkreg_t imb_int_mask1 : 64;
} pi_int_mask1_b_fld_s;
} pi_int_mask1_b_u_t;
/************************************************************************
* *
* There is one of these registers for each CPU. These registers do *
* not have access protection. A store to this location by a CPU will *
* cause the bit corresponding to the source's region to be set in *
* CC_PEND_A (or CC_PEND_B). The contents of CC_PEND_A (or CC_PEND_B) *
* determines on a bit-per-region basis whether a CPU-to-CPU *
* interrupt is pending CPU_A (or CPU_B). *
* *
************************************************************************/
typedef union pi_cc_pend_set_a_u {
bdrkreg_t pi_cc_pend_set_a_regval;
struct {
bdrkreg_t cpsa_cc_pend : 64;
} pi_cc_pend_set_a_fld_s;
} pi_cc_pend_set_a_u_t;
/************************************************************************
* *
* There is one of these registers for each CPU. These registers do *
* not have access protection. A store to this location by a CPU will *
* cause the bit corresponding to the source's region to be set in *
* CC_PEND_A (or CC_PEND_B). The contents of CC_PEND_A (or CC_PEND_B) *
* determines on a bit-per-region basis whether a CPU-to-CPU *
* interrupt is pending CPU_A (or CPU_B). *
* *
************************************************************************/
typedef union pi_cc_pend_set_b_u {
bdrkreg_t pi_cc_pend_set_b_regval;
struct {
bdrkreg_t cpsb_cc_pend : 64;
} pi_cc_pend_set_b_fld_s;
} pi_cc_pend_set_b_u_t;
/************************************************************************
* *
* There is one of these registers for each CPU. Reading this *
* location will return the contents of CC_PEND_A (or CC_PEND_B). *
* Writing this location will clear the bits corresponding to which *
* data bits are driven high during the store; therefore, storing all *
* ones would clear all bits. *
* *
************************************************************************/
typedef union pi_cc_pend_clr_a_u {
bdrkreg_t pi_cc_pend_clr_a_regval;
struct {
bdrkreg_t cpca_cc_pend : 64;
} pi_cc_pend_clr_a_fld_s;
} pi_cc_pend_clr_a_u_t;
/************************************************************************
* *
* There is one of these registers for each CPU. Reading this *
* location will return the contents of CC_PEND_A (or CC_PEND_B). *
* Writing this location will clear the bits corresponding to which *
* data bits are driven high during the store; therefore, storing all *
* ones would clear all bits. *
* *
************************************************************************/
typedef union pi_cc_pend_clr_b_u {
bdrkreg_t pi_cc_pend_clr_b_regval;
struct {
bdrkreg_t cpcb_cc_pend : 64;
} pi_cc_pend_clr_b_fld_s;
} pi_cc_pend_clr_b_u_t;
/************************************************************************
* *
* This read/write register masks the contents of both CC_PEND_A and *
* CC_PEND_B. *
* *
************************************************************************/
typedef union pi_cc_mask_u {
bdrkreg_t pi_cc_mask_regval;
struct {
bdrkreg_t cm_cc_mask : 64;
} pi_cc_mask_fld_s;
} pi_cc_mask_u_t;
/************************************************************************
* *
* This read/write register redirects INT_PEND1[31:0] from L3 to L2 *
* interrupt level.Bit 4 in this register is used to enable error *
* interrupt forwarding to the II. When this bit is set, if any of *
* the three memory interrupts (correctable error, uncorrectable *
* error, or page migration), or the NI, LB or XB error interrupts *
* are set, the PI_II_ERROR_INT wire will be asserted. When this wire *
* is asserted, the II will send an interrupt to the node specified *
* in its IIDSR (Interrupt Destination Register). This allows these *
* interrupts to be forwarded to another node. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_int_pend1_remap_u {
bdrkreg_t pi_int_pend1_remap_regval;
struct {
bdrkreg_t ipr_remap_0 : 1;
bdrkreg_t ipr_remap_1 : 1;
bdrkreg_t ipr_remap_2 : 1;
bdrkreg_t ipr_remap_3 : 1;
bdrkreg_t ipr_error_forward : 1;
bdrkreg_t ipr_reserved : 59;
} pi_int_pend1_remap_fld_s;
} pi_int_pend1_remap_u_t;
#else
typedef union pi_int_pend1_remap_u {
bdrkreg_t pi_int_pend1_remap_regval;
struct {
bdrkreg_t ipr_reserved : 59;
bdrkreg_t ipr_error_forward : 1;
bdrkreg_t ipr_remap_3 : 1;
bdrkreg_t ipr_remap_2 : 1;
bdrkreg_t ipr_remap_1 : 1;
bdrkreg_t ipr_remap_0 : 1;
} pi_int_pend1_remap_fld_s;
} pi_int_pend1_remap_u_t;
#endif
/************************************************************************
* *
* There is one of these registers for each CPU. When the real time *
* counter (RT_Counter) is equal to the value in this register, the *
* RT_INT_PEND register is set, which causes a Level-4 interrupt to *
* be sent to the processor. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_rt_compare_a_u {
bdrkreg_t pi_rt_compare_a_regval;
struct {
bdrkreg_t rca_rt_compare : 55;
bdrkreg_t rca_rsvd : 9;
} pi_rt_compare_a_fld_s;
} pi_rt_compare_a_u_t;
#else
typedef union pi_rt_compare_a_u {
bdrkreg_t pi_rt_compare_a_regval;
struct {
bdrkreg_t rca_rsvd : 9;
bdrkreg_t rca_rt_compare : 55;
} pi_rt_compare_a_fld_s;
} pi_rt_compare_a_u_t;
#endif
/************************************************************************
* *
* There is one of these registers for each CPU. When the real time *
* counter (RT_Counter) is equal to the value in this register, the *
* RT_INT_PEND register is set, which causes a Level-4 interrupt to *
* be sent to the processor. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_rt_compare_b_u {
bdrkreg_t pi_rt_compare_b_regval;
struct {
bdrkreg_t rcb_rt_compare : 55;
bdrkreg_t rcb_rsvd : 9;
} pi_rt_compare_b_fld_s;
} pi_rt_compare_b_u_t;
#else
typedef union pi_rt_compare_b_u {
bdrkreg_t pi_rt_compare_b_regval;
struct {
bdrkreg_t rcb_rsvd : 9;
bdrkreg_t rcb_rt_compare : 55;
} pi_rt_compare_b_fld_s;
} pi_rt_compare_b_u_t;
#endif
/************************************************************************
* *
* When the least significant 32 bits of the real time counter *
* (RT_Counter) are equal to the value in this register, the *
* PROF_INT_PEND_A and PROF_INT_PEND_B registers are set to 0x1. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_profile_compare_u {
bdrkreg_t pi_profile_compare_regval;
struct {
bdrkreg_t pc_profile_compare : 32;
bdrkreg_t pc_rsvd : 32;
} pi_profile_compare_fld_s;
} pi_profile_compare_u_t;
#else
typedef union pi_profile_compare_u {
bdrkreg_t pi_profile_compare_regval;
struct {
bdrkreg_t pc_rsvd : 32;
bdrkreg_t pc_profile_compare : 32;
} pi_profile_compare_fld_s;
} pi_profile_compare_u_t;
#endif
/************************************************************************
* *
* There is one of these registers for each CPU. If the bit in the *
* corresponding RT_INT_EN_A/B register is set, the processor's level *
* 5 interrupt is set to the value of the RTC_INT_PEND bit in this *
* register. Storing any value to this location will clear the *
* RTC_INT_PEND bit in the register. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_rt_int_pend_a_u {
bdrkreg_t pi_rt_int_pend_a_regval;
struct {
bdrkreg_t ripa_rtc_int_pend : 1;
bdrkreg_t ripa_rsvd : 63;
} pi_rt_int_pend_a_fld_s;
} pi_rt_int_pend_a_u_t;
#else
typedef union pi_rt_int_pend_a_u {
bdrkreg_t pi_rt_int_pend_a_regval;
struct {
bdrkreg_t ripa_rsvd : 63;
bdrkreg_t ripa_rtc_int_pend : 1;
} pi_rt_int_pend_a_fld_s;
} pi_rt_int_pend_a_u_t;
#endif
/************************************************************************
* *
* There is one of these registers for each CPU. If the bit in the *
* corresponding RT_INT_EN_A/B register is set, the processor's level *
* 5 interrupt is set to the value of the RTC_INT_PEND bit in this *
* register. Storing any value to this location will clear the *
* RTC_INT_PEND bit in the register. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_rt_int_pend_b_u {
bdrkreg_t pi_rt_int_pend_b_regval;
struct {
bdrkreg_t ripb_rtc_int_pend : 1;
bdrkreg_t ripb_rsvd : 63;
} pi_rt_int_pend_b_fld_s;
} pi_rt_int_pend_b_u_t;
#else
typedef union pi_rt_int_pend_b_u {
bdrkreg_t pi_rt_int_pend_b_regval;
struct {
bdrkreg_t ripb_rsvd : 63;
bdrkreg_t ripb_rtc_int_pend : 1;
} pi_rt_int_pend_b_fld_s;
} pi_rt_int_pend_b_u_t;
#endif
/************************************************************************
* *
* There is one of these registers for each CPU. Both registers are *
* set when the PROFILE_COMPARE register is equal to bits [31:0] of *
* the RT_Counter. If the bit in the corresponding PROF_INT_EN_A/B *
* register is set, the processor's level 5 interrupt is set to the *
* value of the PROF_INT_PEND bit in this register. Storing any value *
* to this location will clear the PROF_INT_PEND bit in the register. *
* The reason for having A and B versions of this register is that *
* they need to be cleared independently. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_prof_int_pend_a_u {
bdrkreg_t pi_prof_int_pend_a_regval;
struct {
bdrkreg_t pipa_prof_int_pend : 1;
bdrkreg_t pipa_rsvd : 63;
} pi_prof_int_pend_a_fld_s;
} pi_prof_int_pend_a_u_t;
#else
typedef union pi_prof_int_pend_a_u {
bdrkreg_t pi_prof_int_pend_a_regval;
struct {
bdrkreg_t pipa_rsvd : 63;
bdrkreg_t pipa_prof_int_pend : 1;
} pi_prof_int_pend_a_fld_s;
} pi_prof_int_pend_a_u_t;
#endif
/************************************************************************
* *
* There is one of these registers for each CPU. Both registers are *
* set when the PROFILE_COMPARE register is equal to bits [31:0] of *
* the RT_Counter. If the bit in the corresponding PROF_INT_EN_A/B *
* register is set, the processor's level 5 interrupt is set to the *
* value of the PROF_INT_PEND bit in this register. Storing any value *
* to this location will clear the PROF_INT_PEND bit in the register. *
* The reason for having A and B versions of this register is that *
* they need to be cleared independently. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_prof_int_pend_b_u {
bdrkreg_t pi_prof_int_pend_b_regval;
struct {
bdrkreg_t pipb_prof_int_pend : 1;
bdrkreg_t pipb_rsvd : 63;
} pi_prof_int_pend_b_fld_s;
} pi_prof_int_pend_b_u_t;
#else
typedef union pi_prof_int_pend_b_u {
bdrkreg_t pi_prof_int_pend_b_regval;
struct {
bdrkreg_t pipb_rsvd : 63;
bdrkreg_t pipb_prof_int_pend : 1;
} pi_prof_int_pend_b_fld_s;
} pi_prof_int_pend_b_u_t;
#endif
/************************************************************************
* *
* There is one of these registers for each CPU. Enables RTC *
* interrupt to the associated CPU. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_rt_int_en_a_u {
bdrkreg_t pi_rt_int_en_a_regval;
struct {
bdrkreg_t riea_rtc_int_en : 1;
bdrkreg_t riea_rsvd : 63;
} pi_rt_int_en_a_fld_s;
} pi_rt_int_en_a_u_t;
#else
typedef union pi_rt_int_en_a_u {
bdrkreg_t pi_rt_int_en_a_regval;
struct {
bdrkreg_t riea_rsvd : 63;
bdrkreg_t riea_rtc_int_en : 1;
} pi_rt_int_en_a_fld_s;
} pi_rt_int_en_a_u_t;
#endif
/************************************************************************
* *
* There is one of these registers for each CPU. Enables RTC *
* interrupt to the associated CPU. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_rt_int_en_b_u {
bdrkreg_t pi_rt_int_en_b_regval;
struct {
bdrkreg_t rieb_rtc_int_en : 1;
bdrkreg_t rieb_rsvd : 63;
} pi_rt_int_en_b_fld_s;
} pi_rt_int_en_b_u_t;
#else
typedef union pi_rt_int_en_b_u {
bdrkreg_t pi_rt_int_en_b_regval;
struct {
bdrkreg_t rieb_rsvd : 63;
bdrkreg_t rieb_rtc_int_en : 1;
} pi_rt_int_en_b_fld_s;
} pi_rt_int_en_b_u_t;
#endif
/************************************************************************
* *
* There is one of these registers for each CPU. Enables profiling *
* interrupt to the associated CPU. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_prof_int_en_a_u {
bdrkreg_t pi_prof_int_en_a_regval;
struct {
bdrkreg_t piea_prof_int_en : 1;
bdrkreg_t piea_rsvd : 63;
} pi_prof_int_en_a_fld_s;
} pi_prof_int_en_a_u_t;
#else
typedef union pi_prof_int_en_a_u {
bdrkreg_t pi_prof_int_en_a_regval;
struct {
bdrkreg_t piea_rsvd : 63;
bdrkreg_t piea_prof_int_en : 1;
} pi_prof_int_en_a_fld_s;
} pi_prof_int_en_a_u_t;
#endif
/************************************************************************
* *
* There is one of these registers for each CPU. Enables profiling *
* interrupt to the associated CPU. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_prof_int_en_b_u {
bdrkreg_t pi_prof_int_en_b_regval;
struct {
bdrkreg_t pieb_prof_int_en : 1;
bdrkreg_t pieb_rsvd : 63;
} pi_prof_int_en_b_fld_s;
} pi_prof_int_en_b_u_t;
#else
typedef union pi_prof_int_en_b_u {
bdrkreg_t pi_prof_int_en_b_regval;
struct {
bdrkreg_t pieb_rsvd : 63;
bdrkreg_t pieb_prof_int_en : 1;
} pi_prof_int_en_b_fld_s;
} pi_prof_int_en_b_u_t;
#endif
/************************************************************************
* *
* This register controls operation of the debug data from the PI, *
* along with Debug_Sel[2:0] from the Debug module. For some values *
* of Debug_Sel[2:0], the B_SEL bit selects whether the debug bits *
* are looking at the processor A or processor B logic. The remaining *
* bits select which signal(s) are ORed to create DebugData bits 31 *
* and 30 for all of the PI debug selections. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_debug_sel_u {
bdrkreg_t pi_debug_sel_regval;
struct {
bdrkreg_t ds_low_t5cc_a : 1;
bdrkreg_t ds_low_t5cc_b : 1;
bdrkreg_t ds_low_totcc_a : 1;
bdrkreg_t ds_low_totcc_b : 1;
bdrkreg_t ds_low_reqcc_a : 1;
bdrkreg_t ds_low_reqcc_b : 1;
bdrkreg_t ds_low_rplcc_a : 1;
bdrkreg_t ds_low_rplcc_b : 1;
bdrkreg_t ds_low_intcc : 1;
bdrkreg_t ds_low_perf_inc_a_0 : 1;
bdrkreg_t ds_low_perf_inc_a_1 : 1;
bdrkreg_t ds_low_perf_inc_b_0 : 1;
bdrkreg_t ds_low_perf_inc_b_1 : 1;
bdrkreg_t ds_high_t5cc_a : 1;
bdrkreg_t ds_high_t5cc_b : 1;
bdrkreg_t ds_high_totcc_a : 1;
bdrkreg_t ds_high_totcc_b : 1;
bdrkreg_t ds_high_reqcc_a : 1;
bdrkreg_t ds_high_reqcc_b : 1;
bdrkreg_t ds_high_rplcc_a : 1;
bdrkreg_t ds_high_rplcc_b : 1;
bdrkreg_t ds_high_intcc : 1;
bdrkreg_t ds_high_perf_inc_a_0 : 1;
bdrkreg_t ds_high_perf_inc_a_1 : 1;
bdrkreg_t ds_high_perf_inc_b_0 : 1;
bdrkreg_t ds_high_perf_inc_b_1 : 1;
bdrkreg_t ds_b_sel : 1;
bdrkreg_t ds_rsvd : 37;
} pi_debug_sel_fld_s;
} pi_debug_sel_u_t;
#else
typedef union pi_debug_sel_u {
bdrkreg_t pi_debug_sel_regval;
struct {
bdrkreg_t ds_rsvd : 37;
bdrkreg_t ds_b_sel : 1;
bdrkreg_t ds_high_perf_inc_b_1 : 1;
bdrkreg_t ds_high_perf_inc_b_0 : 1;
bdrkreg_t ds_high_perf_inc_a_1 : 1;
bdrkreg_t ds_high_perf_inc_a_0 : 1;
bdrkreg_t ds_high_intcc : 1;
bdrkreg_t ds_high_rplcc_b : 1;
bdrkreg_t ds_high_rplcc_a : 1;
bdrkreg_t ds_high_reqcc_b : 1;
bdrkreg_t ds_high_reqcc_a : 1;
bdrkreg_t ds_high_totcc_b : 1;
bdrkreg_t ds_high_totcc_a : 1;
bdrkreg_t ds_high_t5cc_b : 1;
bdrkreg_t ds_high_t5cc_a : 1;
bdrkreg_t ds_low_perf_inc_b_1 : 1;
bdrkreg_t ds_low_perf_inc_b_0 : 1;
bdrkreg_t ds_low_perf_inc_a_1 : 1;
bdrkreg_t ds_low_perf_inc_a_0 : 1;
bdrkreg_t ds_low_intcc : 1;
bdrkreg_t ds_low_rplcc_b : 1;
bdrkreg_t ds_low_rplcc_a : 1;
bdrkreg_t ds_low_reqcc_b : 1;
bdrkreg_t ds_low_reqcc_a : 1;
bdrkreg_t ds_low_totcc_b : 1;
bdrkreg_t ds_low_totcc_a : 1;
bdrkreg_t ds_low_t5cc_b : 1;
bdrkreg_t ds_low_t5cc_a : 1;
} pi_debug_sel_fld_s;
} pi_debug_sel_u_t;
#endif
/************************************************************************
* *
* A write to this register allows a single bit in the INT_PEND0 or *
* INT_PEND1 registers to be set or cleared. If 6 is clear, a bit is *
* modified in INT_PEND0, while if 6 is set, a bit is modified in *
* INT_PEND1. The value in 5:0 (ranging from 63 to 0) will determine *
* which bit in the register is effected. The value of 8 will *
* determine whether the desired bit is set (8=1) or cleared (8=0). *
* This is the only register which is accessible by IO issued PWRI *
* command and is protected through the IO_PROTECT register. If the *
* region bit in the IO_PROTECT is not set then a WERR reply is *
* issued. CPU access is controlled through CPU_PROTECT. The contents *
* of this register are masked with the contents of INT_MASK_A *
* (INT_MASK_B) to determine whether an L2 interrupt is issued to *
* CPU_A (CPU_B). *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_int_pend_mod_alias_u {
bdrkreg_t pi_int_pend_mod_alias_regval;
struct {
bdrkreg_t ipma_bit_select : 6;
bdrkreg_t ipma_reg_select : 1;
bdrkreg_t ipma_rsvd_1 : 1;
bdrkreg_t ipma_value : 1;
bdrkreg_t ipma_rsvd : 55;
} pi_int_pend_mod_alias_fld_s;
} pi_int_pend_mod_alias_u_t;
#else
typedef union pi_int_pend_mod_alias_u {
bdrkreg_t pi_int_pend_mod_alias_regval;
struct {
bdrkreg_t ipma_rsvd : 55;
bdrkreg_t ipma_value : 1;
bdrkreg_t ipma_rsvd_1 : 1;
bdrkreg_t ipma_reg_select : 1;
bdrkreg_t ipma_bit_select : 6;
} pi_int_pend_mod_alias_fld_s;
} pi_int_pend_mod_alias_u_t;
#endif
/************************************************************************
* *
* There is one of these registers for each CPU. This register *
* specifies the value of the Graphics Page. Uncached writes into the *
* Graphics Page (with uncached attribute of IO) are done with GFXWS *
* commands rather than the normal PWRI commands. GFXWS commands are *
* tracked with the graphics credit counters. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_gfx_page_a_u {
bdrkreg_t pi_gfx_page_a_regval;
struct {
bdrkreg_t gpa_rsvd_1 : 17;
bdrkreg_t gpa_gfx_page_addr : 23;
bdrkreg_t gpa_en_gfx_page : 1;
bdrkreg_t gpa_rsvd : 23;
} pi_gfx_page_a_fld_s;
} pi_gfx_page_a_u_t;
#else
typedef union pi_gfx_page_a_u {
bdrkreg_t pi_gfx_page_a_regval;
struct {
bdrkreg_t gpa_rsvd : 23;
bdrkreg_t gpa_en_gfx_page : 1;
bdrkreg_t gpa_gfx_page_addr : 23;
bdrkreg_t gpa_rsvd_1 : 17;
} pi_gfx_page_a_fld_s;
} pi_gfx_page_a_u_t;
#endif
/************************************************************************
* *
* There is one of these registers for each CPU. This register *
* counts graphics credits. This counter is decremented for each *
* doubleword sent to graphics with GFXWS or GFXWL commands. It is *
* incremented for each doubleword acknowledge from graphics. When *
* this counter has a smaller value than the GFX_BIAS register, *
* SysWrRdy_L is deasserted, an interrupt is sent to the processor, *
* and SysWrRdy_L is allowed to be asserted again. This is the basic *
* mechanism for flow-controlling graphics writes. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_gfx_credit_cntr_a_u {
bdrkreg_t pi_gfx_credit_cntr_a_regval;
struct {
bdrkreg_t gcca_gfx_credit_cntr : 12;
bdrkreg_t gcca_rsvd : 52;
} pi_gfx_credit_cntr_a_fld_s;
} pi_gfx_credit_cntr_a_u_t;
#else
typedef union pi_gfx_credit_cntr_a_u {
bdrkreg_t pi_gfx_credit_cntr_a_regval;
struct {
bdrkreg_t gcca_rsvd : 52;
bdrkreg_t gcca_gfx_credit_cntr : 12;
} pi_gfx_credit_cntr_a_fld_s;
} pi_gfx_credit_cntr_a_u_t;
#endif
/************************************************************************
* *
* There is one of these registers for each CPU. When the graphics *
* credit counter is less than or equal to this value, a flow control *
* interrupt is sent. *
* *
************************************************************************/
#ifdef LITTLE_ENDIAN
typedef union pi_gfx_bias_a_u {
bdrkreg_t pi_gfx_bias_a_regval;
struct {
bdrkreg_t gba_gfx_bias : 12;
bdrkreg_t gba_rsvd : 52;
} pi_gfx_bias_a_fld_s;
} pi_gfx_bias_a_u_t;
#else
typedef union pi_gfx_bias_a_u {
bdrkreg_t pi_gfx_bias_a_regval;
struct {