?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[linux-btrfs-devel.git] / drivers / staging / rtl8192e / rtllib_tx.c
blob44e8006bc1af1f81a284261f87632ccac549c46c
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/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/version.h>
50 #include <linux/wireless.h>
51 #include <linux/etherdevice.h>
52 #include <linux/uaccess.h>
53 #include <linux/if_vlan.h>
54
55 #include "rtllib.h"
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 inline int rtllib_put_snap(u8 *data, u16 h_proto)
158 {
159 struct rtllib_snap_hdr *snap;
160 u8 *oui;
161
162 snap = (struct rtllib_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 rtllib_encrypt_fragment(struct rtllib_device *ieee, struct sk_buff *frag,
181 int hdr_len)
182 {
183 struct rtllib_crypt_data *crypt = NULL;
184 int res;
185
186 crypt = ieee->crypt[ieee->tx_keyidx];
187
188 if (!(crypt && crypt->ops)) {
189 printk(KERN_INFO "=========>%s(), crypt is null\n", __func__);
190 return -1;
191 }
192 /* To encrypt, frame format is:
193 * IV (4 bytes), clear payload (including SNAP), ICV (4 bytes) */
194
195 /* Host-based IEEE 802.11 fragmentation for TX is not yet supported, so
196 * call both MSDU and MPDU encryption functions from here. */
197 atomic_inc(&crypt->refcnt);
198 res = 0;
199 if (crypt->ops->encrypt_msdu)
200 res = crypt->ops->encrypt_msdu(frag, hdr_len, crypt->priv);
201 if (res == 0 && crypt->ops->encrypt_mpdu)
202 res = crypt->ops->encrypt_mpdu(frag, hdr_len, crypt->priv);
203
204 atomic_dec(&crypt->refcnt);
205 if (res < 0) {
206 printk(KERN_INFO "%s: Encryption failed: len=%d.\n",
207 ieee->dev->name, frag->len);
208 ieee->ieee_stats.tx_discards++;
209 return -1;
210 }
211
212 return 0;
213 }
214
215
216 void rtllib_txb_free(struct rtllib_txb *txb)
217 {
218 if (unlikely(!txb))
219 return;
220 kfree(txb);
221 }
222
223 static struct rtllib_txb *rtllib_alloc_txb(int nr_frags, int txb_size,
224 gfp_t gfp_mask)
225 {
226 struct rtllib_txb *txb;
227 int i;
228 txb = kmalloc(sizeof(struct rtllib_txb) + (sizeof(u8 *) * nr_frags),
229 gfp_mask);
230 if (!txb)
231 return NULL;
232
233 memset(txb, 0, sizeof(struct rtllib_txb));
234 txb->nr_frags = nr_frags;
235 txb->frag_size = txb_size;
236
237 for (i = 0; i < nr_frags; i++) {
238 txb->fragments[i] = dev_alloc_skb(txb_size);
239 if (unlikely(!txb->fragments[i])) {
240 i--;
241 break;
242 }
243 memset(txb->fragments[i]->cb, 0, sizeof(txb->fragments[i]->cb));
244 }
245 if (unlikely(i != nr_frags)) {
246 while (i >= 0)
247 dev_kfree_skb_any(txb->fragments[i--]);
248 kfree(txb);
249 return NULL;
250 }
251 return txb;
252 }
253
254 static int rtllib_classify(struct sk_buff *skb, u8 bIsAmsdu)
255 {
256 struct ethhdr *eth;
257 struct iphdr *ip;
258
259 eth = (struct ethhdr *)skb->data;
260 if (eth->h_proto != htons(ETH_P_IP))
261 return 0;
262
263 RTLLIB_DEBUG_DATA(RTLLIB_DL_DATA, skb->data, skb->len);
264 ip = ip_hdr(skb);
265 switch (ip->tos & 0xfc) {
266 case 0x20:
267 return 2;
268 case 0x40:
269 return 1;
270 case 0x60:
271 return 3;
272 case 0x80:
273 return 4;
274 case 0xa0:
275 return 5;
276 case 0xc0:
277 return 6;
278 case 0xe0:
279 return 7;
280 default:
281 return 0;
282 }
283 }
284
285 static void rtllib_tx_query_agg_cap(struct rtllib_device *ieee,
286 struct sk_buff *skb,
287 struct cb_desc *tcb_desc)
288 {
289 struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;
290 struct tx_ts_record *pTxTs = NULL;
291 struct rtllib_hdr_1addr* hdr = (struct rtllib_hdr_1addr *)skb->data;
292
293 if (rtllib_act_scanning(ieee, false))
294 return;
295
296 if (!pHTInfo->bCurrentHTSupport || !pHTInfo->bEnableHT)
297 return;
298 if (!IsQoSDataFrame(skb->data))
299 return;
300 if (is_multicast_ether_addr(hdr->addr1) ||
301 is_broadcast_ether_addr(hdr->addr1))
302 return;
303
304 if (tcb_desc->bdhcp || ieee->CntAfterLink < 2)
305 return;
306
307 if (pHTInfo->IOTAction & HT_IOT_ACT_TX_NO_AGGREGATION)
308 return;
309
310 if (!ieee->GetNmodeSupportBySecCfg(ieee->dev))
311 return;
312 if (pHTInfo->bCurrentAMPDUEnable) {
313 if (!GetTs(ieee, (struct ts_common_info **)(&pTxTs), hdr->addr1,
314 skb->priority, TX_DIR, true)) {
315 printk(KERN_INFO "%s: can't get TS\n", __func__);
316 return;
317 }
318 if (pTxTs->TxAdmittedBARecord.bValid == false) {
319 if (ieee->wpa_ie_len && (ieee->pairwise_key_type ==
320 KEY_TYPE_NA)) {
321 ;
322 } else if (tcb_desc->bdhcp == 1) {
323 ;
324 } else if (!pTxTs->bDisable_AddBa) {
325 TsStartAddBaProcess(ieee, pTxTs);
326 }
327 goto FORCED_AGG_SETTING;
328 } else if (pTxTs->bUsingBa == false) {
329 if (SN_LESS(pTxTs->TxAdmittedBARecord.BaStartSeqCtrl.field.SeqNum,
330 (pTxTs->TxCurSeq+1)%4096))
331 pTxTs->bUsingBa = true;
332 else
333 goto FORCED_AGG_SETTING;
334 }
335 if (ieee->iw_mode == IW_MODE_INFRA) {
336 tcb_desc->bAMPDUEnable = true;
337 tcb_desc->ampdu_factor = pHTInfo->CurrentAMPDUFactor;
338 tcb_desc->ampdu_density = pHTInfo->CurrentMPDUDensity;
339 }
340 }
341 FORCED_AGG_SETTING:
342 switch (pHTInfo->ForcedAMPDUMode) {
343 case HT_AGG_AUTO:
344 break;
345
346 case HT_AGG_FORCE_ENABLE:
347 tcb_desc->bAMPDUEnable = true;
348 tcb_desc->ampdu_density = pHTInfo->ForcedMPDUDensity;
349 tcb_desc->ampdu_factor = pHTInfo->ForcedAMPDUFactor;
350 break;
351
352 case HT_AGG_FORCE_DISABLE:
353 tcb_desc->bAMPDUEnable = false;
354 tcb_desc->ampdu_density = 0;
355 tcb_desc->ampdu_factor = 0;
356 break;
357 }
358 return;
359 }
360
361 static void rtllib_qurey_ShortPreambleMode(struct rtllib_device *ieee,
362 struct cb_desc *tcb_desc)
363 {
364 tcb_desc->bUseShortPreamble = false;
365 if (tcb_desc->data_rate == 2)
366 return;
367 else if (ieee->current_network.capability &
368 WLAN_CAPABILITY_SHORT_PREAMBLE)
369 tcb_desc->bUseShortPreamble = true;
370 return;
371 }
372
373 static void rtllib_query_HTCapShortGI(struct rtllib_device *ieee,
374 struct cb_desc *tcb_desc)
375 {
376 struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;
377
378 tcb_desc->bUseShortGI = false;
379
380 if (!pHTInfo->bCurrentHTSupport || !pHTInfo->bEnableHT)
381 return;
382
383 if (pHTInfo->bForcedShortGI) {
384 tcb_desc->bUseShortGI = true;
385 return;
386 }
387
388 if ((pHTInfo->bCurBW40MHz == true) && pHTInfo->bCurShortGI40MHz)
389 tcb_desc->bUseShortGI = true;
390 else if ((pHTInfo->bCurBW40MHz == false) && pHTInfo->bCurShortGI20MHz)
391 tcb_desc->bUseShortGI = true;
392 }
393
394 static void rtllib_query_BandwidthMode(struct rtllib_device *ieee,
395 struct cb_desc *tcb_desc)
396 {
397 struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;
398
399 tcb_desc->bPacketBW = false;
400
401 if (!pHTInfo->bCurrentHTSupport || !pHTInfo->bEnableHT)
402 return;
403
404 if (tcb_desc->bMulticast || tcb_desc->bBroadcast)
405 return;
406
407 if ((tcb_desc->data_rate & 0x80) == 0)
408 return;
409 if (pHTInfo->bCurBW40MHz && pHTInfo->bCurTxBW40MHz &&
410 !ieee->bandwidth_auto_switch.bforced_tx20Mhz)
411 tcb_desc->bPacketBW = true;
412 return;
413 }
414
415 static void rtllib_query_protectionmode(struct rtllib_device *ieee,
416 struct cb_desc *tcb_desc,
417 struct sk_buff *skb)
418 {
419 tcb_desc->bRTSSTBC = false;
420 tcb_desc->bRTSUseShortGI = false;
421 tcb_desc->bCTSEnable = false;
422 tcb_desc->RTSSC = 0;
423 tcb_desc->bRTSBW = false;
424
425 if (tcb_desc->bBroadcast || tcb_desc->bMulticast)
426 return;
427
428 if (is_broadcast_ether_addr(skb->data+16))
429 return;
430
431 if (ieee->mode < IEEE_N_24G) {
432 if (skb->len > ieee->rts) {
433 tcb_desc->bRTSEnable = true;
434 tcb_desc->rts_rate = MGN_24M;
435 } else if (ieee->current_network.buseprotection) {
436 tcb_desc->bRTSEnable = true;
437 tcb_desc->bCTSEnable = true;
438 tcb_desc->rts_rate = MGN_24M;
439 }
440 return;
441 } else {
442 struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;
443 while (true) {
444 if (pHTInfo->IOTAction & HT_IOT_ACT_FORCED_CTS2SELF) {
445 tcb_desc->bCTSEnable = true;
446 tcb_desc->rts_rate = MGN_24M;
447 tcb_desc->bRTSEnable = true;
448 break;
449 } else if (pHTInfo->IOTAction & (HT_IOT_ACT_FORCED_RTS |
450 HT_IOT_ACT_PURE_N_MODE)) {
451 tcb_desc->bRTSEnable = true;
452 tcb_desc->rts_rate = MGN_24M;
453 break;
454 }
455 if (ieee->current_network.buseprotection) {
456 tcb_desc->bRTSEnable = true;
457 tcb_desc->bCTSEnable = true;
458 tcb_desc->rts_rate = MGN_24M;
459 break;
460 }
461 if (pHTInfo->bCurrentHTSupport && pHTInfo->bEnableHT) {
462 u8 HTOpMode = pHTInfo->CurrentOpMode;
463 if ((pHTInfo->bCurBW40MHz && (HTOpMode == 2 ||
464 HTOpMode == 3)) ||
465 (!pHTInfo->bCurBW40MHz && HTOpMode == 3)) {
466 tcb_desc->rts_rate = MGN_24M;
467 tcb_desc->bRTSEnable = true;
468 break;
469 }
470 }
471 if (skb->len > ieee->rts) {
472 tcb_desc->rts_rate = MGN_24M;
473 tcb_desc->bRTSEnable = true;
474 break;
475 }
476 if (tcb_desc->bAMPDUEnable) {
477 tcb_desc->rts_rate = MGN_24M;
478 tcb_desc->bRTSEnable = false;
479 break;
480 }
481 goto NO_PROTECTION;
482 }
483 }
484 if (ieee->current_network.capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
485 tcb_desc->bUseShortPreamble = true;
486 if (ieee->iw_mode == IW_MODE_MASTER)
487 goto NO_PROTECTION;
488 return;
489 NO_PROTECTION:
490 tcb_desc->bRTSEnable = false;
491 tcb_desc->bCTSEnable = false;
492 tcb_desc->rts_rate = 0;
493 tcb_desc->RTSSC = 0;
494 tcb_desc->bRTSBW = false;
495 }
496
497
498 static void rtllib_txrate_selectmode(struct rtllib_device *ieee,
499 struct cb_desc *tcb_desc)
500 {
501 if (ieee->bTxDisableRateFallBack)
502 tcb_desc->bTxDisableRateFallBack = true;
503
504 if (ieee->bTxUseDriverAssingedRate)
505 tcb_desc->bTxUseDriverAssingedRate = true;
506 if (!tcb_desc->bTxDisableRateFallBack ||
507 !tcb_desc->bTxUseDriverAssingedRate) {
508 if (ieee->iw_mode == IW_MODE_INFRA ||
509 ieee->iw_mode == IW_MODE_ADHOC)
510 tcb_desc->RATRIndex = 0;
511 }
512 }
513
514 u16 rtllib_query_seqnum(struct rtllib_device *ieee, struct sk_buff *skb,
515 u8 *dst)
516 {
517 u16 seqnum = 0;
518
519 if (is_multicast_ether_addr(dst) || is_broadcast_ether_addr(dst))
520 return 0;
521 if (IsQoSDataFrame(skb->data)) {
522 struct tx_ts_record *pTS = NULL;
523 if (!GetTs(ieee, (struct ts_common_info **)(&pTS), dst,
524 skb->priority, TX_DIR, true))
525 return 0;
526 seqnum = pTS->TxCurSeq;
527 pTS->TxCurSeq = (pTS->TxCurSeq+1)%4096;
528 return seqnum;
529 }
530 return 0;
531 }
532
533 static int wme_downgrade_ac(struct sk_buff *skb)
534 {
535 switch (skb->priority) {
536 case 6:
537 case 7:
538 skb->priority = 5; /* VO -> VI */
539 return 0;
540 case 4:
541 case 5:
542 skb->priority = 3; /* VI -> BE */
543 return 0;
544 case 0:
545 case 3:
546 skb->priority = 1; /* BE -> BK */
547 return 0;
548 default:
549 return -1;
550 }
551 }
552
553 int rtllib_xmit_inter(struct sk_buff *skb, struct net_device *dev)
554 {
555 struct rtllib_device *ieee = (struct rtllib_device *)
556 netdev_priv_rsl(dev);
557 struct rtllib_txb *txb = NULL;
558 struct rtllib_hdr_3addrqos *frag_hdr;
559 int i, bytes_per_frag, nr_frags, bytes_last_frag, frag_size;
560 unsigned long flags;
561 struct net_device_stats *stats = &ieee->stats;
562 int ether_type = 0, encrypt;
563 int bytes, fc, qos_ctl = 0, hdr_len;
564 struct sk_buff *skb_frag;
565 struct rtllib_hdr_3addrqos header = { /* Ensure zero initialized */
566 .duration_id = 0,
567 .seq_ctl = 0,
568 .qos_ctl = 0
569 };
570 u8 dest[ETH_ALEN], src[ETH_ALEN];
571 int qos_actived = ieee->current_network.qos_data.active;
572 struct rtllib_crypt_data *crypt = NULL;
573 struct cb_desc *tcb_desc;
574 u8 bIsMulticast = false;
575 u8 IsAmsdu = false;
576 bool bdhcp = false;
577
578 spin_lock_irqsave(&ieee->lock, flags);
579
580 /* If there is no driver handler to take the TXB, dont' bother
581 * creating it... */
582 if ((!ieee->hard_start_xmit && !(ieee->softmac_features &
583 IEEE_SOFTMAC_TX_QUEUE)) ||
584 ((!ieee->softmac_data_hard_start_xmit &&
585 (ieee->softmac_features & IEEE_SOFTMAC_TX_QUEUE)))) {
586 printk(KERN_WARNING "%s: No xmit handler.\n",
587 ieee->dev->name);
588 goto success;
589 }
590
591
592 if (likely(ieee->raw_tx == 0)) {
593 if (unlikely(skb->len < SNAP_SIZE + sizeof(u16))) {
594 printk(KERN_WARNING "%s: skb too small (%d).\n",
595 ieee->dev->name, skb->len);
596 goto success;
597 }
598 /* Save source and destination addresses */
599 memcpy(dest, skb->data, ETH_ALEN);
600 memcpy(src, skb->data+ETH_ALEN, ETH_ALEN);
601
602 memset(skb->cb, 0, sizeof(skb->cb));
603 ether_type = ntohs(((struct ethhdr *)skb->data)->h_proto);
604
605 if (ieee->iw_mode == IW_MODE_MONITOR) {
606 txb = rtllib_alloc_txb(1, skb->len, GFP_ATOMIC);
607 if (unlikely(!txb)) {
608 printk(KERN_WARNING "%s: Could not allocate "
609 "TXB\n",
610 ieee->dev->name);
611 goto failed;
612 }
613
614 txb->encrypted = 0;
615 txb->payload_size = skb->len;
616 memcpy(skb_put(txb->fragments[0], skb->len), skb->data,
617 skb->len);
618
619 goto success;
620 }
621
622 if (skb->len > 282) {
623 if (ETH_P_IP == ether_type) {
624 const struct iphdr *ip = (struct iphdr *)
625 ((u8 *)skb->data+14);
626 if (IPPROTO_UDP == ip->protocol) {
627 struct udphdr *udp;
628
629 udp = (struct udphdr *)((u8 *)ip +
630 (ip->ihl << 2));
631 if (((((u8 *)udp)[1] == 68) &&
632 (((u8 *)udp)[3] == 67)) ||
633 ((((u8 *)udp)[1] == 67) &&
634 (((u8 *)udp)[3] == 68))) {
635 bdhcp = true;
636 ieee->LPSDelayCnt = 200;
637 }
638 }
639 } else if (ETH_P_ARP == ether_type) {
640 printk(KERN_INFO "=================>DHCP "
641 "Protocol start tx ARP pkt!!\n");
642 bdhcp = true;
643 ieee->LPSDelayCnt =
644 ieee->current_network.tim.tim_count;
645 }
646 }
647
648 skb->priority = rtllib_classify(skb, IsAmsdu);
649 crypt = ieee->crypt[ieee->tx_keyidx];
650 encrypt = !(ether_type == ETH_P_PAE && ieee->ieee802_1x) &&
651 ieee->host_encrypt && crypt && crypt->ops;
652 if (!encrypt && ieee->ieee802_1x &&
653 ieee->drop_unencrypted && ether_type != ETH_P_PAE) {
654 stats->tx_dropped++;
655 goto success;
656 }
657 if (crypt && !encrypt && ether_type == ETH_P_PAE) {
658 struct eapol *eap = (struct eapol *)(skb->data +
659 sizeof(struct ethhdr) - SNAP_SIZE -
660 sizeof(u16));
661 RTLLIB_DEBUG_EAP("TX: IEEE 802.11 EAPOL frame: %s\n",
662 eap_get_type(eap->type));
663 }
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 = RTLLIB_FTYPE_DATA | RTLLIB_FCTL_WEP;
673 else
674 fc = RTLLIB_FTYPE_DATA;
675
676 if (qos_actived)
677 fc |= RTLLIB_STYPE_QOS_DATA;
678 else
679 fc |= RTLLIB_STYPE_DATA;
680
681 if (ieee->iw_mode == IW_MODE_INFRA) {
682 fc |= RTLLIB_FCTL_TODS;
683 /* To DS: Addr1 = BSSID, Addr2 = SA,
684 Addr3 = DA */
685 memcpy(&header.addr1, ieee->current_network.bssid,
686 ETH_ALEN);
687 memcpy(&header.addr2, &src, ETH_ALEN);
688 if (IsAmsdu)
689 memcpy(&header.addr3,
690 ieee->current_network.bssid, ETH_ALEN);
691 else
692 memcpy(&header.addr3, &dest, ETH_ALEN);
693 } else if (ieee->iw_mode == IW_MODE_ADHOC) {
694 /* not From/To DS: Addr1 = DA, Addr2 = SA,
695 Addr3 = BSSID */
696 memcpy(&header.addr1, dest, ETH_ALEN);
697 memcpy(&header.addr2, src, ETH_ALEN);
698 memcpy(&header.addr3, ieee->current_network.bssid,
699 ETH_ALEN);
700 }
701
702 bIsMulticast = is_broadcast_ether_addr(header.addr1) ||
703 is_multicast_ether_addr(header.addr1);
704
705 header.frame_ctl = cpu_to_le16(fc);
706
707 /* Determine fragmentation size based on destination (multicast
708 * and broadcast are not fragmented) */
709 if (bIsMulticast) {
710 frag_size = MAX_FRAG_THRESHOLD;
711 qos_ctl |= QOS_CTL_NOTCONTAIN_ACK;
712 } else {
713 frag_size = ieee->fts;
714 qos_ctl = 0;
715 }
716
717 if (qos_actived) {
718 hdr_len = RTLLIB_3ADDR_LEN + 2;
719
720 /* in case we are a client verify acm is not set for this ac */
721 while (unlikely(ieee->wmm_acm & (0x01 << skb->priority))) {
722 printk(KERN_INFO "skb->priority = %x\n", skb->priority);
723 if (wme_downgrade_ac(skb))
724 break;
725 printk(KERN_INFO "converted skb->priority = %x\n",
726 skb->priority);
727 }
728 qos_ctl |= skb->priority;
729 header.qos_ctl = cpu_to_le16(qos_ctl & RTLLIB_QOS_TID);
730 } else {
731 hdr_len = RTLLIB_3ADDR_LEN;
732 }
733 /* Determine amount of payload per fragment. Regardless of if
734 * this stack is providing the full 802.11 header, one will
735 * eventually be affixed to this fragment -- so we must account
736 * for it when determining the amount of payload space. */
737 bytes_per_frag = frag_size - hdr_len;
738 if (ieee->config &
739 (CFG_RTLLIB_COMPUTE_FCS | CFG_RTLLIB_RESERVE_FCS))
740 bytes_per_frag -= RTLLIB_FCS_LEN;
741
742 /* Each fragment may need to have room for encryptiong
743 * pre/postfix */
744 if (encrypt) {
745 bytes_per_frag -= crypt->ops->extra_prefix_len +
746 crypt->ops->extra_postfix_len;
747 }
748 /* Number of fragments is the total bytes_per_frag /
749 * payload_per_fragment */
750 nr_frags = bytes / bytes_per_frag;
751 bytes_last_frag = bytes % bytes_per_frag;
752 if (bytes_last_frag)
753 nr_frags++;
754 else
755 bytes_last_frag = bytes_per_frag;
756
757 /* When we allocate the TXB we allocate enough space for the
758 * reserve and full fragment bytes (bytes_per_frag doesn't
759 * include prefix, postfix, header, FCS, etc.) */
760 txb = rtllib_alloc_txb(nr_frags, frag_size +
761 ieee->tx_headroom, GFP_ATOMIC);
762 if (unlikely(!txb)) {
763 printk(KERN_WARNING "%s: Could not allocate TXB\n",
764 ieee->dev->name);
765 goto failed;
766 }
767 txb->encrypted = encrypt;
768 txb->payload_size = bytes;
769
770 if (qos_actived)
771 txb->queue_index = UP2AC(skb->priority);
772 else
773 txb->queue_index = WME_AC_BE;
774
775 for (i = 0; i < nr_frags; i++) {
776 skb_frag = txb->fragments[i];
777 tcb_desc = (struct cb_desc *)(skb_frag->cb +
778 MAX_DEV_ADDR_SIZE);
779 if (qos_actived) {
780 skb_frag->priority = skb->priority;
781 tcb_desc->queue_index = UP2AC(skb->priority);
782 } else {
783 skb_frag->priority = WME_AC_BE;
784 tcb_desc->queue_index = WME_AC_BE;
785 }
786 skb_reserve(skb_frag, ieee->tx_headroom);
787
788 if (encrypt) {
789 if (ieee->hwsec_active)
790 tcb_desc->bHwSec = 1;
791 else
792 tcb_desc->bHwSec = 0;
793 skb_reserve(skb_frag,
794 crypt->ops->extra_prefix_len);
795 } else {
796 tcb_desc->bHwSec = 0;
797 }
798 frag_hdr = (struct rtllib_hdr_3addrqos *)
799 skb_put(skb_frag, hdr_len);
800 memcpy(frag_hdr, &header, hdr_len);
801
802 /* If this is not the last fragment, then add the
803 * MOREFRAGS bit to the frame control */
804 if (i != nr_frags - 1) {
805 frag_hdr->frame_ctl = cpu_to_le16(
806 fc | RTLLIB_FCTL_MOREFRAGS);
807 bytes = bytes_per_frag;
808
809 } else {
810 /* The last fragment has the remaining length */
811 bytes = bytes_last_frag;
812 }
813 if ((qos_actived) && (!bIsMulticast)) {
814 frag_hdr->seq_ctl =
815 rtllib_query_seqnum(ieee, skb_frag,
816 header.addr1);
817 frag_hdr->seq_ctl =
818 cpu_to_le16(frag_hdr->seq_ctl<<4 | i);
819 } else {
820 frag_hdr->seq_ctl =
821 cpu_to_le16(ieee->seq_ctrl[0]<<4 | i);
822 }
823 /* Put a SNAP header on the first fragment */
824 if (i == 0) {
825 rtllib_put_snap(
826 skb_put(skb_frag, SNAP_SIZE +
827 sizeof(u16)), ether_type);
828 bytes -= SNAP_SIZE + sizeof(u16);
829 }
830
831 memcpy(skb_put(skb_frag, bytes), skb->data, bytes);
832
833 /* Advance the SKB... */
834 skb_pull(skb, bytes);
835
836 /* Encryption routine will move the header forward in
837 * order to insert the IV between the header and the
838 * payload */
839 if (encrypt)
840 rtllib_encrypt_fragment(ieee, skb_frag,
841 hdr_len);
842 if (ieee->config &
843 (CFG_RTLLIB_COMPUTE_FCS | CFG_RTLLIB_RESERVE_FCS))
844 skb_put(skb_frag, 4);
845 }
846
847 if ((qos_actived) && (!bIsMulticast)) {
848 if (ieee->seq_ctrl[UP2AC(skb->priority) + 1] == 0xFFF)
849 ieee->seq_ctrl[UP2AC(skb->priority) + 1] = 0;
850 else
851 ieee->seq_ctrl[UP2AC(skb->priority) + 1]++;
852 } else {
853 if (ieee->seq_ctrl[0] == 0xFFF)
854 ieee->seq_ctrl[0] = 0;
855 else
856 ieee->seq_ctrl[0]++;
857 }
858 } else {
859 if (unlikely(skb->len < sizeof(struct rtllib_hdr_3addr))) {
860 printk(KERN_WARNING "%s: skb too small (%d).\n",
861 ieee->dev->name, skb->len);
862 goto success;
863 }
864
865 txb = rtllib_alloc_txb(1, skb->len, GFP_ATOMIC);
866 if (!txb) {
867 printk(KERN_WARNING "%s: Could not allocate TXB\n",
868 ieee->dev->name);
869 goto failed;
870 }
871
872 txb->encrypted = 0;
873 txb->payload_size = skb->len;
874 memcpy(skb_put(txb->fragments[0], skb->len), skb->data,
875 skb->len);
876 }
877
878 success:
879 if (txb) {
880 struct cb_desc *tcb_desc = (struct cb_desc *)
881 (txb->fragments[0]->cb + MAX_DEV_ADDR_SIZE);
882 tcb_desc->bTxEnableFwCalcDur = 1;
883 tcb_desc->priority = skb->priority;
884
885 if (ether_type == ETH_P_PAE) {
886 if (ieee->pHTInfo->IOTAction &
887 HT_IOT_ACT_WA_IOT_Broadcom) {
888 tcb_desc->data_rate =
889 MgntQuery_TxRateExcludeCCKRates(ieee);
890 tcb_desc->bTxDisableRateFallBack = false;
891 } else {
892 tcb_desc->data_rate = ieee->basic_rate;
893 tcb_desc->bTxDisableRateFallBack = 1;
894 }
895
896
897 tcb_desc->RATRIndex = 7;
898 tcb_desc->bTxUseDriverAssingedRate = 1;
899 } else {
900 if (is_multicast_ether_addr(header.addr1))
901 tcb_desc->bMulticast = 1;
902 if (is_broadcast_ether_addr(header.addr1))
903 tcb_desc->bBroadcast = 1;
904 rtllib_txrate_selectmode(ieee, tcb_desc);
905 if (tcb_desc->bMulticast || tcb_desc->bBroadcast)
906 tcb_desc->data_rate = ieee->basic_rate;
907 else
908 tcb_desc->data_rate = CURRENT_RATE(ieee->mode,
909 ieee->rate, ieee->HTCurrentOperaRate);
910
911 if (bdhcp == true) {
912 if (ieee->pHTInfo->IOTAction &
913 HT_IOT_ACT_WA_IOT_Broadcom) {
914 tcb_desc->data_rate =
915 MgntQuery_TxRateExcludeCCKRates(ieee);
916 tcb_desc->bTxDisableRateFallBack = false;
917 } else {
918 tcb_desc->data_rate = MGN_1M;
919 tcb_desc->bTxDisableRateFallBack = 1;
920 }
921
922
923 tcb_desc->RATRIndex = 7;
924 tcb_desc->bTxUseDriverAssingedRate = 1;
925 tcb_desc->bdhcp = 1;
926 }
927
928 rtllib_qurey_ShortPreambleMode(ieee, tcb_desc);
929 rtllib_tx_query_agg_cap(ieee, txb->fragments[0],
930 tcb_desc);
931 rtllib_query_HTCapShortGI(ieee, tcb_desc);
932 rtllib_query_BandwidthMode(ieee, tcb_desc);
933 rtllib_query_protectionmode(ieee, tcb_desc,
934 txb->fragments[0]);
935 }
936 }
937 spin_unlock_irqrestore(&ieee->lock, flags);
938 dev_kfree_skb_any(skb);
939 if (txb) {
940 if (ieee->softmac_features & IEEE_SOFTMAC_TX_QUEUE) {
941 dev->stats.tx_packets++;
942 dev->stats.tx_bytes += txb->payload_size;
943 rtllib_softmac_xmit(txb, ieee);
944 } else {
945 if ((*ieee->hard_start_xmit)(txb, dev) == 0) {
946 stats->tx_packets++;
947 stats->tx_bytes += txb->payload_size;
948 return 0;
949 }
950 rtllib_txb_free(txb);
951 }
952 }
953
954 return 0;
955
956 failed:
957 spin_unlock_irqrestore(&ieee->lock, flags);
958 netif_stop_queue(dev);
959 stats->tx_errors++;
960 return 1;
961
962 }
963 int rtllib_xmit(struct sk_buff *skb, struct net_device *dev)
964 {
965 memset(skb->cb, 0, sizeof(skb->cb));
966 return rtllib_xmit_inter(skb, dev);
967 }
Linux Btrfs Development