| /* SPDX-License-Identifier: GPL-2.0 |
| * |
| * Copyright (C) 2020 Marvell International Ltd. |
| * |
| * https://spdx.org/licenses |
| */ |
| #ifndef __CSRS_NPA_H__ |
| #define __CSRS_NPA_H__ |
| |
| /** |
| * @file |
| * |
| * Configuration and status register (CSR) address and type definitions for |
| * NPA. |
| * |
| * This file is auto generated. Do not edit. |
| * |
| */ |
| |
| /** |
| * Enumeration npa_af_int_vec_e |
| * |
| * NPA Admin Function Interrupt Vector Enumeration Enumerates the NPA AF |
| * MSI-X interrupt vectors. |
| */ |
| #define NPA_AF_INT_VEC_E_AF_ERR (3) |
| #define NPA_AF_INT_VEC_E_AQ_DONE (2) |
| #define NPA_AF_INT_VEC_E_GEN (1) |
| #define NPA_AF_INT_VEC_E_POISON (4) |
| #define NPA_AF_INT_VEC_E_RVU (0) |
| |
| /** |
| * Enumeration npa_aq_comp_e |
| * |
| * NPA Admin Queue Completion Enumeration Enumerates the values of |
| * NPA_AQ_RES_S[COMPCODE]. |
| */ |
| #define NPA_AQ_COMP_E_CTX_FAULT (4) |
| #define NPA_AQ_COMP_E_CTX_POISON (3) |
| #define NPA_AQ_COMP_E_GOOD (1) |
| #define NPA_AQ_COMP_E_LOCKERR (5) |
| #define NPA_AQ_COMP_E_NOTDONE (0) |
| #define NPA_AQ_COMP_E_SWERR (2) |
| |
| /** |
| * Enumeration npa_aq_ctype_e |
| * |
| * NPA Admin Queue Context Type Enumeration Enumerates |
| * NPA_AQ_INST_S[CTYPE] values. |
| */ |
| #define NPA_AQ_CTYPE_E_AURA (0) |
| #define NPA_AQ_CTYPE_E_POOL (1) |
| |
| /** |
| * Enumeration npa_aq_instop_e |
| * |
| * NPA Admin Queue Opcode Enumeration Enumerates NPA_AQ_INST_S[OP] |
| * values. |
| */ |
| #define NPA_AQ_INSTOP_E_INIT (1) |
| #define NPA_AQ_INSTOP_E_LOCK (4) |
| #define NPA_AQ_INSTOP_E_NOP (0) |
| #define NPA_AQ_INSTOP_E_READ (3) |
| #define NPA_AQ_INSTOP_E_UNLOCK (5) |
| #define NPA_AQ_INSTOP_E_WRITE (2) |
| |
| /** |
| * Enumeration npa_aura_err_int_e |
| * |
| * NPA Aura Error Interrupt Enumeration Enumerates the bit index of |
| * NPA_AURA_S[ERR_INT], and NPA_AURA_S[ERR_INT_ENA]. |
| */ |
| #define NPA_AURA_ERR_INT_E_AURA_ADD_OVER (1) |
| #define NPA_AURA_ERR_INT_E_AURA_ADD_UNDER (2) |
| #define NPA_AURA_ERR_INT_E_AURA_FREE_UNDER (0) |
| #define NPA_AURA_ERR_INT_E_POOL_DIS (3) |
| #define NPA_AURA_ERR_INT_E_RX(a) (0 + (a)) |
| |
| /** |
| * Enumeration npa_bpintf_e |
| * |
| * NPA Backpressure Interface Enumeration Enumerates index of |
| * NPA_AURA_S[BP_ENA]. |
| */ |
| #define NPA_BPINTF_E_NIXX_RX(a) (0 + (a)) |
| |
| /** |
| * Enumeration npa_inpq_e |
| * |
| * NPA Input Queue Enumeration Enumerates ALLOC/FREE input queues from |
| * coprocessors. |
| */ |
| #define NPA_INPQ_E_AURA_OP (0xe) |
| #define NPA_INPQ_E_BPHY (7) |
| #define NPA_INPQ_E_DPI (6) |
| #define NPA_INPQ_E_INTERNAL_RSV (0xf) |
| #define NPA_INPQ_E_NIXX_RX(a) (0 + 2 * (a)) |
| #define NPA_INPQ_E_NIXX_TX(a) (1 + 2 * (a)) |
| #define NPA_INPQ_E_RX(a) (0 + (a)) |
| #define NPA_INPQ_E_SSO (4) |
| #define NPA_INPQ_E_TIM (5) |
| |
| /** |
| * Enumeration npa_lf_int_vec_e |
| * |
| * NPA Local Function Interrupt Vector Enumeration Enumerates the NPA |
| * MSI-X interrupt vectors per LF. |
| */ |
| #define NPA_LF_INT_VEC_E_ERR_INT (0x40) |
| #define NPA_LF_INT_VEC_E_POISON (0x41) |
| #define NPA_LF_INT_VEC_E_QINTX(a) (0 + (a)) |
| |
| /** |
| * Enumeration npa_ndc0_port_e |
| * |
| * NPA NDC0 Port Enumeration Enumerates NPA NDC0 (NDC_IDX_E::NPA_U(0)) |
| * ports and the PORT index of NDC_AF_PORT()_RT()_RW()_REQ_PC and |
| * NDC_AF_PORT()_RT()_RW()_LAT_PC. |
| */ |
| #define NPA_NDC0_PORT_E_AURA0 (0) |
| #define NPA_NDC0_PORT_E_AURA1 (1) |
| #define NPA_NDC0_PORT_E_POOL0 (2) |
| #define NPA_NDC0_PORT_E_POOL1 (3) |
| #define NPA_NDC0_PORT_E_STACK0 (4) |
| #define NPA_NDC0_PORT_E_STACK1 (5) |
| |
| /** |
| * Enumeration npa_pool_err_int_e |
| * |
| * NPA Pool Error Interrupt Enumeration Enumerates the bit index of |
| * NPA_POOL_S[ERR_INT] and NPA_POOL_S[ERR_INT_ENA]. |
| */ |
| #define NPA_POOL_ERR_INT_E_OVFLS (0) |
| #define NPA_POOL_ERR_INT_E_PERR (2) |
| #define NPA_POOL_ERR_INT_E_RX(a) (0 + (a)) |
| #define NPA_POOL_ERR_INT_E_RANGE (1) |
| |
| /** |
| * Structure npa_aq_inst_s |
| * |
| * NPA Admin Queue Instruction Structure This structure specifies the AQ |
| * instruction. Instructions and associated software structures are |
| * stored in memory as little-endian unless NPA_AF_GEN_CFG[AF_BE] is set. |
| * Hardware reads of NPA_AQ_INST_S do not allocate into LLC. Hardware |
| * reads and writes of the context structure selected by [CTYPE], [LF] |
| * and [CINDEX] use the NDC and LLC caching style configured for that |
| * context, i.e.: * NPA_AURA_HW_S reads and writes use |
| * NPA_AF_LF()_AURAS_CFG[CACHING] and NPA_AF_LF()_AURAS_CFG[WAY_MASK]. * |
| * NPA_POOL_HW_S reads and writes use NPA_AURA_HW_S[POOL_CACHING] and |
| * NPA_AURA_HW_S[POOL_WAY_MASK]. |
| */ |
| union npa_aq_inst_s { |
| u64 u[2]; |
| struct npa_aq_inst_s_s { |
| u64 op : 4; |
| u64 ctype : 4; |
| u64 lf : 9; |
| u64 reserved_17_23 : 7; |
| u64 cindex : 20; |
| u64 reserved_44_62 : 19; |
| u64 doneint : 1; |
| u64 res_addr : 64; |
| } s; |
| /* struct npa_aq_inst_s_s cn; */ |
| }; |
| |
| /** |
| * Structure npa_aq_res_s |
| * |
| * NPA Admin Queue Result Structure NPA writes this structure after it |
| * completes the NPA_AQ_INST_S instruction. The result structure is |
| * exactly 16 bytes, and each instruction completion produces exactly one |
| * result structure. Results and associated software structures are |
| * stored in memory as little-endian unless NPA_AF_GEN_CFG[AF_BE] is set. |
| * When [OP] = NPA_AQ_INSTOP_E::INIT, WRITE or READ, this structure is |
| * immediately followed by context read or write data. See |
| * NPA_AQ_INSTOP_E. Hardware writes of NPA_AQ_RES_S and context data |
| * always allocate into LLC. Hardware reads of context data do not |
| * allocate into LLC. |
| */ |
| union npa_aq_res_s { |
| u64 u[2]; |
| struct npa_aq_res_s_s { |
| u64 op : 4; |
| u64 ctype : 4; |
| u64 compcode : 8; |
| u64 doneint : 1; |
| u64 reserved_17_63 : 47; |
| u64 reserved_64_127 : 64; |
| } s; |
| /* struct npa_aq_res_s_s cn; */ |
| }; |
| |
| /** |
| * Structure npa_aura_op_wdata_s |
| * |
| * NPA Aura Operation Write Data Structure This structure specifies the |
| * write data format of a 64-bit atomic load-and-add to |
| * NPA_LF_AURA_OP_ALLOC() and NPA_LF_POOL_OP_PC, and a 128-bit atomic |
| * CASP operation to NPA_LF_AURA_OP_ALLOC(). |
| */ |
| union npa_aura_op_wdata_s { |
| u64 u; |
| struct npa_aura_op_wdata_s_s { |
| u64 aura : 20; |
| u64 reserved_20_62 : 43; |
| u64 drop : 1; |
| } s; |
| /* struct npa_aura_op_wdata_s_s cn; */ |
| }; |
| |
| /** |
| * Structure npa_aura_s |
| * |
| * NPA Aura Context Structure This structure specifies the format used by |
| * software with the NPA admin queue to read and write an aura's |
| * NPA_AURA_HW_S structure maintained by hardware in LLC/DRAM. |
| */ |
| union npa_aura_s { |
| u64 u[8]; |
| struct npa_aura_s_s { |
| u64 pool_addr : 64; |
| u64 ena : 1; |
| u64 reserved_65_66 : 2; |
| u64 pool_caching : 1; |
| u64 pool_way_mask : 16; |
| u64 avg_con : 9; |
| u64 reserved_93 : 1; |
| u64 pool_drop_ena : 1; |
| u64 aura_drop_ena : 1; |
| u64 bp_ena : 2; |
| u64 reserved_98_103 : 6; |
| u64 aura_drop : 8; |
| u64 shift : 6; |
| u64 reserved_118_119 : 2; |
| u64 avg_level : 8; |
| u64 count : 36; |
| u64 reserved_164_167 : 4; |
| u64 nix0_bpid : 9; |
| u64 reserved_177_179 : 3; |
| u64 nix1_bpid : 9; |
| u64 reserved_189_191 : 3; |
| u64 limit : 36; |
| u64 reserved_228_231 : 4; |
| u64 bp : 8; |
| u64 reserved_240_243 : 4; |
| u64 fc_ena : 1; |
| u64 fc_up_crossing : 1; |
| u64 fc_stype : 2; |
| u64 fc_hyst_bits : 4; |
| u64 reserved_252_255 : 4; |
| u64 fc_addr : 64; |
| u64 pool_drop : 8; |
| u64 update_time : 16; |
| u64 err_int : 8; |
| u64 err_int_ena : 8; |
| u64 thresh_int : 1; |
| u64 thresh_int_ena : 1; |
| u64 thresh_up : 1; |
| u64 reserved_363 : 1; |
| u64 thresh_qint_idx : 7; |
| u64 reserved_371 : 1; |
| u64 err_qint_idx : 7; |
| u64 reserved_379_383 : 5; |
| u64 thresh : 36; |
| u64 reserved_420_447 : 28; |
| u64 reserved_448_511 : 64; |
| } s; |
| /* struct npa_aura_s_s cn; */ |
| }; |
| |
| /** |
| * Structure npa_pool_s |
| * |
| * NPA Pool Context Structure This structure specifies the format used by |
| * software with the NPA admin queue to read and write a pool's |
| * NPA_POOL_HW_S structure maintained by hardware in LLC/DRAM. |
| */ |
| union npa_pool_s { |
| u64 u[16]; |
| struct npa_pool_s_s { |
| u64 stack_base : 64; |
| u64 ena : 1; |
| u64 nat_align : 1; |
| u64 reserved_66_67 : 2; |
| u64 stack_caching : 1; |
| u64 reserved_69_71 : 3; |
| u64 stack_way_mask : 16; |
| u64 buf_offset : 12; |
| u64 reserved_100_103 : 4; |
| u64 buf_size : 11; |
| u64 reserved_115_127 : 13; |
| u64 stack_max_pages : 32; |
| u64 stack_pages : 32; |
| u64 op_pc : 48; |
| u64 reserved_240_255 : 16; |
| u64 stack_offset : 4; |
| u64 reserved_260_263 : 4; |
| u64 shift : 6; |
| u64 reserved_270_271 : 2; |
| u64 avg_level : 8; |
| u64 avg_con : 9; |
| u64 fc_ena : 1; |
| u64 fc_stype : 2; |
| u64 fc_hyst_bits : 4; |
| u64 fc_up_crossing : 1; |
| u64 reserved_297_299 : 3; |
| u64 update_time : 16; |
| u64 reserved_316_319 : 4; |
| u64 fc_addr : 64; |
| u64 ptr_start : 64; |
| u64 ptr_end : 64; |
| u64 reserved_512_535 : 24; |
| u64 err_int : 8; |
| u64 err_int_ena : 8; |
| u64 thresh_int : 1; |
| u64 thresh_int_ena : 1; |
| u64 thresh_up : 1; |
| u64 reserved_555 : 1; |
| u64 thresh_qint_idx : 7; |
| u64 reserved_563 : 1; |
| u64 err_qint_idx : 7; |
| u64 reserved_571_575 : 5; |
| u64 thresh : 36; |
| u64 reserved_612_639 : 28; |
| u64 reserved_640_703 : 64; |
| u64 reserved_704_767 : 64; |
| u64 reserved_768_831 : 64; |
| u64 reserved_832_895 : 64; |
| u64 reserved_896_959 : 64; |
| u64 reserved_960_1023 : 64; |
| } s; |
| /* struct npa_pool_s_s cn; */ |
| }; |
| |
| /** |
| * Structure npa_qint_hw_s |
| * |
| * NPA Queue Interrupt Context Hardware Structure This structure contains |
| * context state maintained by hardware for each queue interrupt (QINT) |
| * in NDC/LLC/DRAM. Software accesses this structure with the |
| * NPA_LF_QINT()_* registers. Hardware maintains a table of |
| * NPA_AF_CONST[QINTS] contiguous NPA_QINT_HW_S structures per LF |
| * starting at IOVA NPA_AF_LF()_QINTS_BASE. Always stored in byte |
| * invariant little-endian format (LE8). |
| */ |
| union npa_qint_hw_s { |
| u32 u; |
| struct npa_qint_hw_s_s { |
| u32 count : 22; |
| u32 reserved_22_30 : 9; |
| u32 ena : 1; |
| } s; |
| /* struct npa_qint_hw_s_s cn; */ |
| }; |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_active_cycles_pc |
| * |
| * NPA AF Active Cycles Register |
| */ |
| union npa_af_active_cycles_pc { |
| u64 u; |
| struct npa_af_active_cycles_pc_s { |
| u64 act_cyc : 64; |
| } s; |
| /* struct npa_af_active_cycles_pc_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_ACTIVE_CYCLES_PC(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_ACTIVE_CYCLES_PC(void) |
| { |
| return 0xf0; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_aq_base |
| * |
| * NPA AF Admin Queue Base Address Register |
| */ |
| union npa_af_aq_base { |
| u64 u; |
| struct npa_af_aq_base_s { |
| u64 reserved_0_6 : 7; |
| u64 base_addr : 46; |
| u64 reserved_53_63 : 11; |
| } s; |
| /* struct npa_af_aq_base_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_AQ_BASE(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_AQ_BASE(void) |
| { |
| return 0x610; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_aq_cfg |
| * |
| * NPA AF Admin Queue Configuration Register |
| */ |
| union npa_af_aq_cfg { |
| u64 u; |
| struct npa_af_aq_cfg_s { |
| u64 qsize : 4; |
| u64 reserved_4_63 : 60; |
| } s; |
| /* struct npa_af_aq_cfg_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_AQ_CFG(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_AQ_CFG(void) |
| { |
| return 0x600; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_aq_done |
| * |
| * NPA AF AQ Done Count Register |
| */ |
| union npa_af_aq_done { |
| u64 u; |
| struct npa_af_aq_done_s { |
| u64 done : 20; |
| u64 reserved_20_63 : 44; |
| } s; |
| /* struct npa_af_aq_done_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_AQ_DONE(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_AQ_DONE(void) |
| { |
| return 0x650; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_aq_done_ack |
| * |
| * NPA AF AQ Done Count Ack Register This register is written by software |
| * to acknowledge interrupts. |
| */ |
| union npa_af_aq_done_ack { |
| u64 u; |
| struct npa_af_aq_done_ack_s { |
| u64 done_ack : 20; |
| u64 reserved_20_63 : 44; |
| } s; |
| /* struct npa_af_aq_done_ack_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_AQ_DONE_ACK(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_AQ_DONE_ACK(void) |
| { |
| return 0x660; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_aq_done_ena_w1c |
| * |
| * NPA AF AQ Done Interrupt Enable Clear Register This register clears |
| * interrupt enable bits. |
| */ |
| union npa_af_aq_done_ena_w1c { |
| u64 u; |
| struct npa_af_aq_done_ena_w1c_s { |
| u64 done : 1; |
| u64 reserved_1_63 : 63; |
| } s; |
| /* struct npa_af_aq_done_ena_w1c_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_AQ_DONE_ENA_W1C(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_AQ_DONE_ENA_W1C(void) |
| { |
| return 0x698; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_aq_done_ena_w1s |
| * |
| * NPA AF AQ Done Interrupt Enable Set Register This register sets |
| * interrupt enable bits. |
| */ |
| union npa_af_aq_done_ena_w1s { |
| u64 u; |
| struct npa_af_aq_done_ena_w1s_s { |
| u64 done : 1; |
| u64 reserved_1_63 : 63; |
| } s; |
| /* struct npa_af_aq_done_ena_w1s_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_AQ_DONE_ENA_W1S(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_AQ_DONE_ENA_W1S(void) |
| { |
| return 0x690; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_aq_done_int |
| * |
| * NPA AF AQ Done Interrupt Register |
| */ |
| union npa_af_aq_done_int { |
| u64 u; |
| struct npa_af_aq_done_int_s { |
| u64 done : 1; |
| u64 reserved_1_63 : 63; |
| } s; |
| /* struct npa_af_aq_done_int_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_AQ_DONE_INT(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_AQ_DONE_INT(void) |
| { |
| return 0x680; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_aq_done_int_w1s |
| * |
| * INTERNAL: NPA AF AQ Done Interrupt Set Register |
| */ |
| union npa_af_aq_done_int_w1s { |
| u64 u; |
| struct npa_af_aq_done_int_w1s_s { |
| u64 done : 1; |
| u64 reserved_1_63 : 63; |
| } s; |
| /* struct npa_af_aq_done_int_w1s_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_AQ_DONE_INT_W1S(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_AQ_DONE_INT_W1S(void) |
| { |
| return 0x688; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_aq_done_timer |
| * |
| * NPA AF Admin Queue Done Interrupt Timer Register Used to debug the |
| * queue interrupt coalescing timer. |
| */ |
| union npa_af_aq_done_timer { |
| u64 u; |
| struct npa_af_aq_done_timer_s { |
| u64 count : 16; |
| u64 reserved_16_63 : 48; |
| } s; |
| /* struct npa_af_aq_done_timer_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_AQ_DONE_TIMER(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_AQ_DONE_TIMER(void) |
| { |
| return 0x670; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_aq_done_wait |
| * |
| * NPA AF AQ Done Interrupt Coalescing Wait Register Specifies the queue |
| * interrupt coalescing settings. |
| */ |
| union npa_af_aq_done_wait { |
| u64 u; |
| struct npa_af_aq_done_wait_s { |
| u64 num_wait : 20; |
| u64 reserved_20_31 : 12; |
| u64 time_wait : 16; |
| u64 reserved_48_63 : 16; |
| } s; |
| /* struct npa_af_aq_done_wait_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_AQ_DONE_WAIT(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_AQ_DONE_WAIT(void) |
| { |
| return 0x640; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_aq_door |
| * |
| * NPA AF Admin Queue Doorbell Register Software writes to this register |
| * to enqueue one or more entries to AQ. |
| */ |
| union npa_af_aq_door { |
| u64 u; |
| struct npa_af_aq_door_s { |
| u64 count : 16; |
| u64 reserved_16_63 : 48; |
| } s; |
| /* struct npa_af_aq_door_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_AQ_DOOR(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_AQ_DOOR(void) |
| { |
| return 0x630; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_aq_status |
| * |
| * NPA AF Admin Queue Status Register |
| */ |
| union npa_af_aq_status { |
| u64 u; |
| struct npa_af_aq_status_s { |
| u64 reserved_0_3 : 4; |
| u64 head_ptr : 20; |
| u64 reserved_24_35 : 12; |
| u64 tail_ptr : 20; |
| u64 reserved_56_61 : 6; |
| u64 aq_busy : 1; |
| u64 aq_err : 1; |
| } s; |
| struct npa_af_aq_status_cn { |
| u64 reserved_0_3 : 4; |
| u64 head_ptr : 20; |
| u64 reserved_24_31 : 8; |
| u64 reserved_32_35 : 4; |
| u64 tail_ptr : 20; |
| u64 reserved_56_61 : 6; |
| u64 aq_busy : 1; |
| u64 aq_err : 1; |
| } cn; |
| }; |
| |
| static inline u64 NPA_AF_AQ_STATUS(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_AQ_STATUS(void) |
| { |
| return 0x620; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_avg_delay |
| * |
| * NPA AF Queue Average Delay Register |
| */ |
| union npa_af_avg_delay { |
| u64 u; |
| struct npa_af_avg_delay_s { |
| u64 avg_dly : 19; |
| u64 reserved_19_23 : 5; |
| u64 avg_timer : 16; |
| u64 reserved_40_62 : 23; |
| u64 avg_timer_dis : 1; |
| } s; |
| /* struct npa_af_avg_delay_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_AVG_DELAY(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_AVG_DELAY(void) |
| { |
| return 0x100; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_bar2_alias# |
| * |
| * INTERNAL: NPA Admin Function BAR2 Alias Registers These registers |
| * alias to the NPA BAR2 registers for the PF and function selected by |
| * NPA_AF_BAR2_SEL[PF_FUNC]. Internal: Not implemented. Placeholder for |
| * bug33464. |
| */ |
| union npa_af_bar2_aliasx { |
| u64 u; |
| struct npa_af_bar2_aliasx_s { |
| u64 data : 64; |
| } s; |
| /* struct npa_af_bar2_aliasx_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_BAR2_ALIASX(u64 a) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_BAR2_ALIASX(u64 a) |
| { |
| return 0x9100000 + 8 * a; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_bar2_sel |
| * |
| * INTERNAL: NPA Admin Function BAR2 Select Register This register |
| * configures BAR2 accesses from the NPA_AF_BAR2_ALIAS() registers in |
| * BAR0. Internal: Not implemented. Placeholder for bug33464. |
| */ |
| union npa_af_bar2_sel { |
| u64 u; |
| struct npa_af_bar2_sel_s { |
| u64 alias_pf_func : 16; |
| u64 alias_ena : 1; |
| u64 reserved_17_63 : 47; |
| } s; |
| /* struct npa_af_bar2_sel_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_BAR2_SEL(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_BAR2_SEL(void) |
| { |
| return 0x9000000; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_blk_rst |
| * |
| * NPA AF Block Reset Register |
| */ |
| union npa_af_blk_rst { |
| u64 u; |
| struct npa_af_blk_rst_s { |
| u64 rst : 1; |
| u64 reserved_1_62 : 62; |
| u64 busy : 1; |
| } s; |
| /* struct npa_af_blk_rst_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_BLK_RST(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_BLK_RST(void) |
| { |
| return 0; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_bp_test |
| * |
| * INTERNAL: NPA AF Backpressure Test Register |
| */ |
| union npa_af_bp_test { |
| u64 u; |
| struct npa_af_bp_test_s { |
| u64 lfsr_freq : 12; |
| u64 reserved_12_15 : 4; |
| u64 bp_cfg : 32; |
| u64 enable : 16; |
| } s; |
| /* struct npa_af_bp_test_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_BP_TEST(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_BP_TEST(void) |
| { |
| return 0x200; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_const |
| * |
| * NPA AF Constants Register This register contains constants for |
| * software discovery. |
| */ |
| union npa_af_const { |
| u64 u; |
| struct npa_af_const_s { |
| u64 stack_page_bytes : 8; |
| u64 stack_page_ptrs : 8; |
| u64 lfs : 12; |
| u64 qints : 12; |
| u64 num_ndc : 3; |
| u64 reserved_43_63 : 21; |
| } s; |
| /* struct npa_af_const_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_CONST(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_CONST(void) |
| { |
| return 0x10; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_const1 |
| * |
| * NPA AF Constants Register 1 This register contains constants for |
| * software discovery. |
| */ |
| union npa_af_const1 { |
| u64 u; |
| struct npa_af_const1_s { |
| u64 aura_log2bytes : 4; |
| u64 pool_log2bytes : 4; |
| u64 qint_log2bytes : 4; |
| u64 reserved_12_63 : 52; |
| } s; |
| /* struct npa_af_const1_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_CONST1(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_CONST1(void) |
| { |
| return 0x18; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_dtx_filter_ctl |
| * |
| * NPA AF DTX LF Filter Control Register |
| */ |
| union npa_af_dtx_filter_ctl { |
| u64 u; |
| struct npa_af_dtx_filter_ctl_s { |
| u64 ena : 1; |
| u64 reserved_1_3 : 3; |
| u64 lf : 7; |
| u64 reserved_11_63 : 53; |
| } s; |
| /* struct npa_af_dtx_filter_ctl_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_DTX_FILTER_CTL(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_DTX_FILTER_CTL(void) |
| { |
| return 0x10040; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_eco |
| * |
| * INTERNAL: NPA AF ECO Register |
| */ |
| union npa_af_eco { |
| u64 u; |
| struct npa_af_eco_s { |
| u64 eco_rw : 32; |
| u64 reserved_32_63 : 32; |
| } s; |
| /* struct npa_af_eco_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_ECO(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_ECO(void) |
| { |
| return 0x300; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_err_int |
| * |
| * NPA Admin Function Error Interrupt Register |
| */ |
| union npa_af_err_int { |
| u64 u; |
| struct npa_af_err_int_s { |
| u64 reserved_0_11 : 12; |
| u64 aq_door_err : 1; |
| u64 aq_res_fault : 1; |
| u64 aq_inst_fault : 1; |
| u64 reserved_15_63 : 49; |
| } s; |
| /* struct npa_af_err_int_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_ERR_INT(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_ERR_INT(void) |
| { |
| return 0x180; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_err_int_ena_w1c |
| * |
| * NPA Admin Function Error Interrupt Enable Clear Register This register |
| * clears interrupt enable bits. |
| */ |
| union npa_af_err_int_ena_w1c { |
| u64 u; |
| struct npa_af_err_int_ena_w1c_s { |
| u64 reserved_0_11 : 12; |
| u64 aq_door_err : 1; |
| u64 aq_res_fault : 1; |
| u64 aq_inst_fault : 1; |
| u64 reserved_15_63 : 49; |
| } s; |
| /* struct npa_af_err_int_ena_w1c_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_ERR_INT_ENA_W1C(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_ERR_INT_ENA_W1C(void) |
| { |
| return 0x198; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_err_int_ena_w1s |
| * |
| * NPA Admin Function Error Interrupt Enable Set Register This register |
| * sets interrupt enable bits. |
| */ |
| union npa_af_err_int_ena_w1s { |
| u64 u; |
| struct npa_af_err_int_ena_w1s_s { |
| u64 reserved_0_11 : 12; |
| u64 aq_door_err : 1; |
| u64 aq_res_fault : 1; |
| u64 aq_inst_fault : 1; |
| u64 reserved_15_63 : 49; |
| } s; |
| /* struct npa_af_err_int_ena_w1s_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_ERR_INT_ENA_W1S(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_ERR_INT_ENA_W1S(void) |
| { |
| return 0x190; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_err_int_w1s |
| * |
| * NPA Admin Function Error Interrupt Set Register This register sets |
| * interrupt bits. |
| */ |
| union npa_af_err_int_w1s { |
| u64 u; |
| struct npa_af_err_int_w1s_s { |
| u64 reserved_0_11 : 12; |
| u64 aq_door_err : 1; |
| u64 aq_res_fault : 1; |
| u64 aq_inst_fault : 1; |
| u64 reserved_15_63 : 49; |
| } s; |
| /* struct npa_af_err_int_w1s_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_ERR_INT_W1S(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_ERR_INT_W1S(void) |
| { |
| return 0x188; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_gen_cfg |
| * |
| * NPA AF General Configuration Register This register provides NPA |
| * control and status information. |
| */ |
| union npa_af_gen_cfg { |
| u64 u; |
| struct npa_af_gen_cfg_s { |
| u64 reserved_0 : 1; |
| u64 af_be : 1; |
| u64 reserved_2 : 1; |
| u64 force_cond_clk_en : 1; |
| u64 force_intf_clk_en : 1; |
| u64 reserved_5_9 : 5; |
| u64 ocla_bp : 1; |
| u64 reserved_11 : 1; |
| u64 ratem1 : 4; |
| u64 reserved_16_63 : 48; |
| } s; |
| /* struct npa_af_gen_cfg_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_GEN_CFG(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_GEN_CFG(void) |
| { |
| return 0x30; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_gen_int |
| * |
| * NPA AF General Interrupt Register This register contains general error |
| * interrupt summary bits. |
| */ |
| union npa_af_gen_int { |
| u64 u; |
| struct npa_af_gen_int_s { |
| u64 free_dis : 16; |
| u64 alloc_dis : 16; |
| u64 unmapped_pf_func : 1; |
| u64 reserved_33_63 : 31; |
| } s; |
| /* struct npa_af_gen_int_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_GEN_INT(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_GEN_INT(void) |
| { |
| return 0x140; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_gen_int_ena_w1c |
| * |
| * NPA AF General Interrupt Enable Clear Register This register clears |
| * interrupt enable bits. |
| */ |
| union npa_af_gen_int_ena_w1c { |
| u64 u; |
| struct npa_af_gen_int_ena_w1c_s { |
| u64 free_dis : 16; |
| u64 alloc_dis : 16; |
| u64 unmapped_pf_func : 1; |
| u64 reserved_33_63 : 31; |
| } s; |
| /* struct npa_af_gen_int_ena_w1c_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_GEN_INT_ENA_W1C(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_GEN_INT_ENA_W1C(void) |
| { |
| return 0x158; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_gen_int_ena_w1s |
| * |
| * NPA AF General Interrupt Enable Set Register This register sets |
| * interrupt enable bits. |
| */ |
| union npa_af_gen_int_ena_w1s { |
| u64 u; |
| struct npa_af_gen_int_ena_w1s_s { |
| u64 free_dis : 16; |
| u64 alloc_dis : 16; |
| u64 unmapped_pf_func : 1; |
| u64 reserved_33_63 : 31; |
| } s; |
| /* struct npa_af_gen_int_ena_w1s_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_GEN_INT_ENA_W1S(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_GEN_INT_ENA_W1S(void) |
| { |
| return 0x150; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_gen_int_w1s |
| * |
| * NPA AF General Interrupt Set Register This register sets interrupt |
| * bits. |
| */ |
| union npa_af_gen_int_w1s { |
| u64 u; |
| struct npa_af_gen_int_w1s_s { |
| u64 free_dis : 16; |
| u64 alloc_dis : 16; |
| u64 unmapped_pf_func : 1; |
| u64 reserved_33_63 : 31; |
| } s; |
| /* struct npa_af_gen_int_w1s_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_GEN_INT_W1S(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_GEN_INT_W1S(void) |
| { |
| return 0x148; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_inp_ctl |
| * |
| * NPA AF Input Control Register |
| */ |
| union npa_af_inp_ctl { |
| u64 u; |
| struct npa_af_inp_ctl_s { |
| u64 free_dis : 16; |
| u64 alloc_dis : 16; |
| u64 reserved_32_63 : 32; |
| } s; |
| /* struct npa_af_inp_ctl_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_INP_CTL(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_INP_CTL(void) |
| { |
| return 0xd0; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_lf#_auras_cfg |
| * |
| * NPA AF Local Function Auras Configuration Registers |
| */ |
| union npa_af_lfx_auras_cfg { |
| u64 u; |
| struct npa_af_lfx_auras_cfg_s { |
| u64 way_mask : 16; |
| u64 loc_aura_size : 4; |
| u64 loc_aura_offset : 14; |
| u64 caching : 1; |
| u64 be : 1; |
| u64 rmt_aura_size : 4; |
| u64 rmt_aura_offset : 14; |
| u64 rmt_lf : 7; |
| u64 reserved_61_63 : 3; |
| } s; |
| struct npa_af_lfx_auras_cfg_cn96xxp1 { |
| u64 way_mask : 16; |
| u64 loc_aura_size : 4; |
| u64 loc_aura_offset : 14; |
| u64 caching : 1; |
| u64 reserved_35 : 1; |
| u64 rmt_aura_size : 4; |
| u64 rmt_aura_offset : 14; |
| u64 rmt_lf : 7; |
| u64 reserved_61_63 : 3; |
| } cn96xxp1; |
| /* struct npa_af_lfx_auras_cfg_s cn96xxp3; */ |
| /* struct npa_af_lfx_auras_cfg_s cnf95xx; */ |
| }; |
| |
| static inline u64 NPA_AF_LFX_AURAS_CFG(u64 a) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_LFX_AURAS_CFG(u64 a) |
| { |
| return 0x4000 + 0x40000 * a; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_lf#_loc_auras_base |
| * |
| * NPA AF Local Function Auras Base Registers |
| */ |
| union npa_af_lfx_loc_auras_base { |
| u64 u; |
| struct npa_af_lfx_loc_auras_base_s { |
| u64 reserved_0_6 : 7; |
| u64 addr : 46; |
| u64 reserved_53_63 : 11; |
| } s; |
| /* struct npa_af_lfx_loc_auras_base_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_LFX_LOC_AURAS_BASE(u64 a) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_LFX_LOC_AURAS_BASE(u64 a) |
| { |
| return 0x4010 + 0x40000 * a; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_lf#_qints_base |
| * |
| * NPA AF Local Function Queue Interrupts Base Registers |
| */ |
| union npa_af_lfx_qints_base { |
| u64 u; |
| struct npa_af_lfx_qints_base_s { |
| u64 reserved_0_6 : 7; |
| u64 addr : 46; |
| u64 reserved_53_63 : 11; |
| } s; |
| /* struct npa_af_lfx_qints_base_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_LFX_QINTS_BASE(u64 a) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_LFX_QINTS_BASE(u64 a) |
| { |
| return 0x4110 + 0x40000 * a; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_lf#_qints_cfg |
| * |
| * NPA AF Local Function Queue Interrupts Configuration Registers This |
| * register controls access to the LF's queue interrupt context table in |
| * LLC/DRAM. The table consists of NPA_AF_CONST[QINTS] contiguous |
| * NPA_QINT_HW_S structures. The size of each structure is 1 \<\< |
| * NPA_AF_CONST1[QINT_LOG2BYTES] bytes. |
| */ |
| union npa_af_lfx_qints_cfg { |
| u64 u; |
| struct npa_af_lfx_qints_cfg_s { |
| u64 reserved_0_19 : 20; |
| u64 way_mask : 16; |
| u64 caching : 2; |
| u64 reserved_38_63 : 26; |
| } s; |
| /* struct npa_af_lfx_qints_cfg_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_LFX_QINTS_CFG(u64 a) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_LFX_QINTS_CFG(u64 a) |
| { |
| return 0x4100 + 0x40000 * a; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_lf_rst |
| * |
| * NPA Admin Function LF Reset Register |
| */ |
| union npa_af_lf_rst { |
| u64 u; |
| struct npa_af_lf_rst_s { |
| u64 lf : 8; |
| u64 reserved_8_11 : 4; |
| u64 exec : 1; |
| u64 reserved_13_63 : 51; |
| } s; |
| /* struct npa_af_lf_rst_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_LF_RST(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_LF_RST(void) |
| { |
| return 0x20; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_ndc_cfg |
| * |
| * NDC AF General Configuration Register This register provides NDC |
| * control. |
| */ |
| union npa_af_ndc_cfg { |
| u64 u; |
| struct npa_af_ndc_cfg_s { |
| u64 ndc_bypass : 1; |
| u64 ndc_ign_pois : 1; |
| u64 byp_aura : 1; |
| u64 byp_pool : 1; |
| u64 byp_stack : 1; |
| u64 byp_qint : 1; |
| u64 reserved_6_63 : 58; |
| } s; |
| /* struct npa_af_ndc_cfg_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_NDC_CFG(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_NDC_CFG(void) |
| { |
| return 0x40; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_ndc_sync |
| * |
| * NPA AF NDC Sync Register Used to synchronize the NPA NDC. |
| */ |
| union npa_af_ndc_sync { |
| u64 u; |
| struct npa_af_ndc_sync_s { |
| u64 lf : 8; |
| u64 reserved_8_11 : 4; |
| u64 exec : 1; |
| u64 reserved_13_63 : 51; |
| } s; |
| /* struct npa_af_ndc_sync_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_NDC_SYNC(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_NDC_SYNC(void) |
| { |
| return 0x50; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_ras |
| * |
| * NPA AF RAS Interrupt Register This register is intended for delivery |
| * of RAS events to the SCP, so should be ignored by OS drivers. |
| */ |
| union npa_af_ras { |
| u64 u; |
| struct npa_af_ras_s { |
| u64 reserved_0_31 : 32; |
| u64 aq_ctx_poison : 1; |
| u64 aq_res_poison : 1; |
| u64 aq_inst_poison : 1; |
| u64 reserved_35_63 : 29; |
| } s; |
| /* struct npa_af_ras_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_RAS(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_RAS(void) |
| { |
| return 0x1a0; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_ras_ena_w1c |
| * |
| * NPA AF RAS Interrupt Enable Clear Register This register clears |
| * interrupt enable bits. |
| */ |
| union npa_af_ras_ena_w1c { |
| u64 u; |
| struct npa_af_ras_ena_w1c_s { |
| u64 reserved_0_31 : 32; |
| u64 aq_ctx_poison : 1; |
| u64 aq_res_poison : 1; |
| u64 aq_inst_poison : 1; |
| u64 reserved_35_63 : 29; |
| } s; |
| /* struct npa_af_ras_ena_w1c_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_RAS_ENA_W1C(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_RAS_ENA_W1C(void) |
| { |
| return 0x1b8; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_ras_ena_w1s |
| * |
| * NPA AF RAS Interrupt Enable Set Register This register sets interrupt |
| * enable bits. |
| */ |
| union npa_af_ras_ena_w1s { |
| u64 u; |
| struct npa_af_ras_ena_w1s_s { |
| u64 reserved_0_31 : 32; |
| u64 aq_ctx_poison : 1; |
| u64 aq_res_poison : 1; |
| u64 aq_inst_poison : 1; |
| u64 reserved_35_63 : 29; |
| } s; |
| /* struct npa_af_ras_ena_w1s_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_RAS_ENA_W1S(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_RAS_ENA_W1S(void) |
| { |
| return 0x1b0; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_ras_w1s |
| * |
| * NPA AF RAS Interrupt Set Register This register sets interrupt bits. |
| */ |
| union npa_af_ras_w1s { |
| u64 u; |
| struct npa_af_ras_w1s_s { |
| u64 reserved_0_31 : 32; |
| u64 aq_ctx_poison : 1; |
| u64 aq_res_poison : 1; |
| u64 aq_inst_poison : 1; |
| u64 reserved_35_63 : 29; |
| } s; |
| /* struct npa_af_ras_w1s_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_RAS_W1S(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_RAS_W1S(void) |
| { |
| return 0x1a8; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_rvu_int |
| * |
| * NPA AF RVU Interrupt Register This register contains RVU error |
| * interrupt summary bits. |
| */ |
| union npa_af_rvu_int { |
| u64 u; |
| struct npa_af_rvu_int_s { |
| u64 unmapped_slot : 1; |
| u64 reserved_1_63 : 63; |
| } s; |
| /* struct npa_af_rvu_int_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_RVU_INT(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_RVU_INT(void) |
| { |
| return 0x160; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_rvu_int_ena_w1c |
| * |
| * NPA AF RVU Interrupt Enable Clear Register This register clears |
| * interrupt enable bits. |
| */ |
| union npa_af_rvu_int_ena_w1c { |
| u64 u; |
| struct npa_af_rvu_int_ena_w1c_s { |
| u64 unmapped_slot : 1; |
| u64 reserved_1_63 : 63; |
| } s; |
| /* struct npa_af_rvu_int_ena_w1c_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_RVU_INT_ENA_W1C(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_RVU_INT_ENA_W1C(void) |
| { |
| return 0x178; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_rvu_int_ena_w1s |
| * |
| * NPA AF RVU Interrupt Enable Set Register This register sets interrupt |
| * enable bits. |
| */ |
| union npa_af_rvu_int_ena_w1s { |
| u64 u; |
| struct npa_af_rvu_int_ena_w1s_s { |
| u64 unmapped_slot : 1; |
| u64 reserved_1_63 : 63; |
| } s; |
| /* struct npa_af_rvu_int_ena_w1s_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_RVU_INT_ENA_W1S(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_RVU_INT_ENA_W1S(void) |
| { |
| return 0x170; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_rvu_int_w1s |
| * |
| * NPA AF RVU Interrupt Set Register This register sets interrupt bits. |
| */ |
| union npa_af_rvu_int_w1s { |
| u64 u; |
| struct npa_af_rvu_int_w1s_s { |
| u64 unmapped_slot : 1; |
| u64 reserved_1_63 : 63; |
| } s; |
| /* struct npa_af_rvu_int_w1s_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_RVU_INT_W1S(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_RVU_INT_W1S(void) |
| { |
| return 0x168; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_af_rvu_lf_cfg_debug |
| * |
| * NPA Privileged LF Configuration Debug Register This debug register |
| * allows software to lookup the reverse mapping from VF/PF slot to LF. |
| * The forward mapping is programmed with NPA_PRIV_LF()_CFG. |
| */ |
| union npa_af_rvu_lf_cfg_debug { |
| u64 u; |
| struct npa_af_rvu_lf_cfg_debug_s { |
| u64 lf : 12; |
| u64 lf_valid : 1; |
| u64 exec : 1; |
| u64 reserved_14_15 : 2; |
| u64 slot : 8; |
| u64 pf_func : 16; |
| u64 reserved_40_63 : 24; |
| } s; |
| /* struct npa_af_rvu_lf_cfg_debug_s cn; */ |
| }; |
| |
| static inline u64 NPA_AF_RVU_LF_CFG_DEBUG(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_AF_RVU_LF_CFG_DEBUG(void) |
| { |
| return 0x10030; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_aura_op_alloc# |
| * |
| * NPA Aura Allocate Operation Registers These registers are used to |
| * allocate one or two pointers from a given aura's pool. A 64-bit atomic |
| * load-and-add to NPA_LF_AURA_OP_ALLOC(0) allocates a single pointer. A |
| * 128-bit atomic CASP operation to NPA_LF_AURA_OP_ALLOC(0..1) allocates |
| * two pointers. The atomic write data format is NPA_AURA_OP_WDATA_S. For |
| * CASP, the first SWAP word in the write data contains |
| * NPA_AURA_OP_WDATA_S and the remaining write data words are ignored. |
| * All other accesses to this register (e.g. reads and writes) are |
| * RAZ/WI. RSL accesses to this register are RAZ/WI. |
| */ |
| union npa_lf_aura_op_allocx { |
| u64 u; |
| struct npa_lf_aura_op_allocx_s { |
| u64 addr : 64; |
| } s; |
| /* struct npa_lf_aura_op_allocx_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_AURA_OP_ALLOCX(u64 a) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_AURA_OP_ALLOCX(u64 a) |
| { |
| return 0x10 + 8 * a; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_aura_op_cnt |
| * |
| * NPA LF Aura Count Register A 64-bit atomic load-and-add to this |
| * register returns a given aura's count. A write sets or adds the aura's |
| * count. A read is RAZ. RSL accesses to this register are RAZ/WI. |
| */ |
| union npa_lf_aura_op_cnt { |
| u64 u; |
| struct npa_lf_aura_op_cnt_s { |
| u64 count : 36; |
| u64 reserved_36_41 : 6; |
| u64 op_err : 1; |
| u64 cnt_add : 1; |
| u64 aura : 20; |
| } s; |
| /* struct npa_lf_aura_op_cnt_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_AURA_OP_CNT(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_AURA_OP_CNT(void) |
| { |
| return 0x30; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_aura_op_free0 |
| * |
| * NPA LF Aura Free Operation Register 0 A 128-bit write (STP) to |
| * NPA_LF_AURA_OP_FREE0 and NPA_LF_AURA_OP_FREE1 frees a pointer into a |
| * given aura's pool. All other accesses to these registers (e.g. reads |
| * and 64-bit writes) are RAZ/WI. RSL accesses to this register are |
| * RAZ/WI. |
| */ |
| union npa_lf_aura_op_free0 { |
| u64 u; |
| struct npa_lf_aura_op_free0_s { |
| u64 addr : 64; |
| } s; |
| /* struct npa_lf_aura_op_free0_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_AURA_OP_FREE0(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_AURA_OP_FREE0(void) |
| { |
| return 0x20; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_aura_op_free1 |
| * |
| * NPA LF Aura Free Operation Register 1 See NPA_LF_AURA_OP_FREE0. RSL |
| * accesses to this register are RAZ/WI. |
| */ |
| union npa_lf_aura_op_free1 { |
| u64 u; |
| struct npa_lf_aura_op_free1_s { |
| u64 aura : 20; |
| u64 reserved_20_62 : 43; |
| u64 fabs : 1; |
| } s; |
| /* struct npa_lf_aura_op_free1_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_AURA_OP_FREE1(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_AURA_OP_FREE1(void) |
| { |
| return 0x28; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_aura_op_int |
| * |
| * NPA LF Aura Interrupt Operation Register A 64-bit atomic load-and-add |
| * to this register reads |
| * NPA_AURA_HW_S[ERR_INT,ERR_INT_ENA,THRESH_INT,THRESH_INT_ENA]. A write |
| * optionally sets or clears these fields. A read is RAZ. RSL accesses |
| * to this register are RAZ/WI. |
| */ |
| union npa_lf_aura_op_int { |
| u64 u; |
| struct npa_lf_aura_op_int_s { |
| u64 err_int : 8; |
| u64 err_int_ena : 8; |
| u64 thresh_int : 1; |
| u64 thresh_int_ena : 1; |
| u64 reserved_18_41 : 24; |
| u64 op_err : 1; |
| u64 setop : 1; |
| u64 aura : 20; |
| } s; |
| /* struct npa_lf_aura_op_int_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_AURA_OP_INT(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_AURA_OP_INT(void) |
| { |
| return 0x60; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_aura_op_limit |
| * |
| * NPA LF Aura Allocation Limit Register A 64-bit atomic load-and-add to |
| * this register returns a given aura's limit. A write sets the aura's |
| * limit. A read is RAZ. RSL accesses to this register are RAZ/WI. |
| */ |
| union npa_lf_aura_op_limit { |
| u64 u; |
| struct npa_lf_aura_op_limit_s { |
| u64 limit : 36; |
| u64 reserved_36_41 : 6; |
| u64 op_err : 1; |
| u64 reserved_43 : 1; |
| u64 aura : 20; |
| } s; |
| /* struct npa_lf_aura_op_limit_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_AURA_OP_LIMIT(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_AURA_OP_LIMIT(void) |
| { |
| return 0x50; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_aura_op_thresh |
| * |
| * NPA LF Aura Threshold Operation Register A 64-bit atomic load-and-add |
| * to this register reads NPA_AURA_HW_S[THRESH_UP,THRESH]. A write to the |
| * register writes NPA_AURA_HW_S[THRESH_UP,THRESH] and recomputes |
| * NPA_AURA_HW_S[THRESH_INT]. A read is RAZ. RSL accesses to this |
| * register are RAZ/WI. |
| */ |
| union npa_lf_aura_op_thresh { |
| u64 u; |
| struct npa_lf_aura_op_thresh_s { |
| u64 thresh : 36; |
| u64 reserved_36_41 : 6; |
| u64 op_err : 1; |
| u64 thresh_up : 1; |
| u64 aura : 20; |
| } s; |
| /* struct npa_lf_aura_op_thresh_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_AURA_OP_THRESH(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_AURA_OP_THRESH(void) |
| { |
| return 0x70; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_err_int |
| * |
| * NPA LF Error Interrupt Register |
| */ |
| union npa_lf_err_int { |
| u64 u; |
| struct npa_lf_err_int_s { |
| u64 aura_dis : 1; |
| u64 aura_oor : 1; |
| u64 reserved_2 : 1; |
| u64 rmt_req_oor : 1; |
| u64 reserved_4_11 : 8; |
| u64 aura_fault : 1; |
| u64 pool_fault : 1; |
| u64 stack_fault : 1; |
| u64 qint_fault : 1; |
| u64 reserved_16_63 : 48; |
| } s; |
| /* struct npa_lf_err_int_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_ERR_INT(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_ERR_INT(void) |
| { |
| return 0x200; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_err_int_ena_w1c |
| * |
| * NPA LF Error Interrupt Enable Clear Register This register clears |
| * interrupt enable bits. |
| */ |
| union npa_lf_err_int_ena_w1c { |
| u64 u; |
| struct npa_lf_err_int_ena_w1c_s { |
| u64 aura_dis : 1; |
| u64 aura_oor : 1; |
| u64 reserved_2 : 1; |
| u64 rmt_req_oor : 1; |
| u64 reserved_4_11 : 8; |
| u64 aura_fault : 1; |
| u64 pool_fault : 1; |
| u64 stack_fault : 1; |
| u64 qint_fault : 1; |
| u64 reserved_16_63 : 48; |
| } s; |
| /* struct npa_lf_err_int_ena_w1c_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_ERR_INT_ENA_W1C(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_ERR_INT_ENA_W1C(void) |
| { |
| return 0x210; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_err_int_ena_w1s |
| * |
| * NPA LF Error Interrupt Enable Set Register This register sets |
| * interrupt enable bits. |
| */ |
| union npa_lf_err_int_ena_w1s { |
| u64 u; |
| struct npa_lf_err_int_ena_w1s_s { |
| u64 aura_dis : 1; |
| u64 aura_oor : 1; |
| u64 reserved_2 : 1; |
| u64 rmt_req_oor : 1; |
| u64 reserved_4_11 : 8; |
| u64 aura_fault : 1; |
| u64 pool_fault : 1; |
| u64 stack_fault : 1; |
| u64 qint_fault : 1; |
| u64 reserved_16_63 : 48; |
| } s; |
| /* struct npa_lf_err_int_ena_w1s_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_ERR_INT_ENA_W1S(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_ERR_INT_ENA_W1S(void) |
| { |
| return 0x218; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_err_int_w1s |
| * |
| * NPA LF Error Interrupt Set Register This register sets interrupt bits. |
| */ |
| union npa_lf_err_int_w1s { |
| u64 u; |
| struct npa_lf_err_int_w1s_s { |
| u64 aura_dis : 1; |
| u64 aura_oor : 1; |
| u64 reserved_2 : 1; |
| u64 rmt_req_oor : 1; |
| u64 reserved_4_11 : 8; |
| u64 aura_fault : 1; |
| u64 pool_fault : 1; |
| u64 stack_fault : 1; |
| u64 qint_fault : 1; |
| u64 reserved_16_63 : 48; |
| } s; |
| /* struct npa_lf_err_int_w1s_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_ERR_INT_W1S(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_ERR_INT_W1S(void) |
| { |
| return 0x208; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_pool_op_available |
| * |
| * NPA LF Pool Available Count Operation Register A 64-bit atomic load- |
| * and-add to this register returns a given pool's free pointer count. |
| * Reads and writes are RAZ/WI. RSL accesses to this register are |
| * RAZ/WI. |
| */ |
| union npa_lf_pool_op_available { |
| u64 u; |
| struct npa_lf_pool_op_available_s { |
| u64 count : 36; |
| u64 reserved_36_41 : 6; |
| u64 op_err : 1; |
| u64 reserved_43 : 1; |
| u64 aura : 20; |
| } s; |
| /* struct npa_lf_pool_op_available_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_POOL_OP_AVAILABLE(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_POOL_OP_AVAILABLE(void) |
| { |
| return 0x110; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_pool_op_int |
| * |
| * NPA LF Pool Interrupt Operation Register A 64-bit atomic load-and-add |
| * to this register reads |
| * NPA_POOL_S[ERR_INT,ERR_INT_ENA,THRESH_INT,THRESH_INT_ENA]. A write |
| * optionally sets or clears these fields. A read is RAZ. RSL accesses |
| * to this register are RAZ/WI. |
| */ |
| union npa_lf_pool_op_int { |
| u64 u; |
| struct npa_lf_pool_op_int_s { |
| u64 err_int : 8; |
| u64 err_int_ena : 8; |
| u64 thresh_int : 1; |
| u64 thresh_int_ena : 1; |
| u64 reserved_18_41 : 24; |
| u64 op_err : 1; |
| u64 setop : 1; |
| u64 aura : 20; |
| } s; |
| /* struct npa_lf_pool_op_int_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_POOL_OP_INT(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_POOL_OP_INT(void) |
| { |
| return 0x160; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_pool_op_pc |
| * |
| * NPA LF Pool Performance Count Register A 64-bit atomic load-and-add to |
| * this register reads NPA_POOL_S[OP_PC] from a given aura's pool. The |
| * aura is selected by the atomic write data, whose format is |
| * NPA_AURA_OP_WDATA_S. Reads and writes are RAZ/WI. RSL accesses to |
| * this register are RAZ/WI. |
| */ |
| union npa_lf_pool_op_pc { |
| u64 u; |
| struct npa_lf_pool_op_pc_s { |
| u64 op_pc : 48; |
| u64 op_err : 1; |
| u64 reserved_49_63 : 15; |
| } s; |
| /* struct npa_lf_pool_op_pc_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_POOL_OP_PC(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_POOL_OP_PC(void) |
| { |
| return 0x100; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_pool_op_ptr_end0 |
| * |
| * NPA LF Pool Pointer End Operation Register 0 A 128-bit write (STP) to |
| * the NPA_LF_POOL_OP_PTR_END0 and NPA_LF_POOL_OP_PTR_END1 registers |
| * writes to a given pool's pointer end value. All other accesses to |
| * these registers (e.g. reads and 64-bit writes) are RAZ/WI. RSL |
| * accesses to this register are RAZ/WI. |
| */ |
| union npa_lf_pool_op_ptr_end0 { |
| u64 u; |
| struct npa_lf_pool_op_ptr_end0_s { |
| u64 ptr_end : 64; |
| } s; |
| /* struct npa_lf_pool_op_ptr_end0_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_POOL_OP_PTR_END0(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_POOL_OP_PTR_END0(void) |
| { |
| return 0x130; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_pool_op_ptr_end1 |
| * |
| * NPA LF Pool Pointer End Operation Register 1 See |
| * NPA_LF_POOL_OP_PTR_END0. RSL accesses to this register are RAZ/WI. |
| */ |
| union npa_lf_pool_op_ptr_end1 { |
| u64 u; |
| struct npa_lf_pool_op_ptr_end1_s { |
| u64 aura : 20; |
| u64 reserved_20_63 : 44; |
| } s; |
| /* struct npa_lf_pool_op_ptr_end1_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_POOL_OP_PTR_END1(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_POOL_OP_PTR_END1(void) |
| { |
| return 0x138; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_pool_op_ptr_start0 |
| * |
| * NPA LF Pool Pointer Start Operation Register 0 A 128-bit write (STP) |
| * to the NPA_LF_POOL_OP_PTR_START0 and NPA_LF_POOL_OP_PTR_START1 |
| * registers writes to a given pool's pointer start value. All other |
| * accesses to these registers (e.g. reads and 64-bit writes) are RAZ/WI. |
| * RSL accesses to this register are RAZ/WI. |
| */ |
| union npa_lf_pool_op_ptr_start0 { |
| u64 u; |
| struct npa_lf_pool_op_ptr_start0_s { |
| u64 ptr_start : 64; |
| } s; |
| /* struct npa_lf_pool_op_ptr_start0_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_POOL_OP_PTR_START0(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_POOL_OP_PTR_START0(void) |
| { |
| return 0x120; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_pool_op_ptr_start1 |
| * |
| * NPA LF Pool Pointer Start Operation Register 1 See |
| * NPA_LF_POOL_OP_PTR_START0. RSL accesses to this register are RAZ/WI. |
| */ |
| union npa_lf_pool_op_ptr_start1 { |
| u64 u; |
| struct npa_lf_pool_op_ptr_start1_s { |
| u64 aura : 20; |
| u64 reserved_20_63 : 44; |
| } s; |
| /* struct npa_lf_pool_op_ptr_start1_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_POOL_OP_PTR_START1(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_POOL_OP_PTR_START1(void) |
| { |
| return 0x128; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_pool_op_thresh |
| * |
| * NPA LF Pool Threshold Operation Register A 64-bit atomic load-and-add |
| * to this register reads NPA_POOL_S[THRESH_UP,THRESH]. A write to the |
| * register writes NPA_POOL_S[THRESH_UP,THRESH]. A read is RAZ. RSL |
| * accesses to this register are RAZ/WI. |
| */ |
| union npa_lf_pool_op_thresh { |
| u64 u; |
| struct npa_lf_pool_op_thresh_s { |
| u64 thresh : 36; |
| u64 reserved_36_41 : 6; |
| u64 op_err : 1; |
| u64 thresh_up : 1; |
| u64 aura : 20; |
| } s; |
| /* struct npa_lf_pool_op_thresh_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_POOL_OP_THRESH(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_POOL_OP_THRESH(void) |
| { |
| return 0x170; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_qint#_cnt |
| * |
| * NPA LF Queue Interrupt Count Registers |
| */ |
| union npa_lf_qintx_cnt { |
| u64 u; |
| struct npa_lf_qintx_cnt_s { |
| u64 count : 22; |
| u64 reserved_22_63 : 42; |
| } s; |
| /* struct npa_lf_qintx_cnt_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_QINTX_CNT(u64 a) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_QINTX_CNT(u64 a) |
| { |
| return 0x300 + 0x1000 * a; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_qint#_ena_w1c |
| * |
| * NPA LF Queue Interrupt Enable Clear Registers This register clears |
| * interrupt enable bits. |
| */ |
| union npa_lf_qintx_ena_w1c { |
| u64 u; |
| struct npa_lf_qintx_ena_w1c_s { |
| u64 intr : 1; |
| u64 reserved_1_63 : 63; |
| } s; |
| /* struct npa_lf_qintx_ena_w1c_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_QINTX_ENA_W1C(u64 a) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_QINTX_ENA_W1C(u64 a) |
| { |
| return 0x330 + 0x1000 * a; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_qint#_ena_w1s |
| * |
| * NPA LF Queue Interrupt Enable Set Registers This register sets |
| * interrupt enable bits. |
| */ |
| union npa_lf_qintx_ena_w1s { |
| u64 u; |
| struct npa_lf_qintx_ena_w1s_s { |
| u64 intr : 1; |
| u64 reserved_1_63 : 63; |
| } s; |
| /* struct npa_lf_qintx_ena_w1s_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_QINTX_ENA_W1S(u64 a) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_QINTX_ENA_W1S(u64 a) |
| { |
| return 0x320 + 0x1000 * a; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_qint#_int |
| * |
| * NPA LF Queue Interrupt Registers |
| */ |
| union npa_lf_qintx_int { |
| u64 u; |
| struct npa_lf_qintx_int_s { |
| u64 intr : 1; |
| u64 reserved_1_63 : 63; |
| } s; |
| /* struct npa_lf_qintx_int_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_QINTX_INT(u64 a) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_QINTX_INT(u64 a) |
| { |
| return 0x310 + 0x1000 * a; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_qint#_int_w1s |
| * |
| * INTERNAL: NPA LF Queue Interrupt Set Registers |
| */ |
| union npa_lf_qintx_int_w1s { |
| u64 u; |
| struct npa_lf_qintx_int_w1s_s { |
| u64 intr : 1; |
| u64 reserved_1_63 : 63; |
| } s; |
| /* struct npa_lf_qintx_int_w1s_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_QINTX_INT_W1S(u64 a) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_QINTX_INT_W1S(u64 a) |
| { |
| return 0x318 + 0x1000 * a; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_ras |
| * |
| * NPA LF RAS Interrupt Register |
| */ |
| union npa_lf_ras { |
| u64 u; |
| struct npa_lf_ras_s { |
| u64 aura_poison : 1; |
| u64 pool_poison : 1; |
| u64 stack_poison : 1; |
| u64 qint_poison : 1; |
| u64 reserved_4_63 : 60; |
| } s; |
| /* struct npa_lf_ras_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_RAS(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_RAS(void) |
| { |
| return 0x220; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_ras_ena_w1c |
| * |
| * NPA LF RAS Interrupt Enable Clear Register This register clears |
| * interrupt enable bits. |
| */ |
| union npa_lf_ras_ena_w1c { |
| u64 u; |
| struct npa_lf_ras_ena_w1c_s { |
| u64 aura_poison : 1; |
| u64 pool_poison : 1; |
| u64 stack_poison : 1; |
| u64 qint_poison : 1; |
| u64 reserved_4_63 : 60; |
| } s; |
| /* struct npa_lf_ras_ena_w1c_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_RAS_ENA_W1C(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_RAS_ENA_W1C(void) |
| { |
| return 0x230; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_ras_ena_w1s |
| * |
| * NPA LF RAS Interrupt Enable Set Register This register sets interrupt |
| * enable bits. |
| */ |
| union npa_lf_ras_ena_w1s { |
| u64 u; |
| struct npa_lf_ras_ena_w1s_s { |
| u64 aura_poison : 1; |
| u64 pool_poison : 1; |
| u64 stack_poison : 1; |
| u64 qint_poison : 1; |
| u64 reserved_4_63 : 60; |
| } s; |
| /* struct npa_lf_ras_ena_w1s_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_RAS_ENA_W1S(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_RAS_ENA_W1S(void) |
| { |
| return 0x238; |
| } |
| |
| /** |
| * Register (RVU_PFVF_BAR2) npa_lf_ras_w1s |
| * |
| * NPA LF RAS Interrupt Set Register This register sets interrupt bits. |
| */ |
| union npa_lf_ras_w1s { |
| u64 u; |
| struct npa_lf_ras_w1s_s { |
| u64 aura_poison : 1; |
| u64 pool_poison : 1; |
| u64 stack_poison : 1; |
| u64 qint_poison : 1; |
| u64 reserved_4_63 : 60; |
| } s; |
| /* struct npa_lf_ras_w1s_s cn; */ |
| }; |
| |
| static inline u64 NPA_LF_RAS_W1S(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_LF_RAS_W1S(void) |
| { |
| return 0x228; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_priv_af_int_cfg |
| * |
| * NPA Privileged AF Interrupt Configuration Register |
| */ |
| union npa_priv_af_int_cfg { |
| u64 u; |
| struct npa_priv_af_int_cfg_s { |
| u64 msix_offset : 11; |
| u64 reserved_11 : 1; |
| u64 msix_size : 8; |
| u64 reserved_20_63 : 44; |
| } s; |
| /* struct npa_priv_af_int_cfg_s cn; */ |
| }; |
| |
| static inline u64 NPA_PRIV_AF_INT_CFG(void) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_PRIV_AF_INT_CFG(void) |
| { |
| return 0x10000; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_priv_lf#_cfg |
| * |
| * NPA Privileged Local Function Configuration Registers These registers |
| * allow each NPA local function (LF) to be provisioned to a VF/PF slot |
| * for RVU. See also NPA_AF_RVU_LF_CFG_DEBUG. Software should read this |
| * register after write to ensure that the LF is mapped to [PF_FUNC] |
| * before issuing transactions to the mapped PF and function. [SLOT] |
| * must be zero. Internal: Hardware ignores [SLOT] and always assumes |
| * 0x0. |
| */ |
| union npa_priv_lfx_cfg { |
| u64 u; |
| struct npa_priv_lfx_cfg_s { |
| u64 slot : 8; |
| u64 pf_func : 16; |
| u64 reserved_24_62 : 39; |
| u64 ena : 1; |
| } s; |
| /* struct npa_priv_lfx_cfg_s cn; */ |
| }; |
| |
| static inline u64 NPA_PRIV_LFX_CFG(u64 a) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_PRIV_LFX_CFG(u64 a) |
| { |
| return 0x10010 + 0x100 * a; |
| } |
| |
| /** |
| * Register (RVU_PF_BAR0) npa_priv_lf#_int_cfg |
| * |
| * NPA Privileged LF Interrupt Configuration Registers |
| */ |
| union npa_priv_lfx_int_cfg { |
| u64 u; |
| struct npa_priv_lfx_int_cfg_s { |
| u64 msix_offset : 11; |
| u64 reserved_11 : 1; |
| u64 msix_size : 8; |
| u64 reserved_20_63 : 44; |
| } s; |
| /* struct npa_priv_lfx_int_cfg_s cn; */ |
| }; |
| |
| static inline u64 NPA_PRIV_LFX_INT_CFG(u64 a) |
| __attribute__ ((pure, always_inline)); |
| static inline u64 NPA_PRIV_LFX_INT_CFG(u64 a) |
| { |
| return 0x10020 + 0x100 * a; |
| } |
| |
| #endif /* __CSRS_NPA_H__ */ |