vxge_config.h File Reference

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

Define Documentation

#define VXGE_CACHE_LINE_SIZE 4096

Definition at line 25 of file vxge_config.h.

#define WAIT_FACTOR 1

Definition at line 28 of file vxge_config.h.

Referenced by vxge_hw_set_fw_api().

#define ARRAY_SIZE ( a ) (sizeof(a) / sizeof((a)[0]))

Definition at line 31 of file vxge_config.h.

#define VXGE_HW_MAC_MAX_WIRE_PORTS 2

Definition at line 34 of file vxge_config.h.

#define VXGE_HW_MAC_MAX_AGGR_PORTS 2

Definition at line 35 of file vxge_config.h.

#define VXGE_HW_MAC_MAX_PORTS 3

Definition at line 36 of file vxge_config.h.

#define VXGE_HW_MIN_MTU 68

Definition at line 38 of file vxge_config.h.

Referenced by vxge_hw_vpath_mtu_set().

#define VXGE_HW_MAX_MTU 9600

Definition at line 39 of file vxge_config.h.

#define VXGE_HW_DEFAULT_MTU 1500

Definition at line 40 of file vxge_config.h.

Referenced by vxge_open(), and vxge_probe().

#define VXGE_NONE 0x00

debug filtering masks

Definition at line 53 of file vxge_config.h.

#define VXGE_INFO 0x01

Definition at line 54 of file vxge_config.h.

Referenced by __vxge_hw_vpath_alarm_process(), vxge_close(), vxge_device_register(), vxge_device_unregister(), vxge_hw_vpath_poll_rx(), vxge_irq(), vxge_open(), vxge_probe(), and vxge_remove().

#define VXGE_INTR 0x02

Definition at line 55 of file vxge_config.h.

Referenced by __vxge_hw_vpath_alarm_process().

#define VXGE_XMIT 0x04

Definition at line 56 of file vxge_config.h.

Referenced by vxge_xmit().

#define VXGE_POLL 0x08

Definition at line 57 of file vxge_config.h.

Referenced by vxge_poll().

#define VXGE_ERR 0x10

Definition at line 58 of file vxge_config.h.

Referenced by __vxge_hw_fifo_create(), __vxge_hw_ring_create(), __vxge_hw_vpath_alarm_process(), vxge_device_register(), vxge_hw_device_begin_irq(), vxge_hw_device_initialize(), vxge_hw_fifo_free_txdl_get(), vxge_hw_vpath_poll_rx(), vxge_open(), vxge_open_vpaths(), vxge_probe(), vxge_reset_all_vpaths(), vxge_xmit(), and vxge_xmit_compl().

#define VXGE_TRACE 0x20

Definition at line 59 of file vxge_config.h.

#define VXGE_ALL

Value:

(VXGE_INFO|VXGE_INTR|VXGE_XMIT\
                        |VXGE_POLL|VXGE_ERR|VXGE_TRACE)

Definition at line 60 of file vxge_config.h.

#define NULL_VPID 0xFFFFFFFF

Definition at line 63 of file vxge_config.h.

#define VXGE_HW_EVENT_BASE 0

Definition at line 65 of file vxge_config.h.

#define VXGE_LL_EVENT_BASE 100

Definition at line 66 of file vxge_config.h.

#define VXGE_HW_BASE_INF 100

Definition at line 68 of file vxge_config.h.

#define VXGE_HW_BASE_ERR 200

Definition at line 69 of file vxge_config.h.

#define VXGE_HW_BASE_BADCFG 300

Definition at line 70 of file vxge_config.h.

#define VXGE_HW_DEF_DEVICE_POLL_MILLIS 1000

Definition at line 71 of file vxge_config.h.

Referenced by __vxge_hw_device_vpath_reset_in_prog_check(), __vxge_hw_vpath_addr_get(), __vxge_hw_vpath_card_info_get(), __vxge_hw_vpath_fw_ver_get(), __vxge_hw_vpath_pci_read(), __vxge_hw_vpath_reset_check(), and vxge_hw_set_fw_api().

#define VXGE_HW_MAX_PAYLOAD_SIZE_512 2

Definition at line 72 of file vxge_config.h.

Referenced by __vxge_hw_vpath_initialize().

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

Definition at line 161 of file vxge_config.h.

#define VXGE_HW_RING_RXD_LIST_OWN_ADAPTER vxge_mBIT(7)

Definition at line 163 of file vxge_config.h.

Referenced by vxge_hw_ring_rxd_post(), and vxge_hw_vpath_poll_rx().

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

Definition at line 165 of file vxge_config.h.

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

Definition at line 167 of file vxge_config.h.

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

Definition at line 169 of file vxge_config.h.

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

Definition at line 171 of file vxge_config.h.

Referenced by vxge_hw_vpath_poll_rx().

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

Definition at line 172 of file vxge_config.h.

#define VXGE_HW_RING_RXD_T_CODE_UNUSED VXGE_HW_RING_T_CODE_UNUSED

Definition at line 174 of file vxge_config.h.

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

Definition at line 176 of file vxge_config.h.

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

Definition at line 178 of file vxge_config.h.

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

Definition at line 180 of file vxge_config.h.

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

Definition at line 182 of file vxge_config.h.

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

Definition at line 184 of file vxge_config.h.

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

Definition at line 186 of file vxge_config.h.

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

Definition at line 188 of file vxge_config.h.

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

Definition at line 190 of file vxge_config.h.

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

Definition at line 192 of file vxge_config.h.

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

Definition at line 194 of file vxge_config.h.

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

Definition at line 198 of file vxge_config.h.

Referenced by vxge_hw_vpath_poll_rx().

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

Definition at line 199 of file vxge_config.h.

Referenced by vxge_hw_ring_rxd_1b_set().

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

Definition at line 200 of file vxge_config.h.

Referenced by vxge_hw_ring_rxd_1b_set().

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

Definition at line 202 of file vxge_config.h.

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

Definition at line 204 of file vxge_config.h.

#define VXGE_HW_FIFO_TXD_LIST_OWN_ADAPTER vxge_mBIT(7)

Definition at line 218 of file vxge_config.h.

Referenced by vxge_hw_fifo_free_txdl_get(), vxge_hw_fifo_txdl_post(), and vxge_hw_vpath_poll_tx().

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

Definition at line 220 of file vxge_config.h.

Referenced by vxge_hw_vpath_poll_tx().

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

Definition at line 221 of file vxge_config.h.

#define VXGE_HW_FIFO_TXD_T_CODE_UNUSED VXGE_HW_FIFO_T_CODE_UNUSED

Definition at line 222 of file vxge_config.h.

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

Definition at line 224 of file vxge_config.h.

Referenced by vxge_hw_fifo_txdl_buffer_set().

#define VXGE_HW_FIFO_TXD_GATHER_CODE_FIRST VXGE_HW_FIFO_GATHER_CODE_FIRST

Definition at line 225 of file vxge_config.h.

#define VXGE_HW_FIFO_TXD_GATHER_CODE_LAST VXGE_HW_FIFO_GATHER_CODE_LAST

Definition at line 226 of file vxge_config.h.

#define VXGE_HW_FIFO_TXD_LSO_EN vxge_mBIT(30)

Definition at line 228 of file vxge_config.h.

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

Definition at line 229 of file vxge_config.h.

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

Definition at line 230 of file vxge_config.h.

Referenced by vxge_hw_fifo_txdl_buffer_set().

#define VXGE_HW_FIFO_TXD_TX_CKO_IPV4_EN vxge_mBIT(5)

Definition at line 233 of file vxge_config.h.

#define VXGE_HW_FIFO_TXD_TX_CKO_TCP_EN vxge_mBIT(6)

Definition at line 234 of file vxge_config.h.

#define VXGE_HW_FIFO_TXD_TX_CKO_UDP_EN vxge_mBIT(7)

Definition at line 235 of file vxge_config.h.

#define VXGE_HW_FIFO_TXD_VLAN_ENABLE vxge_mBIT(15)

Definition at line 236 of file vxge_config.h.

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

Definition at line 238 of file vxge_config.h.

#define VXGE_HW_FIFO_TXD_NO_BW_LIMIT vxge_mBIT(43)

Definition at line 239 of file vxge_config.h.

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

Definition at line 241 of file vxge_config.h.

Referenced by vxge_hw_fifo_txdl_buffer_set().

#define VXGE_HW_FIFO_TXD_INT_TYPE_PER_LIST vxge_mBIT(46)

Definition at line 243 of file vxge_config.h.

Referenced by vxge_hw_fifo_txdl_buffer_set().

#define VXGE_HW_FIFO_TXD_INT_TYPE_UTILZ vxge_mBIT(47)

Definition at line 244 of file vxge_config.h.

#define VXGE_HW_FW_STRLEN 32

struct vxge_hw_device_date - Date Format : Day : Month : Year

Date:: : Date in string format

Structure for returning date

Definition at line 261 of file vxge_config.h.

Referenced by __vxge_hw_vpath_fw_ver_get().

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

Definition at line 297 of file vxge_config.h.

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

Definition at line 298 of file vxge_config.h.

Referenced by __vxge_hw_non_offload_db_post().

#define VXGE_HW_NODBW_TYPE_NODBW 0

Definition at line 299 of file vxge_config.h.

Referenced by __vxge_hw_non_offload_db_post().

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

