?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Staging: rtl8192u: remove dead code
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / staging / rtl8192u / ieee80211 / ieee80211_tx.c
blobb29c36bac377d005d7308f52c4ad024df2cb1be0
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 <andreamrl@tiscali.it>
29
30 A special thanks goes to Realtek for their support !
31
32 ******************************************************************************/
33
34 #include <linux/compiler.h>
35 //#include <linux/config.h>
36 #include <linux/errno.h>
37 #include <linux/if_arp.h>
38 #include <linux/in6.h>
39 #include <linux/in.h>
40 #include <linux/ip.h>
41 #include <linux/kernel.h>
42 #include <linux/module.h>
43 #include <linux/netdevice.h>
44 #include <linux/pci.h>
45 #include <linux/proc_fs.h>
46 #include <linux/skbuff.h>
47 #include <linux/slab.h>
48 #include <linux/tcp.h>
49 #include <linux/types.h>
50 #include <linux/version.h>
51 #include <linux/wireless.h>
52 #include <linux/etherdevice.h>
53 #include <asm/uaccess.h>
54 #include <linux/if_vlan.h>
55
56 #include "ieee80211.h"
57
58
59 /*
60
61
62 802.11 Data Frame
63
64
65 802.11 frame_contorl for data frames - 2 bytes
66 ,-----------------------------------------------------------------------------------------.
67 bits | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | a | b | c | d | e |
68 |----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|------|
69 val | 0 | 0 | 0 | 1 | x | 0 | 0 | 0 | 1 | 0 | x | x | x | x | x |
70 |----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|------|
71 desc | ^-ver-^ | ^type-^ | ^-----subtype-----^ | to |from |more |retry| pwr |more |wep |
72 | | | x=0 data,x=1 data+ack | DS | DS |frag | | mgm |data | |
73 '-----------------------------------------------------------------------------------------'
74 /\
75 |
76 802.11 Data Frame |
77 ,--------- 'ctrl' expands to >-----------'
78 |
79 ,--'---,-------------------------------------------------------------.
80 Bytes | 2 | 2 | 6 | 6 | 6 | 2 | 0..2312 | 4 |
81 |------|------|---------|---------|---------|------|---------|------|
82 Desc. | ctrl | dura | DA/RA | TA | SA | Sequ | Frame | fcs |
83 | | tion | (BSSID) | | | ence | data | |
84 `--------------------------------------------------| |------'
85 Total: 28 non-data bytes `----.----'
86 |
87 .- 'Frame data' expands to <---------------------------'
88 |
89 V
90 ,---------------------------------------------------.
91 Bytes | 1 | 1 | 1 | 3 | 2 | 0-2304 |
92 |------|------|---------|----------|------|---------|
93 Desc. | SNAP | SNAP | Control |Eth Tunnel| Type | IP |
94 | DSAP | SSAP | | | | Packet |
95 | 0xAA | 0xAA |0x03 (UI)|0x00-00-F8| | |
96 `-----------------------------------------| |
97 Total: 8 non-data bytes `----.----'
98 |
99 .- 'IP Packet' expands, if WEP enabled, to <--'
100 |
101 V
102 ,-----------------------.
103 Bytes | 4 | 0-2296 | 4 |
104 |-----|-----------|-----|
105 Desc. | IV | Encrypted | ICV |
106 | | IP Packet | |
107 `-----------------------'
108 Total: 8 non-data bytes
109
110
111 802.3 Ethernet Data Frame
112
113 ,-----------------------------------------.
114 Bytes | 6 | 6 | 2 | Variable | 4 |
115 |-------|-------|------|-----------|------|
116 Desc. | Dest. | Source| Type | IP Packet | fcs |
117 | MAC | MAC | | | |
118 `-----------------------------------------'
119 Total: 18 non-data bytes
120
121 In the event that fragmentation is required, the incoming payload is split into
122 N parts of size ieee->fts. The first fragment contains the SNAP header and the
123 remaining packets are just data.
124
125 If encryption is enabled, each fragment payload size is reduced by enough space
126 to add the prefix and postfix (IV and ICV totalling 8 bytes in the case of WEP)
127 So if you have 1500 bytes of payload with ieee->fts set to 500 without
128 encryption it will take 3 frames. With WEP it will take 4 frames as the
129 payload of each frame is reduced to 492 bytes.
130
131 * SKB visualization
132 *
133 * ,- skb->data
134 * |
135 * | ETHERNET HEADER ,-<-- PAYLOAD
136 * | | 14 bytes from skb->data
137 * | 2 bytes for Type --> ,T. | (sizeof ethhdr)
138 * | | | |
139 * |,-Dest.--. ,--Src.---. | | |
140 * | 6 bytes| | 6 bytes | | | |
141 * v | | | | | |
142 * 0 | v 1 | v | v 2
143 * 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
144 * ^ | ^ | ^ |
145 * | | | | | |
146 * | | | | `T' <---- 2 bytes for Type
147 * | | | |
148 * | | '---SNAP--' <-------- 6 bytes for SNAP
149 * | |
150 * `-IV--' <-------------------- 4 bytes for IV (WEP)
151 *
152 * SNAP HEADER
153 *
154 */
155
156 static u8 P802_1H_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0xf8 };
157 static u8 RFC1042_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0x00 };
158
159 static inline int ieee80211_put_snap(u8 *data, u16 h_proto)
160 {
161 struct ieee80211_snap_hdr *snap;
162 u8 *oui;
163
164 snap = (struct ieee80211_snap_hdr *)data;
165 snap->dsap = 0xaa;
166 snap->ssap = 0xaa;
167 snap->ctrl = 0x03;
168
169 if (h_proto == 0x8137 || h_proto == 0x80f3)
170 oui = P802_1H_OUI;
171 else
172 oui = RFC1042_OUI;
173 snap->oui[0] = oui[0];
174 snap->oui[1] = oui[1];
175 snap->oui[2] = oui[2];
176
177 *(u16 *)(data + SNAP_SIZE) = htons(h_proto);
178
179 return SNAP_SIZE + sizeof(u16);
180 }
181
182 int ieee80211_encrypt_fragment(
183 struct ieee80211_device *ieee,
184 struct sk_buff *frag,
185 int hdr_len)
186 {
187 struct ieee80211_crypt_data* crypt = ieee->crypt[ieee->tx_keyidx];
188 int res;
189
190 if (!(crypt && crypt->ops))
191 {
192 printk("=========>%s(), crypt is null\n", __FUNCTION__);
193 return -1;
194 }
195 #ifdef CONFIG_IEEE80211_CRYPT_TKIP
196 struct ieee80211_hdr *header;
197
198 if (ieee->tkip_countermeasures &&
199 crypt && crypt->ops && strcmp(crypt->ops->name, "TKIP") == 0) {
200 header = (struct ieee80211_hdr *) frag->data;
201 if (net_ratelimit()) {
202 printk(KERN_DEBUG "%s: TKIP countermeasures: dropped "
203 "TX packet to " MAC_FMT "\n",
204 ieee->dev->name, MAC_ARG(header->addr1));
205 }
206 return -1;
207 }
208 #endif
209 /* To encrypt, frame format is:
210 * IV (4 bytes), clear payload (including SNAP), ICV (4 bytes) */
211
212 // PR: FIXME: Copied from hostap. Check fragmentation/MSDU/MPDU encryption.
213 /* Host-based IEEE 802.11 fragmentation for TX is not yet supported, so
214 * call both MSDU and MPDU encryption functions from here. */
215 atomic_inc(&crypt->refcnt);
216 res = 0;
217 if (crypt->ops->encrypt_msdu)
218 res = crypt->ops->encrypt_msdu(frag, hdr_len, crypt->priv);
219 if (res == 0 && crypt->ops->encrypt_mpdu)
220 res = crypt->ops->encrypt_mpdu(frag, hdr_len, crypt->priv);
221
222 atomic_dec(&crypt->refcnt);
223 if (res < 0) {
224 printk(KERN_INFO "%s: Encryption failed: len=%d.\n",
225 ieee->dev->name, frag->len);
226 ieee->ieee_stats.tx_discards++;
227 return -1;
228 }
229
230 return 0;
231 }
232
233
234 void ieee80211_txb_free(struct ieee80211_txb *txb) {
235 //int i;
236 if (unlikely(!txb))
237 return;
238 kfree(txb);
239 }
240
241 struct ieee80211_txb *ieee80211_alloc_txb(int nr_frags, int txb_size,
242 int gfp_mask)
243 {
244 struct ieee80211_txb *txb;
245 int i;
246 txb = kmalloc(
247 sizeof(struct ieee80211_txb) + (sizeof(u8*) * nr_frags),
248 gfp_mask);
249 if (!txb)
250 return NULL;
251
252 memset(txb, 0, sizeof(struct ieee80211_txb));
253 txb->nr_frags = nr_frags;
254 txb->frag_size = txb_size;
255
256 for (i = 0; i < nr_frags; i++) {
257 txb->fragments[i] = dev_alloc_skb(txb_size);
258 if (unlikely(!txb->fragments[i])) {
259 i--;
260 break;
261 }
262 memset(txb->fragments[i]->cb, 0, sizeof(txb->fragments[i]->cb));
263 }
264 if (unlikely(i != nr_frags)) {
265 while (i >= 0)
266 dev_kfree_skb_any(txb->fragments[i--]);
267 kfree(txb);
268 return NULL;
269 }
270 return txb;
271 }
272
273 // Classify the to-be send data packet
274 // Need to acquire the sent queue index.
275 static int
276 ieee80211_classify(struct sk_buff *skb, struct ieee80211_network *network)
277 {
278 struct ethhdr *eth;
279 struct iphdr *ip;
280 eth = (struct ethhdr *)skb->data;
281 if (eth->h_proto != htons(ETH_P_IP))
282 return 0;
283
284 // IEEE80211_DEBUG_DATA(IEEE80211_DL_DATA, skb->data, skb->len);
285 ip = ip_hdr(skb);
286 switch (ip->tos & 0xfc) {
287 case 0x20:
288 return 2;
289 case 0x40:
290 return 1;
291 case 0x60:
292 return 3;
293 case 0x80:
294 return 4;
295 case 0xa0:
296 return 5;
297 case 0xc0:
298 return 6;
299 case 0xe0:
300 return 7;
301 default:
302 return 0;
303 }
304 }
305
306 #define SN_LESS(a, b) (((a-b)&0x800)!=0)
307 void ieee80211_tx_query_agg_cap(struct ieee80211_device* ieee, 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) || is_broadcast_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 extern void ieee80211_qurey_ShortPreambleMode(struct ieee80211_device* ieee, cb_desc* tcb_desc)
382 {
383 tcb_desc->bUseShortPreamble = false;
384 if (tcb_desc->data_rate == 2)
385 {//// 1M can only use Long Preamble. 11B spec
386 return;
387 }
388 else if (ieee->current_network.capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
389 {
390 tcb_desc->bUseShortPreamble = true;
391 }
392 return;
393 }
394 extern void
395 ieee80211_query_HTCapShortGI(struct ieee80211_device *ieee, cb_desc *tcb_desc)
396 {
397 PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo;
398
399 tcb_desc->bUseShortGI = false;
400
401 if(!pHTInfo->bCurrentHTSupport||!pHTInfo->bEnableHT)
402 return;
403
404 if(pHTInfo->bForcedShortGI)
405 {
406 tcb_desc->bUseShortGI = true;
407 return;
408 }
409
410 if((pHTInfo->bCurBW40MHz==true) && pHTInfo->bCurShortGI40MHz)
411 tcb_desc->bUseShortGI = true;
412 else if((pHTInfo->bCurBW40MHz==false) && pHTInfo->bCurShortGI20MHz)
413 tcb_desc->bUseShortGI = true;
414 }
415
416 void ieee80211_query_BandwidthMode(struct ieee80211_device* ieee, cb_desc *tcb_desc)
417 {
418 PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo;
419
420 tcb_desc->bPacketBW = false;
421
422 if(!pHTInfo->bCurrentHTSupport||!pHTInfo->bEnableHT)
423 return;
424
425 if(tcb_desc->bMulticast || tcb_desc->bBroadcast)
426 return;
427
428 if((tcb_desc->data_rate & 0x80)==0) // If using legacy rate, it shall use 20MHz channel.
429 return;
430 //BandWidthAutoSwitch is for auto switch to 20 or 40 in long distance
431 if(pHTInfo->bCurBW40MHz && pHTInfo->bCurTxBW40MHz && !ieee->bandwidth_auto_switch.bforced_tx20Mhz)
432 tcb_desc->bPacketBW = true;
433 return;
434 }
435
436 void ieee80211_query_protectionmode(struct ieee80211_device* ieee, cb_desc* tcb_desc, struct sk_buff* skb)
437 {
438 // Common Settings
439 tcb_desc->bRTSSTBC = false;
440 tcb_desc->bRTSUseShortGI = false; // Since protection frames are always sent by legacy rate, ShortGI will never be used.
441 tcb_desc->bCTSEnable = false; // Most of protection using RTS/CTS
442 tcb_desc->RTSSC = 0; // 20MHz: Don't care; 40MHz: Duplicate.
443 tcb_desc->bRTSBW = false; // RTS frame bandwidth is always 20MHz
444
445 if(tcb_desc->bBroadcast || tcb_desc->bMulticast)//only unicast frame will use rts/cts
446 return;
447
448 if (is_broadcast_ether_addr(skb->data+16)) //check addr3 as infrastructure add3 is DA.
449 return;
450
451 if (ieee->mode < IEEE_N_24G) //b, g mode
452 {
453 // (1) RTS_Threshold is compared to the MPDU, not MSDU.
454 // (2) If there are more than one frag in this MSDU, only the first frag uses protection frame.
455 // Other fragments are protected by previous fragment.
456 // So we only need to check the length of first fragment.
457 if (skb->len > ieee->rts)
458 {
459 tcb_desc->bRTSEnable = true;
460 tcb_desc->rts_rate = MGN_24M;
461 }
462 else if (ieee->current_network.buseprotection)
463 {
464 // Use CTS-to-SELF in protection mode.
465 tcb_desc->bRTSEnable = true;
466 tcb_desc->bCTSEnable = true;
467 tcb_desc->rts_rate = MGN_24M;
468 }
469 //otherwise return;
470 return;
471 }
472 else
473 {// 11n High throughput case.
474 PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo;
475 while (true)
476 {
477 //check ERP protection
478 if (ieee->current_network.buseprotection)
479 {// CTS-to-SELF
480 tcb_desc->bRTSEnable = true;
481 tcb_desc->bCTSEnable = true;
482 tcb_desc->rts_rate = MGN_24M;
483 break;
484 }
485 //check HT op mode
486 if(pHTInfo->bCurrentHTSupport && pHTInfo->bEnableHT)
487 {
488 u8 HTOpMode = pHTInfo->CurrentOpMode;
489 if((pHTInfo->bCurBW40MHz && (HTOpMode == 2 || HTOpMode == 3)) ||
490 (!pHTInfo->bCurBW40MHz && HTOpMode == 3) )
491 {
492 tcb_desc->rts_rate = MGN_24M; // Rate is 24Mbps.
493 tcb_desc->bRTSEnable = true;
494 break;
495 }
496 }
497 //check rts
498 if (skb->len > ieee->rts)
499 {
500 tcb_desc->rts_rate = MGN_24M; // Rate is 24Mbps.
501 tcb_desc->bRTSEnable = true;
502 break;
503 }
504 //to do list: check MIMO power save condition.
505 //check AMPDU aggregation for TXOP
506 if(tcb_desc->bAMPDUEnable)
507 {
508 tcb_desc->rts_rate = MGN_24M; // Rate is 24Mbps.
509 // According to 8190 design, firmware sends CF-End only if RTS/CTS is enabled. However, it degrads
510 // throughput around 10M, so we disable of this mechanism. 2007.08.03 by Emily
511 tcb_desc->bRTSEnable = false;
512 break;
513 }
514 //check IOT action
515 if(pHTInfo->IOTAction & HT_IOT_ACT_FORCED_CTS2SELF)
516 {
517 tcb_desc->bCTSEnable = true;
518 tcb_desc->rts_rate = MGN_24M;
519 tcb_desc->bRTSEnable = true;
520 break;
521 }
522 // Totally no protection case!!
523 goto NO_PROTECTION;
524 }
525 }
526 // For test , CTS replace with RTS
527 if( 0 )
528 {
529 tcb_desc->bCTSEnable = true;
530 tcb_desc->rts_rate = MGN_24M;
531 tcb_desc->bRTSEnable = true;
532 }
533 if (ieee->current_network.capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
534 tcb_desc->bUseShortPreamble = true;
535 if (ieee->mode == IW_MODE_MASTER)
536 goto NO_PROTECTION;
537 return;
538 NO_PROTECTION:
539 tcb_desc->bRTSEnable = false;
540 tcb_desc->bCTSEnable = false;
541 tcb_desc->rts_rate = 0;
542 tcb_desc->RTSSC = 0;
543 tcb_desc->bRTSBW = false;
544 }
545
546
547 void ieee80211_txrate_selectmode(struct ieee80211_device* ieee, cb_desc* tcb_desc)
548 {
549 #ifdef TO_DO_LIST
550 if(!IsDataFrame(pFrame))
551 {
552 pTcb->bTxDisableRateFallBack = TRUE;
553 pTcb->bTxUseDriverAssingedRate = TRUE;
554 pTcb->RATRIndex = 7;
555 return;
556 }
557
558 if(pMgntInfo->ForcedDataRate!= 0)
559 {
560 pTcb->bTxDisableRateFallBack = TRUE;
561 pTcb->bTxUseDriverAssingedRate = TRUE;
562 return;
563 }
564 #endif
565 if(ieee->bTxDisableRateFallBack)
566 tcb_desc->bTxDisableRateFallBack = true;
567
568 if(ieee->bTxUseDriverAssingedRate)
569 tcb_desc->bTxUseDriverAssingedRate = true;
570 if(!tcb_desc->bTxDisableRateFallBack || !tcb_desc->bTxUseDriverAssingedRate)
571 {
572 if (ieee->iw_mode == IW_MODE_INFRA || ieee->iw_mode == IW_MODE_ADHOC)
573 tcb_desc->RATRIndex = 0;
574 }
575 }
576
577 void ieee80211_query_seqnum(struct ieee80211_device*ieee, struct sk_buff* skb, u8* dst)
578 {
579 if (is_multicast_ether_addr(dst) || is_broadcast_ether_addr(dst))
580 return;
581 if (IsQoSDataFrame(skb->data)) //we deal qos data only
582 {
583 PTX_TS_RECORD pTS = NULL;
584 if (!GetTs(ieee, (PTS_COMMON_INFO*)(&pTS), dst, skb->priority, TX_DIR, true))
585 {
586 return;
587 }
588 pTS->TxCurSeq = (pTS->TxCurSeq+1)%4096;
589 }
590 }
591
592 int ieee80211_xmit(struct sk_buff *skb, struct net_device *dev)
593 {
594 struct ieee80211_device *ieee = netdev_priv(dev);
595 struct ieee80211_txb *txb = NULL;
596 struct ieee80211_hdr_3addrqos *frag_hdr;
597 int i, bytes_per_frag, nr_frags, bytes_last_frag, frag_size;
598 unsigned long flags;
599 struct net_device_stats *stats = &ieee->stats;
600 int ether_type = 0, encrypt;
601 int bytes, fc, qos_ctl = 0, hdr_len;
602 struct sk_buff *skb_frag;
603 struct ieee80211_hdr_3addrqos header = { /* Ensure zero initialized */
604 .duration_id = 0,
605 .seq_ctl = 0,
606 .qos_ctl = 0
607 };
608 u8 dest[ETH_ALEN], src[ETH_ALEN];
609 int qos_actived = ieee->current_network.qos_data.active;
610
611 struct ieee80211_crypt_data* crypt;
612
613 cb_desc *tcb_desc;
614
615 spin_lock_irqsave(&ieee->lock, flags);
616
617 /* If there is no driver handler to take the TXB, dont' bother
618 * creating it... */
619 if ((!ieee->hard_start_xmit && !(ieee->softmac_features & IEEE_SOFTMAC_TX_QUEUE))||
620 ((!ieee->softmac_data_hard_start_xmit && (ieee->softmac_features & IEEE_SOFTMAC_TX_QUEUE)))) {
621 printk(KERN_WARNING "%s: No xmit handler.\n",
622 ieee->dev->name);
623 goto success;
624 }
625
626
627 if(likely(ieee->raw_tx == 0)){
628 if (unlikely(skb->len < SNAP_SIZE + sizeof(u16))) {
629 printk(KERN_WARNING "%s: skb too small (%d).\n",
630 ieee->dev->name, skb->len);
631 goto success;
632 }
633
634 memset(skb->cb, 0, sizeof(skb->cb));
635 ether_type = ntohs(((struct ethhdr *)skb->data)->h_proto);
636
637 crypt = ieee->crypt[ieee->tx_keyidx];
638
639 encrypt = !(ether_type == ETH_P_PAE && ieee->ieee802_1x) &&
640 ieee->host_encrypt && crypt && crypt->ops;
641
642 if (!encrypt && ieee->ieee802_1x &&
643 ieee->drop_unencrypted && ether_type != ETH_P_PAE) {
644 stats->tx_dropped++;
645 goto success;
646 }
647 #ifdef CONFIG_IEEE80211_DEBUG
648 if (crypt && !encrypt && ether_type == ETH_P_PAE) {
649 struct eapol *eap = (struct eapol *)(skb->data +
650 sizeof(struct ethhdr) - SNAP_SIZE - sizeof(u16));
651 IEEE80211_DEBUG_EAP("TX: IEEE 802.11 EAPOL frame: %s\n",
652 eap_get_type(eap->type));
653 }
654 #endif
655
656 /* Save source and destination addresses */
657 memcpy(&dest, skb->data, ETH_ALEN);
658 memcpy(&src, skb->data+ETH_ALEN, ETH_ALEN);
659
660 /* Advance the SKB to the start of the payload */
661 skb_pull(skb, sizeof(struct ethhdr));
662
663 /* Determine total amount of storage required for TXB packets */
664 bytes = skb->len + SNAP_SIZE + sizeof(u16);
665
666 if (encrypt)
667 fc = IEEE80211_FTYPE_DATA | IEEE80211_FCTL_WEP;
668 else
669
670 fc = IEEE80211_FTYPE_DATA;
671
672 //if(ieee->current_network.QoS_Enable)
673 if(qos_actived)
674 fc |= IEEE80211_STYPE_QOS_DATA;
675 else
676 fc |= IEEE80211_STYPE_DATA;
677
678 if (ieee->iw_mode == IW_MODE_INFRA) {
679 fc |= IEEE80211_FCTL_TODS;
680 /* To DS: Addr1 = BSSID, Addr2 = SA,
681 Addr3 = DA */
682 memcpy(&header.addr1, ieee->current_network.bssid, ETH_ALEN);
683 memcpy(&header.addr2, &src, ETH_ALEN);
684 memcpy(&header.addr3, &dest, ETH_ALEN);
685 } else if (ieee->iw_mode == IW_MODE_ADHOC) {
686 /* not From/To DS: Addr1 = DA, Addr2 = SA,
687 Addr3 = BSSID */
688 memcpy(&header.addr1, dest, ETH_ALEN);
689 memcpy(&header.addr2, src, ETH_ALEN);
690 memcpy(&header.addr3, ieee->current_network.bssid, ETH_ALEN);
691 }
692
693 header.frame_ctl = cpu_to_le16(fc);
694
695 /* Determine fragmentation size based on destination (multicast
696 * and broadcast are not fragmented) */
697 if (is_multicast_ether_addr(header.addr1) ||
698 is_broadcast_ether_addr(header.addr1)) {
699 frag_size = MAX_FRAG_THRESHOLD;
700 qos_ctl |= QOS_CTL_NOTCONTAIN_ACK;
701 }
702 else {
703 frag_size = ieee->fts;//default:392
704 qos_ctl = 0;
705 }
706
707 //if (ieee->current_network.QoS_Enable)
708 if(qos_actived)
709 {
710 hdr_len = IEEE80211_3ADDR_LEN + 2;
711
712 skb->priority = ieee80211_classify(skb, &ieee->current_network);
713 qos_ctl |= skb->priority; //set in the ieee80211_classify
714 header.qos_ctl = cpu_to_le16(qos_ctl & IEEE80211_QOS_TID);
715 } else {
716 hdr_len = IEEE80211_3ADDR_LEN;
717 }
718 /* Determine amount of payload per fragment. Regardless of if
719 * this stack is providing the full 802.11 header, one will
720 * eventually be affixed to this fragment -- so we must account for
721 * it when determining the amount of payload space. */
722 bytes_per_frag = frag_size - hdr_len;
723 if (ieee->config &
724 (CFG_IEEE80211_COMPUTE_FCS | CFG_IEEE80211_RESERVE_FCS))
725 bytes_per_frag -= IEEE80211_FCS_LEN;
726
727 /* Each fragment may need to have room for encryptiong pre/postfix */
728 if (encrypt)
729 bytes_per_frag -= crypt->ops->extra_prefix_len +
730 crypt->ops->extra_postfix_len;
731
732 /* Number of fragments is the total bytes_per_frag /
733 * payload_per_fragment */
734 nr_frags = bytes / bytes_per_frag;
735 bytes_last_frag = bytes % bytes_per_frag;
736 if (bytes_last_frag)
737 nr_frags++;
738 else
739 bytes_last_frag = bytes_per_frag;
740
741 /* When we allocate the TXB we allocate enough space for the reserve
742 * and full fragment bytes (bytes_per_frag doesn't include prefix,
743 * postfix, header, FCS, etc.) */
744 txb = ieee80211_alloc_txb(nr_frags, frag_size + ieee->tx_headroom, GFP_ATOMIC);
745 if (unlikely(!txb)) {
746 printk(KERN_WARNING "%s: Could not allocate TXB\n",
747 ieee->dev->name);
748 goto failed;
749 }
750 txb->encrypted = encrypt;
751 txb->payload_size = bytes;
752
753 //if (ieee->current_network.QoS_Enable)
754 if(qos_actived)
755 {
756 txb->queue_index = UP2AC(skb->priority);
757 } else {
758 txb->queue_index = WME_AC_BK;;
759 }
760
761
762
763 for (i = 0; i < nr_frags; i++) {
764 skb_frag = txb->fragments[i];
765 tcb_desc = (cb_desc *)(skb_frag->cb + MAX_DEV_ADDR_SIZE);
766 if(qos_actived){
767 skb_frag->priority = skb->priority;//UP2AC(skb->priority);
768 tcb_desc->queue_index = UP2AC(skb->priority);
769 } else {
770 skb_frag->priority = WME_AC_BK;
771 tcb_desc->queue_index = WME_AC_BK;
772 }
773 skb_reserve(skb_frag, ieee->tx_headroom);
774
775 if (encrypt){
776 if (ieee->hwsec_active)
777 tcb_desc->bHwSec = 1;
778 else
779 tcb_desc->bHwSec = 0;
780 skb_reserve(skb_frag, crypt->ops->extra_prefix_len);
781 }
782 else
783 {
784 tcb_desc->bHwSec = 0;
785 }
786 frag_hdr = (struct ieee80211_hdr_3addrqos *)skb_put(skb_frag, hdr_len);
787 memcpy(frag_hdr, &header, hdr_len);
788
789 /* If this is not the last fragment, then add the MOREFRAGS
790 * bit to the frame control */
791 if (i != nr_frags - 1) {
792 frag_hdr->frame_ctl = cpu_to_le16(
793 fc | IEEE80211_FCTL_MOREFRAGS);
794 bytes = bytes_per_frag;
795
796 } else {
797 /* The last fragment takes the remaining length */
798 bytes = bytes_last_frag;
799 }
800 //if(ieee->current_network.QoS_Enable)
801 if(qos_actived)
802 {
803 // add 1 only indicate to corresponding seq number control 2006/7/12
804 frag_hdr->seq_ctl = cpu_to_le16(ieee->seq_ctrl[UP2AC(skb->priority)+1]<<4 | i);
805 } else {
806 frag_hdr->seq_ctl = cpu_to_le16(ieee->seq_ctrl[0]<<4 | i);
807 }
808
809 /* Put a SNAP header on the first fragment */
810 if (i == 0) {
811 ieee80211_put_snap(
812 skb_put(skb_frag, SNAP_SIZE + sizeof(u16)),
813 ether_type);
814 bytes -= SNAP_SIZE + sizeof(u16);
815 }
816
817 memcpy(skb_put(skb_frag, bytes), skb->data, bytes);
818
819 /* Advance the SKB... */
820 skb_pull(skb, bytes);
821
822 /* Encryption routine will move the header forward in order
823 * to insert the IV between the header and the payload */
824 if (encrypt)
825 ieee80211_encrypt_fragment(ieee, skb_frag, hdr_len);
826 if (ieee->config &
827 (CFG_IEEE80211_COMPUTE_FCS | CFG_IEEE80211_RESERVE_FCS))
828 skb_put(skb_frag, 4);
829 }
830
831 if(qos_actived)
832 {
833 if (ieee->seq_ctrl[UP2AC(skb->priority) + 1] == 0xFFF)
834 ieee->seq_ctrl[UP2AC(skb->priority) + 1] = 0;
835 else
836 ieee->seq_ctrl[UP2AC(skb->priority) + 1]++;
837 } else {
838 if (ieee->seq_ctrl[0] == 0xFFF)
839 ieee->seq_ctrl[0] = 0;
840 else
841 ieee->seq_ctrl[0]++;
842 }
843 }else{
844 if (unlikely(skb->len < sizeof(struct ieee80211_hdr_3addr))) {
845 printk(KERN_WARNING "%s: skb too small (%d).\n",
846 ieee->dev->name, skb->len);
847 goto success;
848 }
849
850 txb = ieee80211_alloc_txb(1, skb->len, GFP_ATOMIC);
851 if(!txb){
852 printk(KERN_WARNING "%s: Could not allocate TXB\n",
853 ieee->dev->name);
854 goto failed;
855 }
856
857 txb->encrypted = 0;
858 txb->payload_size = skb->len;
859 memcpy(skb_put(txb->fragments[0],skb->len), skb->data, skb->len);
860 }
861
862 success:
863 //WB add to fill data tcb_desc here. only first fragment is considered, need to change, and you may remove to other place.
864 if (txb)
865 {
866 cb_desc *tcb_desc = (cb_desc *)(txb->fragments[0]->cb + MAX_DEV_ADDR_SIZE);
867 tcb_desc->bTxEnableFwCalcDur = 1;
868 if (is_multicast_ether_addr(header.addr1))
869 tcb_desc->bMulticast = 1;
870 if (is_broadcast_ether_addr(header.addr1))
871 tcb_desc->bBroadcast = 1;
872 ieee80211_txrate_selectmode(ieee, tcb_desc);
873 if ( tcb_desc->bMulticast || tcb_desc->bBroadcast)
874 tcb_desc->data_rate = ieee->basic_rate;
875 else
876 //tcb_desc->data_rate = CURRENT_RATE(ieee->current_network.mode, ieee->rate, ieee->HTCurrentOperaRate);
877 tcb_desc->data_rate = CURRENT_RATE(ieee->mode, ieee->rate, ieee->HTCurrentOperaRate);
878 ieee80211_qurey_ShortPreambleMode(ieee, tcb_desc);
879 ieee80211_tx_query_agg_cap(ieee, txb->fragments[0], tcb_desc);
880 ieee80211_query_HTCapShortGI(ieee, tcb_desc);
881 ieee80211_query_BandwidthMode(ieee, tcb_desc);
882 ieee80211_query_protectionmode(ieee, tcb_desc, txb->fragments[0]);
883 ieee80211_query_seqnum(ieee, txb->fragments[0], header.addr1);
884 // IEEE80211_DEBUG_DATA(IEEE80211_DL_DATA, txb->fragments[0]->data, txb->fragments[0]->len);
885 //IEEE80211_DEBUG_DATA(IEEE80211_DL_DATA, tcb_desc, sizeof(cb_desc));
886 }
887 spin_unlock_irqrestore(&ieee->lock, flags);
888 dev_kfree_skb_any(skb);
889 if (txb) {
890 if (ieee->softmac_features & IEEE_SOFTMAC_TX_QUEUE){
891 ieee80211_softmac_xmit(txb, ieee);
892 }else{
893 if ((*ieee->hard_start_xmit)(txb, dev) == 0) {
894 stats->tx_packets++;
895 stats->tx_bytes += txb->payload_size;
896 return 0;
897 }
898 ieee80211_txb_free(txb);
899 }
900 }
901
902 return 0;
903
904 failed:
905 spin_unlock_irqrestore(&ieee->lock, flags);
906 netif_stop_queue(dev);
907 stats->tx_errors++;
908 return 1;
909
910 }
911
912 EXPORT_SYMBOL(ieee80211_txb_free);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree