hostmini.c

三星2410的BSP开发包

            GenericUlong = RNDIS_MAX_PACKETS_PER_MESSAGE;             
            break;
		
		////////////////////////////////////////////////////////////////

        case OID_GEN_XMIT_OK:
//			CELOGMSG (0,
//				(TEXT("OID_GEN_XMIT_OK returning [%d]\r\n"),
//				RndisMdd.dwTransmitOkay));

            GenericUlong = RndisMdd.dwTransmitOkay;
            break;

        ////////////////////////////////////////////////////////////////

        case OID_GEN_RCV_OK:
//			CELOGMSG (0,
//				(TEXT("OID_GEN_RCV_OK returning [%d]\r\n"),
//				RndisMdd.dwReceiveOkay));
            GenericUlong = RndisMdd.dwReceiveOkay;
            break;

        ////////////////////////////////////////////////////////////////

        case OID_GEN_XMIT_ERROR:                    
//			CELOGMSG (0,
//				(TEXT("OID_GEN_XMIT_ERROR returning [%d]\r\n"),
//				RndisMdd.dwTransmitError));
            GenericUlong = RndisMdd.dwTransmitError;
            break;

        ////////////////////////////////////////////////////////////////

        case OID_GEN_RCV_ERROR:                 
//			CELOGMSG (0,
//				(TEXT("OID_GEN_RCV_ERROR returning [%d]\r\n"),
//				RndisMdd.dwReceiveError));
            GenericUlong = RndisMdd.dwReceiveError;
            break;

        ////////////////////////////////////////////////////////////////

        case OID_GEN_RCV_NO_BUFFER:                 
//			CELOGMSG (0,
//				(TEXT("OID_GEN_RCV_NO_BUFFER returning [%d]\r\n"),
//				RndisMdd.dwReceiveNoBuffer));
            GenericUlong = RndisMdd.dwReceiveNoBuffer;
            break;


		////////////////////////////////////////////////////////////////

        case OID_GEN_RCV_CRC_ERROR:                 
//			CELOGMSG (0,
//				(TEXT("OID_GEN_RCV_CRC_ERROR returning [%d]\r\n"),
//				0x00));
            GenericUlong = 0x00;
            break;
		
		////////////////////////////////////////////////////////////////////////
		
		default:
    		EdbgOutputDebugString("OID[%x] not yet implemented!\r\n", Oid);			

//			CELOGMSG (ZONE_HOSTMINI,
//				(TEXT("OID[%x] not yet implemented!\r\n"), 
//				Oid));			

			NdisStatus = NDIS_STATUS_INVALID_OID;
			break;
	
	}	//	switch()


	//
    //  Everyone gets here...
    //  
    
	if (NdisStatus == NDIS_STATUS_SUCCESS) 
    {
//		CELOGMSG (0, (TEXT("ulTotalBytes = [%d]\r\n"),
//			ulTotalBytes));

        if (ulTotalBytes > ulInformationBufferLength) 
        {
            //
            //  Not enough room in pvInformationBuffer. Punt
            //          

//			CELOGMSG (0, 
//				(TEXT("HostMini:: Small InBuff [%d]bytes, need [%d]\r\n"),
//				ulInformationBufferLength,
//				ulTotalBytes));

            *pulBytesNeeded = ulTotalBytes;
            NdisStatus = NDIS_STATUS_INVALID_LENGTH;
        } 
        else 
        {
            //
            //  Store result.
            //			

            memcpy(
				pvInformationBuffer, 
				pucBuffer, 
				ulTotalBytes);

            *pulBytesWritten = ulTotalBytes;         
        }   
    }
    
//    CELOGMSG (0, 
//		(TEXT("HostMini:: QueryInformation returning: %s\r\n"),
//        NdisStatus ? TEXT("Error") : TEXT("Success")));
    
    return NdisStatus;  

}	// HostMiniQueryInformation()



