#include <stdint.h>
#include <ipxe/list.h>
#include <ipxe/pci.h>

Data Structures
struct	vxge_hw_ring_rxd_1
	struct vxge_hw_ring_rxd_1 - One buffer mode RxD for ring More...

struct	vxge_hw_fifo_txd
	struct vxge_hw_fifo_txd - Transmit Descriptor More...

struct	vxge_hw_device_date

struct	vxge_hw_device_version

struct	__vxge_hw_non_offload_db_wrapper

struct	__vxge_hw_fifo

struct	__vxge_hw_ring_block

struct	__vxge_hw_ring

struct	__vxge_hw_virtualpath

struct	vxge_hw_device_hw_info
	struct vxge_hw_device_hw_info - Device information @host_type: Host Type @func_id: Function Id @vpath_mask: vpath bit mask @fw_version: Firmware version @fw_date: Firmware Date @flash_version: Firmware version @flash_date: Firmware Date @mac_addrs: Mac addresses for each vpath @mac_addr_masks: Mac address masks for each vpath More...

struct	__vxge_hw_device
	struct __vxge_hw_device - Hal device object @magic: Magic Number @bar0: BAR0 virtual address. More...

Macros
#define	VXGE_CONFIG_H

#define	VXGE_CACHE_LINE_SIZE 4096

#define	WAIT_FACTOR 1

#define	VXGE_HW_MAC_MAX_WIRE_PORTS 2

#define	VXGE_HW_MAC_MAX_AGGR_PORTS 2

#define	VXGE_HW_MAC_MAX_PORTS 3

#define	VXGE_HW_MIN_MTU 68

#define	VXGE_HW_MAX_MTU 9600

#define	VXGE_HW_DEFAULT_MTU 1500

#define	__iomem

#define	____cacheline_aligned

#define	VXGE_NONE 0x00
	debug filtering masks More...

#define	VXGE_INFO 0x01

#define	VXGE_INTR 0x02

#define	VXGE_XMIT 0x04

#define	VXGE_POLL 0x08

#define	VXGE_ERR 0x10

#define	VXGE_TRACE 0x20

#define	VXGE_ALL

#define	NULL_VPID 0xFFFFFFFF

#define	VXGE_HW_EVENT_BASE 0

#define	VXGE_LL_EVENT_BASE 100

#define	VXGE_HW_BASE_INF 100

#define	VXGE_HW_BASE_ERR 200

#define	VXGE_HW_BASE_BADCFG 300

#define	VXGE_HW_DEF_DEVICE_POLL_MILLIS 1000

#define	VXGE_HW_MAX_PAYLOAD_SIZE_512 2

#define	VXGE_HW_RING_RXD_RTH_BUCKET_GET(ctrl0) vxge_bVALn(ctrl0, 0, 7)

#define	VXGE_HW_RING_RXD_LIST_OWN_ADAPTER vxge_mBIT(7)

#define	VXGE_HW_RING_RXD_FAST_PATH_ELIGIBLE_GET(ctrl0) vxge_bVALn(ctrl0, 8, 1)

#define	VXGE_HW_RING_RXD_L3_CKSUM_CORRECT_GET(ctrl0) vxge_bVALn(ctrl0, 9, 1)

#define	VXGE_HW_RING_RXD_L4_CKSUM_CORRECT_GET(ctrl0) vxge_bVALn(ctrl0, 10, 1)

#define	VXGE_HW_RING_RXD_T_CODE_GET(ctrl0) vxge_bVALn(ctrl0, 12, 4)

#define	VXGE_HW_RING_RXD_T_CODE(val) vxge_vBIT(val, 12, 4)

#define	VXGE_HW_RING_RXD_T_CODE_UNUSED VXGE_HW_RING_T_CODE_UNUSED

#define	VXGE_HW_RING_RXD_SYN_GET(ctrl0) vxge_bVALn(ctrl0, 16, 1)

#define	VXGE_HW_RING_RXD_IS_ICMP_GET(ctrl0) vxge_bVALn(ctrl0, 17, 1)

#define	VXGE_HW_RING_RXD_RTH_SPDM_HIT_GET(ctrl0) vxge_bVALn(ctrl0, 18, 1)

#define	VXGE_HW_RING_RXD_RTH_IT_HIT_GET(ctrl0) vxge_bVALn(ctrl0, 19, 1)

#define	VXGE_HW_RING_RXD_RTH_HASH_TYPE_GET(ctrl0) vxge_bVALn(ctrl0, 20, 4)

#define	VXGE_HW_RING_RXD_IS_VLAN_GET(ctrl0) vxge_bVALn(ctrl0, 24, 1)

#define	VXGE_HW_RING_RXD_ETHER_ENCAP_GET(ctrl0) vxge_bVALn(ctrl0, 25, 2)

#define	VXGE_HW_RING_RXD_FRAME_PROTO_GET(ctrl0) vxge_bVALn(ctrl0, 27, 5)

#define	VXGE_HW_RING_RXD_L3_CKSUM_GET(ctrl0) vxge_bVALn(ctrl0, 32, 16)

#define	VXGE_HW_RING_RXD_L4_CKSUM_GET(ctrl0) vxge_bVALn(ctrl0, 48, 16)

#define	VXGE_HW_RING_RXD_1_BUFFER0_SIZE_GET(ctrl1) vxge_bVALn(ctrl1, 2, 14)

#define	VXGE_HW_RING_RXD_1_BUFFER0_SIZE(val) vxge_vBIT(val, 2, 14)

#define	VXGE_HW_RING_RXD_1_BUFFER0_SIZE_MASK vxge_vBIT(0x3FFF, 2, 14)

#define	VXGE_HW_RING_RXD_1_RTH_HASH_VAL_GET(ctrl1) vxge_bVALn(ctrl1, 16, 32)

#define	VXGE_HW_RING_RXD_VLAN_TAG_GET(ctrl1) vxge_bVALn(ctrl1, 48, 16)

#define	VXGE_HW_FIFO_TXD_LIST_OWN_ADAPTER vxge_mBIT(7)

#define	VXGE_HW_FIFO_TXD_T_CODE_GET(ctrl0) vxge_bVALn(ctrl0, 12, 4)

#define	VXGE_HW_FIFO_TXD_T_CODE(val) vxge_vBIT(val, 12, 4)

#define	VXGE_HW_FIFO_TXD_T_CODE_UNUSED VXGE_HW_FIFO_T_CODE_UNUSED

#define	VXGE_HW_FIFO_TXD_GATHER_CODE(val) vxge_vBIT(val, 22, 2)

#define	VXGE_HW_FIFO_TXD_GATHER_CODE_FIRST VXGE_HW_FIFO_GATHER_CODE_FIRST

#define	VXGE_HW_FIFO_TXD_GATHER_CODE_LAST VXGE_HW_FIFO_GATHER_CODE_LAST

#define	VXGE_HW_FIFO_TXD_LSO_EN vxge_mBIT(30)

#define	VXGE_HW_FIFO_TXD_LSO_MSS(val) vxge_vBIT(val, 34, 14)

#define	VXGE_HW_FIFO_TXD_BUFFER_SIZE(val) vxge_vBIT(val, 48, 16)

#define	VXGE_HW_FIFO_TXD_TX_CKO_IPV4_EN vxge_mBIT(5)

#define	VXGE_HW_FIFO_TXD_TX_CKO_TCP_EN vxge_mBIT(6)

#define	VXGE_HW_FIFO_TXD_TX_CKO_UDP_EN vxge_mBIT(7)

#define	VXGE_HW_FIFO_TXD_VLAN_ENABLE vxge_mBIT(15)

#define	VXGE_HW_FIFO_TXD_VLAN_TAG(val) vxge_vBIT(val, 16, 16)

#define	VXGE_HW_FIFO_TXD_NO_BW_LIMIT vxge_mBIT(43)

#define	VXGE_HW_FIFO_TXD_INT_NUMBER(val) vxge_vBIT(val, 34, 6)

#define	VXGE_HW_FIFO_TXD_INT_TYPE_PER_LIST vxge_mBIT(46)

#define	VXGE_HW_FIFO_TXD_INT_TYPE_UTILZ vxge_mBIT(47)

#define	VXGE_HW_FW_STRLEN 32
	struct vxge_hw_device_date - Date Format @day: Day @month: Month @year: Year More...

#define	VXGE_HW_NODBW_GET_TYPE(ctrl0) vxge_bVALn(ctrl0, 0, 8)

#define	VXGE_HW_NODBW_TYPE(val) vxge_vBIT(val, 0, 8)

#define	VXGE_HW_NODBW_TYPE_NODBW 0

#define	VXGE_HW_NODBW_GET_LAST_TXD_NUMBER(ctrl0) vxge_bVALn(ctrl0, 32, 8)

#define	VXGE_HW_NODBW_LAST_TXD_NUMBER(val) vxge_vBIT(val, 32, 8)

#define	VXGE_HW_NODBW_GET_NO_SNOOP(ctrl0) vxge_bVALn(ctrl0, 56, 8)

#define	VXGE_HW_NODBW_LIST_NO_SNOOP(val) vxge_vBIT(val, 56, 8)

#define	VXGE_HW_NODBW_LIST_NO_SNOOP_TXD_READ_TXD0_WRITE 0x2

#define	VXGE_HW_NODBW_LIST_NO_SNOOP_TX_FRAME_DATA_READ 0x1

#define	VXGE_HW_FIFO_TXD_DEPTH 128

#define	VXGE_HW_MAX_RXDS_PER_BLOCK_1 127

#define	END_OF_BLOCK 0xFEFFFFFFFFFFFFFFULL

#define	VXGE_HW_RING_RXD_QWORDS_MODE_1 4

#define	VXGE_HW_RING_RXD_QWORD_LIMIT 16

#define	VXGE_HW_RING_BUF_PER_BLOCK 9

#define	VXGE_HW_RING_RX_POLL_WEIGHT 8

#define	VXGE_HW_VP_NOT_OPEN 0

#define	VXGE_HW_VP_OPEN 1

#define	VXGE_HW_INFO_LEN 64

#define	VXGE_HW_PMD_INFO_LEN 16

#define	VXGE_MAX_PRINT_BUF_SIZE 128

#define	VXGE_HW_NO_MR_NO_SR_NORMAL_FUNCTION 0

#define	VXGE_HW_MR_NO_SR_VH0_BASE_FUNCTION 1

#define	VXGE_HW_NO_MR_SR_VH0_FUNCTION0 2

#define	VXGE_HW_NO_MR_SR_VH0_VIRTUAL_FUNCTION 3

#define	VXGE_HW_MR_SR_VH0_INVALID_CONFIG 4

#define	VXGE_HW_SR_VH_FUNCTION0 5

#define	VXGE_HW_SR_VH_VIRTUAL_FUNCTION 6

#define	VXGE_HW_VH_NORMAL_FUNCTION 7

#define	VXGE_HW_FUNCTION_MODE_MIN 0

#define	VXGE_HW_FUNCTION_MODE_MAX 11

#define	VXGE_HW_FUNCTION_MODE_SINGLE_FUNCTION 0

#define	VXGE_HW_FUNCTION_MODE_MULTI_FUNCTION 1

#define	VXGE_HW_FUNCTION_MODE_SRIOV 2

#define	VXGE_HW_FUNCTION_MODE_MRIOV 3

#define	VXGE_HW_FUNCTION_MODE_MRIOV_8 4

#define	VXGE_HW_FUNCTION_MODE_MULTI_FUNCTION_17 5

#define	VXGE_HW_FUNCTION_MODE_SRIOV_8 6

#define	VXGE_HW_FUNCTION_MODE_SRIOV_4 7

#define	VXGE_HW_FUNCTION_MODE_MULTI_FUNCTION_2 8

#define	VXGE_HW_FUNCTION_MODE_MULTI_FUNCTION_4 9

#define	VXGE_HW_FUNCTION_MODE_MRIOV_4 10

#define	VXGE_HW_FUNCTION_MODE_MULTI_FUNCTION_DIRECT_IO 11

#define	VXGE_HW_DEVICE_MAGIC 0x12345678

#define	VXGE_HW_DEVICE_DEAD 0xDEADDEAD

#define	VXGE_HW_DEVICE_ACCESS_RIGHT_VPATH 0x1

#define	VXGE_HW_DEVICE_ACCESS_RIGHT_SRPCIM 0x2

#define	VXGE_HW_DEVICE_ACCESS_RIGHT_MRPCIM 0x4

#define	VXGE_HW_DEVICE_LINK_STATE_SET(hldev, ls) (hldev->link_state = ls)

#define	VXGE_HW_DEVICE_TIM_INT_MASK_SET(m0, m1, i)

#define	VXGE_HW_DEVICE_TIM_INT_MASK_RESET(m0, m1, i)

#define	vxge_debug(mask, fmt...)

#define	vxge_trace() vxge_debug(VXGE_TRACE, "%s:%d\n", __func__, __LINE__);