Definition at line 301 of file vxge_config.h.

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

Definition at line 302 of file vxge_config.h.

Referenced by __vxge_hw_non_offload_db_post().

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

Definition at line 304 of file vxge_config.h.

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

Definition at line 305 of file vxge_config.h.

#define VXGE_HW_NODBW_LIST_NO_SNOOP_TXD_READ_TXD0_WRITE 0x2

Definition at line 306 of file vxge_config.h.

#define VXGE_HW_NODBW_LIST_NO_SNOOP_TX_FRAME_DATA_READ 0x1

Definition at line 307 of file vxge_config.h.

#define VXGE_HW_FIFO_TXD_DEPTH 128

Definition at line 333 of file vxge_config.h.

Referenced by __vxge_hw_fifo_create(), and vxge_hw_fifo_txd_offset_up().

#define VXGE_HW_MAX_RXDS_PER_BLOCK_1 127

Definition at line 345 of file vxge_config.h.

Referenced by vxge_hw_ring_replenish(), vxge_hw_ring_rxd_offset_up(), and vxge_hw_vpath_doorbell_rx().

#define END_OF_BLOCK 0xFEFFFFFFFFFFFFFFULL

Definition at line 349 of file vxge_config.h.

#define VXGE_HW_RING_RXD_QWORDS_MODE_1 4

Definition at line 368 of file vxge_config.h.

Referenced by vxge_hw_vpath_doorbell_rx(), and vxge_hw_vpath_rx_doorbell_init().

#define VXGE_HW_RING_RXD_QWORD_LIMIT 16

Definition at line 371 of file vxge_config.h.

Referenced by __vxge_hw_ring_create().

#define VXGE_HW_RING_BUF_PER_BLOCK 9

Definition at line 375 of file vxge_config.h.

Referenced by __vxge_hw_ring_create(), and vxge_hw_ring_replenish().

#define VXGE_HW_RING_RX_POLL_WEIGHT 8

Definition at line 379 of file vxge_config.h.

Referenced by __vxge_hw_ring_create().

#define VXGE_HW_VP_NOT_OPEN 0

Definition at line 397 of file vxge_config.h.

Referenced by __vxge_hw_vp_terminate(), vxge_hw_vpath_close(), vxge_hw_vpath_intr_disable(), vxge_hw_vpath_intr_enable(), vxge_hw_vpath_recover_from_reset(), and vxge_hw_vpath_reset().

#define VXGE_HW_VP_OPEN 1

Definition at line 398 of file vxge_config.h.

Referenced by __vxge_hw_vp_initialize(), and vxge_hw_vpath_open().

#define VXGE_HW_INFO_LEN 64

Definition at line 413 of file vxge_config.h.

Referenced by vxge_probe().

#define VXGE_HW_PMD_INFO_LEN 16

Definition at line 414 of file vxge_config.h.

#define VXGE_MAX_PRINT_BUF_SIZE 128

Definition at line 415 of file vxge_config.h.

#define VXGE_HW_NO_MR_NO_SR_NORMAL_FUNCTION 0

Definition at line 433 of file vxge_config.h.

Referenced by __vxge_hw_device_access_rights_get().

#define VXGE_HW_MR_NO_SR_VH0_BASE_FUNCTION 1

Definition at line 434 of file vxge_config.h.

Referenced by __vxge_hw_device_access_rights_get().

#define VXGE_HW_NO_MR_SR_VH0_FUNCTION0 2

Definition at line 435 of file vxge_config.h.

Referenced by __vxge_hw_device_access_rights_get().

#define VXGE_HW_NO_MR_SR_VH0_VIRTUAL_FUNCTION 3

Definition at line 436 of file vxge_config.h.

Referenced by __vxge_hw_device_access_rights_get().

#define VXGE_HW_MR_SR_VH0_INVALID_CONFIG 4

Definition at line 437 of file vxge_config.h.

Referenced by __vxge_hw_device_access_rights_get().

#define VXGE_HW_SR_VH_FUNCTION0 5

Definition at line 438 of file vxge_config.h.

Referenced by __vxge_hw_device_access_rights_get().

#define VXGE_HW_SR_VH_VIRTUAL_FUNCTION 6

Definition at line 439 of file vxge_config.h.

Referenced by __vxge_hw_device_access_rights_get().

#define VXGE_HW_VH_NORMAL_FUNCTION 7

Definition at line 440 of file vxge_config.h.

Referenced by __vxge_hw_device_access_rights_get().

#define VXGE_HW_FUNCTION_MODE_MIN 0

Definition at line 442 of file vxge_config.h.

#define VXGE_HW_FUNCTION_MODE_MAX 10

Definition at line 443 of file vxge_config.h.

#define VXGE_HW_FUNCTION_MODE_SINGLE_FUNCTION 0

Definition at line 445 of file vxge_config.h.

#define VXGE_HW_FUNCTION_MODE_MULTI_FUNCTION 1

Definition at line 446 of file vxge_config.h.

#define VXGE_HW_FUNCTION_MODE_SRIOV 2

Definition at line 447 of file vxge_config.h.

#define VXGE_HW_FUNCTION_MODE_MRIOV 3

Definition at line 448 of file vxge_config.h.

#define VXGE_HW_FUNCTION_MODE_MRIOV_8 4

Definition at line 449 of file vxge_config.h.

#define VXGE_HW_FUNCTION_MODE_MULTI_FUNCTION_17 5

Definition at line 450 of file vxge_config.h.

#define VXGE_HW_FUNCTION_MODE_SRIOV_8 6

Definition at line 451 of file vxge_config.h.

#define VXGE_HW_FUNCTION_MODE_SRIOV_4 7

Definition at line 452 of file vxge_config.h.

#define VXGE_HW_FUNCTION_MODE_MULTI_FUNCTION_2 8

Definition at line 453 of file vxge_config.h.

#define VXGE_HW_FUNCTION_MODE_MULTI_FUNCTION_4 9

Definition at line 454 of file vxge_config.h.

#define VXGE_HW_FUNCTION_MODE_MRIOV_4 10

Definition at line 455 of file vxge_config.h.

#define VXGE_HW_DEVICE_MAGIC 0x12345678

Definition at line 482 of file vxge_config.h.

Referenced by vxge_hw_device_initialize(), and vxge_hw_device_terminate().

#define VXGE_HW_DEVICE_DEAD 0xDEADDEAD

Definition at line 483 of file vxge_config.h.

Referenced by vxge_hw_device_terminate().

#define VXGE_HW_DEVICE_ACCESS_RIGHT_VPATH 0x1

Definition at line 495 of file vxge_config.h.

Referenced by __vxge_hw_device_access_rights_get().

#define VXGE_HW_DEVICE_ACCESS_RIGHT_SRPCIM 0x2

Definition at line 496 of file vxge_config.h.

Referenced by __vxge_hw_device_access_rights_get().

#define VXGE_HW_DEVICE_ACCESS_RIGHT_MRPCIM 0x4

Definition at line 497 of file vxge_config.h.

Referenced by __vxge_hw_device_access_rights_get(), and vxge_hw_device_hw_info_get().

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

Definition at line 520 of file vxge_config.h.

Referenced by __vxge_hw_vpath_mgmt_read().

#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 522 of file vxge_config.h.

Referenced by __vxge_hw_vp_initialize().

#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 533 of file vxge_config.h.

Referenced by __vxge_hw_vp_terminate().

#define vxge_debug	(	mask,
		fmt...		)

Value:

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

Definition at line 770 of file vxge_config.h.

Referenced by __vxge_hw_fifo_create(), __vxge_hw_ring_create(), __vxge_hw_vpath_alarm_process(), vxge_close(), vxge_device_register(), vxge_device_unregister(), vxge_hw_device_begin_irq(), vxge_hw_device_initialize(), vxge_hw_fifo_free_txdl_get(), vxge_hw_vpath_poll_rx(), vxge_irq(), vxge_open(), vxge_open_vpaths(), vxge_poll(), vxge_probe(), vxge_remove(), vxge_reset_all_vpaths(), vxge_xmit(), and vxge_xmit_compl().

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

Definition at line 775 of file vxge_config.h.

Referenced by __vxge_hw_device_pci_e_init(), __vxge_hw_device_vpath_reset_in_prog_check(), __vxge_hw_fifo_create(), __vxge_hw_fifo_delete(), __vxge_hw_kdfc_swapper_set(), __vxge_hw_legacy_swapper_set(), __vxge_hw_ring_create(), __vxge_hw_ring_delete(), __vxge_hw_vp_initialize(), __vxge_hw_vp_terminate(), __vxge_hw_vpath_initialize(), __vxge_hw_vpath_kdfc_configure(), __vxge_hw_vpath_mac_configure(), __vxge_hw_vpath_prc_configure(), __vxge_hw_vpath_reset(), __vxge_hw_vpath_reset_check(), __vxge_hw_vpath_swapper_set(), __vxge_hw_vpath_tim_configure(), vxge_hw_device_hw_info_get(), vxge_hw_device_initialize(), vxge_hw_device_terminate(), vxge_hw_ring_replenish(), vxge_hw_vpath_close(), vxge_hw_vpath_enable(), vxge_hw_vpath_mtu_set(), vxge_hw_vpath_open(), vxge_hw_vpath_recover_from_reset(), vxge_hw_vpath_reset(), vxge_hw_vpath_rx_doorbell_init(), vxge_reset_all_vpaths(), vxge_xmit(), and vxge_xmit_compl().

