spin_lock_init(&psta_xmitpriv->lock);
 
-
        _init_txservq(&psta_xmitpriv->be_q);
        _init_txservq(&psta_xmitpriv->bk_q);
        _init_txservq(&psta_xmitpriv->vi_q);
 
        pxmitpriv->adapter = padapter;
 
-
        _rtw_init_queue(&pxmitpriv->be_pending);
        _rtw_init_queue(&pxmitpriv->bk_pending);
        _rtw_init_queue(&pxmitpriv->vi_pending);
        _rtw_init_queue(&pxmitpriv->vo_pending);
        _rtw_init_queue(&pxmitpriv->bm_pending);
 
-
        _rtw_init_queue(&pxmitpriv->free_xmit_queue);
 
        /*
 
        pxmitpriv->frag_len = MAX_FRAG_THRESHOLD;
 
-
        /* init xmit_buf */
        _rtw_init_queue(&pxmitpriv->free_xmitbuf_queue);
        _rtw_init_queue(&pxmitpriv->pending_xmitbuf_queue);
        if (pxmitpriv->pallocated_frame_buf)
                vfree(pxmitpriv->pallocated_frame_buf);
 
-
        if (pxmitpriv->pallocated_xmitbuf)
                vfree(pxmitpriv->pallocated_xmitbuf);
 
                                break;
                        }
 
-
                        /* check ERP protection */
                        if (pattrib->rtsen || pattrib->cts2self) {
                                if (pattrib->rtsen)
        else
                pattrib->ampdu_spacing = psta->htpriv.rx_ampdu_min_spacing;
 
-
-
        pattrib->retry_ctrl = false;
 
 #ifdef CONFIG_AUTO_AP_MODE
                else
                        TKIP_IV(pattrib->iv, psta->dot11txpn, 0);
 
-
                memcpy(pattrib->dot11tkiptxmickey.skey, psta->dot11tkiptxmickey.skey, 16);
 
                break;
        struct iphdr ip_hdr;
        s32 UserPriority = 0;
 
-
        _rtw_open_pktfile(ppktfile->pkt, ppktfile);
        _rtw_pktfile_read(ppktfile, (unsigned char *)ðerhdr, ETH_HLEN);
 
 
        pattrib->ether_type = ntohs(etherhdr.h_proto);
 
-
        memcpy(pattrib->dst, ðerhdr.h_dest, ETH_ALEN);
        memcpy(pattrib->src, ðerhdr.h_source, ETH_ALEN);
 
-
        if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true) ||
                (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true)) {
                memcpy(pattrib->ra, pattrib->dst, ETH_ALEN);
                        }
                }
 
-
        } else if (0x888e == pattrib->ether_type) {
                DBG_871X_LEVEL(_drv_always_, "send eapol packet\n");
        }
                return _FAIL;
        }
 
-
-
        /* TODO:_lock */
        if (update_attrib_sec_info(padapter, pattrib, psta) == _FAIL) {
                DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_err_sec);
 
        update_attrib_phy_info(padapter, pattrib, psta);
 
-
        pattrib->psta = psta;
        /* TODO:_unlock */
 
        u8 hw_hdr_offset = 0;
        sint bmcst = IS_MCAST(pattrib->ra);
 
-
        hw_hdr_offset = TXDESC_OFFSET;
 
        if (pattrib->encrypt == _TKIP_) {
                        if (pattrib->qos_en)
                                priority[0] = (u8)pxmitframe->attrib.priority;
 
-
                        rtw_secmicappend(&micdata, &priority[0], 4);
 
                        payload = pframe;
                                return _FAIL;
                        }
 
