vdevadap.cpp

驱动设计文档

				for(UINT itmp = 0;itmp < size; itmp ++)
					T.Trace("[%02x]",Buffer[itmp]);
			}

		} else {
			T.Trace("VdevAdapter::Send Buffer is NULL !\n");
		}
		
		buf = buf.GetNext();
		if (buf == NULL){
			T.Trace("VdevAdapter::Send GetNext is NULL !\n");
			break;
		}
	}
	// TODO:	Manage the packet into the hardware. 
	// Return NDIS_STATUS_SUCCESS if the packet got submitted to the h/w and 
	// NDIS_STATUS_PENDING if it's been queued into m_TxQueue.
	//

	m_GenStats->xmit_ok++;
//	RWBufMutex.Release();

	return NDIS_STATUS_SUCCESS;
#endif
}

NTSTATUS  VdevAdapter::IoRead (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
	NTSTATUS Status = STATUS_SUCCESS;
	KIrp	I(Irp);

//	RWBufMutex.Wait();

	if (NicSendDataBufLength > 0)
	{
		if (I.BufferedReadDest() == NULL)
		{
			T.Trace("VdevAdapter::IoRead UserBuffer!\n");
			memcpy((PUCHAR)I.UserBuffer(),NicSendDataBuf,NicSendDataBufLength);
		}
		else
		{
			T.Trace("VdevAdapter::IoRead BufferedReadDest !\n");
			memcpy((PUCHAR)I.BufferedReadDest(),NicSendDataBuf,NicSendDataBufLength);
		}

		T.Trace("VdevAdapter::IoRead Size [%d]\n", NicSendDataBufLength);
	}
//	I.UserReadBuffer();

//	T.Trace("VdevAdapter::IoRead Size [%d]\n", I.ReadSize());
	
	I.Information() = NicSendDataBufLength;

	NicSendDataBufLength = 0;

//	RWBufMutex.Release();
	
	return I.Complete(Status);	
}
////////////////////////////////////////////////////////////////////
// VdevAdapter::ReturnPacket
//
// This method is called when NDIS returns a packet previuosly
// indicated by IndicateReceive() back to the miniport
//
// Parameters:
//		Packet 
//			Points to a packet descriptor specifying the packet 
// IRQL: 
//		DISPATCH_LEVEL
// Return Mode:
//		n/a
// NOTE:
//		The packet returns to the "free list" in the Rx area. 
//		Reclaim() does the necessary reset of the chained buffer
//		and OOB data if any.
VOID VdevAdapter::ReturnPacket(IN PNDIS_PACKET Packet)
{
	T.Trace("VdevAdapter::ReturnPacket() Entered \n");
	T << Packet;
#if 1
	// declare for convenience
//	KNdisPacket pkt(Packet);

	NDIS_STATUS status = NDIS_GET_PACKET_STATUS(Packet);
	
	if(status == NDIS_STATUS_SUCCESS)
	{
			T.Trace("VdevAdapter::Write GetNext ReturnPacket is NDIS_STATUS_SUCCESS!\n");
	}
	else if(status == NDIS_STATUS_PENDING)
	{
		T.Trace("VdevAdapter::Write GetNext ReturnPacket is NDIS_STATUS_PENDING!\n");
		
/*
				TRACE("status=%s","NDIS_STATUS_PENDING");
				NdisUnchainBufferAtFront(Packet,&ndisBuffer);
				if(ndisBuffer)
					NdisFreeBuffer(ndisBuffer);
				NdisReinitializePacket(Packet);*/
		
	}
	else
		T.Trace("VdevAdapter::Write GetNext ReturnPacket is NDIS_STATUS_RESOURCES!\n");
	
// 		TRACE("status=%s","NDIS_STATUS_RESOURCES");
	
	
// 	NdisUnchainBufferAtFront(m_OurPacket,&m_OurBuffer);
//	if(m_OurBuffer)
//		NdisFreeBuffer(m_OurBuffer);
	NdisFreePacket(Packet);
	// TODO:	Reclaim the packet back to an internal list
	//
#endif
}