Enumeration Type Documentation

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 74 of file vxge_config.h.

00074                     {
00075         VXGE_HW_OK                                = 0,
00076         VXGE_HW_FAIL                              = 1,
00077         VXGE_HW_PENDING                           = 2,
00078         VXGE_HW_COMPLETIONS_REMAIN                = 3,
00079 
00080         VXGE_HW_INF_NO_MORE_COMPLETED_DESCRIPTORS = VXGE_HW_BASE_INF + 1,
00081         VXGE_HW_INF_OUT_OF_DESCRIPTORS            = VXGE_HW_BASE_INF + 2,
00082         VXGE_HW_INF_SW_LRO_BEGIN                  = VXGE_HW_BASE_INF + 3,
00083         VXGE_HW_INF_SW_LRO_CONT                   = VXGE_HW_BASE_INF + 4,
00084         VXGE_HW_INF_SW_LRO_UNCAPABLE              = VXGE_HW_BASE_INF + 5,
00085         VXGE_HW_INF_SW_LRO_FLUSH_SESSION          = VXGE_HW_BASE_INF + 6,
00086         VXGE_HW_INF_SW_LRO_FLUSH_BOTH             = VXGE_HW_BASE_INF + 7,
00087 
00088         VXGE_HW_ERR_INVALID_HANDLE                = VXGE_HW_BASE_ERR + 1,
00089         VXGE_HW_ERR_OUT_OF_MEMORY                 = VXGE_HW_BASE_ERR + 2,
00090         VXGE_HW_ERR_VPATH_NOT_AVAILABLE           = VXGE_HW_BASE_ERR + 3,
00091         VXGE_HW_ERR_VPATH_NOT_OPEN                = VXGE_HW_BASE_ERR + 4,
00092         VXGE_HW_ERR_WRONG_IRQ                     = VXGE_HW_BASE_ERR + 5,
00093         VXGE_HW_ERR_SWAPPER_CTRL                  = VXGE_HW_BASE_ERR + 6,
00094         VXGE_HW_ERR_INVALID_MTU_SIZE              = VXGE_HW_BASE_ERR + 7,
00095         VXGE_HW_ERR_INVALID_INDEX                 = VXGE_HW_BASE_ERR + 8,
00096         VXGE_HW_ERR_INVALID_TYPE                  = VXGE_HW_BASE_ERR + 9,
00097         VXGE_HW_ERR_INVALID_OFFSET                = VXGE_HW_BASE_ERR + 10,
00098         VXGE_HW_ERR_INVALID_DEVICE                = VXGE_HW_BASE_ERR + 11,
00099         VXGE_HW_ERR_VERSION_CONFLICT              = VXGE_HW_BASE_ERR + 12,
00100         VXGE_HW_ERR_INVALID_PCI_INFO              = VXGE_HW_BASE_ERR + 13,
00101         VXGE_HW_ERR_INVALID_TCODE                 = VXGE_HW_BASE_ERR + 14,
00102         VXGE_HW_ERR_INVALID_BLOCK_SIZE            = VXGE_HW_BASE_ERR + 15,
00103         VXGE_HW_ERR_INVALID_STATE                 = VXGE_HW_BASE_ERR + 16,
00104         VXGE_HW_ERR_PRIVILAGED_OPEARATION         = VXGE_HW_BASE_ERR + 17,
00105         VXGE_HW_ERR_INVALID_PORT                  = VXGE_HW_BASE_ERR + 18,
00106         VXGE_HW_ERR_FIFO                          = VXGE_HW_BASE_ERR + 19,
00107         VXGE_HW_ERR_VPATH                         = VXGE_HW_BASE_ERR + 20,
00108         VXGE_HW_ERR_CRITICAL                      = VXGE_HW_BASE_ERR + 21,
00109         VXGE_HW_ERR_SLOT_FREEZE                   = VXGE_HW_BASE_ERR + 22,
00110         VXGE_HW_ERR_INVALID_MIN_BANDWIDTH         = VXGE_HW_BASE_ERR + 25,
00111         VXGE_HW_ERR_INVALID_MAX_BANDWIDTH         = VXGE_HW_BASE_ERR + 26,
00112         VXGE_HW_ERR_INVALID_TOTAL_BANDWIDTH       = VXGE_HW_BASE_ERR + 27,
00113         VXGE_HW_ERR_INVALID_BANDWIDTH_LIMIT       = VXGE_HW_BASE_ERR + 28,
00114         VXGE_HW_ERR_RESET_IN_PROGRESS             = VXGE_HW_BASE_ERR + 29,
00115         VXGE_HW_ERR_OUT_OF_SPACE                  = VXGE_HW_BASE_ERR + 30,
00116         VXGE_HW_ERR_INVALID_FUNC_MODE             = VXGE_HW_BASE_ERR + 31,
00117         VXGE_HW_ERR_INVALID_DP_MODE               = VXGE_HW_BASE_ERR + 32,
00118         VXGE_HW_ERR_INVALID_FAILURE_BEHAVIOUR     = VXGE_HW_BASE_ERR + 33,
00119         VXGE_HW_ERR_INVALID_L2_SWITCH_STATE       = VXGE_HW_BASE_ERR + 34,
00120         VXGE_HW_ERR_INVALID_CATCH_BASIN_MODE      = VXGE_HW_BASE_ERR + 35,
00121 
00122         VXGE_HW_BADCFG_RING_INDICATE_MAX_PKTS     = VXGE_HW_BASE_BADCFG + 1,
00123         VXGE_HW_BADCFG_FIFO_BLOCKS                = VXGE_HW_BASE_BADCFG + 2,
00124         VXGE_HW_BADCFG_VPATH_MTU                  = VXGE_HW_BASE_BADCFG + 3,
00125         VXGE_HW_BADCFG_VPATH_RPA_STRIP_VLAN_TAG   = VXGE_HW_BASE_BADCFG + 4,
00126         VXGE_HW_BADCFG_VPATH_MIN_BANDWIDTH        = VXGE_HW_BASE_BADCFG + 5,
00127         VXGE_HW_BADCFG_VPATH_BANDWIDTH_LIMIT      = VXGE_HW_BASE_BADCFG + 6,
00128         VXGE_HW_BADCFG_INTR_MODE                  = VXGE_HW_BASE_BADCFG + 7,
00129         VXGE_HW_BADCFG_RTS_MAC_EN                 = VXGE_HW_BASE_BADCFG + 8,
00130         VXGE_HW_BADCFG_VPATH_AGGR_ACK             = VXGE_HW_BASE_BADCFG + 9,
00131         VXGE_HW_BADCFG_VPATH_PRIORITY             = VXGE_HW_BASE_BADCFG + 10,
00132 
00133         VXGE_HW_EOF_TRACE_BUF                     = -1
00134 };

enum vxge_hw_device_link_state

enum enum vxge_hw_device_link_state - Link state enumeration.

: Invalid link state. : Link is down. : Link is up.

Enumerator:

VXGE_HW_LINK_NONE
VXGE_HW_LINK_DOWN
VXGE_HW_LINK_UP

Definition at line 143 of file vxge_config.h.

00143                                {
00144         VXGE_HW_LINK_NONE,
00145         VXGE_HW_LINK_DOWN,
00146         VXGE_HW_LINK_UP
00147 };

enum vxge_hw_txdl_state

enum enum vxge_hw_txdl_state - Descriptor (TXDL) state.

: Invalid state. : Descriptor is available for reservation. : Descriptor is posted for processing by the device. : 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 556 of file vxge_config.h.

00556                         {
00557         VXGE_HW_TXDL_STATE_NONE = 0,
00558         VXGE_HW_TXDL_STATE_AVAIL        = 1,
00559         VXGE_HW_TXDL_STATE_POSTED       = 2,
00560         VXGE_HW_TXDL_STATE_FREED        = 3
00561 };

Function Documentation

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
	)			`[inline, static]`

Definition at line 565 of file vxge_config.h.

Referenced by vxge_hw_fifo_txd_offset_up(), and vxge_hw_ring_rxd_offset_up().

00567 {
00568         if (++(*offset) >= upper_limit)
00569                 *offset = 0;
00570 }

static void vxge_hw_ring_rxd_offset_up ( u16 * offset ) [inline, static]

Definition at line 573 of file vxge_config.h.

References __vxge_hw_desc_offset_up(), and VXGE_HW_MAX_RXDS_PER_BLOCK_1.

Referenced by vxge_hw_vpath_poll_rx().

00574 {
00575         __vxge_hw_desc_offset_up(VXGE_HW_MAX_RXDS_PER_BLOCK_1,
00576                         offset);
00577 }

static void vxge_hw_fifo_txd_offset_up ( u16 * offset ) [inline, static]

Definition at line 579 of file vxge_config.h.

References __vxge_hw_desc_offset_up(), and VXGE_HW_FIFO_TXD_DEPTH.

Referenced by vxge_hw_fifo_txdl_post(), and vxge_hw_vpath_poll_tx().

00580 {
00581         __vxge_hw_desc_offset_up(VXGE_HW_FIFO_TXD_DEPTH, offset);
00582 }

