Added HAVE_REQUEST_QUEUE_REQUEST_FN_ACTIVE macro
[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 kernel has ktime_get_ns])
143         LB_LINUX_TRY_COMPILE([
144                 #include <linux/ktime.h>
145         ],[
146                 unsigned long long ns;
147
148                 ns = ktime_get_ns();
149                 return 0;
150         ],[
151                 AC_MSG_RESULT(yes)
152                 AC_DEFINE(HAVE_KTIME_GET_NS, 1,
153                           [ktime_get_ns defined])
154         ],[
155                 AC_MSG_RESULT(no)
156         ])
157
158         AC_MSG_CHECKING([if svc_xprt_class has xcl_ident])
159         LB_LINUX_TRY_COMPILE([
160                 #include <linux/sunrpc/xprt.h>
161                 #include <linux/sunrpc/svc_xprt.h>
162         ],[
163                 struct svc_xprt_class svc_rdma_class = {
164                         .xcl_ident = XPRT_TRANSPORT_RDMA,
165                 };
166                 return 0;
167         ],[
168                 AC_MSG_RESULT(yes)
169                 AC_DEFINE(HAVE_XCL_IDENT, 1,
170                           [xcl_ident defined])
171         ],[
172                 AC_MSG_RESULT(no)
173         ])
174
175         AC_MSG_CHECKING([if struct ifla_vf_info has max_tx_rate])
176         LB_LINUX_TRY_COMPILE([
177                 #include <linux/if_link.h>
178         ],[
179                 struct ifla_vf_info *ivf;
180
181                 ivf->max_tx_rate = 0;
182                 ivf->min_tx_rate = 0;
183
184                 return 0;
185         ],[
186                 AC_MSG_RESULT(yes)
187                 AC_DEFINE(HAVE_TX_RATE_LIMIT, 1,
188                           [max_tx_rate is defined])
189         ],[
190                 AC_MSG_RESULT(no)
191         ])
192
193         AC_MSG_CHECKING([if struct ethtool_ops has get/set_rxfh])
194         LB_LINUX_TRY_COMPILE([
195                 #include <linux/ethtool.h>
196         ],[
197                 const struct ethtool_ops en_ethtool_ops = {
198                         .get_rxfh_indir_size = NULL,
199                         .get_rxfh = NULL,
200                         .set_rxfh = NULL,
201                 };
202
203                 return 0;
204         ],[
205                 AC_MSG_RESULT(yes)
206                 AC_DEFINE(HAVE_GET_SET_RXFH, 1,
207                           [get/set_rxfh is defined])
208         ],[
209                 AC_MSG_RESULT(no)
210         ])
211
212
213         AC_MSG_CHECKING([if struct ethtool_ops has get/set_tunable])
214         LB_LINUX_TRY_COMPILE([
215                 #include <linux/ethtool.h>
216         ],[
217                 const struct ethtool_ops en_ethtool_ops = {
218                         .get_tunable = NULL,
219                         .set_tunable = NULL,
220                 };
221
222                 return 0;
223         ],[
224                 AC_MSG_RESULT(yes)
225                 AC_DEFINE(HAVE_GET_SET_TUNABLE, 1,
226                           [get/set_tunable is defined])
227         ],[
228                 AC_MSG_RESULT(no)
229         ])
230
231         AC_MSG_CHECKING([if exist struct ethtool_ops_ext])
232         LB_LINUX_TRY_COMPILE([
233                 #include <linux/ethtool.h>
234         ],[
235                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
236                         .size = sizeof(struct ethtool_ops_ext),
237                 };
238
239                 return 0;
240         ],[
241                 AC_MSG_RESULT(yes)
242                 AC_DEFINE(HAVE_ETHTOOL_OPS_EXT, 1,
243                           [struct ethtool_ops_ext is defined])
244         ],[
245                 AC_MSG_RESULT(no)
246         ])
247
248         AC_MSG_CHECKING([if struct ethtool_ops_ext has get/set_rxfh])
249         LB_LINUX_TRY_COMPILE([
250                 #include <linux/ethtool.h>
251         ],[
252                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
253                         .get_rxfh_indir_size = NULL,
254                         .get_rxfh = NULL,
255                         .set_rxfh = NULL,
256                 };
257
258                 return 0;
259         ],[
260                 AC_MSG_RESULT(yes)
261                 AC_DEFINE(HAVE_GET_SET_RXFH_OPS_EXT, 1,
262                           [get/set_rxfh is defined])
263         ],[
264                 AC_MSG_RESULT(no)
265         ])
266
267         AC_MSG_CHECKING([if struct ethtool_ops_ext has get/set_rxfh_indir])
268         LB_LINUX_TRY_COMPILE([
269                 #include <linux/ethtool.h>
270         ],[
271                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
272                         .get_rxfh_indir_size = NULL,
273                         .get_rxfh_indir = NULL,
274                         .set_rxfh_indir = NULL,
275                 };
276
277                 return 0;
278         ],[
279                 AC_MSG_RESULT(yes)
280                 AC_DEFINE(HAVE_GET_SET_RXFH_INDIR, 1,
281                           [get/set_rxfh_indir is defined])
282         ],[
283                 AC_MSG_RESULT(no)
284         ])
285
286         AC_MSG_CHECKING([if struct net_device has dev_port])
287         LB_LINUX_TRY_COMPILE([
288                 #include <linux/netdevice.h>
289         ],[
290                 struct net_device *dev = NULL;
291
292                 dev->dev_port = 0;
293
294                 return 0;
295         ],[
296                 AC_MSG_RESULT(yes)
297                 AC_DEFINE(HAVE_NET_DEVICE_DEV_PORT, 1,
298                           [dev_port is defined])
299         ],[
300                 AC_MSG_RESULT(no)
301         ])
302
303         AC_MSG_CHECKING([if struct ptp_clock_info has n_pins])
304         LB_LINUX_TRY_COMPILE([
305                 #include <linux/ptp_clock_kernel.h>
306         ],[
307                 struct ptp_clock_info *info;
308                 info->n_pins = 0;
309
310                 return 0;
311         ],[
312                 AC_MSG_RESULT(yes)
313                 AC_DEFINE(HAVE_PTP_CLOCK_INFO_N_PINS, 1,
314                           [n_pins is defined])
315         ],[
316                 AC_MSG_RESULT(no)
317         ])
318
319         AC_MSG_CHECKING([if pci.h pci_enable_msi_exact])
320         LB_LINUX_TRY_COMPILE([
321                 #include <linux/pci.h>
322         ],[
323                 int x = pci_enable_msi_exact(NULL, 0);
324
325                 return 0;
326         ],[
327                 AC_MSG_RESULT(yes)
328                 AC_DEFINE(HAVE_PCI_ENABLE_MSI_EXACT, 1,
329                           [pci_enable_msi_exact is defined])
330         ],[
331                 AC_MSG_RESULT(no)
332         ])
333
334         AC_MSG_CHECKING([if pci.h pci_enable_msix_range])
335         LB_LINUX_TRY_COMPILE([
336                 #include <linux/pci.h>
337         ],[
338                 int x = pci_enable_msix_range(NULL, 0, 0, 0);
339
340                 return 0;
341         ],[
342                 AC_MSG_RESULT(yes)
343                 AC_DEFINE(HAVE_PCI_ENABLE_MSIX_RANGE, 1,
344                           [pci_enable_msix_range is defined])
345         ],[
346                 AC_MSG_RESULT(no)
347         ])
348
349         AC_MSG_CHECKING([if struct iscsi_transport has attr_is_visible])
350         LB_LINUX_TRY_COMPILE([
351                 #include <scsi/scsi_transport_iscsi.h>
352         ],[
353                 static struct iscsi_transport iscsi_iser_transport = {
354                         .attr_is_visible = NULL,
355                 };
356
357                 return 0;
358         ],[
359                 AC_MSG_RESULT(yes)
360                 AC_DEFINE(HAVE_ISCSI_ATTR_IS_VISIBLE, 1,
361                           [attr_is_visible is defined])
362         ],[
363                 AC_MSG_RESULT(no)
364         ])
365
366         AC_MSG_CHECKING([if struct iscsi_transport has get_ep_param])
367         LB_LINUX_TRY_COMPILE([
368                 #include <scsi/scsi_transport_iscsi.h>
369         ],[
370                 static struct iscsi_transport iscsi_iser_transport = {
371                         .get_ep_param = NULL,
372                 };
373
374                 return 0;
375         ],[
376                 AC_MSG_RESULT(yes)
377                 AC_DEFINE(HAVE_ISCSI_GET_EP_PARAM, 1,
378                           [get_ep_param is defined])
379         ],[
380                 AC_MSG_RESULT(no)
381         ])
382
383         AC_MSG_CHECKING([if struct iscsi_transport has check_protection])
384         LB_LINUX_TRY_COMPILE([
385                 #include <scsi/scsi_transport_iscsi.h>
386         ],[
387                 static struct iscsi_transport iscsi_iser_transport = {
388                         .check_protection = NULL,
389                 };
390
391                 return 0;
392         ],[
393                 AC_MSG_RESULT(yes)
394                 AC_DEFINE(HAVE_ISCSI_CHECK_PROTECTION, 1,
395                           [check_protection is defined])
396         ],[
397                 AC_MSG_RESULT(no)
398         ])
399
400         AC_MSG_CHECKING([if iscsi_proto.h has struct iscsi_scsi_req])
401         LB_LINUX_TRY_COMPILE([
402                 #include <scsi/iscsi_proto.h>
403         ],[
404                 struct iscsi_scsi_req *req = NULL;
405
406                 return 0;
407         ],[
408                 AC_MSG_RESULT(yes)
409                 AC_DEFINE(HAVE_ISCSI_SCSI_REQ, 1,
410                           [struct iscsi_scsi_req is defined])
411         ],[
412                 AC_MSG_RESULT(no)
413         ])
414
415         AC_MSG_CHECKING([if struct request_queue has request_fn_active])
416         LB_LINUX_TRY_COMPILE([
417                 #include <linux/blkdev.h>
418         ],[
419                 struct request_queue rq = {
420                         .request_fn_active = 0,
421                 };
422
423                 return 0;
424         ],[
425                 AC_MSG_RESULT(yes)
426                 AC_DEFINE(HAVE_REQUEST_QUEUE_REQUEST_FN_ACTIVE, 1,
427                           [struct request_queue has request_fn_active])
428         ],[
429                 AC_MSG_RESULT(no)
430         ])
431
432         AC_MSG_CHECKING([if netdevice.h has select_queue_fallback_t])
433         LB_LINUX_TRY_COMPILE([
434                 #include <linux/netdevice.h>
435         ],[
436                 select_queue_fallback_t fallback;
437
438                 fallback = NULL;
439
440                 return 0;
441         ],[
442                 AC_MSG_RESULT(yes)
443                 AC_DEFINE(HAVE_SELECT_QUEUE_FALLBACK_T, 1,
444                           [select_queue_fallback_t is defined])
445         ],[
446                 AC_MSG_RESULT(no)
447         ])
448
449         AC_MSG_CHECKING([if skbuff.h has skb_set_hash])
450         LB_LINUX_TRY_COMPILE([
451                 #include <linux/netdevice.h>
452         ],[
453                 skb_set_hash(NULL, 0, PKT_HASH_TYPE_L3);
454
455                 return 0;
456         ],[
457                 AC_MSG_RESULT(yes)
458                 AC_DEFINE(HAVE_SKB_SET_HASH, 1,
459                           [skb_set_hash is defined])
460         ],[
461                 AC_MSG_RESULT(no)
462         ])
463
464         AC_MSG_CHECKING([if sockios.h has SIOCGHWTSTAMP])
465         LB_LINUX_TRY_COMPILE([
466                 #include <linux/sockios.h>
467         ],[
468                 int x = SIOCGHWTSTAMP;
469
470                 return 0;
471         ],[
472                 AC_MSG_RESULT(yes)
473                 AC_DEFINE(HAVE_SIOCGHWTSTAMP, 1,
474                           [SIOCGHWTSTAMP is defined])
475         ],[
476                 AC_MSG_RESULT(no)
477         ])
478
479         AC_MSG_CHECKING([if ip.h inet_get_local_port_range has 3 parameters])
480         LB_LINUX_TRY_COMPILE([
481                 #include <net/ip.h>
482         ],[
483                 inet_get_local_port_range(NULL, NULL, NULL);
484
485                 return 0;
486         ],[
487                 AC_MSG_RESULT(yes)
488                 AC_DEFINE(HAVE_INET_GET_LOCAL_PORT_RANGE_3_PARAMS, 1,
489                           [inet_get_local_port_range has 3 parameters])
490         ],[
491                 AC_MSG_RESULT(no)
492         ])
493
494         AC_MSG_CHECKING([if net.h has net_get_random_once])
495         LB_LINUX_TRY_COMPILE([
496                 #include <linux/net.h>
497         ],[
498                 net_get_random_once(NULL, 0);
499
500                 return 0;
501         ],[
502                 AC_MSG_RESULT(yes)
503                 AC_DEFINE(HAVE_NET_GET_RANDOM_ONCE, 1,
504                           [net_get_random_once is defined])
505         ],[
506                 AC_MSG_RESULT(no)
507         ])
508
509         AC_MSG_CHECKING([if inet_sock.h has __inet_ehashfn])
510         LB_LINUX_TRY_COMPILE([
511                 #include <net/inet_sock.h>
512         ],[
513                 __inet_ehashfn(0, 0, 0, 0, 0);
514
515                 return 0;
516         ],[
517                 AC_MSG_RESULT(yes)
518                 AC_DEFINE(HAVE_INET_EHASHFN, 1,
519                           [__inet_ehashfn is defined])
520         ],[
521                 AC_MSG_RESULT(no)
522         ])
523
524         AC_MSG_CHECKING([if err.h has PTR_ERR_OR_ZERO])
525         LB_LINUX_TRY_COMPILE([
526                 #include <linux/err.h>
527         ],[
528                 int x = PTR_ERR_OR_ZERO(NULL);
529
530                 return 0;
531         ],[
532                 AC_MSG_RESULT(yes)
533                 AC_DEFINE(HAVE_PTR_ERR_OR_ZERO, 1,
534                           [PTR_ERR_OR_ZERO is defined])
535         ],[
536                 AC_MSG_RESULT(no)
537         ])
538
539         AC_MSG_CHECKING([if struct iscsi_session has discovery_sess])
540         LB_LINUX_TRY_COMPILE([
541                 #include <scsi/libiscsi.h>
542         ],[
543                 struct iscsi_session session;
544                 session.discovery_sess = 0;
545
546                 return 0;
547         ],[
548                 AC_MSG_RESULT(yes)
549                 AC_DEFINE(HAVE_ISCSI_DISCOVERY_SESS, 1,
550                           [discovery_sess is defined])
551         ],[
552                 AC_MSG_RESULT(no)
553         ])
554
555         AC_MSG_CHECKING([if enum iscsi_param has ISCSI_PARAM_DISCOVERY_SESS])
556         LB_LINUX_TRY_COMPILE([
557                 #include <scsi/iscsi_if.h>
558         ],[
559                 int x = ISCSI_PARAM_DISCOVERY_SESS;
560
561                 return 0;
562         ],[
563                 AC_MSG_RESULT(yes)
564                 AC_DEFINE(HAVE_ISCSI_PARAM_DISCOVERY_SESS, 1,
565                           [ISCSI_PARAM_DISCOVERY_SESS is defined])
566         ],[
567                 AC_MSG_RESULT(no)
568         ])
569
570         AC_MSG_CHECKING([if pci.h has enum pcie_link_width])
571         LB_LINUX_TRY_COMPILE([
572                 #include <linux/pci.h>
573         ],[
574                 enum pcie_link_width width = PCIE_LNK_WIDTH_UNKNOWN;
575
576                 return 0;
577         ],[
578                 AC_MSG_RESULT(yes)
579                 AC_DEFINE(HAVE_PCIE_LINK_WIDTH, 1,
580                           [pcie_link_width is defined])
581         ],[
582                 AC_MSG_RESULT(no)
583         ])
584
585         AC_MSG_CHECKING([if pci.h has enum pci_bus_speed])
586         LB_LINUX_TRY_COMPILE([
587                 #include <linux/pci.h>
588         ],[
589                 enum pci_bus_speed speed = PCI_SPEED_UNKNOWN;
590
591                 return 0;
592         ],[
593                 AC_MSG_RESULT(yes)
594                 AC_DEFINE(HAVE_PCI_BUS_SPEED, 1,
595                           [pci_bus_speed is defined])
596         ],[
597                 AC_MSG_RESULT(no)
598         ])
599
600         AC_MSG_CHECKING([if netdevice.h has struct netdev_phys_port_id])
601         LB_LINUX_TRY_COMPILE([
602                 #include <linux/netdevice.h>
603         ],[
604                 struct netdev_phys_port_id *x = NULL;
605
606                 return 0;
607         ],[
608                 AC_MSG_RESULT(yes)
609                 AC_DEFINE(HAVE_NETDEV_PHYS_PORT_ID, 1,
610                           [netdev_phys_port_id is defined])
611         ],[
612                 AC_MSG_RESULT(no)
613         ])
614
615         AC_MSG_CHECKING([if struct ifla_vf_info has linkstate])
616         LB_LINUX_TRY_COMPILE([
617                 #include <linux/if_link.h>
618         ],[
619                 struct struct ifla_vf_info x;
620                 x->linkstate = 0;
621
622                 return 0;
623         ],[
624                 AC_MSG_RESULT(yes)
625                 AC_DEFINE(HAVE_LINKSTATE, 1,
626                           [linkstate is defined])
627         ],[
628                 AC_MSG_RESULT(no)
629         ])
630
631         AC_MSG_CHECKING([if busy_poll.h has skb_mark_napi_id])
632         LB_LINUX_TRY_COMPILE([
633                 #include <net/busy_poll.h>
634         ],[
635                 skb_mark_napi_id(NULL, NULL);
636
637                 return 0;
638         ],[
639                 AC_MSG_RESULT(yes)
640                 AC_DEFINE(HAVE_SKB_MARK_NAPI_ID, 1,
641                           [skb_mark_napi_id is defined])
642         ],[
643                 AC_MSG_RESULT(no)
644         ])
645
646         AC_MSG_CHECKING([if netdevice.h has napi_hash_add])
647         LB_LINUX_TRY_COMPILE([
648                 #include <linux/netdevice.h>
649         ],[
650                 napi_hash_add(NULL);
651
652                 return 0;
653         ],[
654                 AC_MSG_RESULT(yes)
655                 AC_DEFINE(HAVE_NAPI_HASH_ADD, 1,
656                           [napi_hash_add is defined])
657         ],[
658                 AC_MSG_RESULT(no)
659         ])
660
661         AC_MSG_CHECKING([if netdevice.h has netif_keep_dst])
662         LB_LINUX_TRY_COMPILE([
663                 #include <linux/netdevice.h>
664         ],[
665                 netif_keep_dst(NULL);
666
667                 return 0;
668         ],[
669                 AC_MSG_RESULT(yes)
670                 AC_DEFINE(HAVE_NETIF_KEEP_DST, 1,
671                           [netif_keep_dst is defined])
672         ],[
673                 AC_MSG_RESULT(no)
674         ])
675
676         AC_MSG_CHECKING([if mm.h has kvfree])
677         LB_LINUX_TRY_COMPILE([
678                 #include <linux/mm.h>
679         ],[
680                 kvfree(NULL);
681
682                 return 0;
683         ],[
684                 AC_MSG_RESULT(yes)
685                 AC_DEFINE(HAVE_KVFREE, 1,
686                           [kvfree is defined])
687         ],[
688                 AC_MSG_RESULT(no)
689         ])
690
691         AC_MSG_CHECKING([if netdevice.h has dev_consume_skb_any])
692         LB_LINUX_TRY_COMPILE([
693                 #include <linux/netdevice.h>
694         ],[
695                 dev_consume_skb_any(NULL);
696
697                 return 0;
698         ],[
699                 AC_MSG_RESULT(yes)
700                 AC_DEFINE(HAVE_DEV_CONSUME_SKB_ANY, 1,
701                           [dev_consume_skb_any is defined])
702         ],[
703                 AC_MSG_RESULT(no)
704         ])
705
706         AC_MSG_CHECKING([if netdevice.h has netdev_txq_bql_complete_prefetchw])
707         LB_LINUX_TRY_COMPILE([
708                 #include <linux/netdevice.h>
709         ],[
710                 netdev_txq_bql_complete_prefetchw(NULL);
711                 netdev_txq_bql_enqueue_prefetchw(NULL);
712
713                 return 0;
714         ],[
715                 AC_MSG_RESULT(yes)
716                 AC_DEFINE(HAVE_NETDEV_TXQ_BQL_PREFETCHW, 1,
717                           [netdev_txq_bql_complete_prefetchw is defined])
718         ],[
719                 AC_MSG_RESULT(no)
720         ])
721
722         AC_MSG_CHECKING([if struct sk_buff has xmit_more])
723         LB_LINUX_TRY_COMPILE([
724                 #include <linux/skbuff.h>
725         ],[
726                 struct sk_buff *skb;
727                 skb->xmit_more = 0;
728
729                 return 0;
730         ],[
731                 AC_MSG_RESULT(yes)
732                 AC_DEFINE(HAVE_SK_BUFF_XMIT_MORE, 1,
733                           [xmit_more is defined])
734         ],[
735                 AC_MSG_RESULT(no)
736         ])
737
738         AC_MSG_CHECKING([if struct sk_buff has encapsulation])
739         LB_LINUX_TRY_COMPILE([
740                 #include <linux/skbuff.h>
741         ],[
742                 struct sk_buff *skb;
743                 skb->encapsulation = 0;
744
745                 return 0;
746         ],[
747                 AC_MSG_RESULT(yes)
748                 AC_DEFINE(HAVE_SK_BUFF_ENCAPSULATION, 1,
749                           [encapsulation is defined])
750         ],[
751                 AC_MSG_RESULT(no)
752         ])
753
754         AC_MSG_CHECKING([if etherdevice.h has eth_get_headlen])
755         LB_LINUX_TRY_COMPILE([
756                 #include <linux/etherdevice.h>
757         ],[
758                 eth_get_headlen(NULL, 0);
759
760                 return 0;
761         ],[
762                 AC_MSG_RESULT(yes)
763                 AC_DEFINE(HAVE_ETH_GET_HEADLEN, 1,
764                           [eth_get_headlen is defined])
765         ],[
766                 AC_MSG_RESULT(no)
767         ])
768
769         AC_MSG_CHECKING([if struct sk_buff has csum_level])
770         LB_LINUX_TRY_COMPILE([
771                 #include <linux/skbuff.h>
772         ],[
773                 struct sk_buff *skb;
774                 skb->csum_level = 0;
775
776                 return 0;
777         ],[
778                 AC_MSG_RESULT(yes)
779                 AC_DEFINE(HAVE_SK_BUFF_CSUM_LEVEL, 1,
780                           [csum_level is defined])
781         ],[
782                 AC_MSG_RESULT(no)
783         ])
784
785         AC_MSG_CHECKING([if struct skbuff.h has skb_inner_transport_header])
786         LB_LINUX_TRY_COMPILE([
787                 #include <linux/skbuff.h>
788         ],[
789                 skb_inner_transport_header(NULL);
790
791                 return 0;
792         ],[
793                 AC_MSG_RESULT(yes)
794                 AC_DEFINE(HAVE_SKB_INNER_TRANSPORT_HEADER, 1,
795                           [skb_inner_transport_header is defined])
796         ],[
797                 AC_MSG_RESULT(no)
798         ])
799
800         AC_MSG_CHECKING([if struct skbuff.h has skb_inner_network_header])
801         LB_LINUX_TRY_COMPILE([
802                 #include <linux/skbuff.h>
803         ],[
804                 skb_inner_network_header(NULL);
805
806                 return 0;
807         ],[
808                 AC_MSG_RESULT(yes)
809                 AC_DEFINE(HAVE_SKB_INNER_NETWORK_HEADER, 1,
810                           [skb_inner_network_header is defined])
811         ],[
812                 AC_MSG_RESULT(no)
813         ])
814
815         AC_MSG_CHECKING([if if_vlan.h has vlan_dev_get_egress_qos_mask])
816         LB_LINUX_TRY_COMPILE([
817                 #include <linux/if_vlan.h>
818         ],[
819                 vlan_dev_get_egress_qos_mask(NULL, 0);
820
821                 return 0;
822         ],[
823                 AC_MSG_RESULT(yes)
824                 AC_DEFINE(HAVE_VLAN_DEV_GET_EGRESS_QOS_MASK, 1,
825                           [vlan_dev_get_egress_qos_mask is defined])
826         ],[
827                 AC_MSG_RESULT(no)
828         ])
829
830         AC_MSG_CHECKING([if netdevice.h has netdev_get_prio_tc_map])
831         LB_LINUX_TRY_COMPILE([
832                 #include <linux/netdevice.h>
833         ],[
834                 netdev_get_prio_tc_map(NULL, 0);
835
836                 return 0;
837         ],[
838                 AC_MSG_RESULT(yes)
839                 AC_DEFINE(HAVE_NETDEV_GET_PRIO_TC_MAP, 1,
840                           [netdev_get_prio_tc_map is defined])
841         ],[
842                 AC_MSG_RESULT(no)
843         ])
844
845         AC_MSG_CHECKING([if if_vlan.h has __vlan_find_dev_deep_rcu])
846         LB_LINUX_TRY_COMPILE([
847                 #include <linux/if_vlan.h>
848         ],[
849                 __vlan_find_dev_deep_rcu(NULL, 0, 0);
850
851                 return 0;
852         ],[
853                 AC_MSG_RESULT(yes)
854                 AC_DEFINE(HAVE___VLAN_FIND_DEV_DEEP_RCU, 1,
855                           [__vlan_find_dev_deep_rcu is defined])
856         ],[
857                 AC_MSG_RESULT(no)
858         ])
859
860         AC_MSG_CHECKING([if ndo_select_queue has accel_priv])
861         LB_LINUX_TRY_COMPILE([
862                 #include <linux/netdevice.h>
863
864                 static u16 select_queue(struct net_device *dev, struct sk_buff *skb,
865                                         void *accel_priv)
866                 {
867                         return 0;
868                 }
869         ],[
870                 struct net_device_opts ndops;
871
872                 ndops.ndo_select_queue = select_queue;
873
874                 return 0;
875         ],[
876                 AC_MSG_RESULT(yes)
877                 AC_DEFINE(NDO_SELECT_QUEUE_HAS_ACCEL_PRIV, 1,
878                           [ndo_select_queue has accel_priv])
879         ],[
880                 AC_MSG_RESULT(no)
881         ])
882
883         AC_MSG_CHECKING([if drivers/net/bonding/bonding.h exists])
884         LB_LINUX_TRY_COMPILE([
885                 #include "../drivers/net/bonding/bonding.h"
886         ],[
887                 return 0;
888         ],[
889                 AC_MSG_RESULT(yes)
890                 AC_DEFINE(HAVE_BONDING_H, 1,
891                           [drivers/net/bonding/bonding.h exists])
892         ],[
893                 AC_MSG_RESULT(no)
894         ])
895
896         AC_MSG_CHECKING([if bonding.h bond_for_each_slave has 3 parameters])
897         LB_LINUX_TRY_COMPILE([
898                 #include "../drivers/net/bonding/bonding.h"
899         ],[
900                 struct bonding *bond = NULL;
901                 struct list_head *iter = NULL;
902                 struct slave *slave = NULL;
903
904                 bond_for_each_slave(bond, slave, iter) ;
905
906                 return 0;
907         ],[
908                 AC_MSG_RESULT(yes)
909                 AC_DEFINE(HAVE_BOND_FOR_EACH_SLAVE_3_PARAMS, 1,
910                           [bond_for_each_slave has 3 parameters])
911         ],[
912                 AC_MSG_RESULT(no)
913         ])
914
915
916         AC_MSG_CHECKING([if u64_stats_sync.h has u64_stats_init])
917         LB_LINUX_TRY_COMPILE([
918                 #include <linux/u64_stats_sync.h>
919         ],[
920                 struct u64_stats_sync sync;
921                 u64_stats_init(&sync);
922
923                 return 0;
924         ],[
925                 AC_MSG_RESULT(yes)
926                 AC_DEFINE(HAVE_U64_STATS_SYNC, 1,
927                           [u64_stats_sync is defined])
928         ],[
929                 AC_MSG_RESULT(no)
930         ])
931
932         AC_MSG_CHECKING([if u64_stats_sync.h has u64_stats_fetch_begin_irq])
933         LB_LINUX_TRY_COMPILE([
934                 #include <linux/u64_stats_sync.h>
935         ],[
936                 struct u64_stats_sync sync;
937                 u64_stats_fetch_begin_irq(&sync);
938
939                 return 0;
940         ],[
941                 AC_MSG_RESULT(yes)
942                 AC_DEFINE(HAVE_U64_STATS_FETCH_BEGIN_IRQ, 1,
943                           [u64_stats_fetch_begin_irq is defined])
944         ],[
945                 AC_MSG_RESULT(no)
946         ])
947         AC_MSG_CHECKING([if etherdevice.h has ether_addr_copy])
948         LB_LINUX_TRY_COMPILE([
949                 #include <linux/etherdevice.h>
950         ],[
951                 char dest[6], src[6];
952                 ether_addr_copy(&dest, &src);
953
954                 return 0;
955         ],[
956                 AC_MSG_RESULT(yes)
957                 AC_DEFINE(HAVE_ETHER_ADDR_COPY, 1,
958                           [ether_addr_copy is defined])
959         ],[
960                 AC_MSG_RESULT(no)
961         ])
962
963         AC_MSG_CHECKING([if struct net_device_ops has *ndo_set_vf_rate])
964         LB_LINUX_TRY_COMPILE([
965                 #include <linux/netdevice.h>
966
967                 int set_vf_rate(struct net_device *dev, int vf, int min_tx_rate,
968                                                    int max_tx_rate)
969                 {
970                         return 0;
971                 }
972         ],[
973                 struct net_device_ops netdev_ops;
974
975                 netdev_ops.ndo_set_vf_rate = set_vf_rate;
976                 return 0;
977         ],[
978                 AC_MSG_RESULT(yes)
979                 AC_DEFINE(HAVE_SET_VF_RATE, 1,
980                           [ndo_set_vf_rate is defined])
981         ],[
982                 AC_MSG_RESULT(no)
983         ])
984
985         AC_MSG_CHECKING([if netdev_extended has hw_features])
986         LB_LINUX_TRY_COMPILE([
987                 #include <linux/netdevice.h>
988         ],[
989                 struct net_device *dev = NULL;
990
991                 netdev_extended(dev)->hw_features = 0;
992
993                 return 0;
994         ],[
995                 AC_MSG_RESULT(yes)
996                 AC_DEFINE(HAVE_NETDEV_EXTENDED_HW_FEATURES, 1,
997                           [ is defined])
998         ],[
999                 AC_MSG_RESULT(no)
1000         ])
1001
1002         AC_MSG_CHECKING([if net_device_extended has _tx_ext])
1003         LB_LINUX_TRY_COMPILE([
1004                 #include <linux/netdevice.h>
1005         ],[
1006                 struct net_device *dev = NULL;
1007
1008                 netdev_extended(dev)->_tx_ext = NULL;
1009
1010                 return 0;
1011         ],[
1012                 AC_MSG_RESULT(yes)
1013                 AC_DEFINE(HAVE_NET_DEVICE_EXTENDED_TX_EXT, 1,
1014                           [ is defined])
1015         ],[
1016                 AC_MSG_RESULT(no)
1017         ])
1018
1019         AC_MSG_CHECKING([if net_device_extended has ndo_busy_poll])
1020         LB_LINUX_TRY_COMPILE([
1021                 #include <linux/netdevice.h>
1022
1023                 int busy_poll(struct napi_struct *napi)
1024                 {
1025                         return 0;
1026                 }
1027         ],[
1028                 struct net_device *dev = NULL;
1029
1030                 netdev_extended(dev)->ndo_busy_poll = busy_poll;
1031
1032                 return 0;
1033         ],[
1034                 AC_MSG_RESULT(yes)
1035                 AC_DEFINE(HAVE_NETDEV_EXTENDED_NDO_BUSY_POLL, 1,
1036                           [ is defined])
1037         ],[
1038                 AC_MSG_RESULT(no)
1039         ])
1040
1041         AC_MSG_CHECKING([if netdevice.h has set_netdev_hw_features])
1042         LB_LINUX_TRY_COMPILE([
1043                 #include <linux/netdevice.h>
1044         ],[
1045                 struct net_device *dev = NULL;
1046
1047                 set_netdev_hw_features(dev, 0);
1048
1049                 return 0;
1050         ],[
1051                 AC_MSG_RESULT(yes)
1052                 AC_DEFINE(HAVE_SET_NETDEV_HW_FEATURES, 1,
1053                           [ is defined])
1054         ],[
1055                 AC_MSG_RESULT(no)
1056         ])
1057
1058         AC_MSG_CHECKING([if netdevice.h has netif_set_xps_queue])
1059         LB_LINUX_TRY_COMPILE([
1060                 #include <linux/netdevice.h>
1061         ],[
1062                 struct net_device *dev = NULL;
1063
1064                 netif_set_xps_queue(dev, NULL, 0);
1065
1066                 return 0;
1067         ],[
1068                 AC_MSG_RESULT(yes)
1069                 AC_DEFINE(HAVE_NETIF_SET_XPS_QUEUE, 1,
1070                           [ is defined])
1071         ],[
1072                 AC_MSG_RESULT(no)
1073         ])
1074
1075
1076         AC_MSG_CHECKING([if struct net_device_ops has *ndo_set_features])
1077         LB_LINUX_TRY_COMPILE([
1078                 #include <linux/netdevice.h>
1079
1080                 int set_features(struct net_device *dev, netdev_features_t features)
1081                 {
1082                         return 0;
1083                 }
1084         ],[
1085                 struct net_device_ops netdev_ops;
1086
1087                 netdev_ops.ndo_set_features = set_features;
1088                 return 0;
1089         ],[
1090                 AC_MSG_RESULT(yes)
1091                 AC_DEFINE(HAVE_NDO_SET_FEATURES, 1,
1092                           [ndo_set_features is defined])
1093         ],[
1094                 AC_MSG_RESULT(no)
1095         ])
1096
1097         AC_MSG_CHECKING([if struct net_device_ops has *ndo_setup_tc])
1098         LB_LINUX_TRY_COMPILE([
1099                 #include <linux/netdevice.h>
1100
1101                 int setup_tc(struct net_device *dev, , u8 tc)
1102                 {
1103                         return 0;
1104                 }
1105         ],[
1106                 struct net_device_ops netdev_ops;
1107
1108                 netdev_ops.ndo_setup_tc = setup_tc;
1109                 return 0;
1110         ],[
1111                 AC_MSG_RESULT(yes)
1112                 AC_DEFINE(HAVE_NDO_SETUP_TC, 1,
1113                           [ndo_setup_tc is defined])
1114         ],[
1115                 AC_MSG_RESULT(no)
1116         ])
1117
1118         AC_MSG_CHECKING([if struct net_device_ops has *ndo_rx_flow_steer])
1119         LB_LINUX_TRY_COMPILE([
1120                 #include <linux/netdevice.h>
1121
1122                 int rx_flow_steer(struct net_device *dev,
1123                                                      const struct sk_buff *skb,
1124                                                      u16 rxq_index,
1125                                                      u32 flow_id)
1126                 {
1127                         return 0;
1128                 }
1129         ],[
1130                 struct net_device_ops netdev_ops;
1131
1132                 netdev_ops.ndo_rx_flow_steer = rx_flow_steer;
1133                 return 0;
1134         ],[
1135                 AC_MSG_RESULT(yes)
1136                 AC_DEFINE(HAVE_NDO_RX_FLOW_STEER, 1,
1137                           [ndo_rx_flow_steer is defined])
1138         ],[
1139                 AC_MSG_RESULT(no)
1140         ])
1141
1142         AC_MSG_CHECKING([if struct net_device has priv_flags])
1143         LB_LINUX_TRY_COMPILE([
1144                 #include <linux/netdevice.h>
1145         ],[
1146                 struct net_device *netdev;
1147                 netdev->priv_flags = 0;
1148
1149                 return 0;
1150         ],[
1151                 AC_MSG_RESULT(yes)
1152                 AC_DEFINE(HAVE_NET_DEVICE_PRIV_FLAGS, 1,
1153                           [priv_flags is defined])
1154         ],[
1155                 AC_MSG_RESULT(no)
1156         ])
1157
1158         AC_MSG_CHECKING([if struct net_device_ops has *ndo_get_stats64])
1159         LB_LINUX_TRY_COMPILE([
1160                 #include <linux/netdevice.h>
1161
1162                 struct rtnl_link_stats64* get_stats_64(struct net_device *dev,
1163                                                      struct rtnl_link_stats64 *storage)
1164                 {
1165                         struct rtnl_link_stats64 stats_64;
1166                         return &stats_64;
1167                 }
1168         ],[
1169                 struct net_device_ops netdev_ops;
1170
1171                 netdev_ops.ndo_get_stats64 = get_stats_64;
1172
1173                 return 0;
1174         ],[
1175                 AC_MSG_RESULT(yes)
1176                 AC_DEFINE(HAVE_NDO_GET_STATS64, 1,
1177                           [ndo_get_stats64 is defined])
1178         ],[
1179                 AC_MSG_RESULT(no)
1180         ])
1181         AC_MSG_CHECKING([if struct net_device_ops has ndo_bridge_set/getlink])
1182         LB_LINUX_TRY_COMPILE([
1183                 #include <linux/netdevice.h>
1184         ],[
1185                 struct net_device_ops netdev_ops =  {
1186                         .ndo_bridge_setlink = NULL,
1187                         .ndo_bridge_getlink = NULL,
1188                 };
1189
1190                 return 0;
1191         ],[
1192                 AC_MSG_RESULT(yes)
1193                 AC_DEFINE(HAVE_NDO_BRIDGE_SET_GET_LINK, 1,
1194                           [ndo_bridge_set/getlink is defined])
1195         ],[
1196                 AC_MSG_RESULT(no)
1197         ])
1198
1199         AC_MSG_CHECKING([if struct net_device_ops ndo_vlan_rx_add_vid has 3 parameters ])
1200         LB_LINUX_TRY_COMPILE([
1201                 #include <linux/netdevice.h>
1202
1203                 int vlan_rx_add_vid(struct net_device *dev,__be16 proto, u16 vid)
1204                 {
1205                         return 0;
1206                 }
1207         ],[
1208                 struct net_device_ops netdev_ops;
1209
1210                 netdev_ops.ndo_vlan_rx_add_vid = vlan_rx_add_vid;
1211
1212                 return 0;
1213         ],[
1214                 AC_MSG_RESULT(yes)
1215                 AC_DEFINE(HAVE_NDO_RX_ADD_VID_HAS_3_PARAMS, 1,
1216                           [ndo_vlan_rx_add_vid has 3 parameters])
1217         ],[
1218                 AC_MSG_RESULT(no)
1219         ])
1220
1221         AC_MSG_CHECKING([if net_device_ops has ndo_get_phys_port_id])
1222         LB_LINUX_TRY_COMPILE([
1223                 #include <linux/netdevice.h>
1224
1225                 int get_phys_port_id(struct net_device *dev,
1226                                      struct netdev_phys_port_id *ppid)
1227                 {
1228                         return 0;
1229                 }
1230         ],[
1231                 struct net_device_ops netdev_ops;
1232
1233                 netdev_ops.ndo_get_phys_port_id = get_phys_port_id;
1234
1235                 return 0;
1236         ],[
1237                 AC_MSG_RESULT(yes)
1238                 AC_DEFINE(HAVE_NETDEV_NDO_GET_PHYS_PORT_ID, 1,
1239                           [ is defined])
1240         ],[
1241                 AC_MSG_RESULT(no)
1242         ])
1243
1244         AC_MSG_CHECKING([if struct net_device_ops_ext exist])
1245         LB_LINUX_TRY_COMPILE([
1246                 #include <linux/netdevice.h>
1247         ],[
1248                 struct net_device_ops_ext netdev_ops_ext;
1249                 struct net_device_ops_ext netdev_ops__ext = {
1250                         .size                   = sizeof(struct net_device_ops_ext),
1251                 };
1252
1253                 return 0;
1254         ],[
1255                 AC_MSG_RESULT(yes)
1256                 AC_DEFINE(HAVE_NET_DEVICE_OPS_EXT, 1,
1257                           [struct net_device_ops_ext is defined])
1258         ],[
1259                 AC_MSG_RESULT(no)
1260         ])
1261
1262         AC_MSG_CHECKING([if net_device_ops_ext has ndo_get_phys_port_id])
1263         LB_LINUX_TRY_COMPILE([
1264                 #include <linux/netdevice.h>
1265
1266                 int get_phys_port_id(struct net_device *dev,
1267                                      struct netdev_phys_port_id *ppid)
1268                 {
1269                         return 0;
1270                 }
1271         ],[
1272                 struct net_device_ops_ext netdev_ops_ext;
1273
1274                 netdev_ops_ext.ndo_get_phys_port_id = get_phys_port_id;
1275
1276                 return 0;
1277         ],[
1278                 AC_MSG_RESULT(yes)
1279                 AC_DEFINE(HAVE_NETDEV_EXT_NDO_GET_PHYS_PORT_ID, 1,
1280                           [ndo_get_phys_port_id is defined])
1281         ],[
1282                 AC_MSG_RESULT(no)
1283         ])
1284
1285         AC_MSG_CHECKING([if net_device_ops has ndo_set_vf_spoofchk])
1286         LB_LINUX_TRY_COMPILE([
1287                 #include <linux/netdevice.h>
1288
1289                 int set_vf_spoofchk(struct net_device *dev, int vf, bool setting)
1290                 {
1291                         return 0;
1292                 }
1293         ],[
1294                 struct net_device_ops netdev_ops;
1295
1296                 netdev_ops.ndo_set_vf_spoofchk = set_vf_spoofchk;
1297
1298                 return 0;
1299         ],[
1300                 AC_MSG_RESULT(yes)
1301                 AC_DEFINE(HAVE_NETDEV_OPS_NDO_SET_VF_SPOOFCHK, 1,
1302                           [ndo_set_vf_spoofchk is defined in net_device_ops])
1303         ],[
1304                 AC_MSG_RESULT(no)
1305         ])
1306
1307         AC_MSG_CHECKING([if net_device_ops_ext has ndo_set_vf_spoofchk])
1308         LB_LINUX_TRY_COMPILE([
1309                 #include <linux/netdevice.h>
1310
1311                 int set_vf_spoofchk(struct net_device *dev, int vf, bool setting)
1312                 {
1313                         return 0;
1314                 }
1315         ],[
1316                 struct net_device_ops_ext netdev_ops_ext;
1317
1318                 netdev_ops_ext.ndo_set_vf_spoofchk = set_vf_spoofchk;
1319
1320                 return 0;
1321         ],[
1322                 AC_MSG_RESULT(yes)
1323                 AC_DEFINE(HAVE_NETDEV_OPS_EXT_NDO_SET_VF_SPOOFCHK, 1,
1324                           [ndo_set_vf_spoofchk is defined in net_device_ops_ext])
1325         ],[
1326                 AC_MSG_RESULT(no)
1327         ])
1328
1329         AC_MSG_CHECKING([if net_device_ops has ndo_set_vf_link_state])
1330         LB_LINUX_TRY_COMPILE([
1331                 #include <linux/netdevice.h>
1332
1333                 int set_vf_link_state(struct net_device *dev, int vf, int link_state)
1334                 {
1335                         return 0;
1336                 }
1337         ],[
1338                 struct net_device_ops netdev_ops;
1339
1340                 netdev_ops.ndo_set_vf_link_state = set_vf_link_state;
1341
1342                 return 0;
1343         ],[
1344                 AC_MSG_RESULT(yes)
1345                 AC_DEFINE(HAVE_NETDEV_OPS_NDO_SET_VF_LINK_STATE, 1,
1346                           [ndo_set_vf_link_state is defined in net_device_ops])
1347         ],[
1348                 AC_MSG_RESULT(no)
1349         ])
1350
1351         AC_MSG_CHECKING([if net_device_ops_ext has ndo_set_vf_link_state])
1352         LB_LINUX_TRY_COMPILE([
1353                 #include <linux/netdevice.h>
1354
1355                 int set_vf_link_state(struct net_device *dev, int vf, int link_state)
1356                 {
1357                         return 0;
1358                 }
1359         ],[
1360                 struct net_device_ops_ext netdev_ops_ext;
1361
1362                 netdev_ops_ext.ndo_set_vf_link_state = set_vf_link_state;
1363
1364                 return 0;
1365         ],[
1366                 AC_MSG_RESULT(yes)
1367                 AC_DEFINE(HAVE_NETDEV_OPS_EXT_NDO_SET_VF_LINK_STATE, 1,
1368                           [ndo_set_vf_link_state is defined])
1369         ],[
1370                 AC_MSG_RESULT(no)
1371         ])
1372
1373
1374         AC_MSG_CHECKING([if netdevice.h netif_set_real_num_tx_queues returns int])
1375         LB_LINUX_TRY_COMPILE([
1376                 #include <linux/netdevice.h>
1377         ],[
1378                 struct net_device dev;
1379                 int ret;
1380                 ret = netif_set_real_num_tx_queues(&dev, 2);
1381                 return 0;
1382         ],[
1383                 AC_MSG_RESULT(yes)
1384                 AC_DEFINE(HAVE_RETURN_INT_FOR_SET_NUM_TX_QUEUES, 1,
1385                           [netif_set_real_num_tx_queues returns int])
1386         ],[
1387                 AC_MSG_RESULT(no)
1388         ])
1389
1390         AC_MSG_CHECKING([if struct netdevice.h has struct xps_map])
1391         LB_LINUX_TRY_COMPILE([
1392                 #include <linux/netdevice.h>
1393         ],[
1394                 struct xps_map map;
1395                 map.len = 0;
1396
1397                 return 0;
1398         ],[
1399                 AC_MSG_RESULT(yes)
1400                 AC_DEFINE(HAVE_XPS_MAP, 1,
1401                           [struct xps_map is defined])
1402         ],[
1403                 AC_MSG_RESULT(no)
1404         ])
1405
1406         AC_MSG_CHECKING([if struct ethtool_ops has set_phys_id])
1407         LB_LINUX_TRY_COMPILE([
1408                 #include <linux/ethtool.h>
1409         ],[
1410                 const struct ethtool_ops en_ethtool_ops = {
1411                         .set_phys_id= NULL,
1412                 };
1413
1414                 return 0;
1415         ],[
1416                 AC_MSG_RESULT(yes)
1417                 AC_DEFINE(HAVE_SET_PHYS_ID, 1,
1418                           [set_phys_id is defined])
1419         ],[
1420                 AC_MSG_RESULT(no)
1421         ])
1422
1423         AC_MSG_CHECKING([if struct ethtool_ops has get/set_channels])
1424         LB_LINUX_TRY_COMPILE([
1425                 #include <linux/ethtool.h>
1426         ],[
1427                 const struct ethtool_ops en_ethtool_ops = {
1428                         .get_channels = NULL,
1429                         .set_channels = NULL,
1430                 };
1431
1432                 return 0;
1433         ],[
1434                 AC_MSG_RESULT(yes)
1435                 AC_DEFINE(HAVE_GET_SET_CHANNELS, 1,
1436                           [get/set_channels is defined])
1437         ],[
1438                 AC_MSG_RESULT(no)
1439         ])
1440
1441         AC_MSG_CHECKING([if struct ethtool_ops_ext has get/set_channels])
1442         LB_LINUX_TRY_COMPILE([
1443                 #include <linux/ethtool.h>
1444         ],[
1445                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
1446                         .get_channels = NULL,
1447                         .set_channels = NULL,
1448                 };
1449
1450                 return 0;
1451         ],[
1452                 AC_MSG_RESULT(yes)
1453                 AC_DEFINE(HAVE_GET_SET_CHANNELS_EXT, 1,
1454                           [get/set_channels is defined in ethtool_ops_ext])
1455         ],[
1456                 AC_MSG_RESULT(no)
1457         ])
1458
1459         AC_MSG_CHECKING([if struct ethtool_ops has get_ts_info])
1460         LB_LINUX_TRY_COMPILE([
1461                 #include <linux/ethtool.h>
1462         ],[
1463                 const struct ethtool_ops en_ethtool_ops = {
1464                         .get_ts_info = NULL,
1465                 };
1466
1467                 return 0;
1468         ],[
1469                 AC_MSG_RESULT(yes)
1470                 AC_DEFINE(HAVE_GET_TS_INFO, 1,
1471                           [get_ts_info is defined])
1472         ],[
1473                 AC_MSG_RESULT(no)
1474         ])
1475
1476         AC_MSG_CHECKING([if struct ethtool_ops_ext has get_ts_info])
1477         LB_LINUX_TRY_COMPILE([
1478                 #include <linux/ethtool.h>
1479         ],[
1480                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
1481                         .get_ts_info = NULL,
1482                 };
1483
1484                 return 0;
1485         ],[
1486                 AC_MSG_RESULT(yes)
1487                 AC_DEFINE(HAVE_GET_TS_INFO_EXT, 1,
1488                           [get_ts_info is defined in ethtool_ops_ext])
1489         ],[
1490                 AC_MSG_RESULT(no)
1491         ])
1492
1493         AC_MSG_CHECKING([if struct ethtool_flow_ext has h_dest])
1494         LB_LINUX_TRY_COMPILE([
1495                 #include <linux/ethtool.h>
1496         ],[
1497                 unsigned char mac[ETH_ALEN];
1498                 struct ethtool_flow_ext h_ext;
1499
1500                 memcpy(&mac, h_ext.h_dest, ETH_ALEN);
1501
1502                 return 0;
1503         ],[
1504                 AC_MSG_RESULT(yes)
1505                 AC_DEFINE(HAVE_ETHTOOL_FLOW_EXT_H_DEST, 1,
1506                           [ethtool_flow_ext has h_dest])
1507         ],[
1508                 AC_MSG_RESULT(no)
1509         ])
1510
1511         AC_MSG_CHECKING([if netdevice.h has struct netdev_hw_addr])
1512         LB_LINUX_TRY_COMPILE([
1513                 #include <linux/netdevice.h>
1514         ],[
1515                 struct netdev_hw_addr addr;
1516                 return 0;
1517         ],[
1518                 AC_MSG_RESULT(yes)
1519                 AC_DEFINE(HAVE_NETDEV_HW_ADDR, 1,
1520                           [netdev_hw_addr is defined])
1521         ],[
1522                 AC_MSG_RESULT(no)
1523         ])
1524
1525         AC_MSG_CHECKING([if pci.h has pci_vfs_assigned])
1526         LB_LINUX_TRY_COMPILE([
1527                 #include <linux/pci.h>
1528         ],[
1529                 struct pci_dev pdev;
1530                 pci_vfs_assigned(&pdev);
1531                 return 0;
1532         ],[
1533                 AC_MSG_RESULT(yes)
1534                 AC_DEFINE(HAVE_PCI_VF_ASSIGNED, 1,
1535                           [pci_vfs_assigned is defined])
1536         ],[
1537                 AC_MSG_RESULT(no)
1538         ])
1539         AC_MSG_CHECKING([if __vlan_put_tag has 3 parameters])
1540         LB_LINUX_TRY_COMPILE([
1541                 #include <linux/if_vlan.h>
1542         ],[
1543                 struct sk_buff *skb;
1544                 __vlan_put_tag(skb, 0, 0);
1545
1546                 return 0;
1547         ],[
1548                 AC_MSG_RESULT(yes)
1549                 AC_DEFINE(HAVE_3_PARAMS_FOR_VLAN_PUT_TAG, 1,
1550                           [__vlan_put_tag has 3 parameters])
1551         ],[
1552                 AC_MSG_RESULT(no)
1553         ])
1554
1555         AC_MSG_CHECKING([if __vlan_hwaccel_put_tag has 3 parameters])
1556         LB_LINUX_TRY_COMPILE([
1557                 #include <linux/if_vlan.h>
1558         ],[
1559                 struct sk_buff *skb;
1560                 __vlan_hwaccel_put_tag(skb, 0, 0);
1561
1562                 return 0;
1563         ],[
1564                 AC_MSG_RESULT(yes)
1565                 AC_DEFINE(HAVE_3_PARAMS_FOR_VLAN_HWACCEL_PUT_TAG, 1,
1566                           [__vlan_hwaccel_put_tag has 3 parameters])
1567         ],[
1568                 AC_MSG_RESULT(no)
1569         ])
1570
1571         AC_MSG_CHECKING([if struct net_device has hw_features])
1572         LB_LINUX_TRY_COMPILE([
1573                 #include <linux/netdevice.h>
1574         ],[
1575                 struct net_device dev;
1576                 dev.hw_features = 0;
1577
1578                 return 0;
1579         ],[
1580                 AC_MSG_RESULT(yes)
1581                 AC_DEFINE(HAVE_NETDEV_HW_FEATURES, 1,
1582                           [hw_features is defined])
1583         ],[
1584                 AC_MSG_RESULT(no)
1585         ])
1586
1587         AC_MSG_CHECKING([if struct net_device has hw_enc_features])
1588         LB_LINUX_TRY_COMPILE([
1589                 #include <linux/netdevice.h>
1590         ],[
1591                 struct net_device dev;
1592                 dev.hw_enc_features = 0;
1593
1594                 return 0;
1595         ],[
1596                 AC_MSG_RESULT(yes)
1597                 AC_DEFINE(HAVE_NETDEV_HW_ENC_FEATURES, 1,
1598                           [hw_enc_features is defined])
1599         ],[
1600                 AC_MSG_RESULT(no)
1601         ])
1602
1603         AC_MSG_CHECKING([if struct net_device has rx_cpu_rmap])
1604         LB_LINUX_TRY_COMPILE([
1605                 #include <linux/netdevice.h>
1606         ],[
1607                 struct net_device dev;
1608                 dev.rx_cpu_rmap = NULL;
1609
1610                 return 0;
1611         ],[
1612                 AC_MSG_RESULT(yes)
1613                 AC_DEFINE(HAVE_NETDEV_RX_CPU_RMAP, 1,
1614                           [rx_cpu_rmap is defined])
1615         ],[
1616                 AC_MSG_RESULT(no)
1617         ])
1618
1619         AC_MSG_CHECKING([if if_vlan.h has vlan_hwaccel_receive_skb])
1620         LB_LINUX_TRY_COMPILE([
1621                 #include <linux/if_vlan.h>
1622         ],[
1623                 struct sk_buff *skb;
1624                 vlan_hwaccel_receive_skb(skb,0,0);
1625                 return 0;
1626         ],[
1627                 AC_MSG_RESULT(yes)
1628                 AC_DEFINE(HAVE_VLAN_HWACCEL_RECEIVE_SKB, 1,
1629                           [vlan_hwaccel_receive_skb is defined])
1630         ],[
1631                 AC_MSG_RESULT(no)
1632         ])
1633
1634         AC_MSG_CHECKING([if irqdesc.h has irq_desc_get_irq_data])
1635         LB_LINUX_TRY_COMPILE([
1636                 #include <linux/irqdesc.h>
1637         ],[
1638                 struct irq_data *data = irq_desc_get_irq_data(NULL);
1639                 return 0;
1640         ],[
1641                 AC_MSG_RESULT(yes)
1642                 AC_DEFINE(HAVE_IRQ_DESC_GET_IRQ_DATA, 1,
1643                           [irq_desc_get_irq_data is defined])
1644         ],[
1645                 AC_MSG_RESULT(no)
1646         ])
1647
1648
1649         AC_MSG_CHECKING([if pci_dev has pcie_mpss])
1650         LB_LINUX_TRY_COMPILE([
1651                 #include <linux/pci.h>
1652         ],[
1653                 struct pci_dev pdev;
1654
1655                 pdev->pcie_mpss = 0;
1656                 return 0;
1657         ],[
1658                 AC_MSG_RESULT(yes)
1659                 AC_DEFINE(HAVE_PCI_DEV_PCIE_MPSS, 1,
1660                           [pcie_mpss is defined])
1661         ],[
1662                 AC_MSG_RESULT(no)
1663         ])
1664
1665         AC_MSG_CHECKING([if uapi/linux/if_ether.h exist])
1666         LB_LINUX_TRY_COMPILE([
1667                 #include <uapi/linux/if_ether.h>
1668         ],[
1669                 return 0;
1670         ],[
1671                 AC_MSG_RESULT(yes)
1672                 AC_DEFINE(HAVE_UAPI_LINUX_IF_ETHER_H, 1,
1673                           [uapi/linux/if_ether.h exist])
1674         ],[
1675                 AC_MSG_RESULT(no)
1676         ])
1677
1678         AC_MSG_CHECKING([if ifla_vf_info has spoofchk])
1679         LB_LINUX_TRY_COMPILE([
1680                 #include <linux/if_link.h>
1681         ],[
1682                 struct ifla_vf_info *ivf;
1683
1684                 ivf->spoofchk = 0;
1685                 return 0;
1686         ],[
1687                 AC_MSG_RESULT(yes)
1688                 AC_DEFINE(HAVE_VF_INFO_SPOOFCHK, 1,
1689                           [spoofchk is defined])
1690         ],[
1691                 AC_MSG_RESULT(no)
1692         ])
1693
1694         AC_MSG_CHECKING([if dst.h has dst_get_neighbour])
1695         LB_LINUX_TRY_COMPILE([
1696                 #include <net/dst.h>
1697         ],[
1698                 struct neighbour *neigh = dst_get_neighbour(NULL);
1699
1700                 return 0;
1701         ],[
1702                 AC_MSG_RESULT(yes)
1703                 AC_DEFINE(HAVE_DST_GET_NEIGHBOUR, 1,
1704                           [ is defined])
1705         ],[
1706                 AC_MSG_RESULT(no)
1707         ])
1708
1709         AC_MSG_CHECKING([if netlink_dump_start has 6 parameters])
1710         LB_LINUX_TRY_COMPILE([
1711                 #include <linux/netlink.h>
1712         ],[
1713                 int ret = netlink_dump_start(NULL, NULL, NULL, NULL, NULL, 0);
1714
1715                 return 0;
1716         ],[
1717                 AC_MSG_RESULT(yes)
1718                 AC_DEFINE(HAVE_NETLINK_DUMP_START_6P, 1,
1719                           [ is defined])
1720         ],[
1721                 AC_MSG_RESULT(no)
1722         ])
1723
1724         AC_MSG_CHECKING([if netlink_dump_start has 5 parameters])
1725         LB_LINUX_TRY_COMPILE([
1726                 #include <linux/netlink.h>
1727         ],[
1728                 int ret = netlink_dump_start(NULL, NULL, NULL, NULL, NULL);
1729
1730                 return 0;
1731         ],[
1732                 AC_MSG_RESULT(yes)
1733                 AC_DEFINE(HAVE_NETLINK_DUMP_START_5P, 1,
1734                           [ is defined])
1735         ],[
1736                 AC_MSG_RESULT(no)
1737         ])
1738
1739         AC_MSG_CHECKING([if struct dcbnl_rtnl_ops has ieee_getmaxrate/ieee_setmaxrate])
1740         LB_LINUX_TRY_COMPILE([
1741                 #include <net/dcbnl.h>
1742         ],[
1743                 const struct dcbnl_rtnl_ops en_dcbnl_ops = {
1744                         .ieee_getmaxrate = NULL,
1745                         .ieee_setmaxrate = NULL,
1746                 };
1747
1748                 return 0;
1749         ],[
1750                 AC_MSG_RESULT(yes)
1751                 AC_DEFINE(HAVE_IEEE_GET_SET_MAXRATE, 1,
1752                           [ieee_getmaxrate/ieee_setmaxrate is defined])
1753         ],[
1754                 AC_MSG_RESULT(no)
1755         ])
1756 ])
1757 #
1758 # COMPAT_CONFIG_HEADERS
1759 #
1760 # add -include config.h
1761 #
1762 AC_DEFUN([COMPAT_CONFIG_HEADERS],[
1763         AC_CONFIG_HEADERS([config.h])
1764         EXTRA_KCFLAGS="-include $PWD/config.h $EXTRA_KCFLAGS"
1765         AC_SUBST(EXTRA_KCFLAGS)
1766 ])
1767
1768 AC_DEFUN([OFA_PROG_LINUX],
1769 [
1770
1771 LB_LINUX_PATH
1772 LB_LINUX_SYMVERFILE
1773 LB_LINUX_CONFIG([MODULES],[],[
1774     AC_MSG_ERROR([module support is required to build mlnx kernel modules.])
1775 ])
1776 LB_LINUX_CONFIG([MODVERSIONS])
1777 LB_LINUX_CONFIG([KALLSYMS],[],[
1778     AC_MSG_ERROR([compat_mlnx requires that CONFIG_KALLSYMS is enabled in your kernel.])
1779 ])
1780
1781 LINUX_CONFIG_COMPAT
1782 COMPAT_CONFIG_HEADERS
1783
1784 ])