InitializeCriticalSection(&v_AdapterCS);
        DEBUGMSG(ZONE_INIT, (TEXT("ASYNCMAC: DLL_PROCESS_ATTACH\n")));
        break;
    case DLL_PROCESS_DETACH:
        DEBUGMSG(ZONE_INIT, (TEXT("ASYNCMAC: DLL_PROCESS_DETACH\n")));
		DeleteCriticalSection(&v_AdapterCS);
        break;
    }
    return TRUE;
}


VOID	
MpHalt(
	IN NDIS_HANDLE	MiniportAdapterContext
	)
{
	DEBUGMSG (ZONE_INIT|ZONE_INTERFACE, (TEXT("+ASYNCMAC:MpHalt(0x%X)\n"), MiniportAdapterContext));

	EnterCriticalSection(&v_AdapterCS);
    AsyncMacFreeMemory(MiniportAdapterContext, sizeof(ASYNCMAC_ADAPTER));
	v_pAdapter = NULL;
	v_GlobalAdapterCount--;
	LeaveCriticalSection(&v_AdapterCS);

	DEBUGMSG (ZONE_INIT|ZONE_INTERFACE, (TEXT("-ASYNCMAC:MpHalt\n")));
}


NDIS_STATUS
MpInit(
	OUT PNDIS_STATUS	OpenErrorStatus,
	OUT PUINT			SelectedMediumIndex,
	IN	PNDIS_MEDIUM	MediumArray,
	IN	UINT			MediumArraySize,
	IN	NDIS_HANDLE		MiniportAdapterHandle,
	IN	NDIS_HANDLE		WrapperConfigurationContext
	)
{
	NDIS_STATUS						Status;
    UINT							i;		// counter
	PASYNCMAC_ADAPTER				pAdapter;
    NDIS_HANDLE						ConfigHandle;
    PNDIS_CONFIGURATION_PARAMETER	ReturnedValue;
    NDIS_STRING						MaxFrameSizeStr = NDIS_STRING_CONST("MaxFrameSize");
    NDIS_STRING						MaxSendFrameSizeStr = NDIS_STRING_CONST("MaxSendFrameSize");
    NDIS_STRING						MaxRecvFrameSizeStr = NDIS_STRING_CONST("MaxRecvFrameSize");
    NDIS_STRING						RecvBufSizeStr = NDIS_STRING_CONST("ReceiveBufferSize");
    NDIS_STRING						RecvThreadPrioStr = NDIS_STRING_CONST("ReceiveThreadPriority256");

	DEBUGMSG (ZONE_INIT|ZONE_INTERFACE,
			  (TEXT("+ASYNCMAC:MpInit(0x%X, 0x%X, 0x%X, %d, 0x%X, 0x%X)\r\n"),
			   OpenErrorStatus, SelectedMediumIndex, MediumArray,
			   MediumArraySize, MiniportAdapterHandle,
			   WrapperConfigurationContext));
	
	//
	// We only support a single instance of AsyncMac
	//
	if (v_GlobalAdapterCount != 0) {
		return NDIS_STATUS_FAILURE;
	}

	for (i = 0; TRUE; i++)
	{
		if (i >= MediumArraySize)
			return NDIS_STATUS_UNSUPPORTED_MEDIA;

		if (MediumArray[i] == NdisMediumWan)
		{
			*SelectedMediumIndex = i;
			break;
		}
	}

	//
	// Let's allocate an AsyncMac adapter structure.
    //
	pAdapter = AsyncMacAllocateMemory(sizeof(ASYNCMAC_ADAPTER));
    if (pAdapter == NULL)
	{
        return NDIS_STATUS_RESOURCES;
    }

	ASSERT(AsyncMacGuardRegionOk(pAdapter, sizeof(ASYNCMAC_ADAPTER)));

#ifdef DEBUG
	pAdapter->dwDebugSigStart = AA_SIG_START;
	pAdapter->dwDebugSigEnd = AA_SIG_END;
	DEBUGMSG (ZONE_ALLOC, (TEXT(" ASYNCMAC:MpInit: Allocated pAdapter 0x%X(%d)\r\n"),
						   pAdapter, sizeof(ASYNCMAC_ADAPTER)));
	
#endif
	pAdapter->hMiniportAdapter = MiniportAdapterHandle;

    //
    // Open the configuration space.
    //
    NdisOpenConfiguration(&Status, &ConfigHandle, WrapperConfigurationContext);

    if (Status != NDIS_STATUS_SUCCESS)
	{
        AsyncMacFreeMemory(pAdapter, sizeof(ASYNCMAC_ADAPTER));

        DEBUGMSG(ZONE_INIT,
            (TEXT("NE2000:Initialize: NdisOpenConfiguration failed 0x%x\n"),
            Status));
        return Status;
    }

	pAdapter->Info.MaxFrameSize = MAX_FRAME_SIZE;

    NdisReadConfiguration(&Status, &ReturnedValue, ConfigHandle, &MaxFrameSizeStr, NdisParameterInteger);

    if (Status == NDIS_STATUS_SUCCESS)
	{
		pAdapter->Info.MaxFrameSize = ReturnedValue->ParameterData.IntegerData;
		DEBUGMSG(ZONE_INIT,(TEXT("ASYNCMAC: MaxFrameSize=%d.\n"), pAdapter->Info.MaxFrameSize));
    }
	

	pAdapter->MaxSendFrameSize = pAdapter->Info.MaxFrameSize;

    NdisReadConfiguration(&Status, &ReturnedValue, ConfigHandle, &MaxSendFrameSizeStr, NdisParameterInteger);

    if (Status == NDIS_STATUS_SUCCESS)
	{
		pAdapter->MaxSendFrameSize = ReturnedValue->ParameterData.IntegerData;
		DEBUGMSG(ZONE_INIT,(TEXT("ASYNCMAC: MaxSendFrameSize=%d.\n"), pAdapter->MaxSendFrameSize));
    }

	pAdapter->MaxRecvFrameSize = pAdapter->Info.MaxFrameSize;

    NdisReadConfiguration(&Status, &ReturnedValue, ConfigHandle, &MaxRecvFrameSizeStr, NdisParameterInteger);

    if (Status == NDIS_STATUS_SUCCESS)
	{
		pAdapter->MaxRecvFrameSize = ReturnedValue->ParameterData.IntegerData;
		DEBUGMSG(ZONE_INIT,(TEXT("ASYNCMAC: MaxRecvFrameSize=%d.\n"), pAdapter->MaxRecvFrameSize));
    }

	pAdapter->dwRecvBufSize = DEFAULT_RX_BUF_SIZE;

    NdisReadConfiguration(&Status, &ReturnedValue, ConfigHandle, &RecvBufSizeStr, NdisParameterInteger);

    if (Status == NDIS_STATUS_SUCCESS)
	{
		pAdapter->dwRecvBufSize = ReturnedValue->ParameterData.IntegerData;
		DEBUGMSG(ZONE_INIT,(TEXT("ASYNCMAC: RecvBufferSize=%d.\n"), pAdapter->dwRecvBufSize));
    }

	pAdapter->dwRecvThreadPrio = DEFAULT_RX_THREAD_PRIORITY;

	NdisReadConfiguration(&Status, &ReturnedValue, ConfigHandle, &RecvThreadPrioStr, NdisParameterInteger);

    if (Status == NDIS_STATUS_SUCCESS)
	{
		pAdapter->dwRecvThreadPrio = ReturnedValue->ParameterData.IntegerData;
    }
	DEBUGMSG(ZONE_INIT,(TEXT("ASYNCMAC: RecvThreadPrio=%d.\n"), pAdapter->dwRecvThreadPrio));

	// Just close the config handle
	NdisCloseConfiguration (ConfigHandle);

	// Initialize our structure.
	pAdapter->Info.MaxTransmit = 2;

#define	ROUND_UP_TO_MULTIPLE_OF_N(value, N)	((value + N - 1) & ~(N - 1))

	// For more info on HeaderPadding and TailPadding sizes see AssemblePPPFrame.
	// HeaderPadding = 1 byte for opening flag (7e) + MaxFrameSize bytes to allow for insertion of escape bytes
	// TailPadding   = 4 bytes for escaped 16 bit CRC + 1 byte for closing flag
	//
	// The header padding must be rounded up because the PPP code that builds a packet expects that
	// PacketStartAddress + HeaderPadding will be DWORD aligned.
	pAdapter->Info.HeaderPadding = ROUND_UP_TO_MULTIPLE_OF_N(1 + pAdapter->Info.MaxFrameSize, 4);
	pAdapter->Info.TailPadding = 4 + 1;

	pAdapter->Info.Endpoints = 1;
	pAdapter->Info.MemoryFlags = 0;
//	pAdapter->Info.HighestAcceptableAddress = NDIS_PHYSICAL_ADDRESS_CONST(-1,-1);
	pAdapter->Info.FramingBits = PPP_FRAMING|SLIP_FRAMING;
	pAdapter->Info.DesiredACCM = DEFAULT_ACCM;
	
	// Tell NDIS about our handle
    NdisMSetAttributesEx(MiniportAdapterHandle, (NDIS_HANDLE)pAdapter, 1000,
						 0, NdisInterfaceInternal);
	
	
	// Initialize TAPI
#ifdef TODO
	// Once we change the load order so that miniports get loaded after the
	// system is initialized we can do the lineInitialize here.  In the meantime
	// we'll use a lame function to sleep for awhile until we think the system
	// might be happy.
	{
		long	lReturn;
		lReturn = lineInitialize (&(pAdapter->hLineApp),
								  v_hInstance, lineCallbackFunc, 
								  TEXT("ASYNCMAC"), &(pAdapter->dwNumDevs));
		DEBUGMSG (1, (TEXT("lineInitialize returned %d\r\n"),
					  lReturn));

		DEBUGMSG (1, (TEXT("lineInitialize say's there's %d devices\r\n"),
					  pAdapter->dwNumDevs));
	
	}
#else
	{
		NdisMInitializeTimer (&(pAdapter->ntLineInit),
							  pAdapter->hMiniportAdapter,
							  DoLineInitialize, pAdapter);
							  
							  
		NdisMSetTimer (&(pAdapter->ntLineInit), 1000);
					  
	}
#endif

	// Lot's more stuff.
	EnterCriticalSection(&v_AdapterCS);
	v_pAdapter = pAdapter;
	v_GlobalAdapterCount++;
	LeaveCriticalSection(&v_AdapterCS);

	ASSERT(AsyncMacGuardRegionOk(pAdapter, sizeof(ASYNCMAC_ADAPTER)));

	DEBUGMSG (ZONE_INIT|ZONE_INTERFACE, (TEXT("-ASYNCMAC:MpInit\r\n")));
	
    return NDIS_STATUS_SUCCESS;
}

