自学教程：C++ DBGPRINT_RAW函数代码示例

/*	========================================================================		Routine Description:	Arguments:	Return Value:	Note:		========================================================================*/VOID	RTUSBCancelPendingBulkInIRP(	IN	PRTMP_ADAPTER	pAd){	PRX_CONTEXT		pRxContext;	PCMD_RSP_CONTEXT pCmdRspEventContext = &pAd->CmdRspEventContext;	UINT			i;	DBGPRINT_RAW(RT_DEBUG_TRACE, ("--->RTUSBCancelPendingBulkInIRP/n"));	for ( i = 0; i < (RX_RING_SIZE); i++)	{		pRxContext = &(pAd->RxContext[i]);		if(pRxContext->IRPPending == TRUE)		{			RTUSB_UNLINK_URB(pRxContext->pUrb);			pRxContext->IRPPending = FALSE;			pRxContext->InUse = FALSE;			/*NdisInterlockedDecrement(&pAd->PendingRx);*/			/*pAd->PendingRx--;*/		}	}	if (pCmdRspEventContext->IRPPending == TRUE)	{		printk("unlink cmd rsp urb/n");		RTUSB_UNLINK_URB(pCmdRspEventContext->pUrb);		pCmdRspEventContext->IRPPending = FALSE;		pCmdRspEventContext->InUse = FALSE;	}	DBGPRINT_RAW(RT_DEBUG_TRACE, ("<---RTUSBCancelPendingBulkInIRP/n"));}

