| /* |
| * 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); |
| } |
