rxproc.c

marvell wifi driver CF-8385PN-NDIS-ARM4-WINCE50-5.24.17.p5-27.p11.src.zip

   		// Average out the SNR from the received packet 
   		Adapter->SNR[TYPE_RXPD][TYPE_AVG] =
    		CAL_AVG_SNR_NF(Adapter->SNR[TYPE_RXPD][TYPE_AVG], pRxPDCurrent->SNR);

  		// Average out the NF value 
   		Adapter->NF[TYPE_RXPD][TYPE_AVG] = 
    		        CAL_AVG_SNR_NF(Adapter->NF[TYPE_RXPD][TYPE_AVG], pRxPDCurrent->NF);

  		DBGPRINT(DBG_RXDATA ,("After computing SNR and NF\n"));
  		DBGPRINT(DBG_RXDATA ,("Adapter: SNR- avg = %d, NF-avg = %d\n", (Adapter->SNR[TYPE_RXPD][TYPE_AVG] / AVG_SCALE), (Adapter->NF[TYPE_RXPD][TYPE_AVG] / AVG_SCALE)));
  		
   		// store the RXPD values in SNRNF variable, 
   		// which is present in adapter structure 
   		Adapter->SNRNF[SNR_RXPD][TYPE_NOAVG]  = 
    			(UCHAR)Adapter->SNR[TYPE_RXPD][TYPE_NOAVG];
  		Adapter->SNRNF[SNR_RXPD][TYPE_AVG]  = 
    			(Adapter->SNR[TYPE_RXPD][TYPE_AVG] / AVG_SCALE); 
  		Adapter->SNRNF[NF_RXPD][TYPE_NOAVG] = 
    			(UCHAR)Adapter->NF[TYPE_RXPD][TYPE_NOAVG];
  		Adapter->SNRNF[NF_RXPD][TYPE_AVG] = 
    			(Adapter->NF[TYPE_RXPD][TYPE_AVG] / AVG_SCALE);
   
  		// NOTE: Adapter->SNRNF[SNR_BEACON][X] - represents BEACON for SNR
  		// Adapter->SNRNF[NF_BEACON][X] - represents BEACON for NF

  		Adapter->RSSI[TYPE_RXPD][TYPE_NOAVG] = 
    		        CAL_RSSI(Adapter->SNR[TYPE_RXPD][TYPE_NOAVG],
      		Adapter->NF[TYPE_RXPD][TYPE_NOAVG]);

 		Adapter->RSSI[TYPE_RXPD][TYPE_AVG] = 
    		        CAL_RSSI((Adapter->SNR[TYPE_RXPD][TYPE_AVG] / AVG_SCALE),
      			(Adapter->NF[TYPE_RXPD][TYPE_AVG] / AVG_SCALE));
        
              // DBGPRINT(DBG_RXDATA, ("1HandleRxReadyEvent: RSSI: pRxPDCurrent->SNR = %d,pRxPDCurrent->NF= %d,Adapter->RSSI[TYPE_BEACON][TYPE_NOAVG] = %d, Adapter->RSSI[TYPE_BEACON][TYPE_AVG]= %d, Adapter->LastRSSI=%d\n", 
              //                        pRxPDCurrent->SNR, 
              //                        pRxPDCurrent->NF,
              //                        Adapter->RSSI[TYPE_RXPD][TYPE_NOAVG],
              //                        Adapter->RSSI[TYPE_RXPD][TYPE_AVG],
              //                        Adapter->LastRSSI));
 
     		if ((Adapter->RSSI[TYPE_RXPD][TYPE_AVG] > -10) || (Adapter->RSSI[TYPE_RXPD][TYPE_AVG] < -200))
        	{
			DBGPRINT(DBG_ERROR, ("ERROR: Incorrect RSSI Value2 - SNR = %d, "
                                          "NF= %d, Adapter->RSSI[TYPE_RXPD][TYPE_AVG] = %d, Adapter->LastRSSI = %d\n", 
                                 pRxPDCurrent->SNR, 
                                 pRxPDCurrent->NF,
                                          Adapter->RSSI[TYPE_RXPD][TYPE_AVG],
                                 Adapter->LastRSSI));
        	}
        	else
        	{
            		if (Adapter->LastRSSI == MRVL_DEFAULT_INITIAL_RSSI)
            		{
                		Adapter->LastRSSI = Adapter->RSSI[TYPE_RXPD][TYPE_AVG];                    
            		}
            		else
            		{
                   		Adapter->LastRSSI = ((Adapter->LastRSSI * 3)+(Adapter->RSSI[TYPE_RXPD][TYPE_AVG]))/4;
            		}
        	}
		
		if (Adapter->LastRSSI <= Adapter->RSSITriggerValue)
		{
			// Increment RSSITriggerCounter
			Adapter->RSSITriggerCounter++;
		}
		else
		{
			// Reset the counter if RSSI goes above the trigger level
			if (Adapter->RSSITriggerCounter !=0)
				Adapter->RSSITriggerCounter=0;
		}
	
		// If the trigger occurs many times, send indication above
		if (Adapter->RSSITriggerCounter >= MRVDRV_RSSI_INDICATION_THRESHOLD)
		{			
			// Indicate to protocol driver about RSSI status
			NdisMIndicateStatus(Adapter->MrvDrvAdapterHdl,
						NDIS_STATUS_MEDIA_SPECIFIC_INDICATION,
						&(Adapter->LastRSSI),
						sizeof(LONG));
			NdisMIndicateStatusComplete(Adapter->MrvDrvAdapterHdl);
		
			// Reset the counter
			Adapter->RSSITriggerCounter=0;
		}

   		DBGPRINT(DBG_RXDATA, ("2HandleRxReadyEvent: RSSI: pRxPDCurrent->SNR = %d,pRxPDCurrent->NF= %d,Adapter->RSSI[TYPE_BEACON][TYPE_NOAVG] = %d, Adapter->RSSI[TYPE_BEACON][TYPE_AVG]= %d, Adapter->LastRSSI=%d\n", 
              			                      pRxPDCurrent->SNR, 
                                    		      pRxPDCurrent->NF,
                                    		      Adapter->RSSI[TYPE_RXPD][TYPE_NOAVG],
                                    		      Adapter->RSSI[TYPE_RXPD][TYPE_AVG],
                                    		      Adapter->LastRSSI));

	}
	else
	{
		DBGPRINT(DBG_RXDATA | DBG_WARNING,("WARNING: frame received with bad status\n"));
///RETAILMSG(1, (TEXT("WARNING: frame received with bad status  \r\n")));
	}

       if ( Adapter->bIsPendingReset == TRUE )
			return; 

	if (Adapter->bIsFreeNow == TRUE)
			return; 
	
	//return;
	

    	/// Get a packet then fill it and indicate to NDIS
    	
