case OID_GEN_MEDIA_SUPPORTED :
	case OID_GEN_MEDIA_IN_USE:
		MoveSource = (PVOID)&Medium;
		MoveBytes = sizeof(Medium);
		break;

	case OID_GEN_VENDOR_ID:
		GenericULong = 0xFFFFFFFF;
		MoveBytes = 3;
		break;

	case OID_GEN_VENDOR_DESCRIPTION:
		MoveSource = (PVOID)"AsyncMac Adapter";
		MoveBytes = 16;
		break;

	case OID_GEN_DRIVER_VERSION:
		GenericUShort = 0x0300;
		MoveSource = (PVOID)&GenericUShort;
		MoveBytes = sizeof(USHORT);
		break;

	case OID_GEN_HARDWARE_STATUS:
		MoveSource = (PVOID)&HardwareStatus;
		MoveBytes = sizeof(HardwareStatus);
		break;

	case OID_GEN_LINK_SPEED:
		//
		// Who knows what the initial link speed is?
		// This should not be called, right?
		//
		GenericULong = (ULONG)288;
		break;
		
	case OID_TAPI_PROVIDER_INITIALIZE:
		fDoCommonMove = FALSE;
		if (InformationBufferLength < sizeof(NDIS_TAPI_PROVIDER_INITIALIZE)) {
			StatusToReturn = NDIS_STATUS_BUFFER_TOO_SHORT;
			*BytesNeeded = sizeof(NDIS_TAPI_PROVIDER_INITIALIZE);	
		} else {
			PNDIS_TAPI_PROVIDER_INITIALIZE	pProvInit = (PNDIS_TAPI_PROVIDER_INITIALIZE)InformationBuffer;
			pProvInit->ulNumLineDevs = pAdapter->dwNumDevs;
			*BytesWritten = sizeof(NDIS_TAPI_PROVIDER_INITIALIZE);
		}
		break;

	case OID_TAPI_GET_DEV_CAPS :
		fDoCommonMove = FALSE;
		if (InformationBufferLength < sizeof(NDIS_TAPI_GET_DEV_CAPS))
		{
			StatusToReturn = NDIS_STATUS_BUFFER_TOO_SHORT;
			*BytesNeeded = sizeof(NDIS_TAPI_GET_DEV_CAPS);
		} else
		{
			LONG						lResult;

			PNDIS_TAPI_GET_DEV_CAPS	pGetDevCaps = (PNDIS_TAPI_GET_DEV_CAPS)InformationBuffer;

			lResult = lineGetDevCaps(pAdapter->hLineApp, pGetDevCaps->ulDeviceID, pAdapter->dwAPIVersion,
						   0, (LPLINEDEVCAPS)&(pGetDevCaps->LineDevCaps));
			if (lResult != 0)
			{
				DEBUGMSG (ZONE_TAPI|ZONE_ERROR, (TEXT("lineGetDevCaps failed (%d)\n"), lResult));
				StatusToReturn = MapTapiErrorToNdisStatus(lResult);
			}
		}
		break;

	case OID_TAPI_GET_DEV_CONFIG :
		fDoCommonMove = FALSE;
		if (InformationBufferLength < sizeof(NDIS_TAPI_GET_DEV_CONFIG))
		{
			DEBUGMSG (ZONE_TAPI, (TEXT("ASYNCMAC: Buffer too short (%d < %d)\n"), InformationBufferLength, sizeof(NDIS_TAPI_GET_DEV_CONFIG)));
			StatusToReturn = NDIS_STATUS_BUFFER_TOO_SHORT;
			*BytesNeeded = sizeof(NDIS_TAPI_GET_DEV_CONFIG);
			break;
		}
		else
		{
			PNDIS_TAPI_GET_DEV_CONFIG	pTapiDevConfig = (PNDIS_TAPI_GET_DEV_CONFIG)InformationBuffer;
			LPVARSTRING					pDevConfig = (LPVARSTRING)&pTapiDevConfig->DeviceConfig;
			LONG						lResult;

			DEBUGMSG (ZONE_TAPI, (TEXT("ASYNCMAC: Calling lineGetDevConfig\n")));
			lResult = lineGetDevConfig(
							pTapiDevConfig->ulDeviceID,
							pDevConfig,
							DEV_CLASS_COMM_DATAMODEM);
			if (lResult != 0)
			{
				DEBUGMSG (ZONE_TAPI|ZONE_ERROR, (TEXT("lineGetDevConfig failed (%d)\n"), lResult));
				StatusToReturn = MapTapiErrorToNdisStatus(lResult);
			}
		}
		break;

	case OID_TAPI_TRANSLATE_ADDRESS :
		fDoCommonMove = FALSE;
		if (InformationBufferLength < sizeof(NDIS_TAPI_LINE_TRANSLATE)) {
			StatusToReturn = NDIS_STATUS_BUFFER_TOO_SHORT;
			*BytesNeeded = sizeof(NDIS_TAPI_LINE_TRANSLATE);
			DEBUGMSG (ZONE_ERROR, (TEXT(" ASYNCMAC:MpQueryInfo length too short for lineTranslateAddress, new length=%d\r\n"),
								   *BytesNeeded));
		} else {
			PNDIS_TAPI_LINE_TRANSLATE pLineTranslate = (PNDIS_TAPI_LINE_TRANSLATE)InformationBuffer;
			long lResult;

			// Lame check to see if the structures are the same size
			ASSERT (sizeof(LINETRANSLATEOUTPUT) == sizeof(LINE_TRANSLATE_OUTPUT));

			lResult = lineTranslateAddress (pAdapter->hLineApp, pLineTranslate->ulDeviceID,
											pAdapter->dwAPIVersion, (LPTSTR)pLineTranslate->DataBuf,
											0, pLineTranslate->ulTranslateOptions,
											(LPLINETRANSLATEOUTPUT)(pLineTranslate->DataBuf+pLineTranslate->ulLineTranslateOutputOffset));
			if (lResult != 0) {
				DEBUGMSG (ZONE_ERROR, (TEXT(" ASYNCMAC:MpQueryInfo Error %d from lineTranslateAddress\r\n"),
									   lResult));
				StatusToReturn = MapTapiErrorToNdisStatus(lResult);
			}
		}
		break;

	case OID_TAPI_OPEN :
		fDoCommonMove = FALSE;
		if (InformationBufferLength < sizeof(NDIS_TAPI_OPEN)) {
			StatusToReturn = NDIS_STATUS_BUFFER_TOO_SHORT;
			*BytesNeeded = sizeof(NDIS_TAPI_OPEN);
			break;
		} else {
			PNDIS_TAPI_OPEN		pTapiOpen = (PNDIS_TAPI_OPEN)InformationBuffer;
			PASYNCMAC_OPEN_LINE	pOpenLine;
			long				lResult;

			pOpenLine = AsyncMacAllocateMemory(sizeof(ASYNCMAC_OPEN_LINE));

			if (pOpenLine == NULL)
			{
				StatusToReturn = NDIS_STATUS_RESOURCES;
				break;
			}
			ASSERT(AsyncMacGuardRegionOk(pOpenLine, sizeof(ASYNCMAC_OPEN_LINE)));
#ifdef DEBUG
			pOpenLine->dwDebugSigStart = AOL_SIG_START;
			pOpenLine->dwDebugSigEnd = AOL_SIG_END;
			DEBUGMSG (ZONE_ALLOC, (TEXT(" ASYNCMAC:MpQueryInfo: Allocated pOpenLine 0x%X(%d)\r\n"),
								   pOpenLine, sizeof(ASYNCMAC_OPEN_LINE)));
#endif
			DEBUGMSG (ZONE_TAPI, (TEXT("***Allocated pOpenLine at 0x%X\r\n"),
						  pOpenLine));
			pOpenLine->dwRefCnt = 1;	// InitializeRefCnt
			pOpenLine->pAdapter = pAdapter;
			pOpenLine->dwDeviceID = pTapiOpen->ulDeviceID;
			pOpenLine->htLine = pTapiOpen->htLine;
			pOpenLine->dwBaudRate = AOL_DEF_BAUD_RATE;	// Default baud rate.

			// Initialize the GET_LINK_INFO struct
			pOpenLine->WanLinkInfo.MaxSendFrameSize = pAdapter->MaxSendFrameSize;
			pOpenLine->WanLinkInfo.MaxRecvFrameSize = pAdapter->MaxRecvFrameSize;
			pOpenLine->WanLinkInfo.HeaderPadding    = pAdapter->Info.HeaderPadding;
			pOpenLine->WanLinkInfo.TailPadding      = pAdapter->Info.TailPadding;
			pOpenLine->WanLinkInfo.SendFramingBits = PPP_FRAMING;	// For SLIP, we will have to be told to turn this off.
			pOpenLine->WanLinkInfo.RecvFramingBits = PPP_FRAMING;
			pOpenLine->WanLinkInfo.SendCompressionBits = 0;
			pOpenLine->WanLinkInfo.RecvCompressionBits = 0;
			pOpenLine->WanLinkInfo.SendACCM = (ULONG) -1;
			pOpenLine->WanLinkInfo.RecvACCM = (ULONG) -1;
			
			lResult = lineOpen(pAdapter->hLineApp, pTapiOpen->ulDeviceID,
							   &pOpenLine->hLine,
							   pAdapter->dwAPIVersion, 0,
							   (DWORD)pOpenLine, LINECALLPRIVILEGE_OWNER,
							   LINEMEDIAMODE_DATAMODEM, NULL);

			if (lResult != 0) {
				DEBUGMSG (ZONE_TAPI|ZONE_ERROR,
						  (TEXT("lineOpen failed (%x)\r\n"), lResult));
				AsyncMacFreeMemory (pOpenLine, sizeof(ASYNCMAC_OPEN_LINE));
				StatusToReturn = MapTapiErrorToNdisStatus(lResult);
			} else {
				DEBUGMSG (ZONE_TAPI, (TEXT("lineOpen success\r\n")));
				pTapiOpen->hdLine = (HDRV_LINE)pOpenLine;

				// Add ourselves to the list of open lines for this adapter
				pOpenLine->pNext = pAdapter->pHead;
				pAdapter->pHead = pOpenLine;
				DEBUGMSG(ZONE_TAPI, (TEXT(" Add pOpenLine=%x to pAdapter=%x (v_pAdapter=%x)\n"), pOpenLine, pAdapter, v_pAdapter));
			}
		}
		break;

	case OID_TAPI_MAKE_CALL :
		fDoCommonMove = FALSE;
		if (InformationBufferLength < sizeof(NDIS_TAPI_MAKE_CALL)) {
			StatusToReturn = NDIS_STATUS_BUFFER_TOO_SHORT;
			*BytesNeeded = sizeof(NDIS_TAPI_MAKE_CALL);
			break;
		} else {
			PNDIS_TAPI_MAKE_CALL pTapiMakeCall = (PNDIS_TAPI_MAKE_CALL)InformationBuffer;
			long lResult;
			PASYNCMAC_OPEN_LINE	pOpenLine;
			LINECALLPARAMS CallParams;
			LPTSTR			szDialStr;

			pOpenLine = (PASYNCMAC_OPEN_LINE)pTapiMakeCall->hdLine;
			ASSERT(CHK_AOL(pOpenLine));
			pOpenLine->htCall = pTapiMakeCall->htCall;

#ifdef TODO
	// For now I'll assume that the bUserDefaultCallParams has been
	// specified
#endif
			szDialStr = (LPTSTR)((PBYTE)pTapiMakeCall+pTapiMakeCall->ulDestAddressOffset);
			RETAILMSG (1, (TEXT("ASYNCMAC: Dialing '%s'\r\n"), szDialStr));
			memset ((char *)&CallParams, 0, sizeof(LINECALLPARAMS));
			CallParams.dwTotalSize = sizeof(LINECALLPARAMS);
			CallParams.dwBearerMode = LINEBEARERMODE_DATA;
			CallParams.dwMinRate = 0;   // Any rate
			CallParams.dwMaxRate = 0;   // This should mean any max rate
			CallParams.dwMediaMode = LINEMEDIAMODE_DATAMODEM;
			CallParams.dwCallParamFlags = LINECALLPARAMFLAGS_IDLE;
			CallParams.dwAddressMode = LINEADDRESSMODE_ADDRESSID;
			CallParams.dwAddressID = 0;  // there's only one address...

			lResult = lineMakeCall (pOpenLine->hLine, &(pOpenLine->hCall),
									szDialStr, 0,
									&CallParams);
			if (lResult < 0) {
				DEBUGMSG (ZONE_TAPI|ZONE_ERROR,
						  (TEXT("Error %x from lineMakeCall\r\n"), lResult));
				StatusToReturn = MapTapiErrorToNdisStatus(lResult);
			} else {
				DEBUGMSG (ZONE_TAPI, (TEXT("lineMakeCall Success.  RequestID=%d, hCall=0x%X\r\n"),
									  lResult, pOpenLine->hCall));
				pTapiMakeCall->hdCall = (HDRV_CALL)pOpenLine;
				pOpenLine->TapiReqID = lResult;
			}
			ASSERT(CHK_AOL(pOpenLine));
		}
		break;

	case OID_TAPI_CONFIG_DIALOG_EDIT :
		fDoCommonMove = FALSE;
		if (InformationBufferLength < sizeof(NDIS_TAPI_LINE_CONFIG_DIALOG_EDIT)) {
			StatusToReturn = NDIS_STATUS_BUFFER_TOO_SHORT;
			*BytesNeeded = sizeof(NDIS_TAPI_LINE_CONFIG_DIALOG_EDIT);
			DEBUGMSG (ZONE_ERROR, (TEXT(" ASYNCMAC:MpQueryInfo length too short for lineTranslateAddress, new length=%d\r\n"),
								   *BytesNeeded));
		} else {
			long lResult;
			HANDLE	hEditThread;
			DWORD	dwID;

			//
			//	Spin a thread to do the edit.
			//	That way, when the edit thread goes away GWE will release any "hidden" window
			//	from the system. Otherwise the hidden window would persist as long as the INdisDriverThread
			//	for asyncmac was around and cause problems as there is no message pump for it.
			//
			hEditThread = CreateThread(NULL, 0, LineConfigDialogEditThread, InformationBuffer, 0, &dwID);

			if (hEditThread == INVALID_HANDLE_VALUE)
			{
				StatusToReturn = NDIS_STATUS_RESOURCES;
			}
			else
			{
				WaitForSingleObject(hEditThread, INFINITE);
				GetExitCodeThread(hEditThread, (PDWORD)&lResult);
				CloseHandle(hEditThread);

				DEBUGMSG (lResult && ZONE_ERROR, (TEXT(" ASYNCMAC:MpQueryInfo Error 0x%X(%d) from lineConfigDialogEdit\r\n"), lResult, lResult));
			}
		}
		break;

	case OID_WAN_CURRENT_ADDRESS:
	case OID_WAN_PERMANENT_ADDRESS:
		MoveSource = WanAddress;
		MoveBytes = sizeof(WanAddress);
		break;
		
	case OID_WAN_GET_INFO:
		MoveSource = &pAdapter->Info;
		MoveBytes = sizeof(pAdapter->Info);
		break;
		
	case OID_WAN_MEDIUM_SUBTYPE:
	    GenericULong = NdisWanMediumSerial;
	    break;

	case OID_WAN_HEADER_FORMAT:
	    GenericULong = NdisWanHeaderEthernet;
	    break;


	case OID_GEN_MAC_OPTIONS:
		GenericULong = (ULONG)(NDIS_MAC_OPTION_RECEIVE_SERIALIZED |
							   NDIS_MAC_OPTION_TRANSFERS_NOT_PEND |
                               NDIS_MAC_OPTION_FULL_DUPLEX |
							   NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA);
		break;

	case OID_GEN_MAXIMUM_LOOKAHEAD :
	case OID_GEN_CURRENT_LOOKAHEAD:
	case OID_GEN_MAXIMUM_FRAME_SIZE:
	case OID_GEN_TRANSMIT_BLOCK_SIZE:
	case OID_GEN_RECEIVE_BLOCK_SIZE:
	case OID_GEN_MAXIMUM_TOTAL_SIZE:
		GenericULong = pAdapter->Info.MaxFrameSize;
		break;

	case OID_GEN_TRANSMIT_BUFFER_SPACE:
	case OID_GEN_RECEIVE_BUFFER_SPACE:
		// TODO: Get real buffer space numbers
		GenericULong = (ULONG)(pAdapter->Info.MaxFrameSize * 2);
		break;

	case OID_WAN_GET_LINK_INFO :
		if (InformationBufferLength < sizeof (NDIS_WAN_GET_LINK_INFO)) {
			StatusToReturn = NDIS_STATUS_BUFFER_TOO_SHORT;
			*BytesNeeded = sizeof(NDIS_WAN_GET_LINK_INFO);
			break;
		} else {
			PNDIS_WAN_GET_LINK_INFO	pLinkInfo = (PNDIS_WAN_GET_LINK_INFO)InformationBuffer;
			PASYNCMAC_OPEN_LINE	pOpenLine;

			pOpenLine = (PASYNCMAC_OPEN_LINE)pLinkInfo->NdisLinkHandle;
			ASSERT(CHK_AOL(pOpenLine));

			// Let's move this just in case...
			pOpenLine->WanLinkInfo.NdisLinkHandle = pLinkInfo->NdisLinkHandle;
				
			MoveSource = &pOpenLine->WanLinkInfo;
			MoveBytes = sizeof(pOpenLine->WanLinkInfo);
		}
		
		break;

    default:
		DEBUGMSG (ZONE_ERROR,
				  (TEXT(" ASYNCMAC:MpQueryInfo: OID 0x%X/%hs not supported\r\n"),
				  Oid, GetOidString(Oid)));
        StatusToReturn = NDIS_STATUS_NOT_SUPPORTED;
        break;
    }
	
    if ( StatusToReturn == NDIS_STATUS_SUCCESS ) {

        if (fDoCommonMove) {
            //
            //  If there is enough room then we can copy the data and
            //  return the number of bytes copied, otherwise we must
            //  fail and return the number of bytes needed.
            //
            if ( MoveBytes <= InformationBufferLength ) {

                memcpy (InformationBuffer, MoveSource, MoveBytes);

                *BytesWritten = MoveBytes;

            } else {

                *BytesNeeded = MoveBytes;

	        	StatusToReturn = NDIS_STATUS_BUFFER_TOO_SHORT;

            }
        }
    }

	DEBUGMSG (ZONE_INIT|ZONE_INTERFACE,
			  (TEXT("-ASYNCMAC:MpQueryInfo: Returning 0x%X\r\n"),
			   StatusToReturn));
	
	return StatusToReturn;
}

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

Routine Description:

    The AsyncSetInformation is used by AsyncRequest to set information
    about the MAC.

    Note: Assumes it is called with the lock held.  Any calls are made down
	to the serial driver from this routine may return pending.  If this happens
	the completion routine for the call needs to complete this request by
	calling NdisMSetInformationComplete.

Arguments: