projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Staging: rtl8192u: Replace TRUE with true
[deliverable/linux.git] / drivers / staging / rtl8192u / ieee80211 / ieee80211_tx.c
1 /******************************************************************************
2
3 Copyright(c) 2003 - 2004 Intel Corporation. All rights reserved.
4
5 This program is free software; you can redistribute it and/or modify it
6 under the terms of version 2 of the GNU General Public License as
7 published by the Free Software Foundation.
8
9 This program is distributed in the hope that it will be useful, but WITHOUT
10 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 more details.
13
14 You should have received a copy of the GNU General Public License along with
15 this program; if not, write to the Free Software Foundation, Inc., 59
16 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17
18 The full GNU General Public License is included in this distribution in the
19 file called LICENSE.
20
21 Contact Information:
22 James P. Ketrenos <ipw2100-admin@linux.intel.com>
23 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
24
25 ******************************************************************************
26
27 Few modifications for Realtek's Wi-Fi drivers by
28 Andrea Merello <andrea.merello@gmail.com>
29
30 A special thanks goes to Realtek for their support !
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 <asm/uaccess.h>
52 #include <linux/if_vlan.h>
53
54 #include "ieee80211.h"
55
56
57 /*
58
59
60 802.11 Data Frame
61
62
63 802.11 frame_contorl for data frames - 2 bytes
64 ,-----------------------------------------------------------------------------------------.
65 bits | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | a | b | c | d | e |
66 |----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|------|
67 val | 0 | 0 | 0 | 1 | x | 0 | 0 | 0 | 1 | 0 | x | x | x | x | x |
68 |----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|------|
69 desc | ^-ver-^ | ^type-^ | ^-----subtype-----^ | to |from |more |retry| pwr |more |wep |
70 | | | x=0 data,x=1 data+ack | DS | DS |frag | | mgm |data | |
71 '-----------------------------------------------------------------------------------------'
72 /\
73 |
74 802.11 Data Frame |
75 ,--------- 'ctrl' expands to >-----------'
76 |
77 ,--'---,-------------------------------------------------------------.
78 Bytes | 2 | 2 | 6 | 6 | 6 | 2 | 0..2312 | 4 |
79 |------|------|---------|---------|---------|------|---------|------|
80 Desc. | ctrl | dura | DA/RA | TA | SA | Sequ | Frame | fcs |
81 | | tion | (BSSID) | | | ence | data | |
82 `--------------------------------------------------| |------'
83 Total: 28 non-data bytes `----.----'
84 |
85 .- 'Frame data' expands to <---------------------------'
86 |
87 V
88 ,---------------------------------------------------.
89 Bytes | 1 | 1 | 1 | 3 | 2 | 0-2304 |
90 |------|------|---------|----------|------|---------|
91 Desc. | SNAP | SNAP | Control |Eth Tunnel| Type | IP |
92 | DSAP | SSAP | | | | Packet |
93 | 0xAA | 0xAA |0x03 (UI)|0x00-00-F8| | |
94 `-----------------------------------------| |
95 Total: 8 non-data bytes `----.----'
96 |
97 .- 'IP Packet' expands, if WEP enabled, to <--'
98 |
99 V
100 ,-----------------------.
101 Bytes | 4 | 0-2296 | 4 |
102 |-----|-----------|-----|
103 Desc. | IV | Encrypted | ICV |
104 | | IP Packet | |
105 `-----------------------'
106 Total: 8 non-data bytes
107
108
109 802.3 Ethernet Data Frame
110
111 ,-----------------------------------------.
112 Bytes | 6 | 6 | 2 | Variable | 4 |
113 |-------|-------|------|-----------|------|
114 Desc. | Dest. | Source| Type | IP Packet | fcs |
115 | MAC | MAC | | | |
116 `-----------------------------------------'
117 Total: 18 non-data bytes
118
119 In the event that fragmentation is required, the incoming payload is split into
120 N parts of size ieee->fts. The first fragment contains the SNAP header and the
121 remaining packets are just data.
122
123 If encryption is enabled, each fragment payload size is reduced by enough space
124 to add the prefix and postfix (IV and ICV totalling 8 bytes in the case of WEP)
125 So if you have 1500 bytes of payload with ieee->fts set to 500 without
126 encryption it will take 3 frames. With WEP it will take 4 frames as the
127 payload of each frame is reduced to 492 bytes.
128
129 * SKB visualization
130 *
131 * ,- skb->data
132 * |
133 * | ETHERNET HEADER ,-<-- PAYLOAD
134 * | | 14 bytes from skb->data
135 * | 2 bytes for Type --> ,T. | (sizeof ethhdr)
136 * | | | |
137 * |,-Dest.--. ,--Src.---. | | |
138 * | 6 bytes| | 6 bytes | | | |
139 * v | | | | | |
140 * 0 | v 1 | v | v 2
141 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
142 * ^ | ^ | ^ |
143 * | | | | | |
144 * | | | | `T' <---- 2 bytes for Type
145 * | | | |
146 * | | '---SNAP--' <-------- 6 bytes for SNAP
147 * | |
148 * `-IV--' <-------------------- 4 bytes for IV (WEP)
149 *
150 * SNAP HEADER
151 *
152 */
153
154 static u8 P802_1H_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0xf8 };
155 static u8 RFC1042_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0x00 };
156
157 static 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
180 int 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 ieee80211_hdr_3addrqos *header;
198
199 header = (struct ieee80211_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 /* To encrypt, frame format is:
208 * IV (4 bytes), clear payload (including SNAP), ICV (4 bytes) */
209
210 // PR: FIXME: Copied from hostap. Check fragmentation/MSDU/MPDU encryption.
211 /* Host-based IEEE 802.11 fragmentation for TX is not yet supported, so
212 * call both MSDU and MPDU encryption functions from here. */
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
232 void ieee80211_txb_free(struct ieee80211_txb *txb) {
233 //int i;
234 if (unlikely(!txb))
235 return;
236 kfree(txb);
237 }
238 EXPORT_SYMBOL(ieee80211_txb_free);
239
240 static 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 // Classify the to-be send data packet
273 // Need to acquire the sent queue index.
274 static int
275 ieee80211_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 // IEEE80211_DEBUG_DATA(IEEE80211_DL_DATA, skb->data, skb->len);
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)
306 static 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 ieee80211_hdr_1addr *hdr = (struct ieee80211_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 //check packet and mode later
321 #ifdef TO_DO_LIST
322 if(pTcb->PacketLength >= 4096)
323 return;
324 // For RTL819X, if pairwisekey = wep/tkip, we don't aggrregation.
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 == false)
340 {
341 TsStartAddBaProcess(ieee, pTxTs);
342 goto FORCED_AGG_SETTING;
343 }
344 else if (pTxTs->bUsingBa == false)
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 }
359 FORCED_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
381 static 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 {//// 1M can only use Long Preamble. 11B spec
387 return;
388 }
389 else if (ieee->current_network.capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
390 {
391 tcb_desc->bUseShortPreamble = true;
392 }
393 return;
394 }
395 static void
396 ieee80211_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
417 static 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) // If using legacy rate, it shall use 20MHz channel.
431 return;
432 //BandWidthAutoSwitch is for auto switch to 20 or 40 in long distance
433 if(pHTInfo->bCurBW40MHz && pHTInfo->bCurTxBW40MHz && !ieee->bandwidth_auto_switch.bforced_tx20Mhz)
434 tcb_desc->bPacketBW = true;
435 return;
436 }
437
438 static void ieee80211_query_protectionmode(struct ieee80211_device *ieee,
439 cb_desc *tcb_desc,
440 struct sk_buff *skb)
441 {
442 // Common Settings
443 tcb_desc->bRTSSTBC = false;
444 tcb_desc->bRTSUseShortGI = false; // Since protection frames are always sent by legacy rate, ShortGI will never be used.
445 tcb_desc->bCTSEnable = false; // Most of protection using RTS/CTS
446 tcb_desc->RTSSC = 0; // 20MHz: Don't care; 40MHz: Duplicate.
447 tcb_desc->bRTSBW = false; // RTS frame bandwidth is always 20MHz
448
449 if(tcb_desc->bBroadcast || tcb_desc->bMulticast)//only unicast frame will use rts/cts
450 return;
451
452 if (is_broadcast_ether_addr(skb->data+16)) //check addr3 as infrastructure add3 is DA.
453 return;
454
455 if (ieee->mode < IEEE_N_24G) //b, g mode
456 {
457 // (1) RTS_Threshold is compared to the MPDU, not MSDU.
458 // (2) If there are more than one frag in this MSDU, only the first frag uses protection frame.
459 // Other fragments are protected by previous fragment.
460 // So we only need to check the length of first fragment.
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 // Use CTS-to-SELF in protection mode.
469 tcb_desc->bRTSEnable = true;
470 tcb_desc->bCTSEnable = true;
471 tcb_desc->rts_rate = MGN_24M;
472 }
473 //otherwise return;
474 return;
475 }
476 else
477 {// 11n High throughput case.
478 PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo;
479 while (true)
480 {
481 //check ERP protection
482 if (ieee->current_network.buseprotection)
483 {// CTS-to-SELF
484 tcb_desc->bRTSEnable = true;
485 tcb_desc->bCTSEnable = true;
486 tcb_desc->rts_rate = MGN_24M;
487 break;
488 }
489 //check HT op mode
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; // Rate is 24Mbps.
497 tcb_desc->bRTSEnable = true;
498 break;
499 }
500 }
501 //check rts
502 if (skb->len > ieee->rts)
503 {
504 tcb_desc->rts_rate = MGN_24M; // Rate is 24Mbps.
505 tcb_desc->bRTSEnable = true;
506 break;
507 }
508 //to do list: check MIMO power save condition.
509 //check AMPDU aggregation for TXOP
510 if(tcb_desc->bAMPDUEnable)
511 {
512 tcb_desc->rts_rate = MGN_24M; // Rate is 24Mbps.
513 // According to 8190 design, firmware sends CF-End only if RTS/CTS is enabled. However, it degrads
514 // throughput around 10M, so we disable of this mechanism. 2007.08.03 by Emily
515 tcb_desc->bRTSEnable = false;
516 break;
517 }
518 //check IOT action
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 // Totally no protection case!!
527 goto NO_PROTECTION;
528 }
529 }
530 // For test , CTS replace with RTS
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;
541 NO_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
550 static 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
581 static 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)) //we deal qos data only
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
597 int 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 ieee80211_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 ieee80211_hdr_3addrqos header = { /* Ensure zero initialized */
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 /* If there is no driver handler to take the TXB, dont' bother
623 * creating it... */
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 /* Save source and destination addresses */
662 memcpy(&dest, skb->data, ETH_ALEN);
663 memcpy(&src, skb->data+ETH_ALEN, ETH_ALEN);
664
665 /* Advance the SKB to the start of the payload */
666 skb_pull(skb, sizeof(struct ethhdr));
667
668 /* Determine total amount of storage required for TXB packets */
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 //if(ieee->current_network.QoS_Enable)
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 /* To DS: Addr1 = BSSID, Addr2 = SA,
686 Addr3 = DA */
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 /* not From/To DS: Addr1 = DA, Addr2 = SA,
692 Addr3 = BSSID */
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 /* Determine fragmentation size based on destination (multicast
701 * and broadcast are not fragmented) */
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;//default:392
708 qos_ctl = 0;
709 }
710
711 //if (ieee->current_network.QoS_Enable)
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; //set in the ieee80211_classify
718 header.qos_ctl = cpu_to_le16(qos_ctl & IEEE80211_QOS_TID);
719 } else {
720 hdr_len = IEEE80211_3ADDR_LEN;
721 }
722 /* Determine amount of payload per fragment. Regardless of if
723 * this stack is providing the full 802.11 header, one will
724 * eventually be affixed to this fragment -- so we must account for
725 * it when determining the amount of payload space. */
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 /* Each fragment may need to have room for encryption pre/postfix */
732 if (encrypt)
733 bytes_per_frag -= crypt->ops->extra_prefix_len +
734 crypt->ops->extra_postfix_len;
735
736 /* Number of fragments is the total bytes_per_frag /
737 * payload_per_fragment */
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 /* When we allocate the TXB we allocate enough space for the reserve
746 * and full fragment bytes (bytes_per_frag doesn't include prefix,
747 * postfix, header, FCS, etc.) */
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 //if (ieee->current_network.QoS_Enable)
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;//UP2AC(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 ieee80211_hdr_3addrqos *)skb_put(skb_frag, hdr_len);
791 memcpy(frag_hdr, &header, hdr_len);
792
793 /* If this is not the last fragment, then add the MOREFRAGS
794 * bit to the frame control */
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 /* The last fragment takes the remaining length */
802 bytes = bytes_last_frag;
803 }
804 //if(ieee->current_network.QoS_Enable)
805 if(qos_actived)
806 {
807 // add 1 only indicate to corresponding seq number control 2006/7/12
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 /* Put a SNAP header on the first fragment */
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 /* Advance the SKB... */
824 skb_pull(skb, bytes);
825
826 /* Encryption routine will move the header forward in order
827 * to insert the IV between the header and the payload */
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 ieee80211_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 //WB add to fill data tcb_desc here. only first fragment is considered, need to change, and you may remove to other place.
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 //tcb_desc->data_rate = CURRENT_RATE(ieee->current_network.mode, ieee->rate, ieee->HTCurrentOperaRate);
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 // IEEE80211_DEBUG_DATA(IEEE80211_DL_DATA, txb->fragments[0]->data, txb->fragments[0]->len);
889 //IEEE80211_DEBUG_DATA(IEEE80211_DL_DATA, tcb_desc, sizeof(cb_desc));
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 }
Linux kernel - Deliverables
This page took 0.074293 seconds and 5 git commands to generate.