static void vxge_hw_ring_rxd_1b_set	(	struct vxge_hw_ring_rxd_1 *	rxdp,
		struct io_buffer *	iob,
		u32	size
	)			`[inline, static]`

vxge_hw_ring_rxd_1b_set - Prepare 1-buffer-mode descriptor.

: Descriptor handle. : 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 of the receive 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 600 of file vxge_config.h.

References vxge_hw_ring_rxd_1::buffer0_ptr, vxge_hw_ring_rxd_1::control_1, io_buffer::data, vxge_hw_ring_rxd_1::host_control, 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().

00602 {
00603         rxdp->host_control = (intptr_t)(iob);
00604         rxdp->buffer0_ptr = virt_to_bus(iob->data);
00605         rxdp->control_1 &= ~VXGE_HW_RING_RXD_1_BUFFER0_SIZE_MASK;
00606         rxdp->control_1 |= VXGE_HW_RING_RXD_1_BUFFER0_SIZE(size);
00607 }

enum vxge_hw_status vxge_hw_device_hw_info_get	(	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 357 of file vxge_config.c.

References __vxge_hw_device_access_rights_get(), __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, 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().

00359 {
00360         u32 i;
00361         u64 val64;
00362         struct vxge_hw_toc_reg __iomem *toc;
00363         struct vxge_hw_mrpcim_reg __iomem *mrpcim_reg;
00364         struct vxge_hw_common_reg __iomem *common_reg;
00365         struct vxge_hw_vpath_reg __iomem *vpath_reg;
00366         struct vxge_hw_vpmgmt_reg __iomem *vpmgmt_reg;
00367         enum vxge_hw_status status;
00368 
00369         vxge_trace();
00370 
00371         memset(hw_info, 0, sizeof(struct vxge_hw_device_hw_info));
00372 
00373         toc = __vxge_hw_device_toc_get(bar0);
00374         if (toc == NULL) {
00375                 status = VXGE_HW_ERR_CRITICAL;
00376                 goto exit;
00377         }
00378 
00379         val64 = readq(&toc->toc_common_pointer);
00380         common_reg = (struct vxge_hw_common_reg __iomem *)(bar0 + val64);
00381 
00382         status = __vxge_hw_device_vpath_reset_in_prog_check(
00383                 (u64 __iomem *)&common_reg->vpath_rst_in_prog);
00384         if (status != VXGE_HW_OK)
00385                 goto exit;
00386 
00387         hw_info->vpath_mask = readq(&common_reg->vpath_assignments);
00388 
00389         val64 = readq(&common_reg->host_type_assignments);
00390 
00391         hw_info->host_type =
00392            (u32)VXGE_HW_HOST_TYPE_ASSIGNMENTS_GET_HOST_TYPE_ASSIGNMENTS(val64);
00393 
00394         for (i = 0; i < VXGE_HW_MAX_VIRTUAL_PATHS; i++) {
00395 
00396                 if (!((hw_info->vpath_mask) & vxge_mBIT(i)))
00397                         continue;
00398 
00399                 val64 = readq(&toc->toc_vpmgmt_pointer[i]);
00400 
00401                 vpmgmt_reg = (struct vxge_hw_vpmgmt_reg __iomem *)
00402                                 (bar0 + val64);
00403 
00404                 hw_info->func_id = __vxge_hw_vpath_func_id_get(vpmgmt_reg);
00405                 if (__vxge_hw_device_access_rights_get(hw_info->host_type,
00406                         hw_info->func_id) &
00407                         VXGE_HW_DEVICE_ACCESS_RIGHT_MRPCIM) {
00408 
00409                         val64 = readq(&toc->toc_mrpcim_pointer);
00410 
00411                         mrpcim_reg = (struct vxge_hw_mrpcim_reg __iomem *)
00412                                         (bar0 + val64);
00413 
00414                         writeq(0, &mrpcim_reg->xgmac_gen_fw_memo_mask);
00415                         wmb();
00416                 }
00417 
00418                 val64 = readq(&toc->toc_vpath_pointer[i]);
00419 
00420                 vpath_reg = (struct vxge_hw_vpath_reg __iomem *)(bar0 + val64);
00421 
00422                 status = __vxge_hw_vpath_fw_ver_get(vpath_reg, hw_info);
00423                 if (status != VXGE_HW_OK)
00424                         goto exit;
00425 
00426                 status = __vxge_hw_vpath_card_info_get(vpath_reg, hw_info);
00427                 if (status != VXGE_HW_OK)
00428                         goto exit;
00429 
00430                 break;
00431         }
00432 
00433         for (i = 0; i < VXGE_HW_MAX_VIRTUAL_PATHS; i++) {
00434 
00435                 if (!((hw_info->vpath_mask) & vxge_mBIT(i)))
00436                         continue;
00437 
00438                 val64 = readq(&toc->toc_vpath_pointer[i]);
00439                 vpath_reg = (struct vxge_hw_vpath_reg __iomem *)(bar0 + val64);
00440 
00441                 status =  __vxge_hw_vpath_addr_get(vpath_reg,
00442                                 hw_info->mac_addrs[i],
00443                                 hw_info->mac_addr_masks[i]);
00444                 if (status != VXGE_HW_OK)
00445                         goto exit;
00446         }
00447 exit:
00448         return status;
00449 }

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 1022 of file vxge_config.c.

Referenced by vxge_hw_device_hw_info_get().

01025 {
01026         u64 val64;
01027         u64 data1 = 0ULL;
01028         u64 data2 = 0ULL;
01029         struct vxge_hw_device_version *fw_version = &hw_info->fw_version;
01030         struct vxge_hw_device_date *fw_date = &hw_info->fw_date;
01031         struct vxge_hw_device_version *flash_version = &hw_info->flash_version;
01032         struct vxge_hw_device_date *flash_date = &hw_info->flash_date;
01033         enum vxge_hw_status status = VXGE_HW_OK;
01034 
01035         val64 = VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION(
01036                 VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION_READ_ENTRY) |
01037                 VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(
01038                 VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO) |
01039                 VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE |
01040                 VXGE_HW_RTS_ACCESS_STEER_CTRL_OFFSET(0);
01041 
01042         status = __vxge_hw_pio_mem_write64(val64,
01043                                 &vpath_reg->rts_access_steer_ctrl,
01044                                 VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE,
01045                                 VXGE_HW_DEF_DEVICE_POLL_MILLIS);
01046 
01047         if (status != VXGE_HW_OK)
01048                 goto exit;
01049 
01050         val64 = readq(&vpath_reg->rts_access_steer_ctrl);
01051 
01052         if (val64 & VXGE_HW_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS) {
01053 
01054                 data1 = readq(&vpath_reg->rts_access_steer_data0);
01055                 data2 = readq(&vpath_reg->rts_access_steer_data1);
01056 
01057                 fw_date->day =
01058                         (u32)VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_DAY(
01059                                                 data1);
01060                 fw_date->month =
01061                         (u32)VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_MONTH(
01062                                                 data1);
01063                 fw_date->year =
01064                         (u32)VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_YEAR(
01065                                                 data1);
01066 
01067                 snprintf(fw_date->date, VXGE_HW_FW_STRLEN, "%d/%d/%d",
01068                         fw_date->month, fw_date->day, fw_date->year);
01069 
01070                 fw_version->major =
01071                     (u32)VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_MAJOR(data1);
01072                 fw_version->minor =
01073                     (u32)VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_MINOR(data1);
01074                 fw_version->build =
01075                     (u32)VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_BUILD(data1);
01076 
01077                 snprintf(fw_version->version, VXGE_HW_FW_STRLEN, "%d.%d.%d",
01078                     fw_version->major, fw_version->minor, fw_version->build);
01079 
01080                 flash_date->day =
01081                   (u32)VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_FLASH_VER_DAY(data2);
01082                 flash_date->month =
01083                  (u32)VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_FLASH_VER_MONTH(data2);
01084                 flash_date->year =
01085                  (u32)VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_FLASH_VER_YEAR(data2);
01086 
01087                 snprintf(flash_date->date, VXGE_HW_FW_STRLEN, "%d/%d/%d",
01088                         flash_date->month, flash_date->day, flash_date->year);
01089 
01090                 flash_version->major =
01091                  (u32)VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_FLASH_VER_MAJOR(data2);
01092                 flash_version->minor =
01093                  (u32)VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_FLASH_VER_MINOR(data2);
01094                 flash_version->build =
01095                  (u32)VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_FLASH_VER_BUILD(data2);
01096 
01097                 snprintf(flash_version->version, VXGE_HW_FW_STRLEN, "%d.%d.%d",
01098                         flash_version->major, flash_version->minor,
01099                         flash_version->build);
01100 
01101                 status = VXGE_HW_OK;
01102 
01103         } else
01104                 status = VXGE_HW_FAIL;
01105 exit:
01106         return status;
01107 }

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 901 of file vxge_config.c.

Referenced by vxge_hw_device_hw_info_get().

00904 {
00905         u32 i, j;
00906         u64 val64;
00907         u64 data1 = 0ULL;
00908         u64 data2 = 0ULL;
00909         enum vxge_hw_status status = VXGE_HW_OK;
00910         u8 *serial_number = hw_info->serial_number;
00911         u8 *part_number = hw_info->part_number;
00912         u8 *product_desc = hw_info->product_desc;
00913 
00914         __vxge_hw_read_rts_ds(vpath_reg,
00915                 VXGE_HW_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_SERIAL_NUMBER);
00916 
00917         val64 = VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION(
00918                         VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION_READ_MEMO_ENTRY) |
00919                 VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(
00920                         VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO) |
00921                 VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE |
00922                 VXGE_HW_RTS_ACCESS_STEER_CTRL_OFFSET(0);
00923 
00924         status = __vxge_hw_pio_mem_write64(val64,
00925                                 &vpath_reg->rts_access_steer_ctrl,
00926                                 VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE,
00927                                 VXGE_HW_DEF_DEVICE_POLL_MILLIS);
00928 
00929         if (status != VXGE_HW_OK)
00930                 return status;
00931 
00932         val64 = readq(&vpath_reg->rts_access_steer_ctrl);
00933 
00934         if (val64 & VXGE_HW_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS) {
00935                 data1 = readq(&vpath_reg->rts_access_steer_data0);
00936                 ((u64 *)serial_number)[0] = be64_to_cpu(data1);
00937 
00938                 data2 = readq(&vpath_reg->rts_access_steer_data1);
00939                 ((u64 *)serial_number)[1] = be64_to_cpu(data2);
00940                 status = VXGE_HW_OK;
00941         } else
00942                 *serial_number = 0;
00943 
00944         __vxge_hw_read_rts_ds(vpath_reg,
00945                         VXGE_HW_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_PART_NUMBER);
00946 
00947         val64 = VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION(
00948                         VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION_READ_MEMO_ENTRY) |
00949                 VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(
00950                         VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO) |
00951                 VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE |
00952                 VXGE_HW_RTS_ACCESS_STEER_CTRL_OFFSET(0);
00953 
00954         status = __vxge_hw_pio_mem_write64(val64,
00955                                 &vpath_reg->rts_access_steer_ctrl,
00956                                 VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE,
00957                                 VXGE_HW_DEF_DEVICE_POLL_MILLIS);
00958 
00959         if (status != VXGE_HW_OK)
00960                 return status;
00961 
00962         val64 = readq(&vpath_reg->rts_access_steer_ctrl);
00963 
00964         if (val64 & VXGE_HW_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS) {
00965 
00966                 data1 = readq(&vpath_reg->rts_access_steer_data0);
00967                 ((u64 *)part_number)[0] = be64_to_cpu(data1);
00968 
00969                 data2 = readq(&vpath_reg->rts_access_steer_data1);
00970                 ((u64 *)part_number)[1] = be64_to_cpu(data2);
00971 
00972                 status = VXGE_HW_OK;
00973 
00974         } else
00975                 *part_number = 0;
00976 
00977         j = 0;
00978 
00979         for (i = VXGE_HW_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_DESC_0;
00980              i <= VXGE_HW_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_DESC_3; i++) {
00981 
00982                 __vxge_hw_read_rts_ds(vpath_reg, i);
00983 
00984                 val64 = VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION(
00985                         VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION_READ_MEMO_ENTRY) |
00986                         VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(
00987                         VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO) |
00988                         VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE |
00989                         VXGE_HW_RTS_ACCESS_STEER_CTRL_OFFSET(0);
00990 
00991                 status = __vxge_hw_pio_mem_write64(val64,
00992                                 &vpath_reg->rts_access_steer_ctrl,
00993                                 VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE,
00994                                 VXGE_HW_DEF_DEVICE_POLL_MILLIS);
00995 
00996                 if (status != VXGE_HW_OK)
00997                         return status;
00998 
00999                 val64 = readq(&vpath_reg->rts_access_steer_ctrl);
01000 
01001                 if (val64 & VXGE_HW_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS) {
01002 
01003                         data1 = readq(&vpath_reg->rts_access_steer_data0);
01004                         ((u64 *)product_desc)[j++] = be64_to_cpu(data1);
01005 
01006                         data2 = readq(&vpath_reg->rts_access_steer_data1);
01007                         ((u64 *)product_desc)[j++] = be64_to_cpu(data2);
01008 
01009                         status = VXGE_HW_OK;
01010                 } else
01011                         *product_desc = 0;
01012         }
01013 
01014         return status;
01015 }

static enum vxge_hw_device_link_state vxge_hw_device_link_state_get ( struct __vxge_hw_device * devh ) [inline, static]

vxge_hw_device_link_state_get - Get link state.

: HW device handle.

Get link state. Returns: link state.

Definition at line 631 of file vxge_config.h.

References __vxge_hw_device::link_state.

Referenced by vxge_open().

00633 {
00634         return devh->link_state;
00635 }

void vxge_hw_device_terminate ( struct __vxge_hw_device * devh )

Definition at line 508 of file vxge_config.c.

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().

00509 {
00510         vxge_trace();
00511 
00512         assert(hldev->magic == VXGE_HW_DEVICE_MAGIC);
00513 
00514         hldev->magic = VXGE_HW_DEVICE_DEAD;
00515         free(hldev);
00516 }

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

Definition at line 461 of file vxge_config.c.

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, __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().

00466 {
00467         struct __vxge_hw_device *hldev = NULL;
00468         enum vxge_hw_status status = VXGE_HW_OK;
00469 
00470         vxge_trace();
00471 
00472         hldev = (struct __vxge_hw_device *)
00473                         zalloc(sizeof(struct __vxge_hw_device));
00474         if (hldev == NULL) {
00475                 vxge_debug(VXGE_ERR, "hldev allocation failed\n");
00476                 status = VXGE_HW_ERR_OUT_OF_MEMORY;
00477                 goto exit;
00478         }
00479 
00480         hldev->magic = VXGE_HW_DEVICE_MAGIC;
00481 
00482         hldev->bar0 = bar0;
00483         hldev->pdev = pdev;
00484         hldev->titan1 = titan1;
00485 
00486         __vxge_hw_device_pci_e_init(hldev);
00487 
00488         status = __vxge_hw_device_reg_addr_get(hldev);
00489         if (status != VXGE_HW_OK) {
00490                 vxge_debug(VXGE_ERR, "%s:%d __vxge_hw_device_reg_addr_get "
00491                         "failed\n", __func__, __LINE__);
00492                 vxge_hw_device_terminate(hldev);
00493                 goto exit;
00494         }
00495 
00496         __vxge_hw_device_host_info_get(hldev);
00497 
00498         *devh = hldev;
00499 exit:
00500         return status;
00501 }

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

Definition at line 1656 of file vxge_config.c.

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::ringh, __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().

01657 {
01658         struct __vxge_hw_virtualpath *vpathh;
01659         enum vxge_hw_status status;
01660 
01661         vxge_trace();
01662 
01663         vpathh = &hldev->virtual_path;
01664 
01665         if (vpath->vp_open == VXGE_HW_VP_OPEN) {
01666                 status = VXGE_HW_ERR_INVALID_STATE;
01667                 goto vpath_open_exit1;
01668         }
01669 
01670         status = __vxge_hw_vp_initialize(hldev, hldev->first_vp_id, vpathh);
01671         if (status != VXGE_HW_OK)
01672                 goto vpath_open_exit1;
01673 
01674         status = __vxge_hw_fifo_create(vpathh, &vpathh->fifoh);
01675         if (status != VXGE_HW_OK)
01676                 goto vpath_open_exit2;
01677 
01678         status = __vxge_hw_ring_create(vpathh, &vpathh->ringh);
01679         if (status != VXGE_HW_OK)
01680                 goto vpath_open_exit3;
01681 
01682         __vxge_hw_vpath_prc_configure(hldev);
01683 
01684         return VXGE_HW_OK;
01685 
01686 vpath_open_exit3:
01687         __vxge_hw_fifo_delete(&vpathh->fifoh);
01688 vpath_open_exit2:
01689         __vxge_hw_vp_terminate(hldev, vpathh);
01690 vpath_open_exit1:
01691         return status;
01692 }

enum vxge_hw_status __vxge_hw_device_vpath_reset_in_prog_check ( u64 __iomem * vpath_rst_in_prog )

Definition at line 176 of file vxge_config.c.

References __vxge_hw_device_register_poll(), 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().

00177 {
00178         enum vxge_hw_status status;
00179 
00180         vxge_trace();
00181 
00182         status = __vxge_hw_device_register_poll(vpath_rst_in_prog,
00183                         VXGE_HW_VPATH_RST_IN_PROG_VPATH_RST_IN_PROG(0x1ffff),
00184                         VXGE_HW_DEF_DEVICE_POLL_MILLIS);
00185         return status;
00186 }

enum vxge_hw_status vxge_hw_vpath_close ( struct __vxge_hw_virtualpath * vpath )

Definition at line 1726 of file vxge_config.c.

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, u32, __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().

01727 {
01728         struct __vxge_hw_device *devh = NULL;
01729         u32 vp_id = vpath->vp_id;
01730         enum vxge_hw_status status = VXGE_HW_OK;
01731 
01732         vxge_trace();
01733 
01734         devh = vpath->hldev;
01735 
01736         if (vpath->vp_open == VXGE_HW_VP_NOT_OPEN) {
01737                 status = VXGE_HW_ERR_VPATH_NOT_OPEN;
01738                 goto vpath_close_exit;
01739         }
01740 
01741         devh->vpaths_deployed &= ~vxge_mBIT(vp_id);
01742 
01743         __vxge_hw_ring_delete(&vpath->ringh);
01744 
01745         __vxge_hw_fifo_delete(&vpath->fifoh);
01746 
01747         __vxge_hw_vp_terminate(devh, vpath);
01748 
01749         vpath->vp_open = VXGE_HW_VP_NOT_OPEN;
01750 
01751 vpath_close_exit:
01752         return status;
01753 }

enum vxge_hw_status vxge_hw_vpath_reset ( struct __vxge_hw_virtualpath * vpath )

Definition at line 1759 of file vxge_config.c.

References __vxge_hw_vpath_reset(), __vxge_hw_virtualpath::hldev, u32, __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().

01760 {
01761         enum vxge_hw_status status;
01762         u32 vp_id;
01763 
01764         vxge_trace();
01765 
01766         vp_id = vpath->vp_id;
01767 
01768         if (vpath->vp_open == VXGE_HW_VP_NOT_OPEN) {
01769                 status = VXGE_HW_ERR_VPATH_NOT_OPEN;
01770                 goto exit;
01771         }
01772 
01773         status = __vxge_hw_vpath_reset(vpath->hldev, vp_id);
01774 exit:
01775         return status;
01776 }

enum vxge_hw_status vxge_hw_vpath_recover_from_reset ( struct __vxge_hw_virtualpath * vpath )

Definition at line 1784 of file vxge_config.c.

References __vxge_hw_vpath_initialize(), __vxge_hw_vpath_prc_configure(), __vxge_hw_vpath_reset_check(), __vxge_hw_virtualpath::hldev, u32, __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().

01785 {
01786         enum vxge_hw_status status;
01787         struct __vxge_hw_device *hldev;
01788         u32 vp_id;
01789 
01790         vxge_trace();
01791 
01792         vp_id = vpath->vp_id;
01793         hldev = vpath->hldev;
01794 
01795         if (vpath->vp_open == VXGE_HW_VP_NOT_OPEN) {
01796                 status = VXGE_HW_ERR_VPATH_NOT_OPEN;
01797                 goto exit;
01798         }
01799 
01800         status = __vxge_hw_vpath_reset_check(vpath);
01801         if (status != VXGE_HW_OK)
01802                 goto exit;
01803 
01804         status = __vxge_hw_vpath_initialize(hldev, vp_id);
01805         if (status != VXGE_HW_OK)
01806                 goto exit;
01807 
01808         __vxge_hw_vpath_prc_configure(hldev);
01809 
01810 exit:
01811         return status;
01812 }

void vxge_hw_vpath_enable ( struct __vxge_hw_virtualpath * vpath )

Definition at line 1820 of file vxge_config.c.

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

Referenced by vxge_open().

01821 {
01822         struct __vxge_hw_device *hldev;
01823         u64 val64;
01824 
01825         vxge_trace();
01826 
01827         hldev = vpath->hldev;
01828 
01829         val64 = VXGE_HW_CMN_RSTHDLR_CFG1_CLR_VPATH_RESET(
01830                 1 << (16 - vpath->vp_id));
01831 
01832         __vxge_hw_pio_mem_write32_upper((u32)vxge_bVALn(val64, 0, 32),
01833                 &hldev->common_reg->cmn_rsthdlr_cfg1);
01834 }

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

Definition at line 1627 of file vxge_config.c.

References __vxge_hw_virtualpath::max_mtu, readq, vxge_hw_vpath_reg::rxmac_vcfg0, __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().

01628 {
01629         u64 val64;
01630         enum vxge_hw_status status = VXGE_HW_OK;
01631 
01632         vxge_trace();
01633 
01634         new_mtu += VXGE_HW_MAC_HEADER_MAX_SIZE;
01635 
01636         if ((new_mtu < VXGE_HW_MIN_MTU) || (new_mtu > vpath->max_mtu))
01637                 status = VXGE_HW_ERR_INVALID_MTU_SIZE;
01638 
01639         val64 = readq(&vpath->vp_reg->rxmac_vcfg0);
01640 
01641         val64 &= ~VXGE_HW_RXMAC_VCFG0_RTS_MAX_FRM_LEN(0x3fff);
01642         val64 |= VXGE_HW_RXMAC_VCFG0_RTS_MAX_FRM_LEN(new_mtu);
01643 
01644         writeq(val64, &vpath->vp_reg->rxmac_vcfg0);
01645 
01646         return status;
01647 }

void vxge_hw_vpath_rx_doorbell_init ( struct __vxge_hw_virtualpath * vpath )

Definition at line 1703 of file vxge_config.c.

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().

01704 {
01705         u64 new_count, val64;
01706 
01707         vxge_trace();
01708 
01709         if (vpath->hldev->titan1) {
01710                 new_count = readq(&vpath->vp_reg->rxdmem_size);
01711                 new_count &= 0x1fff;
01712         } else
01713                 new_count = VXGE_HW_RING_RXD_QWORDS_MODE_1 * 4;
01714 
01715         val64 = (VXGE_HW_RXDMEM_SIZE_PRC_RXDMEM_SIZE(new_count));
01716 
01717         writeq(VXGE_HW_PRC_RXD_DOORBELL_NEW_QW_CNT(val64),
01718                 &vpath->vp_reg->prc_rxd_doorbell);
01719 }

void __vxge_hw_device_pci_e_init ( struct __vxge_hw_device * hldev )

Definition at line 124 of file vxge_config.c.

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

Referenced by vxge_hw_device_initialize().

00125 {
00126         u16 cmd = 0;
00127         struct pci_device *pdev = hldev->pdev;
00128 
00129         vxge_trace();
00130 
00131         /* Set the PErr Repconse bit and SERR in PCI command register. */
00132         pci_read_config_word(pdev, PCI_COMMAND, &cmd);
00133         cmd |= 0x140;
00134         pci_write_config_word(pdev, PCI_COMMAND, cmd);
00135 
00136         return;
00137 }

enum vxge_hw_status __vxge_hw_legacy_swapper_set ( struct vxge_hw_legacy_reg __iomem * legacy_reg )

Definition at line 649 of file vxge_config.c.

References readq, 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_toc_get(), and __vxge_hw_vpath_initialize().

00650 {
00651         u64 val64;
00652         enum vxge_hw_status status = VXGE_HW_OK;
00653 
00654         vxge_trace();
00655 
00656         val64 = readq(&legacy_reg->toc_swapper_fb);
00657 
00658         wmb();
00659 
00660         switch (val64) {
00661 
00662         case VXGE_HW_SWAPPER_INITIAL_VALUE:
00663                 return status;
00664 
00665         case VXGE_HW_SWAPPER_BYTE_SWAPPED_BIT_FLIPPED:
00666                 writeq(VXGE_HW_SWAPPER_READ_BYTE_SWAP_ENABLE,
00667                         &legacy_reg->pifm_rd_swap_en);
00668                 writeq(VXGE_HW_SWAPPER_READ_BIT_FLAP_ENABLE,
00669                         &legacy_reg->pifm_rd_flip_en);
00670                 writeq(VXGE_HW_SWAPPER_WRITE_BYTE_SWAP_ENABLE,
00671                         &legacy_reg->pifm_wr_swap_en);
00672                 writeq(VXGE_HW_SWAPPER_WRITE_BIT_FLAP_ENABLE,
00673                         &legacy_reg->pifm_wr_flip_en);
00674                 break;
00675 
00676         case VXGE_HW_SWAPPER_BYTE_SWAPPED:
00677                 writeq(VXGE_HW_SWAPPER_READ_BYTE_SWAP_ENABLE,
00678                         &legacy_reg->pifm_rd_swap_en);
00679                 writeq(VXGE_HW_SWAPPER_WRITE_BYTE_SWAP_ENABLE,
00680                         &legacy_reg->pifm_wr_swap_en);
00681                 break;
00682 
00683         case VXGE_HW_SWAPPER_BIT_FLIPPED:
00684                 writeq(VXGE_HW_SWAPPER_READ_BIT_FLAP_ENABLE,
00685                         &legacy_reg->pifm_rd_flip_en);
00686                 writeq(VXGE_HW_SWAPPER_WRITE_BIT_FLAP_ENABLE,
00687                         &legacy_reg->pifm_wr_flip_en);
00688                 break;
00689         }
00690 
00691         wmb();
00692 
00693         val64 = readq(&legacy_reg->toc_swapper_fb);
00694         if (val64 != VXGE_HW_SWAPPER_INITIAL_VALUE)
00695                 status = VXGE_HW_ERR_SWAPPER_CTRL;
00696 
00697         return status;
00698 }

enum vxge_hw_status __vxge_hw_vpath_swapper_set ( struct vxge_hw_vpath_reg __iomem * vpath_reg )

Definition at line 705 of file vxge_config.c.

References readq, VXGE_HW_OK, VXGE_HW_VPATH_GENERAL_CFG1_CTL_BYTE_SWAPEN, vxge_trace, wmb, and writeq.

Referenced by __vxge_hw_vpath_initialize().

00706 {
00707         vxge_trace();
00708 
00709 #if (__BYTE_ORDER != __BIG_ENDIAN)
00710         u64 val64;
00711 
00712         val64 = readq(&vpath_reg->vpath_general_cfg1);
00713         wmb();
00714         val64 |= VXGE_HW_VPATH_GENERAL_CFG1_CTL_BYTE_SWAPEN;
00715         writeq(val64, &vpath_reg->vpath_general_cfg1);
00716         wmb();
00717 #endif
00718         return VXGE_HW_OK;
00719 }

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 726 of file vxge_config.c.

References readq, 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().

00729 {
00730         u64 val64;
00731 
00732         vxge_trace();
00733 
00734         val64 = readq(&legacy_reg->pifm_wr_swap_en);
00735 
00736         if (val64 == VXGE_HW_SWAPPER_WRITE_BYTE_SWAP_ENABLE) {
00737                 val64 = readq(&vpath_reg->kdfcctl_cfg0);
00738                 wmb();
00739 
00740                 val64 |= VXGE_HW_KDFCCTL_CFG0_BYTE_SWAPEN_FIFO0 |
00741                         VXGE_HW_KDFCCTL_CFG0_BYTE_SWAPEN_FIFO1  |
00742                         VXGE_HW_KDFCCTL_CFG0_BYTE_SWAPEN_FIFO2;
00743 
00744                 writeq(val64, &vpath_reg->kdfcctl_cfg0);
00745                 wmb();
00746         }
00747 
00748         return VXGE_HW_OK;
00749 }

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

Definition at line 145 of file vxge_config.c.

References readq, u32, 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().

00146 {
00147         u64 val64;
00148         u32 i = 0;
00149         enum vxge_hw_status ret = VXGE_HW_FAIL;
00150 
00151         udelay(10);
00152 
00153         do {
00154                 val64 = readq(reg);
00155                 if (!(val64 & mask))
00156                         return VXGE_HW_OK;
00157                 udelay(100);
00158         } while (++i <= 9);
00159 
00160         i = 0;
00161         do {
00162                 val64 = readq(reg);
00163                 if (!(val64 & mask))
00164                         return VXGE_HW_OK;
00165                 udelay(1000);
00166         } while (++i <= max_millis);
00167 
00168         return ret;
00169 }

static void __vxge_hw_pio_mem_write32_upper	(	u32	val,
		void __iomem *	addr
	)			`[inline, static]`

Definition at line 705 of file vxge_config.h.

References 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().

00706 {
00707         writel(val, addr + 4);
00708 }

static void __vxge_hw_pio_mem_write32_lower	(	u32	val,
		void __iomem *	addr
	)			`[inline, static]`

Definition at line 710 of file vxge_config.h.

References writel.

Referenced by __vxge_hw_pio_mem_write64().

00711 {
00712         writel(val, addr);
00713 }

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

Definition at line 716 of file vxge_config.h.

References __vxge_hw_device_register_poll(), __vxge_hw_pio_mem_write32_lower(), __vxge_hw_pio_mem_write32_upper(), u32, 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().

00718 {
00719         enum vxge_hw_status status = VXGE_HW_OK;
00720 
00721         __vxge_hw_pio_mem_write32_lower((u32)vxge_bVALn(val64, 32, 32), addr);
00722         wmb();
00723         __vxge_hw_pio_mem_write32_upper((u32)vxge_bVALn(val64, 0, 32), addr);
00724         wmb();
00725 
00726         status = __vxge_hw_device_register_poll(addr, mask, max_millis);
00727         return status;
00728 }

struct vxge_hw_toc_reg __iomem* __vxge_hw_device_toc_get ( void __iomem * bar0 ) [read]

Definition at line 194 of file vxge_config.c.

References __vxge_hw_legacy_swapper_set(), NULL, readq, vxge_hw_legacy_reg::toc_first_pointer, and VXGE_HW_OK.

Referenced by __vxge_hw_device_reg_addr_get(), and vxge_hw_device_hw_info_get().

00195 {
00196         u64 val64;
00197         struct vxge_hw_toc_reg __iomem *toc = NULL;
00198         enum vxge_hw_status status;
00199 
00200         struct vxge_hw_legacy_reg __iomem *legacy_reg =
00201                 (struct vxge_hw_legacy_reg __iomem *)bar0;
00202 
00203         status = __vxge_hw_legacy_swapper_set(legacy_reg);
00204         if (status != VXGE_HW_OK)
00205                 goto exit;
00206 
00207         val64 = readq(&legacy_reg->toc_first_pointer);
00208         toc = (struct vxge_hw_toc_reg __iomem *)(bar0+val64);
00209 exit:
00210         return toc;
00211 }

enum vxge_hw_status __vxge_hw_device_reg_addr_get ( struct __vxge_hw_device * hldev )

Definition at line 220 of file vxge_config.c.

References __vxge_hw_device_toc_get(), __vxge_hw_device_vpath_reset_in_prog_check(), __vxge_hw_device::bar0, __vxge_hw_device::common_reg, __vxge_hw_device::kdfc, __vxge_hw_device::legacy_reg, __vxge_hw_device::mrpcim_reg, NULL, readq, __vxge_hw_device::srpcim_reg, vxge_hw_toc_reg::toc_common_pointer, vxge_hw_toc_reg::toc_kdfc, vxge_hw_toc_reg::toc_mrpcim_pointer, __vxge_hw_device::toc_reg, vxge_hw_toc_reg::toc_srpcim_pointer, vxge_hw_toc_reg::toc_vpath_pointer, vxge_hw_toc_reg::toc_vpmgmt_pointer, u32, u8, __vxge_hw_device::vpath_reg, vxge_hw_common_reg::vpath_rst_in_prog, __vxge_hw_device::vpmgmt_reg, VXGE_HW_FAIL, VXGE_HW_OK, VXGE_HW_TITAN_SRPCIM_REG_SPACES, VXGE_HW_TITAN_VPATH_REG_SPACES, VXGE_HW_TITAN_VPMGMT_REG_SPACES, VXGE_HW_TOC_GET_KDFC_INITIAL_BIR, and VXGE_HW_TOC_GET_KDFC_INITIAL_OFFSET.

Referenced by vxge_hw_device_initialize().

00221 {
00222         u64 val64;
00223         u32 i;
00224         enum vxge_hw_status status = VXGE_HW_OK;
00225 
00226         hldev->legacy_reg = (struct vxge_hw_legacy_reg __iomem *)hldev->bar0;
00227 
00228         hldev->toc_reg = __vxge_hw_device_toc_get(hldev->bar0);
00229         if (hldev->toc_reg  == NULL) {
00230                 status = VXGE_HW_FAIL;
00231                 goto exit;
00232         }
00233 
00234         val64 = readq(&hldev->toc_reg->toc_common_pointer);
00235         hldev->common_reg =
00236         (struct vxge_hw_common_reg __iomem *)(hldev->bar0 + val64);
00237 
00238         val64 = readq(&hldev->toc_reg->toc_mrpcim_pointer);
00239         hldev->mrpcim_reg =
00240                 (struct vxge_hw_mrpcim_reg __iomem *)(hldev->bar0 + val64);
00241 
00242         for (i = 0; i < VXGE_HW_TITAN_SRPCIM_REG_SPACES; i++) {
00243                 val64 = readq(&hldev->toc_reg->toc_srpcim_pointer[i]);
00244                 hldev->srpcim_reg[i] =
00245                         (struct vxge_hw_srpcim_reg __iomem *)
00246                                 (hldev->bar0 + val64);
00247         }
00248 
00249         for (i = 0; i < VXGE_HW_TITAN_VPMGMT_REG_SPACES; i++) {
00250                 val64 = readq(&hldev->toc_reg->toc_vpmgmt_pointer[i]);
00251                 hldev->vpmgmt_reg[i] =
00252                 (struct vxge_hw_vpmgmt_reg __iomem *)(hldev->bar0 + val64);
00253         }
00254 
00255         for (i = 0; i < VXGE_HW_TITAN_VPATH_REG_SPACES; i++) {
00256                 val64 = readq(&hldev->toc_reg->toc_vpath_pointer[i]);
00257                 hldev->vpath_reg[i] =
00258                         (struct vxge_hw_vpath_reg __iomem *)
00259                                 (hldev->bar0 + val64);
00260         }
00261 
00262         val64 = readq(&hldev->toc_reg->toc_kdfc);
00263 
00264         switch (VXGE_HW_TOC_GET_KDFC_INITIAL_BIR(val64)) {
00265         case 0:
00266                 hldev->kdfc = (u8 __iomem *)(hldev->bar0 +
00267                         VXGE_HW_TOC_GET_KDFC_INITIAL_OFFSET(val64));
00268                 break;
00269         default:
00270                 break;
00271         }
00272 
00273         status = __vxge_hw_device_vpath_reset_in_prog_check(
00274                         (u64 __iomem *)&hldev->common_reg->vpath_rst_in_prog);
00275 exit:
00276         return status;
00277 }

void __vxge_hw_device_host_info_get ( struct __vxge_hw_device * hldev )

Definition at line 320 of file vxge_config.c.

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_common_reg::vpath_assignments, __vxge_hw_device::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().

00321 {
00322         u64 val64;
00323         u32 i;
00324 
00325         val64 = readq(&hldev->common_reg->host_type_assignments);
00326 
00327         hldev->host_type =
00328            (u32)VXGE_HW_HOST_TYPE_ASSIGNMENTS_GET_HOST_TYPE_ASSIGNMENTS(val64);
00329 
00330         hldev->vpath_assignments = readq(&hldev->common_reg->vpath_assignments);
00331 
00332         for (i = 0; i < VXGE_HW_MAX_VIRTUAL_PATHS; i++) {
00333 
00334                 if (!(hldev->vpath_assignments & vxge_mBIT(i)))
00335                         continue;
00336 
00337                 hldev->func_id =
00338                         __vxge_hw_vpath_func_id_get(hldev->vpmgmt_reg[i]);
00339 
00340                 hldev->access_rights = __vxge_hw_device_access_rights_get(
00341                         hldev->host_type, hldev->func_id);
00342 
00343                 hldev->first_vp_id = i;
00344                 break;
00345         }
00346 
00347         return;
00348 }

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
	)

