lib/librte_eal/linuxapp/kni/ethtool/ixgbe/kcompat.h

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