kernel/linux/kni/ethtool/ixgbe/kcompat.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*******************************************************************************
   3
   4   Intel 10 Gigabit PCI Express Linux driver
   5   Copyright(c) 1999 - 2012 Intel Corporation.
   6
   7   Contact Information:
   8   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
   9   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  10
  11 *******************************************************************************/
  12
  13 #ifndef _KCOMPAT_H_
  14 #define _KCOMPAT_H_
  15
  16 #ifndef LINUX_VERSION_CODE
  17 #include <linux/version.h>
  18 #else
  19 #define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
  20 #endif
  21 #include <linux/init.h>
  22 #include <linux/types.h>
  23 #include <linux/errno.h>
  24 #include <linux/module.h>
  25 #include <linux/pci.h>
  26 #include <linux/netdevice.h>
  27 #include <linux/etherdevice.h>
  28 #include <linux/skbuff.h>
  29 #include <linux/ioport.h>
  30 #include <linux/slab.h>
  31 #include <linux/list.h>
  32 #include <linux/delay.h>
  33 #include <linux/sched.h>
  34 #include <linux/in.h>
  35 #include <linux/ip.h>
  36 #include <linux/udp.h>
  37 #include <linux/mii.h>
  38 #include <linux/vmalloc.h>
  39 #include <asm/io.h>
  40 #include <linux/ethtool.h>
  41 #include <linux/if_vlan.h>
  42
  43 /* NAPI enable/disable flags here */
  44 /* enable NAPI for ixgbe by default */
  45 #undef CONFIG_IXGBE_NAPI
  46 #define CONFIG_IXGBE_NAPI
  47 #define NAPI
  48 #ifdef CONFIG_IXGBE_NAPI
  49 #undef NAPI
  50 #define NAPI
  51 #endif /* CONFIG_IXGBE_NAPI */
  52 #ifdef IXGBE_NAPI
  53 #undef NAPI
  54 #define NAPI
  55 #endif /* IXGBE_NAPI */
  56 #ifdef IXGBE_NO_NAPI
  57 #undef NAPI
  58 #endif /* IXGBE_NO_NAPI */
  59
  60 #define adapter_struct ixgbe_adapter
  61 #define adapter_q_vector ixgbe_q_vector
  62
  63 /* and finally set defines so that the code sees the changes */
  64 #ifdef NAPI
  65 #ifndef CONFIG_IXGBE_NAPI
  66 #define CONFIG_IXGBE_NAPI
  67 #endif
  68 #else
  69 #undef CONFIG_IXGBE_NAPI
  70 #endif /* NAPI */
  71
  72 /* packet split disable/enable */
  73 #ifdef DISABLE_PACKET_SPLIT
  74 #ifndef CONFIG_IXGBE_DISABLE_PACKET_SPLIT
  75 #define CONFIG_IXGBE_DISABLE_PACKET_SPLIT
  76 #endif
  77 #endif /* DISABLE_PACKET_SPLIT */
  78
  79 /* MSI compatibility code for all kernels and drivers */
  80 #ifdef DISABLE_PCI_MSI
  81 #undef CONFIG_PCI_MSI
  82 #endif
  83 #ifndef CONFIG_PCI_MSI
  84 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,8) )
  85 struct msix_entry {
  86         u16 vector; /* kernel uses to write allocated vector */
  87         u16 entry;  /* driver uses to specify entry, OS writes */
  88 };
  89 #endif
  90 #undef pci_enable_msi
  91 #define pci_enable_msi(a) -ENOTSUPP
  92 #undef pci_disable_msi
  93 #define pci_disable_msi(a) do {} while (0)
  94 #undef pci_enable_msix
  95 #define pci_enable_msix(a, b, c) -ENOTSUPP
  96 #undef pci_disable_msix
  97 #define pci_disable_msix(a) do {} while (0)
  98 #define msi_remove_pci_irq_vectors(a) do {} while (0)
  99 #endif /* CONFIG_PCI_MSI */
 100 #ifdef DISABLE_PM
 101 #undef CONFIG_PM
 102 #endif
 103
 104 #ifdef DISABLE_NET_POLL_CONTROLLER
 105 #undef CONFIG_NET_POLL_CONTROLLER
 106 #endif
 107
 108 #ifndef PMSG_SUSPEND
 109 #define PMSG_SUSPEND 3
 110 #endif
 111
 112 /* generic boolean compatibility */
 113 #undef TRUE
 114 #undef FALSE
 115 #define TRUE true
 116 #define FALSE false
 117 #ifdef GCC_VERSION
 118 #if ( GCC_VERSION < 3000 )
 119 #define _Bool char
 120 #endif
 121 #else
 122 #define _Bool char
 123 #endif
 124
 125 /* kernels less than 2.4.14 don't have this */
 126 #ifndef ETH_P_8021Q
 127 #define ETH_P_8021Q 0x8100
 128 #endif
 129
 130 #ifndef module_param
 131 #define module_param(v,t,p) MODULE_PARM(v, "i");
 132 #endif
 133
 134 #ifndef DMA_64BIT_MASK
 135 #define DMA_64BIT_MASK  0xffffffffffffffffULL
 136 #endif
 137
 138 #ifndef DMA_32BIT_MASK
 139 #define DMA_32BIT_MASK  0x00000000ffffffffULL
 140 #endif
 141
 142 #ifndef PCI_CAP_ID_EXP
 143 #define PCI_CAP_ID_EXP 0x10
 144 #endif
 145
 146 #ifndef PCIE_LINK_STATE_L0S
 147 #define PCIE_LINK_STATE_L0S 1
 148 #endif
 149 #ifndef PCIE_LINK_STATE_L1
 150 #define PCIE_LINK_STATE_L1 2
 151 #endif
 152
 153 #ifndef mmiowb
 154 #ifdef CONFIG_IA64
 155 #define mmiowb() asm volatile ("mf.a" ::: "memory")
 156 #else
 157 #define mmiowb()
 158 #endif
 159 #endif
 160
 161 #ifndef SET_NETDEV_DEV
 162 #define SET_NETDEV_DEV(net, pdev)
 163 #endif
 164
 165 #if !defined(HAVE_FREE_NETDEV) && ( LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0) )
 166 #define free_netdev(x)  kfree(x)
 167 #endif
 168
 169 #ifdef HAVE_POLL_CONTROLLER
 170 #define CONFIG_NET_POLL_CONTROLLER
 171 #endif
 172
 173 #ifndef SKB_DATAREF_SHIFT
 174 /* if we do not have the infrastructure to detect if skb_header is cloned
 175    just return false in all cases */
 176 #define skb_header_cloned(x) 0
 177 #endif
 178
 179 #ifndef NETIF_F_GSO
 180 #define gso_size tso_size
 181 #define gso_segs tso_segs
 182 #endif
 183
 184 #ifndef NETIF_F_GRO
 185 #define vlan_gro_receive(_napi, _vlgrp, _vlan, _skb) \
 186                 vlan_hwaccel_receive_skb(_skb, _vlgrp, _vlan)
 187 #define napi_gro_receive(_napi, _skb) netif_receive_skb(_skb)
 188 #endif
 189
 190 #ifndef NETIF_F_SCTP_CSUM
 191 #define NETIF_F_SCTP_CSUM 0
 192 #endif
 193
 194 #ifndef NETIF_F_LRO
 195 #define NETIF_F_LRO (1 << 15)
 196 #endif
 197
 198 #ifndef NETIF_F_NTUPLE
 199 #define NETIF_F_NTUPLE (1 << 27)
 200 #endif
 201
 202 #ifndef IPPROTO_SCTP
 203 #define IPPROTO_SCTP 132
 204 #endif
 205
 206 #ifndef CHECKSUM_PARTIAL
 207 #define CHECKSUM_PARTIAL CHECKSUM_HW
 208 #define CHECKSUM_COMPLETE CHECKSUM_HW
 209 #endif
 210
 211 #ifndef __read_mostly
 212 #define __read_mostly
 213 #endif
 214
 215 #ifndef MII_RESV1
 216 #define MII_RESV1               0x17            /* Reserved...          */
 217 #endif
 218
 219 #ifndef unlikely
 220 #define unlikely(_x) _x
 221 #define likely(_x) _x
 222 #endif
 223
 224 #ifndef WARN_ON
 225 #define WARN_ON(x)
 226 #endif
 227
 228 #ifndef PCI_DEVICE
 229 #define PCI_DEVICE(vend,dev) \
 230         .vendor = (vend), .device = (dev), \
 231         .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
 232 #endif
 233
 234 #ifndef node_online
 235 #define node_online(node) ((node) == 0)
 236 #endif
 237
 238 #ifndef num_online_cpus
 239 #define num_online_cpus() smp_num_cpus
 240 #endif
 241
 242 #ifndef cpu_online
 243 #define cpu_online(cpuid) test_bit((cpuid), &cpu_online_map)
 244 #endif
 245
 246 #ifndef _LINUX_RANDOM_H
 247 #include <linux/random.h>
 248 #endif
 249
 250 #ifndef DECLARE_BITMAP
 251 #ifndef BITS_TO_LONGS
 252 #define BITS_TO_LONGS(bits) (((bits)+BITS_PER_LONG-1)/BITS_PER_LONG)
 253 #endif
 254 #define DECLARE_BITMAP(name,bits) long name[BITS_TO_LONGS(bits)]
 255 #endif
 256
 257 #ifndef VLAN_HLEN
 258 #define VLAN_HLEN 4
 259 #endif
 260
 261 #ifndef VLAN_ETH_HLEN
 262 #define VLAN_ETH_HLEN 18
 263 #endif
 264
 265 #ifndef VLAN_ETH_FRAME_LEN
 266 #define VLAN_ETH_FRAME_LEN 1518
 267 #endif
 268
 269 #if !defined(IXGBE_DCA) && !defined(IGB_DCA)
 270 #define dca_get_tag(b) 0
 271 #define dca_add_requester(a) -1
 272 #define dca_remove_requester(b) do { } while(0)
 273 #define DCA_PROVIDER_ADD     0x0001
 274 #define DCA_PROVIDER_REMOVE  0x0002
 275 #endif
 276
 277 #ifndef DCA_GET_TAG_TWO_ARGS
 278 #define dca3_get_tag(a,b) dca_get_tag(b)
 279 #endif
 280
 281 #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
 282 #if defined(__i386__) || defined(__x86_64__)
 283 #define CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
 284 #endif
 285 #endif
 286
 287 /* taken from 2.6.24 definition in linux/kernel.h */
 288 #ifndef IS_ALIGNED
 289 #define IS_ALIGNED(x,a)         (((x) % ((typeof(x))(a))) == 0)
 290 #endif
 291
 292 #ifndef NETIF_F_HW_VLAN_TX
 293 struct _kc_vlan_ethhdr {
 294         unsigned char   h_dest[ETH_ALEN];
 295         unsigned char   h_source[ETH_ALEN];
 296         __be16          h_vlan_proto;
 297         __be16          h_vlan_TCI;
 298         __be16          h_vlan_encapsulated_proto;
 299 };
 300 #define vlan_ethhdr _kc_vlan_ethhdr
 301 struct _kc_vlan_hdr {
 302         __be16          h_vlan_TCI;
 303         __be16          h_vlan_encapsulated_proto;
 304 };
 305 #define vlan_hdr _kc_vlan_hdr
 306 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0) )
 307 #define vlan_tx_tag_present(_skb) 0
 308 #define vlan_tx_tag_get(_skb) 0
 309 #endif
 310 #endif
 311
 312 #ifndef VLAN_PRIO_SHIFT
 313 #define VLAN_PRIO_SHIFT 13
 314 #endif
 315
 316
 317 #ifndef __GFP_COLD
 318 #define __GFP_COLD 0
 319 #endif
 320
 321 /*****************************************************************************/
 322 /* Installations with ethtool version without eeprom, adapter id, or statistics
 323  * support */
 324
 325 #ifndef ETH_GSTRING_LEN
 326 #define ETH_GSTRING_LEN 32
 327 #endif
 328
 329 #ifndef ETHTOOL_GSTATS
 330 #define ETHTOOL_GSTATS 0x1d
 331 #undef ethtool_drvinfo
 332 #define ethtool_drvinfo k_ethtool_drvinfo
 333 struct k_ethtool_drvinfo {
 334         u32 cmd;
 335         char driver[32];
 336         char version[32];
 337         char fw_version[32];
 338         char bus_info[32];
 339         char reserved1[32];
 340         char reserved2[16];
 341         u32 n_stats;
 342         u32 testinfo_len;
 343         u32 eedump_len;
 344         u32 regdump_len;
 345 };
 346
 347 struct ethtool_stats {
 348         u32 cmd;
 349         u32 n_stats;
 350         u64 data[0];
 351 };
 352 #endif /* ETHTOOL_GSTATS */
 353
 354 #ifndef ETHTOOL_PHYS_ID
 355 #define ETHTOOL_PHYS_ID 0x1c
 356 #endif /* ETHTOOL_PHYS_ID */
 357
 358 #ifndef ETHTOOL_GSTRINGS
 359 #define ETHTOOL_GSTRINGS 0x1b
 360 enum ethtool_stringset {
 361         ETH_SS_TEST             = 0,
 362         ETH_SS_STATS,
 363 };
 364 struct ethtool_gstrings {
 365         u32 cmd;            /* ETHTOOL_GSTRINGS */
 366         u32 string_set;     /* string set id e.c. ETH_SS_TEST, etc*/
 367         u32 len;            /* number of strings in the string set */
 368         u8 data[0];
 369 };
 370 #endif /* ETHTOOL_GSTRINGS */
 371
 372 #ifndef ETHTOOL_TEST
 373 #define ETHTOOL_TEST 0x1a
 374 enum ethtool_test_flags {
 375         ETH_TEST_FL_OFFLINE     = (1 << 0),
 376         ETH_TEST_FL_FAILED      = (1 << 1),
 377 };
 378 struct ethtool_test {
 379         u32 cmd;
 380         u32 flags;
 381         u32 reserved;
 382         u32 len;
 383         u64 data[0];
 384 };
 385 #endif /* ETHTOOL_TEST */
 386
 387 #ifndef ETHTOOL_GEEPROM
 388 #define ETHTOOL_GEEPROM 0xb
 389 #undef ETHTOOL_GREGS
 390 struct ethtool_eeprom {
 391         u32 cmd;
 392         u32 magic;
 393         u32 offset;
 394         u32 len;
 395         u8 data[0];
 396 };
 397
 398 struct ethtool_value {
 399         u32 cmd;
 400         u32 data;
 401 };
 402 #endif /* ETHTOOL_GEEPROM */
 403
 404 #ifndef ETHTOOL_GLINK
 405 #define ETHTOOL_GLINK 0xa
 406 #endif /* ETHTOOL_GLINK */
 407
 408 #ifndef ETHTOOL_GWOL
 409 #define ETHTOOL_GWOL 0x5
 410 #define ETHTOOL_SWOL 0x6
 411 #define SOPASS_MAX      6
 412 struct ethtool_wolinfo {
 413         u32 cmd;
 414         u32 supported;
 415         u32 wolopts;
 416         u8 sopass[SOPASS_MAX]; /* SecureOn(tm) password */
 417 };
 418 #endif /* ETHTOOL_GWOL */
 419
 420 #ifndef ETHTOOL_GREGS
 421 #define ETHTOOL_GREGS           0x00000004 /* Get NIC registers */
 422 #define ethtool_regs _kc_ethtool_regs
 423 /* for passing big chunks of data */
 424 struct _kc_ethtool_regs {
 425         u32 cmd;
 426         u32 version; /* driver-specific, indicates different chips/revs */
 427         u32 len; /* bytes */
 428         u8 data[0];
 429 };
 430 #endif /* ETHTOOL_GREGS */
 431
 432 #ifndef ETHTOOL_GMSGLVL
 433 #define ETHTOOL_GMSGLVL         0x00000007 /* Get driver message level */
 434 #endif
 435 #ifndef ETHTOOL_SMSGLVL
 436 #define ETHTOOL_SMSGLVL         0x00000008 /* Set driver msg level, priv. */
 437 #endif
 438 #ifndef ETHTOOL_NWAY_RST
 439 #define ETHTOOL_NWAY_RST        0x00000009 /* Restart autonegotiation, priv */
 440 #endif
 441 #ifndef ETHTOOL_GLINK
 442 #define ETHTOOL_GLINK           0x0000000a /* Get link status */
 443 #endif
 444 #ifndef ETHTOOL_GEEPROM
 445 #define ETHTOOL_GEEPROM         0x0000000b /* Get EEPROM data */
 446 #endif
 447 #ifndef ETHTOOL_SEEPROM
 448 #define ETHTOOL_SEEPROM         0x0000000c /* Set EEPROM data */
 449 #endif
 450 #ifndef ETHTOOL_GCOALESCE
 451 #define ETHTOOL_GCOALESCE       0x0000000e /* Get coalesce config */
 452 /* for configuring coalescing parameters of chip */
 453 #define ethtool_coalesce _kc_ethtool_coalesce
 454 struct _kc_ethtool_coalesce {
 455         u32     cmd;    /* ETHTOOL_{G,S}COALESCE */
 456
 457         /* How many usecs to delay an RX interrupt after
 458          * a packet arrives.  If 0, only rx_max_coalesced_frames
 459          * is used.
 460          */
 461         u32     rx_coalesce_usecs;
 462
 463         /* How many packets to delay an RX interrupt after
 464          * a packet arrives.  If 0, only rx_coalesce_usecs is
 465          * used.  It is illegal to set both usecs and max frames
 466          * to zero as this would cause RX interrupts to never be
 467          * generated.
 468          */
 469         u32     rx_max_coalesced_frames;
 470
 471         /* Same as above two parameters, except that these values
 472          * apply while an IRQ is being serviced by the host.  Not
 473          * all cards support this feature and the values are ignored
 474          * in that case.
 475          */
 476         u32     rx_coalesce_usecs_irq;
 477         u32     rx_max_coalesced_frames_irq;
 478
 479         /* How many usecs to delay a TX interrupt after
 480          * a packet is sent.  If 0, only tx_max_coalesced_frames
 481          * is used.
 482          */
 483         u32     tx_coalesce_usecs;
 484
 485         /* How many packets to delay a TX interrupt after
 486          * a packet is sent.  If 0, only tx_coalesce_usecs is
 487          * used.  It is illegal to set both usecs and max frames
 488          * to zero as this would cause TX interrupts to never be
 489          * generated.
 490          */
 491         u32     tx_max_coalesced_frames;
 492
 493         /* Same as above two parameters, except that these values
 494          * apply while an IRQ is being serviced by the host.  Not
 495          * all cards support this feature and the values are ignored
 496          * in that case.
 497          */
 498         u32     tx_coalesce_usecs_irq;
 499         u32     tx_max_coalesced_frames_irq;
 500
 501         /* How many usecs to delay in-memory statistics
 502          * block updates.  Some drivers do not have an in-memory
 503          * statistic block, and in such cases this value is ignored.
 504          * This value must not be zero.
 505          */
 506         u32     stats_block_coalesce_usecs;
 507
 508         /* Adaptive RX/TX coalescing is an algorithm implemented by
 509          * some drivers to improve latency under low packet rates and
 510          * improve throughput under high packet rates.  Some drivers
 511          * only implement one of RX or TX adaptive coalescing.  Anything
 512          * not implemented by the driver causes these values to be
 513          * silently ignored.
 514          */
 515         u32     use_adaptive_rx_coalesce;
 516         u32     use_adaptive_tx_coalesce;
 517
 518         /* When the packet rate (measured in packets per second)
 519          * is below pkt_rate_low, the {rx,tx}_*_low parameters are
 520          * used.
 521          */
 522         u32     pkt_rate_low;
 523         u32     rx_coalesce_usecs_low;
 524         u32     rx_max_coalesced_frames_low;
 525         u32     tx_coalesce_usecs_low;
 526         u32     tx_max_coalesced_frames_low;
 527
 528         /* When the packet rate is below pkt_rate_high but above
 529          * pkt_rate_low (both measured in packets per second) the
 530          * normal {rx,tx}_* coalescing parameters are used.
 531          */
 532
 533         /* When the packet rate is (measured in packets per second)
 534          * is above pkt_rate_high, the {rx,tx}_*_high parameters are
 535          * used.
 536          */
 537         u32     pkt_rate_high;
 538         u32     rx_coalesce_usecs_high;
 539         u32     rx_max_coalesced_frames_high;
 540         u32     tx_coalesce_usecs_high;
 541         u32     tx_max_coalesced_frames_high;
 542
 543         /* How often to do adaptive coalescing packet rate sampling,
 544          * measured in seconds.  Must not be zero.
 545          */
 546         u32     rate_sample_interval;
 547 };
 548 #endif /* ETHTOOL_GCOALESCE */
 549
 550 #ifndef ETHTOOL_SCOALESCE
 551 #define ETHTOOL_SCOALESCE       0x0000000f /* Set coalesce config. */
 552 #endif
 553 #ifndef ETHTOOL_GRINGPARAM
 554 #define ETHTOOL_GRINGPARAM      0x00000010 /* Get ring parameters */
 555 /* for configuring RX/TX ring parameters */
 556 #define ethtool_ringparam _kc_ethtool_ringparam
 557 struct _kc_ethtool_ringparam {
 558         u32     cmd;    /* ETHTOOL_{G,S}RINGPARAM */
 559
 560         /* Read only attributes.  These indicate the maximum number
 561          * of pending RX/TX ring entries the driver will allow the
 562          * user to set.
 563          */
 564         u32     rx_max_pending;
 565         u32     rx_mini_max_pending;
 566         u32     rx_jumbo_max_pending;
 567         u32     tx_max_pending;
 568
 569         /* Values changeable by the user.  The valid values are
 570          * in the range 1 to the "*_max_pending" counterpart above.
 571          */
 572         u32     rx_pending;
 573         u32     rx_mini_pending;
 574         u32     rx_jumbo_pending;
 575         u32     tx_pending;
 576 };
 577 #endif /* ETHTOOL_GRINGPARAM */
 578
 579 #ifndef ETHTOOL_SRINGPARAM
 580 #define ETHTOOL_SRINGPARAM      0x00000011 /* Set ring parameters, priv. */
 581 #endif
 582 #ifndef ETHTOOL_GPAUSEPARAM
 583 #define ETHTOOL_GPAUSEPARAM     0x00000012 /* Get pause parameters */
 584 /* for configuring link flow control parameters */
 585 #define ethtool_pauseparam _kc_ethtool_pauseparam
 586 struct _kc_ethtool_pauseparam {
 587         u32     cmd;    /* ETHTOOL_{G,S}PAUSEPARAM */
 588
 589         /* If the link is being auto-negotiated (via ethtool_cmd.autoneg
 590          * being true) the user may set 'autoneg' here non-zero to have the
 591          * pause parameters be auto-negotiated too.  In such a case, the
 592          * {rx,tx}_pause values below determine what capabilities are
 593          * advertised.
 594          *
 595          * If 'autoneg' is zero or the link is not being auto-negotiated,
 596          * then {rx,tx}_pause force the driver to use/not-use pause
 597          * flow control.
 598          */
 599         u32     autoneg;
 600         u32     rx_pause;
 601         u32     tx_pause;
 602 };
 603 #endif /* ETHTOOL_GPAUSEPARAM */
 604
 605 #ifndef ETHTOOL_SPAUSEPARAM
 606 #define ETHTOOL_SPAUSEPARAM     0x00000013 /* Set pause parameters. */
 607 #endif
 608 #ifndef ETHTOOL_GRXCSUM
 609 #define ETHTOOL_GRXCSUM         0x00000014 /* Get RX hw csum enable (ethtool_value) */
 610 #endif
 611 #ifndef ETHTOOL_SRXCSUM
 612 #define ETHTOOL_SRXCSUM         0x00000015 /* Set RX hw csum enable (ethtool_value) */
 613 #endif
 614 #ifndef ETHTOOL_GTXCSUM
 615 #define ETHTOOL_GTXCSUM         0x00000016 /* Get TX hw csum enable (ethtool_value) */
 616 #endif
 617 #ifndef ETHTOOL_STXCSUM
 618 #define ETHTOOL_STXCSUM         0x00000017 /* Set TX hw csum enable (ethtool_value) */
 619 #endif
 620 #ifndef ETHTOOL_GSG
 621 #define ETHTOOL_GSG             0x00000018 /* Get scatter-gather enable
 622                                             * (ethtool_value) */
 623 #endif
 624 #ifndef ETHTOOL_SSG
 625 #define ETHTOOL_SSG             0x00000019 /* Set scatter-gather enable
 626                                             * (ethtool_value). */
 627 #endif
 628 #ifndef ETHTOOL_TEST
 629 #define ETHTOOL_TEST            0x0000001a /* execute NIC self-test, priv. */
 630 #endif
 631 #ifndef ETHTOOL_GSTRINGS
 632 #define ETHTOOL_GSTRINGS        0x0000001b /* get specified string set */
 633 #endif
 634 #ifndef ETHTOOL_PHYS_ID
 635 #define ETHTOOL_PHYS_ID         0x0000001c /* identify the NIC */
 636 #endif
 637 #ifndef ETHTOOL_GSTATS
 638 #define ETHTOOL_GSTATS          0x0000001d /* get NIC-specific statistics */
 639 #endif
 640 #ifndef ETHTOOL_GTSO
 641 #define ETHTOOL_GTSO            0x0000001e /* Get TSO enable (ethtool_value) */
 642 #endif
 643 #ifndef ETHTOOL_STSO
 644 #define ETHTOOL_STSO            0x0000001f /* Set TSO enable (ethtool_value) */
 645 #endif
 646
 647 #ifndef ETHTOOL_BUSINFO_LEN
 648 #define ETHTOOL_BUSINFO_LEN     32
 649 #endif
 650
 651 #ifndef RHEL_RELEASE_CODE
 652 /* NOTE: RHEL_RELEASE_* introduced in RHEL4.5 */
 653 #define RHEL_RELEASE_CODE 0
 654 #endif
 655 #ifndef RHEL_RELEASE_VERSION
 656 #define RHEL_RELEASE_VERSION(a,b) (((a) << 8) + (b))
 657 #endif
 658 #ifndef AX_RELEASE_CODE
 659 #define AX_RELEASE_CODE 0
 660 #endif
 661 #ifndef AX_RELEASE_VERSION
 662 #define AX_RELEASE_VERSION(a,b) (((a) << 8) + (b))
 663 #endif
 664
 665 /* SuSE version macro is the same as Linux kernel version */
 666 #ifndef SLE_VERSION
 667 #define SLE_VERSION(a,b,c) KERNEL_VERSION(a,b,c)
 668 #endif
 669 #ifndef SLE_VERSION_CODE
 670 #ifdef CONFIG_SUSE_KERNEL
 671 /* SLES11 GA is 2.6.27 based */
 672 #if ( LINUX_VERSION_CODE == KERNEL_VERSION(2,6,27) )
 673 #define SLE_VERSION_CODE SLE_VERSION(11,0,0)
 674 #elif ( LINUX_VERSION_CODE == KERNEL_VERSION(2,6,32) )
 675 /* SLES11 SP1 is 2.6.32 based */
 676 #define SLE_VERSION_CODE SLE_VERSION(11,1,0)
 677 #else
 678 #define SLE_VERSION_CODE 0
 679 #endif
 680 #else /* CONFIG_SUSE_KERNEL */
 681 #define SLE_VERSION_CODE 0
 682 #endif /* CONFIG_SUSE_KERNEL */
 683 #endif /* SLE_VERSION_CODE */
 684
 685 #ifdef __KLOCWORK__
 686 #ifdef ARRAY_SIZE
 687 #undef ARRAY_SIZE
 688 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
 689 #endif
 690 #endif /* __KLOCWORK__ */
 691
 692 /*****************************************************************************/
 693 /* 2.4.3 => 2.4.0 */
 694 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,3) )
 695
 696 /**************************************/
 697 /* PCI DRIVER API */
 698
 699 #ifndef pci_set_dma_mask
 700 #define pci_set_dma_mask _kc_pci_set_dma_mask
 701 extern int _kc_pci_set_dma_mask(struct pci_dev *dev, dma_addr_t mask);
 702 #endif
 703
 704 #ifndef pci_request_regions
 705 #define pci_request_regions _kc_pci_request_regions
 706 extern int _kc_pci_request_regions(struct pci_dev *pdev, char *res_name);
 707 #endif
 708
 709 #ifndef pci_release_regions
 710 #define pci_release_regions _kc_pci_release_regions
 711 extern void _kc_pci_release_regions(struct pci_dev *pdev);
 712 #endif
 713
 714 /**************************************/
 715 /* NETWORK DRIVER API */
 716
 717 #ifndef alloc_etherdev
 718 #define alloc_etherdev _kc_alloc_etherdev
 719 extern struct net_device * _kc_alloc_etherdev(int sizeof_priv);
 720 #endif
 721
 722 #ifndef is_valid_ether_addr
 723 #define is_valid_ether_addr _kc_is_valid_ether_addr
 724 extern int _kc_is_valid_ether_addr(u8 *addr);
 725 #endif
 726
 727 /**************************************/
 728 /* MISCELLANEOUS */
 729
 730 #ifndef INIT_TQUEUE
 731 #define INIT_TQUEUE(_tq, _routine, _data)               \
 732         do {                                            \
 733                 INIT_LIST_HEAD(&(_tq)->list);           \
 734                 (_tq)->sync = 0;                        \
 735                 (_tq)->routine = _routine;              \
 736                 (_tq)->data = _data;                    \
 737         } while (0)
 738 #endif
 739
 740 #endif /* 2.4.3 => 2.4.0 */
 741
 742 /*****************************************************************************/
 743 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,5) )
 744 /* Generic MII registers. */
 745 #define MII_BMCR            0x00        /* Basic mode control register */
 746 #define MII_BMSR            0x01        /* Basic mode status register  */
 747 #define MII_PHYSID1         0x02        /* PHYS ID 1                   */
 748 #define MII_PHYSID2         0x03        /* PHYS ID 2                   */
 749 #define MII_ADVERTISE       0x04        /* Advertisement control reg   */
 750 #define MII_LPA             0x05        /* Link partner ability reg    */
 751 #define MII_EXPANSION       0x06        /* Expansion register          */
 752 /* Basic mode control register. */
 753 #define BMCR_FULLDPLX           0x0100  /* Full duplex                 */
 754 #define BMCR_ANENABLE           0x1000  /* Enable auto negotiation     */
 755 /* Basic mode status register. */
 756 #define BMSR_ERCAP              0x0001  /* Ext-reg capability          */
 757 #define BMSR_ANEGCAPABLE        0x0008  /* Able to do auto-negotiation */
 758 #define BMSR_10HALF             0x0800  /* Can do 10mbps, half-duplex  */
 759 #define BMSR_10FULL             0x1000  /* Can do 10mbps, full-duplex  */
 760 #define BMSR_100HALF            0x2000  /* Can do 100mbps, half-duplex */
 761 #define BMSR_100FULL            0x4000  /* Can do 100mbps, full-duplex */
 762 /* Advertisement control register. */
 763 #define ADVERTISE_CSMA          0x0001  /* Only selector supported     */
 764 #define ADVERTISE_10HALF        0x0020  /* Try for 10mbps half-duplex  */
 765 #define ADVERTISE_10FULL        0x0040  /* Try for 10mbps full-duplex  */
 766 #define ADVERTISE_100HALF       0x0080  /* Try for 100mbps half-duplex */
 767 #define ADVERTISE_100FULL       0x0100  /* Try for 100mbps full-duplex */
 768 #define ADVERTISE_ALL (ADVERTISE_10HALF | ADVERTISE_10FULL | \
 769                        ADVERTISE_100HALF | ADVERTISE_100FULL)
 770 /* Expansion register for auto-negotiation. */
 771 #define EXPANSION_ENABLENPAGE   0x0004  /* This enables npage words    */
 772 #endif
 773
 774 /*****************************************************************************/
 775 /* 2.4.6 => 2.4.3 */
 776 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,6) )
 777
 778 #ifndef pci_set_power_state
 779 #define pci_set_power_state _kc_pci_set_power_state
 780 extern int _kc_pci_set_power_state(struct pci_dev *dev, int state);
 781 #endif
 782
 783 #ifndef pci_enable_wake
 784 #define pci_enable_wake _kc_pci_enable_wake
 785 extern int _kc_pci_enable_wake(struct pci_dev *pdev, u32 state, int enable);
 786 #endif
 787
 788 #ifndef pci_disable_device
 789 #define pci_disable_device _kc_pci_disable_device
 790 extern void _kc_pci_disable_device(struct pci_dev *pdev);
 791 #endif
 792
 793 /* PCI PM entry point syntax changed, so don't support suspend/resume */
 794 #undef CONFIG_PM
 795
 796 #endif /* 2.4.6 => 2.4.3 */
 797
 798 #ifndef HAVE_PCI_SET_MWI
 799 #define pci_set_mwi(X) pci_write_config_word(X, \
 800                                PCI_COMMAND, adapter->hw.bus.pci_cmd_word | \
 801                                PCI_COMMAND_INVALIDATE);
 802 #define pci_clear_mwi(X) pci_write_config_word(X, \
 803                                PCI_COMMAND, adapter->hw.bus.pci_cmd_word & \
 804                                ~PCI_COMMAND_INVALIDATE);
 805 #endif
 806
 807 /*****************************************************************************/
 808 /* 2.4.10 => 2.4.9 */
 809 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,10) )
 810
 811 /**************************************/
 812 /* MODULE API */
 813
 814 #ifndef MODULE_LICENSE
 815         #define MODULE_LICENSE(X)
 816 #endif
 817
 818 /**************************************/
 819 /* OTHER */
 820
 821 #undef min
 822 #define min(x,y) ({ \
 823         const typeof(x) _x = (x);       \
 824         const typeof(y) _y = (y);       \
 825         (void) (&_x == &_y);            \
 826         _x < _y ? _x : _y; })
 827
 828 #undef max
 829 #define max(x,y) ({ \
 830         const typeof(x) _x = (x);       \
 831         const typeof(y) _y = (y);       \
 832         (void) (&_x == &_y);            \
 833         _x > _y ? _x : _y; })
 834
 835 #define min_t(type,x,y) ({ \
 836         type _x = (x); \
 837         type _y = (y); \
 838         _x < _y ? _x : _y; })
 839
 840 #define max_t(type,x,y) ({ \
 841         type _x = (x); \
 842         type _y = (y); \
 843         _x > _y ? _x : _y; })
 844
 845 #ifndef list_for_each_safe
 846 #define list_for_each_safe(pos, n, head) \
 847         for (pos = (head)->next, n = pos->next; pos != (head); \
 848                 pos = n, n = pos->next)
 849 #endif
 850
 851 #ifndef ____cacheline_aligned_in_smp
 852 #ifdef CONFIG_SMP
 853 #define ____cacheline_aligned_in_smp ____cacheline_aligned
 854 #else
 855 #define ____cacheline_aligned_in_smp
 856 #endif /* CONFIG_SMP */
 857 #endif
 858
 859 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,8) )
 860 extern int _kc_snprintf(char * buf, size_t size, const char *fmt, ...);
 861 #define snprintf(buf, size, fmt, args...) _kc_snprintf(buf, size, fmt, ##args)
 862 extern int _kc_vsnprintf(char *buf, size_t size, const char *fmt, va_list args);
 863 #define vsnprintf(buf, size, fmt, args) _kc_vsnprintf(buf, size, fmt, args)
 864 #else /* 2.4.8 => 2.4.9 */
 865 extern int snprintf(char * buf, size_t size, const char *fmt, ...);
 866 extern int vsnprintf(char *buf, size_t size, const char *fmt, va_list args);
 867 #endif
 868 #endif /* 2.4.10 -> 2.4.6 */
 869
 870
 871 /*****************************************************************************/
 872 /* 2.4.12 => 2.4.10 */
 873 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,12) )
 874 #ifndef HAVE_NETIF_MSG
 875 #define HAVE_NETIF_MSG 1
 876 enum {
 877         NETIF_MSG_DRV           = 0x0001,
 878         NETIF_MSG_PROBE         = 0x0002,
 879         NETIF_MSG_LINK          = 0x0004,
 880         NETIF_MSG_TIMER         = 0x0008,
 881         NETIF_MSG_IFDOWN        = 0x0010,
 882         NETIF_MSG_IFUP          = 0x0020,
 883         NETIF_MSG_RX_ERR        = 0x0040,
 884         NETIF_MSG_TX_ERR        = 0x0080,
 885         NETIF_MSG_TX_QUEUED     = 0x0100,
 886         NETIF_MSG_INTR          = 0x0200,
 887         NETIF_MSG_TX_DONE       = 0x0400,
 888         NETIF_MSG_RX_STATUS     = 0x0800,
 889         NETIF_MSG_PKTDATA       = 0x1000,
 890         NETIF_MSG_HW            = 0x2000,
 891         NETIF_MSG_WOL           = 0x4000,
 892 };
 893
 894 #define netif_msg_drv(p)        ((p)->msg_enable & NETIF_MSG_DRV)
 895 #define netif_msg_probe(p)      ((p)->msg_enable & NETIF_MSG_PROBE)
 896 #define netif_msg_link(p)       ((p)->msg_enable & NETIF_MSG_LINK)
 897 #define netif_msg_timer(p)      ((p)->msg_enable & NETIF_MSG_TIMER)
 898 #define netif_msg_ifdown(p)     ((p)->msg_enable & NETIF_MSG_IFDOWN)
 899 #define netif_msg_ifup(p)       ((p)->msg_enable & NETIF_MSG_IFUP)
 900 #define netif_msg_rx_err(p)     ((p)->msg_enable & NETIF_MSG_RX_ERR)
 901 #define netif_msg_tx_err(p)     ((p)->msg_enable & NETIF_MSG_TX_ERR)
 902 #define netif_msg_tx_queued(p)  ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
 903 #define netif_msg_intr(p)       ((p)->msg_enable & NETIF_MSG_INTR)
 904 #define netif_msg_tx_done(p)    ((p)->msg_enable & NETIF_MSG_TX_DONE)
 905 #define netif_msg_rx_status(p)  ((p)->msg_enable & NETIF_MSG_RX_STATUS)
 906 #define netif_msg_pktdata(p)    ((p)->msg_enable & NETIF_MSG_PKTDATA)
 907 #endif /* !HAVE_NETIF_MSG */
 908 #endif /* 2.4.12 => 2.4.10 */
 909
 910 /*****************************************************************************/
 911 /* 2.4.13 => 2.4.12 */
 912 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,13) )
 913
 914 /**************************************/
 915 /* PCI DMA MAPPING */
 916
 917 #ifndef virt_to_page
 918         #define virt_to_page(v) (mem_map + (virt_to_phys(v) >> PAGE_SHIFT))
 919 #endif
 920
 921 #ifndef pci_map_page
 922 #define pci_map_page _kc_pci_map_page
 923 extern u64 _kc_pci_map_page(struct pci_dev *dev, struct page *page, unsigned long offset, size_t size, int direction);
 924 #endif
 925
 926 #ifndef pci_unmap_page
 927 #define pci_unmap_page _kc_pci_unmap_page
 928 extern void _kc_pci_unmap_page(struct pci_dev *dev, u64 dma_addr, size_t size, int direction);
 929 #endif
 930
 931 /* pci_set_dma_mask takes dma_addr_t, which is only 32-bits prior to 2.4.13 */
 932
 933 #undef DMA_32BIT_MASK
 934 #define DMA_32BIT_MASK  0xffffffff
 935 #undef DMA_64BIT_MASK
 936 #define DMA_64BIT_MASK  0xffffffff
 937
 938 /**************************************/
 939 /* OTHER */
 940
 941 #ifndef cpu_relax
 942 #define cpu_relax()     rep_nop()
 943 #endif
 944
 945 struct vlan_ethhdr {
 946         unsigned char h_dest[ETH_ALEN];
 947         unsigned char h_source[ETH_ALEN];
 948         unsigned short h_vlan_proto;
 949         unsigned short h_vlan_TCI;
 950         unsigned short h_vlan_encapsulated_proto;
 951 };
 952 #endif /* 2.4.13 => 2.4.12 */
 953
 954 /*****************************************************************************/
 955 /* 2.4.17 => 2.4.12 */
 956 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,17) )
 957
 958 #ifndef __devexit_p
 959         #define __devexit_p(x) &(x)
 960 #endif
 961
 962 #endif /* 2.4.17 => 2.4.13 */
 963
 964 /*****************************************************************************/
 965 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,18) )
 966 #define NETIF_MSG_HW    0x2000
 967 #define NETIF_MSG_WOL   0x4000
 968
 969 #ifndef netif_msg_hw
 970 #define netif_msg_hw(p)         ((p)->msg_enable & NETIF_MSG_HW)
 971 #endif
 972 #ifndef netif_msg_wol
 973 #define netif_msg_wol(p)        ((p)->msg_enable & NETIF_MSG_WOL)
 974 #endif
 975 #endif /* 2.4.18 */
 976
 977 /*****************************************************************************/
 978
 979 /*****************************************************************************/
 980 /* 2.4.20 => 2.4.19 */
 981 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,20) )
 982
 983 /* we won't support NAPI on less than 2.4.20 */
 984 #ifdef NAPI
 985 #undef NAPI
 986 #undef CONFIG_IXGBE_NAPI
 987 #endif
 988
 989 #endif /* 2.4.20 => 2.4.19 */
 990
 991 /*****************************************************************************/
 992 /* 2.4.22 => 2.4.17 */
 993 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,22) )
 994 #define pci_name(x)     ((x)->slot_name)
 995 #endif
 996
 997 /*****************************************************************************/
 998 /* 2.4.22 => 2.4.17 */
 999
