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