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