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

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*******************************************************************************
   3
   4   Intel(R) Gigabit Ethernet Linux driver
   5   Copyright(c) 2007-2013 Intel Corporation.
   6
   7   Contact Information:
   8   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
   9   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  10
  11 *******************************************************************************/
  12
  13 #ifndef _KCOMPAT_H_
  14 #define _KCOMPAT_H_
  15
  16 #ifndef LINUX_VERSION_CODE
  17 #include <linux/version.h>
  18 #else
  19 #define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
  20 #endif
  21 #include <linux/init.h>
  22 #include <linux/types.h>
  23 #include <linux/errno.h>
  24 #include <linux/module.h>
  25 #include <linux/pci.h>
  26 #include <linux/netdevice.h>
  27 #include <linux/etherdevice.h>
  28 #include <linux/skbuff.h>
  29 #include <linux/ioport.h>
  30 #include <linux/slab.h>
  31 #include <linux/list.h>
  32 #include <linux/delay.h>
  33 #include <linux/sched.h>
  34 #include <linux/in.h>
  35 #include <linux/ip.h>
  36 #include <linux/udp.h>
  37 #include <linux/mii.h>
  38 #include <linux/vmalloc.h>
  39 #include <asm/io.h>
  40 #include <linux/ethtool.h>
  41 #include <linux/if_vlan.h>
  42
  43 /* NAPI enable/disable flags here */
  44 #define NAPI
  45
  46 #define adapter_struct igb_adapter
  47 #define adapter_q_vector igb_q_vector
  48 #define NAPI
  49
  50 /* and finally set defines so that the code sees the changes */
  51 #ifdef NAPI
  52 #else
  53 #endif /* NAPI */
  54
  55 /* packet split disable/enable */
  56 #ifdef DISABLE_PACKET_SPLIT
  57 #ifndef CONFIG_IGB_DISABLE_PACKET_SPLIT
  58 #define CONFIG_IGB_DISABLE_PACKET_SPLIT
  59 #endif
  60 #endif /* DISABLE_PACKET_SPLIT */
  61
  62 /* MSI compatibility code for all kernels and drivers */
  63 #ifdef DISABLE_PCI_MSI
  64 #undef CONFIG_PCI_MSI
  65 #endif
  66 #ifndef CONFIG_PCI_MSI
  67 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,8) )
  68 struct msix_entry {
  69         u16 vector; /* kernel uses to write allocated vector */
  70         u16 entry;  /* driver uses to specify entry, OS writes */
  71 };
  72 #endif
  73 #undef pci_enable_msi
  74 #define pci_enable_msi(a) -ENOTSUPP
  75 #undef pci_disable_msi
  76 #define pci_disable_msi(a) do {} while (0)
  77 #undef pci_enable_msix
  78 #define pci_enable_msix(a, b, c) -ENOTSUPP
  79 #undef pci_disable_msix
  80 #define pci_disable_msix(a) do {} while (0)
  81 #define msi_remove_pci_irq_vectors(a) do {} while (0)
  82 #endif /* CONFIG_PCI_MSI */
  83 #ifdef DISABLE_PM
  84 #undef CONFIG_PM
  85 #endif
  86
  87 #ifdef DISABLE_NET_POLL_CONTROLLER
  88 #undef CONFIG_NET_POLL_CONTROLLER
  89 #endif
  90
  91 #ifndef PMSG_SUSPEND
  92 #define PMSG_SUSPEND 3
  93 #endif
  94
  95 /* generic boolean compatibility */
  96 #undef TRUE
  97 #undef FALSE
  98 #define TRUE true
  99 #define FALSE false
 100 #ifdef GCC_VERSION
 101 #if ( GCC_VERSION < 3000 )
 102 #define _Bool char
 103 #endif
 104 #else
 105 #define _Bool char
 106 #endif
 107
 108 /* kernels less than 2.4.14 don't have this */
 109 #ifndef ETH_P_8021Q
 110 #define ETH_P_8021Q 0x8100
 111 #endif
 112
 113 #ifndef module_param
 114 #define module_param(v,t,p) MODULE_PARM(v, "i");
 115 #endif
 116
 117 #ifndef DMA_64BIT_MASK
 118 #define DMA_64BIT_MASK  0xffffffffffffffffULL
 119 #endif
 120
 121 #ifndef DMA_32BIT_MASK
 122 #define DMA_32BIT_MASK  0x00000000ffffffffULL
 123 #endif
 124
 125 #ifndef PCI_CAP_ID_EXP
 126 #define PCI_CAP_ID_EXP 0x10
 127 #endif
 128
 129 #ifndef PCIE_LINK_STATE_L0S
 130 #define PCIE_LINK_STATE_L0S 1
 131 #endif
 132 #ifndef PCIE_LINK_STATE_L1
 133 #define PCIE_LINK_STATE_L1 2
 134 #endif
 135
 136 #ifndef mmiowb
 137 #ifdef CONFIG_IA64
 138 #define mmiowb() asm volatile ("mf.a" ::: "memory")
 139 #else
 140 #define mmiowb()
 141 #endif
 142 #endif
 143
 144 #ifndef SET_NETDEV_DEV
 145 #define SET_NETDEV_DEV(net, pdev)
 146 #endif
 147
 148 #if !defined(HAVE_FREE_NETDEV) && ( LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0) )
 149 #define free_netdev(x)  kfree(x)
 150 #endif
 151
 152 #ifdef HAVE_POLL_CONTROLLER
 153 #define CONFIG_NET_POLL_CONTROLLER
 154 #endif
 155
 156 #ifndef SKB_DATAREF_SHIFT
 157 /* if we do not have the infrastructure to detect if skb_header is cloned
 158    just return false in all cases */
 159 #define skb_header_cloned(x) 0
 160 #endif
 161
 162 #ifndef NETIF_F_GSO
 163 #define gso_size tso_size
 164 #define gso_segs tso_segs
 165 #endif
 166
 167 #ifndef NETIF_F_GRO
 168 #define vlan_gro_receive(_napi, _vlgrp, _vlan, _skb) \
 169                 vlan_hwaccel_receive_skb(_skb, _vlgrp, _vlan)
 170 #define napi_gro_receive(_napi, _skb) netif_receive_skb(_skb)
 171 #endif
 172
 173 #ifndef NETIF_F_SCTP_CSUM
 174 #define NETIF_F_SCTP_CSUM 0
 175 #endif
 176
 177 #ifndef NETIF_F_LRO
 178 #define NETIF_F_LRO (1 << 15)
 179 #endif
 180
 181 #ifndef NETIF_F_NTUPLE
 182 #define NETIF_F_NTUPLE (1 << 27)
 183 #endif
 184
 185 #ifndef IPPROTO_SCTP
 186 #define IPPROTO_SCTP 132
 187 #endif
 188
 189 #ifndef CHECKSUM_PARTIAL
 190 #define CHECKSUM_PARTIAL CHECKSUM_HW
 191 #define CHECKSUM_COMPLETE CHECKSUM_HW
 192 #endif
 193
 194 #ifndef __read_mostly
 195 #define __read_mostly
 196 #endif
 197
 198 #ifndef MII_RESV1
 199 #define MII_RESV1               0x17            /* Reserved...          */
 200 #endif
 201
 202 #ifndef unlikely
 203 #define unlikely(_x) _x
 204 #define likely(_x) _x
 205 #endif
 206
 207 #ifndef WARN_ON
 208 #define WARN_ON(x)
 209 #endif
 210
 211 #ifndef PCI_DEVICE
 212 #define PCI_DEVICE(vend,dev) \
 213         .vendor = (vend), .device = (dev), \
 214         .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
 215 #endif
 216
 217 #ifndef node_online
 218 #define node_online(node) ((node) == 0)
 219 #endif
 220
 221 #ifndef num_online_cpus
 222 #define num_online_cpus() smp_num_cpus
 223 #endif
 224
 225 #ifndef cpu_online
 226 #define cpu_online(cpuid) test_bit((cpuid), &cpu_online_map)
 227 #endif
 228
 229 #ifndef _LINUX_RANDOM_H
 230 #include <linux/random.h>
 231 #endif
 232
 233 #ifndef DECLARE_BITMAP
 234 #ifndef BITS_TO_LONGS
 235 #define BITS_TO_LONGS(bits) (((bits)+BITS_PER_LONG-1)/BITS_PER_LONG)
 236 #endif
 237 #define DECLARE_BITMAP(name,bits) long name[BITS_TO_LONGS(bits)]
 238 #endif
 239
 240 #ifndef VLAN_HLEN
 241 #define VLAN_HLEN 4
 242 #endif
 243
 244 #ifndef VLAN_ETH_HLEN
 245 #define VLAN_ETH_HLEN 18
 246 #endif
 247
 248 #ifndef VLAN_ETH_FRAME_LEN
 249 #define VLAN_ETH_FRAME_LEN 1518
 250 #endif
 251
 252 #if !defined(IXGBE_DCA) && !defined(IGB_DCA)
 253 #define dca_get_tag(b) 0
 254 #define dca_add_requester(a) -1
 255 #define dca_remove_requester(b) do { } while(0)
 256 #define DCA_PROVIDER_ADD     0x0001
 257 #define DCA_PROVIDER_REMOVE  0x0002
 258 #endif
 259
 260 #ifndef DCA_GET_TAG_TWO_ARGS
 261 #define dca3_get_tag(a,b) dca_get_tag(b)
 262 #endif
 263
 264 #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
 265 #if defined(__i386__) || defined(__x86_64__)
 266 #define CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
 267 #endif
 268 #endif
 269
 270 /* taken from 2.6.24 definition in linux/kernel.h */
 271 #ifndef IS_ALIGNED
 272 #define IS_ALIGNED(x,a)         (((x) % ((typeof(x))(a))) == 0)
 273 #endif
 274
 275 #ifdef IS_ENABLED
 276 #undef IS_ENABLED
 277 #undef __ARG_PLACEHOLDER_1
 278 #undef config_enabled
 279 #undef _config_enabled
 280 #undef __config_enabled
 281 #undef ___config_enabled
 282 #endif
 283
 284 #define __ARG_PLACEHOLDER_1 0,
 285 #define config_enabled(cfg) _config_enabled(cfg)
 286 #define _config_enabled(value) __config_enabled(__ARG_PLACEHOLDER_##value)
 287 #define __config_enabled(arg1_or_junk) ___config_enabled(arg1_or_junk 1, 0)
 288 #define ___config_enabled(__ignored, val, ...) val
 289
 290 #define IS_ENABLED(option) \
 291         (config_enabled(option) || config_enabled(option##_MODULE))
 292
 293 #if !defined(NETIF_F_HW_VLAN_TX) && !defined(NETIF_F_HW_VLAN_CTAG_TX)
 294 struct _kc_vlan_ethhdr {
 295         unsigned char   h_dest[ETH_ALEN];
 296         unsigned char   h_source[ETH_ALEN];
 297         __be16          h_vlan_proto;
 298         __be16          h_vlan_TCI;
 299         __be16          h_vlan_encapsulated_proto;
 300 };
 301 #define vlan_ethhdr _kc_vlan_ethhdr
 302 struct _kc_vlan_hdr {
 303         __be16          h_vlan_TCI;
 304         __be16          h_vlan_encapsulated_proto;
 305 };
 306 #define vlan_hdr _kc_vlan_hdr
 307 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0) )
 308 #define vlan_tx_tag_present(_skb) 0
 309 #define vlan_tx_tag_get(_skb) 0
 310 #endif
 311 #endif /* NETIF_F_HW_VLAN_TX && NETIF_F_HW_VLAN_CTAG_TX */
 312
 313 #ifndef VLAN_PRIO_SHIFT
 314 #define VLAN_PRIO_SHIFT 13
 315 #endif
 316
 317
 318 #ifndef __GFP_COLD
 319 #define __GFP_COLD 0
 320 #endif
 321
 322 #ifndef __GFP_COMP
 323 #define __GFP_COMP 0
 324 #endif
 325
 326 /*****************************************************************************/
 327 /* Installations with ethtool version without eeprom, adapter id, or statistics
 328  * support */
 329
 330 #ifndef ETH_GSTRING_LEN
 331 #define ETH_GSTRING_LEN 32
 332 #endif
 333
 334 #ifndef ETHTOOL_GSTATS
 335 #define ETHTOOL_GSTATS 0x1d
 336 #undef ethtool_drvinfo
 337 #define ethtool_drvinfo k_ethtool_drvinfo
 338 struct k_ethtool_drvinfo {
 339         u32 cmd;
 340         char driver[32];
 341         char version[32];
 342         char fw_version[32];
 343         char bus_info[32];
 344         char reserved1[32];
 345         char reserved2[16];
 346         u32 n_stats;
 347         u32 testinfo_len;
 348         u32 eedump_len;
 349         u32 regdump_len;
 350 };
 351
 352 struct ethtool_stats {
 353         u32 cmd;
 354         u32 n_stats;
 355         u64 data[0];
 356 };
 357 #endif /* ETHTOOL_GSTATS */
 358
 359 #ifndef ETHTOOL_PHYS_ID
 360 #define ETHTOOL_PHYS_ID 0x1c
 361 #endif /* ETHTOOL_PHYS_ID */
 362
 363 #ifndef ETHTOOL_GSTRINGS
 364 #define ETHTOOL_GSTRINGS 0x1b
 365 enum ethtool_stringset {
 366         ETH_SS_TEST             = 0,
 367         ETH_SS_STATS,
 368 };
 369 struct ethtool_gstrings {
 370         u32 cmd;            /* ETHTOOL_GSTRINGS */
 371         u32 string_set;     /* string set id e.c. ETH_SS_TEST, etc*/
 372         u32 len;            /* number of strings in the string set */
 373         u8 data[0];
 374 };
 375 #endif /* ETHTOOL_GSTRINGS */
 376
 377 #ifndef ETHTOOL_TEST
 378 #define ETHTOOL_TEST 0x1a
 379 enum ethtool_test_flags {
 380         ETH_TEST_FL_OFFLINE     = (1 << 0),
 381         ETH_TEST_FL_FAILED      = (1 << 1),
 382 };
 383 struct ethtool_test {
 384         u32 cmd;
 385         u32 flags;
 386         u32 reserved;
 387         u32 len;
 388         u64 data[0];
 389 };
 390 #endif /* ETHTOOL_TEST */
 391
 392 #ifndef ETHTOOL_GEEPROM
 393 #define ETHTOOL_GEEPROM 0xb
 394 #undef ETHTOOL_GREGS
 395 struct ethtool_eeprom {
 396         u32 cmd;
 397         u32 magic;
 398         u32 offset;
 399         u32 len;
 400         u8 data[0];
 401 };
 402
 403 struct ethtool_value {
 404         u32 cmd;
 405         u32 data;
 406 };
 407 #endif /* ETHTOOL_GEEPROM */
 408
 409 #ifndef ETHTOOL_GLINK
 410 #define ETHTOOL_GLINK 0xa
 411 #endif /* ETHTOOL_GLINK */
 412
 413 #ifndef ETHTOOL_GWOL
 414 #define ETHTOOL_GWOL 0x5
 415 #define ETHTOOL_SWOL 0x6
 416 #define SOPASS_MAX      6
 417 struct ethtool_wolinfo {
 418         u32 cmd;
 419         u32 supported;
 420         u32 wolopts;
 421         u8 sopass[SOPASS_MAX]; /* SecureOn(tm) password */
 422 };
 423 #endif /* ETHTOOL_GWOL */
 424
 425 #ifndef ETHTOOL_GREGS
 426 #define ETHTOOL_GREGS           0x00000004 /* Get NIC registers */
 427 #define ethtool_regs _kc_ethtool_regs
 428 /* for passing big chunks of data */
 429 struct _kc_ethtool_regs {
 430         u32 cmd;
 431         u32 version; /* driver-specific, indicates different chips/revs */
 432         u32 len; /* bytes */
 433         u8 data[0];
 434 };
 435 #endif /* ETHTOOL_GREGS */
 436
 437 #ifndef ETHTOOL_GMSGLVL
 438 #define ETHTOOL_GMSGLVL         0x00000007 /* Get driver message level */
 439 #endif
 440 #ifndef ETHTOOL_SMSGLVL
 441 #define ETHTOOL_SMSGLVL         0x00000008 /* Set driver msg level, priv. */
 442 #endif
 443 #ifndef ETHTOOL_NWAY_RST
 444 #define ETHTOOL_NWAY_RST        0x00000009 /* Restart autonegotiation, priv */
 445 #endif
 446 #ifndef ETHTOOL_GLINK
 447 #define ETHTOOL_GLINK           0x0000000a /* Get link status */
 448 #endif
 449 #ifndef ETHTOOL_GEEPROM
 450 #define ETHTOOL_GEEPROM         0x0000000b /* Get EEPROM data */
 451 #endif
 452 #ifndef ETHTOOL_SEEPROM
 453 #define ETHTOOL_SEEPROM         0x0000000c /* Set EEPROM data */
 454 #endif
 455 #ifndef ETHTOOL_GCOALESCE
 456 #define ETHTOOL_GCOALESCE       0x0000000e /* Get coalesce config */
 457 /* for configuring coalescing parameters of chip */
 458 #define ethtool_coalesce _kc_ethtool_coalesce
 459 struct _kc_ethtool_coalesce {
 460         u32     cmd;    /* ETHTOOL_{G,S}COALESCE */
 461
 462         /* How many usecs to delay an RX interrupt after
 463          * a packet arrives.  If 0, only rx_max_coalesced_frames
 464          * is used.
 465          */
 466         u32     rx_coalesce_usecs;
 467
 468         /* How many packets to delay an RX interrupt after
 469          * a packet arrives.  If 0, only rx_coalesce_usecs is
 470          * used.  It is illegal to set both usecs and max frames
 471          * to zero as this would cause RX interrupts to never be
 472          * generated.
 473          */
 474         u32     rx_max_coalesced_frames;
 475
 476         /* Same as above two parameters, except that these values
 477          * apply while an IRQ is being serviced by the host.  Not
 478          * all cards support this feature and the values are ignored
 479          * in that case.
 480          */
 481         u32     rx_coalesce_usecs_irq;
 482         u32     rx_max_coalesced_frames_irq;
 483
 484         /* How many usecs to delay a TX interrupt after
 485          * a packet is sent.  If 0, only tx_max_coalesced_frames
 486          * is used.
 487          */
 488         u32     tx_coalesce_usecs;
 489
 490         /* How many packets to delay a TX interrupt after
 491          * a packet is sent.  If 0, only tx_coalesce_usecs is
 492          * used.  It is illegal to set both usecs and max frames
 493          * to zero as this would cause TX interrupts to never be
 494          * generated.
 495          */
 496         u32     tx_max_coalesced_frames;
 497
 498         /* Same as above two parameters, except that these values
 499          * apply while an IRQ is being serviced by the host.  Not
 500          * all cards support this feature and the values are ignored
 501          * in that case.
 502          */
 503         u32     tx_coalesce_usecs_irq;
 504         u32     tx_max_coalesced_frames_irq;
 505
 506         /* How many usecs to delay in-memory statistics
 507          * block updates.  Some drivers do not have an in-memory
 508          * statistic block, and in such cases this value is ignored.
 509          * This value must not be zero.
 510          */
 511         u32     stats_block_coalesce_usecs;
 512
 513         /* Adaptive RX/TX coalescing is an algorithm implemented by
 514          * some drivers to improve latency under low packet rates and
 515          * improve throughput under high packet rates.  Some drivers
 516          * only implement one of RX or TX adaptive coalescing.  Anything
 517          * not implemented by the driver causes these values to be
 518          * silently ignored.
 519          */
 520         u32     use_adaptive_rx_coalesce;
 521         u32     use_adaptive_tx_coalesce;
 522
 523         /* When the packet rate (measured in packets per second)
 524          * is below pkt_rate_low, the {rx,tx}_*_low parameters are
 525          * used.
 526          */
 527         u32     pkt_rate_low;
 528         u32     rx_coalesce_usecs_low;
 529         u32     rx_max_coalesced_frames_low;
 530         u32     tx_coalesce_usecs_low;
 531         u32     tx_max_coalesced_frames_low;
 532
 533         /* When the packet rate is below pkt_rate_high but above
 534          * pkt_rate_low (both measured in packets per second) the
 535          * normal {rx,tx}_* coalescing parameters are used.
 536          */
 537
 538         /* When the packet rate is (measured in packets per second)
 539          * is above pkt_rate_high, the {rx,tx}_*_high parameters are
 540          * used.
 541          */
 542         u32     pkt_rate_high;
 543         u32     rx_coalesce_usecs_high;
 544         u32     rx_max_coalesced_frames_high;
 545         u32     tx_coalesce_usecs_high;
 546         u32     tx_max_coalesced_frames_high;
 547
 548         /* How often to do adaptive coalescing packet rate sampling,
 549          * measured in seconds.  Must not be zero.
 550          */
 551         u32     rate_sample_interval;
 552 };
 553 #endif /* ETHTOOL_GCOALESCE */
 554
 555 #ifndef ETHTOOL_SCOALESCE
 556 #define ETHTOOL_SCOALESCE       0x0000000f /* Set coalesce config. */
 557 #endif
 558 #ifndef ETHTOOL_GRINGPARAM
 559 #define ETHTOOL_GRINGPARAM      0x00000010 /* Get ring parameters */
 560 /* for configuring RX/TX ring parameters */
 561 #define ethtool_ringparam _kc_ethtool_ringparam
 562 struct _kc_ethtool_ringparam {
 563         u32     cmd;    /* ETHTOOL_{G,S}RINGPARAM */
 564
 565         /* Read only attributes.  These indicate the maximum number
 566          * of pending RX/TX ring entries the driver will allow the
 567          * user to set.
 568          */
 569         u32     rx_max_pending;
 570         u32     rx_mini_max_pending;
 571         u32     rx_jumbo_max_pending;
 572         u32     tx_max_pending;
 573
 574         /* Values changeable by the user.  The valid values are
 575          * in the range 1 to the "*_max_pending" counterpart above.
 576          */
 577         u32     rx_pending;
 578         u32     rx_mini_pending;
 579         u32     rx_jumbo_pending;
 580         u32     tx_pending;
 581 };
 582 #endif /* ETHTOOL_GRINGPARAM */
 583
 584 #ifndef ETHTOOL_SRINGPARAM
 585 #define ETHTOOL_SRINGPARAM      0x00000011 /* Set ring parameters, priv. */
 586 #endif
 587 #ifndef ETHTOOL_GPAUSEPARAM
 588 #define ETHTOOL_GPAUSEPARAM     0x00000012 /* Get pause parameters */
 589 /* for configuring link flow control parameters */
 590 #define ethtool_pauseparam _kc_ethtool_pauseparam
 591 struct _kc_ethtool_pauseparam {
 592         u32     cmd;    /* ETHTOOL_{G,S}PAUSEPARAM */
 593
 594         /* If the link is being auto-negotiated (via ethtool_cmd.autoneg
 595          * being true) the user may set 'autoneg' here non-zero to have the
 596          * pause parameters be auto-negotiated too.  In such a case, the
 597          * {rx,tx}_pause values below determine what capabilities are
 598          * advertised.
 599          *
 600          * If 'autoneg' is zero or the link is not being auto-negotiated,
 601          * then {rx,tx}_pause force the driver to use/not-use pause
 602          * flow control.
 603          */
 604         u32     autoneg;
 605         u32     rx_pause;
 606         u32     tx_pause;
 607 };
 608 #endif /* ETHTOOL_GPAUSEPARAM */
 609
 610 #ifndef ETHTOOL_SPAUSEPARAM
 611 #define ETHTOOL_SPAUSEPARAM     0x00000013 /* Set pause parameters. */
 612 #endif
 613 #ifndef ETHTOOL_GRXCSUM
 614 #define ETHTOOL_GRXCSUM         0x00000014 /* Get RX hw csum enable (ethtool_value) */
 615 #endif
 616 #ifndef ETHTOOL_SRXCSUM
 617 #define ETHTOOL_SRXCSUM         0x00000015 /* Set RX hw csum enable (ethtool_value) */
 618 #endif
 619 #ifndef ETHTOOL_GTXCSUM
 620 #define ETHTOOL_GTXCSUM         0x00000016 /* Get TX hw csum enable (ethtool_value) */
 621 #endif
 622 #ifndef ETHTOOL_STXCSUM
 623 #define ETHTOOL_STXCSUM         0x00000017 /* Set TX hw csum enable (ethtool_value) */
 624 #endif
 625 #ifndef ETHTOOL_GSG
 626 #define ETHTOOL_GSG             0x00000018 /* Get scatter-gather enable
 627                                             * (ethtool_value) */
 628 #endif
 629 #ifndef ETHTOOL_SSG
 630 #define ETHTOOL_SSG             0x00000019 /* Set scatter-gather enable
 631                                             * (ethtool_value). */
 632 #endif
 633 #ifndef ETHTOOL_TEST
 634 #define ETHTOOL_TEST            0x0000001a /* execute NIC self-test, priv. */
 635 #endif
 636 #ifndef ETHTOOL_GSTRINGS
 637 #define ETHTOOL_GSTRINGS        0x0000001b /* get specified string set */
 638 #endif
 639 #ifndef ETHTOOL_PHYS_ID
 640 #define ETHTOOL_PHYS_ID         0x0000001c /* identify the NIC */
 641 #endif
 642 #ifndef ETHTOOL_GSTATS
 643 #define ETHTOOL_GSTATS          0x0000001d /* get NIC-specific statistics */
 644 #endif
 645 #ifndef ETHTOOL_GTSO
 646 #define ETHTOOL_GTSO            0x0000001e /* Get TSO enable (ethtool_value) */
 647 #endif
 648 #ifndef ETHTOOL_STSO
 649 #define ETHTOOL_STSO            0x0000001f /* Set TSO enable (ethtool_value) */
 650 #endif
 651
 652 #ifndef ETHTOOL_BUSINFO_LEN
 653 #define ETHTOOL_BUSINFO_LEN     32
 654 #endif
 655
 656 #ifndef RHEL_RELEASE_VERSION
 657 #define RHEL_RELEASE_VERSION(a,b) (((a) << 8) + (b))
 658 #endif
 659 #ifndef AX_RELEASE_VERSION
 660 #define AX_RELEASE_VERSION(a,b) (((a) << 8) + (b))
 661 #endif
 662
 663 #ifndef AX_RELEASE_CODE
 664 #define AX_RELEASE_CODE 0
 665 #endif
 666
 667 #if (AX_RELEASE_CODE && AX_RELEASE_CODE == AX_RELEASE_VERSION(3,0))
 668 #define RHEL_RELEASE_CODE RHEL_RELEASE_VERSION(5,0)
 669 #elif (AX_RELEASE_CODE && AX_RELEASE_CODE == AX_RELEASE_VERSION(3,1))
 670 #define RHEL_RELEASE_CODE RHEL_RELEASE_VERSION(5,1)
 671 #elif (AX_RELEASE_CODE && AX_RELEASE_CODE == AX_RELEASE_VERSION(3,2))
 672 #define RHEL_RELEASE_CODE RHEL_RELEASE_VERSION(5,3)
 673 #endif
 674
 675 #ifndef RHEL_RELEASE_CODE
 676 /* NOTE: RHEL_RELEASE_* introduced in RHEL4.5 */
 677 #define RHEL_RELEASE_CODE 0
 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 #ifdef CONFIG_SUSE_KERNEL
 685 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 57))
 686 /* SLES12SP3 is at least 4.4.57+ based */
 687 #define SLE_VERSION_CODE SLE_VERSION(12, 3, 0)
 688 #elif ( LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,28) )
 689 /* SLES12 is at least 3.12.28+ based */
 690 #define SLE_VERSION_CODE SLE_VERSION(12,0,0)
 691 #elif ((LINUX_VERSION_CODE >= KERNEL_VERSION(3,0,61)) && \
 692        (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0)))
 693 /* SLES11 SP3 is at least 3.0.61+ based */
 694 #define SLE_VERSION_CODE SLE_VERSION(11,3,0)
 695 #elif ( LINUX_VERSION_CODE == KERNEL_VERSION(2,6,32) )
 696 /* SLES11 SP1 is 2.6.32 based */
 697 #define SLE_VERSION_CODE SLE_VERSION(11,1,0)
 698 #elif ( LINUX_VERSION_CODE == KERNEL_VERSION(2,6,27) )
 699 /* SLES11 GA is 2.6.27 based */
 700 #define SLE_VERSION_CODE SLE_VERSION(11,0,0)
 701 #endif /* LINUX_VERSION_CODE == KERNEL_VERSION(x,y,z) */
 702 #endif /* CONFIG_SUSE_KERNEL */
 703 #ifndef SLE_VERSION_CODE
 704 #define SLE_VERSION_CODE 0
 705 #endif /* SLE_VERSION_CODE */
 706
 707 /* Ubuntu release and kernel codes must be specified from Makefile */
 708 #ifndef UBUNTU_RELEASE_VERSION
 709 #define UBUNTU_RELEASE_VERSION(a,b) (((a) * 100) + (b))
 710 #endif
 711 #ifndef UBUNTU_KERNEL_VERSION
 712 #define UBUNTU_KERNEL_VERSION(a,b,c,abi,upload) (((a) << 40) + ((b) << 32) + ((c) << 24) + ((abi) << 8) + (upload))
 713 #endif
 714 #ifndef UBUNTU_RELEASE_CODE
 715 #define UBUNTU_RELEASE_CODE 0
 716 #endif
 717 #ifndef UBUNTU_KERNEL_CODE
 718 #define UBUNTU_KERNEL_CODE 0
 719 #endif
 720
 721 #ifdef __KLOCWORK__
 722 #ifdef ARRAY_SIZE
 723 #undef ARRAY_SIZE
 724 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
 725 #endif
 726 #endif /* __KLOCWORK__ */
 727
 728 /*****************************************************************************/
 729 /* 2.4.3 => 2.4.0 */
 730 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,3) )
 731
 732 /**************************************/
 733 /* PCI DRIVER API */
 734
 735 #ifndef pci_set_dma_mask
 736 #define pci_set_dma_mask _kc_pci_set_dma_mask
 737 extern int _kc_pci_set_dma_mask(struct pci_dev *dev, dma_addr_t mask);
 738 #endif
 739
 740 #ifndef pci_request_regions
 741 #define pci_request_regions _kc_pci_request_regions
 742 extern int _kc_pci_request_regions(struct pci_dev *pdev, char *res_name);
 743 #endif
 744
 745 #ifndef pci_release_regions
 746 #define pci_release_regions _kc_pci_release_regions
 747 extern void _kc_pci_release_regions(struct pci_dev *pdev);
 748 #endif
 749
 750 /**************************************/
 751 /* NETWORK DRIVER API */
 752
 753 #ifndef alloc_etherdev
 754 #define alloc_etherdev _kc_alloc_etherdev
 755 extern struct net_device * _kc_alloc_etherdev(int sizeof_priv);
 756 #endif
 757
 758 #ifndef is_valid_ether_addr
 759 #define is_valid_ether_addr _kc_is_valid_ether_addr
 760 extern int _kc_is_valid_ether_addr(u8 *addr);
 761 #endif
 762
 763 /**************************************/
 764 /* MISCELLANEOUS */
 765
 766 #ifndef INIT_TQUEUE
 767 #define INIT_TQUEUE(_tq, _routine, _data)               \
 768         do {                                            \
 769                 INIT_LIST_HEAD(&(_tq)->list);           \
 770                 (_tq)->sync = 0;                        \
 771                 (_tq)->routine = _routine;              \
 772                 (_tq)->data = _data;                    \
 773         } while (0)
 774 #endif
 775
 776 #endif /* 2.4.3 => 2.4.0 */
 777
 778 /*****************************************************************************/
 779 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,5) )
 780 /* Generic MII registers. */
 781 #define MII_BMCR            0x00        /* Basic mode control register */
 782 #define MII_BMSR            0x01        /* Basic mode status register  */
 783 #define MII_PHYSID1         0x02        /* PHYS ID 1                   */
 784 #define MII_PHYSID2         0x03        /* PHYS ID 2                   */
 785 #define MII_ADVERTISE       0x04        /* Advertisement control reg   */
 786 #define MII_LPA             0x05        /* Link partner ability reg    */
 787 #define MII_EXPANSION       0x06        /* Expansion register          */
 788 /* Basic mode control register. */
 789 #define BMCR_FULLDPLX           0x0100  /* Full duplex                 */
 790 #define BMCR_ANENABLE           0x1000  /* Enable auto negotiation     */
 791 /* Basic mode status register. */
 792 #define BMSR_ERCAP              0x0001  /* Ext-reg capability          */
 793 #define BMSR_ANEGCAPABLE        0x0008  /* Able to do auto-negotiation */
 794 #define BMSR_10HALF             0x0800  /* Can do 10mbps, half-duplex  */
 795 #define BMSR_10FULL             0x1000  /* Can do 10mbps, full-duplex  */
 796 #define BMSR_100HALF            0x2000  /* Can do 100mbps, half-duplex */
 797 #define BMSR_100FULL            0x4000  /* Can do 100mbps, full-duplex */
 798 /* Advertisement control register. */
 799 #define ADVERTISE_CSMA          0x0001  /* Only selector supported     */
 800 #define ADVERTISE_10HALF        0x0020  /* Try for 10mbps half-duplex  */
 801 #define ADVERTISE_10FULL        0x0040  /* Try for 10mbps full-duplex  */
 802 #define ADVERTISE_100HALF       0x0080  /* Try for 100mbps half-duplex */
 803 #define ADVERTISE_100FULL       0x0100  /* Try for 100mbps full-duplex */
 804 #define ADVERTISE_ALL (ADVERTISE_10HALF | ADVERTISE_10FULL | \
 805                        ADVERTISE_100HALF | ADVERTISE_100FULL)
 806 /* Expansion register for auto-negotiation. */
 807 #define EXPANSION_ENABLENPAGE   0x0004  /* This enables npage words    */
 808 #endif
 809
 810 /*****************************************************************************/
 811 /* 2.4.6 => 2.4.3 */
 812 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,6) )
 813
 814 #ifndef pci_set_power_state
 815 #define pci_set_power_state _kc_pci_set_power_state
 816 extern int _kc_pci_set_power_state(struct pci_dev *dev, int state);
 817 #endif
 818
 819 #ifndef pci_enable_wake
 820 #define pci_enable_wake _kc_pci_enable_wake
 821 extern int _kc_pci_enable_wake(struct pci_dev *pdev, u32 state, int enable);
 822 #endif
 823
 824 #ifndef pci_disable_device
 825 #define pci_disable_device _kc_pci_disable_device
 826 extern void _kc_pci_disable_device(struct pci_dev *pdev);
 827 #endif
 828
 829 /* PCI PM entry point syntax changed, so don't support suspend/resume */
 830 #undef CONFIG_PM
 831
 832 #endif /* 2.4.6 => 2.4.3 */
 833
 834 #ifndef HAVE_PCI_SET_MWI
 835 #define pci_set_mwi(X) pci_write_config_word(X, \
 836                                PCI_COMMAND, adapter->hw.bus.pci_cmd_word | \
 837                                PCI_COMMAND_INVALIDATE);
 838 #define pci_clear_mwi(X) pci_write_config_word(X, \
 839                                PCI_COMMAND, adapter->hw.bus.pci_cmd_word & \
 840                                ~PCI_COMMAND_INVALIDATE);
 841 #endif
 842
 843 /*****************************************************************************/
 844 /* 2.4.10 => 2.4.9 */
 845 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,10) )
 846
 847 /**************************************/
 848 /* MODULE API */
 849
 850 #ifndef MODULE_LICENSE
 851         #define MODULE_LICENSE(X)
 852 #endif
 853
 854 /**************************************/
 855 /* OTHER */
 856
 857 #undef min
 858 #define min(x,y) ({ \
 859         const typeof(x) _x = (x);       \
 860         const typeof(y) _y = (y);       \
 861         (void) (&_x == &_y);            \
 862         _x < _y ? _x : _y; })
 863
 864 #undef max
 865 #define max(x,y) ({ \
 866         const typeof(x) _x = (x);       \
 867         const typeof(y) _y = (y);       \
 868         (void) (&_x == &_y);            \
 869         _x > _y ? _x : _y; })
 870
 871 #define min_t(type,x,y) ({ \
 872         type _x = (x); \
 873         type _y = (y); \
 874         _x < _y ? _x : _y; })
 875
 876 #define max_t(type,x,y) ({ \
 877         type _x = (x); \
 878         type _y = (y); \
 879         _x > _y ? _x : _y; })
 880
 881 #ifndef list_for_each_safe
 882 #define list_for_each_safe(pos, n, head) \
 883         for (pos = (head)->next, n = pos->next; pos != (head); \
 884                 pos = n, n = pos->next)
 885 #endif
 886
 887 #ifndef ____cacheline_aligned_in_smp
 888 #ifdef CONFIG_SMP
 889 #define ____cacheline_aligned_in_smp ____cacheline_aligned
 890 #else
 891 #define ____cacheline_aligned_in_smp
 892 #endif /* CONFIG_SMP */
 893 #endif
 894
 895 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,8) )
 896 extern int _kc_snprintf(char * buf, size_t size, const char *fmt, ...);
 897 #define snprintf(buf, size, fmt, args...) _kc_snprintf(buf, size, fmt, ##args)
 898 extern int _kc_vsnprintf(char *buf, size_t size, const char *fmt, va_list args);
 899 #define vsnprintf(buf, size, fmt, args) _kc_vsnprintf(buf, size, fmt, args)
 900 #else /* 2.4.8 => 2.4.9 */
 901 extern int snprintf(char * buf, size_t size, const char *fmt, ...);
 902 extern int vsnprintf(char *buf, size_t size, const char *fmt, va_list args);
 903 #endif
 904 #endif /* 2.4.10 -> 2.4.6 */
 905
 906
 907 /*****************************************************************************/
 908 /* 2.4.12 => 2.4.10 */
 909 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,12) )
 910 #ifndef HAVE_NETIF_MSG
 911 #define HAVE_NETIF_MSG 1
 912 enum {
 913         NETIF_MSG_DRV           = 0x0001,
 914         NETIF_MSG_PROBE         = 0x0002,
 915         NETIF_MSG_LINK          = 0x0004,
 916         NETIF_MSG_TIMER         = 0x0008,
 917         NETIF_MSG_IFDOWN        = 0x0010,
 918         NETIF_MSG_IFUP          = 0x0020,
 919         NETIF_MSG_RX_ERR        = 0x0040,
 920         NETIF_MSG_TX_ERR        = 0x0080,
 921         NETIF_MSG_TX_QUEUED     = 0x0100,
 922         NETIF_MSG_INTR          = 0x0200,
 923         NETIF_MSG_TX_DONE       = 0x0400,
 924         NETIF_MSG_RX_STATUS     = 0x0800,
 925         NETIF_MSG_PKTDATA       = 0x1000,
 926         NETIF_MSG_HW            = 0x2000,
 927         NETIF_MSG_WOL           = 0x4000,
 928 };
 929
 930 #define netif_msg_drv(p)        ((p)->msg_enable & NETIF_MSG_DRV)
 931 #define netif_msg_probe(p)      ((p)->msg_enable & NETIF_MSG_PROBE)
 932 #define netif_msg_link(p)       ((p)->msg_enable & NETIF_MSG_LINK)
 933 #define netif_msg_timer(p)      ((p)->msg_enable & NETIF_MSG_TIMER)
 934 #define netif_msg_ifdown(p)     ((p)->msg_enable & NETIF_MSG_IFDOWN)
 935 #define netif_msg_ifup(p)       ((p)->msg_enable & NETIF_MSG_IFUP)
 936 #define netif_msg_rx_err(p)     ((p)->msg_enable & NETIF_MSG_RX_ERR)
 937 #define netif_msg_tx_err(p)     ((p)->msg_enable & NETIF_MSG_TX_ERR)
 938 #define netif_msg_tx_queued(p)  ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
 939 #define netif_msg_intr(p)       ((p)->msg_enable & NETIF_MSG_INTR)
 940 #define netif_msg_tx_done(p)    ((p)->msg_enable & NETIF_MSG_TX_DONE)
 941 #define netif_msg_rx_status(p)  ((p)->msg_enable & NETIF_MSG_RX_STATUS)
 942 #define netif_msg_pktdata(p)    ((p)->msg_enable & NETIF_MSG_PKTDATA)
 943 #endif /* !HAVE_NETIF_MSG */
 944 #endif /* 2.4.12 => 2.4.10 */
 945
 946 /*****************************************************************************/
 947 /* 2.4.13 => 2.4.12 */
 948 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,13) )
 949
 950 /**************************************/
 951 /* PCI DMA MAPPING */
 952
 953 #ifndef virt_to_page
 954         #define virt_to_page(v) (mem_map + (virt_to_phys(v) >> PAGE_SHIFT))
 955 #endif
 956
 957 #ifndef pci_map_page
 958 #define pci_map_page _kc_pci_map_page
 959 extern u64 _kc_pci_map_page(struct pci_dev *dev, struct page *page, unsigned long offset, size_t size, int direction);
 960 #endif
 961
 962 #ifndef pci_unmap_page
 963 #define pci_unmap_page _kc_pci_unmap_page
 964 extern void _kc_pci_unmap_page(struct pci_dev *dev, u64 dma_addr, size_t size, int direction);
 965 #endif
 966
 967 /* pci_set_dma_mask takes dma_addr_t, which is only 32-bits prior to 2.4.13 */
 968
 969 #undef DMA_32BIT_MASK
 970 #define DMA_32BIT_MASK  0xffffffff
 971 #undef DMA_64BIT_MASK
 972 #define DMA_64BIT_MASK  0xffffffff
 973
 974 /**************************************/
 975 /* OTHER */
 976
 977 #ifndef cpu_relax
 978 #define cpu_relax()     rep_nop()
 979 #endif
 980
 981 struct vlan_ethhdr {
 982         unsigned char h_dest[ETH_ALEN];
 983         unsigned char h_source[ETH_ALEN];
 984         unsigned short h_vlan_proto;
 985         unsigned short h_vlan_TCI;
 986         unsigned short h_vlan_encapsulated_proto;
 987 };
 988 #endif /* 2.4.13 => 2.4.12 */
 989
 990 /*****************************************************************************/
 991 /* 2.4.17 => 2.4.12 */
 992 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,17) )
 993
 994 #ifndef __devexit_p
 995         #define __devexit_p(x) &(x)
 996 #endif
 997
 998 #else
 999         /* For Kernel 3.8 these are not defined - so undefine all */