Enumerations
enum	vxge_hw_status { VXGE_HW_OK = 0, VXGE_HW_FAIL = 1, VXGE_HW_PENDING = 2, VXGE_HW_COMPLETIONS_REMAIN = 3, VXGE_HW_INF_NO_MORE_COMPLETED_DESCRIPTORS = VXGE_HW_BASE_INF + 1, VXGE_HW_INF_OUT_OF_DESCRIPTORS = VXGE_HW_BASE_INF + 2, VXGE_HW_INF_SW_LRO_BEGIN = VXGE_HW_BASE_INF + 3, VXGE_HW_INF_SW_LRO_CONT = VXGE_HW_BASE_INF + 4, VXGE_HW_INF_SW_LRO_UNCAPABLE = VXGE_HW_BASE_INF + 5, VXGE_HW_INF_SW_LRO_FLUSH_SESSION = VXGE_HW_BASE_INF + 6, VXGE_HW_INF_SW_LRO_FLUSH_BOTH = VXGE_HW_BASE_INF + 7, VXGE_HW_ERR_INVALID_HANDLE = VXGE_HW_BASE_ERR + 1, VXGE_HW_ERR_OUT_OF_MEMORY = VXGE_HW_BASE_ERR + 2, VXGE_HW_ERR_VPATH_NOT_AVAILABLE = VXGE_HW_BASE_ERR + 3, VXGE_HW_ERR_VPATH_NOT_OPEN = VXGE_HW_BASE_ERR + 4, VXGE_HW_ERR_WRONG_IRQ = VXGE_HW_BASE_ERR + 5, VXGE_HW_ERR_SWAPPER_CTRL = VXGE_HW_BASE_ERR + 6, VXGE_HW_ERR_INVALID_MTU_SIZE = VXGE_HW_BASE_ERR + 7, VXGE_HW_ERR_INVALID_INDEX = VXGE_HW_BASE_ERR + 8, VXGE_HW_ERR_INVALID_TYPE = VXGE_HW_BASE_ERR + 9, VXGE_HW_ERR_INVALID_OFFSET = VXGE_HW_BASE_ERR + 10, VXGE_HW_ERR_INVALID_DEVICE = VXGE_HW_BASE_ERR + 11, VXGE_HW_ERR_VERSION_CONFLICT = VXGE_HW_BASE_ERR + 12, VXGE_HW_ERR_INVALID_PCI_INFO = VXGE_HW_BASE_ERR + 13, VXGE_HW_ERR_INVALID_TCODE = VXGE_HW_BASE_ERR + 14, VXGE_HW_ERR_INVALID_BLOCK_SIZE = VXGE_HW_BASE_ERR + 15, VXGE_HW_ERR_INVALID_STATE = VXGE_HW_BASE_ERR + 16, VXGE_HW_ERR_PRIVILAGED_OPEARATION = VXGE_HW_BASE_ERR + 17, VXGE_HW_ERR_INVALID_PORT = VXGE_HW_BASE_ERR + 18, VXGE_HW_ERR_FIFO = VXGE_HW_BASE_ERR + 19, VXGE_HW_ERR_VPATH = VXGE_HW_BASE_ERR + 20, VXGE_HW_ERR_CRITICAL = VXGE_HW_BASE_ERR + 21, VXGE_HW_ERR_SLOT_FREEZE = VXGE_HW_BASE_ERR + 22, VXGE_HW_ERR_INVALID_MIN_BANDWIDTH = VXGE_HW_BASE_ERR + 25, VXGE_HW_ERR_INVALID_MAX_BANDWIDTH = VXGE_HW_BASE_ERR + 26, VXGE_HW_ERR_INVALID_TOTAL_BANDWIDTH = VXGE_HW_BASE_ERR + 27, VXGE_HW_ERR_INVALID_BANDWIDTH_LIMIT = VXGE_HW_BASE_ERR + 28, VXGE_HW_ERR_RESET_IN_PROGRESS = VXGE_HW_BASE_ERR + 29, VXGE_HW_ERR_OUT_OF_SPACE = VXGE_HW_BASE_ERR + 30, VXGE_HW_ERR_INVALID_FUNC_MODE = VXGE_HW_BASE_ERR + 31, VXGE_HW_ERR_INVALID_DP_MODE = VXGE_HW_BASE_ERR + 32, VXGE_HW_ERR_INVALID_FAILURE_BEHAVIOUR = VXGE_HW_BASE_ERR + 33, VXGE_HW_ERR_INVALID_L2_SWITCH_STATE = VXGE_HW_BASE_ERR + 34, VXGE_HW_ERR_INVALID_CATCH_BASIN_MODE = VXGE_HW_BASE_ERR + 35, VXGE_HW_BADCFG_RING_INDICATE_MAX_PKTS = VXGE_HW_BASE_BADCFG + 1, VXGE_HW_BADCFG_FIFO_BLOCKS = VXGE_HW_BASE_BADCFG + 2, VXGE_HW_BADCFG_VPATH_MTU = VXGE_HW_BASE_BADCFG + 3, VXGE_HW_BADCFG_VPATH_RPA_STRIP_VLAN_TAG = VXGE_HW_BASE_BADCFG + 4, VXGE_HW_BADCFG_VPATH_MIN_BANDWIDTH = VXGE_HW_BASE_BADCFG + 5, VXGE_HW_BADCFG_VPATH_BANDWIDTH_LIMIT = VXGE_HW_BASE_BADCFG + 6, VXGE_HW_BADCFG_INTR_MODE = VXGE_HW_BASE_BADCFG + 7, VXGE_HW_BADCFG_RTS_MAC_EN = VXGE_HW_BASE_BADCFG + 8, VXGE_HW_BADCFG_VPATH_AGGR_ACK = VXGE_HW_BASE_BADCFG + 9, VXGE_HW_BADCFG_VPATH_PRIORITY = VXGE_HW_BASE_BADCFG + 10, VXGE_HW_EOF_TRACE_BUF = -1 }

enum	vxge_hw_device_link_state { VXGE_HW_LINK_NONE, VXGE_HW_LINK_DOWN, VXGE_HW_LINK_UP }
	enum enum vxge_hw_device_link_state - Link state enumeration. More...

enum	vxge_hw_txdl_state { VXGE_HW_TXDL_STATE_NONE = 0, VXGE_HW_TXDL_STATE_AVAIL = 1, VXGE_HW_TXDL_STATE_POSTED = 2, VXGE_HW_TXDL_STATE_FREED = 3 }
	enum enum vxge_hw_txdl_state - Descriptor (TXDL) state. More...

Functions
	FILE_LICENCE (GPL2_ONLY)

u64	__vxge_hw_vpath_pci_func_mode_get (u32 vp_id, struct vxge_hw_vpath_reg __iomem *vpath_reg)

static void	__vxge_hw_desc_offset_up (u16 upper_limit, u16 *offset)

static void	vxge_hw_ring_rxd_offset_up (u16 *offset)

static void	vxge_hw_fifo_txd_offset_up (u16 *offset)

static void	vxge_hw_ring_rxd_1b_set (struct vxge_hw_ring_rxd_1 rxdp, struct io_buffer iob, u32 size)
	vxge_hw_ring_rxd_1b_set - Prepare 1-buffer-mode descriptor. More...

enum vxge_hw_status	vxge_hw_device_hw_info_get (struct pci_device pdev, void __iomem bar0, struct vxge_hw_device_hw_info *hw_info)
	vxge_hw_device_hw_info_get - Get the hw information Returns the vpath mask that has the bits set for each vpath allocated for the driver, FW version information and the first mac addresse for each vpath More...

enum vxge_hw_status	__vxge_hw_vpath_fw_ver_get (struct vxge_hw_vpath_reg __iomem vpath_reg, struct vxge_hw_device_hw_info hw_info)

enum vxge_hw_status	__vxge_hw_vpath_card_info_get (struct vxge_hw_vpath_reg __iomem vpath_reg, struct vxge_hw_device_hw_info hw_info)

static enum vxge_hw_device_link_state	vxge_hw_device_link_state_get (struct __vxge_hw_device *devh)
	vxge_hw_device_link_state_get - Get link state. More...

void	vxge_hw_device_terminate (struct __vxge_hw_device *devh)

enum vxge_hw_status	vxge_hw_device_initialize (struct __vxge_hw_device *devh, void bar0, struct pci_device *pdev, u8 titan1)

enum vxge_hw_status	vxge_hw_vpath_open (struct __vxge_hw_device hldev, struct vxge_vpath vpath)

enum vxge_hw_status	__vxge_hw_device_vpath_reset_in_prog_check (u64 __iomem *vpath_rst_in_prog)

enum vxge_hw_status	vxge_hw_vpath_close (struct __vxge_hw_virtualpath *vpath)

enum vxge_hw_status	vxge_hw_vpath_reset (struct __vxge_hw_virtualpath *vpath)

enum vxge_hw_status	vxge_hw_vpath_recover_from_reset (struct __vxge_hw_virtualpath *vpath)

void	vxge_hw_vpath_enable (struct __vxge_hw_virtualpath *vpath)

enum vxge_hw_status	vxge_hw_vpath_mtu_set (struct __vxge_hw_virtualpath *vpath, u32 new_mtu)

void	vxge_hw_vpath_rx_doorbell_init (struct __vxge_hw_virtualpath *vpath)

void	__vxge_hw_device_pci_e_init (struct __vxge_hw_device *hldev)

enum vxge_hw_status	__vxge_hw_legacy_swapper_set (struct vxge_hw_legacy_reg __iomem *legacy_reg)

enum vxge_hw_status	__vxge_hw_vpath_swapper_set (struct vxge_hw_vpath_reg __iomem *vpath_reg)

enum vxge_hw_status	__vxge_hw_kdfc_swapper_set (struct vxge_hw_legacy_reg __iomem legacy_reg, struct vxge_hw_vpath_reg __iomem vpath_reg)

enum vxge_hw_status	__vxge_hw_device_register_poll (void __iomem *reg, u64 mask, u32 max_millis)

static void	__vxge_hw_pio_mem_write32_upper (u32 val, void __iomem *addr)

static void	__vxge_hw_pio_mem_write32_lower (u32 val, void __iomem *addr)

static enum vxge_hw_status	__vxge_hw_pio_mem_write64 (u64 val64, void __iomem *addr, u64 mask, u32 max_millis)

void	__vxge_hw_device_host_info_get (struct __vxge_hw_device *hldev)

enum vxge_hw_status	__vxge_hw_device_initialize (struct __vxge_hw_device *hldev)

enum vxge_hw_status	__vxge_hw_vpath_pci_read (struct __vxge_hw_virtualpath vpath, u32 phy_func_0, u32 offset, u32 val)

enum vxge_hw_status	__vxge_hw_vpath_addr_get (struct vxge_hw_vpath_reg __iomem *vpath_reg, u8(macaddr)[ETH_ALEN], u8(macaddr_mask)[ETH_ALEN])

u32	__vxge_hw_vpath_func_id_get (struct vxge_hw_vpmgmt_reg __iomem *vpmgmt_reg)

enum vxge_hw_status	__vxge_hw_vpath_reset_check (struct __vxge_hw_virtualpath *vpath)

enum vxge_hw_status	vxge_hw_vpath_strip_fcs_check (struct __vxge_hw_device *hldev, u64 vpath_mask)

enum vxge_hw_status	vxge_hw_get_func_mode (struct __vxge_hw_device hldev, u32 func_mode)

enum vxge_hw_status	vxge_hw_set_fw_api (struct __vxge_hw_device *hldev, u64 vp_id, u32 action, u32 offset, u64 data0, u64 data1)

void	vxge_hw_vpath_set_zero_rx_frm_len (struct __vxge_hw_device *hldev)

Variables
static const u16	debug_filter = VXGE_ERR
	vxge_debug @mask: mask for the debug @fmt: printf like format string More...

Macro Definition Documentation

◆ VXGE_CONFIG_H

#define VXGE_CONFIG_H

Definition at line 18 of file vxge_config.h.

◆ VXGE_CACHE_LINE_SIZE

#define VXGE_CACHE_LINE_SIZE 4096

Definition at line 25 of file vxge_config.h.

◆ WAIT_FACTOR

#define WAIT_FACTOR 1

Definition at line 28 of file vxge_config.h.

◆ VXGE_HW_MAC_MAX_WIRE_PORTS

#define VXGE_HW_MAC_MAX_WIRE_PORTS 2

Definition at line 30 of file vxge_config.h.

◆ VXGE_HW_MAC_MAX_AGGR_PORTS

#define VXGE_HW_MAC_MAX_AGGR_PORTS 2

Definition at line 31 of file vxge_config.h.

◆ VXGE_HW_MAC_MAX_PORTS

#define VXGE_HW_MAC_MAX_PORTS 3

Definition at line 32 of file vxge_config.h.

◆ VXGE_HW_MIN_MTU

#define VXGE_HW_MIN_MTU 68

Definition at line 34 of file vxge_config.h.

◆ VXGE_HW_MAX_MTU

#define VXGE_HW_MAX_MTU 9600

Definition at line 35 of file vxge_config.h.

◆ VXGE_HW_DEFAULT_MTU

#define VXGE_HW_DEFAULT_MTU 1500

Definition at line 36 of file vxge_config.h.

◆ __iomem

#define __iomem

Definition at line 39 of file vxge_config.h.

◆ ____cacheline_aligned

#define ____cacheline_aligned

Definition at line 43 of file vxge_config.h.

◆ VXGE_NONE

#define VXGE_NONE 0x00

debug filtering masks

Definition at line 49 of file vxge_config.h.

◆ VXGE_INFO

#define VXGE_INFO 0x01

Definition at line 50 of file vxge_config.h.

◆ VXGE_INTR

#define VXGE_INTR 0x02

Definition at line 51 of file vxge_config.h.

◆ VXGE_XMIT

#define VXGE_XMIT 0x04

Definition at line 52 of file vxge_config.h.

◆ VXGE_POLL

#define VXGE_POLL 0x08

Definition at line 53 of file vxge_config.h.

◆ VXGE_ERR

#define VXGE_ERR 0x10

Definition at line 54 of file vxge_config.h.

◆ VXGE_TRACE

#define VXGE_TRACE 0x20

Definition at line 55 of file vxge_config.h.

◆ VXGE_ALL

#define VXGE_ALL

Value:

(VXGE_INFO|VXGE_INTR|VXGE_XMIT\

|VXGE_POLL|VXGE_ERR|VXGE_TRACE)

VXGE_XMIT

#define VXGE_XMIT

Definition: vxge_config.h:52

VXGE_INFO

#define VXGE_INFO

Definition: vxge_config.h:50

VXGE_POLL

#define VXGE_POLL

Definition: vxge_config.h:53

VXGE_INTR

#define VXGE_INTR

Definition: vxge_config.h:51

VXGE_TRACE

#define VXGE_TRACE

Definition: vxge_config.h:55

VXGE_ERR

#define VXGE_ERR

Definition: vxge_config.h:54

Definition at line 56 of file vxge_config.h.

◆ NULL_VPID

#define NULL_VPID 0xFFFFFFFF

Definition at line 59 of file vxge_config.h.

◆ VXGE_HW_EVENT_BASE

#define VXGE_HW_EVENT_BASE 0

Definition at line 61 of file vxge_config.h.

◆ VXGE_LL_EVENT_BASE

#define VXGE_LL_EVENT_BASE 100

Definition at line 62 of file vxge_config.h.

◆ VXGE_HW_BASE_INF

#define VXGE_HW_BASE_INF 100

Definition at line 64 of file vxge_config.h.

◆ VXGE_HW_BASE_ERR

#define VXGE_HW_BASE_ERR 200

Definition at line 65 of file vxge_config.h.

◆ VXGE_HW_BASE_BADCFG

#define VXGE_HW_BASE_BADCFG 300

Definition at line 66 of file vxge_config.h.

◆ VXGE_HW_DEF_DEVICE_POLL_MILLIS

#define VXGE_HW_DEF_DEVICE_POLL_MILLIS 1000

Definition at line 67 of file vxge_config.h.

◆ VXGE_HW_MAX_PAYLOAD_SIZE_512

#define VXGE_HW_MAX_PAYLOAD_SIZE_512 2

Definition at line 68 of file vxge_config.h.

◆ VXGE_HW_RING_RXD_RTH_BUCKET_GET

#define VXGE_HW_RING_RXD_RTH_BUCKET_GET ( ctrl0 ) vxge_bVALn(ctrl0, 0, 7)

Definition at line 157 of file vxge_config.h.

◆ VXGE_HW_RING_RXD_LIST_OWN_ADAPTER

#define VXGE_HW_RING_RXD_LIST_OWN_ADAPTER vxge_mBIT(7)

Definition at line 159 of file vxge_config.h.

◆ VXGE_HW_RING_RXD_FAST_PATH_ELIGIBLE_GET

#define VXGE_HW_RING_RXD_FAST_PATH_ELIGIBLE_GET ( ctrl0 ) vxge_bVALn(ctrl0, 8, 1)

Definition at line 161 of file vxge_config.h.

◆ VXGE_HW_RING_RXD_L3_CKSUM_CORRECT_GET

#define VXGE_HW_RING_RXD_L3_CKSUM_CORRECT_GET ( ctrl0 ) vxge_bVALn(ctrl0, 9, 1)

Definition at line 163 of file vxge_config.h.

◆ VXGE_HW_RING_RXD_L4_CKSUM_CORRECT_GET

#define VXGE_HW_RING_RXD_L4_CKSUM_CORRECT_GET ( ctrl0 ) vxge_bVALn(ctrl0, 10, 1)

Definition at line 165 of file vxge_config.h.

◆ VXGE_HW_RING_RXD_T_CODE_GET

#define VXGE_HW_RING_RXD_T_CODE_GET ( ctrl0 ) vxge_bVALn(ctrl0, 12, 4)

Definition at line 167 of file vxge_config.h.

◆ VXGE_HW_RING_RXD_T_CODE

#define VXGE_HW_RING_RXD_T_CODE ( val ) vxge_vBIT(val, 12, 4)

Definition at line 168 of file vxge_config.h.

