VOID RTUSBBulkOutDataPacket(
IN PRTMP_ADAPTER pAd,
IN UCHAR BulkOutPipeId,
IN UCHAR Index)
{
PHT_TX_CONTEXT pHTTXContext;
PURB pUrb;
int ret = 0;
PTXINFO_STRUC pTxInfo, pLastTxInfo = NULL;
PTXWI_STRUC pTxWI;
ULONG TmpBulkEndPos, ThisBulkSize;
unsigned long IrqFlags = 0, IrqFlags2 = 0;
PUCHAR pWirelessPkt, pAppendant;
#ifdef USB_BULK_BUF_ALIGMENT
BOOLEAN bLasAlignmentsectiontRound = FALSE;
#else
BOOLEAN bTxQLastRound = FALSE;
UCHAR allzero[4]= {0x0,0x0,0x0,0x0};
#endif /* USB_BULK_BUF_ALIGMENT */
BULK_OUT_LOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
if ((pAd->BulkOutPending[BulkOutPipeId] == TRUE) || RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NEED_STOP_TX))
{
BULK_OUT_UNLOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
return;
}
pAd->BulkOutPending[BulkOutPipeId] = TRUE;
if (((!OPSTATUS_TEST_FLAG(pAd, fOP_AP_STATUS_MEDIA_STATE_CONNECTED)) &&
( !OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED)))
)
{
pAd->BulkOutPending[BulkOutPipeId] = FALSE;
BULK_OUT_UNLOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
return;
}
BULK_OUT_UNLOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
pHTTXContext = &(pAd->TxContext[BulkOutPipeId]);
BULK_OUT_LOCK(&pAd->TxContextQueueLock[BulkOutPipeId], IrqFlags2);
#ifdef USB_BULK_BUF_ALIGMENT
if ( (pHTTXContext->NextBulkIdx != pHTTXContext->CurtBulkIdx)
|| ((pHTTXContext->CurWriteRealPos > pHTTXContext->CurWritePosition) &&(pHTTXContext->NextBulkIdx == pHTTXContext->CurWriteIdx))
|| ((pHTTXContext->CurWriteRealPos == 0) && (pHTTXContext->NextBulkIdx == pHTTXContext->CurWriteIdx))
)
#else
if ((pHTTXContext->ENextBulkOutPosition == pHTTXContext->CurWritePosition)
|| ((pHTTXContext->ENextBulkOutPosition-8) == pHTTXContext->CurWritePosition))
#endif /* USB_BULK_BUF_ALIGMENT */
/* druing writing. */
{
BULK_OUT_UNLOCK(&pAd->TxContextQueueLock[BulkOutPipeId], IrqFlags2);
BULK_OUT_LOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
pAd->BulkOutPending[BulkOutPipeId] = FALSE;
/* Clear Data flag*/
RTUSB_CLEAR_BULK_FLAG(pAd, (fRTUSB_BULK_OUT_DATA_FRAG << BulkOutPipeId));
RTUSB_CLEAR_BULK_FLAG(pAd, (fRTUSB_BULK_OUT_DATA_NORMAL << BulkOutPipeId));
BULK_OUT_UNLOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
return;
}
/* Clear Data flag*/
RTUSB_CLEAR_BULK_FLAG(pAd, (fRTUSB_BULK_OUT_DATA_FRAG << BulkOutPipeId));
RTUSB_CLEAR_BULK_FLAG(pAd, (fRTUSB_BULK_OUT_DATA_NORMAL << BulkOutPipeId));
/*DBGPRINT(RT_DEBUG_TRACE,("BulkOut-B:I=0x%lx, CWPos=%ld, CWRPos=%ld, NBPos=%ld, ENBPos=%ld, bCopy=%d!\n", in_interrupt(), */
/* pHTTXContext->CurWritePosition, pHTTXContext->CurWriteRealPos, pHTTXContext->NextBulkOutPosition, */
/* pHTTXContext->ENextBulkOutPosition, pHTTXContext->bCopySavePad));*/
pHTTXContext->NextBulkOutPosition = pHTTXContext->ENextBulkOutPosition;
ThisBulkSize = 0;
TmpBulkEndPos = pHTTXContext->NextBulkOutPosition;
#ifdef USB_BULK_BUF_ALIGMENT
INT idx;
idx = pHTTXContext->NextBulkIdx;
pWirelessPkt = &pHTTXContext->TransferBuffer[idx]->field.WirelessPacket[0];
#else
pWirelessPkt = &pHTTXContext->TransferBuffer->field.WirelessPacket[0];
#endif /* USB_BULK_BUF_ALIGMENT */
#ifndef USB_BULK_BUF_ALIGMENT
if ((pHTTXContext->bCopySavePad == TRUE))
{
if (RTMPEqualMemory(pHTTXContext->SavedPad, allzero,4))
{
DBGPRINT_RAW(RT_DEBUG_ERROR,("e1, allzero : %x %x %x %x %x %x %x %x \n",
pHTTXContext->SavedPad[0], pHTTXContext->SavedPad[1], pHTTXContext->SavedPad[2],pHTTXContext->SavedPad[3]
,pHTTXContext->SavedPad[4], pHTTXContext->SavedPad[5], pHTTXContext->SavedPad[6],pHTTXContext->SavedPad[7]));
}
NdisMoveMemory(&pWirelessPkt[TmpBulkEndPos], pHTTXContext->SavedPad, 8);
pHTTXContext->bCopySavePad = FALSE;
if (pAd->bForcePrintTX == TRUE)
DBGPRINT(RT_DEBUG_TRACE,("RTUSBBulkOutDataPacket --> COPY PAD. CurWrite = %ld, NextBulk = %ld. ENextBulk = %ld.\n", pHTTXContext->CurWritePosition, pHTTXContext->NextBulkOutPosition, pHTTXContext->ENextBulkOutPosition));
}
#endif /* USB_BULK_BUF_ALIGMENT */
do
{
pTxInfo = (PTXINFO_STRUC)&pWirelessPkt[TmpBulkEndPos];
pTxWI = (PTXWI_STRUC)&pWirelessPkt[TmpBulkEndPos + TXINFO_SIZE];
if (pAd->bForcePrintTX == TRUE)
DBGPRINT(RT_DEBUG_TRACE, ("RTUSBBulkOutDataPacket AMPDU = %d.\n", pTxWI->AMPDU));
/* add by Iverson, limit BulkOut size to 4k to pass WMM b mode 2T1R test items*/
/*if ((ThisBulkSize != 0) && (pTxWI->AMPDU == 0))*/
if ((ThisBulkSize != 0) && (pTxWI->PHYMODE == MODE_CCK))
{
#ifdef INF_AMAZON_SE
/*Iverson Add for AMAZON USB (RT2070 && RT3070) to pass WMM A2-T4 ~ A2-T10*/
if(OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_WMM_INUSED))
{
/*Iverson patch for WMM A5-T07 ,WirelessStaToWirelessSta do not bulk out aggregate*/
if(pTxWI->PacketId == 6)
{
pHTTXContext->ENextBulkOutPosition = TmpBulkEndPos;
break;
}
else if (((ThisBulkSize&0xffff8000) != 0) || ((ThisBulkSize&pAd->BulkOutDataSizeLimit[BulkOutPipeId]) == pAd->BulkOutDataSizeLimit[BulkOutPipeId]))
{
/*printk("===Bulkout size limit :%d ===\n",MaxBulkOutSize);*/
/*DBGPRINT(RT_DEBUG_TRACE,("b mode BulkOutPipeId %d pAd->BulkOutDataSizeLimit[BulkOutPipeId] %d \n",BulkOutPipeId,pAd->BulkOutDataSizeLimit[BulkOutPipeId]));*/
pHTTXContext->ENextBulkOutPosition = TmpBulkEndPos;
break;
}
}
else if (((ThisBulkSize&0xffff8000) != 0) || ((ThisBulkSize&0x1000) == 0x1000))
{
/* Limit BulkOut size to about 4k bytes.*/
pHTTXContext->ENextBulkOutPosition = TmpBulkEndPos;
break;
}
#endif /* INF_AMAZON_SE */
#ifndef INF_AMAZON_SE
#ifndef USB_BULK_BUF_ALIGMENT
if (((ThisBulkSize&0xffff8000) != 0) || ((ThisBulkSize&0x1000) == 0x1000))
{
/* Limit BulkOut size to about 4k bytes.*/
pHTTXContext->ENextBulkOutPosition = TmpBulkEndPos;
break;
}
#else
if (((ThisBulkSize&0xffff8000) != 0) || ((ThisBulkSize&BULKOUT_SIZE) == BULKOUT_SIZE))
{
/* Limit BulkOut size to about 24k bytes.*/
pHTTXContext->ENextBulkOutPosition = TmpBulkEndPos;
/*
when bulk size is > 6000, it mean that this is the lasttround at this alignmnet section.
*/
bLasAlignmentsectiontRound = TRUE;
break;
}
#endif /* USB_BULK_BUF_ALIGMENT */
#endif /* INF_AMAZON_SE */
#ifndef USB_BULK_BUF_ALIGMENT
else if (((pAd->BulkOutMaxPacketSize < 512) && ((ThisBulkSize&0xfffff800) != 0) ) /*|| ( (ThisBulkSize != 0) && (pTxWI->AMPDU == 0))*/)
{
/* For USB 1.1 or peer which didn't support AMPDU, limit the BulkOut size. */
/* For performence in b/g mode, now just check for USB 1.1 and didn't care about the APMDU or not! 2008/06/04.*/
pHTTXContext->ENextBulkOutPosition = TmpBulkEndPos;
break;
}
#else
else if (((pAd->BulkOutMaxPacketSize < 512) && (((ThisBulkSize&0xffff8000) != 0) || ((ThisBulkSize&BULKOUT_SIZE) == BULKOUT_SIZE)) ))
{
/* Limit BulkOut size to about 24k bytes.*/
pHTTXContext->ENextBulkOutPosition = TmpBulkEndPos;
/*
when bulk size is > 6000, it mean that this is the lasttround at this alignmnet section.
*/
bLasAlignmentsectiontRound = TRUE;
break;
}
#endif /* USB_BULK_BUF_ALIGMENT */
}
/* end Iverson*/
else
{
#ifdef USB_BULK_BUF_ALIGMENT
if (((ThisBulkSize&0xffff8000) != 0) || ((ThisBulkSize&BULKOUT_SIZE) == BULKOUT_SIZE))
#else
if (((ThisBulkSize&0xffff8000) != 0) || ((ThisBulkSize&0x6000) == 0x6000))
#endif /* USB_BULK_BUF_ALIGMENT */
{ /* Limit BulkOut size to about 24k bytes.*/
pHTTXContext->ENextBulkOutPosition = TmpBulkEndPos;
#ifdef USB_BULK_BUF_ALIGMENT
/*
when bulk size is > 0x6000, it mean that this is the lasttround at this alignmnet section.
*/
bLasAlignmentsectiontRound = TRUE;
/* printk("data bulk out bLasAlignmentsectiontRound \n");*/
#endif /* USB_BULK_BUF_ALIGMENT */
break;
}
#ifdef INF_AMAZON_SE
else if (((ThisBulkSize&0xffff8000) != 0) || ((ThisBulkSize&pAd->BulkOutDataSizeLimit[BulkOutPipeId]) == pAd->BulkOutDataSizeLimit[BulkOutPipeId]))
{
/*printk("===Bulkout size limit :%d ===\n",ThisBulkSize);*/
pHTTXContext->ENextBulkOutPosition = TmpBulkEndPos;
break;
}
#endif /* INF_AMAZON_SE */
#ifndef USB_BULK_BUF_ALIGMENT
else if (((pAd->BulkOutMaxPacketSize < 512) && ((ThisBulkSize&0xfffff800) != 0) ) /*|| ( (ThisBulkSize != 0) && (pTxWI->AMPDU == 0))*/)
{ /* For USB 1.1 or peer which didn't support AMPDU, limit the BulkOut size. */
/* For performence in b/g mode, now just check for USB 1.1 and didn't care about the APMDU or not! 2008/06/04.*/
pHTTXContext->ENextBulkOutPosition = TmpBulkEndPos;
break;
}
#else
else if (((pAd->BulkOutMaxPacketSize < 512) && (((ThisBulkSize&0xffff8000) != 0) || ((ThisBulkSize&BULKOUT_SIZE) == BULKOUT_SIZE)) ))
{
/* Limit BulkOut size to about 24k bytes.*/
pHTTXContext->ENextBulkOutPosition = TmpBulkEndPos;
/*
when bulk size is > 6000, it mean that this is the lasttround at this alignmnet section.
*/
bLasAlignmentsectiontRound = TRUE;
break;
}
#endif /* USB_BULK_BUF_ALIGMENT */
}
#ifdef USB_BULK_BUF_ALIGMENT
if ((TmpBulkEndPos == pHTTXContext->CurWritePosition) && (pHTTXContext->NextBulkIdx == pHTTXContext->CurWriteIdx))
#else
if (TmpBulkEndPos == pHTTXContext->CurWritePosition)
#endif /* USB_BULK_BUF_ALIGMENT */
{
pHTTXContext->ENextBulkOutPosition = TmpBulkEndPos;
break;
}
#if !defined(CONFIG_MULTI_CHANNEL) && !defined(DOT11Z_TDLS_SUPPORT)
if (pTxInfo->QSEL != FIFO_EDCA)
{
DBGPRINT(RT_DEBUG_ERROR, ("%s(): ====> pTxInfo->QueueSel(%d)!= FIFO_EDCA!!!!\n",
__FUNCTION__, pTxInfo->QSEL));
DBGPRINT(RT_DEBUG_ERROR, ("\tCWPos=%ld, NBPos=%ld, ENBPos=%ld, bCopy=%d!\n",
pHTTXContext->CurWritePosition, pHTTXContext->NextBulkOutPosition,
pHTTXContext->ENextBulkOutPosition, pHTTXContext->bCopySavePad));
hex_dump("Wrong QSel Pkt:", (PUCHAR)&pWirelessPkt[TmpBulkEndPos], (pHTTXContext->CurWritePosition - pHTTXContext->NextBulkOutPosition));
}
#endif /* !defined(CONFIG_MULTI_CHANNEL) && !defined(DOT11Z_TDLS_SUPPORT) */
if (pTxInfo->USBDMATxPktLen <= 8)
{
BULK_OUT_UNLOCK(&pAd->TxContextQueueLock[BulkOutPipeId], IrqFlags2);
DBGPRINT(RT_DEBUG_ERROR /*RT_DEBUG_TRACE*/,("e2, USBDMATxPktLen==0, Size=%ld, bCSPad=%d, CWPos=%ld, NBPos=%ld, CWRPos=%ld!\n",
pHTTXContext->BulkOutSize, pHTTXContext->bCopySavePad, pHTTXContext->CurWritePosition, pHTTXContext->NextBulkOutPosition, pHTTXContext->CurWriteRealPos));
{
DBGPRINT_RAW(RT_DEBUG_ERROR /*RT_DEBUG_TRACE*/,("%x %x %x %x %x %x %x %x \n",
pHTTXContext->SavedPad[0], pHTTXContext->SavedPad[1], pHTTXContext->SavedPad[2],pHTTXContext->SavedPad[3]
,pHTTXContext->SavedPad[4], pHTTXContext->SavedPad[5], pHTTXContext->SavedPad[6],pHTTXContext->SavedPad[7]));
}
pAd->bForcePrintTX = TRUE;
BULK_OUT_LOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
pAd->BulkOutPending[BulkOutPipeId] = FALSE;
BULK_OUT_UNLOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
/*DBGPRINT(RT_DEBUG_LOUD,("Out:pTxInfo->USBDMATxPktLen=%d!\n", pTxInfo->USBDMATxPktLen));*/
return;
}
/* Increase Total transmit byte counter*/
pAd->RalinkCounters.OneSecTransmittedByteCount += pTxWI->MPDUtotalByteCount;
pAd->RalinkCounters.TransmittedByteCount += pTxWI->MPDUtotalByteCount;
pLastTxInfo = pTxInfo;
#if !defined(CONFIG_MULTI_CHANNEL) && !defined(DOT11Z_TDLS_SUPPORT)
/* Make sure we use EDCA QUEUE. */
pTxInfo->QSEL = FIFO_EDCA;
#endif /* !defined(CONFIG_MULTI_CHANNEL) && !defined(DOT11Z_TDLS_SUPPORT) */
ThisBulkSize += (pTxInfo->USBDMATxPktLen+4);
TmpBulkEndPos += (pTxInfo->USBDMATxPktLen+4);
if (TmpBulkEndPos != pHTTXContext->CurWritePosition)
pTxInfo->USBDMANextVLD = 1;
#ifdef USB_BULK_BUF_ALIGMENT
/*
this is for frag packet , because it will finish this section
when ((((pHTTXContext->CurWritePosition + 3906)& 0x00007fff) & 0xffff6000) == 0x00006000)
*/
if (pTxInfo->SwRingUseLastRound == 1)
{
bLasAlignmentsectiontRound = TRUE;
#ifdef RT_BIG_ENDIAN
RTMPDescriptorEndianChange((PUCHAR)pTxInfo, TYPE_TXINFO);
RTMPWIEndianChange(pAd, (PUCHAR)pTxWI, TYPE_TXWI);
#endif /* RT_BIG_ENDIAN */
break;
}
#else
if (pTxInfo->SwRingUseLastRound == 1)
{
if (pHTTXContext->CurWritePosition == 8)
pTxInfo->USBDMANextVLD = 0;
pTxInfo->SwRingUseLastRound = 0;
bTxQLastRound = TRUE;
pHTTXContext->ENextBulkOutPosition = 8;
#ifdef RT_BIG_ENDIAN
RTMPDescriptorEndianChange((PUCHAR)pTxInfo, TYPE_TXINFO);
RTMPWIEndianChange(pAd, (PUCHAR)pTxWI, TYPE_TXWI);
#endif /* RT_BIG_ENDIAN */
break;
}
#endif /* USB_BULK_BUF_ALIGMENT */
#ifdef RT_BIG_ENDIAN
RTMPDescriptorEndianChange((PUCHAR)pTxInfo, TYPE_TXINFO);
RTMPWIEndianChange(pAd, (PUCHAR)pTxWI, TYPE_TXWI);
#endif /* RT_BIG_ENDIAN */
}while (TRUE);
/* adjust the pTxInfo->USBDMANextVLD value of last pTxInfo.*/
if (pLastTxInfo)
{
#ifdef RT_BIG_ENDIAN
RTMPDescriptorEndianChange((PUCHAR)pLastTxInfo, TYPE_TXINFO);
#endif /* RT_BIG_ENDIAN */
pLastTxInfo->USBDMANextVLD = 0;
#ifdef RT_BIG_ENDIAN
RTMPDescriptorEndianChange((PUCHAR)pLastTxInfo, TYPE_TXINFO);
#endif /* RT_BIG_ENDIAN */
}
/*
We need to copy SavedPad when following condition matched!
1. Not the last round of the TxQueue and
2. any match of following cases:
(1). The End Position of this bulk out is reach to the Currenct Write position and
the TxInfo and related header already write to the CurWritePosition.
=>(ENextBulkOutPosition == CurWritePosition) && (CurWriteRealPos > CurWritePosition)
(2). The EndPosition of the bulk out is not reach to the Current Write Position.
=>(ENextBulkOutPosition != CurWritePosition)
*/
#ifndef USB_BULK_BUF_ALIGMENT
if ((bTxQLastRound == FALSE) &&
(((pHTTXContext->ENextBulkOutPosition == pHTTXContext->CurWritePosition) && (pHTTXContext->CurWriteRealPos > pHTTXContext->CurWritePosition)) ||
(pHTTXContext->ENextBulkOutPosition != pHTTXContext->CurWritePosition))
)
{
NdisMoveMemory(pHTTXContext->SavedPad, &pWirelessPkt[pHTTXContext->ENextBulkOutPosition], 8);
pHTTXContext->bCopySavePad = TRUE;
if (RTMPEqualMemory(pHTTXContext->SavedPad, allzero,4))
{
PUCHAR pBuf = &pHTTXContext->SavedPad[0];
DBGPRINT_RAW(RT_DEBUG_ERROR,("WARNING-Zero-3:%02x%02x%02x%02x%02x%02x%02x%02x,CWPos=%ld, CWRPos=%ld, bCW=%d, NBPos=%ld, TBPos=%ld, TBSize=%ld\n",
pBuf[0], pBuf[1], pBuf[2],pBuf[3],pBuf[4], pBuf[5], pBuf[6],pBuf[7], pHTTXContext->CurWritePosition, pHTTXContext->CurWriteRealPos,
pHTTXContext->bCurWriting, pHTTXContext->NextBulkOutPosition, TmpBulkEndPos, ThisBulkSize));
pBuf = &pWirelessPkt[pHTTXContext->CurWritePosition];
DBGPRINT_RAW(RT_DEBUG_ERROR,("\tCWPos=%02x%02x%02x%02x%02x%02x%02x%02x\n", pBuf[0], pBuf[1], pBuf[2],pBuf[3],pBuf[4], pBuf[5], pBuf[6],pBuf[7]));
}
/*DBGPRINT(RT_DEBUG_LOUD,("ENPos==CWPos=%ld, CWRPos=%ld, bCSPad=%d!\n", pHTTXContext->CurWritePosition, pHTTXContext->CurWriteRealPos, pHTTXContext->bCopySavePad));*/
}
#endif /* USB_BULK_BUF_ALIGMENT */
if (pAd->bForcePrintTX == TRUE)
DBGPRINT(RT_DEBUG_TRACE,("BulkOut-A:Size=%ld, CWPos=%ld, NBPos=%ld, ENBPos=%ld, bCopy=%d!\n", ThisBulkSize, pHTTXContext->CurWritePosition, pHTTXContext->NextBulkOutPosition, pHTTXContext->ENextBulkOutPosition, pHTTXContext->bCopySavePad));
/*DBGPRINT(RT_DEBUG_LOUD,("BulkOut-A:Size=%ld, CWPos=%ld, CWRPos=%ld, NBPos=%ld, ENBPos=%ld, bCopy=%d, bLRound=%d!\n", ThisBulkSize, pHTTXContext->CurWritePosition, pHTTXContext->CurWriteRealPos, pHTTXContext->NextBulkOutPosition, pHTTXContext->ENextBulkOutPosition, pHTTXContext->bCopySavePad, bTxQLastRound));*/
/* USB DMA engine requires to pad extra 4 bytes. This pad doesn't count into real bulkoutsize.*/
pAppendant = &pWirelessPkt[TmpBulkEndPos];
NdisZeroMemory(pAppendant, 8);
ThisBulkSize += 4;
pHTTXContext->LastOne = TRUE;
pHTTXContext->BulkOutSize = ThisBulkSize;
#ifdef USB_BULK_BUF_ALIGMENT
/*
if it is the last alignment section round,that we just need to add nextbulkindex,
otherwise we both need to add nextbulkindex and CurWriteIdx
(because when alignment section round happened, the CurWriteIdx is added at function writing resource.)
*/
if(bLasAlignmentsectiontRound == TRUE)
{
CUR_WRITE_IDX_INC(pHTTXContext->NextBulkIdx, BUF_ALIGMENT_RINGSIZE);
pHTTXContext->ENextBulkOutPosition = 0;
}
else
{
CUR_WRITE_IDX_INC(pHTTXContext->NextBulkIdx, BUF_ALIGMENT_RINGSIZE);
pHTTXContext->ENextBulkOutPosition = 0;
CUR_WRITE_IDX_INC(pHTTXContext->CurWriteIdx, BUF_ALIGMENT_RINGSIZE);
pHTTXContext->CurWritePosition = 0;
}
#endif /* USB_BULK_BUF_ALIGMENT */
pAd->watchDogTxPendingCnt[BulkOutPipeId] = 1;
BULK_OUT_UNLOCK(&pAd->TxContextQueueLock[BulkOutPipeId], IrqFlags2);
/* Init Tx context descriptor*/
RTUSBInitHTTxDesc(pAd, pHTTXContext, BulkOutPipeId, ThisBulkSize, (usb_complete_t)RtmpUsbBulkOutDataPacketComplete);
#ifdef USB_BULK_BUF_ALIGMENT
pUrb = pHTTXContext->pUrb[pHTTXContext->CurtBulkIdx];
#else
pUrb = pHTTXContext->pUrb;
#endif /* USB_BULK_BUF_ALIGMENT */
if((ret = RTUSB_SUBMIT_URB(pUrb))!=0)
{
DBGPRINT(RT_DEBUG_ERROR, ("RTUSBBulkOutDataPacket: Submit Tx URB failed %d\n", ret));
BULK_OUT_LOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
pAd->BulkOutPending[BulkOutPipeId] = FALSE;
pAd->watchDogTxPendingCnt[BulkOutPipeId] = 0;
BULK_OUT_UNLOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
return;
}
BULK_OUT_LOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
pHTTXContext->IRPPending = TRUE;
BULK_OUT_UNLOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
pAd->BulkOutReq++;
}
VOID RtmpUSB_FinalWriteTxResource(
IN RTMP_ADAPTER *pAd,
IN TX_BLK *pTxBlk,
IN USHORT totalMPDUSize,
IN USHORT TxIdx)
{
UCHAR QueIdx;
HT_TX_CONTEXT *pHTTXContext;
UINT32 fillOffset;
TXINFO_STRUC *pTxInfo;
TXWI_STRUC *pTxWI;
UINT32 USBDMApktLen, padding;
unsigned long IrqFlags;
PUCHAR pWirelessPacket;
QueIdx = pTxBlk->QueIdx;
pHTTXContext = &pAd->TxContext[QueIdx];
RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
if (pHTTXContext->bCurWriting == TRUE)
{
fillOffset = pHTTXContext->CurWritePosition;
#ifndef USB_BULK_BUF_ALIGMENT
if (((pHTTXContext->ENextBulkOutPosition == pHTTXContext->CurWritePosition) || ((pHTTXContext->ENextBulkOutPosition-8) == pHTTXContext->CurWritePosition))
&& (pHTTXContext->bCopySavePad == TRUE))
pWirelessPacket = (PUCHAR)(&pHTTXContext->SavedPad[0]);
else
#endif /* USB_BULK_BUF_ALIGMENT */
pWirelessPacket = (PUCHAR)(&pHTTXContext->TransferBuffer->field.WirelessPacket[fillOffset]);
/* Update TxInfo->USBDMApktLen , */
/* the length = TXWI_SIZE + 802.11_hdr + 802.11_hdr_pad + payload_of_all_batch_frames + Bulk-Out-padding*/
pTxInfo = (TXINFO_STRUC *)(pWirelessPacket);
/* Calculate the bulk-out padding*/
USBDMApktLen = pTxBlk->Priv - TXINFO_SIZE;
padding = (4 - (USBDMApktLen % 4)) & 0x03; /* round up to 4 byte alignment*/
USBDMApktLen += padding;
pTxInfo->TxInfoPktLen = USBDMApktLen;
/*
Update TXWI->TxWIMPDUByteCnt,
the length = 802.11 header + payload_of_all_batch_frames
*/
pTxWI= (TXWI_STRUC *)(pWirelessPacket + TXINFO_SIZE);
pTxWI->TxWIMPDUByteCnt = totalMPDUSize;
/* Update the pHTTXContext->CurWritePosition*/
pHTTXContext->CurWritePosition += (TXINFO_SIZE + USBDMApktLen);
#ifdef USB_BULK_BUF_ALIGMENT
/*
when CurWritePosition > 0x6000 mean that it is at the max bulk out size,
we CurWriteIdx must move to the next alignment section.
Otherwirse, CurWriteIdx will be moved to the next section at databulkout.
Writingflag = TRUE ,mean that when we writing resource ,and databulkout happen,
So we bulk out when this packet finish.
*/
if ( (pHTTXContext->CurWritePosition & 0x00006000) == 0x00006000)
{
pHTTXContext->CurWritePosition = ((CUR_WRITE_IDX_INC(pHTTXContext->CurWriteIdx, BUF_ALIGMENT_RINGSIZE)) * 0x8000);
}
#else
if ((pHTTXContext->CurWritePosition + 3906)> MAX_TXBULK_LIMIT)
{ /* Add 3906 for prevent the NextBulkOut packet size is a A-RALINK/A-MSDU Frame.*/
pHTTXContext->CurWritePosition = 8;
pTxInfo->TxInfoSwLstRnd = 1;
}
#endif /* USB_BULK_BUF_ALIGMENT */
pHTTXContext->CurWriteRealPos = pHTTXContext->CurWritePosition;
#ifdef UAPSD_SUPPORT
#endif /* UAPSD_SUPPORT */
/* Zero the last padding.*/
pWirelessPacket = (&pHTTXContext->TransferBuffer->field.WirelessPacket[fillOffset + pTxBlk->Priv]);
NdisZeroMemory(pWirelessPacket, padding + 8);
/* Finally, set bCurWriting as FALSE*/
pHTTXContext->bCurWriting = FALSE;
}
else
{ /* It should not happened now unless we are going to shutdown.*/
DBGPRINT(RT_DEBUG_ERROR, ("FinalWriteTxResource():bCurWriting is FALSE when handle last frames.\n"));
}
RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
}
USHORT RtmpUSB_WriteFragTxResource(
IN RTMP_ADAPTER *pAd,
IN TX_BLK *pTxBlk,
IN UCHAR fragNum,
OUT USHORT *freeCnt)
{
HT_TX_CONTEXT *pHTTXContext;
USHORT hwHdrLen; /* The hwHdrLen consist of 802.11 header length plus the header padding length.*/
UINT32 fillOffset;
TXINFO_STRUC *pTxInfo;
TXWI_STRUC *pTxWI;
PUCHAR pWirelessPacket = NULL;
UCHAR QueIdx;
NDIS_STATUS Status;
unsigned long IrqFlags;
UINT32 USBDMApktLen = 0, DMAHdrLen, padding;
#ifdef USB_BULK_BUF_ALIGMENT
BOOLEAN bLasAlignmentsectiontRound = FALSE;
#else
BOOLEAN TxQLastRound = FALSE;
#endif /* USB_BULK_BUF_ALIGMENT */
UINT8 TXWISize = pAd->chipCap.TXWISize;
/* get Tx Ring Resource & Dma Buffer address*/
QueIdx = pTxBlk->QueIdx;
pHTTXContext = &pAd->TxContext[QueIdx];
RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
pHTTXContext = &pAd->TxContext[QueIdx];
fillOffset = pHTTXContext->CurWritePosition;
if(fragNum == 0)
{
/* Check if we have enough space for this bulk-out batch.*/
Status = RtmpUSBCanDoWrite(pAd, QueIdx, pHTTXContext);
if (Status == NDIS_STATUS_SUCCESS)
{
pHTTXContext->bCurWriting = TRUE;
#ifndef USB_BULK_BUF_ALIGMENT
/* Reserve space for 8 bytes padding.*/
if ((pHTTXContext->ENextBulkOutPosition == pHTTXContext->CurWritePosition))
{
pHTTXContext->ENextBulkOutPosition += 8;
pHTTXContext->CurWritePosition += 8;
fillOffset += 8;
}
#endif /* USB_BULK_BUF_ALIGMENT */
pTxBlk->Priv = 0;
pHTTXContext->CurWriteRealPos = pHTTXContext->CurWritePosition;
}
else
{
RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket, NDIS_STATUS_FAILURE);
return(Status);
}
}
else
{
/* For sub-sequent frames of this bulk-out batch. Just copy it to our bulk-out buffer.*/
Status = ((pHTTXContext->bCurWriting == TRUE) ? NDIS_STATUS_SUCCESS : NDIS_STATUS_FAILURE);
if (Status == NDIS_STATUS_SUCCESS)
{
fillOffset += pTxBlk->Priv;
}
else
{
RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket, NDIS_STATUS_FAILURE);
return(Status);
}
}
NdisZeroMemory((PUCHAR)(&pTxBlk->HeaderBuf[0]), TXINFO_SIZE);
pTxInfo = (TXINFO_STRUC *)(&pTxBlk->HeaderBuf[0]);
pTxWI= (TXWI_STRUC *)(&pTxBlk->HeaderBuf[TXINFO_SIZE]);
pWirelessPacket = &pHTTXContext->TransferBuffer->field.WirelessPacket[fillOffset];
/* copy TXWI + WLAN Header + LLC into DMA Header Buffer*/
/*hwHdrLen = ROUND_UP(pTxBlk->MpduHeaderLen, 4);*/
hwHdrLen = pTxBlk->MpduHeaderLen + pTxBlk->HdrPadLen;
/* Build our URB for USBD*/
DMAHdrLen = TXWISize + hwHdrLen;
USBDMApktLen = DMAHdrLen + pTxBlk->SrcBufLen;
padding = (4 - (USBDMApktLen % 4)) & 0x03; /* round up to 4 byte alignment*/
USBDMApktLen += padding;
pTxBlk->Priv += (TXINFO_SIZE + USBDMApktLen);
/* For TxInfo, the length of USBDMApktLen = TXWI_SIZE + 802.11 header + payload*/
rlt_usb_write_txinfo(pAd, pTxInfo, (USHORT)(USBDMApktLen), FALSE, FIFO_EDCA, FALSE /*NextValid*/, FALSE);
if (fragNum == pTxBlk->TotalFragNum)
{
pTxInfo->TxInfoUDMATxburst = 0;
#ifdef USB_BULK_BUF_ALIGMENT
/*
when CurWritePosition > 0x6000 mean that it is at the max bulk out size,
we CurWriteIdx must move to the next alignment section.
Otherwirse, CurWriteIdx will be moved to the next section at databulkout.
(((pHTTXContext->CurWritePosition + 3906)& 0x00007fff) & 0xffff6000) == 0x00006000)
we must make sure that the last fragNun packet just over the 0x6000
otherwise it will error because the last frag packet will at the section but will not bulk out.
ex: when secoend packet writeresouce and it > 0x6000
And the last packet writesource and it also > 0x6000 at this time CurWriteIdx++
but when data bulk out , because at second packet it will > 0x6000 , the last packet will not bulk out.
*/
if ( ((pHTTXContext->CurWritePosition + 3906) & 0x00006000) == 0x00006000)
{
bLasAlignmentsectiontRound = TRUE;
pTxInfo->bFragLasAlignmentsectiontRound = 1;
}
#else
if ((pHTTXContext->CurWritePosition + pTxBlk->Priv + 3906)> MAX_TXBULK_LIMIT)
{
pTxInfo->TxInfoSwLstRnd = 1;
TxQLastRound = TRUE;
}
#endif /* USB_BULK_BUF_ALIGMENT */
}
else
{
pTxInfo->TxInfoUDMATxburst = 1;
}
NdisMoveMemory(pWirelessPacket, pTxBlk->HeaderBuf, TXINFO_SIZE + TXWISize + hwHdrLen);
#ifdef RT_BIG_ENDIAN
RTMPFrameEndianChange(pAd, (PUCHAR)(pWirelessPacket + TXINFO_SIZE + TXWISize), DIR_WRITE, FALSE);
#endif /* RT_BIG_ENDIAN */
pWirelessPacket += (TXINFO_SIZE + TXWISize + hwHdrLen);
pHTTXContext->CurWriteRealPos += (TXINFO_SIZE + TXWISize + hwHdrLen);
RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
NdisMoveMemory(pWirelessPacket, pTxBlk->pSrcBufData, pTxBlk->SrcBufLen);
/* Zero the last padding.*/
pWirelessPacket += pTxBlk->SrcBufLen;
NdisZeroMemory(pWirelessPacket, padding + 8);
if (fragNum == pTxBlk->TotalFragNum)
{
RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
/* Update the pHTTXContext->CurWritePosition. 3906 used to prevent the NextBulkOut is a A-RALINK/A-MSDU Frame.*/
pHTTXContext->CurWritePosition += pTxBlk->Priv;
#ifndef USB_BULK_BUF_ALIGMENT
if (TxQLastRound == TRUE)
pHTTXContext->CurWritePosition = 8;
#endif /* USB_BULK_BUF_ALIGMENT */
#ifdef USB_BULK_BUF_ALIGMENT
if(bLasAlignmentsectiontRound == TRUE)
{
pHTTXContext->CurWritePosition = ((CUR_WRITE_IDX_INC(pHTTXContext->CurWriteIdx, BUF_ALIGMENT_RINGSIZE)) * 0x8000);
}
#endif /* USB_BULK_BUF_ALIGMENT */
pHTTXContext->CurWriteRealPos = pHTTXContext->CurWritePosition;
#ifdef UAPSD_SUPPORT
#endif /* UAPSD_SUPPORT */
/* Finally, set bCurWriting as FALSE*/
pHTTXContext->bCurWriting = FALSE;
RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
/* succeed and release the skb buffer*/
RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket, NDIS_STATUS_SUCCESS);
}
return(Status);
}
USHORT RtmpUSB_WriteSingleTxResource(
IN RTMP_ADAPTER *pAd,
IN TX_BLK *pTxBlk,
IN BOOLEAN bIsLast,
OUT USHORT *freeCnt)
{
HT_TX_CONTEXT *pHTTXContext;
UINT32 fillOffset;
TXINFO_STRUC *pTxInfo;
TXWI_STRUC *pTxWI;
UCHAR *pWirelessPacket, *buf;
UCHAR QueIdx;
unsigned long IrqFlags;
NDIS_STATUS Status;
UINT32 hdr_copy_len, hdr_len, dma_len = 0, padding;
#ifndef USB_BULK_BUF_ALIGMENT
BOOLEAN bTxQLastRound = FALSE;
#endif /* USB_BULK_BUF_ALIGMENT */
UINT8 TXWISize = pAd->chipCap.TXWISize;
/* get Tx Ring Resource & Dma Buffer address*/
QueIdx = pTxBlk->QueIdx;
RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
pHTTXContext = &pAd->TxContext[QueIdx];
fillOffset = pHTTXContext->CurWritePosition;
/* Check ring full */
Status = RtmpUSBCanDoWrite(pAd, QueIdx, pHTTXContext);
if(Status == NDIS_STATUS_SUCCESS)
{
pHTTXContext->bCurWriting = TRUE;
buf = &pTxBlk->HeaderBuf[0];
pTxInfo = (TXINFO_STRUC *)buf;
pTxWI= (TXWI_STRUC *)&buf[TXINFO_SIZE];
#ifndef USB_BULK_BUF_ALIGMENT
/* Reserve space for 8 bytes padding.*/
if ((pHTTXContext->ENextBulkOutPosition == pHTTXContext->CurWritePosition))
{
pHTTXContext->ENextBulkOutPosition += 8;
pHTTXContext->CurWritePosition += 8;
fillOffset += 8;
}
#endif /* USB_BULK_BUF_ALIGMENT */
pHTTXContext->CurWriteRealPos = pHTTXContext->CurWritePosition;
pWirelessPacket = &pHTTXContext->TransferBuffer->field.WirelessPacket[fillOffset];
/* Build our URB for USBD */
hdr_len = TXWISize + TSO_SIZE + pTxBlk->MpduHeaderLen + pTxBlk->HdrPadLen;
hdr_copy_len = TXINFO_SIZE + hdr_len;
dma_len = hdr_len + pTxBlk->SrcBufLen;
padding = (4 - (dma_len % 4)) & 0x03; /* round up to 4 byte alignment*/
dma_len += padding;
pTxBlk->Priv = (TXINFO_SIZE + dma_len);
/* For TxInfo, the length of USBDMApktLen = TXWI_SIZE + TSO_SIZE + 802.11 header + payload */
rlt_usb_write_txinfo(pAd, pTxInfo, (USHORT)(dma_len), FALSE, FIFO_EDCA, FALSE /*NextValid*/, FALSE);
#ifndef USB_BULK_BUF_ALIGMENT
if ((pHTTXContext->CurWritePosition + 3906 + pTxBlk->Priv) > MAX_TXBULK_LIMIT)
{
pTxInfo->TxInfoSwLstRnd = 1;
bTxQLastRound = TRUE;
}
#endif /* USB_BULK_BUF_ALIGMENT */
NdisMoveMemory(pWirelessPacket, pTxBlk->HeaderBuf, hdr_copy_len);
#ifdef RT_BIG_ENDIAN
RTMPFrameEndianChange(pAd, (PUCHAR)(pWirelessPacket + TXINFO_SIZE + TXWISize + TSO_SIZE), DIR_WRITE, FALSE);
#endif /* RT_BIG_ENDIAN */
pWirelessPacket += (hdr_copy_len);
/* We unlock it here to prevent the first 8 bytes maybe over-writed issue.*/
/* 1. First we got CurWritePosition but the first 8 bytes still not write to the pTxcontext.*/
/* 2. An interrupt break our routine and handle bulk-out complete.*/
/* 3. In the bulk-out compllete, it need to do another bulk-out, */
/* if the ENextBulkOutPosition is just the same as CurWritePosition, it will save the first 8 bytes from CurWritePosition,*/
/* but the payload still not copyed. the pTxContext->SavedPad[] will save as allzero. and set the bCopyPad = TRUE.*/
/* 4. Interrupt complete.*/
/* 5. Our interrupted routine go back and fill the first 8 bytes to pTxContext.*/
/* 6. Next time when do bulk-out, it found the bCopyPad==TRUE and will copy the SavedPad[] to pTxContext->NextBulkOutPosition.*/
/* and the packet will wrong.*/
pHTTXContext->CurWriteRealPos += hdr_copy_len;
#ifndef USB_BULK_BUF_ALIGMENT
RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
#endif /* USB_BULK_BUF_ALIGMENT */
#ifdef TX_PKT_SG
if (pTxBlk->pkt_info.BufferCount > 1) {
INT i, len;
void *data;
PKT_SG_T *sg = &pTxBlk->pkt_info.sg_list[0];
for (i = 0 ; i < pTxBlk->pkt_info.BufferCount; i++) {
data = sg[i].data;
len = sg[i].len;
if (i == 0) {
len -= ((ULONG)pTxBlk->pSrcBufData - (ULONG)sg[i].data);
data = pTxBlk->pSrcBufData;
}
//DBGPRINT(RT_DEBUG_TRACE, ("%s:sg[%d]=0x%x, len=%d\n", __FUNCTION__, i, data, len));
if (len <= 0) {
DBGPRINT(RT_DEBUG_ERROR, ("%s():sg[%d] info error, sg.data=0x%x, sg.len=%d, pTxBlk->pSrcBufData=0x%x, pTxBlk->SrcBufLen=%d, data=0x%x, len=%d\n",
__FUNCTION__, i, sg[i].data, sg[i].len, pTxBlk->pSrcBufData, pTxBlk->SrcBufLen, data, len));
break;
}
NdisMoveMemory(pWirelessPacket, data, len);
pWirelessPacket += len;
}
}
else
#endif /* TX_PKT_SG */
{
NdisMoveMemory(pWirelessPacket, pTxBlk->pSrcBufData, pTxBlk->SrcBufLen);
pWirelessPacket += pTxBlk->SrcBufLen;
}
#ifndef USB_BULK_BUF_ALIGMENT
NdisZeroMemory(pWirelessPacket, padding + 8);
RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
#endif /* USB_BULK_BUF_ALIGMENT */
pHTTXContext->CurWritePosition += pTxBlk->Priv;
#ifdef UAPSD_SUPPORT
#endif /* UAPSD_SUPPORT */
#ifdef USB_BULK_BUF_ALIGMENT
/*
when CurWritePosition > 0x6000 mean that it is at the max bulk out size,
we CurWriteIdx must move to the next alignment section.
Otherwirse, CurWriteIdx will be moved to the next section at databulkout.
Writingflag = TRUE ,mean that when we writing resource ,and databulkout happen,
So we bulk out when this packet finish.
*/
if ( (pHTTXContext->CurWritePosition & 0x00006000) == 0x00006000)
{
pHTTXContext->CurWritePosition = ((CUR_WRITE_IDX_INC(pHTTXContext->CurWriteIdx, BUF_ALIGMENT_RINGSIZE)) * 0x8000);
}
#else
if (bTxQLastRound)
pHTTXContext->CurWritePosition = 8;
#endif /* USB_BULK_BUF_ALIGMENT */
pHTTXContext->CurWriteRealPos = pHTTXContext->CurWritePosition;
pHTTXContext->bCurWriting = FALSE;
}
RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
/* succeed and release the skb buffer*/
RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket, NDIS_STATUS_SUCCESS);
return(Status);
}
static void rtusb_dataout_complete(unsigned long data)
{
PRTMP_ADAPTER pAd;
purbb_t pUrb;
POS_COOKIE pObj;
PHT_TX_CONTEXT pHTTXContext;
UCHAR BulkOutPipeId;
NTSTATUS Status;
unsigned long IrqFlags;
#ifdef USB_BULK_BUF_ALIGMENT
unsigned long IrqFlags2 = 0;
INT idx = 0;
#endif /* USB_BULK_BUF_ALIGMENT */
#ifdef RELEASE_EXCLUDE
DBGPRINT_RAW(RT_DEBUG_INFO, ("--->RTUSBBulkOutDataPacketComplete\n"));
#endif /* RELEASE_EXCLUDE */
pUrb = (purbb_t)data;
/* pHTTXContext = (PHT_TX_CONTEXT)pUrb->context; */
pHTTXContext = (PHT_TX_CONTEXT)RTMP_USB_URB_DATA_GET(pUrb);
Status = RTMP_USB_URB_STATUS_GET(pUrb);
pAd = pHTTXContext->pAd;
pObj = (POS_COOKIE) pAd->OS_Cookie;
/* Status = pUrb->status; */
/* Store BulkOut PipeId */
BulkOutPipeId = pHTTXContext->BulkOutPipeId;
pAd->BulkOutDataOneSecCount++;
/*DBGPRINT(RT_DEBUG_LOUD, ("Done-B(%d):I=0x%lx, CWPos=%ld, NBPos=%ld, ENBPos=%ld, bCopy=%d!\n", BulkOutPipeId, in_interrupt(), pHTTXContext->CurWritePosition, */
/* pHTTXContext->NextBulkOutPosition, pHTTXContext->ENextBulkOutPosition, pHTTXContext->bCopySavePad)); */
RTMP_IRQ_LOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
pAd->BulkOutPending[BulkOutPipeId] = FALSE;
pHTTXContext->IRPPending = FALSE;
pAd->watchDogTxPendingCnt[BulkOutPipeId] = 0;
if (Status == USB_ST_NOERROR)
{
pAd->BulkOutComplete++;
RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
pAd->Counters8023.GoodTransmits++;
/*RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[BulkOutPipeId], IrqFlags); */
FREE_HTTX_RING(pAd, BulkOutPipeId, pHTTXContext);
/*RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[BulkOutPipeId], IrqFlags); */
#ifdef UAPSD_SUPPORT
#if defined(DOT11Z_TDLS_SUPPORT) || defined(CFG_TDLS_SUPPORT)
#ifdef USB_BULK_BUF_ALIGMENT
UAPSD_UnTagFrame(pAd, BulkOutPipeId, pHTTXContext->CurtBulkIdx, pHTTXContext->NextBulkIdx);
#else
UAPSD_UnTagFrame(pAd, BulkOutPipeId, pHTTXContext->NextBulkOutPosition, pHTTXContext->ENextBulkOutPosition);
#endif /* USB_BULK_BUF_ALIGMENT */
#else
#ifdef CONFIG_AP_SUPPORT
#ifdef P2P_SUPPORT
if (P2P_GO_ON(pAd))
#else
#ifdef RT_CFG80211_P2P_SUPPORT
if (RTMP_CFG80211_VIF_P2P_GO_ON(pAd))
#else
IF_DEV_CONFIG_OPMODE_ON_AP(pAd)
#endif /* RT_CFG80211_P2P_SUPPORT */
#endif /* P2P_SUPPORT */
{
#ifdef USB_BULK_BUF_ALIGMENT
UAPSD_UnTagFrame(pAd, BulkOutPipeId, pHTTXContext->CurtBulkIdx, pHTTXContext->NextBulkIdx);
#else
UAPSD_UnTagFrame(pAd, BulkOutPipeId, pHTTXContext->NextBulkOutPosition, pHTTXContext->ENextBulkOutPosition);
#endif /* USB_BULK_BUF_ALIGMENT */
}
#endif /* CONFIG_AP_SUPPORT */
#endif /* defined(DOT11Z_TDLS_SUPPORT) || defined(CFG_TDLS_SUPPORT) */
#endif /* UAPSD_SUPPORT */
#ifdef USB_BULK_BUF_ALIGMENT
RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[BulkOutPipeId], IrqFlags2);
CUR_WRITE_IDX_INC(pHTTXContext->CurtBulkIdx, BUF_ALIGMENT_RINGSIZE);
RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[BulkOutPipeId], IrqFlags2);
#endif /* USB_BULK_BUF_ALIGMENT */
}
