rdma.m4: fix typo
[~tnikolova/compat/.git] / config / rdma.m4
1 dnl Checks for the in-box ib_core
2 AC_DEFUN([RDMA_CONFIG_COMPAT],
3 [
4         AC_MSG_CHECKING([if ib_verbs has ib_dma_map_single])
5         LB_LINUX_TRY_COMPILE([
6                 #include <linux/version.h>
7                 #include <linux/pci.h>
8                 #include <linux/gfp.h>
9                 #include <rdma/ib_verbs.h>
10         ],[
11                 ib_dma_map_single(NULL, NULL, 0, 0);
12                 return 0;
13         ],[
14                 AC_MSG_RESULT(yes)
15                 AC_DEFINE(HAVE_INBOX_IB_DMA_MAP, 1,
16                           [ib_dma_map_single defined])
17         ],[
18                 AC_MSG_RESULT(no)
19         ])
20
21         AC_MSG_CHECKING([if ib_create_cq wants comp_vector])
22         LB_LINUX_TRY_COMPILE([
23                 #include <linux/version.h>
24                 #include <linux/pci.h>
25                 #include <linux/gfp.h>
26                 #include <rdma/ib_verbs.h>
27         ],[
28                 ib_create_cq(NULL, NULL, NULL, NULL, 0, 0);
29                 return 0;
30         ],[
31                 AC_MSG_RESULT(yes)
32                 AC_DEFINE(HAVE_INBOX_IB_COMP_VECTOR, 1,
33                           [has completion vector])
34         ],[
35                 AC_MSG_RESULT(no)
36         ])
37
38         AC_MSG_CHECKING([if rdma_cm has RDMA_CM_EVENT_ADDR_CHANGE])
39         LB_LINUX_TRY_COMPILE([
40                 #include <linux/version.h>
41                 #include <linux/pci.h>
42                 #include <linux/gfp.h>
43                 #include <rdma/rdma_cm.h>
44         ],[
45                 return (RDMA_CM_EVENT_ADDR_CHANGE == 0);
46         ],[
47                 AC_MSG_RESULT(yes)
48                 AC_DEFINE(HAVE_INBOX_RDMA_CMEV_ADDRCHANGE, 1,
49                           [has completion vector])
50         ],[
51                 AC_MSG_RESULT(no)
52         ])
53
54         AC_MSG_CHECKING([if rdma_cm has RDMA_CM_EVENT_TIMEWAIT_EXIT])
55         LB_LINUX_TRY_COMPILE([
56                 #include <linux/version.h>
57                 #include <linux/pci.h>
58                 #include <linux/gfp.h>
59                 #include <rdma/rdma_cm.h>
60         ],[
61                 return (RDMA_CM_EVENT_TIMEWAIT_EXIT == 0);
62         ],[
63                 AC_MSG_RESULT(yes)
64                 AC_DEFINE(HAVE_INBOX_RDMA_CMEV_TIMEWAIT_EXIT, 1,
65                           [has completion vector])
66         ],[
67                 AC_MSG_RESULT(no)
68         ])
69
70         AC_MSG_CHECKING([if rdma_cm has rdma_set_reuseaddr])
71         LB_LINUX_TRY_COMPILE([
72                 #include <linux/version.h>
73                 #include <linux/pci.h>
74                 #include <linux/gfp.h>
75                 #include <rdma/rdma_cm.h>
76         ],[
77                 rdma_set_reuseaddr(NULL, 1);
78                 return 0;
79         ],[
80                 AC_MSG_RESULT(yes)
81                 AC_DEFINE(HAVE_INBOX_RDMA_SET_REUSEADDR, 1,
82                           [rdma_set_reuse defined])
83         ],[
84                 AC_MSG_RESULT(no)
85         ])
86
87         AC_MSG_CHECKING([if struct ib_wc has member named ts])
88         LB_LINUX_TRY_COMPILE([
89                 #include <linux/version.h>
90                 #include <rdma/ib_verbs.h>
91         ],[
92         struct ib_wc wc;
93         wc->ts.timestamp = 0;
94
95                 return 0;
96         ],[
97                 AC_MSG_RESULT(yes)
98                 AC_DEFINE(HAVE_INBOX_IB_WC_TS, 1,
99                           [ib_wc has member named ts])
100         ],[
101                 AC_MSG_RESULT(no)
102         ])
103
104         AC_MSG_CHECKING([if struct ib_ah_attr has member named dmac])
105         LB_LINUX_TRY_COMPILE([
106                 #include <linux/version.h>
107                 #include <rdma/ib_verbs.h>
108         ],[
109         struct ib_ah_attr *ah_attr;
110         memset(ah_attr->dmac, 0, 6);
111
112                 return 0;
113         ],[
114                 AC_MSG_RESULT(yes)
115                 AC_DEFINE(HAVE_INBOX_IB_AH_ATTR_DMAC, 1,
116                           [ah_attr has member named dmac])
117         ],[
118                 AC_MSG_RESULT(no)
119         ])
120
121         AC_MSG_CHECKING([if struct ib_ah_attr has member named vlan_id])
122         LB_LINUX_TRY_COMPILE([
123                 #include <linux/version.h>
124                 #include <rdma/ib_verbs.h>
125         ],[
126         struct ib_ah_attr *ah_attr;
127         ah_attr->vlan_id = 0;
128
129                 return 0;
130         ],[
131                 AC_MSG_RESULT(yes)
132                 AC_DEFINE(HAVE_INBOX_IB_AH_ATTR_VLAN_ID, 1,
133                           [ah_attr has member named vlan_id])
134         ],[
135                 AC_MSG_RESULT(no)
136         ])
137 ])
138
139 dnl Examine kernel functionality
140 AC_DEFUN([LINUX_CONFIG_COMPAT],
141 [
142         AC_MSG_CHECKING([if 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 check_protection])
350         LB_LINUX_TRY_COMPILE([
351                 #include <scsi/scsi_transport_iscsi.h>
352         ],[
353                 static struct iscsi_transport iscsi_iser_transport = {
354                         .check_protection = NULL,
355                 };
356
357                 return 0;
358         ],[
359                 AC_MSG_RESULT(yes)
360                 AC_DEFINE(HAVE_ISCSI_CHECK_PROTECTION, 1,
361                           [check_protection is defined])
362         ],[
363                 AC_MSG_RESULT(no)
364         ])
365
366         AC_MSG_CHECKING([if netdevice.h has select_queue_fallback_t])
367         LB_LINUX_TRY_COMPILE([
368                 #include <linux/netdevice.h>
369         ],[
370                 select_queue_fallback_t fallback;
371
372                 fallback = NULL;
373
374                 return 0;
375         ],[
376                 AC_MSG_RESULT(yes)
377                 AC_DEFINE(HAVE_SELECT_QUEUE_FALLBACK_T, 1,
378                           [select_queue_fallback_t is defined])
379         ],[
380                 AC_MSG_RESULT(no)
381         ])
382
383         AC_MSG_CHECKING([if skbuff.h has skb_set_hash])
384         LB_LINUX_TRY_COMPILE([
385                 #include <linux/netdevice.h>
386         ],[
387                 skb_set_hash(NULL, 0, PKT_HASH_TYPE_L3);
388
389                 return 0;
390         ],[
391                 AC_MSG_RESULT(yes)
392                 AC_DEFINE(HAVE_SKB_SET_HASH, 1,
393                           [skb_set_hash is defined])
394         ],[
395                 AC_MSG_RESULT(no)
396         ])
397
398         AC_MSG_CHECKING([if sockios.h has SIOCGHWTSTAMP])
399         LB_LINUX_TRY_COMPILE([
400                 #include <linux/sockios.h>
401         ],[
402                 int x = SIOCGHWTSTAMP;
403
404                 return 0;
405         ],[
406                 AC_MSG_RESULT(yes)
407                 AC_DEFINE(HAVE_SIOCGHWTSTAMP, 1,
408                           [SIOCGHWTSTAMP is defined])
409         ],[
410                 AC_MSG_RESULT(no)
411         ])
412
413         AC_MSG_CHECKING([if ip.h inet_get_local_port_range has 3 parameters])
414         LB_LINUX_TRY_COMPILE([
415                 #include <net/ip.h>
416         ],[
417                 inet_get_local_port_range(NULL, NULL, NULL);
418
419                 return 0;
420         ],[
421                 AC_MSG_RESULT(yes)
422                 AC_DEFINE(HAVE_INET_GET_LOCAL_PORT_RANGE_3_PARAMS, 1,
423                           [inet_get_local_port_range has 3 parameters])
424         ],[
425                 AC_MSG_RESULT(no)
426         ])
427
428         AC_MSG_CHECKING([if net.h has net_get_random_once])
429         LB_LINUX_TRY_COMPILE([
430                 #include <linux/net.h>
431         ],[
432                 net_get_random_once(NULL, 0);
433
434                 return 0;
435         ],[
436                 AC_MSG_RESULT(yes)
437                 AC_DEFINE(HAVE_NET_GET_RANDOM_ONCE, 1,
438                           [net_get_random_once is defined])
439         ],[
440                 AC_MSG_RESULT(no)
441         ])
442
443         AC_MSG_CHECKING([if inet_sock.h has __inet_ehashfn])
444         LB_LINUX_TRY_COMPILE([
445                 #include <net/inet_sock.h>
446         ],[
447                 __inet_ehashfn(0, 0, 0, 0, 0);
448
449                 return 0;
450         ],[
451                 AC_MSG_RESULT(yes)
452                 AC_DEFINE(HAVE_INET_EHASHFN, 1,
453                           [__inet_ehashfn is defined])
454         ],[
455                 AC_MSG_RESULT(no)
456         ])
457
458         AC_MSG_CHECKING([if err.h has PTR_ERR_OR_ZERO])
459         LB_LINUX_TRY_COMPILE([
460                 #include <linux/err.h>
461         ],[
462                 int x = PTR_ERR_OR_ZERO(NULL);
463
464                 return 0;
465         ],[
466                 AC_MSG_RESULT(yes)
467                 AC_DEFINE(HAVE_PTR_ERR_OR_ZERO, 1,
468                           [PTR_ERR_OR_ZERO is defined])
469         ],[
470                 AC_MSG_RESULT(no)
471         ])
472
473         AC_MSG_CHECKING([if struct iscsi_session has discovery_sess])
474         LB_LINUX_TRY_COMPILE([
475                 #include <scsi/libiscsi.h>
476         ],[
477                 struct iscsi_session session;
478                 session.discovery_sess = 0;
479
480                 return 0;
481         ],[
482                 AC_MSG_RESULT(yes)
483                 AC_DEFINE(HAVE_ISCSI_DISCOVERY_SESS, 1,
484                           [discovery_sess is defined])
485         ],[
486                 AC_MSG_RESULT(no)
487         ])
488
489         AC_MSG_CHECKING([if enum iscsi_param has ISCSI_PARAM_DISCOVERY_SESS])
490         LB_LINUX_TRY_COMPILE([
491                 #include <scsi/iscsi_if.h>
492         ],[
493                 int x = ISCSI_PARAM_DISCOVERY_SESS;
494
495                 return 0;
496         ],[
497                 AC_MSG_RESULT(yes)
498                 AC_DEFINE(HAVE_ISCSI_PARAM_DISCOVERY_SESS, 1,
499                           [ISCSI_PARAM_DISCOVERY_SESS is defined])
500         ],[
501                 AC_MSG_RESULT(no)
502         ])
503
504         AC_MSG_CHECKING([if pci.h has enum pcie_link_width])
505         LB_LINUX_TRY_COMPILE([
506                 #include <linux/pci.h>
507         ],[
508                 enum pcie_link_width width = PCIE_LNK_WIDTH_UNKNOWN;
509
510                 return 0;
511         ],[
512                 AC_MSG_RESULT(yes)
513                 AC_DEFINE(HAVE_PCIE_LINK_WIDTH, 1,
514                           [pcie_link_width is defined])
515         ],[
516                 AC_MSG_RESULT(no)
517         ])
518
519         AC_MSG_CHECKING([if pci.h has enum pci_bus_speed])
520         LB_LINUX_TRY_COMPILE([
521                 #include <linux/pci.h>
522         ],[
523                 enum pci_bus_speed speed = PCI_SPEED_UNKNOWN;
524
525                 return 0;
526         ],[
527                 AC_MSG_RESULT(yes)
528                 AC_DEFINE(HAVE_PCI_BUS_SPEED, 1,
529                           [pci_bus_speed is defined])
530         ],[
531                 AC_MSG_RESULT(no)
532         ])
533
534         AC_MSG_CHECKING([if netdevice.h has struct netdev_phys_port_id])
535         LB_LINUX_TRY_COMPILE([
536                 #include <linux/netdevice.h>
537         ],[
538                 struct netdev_phys_port_id *x = NULL;
539
540                 return 0;
541         ],[
542                 AC_MSG_RESULT(yes)
543                 AC_DEFINE(HAVE_NETDEV_PHYS_PORT_ID, 1,
544                           [netdev_phys_port_id is defined])
545         ],[
546                 AC_MSG_RESULT(no)
547         ])
548
549         AC_MSG_CHECKING([if struct ifla_vf_info has linkstate])
550         LB_LINUX_TRY_COMPILE([
551                 #include <linux/if_link.h>
552         ],[
553                 struct struct ifla_vf_info x;
554                 x->linkstate = 0;
555
556                 return 0;
557         ],[
558                 AC_MSG_RESULT(yes)
559                 AC_DEFINE(HAVE_LINKSTATE, 1,
560                           [linkstate is defined])
561         ],[
562                 AC_MSG_RESULT(no)
563         ])
564
565         AC_MSG_CHECKING([if busy_poll.h has skb_mark_napi_id])
566         LB_LINUX_TRY_COMPILE([
567                 #include <net/busy_poll.h>
568         ],[
569                 skb_mark_napi_id(NULL, NULL);
570
571                 return 0;
572         ],[
573                 AC_MSG_RESULT(yes)
574                 AC_DEFINE(HAVE_SKB_MARK_NAPI_ID, 1,
575                           [skb_mark_napi_id is defined])
576         ],[
577                 AC_MSG_RESULT(no)
578         ])
579
580         AC_MSG_CHECKING([if netdevice.h has napi_hash_add])
581         LB_LINUX_TRY_COMPILE([
582                 #include <linux/netdevice.h>
583         ],[
584                 napi_hash_add(NULL);
585
586                 return 0;
587         ],[
588                 AC_MSG_RESULT(yes)
589                 AC_DEFINE(HAVE_NAPI_HASH_ADD, 1,
590                           [napi_hash_add is defined])
591         ],[
592                 AC_MSG_RESULT(no)
593         ])
594
595         AC_MSG_CHECKING([if netdevice.h has netif_keep_dst])
596         LB_LINUX_TRY_COMPILE([
597                 #include <linux/netdevice.h>
598         ],[
599                 netif_keep_dst(NULL);
600
601                 return 0;
602         ],[
603                 AC_MSG_RESULT(yes)
604                 AC_DEFINE(HAVE_NETIF_KEEP_DST, 1,
605                           [netif_keep_dst is defined])
606         ],[
607                 AC_MSG_RESULT(no)
608         ])
609
610         AC_MSG_CHECKING([if mm.h has kvfree])
611         LB_LINUX_TRY_COMPILE([
612                 #include <linux/mm.h>
613         ],[
614                 kvfree(NULL);
615
616                 return 0;
617         ],[
618                 AC_MSG_RESULT(yes)
619                 AC_DEFINE(HAVE_KVFREE, 1,
620                           [kvfree is defined])
621         ],[
622                 AC_MSG_RESULT(no)
623         ])
624
625         AC_MSG_CHECKING([if netdevice.h has dev_consume_skb_any])
626         LB_LINUX_TRY_COMPILE([
627                 #include <linux/netdevice.h>
628         ],[
629                 dev_consume_skb_any(NULL);
630
631                 return 0;
632         ],[
633                 AC_MSG_RESULT(yes)
634                 AC_DEFINE(HAVE_DEV_CONSUME_SKB_ANY, 1,
635                           [dev_consume_skb_any is defined])
636         ],[
637                 AC_MSG_RESULT(no)
638         ])
639
640         AC_MSG_CHECKING([if netdevice.h has netdev_txq_bql_complete_prefetchw])
641         LB_LINUX_TRY_COMPILE([
642                 #include <linux/netdevice.h>
643         ],[
644                 netdev_txq_bql_complete_prefetchw(NULL);
645                 netdev_txq_bql_enqueue_prefetchw(NULL);
646
647                 return 0;
648         ],[
649                 AC_MSG_RESULT(yes)
650                 AC_DEFINE(HAVE_NETDEV_TXQ_BQL_PREFETCHW, 1,
651                           [netdev_txq_bql_complete_prefetchw is defined])
652         ],[
653                 AC_MSG_RESULT(no)
654         ])
655
656         AC_MSG_CHECKING([if struct sk_buff has xmit_more])
657         LB_LINUX_TRY_COMPILE([
658                 #include <linux/skbuff.h>
659         ],[
660                 struct sk_buff *skb;
661                 skb->xmit_more = 0;
662
663                 return 0;
664         ],[
665                 AC_MSG_RESULT(yes)
666                 AC_DEFINE(HAVE_SK_BUFF_XMIT_MORE, 1,
667                           [xmit_more is defined])
668         ],[
669                 AC_MSG_RESULT(no)
670         ])
671
672         AC_MSG_CHECKING([if etherdevice.h has eth_get_headlen])
673         LB_LINUX_TRY_COMPILE([
674                 #include <linux/etherdevice.h>
675         ],[
676                 eth_get_headlen(NULL, 0);
677
678                 return 0;
679         ],[
680                 AC_MSG_RESULT(yes)
681                 AC_DEFINE(HAVE_ETH_GET_HEADLEN, 1,
682                           [eth_get_headlen is defined])
683         ],[
684                 AC_MSG_RESULT(no)
685         ])
686
687         AC_MSG_CHECKING([if struct sk_buff has csum_level])
688         LB_LINUX_TRY_COMPILE([
689                 #include <linux/skbuff.h>
690         ],[
691                 struct sk_buff *skb;
692                 skb->csum_level = 0;
693
694                 return 0;
695         ],[
696                 AC_MSG_RESULT(yes)
697                 AC_DEFINE(HAVE_SK_BUFF_CSUM_LEVEL, 1,
698                           [csum_level is defined])
699         ],[
700                 AC_MSG_RESULT(no)
701         ])
702
703         AC_MSG_CHECKING([if struct skbuff.h has skb_inner_transport_header])
704         LB_LINUX_TRY_COMPILE([
705                 #include <linux/skbuff.h>
706         ],[
707                 skb_inner_transport_header(NULL);
708
709                 return 0;
710         ],[
711                 AC_MSG_RESULT(yes)
712                 AC_DEFINE(HAVE_SKB_INNER_TRANSPORT_HEADER, 1,
713                           [skb_inner_transport_header is defined])
714         ],[
715                 AC_MSG_RESULT(no)
716         ])
717
718         AC_MSG_CHECKING([if struct skbuff.h has skb_inner_network_header])
719         LB_LINUX_TRY_COMPILE([
720                 #include <linux/skbuff.h>
721         ],[
722                 skb_inner_network_header(NULL);
723
724                 return 0;
725         ],[
726                 AC_MSG_RESULT(yes)
727                 AC_DEFINE(HAVE_SKB_INNER_NETWORK_HEADER, 1,
728                           [skb_inner_network_header is defined])
729         ],[
730                 AC_MSG_RESULT(no)
731         ])
732
733         AC_MSG_CHECKING([if if_vlan.h has vlan_dev_get_egress_qos_mask])
734         LB_LINUX_TRY_COMPILE([
735                 #include <linux/if_vlan.h>
736         ],[
737                 vlan_dev_get_egress_qos_mask(NULL, 0);
738
739                 return 0;
740         ],[
741                 AC_MSG_RESULT(yes)
742                 AC_DEFINE(HAVE_VLAN_DEV_GET_EGRESS_QOS_MASK, 1,
743                           [vlan_dev_get_egress_qos_mask is defined])
744         ],[
745                 AC_MSG_RESULT(no)
746         ])
747
748         AC_MSG_CHECKING([if netdevice.h has netdev_get_prio_tc_map])
749         LB_LINUX_TRY_COMPILE([
750                 #include <linux/netdevice.h>
751         ],[
752                 netdev_get_prio_tc_map(NULL, 0);
753
754                 return 0;
755         ],[
756                 AC_MSG_RESULT(yes)
757                 AC_DEFINE(HAVE_NETDEV_GET_PRIO_TC_MAP, 1,
758                           [netdev_get_prio_tc_map is defined])
759         ],[
760                 AC_MSG_RESULT(no)
761         ])
762
763         AC_MSG_CHECKING([if if_vlan.h has __vlan_find_dev_deep_rcu])
764         LB_LINUX_TRY_COMPILE([
765                 #include <linux/if_vlan.h>
766         ],[
767                 __vlan_find_dev_deep_rcu(NULL, 0, 0);
768
769                 return 0;
770         ],[
771                 AC_MSG_RESULT(yes)
772                 AC_DEFINE(HAVE___VLAN_FIND_DEV_DEEP_RCU, 1,
773                           [__vlan_find_dev_deep_rcu is defined])
774         ],[
775                 AC_MSG_RESULT(no)
776         ])
777
778         AC_MSG_CHECKING([if ndo_select_queue has accel_priv])
779         LB_LINUX_TRY_COMPILE([
780                 #include <linux/netdevice.h>
781
782                 static u16 select_queue(struct net_device *dev, struct sk_buff *skb,
783                                         void *accel_priv)
784                 {
785                         return 0;
786                 }
787         ],[
788                 struct net_device_opts ndops;
789
790                 ndops.ndo_select_queue = select_queue;
791
792                 return 0;
793         ],[
794                 AC_MSG_RESULT(yes)
795                 AC_DEFINE(NDO_SELECT_QUEUE_HAS_ACCEL_PRIV, 1,
796                           [ndo_select_queue has accel_priv])
797         ],[
798                 AC_MSG_RESULT(no)
799         ])
800
801         AC_MSG_CHECKING([if drivers/net/bonding/bonding.h exists])
802         LB_LINUX_TRY_COMPILE([
803                 #include "../drivers/net/bonding/bonding.h"
804         ],[
805                 return 0;
806         ],[
807                 AC_MSG_RESULT(yes)
808                 AC_DEFINE(HAVE_BONDING_H, 1,
809                           [drivers/net/bonding/bonding.h exists])
810         ],[
811                 AC_MSG_RESULT(no)
812         ])
813
814         AC_MSG_CHECKING([if bonding.h bond_for_each_slave has 3 parameters])
815         LB_LINUX_TRY_COMPILE([
816                 #include "../drivers/net/bonding/bonding.h"
817         ],[
818                 struct bonding *bond = NULL;
819                 struct list_head *iter = NULL;
820                 struct slave *slave = NULL;
821
822                 bond_for_each_slave(bond, slave, iter) ;
823
824                 return 0;
825         ],[
826                 AC_MSG_RESULT(yes)
827                 AC_DEFINE(HAVE_BOND_FOR_EACH_SLAVE_3_PARAMS, 1,
828                           [bond_for_each_slave has 3 parameters])
829         ],[
830                 AC_MSG_RESULT(no)
831         ])
832
833
834         AC_MSG_CHECKING([if u64_stats_sync.h has u64_stats_init])
835         LB_LINUX_TRY_COMPILE([
836                 #include <linux/u64_stats_sync.h>
837         ],[
838                 struct u64_stats_sync sync;
839                 u64_stats_init(&sync);
840
841                 return 0;
842         ],[
843                 AC_MSG_RESULT(yes)
844                 AC_DEFINE(HAVE_U64_STATS_SYNC, 1,
845                           [u64_stats_sync is defined])
846         ],[
847                 AC_MSG_RESULT(no)
848         ])
849
850         AC_MSG_CHECKING([if u64_stats_sync.h has u64_stats_fetch_begin_irq])
851         LB_LINUX_TRY_COMPILE([
852                 #include <linux/u64_stats_sync.h>
853         ],[
854                 struct u64_stats_sync sync;
855                 u64_stats_fetch_begin_irq(&sync);
856
857                 return 0;
858         ],[
859                 AC_MSG_RESULT(yes)
860                 AC_DEFINE(HAVE_U64_STATS_FETCH_BEGIN_IRQ, 1,
861                           [u64_stats_fetch_begin_irq is defined])
862         ],[
863                 AC_MSG_RESULT(no)
864         ])
865         AC_MSG_CHECKING([if etherdevice.h has ether_addr_copy])
866         LB_LINUX_TRY_COMPILE([
867                 #include <linux/etherdevice.h>
868         ],[
869                 char dest[6], src[6];
870                 ether_addr_copy(&dest, &src);
871
872                 return 0;
873         ],[
874                 AC_MSG_RESULT(yes)
875                 AC_DEFINE(HAVE_ETHER_ADDR_COPY, 1,
876                           [ether_addr_copy is defined])
877         ],[
878                 AC_MSG_RESULT(no)
879         ])
880
881         AC_MSG_CHECKING([if struct net_device_ops has *ndo_set_vf_rate])
882         LB_LINUX_TRY_COMPILE([
883                 #include <linux/netdevice.h>
884
885                 int set_vf_rate(struct net_device *dev, int vf, int min_tx_rate,
886                                                    int max_tx_rate)
887                 {
888                         return 0;
889                 }
890         ],[
891                 struct net_device_ops netdev_ops;
892
893                 netdev_ops.ndo_set_vf_rate = set_vf_rate;
894                 return 0;
895         ],[
896                 AC_MSG_RESULT(yes)
897                 AC_DEFINE(HAVE_SET_VF_RATE, 1,
898                           [ndo_set_vf_rate is defined])
899         ],[
900                 AC_MSG_RESULT(no)
901         ])
902
903         AC_MSG_CHECKING([if netdev_extended has hw_features])
904         LB_LINUX_TRY_COMPILE([
905                 #include <linux/netdevice.h>
906         ],[
907                 struct net_device *dev = NULL;
908
909                 netdev_extended(dev)->hw_features = 0;
910
911                 return 0;
912         ],[
913                 AC_MSG_RESULT(yes)
914                 AC_DEFINE(HAVE_NETDEV_EXTENDED_HW_FEATURES, 1,
915                           [ is defined])
916         ],[
917                 AC_MSG_RESULT(no)
918         ])
919
920         AC_MSG_CHECKING([if net_device_extended has _tx_ext])
921         LB_LINUX_TRY_COMPILE([
922                 #include <linux/netdevice.h>
923         ],[
924                 struct net_device *dev = NULL;
925
926                 netdev_extended(dev)->_tx_ext = NULL;
927
928                 return 0;
929         ],[
930                 AC_MSG_RESULT(yes)
931                 AC_DEFINE(HAVE_NET_DEVICE_EXTENDED_TX_EXT, 1,
932                           [ is defined])
933         ],[
934                 AC_MSG_RESULT(no)
935         ])
936
937         AC_MSG_CHECKING([if net_device_extended has ndo_busy_poll])
938         LB_LINUX_TRY_COMPILE([
939                 #include <linux/netdevice.h>
940
941                 int busy_poll(struct napi_struct *napi)
942                 {
943                         return 0;
944                 }
945         ],[
946                 struct net_device *dev = NULL;
947
948                 netdev_extended(dev)->ndo_busy_poll = busy_poll;
949
950                 return 0;
951         ],[
952                 AC_MSG_RESULT(yes)
953                 AC_DEFINE(HAVE_NETDEV_EXTENDED_NDO_BUSY_POLL, 1,
954                           [ is defined])
955         ],[
956                 AC_MSG_RESULT(no)
957         ])
958
959         AC_MSG_CHECKING([if netdevice.h has set_netdev_hw_features])
960         LB_LINUX_TRY_COMPILE([
961                 #include <linux/netdevice.h>
962         ],[
963                 struct net_device *dev = NULL;
964
965                 set_netdev_hw_features(dev, 0);
966
967                 return 0;
968         ],[
969                 AC_MSG_RESULT(yes)
970                 AC_DEFINE(HAVE_SET_NETDEV_HW_FEATURES, 1,
971                           [ is defined])
972         ],[
973                 AC_MSG_RESULT(no)
974         ])
975
976         AC_MSG_CHECKING([if netdevice.h has netif_set_xps_queue])
977         LB_LINUX_TRY_COMPILE([
978                 #include <linux/netdevice.h>
979         ],[
980                 struct net_device *dev = NULL;
981
982                 netif_set_xps_queue(dev, NULL, 0);
983
984                 return 0;
985         ],[
986                 AC_MSG_RESULT(yes)
987                 AC_DEFINE(HAVE_NETIF_SET_XPS_QUEUE, 1,
988                           [ is defined])
989         ],[
990                 AC_MSG_RESULT(no)
991         ])
992
993
994         AC_MSG_CHECKING([if struct net_device_ops has *ndo_set_features])
995         LB_LINUX_TRY_COMPILE([
996                 #include <linux/netdevice.h>
997
998                 int set_features(struct net_device *dev, netdev_features_t features)
999                 {
1000                         return 0;
1001                 }
1002         ],[
1003                 struct net_device_ops netdev_ops;
1004
1005                 netdev_ops.ndo_set_features = set_features;
1006                 return 0;
1007         ],[
1008                 AC_MSG_RESULT(yes)
1009                 AC_DEFINE(HAVE_NDO_SET_FEATURES, 1,
1010                           [ndo_set_features is defined])
1011         ],[
1012                 AC_MSG_RESULT(no)
1013         ])
1014
1015         AC_MSG_CHECKING([if struct net_device_ops has *ndo_setup_tc])
1016         LB_LINUX_TRY_COMPILE([
1017                 #include <linux/netdevice.h>
1018
1019                 int setup_tc(struct net_device *dev, , u8 tc)
1020                 {
1021                         return 0;
1022                 }
1023         ],[
1024                 struct net_device_ops netdev_ops;
1025
1026                 netdev_ops.ndo_setup_tc = setup_tc;
1027                 return 0;
1028         ],[
1029                 AC_MSG_RESULT(yes)
1030                 AC_DEFINE(HAVE_NDO_SETUP_TC, 1,
1031                           [ndo_setup_tc is defined])
1032         ],[
1033                 AC_MSG_RESULT(no)
1034         ])
1035
1036         AC_MSG_CHECKING([if struct net_device_ops has *ndo_rx_flow_steer])
1037         LB_LINUX_TRY_COMPILE([
1038                 #include <linux/netdevice.h>
1039
1040                 int rx_flow_steer(struct net_device *dev,
1041                                                      const struct sk_buff *skb,
1042                                                      u16 rxq_index,
1043                                                      u32 flow_id)
1044                 {
1045                         return 0;
1046                 }
1047         ],[
1048                 struct net_device_ops netdev_ops;
1049
1050                 netdev_ops.ndo_rx_flow_steer = rx_flow_steer;
1051                 return 0;
1052         ],[
1053                 AC_MSG_RESULT(yes)
1054                 AC_DEFINE(HAVE_NDO_RX_FLOW_STEER, 1,
1055                           [ndo_rx_flow_steer is defined])
1056         ],[
1057                 AC_MSG_RESULT(no)
1058         ])
1059
1060         AC_MSG_CHECKING([if struct net_device has priv_flags])
1061         LB_LINUX_TRY_COMPILE([
1062                 #include <linux/netdevice.h>
1063         ],[
1064                 struct net_device *netdev;
1065                 netdev->priv_flags = 0;
1066
1067                 return 0;
1068         ],[
1069                 AC_MSG_RESULT(yes)
1070                 AC_DEFINE(HAVE_NET_DEVICE_PRIV_FLAGS, 1,
1071                           [priv_flags is defined])
1072         ],[
1073                 AC_MSG_RESULT(no)
1074         ])
1075
1076         AC_MSG_CHECKING([if struct net_device_ops has *ndo_get_stats64])
1077         LB_LINUX_TRY_COMPILE([
1078                 #include <linux/netdevice.h>
1079
1080                 struct rtnl_link_stats64* get_stats_64(struct net_device *dev,
1081                                                      struct rtnl_link_stats64 *storage)
1082                 {
1083                         struct rtnl_link_stats64 stats_64;
1084                         return &stats_64;
1085                 }
1086         ],[
1087                 struct net_device_ops netdev_ops;
1088
1089                 netdev_ops.ndo_get_stats64 = get_stats_64;
1090
1091                 return 0;
1092         ],[
1093                 AC_MSG_RESULT(yes)
1094                 AC_DEFINE(HAVE_NDO_GET_STATS64, 1,
1095                           [ndo_get_stats64 is defined])
1096         ],[
1097                 AC_MSG_RESULT(no)
1098         ])
1099         AC_MSG_CHECKING([if struct net_device_ops has ndo_bridge_set/getlink])
1100         LB_LINUX_TRY_COMPILE([
1101                 #include <linux/netdevice.h>
1102         ],[
1103                 struct net_device_ops netdev_ops =  {
1104                         .ndo_bridge_setlink = NULL,
1105                         .ndo_bridge_getlink = NULL,
1106                 };
1107
1108                 return 0;
1109         ],[
1110                 AC_MSG_RESULT(yes)
1111                 AC_DEFINE(HAVE_NDO_BRIDGE_SET_GET_LINK, 1,
1112                           [ndo_bridge_set/getlink is defined])
1113         ],[
1114                 AC_MSG_RESULT(no)
1115         ])
1116
1117         AC_MSG_CHECKING([if struct net_device_ops ndo_vlan_rx_add_vid has 3 parameters ])
1118         LB_LINUX_TRY_COMPILE([
1119                 #include <linux/netdevice.h>
1120
1121                 int vlan_rx_add_vid(struct net_device *dev,__be16 proto, u16 vid)
1122                 {
1123                         return 0;
1124                 }
1125         ],[
1126                 struct net_device_ops netdev_ops;
1127
1128                 netdev_ops.ndo_vlan_rx_add_vid = vlan_rx_add_vid;
1129
1130                 return 0;
1131         ],[
1132                 AC_MSG_RESULT(yes)
1133                 AC_DEFINE(HAVE_NDO_RX_ADD_VID_HAS_3_PARAMS, 1,
1134                           [ndo_vlan_rx_add_vid has 3 parameters])
1135         ],[
1136                 AC_MSG_RESULT(no)
1137         ])
1138
1139         AC_MSG_CHECKING([if net_device_ops has ndo_get_phys_port_id])
1140         LB_LINUX_TRY_COMPILE([
1141                 #include <linux/netdevice.h>
1142
1143                 int get_phys_port_id(struct net_device *dev,
1144                                      struct netdev_phys_port_id *ppid)
1145                 {
1146                         return 0;
1147                 }
1148         ],[
1149                 struct net_device_ops netdev_ops;
1150
1151                 netdev_ops.ndo_get_phys_port_id = get_phys_port_id;
1152
1153                 return 0;
1154         ],[
1155                 AC_MSG_RESULT(yes)
1156                 AC_DEFINE(HAVE_NETDEV_NDO_GET_PHYS_PORT_ID, 1,
1157                           [ is defined])
1158         ],[
1159                 AC_MSG_RESULT(no)
1160         ])
1161
1162         AC_MSG_CHECKING([if struct net_device_ops_ext exist])
1163         LB_LINUX_TRY_COMPILE([
1164                 #include <linux/netdevice.h>
1165         ],[
1166                 struct net_device_ops_ext netdev_ops_ext;
1167                 struct net_device_ops_ext netdev_ops__ext = {
1168                         .size                   = sizeof(struct net_device_ops_ext),
1169                 };
1170
1171                 return 0;
1172         ],[
1173                 AC_MSG_RESULT(yes)
1174                 AC_DEFINE(HAVE_NET_DEVICE_OPS_EXT, 1,
1175                           [struct net_device_ops_ext is defined])
1176         ],[
1177                 AC_MSG_RESULT(no)
1178         ])
1179
1180         AC_MSG_CHECKING([if net_device_ops_ext has ndo_get_phys_port_id])
1181         LB_LINUX_TRY_COMPILE([
1182                 #include <linux/netdevice.h>
1183
1184                 int get_phys_port_id(struct net_device *dev,
1185                                      struct netdev_phys_port_id *ppid)
1186                 {
1187                         return 0;
1188                 }
1189         ],[
1190                 struct net_device_ops_ext netdev_ops_ext;
1191
1192                 netdev_ops_ext.ndo_get_phys_port_id = get_phys_port_id;
1193
1194                 return 0;
1195         ],[
1196                 AC_MSG_RESULT(yes)
1197                 AC_DEFINE(HAVE_NETDEV_EXT_NDO_GET_PHYS_PORT_ID, 1,
1198                           [ndo_get_phys_port_id is defined])
1199         ],[
1200                 AC_MSG_RESULT(no)
1201         ])
1202
1203         AC_MSG_CHECKING([if net_device_ops has ndo_set_vf_spoofchk])
1204         LB_LINUX_TRY_COMPILE([
1205                 #include <linux/netdevice.h>
1206
1207                 int set_vf_spoofchk(struct net_device *dev, int vf, bool setting)
1208                 {
1209                         return 0;
1210                 }
1211         ],[
1212                 struct net_device_ops netdev_ops;
1213
1214                 netdev_ops.ndo_set_vf_spoofchk = set_vf_spoofchk;
1215
1216                 return 0;
1217         ],[
1218                 AC_MSG_RESULT(yes)
1219                 AC_DEFINE(HAVE_NETDEV_OPS_NDO_SET_VF_SPOOFCHK, 1,
1220                           [ndo_set_vf_spoofchk is defined in net_device_ops])
1221         ],[
1222                 AC_MSG_RESULT(no)
1223         ])
1224
1225         AC_MSG_CHECKING([if net_device_ops_ext has ndo_set_vf_spoofchk])
1226         LB_LINUX_TRY_COMPILE([
1227                 #include <linux/netdevice.h>
1228
1229                 int set_vf_spoofchk(struct net_device *dev, int vf, bool setting)
1230                 {
1231                         return 0;
1232                 }
1233         ],[
1234                 struct net_device_ops_ext netdev_ops_ext;
1235
1236                 netdev_ops_ext.ndo_set_vf_spoofchk = set_vf_spoofchk;
1237
1238                 return 0;
1239         ],[
1240                 AC_MSG_RESULT(yes)
1241                 AC_DEFINE(HAVE_NETDEV_OPS_EXT_NDO_SET_VF_SPOOFCHK, 1,
1242                           [ndo_set_vf_spoofchk is defined in net_device_ops_ext])
1243         ],[
1244                 AC_MSG_RESULT(no)
1245         ])
1246
1247         AC_MSG_CHECKING([if net_device_ops has ndo_set_vf_link_state])
1248         LB_LINUX_TRY_COMPILE([
1249                 #include <linux/netdevice.h>
1250
1251                 int set_vf_link_state(struct net_device *dev, int vf, int link_state)
1252                 {
1253                         return 0;
1254                 }
1255         ],[
1256                 struct net_device_ops netdev_ops;
1257
1258                 netdev_ops.ndo_set_vf_link_state = set_vf_link_state;
1259
1260                 return 0;
1261         ],[
1262                 AC_MSG_RESULT(yes)
1263                 AC_DEFINE(HAVE_NETDEV_OPS_NDO_SET_VF_LINK_STATE, 1,
1264                           [ndo_set_vf_link_state is defined in net_device_ops])
1265         ],[
1266                 AC_MSG_RESULT(no)
1267         ])
1268
1269         AC_MSG_CHECKING([if net_device_ops_ext has ndo_set_vf_link_state])
1270         LB_LINUX_TRY_COMPILE([
1271                 #include <linux/netdevice.h>
1272
1273                 int set_vf_link_state(struct net_device *dev, int vf, int link_state)
1274                 {
1275                         return 0;
1276                 }
1277         ],[
1278                 struct net_device_ops_ext netdev_ops_ext;
1279
1280                 netdev_ops_ext.ndo_set_vf_link_state = set_vf_link_state;
1281
1282                 return 0;
1283         ],[
1284                 AC_MSG_RESULT(yes)
1285                 AC_DEFINE(HAVE_NETDEV_OPS_EXT_NDO_SET_VF_LINK_STATE, 1,
1286                           [ndo_set_vf_link_state is defined])
1287         ],[
1288                 AC_MSG_RESULT(no)
1289         ])
1290
1291
1292         AC_MSG_CHECKING([if netdevice.h netif_set_real_num_tx_queues returns int])
1293         LB_LINUX_TRY_COMPILE([
1294                 #include <linux/netdevice.h>
1295         ],[
1296                 struct net_device dev;
1297                 int ret;
1298                 ret = netif_set_real_num_tx_queues(&dev, 2);
1299                 return 0;
1300         ],[
1301                 AC_MSG_RESULT(yes)
1302                 AC_DEFINE(HAVE_RETURN_INT_FOR_SET_NUM_TX_QUEUES, 1,
1303                           [netif_set_real_num_tx_queues returns int])
1304         ],[
1305                 AC_MSG_RESULT(no)
1306         ])
1307
1308         AC_MSG_CHECKING([if struct netdevice.h has struct xps_map])
1309         LB_LINUX_TRY_COMPILE([
1310                 #include <linux/netdevice.h>
1311         ],[
1312                 struct xps_map map;
1313                 map.len = 0;
1314
1315                 return 0;
1316         ],[
1317                 AC_MSG_RESULT(yes)
1318                 AC_DEFINE(HAVE_XPS_MAP, 1,
1319                           [struct xps_map is defined])
1320         ],[
1321                 AC_MSG_RESULT(no)
1322         ])
1323
1324         AC_MSG_CHECKING([if struct ethtool_ops has set_phys_id])
1325         LB_LINUX_TRY_COMPILE([
1326                 #include <linux/ethtool.h>
1327         ],[
1328                 const struct ethtool_ops en_ethtool_ops = {
1329                         .set_phys_id= NULL,
1330                 };
1331
1332                 return 0;
1333         ],[
1334                 AC_MSG_RESULT(yes)
1335                 AC_DEFINE(HAVE_SET_PHYS_ID, 1,
1336                           [set_phys_id is defined])
1337         ],[
1338                 AC_MSG_RESULT(no)
1339         ])
1340
1341         AC_MSG_CHECKING([if struct ethtool_ops has get/set_channels])
1342         LB_LINUX_TRY_COMPILE([
1343                 #include <linux/ethtool.h>
1344         ],[
1345                 const struct ethtool_ops en_ethtool_ops = {
1346                         .get_channels = NULL,
1347                         .set_channels = NULL,
1348                 };
1349
1350                 return 0;
1351         ],[
1352                 AC_MSG_RESULT(yes)
1353                 AC_DEFINE(HAVE_GET_SET_CHANNELS, 1,
1354                           [get/set_channels is defined])
1355         ],[
1356                 AC_MSG_RESULT(no)
1357         ])
1358
1359         AC_MSG_CHECKING([if struct ethtool_ops_ext has get/set_channels])
1360         LB_LINUX_TRY_COMPILE([
1361                 #include <linux/ethtool.h>
1362         ],[
1363                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
1364                         .get_channels = NULL,
1365                         .set_channels = NULL,
1366                 };
1367
1368                 return 0;
1369         ],[
1370                 AC_MSG_RESULT(yes)
1371                 AC_DEFINE(HAVE_GET_SET_CHANNELS_EXT, 1,
1372                           [get/set_channels is defined in ethtool_ops_ext])
1373         ],[
1374                 AC_MSG_RESULT(no)
1375         ])
1376
1377         AC_MSG_CHECKING([if struct ethtool_ops has get_ts_info])
1378         LB_LINUX_TRY_COMPILE([
1379                 #include <linux/ethtool.h>
1380         ],[
1381                 const struct ethtool_ops en_ethtool_ops = {
1382                         .get_ts_info = NULL,
1383                 };
1384
1385                 return 0;
1386         ],[
1387                 AC_MSG_RESULT(yes)
1388                 AC_DEFINE(HAVE_GET_TS_INFO, 1,
1389                           [get_ts_info is defined])
1390         ],[
1391                 AC_MSG_RESULT(no)
1392         ])
1393
1394         AC_MSG_CHECKING([if struct ethtool_ops_ext has get_ts_info])
1395         LB_LINUX_TRY_COMPILE([
1396                 #include <linux/ethtool.h>
1397         ],[
1398                 const struct ethtool_ops_ext en_ethtool_ops_ext = {
1399                         .get_ts_info = NULL,
1400                 };
1401
1402                 return 0;
1403         ],[
1404                 AC_MSG_RESULT(yes)
1405                 AC_DEFINE(HAVE_GET_TS_INFO_EXT, 1,
1406                           [get_ts_info is defined in ethtool_ops_ext])
1407         ],[
1408                 AC_MSG_RESULT(no)
1409         ])
1410
1411         AC_MSG_CHECKING([if netdevice.h has struct netdev_hw_addr])
1412         LB_LINUX_TRY_COMPILE([
1413                 #include <linux/netdevice.h>
1414         ],[
1415                 struct netdev_hw_addr addr;
1416                 return 0;
1417         ],[
1418                 AC_MSG_RESULT(yes)
1419                 AC_DEFINE(HAVE_NETDEV_HW_ADDR, 1,
1420                           [netdev_hw_addr is defined])
1421         ],[
1422                 AC_MSG_RESULT(no)
1423         ])
1424
1425         AC_MSG_CHECKING([if pci.h has pci_vfs_assigned])
1426         LB_LINUX_TRY_COMPILE([
1427                 #include <linux/pci.h>
1428         ],[
1429                 struct pci_dev pdev;
1430                 pci_vfs_assigned(&pdev);
1431                 return 0;
1432         ],[
1433                 AC_MSG_RESULT(yes)
1434                 AC_DEFINE(HAVE_PCI_VF_ASSIGNED, 1,
1435                           [pci_vfs_assigned is defined])
1436         ],[
1437                 AC_MSG_RESULT(no)
1438         ])
1439         AC_MSG_CHECKING([if __vlan_put_tag has 3 parameters])
1440         LB_LINUX_TRY_COMPILE([
1441                 #include <linux/if_vlan.h>
1442         ],[
1443                 struct sk_buff *skb;
1444                 __vlan_put_tag(skb, 0, 0);
1445
1446                 return 0;
1447         ],[
1448                 AC_MSG_RESULT(yes)
1449                 AC_DEFINE(HAVE_3_PARAMS_FOR_VLAN_PUT_TAG, 1,
1450                           [__vlan_put_tag has 3 parameters])
1451         ],[
1452                 AC_MSG_RESULT(no)
1453         ])
1454
1455         AC_MSG_CHECKING([if __vlan_hwaccel_put_tag has 3 parameters])
1456         LB_LINUX_TRY_COMPILE([
1457                 #include <linux/if_vlan.h>
1458         ],[
1459                 struct sk_buff *skb;
1460                 __vlan_hwaccel_put_tag(skb, 0, 0);
1461
1462                 return 0;
1463         ],[
1464                 AC_MSG_RESULT(yes)
1465                 AC_DEFINE(HAVE_3_PARAMS_FOR_VLAN_HWACCEL_PUT_TAG, 1,
1466                           [__vlan_hwaccel_put_tag has 3 parameters])
1467         ],[
1468                 AC_MSG_RESULT(no)
1469         ])
1470
1471         AC_MSG_CHECKING([if struct net_device has hw_features])
1472         LB_LINUX_TRY_COMPILE([
1473                 #include <linux/netdevice.h>
1474         ],[
1475                 struct net_device dev;
1476                 dev.hw_features = 0;
1477
1478                 return 0;
1479         ],[
1480                 AC_MSG_RESULT(yes)
1481                 AC_DEFINE(HAVE_NETDEV_HW_FEATURES, 1,
1482                           [hw_features is defined])
1483         ],[
1484                 AC_MSG_RESULT(no)
1485         ])
1486
1487         AC_MSG_CHECKING([if struct net_device has hw_enc_features])
1488         LB_LINUX_TRY_COMPILE([
1489                 #include <linux/netdevice.h>
1490         ],[
1491                 struct net_device dev;
1492                 dev.hw_enc_features = 0;
1493
1494                 return 0;
1495         ],[
1496                 AC_MSG_RESULT(yes)
1497                 AC_DEFINE(HAVE_NETDEV_HW_ENC_FEATURES, 1,
1498                           [hw_enc_features is defined])
1499         ],[
1500                 AC_MSG_RESULT(no)
1501         ])
1502
1503         AC_MSG_CHECKING([if struct net_device has rx_cpu_rmap])
1504         LB_LINUX_TRY_COMPILE([
1505                 #include <linux/netdevice.h>
1506         ],[
1507                 struct net_device dev;
1508                 dev.rx_cpu_rmap = NULL;
1509
1510                 return 0;
1511         ],[
1512                 AC_MSG_RESULT(yes)
1513                 AC_DEFINE(HAVE_NETDEV_RX_CPU_RMAP, 1,
1514                           [rx_cpu_rmap is defined])
1515         ],[
1516                 AC_MSG_RESULT(no)
1517         ])
1518
1519         AC_MSG_CHECKING([if if_vlan.h has vlan_hwaccel_receive_skb])
1520         LB_LINUX_TRY_COMPILE([
1521                 #include <linux/if_vlan.h>
1522         ],[
1523                 struct sk_buff *skb;
1524                 vlan_hwaccel_receive_skb(skb,0,0);
1525                 return 0;
1526         ],[
1527                 AC_MSG_RESULT(yes)
1528                 AC_DEFINE(HAVE_VLAN_HWACCEL_RECEIVE_SKB, 1,
1529                           [vlan_hwaccel_receive_skb is defined])
1530         ],[
1531                 AC_MSG_RESULT(no)
1532         ])
1533
1534         AC_MSG_CHECKING([if irqdesc.h has irq_desc_get_irq_data])
1535         LB_LINUX_TRY_COMPILE([
1536                 #include <linux/irqdesc.h>
1537         ],[
1538                 struct irq_data *data = irq_desc_get_irq_data(NULL);
1539                 return 0;
1540         ],[
1541                 AC_MSG_RESULT(yes)
1542                 AC_DEFINE(HAVE_IRQ_DESC_GET_IRQ_DATA, 1,
1543                           [irq_desc_get_irq_data is defined])
1544         ],[
1545                 AC_MSG_RESULT(no)
1546         ])
1547
1548
1549         AC_MSG_CHECKING([if pci_dev has pcie_mpss])
1550         LB_LINUX_TRY_COMPILE([
1551                 #include <linux/pci.h>
1552         ],[
1553                 struct pci_dev pdev;
1554
1555                 pdev->pcie_mpss = 0;
1556                 return 0;
1557         ],[
1558                 AC_MSG_RESULT(yes)
1559                 AC_DEFINE(HAVE_PCI_DEV_PCIE_MPSS, 1,
1560                           [pcie_mpss is defined])
1561         ],[
1562                 AC_MSG_RESULT(no)
1563         ])
1564
1565         AC_MSG_CHECKING([if uapi/linux/if_ether.h exist])
1566         LB_LINUX_TRY_COMPILE([
1567                 #include <uapi/linux/if_ether.h>
1568         ],[
1569                 return 0;
1570         ],[
1571                 AC_MSG_RESULT(yes)
1572                 AC_DEFINE(HAVE_UAPI_LINUX_IF_ETHER_H, 1,
1573                           [uapi/linux/if_ether.h exist])
1574         ],[
1575                 AC_MSG_RESULT(no)
1576         ])
1577
1578         AC_MSG_CHECKING([if ifla_vf_info has spoofchk])
1579         LB_LINUX_TRY_COMPILE([
1580                 #include <linux/if_link.h>
1581         ],[
1582                 struct ifla_vf_info *ivf;
1583
1584                 ivf->spoofchk = 0;
1585                 return 0;
1586         ],[
1587                 AC_MSG_RESULT(yes)
1588                 AC_DEFINE(HAVE_VF_INFO_SPOOFCHK, 1,
1589                           [spoofchk is defined])
1590         ],[
1591                 AC_MSG_RESULT(no)
1592         ])
1593
1594 ])
1595 #
1596 # COMPAT_CONFIG_HEADERS
1597 #
1598 # add -include config.h
1599 #
1600 AC_DEFUN([COMPAT_CONFIG_HEADERS],[
1601         AC_CONFIG_HEADERS([config.h])
1602         EXTRA_KCFLAGS="-include $PWD/config.h $EXTRA_KCFLAGS"
1603         AC_SUBST(EXTRA_KCFLAGS)
1604 ])
1605
1606 AC_DEFUN([OFA_PROG_LINUX],
1607 [
1608
1609 LB_LINUX_PATH
1610 LB_LINUX_SYMVERFILE
1611 LB_LINUX_CONFIG([MODULES],[],[
1612     AC_MSG_ERROR([module support is required to build mlnx kernel modules.])
1613 ])
1614 LB_LINUX_CONFIG([MODVERSIONS])
1615 LB_LINUX_CONFIG([KALLSYMS],[],[
1616     AC_MSG_ERROR([compat_mlnx requires that CONFIG_KALLSYMS is enabled in your kernel.])
1617 ])
1618
1619 LINUX_CONFIG_COMPAT
1620 COMPAT_CONFIG_HEADERS
1621
1622 ])