/*	========================================================================		Routine Description:	Arguments:	Return Value:	IRQL = 		Note:		========================================================================*/VOID	RTUSBRejectPendingPackets(	IN	PRTMP_ADAPTER	pAd){	UCHAR			Index;	PQUEUE_ENTRY	pEntry;	PNDIS_PACKET	pPacket;	PQUEUE_HEADER	pQueue;	#ifdef RELEASE_EXCLUDE	DBGPRINT_RAW(RT_DEBUG_INFO, ("--->RejectPendingPackets/n"));#endif // RELEASE_EXCLUDE //	for (Index = 0; Index < 4; Index++)	{		NdisAcquireSpinLock(&pAd->TxSwQueueLock[Index]);		while (pAd->TxSwQueue[Index].Head != NULL)		{			pQueue = (PQUEUE_HEADER) &(pAd->TxSwQueue[Index]);			pEntry = RemoveHeadQueue(pQueue);			pPacket = QUEUE_ENTRY_TO_PACKET(pEntry);			RELEASE_NDIS_PACKET(pAd, pPacket, NDIS_STATUS_FAILURE);		}		NdisReleaseSpinLock(&pAd->TxSwQueueLock[Index]);	}#ifdef RELEASE_EXCLUDE	DBGPRINT_RAW(RT_DEBUG_INFO, ("<---RejectPendingPackets/n"));#endif // RELEASE_EXCLUDE //}

static BOOLEAN USBDevConfigInit(	IN struct usb_device 	*dev,	IN struct usb_interface *intf, 	IN VOID					*pAd){	struct usb_interface_descriptor *iface_desc;	struct usb_endpoint_descriptor *endpoint;	ULONG BulkOutIdx;	UINT32 i;	RT_CMD_USB_DEV_CONFIG Config, *pConfig = &Config;	iface_desc = &intf->altsetting[0];	/* get # of enpoints */	pConfig->NumberOfPipes = iface_desc->bNumEndpoints;	DBGPRINT(RT_DEBUG_TRACE, ("NumEndpoints=%d/n", iface_desc->bNumEndpoints));		 	/* Configure Pipes */	endpoint = &iface_desc->endpoint[0];	BulkOutIdx = 0;	for(i=0; i<pConfig->NumberOfPipes; i++)	{		if ((endpoint[i].bmAttributes == USB_ENDPOINT_XFER_BULK) && 			((endpoint[i].bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN))		{			pConfig->BulkInEpAddr = endpoint[i].bEndpointAddress;			pConfig->BulkInMaxPacketSize = endpoint[i].wMaxPacketSize;			DBGPRINT_RAW(RT_DEBUG_TRACE, ("BULK IN MaximumPacketSize = %d/n", pConfig->BulkInMaxPacketSize));			DBGPRINT_RAW(RT_DEBUG_TRACE, ("EP address = 0x%2x  /n", endpoint[i].bEndpointAddress));		}		else if ((endpoint[i].bmAttributes == USB_ENDPOINT_XFER_BULK) && 				((endpoint[i].bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT))		{			/* There are 6 bulk out EP. EP6 highest priority. */			/* EP1-4 is EDCA.  EP5 is HCCA. */			pConfig->BulkOutEpAddr[BulkOutIdx++] = endpoint[i].bEndpointAddress;			pConfig->BulkOutMaxPacketSize = endpoint[i].wMaxPacketSize;			DBGPRINT_RAW(RT_DEBUG_TRACE, ("BULK OUT MaximumPacketSize = %d/n", pConfig->BulkOutMaxPacketSize));			DBGPRINT_RAW(RT_DEBUG_TRACE, ("EP address = 0x%2x  /n", endpoint[i].bEndpointAddress));		}	}	if (!(pConfig->BulkInEpAddr && pConfig->BulkOutEpAddr[0])) 	{		printk("Could not find both bulk-in and bulk-out endpoints/n");		return FALSE;	}	pConfig->pConfig = dev->config;	RTMP_DRIVER_USB_CONFIG_INIT(pAd, pConfig);	RT28XXVendorSpecificCheck(dev, pAd);	return TRUE;	}

/* Antenna divesity use GPIO3 and EESK pin for control Antenna and EEPROM access are both using EESK pin, Therefor we should avoid accessing EESK at the same time Then restore antenna after EEPROM access The original name of this function is AsicSetRxAnt(), now change to */VOID RT30xxSetRxAnt(	IN PRTMP_ADAPTER	pAd,	IN UCHAR			Ant){	UINT32	Value;	if (/*(!pAd->NicConfig2.field.AntDiversity) ||*/		(RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS))	||		(RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS))	||		(RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RADIO_OFF)) ||		(RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)))	{		return;	}	/* the antenna selection is through firmware and MAC register(GPIO3) */	if (IS_RT2070(pAd) || (IS_RT3070(pAd) && pAd->RfIcType == RFIC_3020) ||			(IS_RT3090(pAd) && pAd->RfIcType == RFIC_3020))	{	if (Ant == 0)	{		/*			Main antenna			E2PROM_CSR only in PCI bus Reg., USB Bus need MCU commad to control the EESK pin.		*/#ifdef RTMP_MAC_USB		AsicSendCommandToMcu(pAd, 0x73, 0xFF, 0x1, 0x0, FALSE);#endif /* RTMP_MAC_USB */		RTMP_IO_READ32(pAd, GPIO_CTRL_CFG, &Value);		Value &= ~(0x0808);		RTMP_IO_WRITE32(pAd, GPIO_CTRL_CFG, Value);		DBGPRINT_RAW(RT_DEBUG_TRACE, ("AsicSetRxAnt, switch to main antenna/n"));	}	else	{		/*			Aux antenna		 	E2PROM_CSR only in PCI bus Reg., USB Bus need MCU commad to control the EESK pin.		*/#ifdef RTMP_MAC_USB		AsicSendCommandToMcu(pAd, 0x73, 0xFF, 0x0, 0x0, FALSE);#endif /* RTMP_MAC_USB */		RTMP_IO_READ32(pAd, GPIO_CTRL_CFG, &Value);		Value &= ~(0x0808);		Value |= 0x08;		RTMP_IO_WRITE32(pAd, GPIO_CTRL_CFG, Value);		DBGPRINT_RAW(RT_DEBUG_TRACE, ("AsicSetRxAnt, switch to aux antenna/n"));		}	}}

// RTS frame use BulkOutPipeId = PipeIDVOID RTUSBBulkOutRTSFrameComplete(purbb_t pUrb, struct pt_regs *pt_regs){	PRTMP_ADAPTER	pAd;	PTX_CONTEXT		pRTSContext;	NTSTATUS		status;	unsigned long	IrqFlags;		pRTSContext= (PTX_CONTEXT)pUrb->context;	pAd = pRTSContext->pAd;			DBGPRINT_RAW(RT_DEBUG_INFO, "--->RTUSBBulkOutRTSFrameComplete/n");	// Reset RTS frame context flags	pRTSContext->IRPPending = FALSE;	pRTSContext->InUse = FALSE;			status = pUrb->status;		if (status == USB_ST_NOERROR)	{		// Don't worry about the queue is empty or not, this function will check itself		RTMPDeQueuePacket(pAd, pRTSContext->BulkOutPipeId);	}#if 1	// STATUS_OTHER	else	{		if ((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)) &&			(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)) &&			(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)) &&			(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET)))		{			DBGPRINT_RAW(RT_DEBUG_ERROR, "Bulk Out RTS Frame Failed/n");			RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET);			RTUSBEnqueueInternalCmd(pAd, RT_OID_USB_RESET_BULK_OUT);		}	}#endif	NdisAcquireSpinLock(&pAd->BulkOutLock[pRTSContext->BulkOutPipeId], IrqFlags);	pAd->BulkOutPending[pRTSContext->BulkOutPipeId] = FALSE;	NdisReleaseSpinLock(&pAd->BulkOutLock[pRTSContext->BulkOutPipeId], IrqFlags);	// Always call Bulk routine, even reset bulk.	// The protectioon of rest bulk should be in BulkOut routine	RTUSBKickBulkOut(pAd);	DBGPRINT_RAW(RT_DEBUG_INFO, "<---RTUSBBulkOutRTSFrameComplete/n");	}

/*	========================================================================		Routine Description:	Arguments:	Return Value:	Note: 		========================================================================*/VOID	RTUSBBulkOutRTSFrame(	IN	PRTMP_ADAPTER	pAd){	PTX_CONTEXT	pRTSContext = &(pAd->RTSContext);	PURB		pUrb;	int 		ret = 0;	unsigned long	IrqFlags;	UCHAR		PipeID=0;		if (RTUSB_TEST_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_NORMAL_4))		PipeID= 3;	else if (RTUSB_TEST_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_NORMAL_3))		PipeID= 2;	else if (RTUSB_TEST_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_NORMAL_2))		PipeID= 1;	else if (RTUSB_TEST_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_NORMAL))		PipeID= 0;	NdisAcquireSpinLock(&pAd->BulkOutLock[PipeID], IrqFlags);	if (pAd->BulkOutPending[PipeID] == TRUE)	{		NdisReleaseSpinLock(&pAd->BulkOutLock[PipeID], IrqFlags);		return;	}	pAd->BulkOutPending[PipeID] = TRUE;	NdisReleaseSpinLock(&pAd->BulkOutLock[PipeID], IrqFlags);	// Increase Total transmit byte counter	pAd->RalinkCounters.TransmittedByteCount +=  pRTSContext->BulkOutSize;	DBGPRINT_RAW(RT_DEBUG_INFO, "--->RTUSBBulkOutRTSFrame /n");		// Clear RTS frame bulk flag	RTUSB_CLEAR_BULK_FLAG(pAd, fRTUSB_BULK_OUT_RTS);	// Init Tx context descriptor	RTUSBInitTxDesc(pAd, pRTSContext, PipeID, RTUSBBulkOutRTSFrameComplete);	pRTSContext->IRPPending = TRUE;		pUrb = pRTSContext->pUrb;	if((ret = rtusb_submit_urb(pUrb))!=0)	{		DBGPRINT(RT_DEBUG_ERROR,"Submit Tx URB failed %d/n", ret);		return;	}			DBGPRINT_RAW(RT_DEBUG_INFO, "<---RTUSBBulkOutRTSFrame /n");	return;}