////////////////////////////////////////////////////////////////////////////////
//  HostMiniSetInformation()
//
//	Routine Description:
//
//  Handles a set operation for a single Oid
//
//  Arguments:
//      Oid							-  The OID of the set.
//      pvInformationBuffer			-  Holds the data to be set.
//      ulInformationBufferLength	-  The length of pvInformationBuffer.
//      pulBytesRead                -  If the call is successful, returns the number
//                                      of bytes read from pvInformationBuffer.
//      pulBytesNeeded				-  If there is not enough data in 
//                                      pvInformationBuffer to satisfy the OID, 
//                                      returns the amount of storage needed.
//
//  Return Value:
//
//  -   NDIS_STATUS_SUCCESS
//  -   NDIS_STATUS_PENDING
//  -   NDIS_STATUS_INVALID_LENGTH
//  -   NDIS_STATUS_INVALID_OID
//
//
NDIS_STATUS
HostMiniSetInformation(
   IN   NDIS_OID    Oid,
   IN   PVOID       pvInformationBuffer,
   IN   ULONG       ulInformationBufferLength,
   OUT  PULONG      pulBytesRead,
   OUT  PULONG      pulBytesNeeded
   )
{    
    PUCHAR          InfoBuffer      = (PUCHAR)pvInformationBuffer;    
	DWORD			dwFilter;

//	CELOGMSG (0, (TEXT("HostMini:: SetInformation():: ")));

    //
    //  Check for the most common OIDs
    //
    
	switch (Oid) 
    { 
		////////////////////////////////////////////////////////////////////////

        case OID_802_3_MULTICAST_LIST:                                      
//			CELOGMSG (0, 
//				(TEXT("OID_802_3_MULTICAST_LIST.\r\n")));

			*pulBytesRead = ulInformationBufferLength;
			*pulBytesNeeded = 0;
			
			if ((ulInformationBufferLength % 6) != 0)
				return NDIS_STATUS_INVALID_LENGTH;			

			if ((ulInformationBufferLength / 6) > DEFAULT_MULTICASTLIST_MAX)
				return NDIS_STATUS_MULTICAST_FULL;
			
			memcpy(
				&(RndisMdd.MulticastAddresses),
				pvInformationBuffer, 
				ulInformationBufferLength);

			RndisMdd.dwMulticastListInUse = ulInformationBufferLength / 6;

			//
			//	[stjong] VEHub interface
			//	Do something here to inform VEHub that we are listening to the
			//	new set of multicast addresses..
			//
			return NDIS_STATUS_SUCCESS;
            break;
        
		////////////////////////////////////////////////////////////////////////

        case OID_GEN_CURRENT_PACKET_FILTER:
 //           CELOGMSG (0, 
//				(TEXT("OID_GEN_CURRENT_PACKET_FILTER.\r\n")));

			*pulBytesRead	= ulInformationBufferLength;
            *pulBytesNeeded = 0;

			if (ulInformationBufferLength != 4 ) 
				return NDIS_STATUS_INVALID_LENGTH;                        
        
			memcpy (&dwFilter, pvInformationBuffer, 4);
        
			//
			//	Reject types we don't support..
			//

			if (dwFilter & 
				 (NDIS_PACKET_TYPE_SOURCE_ROUTING	|
				  NDIS_PACKET_TYPE_SMT				|
				  NDIS_PACKET_TYPE_MAC_FRAME		|
				  NDIS_PACKET_TYPE_FUNCTIONAL		|
				  NDIS_PACKET_TYPE_ALL_FUNCTIONAL	|
				  NDIS_PACKET_TYPE_GROUP)) 
			{
				return NDIS_STATUS_NOT_SUPPORTED;				
			}			

			EdbgOutputDebugString("HostMini:: New filter set: [0x%x] --> [0x%x]\r\n",
				RndisMdd.dwCurrentPacketFilter,
				dwFilter);

			//
			//	Hence we support:
			//	DIRECTED, MULTICAST, ALL_MULTICAST, BROADCAST, 
			//	Set the new value on the adapter..
			//
			
			RndisMdd.dwCurrentPacketFilter = dwFilter;

			if (dwFilter)							
				RndisMdd.dwDeviceState = RNDIS_INITIALIZED;							
			else			
				RndisMdd.dwDeviceState = RNDIS_DATA_INITIALIZED;

			return NDIS_STATUS_SUCCESS;
            break;

        
        ////////////////////////////////////////////////////////////////////////

        case OID_GEN_CURRENT_LOOKAHEAD:
            
			//
            //  No need to record requested lookahead length since we
            //  always indicate the whole packet.
            //
//            CELOGMSG (0, 
//				(TEXT("HostMini:: OID_GEN_CURRENT_LOOKAHEAD...\r\n")));            
            *pulBytesRead = 4;
            break;


        ////////////////////////////////////////////////////////////////////////

        default:
//            CELOGMSG(
//				0, (TEXT("HostMini:: Default...returning INVALID\r\n")));
            *pulBytesRead = 0;
            *pulBytesNeeded = 0;
            return NDIS_STATUS_INVALID_OID;
    }
    
    return NDIS_STATUS_SUCCESS;

}   //  HostMiniSetInformation()



