559 lines
14 KiB
C
559 lines
14 KiB
C
/******************************************************************************
|
|
* This software may be used and distributed according to the terms of
|
|
* the GNU General Public License (GPL), incorporated herein by reference.
|
|
* Drivers based on or derived from this code fall under the GPL and must
|
|
* retain the authorship, copyright and license notice. This file is not
|
|
* a complete program and may only be used when the entire operating
|
|
* system is licensed under the GPL.
|
|
* See the file COPYING in this distribution for more information.
|
|
*
|
|
* vxge-main.h: Driver for Neterion Inc's X3100 Series 10GbE PCIe I/O
|
|
* Virtualized Server Adapter.
|
|
* Copyright(c) 2002-2009 Neterion Inc.
|
|
******************************************************************************/
|
|
#ifndef VXGE_MAIN_H
|
|
#define VXGE_MAIN_H
|
|
|
|
#include "vxge-traffic.h"
|
|
#include "vxge-config.h"
|
|
#include "vxge-version.h"
|
|
#include <linux/list.h>
|
|
|
|
#define VXGE_DRIVER_NAME "vxge"
|
|
#define VXGE_DRIVER_VENDOR "Neterion, Inc"
|
|
#define VXGE_DRIVER_FW_VERSION_MAJOR 1
|
|
|
|
#define DRV_VERSION VXGE_VERSION_MAJOR"."VXGE_VERSION_MINOR"."\
|
|
VXGE_VERSION_FIX"."VXGE_VERSION_BUILD"-"\
|
|
VXGE_VERSION_FOR
|
|
|
|
#define PCI_DEVICE_ID_TITAN_WIN 0x5733
|
|
#define PCI_DEVICE_ID_TITAN_UNI 0x5833
|
|
#define VXGE_USE_DEFAULT 0xffffffff
|
|
#define VXGE_HW_VPATH_MSIX_ACTIVE 4
|
|
#define VXGE_HW_RXSYNC_FREQ_CNT 4
|
|
#define VXGE_LL_WATCH_DOG_TIMEOUT (15 * HZ)
|
|
#define VXGE_LL_RX_COPY_THRESHOLD 256
|
|
#define VXGE_DEF_FIFO_LENGTH 84
|
|
|
|
#define NO_STEERING 0
|
|
#define PORT_STEERING 0x1
|
|
#define RTH_STEERING 0x2
|
|
#define RX_TOS_STEERING 0x3
|
|
#define RX_VLAN_STEERING 0x4
|
|
#define RTH_BUCKET_SIZE 4
|
|
|
|
#define TX_PRIORITY_STEERING 1
|
|
#define TX_VLAN_STEERING 2
|
|
#define TX_PORT_STEERING 3
|
|
#define TX_MULTIQ_STEERING 4
|
|
|
|
#define VXGE_HW_MAC_ADDR_LEARN_DEFAULT VXGE_HW_RTS_MAC_DISABLE
|
|
|
|
#define VXGE_TTI_BTIMER_VAL 250000
|
|
|
|
#define VXGE_TTI_LTIMER_VAL 1000
|
|
#define VXGE_TTI_RTIMER_VAL 0
|
|
#define VXGE_RTI_BTIMER_VAL 250
|
|
#define VXGE_RTI_LTIMER_VAL 100
|
|
#define VXGE_RTI_RTIMER_VAL 0
|
|
#define VXGE_FIFO_INDICATE_MAX_PKTS VXGE_DEF_FIFO_LENGTH
|
|
#define VXGE_ISR_POLLING_CNT 8
|
|
#define VXGE_MAX_CONFIG_DEV 0xFF
|
|
#define VXGE_EXEC_MODE_DISABLE 0
|
|
#define VXGE_EXEC_MODE_ENABLE 1
|
|
#define VXGE_MAX_CONFIG_PORT 1
|
|
#define VXGE_ALL_VID_DISABLE 0
|
|
#define VXGE_ALL_VID_ENABLE 1
|
|
#define VXGE_PAUSE_CTRL_DISABLE 0
|
|
#define VXGE_PAUSE_CTRL_ENABLE 1
|
|
|
|
#define TTI_TX_URANGE_A 5
|
|
#define TTI_TX_URANGE_B 15
|
|
#define TTI_TX_URANGE_C 40
|
|
#define TTI_TX_UFC_A 5
|
|
#define TTI_TX_UFC_B 40
|
|
#define TTI_TX_UFC_C 60
|
|
#define TTI_TX_UFC_D 100
|
|
|
|
#define RTI_RX_URANGE_A 5
|
|
#define RTI_RX_URANGE_B 15
|
|
#define RTI_RX_URANGE_C 40
|
|
#define RTI_RX_UFC_A 1
|
|
#define RTI_RX_UFC_B 5
|
|
#define RTI_RX_UFC_C 10
|
|
#define RTI_RX_UFC_D 15
|
|
|
|
/* Milli secs timer period */
|
|
#define VXGE_TIMER_DELAY 10000
|
|
|
|
#define VXGE_LL_MAX_FRAME_SIZE(dev) ((dev)->mtu + VXGE_HW_MAC_HEADER_MAX_SIZE)
|
|
|
|
enum vxge_reset_event {
|
|
/* reset events */
|
|
VXGE_LL_VPATH_RESET = 0,
|
|
VXGE_LL_DEVICE_RESET = 1,
|
|
VXGE_LL_FULL_RESET = 2,
|
|
VXGE_LL_START_RESET = 3,
|
|
VXGE_LL_COMPL_RESET = 4
|
|
};
|
|
/* These flags represent the devices temporary state */
|
|
enum vxge_device_state_t {
|
|
__VXGE_STATE_RESET_CARD = 0,
|
|
__VXGE_STATE_CARD_UP
|
|
};
|
|
|
|
enum vxge_mac_addr_state {
|
|
/* mac address states */
|
|
VXGE_LL_MAC_ADDR_IN_LIST = 0,
|
|
VXGE_LL_MAC_ADDR_IN_DA_TABLE = 1
|
|
};
|
|
|
|
struct vxge_drv_config {
|
|
int config_dev_cnt;
|
|
int total_dev_cnt;
|
|
int g_no_cpus;
|
|
unsigned int vpath_per_dev;
|
|
};
|
|
|
|
struct macInfo {
|
|
unsigned char macaddr[ETH_ALEN];
|
|
unsigned char macmask[ETH_ALEN];
|
|
unsigned int vpath_no;
|
|
enum vxge_mac_addr_state state;
|
|
};
|
|
|
|
struct vxge_config {
|
|
int tx_pause_enable;
|
|
int rx_pause_enable;
|
|
|
|
#define NEW_NAPI_WEIGHT 64
|
|
int napi_weight;
|
|
#define VXGE_GRO_DONOT_AGGREGATE 0
|
|
#define VXGE_GRO_ALWAYS_AGGREGATE 1
|
|
int gro_enable;
|
|
int intr_type;
|
|
#define INTA 0
|
|
#define MSI 1
|
|
#define MSI_X 2
|
|
|
|
int addr_learn_en;
|
|
|
|
int rth_steering;
|
|
int rth_algorithm;
|
|
int rth_hash_type_tcpipv4;
|
|
int rth_hash_type_ipv4;
|
|
int rth_hash_type_tcpipv6;
|
|
int rth_hash_type_ipv6;
|
|
int rth_hash_type_tcpipv6ex;
|
|
int rth_hash_type_ipv6ex;
|
|
int rth_bkt_sz;
|
|
int rth_jhash_golden_ratio;
|
|
int tx_steering_type;
|
|
int fifo_indicate_max_pkts;
|
|
struct vxge_hw_device_hw_info device_hw_info;
|
|
};
|
|
|
|
struct vxge_msix_entry {
|
|
/* Mimicing the msix_entry struct of Kernel. */
|
|
u16 vector;
|
|
u16 entry;
|
|
u16 in_use;
|
|
void *arg;
|
|
};
|
|
|
|
/* Software Statistics */
|
|
|
|
struct vxge_sw_stats {
|
|
/* Network Stats (interface stats) */
|
|
struct net_device_stats net_stats;
|
|
|
|
/* Tx */
|
|
u64 tx_frms;
|
|
u64 tx_errors;
|
|
u64 tx_bytes;
|
|
u64 txd_not_free;
|
|
u64 txd_out_of_desc;
|
|
|
|
/* Virtual Path */
|
|
u64 vpaths_open;
|
|
u64 vpath_open_fail;
|
|
|
|
/* Rx */
|
|
u64 rx_frms;
|
|
u64 rx_errors;
|
|
u64 rx_bytes;
|
|
u64 rx_mcast;
|
|
|
|
/* Misc. */
|
|
u64 link_up;
|
|
u64 link_down;
|
|
u64 pci_map_fail;
|
|
u64 skb_alloc_fail;
|
|
};
|
|
|
|
struct vxge_mac_addrs {
|
|
struct list_head item;
|
|
u64 macaddr;
|
|
u64 macmask;
|
|
enum vxge_mac_addr_state state;
|
|
};
|
|
|
|
struct vxgedev;
|
|
|
|
struct vxge_fifo_stats {
|
|
u64 tx_frms;
|
|
u64 tx_errors;
|
|
u64 tx_bytes;
|
|
u64 txd_not_free;
|
|
u64 txd_out_of_desc;
|
|
u64 pci_map_fail;
|
|
};
|
|
|
|
struct vxge_fifo {
|
|
struct net_device *ndev;
|
|
struct pci_dev *pdev;
|
|
struct __vxge_hw_fifo *handle;
|
|
|
|
/* The vpath id maintained in the driver -
|
|
* 0 to 'maximum_vpaths_in_function - 1'
|
|
*/
|
|
int driver_id;
|
|
int tx_steering_type;
|
|
int indicate_max_pkts;
|
|
spinlock_t tx_lock;
|
|
/* flag used to maintain queue state when MULTIQ is not enabled */
|
|
#define VPATH_QUEUE_START 0
|
|
#define VPATH_QUEUE_STOP 1
|
|
int queue_state;
|
|
|
|
/* Tx stats */
|
|
struct vxge_fifo_stats stats;
|
|
} ____cacheline_aligned;
|
|
|
|
struct vxge_ring_stats {
|
|
u64 prev_rx_frms;
|
|
u64 rx_frms;
|
|
u64 rx_errors;
|
|
u64 rx_dropped;
|
|
u64 rx_bytes;
|
|
u64 rx_mcast;
|
|
u64 pci_map_fail;
|
|
u64 skb_alloc_fail;
|
|
};
|
|
|
|
struct vxge_ring {
|
|
struct net_device *ndev;
|
|
struct pci_dev *pdev;
|
|
struct __vxge_hw_ring *handle;
|
|
/* The vpath id maintained in the driver -
|
|
* 0 to 'maximum_vpaths_in_function - 1'
|
|
*/
|
|
int driver_id;
|
|
|
|
/* copy of the flag indicating whether rx_csum is to be used */
|
|
u32 rx_csum;
|
|
|
|
int pkts_processed;
|
|
int budget;
|
|
int gro_enable;
|
|
|
|
struct napi_struct napi;
|
|
struct napi_struct *napi_p;
|
|
|
|
#define VXGE_MAX_MAC_ADDR_COUNT 30
|
|
|
|
int vlan_tag_strip;
|
|
struct vlan_group *vlgrp;
|
|
int rx_vector_no;
|
|
enum vxge_hw_status last_status;
|
|
|
|
/* Rx stats */
|
|
struct vxge_ring_stats stats;
|
|
} ____cacheline_aligned;
|
|
|
|
struct vxge_vpath {
|
|
|
|
struct vxge_fifo fifo;
|
|
struct vxge_ring ring;
|
|
|
|
struct __vxge_hw_vpath_handle *handle;
|
|
|
|
/* Actual vpath id for this vpath in the device - 0 to 16 */
|
|
int device_id;
|
|
int max_mac_addr_cnt;
|
|
int is_configured;
|
|
int is_open;
|
|
struct vxgedev *vdev;
|
|
u8 (macaddr)[ETH_ALEN];
|
|
u8 (macmask)[ETH_ALEN];
|
|
|
|
#define VXGE_MAX_LEARN_MAC_ADDR_CNT 2048
|
|
/* mac addresses currently programmed into NIC */
|
|
u16 mac_addr_cnt;
|
|
u16 mcast_addr_cnt;
|
|
struct list_head mac_addr_list;
|
|
|
|
u32 level_err;
|
|
u32 level_trace;
|
|
};
|
|
#define VXGE_COPY_DEBUG_INFO_TO_LL(vdev, err, trace) { \
|
|
for (i = 0; i < vdev->no_of_vpath; i++) { \
|
|
vdev->vpaths[i].level_err = err; \
|
|
vdev->vpaths[i].level_trace = trace; \
|
|
} \
|
|
vdev->level_err = err; \
|
|
vdev->level_trace = trace; \
|
|
}
|
|
|
|
struct vxgedev {
|
|
struct net_device *ndev;
|
|
struct pci_dev *pdev;
|
|
struct __vxge_hw_device *devh;
|
|
struct vlan_group *vlgrp;
|
|
int vlan_tag_strip;
|
|
struct vxge_config config;
|
|
unsigned long state;
|
|
|
|
/* Indicates which vpath to reset */
|
|
unsigned long vp_reset;
|
|
|
|
/* Timer used for polling vpath resets */
|
|
struct timer_list vp_reset_timer;
|
|
|
|
/* Timer used for polling vpath lockup */
|
|
struct timer_list vp_lockup_timer;
|
|
|
|
/*
|
|
* Flags to track whether device is in All Multicast
|
|
* or in promiscuous mode.
|
|
*/
|
|
u16 all_multi_flg;
|
|
|
|
/* A flag indicating whether rx_csum is to be used or not. */
|
|
u32 rx_csum;
|
|
|
|
struct vxge_msix_entry *vxge_entries;
|
|
struct msix_entry *entries;
|
|
/*
|
|
* 4 for each vpath * 17;
|
|
* total is 68
|
|
*/
|
|
#define VXGE_MAX_REQUESTED_MSIX 68
|
|
#define VXGE_INTR_STRLEN 80
|
|
char desc[VXGE_MAX_REQUESTED_MSIX][VXGE_INTR_STRLEN];
|
|
|
|
enum vxge_hw_event cric_err_event;
|
|
|
|
int max_vpath_supported;
|
|
int no_of_vpath;
|
|
|
|
struct napi_struct napi;
|
|
/* A debug option, when enabled and if error condition occurs,
|
|
* the driver will do following steps:
|
|
* - mask all interrupts
|
|
* - Not clear the source of the alarm
|
|
* - gracefully stop all I/O
|
|
* A diagnostic dump of register and stats at this point
|
|
* reveals very useful information.
|
|
*/
|
|
int exec_mode;
|
|
int max_config_port;
|
|
struct vxge_vpath *vpaths;
|
|
|
|
struct __vxge_hw_vpath_handle *vp_handles[VXGE_HW_MAX_VIRTUAL_PATHS];
|
|
void __iomem *bar0;
|
|
struct vxge_sw_stats stats;
|
|
int mtu;
|
|
/* Below variables are used for vpath selection to transmit a packet */
|
|
u8 vpath_selector[VXGE_HW_MAX_VIRTUAL_PATHS];
|
|
u64 vpaths_deployed;
|
|
|
|
u32 intr_cnt;
|
|
u32 level_err;
|
|
u32 level_trace;
|
|
char fw_version[VXGE_HW_FW_STRLEN];
|
|
};
|
|
|
|
struct vxge_rx_priv {
|
|
struct sk_buff *skb;
|
|
unsigned char *skb_data;
|
|
dma_addr_t data_dma;
|
|
dma_addr_t data_size;
|
|
};
|
|
|
|
struct vxge_tx_priv {
|
|
struct sk_buff *skb;
|
|
dma_addr_t dma_buffers[MAX_SKB_FRAGS+1];
|
|
};
|
|
|
|
#define VXGE_MODULE_PARAM_INT(p, val) \
|
|
static int p = val; \
|
|
module_param(p, int, 0)
|
|
|
|
#define vxge_os_bug(fmt...) { printk(fmt); BUG(); }
|
|
|
|
#define vxge_os_timer(timer, handle, arg, exp) do { \
|
|
init_timer(&timer); \
|
|
timer.function = handle; \
|
|
timer.data = (unsigned long) arg; \
|
|
mod_timer(&timer, (jiffies + exp)); \
|
|
} while (0);
|
|
|
|
int __devinit vxge_device_register(struct __vxge_hw_device *devh,
|
|
struct vxge_config *config,
|
|
int high_dma, int no_of_vpath,
|
|
struct vxgedev **vdev);
|
|
|
|
void vxge_device_unregister(struct __vxge_hw_device *devh);
|
|
|
|
void vxge_vpath_intr_enable(struct vxgedev *vdev, int vp_id);
|
|
|
|
void vxge_vpath_intr_disable(struct vxgedev *vdev, int vp_id);
|
|
|
|
void vxge_callback_link_up(struct __vxge_hw_device *devh);
|
|
|
|
void vxge_callback_link_down(struct __vxge_hw_device *devh);
|
|
|
|
enum vxge_hw_status vxge_add_mac_addr(struct vxgedev *vdev,
|
|
struct macInfo *mac);
|
|
|
|
int vxge_mac_list_del(struct vxge_vpath *vpath, struct macInfo *mac);
|
|
|
|
int vxge_reset(struct vxgedev *vdev);
|
|
|
|
enum vxge_hw_status
|
|
vxge_rx_1b_compl(struct __vxge_hw_ring *ringh, void *dtr,
|
|
u8 t_code, void *userdata);
|
|
|
|
enum vxge_hw_status
|
|
vxge_xmit_compl(struct __vxge_hw_fifo *fifo_hw, void *dtr,
|
|
enum vxge_hw_fifo_tcode t_code, void *userdata,
|
|
struct sk_buff ***skb_ptr, int nr_skbs, int *more);
|
|
|
|
int vxge_close(struct net_device *dev);
|
|
|
|
int vxge_open(struct net_device *dev);
|
|
|
|
void vxge_close_vpaths(struct vxgedev *vdev, int index);
|
|
|
|
int vxge_open_vpaths(struct vxgedev *vdev);
|
|
|
|
enum vxge_hw_status vxge_reset_all_vpaths(struct vxgedev *vdev);
|
|
|
|
void vxge_stop_all_tx_queue(struct vxgedev *vdev);
|
|
|
|
void vxge_stop_tx_queue(struct vxge_fifo *fifo);
|
|
|
|
void vxge_start_all_tx_queue(struct vxgedev *vdev);
|
|
|
|
void vxge_wake_tx_queue(struct vxge_fifo *fifo, struct sk_buff *skb);
|
|
|
|
enum vxge_hw_status vxge_add_mac_addr(struct vxgedev *vdev,
|
|
struct macInfo *mac);
|
|
|
|
enum vxge_hw_status vxge_del_mac_addr(struct vxgedev *vdev,
|
|
struct macInfo *mac);
|
|
|
|
int vxge_mac_list_add(struct vxge_vpath *vpath,
|
|
struct macInfo *mac);
|
|
|
|
void vxge_free_mac_add_list(struct vxge_vpath *vpath);
|
|
|
|
enum vxge_hw_status vxge_restore_vpath_mac_addr(struct vxge_vpath *vpath);
|
|
|
|
enum vxge_hw_status vxge_restore_vpath_vid_table(struct vxge_vpath *vpath);
|
|
|
|
int do_vxge_close(struct net_device *dev, int do_io);
|
|
extern void initialize_ethtool_ops(struct net_device *ndev);
|
|
/**
|
|
* #define VXGE_DEBUG_INIT: debug for initialization functions
|
|
* #define VXGE_DEBUG_TX : debug transmit related functions
|
|
* #define VXGE_DEBUG_RX : debug recevice related functions
|
|
* #define VXGE_DEBUG_MEM : debug memory module
|
|
* #define VXGE_DEBUG_LOCK: debug locks
|
|
* #define VXGE_DEBUG_SEM : debug semaphore
|
|
* #define VXGE_DEBUG_ENTRYEXIT: debug functions by adding entry exit statements
|
|
*/
|
|
#define VXGE_DEBUG_INIT 0x00000001
|
|
#define VXGE_DEBUG_TX 0x00000002
|
|
#define VXGE_DEBUG_RX 0x00000004
|
|
#define VXGE_DEBUG_MEM 0x00000008
|
|
#define VXGE_DEBUG_LOCK 0x00000010
|
|
#define VXGE_DEBUG_SEM 0x00000020
|
|
#define VXGE_DEBUG_ENTRYEXIT 0x00000040
|
|
#define VXGE_DEBUG_INTR 0x00000080
|
|
#define VXGE_DEBUG_LL_CONFIG 0x00000100
|
|
|
|
/* Debug tracing for VXGE driver */
|
|
#ifndef VXGE_DEBUG_MASK
|
|
#define VXGE_DEBUG_MASK 0x0
|
|
#endif
|
|
|
|
#if (VXGE_DEBUG_LL_CONFIG & VXGE_DEBUG_MASK)
|
|
#define vxge_debug_ll_config(level, fmt, ...) \
|
|
vxge_debug_ll(level, VXGE_DEBUG_LL_CONFIG, fmt, __VA_ARGS__)
|
|
#else
|
|
#define vxge_debug_ll_config(level, fmt, ...)
|
|
#endif
|
|
|
|
#if (VXGE_DEBUG_INIT & VXGE_DEBUG_MASK)
|
|
#define vxge_debug_init(level, fmt, ...) \
|
|
vxge_debug_ll(level, VXGE_DEBUG_INIT, fmt, __VA_ARGS__)
|
|
#else
|
|
#define vxge_debug_init(level, fmt, ...)
|
|
#endif
|
|
|
|
#if (VXGE_DEBUG_TX & VXGE_DEBUG_MASK)
|
|
#define vxge_debug_tx(level, fmt, ...) \
|
|
vxge_debug_ll(level, VXGE_DEBUG_TX, fmt, __VA_ARGS__)
|
|
#else
|
|
#define vxge_debug_tx(level, fmt, ...)
|
|
#endif
|
|
|
|
#if (VXGE_DEBUG_RX & VXGE_DEBUG_MASK)
|
|
#define vxge_debug_rx(level, fmt, ...) \
|
|
vxge_debug_ll(level, VXGE_DEBUG_RX, fmt, __VA_ARGS__)
|
|
#else
|
|
#define vxge_debug_rx(level, fmt, ...)
|
|
#endif
|
|
|
|
#if (VXGE_DEBUG_MEM & VXGE_DEBUG_MASK)
|
|
#define vxge_debug_mem(level, fmt, ...) \
|
|
vxge_debug_ll(level, VXGE_DEBUG_MEM, fmt, __VA_ARGS__)
|
|
#else
|
|
#define vxge_debug_mem(level, fmt, ...)
|
|
#endif
|
|
|
|
#if (VXGE_DEBUG_ENTRYEXIT & VXGE_DEBUG_MASK)
|
|
#define vxge_debug_entryexit(level, fmt, ...) \
|
|
vxge_debug_ll(level, VXGE_DEBUG_ENTRYEXIT, fmt, __VA_ARGS__)
|
|
#else
|
|
#define vxge_debug_entryexit(level, fmt, ...)
|
|
#endif
|
|
|
|
#if (VXGE_DEBUG_INTR & VXGE_DEBUG_MASK)
|
|
#define vxge_debug_intr(level, fmt, ...) \
|
|
vxge_debug_ll(level, VXGE_DEBUG_INTR, fmt, __VA_ARGS__)
|
|
#else
|
|
#define vxge_debug_intr(level, fmt, ...)
|
|
#endif
|
|
|
|
#define VXGE_DEVICE_DEBUG_LEVEL_SET(level, mask, vdev) {\
|
|
vxge_hw_device_debug_set((struct __vxge_hw_device *)vdev->devh, \
|
|
level, mask);\
|
|
VXGE_COPY_DEBUG_INFO_TO_LL(vdev, \
|
|
vxge_hw_device_error_level_get((struct __vxge_hw_device *) \
|
|
vdev->devh), \
|
|
vxge_hw_device_trace_level_get((struct __vxge_hw_device *) \
|
|
vdev->devh));\
|
|
}
|
|
|
|
#ifdef NETIF_F_GSO
|
|
#define vxge_tcp_mss(skb) (skb_shinfo(skb)->gso_size)
|
|
#define vxge_udp_mss(skb) (skb_shinfo(skb)->gso_size)
|
|
#define vxge_offload_type(skb) (skb_shinfo(skb)->gso_type)
|
|
#endif
|
|
|
|
#endif
|