// Antenna divesity use GPIO3 and EESK pin for control// Antenna and EEPROM access are both using EESK pin,// Therefor we should avoid accessing EESK at the same time// Then restore antenna after EEPROM access// The original name of this function is AsicSetRxAnt(), now change to //VOID AsicSetRxAnt(VOID RT30xxSetRxAnt(	IN PRTMP_ADAPTER	pAd,	IN UCHAR			Ant){	UINT32	Value;#ifdef RTMP_MAC_PCI	UINT32	x;#endif // RTMP_MAC_PCI //	if ((pAd->EepromAccess) ||		(RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS))	||		(RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS))	||		(RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RADIO_OFF)) ||		(RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)))	{		return;	}	// the antenna selection is through firmware and MAC register(GPIO3)	if (Ant == 0)	{		// Main antenna		// E2PROM_CSR only in PCI bus Reg., USB Bus need MCU commad to control the EESK pin.#ifdef RTMP_MAC_PCI		RTMP_IO_READ32(pAd, E2PROM_CSR, &x);		x |= (EESK);		RTMP_IO_WRITE32(pAd, E2PROM_CSR, x);#endif // RTMP_MAC_PCI //		RTMP_IO_READ32(pAd, GPIO_CTRL_CFG, &Value);		Value &= ~(0x0808);		RTMP_IO_WRITE32(pAd, GPIO_CTRL_CFG, Value);		DBGPRINT_RAW(RT_DEBUG_TRACE, ("AsicSetRxAnt, switch to main antenna/n"));	}	else	{		// Aux antenna		// E2PROM_CSR only in PCI bus Reg., USB Bus need MCU commad to control the EESK pin.#ifdef RTMP_MAC_PCI		RTMP_IO_READ32(pAd, E2PROM_CSR, &x);		x &= ~(EESK);		RTMP_IO_WRITE32(pAd, E2PROM_CSR, x);#endif // RTMP_MAC_PCI //		RTMP_IO_READ32(pAd, GPIO_CTRL_CFG, &Value);		Value &= ~(0x0808);		Value |= 0x08;		RTMP_IO_WRITE32(pAd, GPIO_CTRL_CFG, Value);		DBGPRINT_RAW(RT_DEBUG_TRACE, ("AsicSetRxAnt, switch to aux antenna/n"));	}}

static void rtusb_hcca_dma_done_tasklet(unsigned long data){	PRTMP_ADAPTER		pAd;	PHT_TX_CONTEXT		pHTTXContext;	UCHAR				BulkOutPipeId = 4;	purbb_t				pUrb;		DBGPRINT_RAW(RT_DEBUG_ERROR, ("--->hcca_dma_done_tasklet/n"));	pUrb			= (purbb_t)data;/*	pHTTXContext	= (PHT_TX_CONTEXT)pUrb->context; */	pHTTXContext	= (PHT_TX_CONTEXT)RTMP_USB_URB_DATA_GET(pUrb);	pAd				= pHTTXContext->pAd;	rtusb_dataout_complete((unsigned long)pUrb);	if ((RTMP_TEST_FLAG(pAd, (fRTMP_ADAPTER_RESET_IN_PROGRESS | 								fRTMP_ADAPTER_HALT_IN_PROGRESS | 								fRTMP_ADAPTER_NIC_NOT_EXIST)))) 	{		/* do nothing and return directly. */	}	else 	{			if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET))		{			RTEnqueueInternalCmd(pAd, CMDTHREAD_RESET_BULK_OUT, NULL, 0);			}		else		{	pHTTXContext = &pAd->TxContext[BulkOutPipeId];			if ((pAd->TxSwQueue[BulkOutPipeId].Number > 0) && 				/*((pHTTXContext->CurWritePosition > (pHTTXContext->NextBulkOutPosition + 0x6000)) || (pHTTXContext->NextBulkOutPosition > pHTTXContext->CurWritePosition + 0x6000)) && */				(pAd->DeQueueRunning[BulkOutPipeId] == FALSE) && 				(pHTTXContext->bCurWriting == FALSE))			{				RTMPDeQueuePacket(pAd, FALSE, BulkOutPipeId, MAX_TX_PROCESS);			}						RTUSB_SET_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_NORMAL);			RTUSBKickBulkOut(pAd);		}	}		DBGPRINT_RAW(RT_DEBUG_ERROR, ("<---hcca_dma_done_tasklet/n"));		return;}