Definition at line 830 of file vxge_config.c.

References __vxge_hw_device_register_poll(), 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, u32, __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().

00832 {
00833         u64 val64;
00834         enum vxge_hw_status status = VXGE_HW_OK;
00835         struct vxge_hw_vpath_reg __iomem *vp_reg = vpath->vp_reg;
00836 
00837         val64 = VXGE_HW_PCI_CONFIG_ACCESS_CFG1_ADDRESS(offset);
00838 
00839         if (phy_func_0)
00840                 val64 |= VXGE_HW_PCI_CONFIG_ACCESS_CFG1_SEL_FUNC0;
00841 
00842         writeq(val64, &vp_reg->pci_config_access_cfg1);
00843         wmb();
00844         writeq(VXGE_HW_PCI_CONFIG_ACCESS_CFG2_REQ,
00845                         &vp_reg->pci_config_access_cfg2);
00846         wmb();
00847 
00848         status = __vxge_hw_device_register_poll(
00849                         &vp_reg->pci_config_access_cfg2,
00850                         VXGE_HW_INTR_MASK_ALL, VXGE_HW_DEF_DEVICE_POLL_MILLIS);
00851 
00852         if (status != VXGE_HW_OK)
00853                 goto exit;
00854 
00855         val64 = readq(&vp_reg->pci_config_access_status);
00856 
00857         if (val64 & VXGE_HW_PCI_CONFIG_ACCESS_STATUS_ACCESS_ERR) {
00858                 status = VXGE_HW_FAIL;
00859                 *val = 0;
00860         } else
00861                 *val = (u32)vxge_bVALn(val64, 32, 32);
00862 exit:
00863         return status;
00864 }

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 )