1000         #undef __devexit_p
1001         #undef __devexit
1002         #undef __devinit
1003         #undef __devinitdata
1004         #define __devexit_p(x) &(x)
1005         #define __devexit
1006         #define __devinit
1007         #define __devinitdata
1008
1009 #endif /* 2.4.17 => 2.4.13 */
1010
1011 /*****************************************************************************/
1012 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,18) )
1013 #define NETIF_MSG_HW    0x2000
1014 #define NETIF_MSG_WOL   0x4000
1015
1016 #ifndef netif_msg_hw
1017 #define netif_msg_hw(p)         ((p)->msg_enable & NETIF_MSG_HW)
1018 #endif
1019 #ifndef netif_msg_wol
1020 #define netif_msg_wol(p)        ((p)->msg_enable & NETIF_MSG_WOL)
1021 #endif
1022 #endif /* 2.4.18 */
1023
1024 /*****************************************************************************/
1025
1026 /*****************************************************************************/
1027 /* 2.4.20 => 2.4.19 */
1028 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,20) )
1029
1030 /* we won't support NAPI on less than 2.4.20 */
1031 #ifdef NAPI
1032 #undef NAPI
1033 #endif
1034
1035 #endif /* 2.4.20 => 2.4.19 */
1036
1037 /*****************************************************************************/
1038 /* 2.4.22 => 2.4.17 */
1039 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,22) )
1040 #define pci_name(x)     ((x)->slot_name)
1041
1042 #ifndef SUPPORTED_10000baseT_Full
1043 #define SUPPORTED_10000baseT_Full       (1 << 12)
1044 #endif
1045 #ifndef ADVERTISED_10000baseT_Full
1046 #define ADVERTISED_10000baseT_Full      (1 << 12)
1047 #endif
1048 #endif
1049
1050 /*****************************************************************************/
1051 /* 2.4.22 => 2.4.17 */
1052
1053 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,22) )
1054 #ifndef IGB_NO_LRO
1055 #define IGB_NO_LRO
1056 #endif
1057 #endif
1058
1059 /*****************************************************************************/
1060 /*****************************************************************************/
1061 /* 2.4.23 => 2.4.22 */
1062 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,23) )
1063 /*****************************************************************************/
1064 #ifdef NAPI
1065 #ifndef netif_poll_disable
1066 #define netif_poll_disable(x) _kc_netif_poll_disable(x)
1067 static inline void _kc_netif_poll_disable(struct net_device *netdev)
1068 {
1069         while (test_and_set_bit(__LINK_STATE_RX_SCHED, &netdev->state)) {
1070                 /* No hurry */
1071                 current->state = TASK_INTERRUPTIBLE;
1072                 schedule_timeout(1);
1073         }
1074 }
1075 #endif
1076 #ifndef netif_poll_enable
1077 #define netif_poll_enable(x) _kc_netif_poll_enable(x)
1078 static inline void _kc_netif_poll_enable(struct net_device *netdev)
1079 {
1080         clear_bit(__LINK_STATE_RX_SCHED, &netdev->state);
1081 }
1082 #endif
1083 #endif /* NAPI */
1084 #ifndef netif_tx_disable
1085 #define netif_tx_disable(x) _kc_netif_tx_disable(x)
1086 static inline void _kc_netif_tx_disable(struct net_device *dev)
1087 {
1088         spin_lock_bh(&dev->xmit_lock);
1089         netif_stop_queue(dev);
1090         spin_unlock_bh(&dev->xmit_lock);
1091 }
1092 #endif
1093 #else /* 2.4.23 => 2.4.22 */
1094 #define HAVE_SCTP
1095 #endif /* 2.4.23 => 2.4.22 */
1096
1097 /*****************************************************************************/
1098 /* 2.6.4 => 2.6.0 */
1099 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,25) || \
1100     ( LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) && \
1101       LINUX_VERSION_CODE < KERNEL_VERSION(2,6,4) ) )
1102 #define ETHTOOL_OPS_COMPAT
1103 #endif /* 2.6.4 => 2.6.0 */
1104
1105 /*****************************************************************************/
1106 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,27) )
1107 #define __user
1108 #endif /* < 2.4.27 */
1109
1110 /*****************************************************************************/
1111 /* 2.5.71 => 2.4.x */
1112 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,5,71) )
1113 #define sk_protocol protocol
1114 #define pci_get_device pci_find_device
1115 #endif /* 2.5.70 => 2.4.x */
1116
1117 /*****************************************************************************/
1118 /* < 2.4.27 or 2.6.0 <= 2.6.5 */
1119 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,27) || \
1120     ( LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) && \
1121       LINUX_VERSION_CODE < KERNEL_VERSION(2,6,5) ) )
1122
1123 #ifndef netif_msg_init
1124 #define netif_msg_init _kc_netif_msg_init
1125 static inline u32 _kc_netif_msg_init(int debug_value, int default_msg_enable_bits)
1126 {
1127         /* use default */
1128         if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
1129                 return default_msg_enable_bits;
1130         if (debug_value == 0) /* no output */
1131                 return 0;
1132         /* set low N bits */
1133         return (1 << debug_value) -1;
1134 }
1135 #endif
1136
1137 #endif /* < 2.4.27 or 2.6.0 <= 2.6.5 */
1138 /*****************************************************************************/
1139 #if (( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,27) ) || \
1140      (( LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) ) && \
1141       ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,3) )))
1142 #define netdev_priv(x) x->priv
1143 #endif
1144
1145 /*****************************************************************************/
1146 /* <= 2.5.0 */
1147 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0) )
1148 #include <linux/rtnetlink.h>
1149 #undef pci_register_driver
1150 #define pci_register_driver pci_module_init
1151
1152 /*
1153  * Most of the dma compat code is copied/modified from the 2.4.37
1154  * /include/linux/libata-compat.h header file
1155  */
1156 /* These definitions mirror those in pci.h, so they can be used
1157  * interchangeably with their PCI_ counterparts */
1158 enum dma_data_direction {
1159         DMA_BIDIRECTIONAL = 0,
1160         DMA_TO_DEVICE = 1,
1161         DMA_FROM_DEVICE = 2,
1162         DMA_NONE = 3,
1163 };
1164
1165 struct device {
1166         struct pci_dev pdev;
1167 };
1168
1169 static inline struct pci_dev *to_pci_dev (struct device *dev)
1170 {
1171         return (struct pci_dev *) dev;
1172 }
1173 static inline struct device *pci_dev_to_dev(struct pci_dev *pdev)
1174 {
1175         return (struct device *) pdev;
1176 }
1177
1178 #define pdev_printk(lvl, pdev, fmt, args...)    \
1179         printk("%s %s: " fmt, lvl, pci_name(pdev), ## args)
1180 #define dev_err(dev, fmt, args...)            \
1181         pdev_printk(KERN_ERR, to_pci_dev(dev), fmt, ## args)
1182 #define dev_info(dev, fmt, args...)            \
1183         pdev_printk(KERN_INFO, to_pci_dev(dev), fmt, ## args)
1184 #define dev_warn(dev, fmt, args...)            \
1185         pdev_printk(KERN_WARNING, to_pci_dev(dev), fmt, ## args)
1186 #define dev_notice(dev, fmt, args...)            \
1187         pdev_printk(KERN_NOTICE, to_pci_dev(dev), fmt, ## args)
1188 #define dev_dbg(dev, fmt, args...) \
1189         pdev_printk(KERN_DEBUG, to_pci_dev(dev), fmt, ## args)
1190
1191 /* NOTE: dangerous! we ignore the 'gfp' argument */
1192 #define dma_alloc_coherent(dev,sz,dma,gfp) \
1193         pci_alloc_consistent(to_pci_dev(dev),(sz),(dma))
1194 #define dma_free_coherent(dev,sz,addr,dma_addr) \
1195         pci_free_consistent(to_pci_dev(dev),(sz),(addr),(dma_addr))
1196
1197 #define dma_map_page(dev,a,b,c,d) \
1198         pci_map_page(to_pci_dev(dev),(a),(b),(c),(d))
1199 #define dma_unmap_page(dev,a,b,c) \
1200         pci_unmap_page(to_pci_dev(dev),(a),(b),(c))
1201
1202 #define dma_map_single(dev,a,b,c) \
1203         pci_map_single(to_pci_dev(dev),(a),(b),(c))
1204 #define dma_unmap_single(dev,a,b,c) \
1205         pci_unmap_single(to_pci_dev(dev),(a),(b),(c))
1206
1207 #define dma_map_sg(dev, sg, nents, dir) \
1208         pci_map_sg(to_pci_dev(dev), (sg), (nents), (dir)
1209 #define dma_unmap_sg(dev, sg, nents, dir) \
1210         pci_unmap_sg(to_pci_dev(dev), (sg), (nents), (dir)
1211
1212 #define dma_sync_single(dev,a,b,c) \
1213         pci_dma_sync_single(to_pci_dev(dev),(a),(b),(c))
1214
1215 /* for range just sync everything, that's all the pci API can do */
1216 #define dma_sync_single_range(dev,addr,off,sz,dir) \
1217         pci_dma_sync_single(to_pci_dev(dev),(addr),(off)+(sz),(dir))
1218
1219 #define dma_set_mask(dev,mask) \
1220         pci_set_dma_mask(to_pci_dev(dev),(mask))
1221
1222 /* hlist_* code - double linked lists */
1223 struct hlist_head {
1224         struct hlist_node *first;
1225 };
1226
1227 struct hlist_node {
1228         struct hlist_node *next, **pprev;
1229 };
1230
1231 static inline void __hlist_del(struct hlist_node *n)
1232 {
1233         struct hlist_node *next = n->next;
1234         struct hlist_node **pprev = n->pprev;
1235         *pprev = next;
1236         if (next)
1237         next->pprev = pprev;
1238 }
1239
1240 static inline void hlist_del(struct hlist_node *n)
1241 {
1242         __hlist_del(n);
1243         n->next = NULL;
1244         n->pprev = NULL;
1245 }
1246
1247 static inline void hlist_add_head(struct hlist_node *n, struct hlist_head *h)
1248 {
1249         struct hlist_node *first = h->first;
1250         n->next = first;
1251         if (first)
1252                 first->pprev = &n->next;
1253         h->first = n;
1254         n->pprev = &h->first;
1255 }
1256
1257 static inline int hlist_empty(const struct hlist_head *h)
1258 {
1259         return !h->first;
1260 }
1261 #define HLIST_HEAD_INIT { .first = NULL }
1262 #define HLIST_HEAD(name) struct hlist_head name = {  .first = NULL }
1263 #define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL)
1264 static inline void INIT_HLIST_NODE(struct hlist_node *h)
1265 {
1266         h->next = NULL;
1267         h->pprev = NULL;
1268 }
1269
1270 #ifndef might_sleep
1271 #define might_sleep()
1272 #endif
1273 #else
1274 static inline struct device *pci_dev_to_dev(struct pci_dev *pdev)
1275 {
1276         return &pdev->dev;
1277 }
1278 #endif /* <= 2.5.0 */
1279
1280 /*****************************************************************************/
1281 /* 2.5.28 => 2.4.23 */
1282 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,5,28) )
1283
1284 #include <linux/tqueue.h>
1285 #define work_struct tq_struct
1286 #undef INIT_WORK
1287 #define INIT_WORK(a,b) INIT_TQUEUE(a,(void (*)(void *))b,a)
1288 #undef container_of
1289 #define container_of list_entry
1290 #define schedule_work schedule_task
1291 #define flush_scheduled_work flush_scheduled_tasks
1292 #define cancel_work_sync(x) flush_scheduled_work()
1293
1294 #endif /* 2.5.28 => 2.4.17 */
1295
1296 /*****************************************************************************/
1297 /* 2.6.0 => 2.5.28 */
1298 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) )
1299 #ifndef read_barrier_depends
1300 #define read_barrier_depends() rmb()
1301 #endif
1302
1303 #undef get_cpu
1304 #define get_cpu() smp_processor_id()
1305 #undef put_cpu
1306 #define put_cpu() do { } while(0)
1307 #define MODULE_INFO(version, _version)
1308 #ifndef CONFIG_E1000_DISABLE_PACKET_SPLIT
1309 #define CONFIG_E1000_DISABLE_PACKET_SPLIT 1
1310 #endif
1311 #ifndef CONFIG_IGB_DISABLE_PACKET_SPLIT
1312 #define CONFIG_IGB_DISABLE_PACKET_SPLIT 1
1313 #endif
1314
1315 #define dma_set_coherent_mask(dev,mask) 1
1316
1317 #undef dev_put
1318 #define dev_put(dev) __dev_put(dev)
1319
1320 #ifndef skb_fill_page_desc
1321 #define skb_fill_page_desc _kc_skb_fill_page_desc
1322 extern void _kc_skb_fill_page_desc(struct sk_buff *skb, int i, struct page *page, int off, int size);
1323 #endif
1324
1325 #undef ALIGN
1326 #define ALIGN(x,a) (((x)+(a)-1)&~((a)-1))
1327
1328 #ifndef page_count
1329 #define page_count(p) atomic_read(&(p)->count)
1330 #endif
1331
1332 #ifdef MAX_NUMNODES
1333 #undef MAX_NUMNODES
1334 #endif
1335 #define MAX_NUMNODES 1
1336
1337 /* find_first_bit and find_next bit are not defined for most
1338  * 2.4 kernels (except for the redhat 2.4.21 kernels
1339  */
1340 #include <linux/bitops.h>
1341 #define BITOP_WORD(nr)          ((nr) / BITS_PER_LONG)
1342 #undef find_next_bit
1343 #define find_next_bit _kc_find_next_bit
1344 extern unsigned long _kc_find_next_bit(const unsigned long *addr,
1345                                        unsigned long size,
1346                                        unsigned long offset);
1347 #define find_first_bit(addr, size) find_next_bit((addr), (size), 0)
1348
1349
1350 #ifndef netdev_name
1351 static inline const char *_kc_netdev_name(const struct net_device *dev)
1352 {
1353         if (strchr(dev->name, '%'))
1354                 return "(unregistered net_device)";
1355         return dev->name;
1356 }
1357 #define netdev_name(netdev)     _kc_netdev_name(netdev)
1358 #endif /* netdev_name */
1359
1360 #ifndef strlcpy
1361 #define strlcpy _kc_strlcpy
1362 extern size_t _kc_strlcpy(char *dest, const char *src, size_t size);
1363 #endif /* strlcpy */
1364
1365 #ifndef do_div
1366 #if BITS_PER_LONG == 64
1367 # define do_div(n,base) ({                                      \
1368         uint32_t __base = (base);                               \
1369         uint32_t __rem;                                         \
1370         __rem = ((uint64_t)(n)) % __base;                       \
1371         (n) = ((uint64_t)(n)) / __base;                         \
1372         __rem;                                                  \
1373  })
1374 #elif BITS_PER_LONG == 32
1375 extern uint32_t _kc__div64_32(uint64_t *dividend, uint32_t divisor);
1376 # define do_div(n,base) ({                              \
1377         uint32_t __base = (base);                       \
1378         uint32_t __rem;                                 \
1379         if (likely(((n) >> 32) == 0)) {                 \
1380                 __rem = (uint32_t)(n) % __base;         \
1381                 (n) = (uint32_t)(n) / __base;           \
1382         } else                                          \
1383                 __rem = _kc__div64_32(&(n), __base);    \
1384         __rem;                                          \
1385  })
1386 #else /* BITS_PER_LONG == ?? */
1387 # error do_div() does not yet support the C64
1388 #endif /* BITS_PER_LONG */
1389 #endif /* do_div */
1390
1391 #ifndef NSEC_PER_SEC
1392 #define NSEC_PER_SEC    1000000000L
1393 #endif
1394
1395 #undef HAVE_I2C_SUPPORT
1396 #else /* 2.6.0 */
1397 #if IS_ENABLED(CONFIG_I2C_ALGOBIT) && \
1398         (RHEL_RELEASE_CODE && (RHEL_RELEASE_CODE > RHEL_RELEASE_VERSION(4,9)))
1399 #define HAVE_I2C_SUPPORT
1400 #endif /* IS_ENABLED(CONFIG_I2C_ALGOBIT) */
1401
1402 #endif /* 2.6.0 => 2.5.28 */
1403 /*****************************************************************************/
1404 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,3) )
1405 #define dma_pool pci_pool
1406 #define dma_pool_destroy pci_pool_destroy
1407 #define dma_pool_alloc pci_pool_alloc
1408 #define dma_pool_free pci_pool_free
1409
1410 #define dma_pool_create(name,dev,size,align,allocation) \
1411        pci_pool_create((name),to_pci_dev(dev),(size),(align),(allocation))
1412 #endif /* < 2.6.3 */
1413
1414 /*****************************************************************************/
1415 /* 2.6.4 => 2.6.0 */
1416 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,4) )
1417 #define MODULE_VERSION(_version) MODULE_INFO(version, _version)
1418 #endif /* 2.6.4 => 2.6.0 */
1419
1420 /*****************************************************************************/
1421 /* 2.6.5 => 2.6.0 */
1422 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,5) )
1423 #define dma_sync_single_for_cpu         dma_sync_single
1424 #define dma_sync_single_for_device      dma_sync_single
1425 #define dma_sync_single_range_for_cpu           dma_sync_single_range
1426 #define dma_sync_single_range_for_device        dma_sync_single_range
1427 #ifndef pci_dma_mapping_error
1428 #define pci_dma_mapping_error _kc_pci_dma_mapping_error
1429 static inline int _kc_pci_dma_mapping_error(dma_addr_t dma_addr)
1430 {
1431         return dma_addr == 0;
1432 }
1433 #endif
1434 #endif /* 2.6.5 => 2.6.0 */
1435
1436 /*****************************************************************************/
1437 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,4) )
1438 extern int _kc_scnprintf(char * buf, size_t size, const char *fmt, ...);
1439 #define scnprintf(buf, size, fmt, args...) _kc_scnprintf(buf, size, fmt, ##args)
1440 #endif /* < 2.6.4 */
1441
1442 /*****************************************************************************/
1443 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,6) )
1444 /* taken from 2.6 include/linux/bitmap.h */
1445 #undef bitmap_zero
1446 #define bitmap_zero _kc_bitmap_zero
1447 static inline void _kc_bitmap_zero(unsigned long *dst, int nbits)
1448 {
1449         if (nbits <= BITS_PER_LONG)
1450                 *dst = 0UL;
1451         else {
1452                 int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long);
1453                 memset(dst, 0, len);
1454         }
1455 }
1456 #define random_ether_addr _kc_random_ether_addr
1457 static inline void _kc_random_ether_addr(u8 *addr)
1458 {
1459         get_random_bytes(addr, ETH_ALEN);
1460         addr[0] &= 0xfe; /* clear multicast */
1461         addr[0] |= 0x02; /* set local assignment */
1462 }
1463 #define page_to_nid(x) 0
1464
1465 #endif /* < 2.6.6 */
1466
1467 /*****************************************************************************/
1468 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,7) )
1469 #undef if_mii
1470 #define if_mii _kc_if_mii
1471 static inline struct mii_ioctl_data *_kc_if_mii(struct ifreq *rq)
1472 {
1473         return (struct mii_ioctl_data *) &rq->ifr_ifru;
1474 }
1475
1476 #ifndef __force
1477 #define __force
1478 #endif
1479 #endif /* < 2.6.7 */
1480
1481 /*****************************************************************************/
1482 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,8) )
1483 #ifndef PCI_EXP_DEVCTL
1484 #define PCI_EXP_DEVCTL 8
1485 #endif
1486 #ifndef PCI_EXP_DEVCTL_CERE
1487 #define PCI_EXP_DEVCTL_CERE 0x0001
1488 #endif
1489 #define PCI_EXP_FLAGS           2       /* Capabilities register */
1490 #define PCI_EXP_FLAGS_VERS      0x000f  /* Capability version */
1491 #define PCI_EXP_FLAGS_TYPE      0x00f0  /* Device/Port type */
1492 #define  PCI_EXP_TYPE_ENDPOINT  0x0     /* Express Endpoint */
1493 #define  PCI_EXP_TYPE_LEG_END   0x1     /* Legacy Endpoint */
1494 #define  PCI_EXP_TYPE_ROOT_PORT 0x4     /* Root Port */
1495 #define  PCI_EXP_TYPE_DOWNSTREAM 0x6    /* Downstream Port */
1496 #define PCI_EXP_FLAGS_SLOT      0x0100  /* Slot implemented */
1497 #define PCI_EXP_DEVCAP          4       /* Device capabilities */
1498 #define PCI_EXP_DEVSTA          10      /* Device Status */
1499 #define msleep(x)       do { set_current_state(TASK_UNINTERRUPTIBLE); \
1500                                 schedule_timeout((x * HZ)/1000 + 2); \
1501                         } while (0)
1502
1503 #endif /* < 2.6.8 */
1504
1505 /*****************************************************************************/
1506 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,9))
1507 #include <net/dsfield.h>
1508 #define __iomem
1509
1510 #ifndef kcalloc
1511 #define kcalloc(n, size, flags) _kc_kzalloc(((n) * (size)), flags)
1512 extern void *_kc_kzalloc(size_t size, int flags);
1513 #endif
1514 #define MSEC_PER_SEC    1000L
1515 static inline unsigned int _kc_jiffies_to_msecs(const unsigned long j)
1516 {
1517 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
1518         return (MSEC_PER_SEC / HZ) * j;
1519 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
1520         return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC);
1521 #else
1522         return (j * MSEC_PER_SEC) / HZ;
1523 #endif
1524 }
1525 static inline unsigned long _kc_msecs_to_jiffies(const unsigned int m)
1526 {
1527         if (m > _kc_jiffies_to_msecs(MAX_JIFFY_OFFSET))
1528                 return MAX_JIFFY_OFFSET;
1529 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
1530         return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);
1531 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
1532         return m * (HZ / MSEC_PER_SEC);
1533 #else
1534         return (m * HZ + MSEC_PER_SEC - 1) / MSEC_PER_SEC;
1535 #endif
1536 }
1537
1538 #define msleep_interruptible _kc_msleep_interruptible
1539 static inline unsigned long _kc_msleep_interruptible(unsigned int msecs)
1540 {
1541         unsigned long timeout = _kc_msecs_to_jiffies(msecs) + 1;
1542
1543         while (timeout && !signal_pending(current)) {
1544                 __set_current_state(TASK_INTERRUPTIBLE);
1545                 timeout = schedule_timeout(timeout);
1546         }
1547         return _kc_jiffies_to_msecs(timeout);
1548 }
1549
1550 /* Basic mode control register. */
1551 #define BMCR_SPEED1000          0x0040  /* MSB of Speed (1000)         */
1552
1553 #ifndef __le16
1554 #define __le16 u16
1555 #endif
1556 #ifndef __le32
1557 #define __le32 u32
1558 #endif
1559 #ifndef __le64
1560 #define __le64 u64
1561 #endif
1562 #ifndef __be16
1563 #define __be16 u16
1564 #endif
1565 #ifndef __be32
1566 #define __be32 u32
1567 #endif
1568 #ifndef __be64
1569 #define __be64 u64
1570 #endif
1571
1572 static inline struct vlan_ethhdr *vlan_eth_hdr(const struct sk_buff *skb)
1573 {
1574         return (struct vlan_ethhdr *)skb->mac.raw;
1575 }
1576
1577 /* Wake-On-Lan options. */
1578 #define WAKE_PHY                (1 << 0)
1579 #define WAKE_UCAST              (1 << 1)
1580 #define WAKE_MCAST              (1 << 2)
1581 #define WAKE_BCAST              (1 << 3)
1582 #define WAKE_ARP                (1 << 4)
1583 #define WAKE_MAGIC              (1 << 5)
1584 #define WAKE_MAGICSECURE        (1 << 6) /* only meaningful if WAKE_MAGIC */
1585
1586 #define skb_header_pointer _kc_skb_header_pointer
1587 static inline void *_kc_skb_header_pointer(const struct sk_buff *skb,
1588                                             int offset, int len, void *buffer)
1589 {
1590         int hlen = skb_headlen(skb);
1591
1592         if (hlen - offset >= len)
1593                 return skb->data + offset;
1594
1595 #ifdef MAX_SKB_FRAGS
1596         if (skb_copy_bits(skb, offset, buffer, len) < 0)
1597                 return NULL;
1598
1599         return buffer;
1600 #else
1601         return NULL;
1602 #endif
1603
1604 #ifndef NETDEV_TX_OK
1605 #define NETDEV_TX_OK 0
1606 #endif
1607 #ifndef NETDEV_TX_BUSY
1608 #define NETDEV_TX_BUSY 1
1609 #endif
1610 #ifndef NETDEV_TX_LOCKED
1611 #define NETDEV_TX_LOCKED -1
1612 #endif
1613 }
1614
1615 #ifndef __bitwise
1616 #define __bitwise
1617 #endif
1618 #endif /* < 2.6.9 */
1619
1620 /*****************************************************************************/
1621 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) )
1622 #ifdef module_param_array_named
1623 #undef module_param_array_named
1624 #define module_param_array_named(name, array, type, nump, perm)          \
1625         static struct kparam_array __param_arr_##name                    \
1626         = { ARRAY_SIZE(array), nump, param_set_##type, param_get_##type, \
1627             sizeof(array[0]), array };                                   \
1628         module_param_call(name, param_array_set, param_array_get,        \
1629                           &__param_arr_##name, perm)
1630 #endif /* module_param_array_named */
1631 /*
1632  * num_online is broken for all < 2.6.10 kernels.  This is needed to support
1633  * Node module parameter of ixgbe.
1634  */
1635 #undef num_online_nodes
1636 #define num_online_nodes(n) 1
1637 extern DECLARE_BITMAP(_kcompat_node_online_map, MAX_NUMNODES);
1638 #undef node_online_map
1639 #define node_online_map _kcompat_node_online_map
1640 #define pci_get_class pci_find_class
1641 #endif /* < 2.6.10 */
1642
1643 /*****************************************************************************/
1644 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,11) )
1645 #define PCI_D0      0
1646 #define PCI_D1      1
1647 #define PCI_D2      2
1648 #define PCI_D3hot   3
1649 #define PCI_D3cold  4
1650 typedef int pci_power_t;
1651 #define pci_choose_state(pdev,state) state
1652 #define PMSG_SUSPEND 3
1653 #define PCI_EXP_LNKCTL  16
1654
1655 #undef NETIF_F_LLTX
1656
1657 #ifndef ARCH_HAS_PREFETCH
1658 #define prefetch(X)
1659 #endif
1660
1661 #ifndef NET_IP_ALIGN
1662 #define NET_IP_ALIGN 2
1663 #endif
1664
1665 #define KC_USEC_PER_SEC 1000000L
1666 #define usecs_to_jiffies _kc_usecs_to_jiffies
1667 static inline unsigned int _kc_jiffies_to_usecs(const unsigned long j)
1668 {
1669 #if HZ <= KC_USEC_PER_SEC && !(KC_USEC_PER_SEC % HZ)
1670         return (KC_USEC_PER_SEC / HZ) * j;
1671 #elif HZ > KC_USEC_PER_SEC && !(HZ % KC_USEC_PER_SEC)
1672         return (j + (HZ / KC_USEC_PER_SEC) - 1)/(HZ / KC_USEC_PER_SEC);
1673 #else
1674         return (j * KC_USEC_PER_SEC) / HZ;
1675 #endif
1676 }
1677 static inline unsigned long _kc_usecs_to_jiffies(const unsigned int m)
1678 {
1679         if (m > _kc_jiffies_to_usecs(MAX_JIFFY_OFFSET))
1680                 return MAX_JIFFY_OFFSET;
1681 #if HZ <= KC_USEC_PER_SEC && !(KC_USEC_PER_SEC % HZ)
1682         return (m + (KC_USEC_PER_SEC / HZ) - 1) / (KC_USEC_PER_SEC / HZ);
1683 #elif HZ > KC_USEC_PER_SEC && !(HZ % KC_USEC_PER_SEC)
1684         return m * (HZ / KC_USEC_PER_SEC);
1685 #else
1686         return (m * HZ + KC_USEC_PER_SEC - 1) / KC_USEC_PER_SEC;
1687 #endif
1688 }
1689
1690 #define PCI_EXP_LNKCAP          12      /* Link Capabilities */
1691 #define PCI_EXP_LNKSTA          18      /* Link Status */
1692 #define PCI_EXP_SLTCAP          20      /* Slot Capabilities */
1693 #define PCI_EXP_SLTCTL          24      /* Slot Control */
1694 #define PCI_EXP_SLTSTA          26      /* Slot Status */
1695 #define PCI_EXP_RTCTL           28      /* Root Control */
1696 #define PCI_EXP_RTCAP           30      /* Root Capabilities */
1697 #define PCI_EXP_RTSTA           32      /* Root Status */
1698 #endif /* < 2.6.11 */
1699
1700 /*****************************************************************************/
1701 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,12) )
1702 #include <linux/reboot.h>
1703 #define USE_REBOOT_NOTIFIER
1704
1705 /* Generic MII registers. */
1706 #define MII_CTRL1000        0x09        /* 1000BASE-T control          */
1707 #define MII_STAT1000        0x0a        /* 1000BASE-T status           */
1708 /* Advertisement control register. */
1709 #define ADVERTISE_PAUSE_CAP     0x0400  /* Try for pause               */
1710 #define ADVERTISE_PAUSE_ASYM    0x0800  /* Try for asymmetric pause     */
1711 /* Link partner ability register. */
1712 #define LPA_PAUSE_CAP           0x0400  /* Can pause                   */
1713 #define LPA_PAUSE_ASYM          0x0800  /* Can pause asymetrically     */
1714 /* 1000BASE-T Control register */
1715 #define ADVERTISE_1000FULL      0x0200  /* Advertise 1000BASE-T full duplex */
1716 #define ADVERTISE_1000HALF      0x0100  /* Advertise 1000BASE-T half duplex */
1717 /* 1000BASE-T Status register */
1718 #define LPA_1000LOCALRXOK       0x2000  /* Link partner local receiver status */
1719 #define LPA_1000REMRXOK         0x1000  /* Link partner remote receiver status */
1720
1721 #ifndef is_zero_ether_addr
1722 #define is_zero_ether_addr _kc_is_zero_ether_addr
1723 static inline int _kc_is_zero_ether_addr(const u8 *addr)
1724 {
1725         return !(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5]);
1726 }
1727 #endif /* is_zero_ether_addr */
1728 #ifndef is_multicast_ether_addr
1729 #define is_multicast_ether_addr _kc_is_multicast_ether_addr
1730 static inline int _kc_is_multicast_ether_addr(const u8 *addr)
1731 {
1732         return addr[0] & 0x01;
1733 }
1734 #endif /* is_multicast_ether_addr */
1735 #endif /* < 2.6.12 */
1736
1737 /*****************************************************************************/
1738 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,13) )
1739 #ifndef kstrdup
1740 #define kstrdup _kc_kstrdup
1741 extern char *_kc_kstrdup(const char *s, unsigned int gfp);
1742 #endif
1743 #endif /* < 2.6.13 */
1744
1745 /*****************************************************************************/
1746 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14) )
1747 #define pm_message_t u32
1748 #ifndef kzalloc
1749 #define kzalloc _kc_kzalloc
1750 extern void *_kc_kzalloc(size_t size, int flags);
1751 #endif
1752
1753 /* Generic MII registers. */
1754 #define MII_ESTATUS         0x0f        /* Extended Status */
1755 /* Basic mode status register. */
1756 #define BMSR_ESTATEN            0x0100  /* Extended Status in R15 */
1757 /* Extended status register. */
1758 #define ESTATUS_1000_TFULL      0x2000  /* Can do 1000BT Full */
1759 #define ESTATUS_1000_THALF      0x1000  /* Can do 1000BT Half */
1760
1761 #define SUPPORTED_Pause         (1 << 13)
1762 #define SUPPORTED_Asym_Pause    (1 << 14)
1763 #define ADVERTISED_Pause        (1 << 13)
1764 #define ADVERTISED_Asym_Pause   (1 << 14)
1765
1766 #if (!(RHEL_RELEASE_CODE && \
1767        (RHEL_RELEASE_CODE > RHEL_RELEASE_VERSION(4,3)) && \
1768        (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(5,0))))
1769 #if ((LINUX_VERSION_CODE == KERNEL_VERSION(2,6,9)) && !defined(gfp_t))
1770 #define gfp_t unsigned
1771 #else
1772 typedef unsigned gfp_t;
1773 #endif
1774 #endif /* !RHEL4.3->RHEL5.0 */
1775
1776 #if ( LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,9) )
1777 #ifdef CONFIG_X86_64
1778 #define dma_sync_single_range_for_cpu(dev, addr, off, sz, dir)       \
1779         dma_sync_single_for_cpu((dev), (addr), (off) + (sz), (dir))
1780 #define dma_sync_single_range_for_device(dev, addr, off, sz, dir)    \
1781         dma_sync_single_for_device((dev), (addr), (off) + (sz), (dir))
1782 #endif
1783 #endif
1784 #endif /* < 2.6.14 */
1785
1786 /*****************************************************************************/
1787 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,15) )
1788 #ifndef vmalloc_node
1789 #define vmalloc_node(a,b) vmalloc(a)
1790 #endif /* vmalloc_node*/
1791
1792 #define setup_timer(_timer, _function, _data) \
1793 do { \
1794         (_timer)->function = _function; \
1795         (_timer)->data = _data; \
1796         init_timer(_timer); \
1797 } while (0)
1798 #ifndef device_can_wakeup
1799 #define device_can_wakeup(dev)  (1)
1800 #endif
1801 #ifndef device_set_wakeup_enable
1802 #define device_set_wakeup_enable(dev, val)      do{}while(0)
1803 #endif
1804 #ifndef device_init_wakeup
1805 #define device_init_wakeup(dev,val) do {} while (0)
1806 #endif
1807 static inline unsigned _kc_compare_ether_addr(const u8 *addr1, const u8 *addr2)
1808 {
1809         const u16 *a = (const u16 *) addr1;
1810         const u16 *b = (const u16 *) addr2;
1811
1812         return ((a[0] ^ b[0]) | (a[1] ^ b[1]) | (a[2] ^ b[2])) != 0;
1813 }
1814 #undef compare_ether_addr
1815 #define compare_ether_addr(addr1, addr2) _kc_compare_ether_addr(addr1, addr2)
1816 #endif /* < 2.6.15 */
1817
1818 /*****************************************************************************/
1819 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,16) )
1820 #undef DEFINE_MUTEX
1821 #define DEFINE_MUTEX(x) DECLARE_MUTEX(x)
1822 #define mutex_lock(x)   down_interruptible(x)
1823 #define mutex_unlock(x) up(x)
1824
1825 #ifndef ____cacheline_internodealigned_in_smp
1826 #ifdef CONFIG_SMP
1827 #define ____cacheline_internodealigned_in_smp ____cacheline_aligned_in_smp
1828 #else
1829 #define ____cacheline_internodealigned_in_smp
1830 #endif /* CONFIG_SMP */
1831 #endif /* ____cacheline_internodealigned_in_smp */
1832 #undef HAVE_PCI_ERS
1833 #else /* 2.6.16 and above */
1834 #undef HAVE_PCI_ERS
1835 #define HAVE_PCI_ERS
1836 #if ( SLE_VERSION_CODE && SLE_VERSION_CODE == SLE_VERSION(10,4,0) )
1837 #ifdef device_can_wakeup
1838 #undef device_can_wakeup
1839 #endif /* device_can_wakeup */
1840 #define device_can_wakeup(dev) 1
1841 #endif /* SLE_VERSION(10,4,0) */
1842 #endif /* < 2.6.16 */
1843
1844 /*****************************************************************************/
1845 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,17) )
1846 #ifndef dev_notice
1847 #define dev_notice(dev, fmt, args...)            \
1848         dev_printk(KERN_NOTICE, dev, fmt, ## args)
1849 #endif
1850
1851 #ifndef first_online_node
1852 #define first_online_node 0
1853 #endif
1854 #ifndef NET_SKB_PAD
1855 #define NET_SKB_PAD 16
1856 #endif
1857 #endif /* < 2.6.17 */
1858
1859 /*****************************************************************************/
1860 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18) )
1861
1862 #ifndef IRQ_HANDLED
1863 #define irqreturn_t void
1864 #define IRQ_HANDLED
1865 #define IRQ_NONE
1866 #endif
1867
1868 #ifndef IRQF_PROBE_SHARED
1869 #ifdef SA_PROBEIRQ
1870 #define IRQF_PROBE_SHARED SA_PROBEIRQ
1871 #else
1872 #define IRQF_PROBE_SHARED 0
1873 #endif
1874 #endif
1875
1876 #ifndef IRQF_SHARED
1877 #define IRQF_SHARED SA_SHIRQ
1878 #endif
1879
1880 #ifndef ARRAY_SIZE
1881 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
1882 #endif
1883
1884 #ifndef FIELD_SIZEOF
1885 #define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f))
1886 #endif
1887
1888 #ifndef skb_is_gso
1889 #ifdef NETIF_F_TSO
1890 #define skb_is_gso _kc_skb_is_gso
1891 static inline int _kc_skb_is_gso(const struct sk_buff *skb)
1892 {
1893         return skb_shinfo(skb)->gso_size;
1894 }
1895 #else
1896 #define skb_is_gso(a) 0
1897 #endif
1898 #endif
1899
1900 #ifndef resource_size_t
1901 #define resource_size_t unsigned long
1902 #endif
1903
1904 #ifdef skb_pad
1905 #undef skb_pad
1906 #endif
1907 #define skb_pad(x,y) _kc_skb_pad(x, y)
1908 int _kc_skb_pad(struct sk_buff *skb, int pad);
1909 #ifdef skb_padto
1910 #undef skb_padto
1911 #endif
1912 #define skb_padto(x,y) _kc_skb_padto(x, y)
1913 static inline int _kc_skb_padto(struct sk_buff *skb, unsigned int len)
1914 {
1915         unsigned int size = skb->len;
1916         if(likely(size >= len))
1917                 return 0;
1918         return _kc_skb_pad(skb, len - size);
1919 }
1920
1921 #ifndef DECLARE_PCI_UNMAP_ADDR
1922 #define DECLARE_PCI_UNMAP_ADDR(ADDR_NAME) \
1923         dma_addr_t ADDR_NAME
1924 #define DECLARE_PCI_UNMAP_LEN(LEN_NAME) \
1925         u32 LEN_NAME
1926 #define pci_unmap_addr(PTR, ADDR_NAME) \
1927         ((PTR)->ADDR_NAME)
1928 #define pci_unmap_addr_set(PTR, ADDR_NAME, VAL) \
1929         (((PTR)->ADDR_NAME) = (VAL))
1930 #define pci_unmap_len(PTR, LEN_NAME) \
1931         ((PTR)->LEN_NAME)
1932 #define pci_unmap_len_set(PTR, LEN_NAME, VAL) \
1933         (((PTR)->LEN_NAME) = (VAL))
1934 #endif /* DECLARE_PCI_UNMAP_ADDR */
1935 #endif /* < 2.6.18 */
1936
1937 /*****************************************************************************/
1938 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19) )
1939
1940 #if (!(RHEL_RELEASE_CODE && RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(5,0)))
1941 #define i_private u.generic_ip
1942 #endif /* >= RHEL 5.0 */
1943
1944 #ifndef DIV_ROUND_UP
1945 #define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
1946 #endif
1947 #ifndef __ALIGN_MASK
1948 #define __ALIGN_MASK(x, mask) (((x) + (mask)) & ~(mask))
1949 #endif
1950 #if ( LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0) )
1951 #if (!((RHEL_RELEASE_CODE && \
1952         ((RHEL_RELEASE_CODE > RHEL_RELEASE_VERSION(4,4) && \
1953           RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(5,0)) || \
1954          (RHEL_RELEASE_CODE > RHEL_RELEASE_VERSION(5,0))))))
1955 typedef irqreturn_t (*irq_handler_t)(int, void*, struct pt_regs *);
1956 #endif
1957 #if (RHEL_RELEASE_CODE && RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(6,0))
1958 #undef CONFIG_INET_LRO
1959 #undef CONFIG_INET_LRO_MODULE
1960 #ifdef IXGBE_FCOE
1961 #undef CONFIG_FCOE
1962 #undef CONFIG_FCOE_MODULE
1963 #endif /* IXGBE_FCOE */
1964 #endif
1965 typedef irqreturn_t (*new_handler_t)(int, void*);
1966 static inline irqreturn_t _kc_request_irq(unsigned int irq, new_handler_t handler, unsigned long flags, const char *devname, void *dev_id)
1967 #else /* 2.4.x */
1968 typedef void (*irq_handler_t)(int, void*, struct pt_regs *);
1969 typedef void (*new_handler_t)(int, void*);
1970 static inline int _kc_request_irq(unsigned int irq, new_handler_t handler, unsigned long flags, const char *devname, void *dev_id)
1971 #endif /* >= 2.5.x */
1972 {
1973         irq_handler_t new_handler = (irq_handler_t) handler;
1974         return request_irq(irq, new_handler, flags, devname, dev_id);
1975 }
1976
1977 #undef request_irq
1978 #define request_irq(irq, handler, flags, devname, dev_id) _kc_request_irq((irq), (handler), (flags), (devname), (dev_id))
1979
1980 #define irq_handler_t new_handler_t
1981 /* pci_restore_state and pci_save_state handles MSI/PCIE from 2.6.19 */
1982 #if (!(RHEL_RELEASE_CODE && RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(5,4)))
1983 #define PCIE_CONFIG_SPACE_LEN 256
1984 #define PCI_CONFIG_SPACE_LEN 64
1985 #define PCIE_LINK_STATUS 0x12
1986 #define pci_config_space_ich8lan() do {} while(0)
1987 #undef pci_save_state
1988 extern int _kc_pci_save_state(struct pci_dev *);
1989 #define pci_save_state(pdev) _kc_pci_save_state(pdev)
1990 #undef pci_restore_state
1991 extern void _kc_pci_restore_state(struct pci_dev *);
1992 #define pci_restore_state(pdev) _kc_pci_restore_state(pdev)
1993 #endif /* !(RHEL_RELEASE_CODE >= RHEL 5.4) */
1994
1995 #ifdef HAVE_PCI_ERS
1996 #undef free_netdev
1997 extern void _kc_free_netdev(struct net_device *);
1998 #define free_netdev(netdev) _kc_free_netdev(netdev)
1999 #endif
2000 static inline int pci_enable_pcie_error_reporting(struct pci_dev *dev)
2001 {
2002         return 0;
2003 }
2004 #define pci_disable_pcie_error_reporting(dev) do {} while (0)
2005 #define pci_cleanup_aer_uncorrect_error_status(dev) do {} while (0)
2006
2007 extern void *_kc_kmemdup(const void *src, size_t len, unsigned gfp);
2008 #define kmemdup(src, len, gfp) _kc_kmemdup(src, len, gfp)
2009 #ifndef bool
2010 #define bool _Bool
2011 #define true 1
2012 #define false 0
2013 #endif
2014 #else /* 2.6.19 */
2015 #include <linux/aer.h>
2016 #include <linux/string.h>
2017 #endif /* < 2.6.19 */
2018
2019 /*****************************************************************************/
2020 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20) )
2021 #if ( LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,28) )
2022 #undef INIT_WORK
2023 #define INIT_WORK(_work, _func) \
2024 do { \
2025         INIT_LIST_HEAD(&(_work)->entry); \
2026         (_work)->pending = 0; \
2027         (_work)->func = (void (*)(void *))_func; \
2028         (_work)->data = _work; \
2029         init_timer(&(_work)->timer); \
2030 } while (0)
2031 #endif
2032
2033 #ifndef PCI_VDEVICE
2034 #define PCI_VDEVICE(ven, dev)        \
2035         PCI_VENDOR_ID_##ven, (dev),  \
2036         PCI_ANY_ID, PCI_ANY_ID, 0, 0
2037 #endif
2038
2039 #ifndef PCI_VENDOR_ID_INTEL
2040 #define PCI_VENDOR_ID_INTEL 0x8086
2041 #endif
2042
2043 #ifndef round_jiffies
2044 #define round_jiffies(x) x
2045 #endif
2046
2047 #define csum_offset csum
2048
2049 #define HAVE_EARLY_VMALLOC_NODE
2050 #define dev_to_node(dev) -1
2051 #undef set_dev_node
2052 /* remove compiler warning with b=b, for unused variable */
2053 #define set_dev_node(a, b) do { (b) = (b); } while(0)
2054
2055 #if (!(RHEL_RELEASE_CODE && \
2056        (((RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(4,7)) && \
2057          (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(5,0))) || \
2058         (RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(5,6)))) && \
2059      !(SLE_VERSION_CODE && SLE_VERSION_CODE >= SLE_VERSION(10,2,0)))
2060 typedef __u16 __bitwise __sum16;
2061 typedef __u32 __bitwise __wsum;
2062 #endif
2063
2064 #if (!(RHEL_RELEASE_CODE && \
2065        (((RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(4,7)) && \
2066          (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(5,0))) || \
2067         (RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(5,4)))) && \
2068      !(SLE_VERSION_CODE && SLE_VERSION_CODE >= SLE_VERSION(10,2,0)))
2069 static inline __wsum csum_unfold(__sum16 n)
2070 {
2071         return (__force __wsum)n;
2072 }
2073 #endif
2074
2075 #else /* < 2.6.20 */
2076 #define HAVE_DEVICE_NUMA_NODE
2077 #endif /* < 2.6.20 */
2078
2079 /*****************************************************************************/
2080 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21) )
2081 #define to_net_dev(class) container_of(class, struct net_device, class_dev)
2082 #define NETDEV_CLASS_DEV
2083 #if (!(RHEL_RELEASE_CODE && RHEL_RELEASE_CODE > RHEL_RELEASE_VERSION(5,5)))
2084 #define vlan_group_get_device(vg, id) (vg->vlan_devices[id])
2085 #define vlan_group_set_device(vg, id, dev)              \
2086         do {                                            \
2087                 if (vg) vg->vlan_devices[id] = dev;     \
2088         } while (0)
2089 #endif /* !(RHEL_RELEASE_CODE > RHEL_RELEASE_VERSION(5,5)) */
2090 #define pci_channel_offline(pdev) (pdev->error_state && \
2091         pdev->error_state != pci_channel_io_normal)
2092 #define pci_request_selected_regions(pdev, bars, name) \
2093         pci_request_regions(pdev, name)
2094 #define pci_release_selected_regions(pdev, bars) pci_release_regions(pdev);
2095
2096 #ifndef __aligned
2097 #define __aligned(x)                    __attribute__((aligned(x)))
2098 #endif
2099
2100 extern struct pci_dev *_kc_netdev_to_pdev(struct net_device *netdev);
2101 #define netdev_to_dev(netdev)   \
2102         pci_dev_to_dev(_kc_netdev_to_pdev(netdev))
2103 #else
2104 static inline struct device *netdev_to_dev(struct net_device *netdev)
2105 {
2106         return &netdev->dev;
2107 }
2108
2109 #endif /* < 2.6.21 */
2110
2111 /*****************************************************************************/
2112 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22) )
2113 #define tcp_hdr(skb) (skb->h.th)
2114 #define tcp_hdrlen(skb) (skb->h.th->doff << 2)
2115 #define skb_transport_offset(skb) (skb->h.raw - skb->data)
2116 #define skb_transport_header(skb) (skb->h.raw)
2117 #define ipv6_hdr(skb) (skb->nh.ipv6h)
2118 #define ip_hdr(skb) (skb->nh.iph)
2119 #define skb_network_offset(skb) (skb->nh.raw - skb->data)
2120 #define skb_network_header(skb) (skb->nh.raw)
2121 #define skb_tail_pointer(skb) skb->tail
2122 #define skb_reset_tail_pointer(skb) \
2123         do { \
2124                 skb->tail = skb->data; \
2125         } while (0)
2126 #define skb_set_tail_pointer(skb, offset) \
2127         do { \
2128                 skb->tail = skb->data + offset; \
2129         } while (0)
2130 #define skb_copy_to_linear_data(skb, from, len) \
2131                                 memcpy(skb->data, from, len)
2132 #define skb_copy_to_linear_data_offset(skb, offset, from, len) \
2133                                 memcpy(skb->data + offset, from, len)
2134 #define skb_network_header_len(skb) (skb->h.raw - skb->nh.raw)
2135 #define pci_register_driver pci_module_init
2136 #define skb_mac_header(skb) skb->mac.raw
2137
2138 #ifdef NETIF_F_MULTI_QUEUE
2139 #ifndef alloc_etherdev_mq
2140 #define alloc_etherdev_mq(_a, _b) alloc_etherdev(_a)
2141 #endif
2142 #endif /* NETIF_F_MULTI_QUEUE */
2143
2144 #ifndef ETH_FCS_LEN
2145 #define ETH_FCS_LEN 4
2146 #endif
2147 #define cancel_work_sync(x) flush_scheduled_work()
2148 #ifndef udp_hdr
2149 #define udp_hdr _udp_hdr
2150 static inline struct udphdr *_udp_hdr(const struct sk_buff *skb)
2151 {
2152         return (struct udphdr *)skb_transport_header(skb);
2153 }
2154 #endif
2155
2156 #ifdef cpu_to_be16
2157 #undef cpu_to_be16
2158 #endif
2159 #define cpu_to_be16(x) __constant_htons(x)
2160
2161 #if (!(RHEL_RELEASE_CODE && RHEL_RELEASE_CODE > RHEL_RELEASE_VERSION(5,1)))
2162 enum {
2163         DUMP_PREFIX_NONE,
2164         DUMP_PREFIX_ADDRESS,
2165         DUMP_PREFIX_OFFSET
2166 };
2167 #endif /* !(RHEL_RELEASE_CODE > RHEL_RELEASE_VERSION(5,1)) */
2168 #ifndef hex_asc
2169 #define hex_asc(x)      "0123456789abcdef"[x]
2170 #endif
2171 #include <linux/ctype.h>
2172 extern void _kc_print_hex_dump(const char *level, const char *prefix_str,
2173                                int prefix_type, int rowsize, int groupsize,
2174                                const void *buf, size_t len, bool ascii);
2175 #define print_hex_dump(lvl, s, t, r, g, b, l, a) \
2176                 _kc_print_hex_dump(lvl, s, t, r, g, b, l, a)
2177 #ifndef ADVERTISED_2500baseX_Full
2178 #define ADVERTISED_2500baseX_Full (1 << 15)
2179 #endif
2180 #ifndef SUPPORTED_2500baseX_Full
2181 #define SUPPORTED_2500baseX_Full (1 << 15)
2182 #endif
2183
2184 #ifdef HAVE_I2C_SUPPORT
2185 #include <linux/i2c.h>
2186 #if (!(RHEL_RELEASE_CODE && RHEL_RELEASE_CODE > RHEL_RELEASE_VERSION(5,5)))
2187 struct i2c_board_info {
2188         char    driver_name[KOBJ_NAME_LEN];
2189         char    type[I2C_NAME_SIZE];
2190         unsigned short  flags;
2191         unsigned short  addr;
2192         void            *platform_data;
2193 };
2194 #define I2C_BOARD_INFO(driver, dev_addr) .driver_name = (driver),\
2195                         .addr = (dev_addr)
2196 #endif /* !(RHEL_RELEASE_CODE > RHEL_RELEASE_VERSION(5,5)) */
2197 #define i2c_new_device(adap, info) _kc_i2c_new_device(adap, info)
2198 extern struct i2c_client *
2199 _kc_i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info);
2200 #endif /* HAVE_I2C_SUPPORT */
2201
2202 #else /* 2.6.22 */
2203 #define ETH_TYPE_TRANS_SETS_DEV
2204 #define HAVE_NETDEV_STATS_IN_NETDEV
2205 #endif /* < 2.6.22 */
2206
2207 /*****************************************************************************/
2208 #if ( LINUX_VERSION_CODE > KERNEL_VERSION(2,6,22) )
2209 #undef SET_MODULE_OWNER
2210 #define SET_MODULE_OWNER(dev) do { } while (0)
2211 #endif /* > 2.6.22 */
2212
2213 /*****************************************************************************/
2214 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23) )
2215 #define netif_subqueue_stopped(_a, _b) 0
2216 #ifndef PTR_ALIGN
2217 #define PTR_ALIGN(p, a)         ((typeof(p))ALIGN((unsigned long)(p), (a)))
2218 #endif
2219
2220 #ifndef CONFIG_PM_SLEEP
2221 #define CONFIG_PM_SLEEP CONFIG_PM
2222 #endif
2223
2224 #if ( LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13) )
2225 #define HAVE_ETHTOOL_GET_PERM_ADDR
2226 #endif /* 2.6.14 through 2.6.22 */
2227 #endif /* < 2.6.23 */
2228
2229 /*****************************************************************************/
2230 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24) )
2231 #ifndef ETH_FLAG_LRO
2232 #define ETH_FLAG_LRO NETIF_F_LRO
2233 #endif
2234
2235 /* if GRO is supported then the napi struct must already exist */
2236 #ifndef NETIF_F_GRO
2237 /* NAPI API changes in 2.6.24 break everything */
2238 struct napi_struct {
2239         /* used to look up the real NAPI polling routine */
2240         int (*poll)(struct napi_struct *, int);
2241         struct net_device *dev;
2242         int weight;
2243 };
2244 #endif
2245
2246 #ifdef NAPI
2247 extern int __kc_adapter_clean(struct net_device *, int *);
2248 extern struct net_device *napi_to_poll_dev(const struct napi_struct *napi);
2249 #define netif_napi_add(_netdev, _napi, _poll, _weight) \
2250         do { \
2251                 struct napi_struct *__napi = (_napi); \
2252                 struct net_device *poll_dev = napi_to_poll_dev(__napi); \
2253                 poll_dev->poll = &(__kc_adapter_clean); \
2254                 poll_dev->priv = (_napi); \
2255                 poll_dev->weight = (_weight); \
2256                 set_bit(__LINK_STATE_RX_SCHED, &poll_dev->state); \
2257                 set_bit(__LINK_STATE_START, &poll_dev->state);\
2258                 dev_hold(poll_dev); \
2259                 __napi->poll = &(_poll); \
2260                 __napi->weight = (_weight); \
2261                 __napi->dev = (_netdev); \
2262         } while (0)
2263 #define netif_napi_del(_napi) \
2264         do { \
2265                 struct net_device *poll_dev = napi_to_poll_dev(_napi); \
2266                 WARN_ON(!test_bit(__LINK_STATE_RX_SCHED, &poll_dev->state)); \
2267                 dev_put(poll_dev); \
2268                 memset(poll_dev, 0, sizeof(struct net_device));\
2269         } while (0)
2270 #define napi_schedule_prep(_napi) \
2271         (netif_running((_napi)->dev) && netif_rx_schedule_prep(napi_to_poll_dev(_napi)))
2272 #define napi_schedule(_napi) \
2273         do { \
2274                 if (napi_schedule_prep(_napi)) \
2275                         __netif_rx_schedule(napi_to_poll_dev(_napi)); \
2276         } while (0)
2277 #define napi_enable(_napi) netif_poll_enable(napi_to_poll_dev(_napi))
2278 #define napi_disable(_napi) netif_poll_disable(napi_to_poll_dev(_napi))
2279 #ifdef CONFIG_SMP
2280 static inline void napi_synchronize(const struct napi_struct *n)
2281 {
2282         struct net_device *dev = napi_to_poll_dev(n);
2283
2284         while (test_bit(__LINK_STATE_RX_SCHED, &dev->state)) {
2285                 /* No hurry. */
2286                 msleep(1);
2287         }
2288 }
2289 #else
2290 #define napi_synchronize(n)     barrier()
2291 #endif /* CONFIG_SMP */
2292 #define __napi_schedule(_napi) __netif_rx_schedule(napi_to_poll_dev(_napi))
2293 #ifndef NETIF_F_GRO
2294 #define napi_complete(_napi) netif_rx_complete(napi_to_poll_dev(_napi))
2295 #else
2296 #define napi_complete(_napi) \
2297         do { \
2298                 napi_gro_flush(_napi); \
2299                 netif_rx_complete(napi_to_poll_dev(_napi)); \
2300         } while (0)
2301 #endif /* NETIF_F_GRO */
2302 #else /* NAPI */
2303 #define netif_napi_add(_netdev, _napi, _poll, _weight) \
2304         do { \
2305                 struct napi_struct *__napi = _napi; \
2306                 _netdev->poll = &(_poll); \
2307                 _netdev->weight = (_weight); \
2308                 __napi->poll = &(_poll); \
2309                 __napi->weight = (_weight); \
2310                 __napi->dev = (_netdev); \
2311         } while (0)
2312 #define netif_napi_del(_a) do {} while (0)
2313 #endif /* NAPI */
2314
2315 #undef dev_get_by_name
2316 #define dev_get_by_name(_a, _b) dev_get_by_name(_b)
2317 #define __netif_subqueue_stopped(_a, _b) netif_subqueue_stopped(_a, _b)
2318 #ifndef DMA_BIT_MASK
2319 #define DMA_BIT_MASK(n) (((n) == 64) ? DMA_64BIT_MASK : ((1ULL<<(n))-1))
2320 #endif
2321
2322 #ifdef NETIF_F_TSO6
2323 #define skb_is_gso_v6 _kc_skb_is_gso_v6
2324 static inline int _kc_skb_is_gso_v6(const struct sk_buff *skb)
2325 {
2326         return skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6;
2327 }
2328 #endif /* NETIF_F_TSO6 */
2329
2330 #ifndef KERN_CONT
2331 #define KERN_CONT       ""
2332 #endif
2333 #ifndef pr_err
2334 #define pr_err(fmt, arg...) \
2335         printk(KERN_ERR fmt, ##arg)
2336 #endif
2337 #else /* < 2.6.24 */
2338 #define HAVE_ETHTOOL_GET_SSET_COUNT
2339 #define HAVE_NETDEV_NAPI_LIST
2340 #endif /* < 2.6.24 */
2341
2342 /*****************************************************************************/
2343 #if ( LINUX_VERSION_CODE > KERNEL_VERSION(2,6,24) )
2344 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(3,2,0) )
2345 #include <linux/pm_qos_params.h>
2346 #else /* >= 3.2.0 */
2347 #include <linux/pm_qos.h>
2348 #endif /* else >= 3.2.0 */
2349 #endif /* > 2.6.24 */
2350
2351 /*****************************************************************************/
2352 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25) )
2353 #define PM_QOS_CPU_DMA_LATENCY  1
2354
2355 #if ( LINUX_VERSION_CODE > KERNEL_VERSION(2,6,18) )
2356 #include <linux/latency.h>
2357 #define PM_QOS_DEFAULT_VALUE    INFINITE_LATENCY
2358 #define pm_qos_add_requirement(pm_qos_class, name, value) \
2359                 set_acceptable_latency(name, value)
2360 #define pm_qos_remove_requirement(pm_qos_class, name) \
2361                 remove_acceptable_latency(name)
2362 #define pm_qos_update_requirement(pm_qos_class, name, value) \
2363                 modify_acceptable_latency(name, value)
2364 #else
2365 #define PM_QOS_DEFAULT_VALUE    -1
2366 #define pm_qos_add_requirement(pm_qos_class, name, value)
2367 #define pm_qos_remove_requirement(pm_qos_class, name)
2368 #define pm_qos_update_requirement(pm_qos_class, name, value) { \
2369         if (value != PM_QOS_DEFAULT_VALUE) { \
2370                 printk(KERN_WARNING "%s: unable to set PM QoS requirement\n", \
2371                         pci_name(adapter->pdev)); \
2372         } \
2373 }
2374
2375 #endif /* > 2.6.18 */
2376
2377 #define pci_enable_device_mem(pdev) pci_enable_device(pdev)
2378
2379 #ifndef DEFINE_PCI_DEVICE_TABLE
2380 #define DEFINE_PCI_DEVICE_TABLE(_table) struct pci_device_id _table[]
2381 #endif /* DEFINE_PCI_DEVICE_TABLE */
2382
2383
2384 #if ( LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) )
2385 #ifndef IGB_PROCFS
2386 #define IGB_PROCFS
2387 #endif /* IGB_PROCFS */
2388 #endif /* >= 2.6.0 */
2389
2390 #else /* < 2.6.25 */
2391
2392
2393 #if IS_ENABLED(CONFIG_HWMON)
2394 #ifndef IGB_HWMON
2395 #define IGB_HWMON
2396 #endif /* IGB_HWMON */
2397 #endif /* CONFIG_HWMON */
2398
2399 #endif /* < 2.6.25 */
2400
2401 /*****************************************************************************/
2402 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26) )
2403 #ifndef clamp_t
2404 #define clamp_t(type, val, min, max) ({         \
2405         type __val = (val);                     \
2406         type __min = (min);                     \
2407         type __max = (max);                     \
2408         __val = __val < __min ? __min : __val;  \
2409         __val > __max ? __max : __val; })
2410 #endif /* clamp_t */
2411 #undef kzalloc_node
2412 #define kzalloc_node(_size, _flags, _node) kzalloc(_size, _flags)
2413
2414 extern void _kc_pci_disable_link_state(struct pci_dev *dev, int state);
2415 #define pci_disable_link_state(p, s) _kc_pci_disable_link_state(p, s)
2416 #else /* < 2.6.26 */
2417 #include <linux/pci-aspm.h>
2418 #define HAVE_NETDEV_VLAN_FEATURES
2419 #ifndef PCI_EXP_LNKCAP_ASPMS
2420 #define PCI_EXP_LNKCAP_ASPMS 0x00000c00 /* ASPM Support */
2421 #endif /* PCI_EXP_LNKCAP_ASPMS */
2422 #endif /* < 2.6.26 */
2423 /*****************************************************************************/
2424 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27) )
2425 static inline void _kc_ethtool_cmd_speed_set(struct ethtool_cmd *ep,
2426                                              __u32 speed)
2427 {
2428         ep->speed = (__u16)speed;
2429         /* ep->speed_hi = (__u16)(speed >> 16); */
2430 }
2431 #define ethtool_cmd_speed_set _kc_ethtool_cmd_speed_set
2432
2433 static inline __u32 _kc_ethtool_cmd_speed(struct ethtool_cmd *ep)
2434 {
2435         /* no speed_hi before 2.6.27, and probably no need for it yet */
2436         return (__u32)ep->speed;
2437 }
2438 #define ethtool_cmd_speed _kc_ethtool_cmd_speed
2439
2440 #if ( LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15) )
2441 #if ((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)) && defined(CONFIG_PM))
2442 #define ANCIENT_PM 1
2443 #elif ((LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)) && \
2444        (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26)) && \
2445        defined(CONFIG_PM_SLEEP))
2446 #define NEWER_PM 1
2447 #endif
2448 #if defined(ANCIENT_PM) || defined(NEWER_PM)
2449 #undef device_set_wakeup_enable
2450 #define device_set_wakeup_enable(dev, val) \
2451         do { \
2452                 u16 pmc = 0; \
2453                 int pm = pci_find_capability(adapter->pdev, PCI_CAP_ID_PM); \
2454                 if (pm) { \
2455                         pci_read_config_word(adapter->pdev, pm + PCI_PM_PMC, \
2456                                 &pmc); \
2457                 } \
2458                 (dev)->power.can_wakeup = !!(pmc >> 11); \
2459                 (dev)->power.should_wakeup = (val && (pmc >> 11)); \
2460         } while (0)
2461 #endif /* 2.6.15-2.6.22 and CONFIG_PM or 2.6.23-2.6.25 and CONFIG_PM_SLEEP */
2462 #endif /* 2.6.15 through 2.6.27 */
2463 #ifndef netif_napi_del
2464 #define netif_napi_del(_a) do {} while (0)
2465 #ifdef NAPI
2466 #ifdef CONFIG_NETPOLL
2467 #undef netif_napi_del
2468 #define netif_napi_del(_a) list_del(&(_a)->dev_list);
2469 #endif
2470 #endif
2471 #endif /* netif_napi_del */
2472 #ifdef dma_mapping_error
2473 #undef dma_mapping_error
2474 #endif
2475 #define dma_mapping_error(dev, dma_addr) pci_dma_mapping_error(dma_addr)
2476
2477 #ifdef CONFIG_NETDEVICES_MULTIQUEUE
2478 #define HAVE_TX_MQ
2479 #endif
2480
2481 #ifdef HAVE_TX_MQ
2482 extern void _kc_netif_tx_stop_all_queues(struct net_device *);
2483 extern void _kc_netif_tx_wake_all_queues(struct net_device *);
2484 extern void _kc_netif_tx_start_all_queues(struct net_device *);
2485 #define netif_tx_stop_all_queues(a) _kc_netif_tx_stop_all_queues(a)
2486 #define netif_tx_wake_all_queues(a) _kc_netif_tx_wake_all_queues(a)
2487 #define netif_tx_start_all_queues(a) _kc_netif_tx_start_all_queues(a)
2488 #undef netif_stop_subqueue
2489 #define netif_stop_subqueue(_ndev,_qi) do { \
2490         if (netif_is_multiqueue((_ndev))) \
2491                 netif_stop_subqueue((_ndev), (_qi)); \
2492         else \
2493                 netif_stop_queue((_ndev)); \
2494         } while (0)
2495 #undef netif_start_subqueue
2496 #define netif_start_subqueue(_ndev,_qi) do { \
2497         if (netif_is_multiqueue((_ndev))) \
2498                 netif_start_subqueue((_ndev), (_qi)); \
2499         else \
2500                 netif_start_queue((_ndev)); \
2501         } while (0)
2502 #else /* HAVE_TX_MQ */
2503 #define netif_tx_stop_all_queues(a) netif_stop_queue(a)
2504 #define netif_tx_wake_all_queues(a) netif_wake_queue(a)
2505 #if ( LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12) )
2506 #define netif_tx_start_all_queues(a) netif_start_queue(a)
2507 #else
2508 #define netif_tx_start_all_queues(a) do {} while (0)
2509 #endif
2510 #define netif_stop_subqueue(_ndev,_qi) netif_stop_queue((_ndev))
2511 #define netif_start_subqueue(_ndev,_qi) netif_start_queue((_ndev))
2512 #endif /* HAVE_TX_MQ */
2513 #ifndef NETIF_F_MULTI_QUEUE
2514 #define NETIF_F_MULTI_QUEUE 0
2515 #define netif_is_multiqueue(a) 0
2516 #define netif_wake_subqueue(a, b)
2517 #endif /* NETIF_F_MULTI_QUEUE */
2518
2519 #ifndef __WARN_printf
2520 extern void __kc_warn_slowpath(const char *file, const int line,
2521                 const char *fmt, ...) __attribute__((format(printf, 3, 4)));
2522 #define __WARN_printf(arg...) __kc_warn_slowpath(__FILE__, __LINE__, arg)
2523 #endif /* __WARN_printf */
2524
2525 #ifndef WARN
2526 #define WARN(condition, format...) ({                                           \
2527         int __ret_warn_on = !!(condition);                              \
2528         if (unlikely(__ret_warn_on))                                    \
2529                 __WARN_printf(format);                                  \
2530         unlikely(__ret_warn_on);                                        \
2531 })
2532 #endif /* WARN */
2533 #undef HAVE_IXGBE_DEBUG_FS
2534 #undef HAVE_IGB_DEBUG_FS
2535 #else /* < 2.6.27 */
2536 #define HAVE_TX_MQ
2537 #define HAVE_NETDEV_SELECT_QUEUE
2538 #ifdef CONFIG_DEBUG_FS
2539 #define HAVE_IXGBE_DEBUG_FS
2540 #define HAVE_IGB_DEBUG_FS
2541 #endif /* CONFIG_DEBUG_FS */
2542 #endif /* < 2.6.27 */
2543
2544 /*****************************************************************************/
2545 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28) )
2546 #define pci_ioremap_bar(pdev, bar)      ioremap(pci_resource_start(pdev, bar), \
2547                                                 pci_resource_len(pdev, bar))
2548 #define pci_wake_from_d3 _kc_pci_wake_from_d3
2549 #define pci_prepare_to_sleep _kc_pci_prepare_to_sleep
2550 extern int _kc_pci_wake_from_d3(struct pci_dev *dev, bool enable);
2551 extern int _kc_pci_prepare_to_sleep(struct pci_dev *dev);
2552 #define netdev_alloc_page(a) alloc_page(GFP_ATOMIC)
2553 #ifndef __skb_queue_head_init
2554 static inline void __kc_skb_queue_head_init(struct sk_buff_head *list)
2555 {
2556         list->prev = list->next = (struct sk_buff *)list;
2557         list->qlen = 0;
2558 }
2559 #define __skb_queue_head_init(_q) __kc_skb_queue_head_init(_q)
2560 #endif
2561
2562 #define PCI_EXP_DEVCAP2         36      /* Device Capabilities 2 */
2563 #define PCI_EXP_DEVCTL2         40      /* Device Control 2 */
2564
2565 #endif /* < 2.6.28 */
2566
2567 /*****************************************************************************/
2568 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29) )
2569 #ifndef swap
2570 #define swap(a, b) \
2571         do { typeof(a) __tmp = (a); (a) = (b); (b) = __tmp; } while (0)
2572 #endif
2573 #define pci_request_selected_regions_exclusive(pdev, bars, name) \
2574                 pci_request_selected_regions(pdev, bars, name)
2575 #ifndef CONFIG_NR_CPUS
2576 #define CONFIG_NR_CPUS 1
2577 #endif /* CONFIG_NR_CPUS */
2578 #ifndef pcie_aspm_enabled
2579 #define pcie_aspm_enabled()   (1)
2580 #endif /* pcie_aspm_enabled */
2581
2582 #define  PCI_EXP_SLTSTA_PDS     0x0040  /* Presence Detect State */
2583
2584 #ifndef pci_clear_master
2585 extern void _kc_pci_clear_master(struct pci_dev *dev);
2586 #define pci_clear_master(dev)   _kc_pci_clear_master(dev)
2587 #endif
2588
2589 #ifndef PCI_EXP_LNKCTL_ASPMC
2590 #define  PCI_EXP_LNKCTL_ASPMC   0x0003  /* ASPM Control */
2591 #endif
2592 #else /* < 2.6.29 */
2593 #ifndef HAVE_NET_DEVICE_OPS
2594 #define HAVE_NET_DEVICE_OPS
2595 #endif
2596 #ifdef CONFIG_DCB
2597 #define HAVE_PFC_MODE_ENABLE
2598 #endif /* CONFIG_DCB */
2599 #endif /* < 2.6.29 */
2600
2601 /*****************************************************************************/
2602 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30) )
2603 #define skb_rx_queue_recorded(a) false
2604 #define skb_get_rx_queue(a) 0
2605 #define skb_record_rx_queue(a, b) do {} while (0)
2606 #define skb_tx_hash(n, s) ___kc_skb_tx_hash((n), (s), (n)->real_num_tx_queues)
2607 #ifndef CONFIG_PCI_IOV
2608 #undef pci_enable_sriov
2609 #define pci_enable_sriov(a, b) -ENOTSUPP
2610 #undef pci_disable_sriov
2611 #define pci_disable_sriov(a) do {} while (0)
2612 #endif /* CONFIG_PCI_IOV */
2613 #ifndef pr_cont
2614 #define pr_cont(fmt, ...) \
2615         printk(KERN_CONT fmt, ##__VA_ARGS__)
2616 #endif /* pr_cont */
2617 static inline void _kc_synchronize_irq(unsigned int a)
2618 {
2619 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,5,28) )
2620         synchronize_irq();
2621 #else /* < 2.5.28 */
2622         synchronize_irq(a);
2623 #endif /* < 2.5.28 */
2624 }
2625 #undef synchronize_irq
2626 #define synchronize_irq(a) _kc_synchronize_irq(a)
2627
2628 #define PCI_EXP_LNKCTL2         48      /* Link Control 2 */
2629
2630 #else /* < 2.6.30 */
2631 #define HAVE_ASPM_QUIRKS
2632 #endif /* < 2.6.30 */
2633
2634 /*****************************************************************************/
2635 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31) )
2636 #define ETH_P_1588 0x88F7
2637 #define ETH_P_FIP  0x8914
2638 #ifndef netdev_uc_count
2639 #define netdev_uc_count(dev) ((dev)->uc_count)
2640 #endif
2641 #ifndef netdev_for_each_uc_addr
2642 #define netdev_for_each_uc_addr(uclist, dev) \
2643         for (uclist = dev->uc_list; uclist; uclist = uclist->next)
2644 #endif
2645 #ifndef PORT_OTHER
2646 #define PORT_OTHER 0xff
2647 #endif
2648 #ifndef MDIO_PHY_ID_PRTAD
2649 #define MDIO_PHY_ID_PRTAD 0x03e0
2650 #endif
2651 #ifndef MDIO_PHY_ID_DEVAD
2652 #define MDIO_PHY_ID_DEVAD 0x001f
2653 #endif
2654 #ifndef skb_dst
2655 #define skb_dst(s) ((s)->dst)
2656 #endif
2657
2658 #ifndef SUPPORTED_1000baseKX_Full
2659 #define SUPPORTED_1000baseKX_Full       (1 << 17)
2660 #endif
2661 #ifndef SUPPORTED_10000baseKX4_Full
2662 #define SUPPORTED_10000baseKX4_Full     (1 << 18)
2663 #endif
2664 #ifndef SUPPORTED_10000baseKR_Full
2665 #define SUPPORTED_10000baseKR_Full      (1 << 19)
2666 #endif
2667
2668 #ifndef ADVERTISED_1000baseKX_Full
2669 #define ADVERTISED_1000baseKX_Full      (1 << 17)
2670 #endif
2671 #ifndef ADVERTISED_10000baseKX4_Full
2672 #define ADVERTISED_10000baseKX4_Full    (1 << 18)
2673 #endif
2674 #ifndef ADVERTISED_10000baseKR_Full
2675 #define ADVERTISED_10000baseKR_Full     (1 << 19)
2676 #endif
2677
2678 #else /* < 2.6.31 */
2679 #ifndef HAVE_NETDEV_STORAGE_ADDRESS
2680 #define HAVE_NETDEV_STORAGE_ADDRESS
2681 #endif
2682 #ifndef HAVE_NETDEV_HW_ADDR
2683 #define HAVE_NETDEV_HW_ADDR
2684 #endif
2685 #ifndef HAVE_TRANS_START_IN_QUEUE
2686 #define HAVE_TRANS_START_IN_QUEUE
2687 #endif
2688 #ifndef HAVE_INCLUDE_LINUX_MDIO_H
2689 #define HAVE_INCLUDE_LINUX_MDIO_H
2690 #endif
2691 #endif /* < 2.6.31 */
2692
2693 /*****************************************************************************/
2694 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32) )
2695 #undef netdev_tx_t
2696 #define netdev_tx_t int
2697 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
2698 #ifndef NETIF_F_FCOE_MTU
2699 #define NETIF_F_FCOE_MTU       (1 << 26)
2700 #endif
2701 #endif /* CONFIG_FCOE || CONFIG_FCOE_MODULE */
2702
2703 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) )
2704 static inline int _kc_pm_runtime_get_sync()
2705 {
2706         return 1;
2707 }
2708 #define pm_runtime_get_sync(dev)        _kc_pm_runtime_get_sync()
2709 #else /* 2.6.0 => 2.6.32 */
2710 static inline int _kc_pm_runtime_get_sync(struct device *dev)
2711 {
2712         return 1;
2713 }
2714 #ifndef pm_runtime_get_sync
2715 #define pm_runtime_get_sync(dev)        _kc_pm_runtime_get_sync(dev)
2716 #endif
2717 #endif /* 2.6.0 => 2.6.32 */
2718 #ifndef pm_runtime_put
2719 #define pm_runtime_put(dev)             do {} while (0)
2720 #endif
2721 #ifndef pm_runtime_put_sync
2722 #define pm_runtime_put_sync(dev)        do {} while (0)
2723 #endif
2724 #ifndef pm_runtime_resume
2725 #define pm_runtime_resume(dev)          do {} while (0)
2726 #endif
2727 #ifndef pm_schedule_suspend
2728 #define pm_schedule_suspend(dev, t)     do {} while (0)
2729 #endif
2730 #ifndef pm_runtime_set_suspended
2731 #define pm_runtime_set_suspended(dev)   do {} while (0)
2732 #endif
2733 #ifndef pm_runtime_disable
2734 #define pm_runtime_disable(dev)         do {} while (0)
2735 #endif
2736 #ifndef pm_runtime_put_noidle
2737 #define pm_runtime_put_noidle(dev)      do {} while (0)
2738 #endif
2739 #ifndef pm_runtime_set_active
2740 #define pm_runtime_set_active(dev)      do {} while (0)
2741 #endif
2742 #ifndef pm_runtime_enable
2743 #define pm_runtime_enable(dev)  do {} while (0)
2744 #endif
2745 #ifndef pm_runtime_get_noresume
2746 #define pm_runtime_get_noresume(dev)    do {} while (0)
2747 #endif
2748 #else /* < 2.6.32 */
2749 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
2750 #ifndef HAVE_NETDEV_OPS_FCOE_ENABLE
2751 #define HAVE_NETDEV_OPS_FCOE_ENABLE
2752 #endif
2753 #endif /* CONFIG_FCOE || CONFIG_FCOE_MODULE */
2754 #ifdef CONFIG_DCB
2755 #ifndef HAVE_DCBNL_OPS_GETAPP
2756 #define HAVE_DCBNL_OPS_GETAPP
2757 #endif
2758 #endif /* CONFIG_DCB */
2759 #include <linux/pm_runtime.h>
2760 /* IOV bad DMA target work arounds require at least this kernel rev support */
2761 #define HAVE_PCIE_TYPE
2762 #endif /* < 2.6.32 */
2763
2764 /*****************************************************************************/
2765 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33) )
2766 #ifndef pci_pcie_cap
2767 #define pci_pcie_cap(pdev) pci_find_capability(pdev, PCI_CAP_ID_EXP)
2768 #endif
2769 #ifndef IPV4_FLOW
2770 #define IPV4_FLOW 0x10
2771 #endif /* IPV4_FLOW */
2772 #ifndef IPV6_FLOW
2773 #define IPV6_FLOW 0x11
2774 #endif /* IPV6_FLOW */
2775 /* Features back-ported to RHEL6 or SLES11 SP1 after 2.6.32 */
2776 #if ( (RHEL_RELEASE_CODE && RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(6,0)) || \
2777       (SLE_VERSION_CODE && SLE_VERSION_CODE >= SLE_VERSION(11,1,0)) )
2778 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
2779 #ifndef HAVE_NETDEV_OPS_FCOE_GETWWN
2780 #define HAVE_NETDEV_OPS_FCOE_GETWWN
2781 #endif
2782 #endif /* CONFIG_FCOE || CONFIG_FCOE_MODULE */
2783 #endif /* RHEL6 or SLES11 SP1 */
2784 #ifndef __percpu
2785 #define __percpu
2786 #endif /* __percpu */
2787 #ifndef PORT_DA
2788 #define PORT_DA PORT_OTHER
2789 #endif
2790 #ifndef PORT_NONE
2791 #define PORT_NONE PORT_OTHER
2792 #endif
2793
2794 #if ((RHEL_RELEASE_CODE && \
2795      (RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(6,3)) && \
2796      (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(7,0))))
2797 #if !defined(CONFIG_X86_32) && !defined(CONFIG_NEED_DMA_MAP_STATE)
2798 #undef DEFINE_DMA_UNMAP_ADDR
2799 #define DEFINE_DMA_UNMAP_ADDR(ADDR_NAME)        dma_addr_t ADDR_NAME
2800 #undef DEFINE_DMA_UNMAP_LEN
2801 #define DEFINE_DMA_UNMAP_LEN(LEN_NAME)          __u32 LEN_NAME
2802 #undef dma_unmap_addr
2803 #define dma_unmap_addr(PTR, ADDR_NAME)          ((PTR)->ADDR_NAME)
2804 #undef dma_unmap_addr_set
2805 #define dma_unmap_addr_set(PTR, ADDR_NAME, VAL) (((PTR)->ADDR_NAME) = (VAL))
2806 #undef dma_unmap_len
2807 #define dma_unmap_len(PTR, LEN_NAME)            ((PTR)->LEN_NAME)
2808 #undef dma_unmap_len_set
2809 #define dma_unmap_len_set(PTR, LEN_NAME, VAL)   (((PTR)->LEN_NAME) = (VAL))
2810 #endif /* CONFIG_X86_64 && !CONFIG_NEED_DMA_MAP_STATE */
2811 #endif /* RHEL_RELEASE_CODE */
2812
2813 #if (!(RHEL_RELEASE_CODE && \
2814        (((RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(5,8)) && \
2815          (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(6,0))) || \
2816         ((RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(6,1)) && \
2817          (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(7,0))))))
2818 static inline bool pci_is_pcie(struct pci_dev *dev)
2819 {
2820         return !!pci_pcie_cap(dev);
2821 }
2822 #endif /* RHEL_RELEASE_CODE */
2823
2824 #ifndef __always_unused
2825 #define __always_unused __attribute__((__unused__))
2826 #endif
2827 #ifndef __maybe_unused
2828 #define __maybe_unused __attribute__((__unused__))
2829 #endif
2830
2831 #if (!(RHEL_RELEASE_CODE && \
2832       (RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(6,2))))
2833 #define sk_tx_queue_get(_sk) (-1)
2834 #define sk_tx_queue_set(_sk, _tx_queue) do {} while(0)
2835 #endif /* !(RHEL >= 6.2) */
2836
2837 #if (RHEL_RELEASE_CODE && \
2838      (RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(6,4)) && \
2839      (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(7,0)))
2840 #define HAVE_RHEL6_ETHTOOL_OPS_EXT_STRUCT
2841 #define HAVE_ETHTOOL_SET_PHYS_ID
2842 #define HAVE_ETHTOOL_GET_TS_INFO
2843 #endif /* RHEL >= 6.4 && RHEL < 7.0 */
2844
2845 #if (RHEL_RELEASE_CODE && \
2846      (RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(6,5)) && \
2847      (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(7,0)))
2848 #define HAVE_RHEL6_NETDEV_OPS_EXT_FDB
2849 #endif /* RHEL >= 6.5 && RHEL < 7.0 */
2850
2851 #else /* < 2.6.33 */
2852 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
2853 #ifndef HAVE_NETDEV_OPS_FCOE_GETWWN
2854 #define HAVE_NETDEV_OPS_FCOE_GETWWN
2855 #endif
2856 #endif /* CONFIG_FCOE || CONFIG_FCOE_MODULE */
2857 #endif /* < 2.6.33 */
2858
2859 /*****************************************************************************/
2860 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,34) )
2861 #if (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(6,0))
2862 #ifndef pci_num_vf
2863 #define pci_num_vf(pdev) _kc_pci_num_vf(pdev)
2864 extern int _kc_pci_num_vf(struct pci_dev *dev);
2865 #endif
2866 #endif /* RHEL_RELEASE_CODE */
2867
2868 #ifndef ETH_FLAG_NTUPLE
2869 #define ETH_FLAG_NTUPLE NETIF_F_NTUPLE
2870 #endif
2871
2872 #ifndef netdev_mc_count
2873 #define netdev_mc_count(dev) ((dev)->mc_count)
2874 #endif
2875 #ifndef netdev_mc_empty
2876 #define netdev_mc_empty(dev) (netdev_mc_count(dev) == 0)
2877 #endif
2878 #ifndef netdev_for_each_mc_addr
2879 #define netdev_for_each_mc_addr(mclist, dev) \
2880         for (mclist = dev->mc_list; mclist; mclist = mclist->next)
2881 #endif
2882 #ifndef netdev_uc_count
2883 #define netdev_uc_count(dev) ((dev)->uc.count)
2884 #endif
2885 #ifndef netdev_uc_empty
2886 #define netdev_uc_empty(dev) (netdev_uc_count(dev) == 0)
2887 #endif
2888 #ifndef netdev_for_each_uc_addr
2889 #define netdev_for_each_uc_addr(ha, dev) \
2890         list_for_each_entry(ha, &dev->uc.list, list)
2891 #endif
2892 #ifndef dma_set_coherent_mask
2893 #define dma_set_coherent_mask(dev,mask) \
2894         pci_set_consistent_dma_mask(to_pci_dev(dev),(mask))
2895 #endif
2896 #ifndef pci_dev_run_wake
2897 #define pci_dev_run_wake(pdev)  (0)
2898 #endif
2899
2900 /* netdev logging taken from include/linux/netdevice.h */
2901 #ifndef netdev_name
2902 static inline const char *_kc_netdev_name(const struct net_device *dev)
2903 {
2904         if (dev->reg_state != NETREG_REGISTERED)
2905                 return "(unregistered net_device)";
2906         return dev->name;
2907 }
2908 #define netdev_name(netdev)     _kc_netdev_name(netdev)
2909 #endif /* netdev_name */
2910
2911 #undef netdev_printk
2912 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) )
2913 #define netdev_printk(level, netdev, format, args...)           \
2914 do {                                                            \
2915         struct pci_dev *pdev = _kc_netdev_to_pdev(netdev);      \
2916         printk(level "%s: " format, pci_name(pdev), ##args);    \
2917 } while(0)
2918 #elif ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21) )
2919 #define netdev_printk(level, netdev, format, args...)           \
2920 do {                                                            \
2921         struct pci_dev *pdev = _kc_netdev_to_pdev(netdev);      \
2922         struct device *dev = pci_dev_to_dev(pdev);              \
2923         dev_printk(level, dev, "%s: " format,                   \
2924                    netdev_name(netdev), ##args);                \
2925 } while(0)
2926 #else /* 2.6.21 => 2.6.34 */
2927 #define netdev_printk(level, netdev, format, args...)           \
2928         dev_printk(level, (netdev)->dev.parent,                 \
2929                    "%s: " format,                               \
2930                    netdev_name(netdev), ##args)
2931 #endif /* <2.6.0 <2.6.21 <2.6.34 */
2932 #undef netdev_emerg
2933 #define netdev_emerg(dev, format, args...)                      \
2934         netdev_printk(KERN_EMERG, dev, format, ##args)
2935 #undef netdev_alert
2936 #define netdev_alert(dev, format, args...)                      \
2937         netdev_printk(KERN_ALERT, dev, format, ##args)
2938 #undef netdev_crit
2939 #define netdev_crit(dev, format, args...)                       \
2940         netdev_printk(KERN_CRIT, dev, format, ##args)
2941 #undef netdev_err
2942 #define netdev_err(dev, format, args...)                        \
2943         netdev_printk(KERN_ERR, dev, format, ##args)
2944 #undef netdev_warn
2945 #define netdev_warn(dev, format, args...)                       \
2946         netdev_printk(KERN_WARNING, dev, format, ##args)
2947 #undef netdev_notice
2948 #define netdev_notice(dev, format, args...)                     \
2949         netdev_printk(KERN_NOTICE, dev, format, ##args)
2950 #undef netdev_info
2951 #define netdev_info(dev, format, args...)                       \
2952         netdev_printk(KERN_INFO, dev, format, ##args)
2953 #undef netdev_dbg
2954 #if defined(DEBUG)
2955 #define netdev_dbg(__dev, format, args...)                      \
2956         netdev_printk(KERN_DEBUG, __dev, format, ##args)
2957 #elif defined(CONFIG_DYNAMIC_DEBUG)
2958 #define netdev_dbg(__dev, format, args...)                      \
2959 do {                                                            \
2960         dynamic_dev_dbg((__dev)->dev.parent, "%s: " format,     \
2961                         netdev_name(__dev), ##args);            \
2962 } while (0)
2963 #else /* DEBUG */
2964 #define netdev_dbg(__dev, format, args...)                      \
2965 ({                                                              \
2966         if (0)                                                  \
2967                 netdev_printk(KERN_DEBUG, __dev, format, ##args); \
2968         0;                                                      \
2969 })
2970 #endif /* DEBUG */
2971
2972 #undef netif_printk
2973 #define netif_printk(priv, type, level, dev, fmt, args...)      \
2974 do {                                                            \
2975         if (netif_msg_##type(priv))                             \
2976                 netdev_printk(level, (dev), fmt, ##args);       \
2977 } while (0)
2978
2979 #undef netif_emerg
2980 #define netif_emerg(priv, type, dev, fmt, args...)              \
2981         netif_level(emerg, priv, type, dev, fmt, ##args)
2982 #undef netif_alert
2983 #define netif_alert(priv, type, dev, fmt, args...)              \
2984         netif_level(alert, priv, type, dev, fmt, ##args)
2985 #undef netif_crit
2986 #define netif_crit(priv, type, dev, fmt, args...)               \
2987         netif_level(crit, priv, type, dev, fmt, ##args)
2988 #undef netif_err
2989 #define netif_err(priv, type, dev, fmt, args...)                \
2990         netif_level(err, priv, type, dev, fmt, ##args)
2991 #undef netif_warn
2992 #define netif_warn(priv, type, dev, fmt, args...)               \
2993         netif_level(warn, priv, type, dev, fmt, ##args)
2994 #undef netif_notice
2995 #define netif_notice(priv, type, dev, fmt, args...)             \
2996         netif_level(notice, priv, type, dev, fmt, ##args)
2997 #undef netif_info
2998 #define netif_info(priv, type, dev, fmt, args...)               \
2999         netif_level(info, priv, type, dev, fmt, ##args)
3000 #undef netif_dbg
3001 #define netif_dbg(priv, type, dev, fmt, args...)                \
3002         netif_level(dbg, priv, type, dev, fmt, ##args)
3003
3004 #ifdef SET_SYSTEM_SLEEP_PM_OPS
3005 #define HAVE_SYSTEM_SLEEP_PM_OPS
3006 #endif
3007
3008 #ifndef for_each_set_bit
3009 #define for_each_set_bit(bit, addr, size) \
3010         for ((bit) = find_first_bit((addr), (size)); \
3011                 (bit) < (size); \
3012                 (bit) = find_next_bit((addr), (size), (bit) + 1))
3013 #endif /* for_each_set_bit */
3014
3015 #ifndef DEFINE_DMA_UNMAP_ADDR
3016 #define DEFINE_DMA_UNMAP_ADDR DECLARE_PCI_UNMAP_ADDR
3017 #define DEFINE_DMA_UNMAP_LEN DECLARE_PCI_UNMAP_LEN
3018 #define dma_unmap_addr pci_unmap_addr
3019 #define dma_unmap_addr_set pci_unmap_addr_set
3020 #define dma_unmap_len pci_unmap_len
3021 #define dma_unmap_len_set pci_unmap_len_set
3022 #endif /* DEFINE_DMA_UNMAP_ADDR */
3023
3024 #if (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(6,3))
3025 #ifdef IGB_HWMON
3026 #ifdef CONFIG_DEBUG_LOCK_ALLOC
3027 #define sysfs_attr_init(attr)                           \
3028         do {                                            \
3029                 static struct lock_class_key __key;     \
3030                 (attr)->key = &__key;                   \
3031         } while (0)
3032 #else
3033 #define sysfs_attr_init(attr) do {} while (0)
3034 #endif /* CONFIG_DEBUG_LOCK_ALLOC */
3035 #endif /* IGB_HWMON */
3036 #endif /* RHEL_RELEASE_CODE */
3037
3038 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) )
3039 static inline bool _kc_pm_runtime_suspended()
3040 {
3041         return false;
3042 }
3043 #define pm_runtime_suspended(dev)       _kc_pm_runtime_suspended()
3044 #else /* 2.6.0 => 2.6.34 */
3045 static inline bool _kc_pm_runtime_suspended(struct device *dev)
3046 {
3047         return false;
3048 }
3049 #ifndef pm_runtime_suspended
3050 #define pm_runtime_suspended(dev)       _kc_pm_runtime_suspended(dev)
3051 #endif
3052 #endif /* 2.6.0 => 2.6.34 */
3053
3054 #else /* < 2.6.34 */
3055 #define HAVE_SYSTEM_SLEEP_PM_OPS
3056 #ifndef HAVE_SET_RX_MODE
3057 #define HAVE_SET_RX_MODE
3058 #endif
3059
3060 #endif /* < 2.6.34 */
3061
3062 /*****************************************************************************/
3063 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35) )
3064
3065 ssize_t _kc_simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
3066                                    const void __user *from, size_t count);
3067 #define simple_write_to_buffer _kc_simple_write_to_buffer
3068
3069 #ifndef numa_node_id
3070 #define numa_node_id() 0
3071 #endif
3072 #ifdef HAVE_TX_MQ
3073 #include <net/sch_generic.h>
3074 #ifndef CONFIG_NETDEVICES_MULTIQUEUE
3075 #if (!(RHEL_RELEASE_CODE && RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(6,0)))
3076 void _kc_netif_set_real_num_tx_queues(struct net_device *, unsigned int);
3077 #define netif_set_real_num_tx_queues  _kc_netif_set_real_num_tx_queues
3078 #endif /* !(RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(6,0)) */
3079 #else /* CONFIG_NETDEVICES_MULTI_QUEUE */
3080 #define netif_set_real_num_tx_queues(_netdev, _count) \
3081         do { \
3082                 (_netdev)->egress_subqueue_count = _count; \
3083         } while (0)
3084 #endif /* CONFIG_NETDEVICES_MULTI_QUEUE */
3085 #else /* HAVE_TX_MQ */
3086 #define netif_set_real_num_tx_queues(_netdev, _count) do {} while(0)
3087 #endif /* HAVE_TX_MQ */
3088 #ifndef ETH_FLAG_RXHASH
3089 #define ETH_FLAG_RXHASH (1<<28)
3090 #endif /* ETH_FLAG_RXHASH */
3091 #if (RHEL_RELEASE_CODE && RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(6,0))
3092 #define HAVE_IRQ_AFFINITY_HINT
3093 #endif
3094 #else /* < 2.6.35 */
3095 #define HAVE_PM_QOS_REQUEST_LIST
3096 #define HAVE_IRQ_AFFINITY_HINT
3097 #endif /* < 2.6.35 */
3098
3099 /*****************************************************************************/
3100 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36) )
3101 extern int _kc_ethtool_op_set_flags(struct net_device *, u32, u32);
3102 #define ethtool_op_set_flags _kc_ethtool_op_set_flags
3103 extern u32 _kc_ethtool_op_get_flags(struct net_device *);
3104 #define ethtool_op_get_flags _kc_ethtool_op_get_flags
3105
3106 #ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
3107 #ifdef NET_IP_ALIGN
3108 #undef NET_IP_ALIGN
3109 #endif
3110 #define NET_IP_ALIGN 0
3111 #endif /* CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS */
3112
3113 #ifdef NET_SKB_PAD
3114 #undef NET_SKB_PAD
3115 #endif
3116
3117 #if (L1_CACHE_BYTES > 32)
3118 #define NET_SKB_PAD L1_CACHE_BYTES
3119 #else
3120 #define NET_SKB_PAD 32
3121 #endif
3122
3123 static inline struct sk_buff *_kc_netdev_alloc_skb_ip_align(struct net_device *dev,
3124                                                             unsigned int length)
3125 {
3126         struct sk_buff *skb;
3127
3128         skb = alloc_skb(length + NET_SKB_PAD + NET_IP_ALIGN, GFP_ATOMIC);
3129         if (skb) {
3130 #if (NET_IP_ALIGN + NET_SKB_PAD)
3131                 skb_reserve(skb, NET_IP_ALIGN + NET_SKB_PAD);
3132 #endif
3133                 skb->dev = dev;
3134         }
3135         return skb;
3136 }
3137
3138 #ifdef netdev_alloc_skb_ip_align
3139 #undef netdev_alloc_skb_ip_align
3140 #endif
3141 #define netdev_alloc_skb_ip_align(n, l) _kc_netdev_alloc_skb_ip_align(n, l)
3142
3143 #undef netif_level
3144 #define netif_level(level, priv, type, dev, fmt, args...)       \
3145 do {                                                            \
3146         if (netif_msg_##type(priv))                             \
3147                 netdev_##level(dev, fmt, ##args);               \
3148 } while (0)
3149
3150 #undef usleep_range
3151 #define usleep_range(min, max)  msleep(DIV_ROUND_UP(min, 1000))
3152
3153 #define u64_stats_update_begin(a) do { } while(0)
3154 #define u64_stats_update_end(a) do { } while(0)
3155 #define u64_stats_fetch_begin(a) do { } while(0)
3156 #define u64_stats_fetch_retry_bh(a) (0)
3157 #define u64_stats_fetch_begin_bh(a) (0)
3158
3159 #if (RHEL_RELEASE_CODE && RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(6,1))
3160 #define HAVE_8021P_SUPPORT
3161 #endif
3162
3163 #else /* < 2.6.36 */
3164
3165
3166 #define HAVE_PM_QOS_REQUEST_ACTIVE
3167 #define HAVE_8021P_SUPPORT
3168 #define HAVE_NDO_GET_STATS64
3169 #endif /* < 2.6.36 */
3170
3171 /*****************************************************************************/
3172 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37) )
3173 #ifndef netif_set_real_num_rx_queues
3174 static inline int __kc_netif_set_real_num_rx_queues(struct net_device *dev,
3175                                                     unsigned int rxq)
3176 {
3177         return 0;
3178 }
3179 #define netif_set_real_num_rx_queues(dev, rxq) \
3180         __kc_netif_set_real_num_rx_queues((dev), (rxq))
3181 #endif
3182 #ifndef ETHTOOL_RXNTUPLE_ACTION_CLEAR
3183 #define ETHTOOL_RXNTUPLE_ACTION_CLEAR (-2)
3184 #endif
3185 #ifndef VLAN_N_VID
3186 #define VLAN_N_VID      VLAN_GROUP_ARRAY_LEN
3187 #endif /* VLAN_N_VID */
3188 #ifndef ETH_FLAG_TXVLAN
3189 #define ETH_FLAG_TXVLAN (1 << 7)
3190 #endif /* ETH_FLAG_TXVLAN */
3191 #ifndef ETH_FLAG_RXVLAN
3192 #define ETH_FLAG_RXVLAN (1 << 8)
3193 #endif /* ETH_FLAG_RXVLAN */
3194
3195 static inline void _kc_skb_checksum_none_assert(struct sk_buff *skb)
3196 {
3197         WARN_ON(skb->ip_summed != CHECKSUM_NONE);
3198 }
3199 #define skb_checksum_none_assert(skb) _kc_skb_checksum_none_assert(skb)
3200
3201 static inline void *_kc_vzalloc_node(unsigned long size, int node)
3202 {
3203         void *addr = vmalloc_node(size, node);
3204         if (addr)
3205                 memset(addr, 0, size);
3206         return addr;
3207 }
3208 #define vzalloc_node(_size, _node) _kc_vzalloc_node(_size, _node)
3209
3210 static inline void *_kc_vzalloc(unsigned long size)
3211 {
3212         void *addr = vmalloc(size);
3213         if (addr)
3214                 memset(addr, 0, size);
3215         return addr;
3216 }
3217 #define vzalloc(_size) _kc_vzalloc(_size)
3218
3219 #ifndef vlan_get_protocol
3220 static inline __be16 __kc_vlan_get_protocol(const struct sk_buff *skb)
3221 {
3222         if (vlan_tx_tag_present(skb) ||
3223             skb->protocol != cpu_to_be16(ETH_P_8021Q))
3224                 return skb->protocol;
3225
3226         if (skb_headlen(skb) < sizeof(struct vlan_ethhdr))
3227                 return 0;
3228
3229         return ((struct vlan_ethhdr*)skb->data)->h_vlan_encapsulated_proto;
3230 }
3231 #define vlan_get_protocol(_skb) __kc_vlan_get_protocol(_skb)
3232 #endif
3233 #ifdef HAVE_HW_TIME_STAMP
3234 #define SKBTX_HW_TSTAMP (1 << 0)
3235 #define SKBTX_IN_PROGRESS (1 << 2)
3236 #define SKB_SHARED_TX_IS_UNION
3237 #endif
3238
3239 #ifndef device_wakeup_enable
3240 #define device_wakeup_enable(dev)       device_set_wakeup_enable(dev, true)
3241 #endif
3242
3243 #if ( LINUX_VERSION_CODE > KERNEL_VERSION(2,4,18) )
3244 #ifndef HAVE_VLAN_RX_REGISTER
3245 #define HAVE_VLAN_RX_REGISTER
3246 #endif
3247 #endif /* > 2.4.18 */
3248 #endif /* < 2.6.37 */
3249
3250 /*****************************************************************************/
3251 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38) )
3252 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22) )
3253 #define skb_checksum_start_offset(skb) skb_transport_offset(skb)
3254 #else /* 2.6.22 -> 2.6.37 */
3255 static inline int _kc_skb_checksum_start_offset(const struct sk_buff *skb)
3256 {
3257         return skb->csum_start - skb_headroom(skb);
3258 }
3259 #define skb_checksum_start_offset(skb) _kc_skb_checksum_start_offset(skb)
3260 #endif /* 2.6.22 -> 2.6.37 */
3261 #ifdef CONFIG_DCB
3262 #ifndef IEEE_8021QAZ_MAX_TCS
3263 #define IEEE_8021QAZ_MAX_TCS 8
3264 #endif
3265 #ifndef DCB_CAP_DCBX_HOST
3266 #define DCB_CAP_DCBX_HOST               0x01
3267 #endif
3268 #ifndef DCB_CAP_DCBX_LLD_MANAGED
3269 #define DCB_CAP_DCBX_LLD_MANAGED        0x02
3270 #endif
3271 #ifndef DCB_CAP_DCBX_VER_CEE
3272 #define DCB_CAP_DCBX_VER_CEE            0x04
3273 #endif
3274 #ifndef DCB_CAP_DCBX_VER_IEEE
3275 #define DCB_CAP_DCBX_VER_IEEE           0x08
3276 #endif
3277 #ifndef DCB_CAP_DCBX_STATIC
3278 #define DCB_CAP_DCBX_STATIC             0x10
3279 #endif
3280 #endif /* CONFIG_DCB */
3281 #if (RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(6,2))
3282 #define CONFIG_XPS
3283 #endif /* RHEL_RELEASE_VERSION(6,2) */
3284 #endif /* < 2.6.38 */
3285
3286 /*****************************************************************************/
3287 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39) )
3288 #ifndef NETIF_F_RXCSUM
3289 #define NETIF_F_RXCSUM          (1 << 29)
3290 #endif
3291 #ifndef skb_queue_reverse_walk_safe
3292 #define skb_queue_reverse_walk_safe(queue, skb, tmp)                            \
3293                 for (skb = (queue)->prev, tmp = skb->prev;                      \
3294                      skb != (struct sk_buff *)(queue);                          \
3295                      skb = tmp, tmp = skb->prev)
3296 #endif
3297 #else /* < 2.6.39 */
3298 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
3299 #ifndef HAVE_NETDEV_OPS_FCOE_DDP_TARGET
3300 #define HAVE_NETDEV_OPS_FCOE_DDP_TARGET
3301 #endif
3302 #endif /* CONFIG_FCOE || CONFIG_FCOE_MODULE */
3303 #ifndef HAVE_MQPRIO
3304 #define HAVE_MQPRIO
3305 #endif
3306 #ifndef HAVE_SETUP_TC
3307 #define HAVE_SETUP_TC
3308 #endif
3309 #ifdef CONFIG_DCB
3310 #ifndef HAVE_DCBNL_IEEE
3311 #define HAVE_DCBNL_IEEE
3312 #endif
3313 #endif /* CONFIG_DCB */
3314 #ifndef HAVE_NDO_SET_FEATURES
3315 #define HAVE_NDO_SET_FEATURES
3316 #endif
3317 #endif /* < 2.6.39 */
3318
3319 /*****************************************************************************/
3320 /* use < 2.6.40 because of a Fedora 15 kernel update where they
3321  * updated the kernel version to 2.6.40.x and they back-ported 3.0 features
3322  * like set_phys_id for ethtool.
3323  */
3324 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,40) )
3325 #ifdef ETHTOOL_GRXRINGS
3326 #ifndef FLOW_EXT
3327 #define FLOW_EXT        0x80000000
3328 union _kc_ethtool_flow_union {
3329         struct ethtool_tcpip4_spec              tcp_ip4_spec;
3330         struct ethtool_usrip4_spec              usr_ip4_spec;
3331         __u8                                    hdata[60];
3332 };
3333 struct _kc_ethtool_flow_ext {
3334         __be16  vlan_etype;
3335         __be16  vlan_tci;
3336         __be32  data[2];
3337 };
3338 struct _kc_ethtool_rx_flow_spec {
3339         __u32           flow_type;
3340         union _kc_ethtool_flow_union h_u;
3341         struct _kc_ethtool_flow_ext h_ext;
3342         union _kc_ethtool_flow_union m_u;
3343         struct _kc_ethtool_flow_ext m_ext;
3344         __u64           ring_cookie;
3345         __u32           location;
3346 };
3347 #define ethtool_rx_flow_spec _kc_ethtool_rx_flow_spec
3348 #endif /* FLOW_EXT */
3349 #endif
3350
3351 #define pci_disable_link_state_locked pci_disable_link_state
3352
3353 #ifndef PCI_LTR_VALUE_MASK
3354 #define  PCI_LTR_VALUE_MASK     0x000003ff
3355 #endif
3356 #ifndef PCI_LTR_SCALE_MASK
3357 #define  PCI_LTR_SCALE_MASK     0x00001c00
3358 #endif
3359 #ifndef PCI_LTR_SCALE_SHIFT
3360 #define  PCI_LTR_SCALE_SHIFT    10
3361 #endif
3362
3363 #else /* < 2.6.40 */
3364 #define HAVE_ETHTOOL_SET_PHYS_ID
3365 #endif /* < 2.6.40 */
3366
3367 /*****************************************************************************/
3368 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0) )
3369 #define USE_LEGACY_PM_SUPPORT
3370 #endif /* < 3.0.0 */
3371
3372 /*****************************************************************************/
3373 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0) )
3374 #ifndef __netdev_alloc_skb_ip_align
3375 #define __netdev_alloc_skb_ip_align(d,l,_g) netdev_alloc_skb_ip_align(d,l)
3376 #endif /* __netdev_alloc_skb_ip_align */
3377 #define dcb_ieee_setapp(dev, app) dcb_setapp(dev, app)
3378 #define dcb_ieee_delapp(dev, app) 0
3379 #define dcb_ieee_getapp_mask(dev, app) (1 << app->priority)
3380
3381 /* 1000BASE-T Control register */
3382 #define CTL1000_AS_MASTER       0x0800
3383 #define CTL1000_ENABLE_MASTER   0x1000
3384
3385 #else /* < 3.1.0 */
3386 #ifndef HAVE_DCBNL_IEEE_DELAPP
3387 #define HAVE_DCBNL_IEEE_DELAPP
3388 #endif
3389 #endif /* < 3.1.0 */
3390
3391 /*****************************************************************************/
3392 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(3,2,0) )
3393 #ifdef ETHTOOL_GRXRINGS
3394 #define HAVE_ETHTOOL_GET_RXNFC_VOID_RULE_LOCS
3395 #endif /* ETHTOOL_GRXRINGS */
3396
3397 #ifndef skb_frag_size
3398 #define skb_frag_size(frag)     _kc_skb_frag_size(frag)
3399 static inline unsigned int _kc_skb_frag_size(const skb_frag_t *frag)
3400 {
3401         return frag->size;
3402 }
3403 #endif /* skb_frag_size */
3404
3405 #ifndef skb_frag_size_sub
3406 #define skb_frag_size_sub(frag, delta)  _kc_skb_frag_size_sub(frag, delta)
3407 static inline void _kc_skb_frag_size_sub(skb_frag_t *frag, int delta)
3408 {
3409         frag->size -= delta;
3410 }
3411 #endif /* skb_frag_size_sub */
3412
3413 #ifndef skb_frag_page
3414 #define skb_frag_page(frag)     _kc_skb_frag_page(frag)
3415 static inline struct page *_kc_skb_frag_page(const skb_frag_t *frag)
3416 {
3417         return frag->page;
3418 }
3419 #endif /* skb_frag_page */
3420
3421 #ifndef skb_frag_address
3422 #define skb_frag_address(frag)  _kc_skb_frag_address(frag)
3423 static inline void *_kc_skb_frag_address(const skb_frag_t *frag)
3424 {
3425         return page_address(skb_frag_page(frag)) + frag->page_offset;
3426 }
3427 #endif /* skb_frag_address */
3428
3429 #ifndef skb_frag_dma_map
3430 #if ( LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) )
3431 #include <linux/dma-mapping.h>
3432 #endif
3433 #define skb_frag_dma_map(dev,frag,offset,size,dir) \
3434                 _kc_skb_frag_dma_map(dev,frag,offset,size,dir)
3435 static inline dma_addr_t _kc_skb_frag_dma_map(struct device *dev,
3436                                               const skb_frag_t *frag,
3437                                               size_t offset, size_t size,
3438                                               enum dma_data_direction dir)
3439 {
3440         return dma_map_page(dev, skb_frag_page(frag),
3441                             frag->page_offset + offset, size, dir);
3442 }
3443 #endif /* skb_frag_dma_map */
3444
3445 #ifndef __skb_frag_unref
3446 #define __skb_frag_unref(frag) __kc_skb_frag_unref(frag)
3447 static inline void __kc_skb_frag_unref(skb_frag_t *frag)
3448 {
3449         put_page(skb_frag_page(frag));
3450 }
3451 #endif /* __skb_frag_unref */
3452
3453 #ifndef SPEED_UNKNOWN
3454 #define SPEED_UNKNOWN   -1
3455 #endif
3456 #ifndef DUPLEX_UNKNOWN
3457 #define DUPLEX_UNKNOWN  0xff
3458 #endif
3459 #if (RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(6,3))
3460 #ifndef HAVE_PCI_DEV_FLAGS_ASSIGNED
3461 #define HAVE_PCI_DEV_FLAGS_ASSIGNED
3462 #endif
3463 #endif
3464 #else /* < 3.2.0 */
3465 #ifndef HAVE_PCI_DEV_FLAGS_ASSIGNED
3466 #define HAVE_PCI_DEV_FLAGS_ASSIGNED
3467 #define HAVE_VF_SPOOFCHK_CONFIGURE
3468 #endif
3469 #endif /* < 3.2.0 */
3470
3471 #if (RHEL_RELEASE_CODE && RHEL_RELEASE_CODE == RHEL_RELEASE_VERSION(6,2))
3472 #undef ixgbe_get_netdev_tc_txq
3473 #define ixgbe_get_netdev_tc_txq(dev, tc) (&netdev_extended(dev)->qos_data.tc_to_txq[tc])
3474 #endif
3475 /*****************************************************************************/
3476 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0) )
3477 typedef u32 kni_netdev_features_t;
3478 #undef PCI_EXP_TYPE_RC_EC
3479 #define  PCI_EXP_TYPE_RC_EC     0xa     /* Root Complex Event Collector */
3480 #ifndef CONFIG_BQL
3481 #define netdev_tx_completed_queue(_q, _p, _b) do {} while (0)
3482 #define netdev_completed_queue(_n, _p, _b) do {} while (0)
3483 #define netdev_tx_sent_queue(_q, _b) do {} while (0)
3484 #define netdev_sent_queue(_n, _b) do {} while (0)
3485 #define netdev_tx_reset_queue(_q) do {} while (0)
3486 #define netdev_reset_queue(_n) do {} while (0)
3487 #endif
3488 #else /* ! < 3.3.0 */
3489 typedef netdev_features_t kni_netdev_features_t;
3490 #define HAVE_INT_NDO_VLAN_RX_ADD_VID
3491 #ifdef ETHTOOL_SRXNTUPLE
3492 #undef ETHTOOL_SRXNTUPLE
3493 #endif
3494 #endif /* < 3.3.0 */
3495
3496 /*****************************************************************************/
3497 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(3,4,0) )
3498 #ifndef NETIF_F_RXFCS
3499 #define NETIF_F_RXFCS   0
3500 #endif /* NETIF_F_RXFCS */
3501 #ifndef NETIF_F_RXALL
3502 #define NETIF_F_RXALL   0
3503 #endif /* NETIF_F_RXALL */
3504
3505 #if !(SLE_VERSION_CODE && SLE_VERSION_CODE >= SLE_VERSION(11,3,0))
3506 #define NUMTCS_RETURNS_U8
3507
3508 int _kc_simple_open(struct inode *inode, struct file *file);
3509 #define simple_open _kc_simple_open
3510 #endif /* !(SLE_VERSION_CODE && SLE_VERSION_CODE >= SLE_VERSION(11,3,0)) */
3511
3512
3513 #ifndef skb_add_rx_frag
3514 #define skb_add_rx_frag _kc_skb_add_rx_frag
3515 extern void _kc_skb_add_rx_frag(struct sk_buff *, int, struct page *,
3516                                 int, int, unsigned int);
3517 #endif
3518 #ifdef NET_ADDR_RANDOM
3519 #define eth_hw_addr_random(N) do { \
3520         random_ether_addr(N->dev_addr); \
3521         N->addr_assign_type |= NET_ADDR_RANDOM; \
3522         } while (0)
3523 #else /* NET_ADDR_RANDOM */
3524 #define eth_hw_addr_random(N) random_ether_addr(N->dev_addr)
3525 #endif /* NET_ADDR_RANDOM */
3526 #else /* < 3.4.0 */
3527 #include <linux/kconfig.h>
3528 #endif /* >= 3.4.0 */
3529
3530 /*****************************************************************************/
3531 #if defined(E1000E_PTP) || defined(IGB_PTP) || defined(IXGBE_PTP) || defined(I40E_PTP)
3532 #if ( LINUX_VERSION_CODE >= KERNEL_VERSION(3,0,0) ) && IS_ENABLED(CONFIG_PTP_1588_CLOCK)
3533 #define HAVE_PTP_1588_CLOCK
3534 #else
3535 #error Cannot enable PTP Hardware Clock support due to a pre-3.0 kernel version or CONFIG_PTP_1588_CLOCK not enabled in the kernel
3536 #endif /* > 3.0.0 && IS_ENABLED(CONFIG_PTP_1588_CLOCK) */
3537 #endif /* E1000E_PTP || IGB_PTP || IXGBE_PTP || I40E_PTP */
3538
3539 /*****************************************************************************/
3540 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0) )
3541 #define skb_tx_timestamp(skb) do {} while (0)
3542 static inline bool __kc_ether_addr_equal(const u8 *addr1, const u8 *addr2)
3543 {
3544         return !compare_ether_addr(addr1, addr2);
3545 }
3546 #define ether_addr_equal(_addr1, _addr2) __kc_ether_addr_equal((_addr1),(_addr2))
3547 #else
3548 #define HAVE_FDB_OPS
3549 #define HAVE_ETHTOOL_GET_TS_INFO
3550 #endif /* < 3.5.0 */
3551
3552 /*****************************************************************************/
3553 #include <linux/mdio.h>
3554 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0) )
3555 #define PCI_EXP_LNKCAP2         44      /* Link Capability 2 */
3556
3557 #ifndef MDIO_EEE_100TX
3558 #define MDIO_EEE_100TX          0x0002  /* 100TX EEE cap */
3559 #endif
3560 #ifndef MDIO_EEE_1000T
3561 #define MDIO_EEE_1000T          0x0004  /* 1000T EEE cap */
3562 #endif
3563 #ifndef MDIO_EEE_10GT
3564 #define MDIO_EEE_10GT           0x0008  /* 10GT EEE cap */
3565 #endif
3566 #ifndef MDIO_EEE_1000KX
3567 #define MDIO_EEE_1000KX         0x0010  /* 1000KX EEE cap */
3568 #endif
3569 #ifndef MDIO_EEE_10GKX4
3570 #define MDIO_EEE_10GKX4         0x0020  /* 10G KX4 EEE cap */
3571 #endif
3572 #ifndef MDIO_EEE_10GKR
3573 #define MDIO_EEE_10GKR          0x0040  /* 10G KR EEE cap */
3574 #endif
3575 #endif /* < 3.6.0 */
3576
3577 /******************************************************************************/
3578 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(3,7,0) )
3579 #ifndef ADVERTISED_40000baseKR4_Full
3580 /* these defines were all added in one commit, so should be safe
3581  * to trigger activiation on one define
3582  */
3583 #define SUPPORTED_40000baseKR4_Full     (1 << 23)
3584 #define SUPPORTED_40000baseCR4_Full     (1 << 24)
3585 #define SUPPORTED_40000baseSR4_Full     (1 << 25)
3586 #define SUPPORTED_40000baseLR4_Full     (1 << 26)
3587 #define ADVERTISED_40000baseKR4_Full    (1 << 23)
3588 #define ADVERTISED_40000baseCR4_Full    (1 << 24)
3589 #define ADVERTISED_40000baseSR4_Full    (1 << 25)
3590 #define ADVERTISED_40000baseLR4_Full    (1 << 26)
3591 #endif
3592
3593 /**
3594  * mmd_eee_cap_to_ethtool_sup_t
3595  * @eee_cap: value of the MMD EEE Capability register
3596  *
3597  * A small helper function that translates MMD EEE Capability (3.20) bits
3598  * to ethtool supported settings.
3599  */
3600 static inline u32 __kc_mmd_eee_cap_to_ethtool_sup_t(u16 eee_cap)
3601 {
3602         u32 supported = 0;
3603
3604         if (eee_cap & MDIO_EEE_100TX)
3605                 supported |= SUPPORTED_100baseT_Full;
3606         if (eee_cap & MDIO_EEE_1000T)
3607                 supported |= SUPPORTED_1000baseT_Full;
3608         if (eee_cap & MDIO_EEE_10GT)
3609                 supported |= SUPPORTED_10000baseT_Full;
3610         if (eee_cap & MDIO_EEE_1000KX)
3611                 supported |= SUPPORTED_1000baseKX_Full;
3612         if (eee_cap & MDIO_EEE_10GKX4)
3613                 supported |= SUPPORTED_10000baseKX4_Full;
3614         if (eee_cap & MDIO_EEE_10GKR)
3615                 supported |= SUPPORTED_10000baseKR_Full;
3616
3617         return supported;
3618 }
3619 #define mmd_eee_cap_to_ethtool_sup_t(eee_cap) \
3620         __kc_mmd_eee_cap_to_ethtool_sup_t(eee_cap)
3621
3622 /**
3623  * mmd_eee_adv_to_ethtool_adv_t
3624  * @eee_adv: value of the MMD EEE Advertisement/Link Partner Ability registers
3625  *
3626  * A small helper function that translates the MMD EEE Advertisement (7.60)
3627  * and MMD EEE Link Partner Ability (7.61) bits to ethtool advertisement
3628  * settings.
3629  */
3630 static inline u32 __kc_mmd_eee_adv_to_ethtool_adv_t(u16 eee_adv)
3631 {
3632         u32 adv = 0;
3633
3634         if (eee_adv & MDIO_EEE_100TX)
3635                 adv |= ADVERTISED_100baseT_Full;
3636         if (eee_adv & MDIO_EEE_1000T)
3637                 adv |= ADVERTISED_1000baseT_Full;
3638         if (eee_adv & MDIO_EEE_10GT)
3639                 adv |= ADVERTISED_10000baseT_Full;
3640         if (eee_adv & MDIO_EEE_1000KX)
3641                 adv |= ADVERTISED_1000baseKX_Full;
3642         if (eee_adv & MDIO_EEE_10GKX4)
3643                 adv |= ADVERTISED_10000baseKX4_Full;
3644         if (eee_adv & MDIO_EEE_10GKR)
3645                 adv |= ADVERTISED_10000baseKR_Full;
3646
3647         return adv;
3648 }
3649 #define mmd_eee_adv_to_ethtool_adv_t(eee_adv) \
3650         __kc_mmd_eee_adv_to_ethtool_adv_t(eee_adv)
3651
3652 /**
3653  * ethtool_adv_to_mmd_eee_adv_t
3654  * @adv: the ethtool advertisement settings
3655  *
3656  * A small helper function that translates ethtool advertisement settings
3657  * to EEE advertisements for the MMD EEE Advertisement (7.60) and
3658  * MMD EEE Link Partner Ability (7.61) registers.
3659  */
3660 static inline u16 __kc_ethtool_adv_to_mmd_eee_adv_t(u32 adv)
3661 {
3662         u16 reg = 0;
3663
3664         if (adv & ADVERTISED_100baseT_Full)
3665                 reg |= MDIO_EEE_100TX;
3666         if (adv & ADVERTISED_1000baseT_Full)
3667                 reg |= MDIO_EEE_1000T;
3668         if (adv & ADVERTISED_10000baseT_Full)
3669                 reg |= MDIO_EEE_10GT;
3670         if (adv & ADVERTISED_1000baseKX_Full)
3671                 reg |= MDIO_EEE_1000KX;
3672         if (adv & ADVERTISED_10000baseKX4_Full)
3673                 reg |= MDIO_EEE_10GKX4;
3674         if (adv & ADVERTISED_10000baseKR_Full)
3675                 reg |= MDIO_EEE_10GKR;
3676
3677         return reg;
3678 }
3679 #define ethtool_adv_to_mmd_eee_adv_t(adv) \
3680         __kc_ethtool_adv_to_mmd_eee_adv_t(adv)
3681
3682 #ifndef pci_pcie_type
3683 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24) )
3684 static inline u8 pci_pcie_type(struct pci_dev *pdev)
3685 {
3686         int pos;
3687         u16 reg16;
3688
3689         pos = pci_find_capability(pdev, PCI_CAP_ID_EXP);
3690         if (!pos)
3691                 BUG();
3692         pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, &reg16);
3693         return (reg16 & PCI_EXP_FLAGS_TYPE) >> 4;
3694 }
3695 #else /* < 2.6.24 */
3696 #define pci_pcie_type(x)        (x)->pcie_type
3697 #endif /* < 2.6.24 */
3698 #endif /* pci_pcie_type */
3699
3700 #define ptp_clock_register(caps, args...) ptp_clock_register(caps)
3701
3702 #ifndef PCI_EXP_LNKSTA2
3703 int __kc_pcie_capability_read_word(struct pci_dev *dev, int pos, u16 *val);
3704 #define pcie_capability_read_word(d,p,v) __kc_pcie_capability_read_word(d,p,v)
3705 int __kc_pcie_capability_write_word(struct pci_dev *dev, int pos, u16 val);
3706 #define pcie_capability_write_word(d,p,v) __kc_pcie_capability_write_word(d,p,v)
3707 int __kc_pcie_capability_clear_and_set_word(struct pci_dev *dev, int pos,
3708                                             u16 clear, u16 set);
3709 #define pcie_capability_clear_and_set_word(d,p,c,s) \
3710         __kc_pcie_capability_clear_and_set_word(d,p,c,s)
3711
3712 #define PCI_EXP_LNKSTA2         50      /* Link Status 2 */
3713
3714 static inline int pcie_capability_clear_word(struct pci_dev *dev, int pos,
3715                                              u16 clear)
3716 {
3717         return __kc_pcie_capability_clear_and_set_word(dev, pos, clear, 0);
3718 }
3719 #endif /* !PCI_EXP_LNKSTA2 */
3720
3721 #if (SLE_VERSION_CODE && SLE_VERSION_CODE >= SLE_VERSION(11,3,0))
3722 #define USE_CONST_DEV_UC_CHAR
3723 #endif
3724
3725 #else /* >= 3.7.0 */
3726 #define HAVE_CONST_STRUCT_PCI_ERROR_HANDLERS
3727 #define USE_CONST_DEV_UC_CHAR
3728 #endif /* >= 3.7.0 */
3729
3730 /*****************************************************************************/
3731 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(3,8,0) )
3732 #ifndef PCI_EXP_LNKCTL_ASPM_L0S
3733 #define  PCI_EXP_LNKCTL_ASPM_L0S  0x01  /* L0s Enable */
3734 #endif
3735 #ifndef PCI_EXP_LNKCTL_ASPM_L1
3736 #define  PCI_EXP_LNKCTL_ASPM_L1   0x02  /* L1 Enable */
3737 #endif
3738 #define HAVE_CONFIG_HOTPLUG
3739 /* Reserved Ethernet Addresses per IEEE 802.1Q */
3740 static const u8 eth_reserved_addr_base[ETH_ALEN] __aligned(2) = {
3741         0x01, 0x80, 0xc2, 0x00, 0x00, 0x00 };
3742 #if !(SLE_VERSION_CODE && SLE_VERSION_CODE >= SLE_VERSION(11,3,0)) &&\
3743     !(RHEL_RELEASE_CODE && RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(6,5))
3744 static inline bool is_link_local_ether_addr(const u8 *addr)
3745 {
3746         __be16 *a = (__be16 *)addr;
3747         static const __be16 *b = (const __be16 *)eth_reserved_addr_base;
3748         static const __be16 m = cpu_to_be16(0xfff0);
3749
3750         return ((a[0] ^ b[0]) | (a[1] ^ b[1]) | ((a[2] ^ b[2]) & m)) == 0;
3751 }
3752 #endif /* !(SLE_VERSION_CODE && SLE_VERSION_CODE >= SLE_VERSION(11,3,0)) */
3753 #else /* >= 3.8.0 */
3754 #ifndef __devinit
3755 #define __devinit
3756 #define HAVE_ENCAP_CSUM_OFFLOAD
3757 #endif
3758
3759 #ifndef __devinitdata
3760 #define __devinitdata
3761 #endif
3762
3763 #ifndef __devexit
3764 #define __devexit
3765 #endif
3766
3767 #ifndef __devexit_p
3768 #define __devexit_p
3769 #endif
3770
3771 #ifndef HAVE_SRIOV_CONFIGURE
3772 #define HAVE_SRIOV_CONFIGURE
3773 #endif
3774
3775 #define HAVE_BRIDGE_ATTRIBS
3776 #ifndef BRIDGE_MODE_VEB
3777 #define BRIDGE_MODE_VEB         0       /* Default loopback mode */
3778 #endif /* BRIDGE_MODE_VEB */
3779 #ifndef BRIDGE_MODE_VEPA
3780 #define BRIDGE_MODE_VEPA        1       /* 802.1Qbg defined VEPA mode */
3781 #endif /* BRIDGE_MODE_VEPA */
3782 #endif /* >= 3.8.0 */
3783
3784 /*****************************************************************************/
3785 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(3,9,0) )
3786
3787 #undef hlist_entry
3788 #define hlist_entry(ptr, type, member) container_of(ptr,type,member)
3789
3790 #undef hlist_entry_safe
3791 #define hlist_entry_safe(ptr, type, member) \
3792         (ptr) ? hlist_entry(ptr, type, member) : NULL
3793
3794 #undef hlist_for_each_entry
3795 #define hlist_for_each_entry(pos, head, member)                             \
3796         for (pos = hlist_entry_safe((head)->first, typeof(*(pos)), member); \
3797              pos;                                                           \
3798              pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member))
3799
3800 #undef hlist_for_each_entry_safe
3801 #define hlist_for_each_entry_safe(pos, n, head, member)             \
3802         for (pos = hlist_entry_safe((head)->first, typeof(*pos), member);   \
3803              pos && ({ n = pos->member.next; 1; });                         \
3804              pos = hlist_entry_safe(n, typeof(*pos), member))
3805
3806 #ifdef CONFIG_XPS
3807 extern int __kc_netif_set_xps_queue(struct net_device *, struct cpumask *, u16);
3808 #define netif_set_xps_queue(_dev, _mask, _idx) __kc_netif_set_xps_queue((_dev), (_mask), (_idx))
3809 #else /* CONFIG_XPS */
3810 #define netif_set_xps_queue(_dev, _mask, _idx) do {} while (0)
3811 #endif /* CONFIG_XPS */
3812
3813 #ifdef HAVE_NETDEV_SELECT_QUEUE
3814 #define _kc_hashrnd 0xd631614b /* not so random hash salt */
3815 extern u16 __kc_netdev_pick_tx(struct net_device *dev, struct sk_buff *skb);
3816 #define __netdev_pick_tx __kc_netdev_pick_tx
3817 #endif /* HAVE_NETDEV_SELECT_QUEUE */
3818 #else
3819 #define HAVE_BRIDGE_FILTER
3820 #define USE_DEFAULT_FDB_DEL_DUMP
3821 #endif /* < 3.9.0 */
3822
3823 /*****************************************************************************/
3824 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0) )
3825 #ifdef CONFIG_PCI_IOV
3826 extern int __kc_pci_vfs_assigned(struct pci_dev *dev);
3827 #else
3828 static inline int __kc_pci_vfs_assigned(struct pci_dev *dev)
3829 {
3830         return 0;
3831 }
3832 #endif
3833 #define pci_vfs_assigned(dev) __kc_pci_vfs_assigned(dev)
3834
3835 #ifndef VLAN_TX_COOKIE_MAGIC
3836 static inline struct sk_buff *__kc__vlan_hwaccel_put_tag(struct sk_buff *skb,
3837                                                          u16 vlan_tci)
3838 {
3839 #ifdef VLAN_TAG_PRESENT
3840         vlan_tci |= VLAN_TAG_PRESENT;
3841 #endif
3842         skb->vlan_tci = vlan_tci;
3843         return skb;
3844 }
3845 #define __vlan_hwaccel_put_tag(skb, vlan_proto, vlan_tci) \
3846         __kc__vlan_hwaccel_put_tag(skb, vlan_tci)
3847 #endif
3848
3849 #else /* >= 3.10.0 */
3850 #define HAVE_ENCAP_TSO_OFFLOAD
3851 #endif /* >= 3.10.0 */
3852
3853 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(3,14,0) )
3854 #if (!(RHEL_RELEASE_CODE && RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(6,6)))
3855 #if (!(UBUNTU_KERNEL_CODE >= UBUNTU_KERNEL_VERSION(3,13,0,30,0) \
3856     && (UBUNTU_RELEASE_CODE == UBUNTU_RELEASE_VERSION(12,4) \
3857      || UBUNTU_RELEASE_CODE == UBUNTU_RELEASE_VERSION(14,4))))
3858 #if (!(SLE_VERSION_CODE == SLE_VERSION(12,0,0)))
3859 #ifdef NETIF_F_RXHASH
3860 #define PKT_HASH_TYPE_L3 0
3861 static inline void
3862 skb_set_hash(struct sk_buff *skb, __u32 hash, __always_unused int type)
3863 {
3864         skb->rxhash = hash;
3865 }
3866 #endif /* NETIF_F_RXHASH */
3867 #endif /* < SLES12 */
3868 #endif /* < 3.13.0-30.54 (Ubuntu 14.04) */
3869 #endif /* < RHEL7 */
3870 #endif /* < 3.14.0 */
3871
3872 #if (( LINUX_VERSION_CODE >= KERNEL_VERSION(3,16,0) ) \
3873     || ( RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(7,2) ))
3874 #undef SET_ETHTOOL_OPS
3875 #define SET_ETHTOOL_OPS(netdev, ops) ((netdev)->ethtool_ops = (ops))
3876 #define HAVE_VF_MIN_MAX_TXRATE 1
3877 #endif /* >= 3.16.0 */
3878
3879 #if (( LINUX_VERSION_CODE >= KERNEL_VERSION(3,19,0) ) \
3880     || ( RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(7,2) ))
3881 #define HAVE_NDO_DFLT_BRIDGE_ADD_MASK
3882 #if ( RHEL_RELEASE_CODE != RHEL_RELEASE_VERSION(7,2) )
3883 #define HAVE_NDO_FDB_ADD_VID
3884 #endif /* !RHEL 7.2 */
3885 #endif /* >= 3.19.0 */
3886
3887 #if (( LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0) ) \
3888     || ( RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(7,2) ))
3889 /* vlan_tx_xx functions got renamed to skb_vlan */
3890 #define vlan_tx_tag_get skb_vlan_tag_get
3891 #define vlan_tx_tag_present skb_vlan_tag_present
3892 #if ( RHEL_RELEASE_CODE != RHEL_RELEASE_VERSION(7,2) )
3893 #define HAVE_NDO_BRIDGE_SET_DEL_LINK_FLAGS
3894 #endif /* !RHEL 7.2 */
3895 #endif /* 4.0.0 */
3896
3897 #if (( LINUX_VERSION_CODE >= KERNEL_VERSION(4,1,0) ) \
3898     || ( RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(7,3) ))
3899 /* ndo_bridge_getlink adds new nlflags parameter */
3900 #define HAVE_NDO_BRIDGE_GETLINK_NLFLAGS
3901 #endif /* >= 4.1.0 */
3902
3903 #if ( LINUX_VERSION_CODE >= KERNEL_VERSION(4,2,0) )
3904 /* ndo_bridge_getlink adds new filter_mask and vlan_fill parameters */
3905 #define HAVE_NDO_BRIDGE_GETLINK_FILTER_MASK_VLAN_FILL
3906 #endif /* >= 4.2.0 */
3907
3908 /*
3909  * vlan_tx_tag_* macros renamed to skb_vlan_tag_* (Linux commit: df8a39defad4)
3910  * For older kernels backported this commit, need to use renamed functions.
3911  * This fix is specific to RedHat/CentOS kernels.
3912  */
3913 #if (defined(RHEL_RELEASE_CODE) && \
3914         (RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(6, 8)) && \
3915         (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 34)))
3916 #define vlan_tx_tag_get skb_vlan_tag_get
3917 #define vlan_tx_tag_present skb_vlan_tag_present
3918 #endif
3919
3920 #if ((LINUX_VERSION_CODE >= KERNEL_VERSION(4, 9, 0)) || \
3921     (SLE_VERSION_CODE && SLE_VERSION_CODE >= SLE_VERSION(12, 3, 0)))
3922 #define HAVE_VF_VLAN_PROTO
3923 #endif /* >= 4.9.0, >= SLES12SP3 */
3924
3925 #if LINUX_VERSION_CODE < KERNEL_VERSION(4, 8, 0)
3926 #define HAVE_PCI_ENABLE_MSIX
3927 #endif
3928
3929 #if defined(timer_setup) && defined(from_timer)
3930 #define HAVE_TIMER_SETUP
3931 #endif
3932
3933 #endif /* _KCOMPAT_H_ */