/****************************************************************************** * 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 #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_ALARM_MSIX_ID 2 #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