◆ VXGE_HW_RING_RXD_T_CODE_UNUSED

#define VXGE_HW_RING_RXD_T_CODE_UNUSED VXGE_HW_RING_T_CODE_UNUSED

Definition at line 170 of file vxge_config.h.

◆ VXGE_HW_RING_RXD_SYN_GET

#define VXGE_HW_RING_RXD_SYN_GET ( ctrl0 ) vxge_bVALn(ctrl0, 16, 1)

Definition at line 172 of file vxge_config.h.

◆ VXGE_HW_RING_RXD_IS_ICMP_GET

#define VXGE_HW_RING_RXD_IS_ICMP_GET ( ctrl0 ) vxge_bVALn(ctrl0, 17, 1)

Definition at line 174 of file vxge_config.h.

◆ VXGE_HW_RING_RXD_RTH_SPDM_HIT_GET

#define VXGE_HW_RING_RXD_RTH_SPDM_HIT_GET ( ctrl0 ) vxge_bVALn(ctrl0, 18, 1)

Definition at line 176 of file vxge_config.h.

◆ VXGE_HW_RING_RXD_RTH_IT_HIT_GET

#define VXGE_HW_RING_RXD_RTH_IT_HIT_GET ( ctrl0 ) vxge_bVALn(ctrl0, 19, 1)

Definition at line 178 of file vxge_config.h.

◆ VXGE_HW_RING_RXD_RTH_HASH_TYPE_GET

#define VXGE_HW_RING_RXD_RTH_HASH_TYPE_GET ( ctrl0 ) vxge_bVALn(ctrl0, 20, 4)

Definition at line 180 of file vxge_config.h.

◆ VXGE_HW_RING_RXD_IS_VLAN_GET

#define VXGE_HW_RING_RXD_IS_VLAN_GET ( ctrl0 ) vxge_bVALn(ctrl0, 24, 1)

Definition at line 182 of file vxge_config.h.

◆ VXGE_HW_RING_RXD_ETHER_ENCAP_GET

#define VXGE_HW_RING_RXD_ETHER_ENCAP_GET ( ctrl0 ) vxge_bVALn(ctrl0, 25, 2)

Definition at line 184 of file vxge_config.h.

◆ VXGE_HW_RING_RXD_FRAME_PROTO_GET

#define VXGE_HW_RING_RXD_FRAME_PROTO_GET ( ctrl0 ) vxge_bVALn(ctrl0, 27, 5)

Definition at line 186 of file vxge_config.h.

◆ VXGE_HW_RING_RXD_L3_CKSUM_GET

#define VXGE_HW_RING_RXD_L3_CKSUM_GET ( ctrl0 ) vxge_bVALn(ctrl0, 32, 16)

Definition at line 188 of file vxge_config.h.

◆ VXGE_HW_RING_RXD_L4_CKSUM_GET

#define VXGE_HW_RING_RXD_L4_CKSUM_GET ( ctrl0 ) vxge_bVALn(ctrl0, 48, 16)

Definition at line 190 of file vxge_config.h.

◆ VXGE_HW_RING_RXD_1_BUFFER0_SIZE_GET

#define VXGE_HW_RING_RXD_1_BUFFER0_SIZE_GET ( ctrl1 ) vxge_bVALn(ctrl1, 2, 14)

Definition at line 194 of file vxge_config.h.

◆ VXGE_HW_RING_RXD_1_BUFFER0_SIZE

#define VXGE_HW_RING_RXD_1_BUFFER0_SIZE ( val ) vxge_vBIT(val, 2, 14)

Definition at line 195 of file vxge_config.h.

◆ VXGE_HW_RING_RXD_1_BUFFER0_SIZE_MASK

#define VXGE_HW_RING_RXD_1_BUFFER0_SIZE_MASK vxge_vBIT(0x3FFF, 2, 14)

Definition at line 196 of file vxge_config.h.

◆ VXGE_HW_RING_RXD_1_RTH_HASH_VAL_GET

#define VXGE_HW_RING_RXD_1_RTH_HASH_VAL_GET ( ctrl1 ) vxge_bVALn(ctrl1, 16, 32)

Definition at line 198 of file vxge_config.h.

◆ VXGE_HW_RING_RXD_VLAN_TAG_GET

#define VXGE_HW_RING_RXD_VLAN_TAG_GET ( ctrl1 ) vxge_bVALn(ctrl1, 48, 16)

Definition at line 200 of file vxge_config.h.

◆ VXGE_HW_FIFO_TXD_LIST_OWN_ADAPTER

#define VXGE_HW_FIFO_TXD_LIST_OWN_ADAPTER vxge_mBIT(7)

Definition at line 214 of file vxge_config.h.

◆ VXGE_HW_FIFO_TXD_T_CODE_GET

#define VXGE_HW_FIFO_TXD_T_CODE_GET ( ctrl0 ) vxge_bVALn(ctrl0, 12, 4)

Definition at line 216 of file vxge_config.h.

◆ VXGE_HW_FIFO_TXD_T_CODE

#define VXGE_HW_FIFO_TXD_T_CODE ( val ) vxge_vBIT(val, 12, 4)

Definition at line 217 of file vxge_config.h.

◆ VXGE_HW_FIFO_TXD_T_CODE_UNUSED

#define VXGE_HW_FIFO_TXD_T_CODE_UNUSED VXGE_HW_FIFO_T_CODE_UNUSED

Definition at line 218 of file vxge_config.h.

◆ VXGE_HW_FIFO_TXD_GATHER_CODE

#define VXGE_HW_FIFO_TXD_GATHER_CODE ( val ) vxge_vBIT(val, 22, 2)

Definition at line 220 of file vxge_config.h.

◆ VXGE_HW_FIFO_TXD_GATHER_CODE_FIRST

#define VXGE_HW_FIFO_TXD_GATHER_CODE_FIRST VXGE_HW_FIFO_GATHER_CODE_FIRST

Definition at line 221 of file vxge_config.h.

◆ VXGE_HW_FIFO_TXD_GATHER_CODE_LAST

#define VXGE_HW_FIFO_TXD_GATHER_CODE_LAST VXGE_HW_FIFO_GATHER_CODE_LAST

Definition at line 222 of file vxge_config.h.

◆ VXGE_HW_FIFO_TXD_LSO_EN

#define VXGE_HW_FIFO_TXD_LSO_EN vxge_mBIT(30)

Definition at line 224 of file vxge_config.h.

◆ VXGE_HW_FIFO_TXD_LSO_MSS

#define VXGE_HW_FIFO_TXD_LSO_MSS ( val ) vxge_vBIT(val, 34, 14)

Definition at line 225 of file vxge_config.h.

◆ VXGE_HW_FIFO_TXD_BUFFER_SIZE

#define VXGE_HW_FIFO_TXD_BUFFER_SIZE ( val ) vxge_vBIT(val, 48, 16)

Definition at line 226 of file vxge_config.h.

◆ VXGE_HW_FIFO_TXD_TX_CKO_IPV4_EN

#define VXGE_HW_FIFO_TXD_TX_CKO_IPV4_EN vxge_mBIT(5)

Definition at line 229 of file vxge_config.h.

◆ VXGE_HW_FIFO_TXD_TX_CKO_TCP_EN

#define VXGE_HW_FIFO_TXD_TX_CKO_TCP_EN vxge_mBIT(6)

Definition at line 230 of file vxge_config.h.

◆ VXGE_HW_FIFO_TXD_TX_CKO_UDP_EN

#define VXGE_HW_FIFO_TXD_TX_CKO_UDP_EN vxge_mBIT(7)

Definition at line 231 of file vxge_config.h.

◆ VXGE_HW_FIFO_TXD_VLAN_ENABLE

#define VXGE_HW_FIFO_TXD_VLAN_ENABLE vxge_mBIT(15)

Definition at line 232 of file vxge_config.h.

◆ VXGE_HW_FIFO_TXD_VLAN_TAG

#define VXGE_HW_FIFO_TXD_VLAN_TAG ( val ) vxge_vBIT(val, 16, 16)

Definition at line 234 of file vxge_config.h.

◆ VXGE_HW_FIFO_TXD_NO_BW_LIMIT

#define VXGE_HW_FIFO_TXD_NO_BW_LIMIT vxge_mBIT(43)

Definition at line 235 of file vxge_config.h.

◆ VXGE_HW_FIFO_TXD_INT_NUMBER

#define VXGE_HW_FIFO_TXD_INT_NUMBER ( val ) vxge_vBIT(val, 34, 6)

Definition at line 237 of file vxge_config.h.

◆ VXGE_HW_FIFO_TXD_INT_TYPE_PER_LIST

#define VXGE_HW_FIFO_TXD_INT_TYPE_PER_LIST vxge_mBIT(46)

Definition at line 239 of file vxge_config.h.

◆ VXGE_HW_FIFO_TXD_INT_TYPE_UTILZ

#define VXGE_HW_FIFO_TXD_INT_TYPE_UTILZ vxge_mBIT(47)

Definition at line 240 of file vxge_config.h.

◆ VXGE_HW_FW_STRLEN

#define VXGE_HW_FW_STRLEN 32

struct vxge_hw_device_date - Date Format @day: Day @month: Month @year: Year

Date: : Date in string format

Structure for returning date

Definition at line 257 of file vxge_config.h.

◆ VXGE_HW_NODBW_GET_TYPE

#define VXGE_HW_NODBW_GET_TYPE ( ctrl0 ) vxge_bVALn(ctrl0, 0, 8)

Definition at line 293 of file vxge_config.h.

◆ VXGE_HW_NODBW_TYPE

#define VXGE_HW_NODBW_TYPE ( val ) vxge_vBIT(val, 0, 8)

Definition at line 294 of file vxge_config.h.

◆ VXGE_HW_NODBW_TYPE_NODBW

#define VXGE_HW_NODBW_TYPE_NODBW 0

Definition at line 295 of file vxge_config.h.

◆ VXGE_HW_NODBW_GET_LAST_TXD_NUMBER

#define VXGE_HW_NODBW_GET_LAST_TXD_NUMBER ( ctrl0 ) vxge_bVALn(ctrl0, 32, 8)

Definition at line 297 of file vxge_config.h.

◆ VXGE_HW_NODBW_LAST_TXD_NUMBER

#define VXGE_HW_NODBW_LAST_TXD_NUMBER ( val ) vxge_vBIT(val, 32, 8)

Definition at line 298 of file vxge_config.h.

◆ VXGE_HW_NODBW_GET_NO_SNOOP

#define VXGE_HW_NODBW_GET_NO_SNOOP ( ctrl0 ) vxge_bVALn(ctrl0, 56, 8)

Definition at line 300 of file vxge_config.h.

◆ VXGE_HW_NODBW_LIST_NO_SNOOP

#define VXGE_HW_NODBW_LIST_NO_SNOOP ( val ) vxge_vBIT(val, 56, 8)

Definition at line 301 of file vxge_config.h.

◆ VXGE_HW_NODBW_LIST_NO_SNOOP_TXD_READ_TXD0_WRITE

#define VXGE_HW_NODBW_LIST_NO_SNOOP_TXD_READ_TXD0_WRITE 0x2

Definition at line 302 of file vxge_config.h.

◆ VXGE_HW_NODBW_LIST_NO_SNOOP_TX_FRAME_DATA_READ

#define VXGE_HW_NODBW_LIST_NO_SNOOP_TX_FRAME_DATA_READ 0x1

Definition at line 303 of file vxge_config.h.

◆ VXGE_HW_FIFO_TXD_DEPTH

#define VXGE_HW_FIFO_TXD_DEPTH 128

Definition at line 329 of file vxge_config.h.

◆ VXGE_HW_MAX_RXDS_PER_BLOCK_1

#define VXGE_HW_MAX_RXDS_PER_BLOCK_1 127

Definition at line 341 of file vxge_config.h.

◆ END_OF_BLOCK

#define END_OF_BLOCK 0xFEFFFFFFFFFFFFFFULL

Definition at line 345 of file vxge_config.h.

◆ VXGE_HW_RING_RXD_QWORDS_MODE_1

#define VXGE_HW_RING_RXD_QWORDS_MODE_1 4

Definition at line 364 of file vxge_config.h.

◆ VXGE_HW_RING_RXD_QWORD_LIMIT

#define VXGE_HW_RING_RXD_QWORD_LIMIT 16

Definition at line 367 of file vxge_config.h.

◆ VXGE_HW_RING_BUF_PER_BLOCK

#define VXGE_HW_RING_BUF_PER_BLOCK 9

Definition at line 371 of file vxge_config.h.

◆ VXGE_HW_RING_RX_POLL_WEIGHT

#define VXGE_HW_RING_RX_POLL_WEIGHT 8

Definition at line 375 of file vxge_config.h.

◆ VXGE_HW_VP_NOT_OPEN

#define VXGE_HW_VP_NOT_OPEN 0

Definition at line 393 of file vxge_config.h.

◆ VXGE_HW_VP_OPEN

#define VXGE_HW_VP_OPEN 1

Definition at line 394 of file vxge_config.h.

◆ VXGE_HW_INFO_LEN

#define VXGE_HW_INFO_LEN 64

Definition at line 409 of file vxge_config.h.

◆ VXGE_HW_PMD_INFO_LEN

#define VXGE_HW_PMD_INFO_LEN 16

Definition at line 410 of file vxge_config.h.

◆ VXGE_MAX_PRINT_BUF_SIZE

#define VXGE_MAX_PRINT_BUF_SIZE 128

Definition at line 411 of file vxge_config.h.

◆ VXGE_HW_NO_MR_NO_SR_NORMAL_FUNCTION

#define VXGE_HW_NO_MR_NO_SR_NORMAL_FUNCTION 0

Definition at line 429 of file vxge_config.h.

◆ VXGE_HW_MR_NO_SR_VH0_BASE_FUNCTION

#define VXGE_HW_MR_NO_SR_VH0_BASE_FUNCTION 1

Definition at line 430 of file vxge_config.h.

◆ VXGE_HW_NO_MR_SR_VH0_FUNCTION0

#define VXGE_HW_NO_MR_SR_VH0_FUNCTION0 2

Definition at line 431 of file vxge_config.h.

◆ VXGE_HW_NO_MR_SR_VH0_VIRTUAL_FUNCTION

#define VXGE_HW_NO_MR_SR_VH0_VIRTUAL_FUNCTION 3

Definition at line 432 of file vxge_config.h.

◆ VXGE_HW_MR_SR_VH0_INVALID_CONFIG

#define VXGE_HW_MR_SR_VH0_INVALID_CONFIG 4

Definition at line 433 of file vxge_config.h.

◆ VXGE_HW_SR_VH_FUNCTION0

#define VXGE_HW_SR_VH_FUNCTION0 5

Definition at line 434 of file vxge_config.h.

◆ VXGE_HW_SR_VH_VIRTUAL_FUNCTION

#define VXGE_HW_SR_VH_VIRTUAL_FUNCTION 6

Definition at line 435 of file vxge_config.h.

◆ VXGE_HW_VH_NORMAL_FUNCTION

#define VXGE_HW_VH_NORMAL_FUNCTION 7

Definition at line 436 of file vxge_config.h.

◆ VXGE_HW_FUNCTION_MODE_MIN

#define VXGE_HW_FUNCTION_MODE_MIN 0

Definition at line 438 of file vxge_config.h.

◆ VXGE_HW_FUNCTION_MODE_MAX

#define VXGE_HW_FUNCTION_MODE_MAX 11

Definition at line 439 of file vxge_config.h.

