rdma.m4: be2net backport for RHEL 7.2
[compat-rdma/compat.git] / 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 file_system_type has mount method])
143         LB_LINUX_TRY_COMPILE([
144                 #include <linux/fs.h>
145         ],[
146                 struct file_system_type fst;
147
148                 fst.mount = NULL;
149                 return 0;
150         ],[
151                 AC_MSG_RESULT(yes)
152                 AC_DEFINE(HAVE_MOUNT_METHOD, 1,
153                           [mount method defined])
154         ],[
155                 AC_MSG_RESULT(no)
156         ])
157
158         AC_MSG_CHECKING([if kernel has get_next_ino])
159         LB_LINUX_TRY_COMPILE([
160                 #include <linux/fs.h>
161         ],[
162                 unsigned int ino;
163
164                 ino = get_next_ino();
165                 return 0;
166         ],[
167                 AC_MSG_RESULT(yes)
168                 AC_DEFINE(HAVE_GET_NEXT_INO, 1,
169                           [get_next_ino defined])
170         ],[
171                 AC_MSG_RESULT(no)
172         ])
173
174         AC_MSG_CHECKING([if kernel has ktime_get_ns])
175         LB_LINUX_TRY_COMPILE([
176                 #include <linux/ktime.h>
177         ],[
178                 unsigned long long ns;
179
180                 ns = ktime_get_ns();
181                 return 0;
182         ],[
183                 AC_MSG_RESULT(yes)
184                 AC_DEFINE(HAVE_KTIME_GET_NS, 1,
185                           [ktime_get_ns defined])
186         ],[
187                 AC_MSG_RESULT(no)
188         ])
189
190         AC_MSG_CHECKING([if svc_xprt_class has xcl_ident])
191         LB_LINUX_TRY_COMPILE([
192                 #include <linux/sunrpc/xprt.h>
193                 #include <linux/sunrpc/svc_xprt.h>
194         ],[
195                 struct svc_xprt_class svc_rdma_class = {
196                         .xcl_ident = XPRT_TRANSPORT_RDMA,
197                 };
198                 return 0;
199         ],[
200                 AC_MSG_RESULT(yes)
201                 AC_DEFINE(HAVE_XCL_IDENT, 1,
202                           [xcl_ident defined])
203         ],[
204                 AC_MSG_RESULT(no)
205         ])
206
207         AC_MSG_CHECKING([if struct ifla_vf_info has max_tx_rate])
208         LB_LINUX_TRY_COMPILE([
209                 #include <linux/if_link.h>
210         ],[
211                 struct ifla_vf_info *ivf;
212
213                 ivf->max_tx_rate = 0;
214                 ivf->min_tx_rate = 0;
215
216                 return 0;
217         ],[
218                 AC_MSG_RESULT(yes)
219                 AC_DEFINE(HAVE_TX_RATE_LIMIT, 1,
220                           [max_tx_rate is defined])
221         ],[
222                 AC_MSG_RESULT(no)
223         ])
224
225         AC_MSG_CHECKING([if struct ethtool_ops has get/set_rxfh])
226         LB_LINUX_TRY_COMPILE([
227                 #include <linux/ethtool.h>
228         ],[
229                 const struct ethtool_ops en_ethtool_ops = {
230                         .get_rxfh_indir_size = NULL,
231                         .get_rxfh = NULL,
232                         .set_rxfh = NULL,
233                 };
234
235                 return 0;
236         ],[
237                 AC_MSG_RESULT(yes)
238                 AC_DEFINE(HAVE_GET_SET_RXFH, 1,
239                           [get/set_rxfh is defined])
240         ],[
241                 AC_MSG_RESULT(no)
242         ])
243
244
245         AC_MSG_CHECKING([if struct ethtool_ops has get/set_tunable])
246         LB_LINUX_TRY_COMPILE([
247                 #include <linux/ethtool.h>
248         ],[
249                 const struct ethtool_ops en_ethtool_ops = {
250                         .get_tunable = NULL,
251                         .set_tunable = NULL,
252                 };
253
254                 return 0;
255         ],[
256                 AC_MSG_RESULT(yes)
257                 AC_DEFINE(HAVE_GET_SET_TUNABLE, 1,
258                           [get/set_tunable is defined])
259         ],[
260                 AC_MSG_RESULT(no)
261         ])
262
263         AC_MSG_CHECKING([if exist struct ethtool_ops_ext])
264         LB_LINUX_TRY_COMPILE([
265                 #include <linux/ethtool.h>
266         ],[
267                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
268                         .size = sizeof(struct ethtool_ops_ext),
269                 };
270
271                 return 0;
272         ],[
273                 AC_MSG_RESULT(yes)
274                 AC_DEFINE(HAVE_ETHTOOL_OPS_EXT, 1,
275                           [struct ethtool_ops_ext is defined])
276         ],[
277                 AC_MSG_RESULT(no)
278         ])
279
280         AC_MSG_CHECKING([if struct ethtool_ops_ext has get/set_rxfh])
281         LB_LINUX_TRY_COMPILE([
282                 #include <linux/ethtool.h>
283         ],[
284                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
285                         .get_rxfh_indir_size = NULL,
286                         .get_rxfh = NULL,
287                         .set_rxfh = NULL,
288                 };
289
290                 return 0;
291         ],[
292                 AC_MSG_RESULT(yes)
293                 AC_DEFINE(HAVE_GET_SET_RXFH_OPS_EXT, 1,
294                           [get/set_rxfh is defined])
295         ],[
296                 AC_MSG_RESULT(no)
297         ])
298
299         AC_MSG_CHECKING([if struct ethtool_ops_ext has get/set_rxfh_indir])
300         LB_LINUX_TRY_COMPILE([
301                 #include <linux/ethtool.h>
302         ],[
303                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
304                         .get_rxfh_indir = NULL,
305                         .set_rxfh_indir = NULL,
306                 };
307
308                 return 0;
309         ],[
310                 AC_MSG_RESULT(yes)
311                 AC_DEFINE(HAVE_GET_SET_RXFH_INDIR, 1,
312                           [get/set_rxfh_indir is defined])
313         ],[
314                 AC_MSG_RESULT(no)
315         ])
316
317         AC_MSG_CHECKING([if struct net_device has dev_port])
318         LB_LINUX_TRY_COMPILE([
319                 #include <linux/netdevice.h>
320         ],[
321                 struct net_device *dev = NULL;
322
323                 dev->dev_port = 0;
324
325                 return 0;
326         ],[
327                 AC_MSG_RESULT(yes)
328                 AC_DEFINE(HAVE_NET_DEVICE_DEV_PORT, 1,
329                           [dev_port is defined])
330         ],[
331                 AC_MSG_RESULT(no)
332         ])
333
334         AC_MSG_CHECKING([if struct ptp_clock_info has n_pins])
335         LB_LINUX_TRY_COMPILE([
336                 #include <linux/ptp_clock_kernel.h>
337         ],[
338                 struct ptp_clock_info *info;
339                 info->n_pins = 0;
340
341                 return 0;
342         ],[
343                 AC_MSG_RESULT(yes)
344                 AC_DEFINE(HAVE_PTP_CLOCK_INFO_N_PINS, 1,
345                           [n_pins is defined])
346         ],[
347                 AC_MSG_RESULT(no)
348         ])
349
350         AC_MSG_CHECKING([if pci.h pci_enable_msi_exact])
351         LB_LINUX_TRY_COMPILE([
352                 #include <linux/pci.h>
353         ],[
354                 int x = pci_enable_msi_exact(NULL, 0);
355
356                 return 0;
357         ],[
358                 AC_MSG_RESULT(yes)
359                 AC_DEFINE(HAVE_PCI_ENABLE_MSI_EXACT, 1,
360                           [pci_enable_msi_exact is defined])
361         ],[
362                 AC_MSG_RESULT(no)
363         ])
364
365         AC_MSG_CHECKING([if pci.h pci_enable_msix_range])
366         LB_LINUX_TRY_COMPILE([
367                 #include <linux/pci.h>
368         ],[
369                 int x = pci_enable_msix_range(NULL, 0, 0, 0);
370
371                 return 0;
372         ],[
373                 AC_MSG_RESULT(yes)
374                 AC_DEFINE(HAVE_PCI_ENABLE_MSIX_RANGE, 1,
375                           [pci_enable_msix_range is defined])
376         ],[
377                 AC_MSG_RESULT(no)
378         ])
379
380         AC_MSG_CHECKING([if pci.h pci_msix_vec_count])
381         LB_LINUX_TRY_COMPILE([
382                 #include <linux/pci.h>
383         ],[
384                 int x = pci_msix_vec_count(NULL);
385
386                 return 0;
387         ],[
388                 AC_MSG_RESULT(yes)
389                 AC_DEFINE(HAVE_PCI_MSIX_VEC_COUNT, 1,
390                           [pci_msix_vec_count is defined])
391         ],[
392                 AC_MSG_RESULT(no)
393         ])
394
395         AC_MSG_CHECKING([if pci_dev has msix_cap])
396         LB_LINUX_TRY_COMPILE([
397                 #include <linux/pci.h>
398         ],[
399                 struct pci_dev pdev;
400                 pdev.msix_cap = 0;
401
402                 return 0;
403         ],[
404                 AC_MSG_RESULT(yes)
405                 AC_DEFINE(HAVE_PCI_MSIX_CAP, 1,
406                           [msix_cap is defined])
407         ],[
408                 AC_MSG_RESULT(no)
409         ])
410
411         AC_MSG_CHECKING([if mm_struct has pinned_vm])
412         LB_LINUX_TRY_COMPILE([
413                 #include <linux/mm_types.h>
414         ],[
415                 struct mm_types mmt;
416                 mmt.pinned_vm = 0;
417
418                 return 0;
419         ],[
420                 AC_MSG_RESULT(yes)
421                 AC_DEFINE(HAVE_PINNED_VM, 1,
422                           [pinned_vm is defined])
423         ],[
424                 AC_MSG_RESULT(no)
425         ])
426
427         AC_MSG_CHECKING([if kernel has idr_alloc])
428         LB_LINUX_TRY_COMPILE([
429                 #include <linux/idr.h>
430         ],[
431                 int x;
432                 x =  idr_alloc(NULL, NULL, 0, 0, 0);
433
434                 return 0;
435         ],[
436                 AC_MSG_RESULT(yes)
437                 AC_DEFINE(HAVE_IDR_ALLOC, 1,
438                           [idr_alloc is defined])
439         ],[
440                 AC_MSG_RESULT(no)
441         ])
442
443         AC_MSG_CHECKING([if kernel has percpu variables])
444         LB_LINUX_TRY_COMPILE([
445                 #include <linux/percpu.h>
446         ],[
447                 static DEFINE_PER_CPU(unsigned int, x);
448                 this_cpu_inc(x);
449
450                 return 0;
451         ],[
452                 AC_MSG_RESULT(yes)
453                 AC_DEFINE(HAVE_PERCPU_VARS, 1,
454                           [percpu variables are defined])
455         ],[
456                 AC_MSG_RESULT(no)
457         ])
458
459         AC_MSG_CHECKING([if struct iscsi_transport has attr_is_visible])
460         LB_LINUX_TRY_COMPILE([
461                 #include <scsi/scsi_transport_iscsi.h>
462         ],[
463                 static struct iscsi_transport iscsi_iser_transport = {
464                         .attr_is_visible = NULL,
465                 };
466
467                 return 0;
468         ],[
469                 AC_MSG_RESULT(yes)
470                 AC_DEFINE(HAVE_ISCSI_ATTR_IS_VISIBLE, 1,
471                           [attr_is_visible is defined])
472         ],[
473                 AC_MSG_RESULT(no)
474         ])
475
476         AC_MSG_CHECKING([if struct iscsi_transport has get_ep_param])
477         LB_LINUX_TRY_COMPILE([
478                 #include <scsi/scsi_transport_iscsi.h>
479         ],[
480                 static struct iscsi_transport iscsi_iser_transport = {
481                         .get_ep_param = NULL,
482                 };
483
484                 return 0;
485         ],[
486                 AC_MSG_RESULT(yes)
487                 AC_DEFINE(HAVE_ISCSI_GET_EP_PARAM, 1,
488                           [get_ep_param is defined])
489         ],[
490                 AC_MSG_RESULT(no)
491         ])
492
493         AC_MSG_CHECKING([if struct iscsi_transport has check_protection])
494         LB_LINUX_TRY_COMPILE([
495                 #include <scsi/scsi_transport_iscsi.h>
496         ],[
497                 static struct iscsi_transport iscsi_iser_transport = {
498                         .check_protection = NULL,
499                 };
500
501                 return 0;
502         ],[
503                 AC_MSG_RESULT(yes)
504                 AC_DEFINE(HAVE_ISCSI_CHECK_PROTECTION, 1,
505                           [check_protection is defined])
506         ],[
507                 AC_MSG_RESULT(no)
508         ])
509
510         AC_MSG_CHECKING([if iscsi_proto.h has struct iscsi_scsi_req])
511         LB_LINUX_TRY_COMPILE([
512                 #include <scsi/iscsi_proto.h>
513         ],[
514                 struct iscsi_scsi_req req = {
515                         .opcode = 0,
516                 };
517
518                 return 0;
519         ],[
520                 AC_MSG_RESULT(yes)
521                 AC_DEFINE(HAVE_ISCSI_SCSI_REQ, 1,
522                           [struct iscsi_scsi_req is defined])
523         ],[
524                 AC_MSG_RESULT(no)
525         ])
526
527         AC_MSG_CHECKING([if struct request_queue has request_fn_active])
528         LB_LINUX_TRY_COMPILE([
529                 #include <linux/blkdev.h>
530         ],[
531                 struct request_queue rq = {
532                         .request_fn_active = 0,
533                 };
534
535                 return 0;
536         ],[
537                 AC_MSG_RESULT(yes)
538                 AC_DEFINE(HAVE_REQUEST_QUEUE_REQUEST_FN_ACTIVE, 1,
539                           [struct request_queue has request_fn_active])
540         ],[
541                 AC_MSG_RESULT(no)
542         ])
543
544         AC_MSG_CHECKING([if netdevice.h has select_queue_fallback_t])
545         LB_LINUX_TRY_COMPILE([
546                 #include <linux/netdevice.h>
547         ],[
548                 select_queue_fallback_t fallback;
549
550                 fallback = NULL;
551
552                 return 0;
553         ],[
554                 AC_MSG_RESULT(yes)
555                 AC_DEFINE(HAVE_SELECT_QUEUE_FALLBACK_T, 1,
556                           [select_queue_fallback_t is defined])
557         ],[
558                 AC_MSG_RESULT(no)
559         ])
560
561         AC_MSG_CHECKING([if netdevice.h has skb_set_hash])
562         LB_LINUX_TRY_COMPILE([
563                 #include <linux/netdevice.h>
564         ],[
565                 skb_set_hash(NULL, 0, PKT_HASH_TYPE_L3);
566
567                 return 0;
568         ],[
569                 AC_MSG_RESULT(yes)
570                 AC_DEFINE(HAVE_SKB_SET_HASH, 1,
571                           [skb_set_hash is defined])
572         ],[
573                 AC_MSG_RESULT(no)
574         ])
575
576         AC_MSG_CHECKING([if netdevice.h has alloc_netdev with 4 params])
577         LB_LINUX_TRY_COMPILE([
578                 #include <linux/netdevice.h>
579         ],[
580                 struct net_device *dev;
581
582                 dev = alloc_netdev(0, NULL, 0, NULL);
583
584                 return 0;
585         ],[
586                 AC_MSG_RESULT(yes)
587                 AC_DEFINE(HAVE_ALLOC_NETDEV_4P, 1,
588                           [alloc_netdev has 4 parameters])
589         ],[
590                 AC_MSG_RESULT(no)
591         ])
592
593         AC_MSG_CHECKING([if sockios.h has SIOCGHWTSTAMP])
594         LB_LINUX_TRY_COMPILE([
595                 #include <linux/sockios.h>
596         ],[
597                 int x = SIOCGHWTSTAMP;
598
599                 return 0;
600         ],[
601                 AC_MSG_RESULT(yes)
602                 AC_DEFINE(HAVE_SIOCGHWTSTAMP, 1,
603                           [SIOCGHWTSTAMP is defined])
604         ],[
605                 AC_MSG_RESULT(no)
606         ])
607
608         AC_MSG_CHECKING([if ip.h inet_get_local_port_range has 3 parameters])
609         LB_LINUX_TRY_COMPILE([
610                 #include <net/ip.h>
611         ],[
612                 inet_get_local_port_range(NULL, NULL, NULL);
613
614                 return 0;
615         ],[
616                 AC_MSG_RESULT(yes)
617                 AC_DEFINE(HAVE_INET_GET_LOCAL_PORT_RANGE_3_PARAMS, 1,
618                           [inet_get_local_port_range has 3 parameters])
619         ],[
620                 AC_MSG_RESULT(no)
621         ])
622
623         AC_MSG_CHECKING([if net.h has net_get_random_once])
624         LB_LINUX_TRY_COMPILE([
625                 #include <linux/net.h>
626         ],[
627                 net_get_random_once(NULL, 0);
628
629                 return 0;
630         ],[
631                 AC_MSG_RESULT(yes)
632                 AC_DEFINE(HAVE_NET_GET_RANDOM_ONCE, 1,
633                           [net_get_random_once is defined])
634         ],[
635                 AC_MSG_RESULT(no)
636         ])
637
638         AC_MSG_CHECKING([if inet_sock.h has __inet_ehashfn])
639         LB_LINUX_TRY_COMPILE([
640                 #include <net/inet_sock.h>
641         ],[
642                 __inet_ehashfn(0, 0, 0, 0, 0);
643
644                 return 0;
645         ],[
646                 AC_MSG_RESULT(yes)
647                 AC_DEFINE(HAVE_INET_EHASHFN, 1,
648                           [__inet_ehashfn is defined])
649         ],[
650                 AC_MSG_RESULT(no)
651         ])
652
653         AC_MSG_CHECKING([if err.h has PTR_ERR_OR_ZERO])
654         LB_LINUX_TRY_COMPILE([
655                 #include <linux/err.h>
656         ],[
657                 int x = PTR_ERR_OR_ZERO(NULL);
658
659                 return 0;
660         ],[
661                 AC_MSG_RESULT(yes)
662                 AC_DEFINE(HAVE_PTR_ERR_OR_ZERO, 1,
663                           [PTR_ERR_OR_ZERO is defined])
664         ],[
665                 AC_MSG_RESULT(no)
666         ])
667
668         AC_MSG_CHECKING([if struct iscsi_session has discovery_sess])
669         LB_LINUX_TRY_COMPILE([
670                 #include <scsi/libiscsi.h>
671         ],[
672                 struct iscsi_session session;
673                 session.discovery_sess = 0;
674
675                 return 0;
676         ],[
677                 AC_MSG_RESULT(yes)
678                 AC_DEFINE(HAVE_ISCSI_DISCOVERY_SESS, 1,
679                           [discovery_sess is defined])
680         ],[
681                 AC_MSG_RESULT(no)
682         ])
683
684         AC_MSG_CHECKING([if enum iscsi_param has ISCSI_PARAM_DISCOVERY_SESS])
685         LB_LINUX_TRY_COMPILE([
686                 #include <scsi/iscsi_if.h>
687         ],[
688                 int x = ISCSI_PARAM_DISCOVERY_SESS;
689
690                 return 0;
691         ],[
692                 AC_MSG_RESULT(yes)
693                 AC_DEFINE(HAVE_ISCSI_PARAM_DISCOVERY_SESS, 1,
694                           [ISCSI_PARAM_DISCOVERY_SESS is defined])
695         ],[
696                 AC_MSG_RESULT(no)
697         ])
698
699         AC_MSG_CHECKING([if pci.h has enum pcie_link_width])
700         LB_LINUX_TRY_COMPILE([
701                 #include <linux/pci.h>
702                 #include <linux/pci_hotplug.h>
703         ],[
704                 enum pcie_link_width width = PCIE_LNK_WIDTH_UNKNOWN;
705
706                 return 0;
707         ],[
708                 AC_MSG_RESULT(yes)
709                 AC_DEFINE(HAVE_PCIE_LINK_WIDTH, 1,
710                           [pcie_link_width is defined])
711         ],[
712                 AC_MSG_RESULT(no)
713         ])
714
715         AC_MSG_CHECKING([if pci.h has enum pci_bus_speed])
716         LB_LINUX_TRY_COMPILE([
717                 #include <linux/pci.h>
718                 #include <linux/pci_hotplug.h>
719         ],[
720                 enum pci_bus_speed speed = PCI_SPEED_UNKNOWN;
721
722                 return 0;
723         ],[
724                 AC_MSG_RESULT(yes)
725                 AC_DEFINE(HAVE_PCI_BUS_SPEED, 1,
726                           [pci_bus_speed is defined])
727         ],[
728                 AC_MSG_RESULT(no)
729         ])
730
731         AC_MSG_CHECKING([if netdevice.h has struct netdev_phys_port_id])
732         LB_LINUX_TRY_COMPILE([
733                 #include <linux/netdevice.h>
734         ],[
735                 struct netdev_phys_port_id *x = NULL;
736
737                 return 0;
738         ],[
739                 AC_MSG_RESULT(yes)
740                 AC_DEFINE(HAVE_NETDEV_PHYS_PORT_ID, 1,
741                           [netdev_phys_port_id is defined])
742         ],[
743                 AC_MSG_RESULT(no)
744         ])
745
746         AC_MSG_CHECKING([if struct ifla_vf_info has linkstate])
747         LB_LINUX_TRY_COMPILE([
748                 #include <linux/if_link.h>
749         ],[
750                 struct ifla_vf_info *x;
751                 x->linkstate = 0;
752
753                 return 0;
754         ],[
755                 AC_MSG_RESULT(yes)
756                 AC_DEFINE(HAVE_LINKSTATE, 1,
757                           [linkstate is defined])
758         ],[
759                 AC_MSG_RESULT(no)
760         ])
761
762         AC_MSG_CHECKING([if busy_poll.h has skb_mark_napi_id])
763         LB_LINUX_TRY_COMPILE([
764                 #include <net/busy_poll.h>
765         ],[
766                 skb_mark_napi_id(NULL, NULL);
767
768                 return 0;
769         ],[
770                 AC_MSG_RESULT(yes)
771                 AC_DEFINE(HAVE_SKB_MARK_NAPI_ID, 1,
772                           [skb_mark_napi_id is defined])
773         ],[
774                 AC_MSG_RESULT(no)
775         ])
776
777         AC_MSG_CHECKING([if netdevice.h has napi_hash_add])
778         LB_LINUX_TRY_COMPILE([
779                 #include <linux/netdevice.h>
780         ],[
781                 napi_hash_add(NULL);
782
783                 return 0;
784         ],[
785                 AC_MSG_RESULT(yes)
786                 AC_DEFINE(HAVE_NAPI_HASH_ADD, 1,
787                           [napi_hash_add is defined])
788         ],[
789                 AC_MSG_RESULT(no)
790         ])
791
792         AC_MSG_CHECKING([if netdevice.h has netif_keep_dst])
793         LB_LINUX_TRY_COMPILE([
794                 #include <linux/netdevice.h>
795         ],[
796                 netif_keep_dst(NULL);
797
798                 return 0;
799         ],[
800                 AC_MSG_RESULT(yes)
801                 AC_DEFINE(HAVE_NETIF_KEEP_DST, 1,
802                           [netif_keep_dst is defined])
803         ],[
804                 AC_MSG_RESULT(no)
805         ])
806
807         AC_MSG_CHECKING([if netdevice.h has dev_consume_skb_any])
808         LB_LINUX_TRY_COMPILE([
809                 #include <linux/netdevice.h>
810         ],[
811                 dev_consume_skb_any(NULL);
812
813                 return 0;
814         ],[
815                 AC_MSG_RESULT(yes)
816                 AC_DEFINE(HAVE_DEV_CONSUME_SKB_ANY, 1,
817                           [dev_consume_skb_any is defined])
818         ],[
819                 AC_MSG_RESULT(no)
820         ])
821
822         AC_MSG_CHECKING([if netdevice.h has netdev_txq_bql_complete_prefetchw])
823         LB_LINUX_TRY_COMPILE([
824                 #include <linux/netdevice.h>
825         ],[
826                 netdev_txq_bql_complete_prefetchw(NULL);
827                 netdev_txq_bql_enqueue_prefetchw(NULL);
828
829                 return 0;
830         ],[
831                 AC_MSG_RESULT(yes)
832                 AC_DEFINE(HAVE_NETDEV_TXQ_BQL_PREFETCHW, 1,
833                           [netdev_txq_bql_complete_prefetchw is defined])
834         ],[
835                 AC_MSG_RESULT(no)
836         ])
837
838         AC_MSG_CHECKING([if struct sk_buff has xmit_more])
839         LB_LINUX_TRY_COMPILE([
840                 #include <linux/skbuff.h>
841         ],[
842                 struct sk_buff *skb;
843                 skb->xmit_more = 0;
844
845                 return 0;
846         ],[
847                 AC_MSG_RESULT(yes)
848                 AC_DEFINE(HAVE_SK_BUFF_XMIT_MORE, 1,
849                           [xmit_more is defined])
850         ],[
851                 AC_MSG_RESULT(no)
852         ])
853
854         AC_MSG_CHECKING([if struct sk_buff has encapsulation])
855         LB_LINUX_TRY_COMPILE([
856                 #include <linux/skbuff.h>
857         ],[
858                 struct sk_buff *skb;
859                 skb->encapsulation = 0;
860
861                 return 0;
862         ],[
863                 AC_MSG_RESULT(yes)
864                 AC_DEFINE(HAVE_SK_BUFF_ENCAPSULATION, 1,
865                           [encapsulation is defined])
866         ],[
867                 AC_MSG_RESULT(no)
868         ])
869
870         AC_MSG_CHECKING([if etherdevice.h has eth_get_headlen])
871         LB_LINUX_TRY_COMPILE([
872                 #include <linux/etherdevice.h>
873         ],[
874                 eth_get_headlen(NULL, 0);
875
876                 return 0;
877         ],[
878                 AC_MSG_RESULT(yes)
879                 AC_DEFINE(HAVE_ETH_GET_HEADLEN, 1,
880                           [eth_get_headlen is defined])
881         ],[
882                 AC_MSG_RESULT(no)
883         ])
884
885         AC_MSG_CHECKING([if struct sk_buff has csum_level])
886         LB_LINUX_TRY_COMPILE([
887                 #include <linux/skbuff.h>
888         ],[
889                 struct sk_buff *skb;
890                 skb->csum_level = 0;
891
892                 return 0;
893         ],[
894                 AC_MSG_RESULT(yes)
895                 AC_DEFINE(HAVE_SK_BUFF_CSUM_LEVEL, 1,
896                           [csum_level is defined])
897         ],[
898                 AC_MSG_RESULT(no)
899         ])
900
901         AC_MSG_CHECKING([if struct skbuff.h has skb_inner_transport_header])
902         LB_LINUX_TRY_COMPILE([
903                 #include <linux/skbuff.h>
904         ],[
905                 skb_inner_transport_header(NULL);
906
907                 return 0;
908         ],[
909                 AC_MSG_RESULT(yes)
910                 AC_DEFINE(HAVE_SKB_INNER_TRANSPORT_HEADER, 1,
911                           [skb_inner_transport_header is defined])
912         ],[
913                 AC_MSG_RESULT(no)
914         ])
915
916         AC_MSG_CHECKING([if struct skbuff.h has skb_inner_network_header])
917         LB_LINUX_TRY_COMPILE([
918                 #include <linux/skbuff.h>
919         ],[
920                 skb_inner_network_header(NULL);
921
922                 return 0;
923         ],[
924                 AC_MSG_RESULT(yes)
925                 AC_DEFINE(HAVE_SKB_INNER_NETWORK_HEADER, 1,
926                           [skb_inner_network_header is defined])
927         ],[
928                 AC_MSG_RESULT(no)
929         ])
930
931         AC_MSG_CHECKING([if if_vlan.h has vlan_dev_get_egress_qos_mask])
932         LB_LINUX_TRY_COMPILE([
933                 #include <linux/if_vlan.h>
934         ],[
935                 vlan_dev_get_egress_qos_mask(NULL, 0);
936
937                 return 0;
938         ],[
939                 AC_MSG_RESULT(yes)
940                 AC_DEFINE(HAVE_VLAN_DEV_GET_EGRESS_QOS_MASK, 1,
941                           [vlan_dev_get_egress_qos_mask is defined])
942         ],[
943                 AC_MSG_RESULT(no)
944         ])
945
946         AC_MSG_CHECKING([if netdevice.h has netdev_get_prio_tc_map])
947         LB_LINUX_TRY_COMPILE([
948                 #include <linux/netdevice.h>
949         ],[
950                 netdev_get_prio_tc_map(NULL, 0);
951
952                 return 0;
953         ],[
954                 AC_MSG_RESULT(yes)
955                 AC_DEFINE(HAVE_NETDEV_GET_PRIO_TC_MAP, 1,
956                           [netdev_get_prio_tc_map is defined])
957         ],[
958                 AC_MSG_RESULT(no)
959         ])
960
961         AC_MSG_CHECKING([if if_vlan.h has __vlan_find_dev_deep_rcu])
962         LB_LINUX_TRY_COMPILE([
963                 #include <linux/if_vlan.h>
964         ],[
965                 __vlan_find_dev_deep_rcu(NULL, 0, 0);
966
967                 return 0;
968         ],[
969                 AC_MSG_RESULT(yes)
970                 AC_DEFINE(HAVE___VLAN_FIND_DEV_DEEP_RCU, 1,
971                           [__vlan_find_dev_deep_rcu is defined])
972         ],[
973                 AC_MSG_RESULT(no)
974         ])
975
976         AC_MSG_CHECKING([if ndo_select_queue has accel_priv])
977         LB_LINUX_TRY_COMPILE([
978                 #include <linux/netdevice.h>
979
980                 static u16 select_queue(struct net_device *dev, struct sk_buff *skb,
981                                         void *accel_priv)
982                 {
983                         return 0;
984                 }
985         ],[
986                 struct net_device_opts ndops;
987
988                 ndops.ndo_select_queue = select_queue;
989
990                 return 0;
991         ],[
992                 AC_MSG_RESULT(yes)
993                 AC_DEFINE(NDO_SELECT_QUEUE_HAS_ACCEL_PRIV, 1,
994                           [ndo_select_queue has accel_priv])
995         ],[
996                 AC_MSG_RESULT(no)
997         ])
998
999         AC_MSG_CHECKING([if include/net/bonding.h exists])
1000         LB_LINUX_TRY_COMPILE([
1001                 #include <net/bonding.h>
1002         ],[
1003                 return 0;
1004         ],[
1005                 AC_MSG_RESULT(yes)
1006                 AC_DEFINE(HAVE_BONDING_H, 1,
1007                           [include/net/bonding.h exists])
1008         ],[
1009                 AC_MSG_RESULT(no)
1010         ])
1011
1012         AC_MSG_CHECKING([if bonding.h bond_for_each_slave has 3 parameters])
1013         LB_LINUX_TRY_COMPILE([
1014                 #include "../drivers/net/bonding/bonding.h"
1015         ],[
1016                 struct bonding *bond = NULL;
1017                 struct list_head *iter = NULL;
1018                 struct slave *slave = NULL;
1019
1020                 bond_for_each_slave(bond, slave, iter) ;
1021
1022                 return 0;
1023         ],[
1024                 AC_MSG_RESULT(yes)
1025                 AC_DEFINE(HAVE_BOND_FOR_EACH_SLAVE_3_PARAMS, 1,
1026                           [bond_for_each_slave has 3 parameters])
1027         ],[
1028                 AC_MSG_RESULT(no)
1029         ])
1030
1031
1032         AC_MSG_CHECKING([if u64_stats_sync.h has u64_stats_init])
1033         LB_LINUX_TRY_COMPILE([
1034                 #include <linux/u64_stats_sync.h>
1035         ],[
1036                 struct u64_stats_sync sync;
1037                 u64_stats_init(&sync);
1038
1039                 return 0;
1040         ],[
1041                 AC_MSG_RESULT(yes)
1042                 AC_DEFINE(HAVE_U64_STATS_SYNC, 1,
1043                           [u64_stats_sync is defined])
1044         ],[
1045                 AC_MSG_RESULT(no)
1046         ])
1047
1048         AC_MSG_CHECKING([if u64_stats_sync.h has u64_stats_fetch_begin_irq])
1049         LB_LINUX_TRY_COMPILE([
1050                 #include <linux/u64_stats_sync.h>
1051         ],[
1052                 struct u64_stats_sync sync;
1053                 u64_stats_fetch_begin_irq(&sync);
1054
1055                 return 0;
1056         ],[
1057                 AC_MSG_RESULT(yes)
1058                 AC_DEFINE(HAVE_U64_STATS_FETCH_BEGIN_IRQ, 1,
1059                           [u64_stats_fetch_begin_irq is defined])
1060         ],[
1061                 AC_MSG_RESULT(no)
1062         ])
1063         AC_MSG_CHECKING([if etherdevice.h has ether_addr_copy])
1064         LB_LINUX_TRY_COMPILE([
1065                 #include <linux/etherdevice.h>
1066         ],[
1067                 char dest[6], src[6];
1068                 ether_addr_copy(&dest, &src);
1069
1070                 return 0;
1071         ],[
1072                 AC_MSG_RESULT(yes)
1073                 AC_DEFINE(HAVE_ETHER_ADDR_COPY, 1,
1074                           [ether_addr_copy is defined])
1075         ],[
1076                 AC_MSG_RESULT(no)
1077         ])
1078
1079         AC_MSG_CHECKING([if struct net_device_ops has *ndo_set_vf_rate])
1080         LB_LINUX_TRY_COMPILE([
1081                 #include <linux/netdevice.h>
1082
1083                 int set_vf_rate(struct net_device *dev, int vf, int min_tx_rate,
1084                                                    int max_tx_rate)
1085                 {
1086                         return 0;
1087                 }
1088         ],[
1089                 struct net_device_ops netdev_ops;
1090
1091                 netdev_ops.ndo_set_vf_rate = set_vf_rate;
1092                 return 0;
1093         ],[
1094                 AC_MSG_RESULT(yes)
1095                 AC_DEFINE(HAVE_SET_VF_RATE, 1,
1096                           [ndo_set_vf_rate is defined])
1097         ],[
1098                 AC_MSG_RESULT(no)
1099         ])
1100
1101         AC_MSG_CHECKING([if netdev_extended has hw_features])
1102         LB_LINUX_TRY_COMPILE([
1103                 #include <linux/netdevice.h>
1104         ],[
1105                 struct net_device *dev = NULL;
1106
1107                 netdev_extended(dev)->hw_features = 0;
1108
1109                 return 0;
1110         ],[
1111                 AC_MSG_RESULT(yes)
1112                 AC_DEFINE(HAVE_NETDEV_EXTENDED_HW_FEATURES, 1,
1113                           [ is defined])
1114         ],[
1115                 AC_MSG_RESULT(no)
1116         ])
1117
1118         AC_MSG_CHECKING([if net_device_extended has _tx_ext])
1119         LB_LINUX_TRY_COMPILE([
1120                 #include <linux/netdevice.h>
1121         ],[
1122                 struct net_device *dev = NULL;
1123
1124                 netdev_extended(dev)->_tx_ext = NULL;
1125
1126                 return 0;
1127         ],[
1128                 AC_MSG_RESULT(yes)
1129                 AC_DEFINE(HAVE_NET_DEVICE_EXTENDED_TX_EXT, 1,
1130                           [ is defined])
1131         ],[
1132                 AC_MSG_RESULT(no)
1133         ])
1134
1135         AC_MSG_CHECKING([if net_device_extended has ndo_busy_poll])
1136         LB_LINUX_TRY_COMPILE([
1137                 #include <linux/netdevice.h>
1138
1139                 int busy_poll(struct napi_struct *napi)
1140                 {
1141                         return 0;
1142                 }
1143         ],[
1144                 struct net_device *dev = NULL;
1145
1146                 netdev_extended(dev)->ndo_busy_poll = busy_poll;
1147
1148                 return 0;
1149         ],[
1150                 AC_MSG_RESULT(yes)
1151                 AC_DEFINE(HAVE_NETDEV_EXTENDED_NDO_BUSY_POLL, 1,
1152                           [ is defined])
1153         ],[
1154                 AC_MSG_RESULT(no)
1155         ])
1156
1157         AC_MSG_CHECKING([if netdevice.h has set_netdev_hw_features])
1158         LB_LINUX_TRY_COMPILE([
1159                 #include <linux/netdevice.h>
1160         ],[
1161                 struct net_device *dev = NULL;
1162
1163                 set_netdev_hw_features(dev, 0);
1164
1165                 return 0;
1166         ],[
1167                 AC_MSG_RESULT(yes)
1168                 AC_DEFINE(HAVE_SET_NETDEV_HW_FEATURES, 1,
1169                           [ is defined])
1170         ],[
1171                 AC_MSG_RESULT(no)
1172         ])
1173
1174         AC_MSG_CHECKING([if netdevice.h has netif_set_xps_queue])
1175         LB_LINUX_TRY_COMPILE([
1176                 #include <linux/netdevice.h>
1177         ],[
1178                 struct net_device *dev = NULL;
1179
1180                 netif_set_xps_queue(dev, NULL, 0);
1181
1182                 return 0;
1183         ],[
1184                 AC_MSG_RESULT(yes)
1185                 AC_DEFINE(HAVE_NETIF_SET_XPS_QUEUE, 1,
1186                           [ is defined])
1187         ],[
1188                 AC_MSG_RESULT(no)
1189         ])
1190
1191
1192         AC_MSG_CHECKING([if struct net_device_ops has *ndo_set_features])
1193         LB_LINUX_TRY_COMPILE([
1194                 #include <linux/netdevice.h>
1195
1196                 int set_features(struct net_device *dev, netdev_features_t features)
1197                 {
1198                         return 0;
1199                 }
1200         ],[
1201                 struct net_device_ops netdev_ops;
1202
1203                 netdev_ops.ndo_set_features = set_features;
1204                 return 0;
1205         ],[
1206                 AC_MSG_RESULT(yes)
1207                 AC_DEFINE(HAVE_NDO_SET_FEATURES, 1,
1208                           [ndo_set_features is defined])
1209         ],[
1210                 AC_MSG_RESULT(no)
1211         ])
1212
1213         AC_MSG_CHECKING([if struct net_device_ops has *ndo_setup_tc])
1214         LB_LINUX_TRY_COMPILE([
1215                 #include <linux/netdevice.h>
1216         ],[
1217                 struct net_device_ops x = {
1218                         .ndo_setup_tc = NULL,
1219                 };
1220
1221                 return 0;
1222         ],[
1223                 AC_MSG_RESULT(yes)
1224                 AC_DEFINE(HAVE_NDO_SETUP_TC, 1,
1225                           [ndo_setup_tc is defined])
1226         ],[
1227                 AC_MSG_RESULT(no)
1228         ])
1229
1230         AC_MSG_CHECKING([if struct net_device_ops has *ndo_rx_flow_steer])
1231         LB_LINUX_TRY_COMPILE([
1232                 #include <linux/netdevice.h>
1233
1234                 int rx_flow_steer(struct net_device *dev,
1235                                                      const struct sk_buff *skb,
1236                                                      u16 rxq_index,
1237                                                      u32 flow_id)
1238                 {
1239                         return 0;
1240                 }
1241         ],[
1242                 struct net_device_ops netdev_ops;
1243
1244                 netdev_ops.ndo_rx_flow_steer = rx_flow_steer;
1245                 return 0;
1246         ],[
1247                 AC_MSG_RESULT(yes)
1248                 AC_DEFINE(HAVE_NDO_RX_FLOW_STEER, 1,
1249                           [ndo_rx_flow_steer is defined])
1250         ],[
1251                 AC_MSG_RESULT(no)
1252         ])
1253
1254         AC_MSG_CHECKING([if struct net_device has priv_flags])
1255         LB_LINUX_TRY_COMPILE([
1256                 #include <linux/netdevice.h>
1257         ],[
1258                 struct net_device *netdev;
1259                 netdev->priv_flags = 0;
1260
1261                 return 0;
1262         ],[
1263                 AC_MSG_RESULT(yes)
1264                 AC_DEFINE(HAVE_NET_DEVICE_PRIV_FLAGS, 1,
1265                           [priv_flags is defined])
1266         ],[
1267                 AC_MSG_RESULT(no)
1268         ])
1269
1270         AC_MSG_CHECKING([if struct net_device_ops has *ndo_get_stats64])
1271         LB_LINUX_TRY_COMPILE([
1272                 #include <linux/netdevice.h>
1273
1274                 struct rtnl_link_stats64* get_stats_64(struct net_device *dev,
1275                                                      struct rtnl_link_stats64 *storage)
1276                 {
1277                         struct rtnl_link_stats64 stats_64;
1278                         return &stats_64;
1279                 }
1280         ],[
1281                 struct net_device_ops netdev_ops;
1282
1283                 netdev_ops.ndo_get_stats64 = get_stats_64;
1284
1285                 return 0;
1286         ],[
1287                 AC_MSG_RESULT(yes)
1288                 AC_DEFINE(HAVE_NDO_GET_STATS64, 1,
1289                           [ndo_get_stats64 is defined])
1290         ],[
1291                 AC_MSG_RESULT(no)
1292         ])
1293         AC_MSG_CHECKING([if struct net_device_ops has ndo_bridge_set/getlink])
1294         LB_LINUX_TRY_COMPILE([
1295                 #include <linux/netdevice.h>
1296         ],[
1297                 struct net_device_ops netdev_ops =  {
1298                         .ndo_bridge_setlink = NULL,
1299                         .ndo_bridge_getlink = NULL,
1300                 };
1301
1302                 return 0;
1303         ],[
1304                 AC_MSG_RESULT(yes)
1305                 AC_DEFINE(HAVE_NDO_BRIDGE_SET_GET_LINK, 1,
1306                           [ndo_bridge_set/getlink is defined])
1307         ],[
1308                 AC_MSG_RESULT(no)
1309         ])
1310
1311         AC_MSG_CHECKING([if rtnetlink.h ndo_dflt_bridge_getlink has 7 params])
1312         LB_LINUX_TRY_COMPILE([
1313                 #include <linux/rtnetlink.h>
1314         ],[
1315                 ndo_dflt_bridge_getlink(NULL, 0, 0, NULL, 0, 0, 0);
1316
1317                 return 0;
1318         ],[
1319                 AC_MSG_RESULT(yes)
1320                 AC_DEFINE(HAVE_NDO_DFLT_BRIDGE_GETLINK_7_PARAMS, 1,
1321                         [ ndo_dflt_bridge_getlink with 7 params is defined])
1322         ],[
1323                 AC_MSG_RESULT(no)
1324         ])
1325
1326         AC_MSG_CHECKING([if struct net_device_ops ndo_vlan_rx_add_vid has 3 parameters ])
1327         LB_LINUX_TRY_COMPILE([
1328                 #include <linux/netdevice.h>
1329
1330         ],[
1331                 int vlan_rx_add_vid(struct net_device *dev,__be16 proto, u16 vid)
1332                 {
1333                         return 0;
1334                 }
1335                 struct net_device_ops netdev_ops;
1336
1337                 netdev_ops.ndo_vlan_rx_add_vid = vlan_rx_add_vid;
1338                 netdev_ops.ndo_vlan_rx_add_vid (NULL, 1, 1) ;
1339
1340                 return 0;
1341         ],[
1342                 AC_MSG_RESULT(yes)
1343                 AC_DEFINE(HAVE_NDO_RX_ADD_VID_HAS_3_PARAMS, 1,
1344                           [ndo_vlan_rx_add_vid has 3 parameters])
1345         ],[
1346                 AC_MSG_RESULT(no)
1347         ])
1348
1349         AC_MSG_CHECKING([if net_device_ops has ndo_get_phys_port_id])
1350         LB_LINUX_TRY_COMPILE([
1351                 #include <linux/netdevice.h>
1352
1353                 int get_phys_port_id(struct net_device *dev,
1354                                      struct netdev_phys_port_id *ppid)
1355                 {
1356                         return 0;
1357                 }
1358         ],[
1359                 struct net_device_ops netdev_ops;
1360
1361                 netdev_ops.ndo_get_phys_port_id = get_phys_port_id;
1362
1363                 return 0;
1364         ],[
1365                 AC_MSG_RESULT(yes)
1366                 AC_DEFINE(HAVE_NETDEV_NDO_GET_PHYS_PORT_ID, 1,
1367                           [ is defined])
1368         ],[
1369                 AC_MSG_RESULT(no)
1370         ])
1371
1372         AC_MSG_CHECKING([if struct net_device_ops_ext exist])
1373         LB_LINUX_TRY_COMPILE([
1374                 #include <linux/netdevice.h>
1375         ],[
1376                 struct net_device_ops_ext netdev_ops_ext = {
1377                         .size = sizeof(struct net_device_ops_ext),
1378                 };
1379
1380                 return 0;
1381         ],[
1382                 AC_MSG_RESULT(yes)
1383                 AC_DEFINE(HAVE_NET_DEVICE_OPS_EXT, 1,
1384                           [struct net_device_ops_ext is defined])
1385         ],[
1386                 AC_MSG_RESULT(no)
1387         ])
1388
1389         AC_MSG_CHECKING([if net_device_ops_ext has ndo_get_phys_port_id])
1390         LB_LINUX_TRY_COMPILE([
1391                 #include <linux/netdevice.h>
1392
1393                 int get_phys_port_id(struct net_device *dev,
1394                                      struct netdev_phys_port_id *ppid)
1395                 {
1396                         return 0;
1397                 }
1398         ],[
1399                 struct net_device_ops_ext netdev_ops_ext;
1400
1401                 netdev_ops_ext.ndo_get_phys_port_id = get_phys_port_id;
1402
1403                 return 0;
1404         ],[
1405                 AC_MSG_RESULT(yes)
1406                 AC_DEFINE(HAVE_NETDEV_EXT_NDO_GET_PHYS_PORT_ID, 1,
1407                           [ndo_get_phys_port_id is defined])
1408         ],[
1409                 AC_MSG_RESULT(no)
1410         ])
1411
1412         AC_MSG_CHECKING([if net_device_ops has ndo_set_vf_spoofchk])
1413         LB_LINUX_TRY_COMPILE([
1414                 #include <linux/netdevice.h>
1415
1416                 int set_vf_spoofchk(struct net_device *dev, int vf, bool setting)
1417                 {
1418                         return 0;
1419                 }
1420         ],[
1421                 struct net_device_ops netdev_ops;
1422
1423                 netdev_ops.ndo_set_vf_spoofchk = set_vf_spoofchk;
1424
1425                 return 0;
1426         ],[
1427                 AC_MSG_RESULT(yes)
1428                 AC_DEFINE(HAVE_NETDEV_OPS_NDO_SET_VF_SPOOFCHK, 1,
1429                           [ndo_set_vf_spoofchk is defined in net_device_ops])
1430         ],[
1431                 AC_MSG_RESULT(no)
1432         ])
1433
1434         AC_MSG_CHECKING([if net_device_ops_ext has ndo_set_vf_spoofchk])
1435         LB_LINUX_TRY_COMPILE([
1436                 #include <linux/netdevice.h>
1437
1438                 int set_vf_spoofchk(struct net_device *dev, int vf, bool setting)
1439                 {
1440                         return 0;
1441                 }
1442         ],[
1443                 struct net_device_ops_ext netdev_ops_ext;
1444
1445                 netdev_ops_ext.ndo_set_vf_spoofchk = set_vf_spoofchk;
1446
1447                 return 0;
1448         ],[
1449                 AC_MSG_RESULT(yes)
1450                 AC_DEFINE(HAVE_NETDEV_OPS_EXT_NDO_SET_VF_SPOOFCHK, 1,
1451                           [ndo_set_vf_spoofchk is defined in net_device_ops_ext])
1452         ],[
1453                 AC_MSG_RESULT(no)
1454         ])
1455
1456         AC_MSG_CHECKING([if net_device_ops has ndo_set_vf_link_state])
1457         LB_LINUX_TRY_COMPILE([
1458                 #include <linux/netdevice.h>
1459
1460                 int set_vf_link_state(struct net_device *dev, int vf, int link_state)
1461                 {
1462                         return 0;
1463                 }
1464         ],[
1465                 struct net_device_ops netdev_ops;
1466
1467                 netdev_ops.ndo_set_vf_link_state = set_vf_link_state;
1468
1469                 return 0;
1470         ],[
1471                 AC_MSG_RESULT(yes)
1472                 AC_DEFINE(HAVE_NETDEV_OPS_NDO_SET_VF_LINK_STATE, 1,
1473                           [ndo_set_vf_link_state is defined in net_device_ops])
1474         ],[
1475                 AC_MSG_RESULT(no)
1476         ])
1477
1478         AC_MSG_CHECKING([if net_device_ops_ext has ndo_set_vf_link_state])
1479         LB_LINUX_TRY_COMPILE([
1480                 #include <linux/netdevice.h>
1481
1482                 int set_vf_link_state(struct net_device *dev, int vf, int link_state)
1483                 {
1484                         return 0;
1485                 }
1486         ],[
1487                 struct net_device_ops_ext netdev_ops_ext;
1488
1489                 netdev_ops_ext.ndo_set_vf_link_state = set_vf_link_state;
1490
1491                 return 0;
1492         ],[
1493                 AC_MSG_RESULT(yes)
1494                 AC_DEFINE(HAVE_NETDEV_OPS_EXT_NDO_SET_VF_LINK_STATE, 1,
1495                           [ndo_set_vf_link_state is defined])
1496         ],[
1497                 AC_MSG_RESULT(no)
1498         ])
1499
1500
1501         AC_MSG_CHECKING([if netdevice.h netif_set_real_num_tx_queues returns int])
1502         LB_LINUX_TRY_COMPILE([
1503                 #include <linux/netdevice.h>
1504         ],[
1505                 struct net_device dev;
1506                 int ret;
1507                 ret = netif_set_real_num_tx_queues(&dev, 2);
1508                 return 0;
1509         ],[
1510                 AC_MSG_RESULT(yes)
1511                 AC_DEFINE(HAVE_RETURN_INT_FOR_SET_NUM_TX_QUEUES, 1,
1512                           [netif_set_real_num_tx_queues returns int])
1513         ],[
1514                 AC_MSG_RESULT(no)
1515         ])
1516
1517         AC_MSG_CHECKING([if struct netdevice.h has struct xps_map])
1518         LB_LINUX_TRY_COMPILE([
1519                 #include <linux/netdevice.h>
1520         ],[
1521                 struct xps_map map;
1522                 map.len = 0;
1523
1524                 return 0;
1525         ],[
1526                 AC_MSG_RESULT(yes)
1527                 AC_DEFINE(HAVE_XPS_MAP, 1,
1528                           [struct xps_map is defined])
1529         ],[
1530                 AC_MSG_RESULT(no)
1531         ])
1532
1533         AC_MSG_CHECKING([if struct ethtool_ops has set_phys_id])
1534         LB_LINUX_TRY_COMPILE([
1535                 #include <linux/ethtool.h>
1536         ],[
1537                 const struct ethtool_ops en_ethtool_ops = {
1538                         .set_phys_id= NULL,
1539                 };
1540
1541                 return 0;
1542         ],[
1543                 AC_MSG_RESULT(yes)
1544                 AC_DEFINE(HAVE_SET_PHYS_ID, 1,
1545                           [set_phys_id is defined])
1546         ],[
1547                 AC_MSG_RESULT(no)
1548         ])
1549
1550         AC_MSG_CHECKING([if struct ethtool_ops has get/set_channels])
1551         LB_LINUX_TRY_COMPILE([
1552                 #include <linux/ethtool.h>
1553         ],[
1554                 const struct ethtool_ops en_ethtool_ops = {
1555                         .get_channels = NULL,
1556                         .set_channels = NULL,
1557                 };
1558
1559                 return 0;
1560         ],[
1561                 AC_MSG_RESULT(yes)
1562                 AC_DEFINE(HAVE_GET_SET_CHANNELS, 1,
1563                           [get/set_channels is defined])
1564         ],[
1565                 AC_MSG_RESULT(no)
1566         ])
1567
1568         AC_MSG_CHECKING([if struct ethtool_ops_ext has get/set_channels])
1569         LB_LINUX_TRY_COMPILE([
1570                 #include <linux/ethtool.h>
1571         ],[
1572                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
1573                         .get_channels = NULL,
1574                         .set_channels = NULL,
1575                 };
1576
1577                 return 0;
1578         ],[
1579                 AC_MSG_RESULT(yes)
1580                 AC_DEFINE(HAVE_GET_SET_CHANNELS_EXT, 1,
1581                           [get/set_channels is defined in ethtool_ops_ext])
1582         ],[
1583                 AC_MSG_RESULT(no)
1584         ])
1585
1586         AC_MSG_CHECKING([if struct ethtool_ops has get_ts_info])
1587         LB_LINUX_TRY_COMPILE([
1588                 #include <linux/ethtool.h>
1589         ],[
1590                 const struct ethtool_ops en_ethtool_ops = {
1591                         .get_ts_info = NULL,
1592                 };
1593
1594                 return 0;
1595         ],[
1596                 AC_MSG_RESULT(yes)
1597                 AC_DEFINE(HAVE_GET_TS_INFO, 1,
1598                           [get_ts_info is defined])
1599         ],[
1600                 AC_MSG_RESULT(no)
1601         ])
1602
1603         AC_MSG_CHECKING([if linux/timecounter.h exists])
1604         LB_LINUX_TRY_COMPILE([
1605                 #include <linux/timecounter.h>
1606         ],[
1607                 return 0;
1608         ],[
1609                 AC_MSG_RESULT(yes)
1610                 AC_DEFINE(HAVE_TIMECOUNTER_H, 1,
1611                           [linux/timecounter.h exists])
1612         ],[
1613                 AC_MSG_RESULT(no)
1614         ])
1615
1616         # timecounter_adjtime can be in timecounter.h or clocksource.h
1617         AC_MSG_CHECKING([if linux/timecounter.h has timecounter_adjtime])
1618         LB_LINUX_TRY_COMPILE([
1619                 #include <linux/timecounter.h>
1620         ],[
1621                 struct timecounter x;
1622                 s64 y = 0;
1623                 timecounter_adjtime(&x, y);
1624
1625                 return 0;
1626         ],[
1627                 AC_MSG_RESULT(yes)
1628                 AC_DEFINE(HAVE_TIMECOUNTER_ADJTIME, 1,
1629                           [timecounter_adjtime is defined])
1630         ],[
1631                 AC_MSG_RESULT(no)
1632         ])
1633
1634         AC_MSG_CHECKING([if linux/clocksource.h has timecounter_adjtime])
1635         LB_LINUX_TRY_COMPILE([
1636                 #include <linux/clocksource.h>
1637         ],[
1638                 struct timecounter x;
1639                 s64 y = 0;
1640                 timecounter_adjtime(&x, y);
1641
1642                 return 0;
1643         ],[
1644                 AC_MSG_RESULT(yes)
1645                 AC_DEFINE(HAVE_TIMECOUNTER_ADJTIME, 1,
1646                           [timecounter_adjtime is defined])
1647         ],[
1648                 AC_MSG_RESULT(no)
1649         ])
1650
1651         AC_MSG_CHECKING([if struct ethtool_ops has set_dump])
1652         LB_LINUX_TRY_COMPILE([
1653                 #include <linux/ethtool.h>
1654         ],[
1655                 const struct ethtool_ops en_ethtool_ops = {
1656                         .set_dump = NULL,
1657                 };
1658
1659                 return 0;
1660         ],[
1661                 AC_MSG_RESULT(yes)
1662                 AC_DEFINE(HAVE_ETHTOOL_OPS_SET_DUMP, 1,
1663                           [set_dump is defined])
1664         ],[
1665                 AC_MSG_RESULT(no)
1666         ])
1667
1668         AC_MSG_CHECKING([if struct ethtool_ops has get_module_info])
1669         LB_LINUX_TRY_COMPILE([
1670                 #include <linux/ethtool.h>
1671         ],[
1672                 const struct ethtool_ops en_ethtool_ops = {
1673                         .get_module_info = NULL,
1674                 };
1675
1676                 return 0;
1677         ],[
1678                 AC_MSG_RESULT(yes)
1679                 AC_DEFINE(HAVE_ETHTOOL_OPS_GET_MODULE_INFO, 1,
1680                           [get_module_info is defined])
1681         ],[
1682                 AC_MSG_RESULT(no)
1683         ])
1684
1685         AC_MSG_CHECKING([if struct ethtool_ops has get_module_eeprom])
1686         LB_LINUX_TRY_COMPILE([
1687                 #include <linux/ethtool.h>
1688         ],[
1689                 const struct ethtool_ops en_ethtool_ops = {
1690                         .get_module_eeprom = NULL,
1691                 };
1692
1693                 return 0;
1694         ],[
1695                 AC_MSG_RESULT(yes)
1696                 AC_DEFINE(HAVE_ETHTOOL_OPS_GET_MODULE_EEPROM, 1,
1697                           [get_module_eeprom is defined])
1698         ],[
1699                 AC_MSG_RESULT(no)
1700         ])
1701
1702         AC_MSG_CHECKING([if struct ethtool_ops_ext has get_ts_info])
1703         LB_LINUX_TRY_COMPILE([
1704                 #include <linux/ethtool.h>
1705         ],[
1706                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
1707                         .get_ts_info = NULL,
1708                 };
1709
1710                 return 0;
1711         ],[
1712                 AC_MSG_RESULT(yes)
1713                 AC_DEFINE(HAVE_GET_TS_INFO_EXT, 1,
1714                           [get_ts_info is defined in ethtool_ops_ext])
1715         ],[
1716                 AC_MSG_RESULT(no)
1717         ])
1718
1719         AC_MSG_CHECKING([if struct ethtool_flow_ext has h_dest])
1720         LB_LINUX_TRY_COMPILE([
1721                 #include <linux/ethtool.h>
1722         ],[
1723                 unsigned char mac[ETH_ALEN];
1724                 struct ethtool_flow_ext h_ext;
1725
1726                 memcpy(&mac, h_ext.h_dest, ETH_ALEN);
1727
1728                 return 0;
1729         ],[
1730                 AC_MSG_RESULT(yes)
1731                 AC_DEFINE(HAVE_ETHTOOL_FLOW_EXT_H_DEST, 1,
1732                           [ethtool_flow_ext has h_dest])
1733         ],[
1734                 AC_MSG_RESULT(no)
1735         ])
1736
1737         AC_MSG_CHECKING([if netdevice.h has struct dev_addr_list])
1738         LB_LINUX_TRY_COMPILE([
1739                 #include <linux/netdevice.h>
1740         ],[
1741                 struct dev_addr_list addr;
1742                 return 0;
1743         ],[
1744                 AC_MSG_RESULT(yes)
1745                 AC_DEFINE(HAVE_NETDEV_DEV_ADDR, 1,
1746                           [dev_addr_list is defined])
1747         ],[
1748                 AC_MSG_RESULT(no)
1749         ])
1750
1751         AC_MSG_CHECKING([if pci.h has pci_vfs_assigned])
1752         LB_LINUX_TRY_COMPILE([
1753                 #include <linux/pci.h>
1754         ],[
1755                 struct pci_dev pdev;
1756                 pci_vfs_assigned(&pdev);
1757                 return 0;
1758         ],[
1759                 AC_MSG_RESULT(yes)
1760                 AC_DEFINE(HAVE_PCI_VF_ASSIGNED, 1,
1761                           [pci_vfs_assigned is defined])
1762         ],[
1763                 AC_MSG_RESULT(no)
1764         ])
1765
1766         AC_MSG_CHECKING([if vlan_insert_tag_set_proto is defined])
1767         LB_LINUX_TRY_COMPILE([
1768                 #include <linux/if_vlan.h>
1769         ],[
1770                 struct sk_buff *skb;
1771                 vlan_insert_tag_set_proto(skb, 0, 0);
1772                 return 0;
1773         ],[
1774                 AC_MSG_RESULT(yes)
1775                 AC_DEFINE(HAVE_VLAN_INSERT_TAG_SET_PROTO, 1,
1776                           [vlan_insert_tag_set_proto is defined])
1777         ],[
1778                 AC_MSG_RESULT(no)
1779                 AC_MSG_CHECKING([if __vlan_put_tag has 3 parameters])
1780                 LB_LINUX_TRY_COMPILE([
1781                         #include <linux/if_vlan.h>
1782                 ],[
1783                         struct sk_buff *skb;
1784                         __vlan_put_tag(skb, 0, 0);
1785                         return 0;
1786                 ],[
1787                         AC_MSG_RESULT(yes)
1788                         AC_DEFINE(HAVE_3_PARAMS_FOR_VLAN_PUT_TAG, 1,
1789                                   [__vlan_put_tag has 3 parameters])
1790                 ],[
1791                         AC_MSG_RESULT(no)
1792                 ])
1793         ])
1794
1795         AC_MSG_CHECKING([if __vlan_hwaccel_put_tag has 3 parameters])
1796         LB_LINUX_TRY_COMPILE([
1797                 #include <linux/if_vlan.h>
1798         ],[
1799                 struct sk_buff *skb;
1800                 __vlan_hwaccel_put_tag(skb, 0, 0);
1801
1802                 return 0;
1803         ],[
1804                 AC_MSG_RESULT(yes)
1805                 AC_DEFINE(HAVE_3_PARAMS_FOR_VLAN_HWACCEL_PUT_TAG, 1,
1806                           [__vlan_hwaccel_put_tag has 3 parameters])
1807         ],[
1808                 AC_MSG_RESULT(no)
1809         ])
1810
1811         AC_MSG_CHECKING([if struct inet6_ifaddr has if_next])
1812         LB_LINUX_TRY_COMPILE([
1813                 #include <net/if_inet6.h>
1814         ],[
1815                 struct inet6_ifaddr ifp ;
1816                 ifp.if_next = 0;
1817
1818                 return 0;
1819         ],[
1820                 AC_MSG_RESULT(yes)
1821                 AC_DEFINE(HAVE_INETADDR_IF_NEXT, 1,
1822                           [if_next is defined])
1823         ],[
1824                 AC_MSG_RESULT(no)
1825         ])
1826
1827         AC_MSG_CHECKING([if struct net_device has hw_features])
1828         LB_LINUX_TRY_COMPILE([
1829                 #include <linux/netdevice.h>
1830         ],[
1831                 struct net_device dev;
1832                 dev.hw_features = 0;
1833
1834                 return 0;
1835         ],[
1836                 AC_MSG_RESULT(yes)
1837                 AC_DEFINE(HAVE_NETDEV_HW_FEATURES, 1,
1838                           [hw_features is defined])
1839         ],[
1840                 AC_MSG_RESULT(no)
1841         ])
1842
1843         AC_MSG_CHECKING([if struct net_device has hw_enc_features])
1844         LB_LINUX_TRY_COMPILE([
1845                 #include <linux/netdevice.h>
1846         ],[
1847                 struct net_device dev;
1848                 dev.hw_enc_features = 0;
1849
1850                 return 0;
1851         ],[
1852                 AC_MSG_RESULT(yes)
1853                 AC_DEFINE(HAVE_NETDEV_HW_ENC_FEATURES, 1,
1854                           [hw_enc_features is defined])
1855         ],[
1856                 AC_MSG_RESULT(no)
1857         ])
1858
1859         AC_MSG_CHECKING([if struct net_device has rx_cpu_rmap])
1860         LB_LINUX_TRY_COMPILE([
1861                 #include <linux/netdevice.h>
1862         ],[
1863                 struct net_device dev;
1864                 dev.rx_cpu_rmap = NULL;
1865
1866                 return 0;
1867         ],[
1868                 AC_MSG_RESULT(yes)
1869                 AC_DEFINE(HAVE_NETDEV_RX_CPU_RMAP, 1,
1870                           [rx_cpu_rmap is defined])
1871         ],[
1872                 AC_MSG_RESULT(no)
1873         ])
1874
1875         AC_MSG_CHECKING([if if_vlan.h has vlan_hwaccel_receive_skb])
1876         LB_LINUX_TRY_COMPILE([
1877                 #include <linux/if_vlan.h>
1878         ],[
1879                 struct sk_buff *skb;
1880                 vlan_hwaccel_receive_skb(skb,0,0);
1881                 return 0;
1882         ],[
1883                 AC_MSG_RESULT(yes)
1884                 AC_DEFINE(HAVE_VLAN_HWACCEL_RECEIVE_SKB, 1,
1885                           [vlan_hwaccel_receive_skb is defined])
1886         ],[
1887                 AC_MSG_RESULT(no)
1888         ])
1889
1890         AC_MSG_CHECKING([if irqdesc.h has irq_desc_get_irq_data])
1891         LB_LINUX_TRY_COMPILE([
1892                 #include <linux/irq.h>
1893                 #include <linux/irqdesc.h>
1894         ],[
1895                 struct irq_desc desc;
1896                 struct irq_data *data = irq_desc_get_irq_data(&desc);
1897
1898                 return 0;
1899         ],[
1900                 AC_MSG_RESULT(yes)
1901                 AC_DEFINE(HAVE_IRQ_DESC_GET_IRQ_DATA, 1,
1902                           [irq_desc_get_irq_data is defined])
1903         ],[
1904                 AC_MSG_RESULT(no)
1905         ])
1906
1907
1908         AC_MSG_CHECKING([if pci_dev has pcie_mpss])
1909         LB_LINUX_TRY_COMPILE([
1910                 #include <linux/pci.h>
1911         ],[
1912                 struct pci_dev *pdev;
1913
1914                 pdev->pcie_mpss = 0;
1915                 return 0;
1916         ],[
1917                 AC_MSG_RESULT(yes)
1918                 AC_DEFINE(HAVE_PCI_DEV_PCIE_MPSS, 1,
1919                           [pcie_mpss is defined])
1920         ],[
1921                 AC_MSG_RESULT(no)
1922         ])
1923
1924         AC_MSG_CHECKING([if uapi/linux/if_ether.h exist])
1925         LB_LINUX_TRY_COMPILE([
1926                 #include <uapi/linux/if_ether.h>
1927         ],[
1928                 return 0;
1929         ],[
1930                 AC_MSG_RESULT(yes)
1931                 AC_DEFINE(HAVE_UAPI_LINUX_IF_ETHER_H, 1,
1932                           [uapi/linux/if_ether.h exist])
1933         ],[
1934                 AC_MSG_RESULT(no)
1935         ])
1936
1937         AC_MSG_CHECKING([if ifla_vf_info has spoofchk])
1938         LB_LINUX_TRY_COMPILE([
1939                 #include <linux/if_link.h>
1940         ],[
1941                 struct ifla_vf_info *ivf;
1942
1943                 ivf->spoofchk = 0;
1944                 return 0;
1945         ],[
1946                 AC_MSG_RESULT(yes)
1947                 AC_DEFINE(HAVE_VF_INFO_SPOOFCHK, 1,
1948                           [spoofchk is defined])
1949         ],[
1950                 AC_MSG_RESULT(no)
1951         ])
1952
1953         AC_MSG_CHECKING([if vxlan.h has vxlan_gso_check])
1954         LB_LINUX_TRY_COMPILE([
1955                 #include <net/vxlan.h>
1956         ],[
1957                 vxlan_gso_check(NULL);
1958
1959                 return 0;
1960         ],[
1961                 AC_MSG_RESULT(yes)
1962                 AC_DEFINE(HAVE_VXLAN_GSO_CHECK, 1,
1963                           [vxlan_gso_check is defined])
1964         ],[
1965                 AC_MSG_RESULT(no)
1966         ])
1967
1968         AC_MSG_CHECKING([if dst.h has dst_get_neighbour])
1969         LB_LINUX_TRY_COMPILE([
1970                 #include <net/dst.h>
1971         ],[
1972                 struct neighbour *neigh = dst_get_neighbour(NULL);
1973
1974                 return 0;
1975         ],[
1976                 AC_MSG_RESULT(yes)
1977                 AC_DEFINE(HAVE_DST_GET_NEIGHBOUR, 1,
1978                           [ is defined])
1979         ],[
1980                 AC_MSG_RESULT(no)
1981         ])
1982
1983         AC_MSG_CHECKING([if netlink_dump_start has 6 parameters])
1984         LB_LINUX_TRY_COMPILE([
1985                 #include <linux/netlink.h>
1986         ],[
1987                 int ret = netlink_dump_start(NULL, NULL, NULL, NULL, NULL, 0);
1988
1989                 return 0;
1990         ],[
1991                 AC_MSG_RESULT(yes)
1992                 AC_DEFINE(HAVE_NETLINK_DUMP_START_6P, 1,
1993                           [ is defined])
1994         ],[
1995                 AC_MSG_RESULT(no)
1996         ])
1997
1998         AC_MSG_CHECKING([if netlink_dump_start has 5 parameters])
1999         LB_LINUX_TRY_COMPILE([
2000                 #include <linux/netlink.h>
2001         ],[
2002                 int ret = netlink_dump_start(NULL, NULL, NULL, NULL, NULL);
2003
2004                 return 0;
2005         ],[
2006                 AC_MSG_RESULT(yes)
2007                 AC_DEFINE(HAVE_NETLINK_DUMP_START_5P, 1,
2008                           [ is defined])
2009         ],[
2010                 AC_MSG_RESULT(no)
2011         ])
2012
2013         AC_MSG_CHECKING([if struct dcbnl_rtnl_ops has ieee_getmaxrate/ieee_setmaxrate])
2014         LB_LINUX_TRY_COMPILE([
2015                 #include <net/dcbnl.h>
2016         ],[
2017                 const struct dcbnl_rtnl_ops en_dcbnl_ops = {
2018                         .ieee_getmaxrate = NULL,
2019                         .ieee_setmaxrate = NULL,
2020                 };
2021
2022                 return 0;
2023         ],[
2024                 AC_MSG_RESULT(yes)
2025                 AC_DEFINE(HAVE_IEEE_GET_SET_MAXRATE, 1,
2026                           [ieee_getmaxrate/ieee_setmaxrate is defined])
2027         ],[
2028                 AC_MSG_RESULT(no)
2029         ])
2030
2031         AC_LANG_PUSH(C)
2032         ac_c_werror_flag=yes
2033         save_EXTRA_KCFLAGS=$EXTRA_KCFLAGS
2034         EXTRA_KCFLAGS="$EXTRA_KCFLAGS -Werror"
2035
2036         AC_MSG_CHECKING([if bonding.h bond_for_each_slave has int for 3rd parameter])
2037         LB_LINUX_TRY_COMPILE([
2038                 #include "../drivers/net/bonding/bonding.h"
2039         ],[
2040                 struct bonding *bond = NULL;
2041                 struct slave *slave = NULL;
2042                 int iter;
2043
2044                 bond_for_each_slave(bond, slave, iter) ;
2045
2046                 return 0;
2047         ],[
2048                 AC_MSG_RESULT(yes)
2049                 AC_DEFINE(HAVE_BOND_FOR_EACH_SLAVE_3RD_PARAM_IS_INT, 1,
2050                           [bond_for_each_slave has int for 3rd parameter])
2051         ],[
2052                 AC_MSG_RESULT(no)
2053         ])
2054         EXTRA_KCFLAGS="$save_EXTRA_KCFLAGS"
2055         ac_c_werror_flag=
2056         AC_LANG_POP
2057
2058         AC_MSG_CHECKING([if netdevice.h has netdev_master_upper_dev_get_rcu])
2059         LB_LINUX_TRY_COMPILE([
2060                 #include <linux/netdevice.h>
2061         ],[
2062                 netdev_master_upper_dev_get_rcu(NULL);
2063
2064                 return 0;
2065         ],[
2066                 AC_MSG_RESULT(yes)
2067                 AC_DEFINE(HAVE_NETDEV_MASTER_UPPER_DEV_GET_RCU, 1,
2068                           [netdev_master_upper_dev_get_rcu is defined])
2069         ],[
2070                 AC_MSG_RESULT(no)
2071         ])
2072
2073         AC_MSG_CHECKING([if __vlan_find_dev_deep has 3 parameters])
2074         LB_LINUX_TRY_COMPILE([
2075                 #include <linux/if_vlan.h>
2076         ],[
2077                 __vlan_find_dev_deep(NULL, 0, 0);
2078
2079                 return 0;
2080         ],[
2081                 AC_MSG_RESULT(yes)
2082                 AC_DEFINE(HAVE__VLAN_FIND_DEV_DEEP_3P, 1,
2083                           [__vlan_find_dev_deep has 3 paramters])
2084         ],[
2085                 AC_MSG_RESULT(no)
2086         ])
2087
2088         AC_MSG_CHECKING([if sk_buff.h has __skb_alloc_page])
2089         LB_LINUX_TRY_COMPILE([
2090                 #include <linux/skbuff.h>
2091         ],[
2092                 __skb_alloc_page(0, NULL);
2093
2094                 return 0;
2095         ],[
2096                 AC_MSG_RESULT(yes)
2097                 AC_DEFINE(HAVE__SKB_ALLOC_PAGE, 1,
2098                           [sk_buff has __skb_alloc_page])
2099         ],[
2100                 AC_MSG_RESULT(no)
2101         ])
2102
2103         AC_MSG_CHECKING([if __vlan_hwaccel_put_tag has 3 parameters])
2104         LB_LINUX_TRY_COMPILE([
2105                 #include <linux/if_vlan.h>
2106         ],[
2107                 __vlan_hwaccel_put_tag(NULL, 0, 0);
2108
2109                 return 0;
2110         ],[
2111                 AC_MSG_RESULT(yes)
2112                 AC_DEFINE(HAVE__VLAN_HWACCEL_PUT_TAG_3P, 1,
2113                           [__vlan_hwaccel_put_tag has 3 paramters])
2114         ],[
2115                 AC_MSG_RESULT(no)
2116         ])
2117
2118         AC_MSG_CHECKING([if linux/mm_types.h has struct page_frag])
2119         LB_LINUX_TRY_COMPILE([
2120                 #include <linux/mm_types.h>
2121         ],[
2122                 struct page_frag frag = {0};
2123
2124                 return 0;
2125         ],[
2126                 AC_MSG_RESULT(yes)
2127                 AC_DEFINE(HAVE_MM_TYPES_PAGE_FRAG, 1,
2128                           [linux/mm_types.h has struct page_frag])
2129         ],[
2130                 AC_MSG_RESULT(no)
2131         ])
2132
2133         AC_MSG_CHECKING([if if_vlan.h has __vlan_find_dev_deep])
2134         LB_LINUX_TRY_COMPILE([
2135                 #include <linux/if_vlan.h>
2136         ],[
2137                 __vlan_find_dev_deep(NULL, 0);
2138
2139                 return 0;
2140         ],[
2141                 AC_MSG_RESULT(yes)
2142                 AC_DEFINE(HAVE___VLAN_FIND_DEV_DEEP, 1,
2143                           [__vlan_find_dev_deep is defined])
2144         ],[
2145                 AC_MSG_RESULT(no)
2146         ])
2147
2148         AC_MSG_CHECKING([if idr .h has idr_Alloc])
2149         LB_LINUX_TRY_COMPILE([
2150                 #include <linux/idr.h>
2151         ],[
2152                 idr_alloc(NULL, NULL, 0, 0, 0);
2153                 return 0;
2154         ],[
2155                 AC_MSG_RESULT(yes)
2156                 AC_DEFINE(HAVE_IDR_NEW_INTERFACE, 1,
2157                           [idr_Alloc is defined]) ],[
2158                 AC_MSG_RESULT(no)
2159         ])
2160
2161         AC_MSG_CHECKING([if completion.h has reinit_completion])
2162         LB_LINUX_TRY_COMPILE([
2163                 #include <linux/completion.h>
2164         ],[
2165                 struct completion c;
2166
2167                 reinit_completion(&c);
2168                 return 0;
2169         ],[
2170                 AC_MSG_RESULT(yes)
2171                 AC_DEFINE(HAVE_REINIT_COMPLETION, 1,
2172                           [reinit_completion is defined])
2173         ],[
2174                 AC_MSG_RESULT(no)
2175         ])
2176
2177         AC_MSG_CHECKING([if dma-mapping.h has dma_set_mask_and_coherent])
2178         LB_LINUX_TRY_COMPILE([
2179                 #include <linux/dma-mapping.h>
2180         ],[
2181                 dma_set_mask_and_coherent(NULL, 0);
2182
2183                 return 0;
2184         ],[
2185                 AC_MSG_RESULT(yes)
2186                 AC_DEFINE(HAVE_DMA_SET_MASK_AND_COHERENT, 1,
2187                           [dma_set_mask_and_coherent is defined])
2188         ],[
2189                 AC_MSG_RESULT(no)
2190         ])
2191
2192         AC_MSG_CHECKING([if in.h has proto_ports_offset])
2193         LB_LINUX_TRY_COMPILE([
2194                 #include <linux/in.h>
2195         ],[
2196                 int x = proto_ports_offset(IPPROTO_TCP);
2197                 return 0;
2198         ],[
2199                 AC_MSG_RESULT(yes)
2200                 AC_DEFINE(HAVE_PROTO_PORTS_OFFSET, 1,
2201                           [proto_ports_offset is defined])
2202         ],[
2203                 AC_MSG_RESULT(no)
2204         ])
2205
2206         LB_CHECK_SYMBOL_EXPORT([elfcorehdr_addr],
2207                 [kernel/crash_dump.c],
2208                 [AC_DEFINE(HAVE_ELFCOREHDR_ADDR_EXPORTED, 1,
2209                         [elfcorehdr_addr is exported by the kernel])],
2210         [])
2211
2212         AC_MSG_CHECKING([if netif_set_real_num_rx_queues is defined])
2213         LB_LINUX_TRY_COMPILE([
2214                 #include <linux/netdevice.h>
2215         ],[
2216                 int rc = netif_set_real_num_rx_queues(NULL, 0);
2217
2218                 return rc;
2219         ],[
2220                 AC_MSG_RESULT(yes)
2221                 AC_DEFINE(HAVE_NETIF_SET_REAL_NUM_RX_QUEUES, 1,
2222                           [netif_set_real_num_rx_queues is defined])
2223         ],[
2224                 AC_MSG_RESULT(no)
2225         ])
2226
2227         AC_MSG_CHECKING([if if_vlan.h has is_vlan_dev])
2228         LB_LINUX_TRY_COMPILE([
2229                 #include <linux/netdevice.h>
2230                 #include <linux/if_vlan.h>
2231         ],[
2232                 struct net_device dev;
2233                 is_vlan_dev(&dev);
2234
2235                 return 0;
2236         ],[
2237                 AC_MSG_RESULT(yes)
2238                 AC_DEFINE(HAVE_IS_VLAN_DEV, 1,
2239                           [is_vlan_dev is defined])
2240         ],[
2241                 AC_MSG_RESULT(no)
2242         ])
2243
2244         AC_MSG_CHECKING([if linux/timecounter.h exists])
2245         LB_LINUX_TRY_COMPILE([
2246                 #include <linux/timecounter.h>
2247         ],[
2248                 return 0;
2249         ],[
2250                 AC_MSG_RESULT(yes)
2251                 AC_DEFINE(HAVE_TIMECOUNTER_H, 1,
2252                           [linux/timecounter.h exists])
2253         ],[
2254                 AC_MSG_RESULT(no)
2255         ])
2256
2257         # timecounter_adjtime can be in timecounter.h or clocksource.h
2258         AC_MSG_CHECKING([if linux/timecounter.h has timecounter_adjtime])
2259         LB_LINUX_TRY_COMPILE([
2260                 #include <linux/timecounter.h>
2261         ],[
2262                 struct timecounter x;
2263                 s64 y = 0;
2264                 timecounter_adjtime(&x, y);
2265
2266                 return 0;
2267         ],[
2268                 AC_MSG_RESULT(yes)
2269                 AC_DEFINE(HAVE_TIMECOUNTER_ADJTIME, 1,
2270                           [timecounter_adjtime is defined])
2271         ],[
2272                 AC_MSG_RESULT(no)
2273         ])
2274
2275         AC_MSG_CHECKING([if linux/clocksource.h has timecounter_adjtime])
2276         LB_LINUX_TRY_COMPILE([
2277                 #include <linux/clocksource.h>
2278         ],[
2279                 struct timecounter x;
2280                 s64 y = 0;
2281                 timecounter_adjtime(&x, y);
2282
2283                 return 0;
2284         ],[
2285                 AC_MSG_RESULT(yes)
2286                 AC_DEFINE(HAVE_TIMECOUNTER_ADJTIME, 1,
2287                           [timecounter_adjtime is defined])
2288         ],[
2289                 AC_MSG_RESULT(no)
2290         ])
2291
2292         AC_MSG_CHECKING([if cyclecounter_cyc2ns has 4 parameters])
2293         LB_LINUX_TRY_COMPILE([
2294                 #include <linux/timecounter.h>
2295         ],[
2296                 cyclecounter_cyc2ns(NULL, NULL, 0, NULL);
2297
2298                 return 0;
2299         ],[
2300                 AC_MSG_RESULT(yes)
2301                 AC_DEFINE(HAVE_CYCLECOUNTER_CYC2NS_4_PARAMS, 1,
2302                           [cyclecounter_cyc2ns has 4 parameters])
2303         ],[
2304                 AC_MSG_RESULT(no)
2305         ])
2306
2307         AC_MSG_CHECKING([if netdevice.h struct net_device_ops has ndo_features_check])
2308         LB_LINUX_TRY_COMPILE([
2309                 #include <linux/netdevice.h>
2310         ],[
2311                 static const struct net_device_ops mlx4_netdev_ops = {
2312                         .ndo_features_check     = NULL,
2313                 };
2314
2315                 return 0;
2316         ],[
2317                 AC_MSG_RESULT(yes)
2318                 AC_DEFINE(HAVE_NETDEV_FEATURES_T, 1,
2319                           [netdev_features_t is defined])
2320         ],[
2321                 AC_MSG_RESULT(no)
2322         ])
2323
2324         AC_MSG_CHECKING([if struct ethtool_ops get_rxnfc gets u32 *rule_locs])
2325         LB_LINUX_TRY_COMPILE([
2326                 #include <linux/ethtool.h>
2327                 static int mlx4_en_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *c,
2328                                              u32 *rule_locs)
2329                 {
2330                         return 0;
2331                 }
2332         ],[
2333                 struct ethtool_ops x = {
2334                         .get_rxnfc = mlx4_en_get_rxnfc,
2335                 };
2336
2337                 return 0;
2338         ],[
2339                 AC_MSG_RESULT(yes)
2340                 AC_DEFINE(HAVE_ETHTOOL_OPS_GET_RXNFC_U32_RULE_LOCS, 1,
2341                           [ethtool_ops get_rxnfc gets u32 *rule_locs])
2342         ],[
2343                 AC_MSG_RESULT(no)
2344         ])
2345
2346         AC_MSG_CHECKING([if ethtool.h enum ethtool_stringset has ETH_SS_RSS_HASH_FUNCS])
2347         LB_LINUX_TRY_COMPILE([
2348                 #include <linux/ethtool.h>
2349         ],[
2350                 enum ethtool_stringset x = ETH_SS_RSS_HASH_FUNCS;
2351
2352                 return 0;
2353         ],[
2354                 AC_MSG_RESULT(yes)
2355                 AC_DEFINE(HAVE_ETH_SS_RSS_HASH_FUNCS, 1,
2356                           [ETH_SS_RSS_HASH_FUNCS is defined])
2357         ],[
2358                 AC_MSG_RESULT(no)
2359         ])
2360 ])
2361 #
2362 # COMPAT_CONFIG_HEADERS
2363 #
2364 # add -include config.h
2365 #
2366 AC_DEFUN([COMPAT_CONFIG_HEADERS],[
2367         AC_CONFIG_HEADERS([config.h])
2368         EXTRA_KCFLAGS="-include $PWD/config.h $EXTRA_KCFLAGS"
2369         AC_SUBST(EXTRA_KCFLAGS)
2370 ])
2371
2372 AC_DEFUN([OFA_PROG_LINUX],
2373 [
2374
2375 LB_LINUX_PATH
2376 LB_LINUX_SYMVERFILE
2377 LB_LINUX_CONFIG([MODULES],[],[
2378     AC_MSG_ERROR([module support is required to build mlnx kernel modules.])
2379 ])
2380 LB_LINUX_CONFIG([MODVERSIONS])
2381 LB_LINUX_CONFIG([KALLSYMS],[],[
2382     AC_MSG_ERROR([compat_mlnx requires that CONFIG_KALLSYMS is enabled in your kernel.])
2383 ])
2384
2385 LINUX_CONFIG_COMPAT
2386 COMPAT_CONFIG_HEADERS
2387
2388 ])