////////////////////////////////////////////////////////////////////
// VdevAdapter::CheckForHang
//		Optional function that reports the state of the NIC or monitors
//		 the responsiveness of an underlying device driver.
// Parameters:
//		none
// IRQL: 
//		IRQL DISPATCH_LEVEL
// Return Mode:
//		Synchronous
// NOTE:
//		By default, the NDIS library calls MiniportCheckForHang 
//		approximately every two seconds. If MiniportCheckForHang returns
//		TRUE, NDIS then calls the driver's MiniportReset function. 
BOOLEAN VdevAdapter::CheckForHang()
{
	// TODO:	Check the h/w for hang
	return FALSE;
}

	

/////////////////////////
// I/O Dispatching
NTSTATUS VdevAdapter::IoDispatch (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
	NTSTATUS Status = STATUS_SUCCESS;
	KIrp	I(Irp);

	T.Trace("VdevAdapter::IoDispatch func 0x%02x \n", I.MajorFunction());

	switch (I.MajorFunction()) {
    case IRP_MJ_CREATE:			// TODO
    case IRP_MJ_CLOSE:			// TODO
    case IRP_MJ_CLEANUP:		// TODO
    case IRP_MJ_READ:			// TODO		
    case IRP_MJ_WRITE:			// TODO
    case IRP_MJ_DEVICE_CONTROL: // TODO
			I.Information() = 0;
			break;
	default: 
		Status = STATUS_UNSUCCESSFUL;

	};

	return I.Complete(Status);
}
NTSTATUS VdevAdapter::IoCreate (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
	NTSTATUS Status = STATUS_SUCCESS;
	KIrp	I(Irp);	
	
	DeviceObject->Flags |= DO_BUFFERED_IO;	
	//LsaNtStatusToWinError
	
	return I.Complete(Status);
}

NTSTATUS VdevAdapter::IoClose (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
	NTSTATUS Status = STATUS_SUCCESS;
	KIrp	I(Irp);	

	return I.Complete(Status);
}

NTSTATUS VdevAdapter::IoCleanup(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
	NTSTATUS Status = STATUS_SUCCESS;
	KIrp	I(Irp);	
	
	return I.Complete(Status);
}

#define SENDLENGTH 	56
UCHAR pWriteBuf[SENDLENGTH] = {
		0x00,0x11,0x22,0x33,0x44,0x55,
		0x00,0x07,0x95,0xa5,0x34,0x0f,
		0x00,0x28,
		0xff,0xff,
		0x00,0x27,
		0x00,0x00,
		
		0x00,0x00,0x00,0x10,
		0x00,0x11,0x22,0x33,0x44,0x55,
		0x0e,0x22,
		
		0x00,0x00,0x00,0x10,
		0x00,0x07,0x95,0xa5,0x34,0x0f,
		0x0e,0x22,
		
		0x39,0x38,0x37,0x36,0x35,0x34,0x33,0x32,0x31,
		
		0xb1,0x00,0x00
};