◆ VXGE_HW_FUNCTION_MODE_SINGLE_FUNCTION

#define VXGE_HW_FUNCTION_MODE_SINGLE_FUNCTION 0

Definition at line 441 of file vxge_config.h.

◆ VXGE_HW_FUNCTION_MODE_MULTI_FUNCTION

#define VXGE_HW_FUNCTION_MODE_MULTI_FUNCTION 1

Definition at line 442 of file vxge_config.h.

◆ VXGE_HW_FUNCTION_MODE_SRIOV

#define VXGE_HW_FUNCTION_MODE_SRIOV 2

Definition at line 443 of file vxge_config.h.

◆ VXGE_HW_FUNCTION_MODE_MRIOV

#define VXGE_HW_FUNCTION_MODE_MRIOV 3

Definition at line 444 of file vxge_config.h.

◆ VXGE_HW_FUNCTION_MODE_MRIOV_8

#define VXGE_HW_FUNCTION_MODE_MRIOV_8 4

Definition at line 445 of file vxge_config.h.

◆ VXGE_HW_FUNCTION_MODE_MULTI_FUNCTION_17

#define VXGE_HW_FUNCTION_MODE_MULTI_FUNCTION_17 5

Definition at line 446 of file vxge_config.h.

◆ VXGE_HW_FUNCTION_MODE_SRIOV_8

#define VXGE_HW_FUNCTION_MODE_SRIOV_8 6

Definition at line 447 of file vxge_config.h.

◆ VXGE_HW_FUNCTION_MODE_SRIOV_4

#define VXGE_HW_FUNCTION_MODE_SRIOV_4 7

Definition at line 448 of file vxge_config.h.

◆ VXGE_HW_FUNCTION_MODE_MULTI_FUNCTION_2

#define VXGE_HW_FUNCTION_MODE_MULTI_FUNCTION_2 8

Definition at line 449 of file vxge_config.h.

◆ VXGE_HW_FUNCTION_MODE_MULTI_FUNCTION_4

#define VXGE_HW_FUNCTION_MODE_MULTI_FUNCTION_4 9

Definition at line 450 of file vxge_config.h.

◆ VXGE_HW_FUNCTION_MODE_MRIOV_4

#define VXGE_HW_FUNCTION_MODE_MRIOV_4 10

Definition at line 451 of file vxge_config.h.

◆ VXGE_HW_FUNCTION_MODE_MULTI_FUNCTION_DIRECT_IO

#define VXGE_HW_FUNCTION_MODE_MULTI_FUNCTION_DIRECT_IO 11

Definition at line 452 of file vxge_config.h.

◆ VXGE_HW_DEVICE_MAGIC

#define VXGE_HW_DEVICE_MAGIC 0x12345678

Definition at line 479 of file vxge_config.h.

◆ VXGE_HW_DEVICE_DEAD

#define VXGE_HW_DEVICE_DEAD 0xDEADDEAD

Definition at line 480 of file vxge_config.h.

◆ VXGE_HW_DEVICE_ACCESS_RIGHT_VPATH

#define VXGE_HW_DEVICE_ACCESS_RIGHT_VPATH 0x1

Definition at line 492 of file vxge_config.h.

◆ VXGE_HW_DEVICE_ACCESS_RIGHT_SRPCIM

#define VXGE_HW_DEVICE_ACCESS_RIGHT_SRPCIM 0x2

Definition at line 493 of file vxge_config.h.

◆ VXGE_HW_DEVICE_ACCESS_RIGHT_MRPCIM

#define VXGE_HW_DEVICE_ACCESS_RIGHT_MRPCIM 0x4

Definition at line 494 of file vxge_config.h.

◆ VXGE_HW_DEVICE_LINK_STATE_SET

#define VXGE_HW_DEVICE_LINK_STATE_SET	(	hldev,
		ls
	)	(hldev->link_state = ls)

Definition at line 517 of file vxge_config.h.

◆ VXGE_HW_DEVICE_TIM_INT_MASK_SET

#define VXGE_HW_DEVICE_TIM_INT_MASK_SET	(	m0,
		m1,
		i
	)

Value:

{       \
        if (i < 16) {                                   \
                m0[0] |= vxge_vBIT(0x8, (i*4), 4);      \
                m0[1] |= vxge_vBIT(0x4, (i*4), 4);      \
        }                                       \
        else {                                  \
                m1[0] = 0x80000000;             \
                m1[1] = 0x40000000;             \
        }                                       \
}

Definition at line 519 of file vxge_config.h.

◆ VXGE_HW_DEVICE_TIM_INT_MASK_RESET

#define VXGE_HW_DEVICE_TIM_INT_MASK_RESET	(	m0,
		m1,
		i
	)

Value:

{       \
        if (i < 16) {                                   \
                m0[0] &= ~vxge_vBIT(0x8, (i*4), 4);     \
                m0[1] &= ~vxge_vBIT(0x4, (i*4), 4);     \
        }                                               \
        else {                                          \
                m1[0] = 0;                              \
                m1[1] = 0;                              \
        }                                               \
}

Definition at line 530 of file vxge_config.h.

◆ vxge_debug

#define vxge_debug	(	mask,
		fmt...
	)

Value:

do {    \
                if (debug_filter & mask)        \
                        DBG(fmt);               \
        } while (0);

Definition at line 762 of file vxge_config.h.

◆ vxge_trace

#define vxge_trace ( ) vxge_debug(VXGE_TRACE, "%s:%d\n", __func__, __LINE__);

Definition at line 767 of file vxge_config.h.

Enumeration Type Documentation

◆ vxge_hw_status

enum vxge_hw_status

Enumerator
VXGE_HW_OK
VXGE_HW_FAIL
VXGE_HW_PENDING
VXGE_HW_COMPLETIONS_REMAIN
VXGE_HW_INF_NO_MORE_COMPLETED_DESCRIPTORS
VXGE_HW_INF_OUT_OF_DESCRIPTORS
VXGE_HW_INF_SW_LRO_BEGIN
VXGE_HW_INF_SW_LRO_CONT
VXGE_HW_INF_SW_LRO_UNCAPABLE
VXGE_HW_INF_SW_LRO_FLUSH_SESSION
VXGE_HW_INF_SW_LRO_FLUSH_BOTH
VXGE_HW_ERR_INVALID_HANDLE
VXGE_HW_ERR_OUT_OF_MEMORY
VXGE_HW_ERR_VPATH_NOT_AVAILABLE
VXGE_HW_ERR_VPATH_NOT_OPEN
VXGE_HW_ERR_WRONG_IRQ
VXGE_HW_ERR_SWAPPER_CTRL
VXGE_HW_ERR_INVALID_MTU_SIZE
VXGE_HW_ERR_INVALID_INDEX
VXGE_HW_ERR_INVALID_TYPE
VXGE_HW_ERR_INVALID_OFFSET
VXGE_HW_ERR_INVALID_DEVICE
VXGE_HW_ERR_VERSION_CONFLICT
VXGE_HW_ERR_INVALID_PCI_INFO
VXGE_HW_ERR_INVALID_TCODE
VXGE_HW_ERR_INVALID_BLOCK_SIZE
VXGE_HW_ERR_INVALID_STATE
VXGE_HW_ERR_PRIVILAGED_OPEARATION
VXGE_HW_ERR_INVALID_PORT
VXGE_HW_ERR_FIFO
VXGE_HW_ERR_VPATH
VXGE_HW_ERR_CRITICAL
VXGE_HW_ERR_SLOT_FREEZE
VXGE_HW_ERR_INVALID_MIN_BANDWIDTH
VXGE_HW_ERR_INVALID_MAX_BANDWIDTH
VXGE_HW_ERR_INVALID_TOTAL_BANDWIDTH
VXGE_HW_ERR_INVALID_BANDWIDTH_LIMIT
VXGE_HW_ERR_RESET_IN_PROGRESS
VXGE_HW_ERR_OUT_OF_SPACE
VXGE_HW_ERR_INVALID_FUNC_MODE
VXGE_HW_ERR_INVALID_DP_MODE
VXGE_HW_ERR_INVALID_FAILURE_BEHAVIOUR
VXGE_HW_ERR_INVALID_L2_SWITCH_STATE
VXGE_HW_ERR_INVALID_CATCH_BASIN_MODE
VXGE_HW_BADCFG_RING_INDICATE_MAX_PKTS
VXGE_HW_BADCFG_FIFO_BLOCKS
VXGE_HW_BADCFG_VPATH_MTU
VXGE_HW_BADCFG_VPATH_RPA_STRIP_VLAN_TAG
VXGE_HW_BADCFG_VPATH_MIN_BANDWIDTH
VXGE_HW_BADCFG_VPATH_BANDWIDTH_LIMIT
VXGE_HW_BADCFG_INTR_MODE
VXGE_HW_BADCFG_RTS_MAC_EN
VXGE_HW_BADCFG_VPATH_AGGR_ACK
VXGE_HW_BADCFG_VPATH_PRIORITY
VXGE_HW_EOF_TRACE_BUF

Definition at line 70 of file vxge_config.h.

                     {
         VXGE_HW_OK                                = 0,
         VXGE_HW_FAIL                              = 1,
         VXGE_HW_PENDING                           = 2,
         VXGE_HW_COMPLETIONS_REMAIN                = 3,
 
         VXGE_HW_INF_NO_MORE_COMPLETED_DESCRIPTORS = VXGE_HW_BASE_INF + 1,
         VXGE_HW_INF_OUT_OF_DESCRIPTORS            = VXGE_HW_BASE_INF + 2,
         VXGE_HW_INF_SW_LRO_BEGIN                  = VXGE_HW_BASE_INF + 3,
         VXGE_HW_INF_SW_LRO_CONT                   = VXGE_HW_BASE_INF + 4,
         VXGE_HW_INF_SW_LRO_UNCAPABLE              = VXGE_HW_BASE_INF + 5,
         VXGE_HW_INF_SW_LRO_FLUSH_SESSION          = VXGE_HW_BASE_INF + 6,
         VXGE_HW_INF_SW_LRO_FLUSH_BOTH             = VXGE_HW_BASE_INF + 7,
 
         VXGE_HW_ERR_INVALID_HANDLE                = VXGE_HW_BASE_ERR + 1,
         VXGE_HW_ERR_OUT_OF_MEMORY                 = VXGE_HW_BASE_ERR + 2,
         VXGE_HW_ERR_VPATH_NOT_AVAILABLE           = VXGE_HW_BASE_ERR + 3,
         VXGE_HW_ERR_VPATH_NOT_OPEN                = VXGE_HW_BASE_ERR + 4,
         VXGE_HW_ERR_WRONG_IRQ                     = VXGE_HW_BASE_ERR + 5,
         VXGE_HW_ERR_SWAPPER_CTRL                  = VXGE_HW_BASE_ERR + 6,
         VXGE_HW_ERR_INVALID_MTU_SIZE              = VXGE_HW_BASE_ERR + 7,
         VXGE_HW_ERR_INVALID_INDEX                 = VXGE_HW_BASE_ERR + 8,
         VXGE_HW_ERR_INVALID_TYPE                  = VXGE_HW_BASE_ERR + 9,
         VXGE_HW_ERR_INVALID_OFFSET                = VXGE_HW_BASE_ERR + 10,
         VXGE_HW_ERR_INVALID_DEVICE                = VXGE_HW_BASE_ERR + 11,
         VXGE_HW_ERR_VERSION_CONFLICT              = VXGE_HW_BASE_ERR + 12,
         VXGE_HW_ERR_INVALID_PCI_INFO              = VXGE_HW_BASE_ERR + 13,
         VXGE_HW_ERR_INVALID_TCODE                 = VXGE_HW_BASE_ERR + 14,
         VXGE_HW_ERR_INVALID_BLOCK_SIZE            = VXGE_HW_BASE_ERR + 15,
         VXGE_HW_ERR_INVALID_STATE                 = VXGE_HW_BASE_ERR + 16,
         VXGE_HW_ERR_PRIVILAGED_OPEARATION         = VXGE_HW_BASE_ERR + 17,
         VXGE_HW_ERR_INVALID_PORT                  = VXGE_HW_BASE_ERR + 18,
         VXGE_HW_ERR_FIFO                          = VXGE_HW_BASE_ERR + 19,
         VXGE_HW_ERR_VPATH                         = VXGE_HW_BASE_ERR + 20,
         VXGE_HW_ERR_CRITICAL                      = VXGE_HW_BASE_ERR + 21,
         VXGE_HW_ERR_SLOT_FREEZE                   = VXGE_HW_BASE_ERR + 22,
         VXGE_HW_ERR_INVALID_MIN_BANDWIDTH         = VXGE_HW_BASE_ERR + 25,
         VXGE_HW_ERR_INVALID_MAX_BANDWIDTH         = VXGE_HW_BASE_ERR + 26,
         VXGE_HW_ERR_INVALID_TOTAL_BANDWIDTH       = VXGE_HW_BASE_ERR + 27,
         VXGE_HW_ERR_INVALID_BANDWIDTH_LIMIT       = VXGE_HW_BASE_ERR + 28,
         VXGE_HW_ERR_RESET_IN_PROGRESS             = VXGE_HW_BASE_ERR + 29,
         VXGE_HW_ERR_OUT_OF_SPACE                  = VXGE_HW_BASE_ERR + 30,
         VXGE_HW_ERR_INVALID_FUNC_MODE             = VXGE_HW_BASE_ERR + 31,
         VXGE_HW_ERR_INVALID_DP_MODE               = VXGE_HW_BASE_ERR + 32,
         VXGE_HW_ERR_INVALID_FAILURE_BEHAVIOUR     = VXGE_HW_BASE_ERR + 33,
         VXGE_HW_ERR_INVALID_L2_SWITCH_STATE       = VXGE_HW_BASE_ERR + 34,
         VXGE_HW_ERR_INVALID_CATCH_BASIN_MODE      = VXGE_HW_BASE_ERR + 35,
 
         VXGE_HW_BADCFG_RING_INDICATE_MAX_PKTS     = VXGE_HW_BASE_BADCFG + 1,
         VXGE_HW_BADCFG_FIFO_BLOCKS                = VXGE_HW_BASE_BADCFG + 2,
         VXGE_HW_BADCFG_VPATH_MTU                  = VXGE_HW_BASE_BADCFG + 3,
         VXGE_HW_BADCFG_VPATH_RPA_STRIP_VLAN_TAG   = VXGE_HW_BASE_BADCFG + 4,
         VXGE_HW_BADCFG_VPATH_MIN_BANDWIDTH        = VXGE_HW_BASE_BADCFG + 5,
         VXGE_HW_BADCFG_VPATH_BANDWIDTH_LIMIT      = VXGE_HW_BASE_BADCFG + 6,
         VXGE_HW_BADCFG_INTR_MODE                  = VXGE_HW_BASE_BADCFG + 7,
         VXGE_HW_BADCFG_RTS_MAC_EN                 = VXGE_HW_BASE_BADCFG + 8,
         VXGE_HW_BADCFG_VPATH_AGGR_ACK             = VXGE_HW_BASE_BADCFG + 9,
         VXGE_HW_BADCFG_VPATH_PRIORITY             = VXGE_HW_BASE_BADCFG + 10,
 
         VXGE_HW_EOF_TRACE_BUF                     = -1
 };

◆ vxge_hw_device_link_state

enum vxge_hw_device_link_state

enum enum vxge_hw_device_link_state - Link state enumeration.

