drivers/net/wireless/rtl8723au/core/rtw_xmit.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of version 2 of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  17  *
  18  *
  19  ******************************************************************************/
  20 #define _RTW_XMIT_C_
  21
  22 #include <drv_conf.h>
  23 #include <osdep_service.h>
  24 #include <drv_types.h>
  25 #include <rtw_byteorder.h>
  26 #include <wifi.h>
  27 #include <osdep_intf.h>
  28 #include <circ_buf.h>
  29 #include <ip.h>
  30
  31 #if defined (PLATFORM_LINUX) && defined (PLATFORM_WINDOWS)
  32 #error "Shall be Linux or Windows, but not both!\n"
  33 #endif
  34
  35 #ifdef PLATFORM_WINDOWS
  36 #include <if_ether.h>
  37 #endif
  38
  39 #ifdef CONFIG_USB_HCI
  40 #include <usb_ops.h>
  41 #endif
  42
  43
  44 static u8 P802_1H_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0xf8 };
  45 static u8 RFC1042_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0x00 };
  46
  47 static void _init_txservq(struct tx_servq *ptxservq)
  48 {
  49 _func_enter_;
  50         _rtw_init_listhead(&ptxservq->tx_pending);
  51         _rtw_init_queue(&ptxservq->sta_pending);
  52         ptxservq->qcnt = 0;
  53 _func_exit_;
  54 }
  55
  56
  57 void    _rtw_init_sta_xmit_priv(struct sta_xmit_priv *psta_xmitpriv)
  58 {
  59
  60 _func_enter_;
  61
  62         _rtw_memset((unsigned char *)psta_xmitpriv, 0, sizeof (struct sta_xmit_priv));
  63
  64         _rtw_spinlock_init(&psta_xmitpriv->lock);
  65
  66         //for(i = 0 ; i < MAX_NUMBLKS; i++)
  67         //      _init_txservq(&(psta_xmitpriv->blk_q[i]));
  68
  69         _init_txservq(&psta_xmitpriv->be_q);
  70         _init_txservq(&psta_xmitpriv->bk_q);
  71         _init_txservq(&psta_xmitpriv->vi_q);
  72         _init_txservq(&psta_xmitpriv->vo_q);
  73         _rtw_init_listhead(&psta_xmitpriv->legacy_dz);
  74         _rtw_init_listhead(&psta_xmitpriv->apsd);
  75
  76 _func_exit_;
  77
  78 }
  79
  80 s32     _rtw_init_xmit_priv(struct xmit_priv *pxmitpriv, _adapter *padapter)
  81 {
  82         int i;
  83         struct xmit_buf *pxmitbuf;
  84         struct xmit_frame *pxframe;
  85         sint    res=_SUCCESS;
  86         u32 max_xmit_extbuf_size = MAX_XMIT_EXTBUF_SZ;
  87         u32 num_xmit_extbuf = NR_XMIT_EXTBUFF;
  88
  89 #if defined(CONFIG_MP_INCLUDED) && defined(CONFIG_RTL8723A)
  90                 if (padapter->registrypriv.mp_mode) {
  91                         max_xmit_extbuf_size = 6000;
  92                         num_xmit_extbuf = 8;
  93                 }
  94 #endif
  95
  96 _func_enter_;
  97
  98         // We don't need to memset padapter->XXX to zero, because adapter is allocated by rtw_zvmalloc().
  99         //_rtw_memset((unsigned char *)pxmitpriv, 0, sizeof(struct xmit_priv));
 100
 101         _rtw_spinlock_init(&pxmitpriv->lock);
 102         _rtw_spinlock_init(&pxmitpriv->lock_sctx);
 103         _rtw_init_sema(&pxmitpriv->xmit_sema, 0);
 104         _rtw_init_sema(&pxmitpriv->terminate_xmitthread_sema, 0);
 105
 106         /*
 107         Please insert all the queue initializaiton using _rtw_init_queue below
 108         */
 109
 110         pxmitpriv->adapter = padapter;
 111
 112         //for(i = 0 ; i < MAX_NUMBLKS; i++)
 113         //      _rtw_init_queue(&pxmitpriv->blk_strms[i]);
 114
 115         _rtw_init_queue(&pxmitpriv->be_pending);
 116         _rtw_init_queue(&pxmitpriv->bk_pending);
 117         _rtw_init_queue(&pxmitpriv->vi_pending);
 118         _rtw_init_queue(&pxmitpriv->vo_pending);
 119         _rtw_init_queue(&pxmitpriv->bm_pending);
 120
 121         //_rtw_init_queue(&pxmitpriv->legacy_dz_queue);
 122         //_rtw_init_queue(&pxmitpriv->apsd_queue);
 123
 124         _rtw_init_queue(&pxmitpriv->free_xmit_queue);
 125
 126         /*
 127         Please allocate memory with the sz = (struct xmit_frame) * NR_XMITFRAME,
 128         and initialize free_xmit_frame below.
 129         Please also apply  free_txobj to link_up all the xmit_frames...
 130         */
 131
 132         pxmitpriv->pallocated_frame_buf = rtw_zvmalloc(NR_XMITFRAME * sizeof(struct xmit_frame) + 4);
 133
 134         if (pxmitpriv->pallocated_frame_buf  == NULL){
 135                 pxmitpriv->pxmit_frame_buf =NULL;
 136                 RT_TRACE(_module_rtl871x_xmit_c_,_drv_err_,("alloc xmit_frame fail!\n"));
 137                 res= _FAIL;
 138                 goto exit;
 139         }
 140         pxmitpriv->pxmit_frame_buf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->pallocated_frame_buf), 4);
 141         //pxmitpriv->pxmit_frame_buf = pxmitpriv->pallocated_frame_buf + 4 -
 142         //                                              ((SIZE_PTR) (pxmitpriv->pallocated_frame_buf) &3);
 143
 144         pxframe = (struct xmit_frame*) pxmitpriv->pxmit_frame_buf;
 145
 146         for (i = 0; i < NR_XMITFRAME; i++)
 147         {
 148                 _rtw_init_listhead(&(pxframe->list));
 149
 150                 pxframe->padapter = padapter;
 151                 pxframe->frame_tag = NULL_FRAMETAG;
 152
 153                 pxframe->pkt = NULL;
 154
 155                 pxframe->buf_addr = NULL;
 156                 pxframe->pxmitbuf = NULL;
 157
 158                 rtw_list_insert_tail(&(pxframe->list), &(pxmitpriv->free_xmit_queue.queue));
 159
 160                 pxframe++;
 161         }
 162
 163         pxmitpriv->free_xmitframe_cnt = NR_XMITFRAME;
 164
 165         pxmitpriv->frag_len = MAX_FRAG_THRESHOLD;
 166
 167
 168         //init xmit_buf
 169         _rtw_init_queue(&pxmitpriv->free_xmitbuf_queue);
 170         _rtw_init_queue(&pxmitpriv->pending_xmitbuf_queue);
 171
 172         pxmitpriv->pallocated_xmitbuf = rtw_zvmalloc(NR_XMITBUFF * sizeof(struct xmit_buf) + 4);
 173
 174         if (pxmitpriv->pallocated_xmitbuf  == NULL){
 175                 RT_TRACE(_module_rtl871x_xmit_c_,_drv_err_,("alloc xmit_buf fail!\n"));
 176                 res= _FAIL;
 177                 goto exit;
 178         }
 179
 180         pxmitpriv->pxmitbuf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->pallocated_xmitbuf), 4);
 181         //pxmitpriv->pxmitbuf = pxmitpriv->pallocated_xmitbuf + 4 -
 182         //                                              ((SIZE_PTR) (pxmitpriv->pallocated_xmitbuf) &3);
 183
 184         pxmitbuf = (struct xmit_buf*)pxmitpriv->pxmitbuf;
 185
 186         for (i = 0; i < NR_XMITBUFF; i++)
 187         {
 188                 _rtw_init_listhead(&pxmitbuf->list);
 189
 190                 pxmitbuf->priv_data = NULL;
 191                 pxmitbuf->padapter = padapter;
 192                 pxmitbuf->ext_tag = _FALSE;
 193
 194 /*
 195                 pxmitbuf->pallocated_buf = rtw_zmalloc(MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ);
 196                 if (pxmitbuf->pallocated_buf == NULL)
 197                 {
 198                         res = _FAIL;
 199                         goto exit;
 200                 }
 201
 202                 pxmitbuf->pbuf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitbuf->pallocated_buf), XMITBUF_ALIGN_SZ);
 203                 //pxmitbuf->pbuf = pxmitbuf->pallocated_buf + XMITBUF_ALIGN_SZ -((SIZE_PTR) (pxmitbuf->pallocated_buf) &(XMITBUF_ALIGN_SZ-1));
 204 */
 205                 /* Tx buf allocation may fail sometimes, so sleep and retry. */
 206                 if((res=rtw_os_xmit_resource_alloc(padapter, pxmitbuf,(MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ))) == _FAIL) {
 207                         rtw_msleep_os(10);
 208                         res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf,(MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ));
 209                         if (res == _FAIL) {
 210                                 goto exit;
 211                         }
 212                 }
 213
 214 #if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
 215                 pxmitbuf->phead = pxmitbuf->pbuf;
 216                 pxmitbuf->pend = pxmitbuf->pbuf + MAX_XMITBUF_SZ;
 217                 pxmitbuf->len = 0;
 218                 pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
 219 #endif
 220
 221                 pxmitbuf->flags = XMIT_VO_QUEUE;
 222
 223                 rtw_list_insert_tail(&pxmitbuf->list, &(pxmitpriv->free_xmitbuf_queue.queue));
 224                 #ifdef DBG_XMIT_BUF
 225                 pxmitbuf->no=i;
 226                 #endif
 227
 228                 pxmitbuf++;
 229
 230         }
 231
 232         pxmitpriv->free_xmitbuf_cnt = NR_XMITBUFF;
 233
 234         /* init xframe_ext queue,  the same count as extbuf  */
 235         _rtw_init_queue(&pxmitpriv->free_xframe_ext_queue);
 236
 237         pxmitpriv->xframe_ext_alloc_addr = rtw_zvmalloc(num_xmit_extbuf * sizeof(struct xmit_frame) + 4);
 238
 239         if (pxmitpriv->xframe_ext_alloc_addr  == NULL){
 240                 pxmitpriv->xframe_ext = NULL;
 241                 RT_TRACE(_module_rtl871x_xmit_c_,_drv_err_,("alloc xframe_ext fail!\n"));
 242                 res= _FAIL;
 243                 goto exit;
 244         }
 245         pxmitpriv->xframe_ext = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->xframe_ext_alloc_addr), 4);
 246         pxframe = (struct xmit_frame*)pxmitpriv->xframe_ext;
 247
 248         for (i = 0; i < num_xmit_extbuf; i++) {
 249                 _rtw_init_listhead(&(pxframe->list));
 250
 251                 pxframe->padapter = padapter;
 252                 pxframe->frame_tag = NULL_FRAMETAG;
 253
 254                 pxframe->pkt = NULL;
 255
 256                 pxframe->buf_addr = NULL;
 257                 pxframe->pxmitbuf = NULL;
 258
 259                 pxframe->ext_tag = 1;
 260
 261                 rtw_list_insert_tail(&(pxframe->list), &(pxmitpriv->free_xframe_ext_queue.queue));
 262
 263                 pxframe++;
 264         }
 265         pxmitpriv->free_xframe_ext_cnt = num_xmit_extbuf;
 266
 267         // Init xmit extension buff
 268         _rtw_init_queue(&pxmitpriv->free_xmit_extbuf_queue);
 269
 270         pxmitpriv->pallocated_xmit_extbuf = rtw_zvmalloc(num_xmit_extbuf * sizeof(struct xmit_buf) + 4);
 271
 272         if (pxmitpriv->pallocated_xmit_extbuf  == NULL){
 273                 RT_TRACE(_module_rtl871x_xmit_c_,_drv_err_,("alloc xmit_extbuf fail!\n"));
 274                 res= _FAIL;
 275                 goto exit;
 276         }
 277
 278         pxmitpriv->pxmit_extbuf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->pallocated_xmit_extbuf), 4);
 279
 280         pxmitbuf = (struct xmit_buf*)pxmitpriv->pxmit_extbuf;
 281
 282         for (i = 0; i < num_xmit_extbuf; i++)
 283         {
 284                 _rtw_init_listhead(&pxmitbuf->list);
 285
 286                 pxmitbuf->priv_data = NULL;
 287                 pxmitbuf->padapter = padapter;
 288                 pxmitbuf->ext_tag = _TRUE;
 289
 290 /*
 291                 pxmitbuf->pallocated_buf = rtw_zmalloc(max_xmit_extbuf_size);
 292                 if (pxmitbuf->pallocated_buf == NULL)
 293                 {
 294                         res = _FAIL;
 295                         goto exit;
 296                 }
 297
 298                 pxmitbuf->pbuf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitbuf->pallocated_buf), 4);
 299 */
 300
 301                 if((res=rtw_os_xmit_resource_alloc(padapter, pxmitbuf,max_xmit_extbuf_size + XMITBUF_ALIGN_SZ)) == _FAIL) {
 302                         res= _FAIL;
 303                         goto exit;
 304                 }
 305
 306 #if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
 307                 pxmitbuf->phead = pxmitbuf->pbuf;
 308                 pxmitbuf->pend = pxmitbuf->pbuf + max_xmit_extbuf_size;
 309                 pxmitbuf->len = 0;
 310                 pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
 311 #endif
 312
 313                 rtw_list_insert_tail(&pxmitbuf->list, &(pxmitpriv->free_xmit_extbuf_queue.queue));
 314                 #ifdef DBG_XMIT_BUF_EXT
 315                 pxmitbuf->no=i;
 316                 #endif
 317                 pxmitbuf++;
 318
 319         }
 320
 321         pxmitpriv->free_xmit_extbuf_cnt = num_xmit_extbuf;
 322
 323         rtw_alloc_hwxmits(padapter);
 324         rtw_init_hwxmits(pxmitpriv->hwxmits, pxmitpriv->hwxmit_entry);
 325
 326         for (i = 0; i < 4; i ++)
 327         {
 328                 pxmitpriv->wmm_para_seq[i] = i;
 329         }
 330
 331 #ifdef CONFIG_USB_HCI
 332         pxmitpriv->txirp_cnt=1;
 333
 334         _rtw_init_sema(&(pxmitpriv->tx_retevt), 0);
 335
 336         //per AC pending irp
 337         pxmitpriv->beq_cnt = 0;
 338         pxmitpriv->bkq_cnt = 0;
 339         pxmitpriv->viq_cnt = 0;
 340         pxmitpriv->voq_cnt = 0;
 341 #endif
 342
 343
 344 #ifdef CONFIG_XMIT_ACK
 345         pxmitpriv->ack_tx = _FALSE;
 346         _rtw_mutex_init(&pxmitpriv->ack_tx_mutex);
 347         rtw_sctx_init(&pxmitpriv->ack_tx_ops, 0);
 348 #endif
 349
 350         rtw_hal_init_xmit_priv(padapter);
 351
 352 exit:
 353
 354 _func_exit_;
 355
 356         return res;
 357 }
 358
 359 void  rtw_mfree_xmit_priv_lock (struct xmit_priv *pxmitpriv);
 360 void  rtw_mfree_xmit_priv_lock (struct xmit_priv *pxmitpriv)
 361 {
 362         _rtw_spinlock_free(&pxmitpriv->lock);
 363         _rtw_free_sema(&pxmitpriv->xmit_sema);
 364         _rtw_free_sema(&pxmitpriv->terminate_xmitthread_sema);
 365
 366         _rtw_spinlock_free(&pxmitpriv->be_pending.lock);
 367         _rtw_spinlock_free(&pxmitpriv->bk_pending.lock);
 368         _rtw_spinlock_free(&pxmitpriv->vi_pending.lock);
 369         _rtw_spinlock_free(&pxmitpriv->vo_pending.lock);
 370         _rtw_spinlock_free(&pxmitpriv->bm_pending.lock);
 371
 372         //_rtw_spinlock_free(&pxmitpriv->legacy_dz_queue.lock);
 373         //_rtw_spinlock_free(&pxmitpriv->apsd_queue.lock);
 374
 375         _rtw_spinlock_free(&pxmitpriv->free_xmit_queue.lock);
 376         _rtw_spinlock_free(&pxmitpriv->free_xmitbuf_queue.lock);
 377         _rtw_spinlock_free(&pxmitpriv->pending_xmitbuf_queue.lock);
 378 }
 379
 380
 381 void _rtw_free_xmit_priv (struct xmit_priv *pxmitpriv)
 382 {
 383        int i;
 384       _adapter *padapter = pxmitpriv->adapter;
 385         struct xmit_frame       *pxmitframe = (struct xmit_frame*) pxmitpriv->pxmit_frame_buf;
 386         struct xmit_buf *pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmitbuf;
 387         u32 max_xmit_extbuf_size = MAX_XMIT_EXTBUF_SZ;
 388         u32 num_xmit_extbuf = NR_XMIT_EXTBUFF;
 389
 390 #if defined(CONFIG_MP_INCLUDED) && defined(CONFIG_RTL8723A)
 391         if (padapter->registrypriv.mp_mode) {
 392                         max_xmit_extbuf_size = 6000;
 393                         num_xmit_extbuf = 8;
 394         }
 395 #endif
 396
 397  _func_enter_;
 398
 399         rtw_hal_free_xmit_priv(padapter);
 400
 401         rtw_mfree_xmit_priv_lock(pxmitpriv);
 402
 403         if(pxmitpriv->pxmit_frame_buf==NULL)
 404                 goto out;
 405
 406         for(i=0; i<NR_XMITFRAME; i++)
 407         {
 408                 rtw_os_xmit_complete(padapter, pxmitframe);
 409
 410                 pxmitframe++;
 411         }
 412
 413         for(i=0; i<NR_XMITBUFF; i++)
 414         {
 415                 rtw_os_xmit_resource_free(padapter, pxmitbuf,(MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ));
 416
 417                 //if(pxmitbuf->pallocated_buf)
 418                 //      rtw_mfree(pxmitbuf->pallocated_buf, MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ);
 419
 420                 pxmitbuf++;
 421         }
 422
 423         if(pxmitpriv->pallocated_frame_buf) {
 424                 rtw_vmfree(pxmitpriv->pallocated_frame_buf, NR_XMITFRAME * sizeof(struct xmit_frame) + 4);
 425         }
 426
 427
 428         if(pxmitpriv->pallocated_xmitbuf) {
 429                 rtw_vmfree(pxmitpriv->pallocated_xmitbuf, NR_XMITBUFF * sizeof(struct xmit_buf) + 4);
 430         }
 431
 432         /* free xframe_ext queue,  the same count as extbuf  */
 433         if ((pxmitframe = (struct xmit_frame*)pxmitpriv->xframe_ext)) {
 434                 for (i=0; i<num_xmit_extbuf; i++) {
 435                         rtw_os_xmit_complete(padapter, pxmitframe);
 436                         pxmitframe++;
 437                 }
 438         }
 439         if (pxmitpriv->xframe_ext_alloc_addr)
 440                 rtw_vmfree(pxmitpriv->xframe_ext_alloc_addr, num_xmit_extbuf * sizeof(struct xmit_frame) + 4);
 441         _rtw_spinlock_free(&pxmitpriv->free_xframe_ext_queue.lock);
 442
 443         // free xmit extension buff
 444         _rtw_spinlock_free(&pxmitpriv->free_xmit_extbuf_queue.lock);
 445
 446         pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmit_extbuf;
 447         for(i=0; i<num_xmit_extbuf; i++)
 448         {
 449                 rtw_os_xmit_resource_free(padapter, pxmitbuf,(max_xmit_extbuf_size + XMITBUF_ALIGN_SZ));
 450
 451                 //if(pxmitbuf->pallocated_buf)
 452                 //      rtw_mfree(pxmitbuf->pallocated_buf, max_xmit_extbuf_size);
 453
 454                 pxmitbuf++;
 455         }
 456
 457         if(pxmitpriv->pallocated_xmit_extbuf) {
 458                 rtw_vmfree(pxmitpriv->pallocated_xmit_extbuf, num_xmit_extbuf * sizeof(struct xmit_buf) + 4);
 459         }
 460
 461         rtw_free_hwxmits(padapter);
 462
 463 #ifdef CONFIG_XMIT_ACK
 464         _rtw_mutex_free(&pxmitpriv->ack_tx_mutex);
 465 #endif
 466
 467 out:
 468
 469 _func_exit_;
 470
 471 }
 472
 473 static void update_attrib_vcs_info(_adapter *padapter, struct xmit_frame *pxmitframe)
 474 {
 475         u32     sz;
 476         struct pkt_attrib       *pattrib = &pxmitframe->attrib;
 477         struct sta_info *psta = pattrib->psta;
 478         struct mlme_ext_priv    *pmlmeext = &(padapter->mlmeextpriv);
 479         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
 480
 481         if(pattrib->psta)
 482         {
 483                 psta = pattrib->psta;
 484         }
 485         else
 486         {
 487                 DBG_871X("%s, call rtw_get_stainfo()\n", __func__);
 488                 psta=rtw_get_stainfo(&padapter->stapriv ,&pattrib->ra[0] );
 489         }
 490
 491         if(psta==NULL)
 492         {
 493                 DBG_871X("%s, psta==NUL\n", __func__);
 494                 return;
 495         }
 496
 497         if(!(psta->state &_FW_LINKED))
 498         {
 499                 DBG_871X("%s, psta->state(0x%x) != _FW_LINKED\n", __func__, psta->state);
 500                 return;
 501         }
 502
 503         if (pattrib->nr_frags != 1)
 504         {
 505                 sz = padapter->xmitpriv.frag_len;
 506         }
 507         else //no frag
 508         {
 509                 sz = pattrib->last_txcmdsz;
 510         }
 511
 512         // (1) RTS_Threshold is compared to the MPDU, not MSDU.
 513         // (2) If there are more than one frag in  this MSDU, only the first frag uses protection frame.
 514         //              Other fragments are protected by previous fragment.
 515         //              So we only need to check the length of first fragment.
 516         if(pmlmeext->cur_wireless_mode < WIRELESS_11_24N  || padapter->registrypriv.wifi_spec)
 517         {
 518                 if(sz > padapter->registrypriv.rts_thresh)
 519                 {
 520                         pattrib->vcs_mode = RTS_CTS;
 521                 }
 522                 else
 523                 {
 524                         if(psta->rtsen)
 525                                 pattrib->vcs_mode = RTS_CTS;
 526                         else if(psta->cts2self)
 527                                 pattrib->vcs_mode = CTS_TO_SELF;
 528                         else
 529                                 pattrib->vcs_mode = NONE_VCS;
 530                 }
 531         }
 532         else
 533         {
 534                 while (_TRUE)
 535                 {
 536 #if 0 //Todo
 537                         //check IOT action
 538                         if(pHTInfo->IOTAction & HT_IOT_ACT_FORCED_CTS2SELF)
 539                         {
 540                                 pattrib->vcs_mode = CTS_TO_SELF;
 541                                 pattrib->rts_rate = MGN_24M;
 542                                 break;
 543                         }
 544                         else if(pHTInfo->IOTAction & (HT_IOT_ACT_FORCED_RTS|HT_IOT_ACT_PURE_N_MODE))
 545                         {
 546                                 pattrib->vcs_mode = RTS_CTS;
 547                                 pattrib->rts_rate = MGN_24M;
 548                                 break;
 549                         }
 550 #endif
 551
 552                         //IOT action
 553                         if((pmlmeinfo->assoc_AP_vendor == HT_IOT_PEER_ATHEROS) && (pattrib->ampdu_en==_TRUE) &&
 554                                 (padapter->securitypriv.dot11PrivacyAlgrthm == _AES_ ))
 555                         {
 556                                 pattrib->vcs_mode = CTS_TO_SELF;
 557                                 break;
 558                         }
 559
 560
 561                         //check ERP protection
 562                         if(psta->rtsen || psta->cts2self)
 563                         {
 564                                 if(psta->rtsen)
 565                                         pattrib->vcs_mode = RTS_CTS;
 566                                 else if(psta->cts2self)
 567                                         pattrib->vcs_mode = CTS_TO_SELF;
 568
 569                                 break;
 570                         }
 571
 572                         //check HT op mode
 573                         if(pattrib->ht_en)
 574                         {
 575                                 u8 HTOpMode = pmlmeinfo->HT_protection;
 576                                 if((pmlmeext->cur_bwmode && (HTOpMode == 2 || HTOpMode == 3)) ||
 577                                         (!pmlmeext->cur_bwmode && HTOpMode == 3) )
 578                                 {
 579                                         pattrib->vcs_mode = RTS_CTS;
 580                                         break;
 581                                 }
 582                         }
 583
 584                         //check rts
 585                         if(sz > padapter->registrypriv.rts_thresh)
 586                         {
 587                                 pattrib->vcs_mode = RTS_CTS;
 588                                 break;
 589                         }
 590
 591                         //to do list: check MIMO power save condition.
 592
 593                         //check AMPDU aggregation for TXOP
 594                         if(pattrib->ampdu_en==_TRUE)
 595                         {
 596                                 pattrib->vcs_mode = RTS_CTS;
 597                                 break;
 598                         }
 599
 600                         pattrib->vcs_mode = NONE_VCS;
 601                         break;
 602                 }
 603         }
 604 }
 605
 606 static void update_attrib_phy_info(struct pkt_attrib *pattrib, struct sta_info *psta)
 607 {
 608         /*if(psta->rtsen)
 609                 pattrib->vcs_mode = RTS_CTS;
 610         else if(psta->cts2self)
 611                 pattrib->vcs_mode = CTS_TO_SELF;
 612         else
 613                 pattrib->vcs_mode = NONE_VCS;*/
 614
 615         pattrib->mdata = 0;
 616         pattrib->eosp = 0;
 617         pattrib->triggered=0;
 618
 619         //qos_en, ht_en, init rate, ,bw, ch_offset, sgi
 620         pattrib->qos_en = psta->qos_option;
 621
 622         pattrib->raid = psta->raid;
 623 #ifdef CONFIG_80211N_HT
 624         pattrib->ht_en = psta->htpriv.ht_option;
 625         pattrib->bwmode = psta->htpriv.bwmode;
 626         pattrib->ch_offset = psta->htpriv.ch_offset;
 627         pattrib->sgi= psta->htpriv.sgi;
 628         pattrib->ampdu_en = _FALSE;
 629 #endif //CONFIG_80211N_HT
 630         //if(pattrib->ht_en && psta->htpriv.ampdu_enable)
 631         //{
 632         //      if(psta->htpriv.agg_enable_bitmap & BIT(pattrib->priority))
 633         //              pattrib->ampdu_en = _TRUE;
 634         //}
 635
 636
 637         pattrib->retry_ctrl = _FALSE;
 638
 639 }
 640
 641 u8      qos_acm(u8 acm_mask, u8 priority)
 642 {
 643         u8      change_priority = priority;
 644
 645         switch (priority)
 646         {
 647                 case 0:
 648                 case 3:
 649                         if(acm_mask & BIT(1))
 650                                 change_priority = 1;
 651                         break;
 652                 case 1:
 653                 case 2:
 654                         break;
 655                 case 4:
 656                 case 5:
 657                         if(acm_mask & BIT(2))
 658                                 change_priority = 0;
 659                         break;
 660                 case 6:
 661                 case 7:
 662                         if(acm_mask & BIT(3))
 663                                 change_priority = 5;
 664                         break;
 665                 default:
 666                         DBG_871X("qos_acm(): invalid pattrib->priority: %d!!!\n", priority);
 667                         break;
 668         }
 669
 670         return change_priority;
 671 }
 672
 673 static void set_qos(struct pkt_file *ppktfile, struct pkt_attrib *pattrib)
 674 {
 675         struct ethhdr etherhdr;
 676         struct iphdr ip_hdr;
 677         s32 UserPriority = 0;
 678
 679
 680         _rtw_open_pktfile(ppktfile->pkt, ppktfile);
 681         _rtw_pktfile_read(ppktfile, (unsigned char*)&etherhdr, ETH_HLEN);
 682
 683         // get UserPriority from IP hdr
 684         if (pattrib->ether_type == 0x0800) {
 685                 _rtw_pktfile_read(ppktfile, (u8*)&ip_hdr, sizeof(ip_hdr));
 686 //              UserPriority = (ntohs(ip_hdr.tos) >> 5) & 0x3;
 687                 UserPriority = ip_hdr.tos >> 5;
 688         } else if (pattrib->ether_type == 0x888e) {
 689                 // "When priority processing of data frames is supported,
 690                 // a STA's SME should send EAPOL-Key frames at the highest priority."
 691                 UserPriority = 7;
 692         }
 693
 694         pattrib->priority = UserPriority;
 695         pattrib->hdrlen = WLAN_HDR_A3_QOS_LEN;
 696         pattrib->subtype = WIFI_QOS_DATA_TYPE;
 697 }
 698
 699 static s32 update_attrib(_adapter *padapter, _pkt *pkt, struct pkt_attrib *pattrib)
 700 {
 701         uint i;
 702         struct pkt_file pktfile;
 703         struct sta_info *psta = NULL;
 704         struct ethhdr etherhdr;
 705
 706         sint bmcast;
 707         struct sta_priv         *pstapriv = &padapter->stapriv;
 708         struct security_priv    *psecuritypriv = &padapter->securitypriv;
 709         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
 710         struct qos_priv         *pqospriv= &pmlmepriv->qospriv;
 711         sint res = _SUCCESS;
 712
 713  _func_enter_;
 714
 715         _rtw_open_pktfile(pkt, &pktfile);
 716         i = _rtw_pktfile_read(&pktfile, (u8*)&etherhdr, ETH_HLEN);
 717
 718         pattrib->ether_type = ntohs(etherhdr.h_proto);
 719
 720
 721         _rtw_memcpy(pattrib->dst, &etherhdr.h_dest, ETH_ALEN);
 722         _rtw_memcpy(pattrib->src, &etherhdr.h_source, ETH_ALEN);
 723
 724         pattrib->pctrl = 0;
 725
 726         if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == _TRUE) ||
 727                 (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == _TRUE)) {
 728                 _rtw_memcpy(pattrib->ra, pattrib->dst, ETH_ALEN);
 729                 _rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
 730         }
 731         else if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) {
 732                 _rtw_memcpy(pattrib->ra, get_bssid(pmlmepriv), ETH_ALEN);
 733                 _rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
 734         }
 735         else if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
 736                 _rtw_memcpy(pattrib->ra, pattrib->dst, ETH_ALEN);
 737                 _rtw_memcpy(pattrib->ta, get_bssid(pmlmepriv), ETH_ALEN);
 738         }
 739
 740         pattrib->pktlen = pktfile.pkt_len;
 741
 742         if (ETH_P_IP == pattrib->ether_type)
 743         {
 744                 // The following is for DHCP and ARP packet, we use cck1M to tx these packets and let LPS awake some time
 745                 // to prevent DHCP protocol fail
 746                 u8 tmp[24];
 747                 _rtw_pktfile_read(&pktfile, &tmp[0], 24);
 748                 pattrib->dhcp_pkt = 0;
 749                 if (pktfile.pkt_len > 282) {//MINIMUM_DHCP_PACKET_SIZE) {
 750                         if (ETH_P_IP == pattrib->ether_type) {// IP header
 751                                 if (((tmp[21] == 68) && (tmp[23] == 67)) ||
 752                                         ((tmp[21] == 67) && (tmp[23] == 68))) {
 753                                         // 68 : UDP BOOTP client
 754                                         // 67 : UDP BOOTP server
 755                                         RT_TRACE(_module_rtl871x_xmit_c_,_drv_err_,("======================update_attrib: get DHCP Packet \n"));
 756                                         // Use low rate to send DHCP packet.
 757                                         //if(pMgntInfo->IOTAction & HT_IOT_ACT_WA_IOT_Broadcom)
 758                                         //{
 759                                         //      tcb_desc->DataRate = MgntQuery_TxRateExcludeCCKRates(ieee);//0xc;//ofdm 6m
 760                                         //      tcb_desc->bTxDisableRateFallBack = false;
 761                                         //}
 762                                         //else
 763                                         //      pTcb->DataRate = Adapter->MgntInfo.LowestBasicRate;
 764                                         //RTPRINT(FDM, WA_IOT, ("DHCP TranslateHeader(), pTcb->DataRate = 0x%x\n", pTcb->DataRate));
 765                                         pattrib->dhcp_pkt = 1;
 766                                 }
 767                         }
 768                 }
 769         } else if (0x888e == pattrib->ether_type) {
 770                 DBG_871X_LEVEL(_drv_always_, "send eapol packet\n");
 771         }
 772
 773         if ( (pattrib->ether_type == 0x888e) || (pattrib->dhcp_pkt == 1) )
 774         {
 775                 rtw_set_scan_deny(padapter, 3000);
 776         }
 777
 778 #ifdef CONFIG_LPS
 779         // If EAPOL , ARP , OR DHCP packet, driver must be in active mode.
 780 #ifdef CONFIG_WAPI_SUPPORT
 781         if ( (pattrib->ether_type == 0x88B4) || (pattrib->ether_type == 0x0806) || (pattrib->ether_type == 0x888e) || (pattrib->dhcp_pkt == 1) )
 782 #else
 783         if ( (pattrib->ether_type == 0x0806) || (pattrib->ether_type == 0x888e) || (pattrib->dhcp_pkt == 1) )
 784 #endif
 785         {
 786                 rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_SPECIAL_PACKET, 1);
 787         }
 788 #endif
 789
 790         bmcast = IS_MCAST(pattrib->ra);
 791
 792         // get sta_info
 793         if (bmcast) {
 794                 psta = rtw_get_bcmc_stainfo(padapter);
 795         } else {
 796                 psta = rtw_get_stainfo(pstapriv, pattrib->ra);
 797                 if (psta == NULL)       { // if we cannot get psta => drrp the pkt
 798                         RT_TRACE(_module_rtl871x_xmit_c_, _drv_alert_, ("\nupdate_attrib => get sta_info fail, ra:" MAC_FMT"\n", MAC_ARG(pattrib->ra)));
 799                         #ifdef DBG_TX_DROP_FRAME
 800                         DBG_871X("DBG_TX_DROP_FRAME %s get sta_info fail, ra:" MAC_FMT"\n", __FUNCTION__, MAC_ARG(pattrib->ra));
 801                         #endif
 802                         res =_FAIL;
 803                         goto exit;
 804                 }
 805                 else if((check_fwstate(pmlmepriv, WIFI_AP_STATE)==_TRUE)&&(!(psta->state & _FW_LINKED)))
 806                 {
 807                         res =_FAIL;
 808                         goto exit;
 809                 }
 810         }
 811
 812         if (psta)
 813         {
 814                 pattrib->mac_id = psta->mac_id;
 815                 //DBG_8192C("%s ==> mac_id(%d)\n",__FUNCTION__,pattrib->mac_id );
 816                 pattrib->psta = psta;
 817         }
 818         else
 819         {
 820                 // if we cannot get psta => drop the pkt
 821                 RT_TRACE(_module_rtl871x_xmit_c_, _drv_alert_, ("\nupdate_attrib => get sta_info fail, ra:" MAC_FMT "\n", MAC_ARG(pattrib->ra)));
 822                 #ifdef DBG_TX_DROP_FRAME
 823                 DBG_871X("DBG_TX_DROP_FRAME %s get sta_info fail, ra:" MAC_FMT"\n", __FUNCTION__, MAC_ARG(pattrib->ra));
 824                 #endif
 825                 res = _FAIL;
 826                 goto exit;
 827         }
 828
 829         pattrib->ack_policy = 0;
 830         // get ether_hdr_len
 831         pattrib->pkt_hdrlen = ETH_HLEN;//(pattrib->ether_type == 0x8100) ? (14 + 4 ): 14; //vlan tag
 832
 833         pattrib->hdrlen = WLAN_HDR_A3_LEN;
 834         pattrib->subtype = WIFI_DATA_TYPE;
 835         pattrib->priority = 0;
 836
 837         if (check_fwstate(pmlmepriv, WIFI_AP_STATE|WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE))
 838         {
 839                 if(psta->qos_option)
 840                         set_qos(&pktfile, pattrib);
 841         }
 842         else
 843         {
 844                 if(pqospriv->qos_option)
 845                 {
 846                         set_qos(&pktfile, pattrib);
 847
 848                         if(pmlmepriv->acm_mask != 0)
 849                         {
 850                                 pattrib->priority = qos_acm(pmlmepriv->acm_mask, pattrib->priority);
 851                         }
 852                 }
 853         }
 854
 855         //pattrib->priority = 5; //force to used VI queue, for testing
 856
 857         if (psta->ieee8021x_blocked == _TRUE)
 858         {
 859                 RT_TRACE(_module_rtl871x_xmit_c_,_drv_err_,("\n psta->ieee8021x_blocked == _TRUE \n"));
 860
 861                 pattrib->encrypt = 0;
 862
 863                 if((pattrib->ether_type != 0x888e) && (check_fwstate(pmlmepriv, WIFI_MP_STATE) == _FALSE))
 864                 {
 865                         RT_TRACE(_module_rtl871x_xmit_c_,_drv_err_,("\npsta->ieee8021x_blocked == _TRUE,  pattrib->ether_type(%.4x) != 0x888e\n",pattrib->ether_type));
 866                         #ifdef DBG_TX_DROP_FRAME
 867                         DBG_871X("DBG_TX_DROP_FRAME %s psta->ieee8021x_blocked == _TRUE,  pattrib->ether_type(%04x) != 0x888e\n", __FUNCTION__,pattrib->ether_type);
 868                         #endif
 869                         res = _FAIL;
 870                         goto exit;
 871                 }
 872         }
 873         else
 874         {
 875                 GET_ENCRY_ALGO(psecuritypriv, psta, pattrib->encrypt, bmcast);
 876
 877 #ifdef CONFIG_WAPI_SUPPORT
 878                 if(pattrib->ether_type == 0x88B4)
 879                         pattrib->encrypt=_NO_PRIVACY_;
 880 #endif
 881
 882                 switch(psecuritypriv->dot11AuthAlgrthm)
 883                 {
 884                         case dot11AuthAlgrthm_Open:
 885                         case dot11AuthAlgrthm_Shared:
 886                         case dot11AuthAlgrthm_Auto:
 887                                 pattrib->key_idx = (u8)psecuritypriv->dot11PrivacyKeyIndex;
 888                                 break;
 889                         case dot11AuthAlgrthm_8021X:
 890                                 if(bmcast)
 891                                         pattrib->key_idx = (u8)psecuritypriv->dot118021XGrpKeyid;
 892                                 else
 893                                         pattrib->key_idx = 0;
 894                                 break;
 895                         default:
 896                                 pattrib->key_idx = 0;
 897                                 break;
 898                 }
 899
 900
 901         }
 902
 903         switch (pattrib->encrypt)
 904         {
 905                 case _WEP40_:
 906                 case _WEP104_:
 907                         pattrib->iv_len = 4;
 908                         pattrib->icv_len = 4;
 909                         break;
 910
 911                 case _TKIP_:
 912                         pattrib->iv_len = 8;
 913                         pattrib->icv_len = 4;
 914
 915                         if(padapter->securitypriv.busetkipkey==_FAIL)
 916                         {
 917                                 RT_TRACE(_module_rtl871x_xmit_c_,_drv_err_,("\npadapter->securitypriv.busetkipkey(%d)==_FAIL drop packet\n", padapter->securitypriv.busetkipkey));
 918                                 #ifdef DBG_TX_DROP_FRAME
 919                                 DBG_871X("DBG_TX_DROP_FRAME %s padapter->securitypriv.busetkipkey(%d)==_FAIL drop packet\n", __FUNCTION__, padapter->securitypriv.busetkipkey);
 920                                 #endif
 921                                 res =_FAIL;
 922                                 goto exit;
 923                         }
 924
 925                         break;
 926                 case _AES_:
 927                         RT_TRACE(_module_rtl871x_xmit_c_,_drv_info_,("pattrib->encrypt=%d (_AES_)\n",pattrib->encrypt));
 928                         pattrib->iv_len = 8;
 929                         pattrib->icv_len = 8;
 930                         break;
 931
 932 #ifdef CONFIG_WAPI_SUPPORT
 933                 case _SMS4_:
 934                         pattrib->iv_len = 18;
 935                         pattrib->icv_len = 16;
 936                         break;
 937 #endif
 938
 939                 default:
 940                         pattrib->iv_len = 0;
 941                         pattrib->icv_len = 0;
 942                         break;
 943         }
 944
 945         RT_TRACE(_module_rtl871x_xmit_c_, _drv_info_,
 946                  ("update_attrib: encrypt=%d  securitypriv.sw_encrypt=%d\n",
 947                   pattrib->encrypt, padapter->securitypriv.sw_encrypt));
 948
 949         if (pattrib->encrypt &&
 950             ((padapter->securitypriv.sw_encrypt == _TRUE) || (psecuritypriv->hw_decrypted == _FALSE)))
 951         {
 952                 pattrib->bswenc = _TRUE;
 953                 RT_TRACE(_module_rtl871x_xmit_c_,_drv_err_,
 954                          ("update_attrib: encrypt=%d securitypriv.hw_decrypted=%d bswenc=_TRUE\n",
 955                           pattrib->encrypt, padapter->securitypriv.sw_encrypt));
 956         } else {
 957                 pattrib->bswenc = _FALSE;
 958                 RT_TRACE(_module_rtl871x_xmit_c_,_drv_info_,("update_attrib: bswenc=_FALSE\n"));
 959         }
 960
 961 #ifdef CONFIG_CONCURRENT_MODE
 962         if((pattrib->encrypt && bmcast) || (pattrib->encrypt ==_WEP40_) || (pattrib->encrypt ==_WEP104_))
 963         {
 964                 pattrib->bswenc = _TRUE;//force using sw enc.
 965         }
 966 #endif
 967
 968 #ifdef CONFIG_WAPI_SUPPORT
 969         if(pattrib->encrypt == _SMS4_)
 970                 pattrib->bswenc = _FALSE;
 971 #endif
 972
 973         rtw_set_tx_chksum_offload(pkt, pattrib);
 974
 975         update_attrib_phy_info(pattrib, psta);
 976
 977 exit:
 978
 979 _func_exit_;
 980
 981         return res;
 982 }
 983
 984 static s32 xmitframe_addmic(_adapter *padapter, struct xmit_frame *pxmitframe){
 985         sint                    curfragnum,length;
 986         u8      *pframe, *payload,mic[8];
 987         struct  mic_data                micdata;
 988         struct  sta_info                *stainfo;
 989         struct  qos_priv   *pqospriv= &(padapter->mlmepriv.qospriv);
 990         struct  pkt_attrib       *pattrib = &pxmitframe->attrib;
 991         struct  security_priv   *psecuritypriv=&padapter->securitypriv;
 992         struct  xmit_priv               *pxmitpriv=&padapter->xmitpriv;
 993         u8 priority[4]={0x0,0x0,0x0,0x0};
 994         u8 hw_hdr_offset = 0;
 995         sint bmcst = IS_MCAST(pattrib->ra);
 996
 997         if(pattrib->psta)
 998         {
 999                 stainfo = pattrib->psta;
1000         }
1001         else
1002         {
1003                 DBG_871X("%s, call rtw_get_stainfo()\n", __func__);
1004                 stainfo=rtw_get_stainfo(&padapter->stapriv ,&pattrib->ra[0]);
1005         }
1006
1007         if(stainfo==NULL)
1008         {
1009                 DBG_871X("%s, psta==NUL\n", __func__);
1010                 return _FAIL;
1011         }
1012
1013         if(!(stainfo->state &_FW_LINKED))
1014         {
1015                 DBG_871X("%s, psta->state(0x%x) != _FW_LINKED\n", __func__, stainfo->state);
1016                 return _FAIL;
1017         }
1018
1019 _func_enter_;
1020
1021 #ifdef CONFIG_USB_TX_AGGREGATION
1022         hw_hdr_offset = TXDESC_SIZE + (pxmitframe->pkt_offset * PACKET_OFFSET_SZ);;
1023 #else
1024         #ifdef CONFIG_TX_EARLY_MODE
1025         hw_hdr_offset = TXDESC_OFFSET+ EARLY_MODE_INFO_SIZE;
1026         #else
1027         hw_hdr_offset = TXDESC_OFFSET;
1028         #endif
1029 #endif
1030
1031         if(pattrib->encrypt ==_TKIP_)//if(psecuritypriv->dot11PrivacyAlgrthm==_TKIP_PRIVACY_)
1032         {
1033                 //encode mic code
1034                 if(stainfo!= NULL){
1035                         u8 null_key[16]={0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
1036
1037                         pframe = pxmitframe->buf_addr + hw_hdr_offset;
1038
1039                         if(bmcst)
1040                         {
1041                                 if(_rtw_memcmp(psecuritypriv->dot118021XGrptxmickey[psecuritypriv->dot118021XGrpKeyid].skey, null_key, 16)==_TRUE){
1042                                         //DbgPrint("\nxmitframe_addmic:stainfo->dot11tkiptxmickey==0\n");
1043                                         //rtw_msleep_os(10);
1044                                         return _FAIL;
1045                                 }
1046                                 //start to calculate the mic code
1047                                 rtw_secmicsetkey(&micdata, psecuritypriv->dot118021XGrptxmickey[psecuritypriv->dot118021XGrpKeyid].skey);
1048                         }
1049                         else
1050                         {
1051                                 if(_rtw_memcmp(&stainfo->dot11tkiptxmickey.skey[0],null_key, 16)==_TRUE){
1052                                         //DbgPrint("\nxmitframe_addmic:stainfo->dot11tkiptxmickey==0\n");
1053                                         //rtw_msleep_os(10);
1054                                         return _FAIL;
1055                                 }
1056                                 //start to calculate the mic code
1057                                 rtw_secmicsetkey(&micdata, &stainfo->dot11tkiptxmickey.skey[0]);
1058                         }
1059
1060                         if(pframe[1]&1){   //ToDS==1
1061                                 rtw_secmicappend(&micdata, &pframe[16], 6);  //DA
1062                                 if(pframe[1]&2)  //From Ds==1
1063                                         rtw_secmicappend(&micdata, &pframe[24], 6);
1064                                 else
1065                                 rtw_secmicappend(&micdata, &pframe[10], 6);
1066                         }
1067                         else{   //ToDS==0
1068                                 rtw_secmicappend(&micdata, &pframe[4], 6);   //DA
1069                                 if(pframe[1]&2)  //From Ds==1
1070                                         rtw_secmicappend(&micdata, &pframe[16], 6);
1071                                 else
1072                                         rtw_secmicappend(&micdata, &pframe[10], 6);
1073
1074                         }
1075
1076                     //if(pqospriv->qos_option==1)
1077                     if(pattrib->qos_en)
1078                                 priority[0]=(u8)pxmitframe->attrib.priority;
1079
1080
1081                         rtw_secmicappend(&micdata, &priority[0], 4);
1082
1083                         payload=pframe;
1084
1085                         for(curfragnum=0;curfragnum<pattrib->nr_frags;curfragnum++){
1086                                 payload=(u8 *)RND4((SIZE_PTR)(payload));
1087                                 RT_TRACE(_module_rtl871x_xmit_c_,_drv_err_,("===curfragnum=%d, pframe= 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x,!!!\n",
1088                                         curfragnum,*payload, *(payload+1),*(payload+2),*(payload+3),*(payload+4),*(payload+5),*(payload+6),*(payload+7)));
1089
1090                                 payload=payload+pattrib->hdrlen+pattrib->iv_len;
1091                                 RT_TRACE(_module_rtl871x_xmit_c_,_drv_err_,("curfragnum=%d pattrib->hdrlen=%d pattrib->iv_len=%d",curfragnum,pattrib->hdrlen,pattrib->iv_len));
1092                                 if((curfragnum+1)==pattrib->nr_frags){
1093                                         length=pattrib->last_txcmdsz-pattrib->hdrlen-pattrib->iv_len-( (pattrib->bswenc) ? pattrib->icv_len : 0);
1094                                         rtw_secmicappend(&micdata, payload,length);
1095                                         payload=payload+length;
1096                                 }
1097                                 else{
1098                                         length=pxmitpriv->frag_len-pattrib->hdrlen-pattrib->iv_len-( (pattrib->bswenc) ? pattrib->icv_len : 0);
1099                                         rtw_secmicappend(&micdata, payload, length);
1100                                         payload=payload+length+pattrib->icv_len;
1101                                         RT_TRACE(_module_rtl871x_xmit_c_,_drv_err_,("curfragnum=%d length=%d pattrib->icv_len=%d",curfragnum,length,pattrib->icv_len));
1102                                 }
1103                         }
1104                         rtw_secgetmic(&micdata,&(mic[0]));
1105                         RT_TRACE(_module_rtl871x_xmit_c_,_drv_err_,("xmitframe_addmic: before add mic code!!!\n"));
1106                         RT_TRACE(_module_rtl871x_xmit_c_,_drv_err_,("xmitframe_addmic: pattrib->last_txcmdsz=%d!!!\n",pattrib->last_txcmdsz));
1107                         RT_TRACE(_module_rtl871x_xmit_c_,_drv_err_,("xmitframe_addmic: mic[0]=0x%.2x ,mic[1]=0x%.2x ,mic[2]=0x%.2x ,mic[3]=0x%.2x \n\
1108   mic[4]=0x%.2x ,mic[5]=0x%.2x ,mic[6]=0x%.2x ,mic[7]=0x%.2x !!!!\n",
1109                                 mic[0],mic[1],mic[2],mic[3],mic[4],mic[5],mic[6],mic[7]));
1110                         //add mic code  and add the mic code length in last_txcmdsz
1111
1112                         _rtw_memcpy(payload, &(mic[0]),8);
1113                         pattrib->last_txcmdsz+=8;
1114
1115                         RT_TRACE(_module_rtl871x_xmit_c_,_drv_info_,("\n ========last pkt========\n"));
1116                         payload=payload-pattrib->last_txcmdsz+8;
1117                         for(curfragnum=0;curfragnum<pattrib->last_txcmdsz;curfragnum=curfragnum+8)
1118                                         RT_TRACE(_module_rtl871x_xmit_c_,_drv_info_,(" %.2x,  %.2x,  %.2x,  %.2x,  %.2x,  %.2x,  %.2x,  %.2x ",
1119                                         *(payload+curfragnum), *(payload+curfragnum+1), *(payload+curfragnum+2),*(payload+curfragnum+3),
1120                                         *(payload+curfragnum+4),*(payload+curfragnum+5),*(payload+curfragnum+6),*(payload+curfragnum+7)));
1121                         }
1122                         else{
1123                                 RT_TRACE(_module_rtl871x_xmit_c_,_drv_err_,("xmitframe_addmic: rtw_get_stainfo==NULL!!!\n"));
1124                         }
1125         }
1126
1127 _func_exit_;
1128
1129         return _SUCCESS;
1130 }
1131
1132 static s32 xmitframe_swencrypt(_adapter *padapter, struct xmit_frame *pxmitframe){
1133
1134         struct  pkt_attrib       *pattrib = &pxmitframe->attrib;
1135         //struct        security_priv   *psecuritypriv=&padapter->securitypriv;
1136
1137 _func_enter_;
1138
1139         //if((psecuritypriv->sw_encrypt)||(pattrib->bswenc))
1140         if(pattrib->bswenc)
1141         {
1142                 //DBG_871X("start xmitframe_swencrypt\n");
1143                 RT_TRACE(_module_rtl871x_xmit_c_,_drv_alert_,("### xmitframe_swencrypt\n"));
1144                 switch(pattrib->encrypt){
1145                 case _WEP40_:
1146                 case _WEP104_:
1147                         rtw_wep_encrypt(padapter, (u8 *)pxmitframe);
1148                         break;
1149                 case _TKIP_:
1150                         rtw_tkip_encrypt(padapter, (u8 *)pxmitframe);
1151                         break;
1152                 case _AES_:
1153                         rtw_aes_encrypt(padapter, (u8 * )pxmitframe);
1154                         break;
1155 #ifdef CONFIG_WAPI_SUPPORT
1156                 case _SMS4_:
1157                         rtw_sms4_encrypt(padapter, (u8 * )pxmitframe);
1158 #endif
1159                 default:
1160                                 break;
1161                 }
1162
1163         } else {
1164                 RT_TRACE(_module_rtl871x_xmit_c_,_drv_notice_,("### xmitframe_hwencrypt\n"));
1165         }
1166
1167 _func_exit_;
1168
1169         return _SUCCESS;
1170 }
1171
1172 s32 rtw_make_wlanhdr (_adapter *padapter , u8 *hdr, struct pkt_attrib *pattrib)
1173 {
1174         u16 *qc;
1175
1176         struct rtw_ieee80211_hdr *pwlanhdr = (struct rtw_ieee80211_hdr *)hdr;
1177         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1178         struct qos_priv *pqospriv = &pmlmepriv->qospriv;
1179         u8 qos_option = _FALSE;
1180 #ifdef CONFIG_TDLS
1181         struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
1182         struct sta_priv         *pstapriv = &padapter->stapriv;
1183         struct sta_info *ptdls_sta=NULL, *psta_backup=NULL;
1184         u8 direct_link=0;
1185 #endif //CONFIG_TDLS
1186
1187         sint res = _SUCCESS;
1188         u16 *fctrl = &pwlanhdr->frame_ctl;
1189
1190         struct sta_info *psta;
1191
1192         sint bmcst = IS_MCAST(pattrib->ra);
1193
1194 _func_enter_;
1195
1196         if (pattrib->psta) {
1197                 psta = pattrib->psta;
1198         } else {
1199                 DBG_871X("%s, call rtw_get_stainfo()\n", __func__);
1200                 if(bmcst) {
1201                         psta = rtw_get_bcmc_stainfo(padapter);
1202                 } else {
1203                         psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
1204                 }
1205         }
1206
1207         if(psta==NULL)
1208         {
1209                 DBG_871X("%s, psta==NUL\n", __func__);
1210                 return _FAIL;
1211         }
1212
1213         if(!(psta->state &_FW_LINKED))
1214         {
1215                 DBG_871X("%s, psta->state(0x%x) != _FW_LINKED\n", __func__, psta->state);
1216                 return _FAIL;
1217         }
1218
1219         _rtw_memset(hdr, 0, WLANHDR_OFFSET);
1220
1221         SetFrameSubType(fctrl, pattrib->subtype);
1222
1223         if (pattrib->subtype & WIFI_DATA_TYPE)
1224         {
1225                 if ((check_fwstate(pmlmepriv,  WIFI_STATION_STATE) == _TRUE)) {
1226                         //to_ds = 1, fr_ds = 0;
1227 #ifdef CONFIG_TDLS
1228                         if((ptdlsinfo->setup_state == TDLS_LINKED_STATE)){
1229                                 ptdls_sta = rtw_get_stainfo(pstapriv, pattrib->dst);
1230                                 if((ptdls_sta!=NULL)&&(ptdls_sta->tdls_sta_state & TDLS_LINKED_STATE)&&(pattrib->ether_type!=0x0806)){
1231                                         //TDLS data transfer, ToDS=0, FrDs=0
1232                                         _rtw_memcpy(pwlanhdr->addr1, pattrib->dst, ETH_ALEN);
1233                                         _rtw_memcpy(pwlanhdr->addr2, pattrib->src, ETH_ALEN);
1234                                         _rtw_memcpy(pwlanhdr->addr3, get_bssid(pmlmepriv), ETH_ALEN);
1235                                         direct_link=1;
1236                                 }else{
1237                                         // 1.Data transfer to AP
1238                                         // 2.Arp pkt will relayed by AP
1239                                         SetToDs(fctrl);
1240                                         _rtw_memcpy(pwlanhdr->addr1, get_bssid(pmlmepriv), ETH_ALEN);
1241                                         _rtw_memcpy(pwlanhdr->addr2, pattrib->src, ETH_ALEN);
1242                                         _rtw_memcpy(pwlanhdr->addr3, pattrib->dst, ETH_ALEN);
1243                                 }
1244                         }else
1245 #endif //CONFIG_TDLS
1246                         {
1247                                 //Data transfer to AP
1248                                 SetToDs(fctrl);
1249                                 _rtw_memcpy(pwlanhdr->addr1, get_bssid(pmlmepriv), ETH_ALEN);
1250                                 _rtw_memcpy(pwlanhdr->addr2, pattrib->src, ETH_ALEN);
1251                                 _rtw_memcpy(pwlanhdr->addr3, pattrib->dst, ETH_ALEN);
1252                         }
1253
1254                         if (pqospriv->qos_option)
1255                                 qos_option = _TRUE;
1256
1257                 }
1258                 else if ((check_fwstate(pmlmepriv,  WIFI_AP_STATE) == _TRUE) ) {
1259                         //to_ds = 0, fr_ds = 1;
1260                         SetFrDs(fctrl);
1261                         _rtw_memcpy(pwlanhdr->addr1, pattrib->dst, ETH_ALEN);
1262                         _rtw_memcpy(pwlanhdr->addr2, get_bssid(pmlmepriv), ETH_ALEN);
1263                         _rtw_memcpy(pwlanhdr->addr3, pattrib->src, ETH_ALEN);
1264
1265                         if(psta->qos_option)
1266                                 qos_option = _TRUE;
1267                 }
1268                 else if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == _TRUE) ||
1269                 (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == _TRUE)) {
1270                         _rtw_memcpy(pwlanhdr->addr1, pattrib->dst, ETH_ALEN);
1271                         _rtw_memcpy(pwlanhdr->addr2, pattrib->src, ETH_ALEN);
1272                         _rtw_memcpy(pwlanhdr->addr3, get_bssid(pmlmepriv), ETH_ALEN);
1273
1274                         if(psta->qos_option)
1275                                 qos_option = _TRUE;
1276                 }
1277                 else {
1278                         RT_TRACE(_module_rtl871x_xmit_c_,_drv_err_,("fw_state:%x is not allowed to xmit frame\n", get_fwstate(pmlmepriv)));
1279                         res = _FAIL;
1280                         goto exit;
1281                 }
1282
1283                 if(pattrib->mdata)
1284                         SetMData(fctrl);
1285
1286                 if (pattrib->encrypt)
1287                         SetPrivacy(fctrl);
1288
1289                 if (qos_option)
1290                 {
1291                         qc = (unsigned short *)(hdr + pattrib->hdrlen - 2);
1292
1293                         if (pattrib->priority)
1294                                 SetPriority(qc, pattrib->priority);
1295
1296                         SetEOSP(qc, pattrib->eosp);
1297
1298                         SetAckpolicy(qc, pattrib->ack_policy);
1299                 }
1300
1301                 //TODO: fill HT Control Field
1302
1303                 //Update Seq Num will be handled by f/w
1304                 {
1305                         if(psta){
1306 #ifdef CONFIG_TDLS
1307                                 if(direct_link==1)
1308                                 {
1309                                         psta_backup = psta;
1310                                         psta = ptdls_sta;
1311                                 }
1312 #endif //CONFIG_TDLS
1313
1314                                 psta->sta_xmitpriv.txseq_tid[pattrib->priority]++;
1315                                 psta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 0xFFF;
1316
1317                                 pattrib->seqnum = psta->sta_xmitpriv.txseq_tid[pattrib->priority];
1318
1319                                 SetSeqNum(hdr, pattrib->seqnum);
1320
1321 #ifdef CONFIG_80211N_HT
1322                                 //check if enable ampdu
1323                                 if(pattrib->ht_en && psta->htpriv.ampdu_enable)
1324                                 {
1325                                         if(psta->htpriv.agg_enable_bitmap & BIT(pattrib->priority))
1326                                         pattrib->ampdu_en = _TRUE;
1327                                 }
1328
1329                                 //re-check if enable ampdu by BA_starting_seqctrl
1330                                 if(pattrib->ampdu_en == _TRUE)
1331                                 {
1332                                         u16 tx_seq;
1333
1334                                         tx_seq = psta->BA_starting_seqctrl[pattrib->priority & 0x0f];
1335
1336                                         //check BA_starting_seqctrl
1337                                         if(SN_LESS(pattrib->seqnum, tx_seq))
1338                                         {
1339                                                 //DBG_871X("tx ampdu seqnum(%d) < tx_seq(%d)\n", pattrib->seqnum, tx_seq);
1340                                                 pattrib->ampdu_en = _FALSE;//AGG BK
1341                                         }
1342                                         else if(SN_EQUAL(pattrib->seqnum, tx_seq))
1343                                         {
1344                                                 psta->BA_starting_seqctrl[pattrib->priority & 0x0f] = (tx_seq+1)&0xfff;
1345
1346                                                 pattrib->ampdu_en = _TRUE;//AGG EN
1347                                         }
1348                                         else
1349                                         {
1350                                                 //DBG_871X("tx ampdu over run\n");
1351                                                 psta->BA_starting_seqctrl[pattrib->priority & 0x0f] = (pattrib->seqnum+1)&0xfff;
1352                                                 pattrib->ampdu_en = _TRUE;//AGG EN
1353                                         }
1354
1355                                 }
1356 #endif //CONFIG_80211N_HT
1357 #ifdef CONFIG_TDLS
1358                                 if(direct_link==1)
1359                                 {
1360                                         if (pattrib->encrypt){
1361                                                 pattrib->encrypt= _AES_;
1362                                                 pattrib->iv_len=8;
1363                                                 pattrib->icv_len=8;
1364                                         }
1365
1366                                         //qos_en, ht_en, init rate, ,bw, ch_offset, sgi
1367                                         //pattrib->qos_en = ptdls_sta->qos_option;
1368
1369                                         pattrib->raid = ptdls_sta->raid;
1370 #ifdef CONFIG_80211N_HT
1371                                         pattrib->bwmode = ptdls_sta->htpriv.bwmode;
1372                                         pattrib->ht_en = ptdls_sta->htpriv.ht_option;
1373                                         pattrib->ch_offset = ptdls_sta->htpriv.ch_offset;
1374                                         pattrib->sgi= ptdls_sta->htpriv.sgi;
1375 #endif //CONFIG_80211N_HT
1376                                         pattrib->mac_id = ptdls_sta->mac_id;
1377
1378                                         psta = psta_backup;
1379                                 }
1380 #endif //CONFIG_TDLS
1381
1382                         }
1383                 }
1384
1385         }
1386         else
1387         {
1388
1389         }
1390
1391 exit:
1392
1393 _func_exit_;
1394
1395         return res;
1396 }
1397
1398 s32 rtw_txframes_pending(_adapter *padapter)
1399 {
1400         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
1401
1402         return ((_rtw_queue_empty(&pxmitpriv->be_pending) == _FALSE) ||
1403                          (_rtw_queue_empty(&pxmitpriv->bk_pending) == _FALSE) ||
1404                          (_rtw_queue_empty(&pxmitpriv->vi_pending) == _FALSE) ||
1405                          (_rtw_queue_empty(&pxmitpriv->vo_pending) == _FALSE));
1406 }
1407
1408 s32 rtw_txframes_sta_ac_pending(_adapter *padapter, struct pkt_attrib *pattrib)
1409 {
1410         struct sta_info *psta;
1411         struct tx_servq *ptxservq;
1412         int priority = pattrib->priority;
1413
1414         if(pattrib->psta)
1415         {
1416                 psta = pattrib->psta;
1417         }
1418         else
1419         {
1420                 DBG_871X("%s, call rtw_get_stainfo()\n", __func__);
1421                 psta=rtw_get_stainfo(&padapter->stapriv ,&pattrib->ra[0]);
1422         }
1423
1424         if(psta==NULL)
1425         {
1426                 DBG_871X("%s, psta==NUL\n", __func__);
1427                 return 0;
1428         }
1429
1430         if(!(psta->state &_FW_LINKED))
1431         {
1432                 DBG_871X("%s, psta->state(0x%x) != _FW_LINKED\n", __func__, psta->state);
1433                 return 0;
1434         }
1435
1436         switch(priority)
1437         {
1438                         case 1:
1439                         case 2:
1440                                 ptxservq = &(psta->sta_xmitpriv.bk_q);
1441                                 break;
1442                         case 4:
1443                         case 5:
1444                                 ptxservq = &(psta->sta_xmitpriv.vi_q);
1445                                 break;
1446                         case 6:
1447                         case 7:
1448                                 ptxservq = &(psta->sta_xmitpriv.vo_q);
1449                                 break;
1450                         case 0:
1451                         case 3:
1452                         default:
1453                                 ptxservq = &(psta->sta_xmitpriv.be_q);
1454                         break;
1455
1456         }
1457
1458         return ptxservq->qcnt;
1459 }
1460
1461 #ifdef CONFIG_TDLS
1462
1463 int rtw_build_tdls_ies(_adapter * padapter, struct xmit_frame * pxmitframe, u8 *pframe, u8 action)
1464 {
1465         int res=_SUCCESS;
1466
1467         switch(action){
1468                 case TDLS_SETUP_REQUEST:
1469                         rtw_build_tdls_setup_req_ies(padapter, pxmitframe, pframe);
1470                         break;
1471                 case TDLS_SETUP_RESPONSE:
1472                         rtw_build_tdls_setup_rsp_ies(padapter, pxmitframe, pframe);
1473                         break;
1474                 case TDLS_SETUP_CONFIRM:
1475                         rtw_build_tdls_setup_cfm_ies(padapter, pxmitframe, pframe);
1476                         break;
1477                 case TDLS_TEARDOWN:
1478                         rtw_build_tdls_teardown_ies(padapter, pxmitframe, pframe);
1479                         break;
1480                 case TDLS_DISCOVERY_REQUEST:
1481                         rtw_build_tdls_dis_req_ies(padapter, pxmitframe, pframe);
1482                         break;
1483                 case TDLS_PEER_TRAFFIC_INDICATION:
1484                         rtw_build_tdls_peer_traffic_indication_ies(padapter, pxmitframe, pframe);
1485                         break;
1486                 case TDLS_CHANNEL_SWITCH_REQUEST:
1487                         rtw_build_tdls_ch_switch_req_ies(padapter, pxmitframe, pframe);
1488                         break;
1489                 case TDLS_CHANNEL_SWITCH_RESPONSE:
1490                         rtw_build_tdls_ch_switch_rsp_ies(padapter, pxmitframe, pframe);
1491                         break;
1492 #ifdef CONFIG_WFD
1493                 case TUNNELED_PROBE_REQ:
1494                         rtw_build_tunneled_probe_req_ies(padapter, pxmitframe, pframe);
1495                         break;
1496                 case TUNNELED_PROBE_RSP:
1497                         rtw_build_tunneled_probe_rsp_ies(padapter, pxmitframe, pframe);
1498                         break;
1499 #endif //CONFIG_WFD
1500                 default:
1501                         res=_FAIL;
1502                         break;
1503         }
1504
1505         return res;
1506 }
1507
1508 s32 rtw_make_tdls_wlanhdr (_adapter *padapter , u8 *hdr, struct pkt_attrib *pattrib, u8 action)
1509 {
1510         u16 *qc;
1511         struct rtw_ieee80211_hdr *pwlanhdr = (struct rtw_ieee80211_hdr *)hdr;
1512         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1513         struct qos_priv *pqospriv = &pmlmepriv->qospriv;
1514         struct sta_priv         *pstapriv = &padapter->stapriv;
1515         struct sta_info *psta=NULL, *ptdls_sta=NULL;
1516         u8 tdls_seq=0, baddr[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1517
1518         sint res = _SUCCESS;
1519         u16 *fctrl = &pwlanhdr->frame_ctl;
1520
1521 _func_enter_;
1522
1523         _rtw_memset(hdr, 0, WLANHDR_OFFSET);
1524
1525         SetFrameSubType(fctrl, pattrib->subtype);
1526
1527         switch(action){
1528                 case TDLS_SETUP_REQUEST:
1529                 case TDLS_SETUP_RESPONSE:
1530                 case TDLS_SETUP_CONFIRM:
1531                 case TDLS_TEARDOWN:     //directly to peer STA or via AP
1532                 case TDLS_PEER_TRAFFIC_INDICATION:
1533                 case TDLS_PEER_PSM_REQUEST:     //directly to peer STA or via AP
1534                 case TUNNELED_PROBE_REQ:
1535                 case TUNNELED_PROBE_RSP:
1536                         SetToDs(fctrl);
1537                         _rtw_memcpy(pwlanhdr->addr1, get_bssid(pmlmepriv), ETH_ALEN);
1538                         _rtw_memcpy(pwlanhdr->addr2, pattrib->src, ETH_ALEN);
1539                         _rtw_memcpy(pwlanhdr->addr3, pattrib->dst, ETH_ALEN);
1540                         break;
1541                 case TDLS_CHANNEL_SWITCH_REQUEST:
1542                 case TDLS_CHANNEL_SWITCH_RESPONSE:
1543                 case TDLS_PEER_PSM_RESPONSE:
1544                 case TDLS_PEER_TRAFFIC_RESPONSE:
1545                         _rtw_memcpy(pwlanhdr->addr1, pattrib->dst, ETH_ALEN);
1546                         _rtw_memcpy(pwlanhdr->addr2, pattrib->src, ETH_ALEN);
1547                         _rtw_memcpy(pwlanhdr->addr3, get_bssid(pmlmepriv), ETH_ALEN);
1548                         tdls_seq=1;
1549                         break;
1550                 case TDLS_DISCOVERY_REQUEST:    //unicast: directly to peer sta, Bcast: via AP
1551                         if(_rtw_memcmp(pattrib->dst, baddr, ETH_ALEN) )
1552                         {
1553                                 SetToDs(fctrl);
1554                                 _rtw_memcpy(pwlanhdr->addr1, get_bssid(pmlmepriv), ETH_ALEN);
1555                                 _rtw_memcpy(pwlanhdr->addr2, pattrib->src, ETH_ALEN);
1556                                 _rtw_memcpy(pwlanhdr->addr3, pattrib->dst, ETH_ALEN);
1557                         }
1558                         else
1559                         {
1560                                 _rtw_memcpy(pwlanhdr->addr1, pattrib->dst, ETH_ALEN);
1561                                 _rtw_memcpy(pwlanhdr->addr2, pattrib->src, ETH_ALEN);
1562                                 _rtw_memcpy(pwlanhdr->addr3, get_bssid(pmlmepriv), ETH_ALEN);
1563                                 tdls_seq=1;
1564                         }
1565                         break;
1566         }
1567
1568         if (pattrib->encrypt)
1569                 SetPrivacy(fctrl);
1570
1571         if (pqospriv->qos_option)
1572         {
1573                 qc = (unsigned short *)(hdr + pattrib->hdrlen - 2);
1574                 if (pattrib->priority)
1575                         SetPriority(qc, pattrib->priority);
1576                 SetAckpolicy(qc, pattrib->ack_policy);
1577         }
1578
1579         psta = pattrib->psta;
1580
1581         //  1. update seq_num per link by sta_info
1582         //  2. rewrite encrypt to _AES_, also rewrite iv_len, icv_len
1583         if(tdls_seq==1){
1584                 ptdls_sta=rtw_get_stainfo(pstapriv, pattrib->dst);
1585                 if(ptdls_sta){
1586                         ptdls_sta->sta_xmitpriv.txseq_tid[pattrib->priority]++;
1587                         ptdls_sta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 0xFFF;
1588                         pattrib->seqnum = ptdls_sta->sta_xmitpriv.txseq_tid[pattrib->priority];
1589                         SetSeqNum(hdr, pattrib->seqnum);
1590
1591                         if (pattrib->encrypt){
1592                                 pattrib->encrypt= _AES_;
1593                                 pattrib->iv_len=8;
1594                                 pattrib->icv_len=8;
1595                         }
1596                 }else{
1597                         res=_FAIL;
1598                         goto exit;
1599                 }
1600         }else if(psta){
1601                 psta->sta_xmitpriv.txseq_tid[pattrib->priority]++;
1602                 psta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 0xFFF;
1603                 pattrib->seqnum = psta->sta_xmitpriv.txseq_tid[pattrib->priority];
1604                 SetSeqNum(hdr, pattrib->seqnum);
1605         }
1606
1607
1608 exit:
1609
1610 _func_exit_;
1611
1612         return res;
1613 }
1614
1615 s32 rtw_xmit_tdls_coalesce(_adapter * padapter, struct xmit_frame * pxmitframe, u8 action)
1616 {
1617         s32 llc_sz;
1618
1619         u8 *pframe, *mem_start;
1620
1621         struct sta_info         *psta;
1622         struct sta_priv         *pstapriv = &padapter->stapriv;
1623         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
1624         struct pkt_attrib       *pattrib = &pxmitframe->attrib;
1625         u8 *pbuf_start;
1626         s32 bmcst = IS_MCAST(pattrib->ra);
1627         s32 res = _SUCCESS;
1628
1629 _func_enter_;
1630
1631         if (pattrib->psta) {
1632                 psta = pattrib->psta;
1633         } else {
1634                 if(bmcst) {
1635                         psta = rtw_get_bcmc_stainfo(padapter);
1636                 } else {
1637                         psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
1638                 }
1639         }
1640
1641         if(psta==NULL)
1642                 return _FAIL;
1643
1644         if (pxmitframe->buf_addr == NULL)
1645                 return _FAIL;
1646
1647         pbuf_start = pxmitframe->buf_addr;
1648         mem_start = pbuf_start + TXDESC_OFFSET;
1649
1650         if (rtw_make_tdls_wlanhdr(padapter, mem_start, pattrib, action) == _FAIL) {
1651                 res = _FAIL;
1652                 goto exit;
1653         }
1654
1655         pframe = mem_start;
1656         pframe += pattrib->hdrlen;
1657
1658         //adding icv, if necessary...
1659         if (pattrib->iv_len)
1660         {
1661                 if (psta != NULL)
1662                 {
1663                         switch(pattrib->encrypt)
1664                         {
1665                                 case _WEP40_:
1666                                 case _WEP104_:
1667                                                 WEP_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
1668                                         break;
1669                                 case _TKIP_:
1670                                         if(bmcst)
1671                                                 TKIP_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
1672                                         else
1673                                                 TKIP_IV(pattrib->iv, psta->dot11txpn, 0);
1674                                         break;
1675                                 case _AES_:
1676                                         if(bmcst)
1677                                                 AES_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
1678                                         else
1679                                                 AES_IV(pattrib->iv, psta->dot11txpn, 0);
1680                                         break;
1681                         }
1682                 }
1683
1684                 _rtw_memcpy(pframe, pattrib->iv, pattrib->iv_len);
1685                 pframe += pattrib->iv_len;
1686
1687         }
1688
1689         llc_sz = rtw_put_snap(pframe, pattrib->ether_type);
1690         pframe += llc_sz;
1691
1692         //pattrib->pktlen will be counted in rtw_build_tdls_ies
1693         pattrib->pktlen = 0;
1694
1695         rtw_build_tdls_ies(padapter, pxmitframe, pframe, action);
1696
1697         if ((pattrib->icv_len >0 )&& (pattrib->bswenc)) {
1698                 pframe += pattrib->pktlen;
1699                 _rtw_memcpy(pframe, pattrib->icv, pattrib->icv_len);
1700                 pframe += pattrib->icv_len;
1701         }
1702
1703         pattrib->nr_frags = 1;
1704         pattrib->last_txcmdsz = pattrib->hdrlen + pattrib->iv_len + llc_sz +
1705                         ((pattrib->bswenc) ? pattrib->icv_len : 0) + pattrib->pktlen;
1706
1707         if (xmitframe_addmic(padapter, pxmitframe) == _FAIL)
1708         {
1709                 goto exit;
1710         }
1711
1712         xmitframe_swencrypt(padapter, pxmitframe);
1713
1714         update_attrib_vcs_info(padapter, pxmitframe);
1715
1716 exit:
1717
1718 _func_exit_;
1719
1720         return res;
1721 }
1722 #endif //CONFIG_TDLS
1723
1724 /*
1725  * Calculate wlan 802.11 packet MAX size from pkt_attrib
1726  * This function doesn't consider fragment case
1727  */
1728 u32 rtw_calculate_wlan_pkt_size_by_attribue(struct pkt_attrib *pattrib)
1729 {
1730         u32     len = 0;
1731
1732         len = pattrib->hdrlen + pattrib->iv_len; // WLAN Header and IV
1733         len += SNAP_SIZE + sizeof(u16); // LLC
1734         len += pattrib->pktlen;
1735         if (pattrib->encrypt == _TKIP_) len += 8; // MIC
1736         len += ((pattrib->bswenc) ? pattrib->icv_len : 0); // ICV
1737
1738         return len;
1739 }
1740
1741 /*
1742
1743 This sub-routine will perform all the following:
1744
1745 1. remove 802.3 header.
1746 2. create wlan_header, based on the info in pxmitframe
1747 3. append sta's iv/ext-iv
1748 4. append LLC
1749 5. move frag chunk from pframe to pxmitframe->mem
1750 6. apply sw-encrypt, if necessary.
1751
1752 */
1753 s32 rtw_xmitframe_coalesce(_adapter *padapter, _pkt *pkt, struct xmit_frame *pxmitframe)
1754 {
1755         struct pkt_file pktfile;
1756
1757         s32 frg_inx, frg_len, mpdu_len, llc_sz, mem_sz;
1758
1759         SIZE_PTR addr;
1760
1761         u8 *pframe, *mem_start;
1762         u8 hw_hdr_offset;
1763
1764         struct sta_info         *psta;
1765         //struct sta_priv               *pstapriv = &padapter->stapriv;
1766         //struct mlme_priv      *pmlmepriv = &padapter->mlmepriv;
1767         struct xmit_priv        *pxmitpriv = &padapter->xmitpriv;
1768
1769         struct pkt_attrib       *pattrib = &pxmitframe->attrib;
1770
1771         u8 *pbuf_start;
1772
1773         s32 bmcst = IS_MCAST(pattrib->ra);
1774         s32 res = _SUCCESS;
1775
1776 _func_enter_;
1777
1778         if (pattrib->psta)
1779         {
1780                 psta = pattrib->psta;
1781         } else
1782         {
1783                 DBG_871X("%s, call rtw_get_stainfo()\n", __func__);
1784                 psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
1785         }
1786
1787         if(psta==NULL)
1788         {
1789
1790                 DBG_871X("%s, psta==NUL\n", __func__);
1791                 return _FAIL;
1792         }
1793
1794
1795         if(!(psta->state &_FW_LINKED))
1796         {
1797                 DBG_871X("%s, psta->state(0x%x) != _FW_LINKED\n", __func__, psta->state);
1798                 return _FAIL;
1799         }
1800
1801         if (pxmitframe->buf_addr == NULL){
1802                 DBG_8192C("==> %s buf_addr==NULL \n",__FUNCTION__);
1803                 return _FAIL;
1804         }
1805
1806         pbuf_start = pxmitframe->buf_addr;
1807
1808 #ifdef CONFIG_USB_TX_AGGREGATION
1809         hw_hdr_offset =  TXDESC_SIZE + (pxmitframe->pkt_offset * PACKET_OFFSET_SZ);
1810 #else
1811         #ifdef CONFIG_TX_EARLY_MODE //for SDIO && Tx Agg
1812         hw_hdr_offset = TXDESC_OFFSET + EARLY_MODE_INFO_SIZE;
1813         #else
1814         hw_hdr_offset = TXDESC_OFFSET;
1815         #endif
1816 #endif
1817
1818         mem_start = pbuf_start +        hw_hdr_offset;
1819
1820         if (rtw_make_wlanhdr(padapter, mem_start, pattrib) == _FAIL) {
1821                 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, ("rtw_xmitframe_coalesce: rtw_make_wlanhdr fail; drop pkt\n"));
1822                 DBG_8192C("rtw_xmitframe_coalesce: rtw_make_wlanhdr fail; drop pkt\n");
1823                 res = _FAIL;
1824                 goto exit;
1825         }
1826
1827         _rtw_open_pktfile(pkt, &pktfile);
1828         _rtw_pktfile_read(&pktfile, NULL, pattrib->pkt_hdrlen);
1829
1830         frg_inx = 0;
1831         frg_len = pxmitpriv->frag_len - 4;//2346-4 = 2342
1832
1833         while (1)
1834         {
1835                 llc_sz = 0;
1836
1837                 mpdu_len = frg_len;
1838
1839                 pframe = mem_start;
1840
1841                 SetMFrag(mem_start);
1842
1843                 pframe += pattrib->hdrlen;
1844                 mpdu_len -= pattrib->hdrlen;
1845
1846                 //adding icv, if necessary...
1847                 if (pattrib->iv_len)
1848                 {
1849                         //if (check_fwstate(pmlmepriv, WIFI_MP_STATE))
1850                         //      psta = rtw_get_stainfo(pstapriv, get_bssid(pmlmepriv));
1851                         //else
1852                         //      psta = rtw_get_stainfo(pstapriv, pattrib->ra);
1853
1854                         if (psta != NULL)
1855                         {
1856                                 switch(pattrib->encrypt)
1857                                 {
1858                                         case _WEP40_:
1859                                         case _WEP104_:
1860                                                         WEP_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
1861                                                 break;
1862                                         case _TKIP_:
1863                                                 if(bmcst)
1864                                                         TKIP_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
1865                                                 else
1866                                                         TKIP_IV(pattrib->iv, psta->dot11txpn, 0);
1867                                                 break;
1868                                         case _AES_:
1869                                                 if(bmcst)
1870                                                         AES_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
1871                                                 else
1872                                                         AES_IV(pattrib->iv, psta->dot11txpn, 0);
1873                                                 break;
1874 #ifdef CONFIG_WAPI_SUPPORT
1875                                         case _SMS4_:
1876                                                 rtw_wapi_get_iv(padapter,pattrib->ra,pattrib->iv);
1877                                                 break;
1878 #endif
1879                                 }
1880                         }
1881
1882                         _rtw_memcpy(pframe, pattrib->iv, pattrib->iv_len);
1883
1884                         RT_TRACE(_module_rtl871x_xmit_c_, _drv_notice_,
1885                                  ("rtw_xmitframe_coalesce: keyid=%d pattrib->iv[3]=%.2x pframe=%.2x %.2x %.2x %.2x\n",
1886                                   padapter->securitypriv.dot11PrivacyKeyIndex, pattrib->iv[3], *pframe, *(pframe+1), *(pframe+2), *(pframe+3)));
1887
1888                         pframe += pattrib->iv_len;
1889
1890                         mpdu_len -= pattrib->iv_len;
1891                 }
1892
1893                 if (frg_inx == 0) {
1894                         llc_sz = rtw_put_snap(pframe, pattrib->ether_type);
1895                         pframe += llc_sz;
1896                         mpdu_len -= llc_sz;
1897                 }
1898
1899                 if ((pattrib->icv_len >0) && (pattrib->bswenc)) {
1900                         mpdu_len -= pattrib->icv_len;
1901                 }
1902
1903
1904                 if (bmcst) {
1905                         // don't do fragment to broadcat/multicast packets
1906                         mem_sz = _rtw_pktfile_read(&pktfile, pframe, pattrib->pktlen);
1907                 } else {
1908                         mem_sz = _rtw_pktfile_read(&pktfile, pframe, mpdu_len);
1909                 }
1910
1911                 pframe += mem_sz;
1912
1913                 if ((pattrib->icv_len >0 )&& (pattrib->bswenc)) {
1914                         _rtw_memcpy(pframe, pattrib->icv, pattrib->icv_len);
1915                         pframe += pattrib->icv_len;
1916                 }
1917
1918                 frg_inx++;
1919
1920                 if (bmcst || (rtw_endofpktfile(&pktfile) == _TRUE))
1921                 {
1922                         pattrib->nr_frags = frg_inx;
1923
1924                         pattrib->last_txcmdsz = pattrib->hdrlen + pattrib->iv_len + ((pattrib->nr_frags==1)? llc_sz:0) +
1925                                         ((pattrib->bswenc) ? pattrib->icv_len : 0) + mem_sz;
1926
1927                         ClearMFrag(mem_start);
1928
1929                         break;
1930                 } else {
1931                         RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, ("%s: There're still something in packet!\n", __FUNCTION__));
1932                 }
1933
1934                 addr = (SIZE_PTR)(pframe);
1935
1936                 mem_start = (unsigned char *)RND4(addr) + hw_hdr_offset;
1937                 _rtw_memcpy(mem_start, pbuf_start + hw_hdr_offset, pattrib->hdrlen);
1938
1939         }
1940
1941         if (xmitframe_addmic(padapter, pxmitframe) == _FAIL)
1942         {
1943                 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, ("xmitframe_addmic(padapter, pxmitframe)==_FAIL\n"));
1944                 DBG_8192C("xmitframe_addmic(padapter, pxmitframe)==_FAIL\n");
1945                 res = _FAIL;
1946                 goto exit;
1947         }
1948
1949         xmitframe_swencrypt(padapter, pxmitframe);
1950
1951         if(bmcst == _FALSE)
1952                 update_attrib_vcs_info(padapter, pxmitframe);
1953         else
1954                 pattrib->vcs_mode = NONE_VCS;
1955
1956 exit:
1957
1958 _func_exit_;
1959
1960         return res;
1961 }
1962
1963 #ifdef CONFIG_IEEE80211W
1964 //broadcast or multicast management pkt use BIP, unicast management pkt use CCMP encryption
1965 s32 rtw_mgmt_xmitframe_coalesce(_adapter *padapter, _pkt *pkt, struct xmit_frame *pxmitframe)
1966 {
1967         struct pkt_file pktfile;
1968         s32 frg_inx, frg_len, mpdu_len, llc_sz, mem_sz;
1969         SIZE_PTR addr;
1970         u8 *pframe, *mem_start = NULL, *tmp_buf=NULL;
1971         u8 hw_hdr_offset, subtype ;
1972         struct sta_info         *psta = NULL;
1973         struct xmit_priv        *pxmitpriv = &padapter->xmitpriv;
1974         struct pkt_attrib       *pattrib = &pxmitframe->attrib;
1975         u8 *pbuf_start;
1976         s32 bmcst = IS_MCAST(pattrib->ra);
1977         s32 res = _FAIL;
1978         u8 *BIP_AAD;
1979         u8 *MGMT_body=NULL;
1980
1981         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
1982         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
1983         struct rtw_ieee80211_hdr        *pwlanhdr;
1984         u8 MME[_MME_IE_LENGTH_];
1985
1986         _irqL irqL;
1987         u32     ori_len;
1988         mem_start = pframe = (u8 *)(pxmitframe->buf_addr) + TXDESC_OFFSET;
1989         pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
1990         tmp_buf = BIP_AAD;
1991
1992 _func_enter_;
1993         ori_len = BIP_AAD_SIZE+pattrib->pktlen;
1994         tmp_buf = BIP_AAD = rtw_zmalloc(ori_len);
1995         subtype = GetFrameSubType(pframe); //bit(7)~bit(2)
1996
1997         if(BIP_AAD == NULL)
1998                 return _FAIL;
1999
2000         _enter_critical_bh(&padapter->security_key_mutex, &irqL);
2001
2002         //only support station mode
2003         if(!check_fwstate(pmlmepriv, WIFI_STATION_STATE) || !check_fwstate(pmlmepriv, _FW_LINKED))
2004                 goto xmitframe_coalesce_success;
2005
2006         //IGTK key is not install, it may not support 802.11w
2007         if(padapter->securitypriv.binstallBIPkey != _TRUE)
2008         {
2009                 DBG_871X("no instll BIP key\n");
2010                 goto xmitframe_coalesce_success;
2011         }
2012         //station mode doesn't need TX BIP, just ready the code
2013         if(bmcst)
2014         {
2015                 int frame_body_len;
2016                 u8 mic[16];
2017
2018                 _rtw_memset(MME, 0, 18);
2019
2020                 //other types doesn't need the BIP
2021                 if(GetFrameSubType(pframe) != WIFI_DEAUTH && GetFrameSubType(pframe) != WIFI_DISASSOC)
2022                         goto xmitframe_coalesce_fail;
2023
2024                 MGMT_body = pframe + sizeof(struct rtw_ieee80211_hdr_3addr);
2025                 pframe += pattrib->pktlen;
2026
2027                 //octent 0 and 1 is key index ,BIP keyid is 4 or 5, LSB only need octent 0
2028                 MME[0]=padapter->securitypriv.dot11wBIPKeyid;
2029                 //copy packet number
2030                 _rtw_memcpy(&MME[2], &pmlmeext->mgnt_80211w_IPN, 6);
2031                 //increase the packet number
2032                 pmlmeext->mgnt_80211w_IPN++;
2033
2034                 //add MME IE with MIC all zero, MME string doesn't include element id and length
2035                 pframe = rtw_set_ie(pframe, _MME_IE_ , 16 , MME, &(pattrib->pktlen));
2036                 pattrib->last_txcmdsz = pattrib->pktlen;
2037                 // total frame length - header length
2038                 frame_body_len = pattrib->pktlen - sizeof(struct rtw_ieee80211_hdr_3addr);
2039
2040                 //conscruct AAD, copy frame control field
2041                 _rtw_memcpy(BIP_AAD, &pwlanhdr->frame_ctl, 2);
2042                 ClearRetry(BIP_AAD);
2043                 ClearPwrMgt(BIP_AAD);
2044                 ClearMData(BIP_AAD);
2045                 //conscruct AAD, copy address 1 to address 3
2046                 _rtw_memcpy(BIP_AAD+2, pwlanhdr->addr1, 18);
2047                 //copy management fram body
2048                 _rtw_memcpy(BIP_AAD+BIP_AAD_SIZE, MGMT_body, frame_body_len);
2049                 /*//dump total packet include MME with zero MIC
2050                 {
2051                         int i;
2052                         printk("Total packet: ");
2053                         for(i=0; i < BIP_AAD_SIZE+frame_body_len; i++)
2054                                 printk(" %02x ", BIP_AAD[i]);
2055                         printk("\n");
2056                 }*/
2057                 //calculate mic
2058                 if(omac1_aes_128(padapter->securitypriv.dot11wBIPKey[padapter->securitypriv.dot11wBIPKeyid].skey
2059                         , BIP_AAD, BIP_AAD_SIZE+frame_body_len, mic))
2060                         goto xmitframe_coalesce_fail;
2061
2062                 /*//dump calculated mic result
2063                 {
2064                         int i;
2065                         printk("Calculated mic result: ");
2066                         for(i=0; i<16; i++)
2067                                 printk(" %02x ", mic[i]);
2068                         printk("\n");
2069                 }*/
2070                 //copy right BIP mic value, total is 128bits, we use the 0~63 bits
2071                 _rtw_memcpy(pframe-8, mic, 8);
2072                 /*/dump all packet after mic ok
2073                 {
2074                         int pp;
2075                         printk("pattrib->pktlen = %d \n", pattrib->pktlen);
2076                         for(pp=0;pp< pattrib->pktlen; pp++)
2077                                 printk(" %02x ", mem_start[pp]);
2078                         printk("\n");
2079                 }*/
2080         }
2081         else //unicast mgmt frame TX
2082         {
2083                 //start to encrypt mgmt frame
2084                 if(subtype == WIFI_DEAUTH || subtype == WIFI_DISASSOC ||
2085                         subtype == WIFI_REASSOCREQ || subtype == WIFI_ACTION)
2086                 {
2087                         if (pattrib->psta)
2088                                 psta = pattrib->psta;
2089                         else
2090                         {
2091                                 psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
2092                         }
2093
2094                         if(psta==NULL)
2095                     {
2096
2097                                 DBG_871X("%s, psta==NUL\n", __func__);
2098                                 goto xmitframe_coalesce_fail;
2099                         }
2100
2101                         if(!(psta->state & _FW_LINKED) || pxmitframe->buf_addr==NULL)
2102                         {
2103                                 DBG_871X("%s, not _FW_LINKED or addr null\n", __func__);
2104                                 goto xmitframe_coalesce_fail;
2105                         }
2106
2107                         //DBG_871X("%s, action frame category=%d \n", __func__, pframe[WLAN_HDR_A3_LEN]);
2108                         //according 802.11-2012 standard, these five types are not robust types
2109                         if(subtype == WIFI_ACTION &&
2110                         (pframe[WLAN_HDR_A3_LEN] == RTW_WLAN_CATEGORY_PUBLIC ||
2111                         pframe[WLAN_HDR_A3_LEN] == RTW_WLAN_CATEGORY_HT ||
2112                         pframe[WLAN_HDR_A3_LEN] == RTW_WLAN_CATEGORY_UNPROTECTED_WNM ||
2113                         pframe[WLAN_HDR_A3_LEN] == RTW_WLAN_CATEGORY_SELF_PROTECTED  ||
2114                         pframe[WLAN_HDR_A3_LEN] == RTW_WLAN_CATEGORY_P2P))
2115                                 goto xmitframe_coalesce_fail;
2116                         /*//before encrypt dump the management packet content
2117                         {
2118                                 int i;
2119                                 printk("Management pkt: ");
2120                                 for(i=0; i<pattrib->pktlen; i++)
2121                                 printk(" %02x ", pframe[i]);
2122                                 printk("=======\n");
2123                         }*/
2124
2125                         //bakeup original management packet
2126                         _rtw_memcpy(tmp_buf, pframe, pattrib->pktlen);
2127                         //move to data portion
2128                         pframe += pattrib->hdrlen;
2129
2130                         //802.11w unicast management packet must be _AES_
2131                         pattrib->iv_len = 8;
2132                         //it's MIC of AES
2133                         pattrib->icv_len = 8;
2134
2135                         switch(pattrib->encrypt)
2136                         {
2137                                 case _AES_:
2138                                                 //set AES IV header
2139                                                 AES_IV(pattrib->iv, psta->dot11wtxpn, 0);
2140                                         break;
2141                                 default:
2142                                         goto xmitframe_coalesce_fail;
2143                         }
2144                         //insert iv header into management frame
2145                         _rtw_memcpy(pframe, pattrib->iv, pattrib->iv_len);
2146                         pframe += pattrib->iv_len;
2147                         //copy mgmt data portion after CCMP header
2148                         _rtw_memcpy(pframe, tmp_buf+pattrib->hdrlen, pattrib->pktlen-pattrib->hdrlen);
2149                         //move pframe to end of mgmt pkt
2150                         pframe += pattrib->pktlen-pattrib->hdrlen;
2151                         //add 8 bytes CCMP IV header to length
2152                         pattrib->pktlen += pattrib->iv_len;
2153                         /*//dump management packet include AES IV header
2154                         {
2155                                 int i;
2156                                 printk("Management pkt + IV: ");
2157                                 //for(i=0; i<pattrib->pktlen; i++)
2158                                 //printk(" %02x ", mem_start[i]);
2159                                 printk("@@@@@@@@@@@@@\n");
2160                         }*/
2161
2162                         if ((pattrib->icv_len >0 )&& (pattrib->bswenc)) {
2163                                 _rtw_memcpy(pframe, pattrib->icv, pattrib->icv_len);
2164                                 pframe += pattrib->icv_len;
2165                         }
2166                         //add 8 bytes MIC
2167                         pattrib->pktlen += pattrib->icv_len;
2168                         //set final tx command size
2169                         pattrib->last_txcmdsz = pattrib->pktlen;
2170
2171                         //set protected bit must be beofre SW encrypt
2172                         SetPrivacy(mem_start);
2173                         /*//dump management packet include AES header
2174                         {
2175                                 int i;
2176                                 printk("prepare to enc Management pkt + IV: ");
2177                                 for(i=0; i<pattrib->pktlen; i++)
2178                                 printk(" %02x ", mem_start[i]);
2179                                 printk("@@@@@@@@@@@@@\n");
2180                         }*/
2181                         //software encrypt
2182                         xmitframe_swencrypt(padapter, pxmitframe);
2183                 }
2184         }
2185
2186 xmitframe_coalesce_success:
2187         _exit_critical_bh(&padapter->security_key_mutex, &irqL);
2188         rtw_mfree(BIP_AAD, ori_len);
2189 _func_exit_;
2190         return _SUCCESS;
2191
2192 xmitframe_coalesce_fail:
2193         _exit_critical_bh(&padapter->security_key_mutex, &irqL);
2194         rtw_mfree(BIP_AAD, ori_len);
2195 _func_exit_;
2196
2197         return _FAIL;
2198 }
2199 #endif //CONFIG_IEEE80211W
2200
2201 /* Logical Link Control(LLC) SubNetwork Attachment Point(SNAP) header
2202  * IEEE LLC/SNAP header contains 8 octets
2203  * First 3 octets comprise the LLC portion
2204  * SNAP portion, 5 octets, is divided into two fields:
2205  *      Organizationally Unique Identifier(OUI), 3 octets,
2206  *      type, defined by that organization, 2 octets.
2207  */
2208 s32 rtw_put_snap(u8 *data, u16 h_proto)
2209 {
2210         struct ieee80211_snap_hdr *snap;
2211         u8 *oui;
2212
2213 _func_enter_;
2214
2215         snap = (struct ieee80211_snap_hdr *)data;
2216         snap->dsap = 0xaa;
2217         snap->ssap = 0xaa;
2218         snap->ctrl = 0x03;
2219
2220         if (h_proto == 0x8137 || h_proto == 0x80f3)
2221                 oui = P802_1H_OUI;
2222         else
2223                 oui = RFC1042_OUI;
2224
2225         snap->oui[0] = oui[0];
2226         snap->oui[1] = oui[1];
2227         snap->oui[2] = oui[2];
2228
2229         *(u16 *)(data + SNAP_SIZE) = htons(h_proto);
2230
2231 _func_exit_;
2232
2233         return SNAP_SIZE + sizeof(u16);
2234 }
2235
2236 void rtw_update_protection(_adapter *padapter, u8 *ie, uint ie_len)
2237 {
2238
2239         uint    protection;
2240         u8      *perp;
2241         sint     erp_len;
2242         struct  xmit_priv *pxmitpriv = &padapter->xmitpriv;
2243         struct  registry_priv *pregistrypriv = &padapter->registrypriv;
2244
2245 _func_enter_;
2246
2247         switch(pxmitpriv->vcs_setting)
2248         {
2249                 case DISABLE_VCS:
2250                         pxmitpriv->vcs = NONE_VCS;
2251                         break;
2252
2253                 case ENABLE_VCS:
2254                         break;
2255
2256                 case AUTO_VCS:
2257                 default:
2258                         perp = rtw_get_ie(ie, _ERPINFO_IE_, &erp_len, ie_len);
2259                         if(perp == NULL)
2260                         {
2261                                 pxmitpriv->vcs = NONE_VCS;
2262                         }
2263                         else
2264                         {
2265                                 protection = (*(perp + 2)) & BIT(1);
2266                                 if (protection)
2267                                 {
2268                                         if(pregistrypriv->vcs_type == RTS_CTS)
2269                                                 pxmitpriv->vcs = RTS_CTS;
2270                                         else
2271                                                 pxmitpriv->vcs = CTS_TO_SELF;
2272                                 }
2273                                 else
2274                                         pxmitpriv->vcs = NONE_VCS;
2275                         }
2276
2277                         break;
2278
2279         }
2280
2281 _func_exit_;
2282
2283 }
2284
2285 void rtw_count_tx_stats(PADAPTER padapter, struct xmit_frame *pxmitframe, int sz)
2286 {
2287         struct sta_info *psta = NULL;
2288         struct stainfo_stats *pstats = NULL;
2289         struct xmit_priv        *pxmitpriv = &padapter->xmitpriv;
2290         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
2291
2292         if ((pxmitframe->frame_tag&0x0f) == DATA_FRAMETAG)
2293         {
2294                 pxmitpriv->tx_bytes += sz;
2295 #if defined(CONFIG_USB_TX_AGGREGATION) || defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
2296                 pmlmepriv->LinkDetectInfo.NumTxOkInPeriod += pxmitframe->agg_num;
2297 #else
2298                 pmlmepriv->LinkDetectInfo.NumTxOkInPeriod++;
2299 #endif
2300
2301                 psta = pxmitframe->attrib.psta;
2302                 if (psta)
2303                 {
2304                         pstats = &psta->sta_stats;
2305 #if defined(CONFIG_USB_TX_AGGREGATION) || defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
2306                         pstats->tx_pkts += pxmitframe->agg_num;
2307 #else
2308                         pstats->tx_pkts++;
2309 #endif
2310                         pstats->tx_bytes += sz;
2311                 }
2312         }
2313 }
2314
2315 struct xmit_buf *rtw_alloc_xmitbuf_ext(struct xmit_priv *pxmitpriv)
2316 {
2317         _irqL irqL;
2318         struct xmit_buf *pxmitbuf =  NULL;
2319         _list *plist, *phead;
2320         _queue *pfree_queue = &pxmitpriv->free_xmit_extbuf_queue;
2321
2322 _func_enter_;
2323
2324         _enter_critical(&pfree_queue->lock, &irqL);
2325
2326         if(_rtw_queue_empty(pfree_queue) == _TRUE) {
2327                 pxmitbuf = NULL;
2328         } else {
2329
2330                 phead = get_list_head(pfree_queue);
2331
2332                 plist = get_next(phead);
2333
2334                 pxmitbuf = LIST_CONTAINOR(plist, struct xmit_buf, list);
2335
2336                 rtw_list_delete(&(pxmitbuf->list));
2337         }
2338
2339         if (pxmitbuf !=  NULL)
2340         {
2341                 pxmitpriv->free_xmit_extbuf_cnt--;
2342                 #ifdef DBG_XMIT_BUF_EXT
2343                 DBG_871X("DBG_XMIT_BUF_EXT ALLOC no=%d,  free_xmit_extbuf_cnt=%d\n",pxmitbuf->no, pxmitpriv->free_xmit_extbuf_cnt);
2344                 #endif
2345
2346
2347                 pxmitbuf->priv_data = NULL;
2348                 //pxmitbuf->ext_tag = _TRUE;
2349
2350 #if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
2351                 pxmitbuf->len = 0;
2352                 pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
2353 #endif
2354 #ifdef CONFIG_PCI_HCI
2355                 pxmitbuf->len = 0;
2356 #endif
2357
2358                 if (pxmitbuf->sctx) {
2359                         DBG_871X("%s pxmitbuf->sctx is not NULL\n", __func__);
2360                         rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_ALLOC);
2361                 }
2362
2363         }
2364
2365         _exit_critical(&pfree_queue->lock, &irqL);
2366
2367 _func_exit_;
2368
2369         return pxmitbuf;
2370 }
2371
2372 s32 rtw_free_xmitbuf_ext(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
2373 {
2374         _irqL irqL;
2375         _queue *pfree_queue = &pxmitpriv->free_xmit_extbuf_queue;
2376
2377 _func_enter_;
2378
2379         if(pxmitbuf==NULL)
2380         {
2381                 return _FAIL;
2382         }
2383
2384         _enter_critical(&pfree_queue->lock, &irqL);
2385
2386         rtw_list_delete(&pxmitbuf->list);
2387
2388         rtw_list_insert_tail(&(pxmitbuf->list), get_list_head(pfree_queue));
2389         pxmitpriv->free_xmit_extbuf_cnt++;
2390         #ifdef DBG_XMIT_BUF_EXT
2391         DBG_871X("DBG_XMIT_BUF_EXT FREE no=%d, free_xmit_extbuf_cnt=%d\n",pxmitbuf->no ,pxmitpriv->free_xmit_extbuf_cnt);
2392         #endif
2393
2394         _exit_critical(&pfree_queue->lock, &irqL);
2395
2396 _func_exit_;
2397
2398         return _SUCCESS;
2399 }
2400
2401 struct xmit_buf *rtw_alloc_xmitbuf(struct xmit_priv *pxmitpriv)
2402 {
2403         _irqL irqL;
2404         struct xmit_buf *pxmitbuf =  NULL;
2405         _list *plist, *phead;
2406         _queue *pfree_xmitbuf_queue = &pxmitpriv->free_xmitbuf_queue;
2407
2408 _func_enter_;
2409
2410         //DBG_871X("+rtw_alloc_xmitbuf\n");
2411
2412         _enter_critical(&pfree_xmitbuf_queue->lock, &irqL);
2413
2414         if(_rtw_queue_empty(pfree_xmitbuf_queue) == _TRUE) {
2415                 pxmitbuf = NULL;
2416         } else {
2417
2418                 phead = get_list_head(pfree_xmitbuf_queue);
2419
2420                 plist = get_next(phead);
2421
2422                 pxmitbuf = LIST_CONTAINOR(plist, struct xmit_buf, list);
2423
2424                 rtw_list_delete(&(pxmitbuf->list));
2425         }
2426
2427         if (pxmitbuf !=  NULL)
2428         {
2429                 pxmitpriv->free_xmitbuf_cnt--;
2430                 #ifdef DBG_XMIT_BUF
2431                 DBG_871X("DBG_XMIT_BUF ALLOC no=%d,  free_xmitbuf_cnt=%d\n",pxmitbuf->no, pxmitpriv->free_xmitbuf_cnt);
2432                 #endif
2433                 //DBG_871X("alloc, free_xmitbuf_cnt=%d\n", pxmitpriv->free_xmitbuf_cnt);
2434
2435                 pxmitbuf->priv_data = NULL;
2436                 //pxmitbuf->ext_tag = _FALSE;
2437 #if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
2438                 pxmitbuf->len = 0;
2439                 pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
2440                 pxmitbuf->agg_num = 0;
2441                 pxmitbuf->pg_num = 0;
2442 #endif
2443 #ifdef CONFIG_PCI_HCI
2444                 pxmitbuf->len = 0;
2445 #endif
2446
2447                 if (pxmitbuf->sctx) {
2448                         DBG_871X("%s pxmitbuf->sctx is not NULL\n", __func__);
2449                         rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_ALLOC);
2450                 }
2451         }
2452         #ifdef DBG_XMIT_BUF
2453         else
2454         {
2455                 DBG_871X("DBG_XMIT_BUF rtw_alloc_xmitbuf return NULL\n");
2456         }
2457         #endif
2458
2459         _exit_critical(&pfree_xmitbuf_queue->lock, &irqL);
2460
2461 _func_exit_;
2462
2463         return pxmitbuf;
2464 }
2465
2466 s32 rtw_free_xmitbuf(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
2467 {
2468         _irqL irqL;
2469         _queue *pfree_xmitbuf_queue = &pxmitpriv->free_xmitbuf_queue;
2470
2471 _func_enter_;
2472
2473         //DBG_871X("+rtw_free_xmitbuf\n");
2474
2475         if(pxmitbuf==NULL)
2476         {
2477                 return _FAIL;
2478         }
2479
2480         if (pxmitbuf->sctx) {
2481                 DBG_871X("%s pxmitbuf->sctx is not NULL\n", __func__);
2482                 rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_FREE);
2483         }
2484
2485         if(pxmitbuf->ext_tag)
2486         {
2487                 rtw_free_xmitbuf_ext(pxmitpriv, pxmitbuf);
2488         }
2489         else
2490         {
2491                 _enter_critical(&pfree_xmitbuf_queue->lock, &irqL);
2492
2493                 rtw_list_delete(&pxmitbuf->list);
2494
2495                 rtw_list_insert_tail(&(pxmitbuf->list), get_list_head(pfree_xmitbuf_queue));
2496
2497                 pxmitpriv->free_xmitbuf_cnt++;
2498                 //DBG_871X("FREE, free_xmitbuf_cnt=%d\n", pxmitpriv->free_xmitbuf_cnt);
2499                 #ifdef DBG_XMIT_BUF
2500                 DBG_871X("DBG_XMIT_BUF FREE no=%d, free_xmitbuf_cnt=%d\n",pxmitbuf->no ,pxmitpriv->free_xmitbuf_cnt);
2501                 #endif
2502                 _exit_critical(&pfree_xmitbuf_queue->lock, &irqL);
2503         }
2504
2505 _func_exit_;
2506
2507         return _SUCCESS;
2508 }
2509
2510 void rtw_init_xmitframe(struct xmit_frame *pxframe)
2511 {
2512         if (pxframe !=  NULL)//default value setting
2513         {
2514                 pxframe->buf_addr = NULL;
2515                 pxframe->pxmitbuf = NULL;
2516
2517                 _rtw_memset(&pxframe->attrib, 0, sizeof(struct pkt_attrib));
2518                 //pxframe->attrib.psta = NULL;
2519
2520                 pxframe->frame_tag = DATA_FRAMETAG;
2521
2522 #ifdef CONFIG_USB_HCI
2523                 pxframe->pkt = NULL;
2524                 pxframe->pkt_offset = 1;//default use pkt_offset to fill tx desc
2525
2526 #ifdef CONFIG_USB_TX_AGGREGATION
2527                 pxframe->agg_num = 1;
2528 #endif
2529
2530 #endif //#ifdef CONFIG_USB_HCI
2531
2532 #if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
2533                 pxframe->pg_num = 1;
2534                 pxframe->agg_num = 1;
2535 #endif
2536
2537 #ifdef CONFIG_XMIT_ACK
2538                 pxframe->ack_report = 0;
2539 #endif
2540
2541         }
2542 }
2543
2544 /*
2545 Calling context:
2546 1. OS_TXENTRY
2547 2. RXENTRY (rx_thread or RX_ISR/RX_CallBack)
2548
2549 If we turn on USE_RXTHREAD, then, no need for critical section.
2550 Otherwise, we must use _enter/_exit critical to protect free_xmit_queue...
2551
2552 Must be very very cautious...
2553
2554 */
2555 struct xmit_frame *rtw_alloc_xmitframe(struct xmit_priv *pxmitpriv)//(_queue *pfree_xmit_queue)
2556 {
2557         /*
2558                 Please remember to use all the osdep_service api,
2559                 and lock/unlock or _enter/_exit critical to protect
2560                 pfree_xmit_queue
2561         */
2562
2563         _irqL irqL;
2564         struct xmit_frame *pxframe = NULL;
2565         _list *plist, *phead;
2566         _queue *pfree_xmit_queue = &pxmitpriv->free_xmit_queue;
2567 #ifdef PLATFORM_LINUX
2568         _adapter *padapter = pxmitpriv->adapter;
2569 #endif //PLATFORM_LINUX
2570
2571 _func_enter_;
2572
2573         _enter_critical_bh(&pfree_xmit_queue->lock, &irqL);
2574
2575         if (_rtw_queue_empty(pfree_xmit_queue) == _TRUE) {
2576                 RT_TRACE(_module_rtl871x_xmit_c_,_drv_info_,("rtw_alloc_xmitframe:%d\n", pxmitpriv->free_xmitframe_cnt));
2577                 pxframe =  NULL;
2578         } else {
2579                 phead = get_list_head(pfree_xmit_queue);
2580
2581                 plist = get_next(phead);
2582
2583                 pxframe = LIST_CONTAINOR(plist, struct xmit_frame, list);
2584
2585                 rtw_list_delete(&(pxframe->list));
2586                 pxmitpriv->free_xmitframe_cnt--;
2587                 RT_TRACE(_module_rtl871x_xmit_c_, _drv_info_, ("rtw_alloc_xmitframe():free_xmitframe_cnt=%d\n", pxmitpriv->free_xmitframe_cnt));
2588         }
2589
2590         _exit_critical_bh(&pfree_xmit_queue->lock, &irqL);
2591
2592         rtw_init_xmitframe(pxframe);
2593
2594 _func_exit_;
2595
2596         return pxframe;
2597 }
2598
2599 struct xmit_frame *rtw_alloc_xmitframe_ext(struct xmit_priv *pxmitpriv)
2600 {
2601         _irqL irqL;
2602         struct xmit_frame *pxframe = NULL;
2603         _list *plist, *phead;
2604         _queue *queue = &pxmitpriv->free_xframe_ext_queue;
2605
2606 _func_enter_;
2607
2608         _enter_critical_bh(&queue->lock, &irqL);
2609
2610         if (_rtw_queue_empty(queue) == _TRUE) {
2611                 RT_TRACE(_module_rtl871x_xmit_c_,_drv_info_,("rtw_alloc_xmitframe_ext:%d\n", pxmitpriv->free_xframe_ext_cnt));
2612                 pxframe =  NULL;
2613         } else {
2614                 phead = get_list_head(queue);
2615                 plist = get_next(phead);
2616                 pxframe = LIST_CONTAINOR(plist, struct xmit_frame, list);
2617
2618                 rtw_list_delete(&(pxframe->list));
2619                 pxmitpriv->free_xframe_ext_cnt--;
2620                 RT_TRACE(_module_rtl871x_xmit_c_, _drv_info_, ("rtw_alloc_xmitframe_ext():free_xmitframe_cnt=%d\n", pxmitpriv->free_xframe_ext_cnt));
2621         }
2622
2623         _exit_critical_bh(&queue->lock, &irqL);
2624
2625         rtw_init_xmitframe(pxframe);
2626
2627 _func_exit_;
2628
2629         return pxframe;
2630 }
2631
2632 struct xmit_frame *rtw_alloc_xmitframe_once(struct xmit_priv *pxmitpriv)
2633 {
2634         struct xmit_frame *pxframe = NULL;
2635         u8 *alloc_addr;
2636
2637         alloc_addr = rtw_zmalloc(sizeof(struct xmit_frame) + 4);
2638
2639         if (alloc_addr == NULL)
2640                 goto exit;
2641
2642         pxframe = (struct xmit_frame *)N_BYTE_ALIGMENT((SIZE_PTR)(alloc_addr), 4);
2643         pxframe->alloc_addr = alloc_addr;
2644
2645         pxframe->padapter = pxmitpriv->adapter;
2646         pxframe->frame_tag = NULL_FRAMETAG;
2647
2648         pxframe->pkt = NULL;
2649
2650         pxframe->buf_addr = NULL;
2651         pxframe->pxmitbuf = NULL;
2652
2653         rtw_init_xmitframe(pxframe);
2654
2655         DBG_871X("################## %s ##################\n", __func__);
2656
2657 exit:
2658         return pxframe;
2659 }
2660
2661 s32 rtw_free_xmitframe(struct xmit_priv *pxmitpriv, struct xmit_frame *pxmitframe)
2662 {
2663         _irqL irqL;
2664         _queue *queue;
2665         _adapter *padapter = pxmitpriv->adapter;
2666         _pkt *pndis_pkt = NULL;
2667
2668 _func_enter_;
2669
2670         if (pxmitframe == NULL) {
2671                 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, ("======rtw_free_xmitframe():pxmitframe==NULL!!!!!!!!!!\n"));
2672                 goto exit;
2673         }
2674
2675         if (pxmitframe->pkt){
2676                 pndis_pkt = pxmitframe->pkt;
2677                 pxmitframe->pkt = NULL;
2678         }
2679
2680         if (pxmitframe->alloc_addr) {
2681                 DBG_871X("################## %s with alloc_addr ##################\n", __func__);
2682                 rtw_mfree(pxmitframe->alloc_addr, sizeof(struct xmit_frame) + 4);
2683                 goto check_pkt_complete;
2684         }
2685
2686         if (pxmitframe->ext_tag == 0)
2687                 queue = &pxmitpriv->free_xmit_queue;
2688         else if(pxmitframe->ext_tag == 1)
2689                 queue = &pxmitpriv->free_xframe_ext_queue;
2690         else
2691         {}
2692
2693         _enter_critical_bh(&queue->lock, &irqL);
2694
2695         rtw_list_delete(&pxmitframe->list);
2696         rtw_list_insert_tail(&pxmitframe->list, get_list_head(queue));
2697         if (pxmitframe->ext_tag == 0) {
2698                 pxmitpriv->free_xmitframe_cnt++;
2699                 RT_TRACE(_module_rtl871x_xmit_c_, _drv_debug_, ("rtw_free_xmitframe():free_xmitframe_cnt=%d\n", pxmitpriv->free_xmitframe_cnt));
2700         } else if(pxmitframe->ext_tag == 1) {
2701                 pxmitpriv->free_xframe_ext_cnt++;
2702                 RT_TRACE(_module_rtl871x_xmit_c_, _drv_debug_, ("rtw_free_xmitframe():free_xframe_ext_cnt=%d\n", pxmitpriv->free_xframe_ext_cnt));
2703         } else {
2704         }
2705
2706         _exit_critical_bh(&queue->lock, &irqL);
2707
2708 check_pkt_complete:
2709
2710         if(pndis_pkt)
2711                 rtw_os_pkt_complete(padapter, pndis_pkt);
2712
2713 exit:
2714
2715 _func_exit_;
2716
2717         return _SUCCESS;
2718 }
2719
2720 void rtw_free_xmitframe_queue(struct xmit_priv *pxmitpriv, _queue *pframequeue)
2721 {
2722         _irqL irqL;
2723         _list   *plist, *phead;
2724         struct  xmit_frame      *pxmitframe;
2725
2726 _func_enter_;
2727
2728         _enter_critical_bh(&(pframequeue->lock), &irqL);
2729
2730         phead = get_list_head(pframequeue);
2731         plist = get_next(phead);
2732
2733         while (rtw_end_of_queue_search(phead, plist) == _FALSE)
2734         {
2735
2736                 pxmitframe = LIST_CONTAINOR(plist, struct xmit_frame, list);
2737
2738                 plist = get_next(plist);
2739
2740                 rtw_free_xmitframe(pxmitpriv,pxmitframe);
2741
2742         }
2743         _exit_critical_bh(&(pframequeue->lock), &irqL);
2744
2745 _func_exit_;
2746 }
2747
2748 s32 rtw_xmitframe_enqueue(_adapter *padapter, struct xmit_frame *pxmitframe)
2749 {
2750         if (rtw_xmit_classifier(padapter, pxmitframe) == _FAIL)
2751         {
2752                 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_,
2753                          ("rtw_xmitframe_enqueue: drop xmit pkt for classifier fail\n"));
2754 //              pxmitframe->pkt = NULL;
2755                 return _FAIL;
2756         }
2757
2758         return _SUCCESS;
2759 }
2760
2761 static struct xmit_frame *dequeue_one_xmitframe(struct xmit_priv *pxmitpriv, struct hw_xmit *phwxmit, struct tx_servq *ptxservq, _queue *pframe_queue)
2762 {
2763         _list   *xmitframe_plist, *xmitframe_phead;
2764         struct  xmit_frame      *pxmitframe=NULL;
2765
2766         xmitframe_phead = get_list_head(pframe_queue);
2767         xmitframe_plist = get_next(xmitframe_phead);
2768
2769         while ((rtw_end_of_queue_search(xmitframe_phead, xmitframe_plist)) == _FALSE)
2770         {
2771                 pxmitframe = LIST_CONTAINOR(xmitframe_plist, struct xmit_frame, list);
2772
2773                 xmitframe_plist = get_next(xmitframe_plist);
2774
2775 /*#ifdef RTK_DMP_PLATFORM
2776 #ifdef CONFIG_USB_TX_AGGREGATION
2777                 if((ptxservq->qcnt>0) && (ptxservq->qcnt<=2))
2778                 {
2779                         pxmitframe = NULL;
2780
2781                         tasklet_schedule(&pxmitpriv->xmit_tasklet);
2782
2783                         break;
2784                 }
2785 #endif
2786 #endif*/
2787                 rtw_list_delete(&pxmitframe->list);
2788
2789                 ptxservq->qcnt--;
2790
2791                 //rtw_list_insert_tail(&pxmitframe->list, &phwxmit->pending);
2792
2793                 //ptxservq->qcnt--;
2794
2795                 break;
2796
2797                 pxmitframe = NULL;
2798
2799         }
2800
2801         return pxmitframe;
2802 }
2803
2804 struct xmit_frame* rtw_dequeue_xframe(struct xmit_priv *pxmitpriv, struct hw_xmit *phwxmit_i, sint entry)
2805 {
2806         _irqL irqL0;
2807         _list *sta_plist, *sta_phead;
2808         struct hw_xmit *phwxmit;
2809         struct tx_servq *ptxservq = NULL;
2810         _queue *pframe_queue = NULL;
2811         struct xmit_frame *pxmitframe = NULL;
2812         _adapter *padapter = pxmitpriv->adapter;
2813         struct registry_priv    *pregpriv = &padapter->registrypriv;
2814         int i, inx[4];
2815 #ifdef CONFIG_USB_HCI
2816 //      int j, tmp, acirp_cnt[4];
2817 #endif
2818
2819 _func_enter_;
2820
2821         inx[0] = 0; inx[1] = 1; inx[2] = 2; inx[3] = 3;
2822
2823         if(pregpriv->wifi_spec==1)
2824         {
2825                 int j, tmp, acirp_cnt[4];
2826 #if 0
2827                 if(flags<XMIT_QUEUE_ENTRY)
2828                 {
2829                         //priority exchange according to the completed xmitbuf flags.
2830                         inx[flags] = 0;
2831                         inx[0] = flags;
2832                 }
2833 #endif
2834
2835 #if defined(CONFIG_USB_HCI) || defined(CONFIG_SDIO_HCI)
2836                 for(j=0; j<4; j++)
2837                         inx[j] = pxmitpriv->wmm_para_seq[j];
2838 #endif
2839         }
2840
2841         _enter_critical_bh(&pxmitpriv->lock, &irqL0);
2842
2843         for(i = 0; i < entry; i++)
2844         {
2845                 phwxmit = phwxmit_i + inx[i];
2846
2847                 //_enter_critical_ex(&phwxmit->sta_queue->lock, &irqL0);
2848
2849                 sta_phead = get_list_head(phwxmit->sta_queue);
2850                 sta_plist = get_next(sta_phead);
2851
2852                 while ((rtw_end_of_queue_search(sta_phead, sta_plist)) == _FALSE)
2853                 {
2854
2855                         ptxservq= LIST_CONTAINOR(sta_plist, struct tx_servq, tx_pending);
2856
2857                         pframe_queue = &ptxservq->sta_pending;
2858
2859                         pxmitframe = dequeue_one_xmitframe(pxmitpriv, phwxmit, ptxservq, pframe_queue);
2860
2861                         if(pxmitframe)
2862                         {
2863                                 phwxmit->accnt--;
2864
2865                                 //Remove sta node when there is no pending packets.
2866                                 if(_rtw_queue_empty(pframe_queue)) //must be done after get_next and before break
2867                                         rtw_list_delete(&ptxservq->tx_pending);
2868
2869                                 //_exit_critical_ex(&phwxmit->sta_queue->lock, &irqL0);
2870
2871                                 goto exit;
2872                         }
2873
2874                         sta_plist = get_next(sta_plist);
2875
2876                 }
2877
2878                 //_exit_critical_ex(&phwxmit->sta_queue->lock, &irqL0);
2879
2880         }
2881
2882 exit:
2883
2884         _exit_critical_bh(&pxmitpriv->lock, &irqL0);
2885
2886 _func_exit_;
2887
2888         return pxmitframe;
2889 }
2890
2891 #if 1
2892 struct tx_servq *rtw_get_sta_pending(_adapter *padapter, struct sta_info *psta, sint up, u8 *ac)
2893 {
2894         struct tx_servq *ptxservq=NULL;
2895
2896 _func_enter_;
2897
2898         switch (up)
2899         {
2900                 case 1:
2901                 case 2:
2902                         ptxservq = &(psta->sta_xmitpriv.bk_q);
2903                         *(ac) = 3;
2904                         RT_TRACE(_module_rtl871x_xmit_c_,_drv_info_,("rtw_get_sta_pending : BK \n"));
2905                         break;
2906
2907                 case 4:
2908                 case 5:
2909                         ptxservq = &(psta->sta_xmitpriv.vi_q);
2910                         *(ac) = 1;
2911                         RT_TRACE(_module_rtl871x_xmit_c_,_drv_info_,("rtw_get_sta_pending : VI\n"));
2912                         break;
2913
2914                 case 6:
2915                 case 7:
2916                         ptxservq = &(psta->sta_xmitpriv.vo_q);
2917                         *(ac) = 0;
2918                         RT_TRACE(_module_rtl871x_xmit_c_,_drv_info_,("rtw_get_sta_pending : VO \n"));
2919                         break;
2920
2921                 case 0:
2922                 case 3:
2923                 default:
2924                         ptxservq = &(psta->sta_xmitpriv.be_q);
2925                         *(ac) = 2;
2926                         RT_TRACE(_module_rtl871x_xmit_c_,_drv_info_,("rtw_get_sta_pending : BE \n"));
2927                 break;
2928
2929         }
2930
2931 _func_exit_;
2932
2933         return ptxservq;
2934 }
2935 #else
2936 __inline static struct tx_servq *rtw_get_sta_pending
2937         (_adapter *padapter, _queue **ppstapending, struct sta_info *psta, sint up)
2938 {
2939         struct tx_servq *ptxservq;
2940         struct hw_xmit *phwxmits =  padapter->xmitpriv.hwxmits;
2941
2942 _func_enter_;
2943
2944 #ifdef CONFIG_RTL8711
2945
2946         if(IS_MCAST(psta->hwaddr))
2947         {
2948                 ptxservq = &(psta->sta_xmitpriv.be_q); // we will use be_q to queue bc/mc frames in BCMC_stainfo
2949                 *ppstapending = &padapter->xmitpriv.bm_pending;
2950         }
2951         else
2952 #endif
2953         {
2954                 switch (up)
2955                 {
2956                         case 1:
2957                         case 2:
2958                                 ptxservq = &(psta->sta_xmitpriv.bk_q);
2959                                 *ppstapending = &padapter->xmitpriv.bk_pending;
2960                                 (phwxmits+3)->accnt++;
2961                                 RT_TRACE(_module_rtl871x_xmit_c_,_drv_info_,("rtw_get_sta_pending : BK \n"));
2962                                 break;
2963
2964                         case 4:
2965                         case 5:
2966                                 ptxservq = &(psta->sta_xmitpriv.vi_q);
2967                                 *ppstapending = &padapter->xmitpriv.vi_pending;
2968                                 (phwxmits+1)->accnt++;
2969                                 RT_TRACE(_module_rtl871x_xmit_c_,_drv_info_,("rtw_get_sta_pending : VI\n"));
2970                                 break;
2971
2972                         case 6:
2973                         case 7:
2974                                 ptxservq = &(psta->sta_xmitpriv.vo_q);
2975                                 *ppstapending = &padapter->xmitpriv.vo_pending;
2976                                 (phwxmits+0)->accnt++;
2977                                 RT_TRACE(_module_rtl871x_xmit_c_,_drv_info_,("rtw_get_sta_pending : VO \n"));
2978                                 break;
2979
2980                         case 0:
2981                         case 3:
2982                         default:
2983                                 ptxservq = &(psta->sta_xmitpriv.be_q);
2984                                 *ppstapending = &padapter->xmitpriv.be_pending;
2985                                 (phwxmits+2)->accnt++;
2986                                 RT_TRACE(_module_rtl871x_xmit_c_,_drv_info_,("rtw_get_sta_pending : BE \n"));
2987                         break;
2988
2989                 }
2990
2991         }
2992
2993 _func_exit_;
2994
2995         return ptxservq;
2996 }
2997 #endif
2998
2999 /*
3000  * Will enqueue pxmitframe to the proper queue,
3001  * and indicate it to xx_pending list.....
3002  */
3003 s32 rtw_xmit_classifier(_adapter *padapter, struct xmit_frame *pxmitframe)
3004 {
3005         //_irqL irqL0;
3006         u8      ac_index;
3007         struct sta_info *psta;
3008         struct tx_servq *ptxservq;
3009         struct pkt_attrib       *pattrib = &pxmitframe->attrib;
3010         struct sta_priv *pstapriv = &padapter->stapriv;
3011         struct hw_xmit  *phwxmits =  padapter->xmitpriv.hwxmits;
3012         sint res = _SUCCESS;
3013
3014 _func_enter_;
3015
3016         if (pattrib->psta) {
3017                 psta = pattrib->psta;
3018         } else {
3019                 DBG_871X("%s, call rtw_get_stainfo()\n", __func__);
3020                 psta = rtw_get_stainfo(pstapriv, pattrib->ra);
3021         }
3022
3023         if (psta == NULL) {
3024                 res = _FAIL;
3025                 DBG_8192C("rtw_xmit_classifier: psta == NULL\n");
3026                 RT_TRACE(_module_rtl871x_xmit_c_,_drv_err_,("rtw_xmit_classifier: psta == NULL\n"));
3027                 goto exit;
3028         }
3029
3030         if(!(psta->state &_FW_LINKED))
3031         {
3032                 DBG_871X("%s, psta->state(0x%x) != _FW_LINKED\n", __func__, psta->state);
3033                 return _FAIL;
3034         }
3035
3036         ptxservq = rtw_get_sta_pending(padapter, psta, pattrib->priority, (u8 *)(&ac_index));
3037
3038         //_enter_critical(&pstapending->lock, &irqL0);
3039
3040         if (rtw_is_list_empty(&ptxservq->tx_pending)) {
3041                 rtw_list_insert_tail(&ptxservq->tx_pending, get_list_head(phwxmits[ac_index].sta_queue));
3042         }
3043
3044         //_enter_critical(&ptxservq->sta_pending.lock, &irqL1);
3045
3046         rtw_list_insert_tail(&pxmitframe->list, get_list_head(&ptxservq->sta_pending));
3047         ptxservq->qcnt++;
3048         phwxmits[ac_index].accnt++;
3049
3050         //_exit_critical(&ptxservq->sta_pending.lock, &irqL1);
3051
3052         //_exit_critical(&pstapending->lock, &irqL0);
3053
3054 exit:
3055
3056 _func_exit_;
3057
3058         return res;
3059 }
3060
3061 void rtw_alloc_hwxmits(_adapter *padapter)
3062 {
3063         struct hw_xmit *hwxmits;
3064         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
3065
3066         pxmitpriv->hwxmit_entry = HWXMIT_ENTRY;
3067
3068         pxmitpriv->hwxmits = (struct hw_xmit *)rtw_zmalloc(sizeof (struct hw_xmit) * pxmitpriv->hwxmit_entry);
3069
3070         hwxmits = pxmitpriv->hwxmits;
3071
3072         if(pxmitpriv->hwxmit_entry == 5)
3073         {
3074                 //pxmitpriv->bmc_txqueue.head = 0;
3075                 //hwxmits[0] .phwtxqueue = &pxmitpriv->bmc_txqueue;
3076                 hwxmits[0] .sta_queue = &pxmitpriv->bm_pending;
3077
3078                 //pxmitpriv->vo_txqueue.head = 0;
3079                 //hwxmits[1] .phwtxqueue = &pxmitpriv->vo_txqueue;
3080                 hwxmits[1] .sta_queue = &pxmitpriv->vo_pending;
3081
3082                 //pxmitpriv->vi_txqueue.head = 0;
3083                 //hwxmits[2] .phwtxqueue = &pxmitpriv->vi_txqueue;
3084                 hwxmits[2] .sta_queue = &pxmitpriv->vi_pending;
3085
3086                 //pxmitpriv->bk_txqueue.head = 0;
3087                 //hwxmits[3] .phwtxqueue = &pxmitpriv->bk_txqueue;
3088                 hwxmits[3] .sta_queue = &pxmitpriv->bk_pending;
3089
3090                 //pxmitpriv->be_txqueue.head = 0;
3091                 //hwxmits[4] .phwtxqueue = &pxmitpriv->be_txqueue;
3092                 hwxmits[4] .sta_queue = &pxmitpriv->be_pending;
3093
3094         }
3095         else if(pxmitpriv->hwxmit_entry == 4)
3096         {
3097
3098                 //pxmitpriv->vo_txqueue.head = 0;
3099                 //hwxmits[0] .phwtxqueue = &pxmitpriv->vo_txqueue;
3100                 hwxmits[0] .sta_queue = &pxmitpriv->vo_pending;
3101
3102                 //pxmitpriv->vi_txqueue.head = 0;
3103                 //hwxmits[1] .phwtxqueue = &pxmitpriv->vi_txqueue;
3104                 hwxmits[1] .sta_queue = &pxmitpriv->vi_pending;
3105
3106                 //pxmitpriv->be_txqueue.head = 0;
3107                 //hwxmits[2] .phwtxqueue = &pxmitpriv->be_txqueue;
3108                 hwxmits[2] .sta_queue = &pxmitpriv->be_pending;
3109
3110                 //pxmitpriv->bk_txqueue.head = 0;
3111                 //hwxmits[3] .phwtxqueue = &pxmitpriv->bk_txqueue;
3112                 hwxmits[3] .sta_queue = &pxmitpriv->bk_pending;
3113         }
3114         else
3115         {
3116
3117
3118         }
3119
3120
3121 }
3122
3123 void rtw_free_hwxmits(_adapter *padapter)
3124 {
3125         struct hw_xmit *hwxmits;
3126         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
3127
3128         hwxmits = pxmitpriv->hwxmits;
3129         if(hwxmits)
3130                 rtw_mfree((u8 *)hwxmits, (sizeof (struct hw_xmit) * pxmitpriv->hwxmit_entry));
3131 }
3132
3133 void rtw_init_hwxmits(struct hw_xmit *phwxmit, sint entry)
3134 {
3135         sint i;
3136 _func_enter_;
3137         for(i = 0; i < entry; i++, phwxmit++)
3138         {
3139                 //_rtw_spinlock_init(&phwxmit->xmit_lock);
3140                 //_rtw_init_listhead(&phwxmit->pending);
3141                 //phwxmit->txcmdcnt = 0;
3142                 phwxmit->accnt = 0;
3143         }
3144 _func_exit_;
3145 }
3146
3147 #ifdef CONFIG_BR_EXT
3148 int rtw_br_client_tx(_adapter *padapter, struct sk_buff **pskb)
3149 {
3150         struct sk_buff *skb = *pskb;
3151         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
3152         _irqL irqL;
3153         //if(check_fwstate(pmlmepriv, WIFI_STATION_STATE|WIFI_ADHOC_STATE) == _TRUE)
3154         {
3155                 void dhcp_flag_bcast(_adapter *priv, struct sk_buff *skb);
3156                 int res, is_vlan_tag=0, i, do_nat25=1;
3157                 unsigned short vlan_hdr=0;
3158                 void *br_port = NULL;
3159
3160                 //mac_clone_handle_frame(priv, skb);
3161
3162 #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35))
3163                 br_port = padapter->pnetdev->br_port;
3164 #else   // (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35))
3165                 rcu_read_lock();
3166                 br_port = rcu_dereference(padapter->pnetdev->rx_handler_data);
3167                 rcu_read_unlock();
3168 #endif  // (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35))
3169                 _enter_critical_bh(&padapter->br_ext_lock, &irqL);
3170                 if (    !(skb->data[0] & 1) &&
3171                                 br_port &&
3172                                 memcmp(skb->data+MACADDRLEN, padapter->br_mac, MACADDRLEN) &&
3173                                 *((unsigned short *)(skb->data+MACADDRLEN*2)) != __constant_htons(ETH_P_8021Q) &&
3174                                 *((unsigned short *)(skb->data+MACADDRLEN*2)) == __constant_htons(ETH_P_IP) &&
3175                                 !memcmp(padapter->scdb_mac, skb->data+MACADDRLEN, MACADDRLEN) && padapter->scdb_entry) {
3176                         memcpy(skb->data+MACADDRLEN, GET_MY_HWADDR(padapter), MACADDRLEN);
3177                         padapter->scdb_entry->ageing_timer = jiffies;
3178                         _exit_critical_bh(&padapter->br_ext_lock, &irqL);
3179                 }
3180                 else
3181                 //if (!priv->pmib->ethBrExtInfo.nat25_disable)
3182                 {
3183 //                      if (priv->dev->br_port &&
3184 //                               !memcmp(skb->data+MACADDRLEN, priv->br_mac, MACADDRLEN)) {
3185 #if 1
3186                         if (*((unsigned short *)(skb->data+MACADDRLEN*2)) == __constant_htons(ETH_P_8021Q)) {
3187                                 is_vlan_tag = 1;
3188                                 vlan_hdr = *((unsigned short *)(skb->data+MACADDRLEN*2+2));
3189                                 for (i=0; i<6; i++)
3190                                         *((unsigned short *)(skb->data+MACADDRLEN*2+2-i*2)) = *((unsigned short *)(skb->data+MACADDRLEN*2-2-i*2));
3191                                 skb_pull(skb, 4);
3192                         }
3193                         //if SA == br_mac && skb== IP  => copy SIP to br_ip ?? why
3194                         if (!memcmp(skb->data+MACADDRLEN, padapter->br_mac, MACADDRLEN) &&
3195                                 (*((unsigned short *)(skb->data+MACADDRLEN*2)) == __constant_htons(ETH_P_IP)))
3196                                 memcpy(padapter->br_ip, skb->data+WLAN_ETHHDR_LEN+12, 4);
3197
3198                         if (*((unsigned short *)(skb->data+MACADDRLEN*2)) == __constant_htons(ETH_P_IP)) {
3199                                 if (memcmp(padapter->scdb_mac, skb->data+MACADDRLEN, MACADDRLEN)) {
3200                                         void *scdb_findEntry(_adapter *priv, unsigned char *macAddr, unsigned char *ipAddr);
3201
3202                                         if ((padapter->scdb_entry = (struct nat25_network_db_entry *)scdb_findEntry(padapter,
3203                                                                 skb->data+MACADDRLEN, skb->data+WLAN_ETHHDR_LEN+12)) != NULL) {
3204                                                 memcpy(padapter->scdb_mac, skb->data+MACADDRLEN, MACADDRLEN);
3205                                                 memcpy(padapter->scdb_ip, skb->data+WLAN_ETHHDR_LEN+12, 4);
3206                                                 padapter->scdb_entry->ageing_timer = jiffies;
3207                                                 do_nat25 = 0;
3208                                         }
3209                                 }
3210                                 else {
3211                                         if (padapter->scdb_entry) {
3212                                                 padapter->scdb_entry->ageing_timer = jiffies;
3213                                                 do_nat25 = 0;
3214                                         }
3215                                         else {
3216                                                 memset(padapter->scdb_mac, 0, MACADDRLEN);
3217                                                 memset(padapter->scdb_ip, 0, 4);
3218                                         }
3219                                 }
3220                         }
3221                         _exit_critical_bh(&padapter->br_ext_lock, &irqL);
3222 #endif // 1
3223                         if (do_nat25)
3224                         {
3225                                 int nat25_db_handle(_adapter *priv, struct sk_buff *skb, int method);
3226                                 if (nat25_db_handle(padapter, skb, NAT25_CHECK) == 0) {
3227                                         struct sk_buff *newskb;
3228
3229                                         if (is_vlan_tag) {
3230                                                 skb_push(skb, 4);
3231                                                 for (i=0; i<6; i++)
3232                                                         *((unsigned short *)(skb->data+i*2)) = *((unsigned short *)(skb->data+4+i*2));
3233                                                 *((unsigned short *)(skb->data+MACADDRLEN*2)) = __constant_htons(ETH_P_8021Q);
3234                                                 *((unsigned short *)(skb->data+MACADDRLEN*2+2)) = vlan_hdr;
3235                                         }
3236
3237                                         newskb = rtw_skb_copy(skb);
3238                                         if (newskb == NULL) {
3239                                                 //priv->ext_stats.tx_drops++;
3240                                                 DEBUG_ERR("TX DROP: rtw_skb_copy fail!\n");
3241                                                 //goto stop_proc;
3242                                                 return -1;
3243                                         }
3244                                         rtw_skb_free(skb);
3245
3246                                         *pskb = skb = newskb;
3247                                         if (is_vlan_tag) {
3248                                                 vlan_hdr = *((unsigned short *)(skb->data+MACADDRLEN*2+2));
3249                                                 for (i=0; i<6; i++)
3250                                                         *((unsigned short *)(skb->data+MACADDRLEN*2+2-i*2)) = *((unsigned short *)(skb->data+MACADDRLEN*2-2-i*2));
3251                                                 skb_pull(skb, 4);
3252                                         }
3253                                 }
3254
3255                                 if (skb_is_nonlinear(skb))
3256                                         DEBUG_ERR("%s(): skb_is_nonlinear!!\n", __FUNCTION__);
3257
3258
3259 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18))
3260                                 res = skb_linearize(skb, GFP_ATOMIC);
3261 #else   // (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18))
3262                                 res = skb_linearize(skb);
3263 #endif  // (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18))
3264                                 if (res < 0) {
3265                                                 DEBUG_ERR("TX DROP: skb_linearize fail!\n");
3266                                                 //goto free_and_stop;
3267                                                 return -1;
3268                                 }
3269
3270                                 res = nat25_db_handle(padapter, skb, NAT25_INSERT);
3271                                 if (res < 0) {
3272                                         if (res == -2) {
3273                                                 //priv->ext_stats.tx_drops++;
3274                                                 DEBUG_ERR("TX DROP: nat25_db_handle fail!\n");
3275                                                 //goto free_and_stop;
3276                                                 return -1;
3277
3278                                         }
3279                                         // we just print warning message and let it go
3280                                         //DEBUG_WARN("%s()-%d: nat25_db_handle INSERT Warning!\n", __FUNCTION__, __LINE__);
3281                                         //return -1; // return -1 will cause system crash on 2011/08/30!
3282                                         return 0;
3283                                 }
3284                         }
3285
3286                         memcpy(skb->data+MACADDRLEN, GET_MY_HWADDR(padapter), MACADDRLEN);
3287
3288                         dhcp_flag_bcast(padapter, skb);
3289
3290                         if (is_vlan_tag) {
3291                                 skb_push(skb, 4);
3292                                 for (i=0; i<6; i++)
3293                                         *((unsigned short *)(skb->data+i*2)) = *((unsigned short *)(skb->data+4+i*2));
3294                                 *((unsigned short *)(skb->data+MACADDRLEN*2)) = __constant_htons(ETH_P_8021Q);
3295                                 *((unsigned short *)(skb->data+MACADDRLEN*2+2)) = vlan_hdr;
3296                         }
3297                 }
3298 #if 0
3299                 else{
3300                         if (*((unsigned short *)(skb->data+MACADDRLEN*2)) == __constant_htons(ETH_P_8021Q)) {
3301                                 is_vlan_tag = 1;
3302                         }
3303
3304                         if(is_vlan_tag){
3305                                 if(ICMPV6_MCAST_MAC(skb->data) && ICMPV6_PROTO1A_VALN(skb->data)){
3306                                         memcpy(skb->data+MACADDRLEN, GET_MY_HWADDR(padapter), MACADDRLEN);
3307                                 }
3308                         }else
3309                         {
3310                                 if(ICMPV6_MCAST_MAC(skb->data) && ICMPV6_PROTO1A(skb->data)){
3311                                         memcpy(skb->data+MACADDRLEN, GET_MY_HWADDR(padapter), MACADDRLEN);
3312                                 }
3313                         }
3314                 }
3315 #endif  // 0
3316
3317                 // check if SA is equal to our MAC
3318                 if (memcmp(skb->data+MACADDRLEN, GET_MY_HWADDR(padapter), MACADDRLEN)) {
3319                         //priv->ext_stats.tx_drops++;
3320                         DEBUG_ERR("TX DROP: untransformed frame SA:%02X%02X%02X%02X%02X%02X!\n",
3321                                 skb->data[6],skb->data[7],skb->data[8],skb->data[9],skb->data[10],skb->data[11]);
3322                         //goto free_and_stop;
3323                         return -1;
3324                 }
3325         }
3326         return 0;
3327 }
3328 #endif  // CONFIG_BR_EXT
3329
3330 u32 rtw_get_ff_hwaddr(struct xmit_frame *pxmitframe)
3331 {
3332         u32 addr;
3333         struct pkt_attrib *pattrib = &pxmitframe->attrib;
3334
3335         switch(pattrib->qsel)
3336         {
3337                 case 0:
3338                 case 3:
3339                         addr = BE_QUEUE_INX;
3340                         break;
3341                 case 1:
3342                 case 2:
3343                         addr = BK_QUEUE_INX;
3344                         break;
3345                 case 4:
3346                 case 5:
3347                         addr = VI_QUEUE_INX;
3348                         break;
3349                 case 6:
3350                 case 7:
3351                         addr = VO_QUEUE_INX;
3352                         break;
3353                 case 0x10:
3354                         addr = BCN_QUEUE_INX;
3355                         break;
3356                 case 0x11://BC/MC in PS (HIQ)
3357                         addr = HIGH_QUEUE_INX;
3358                         break;
3359                 case 0x12:
3360                 default:
3361                         addr = MGT_QUEUE_INX;
3362                         break;
3363
3364         }
3365
3366         return addr;
3367
3368 }
3369
3370 static void do_queue_select(_adapter    *padapter, struct pkt_attrib *pattrib)
3371 {
3372         u8 qsel;
3373
3374         qsel = pattrib->priority;
3375         RT_TRACE(_module_rtl871x_xmit_c_,_drv_info_,("### do_queue_select priority=%d ,qsel = %d\n",pattrib->priority ,qsel));
3376
3377 #ifdef CONFIG_CONCURRENT_MODE
3378 //      if (check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) == _TRUE)
3379 //              qsel = 7;//
3380 #endif
3381
3382         pattrib->qsel = qsel;
3383 }
3384
3385 /*
3386  * The main transmit(tx) entry
3387  *
3388  * Return
3389  *      1       enqueue
3390  *      0       success, hardware will handle this xmit frame(packet)
3391  *      <0      fail
3392  */
3393 s32 rtw_xmit(_adapter *padapter, _pkt **ppkt)
3394 {
3395         static u32 start = 0;
3396         static u32 drop_cnt = 0;
3397 #ifdef CONFIG_AP_MODE
3398         _irqL irqL0;
3399 #endif
3400         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
3401         struct xmit_frame *pxmitframe = NULL;
3402 #ifdef CONFIG_BR_EXT
3403         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
3404         void *br_port = NULL;
3405 #endif  // CONFIG_BR_EXT
3406
3407         s32 res;
3408
3409         if (start == 0)
3410                 start = rtw_get_current_time();
3411
3412         pxmitframe = rtw_alloc_xmitframe(pxmitpriv);
3413
3414         if (rtw_get_passing_time_ms(start) > 2000) {
3415                 if (drop_cnt)
3416                         DBG_871X("DBG_TX_DROP_FRAME %s no more pxmitframe, drop_cnt:%u\n", __FUNCTION__, drop_cnt);
3417                 start = rtw_get_current_time();
3418                 drop_cnt = 0;
3419         }
3420
3421         if (pxmitframe == NULL) {
3422                 drop_cnt ++;
3423                 RT_TRACE(_module_xmit_osdep_c_, _drv_err_, ("rtw_xmit: no more pxmitframe\n"));
3424                 return -1;
3425         }
3426
3427 #ifdef CONFIG_BR_EXT
3428
3429 #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35))
3430         br_port = padapter->pnetdev->br_port;
3431 #else   // (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35))
3432         rcu_read_lock();
3433         br_port = rcu_dereference(padapter->pnetdev->rx_handler_data);
3434         rcu_read_unlock();
3435 #endif  // (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35))
3436
3437         if( br_port && check_fwstate(pmlmepriv, WIFI_STATION_STATE|WIFI_ADHOC_STATE) == _TRUE)
3438         {
3439                 res = rtw_br_client_tx(padapter, ppkt);
3440                 if (res == -1)
3441                 {
3442                         rtw_free_xmitframe(pxmitpriv, pxmitframe);
3443                         return -1;
3444                 }
3445         }
3446
3447 #endif  // CONFIG_BR_EXT
3448
3449         res = update_attrib(padapter, *ppkt, &pxmitframe->attrib);
3450
3451 #ifdef CONFIG_WAPI_SUPPORT
3452         if(pxmitframe->attrib.ether_type != 0x88B4)
3453         {
3454                 if(rtw_wapi_drop_for_key_absent(padapter, pxmitframe->attrib.ra))
3455                 {
3456                         WAPI_TRACE(WAPI_RX,"drop for key absend when tx \n");
3457                         res = _FAIL;
3458                 }
3459         }
3460 #endif
3461         if (res == _FAIL) {
3462                 RT_TRACE(_module_xmit_osdep_c_, _drv_err_, ("rtw_xmit: update attrib fail\n"));
3463                 #ifdef DBG_TX_DROP_FRAME
3464                 DBG_871X("DBG_TX_DROP_FRAME %s update attrib fail\n", __FUNCTION__);
3465                 #endif
3466                 rtw_free_xmitframe(pxmitpriv, pxmitframe);
3467                 return -1;
3468         }
3469         pxmitframe->pkt = *ppkt;
3470
3471         rtw_led_control(padapter, LED_CTL_TX);
3472
3473         do_queue_select(padapter, &pxmitframe->attrib);
3474
3475 #ifdef CONFIG_AP_MODE
3476         _enter_critical_bh(&pxmitpriv->lock, &irqL0);
3477         if(xmitframe_enqueue_for_sleeping_sta(padapter, pxmitframe) == _TRUE)
3478         {
3479                 _exit_critical_bh(&pxmitpriv->lock, &irqL0);
3480                 return 1;
3481         }
3482         _exit_critical_bh(&pxmitpriv->lock, &irqL0);
3483 #endif
3484
3485         if (rtw_hal_xmit(padapter, pxmitframe) == _FALSE)
3486                 return 1;
3487
3488         return 0;
3489 }
3490
3491 #ifdef CONFIG_TDLS
3492 sint xmitframe_enqueue_for_tdls_sleeping_sta(_adapter *padapter, struct xmit_frame *pxmitframe)
3493 {
3494         sint ret=_FALSE;
3495
3496         _irqL irqL;
3497         struct sta_info *ptdls_sta=NULL;
3498         struct sta_priv *pstapriv = &padapter->stapriv;
3499         struct pkt_attrib *pattrib = &pxmitframe->attrib;
3500         struct mlme_ext_priv    *pmlmeext = &(padapter->mlmeextpriv);
3501         int i;
3502
3503         ptdls_sta=rtw_get_stainfo(pstapriv, pattrib->dst);
3504         if(ptdls_sta==NULL){
3505                 return ret;
3506         }else if(ptdls_sta->tdls_sta_state&TDLS_LINKED_STATE){
3507
3508                 if(pattrib->triggered==1)
3509                 {
3510                         ret = _TRUE;
3511                         return ret;
3512                         }
3513
3514                 _enter_critical_bh(&ptdls_sta->sleep_q.lock, &irqL);
3515
3516                 if(ptdls_sta->state&WIFI_SLEEP_STATE)
3517                 {
3518                         rtw_list_delete(&pxmitframe->list);
3519
3520                         //_enter_critical_bh(&psta->sleep_q.lock, &irqL);
3521
3522                         rtw_list_insert_tail(&pxmitframe->list, get_list_head(&ptdls_sta->sleep_q));
3523
3524                         ptdls_sta->sleepq_len++;
3525                         ptdls_sta->sleepq_ac_len++;
3526
3527                         //indicate 4-AC queue bit in TDLS peer traffic indication
3528                         switch(pattrib->priority)
3529                         {
3530                                 case 1:
3531                                 case 2:
3532                                         ptdls_sta->uapsd_bk = ptdls_sta->uapsd_bk | BIT(1);
3533                                         break;
3534                                 case 4:
3535                                 case 5:
3536                                         ptdls_sta->uapsd_vi = ptdls_sta->uapsd_vi | BIT(1);
3537                                         break;
3538                                 case 6:
3539                                 case 7:
3540                                         ptdls_sta->uapsd_vo = ptdls_sta->uapsd_vo | BIT(1);
3541                                         break;
3542                                 case 0:
3543                                 case 3:
3544                                 default:
3545                                         ptdls_sta->uapsd_be = ptdls_sta->uapsd_be | BIT(1);
3546                                         break;
3547                         }
3548
3549                         if(ptdls_sta->sleepq_len==1)
3550                         {
3551                                 //transmit TDLS PTI via AP
3552                                 rtw_tdls_cmd(padapter, ptdls_sta->hwaddr, TDLS_SD_PTI);
3553                         }
3554                         ret = _TRUE;
3555
3556                 }
3557
3558                 _exit_critical_bh(&ptdls_sta->sleep_q.lock, &irqL);
3559         }
3560
3561         return ret;
3562
3563 }
3564 #endif //CONFIG_TDLS
3565
3566 #if defined(CONFIG_AP_MODE) || defined(CONFIG_TDLS)
3567
3568 sint xmitframe_enqueue_for_sleeping_sta(_adapter *padapter, struct xmit_frame *pxmitframe)
3569 {
3570         _irqL irqL;
3571         sint ret=_FALSE;
3572         struct sta_info *psta=NULL;
3573         struct sta_priv *pstapriv = &padapter->stapriv;
3574         struct pkt_attrib *pattrib = &pxmitframe->attrib;
3575         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
3576         sint bmcst = IS_MCAST(pattrib->ra);
3577 #ifdef CONFIG_TDLS
3578         struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
3579
3580         if( ptdlsinfo->setup_state == TDLS_LINKED_STATE )
3581         {
3582                 ret = xmitframe_enqueue_for_tdls_sleeping_sta(padapter, pxmitframe);
3583                 return ret;
3584         }
3585 #endif //CONFIG_TDLS
3586
3587         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == _FALSE)
3588             return ret;
3589
3590         if(pattrib->psta)
3591         {
3592                 psta = pattrib->psta;
3593         }
3594         else
3595         {
3596                 DBG_871X("%s, call rtw_get_stainfo()\n", __func__);
3597                 psta=rtw_get_stainfo(pstapriv, pattrib->ra);
3598         }
3599
3600         if(psta==NULL)
3601         {
3602                 DBG_871X("%s, psta==NUL\n", __func__);
3603                 return _FALSE;
3604         }
3605
3606         if(!(psta->state &_FW_LINKED))
3607         {
3608                 DBG_871X("%s, psta->state(0x%x) != _FW_LINKED\n", __func__, psta->state);
3609                 return _FALSE;
3610         }
3611
3612         if(pattrib->triggered==1)
3613         {
3614                 //DBG_871X("directly xmit pspoll_triggered packet\n");
3615
3616                 //pattrib->triggered=0;
3617
3618                 if(bmcst)
3619                         pattrib->qsel = 0x11;//HIQ
3620
3621
3622                 return ret;
3623         }
3624
3625
3626         if(bmcst)
3627         {
3628                 _enter_critical_bh(&psta->sleep_q.lock, &irqL);
3629
3630                 if(pstapriv->sta_dz_bitmap)//if anyone sta is in ps mode
3631                 {
3632                         //pattrib->qsel = 0x11;//HIQ
3633
3634                         rtw_list_delete(&pxmitframe->list);
3635
3636                         //_enter_critical_bh(&psta->sleep_q.lock, &irqL);
3637
3638                         rtw_list_insert_tail(&pxmitframe->list, get_list_head(&psta->sleep_q));
3639
3640                         psta->sleepq_len++;
3641
3642                         pstapriv->tim_bitmap |= BIT(0);//
3643                         pstapriv->sta_dz_bitmap |= BIT(0);
3644
3645                         //DBG_871X("enqueue, sq_len=%d, tim=%x\n", psta->sleepq_len, pstapriv->tim_bitmap);
3646
3647                         update_beacon(padapter, _TIM_IE_, NULL, _FALSE);//tx bc/mc packets after upate bcn
3648
3649                         //_exit_critical_bh(&psta->sleep_q.lock, &irqL);
3650
3651                         ret = _TRUE;
3652
3653                 }
3654
3655                 _exit_critical_bh(&psta->sleep_q.lock, &irqL);
3656
3657                 return ret;
3658
3659         }
3660
3661
3662         _enter_critical_bh(&psta->sleep_q.lock, &irqL);
3663
3664         if(psta->state&WIFI_SLEEP_STATE)
3665         {
3666                 u8 wmmps_ac=0;
3667
3668                 if(pstapriv->sta_dz_bitmap&BIT(psta->aid))
3669                 {
3670                         rtw_list_delete(&pxmitframe->list);
3671
3672                         //_enter_critical_bh(&psta->sleep_q.lock, &irqL);
3673
3674                         rtw_list_insert_tail(&pxmitframe->list, get_list_head(&psta->sleep_q));
3675
3676                         psta->sleepq_len++;
3677
3678                         switch(pattrib->priority)
3679                         {
3680                                 case 1:
3681                                 case 2:
3682                                         wmmps_ac = psta->uapsd_bk&BIT(0);
3683                                         break;
3684                                 case 4:
3685                                 case 5:
3686                                         wmmps_ac = psta->uapsd_vi&BIT(0);
3687                                         break;
3688                                 case 6:
3689                                 case 7:
3690                                         wmmps_ac = psta->uapsd_vo&BIT(0);
3691                                         break;
3692                                 case 0:
3693                                 case 3:
3694                                 default:
3695                                         wmmps_ac = psta->uapsd_be&BIT(0);
3696                                         break;
3697                         }
3698
3699                         if(wmmps_ac)
3700                                 psta->sleepq_ac_len++;
3701
3702                         if(((psta->has_legacy_ac) && (!wmmps_ac)) ||((!psta->has_legacy_ac)&&(wmmps_ac)))
3703                         {
3704                                 pstapriv->tim_bitmap |= BIT(psta->aid);
3705
3706                                 //DBG_871X("enqueue, sq_len=%d, tim=%x\n", psta->sleepq_len, pstapriv->tim_bitmap);
3707
3708                                 if(psta->sleepq_len==1)
3709                                 {
3710                                         //DBG_871X("sleepq_len==1, update BCNTIM\n");
3711                                         //upate BCN for TIM IE
3712                                         update_beacon(padapter, _TIM_IE_, NULL, _FALSE);
3713                                 }
3714                         }
3715
3716                         //_exit_critical_bh(&psta->sleep_q.lock, &irqL);
3717
3718                         //if(psta->sleepq_len > (NR_XMITFRAME>>3))
3719                         //{
3720                         //      wakeup_sta_to_xmit(padapter, psta);
3721                         //}
3722
3723                         ret = _TRUE;
3724
3725                 }
3726
3727         }
3728
3729         _exit_critical_bh(&psta->sleep_q.lock, &irqL);
3730
3731         return ret;
3732
3733 }
3734
3735 static void dequeue_xmitframes_to_sleeping_queue(_adapter *padapter, struct sta_info *psta, _queue *pframequeue)
3736 {
3737         sint ret;
3738         _list   *plist, *phead;
3739         u8      ac_index;
3740         struct tx_servq *ptxservq;
3741         struct pkt_attrib       *pattrib;
3742         struct xmit_frame       *pxmitframe;
3743         struct hw_xmit *phwxmits =  padapter->xmitpriv.hwxmits;
3744
3745         phead = get_list_head(pframequeue);
3746         plist = get_next(phead);
3747
3748         while (rtw_end_of_queue_search(phead, plist) == _FALSE)
3749         {
3750                 pxmitframe = LIST_CONTAINOR(plist, struct xmit_frame, list);
3751
3752                 plist = get_next(plist);
3753
3754                 ret = xmitframe_enqueue_for_sleeping_sta(padapter, pxmitframe);
3755
3756                 if(_TRUE == ret)
3757                 {
3758                         pattrib = &pxmitframe->attrib;
3759
3760                         ptxservq = rtw_get_sta_pending(padapter, psta, pattrib->priority, (u8 *)(&ac_index));
3761
3762                         ptxservq->qcnt--;
3763                         phwxmits[ac_index].accnt--;
3764                 }
3765                 else
3766                 {
3767                         //DBG_871X("xmitframe_enqueue_for_sleeping_sta return _FALSE\n");
3768                 }
3769
3770         }
3771
3772 }
3773
3774 void stop_sta_xmit(_adapter *padapter, struct sta_info *psta)
3775 {
3776         _irqL irqL0;
3777         struct sta_info *psta_bmc;
3778         struct sta_xmit_priv *pstaxmitpriv;
3779         struct sta_priv *pstapriv = &padapter->stapriv;
3780         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
3781
3782         pstaxmitpriv = &psta->sta_xmitpriv;
3783
3784         //for BC/MC Frames
3785         psta_bmc = rtw_get_bcmc_stainfo(padapter);
3786
3787
3788         _enter_critical_bh(&pxmitpriv->lock, &irqL0);
3789
3790         psta->state |= WIFI_SLEEP_STATE;
3791
3792 #ifdef CONFIG_TDLS
3793         if( !(psta->tdls_sta_state & TDLS_LINKED_STATE) )
3794 #endif //CONFIG_TDLS
3795         pstapriv->sta_dz_bitmap |= BIT(psta->aid);
3796
3797
3798
3799         dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->vo_q.sta_pending);
3800         rtw_list_delete(&(pstaxmitpriv->vo_q.tx_pending));
3801
3802
3803         dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->vi_q.sta_pending);
3804         rtw_list_delete(&(pstaxmitpriv->vi_q.tx_pending));
3805
3806
3807         dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->be_q.sta_pending);
3808         rtw_list_delete(&(pstaxmitpriv->be_q.tx_pending));
3809
3810
3811         dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->bk_q.sta_pending);
3812         rtw_list_delete(&(pstaxmitpriv->bk_q.tx_pending));
3813
3814 #ifdef CONFIG_TDLS
3815         if( !(psta->tdls_sta_state & TDLS_LINKED_STATE) )
3816         {
3817                 if( psta_bmc != NULL )
3818                 {
3819 #endif //CONFIG_TDLS
3820
3821
3822         //for BC/MC Frames
3823         pstaxmitpriv = &psta_bmc->sta_xmitpriv;
3824         dequeue_xmitframes_to_sleeping_queue(padapter, psta_bmc, &pstaxmitpriv->be_q.sta_pending);
3825         rtw_list_delete(&(pstaxmitpriv->be_q.tx_pending));
3826
3827
3828 #ifdef CONFIG_TDLS
3829                 }
3830         }
3831 #endif //CONFIG_TDLS
3832         _exit_critical_bh(&pxmitpriv->lock, &irqL0);
3833
3834
3835 }
3836
3837 void wakeup_sta_to_xmit(_adapter *padapter, struct sta_info *psta)
3838 {
3839         _irqL irqL;
3840         u8 update_mask=0, wmmps_ac=0;
3841         struct sta_info *psta_bmc;
3842         _list   *xmitframe_plist, *xmitframe_phead;
3843         struct xmit_frame *pxmitframe=NULL;
3844         struct sta_priv *pstapriv = &padapter->stapriv;
3845         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
3846
3847         psta_bmc = rtw_get_bcmc_stainfo(padapter);
3848
3849
3850         //_enter_critical_bh(&psta->sleep_q.lock, &irqL);
3851         _enter_critical_bh(&pxmitpriv->lock, &irqL);
3852
3853         xmitframe_phead = get_list_head(&psta->sleep_q);
3854         xmitframe_plist = get_next(xmitframe_phead);
3855
3856         while ((rtw_end_of_queue_search(xmitframe_phead, xmitframe_plist)) == _FALSE)
3857         {
3858                 pxmitframe = LIST_CONTAINOR(xmitframe_plist, struct xmit_frame, list);
3859
3860                 xmitframe_plist = get_next(xmitframe_plist);
3861
3862                 rtw_list_delete(&pxmitframe->list);
3863
3864                 switch(pxmitframe->attrib.priority)
3865                 {
3866                         case 1:
3867                         case 2:
3868                                 wmmps_ac = psta->uapsd_bk&BIT(1);
3869                                 break;
3870                         case 4:
3871                         case 5:
3872                                 wmmps_ac = psta->uapsd_vi&BIT(1);
3873                                 break;
3874                         case 6:
3875                         case 7:
3876                                 wmmps_ac = psta->uapsd_vo&BIT(1);
3877                                 break;
3878                         case 0:
3879                         case 3:
3880                         default:
3881                                 wmmps_ac = psta->uapsd_be&BIT(1);
3882                                 break;
3883                 }
3884
3885                 psta->sleepq_len--;
3886                 if(psta->sleepq_len>0)
3887                         pxmitframe->attrib.mdata = 1;
3888                 else
3889                         pxmitframe->attrib.mdata = 0;
3890
3891                 if(wmmps_ac)
3892                 {
3893                         psta->sleepq_ac_len--;
3894                         if(psta->sleepq_ac_len>0)
3895                         {
3896                                 pxmitframe->attrib.mdata = 1;
3897                                 pxmitframe->attrib.eosp = 0;
3898                         }
3899                         else
3900                         {
3901                                 pxmitframe->attrib.mdata = 0;
3902                                 pxmitframe->attrib.eosp = 1;
3903                         }
3904                 }
3905
3906                 pxmitframe->attrib.triggered = 1;
3907
3908 /*
3909                 _exit_critical_bh(&psta->sleep_q.lock, &irqL);
3910                 if(rtw_hal_xmit(padapter, pxmitframe) == _TRUE)
3911                 {
3912                         rtw_os_xmit_complete(padapter, pxmitframe);
3913                 }
3914                 _enter_critical_bh(&psta->sleep_q.lock, &irqL);
3915 */
3916                 rtw_hal_xmitframe_enqueue(padapter, pxmitframe);
3917
3918
3919         }
3920
3921         //for BC/MC Frames
3922         if(!psta_bmc)
3923                 goto _exit;
3924
3925         if((pstapriv->sta_dz_bitmap&0xfffe) == 0x0)//no any sta in ps mode
3926         {
3927                 xmitframe_phead = get_list_head(&psta_bmc->sleep_q);
3928                 xmitframe_plist = get_next(xmitframe_phead);
3929
3930                 while ((rtw_end_of_queue_search(xmitframe_phead, xmitframe_plist)) == _FALSE)
3931                 {
3932                         pxmitframe = LIST_CONTAINOR(xmitframe_plist, struct xmit_frame, list);
3933
3934                         xmitframe_plist = get_next(xmitframe_plist);
3935
3936                         rtw_list_delete(&pxmitframe->list);
3937
3938                         psta_bmc->sleepq_len--;
3939                         if(psta_bmc->sleepq_len>0)
3940                                 pxmitframe->attrib.mdata = 1;
3941                         else
3942                                 pxmitframe->attrib.mdata = 0;
3943
3944
3945                         pxmitframe->attrib.triggered = 1;
3946 /*
3947                         _exit_critical_bh(&psta_bmc->sleep_q.lock, &irqL);
3948                         if(rtw_hal_xmit(padapter, pxmitframe) == _TRUE)
3949                         {
3950                                 rtw_os_xmit_complete(padapter, pxmitframe);
3951                         }
3952                         _enter_critical_bh(&psta_bmc->sleep_q.lock, &irqL);
3953
3954 */
3955                         rtw_hal_xmitframe_enqueue(padapter, pxmitframe);
3956
3957                 }
3958
3959                 if(psta_bmc->sleepq_len==0)
3960                 {
3961                         pstapriv->tim_bitmap &= ~BIT(0);
3962                         pstapriv->sta_dz_bitmap &= ~BIT(0);
3963
3964                         //DBG_871X("wakeup to xmit, qlen==0, update_BCNTIM, tim=%x\n", pstapriv->tim_bitmap);
3965                         //upate BCN for TIM IE
3966                         //update_BCNTIM(padapter);
3967                         update_mask |= BIT(1);
3968                 }
3969
3970         }
3971
3972         if(psta->sleepq_len==0)
3973         {
3974 #ifdef CONFIG_TDLS
3975                 if( psta->tdls_sta_state & TDLS_LINKED_STATE )
3976                 {
3977                         if(psta->state&WIFI_SLEEP_STATE)
3978                                 psta->state ^= WIFI_SLEEP_STATE;
3979
3980                         goto _exit;
3981                 }
3982 #endif //CONFIG_TDLS
3983                 pstapriv->tim_bitmap &= ~BIT(psta->aid);
3984
3985                 //DBG_871X("wakeup to xmit, qlen==0, update_BCNTIM, tim=%x\n", pstapriv->tim_bitmap);
3986                 //upate BCN for TIM IE
3987                 //update_BCNTIM(padapter);
3988                 update_mask = BIT(0);
3989
3990                 if(psta->state&WIFI_SLEEP_STATE)
3991                         psta->state ^= WIFI_SLEEP_STATE;
3992
3993                 if(psta->state & WIFI_STA_ALIVE_CHK_STATE)
3994                 {
3995                         psta->expire_to = pstapriv->expire_to;
3996                         psta->state ^= WIFI_STA_ALIVE_CHK_STATE;
3997                 }
3998
3999                 pstapriv->sta_dz_bitmap &= ~BIT(psta->aid);
4000         }
4001
4002 _exit:
4003
4004         //_exit_critical_bh(&psta_bmc->sleep_q.lock, &irqL);
4005         _exit_critical_bh(&pxmitpriv->lock, &irqL);
4006
4007         if(update_mask)
4008         {
4009                 //update_BCNTIM(padapter);
4010                 //printk("%s => call update_beacon\n",__FUNCTION__);
4011                 update_beacon(padapter, _TIM_IE_, NULL, _FALSE);
4012         }
4013
4014 }
4015
4016 void xmit_delivery_enabled_frames(_adapter *padapter, struct sta_info *psta)
4017 {
4018         _irqL irqL;
4019         u8 wmmps_ac=0;
4020         _list   *xmitframe_plist, *xmitframe_phead;
4021         struct xmit_frame *pxmitframe=NULL;
4022         struct sta_priv *pstapriv = &padapter->stapriv;
4023         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
4024
4025
4026         //_enter_critical_bh(&psta->sleep_q.lock, &irqL);
4027         _enter_critical_bh(&pxmitpriv->lock, &irqL);
4028
4029         xmitframe_phead = get_list_head(&psta->sleep_q);
4030         xmitframe_plist = get_next(xmitframe_phead);
4031
4032         while ((rtw_end_of_queue_search(xmitframe_phead, xmitframe_plist)) == _FALSE)
4033         {
4034                 pxmitframe = LIST_CONTAINOR(xmitframe_plist, struct xmit_frame, list);
4035
4036                 xmitframe_plist = get_next(xmitframe_plist);
4037
4038                 switch(pxmitframe->attrib.priority)
4039                 {
4040                         case 1:
4041                         case 2:
4042                                 wmmps_ac = psta->uapsd_bk&BIT(1);
4043                                 break;
4044                         case 4:
4045                         case 5:
4046                                 wmmps_ac = psta->uapsd_vi&BIT(1);
4047                                 break;
4048                         case 6:
4049                         case 7:
4050                                 wmmps_ac = psta->uapsd_vo&BIT(1);
4051                                 break;
4052                         case 0:
4053                         case 3:
4054                         default:
4055                                 wmmps_ac = psta->uapsd_be&BIT(1);
4056                                 break;
4057                 }
4058
4059                 if(!wmmps_ac)
4060                         continue;
4061
4062                 rtw_list_delete(&pxmitframe->list);
4063
4064                 psta->sleepq_len--;
4065                 psta->sleepq_ac_len--;
4066
4067                 if(psta->sleepq_ac_len>0)
4068                 {
4069                         pxmitframe->attrib.mdata = 1;
4070                         pxmitframe->attrib.eosp = 0;
4071                 }
4072                 else
4073                 {
4074                         pxmitframe->attrib.mdata = 0;
4075                         pxmitframe->attrib.eosp = 1;
4076                 }
4077
4078                 pxmitframe->attrib.triggered = 1;
4079
4080 /*
4081                 if(rtw_hal_xmit(padapter, pxmitframe) == _TRUE)
4082                 {
4083                         rtw_os_xmit_complete(padapter, pxmitframe);
4084                 }
4085 */
4086                 rtw_hal_xmitframe_enqueue(padapter, pxmitframe);
4087
4088                 if((psta->sleepq_ac_len==0) && (!psta->has_legacy_ac) && (wmmps_ac))
4089                 {
4090 #ifdef CONFIG_TDLS
4091                         if(psta->tdls_sta_state & TDLS_LINKED_STATE )
4092                         {
4093                                 //_exit_critical_bh(&psta->sleep_q.lock, &irqL);
4094                                 _exit_critical_bh(&pxmitpriv->lock, &irqL);
4095                                 return;
4096                         }
4097 #endif //CONFIG_TDLS
4098                         pstapriv->tim_bitmap &= ~BIT(psta->aid);
4099
4100                         //DBG_871X("wakeup to xmit, qlen==0, update_BCNTIM, tim=%x\n", pstapriv->tim_bitmap);
4101                         //upate BCN for TIM IE
4102                         //update_BCNTIM(padapter);
4103                         update_beacon(padapter, _TIM_IE_, NULL, _FALSE);
4104                         //update_mask = BIT(0);
4105                 }
4106
4107         }
4108
4109         //_exit_critical_bh(&psta->sleep_q.lock, &irqL);
4110         _exit_critical_bh(&pxmitpriv->lock, &irqL);
4111
4112 }
4113
4114 #endif
4115
4116 #ifdef CONFIG_XMIT_THREAD_MODE
4117 void enqueue_pending_xmitbuf(
4118         struct xmit_priv *pxmitpriv,
4119         struct xmit_buf *pxmitbuf)
4120 {
4121         _irqL irql;
4122         _queue *pqueue;
4123         _adapter *pri_adapter = pxmitpriv->adapter;
4124
4125         pqueue = &pxmitpriv->pending_xmitbuf_queue;
4126
4127         _enter_critical_bh(&pqueue->lock, &irql);
4128         rtw_list_delete(&pxmitbuf->list);
4129         rtw_list_insert_tail(&pxmitbuf->list, get_list_head(pqueue));
4130         _exit_critical_bh(&pqueue->lock, &irql);
4131
4132
4133
4134 #if defined(CONFIG_SDIO_HCI) && defined(CONFIG_CONCURRENT_MODE)
4135         if (pri_adapter->adapter_type > PRIMARY_ADAPTER)
4136                 pri_adapter = pri_adapter->pbuddy_adapter;
4137 #endif  //SDIO_HCI + CONCURRENT
4138         _rtw_up_sema(&(pri_adapter->xmitpriv.xmit_sema));
4139
4140 }
4141
4142 struct xmit_buf* dequeue_pending_xmitbuf(
4143         struct xmit_priv *pxmitpriv)
4144 {
4145         _irqL irql;
4146         struct xmit_buf *pxmitbuf;
4147         _queue *pqueue;
4148
4149
4150         pxmitbuf = NULL;
4151         pqueue = &pxmitpriv->pending_xmitbuf_queue;
4152
4153         _enter_critical_bh(&pqueue->lock, &irql);
4154
4155         if (_rtw_queue_empty(pqueue) == _FALSE)
4156         {
4157                 _list *plist, *phead;
4158
4159                 phead = get_list_head(pqueue);
4160                 plist = get_next(phead);
4161                 pxmitbuf = LIST_CONTAINOR(plist, struct xmit_buf, list);
4162                 rtw_list_delete(&pxmitbuf->list);
4163         }
4164
4165         _exit_critical_bh(&pqueue->lock, &irql);
4166
4167         return pxmitbuf;
4168 }
4169
4170 struct xmit_buf* dequeue_pending_xmitbuf_under_survey(
4171         struct xmit_priv *pxmitpriv)
4172 {
4173         _irqL irql;
4174         struct xmit_buf *pxmitbuf;
4175 #ifdef CONFIG_USB_HCI
4176         struct xmit_frame *pxmitframe;
4177 #endif
4178         _queue *pqueue;
4179
4180
4181         pxmitbuf = NULL;
4182         pqueue = &pxmitpriv->pending_xmitbuf_queue;
4183
4184         _enter_critical_bh(&pqueue->lock, &irql);
4185
4186         if (_rtw_queue_empty(pqueue) == _FALSE)
4187         {
4188                 _list *plist, *phead;
4189                 u8 type;
4190
4191                 phead = get_list_head(pqueue);
4192                 plist = phead;
4193                 do {
4194                         plist = get_next(plist);
4195                                 if (plist == phead) break;
4196
4197                         pxmitbuf = LIST_CONTAINOR(plist, struct xmit_buf, list);
4198
4199 #ifdef CONFIG_USB_HCI
4200                         pxmitframe = (struct xmit_frame*)pxmitbuf->priv_data;
4201                         if(pxmitframe)
4202                         {
4203                                 type = GetFrameSubType(pxmitbuf->pbuf + TXDESC_SIZE + pxmitframe->pkt_offset * PACKET_OFFSET_SZ);
4204                         }
4205                         else
4206                         {
4207                                 DBG_871X("%s, !!!ERROR!!! For USB, TODO ITEM \n", __FUNCTION__);
4208                         }
4209 #else
4210                         type = GetFrameSubType(pxmitbuf->pbuf + TXDESC_OFFSET);
4211 #endif
4212
4213                         if ((type == WIFI_PROBEREQ) ||
4214                                 (type == WIFI_DATA_NULL) ||
4215                                 (type == WIFI_QOS_DATA_NULL))
4216                         {
4217                                 rtw_list_delete(&pxmitbuf->list);
4218                                 break;
4219                         }
4220                         pxmitbuf = NULL;
4221                 } while (1);
4222         }
4223
4224         _exit_critical_bh(&pqueue->lock, &irql);
4225
4226         return pxmitbuf;
4227 }
4228
4229 sint check_pending_xmitbuf(
4230         struct xmit_priv *pxmitpriv)
4231 {
4232         _queue *pqueue;
4233
4234         pqueue = &pxmitpriv->pending_xmitbuf_queue;
4235
4236         if(_rtw_queue_empty(pqueue) == _FALSE)
4237                 return _TRUE;
4238         else
4239                 return _FALSE;
4240 }
4241
4242 thread_return rtw_xmit_thread(thread_context context)
4243 {
4244         s32 err;
4245         PADAPTER padapter;
4246
4247
4248         err = _SUCCESS;
4249         padapter = (PADAPTER)context;
4250
4251         thread_enter("RTW_XMIT_THREAD");
4252
4253         do {
4254                 err = rtw_hal_xmit_thread_handler(padapter);
4255                 flush_signals_thread();
4256         } while (_SUCCESS == err);
4257
4258         _rtw_up_sema(&padapter->xmitpriv.terminate_xmitthread_sema);
4259
4260         thread_exit();
4261 }
4262 #endif
4263
4264 void rtw_sctx_init(struct submit_ctx *sctx, int timeout_ms)
4265 {
4266         sctx->timeout_ms = timeout_ms;
4267         sctx->submit_time= rtw_get_current_time();
4268 #ifdef PLATFORM_LINUX /* TODO: add condition wating interface for other os */
4269         init_completion(&sctx->done);
4270 #endif
4271         sctx->status = RTW_SCTX_SUBMITTED;
4272 }
4273
4274 int rtw_sctx_wait(struct submit_ctx *sctx)
4275 {
4276         int ret = _FAIL;
4277         unsigned long expire;
4278         int status = 0;
4279
4280 #ifdef PLATFORM_LINUX
4281         expire= sctx->timeout_ms ? msecs_to_jiffies(sctx->timeout_ms) : MAX_SCHEDULE_TIMEOUT;
4282         if (!wait_for_completion_timeout(&sctx->done, expire)) {
4283                 /* timeout, do something?? */
4284                 status = RTW_SCTX_DONE_TIMEOUT;
4285                 DBG_871X("%s timeout\n", __func__);
4286         } else {
4287                 status = sctx->status;
4288         }
4289 #endif
4290
4291         if (status == RTW_SCTX_DONE_SUCCESS) {
4292                 ret = _SUCCESS;
4293         }
4294
4295         return ret;
4296 }
4297
4298 bool rtw_sctx_chk_waring_status(int status)
4299 {
4300         switch(status) {
4301         case RTW_SCTX_DONE_UNKNOWN:
4302         case RTW_SCTX_DONE_BUF_ALLOC:
4303         case RTW_SCTX_DONE_BUF_FREE:
4304
4305         case RTW_SCTX_DONE_DRV_STOP:
4306         case RTW_SCTX_DONE_DEV_REMOVE:
4307                 return _TRUE;
4308         default:
4309                 return _FALSE;
4310         }
4311 }
4312
4313 void rtw_sctx_done_err(struct submit_ctx **sctx, int status)
4314 {
4315         if (*sctx) {
4316                 if (rtw_sctx_chk_waring_status(status))
4317                         DBG_871X("%s status:%d\n", __func__, status);
4318                 (*sctx)->status = status;
4319                 #ifdef PLATFORM_LINUX
4320                 complete(&((*sctx)->done));
4321                 #endif
4322                 *sctx = NULL;
4323         }
4324 }
4325
4326 void rtw_sctx_done(struct submit_ctx **sctx)
4327 {
4328         rtw_sctx_done_err(sctx, RTW_SCTX_DONE_SUCCESS);
4329 }
4330
4331 #ifdef CONFIG_XMIT_ACK
4332
4333 #ifdef CONFIG_XMIT_ACK_POLLING
4334 s32 c2h_evt_hdl(_adapter *adapter, struct c2h_evt_hdr *c2h_evt, c2h_id_filter filter);
4335
4336 /**
4337  * rtw_ack_tx_polling -
4338  * @pxmitpriv: xmit_priv to address ack_tx_ops
4339  * @timeout_ms: timeout msec
4340  *
4341  * Init ack_tx_ops and then do c2h_evt_hdl() and polling ack_tx_ops repeatedly
4342  * till tx report or timeout
4343  * Returns: _SUCCESS if TX report ok, _FAIL for others
4344  */
4345 int rtw_ack_tx_polling(struct xmit_priv *pxmitpriv, u32 timeout_ms)
4346 {
4347         int ret = _FAIL;
4348         struct submit_ctx *pack_tx_ops = &pxmitpriv->ack_tx_ops;
4349         _adapter *adapter = container_of(pxmitpriv, _adapter, xmitpriv);
4350
4351         pack_tx_ops->submit_time = rtw_get_current_time();
4352         pack_tx_ops->timeout_ms = timeout_ms;
4353         pack_tx_ops->status = RTW_SCTX_SUBMITTED;
4354
4355         do {
4356                 c2h_evt_hdl(adapter, NULL, rtw_hal_c2h_id_filter_ccx(adapter));
4357                 if (pack_tx_ops->status != RTW_SCTX_SUBMITTED)
4358                         break;
4359
4360                 if (adapter->bDriverStopped) {
4361                         pack_tx_ops->status = RTW_SCTX_DONE_DRV_STOP;
4362                         break;
4363                 }
4364                 if (adapter->bSurpriseRemoved) {
4365                         pack_tx_ops->status = RTW_SCTX_DONE_DEV_REMOVE;
4366                         break;
4367                 }
4368
4369                 rtw_msleep_os(10);
4370         } while (rtw_get_passing_time_ms(pack_tx_ops->submit_time) < timeout_ms);
4371
4372         if (pack_tx_ops->status == RTW_SCTX_SUBMITTED) {
4373                 pack_tx_ops->status = RTW_SCTX_DONE_TIMEOUT;
4374                 DBG_871X("%s timeout\n", __func__);
4375         }
4376
4377         if (pack_tx_ops->status == RTW_SCTX_DONE_SUCCESS)
4378                 ret = _SUCCESS;
4379
4380         return ret;
4381 }
4382 #endif
4383
4384 #ifdef CONFIG_DETECT_C2H_BY_POLLING
4385 s32 c2h_evt_hdl(_adapter *adapter, struct c2h_evt_hdr *c2h_evt, c2h_id_filter filter);
4386 #endif
4387
4388 int rtw_ack_tx_wait(struct xmit_priv *pxmitpriv, u32 timeout_ms)
4389 {
4390 #ifdef CONFIG_DETECT_C2H_BY_POLLING
4391         _adapter *adapter = container_of(pxmitpriv, _adapter, xmitpriv);
4392         c2h_id_filter ccx_id_filter = rtw_hal_c2h_id_filter_ccx(adapter);
4393         struct submit_ctx *pack_tx_ops = &pxmitpriv->ack_tx_ops;
4394         u8 check_c2hcmd;
4395         u8 check_ccx;
4396         int ret = _FAIL;
4397
4398         pack_tx_ops->submit_time = rtw_get_current_time();
4399         pack_tx_ops->timeout_ms = timeout_ms;
4400         pack_tx_ops->status = RTW_SCTX_SUBMITTED;
4401
4402         do {
4403                 rtw_msleep_os(10);
4404                 //check_c2hcmd = rtw_read8(adapter, 0x1AF);
4405                 //check_ccx = rtw_read8(adapter, 0x1A0);
4406                 rtw_hal_get_hwreg(adapter, HW_VAR_C2HEVT_CLEAR, (u8 *)(&check_c2hcmd));
4407                 rtw_hal_get_hwreg(adapter, HW_VAR_C2HEVT_MSG_NORMAL, (u8 *)(&check_ccx));
4408
4409
4410                 if (check_c2hcmd != 0)
4411                 {
4412                         if (check_c2hcmd != 0xFF)
4413                         {
4414                                 c2h_evt_clear(adapter);
4415                         }
4416                         else if (ccx_id_filter(check_ccx & 0x0F) == _TRUE)
4417                         {
4418                                 c2h_evt_hdl(adapter, NULL, ccx_id_filter);
4419                                 if (pack_tx_ops->status != RTW_SCTX_SUBMITTED)
4420                                         break;
4421
4422                                 if (adapter->bDriverStopped) {
4423                                         pack_tx_ops->status = RTW_SCTX_DONE_DRV_STOP;
4424                                         break;
4425                                 }
4426                                 if (adapter->bSurpriseRemoved) {
4427                                         pack_tx_ops->status = RTW_SCTX_DONE_DEV_REMOVE;
4428                                         break;
4429                                 }
4430                         }
4431                 }
4432         } while (rtw_get_passing_time_ms(pack_tx_ops->submit_time) < timeout_ms);
4433
4434         if (pack_tx_ops->status == RTW_SCTX_SUBMITTED) {
4435                 pack_tx_ops->status = RTW_SCTX_DONE_TIMEOUT;
4436                 DBG_871X("%s timeout\n", __func__);
4437         }
4438
4439         if (pack_tx_ops->status == RTW_SCTX_DONE_SUCCESS)
4440                 ret = _SUCCESS;
4441
4442         return ret;
4443 #else
4444 #ifdef CONFIG_XMIT_ACK_POLLING
4445         return rtw_ack_tx_polling(pxmitpriv, timeout_ms);
4446 #else
4447         struct submit_ctx *pack_tx_ops = &pxmitpriv->ack_tx_ops;
4448
4449         pack_tx_ops->submit_time = rtw_get_current_time();
4450         pack_tx_ops->timeout_ms = timeout_ms;
4451         pack_tx_ops->status = RTW_SCTX_SUBMITTED;
4452
4453         return rtw_sctx_wait(pack_tx_ops);
4454 #endif
4455 #endif
4456 }
4457
4458 void rtw_ack_tx_done(struct xmit_priv *pxmitpriv, int status)
4459 {
4460         struct submit_ctx *pack_tx_ops = &pxmitpriv->ack_tx_ops;
4461
4462         if (pxmitpriv->ack_tx) {
4463                 rtw_sctx_done_err(&pack_tx_ops, status);
4464         } else {
4465                 DBG_871X("%s ack_tx not set\n", __func__);
4466         }
4467 }
4468 #endif //CONFIG_XMIT_ACK
4469