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