#ifdef USE_RX_QUEUE

	qStatus = GetRxPacketDesc(Adapter, &pPacket);

	if (qStatus == GPS_FAILED)
    	{
       	DBGPRINT( DBG_RXDATA | DBG_WARNING,("Unable to obtain packet descriptor, just drop packet\n"));

		//NdisReleaseSpinLock(&Adapter->RxSpinLock);
		return;
    	}
    
    	NdisQueryPacket(pPacket, NULL, NULL, &pBuffer, NULL);
    	NdisQueryBufferSafe(pBuffer, &pRxBufVM, &bufferLength, HighPagePriority);

    	if (Adapter->MediaConnectStatus == NdisMediaStateConnected)
    	{
       	Adapter->ulRxByteInLastPeriod += Adapter->ulRxSize;

        	NdisAdjustBufferLength(pBuffer, Adapter->ulRxSize);

		NdisMoveMemory( pRxBufVM, Adapter->pRxBuf, Adapter->ulRxSize);
		
        	NDIS_SET_PACKET_STATUS(pPacket, NDIS_STATUS_SUCCESS);

		NdisMIndicateReceivePacket(Adapter->MrvDrvAdapterHdl, &pPacket, 1);
        	pStatus = NDIS_GET_PACKET_STATUS(pPacket);
        
        	if ((pStatus == NDIS_STATUS_RESOURCES) || (pStatus == NDIS_STATUS_SUCCESS))
        	{
            		// return packet
           	 	DBGPRINT(DBG_RXDATA, ("Packet returned success or resources...\n"));
            		ReturnRxPacketDesc(Adapter,pPacket);            
        	}
        	else
        	{
            		DBGPRINT(DBG_RXDATA, ("Packet returned pending...\n"));
        	}
    	}
    	else
    	{
        	DBGPRINT(DBG_RXDATA, ("Not connected, packet was dropped...\n"));
        	ReturnRxPacketDesc(Adapter,pPacket);
    	}
	
