config/rdma.m4

   1 dnl Checks for the in-box ib_core
   2 AC_DEFUN([RDMA_CONFIG_COMPAT],
   3 [
   4         AC_MSG_CHECKING([if ib_verbs has ib_dma_map_single])
   5         LB_LINUX_TRY_COMPILE([
   6                 #include <linux/version.h>
   7                 #include <linux/pci.h>
   8                 #include <linux/gfp.h>
   9                 #include <rdma/ib_verbs.h>
  10         ],[
  11                 ib_dma_map_single(NULL, NULL, 0, 0);
  12                 return 0;
  13         ],[
  14                 AC_MSG_RESULT(yes)
  15                 AC_DEFINE(HAVE_INBOX_IB_DMA_MAP, 1,
  16                           [ib_dma_map_single defined])
  17         ],[
  18                 AC_MSG_RESULT(no)
  19         ])
  20
  21         AC_MSG_CHECKING([if ib_create_cq wants comp_vector])
  22         LB_LINUX_TRY_COMPILE([
  23                 #include <linux/version.h>
  24                 #include <linux/pci.h>
  25                 #include <linux/gfp.h>
  26                 #include <rdma/ib_verbs.h>
  27         ],[
  28                 ib_create_cq(NULL, NULL, NULL, NULL, 0, 0);
  29                 return 0;
  30         ],[
  31                 AC_MSG_RESULT(yes)
  32                 AC_DEFINE(HAVE_INBOX_IB_COMP_VECTOR, 1,
  33                           [has completion vector])
  34         ],[
  35                 AC_MSG_RESULT(no)
  36         ])
  37
  38         AC_MSG_CHECKING([if rdma_cm has RDMA_CM_EVENT_ADDR_CHANGE])
  39         LB_LINUX_TRY_COMPILE([
  40                 #include <linux/version.h>
  41                 #include <linux/pci.h>
  42                 #include <linux/gfp.h>
  43                 #include <rdma/rdma_cm.h>
  44         ],[
  45                 return (RDMA_CM_EVENT_ADDR_CHANGE == 0);
  46         ],[
  47                 AC_MSG_RESULT(yes)
  48                 AC_DEFINE(HAVE_INBOX_RDMA_CMEV_ADDRCHANGE, 1,
  49                           [has completion vector])
  50         ],[
  51                 AC_MSG_RESULT(no)
  52         ])
  53
  54         AC_MSG_CHECKING([if rdma_cm has RDMA_CM_EVENT_TIMEWAIT_EXIT])
  55         LB_LINUX_TRY_COMPILE([
  56                 #include <linux/version.h>
  57                 #include <linux/pci.h>
  58                 #include <linux/gfp.h>
  59                 #include <rdma/rdma_cm.h>
  60         ],[
  61                 return (RDMA_CM_EVENT_TIMEWAIT_EXIT == 0);
  62         ],[
  63                 AC_MSG_RESULT(yes)
  64                 AC_DEFINE(HAVE_INBOX_RDMA_CMEV_TIMEWAIT_EXIT, 1,
  65                           [has completion vector])
  66         ],[
  67                 AC_MSG_RESULT(no)
  68         ])
  69
  70         AC_MSG_CHECKING([if rdma_cm has rdma_set_reuseaddr])
  71         LB_LINUX_TRY_COMPILE([
  72                 #include <linux/version.h>
  73                 #include <linux/pci.h>
  74                 #include <linux/gfp.h>
  75                 #include <rdma/rdma_cm.h>
  76         ],[
  77                 rdma_set_reuseaddr(NULL, 1);
  78                 return 0;
  79         ],[
  80                 AC_MSG_RESULT(yes)
  81                 AC_DEFINE(HAVE_INBOX_RDMA_SET_REUSEADDR, 1,
  82                           [rdma_set_reuse defined])
  83         ],[
  84                 AC_MSG_RESULT(no)
  85         ])
  86
  87         AC_MSG_CHECKING([if struct ib_wc has member named ts])
  88         LB_LINUX_TRY_COMPILE([
  89                 #include <linux/version.h>
  90                 #include <rdma/ib_verbs.h>
  91         ],[
  92         struct ib_wc wc;
  93         wc->ts.timestamp = 0;
  94
  95                 return 0;
  96         ],[
  97                 AC_MSG_RESULT(yes)
  98                 AC_DEFINE(HAVE_INBOX_IB_WC_TS, 1,
  99                           [ib_wc has member named ts])
 100         ],[
 101                 AC_MSG_RESULT(no)
 102         ])
 103
 104         AC_MSG_CHECKING([if struct ib_ah_attr has member named dmac])
 105         LB_LINUX_TRY_COMPILE([
 106                 #include <linux/version.h>
 107                 #include <rdma/ib_verbs.h>
 108         ],[
 109         struct ib_ah_attr *ah_attr;
 110         memset(ah_attr->dmac, 0, 6);
 111
 112                 return 0;
 113         ],[
 114                 AC_MSG_RESULT(yes)
 115                 AC_DEFINE(HAVE_INBOX_IB_AH_ATTR_DMAC, 1,
 116                           [ah_attr has member named dmac])
 117         ],[
 118                 AC_MSG_RESULT(no)
 119         ])
 120
 121         AC_MSG_CHECKING([if struct ib_ah_attr has member named vlan_id])
 122         LB_LINUX_TRY_COMPILE([
 123                 #include <linux/version.h>
 124                 #include <rdma/ib_verbs.h>
 125         ],[
 126         struct ib_ah_attr *ah_attr;
 127         ah_attr->vlan_id = 0;
 128
 129                 return 0;
 130         ],[
 131                 AC_MSG_RESULT(yes)
 132                 AC_DEFINE(HAVE_INBOX_IB_AH_ATTR_VLAN_ID, 1,
 133                           [ah_attr has member named vlan_id])
 134         ],[
 135                 AC_MSG_RESULT(no)
 136         ])
 137 ])
 138
 139 dnl Examine kernel functionality
 140 AC_DEFUN([LINUX_CONFIG_COMPAT],
 141 [
 142         AC_MSG_CHECKING([if kernel has ktime_get_ns])
 143         LB_LINUX_TRY_COMPILE([
 144                 #include <linux/ktime.h>
 145         ],[
 146                 unsigned long long ns;
 147
 148                 ns = ktime_get_ns();
 149                 return 0;
 150         ],[
 151                 AC_MSG_RESULT(yes)
 152                 AC_DEFINE(HAVE_KTIME_GET_NS, 1,
 153                           [ktime_get_ns defined])
 154         ],[
 155                 AC_MSG_RESULT(no)
 156         ])
 157
 158         AC_MSG_CHECKING([if svc_xprt_class has xcl_ident])
 159         LB_LINUX_TRY_COMPILE([
 160                 #include <linux/sunrpc/xprt.h>
 161                 #include <linux/sunrpc/svc_xprt.h>
 162         ],[
 163                 struct svc_xprt_class svc_rdma_class = {
 164                         .xcl_ident = XPRT_TRANSPORT_RDMA,
 165                 };
 166                 return 0;
 167         ],[
 168                 AC_MSG_RESULT(yes)
 169                 AC_DEFINE(HAVE_XCL_IDENT, 1,
 170                           [xcl_ident defined])
 171         ],[
 172                 AC_MSG_RESULT(no)
 173         ])
 174
 175         AC_MSG_CHECKING([if struct ifla_vf_info has max_tx_rate])
 176         LB_LINUX_TRY_COMPILE([
 177                 #include <linux/if_link.h>
 178         ],[
 179                 struct ifla_vf_info *ivf;
 180
 181                 ivf->max_tx_rate = 0;
 182                 ivf->min_tx_rate = 0;
 183
 184                 return 0;
 185         ],[
 186                 AC_MSG_RESULT(yes)
 187                 AC_DEFINE(HAVE_TX_RATE_LIMIT, 1,
 188                           [max_tx_rate is defined])
 189         ],[
 190                 AC_MSG_RESULT(no)
 191         ])
 192
 193         AC_MSG_CHECKING([if struct ethtool_ops has get/set_rxfh])
 194         LB_LINUX_TRY_COMPILE([
 195                 #include <linux/ethtool.h>
 196         ],[
 197                 const struct ethtool_ops en_ethtool_ops = {
 198                         .get_rxfh_indir_size = NULL,
 199                         .get_rxfh = NULL,
 200                         .set_rxfh = NULL,
 201                 };
 202
 203                 return 0;
 204         ],[
 205                 AC_MSG_RESULT(yes)
 206                 AC_DEFINE(HAVE_GET_SET_RXFH, 1,
 207                           [get/set_rxfh is defined])
 208         ],[
 209                 AC_MSG_RESULT(no)
 210         ])
 211
 212
 213         AC_MSG_CHECKING([if struct ethtool_ops has get/set_tunable])
 214         LB_LINUX_TRY_COMPILE([
 215                 #include <linux/ethtool.h>
 216         ],[
 217                 const struct ethtool_ops en_ethtool_ops = {
 218                         .get_tunable = NULL,
 219                         .set_tunable = NULL,
 220                 };
 221
 222                 return 0;
 223         ],[
 224                 AC_MSG_RESULT(yes)
 225                 AC_DEFINE(HAVE_GET_SET_TUNABLE, 1,
 226                           [get/set_tunable is defined])
 227         ],[
 228                 AC_MSG_RESULT(no)
 229         ])
 230
 231         AC_MSG_CHECKING([if exist struct ethtool_ops_ext])
 232         LB_LINUX_TRY_COMPILE([
 233                 #include <linux/ethtool.h>
 234         ],[
 235                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
 236                         .size = sizeof(struct ethtool_ops_ext),
 237                 };
 238
 239                 return 0;
 240         ],[
 241                 AC_MSG_RESULT(yes)
 242                 AC_DEFINE(HAVE_ETHTOOL_OPS_EXT, 1,
 243                           [struct ethtool_ops_ext is defined])
 244         ],[
 245                 AC_MSG_RESULT(no)
 246         ])
 247
 248         AC_MSG_CHECKING([if struct ethtool_ops_ext has get/set_rxfh])
 249         LB_LINUX_TRY_COMPILE([
 250                 #include <linux/ethtool.h>
 251         ],[
 252                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
 253                         .get_rxfh_indir_size = NULL,
 254                         .get_rxfh = NULL,
 255                         .set_rxfh = NULL,
 256                 };
 257
 258                 return 0;
 259         ],[
 260                 AC_MSG_RESULT(yes)
 261                 AC_DEFINE(HAVE_GET_SET_RXFH_OPS_EXT, 1,
 262                           [get/set_rxfh is defined])
 263         ],[
 264                 AC_MSG_RESULT(no)
 265         ])
 266
 267         AC_MSG_CHECKING([if struct ethtool_ops_ext has get/set_rxfh_indir])
 268         LB_LINUX_TRY_COMPILE([
 269                 #include <linux/ethtool.h>
 270         ],[
 271                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
 272                         .get_rxfh_indir_size = NULL,
 273                         .get_rxfh_indir = NULL,
 274                         .set_rxfh_indir = NULL,
 275                 };
 276
 277                 return 0;
 278         ],[
 279                 AC_MSG_RESULT(yes)
 280                 AC_DEFINE(HAVE_GET_SET_RXFH_INDIR, 1,
 281                           [get/set_rxfh_indir is defined])
 282         ],[
 283                 AC_MSG_RESULT(no)
 284         ])
 285
 286         AC_MSG_CHECKING([if struct net_device has dev_port])
 287         LB_LINUX_TRY_COMPILE([
 288                 #include <linux/netdevice.h>
 289         ],[
 290                 struct net_device *dev = NULL;
 291
 292                 dev->dev_port = 0;
 293
 294                 return 0;
 295         ],[
 296                 AC_MSG_RESULT(yes)
 297                 AC_DEFINE(HAVE_NET_DEVICE_DEV_PORT, 1,
 298                           [dev_port is defined])
 299         ],[
 300                 AC_MSG_RESULT(no)
 301         ])
 302
 303         AC_MSG_CHECKING([if struct ptp_clock_info has n_pins])
 304         LB_LINUX_TRY_COMPILE([
 305                 #include <linux/ptp_clock_kernel.h>
 306         ],[
 307                 struct ptp_clock_info *info;
 308                 info->n_pins = 0;
 309
 310                 return 0;
 311         ],[
 312                 AC_MSG_RESULT(yes)
 313                 AC_DEFINE(HAVE_PTP_CLOCK_INFO_N_PINS, 1,
 314                           [n_pins is defined])
 315         ],[
 316                 AC_MSG_RESULT(no)
 317         ])
 318
 319         AC_MSG_CHECKING([if pci.h pci_enable_msi_exact])
 320         LB_LINUX_TRY_COMPILE([
 321                 #include <linux/pci.h>
 322         ],[
 323                 int x = pci_enable_msi_exact(NULL, 0);
 324
 325                 return 0;
 326         ],[
 327                 AC_MSG_RESULT(yes)
 328                 AC_DEFINE(HAVE_PCI_ENABLE_MSI_EXACT, 1,
 329                           [pci_enable_msi_exact is defined])
 330         ],[
 331                 AC_MSG_RESULT(no)
 332         ])
 333
 334         AC_MSG_CHECKING([if pci.h pci_enable_msix_range])
 335         LB_LINUX_TRY_COMPILE([
 336                 #include <linux/pci.h>
 337         ],[
 338                 int x = pci_enable_msix_range(NULL, 0, 0, 0);
 339
 340                 return 0;
 341         ],[
 342                 AC_MSG_RESULT(yes)
 343                 AC_DEFINE(HAVE_PCI_ENABLE_MSIX_RANGE, 1,
 344                           [pci_enable_msix_range is defined])
 345         ],[
 346                 AC_MSG_RESULT(no)
 347         ])
 348
 349         AC_MSG_CHECKING([if struct iscsi_transport has check_protection])
 350         LB_LINUX_TRY_COMPILE([
 351                 #include <scsi/scsi_transport_iscsi.h>
 352         ],[
 353                 static struct iscsi_transport iscsi_iser_transport = {
 354                         .check_protection = NULL,
 355                 };
 356
 357                 return 0;
 358         ],[
 359                 AC_MSG_RESULT(yes)
 360                 AC_DEFINE(HAVE_ISCSI_CHECK_PROTECTION, 1,
 361                           [check_protection is defined])
 362         ],[
 363                 AC_MSG_RESULT(no)
 364         ])
 365
 366         AC_MSG_CHECKING([if netdevice.h has select_queue_fallback_t])
 367         LB_LINUX_TRY_COMPILE([
 368                 #include <linux/netdevice.h>
 369         ],[
 370                 select_queue_fallback_t fallback;
 371
 372                 fallback = NULL;
 373
 374                 return 0;
 375         ],[
 376                 AC_MSG_RESULT(yes)
 377                 AC_DEFINE(HAVE_SELECT_QUEUE_FALLBACK_T, 1,
 378                           [select_queue_fallback_t is defined])
 379         ],[
 380                 AC_MSG_RESULT(no)
 381         ])
 382
 383         AC_MSG_CHECKING([if skbuff.h has skb_set_hash])
 384         LB_LINUX_TRY_COMPILE([
 385                 #include <linux/netdevice.h>
 386         ],[
 387                 skb_set_hash(NULL, 0, PKT_HASH_TYPE_L3);
 388
 389                 return 0;
 390         ],[
 391                 AC_MSG_RESULT(yes)
 392                 AC_DEFINE(HAVE_SKB_SET_HASH, 1,
 393                           [skb_set_hash is defined])
 394         ],[
 395                 AC_MSG_RESULT(no)
 396         ])
 397
 398         AC_MSG_CHECKING([if sockios.h has SIOCGHWTSTAMP])
 399         LB_LINUX_TRY_COMPILE([
 400                 #include <linux/sockios.h>
 401         ],[
 402                 int x = SIOCGHWTSTAMP;
 403
 404                 return 0;
 405         ],[
 406                 AC_MSG_RESULT(yes)
 407                 AC_DEFINE(HAVE_SIOCGHWTSTAMP, 1,
 408                           [SIOCGHWTSTAMP is defined])
 409         ],[
 410                 AC_MSG_RESULT(no)
 411         ])
 412
 413         AC_MSG_CHECKING([if ip.h inet_get_local_port_range has 3 parameters])
 414         LB_LINUX_TRY_COMPILE([
 415                 #include <net/ip.h>
 416         ],[
 417                 inet_get_local_port_range(NULL, NULL, NULL);
 418
 419                 return 0;
 420         ],[
 421                 AC_MSG_RESULT(yes)
 422                 AC_DEFINE(HAVE_INET_GET_LOCAL_PORT_RANGE_3_PARAMS, 1,
 423                           [inet_get_local_port_range has 3 parameters])
 424         ],[
 425                 AC_MSG_RESULT(no)
 426         ])
 427
 428         AC_MSG_CHECKING([if net.h has net_get_random_once])
 429         LB_LINUX_TRY_COMPILE([
 430                 #include <linux/net.h>
 431         ],[
 432                 net_get_random_once(NULL, 0);
 433
 434                 return 0;
 435         ],[
 436                 AC_MSG_RESULT(yes)
 437                 AC_DEFINE(HAVE_NET_GET_RANDOM_ONCE, 1,
 438                           [net_get_random_once is defined])
 439         ],[
 440                 AC_MSG_RESULT(no)
 441         ])
 442
 443         AC_MSG_CHECKING([if inet_sock.h has __inet_ehashfn])
 444         LB_LINUX_TRY_COMPILE([
 445                 #include <net/inet_sock.h>
 446         ],[
 447                 __inet_ehashfn(0, 0, 0, 0, 0);
 448
 449                 return 0;
 450         ],[
 451                 AC_MSG_RESULT(yes)
 452                 AC_DEFINE(HAVE_INET_EHASHFN, 1,
 453                           [__inet_ehashfn is defined])
 454         ],[
 455                 AC_MSG_RESULT(no)
 456         ])
 457
 458         AC_MSG_CHECKING([if err.h has PTR_ERR_OR_ZERO])
 459         LB_LINUX_TRY_COMPILE([
 460                 #include <linux/err.h>
 461         ],[
 462                 int x = PTR_ERR_OR_ZERO(NULL);
 463
 464                 return 0;
 465         ],[
 466                 AC_MSG_RESULT(yes)
 467                 AC_DEFINE(HAVE_PTR_ERR_OR_ZERO, 1,
 468                           [PTR_ERR_OR_ZERO is defined])
 469         ],[
 470                 AC_MSG_RESULT(no)
 471         ])
 472
 473         AC_MSG_CHECKING([if struct iscsi_session has discovery_sess])
 474         LB_LINUX_TRY_COMPILE([
 475                 #include <scsi/libiscsi.h>
 476         ],[
 477                 struct iscsi_session session;
 478                 session.discovery_sess = 0;
 479
 480                 return 0;
 481         ],[
 482                 AC_MSG_RESULT(yes)
 483                 AC_DEFINE(HAVE_ISCSI_DISCOVERY_SESS, 1,
 484                           [discovery_sess is defined])
 485         ],[
 486                 AC_MSG_RESULT(no)
 487         ])
 488
 489         AC_MSG_CHECKING([if enum iscsi_param has ISCSI_PARAM_DISCOVERY_SESS])
 490         LB_LINUX_TRY_COMPILE([
 491                 #include <scsi/iscsi_if.h>
 492         ],[
 493                 int x = ISCSI_PARAM_DISCOVERY_SESS;
 494
 495                 return 0;
 496         ],[
 497                 AC_MSG_RESULT(yes)
 498                 AC_DEFINE(HAVE_ISCSI_PARAM_DISCOVERY_SESS, 1,
 499                           [ISCSI_PARAM_DISCOVERY_SESS is defined])
 500         ],[
 501                 AC_MSG_RESULT(no)
 502         ])
 503
 504         AC_MSG_CHECKING([if pci.h has enum pcie_link_width])
 505         LB_LINUX_TRY_COMPILE([
 506                 #include <linux/pci.h>
 507         ],[
 508                 enum pcie_link_width width = PCIE_LNK_WIDTH_UNKNOWN;
 509
 510                 return 0;
 511         ],[
 512                 AC_MSG_RESULT(yes)
 513                 AC_DEFINE(HAVE_PCIE_LINK_WIDTH, 1,
 514                           [pcie_link_width is defined])
 515         ],[
 516                 AC_MSG_RESULT(no)
 517         ])
 518
 519         AC_MSG_CHECKING([if pci.h has enum pci_bus_speed])
 520         LB_LINUX_TRY_COMPILE([
 521                 #include <linux/pci.h>
 522         ],[
 523                 enum pci_bus_speed speed = PCI_SPEED_UNKNOWN;
 524
 525                 return 0;
 526         ],[
 527                 AC_MSG_RESULT(yes)
 528                 AC_DEFINE(HAVE_PCI_BUS_SPEED, 1,
 529                           [pci_bus_speed is defined])
 530         ],[
 531                 AC_MSG_RESULT(no)
 532         ])
 533
 534         AC_MSG_CHECKING([if netdevice.h has struct netdev_phys_port_id])
 535         LB_LINUX_TRY_COMPILE([
 536                 #include <linux/netdevice.h>
 537         ],[
 538                 struct netdev_phys_port_id *x = NULL;
 539
 540                 return 0;
 541         ],[
 542                 AC_MSG_RESULT(yes)
 543                 AC_DEFINE(HAVE_NETDEV_PHYS_PORT_ID, 1,
 544                           [netdev_phys_port_id is defined])
 545         ],[
 546                 AC_MSG_RESULT(no)
 547         ])
 548
 549         AC_MSG_CHECKING([if struct ifla_vf_info has linkstate])
 550         LB_LINUX_TRY_COMPILE([
 551                 #include <linux/if_link.h>
 552         ],[
 553                 struct struct ifla_vf_info x;
 554                 x->linkstate = 0;
 555
 556                 return 0;
 557         ],[
 558                 AC_MSG_RESULT(yes)
 559                 AC_DEFINE(HAVE_LINKSTATE, 1,
 560                           [linkstate is defined])
 561         ],[
 562                 AC_MSG_RESULT(no)
 563         ])
 564
 565         AC_MSG_CHECKING([if busy_poll.h has skb_mark_napi_id])
 566         LB_LINUX_TRY_COMPILE([
 567                 #include <net/busy_poll.h>
 568         ],[
 569                 skb_mark_napi_id(NULL, NULL);
 570
 571                 return 0;
 572         ],[
 573                 AC_MSG_RESULT(yes)
 574                 AC_DEFINE(HAVE_SKB_MARK_NAPI_ID, 1,
 575                           [skb_mark_napi_id is defined])
 576         ],[
 577                 AC_MSG_RESULT(no)
 578         ])
 579
 580         AC_MSG_CHECKING([if netdevice.h has napi_hash_add])
 581         LB_LINUX_TRY_COMPILE([
 582                 #include <linux/netdevice.h>
 583         ],[
 584                 napi_hash_add(NULL);
 585
 586                 return 0;
 587         ],[
 588                 AC_MSG_RESULT(yes)
 589                 AC_DEFINE(HAVE_NAPI_HASH_ADD, 1,
 590                           [napi_hash_add is defined])
 591         ],[
 592                 AC_MSG_RESULT(no)
 593         ])
 594
 595         AC_MSG_CHECKING([if netdevice.h has netif_keep_dst])
 596         LB_LINUX_TRY_COMPILE([
 597                 #include <linux/netdevice.h>
 598         ],[
 599                 netif_keep_dst(NULL);
 600
 601                 return 0;
 602         ],[
 603                 AC_MSG_RESULT(yes)
 604                 AC_DEFINE(HAVE_NETIF_KEEP_DST, 1,
 605                           [netif_keep_dst is defined])
 606         ],[
 607                 AC_MSG_RESULT(no)
 608         ])
 609
 610         AC_MSG_CHECKING([if mm.h has kvfree])
 611         LB_LINUX_TRY_COMPILE([
 612                 #include <linux/mm.h>
 613         ],[
 614                 kvfree(NULL);
 615
 616                 return 0;
 617         ],[
 618                 AC_MSG_RESULT(yes)
 619                 AC_DEFINE(HAVE_KVFREE, 1,
 620                           [kvfree is defined])
 621         ],[
 622                 AC_MSG_RESULT(no)
 623         ])
 624
 625         AC_MSG_CHECKING([if netdevice.h has dev_consume_skb_any])
 626         LB_LINUX_TRY_COMPILE([
 627                 #include <linux/netdevice.h>
 628         ],[
 629                 dev_consume_skb_any(NULL);
 630
 631                 return 0;
 632         ],[
 633                 AC_MSG_RESULT(yes)
 634                 AC_DEFINE(HAVE_DEV_CONSUME_SKB_ANY, 1,
 635                           [dev_consume_skb_any is defined])
 636         ],[
 637                 AC_MSG_RESULT(no)
 638         ])
 639
 640         AC_MSG_CHECKING([if netdevice.h has netdev_txq_bql_complete_prefetchw])
 641         LB_LINUX_TRY_COMPILE([
 642                 #include <linux/netdevice.h>
 643         ],[
 644                 netdev_txq_bql_complete_prefetchw(NULL);
 645                 netdev_txq_bql_enqueue_prefetchw(NULL);
 646
 647                 return 0;
 648         ],[
 649                 AC_MSG_RESULT(yes)
 650                 AC_DEFINE(HAVE_NETDEV_TXQ_BQL_PREFETCHW, 1,
 651                           [netdev_txq_bql_complete_prefetchw is defined])
 652         ],[
 653                 AC_MSG_RESULT(no)
 654         ])
 655
 656         AC_MSG_CHECKING([if struct sk_buff has xmit_more])
 657         LB_LINUX_TRY_COMPILE([
 658                 #include <linux/skbuff.h>
 659         ],[
 660                 struct sk_buff *skb;
 661                 skb->xmit_more = 0;
 662
 663                 return 0;
 664         ],[
 665                 AC_MSG_RESULT(yes)
 666                 AC_DEFINE(HAVE_SK_BUFF_XMIT_MORE, 1,
 667                           [xmit_more is defined])
 668         ],[
 669                 AC_MSG_RESULT(no)
 670         ])
 671
 672         AC_MSG_CHECKING([if struct sk_buff has encapsulation])
 673         LB_LINUX_TRY_COMPILE([
 674                 #include <linux/skbuff.h>
 675         ],[
 676                 struct sk_buff *skb;
 677                 skb->encapsulation = 0;
 678
 679                 return 0;
 680         ],[
 681                 AC_MSG_RESULT(yes)
 682                 AC_DEFINE(HAVE_SK_BUFF_ENCAPSULATION, 1,
 683                           [encapsulation is defined])
 684         ],[
 685                 AC_MSG_RESULT(no)
 686         ])
 687
 688         AC_MSG_CHECKING([if etherdevice.h has eth_get_headlen])
 689         LB_LINUX_TRY_COMPILE([
 690                 #include <linux/etherdevice.h>
 691         ],[
 692                 eth_get_headlen(NULL, 0);
 693
 694                 return 0;
 695         ],[
 696                 AC_MSG_RESULT(yes)
 697                 AC_DEFINE(HAVE_ETH_GET_HEADLEN, 1,
 698                           [eth_get_headlen is defined])
 699         ],[
 700                 AC_MSG_RESULT(no)
 701         ])
 702
 703         AC_MSG_CHECKING([if struct sk_buff has csum_level])
 704         LB_LINUX_TRY_COMPILE([
 705                 #include <linux/skbuff.h>
 706         ],[
 707                 struct sk_buff *skb;
 708                 skb->csum_level = 0;
 709
 710                 return 0;
 711         ],[
 712                 AC_MSG_RESULT(yes)
 713                 AC_DEFINE(HAVE_SK_BUFF_CSUM_LEVEL, 1,
 714                           [csum_level is defined])
 715         ],[
 716                 AC_MSG_RESULT(no)
 717         ])
 718
 719         AC_MSG_CHECKING([if struct skbuff.h has skb_inner_transport_header])
 720         LB_LINUX_TRY_COMPILE([
 721                 #include <linux/skbuff.h>
 722         ],[
 723                 skb_inner_transport_header(NULL);
 724
 725                 return 0;
 726         ],[
 727                 AC_MSG_RESULT(yes)
 728                 AC_DEFINE(HAVE_SKB_INNER_TRANSPORT_HEADER, 1,
 729                           [skb_inner_transport_header is defined])
 730         ],[
 731                 AC_MSG_RESULT(no)
 732         ])
 733
 734         AC_MSG_CHECKING([if struct skbuff.h has skb_inner_network_header])
 735         LB_LINUX_TRY_COMPILE([
 736                 #include <linux/skbuff.h>
 737         ],[
 738                 skb_inner_network_header(NULL);
 739
 740                 return 0;
 741         ],[
 742                 AC_MSG_RESULT(yes)
 743                 AC_DEFINE(HAVE_SKB_INNER_NETWORK_HEADER, 1,
 744                           [skb_inner_network_header is defined])
 745         ],[
 746                 AC_MSG_RESULT(no)
 747         ])
 748
 749         AC_MSG_CHECKING([if if_vlan.h has vlan_dev_get_egress_qos_mask])
 750         LB_LINUX_TRY_COMPILE([
 751                 #include <linux/if_vlan.h>
 752         ],[
 753                 vlan_dev_get_egress_qos_mask(NULL, 0);
 754
 755                 return 0;
 756         ],[
 757                 AC_MSG_RESULT(yes)
 758                 AC_DEFINE(HAVE_VLAN_DEV_GET_EGRESS_QOS_MASK, 1,
 759                           [vlan_dev_get_egress_qos_mask is defined])
 760         ],[
 761                 AC_MSG_RESULT(no)
 762         ])
 763
 764         AC_MSG_CHECKING([if netdevice.h has netdev_get_prio_tc_map])
 765         LB_LINUX_TRY_COMPILE([
 766                 #include <linux/netdevice.h>
 767         ],[
 768                 netdev_get_prio_tc_map(NULL, 0);
 769
 770                 return 0;
 771         ],[
 772                 AC_MSG_RESULT(yes)
 773                 AC_DEFINE(HAVE_NETDEV_GET_PRIO_TC_MAP, 1,
 774                           [netdev_get_prio_tc_map is defined])
 775         ],[
 776                 AC_MSG_RESULT(no)
 777         ])
 778
 779         AC_MSG_CHECKING([if if_vlan.h has __vlan_find_dev_deep_rcu])
 780         LB_LINUX_TRY_COMPILE([
 781                 #include <linux/if_vlan.h>
 782         ],[
 783                 __vlan_find_dev_deep_rcu(NULL, 0, 0);
 784
 785                 return 0;
 786         ],[
 787                 AC_MSG_RESULT(yes)
 788                 AC_DEFINE(HAVE___VLAN_FIND_DEV_DEEP_RCU, 1,
 789                           [__vlan_find_dev_deep_rcu is defined])
 790         ],[
 791                 AC_MSG_RESULT(no)
 792         ])
 793
 794         AC_MSG_CHECKING([if ndo_select_queue has accel_priv])
 795         LB_LINUX_TRY_COMPILE([
 796                 #include <linux/netdevice.h>
 797
 798                 static u16 select_queue(struct net_device *dev, struct sk_buff *skb,
 799                                         void *accel_priv)
 800                 {
 801                         return 0;
 802                 }
 803         ],[
 804                 struct net_device_opts ndops;
 805
 806                 ndops.ndo_select_queue = select_queue;
 807
 808                 return 0;
 809         ],[
 810                 AC_MSG_RESULT(yes)
 811                 AC_DEFINE(NDO_SELECT_QUEUE_HAS_ACCEL_PRIV, 1,
 812                           [ndo_select_queue has accel_priv])
 813         ],[
 814                 AC_MSG_RESULT(no)
 815         ])
 816
 817         AC_MSG_CHECKING([if drivers/net/bonding/bonding.h exists])
 818         LB_LINUX_TRY_COMPILE([
 819                 #include "../drivers/net/bonding/bonding.h"
 820         ],[
 821                 return 0;
 822         ],[
 823                 AC_MSG_RESULT(yes)
 824                 AC_DEFINE(HAVE_BONDING_H, 1,
 825                           [drivers/net/bonding/bonding.h exists])
 826         ],[
 827                 AC_MSG_RESULT(no)
 828         ])
 829
 830         AC_MSG_CHECKING([if bonding.h bond_for_each_slave has 3 parameters])
 831         LB_LINUX_TRY_COMPILE([
 832                 #include "../drivers/net/bonding/bonding.h"
 833         ],[
 834                 struct bonding *bond = NULL;
 835                 struct list_head *iter = NULL;
 836                 struct slave *slave = NULL;
 837
 838                 bond_for_each_slave(bond, slave, iter) ;
 839
 840                 return 0;
 841         ],[
 842                 AC_MSG_RESULT(yes)
 843                 AC_DEFINE(HAVE_BOND_FOR_EACH_SLAVE_3_PARAMS, 1,
 844                           [bond_for_each_slave has 3 parameters])
 845         ],[
 846                 AC_MSG_RESULT(no)
 847         ])
 848
 849
 850         AC_MSG_CHECKING([if u64_stats_sync.h has u64_stats_init])
 851         LB_LINUX_TRY_COMPILE([
 852                 #include <linux/u64_stats_sync.h>
 853         ],[
 854                 struct u64_stats_sync sync;
 855                 u64_stats_init(&sync);
 856
 857                 return 0;
 858         ],[
 859                 AC_MSG_RESULT(yes)
 860                 AC_DEFINE(HAVE_U64_STATS_SYNC, 1,
 861                           [u64_stats_sync is defined])
 862         ],[
 863                 AC_MSG_RESULT(no)
 864         ])
 865
 866         AC_MSG_CHECKING([if u64_stats_sync.h has u64_stats_fetch_begin_irq])
 867         LB_LINUX_TRY_COMPILE([
 868                 #include <linux/u64_stats_sync.h>
 869         ],[
 870                 struct u64_stats_sync sync;
 871                 u64_stats_fetch_begin_irq(&sync);
 872
 873                 return 0;
 874         ],[
 875                 AC_MSG_RESULT(yes)
 876                 AC_DEFINE(HAVE_U64_STATS_FETCH_BEGIN_IRQ, 1,
 877                           [u64_stats_fetch_begin_irq is defined])
 878         ],[
 879                 AC_MSG_RESULT(no)
 880         ])
 881         AC_MSG_CHECKING([if etherdevice.h has ether_addr_copy])
 882         LB_LINUX_TRY_COMPILE([
 883                 #include <linux/etherdevice.h>
 884         ],[
 885                 char dest[6], src[6];
 886                 ether_addr_copy(&dest, &src);
 887
 888                 return 0;
 889         ],[
 890                 AC_MSG_RESULT(yes)
 891                 AC_DEFINE(HAVE_ETHER_ADDR_COPY, 1,
 892                           [ether_addr_copy is defined])
 893         ],[
 894                 AC_MSG_RESULT(no)
 895         ])
 896
 897         AC_MSG_CHECKING([if struct net_device_ops has *ndo_set_vf_rate])
 898         LB_LINUX_TRY_COMPILE([
 899                 #include <linux/netdevice.h>
 900
 901                 int set_vf_rate(struct net_device *dev, int vf, int min_tx_rate,
 902                                                    int max_tx_rate)
 903                 {
 904                         return 0;
 905                 }
 906         ],[
 907                 struct net_device_ops netdev_ops;
 908
 909                 netdev_ops.ndo_set_vf_rate = set_vf_rate;
 910                 return 0;
 911         ],[
 912                 AC_MSG_RESULT(yes)
 913                 AC_DEFINE(HAVE_SET_VF_RATE, 1,
 914                           [ndo_set_vf_rate is defined])
 915         ],[
 916                 AC_MSG_RESULT(no)
 917         ])
 918
 919         AC_MSG_CHECKING([if netdev_extended has hw_features])
 920         LB_LINUX_TRY_COMPILE([
 921                 #include <linux/netdevice.h>
 922         ],[
 923                 struct net_device *dev = NULL;
 924
 925                 netdev_extended(dev)->hw_features = 0;
 926
 927                 return 0;
 928         ],[
 929                 AC_MSG_RESULT(yes)
 930                 AC_DEFINE(HAVE_NETDEV_EXTENDED_HW_FEATURES, 1,
 931                           [ is defined])
 932         ],[
 933                 AC_MSG_RESULT(no)
 934         ])
 935
 936         AC_MSG_CHECKING([if net_device_extended has _tx_ext])
 937         LB_LINUX_TRY_COMPILE([
 938                 #include <linux/netdevice.h>
 939         ],[
 940                 struct net_device *dev = NULL;
 941
 942                 netdev_extended(dev)->_tx_ext = NULL;
 943
 944                 return 0;
 945         ],[
 946                 AC_MSG_RESULT(yes)
 947                 AC_DEFINE(HAVE_NET_DEVICE_EXTENDED_TX_EXT, 1,
 948                           [ is defined])
 949         ],[
 950                 AC_MSG_RESULT(no)
 951         ])
 952
 953         AC_MSG_CHECKING([if net_device_extended has ndo_busy_poll])
 954         LB_LINUX_TRY_COMPILE([
 955                 #include <linux/netdevice.h>
 956
 957                 int busy_poll(struct napi_struct *napi)
 958                 {
 959                         return 0;
 960                 }
 961         ],[
 962                 struct net_device *dev = NULL;
 963
 964                 netdev_extended(dev)->ndo_busy_poll = busy_poll;
 965
 966                 return 0;
 967         ],[
 968                 AC_MSG_RESULT(yes)
 969                 AC_DEFINE(HAVE_NETDEV_EXTENDED_NDO_BUSY_POLL, 1,
 970                           [ is defined])
 971         ],[
 972                 AC_MSG_RESULT(no)
 973         ])
 974
 975         AC_MSG_CHECKING([if netdevice.h has set_netdev_hw_features])
 976         LB_LINUX_TRY_COMPILE([
 977                 #include <linux/netdevice.h>
 978         ],[
 979                 struct net_device *dev = NULL;
 980
 981                 set_netdev_hw_features(dev, 0);
 982
 983                 return 0;
 984         ],[
 985                 AC_MSG_RESULT(yes)
 986                 AC_DEFINE(HAVE_SET_NETDEV_HW_FEATURES, 1,
 987                           [ is defined])
 988         ],[
 989                 AC_MSG_RESULT(no)
 990         ])
 991
 992         AC_MSG_CHECKING([if netdevice.h has netif_set_xps_queue])
 993         LB_LINUX_TRY_COMPILE([
 994                 #include <linux/netdevice.h>
 995         ],[
 996                 struct net_device *dev = NULL;
 997
 998                 netif_set_xps_queue(dev, NULL, 0);
 999
1000                 return 0;
1001         ],[
1002                 AC_MSG_RESULT(yes)
1003                 AC_DEFINE(HAVE_NETIF_SET_XPS_QUEUE, 1,
1004                           [ is defined])
1005         ],[
1006                 AC_MSG_RESULT(no)
1007         ])
1008
1009
1010         AC_MSG_CHECKING([if struct net_device_ops has *ndo_set_features])
1011         LB_LINUX_TRY_COMPILE([
1012                 #include <linux/netdevice.h>
1013
1014                 int set_features(struct net_device *dev, netdev_features_t features)
1015                 {
1016                         return 0;
1017                 }
1018         ],[
1019                 struct net_device_ops netdev_ops;
1020
1021                 netdev_ops.ndo_set_features = set_features;
1022                 return 0;
1023         ],[
1024                 AC_MSG_RESULT(yes)
1025                 AC_DEFINE(HAVE_NDO_SET_FEATURES, 1,
1026                           [ndo_set_features is defined])
1027         ],[
1028                 AC_MSG_RESULT(no)
1029         ])
1030
1031         AC_MSG_CHECKING([if struct net_device_ops has *ndo_setup_tc])
1032         LB_LINUX_TRY_COMPILE([
1033                 #include <linux/netdevice.h>
1034
1035                 int setup_tc(struct net_device *dev, , u8 tc)
1036                 {
1037                         return 0;
1038                 }
1039         ],[
1040                 struct net_device_ops netdev_ops;
1041
1042                 netdev_ops.ndo_setup_tc = setup_tc;
1043                 return 0;
1044         ],[
1045                 AC_MSG_RESULT(yes)
1046                 AC_DEFINE(HAVE_NDO_SETUP_TC, 1,
1047                           [ndo_setup_tc is defined])
1048         ],[
1049                 AC_MSG_RESULT(no)
1050         ])
1051
1052         AC_MSG_CHECKING([if struct net_device_ops has *ndo_rx_flow_steer])
1053         LB_LINUX_TRY_COMPILE([
1054                 #include <linux/netdevice.h>
1055
1056                 int rx_flow_steer(struct net_device *dev,
1057                                                      const struct sk_buff *skb,
1058                                                      u16 rxq_index,
1059                                                      u32 flow_id)
1060                 {
1061                         return 0;
1062                 }
1063         ],[
1064                 struct net_device_ops netdev_ops;
1065
1066                 netdev_ops.ndo_rx_flow_steer = rx_flow_steer;
1067                 return 0;
1068         ],[
1069                 AC_MSG_RESULT(yes)
1070                 AC_DEFINE(HAVE_NDO_RX_FLOW_STEER, 1,
1071                           [ndo_rx_flow_steer is defined])
1072         ],[
1073                 AC_MSG_RESULT(no)
1074         ])
1075
1076         AC_MSG_CHECKING([if struct net_device has priv_flags])
1077         LB_LINUX_TRY_COMPILE([
1078                 #include <linux/netdevice.h>
1079         ],[
1080                 struct net_device *netdev;
1081                 netdev->priv_flags = 0;
1082
1083                 return 0;
1084         ],[
1085                 AC_MSG_RESULT(yes)
1086                 AC_DEFINE(HAVE_NET_DEVICE_PRIV_FLAGS, 1,
1087                           [priv_flags is defined])
1088         ],[
1089                 AC_MSG_RESULT(no)
1090         ])
1091
1092         AC_MSG_CHECKING([if struct net_device_ops has *ndo_get_stats64])
1093         LB_LINUX_TRY_COMPILE([
1094                 #include <linux/netdevice.h>
1095
1096                 struct rtnl_link_stats64* get_stats_64(struct net_device *dev,
1097                                                      struct rtnl_link_stats64 *storage)
1098                 {
1099                         struct rtnl_link_stats64 stats_64;
1100                         return &stats_64;
1101                 }
1102         ],[
1103                 struct net_device_ops netdev_ops;
1104
1105                 netdev_ops.ndo_get_stats64 = get_stats_64;
1106
1107                 return 0;
1108         ],[
1109                 AC_MSG_RESULT(yes)
1110                 AC_DEFINE(HAVE_NDO_GET_STATS64, 1,
1111                           [ndo_get_stats64 is defined])
1112         ],[
1113                 AC_MSG_RESULT(no)
1114         ])
1115         AC_MSG_CHECKING([if struct net_device_ops has ndo_bridge_set/getlink])
1116         LB_LINUX_TRY_COMPILE([
1117                 #include <linux/netdevice.h>
1118         ],[
1119                 struct net_device_ops netdev_ops =  {
1120                         .ndo_bridge_setlink = NULL,
1121                         .ndo_bridge_getlink = NULL,
1122                 };
1123
1124                 return 0;
1125         ],[
1126                 AC_MSG_RESULT(yes)
1127                 AC_DEFINE(HAVE_NDO_BRIDGE_SET_GET_LINK, 1,
1128                           [ndo_bridge_set/getlink is defined])
1129         ],[
1130                 AC_MSG_RESULT(no)
1131         ])
1132
1133         AC_MSG_CHECKING([if struct net_device_ops ndo_vlan_rx_add_vid has 3 parameters ])
1134         LB_LINUX_TRY_COMPILE([
1135                 #include <linux/netdevice.h>
1136
1137                 int vlan_rx_add_vid(struct net_device *dev,__be16 proto, u16 vid)
1138                 {
1139                         return 0;
1140                 }
1141         ],[
1142                 struct net_device_ops netdev_ops;
1143
1144                 netdev_ops.ndo_vlan_rx_add_vid = vlan_rx_add_vid;
1145
1146                 return 0;
1147         ],[
1148                 AC_MSG_RESULT(yes)
1149                 AC_DEFINE(HAVE_NDO_RX_ADD_VID_HAS_3_PARAMS, 1,
1150                           [ndo_vlan_rx_add_vid has 3 parameters])
1151         ],[
1152                 AC_MSG_RESULT(no)
1153         ])
1154
1155         AC_MSG_CHECKING([if net_device_ops has ndo_get_phys_port_id])
1156         LB_LINUX_TRY_COMPILE([
1157                 #include <linux/netdevice.h>
1158
1159                 int get_phys_port_id(struct net_device *dev,
1160                                      struct netdev_phys_port_id *ppid)
1161                 {
1162                         return 0;
1163                 }
1164         ],[
1165                 struct net_device_ops netdev_ops;
1166
1167                 netdev_ops.ndo_get_phys_port_id = get_phys_port_id;
1168
1169                 return 0;
1170         ],[
1171                 AC_MSG_RESULT(yes)
1172                 AC_DEFINE(HAVE_NETDEV_NDO_GET_PHYS_PORT_ID, 1,
1173                           [ is defined])
1174         ],[
1175                 AC_MSG_RESULT(no)
1176         ])
1177
1178         AC_MSG_CHECKING([if struct net_device_ops_ext exist])
1179         LB_LINUX_TRY_COMPILE([
1180                 #include <linux/netdevice.h>
1181         ],[
1182                 struct net_device_ops_ext netdev_ops_ext;
1183                 struct net_device_ops_ext netdev_ops__ext = {
1184                         .size                   = sizeof(struct net_device_ops_ext),
1185                 };
1186
1187                 return 0;
1188         ],[
1189                 AC_MSG_RESULT(yes)
1190                 AC_DEFINE(HAVE_NET_DEVICE_OPS_EXT, 1,
1191                           [struct net_device_ops_ext is defined])
1192         ],[
1193                 AC_MSG_RESULT(no)
1194         ])
1195
1196         AC_MSG_CHECKING([if net_device_ops_ext has ndo_get_phys_port_id])
1197         LB_LINUX_TRY_COMPILE([
1198                 #include <linux/netdevice.h>
1199
1200                 int get_phys_port_id(struct net_device *dev,
1201                                      struct netdev_phys_port_id *ppid)
1202                 {
1203                         return 0;
1204                 }
1205         ],[
1206                 struct net_device_ops_ext netdev_ops_ext;
1207
1208                 netdev_ops_ext.ndo_get_phys_port_id = get_phys_port_id;
1209
1210                 return 0;
1211         ],[
1212                 AC_MSG_RESULT(yes)
1213                 AC_DEFINE(HAVE_NETDEV_EXT_NDO_GET_PHYS_PORT_ID, 1,
1214                           [ndo_get_phys_port_id is defined])
1215         ],[
1216                 AC_MSG_RESULT(no)
1217         ])
1218
1219         AC_MSG_CHECKING([if net_device_ops has ndo_set_vf_spoofchk])
1220         LB_LINUX_TRY_COMPILE([
1221                 #include <linux/netdevice.h>
1222
1223                 int set_vf_spoofchk(struct net_device *dev, int vf, bool setting)
1224                 {
1225                         return 0;
1226                 }
1227         ],[
1228                 struct net_device_ops netdev_ops;
1229
1230                 netdev_ops.ndo_set_vf_spoofchk = set_vf_spoofchk;
1231
1232                 return 0;
1233         ],[
1234                 AC_MSG_RESULT(yes)
1235                 AC_DEFINE(HAVE_NETDEV_OPS_NDO_SET_VF_SPOOFCHK, 1,
1236                           [ndo_set_vf_spoofchk is defined in net_device_ops])
1237         ],[
1238                 AC_MSG_RESULT(no)
1239         ])
1240
1241         AC_MSG_CHECKING([if net_device_ops_ext has ndo_set_vf_spoofchk])
1242         LB_LINUX_TRY_COMPILE([
1243                 #include <linux/netdevice.h>
1244
1245                 int set_vf_spoofchk(struct net_device *dev, int vf, bool setting)
1246                 {
1247                         return 0;
1248                 }
1249         ],[
1250                 struct net_device_ops_ext netdev_ops_ext;
1251
1252                 netdev_ops_ext.ndo_set_vf_spoofchk = set_vf_spoofchk;
1253
1254                 return 0;
1255         ],[
1256                 AC_MSG_RESULT(yes)
1257                 AC_DEFINE(HAVE_NETDEV_OPS_EXT_NDO_SET_VF_SPOOFCHK, 1,
1258                           [ndo_set_vf_spoofchk is defined in net_device_ops_ext])
1259         ],[
1260                 AC_MSG_RESULT(no)
1261         ])
1262
1263         AC_MSG_CHECKING([if net_device_ops has ndo_set_vf_link_state])
1264         LB_LINUX_TRY_COMPILE([
1265                 #include <linux/netdevice.h>
1266
1267                 int set_vf_link_state(struct net_device *dev, int vf, int link_state)
1268                 {
1269                         return 0;
1270                 }
1271         ],[
1272                 struct net_device_ops netdev_ops;
1273
1274                 netdev_ops.ndo_set_vf_link_state = set_vf_link_state;
1275
1276                 return 0;
1277         ],[
1278                 AC_MSG_RESULT(yes)
1279                 AC_DEFINE(HAVE_NETDEV_OPS_NDO_SET_VF_LINK_STATE, 1,
1280                           [ndo_set_vf_link_state is defined in net_device_ops])
1281         ],[
1282                 AC_MSG_RESULT(no)
1283         ])
1284
1285         AC_MSG_CHECKING([if net_device_ops_ext has ndo_set_vf_link_state])
1286         LB_LINUX_TRY_COMPILE([
1287                 #include <linux/netdevice.h>
1288
1289                 int set_vf_link_state(struct net_device *dev, int vf, int link_state)
1290                 {
1291                         return 0;
1292                 }
1293         ],[
1294                 struct net_device_ops_ext netdev_ops_ext;
1295
1296                 netdev_ops_ext.ndo_set_vf_link_state = set_vf_link_state;
1297
1298                 return 0;
1299         ],[
1300                 AC_MSG_RESULT(yes)
1301                 AC_DEFINE(HAVE_NETDEV_OPS_EXT_NDO_SET_VF_LINK_STATE, 1,
1302                           [ndo_set_vf_link_state is defined])
1303         ],[
1304                 AC_MSG_RESULT(no)
1305         ])
1306
1307
1308         AC_MSG_CHECKING([if netdevice.h netif_set_real_num_tx_queues returns int])
1309         LB_LINUX_TRY_COMPILE([
1310                 #include <linux/netdevice.h>
1311         ],[
1312                 struct net_device dev;
1313                 int ret;
1314                 ret = netif_set_real_num_tx_queues(&dev, 2);
1315                 return 0;
1316         ],[
1317                 AC_MSG_RESULT(yes)
1318                 AC_DEFINE(HAVE_RETURN_INT_FOR_SET_NUM_TX_QUEUES, 1,
1319                           [netif_set_real_num_tx_queues returns int])
1320         ],[
1321                 AC_MSG_RESULT(no)
1322         ])
1323
1324         AC_MSG_CHECKING([if struct netdevice.h has struct xps_map])
1325         LB_LINUX_TRY_COMPILE([
1326                 #include <linux/netdevice.h>
1327         ],[
1328                 struct xps_map map;
1329                 map.len = 0;
1330
1331                 return 0;
1332         ],[
1333                 AC_MSG_RESULT(yes)
1334                 AC_DEFINE(HAVE_XPS_MAP, 1,
1335                           [struct xps_map is defined])
1336         ],[
1337                 AC_MSG_RESULT(no)
1338         ])
1339
1340         AC_MSG_CHECKING([if struct ethtool_ops has set_phys_id])
1341         LB_LINUX_TRY_COMPILE([
1342                 #include <linux/ethtool.h>
1343         ],[
1344                 const struct ethtool_ops en_ethtool_ops = {
1345                         .set_phys_id= NULL,
1346                 };
1347
1348                 return 0;
1349         ],[
1350                 AC_MSG_RESULT(yes)
1351                 AC_DEFINE(HAVE_SET_PHYS_ID, 1,
1352                           [set_phys_id is defined])
1353         ],[
1354                 AC_MSG_RESULT(no)
1355         ])
1356
1357         AC_MSG_CHECKING([if struct ethtool_ops has get/set_channels])
1358         LB_LINUX_TRY_COMPILE([
1359                 #include <linux/ethtool.h>
1360         ],[
1361                 const struct ethtool_ops en_ethtool_ops = {
1362                         .get_channels = NULL,
1363                         .set_channels = NULL,
1364                 };
1365
1366                 return 0;
1367         ],[
1368                 AC_MSG_RESULT(yes)
1369                 AC_DEFINE(HAVE_GET_SET_CHANNELS, 1,
1370                           [get/set_channels is defined])
1371         ],[
1372                 AC_MSG_RESULT(no)
1373         ])
1374
1375         AC_MSG_CHECKING([if struct ethtool_ops_ext has get/set_channels])
1376         LB_LINUX_TRY_COMPILE([
1377                 #include <linux/ethtool.h>
1378         ],[
1379                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
1380                         .get_channels = NULL,
1381                         .set_channels = NULL,
1382                 };
1383
1384                 return 0;
1385         ],[
1386                 AC_MSG_RESULT(yes)
1387                 AC_DEFINE(HAVE_GET_SET_CHANNELS_EXT, 1,
1388                           [get/set_channels is defined in ethtool_ops_ext])
1389         ],[
1390                 AC_MSG_RESULT(no)
1391         ])
1392
1393         AC_MSG_CHECKING([if struct ethtool_ops has get_ts_info])
1394         LB_LINUX_TRY_COMPILE([
1395                 #include <linux/ethtool.h>
1396         ],[
1397                 const struct ethtool_ops en_ethtool_ops = {
1398                         .get_ts_info = NULL,
1399                 };
1400
1401                 return 0;
1402         ],[
1403                 AC_MSG_RESULT(yes)
1404                 AC_DEFINE(HAVE_GET_TS_INFO, 1,
1405                           [get_ts_info is defined])
1406         ],[
1407                 AC_MSG_RESULT(no)
1408         ])
1409
1410         AC_MSG_CHECKING([if struct ethtool_ops_ext has get_ts_info])
1411         LB_LINUX_TRY_COMPILE([
1412                 #include <linux/ethtool.h>
1413         ],[
1414                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
1415                         .get_ts_info = NULL,
1416                 };
1417
1418                 return 0;
1419         ],[
1420                 AC_MSG_RESULT(yes)
1421                 AC_DEFINE(HAVE_GET_TS_INFO_EXT, 1,
1422                           [get_ts_info is defined in ethtool_ops_ext])
1423         ],[
1424                 AC_MSG_RESULT(no)
1425         ])
1426
1427         AC_MSG_CHECKING([if struct ethtool_flow_ext has h_dest])
1428         LB_LINUX_TRY_COMPILE([
1429                 #include <linux/ethtool.h>
1430         ],[
1431                 unsigned char mac[ETH_ALEN];
1432                 struct ethtool_flow_ext h_ext;
1433
1434                 memcpy(&mac, h_ext.h_dest, ETH_ALEN);
1435
1436                 return 0;
1437         ],[
1438                 AC_MSG_RESULT(yes)
1439                 AC_DEFINE(HAVE_ETHTOOL_FLOW_EXT_H_DEST, 1,
1440                           [ethtool_flow_ext has h_dest])
1441         ],[
1442                 AC_MSG_RESULT(no)
1443         ])
1444
1445         AC_MSG_CHECKING([if netdevice.h has struct netdev_hw_addr])
1446         LB_LINUX_TRY_COMPILE([
1447                 #include <linux/netdevice.h>
1448         ],[
1449                 struct netdev_hw_addr addr;
1450                 return 0;
1451         ],[
1452                 AC_MSG_RESULT(yes)
1453                 AC_DEFINE(HAVE_NETDEV_HW_ADDR, 1,
1454                           [netdev_hw_addr is defined])
1455         ],[
1456                 AC_MSG_RESULT(no)
1457         ])
1458
1459         AC_MSG_CHECKING([if pci.h has pci_vfs_assigned])
1460         LB_LINUX_TRY_COMPILE([
1461                 #include <linux/pci.h>
1462         ],[
1463                 struct pci_dev pdev;
1464                 pci_vfs_assigned(&pdev);
1465                 return 0;
1466         ],[
1467                 AC_MSG_RESULT(yes)
1468                 AC_DEFINE(HAVE_PCI_VF_ASSIGNED, 1,
1469                           [pci_vfs_assigned is defined])
1470         ],[
1471                 AC_MSG_RESULT(no)
1472         ])
1473         AC_MSG_CHECKING([if __vlan_put_tag has 3 parameters])
1474         LB_LINUX_TRY_COMPILE([
1475                 #include <linux/if_vlan.h>
1476         ],[
1477                 struct sk_buff *skb;
1478                 __vlan_put_tag(skb, 0, 0);
1479
1480                 return 0;
1481         ],[
1482                 AC_MSG_RESULT(yes)
1483                 AC_DEFINE(HAVE_3_PARAMS_FOR_VLAN_PUT_TAG, 1,
1484                           [__vlan_put_tag has 3 parameters])
1485         ],[
1486                 AC_MSG_RESULT(no)
1487         ])
1488
1489         AC_MSG_CHECKING([if __vlan_hwaccel_put_tag has 3 parameters])
1490         LB_LINUX_TRY_COMPILE([
1491                 #include <linux/if_vlan.h>
1492         ],[
1493                 struct sk_buff *skb;
1494                 __vlan_hwaccel_put_tag(skb, 0, 0);
1495
1496                 return 0;
1497         ],[
1498                 AC_MSG_RESULT(yes)
1499                 AC_DEFINE(HAVE_3_PARAMS_FOR_VLAN_HWACCEL_PUT_TAG, 1,
1500                           [__vlan_hwaccel_put_tag has 3 parameters])
1501         ],[
1502                 AC_MSG_RESULT(no)
1503         ])
1504
1505         AC_MSG_CHECKING([if struct net_device has hw_features])
1506         LB_LINUX_TRY_COMPILE([
1507                 #include <linux/netdevice.h>
1508         ],[
1509                 struct net_device dev;
1510                 dev.hw_features = 0;
1511
1512                 return 0;
1513         ],[
1514                 AC_MSG_RESULT(yes)
1515                 AC_DEFINE(HAVE_NETDEV_HW_FEATURES, 1,
1516                           [hw_features is defined])
1517         ],[
1518                 AC_MSG_RESULT(no)
1519         ])
1520
1521         AC_MSG_CHECKING([if struct net_device has hw_enc_features])
1522         LB_LINUX_TRY_COMPILE([
1523                 #include <linux/netdevice.h>
1524         ],[
1525                 struct net_device dev;
1526                 dev.hw_enc_features = 0;
1527
1528                 return 0;
1529         ],[
1530                 AC_MSG_RESULT(yes)
1531                 AC_DEFINE(HAVE_NETDEV_HW_ENC_FEATURES, 1,
1532                           [hw_enc_features is defined])
1533         ],[
1534                 AC_MSG_RESULT(no)
1535         ])
1536
1537         AC_MSG_CHECKING([if struct net_device has rx_cpu_rmap])
1538         LB_LINUX_TRY_COMPILE([
1539                 #include <linux/netdevice.h>
1540         ],[
1541                 struct net_device dev;
1542                 dev.rx_cpu_rmap = NULL;
1543
1544                 return 0;
1545         ],[
1546                 AC_MSG_RESULT(yes)
1547                 AC_DEFINE(HAVE_NETDEV_RX_CPU_RMAP, 1,
1548                           [rx_cpu_rmap is defined])
1549         ],[
1550                 AC_MSG_RESULT(no)
1551         ])
1552
1553         AC_MSG_CHECKING([if if_vlan.h has vlan_hwaccel_receive_skb])
1554         LB_LINUX_TRY_COMPILE([
1555                 #include <linux/if_vlan.h>
1556         ],[
1557                 struct sk_buff *skb;
1558                 vlan_hwaccel_receive_skb(skb,0,0);
1559                 return 0;
1560         ],[
1561                 AC_MSG_RESULT(yes)
1562                 AC_DEFINE(HAVE_VLAN_HWACCEL_RECEIVE_SKB, 1,
1563                           [vlan_hwaccel_receive_skb is defined])
1564         ],[
1565                 AC_MSG_RESULT(no)
1566         ])
1567
1568         AC_MSG_CHECKING([if irqdesc.h has irq_desc_get_irq_data])
1569         LB_LINUX_TRY_COMPILE([
1570                 #include <linux/irqdesc.h>
1571         ],[
1572                 struct irq_data *data = irq_desc_get_irq_data(NULL);
1573                 return 0;
1574         ],[
1575                 AC_MSG_RESULT(yes)
1576                 AC_DEFINE(HAVE_IRQ_DESC_GET_IRQ_DATA, 1,
1577                           [irq_desc_get_irq_data is defined])
1578         ],[
1579                 AC_MSG_RESULT(no)
1580         ])
1581
1582
1583         AC_MSG_CHECKING([if pci_dev has pcie_mpss])
1584         LB_LINUX_TRY_COMPILE([
1585                 #include <linux/pci.h>
1586         ],[
1587                 struct pci_dev pdev;
1588
1589                 pdev->pcie_mpss = 0;
1590                 return 0;
1591         ],[
1592                 AC_MSG_RESULT(yes)
1593                 AC_DEFINE(HAVE_PCI_DEV_PCIE_MPSS, 1,
1594                           [pcie_mpss is defined])
1595         ],[
1596                 AC_MSG_RESULT(no)
1597         ])
1598
1599         AC_MSG_CHECKING([if uapi/linux/if_ether.h exist])
1600         LB_LINUX_TRY_COMPILE([
1601                 #include <uapi/linux/if_ether.h>
1602         ],[
1603                 return 0;
1604         ],[
1605                 AC_MSG_RESULT(yes)
1606                 AC_DEFINE(HAVE_UAPI_LINUX_IF_ETHER_H, 1,
1607                           [uapi/linux/if_ether.h exist])
1608         ],[
1609                 AC_MSG_RESULT(no)
1610         ])
1611
1612         AC_MSG_CHECKING([if ifla_vf_info has spoofchk])
1613         LB_LINUX_TRY_COMPILE([
1614                 #include <linux/if_link.h>
1615         ],[
1616                 struct ifla_vf_info *ivf;
1617
1618                 ivf->spoofchk = 0;
1619                 return 0;
1620         ],[
1621                 AC_MSG_RESULT(yes)
1622                 AC_DEFINE(HAVE_VF_INFO_SPOOFCHK, 1,
1623                           [spoofchk is defined])
1624         ],[
1625                 AC_MSG_RESULT(no)
1626         ])
1627
1628         AC_MSG_CHECKING([if dst.h has dst_get_neighbour])
1629         LB_LINUX_TRY_COMPILE([
1630                 #include <net/dst.h>
1631         ],[
1632                 struct neighbour *neigh = dst_get_neighbour(NULL);
1633
1634                 return 0;
1635         ],[
1636                 AC_MSG_RESULT(yes)
1637                 AC_DEFINE(HAVE_DST_GET_NEIGHBOUR, 1,
1638                           [ is defined])
1639         ],[
1640                 AC_MSG_RESULT(no)
1641         ])
1642
1643         AC_MSG_CHECKING([if netlink_dump_start has 6 parameters])
1644         LB_LINUX_TRY_COMPILE([
1645                 #include <linux/netlink.h>
1646         ],[
1647                 int ret = netlink_dump_start(NULL, NULL, NULL, NULL, NULL, 0);
1648
1649                 return 0;
1650         ],[
1651                 AC_MSG_RESULT(yes)
1652                 AC_DEFINE(HAVE_NETLINK_DUMP_START_6P, 1,
1653                           [ is defined])
1654         ],[
1655                 AC_MSG_RESULT(no)
1656         ])
1657
1658         AC_MSG_CHECKING([if netlink_dump_start has 5 parameters])
1659         LB_LINUX_TRY_COMPILE([
1660                 #include <linux/netlink.h>
1661         ],[
1662                 int ret = netlink_dump_start(NULL, NULL, NULL, NULL, NULL);
1663
1664                 return 0;
1665         ],[
1666                 AC_MSG_RESULT(yes)
1667                 AC_DEFINE(HAVE_NETLINK_DUMP_START_5P, 1,
1668                           [ is defined])
1669         ],[
1670                 AC_MSG_RESULT(no)
1671         ])
1672
1673         AC_MSG_CHECKING([if struct dcbnl_rtnl_ops has ieee_getmaxrate/ieee_setmaxrate])
1674         LB_LINUX_TRY_COMPILE([
1675                 #include <net/dcbnl.h>
1676         ],[
1677                 const struct dcbnl_rtnl_ops en_dcbnl_ops = {
1678                         .ieee_getmaxrate = NULL,
1679                         .ieee_setmaxrate = NULL,
1680                 };
1681
1682                 return 0;
1683         ],[
1684                 AC_MSG_RESULT(yes)
1685                 AC_DEFINE(HAVE_IEEE_GET_SET_MAXRATE, 1,
1686                           [ieee_getmaxrate/ieee_setmaxrate is defined])
1687         ],[
1688                 AC_MSG_RESULT(no)
1689         ])
1690 ])
1691 #
1692 # COMPAT_CONFIG_HEADERS
1693 #
1694 # add -include config.h
1695 #
1696 AC_DEFUN([COMPAT_CONFIG_HEADERS],[
1697         AC_CONFIG_HEADERS([config.h])
1698         EXTRA_KCFLAGS="-include $PWD/config.h $EXTRA_KCFLAGS"
1699         AC_SUBST(EXTRA_KCFLAGS)
1700 ])
1701
1702 AC_DEFUN([OFA_PROG_LINUX],
1703 [
1704
1705 LB_LINUX_PATH
1706 LB_LINUX_SYMVERFILE
1707 LB_LINUX_CONFIG([MODULES],[],[
1708     AC_MSG_ERROR([module support is required to build mlnx kernel modules.])
1709 ])
1710 LB_LINUX_CONFIG([MODVERSIONS])
1711 LB_LINUX_CONFIG([KALLSYMS],[],[
1712     AC_MSG_ERROR([compat_mlnx requires that CONFIG_KALLSYMS is enabled in your kernel.])
1713 ])
1714
1715 LINUX_CONFIG_COMPAT
1716 COMPAT_CONFIG_HEADERS
1717
1718 ])