1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53#include <linux/module.h>
54#include <linux/kernel.h>
55#include <linux/sched.h>
56#include <linux/types.h>
57#include <linux/skbuff.h>
58#include <linux/slab.h>
59#include <linux/proc_fs.h>
60#include <linux/interrupt.h>
61#include <linux/netdevice.h>
62#include <linux/kmod.h>
63#include <linux/if_arp.h>
64#include <linux/wireless.h>
65#include <linux/sockios.h>
66#include <linux/etherdevice.h>
67#include <linux/if_ether.h>
68#include <linux/byteorder/generic.h>
69#include <linux/bitops.h>
70#include <linux/uaccess.h>
71#include <asm/byteorder.h>
72
73#ifdef SIOCETHTOOL
74#include <linux/ethtool.h>
75#endif
76
77#include <net/iw_handler.h>
78#include <net/net_namespace.h>
79#include <net/cfg80211.h>
80
81#include "p80211types.h"
82#include "p80211hdr.h"
83#include "p80211conv.h"
84#include "p80211mgmt.h"
85#include "p80211msg.h"
86#include "p80211netdev.h"
87#include "p80211ioctl.h"
88#include "p80211req.h"
89#include "p80211metastruct.h"
90#include "p80211metadef.h"
91
92#include "cfg80211.c"
93
94
95static int p80211knetdev_init(struct net_device *netdev);
96static int p80211knetdev_open(struct net_device *netdev);
97static int p80211knetdev_stop(struct net_device *netdev);
98static netdev_tx_t p80211knetdev_hard_start_xmit(struct sk_buff *skb,
99 struct net_device *netdev);
100static void p80211knetdev_set_multicast_list(struct net_device *dev);
101static int p80211knetdev_do_ioctl(struct net_device *dev, struct ifreq *ifr,
102 int cmd);
103static int p80211knetdev_set_mac_address(struct net_device *dev, void *addr);
104static void p80211knetdev_tx_timeout(struct net_device *netdev, unsigned int txqueue);
105static int p80211_rx_typedrop(struct wlandevice *wlandev, u16 fc);
106
107int wlan_watchdog = 5000;
108module_param(wlan_watchdog, int, 0644);
109MODULE_PARM_DESC(wlan_watchdog, "transmit timeout in milliseconds");
110
111int wlan_wext_write = 1;
112module_param(wlan_wext_write, int, 0644);
113MODULE_PARM_DESC(wlan_wext_write, "enable write wireless extensions");
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128static int p80211knetdev_init(struct net_device *netdev)
129{
130
131
132
133
134 return 0;
135}
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152static int p80211knetdev_open(struct net_device *netdev)
153{
154 int result = 0;
155 struct wlandevice *wlandev = netdev->ml_priv;
156
157
158 if (wlandev->msdstate != WLAN_MSD_RUNNING)
159 return -ENODEV;
160
161
162 if (wlandev->open) {
163 result = wlandev->open(wlandev);
164 if (result == 0) {
165 netif_start_queue(wlandev->netdev);
166 wlandev->state = WLAN_DEVICE_OPEN;
167 }
168 } else {
169 result = -EAGAIN;
170 }
171
172 return result;
173}
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188static int p80211knetdev_stop(struct net_device *netdev)
189{
190 int result = 0;
191 struct wlandevice *wlandev = netdev->ml_priv;
192
193 if (wlandev->close)
194 result = wlandev->close(wlandev);
195
196 netif_stop_queue(wlandev->netdev);
197 wlandev->state = WLAN_DEVICE_CLOSED;
198
199 return result;
200}
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216void p80211netdev_rx(struct wlandevice *wlandev, struct sk_buff *skb)
217{
218
219 skb_queue_tail(&wlandev->nsd_rxq, skb);
220 tasklet_schedule(&wlandev->rx_bh);
221}
222
223#define CONV_TO_ETHER_SKIPPED 0x01
224#define CONV_TO_ETHER_FAILED 0x02
225
226
227
228
229
230
231
232
233
234
235static int p80211_convert_to_ether(struct wlandevice *wlandev,
236 struct sk_buff *skb)
237{
238 struct p80211_hdr_a3 *hdr;
239
240 hdr = (struct p80211_hdr_a3 *)skb->data;
241 if (p80211_rx_typedrop(wlandev, le16_to_cpu(hdr->fc)))
242 return CONV_TO_ETHER_SKIPPED;
243
244
245
246
247 if (wlandev->netdev->flags & IFF_ALLMULTI) {
248 if (!ether_addr_equal_unaligned(wlandev->netdev->dev_addr,
249 hdr->a1)) {
250 if (!is_multicast_ether_addr(hdr->a1))
251 return CONV_TO_ETHER_SKIPPED;
252 }
253 }
254
255 if (skb_p80211_to_ether(wlandev, wlandev->ethconv, skb) == 0) {
256 wlandev->netdev->stats.rx_packets++;
257 wlandev->netdev->stats.rx_bytes += skb->len;
258 netif_rx_ni(skb);
259 return 0;
260 }
261
262 netdev_dbg(wlandev->netdev, "%s failed.\n", __func__);
263 return CONV_TO_ETHER_FAILED;
264}
265
266
267
268
269
270
271static void p80211netdev_rx_bh(struct tasklet_struct *t)
272{
273 struct wlandevice *wlandev = from_tasklet(wlandev, t, rx_bh);
274 struct sk_buff *skb = NULL;
275 struct net_device *dev = wlandev->netdev;
276
277
278 while ((skb = skb_dequeue(&wlandev->nsd_rxq))) {
279 if (wlandev->state == WLAN_DEVICE_OPEN) {
280 if (dev->type != ARPHRD_ETHER) {
281
282
283
284
285 skb->dev = dev;
286 skb_reset_mac_header(skb);
287 skb->ip_summed = CHECKSUM_NONE;
288 skb->pkt_type = PACKET_OTHERHOST;
289 skb->protocol = htons(ETH_P_80211_RAW);
290
291 dev->stats.rx_packets++;
292 dev->stats.rx_bytes += skb->len;
293 netif_rx_ni(skb);
294 continue;
295 } else {
296 if (!p80211_convert_to_ether(wlandev, skb))
297 continue;
298 }
299 }
300 dev_kfree_skb(skb);
301 }
302}
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324static netdev_tx_t p80211knetdev_hard_start_xmit(struct sk_buff *skb,
325 struct net_device *netdev)
326{
327 int result = 0;
328 int txresult;
329 struct wlandevice *wlandev = netdev->ml_priv;
330 union p80211_hdr p80211_hdr;
331 struct p80211_metawep p80211_wep;
332
333 p80211_wep.data = NULL;
334
335 if (!skb)
336 return NETDEV_TX_OK;
337
338 if (wlandev->state != WLAN_DEVICE_OPEN) {
339 result = 1;
340 goto failed;
341 }
342
343 memset(&p80211_hdr, 0, sizeof(p80211_hdr));
344 memset(&p80211_wep, 0, sizeof(p80211_wep));
345
346 if (netif_queue_stopped(netdev)) {
347 netdev_dbg(netdev, "called when queue stopped.\n");
348 result = 1;
349 goto failed;
350 }
351
352 netif_stop_queue(netdev);
353
354
355 switch (wlandev->macmode) {
356 case WLAN_MACMODE_IBSS_STA:
357 case WLAN_MACMODE_ESS_STA:
358 case WLAN_MACMODE_ESS_AP:
359 break;
360 default:
361
362
363
364
365 if (be16_to_cpu(skb->protocol) != ETH_P_80211_RAW) {
366 netif_start_queue(wlandev->netdev);
367 netdev_notice(netdev, "Tx attempt prior to association, frame dropped.\n");
368 netdev->stats.tx_dropped++;
369 result = 0;
370 goto failed;
371 }
372 break;
373 }
374
375
376 if (be16_to_cpu(skb->protocol) == ETH_P_80211_RAW) {
377 if (!capable(CAP_NET_ADMIN)) {
378 result = 1;
379 goto failed;
380 }
381
382 memcpy(&p80211_hdr, skb->data, sizeof(p80211_hdr));
383 skb_pull(skb, sizeof(p80211_hdr));
384 } else {
385 if (skb_ether_to_p80211
386 (wlandev, wlandev->ethconv, skb, &p80211_hdr,
387 &p80211_wep) != 0) {
388
389 netdev_dbg(netdev, "ether_to_80211(%d) failed.\n",
390 wlandev->ethconv);
391 result = 1;
392 goto failed;
393 }
394 }
395 if (!wlandev->txframe) {
396 result = 1;
397 goto failed;
398 }
399
400 netif_trans_update(netdev);
401
402 netdev->stats.tx_packets++;
403
404 netdev->stats.tx_bytes += skb->len;
405
406 txresult = wlandev->txframe(wlandev, skb, &p80211_hdr, &p80211_wep);
407
408 if (txresult == 0) {
409
410
411 netif_wake_queue(wlandev->netdev);
412 result = NETDEV_TX_OK;
413 } else if (txresult == 1) {
414
415 netdev_dbg(netdev, "txframe success, no more bufs\n");
416
417
418 result = NETDEV_TX_OK;
419 } else if (txresult == 2) {
420
421 netdev_dbg(netdev, "txframe returned alloc_fail\n");
422 result = NETDEV_TX_BUSY;
423 } else {
424
425 netdev_dbg(netdev, "txframe returned full or busy\n");
426 result = NETDEV_TX_BUSY;
427 }
428
429failed:
430
431 if ((p80211_wep.data) && (p80211_wep.data != skb->data))
432 kfree_sensitive(p80211_wep.data);
433
434
435 if (!result)
436 dev_kfree_skb(skb);
437
438 return result;
439}
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454static void p80211knetdev_set_multicast_list(struct net_device *dev)
455{
456 struct wlandevice *wlandev = dev->ml_priv;
457
458
459
460 if (wlandev->set_multicast_list)
461 wlandev->set_multicast_list(wlandev, dev);
462}
463
464#ifdef SIOCETHTOOL
465
466static int p80211netdev_ethtool(struct wlandevice *wlandev,
467 void __user *useraddr)
468{
469 u32 ethcmd;
470 struct ethtool_drvinfo info;
471 struct ethtool_value edata;
472
473 memset(&info, 0, sizeof(info));
474 memset(&edata, 0, sizeof(edata));
475
476 if (copy_from_user(ðcmd, useraddr, sizeof(ethcmd)))
477 return -EFAULT;
478
479 switch (ethcmd) {
480 case ETHTOOL_GDRVINFO:
481 info.cmd = ethcmd;
482 snprintf(info.driver, sizeof(info.driver), "p80211_%s",
483 wlandev->nsdname);
484 snprintf(info.version, sizeof(info.version), "%s",
485 WLAN_RELEASE);
486
487 if (copy_to_user(useraddr, &info, sizeof(info)))
488 return -EFAULT;
489 return 0;
490#ifdef ETHTOOL_GLINK
491 case ETHTOOL_GLINK:
492 edata.cmd = ethcmd;
493
494 if (wlandev->linkstatus &&
495 (wlandev->macmode != WLAN_MACMODE_NONE)) {
496 edata.data = 1;
497 } else {
498 edata.data = 0;
499 }
500
501 if (copy_to_user(useraddr, &edata, sizeof(edata)))
502 return -EFAULT;
503 return 0;
504#endif
505 }
506
507 return -EOPNOTSUPP;
508}
509
510#endif
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540static int p80211knetdev_do_ioctl(struct net_device *dev,
541 struct ifreq *ifr, int cmd)
542{
543 int result = 0;
544 struct p80211ioctl_req *req = (struct p80211ioctl_req *)ifr;
545 struct wlandevice *wlandev = dev->ml_priv;
546 u8 *msgbuf;
547
548 netdev_dbg(dev, "rx'd ioctl, cmd=%d, len=%d\n", cmd, req->len);
549
550#ifdef SIOCETHTOOL
551 if (cmd == SIOCETHTOOL) {
552 result =
553 p80211netdev_ethtool(wlandev, (void __user *)ifr->ifr_data);
554 goto bail;
555 }
556#endif
557
558
559 if (req->magic != P80211_IOCTL_MAGIC) {
560 result = -EINVAL;
561 goto bail;
562 }
563
564 if (cmd == P80211_IFTEST) {
565 result = 0;
566 goto bail;
567 } else if (cmd != P80211_IFREQ) {
568 result = -EINVAL;
569 goto bail;
570 }
571
572 msgbuf = memdup_user(req->data, req->len);
573 if (IS_ERR(msgbuf)) {
574 result = PTR_ERR(msgbuf);
575 goto bail;
576 }
577
578 result = p80211req_dorequest(wlandev, msgbuf);
579
580 if (result == 0) {
581 if (copy_to_user
582 (req->data, msgbuf, req->len)) {
583 result = -EFAULT;
584 }
585 }
586 kfree(msgbuf);
587
588bail:
589
590 return result;
591}
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619static int p80211knetdev_set_mac_address(struct net_device *dev, void *addr)
620{
621 struct sockaddr *new_addr = addr;
622 struct p80211msg_dot11req_mibset dot11req;
623 struct p80211item_unk392 *mibattr;
624 struct p80211item_pstr6 *macaddr;
625 struct p80211item_uint32 *resultcode;
626 int result;
627
628
629 if (netif_running(dev))
630 return -EBUSY;
631
632
633 mibattr = &dot11req.mibattribute;
634 macaddr = (struct p80211item_pstr6 *)&mibattr->data;
635 resultcode = &dot11req.resultcode;
636
637
638 memset(&dot11req, 0, sizeof(dot11req));
639 dot11req.msgcode = DIDMSG_DOT11REQ_MIBSET;
640 dot11req.msglen = sizeof(dot11req);
641 memcpy(dot11req.devname,
642 ((struct wlandevice *)dev->ml_priv)->name,
643 WLAN_DEVNAMELEN_MAX - 1);
644
645
646 mibattr->did = DIDMSG_DOT11REQ_MIBSET_MIBATTRIBUTE;
647 mibattr->status = P80211ENUM_msgitem_status_data_ok;
648 mibattr->len = sizeof(mibattr->data);
649
650 macaddr->did = DIDMIB_DOT11MAC_OPERATIONTABLE_MACADDRESS;
651 macaddr->status = P80211ENUM_msgitem_status_data_ok;
652 macaddr->len = sizeof(macaddr->data);
653 macaddr->data.len = ETH_ALEN;
654 memcpy(&macaddr->data.data, new_addr->sa_data, ETH_ALEN);
655
656
657 resultcode->did = DIDMSG_DOT11REQ_MIBSET_RESULTCODE;
658 resultcode->status = P80211ENUM_msgitem_status_no_value;
659 resultcode->len = sizeof(resultcode->data);
660 resultcode->data = 0;
661
662
663 result = p80211req_dorequest(dev->ml_priv, (u8 *)&dot11req);
664
665
666
667
668 if (result != 0 || resultcode->data != P80211ENUM_resultcode_success) {
669 netdev_err(dev, "Low-level driver failed dot11req_mibset(dot11MACAddress).\n");
670 result = -EADDRNOTAVAIL;
671 } else {
672
673 memcpy(dev->dev_addr, new_addr->sa_data, dev->addr_len);
674 }
675
676 return result;
677}
678
679static const struct net_device_ops p80211_netdev_ops = {
680 .ndo_init = p80211knetdev_init,
681 .ndo_open = p80211knetdev_open,
682 .ndo_stop = p80211knetdev_stop,
683 .ndo_start_xmit = p80211knetdev_hard_start_xmit,
684 .ndo_set_rx_mode = p80211knetdev_set_multicast_list,
685 .ndo_do_ioctl = p80211knetdev_do_ioctl,
686 .ndo_set_mac_address = p80211knetdev_set_mac_address,
687 .ndo_tx_timeout = p80211knetdev_tx_timeout,
688 .ndo_validate_addr = eth_validate_addr,
689};
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715int wlan_setup(struct wlandevice *wlandev, struct device *physdev)
716{
717 int result = 0;
718 struct net_device *netdev;
719 struct wiphy *wiphy;
720 struct wireless_dev *wdev;
721
722
723 wlandev->state = WLAN_DEVICE_CLOSED;
724 wlandev->ethconv = WLAN_ETHCONV_8021h;
725 wlandev->macmode = WLAN_MACMODE_NONE;
726
727
728 skb_queue_head_init(&wlandev->nsd_rxq);
729 tasklet_setup(&wlandev->rx_bh, p80211netdev_rx_bh);
730
731
732 wiphy = wlan_create_wiphy(physdev, wlandev);
733 if (!wiphy) {
734 dev_err(physdev, "Failed to alloc wiphy.\n");
735 return 1;
736 }
737
738
739 netdev = alloc_netdev(sizeof(struct wireless_dev), "wlan%d",
740 NET_NAME_UNKNOWN, ether_setup);
741 if (!netdev) {
742 dev_err(physdev, "Failed to alloc netdev.\n");
743 wlan_free_wiphy(wiphy);
744 result = 1;
745 } else {
746 wlandev->netdev = netdev;
747 netdev->ml_priv = wlandev;
748 netdev->netdev_ops = &p80211_netdev_ops;
749 wdev = netdev_priv(netdev);
750 wdev->wiphy = wiphy;
751 wdev->iftype = NL80211_IFTYPE_STATION;
752 netdev->ieee80211_ptr = wdev;
753 netdev->min_mtu = 68;
754
755
756
757 netdev->max_mtu = (2312 - 20 - 8);
758
759 netif_stop_queue(netdev);
760 netif_carrier_off(netdev);
761 }
762
763 return result;
764}
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786void wlan_unsetup(struct wlandevice *wlandev)
787{
788 struct wireless_dev *wdev;
789
790 tasklet_kill(&wlandev->rx_bh);
791
792 if (wlandev->netdev) {
793 wdev = netdev_priv(wlandev->netdev);
794 if (wdev->wiphy)
795 wlan_free_wiphy(wdev->wiphy);
796 free_netdev(wlandev->netdev);
797 wlandev->netdev = NULL;
798 }
799}
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821int register_wlandev(struct wlandevice *wlandev)
822{
823 return register_netdev(wlandev->netdev);
824}
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844int unregister_wlandev(struct wlandevice *wlandev)
845{
846 struct sk_buff *skb;
847
848 unregister_netdev(wlandev->netdev);
849
850
851 while ((skb = skb_dequeue(&wlandev->nsd_rxq)))
852 dev_kfree_skb(skb);
853
854 return 0;
855}
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888void p80211netdev_hwremoved(struct wlandevice *wlandev)
889{
890 wlandev->hwremoved = 1;
891 if (wlandev->state == WLAN_DEVICE_OPEN)
892 netif_stop_queue(wlandev->netdev);
893
894 netif_device_detach(wlandev->netdev);
895}
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919static int p80211_rx_typedrop(struct wlandevice *wlandev, u16 fc)
920{
921 u16 ftype;
922 u16 fstype;
923 int drop = 0;
924
925 ftype = WLAN_GET_FC_FTYPE(fc);
926 fstype = WLAN_GET_FC_FSTYPE(fc);
927 switch (ftype) {
928 case WLAN_FTYPE_MGMT:
929 if ((wlandev->netdev->flags & IFF_PROMISC) ||
930 (wlandev->netdev->flags & IFF_ALLMULTI)) {
931 drop = 1;
932 break;
933 }
934 netdev_dbg(wlandev->netdev, "rx'd mgmt:\n");
935 wlandev->rx.mgmt++;
936 switch (fstype) {
937 case WLAN_FSTYPE_ASSOCREQ:
938
939 wlandev->rx.assocreq++;
940 break;
941 case WLAN_FSTYPE_ASSOCRESP:
942
943 wlandev->rx.assocresp++;
944 break;
945 case WLAN_FSTYPE_REASSOCREQ:
946
947 wlandev->rx.reassocreq++;
948 break;
949 case WLAN_FSTYPE_REASSOCRESP:
950
951 wlandev->rx.reassocresp++;
952 break;
953 case WLAN_FSTYPE_PROBEREQ:
954
955 wlandev->rx.probereq++;
956 break;
957 case WLAN_FSTYPE_PROBERESP:
958
959 wlandev->rx.proberesp++;
960 break;
961 case WLAN_FSTYPE_BEACON:
962
963 wlandev->rx.beacon++;
964 break;
965 case WLAN_FSTYPE_ATIM:
966
967 wlandev->rx.atim++;
968 break;
969 case WLAN_FSTYPE_DISASSOC:
970
971 wlandev->rx.disassoc++;
972 break;
973 case WLAN_FSTYPE_AUTHEN:
974
975 wlandev->rx.authen++;
976 break;
977 case WLAN_FSTYPE_DEAUTHEN:
978
979 wlandev->rx.deauthen++;
980 break;
981 default:
982
983 wlandev->rx.mgmt_unknown++;
984 break;
985 }
986
987 drop = 2;
988 break;
989
990 case WLAN_FTYPE_CTL:
991 if ((wlandev->netdev->flags & IFF_PROMISC) ||
992 (wlandev->netdev->flags & IFF_ALLMULTI)) {
993 drop = 1;
994 break;
995 }
996 netdev_dbg(wlandev->netdev, "rx'd ctl:\n");
997 wlandev->rx.ctl++;
998 switch (fstype) {
999 case WLAN_FSTYPE_PSPOLL:
1000
1001 wlandev->rx.pspoll++;
1002 break;
1003 case WLAN_FSTYPE_RTS:
1004
1005 wlandev->rx.rts++;
1006 break;
1007 case WLAN_FSTYPE_CTS:
1008
1009 wlandev->rx.cts++;
1010 break;
1011 case WLAN_FSTYPE_ACK:
1012
1013 wlandev->rx.ack++;
1014 break;
1015 case WLAN_FSTYPE_CFEND:
1016
1017 wlandev->rx.cfend++;
1018 break;
1019 case WLAN_FSTYPE_CFENDCFACK:
1020
1021 wlandev->rx.cfendcfack++;
1022 break;
1023 default:
1024
1025 wlandev->rx.ctl_unknown++;
1026 break;
1027 }
1028
1029 drop = 2;
1030 break;
1031
1032 case WLAN_FTYPE_DATA:
1033 wlandev->rx.data++;
1034 switch (fstype) {
1035 case WLAN_FSTYPE_DATAONLY:
1036 wlandev->rx.dataonly++;
1037 break;
1038 case WLAN_FSTYPE_DATA_CFACK:
1039 wlandev->rx.data_cfack++;
1040 break;
1041 case WLAN_FSTYPE_DATA_CFPOLL:
1042 wlandev->rx.data_cfpoll++;
1043 break;
1044 case WLAN_FSTYPE_DATA_CFACK_CFPOLL:
1045 wlandev->rx.data__cfack_cfpoll++;
1046 break;
1047 case WLAN_FSTYPE_NULL:
1048 netdev_dbg(wlandev->netdev, "rx'd data:null\n");
1049 wlandev->rx.null++;
1050 break;
1051 case WLAN_FSTYPE_CFACK:
1052 netdev_dbg(wlandev->netdev, "rx'd data:cfack\n");
1053 wlandev->rx.cfack++;
1054 break;
1055 case WLAN_FSTYPE_CFPOLL:
1056 netdev_dbg(wlandev->netdev, "rx'd data:cfpoll\n");
1057 wlandev->rx.cfpoll++;
1058 break;
1059 case WLAN_FSTYPE_CFACK_CFPOLL:
1060 netdev_dbg(wlandev->netdev, "rx'd data:cfack_cfpoll\n");
1061 wlandev->rx.cfack_cfpoll++;
1062 break;
1063 default:
1064
1065 wlandev->rx.data_unknown++;
1066 break;
1067 }
1068
1069 break;
1070 }
1071 return drop;
1072}
1073
1074static void p80211knetdev_tx_timeout(struct net_device *netdev, unsigned int txqueue)
1075{
1076 struct wlandevice *wlandev = netdev->ml_priv;
1077
1078 if (wlandev->tx_timeout) {
1079 wlandev->tx_timeout(wlandev);
1080 } else {
1081 netdev_warn(netdev, "Implement tx_timeout for %s\n",
1082 wlandev->nsdname);
1083 netif_wake_queue(wlandev->netdev);
1084 }
1085}
1086