/*	========================================================================		Routine Description:	Arguments:	Return Value:	Note: MLME use BulkOutPipeId = 0		========================================================================*/VOID	RTUSBBulkOutMLMEPacket(	IN	PRTMP_ADAPTER	pAd,	IN	UCHAR			Index){	PTX_CONTEXT		pMLMEContext;	PURB			pUrb;	int 			ret = 0;	unsigned long	IrqFlags;		pMLMEContext = &pAd->MLMEContext[Index];		NdisAcquireSpinLock(&pAd->BulkOutLock[0], IrqFlags);	if (pAd->BulkOutPending[0] == TRUE)	{		NdisReleaseSpinLock(&pAd->BulkOutLock[0], IrqFlags);		return;	}	pAd->BulkOutPending[0] = TRUE;	NdisReleaseSpinLock(&pAd->BulkOutLock[0], IrqFlags);	// Increase Total transmit byte counter	pAd->RalinkCounters.TransmittedByteCount +=  pMLMEContext->BulkOutSize;	// Clear MLME bulk flag	RTUSB_CLEAR_BULK_FLAG(pAd, fRTUSB_BULK_OUT_MLME);	DBGPRINT_RAW(RT_DEBUG_INFO, "RTUSBBulkOutMLMEPacket::PrioRingFirstIndex = %d, PrioRingTxCnt = %d, PopMgmtIndex = %d, PushMgmtIndex = %d, NextMLMEIndex = %d/n", 			pAd->PrioRingFirstIndex, 			pAd->PrioRingTxCnt, pAd->PopMgmtIndex, pAd->PushMgmtIndex, pAd->NextMLMEIndex);	DBGPRINT_RAW(RT_DEBUG_INFO, "--->RTUSBBulkOutMLMEPacket/n");	// Init Tx context descriptor	RTUSBInitTxDesc(pAd, pMLMEContext, 0, RTUSBBulkOutMLMEPacketComplete);	pMLMEContext->IRPPending = TRUE;	pUrb = pMLMEContext->pUrb;	if((ret = rtusb_submit_urb(pUrb))!=0)	{		DBGPRINT(RT_DEBUG_ERROR,"Submit MLME URB failed %d/n", ret);		return;	}		DBGPRINT_RAW(RT_DEBUG_INFO, "<---RTUSBBulkOutMLMEPacket /n");	return;}

/*	========================================================================	Routine Description: Write RF register through MAC	Arguments:	Return Value:	IRQL =	Note:	========================================================================*/NTSTATUS	RTUSBWriteRFRegister(	IN	PRTMP_ADAPTER	pAd,	IN	UINT32			Value){	PHY_CSR4_STRUC	PhyCsr4;	UINT			i = 0;	NTSTATUS		status;	NdisZeroMemory(&PhyCsr4, sizeof(PHY_CSR4_STRUC));	do	{		status = RTUSBReadMACRegister(pAd, RF_CSR_CFG0, &PhyCsr4.word);		if (status >= 0)		{		if (!(PhyCsr4.field.Busy))			break;		}		printk("RTUSBWriteRFRegister(RF_CSR_CFG0):retry count=%d!/n", i);		i++;	}	while ((i < RETRY_LIMIT) && (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)));	if ((i == RETRY_LIMIT) || (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)))	{		DBGPRINT_RAW(RT_DEBUG_ERROR, ("Retry count exhausted or device removed!!!/n"));		return STATUS_UNSUCCESSFUL;	}	RTUSBWriteMACRegister(pAd, RF_CSR_CFG0, Value);	return STATUS_SUCCESS;}

static inline BOOLEAN rf_csr_poll_idle(RTMP_ADAPTER *pAd, UINT32 *rfcsr){    RF_CSR_CFG_STRUC *csr_val;    BOOLEAN idle = BUSY;    INT i = 0;    do    {        if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST))            break;        RTMP_IO_READ32(pAd, RF_CSR_CFG, rfcsr);        csr_val = (RF_CSR_CFG_STRUC *)rfcsr;#ifdef RT65xx        if (IS_RT65XX(pAd))            idle = csr_val->bank_65xx.RF_CSR_KICK;        else#endif /* RT65xx */            idle = csr_val->non_bank.RF_CSR_KICK;        if (idle == IDLE)            break;        i++;    } while (i < MAX_BUSY_COUNT);    if ((i == MAX_BUSY_COUNT) || (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)))    {        DBGPRINT_RAW(RT_DEBUG_ERROR, ("Retry count exhausted or device removed(cnt=%d)!/n", i));    }    return idle;}