NDIS_STATUS
MapTapiErrorToNdisStatus(
	IN	DWORD	dwTapiErrorCode)
//
//	Translate a TAPI error code to an NDIS status.
//
{
	NDIS_STATUS	NdisStatus;

	switch(dwTapiErrorCode)
	{
	case 0:
		NdisStatus = NDIS_STATUS_SUCCESS;
		break;

	case LINEERR_BADDEVICEID:
	case LINEERR_INVALADDRESS:
	case LINEERR_INVALAPPHANDLE:
	case LINEERR_INVALPARAM:
	case LINEERR_INVALPOINTER:
	case LINEERR_INVALDEVICECLASS:
	case LINEERR_STRUCTURETOOSMALL:
		NdisStatus = NDIS_STATUS_TAPI_INVALPARAM;
		break;

	case LINEERR_CALLUNAVAIL:
		NdisStatus = NDIS_STATUS_TAPI_CALLUNAVAIL;
		break;

	case LINEERR_INCOMPATIBLEEXTVERSION:
		NdisStatus = NDIS_STATUS_TAPI_INCOMPATIBLEEXTVERSION;
		break;

	case LINEERR_INVALLINESTATE:
		NdisStatus = NDIS_STATUS_TAPI_INVALLINESTATE;
		break;

	case LINEERR_INVALCARD:
	case LINEERR_NODEVICE:
	case LINEERR_UNINITIALIZED:
		NdisStatus = NDIS_STATUS_TAPI_NODEVICE;
		break;

	case LINEERR_NODRIVER:
		NdisStatus = NDIS_STATUS_TAPI_NODRIVER;
		break;

	case LINEERR_NOMEM:
		NdisStatus = NDIS_STATUS_RESOURCES;
		break;

	case LINEERR_OPERATIONUNAVAIL:
		NdisStatus = NDIS_STATUS_TAPI_OPERATIONUNAVAIL;
		break;

	case LINEERR_RESOURCEUNAVAIL:
		NdisStatus = NDIS_STATUS_TAPI_RESOURCEUNAVAIL;
		break;

	case LINEERR_INCOMPATIBLEAPIVERSION:
	case LINEERR_OPERATIONFAILED:
		NdisStatus = NDIS_STATUS_FAILURE;
		break;

	default:
		//
		//	All TAPI codes should be covered explicitly, if
		//	they are not we can catch them with the assert and
		//	add them.
		//
		ASSERT(FALSE);
		NdisStatus = NDIS_STATUS_FAILURE;
		break;

	}

	return NdisStatus;
}