#else

	if (Adapter->MediaConnectStatus == NdisMediaStateConnected)
    	{

///RETAILMSG(1, (TEXT("NdisMEthIndicateReceive  \r\n")));
		
		DBGPRINT(DBG_RXDATA, ("NdisMEthIndicateReceive \n"));

		DBGPRINT(DBG_RXDATA,("Adapter->pRxBuf = %x  Adapter->ulRxSize = %x\n",
		                           (PVOID)(Adapter->pRxBuf), Adapter->ulRxSize));  
		DBGPRINT(DBG_RXDATA,("Adapter->CurrentLookAhead = %x \n",
		                           Adapter->CurrentLookAhead));  
   		///HexDump(DBG_RXDATA , "RX Buffer", Adapter->pRxBuf, Adapter->ulRxSize);

       	if ( Adapter->ulRxSize > Adapter->CurrentLookAhead  + MRVDRV_ETH_HEADER_SIZE )
			ulLookAhead = Adapter->CurrentLookAhead  + MRVDRV_ETH_HEADER_SIZE;
		else
			ulLookAhead = Adapter->ulRxSize;
	
		DBGPRINT(DBG_RXDATA,("ulLookAhead = %x \n", ulLookAhead));  
	
 		// Indicate to wrapper/protocol the received packet.
		if ( ulLookAhead < MRVDRV_ETH_HEADER_SIZE)
		{

///RETAILMSG(1, (TEXT("NdisMEthIndicateReceive  1 \r\n")));

			DBGPRINT(DBG_RXDATA,("NdisMEthIndicateReceive 1 \n")); 
			
			NdisMEthIndicateReceive(
					Adapter->MrvDrvAdapterHdl,
					(NDIS_HANDLE)Adapter,
					(PVOID) (Adapter->pRxBuf ),
					(UINT)  MRVDRV_ETH_HEADER_SIZE,
					NULL,
					0,
					0
					);	
		}
		else
		{

///RETAILMSG(1, (TEXT("NdisMEthIndicateReceive  2 \r\n")));
		
			DBGPRINT(DBG_RXDATA,("NdisMEthIndicateReceive 2 \n")); 
			
			NdisMEthIndicateReceive(
					Adapter->MrvDrvAdapterHdl,
					(NDIS_HANDLE)Adapter,
					(PVOID) (Adapter->pRxBuf ),
					(UINT)  MRVDRV_ETH_HEADER_SIZE,
					(PVOID) (Adapter->pRxBuf + MRVDRV_ETH_HEADER_SIZE),
					(UINT)(ulLookAhead -MRVDRV_ETH_HEADER_SIZE),
					(UINT)(Adapter->ulRxSize - MRVDRV_ETH_HEADER_SIZE)
					);
		}
	
		NdisMEthIndicateReceiveComplete(Adapter->MrvDrvAdapterHdl);
	}
	else
    	{
///RETAILMSG(1, (TEXT("Not connected, packet was dropped  \r\n")));

        	DBGPRINT(DBG_RXDATA, ("Not connected, packet was dropped...\n"));
    	}
	
#endif

	//NdisReleaseSpinLock(&Adapter->RxSpinLock);

	DBGPRINT(DBG_RXDATA,("-HandleRxReadyEvent()\n\n"));	

	return;
}