/*void AsicSetRxAnt( */void RT30xxSetRxAnt(struct rt_rtmp_adapter *pAd, u8 Ant){	u32 Value;#ifdef RTMP_MAC_PCI	u32 x;#endif	if ((pAd->EepromAccess) ||	    (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)) ||	    (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)) ||	    (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RADIO_OFF)) ||	    (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST))) {		return;	}	/* the antenna selection is through firmware and MAC register(GPIO3) */	if (Ant == 0) {		/* Main antenna */#ifdef RTMP_MAC_PCI		RTMP_IO_READ32(pAd, E2PROM_CSR, &x);		x |= (EESK);		RTMP_IO_WRITE32(pAd, E2PROM_CSR, x);#else		AsicSendCommandToMcu(pAd, 0x73, 0xFF, 0x1, 0x0);#endif /* RTMP_MAC_PCI // */		RTMP_IO_READ32(pAd, GPIO_CTRL_CFG, &Value);		Value &= ~(0x0808);		RTMP_IO_WRITE32(pAd, GPIO_CTRL_CFG, Value);		DBGPRINT_RAW(RT_DEBUG_TRACE,			     ("AsicSetRxAnt, switch to main antenna/n"));	} else {		/* Aux antenna */#ifdef RTMP_MAC_PCI		RTMP_IO_READ32(pAd, E2PROM_CSR, &x);		x &= ~(EESK);		RTMP_IO_WRITE32(pAd, E2PROM_CSR, x);#else		AsicSendCommandToMcu(pAd, 0x73, 0xFF, 0x0, 0x0);#endif /* RTMP_MAC_PCI // */		RTMP_IO_READ32(pAd, GPIO_CTRL_CFG, &Value);		Value &= ~(0x0808);		Value |= 0x08;		RTMP_IO_WRITE32(pAd, GPIO_CTRL_CFG, Value);		DBGPRINT_RAW(RT_DEBUG_TRACE,			     ("AsicSetRxAnt, switch to aux antenna/n"));	}}

NTSTATUS RTUSBVenderReset(RTMP_ADAPTER *pAd){	NTSTATUS Status;	DBGPRINT_RAW(RT_DEBUG_ERROR, ("-->RTUSBVenderReset/n"));	Status = RTUSB_VendorRequest(		pAd,		USBD_TRANSFER_DIRECTION_OUT,		DEVICE_VENDOR_REQUEST_OUT,		0x01,		0x1,		0,		NULL,		0);	DBGPRINT_RAW(RT_DEBUG_ERROR, ("<--RTUSBVenderReset/n"));	return Status;}

/*	========================================================================	Routine Description: Write RT30xx RF register through MAC	Arguments:	Return Value:	IRQL =	Note:	========================================================================*/NDIS_STATUS RT30xxWriteRFRegister(    IN	PRTMP_ADAPTER	pAd,    IN	UCHAR			regID,    IN	UCHAR			value){    RF_CSR_CFG_STRUC	rfcsr = { { 0 } };    UINT				i = 0;    ASSERT((regID <= pAd->chipCap.MaxNumOfRfId));    do    {        RTMP_IO_READ32(pAd, RF_CSR_CFG, &rfcsr.word);        if (!rfcsr.field.RF_CSR_KICK)            break;        i++;    }    while ((i < MAX_BUSY_COUNT) && (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)));    if ((i == MAX_BUSY_COUNT) || (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)))    {        DBGPRINT_RAW(RT_DEBUG_ERROR, ("Retry count exhausted or device removed!!!/n"));        return STATUS_UNSUCCESSFUL;    }    rfcsr.field.RF_CSR_WR = 1;    rfcsr.field.RF_CSR_KICK = 1;    rfcsr.field.TESTCSR_RFACC_REGNUM = regID;    if ((pAd->chipCap.RfReg17WtMethod == RF_REG_WT_METHOD_STEP_ON) && (regID == RF_R17))    {        UCHAR IdRf;        UCHAR RfValue;        BOOLEAN beAdd;        RT30xxReadRFRegister(pAd, RF_R17, &RfValue);        beAdd =  (RfValue < value) ? TRUE : FALSE;        IdRf = RfValue;        while(IdRf != value)        {            if (beAdd)                IdRf++;            else                IdRf--;            rfcsr.field.RF_CSR_DATA = IdRf;            RTMP_IO_WRITE32(pAd, RF_CSR_CFG, rfcsr.word);            RtmpOsMsDelay(1);        }    }    rfcsr.field.RF_CSR_DATA = value;    RTMP_IO_WRITE32(pAd, RF_CSR_CFG, rfcsr.word);    return NDIS_STATUS_SUCCESS;}

/*	========================================================================	Routine Description:	Arguments:	Return Value:	Note:	========================================================================*/void RTUSBCancelPendingBulkInIRP(struct rt_rtmp_adapter *pAd){	struct rt_rx_context *pRxContext;	u32 i;	DBGPRINT_RAW(RT_DEBUG_TRACE, ("--->RTUSBCancelPendingBulkInIRP/n"));	for (i = 0; i < (RX_RING_SIZE); i++) {		pRxContext = &(pAd->RxContext[i]);		if (pRxContext->IRPPending == TRUE) {			RTUSB_UNLINK_URB(pRxContext->pUrb);			pRxContext->IRPPending = FALSE;			pRxContext->InUse = FALSE;			/*NdisInterlockedDecrement(&pAd->PendingRx); */			/*pAd->PendingRx--; */		}	}	DBGPRINT_RAW(RT_DEBUG_TRACE, ("<---RTUSBCancelPendingBulkInIRP/n"));}

/*	========================================================================	Routine Description:	  Creates an IRP to submite an IOCTL_INTERNAL_USB_RESET_PORT	  synchronously. Callers of this function must be running at	  PASSIVE LEVEL.	Arguments:	Return Value:	Note:	========================================================================*/NTSTATUS	RTUSB_ResetDevice(	IN	PRTMP_ADAPTER	pAd){	NTSTATUS		Status = TRUE;	DBGPRINT_RAW(RT_DEBUG_TRACE, ("--->USB_ResetDevice/n"));	//RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS);	return Status;}

VOID RT33xxSetRxAnt(	IN PRTMP_ADAPTER	pAd,	IN UCHAR			Ant){	UINT32	Value;	UINT32	x;	if ((!pAd->NicConfig2.field.AntDiversity) ||		(RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS))	||		(RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS))	||		(RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RADIO_OFF)) ||		(RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)))	{		return;	}	// the antenna selection is through firmware and MAC register(GPIO3)	if (Ant == 0)	{		// Main antenna		// E2PROM_CSR only in PCI bus Reg., USB Bus need MCU commad to control the EESK pin.#ifdef RTMP_MAC_USB		AsicSendCommandToMcu(pAd, 0x73, 0xff, 0x1, 0x0);#endif // RTMP_MAC_USB //		RTMP_IO_READ32(pAd, GPIO_CTRL_CFG, &Value);		Value &= ~(0x0808);		RTMP_IO_WRITE32(pAd, GPIO_CTRL_CFG, Value);		DBGPRINT_RAW(RT_DEBUG_TRACE, ("AsicSetRxAnt, switch to main antenna/n"));	}	else	{		// Aux antenna		// E2PROM_CSR only in PCI bus Reg., USB Bus need MCU commad to control the EESK pin.#ifdef RTMP_MAC_USB		AsicSendCommandToMcu(pAd, 0x73, 0xff, 0x0, 0x0);#endif // RTMP_MAC_USB //		RTMP_IO_READ32(pAd, GPIO_CTRL_CFG, &Value);		Value &= ~(0x0808);		Value |= 0x08;		RTMP_IO_WRITE32(pAd, GPIO_CTRL_CFG, Value);		DBGPRINT_RAW(RT_DEBUG_TRACE, ("AsicSetRxAnt, switch to aux antenna/n"));	}}

