OS_Develop/Windows-Server-2003
OS_Develop/Windows-Server-2003
1
0
Fork 0
Code Pull Requests Activity
master
Windows-Server-2003/net/irda/rasirda/rasirda.c

1473 lines
42 KiB
C
Raw Permalink Normal View History

Initiall commit
2024-08-04 01:28:15 +02:00
/*++
Copyright (c) 1996 Microsoft Corporation
Module Name:
rasirda.c
Abstract:
Miniport peice of the irda NDIS 5 miniport (WAN driver)
Author:
mbert 9-97
--*/
#include "rasirdap.h"
// Globals
#if DBG
#include <irioctl.h>
#if 0
int DbgSettings =
DBG_INIT |
DBG_CONFIG |
DBG_CONNECT |
// DBG_SEND |
// DBG_RECV |
DBG_LIB_OBJ |
DBG_LIB_CONNECT |
DBG_ERROR |
1;
#else
int DbgSettings = 0;
#endif
int DbgOutput =
DBG_OUTPUT_BUFFER |
DBG_OUTPUT_DEBUGGER |
0;
PDRIVER_OBJECT pRasIrDriverObject;
PDEVICE_OBJECT pRasIrDeviceObject;
NTSTATUS
DbgDispatch(
PDEVICE_OBJECT pDeviceObject,
PIRP pIrp);
#endif
NDIS_SPIN_LOCK RasIrSpinLock;
LIST_ENTRY RasIrAdapterList;
const USHORT FcsTable[256] = {
0x0000,0x1189,0x2312,0x329B,0x4624,0x57AD,0x6536,0x74BF,
0x8C48,0x9DC1,0xAF5A,0xBED3,0xCA6C,0xDBE5,0xE97E,0xF8F7,
0x1081,0x0108,0x3393,0x221A,0x56A5,0x472C,0x75B7,0x643E,
0x9CC9,0x8D40,0xBFDB,0xAE52,0xDAED,0xCB64,0xF9FF,0xE876,
0x2102,0x308B,0x0210,0x1399,0x6726,0x76AF,0x4434,0x55BD,
0xAD4A,0xBCC3,0x8E58,0x9FD1,0xEB6E,0xFAE7,0xC87C,0xD9F5,
0x3183,0x200A,0x1291,0x0318,0x77A7,0x662E,0x54B5,0x453C,
0xBDCB,0xAC42,0x9ED9,0x8F50,0xFBEF,0xEA66,0xD8FD,0xC974,
0x4204,0x538D,0x6116,0x709F,0x0420,0x15A9,0x2732,0x36BB,
0xCE4C,0xDFC5,0xED5E,0xFCD7,0x8868,0x99E1,0xAB7A,0xBAF3,
0x5285,0x430C,0x7197,0x601E,0x14A1,0x0528,0x37B3,0x263A,
0xDECD,0xCF44,0xFDDF,0xEC56,0x98E9,0x8960,0xBBFB,0xAA72,
0x6306,0x728F,0x4014,0x519D,0x2522,0x34AB,0x0630,0x17B9,
0xEF4E,0xFEC7,0xCC5C,0xDDD5,0xA96A,0xB8E3,0x8A78,0x9BF1,
0x7387,0x620E,0x5095,0x411C,0x35A3,0x242A,0x16B1,0x0738,
0xFFCF,0xEE46,0xDCDD,0xCD54,0xB9EB,0xA862,0x9AF9,0x8B70,
0x8408,0x9581,0xA71A,0xB693,0xC22C,0xD3A5,0xE13E,0xF0B7,
0x0840,0x19C9,0x2B52,0x3ADB,0x4E64,0x5FED,0x6D76,0x7CFF,
0x9489,0x8500,0xB79B,0xA612,0xD2AD,0xC324,0xF1BF,0xE036,
0x18C1,0x0948,0x3BD3,0x2A5A,0x5EE5,0x4F6C,0x7DF7,0x6C7E,
0xA50A,0xB483,0x8618,0x9791,0xE32E,0xF2A7,0xC03C,0xD1B5,
0x2942,0x38CB,0x0A50,0x1BD9,0x6F66,0x7EEF,0x4C74,0x5DFD,
0xB58B,0xA402,0x9699,0x8710,0xF3AF,0xE226,0xD0BD,0xC134,
0x39C3,0x284A,0x1AD1,0x0B58,0x7FE7,0x6E6E,0x5CF5,0x4D7C,
0xC60C,0xD785,0xE51E,0xF497,0x8028,0x91A1,0xA33A,0xB2B3,
0x4A44,0x5BCD,0x6956,0x78DF,0x0C60,0x1DE9,0x2F72,0x3EFB,
0xD68D,0xC704,0xF59F,0xE416,0x90A9,0x8120,0xB3BB,0xA232,
0x5AC5,0x4B4C,0x79D7,0x685E,0x1CE1,0x0D68,0x3FF3,0x2E7A,
0xE70E,0xF687,0xC41C,0xD595,0xA12A,0xB0A3,0x8238,0x93B1,
0x6B46,0x7ACF,0x4854,0x59DD,0x2D62,0x3CEB,0x0E70,0x1FF9,
0xF78F,0xE606,0xD49D,0xC514,0xB1AB,0xA022,0x92B9,0x8330,
0x7BC7,0x6A4E,0x58D5,0x495C,0x3DE3,0x2C6A,0x1EF1,0x0F78
};
NDIS_STATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath);
NDIS_STATUS
QueryInformation(
IN PRASIR_ADAPTER pAdapter,
IN PRASIR_VC pVc,
IN NDIS_OID Oid,
IN PVOID InformationBuffer,
IN ULONG InformationBufferLength,
OUT PULONG BytesWritten,
OUT PULONG BytesNeeded);
NDIS_STATUS
SetInformation(
IN PRASIR_ADAPTER pAdapter,
IN PRASIR_VC pVc,
IN NDIS_OID Oid,
IN PVOID InformationBuffer,
IN ULONG InformationBufferLength,
OUT PULONG BytesRead,
OUT PULONG BytesNeeded);
#pragma NDIS_INIT_FUNCTION(DriverEntry)
NDIS_STATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath )
{
NDIS_STATUS Status;
NDIS_MINIPORT_CHARACTERISTICS MiniportChr;
NDIS_HANDLE NdisWrapperHandle;
#if DBG
UNICODE_STRING DeviceName;
int i;
#endif
DEBUGMSG(DBG_INIT, ("RASIR: DriverEntry\n"));
IrdaClientInitialize();
NdisAllocateSpinLock(&RasIrSpinLock);
InitializeListHead(&RasIrAdapterList);
NdisMInitializeWrapper(&NdisWrapperHandle, DriverObject,
RegistryPath, NULL );
NdisZeroMemory( &MiniportChr, sizeof(MiniportChr) );
MiniportChr.MajorNdisVersion = NDIS_MajorVersion;
MiniportChr.MinorNdisVersion = NDIS_MinorVersion;
MiniportChr.Reserved = NDIS_USE_WAN_WRAPPER;
MiniportChr.HaltHandler = RasIrHalt;
MiniportChr.InitializeHandler = RasIrInitialize;
MiniportChr.ResetHandler = RasIrReset;
MiniportChr.ReturnPacketHandler = RasIrReturnPacket;
MiniportChr.CoActivateVcHandler = RasIrCoActivateVc;
MiniportChr.CoDeactivateVcHandler = RasIrCoDeactivateVc;
MiniportChr.CoSendPacketsHandler = RasIrCoSendPackets;
MiniportChr.CoRequestHandler = RasIrCoRequest;
// no CheckForHangHandler
// no DisableInterruptHandler
// no EnableInterruptHandler
// no HandleInterruptHandler
// no ISRHandler
// no QueryInformationHandler (see CoRequestHandler)
// no SendHandler (see CoSendPacketsHandler)
// no WanSendHandler (see CoSendPacketsHandler)
// no SetInformationHandler (see CoRequestHandler)
// no TransferDataHandler
// no WanTransferDataHandler
// no SendPacketsHandler (see CoSendPacketsHandler)
// no AllocateCompleteHandler
Status = NdisMRegisterMiniport(NdisWrapperHandle, &MiniportChr, sizeof(MiniportChr));
if (Status != NDIS_STATUS_SUCCESS)
{
DEBUGMSG(DBG_ERROR, ("RASIR: ->NdisMRegisterMiniport failed %x\n", Status));
NdisTerminateWrapper(NdisWrapperHandle, NULL);
}
#if 0
DbgMsgInit();
RtlInitUnicodeString(&DeviceName, L"\\Device\\RASIR");
Status = IoCreateDevice(
DriverObject, // DriverObject
0, // DeviceExtensionSize
&DeviceName, // DeviceName
FILE_DEVICE_NETWORK, // DeviceType
0, // DeviceCharacteristics
FALSE, // Exclusive?
&pRasIrDeviceObject); // DeviceObject pointer returned
if (Status != STATUS_SUCCESS)
DbgPrint("Failed to create device\n");
else
{
DriverObject->DriverUnload = NULL;
DriverObject->FastIoDispatch = NULL;
for (i=0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++)
{
DriverObject->MajorFunction[i] = DbgDispatch;
}
pRasIrDeviceObject->Flags |= DO_DIRECT_IO;
}
#endif
return Status;
}
VOID
FreeAdapter(PRASIR_ADAPTER pAdapter)
{
ASSERT(IsListEmpty(&pAdapter->VcList));
#if DBG
pAdapter->Sig = 0xBAD;
#endif
NdisDeleteNPagedLookasideList(&pAdapter->WorkItemsLList);
NdisDeleteNPagedLookasideList(&pAdapter->AsyncBufLList);
NdisFreeMemory(pAdapter, sizeof(PRASIR_ADAPTER), 0);
}
NDIS_STATUS
RasIrInitialize(
OUT PNDIS_STATUS OpenErrorStatus,
OUT PUINT SelectedMediumIndex,
IN PNDIS_MEDIUM MediumArray,
IN UINT MediumArraySize,
IN NDIS_HANDLE MiniportAdapterHandle,
IN NDIS_HANDLE WrapperConfigurationContext)
{
UINT i;
PRASIR_ADAPTER pAdapter;
NDIS_CALL_MANAGER_CHARACTERISTICS CallMgrChr;
CO_ADDRESS_FAMILY Family;
NDIS_STATUS Status;
NDIS_HANDLE hConfig;
PNDIS_CONFIGURATION_PARAMETER Value;
NDIS_STRING TapiLineNameString = NDIS_STRING_CONST("TapiLineName");
NDIS_STRING ModemPortString = NDIS_STRING_CONST("ModemPort");
ULONG ModemPort;
DEBUGMSG(DBG_ERROR, ("RASIR: Miniport initialize\n"));
for (i = 0; i < MediumArraySize; ++i)
{
if (MediumArray[i] == NdisMediumCoWan)
break;
}
if (i == MediumArraySize)
{
DEBUGMSG(DBG_ERROR, ("RASIR: No matching media\n"));
return NDIS_STATUS_FAILURE;
}
*SelectedMediumIndex = i;
NdisAllocateMemoryWithTag((PVOID *)&pAdapter, sizeof(RASIR_ADAPTER),
MT_RASIR_ADAPTER);
if (pAdapter == NULL)
return NDIS_STATUS_RESOURCES;
NdisZeroMemory(pAdapter, sizeof(RASIR_ADAPTER));
InitializeListHead(&pAdapter->VcList);
InitializeListHead(&pAdapter->EndpList);
NdisInitializeNPagedLookasideList(
&pAdapter->WorkItemsLList,
NULL, NULL, 0,
sizeof(NDIS_WORK_ITEM),
MT_RASIR_WORKITEM, // RasIr work item
10);
NdisInitializeNPagedLookasideList(
&pAdapter->AsyncBufLList,
NULL, NULL, 0,
sizeof(ASYNC_BUFFER),
MT_RASIR_ASYNCBUF, // RasIr work item
0);
NdisAllocateSpinLock(&pAdapter->SpinLock);
NdisOpenConfiguration(&Status, &hConfig, WrapperConfigurationContext);
if (Status == NDIS_STATUS_SUCCESS)
{
pAdapter->TapiLineNameBuf[0] = 0;
pAdapter->TapiLineName.Buffer = pAdapter->TapiLineNameBuf;
pAdapter->TapiLineName.Length = 0;
pAdapter->TapiLineName.MaximumLength = sizeof(pAdapter->TapiLineNameBuf);
NdisReadConfiguration(&Status,
&Value,
hConfig,
&TapiLineNameString,
NdisParameterString);
if (Status == NDIS_STATUS_SUCCESS)
{
RtlCopyUnicodeString(&pAdapter->TapiLineName, &Value->ParameterData.StringData);
*(PWCHAR)(pAdapter->TapiLineName.Buffer + (pAdapter->TapiLineName.MaximumLength)/sizeof(WCHAR)) = UNICODE_NULL;
} else {
//
// could not get the line name
//
NdisCloseConfiguration(hConfig);
goto Done;
}
NdisReadConfiguration(&Status,
&Value,
hConfig,
&ModemPortString,
NdisParameterInteger);
if (Status == NDIS_STATUS_SUCCESS)
{
pAdapter->ModemPort = (BOOLEAN) Value->ParameterData.IntegerData;
}
NdisCloseConfiguration(hConfig);
} else {
//
// could open the config info
//
goto Done;
}
DEBUGMSG(DBG_CONFIG, ("RASIR: ModemPort = %d\n", pAdapter->ModemPort));
pAdapter->MiniportAdapterHandle = MiniportAdapterHandle;
pAdapter->Info.MaxFrameSize = IRDA_MAX_DATA_SIZE;
pAdapter->Info.MaxSendWindow = 4;
pAdapter->Info.FramingBits = PPP_FRAMING |
PPP_COMPRESS_ADDRESS_CONTROL |
PPP_COMPRESS_PROTOCOL_FIELD;
pAdapter->Info.DesiredACCM = 0;
#if DBG
pAdapter->Sig = (ULONG)ADAPTER_SIG;
#endif
// Inform NDIS of the attributes of our adapter. Set the
// 'MiniportAdapterContext' returned to us by NDIS when it calls our
// handlers to the address of our adapter control block. Turn off
// hardware oriented timeouts.
//
NdisMSetAttributesEx(
MiniportAdapterHandle,
(NDIS_HANDLE)pAdapter,
(UINT)-1,
NDIS_ATTRIBUTE_IGNORE_PACKET_TIMEOUT
| NDIS_ATTRIBUTE_IGNORE_REQUEST_TIMEOUT,
NdisInterfaceInternal);
NdisZeroMemory(&Family, sizeof(Family));
Family.MajorVersion = NDIS_MajorVersion;
Family.MinorVersion = NDIS_MinorVersion;
Family.AddressFamily = CO_ADDRESS_FAMILY_TAPI_PROXY;
NdisZeroMemory(&CallMgrChr, sizeof(CallMgrChr));
CallMgrChr.MajorVersion = NDIS_MajorVersion;
CallMgrChr.MinorVersion = NDIS_MinorVersion;
CallMgrChr.CmCreateVcHandler = RasIrCmCreateVc;
CallMgrChr.CmDeleteVcHandler = RasIrCmDeleteVc;
CallMgrChr.CmOpenAfHandler = RasIrCmOpenAf;
CallMgrChr.CmCloseAfHandler = RasIrCmCloseAf;
CallMgrChr.CmRegisterSapHandler = RasIrCmRegisterSap;
CallMgrChr.CmDeregisterSapHandler = RasIrCmDeregisterSap;
CallMgrChr.CmMakeCallHandler = RasIrCmMakeCall;
CallMgrChr.CmCloseCallHandler = RasIrCmCloseCall;
CallMgrChr.CmIncomingCallCompleteHandler= RasIrCmIncomingCallComplete;
CallMgrChr.CmActivateVcCompleteHandler = RasIrCmActivateVcComplete;
CallMgrChr.CmDeactivateVcCompleteHandler= RasIrCmDeactivateVcComplete;
CallMgrChr.CmModifyCallQoSHandler = RasIrCmModifyCallQoS;
CallMgrChr.CmRequestHandler = RasIrCmRequest;
// no CmAddPartyHandler
// no CmDropPartyHandler
Status = NdisMCmRegisterAddressFamily(
MiniportAdapterHandle, &Family, &CallMgrChr,
sizeof(CallMgrChr));
Done:
if (Status != NDIS_STATUS_SUCCESS)
{
FreeAdapter(pAdapter);
DEBUGMSG(DBG_ERROR, ("RASIR: NdisMCmRegisterFamily failed %X\n",
Status));
}
else
{
NdisInterlockedInsertTailList(&RasIrAdapterList,
&pAdapter->Linkage,
&RasIrSpinLock);
}
return Status;
}
VOID
RasIrHalt(
IN NDIS_HANDLE MiniportAdapterContext)
{
PRASIR_ADAPTER pAdapter = MiniportAdapterContext;
GOODADAPTER(pAdapter);
NdisAcquireSpinLock(&RasIrSpinLock);
RemoveEntryList(&pAdapter->Linkage);
NdisReleaseSpinLock(&RasIrSpinLock);
DEBUGMSG(DBG_ERROR, ("RASIR: Halt!\n"));
FreeAdapter(pAdapter);
return;
}
NDIS_STATUS
RasIrReset(
OUT PBOOLEAN AddressingReset,
IN NDIS_HANDLE MiniportAdapterContext)
{
return NDIS_STATUS_NOT_RESETTABLE;
}
NDIS_STATUS
RasIrCoActivateVc(
IN NDIS_HANDLE MiniportVcContext,
IN OUT PCO_CALL_PARAMETERS CallParameters)
{
return STATUS_SUCCESS;
}
NDIS_STATUS
RasIrCoDeactivateVc(
IN NDIS_HANDLE MiniportVcContext)
{
return STATUS_SUCCESS;
}
UINT
AddAsyncFraming(
IN PUCHAR pOutBuf,
IN PNDIS_BUFFER pNdisBuf,
IN ULONG Accm)
{
PUCHAR pData;
int DataLen;
USHORT Fcs = 0xFFFF;
PUCHAR pBuf = pOutBuf;
PUCHAR pEndBuf = pOutBuf + ASYNC_BUF_SIZE;
NdisQueryBufferSafe(pNdisBuf, &pData, &DataLen, NormalPagePriority);
if (pData == NULL)
{
return 0;
}
ASSERT(DataLen);
*pBuf++ = AF_FLAG_CHAR;
while (DataLen != 0)
{
int i;
for (i = 0; i < DataLen; i++)
{
Fcs = CALC_FCS(Fcs, pData[i]);
STUFF_BYTE(pBuf, pData[i], Accm);
}
NdisGetNextBuffer(pNdisBuf, &pNdisBuf);
if (pNdisBuf)
{
NdisQueryBufferSafe(pNdisBuf, &pData, &DataLen, NormalPagePriority);
if (pData == NULL)
{
return 0;
}
}
else
{
break;
}
if (pBuf > pEndBuf)
{
return 0;
}
}
Fcs = ~(Fcs);
STUFF_BYTE(pBuf, ((CHAR) (Fcs & 0xFF)), Accm);
STUFF_BYTE(pBuf, ((CHAR) (Fcs >> 8)), Accm);
*pBuf++ = AF_FLAG_CHAR;
return (UINT)((UINT_PTR)pBuf - (UINT_PTR) pOutBuf);
}
VOID
RasIrCoSendPackets(
IN NDIS_HANDLE MiniportVcContext,
IN PPNDIS_PACKET PacketArray,
IN UINT NumberOfPackets )
{
PRASIR_VC pVc = MiniportVcContext;
UINT i;
PNDIS_BUFFER pNdisBuf;
UINT PacketLen;
NTSTATUS Status = NDIS_STATUS_SUCCESS;
BOOLEAN VcDown = FALSE;
PASYNC_BUFFER pAsyncBuf;
PMDL pSendNdisBuf;
GOODVC(pVc);
for (i = 0; i < NumberOfPackets; i++)
{
Status = NDIS_STATUS_SUCCESS;
NdisQueryPacket(PacketArray[i], NULL, NULL, &pNdisBuf, &PacketLen);
ASSERT(PacketLen <= IRDA_MAX_DATA_SIZE);
*((PVOID *) &PacketArray[i]->MiniportReserved[0]) = NULL;
NdisAcquireSpinLock(&pVc->pAdapter->SpinLock);
REFADD(&pVc->RefCnt, 'DNES');
pVc->OutstandingSends += 1;
if (!(pVc->Flags & VCF_IRDA_OPEN))
{
DEBUGMSG(DBG_ERROR, ("RASIR: Not sending on Vc %X, Irda is closed\n", pVc));
Status = NDIS_STATUS_CLOSED;
}
NdisReleaseSpinLock(&pVc->pAdapter->SpinLock);
if (Status == NDIS_STATUS_SUCCESS)
{
if (!pVc->AsyncFraming)
{
pSendNdisBuf = pNdisBuf;
}
else
{
pAsyncBuf = NdisAllocateFromNPagedLookasideList(
&pVc->pAdapter->AsyncBufLList);
*((PVOID *) &PacketArray[i]->MiniportReserved[0]) = pAsyncBuf;
if (!pAsyncBuf)
{
Status = NDIS_STATUS_RESOURCES;
}
else
{
UINT FrameLen;
pAsyncBuf->pNdisBuf = NULL;
FrameLen = AddAsyncFraming(pAsyncBuf->Buf, pNdisBuf,
pVc->LinkInfo.SendACCM);
if (!FrameLen)
{
DEBUGMSG(DBG_ERROR, ("RASIR: not sending, AsyncFraming failed\n"));
IrdaSendComplete(pVc, PacketArray[i], Status);
continue;
}
NdisAllocateBuffer(&Status, &pAsyncBuf->pNdisBuf,
pVc->TxBufferPool, pAsyncBuf->Buf, FrameLen);
if (Status == NDIS_STATUS_SUCCESS)
{
pSendNdisBuf = pAsyncBuf->pNdisBuf;
}
else
{
DEBUGMSG(DBG_ERROR, ("RASIR: NdisAllocateBuffer failed %X\n", Status));
}
}
}
}
if (Status == NDIS_STATUS_SUCCESS)
{
IrdaSend(pVc->IrdaConnContext, pSendNdisBuf, PacketArray[i]);
}
else
{
IrdaSendComplete(pVc, PacketArray[i], Status);
continue;
}
DEBUGMSG(DBG_SEND, ("RASIR: IrdaSend %X len %d pending\n",
PacketArray[i], PacketLen));
}
}
VOID
RasIrReceiveComplete(
PRASIR_VC pVc,
PVOID pRxBuf)
{
if (pVc->AsyncFraming)
{
// Async frames where already completed in
// ProcessAsyncRxPacket() so just return the
// buffer owned by rasir to the BufList
NdisFreeToNPagedLookasideList(
&pVc->pAdapter->AsyncBufLList,
pRxBuf);
}
else
{
IrdaReceiveComplete(pVc->IrdaConnContext,
(PIRDA_RECVBUF) pRxBuf);
}
}
VOID
RasIrReturnPacket(
IN NDIS_HANDLE MiniportAdapterContext,
IN PNDIS_PACKET pNdisPacket)
{
PVOID pRxBuf;
PRASIR_VC pVc;
PNDIS_BUFFER pNdisBuf;
pVc = *((PRASIR_VC *) &pNdisPacket->MiniportReserved[0]);
pRxBuf = *((PVOID *) &pNdisPacket->MiniportReserved[sizeof(PUCHAR)]);
GOODVC(pVc);
DEBUGMSG(DBG_RECV, ("RASIR: ReturnPacket %X\n", pRxBuf));
RasIrReceiveComplete(pVc, pRxBuf);
NdisUnchainBufferAtFront(pNdisPacket, &pNdisBuf);
NdisFreeBuffer(pNdisBuf);
NdisFreePacket(pNdisPacket);
REFDEL(&pVc->RefCnt, 'VCER');
return;
}
NDIS_STATUS
RasIrCoRequest(
IN NDIS_HANDLE MiniportAdapterContext,
IN NDIS_HANDLE MiniportVcContext,
IN OUT PNDIS_REQUEST NdisRequest)
{
NDIS_STATUS Status;
PRASIR_ADAPTER pAdapter = MiniportAdapterContext;
PRASIR_VC pVc = MiniportVcContext;
DEBUGMSG(DBG_CONFIG, ("RASIR: RasIrCoRequest() type %X\n",
NdisRequest->RequestType));
switch (NdisRequest->RequestType)
{
case NdisRequestQueryInformation:
{
Status = QueryInformation(
pAdapter,
pVc,
NdisRequest->DATA.QUERY_INFORMATION.Oid,
NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer,
NdisRequest->DATA.QUERY_INFORMATION.InformationBufferLength,
&NdisRequest->DATA.QUERY_INFORMATION.BytesWritten,
&NdisRequest->DATA.QUERY_INFORMATION.BytesNeeded );
break;
}
case NdisRequestSetInformation:
{
Status = SetInformation(
pAdapter,
pVc,
NdisRequest->DATA.SET_INFORMATION.Oid,
NdisRequest->DATA.SET_INFORMATION.InformationBuffer,
NdisRequest->DATA.SET_INFORMATION.InformationBufferLength,
&NdisRequest->DATA.SET_INFORMATION.BytesRead,
&NdisRequest->DATA.SET_INFORMATION.BytesNeeded );
break;
}
default:
{
Status = NDIS_STATUS_NOT_SUPPORTED;
break;
}
}
return Status;
}
NDIS_STATUS
QueryInformation(
IN PRASIR_ADAPTER pAdapter,
IN PRASIR_VC pVc,
IN NDIS_OID Oid,
IN PVOID InformationBuffer,
IN ULONG InformationBufferLength,
OUT PULONG BytesWritten,
OUT PULONG BytesNeeded)
{
NDIS_STATUS status;
ULONG ulInfo;
VOID* pInfo;
ULONG ulInfoLen;
status = NDIS_STATUS_SUCCESS;
// The cases in this switch statement find or create a buffer containing
// the requested information and point 'pInfo' at it, noting it's length
// in 'ulInfoLen'. Since many of the OIDs return a ULONG, a 'ulInfo'
// buffer is set up as the default.
//
ulInfo = 0;
pInfo = &ulInfo;
ulInfoLen = sizeof(ulInfo);
DEBUGMSG(DBG_CONFIG, ("RASIR: QueryInformation oid:%X\n", Oid));
switch (Oid)
{
case OID_GEN_MAXIMUM_LOOKAHEAD:
{
DEBUGMSG(DBG_CONFIG, (" OID_GET_MAXIMUM_LOOKAHEAD = %d\n",
IRDA_MAX_DATA_SIZE));
ulInfo = IRDA_MAX_DATA_SIZE;
break;
}
case OID_GEN_MAC_OPTIONS:
{
// Report a bitmask defining optional properties of the driver.
//
// NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA promises that our receive
// buffer is not on a device-specific card.
//
// NDIS_MAC_OPTION_TRANSFERS_NOT_PEND promises we won't return
// NDIS_STATUS_PENDING from our TransferData handler which is true
// since we don't have one.
//
ulInfo = NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA
| NDIS_MAC_OPTION_TRANSFERS_NOT_PEND;
DEBUGMSG(DBG_CONFIG, (" OID_GEN_MAC_OPTIONS = %d\n",ulInfo));
break;
}
case OID_WAN_MEDIUM_SUBTYPE:
{
// Report the media subtype we support. NDISWAN may use this in
// the future (doesn't now) to provide framing differences for
// different media.
//
DEBUGMSG(DBG_CONFIG, (" OID_WAN_MEDIUM_SUBTYPE\n"));
if (pAdapter->ModemPort)
{
ulInfo = NdisWanMediumSerial;
}
else
{
ulInfo = NdisWanMediumIrda;
}
break;
}
case OID_WAN_CO_GET_INFO:
{
// Report the capabilities of the adapter.
//
DEBUGMSG(DBG_CONFIG, (" OID_WAN_CO_GET_INFO\n"));
pInfo = &pAdapter->Info;
ulInfoLen = sizeof(NDIS_WAN_CO_INFO);
break;
}
case OID_WAN_CO_GET_LINK_INFO:
{
// Report the current state of the link.
//
DEBUGMSG(DBG_CONFIG, (" OID_WAN_CO_GET_LINK_INFO\n"));
if (!pVc)
return NDIS_STATUS_INVALID_DATA;
pInfo = &pVc->LinkInfo;
ulInfoLen = sizeof(NDIS_WAN_CO_GET_LINK_INFO);
break;
}
case OID_WAN_CO_GET_COMP_INFO:
{
// Report the type of compression we provide, which is none.
//
DEBUGMSG(DBG_CONFIG, (" OID_WAN_CO_GET_COMP_INFO\n"));
status = NDIS_STATUS_NOT_SUPPORTED;
ulInfoLen = 0;
break;
}
case OID_WAN_CO_GET_STATS_INFO:
{
// Because L2TP doesn't do compression, NDISWAN will use it's own
// statistics and not query ours.
//
ASSERT( !"OID_WAN_CO_GET_STATS_INFO?" );
status = NDIS_STATUS_NOT_SUPPORTED;
ulInfoLen = 0;
break;
}
case OID_PNP_QUERY_POWER:
DEBUGMSG(DBG_CONFIG, (" OID_PNP_QUERY_POWER\n"));
status = NDIS_STATUS_NOT_SUPPORTED;
ulInfoLen = 0;
break;
case OID_PNP_CAPABILITIES:
DEBUGMSG(DBG_CONFIG, (" OID_PNP_CAP\n"));
status = NDIS_STATUS_NOT_SUPPORTED;
ulInfoLen = 0;
break;
case OID_PNP_SET_POWER:
DEBUGMSG(DBG_CONFIG, (" OID_PNP_SET_POWER\n"));
status = NDIS_STATUS_NOT_SUPPORTED;
ulInfoLen = 0;
break;
default:
{
DEBUGMSG(DBG_CONFIG, ( " Oid $%08x?\n", Oid));
status = NDIS_STATUS_INVALID_OID;
ulInfoLen = 0;
break;
}
}
if (ulInfoLen > InformationBufferLength)
{
// Caller's buffer is too small. Tell him what he needs.
//
*BytesNeeded = ulInfoLen;
status = NDIS_STATUS_INVALID_LENGTH;
}
else
{
// Copy the found result to caller's buffer.
//
if (ulInfoLen > 0)
{
NdisMoveMemory( InformationBuffer, pInfo, ulInfoLen );
}
*BytesNeeded = *BytesWritten = ulInfoLen;
}
return status;
}
NDIS_STATUS
SetInformation(
IN PRASIR_ADAPTER pAdapter,
IN PRASIR_VC pVc,
IN NDIS_OID Oid,
IN PVOID InformationBuffer,
IN ULONG InformationBufferLength,
OUT PULONG BytesRead,
OUT PULONG BytesNeeded)
{
NDIS_STATUS Status;
DEBUGMSG(DBG_CONFIG, ("RASIR: SetInformation oid:%X\n", Oid));
Status = NDIS_STATUS_SUCCESS;
switch (Oid)
{
case OID_WAN_CO_SET_LINK_INFO:
{
// Read new link state settings.
//
DEBUGMSG(DBG_CONFIG, (" OID_WAN_CO_SET_LINK_INFO\n"));
if (InformationBufferLength < sizeof(NDIS_WAN_CO_SET_LINK_INFO))
{
Status = NDIS_STATUS_INVALID_LENGTH;
*BytesRead = 0;
}
else
{
if (!pVc)
return NDIS_STATUS_INVALID_DATA;
ASSERT( sizeof(pVc->LinkInfo)
== sizeof(NDIS_WAN_CO_SET_LINK_INFO) );
NdisMoveMemory(&pVc->LinkInfo, InformationBuffer,
sizeof(pVc->LinkInfo) );
DEBUGMSG(DBG_CONFIG, (" MaxSend %d MaxRecv %d SendAccm %X RecvAccm %X\n",
pVc->LinkInfo.MaxSendFrameSize,
pVc->LinkInfo.MaxRecvFrameSize,
pVc->LinkInfo.SendACCM,
pVc->LinkInfo.RecvACCM));
*BytesRead = sizeof(NDIS_WAN_CO_SET_LINK_INFO);
}
*BytesNeeded = sizeof(NDIS_WAN_CO_SET_LINK_INFO);
}
break;
case OID_WAN_CO_SET_COMP_INFO:
{
// L2TP doesn't provide compression. Neither does IrDA
//
DEBUGMSG(DBG_CONFIG, (" OID_WAN_CO_SET_COMP_INFO\n"));
Status = NDIS_STATUS_NOT_SUPPORTED;
*BytesRead = *BytesNeeded = 0;
break;
}
case OID_PNP_QUERY_POWER:
DEBUGMSG(DBG_CONFIG, (" OID_PNP_QUERY_POWER\n"));
Status = NDIS_STATUS_NOT_SUPPORTED;
*BytesRead = *BytesNeeded = 0;
break;
case OID_PNP_CAPABILITIES:
DEBUGMSG(DBG_CONFIG, (" OID_PNP_CAP\n"));
Status = NDIS_STATUS_NOT_SUPPORTED;
*BytesRead = *BytesNeeded = 0;
break;
case OID_PNP_SET_POWER:
DEBUGMSG(DBG_CONFIG, (" OID_PNP_SET_POWER\n"));
Status = NDIS_STATUS_NOT_SUPPORTED;
*BytesRead = *BytesNeeded = 0;
break;
#if 0
// These OIDs are mandatory according to current doc, but since
// NDISWAN never requests them they are omitted.
//
case OID_GEN_CURRENT_PACKET_FILTER:
case OID_GEN_CURRENT_LOOKAHEAD:
case OID_GEN_PROTOCOL_OPTIONS:
case OID_WAN_PROTOCOL_TYPE:
case OID_WAN_HEADER_FORMAT:
#endif
default:
{
DEBUGMSG(DBG_CONFIG, ("Oid $%08x?\n", Oid ));
Status = NDIS_STATUS_INVALID_OID;
*BytesRead = *BytesNeeded = 0;
break;
}
}
return Status;
}
VOID
ProcessAsyncRxPacket(
PRASIR_VC pVc,
PIRDA_RECVBUF pIrdaRxBuf)
{
PASYNC_BUFFER pReturnRxBuf = NULL;
BOOLEAN EndOfFrame = FALSE;
PASYNC_BUFFER pCurrAsyncBuf;
UINT i;
CHAR Byte;
//DbgMsgBuf(pIrdaRxBuf->Buf, pIrdaRxBuf->BufLen);
for (i = 0; i < pIrdaRxBuf->BufLen; i++)
{
//
// If we are not currently reasembling a frame
// in pCurrAsyncBuf then get a new one
//
if (pVc->pCurrAsyncBuf == NULL)
{
pVc->AsyncFramingState = RX_READY;
if (!(pCurrAsyncBuf = NdisAllocateFromNPagedLookasideList(
&pVc->pAdapter->AsyncBufLList)))
{
DEBUGMSG(DBG_ERROR, ("RASIR: Failed to allocate AsyncBuf\n"));
return;
}
pCurrAsyncBuf->BufLen = 0;
pVc->pCurrAsyncBuf = pCurrAsyncBuf;
}
else
{
pCurrAsyncBuf = pVc->pCurrAsyncBuf;
}
Byte = pIrdaRxBuf->Buf[i];
switch (pVc->AsyncFramingState)
{
case RX_READY:
if (Byte == AF_FLAG_CHAR)
{
pVc->AsyncFramingState = RX_RX;
}
break;
case RX_RX:
switch (Byte)
{
case AF_FLAG_CHAR:
// We have a complete frame, put it on the completed
// list
pVc->AsyncFramingState = RX_READY;
if (pCurrAsyncBuf->BufLen > 2)
{
// remove FCS, IrDA is reliable so I don't look at it
pCurrAsyncBuf->BufLen -= 2;
NdisInterlockedInsertTailList(
&pVc->CompletedAsyncBufList,
&pCurrAsyncBuf->Linkage,
&pVc->pAdapter->SpinLock);
DEBUGMSG(DBG_RECV, ("RASIR: Complete async frame %d, %d of %d\n",
pVc->pCurrAsyncBuf->BufLen, i, pIrdaRxBuf->BufLen));
pVc->pCurrAsyncBuf = NULL;
}
else
{
// frame too small, we'll just ignore it
pCurrAsyncBuf->BufLen = 0;
DEBUGMSG(DBG_ERROR, ("RASIR: Async failure 1\n"));
}
break;
case AF_ESC_CHAR:
pVc->AsyncFramingState = RX_ESC;
break;
default:
if (pCurrAsyncBuf->BufLen >= ASYNC_BUF_SIZE)
{
pCurrAsyncBuf->BufLen = 0;
pVc->AsyncFramingState = RX_READY;
DEBUGMSG(DBG_ERROR, ("RASIR: Async buffer overflow\n"));
}
else
{
pCurrAsyncBuf->Buf[pCurrAsyncBuf->BufLen] = Byte;
pCurrAsyncBuf->BufLen += 1;
}
}
break;
case RX_ESC:
if (pCurrAsyncBuf->BufLen >= ASYNC_BUF_SIZE)
{
pCurrAsyncBuf->BufLen = 0;
pVc->AsyncFramingState = RX_READY;
DEBUGMSG(DBG_ERROR, ("RASIR: Async failure 2\n"));
}
else
{
pCurrAsyncBuf->Buf[pCurrAsyncBuf->BufLen] = (Byte ^= AF_COMP_BIT);
pCurrAsyncBuf->BufLen += 1;
pVc->AsyncFramingState = RX_RX;
break;
}
}
}
}
VOID
IndicateReceive(
PRASIR_VC pVc,
PIRDA_RECVBUF pRecvBuf,
PASYNC_BUFFER pAsyncBuf,
BOOLEAN LastBuf)
{
PNDIS_PACKET pNdisPacket;
PNDIS_BUFFER pNdisBuf;
NDIS_STATUS Status;
KIRQL OldIrql;
PVOID pRecvOrAsyncBuf = NULL;
int Len;
REFADD(&pVc->RefCnt, 'VCER');
if (pVc->AsyncFraming)
{
ASSERT(pAsyncBuf && !pRecvBuf);
pRecvOrAsyncBuf = pAsyncBuf;
Len = pAsyncBuf->BufLen;
}
else
{
ASSERT(pRecvBuf && !pAsyncBuf);
pRecvOrAsyncBuf = pRecvBuf;
Len = pRecvBuf->BufLen;
}
if (!(pVc->Flags & VCF_OPEN))
{
DEBUGMSG(DBG_ERROR, ("RASIR: VC not open yet, dropping packet\n"));
goto error1;
}
NdisAllocatePacket(&Status, &pNdisPacket, pVc->RxPacketPool);
if (Status != NDIS_STATUS_SUCCESS)
{
DEBUGMSG(DBG_ERROR, ("RASIR: NdisAllocatePacket failed, %X\n",
Status));
goto error1;
}
if (pVc->AsyncFraming)
{
NdisAllocateBuffer(&Status, &pNdisBuf, pVc->RxBufferPool,
pAsyncBuf->Buf, pAsyncBuf->BufLen);
}
else
{
NdisAllocateBuffer(&Status, &pNdisBuf, pVc->RxBufferPool,
pRecvBuf->Buf, pRecvBuf->BufLen);
}
if (Status != NDIS_STATUS_SUCCESS)
{
DEBUGMSG(DBG_ERROR, ("RASIR: NdisAllocateBuffer failed, %X\n",
Status));
goto error2;
}
NdisChainBufferAtFront(pNdisPacket, pNdisBuf);
*((PRASIR_VC *) &pNdisPacket->MiniportReserved[0]) = pVc;
*((PVOID *) &pNdisPacket->MiniportReserved[sizeof(PUCHAR)]) = pRecvOrAsyncBuf;
KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
if (LastBuf)
{
NDIS_SET_PACKET_STATUS(pNdisPacket, NDIS_STATUS_RESOURCES);
DEBUGMSG(DBG_RECV, ("RASIR: Irtdi out of buffers\n"));
}
else
{
NDIS_SET_PACKET_STATUS(pNdisPacket, NDIS_STATUS_SUCCESS);
}
Status = NDIS_GET_PACKET_STATUS(pNdisPacket);
DEBUGMSG(DBG_RECV, ("RASIR: ->NdisMCoIndicateReceive %d\n", Len));
NdisMCoIndicateReceivePacket(pVc->NdisVcHandle, &pNdisPacket, 1);
NdisMCoReceiveComplete(pVc->pAdapter->MiniportAdapterHandle);
KeLowerIrql(OldIrql);
if (Status == NDIS_STATUS_SUCCESS) {
//
// the packets will be returned later
//
return;
}
NdisUnchainBufferAtFront(pNdisPacket, &pNdisBuf);
NdisFreeBuffer(pNdisBuf);
error2:
NdisFreePacket(pNdisPacket);
error1:
DEBUGMSG(DBG_RECV, ("RASIR: RecvIndication completed synchronously for %X\n",
pRecvOrAsyncBuf));
RasIrReceiveComplete(pVc, pRecvOrAsyncBuf);
REFDEL(&pVc->RefCnt, 'VCER');
}
VOID
IrdaReceiveIndication(
PVOID ConnectionContext,
PIRDA_RECVBUF pRecvBuf,
BOOLEAN LastBuf)
{
PRASIR_VC pVc = ConnectionContext;
PASYNC_BUFFER pAsyncRxBuf;
DEBUGMSG(DBG_RECV, ("RASIR: IrdaReceiveIndication %X, %d bytes\n",
pRecvBuf, pRecvBuf->BufLen));
if (!pVc)
{
DEBUGMSG(DBG_ERROR, ("RASIR: IrdaReceiveIndication NULL vc\n"));
ASSERT(0);
return;
}
GOODVC(pVc);
GOODADAPTER(pVc->pAdapter);
if (pVc->IrModemCall && pVc->ModemState < MS_ONLINE)
{
ProcessOfflineRxBuf(pVc, pRecvBuf);
IrdaReceiveComplete(pVc->IrdaConnContext, pRecvBuf);
return;
}
if (pVc->AsyncFraming)
{
ProcessAsyncRxPacket(pVc, pRecvBuf);
// We are done with pRecvBuf. The async framing has
// been removed and the data is now contained in a buffer
// on the CompletedAsyncBufList or if not a full frame
// then in pCurrAsyncBuf
IrdaReceiveComplete(pVc->IrdaConnContext, pRecvBuf);
while ((pAsyncRxBuf = (PASYNC_BUFFER) NdisInterlockedRemoveHeadList(
&pVc->CompletedAsyncBufList,
&pVc->pAdapter->SpinLock)) != NULL)
{
IndicateReceive(pVc, NULL, pAsyncRxBuf, LastBuf);
}
}
else
{
IndicateReceive(pVc, pRecvBuf, NULL, LastBuf);
}
return;
}
VOID
IrdaSendComplete(
PVOID ConnectContext,
PVOID SendContext,
NTSTATUS Status)
{
PRASIR_VC pVc = ConnectContext;
PNDIS_PACKET pNdisPacket = (PNDIS_PACKET) SendContext;
DEBUGMSG(DBG_SEND, ("RASIR: IrdaSendComplete vc:%X, Packet %X\n", pVc, SendContext));
GOODVC(pVc);
if (SendContext == RASIR_INTERNAL_SEND)
{
ASSERT(pVc->pOfflineNdisBuf);
NdisFreeBuffer(pVc->pOfflineNdisBuf);
pVc->pOfflineNdisBuf = NULL;
goto EXIT;
}
if (pVc->AsyncFraming)
{
PASYNC_BUFFER pAsyncBuf;
pAsyncBuf = *((PASYNC_BUFFER *) &pNdisPacket->MiniportReserved[0]);
if (pAsyncBuf)
{
if (pAsyncBuf->pNdisBuf)
{
NdisFreeBuffer(pAsyncBuf->pNdisBuf);
}
NdisFreeToNPagedLookasideList(&pVc->pAdapter->AsyncBufLList,
pAsyncBuf);
}
}
NdisMCoSendComplete(Status, pVc->NdisVcHandle, pNdisPacket);
NdisAcquireSpinLock(&pVc->pAdapter->SpinLock);
pVc->OutstandingSends -= 1; // do interlockedDec dork
NdisReleaseSpinLock(&pVc->pAdapter->SpinLock);
if ((pVc->Flags & VCF_CLOSE_PEND) && (pVc->OutstandingSends == 0))
{
DEBUGMSG(DBG_CONNECT, ("RASIR: Outstanding send to 0, CompleteClose\n"));
CompleteClose(pVc);
}
EXIT:
REFDEL(&pVc->RefCnt, 'DNES');
}
NDIS_STATUS
ScheduleWork(
IN PRASIR_ADAPTER pAdapter,
IN NDIS_PROC pProc,
IN PVOID pContext )
// Schedules a PASSIVE IRQL callback to routine 'pProc' which will be
// passed 'pContext'. 'PAdapter' is the adapter control block from which
// the work item is allocated.
//
// Returns NDIS_STATUS_SUCCESS or an error code.
//
{
NDIS_STATUS status;
NDIS_WORK_ITEM* pWork;
pWork = NdisAllocateFromNPagedLookasideList(&pAdapter->WorkItemsLList);
if (!pWork)
{
ASSERT( !"Alloc work?" );
return NDIS_STATUS_RESOURCES;
}
NdisInitializeWorkItem( pWork, pProc, pContext );
status = NdisScheduleWorkItem( pWork );
if (status != NDIS_STATUS_SUCCESS)
{
ASSERT( !"SchedWork?" );
NdisFreeToNPagedLookasideList(&pAdapter->WorkItemsLList, pWork);
}
return status;
}
#if DBG
NTSTATUS
DbgDispatch(
PDEVICE_OBJECT pDeviceObject,
PIRP pIrp)
{
PIO_STACK_LOCATION pIrpSp;
pIrpSp = IoGetCurrentIrpStackLocation(pIrp);
if (pIrpSp->MajorFunction != IRP_MJ_DEVICE_CONTROL)
{
pIrp->IoStatus.Status = STATUS_SUCCESS;
pIrp->IoStatus.Information = 0;
IoCompleteRequest(pIrp, IO_NETWORK_INCREMENT);
return STATUS_SUCCESS;
}
ASSERT(pIrpSp->MajorFunction != IRP_MJ_INTERNAL_DEVICE_CONTROL);
switch(pIrpSp->Parameters.DeviceIoControl.IoControlCode)
{
case IOCTL_IRDA_GET_DBG_MSGS:
{
NTSTATUS Status;
if ((Status = DbgMsgIrp(pIrp, pIrpSp)) == STATUS_PENDING)
{
return STATUS_PENDING;
}
break;
}
case IOCTL_IRDA_GET_DBG_SETTINGS:
{
UINT *Settings = pIrp->AssociatedIrp.SystemBuffer;
Settings[0] = DbgSettings;
Settings[1] = DbgOutput;
pIrp->IoStatus.Information = sizeof(UINT)*2;
pIrp->IoStatus.Status = STATUS_SUCCESS;
break;
}
case IOCTL_IRDA_SET_DBG_SETTINGS:
{
UINT *Settings = pIrp->AssociatedIrp.SystemBuffer;
DbgSettings = Settings[0];
DbgOutput = Settings[1];
pIrp->IoStatus.Information = 0;
pIrp->IoStatus.Status = STATUS_SUCCESS;
break;
}
default:
pIrp->IoStatus.Information = 0;
pIrp->IoStatus.Status = STATUS_SUCCESS;
}
IoCompleteRequest(pIrp, IO_NETWORK_INCREMENT);
return STATUS_SUCCESS;
}
#endif
Copy Permalink