int ReadRxFrame(
	PMRVDRV_ADAPTER Adapter,
	ULONG *pFrameLen
	)
{
        USHORT		  usRxPacketLength  , usval;
	 PUSHORT         packetPtr;
    	 PCF_OBJECT 	  pCf = Adapter->hwIface;		
	 USHORT 		  packetSizeWords;
	 int 			  ii;
	 BOOLEAN         status = FALSE;
  	
	 Adapter->bIsDoingRx = TRUE;

	 if ( (Adapter->psState == PS_STATE_SLEEP) ||(Adapter->psState == PS_STATE_SLEEP_PENDING))
                goto end1;	
		
        /// check for upload ready
    	 NdisRawReadPortUshort( 
    			pCf->ulMrvDrvVirtualIoBase + CFMACREG_CCR_CARD_STATUS,
    			&usval);

        if (!(usval & CFMACREG_HCR_HIM_RxUpLdRdy))
    	 {	
                DBGPRINT(DBG_ERROR, ("ERROR: Device RX upload ready is not set, nothing to read!\n"));
        	  goto end1;
    	 }

    	 /// read packet length
    	 NdisRawReadPortUshort(
  		 		pCf->ulMrvDrvVirtualIoBase + CFMACREG_CCR_IO_READ_LEN,
				&usRxPacketLength);
	   
    	DBGPRINT(DBG_HWIF,("cf_RxStartPacket: Will transfer %d bytes\n",usRxPacketLength));          

	Adapter->ulRxSize = usRxPacketLength; 

    	if ( usRxPacketLength < (sizeof(RxPD) + 14) ||
	     usRxPacketLength > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE )	                
	{
		DBGPRINT(DBG_ERROR,("RECV Got incorrect packet size (%d). Discarding!\n", usRxPacketLength));
        	goto end;
    	}

       /// Read current block from the device.
    	DBGPRINT(DBG_T2 | DBG_CRLF,("Start RX block\n"));
	  
   	// pCf->ulRxPacketByteCount += Adapter->ulRxSize;

    	// Read RxPD
    	packetPtr = (USHORT *)(&Adapter->RxPD);    
    	packetSizeWords = sizeof(RxPD) >> 1;
    	for ( ii=0; ii < (int)packetSizeWords; ii++ )
    	{
        	NdisRawReadPortUshort(
  			        	pCf->ulMrvDrvVirtualIoBase + CFMACREG_HCR_IO_READ_PORT,
   	           		 	packetPtr);
       	packetPtr++;
    	}	
		
       DBGPRINT(DBG_RXDATA,("Adapter->pRxBuf = %x \n", (PVOID)(Adapter->pRxBuf)));   
 	DBGPRINT(DBG_RXDATA,("sizeof(RxPD) = %x \n",  sizeof(RxPD)));   
	DBGPRINT(DBG_RXDATA,("Adapter->RxPD->PktPtr = %x \n", Adapter->RxPD.PktPtr)); 
	   
    	Adapter->ulRxSize -= sizeof(RxPD);

	// Read the destination and soure addresss of 802.3 frame
	packetPtr = (PUSHORT)Adapter->pRxBuf;
	       
    	packetSizeWords = MRVDRV_ETH_ADDR_LEN*2 >> 1;
    	for ( ii = 0; ii < (int)packetSizeWords; ii++ )
    	{
		NdisRawReadPortUshort(
  				        pCf->ulMrvDrvVirtualIoBase + CFMACREG_HCR_IO_READ_PORT,
   	             			 packetPtr);
        	packetPtr++;
    	}
	
    	// Read LLC header and discard, LLC header is 8 bytes
	packetSizeWords = 8 >> 1;
	for ( ii=0; ii < (int)packetSizeWords; ii++ )
            	{
        	NdisRawReadPortUshort(
  			        	pCf->ulMrvDrvVirtualIoBase + CFMACREG_HCR_IO_READ_PORT,
   	       	     		packetPtr);
		packetPtr++;
            	}
    	//Adapter->ulRxSize -= 8;
       
	// Read the other of 802.3 frame 
	packetSizeWords = (USHORT)(Adapter->ulRxSize+1) / sizeof(USHORT);
    	for( ii = 0; ii < (int)packetSizeWords; ii++ )
            	        {
		NdisRawReadPortUshort(
  				        pCf->ulMrvDrvVirtualIoBase + CFMACREG_HCR_IO_READ_PORT,
   	             			 packetPtr);
        	packetPtr++;
            	        }
	
   	HexDump(DBG_RXDATA | DBG_ALLEN, "RX Buffer_1", Adapter->pRxBuf, Adapter->ulRxSize);
	
       /*
       {     ULONG i;
			
		RETAILMSG(1, (TEXT("RX Buffer_2  \r\n")));	
			
		for (i=0; i<Adapter->ulRxSize; i++)
		{
                     RETAILMSG(1, (TEXT("%02x  "), *(((UCHAR *)(Adapter->pRxBuf))+ i) ));
			if (((i %16) == 0) && i)
				RETAILMSG(1, (TEXT("\r\n")));
			
	       }	
		RETAILMSG(1, (TEXT("\r\n")));		
       }
       */

     	if ((*(Adapter->pRxBuf + 14) == 0xaa) &&
             (*(Adapter->pRxBuf + 15) == 0xaa) &&
             (*(Adapter->pRxBuf + 16) == 0x03) &&
             (*(Adapter->pRxBuf + 20) == 0x88) &&
             (*(Adapter->pRxBuf + 21) == 0x8e) )

	       {
///RETAILMSG(1, (TEXT("Receive EPOL KEY  \r\n")));
		NdisMoveMemory( Adapter->pRxBuf+12, Adapter->pRxBuf+20, Adapter->ulRxSize-20);	
			 Adapter->ulRxSize -= 8;
    	       }
	       /*	
    	       else
    	       {
		        UCHAR c;
		        c = *(Adapter->pRxBuf+12);
		        *(Adapter->pRxBuf+12) = *(Adapter->pRxBuf+13);
		        *(Adapter->pRxBuf+13) = c;
    	       }
	       */
              ///HexDump(DBG_RXDATA | DBG_ALLEN, "RX Buffer_2", Adapter->pRxBuf, Adapter->ulRxSize);

	*pFrameLen = Adapter->ulRxSize;
    	status = TRUE;

end:
	
    	cf_RxEndPacket(pCf);
end1:		
	
	Adapter->bIsDoingRx = FALSE;

	return status;

}	

