drivers/net/vxge/vxge-main.h

   1 /******************************************************************************
   2  * This software may be used and distributed according to the terms of
   3  * the GNU General Public License (GPL), incorporated herein by reference.
   4  * Drivers based on or derived from this code fall under the GPL and must
   5  * retain the authorship, copyright and license notice.  This file is not
   6  * a complete program and may only be used when the entire operating
   7  * system is licensed under the GPL.
   8  * See the file COPYING in this distribution for more information.
   9  *
  10  * vxge-main.h: Driver for Exar Corp's X3100 Series 10GbE PCIe I/O
  11  *              Virtualized Server Adapter.
  12  * Copyright(c) 2002-2010 Exar Corp.
  13  ******************************************************************************/
  14 #ifndef VXGE_MAIN_H
  15 #define VXGE_MAIN_H
  16
  17 #include "vxge-traffic.h"
  18 #include "vxge-config.h"
  19 #include "vxge-version.h"
  20 #include <linux/list.h>
  21
  22 #define VXGE_DRIVER_NAME                "vxge"
  23 #define VXGE_DRIVER_VENDOR              "Neterion, Inc"
  24 #define VXGE_DRIVER_FW_VERSION_MAJOR    1
  25
  26 #define DRV_VERSION     VXGE_VERSION_MAJOR"."VXGE_VERSION_MINOR"."\
  27         VXGE_VERSION_FIX"."VXGE_VERSION_BUILD"-"\
  28         VXGE_VERSION_FOR
  29
  30 #define PCI_DEVICE_ID_TITAN_WIN         0x5733
  31 #define PCI_DEVICE_ID_TITAN_UNI         0x5833
  32 #define VXGE_HW_TITAN1_PCI_REVISION     1
  33 #define VXGE_HW_TITAN1A_PCI_REVISION    2
  34
  35 #define VXGE_USE_DEFAULT                0xffffffff
  36 #define VXGE_HW_VPATH_MSIX_ACTIVE       4
  37 #define VXGE_ALARM_MSIX_ID              2
  38 #define VXGE_HW_RXSYNC_FREQ_CNT         4
  39 #define VXGE_LL_WATCH_DOG_TIMEOUT       (15 * HZ)
  40 #define VXGE_LL_RX_COPY_THRESHOLD       256
  41 #define VXGE_DEF_FIFO_LENGTH            84
  42
  43 #define NO_STEERING             0
  44 #define PORT_STEERING           0x1
  45 #define RTH_STEERING            0x2
  46 #define RX_TOS_STEERING         0x3
  47 #define RX_VLAN_STEERING        0x4
  48 #define RTH_BUCKET_SIZE         4
  49
  50 #define TX_PRIORITY_STEERING    1
  51 #define TX_VLAN_STEERING        2
  52 #define TX_PORT_STEERING        3
  53 #define TX_MULTIQ_STEERING      4
  54
  55 #define VXGE_HW_MAC_ADDR_LEARN_DEFAULT VXGE_HW_RTS_MAC_DISABLE
  56
  57 #define VXGE_TTI_BTIMER_VAL 250000
  58
  59 #define VXGE_TTI_LTIMER_VAL     1000
  60 #define VXGE_T1A_TTI_LTIMER_VAL 80
  61 #define VXGE_TTI_RTIMER_VAL     0
  62 #define VXGE_TTI_RTIMER_ADAPT_VAL       10
  63 #define VXGE_T1A_TTI_RTIMER_VAL 400
  64 #define VXGE_RTI_BTIMER_VAL     250
  65 #define VXGE_RTI_LTIMER_VAL     100
  66 #define VXGE_RTI_RTIMER_VAL     0
  67 #define VXGE_RTI_RTIMER_ADAPT_VAL       15
  68 #define VXGE_FIFO_INDICATE_MAX_PKTS     VXGE_DEF_FIFO_LENGTH
  69 #define VXGE_ISR_POLLING_CNT    8
  70 #define VXGE_MAX_CONFIG_DEV     0xFF
  71 #define VXGE_EXEC_MODE_DISABLE  0
  72 #define VXGE_EXEC_MODE_ENABLE   1
  73 #define VXGE_MAX_CONFIG_PORT    1
  74 #define VXGE_ALL_VID_DISABLE    0
  75 #define VXGE_ALL_VID_ENABLE     1
  76 #define VXGE_PAUSE_CTRL_DISABLE 0
  77 #define VXGE_PAUSE_CTRL_ENABLE  1
  78
  79 #define TTI_TX_URANGE_A 5
  80 #define TTI_TX_URANGE_B 15
  81 #define TTI_TX_URANGE_C 40
  82 #define TTI_TX_UFC_A    5
  83 #define TTI_TX_UFC_B    40
  84 #define TTI_TX_UFC_C    60
  85 #define TTI_TX_UFC_D    100
  86 #define TTI_T1A_TX_UFC_A        30
  87 #define TTI_T1A_TX_UFC_B        80
  88 /* Slope - (max_mtu - min_mtu)/(max_mtu_ufc - min_mtu_ufc) */
  89 /* Slope - 93 */
  90 /* 60 - 9k Mtu, 140 - 1.5k mtu */
  91 #define TTI_T1A_TX_UFC_C(mtu)   (60 + ((VXGE_HW_MAX_MTU - mtu) / 93))
  92
  93 /* Slope - 37 */
  94 /* 100 - 9k Mtu, 300 - 1.5k mtu */
  95 #define TTI_T1A_TX_UFC_D(mtu)   (100 + ((VXGE_HW_MAX_MTU - mtu) / 37))
  96
  97
  98 #define RTI_RX_URANGE_A         5
  99 #define RTI_RX_URANGE_B         15
 100 #define RTI_RX_URANGE_C         40
 101 #define RTI_T1A_RX_URANGE_A     1
 102 #define RTI_T1A_RX_URANGE_B     20
 103 #define RTI_T1A_RX_URANGE_C     50
 104 #define RTI_RX_UFC_A            1
 105 #define RTI_RX_UFC_B            5
 106 #define RTI_RX_UFC_C            10
 107 #define RTI_RX_UFC_D            15
 108 #define RTI_T1A_RX_UFC_B        20
 109 #define RTI_T1A_RX_UFC_C        50
 110 #define RTI_T1A_RX_UFC_D        60
 111
 112 /*
 113  * The interrupt rate is maintained at 3k per second with the moderation
 114  * parameters for most traffic but not all. This is the maximum interrupt
 115  * count allowed per function with INTA or per vector in the case of
 116  * MSI-X in a 10 millisecond time period. Enabled only for Titan 1A.
 117  */
 118 #define VXGE_T1A_MAX_INTERRUPT_COUNT    100
 119 #define VXGE_T1A_MAX_TX_INTERRUPT_COUNT 200
 120
 121 /* Milli secs timer period */
 122 #define VXGE_TIMER_DELAY                10000
 123
 124 #define VXGE_LL_MAX_FRAME_SIZE(dev) ((dev)->mtu + VXGE_HW_MAC_HEADER_MAX_SIZE)
 125
 126 #define is_sriov(function_mode) \
 127         ((function_mode == VXGE_HW_FUNCTION_MODE_SRIOV) || \
 128         (function_mode == VXGE_HW_FUNCTION_MODE_SRIOV_8) || \
 129         (function_mode == VXGE_HW_FUNCTION_MODE_SRIOV_4))
 130
 131 enum vxge_reset_event {
 132         /* reset events */
 133         VXGE_LL_VPATH_RESET     = 0,
 134         VXGE_LL_DEVICE_RESET    = 1,
 135         VXGE_LL_FULL_RESET      = 2,
 136         VXGE_LL_START_RESET     = 3,
 137         VXGE_LL_COMPL_RESET     = 4
 138 };
 139 /* These flags represent the devices temporary state */
 140 enum vxge_device_state_t {
 141 __VXGE_STATE_RESET_CARD = 0,
 142 __VXGE_STATE_CARD_UP
 143 };
 144
 145 enum vxge_mac_addr_state {
 146         /* mac address states */
 147         VXGE_LL_MAC_ADDR_IN_LIST        = 0,
 148         VXGE_LL_MAC_ADDR_IN_DA_TABLE    = 1
 149 };
 150
 151 struct vxge_drv_config {
 152         int config_dev_cnt;
 153         int total_dev_cnt;
 154         int g_no_cpus;
 155         unsigned int vpath_per_dev;
 156 };
 157
 158 struct macInfo {
 159         unsigned char macaddr[ETH_ALEN];
 160         unsigned char macmask[ETH_ALEN];
 161         unsigned int vpath_no;
 162         enum vxge_mac_addr_state state;
 163 };
 164
 165 struct vxge_config {
 166         int             tx_pause_enable;
 167         int             rx_pause_enable;
 168
 169 #define NEW_NAPI_WEIGHT 64
 170         int             napi_weight;
 171 #define VXGE_GRO_DONOT_AGGREGATE                0
 172 #define VXGE_GRO_ALWAYS_AGGREGATE               1
 173         int             gro_enable;
 174         int             intr_type;
 175 #define INTA    0
 176 #define MSI     1
 177 #define MSI_X   2
 178
 179         int             addr_learn_en;
 180
 181         u32             rth_steering:2,
 182                         rth_algorithm:2,
 183                         rth_hash_type_tcpipv4:1,
 184                         rth_hash_type_ipv4:1,
 185                         rth_hash_type_tcpipv6:1,
 186                         rth_hash_type_ipv6:1,
 187                         rth_hash_type_tcpipv6ex:1,
 188                         rth_hash_type_ipv6ex:1,
 189                         rth_bkt_sz:8;
 190         int             rth_jhash_golden_ratio;
 191         int             tx_steering_type;
 192         int     fifo_indicate_max_pkts;
 193         struct vxge_hw_device_hw_info device_hw_info;
 194 };
 195
 196 struct vxge_msix_entry {
 197         /* Mimicing the msix_entry struct of Kernel. */
 198         u16 vector;
 199         u16 entry;
 200         u16 in_use;
 201         void *arg;
 202 };
 203
 204 /* Software Statistics */
 205
 206 struct vxge_sw_stats {
 207         /* Network Stats (interface stats) */
 208
 209         /* Tx */
 210         u64 tx_frms;
 211         u64 tx_errors;
 212         u64 tx_bytes;
 213         u64 txd_not_free;
 214         u64 txd_out_of_desc;
 215
 216         /* Virtual Path */
 217         u64 vpaths_open;
 218         u64 vpath_open_fail;
 219
 220         /* Rx */
 221         u64 rx_frms;
 222         u64 rx_errors;
 223         u64 rx_bytes;
 224         u64 rx_mcast;
 225
 226         /* Misc. */
 227         u64 link_up;
 228         u64 link_down;
 229         u64 pci_map_fail;
 230         u64 skb_alloc_fail;
 231 };
 232
 233 struct vxge_mac_addrs {
 234         struct list_head item;
 235         u64 macaddr;
 236         u64 macmask;
 237         enum vxge_mac_addr_state state;
 238 };
 239
 240 struct vxgedev;
 241
 242 struct vxge_fifo_stats {
 243         u64 tx_frms;
 244         u64 tx_errors;
 245         u64 tx_bytes;
 246         u64 txd_not_free;
 247         u64 txd_out_of_desc;
 248         u64 pci_map_fail;
 249 };
 250
 251 struct vxge_fifo {
 252         struct net_device *ndev;
 253         struct pci_dev *pdev;
 254         struct __vxge_hw_fifo *handle;
 255         struct netdev_queue *txq;
 256
 257         int tx_steering_type;
 258         int indicate_max_pkts;
 259
 260         /* Adaptive interrupt moderation parameters used in T1A */
 261         unsigned long interrupt_count;
 262         unsigned long jiffies;
 263
 264         u32 tx_vector_no;
 265         /* Tx stats */
 266         struct vxge_fifo_stats stats;
 267 } ____cacheline_aligned;
 268
 269 struct vxge_ring_stats {
 270         u64 prev_rx_frms;
 271         u64 rx_frms;
 272         u64 rx_errors;
 273         u64 rx_dropped;
 274         u64 rx_bytes;
 275         u64 rx_mcast;
 276         u64 pci_map_fail;
 277         u64 skb_alloc_fail;
 278 };
 279
 280 struct vxge_ring {
 281         struct net_device       *ndev;
 282         struct pci_dev          *pdev;
 283         struct __vxge_hw_ring   *handle;
 284         /* The vpath id maintained in the driver -
 285          * 0 to 'maximum_vpaths_in_function - 1'
 286          */
 287         int driver_id;
 288
 289         /* Adaptive interrupt moderation parameters used in T1A */
 290         unsigned long interrupt_count;
 291         unsigned long jiffies;
 292
 293         /* copy of the flag indicating whether rx_csum is to be used */
 294         u32 rx_csum:1,
 295             rx_hwts:1;
 296
 297         int pkts_processed;
 298         int budget;
 299         int gro_enable;
 300
 301         struct napi_struct napi;
 302         struct napi_struct *napi_p;
 303
 304 #define VXGE_MAX_MAC_ADDR_COUNT         30
 305
 306         int vlan_tag_strip;
 307         struct vlan_group *vlgrp;
 308         u32 rx_vector_no;
 309         enum vxge_hw_status last_status;
 310
 311         /* Rx stats */
 312         struct vxge_ring_stats stats;
 313 } ____cacheline_aligned;
 314
 315 struct vxge_vpath {
 316         struct vxge_fifo fifo;
 317         struct vxge_ring ring;
 318
 319         struct __vxge_hw_vpath_handle *handle;
 320
 321         /* Actual vpath id for this vpath in the device - 0 to 16 */
 322         int device_id;
 323         int max_mac_addr_cnt;
 324         int is_configured;
 325         int is_open;
 326         struct vxgedev *vdev;
 327         u8 macaddr[ETH_ALEN];
 328         u8 macmask[ETH_ALEN];
 329
 330 #define VXGE_MAX_LEARN_MAC_ADDR_CNT     2048
 331         /* mac addresses currently programmed into NIC */
 332         u16 mac_addr_cnt;
 333         u16 mcast_addr_cnt;
 334         struct list_head mac_addr_list;
 335
 336         u32 level_err;
 337         u32 level_trace;
 338 };
 339 #define VXGE_COPY_DEBUG_INFO_TO_LL(vdev, err, trace) {  \
 340         for (i = 0; i < vdev->no_of_vpath; i++) {               \
 341                 vdev->vpaths[i].level_err = err;                \
 342                 vdev->vpaths[i].level_trace = trace;            \
 343         }                                                       \
 344         vdev->level_err = err;                                  \
 345         vdev->level_trace = trace;                              \
 346 }
 347
 348 struct vxgedev {
 349         struct net_device       *ndev;
 350         struct pci_dev          *pdev;
 351         struct __vxge_hw_device *devh;
 352         struct vlan_group       *vlgrp;
 353         int vlan_tag_strip;
 354         struct vxge_config      config;
 355         unsigned long   state;
 356
 357         /* Indicates which vpath to reset */
 358         unsigned long  vp_reset;
 359
 360         /* Timer used for polling vpath resets */
 361         struct timer_list vp_reset_timer;
 362
 363         /* Timer used for polling vpath lockup */
 364         struct timer_list vp_lockup_timer;
 365
 366         /*
 367          * Flags to track whether device is in All Multicast
 368          * or in promiscuous mode.
 369          */
 370         u16             all_multi_flg;
 371
 372          /* A flag indicating whether rx_csum is to be used or not. */
 373         u32     rx_csum:1,
 374                 rx_hwts:1,
 375                 titan1:1;
 376
 377         struct vxge_msix_entry *vxge_entries;
 378         struct msix_entry *entries;
 379         /*
 380          * 4 for each vpath * 17;
 381          * total is 68
 382          */
 383 #define VXGE_MAX_REQUESTED_MSIX 68
 384 #define VXGE_INTR_STRLEN 80
 385         char desc[VXGE_MAX_REQUESTED_MSIX][VXGE_INTR_STRLEN];
 386
 387         enum vxge_hw_event cric_err_event;
 388
 389         int max_vpath_supported;
 390         int no_of_vpath;
 391
 392         struct napi_struct napi;
 393         /* A debug option, when enabled and if error condition occurs,
 394          * the driver will do following steps:
 395          * - mask all interrupts
 396          * - Not clear the source of the alarm
 397          * - gracefully stop all I/O
 398          * A diagnostic dump of register and stats at this point
 399          * reveals very useful information.
 400          */
 401         int exec_mode;
 402         int max_config_port;
 403         struct vxge_vpath       *vpaths;
 404
 405         struct __vxge_hw_vpath_handle *vp_handles[VXGE_HW_MAX_VIRTUAL_PATHS];
 406         void __iomem *bar0;
 407         struct vxge_sw_stats    stats;
 408         int             mtu;
 409         /* Below variables are used for vpath selection to transmit a packet */
 410         u8              vpath_selector[VXGE_HW_MAX_VIRTUAL_PATHS];
 411         u64             vpaths_deployed;
 412
 413         u32             intr_cnt;
 414         u32             level_err;
 415         u32             level_trace;
 416         char            fw_version[VXGE_HW_FW_STRLEN];
 417         struct work_struct reset_task;
 418 };
 419
 420 struct vxge_rx_priv {
 421         struct sk_buff          *skb;
 422         unsigned char           *skb_data;
 423         dma_addr_t              data_dma;
 424         dma_addr_t              data_size;
 425 };
 426
 427 struct vxge_tx_priv {
 428         struct sk_buff          *skb;
 429         dma_addr_t              dma_buffers[MAX_SKB_FRAGS+1];
 430 };
 431
 432 #define VXGE_MODULE_PARAM_INT(p, val) \
 433         static int p = val; \
 434         module_param(p, int, 0)
 435
 436 #define vxge_os_timer(timer, handle, arg, exp) do { \
 437                 init_timer(&timer); \
 438                 timer.function = handle; \
 439                 timer.data = (unsigned long) arg; \
 440                 mod_timer(&timer, (jiffies + exp)); \
 441         } while (0);
 442
 443 void vxge_initialize_ethtool_ops(struct net_device *ndev);
 444 enum vxge_hw_status vxge_reset_all_vpaths(struct vxgedev *vdev);
 445 int vxge_fw_upgrade(struct vxgedev *vdev, char *fw_name, int override);
 446
 447 /**
 448  * #define VXGE_DEBUG_INIT: debug for initialization functions
 449  * #define VXGE_DEBUG_TX         : debug transmit related functions
 450  * #define VXGE_DEBUG_RX  : debug recevice related functions
 451  * #define VXGE_DEBUG_MEM : debug memory module
 452  * #define VXGE_DEBUG_LOCK: debug locks
 453  * #define VXGE_DEBUG_SEM : debug semaphore
 454  * #define VXGE_DEBUG_ENTRYEXIT: debug functions by adding entry exit statements
 455 */
 456 #define VXGE_DEBUG_INIT         0x00000001
 457 #define VXGE_DEBUG_TX           0x00000002
 458 #define VXGE_DEBUG_RX           0x00000004
 459 #define VXGE_DEBUG_MEM          0x00000008
 460 #define VXGE_DEBUG_LOCK         0x00000010
 461 #define VXGE_DEBUG_SEM          0x00000020
 462 #define VXGE_DEBUG_ENTRYEXIT    0x00000040
 463 #define VXGE_DEBUG_INTR         0x00000080
 464 #define VXGE_DEBUG_LL_CONFIG    0x00000100
 465
 466 /* Debug tracing for VXGE driver */
 467 #ifndef VXGE_DEBUG_MASK
 468 #define VXGE_DEBUG_MASK 0x0
 469 #endif
 470
 471 #if (VXGE_DEBUG_LL_CONFIG & VXGE_DEBUG_MASK)
 472 #define vxge_debug_ll_config(level, fmt, ...) \
 473         vxge_debug_ll(level, VXGE_DEBUG_LL_CONFIG, fmt, __VA_ARGS__)
 474 #else
 475 #define vxge_debug_ll_config(level, fmt, ...)
 476 #endif
 477
 478 #if (VXGE_DEBUG_INIT & VXGE_DEBUG_MASK)
 479 #define vxge_debug_init(level, fmt, ...) \
 480         vxge_debug_ll(level, VXGE_DEBUG_INIT, fmt, __VA_ARGS__)
 481 #else
 482 #define vxge_debug_init(level, fmt, ...)
 483 #endif
 484
 485 #if (VXGE_DEBUG_TX & VXGE_DEBUG_MASK)
 486 #define vxge_debug_tx(level, fmt, ...) \
 487         vxge_debug_ll(level, VXGE_DEBUG_TX, fmt, __VA_ARGS__)
 488 #else
 489 #define vxge_debug_tx(level, fmt, ...)
 490 #endif
 491
 492 #if (VXGE_DEBUG_RX & VXGE_DEBUG_MASK)
 493 #define vxge_debug_rx(level, fmt, ...) \
 494         vxge_debug_ll(level, VXGE_DEBUG_RX, fmt, __VA_ARGS__)
 495 #else
 496 #define vxge_debug_rx(level, fmt, ...)
 497 #endif
 498
 499 #if (VXGE_DEBUG_MEM & VXGE_DEBUG_MASK)
 500 #define vxge_debug_mem(level, fmt, ...) \
 501         vxge_debug_ll(level, VXGE_DEBUG_MEM, fmt, __VA_ARGS__)
 502 #else
 503 #define vxge_debug_mem(level, fmt, ...)
 504 #endif
 505
 506 #if (VXGE_DEBUG_ENTRYEXIT & VXGE_DEBUG_MASK)
 507 #define vxge_debug_entryexit(level, fmt, ...) \
 508         vxge_debug_ll(level, VXGE_DEBUG_ENTRYEXIT, fmt, __VA_ARGS__)
 509 #else
 510 #define vxge_debug_entryexit(level, fmt, ...)
 511 #endif
 512
 513 #if (VXGE_DEBUG_INTR & VXGE_DEBUG_MASK)
 514 #define vxge_debug_intr(level, fmt, ...) \
 515         vxge_debug_ll(level, VXGE_DEBUG_INTR, fmt, __VA_ARGS__)
 516 #else
 517 #define vxge_debug_intr(level, fmt, ...)
 518 #endif
 519
 520 #define VXGE_DEVICE_DEBUG_LEVEL_SET(level, mask, vdev) {\
 521         vxge_hw_device_debug_set((struct __vxge_hw_device  *)vdev->devh, \
 522                 level, mask);\
 523         VXGE_COPY_DEBUG_INFO_TO_LL(vdev, \
 524                 vxge_hw_device_error_level_get((struct __vxge_hw_device  *) \
 525                         vdev->devh), \
 526                 vxge_hw_device_trace_level_get((struct __vxge_hw_device  *) \
 527                         vdev->devh));\
 528 }
 529
 530 #ifdef NETIF_F_GSO
 531 #define vxge_tcp_mss(skb) (skb_shinfo(skb)->gso_size)
 532 #define vxge_udp_mss(skb) (skb_shinfo(skb)->gso_size)
 533 #define vxge_offload_type(skb) (skb_shinfo(skb)->gso_type)
 534 #endif
 535
 536 #endif