-
                        if (psta) {
                                psta->sta_xmitpriv.txseq_tid[pattrib->priority]++;
                                psta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 0xFFF;
                                        if (psta->htpriv.agg_enable_bitmap & BIT(pattrib->priority))
                                                pattrib->ampdu_en = true;
 
-
                                /* re-check if enable ampdu by BA_starting_seqctrl */
                                if (pattrib->ampdu_en == true) {
                                        u16 tx_seq;
                        mpdu_len -= pattrib->icv_len;
                }
 
-
                if (bmcst) {
                        /*  don't do fragment to broadcat/multicast packets */
                        mem_sz = _rtw_pktfile_read(&pktfile, pframe, pattrib->pktlen);
                DBG_871X("DBG_XMIT_BUF_EXT ALLOC no =%d,  free_xmit_extbuf_cnt =%d\n", pxmitbuf->no, pxmitpriv->free_xmit_extbuf_cnt);
                #endif
 
-
                pxmitbuf->priv_data = NULL;
 
                pxmitbuf->len = 0;
        struct list_head *plist, *phead;
        struct __queue *pfree_xmitbuf_queue = &pxmitpriv->free_xmitbuf_queue;
 
-
        spin_lock_irqsave(&pfree_xmitbuf_queue->lock, irqL);
 
        if (list_empty(&pfree_xmitbuf_queue->queue)) {
        _irqL irqL;
        struct __queue *pfree_xmitbuf_queue = &pxmitpriv->free_xmitbuf_queue;
 
-
        if (!pxmitbuf)
                return _FAIL;
 
 
        DBG_COUNTER(padapter->tx_logs.core_tx_enqueue_class);
 
-
        psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
        if (pattrib->psta != psta) {
                DBG_COUNTER(padapter->tx_logs.core_tx_enqueue_class_err_sta);
 
        ptxservq = rtw_get_sta_pending(padapter, psta, pattrib->priority, (u8 *)(&ac_index));
 
-
        if (list_empty(&ptxservq->tx_pending)) {
                list_add_tail(&ptxservq->tx_pending, get_list_head(phwxmits[ac_index].sta_queue));
        }
 
-
        list_add_tail(&pxmitframe->list, get_list_head(&ptxservq->sta_pending));
        ptxservq->qcnt++;
        phwxmits[ac_index].accnt++;
 
-
-
 exit:
 
        return res;
                return ret;
        }
 
-
        if (bmcst) {
                spin_lock_bh(&psta->sleep_q.lock);
 
 
                        list_del_init(&pxmitframe->list);
 
-
                        list_add_tail(&pxmitframe->list, get_list_head(&psta->sleep_q));
 
                        psta->sleepq_len++;
                        pstapriv->tim_bitmap |= BIT(0);
                        pstapriv->sta_dz_bitmap |= BIT(0);
 
-
                        if (update_tim) {
                                update_beacon(padapter, _TIM_IE_, NULL, true);
                        } else {
                                chk_bmc_sleepq_cmd(padapter);
                        }
 
-
                        ret = true;
 
                        DBG_COUNTER(padapter->tx_logs.core_tx_ap_enqueue_mcast);
 
        }
 
-
        spin_lock_bh(&psta->sleep_q.lock);
 
        if (psta->state&WIFI_SLEEP_STATE) {
                if (pstapriv->sta_dz_bitmap & BIT(psta->aid)) {
                        list_del_init(&pxmitframe->list);
 
-
                        list_add_tail(&pxmitframe->list, get_list_head(&psta->sleep_q));
 
                        psta->sleepq_len++;
 
                                pstapriv->tim_bitmap |= BIT(psta->aid);
 
-
                                if (update_tim)
                                        /* upate BCN for TIM IE */
                                        update_beacon(padapter, _TIM_IE_, NULL, true);
                        }
 
-
-
                        ret = true;
 
                        DBG_COUNTER(padapter->tx_logs.core_tx_ap_enqueue_ucast);
        /* for BC/MC Frames */
        psta_bmc = rtw_get_bcmc_stainfo(padapter);
 
-
        spin_lock_bh(&pxmitpriv->lock);
 
        psta->state |= WIFI_SLEEP_STATE;
 
        pstapriv->sta_dz_bitmap |= BIT(psta->aid);
 
-
-
        dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->vo_q.sta_pending);
        list_del_init(&pstaxmitpriv->vo_q.tx_pending);
 
-
        dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->vi_q.sta_pending);
        list_del_init(&pstaxmitpriv->vi_q.tx_pending);
 
-
        dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->be_q.sta_pending);
        list_del_init(&pstaxmitpriv->be_q.tx_pending);
 
-
        dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->bk_q.sta_pending);
        list_del_init(&pstaxmitpriv->bk_q.tx_pending);
 
 
        psta_bmc = rtw_get_bcmc_stainfo(padapter);
 
-
        spin_lock_bh(&pxmitpriv->lock);
 
        xmitframe_phead = get_list_head(&psta->sleep_q);
 
                rtw_hal_xmitframe_enqueue(padapter, pxmitframe);
 
-
        }
 
        if (psta->sleepq_len == 0) {
                        else
                                pxmitframe->attrib.mdata = 0;
 
-
                        pxmitframe->attrib.triggered = 1;
                        rtw_hal_xmitframe_enqueue(padapter, pxmitframe);
 
        struct sta_priv *pstapriv = &padapter->stapriv;
        struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
 
-
        spin_lock_bh(&pxmitpriv->lock);
 
        xmitframe_phead = get_list_head(&psta->sleep_q);
        struct xmit_buf *pxmitbuf;
        struct __queue *pqueue;
 
-
        pxmitbuf = NULL;
        pqueue = &pxmitpriv->pending_xmitbuf_queue;
 
        struct xmit_buf *pxmitbuf;
        struct __queue *pqueue;
 
-
        pxmitbuf = NULL;
        pqueue = &pxmitpriv->pending_xmitbuf_queue;
 
        s32 err;
        struct adapter *padapter;
 
-
        err = _SUCCESS;
        padapter = context;