Definition at line 871 of file vxge_config.c.

References readq, u32, 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().

00872 {
00873         u64 val64;
00874 
00875         val64 = readq(&vpmgmt_reg->vpath_to_func_map_cfg1);
00876 
00877         return
00878          (u32)VXGE_HW_VPATH_TO_FUNC_MAP_CFG1_GET_VPATH_TO_FUNC_MAP_CFG1(val64);
00879 }

enum vxge_hw_status __vxge_hw_vpath_reset_check ( struct __vxge_hw_virtualpath * vpath )

Definition at line 1215 of file vxge_config.c.

References __vxge_hw_device_register_poll(), __vxge_hw_device::common_reg, __vxge_hw_virtualpath::hldev, __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().

01216 {
01217         enum vxge_hw_status status;
01218 
01219         vxge_trace();
01220 
01221         status = __vxge_hw_device_register_poll(
01222                         &vpath->hldev->common_reg->vpath_rst_in_prog,
01223                         VXGE_HW_VPATH_RST_IN_PROG_VPATH_RST_IN_PROG(
01224                                 1 << (16 - vpath->vp_id)),
01225                         VXGE_HW_DEF_DEVICE_POLL_MILLIS);
01226 
01227         return status;
01228 }

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

Definition at line 755 of file vxge_config.c.

