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#include <linux/compiler.h>
35#include <linux/errno.h>
36#include <linux/if_arp.h>
37#include <linux/in6.h>
38#include <linux/in.h>
39#include <linux/ip.h>
40#include <linux/kernel.h>
41#include <linux/module.h>
42#include <linux/netdevice.h>
43#include <linux/pci.h>
44#include <linux/proc_fs.h>
45#include <linux/skbuff.h>
46#include <linux/slab.h>
47#include <linux/tcp.h>
48#include <linux/types.h>
49#include <linux/wireless.h>
50#include <linux/etherdevice.h>
51#include <linux/uaccess.h>
52#include <linux/if_vlan.h>
53
54#include "ieee80211.h"
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154static u8 P802_1H_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0xf8 };
155static u8 RFC1042_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0x00 };
156
157static inline int ieee80211_put_snap(u8 *data, u16 h_proto)
158{
159 struct ieee80211_snap_hdr *snap;
160 u8 *oui;
161
162 snap = (struct ieee80211_snap_hdr *)data;
163 snap->dsap = 0xaa;
164 snap->ssap = 0xaa;
165 snap->ctrl = 0x03;
166
167 if (h_proto == 0x8137 || h_proto == 0x80f3)
168 oui = P802_1H_OUI;
169 else
170 oui = RFC1042_OUI;
171 snap->oui[0] = oui[0];
172 snap->oui[1] = oui[1];
173 snap->oui[2] = oui[2];
174
175 *(u16 *)(data + SNAP_SIZE) = htons(h_proto);
176
177 return SNAP_SIZE + sizeof(u16);
178}
179
180int ieee80211_encrypt_fragment(
181 struct ieee80211_device *ieee,
182 struct sk_buff *frag,
183 int hdr_len)
184{
185 struct ieee80211_crypt_data *crypt = ieee->crypt[ieee->tx_keyidx];
186 int res;
187
188 if (!(crypt && crypt->ops))
189 {
190 printk("=========>%s(), crypt is null\n", __func__);
191 return -1;
192 }
193
194 if (ieee->tkip_countermeasures &&
195 crypt && crypt->ops && strcmp(crypt->ops->name, "TKIP") == 0) {
196 if (net_ratelimit()) {
197 struct rtl_80211_hdr_3addrqos *header;
198
199 header = (struct rtl_80211_hdr_3addrqos *)frag->data;
200 printk(KERN_DEBUG "%s: TKIP countermeasures: dropped "
201 "TX packet to %pM\n",
202 ieee->dev->name, header->addr1);
203 }
204 return -1;
205 }
206
207
208
209
210
211
212
213 atomic_inc(&crypt->refcnt);
214 res = 0;
215 if (crypt->ops->encrypt_msdu)
216 res = crypt->ops->encrypt_msdu(frag, hdr_len, crypt->priv);
217 if (res == 0 && crypt->ops->encrypt_mpdu)
218 res = crypt->ops->encrypt_mpdu(frag, hdr_len, crypt->priv);
219
220 atomic_dec(&crypt->refcnt);
221 if (res < 0) {
222 printk(KERN_INFO "%s: Encryption failed: len=%d.\n",
223 ieee->dev->name, frag->len);
224 ieee->ieee_stats.tx_discards++;
225 return -1;
226 }
227
228 return 0;
229}
230
231
232void ieee80211_txb_free(struct ieee80211_txb *txb) {
233
234 if (unlikely(!txb))
235 return;
236 kfree(txb);
237}
238EXPORT_SYMBOL(ieee80211_txb_free);
239
240static struct ieee80211_txb *ieee80211_alloc_txb(int nr_frags, int txb_size,
241 gfp_t gfp_mask)
242{
243 struct ieee80211_txb *txb;
244 int i;
245 txb = kmalloc(
246 sizeof(struct ieee80211_txb) + (sizeof(u8 *) * nr_frags),
247 gfp_mask);
248 if (!txb)
249 return NULL;
250
251 memset(txb, 0, sizeof(struct ieee80211_txb));
252 txb->nr_frags = nr_frags;
253 txb->frag_size = txb_size;
254
255 for (i = 0; i < nr_frags; i++) {
256 txb->fragments[i] = dev_alloc_skb(txb_size);
257 if (unlikely(!txb->fragments[i])) {
258 i--;
259 break;
260 }
261 memset(txb->fragments[i]->cb, 0, sizeof(txb->fragments[i]->cb));
262 }
263 if (unlikely(i != nr_frags)) {
264 while (i >= 0)
265 dev_kfree_skb_any(txb->fragments[i--]);
266 kfree(txb);
267 return NULL;
268 }
269 return txb;
270}
271
272
273
274static int
275ieee80211_classify(struct sk_buff *skb, struct ieee80211_network *network)
276{
277 struct ethhdr *eth;
278 struct iphdr *ip;
279 eth = (struct ethhdr *)skb->data;
280 if (eth->h_proto != htons(ETH_P_IP))
281 return 0;
282
283
284 ip = ip_hdr(skb);
285 switch (ip->tos & 0xfc) {
286 case 0x20:
287 return 2;
288 case 0x40:
289 return 1;
290 case 0x60:
291 return 3;
292 case 0x80:
293 return 4;
294 case 0xa0:
295 return 5;
296 case 0xc0:
297 return 6;
298 case 0xe0:
299 return 7;
300 default:
301 return 0;
302 }
303}
304
305#define SN_LESS(a, b) (((a-b)&0x800)!=0)
306static void ieee80211_tx_query_agg_cap(struct ieee80211_device *ieee,
307 struct sk_buff *skb, cb_desc *tcb_desc)
308{
309 PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo;
310 PTX_TS_RECORD pTxTs = NULL;
311 struct rtl_80211_hdr_1addr *hdr = (struct rtl_80211_hdr_1addr *)skb->data;
312
313 if (!pHTInfo->bCurrentHTSupport||!pHTInfo->bEnableHT)
314 return;
315 if (!IsQoSDataFrame(skb->data))
316 return;
317
318 if (is_multicast_ether_addr(hdr->addr1))
319 return;
320
321#ifdef TO_DO_LIST
322 if(pTcb->PacketLength >= 4096)
323 return;
324
325 if(!Adapter->HalFunc.GetNmodeSupportBySecCfgHandler(Adapter))
326 return;
327#endif
328 if(!ieee->GetNmodeSupportBySecCfg(ieee->dev))
329 {
330 return;
331 }
332 if(pHTInfo->bCurrentAMPDUEnable)
333 {
334 if (!GetTs(ieee, (PTS_COMMON_INFO *)(&pTxTs), hdr->addr1, skb->priority, TX_DIR, true))
335 {
336 printk("===>can't get TS\n");
337 return;
338 }
339 if (!pTxTs->TxAdmittedBARecord.bValid)
340 {
341 TsStartAddBaProcess(ieee, pTxTs);
342 goto FORCED_AGG_SETTING;
343 }
344 else if (!pTxTs->bUsingBa)
345 {
346 if (SN_LESS(pTxTs->TxAdmittedBARecord.BaStartSeqCtrl.field.SeqNum, (pTxTs->TxCurSeq+1)%4096))
347 pTxTs->bUsingBa = true;
348 else
349 goto FORCED_AGG_SETTING;
350 }
351
352 if (ieee->iw_mode == IW_MODE_INFRA)
353 {
354 tcb_desc->bAMPDUEnable = true;
355 tcb_desc->ampdu_factor = pHTInfo->CurrentAMPDUFactor;
356 tcb_desc->ampdu_density = pHTInfo->CurrentMPDUDensity;
357 }
358 }
359FORCED_AGG_SETTING:
360 switch (pHTInfo->ForcedAMPDUMode )
361 {
362 case HT_AGG_AUTO:
363 break;
364
365 case HT_AGG_FORCE_ENABLE:
366 tcb_desc->bAMPDUEnable = true;
367 tcb_desc->ampdu_density = pHTInfo->ForcedMPDUDensity;
368 tcb_desc->ampdu_factor = pHTInfo->ForcedAMPDUFactor;
369 break;
370
371 case HT_AGG_FORCE_DISABLE:
372 tcb_desc->bAMPDUEnable = false;
373 tcb_desc->ampdu_density = 0;
374 tcb_desc->ampdu_factor = 0;
375 break;
376
377 }
378 return;
379}
380
381static void ieee80211_qurey_ShortPreambleMode(struct ieee80211_device *ieee,
382 cb_desc *tcb_desc)
383{
384 tcb_desc->bUseShortPreamble = false;
385 if (tcb_desc->data_rate == 2)
386 {
387 return;
388 }
389 else if (ieee->current_network.capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
390 {
391 tcb_desc->bUseShortPreamble = true;
392 }
393 return;
394}
395static void
396ieee80211_query_HTCapShortGI(struct ieee80211_device *ieee, cb_desc *tcb_desc)
397{
398 PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo;
399
400 tcb_desc->bUseShortGI = false;
401
402 if(!pHTInfo->bCurrentHTSupport||!pHTInfo->bEnableHT)
403 return;
404
405 if(pHTInfo->bForcedShortGI)
406 {
407 tcb_desc->bUseShortGI = true;
408 return;
409 }
410
411 if((pHTInfo->bCurBW40MHz==true) && pHTInfo->bCurShortGI40MHz)
412 tcb_desc->bUseShortGI = true;
413 else if((pHTInfo->bCurBW40MHz==false) && pHTInfo->bCurShortGI20MHz)
414 tcb_desc->bUseShortGI = true;
415}
416
417static void ieee80211_query_BandwidthMode(struct ieee80211_device *ieee,
418 cb_desc *tcb_desc)
419{
420 PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo;
421
422 tcb_desc->bPacketBW = false;
423
424 if(!pHTInfo->bCurrentHTSupport||!pHTInfo->bEnableHT)
425 return;
426
427 if(tcb_desc->bMulticast || tcb_desc->bBroadcast)
428 return;
429
430 if((tcb_desc->data_rate & 0x80)==0)
431 return;
432
433 if(pHTInfo->bCurBW40MHz && pHTInfo->bCurTxBW40MHz && !ieee->bandwidth_auto_switch.bforced_tx20Mhz)
434 tcb_desc->bPacketBW = true;
435 return;
436}
437
438static void ieee80211_query_protectionmode(struct ieee80211_device *ieee,
439 cb_desc *tcb_desc,
440 struct sk_buff *skb)
441{
442
443 tcb_desc->bRTSSTBC = false;
444 tcb_desc->bRTSUseShortGI = false;
445 tcb_desc->bCTSEnable = false;
446 tcb_desc->RTSSC = 0;
447 tcb_desc->bRTSBW = false;
448
449 if(tcb_desc->bBroadcast || tcb_desc->bMulticast)
450 return;
451
452 if (is_broadcast_ether_addr(skb->data+16))
453 return;
454
455 if (ieee->mode < IEEE_N_24G)
456 {
457
458
459
460
461 if (skb->len > ieee->rts)
462 {
463 tcb_desc->bRTSEnable = true;
464 tcb_desc->rts_rate = MGN_24M;
465 }
466 else if (ieee->current_network.buseprotection)
467 {
468
469 tcb_desc->bRTSEnable = true;
470 tcb_desc->bCTSEnable = true;
471 tcb_desc->rts_rate = MGN_24M;
472 }
473
474 return;
475 }
476 else
477 {
478 PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo;
479 while (true)
480 {
481
482 if (ieee->current_network.buseprotection)
483 {
484 tcb_desc->bRTSEnable = true;
485 tcb_desc->bCTSEnable = true;
486 tcb_desc->rts_rate = MGN_24M;
487 break;
488 }
489
490 if(pHTInfo->bCurrentHTSupport && pHTInfo->bEnableHT)
491 {
492 u8 HTOpMode = pHTInfo->CurrentOpMode;
493 if((pHTInfo->bCurBW40MHz && (HTOpMode == 2 || HTOpMode == 3)) ||
494 (!pHTInfo->bCurBW40MHz && HTOpMode == 3) )
495 {
496 tcb_desc->rts_rate = MGN_24M;
497 tcb_desc->bRTSEnable = true;
498 break;
499 }
500 }
501
502 if (skb->len > ieee->rts)
503 {
504 tcb_desc->rts_rate = MGN_24M;
505 tcb_desc->bRTSEnable = true;
506 break;
507 }
508
509
510 if(tcb_desc->bAMPDUEnable)
511 {
512 tcb_desc->rts_rate = MGN_24M;
513
514
515 tcb_desc->bRTSEnable = false;
516 break;
517 }
518
519 if(pHTInfo->IOTAction & HT_IOT_ACT_FORCED_CTS2SELF)
520 {
521 tcb_desc->bCTSEnable = true;
522 tcb_desc->rts_rate = MGN_24M;
523 tcb_desc->bRTSEnable = true;
524 break;
525 }
526
527 goto NO_PROTECTION;
528 }
529 }
530
531 if (0) {
532 tcb_desc->bCTSEnable = true;
533 tcb_desc->rts_rate = MGN_24M;
534 tcb_desc->bRTSEnable = true;
535 }
536 if (ieee->current_network.capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
537 tcb_desc->bUseShortPreamble = true;
538 if (ieee->mode == IW_MODE_MASTER)
539 goto NO_PROTECTION;
540 return;
541NO_PROTECTION:
542 tcb_desc->bRTSEnable = false;
543 tcb_desc->bCTSEnable = false;
544 tcb_desc->rts_rate = 0;
545 tcb_desc->RTSSC = 0;
546 tcb_desc->bRTSBW = false;
547}
548
549
550static void ieee80211_txrate_selectmode(struct ieee80211_device *ieee,
551 cb_desc *tcb_desc)
552{
553#ifdef TO_DO_LIST
554 if(!IsDataFrame(pFrame))
555 {
556 pTcb->bTxDisableRateFallBack = true;
557 pTcb->bTxUseDriverAssingedRate = true;
558 pTcb->RATRIndex = 7;
559 return;
560 }
561
562 if(pMgntInfo->ForcedDataRate!= 0)
563 {
564 pTcb->bTxDisableRateFallBack = true;
565 pTcb->bTxUseDriverAssingedRate = true;
566 return;
567 }
568#endif
569 if(ieee->bTxDisableRateFallBack)
570 tcb_desc->bTxDisableRateFallBack = true;
571
572 if(ieee->bTxUseDriverAssingedRate)
573 tcb_desc->bTxUseDriverAssingedRate = true;
574 if(!tcb_desc->bTxDisableRateFallBack || !tcb_desc->bTxUseDriverAssingedRate)
575 {
576 if (ieee->iw_mode == IW_MODE_INFRA || ieee->iw_mode == IW_MODE_ADHOC)
577 tcb_desc->RATRIndex = 0;
578 }
579}
580
581static void ieee80211_query_seqnum(struct ieee80211_device *ieee,
582 struct sk_buff *skb, u8 *dst)
583{
584 if (is_multicast_ether_addr(dst))
585 return;
586 if (IsQoSDataFrame(skb->data))
587 {
588 PTX_TS_RECORD pTS = NULL;
589 if (!GetTs(ieee, (PTS_COMMON_INFO *)(&pTS), dst, skb->priority, TX_DIR, true))
590 {
591 return;
592 }
593 pTS->TxCurSeq = (pTS->TxCurSeq+1)%4096;
594 }
595}
596
597int ieee80211_xmit(struct sk_buff *skb, struct net_device *dev)
598{
599 struct ieee80211_device *ieee = netdev_priv(dev);
600 struct ieee80211_txb *txb = NULL;
601 struct rtl_80211_hdr_3addrqos *frag_hdr;
602 int i, bytes_per_frag, nr_frags, bytes_last_frag, frag_size;
603 unsigned long flags;
604 struct net_device_stats *stats = &ieee->stats;
605 int ether_type = 0, encrypt;
606 int bytes, fc, qos_ctl = 0, hdr_len;
607 struct sk_buff *skb_frag;
608 struct rtl_80211_hdr_3addrqos header = {
609 .duration_id = 0,
610 .seq_ctl = 0,
611 .qos_ctl = 0
612 };
613 u8 dest[ETH_ALEN], src[ETH_ALEN];
614 int qos_actived = ieee->current_network.qos_data.active;
615
616 struct ieee80211_crypt_data *crypt;
617
618 cb_desc *tcb_desc;
619
620 spin_lock_irqsave(&ieee->lock, flags);
621
622
623
624 if ((!ieee->hard_start_xmit && !(ieee->softmac_features & IEEE_SOFTMAC_TX_QUEUE))||
625 ((!ieee->softmac_data_hard_start_xmit && (ieee->softmac_features & IEEE_SOFTMAC_TX_QUEUE)))) {
626 printk(KERN_WARNING "%s: No xmit handler.\n",
627 ieee->dev->name);
628 goto success;
629 }
630
631
632 if(likely(ieee->raw_tx == 0)){
633 if (unlikely(skb->len < SNAP_SIZE + sizeof(u16))) {
634 printk(KERN_WARNING "%s: skb too small (%d).\n",
635 ieee->dev->name, skb->len);
636 goto success;
637 }
638
639 memset(skb->cb, 0, sizeof(skb->cb));
640 ether_type = ntohs(((struct ethhdr *)skb->data)->h_proto);
641
642 crypt = ieee->crypt[ieee->tx_keyidx];
643
644 encrypt = !(ether_type == ETH_P_PAE && ieee->ieee802_1x) &&
645 ieee->host_encrypt && crypt && crypt->ops;
646
647 if (!encrypt && ieee->ieee802_1x &&
648 ieee->drop_unencrypted && ether_type != ETH_P_PAE) {
649 stats->tx_dropped++;
650 goto success;
651 }
652 #ifdef CONFIG_IEEE80211_DEBUG
653 if (crypt && !encrypt && ether_type == ETH_P_PAE) {
654 struct eapol *eap = (struct eapol *)(skb->data +
655 sizeof(struct ethhdr) - SNAP_SIZE - sizeof(u16));
656 IEEE80211_DEBUG_EAP("TX: IEEE 802.11 EAPOL frame: %s\n",
657 eap_get_type(eap->type));
658 }
659 #endif
660
661
662 memcpy(&dest, skb->data, ETH_ALEN);
663 memcpy(&src, skb->data+ETH_ALEN, ETH_ALEN);
664
665
666 skb_pull(skb, sizeof(struct ethhdr));
667
668
669 bytes = skb->len + SNAP_SIZE + sizeof(u16);
670
671 if (encrypt)
672 fc = IEEE80211_FTYPE_DATA | IEEE80211_FCTL_WEP;
673 else
674
675 fc = IEEE80211_FTYPE_DATA;
676
677
678 if(qos_actived)
679 fc |= IEEE80211_STYPE_QOS_DATA;
680 else
681 fc |= IEEE80211_STYPE_DATA;
682
683 if (ieee->iw_mode == IW_MODE_INFRA) {
684 fc |= IEEE80211_FCTL_TODS;
685
686
687 memcpy(&header.addr1, ieee->current_network.bssid, ETH_ALEN);
688 memcpy(&header.addr2, &src, ETH_ALEN);
689 memcpy(&header.addr3, &dest, ETH_ALEN);
690 } else if (ieee->iw_mode == IW_MODE_ADHOC) {
691
692
693 memcpy(&header.addr1, dest, ETH_ALEN);
694 memcpy(&header.addr2, src, ETH_ALEN);
695 memcpy(&header.addr3, ieee->current_network.bssid, ETH_ALEN);
696 }
697
698 header.frame_ctl = cpu_to_le16(fc);
699
700
701
702 if (is_multicast_ether_addr(header.addr1)) {
703 frag_size = MAX_FRAG_THRESHOLD;
704 qos_ctl |= QOS_CTL_NOTCONTAIN_ACK;
705 }
706 else {
707 frag_size = ieee->fts;
708 qos_ctl = 0;
709 }
710
711
712 if(qos_actived)
713 {
714 hdr_len = IEEE80211_3ADDR_LEN + 2;
715
716 skb->priority = ieee80211_classify(skb, &ieee->current_network);
717 qos_ctl |= skb->priority;
718 header.qos_ctl = cpu_to_le16(qos_ctl & IEEE80211_QOS_TID);
719 } else {
720 hdr_len = IEEE80211_3ADDR_LEN;
721 }
722
723
724
725
726 bytes_per_frag = frag_size - hdr_len;
727 if (ieee->config &
728 (CFG_IEEE80211_COMPUTE_FCS | CFG_IEEE80211_RESERVE_FCS))
729 bytes_per_frag -= IEEE80211_FCS_LEN;
730
731
732 if (encrypt)
733 bytes_per_frag -= crypt->ops->extra_prefix_len +
734 crypt->ops->extra_postfix_len;
735
736
737
738 nr_frags = bytes / bytes_per_frag;
739 bytes_last_frag = bytes % bytes_per_frag;
740 if (bytes_last_frag)
741 nr_frags++;
742 else
743 bytes_last_frag = bytes_per_frag;
744
745
746
747
748 txb = ieee80211_alloc_txb(nr_frags, frag_size + ieee->tx_headroom, GFP_ATOMIC);
749 if (unlikely(!txb)) {
750 printk(KERN_WARNING "%s: Could not allocate TXB\n",
751 ieee->dev->name);
752 goto failed;
753 }
754 txb->encrypted = encrypt;
755 txb->payload_size = bytes;
756
757
758 if(qos_actived)
759 {
760 txb->queue_index = UP2AC(skb->priority);
761 } else {
762 txb->queue_index = WME_AC_BK;
763 }
764
765
766
767 for (i = 0; i < nr_frags; i++) {
768 skb_frag = txb->fragments[i];
769 tcb_desc = (cb_desc *)(skb_frag->cb + MAX_DEV_ADDR_SIZE);
770 if(qos_actived){
771 skb_frag->priority = skb->priority;
772 tcb_desc->queue_index = UP2AC(skb->priority);
773 } else {
774 skb_frag->priority = WME_AC_BK;
775 tcb_desc->queue_index = WME_AC_BK;
776 }
777 skb_reserve(skb_frag, ieee->tx_headroom);
778
779 if (encrypt){
780 if (ieee->hwsec_active)
781 tcb_desc->bHwSec = 1;
782 else
783 tcb_desc->bHwSec = 0;
784 skb_reserve(skb_frag, crypt->ops->extra_prefix_len);
785 }
786 else
787 {
788 tcb_desc->bHwSec = 0;
789 }
790 frag_hdr = (struct rtl_80211_hdr_3addrqos *)skb_put(skb_frag, hdr_len);
791 memcpy(frag_hdr, &header, hdr_len);
792
793
794
795 if (i != nr_frags - 1) {
796 frag_hdr->frame_ctl = cpu_to_le16(
797 fc | IEEE80211_FCTL_MOREFRAGS);
798 bytes = bytes_per_frag;
799
800 } else {
801
802 bytes = bytes_last_frag;
803 }
804
805 if(qos_actived)
806 {
807
808 frag_hdr->seq_ctl = cpu_to_le16(ieee->seq_ctrl[UP2AC(skb->priority)+1]<<4 | i);
809 } else {
810 frag_hdr->seq_ctl = cpu_to_le16(ieee->seq_ctrl[0]<<4 | i);
811 }
812
813
814 if (i == 0) {
815 ieee80211_put_snap(
816 skb_put(skb_frag, SNAP_SIZE + sizeof(u16)),
817 ether_type);
818 bytes -= SNAP_SIZE + sizeof(u16);
819 }
820
821 memcpy(skb_put(skb_frag, bytes), skb->data, bytes);
822
823
824 skb_pull(skb, bytes);
825
826
827
828 if (encrypt)
829 ieee80211_encrypt_fragment(ieee, skb_frag, hdr_len);
830 if (ieee->config &
831 (CFG_IEEE80211_COMPUTE_FCS | CFG_IEEE80211_RESERVE_FCS))
832 skb_put(skb_frag, 4);
833 }
834
835 if(qos_actived)
836 {
837 if (ieee->seq_ctrl[UP2AC(skb->priority) + 1] == 0xFFF)
838 ieee->seq_ctrl[UP2AC(skb->priority) + 1] = 0;
839 else
840 ieee->seq_ctrl[UP2AC(skb->priority) + 1]++;
841 } else {
842 if (ieee->seq_ctrl[0] == 0xFFF)
843 ieee->seq_ctrl[0] = 0;
844 else
845 ieee->seq_ctrl[0]++;
846 }
847 }else{
848 if (unlikely(skb->len < sizeof(struct rtl_80211_hdr_3addr))) {
849 printk(KERN_WARNING "%s: skb too small (%d).\n",
850 ieee->dev->name, skb->len);
851 goto success;
852 }
853
854 txb = ieee80211_alloc_txb(1, skb->len, GFP_ATOMIC);
855 if(!txb){
856 printk(KERN_WARNING "%s: Could not allocate TXB\n",
857 ieee->dev->name);
858 goto failed;
859 }
860
861 txb->encrypted = 0;
862 txb->payload_size = skb->len;
863 memcpy(skb_put(txb->fragments[0],skb->len), skb->data, skb->len);
864 }
865
866 success:
867
868 if (txb)
869 {
870 cb_desc *tcb_desc = (cb_desc *)(txb->fragments[0]->cb + MAX_DEV_ADDR_SIZE);
871 tcb_desc->bTxEnableFwCalcDur = 1;
872 if (is_multicast_ether_addr(header.addr1))
873 tcb_desc->bMulticast = 1;
874 if (is_broadcast_ether_addr(header.addr1))
875 tcb_desc->bBroadcast = 1;
876 ieee80211_txrate_selectmode(ieee, tcb_desc);
877 if (tcb_desc->bMulticast || tcb_desc->bBroadcast)
878 tcb_desc->data_rate = ieee->basic_rate;
879 else
880
881 tcb_desc->data_rate = CURRENT_RATE(ieee->mode, ieee->rate, ieee->HTCurrentOperaRate);
882 ieee80211_qurey_ShortPreambleMode(ieee, tcb_desc);
883 ieee80211_tx_query_agg_cap(ieee, txb->fragments[0], tcb_desc);
884 ieee80211_query_HTCapShortGI(ieee, tcb_desc);
885 ieee80211_query_BandwidthMode(ieee, tcb_desc);
886 ieee80211_query_protectionmode(ieee, tcb_desc, txb->fragments[0]);
887 ieee80211_query_seqnum(ieee, txb->fragments[0], header.addr1);
888
889
890 }
891 spin_unlock_irqrestore(&ieee->lock, flags);
892 dev_kfree_skb_any(skb);
893 if (txb) {
894 if (ieee->softmac_features & IEEE_SOFTMAC_TX_QUEUE){
895 ieee80211_softmac_xmit(txb, ieee);
896 }else{
897 if ((*ieee->hard_start_xmit)(txb, dev) == 0) {
898 stats->tx_packets++;
899 stats->tx_bytes += txb->payload_size;
900 return 0;
901 }
902 ieee80211_txb_free(txb);
903 }
904 }
905
906 return 0;
907
908 failed:
909 spin_unlock_irqrestore(&ieee->lock, flags);
910 netif_stop_queue(dev);
911 stats->tx_errors++;
912 return 1;
913
914}
915