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