drivers/staging/rtl8192e/rtllib_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 <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/wireless.h>
  50 #include <linux/etherdevice.h>
  51 #include <linux/uaccess.h>
  52 #include <linux/if_vlan.h>
  53
  54 #include "rtllib.h"
  55
  56 /*
  57
  58
  59 802.11 Data Frame
  60
  61
  62 802.11 frame_control for data frames - 2 bytes
  63      ,-----------------------------------------------------------------------------------------.
  64 bits | 0  |  1  |  2  |  3  |  4  |  5  |  6  |  7  |  8  |  9  |  a  |  b  |  c  |  d  |  e   |
  65      |----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|------|
  66 val  | 0  |  0  |  0  |  1  |  x  |  0  |  0  |  0  |  1  |  0  |  x  |  x  |  x  |  x  |  x   |
  67      |----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|------|
  68 desc | ^-ver-^  |  ^type-^  |  ^-----subtype-----^  | to  |from |more |retry| pwr |more |wep   |
  69      |    |        | x=0 data,x=1 data+ack | DS  | DS  |frag |     | mgm |data |      |
  70      '-----------------------------------------------------------------------------------------'
  71                                                     /\
  72                                                     |
  73 802.11 Data Frame                                  |
  74            ,--------- 'ctrl' expands to >-----------'
  75           |
  76       ,--'---,-------------------------------------------------------------.
  77 Bytes |  2   |  2   |    6    |    6    |    6    |  2   | 0..2312 |   4  |
  78       |------|------|---------|---------|---------|------|---------|------|
  79 Desc. | ctrl | dura |  DA/RA  |   TA    |    SA   | Sequ |  Frame  |  fcs |
  80       |      | tion | (BSSID) |  |       | ence |  data   |      |
  81       `--------------------------------------------------|       |------'
  82 Total: 28 non-data bytes                                 `----.----'
  83                                                               |
  84        .- 'Frame data' expands to <---------------------------'
  85        |
  86        V
  87       ,---------------------------------------------------.
  88 Bytes |  1   |  1   |    1    |    3     |  2   |  0-2304 |
  89       |------|------|---------|----------|------|---------|
  90 Desc. | SNAP | SNAP | Control |Eth Tunnel| Type | IP      |
  91       | DSAP | SSAP |    |        |      | Packet  |
  92       | 0xAA | 0xAA |0x03 (UI)|0x00-00-F8|      |        |
  93       `-----------------------------------------|        |
  94 Total: 8 non-data bytes                  `----.----'
  95                                                      |
  96        .- 'IP Packet' expands, if WEP enabled, to <--'
  97        |
  98        V
  99       ,-----------------------.
 100 Bytes |  4  |   0-2296  |  4  |
 101       |-----|-----------|-----|
 102 Desc. | IV  | Encrypted | ICV |
 103       |     | IP Packet |     |
 104       `-----------------------'
 105 Total: 8 non-data bytes
 106
 107
 108 802.3 Ethernet Data Frame
 109
 110       ,-----------------------------------------.
 111 Bytes |   6   |   6   |  2   |  Variable |   4  |
 112       |-------|-------|------|-----------|------|
 113 Desc. | Dest. | Source| Type | IP Packet |  fcs |
 114       |  MAC  |  MAC  |      |     |      |
 115       `-----------------------------------------'
 116 Total: 18 non-data bytes
 117
 118 In the event that fragmentation is required, the incoming payload is split into
 119 N parts of size ieee->fts.  The first fragment contains the SNAP header and the
 120 remaining packets are just data.
 121
 122 If encryption is enabled, each fragment payload size is reduced by enough space
 123 to add the prefix and postfix (IV and ICV totalling 8 bytes in the case of WEP)
 124 So if you have 1500 bytes of payload with ieee->fts set to 500 without
 125 encryption it will take 3 frames.  With WEP it will take 4 frames as the
 126 payload of each frame is reduced to 492 bytes.
 127
 128 * SKB visualization
 129 *
 130 *  ,- skb->data
 131 * |
 132 * |    ETHERNET HEADER  ,-<-- PAYLOAD
 133 * |                        |     14 bytes from skb->data
 134 * |  2 bytes for Type --> ,T. |     (sizeof ethhdr)
 135 * |                    | | |
 136 * |,-Dest.--. ,--Src.---. | | |
 137 * |  6 bytes| | 6 bytes | | | |
 138 * v      | |     | | | |
 139 * 0      | v       1 | v | v       2
 140 * 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
 141 *     ^     | ^  | ^ |
 142 *     |     | |  | | |
 143 *     |     | |  | `T' <---- 2 bytes for Type
 144 *     |     | |  |
 145 *     |     | '---SNAP--' <-------- 6 bytes for SNAP
 146 *     |     |
 147 *     `-IV--' <-------------------- 4 bytes for IV (WEP)
 148 *
 149 *      SNAP HEADER
 150 *
 151 */
 152
 153 static u8 P802_1H_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0xf8 };
 154 static u8 RFC1042_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0x00 };
 155
 156 inline int rtllib_put_snap(u8 *data, u16 h_proto)
 157 {
 158         struct rtllib_snap_hdr *snap;
 159         u8 *oui;
 160
 161         snap = (struct rtllib_snap_hdr *)data;
 162         snap->dsap = 0xaa;
 163         snap->ssap = 0xaa;
 164         snap->ctrl = 0x03;
 165
 166         if (h_proto == 0x8137 || h_proto == 0x80f3)
 167                 oui = P802_1H_OUI;
 168         else
 169                 oui = RFC1042_OUI;
 170         snap->oui[0] = oui[0];
 171         snap->oui[1] = oui[1];
 172         snap->oui[2] = oui[2];
 173
 174         *(u16 *)(data + SNAP_SIZE) = htons(h_proto);
 175
 176         return SNAP_SIZE + sizeof(u16);
 177 }
 178
 179 int rtllib_encrypt_fragment(struct rtllib_device *ieee, struct sk_buff *frag,
 180                             int hdr_len)
 181 {
 182         struct lib80211_crypt_data *crypt = NULL;
 183         int res;
 184
 185         crypt = ieee->crypt_info.crypt[ieee->crypt_info.tx_keyidx];
 186
 187         if (!(crypt && crypt->ops)) {
 188                 printk(KERN_INFO "=========>%s(), crypt is null\n", __func__);
 189                 return -1;
 190         }
 191         /* To encrypt, frame format is:
 192          * IV (4 bytes), clear payload (including SNAP), ICV (4 bytes) */
 193
 194         /* Host-based IEEE 802.11 fragmentation for TX is not yet supported, so
 195          * call both MSDU and MPDU encryption functions from here. */
 196         atomic_inc(&crypt->refcnt);
 197         res = 0;
 198         if (crypt->ops->encrypt_msdu)
 199                 res = crypt->ops->encrypt_msdu(frag, hdr_len, crypt->priv);
 200         if (res == 0 && crypt->ops->encrypt_mpdu)
 201                 res = crypt->ops->encrypt_mpdu(frag, hdr_len, crypt->priv);
 202
 203         atomic_dec(&crypt->refcnt);
 204         if (res < 0) {
 205                 printk(KERN_INFO "%s: Encryption failed: len=%d.\n",
 206                        ieee->dev->name, frag->len);
 207                 ieee->ieee_stats.tx_discards++;
 208                 return -1;
 209         }
 210
 211         return 0;
 212 }
 213
 214
 215 void rtllib_txb_free(struct rtllib_txb *txb)
 216 {
 217         if (unlikely(!txb))
 218                 return;
 219         kfree(txb);
 220 }
 221
 222 static struct rtllib_txb *rtllib_alloc_txb(int nr_frags, int txb_size,
 223                                            gfp_t gfp_mask)
 224 {
 225         struct rtllib_txb *txb;
 226         int i;
 227         txb = kmalloc(sizeof(struct rtllib_txb) + (sizeof(u8 *) * nr_frags),
 228                       gfp_mask);
 229         if (!txb)
 230                 return NULL;
 231
 232         memset(txb, 0, sizeof(struct rtllib_txb));
 233         txb->nr_frags = nr_frags;
 234         txb->frag_size = txb_size;
 235
 236         for (i = 0; i < nr_frags; i++) {
 237                 txb->fragments[i] = dev_alloc_skb(txb_size);
 238                 if (unlikely(!txb->fragments[i])) {
 239                         i--;
 240                         break;
 241                 }
 242                 memset(txb->fragments[i]->cb, 0, sizeof(txb->fragments[i]->cb));
 243         }
 244         if (unlikely(i != nr_frags)) {
 245                 while (i >= 0)
 246                         dev_kfree_skb_any(txb->fragments[i--]);
 247                 kfree(txb);
 248                 return NULL;
 249         }
 250         return txb;
 251 }
 252
 253 static int rtllib_classify(struct sk_buff *skb, u8 bIsAmsdu)
 254 {
 255         struct ethhdr *eth;
 256         struct iphdr *ip;
 257
 258         eth = (struct ethhdr *)skb->data;
 259         if (eth->h_proto != htons(ETH_P_IP))
 260                 return 0;
 261
 262         RTLLIB_DEBUG_DATA(RTLLIB_DL_DATA, skb->data, skb->len);
 263         ip = ip_hdr(skb);
 264         switch (ip->tos & 0xfc) {
 265         case 0x20:
 266                 return 2;
 267         case 0x40:
 268                 return 1;
 269         case 0x60:
 270                 return 3;
 271         case 0x80:
 272                 return 4;
 273         case 0xa0:
 274                 return 5;
 275         case 0xc0:
 276                 return 6;
 277         case 0xe0:
 278                 return 7;
 279         default:
 280                 return 0;
 281         }
 282 }
 283
 284 static void rtllib_tx_query_agg_cap(struct rtllib_device *ieee,
 285                                     struct sk_buff *skb,
 286                                     struct cb_desc *tcb_desc)
 287 {
 288         struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;
 289         struct tx_ts_record *pTxTs = NULL;
 290         struct rtllib_hdr_1addr *hdr = (struct rtllib_hdr_1addr *)skb->data;
 291
 292         if (rtllib_act_scanning(ieee, false))
 293                 return;
 294
 295         if (!pHTInfo->bCurrentHTSupport || !pHTInfo->bEnableHT)
 296                 return;
 297         if (!IsQoSDataFrame(skb->data))
 298                 return;
 299         if (is_multicast_ether_addr(hdr->addr1))
 300                 return;
 301
 302         if (tcb_desc->bdhcp || ieee->CntAfterLink < 2)
 303                 return;
 304
 305         if (pHTInfo->IOTAction & HT_IOT_ACT_TX_NO_AGGREGATION)
 306                 return;
 307
 308         if (!ieee->GetNmodeSupportBySecCfg(ieee->dev))
 309                 return;
 310         if (pHTInfo->bCurrentAMPDUEnable) {
 311                 if (!GetTs(ieee, (struct ts_common_info **)(&pTxTs), hdr->addr1,
 312                     skb->priority, TX_DIR, true)) {
 313                         printk(KERN_INFO "%s: can't get TS\n", __func__);
 314                         return;
 315                 }
 316                 if (pTxTs->TxAdmittedBARecord.bValid == false) {
 317                         if (ieee->wpa_ie_len && (ieee->pairwise_key_type ==
 318                             KEY_TYPE_NA)) {
 319                                 ;
 320                         } else if (tcb_desc->bdhcp == 1) {
 321                                 ;
 322                         } else if (!pTxTs->bDisable_AddBa) {
 323                                 TsStartAddBaProcess(ieee, pTxTs);
 324                         }
 325                         goto FORCED_AGG_SETTING;
 326                 } else if (pTxTs->bUsingBa == false) {
 327                         if (SN_LESS(pTxTs->TxAdmittedBARecord.BaStartSeqCtrl.field.SeqNum,
 328                            (pTxTs->TxCurSeq+1)%4096))
 329                                 pTxTs->bUsingBa = true;
 330                         else
 331                                 goto FORCED_AGG_SETTING;
 332                 }
 333                 if (ieee->iw_mode == IW_MODE_INFRA) {
 334                         tcb_desc->bAMPDUEnable = true;
 335                         tcb_desc->ampdu_factor = pHTInfo->CurrentAMPDUFactor;
 336                         tcb_desc->ampdu_density = pHTInfo->CurrentMPDUDensity;
 337                 }
 338         }
 339 FORCED_AGG_SETTING:
 340         switch (pHTInfo->ForcedAMPDUMode) {
 341         case HT_AGG_AUTO:
 342                 break;
 343
 344         case HT_AGG_FORCE_ENABLE:
 345                 tcb_desc->bAMPDUEnable = true;
 346                 tcb_desc->ampdu_density = pHTInfo->ForcedMPDUDensity;
 347                 tcb_desc->ampdu_factor = pHTInfo->ForcedAMPDUFactor;
 348                 break;
 349
 350         case HT_AGG_FORCE_DISABLE:
 351                 tcb_desc->bAMPDUEnable = false;
 352                 tcb_desc->ampdu_density = 0;
 353                 tcb_desc->ampdu_factor = 0;
 354                 break;
 355         }
 356         return;
 357 }
 358
 359 static void rtllib_qurey_ShortPreambleMode(struct rtllib_device *ieee,
 360                                            struct cb_desc *tcb_desc)
 361 {
 362         tcb_desc->bUseShortPreamble = false;
 363         if (tcb_desc->data_rate == 2)
 364                 return;
 365         else if (ieee->current_network.capability &
 366                  WLAN_CAPABILITY_SHORT_PREAMBLE)
 367                 tcb_desc->bUseShortPreamble = true;
 368         return;
 369 }
 370
 371 static void rtllib_query_HTCapShortGI(struct rtllib_device *ieee,
 372                                       struct cb_desc *tcb_desc)
 373 {
 374         struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;
 375
 376         tcb_desc->bUseShortGI           = false;
 377
 378         if (!pHTInfo->bCurrentHTSupport || !pHTInfo->bEnableHT)
 379                 return;
 380
 381         if (pHTInfo->bForcedShortGI) {
 382                 tcb_desc->bUseShortGI = true;
 383                 return;
 384         }
 385
 386         if ((pHTInfo->bCurBW40MHz == true) && pHTInfo->bCurShortGI40MHz)
 387                 tcb_desc->bUseShortGI = true;
 388         else if ((pHTInfo->bCurBW40MHz == false) && pHTInfo->bCurShortGI20MHz)
 389                 tcb_desc->bUseShortGI = true;
 390 }
 391
 392 static void rtllib_query_BandwidthMode(struct rtllib_device *ieee,
 393                                        struct cb_desc *tcb_desc)
 394 {
 395         struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;
 396
 397         tcb_desc->bPacketBW = false;
 398
 399         if (!pHTInfo->bCurrentHTSupport || !pHTInfo->bEnableHT)
 400                 return;
 401
 402         if (tcb_desc->bMulticast || tcb_desc->bBroadcast)
 403                 return;
 404
 405         if ((tcb_desc->data_rate & 0x80) == 0)
 406                 return;
 407         if (pHTInfo->bCurBW40MHz && pHTInfo->bCurTxBW40MHz &&
 408             !ieee->bandwidth_auto_switch.bforced_tx20Mhz)
 409                 tcb_desc->bPacketBW = true;
 410         return;
 411 }
 412
 413 static void rtllib_query_protectionmode(struct rtllib_device *ieee,
 414                                         struct cb_desc *tcb_desc,
 415                                         struct sk_buff *skb)
 416 {
 417         tcb_desc->bRTSSTBC                      = false;
 418         tcb_desc->bRTSUseShortGI                = false;
 419         tcb_desc->bCTSEnable                    = false;
 420         tcb_desc->RTSSC                         = 0;
 421         tcb_desc->bRTSBW                        = false;
 422
 423         if (tcb_desc->bBroadcast || tcb_desc->bMulticast)
 424                 return;
 425
 426         if (is_broadcast_ether_addr(skb->data+16))
 427                 return;
 428
 429         if (ieee->mode < IEEE_N_24G) {
 430                 if (skb->len > ieee->rts) {
 431                         tcb_desc->bRTSEnable = true;
 432                         tcb_desc->rts_rate = MGN_24M;
 433                 } else if (ieee->current_network.buseprotection) {
 434                         tcb_desc->bRTSEnable = true;
 435                         tcb_desc->bCTSEnable = true;
 436                         tcb_desc->rts_rate = MGN_24M;
 437                 }
 438                 return;
 439         } else {
 440                 struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;
 441                 while (true) {
 442                         if (pHTInfo->IOTAction & HT_IOT_ACT_FORCED_CTS2SELF) {
 443                                 tcb_desc->bCTSEnable    = true;
 444                                 tcb_desc->rts_rate  =   MGN_24M;
 445                                 tcb_desc->bRTSEnable = true;
 446                                 break;
 447                         } else if (pHTInfo->IOTAction & (HT_IOT_ACT_FORCED_RTS |
 448                                    HT_IOT_ACT_PURE_N_MODE)) {
 449                                 tcb_desc->bRTSEnable = true;
 450                                 tcb_desc->rts_rate  =   MGN_24M;
 451                                 break;
 452                         }
 453                         if (ieee->current_network.buseprotection) {
 454                                 tcb_desc->bRTSEnable = true;
 455                                 tcb_desc->bCTSEnable = true;
 456                                 tcb_desc->rts_rate = MGN_24M;
 457                                 break;
 458                         }
 459                         if (pHTInfo->bCurrentHTSupport  && pHTInfo->bEnableHT) {
 460                                 u8 HTOpMode = pHTInfo->CurrentOpMode;
 461                                 if ((pHTInfo->bCurBW40MHz && (HTOpMode == 2 ||
 462                                      HTOpMode == 3)) ||
 463                                      (!pHTInfo->bCurBW40MHz && HTOpMode == 3)) {
 464                                         tcb_desc->rts_rate = MGN_24M;
 465                                         tcb_desc->bRTSEnable = true;
 466                                         break;
 467                                 }
 468                         }
 469                         if (skb->len > ieee->rts) {
 470                                 tcb_desc->rts_rate = MGN_24M;
 471                                 tcb_desc->bRTSEnable = true;
 472                                 break;
 473                         }
 474                         if (tcb_desc->bAMPDUEnable) {
 475                                 tcb_desc->rts_rate = MGN_24M;
 476                                 tcb_desc->bRTSEnable = false;
 477                                 break;
 478                         }
 479                         goto NO_PROTECTION;
 480                 }
 481         }
 482         if (ieee->current_network.capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
 483                 tcb_desc->bUseShortPreamble = true;
 484         if (ieee->iw_mode == IW_MODE_MASTER)
 485                         goto NO_PROTECTION;
 486         return;
 487 NO_PROTECTION:
 488         tcb_desc->bRTSEnable    = false;
 489         tcb_desc->bCTSEnable    = false;
 490         tcb_desc->rts_rate      = 0;
 491         tcb_desc->RTSSC         = 0;
 492         tcb_desc->bRTSBW        = false;
 493 }
 494
 495
 496 static void rtllib_txrate_selectmode(struct rtllib_device *ieee,
 497                                      struct cb_desc *tcb_desc)
 498 {
 499         if (ieee->bTxDisableRateFallBack)
 500                 tcb_desc->bTxDisableRateFallBack = true;
 501
 502         if (ieee->bTxUseDriverAssingedRate)
 503                 tcb_desc->bTxUseDriverAssingedRate = true;
 504         if (!tcb_desc->bTxDisableRateFallBack ||
 505             !tcb_desc->bTxUseDriverAssingedRate) {
 506                 if (ieee->iw_mode == IW_MODE_INFRA ||
 507                     ieee->iw_mode == IW_MODE_ADHOC)
 508                         tcb_desc->RATRIndex = 0;
 509         }
 510 }
 511
 512 u16 rtllib_query_seqnum(struct rtllib_device *ieee, struct sk_buff *skb,
 513                         u8 *dst)
 514 {
 515         u16 seqnum = 0;
 516
 517         if (is_multicast_ether_addr(dst))
 518                 return 0;
 519         if (IsQoSDataFrame(skb->data)) {
 520                 struct tx_ts_record *pTS = NULL;
 521                 if (!GetTs(ieee, (struct ts_common_info **)(&pTS), dst,
 522                     skb->priority, TX_DIR, true))
 523                         return 0;
 524                 seqnum = pTS->TxCurSeq;
 525                 pTS->TxCurSeq = (pTS->TxCurSeq+1)%4096;
 526                 return seqnum;
 527         }
 528         return 0;
 529 }
 530
 531 static int wme_downgrade_ac(struct sk_buff *skb)
 532 {
 533         switch (skb->priority) {
 534         case 6:
 535         case 7:
 536                 skb->priority = 5; /* VO -> VI */
 537                 return 0;
 538         case 4:
 539         case 5:
 540                 skb->priority = 3; /* VI -> BE */
 541                 return 0;
 542         case 0:
 543         case 3:
 544                 skb->priority = 1; /* BE -> BK */
 545                 return 0;
 546         default:
 547                 return -1;
 548         }
 549 }
 550
 551 int rtllib_xmit_inter(struct sk_buff *skb, struct net_device *dev)
 552 {
 553         struct rtllib_device *ieee = (struct rtllib_device *)
 554                                      netdev_priv_rsl(dev);
 555         struct rtllib_txb *txb = NULL;
 556         struct rtllib_hdr_3addrqos *frag_hdr;
 557         int i, bytes_per_frag, nr_frags, bytes_last_frag, frag_size;
 558         unsigned long flags;
 559         struct net_device_stats *stats = &ieee->stats;
 560         int ether_type = 0, encrypt;
 561         int bytes, fc, qos_ctl = 0, hdr_len;
 562         struct sk_buff *skb_frag;
 563         struct rtllib_hdr_3addrqos header = { /* Ensure zero initialized */
 564                 .duration_id = 0,
 565                 .seq_ctl = 0,
 566                 .qos_ctl = 0
 567         };
 568         u8 dest[ETH_ALEN], src[ETH_ALEN];
 569         int qos_actived = ieee->current_network.qos_data.active;
 570         struct lib80211_crypt_data *crypt = NULL;
 571         struct cb_desc *tcb_desc;
 572         u8 bIsMulticast = false;
 573         u8 IsAmsdu = false;
 574         bool    bdhcp = false;
 575
 576         spin_lock_irqsave(&ieee->lock, flags);
 577
 578         /* If there is no driver handler to take the TXB, don't bother
 579          * creating it... */
 580         if ((!ieee->hard_start_xmit && !(ieee->softmac_features &
 581            IEEE_SOFTMAC_TX_QUEUE)) ||
 582            ((!ieee->softmac_data_hard_start_xmit &&
 583            (ieee->softmac_features & IEEE_SOFTMAC_TX_QUEUE)))) {
 584                 printk(KERN_WARNING "%s: No xmit handler.\n",
 585                        ieee->dev->name);
 586                 goto success;
 587         }
 588
 589
 590         if (likely(ieee->raw_tx == 0)) {
 591                 if (unlikely(skb->len < SNAP_SIZE + sizeof(u16))) {
 592                         printk(KERN_WARNING "%s: skb too small (%d).\n",
 593                         ieee->dev->name, skb->len);
 594                         goto success;
 595                 }
 596                 /* Save source and destination addresses */
 597                 memcpy(dest, skb->data, ETH_ALEN);
 598                 memcpy(src, skb->data+ETH_ALEN, ETH_ALEN);
 599
 600                 memset(skb->cb, 0, sizeof(skb->cb));
 601                 ether_type = ntohs(((struct ethhdr *)skb->data)->h_proto);
 602
 603                 if (ieee->iw_mode == IW_MODE_MONITOR) {
 604                         txb = rtllib_alloc_txb(1, skb->len, GFP_ATOMIC);
 605                         if (unlikely(!txb)) {
 606                                 printk(KERN_WARNING "%s: Could not allocate "
 607                                        "TXB\n",
 608                                 ieee->dev->name);
 609                                 goto failed;
 610                         }
 611
 612                         txb->encrypted = 0;
 613                         txb->payload_size = skb->len;
 614                         memcpy(skb_put(txb->fragments[0], skb->len), skb->data,
 615                                skb->len);
 616
 617                         goto success;
 618                 }
 619
 620                 if (skb->len > 282) {
 621                         if (ETH_P_IP == ether_type) {
 622                                 const struct iphdr *ip = (struct iphdr *)
 623                                         ((u8 *)skb->data+14);
 624                                 if (IPPROTO_UDP == ip->protocol) {
 625                                         struct udphdr *udp;
 626
 627                                         udp = (struct udphdr *)((u8 *)ip +
 628                                               (ip->ihl << 2));
 629                                         if (((((u8 *)udp)[1] == 68) &&
 630                                            (((u8 *)udp)[3] == 67)) ||
 631                                            ((((u8 *)udp)[1] == 67) &&
 632                                            (((u8 *)udp)[3] == 68))) {
 633                                                 bdhcp = true;
 634                                                 ieee->LPSDelayCnt = 200;
 635                                         }
 636                                 }
 637                         } else if (ETH_P_ARP == ether_type) {
 638                                 printk(KERN_INFO "=================>DHCP "
 639                                        "Protocol start tx ARP pkt!!\n");
 640                                 bdhcp = true;
 641                                 ieee->LPSDelayCnt =
 642                                          ieee->current_network.tim.tim_count;
 643                         }
 644                 }
 645
 646                 skb->priority = rtllib_classify(skb, IsAmsdu);
 647                 crypt = ieee->crypt_info.crypt[ieee->crypt_info.tx_keyidx];
 648                 encrypt = !(ether_type == ETH_P_PAE && ieee->ieee802_1x) &&
 649                         ieee->host_encrypt && crypt && crypt->ops;
 650                 if (!encrypt && ieee->ieee802_1x &&
 651                     ieee->drop_unencrypted && ether_type != ETH_P_PAE) {
 652                         stats->tx_dropped++;
 653                         goto success;
 654                 }
 655                 if (crypt && !encrypt && ether_type == ETH_P_PAE) {
 656                         struct eapol *eap = (struct eapol *)(skb->data +
 657                                 sizeof(struct ethhdr) - SNAP_SIZE -
 658                                 sizeof(u16));
 659                         RTLLIB_DEBUG_EAP("TX: IEEE 802.11 EAPOL frame: %s\n",
 660                                 eap_get_type(eap->type));
 661                 }
 662
 663                 /* Advance the SKB to the start of the payload */
 664                 skb_pull(skb, sizeof(struct ethhdr));
 665
 666                 /* Determine total amount of storage required for TXB packets */
 667                 bytes = skb->len + SNAP_SIZE + sizeof(u16);
 668
 669                 if (encrypt)
 670                         fc = RTLLIB_FTYPE_DATA | RTLLIB_FCTL_WEP;
 671                 else
 672                         fc = RTLLIB_FTYPE_DATA;
 673
 674                 if (qos_actived)
 675                         fc |= RTLLIB_STYPE_QOS_DATA;
 676                 else
 677                         fc |= RTLLIB_STYPE_DATA;
 678
 679                 if (ieee->iw_mode == IW_MODE_INFRA) {
 680                         fc |= RTLLIB_FCTL_TODS;
 681                         /* To DS: Addr1 = BSSID, Addr2 = SA,
 682                         Addr3 = DA */
 683                         memcpy(&header.addr1, ieee->current_network.bssid,
 684                                ETH_ALEN);
 685                         memcpy(&header.addr2, &src, ETH_ALEN);
 686                         if (IsAmsdu)
 687                                 memcpy(&header.addr3,
 688                                        ieee->current_network.bssid, ETH_ALEN);
 689                         else
 690                                 memcpy(&header.addr3, &dest, ETH_ALEN);
 691                 } else if (ieee->iw_mode == IW_MODE_ADHOC) {
 692                         /* not From/To DS: Addr1 = DA, Addr2 = SA,
 693                         Addr3 = BSSID */
 694                         memcpy(&header.addr1, dest, ETH_ALEN);
 695                         memcpy(&header.addr2, src, ETH_ALEN);
 696                         memcpy(&header.addr3, ieee->current_network.bssid,
 697                                ETH_ALEN);
 698                 }
 699
 700                 bIsMulticast = is_multicast_ether_addr(header.addr1);
 701
 702                 header.frame_ctl = cpu_to_le16(fc);
 703
 704                 /* Determine fragmentation size based on destination (multicast
 705                 * and broadcast are not fragmented) */
 706                 if (bIsMulticast) {
 707                         frag_size = MAX_FRAG_THRESHOLD;
 708                         qos_ctl |= QOS_CTL_NOTCONTAIN_ACK;
 709                 } else {
 710                         frag_size = ieee->fts;
 711                         qos_ctl = 0;
 712                 }
 713
 714                 if (qos_actived) {
 715                         hdr_len = RTLLIB_3ADDR_LEN + 2;
 716
 717                 /* in case we are a client verify acm is not set for this ac */
 718                 while (unlikely(ieee->wmm_acm & (0x01 << skb->priority))) {
 719                         printk(KERN_INFO "skb->priority = %x\n", skb->priority);
 720                         if (wme_downgrade_ac(skb))
 721                                 break;
 722                         printk(KERN_INFO "converted skb->priority = %x\n",
 723                                skb->priority);
 724                  }
 725                         qos_ctl |= skb->priority;
 726                         header.qos_ctl = cpu_to_le16(qos_ctl & RTLLIB_QOS_TID);
 727                 } else {
 728                         hdr_len = RTLLIB_3ADDR_LEN;
 729                 }
 730                 /* Determine amount of payload per fragment.  Regardless of if
 731                  * this stack is providing the full 802.11 header, one will
 732                  * eventually be affixed to this fragment -- so we must account
 733                  * for it when determining the amount of payload space. */
 734                 bytes_per_frag = frag_size - hdr_len;
 735                 if (ieee->config &
 736                    (CFG_RTLLIB_COMPUTE_FCS | CFG_RTLLIB_RESERVE_FCS))
 737                         bytes_per_frag -= RTLLIB_FCS_LEN;
 738
 739                 /* Each fragment may need to have room for encrypting
 740                  * pre/postfix */
 741                 if (encrypt) {
 742                         bytes_per_frag -= crypt->ops->extra_mpdu_prefix_len +
 743                                 crypt->ops->extra_mpdu_postfix_len +
 744                                 crypt->ops->extra_msdu_prefix_len +
 745                                 crypt->ops->extra_msdu_postfix_len;
 746                 }
 747                 /* Number of fragments is the total bytes_per_frag /
 748                 * payload_per_fragment */
 749                 nr_frags = bytes / bytes_per_frag;
 750                 bytes_last_frag = bytes % bytes_per_frag;
 751                 if (bytes_last_frag)
 752                         nr_frags++;
 753                 else
 754                         bytes_last_frag = bytes_per_frag;
 755
 756                 /* When we allocate the TXB we allocate enough space for the
 757                  * reserve and full fragment bytes (bytes_per_frag doesn't
 758                  * include prefix, postfix, header, FCS, etc.) */
 759                 txb = rtllib_alloc_txb(nr_frags, frag_size +
 760                                        ieee->tx_headroom, GFP_ATOMIC);
 761                 if (unlikely(!txb)) {
 762                         printk(KERN_WARNING "%s: Could not allocate TXB\n",
 763                         ieee->dev->name);
 764                         goto failed;
 765                 }
 766                 txb->encrypted = encrypt;
 767                 txb->payload_size = bytes;
 768
 769                 if (qos_actived)
 770                         txb->queue_index = UP2AC(skb->priority);
 771                 else
 772                         txb->queue_index = WME_AC_BE;
 773
 774                 for (i = 0; i < nr_frags; i++) {
 775                         skb_frag = txb->fragments[i];
 776                         tcb_desc = (struct cb_desc *)(skb_frag->cb +
 777                                     MAX_DEV_ADDR_SIZE);
 778                         if (qos_actived) {
 779                                 skb_frag->priority = skb->priority;
 780                                 tcb_desc->queue_index =  UP2AC(skb->priority);
 781                         } else {
 782                                 skb_frag->priority = WME_AC_BE;
 783                                 tcb_desc->queue_index = WME_AC_BE;
 784                         }
 785                         skb_reserve(skb_frag, ieee->tx_headroom);
 786
 787                         if (encrypt) {
 788                                 if (ieee->hwsec_active)
 789                                         tcb_desc->bHwSec = 1;
 790                                 else
 791                                         tcb_desc->bHwSec = 0;
 792                                 skb_reserve(skb_frag,
 793                                             crypt->ops->extra_mpdu_prefix_len +
 794                                             crypt->ops->extra_msdu_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 }
 968 EXPORT_SYMBOL(rtllib_xmit);