espressif/openthread
1
0
Fork 0
mirror of https://github.com/espressif/openthread.git synced 2026-10-02 13:57:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add Windows Tunnel Mode Miniport Driver (ottmp) (#993)

Browse Source 
* Add Windows Tunnel Mode Miniport Driver (ottmp)
This commit is contained in:
Nick Banks
2016-12-07 14:57:32 -08:00
committed by Jonathan Hui
parent 8b07e4a67d
commit 1d999ccea3
22 changed files with 4510 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files
examples/drivers/windows/ottmp/device.cpp
+383
View File
@@ -0,0 +1,383 @@
/*
* Copyright (c) 2016, The OpenThread Authors.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holder nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* @file
* This module implements code to manage the WDFDEVICE object for the
* network adapter.
*/
#include <initguid.h>
#include "pch.hpp"
#include "device.tmh"
PAGED
_IRQL_requires_( PASSIVE_LEVEL )
_Function_class_( MINIPORT_INITIALIZE )
NDIS_STATUS
MPInitializeEx(
_In_ NDIS_HANDLE MiniportAdapterHandle,
_In_ NDIS_HANDLE MiniportDriverContext,
_In_ PNDIS_MINIPORT_INIT_PARAMETERS /* MiniportInitParameters */
)
/*++
Routine Description:
The MiniportInitialize function is a required function that sets up a
NIC (or virtual NIC) for network I/O operations, claims all hardware
resources necessary to the NIC in the registry, and allocates resources
the driver needs to carry out network I/O operations.
MiniportInitialize runs at IRQL = PASSIVE_LEVEL.
Arguments:
Return Value:
NDIS_STATUS_xxx code
--*/
{
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
PGLOBALS pGlobals = (PGLOBALS)MiniportDriverContext;
PDEVICE_OBJECT pPdo = nullptr;
PDEVICE_OBJECT pFdo = nullptr;
PDEVICE_OBJECT pNextDeviceObject = nullptr;
WDF_OBJECT_ATTRIBUTES attributes;
WDFDEVICE device = nullptr;
POTTMP_DEVICE_CONTEXT deviceContext = nullptr;
LogFuncEntry(DRIVER_DEFAULT);
PAGED_CODE();
do
{
NDIS_MINIPORT_ADAPTER_REGISTRATION_ATTRIBUTES AdapterRegistration = { 0 };
NDIS_MINIPORT_ADAPTER_GENERAL_ATTRIBUTES AdapterGeneral = { 0 };
NDIS_PM_CAPABILITIES PmCapabilities = { 0 };
//
// NdisMGetDeviceProperty function enables us to get the:
// PDO - created by the bus driver to represent our device.
// FDO - created by NDIS to represent our miniport as a function
// driver.
// NextDeviceObject - deviceobject of another driver (filter)
// attached to us at the bottom.
// Since our driver is talking to NDISPROT, the NextDeviceObject
// is not useful. But if we were to talk to a driver that we
// are attached to as part of the devicestack then NextDeviceObject
// would be our target DeviceObject for sending read/write Requests.
//
NdisMGetDeviceProperty(
MiniportAdapterHandle,
&pPdo,
&pFdo,
&pNextDeviceObject,
nullptr,
nullptr);
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, OTTMP_DEVICE_CONTEXT);
NTSTATUS ntStatus = WdfDeviceMiniportCreate(
pGlobals->WdfDriver,
&attributes,
pFdo,
pNextDeviceObject,
pPdo,
&device);
if (!NT_SUCCESS(ntStatus))
{
LogError(DRIVER_DEFAULT, "WdfDeviceMiniportCreate failed %!STATUS!", ntStatus);
Status = NDIS_STATUS_FAILURE;
break;
}
//
// Get WDF miniport device context.
//
deviceContext = GetDeviceContext(device);
deviceContext->Signature = OTTMP_DEVICE_CONTEXT_SIGNATURE;
deviceContext->Device = device;
//
// Allocate adapter context structure and initialize all the
// memory resources for sending and receiving packets.
//
deviceContext->AdapterContext = (POTTMP_ADAPTER_CONTEXT)NdisAllocateMemoryWithTagPriority(
pGlobals->hDriver,
sizeof(OTTMP_ADAPTER_CONTEXT),
OTTMP_ADAPTER_CONTEXT_SIGNATURE,
NormalPoolPriority);
if (deviceContext->AdapterContext == nullptr)
{
LogError(DRIVER_DEFAULT, "NdisAllocateMemoryWithTagPriority failed");
Status = NDIS_STATUS_RESOURCES;
break;
}
RtlZeroMemory(deviceContext->AdapterContext, sizeof(OTTMP_ADAPTER_CONTEXT));
deviceContext->AdapterContext->Signature = OTTMP_ADAPTER_CONTEXT_SIGNATURE;
deviceContext->AdapterContext->Adapter = MiniportAdapterHandle;
deviceContext->AdapterContext->Device = deviceContext->Device;
deviceContext->AdapterContext->pGlobals = pGlobals;
Status = AdapterInitialize(
MiniportAdapterHandle,
deviceContext->AdapterContext);
if (NDIS_STATUS_SUCCESS != Status)
{
LogError(DRIVER_DEFAULT, "AdapterInitialize failed %!NDIS_STATUS!", Status);
break;
}
ntStatus = SerialInitialize(deviceContext->AdapterContext);
if (!NT_SUCCESS(ntStatus))
{
Status = NDIS_STATUS_FAILURE;
break;
}
// Start the read loop
LogVerbose(DRIVER_DEFAULT, "Starting recv worker");
WdfWorkItemEnqueue(deviceContext->AdapterContext->RecvWorkItem);
} while (FALSE);
if (Status != NDIS_STATUS_SUCCESS)
{
if (deviceContext && deviceContext->AdapterContext)
{
AdapterUninitialize(deviceContext->AdapterContext);
deviceContext->AdapterContext = nullptr;
}
}
LogFuncExitNDIS(DRIVER_DEFAULT, Status);
return Status;
}
PAGED
VOID
MPHaltEx(
_In_ NDIS_HANDLE MiniportAdapterContext,
_In_ NDIS_HALT_ACTION HaltAction
)
/*++
Routine Description:
Halt handler is called when NDIS receives IRP_MN_STOP_DEVICE,
IRP_MN_SUPRISE_REMOVE or IRP_MN_REMOVE_DEVICE requests from the PNP
manager. Here, the driver should free all the resources acquired in
MiniportInitialize and stop access to the hardware. NDIS will not submit
any further request once this handler is invoked.
1) Free and unmap all I/O resources.
2) Disable interrupt and deregister interrupt handler.
3) Deregister shutdown handler regsitered by
NdisMRegisterAdapterShutdownHandler .
4) Cancel all queued up timer callbacks.
5) Finally wait indefinitely for all the outstanding receive
packets indicated to the protocol to return.
MiniportHalt runs at IRQL = PASSIVE_LEVEL.
Arguments:
MiniportAdapterContext Pointer to the Adapter
HaltAction The reason for halting the adapter
Return Value:
None.
--*/
{
POTTMP_ADAPTER_CONTEXT AdapterContext = (POTTMP_ADAPTER_CONTEXT)MiniportAdapterContext;
LogFuncEntry(DRIVER_DEFAULT);
PAGED_CODE();
//
// Call Shutdown handler to disable interrupt and turn the hardware off
// by issuing a full reset
//
if (HaltAction != NdisHaltDeviceSurpriseRemoved)
{
MPShutdownEx(MiniportAdapterContext, NdisShutdownPowerOff);
}
AdapterUninitialize(AdapterContext);
LogFuncExit(DRIVER_DEFAULT);
}
VOID
MPShutdownEx(
_In_ NDIS_HANDLE /* MiniportAdapterContext */,
_In_ NDIS_SHUTDOWN_ACTION /* ShutdownAction */
)
/*++
Routine Description:
The MiniportShutdownEx handler restores hardware to its initial state when
the system is shut down, whether by the user or because an unrecoverable
system error occurred. This is to ensure that the NIC is in a known
state and ready to be reinitialized when the machine is rebooted after
a system shutdown occurs for any reason, including a crash dump.
Here just disable the interrupt and stop the DMA engine. Do not free
memory resources or wait for any packet transfers to complete. Do not call
into NDIS at this time.
This can be called at aribitrary IRQL, including in the context of a
bugcheck.
Arguments:
MiniportAdapterContext Pointer to our adapter
ShutdownAction The reason why NDIS called the shutdown function
Return Value:
None.
--*/
{
LogFuncEntry(DRIVER_DEFAULT);
LogFuncExit(DRIVER_DEFAULT);
}
PAGED
VOID
MPDevicePnpEventNotify(
_In_ NDIS_HANDLE /* MiniportAdapterContext */,
_In_ PNET_DEVICE_PNP_EVENT NetDevicePnPEvent
)
/*++
Routine Description:
Runs at IRQL = PASSIVE_LEVEL in the context of system thread.
Arguments:
MiniportAdapterContext Pointer to our adapter
NetDevicePnPEvent Self-explanatory
Return Value:
None.
--*/
{
LogFuncEntry(DRIVER_DEFAULT);
PAGED_CODE();
switch (NetDevicePnPEvent->DevicePnPEvent)
{
case NdisDevicePnPEventQueryRemoved:
//
// Called when NDIS receives IRP_MN_QUERY_REMOVE_DEVICE.
//
LogInfo(DRIVER_DEFAULT, "MPPnPEventNotify: NdisDevicePnPEventQueryRemoved");
break;
case NdisDevicePnPEventRemoved:
//
// Called when NDIS receives IRP_MN_REMOVE_DEVICE.
// NDIS calls MiniportHalt function after this call returns.
//
LogInfo(DRIVER_DEFAULT, "MPPnPEventNotify: NdisDevicePnPEventRemoved");
break;
case NdisDevicePnPEventSurpriseRemoved:
//
// Called when NDIS receives IRP_MN_SUPRISE_REMOVAL.
// NDIS calls MiniportHalt function after this call returns.
//
LogInfo(DRIVER_DEFAULT, "MPDevicePnpEventNotify: NdisDevicePnPEventSurpriseRemoved");
break;
case NdisDevicePnPEventQueryStopped:
//
// Called when NDIS receives IRP_MN_QUERY_STOP_DEVICE. ??
//
LogInfo(DRIVER_DEFAULT, "MPPnPEventNotify: NdisDevicePnPEventQueryStopped");
break;
case NdisDevicePnPEventStopped:
//
// Called when NDIS receives IRP_MN_STOP_DEVICE.
// NDIS calls MiniportHalt function after this call returns.
//
//
LogInfo(DRIVER_DEFAULT, "MPPnPEventNotify: NdisDevicePnPEventStopped");
break;
case NdisDevicePnPEventPowerProfileChanged:
//
// After initializing a miniport driver and after miniport driver
// receives an OID_PNP_SET_POWER notification that specifies
// a device power state of NdisDeviceStateD0 (the powered-on state),
// NDIS calls the miniport's MiniportPnPEventNotify function with
// PnPEvent set to NdisDevicePnPEventPowerProfileChanged.
//
LogInfo(DRIVER_DEFAULT, "MPDevicePnpEventNotify: NdisDevicePnPEventPowerProfileChanged");
if (NetDevicePnPEvent->InformationBufferLength == sizeof( ULONG ))
{
const ULONG NdisPowerProfile = *((const ULONG *)NetDevicePnPEvent->InformationBuffer);
if (NdisPowerProfile == NdisPowerProfileBattery)
{
LogInfo(DRIVER_DEFAULT, "The host system is running on battery power");
}
else if (NdisPowerProfile == NdisPowerProfileAcOnLine)
{
LogInfo(DRIVER_DEFAULT, "The host system is running on AC power");
}
}
break;
default:
LogError(DRIVER_DEFAULT, "MPDevicePnpEventNotify: unknown PnP event 0x%x\n", NetDevicePnPEvent->DevicePnPEvent);
}
LogFuncExit(DRIVER_DEFAULT);
}