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 <andrea.merello@gmail.com>
  29
  30   A special thanks goes to Realtek for their support !
  31
  32 ******************************************************************************/
  33
  34 #include <linux/compiler.h>
  35 #include <linux/errno.h>
  36 #include <linux/if_arp.h>
  37 #include <linux/in6.h>
  38 #include <linux/in.h>
  39 #include <linux/ip.h>
  40 #include <linux/kernel.h>
  41 #include <linux/module.h>
  42 #include <linux/netdevice.h>
  43 #include <linux/pci.h>
  44 #include <linux/proc_fs.h>
  45 #include <linux/skbuff.h>
  46 #include <linux/slab.h>
  47 #include <linux/tcp.h>
  48 #include <linux/types.h>
  49 #include <linux/wireless.h>
  50 #include <linux/etherdevice.h>
  51 #include <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         *(__be16 *)(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                 netdev_info(ieee->dev, "=========>%s(), crypt is null\n",
 189                             __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                 netdev_info(ieee->dev, "%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
 229         txb = kmalloc(sizeof(struct rtllib_txb) + (sizeof(u8 *) * nr_frags),
 230                       gfp_mask);
 231         if (!txb)
 232                 return NULL;
 233
 234         memset(txb, 0, sizeof(struct rtllib_txb));
 235         txb->nr_frags = nr_frags;
 236         txb->frag_size = cpu_to_le16(txb_size);
 237
 238         for (i = 0; i < nr_frags; i++) {
 239                 txb->fragments[i] = dev_alloc_skb(txb_size);
 240                 if (unlikely(!txb->fragments[i])) {
 241                         i--;
 242                         break;
 243                 }
 244                 memset(txb->fragments[i]->cb, 0, sizeof(txb->fragments[i]->cb));
 245         }
 246         if (unlikely(i != nr_frags)) {
 247                 while (i >= 0)
 248                         dev_kfree_skb_any(txb->fragments[i--]);
 249                 kfree(txb);
 250                 return NULL;
 251         }
 252         return txb;
 253 }
 254
 255 static int rtllib_classify(struct sk_buff *skb, u8 bIsAmsdu)
 256 {
 257         struct ethhdr *eth;
 258         struct iphdr *ip;
 259
 260         eth = (struct ethhdr *)skb->data;
 261         if (eth->h_proto != htons(ETH_P_IP))
 262                 return 0;
 263
 264         RTLLIB_DEBUG_DATA(RTLLIB_DL_DATA, skb->data, skb->len);
 265         ip = ip_hdr(skb);
 266         switch (ip->tos & 0xfc) {
 267         case 0x20:
 268                 return 2;
 269         case 0x40:
 270                 return 1;
 271         case 0x60:
 272                 return 3;
 273         case 0x80:
 274                 return 4;
 275         case 0xa0:
 276                 return 5;
 277         case 0xc0:
 278                 return 6;
 279         case 0xe0:
 280                 return 7;
 281         default:
 282                 return 0;
 283         }
 284 }
 285
 286 static void rtllib_tx_query_agg_cap(struct rtllib_device *ieee,
 287                                     struct sk_buff *skb,
 288                                     struct cb_desc *tcb_desc)
 289 {
 290         struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;
 291         struct tx_ts_record *pTxTs = NULL;
 292         struct rtllib_hdr_1addr *hdr = (struct rtllib_hdr_1addr *)skb->data;
 293
 294         if (rtllib_act_scanning(ieee, false))
 295                 return;
 296
 297         if (!pHTInfo->bCurrentHTSupport || !pHTInfo->bEnableHT)
 298                 return;
 299         if (!IsQoSDataFrame(skb->data))
 300                 return;
 301         if (is_multicast_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                         netdev_info(ieee->dev, "%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 }
 359
 360 static void rtllib_qurey_ShortPreambleMode(struct rtllib_device *ieee,
 361                                            struct cb_desc *tcb_desc)
 362 {
 363         tcb_desc->bUseShortPreamble = false;
 364         if (tcb_desc->data_rate == 2)
 365                 return;
 366         else if (ieee->current_network.capability &
 367                  WLAN_CAPABILITY_SHORT_PREAMBLE)
 368                 tcb_desc->bUseShortPreamble = true;
 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 }
 411
 412 static void rtllib_query_protectionmode(struct rtllib_device *ieee,
 413                                         struct cb_desc *tcb_desc,
 414                                         struct sk_buff *skb)
 415 {
 416         struct rt_hi_throughput *pHTInfo;
 417
 418         tcb_desc->bRTSSTBC                      = false;
 419         tcb_desc->bRTSUseShortGI                = false;
 420         tcb_desc->bCTSEnable                    = false;
 421         tcb_desc->RTSSC                         = 0;
 422         tcb_desc->bRTSBW                        = false;
 423
 424         if (tcb_desc->bBroadcast || tcb_desc->bMulticast)
 425                 return;
 426
 427         if (is_broadcast_ether_addr(skb->data+16))
 428                 return;
 429
 430         if (ieee->mode < IEEE_N_24G) {
 431                 if (skb->len > ieee->rts) {
 432                         tcb_desc->bRTSEnable = true;
 433                         tcb_desc->rts_rate = MGN_24M;
 434                 } else if (ieee->current_network.buseprotection) {
 435                         tcb_desc->bRTSEnable = true;
 436                         tcb_desc->bCTSEnable = true;
 437                         tcb_desc->rts_rate = MGN_24M;
 438                 }
 439                 return;
 440         }
 441
 442         pHTInfo = ieee->pHTInfo;
 443
 444         while (true) {
 445                 if (pHTInfo->IOTAction & HT_IOT_ACT_FORCED_CTS2SELF) {
 446                         tcb_desc->bCTSEnable    = true;
 447                         tcb_desc->rts_rate  =   MGN_24M;
 448                         tcb_desc->bRTSEnable = true;
 449                         break;
 450                 } else if (pHTInfo->IOTAction & (HT_IOT_ACT_FORCED_RTS |
 451                            HT_IOT_ACT_PURE_N_MODE)) {
 452                         tcb_desc->bRTSEnable = true;
 453                         tcb_desc->rts_rate  =   MGN_24M;
 454                         break;
 455                 }
 456                 if (ieee->current_network.buseprotection) {
 457                         tcb_desc->bRTSEnable = true;
 458                         tcb_desc->bCTSEnable = true;
 459                         tcb_desc->rts_rate = MGN_24M;
 460                         break;
 461                 }
 462                 if (pHTInfo->bCurrentHTSupport  && pHTInfo->bEnableHT) {
 463                         u8 HTOpMode = pHTInfo->CurrentOpMode;
 464
 465                         if ((pHTInfo->bCurBW40MHz && (HTOpMode == 2 ||
 466                              HTOpMode == 3)) ||
 467                              (!pHTInfo->bCurBW40MHz && HTOpMode == 3)) {
 468                                 tcb_desc->rts_rate = MGN_24M;
 469                                 tcb_desc->bRTSEnable = true;
 470                                 break;
 471                         }
 472                 }
 473                 if (skb->len > ieee->rts) {
 474                         tcb_desc->rts_rate = MGN_24M;
 475                         tcb_desc->bRTSEnable = true;
 476                         break;
 477                 }
 478                 if (tcb_desc->bAMPDUEnable) {
 479                         tcb_desc->rts_rate = MGN_24M;
 480                         tcb_desc->bRTSEnable = false;
 481                         break;
 482                 }
 483                 goto NO_PROTECTION;
 484         }
 485         if (ieee->current_network.capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
 486                 tcb_desc->bUseShortPreamble = true;
 487         if (ieee->iw_mode == IW_MODE_MASTER)
 488                         goto NO_PROTECTION;
 489         return;
 490 NO_PROTECTION:
 491         tcb_desc->bRTSEnable    = false;
 492         tcb_desc->bCTSEnable    = false;
 493         tcb_desc->rts_rate      = 0;
 494         tcb_desc->RTSSC         = 0;
 495         tcb_desc->bRTSBW        = false;
 496 }
 497
 498
 499 static void rtllib_txrate_selectmode(struct rtllib_device *ieee,
 500                                      struct cb_desc *tcb_desc)
 501 {
 502         if (ieee->bTxDisableRateFallBack)
 503                 tcb_desc->bTxDisableRateFallBack = true;
 504
 505         if (ieee->bTxUseDriverAssingedRate)
 506                 tcb_desc->bTxUseDriverAssingedRate = true;
 507         if (!tcb_desc->bTxDisableRateFallBack ||
 508             !tcb_desc->bTxUseDriverAssingedRate) {
 509                 if (ieee->iw_mode == IW_MODE_INFRA ||
 510                     ieee->iw_mode == IW_MODE_ADHOC)
 511                         tcb_desc->RATRIndex = 0;
 512         }
 513 }
 514
 515 u16 rtllib_query_seqnum(struct rtllib_device *ieee, struct sk_buff *skb,
 516                         u8 *dst)
 517 {
 518         u16 seqnum = 0;
 519
 520         if (is_multicast_ether_addr(dst))
 521                 return 0;
 522         if (IsQoSDataFrame(skb->data)) {
 523                 struct tx_ts_record *pTS = NULL;
 524
 525                 if (!GetTs(ieee, (struct ts_common_info **)(&pTS), dst,
 526                     skb->priority, TX_DIR, true))
 527                         return 0;
 528                 seqnum = pTS->TxCurSeq;
 529                 pTS->TxCurSeq = (pTS->TxCurSeq+1)%4096;
 530                 return seqnum;
 531         }
 532         return 0;
 533 }
 534
 535 static int wme_downgrade_ac(struct sk_buff *skb)
 536 {
 537         switch (skb->priority) {
 538         case 6:
 539         case 7:
 540                 skb->priority = 5; /* VO -> VI */
 541                 return 0;
 542         case 4:
 543         case 5:
 544                 skb->priority = 3; /* VI -> BE */
 545                 return 0;
 546         case 0:
 547         case 3:
 548                 skb->priority = 1; /* BE -> BK */
 549                 return 0;
 550         default:
 551                 return -1;
 552         }
 553 }
 554
 555 static u8 rtllib_current_rate(struct rtllib_device *ieee)
 556 {
 557         if (ieee->mode & IEEE_MODE_MASK)
 558                 return ieee->rate;
 559
 560         if (ieee->HTCurrentOperaRate)
 561                 return ieee->HTCurrentOperaRate;
 562         else
 563                 return ieee->rate & 0x7F;
 564 }
 565
 566 int rtllib_xmit_inter(struct sk_buff *skb, struct net_device *dev)
 567 {
 568         struct rtllib_device *ieee = (struct rtllib_device *)
 569                                      netdev_priv_rsl(dev);
 570         struct rtllib_txb *txb = NULL;
 571         struct rtllib_hdr_3addrqos *frag_hdr;
 572         int i, bytes_per_frag, nr_frags, bytes_last_frag, frag_size;
 573         unsigned long flags;
 574         struct net_device_stats *stats = &ieee->stats;
 575         int ether_type = 0, encrypt;
 576         int bytes, fc, qos_ctl = 0, hdr_len;
 577         struct sk_buff *skb_frag;
 578         struct rtllib_hdr_3addrqos header = { /* Ensure zero initialized */
 579                 .duration_id = 0,
 580                 .seq_ctl = 0,
 581                 .qos_ctl = 0
 582         };
 583         u8 dest[ETH_ALEN], src[ETH_ALEN];
 584         int qos_actived = ieee->current_network.qos_data.active;
 585         struct lib80211_crypt_data *crypt = NULL;
 586         struct cb_desc *tcb_desc;
 587         u8 bIsMulticast = false;
 588         u8 IsAmsdu = false;
 589         bool    bdhcp = false;
 590
 591         spin_lock_irqsave(&ieee->lock, flags);
 592
 593         /* If there is no driver handler to take the TXB, don't bother
 594          * creating it... */
 595         if ((!ieee->hard_start_xmit && !(ieee->softmac_features &
 596            IEEE_SOFTMAC_TX_QUEUE)) ||
 597            ((!ieee->softmac_data_hard_start_xmit &&
 598            (ieee->softmac_features & IEEE_SOFTMAC_TX_QUEUE)))) {
 599                 netdev_warn(ieee->dev, "No xmit handler.\n");
 600                 goto success;
 601         }
 602
 603
 604         if (likely(ieee->raw_tx == 0)) {
 605                 if (unlikely(skb->len < SNAP_SIZE + sizeof(u16))) {
 606                         netdev_warn(ieee->dev, "skb too small (%d).\n",
 607                                     skb->len);
 608                         goto success;
 609                 }
 610                 /* Save source and destination addresses */
 611                 memcpy(dest, skb->data, ETH_ALEN);
 612                 memcpy(src, skb->data+ETH_ALEN, ETH_ALEN);
 613
 614                 memset(skb->cb, 0, sizeof(skb->cb));
 615                 ether_type = ntohs(((struct ethhdr *)skb->data)->h_proto);
 616
 617                 if (ieee->iw_mode == IW_MODE_MONITOR) {
 618                         txb = rtllib_alloc_txb(1, skb->len, GFP_ATOMIC);
 619                         if (unlikely(!txb)) {
 620                                 netdev_warn(ieee->dev,
 621                                             "Could not allocate TXB\n");
 622                                 goto failed;
 623                         }
 624
 625                         txb->encrypted = 0;
 626                         txb->payload_size = cpu_to_le16(skb->len);
 627                         memcpy(skb_put(txb->fragments[0], skb->len), skb->data,
 628                                skb->len);
 629
 630                         goto success;
 631                 }
 632
 633                 if (skb->len > 282) {
 634                         if (ETH_P_IP == ether_type) {
 635                                 const struct iphdr *ip = (struct iphdr *)
 636                                         ((u8 *)skb->data+14);
 637                                 if (IPPROTO_UDP == ip->protocol) {
 638                                         struct udphdr *udp;
 639
 640                                         udp = (struct udphdr *)((u8 *)ip +
 641                                               (ip->ihl << 2));
 642                                         if (((((u8 *)udp)[1] == 68) &&
 643                                            (((u8 *)udp)[3] == 67)) ||
 644                                            ((((u8 *)udp)[1] == 67) &&
 645                                            (((u8 *)udp)[3] == 68))) {
 646                                                 bdhcp = true;
 647                                                 ieee->LPSDelayCnt = 200;
 648                                         }
 649                                 }
 650                         } else if (ETH_P_ARP == ether_type) {
 651                                 netdev_info(ieee->dev,
 652                                             "=================>DHCP Protocol start tx ARP pkt!!\n");
 653                                 bdhcp = true;
 654                                 ieee->LPSDelayCnt =
 655                                          ieee->current_network.tim.tim_count;
 656                         }
 657                 }
 658
 659                 skb->priority = rtllib_classify(skb, IsAmsdu);
 660                 crypt = ieee->crypt_info.crypt[ieee->crypt_info.tx_keyidx];
 661                 encrypt = !(ether_type == ETH_P_PAE && ieee->ieee802_1x) &&
 662                         ieee->host_encrypt && crypt && crypt->ops;
 663                 if (!encrypt && ieee->ieee802_1x &&
 664                     ieee->drop_unencrypted && ether_type != ETH_P_PAE) {
 665                         stats->tx_dropped++;
 666                         goto success;
 667                 }
 668                 if (crypt && !encrypt && ether_type == ETH_P_PAE) {
 669                         struct eapol *eap = (struct eapol *)(skb->data +
 670                                 sizeof(struct ethhdr) - SNAP_SIZE -
 671                                 sizeof(u16));
 672                         RTLLIB_DEBUG_EAP("TX: IEEE 802.11 EAPOL frame: %s\n",
 673                                 eap_get_type(eap->type));
 674                 }
 675
 676                 /* Advance the SKB to the start of the payload */
 677                 skb_pull(skb, sizeof(struct ethhdr));
 678
 679                 /* Determine total amount of storage required for TXB packets */
 680                 bytes = skb->len + SNAP_SIZE + sizeof(u16);
 681
 682                 if (encrypt)
 683                         fc = RTLLIB_FTYPE_DATA | RTLLIB_FCTL_WEP;
 684                 else
 685                         fc = RTLLIB_FTYPE_DATA;
 686
 687                 if (qos_actived)
 688                         fc |= RTLLIB_STYPE_QOS_DATA;
 689                 else
 690                         fc |= RTLLIB_STYPE_DATA;
 691
 692                 if (ieee->iw_mode == IW_MODE_INFRA) {
 693                         fc |= RTLLIB_FCTL_TODS;
 694                         /* To DS: Addr1 = BSSID, Addr2 = SA,
 695                         Addr3 = DA */
 696                         memcpy(&header.addr1, ieee->current_network.bssid,
 697                                ETH_ALEN);
 698                         memcpy(&header.addr2, &src, ETH_ALEN);
 699                         if (IsAmsdu)
 700                                 memcpy(&header.addr3,
 701                                        ieee->current_network.bssid, ETH_ALEN);
 702                         else
 703                                 memcpy(&header.addr3, &dest, ETH_ALEN);
 704                 } else if (ieee->iw_mode == IW_MODE_ADHOC) {
 705                         /* not From/To DS: Addr1 = DA, Addr2 = SA,
 706                         Addr3 = BSSID */
 707                         memcpy(&header.addr1, dest, ETH_ALEN);
 708                         memcpy(&header.addr2, src, ETH_ALEN);
 709                         memcpy(&header.addr3, ieee->current_network.bssid,
 710                                ETH_ALEN);
 711                 }
 712
 713                 bIsMulticast = is_multicast_ether_addr(header.addr1);
 714
 715                 header.frame_ctl = cpu_to_le16(fc);
 716
 717                 /* Determine fragmentation size based on destination (multicast
 718                 * and broadcast are not fragmented) */
 719                 if (bIsMulticast) {
 720                         frag_size = MAX_FRAG_THRESHOLD;
 721                         qos_ctl |= QOS_CTL_NOTCONTAIN_ACK;
 722                 } else {
 723                         frag_size = ieee->fts;
 724                         qos_ctl = 0;
 725                 }
 726
 727                 if (qos_actived) {
 728                         hdr_len = RTLLIB_3ADDR_LEN + 2;
 729
 730                 /* in case we are a client verify acm is not set for this ac */
 731                 while (unlikely(ieee->wmm_acm & (0x01 << skb->priority))) {
 732                         netdev_info(ieee->dev, "skb->priority = %x\n",
 733                                     skb->priority);
 734                         if (wme_downgrade_ac(skb))
 735                                 break;
 736                         netdev_info(ieee->dev, "converted skb->priority = %x\n",
 737                                skb->priority);
 738                  }
 739                         qos_ctl |= skb->priority;
 740                         header.qos_ctl = cpu_to_le16(qos_ctl & RTLLIB_QOS_TID);
 741                 } else {
 742                         hdr_len = RTLLIB_3ADDR_LEN;
 743                 }
 744                 /* Determine amount of payload per fragment.  Regardless of if
 745                  * this stack is providing the full 802.11 header, one will
 746                  * eventually be affixed to this fragment -- so we must account
 747                  * for it when determining the amount of payload space. */
 748                 bytes_per_frag = frag_size - hdr_len;
 749                 if (ieee->config &
 750                    (CFG_RTLLIB_COMPUTE_FCS | CFG_RTLLIB_RESERVE_FCS))
 751                         bytes_per_frag -= RTLLIB_FCS_LEN;
 752
 753                 /* Each fragment may need to have room for encrypting
 754                  * pre/postfix */
 755                 if (encrypt) {
 756                         bytes_per_frag -= crypt->ops->extra_mpdu_prefix_len +
 757                                 crypt->ops->extra_mpdu_postfix_len +
 758                                 crypt->ops->extra_msdu_prefix_len +
 759                                 crypt->ops->extra_msdu_postfix_len;
 760                 }
 761                 /* Number of fragments is the total bytes_per_frag /
 762                 * payload_per_fragment */
 763                 nr_frags = bytes / bytes_per_frag;
 764                 bytes_last_frag = bytes % bytes_per_frag;
 765                 if (bytes_last_frag)
 766                         nr_frags++;
 767                 else
 768                         bytes_last_frag = bytes_per_frag;
 769
 770                 /* When we allocate the TXB we allocate enough space for the
 771                  * reserve and full fragment bytes (bytes_per_frag doesn't
 772                  * include prefix, postfix, header, FCS, etc.) */
 773                 txb = rtllib_alloc_txb(nr_frags, frag_size +
 774                                        ieee->tx_headroom, GFP_ATOMIC);
 775                 if (unlikely(!txb)) {
 776                         netdev_warn(ieee->dev, "Could not allocate TXB\n");
 777                         goto failed;
 778                 }
 779                 txb->encrypted = encrypt;
 780                 txb->payload_size = cpu_to_le16(bytes);
 781
 782                 if (qos_actived)
 783                         txb->queue_index = UP2AC(skb->priority);
 784                 else
 785                         txb->queue_index = WME_AC_BE;
 786
 787                 for (i = 0; i < nr_frags; i++) {
 788                         skb_frag = txb->fragments[i];
 789                         tcb_desc = (struct cb_desc *)(skb_frag->cb +
 790                                     MAX_DEV_ADDR_SIZE);
 791                         if (qos_actived) {
 792                                 skb_frag->priority = skb->priority;
 793                                 tcb_desc->queue_index =  UP2AC(skb->priority);
 794                         } else {
 795                                 skb_frag->priority = WME_AC_BE;
 796                                 tcb_desc->queue_index = WME_AC_BE;
 797                         }
 798                         skb_reserve(skb_frag, ieee->tx_headroom);
 799
 800                         if (encrypt) {
 801                                 if (ieee->hwsec_active)
 802                                         tcb_desc->bHwSec = 1;
 803                                 else
 804                                         tcb_desc->bHwSec = 0;
 805                                 skb_reserve(skb_frag,
 806                                             crypt->ops->extra_mpdu_prefix_len +
 807                                             crypt->ops->extra_msdu_prefix_len);
 808                         } else {
 809                                 tcb_desc->bHwSec = 0;
 810                         }
 811                         frag_hdr = (struct rtllib_hdr_3addrqos *)
 812                                    skb_put(skb_frag, hdr_len);
 813                         memcpy(frag_hdr, &header, hdr_len);
 814
 815                         /* If this is not the last fragment, then add the
 816                          * MOREFRAGS bit to the frame control */
 817                         if (i != nr_frags - 1) {
 818                                 frag_hdr->frame_ctl = cpu_to_le16(
 819                                         fc | RTLLIB_FCTL_MOREFRAGS);
 820                                 bytes = bytes_per_frag;
 821
 822                         } else {
 823                                 /* The last fragment has the remaining length */
 824                                 bytes = bytes_last_frag;
 825                         }
 826                         if ((qos_actived) && (!bIsMulticast)) {
 827                                 frag_hdr->seq_ctl =
 828                                          cpu_to_le16(rtllib_query_seqnum(ieee, skb_frag,
 829                                                              header.addr1));
 830                                 frag_hdr->seq_ctl =
 831                                          cpu_to_le16(le16_to_cpu(frag_hdr->seq_ctl)<<4 | i);
 832                         } else {
 833                                 frag_hdr->seq_ctl =
 834                                          cpu_to_le16(ieee->seq_ctrl[0]<<4 | i);
 835                         }
 836                         /* Put a SNAP header on the first fragment */
 837                         if (i == 0) {
 838                                 rtllib_put_snap(
 839                                         skb_put(skb_frag, SNAP_SIZE +
 840                                         sizeof(u16)), ether_type);
 841                                 bytes -= SNAP_SIZE + sizeof(u16);
 842                         }
 843
 844                         memcpy(skb_put(skb_frag, bytes), skb->data, bytes);
 845
 846                         /* Advance the SKB... */
 847                         skb_pull(skb, bytes);
 848
 849                         /* Encryption routine will move the header forward in
 850                          * order to insert the IV between the header and the
 851                          * payload */
 852                         if (encrypt)
 853                                 rtllib_encrypt_fragment(ieee, skb_frag,
 854                                                         hdr_len);
 855                         if (ieee->config &
 856                            (CFG_RTLLIB_COMPUTE_FCS | CFG_RTLLIB_RESERVE_FCS))
 857                                 skb_put(skb_frag, 4);
 858                 }
 859
 860                 if ((qos_actived) && (!bIsMulticast)) {
 861                         if (ieee->seq_ctrl[UP2AC(skb->priority) + 1] == 0xFFF)
 862                                 ieee->seq_ctrl[UP2AC(skb->priority) + 1] = 0;
 863                         else
 864                                 ieee->seq_ctrl[UP2AC(skb->priority) + 1]++;
 865                 } else {
 866                         if (ieee->seq_ctrl[0] == 0xFFF)
 867                                 ieee->seq_ctrl[0] = 0;
 868                         else
 869                                         ieee->seq_ctrl[0]++;
 870                 }
 871         } else {
 872                 if (unlikely(skb->len < sizeof(struct rtllib_hdr_3addr))) {
 873                         netdev_warn(ieee->dev, "skb too small (%d).\n",
 874                                     skb->len);
 875                         goto success;
 876                 }
 877
 878                 txb = rtllib_alloc_txb(1, skb->len, GFP_ATOMIC);
 879                 if (!txb) {
 880                         netdev_warn(ieee->dev, "Could not allocate TXB\n");
 881                         goto failed;
 882                 }
 883
 884                 txb->encrypted = 0;
 885                 txb->payload_size = cpu_to_le16(skb->len);
 886                 memcpy(skb_put(txb->fragments[0], skb->len), skb->data,
 887                        skb->len);
 888         }
 889
 890  success:
 891         if (txb) {
 892                 struct cb_desc *tcb_desc = (struct cb_desc *)
 893                                 (txb->fragments[0]->cb + MAX_DEV_ADDR_SIZE);
 894                 tcb_desc->bTxEnableFwCalcDur = 1;
 895                 tcb_desc->priority = skb->priority;
 896
 897                 if (ether_type == ETH_P_PAE) {
 898                         if (ieee->pHTInfo->IOTAction &
 899                             HT_IOT_ACT_WA_IOT_Broadcom) {
 900                                 tcb_desc->data_rate =
 901                                          MgntQuery_TxRateExcludeCCKRates(ieee);
 902                                 tcb_desc->bTxDisableRateFallBack = false;
 903                         } else {
 904                                 tcb_desc->data_rate = ieee->basic_rate;
 905                                 tcb_desc->bTxDisableRateFallBack = 1;
 906                         }
 907
 908
 909                         tcb_desc->RATRIndex = 7;
 910                         tcb_desc->bTxUseDriverAssingedRate = 1;
 911                 } else {
 912                         if (is_multicast_ether_addr(header.addr1))
 913                                 tcb_desc->bMulticast = 1;
 914                         if (is_broadcast_ether_addr(header.addr1))
 915                                 tcb_desc->bBroadcast = 1;
 916                         rtllib_txrate_selectmode(ieee, tcb_desc);
 917                         if (tcb_desc->bMulticast ||  tcb_desc->bBroadcast)
 918                                 tcb_desc->data_rate = ieee->basic_rate;
 919                         else
 920                                 tcb_desc->data_rate = rtllib_current_rate(ieee);
 921
 922                         if (bdhcp) {
 923                                 if (ieee->pHTInfo->IOTAction &
 924                                     HT_IOT_ACT_WA_IOT_Broadcom) {
 925                                         tcb_desc->data_rate =
 926                                            MgntQuery_TxRateExcludeCCKRates(ieee);
 927                                         tcb_desc->bTxDisableRateFallBack = false;
 928                                 } else {
 929                                         tcb_desc->data_rate = MGN_1M;
 930                                         tcb_desc->bTxDisableRateFallBack = 1;
 931                                 }
 932
 933
 934                                 tcb_desc->RATRIndex = 7;
 935                                 tcb_desc->bTxUseDriverAssingedRate = 1;
 936                                 tcb_desc->bdhcp = 1;
 937                         }
 938
 939                         rtllib_qurey_ShortPreambleMode(ieee, tcb_desc);
 940                         rtllib_tx_query_agg_cap(ieee, txb->fragments[0],
 941                                                 tcb_desc);
 942                         rtllib_query_HTCapShortGI(ieee, tcb_desc);
 943                         rtllib_query_BandwidthMode(ieee, tcb_desc);
 944                         rtllib_query_protectionmode(ieee, tcb_desc,
 945                                                     txb->fragments[0]);
 946                 }
 947         }
 948         spin_unlock_irqrestore(&ieee->lock, flags);
 949         dev_kfree_skb_any(skb);
 950         if (txb) {
 951                 if (ieee->softmac_features & IEEE_SOFTMAC_TX_QUEUE) {
 952                         dev->stats.tx_packets++;
 953                         dev->stats.tx_bytes += le16_to_cpu(txb->payload_size);
 954                         rtllib_softmac_xmit(txb, ieee);
 955                 } else {
 956                         if ((*ieee->hard_start_xmit)(txb, dev) == 0) {
 957                                 stats->tx_packets++;
 958                                 stats->tx_bytes += le16_to_cpu(txb->payload_size);
 959                                 return 0;
 960                         }
 961                         rtllib_txb_free(txb);
 962                 }
 963         }
 964
 965         return 0;
 966
 967  failed:
 968         spin_unlock_irqrestore(&ieee->lock, flags);
 969         netif_stop_queue(dev);
 970         stats->tx_errors++;
 971         return 1;
 972
 973 }
 974 int rtllib_xmit(struct sk_buff *skb, struct net_device *dev)
 975 {
 976         memset(skb->cb, 0, sizeof(skb->cb));
 977         return rtllib_xmit_inter(skb, dev);
 978 }
 979 EXPORT_SYMBOL(rtllib_xmit);