@VXGE_HW_LINK_NONE: Invalid link state. @VXGE_HW_LINK_DOWN: Link is down. @VXGE_HW_LINK_UP: Link is up.

Enumerator
VXGE_HW_LINK_NONE
VXGE_HW_LINK_DOWN
VXGE_HW_LINK_UP

Definition at line 139 of file vxge_config.h.

                                {
         VXGE_HW_LINK_NONE,
         VXGE_HW_LINK_DOWN,
         VXGE_HW_LINK_UP
 };

◆ vxge_hw_txdl_state

enum vxge_hw_txdl_state

enum enum vxge_hw_txdl_state - Descriptor (TXDL) state.

@VXGE_HW_TXDL_STATE_NONE: Invalid state. @VXGE_HW_TXDL_STATE_AVAIL: Descriptor is available for reservation. @VXGE_HW_TXDL_STATE_POSTED: Descriptor is posted for processing by the device. @VXGE_HW_TXDL_STATE_FREED: Descriptor is free and can be reused for filling-in and posting later.

Titan/HW descriptor states.

Enumerator
VXGE_HW_TXDL_STATE_NONE
VXGE_HW_TXDL_STATE_AVAIL
VXGE_HW_TXDL_STATE_POSTED
VXGE_HW_TXDL_STATE_FREED

Definition at line 553 of file vxge_config.h.

                         {
         VXGE_HW_TXDL_STATE_NONE = 0,
         VXGE_HW_TXDL_STATE_AVAIL        = 1,
         VXGE_HW_TXDL_STATE_POSTED       = 2,
         VXGE_HW_TXDL_STATE_FREED        = 3
 };

Function Documentation

◆ FILE_LICENCE()

FILE_LICENCE ( GPL2_ONLY )

◆ __vxge_hw_vpath_pci_func_mode_get()

u64 __vxge_hw_vpath_pci_func_mode_get	(	u32	vp_id,
		struct vxge_hw_vpath_reg __iomem *	vpath_reg
	)

◆ __vxge_hw_desc_offset_up()

static void __vxge_hw_desc_offset_up	(	u16	upper_limit,
		u16 *	offset
	)

inlinestatic

Definition at line 562 of file vxge_config.h.

 {
         if (++(*offset) >= upper_limit)
                 *offset = 0;
 }

References offset.

Referenced by vxge_hw_fifo_txd_offset_up(), and vxge_hw_ring_rxd_offset_up().

◆ vxge_hw_ring_rxd_offset_up()

static void vxge_hw_ring_rxd_offset_up ( u16 * offset )

inlinestatic

Definition at line 570 of file vxge_config.h.

 {
         __vxge_hw_desc_offset_up(VXGE_HW_MAX_RXDS_PER_BLOCK_1,
                         offset);
 }

References __vxge_hw_desc_offset_up(), offset, and VXGE_HW_MAX_RXDS_PER_BLOCK_1.

Referenced by vxge_hw_vpath_poll_rx().

◆ vxge_hw_fifo_txd_offset_up()

static void vxge_hw_fifo_txd_offset_up ( u16 * offset )

inlinestatic

Definition at line 576 of file vxge_config.h.

 {
         __vxge_hw_desc_offset_up(VXGE_HW_FIFO_TXD_DEPTH, offset);
 }

References __vxge_hw_desc_offset_up(), offset, and VXGE_HW_FIFO_TXD_DEPTH.

Referenced by vxge_hw_fifo_txdl_post(), and vxge_hw_vpath_poll_tx().

◆ vxge_hw_ring_rxd_1b_set()

static void vxge_hw_ring_rxd_1b_set	(	struct vxge_hw_ring_rxd_1 *	rxdp,
		struct io_buffer *	iob,
		u32	size
	)

inlinestatic

vxge_hw_ring_rxd_1b_set - Prepare 1-buffer-mode descriptor.

@rxdh: Descriptor handle. @dma_pointer: DMA address of a single receive buffer this descriptor should carry. Note that by the time vxge_hw_ring_rxd_1b_set is called, the receive buffer should be already mapped to the device @size: Size of the receive @dma_pointer buffer.

Prepare 1-buffer-mode Rx descriptor for posting (via vxge_hw_ring_rxd_post()).

This inline helper-function does not return any parameters and always succeeds.

Definition at line 597 of file vxge_config.h.

 {
         rxdp->host_control = (intptr_t)(iob);
         rxdp->buffer0_ptr = virt_to_bus(iob->data);
         rxdp->control_1 &= ~VXGE_HW_RING_RXD_1_BUFFER0_SIZE_MASK;
         rxdp->control_1 |= VXGE_HW_RING_RXD_1_BUFFER0_SIZE(size);
 }

References io_buffer::data, rxdp, size, virt_to_bus(), VXGE_HW_RING_RXD_1_BUFFER0_SIZE, and VXGE_HW_RING_RXD_1_BUFFER0_SIZE_MASK.

Referenced by vxge_hw_ring_replenish(), and vxge_hw_vpath_poll_rx().

◆ vxge_hw_device_hw_info_get()

enum vxge_hw_status vxge_hw_device_hw_info_get	(	struct pci_device *	pdev,
		void __iomem *	bar0,
		struct vxge_hw_device_hw_info *	hw_info
	)

vxge_hw_device_hw_info_get - Get the hw information Returns the vpath mask that has the bits set for each vpath allocated for the driver, FW version information and the first mac addresse for each vpath

Definition at line 385 of file vxge_config.c.

 {
         u32 i;
         u64 val64;
         struct vxge_hw_toc_reg __iomem *toc;
         struct vxge_hw_mrpcim_reg __iomem *mrpcim_reg;
         struct vxge_hw_common_reg __iomem *common_reg;
         struct vxge_hw_vpath_reg __iomem *vpath_reg;
         struct vxge_hw_vpmgmt_reg __iomem *vpmgmt_reg;
         struct vxge_hw_legacy_reg __iomem *legacy_reg;
         enum vxge_hw_status status;
 
         vxge_trace();
 
         memset(hw_info, 0, sizeof(struct vxge_hw_device_hw_info));
 
         legacy_reg = __vxge_hw_device_get_legacy_reg(pdev, bar0);
         if (legacy_reg == NULL) {
                 status = VXGE_HW_ERR_CRITICAL;
                 goto exit;
         }
 
         toc = __vxge_hw_device_toc_get(bar0, legacy_reg);
         if (toc == NULL) {
                 status = VXGE_HW_ERR_CRITICAL;
                 goto exit;
         }
 
         val64 = readq(&toc->toc_common_pointer);
         common_reg = (struct vxge_hw_common_reg __iomem *)(bar0 + val64);
 
         status = __vxge_hw_device_vpath_reset_in_prog_check(
                 (u64 __iomem *)&common_reg->vpath_rst_in_prog);
         if (status != VXGE_HW_OK)
                 goto exit;
 
         hw_info->vpath_mask = readq(&common_reg->vpath_assignments);
 
         val64 = readq(&common_reg->host_type_assignments);
 
         hw_info->host_type =
            (u32)VXGE_HW_HOST_TYPE_ASSIGNMENTS_GET_HOST_TYPE_ASSIGNMENTS(val64);
 
         for (i = 0; i < VXGE_HW_MAX_VIRTUAL_PATHS; i++) {
 
                 if (!((hw_info->vpath_mask) & vxge_mBIT(i)))
                         continue;
 
                 val64 = readq(&toc->toc_vpmgmt_pointer[i]);
 
                 vpmgmt_reg = (struct vxge_hw_vpmgmt_reg __iomem *)
                                 (bar0 + val64);
 
                 hw_info->func_id = __vxge_hw_vpath_func_id_get(vpmgmt_reg);
                 if (__vxge_hw_device_access_rights_get(hw_info->host_type,
                         hw_info->func_id) &
                         VXGE_HW_DEVICE_ACCESS_RIGHT_MRPCIM) {
 
                         val64 = readq(&toc->toc_mrpcim_pointer);
 
                         mrpcim_reg = (struct vxge_hw_mrpcim_reg __iomem *)
                                         (bar0 + val64);
 
                         writeq(0, &mrpcim_reg->xgmac_gen_fw_memo_mask);
                         wmb();
                 }
 
                 val64 = readq(&toc->toc_vpath_pointer[i]);
 
                 vpath_reg = (struct vxge_hw_vpath_reg __iomem *)(bar0 + val64);
 
                 status = __vxge_hw_vpath_fw_ver_get(vpath_reg, hw_info);
                 if (status != VXGE_HW_OK)
                         goto exit;
 
                 status = __vxge_hw_vpath_card_info_get(vpath_reg, hw_info);
                 if (status != VXGE_HW_OK)
                         goto exit;
 
                 break;
         }
 
         for (i = 0; i < VXGE_HW_MAX_VIRTUAL_PATHS; i++) {
 
                 if (!((hw_info->vpath_mask) & vxge_mBIT(i)))
                         continue;
 
                 val64 = readq(&toc->toc_vpath_pointer[i]);
                 vpath_reg = (struct vxge_hw_vpath_reg __iomem *)(bar0 + val64);
 
                 status =  __vxge_hw_vpath_addr_get(vpath_reg,
                                 hw_info->mac_addrs[i],
                                 hw_info->mac_addr_masks[i]);
                 if (status != VXGE_HW_OK)
                         goto exit;
         }
 exit:
         return status;
 }

References __iomem, __vxge_hw_device_access_rights_get(), __vxge_hw_device_get_legacy_reg(), __vxge_hw_device_toc_get(), __vxge_hw_device_vpath_reset_in_prog_check(), __vxge_hw_vpath_addr_get(), __vxge_hw_vpath_card_info_get(), __vxge_hw_vpath_func_id_get(), __vxge_hw_vpath_fw_ver_get(), vxge_hw_device_hw_info::func_id, vxge_hw_device_hw_info::host_type, vxge_hw_common_reg::host_type_assignments, memset(), NULL, readq(), status, vxge_hw_toc_reg::toc_common_pointer, vxge_hw_toc_reg::toc_mrpcim_pointer, vxge_hw_toc_reg::toc_vpath_pointer, vxge_hw_toc_reg::toc_vpmgmt_pointer, u32, vxge_hw_common_reg::vpath_assignments, vxge_hw_device_hw_info::vpath_mask, vxge_hw_common_reg::vpath_rst_in_prog, VXGE_HW_DEVICE_ACCESS_RIGHT_MRPCIM, VXGE_HW_ERR_CRITICAL, VXGE_HW_HOST_TYPE_ASSIGNMENTS_GET_HOST_TYPE_ASSIGNMENTS, VXGE_HW_MAX_VIRTUAL_PATHS, VXGE_HW_OK, vxge_mBIT, vxge_trace, wmb(), writeq(), and vxge_hw_mrpcim_reg::xgmac_gen_fw_memo_mask.

Referenced by vxge_probe().

◆ __vxge_hw_vpath_fw_ver_get()

enum vxge_hw_status __vxge_hw_vpath_fw_ver_get	(	struct vxge_hw_vpath_reg __iomem *	vpath_reg,
		struct vxge_hw_device_hw_info *	hw_info
	)

Definition at line 1057 of file vxge_config.c.

 {
         u64 val64;
         u64 data1 = 0ULL;
         u64 data2 = 0ULL;
         struct vxge_hw_device_version *fw_version = &hw_info->fw_version;
         struct vxge_hw_device_date *fw_date = &hw_info->fw_date;
         struct vxge_hw_device_version *flash_version = &hw_info->flash_version;
         struct vxge_hw_device_date *flash_date = &hw_info->flash_date;
         enum vxge_hw_status status = VXGE_HW_OK;
 
         val64 = VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION(
                 VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION_READ_ENTRY) |
                 VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(
                 VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO) |
                 VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE |
                 VXGE_HW_RTS_ACCESS_STEER_CTRL_OFFSET(0);
 
         status = __vxge_hw_pio_mem_write64(val64,
                                 &vpath_reg->rts_access_steer_ctrl,
                                 VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE,
                                 VXGE_HW_DEF_DEVICE_POLL_MILLIS);
 
         if (status != VXGE_HW_OK)
                 goto exit;
 
         val64 = readq(&vpath_reg->rts_access_steer_ctrl);
 
         if (val64 & VXGE_HW_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS) {
 
                 data1 = readq(&vpath_reg->rts_access_steer_data0);
                 data2 = readq(&vpath_reg->rts_access_steer_data1);
 
                 fw_date->day =
                         (u32)VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_DAY(
                                                 data1);
                 fw_date->month =
                         (u32)VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_MONTH(
                                                 data1);
                 fw_date->year =
                         (u32)VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_YEAR(
                                                 data1);
 
                 snprintf(fw_date->date, VXGE_HW_FW_STRLEN, "%d/%d/%d",
                         fw_date->month, fw_date->day, fw_date->year);
 
                 fw_version->major =
                     (u32)VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_MAJOR(data1);
                 fw_version->minor =
                     (u32)VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_MINOR(data1);
                 fw_version->build =
                     (u32)VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_BUILD(data1);
 
                 snprintf(fw_version->version, VXGE_HW_FW_STRLEN, "%d.%d.%d",
                     fw_version->major, fw_version->minor, fw_version->build);
 
                 flash_date->day =
                   (u32)VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_FLASH_VER_DAY(data2);
                 flash_date->month =
                  (u32)VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_FLASH_VER_MONTH(data2);
                 flash_date->year =
                  (u32)VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_FLASH_VER_YEAR(data2);
 
                 snprintf(flash_date->date, VXGE_HW_FW_STRLEN, "%d/%d/%d",
                         flash_date->month, flash_date->day, flash_date->year);
 
                 flash_version->major =
                  (u32)VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_FLASH_VER_MAJOR(data2);
                 flash_version->minor =
                  (u32)VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_FLASH_VER_MINOR(data2);
                 flash_version->build =
                  (u32)VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_FLASH_VER_BUILD(data2);
 
                 snprintf(flash_version->version, VXGE_HW_FW_STRLEN, "%d.%d.%d",
                         flash_version->major, flash_version->minor,
                         flash_version->build);
 
                 status = VXGE_HW_OK;
 
         } else
                 status = VXGE_HW_FAIL;
 exit:
         return status;
 }

Referenced by vxge_hw_device_hw_info_get().

◆ __vxge_hw_vpath_card_info_get()

enum vxge_hw_status __vxge_hw_vpath_card_info_get	(	struct vxge_hw_vpath_reg __iomem *	vpath_reg,
		struct vxge_hw_device_hw_info *	hw_info
	)