VOID ATE_RTUSBBulkOutDataPacket(		IN	PRTMP_ADAPTER	pAd){	PTX_CONTEXT		pNullContext = &(pAd->NullContext);	PURB			pUrb;	int 			ret = 0;	unsigned long	IrqFlags;	ATE_RTMPSendNullFrame(pAd);		DBGPRINT_RAW(RT_DEBUG_INFO, "--->ATE_RTUSBBulkOutDataPacket /n");		NdisAcquireSpinLock(&pAd->BulkOutLock[0], IrqFlags);	if (pAd->BulkOutPending[0] == TRUE)	{		DBGPRINT_RAW(RT_DEBUG_INFO, "--->ATE_RTUSBBulkOutDataPacket BulkOutPending /n");		NdisReleaseSpinLock(&pAd->BulkOutLock[0], IrqFlags);		return;	}	pAd->BulkOutPending[0] = TRUE;	NdisReleaseSpinLock(&pAd->BulkOutLock[0], IrqFlags);	// Increase Total transmit byte counter	pAd->RalinkCounters.TransmittedByteCount +=  pNullContext->BulkOutSize;	DBGPRINT_RAW(RT_DEBUG_INFO, "--->ATE_RTUSBBulkOutDataPacket /n");	// Clear Null frame bulk flag	RTUSB_CLEAR_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_ATE);		// Init Tx context descriptor	RTUSBInitTxDesc(pAd, pNullContext, 0, ATE_RTUSBBulkOutDataPacketComplete);	pNullContext->IRPPending = TRUE;	pUrb = pNullContext->pUrb;	if((ret = rtusb_submit_urb(pUrb))!=0)	{		DBGPRINT(RT_DEBUG_ERROR,"Submit Tx URB failed %d/n", ret);		return;	}			DBGPRINT_RAW(RT_DEBUG_INFO, "<---ATE_RTUSBBulkOutDataPacket /n");	return;}

VOID RT33xxSetRxAnt(	IN PRTMP_ADAPTER	pAd,	IN UCHAR			Ant){	UINT32	Value;	UINT32	x;	if ((pAd->EepromAccess) ||		(RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS))	||		(RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS))	||		(RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RADIO_OFF)) ||		(RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)))	{		return;	}	// the antenna selection is through firmware and MAC register(GPIO3)	if (Ant == 0)	{		// Main antenna		RTMP_IO_READ32(pAd, E2PROM_CSR, &x);		x |= (EESK);		RTMP_IO_WRITE32(pAd, E2PROM_CSR, x);		RTMP_IO_READ32(pAd, GPIO_CTRL_CFG, &Value);		Value &= ~(0x0808);		RTMP_IO_WRITE32(pAd, GPIO_CTRL_CFG, Value);		DBGPRINT_RAW(RT_DEBUG_TRACE, ("AsicSetRxAnt, switch to main antenna/n"));	}	else	{		// Aux antenna		RTMP_IO_READ32(pAd, E2PROM_CSR, &x);		x &= ~(EESK);		RTMP_IO_WRITE32(pAd, E2PROM_CSR, x);		RTMP_IO_READ32(pAd, GPIO_CTRL_CFG, &Value);		Value &= ~(0x0808);		Value |= 0x08;		RTMP_IO_WRITE32(pAd, GPIO_CTRL_CFG, Value);		DBGPRINT_RAW(RT_DEBUG_TRACE, ("AsicSetRxAnt, switch to aux antenna/n"));	}}

/*	========================================================================	Routine Description:	Arguments:	Return Value:	IRQL =	Note:	========================================================================*/VOID RTUSBPutToSleep(RTMP_ADAPTER *pAd){	UINT32 value;	/* Timeout 0x40 x 50us*/	value = (SLEEPCID<<16)+(OWNERMCU<<24)+ (0x40<<8)+1;	RTUSBWriteMACRegister(pAd, 0x7010, value, FALSE);	RTUSBWriteMACRegister(pAd, 0x404, 0x30, FALSE);	DBGPRINT_RAW(RT_DEBUG_ERROR, ("Sleep Mailbox testvalue %x/n", value));}

/*	========================================================================		Routine Description:	Arguments:	Return Value:	Note:		========================================================================*/VOID	RTUSBCancelPendingBulkInIRP(	IN	PRTMP_ADAPTER	pAd){	PRX_CONTEXT	pRxContext;	UINT		i;	DBGPRINT_RAW(RT_DEBUG_TRACE,"--->RTUSBCancelPendingBulkInIRP/n");	for ( i = 0; i < RX_RING_SIZE; i++)	{		pRxContext = &(pAd->RxContext[i]);		if(atomic_read(&pRxContext->IrpLock) == IRPLOCK_CANCELABLE)		{			RTUSB_UNLINK_URB(pRxContext->pUrb);		}		atomic_set(&pRxContext->IrpLock, IRPLOCK_CANCE_START);	}	DBGPRINT_RAW(RT_DEBUG_TRACE,"<---RTUSBCancelPendingBulkInIRP/n");}