DWORD WINAPI
LineConfigDialogEditThread(
	LPVOID pVArg)
{
	PNDIS_TAPI_LINE_CONFIG_DIALOG_EDIT pConfigDlgEdit = (PNDIS_TAPI_LINE_CONFIG_DIALOG_EDIT)pVArg;
	long lResult;
	LPTSTR	szDeviceClass;

	//
	//	In case any of the data is on the application stack or heap...
	//
	SetProcPermissions(-1);

	if (pConfigDlgEdit->ulDeviceClassLen) {
		szDeviceClass = (LPTSTR)pConfigDlgEdit->DataBuf;
	} else {
		szDeviceClass = NULL;
	}

	lResult = lineConfigDialogEdit (pConfigDlgEdit->ulDeviceID,
									pConfigDlgEdit->hwndOwner,
									szDeviceClass,
									pConfigDlgEdit->DataBuf + pConfigDlgEdit->ulConfigInOffset,
									pConfigDlgEdit->ulConfigInSize,
									(LPVARSTRING)(pConfigDlgEdit->DataBuf + pConfigDlgEdit->ulConfigOutOffset));

	return (DWORD)lResult;
}

NDIS_STATUS
MpQueryInfo(
	IN	NDIS_HANDLE	MiniportAdapterContext,
	IN	NDIS_OID	Oid,
	IN	PVOID		InformationBuffer,
	IN	ULONG		InformationBufferLength,
	OUT PULONG		BytesWritten,
	OUT PULONG		BytesNeeded
	)