Definition at line 936 of file vxge_config.c.

 {
         u32 i, j;
         u64 val64;
         u64 data1 = 0ULL;
         u64 data2 = 0ULL;
         enum vxge_hw_status status = VXGE_HW_OK;
         u8 *serial_number = hw_info->serial_number;
         u8 *part_number = hw_info->part_number;
         u8 *product_desc = hw_info->product_desc;
 
         __vxge_hw_read_rts_ds(vpath_reg,
                 VXGE_HW_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_SERIAL_NUMBER);
 
         val64 = VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION(
                         VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION_READ_MEMO_ENTRY) |
                 VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(
                         VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO) |
                 VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE |
                 VXGE_HW_RTS_ACCESS_STEER_CTRL_OFFSET(0);
 
         status = __vxge_hw_pio_mem_write64(val64,
                                 &vpath_reg->rts_access_steer_ctrl,
                                 VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE,
                                 VXGE_HW_DEF_DEVICE_POLL_MILLIS);
 
         if (status != VXGE_HW_OK)
                 return status;
 
         val64 = readq(&vpath_reg->rts_access_steer_ctrl);
 
         if (val64 & VXGE_HW_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS) {
                 data1 = readq(&vpath_reg->rts_access_steer_data0);
                 ((u64 *)serial_number)[0] = be64_to_cpu(data1);
 
                 data2 = readq(&vpath_reg->rts_access_steer_data1);
                 ((u64 *)serial_number)[1] = be64_to_cpu(data2);
                 status = VXGE_HW_OK;
         } else
                 *serial_number = 0;
 
         __vxge_hw_read_rts_ds(vpath_reg,
                         VXGE_HW_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_PART_NUMBER);
 
         val64 = VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION(
                         VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION_READ_MEMO_ENTRY) |
                 VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(
                         VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO) |
                 VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE |
                 VXGE_HW_RTS_ACCESS_STEER_CTRL_OFFSET(0);
 
         status = __vxge_hw_pio_mem_write64(val64,
                                 &vpath_reg->rts_access_steer_ctrl,
                                 VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE,
                                 VXGE_HW_DEF_DEVICE_POLL_MILLIS);
 
         if (status != VXGE_HW_OK)
                 return status;
 
         val64 = readq(&vpath_reg->rts_access_steer_ctrl);
 
         if (val64 & VXGE_HW_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS) {
 
                 data1 = readq(&vpath_reg->rts_access_steer_data0);
                 ((u64 *)part_number)[0] = be64_to_cpu(data1);
 
                 data2 = readq(&vpath_reg->rts_access_steer_data1);
                 ((u64 *)part_number)[1] = be64_to_cpu(data2);
 
                 status = VXGE_HW_OK;
 
         } else
                 *part_number = 0;
 
         j = 0;
 
         for (i = VXGE_HW_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_DESC_0;
              i <= VXGE_HW_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_DESC_3; i++) {
 
                 __vxge_hw_read_rts_ds(vpath_reg, i);
 
                 val64 = VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION(
                         VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION_READ_MEMO_ENTRY) |
                         VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(
                         VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO) |
                         VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE |
                         VXGE_HW_RTS_ACCESS_STEER_CTRL_OFFSET(0);
 
                 status = __vxge_hw_pio_mem_write64(val64,
                                 &vpath_reg->rts_access_steer_ctrl,
                                 VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE,
                                 VXGE_HW_DEF_DEVICE_POLL_MILLIS);
 
                 if (status != VXGE_HW_OK)
                         return status;
 
                 val64 = readq(&vpath_reg->rts_access_steer_ctrl);
 
                 if (val64 & VXGE_HW_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS) {
 
                         data1 = readq(&vpath_reg->rts_access_steer_data0);
                         ((u64 *)product_desc)[j++] = be64_to_cpu(data1);
 
                         data2 = readq(&vpath_reg->rts_access_steer_data1);
                         ((u64 *)product_desc)[j++] = be64_to_cpu(data2);
 
                         status = VXGE_HW_OK;
                 } else
                         *product_desc = 0;
         }
 
         return status;
 }

Referenced by vxge_hw_device_hw_info_get().

◆ vxge_hw_device_link_state_get()

static enum vxge_hw_device_link_state vxge_hw_device_link_state_get ( struct __vxge_hw_device * devh )

inlinestatic

vxge_hw_device_link_state_get - Get link state.

@devh: HW device handle.

Get link state. Returns: link state.

Definition at line 629 of file vxge_config.h.

 {
         return devh->link_state;
 }

References __vxge_hw_device::link_state.

Referenced by vxge_open().

◆ vxge_hw_device_terminate()

void vxge_hw_device_terminate ( struct __vxge_hw_device * devh )

Definition at line 543 of file vxge_config.c.

 {
         vxge_trace();
 
         assert(hldev->magic == VXGE_HW_DEVICE_MAGIC);
 
         hldev->magic = VXGE_HW_DEVICE_DEAD;
         free(hldev);
 }

References assert(), free, __vxge_hw_device::magic, VXGE_HW_DEVICE_DEAD, VXGE_HW_DEVICE_MAGIC, and vxge_trace.

Referenced by vxge_hw_device_initialize(), vxge_probe(), and vxge_remove().

◆ vxge_hw_device_initialize()

enum vxge_hw_status vxge_hw_device_initialize	(	struct __vxge_hw_device **	devh,
		void *	bar0,
		struct pci_device *	pdev,
		u8	titan1
	)

Definition at line 496 of file vxge_config.c.

 {
         struct __vxge_hw_device *hldev = NULL;
         enum vxge_hw_status status = VXGE_HW_OK;
 
         vxge_trace();
 
         hldev = (struct __vxge_hw_device *)
                         zalloc(sizeof(struct __vxge_hw_device));
         if (hldev == NULL) {
                 vxge_debug(VXGE_ERR, "hldev allocation failed\n");
                 status = VXGE_HW_ERR_OUT_OF_MEMORY;
                 goto exit;
         }
 
         hldev->magic = VXGE_HW_DEVICE_MAGIC;
 
         hldev->bar0 = bar0;
         hldev->pdev = pdev;
         hldev->titan1 = titan1;
 
         __vxge_hw_device_pci_e_init(hldev);
 
         status = __vxge_hw_device_reg_addr_get(hldev);
         if (status != VXGE_HW_OK) {
                 vxge_debug(VXGE_ERR, "%s:%d __vxge_hw_device_reg_addr_get "
                         "failed\n", __func__, __LINE__);
                 vxge_hw_device_terminate(hldev);
                 goto exit;
         }
 
         __vxge_hw_device_host_info_get(hldev);
 
         *devh = hldev;
 exit:
         return status;
 }

References __vxge_hw_device_host_info_get(), __vxge_hw_device_pci_e_init(), __vxge_hw_device_reg_addr_get(), __vxge_hw_device::bar0, __vxge_hw_device::magic, NULL, __vxge_hw_device::pdev, status, __vxge_hw_device::titan1, vxge_debug, VXGE_ERR, VXGE_HW_DEVICE_MAGIC, vxge_hw_device_terminate(), VXGE_HW_ERR_OUT_OF_MEMORY, VXGE_HW_OK, vxge_trace, and zalloc().

Referenced by vxge_probe().

◆ vxge_hw_vpath_open()

enum vxge_hw_status vxge_hw_vpath_open	(	struct __vxge_hw_device *	hldev,
		struct vxge_vpath *	vpath
	)

Definition at line 1691 of file vxge_config.c.

 {
         struct __vxge_hw_virtualpath *vpathh;
         enum vxge_hw_status status;
 
         vxge_trace();
 
         vpathh = &hldev->virtual_path;
 
         if (vpath->vp_open == VXGE_HW_VP_OPEN) {
                 status = VXGE_HW_ERR_INVALID_STATE;
                 goto vpath_open_exit1;
         }
 
         status = __vxge_hw_vp_initialize(hldev, hldev->first_vp_id, vpathh);
         if (status != VXGE_HW_OK)
                 goto vpath_open_exit1;
 
         status = __vxge_hw_fifo_create(vpathh, &vpathh->fifoh);
         if (status != VXGE_HW_OK)
                 goto vpath_open_exit2;
 
         status = __vxge_hw_ring_create(vpathh, &vpathh->ringh);
         if (status != VXGE_HW_OK)
                 goto vpath_open_exit3;
 
         __vxge_hw_vpath_prc_configure(hldev);
 
         return VXGE_HW_OK;
 
 vpath_open_exit3:
         __vxge_hw_fifo_delete(&vpathh->fifoh);
 vpath_open_exit2:
         __vxge_hw_vp_terminate(hldev, vpathh);
 vpath_open_exit1:
         return status;
 }

References __vxge_hw_fifo_create(), __vxge_hw_fifo_delete(), __vxge_hw_ring_create(), __vxge_hw_vp_initialize(), __vxge_hw_vp_terminate(), __vxge_hw_vpath_prc_configure(), __vxge_hw_virtualpath::fifoh, __vxge_hw_device::first_vp_id, __vxge_hw_virtualpath::hldev, __vxge_hw_virtualpath::ringh, status, __vxge_hw_device::virtual_path, vxge_vpath::vp_open, VXGE_HW_ERR_INVALID_STATE, VXGE_HW_OK, VXGE_HW_VP_OPEN, and vxge_trace.

Referenced by vxge_open_vpaths().

◆ __vxge_hw_device_vpath_reset_in_prog_check()

enum vxge_hw_status __vxge_hw_device_vpath_reset_in_prog_check ( u64 __iomem * vpath_rst_in_prog )

Definition at line 179 of file vxge_config.c.

 {
         enum vxge_hw_status status;
 
         vxge_trace();
 
         status = __vxge_hw_device_register_poll(vpath_rst_in_prog,
                         VXGE_HW_VPATH_RST_IN_PROG_VPATH_RST_IN_PROG(0x1ffff),
                         VXGE_HW_DEF_DEVICE_POLL_MILLIS);
         return status;
 }

References __vxge_hw_device_register_poll(), status, vpath_rst_in_prog, VXGE_HW_DEF_DEVICE_POLL_MILLIS, VXGE_HW_VPATH_RST_IN_PROG_VPATH_RST_IN_PROG, and vxge_trace.

Referenced by __vxge_hw_device_reg_addr_get(), and vxge_hw_device_hw_info_get().

◆ vxge_hw_vpath_close()

enum vxge_hw_status vxge_hw_vpath_close ( struct __vxge_hw_virtualpath * vpath )

Definition at line 1761 of file vxge_config.c.

 {
         struct __vxge_hw_device *devh = NULL;
         u32 vp_id = vpath->vp_id;
         enum vxge_hw_status status = VXGE_HW_OK;
 
         vxge_trace();
 
         devh = vpath->hldev;
 
         if (vpath->vp_open == VXGE_HW_VP_NOT_OPEN) {
                 status = VXGE_HW_ERR_VPATH_NOT_OPEN;
                 goto vpath_close_exit;
         }
 
         devh->vpaths_deployed &= ~vxge_mBIT(vp_id);
 
         __vxge_hw_ring_delete(&vpath->ringh);
 
         __vxge_hw_fifo_delete(&vpath->fifoh);
 
         __vxge_hw_vp_terminate(devh, vpath);
 
         vpath->vp_open = VXGE_HW_VP_NOT_OPEN;
 
 vpath_close_exit:
         return status;
 }

References __vxge_hw_fifo_delete(), __vxge_hw_ring_delete(), __vxge_hw_vp_terminate(), __vxge_hw_virtualpath::fifoh, __vxge_hw_virtualpath::hldev, NULL, __vxge_hw_virtualpath::ringh, status, __vxge_hw_virtualpath::vp_id, __vxge_hw_virtualpath::vp_open, __vxge_hw_device::vpaths_deployed, VXGE_HW_ERR_VPATH_NOT_OPEN, VXGE_HW_OK, VXGE_HW_VP_NOT_OPEN, vxge_mBIT, and vxge_trace.

Referenced by vxge_close_vpaths().

◆ vxge_hw_vpath_reset()

enum vxge_hw_status vxge_hw_vpath_reset ( struct __vxge_hw_virtualpath * vpath )

Definition at line 1794 of file vxge_config.c.

 {
         enum vxge_hw_status status;
         u32 vp_id;
 
         vxge_trace();
 
         vp_id = vpath->vp_id;
 
         if (vpath->vp_open == VXGE_HW_VP_NOT_OPEN) {
                 status = VXGE_HW_ERR_VPATH_NOT_OPEN;
                 goto exit;
         }
 
         status = __vxge_hw_vpath_reset(vpath->hldev, vp_id);
 exit:
         return status;
 }

References __vxge_hw_vpath_reset(), __vxge_hw_virtualpath::hldev, status, __vxge_hw_virtualpath::vp_id, __vxge_hw_virtualpath::vp_open, VXGE_HW_ERR_VPATH_NOT_OPEN, VXGE_HW_VP_NOT_OPEN, and vxge_trace.

Referenced by vxge_reset_all_vpaths().

◆ vxge_hw_vpath_recover_from_reset()

enum vxge_hw_status vxge_hw_vpath_recover_from_reset ( struct __vxge_hw_virtualpath * vpath )

Definition at line 1819 of file vxge_config.c.

 {
         enum vxge_hw_status status;
         struct __vxge_hw_device *hldev;
         u32 vp_id;
 
         vxge_trace();
 
         vp_id = vpath->vp_id;
         hldev = vpath->hldev;
 
         if (vpath->vp_open == VXGE_HW_VP_NOT_OPEN) {
                 status = VXGE_HW_ERR_VPATH_NOT_OPEN;
                 goto exit;
         }
 
         status = __vxge_hw_vpath_reset_check(vpath);
         if (status != VXGE_HW_OK)
                 goto exit;
 
         status = __vxge_hw_vpath_initialize(hldev, vp_id);
         if (status != VXGE_HW_OK)
                 goto exit;
 
         __vxge_hw_vpath_prc_configure(hldev);
 
 exit:
         return status;
 }

References __vxge_hw_vpath_initialize(), __vxge_hw_vpath_prc_configure(), __vxge_hw_vpath_reset_check(), __vxge_hw_virtualpath::hldev, status, __vxge_hw_virtualpath::vp_id, __vxge_hw_virtualpath::vp_open, VXGE_HW_ERR_VPATH_NOT_OPEN, VXGE_HW_OK, VXGE_HW_VP_NOT_OPEN, and vxge_trace.

Referenced by vxge_reset_all_vpaths().

◆ vxge_hw_vpath_enable()

void vxge_hw_vpath_enable ( struct __vxge_hw_virtualpath * vpath )

Definition at line 1855 of file vxge_config.c.

 {
         struct __vxge_hw_device *hldev;
         u64 val64;
 
         vxge_trace();
 
         hldev = vpath->hldev;
 
         val64 = VXGE_HW_CMN_RSTHDLR_CFG1_CLR_VPATH_RESET(
                 1 << (16 - vpath->vp_id));
 
         __vxge_hw_pio_mem_write32_upper((u32)vxge_bVALn(val64, 0, 32),
                 &hldev->common_reg->cmn_rsthdlr_cfg1);
 }

References __vxge_hw_pio_mem_write32_upper(), vxge_hw_common_reg::cmn_rsthdlr_cfg1, __vxge_hw_device::common_reg, __vxge_hw_virtualpath::hldev, __vxge_hw_virtualpath::vp_id, vxge_bVALn, VXGE_HW_CMN_RSTHDLR_CFG1_CLR_VPATH_RESET, and vxge_trace.

Referenced by vxge_open().

◆ vxge_hw_vpath_mtu_set()

enum vxge_hw_status vxge_hw_vpath_mtu_set	(	struct __vxge_hw_virtualpath *	vpath,
		u32	new_mtu
	)

Definition at line 1662 of file vxge_config.c.

 {
         u64 val64;
         enum vxge_hw_status status = VXGE_HW_OK;
 
         vxge_trace();
 
         new_mtu += VXGE_HW_MAC_HEADER_MAX_SIZE;
 
         if ((new_mtu < VXGE_HW_MIN_MTU) || (new_mtu > vpath->max_mtu))
                 status = VXGE_HW_ERR_INVALID_MTU_SIZE;
 
         val64 = readq(&vpath->vp_reg->rxmac_vcfg0);
 
         val64 &= ~VXGE_HW_RXMAC_VCFG0_RTS_MAX_FRM_LEN(0x3fff);
         val64 |= VXGE_HW_RXMAC_VCFG0_RTS_MAX_FRM_LEN(new_mtu);
 
         writeq(val64, &vpath->vp_reg->rxmac_vcfg0);
 
         return status;
 }

References __vxge_hw_virtualpath::max_mtu, readq(), vxge_hw_vpath_reg::rxmac_vcfg0, status, __vxge_hw_virtualpath::vp_reg, VXGE_HW_ERR_INVALID_MTU_SIZE, VXGE_HW_MAC_HEADER_MAX_SIZE, VXGE_HW_MIN_MTU, VXGE_HW_OK, VXGE_HW_RXMAC_VCFG0_RTS_MAX_FRM_LEN, vxge_trace, and writeq().

Referenced by vxge_open().

◆ vxge_hw_vpath_rx_doorbell_init()

void vxge_hw_vpath_rx_doorbell_init ( struct __vxge_hw_virtualpath * vpath )

Definition at line 1738 of file vxge_config.c.

 {
         u64 new_count, val64;
 
         vxge_trace();
 
         if (vpath->hldev->titan1) {
                 new_count = readq(&vpath->vp_reg->rxdmem_size);
                 new_count &= 0x1fff;
         } else
                 new_count = VXGE_HW_RING_RXD_QWORDS_MODE_1 * 4;
 
         val64 = (VXGE_HW_RXDMEM_SIZE_PRC_RXDMEM_SIZE(new_count));
 
         writeq(VXGE_HW_PRC_RXD_DOORBELL_NEW_QW_CNT(val64),
                 &vpath->vp_reg->prc_rxd_doorbell);
 }

References __vxge_hw_virtualpath::hldev, vxge_hw_vpath_reg::prc_rxd_doorbell, readq(), vxge_hw_vpath_reg::rxdmem_size, __vxge_hw_device::titan1, __vxge_hw_virtualpath::vp_reg, VXGE_HW_PRC_RXD_DOORBELL_NEW_QW_CNT, VXGE_HW_RING_RXD_QWORDS_MODE_1, VXGE_HW_RXDMEM_SIZE_PRC_RXDMEM_SIZE, vxge_trace, and writeq().

Referenced by vxge_open().

◆ __vxge_hw_device_pci_e_init()

void __vxge_hw_device_pci_e_init ( struct __vxge_hw_device * hldev )

Definition at line 127 of file vxge_config.c.

 {
         u16 cmd = 0;
         struct pci_device *pdev = hldev->pdev;
 
         vxge_trace();
 
         /* Set the PErr Repconse bit and SERR in PCI command register. */
         pci_read_config_word(pdev, PCI_COMMAND, &cmd);
         cmd |= 0x140;
         pci_write_config_word(pdev, PCI_COMMAND, cmd);
 
         return;
 }

References cmd, PCI_COMMAND, pci_read_config_word(), pci_write_config_word(), __vxge_hw_device::pdev, and vxge_trace.

Referenced by vxge_hw_device_initialize().

◆ __vxge_hw_legacy_swapper_set()

enum vxge_hw_status __vxge_hw_legacy_swapper_set ( struct vxge_hw_legacy_reg __iomem * legacy_reg )

Definition at line 684 of file vxge_config.c.

 {
         u64 val64;
         enum vxge_hw_status status = VXGE_HW_OK;
 
         vxge_trace();
 
         val64 = readq(&legacy_reg->toc_swapper_fb);
 
         wmb();
 
         switch (val64) {
 
         case VXGE_HW_SWAPPER_INITIAL_VALUE:
                 return status;
 
         case VXGE_HW_SWAPPER_BYTE_SWAPPED_BIT_FLIPPED:
                 writeq(VXGE_HW_SWAPPER_READ_BYTE_SWAP_ENABLE,
                         &legacy_reg->pifm_rd_swap_en);
                 writeq(VXGE_HW_SWAPPER_READ_BIT_FLAP_ENABLE,
                         &legacy_reg->pifm_rd_flip_en);
                 writeq(VXGE_HW_SWAPPER_WRITE_BYTE_SWAP_ENABLE,
                         &legacy_reg->pifm_wr_swap_en);
                 writeq(VXGE_HW_SWAPPER_WRITE_BIT_FLAP_ENABLE,
                         &legacy_reg->pifm_wr_flip_en);
                 break;
 
         case VXGE_HW_SWAPPER_BYTE_SWAPPED:
                 writeq(VXGE_HW_SWAPPER_READ_BYTE_SWAP_ENABLE,
                         &legacy_reg->pifm_rd_swap_en);
                 writeq(VXGE_HW_SWAPPER_WRITE_BYTE_SWAP_ENABLE,
                         &legacy_reg->pifm_wr_swap_en);
                 break;
 
         case VXGE_HW_SWAPPER_BIT_FLIPPED:
                 writeq(VXGE_HW_SWAPPER_READ_BIT_FLAP_ENABLE,
                         &legacy_reg->pifm_rd_flip_en);
                 writeq(VXGE_HW_SWAPPER_WRITE_BIT_FLAP_ENABLE,
                         &legacy_reg->pifm_wr_flip_en);
                 break;
         }
 
         wmb();
 
         val64 = readq(&legacy_reg->toc_swapper_fb);
         if (val64 != VXGE_HW_SWAPPER_INITIAL_VALUE)
                 status = VXGE_HW_ERR_SWAPPER_CTRL;
 
         return status;
 }

References __vxge_hw_device::legacy_reg, vxge_hw_legacy_reg::pifm_rd_flip_en, vxge_hw_legacy_reg::pifm_rd_swap_en, vxge_hw_legacy_reg::pifm_wr_flip_en, vxge_hw_legacy_reg::pifm_wr_swap_en, readq(), status, vxge_hw_legacy_reg::toc_swapper_fb, VXGE_HW_ERR_SWAPPER_CTRL, VXGE_HW_OK, VXGE_HW_SWAPPER_BIT_FLIPPED, VXGE_HW_SWAPPER_BYTE_SWAPPED, VXGE_HW_SWAPPER_BYTE_SWAPPED_BIT_FLIPPED, VXGE_HW_SWAPPER_INITIAL_VALUE, VXGE_HW_SWAPPER_READ_BIT_FLAP_ENABLE, VXGE_HW_SWAPPER_READ_BYTE_SWAP_ENABLE, VXGE_HW_SWAPPER_WRITE_BIT_FLAP_ENABLE, VXGE_HW_SWAPPER_WRITE_BYTE_SWAP_ENABLE, vxge_trace, wmb(), and writeq().

Referenced by __vxge_hw_device_get_legacy_reg(), and __vxge_hw_vpath_initialize().

◆ __vxge_hw_vpath_swapper_set()

enum vxge_hw_status __vxge_hw_vpath_swapper_set ( struct vxge_hw_vpath_reg __iomem * vpath_reg )

Definition at line 740 of file vxge_config.c.

 {
         vxge_trace();
 
 #if (__BYTE_ORDER != __BIG_ENDIAN)
         u64 val64;
 
         val64 = readq(&vpath_reg->vpath_general_cfg1);
         wmb();
         val64 |= VXGE_HW_VPATH_GENERAL_CFG1_CTL_BYTE_SWAPEN;
         writeq(val64, &vpath_reg->vpath_general_cfg1);
         wmb();
 #endif
         return VXGE_HW_OK;
 }

References readq(), vxge_hw_vpath_reg::vpath_general_cfg1, __vxge_hw_device::vpath_reg, VXGE_HW_OK, VXGE_HW_VPATH_GENERAL_CFG1_CTL_BYTE_SWAPEN, vxge_trace, wmb(), and writeq().

Referenced by __vxge_hw_vpath_initialize().

◆ __vxge_hw_kdfc_swapper_set()

enum vxge_hw_status __vxge_hw_kdfc_swapper_set	(	struct vxge_hw_legacy_reg __iomem *	legacy_reg,
		struct vxge_hw_vpath_reg __iomem *	vpath_reg
	)

Definition at line 761 of file vxge_config.c.

 {
         u64 val64;
 
         vxge_trace();
 
         val64 = readq(&legacy_reg->pifm_wr_swap_en);
 
         if (val64 == VXGE_HW_SWAPPER_WRITE_BYTE_SWAP_ENABLE) {
                 val64 = readq(&vpath_reg->kdfcctl_cfg0);
                 wmb();
 
                 val64 |= VXGE_HW_KDFCCTL_CFG0_BYTE_SWAPEN_FIFO0 |
                         VXGE_HW_KDFCCTL_CFG0_BYTE_SWAPEN_FIFO1  |
                         VXGE_HW_KDFCCTL_CFG0_BYTE_SWAPEN_FIFO2;
 
                 writeq(val64, &vpath_reg->kdfcctl_cfg0);
                 wmb();
         }
 
         return VXGE_HW_OK;
 }

References vxge_hw_vpath_reg::kdfcctl_cfg0, __vxge_hw_device::legacy_reg, vxge_hw_legacy_reg::pifm_wr_swap_en, readq(), __vxge_hw_device::vpath_reg, VXGE_HW_KDFCCTL_CFG0_BYTE_SWAPEN_FIFO0, VXGE_HW_KDFCCTL_CFG0_BYTE_SWAPEN_FIFO1, VXGE_HW_KDFCCTL_CFG0_BYTE_SWAPEN_FIFO2, VXGE_HW_OK, VXGE_HW_SWAPPER_WRITE_BYTE_SWAP_ENABLE, vxge_trace, wmb(), and writeq().

Referenced by __vxge_hw_vpath_kdfc_configure().

◆ __vxge_hw_device_register_poll()

enum vxge_hw_status __vxge_hw_device_register_poll	(	void __iomem *	reg,
		u64	mask,
		u32	max_millis
	)

Definition at line 148 of file vxge_config.c.

 {
         u64 val64;
         u32 i = 0;
         enum vxge_hw_status ret = VXGE_HW_FAIL;
 
         udelay(10);
 
         do {
                 val64 = readq(reg);
                 if (!(val64 & mask))
                         return VXGE_HW_OK;
                 udelay(100);
         } while (++i <= 9);
 
         i = 0;
         do {
                 val64 = readq(reg);
                 if (!(val64 & mask))
                         return VXGE_HW_OK;
                 udelay(1000);
         } while (++i <= max_millis);
 
         return ret;
 }

References readq(), reg, udelay(), VXGE_HW_FAIL, and VXGE_HW_OK.

Referenced by __vxge_hw_device_vpath_reset_in_prog_check(), __vxge_hw_pio_mem_write64(), __vxge_hw_vpath_pci_read(), __vxge_hw_vpath_reset_check(), and vxge_hw_set_fw_api().

◆ __vxge_hw_pio_mem_write32_upper()

static void __vxge_hw_pio_mem_write32_upper	(	u32	val,
		void __iomem *	addr
	)

inlinestatic

Definition at line 703 of file vxge_config.h.

 {
         writel(val, addr + 4);
 }

References addr, val, and writel().

Referenced by __vxge_hw_pio_mem_write64(), __vxge_hw_vpath_reset(), vxge_hw_device_clear_tx_rx(), vxge_hw_device_intr_disable(), vxge_hw_device_intr_enable(), vxge_hw_device_mask_all(), vxge_hw_device_unmask_all(), vxge_hw_vpath_enable(), vxge_hw_vpath_intr_disable(), and vxge_hw_vpath_intr_enable().

◆ __vxge_hw_pio_mem_write32_lower()

static void __vxge_hw_pio_mem_write32_lower	(	u32	val,
		void __iomem *	addr
	)

inlinestatic

Definition at line 708 of file vxge_config.h.

 {
         writel(val, addr);
 }

References addr, val, and writel().

Referenced by __vxge_hw_pio_mem_write64().

◆ __vxge_hw_pio_mem_write64()

static enum vxge_hw_status __vxge_hw_pio_mem_write64	(	u64	val64,
		void __iomem *	addr,
		u64	mask,
		u32	max_millis
	)

inlinestatic

Definition at line 714 of file vxge_config.h.

 {
         enum vxge_hw_status status = VXGE_HW_OK;
 
         __vxge_hw_pio_mem_write32_lower((u32)vxge_bVALn(val64, 32, 32), addr);
         wmb();
         __vxge_hw_pio_mem_write32_upper((u32)vxge_bVALn(val64, 0, 32), addr);
         wmb();
 
         status = __vxge_hw_device_register_poll(addr, mask, max_millis);
         return status;
 }

References __vxge_hw_device_register_poll(), __vxge_hw_pio_mem_write32_lower(), __vxge_hw_pio_mem_write32_upper(), addr, status, vxge_bVALn, VXGE_HW_OK, and wmb().

Referenced by __vxge_hw_vpath_addr_get(), __vxge_hw_vpath_card_info_get(), and __vxge_hw_vpath_fw_ver_get().

◆ __vxge_hw_device_host_info_get()

void __vxge_hw_device_host_info_get ( struct __vxge_hw_device * hldev )

Definition at line 348 of file vxge_config.c.

 {
         u64 val64;
         u32 i;
 
         val64 = readq(&hldev->common_reg->host_type_assignments);
 
         hldev->host_type =
            (u32)VXGE_HW_HOST_TYPE_ASSIGNMENTS_GET_HOST_TYPE_ASSIGNMENTS(val64);
 
         hldev->vpath_assignments = readq(&hldev->common_reg->vpath_assignments);
 
         for (i = 0; i < VXGE_HW_MAX_VIRTUAL_PATHS; i++) {
 
                 if (!(hldev->vpath_assignments & vxge_mBIT(i)))
                         continue;
 
                 hldev->func_id =
                         __vxge_hw_vpath_func_id_get(hldev->vpmgmt_reg[i]);
 
                 hldev->access_rights = __vxge_hw_device_access_rights_get(
                         hldev->host_type, hldev->func_id);
 
                 hldev->first_vp_id = i;
                 break;
         }
 
         return;
 }

References __vxge_hw_device_access_rights_get(), __vxge_hw_vpath_func_id_get(), __vxge_hw_device::access_rights, __vxge_hw_device::common_reg, __vxge_hw_device::first_vp_id, __vxge_hw_device::func_id, __vxge_hw_device::host_type, vxge_hw_common_reg::host_type_assignments, readq(), u32, __vxge_hw_device::vpath_assignments, vxge_hw_common_reg::vpath_assignments, __vxge_hw_device::vpmgmt_reg, VXGE_HW_HOST_TYPE_ASSIGNMENTS_GET_HOST_TYPE_ASSIGNMENTS, VXGE_HW_MAX_VIRTUAL_PATHS, and vxge_mBIT.

Referenced by vxge_hw_device_initialize().

◆ __vxge_hw_device_initialize()

enum vxge_hw_status __vxge_hw_device_initialize ( struct __vxge_hw_device * hldev )

◆ __vxge_hw_vpath_pci_read()

enum vxge_hw_status __vxge_hw_vpath_pci_read	(	struct __vxge_hw_virtualpath *	vpath,
		u32	phy_func_0,
		u32	offset,
		u32 *	val
	)