NDIS_STATUS RT635xWriteRFRegister(	IN	PRTMP_ADAPTER	pAd,	IN	UCHAR			bank,	IN	UCHAR			regID,	IN	UCHAR			value){	RF_CSR_CFG_STRUC	rfcsr = { { 0 } };	UINT				i = 0;	NDIS_STATUS	 ret;#ifdef RTMP_MAC_PCI	if ((pAd->bPCIclkOff == TRUE) || (pAd->LastMCUCmd == SLEEP_MCU_CMD))	{		DBGPRINT_ERR(("RT635xWriteRFRegister. Not allow to write RF 0x%x : fail/n",  regID));			return STATUS_UNSUCCESSFUL;	}#endif /* RTMP_MAC_PCI */	ASSERT((regID <= pAd->chipCap.MaxNumOfRfId));	if (regID > pAd->chipCap.MaxNumOfRfId)	{		DBGPRINT(RT_DEBUG_ERROR, ("RegID=%d, pAd->chipCap.MaxNumOfRfId=%d/n", regID, pAd->chipCap.MaxNumOfRfId));	}	ret = STATUS_UNSUCCESSFUL;	do	{		RTMP_IO_READ32(pAd, RF_CSR_CFG, &rfcsr.word);		if (!rfcsr.bank_6352.RF_CSR_KICK)			break;		i++;	}	while ((i < MAX_BUSY_COUNT) && (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)));	if ((i == MAX_BUSY_COUNT) || (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)))	{		DBGPRINT_RAW(RT_DEBUG_ERROR, ("Retry count exhausted or device removed!!!/n"));		goto done;	}	rfcsr.bank_6352.RF_CSR_WR = 1;	rfcsr.bank_6352.RF_CSR_KICK = 1;	rfcsr.bank_6352.TESTCSR_RFACC_REGNUM = (regID | (bank << 6));	rfcsr.bank_6352.RF_CSR_DATA = value;	RTMP_IO_WRITE32(pAd, RF_CSR_CFG, rfcsr.word);	ret = NDIS_STATUS_SUCCESS;done:	return ret;}

/*	========================================================================		Routine Description: Write RT30xx RF register through MAC	Arguments:	Return Value:	IRQL = 		Note:		========================================================================*/NDIS_STATUS RT30xxWriteRFRegister(	IN	PRTMP_ADAPTER	pAd,	IN	UCHAR			regID,	IN	UCHAR			value){	RF_CSR_CFG_STRUC	rfcsr = { { 0 } };	UINT				i = 0;#ifdef RTMP_MAC_PCI	if ((pAd->bPCIclkOff == TRUE) || (pAd->LastMCUCmd == SLEEP_MCU_CMD))	{		DBGPRINT_ERR(("RT30xxWriteRFRegister. Not allow to write RF 0x%x : fail/n",  regID));			return STATUS_UNSUCCESSFUL;	}#endif // RTMP_MAC_PCI //	{		if (IS_RT3883(pAd))		{			ASSERT((regID <= 63)); // R0~R63		}		else		{		ASSERT((regID <= 31)); // R0~R31		}		do		{			RTMP_IO_READ32(pAd, RF_CSR_CFG, &rfcsr.word);			if (!rfcsr.field.RF_CSR_KICK)				break;			i++;		}		while ((i < RETRY_LIMIT) && (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)));		if ((i == RETRY_LIMIT) || (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)))		{			DBGPRINT_RAW(RT_DEBUG_ERROR, ("Retry count exhausted or device removed!!!/n"));			return STATUS_UNSUCCESSFUL;		}		rfcsr.field.RF_CSR_WR = 1;		rfcsr.field.RF_CSR_KICK = 1;		rfcsr.field.TESTCSR_RFACC_REGNUM = regID; // R0~R31		rfcsr.field.RF_CSR_DATA = value;				RTMP_IO_WRITE32(pAd, RF_CSR_CFG, rfcsr.word);	}	return NDIS_STATUS_SUCCESS;}

/*	========================================================================	Routine Description:	Arguments:	Return Value:	Note:	========================================================================*/VOID	RTUSBCancelPendingBulkInIRP(	IN	PRTMP_ADAPTER	pAd){	PRX_CONTEXT		pRxContext;	UINT			i;	DBGPRINT_RAW(RT_DEBUG_TRACE, ("--->RTUSBCancelPendingBulkInIRP/n"));	for ( i = 0; i < (RX_RING_SIZE); i++)	{		pRxContext = &(pAd->RxContext[i]);		if(pRxContext->IRPPending == TRUE)		{			RTUSB_UNLINK_URB(pRxContext->pUrb);			pRxContext->IRPPending = FALSE;			pRxContext->InUse = FALSE;			//NdisInterlockedDecrement(&pAd->PendingRx);			//pAd->PendingRx--;		}	}	DBGPRINT_RAW(RT_DEBUG_TRACE, ("<---RTUSBCancelPendingBulkInIRP/n"));}

static void rtusb_null_frame_done_tasklet(unsigned long data){	PRTMP_ADAPTER	pAd;	PTX_CONTEXT		pNullContext;	purbb_t			pUrb;	NTSTATUS		Status;	unsigned long	irqFlag;	pUrb			= (purbb_t)data;/*	pNullContext	= (PTX_CONTEXT)pUrb->context; */	pNullContext	= (PTX_CONTEXT)RTMP_USB_URB_DATA_GET(pUrb);	Status			= RTMP_USB_URB_STATUS_GET(pUrb);	pAd 			= pNullContext->pAd;/*	Status 			= pUrb->status; */	/* Reset Null frame context flags */	RTMP_IRQ_LOCK(&pAd->BulkOutLock[0], irqFlag);	pNullContext->IRPPending 	= FALSE;	pNullContext->InUse 		= FALSE;	pAd->BulkOutPending[0] = FALSE;	pAd->watchDogTxPendingCnt[0] = 0;	if (Status == USB_ST_NOERROR)	{		RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[0], irqFlag);				RTMPDeQueuePacket(pAd, FALSE, NUM_OF_TX_RING, MAX_TX_PROCESS);	}	else	/* STATUS_OTHER */	{		if ((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)) &&			(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)) &&			(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)) &&			(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET)))		{			DBGPRINT_RAW(RT_DEBUG_ERROR, ("Bulk Out Null Frame Failed, ReasonCode=%d!/n", Status));			RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET);			pAd->bulkResetPipeid = (MGMTPIPEIDX | BULKOUT_MGMT_RESET_FLAG);			RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[0], irqFlag);			RTEnqueueInternalCmd(pAd, CMDTHREAD_RESET_BULK_OUT, NULL, 0);		}		else		{			RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[0], irqFlag);		}	}	/* Always call Bulk routine, even reset bulk. */	/* The protectioon of rest bulk should be in BulkOut routine */	RTUSBKickBulkOut(pAd);}

