bd53a9793755217651f9c23e63a551d98d63dbb5
[~tnikolova/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 struct net_device_ops ndo_vlan_rx_add_vid has 3 parameters ])
1312         LB_LINUX_TRY_COMPILE([
1313                 #include <linux/netdevice.h>
1314
1315         ],[
1316                 int vlan_rx_add_vid(struct net_device *dev,__be16 proto, u16 vid)
1317                 {
1318                         return 0;
1319                 }
1320                 struct net_device_ops netdev_ops;
1321
1322                 netdev_ops.ndo_vlan_rx_add_vid = vlan_rx_add_vid;
1323                 netdev_ops.ndo_vlan_rx_add_vid (NULL, 1, 1) ;
1324
1325                 return 0;
1326         ],[
1327                 AC_MSG_RESULT(yes)
1328                 AC_DEFINE(HAVE_NDO_RX_ADD_VID_HAS_3_PARAMS, 1,
1329                           [ndo_vlan_rx_add_vid has 3 parameters])
1330         ],[
1331                 AC_MSG_RESULT(no)
1332         ])
1333
1334         AC_MSG_CHECKING([if net_device_ops has ndo_get_phys_port_id])
1335         LB_LINUX_TRY_COMPILE([
1336                 #include <linux/netdevice.h>
1337
1338                 int get_phys_port_id(struct net_device *dev,
1339                                      struct netdev_phys_port_id *ppid)
1340                 {
1341                         return 0;
1342                 }
1343         ],[
1344                 struct net_device_ops netdev_ops;
1345
1346                 netdev_ops.ndo_get_phys_port_id = get_phys_port_id;
1347
1348                 return 0;
1349         ],[
1350                 AC_MSG_RESULT(yes)
1351                 AC_DEFINE(HAVE_NETDEV_NDO_GET_PHYS_PORT_ID, 1,
1352                           [ is defined])
1353         ],[
1354                 AC_MSG_RESULT(no)
1355         ])
1356
1357         AC_MSG_CHECKING([if struct net_device_ops_ext exist])
1358         LB_LINUX_TRY_COMPILE([
1359                 #include <linux/netdevice.h>
1360         ],[
1361                 struct net_device_ops_ext netdev_ops_ext = {
1362                         .size = sizeof(struct net_device_ops_ext),
1363                 };
1364
1365                 return 0;
1366         ],[
1367                 AC_MSG_RESULT(yes)
1368                 AC_DEFINE(HAVE_NET_DEVICE_OPS_EXT, 1,
1369                           [struct net_device_ops_ext is defined])
1370         ],[
1371                 AC_MSG_RESULT(no)
1372         ])
1373
1374         AC_MSG_CHECKING([if net_device_ops_ext has ndo_get_phys_port_id])
1375         LB_LINUX_TRY_COMPILE([
1376                 #include <linux/netdevice.h>
1377
1378                 int get_phys_port_id(struct net_device *dev,
1379                                      struct netdev_phys_port_id *ppid)
1380                 {
1381                         return 0;
1382                 }
1383         ],[
1384                 struct net_device_ops_ext netdev_ops_ext;
1385
1386                 netdev_ops_ext.ndo_get_phys_port_id = get_phys_port_id;
1387
1388                 return 0;
1389         ],[
1390                 AC_MSG_RESULT(yes)
1391                 AC_DEFINE(HAVE_NETDEV_EXT_NDO_GET_PHYS_PORT_ID, 1,
1392                           [ndo_get_phys_port_id is defined])
1393         ],[
1394                 AC_MSG_RESULT(no)
1395         ])
1396
1397         AC_MSG_CHECKING([if net_device_ops has ndo_set_vf_spoofchk])
1398         LB_LINUX_TRY_COMPILE([
1399                 #include <linux/netdevice.h>
1400
1401                 int set_vf_spoofchk(struct net_device *dev, int vf, bool setting)
1402                 {
1403                         return 0;
1404                 }
1405         ],[
1406                 struct net_device_ops netdev_ops;
1407
1408                 netdev_ops.ndo_set_vf_spoofchk = set_vf_spoofchk;
1409
1410                 return 0;
1411         ],[
1412                 AC_MSG_RESULT(yes)
1413                 AC_DEFINE(HAVE_NETDEV_OPS_NDO_SET_VF_SPOOFCHK, 1,
1414                           [ndo_set_vf_spoofchk is defined in net_device_ops])
1415         ],[
1416                 AC_MSG_RESULT(no)
1417         ])
1418
1419         AC_MSG_CHECKING([if net_device_ops_ext has ndo_set_vf_spoofchk])
1420         LB_LINUX_TRY_COMPILE([
1421                 #include <linux/netdevice.h>
1422
1423                 int set_vf_spoofchk(struct net_device *dev, int vf, bool setting)
1424                 {
1425                         return 0;
1426                 }
1427         ],[
1428                 struct net_device_ops_ext netdev_ops_ext;
1429
1430                 netdev_ops_ext.ndo_set_vf_spoofchk = set_vf_spoofchk;
1431
1432                 return 0;
1433         ],[
1434                 AC_MSG_RESULT(yes)
1435                 AC_DEFINE(HAVE_NETDEV_OPS_EXT_NDO_SET_VF_SPOOFCHK, 1,
1436                           [ndo_set_vf_spoofchk is defined in net_device_ops_ext])
1437         ],[
1438                 AC_MSG_RESULT(no)
1439         ])
1440
1441         AC_MSG_CHECKING([if net_device_ops has ndo_set_vf_link_state])
1442         LB_LINUX_TRY_COMPILE([
1443                 #include <linux/netdevice.h>
1444
1445                 int set_vf_link_state(struct net_device *dev, int vf, int link_state)
1446                 {
1447                         return 0;
1448                 }
1449         ],[
1450                 struct net_device_ops netdev_ops;
1451
1452                 netdev_ops.ndo_set_vf_link_state = set_vf_link_state;
1453
1454                 return 0;
1455         ],[
1456                 AC_MSG_RESULT(yes)
1457                 AC_DEFINE(HAVE_NETDEV_OPS_NDO_SET_VF_LINK_STATE, 1,
1458                           [ndo_set_vf_link_state is defined in net_device_ops])
1459         ],[
1460                 AC_MSG_RESULT(no)
1461         ])
1462
1463         AC_MSG_CHECKING([if net_device_ops_ext has ndo_set_vf_link_state])
1464         LB_LINUX_TRY_COMPILE([
1465                 #include <linux/netdevice.h>
1466
1467                 int set_vf_link_state(struct net_device *dev, int vf, int link_state)
1468                 {
1469                         return 0;
1470                 }
1471         ],[
1472                 struct net_device_ops_ext netdev_ops_ext;
1473
1474                 netdev_ops_ext.ndo_set_vf_link_state = set_vf_link_state;
1475
1476                 return 0;
1477         ],[
1478                 AC_MSG_RESULT(yes)
1479                 AC_DEFINE(HAVE_NETDEV_OPS_EXT_NDO_SET_VF_LINK_STATE, 1,
1480                           [ndo_set_vf_link_state is defined])
1481         ],[
1482                 AC_MSG_RESULT(no)
1483         ])
1484
1485
1486         AC_MSG_CHECKING([if netdevice.h netif_set_real_num_tx_queues returns int])
1487         LB_LINUX_TRY_COMPILE([
1488                 #include <linux/netdevice.h>
1489         ],[
1490                 struct net_device dev;
1491                 int ret;
1492                 ret = netif_set_real_num_tx_queues(&dev, 2);
1493                 return 0;
1494         ],[
1495                 AC_MSG_RESULT(yes)
1496                 AC_DEFINE(HAVE_RETURN_INT_FOR_SET_NUM_TX_QUEUES, 1,
1497                           [netif_set_real_num_tx_queues returns int])
1498         ],[
1499                 AC_MSG_RESULT(no)
1500         ])
1501
1502         AC_MSG_CHECKING([if struct netdevice.h has struct xps_map])
1503         LB_LINUX_TRY_COMPILE([
1504                 #include <linux/netdevice.h>
1505         ],[
1506                 struct xps_map map;
1507                 map.len = 0;
1508
1509                 return 0;
1510         ],[
1511                 AC_MSG_RESULT(yes)
1512                 AC_DEFINE(HAVE_XPS_MAP, 1,
1513                           [struct xps_map is defined])
1514         ],[
1515                 AC_MSG_RESULT(no)
1516         ])
1517
1518         AC_MSG_CHECKING([if struct ethtool_ops has set_phys_id])
1519         LB_LINUX_TRY_COMPILE([
1520                 #include <linux/ethtool.h>
1521         ],[
1522                 const struct ethtool_ops en_ethtool_ops = {
1523                         .set_phys_id= NULL,
1524                 };
1525
1526                 return 0;
1527         ],[
1528                 AC_MSG_RESULT(yes)
1529                 AC_DEFINE(HAVE_SET_PHYS_ID, 1,
1530                           [set_phys_id is defined])
1531         ],[
1532                 AC_MSG_RESULT(no)
1533         ])
1534
1535         AC_MSG_CHECKING([if struct ethtool_ops has get/set_channels])
1536         LB_LINUX_TRY_COMPILE([
1537                 #include <linux/ethtool.h>
1538         ],[
1539                 const struct ethtool_ops en_ethtool_ops = {
1540                         .get_channels = NULL,
1541                         .set_channels = NULL,
1542                 };
1543
1544                 return 0;
1545         ],[
1546                 AC_MSG_RESULT(yes)
1547                 AC_DEFINE(HAVE_GET_SET_CHANNELS, 1,
1548                           [get/set_channels is defined])
1549         ],[
1550                 AC_MSG_RESULT(no)
1551         ])
1552
1553         AC_MSG_CHECKING([if struct ethtool_ops_ext has get/set_channels])
1554         LB_LINUX_TRY_COMPILE([
1555                 #include <linux/ethtool.h>
1556         ],[
1557                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
1558                         .get_channels = NULL,
1559                         .set_channels = NULL,
1560                 };
1561
1562                 return 0;
1563         ],[
1564                 AC_MSG_RESULT(yes)
1565                 AC_DEFINE(HAVE_GET_SET_CHANNELS_EXT, 1,
1566                           [get/set_channels is defined in ethtool_ops_ext])
1567         ],[
1568                 AC_MSG_RESULT(no)
1569         ])
1570
1571         AC_MSG_CHECKING([if struct ethtool_ops has get_ts_info])
1572         LB_LINUX_TRY_COMPILE([
1573                 #include <linux/ethtool.h>
1574         ],[
1575                 const struct ethtool_ops en_ethtool_ops = {
1576                         .get_ts_info = NULL,
1577                 };
1578
1579                 return 0;
1580         ],[
1581                 AC_MSG_RESULT(yes)
1582                 AC_DEFINE(HAVE_GET_TS_INFO, 1,
1583                           [get_ts_info is defined])
1584         ],[
1585                 AC_MSG_RESULT(no)
1586         ])
1587
1588         AC_MSG_CHECKING([if linux/timecounter.h exists])
1589         LB_LINUX_TRY_COMPILE([
1590                 #include <linux/timecounter.h>
1591         ],[
1592                 return 0;
1593         ],[
1594                 AC_MSG_RESULT(yes)
1595                 AC_DEFINE(HAVE_TIMECOUNTER_H, 1,
1596                           [linux/timecounter.h exists])
1597         ],[
1598                 AC_MSG_RESULT(no)
1599         ])
1600
1601         # timecounter_adjtime can be in timecounter.h or clocksource.h
1602         AC_MSG_CHECKING([if linux/timecounter.h has timecounter_adjtime])
1603         LB_LINUX_TRY_COMPILE([
1604                 #include <linux/timecounter.h>
1605         ],[
1606                 struct timecounter x;
1607                 s64 y = 0;
1608                 timecounter_adjtime(&x, y);
1609
1610                 return 0;
1611         ],[
1612                 AC_MSG_RESULT(yes)
1613                 AC_DEFINE(HAVE_TIMECOUNTER_ADJTIME, 1,
1614                           [timecounter_adjtime is defined])
1615         ],[
1616                 AC_MSG_RESULT(no)
1617         ])
1618
1619         AC_MSG_CHECKING([if linux/clocksource.h has timecounter_adjtime])
1620         LB_LINUX_TRY_COMPILE([
1621                 #include <linux/clocksource.h>
1622         ],[
1623                 struct timecounter x;
1624                 s64 y = 0;
1625                 timecounter_adjtime(&x, y);
1626
1627                 return 0;
1628         ],[
1629                 AC_MSG_RESULT(yes)
1630                 AC_DEFINE(HAVE_TIMECOUNTER_ADJTIME, 1,
1631                           [timecounter_adjtime is defined])
1632         ],[
1633                 AC_MSG_RESULT(no)
1634         ])
1635
1636         AC_MSG_CHECKING([if struct ethtool_ops has set_dump])
1637         LB_LINUX_TRY_COMPILE([
1638                 #include <linux/ethtool.h>
1639         ],[
1640                 const struct ethtool_ops en_ethtool_ops = {
1641                         .set_dump = NULL,
1642                 };
1643
1644                 return 0;
1645         ],[
1646                 AC_MSG_RESULT(yes)
1647                 AC_DEFINE(HAVE_ETHTOOL_OPS_SET_DUMP, 1,
1648                           [set_dump is defined])
1649         ],[
1650                 AC_MSG_RESULT(no)
1651         ])
1652
1653         AC_MSG_CHECKING([if struct ethtool_ops has get_module_info])
1654         LB_LINUX_TRY_COMPILE([
1655                 #include <linux/ethtool.h>
1656         ],[
1657                 const struct ethtool_ops en_ethtool_ops = {
1658                         .get_module_info = NULL,
1659                 };
1660
1661                 return 0;
1662         ],[
1663                 AC_MSG_RESULT(yes)
1664                 AC_DEFINE(HAVE_ETHTOOL_OPS_GET_MODULE_INFO, 1,
1665                           [get_module_info is defined])
1666         ],[
1667                 AC_MSG_RESULT(no)
1668         ])
1669
1670         AC_MSG_CHECKING([if struct ethtool_ops has get_module_eeprom])
1671         LB_LINUX_TRY_COMPILE([
1672                 #include <linux/ethtool.h>
1673         ],[
1674                 const struct ethtool_ops en_ethtool_ops = {
1675                         .get_module_eeprom = NULL,
1676                 };
1677
1678                 return 0;
1679         ],[
1680                 AC_MSG_RESULT(yes)
1681                 AC_DEFINE(HAVE_ETHTOOL_OPS_GET_MODULE_EEPROM, 1,
1682                           [get_module_eeprom is defined])
1683         ],[
1684                 AC_MSG_RESULT(no)
1685         ])
1686
1687         AC_MSG_CHECKING([if struct ethtool_ops_ext has get_ts_info])
1688         LB_LINUX_TRY_COMPILE([
1689                 #include <linux/ethtool.h>
1690         ],[
1691                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
1692                         .get_ts_info = NULL,
1693                 };
1694
1695                 return 0;
1696         ],[
1697                 AC_MSG_RESULT(yes)
1698                 AC_DEFINE(HAVE_GET_TS_INFO_EXT, 1,
1699                           [get_ts_info is defined in ethtool_ops_ext])
1700         ],[
1701                 AC_MSG_RESULT(no)
1702         ])
1703
1704         AC_MSG_CHECKING([if struct ethtool_flow_ext has h_dest])
1705         LB_LINUX_TRY_COMPILE([
1706                 #include <linux/ethtool.h>
1707         ],[
1708                 unsigned char mac[ETH_ALEN];
1709                 struct ethtool_flow_ext h_ext;
1710
1711                 memcpy(&mac, h_ext.h_dest, ETH_ALEN);
1712
1713                 return 0;
1714         ],[
1715                 AC_MSG_RESULT(yes)
1716                 AC_DEFINE(HAVE_ETHTOOL_FLOW_EXT_H_DEST, 1,
1717                           [ethtool_flow_ext has h_dest])
1718         ],[
1719                 AC_MSG_RESULT(no)
1720         ])
1721
1722         AC_MSG_CHECKING([if netdevice.h has struct dev_addr_list])
1723         LB_LINUX_TRY_COMPILE([
1724                 #include <linux/netdevice.h>
1725         ],[
1726                 struct dev_addr_list addr;
1727                 return 0;
1728         ],[
1729                 AC_MSG_RESULT(yes)
1730                 AC_DEFINE(HAVE_NETDEV_DEV_ADDR, 1,
1731                           [dev_addr_list is defined])
1732         ],[
1733                 AC_MSG_RESULT(no)
1734         ])
1735
1736         AC_MSG_CHECKING([if pci.h has pci_vfs_assigned])
1737         LB_LINUX_TRY_COMPILE([
1738                 #include <linux/pci.h>
1739         ],[
1740                 struct pci_dev pdev;
1741                 pci_vfs_assigned(&pdev);
1742                 return 0;
1743         ],[
1744                 AC_MSG_RESULT(yes)
1745                 AC_DEFINE(HAVE_PCI_VF_ASSIGNED, 1,
1746                           [pci_vfs_assigned is defined])
1747         ],[
1748                 AC_MSG_RESULT(no)
1749         ])
1750
1751         AC_MSG_CHECKING([if vlan_insert_tag_set_proto is defined])
1752         LB_LINUX_TRY_COMPILE([
1753                 #include <linux/if_vlan.h>
1754         ],[
1755                 struct sk_buff *skb;
1756                 vlan_insert_tag_set_proto(skb, 0, 0);
1757                 return 0;
1758         ],[
1759                 AC_MSG_RESULT(yes)
1760                 AC_DEFINE(HAVE_VLAN_INSERT_TAG_SET_PROTO, 1,
1761                           [vlan_insert_tag_set_proto is defined])
1762         ],[
1763                 AC_MSG_RESULT(no)
1764                 AC_MSG_CHECKING([if __vlan_put_tag has 3 parameters])
1765                 LB_LINUX_TRY_COMPILE([
1766                         #include <linux/if_vlan.h>
1767                 ],[
1768                         struct sk_buff *skb;
1769                         __vlan_put_tag(skb, 0, 0);
1770                         return 0;
1771                 ],[
1772                         AC_MSG_RESULT(yes)
1773                         AC_DEFINE(HAVE_3_PARAMS_FOR_VLAN_PUT_TAG, 1,
1774                                   [__vlan_put_tag has 3 parameters])
1775                 ],[
1776                         AC_MSG_RESULT(no)
1777                 ])
1778         ])
1779
1780         AC_MSG_CHECKING([if __vlan_hwaccel_put_tag has 3 parameters])
1781         LB_LINUX_TRY_COMPILE([
1782                 #include <linux/if_vlan.h>
1783         ],[
1784                 struct sk_buff *skb;
1785                 __vlan_hwaccel_put_tag(skb, 0, 0);
1786
1787                 return 0;
1788         ],[
1789                 AC_MSG_RESULT(yes)
1790                 AC_DEFINE(HAVE_3_PARAMS_FOR_VLAN_HWACCEL_PUT_TAG, 1,
1791                           [__vlan_hwaccel_put_tag has 3 parameters])
1792         ],[
1793                 AC_MSG_RESULT(no)
1794         ])
1795
1796         AC_MSG_CHECKING([if struct inet6_ifaddr has if_next])
1797         LB_LINUX_TRY_COMPILE([
1798                 #include <net/if_inet6.h>
1799         ],[
1800                 struct inet6_ifaddr ifp ;
1801                 ifp.if_next = 0;
1802
1803                 return 0;
1804         ],[
1805                 AC_MSG_RESULT(yes)
1806                 AC_DEFINE(HAVE_INETADDR_IF_NEXT, 1,
1807                           [if_next is defined])
1808         ],[
1809                 AC_MSG_RESULT(no)
1810         ])
1811
1812         AC_MSG_CHECKING([if struct net_device has hw_features])
1813         LB_LINUX_TRY_COMPILE([
1814                 #include <linux/netdevice.h>
1815         ],[
1816                 struct net_device dev;
1817                 dev.hw_features = 0;
1818
1819                 return 0;
1820         ],[
1821                 AC_MSG_RESULT(yes)
1822                 AC_DEFINE(HAVE_NETDEV_HW_FEATURES, 1,
1823                           [hw_features is defined])
1824         ],[
1825                 AC_MSG_RESULT(no)
1826         ])
1827
1828         AC_MSG_CHECKING([if struct net_device has hw_enc_features])
1829         LB_LINUX_TRY_COMPILE([
1830                 #include <linux/netdevice.h>
1831         ],[
1832                 struct net_device dev;
1833                 dev.hw_enc_features = 0;
1834
1835                 return 0;
1836         ],[
1837                 AC_MSG_RESULT(yes)
1838                 AC_DEFINE(HAVE_NETDEV_HW_ENC_FEATURES, 1,
1839                           [hw_enc_features is defined])
1840         ],[
1841                 AC_MSG_RESULT(no)
1842         ])
1843
1844         AC_MSG_CHECKING([if struct net_device has rx_cpu_rmap])
1845         LB_LINUX_TRY_COMPILE([
1846                 #include <linux/netdevice.h>
1847         ],[
1848                 struct net_device dev;
1849                 dev.rx_cpu_rmap = NULL;
1850
1851                 return 0;
1852         ],[
1853                 AC_MSG_RESULT(yes)
1854                 AC_DEFINE(HAVE_NETDEV_RX_CPU_RMAP, 1,
1855                           [rx_cpu_rmap is defined])
1856         ],[
1857                 AC_MSG_RESULT(no)
1858         ])
1859
1860         AC_MSG_CHECKING([if if_vlan.h has vlan_hwaccel_receive_skb])
1861         LB_LINUX_TRY_COMPILE([
1862                 #include <linux/if_vlan.h>
1863         ],[
1864                 struct sk_buff *skb;
1865                 vlan_hwaccel_receive_skb(skb,0,0);
1866                 return 0;
1867         ],[
1868                 AC_MSG_RESULT(yes)
1869                 AC_DEFINE(HAVE_VLAN_HWACCEL_RECEIVE_SKB, 1,
1870                           [vlan_hwaccel_receive_skb is defined])
1871         ],[
1872                 AC_MSG_RESULT(no)
1873         ])
1874
1875         AC_MSG_CHECKING([if irqdesc.h has irq_desc_get_irq_data])
1876         LB_LINUX_TRY_COMPILE([
1877                 #include <linux/irq.h>
1878                 #include <linux/irqdesc.h>
1879         ],[
1880                 struct irq_desc desc;
1881                 struct irq_data *data = irq_desc_get_irq_data(&desc);
1882
1883                 return 0;
1884         ],[
1885                 AC_MSG_RESULT(yes)
1886                 AC_DEFINE(HAVE_IRQ_DESC_GET_IRQ_DATA, 1,
1887                           [irq_desc_get_irq_data is defined])
1888         ],[
1889                 AC_MSG_RESULT(no)
1890         ])
1891
1892
1893         AC_MSG_CHECKING([if pci_dev has pcie_mpss])
1894         LB_LINUX_TRY_COMPILE([
1895                 #include <linux/pci.h>
1896         ],[
1897                 struct pci_dev *pdev;
1898
1899                 pdev->pcie_mpss = 0;
1900                 return 0;
1901         ],[
1902                 AC_MSG_RESULT(yes)
1903                 AC_DEFINE(HAVE_PCI_DEV_PCIE_MPSS, 1,
1904                           [pcie_mpss is defined])
1905         ],[
1906                 AC_MSG_RESULT(no)
1907         ])
1908
1909         AC_MSG_CHECKING([if uapi/linux/if_ether.h exist])
1910         LB_LINUX_TRY_COMPILE([
1911                 #include <uapi/linux/if_ether.h>
1912         ],[
1913                 return 0;
1914         ],[
1915                 AC_MSG_RESULT(yes)
1916                 AC_DEFINE(HAVE_UAPI_LINUX_IF_ETHER_H, 1,
1917                           [uapi/linux/if_ether.h exist])
1918         ],[
1919                 AC_MSG_RESULT(no)
1920         ])
1921
1922         AC_MSG_CHECKING([if ifla_vf_info has spoofchk])
1923         LB_LINUX_TRY_COMPILE([
1924                 #include <linux/if_link.h>
1925         ],[
1926                 struct ifla_vf_info *ivf;
1927
1928                 ivf->spoofchk = 0;
1929                 return 0;
1930         ],[
1931                 AC_MSG_RESULT(yes)
1932                 AC_DEFINE(HAVE_VF_INFO_SPOOFCHK, 1,
1933                           [spoofchk is defined])
1934         ],[
1935                 AC_MSG_RESULT(no)
1936         ])
1937
1938         AC_MSG_CHECKING([if vxlan.h has vxlan_gso_check])
1939         LB_LINUX_TRY_COMPILE([
1940                 #include <net/vxlan.h>
1941         ],[
1942                 vxlan_gso_check(NULL);
1943
1944                 return 0;
1945         ],[
1946                 AC_MSG_RESULT(yes)
1947                 AC_DEFINE(HAVE_VXLAN_GSO_CHECK, 1,
1948                           [vxlan_gso_check is defined])
1949         ],[
1950                 AC_MSG_RESULT(no)
1951         ])
1952
1953         AC_MSG_CHECKING([if dst.h has dst_get_neighbour])
1954         LB_LINUX_TRY_COMPILE([
1955                 #include <net/dst.h>
1956         ],[
1957                 struct neighbour *neigh = dst_get_neighbour(NULL);
1958
1959                 return 0;
1960         ],[
1961                 AC_MSG_RESULT(yes)
1962                 AC_DEFINE(HAVE_DST_GET_NEIGHBOUR, 1,
1963                           [ is defined])
1964         ],[
1965                 AC_MSG_RESULT(no)
1966         ])
1967
1968         AC_MSG_CHECKING([if netlink_dump_start has 6 parameters])
1969         LB_LINUX_TRY_COMPILE([
1970                 #include <linux/netlink.h>
1971         ],[
1972                 int ret = netlink_dump_start(NULL, NULL, NULL, NULL, NULL, 0);
1973
1974                 return 0;
1975         ],[
1976                 AC_MSG_RESULT(yes)
1977                 AC_DEFINE(HAVE_NETLINK_DUMP_START_6P, 1,
1978                           [ is defined])
1979         ],[
1980                 AC_MSG_RESULT(no)
1981         ])
1982
1983         AC_MSG_CHECKING([if netlink_dump_start has 5 parameters])
1984         LB_LINUX_TRY_COMPILE([
1985                 #include <linux/netlink.h>
1986         ],[
1987                 int ret = netlink_dump_start(NULL, NULL, NULL, NULL, NULL);
1988
1989                 return 0;
1990         ],[
1991                 AC_MSG_RESULT(yes)
1992                 AC_DEFINE(HAVE_NETLINK_DUMP_START_5P, 1,
1993                           [ is defined])
1994         ],[
1995                 AC_MSG_RESULT(no)
1996         ])
1997
1998         AC_MSG_CHECKING([if struct dcbnl_rtnl_ops has ieee_getmaxrate/ieee_setmaxrate])
1999         LB_LINUX_TRY_COMPILE([
2000                 #include <net/dcbnl.h>
2001         ],[
2002                 const struct dcbnl_rtnl_ops en_dcbnl_ops = {
2003                         .ieee_getmaxrate = NULL,
2004                         .ieee_setmaxrate = NULL,
2005                 };
2006
2007                 return 0;
2008         ],[
2009                 AC_MSG_RESULT(yes)
2010                 AC_DEFINE(HAVE_IEEE_GET_SET_MAXRATE, 1,
2011                           [ieee_getmaxrate/ieee_setmaxrate is defined])
2012         ],[
2013                 AC_MSG_RESULT(no)
2014         ])
2015
2016         AC_LANG_PUSH(C)
2017         ac_c_werror_flag=yes
2018         save_EXTRA_KCFLAGS=$EXTRA_KCFLAGS
2019         EXTRA_KCFLAGS="$EXTRA_KCFLAGS -Werror"
2020
2021         AC_MSG_CHECKING([if bonding.h bond_for_each_slave has int for 3rd parameter])
2022         LB_LINUX_TRY_COMPILE([
2023                 #include "../drivers/net/bonding/bonding.h"
2024         ],[
2025                 struct bonding *bond = NULL;
2026                 struct slave *slave = NULL;
2027                 int iter;
2028
2029                 bond_for_each_slave(bond, slave, iter) ;
2030
2031                 return 0;
2032         ],[
2033                 AC_MSG_RESULT(yes)
2034                 AC_DEFINE(HAVE_BOND_FOR_EACH_SLAVE_3RD_PARAM_IS_INT, 1,
2035                           [bond_for_each_slave has int for 3rd parameter])
2036         ],[
2037                 AC_MSG_RESULT(no)
2038         ])
2039         EXTRA_KCFLAGS="$save_EXTRA_KCFLAGS"
2040         ac_c_werror_flag=
2041         AC_LANG_POP
2042
2043         AC_MSG_CHECKING([if netdevice.h has netdev_master_upper_dev_get_rcu])
2044         LB_LINUX_TRY_COMPILE([
2045                 #include <linux/netdevice.h>
2046         ],[
2047                 netdev_master_upper_dev_get_rcu(NULL);
2048
2049                 return 0;
2050         ],[
2051                 AC_MSG_RESULT(yes)
2052                 AC_DEFINE(HAVE_NETDEV_MASTER_UPPER_DEV_GET_RCU, 1,
2053                           [netdev_master_upper_dev_get_rcu is defined])
2054         ],[
2055                 AC_MSG_RESULT(no)
2056         ])
2057
2058         AC_MSG_CHECKING([if __vlan_find_dev_deep has 3 parameters])
2059         LB_LINUX_TRY_COMPILE([
2060                 #include <linux/if_vlan.h>
2061         ],[
2062                 __vlan_find_dev_deep(NULL, 0, 0);
2063
2064                 return 0;
2065         ],[
2066                 AC_MSG_RESULT(yes)
2067                 AC_DEFINE(HAVE__VLAN_FIND_DEV_DEEP_3P, 1,
2068                           [__vlan_find_dev_deep has 3 paramters])
2069         ],[
2070                 AC_MSG_RESULT(no)
2071         ])
2072
2073         AC_MSG_CHECKING([if sk_buff.h has __skb_alloc_page])
2074         LB_LINUX_TRY_COMPILE([
2075                 #include <linux/skbuff.h>
2076         ],[
2077                 __skb_alloc_page(0, NULL);
2078
2079                 return 0;
2080         ],[
2081                 AC_MSG_RESULT(yes)
2082                 AC_DEFINE(HAVE__SKB_ALLOC_PAGE, 1,
2083                           [sk_buff has __skb_alloc_page])
2084         ],[
2085                 AC_MSG_RESULT(no)
2086         ])
2087
2088         AC_MSG_CHECKING([if __vlan_hwaccel_put_tag has 3 parameters])
2089         LB_LINUX_TRY_COMPILE([
2090                 #include <linux/if_vlan.h>
2091         ],[
2092                 __vlan_hwaccel_put_tag(NULL, 0, 0);
2093
2094                 return 0;
2095         ],[
2096                 AC_MSG_RESULT(yes)
2097                 AC_DEFINE(HAVE__VLAN_HWACCEL_PUT_TAG_3P, 1,
2098                           [__vlan_hwaccel_put_tag has 3 paramters])
2099         ],[
2100                 AC_MSG_RESULT(no)
2101         ])
2102
2103         AC_MSG_CHECKING([if linux/mm_types.h has struct page_frag])
2104         LB_LINUX_TRY_COMPILE([
2105                 #include <linux/mm_types.h>
2106         ],[
2107                 struct page_frag frag = {0};
2108
2109                 return 0;
2110         ],[
2111                 AC_MSG_RESULT(yes)
2112                 AC_DEFINE(HAVE_MM_TYPES_PAGE_FRAG, 1,
2113                           [linux/mm_types.h has struct page_frag])
2114         ],[
2115                 AC_MSG_RESULT(no)
2116         ])
2117
2118         AC_MSG_CHECKING([if if_vlan.h has __vlan_find_dev_deep])
2119         LB_LINUX_TRY_COMPILE([
2120                 #include <linux/if_vlan.h>
2121         ],[
2122                 __vlan_find_dev_deep(NULL, 0);
2123
2124                 return 0;
2125         ],[
2126                 AC_MSG_RESULT(yes)
2127                 AC_DEFINE(HAVE___VLAN_FIND_DEV_DEEP, 1,
2128                           [__vlan_find_dev_deep is defined])
2129         ],[
2130                 AC_MSG_RESULT(no)
2131         ])
2132
2133         AC_MSG_CHECKING([if idr .h has idr_Alloc])
2134         LB_LINUX_TRY_COMPILE([
2135                 #include <linux/idr.h>
2136         ],[
2137                 idr_alloc(NULL, NULL, 0, 0, 0);
2138                 return 0;
2139         ],[
2140                 AC_MSG_RESULT(yes)
2141                 AC_DEFINE(HAVE_IDR_NEW_INTERFACE, 1,
2142                           [idr_Alloc is defined]) ],[
2143                 AC_MSG_RESULT(no)
2144         ])
2145
2146         AC_MSG_CHECKING([if completion.h has reinit_completion])
2147         LB_LINUX_TRY_COMPILE([
2148                 #include <linux/completion.h>
2149         ],[
2150                 struct completion c;
2151
2152                 reinit_completion(&c);
2153                 return 0;
2154         ],[
2155                 AC_MSG_RESULT(yes)
2156                 AC_DEFINE(HAVE_REINIT_COMPLETION, 1,
2157                           [reinit_completion is defined])
2158         ],[
2159                 AC_MSG_RESULT(no)
2160         ])
2161
2162         AC_MSG_CHECKING([if dma-mapping.h has dma_set_mask_and_coherent])
2163         LB_LINUX_TRY_COMPILE([
2164                 #include <linux/dma-mapping.h>
2165         ],[
2166                 dma_set_mask_and_coherent(NULL, 0);
2167
2168                 return 0;
2169         ],[
2170                 AC_MSG_RESULT(yes)
2171                 AC_DEFINE(HAVE_DMA_SET_MASK_AND_COHERENT, 1,
2172                           [dma_set_mask_and_coherent is defined])
2173         ],[
2174                 AC_MSG_RESULT(no)
2175         ])
2176
2177         AC_MSG_CHECKING([if in.h has proto_ports_offset])
2178         LB_LINUX_TRY_COMPILE([
2179                 #include <linux/in.h>
2180         ],[
2181                 int x = proto_ports_offset(IPPROTO_TCP);
2182                 return 0;
2183         ],[
2184                 AC_MSG_RESULT(yes)
2185                 AC_DEFINE(HAVE_PROTO_PORTS_OFFSET, 1,
2186                           [proto_ports_offset is defined])
2187         ],[
2188                 AC_MSG_RESULT(no)
2189         ])
2190
2191         LB_CHECK_SYMBOL_EXPORT([elfcorehdr_addr],
2192                 [kernel/crash_dump.c],
2193                 [AC_DEFINE(HAVE_ELFCOREHDR_ADDR_EXPORTED, 1,
2194                         [elfcorehdr_addr is exported by the kernel])],
2195         [])
2196
2197         AC_MSG_CHECKING([if netif_set_real_num_rx_queues is defined])
2198         LB_LINUX_TRY_COMPILE([
2199                 #include <linux/netdevice.h>
2200         ],[
2201                 int rc = netif_set_real_num_rx_queues(NULL, 0);
2202
2203                 return rc;
2204         ],[
2205                 AC_MSG_RESULT(yes)
2206                 AC_DEFINE(HAVE_NETIF_SET_REAL_NUM_RX_QUEUES, 1,
2207                           [netif_set_real_num_rx_queues is defined])
2208         ],[
2209                 AC_MSG_RESULT(no)
2210         ])
2211
2212         AC_MSG_CHECKING([if if_vlan.h has is_vlan_dev])
2213         LB_LINUX_TRY_COMPILE([
2214                 #include <linux/netdevice.h>
2215                 #include <linux/if_vlan.h>
2216         ],[
2217                 struct net_device dev;
2218                 is_vlan_dev(&dev);
2219
2220                 return 0;
2221         ],[
2222                 AC_MSG_RESULT(yes)
2223                 AC_DEFINE(HAVE_IS_VLAN_DEV, 1,
2224                           [is_vlan_dev is defined])
2225         ],[
2226                 AC_MSG_RESULT(no)
2227         ])
2228
2229         AC_MSG_CHECKING([if linux/timecounter.h exists])
2230         LB_LINUX_TRY_COMPILE([
2231                 #include <linux/timecounter.h>
2232         ],[
2233                 return 0;
2234         ],[
2235                 AC_MSG_RESULT(yes)
2236                 AC_DEFINE(HAVE_TIMECOUNTER_H, 1,
2237                           [linux/timecounter.h exists])
2238         ],[
2239                 AC_MSG_RESULT(no)
2240         ])
2241
2242         # timecounter_adjtime can be in timecounter.h or clocksource.h
2243         AC_MSG_CHECKING([if linux/timecounter.h has timecounter_adjtime])
2244         LB_LINUX_TRY_COMPILE([
2245                 #include <linux/timecounter.h>
2246         ],[
2247                 struct timecounter x;
2248                 s64 y = 0;
2249                 timecounter_adjtime(&x, y);
2250
2251                 return 0;
2252         ],[
2253                 AC_MSG_RESULT(yes)
2254                 AC_DEFINE(HAVE_TIMECOUNTER_ADJTIME, 1,
2255                           [timecounter_adjtime is defined])
2256         ],[
2257                 AC_MSG_RESULT(no)
2258         ])
2259
2260         AC_MSG_CHECKING([if linux/clocksource.h has timecounter_adjtime])
2261         LB_LINUX_TRY_COMPILE([
2262                 #include <linux/clocksource.h>
2263         ],[
2264                 struct timecounter x;
2265                 s64 y = 0;
2266                 timecounter_adjtime(&x, y);
2267
2268                 return 0;
2269         ],[
2270                 AC_MSG_RESULT(yes)
2271                 AC_DEFINE(HAVE_TIMECOUNTER_ADJTIME, 1,
2272                           [timecounter_adjtime is defined])
2273         ],[
2274                 AC_MSG_RESULT(no)
2275         ])
2276
2277         AC_MSG_CHECKING([if cyclecounter_cyc2ns has 4 parameters])
2278         LB_LINUX_TRY_COMPILE([
2279                 #include <linux/timecounter.h>
2280         ],[
2281                 cyclecounter_cyc2ns(NULL, NULL, 0, NULL);
2282
2283                 return 0;
2284         ],[
2285                 AC_MSG_RESULT(yes)
2286                 AC_DEFINE(HAVE_CYCLECOUNTER_CYC2NS_4_PARAMS, 1,
2287                           [cyclecounter_cyc2ns has 4 parameters])
2288         ],[
2289                 AC_MSG_RESULT(no)
2290         ])
2291
2292         AC_MSG_CHECKING([if netdevice.h struct net_device_ops has ndo_features_check])
2293         LB_LINUX_TRY_COMPILE([
2294                 #include <linux/netdevice.h>
2295         ],[
2296                 static const struct net_device_ops mlx4_netdev_ops = {
2297                         .ndo_features_check     = NULL,
2298                 };
2299
2300                 return 0;
2301         ],[
2302                 AC_MSG_RESULT(yes)
2303                 AC_DEFINE(HAVE_NETDEV_FEATURES_T, 1,
2304                           [netdev_features_t is defined])
2305         ],[
2306                 AC_MSG_RESULT(no)
2307         ])
2308
2309         AC_MSG_CHECKING([if struct ethtool_ops get_rxnfc gets u32 *rule_locs])
2310         LB_LINUX_TRY_COMPILE([
2311                 #include <linux/ethtool.h>
2312                 static int mlx4_en_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *c,
2313                                              u32 *rule_locs)
2314                 {
2315                         return 0;
2316                 }
2317         ],[
2318                 struct ethtool_ops x = {
2319                         .get_rxnfc = mlx4_en_get_rxnfc,
2320                 };
2321
2322                 return 0;
2323         ],[
2324                 AC_MSG_RESULT(yes)
2325                 AC_DEFINE(HAVE_ETHTOOL_OPS_GET_RXNFC_U32_RULE_LOCS, 1,
2326                           [ethtool_ops get_rxnfc gets u32 *rule_locs])
2327         ],[
2328                 AC_MSG_RESULT(no)
2329         ])
2330
2331         AC_MSG_CHECKING([if ethtool.h enum ethtool_stringset has ETH_SS_RSS_HASH_FUNCS])
2332         LB_LINUX_TRY_COMPILE([
2333                 #include <linux/ethtool.h>
2334         ],[
2335                 enum ethtool_stringset x = ETH_SS_RSS_HASH_FUNCS;
2336
2337                 return 0;
2338         ],[
2339                 AC_MSG_RESULT(yes)
2340                 AC_DEFINE(HAVE_ETH_SS_RSS_HASH_FUNCS, 1,
2341                           [ETH_SS_RSS_HASH_FUNCS is defined])
2342         ],[
2343                 AC_MSG_RESULT(no)
2344         ])
2345 ])
2346 #
2347 # COMPAT_CONFIG_HEADERS
2348 #
2349 # add -include config.h
2350 #
2351 AC_DEFUN([COMPAT_CONFIG_HEADERS],[
2352         AC_CONFIG_HEADERS([config.h])
2353         EXTRA_KCFLAGS="-include $PWD/config.h $EXTRA_KCFLAGS"
2354         AC_SUBST(EXTRA_KCFLAGS)
2355 ])
2356
2357 AC_DEFUN([OFA_PROG_LINUX],
2358 [
2359
2360 LB_LINUX_PATH
2361 LB_LINUX_SYMVERFILE
2362 LB_LINUX_CONFIG([MODULES],[],[
2363     AC_MSG_ERROR([module support is required to build mlnx kernel modules.])
2364 ])
2365 LB_LINUX_CONFIG([MODVERSIONS])
2366 LB_LINUX_CONFIG([KALLSYMS],[],[
2367     AC_MSG_ERROR([compat_mlnx requires that CONFIG_KALLSYMS is enabled in your kernel.])
2368 ])
2369
2370 LINUX_CONFIG_COMPAT
2371 COMPAT_CONFIG_HEADERS
2372
2373 ])