drivers/staging/rtl8723bs/core/rtw_xmit.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /******************************************************************************
   3  *
   4  * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
   5  *
   6  ******************************************************************************/
   7 #include <drv_types.h>
   8 #include <rtw_debug.h>
   9
  10 static u8 P802_1H_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0xf8 };
  11 static u8 RFC1042_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0x00 };
  12
  13 static void _init_txservq(struct tx_servq *ptxservq)
  14 {
  15         INIT_LIST_HEAD(&ptxservq->tx_pending);
  16         INIT_LIST_HEAD(&ptxservq->sta_pending.queue);
  17         spin_lock_init(&ptxservq->sta_pending.lock);
  18         ptxservq->qcnt = 0;
  19 }
  20
  21 void _rtw_init_sta_xmit_priv(struct sta_xmit_priv *psta_xmitpriv)
  22 {
  23         memset((unsigned char *)psta_xmitpriv, 0, sizeof(struct sta_xmit_priv));
  24
  25         spin_lock_init(&psta_xmitpriv->lock);
  26
  27         _init_txservq(&psta_xmitpriv->be_q);
  28         _init_txservq(&psta_xmitpriv->bk_q);
  29         _init_txservq(&psta_xmitpriv->vi_q);
  30         _init_txservq(&psta_xmitpriv->vo_q);
  31         INIT_LIST_HEAD(&psta_xmitpriv->legacy_dz);
  32         INIT_LIST_HEAD(&psta_xmitpriv->apsd);
  33 }
  34
  35 s32 _rtw_init_xmit_priv(struct xmit_priv *pxmitpriv, struct adapter *padapter)
  36 {
  37         int i;
  38         struct xmit_buf *pxmitbuf;
  39         struct xmit_frame *pxframe;
  40         signed int      res = _SUCCESS;
  41
  42         spin_lock_init(&pxmitpriv->lock);
  43         spin_lock_init(&pxmitpriv->lock_sctx);
  44         init_completion(&pxmitpriv->xmit_comp);
  45         init_completion(&pxmitpriv->terminate_xmitthread_comp);
  46
  47         /*
  48          * Please insert all the queue initializaiton using _rtw_init_queue below
  49          */
  50
  51         pxmitpriv->adapter = padapter;
  52
  53         INIT_LIST_HEAD(&pxmitpriv->be_pending.queue);
  54         spin_lock_init(&pxmitpriv->be_pending.lock);
  55         INIT_LIST_HEAD(&pxmitpriv->bk_pending.queue);
  56         spin_lock_init(&pxmitpriv->bk_pending.lock);
  57         INIT_LIST_HEAD(&pxmitpriv->vi_pending.queue);
  58         spin_lock_init(&pxmitpriv->vi_pending.lock);
  59         INIT_LIST_HEAD(&pxmitpriv->vo_pending.queue);
  60         spin_lock_init(&pxmitpriv->vo_pending.lock);
  61         INIT_LIST_HEAD(&pxmitpriv->bm_pending.queue);
  62         spin_lock_init(&pxmitpriv->bm_pending.lock);
  63
  64         INIT_LIST_HEAD(&pxmitpriv->free_xmit_queue.queue);
  65         spin_lock_init(&pxmitpriv->free_xmit_queue.lock);
  66
  67         /*
  68          * Please allocate memory with the sz = (struct xmit_frame) * NR_XMITFRAME,
  69          * and initialize free_xmit_frame below.
  70          * Please also apply  free_txobj to link_up all the xmit_frames...
  71          */
  72
  73         pxmitpriv->pallocated_frame_buf = vzalloc(NR_XMITFRAME * sizeof(struct xmit_frame) + 4);
  74
  75         if (!pxmitpriv->pallocated_frame_buf) {
  76                 pxmitpriv->pxmit_frame_buf = NULL;
  77                 res = _FAIL;
  78                 goto exit;
  79         }
  80         pxmitpriv->pxmit_frame_buf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->pallocated_frame_buf), 4);
  81
  82         pxframe = (struct xmit_frame *) pxmitpriv->pxmit_frame_buf;
  83
  84         for (i = 0; i < NR_XMITFRAME; i++) {
  85                 INIT_LIST_HEAD(&pxframe->list);
  86
  87                 pxframe->padapter = padapter;
  88                 pxframe->frame_tag = NULL_FRAMETAG;
  89
  90                 pxframe->pkt = NULL;
  91
  92                 pxframe->buf_addr = NULL;
  93                 pxframe->pxmitbuf = NULL;
  94
  95                 list_add_tail(&pxframe->list,
  96                               &pxmitpriv->free_xmit_queue.queue);
  97
  98                 pxframe++;
  99         }
 100
 101         pxmitpriv->free_xmitframe_cnt = NR_XMITFRAME;
 102
 103         pxmitpriv->frag_len = MAX_FRAG_THRESHOLD;
 104
 105         /* init xmit_buf */
 106         INIT_LIST_HEAD(&pxmitpriv->free_xmitbuf_queue.queue);
 107         spin_lock_init(&pxmitpriv->free_xmitbuf_queue.lock);
 108         INIT_LIST_HEAD(&pxmitpriv->pending_xmitbuf_queue.queue);
 109         spin_lock_init(&pxmitpriv->pending_xmitbuf_queue.lock);
 110
 111         pxmitpriv->pallocated_xmitbuf = vzalloc(NR_XMITBUFF * sizeof(struct xmit_buf) + 4);
 112
 113         if (!pxmitpriv->pallocated_xmitbuf) {
 114                 res = _FAIL;
 115                 goto exit;
 116         }
 117
 118         pxmitpriv->pxmitbuf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->pallocated_xmitbuf), 4);
 119
 120         pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmitbuf;
 121
 122         for (i = 0; i < NR_XMITBUFF; i++) {
 123                 INIT_LIST_HEAD(&pxmitbuf->list);
 124
 125                 pxmitbuf->priv_data = NULL;
 126                 pxmitbuf->padapter = padapter;
 127                 pxmitbuf->buf_tag = XMITBUF_DATA;
 128
 129                 /* Tx buf allocation may fail sometimes, so sleep and retry. */
 130                 res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf, (MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ), true);
 131                 if (res == _FAIL) {
 132                         msleep(10);
 133                         res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf, (MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ), true);
 134                         if (res == _FAIL)
 135                                 goto exit;
 136                 }
 137
 138                 pxmitbuf->phead = pxmitbuf->pbuf;
 139                 pxmitbuf->pend = pxmitbuf->pbuf + MAX_XMITBUF_SZ;
 140                 pxmitbuf->len = 0;
 141                 pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
 142
 143                 pxmitbuf->flags = XMIT_VO_QUEUE;
 144
 145                 list_add_tail(&pxmitbuf->list,
 146                               &pxmitpriv->free_xmitbuf_queue.queue);
 147                 #ifdef DBG_XMIT_BUF
 148                 pxmitbuf->no = i;
 149                 #endif
 150
 151                 pxmitbuf++;
 152         }
 153
 154         pxmitpriv->free_xmitbuf_cnt = NR_XMITBUFF;
 155
 156         /* init xframe_ext queue,  the same count as extbuf  */
 157         INIT_LIST_HEAD(&pxmitpriv->free_xframe_ext_queue.queue);
 158         spin_lock_init(&pxmitpriv->free_xframe_ext_queue.lock);
 159
 160         pxmitpriv->xframe_ext_alloc_addr = vzalloc(NR_XMIT_EXTBUFF * sizeof(struct xmit_frame) + 4);
 161
 162         if (!pxmitpriv->xframe_ext_alloc_addr) {
 163                 pxmitpriv->xframe_ext = NULL;
 164                 res = _FAIL;
 165                 goto exit;
 166         }
 167         pxmitpriv->xframe_ext = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->xframe_ext_alloc_addr), 4);
 168         pxframe = (struct xmit_frame *)pxmitpriv->xframe_ext;
 169
 170         for (i = 0; i < NR_XMIT_EXTBUFF; i++) {
 171                 INIT_LIST_HEAD(&pxframe->list);
 172
 173                 pxframe->padapter = padapter;
 174                 pxframe->frame_tag = NULL_FRAMETAG;
 175
 176                 pxframe->pkt = NULL;
 177
 178                 pxframe->buf_addr = NULL;
 179                 pxframe->pxmitbuf = NULL;
 180
 181                 pxframe->ext_tag = 1;
 182
 183                 list_add_tail(&pxframe->list,
 184                               &pxmitpriv->free_xframe_ext_queue.queue);
 185
 186                 pxframe++;
 187         }
 188         pxmitpriv->free_xframe_ext_cnt = NR_XMIT_EXTBUFF;
 189
 190         /*  Init xmit extension buff */
 191         INIT_LIST_HEAD(&pxmitpriv->free_xmit_extbuf_queue.queue);
 192         spin_lock_init(&pxmitpriv->free_xmit_extbuf_queue.lock);
 193
 194         pxmitpriv->pallocated_xmit_extbuf = vzalloc(NR_XMIT_EXTBUFF * sizeof(struct xmit_buf) + 4);
 195
 196         if (!pxmitpriv->pallocated_xmit_extbuf) {
 197                 res = _FAIL;
 198                 goto exit;
 199         }
 200
 201         pxmitpriv->pxmit_extbuf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->pallocated_xmit_extbuf), 4);
 202
 203         pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmit_extbuf;
 204
 205         for (i = 0; i < NR_XMIT_EXTBUFF; i++) {
 206                 INIT_LIST_HEAD(&pxmitbuf->list);
 207
 208                 pxmitbuf->priv_data = NULL;
 209                 pxmitbuf->padapter = padapter;
 210                 pxmitbuf->buf_tag = XMITBUF_MGNT;
 211
 212                 res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf, MAX_XMIT_EXTBUF_SZ + XMITBUF_ALIGN_SZ, true);
 213                 if (res == _FAIL) {
 214                         res = _FAIL;
 215                         goto exit;
 216                 }
 217
 218                 pxmitbuf->phead = pxmitbuf->pbuf;
 219                 pxmitbuf->pend = pxmitbuf->pbuf + MAX_XMIT_EXTBUF_SZ;
 220                 pxmitbuf->len = 0;
 221                 pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
 222
 223                 list_add_tail(&pxmitbuf->list,
 224                               &pxmitpriv->free_xmit_extbuf_queue.queue);
 225                 #ifdef DBG_XMIT_BUF_EXT
 226                 pxmitbuf->no = i;
 227                 #endif
 228                 pxmitbuf++;
 229         }
 230
 231         pxmitpriv->free_xmit_extbuf_cnt = NR_XMIT_EXTBUFF;
 232
 233         for (i = 0; i < CMDBUF_MAX; i++) {
 234                 pxmitbuf = &pxmitpriv->pcmd_xmitbuf[i];
 235                 if (pxmitbuf) {
 236                         INIT_LIST_HEAD(&pxmitbuf->list);
 237
 238                         pxmitbuf->priv_data = NULL;
 239                         pxmitbuf->padapter = padapter;
 240                         pxmitbuf->buf_tag = XMITBUF_CMD;
 241
 242                         res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf, MAX_CMDBUF_SZ+XMITBUF_ALIGN_SZ, true);
 243                         if (res == _FAIL) {
 244                                 res = _FAIL;
 245                                 goto exit;
 246                         }
 247
 248                         pxmitbuf->phead = pxmitbuf->pbuf;
 249                         pxmitbuf->pend = pxmitbuf->pbuf + MAX_CMDBUF_SZ;
 250                         pxmitbuf->len = 0;
 251                         pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
 252                         pxmitbuf->alloc_sz = MAX_CMDBUF_SZ+XMITBUF_ALIGN_SZ;
 253                 }
 254         }
 255
 256         res = rtw_alloc_hwxmits(padapter);
 257         if (res == _FAIL)
 258                 goto exit;
 259         rtw_init_hwxmits(pxmitpriv->hwxmits, pxmitpriv->hwxmit_entry);
 260
 261         for (i = 0; i < 4; i++)
 262                 pxmitpriv->wmm_para_seq[i] = i;
 263
 264         pxmitpriv->ack_tx = false;
 265         mutex_init(&pxmitpriv->ack_tx_mutex);
 266         rtw_sctx_init(&pxmitpriv->ack_tx_ops, 0);
 267
 268         rtw_hal_init_xmit_priv(padapter);
 269
 270 exit:
 271         return res;
 272 }
 273
 274 void _rtw_free_xmit_priv(struct xmit_priv *pxmitpriv)
 275 {
 276         int i;
 277         struct adapter *padapter = pxmitpriv->adapter;
 278         struct xmit_frame       *pxmitframe = (struct xmit_frame *) pxmitpriv->pxmit_frame_buf;
 279         struct xmit_buf *pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmitbuf;
 280
 281         rtw_hal_free_xmit_priv(padapter);
 282
 283         if (!pxmitpriv->pxmit_frame_buf)
 284                 return;
 285
 286         for (i = 0; i < NR_XMITFRAME; i++) {
 287                 rtw_os_xmit_complete(padapter, pxmitframe);
 288
 289                 pxmitframe++;
 290         }
 291
 292         for (i = 0; i < NR_XMITBUFF; i++) {
 293                 rtw_os_xmit_resource_free(padapter, pxmitbuf, (MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ), true);
 294
 295                 pxmitbuf++;
 296         }
 297
 298         vfree(pxmitpriv->pallocated_frame_buf);
 299         vfree(pxmitpriv->pallocated_xmitbuf);
 300
 301         /* free xframe_ext queue,  the same count as extbuf  */
 302         pxmitframe = (struct xmit_frame *)pxmitpriv->xframe_ext;
 303         if (pxmitframe) {
 304                 for (i = 0; i < NR_XMIT_EXTBUFF; i++) {
 305                         rtw_os_xmit_complete(padapter, pxmitframe);
 306                         pxmitframe++;
 307                 }
 308         }
 309
 310         vfree(pxmitpriv->xframe_ext_alloc_addr);
 311
 312         /*  free xmit extension buff */
 313         pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmit_extbuf;
 314         for (i = 0; i < NR_XMIT_EXTBUFF; i++) {
 315                 rtw_os_xmit_resource_free(padapter, pxmitbuf, (MAX_XMIT_EXTBUF_SZ + XMITBUF_ALIGN_SZ), true);
 316
 317                 pxmitbuf++;
 318         }
 319
 320         vfree(pxmitpriv->pallocated_xmit_extbuf);
 321
 322         for (i = 0; i < CMDBUF_MAX; i++) {
 323                 pxmitbuf = &pxmitpriv->pcmd_xmitbuf[i];
 324                 if (pxmitbuf)
 325                         rtw_os_xmit_resource_free(padapter, pxmitbuf, MAX_CMDBUF_SZ+XMITBUF_ALIGN_SZ, true);
 326         }
 327
 328         rtw_free_hwxmits(padapter);
 329
 330         mutex_destroy(&pxmitpriv->ack_tx_mutex);
 331 }
 332
 333 u8 query_ra_short_GI(struct sta_info *psta)
 334 {
 335         u8 sgi = false, sgi_20m = false, sgi_40m = false;
 336
 337         sgi_20m = psta->htpriv.sgi_20m;
 338         sgi_40m = psta->htpriv.sgi_40m;
 339
 340         switch (psta->bw_mode) {
 341         case CHANNEL_WIDTH_40:
 342                 sgi = sgi_40m;
 343                 break;
 344         case CHANNEL_WIDTH_20:
 345         default:
 346                 sgi = sgi_20m;
 347                 break;
 348         }
 349
 350         return sgi;
 351 }
 352
 353 static void update_attrib_vcs_info(struct adapter *padapter, struct xmit_frame *pxmitframe)
 354 {
 355         u32 sz;
 356         struct pkt_attrib       *pattrib = &pxmitframe->attrib;
 357         /* struct sta_info *psta = pattrib->psta; */
 358         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
 359         struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
 360
 361         if (pattrib->nr_frags != 1)
 362                 sz = padapter->xmitpriv.frag_len;
 363         else /* no frag */
 364                 sz = pattrib->last_txcmdsz;
 365
 366         /*  (1) RTS_Threshold is compared to the MPDU, not MSDU. */
 367         /*  (2) If there are more than one frag in  this MSDU, only the first frag uses protection frame. */
 368         /* Other fragments are protected by previous fragment. */
 369         /* So we only need to check the length of first fragment. */
 370         if (pmlmeext->cur_wireless_mode < WIRELESS_11_24N  || padapter->registrypriv.wifi_spec) {
 371                 if (sz > padapter->registrypriv.rts_thresh) {
 372                         pattrib->vcs_mode = RTS_CTS;
 373                 } else {
 374                         if (pattrib->rtsen)
 375                                 pattrib->vcs_mode = RTS_CTS;
 376                         else if (pattrib->cts2self)
 377                                 pattrib->vcs_mode = CTS_TO_SELF;
 378                         else
 379                                 pattrib->vcs_mode = NONE_VCS;
 380                 }
 381         } else {
 382                 while (true) {
 383                         /* IOT action */
 384                         if ((pmlmeinfo->assoc_AP_vendor == HT_IOT_PEER_ATHEROS) && (pattrib->ampdu_en == true) &&
 385                                 (padapter->securitypriv.dot11PrivacyAlgrthm == _AES_)) {
 386                                 pattrib->vcs_mode = CTS_TO_SELF;
 387                                 break;
 388                         }
 389
 390                         /* check ERP protection */
 391                         if (pattrib->rtsen || pattrib->cts2self) {
 392                                 if (pattrib->rtsen)
 393                                         pattrib->vcs_mode = RTS_CTS;
 394                                 else if (pattrib->cts2self)
 395                                         pattrib->vcs_mode = CTS_TO_SELF;
 396
 397                                 break;
 398                         }
 399
 400                         /* check HT op mode */
 401                         if (pattrib->ht_en) {
 402                                 u8 HTOpMode = pmlmeinfo->HT_protection;
 403
 404                                 if ((pmlmeext->cur_bwmode && (HTOpMode == 2 || HTOpMode == 3)) ||
 405                                         (!pmlmeext->cur_bwmode && HTOpMode == 3)) {
 406                                         pattrib->vcs_mode = RTS_CTS;
 407                                         break;
 408                                 }
 409                         }
 410
 411                         /* check rts */
 412                         if (sz > padapter->registrypriv.rts_thresh) {
 413                                 pattrib->vcs_mode = RTS_CTS;
 414                                 break;
 415                         }
 416
 417                         /* to do list: check MIMO power save condition. */
 418
 419                         /* check AMPDU aggregation for TXOP */
 420                         if (pattrib->ampdu_en == true) {
 421                                 pattrib->vcs_mode = RTS_CTS;
 422                                 break;
 423                         }
 424
 425                         pattrib->vcs_mode = NONE_VCS;
 426                         break;
 427                 }
 428         }
 429
 430         /* for debug : force driver control vrtl_carrier_sense. */
 431         if (padapter->driver_vcs_en == 1)
 432                 pattrib->vcs_mode = padapter->driver_vcs_type;
 433 }
 434
 435 static void update_attrib_phy_info(struct adapter *padapter, struct pkt_attrib *pattrib, struct sta_info *psta)
 436 {
 437         struct mlme_ext_priv *mlmeext = &padapter->mlmeextpriv;
 438
 439         pattrib->rtsen = psta->rtsen;
 440         pattrib->cts2self = psta->cts2self;
 441
 442         pattrib->mdata = 0;
 443         pattrib->eosp = 0;
 444         pattrib->triggered = 0;
 445         pattrib->ampdu_spacing = 0;
 446
 447         /* qos_en, ht_en, init rate, , bw, ch_offset, sgi */
 448         pattrib->qos_en = psta->qos_option;
 449
 450         pattrib->raid = psta->raid;
 451
 452         pattrib->bwmode = min(mlmeext->cur_bwmode, psta->bw_mode);
 453
 454         pattrib->sgi = query_ra_short_GI(psta);
 455
 456         pattrib->ldpc = psta->ldpc;
 457         pattrib->stbc = psta->stbc;
 458
 459         pattrib->ht_en = psta->htpriv.ht_option;
 460         pattrib->ch_offset = psta->htpriv.ch_offset;
 461         pattrib->ampdu_en = false;
 462
 463         if (padapter->driver_ampdu_spacing != 0xFF) /* driver control AMPDU Density for peer sta's rx */
 464                 pattrib->ampdu_spacing = padapter->driver_ampdu_spacing;
 465         else
 466                 pattrib->ampdu_spacing = psta->htpriv.rx_ampdu_min_spacing;
 467
 468         pattrib->retry_ctrl = false;
 469 }
 470
 471 static s32 update_attrib_sec_info(struct adapter *padapter, struct pkt_attrib *pattrib, struct sta_info *psta)
 472 {
 473         signed int res = _SUCCESS;
 474         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 475         struct security_priv *psecuritypriv = &padapter->securitypriv;
 476         signed int bmcast = IS_MCAST(pattrib->ra);
 477
 478         memset(pattrib->dot118021x_UncstKey.skey,  0, 16);
 479         memset(pattrib->dot11tkiptxmickey.skey,  0, 16);
 480         pattrib->mac_id = psta->mac_id;
 481
 482         if (psta->ieee8021x_blocked == true) {
 483                 pattrib->encrypt = 0;
 484
 485                 if ((pattrib->ether_type != 0x888e) && (check_fwstate(pmlmepriv, WIFI_MP_STATE) == false)) {
 486                         res = _FAIL;
 487                         goto exit;
 488                 }
 489         } else {
 490                 GET_ENCRY_ALGO(psecuritypriv, psta, pattrib->encrypt, bmcast);
 491
 492                 switch (psecuritypriv->dot11AuthAlgrthm) {
 493                 case dot11AuthAlgrthm_Open:
 494                 case dot11AuthAlgrthm_Shared:
 495                 case dot11AuthAlgrthm_Auto:
 496                         pattrib->key_idx = (u8)psecuritypriv->dot11PrivacyKeyIndex;
 497                         break;
 498                 case dot11AuthAlgrthm_8021X:
 499                         if (bmcast)
 500                                 pattrib->key_idx = (u8)psecuritypriv->dot118021XGrpKeyid;
 501                         else
 502                                 pattrib->key_idx = 0;
 503                         break;
 504                 default:
 505                         pattrib->key_idx = 0;
 506                         break;
 507                 }
 508
 509                 /* For WPS 1.0 WEP, driver should not encrypt EAPOL Packet for WPS handshake. */
 510                 if (((pattrib->encrypt == _WEP40_) || (pattrib->encrypt == _WEP104_)) && (pattrib->ether_type == 0x888e))
 511                         pattrib->encrypt = _NO_PRIVACY_;
 512         }
 513
 514         switch (pattrib->encrypt) {
 515         case _WEP40_:
 516         case _WEP104_:
 517                 pattrib->iv_len = 4;
 518                 pattrib->icv_len = 4;
 519                 WEP_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
 520                 break;
 521
 522         case _TKIP_:
 523                 pattrib->iv_len = 8;
 524                 pattrib->icv_len = 4;
 525
 526                 if (psecuritypriv->busetkipkey == _FAIL) {
 527                         res = _FAIL;
 528                         goto exit;
 529                 }
 530
 531                 if (bmcast)
 532                         TKIP_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
 533                 else
 534                         TKIP_IV(pattrib->iv, psta->dot11txpn, 0);
 535
 536                 memcpy(pattrib->dot11tkiptxmickey.skey, psta->dot11tkiptxmickey.skey, 16);
 537
 538                 break;
 539
 540         case _AES_:
 541
 542                 pattrib->iv_len = 8;
 543                 pattrib->icv_len = 8;
 544
 545                 if (bmcast)
 546                         AES_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
 547                 else
 548                         AES_IV(pattrib->iv, psta->dot11txpn, 0);
 549
 550                 break;
 551
 552         default:
 553                 pattrib->iv_len = 0;
 554                 pattrib->icv_len = 0;
 555                 break;
 556         }
 557
 558         if (pattrib->encrypt > 0)
 559                 memcpy(pattrib->dot118021x_UncstKey.skey, psta->dot118021x_UncstKey.skey, 16);
 560
 561         if (pattrib->encrypt &&
 562                 ((padapter->securitypriv.sw_encrypt) || (!psecuritypriv->hw_decrypted)))
 563                 pattrib->bswenc = true;
 564         else
 565                 pattrib->bswenc = false;
 566
 567 exit:
 568
 569         return res;
 570 }
 571
 572 u8 qos_acm(u8 acm_mask, u8 priority)
 573 {
 574         switch (priority) {
 575         case 0:
 576         case 3:
 577                 if (acm_mask & BIT(1))
 578                         priority = 1;
 579                 break;
 580         case 1:
 581         case 2:
 582                 break;
 583         case 4:
 584         case 5:
 585                 if (acm_mask & BIT(2))
 586                         priority = 0;
 587                 break;
 588         case 6:
 589         case 7:
 590                 if (acm_mask & BIT(3))
 591                         priority = 5;
 592                 break;
 593         default:
 594                 break;
 595         }
 596
 597         return priority;
 598 }
 599
 600 static void set_qos(struct pkt_file *ppktfile, struct pkt_attrib *pattrib)
 601 {
 602         struct ethhdr etherhdr;
 603         struct iphdr ip_hdr;
 604         s32 UserPriority = 0;
 605
 606         _rtw_open_pktfile(ppktfile->pkt, ppktfile);
 607         _rtw_pktfile_read(ppktfile, (unsigned char *)&etherhdr, ETH_HLEN);
 608
 609         /*  get UserPriority from IP hdr */
 610         if (pattrib->ether_type == 0x0800) {
 611                 _rtw_pktfile_read(ppktfile, (u8 *)&ip_hdr, sizeof(ip_hdr));
 612                 UserPriority = ip_hdr.tos >> 5;
 613         }
 614         pattrib->priority = UserPriority;
 615         pattrib->hdrlen = WLAN_HDR_A3_QOS_LEN;
 616         pattrib->subtype = WIFI_QOS_DATA_TYPE;
 617 }
 618
 619 static s32 update_attrib(struct adapter *padapter, struct sk_buff *pkt, struct pkt_attrib *pattrib)
 620 {
 621         struct pkt_file pktfile;
 622         struct sta_info *psta = NULL;
 623         struct ethhdr etherhdr;
 624
 625         signed int bmcast;
 626         struct sta_priv *pstapriv = &padapter->stapriv;
 627         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 628         struct qos_priv *pqospriv = &pmlmepriv->qospriv;
 629         signed int res = _SUCCESS;
 630
 631         _rtw_open_pktfile(pkt, &pktfile);
 632         _rtw_pktfile_read(&pktfile, (u8 *)&etherhdr, ETH_HLEN);
 633
 634         pattrib->ether_type = ntohs(etherhdr.h_proto);
 635
 636         memcpy(pattrib->dst, &etherhdr.h_dest, ETH_ALEN);
 637         memcpy(pattrib->src, &etherhdr.h_source, ETH_ALEN);
 638
 639         if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true) ||
 640                 (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true)) {
 641                 memcpy(pattrib->ra, pattrib->dst, ETH_ALEN);
 642                 memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
 643         } else if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) {
 644                 memcpy(pattrib->ra, get_bssid(pmlmepriv), ETH_ALEN);
 645                 memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
 646         } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
 647                 memcpy(pattrib->ra, pattrib->dst, ETH_ALEN);
 648                 memcpy(pattrib->ta, get_bssid(pmlmepriv), ETH_ALEN);
 649         }
 650
 651         pattrib->pktlen = pktfile.pkt_len;
 652
 653         if (pattrib->ether_type == ETH_P_IP) {
 654                 /*  The following is for DHCP and ARP packet, we use cck1M to tx these packets and let LPS awake some time */
 655                 /*  to prevent DHCP protocol fail */
 656
 657                 u8 tmp[24];
 658
 659                 _rtw_pktfile_read(&pktfile, &tmp[0], 24);
 660
 661                 pattrib->dhcp_pkt = 0;
 662                 if (pktfile.pkt_len > 282) {/* MINIMUM_DHCP_PACKET_SIZE) { */
 663                         if (pattrib->ether_type == ETH_P_IP) {/*  IP header */
 664                                 if (((tmp[21] == 68) && (tmp[23] == 67)) ||
 665                                         ((tmp[21] == 67) && (tmp[23] == 68))) {
 666                                         /*  68 : UDP BOOTP client */
 667                                         /*  67 : UDP BOOTP server */
 668                                         pattrib->dhcp_pkt = 1;
 669                                 }
 670                         }
 671                 }
 672
 673                 /* for parsing ICMP pakcets */
 674                 {
 675                         struct iphdr *piphdr = (struct iphdr *)tmp;
 676
 677                         pattrib->icmp_pkt = 0;
 678                         if (piphdr->protocol == 0x1) /*  protocol type in ip header 0x1 is ICMP */
 679                                 pattrib->icmp_pkt = 1;
 680                 }
 681         } else if (pattrib->ether_type == 0x888e) {
 682                 netdev_dbg(padapter->pnetdev, "send eapol packet\n");
 683         }
 684
 685         if ((pattrib->ether_type == 0x888e) || (pattrib->dhcp_pkt == 1))
 686                 rtw_set_scan_deny(padapter, 3000);
 687
 688         /*  If EAPOL , ARP , OR DHCP packet, driver must be in active mode. */
 689         if (pattrib->icmp_pkt == 1)
 690                 rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_LEAVE, 1);
 691         else if (pattrib->dhcp_pkt == 1)
 692                 rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_SPECIAL_PACKET, 1);
 693
 694         bmcast = IS_MCAST(pattrib->ra);
 695
 696         /*  get sta_info */
 697         if (bmcast) {
 698                 psta = rtw_get_bcmc_stainfo(padapter);
 699         } else {
 700                 psta = rtw_get_stainfo(pstapriv, pattrib->ra);
 701                 if (!psta)      { /*  if we cannot get psta => drop the pkt */
 702                         res = _FAIL;
 703                         goto exit;
 704                 } else if ((check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) && (!(psta->state & _FW_LINKED))) {
 705                         res = _FAIL;
 706                         goto exit;
 707                 }
 708         }
 709
 710         if (!psta) {
 711                 /*  if we cannot get psta => drop the pkt */
 712                 res = _FAIL;
 713                 goto exit;
 714         }
 715
 716         if (!(psta->state & _FW_LINKED))
 717                 return _FAIL;
 718
 719         /* TODO:_lock */
 720         if (update_attrib_sec_info(padapter, pattrib, psta) == _FAIL) {
 721                 res = _FAIL;
 722                 goto exit;
 723         }
 724
 725         update_attrib_phy_info(padapter, pattrib, psta);
 726
 727         pattrib->psta = psta;
 728         /* TODO:_unlock */
 729
 730         pattrib->pctrl = 0;
 731
 732         pattrib->ack_policy = 0;
 733         /*  get ether_hdr_len */
 734         pattrib->pkt_hdrlen = ETH_HLEN;/* pattrib->ether_type == 0x8100) ? (14 + 4): 14; vlan tag */
 735
 736         pattrib->hdrlen = WLAN_HDR_A3_LEN;
 737         pattrib->subtype = WIFI_DATA_TYPE;
 738         pattrib->priority = 0;
 739
 740         if (check_fwstate(pmlmepriv, WIFI_AP_STATE|WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE)) {
 741                 if (pattrib->qos_en)
 742                         set_qos(&pktfile, pattrib);
 743         } else {
 744                 if (pqospriv->qos_option) {
 745                         set_qos(&pktfile, pattrib);
 746
 747                         if (pmlmepriv->acm_mask != 0)
 748                                 pattrib->priority = qos_acm(pmlmepriv->acm_mask, pattrib->priority);
 749                 }
 750         }
 751
 752         /* pattrib->priority = 5; force to used VI queue, for testing */
 753
 754 exit:
 755         return res;
 756 }
 757
 758 static s32 xmitframe_addmic(struct adapter *padapter, struct xmit_frame *pxmitframe)
 759 {
 760         signed int                      curfragnum, length;
 761         u8 *pframe, *payload, mic[8];
 762         struct mic_data micdata;
 763         struct pkt_attrib *pattrib = &pxmitframe->attrib;
 764         struct security_priv *psecuritypriv = &padapter->securitypriv;
 765         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
 766         u8 priority[4] = {0x0, 0x0, 0x0, 0x0};
 767         u8 hw_hdr_offset = 0;
 768         signed int bmcst = IS_MCAST(pattrib->ra);
 769
 770         hw_hdr_offset = TXDESC_OFFSET;
 771
 772         if (pattrib->encrypt == _TKIP_) {
 773                 /* encode mic code */
 774                 {
 775                         u8 null_key[16] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
 776
 777                         pframe = pxmitframe->buf_addr + hw_hdr_offset;
 778
 779                         if (bmcst) {
 780                                 if (!memcmp(psecuritypriv->dot118021XGrptxmickey[psecuritypriv->dot118021XGrpKeyid].skey, null_key, 16))
 781                                         return _FAIL;
 782                                 /* start to calculate the mic code */
 783                                 rtw_secmicsetkey(&micdata, psecuritypriv->dot118021XGrptxmickey[psecuritypriv->dot118021XGrpKeyid].skey);
 784                         } else {
 785                                 if (!memcmp(&pattrib->dot11tkiptxmickey.skey[0], null_key, 16))
 786                                         return _FAIL;
 787                                 /* start to calculate the mic code */
 788                                 rtw_secmicsetkey(&micdata, &pattrib->dot11tkiptxmickey.skey[0]);
 789                         }
 790
 791                         if (pframe[1]&1) {   /* ToDS == 1 */
 792                                 rtw_secmicappend(&micdata, &pframe[16], 6);  /* DA */
 793                                 if (pframe[1]&2)  /* From Ds == 1 */
 794                                         rtw_secmicappend(&micdata, &pframe[24], 6);
 795                                 else
 796                                         rtw_secmicappend(&micdata, &pframe[10], 6);
 797                         } else {        /* ToDS == 0 */
 798                                 rtw_secmicappend(&micdata, &pframe[4], 6);   /* DA */
 799                                 if (pframe[1]&2)  /* From Ds == 1 */
 800                                         rtw_secmicappend(&micdata, &pframe[16], 6);
 801                                 else
 802                                         rtw_secmicappend(&micdata, &pframe[10], 6);
 803                         }
 804
 805                         if (pattrib->qos_en)
 806                                 priority[0] = (u8)pxmitframe->attrib.priority;
 807
 808                         rtw_secmicappend(&micdata, &priority[0], 4);
 809
 810                         payload = pframe;
 811
 812                         for (curfragnum = 0; curfragnum < pattrib->nr_frags; curfragnum++) {
 813                                 payload = (u8 *)round_up((SIZE_PTR)(payload), 4);
 814                                 payload = payload+pattrib->hdrlen+pattrib->iv_len;
 815
 816                                 if ((curfragnum+1) == pattrib->nr_frags) {
 817                                         length = pattrib->last_txcmdsz-pattrib->hdrlen-pattrib->iv_len-((pattrib->bswenc) ? pattrib->icv_len : 0);
 818                                         rtw_secmicappend(&micdata, payload, length);
 819                                         payload = payload+length;
 820                                 } else {
 821                                         length = pxmitpriv->frag_len-pattrib->hdrlen-pattrib->iv_len-((pattrib->bswenc) ? pattrib->icv_len : 0);
 822                                         rtw_secmicappend(&micdata, payload, length);
 823                                         payload = payload+length+pattrib->icv_len;
 824                                 }
 825                         }
 826                         rtw_secgetmic(&micdata, &mic[0]);
 827                         /* add mic code  and add the mic code length in last_txcmdsz */
 828
 829                         memcpy(payload, &mic[0], 8);
 830                         pattrib->last_txcmdsz += 8;
 831                         }
 832         }
 833         return _SUCCESS;
 834 }
 835
 836 static s32 xmitframe_swencrypt(struct adapter *padapter, struct xmit_frame *pxmitframe)
 837 {
 838         struct  pkt_attrib       *pattrib = &pxmitframe->attrib;
 839
 840         if (pattrib->bswenc) {
 841                 switch (pattrib->encrypt) {
 842                 case _WEP40_:
 843                 case _WEP104_:
 844                         rtw_wep_encrypt(padapter, (u8 *)pxmitframe);
 845                         break;
 846                 case _TKIP_:
 847                         rtw_tkip_encrypt(padapter, (u8 *)pxmitframe);
 848                         break;
 849                 case _AES_:
 850                         rtw_aes_encrypt(padapter, (u8 *)pxmitframe);
 851                         break;
 852                 default:
 853                                 break;
 854                 }
 855         }
 856
 857         return _SUCCESS;
 858 }
 859
 860 s32 rtw_make_wlanhdr(struct adapter *padapter, u8 *hdr, struct pkt_attrib *pattrib)
 861 {
 862         u16 *qc;
 863
 864         struct ieee80211_hdr *pwlanhdr = (struct ieee80211_hdr *)hdr;
 865         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 866         struct qos_priv *pqospriv = &pmlmepriv->qospriv;
 867         u8 qos_option = false;
 868         signed int res = _SUCCESS;
 869         __le16 *fctrl = &pwlanhdr->frame_control;
 870
 871         memset(hdr, 0, WLANHDR_OFFSET);
 872
 873         SetFrameSubType(fctrl, pattrib->subtype);
 874
 875         if (pattrib->subtype & WIFI_DATA_TYPE) {
 876                 if (check_fwstate(pmlmepriv,  WIFI_STATION_STATE) == true) {
 877                         /* to_ds = 1, fr_ds = 0; */
 878
 879                         {
 880                                 /*  1.Data transfer to AP */
 881                                 /*  2.Arp pkt will relayed by AP */
 882                                 SetToDs(fctrl);
 883                                 memcpy(pwlanhdr->addr1, get_bssid(pmlmepriv), ETH_ALEN);
 884                                 memcpy(pwlanhdr->addr2, pattrib->src, ETH_ALEN);
 885                                 memcpy(pwlanhdr->addr3, pattrib->dst, ETH_ALEN);
 886                         }
 887
 888                         if (pqospriv->qos_option)
 889                                 qos_option = true;
 890                 } else if (check_fwstate(pmlmepriv,  WIFI_AP_STATE) == true) {
 891                         /* to_ds = 0, fr_ds = 1; */
 892                         SetFrDs(fctrl);
 893                         memcpy(pwlanhdr->addr1, pattrib->dst, ETH_ALEN);
 894                         memcpy(pwlanhdr->addr2, get_bssid(pmlmepriv), ETH_ALEN);
 895                         memcpy(pwlanhdr->addr3, pattrib->src, ETH_ALEN);
 896
 897                         if (pattrib->qos_en)
 898                                 qos_option = true;
 899                 } else if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true) ||
 900                 (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true)) {
 901                         memcpy(pwlanhdr->addr1, pattrib->dst, ETH_ALEN);
 902                         memcpy(pwlanhdr->addr2, pattrib->src, ETH_ALEN);
 903                         memcpy(pwlanhdr->addr3, get_bssid(pmlmepriv), ETH_ALEN);
 904
 905                         if (pattrib->qos_en)
 906                                 qos_option = true;
 907                 } else {
 908                         res = _FAIL;
 909                         goto exit;
 910                 }
 911
 912                 if (pattrib->mdata)
 913                         SetMData(fctrl);
 914
 915                 if (pattrib->encrypt)
 916                         SetPrivacy(fctrl);
 917
 918                 if (qos_option) {
 919                         qc = (unsigned short *)(hdr + pattrib->hdrlen - 2);
 920
 921                         if (pattrib->priority)
 922                                 SetPriority(qc, pattrib->priority);
 923
 924                         SetEOSP(qc, pattrib->eosp);
 925
 926                         SetAckpolicy(qc, pattrib->ack_policy);
 927                 }
 928
 929                 /* TODO: fill HT Control Field */
 930
 931                 /* Update Seq Num will be handled by f/w */
 932                 {
 933                         struct sta_info *psta;
 934
 935                         psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
 936                         if (pattrib->psta != psta)
 937                                 return _FAIL;
 938
 939                         if (!psta)
 940                                 return _FAIL;
 941
 942                         if (!(psta->state & _FW_LINKED))
 943                                 return _FAIL;
 944
 945                         if (psta) {
 946                                 psta->sta_xmitpriv.txseq_tid[pattrib->priority]++;
 947                                 psta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 0xFFF;
 948                                 pattrib->seqnum = psta->sta_xmitpriv.txseq_tid[pattrib->priority];
 949
 950                                 SetSeqNum(hdr, pattrib->seqnum);
 951
 952                                 /* check if enable ampdu */
 953                                 if (pattrib->ht_en && psta->htpriv.ampdu_enable)
 954                                         if (psta->htpriv.agg_enable_bitmap & BIT(pattrib->priority))
 955                                                 pattrib->ampdu_en = true;
 956
 957                                 /* re-check if enable ampdu by BA_starting_seqctrl */
 958                                 if (pattrib->ampdu_en == true) {
 959                                         u16 tx_seq;
 960
 961                                         tx_seq = psta->BA_starting_seqctrl[pattrib->priority & 0x0f];
 962
 963                                         /* check BA_starting_seqctrl */
 964                                         if (SN_LESS(pattrib->seqnum, tx_seq)) {
 965                                                 pattrib->ampdu_en = false;/* AGG BK */
 966                                         } else if (SN_EQUAL(pattrib->seqnum, tx_seq)) {
 967                                                 psta->BA_starting_seqctrl[pattrib->priority & 0x0f] = (tx_seq+1)&0xfff;
 968
 969                                                 pattrib->ampdu_en = true;/* AGG EN */
 970                                         } else {
 971                                                 psta->BA_starting_seqctrl[pattrib->priority & 0x0f] = (pattrib->seqnum+1)&0xfff;
 972                                                 pattrib->ampdu_en = true;/* AGG EN */
 973                                         }
 974                                 }
 975                         }
 976                 }
 977         } else {
 978         }
 979
 980 exit:
 981         return res;
 982 }
 983
 984 s32 rtw_txframes_pending(struct adapter *padapter)
 985 {
 986         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
 987
 988         return ((!list_empty(&pxmitpriv->be_pending.queue)) ||
 989                          (!list_empty(&pxmitpriv->bk_pending.queue)) ||
 990                          (!list_empty(&pxmitpriv->vi_pending.queue)) ||
 991                          (!list_empty(&pxmitpriv->vo_pending.queue)));
 992 }
 993
 994 /*
 995  * Calculate wlan 802.11 packet MAX size from pkt_attrib
 996  * This function doesn't consider fragment case
 997  */
 998 u32 rtw_calculate_wlan_pkt_size_by_attribue(struct pkt_attrib *pattrib)
 999 {
1000         u32 len = 0;
1001
1002         len = pattrib->hdrlen + pattrib->iv_len; /*  WLAN Header and IV */
1003         len += SNAP_SIZE + sizeof(u16); /*  LLC */
1004         len += pattrib->pktlen;
1005         if (pattrib->encrypt == _TKIP_)
1006                 len += 8; /*  MIC */
1007         len += ((pattrib->bswenc) ? pattrib->icv_len : 0); /*  ICV */
1008
1009         return len;
1010 }
1011
1012 /*
1013  * This sub-routine will perform all the following:
1014  * 1. remove 802.3 header.
1015  * 2. create wlan_header, based on the info in pxmitframe
1016  * 3. append sta's iv/ext-iv
1017  * 4. append LLC
1018  * 5. move frag chunk from pframe to pxmitframe->mem
1019  * 6. apply sw-encrypt, if necessary.
1020  */
1021 s32 rtw_xmitframe_coalesce(struct adapter *padapter, struct sk_buff *pkt, struct xmit_frame *pxmitframe)
1022 {
1023         struct pkt_file pktfile;
1024
1025         s32 frg_inx, frg_len, mpdu_len, llc_sz, mem_sz;
1026
1027         SIZE_PTR addr;
1028
1029         u8 *pframe, *mem_start;
1030         u8 hw_hdr_offset;
1031
1032         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
1033
1034         struct pkt_attrib       *pattrib = &pxmitframe->attrib;
1035
1036         u8 *pbuf_start;
1037
1038         s32 bmcst = IS_MCAST(pattrib->ra);
1039         s32 res = _SUCCESS;
1040
1041         if (!pxmitframe->buf_addr)
1042                 return _FAIL;
1043
1044         pbuf_start = pxmitframe->buf_addr;
1045
1046         hw_hdr_offset = TXDESC_OFFSET;
1047         mem_start = pbuf_start +        hw_hdr_offset;
1048
1049         if (rtw_make_wlanhdr(padapter, mem_start, pattrib) == _FAIL) {
1050                 res = _FAIL;
1051                 goto exit;
1052         }
1053
1054         _rtw_open_pktfile(pkt, &pktfile);
1055         _rtw_pktfile_read(&pktfile, NULL, pattrib->pkt_hdrlen);
1056
1057         frg_inx = 0;
1058         frg_len = pxmitpriv->frag_len - 4;/* 2346-4 = 2342 */
1059
1060         while (1) {
1061                 llc_sz = 0;
1062
1063                 mpdu_len = frg_len;
1064
1065                 pframe = mem_start;
1066
1067                 SetMFrag(mem_start);
1068
1069                 pframe += pattrib->hdrlen;
1070                 mpdu_len -= pattrib->hdrlen;
1071
1072                 /* adding icv, if necessary... */
1073                 if (pattrib->iv_len) {
1074                         memcpy(pframe, pattrib->iv, pattrib->iv_len);
1075
1076                         pframe += pattrib->iv_len;
1077
1078                         mpdu_len -= pattrib->iv_len;
1079                 }
1080
1081                 if (frg_inx == 0) {
1082                         llc_sz = rtw_put_snap(pframe, pattrib->ether_type);
1083                         pframe += llc_sz;
1084                         mpdu_len -= llc_sz;
1085                 }
1086
1087                 if ((pattrib->icv_len > 0) && (pattrib->bswenc))
1088                         mpdu_len -= pattrib->icv_len;
1089
1090                 if (bmcst) {
1091                         /*  don't do fragment to broadcast/multicast packets */
1092                         mem_sz = _rtw_pktfile_read(&pktfile, pframe, pattrib->pktlen);
1093                 } else {
1094                         mem_sz = _rtw_pktfile_read(&pktfile, pframe, mpdu_len);
1095                 }
1096
1097                 pframe += mem_sz;
1098
1099                 if ((pattrib->icv_len > 0) && (pattrib->bswenc)) {
1100                         memcpy(pframe, pattrib->icv, pattrib->icv_len);
1101                         pframe += pattrib->icv_len;
1102                 }
1103
1104                 frg_inx++;
1105
1106                 if (bmcst || (rtw_endofpktfile(&pktfile) == true)) {
1107                         pattrib->nr_frags = frg_inx;
1108
1109                         pattrib->last_txcmdsz = pattrib->hdrlen + pattrib->iv_len + ((pattrib->nr_frags == 1) ? llc_sz:0) +
1110                                         ((pattrib->bswenc) ? pattrib->icv_len : 0) + mem_sz;
1111
1112                         ClearMFrag(mem_start);
1113
1114                         break;
1115                 }
1116
1117                 addr = (SIZE_PTR)(pframe);
1118
1119                 mem_start = (unsigned char *)round_up(addr, 4) + hw_hdr_offset;
1120                 memcpy(mem_start, pbuf_start + hw_hdr_offset, pattrib->hdrlen);
1121         }
1122
1123         if (xmitframe_addmic(padapter, pxmitframe) == _FAIL) {
1124                 res = _FAIL;
1125                 goto exit;
1126         }
1127
1128         xmitframe_swencrypt(padapter, pxmitframe);
1129
1130         if (bmcst == false)
1131                 update_attrib_vcs_info(padapter, pxmitframe);
1132         else
1133                 pattrib->vcs_mode = NONE_VCS;
1134
1135 exit:
1136         return res;
1137 }
1138
1139 /* broadcast or multicast management pkt use BIP, unicast management pkt use CCMP encryption */
1140 s32 rtw_mgmt_xmitframe_coalesce(struct adapter *padapter, struct sk_buff *pkt, struct xmit_frame *pxmitframe)
1141 {
1142         u8 *pframe, *mem_start = NULL, *tmp_buf = NULL;
1143         u8 subtype;
1144         struct sta_info *psta = NULL;
1145         struct pkt_attrib *pattrib = &pxmitframe->attrib;
1146         s32 bmcst = IS_MCAST(pattrib->ra);
1147         u8 *BIP_AAD = NULL;
1148         u8 *MGMT_body = NULL;
1149
1150         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1151         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1152         struct ieee80211_hdr    *pwlanhdr;
1153         u8 MME[_MME_IE_LENGTH_];
1154         u32 ori_len;
1155
1156         mem_start = pframe = (u8 *)(pxmitframe->buf_addr) + TXDESC_OFFSET;
1157         pwlanhdr = (struct ieee80211_hdr *)pframe;
1158
1159         ori_len = BIP_AAD_SIZE+pattrib->pktlen;
1160         tmp_buf = BIP_AAD = rtw_zmalloc(ori_len);
1161         subtype = GetFrameSubType(pframe); /* bit(7)~bit(2) */
1162
1163         if (!BIP_AAD)
1164                 return _FAIL;
1165
1166         spin_lock_bh(&padapter->security_key_mutex);
1167
1168         /* only support station mode */
1169         if (!check_fwstate(pmlmepriv, WIFI_STATION_STATE) || !check_fwstate(pmlmepriv, _FW_LINKED))
1170                 goto xmitframe_coalesce_success;
1171
1172         /* IGTK key is not install, it may not support 802.11w */
1173         if (!padapter->securitypriv.binstallBIPkey)
1174                 goto xmitframe_coalesce_success;
1175
1176         /* station mode doesn't need TX BIP, just ready the code */
1177         if (bmcst) {
1178                 int frame_body_len;
1179                 u8 mic[16];
1180
1181                 memset(MME, 0, 18);
1182
1183                 /* other types doesn't need the BIP */
1184                 if (GetFrameSubType(pframe) != WIFI_DEAUTH && GetFrameSubType(pframe) != WIFI_DISASSOC)
1185                         goto xmitframe_coalesce_fail;
1186
1187                 MGMT_body = pframe + sizeof(struct ieee80211_hdr_3addr);
1188                 pframe += pattrib->pktlen;
1189
1190                 /* octent 0 and 1 is key index , BIP keyid is 4 or 5, LSB only need octent 0 */
1191                 MME[0] = padapter->securitypriv.dot11wBIPKeyid;
1192                 /* copy packet number */
1193                 memcpy(&MME[2], &pmlmeext->mgnt_80211w_IPN, 6);
1194                 /* increase the packet number */
1195                 pmlmeext->mgnt_80211w_IPN++;
1196
1197                 /* add MME IE with MIC all zero, MME string doesn't include element id and length */
1198                 pframe = rtw_set_ie(pframe, WLAN_EID_MMIE, 16,
1199                                     MME, &pattrib->pktlen);
1200                 pattrib->last_txcmdsz = pattrib->pktlen;
1201                 /*  total frame length - header length */
1202                 frame_body_len = pattrib->pktlen - sizeof(struct ieee80211_hdr_3addr);
1203
1204                 /* conscruct AAD, copy frame control field */
1205                 memcpy(BIP_AAD, &pwlanhdr->frame_control, 2);
1206                 ClearRetry(BIP_AAD);
1207                 ClearPwrMgt(BIP_AAD);
1208                 ClearMData(BIP_AAD);
1209                 /* conscruct AAD, copy address 1 to address 3 */
1210                 memcpy(BIP_AAD+2, pwlanhdr->addr1, 18);
1211                 /* copy management fram body */
1212                 memcpy(BIP_AAD+BIP_AAD_SIZE, MGMT_body, frame_body_len);
1213                 /* calculate mic */
1214                 if (omac1_aes_128(padapter->securitypriv.dot11wBIPKey[padapter->securitypriv.dot11wBIPKeyid].skey
1215                         , BIP_AAD, BIP_AAD_SIZE+frame_body_len, mic))
1216                         goto xmitframe_coalesce_fail;
1217
1218                 /* copy right BIP mic value, total is 128bits, we use the 0~63 bits */
1219                 memcpy(pframe-8, mic, 8);
1220         } else { /* unicast mgmt frame TX */
1221                 /* start to encrypt mgmt frame */
1222                 if (subtype == WIFI_DEAUTH || subtype == WIFI_DISASSOC ||
1223                         subtype == WIFI_REASSOCREQ || subtype == WIFI_ACTION) {
1224                         if (pattrib->psta)
1225                                 psta = pattrib->psta;
1226                         else
1227                                 psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
1228
1229                         if (!psta)
1230                                 goto xmitframe_coalesce_fail;
1231
1232                         if (!(psta->state & _FW_LINKED) || !pxmitframe->buf_addr)
1233                                 goto xmitframe_coalesce_fail;
1234
1235                         /* according 802.11-2012 standard, these five types are not robust types */
1236                         if (subtype == WIFI_ACTION &&
1237                         (pframe[WLAN_HDR_A3_LEN] == RTW_WLAN_CATEGORY_PUBLIC ||
1238                         pframe[WLAN_HDR_A3_LEN] == RTW_WLAN_CATEGORY_HT ||
1239                         pframe[WLAN_HDR_A3_LEN] == RTW_WLAN_CATEGORY_UNPROTECTED_WNM ||
1240                         pframe[WLAN_HDR_A3_LEN] == RTW_WLAN_CATEGORY_SELF_PROTECTED  ||
1241                         pframe[WLAN_HDR_A3_LEN] == RTW_WLAN_CATEGORY_P2P))
1242                                 goto xmitframe_coalesce_fail;
1243                         /* before encrypt dump the management packet content */
1244                         if (pattrib->encrypt > 0)
1245                                 memcpy(pattrib->dot118021x_UncstKey.skey, psta->dot118021x_UncstKey.skey, 16);
1246                         /* bakeup original management packet */
1247                         memcpy(tmp_buf, pframe, pattrib->pktlen);
1248                         /* move to data portion */
1249                         pframe += pattrib->hdrlen;
1250
1251                         /* 802.11w unicast management packet must be _AES_ */
1252                         pattrib->iv_len = 8;
1253                         /* it's MIC of AES */
1254                         pattrib->icv_len = 8;
1255
1256                         switch (pattrib->encrypt) {
1257                         case _AES_:
1258                                         /* set AES IV header */
1259                                         AES_IV(pattrib->iv, psta->dot11wtxpn, 0);
1260                                 break;
1261                         default:
1262                                 goto xmitframe_coalesce_fail;
1263                         }
1264                         /* insert iv header into management frame */
1265                         memcpy(pframe, pattrib->iv, pattrib->iv_len);
1266                         pframe += pattrib->iv_len;
1267                         /* copy mgmt data portion after CCMP header */
1268                         memcpy(pframe, tmp_buf+pattrib->hdrlen, pattrib->pktlen-pattrib->hdrlen);
1269                         /* move pframe to end of mgmt pkt */
1270                         pframe += pattrib->pktlen-pattrib->hdrlen;
1271                         /* add 8 bytes CCMP IV header to length */
1272                         pattrib->pktlen += pattrib->iv_len;
1273                         if ((pattrib->icv_len > 0) && (pattrib->bswenc)) {
1274                                 memcpy(pframe, pattrib->icv, pattrib->icv_len);
1275                                 pframe += pattrib->icv_len;
1276                         }
1277                         /* add 8 bytes MIC */
1278                         pattrib->pktlen += pattrib->icv_len;
1279                         /* set final tx command size */
1280                         pattrib->last_txcmdsz = pattrib->pktlen;
1281
1282                         /* set protected bit must be beofre SW encrypt */
1283                         SetPrivacy(mem_start);
1284                         /* software encrypt */
1285                         xmitframe_swencrypt(padapter, pxmitframe);
1286                 }
1287         }
1288
1289 xmitframe_coalesce_success:
1290         spin_unlock_bh(&padapter->security_key_mutex);
1291         kfree(BIP_AAD);
1292         return _SUCCESS;
1293
1294 xmitframe_coalesce_fail:
1295         spin_unlock_bh(&padapter->security_key_mutex);
1296         kfree(BIP_AAD);
1297         return _FAIL;
1298 }
1299
1300 /* Logical Link Control(LLC) SubNetwork Attachment Point(SNAP) header
1301  * IEEE LLC/SNAP header contains 8 octets
1302  * First 3 octets comprise the LLC portion
1303  * SNAP portion, 5 octets, is divided into two fields:
1304  *Organizationally Unique Identifier(OUI), 3 octets,
1305  *type, defined by that organization, 2 octets.
1306  */
1307 s32 rtw_put_snap(u8 *data, u16 h_proto)
1308 {
1309         struct ieee80211_snap_hdr *snap;
1310         u8 *oui;
1311
1312         snap = (struct ieee80211_snap_hdr *)data;
1313         snap->dsap = 0xaa;
1314         snap->ssap = 0xaa;
1315         snap->ctrl = 0x03;
1316
1317         if (h_proto == 0x8137 || h_proto == 0x80f3)
1318                 oui = P802_1H_OUI;
1319         else
1320                 oui = RFC1042_OUI;
1321
1322         snap->oui[0] = oui[0];
1323         snap->oui[1] = oui[1];
1324         snap->oui[2] = oui[2];
1325
1326         *(__be16 *)(data + SNAP_SIZE) = htons(h_proto);
1327
1328         return SNAP_SIZE + sizeof(u16);
1329 }
1330
1331 void rtw_update_protection(struct adapter *padapter, u8 *ie, uint ie_len)
1332 {
1333         uint    protection;
1334         u8 *perp;
1335         signed int       erp_len;
1336         struct  xmit_priv *pxmitpriv = &padapter->xmitpriv;
1337         struct  registry_priv *pregistrypriv = &padapter->registrypriv;
1338
1339         switch (pxmitpriv->vcs_setting) {
1340         case DISABLE_VCS:
1341                 pxmitpriv->vcs = NONE_VCS;
1342                 break;
1343
1344         case ENABLE_VCS:
1345                 break;
1346
1347         case AUTO_VCS:
1348         default:
1349                 perp = rtw_get_ie(ie, WLAN_EID_ERP_INFO, &erp_len, ie_len);
1350                 if (!perp) {
1351                         pxmitpriv->vcs = NONE_VCS;
1352                 } else {
1353                         protection = (*(perp + 2)) & BIT(1);
1354                         if (protection) {
1355                                 if (pregistrypriv->vcs_type == RTS_CTS)
1356                                         pxmitpriv->vcs = RTS_CTS;
1357                                 else
1358                                         pxmitpriv->vcs = CTS_TO_SELF;
1359                         } else {
1360                                 pxmitpriv->vcs = NONE_VCS;
1361                         }
1362                 }
1363
1364                 break;
1365         }
1366 }
1367
1368 void rtw_count_tx_stats(struct adapter *padapter, struct xmit_frame *pxmitframe, int sz)
1369 {
1370         struct sta_info *psta = NULL;
1371         struct stainfo_stats *pstats = NULL;
1372         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
1373         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1374         u8 pkt_num = 1;
1375
1376         if ((pxmitframe->frame_tag&0x0f) == DATA_FRAMETAG) {
1377                 pkt_num = pxmitframe->agg_num;
1378
1379                 pmlmepriv->LinkDetectInfo.NumTxOkInPeriod += pkt_num;
1380
1381                 pxmitpriv->tx_pkts += pkt_num;
1382
1383                 pxmitpriv->tx_bytes += sz;
1384
1385                 psta = pxmitframe->attrib.psta;
1386                 if (psta) {
1387                         pstats = &psta->sta_stats;
1388
1389                         pstats->tx_pkts += pkt_num;
1390
1391                         pstats->tx_bytes += sz;
1392                 }
1393         }
1394 }
1395
1396 static struct xmit_buf *__rtw_alloc_cmd_xmitbuf(struct xmit_priv *pxmitpriv,
1397                 enum cmdbuf_type buf_type)
1398 {
1399         struct xmit_buf *pxmitbuf =  NULL;
1400
1401         pxmitbuf = &pxmitpriv->pcmd_xmitbuf[buf_type];
1402         if (pxmitbuf) {
1403                 pxmitbuf->priv_data = NULL;
1404
1405                 pxmitbuf->len = 0;
1406                 pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
1407                 pxmitbuf->agg_num = 0;
1408                 pxmitbuf->pg_num = 0;
1409
1410                 if (pxmitbuf->sctx)
1411                         rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_ALLOC);
1412         }
1413
1414         return pxmitbuf;
1415 }
1416
1417 struct xmit_frame *__rtw_alloc_cmdxmitframe(struct xmit_priv *pxmitpriv,
1418                 enum cmdbuf_type buf_type)
1419 {
1420         struct xmit_frame               *pcmdframe;
1421         struct xmit_buf         *pxmitbuf;
1422
1423         pcmdframe = rtw_alloc_xmitframe(pxmitpriv);
1424         if (!pcmdframe)
1425                 return NULL;
1426
1427         pxmitbuf = __rtw_alloc_cmd_xmitbuf(pxmitpriv, buf_type);
1428         if (!pxmitbuf) {
1429                 rtw_free_xmitframe(pxmitpriv, pcmdframe);
1430                 return NULL;
1431         }
1432
1433         pcmdframe->frame_tag = MGNT_FRAMETAG;
1434
1435         pcmdframe->pxmitbuf = pxmitbuf;
1436
1437         pcmdframe->buf_addr = pxmitbuf->pbuf;
1438
1439         pxmitbuf->priv_data = pcmdframe;
1440
1441         return pcmdframe;
1442 }
1443
1444 struct xmit_buf *rtw_alloc_xmitbuf_ext(struct xmit_priv *pxmitpriv)
1445 {
1446         unsigned long irqL;
1447         struct xmit_buf *pxmitbuf =  NULL;
1448         struct list_head *plist, *phead;
1449         struct __queue *pfree_queue = &pxmitpriv->free_xmit_extbuf_queue;
1450
1451         spin_lock_irqsave(&pfree_queue->lock, irqL);
1452
1453         if (list_empty(&pfree_queue->queue)) {
1454                 pxmitbuf = NULL;
1455         } else {
1456                 phead = get_list_head(pfree_queue);
1457
1458                 plist = get_next(phead);
1459
1460                 pxmitbuf = container_of(plist, struct xmit_buf, list);
1461
1462                 list_del_init(&pxmitbuf->list);
1463         }
1464
1465         if (pxmitbuf) {
1466                 pxmitpriv->free_xmit_extbuf_cnt--;
1467
1468                 pxmitbuf->priv_data = NULL;
1469
1470                 pxmitbuf->len = 0;
1471                 pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
1472                 pxmitbuf->agg_num = 1;
1473
1474                 if (pxmitbuf->sctx)
1475                         rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_ALLOC);
1476         }
1477
1478         spin_unlock_irqrestore(&pfree_queue->lock, irqL);
1479
1480         return pxmitbuf;
1481 }
1482
1483 s32 rtw_free_xmitbuf_ext(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
1484 {
1485         unsigned long irqL;
1486         struct __queue *pfree_queue = &pxmitpriv->free_xmit_extbuf_queue;
1487
1488         if (!pxmitbuf)
1489                 return _FAIL;
1490
1491         spin_lock_irqsave(&pfree_queue->lock, irqL);
1492
1493         list_del_init(&pxmitbuf->list);
1494
1495         list_add_tail(&pxmitbuf->list, get_list_head(pfree_queue));
1496         pxmitpriv->free_xmit_extbuf_cnt++;
1497
1498         spin_unlock_irqrestore(&pfree_queue->lock, irqL);
1499
1500         return _SUCCESS;
1501 }
1502
1503 struct xmit_buf *rtw_alloc_xmitbuf(struct xmit_priv *pxmitpriv)
1504 {
1505         unsigned long irqL;
1506         struct xmit_buf *pxmitbuf =  NULL;
1507         struct list_head *plist, *phead;
1508         struct __queue *pfree_xmitbuf_queue = &pxmitpriv->free_xmitbuf_queue;
1509
1510         spin_lock_irqsave(&pfree_xmitbuf_queue->lock, irqL);
1511
1512         if (list_empty(&pfree_xmitbuf_queue->queue)) {
1513                 pxmitbuf = NULL;
1514         } else {
1515                 phead = get_list_head(pfree_xmitbuf_queue);
1516
1517                 plist = get_next(phead);
1518
1519                 pxmitbuf = container_of(plist, struct xmit_buf, list);
1520
1521                 list_del_init(&pxmitbuf->list);
1522         }
1523
1524         if (pxmitbuf) {
1525                 pxmitpriv->free_xmitbuf_cnt--;
1526
1527                 pxmitbuf->priv_data = NULL;
1528
1529                 pxmitbuf->len = 0;
1530                 pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
1531                 pxmitbuf->agg_num = 0;
1532                 pxmitbuf->pg_num = 0;
1533
1534                 if (pxmitbuf->sctx)
1535                         rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_ALLOC);
1536         }
1537
1538         spin_unlock_irqrestore(&pfree_xmitbuf_queue->lock, irqL);
1539
1540         return pxmitbuf;
1541 }
1542
1543 s32 rtw_free_xmitbuf(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
1544 {
1545         unsigned long irqL;
1546         struct __queue *pfree_xmitbuf_queue = &pxmitpriv->free_xmitbuf_queue;
1547
1548         if (!pxmitbuf)
1549                 return _FAIL;
1550
1551         if (pxmitbuf->sctx)
1552                 rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_FREE);
1553
1554         if (pxmitbuf->buf_tag == XMITBUF_CMD) {
1555         } else if (pxmitbuf->buf_tag == XMITBUF_MGNT) {
1556                 rtw_free_xmitbuf_ext(pxmitpriv, pxmitbuf);
1557         } else {
1558                 spin_lock_irqsave(&pfree_xmitbuf_queue->lock, irqL);
1559
1560                 list_del_init(&pxmitbuf->list);
1561
1562                 list_add_tail(&pxmitbuf->list,
1563                               get_list_head(pfree_xmitbuf_queue));
1564
1565                 pxmitpriv->free_xmitbuf_cnt++;
1566                 spin_unlock_irqrestore(&pfree_xmitbuf_queue->lock, irqL);
1567         }
1568         return _SUCCESS;
1569 }
1570
1571 static void rtw_init_xmitframe(struct xmit_frame *pxframe)
1572 {
1573         if (pxframe) { /* default value setting */
1574                 pxframe->buf_addr = NULL;
1575                 pxframe->pxmitbuf = NULL;
1576
1577                 memset(&pxframe->attrib, 0, sizeof(struct pkt_attrib));
1578
1579                 pxframe->frame_tag = DATA_FRAMETAG;
1580
1581                 pxframe->pg_num = 1;
1582                 pxframe->agg_num = 1;
1583                 pxframe->ack_report = 0;
1584         }
1585 }
1586
1587 /*
1588  * Calling context:
1589  * 1. OS_TXENTRY
1590  * 2. RXENTRY (rx_thread or RX_ISR/RX_CallBack)
1591  *
1592  * If we turn on USE_RXTHREAD, then, no need for critical section.
1593  * Otherwise, we must use _enter/_exit critical to protect free_xmit_queue...
1594  *
1595  * Must be very, very cautious...
1596  */
1597 struct xmit_frame *rtw_alloc_xmitframe(struct xmit_priv *pxmitpriv)/* _queue *pfree_xmit_queue) */
1598 {
1599         /*
1600          *      Please remember to use all the osdep_service api,
1601          *      and lock/unlock or _enter/_exit critical to protect
1602          *      pfree_xmit_queue
1603          */
1604
1605         struct xmit_frame *pxframe = NULL;
1606         struct list_head *plist, *phead;
1607         struct __queue *pfree_xmit_queue = &pxmitpriv->free_xmit_queue;
1608
1609         spin_lock_bh(&pfree_xmit_queue->lock);
1610
1611         if (list_empty(&pfree_xmit_queue->queue)) {
1612                 pxframe =  NULL;
1613         } else {
1614                 phead = get_list_head(pfree_xmit_queue);
1615
1616                 plist = get_next(phead);
1617
1618                 pxframe = container_of(plist, struct xmit_frame, list);
1619
1620                 list_del_init(&pxframe->list);
1621                 pxmitpriv->free_xmitframe_cnt--;
1622         }
1623
1624         spin_unlock_bh(&pfree_xmit_queue->lock);
1625
1626         rtw_init_xmitframe(pxframe);
1627         return pxframe;
1628 }
1629
1630 struct xmit_frame *rtw_alloc_xmitframe_ext(struct xmit_priv *pxmitpriv)
1631 {
1632         struct xmit_frame *pxframe = NULL;
1633         struct list_head *plist, *phead;
1634         struct __queue *queue = &pxmitpriv->free_xframe_ext_queue;
1635
1636         spin_lock_bh(&queue->lock);
1637
1638         if (list_empty(&queue->queue)) {
1639                 pxframe =  NULL;
1640         } else {
1641                 phead = get_list_head(queue);
1642                 plist = get_next(phead);
1643                 pxframe = container_of(plist, struct xmit_frame, list);
1644
1645                 list_del_init(&pxframe->list);
1646                 pxmitpriv->free_xframe_ext_cnt--;
1647         }
1648
1649         spin_unlock_bh(&queue->lock);
1650
1651         rtw_init_xmitframe(pxframe);
1652
1653         return pxframe;
1654 }
1655
1656 struct xmit_frame *rtw_alloc_xmitframe_once(struct xmit_priv *pxmitpriv)
1657 {
1658         struct xmit_frame *pxframe = NULL;
1659         u8 *alloc_addr;
1660
1661         alloc_addr = rtw_zmalloc(sizeof(struct xmit_frame) + 4);
1662
1663         if (!alloc_addr)
1664                 goto exit;
1665
1666         pxframe = (struct xmit_frame *)N_BYTE_ALIGMENT((SIZE_PTR)(alloc_addr), 4);
1667         pxframe->alloc_addr = alloc_addr;
1668
1669         pxframe->padapter = pxmitpriv->adapter;
1670         pxframe->frame_tag = NULL_FRAMETAG;
1671
1672         pxframe->pkt = NULL;
1673
1674         pxframe->buf_addr = NULL;
1675         pxframe->pxmitbuf = NULL;
1676
1677         rtw_init_xmitframe(pxframe);
1678
1679 exit:
1680         return pxframe;
1681 }
1682
1683 s32 rtw_free_xmitframe(struct xmit_priv *pxmitpriv, struct xmit_frame *pxmitframe)
1684 {
1685         struct __queue *queue = NULL;
1686         struct adapter *padapter = pxmitpriv->adapter;
1687         struct sk_buff *pndis_pkt = NULL;
1688
1689         if (!pxmitframe)
1690                 goto exit;
1691
1692         if (pxmitframe->pkt) {
1693                 pndis_pkt = pxmitframe->pkt;
1694                 pxmitframe->pkt = NULL;
1695         }
1696
1697         if (pxmitframe->alloc_addr) {
1698                 kfree(pxmitframe->alloc_addr);
1699                 goto check_pkt_complete;
1700         }
1701
1702         if (pxmitframe->ext_tag == 0)
1703                 queue = &pxmitpriv->free_xmit_queue;
1704         else if (pxmitframe->ext_tag == 1)
1705                 queue = &pxmitpriv->free_xframe_ext_queue;
1706         else {
1707         }
1708
1709         spin_lock_bh(&queue->lock);
1710
1711         list_del_init(&pxmitframe->list);
1712         list_add_tail(&pxmitframe->list, get_list_head(queue));
1713         if (pxmitframe->ext_tag == 0)
1714                 pxmitpriv->free_xmitframe_cnt++;
1715         else if (pxmitframe->ext_tag == 1)
1716                 pxmitpriv->free_xframe_ext_cnt++;
1717
1718         spin_unlock_bh(&queue->lock);
1719
1720 check_pkt_complete:
1721
1722         if (pndis_pkt)
1723                 rtw_os_pkt_complete(padapter, pndis_pkt);
1724
1725 exit:
1726         return _SUCCESS;
1727 }
1728
1729 void rtw_free_xmitframe_queue(struct xmit_priv *pxmitpriv, struct __queue *pframequeue)
1730 {
1731         struct list_head *plist, *phead, *tmp;
1732         struct  xmit_frame      *pxmitframe;
1733
1734         spin_lock_bh(&pframequeue->lock);
1735
1736         phead = get_list_head(pframequeue);
1737         list_for_each_safe(plist, tmp, phead) {
1738                 pxmitframe = list_entry(plist, struct xmit_frame, list);
1739
1740                 rtw_free_xmitframe(pxmitpriv, pxmitframe);
1741         }
1742         spin_unlock_bh(&pframequeue->lock);
1743 }
1744
1745 s32 rtw_xmitframe_enqueue(struct adapter *padapter, struct xmit_frame *pxmitframe)
1746 {
1747         if (rtw_xmit_classifier(padapter, pxmitframe) == _FAIL)
1748                 return _FAIL;
1749
1750         return _SUCCESS;
1751 }
1752
1753 struct tx_servq *rtw_get_sta_pending(struct adapter *padapter, struct sta_info *psta, signed int up, u8 *ac)
1754 {
1755         struct tx_servq *ptxservq = NULL;
1756
1757         switch (up) {
1758         case 1:
1759         case 2:
1760                 ptxservq = &psta->sta_xmitpriv.bk_q;
1761                 *(ac) = 3;
1762                 break;
1763
1764         case 4:
1765         case 5:
1766                 ptxservq = &psta->sta_xmitpriv.vi_q;
1767                 *(ac) = 1;
1768                 break;
1769
1770         case 6:
1771         case 7:
1772                 ptxservq = &psta->sta_xmitpriv.vo_q;
1773                 *(ac) = 0;
1774                 break;
1775
1776         case 0:
1777         case 3:
1778         default:
1779                 ptxservq = &psta->sta_xmitpriv.be_q;
1780                 *(ac) = 2;
1781         break;
1782         }
1783
1784         return ptxservq;
1785 }
1786
1787 /*
1788  * Will enqueue pxmitframe to the proper queue,
1789  * and indicate it to xx_pending list.....
1790  */
1791 s32 rtw_xmit_classifier(struct adapter *padapter, struct xmit_frame *pxmitframe)
1792 {
1793         u8 ac_index;
1794         struct sta_info *psta;
1795         struct tx_servq *ptxservq;
1796         struct pkt_attrib       *pattrib = &pxmitframe->attrib;
1797         struct hw_xmit  *phwxmits =  padapter->xmitpriv.hwxmits;
1798         signed int res = _SUCCESS;
1799
1800         psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
1801         if (pattrib->psta != psta)
1802                 return _FAIL;
1803
1804         if (!psta) {
1805                 res = _FAIL;
1806                 goto exit;
1807         }
1808
1809         if (!(psta->state & _FW_LINKED))
1810                 return _FAIL;
1811
1812         ptxservq = rtw_get_sta_pending(padapter, psta, pattrib->priority, (u8 *)(&ac_index));
1813
1814         if (list_empty(&ptxservq->tx_pending))
1815                 list_add_tail(&ptxservq->tx_pending, get_list_head(phwxmits[ac_index].sta_queue));
1816
1817         list_add_tail(&pxmitframe->list, get_list_head(&ptxservq->sta_pending));
1818         ptxservq->qcnt++;
1819         phwxmits[ac_index].accnt++;
1820
1821 exit:
1822
1823         return res;
1824 }
1825
1826 s32 rtw_alloc_hwxmits(struct adapter *padapter)
1827 {
1828         struct hw_xmit *hwxmits;
1829         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
1830
1831         pxmitpriv->hwxmit_entry = HWXMIT_ENTRY;
1832
1833         pxmitpriv->hwxmits = NULL;
1834
1835         pxmitpriv->hwxmits = rtw_zmalloc(sizeof(struct hw_xmit) * pxmitpriv->hwxmit_entry);
1836
1837         if (!pxmitpriv->hwxmits)
1838                 return _FAIL;
1839
1840         hwxmits = pxmitpriv->hwxmits;
1841
1842         if (pxmitpriv->hwxmit_entry == 5) {
1843                 hwxmits[0] .sta_queue = &pxmitpriv->bm_pending;
1844
1845                 hwxmits[1] .sta_queue = &pxmitpriv->vo_pending;
1846
1847                 hwxmits[2] .sta_queue = &pxmitpriv->vi_pending;
1848
1849                 hwxmits[3] .sta_queue = &pxmitpriv->bk_pending;
1850
1851                 hwxmits[4] .sta_queue = &pxmitpriv->be_pending;
1852         } else if (pxmitpriv->hwxmit_entry == 4) {
1853                 hwxmits[0] .sta_queue = &pxmitpriv->vo_pending;
1854
1855                 hwxmits[1] .sta_queue = &pxmitpriv->vi_pending;
1856
1857                 hwxmits[2] .sta_queue = &pxmitpriv->be_pending;
1858
1859                 hwxmits[3] .sta_queue = &pxmitpriv->bk_pending;
1860         } else {
1861         }
1862
1863         return _SUCCESS;
1864 }
1865
1866 void rtw_free_hwxmits(struct adapter *padapter)
1867 {
1868         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
1869
1870         kfree(pxmitpriv->hwxmits);
1871 }
1872
1873 void rtw_init_hwxmits(struct hw_xmit *phwxmit, signed int entry)
1874 {
1875         signed int i;
1876
1877         for (i = 0; i < entry; i++, phwxmit++)
1878                 phwxmit->accnt = 0;
1879 }
1880
1881 u32 rtw_get_ff_hwaddr(struct xmit_frame *pxmitframe)
1882 {
1883         u32 addr;
1884         struct pkt_attrib *pattrib = &pxmitframe->attrib;
1885
1886         switch (pattrib->qsel) {
1887         case 0:
1888         case 3:
1889                 addr = BE_QUEUE_INX;
1890                 break;
1891         case 1:
1892         case 2:
1893                 addr = BK_QUEUE_INX;
1894                 break;
1895         case 4:
1896         case 5:
1897                 addr = VI_QUEUE_INX;
1898                 break;
1899         case 6:
1900         case 7:
1901                 addr = VO_QUEUE_INX;
1902                 break;
1903         case 0x10:
1904                 addr = BCN_QUEUE_INX;
1905                 break;
1906         case 0x11:/* BC/MC in PS (HIQ) */
1907                 addr = HIGH_QUEUE_INX;
1908                 break;
1909         case 0x12:
1910         default:
1911                 addr = MGT_QUEUE_INX;
1912                 break;
1913         }
1914
1915         return addr;
1916 }
1917
1918 static void do_queue_select(struct adapter      *padapter, struct pkt_attrib *pattrib)
1919 {
1920         u8 qsel;
1921
1922         qsel = pattrib->priority;
1923
1924         pattrib->qsel = qsel;
1925 }
1926
1927 /*
1928  * The main transmit(tx) entry
1929  *
1930  * Return
1931  *1     enqueue
1932  *0     success, hardware will handle this xmit frame(packet)
1933  *<0    fail
1934  */
1935 s32 rtw_xmit(struct adapter *padapter, struct sk_buff **ppkt)
1936 {
1937         static unsigned long start;
1938         static u32 drop_cnt;
1939
1940         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
1941         struct xmit_frame *pxmitframe = NULL;
1942
1943         s32 res;
1944
1945         if (start == 0)
1946                 start = jiffies;
1947
1948         pxmitframe = rtw_alloc_xmitframe(pxmitpriv);
1949
1950         if (jiffies_to_msecs(jiffies - start) > 2000) {
1951                 start = jiffies;
1952                 drop_cnt = 0;
1953         }
1954
1955         if (!pxmitframe) {
1956                 drop_cnt++;
1957                 return -1;
1958         }
1959
1960         res = update_attrib(padapter, *ppkt, &pxmitframe->attrib);
1961
1962         if (res == _FAIL) {
1963                 rtw_free_xmitframe(pxmitpriv, pxmitframe);
1964                 return -1;
1965         }
1966         pxmitframe->pkt = *ppkt;
1967
1968         do_queue_select(padapter, &pxmitframe->attrib);
1969
1970         spin_lock_bh(&pxmitpriv->lock);
1971         if (xmitframe_enqueue_for_sleeping_sta(padapter, pxmitframe) == true) {
1972                 spin_unlock_bh(&pxmitpriv->lock);
1973                 return 1;
1974         }
1975         spin_unlock_bh(&pxmitpriv->lock);
1976
1977         /* pre_xmitframe */
1978         if (rtw_hal_xmit(padapter, pxmitframe) == false)
1979                 return 1;
1980
1981         return 0;
1982 }
1983
1984 #define RTW_HIQ_FILTER_ALLOW_ALL 0
1985 #define RTW_HIQ_FILTER_ALLOW_SPECIAL 1
1986 #define RTW_HIQ_FILTER_DENY_ALL 2
1987
1988 inline bool xmitframe_hiq_filter(struct xmit_frame *xmitframe)
1989 {
1990         bool allow = false;
1991         struct adapter *adapter = xmitframe->padapter;
1992         struct registry_priv *registry = &adapter->registrypriv;
1993
1994         if (registry->hiq_filter == RTW_HIQ_FILTER_ALLOW_SPECIAL) {
1995                 struct pkt_attrib *attrib = &xmitframe->attrib;
1996
1997                 if (attrib->ether_type == 0x0806 ||
1998                     attrib->ether_type == 0x888e ||
1999                     attrib->dhcp_pkt
2000                 )
2001                         allow = true;
2002
2003         } else if (registry->hiq_filter == RTW_HIQ_FILTER_ALLOW_ALL)
2004                 allow = true;
2005         else if (registry->hiq_filter == RTW_HIQ_FILTER_DENY_ALL) {
2006         } else
2007                 rtw_warn_on(1);
2008
2009         return allow;
2010 }
2011
2012 signed int xmitframe_enqueue_for_sleeping_sta(struct adapter *padapter, struct xmit_frame *pxmitframe)
2013 {
2014         signed int ret = false;
2015         struct sta_info *psta = NULL;
2016         struct sta_priv *pstapriv = &padapter->stapriv;
2017         struct pkt_attrib *pattrib = &pxmitframe->attrib;
2018         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2019         signed int bmcst = IS_MCAST(pattrib->ra);
2020         bool update_tim = false;
2021
2022         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == false)
2023                 return ret;
2024         psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
2025         if (pattrib->psta != psta)
2026                 return false;
2027
2028         if (!psta)
2029                 return false;
2030
2031         if (!(psta->state & _FW_LINKED))
2032                 return false;
2033
2034         if (pattrib->triggered == 1) {
2035                 if (bmcst && xmitframe_hiq_filter(pxmitframe))
2036                         pattrib->qsel = 0x11;/* HIQ */
2037
2038                 return ret;
2039         }
2040
2041         if (bmcst) {
2042                 spin_lock_bh(&psta->sleep_q.lock);
2043
2044                 if (pstapriv->sta_dz_bitmap) { /* if anyone sta is in ps mode */
2045                         /* pattrib->qsel = 0x11;HIQ */
2046
2047                         list_del_init(&pxmitframe->list);
2048
2049                         list_add_tail(&pxmitframe->list, get_list_head(&psta->sleep_q));
2050
2051                         psta->sleepq_len++;
2052
2053                         if (!(pstapriv->tim_bitmap & BIT(0)))
2054                                 update_tim = true;
2055
2056                         pstapriv->tim_bitmap |= BIT(0);
2057                         pstapriv->sta_dz_bitmap |= BIT(0);
2058
2059                         if (update_tim)
2060                                 update_beacon(padapter, WLAN_EID_TIM, NULL, true);
2061                         else
2062                                 chk_bmc_sleepq_cmd(padapter);
2063
2064                         ret = true;
2065                 }
2066
2067                 spin_unlock_bh(&psta->sleep_q.lock);
2068
2069                 return ret;
2070         }
2071
2072         spin_lock_bh(&psta->sleep_q.lock);
2073
2074         if (psta->state&WIFI_SLEEP_STATE) {
2075                 u8 wmmps_ac = 0;
2076
2077                 if (pstapriv->sta_dz_bitmap & BIT(psta->aid)) {
2078                         list_del_init(&pxmitframe->list);
2079
2080                         list_add_tail(&pxmitframe->list, get_list_head(&psta->sleep_q));
2081
2082                         psta->sleepq_len++;
2083
2084                         switch (pattrib->priority) {
2085                         case 1:
2086                         case 2:
2087                                 wmmps_ac = psta->uapsd_bk&BIT(0);
2088                                 break;
2089                         case 4:
2090                         case 5:
2091                                 wmmps_ac = psta->uapsd_vi&BIT(0);
2092                                 break;
2093                         case 6:
2094                         case 7:
2095                                 wmmps_ac = psta->uapsd_vo&BIT(0);
2096                                 break;
2097                         case 0:
2098                         case 3:
2099                         default:
2100                                 wmmps_ac = psta->uapsd_be&BIT(0);
2101                                 break;
2102                         }
2103
2104                         if (wmmps_ac)
2105                                 psta->sleepq_ac_len++;
2106
2107                         if (((psta->has_legacy_ac) && (!wmmps_ac)) || ((!psta->has_legacy_ac) && (wmmps_ac))) {
2108                                 if (!(pstapriv->tim_bitmap & BIT(psta->aid)))
2109                                         update_tim = true;
2110
2111                                 pstapriv->tim_bitmap |= BIT(psta->aid);
2112
2113                                 if (update_tim)
2114                                         /* update BCN for TIM IE */
2115                                         update_beacon(padapter, WLAN_EID_TIM, NULL, true);
2116                         }
2117
2118                         ret = true;
2119                 }
2120         }
2121
2122         spin_unlock_bh(&psta->sleep_q.lock);
2123
2124         return ret;
2125 }
2126
2127 static void dequeue_xmitframes_to_sleeping_queue(struct adapter *padapter, struct sta_info *psta, struct __queue *pframequeue)
2128 {
2129         signed int ret;
2130         struct list_head *plist, *phead, *tmp;
2131         u8 ac_index;
2132         struct tx_servq *ptxservq;
2133         struct pkt_attrib       *pattrib;
2134         struct xmit_frame       *pxmitframe;
2135         struct hw_xmit *phwxmits =  padapter->xmitpriv.hwxmits;
2136
2137         phead = get_list_head(pframequeue);
2138         list_for_each_safe(plist, tmp, phead) {
2139                 pxmitframe = list_entry(plist, struct xmit_frame, list);
2140
2141                 pattrib = &pxmitframe->attrib;
2142
2143                 pattrib->triggered = 0;
2144
2145                 ret = xmitframe_enqueue_for_sleeping_sta(padapter, pxmitframe);
2146
2147                 if (true == ret) {
2148                         ptxservq = rtw_get_sta_pending(padapter, psta, pattrib->priority, (u8 *)(&ac_index));
2149
2150                         ptxservq->qcnt--;
2151                         phwxmits[ac_index].accnt--;
2152                 } else {
2153                 }
2154         }
2155 }
2156
2157 void stop_sta_xmit(struct adapter *padapter, struct sta_info *psta)
2158 {
2159         struct sta_info *psta_bmc;
2160         struct sta_xmit_priv *pstaxmitpriv;
2161         struct sta_priv *pstapriv = &padapter->stapriv;
2162         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
2163
2164         pstaxmitpriv = &psta->sta_xmitpriv;
2165
2166         /* for BC/MC Frames */
2167         psta_bmc = rtw_get_bcmc_stainfo(padapter);
2168
2169         spin_lock_bh(&pxmitpriv->lock);
2170
2171         psta->state |= WIFI_SLEEP_STATE;
2172
2173         pstapriv->sta_dz_bitmap |= BIT(psta->aid);
2174
2175         dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->vo_q.sta_pending);
2176         list_del_init(&pstaxmitpriv->vo_q.tx_pending);
2177
2178         dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->vi_q.sta_pending);
2179         list_del_init(&pstaxmitpriv->vi_q.tx_pending);
2180
2181         dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->be_q.sta_pending);
2182         list_del_init(&pstaxmitpriv->be_q.tx_pending);
2183
2184         dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->bk_q.sta_pending);
2185         list_del_init(&pstaxmitpriv->bk_q.tx_pending);
2186
2187         /* for BC/MC Frames */
2188         pstaxmitpriv = &psta_bmc->sta_xmitpriv;
2189         dequeue_xmitframes_to_sleeping_queue(padapter, psta_bmc, &pstaxmitpriv->be_q.sta_pending);
2190         list_del_init(&pstaxmitpriv->be_q.tx_pending);
2191
2192         spin_unlock_bh(&pxmitpriv->lock);
2193 }
2194
2195 void wakeup_sta_to_xmit(struct adapter *padapter, struct sta_info *psta)
2196 {
2197         u8 update_mask = 0, wmmps_ac = 0;
2198         struct sta_info *psta_bmc;
2199         struct list_head *xmitframe_plist, *xmitframe_phead, *tmp;
2200         struct xmit_frame *pxmitframe = NULL;
2201         struct sta_priv *pstapriv = &padapter->stapriv;
2202         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
2203
2204         psta_bmc = rtw_get_bcmc_stainfo(padapter);
2205
2206         spin_lock_bh(&pxmitpriv->lock);
2207
2208         xmitframe_phead = get_list_head(&psta->sleep_q);
2209         list_for_each_safe(xmitframe_plist, tmp, xmitframe_phead) {
2210                 pxmitframe = list_entry(xmitframe_plist, struct xmit_frame,
2211                                         list);
2212
2213                 list_del_init(&pxmitframe->list);
2214
2215                 switch (pxmitframe->attrib.priority) {
2216                 case 1:
2217                 case 2:
2218                         wmmps_ac = psta->uapsd_bk&BIT(1);
2219                         break;
2220                 case 4:
2221                 case 5:
2222                         wmmps_ac = psta->uapsd_vi&BIT(1);
2223                         break;
2224                 case 6:
2225                 case 7:
2226                         wmmps_ac = psta->uapsd_vo&BIT(1);
2227                         break;
2228                 case 0:
2229                 case 3:
2230                 default:
2231                         wmmps_ac = psta->uapsd_be&BIT(1);
2232                         break;
2233                 }
2234
2235                 psta->sleepq_len--;
2236                 if (psta->sleepq_len > 0)
2237                         pxmitframe->attrib.mdata = 1;
2238                 else
2239                         pxmitframe->attrib.mdata = 0;
2240
2241                 if (wmmps_ac) {
2242                         psta->sleepq_ac_len--;
2243                         if (psta->sleepq_ac_len > 0) {
2244                                 pxmitframe->attrib.mdata = 1;
2245                                 pxmitframe->attrib.eosp = 0;
2246                         } else {
2247                                 pxmitframe->attrib.mdata = 0;
2248                                 pxmitframe->attrib.eosp = 1;
2249                         }
2250                 }
2251
2252                 pxmitframe->attrib.triggered = 1;
2253
2254                 rtw_hal_xmitframe_enqueue(padapter, pxmitframe);
2255         }
2256
2257         if (psta->sleepq_len == 0) {
2258                 if (pstapriv->tim_bitmap & BIT(psta->aid))
2259                         update_mask = BIT(0);
2260
2261                 pstapriv->tim_bitmap &= ~BIT(psta->aid);
2262
2263                 if (psta->state&WIFI_SLEEP_STATE)
2264                         psta->state ^= WIFI_SLEEP_STATE;
2265
2266                 if (psta->state & WIFI_STA_ALIVE_CHK_STATE) {
2267                         psta->expire_to = pstapriv->expire_to;
2268                         psta->state ^= WIFI_STA_ALIVE_CHK_STATE;
2269                 }
2270
2271                 pstapriv->sta_dz_bitmap &= ~BIT(psta->aid);
2272         }
2273
2274         /* for BC/MC Frames */
2275         if (!psta_bmc)
2276                 goto _exit;
2277
2278         if ((pstapriv->sta_dz_bitmap&0xfffe) == 0x0) { /* no any sta in ps mode */
2279                 xmitframe_phead = get_list_head(&psta_bmc->sleep_q);
2280                 list_for_each_safe(xmitframe_plist, tmp, xmitframe_phead) {
2281                         pxmitframe = list_entry(xmitframe_plist,
2282                                                 struct xmit_frame, list);
2283
2284                         list_del_init(&pxmitframe->list);
2285
2286                         psta_bmc->sleepq_len--;
2287                         if (psta_bmc->sleepq_len > 0)
2288                                 pxmitframe->attrib.mdata = 1;
2289                         else
2290                                 pxmitframe->attrib.mdata = 0;
2291
2292                         pxmitframe->attrib.triggered = 1;
2293                         rtw_hal_xmitframe_enqueue(padapter, pxmitframe);
2294                 }
2295
2296                 if (psta_bmc->sleepq_len == 0) {
2297                         if (pstapriv->tim_bitmap & BIT(0))
2298                                 update_mask |= BIT(1);
2299
2300                         pstapriv->tim_bitmap &= ~BIT(0);
2301                         pstapriv->sta_dz_bitmap &= ~BIT(0);
2302                 }
2303         }
2304
2305 _exit:
2306
2307         spin_unlock_bh(&pxmitpriv->lock);
2308
2309         if (update_mask)
2310                 update_beacon(padapter, WLAN_EID_TIM, NULL, true);
2311 }
2312
2313 void xmit_delivery_enabled_frames(struct adapter *padapter, struct sta_info *psta)
2314 {
2315         u8 wmmps_ac = 0;
2316         struct list_head *xmitframe_plist, *xmitframe_phead, *tmp;
2317         struct xmit_frame *pxmitframe = NULL;
2318         struct sta_priv *pstapriv = &padapter->stapriv;
2319         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
2320
2321         spin_lock_bh(&pxmitpriv->lock);
2322
2323         xmitframe_phead = get_list_head(&psta->sleep_q);
2324         list_for_each_safe(xmitframe_plist, tmp, xmitframe_phead) {
2325                 pxmitframe = list_entry(xmitframe_plist, struct xmit_frame,
2326                                         list);
2327
2328                 switch (pxmitframe->attrib.priority) {
2329                 case 1:
2330                 case 2:
2331                         wmmps_ac = psta->uapsd_bk&BIT(1);
2332                         break;
2333                 case 4:
2334                 case 5:
2335                         wmmps_ac = psta->uapsd_vi&BIT(1);
2336                         break;
2337                 case 6:
2338                 case 7:
2339                         wmmps_ac = psta->uapsd_vo&BIT(1);
2340                         break;
2341                 case 0:
2342                 case 3:
2343                 default:
2344                         wmmps_ac = psta->uapsd_be&BIT(1);
2345                         break;
2346                 }
2347
2348                 if (!wmmps_ac)
2349                         continue;
2350
2351                 list_del_init(&pxmitframe->list);
2352
2353                 psta->sleepq_len--;
2354                 psta->sleepq_ac_len--;
2355
2356                 if (psta->sleepq_ac_len > 0) {
2357                         pxmitframe->attrib.mdata = 1;
2358                         pxmitframe->attrib.eosp = 0;
2359                 } else {
2360                         pxmitframe->attrib.mdata = 0;
2361                         pxmitframe->attrib.eosp = 1;
2362                 }
2363
2364                 pxmitframe->attrib.triggered = 1;
2365                 rtw_hal_xmitframe_enqueue(padapter, pxmitframe);
2366
2367                 if ((psta->sleepq_ac_len == 0) && (!psta->has_legacy_ac) && (wmmps_ac)) {
2368                         pstapriv->tim_bitmap &= ~BIT(psta->aid);
2369
2370                         update_beacon(padapter, WLAN_EID_TIM, NULL, true);
2371                 }
2372         }
2373
2374         spin_unlock_bh(&pxmitpriv->lock);
2375 }
2376
2377 void enqueue_pending_xmitbuf(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
2378 {
2379         struct __queue *pqueue;
2380         struct adapter *pri_adapter = pxmitpriv->adapter;
2381
2382         pqueue = &pxmitpriv->pending_xmitbuf_queue;
2383
2384         spin_lock_bh(&pqueue->lock);
2385         list_del_init(&pxmitbuf->list);
2386         list_add_tail(&pxmitbuf->list, get_list_head(pqueue));
2387         spin_unlock_bh(&pqueue->lock);
2388
2389         complete(&pri_adapter->xmitpriv.xmit_comp);
2390 }
2391
2392 void enqueue_pending_xmitbuf_to_head(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
2393 {
2394         struct __queue *pqueue;
2395
2396         pqueue = &pxmitpriv->pending_xmitbuf_queue;
2397
2398         spin_lock_bh(&pqueue->lock);
2399         list_del_init(&pxmitbuf->list);
2400         list_add(&pxmitbuf->list, get_list_head(pqueue));
2401         spin_unlock_bh(&pqueue->lock);
2402 }
2403
2404 struct xmit_buf *dequeue_pending_xmitbuf(struct xmit_priv *pxmitpriv)
2405 {
2406         struct xmit_buf *pxmitbuf;
2407         struct __queue *pqueue;
2408
2409         pxmitbuf = NULL;
2410         pqueue = &pxmitpriv->pending_xmitbuf_queue;
2411
2412         spin_lock_bh(&pqueue->lock);
2413
2414         if (!list_empty(&pqueue->queue)) {
2415                 struct list_head *plist, *phead;
2416
2417                 phead = get_list_head(pqueue);
2418                 plist = get_next(phead);
2419                 pxmitbuf = container_of(plist, struct xmit_buf, list);
2420                 list_del_init(&pxmitbuf->list);
2421         }
2422
2423         spin_unlock_bh(&pqueue->lock);
2424
2425         return pxmitbuf;
2426 }
2427
2428 struct xmit_buf *dequeue_pending_xmitbuf_under_survey(struct xmit_priv *pxmitpriv)
2429 {
2430         struct xmit_buf *pxmitbuf;
2431         struct __queue *pqueue;
2432
2433         pxmitbuf = NULL;
2434         pqueue = &pxmitpriv->pending_xmitbuf_queue;
2435
2436         spin_lock_bh(&pqueue->lock);
2437
2438         if (!list_empty(&pqueue->queue)) {
2439                 struct list_head *plist, *phead;
2440                 u8 type;
2441
2442                 phead = get_list_head(pqueue);
2443                 plist = phead;
2444                 do {
2445                         plist = get_next(plist);
2446                         if (plist == phead)
2447                                 break;
2448
2449                         pxmitbuf = container_of(plist, struct xmit_buf, list);
2450
2451                         type = GetFrameSubType(pxmitbuf->pbuf + TXDESC_OFFSET);
2452
2453                         if ((type == WIFI_PROBEREQ) ||
2454                                 (type == WIFI_DATA_NULL) ||
2455                                 (type == WIFI_QOS_DATA_NULL)) {
2456                                 list_del_init(&pxmitbuf->list);
2457                                 break;
2458                         }
2459                         pxmitbuf = NULL;
2460                 } while (1);
2461         }
2462
2463         spin_unlock_bh(&pqueue->lock);
2464
2465         return pxmitbuf;
2466 }
2467
2468 signed int check_pending_xmitbuf(struct xmit_priv *pxmitpriv)
2469 {
2470         struct __queue *pqueue;
2471         signed int      ret = false;
2472
2473         pqueue = &pxmitpriv->pending_xmitbuf_queue;
2474
2475         spin_lock_bh(&pqueue->lock);
2476
2477         if (!list_empty(&pqueue->queue))
2478                 ret = true;
2479
2480         spin_unlock_bh(&pqueue->lock);
2481
2482         return ret;
2483 }
2484
2485 int rtw_xmit_thread(void *context)
2486 {
2487         s32 err;
2488         struct adapter *padapter;
2489
2490         err = _SUCCESS;
2491         padapter = context;
2492
2493         thread_enter("RTW_XMIT_THREAD");
2494
2495         do {
2496                 err = rtw_hal_xmit_thread_handler(padapter);
2497                 flush_signals_thread();
2498         } while (err == _SUCCESS);
2499
2500         complete(&padapter->xmitpriv.terminate_xmitthread_comp);
2501
2502         return 0;
2503 }
2504
2505 void rtw_sctx_init(struct submit_ctx *sctx, int timeout_ms)
2506 {
2507         sctx->timeout_ms = timeout_ms;
2508         sctx->submit_time = jiffies;
2509         init_completion(&sctx->done);
2510         sctx->status = RTW_SCTX_SUBMITTED;
2511 }
2512
2513 int rtw_sctx_wait(struct submit_ctx *sctx)
2514 {
2515         int ret = _FAIL;
2516         unsigned long expire;
2517         int status = 0;
2518
2519         expire = sctx->timeout_ms ? msecs_to_jiffies(sctx->timeout_ms) : MAX_SCHEDULE_TIMEOUT;
2520         if (!wait_for_completion_timeout(&sctx->done, expire))
2521                 /* timeout, do something?? */
2522                 status = RTW_SCTX_DONE_TIMEOUT;
2523         else
2524                 status = sctx->status;
2525
2526         if (status == RTW_SCTX_DONE_SUCCESS)
2527                 ret = _SUCCESS;
2528
2529         return ret;
2530 }
2531
2532 void rtw_sctx_done_err(struct submit_ctx **sctx, int status)
2533 {
2534         if (*sctx) {
2535                 (*sctx)->status = status;
2536                 complete(&((*sctx)->done));
2537                 *sctx = NULL;
2538         }
2539 }
2540
2541 void rtw_sctx_done(struct submit_ctx **sctx)
2542 {
2543         rtw_sctx_done_err(sctx, RTW_SCTX_DONE_SUCCESS);
2544 }
2545
2546 int rtw_ack_tx_wait(struct xmit_priv *pxmitpriv, u32 timeout_ms)
2547 {
2548         struct submit_ctx *pack_tx_ops = &pxmitpriv->ack_tx_ops;
2549
2550         pack_tx_ops->submit_time = jiffies;
2551         pack_tx_ops->timeout_ms = timeout_ms;
2552         pack_tx_ops->status = RTW_SCTX_SUBMITTED;
2553
2554         return rtw_sctx_wait(pack_tx_ops);
2555 }
2556
2557 void rtw_ack_tx_done(struct xmit_priv *pxmitpriv, int status)
2558 {
2559         struct submit_ctx *pack_tx_ops = &pxmitpriv->ack_tx_ops;
2560
2561         if (pxmitpriv->ack_tx)
2562                 rtw_sctx_done_err(&pack_tx_ops, status);
2563 }