NTSTATUS VdevAdapter::IoWrite(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
	NTSTATUS Status = STATUS_SUCCESS;
	KIrp	I(Irp);	

	PNDIS_PACKET pNdisPacket;
	NDIS_STATUS	NStatus;

	PNDIS_BUFFER	pNdisDataBuffer;

	PVOID	pWBuf,pDataBuf;
	UINT uiBufLen;


	if (pphflag == -1)
	{
		I.Information() = -9;
		return I.Complete(Status);
	}
	if (bphflag == -1)
	{
		I.Information() = -8;
		return I.Complete(Status);
	}
//PVOID& 
	pWBuf = &(I.BufferedWriteSource());
	uiBufLen = I.WriteSize() ;
	if (uiBufLen <= 0)
	{
		I.Information() = 0;
		return I.Complete(Status);			
	}

	pDataBuf = ExAllocatePool(PagedPool,uiBufLen);
	if (pDataBuf == NULL)
	{
		I.Information() = -1;
		return I.Complete(Status);
	}

	memset(pDataBuf,0,uiBufLen);
	if (I.BufferedWriteSource() != NULL)
		memcpy(pDataBuf,I.BufferedWriteSource(),uiBufLen);
	else
		T.Trace("VdevAdapter::Write I.BufferedWriteSource() == NULL \n");
//		memcpy(pDataBuf,pWBuf,uiBufLen);
	
	NdisAllocatePacket(&NStatus,&pNdisPacket,PacketPoolHandle);
	if( NStatus != NDIS_STATUS_SUCCESS ) 
	{
		I.Information() = -2;
		return I.Complete(Status);
	} 
	else
	{
		I.Information() = 1;
	}

	NdisAllocateBuffer(&NStatus,&pNdisDataBuffer,BufferPoolHandle,pDataBuf,uiBufLen);
	if( NStatus != NDIS_STATUS_SUCCESS ) 
	{
		I.Information() = -3;
		return I.Complete(Status);
	} 
	else
	{
		I.Information() = 1;
	}


	NdisChainBufferAtFront(pNdisPacket, pNdisDataBuffer);
	
	NDIS_SET_PACKET_HEADER_SIZE(pNdisPacket,14);
//	NDIS_SET_PACKET_STATUS(pNdisPacket,NDIS_STATUS_RESOURCES);

#if 0
	KNdisPacket pkt(pNdisPacket);
	KNdisBuffer buf;
	UINT size;
	PUCHAR Buffer;
	
	buf = pkt.QueryFirstBuffer();
	T.Trace("VdevAdapter::Write  Start Display packet info! \n");
	while(buf.IsValid())
	{
		
		size = buf.Length();
		T.Trace("VdevAdapter::Write size is [%ud]\n",size);
		
		Buffer = (PUCHAR)buf.Address();
		if (Buffer != NULL) {
			if (size > 1){
				for(UINT itmp = 0;itmp < size; itmp ++)
					T.Trace("[%02x]",Buffer[itmp]);
			}
		} else {
			T.Trace("VdevAdapter::Write Buffer is NULL !\n");
		}
		
		buf = buf.GetNext();
		if (buf == NULL){
			T.Trace("VdevAdapter::Write GetNext is NULL !\n");
			break;
		}
	}
#endif 

	pThisVdevAdapter->IndicateReceive(pNdisPacket);
	pThisVdevAdapter->m_GenStats->rcv_ok ++;	
	
	NDIS_STATUS status = NDIS_GET_PACKET_STATUS(pNdisPacket);
	
	if(status != NDIS_STATUS_PENDING)
	{

		NdisUnchainBufferAtFront(pNdisPacket,&pNdisDataBuffer);
		NdisFreeBuffer(pNdisDataBuffer);
		NdisFreePacket(pNdisPacket);

		I.Information() = uiBufLen;

		if(Status == NDIS_STATUS_SUCCESS) {
			T.Trace("VdevAdapter::Write Status == NDIS_STATUS_SUCCESS!\n");
		} else {
			T.Trace("VdevAdapter::Write Status != NDIS_STATUS_SUCCESS!\n");
		}
		
		return I.Complete(Status);
	}

	T.Trace("VdevAdapter::Write Status == NDIS_STATUS_PENDING!\n");
	I.Information() = -4;
	
	ExFreePool(pDataBuf);

	return I.Complete(Status);
}

NDIS_STATUS VdevAdapter::TransferData(
										OUT PNDIS_PACKET			Packet,
										OUT PUINT					BytesTransferred,
										IN  PVOID					Lookahead, /* MiniportReceiveContext */
										IN	UINT					ByteOffset,
										IN	UINT					BytesToTransfer)
{
	T.Trace("VdevAdapter::Write TransferData!\n");
	
	return NDIS_STATUS_SUCCESS;
}
// end of file




















// end of file