//
//	Functions below are exported to PDD..
//


////////////////////////////////////////////////////////////////////////////////
//	MddIndicateRndisMessage()
//	
//	Routine Description:
//
//		This routine is called by PDD when it has received one complete RNDIS
//		message.   We process it immediately and generate a reply if necessary.
//	
//	Arguments:
//
//		None.
//
//	Return Value:
//
//		None. [PDD does not need to care whether or not data is valid.]
//		
//	Note:
//		
//		This function will not retain PDD buffer.
//
void
MddIndicateRndisMessage(PDATA_WRAPPER pDataWrapper)	
{
//	CELOGMSG (0,
//		(TEXT("HostMini:: Rndis message received; [%d] bytes.\r\n"),
//		pDataWrapper->dwDataSize));

	RndisProcessMessage(pDataWrapper);
	
	return;

}	// MddIndicateRndisMessage()


////////////////////////////////////////////////////////////////////////////////
//	MddSendRndisMessageComplete()
//	
//	Routine Description:
//
//		This routine is called by PDD when it has completed 
//		sending one RNDIS message.
//	
//	Arguments:
//
//		pDataWrapper :: structure containing the data..
//
//	Return Value:
//
//		None. [PDD does not need to care whether or not data is valid.]
//		
//	Note:
//		
//		This function will not retain PDD buffer.
//
static BOOL RdisPacketBufferEmpty=TRUE;
static DATA_WRAPPER RndisPacketRapper;
static BYTE RdisPacketBuffer[MAX_PACKET_SIZE];

////////////////////////////////////////////////////////////////////////////////
//	MddIndicateRndisPacket()
//	
//	Routine Description:
//
//		This routine is called by PDD when it has completed 
//		sending one RNDIS message.
//	
//	Arguments:
//
//		pDataWrapper  :: The structure containing RNDIS_PACKET
//
//	Return Value:
//
//		None. [PDD does not need to care whether or not data is valid.]
//		
//	Note:
//		
//		This function ** MUST ** retain PDD buffer to be returned in
//		PDD's IndicateRndisPacketCompleteHandler()
//
void
MddIndicateRndisPacket(PDATA_WRAPPER	pDataWrapper)
{
/*	CELOGMSG (0,
		(TEXT("HostMini:: Rndis message received; [%d] bytes.\r\n"),
		pDataWrapper->dwDataSize));
	
	//
	//	Queue it..
	//	

	CELOGMSG (0, 
		(TEXT("HostMini:: Q-Pkt: Wrap[0x%x] Buf[0x%x]\r\n"),		
		pDataWrapper,
		pDataWrapper->pucData));

	EnterCriticalSection(&(RndisMdd.lockInRndisPackets));
		InsertTailList(
			&(RndisMdd.listInRndisPackets),
			&(pDataWrapper->Link));
	LeaveCriticalSection(&(RndisMdd.lockInRndisPackets));


	//
	//	Trigger the worker thread if it is not already working..
	//
	
	EnterCriticalSection(&(RndisMdd.lockMdd));
		if (RndisMdd.dwMddFlag & MDD_FLAG_WAITING)
			SetEvent(RndisMdd.hRndisMddEvent);
	LeaveCriticalSection(&(RndisMdd.lockMdd));
*/
	RndisProcessPacket(pDataWrapper);
	RdisPacketBufferEmpty=TRUE;
	return;

}	//	MddIndicateRndisPacket()