int mt_rf_read(	RTMP_ADAPTER *ad,	u8 rf_idx,	u16 offset,	u32 *data){	u32 i = 0;	u32 value;	int ret;		/* rf control */		RTMP_IO_READ32(ad, RF_CTRL, &value);		/* rf address */	value &= ~RF_ADDR_MASK;	value |= RF_ADDR(offset);		/* read control */	value &= ~RF_R_W_CTRL;	/* rf index */	value &= ~RF_IDX_MASK;	value |= RF_IDX(rf_idx);	RTMP_IO_WRITE32(ad, RF_CTRL, value);		do {		RTMP_IO_READ32(ad, RF_CTRL, &value);		if (RF_READY(value))			break;		i++;		//RtmpOsMsDelay(1);		RtmpusecDelay(50);	//} while ((i < MAX_BUSY_COUNT) && (!RTMP_TEST_FLAG(ad, fRTMP_ADAPTER_NIC_NOT_EXIST)));	} while ((i < MAX_BUSY_COUNT_US) && (!RTMP_TEST_FLAG(ad, fRTMP_ADAPTER_NIC_NOT_EXIST)));		//if ((i == MAX_BUSY_COUNT) || (RTMP_TEST_FLAG(ad, fRTMP_ADAPTER_NIC_NOT_EXIST))) {	if ((i == MAX_BUSY_COUNT_US) || (RTMP_TEST_FLAG(ad, fRTMP_ADAPTER_NIC_NOT_EXIST))) {		DBGPRINT_RAW(RT_DEBUG_ERROR, ("Retry count exhausted or device removed!!!/n"));		ret = STATUS_UNSUCCESSFUL;		goto done;	}	/* rf data */	RTMP_IO_READ32(ad, R_RFDATA, data);done:	return ret;}

static void rt2870_rts_frame_complete_tasklet(unsigned long data){	PRTMP_ADAPTER	pAd;	PTX_CONTEXT		pRTSContext;	purbb_t			pUrb;	NTSTATUS		Status;	unsigned long	irqFlag;	pUrb		= (purbb_t)data;	pRTSContext	= (PTX_CONTEXT)pUrb->context;	pAd			= pRTSContext->pAd;	Status		= pUrb->status;	// Reset RTS frame context flags	RTMP_IRQ_LOCK(&pAd->BulkOutLock[0], irqFlag);	pRTSContext->IRPPending = FALSE;	pRTSContext->InUse		= FALSE;				if (Status == USB_ST_NOERROR)	{		RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[0], irqFlag);		RTMPDeQueuePacket(pAd, FALSE, NUM_OF_TX_RING, MAX_TX_PROCESS);	}	else	// STATUS_OTHER	{		if ((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)) &&			(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)) &&			(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)) &&			(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET)))		{			DBGPRINT_RAW(RT_DEBUG_ERROR, ("Bulk Out RTS Frame Failed/n"));			RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET);			pAd->bulkResetPipeid = (MGMTPIPEIDX | BULKOUT_MGMT_RESET_FLAG);			RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[0], irqFlag);			RTUSBEnqueueInternalCmd(pAd, CMDTHREAD_RESET_BULK_OUT, NULL, 0);		}		else		{			RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[0], irqFlag);		}	}	RTMP_SEM_LOCK(&pAd->BulkOutLock[pRTSContext->BulkOutPipeId]);	pAd->BulkOutPending[pRTSContext->BulkOutPipeId] = FALSE;	RTMP_SEM_UNLOCK(&pAd->BulkOutLock[pRTSContext->BulkOutPipeId]);	// Always call Bulk routine, even reset bulk.	// The protectioon of rest bulk should be in BulkOut routine	RTUSBKickBulkOut(pAd);}

/*	========================================================================	Routine Description:	Arguments:	Return Value:	IRQL =	Note:	========================================================================*/VOID RTUSBPutToSleep(	IN	PRTMP_ADAPTER	pAd){	UINT32		value;	// Timeout 0x40 x 50us	value = (SLEEPCID<<16)+(OWNERMCU<<24)+ (0x40<<8)+1;	RTUSBWriteMACRegister(pAd, 0x7010, value);	RTUSBWriteMACRegister(pAd, 0x404, 0x30);	//RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS);	DBGPRINT_RAW(RT_DEBUG_ERROR, ("Sleep Mailbox testvalue %x/n", value));}