/******************************************************************************
 *
 *  Name: MrvDrvTransferData()
 *
 *  Description: Transferdata function to complete the Rx operation
 *
 *  Arguments:	
 *    
 *  Return Value:        
 * 
 *  Notes:               
 *
 *****************************************************************************/

NDIS_STATUS
MrvDrvTransferData(
    	OUT PNDIS_PACKET pPacket,
    	OUT PUINT pBytesTransferred,
    	IN NDIS_HANDLE hMiniportAdapterContext,
    	IN NDIS_HANDLE hMiniportReceiveContext,
    	IN UINT ulByteOffset,
    	IN UINT ulBytesToTransfer)
{

	PMRVDRV_ADAPTER	Adapter;
	UINT				nBytesLeft, nBytesNow, nBytesWanted, BufLen;
	PUCHAR				CurCardLoc, BufStart;
	PNDIS_BUFFER		CurBuffer;

	Adapter = (PMRVDRV_ADAPTER)hMiniportAdapterContext;

   	DBGPRINT(DBG_RXDATA, ("+MrvDrvTransferData() \n"));

	DBGPRINT(DBG_RXDATA,("ulByteOffset = %x,  ulBytesToTransfer = %x\n",ulByteOffset, ulBytesToTransfer));     

	DBGPRINT(DBG_RXDATA,("Adapter->pRxBuf = %x \n", (PVOID)(Adapter->pRxBuf)));     

       ulByteOffset += MRVDRV_ETH_HEADER_SIZE; 
 
	// See how much data there is to transfer.
	if ((ulByteOffset + ulBytesToTransfer) > Adapter->ulRxSize) 
	{
		if (Adapter->ulRxSize < ulByteOffset) 
		{
			*pBytesTransferred = 0;
			return NDIS_STATUS_FAILURE;
		} 
		nBytesWanted = Adapter->ulRxSize - ulByteOffset;
		DBGPRINT(DBG_RXDATA,("@@@@ \n"));   
	} 
	else
	{
		nBytesWanted = ulBytesToTransfer;
		DBGPRINT(DBG_RXDATA,("#### \n")); 
	}

	DBGPRINT(DBG_RXDATA,("ulByteOffset = %x,  nBytesWanted = %x\n",ulByteOffset, nBytesWanted));     

	// Set the number of bytes left to transfer
	nBytesLeft = nBytesWanted;

	// Copy data from the Adapter->pRxBuf to the Packet structure.
	CurCardLoc = (PUCHAR)(Adapter->pRxBuf);
	CurCardLoc += ulByteOffset;

	// Get location to copy into.
	NdisQueryPacket(pPacket, NULL, NULL, &CurBuffer, NULL);
	NdisQueryBufferSafe(CurBuffer, (PVOID *)&BufStart, &BufLen,NormalPagePriority);

	while (nBytesLeft > 0) 
	{
		if (BufLen > nBytesLeft) 
		{
			nBytesNow = nBytesLeft;
		} 
		else 
		{
			nBytesNow = BufLen;
		} 

		NdisMoveMemory((PVOID)BufStart, (PVOID)CurCardLoc, (ULONG)nBytesNow);

		CurCardLoc += nBytesNow;
		nBytesLeft -= nBytesNow;

		if (nBytesLeft == 0) 
		{
			break;
		} 

		// Set up next buffer.
		NdisGetNextBuffer(CurBuffer, &CurBuffer);
		if (CurBuffer == (PNDIS_BUFFER)NULL) 
		{
			break;
		} 
		NdisQueryBufferSafe(CurBuffer, (PVOID *)&BufStart, &BufLen, NormalPagePriority);

    	} 

	*pBytesTransferred = nBytesWanted - nBytesLeft;

	DBGPRINT(DBG_RXDATA,("*pBytesTransferred = %x \n",*pBytesTransferred));     
	
	// if ( Adapter->EnableQOS )
	// {
	// 	 PRxPD			pRxPD = (PRxPD)Adapter->pRxBuf;
	//	 ULONG			RxPriority;
	//
	//	 // Bits 7:4 is the tag
	//	 RxPriority = (pRxPD->Status >> 4) & 0xF;
	//
	//	 NDIS_PER_PACKET_INFO_FROM_PACKET(pPacket, Ieee8021pPriority) = (PVOID)RxPriority;
	// }
	
	NDIS_SET_PACKET_STATUS(pPacket, NDIS_STATUS_SUCCESS);
	
	return NDIS_STATUS_SUCCESS;
}