// Define for new PDD
PDATA_WRAPPER MDDAllocDataWrapper()
{
	if (RdisPacketBufferEmpty) {
		RdisPacketBufferEmpty=FALSE;
		return &RndisPacketRapper;
	}
	else {
		ASSERT(FALSE);
		return NULL;
	};

}
PBYTE MDDAllocMem(void)
{
	return (PBYTE)RdisPacketBuffer;
}
void MDDFreeMem(PBYTE pDataBuffer)
{

};
void MDDFreeDataWrapper(PDATA_WRAPPER pDataWrapper)
{
	RdisPacketBufferEmpty=TRUE;
};


////////////////////////////////////////////////////////////////////////////////
//	MddDisconnect()
//	
//	Routine Description:
//
//		PDD calls this function when it detects hot disconnect.
//		We reset PDD hardware and get back to ready to connect state..
//	
//	Arguments:
//
//		None.
//
//	Return Value:
//
//		None.
//		
void
MddDisconnect(void)
{
	EdbgOutputDebugString("HostMini:: MddDisconnect!!\r\n");
	
	RndisRestart(TRUE);	

}	//	MddDisconnect()



////////////////////////////////////////////////////////////////////////////////
//	HostMiniInit()
//	
//	Routine Description:
//
//		Called during initialization, our one and only chance to initialize..
//	
//	Arguments:
//
//		None.
//
//	Return Value:
//
//		TRUE if successful, FALSE otherwise.
//
BOOL
HostMiniInit( BYTE *pbBaseAddress, DWORD dwMultiplier, USHORT MacAddr[3])
{
	//
	//	Global initialization..
	//
	
/*	InitializeListHead(&RndisMdd.listInRndisPackets);
	InitializeListHead(&RndisMdd.listVMiniNdisPackets);
	
	RndisMdd.hRndisMddEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

	InitializeCriticalSection(&RndisMdd.lockMdd);
	InitializeCriticalSection(&RndisMdd.lockVMiniNdisPackets);

	CELOGMSG (ZONE_MEM, (TEXT("LookAside for DATA_WRAPPER:\r\n")));

	ExInitializeNPagedLookasideList(
        &DataWrapperLookAsideList,
        NULL,
        NULL,
        0,
        sizeof(DATA_WRAPPER),
        MEM_TAG_DATA_WRAPPER,
        DATA_WRAPPER_LOOKASIDE_DEPTH
        );

*/
	EdbgOutputDebugString("HostMiniInit:: !!\r\n");
	//
	//	Let RNDIS message handling engine init.
	//
	if (!RndisInit( pbBaseAddress,dwMultiplier,MacAddr))
	{
//		CloseHandle(RndisMdd.hRndisMddEvent);
		return FALSE;
	}	
	
	
	//
	//	Everything is fine, fire our worker thread that services h/w.	
	//
	
/*	CreateThread(0,
		 0,
		 (LPTHREAD_START_ROUTINE)HostMiniThread,
		 NULL,
		 0,											
		 NULL );
*/
	return TRUE;
	
}	//	HostMiniInit()



////////////////////////////////////////////////////////////////////////////////
//	HostMiniDeInit()
//	
//	Routine Description:
//
//		Reverse what's done in HostMiniInit()
//	
//	Arguments:
//
//		None.
//
//	Return Value:
//
//		None.
//
void
HostMiniDeInit(void)
{
	RndisMdd.bQuitNow = TRUE;

//	SetEvent(RndisMdd.hRndisMddEvent);

	RndisDeInit();	

//	ExDeleteNPagedLookasideList(&DataWrapperLookAsideList);

}	//	HostMiniDeInit()