1000 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,22) )
1001 #ifndef IXGBE_NO_LRO
1002 /* Don't enable LRO for these legacy kernels */
1003 #define IXGBE_NO_LRO
1004 #endif
1005 #endif
1006
1007 /*****************************************************************************/
1008 /*****************************************************************************/
1009 /* 2.4.23 => 2.4.22 */
1010 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,23) )
1011 /*****************************************************************************/
1012 #ifdef NAPI
1013 #ifndef netif_poll_disable
1014 #define netif_poll_disable(x) _kc_netif_poll_disable(x)
1015 static inline void _kc_netif_poll_disable(struct net_device *netdev)
1016 {
1017         while (test_and_set_bit(__LINK_STATE_RX_SCHED, &netdev->state)) {
1018                 /* No hurry */
1019                 current->state = TASK_INTERRUPTIBLE;
1020                 schedule_timeout(1);
1021         }
1022 }
1023 #endif
1024 #ifndef netif_poll_enable
1025 #define netif_poll_enable(x) _kc_netif_poll_enable(x)
1026 static inline void _kc_netif_poll_enable(struct net_device *netdev)
1027 {
1028         clear_bit(__LINK_STATE_RX_SCHED, &netdev->state);
1029 }
1030 #endif
1031 #endif /* NAPI */
1032 #ifndef netif_tx_disable
1033 #define netif_tx_disable(x) _kc_netif_tx_disable(x)
1034 static inline void _kc_netif_tx_disable(struct net_device *dev)
1035 {
1036         spin_lock_bh(&dev->xmit_lock);
1037         netif_stop_queue(dev);
1038         spin_unlock_bh(&dev->xmit_lock);
1039 }
1040 #endif
1041 #else /* 2.4.23 => 2.4.22 */
1042 #define HAVE_SCTP
1043 #endif /* 2.4.23 => 2.4.22 */
1044
1045 /*****************************************************************************/
1046 /* 2.6.4 => 2.6.0 */
1047 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,25) || \
1048     ( LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) && \
1049       LINUX_VERSION_CODE < KERNEL_VERSION(2,6,4) ) )
1050 #define ETHTOOL_OPS_COMPAT
1051 #endif /* 2.6.4 => 2.6.0 */
1052
1053 /*****************************************************************************/
1054 /* 2.5.71 => 2.4.x */
1055 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,5,71) )
1056 #define sk_protocol protocol
1057 #define pci_get_device pci_find_device
1058 #endif /* 2.5.70 => 2.4.x */
1059
1060 /*****************************************************************************/
1061 /* < 2.4.27 or 2.6.0 <= 2.6.5 */
1062 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,27) || \
1063     ( LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) && \
1064       LINUX_VERSION_CODE < KERNEL_VERSION(2,6,5) ) )
1065
1066 #ifndef netif_msg_init
1067 #define netif_msg_init _kc_netif_msg_init
1068 static inline u32 _kc_netif_msg_init(int debug_value, int default_msg_enable_bits)
1069 {
1070         /* use default */
1071         if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
1072                 return default_msg_enable_bits;
1073         if (debug_value == 0) /* no output */
1074                 return 0;
1075         /* set low N bits */
1076         return (1 << debug_value) -1;
1077 }
1078 #endif
1079
1080 #endif /* < 2.4.27 or 2.6.0 <= 2.6.5 */
1081 /*****************************************************************************/
1082 #if (( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,27) ) || \
1083      (( LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) ) && \
1084       ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,3) )))
1085 #define netdev_priv(x) x->priv
1086 #endif
1087
1088 /*****************************************************************************/
1089 /* <= 2.5.0 */
1090 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0) )
1091 #include <linux/rtnetlink.h>
1092 #undef pci_register_driver
1093 #define pci_register_driver pci_module_init
1094
1095 /*
1096  * Most of the dma compat code is copied/modified from the 2.4.37
1097  * /include/linux/libata-compat.h header file
1098  */
1099 /* These definitions mirror those in pci.h, so they can be used
1100  * interchangeably with their PCI_ counterparts */
1101 enum dma_data_direction {
1102         DMA_BIDIRECTIONAL = 0,
1103         DMA_TO_DEVICE = 1,
1104         DMA_FROM_DEVICE = 2,
1105         DMA_NONE = 3,
1106 };
1107
1108 struct device {
1109         struct pci_dev pdev;
1110 };
1111
1112 static inline struct pci_dev *to_pci_dev (struct device *dev)
1113 {
1114         return (struct pci_dev *) dev;
1115 }
1116 static inline struct device *pci_dev_to_dev(struct pci_dev *pdev)
1117 {
1118         return (struct device *) pdev;
1119 }
1120
1121 #define pdev_printk(lvl, pdev, fmt, args...)    \
1122         printk("%s %s: " fmt, lvl, pci_name(pdev), ## args)
1123 #define dev_err(dev, fmt, args...)            \
1124         pdev_printk(KERN_ERR, to_pci_dev(dev), fmt, ## args)
1125 #define dev_info(dev, fmt, args...)            \
1126         pdev_printk(KERN_INFO, to_pci_dev(dev), fmt, ## args)
1127 #define dev_warn(dev, fmt, args...)            \
1128         pdev_printk(KERN_WARNING, to_pci_dev(dev), fmt, ## args)
1129
1130 /* NOTE: dangerous! we ignore the 'gfp' argument */
1131 #define dma_alloc_coherent(dev,sz,dma,gfp) \
1132         pci_alloc_consistent(to_pci_dev(dev),(sz),(dma))
1133 #define dma_free_coherent(dev,sz,addr,dma_addr) \
1134         pci_free_consistent(to_pci_dev(dev),(sz),(addr),(dma_addr))
1135
1136 #define dma_map_page(dev,a,b,c,d) \
1137         pci_map_page(to_pci_dev(dev),(a),(b),(c),(d))
1138 #define dma_unmap_page(dev,a,b,c) \
1139         pci_unmap_page(to_pci_dev(dev),(a),(b),(c))
1140
1141 #define dma_map_single(dev,a,b,c) \
1142         pci_map_single(to_pci_dev(dev),(a),(b),(c))
1143 #define dma_unmap_single(dev,a,b,c) \
1144         pci_unmap_single(to_pci_dev(dev),(a),(b),(c))
1145
1146 #define dma_sync_single(dev,a,b,c) \
1147         pci_dma_sync_single(to_pci_dev(dev),(a),(b),(c))
1148
1149 /* for range just sync everything, that's all the pci API can do */
1150 #define dma_sync_single_range(dev,addr,off,sz,dir) \
1151         pci_dma_sync_single(to_pci_dev(dev),(addr),(off)+(sz),(dir))
1152
1153 #define dma_set_mask(dev,mask) \
1154         pci_set_dma_mask(to_pci_dev(dev),(mask))
1155
1156 /* hlist_* code - double linked lists */
1157 struct hlist_head {
1158         struct hlist_node *first;
1159 };
1160
1161 struct hlist_node {
1162         struct hlist_node *next, **pprev;
1163 };
1164
1165 static inline void __hlist_del(struct hlist_node *n)
1166 {
1167         struct hlist_node *next = n->next;
1168         struct hlist_node **pprev = n->pprev;
1169         *pprev = next;
1170         if (next)
1171         next->pprev = pprev;
1172 }
1173
1174 static inline void hlist_del(struct hlist_node *n)
1175 {
1176         __hlist_del(n);
1177         n->next = NULL;
1178         n->pprev = NULL;
1179 }
1180
1181 static inline void hlist_add_head(struct hlist_node *n, struct hlist_head *h)
1182 {
1183         struct hlist_node *first = h->first;
1184         n->next = first;
1185         if (first)
1186                 first->pprev = &n->next;
1187         h->first = n;
1188         n->pprev = &h->first;
1189 }
1190
1191 static inline int hlist_empty(const struct hlist_head *h)
1192 {
1193         return !h->first;
1194 }
1195 #define HLIST_HEAD_INIT { .first = NULL }
1196 #define HLIST_HEAD(name) struct hlist_head name = {  .first = NULL }
1197 #define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL)
1198 static inline void INIT_HLIST_NODE(struct hlist_node *h)
1199 {
1200         h->next = NULL;
1201         h->pprev = NULL;
1202 }
1203 #define hlist_entry(ptr, type, member) container_of(ptr,type,member)
1204
1205 #define hlist_for_each_entry(tpos, pos, head, member)                    \
1206         for (pos = (head)->first;                                        \
1207              pos && ({ prefetch(pos->next); 1;}) &&                      \
1208                 ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
1209              pos = pos->next)
1210
1211 #define hlist_for_each_entry_safe(tpos, pos, n, head, member)            \
1212         for (pos = (head)->first;                                        \
1213              pos && ({ n = pos->next; 1; }) &&                           \
1214                 ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
1215              pos = n)
1216
1217 #ifndef might_sleep
1218 #define might_sleep()
1219 #endif
1220 #else
1221 static inline struct device *pci_dev_to_dev(struct pci_dev *pdev)
1222 {
1223         return &pdev->dev;
1224 }
1225 #endif /* <= 2.5.0 */
1226
1227 /*****************************************************************************/
1228 /* 2.5.28 => 2.4.23 */
1229 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,5,28) )
1230
1231 static inline void _kc_synchronize_irq(void)
1232 {
1233         synchronize_irq();
1234 }
1235 #undef synchronize_irq
1236 #define synchronize_irq(X) _kc_synchronize_irq()
1237
1238 #include <linux/tqueue.h>
1239 #define work_struct tq_struct
1240 #undef INIT_WORK
1241 #define INIT_WORK(a,b) INIT_TQUEUE(a,(void (*)(void *))b,a)
1242 #undef container_of
1243 #define container_of list_entry
1244 #define schedule_work schedule_task
1245 #define flush_scheduled_work flush_scheduled_tasks
1246 #define cancel_work_sync(x) flush_scheduled_work()
1247
1248 #endif /* 2.5.28 => 2.4.17 */
1249
1250 /*****************************************************************************/
1251 /* 2.6.0 => 2.5.28 */
1252 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) )
1253 #undef get_cpu
1254 #define get_cpu() smp_processor_id()
1255 #undef put_cpu
1256 #define put_cpu() do { } while(0)
1257 #define MODULE_INFO(version, _version)
1258 #ifndef CONFIG_E1000_DISABLE_PACKET_SPLIT
1259 #define CONFIG_E1000_DISABLE_PACKET_SPLIT 1
1260 #endif
1261 #define CONFIG_IGB_DISABLE_PACKET_SPLIT 1
1262
1263 #define dma_set_coherent_mask(dev,mask) 1
1264
1265 #undef dev_put
1266 #define dev_put(dev) __dev_put(dev)
1267
1268 #ifndef skb_fill_page_desc
1269 #define skb_fill_page_desc _kc_skb_fill_page_desc
1270 extern void _kc_skb_fill_page_desc(struct sk_buff *skb, int i, struct page *page, int off, int size);
1271 #endif
1272
1273 #undef ALIGN
1274 #define ALIGN(x,a) (((x)+(a)-1)&~((a)-1))
1275
1276 #ifndef page_count
1277 #define page_count(p) atomic_read(&(p)->count)
1278 #endif
1279
1280 #ifdef MAX_NUMNODES
1281 #undef MAX_NUMNODES
1282 #endif
1283 #define MAX_NUMNODES 1
1284
1285 /* find_first_bit and find_next bit are not defined for most
1286  * 2.4 kernels (except for the redhat 2.4.21 kernels
1287  */
1288 #include <linux/bitops.h>
1289 #define BITOP_WORD(nr)          ((nr) / BITS_PER_LONG)
1290 #undef find_next_bit
1291 #define find_next_bit _kc_find_next_bit
1292 extern unsigned long _kc_find_next_bit(const unsigned long *addr,
1293                                        unsigned long size,
1294                                        unsigned long offset);
1295 #define find_first_bit(addr, size) find_next_bit((addr), (size), 0)
1296
1297
1298 #ifndef netdev_name
1299 static inline const char *_kc_netdev_name(const struct net_device *dev)
1300 {
1301         if (strchr(dev->name, '%'))
1302                 return "(unregistered net_device)";
1303         return dev->name;
1304 }
1305 #define netdev_name(netdev)     _kc_netdev_name(netdev)
1306 #endif /* netdev_name */
1307
1308 #ifndef strlcpy
1309 #define strlcpy _kc_strlcpy
1310 extern size_t _kc_strlcpy(char *dest, const char *src, size_t size);
1311 #endif /* strlcpy */
1312
1313 #endif /* 2.6.0 => 2.5.28 */
1314
1315 /*****************************************************************************/
1316 /* 2.6.4 => 2.6.0 */
1317 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,4) )
1318 #define MODULE_VERSION(_version) MODULE_INFO(version, _version)
1319 #endif /* 2.6.4 => 2.6.0 */
1320
1321 /*****************************************************************************/
1322 /* 2.6.5 => 2.6.0 */
1323 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,5) )
1324 #define dma_sync_single_for_cpu         dma_sync_single
1325 #define dma_sync_single_for_device      dma_sync_single
1326 #define dma_sync_single_range_for_cpu           dma_sync_single_range
1327 #define dma_sync_single_range_for_device        dma_sync_single_range
1328 #ifndef pci_dma_mapping_error
1329 #define pci_dma_mapping_error _kc_pci_dma_mapping_error
1330 static inline int _kc_pci_dma_mapping_error(dma_addr_t dma_addr)
1331 {
1332         return dma_addr == 0;
1333 }
1334 #endif
1335 #endif /* 2.6.5 => 2.6.0 */
1336
1337 /*****************************************************************************/
1338 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,4) )
1339 extern int _kc_scnprintf(char * buf, size_t size, const char *fmt, ...);
1340 #define scnprintf(buf, size, fmt, args...) _kc_scnprintf(buf, size, fmt, ##args)
1341 #endif /* < 2.6.4 */
1342
1343 /*****************************************************************************/
1344 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,6) )
1345 /* taken from 2.6 include/linux/bitmap.h */
1346 #undef bitmap_zero
1347 #define bitmap_zero _kc_bitmap_zero
1348 static inline void _kc_bitmap_zero(unsigned long *dst, int nbits)
1349 {
1350         if (nbits <= BITS_PER_LONG)
1351                 *dst = 0UL;
1352         else {
1353                 int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long);
1354                 memset(dst, 0, len);
1355         }
1356 }
1357 #define random_ether_addr _kc_random_ether_addr
1358 static inline void _kc_random_ether_addr(u8 *addr)
1359 {
1360         get_random_bytes(addr, ETH_ALEN);
1361         addr[0] &= 0xfe; /* clear multicast */
1362         addr[0] |= 0x02; /* set local assignment */
1363 }
1364 #define page_to_nid(x) 0
1365
1366 #endif /* < 2.6.6 */
1367
1368 /*****************************************************************************/
1369 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,7) )
1370 #undef if_mii
1371 #define if_mii _kc_if_mii
1372 static inline struct mii_ioctl_data *_kc_if_mii(struct ifreq *rq)
1373 {
1374         return (struct mii_ioctl_data *) &rq->ifr_ifru;
1375 }
1376
1377 #ifndef __force
1378 #define __force
1379 #endif
1380 #endif /* < 2.6.7 */
1381
1382 /*****************************************************************************/
1383 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,8) )
1384 #ifndef PCI_EXP_DEVCTL
1385 #define PCI_EXP_DEVCTL 8
1386 #endif
1387 #ifndef PCI_EXP_DEVCTL_CERE
1388 #define PCI_EXP_DEVCTL_CERE 0x0001
1389 #endif
1390 #define msleep(x)       do { set_current_state(TASK_UNINTERRUPTIBLE); \
1391                                 schedule_timeout((x * HZ)/1000 + 2); \
1392                         } while (0)
1393
1394 #endif /* < 2.6.8 */
1395
1396 /*****************************************************************************/
1397 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,9))
1398 #include <net/dsfield.h>
1399 #define __iomem
1400
1401 #ifndef kcalloc
1402 #define kcalloc(n, size, flags) _kc_kzalloc(((n) * (size)), flags)
1403 extern void *_kc_kzalloc(size_t size, int flags);
1404 #endif
1405 #define MSEC_PER_SEC    1000L
1406 static inline unsigned int _kc_jiffies_to_msecs(const unsigned long j)
1407 {
1408 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
1409         return (MSEC_PER_SEC / HZ) * j;
1410 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
1411         return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC);
1412 #else
1413         return (j * MSEC_PER_SEC) / HZ;
1414 #endif
1415 }
1416 static inline unsigned long _kc_msecs_to_jiffies(const unsigned int m)
1417 {
1418         if (m > _kc_jiffies_to_msecs(MAX_JIFFY_OFFSET))
1419                 return MAX_JIFFY_OFFSET;
1420 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
1421         return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);
1422 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
1423         return m * (HZ / MSEC_PER_SEC);
1424 #else
1425         return (m * HZ + MSEC_PER_SEC - 1) / MSEC_PER_SEC;
1426 #endif
1427 }
1428
1429 #define msleep_interruptible _kc_msleep_interruptible
1430 static inline unsigned long _kc_msleep_interruptible(unsigned int msecs)
1431 {
1432         unsigned long timeout = _kc_msecs_to_jiffies(msecs) + 1;
1433
1434         while (timeout && !signal_pending(current)) {
1435                 __set_current_state(TASK_INTERRUPTIBLE);
1436                 timeout = schedule_timeout(timeout);
1437         }
1438         return _kc_jiffies_to_msecs(timeout);
1439 }
1440
1441 /* Basic mode control register. */
1442 #define BMCR_SPEED1000          0x0040  /* MSB of Speed (1000)         */
1443
1444 #ifndef __le16
1445 #define __le16 u16
1446 #endif
1447 #ifndef __le32
1448 #define __le32 u32
1449 #endif
1450 #ifndef __le64
1451 #define __le64 u64
1452 #endif
1453 #ifndef __be16
1454 #define __be16 u16
1455 #endif
1456 #ifndef __be32
1457 #define __be32 u32
1458 #endif
1459 #ifndef __be64
1460 #define __be64 u64
1461 #endif
1462
1463 static inline struct vlan_ethhdr *vlan_eth_hdr(const struct sk_buff *skb)
1464 {
1465         return (struct vlan_ethhdr *)skb->mac.raw;
1466 }
1467
1468 /* Wake-On-Lan options. */
1469 #define WAKE_PHY                (1 << 0)
1470 #define WAKE_UCAST              (1 << 1)
1471 #define WAKE_MCAST              (1 << 2)
1472 #define WAKE_BCAST              (1 << 3)
1473 #define WAKE_ARP                (1 << 4)
1474 #define WAKE_MAGIC              (1 << 5)
1475 #define WAKE_MAGICSECURE        (1 << 6) /* only meaningful if WAKE_MAGIC */
1476
1477 #define skb_header_pointer _kc_skb_header_pointer
1478 static inline void *_kc_skb_header_pointer(const struct sk_buff *skb,
1479                                             int offset, int len, void *buffer)
1480 {
1481         int hlen = skb_headlen(skb);
1482
1483         if (hlen - offset >= len)
1484                 return skb->data + offset;
1485
1486 #ifdef MAX_SKB_FRAGS
1487         if (skb_copy_bits(skb, offset, buffer, len) < 0)
1488                 return NULL;
1489
1490         return buffer;
1491 #else
1492         return NULL;
1493 #endif
1494
1495 #ifndef NETDEV_TX_OK
1496 #define NETDEV_TX_OK 0
1497 #endif
1498 #ifndef NETDEV_TX_BUSY
1499 #define NETDEV_TX_BUSY 1
1500 #endif
1501 #ifndef NETDEV_TX_LOCKED
1502 #define NETDEV_TX_LOCKED -1
1503 #endif
1504 }
1505
1506 #ifndef __bitwise
1507 #define __bitwise
1508 #endif
1509 #endif /* < 2.6.9 */
1510
1511 /*****************************************************************************/
1512 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) )
1513 #ifdef module_param_array_named
1514 #undef module_param_array_named
1515 #define module_param_array_named(name, array, type, nump, perm)          \
1516         static struct kparam_array __param_arr_##name                    \
1517         = { ARRAY_SIZE(array), nump, param_set_##type, param_get_##type, \
1518             sizeof(array[0]), array };                                   \
1519         module_param_call(name, param_array_set, param_array_get,        \
1520                           &__param_arr_##name, perm)
1521 #endif /* module_param_array_named */
1522 /*
1523  * num_online is broken for all < 2.6.10 kernels.  This is needed to support
1524  * Node module parameter of ixgbe.
1525  */
1526 #undef num_online_nodes
1527 #define num_online_nodes(n) 1
1528 extern DECLARE_BITMAP(_kcompat_node_online_map, MAX_NUMNODES);
1529 #undef node_online_map
1530 #define node_online_map _kcompat_node_online_map
1531 #endif /* < 2.6.10 */
1532
1533 /*****************************************************************************/
1534 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,11) )
1535 #define PCI_D0      0
1536 #define PCI_D1      1
1537 #define PCI_D2      2
1538 #define PCI_D3hot   3
1539 #define PCI_D3cold  4
1540 typedef int pci_power_t;
1541 #define pci_choose_state(pdev,state) state
1542 #define PMSG_SUSPEND 3
1543 #define PCI_EXP_LNKCTL  16
1544
1545 #undef NETIF_F_LLTX
1546
1547 #ifndef ARCH_HAS_PREFETCH
1548 #define prefetch(X)
1549 #endif
1550
1551 #ifndef NET_IP_ALIGN
1552 #define NET_IP_ALIGN 2
1553 #endif
1554
1555 #define KC_USEC_PER_SEC 1000000L
1556 #define usecs_to_jiffies _kc_usecs_to_jiffies
1557 static inline unsigned int _kc_jiffies_to_usecs(const unsigned long j)
1558 {
1559 #if HZ <= KC_USEC_PER_SEC && !(KC_USEC_PER_SEC % HZ)
1560         return (KC_USEC_PER_SEC / HZ) * j;
1561 #elif HZ > KC_USEC_PER_SEC && !(HZ % KC_USEC_PER_SEC)
1562         return (j + (HZ / KC_USEC_PER_SEC) - 1)/(HZ / KC_USEC_PER_SEC);
1563 #else
1564         return (j * KC_USEC_PER_SEC) / HZ;
1565 #endif
1566 }
1567 static inline unsigned long _kc_usecs_to_jiffies(const unsigned int m)
1568 {
1569         if (m > _kc_jiffies_to_usecs(MAX_JIFFY_OFFSET))
1570                 return MAX_JIFFY_OFFSET;
1571 #if HZ <= KC_USEC_PER_SEC && !(KC_USEC_PER_SEC % HZ)
1572         return (m + (KC_USEC_PER_SEC / HZ) - 1) / (KC_USEC_PER_SEC / HZ);
1573 #elif HZ > KC_USEC_PER_SEC && !(HZ % KC_USEC_PER_SEC)
1574         return m * (HZ / KC_USEC_PER_SEC);
1575 #else
1576         return (m * HZ + KC_USEC_PER_SEC - 1) / KC_USEC_PER_SEC;
1577 #endif
1578 }
1579 #endif /* < 2.6.11 */
1580
1581 /*****************************************************************************/
1582 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,12) )
1583 #include <linux/reboot.h>
1584 #define USE_REBOOT_NOTIFIER
1585
1586 /* Generic MII registers. */
1587 #define MII_CTRL1000        0x09        /* 1000BASE-T control          */
1588 #define MII_STAT1000        0x0a        /* 1000BASE-T status           */
1589 /* Advertisement control register. */
1590 #define ADVERTISE_PAUSE_CAP     0x0400  /* Try for pause               */
1591 #define ADVERTISE_PAUSE_ASYM    0x0800  /* Try for asymmetric pause     */
1592 /* 1000BASE-T Control register */
1593 #define ADVERTISE_1000FULL      0x0200  /* Advertise 1000BASE-T full duplex */
1594 #ifndef is_zero_ether_addr
1595 #define is_zero_ether_addr _kc_is_zero_ether_addr
1596 static inline int _kc_is_zero_ether_addr(const u8 *addr)
1597 {
1598         return !(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5]);
1599 }
1600 #endif /* is_zero_ether_addr */
1601 #ifndef is_multicast_ether_addr
1602 #define is_multicast_ether_addr _kc_is_multicast_ether_addr
1603 static inline int _kc_is_multicast_ether_addr(const u8 *addr)
1604 {
1605         return addr[0] & 0x01;
1606 }
1607 #endif /* is_multicast_ether_addr */
1608 #endif /* < 2.6.12 */
1609
1610 /*****************************************************************************/
1611 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,13) )
1612 #ifndef kstrdup
1613 #define kstrdup _kc_kstrdup
1614 extern char *_kc_kstrdup(const char *s, unsigned int gfp);
1615 #endif
1616 #endif /* < 2.6.13 */
1617
1618 /*****************************************************************************/
1619 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14) )
1620 #define pm_message_t u32
1621 #ifndef kzalloc
1622 #define kzalloc _kc_kzalloc
1623 extern void *_kc_kzalloc(size_t size, int flags);
1624 #endif
1625
1626 /* Generic MII registers. */
1627 #define MII_ESTATUS         0x0f        /* Extended Status */
1628 /* Basic mode status register. */
1629 #define BMSR_ESTATEN            0x0100  /* Extended Status in R15 */
1630 /* Extended status register. */
1631 #define ESTATUS_1000_TFULL      0x2000  /* Can do 1000BT Full */
1632 #define ESTATUS_1000_THALF      0x1000  /* Can do 1000BT Half */
1633
1634 #define ADVERTISED_Pause        (1 << 13)
1635 #define ADVERTISED_Asym_Pause   (1 << 14)
1636
1637 #if (!(RHEL_RELEASE_CODE && \
1638        (RHEL_RELEASE_CODE > RHEL_RELEASE_VERSION(4,3)) && \
1639        (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(5,0))))
1640 #if ((LINUX_VERSION_CODE == KERNEL_VERSION(2,6,9)) && !defined(gfp_t))
1641 #define gfp_t unsigned
1642 #else
1643 typedef unsigned gfp_t;
1644 #endif
1645 #endif /* !RHEL4.3->RHEL5.0 */
1646
1647 #if ( LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,9) )
1648 #ifdef CONFIG_X86_64
1649 #define dma_sync_single_range_for_cpu(dev, dma_handle, offset, size, dir)       \
1650         dma_sync_single_for_cpu(dev, dma_handle, size, dir)
1651 #define dma_sync_single_range_for_device(dev, dma_handle, offset, size, dir)    \
1652         dma_sync_single_for_device(dev, dma_handle, size, dir)
1653 #endif
1654 #endif
1655 #endif /* < 2.6.14 */
1656
1657 /*****************************************************************************/
1658 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,15) )
1659 #ifndef vmalloc_node
1660 #define vmalloc_node(a,b) vmalloc(a)
1661 #endif /* vmalloc_node*/
1662
1663 #define setup_timer(_timer, _function, _data) \
1664 do { \
1665         (_timer)->function = _function; \
1666         (_timer)->data = _data; \
1667         init_timer(_timer); \
1668 } while (0)
1669 #ifndef device_can_wakeup
1670 #define device_can_wakeup(dev)  (1)
1671 #endif
1672 #ifndef device_set_wakeup_enable
1673 #define device_set_wakeup_enable(dev, val)      do{}while(0)
1674 #endif
1675 #ifndef device_init_wakeup
1676 #define device_init_wakeup(dev,val) do {} while (0)
1677 #endif
1678 static inline unsigned _kc_compare_ether_addr(const u8 *addr1, const u8 *addr2)
1679 {
1680         const u16 *a = (const u16 *) addr1;
1681         const u16 *b = (const u16 *) addr2;
1682
1683         return ((a[0] ^ b[0]) | (a[1] ^ b[1]) | (a[2] ^ b[2])) != 0;
1684 }
1685 #undef compare_ether_addr
1686 #define compare_ether_addr(addr1, addr2) _kc_compare_ether_addr(addr1, addr2)
1687 #endif /* < 2.6.15 */
1688
1689 /*****************************************************************************/
1690 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,16) )
1691 #undef DEFINE_MUTEX
1692 #define DEFINE_MUTEX(x) DECLARE_MUTEX(x)
1693 #define mutex_lock(x)   down_interruptible(x)
1694 #define mutex_unlock(x) up(x)
1695
1696 #ifndef ____cacheline_internodealigned_in_smp
1697 #ifdef CONFIG_SMP
1698 #define ____cacheline_internodealigned_in_smp ____cacheline_aligned_in_smp
1699 #else
1700 #define ____cacheline_internodealigned_in_smp
1701 #endif /* CONFIG_SMP */
1702 #endif /* ____cacheline_internodealigned_in_smp */
1703 #undef HAVE_PCI_ERS
1704 #else /* 2.6.16 and above */
1705 #undef HAVE_PCI_ERS
1706 #define HAVE_PCI_ERS
1707 #endif /* < 2.6.16 */
1708
1709 /*****************************************************************************/
1710 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,17) )
1711 #ifndef first_online_node
1712 #define first_online_node 0
1713 #endif
1714 #ifndef NET_SKB_PAD
1715 #define NET_SKB_PAD 16
1716 #endif
1717 #endif /* < 2.6.17 */
1718
1719 /*****************************************************************************/
1720 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18) )
1721
1722 #ifndef IRQ_HANDLED
1723 #define irqreturn_t void
1724 #define IRQ_HANDLED
1725 #define IRQ_NONE
1726 #endif
1727
1728 #ifndef IRQF_PROBE_SHARED
1729 #ifdef SA_PROBEIRQ
1730 #define IRQF_PROBE_SHARED SA_PROBEIRQ
1731 #else
1732 #define IRQF_PROBE_SHARED 0
1733 #endif
1734 #endif
1735
1736 #ifndef IRQF_SHARED
1737 #define IRQF_SHARED SA_SHIRQ
1738 #endif
1739
1740 #ifndef ARRAY_SIZE
1741 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
1742 #endif
1743
1744 #ifndef FIELD_SIZEOF
1745 #define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f))
1746 #endif
1747
1748 #ifndef skb_is_gso
1749 #ifdef NETIF_F_TSO
1750 #define skb_is_gso _kc_skb_is_gso
1751 static inline int _kc_skb_is_gso(const struct sk_buff *skb)
1752 {
1753         return skb_shinfo(skb)->gso_size;
1754 }
1755 #else
1756 #define skb_is_gso(a) 0
1757 #endif
1758 #endif
1759
1760 #ifndef resource_size_t
1761 #define resource_size_t unsigned long
1762 #endif
1763
1764 #ifdef skb_pad
1765 #undef skb_pad
1766 #endif
1767 #define skb_pad(x,y) _kc_skb_pad(x, y)
1768 int _kc_skb_pad(struct sk_buff *skb, int pad);
1769 #ifdef skb_padto
1770 #undef skb_padto
1771 #endif
1772 #define skb_padto(x,y) _kc_skb_padto(x, y)
1773 static inline int _kc_skb_padto(struct sk_buff *skb, unsigned int len)
1774 {
1775         unsigned int size = skb->len;
1776         if(likely(size >= len))
1777                 return 0;
1778         return _kc_skb_pad(skb, len - size);
1779 }
1780
1781 #ifndef DECLARE_PCI_UNMAP_ADDR
1782 #define DECLARE_PCI_UNMAP_ADDR(ADDR_NAME) \
1783         dma_addr_t ADDR_NAME
1784 #define DECLARE_PCI_UNMAP_LEN(LEN_NAME) \
1785         u32 LEN_NAME
1786 #define pci_unmap_addr(PTR, ADDR_NAME) \
1787         ((PTR)->ADDR_NAME)
1788 #define pci_unmap_addr_set(PTR, ADDR_NAME, VAL) \
1789         (((PTR)->ADDR_NAME) = (VAL))
1790 #define pci_unmap_len(PTR, LEN_NAME) \
1791         ((PTR)->LEN_NAME)
1792 #define pci_unmap_len_set(PTR, LEN_NAME, VAL) \
1793         (((PTR)->LEN_NAME) = (VAL))
1794 #endif /* DECLARE_PCI_UNMAP_ADDR */
1795 #endif /* < 2.6.18 */
1796
1797 /*****************************************************************************/
1798 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19) )
1799
1800 #ifndef DIV_ROUND_UP
1801 #define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
1802 #endif
1803 #if ( LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0) )
1804 #if (!((RHEL_RELEASE_CODE && \
1805         ((RHEL_RELEASE_CODE > RHEL_RELEASE_VERSION(4,4) && \
1806           RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(5,0)) || \
1807          (RHEL_RELEASE_CODE > RHEL_RELEASE_VERSION(5,0)))) || \
1808        (AX_RELEASE_CODE && AX_RELEASE_CODE > AX_RELEASE_VERSION(3,0))))
1809 typedef irqreturn_t (*irq_handler_t)(int, void*, struct pt_regs *);
1810 #endif
1811 #if (RHEL_RELEASE_CODE && RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(6,0))
1812 #undef CONFIG_INET_LRO
1813 #undef CONFIG_INET_LRO_MODULE
1814 #undef CONFIG_FCOE
1815 #undef CONFIG_FCOE_MODULE
1816 #endif
1817 typedef irqreturn_t (*new_handler_t)(int, void*);
1818 static inline irqreturn_t _kc_request_irq(unsigned int irq, new_handler_t handler, unsigned long flags, const char *devname, void *dev_id)
1819 #else /* 2.4.x */
1820 typedef void (*irq_handler_t)(int, void*, struct pt_regs *);
1821 typedef void (*new_handler_t)(int, void*);
1822 static inline int _kc_request_irq(unsigned int irq, new_handler_t handler, unsigned long flags, const char *devname, void *dev_id)
1823 #endif /* >= 2.5.x */
1824 {
1825         irq_handler_t new_handler = (irq_handler_t) handler;
1826         return request_irq(irq, new_handler, flags, devname, dev_id);
1827 }
1828
1829 #undef request_irq
1830 #define request_irq(irq, handler, flags, devname, dev_id) _kc_request_irq((irq), (handler), (flags), (devname), (dev_id))
1831
1832 #define irq_handler_t new_handler_t
1833 /* pci_restore_state and pci_save_state handles MSI/PCIE from 2.6.19 */
1834 #if (!(RHEL_RELEASE_CODE && RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(5,4)))
1835 #define PCIE_CONFIG_SPACE_LEN 256
1836 #define PCI_CONFIG_SPACE_LEN 64
1837 #define PCIE_LINK_STATUS 0x12
1838 #define pci_config_space_ich8lan() do {} while(0)
1839 #undef pci_save_state
1840 extern int _kc_pci_save_state(struct pci_dev *);
1841 #define pci_save_state(pdev) _kc_pci_save_state(pdev)
1842 #undef pci_restore_state
1843 extern void _kc_pci_restore_state(struct pci_dev *);
1844 #define pci_restore_state(pdev) _kc_pci_restore_state(pdev)
1845 #endif /* !(RHEL_RELEASE_CODE >= RHEL 5.4) */
1846
1847 #ifdef HAVE_PCI_ERS
1848 #undef free_netdev
1849 extern void _kc_free_netdev(struct net_device *);
1850 #define free_netdev(netdev) _kc_free_netdev(netdev)
1851 #endif
1852 static inline int pci_enable_pcie_error_reporting(struct pci_dev *dev)
1853 {
1854         return 0;
1855 }
1856 #define pci_disable_pcie_error_reporting(dev) do {} while (0)
1857 #define pci_cleanup_aer_uncorrect_error_status(dev) do {} while (0)
1858
1859 extern void *_kc_kmemdup(const void *src, size_t len, unsigned gfp);
1860 #define kmemdup(src, len, gfp) _kc_kmemdup(src, len, gfp)
1861 #ifndef bool
1862 #define bool _Bool
1863 #define true 1
1864 #define false 0
1865 #endif
1866 #else /* 2.6.19 */
1867 #include <linux/aer.h>
1868 #include <linux/string.h>
1869 #endif /* < 2.6.19 */
1870
1871 /*****************************************************************************/
1872 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20) )
1873 #if ( LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,28) )
1874 #undef INIT_WORK
1875 #define INIT_WORK(_work, _func) \
1876 do { \
1877         INIT_LIST_HEAD(&(_work)->entry); \
1878         (_work)->pending = 0; \
1879         (_work)->func = (void (*)(void *))_func; \
1880         (_work)->data = _work; \
1881         init_timer(&(_work)->timer); \
1882 } while (0)
1883 #endif
1884
1885 #ifndef PCI_VDEVICE
1886 #define PCI_VDEVICE(ven, dev)        \
1887         PCI_VENDOR_ID_##ven, (dev),  \
1888         PCI_ANY_ID, PCI_ANY_ID, 0, 0
1889 #endif
1890
1891 #ifndef round_jiffies
1892 #define round_jiffies(x) x
1893 #endif
1894
1895 #define csum_offset csum
1896
1897 #define HAVE_EARLY_VMALLOC_NODE
1898 #define dev_to_node(dev) -1
1899 #undef set_dev_node
1900 /* remove compiler warning with b=b, for unused variable */
1901 #define set_dev_node(a, b) do { (b) = (b); } while(0)
1902
1903 #if (!(RHEL_RELEASE_CODE && \
1904        (((RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(4,7)) && \
1905          (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(5,0))) || \
1906         (RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(5,6)))) && \
1907      !(SLE_VERSION_CODE && SLE_VERSION_CODE >= SLE_VERSION(10,2,0)))
1908 typedef __u16 __bitwise __sum16;
1909 typedef __u32 __bitwise __wsum;
1910 #endif
1911
1912 #if (!(RHEL_RELEASE_CODE && \
1913        (((RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(4,7)) && \
1914          (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(5,0))) || \
1915         (RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(5,4)))) && \
1916      !(SLE_VERSION_CODE && SLE_VERSION_CODE >= SLE_VERSION(10,2,0)))
1917 static inline __wsum csum_unfold(__sum16 n)
1918 {
1919         return (__force __wsum)n;
1920 }
1921 #endif
1922
1923 #else /* < 2.6.20 */
1924 #define HAVE_DEVICE_NUMA_NODE
1925 #endif /* < 2.6.20 */
1926
1927 /*****************************************************************************/
1928 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21) )
1929 #define to_net_dev(class) container_of(class, struct net_device, class_dev)
1930 #define NETDEV_CLASS_DEV
1931 #if (!(RHEL_RELEASE_CODE && RHEL_RELEASE_CODE > RHEL_RELEASE_VERSION(5,5)))
1932 #define vlan_group_get_device(vg, id) (vg->vlan_devices[id])
1933 #define vlan_group_set_device(vg, id, dev)              \
1934         do {                                            \
1935                 if (vg) vg->vlan_devices[id] = dev;     \
1936         } while (0)
1937 #endif /* !(RHEL_RELEASE_CODE > RHEL_RELEASE_VERSION(5,5)) */
1938 #define pci_channel_offline(pdev) (pdev->error_state && \
1939         pdev->error_state != pci_channel_io_normal)
1940 #define pci_request_selected_regions(pdev, bars, name) \
1941         pci_request_regions(pdev, name)
1942 #define pci_release_selected_regions(pdev, bars) pci_release_regions(pdev);
1943 #endif /* < 2.6.21 */
1944
1945 /*****************************************************************************/
1946 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22) )
1947 #define tcp_hdr(skb) (skb->h.th)
1948 #define tcp_hdrlen(skb) (skb->h.th->doff << 2)
1949 #define skb_transport_offset(skb) (skb->h.raw - skb->data)
1950 #define skb_transport_header(skb) (skb->h.raw)
1951 #define ipv6_hdr(skb) (skb->nh.ipv6h)
1952 #define ip_hdr(skb) (skb->nh.iph)
1953 #define skb_network_offset(skb) (skb->nh.raw - skb->data)
1954 #define skb_network_header(skb) (skb->nh.raw)
1955 #define skb_tail_pointer(skb) skb->tail
1956 #define skb_reset_tail_pointer(skb) \
1957         do { \
1958                 skb->tail = skb->data; \
1959         } while (0)
1960 #define skb_copy_to_linear_data(skb, from, len) \
1961                                 memcpy(skb->data, from, len)
1962 #define skb_copy_to_linear_data_offset(skb, offset, from, len) \
1963                                 memcpy(skb->data + offset, from, len)
1964 #define skb_network_header_len(skb) (skb->h.raw - skb->nh.raw)
1965 #define pci_register_driver pci_module_init
1966 #define skb_mac_header(skb) skb->mac.raw
1967
1968 #ifdef NETIF_F_MULTI_QUEUE
1969 #ifndef alloc_etherdev_mq
1970 #define alloc_etherdev_mq(_a, _b) alloc_etherdev(_a)
1971 #endif
1972 #endif /* NETIF_F_MULTI_QUEUE */
1973
1974 #ifndef ETH_FCS_LEN
1975 #define ETH_FCS_LEN 4
1976 #endif
1977 #define cancel_work_sync(x) flush_scheduled_work()
1978 #ifndef udp_hdr
1979 #define udp_hdr _udp_hdr
1980 static inline struct udphdr *_udp_hdr(const struct sk_buff *skb)
1981 {
1982         return (struct udphdr *)skb_transport_header(skb);
1983 }
1984 #endif
1985
1986 #ifdef cpu_to_be16
1987 #undef cpu_to_be16
1988 #endif
1989 #define cpu_to_be16(x) __constant_htons(x)
1990
1991 #if (!(RHEL_RELEASE_CODE && RHEL_RELEASE_CODE > RHEL_RELEASE_VERSION(5,1)))
1992 enum {
1993         DUMP_PREFIX_NONE,
1994         DUMP_PREFIX_ADDRESS,
1995         DUMP_PREFIX_OFFSET
1996 };
1997 #endif /* !(RHEL_RELEASE_CODE > RHEL_RELEASE_VERSION(5,1)) */
1998 #ifndef hex_asc
1999 #define hex_asc(x)      "0123456789abcdef"[x]
2000 #endif
2001 #include <linux/ctype.h>
2002 extern void _kc_print_hex_dump(const char *level, const char *prefix_str,
2003                                int prefix_type, int rowsize, int groupsize,
2004                                const void *buf, size_t len, bool ascii);
2005 #define print_hex_dump(lvl, s, t, r, g, b, l, a) \
2006                 _kc_print_hex_dump(lvl, s, t, r, g, b, l, a)
2007 #else /* 2.6.22 */
2008 #define ETH_TYPE_TRANS_SETS_DEV
2009 #define HAVE_NETDEV_STATS_IN_NETDEV
2010 #endif /* < 2.6.22 */
2011
2012 /*****************************************************************************/
2013 #if ( LINUX_VERSION_CODE > KERNEL_VERSION(2,6,22) )
2014 #endif /* > 2.6.22 */
2015
2016 /*****************************************************************************/
2017 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23) )
2018 #define netif_subqueue_stopped(_a, _b) 0
2019 #ifndef PTR_ALIGN
2020 #define PTR_ALIGN(p, a)         ((typeof(p))ALIGN((unsigned long)(p), (a)))
2021 #endif
2022
2023 #ifndef CONFIG_PM_SLEEP
2024 #define CONFIG_PM_SLEEP CONFIG_PM
2025 #endif
2026
2027 #if ( LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13) )
2028 #define HAVE_ETHTOOL_GET_PERM_ADDR
2029 #endif /* 2.6.14 through 2.6.22 */
2030 #endif /* < 2.6.23 */
2031
2032 /*****************************************************************************/
2033 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24) )
2034 #ifndef ETH_FLAG_LRO
2035 #define ETH_FLAG_LRO NETIF_F_LRO
2036 #endif
2037
2038 /* if GRO is supported then the napi struct must already exist */
2039 #ifndef NETIF_F_GRO
2040 /* NAPI API changes in 2.6.24 break everything */
2041 struct napi_struct {
2042         /* used to look up the real NAPI polling routine */
2043         int (*poll)(struct napi_struct *, int);
2044         struct net_device *dev;
2045         int weight;
2046 };
2047 #endif
2048
2049 #ifdef NAPI
2050 extern int __kc_adapter_clean(struct net_device *, int *);
2051 extern struct net_device *napi_to_poll_dev(struct napi_struct *napi);
2052 #define netif_napi_add(_netdev, _napi, _poll, _weight) \
2053         do { \
2054                 struct napi_struct *__napi = (_napi); \
2055                 struct net_device *poll_dev = napi_to_poll_dev(__napi); \
2056                 poll_dev->poll = &(__kc_adapter_clean); \
2057                 poll_dev->priv = (_napi); \
2058                 poll_dev->weight = (_weight); \
2059                 set_bit(__LINK_STATE_RX_SCHED, &poll_dev->state); \
2060                 set_bit(__LINK_STATE_START, &poll_dev->state);\
2061                 dev_hold(poll_dev); \
2062                 __napi->poll = &(_poll); \
2063                 __napi->weight = (_weight); \
2064                 __napi->dev = (_netdev); \
2065         } while (0)
2066 #define netif_napi_del(_napi) \
2067         do { \
2068                 struct net_device *poll_dev = napi_to_poll_dev(_napi); \
2069                 WARN_ON(!test_bit(__LINK_STATE_RX_SCHED, &poll_dev->state)); \
2070                 dev_put(poll_dev); \
2071                 memset(poll_dev, 0, sizeof(struct net_device));\
2072         } while (0)
2073 #define napi_schedule_prep(_napi) \
2074         (netif_running((_napi)->dev) && netif_rx_schedule_prep(napi_to_poll_dev(_napi)))
2075 #define napi_schedule(_napi) \
2076         do { \
2077                 if (napi_schedule_prep(_napi)) \
2078                         __netif_rx_schedule(napi_to_poll_dev(_napi)); \
2079         } while (0)
2080 #define napi_enable(_napi) netif_poll_enable(napi_to_poll_dev(_napi))
2081 #define napi_disable(_napi) netif_poll_disable(napi_to_poll_dev(_napi))
2082 #define __napi_schedule(_napi) __netif_rx_schedule(napi_to_poll_dev(_napi))
2083 #ifndef NETIF_F_GRO
2084 #define napi_complete(_napi) netif_rx_complete(napi_to_poll_dev(_napi))
2085 #else
2086 #define napi_complete(_napi) \
2087         do { \
2088                 napi_gro_flush(_napi); \
2089                 netif_rx_complete(napi_to_poll_dev(_napi)); \
2090         } while (0)
2091 #endif /* NETIF_F_GRO */
2092 #else /* NAPI */
2093 #define netif_napi_add(_netdev, _napi, _poll, _weight) \
2094         do { \
2095                 struct napi_struct *__napi = _napi; \
2096                 _netdev->poll = &(_poll); \
2097                 _netdev->weight = (_weight); \
2098                 __napi->poll = &(_poll); \
2099                 __napi->weight = (_weight); \
2100                 __napi->dev = (_netdev); \
2101         } while (0)
2102 #define netif_napi_del(_a) do {} while (0)
2103 #endif /* NAPI */
2104
2105 #undef dev_get_by_name
2106 #define dev_get_by_name(_a, _b) dev_get_by_name(_b)
2107 #define __netif_subqueue_stopped(_a, _b) netif_subqueue_stopped(_a, _b)
2108 #ifndef DMA_BIT_MASK
2109 #define DMA_BIT_MASK(n) (((n) == 64) ? DMA_64BIT_MASK : ((1ULL<<(n))-1))
2110 #endif
2111
2112 #ifdef NETIF_F_TSO6
2113 #define skb_is_gso_v6 _kc_skb_is_gso_v6
2114 static inline int _kc_skb_is_gso_v6(const struct sk_buff *skb)
2115 {
2116         return skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6;
2117 }
2118 #endif /* NETIF_F_TSO6 */
2119
2120 #ifndef KERN_CONT
2121 #define KERN_CONT       ""
2122 #endif
2123 #else /* < 2.6.24 */
2124 #define HAVE_ETHTOOL_GET_SSET_COUNT
2125 #define HAVE_NETDEV_NAPI_LIST
2126 #endif /* < 2.6.24 */
2127
2128 /*****************************************************************************/
2129 #if ( LINUX_VERSION_CODE > KERNEL_VERSION(2,6,24) )
2130 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(3,2,0) )
2131 #include <linux/pm_qos_params.h>
2132 #else /* >= 3.2.0 */
2133 #include <linux/pm_qos.h>
2134 #endif /* else >= 3.2.0 */
2135 #endif /* > 2.6.24 */
2136
2137 /*****************************************************************************/
2138 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25) )
2139 #define PM_QOS_CPU_DMA_LATENCY  1
2140
2141 #if ( LINUX_VERSION_CODE > KERNEL_VERSION(2,6,18) )
2142 #include <linux/latency.h>
2143 #define PM_QOS_DEFAULT_VALUE    INFINITE_LATENCY
2144 #define pm_qos_add_requirement(pm_qos_class, name, value) \
2145                 set_acceptable_latency(name, value)
2146 #define pm_qos_remove_requirement(pm_qos_class, name) \
2147                 remove_acceptable_latency(name)
2148 #define pm_qos_update_requirement(pm_qos_class, name, value) \
2149                 modify_acceptable_latency(name, value)
2150 #else
2151 #define PM_QOS_DEFAULT_VALUE    -1
2152 #define pm_qos_add_requirement(pm_qos_class, name, value)
2153 #define pm_qos_remove_requirement(pm_qos_class, name)
2154 #define pm_qos_update_requirement(pm_qos_class, name, value) { \
2155         if (value != PM_QOS_DEFAULT_VALUE) { \
2156                 printk(KERN_WARNING "%s: unable to set PM QoS requirement\n", \
2157                         pci_name(adapter->pdev)); \
2158         } \
2159 }
2160
2161 #endif /* > 2.6.18 */
2162
2163 #define pci_enable_device_mem(pdev) pci_enable_device(pdev)
2164
2165 #ifndef DEFINE_PCI_DEVICE_TABLE
2166 #define DEFINE_PCI_DEVICE_TABLE(_table) struct pci_device_id _table[]
2167 #endif /* DEFINE_PCI_DEVICE_TABLE */
2168
2169 #if ( LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) )
2170 #ifndef IXGBE_PROCFS
2171 #define IXGBE_PROCFS
2172 #endif /* IXGBE_PROCFS */
2173 #endif /* >= 2.6.0 */
2174
2175
2176 #else /* < 2.6.25 */
2177
2178 #ifndef IXGBE_SYSFS
2179 #define IXGBE_SYSFS
2180 #endif /* IXGBE_SYSFS */
2181
2182
2183 #endif /* < 2.6.25 */
2184
2185 /*****************************************************************************/
2186 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26) )
2187 #ifndef clamp_t
2188 #define clamp_t(type, val, min, max) ({         \
2189         type __val = (val);                     \
2190         type __min = (min);                     \
2191         type __max = (max);                     \
2192         __val = __val < __min ? __min : __val;  \
2193         __val > __max ? __max : __val; })
2194 #endif /* clamp_t */
2195 #ifdef NETIF_F_TSO
2196 #ifdef NETIF_F_TSO6
2197 #define netif_set_gso_max_size(_netdev, size) \
2198         do { \
2199                 if (adapter->flags & IXGBE_FLAG_DCB_ENABLED) { \
2200                         _netdev->features &= ~NETIF_F_TSO; \
2201                         _netdev->features &= ~NETIF_F_TSO6; \
2202                 } else { \
2203                         _netdev->features |= NETIF_F_TSO; \
2204                         _netdev->features |= NETIF_F_TSO6; \
2205                 } \
2206         } while (0)
2207 #else /* NETIF_F_TSO6 */
2208 #define netif_set_gso_max_size(_netdev, size) \
2209         do { \
2210                 if (adapter->flags & IXGBE_FLAG_DCB_ENABLED) \
2211                         _netdev->features &= ~NETIF_F_TSO; \
2212                 else \
2213                         _netdev->features |= NETIF_F_TSO; \
2214         } while (0)
2215 #endif /* NETIF_F_TSO6 */
2216 #else
2217 #define netif_set_gso_max_size(_netdev, size) do {} while (0)
2218 #endif /* NETIF_F_TSO */
2219 #undef kzalloc_node
2220 #define kzalloc_node(_size, _flags, _node) kzalloc(_size, _flags)
2221
2222 extern void _kc_pci_disable_link_state(struct pci_dev *dev, int state);
2223 #define pci_disable_link_state(p, s) _kc_pci_disable_link_state(p, s)
2224 #else /* < 2.6.26 */
2225 #include <linux/pci-aspm.h>
2226 #define HAVE_NETDEV_VLAN_FEATURES
2227 #endif /* < 2.6.26 */
2228 /*****************************************************************************/
2229 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27) )
2230 static inline void _kc_ethtool_cmd_speed_set(struct ethtool_cmd *ep,
2231                                              __u32 speed)
2232 {
2233         ep->speed = (__u16)speed;
2234         /* ep->speed_hi = (__u16)(speed >> 16); */
2235 }
2236 #define ethtool_cmd_speed_set _kc_ethtool_cmd_speed_set
2237
2238 static inline __u32 _kc_ethtool_cmd_speed(struct ethtool_cmd *ep)
2239 {
2240         /* no speed_hi before 2.6.27, and probably no need for it yet */
2241         return (__u32)ep->speed;
2242 }
2243 #define ethtool_cmd_speed _kc_ethtool_cmd_speed
2244
2245 #if ( LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15) )
2246 #if ((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)) && defined(CONFIG_PM))
2247 #define ANCIENT_PM 1
2248 #elif ((LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)) && \
2249        (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26)) && \
2250        defined(CONFIG_PM_SLEEP))
2251 #define NEWER_PM 1
2252 #endif
2253 #if defined(ANCIENT_PM) || defined(NEWER_PM)
2254 #undef device_set_wakeup_enable
2255 #define device_set_wakeup_enable(dev, val) \
2256         do { \
2257                 u16 pmc = 0; \
2258                 int pm = pci_find_capability(adapter->pdev, PCI_CAP_ID_PM); \
2259                 if (pm) { \
2260                         pci_read_config_word(adapter->pdev, pm + PCI_PM_PMC, \
2261                                 &pmc); \
2262                 } \
2263                 (dev)->power.can_wakeup = !!(pmc >> 11); \
2264                 (dev)->power.should_wakeup = (val && (pmc >> 11)); \
2265         } while (0)
2266 #endif /* 2.6.15-2.6.22 and CONFIG_PM or 2.6.23-2.6.25 and CONFIG_PM_SLEEP */
2267 #endif /* 2.6.15 through 2.6.27 */
2268 #ifndef netif_napi_del
2269 #define netif_napi_del(_a) do {} while (0)
2270 #ifdef NAPI
2271 #ifdef CONFIG_NETPOLL
2272 #undef netif_napi_del
2273 #define netif_napi_del(_a) list_del(&(_a)->dev_list);
2274 #endif
2275 #endif
2276 #endif /* netif_napi_del */
2277 #ifdef dma_mapping_error
2278 #undef dma_mapping_error
2279 #endif
2280 #define dma_mapping_error(dev, dma_addr) pci_dma_mapping_error(dma_addr)
2281
2282 #ifdef CONFIG_NETDEVICES_MULTIQUEUE
2283 #define HAVE_TX_MQ
2284 #endif
2285
2286 #ifdef HAVE_TX_MQ
2287 extern void _kc_netif_tx_stop_all_queues(struct net_device *);
2288 extern void _kc_netif_tx_wake_all_queues(struct net_device *);
2289 extern void _kc_netif_tx_start_all_queues(struct net_device *);
2290 #define netif_tx_stop_all_queues(a) _kc_netif_tx_stop_all_queues(a)
2291 #define netif_tx_wake_all_queues(a) _kc_netif_tx_wake_all_queues(a)
2292 #define netif_tx_start_all_queues(a) _kc_netif_tx_start_all_queues(a)
2293 #undef netif_stop_subqueue
2294 #define netif_stop_subqueue(_ndev,_qi) do { \
2295         if (netif_is_multiqueue((_ndev))) \
2296                 netif_stop_subqueue((_ndev), (_qi)); \
2297         else \
2298                 netif_stop_queue((_ndev)); \
2299         } while (0)
2300 #undef netif_start_subqueue
2301 #define netif_start_subqueue(_ndev,_qi) do { \
2302         if (netif_is_multiqueue((_ndev))) \
2303                 netif_start_subqueue((_ndev), (_qi)); \
2304         else \
2305                 netif_start_queue((_ndev)); \
2306         } while (0)
2307 #else /* HAVE_TX_MQ */
2308 #define netif_tx_stop_all_queues(a) netif_stop_queue(a)
2309 #define netif_tx_wake_all_queues(a) netif_wake_queue(a)
2310 #if ( LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12) )
2311 #define netif_tx_start_all_queues(a) netif_start_queue(a)
2312 #else
2313 #define netif_tx_start_all_queues(a) do {} while (0)
2314 #endif
2315 #define netif_stop_subqueue(_ndev,_qi) netif_stop_queue((_ndev))
2316 #define netif_start_subqueue(_ndev,_qi) netif_start_queue((_ndev))
2317 #endif /* HAVE_TX_MQ */
2318 #ifndef NETIF_F_MULTI_QUEUE
2319 #define NETIF_F_MULTI_QUEUE 0
2320 #define netif_is_multiqueue(a) 0
2321 #define netif_wake_subqueue(a, b)
2322 #endif /* NETIF_F_MULTI_QUEUE */
2323
2324 #ifndef __WARN_printf
2325 extern void __kc_warn_slowpath(const char *file, const int line,
2326                 const char *fmt, ...) __attribute__((format(printf, 3, 4)));
2327 #define __WARN_printf(arg...) __kc_warn_slowpath(__FILE__, __LINE__, arg)
2328 #endif /* __WARN_printf */
2329
2330 #ifndef WARN
2331 #define WARN(condition, format...) ({                                           \
2332         int __ret_warn_on = !!(condition);                              \
2333         if (unlikely(__ret_warn_on))                                    \
2334                 __WARN_printf(format);                                  \
2335         unlikely(__ret_warn_on);                                        \
2336 })
2337 #endif /* WARN */
2338 #else /* < 2.6.27 */
2339 #define HAVE_TX_MQ
2340 #define HAVE_NETDEV_SELECT_QUEUE
2341 #endif /* < 2.6.27 */
2342
2343 /*****************************************************************************/
2344 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28) )
2345 #define pci_ioremap_bar(pdev, bar)      ioremap(pci_resource_start(pdev, bar), \
2346                                                 pci_resource_len(pdev, bar))
2347 #define pci_wake_from_d3 _kc_pci_wake_from_d3
2348 #define pci_prepare_to_sleep _kc_pci_prepare_to_sleep
2349 extern int _kc_pci_wake_from_d3(struct pci_dev *dev, bool enable);
2350 extern int _kc_pci_prepare_to_sleep(struct pci_dev *dev);
2351 #define netdev_alloc_page(a) alloc_page(GFP_ATOMIC)
2352 #ifndef __skb_queue_head_init
2353 static inline void __kc_skb_queue_head_init(struct sk_buff_head *list)
2354 {
2355         list->prev = list->next = (struct sk_buff *)list;
2356         list->qlen = 0;
2357 }
2358 #define __skb_queue_head_init(_q) __kc_skb_queue_head_init(_q)
2359 #endif
2360 #endif /* < 2.6.28 */
2361
2362 #ifndef skb_add_rx_frag
2363 #define skb_add_rx_frag _kc_skb_add_rx_frag
2364 extern void _kc_skb_add_rx_frag(struct sk_buff *, int, struct page *, int, int);
2365 #endif
2366
2367 /*****************************************************************************/
2368 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29) )
2369 #ifndef swap
2370 #define swap(a, b) \
2371         do { typeof(a) __tmp = (a); (a) = (b); (b) = __tmp; } while (0)
2372 #endif
2373 #define pci_request_selected_regions_exclusive(pdev, bars, name) \
2374                 pci_request_selected_regions(pdev, bars, name)
2375 #ifndef CONFIG_NR_CPUS
2376 #define CONFIG_NR_CPUS 1
2377 #endif /* CONFIG_NR_CPUS */
2378 #ifndef pcie_aspm_enabled
2379 #define pcie_aspm_enabled()   (1)
2380 #endif /* pcie_aspm_enabled */
2381 #else /* < 2.6.29 */
2382 #ifndef HAVE_NET_DEVICE_OPS
2383 #define HAVE_NET_DEVICE_OPS
2384 #endif
2385 #ifdef CONFIG_DCB
2386 #define HAVE_PFC_MODE_ENABLE
2387 #endif /* CONFIG_DCB */
2388 #endif /* < 2.6.29 */
2389
2390 /*****************************************************************************/
2391 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30) )
2392 #define skb_rx_queue_recorded(a) false
2393 #define skb_get_rx_queue(a) 0
2394 #undef CONFIG_FCOE
2395 #undef CONFIG_FCOE_MODULE
2396 extern u16 _kc_skb_tx_hash(struct net_device *dev, struct sk_buff *skb);
2397 #define skb_tx_hash(n, s) _kc_skb_tx_hash(n, s)
2398 #define skb_record_rx_queue(a, b) do {} while (0)
2399 #ifndef CONFIG_PCI_IOV
2400 #undef pci_enable_sriov
2401 #define pci_enable_sriov(a, b) -ENOTSUPP
2402 #undef pci_disable_sriov
2403 #define pci_disable_sriov(a) do {} while (0)
2404 #endif /* CONFIG_PCI_IOV */
2405 #ifndef pr_cont
2406 #define pr_cont(fmt, ...) \
2407         printk(KERN_CONT fmt, ##__VA_ARGS__)
2408 #endif /* pr_cont */
2409 #else
2410 #define HAVE_ASPM_QUIRKS
2411 #endif /* < 2.6.30 */
2412
2413 /*****************************************************************************/
2414 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31) )
2415 #define ETH_P_1588 0x88F7
2416 #define ETH_P_FIP  0x8914
2417 #ifndef netdev_uc_count
2418 #define netdev_uc_count(dev) ((dev)->uc_count)
2419 #endif
2420 #ifndef netdev_for_each_uc_addr
2421 #define netdev_for_each_uc_addr(uclist, dev) \
2422         for (uclist = dev->uc_list; uclist; uclist = uclist->next)
2423 #endif
2424 #else
2425 #ifndef HAVE_NETDEV_STORAGE_ADDRESS
2426 #define HAVE_NETDEV_STORAGE_ADDRESS
2427 #endif
2428 #ifndef HAVE_NETDEV_HW_ADDR
2429 #define HAVE_NETDEV_HW_ADDR
2430 #endif
2431 #ifndef HAVE_TRANS_START_IN_QUEUE
2432 #define HAVE_TRANS_START_IN_QUEUE
2433 #endif
2434 #endif /* < 2.6.31 */
2435
2436 /*****************************************************************************/
2437 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32) )
2438 #undef netdev_tx_t
2439 #define netdev_tx_t int
2440 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
2441 #ifndef NETIF_F_FCOE_MTU
2442 #define NETIF_F_FCOE_MTU       (1 << 26)
2443 #endif
2444 #endif /* CONFIG_FCOE || CONFIG_FCOE_MODULE */
2445
2446 #ifndef pm_runtime_get_sync
2447 #define pm_runtime_get_sync(dev)        do {} while (0)
2448 #endif
2449 #ifndef pm_runtime_put
2450 #define pm_runtime_put(dev)             do {} while (0)
2451 #endif
2452 #ifndef pm_runtime_put_sync
2453 #define pm_runtime_put_sync(dev)        do {} while (0)
2454 #endif
2455 #ifndef pm_runtime_resume
2456 #define pm_runtime_resume(dev)          do {} while (0)
2457 #endif
2458 #ifndef pm_schedule_suspend
2459 #define pm_schedule_suspend(dev, t)     do {} while (0)
2460 #endif
2461 #ifndef pm_runtime_set_suspended
2462 #define pm_runtime_set_suspended(dev)   do {} while (0)
2463 #endif
2464 #ifndef pm_runtime_disable
2465 #define pm_runtime_disable(dev)         do {} while (0)
2466 #endif
2467 #ifndef pm_runtime_put_noidle
2468 #define pm_runtime_put_noidle(dev)      do {} while (0)
2469 #endif
2470 #ifndef pm_runtime_set_active
2471 #define pm_runtime_set_active(dev)      do {} while (0)
2472 #endif
2473 #ifndef pm_runtime_enable
2474 #define pm_runtime_enable(dev)  do {} while (0)
2475 #endif
2476 #ifndef pm_runtime_get_noresume
2477 #define pm_runtime_get_noresume(dev)    do {} while (0)
2478 #endif
2479 #else /* < 2.6.32 */
2480 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
2481 #ifndef HAVE_NETDEV_OPS_FCOE_ENABLE
2482 #define HAVE_NETDEV_OPS_FCOE_ENABLE
2483 #endif
2484 #endif /* CONFIG_FCOE || CONFIG_FCOE_MODULE */
2485 #ifdef CONFIG_DCB
2486 #ifndef HAVE_DCBNL_OPS_GETAPP
2487 #define HAVE_DCBNL_OPS_GETAPP
2488 #endif
2489 #endif /* CONFIG_DCB */
2490 #include <linux/pm_runtime.h>
2491 /* IOV bad DMA target work arounds require at least this kernel rev support */
2492 #define HAVE_PCIE_TYPE
2493 #endif /* < 2.6.32 */
2494
2495 /*****************************************************************************/
2496 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33) )
2497 #ifndef pci_pcie_cap
2498 #define pci_pcie_cap(pdev) pci_find_capability(pdev, PCI_CAP_ID_EXP)
2499 #endif
2500 #ifndef IPV4_FLOW
2501 #define IPV4_FLOW 0x10
2502 #endif /* IPV4_FLOW */
2503 #ifndef IPV6_FLOW
2504 #define IPV6_FLOW 0x11
2505 #endif /* IPV6_FLOW */
2506 /* Features back-ported to RHEL6 or SLES11 SP1 after 2.6.32 */
2507 #if ( (RHEL_RELEASE_CODE && RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(6,0)) || \
2508       (SLE_VERSION_CODE && SLE_VERSION_CODE >= SLE_VERSION(11,1,0)) )
2509 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
2510 #ifndef HAVE_NETDEV_OPS_FCOE_GETWWN
2511 #define HAVE_NETDEV_OPS_FCOE_GETWWN
2512 #endif
2513 #endif /* CONFIG_FCOE || CONFIG_FCOE_MODULE */
2514 #endif /* RHEL6 or SLES11 SP1 */
2515 #ifndef __percpu
2516 #define __percpu
2517 #endif /* __percpu */
2518 #else /* < 2.6.33 */
2519 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
2520 #ifndef HAVE_NETDEV_OPS_FCOE_GETWWN
2521 #define HAVE_NETDEV_OPS_FCOE_GETWWN
2522 #endif
2523 #endif /* CONFIG_FCOE || CONFIG_FCOE_MODULE */
2524 #define HAVE_ETHTOOL_SFP_DISPLAY_PORT
2525 #endif /* < 2.6.33 */
2526
2527 /*****************************************************************************/
2528 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,34) )
2529 #ifndef ETH_FLAG_NTUPLE
2530 #define ETH_FLAG_NTUPLE NETIF_F_NTUPLE
2531 #endif
2532
2533 #ifndef netdev_mc_count
2534 #define netdev_mc_count(dev) ((dev)->mc_count)
2535 #endif
2536 #ifndef netdev_mc_empty
2537 #define netdev_mc_empty(dev) (netdev_mc_count(dev) == 0)
2538 #endif
2539 #ifndef netdev_for_each_mc_addr
2540 #define netdev_for_each_mc_addr(mclist, dev) \
2541         for (mclist = dev->mc_list; mclist; mclist = mclist->next)
2542 #endif
2543 #ifndef netdev_uc_count
2544 #define netdev_uc_count(dev) ((dev)->uc.count)
2545 #endif
2546 #ifndef netdev_uc_empty
2547 #define netdev_uc_empty(dev) (netdev_uc_count(dev) == 0)
2548 #endif
2549 #ifndef netdev_for_each_uc_addr
2550 #define netdev_for_each_uc_addr(ha, dev) \
2551         list_for_each_entry(ha, &dev->uc.list, list)
2552 #endif
2553 #ifndef dma_set_coherent_mask
2554 #define dma_set_coherent_mask(dev,mask) \
2555         pci_set_consistent_dma_mask(to_pci_dev(dev),(mask))
2556 #endif
2557 #ifndef pci_dev_run_wake
2558 #define pci_dev_run_wake(pdev)  (0)
2559 #endif
2560
2561 /* netdev logging taken from include/linux/netdevice.h */
2562 #ifndef netdev_name
2563 static inline const char *_kc_netdev_name(const struct net_device *dev)
2564 {
2565         if (dev->reg_state != NETREG_REGISTERED)
2566                 return "(unregistered net_device)";
2567         return dev->name;
2568 }
2569 #define netdev_name(netdev)     _kc_netdev_name(netdev)
2570 #endif /* netdev_name */
2571
2572 #undef netdev_printk
2573 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) )
2574 #define netdev_printk(level, netdev, format, args...)           \
2575 do {                                                            \
2576         struct adapter_struct *kc_adapter = netdev_priv(netdev);\
2577         struct pci_dev *pdev = kc_adapter->pdev;                \
2578         printk("%s %s: " format, level, pci_name(pdev),         \
2579                ##args);                                         \
2580 } while(0)
2581 #elif ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21) )
2582 #define netdev_printk(level, netdev, format, args...)           \
2583 do {                                                            \
2584         struct adapter_struct *kc_adapter = netdev_priv(netdev);\
2585         struct pci_dev *pdev = kc_adapter->pdev;                \
2586         struct device *dev = pci_dev_to_dev(pdev);              \
2587         dev_printk(level, dev, "%s: " format,                   \
2588                    netdev_name(netdev), ##args);                \
2589 } while(0)
2590 #else /* 2.6.21 => 2.6.34 */
2591 #define netdev_printk(level, netdev, format, args...)           \
2592         dev_printk(level, (netdev)->dev.parent,                 \
2593                    "%s: " format,                               \
2594                    netdev_name(netdev), ##args)
2595 #endif /* <2.6.0 <2.6.21 <2.6.34 */
2596 #undef netdev_emerg
2597 #define netdev_emerg(dev, format, args...)                      \
2598         netdev_printk(KERN_EMERG, dev, format, ##args)
2599 #undef netdev_alert
2600 #define netdev_alert(dev, format, args...)                      \
2601         netdev_printk(KERN_ALERT, dev, format, ##args)
2602 #undef netdev_crit
2603 #define netdev_crit(dev, format, args...)                       \
2604         netdev_printk(KERN_CRIT, dev, format, ##args)
2605 #undef netdev_err
2606 #define netdev_err(dev, format, args...)                        \
2607         netdev_printk(KERN_ERR, dev, format, ##args)
2608 #undef netdev_warn
2609 #define netdev_warn(dev, format, args...)                       \
2610         netdev_printk(KERN_WARNING, dev, format, ##args)
2611 #undef netdev_notice
2612 #define netdev_notice(dev, format, args...)                     \
2613         netdev_printk(KERN_NOTICE, dev, format, ##args)
2614 #undef netdev_info
2615 #define netdev_info(dev, format, args...)                       \
2616         netdev_printk(KERN_INFO, dev, format, ##args)
2617 #undef netdev_dbg
2618 #if defined(DEBUG)
2619 #define netdev_dbg(__dev, format, args...)                      \
2620         netdev_printk(KERN_DEBUG, __dev, format, ##args)
2621 #elif defined(CONFIG_DYNAMIC_DEBUG)
2622 #define netdev_dbg(__dev, format, args...)                      \
2623 do {                                                            \
2624         dynamic_dev_dbg((__dev)->dev.parent, "%s: " format,     \
2625                         netdev_name(__dev), ##args);            \
2626 } while (0)
2627 #else /* DEBUG */
2628 #define netdev_dbg(__dev, format, args...)                      \
2629 ({                                                              \
2630         if (0)                                                  \
2631                 netdev_printk(KERN_DEBUG, __dev, format, ##args); \
2632         0;                                                      \
2633 })
2634 #endif /* DEBUG */
2635
2636 #undef netif_printk
2637 #define netif_printk(priv, type, level, dev, fmt, args...)      \
2638 do {                                                            \
2639         if (netif_msg_##type(priv))                             \
2640                 netdev_printk(level, (dev), fmt, ##args);       \
2641 } while (0)
2642
2643 #undef netif_emerg
2644 #define netif_emerg(priv, type, dev, fmt, args...)              \
2645         netif_level(emerg, priv, type, dev, fmt, ##args)
2646 #undef netif_alert
2647 #define netif_alert(priv, type, dev, fmt, args...)              \
2648         netif_level(alert, priv, type, dev, fmt, ##args)
2649 #undef netif_crit
2650 #define netif_crit(priv, type, dev, fmt, args...)               \
2651         netif_level(crit, priv, type, dev, fmt, ##args)
2652 #undef netif_err
2653 #define netif_err(priv, type, dev, fmt, args...)                \
2654         netif_level(err, priv, type, dev, fmt, ##args)
2655 #undef netif_warn
2656 #define netif_warn(priv, type, dev, fmt, args...)               \
2657         netif_level(warn, priv, type, dev, fmt, ##args)
2658 #undef netif_notice
2659 #define netif_notice(priv, type, dev, fmt, args...)             \
2660         netif_level(notice, priv, type, dev, fmt, ##args)
2661 #undef netif_info
2662 #define netif_info(priv, type, dev, fmt, args...)               \
2663         netif_level(info, priv, type, dev, fmt, ##args)
2664
2665 #ifdef SET_SYSTEM_SLEEP_PM_OPS
2666 #define HAVE_SYSTEM_SLEEP_PM_OPS
2667 #endif
2668
2669 #ifndef for_each_set_bit
2670 #define for_each_set_bit(bit, addr, size) \
2671         for ((bit) = find_first_bit((addr), (size)); \
2672                 (bit) < (size); \
2673                 (bit) = find_next_bit((addr), (size), (bit) + 1))
2674 #endif /* for_each_set_bit */
2675
2676 #ifndef DEFINE_DMA_UNMAP_ADDR
2677 #define DEFINE_DMA_UNMAP_ADDR DECLARE_PCI_UNMAP_ADDR
2678 #define DEFINE_DMA_UNMAP_LEN DECLARE_PCI_UNMAP_LEN
2679 #define dma_unmap_addr pci_unmap_addr
2680 #define dma_unmap_addr_set pci_unmap_addr_set
2681 #define dma_unmap_len pci_unmap_len
2682 #define dma_unmap_len_set pci_unmap_len_set
2683 #endif /* DEFINE_DMA_UNMAP_ADDR */
2684 #else /* < 2.6.34 */
2685 #define HAVE_SYSTEM_SLEEP_PM_OPS
2686 #ifndef HAVE_SET_RX_MODE
2687 #define HAVE_SET_RX_MODE
2688 #endif
2689
2690 #endif /* < 2.6.34 */
2691
2692 /*****************************************************************************/
2693 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35) )
2694 #ifndef numa_node_id
2695 #define numa_node_id() 0
2696 #endif
2697 #ifdef HAVE_TX_MQ
2698 #include <net/sch_generic.h>
2699 #ifndef CONFIG_NETDEVICES_MULTIQUEUE
2700 void _kc_netif_set_real_num_tx_queues(struct net_device *, unsigned int);
2701 #define netif_set_real_num_tx_queues  _kc_netif_set_real_num_tx_queues
2702 #else /* CONFIG_NETDEVICES_MULTI_QUEUE */
2703 #define netif_set_real_num_tx_queues(_netdev, _count) \
2704         do { \
2705                 (_netdev)->egress_subqueue_count = _count; \
2706         } while (0)
2707 #endif /* CONFIG_NETDEVICES_MULTI_QUEUE */
2708 #else
2709 #define netif_set_real_num_tx_queues(_netdev, _count) do {} while(0)
2710 #endif /* HAVE_TX_MQ */
2711 #ifndef ETH_FLAG_RXHASH
2712 #define ETH_FLAG_RXHASH (1<<28)
2713 #endif /* ETH_FLAG_RXHASH */
2714 #else /* < 2.6.35 */
2715 #define HAVE_PM_QOS_REQUEST_LIST
2716 #define HAVE_IRQ_AFFINITY_HINT
2717 #endif /* < 2.6.35 */
2718
2719 /*****************************************************************************/
2720 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36) )
2721 extern int _kc_ethtool_op_set_flags(struct net_device *, u32, u32);
2722 #define ethtool_op_set_flags _kc_ethtool_op_set_flags
2723 extern u32 _kc_ethtool_op_get_flags(struct net_device *);
2724 #define ethtool_op_get_flags _kc_ethtool_op_get_flags
2725
2726 #ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
2727 #ifdef NET_IP_ALIGN
2728 #undef NET_IP_ALIGN
2729 #endif
2730 #define NET_IP_ALIGN 0
2731 #endif /* CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS */
2732
2733 #ifdef NET_SKB_PAD
2734 #undef NET_SKB_PAD
2735 #endif
2736
2737 #if (L1_CACHE_BYTES > 32)
2738 #define NET_SKB_PAD L1_CACHE_BYTES
2739 #else
2740 #define NET_SKB_PAD 32
2741 #endif
2742
2743 static inline struct sk_buff *_kc_netdev_alloc_skb_ip_align(struct net_device *dev,
2744                                                             unsigned int length)
2745 {
2746         struct sk_buff *skb;
2747
2748         skb = alloc_skb(length + NET_SKB_PAD + NET_IP_ALIGN, GFP_ATOMIC);
2749         if (skb) {
2750 #if (NET_IP_ALIGN + NET_SKB_PAD)
2751                 skb_reserve(skb, NET_IP_ALIGN + NET_SKB_PAD);
2752 #endif
2753                 skb->dev = dev;
2754         }
2755         return skb;
2756 }
2757
2758 #ifdef netdev_alloc_skb_ip_align
2759 #undef netdev_alloc_skb_ip_align
2760 #endif
2761 #define netdev_alloc_skb_ip_align(n, l) _kc_netdev_alloc_skb_ip_align(n, l)
2762
2763 #undef netif_level
2764 #define netif_level(level, priv, type, dev, fmt, args...)       \
2765 do {                                                            \
2766         if (netif_msg_##type(priv))                             \
2767                 netdev_##level(dev, fmt, ##args);               \
2768 } while (0)
2769
2770 #undef usleep_range
2771 #define usleep_range(min, max)  msleep(DIV_ROUND_UP(min, 1000))
2772
2773 #else /* < 2.6.36 */
2774 #define HAVE_PM_QOS_REQUEST_ACTIVE
2775 #define HAVE_8021P_SUPPORT
2776 #define HAVE_NDO_GET_STATS64
2777 #endif /* < 2.6.36 */
2778
2779 /*****************************************************************************/
2780 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37) )
2781 #ifndef ETHTOOL_RXNTUPLE_ACTION_CLEAR
2782 #define ETHTOOL_RXNTUPLE_ACTION_CLEAR (-2)
2783 #endif
2784 #ifndef VLAN_N_VID
2785 #define VLAN_N_VID      VLAN_GROUP_ARRAY_LEN
2786 #endif /* VLAN_N_VID */
2787 #ifndef ETH_FLAG_TXVLAN
2788 #define ETH_FLAG_TXVLAN (1 << 7)
2789 #endif /* ETH_FLAG_TXVLAN */
2790 #ifndef ETH_FLAG_RXVLAN
2791 #define ETH_FLAG_RXVLAN (1 << 8)
2792 #endif /* ETH_FLAG_RXVLAN */
2793
2794 static inline void _kc_skb_checksum_none_assert(struct sk_buff *skb)
2795 {
2796         WARN_ON(skb->ip_summed != CHECKSUM_NONE);
2797 }
2798 #define skb_checksum_none_assert(skb) _kc_skb_checksum_none_assert(skb)
2799
2800 static inline void *_kc_vzalloc_node(unsigned long size, int node)
2801 {
2802         void *addr = vmalloc_node(size, node);
2803         if (addr)
2804                 memset(addr, 0, size);
2805         return addr;
2806 }
2807 #define vzalloc_node(_size, _node) _kc_vzalloc_node(_size, _node)
2808
2809 static inline void *_kc_vzalloc(unsigned long size)
2810 {
2811         void *addr = vmalloc(size);
2812         if (addr)
2813                 memset(addr, 0, size);
2814         return addr;
2815 }
2816 #define vzalloc(_size) _kc_vzalloc(_size)
2817
2818 #ifndef vlan_get_protocol
2819 static inline __be16 __kc_vlan_get_protocol(const struct sk_buff *skb)
2820 {
2821         if (vlan_tx_tag_present(skb) ||
2822             skb->protocol != cpu_to_be16(ETH_P_8021Q))
2823                 return skb->protocol;
2824
2825         if (skb_headlen(skb) < sizeof(struct vlan_ethhdr))
2826                 return 0;
2827
2828         return ((struct vlan_ethhdr*)skb->data)->h_vlan_encapsulated_proto;
2829 }
2830 #define vlan_get_protocol(_skb) __kc_vlan_get_protocol(_skb)
2831 #endif
2832 #ifdef HAVE_HW_TIME_STAMP
2833 #define SKBTX_HW_TSTAMP (1 << 0)
2834 #define SKBTX_IN_PROGRESS (1 << 2)
2835 #define SKB_SHARED_TX_IS_UNION
2836 #endif
2837 #if ( LINUX_VERSION_CODE > KERNEL_VERSION(2,4,18) )
2838 #ifndef HAVE_VLAN_RX_REGISTER
2839 #define HAVE_VLAN_RX_REGISTER
2840 #endif
2841 #endif /* > 2.4.18 */
2842 #endif /* < 2.6.37 */
2843
2844 /*****************************************************************************/
2845 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38) )
2846 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22) )
2847 #define skb_checksum_start_offset(skb) skb_transport_offset(skb)
2848 #else /* 2.6.22 -> 2.6.37 */
2849 static inline int _kc_skb_checksum_start_offset(const struct sk_buff *skb)
2850 {
2851         return skb->csum_start - skb_headroom(skb);
2852 }
2853 #define skb_checksum_start_offset(skb) _kc_skb_checksum_start_offset(skb)
2854 #endif /* 2.6.22 -> 2.6.37 */
2855 #ifdef CONFIG_DCB
2856 #ifndef IEEE_8021QAZ_MAX_TCS
2857 #define IEEE_8021QAZ_MAX_TCS 8
2858 #endif
2859 #ifndef DCB_CAP_DCBX_HOST
2860 #define DCB_CAP_DCBX_HOST               0x01
2861 #endif
2862 #ifndef DCB_CAP_DCBX_LLD_MANAGED
2863 #define DCB_CAP_DCBX_LLD_MANAGED        0x02
2864 #endif
2865 #ifndef DCB_CAP_DCBX_VER_CEE
2866 #define DCB_CAP_DCBX_VER_CEE            0x04
2867 #endif
2868 #ifndef DCB_CAP_DCBX_VER_IEEE
2869 #define DCB_CAP_DCBX_VER_IEEE           0x08
2870 #endif
2871 #ifndef DCB_CAP_DCBX_STATIC
2872 #define DCB_CAP_DCBX_STATIC             0x10
2873 #endif
2874 #endif /* CONFIG_DCB */
2875 #else /* < 2.6.38 */
2876 #endif /* < 2.6.38 */
2877
2878 /*****************************************************************************/
2879 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39) )
2880 #ifndef skb_queue_reverse_walk_safe
2881 #define skb_queue_reverse_walk_safe(queue, skb, tmp)                            \
2882                 for (skb = (queue)->prev, tmp = skb->prev;                      \
2883                      skb != (struct sk_buff *)(queue);                          \
2884                      skb = tmp, tmp = skb->prev)
2885 #endif
2886 #if (!(RHEL_RELEASE_CODE && RHEL_RELEASE_CODE > RHEL_RELEASE_VERSION(6,0)))
2887 extern u8 _kc_netdev_get_num_tc(struct net_device *dev);
2888 #define netdev_get_num_tc(dev) _kc_netdev_get_num_tc(dev)
2889 extern u8 _kc_netdev_get_prio_tc_map(struct net_device *dev, u8 up);
2890 #define netdev_get_prio_tc_map(dev, up) _kc_netdev_get_prio_tc_map(dev, up)
2891 #define netdev_set_prio_tc_map(dev, up, tc) do {} while (0)
2892 #else /* RHEL6.1 or greater */
2893 #ifndef HAVE_MQPRIO
2894 #define HAVE_MQPRIO
2895 #endif /* HAVE_MQPRIO */
2896 #ifdef CONFIG_DCB
2897 #ifndef HAVE_DCBNL_IEEE
2898 #define HAVE_DCBNL_IEEE
2899 #ifndef IEEE_8021QAZ_TSA_STRICT
2900 #define IEEE_8021QAZ_TSA_STRICT         0
2901 #endif
2902 #ifndef IEEE_8021QAZ_TSA_ETS
2903 #define IEEE_8021QAZ_TSA_ETS            2
2904 #endif
2905 #ifndef IEEE_8021QAZ_APP_SEL_ETHERTYPE
2906 #define IEEE_8021QAZ_APP_SEL_ETHERTYPE  1
2907 #endif
2908 #endif
2909 #endif /* CONFIG_DCB */
2910 #endif /* !(RHEL_RELEASE_CODE > RHEL_RELEASE_VERSION(6,0)) */
2911 #else /* < 2.6.39 */
2912 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
2913 #ifndef HAVE_NETDEV_OPS_FCOE_DDP_TARGET
2914 #define HAVE_NETDEV_OPS_FCOE_DDP_TARGET
2915 #endif
2916 #endif /* CONFIG_FCOE || CONFIG_FCOE_MODULE */
2917 #ifndef HAVE_MQPRIO
2918 #define HAVE_MQPRIO
2919 #endif
2920 #ifndef HAVE_SETUP_TC
2921 #define HAVE_SETUP_TC
2922 #endif
2923 #ifdef CONFIG_DCB
2924 #ifndef HAVE_DCBNL_IEEE
2925 #define HAVE_DCBNL_IEEE
2926 #endif
2927 #endif /* CONFIG_DCB */
2928 #ifndef HAVE_NDO_SET_FEATURES
2929 #define HAVE_NDO_SET_FEATURES
2930 #endif
2931 #endif /* < 2.6.39 */
2932
2933 /*****************************************************************************/
2934 /* use < 2.6.40 because of a Fedora 15 kernel update where they
2935  * updated the kernel version to 2.6.40.x and they back-ported 3.0 features
2936  * like set_phys_id for ethtool.
2937  */
2938 #undef ETHTOOL_GRXRINGS
2939 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,40) )
2940 #ifdef ETHTOOL_GRXRINGS
2941 #ifndef FLOW_EXT
2942 #define FLOW_EXT        0x80000000
2943 union _kc_ethtool_flow_union {
2944         struct ethtool_tcpip4_spec              tcp_ip4_spec;
2945         struct ethtool_usrip4_spec              usr_ip4_spec;
2946         __u8                                    hdata[60];
2947 };
2948 struct _kc_ethtool_flow_ext {
2949         __be16  vlan_etype;
2950         __be16  vlan_tci;
2951         __be32  data[2];
2952 };
2953 struct _kc_ethtool_rx_flow_spec {
2954         __u32           flow_type;
2955         union _kc_ethtool_flow_union h_u;
2956         struct _kc_ethtool_flow_ext h_ext;
2957         union _kc_ethtool_flow_union m_u;
2958         struct _kc_ethtool_flow_ext m_ext;
2959         __u64           ring_cookie;
2960         __u32           location;
2961 };
2962 #define ethtool_rx_flow_spec _kc_ethtool_rx_flow_spec
2963 #endif /* FLOW_EXT */
2964 #endif
2965
2966 #define pci_disable_link_state_locked pci_disable_link_state
2967
2968 #ifndef PCI_LTR_VALUE_MASK
2969 #define  PCI_LTR_VALUE_MASK     0x000003ff
2970 #endif
2971 #ifndef PCI_LTR_SCALE_MASK
2972 #define  PCI_LTR_SCALE_MASK     0x00001c00
2973 #endif
2974 #ifndef PCI_LTR_SCALE_SHIFT
2975 #define  PCI_LTR_SCALE_SHIFT    10
2976 #endif
2977
2978 #else /* < 2.6.40 */
2979 #define HAVE_ETHTOOL_SET_PHYS_ID
2980 #endif /* < 2.6.40 */
2981
2982 /*****************************************************************************/
2983 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0) )
2984 #ifndef __netdev_alloc_skb_ip_align
2985 #define __netdev_alloc_skb_ip_align(d,l,_g) netdev_alloc_skb_ip_align(d,l)
2986 #endif /* __netdev_alloc_skb_ip_align */
2987 #define dcb_ieee_setapp(dev, app) dcb_setapp(dev, app)
2988 #define dcb_ieee_delapp(dev, app) 0
2989 #define dcb_ieee_getapp_mask(dev, app) (1 << app->priority)
2990 #else /* < 3.1.0 */
2991 #ifndef HAVE_DCBNL_IEEE_DELAPP
2992 #define HAVE_DCBNL_IEEE_DELAPP
2993 #endif
2994 #endif /* < 3.1.0 */
2995
2996 /*****************************************************************************/
2997 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(3,2,0) )
2998 #ifdef ETHTOOL_GRXRINGS
2999 #define HAVE_ETHTOOL_GET_RXNFC_VOID_RULE_LOCS
3000 #endif /* ETHTOOL_GRXRINGS */
3001
3002 #ifndef skb_frag_size
3003 #define skb_frag_size(frag)     _kc_skb_frag_size(frag)
3004 static inline unsigned int _kc_skb_frag_size(const skb_frag_t *frag)
3005 {
3006         return frag->size;
3007 }
3008 #endif /* skb_frag_size */
3009
3010 #ifndef skb_frag_size_sub
3011 #define skb_frag_size_sub(frag, delta)  _kc_skb_frag_size_sub(frag, delta)
3012 static inline void _kc_skb_frag_size_sub(skb_frag_t *frag, int delta)
3013 {
3014         frag->size -= delta;
3015 }
3016 #endif /* skb_frag_size_sub */
3017
3018 #ifndef skb_frag_page
3019 #define skb_frag_page(frag)     _kc_skb_frag_page(frag)
3020 static inline struct page *_kc_skb_frag_page(const skb_frag_t *frag)
3021 {
3022         return frag->page;
3023 }
3024 #endif /* skb_frag_page */
3025
3026 #ifndef skb_frag_address
3027 #define skb_frag_address(frag)  _kc_skb_frag_address(frag)
3028 static inline void *_kc_skb_frag_address(const skb_frag_t *frag)
3029 {
3030         return page_address(skb_frag_page(frag)) + frag->page_offset;
3031 }
3032 #endif /* skb_frag_address */
3033
3034 #ifndef skb_frag_dma_map
3035 #define skb_frag_dma_map(dev,frag,offset,size,dir) \
3036                 _kc_skb_frag_dma_map(dev,frag,offset,size,dir)
3037 static inline dma_addr_t _kc_skb_frag_dma_map(struct device *dev,
3038                                               const skb_frag_t *frag,
3039                                               size_t offset, size_t size,
3040                                               enum dma_data_direction dir)
3041 {
3042         return dma_map_page(dev, skb_frag_page(frag),
3043                             frag->page_offset + offset, size, dir);
3044 }
3045 #endif /* skb_frag_dma_map */
3046
3047 #ifndef __skb_frag_unref
3048 #define __skb_frag_unref(frag) __kc_skb_frag_unref(frag)
3049 static inline void __kc_skb_frag_unref(skb_frag_t *frag)
3050 {
3051         put_page(skb_frag_page(frag));
3052 }
3053 #endif /* __skb_frag_unref */
3054 #else /* < 3.2.0 */
3055 #ifndef HAVE_PCI_DEV_FLAGS_ASSIGNED
3056 #define HAVE_PCI_DEV_FLAGS_ASSIGNED
3057 #define HAVE_VF_SPOOFCHK_CONFIGURE
3058 #endif
3059 #endif /* < 3.2.0 */
3060
3061 #if (RHEL_RELEASE_CODE && \
3062         (RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(6,2)) && \
3063         (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(7,0)))
3064 #undef ixgbe_get_netdev_tc_txq
3065 #define ixgbe_get_netdev_tc_txq(dev, tc) (&netdev_extended(dev)->qos_data.tc_to_txq[tc])
3066 #endif
3067
3068 /*****************************************************************************/
3069 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0) )
3070 typedef u32 kni_netdev_features_t;
3071 #else /* ! < 3.3.0 */
3072 typedef netdev_features_t kni_netdev_features_t;
3073 #define HAVE_INT_NDO_VLAN_RX_ADD_VID
3074 #ifdef ETHTOOL_SRXNTUPLE
3075 #undef ETHTOOL_SRXNTUPLE
3076 #endif
3077 #endif /* < 3.3.0 */
3078
3079 /*****************************************************************************/
3080 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(3,4,0) )
3081 #ifndef NETIF_F_RXFCS
3082 #define NETIF_F_RXFCS   0
3083 #endif /* NETIF_F_RXFCS */
3084 #ifndef NETIF_F_RXALL
3085 #define NETIF_F_RXALL   0
3086 #endif /* NETIF_F_RXALL */
3087
3088 #define NUMTCS_RETURNS_U8
3089
3090
3091 #endif /* < 3.4.0 */
3092
3093 /*****************************************************************************/
3094 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0) )
3095 static inline bool __kc_ether_addr_equal(const u8 *addr1, const u8 *addr2)
3096 {
3097         return !compare_ether_addr(addr1, addr2);
3098 }
3099 #define ether_addr_equal(_addr1, _addr2) __kc_ether_addr_equal((_addr1),(_addr2))
3100 #else
3101 #define HAVE_FDB_OPS
3102 #endif /* < 3.5.0 */
3103
3104 /*****************************************************************************/
3105 #if ( LINUX_VERSION_CODE >= KERNEL_VERSION(3,10,0) )
3106 #define NETIF_F_HW_VLAN_TX     NETIF_F_HW_VLAN_CTAG_TX
3107 #define NETIF_F_HW_VLAN_RX     NETIF_F_HW_VLAN_CTAG_RX
3108 #define NETIF_F_HW_VLAN_FILTER NETIF_F_HW_VLAN_CTAG_FILTER
3109 #endif /* >= 3.10.0 */
3110
3111 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0) )
3112 #ifdef CONFIG_PCI_IOV
3113 extern int __kc_pci_vfs_assigned(struct pci_dev *dev);
3114 #else
3115 static inline int __kc_pci_vfs_assigned(struct pci_dev *dev)
3116 {
3117         return 0;
3118 }
3119 #endif
3120 #define pci_vfs_assigned(dev) __kc_pci_vfs_assigned(dev)
3121
3122 #endif
3123
3124 #if ( LINUX_VERSION_CODE >= KERNEL_VERSION(3,16,0) )
3125 #define SET_ETHTOOL_OPS(netdev, ops) ((netdev)->ethtool_ops = (ops))
3126 #endif /* >= 3.16.0 */
3127
3128 /*
3129  * vlan_tx_tag_* macros renamed to skb_vlan_tag_* (Linux commit: df8a39defad4)
3130  * For older kernels backported this commit, need to use renamed functions.
3131  * This fix is specific to RedHat/CentOS kernels.
3132  */
3133 #if (defined(RHEL_RELEASE_CODE) && \
3134         RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(6, 8) && \
3135         LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 34))
3136 #define vlan_tx_tag_get skb_vlan_tag_get
3137 #define vlan_tx_tag_present skb_vlan_tag_present
3138 #endif
3139
3140 #endif /* _KCOMPAT_H_ */