Definition at line 865 of file vxge_config.c.

 {
         u64 val64;
         enum vxge_hw_status status = VXGE_HW_OK;
         struct vxge_hw_vpath_reg __iomem *vp_reg = vpath->vp_reg;
 
         val64 = VXGE_HW_PCI_CONFIG_ACCESS_CFG1_ADDRESS(offset);
 
         if (phy_func_0)
                 val64 |= VXGE_HW_PCI_CONFIG_ACCESS_CFG1_SEL_FUNC0;
 
         writeq(val64, &vp_reg->pci_config_access_cfg1);
         wmb();
         writeq(VXGE_HW_PCI_CONFIG_ACCESS_CFG2_REQ,
                         &vp_reg->pci_config_access_cfg2);
         wmb();
 
         status = __vxge_hw_device_register_poll(
                         &vp_reg->pci_config_access_cfg2,
                         VXGE_HW_INTR_MASK_ALL, VXGE_HW_DEF_DEVICE_POLL_MILLIS);
 
         if (status != VXGE_HW_OK)
                 goto exit;
 
         val64 = readq(&vp_reg->pci_config_access_status);
 
         if (val64 & VXGE_HW_PCI_CONFIG_ACCESS_STATUS_ACCESS_ERR) {
                 status = VXGE_HW_FAIL;
                 *val = 0;
         } else
                 *val = (u32)vxge_bVALn(val64, 32, 32);
 exit:
         return status;
 }

References __iomem, __vxge_hw_device_register_poll(), offset, vxge_hw_vpath_reg::pci_config_access_cfg1, vxge_hw_vpath_reg::pci_config_access_cfg2, vxge_hw_vpath_reg::pci_config_access_status, readq(), status, u32, val, __vxge_hw_virtualpath::vp_reg, vxge_bVALn, VXGE_HW_DEF_DEVICE_POLL_MILLIS, VXGE_HW_FAIL, VXGE_HW_INTR_MASK_ALL, VXGE_HW_OK, VXGE_HW_PCI_CONFIG_ACCESS_CFG1_ADDRESS, VXGE_HW_PCI_CONFIG_ACCESS_CFG1_SEL_FUNC0, VXGE_HW_PCI_CONFIG_ACCESS_CFG2_REQ, VXGE_HW_PCI_CONFIG_ACCESS_STATUS_ACCESS_ERR, wmb(), and writeq().

Referenced by __vxge_hw_vpath_initialize().

◆ __vxge_hw_vpath_addr_get()

enum vxge_hw_status __vxge_hw_vpath_addr_get	(	struct vxge_hw_vpath_reg __iomem *	vpath_reg,
		u8(macaddr)	[ETH_ALEN],
		u8(macaddr_mask)	[ETH_ALEN]
	)

◆ __vxge_hw_vpath_func_id_get()

u32 __vxge_hw_vpath_func_id_get ( struct vxge_hw_vpmgmt_reg __iomem * vpmgmt_reg )

Definition at line 906 of file vxge_config.c.

 {
         u64 val64;
 
         val64 = readq(&vpmgmt_reg->vpath_to_func_map_cfg1);
 
         return
          (u32)VXGE_HW_VPATH_TO_FUNC_MAP_CFG1_GET_VPATH_TO_FUNC_MAP_CFG1(val64);
 }

References readq(), and VXGE_HW_VPATH_TO_FUNC_MAP_CFG1_GET_VPATH_TO_FUNC_MAP_CFG1.

Referenced by __vxge_hw_device_host_info_get(), and vxge_hw_device_hw_info_get().

◆ __vxge_hw_vpath_reset_check()

enum vxge_hw_status __vxge_hw_vpath_reset_check ( struct __vxge_hw_virtualpath * vpath )

Definition at line 1250 of file vxge_config.c.

 {
         enum vxge_hw_status status;
 
         vxge_trace();
 
         status = __vxge_hw_device_register_poll(
                         &vpath->hldev->common_reg->vpath_rst_in_prog,
                         VXGE_HW_VPATH_RST_IN_PROG_VPATH_RST_IN_PROG(
                                 1 << (16 - vpath->vp_id)),
                         VXGE_HW_DEF_DEVICE_POLL_MILLIS);
 
         return status;
 }

References __vxge_hw_device_register_poll(), __vxge_hw_device::common_reg, __vxge_hw_virtualpath::hldev, status, __vxge_hw_virtualpath::vp_id, vxge_hw_common_reg::vpath_rst_in_prog, VXGE_HW_DEF_DEVICE_POLL_MILLIS, VXGE_HW_VPATH_RST_IN_PROG_VPATH_RST_IN_PROG, and vxge_trace.

Referenced by __vxge_hw_vp_initialize(), vxge_hw_vpath_recover_from_reset(), and vxge_reset_all_vpaths().

◆ vxge_hw_vpath_strip_fcs_check()

enum vxge_hw_status vxge_hw_vpath_strip_fcs_check	(	struct __vxge_hw_device *	hldev,
		u64	vpath_mask
	)

Definition at line 790 of file vxge_config.c.

 {
         struct vxge_hw_vpmgmt_reg       __iomem *vpmgmt_reg;
         enum vxge_hw_status status = VXGE_HW_OK;
         int i = 0, j = 0;
 
         for (i = 0; i < VXGE_HW_MAX_VIRTUAL_PATHS; i++) {
                 if (!((vpath_mask) & vxge_mBIT(i)))
                         continue;
                 vpmgmt_reg = hldev->vpmgmt_reg[i];
                 for (j = 0; j < VXGE_HW_MAC_MAX_MAC_PORT_ID; j++) {
                         if (readq(&vpmgmt_reg->rxmac_cfg0_port_vpmgmt_clone[j])
                         & VXGE_HW_RXMAC_CFG0_PORT_VPMGMT_CLONE_STRIP_FCS)
                                 return VXGE_HW_FAIL;
                 }
         }
         return status;
 }

References __iomem, readq(), vxge_hw_vpmgmt_reg::rxmac_cfg0_port_vpmgmt_clone, status, __vxge_hw_device::vpmgmt_reg, VXGE_HW_FAIL, VXGE_HW_MAC_MAX_MAC_PORT_ID, VXGE_HW_MAX_VIRTUAL_PATHS, VXGE_HW_OK, VXGE_HW_RXMAC_CFG0_PORT_VPMGMT_CLONE_STRIP_FCS, and vxge_mBIT.

Referenced by vxge_probe().

◆ vxge_hw_get_func_mode()

enum vxge_hw_status vxge_hw_get_func_mode	(	struct __vxge_hw_device *	hldev,
		u32 *	func_mode
	)

Definition at line 98 of file vxge_config.c.

 {
         enum vxge_hw_status status = VXGE_HW_OK;
         struct vxge_hw_vpath_reg __iomem *vp_reg;
         u64 val64;
         int vp_id;
 
         /* get the first vpath number assigned to this function */
         vp_id = hldev->first_vp_id;
 
         vp_reg = (struct vxge_hw_vpath_reg __iomem *)hldev->vpath_reg[vp_id];
 
         status = vxge_hw_set_fw_api(hldev, vp_id,
                                 VXGE_HW_FW_API_GET_FUNC_MODE, 0, 0, 0);
 
         if (status == VXGE_HW_OK) {
                 val64 = readq(&vp_reg->rts_access_steer_data0);
                 *func_mode = VXGE_HW_GET_FUNC_MODE_VAL(val64);
         }
 
         return status;
 }

References __iomem, __vxge_hw_device::first_vp_id, readq(), vxge_hw_vpath_reg::rts_access_steer_data0, status, __vxge_hw_device::vpath_reg, VXGE_HW_FW_API_GET_FUNC_MODE, VXGE_HW_GET_FUNC_MODE_VAL, VXGE_HW_OK, and vxge_hw_set_fw_api().

Referenced by vxge_probe().

◆ vxge_hw_set_fw_api()

enum vxge_hw_status vxge_hw_set_fw_api	(	struct __vxge_hw_device *	hldev,
		u64	vp_id,
		u32	action,
		u32	offset,
		u64	data0,
		u64	data1
	)

Definition at line 48 of file vxge_config.c.

 {
         enum vxge_hw_status status = VXGE_HW_OK;
         u64 val64;
         u32 fw_memo = VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO;
 
         struct vxge_hw_vpath_reg __iomem *vp_reg;
 
         vp_reg = (struct vxge_hw_vpath_reg __iomem *)hldev->vpath_reg[vp_id];
 
         writeq(data0, &vp_reg->rts_access_steer_data0);
         writeq(data1, &vp_reg->rts_access_steer_data1);
 
         wmb();
 
         val64 = VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION(action) |
                 VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(fw_memo) |
                 VXGE_HW_RTS_ACCESS_STEER_CTRL_OFFSET(offset) |
                 VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE;
 
         writeq(val64, &vp_reg->rts_access_steer_ctrl);
 
         wmb();
 
         status = __vxge_hw_device_register_poll(
                         &vp_reg->rts_access_steer_ctrl,
                         VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE,
                         WAIT_FACTOR *
                         VXGE_HW_DEF_DEVICE_POLL_MILLIS);
 
         if (status != VXGE_HW_OK)
                 return VXGE_HW_FAIL;
 
         val64 = readq(&vp_reg->rts_access_steer_ctrl);
 
         if (val64 & VXGE_HW_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS)
                 status = VXGE_HW_OK;
         else
                 status = VXGE_HW_FAIL;
 
         return status;
 }

References __iomem, __vxge_hw_device_register_poll(), data0, data1, offset, readq(), vxge_hw_vpath_reg::rts_access_steer_ctrl, vxge_hw_vpath_reg::rts_access_steer_data0, vxge_hw_vpath_reg::rts_access_steer_data1, status, __vxge_hw_device::vpath_reg, VXGE_HW_DEF_DEVICE_POLL_MILLIS, VXGE_HW_FAIL, VXGE_HW_OK, VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION, VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL, VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO, VXGE_HW_RTS_ACCESS_STEER_CTRL_OFFSET, VXGE_HW_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS, VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE, WAIT_FACTOR, wmb(), and writeq().

Referenced by vxge_hw_get_func_mode().

◆ vxge_hw_vpath_set_zero_rx_frm_len()

void vxge_hw_vpath_set_zero_rx_frm_len ( struct __vxge_hw_device * hldev )

Definition at line 31 of file vxge_config.c.

 {
         u64 val64;
         struct __vxge_hw_virtualpath *vpath;
         struct vxge_hw_vpath_reg __iomem *vp_reg;
 
         vpath = &hldev->virtual_path;
         vp_reg = vpath->vp_reg;
 
         val64 = readq(&vp_reg->rxmac_vcfg0);
         val64 &= ~VXGE_HW_RXMAC_VCFG0_RTS_MAX_FRM_LEN(0x3fff);
         writeq(val64, &vp_reg->rxmac_vcfg0);
         val64 = readq(&vp_reg->rxmac_vcfg0);
         return;
 }

References __iomem, readq(), vxge_hw_vpath_reg::rxmac_vcfg0, __vxge_hw_device::virtual_path, __vxge_hw_virtualpath::vp_reg, VXGE_HW_RXMAC_VCFG0_RTS_MAX_FRM_LEN, and writeq().

Referenced by vxge_close().

Variable Documentation

◆ debug_filter

const u16 debug_filter = VXGE_ERR

static

vxge_debug @mask: mask for the debug @fmt: printf like format string

Definition at line 761 of file vxge_config.h.

Data Structures

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

◆ VXGE_CONFIG_H

◆ VXGE_CACHE_LINE_SIZE

◆ WAIT_FACTOR

◆ VXGE_HW_MAC_MAX_WIRE_PORTS

◆ VXGE_HW_MAC_MAX_AGGR_PORTS

◆ VXGE_HW_MAC_MAX_PORTS

◆ VXGE_HW_MIN_MTU

◆ VXGE_HW_MAX_MTU

◆ VXGE_HW_DEFAULT_MTU

◆ __iomem

◆ ____cacheline_aligned

◆ VXGE_NONE

◆ VXGE_INFO

◆ VXGE_INTR

◆ VXGE_XMIT

◆ VXGE_POLL

◆ VXGE_ERR

◆ VXGE_TRACE

◆ VXGE_ALL

◆ NULL_VPID

◆ VXGE_HW_EVENT_BASE

◆ VXGE_LL_EVENT_BASE

◆ VXGE_HW_BASE_INF

◆ VXGE_HW_BASE_ERR

◆ VXGE_HW_BASE_BADCFG

◆ VXGE_HW_DEF_DEVICE_POLL_MILLIS

◆ VXGE_HW_MAX_PAYLOAD_SIZE_512

◆ VXGE_HW_RING_RXD_RTH_BUCKET_GET

◆ VXGE_HW_RING_RXD_LIST_OWN_ADAPTER

◆ VXGE_HW_RING_RXD_FAST_PATH_ELIGIBLE_GET

◆ VXGE_HW_RING_RXD_L3_CKSUM_CORRECT_GET

◆ VXGE_HW_RING_RXD_L4_CKSUM_CORRECT_GET

◆ VXGE_HW_RING_RXD_T_CODE_GET

◆ VXGE_HW_RING_RXD_T_CODE

◆ VXGE_HW_RING_RXD_T_CODE_UNUSED

◆ VXGE_HW_RING_RXD_SYN_GET

◆ VXGE_HW_RING_RXD_IS_ICMP_GET

◆ VXGE_HW_RING_RXD_RTH_SPDM_HIT_GET

◆ VXGE_HW_RING_RXD_RTH_IT_HIT_GET

◆ VXGE_HW_RING_RXD_RTH_HASH_TYPE_GET

◆ VXGE_HW_RING_RXD_IS_VLAN_GET

◆ VXGE_HW_RING_RXD_ETHER_ENCAP_GET

◆ VXGE_HW_RING_RXD_FRAME_PROTO_GET

◆ VXGE_HW_RING_RXD_L3_CKSUM_GET

◆ VXGE_HW_RING_RXD_L4_CKSUM_GET

◆ VXGE_HW_RING_RXD_1_BUFFER0_SIZE_GET

◆ VXGE_HW_RING_RXD_1_BUFFER0_SIZE

◆ VXGE_HW_RING_RXD_1_BUFFER0_SIZE_MASK

◆ VXGE_HW_RING_RXD_1_RTH_HASH_VAL_GET

◆ VXGE_HW_RING_RXD_VLAN_TAG_GET

◆ VXGE_HW_FIFO_TXD_LIST_OWN_ADAPTER

◆ VXGE_HW_FIFO_TXD_T_CODE_GET

◆ VXGE_HW_FIFO_TXD_T_CODE

◆ VXGE_HW_FIFO_TXD_T_CODE_UNUSED

◆ VXGE_HW_FIFO_TXD_GATHER_CODE

◆ VXGE_HW_FIFO_TXD_GATHER_CODE_FIRST

◆ VXGE_HW_FIFO_TXD_GATHER_CODE_LAST

◆ VXGE_HW_FIFO_TXD_LSO_EN

◆ VXGE_HW_FIFO_TXD_LSO_MSS

◆ VXGE_HW_FIFO_TXD_BUFFER_SIZE

◆ VXGE_HW_FIFO_TXD_TX_CKO_IPV4_EN

◆ VXGE_HW_FIFO_TXD_TX_CKO_TCP_EN

◆ VXGE_HW_FIFO_TXD_TX_CKO_UDP_EN

◆ VXGE_HW_FIFO_TXD_VLAN_ENABLE

◆ VXGE_HW_FIFO_TXD_VLAN_TAG

◆ VXGE_HW_FIFO_TXD_NO_BW_LIMIT

◆ VXGE_HW_FIFO_TXD_INT_NUMBER

◆ VXGE_HW_FIFO_TXD_INT_TYPE_PER_LIST

◆ VXGE_HW_FIFO_TXD_INT_TYPE_UTILZ

◆ VXGE_HW_FW_STRLEN

◆ VXGE_HW_NODBW_GET_TYPE

◆ VXGE_HW_NODBW_TYPE

◆ VXGE_HW_NODBW_TYPE_NODBW

◆ VXGE_HW_NODBW_GET_LAST_TXD_NUMBER