/*++

Routine Description:

    The MpQueryProtocolInformation process a Query request for
    NDIS_OIDs that are specific to a binding about the MAC.  Note that
    some of the OIDs that are specific to bindings are also queryable
    on a global basis.  Rather than recreate this code to handle the
    global queries, I use a flag to indicate if this is a query for the
    global data or the binding specific data.

Arguments:

    Adapter - a pointer to the adapter.

    Oid - the NDIS_OID to process.

Return Value:

    The function value is the status of the operation.

--*/

{
    NDIS_MEDIUM             Medium          = NdisMediumWan;
	PASYNCMAC_ADAPTER		pAdapter = (PASYNCMAC_ADAPTER)MiniportAdapterContext;
    NDIS_STATUS             StatusToReturn  = NDIS_STATUS_SUCCESS;
    NDIS_HARDWARE_STATUS    HardwareStatus  = NdisHardwareStatusReady;
    PVOID                   MoveSource;
    ULONG                   MoveBytes;
    ULONG                   GenericULong    = 0;
    USHORT                  GenericUShort   = 0;
    INT                     fDoCommonMove = TRUE;
    UCHAR					WanAddress[6] = {' ','A','S','Y','N',0xFF};  // This is the address returned by OID_WAN_*_ADDRESS.
	
	DEBUGMSG (ZONE_INIT|ZONE_INTERFACE,
			  (TEXT("+ASYNCMAC:MpQueryInfo(0x%X, 0x%X(%hs), 0x%X, %d, 0x%X, 0x%X)\r\n"),
			   MiniportAdapterContext, Oid, GetOidString(Oid),
			   InformationBuffer, InformationBufferLength,
			   BytesWritten, BytesNeeded));

	ASSERT(CHK_AA(pAdapter));
	
    MoveSource = &GenericULong;
    MoveBytes  = sizeof(GenericULong);
	
	switch ( Oid ) {
	case OID_GEN_SUPPORTED_LIST:
		MoveSource = (PVOID) SupportedOids;
		MoveBytes = sizeof(SupportedOids);
		break;