smsc9118.c

SMSC9118网卡驱动

   	pAdapter->ulMaxLookAhead = (ULONG)MAX_LOOKAHEAD;

	//Read flow control flag.
	NdisReadConfiguration(
		&Status,
		&ReturnedValue,
		hConfigHandle,
		&FlowControl,
		NdisParameterHexInteger);

	if (Status == NDIS_STATUS_SUCCESS) 
	{
		if (ReturnedValue->ParameterData.IntegerData == 1UL) {
			pAdapter->fSwFlowControlEnabled = (BOOLEAN)TRUE;
		}
		else {
			pAdapter->fSwFlowControlEnabled = (BOOLEAN)FALSE;
		}
	}
	else
	{
		pAdapter->fSwFlowControlEnabled = (BOOLEAN)TRUE; //Defaultly set the flow control on.
	}

	//Read the LinkMode
	NdisReadConfiguration(
		&Status,
		&ReturnedValue,
		hConfigHandle,
		&LinkMode,
		NdisParameterHexInteger);

	if (Status == NDIS_STATUS_SUCCESS) {
		pAdapter->LinkMode = (ReturnedValue->ParameterData.IntegerData);
	}
	else {
		pAdapter->LinkMode = LINKMODE_DEFAULT;
	}

	//Read Rx DMA mode.
	NdisReadConfiguration(
		&Status,
		&ReturnedValue,
		hConfigHandle,
		&RxDMAMode,
		NdisParameterHexInteger);

	if (Status == NDIS_STATUS_SUCCESS) 
	{
		pAdapter->fRxDMAMode = (ReturnedValue->ParameterData.IntegerData);
	}
	else
	{
		pAdapter->fRxDMAMode = 0UL;
	}

	//Read Tx DMA mode.
	NdisReadConfiguration(
		&Status,
		&ReturnedValue,
		hConfigHandle,
		&TxDMAMode,
		NdisParameterHexInteger);

	if (Status == NDIS_STATUS_SUCCESS) 
	{
		pAdapter->fTxDMAMode = (ReturnedValue->ParameterData.IntegerData);
	}
	else
	{
		pAdapter->fTxDMAMode = 0UL;
	}

	//Display Tx/Rx modes
	if (pAdapter->fRxDMAMode)
	{
		RETAILMSG(1, (TEXT("Rx DMA\r\n")));
	}
	else 
	{
		RETAILMSG(1, (TEXT("Rx PIO\r\n")));
	}

	if (pAdapter->fTxDMAMode)
	{
		RETAILMSG(1, (TEXT("Tx DMA\r\n")));
	}
	else
	{
		RETAILMSG(1, (TEXT("Tx PIO\r\n")));
	}

	//Read I/O address of 9118.
	NdisReadConfiguration(
		&Status,
		&ReturnedValue,
		hConfigHandle,
		&IOAddressStr,
		NdisParameterHexInteger);

	if (Status == NDIS_STATUS_SUCCESS)
	{
		pAdapter->ulIoBaseAddress= (ReturnedValue->ParameterData.IntegerData);

		NdisReadConfiguration(
			&Status,
			&ReturnedValue,
			hConfigHandle,
			&PhyAddressStr,
			NdisParameterHexInteger);
		
		if (Status == NDIS_STATUS_SUCCESS)
		{
			pAdapter->PhyAddress= (BYTE)(ReturnedValue->ParameterData.IntegerData);
			
			NdisReadConfiguration(
				&Status,
				&ReturnedValue,
				hConfigHandle,
				&InterruptStr,
				NdisParameterInteger);

			if (Status == NDIS_STATUS_SUCCESS)
			{
				pAdapter->ucInterruptNumber = (UCHAR)(ReturnedValue->ParameterData.IntegerData);
			}
		}

	}

	// if any of above three "if" are failed..
	if (Status != NDIS_STATUS_SUCCESS)
	{
		NdisFreeMemory(pAdapter, (UINT)sizeof(SMSC9118_ADAPTER), NDIS_ALLOC_FLAG);
		SMSC_TRACE1(DBG_INIT,"  NdisReadConfiguration failed 0x%x\r\n", Status);
		return NDIS_STATUS_RESOURCES;
	}

	SMSC_TRACE3(DBG_INIT,"  PhyAddress=0x%lx, IoBaseAddress=0x%lx, Interrupt=0x%lx\r\n", 
							pAdapter->PhyAddress,
							pAdapter->ulIoBaseAddress,
							pAdapter->ucInterruptNumber);

	SMSC_TRACE2(DBG_INIT,"  RxDMAMode=0x%lx, TxDMAMode=0x%lx\r\n", 
							pAdapter->fRxDMAMode,
							pAdapter->fTxDMAMode);
	NdisCloseConfiguration (hConfigHandle);
	pAdapter->hMiniportAdapterHandle = hMiniportAdapterHandle;

	pAdapter->lan9118_data.dwLanBase = (DWORD)VirtualAlloc((PVOID)0, 
														   (DWORD)REGISTER_PAGE_SIZE, 
														   (DWORD)MEM_RESERVE, 
														   (DWORD)PAGE_NOACCESS);
	if ((PVOID)(pAdapter->lan9118_data.dwLanBase)==NULL)
	{
		SMSC_TRACE0(DBG_INIT,"VirtualAlloc failed.\r\n");
		return NDIS_STATUS_RESOURCES;
	}
	else {
		SMSC_TRACE1(DBG_INIT,"VirtualAlloc at 0x%x.\r\n", pAdapter->lan9118_data.dwLanBase);   
	}

	SMSC_TRACE1(DBG_INIT,"ulIoBaseAddress = 0x%x.\r\n", pAdapter->ulIoBaseAddress);
	bResult= VirtualCopy((PVOID)pAdapter->lan9118_data.dwLanBase,
						 (PVOID)(pAdapter->ulIoBaseAddress >> 8),
						 (DWORD)REGISTER_PAGE_SIZE,
						 (DWORD)(PAGE_READWRITE|PAGE_NOCACHE|PAGE_PHYSICAL));
	if (bResult == TRUE)
	{
		if (!ChipIdentify(pAdapter))
		{
			SMSC_WARNING0("  ChipIdentify -- Failure\r\n");
			return NDIS_STATUS_ADAPTER_NOT_FOUND;
		}
	}
	else
	{
		SMSC_WARNING0("VirtualCopy ETHERNET_BASE failed\r\n");
		if (pAdapter->lan9118_data.dwLanBase)
		{
			bResult = VirtualFree((PVOID)pAdapter->lan9118_data.dwLanBase, 0UL, (DWORD)MEM_RELEASE);
			pAdapter->lan9118_data.dwLanBase = 0UL;
		}
		return NDIS_STATUS_RESOURCES;
	}

	if (RegisterAdapter(pAdapter, hConfigurationHandle) != NDIS_STATUS_SUCCESS)
	{
		// Free VA for 9118
		if (pAdapter->lan9118_data.dwLanBase)
		{
			bResult = VirtualFree((PVOID)(pAdapter->lan9118_data.dwLanBase - (pAdapter->ulIoBaseAddress & (((DWORD)PAGE_SIZE)-1UL))), 0UL, (DWORD)MEM_RELEASE);
			pAdapter->lan9118_data.dwLanBase = (DWORD)NULL;
		}
		// Free pAdapter.
		NdisFreeMemory(pAdapter, (UINT)sizeof(SMSC9118_ADAPTER), NDIS_ALLOC_FLAG);
		SMSC_WARNING0("  RegisterAdapter failed.\r\n");
		return (NDIS_STATUS_FAILURE);
	}

	//
	// Mapping DMA registers. 
	//
	if (pAdapter->fRxDMAMode || pAdapter->fTxDMAMode)
	{
		// REGISTER_PAGE_SIZE is changed to DMAC_REGSIZE
		pAdapter->DMABaseVA = (DWORD)VirtualAlloc ((PVOID)0, 
												   (DWORD)DMAC_REGSIZE, 
												   (DWORD)MEM_RESERVE, 
												   (DWORD)PAGE_NOACCESS);

		if ((PVOID)(pAdapter->DMABaseVA)==NULL)
		{
			// Free VA for 9118
			if (pAdapter->lan9118_data.dwLanBase)
			{
				bResult = VirtualFree ((PVOID)(pAdapter->lan9118_data.dwLanBase - (pAdapter->ulIoBaseAddress & (((DWORD)PAGE_SIZE)-1UL))), 0UL, (DWORD)MEM_RELEASE);
				pAdapter->lan9118_data.dwLanBase = (DWORD)NULL;
			}
			// Free pAdapter.
			NdisFreeMemory(pAdapter, (UINT)sizeof(SMSC9118_ADAPTER), NDIS_ALLOC_FLAG);
			SMSC_TRACE0(DBG_DMA,"DMA VirtualAlloc failed.\r\n");
			return (NDIS_STATUS_FAILURE);
		}
		else
		{
			SMSC_TRACE1(DBG_DMA,"DMA VirtualAlloc OK. pAdapter->DMABaseVA = 0x%x\r\n", pAdapter->DMABaseVA);
		}

		bResult= VirtualCopy ((PVOID)(pAdapter->DMABaseVA),
							  (PVOID)(DMAC_REGBASE >> 8),
							  (DWORD)DMAC_REGSIZE,
						 	  (DWORD)(PAGE_READWRITE|PAGE_NOCACHE|PAGE_PHYSICAL));

		if (bResult == FALSE)
		{
			// Free VA for DMA
			if (pAdapter->DMABaseVA)
			{
				bResult = VirtualFree ((PVOID)(pAdapter->DMABaseVA), 0UL, (DWORD)MEM_RELEASE);
				pAdapter->DMABaseVA = (DWORD)NULL;
			}
			// Free VA for 9118
			if (pAdapter->lan9118_data.dwLanBase)
			{
				bResult = VirtualFree ((PVOID)(pAdapter->lan9118_data.dwLanBase - (pAdapter->ulIoBaseAddress & (((DWORD)PAGE_SIZE)-1UL))), 0UL, (DWORD)MEM_RELEASE);
				pAdapter->lan9118_data.dwLanBase = (DWORD)NULL;
			}
			// Free pAdapter.
			NdisFreeMemory(pAdapter, (UINT)sizeof(SMSC9118_ADAPTER), NDIS_ALLOC_FLAG);
			SMSC_TRACE0(DBG_DMA,"DMA VirtualCopy failed.\r\n");
			return (NDIS_STATUS_FAILURE);
		}
		else
		{
			SMSC_TRACE0(DBG_DMA,"DMA VirtualCopy OK.\r\n");
		}
	}
	
	//
	// Allocate shared memory for Rx.
	//

	if (pAdapter->fRxDMAMode)
	{
		Status = NdisAllocateMemory((PVOID *)&pAdapter->pSharedMemVA,
									(UINT)sizeof(SMSC9118_SHAREDMEM),
									NDIS_ALLOC_FLAG, HighestAcceptableMax);
		if (Status != NDIS_STATUS_SUCCESS)
		{
			SMSC_WARNING0("Failed to allocate memory for DMA Rx\r\n");
			return (NDIS_STATUS_FAILURE);
		}

		if (!(pAdapter->pSharedMemVA))
		{
			// Free VA for DMA
			if (pAdapter->DMABaseVA)
			{
				bResult = VirtualFree ((PVOID)(pAdapter->DMABaseVA), 0UL, (DWORD)MEM_RELEASE);
				pAdapter->DMABaseVA = (DWORD)NULL;
			}
			// Free VA for 9118
			if (pAdapter->lan9118_data.dwLanBase)
			{
				bResult = VirtualFree ((PVOID)(pAdapter->lan9118_data.dwLanBase - (pAdapter->ulIoBaseAddress & (((DWORD)PAGE_SIZE)-1UL))), 0UL, (DWORD)MEM_RELEASE);
				pAdapter->lan9118_data.dwLanBase = (DWORD)NULL;
			}
			// Free pAdapter.
			NdisFreeMemory(pAdapter, (UINT)sizeof(SMSC9118_ADAPTER), NDIS_ALLOC_FLAG);
			SMSC_TRACE0(DBG_DMA,"  AllocPhysMem failed.\r\n");
			return (NDIS_STATUS_FAILURE);
		}
		else
		{
			SMSC_TRACE2(DBG_DMA,"AllocPhysMem OK. pSharedMemVA = 0x%x; pSharedMemPA = 0x%x.\r\n", pAdapter->pSharedMemVA, pAdapter->pSharedMemPA);
		}
	
	}
	else
	{
		Status = NdisAllocateMemory (&(pAdapter->pSharedMemVA),
									 sizeof (SMSC9118_SHAREDMEM),
									 NDIS_ALLOC_FLAG,
									 HighestAcceptableMax);

		if (Status != NDIS_STATUS_SUCCESS)
		{
			// Free VA for DMA
			if (pAdapter->DMABaseVA)
			{
				bResult = VirtualFree ((PVOID)(pAdapter->DMABaseVA), 0UL, (DWORD)MEM_RELEASE);
				pAdapter->DMABaseVA = (DWORD)NULL;
			}
			// Free VA for 9118
			if (pAdapter->lan9118_data.dwLanBase)
			{
				bResult = VirtualFree ((PVOID)(pAdapter->lan9118_data.dwLanBase - (pAdapter->ulIoBaseAddress & (((DWORD)PAGE_SIZE)-1UL))), 0UL, (DWORD)MEM_RELEASE);
				pAdapter->lan9118_data.dwLanBase = (DWORD)NULL;
			}
			// Free pAdapter.
			NdisFreeMemory(pAdapter, (UINT)sizeof(SMSC9118_ADAPTER), NDIS_ALLOC_FLAG);
			SMSC_TRACE0(DBG_DMA,"  AllocPhysMem failed.\r\n");
			return (NDIS_STATUS_FAILURE);
		}
		else
		{
			SMSC_TRACE2(DBG_DMA,"AllocPhysMem OK. pSharedMemVA = 0x%x; pSharedMemPA = 0x%x.\r\n", pAdapter->pSharedMemVA, pAdapter->pSharedMemPA);
		}

	}

	// Setup the card based on the initialization information
	if (ChipSetup(pAdapter))
	{
		SMSC_TRACE0(DBG_INIT,"  ChipSetup Success\r\n");
		NdisMRegisterAdapterShutdownHandler (pAdapter->hMiniportAdapterHandle, pAdapter, Smsc9118Shutdown);

		ChipStart(pAdapter);

		SMSC_TRACE0(DBG_INIT,"  NdisMRegisterInterrupt Success\r\n");
	}
	else 
	{
		SMSC_TRACE0(DBG_INIT,"  ChipSetup Failed\r\n");
		return NDIS_STATUS_ADAPTER_NOT_FOUND;
	}

	//
	// Initialize DMA
	//
	if (pAdapter->fRxDMAMode || pAdapter->fTxDMAMode) {
		if (DmaInitialize(pAdapter) != TRUE)
		{
			SMSC_TRACE0(DBG_INIT,"  Smsc9118InitializeQueues failed.\r\n");
			return (NDIS_STATUS_FAILURE);
		}
	}
	
	//
	// Initialize queues
	//
	if (InitializeQueues(pAdapter) != NDIS_STATUS_SUCCESS)
	{
		NdisFreeMemory(pAdapter, (UINT)sizeof(SMSC9118_ADAPTER), NDIS_ALLOC_FLAG);
		SMSC_TRACE0(DBG_INIT,"  Smsc9118InitializeQueues failed.\r\n");
		return (NDIS_STATUS_FAILURE);
	}

	//Power management
	pAdapter->CurrentPowerState = NdisDeviceStateD0;

	SMSC_TRACE0(DBG_INIT,"  Initialize succeeded\r\n");

	// Make Lint Happy
	MediumArray = MediumArray;
	uiMediumArraySize = uiMediumArraySize;

	// allocate temp buffer for fragmented packet
	NdisMAllocateSharedMemory(hMiniportAdapterHandle,
			2000UL, (BOOLEAN)FALSE, 
			(PVOID *)&(pAdapter->TxTempPktBuf.pUnAlignedVAddr),
			&(pAdapter->TxTempPktBuf.UnAlignedPAddr));
	if (pAdapter->TxTempPktBuf.pUnAlignedVAddr == NULL)
	{
		SMSC_WARNING0("Error! Can not allocate buffer for fragmented packet\r\n");
		return (NDIS_STATUS_FAILURE);
	}
	else
	{
		pAdapter->TxTempPktBuf.pVAddr = (PUCHAR)(((DWORD)(pAdapter->TxTempPktBuf.pUnAlignedVAddr) + 0x03UL) & (~0x03UL));
		pAdapter->TxTempPktBuf.PAddr.LowPart = (((DWORD)NdisGetPhysicalAddressLow(pAdapter->TxTempPktBuf.UnAlignedPAddr) + 0x03UL) & (~0x03UL));
	}

	// set to Kernel Mode
	oldKmode = SetKMode(1UL);
	oldKmode = oldKmode;		// for Lint

	pAdapter->hSWIntEvt = NULL;

	SMSC_TRACE0(DBG_INIT,"-Smsc9118Initialize\r\n");
	return (NDIS_STATUS_SUCCESS);
}


/*----------------------------------------------------------------------------
	RegisterAdapter
		Register 9118 with NDIS

*/
NDIS_STATUS
RegisterAdapter (IN PSMSC9118_ADAPTER pAdapter, 
				 IN NDIS_HANDLE hConfigurationHandle)
{
	NDIS_STATUS status;

	SMSC_TRACE0(DBG_INIT,"+RegisterAdapter\r\n");

	// avoid Lint error
	hConfigurationHandle = hConfigurationHandle;

	// Inform the wrapper of the physical attributes of this adapter.
	NdisMSetAttributesEx(pAdapter->hMiniportAdapterHandle,