References readq, vxge_hw_vpmgmt_reg::rxmac_cfg0_port_vpmgmt_clone, __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().

00756 {
00757         struct vxge_hw_vpmgmt_reg       __iomem *vpmgmt_reg;
00758         enum vxge_hw_status status = VXGE_HW_OK;
00759         int i = 0, j = 0;
00760 
00761         for (i = 0; i < VXGE_HW_MAX_VIRTUAL_PATHS; i++) {
00762                 if (!((vpath_mask) & vxge_mBIT(i)))
00763                         continue;
00764                 vpmgmt_reg = hldev->vpmgmt_reg[i];
00765                 for (j = 0; j < VXGE_HW_MAC_MAX_MAC_PORT_ID; j++) {
00766                         if (readq(&vpmgmt_reg->rxmac_cfg0_port_vpmgmt_clone[j])
00767                         & VXGE_HW_RXMAC_CFG0_PORT_VPMGMT_CLONE_STRIP_FCS)
00768                                 return VXGE_HW_FAIL;
00769                 }
00770         }
00771         return status;
00772 }

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

Definition at line 95 of file vxge_config.c.

References __vxge_hw_device::first_vp_id, readq, vxge_hw_vpath_reg::rts_access_steer_data0, __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().

00096 {
00097         enum vxge_hw_status status = VXGE_HW_OK;
00098         struct vxge_hw_vpath_reg __iomem *vp_reg;
00099         u64 val64;
00100         int vp_id;
00101 
00102         /* get the first vpath number assigned to this function */
00103         vp_id = hldev->first_vp_id;
00104 
00105         vp_reg = (struct vxge_hw_vpath_reg __iomem *)hldev->vpath_reg[vp_id];
00106 
00107         status = vxge_hw_set_fw_api(hldev, vp_id,
00108                                 VXGE_HW_FW_API_GET_FUNC_MODE, 0, 0, 0);
00109 
00110         if (status == VXGE_HW_OK) {
00111                 val64 = readq(&vp_reg->rts_access_steer_data0);
00112                 *func_mode = VXGE_HW_GET_FUNC_MODE_VAL(val64);
00113         }
00114 
00115         return status;
00116 }

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 45 of file vxge_config.c.

References __vxge_hw_device_register_poll(), 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, u32, __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().

00051 {
00052         enum vxge_hw_status status = VXGE_HW_OK;
00053         u64 val64;
00054         u32 fw_memo = VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO;
00055 
00056         struct vxge_hw_vpath_reg __iomem *vp_reg;
00057 
00058         vp_reg = (struct vxge_hw_vpath_reg __iomem *)hldev->vpath_reg[vp_id];
00059 
00060         writeq(data0, &vp_reg->rts_access_steer_data0);
00061         writeq(data1, &vp_reg->rts_access_steer_data1);
00062 
00063         wmb();
00064 
00065         val64 = VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION(action) |
00066                 VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(fw_memo) |
00067                 VXGE_HW_RTS_ACCESS_STEER_CTRL_OFFSET(offset) |
00068                 VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE;
00069 
00070         writeq(val64, &vp_reg->rts_access_steer_ctrl);
00071 
00072         wmb();
00073 
00074         status = __vxge_hw_device_register_poll(
00075                         &vp_reg->rts_access_steer_ctrl,
00076                         VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE,
00077                         WAIT_FACTOR *
00078                         VXGE_HW_DEF_DEVICE_POLL_MILLIS);
00079 
00080         if (status != VXGE_HW_OK)
00081                 return VXGE_HW_FAIL;
00082 
00083         val64 = readq(&vp_reg->rts_access_steer_ctrl);
00084 
00085         if (val64 & VXGE_HW_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS)
00086                 status = VXGE_HW_OK;
00087         else
00088                 status = VXGE_HW_FAIL;
00089 
00090         return status;
00091 }

void vxge_hw_vpath_set_zero_rx_frm_len ( struct __vxge_hw_device * hldev )

Definition at line 28 of file vxge_config.c.

References 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().

00029 {
00030         u64 val64;
00031         struct __vxge_hw_virtualpath *vpath;
00032         struct vxge_hw_vpath_reg __iomem *vp_reg;
00033 
00034         vpath = &hldev->virtual_path;
00035         vp_reg = vpath->vp_reg;
00036 
00037         val64 = readq(&vp_reg->rxmac_vcfg0);
00038         val64 &= ~VXGE_HW_RXMAC_VCFG0_RTS_MAX_FRM_LEN(0x3fff);
00039         writeq(val64, &vp_reg->rxmac_vcfg0);
00040         val64 = readq(&vp_reg->rxmac_vcfg0);
00041         return;
00042 }

Variable Documentation

const u16 debug_filter = VXGE_ERR [static]

vxge_debug : mask for the debug : printf like format string

Definition at line 769 of file vxge_config.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 : Function Id : vpath bit mask : Firmware version : Firmware Date : Firmware version : Firmware Date : Mac addresses for each vpath : Mac address masks for each vpath More...
struct	__vxge_hw_device
	struct __vxge_hw_device - Hal device object : Magic Number : BAR0 virtual address. More...
Defines
#define	VXGE_CACHE_LINE_SIZE 4096
#define	WAIT_FACTOR 1
#define	ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
#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	VXGE_NONE 0x00
	debug filtering masks
#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 : Month : Year
#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 10
#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_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.
enum vxge_hw_status	vxge_hw_device_hw_info_get (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
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.
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)
struct vxge_hw_toc_reg __iomem *	__vxge_hw_device_toc_get (void __iomem *bar0)
enum vxge_hw_status	__vxge_hw_device_reg_addr_get (struct __vxge_hw_device *hldev)
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 for the debug : printf like format string

vxge_config.h File Reference

Data Structures

Defines

Enumerations

Functions

Variables

Define Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation